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 / artsmodulescommon.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-24  |  76.8 KB  |  2,053 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSMODULESCOMMON_H
  4. #define ARTSMODULESCOMMON_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsgui.h"
  12. #include "artsflow.h"
  13. #include "artsmidi.h"
  14. #include "artsmodulessynth.h"
  15.  
  16. namespace Arts {
  17. namespace Environment {
  18. class Context;
  19. class Container;
  20. class Item;
  21. class InstrumentItem;
  22. class InstrumentItemGuiFactory;
  23. class StereoEffectItem;
  24. class MixerChannel;
  25. class MixerItem;
  26. class EffectRackItem;
  27. }
  28. class MixerItemGui;
  29. class EffectRackItemGui;
  30. class EffectRackSlot;
  31. class MixerGuiFactory;
  32. class EffectRackGuiFactory;
  33.  
  34. namespace Environment {
  35. class ARTS_EXPORT Context_base : virtual public Arts::Object_base {
  36. public:
  37.     static unsigned long _IID; // interface ID
  38.  
  39.     static Context_base *_create(const std::string& subClass = "Arts::Environment::Context");
  40.     static Context_base *_fromString(const std::string& objectref);
  41.     static Context_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  42.  
  43.     static Context_base *_fromDynamicCast(const Arts::Object& object);
  44.     inline Context_base *_copy() {
  45.         assert(_refCnt > 0);
  46.         _refCnt++;
  47.         return this;
  48.     }
  49.  
  50.     virtual std::vector<std::string> _defaultPortsIn() const;
  51.     virtual std::vector<std::string> _defaultPortsOut() const;
  52.  
  53.     void *_cast(unsigned long iid);
  54.  
  55.     virtual void addEntry(const std::string& name, Arts::Object obj) = 0;
  56.     virtual std::string lookupEntry(Arts::Object obj) = 0;
  57.     virtual void removeEntry(Arts::Object obj) = 0;
  58. };
  59.  
  60. class ARTS_EXPORT Context_stub : virtual public Context_base, virtual public Arts::Object_stub {
  61. protected:
  62.     Context_stub();
  63.  
  64. public:
  65.     Context_stub(Arts::Connection *connection, long objectID);
  66.  
  67.     void addEntry(const std::string& name, Arts::Object obj);
  68.     std::string lookupEntry(Arts::Object obj);
  69.     void removeEntry(Arts::Object obj);
  70. };
  71.  
  72. class ARTS_EXPORT Context_skel : virtual public Context_base, virtual public Arts::Object_skel {
  73. public:
  74.     Context_skel();
  75.  
  76.     static std::string _interfaceNameSkel();
  77.     std::string _interfaceName();
  78.     bool _isCompatibleWith(const std::string& interfacename);
  79.     void _buildMethodTable();
  80.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  81. };
  82.  
  83. }
  84. }
  85. #include "reference.h"
  86. namespace Arts {
  87. namespace Environment {
  88. class ARTS_EXPORT Context : public Arts::Object {
  89. private:
  90.     static Arts::Object_base* _Creator();
  91.     Context_base *_cache;
  92.     inline Context_base *_method_call() {
  93.         _pool->checkcreate();
  94.         if(_pool->base) {
  95.             _cache=(Context_base *)_pool->base->_cast(Context_base::_IID);
  96.             assert(_cache);
  97.         }
  98.         return _cache;
  99.     }
  100.  
  101. protected:
  102.     inline Context(Context_base* b) : Arts::Object(b), _cache(0) {}
  103.  
  104.  
  105. public:
  106.     typedef Context_base _base_class;
  107.  
  108.     inline Context() : Arts::Object(_Creator), _cache(0) {}
  109.     inline Context(const Arts::SubClass& s) :
  110.         Arts::Object(Context_base::_create(s.string())), _cache(0) {}
  111.     inline Context(const Arts::Reference &r) :
  112.         Arts::Object(r.isString()?(Context_base::_fromString(r.string())):(Context_base::_fromReference(r.reference(),true))), _cache(0) {}
  113.     inline Context(const Arts::DynamicCast& c) : Arts::Object(Context_base::_fromDynamicCast(c.object())), _cache(0) {}
  114.     inline Context(const Context& target) : Arts::Object(target._pool), _cache(target._cache) {}
  115.     inline Context(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  116.     inline static Context null() {return Context((Context_base*)0);}
  117.     inline static Context _from_base(Context_base* b) {return Context(b);}
  118.     inline Context& operator=(const Context& target) {
  119.         if (_pool == target._pool) return *this;
  120.         _pool->Dec();
  121.         _pool = target._pool;
  122.         _cache = target._cache;
  123.         _pool->Inc();
  124.         return *this;
  125.     }
  126.     inline Context_base* _base() {return _cache?_cache:_method_call();}
  127.  
  128.     inline void addEntry(const std::string& name, Arts::Object obj);
  129.     inline std::string lookupEntry(Arts::Object obj);
  130.     inline void removeEntry(Arts::Object obj);
  131. };
  132.  
  133. class ARTS_EXPORT Container_base : virtual public Arts::Object_base {
  134. public:
  135.     static unsigned long _IID; // interface ID
  136.  
  137.     static Container_base *_create(const std::string& subClass = "Arts::Environment::Container");
  138.     static Container_base *_fromString(const std::string& objectref);
  139.     static Container_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  140.  
  141.     static Container_base *_fromDynamicCast(const Arts::Object& object);
  142.     inline Container_base *_copy() {
  143.         assert(_refCnt > 0);
  144.         _refCnt++;
  145.         return this;
  146.     }
  147.  
  148.     virtual std::vector<std::string> _defaultPortsIn() const;
  149.     virtual std::vector<std::string> _defaultPortsOut() const;
  150.  
  151.     void *_cast(unsigned long iid);
  152.  
  153.     virtual std::string dataDirectory() = 0;
  154.     virtual void dataDirectory(const std::string& newValue) = 0;
  155.     virtual Arts::Environment::Context context() = 0;
  156.     virtual void context(Arts::Environment::Context newValue) = 0;
  157.     virtual std::vector<Arts::Environment::Item> * items() = 0;
  158.     virtual std::vector<std::string> * saveToList() = 0;
  159.     virtual void loadFromList(const std::vector<std::string>& strlist) = 0;
  160.     virtual void addItem(Arts::Environment::Item item) = 0;
  161.     virtual Arts::Environment::Item createItem(const std::string& name) = 0;
  162.     virtual void removeItem(Arts::Environment::Item item) = 0;
  163. };
  164.  
  165. class ARTS_EXPORT Container_stub : virtual public Container_base, virtual public Arts::Object_stub {
  166. protected:
  167.     Container_stub();
  168.  
  169. public:
  170.     Container_stub(Arts::Connection *connection, long objectID);
  171.  
  172.     std::string dataDirectory();
  173.     void dataDirectory(const std::string& newValue);
  174.     Arts::Environment::Context context();
  175.     void context(Arts::Environment::Context newValue);
  176.     std::vector<Arts::Environment::Item> * items();
  177.     std::vector<std::string> * saveToList();
  178.     void loadFromList(const std::vector<std::string>& strlist);
  179.     void addItem(Arts::Environment::Item item);
  180.     Arts::Environment::Item createItem(const std::string& name);
  181.     void removeItem(Arts::Environment::Item item);
  182. };
  183.  
  184. class ARTS_EXPORT Container_skel : virtual public Container_base, virtual public Arts::Object_skel {
  185. protected:
  186.     // emitters for change notifications
  187.     inline void dataDirectory_changed(const std::string& newValue) {
  188.         _emit_changed("dataDirectory_changed",newValue);
  189.     }
  190.  
  191. public:
  192.     Container_skel();
  193.  
  194.     static std::string _interfaceNameSkel();
  195.     std::string _interfaceName();
  196.     bool _isCompatibleWith(const std::string& interfacename);
  197.     void _buildMethodTable();
  198.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  199. };
  200.  
  201. }
  202. }
  203. #include "reference.h"
  204. namespace Arts {
  205. namespace Environment {
  206. class ARTS_EXPORT Container : public Arts::Object {
  207. private:
  208.     static Arts::Object_base* _Creator();
  209.     Container_base *_cache;
  210.     inline Container_base *_method_call() {
  211.         _pool->checkcreate();
  212.         if(_pool->base) {
  213.             _cache=(Container_base *)_pool->base->_cast(Container_base::_IID);
  214.             assert(_cache);
  215.         }
  216.         return _cache;
  217.     }
  218.  
  219. protected:
  220.     inline Container(Container_base* b) : Arts::Object(b), _cache(0) {}
  221.  
  222.  
  223. public:
  224.     typedef Container_base _base_class;
  225.  
  226.     inline Container() : Arts::Object(_Creator), _cache(0) {}
  227.     inline Container(const Arts::SubClass& s) :
  228.         Arts::Object(Container_base::_create(s.string())), _cache(0) {}
  229.     inline Container(const Arts::Reference &r) :
  230.         Arts::Object(r.isString()?(Container_base::_fromString(r.string())):(Container_base::_fromReference(r.reference(),true))), _cache(0) {}
  231.     inline Container(const Arts::DynamicCast& c) : Arts::Object(Container_base::_fromDynamicCast(c.object())), _cache(0) {}
  232.     inline Container(const Container& target) : Arts::Object(target._pool), _cache(target._cache) {}
  233.     inline Container(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  234.     inline static Container null() {return Container((Container_base*)0);}
  235.     inline static Container _from_base(Container_base* b) {return Container(b);}
  236.     inline Container& operator=(const Container& target) {
  237.         if (_pool == target._pool) return *this;
  238.         _pool->Dec();
  239.         _pool = target._pool;
  240.         _cache = target._cache;
  241.         _pool->Inc();
  242.         return *this;
  243.     }
  244.     inline Container_base* _base() {return _cache?_cache:_method_call();}
  245.  
  246.     inline std::string dataDirectory();
  247.     inline void dataDirectory(const std::string& _newValue);
  248.     inline Arts::Environment::Context context();
  249.     inline void context(Arts::Environment::Context _newValue);
  250.     inline std::vector<Arts::Environment::Item> * items();
  251.     inline std::vector<std::string> * saveToList();
  252.     inline void loadFromList(const std::vector<std::string>& strlist);
  253.     inline void addItem(Arts::Environment::Item item);
  254.     inline Arts::Environment::Item createItem(const std::string& name);
  255.     inline void removeItem(Arts::Environment::Item item);
  256. };
  257.  
  258. class ARTS_EXPORT Item_base : virtual public Arts::Object_base {
  259. public:
  260.     static unsigned long _IID; // interface ID
  261.  
  262.     static Item_base *_create(const std::string& subClass = "Arts::Environment::Item");
  263.     static Item_base *_fromString(const std::string& objectref);
  264.     static Item_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  265.  
  266.     static Item_base *_fromDynamicCast(const Arts::Object& object);
  267.     inline Item_base *_copy() {
  268.         assert(_refCnt > 0);
  269.         _refCnt++;
  270.         return this;
  271.     }
  272.  
  273.     virtual std::vector<std::string> _defaultPortsIn() const;
  274.     virtual std::vector<std::string> _defaultPortsOut() const;
  275.  
  276.     void *_cast(unsigned long iid);
  277.  
  278.     virtual bool active() = 0;
  279.     virtual Arts::Environment::Container parent() = 0;
  280.     virtual void setContainer(Arts::Environment::Container container) = 0;
  281.     virtual std::vector<std::string> * saveToList() = 0;
  282.     virtual void loadFromList(const std::vector<std::string>& strlist) = 0;
  283. };
  284.  
  285. class ARTS_EXPORT Item_stub : virtual public Item_base, virtual public Arts::Object_stub {
  286. protected:
  287.     Item_stub();
  288.  
  289. public:
  290.     Item_stub(Arts::Connection *connection, long objectID);
  291.  
  292.     bool active();
  293.     Arts::Environment::Container parent();
  294.     void setContainer(Arts::Environment::Container container);
  295.     std::vector<std::string> * saveToList();
  296.     void loadFromList(const std::vector<std::string>& strlist);
  297. };
  298.  
  299. class ARTS_EXPORT Item_skel : virtual public Item_base, virtual public Arts::Object_skel {
  300. protected:
  301.     // emitters for change notifications
  302.     inline void active_changed(bool newValue) {
  303.         _emit_changed("active_changed",newValue);
  304.     }
  305.  
  306. public:
  307.     Item_skel();
  308.  
  309.     static std::string _interfaceNameSkel();
  310.     std::string _interfaceName();
  311.     bool _isCompatibleWith(const std::string& interfacename);
  312.     void _buildMethodTable();
  313.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  314. };
  315.  
  316. }
  317. }
  318. #include "reference.h"
  319. namespace Arts {
  320. namespace Environment {
  321. class ARTS_EXPORT Item : public Arts::Object {
  322. private:
  323.     static Arts::Object_base* _Creator();
  324.     Item_base *_cache;
  325.     inline Item_base *_method_call() {
  326.         _pool->checkcreate();
  327.         if(_pool->base) {
  328.             _cache=(Item_base *)_pool->base->_cast(Item_base::_IID);
  329.             assert(_cache);
  330.         }
  331.         return _cache;
  332.     }
  333.  
  334. protected:
  335.     inline Item(Item_base* b) : Arts::Object(b), _cache(0) {}
  336.  
  337.  
  338. public:
  339.     typedef Item_base _base_class;
  340.  
  341.     inline Item() : Arts::Object(_Creator), _cache(0) {}
  342.     inline Item(const Arts::SubClass& s) :
  343.         Arts::Object(Item_base::_create(s.string())), _cache(0) {}
  344.     inline Item(const Arts::Reference &r) :
  345.         Arts::Object(r.isString()?(Item_base::_fromString(r.string())):(Item_base::_fromReference(r.reference(),true))), _cache(0) {}
  346.     inline Item(const Arts::DynamicCast& c) : Arts::Object(Item_base::_fromDynamicCast(c.object())), _cache(0) {}
  347.     inline Item(const Item& target) : Arts::Object(target._pool), _cache(target._cache) {}
  348.     inline Item(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  349.     inline static Item null() {return Item((Item_base*)0);}
  350.     inline static Item _from_base(Item_base* b) {return Item(b);}
  351.     inline Item& operator=(const Item& target) {
  352.         if (_pool == target._pool) return *this;
  353.         _pool->Dec();
  354.         _pool = target._pool;
  355.         _cache = target._cache;
  356.         _pool->Inc();
  357.         return *this;
  358.     }
  359.     inline Item_base* _base() {return _cache?_cache:_method_call();}
  360.  
  361.     inline bool active();
  362.     inline Arts::Environment::Container parent();
  363.     inline void setContainer(Arts::Environment::Container container);
  364.     inline std::vector<std::string> * saveToList();
  365.     inline void loadFromList(const std::vector<std::string>& strlist);
  366. };
  367.  
  368. class ARTS_EXPORT InstrumentItem_base : virtual public Arts::Environment::Item_base {
  369. public:
  370.     static unsigned long _IID; // interface ID
  371.  
  372.     static InstrumentItem_base *_create(const std::string& subClass = "Arts::Environment::InstrumentItem");
  373.     static InstrumentItem_base *_fromString(const std::string& objectref);
  374.     static InstrumentItem_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  375.  
  376.     static InstrumentItem_base *_fromDynamicCast(const Arts::Object& object);
  377.     inline InstrumentItem_base *_copy() {
  378.         assert(_refCnt > 0);
  379.         _refCnt++;
  380.         return this;
  381.     }
  382.  
  383.     virtual std::vector<std::string> _defaultPortsIn() const;
  384.     virtual std::vector<std::string> _defaultPortsOut() const;
  385.  
  386.     void *_cast(unsigned long iid);
  387.  
  388.     virtual Arts::MidiPort port() = 0;
  389.     virtual std::string filename() = 0;
  390.     virtual void filename(const std::string& newValue) = 0;
  391.     virtual std::string busname() = 0;
  392.     virtual void busname(const std::string& newValue) = 0;
  393. };
  394.  
  395. class ARTS_EXPORT InstrumentItem_stub : virtual public InstrumentItem_base, virtual public Arts::Environment::Item_stub {
  396. protected:
  397.     InstrumentItem_stub();
  398.  
  399. public:
  400.     InstrumentItem_stub(Arts::Connection *connection, long objectID);
  401.  
  402.     Arts::MidiPort port();
  403.     std::string filename();
  404.     void filename(const std::string& newValue);
  405.     std::string busname();
  406.     void busname(const std::string& newValue);
  407. };
  408.  
  409. class ARTS_EXPORT InstrumentItem_skel : virtual public InstrumentItem_base, virtual public Arts::Environment::Item_skel {
  410. protected:
  411.     // emitters for change notifications
  412.     inline void filename_changed(const std::string& newValue) {
  413.         _emit_changed("filename_changed",newValue);
  414.     }
  415.     inline void busname_changed(const std::string& newValue) {
  416.         _emit_changed("busname_changed",newValue);
  417.     }
  418.  
  419. public:
  420.     InstrumentItem_skel();
  421.  
  422.     static std::string _interfaceNameSkel();
  423.     std::string _interfaceName();
  424.     bool _isCompatibleWith(const std::string& interfacename);
  425.     void _buildMethodTable();
  426.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  427. };
  428.  
  429. }
  430. }
  431. #include "reference.h"
  432. namespace Arts {
  433. namespace Environment {
  434. class ARTS_EXPORT InstrumentItem : public Arts::Object {
  435. private:
  436.     static Arts::Object_base* _Creator();
  437.     InstrumentItem_base *_cache;
  438.     inline InstrumentItem_base *_method_call() {
  439.         _pool->checkcreate();
  440.         if(_pool->base) {
  441.             _cache=(InstrumentItem_base *)_pool->base->_cast(InstrumentItem_base::_IID);
  442.             assert(_cache);
  443.         }
  444.         return _cache;
  445.     }
  446.  
  447. protected:
  448.     inline InstrumentItem(InstrumentItem_base* b) : Arts::Object(b), _cache(0) {}
  449.  
  450.  
  451. public:
  452.     typedef InstrumentItem_base _base_class;
  453.  
  454.     inline InstrumentItem() : Arts::Object(_Creator), _cache(0) {}
  455.     inline InstrumentItem(const Arts::SubClass& s) :
  456.         Arts::Object(InstrumentItem_base::_create(s.string())), _cache(0) {}
  457.     inline InstrumentItem(const Arts::Reference &r) :
  458.         Arts::Object(r.isString()?(InstrumentItem_base::_fromString(r.string())):(InstrumentItem_base::_fromReference(r.reference(),true))), _cache(0) {}
  459.     inline InstrumentItem(const Arts::DynamicCast& c) : Arts::Object(InstrumentItem_base::_fromDynamicCast(c.object())), _cache(0) {}
  460.     inline InstrumentItem(const InstrumentItem& target) : Arts::Object(target._pool), _cache(target._cache) {}
  461.     inline InstrumentItem(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  462.     inline static InstrumentItem null() {return InstrumentItem((InstrumentItem_base*)0);}
  463.     inline static InstrumentItem _from_base(InstrumentItem_base* b) {return InstrumentItem(b);}
  464.     inline InstrumentItem& operator=(const InstrumentItem& target) {
  465.         if (_pool == target._pool) return *this;
  466.         _pool->Dec();
  467.         _pool = target._pool;
  468.         _cache = target._cache;
  469.         _pool->Inc();
  470.         return *this;
  471.     }
  472.     inline operator Arts::Environment::Item() const { return Arts::Environment::Item(*_pool); }
  473.     inline InstrumentItem_base* _base() {return _cache?_cache:_method_call();}
  474.  
  475.     inline bool active();
  476.     inline Arts::Environment::Container parent();
  477.     inline void setContainer(Arts::Environment::Container container);
  478.     inline std::vector<std::string> * saveToList();
  479.     inline void loadFromList(const std::vector<std::string>& strlist);
  480.     inline Arts::MidiPort port();
  481.     inline std::string filename();
  482.     inline void filename(const std::string& _newValue);
  483.     inline std::string busname();
  484.     inline void busname(const std::string& _newValue);
  485. };
  486.  
  487. class ARTS_EXPORT InstrumentItemGuiFactory_base : virtual public Arts::GuiFactory_base {
  488. public:
  489.     static unsigned long _IID; // interface ID
  490.  
  491.     static InstrumentItemGuiFactory_base *_create(const std::string& subClass = "Arts::Environment::InstrumentItemGuiFactory");
  492.     static InstrumentItemGuiFactory_base *_fromString(const std::string& objectref);
  493.     static InstrumentItemGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  494.  
  495.     static InstrumentItemGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  496.     inline InstrumentItemGuiFactory_base *_copy() {
  497.         assert(_refCnt > 0);
  498.         _refCnt++;
  499.         return this;
  500.     }
  501.  
  502.     virtual std::vector<std::string> _defaultPortsIn() const;
  503.     virtual std::vector<std::string> _defaultPortsOut() const;
  504.  
  505.     void *_cast(unsigned long iid);
  506.  
  507. };
  508.  
  509. class ARTS_EXPORT InstrumentItemGuiFactory_stub : virtual public InstrumentItemGuiFactory_base, virtual public Arts::GuiFactory_stub {
  510. protected:
  511.     InstrumentItemGuiFactory_stub();
  512.  
  513. public:
  514.     InstrumentItemGuiFactory_stub(Arts::Connection *connection, long objectID);
  515.  
  516. };
  517.  
  518. class ARTS_EXPORT InstrumentItemGuiFactory_skel : virtual public InstrumentItemGuiFactory_base, virtual public Arts::GuiFactory_skel {
  519. public:
  520.     InstrumentItemGuiFactory_skel();
  521.  
  522.     static std::string _interfaceNameSkel();
  523.     std::string _interfaceName();
  524.     bool _isCompatibleWith(const std::string& interfacename);
  525.     void _buildMethodTable();
  526.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  527. };
  528.  
  529. }
  530. }
  531. #include "reference.h"
  532. namespace Arts {
  533. namespace Environment {
  534. class ARTS_EXPORT InstrumentItemGuiFactory : public Arts::Object {
  535. private:
  536.     static Arts::Object_base* _Creator();
  537.     InstrumentItemGuiFactory_base *_cache;
  538.     inline InstrumentItemGuiFactory_base *_method_call() {
  539.         _pool->checkcreate();
  540.         if(_pool->base) {
  541.             _cache=(InstrumentItemGuiFactory_base *)_pool->base->_cast(InstrumentItemGuiFactory_base::_IID);
  542.             assert(_cache);
  543.         }
  544.         return _cache;
  545.     }
  546.  
  547. protected:
  548.     inline InstrumentItemGuiFactory(InstrumentItemGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  549.  
  550.  
  551. public:
  552.     typedef InstrumentItemGuiFactory_base _base_class;
  553.  
  554.     inline InstrumentItemGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  555.     inline InstrumentItemGuiFactory(const Arts::SubClass& s) :
  556.         Arts::Object(InstrumentItemGuiFactory_base::_create(s.string())), _cache(0) {}
  557.     inline InstrumentItemGuiFactory(const Arts::Reference &r) :
  558.         Arts::Object(r.isString()?(InstrumentItemGuiFactory_base::_fromString(r.string())):(InstrumentItemGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  559.     inline InstrumentItemGuiFactory(const Arts::DynamicCast& c) : Arts::Object(InstrumentItemGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  560.     inline InstrumentItemGuiFactory(const InstrumentItemGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  561.     inline InstrumentItemGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  562.     inline static InstrumentItemGuiFactory null() {return InstrumentItemGuiFactory((InstrumentItemGuiFactory_base*)0);}
  563.     inline static InstrumentItemGuiFactory _from_base(InstrumentItemGuiFactory_base* b) {return InstrumentItemGuiFactory(b);}
  564.     inline InstrumentItemGuiFactory& operator=(const InstrumentItemGuiFactory& target) {
  565.         if (_pool == target._pool) return *this;
  566.         _pool->Dec();
  567.         _pool = target._pool;
  568.         _cache = target._cache;
  569.         _pool->Inc();
  570.         return *this;
  571.     }
  572.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  573.     inline InstrumentItemGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  574.  
  575.     inline Arts::Widget createGui(Arts::Object runningObject);
  576. };
  577.  
  578. class ARTS_EXPORT StereoEffectItem_base : virtual public Arts::Environment::Item_base {
  579. public:
  580.     static unsigned long _IID; // interface ID
  581.  
  582.     static StereoEffectItem_base *_create(const std::string& subClass = "Arts::Environment::StereoEffectItem");
  583.     static StereoEffectItem_base *_fromString(const std::string& objectref);
  584.     static StereoEffectItem_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  585.  
  586.     static StereoEffectItem_base *_fromDynamicCast(const Arts::Object& object);
  587.     inline StereoEffectItem_base *_copy() {
  588.         assert(_refCnt > 0);
  589.         _refCnt++;
  590.         return this;
  591.     }
  592.  
  593.     virtual std::vector<std::string> _defaultPortsIn() const;
  594.     virtual std::vector<std::string> _defaultPortsOut() const;
  595.  
  596.     void *_cast(unsigned long iid);
  597.  
  598.     virtual Arts::SynthModule effect() = 0;
  599.     virtual void effect(Arts::SynthModule newValue) = 0;
  600.     virtual Arts::StereoEffectStack stack() = 0;
  601.     virtual void stack(Arts::StereoEffectStack newValue) = 0;
  602. };
  603.  
  604. class ARTS_EXPORT StereoEffectItem_stub : virtual public StereoEffectItem_base, virtual public Arts::Environment::Item_stub {
  605. protected:
  606.     StereoEffectItem_stub();
  607.  
  608. public:
  609.     StereoEffectItem_stub(Arts::Connection *connection, long objectID);
  610.  
  611.     Arts::SynthModule effect();
  612.     void effect(Arts::SynthModule newValue);
  613.     Arts::StereoEffectStack stack();
  614.     void stack(Arts::StereoEffectStack newValue);
  615. };
  616.  
  617. class ARTS_EXPORT StereoEffectItem_skel : virtual public StereoEffectItem_base, virtual public Arts::Environment::Item_skel {
  618. public:
  619.     StereoEffectItem_skel();
  620.  
  621.     static std::string _interfaceNameSkel();
  622.     std::string _interfaceName();
  623.     bool _isCompatibleWith(const std::string& interfacename);
  624.     void _buildMethodTable();
  625.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  626. };
  627.  
  628. }
  629. }
  630. #include "reference.h"
  631. namespace Arts {
  632. namespace Environment {
  633. class ARTS_EXPORT StereoEffectItem : public Arts::Object {
  634. private:
  635.     static Arts::Object_base* _Creator();
  636.     StereoEffectItem_base *_cache;
  637.     inline StereoEffectItem_base *_method_call() {
  638.         _pool->checkcreate();
  639.         if(_pool->base) {
  640.             _cache=(StereoEffectItem_base *)_pool->base->_cast(StereoEffectItem_base::_IID);
  641.             assert(_cache);
  642.         }
  643.         return _cache;
  644.     }
  645.  
  646. protected:
  647.     inline StereoEffectItem(StereoEffectItem_base* b) : Arts::Object(b), _cache(0) {}
  648.  
  649.  
  650. public:
  651.     typedef StereoEffectItem_base _base_class;
  652.  
  653.     inline StereoEffectItem() : Arts::Object(_Creator), _cache(0) {}
  654.     inline StereoEffectItem(const Arts::SubClass& s) :
  655.         Arts::Object(StereoEffectItem_base::_create(s.string())), _cache(0) {}
  656.     inline StereoEffectItem(const Arts::Reference &r) :
  657.         Arts::Object(r.isString()?(StereoEffectItem_base::_fromString(r.string())):(StereoEffectItem_base::_fromReference(r.reference(),true))), _cache(0) {}
  658.     inline StereoEffectItem(const Arts::DynamicCast& c) : Arts::Object(StereoEffectItem_base::_fromDynamicCast(c.object())), _cache(0) {}
  659.     inline StereoEffectItem(const StereoEffectItem& target) : Arts::Object(target._pool), _cache(target._cache) {}
  660.     inline StereoEffectItem(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  661.     inline static StereoEffectItem null() {return StereoEffectItem((StereoEffectItem_base*)0);}
  662.     inline static StereoEffectItem _from_base(StereoEffectItem_base* b) {return StereoEffectItem(b);}
  663.     inline StereoEffectItem& operator=(const StereoEffectItem& target) {
  664.         if (_pool == target._pool) return *this;
  665.         _pool->Dec();
  666.         _pool = target._pool;
  667.         _cache = target._cache;
  668.         _pool->Inc();
  669.         return *this;
  670.     }
  671.     inline operator Arts::Environment::Item() const { return Arts::Environment::Item(*_pool); }
  672.     inline StereoEffectItem_base* _base() {return _cache?_cache:_method_call();}
  673.  
  674.     inline bool active();
  675.     inline Arts::Environment::Container parent();
  676.     inline void setContainer(Arts::Environment::Container container);
  677.     inline std::vector<std::string> * saveToList();
  678.     inline void loadFromList(const std::vector<std::string>& strlist);
  679.     inline Arts::SynthModule effect();
  680.     inline void effect(Arts::SynthModule _newValue);
  681.     inline Arts::StereoEffectStack stack();
  682.     inline void stack(Arts::StereoEffectStack _newValue);
  683. };
  684.  
  685. class ARTS_EXPORT MixerChannel_base : virtual public Arts::StereoEffect_base {
  686. public:
  687.     static unsigned long _IID; // interface ID
  688.  
  689.     static MixerChannel_base *_create(const std::string& subClass = "Arts::Environment::MixerChannel");
  690.     static MixerChannel_base *_fromString(const std::string& objectref);
  691.     static MixerChannel_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  692.  
  693.     static MixerChannel_base *_fromDynamicCast(const Arts::Object& object);
  694.     inline MixerChannel_base *_copy() {
  695.         assert(_refCnt > 0);
  696.         _refCnt++;
  697.         return this;
  698.     }
  699.  
  700.     virtual std::vector<std::string> _defaultPortsIn() const;
  701.     virtual std::vector<std::string> _defaultPortsOut() const;
  702.  
  703.     void *_cast(unsigned long iid);
  704.  
  705.     virtual std::string name() = 0;
  706.     virtual void name(const std::string& newValue) = 0;
  707. };
  708.  
  709. class ARTS_EXPORT MixerChannel_stub : virtual public MixerChannel_base, virtual public Arts::StereoEffect_stub {
  710. protected:
  711.     MixerChannel_stub();
  712.  
  713. public:
  714.     MixerChannel_stub(Arts::Connection *connection, long objectID);
  715.  
  716.     std::string name();
  717.     void name(const std::string& newValue);
  718. };
  719.  
  720. class ARTS_EXPORT MixerChannel_skel : virtual public MixerChannel_base, virtual public Arts::StereoEffect_skel {
  721. protected:
  722.     // emitters for change notifications
  723.     inline void name_changed(const std::string& newValue) {
  724.         _emit_changed("name_changed",newValue);
  725.     }
  726.  
  727. public:
  728.     MixerChannel_skel();
  729.  
  730.     static std::string _interfaceNameSkel();
  731.     std::string _interfaceName();
  732.     bool _isCompatibleWith(const std::string& interfacename);
  733.     void _buildMethodTable();
  734.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  735. };
  736.  
  737. }
  738. }
  739. #include "reference.h"
  740. namespace Arts {
  741. namespace Environment {
  742. class ARTS_EXPORT MixerChannel : public Arts::Object {
  743. private:
  744.     static Arts::Object_base* _Creator();
  745.     MixerChannel_base *_cache;
  746.     inline MixerChannel_base *_method_call() {
  747.         _pool->checkcreate();
  748.         if(_pool->base) {
  749.             _cache=(MixerChannel_base *)_pool->base->_cast(MixerChannel_base::_IID);
  750.             assert(_cache);
  751.         }
  752.         return _cache;
  753.     }
  754.  
  755. protected:
  756.     inline MixerChannel(MixerChannel_base* b) : Arts::Object(b), _cache(0) {}
  757.  
  758.  
  759. public:
  760.     typedef MixerChannel_base _base_class;
  761.  
  762.     inline MixerChannel() : Arts::Object(_Creator), _cache(0) {}
  763.     inline MixerChannel(const Arts::SubClass& s) :
  764.         Arts::Object(MixerChannel_base::_create(s.string())), _cache(0) {}
  765.     inline MixerChannel(const Arts::Reference &r) :
  766.         Arts::Object(r.isString()?(MixerChannel_base::_fromString(r.string())):(MixerChannel_base::_fromReference(r.reference(),true))), _cache(0) {}
  767.     inline MixerChannel(const Arts::DynamicCast& c) : Arts::Object(MixerChannel_base::_fromDynamicCast(c.object())), _cache(0) {}
  768.     inline MixerChannel(const MixerChannel& target) : Arts::Object(target._pool), _cache(target._cache) {}
  769.     inline MixerChannel(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  770.     inline static MixerChannel null() {return MixerChannel((MixerChannel_base*)0);}
  771.     inline static MixerChannel _from_base(MixerChannel_base* b) {return MixerChannel(b);}
  772.     inline MixerChannel& operator=(const MixerChannel& target) {
  773.         if (_pool == target._pool) return *this;
  774.         _pool->Dec();
  775.         _pool = target._pool;
  776.         _cache = target._cache;
  777.         _pool->Inc();
  778.         return *this;
  779.     }
  780.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  781.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  782.     inline MixerChannel_base* _base() {return _cache?_cache:_method_call();}
  783.  
  784.     inline Arts::AutoSuspendState autoSuspend();
  785.     inline void start();
  786.     inline void stop();
  787.     inline void streamInit();
  788.     inline void streamStart();
  789.     inline void streamEnd();
  790.     inline std::string name();
  791.     inline void name(const std::string& _newValue);
  792. };
  793.  
  794. class ARTS_EXPORT MixerItem_base : virtual public Arts::Environment::Item_base {
  795. public:
  796.     static unsigned long _IID; // interface ID
  797.  
  798.     static MixerItem_base *_create(const std::string& subClass = "Arts::Environment::MixerItem");
  799.     static MixerItem_base *_fromString(const std::string& objectref);
  800.     static MixerItem_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  801.  
  802.     static MixerItem_base *_fromDynamicCast(const Arts::Object& object);
  803.     inline MixerItem_base *_copy() {
  804.         assert(_refCnt > 0);
  805.         _refCnt++;
  806.         return this;
  807.     }
  808.  
  809.     virtual std::vector<std::string> _defaultPortsIn() const;
  810.     virtual std::vector<std::string> _defaultPortsOut() const;
  811.  
  812.     void *_cast(unsigned long iid);
  813.  
  814.     virtual std::vector<Arts::Environment::MixerChannel> * channels() = 0;
  815.     virtual long channelCount() = 0;
  816.     virtual void channelCount(long newValue) = 0;
  817.     virtual std::string name() = 0;
  818.     virtual void name(const std::string& newValue) = 0;
  819.     virtual std::string type() = 0;
  820.     virtual void type(const std::string& newValue) = 0;
  821. };
  822.  
  823. class ARTS_EXPORT MixerItem_stub : virtual public MixerItem_base, virtual public Arts::Environment::Item_stub {
  824. protected:
  825.     MixerItem_stub();
  826.  
  827. public:
  828.     MixerItem_stub(Arts::Connection *connection, long objectID);
  829.  
  830.     std::vector<Arts::Environment::MixerChannel> * channels();
  831.     long channelCount();
  832.     void channelCount(long newValue);
  833.     std::string name();
  834.     void name(const std::string& newValue);
  835.     std::string type();
  836.     void type(const std::string& newValue);
  837. };
  838.  
  839. class ARTS_EXPORT MixerItem_skel : virtual public MixerItem_base, virtual public Arts::Environment::Item_skel {
  840. protected:
  841.     // emitters for change notifications
  842.     inline void channelCount_changed(long newValue) {
  843.         _emit_changed("channelCount_changed",newValue);
  844.     }
  845.     inline void name_changed(const std::string& newValue) {
  846.         _emit_changed("name_changed",newValue);
  847.     }
  848.     inline void type_changed(const std::string& newValue) {
  849.         _emit_changed("type_changed",newValue);
  850.     }
  851.  
  852. public:
  853.     MixerItem_skel();
  854.  
  855.     static std::string _interfaceNameSkel();
  856.     std::string _interfaceName();
  857.     bool _isCompatibleWith(const std::string& interfacename);
  858.     void _buildMethodTable();
  859.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  860. };
  861.  
  862. }
  863. }
  864. #include "reference.h"
  865. namespace Arts {
  866. namespace Environment {
  867. class ARTS_EXPORT MixerItem : public Arts::Object {
  868. private:
  869.     static Arts::Object_base* _Creator();
  870.     MixerItem_base *_cache;
  871.     inline MixerItem_base *_method_call() {
  872.         _pool->checkcreate();
  873.         if(_pool->base) {
  874.             _cache=(MixerItem_base *)_pool->base->_cast(MixerItem_base::_IID);
  875.             assert(_cache);
  876.         }
  877.         return _cache;
  878.     }
  879.  
  880. protected:
  881.     inline MixerItem(MixerItem_base* b) : Arts::Object(b), _cache(0) {}
  882.  
  883.  
  884. public:
  885.     typedef MixerItem_base _base_class;
  886.  
  887.     inline MixerItem() : Arts::Object(_Creator), _cache(0) {}
  888.     inline MixerItem(const Arts::SubClass& s) :
  889.         Arts::Object(MixerItem_base::_create(s.string())), _cache(0) {}
  890.     inline MixerItem(const Arts::Reference &r) :
  891.         Arts::Object(r.isString()?(MixerItem_base::_fromString(r.string())):(MixerItem_base::_fromReference(r.reference(),true))), _cache(0) {}
  892.     inline MixerItem(const Arts::DynamicCast& c) : Arts::Object(MixerItem_base::_fromDynamicCast(c.object())), _cache(0) {}
  893.     inline MixerItem(const MixerItem& target) : Arts::Object(target._pool), _cache(target._cache) {}
  894.     inline MixerItem(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  895.     inline static MixerItem null() {return MixerItem((MixerItem_base*)0);}
  896.     inline static MixerItem _from_base(MixerItem_base* b) {return MixerItem(b);}
  897.     inline MixerItem& operator=(const MixerItem& target) {
  898.         if (_pool == target._pool) return *this;
  899.         _pool->Dec();
  900.         _pool = target._pool;
  901.         _cache = target._cache;
  902.         _pool->Inc();
  903.         return *this;
  904.     }
  905.     inline operator Arts::Environment::Item() const { return Arts::Environment::Item(*_pool); }
  906.     inline MixerItem_base* _base() {return _cache?_cache:_method_call();}
  907.  
  908.     inline bool active();
  909.     inline Arts::Environment::Container parent();
  910.     inline void setContainer(Arts::Environment::Container container);
  911.     inline std::vector<std::string> * saveToList();
  912.     inline void loadFromList(const std::vector<std::string>& strlist);
  913.     inline std::vector<Arts::Environment::MixerChannel> * channels();
  914.     inline long channelCount();
  915.     inline void channelCount(long _newValue);
  916.     inline std::string name();
  917.     inline void name(const std::string& _newValue);
  918.     inline std::string type();
  919.     inline void type(const std::string& _newValue);
  920. };
  921.  
  922. class ARTS_EXPORT EffectRackItem_base : virtual public Arts::Environment::Item_base {
  923. public:
  924.     static unsigned long _IID; // interface ID
  925.  
  926.     static EffectRackItem_base *_create(const std::string& subClass = "Arts::Environment::EffectRackItem");
  927.     static EffectRackItem_base *_fromString(const std::string& objectref);
  928.     static EffectRackItem_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  929.  
  930.     static EffectRackItem_base *_fromDynamicCast(const Arts::Object& object);
  931.     inline EffectRackItem_base *_copy() {
  932.         assert(_refCnt > 0);
  933.         _refCnt++;
  934.         return this;
  935.     }
  936.  
  937.     virtual std::vector<std::string> _defaultPortsIn() const;
  938.     virtual std::vector<std::string> _defaultPortsOut() const;
  939.  
  940.     void *_cast(unsigned long iid);
  941.  
  942.     virtual std::vector<Arts::StereoEffect> * effects() = 0;
  943.     virtual long effectCount() = 0;
  944.     virtual std::string name() = 0;
  945.     virtual void name(const std::string& newValue) = 0;
  946.     virtual Arts::StereoEffect createEffect(const std::string& type, const std::string& name) = 0;
  947.     virtual void delEffect(long pos) = 0;
  948.     virtual void routeToMaster(long pos, bool tomaster) = 0;
  949. };
  950.  
  951. class ARTS_EXPORT EffectRackItem_stub : virtual public EffectRackItem_base, virtual public Arts::Environment::Item_stub {
  952. protected:
  953.     EffectRackItem_stub();
  954.  
  955. public:
  956.     EffectRackItem_stub(Arts::Connection *connection, long objectID);
  957.  
  958.     std::vector<Arts::StereoEffect> * effects();
  959.     long effectCount();
  960.     std::string name();
  961.     void name(const std::string& newValue);
  962.     Arts::StereoEffect createEffect(const std::string& type, const std::string& name);
  963.     void delEffect(long pos);
  964.     void routeToMaster(long pos, bool tomaster);
  965. };
  966.  
  967. class ARTS_EXPORT EffectRackItem_skel : virtual public EffectRackItem_base, virtual public Arts::Environment::Item_skel {
  968. protected:
  969.     // emitters for change notifications
  970.     inline void effectCount_changed(long newValue) {
  971.         _emit_changed("effectCount_changed",newValue);
  972.     }
  973.     inline void name_changed(const std::string& newValue) {
  974.         _emit_changed("name_changed",newValue);
  975.     }
  976.  
  977. public:
  978.     EffectRackItem_skel();
  979.  
  980.     static std::string _interfaceNameSkel();
  981.     std::string _interfaceName();
  982.     bool _isCompatibleWith(const std::string& interfacename);
  983.     void _buildMethodTable();
  984.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  985. };
  986.  
  987. }
  988. }
  989. #include "reference.h"
  990. namespace Arts {
  991. namespace Environment {
  992. class ARTS_EXPORT EffectRackItem : public Arts::Object {
  993. private:
  994.     static Arts::Object_base* _Creator();
  995.     EffectRackItem_base *_cache;
  996.     inline EffectRackItem_base *_method_call() {
  997.         _pool->checkcreate();
  998.         if(_pool->base) {
  999.             _cache=(EffectRackItem_base *)_pool->base->_cast(EffectRackItem_base::_IID);
  1000.             assert(_cache);
  1001.         }
  1002.         return _cache;
  1003.     }
  1004.  
  1005. protected:
  1006.     inline EffectRackItem(EffectRackItem_base* b) : Arts::Object(b), _cache(0) {}
  1007.  
  1008.  
  1009. public:
  1010.     typedef EffectRackItem_base _base_class;
  1011.  
  1012.     inline EffectRackItem() : Arts::Object(_Creator), _cache(0) {}
  1013.     inline EffectRackItem(const Arts::SubClass& s) :
  1014.         Arts::Object(EffectRackItem_base::_create(s.string())), _cache(0) {}
  1015.     inline EffectRackItem(const Arts::Reference &r) :
  1016.         Arts::Object(r.isString()?(EffectRackItem_base::_fromString(r.string())):(EffectRackItem_base::_fromReference(r.reference(),true))), _cache(0) {}
  1017.     inline EffectRackItem(const Arts::DynamicCast& c) : Arts::Object(EffectRackItem_base::_fromDynamicCast(c.object())), _cache(0) {}
  1018.     inline EffectRackItem(const EffectRackItem& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1019.     inline EffectRackItem(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1020.     inline static EffectRackItem null() {return EffectRackItem((EffectRackItem_base*)0);}
  1021.     inline static EffectRackItem _from_base(EffectRackItem_base* b) {return EffectRackItem(b);}
  1022.     inline EffectRackItem& operator=(const EffectRackItem& target) {
  1023.         if (_pool == target._pool) return *this;
  1024.         _pool->Dec();
  1025.         _pool = target._pool;
  1026.         _cache = target._cache;
  1027.         _pool->Inc();
  1028.         return *this;
  1029.     }
  1030.     inline operator Arts::Environment::Item() const { return Arts::Environment::Item(*_pool); }
  1031.     inline EffectRackItem_base* _base() {return _cache?_cache:_method_call();}
  1032.  
  1033.     inline bool active();
  1034.     inline Arts::Environment::Container parent();
  1035.     inline void setContainer(Arts::Environment::Container container);
  1036.     inline std::vector<std::string> * saveToList();
  1037.     inline void loadFromList(const std::vector<std::string>& strlist);
  1038.     inline std::vector<Arts::StereoEffect> * effects();
  1039.     inline long effectCount();
  1040.     inline std::string name();
  1041.     inline void name(const std::string& _newValue);
  1042.     inline Arts::StereoEffect createEffect(const std::string& type, const std::string& name);
  1043.     inline void delEffect(long pos);
  1044.     inline void routeToMaster(long pos, bool tomaster);
  1045. };
  1046.  
  1047. }
  1048. class ARTS_EXPORT MixerItemGui_base : virtual public Arts::Object_base {
  1049. public:
  1050.     static unsigned long _IID; // interface ID
  1051.  
  1052.     static MixerItemGui_base *_create(const std::string& subClass = "Arts::MixerItemGui");
  1053.     static MixerItemGui_base *_fromString(const std::string& objectref);
  1054.     static MixerItemGui_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1055.  
  1056.     static MixerItemGui_base *_fromDynamicCast(const Arts::Object& object);
  1057.     inline MixerItemGui_base *_copy() {
  1058.         assert(_refCnt > 0);
  1059.         _refCnt++;
  1060.         return this;
  1061.     }
  1062.  
  1063.     virtual std::vector<std::string> _defaultPortsIn() const;
  1064.     virtual std::vector<std::string> _defaultPortsOut() const;
  1065.  
  1066.     void *_cast(unsigned long iid);
  1067.  
  1068.     virtual bool active() = 0;
  1069.     virtual void active(bool newValue) = 0;
  1070.     virtual long channelCount() = 0;
  1071.     virtual void channelCount(long newValue) = 0;
  1072.     virtual std::string type() = 0;
  1073.     virtual void type(const std::string& newValue) = 0;
  1074.     virtual Arts::Widget initialize(Arts::Environment::MixerItem item) = 0;
  1075. };
  1076.  
  1077. class ARTS_EXPORT MixerItemGui_stub : virtual public MixerItemGui_base, virtual public Arts::Object_stub {
  1078. protected:
  1079.     MixerItemGui_stub();
  1080.  
  1081. public:
  1082.     MixerItemGui_stub(Arts::Connection *connection, long objectID);
  1083.  
  1084.     bool active();
  1085.     void active(bool newValue);
  1086.     long channelCount();
  1087.     void channelCount(long newValue);
  1088.     std::string type();
  1089.     void type(const std::string& newValue);
  1090.     Arts::Widget initialize(Arts::Environment::MixerItem item);
  1091. };
  1092.  
  1093. class ARTS_EXPORT MixerItemGui_skel : virtual public MixerItemGui_base, virtual public Arts::Object_skel {
  1094. protected:
  1095.     // emitters for change notifications
  1096.     inline void active_changed(bool newValue) {
  1097.         _emit_changed("active_changed",newValue);
  1098.     }
  1099.     inline void channelCount_changed(long newValue) {
  1100.         _emit_changed("channelCount_changed",newValue);
  1101.     }
  1102.     inline void type_changed(const std::string& newValue) {
  1103.         _emit_changed("type_changed",newValue);
  1104.     }
  1105.  
  1106. public:
  1107.     MixerItemGui_skel();
  1108.  
  1109.     static std::string _interfaceNameSkel();
  1110.     std::string _interfaceName();
  1111.     bool _isCompatibleWith(const std::string& interfacename);
  1112.     void _buildMethodTable();
  1113.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1114. };
  1115.  
  1116. }
  1117. #include "reference.h"
  1118. namespace Arts {
  1119. class ARTS_EXPORT MixerItemGui : public Arts::Object {
  1120. private:
  1121.     static Arts::Object_base* _Creator();
  1122.     MixerItemGui_base *_cache;
  1123.     inline MixerItemGui_base *_method_call() {
  1124.         _pool->checkcreate();
  1125.         if(_pool->base) {
  1126.             _cache=(MixerItemGui_base *)_pool->base->_cast(MixerItemGui_base::_IID);
  1127.             assert(_cache);
  1128.         }
  1129.         return _cache;
  1130.     }
  1131.  
  1132. protected:
  1133.     inline MixerItemGui(MixerItemGui_base* b) : Arts::Object(b), _cache(0) {}
  1134.  
  1135.  
  1136. public:
  1137.     typedef MixerItemGui_base _base_class;
  1138.  
  1139.     inline MixerItemGui() : Arts::Object(_Creator), _cache(0) {}
  1140.     inline MixerItemGui(const Arts::SubClass& s) :
  1141.         Arts::Object(MixerItemGui_base::_create(s.string())), _cache(0) {}
  1142.     inline MixerItemGui(const Arts::Reference &r) :
  1143.         Arts::Object(r.isString()?(MixerItemGui_base::_fromString(r.string())):(MixerItemGui_base::_fromReference(r.reference(),true))), _cache(0) {}
  1144.     inline MixerItemGui(const Arts::DynamicCast& c) : Arts::Object(MixerItemGui_base::_fromDynamicCast(c.object())), _cache(0) {}
  1145.     inline MixerItemGui(const MixerItemGui& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1146.     inline MixerItemGui(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1147.     inline static MixerItemGui null() {return MixerItemGui((MixerItemGui_base*)0);}
  1148.     inline static MixerItemGui _from_base(MixerItemGui_base* b) {return MixerItemGui(b);}
  1149.     inline MixerItemGui& operator=(const MixerItemGui& target) {
  1150.         if (_pool == target._pool) return *this;
  1151.         _pool->Dec();
  1152.         _pool = target._pool;
  1153.         _cache = target._cache;
  1154.         _pool->Inc();
  1155.         return *this;
  1156.     }
  1157.     inline MixerItemGui_base* _base() {return _cache?_cache:_method_call();}
  1158.  
  1159.     inline bool active();
  1160.     inline void active(bool _newValue);
  1161.     inline long channelCount();
  1162.     inline void channelCount(long _newValue);
  1163.     inline std::string type();
  1164.     inline void type(const std::string& _newValue);
  1165.     inline Arts::Widget initialize(Arts::Environment::MixerItem item);
  1166. };
  1167.  
  1168. class ARTS_EXPORT EffectRackItemGui_base : virtual public Arts::Object_base {
  1169. public:
  1170.     static unsigned long _IID; // interface ID
  1171.  
  1172.     static EffectRackItemGui_base *_create(const std::string& subClass = "Arts::EffectRackItemGui");
  1173.     static EffectRackItemGui_base *_fromString(const std::string& objectref);
  1174.     static EffectRackItemGui_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1175.  
  1176.     static EffectRackItemGui_base *_fromDynamicCast(const Arts::Object& object);
  1177.     inline EffectRackItemGui_base *_copy() {
  1178.         assert(_refCnt > 0);
  1179.         _refCnt++;
  1180.         return this;
  1181.     }
  1182.  
  1183.     virtual std::vector<std::string> _defaultPortsIn() const;
  1184.     virtual std::vector<std::string> _defaultPortsOut() const;
  1185.  
  1186.     void *_cast(unsigned long iid);
  1187.  
  1188.     virtual bool active() = 0;
  1189.     virtual void active(bool newValue) = 0;
  1190.     virtual std::string type() = 0;
  1191.     virtual void type(const std::string& newValue) = 0;
  1192.     virtual bool addeffect() = 0;
  1193.     virtual void addeffect(bool newValue) = 0;
  1194.     virtual void removeSlot(Arts::EffectRackSlot slot) = 0;
  1195.     virtual void routeToMaster(Arts::EffectRackSlot slot, bool tomaster) = 0;
  1196.     virtual Arts::Widget initialize(Arts::Environment::EffectRackItem item) = 0;
  1197. };
  1198.  
  1199. class ARTS_EXPORT EffectRackItemGui_stub : virtual public EffectRackItemGui_base, virtual public Arts::Object_stub {
  1200. protected:
  1201.     EffectRackItemGui_stub();
  1202.  
  1203. public:
  1204.     EffectRackItemGui_stub(Arts::Connection *connection, long objectID);
  1205.  
  1206.     bool active();
  1207.     void active(bool newValue);
  1208.     std::string type();
  1209.     void type(const std::string& newValue);
  1210.     bool addeffect();
  1211.     void addeffect(bool newValue);
  1212.     void removeSlot(Arts::EffectRackSlot slot);
  1213.     void routeToMaster(Arts::EffectRackSlot slot, bool tomaster);
  1214.     Arts::Widget initialize(Arts::Environment::EffectRackItem item);
  1215. };
  1216.  
  1217. class ARTS_EXPORT EffectRackItemGui_skel : virtual public EffectRackItemGui_base, virtual public Arts::Object_skel {
  1218. protected:
  1219.     // emitters for change notifications
  1220.     inline void active_changed(bool newValue) {
  1221.         _emit_changed("active_changed",newValue);
  1222.     }
  1223.     inline void type_changed(const std::string& newValue) {
  1224.         _emit_changed("type_changed",newValue);
  1225.     }
  1226.     inline void addeffect_changed(bool newValue) {
  1227.         _emit_changed("addeffect_changed",newValue);
  1228.     }
  1229.  
  1230. public:
  1231.     EffectRackItemGui_skel();
  1232.  
  1233.     static std::string _interfaceNameSkel();
  1234.     std::string _interfaceName();
  1235.     bool _isCompatibleWith(const std::string& interfacename);
  1236.     void _buildMethodTable();
  1237.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1238. };
  1239.  
  1240. }
  1241. #include "reference.h"
  1242. namespace Arts {
  1243. class ARTS_EXPORT EffectRackItemGui : public Arts::Object {
  1244. private:
  1245.     static Arts::Object_base* _Creator();
  1246.     EffectRackItemGui_base *_cache;
  1247.     inline EffectRackItemGui_base *_method_call() {
  1248.         _pool->checkcreate();
  1249.         if(_pool->base) {
  1250.             _cache=(EffectRackItemGui_base *)_pool->base->_cast(EffectRackItemGui_base::_IID);
  1251.             assert(_cache);
  1252.         }
  1253.         return _cache;
  1254.     }
  1255.  
  1256. protected:
  1257.     inline EffectRackItemGui(EffectRackItemGui_base* b) : Arts::Object(b), _cache(0) {}
  1258.  
  1259.  
  1260. public:
  1261.     typedef EffectRackItemGui_base _base_class;
  1262.  
  1263.     inline EffectRackItemGui() : Arts::Object(_Creator), _cache(0) {}
  1264.     inline EffectRackItemGui(const Arts::SubClass& s) :
  1265.         Arts::Object(EffectRackItemGui_base::_create(s.string())), _cache(0) {}
  1266.     inline EffectRackItemGui(const Arts::Reference &r) :
  1267.         Arts::Object(r.isString()?(EffectRackItemGui_base::_fromString(r.string())):(EffectRackItemGui_base::_fromReference(r.reference(),true))), _cache(0) {}
  1268.     inline EffectRackItemGui(const Arts::DynamicCast& c) : Arts::Object(EffectRackItemGui_base::_fromDynamicCast(c.object())), _cache(0) {}
  1269.     inline EffectRackItemGui(const EffectRackItemGui& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1270.     inline EffectRackItemGui(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1271.     inline static EffectRackItemGui null() {return EffectRackItemGui((EffectRackItemGui_base*)0);}
  1272.     inline static EffectRackItemGui _from_base(EffectRackItemGui_base* b) {return EffectRackItemGui(b);}
  1273.     inline EffectRackItemGui& operator=(const EffectRackItemGui& target) {
  1274.         if (_pool == target._pool) return *this;
  1275.         _pool->Dec();
  1276.         _pool = target._pool;
  1277.         _cache = target._cache;
  1278.         _pool->Inc();
  1279.         return *this;
  1280.     }
  1281.     inline EffectRackItemGui_base* _base() {return _cache?_cache:_method_call();}
  1282.  
  1283.     inline bool active();
  1284.     inline void active(bool _newValue);
  1285.     inline std::string type();
  1286.     inline void type(const std::string& _newValue);
  1287.     inline bool addeffect();
  1288.     inline void addeffect(bool _newValue);
  1289.     inline void removeSlot(Arts::EffectRackSlot slot);
  1290.     inline void routeToMaster(Arts::EffectRackSlot slot, bool tomaster);
  1291.     inline Arts::Widget initialize(Arts::Environment::EffectRackItem item);
  1292. };
  1293.  
  1294. class ARTS_EXPORT EffectRackSlot_base : virtual public Arts::Object_base {
  1295. public:
  1296.     static unsigned long _IID; // interface ID
  1297.  
  1298.     static EffectRackSlot_base *_create(const std::string& subClass = "Arts::EffectRackSlot");
  1299.     static EffectRackSlot_base *_fromString(const std::string& objectref);
  1300.     static EffectRackSlot_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1301.  
  1302.     static EffectRackSlot_base *_fromDynamicCast(const Arts::Object& object);
  1303.     inline EffectRackSlot_base *_copy() {
  1304.         assert(_refCnt > 0);
  1305.         _refCnt++;
  1306.         return this;
  1307.     }
  1308.  
  1309.     virtual std::vector<std::string> _defaultPortsIn() const;
  1310.     virtual std::vector<std::string> _defaultPortsOut() const;
  1311.  
  1312.     void *_cast(unsigned long iid);
  1313.  
  1314.     virtual bool removeslot() = 0;
  1315.     virtual void removeslot(bool newValue) = 0;
  1316.     virtual bool tomaster() = 0;
  1317.     virtual void tomaster(bool newValue) = 0;
  1318.     virtual void constructor(Arts::Widget parent, Arts::Widget effect, Arts::EffectRackItemGui effectrackgui) = 0;
  1319. };
  1320.  
  1321. class ARTS_EXPORT EffectRackSlot_stub : virtual public EffectRackSlot_base, virtual public Arts::Object_stub {
  1322. protected:
  1323.     EffectRackSlot_stub();
  1324.  
  1325. public:
  1326.     EffectRackSlot_stub(Arts::Connection *connection, long objectID);
  1327.  
  1328.     bool removeslot();
  1329.     void removeslot(bool newValue);
  1330.     bool tomaster();
  1331.     void tomaster(bool newValue);
  1332.     void constructor(Arts::Widget parent, Arts::Widget effect, Arts::EffectRackItemGui effectrackgui);
  1333. };
  1334.  
  1335. class ARTS_EXPORT EffectRackSlot_skel : virtual public EffectRackSlot_base, virtual public Arts::Object_skel {
  1336. protected:
  1337.     // emitters for change notifications
  1338.     inline void removeslot_changed(bool newValue) {
  1339.         _emit_changed("removeslot_changed",newValue);
  1340.     }
  1341.     inline void tomaster_changed(bool newValue) {
  1342.         _emit_changed("tomaster_changed",newValue);
  1343.     }
  1344.  
  1345. public:
  1346.     EffectRackSlot_skel();
  1347.  
  1348.     static std::string _interfaceNameSkel();
  1349.     std::string _interfaceName();
  1350.     bool _isCompatibleWith(const std::string& interfacename);
  1351.     void _buildMethodTable();
  1352.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1353. };
  1354.  
  1355. }
  1356. #include "reference.h"
  1357. namespace Arts {
  1358. class ARTS_EXPORT EffectRackSlot : public Arts::Object {
  1359. private:
  1360.     static Arts::Object_base* _Creator();
  1361.     EffectRackSlot_base *_cache;
  1362.     inline EffectRackSlot_base *_method_call() {
  1363.         _pool->checkcreate();
  1364.         if(_pool->base) {
  1365.             _cache=(EffectRackSlot_base *)_pool->base->_cast(EffectRackSlot_base::_IID);
  1366.             assert(_cache);
  1367.         }
  1368.         return _cache;
  1369.     }
  1370.  
  1371. protected:
  1372.     inline EffectRackSlot(EffectRackSlot_base* b) : Arts::Object(b), _cache(0) {}
  1373.  
  1374.  
  1375. public:
  1376.     typedef EffectRackSlot_base _base_class;
  1377.  
  1378.     inline EffectRackSlot() : Arts::Object(_Creator), _cache(0) {}
  1379.     inline EffectRackSlot(const Arts::SubClass& s) :
  1380.         Arts::Object(EffectRackSlot_base::_create(s.string())), _cache(0) {}
  1381.     inline EffectRackSlot(const Arts::Reference &r) :
  1382.         Arts::Object(r.isString()?(EffectRackSlot_base::_fromString(r.string())):(EffectRackSlot_base::_fromReference(r.reference(),true))), _cache(0) {}
  1383.     inline EffectRackSlot(const Arts::DynamicCast& c) : Arts::Object(EffectRackSlot_base::_fromDynamicCast(c.object())), _cache(0) {}
  1384.     inline EffectRackSlot(const EffectRackSlot& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1385.     inline EffectRackSlot(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1386.     inline static EffectRackSlot null() {return EffectRackSlot((EffectRackSlot_base*)0);}
  1387.     inline static EffectRackSlot _from_base(EffectRackSlot_base* b) {return EffectRackSlot(b);}
  1388.     inline EffectRackSlot& operator=(const EffectRackSlot& target) {
  1389.         if (_pool == target._pool) return *this;
  1390.         _pool->Dec();
  1391.         _pool = target._pool;
  1392.         _cache = target._cache;
  1393.         _pool->Inc();
  1394.         return *this;
  1395.     }
  1396.     inline EffectRackSlot_base* _base() {return _cache?_cache:_method_call();}
  1397.  
  1398.     inline bool removeslot();
  1399.     inline void removeslot(bool _newValue);
  1400.     inline bool tomaster();
  1401.     inline void tomaster(bool _newValue);
  1402.     inline EffectRackSlot(Arts::Widget parent, Arts::Widget effect, Arts::EffectRackItemGui effectrackgui);
  1403. };
  1404.  
  1405. class ARTS_EXPORT MixerGuiFactory_base : virtual public Arts::GuiFactory_base {
  1406. public:
  1407.     static unsigned long _IID; // interface ID
  1408.  
  1409.     static MixerGuiFactory_base *_create(const std::string& subClass = "Arts::MixerGuiFactory");
  1410.     static MixerGuiFactory_base *_fromString(const std::string& objectref);
  1411.     static MixerGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1412.  
  1413.     static MixerGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  1414.     inline MixerGuiFactory_base *_copy() {
  1415.         assert(_refCnt > 0);
  1416.         _refCnt++;
  1417.         return this;
  1418.     }
  1419.  
  1420.     virtual std::vector<std::string> _defaultPortsIn() const;
  1421.     virtual std::vector<std::string> _defaultPortsOut() const;
  1422.  
  1423.     void *_cast(unsigned long iid);
  1424.  
  1425. };
  1426.  
  1427. class ARTS_EXPORT MixerGuiFactory_stub : virtual public MixerGuiFactory_base, virtual public Arts::GuiFactory_stub {
  1428. protected:
  1429.     MixerGuiFactory_stub();
  1430.  
  1431. public:
  1432.     MixerGuiFactory_stub(Arts::Connection *connection, long objectID);
  1433.  
  1434. };
  1435.  
  1436. class ARTS_EXPORT MixerGuiFactory_skel : virtual public MixerGuiFactory_base, virtual public Arts::GuiFactory_skel {
  1437. public:
  1438.     MixerGuiFactory_skel();
  1439.  
  1440.     static std::string _interfaceNameSkel();
  1441.     std::string _interfaceName();
  1442.     bool _isCompatibleWith(const std::string& interfacename);
  1443.     void _buildMethodTable();
  1444.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1445. };
  1446.  
  1447. }
  1448. #include "reference.h"
  1449. namespace Arts {
  1450. class ARTS_EXPORT MixerGuiFactory : public Arts::Object {
  1451. private:
  1452.     static Arts::Object_base* _Creator();
  1453.     MixerGuiFactory_base *_cache;
  1454.     inline MixerGuiFactory_base *_method_call() {
  1455.         _pool->checkcreate();
  1456.         if(_pool->base) {
  1457.             _cache=(MixerGuiFactory_base *)_pool->base->_cast(MixerGuiFactory_base::_IID);
  1458.             assert(_cache);
  1459.         }
  1460.         return _cache;
  1461.     }
  1462.  
  1463. protected:
  1464.     inline MixerGuiFactory(MixerGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  1465.  
  1466.  
  1467. public:
  1468.     typedef MixerGuiFactory_base _base_class;
  1469.  
  1470.     inline MixerGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  1471.     inline MixerGuiFactory(const Arts::SubClass& s) :
  1472.         Arts::Object(MixerGuiFactory_base::_create(s.string())), _cache(0) {}
  1473.     inline MixerGuiFactory(const Arts::Reference &r) :
  1474.         Arts::Object(r.isString()?(MixerGuiFactory_base::_fromString(r.string())):(MixerGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  1475.     inline MixerGuiFactory(const Arts::DynamicCast& c) : Arts::Object(MixerGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  1476.     inline MixerGuiFactory(const MixerGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1477.     inline MixerGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1478.     inline static MixerGuiFactory null() {return MixerGuiFactory((MixerGuiFactory_base*)0);}
  1479.     inline static MixerGuiFactory _from_base(MixerGuiFactory_base* b) {return MixerGuiFactory(b);}
  1480.     inline MixerGuiFactory& operator=(const MixerGuiFactory& target) {
  1481.         if (_pool == target._pool) return *this;
  1482.         _pool->Dec();
  1483.         _pool = target._pool;
  1484.         _cache = target._cache;
  1485.         _pool->Inc();
  1486.         return *this;
  1487.     }
  1488.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  1489.     inline MixerGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  1490.  
  1491.     inline Arts::Widget createGui(Arts::Object runningObject);
  1492. };
  1493.  
  1494. class ARTS_EXPORT EffectRackGuiFactory_base : virtual public Arts::GuiFactory_base {
  1495. public:
  1496.     static unsigned long _IID; // interface ID
  1497.  
  1498.     static EffectRackGuiFactory_base *_create(const std::string& subClass = "Arts::EffectRackGuiFactory");
  1499.     static EffectRackGuiFactory_base *_fromString(const std::string& objectref);
  1500.     static EffectRackGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1501.  
  1502.     static EffectRackGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  1503.     inline EffectRackGuiFactory_base *_copy() {
  1504.         assert(_refCnt > 0);
  1505.         _refCnt++;
  1506.         return this;
  1507.     }
  1508.  
  1509.     virtual std::vector<std::string> _defaultPortsIn() const;
  1510.     virtual std::vector<std::string> _defaultPortsOut() const;
  1511.  
  1512.     void *_cast(unsigned long iid);
  1513.  
  1514. };
  1515.  
  1516. class ARTS_EXPORT EffectRackGuiFactory_stub : virtual public EffectRackGuiFactory_base, virtual public Arts::GuiFactory_stub {
  1517. protected:
  1518.     EffectRackGuiFactory_stub();
  1519.  
  1520. public:
  1521.     EffectRackGuiFactory_stub(Arts::Connection *connection, long objectID);
  1522.  
  1523. };
  1524.  
  1525. class ARTS_EXPORT EffectRackGuiFactory_skel : virtual public EffectRackGuiFactory_base, virtual public Arts::GuiFactory_skel {
  1526. public:
  1527.     EffectRackGuiFactory_skel();
  1528.  
  1529.     static std::string _interfaceNameSkel();
  1530.     std::string _interfaceName();
  1531.     bool _isCompatibleWith(const std::string& interfacename);
  1532.     void _buildMethodTable();
  1533.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1534. };
  1535.  
  1536. }
  1537. #include "reference.h"
  1538. namespace Arts {
  1539. class ARTS_EXPORT EffectRackGuiFactory : public Arts::Object {
  1540. private:
  1541.     static Arts::Object_base* _Creator();
  1542.     EffectRackGuiFactory_base *_cache;
  1543.     inline EffectRackGuiFactory_base *_method_call() {
  1544.         _pool->checkcreate();
  1545.         if(_pool->base) {
  1546.             _cache=(EffectRackGuiFactory_base *)_pool->base->_cast(EffectRackGuiFactory_base::_IID);
  1547.             assert(_cache);
  1548.         }
  1549.         return _cache;
  1550.     }
  1551.  
  1552. protected:
  1553.     inline EffectRackGuiFactory(EffectRackGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  1554.  
  1555.  
  1556. public:
  1557.     typedef EffectRackGuiFactory_base _base_class;
  1558.  
  1559.     inline EffectRackGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  1560.     inline EffectRackGuiFactory(const Arts::SubClass& s) :
  1561.         Arts::Object(EffectRackGuiFactory_base::_create(s.string())), _cache(0) {}
  1562.     inline EffectRackGuiFactory(const Arts::Reference &r) :
  1563.         Arts::Object(r.isString()?(EffectRackGuiFactory_base::_fromString(r.string())):(EffectRackGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  1564.     inline EffectRackGuiFactory(const Arts::DynamicCast& c) : Arts::Object(EffectRackGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  1565.     inline EffectRackGuiFactory(const EffectRackGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1566.     inline EffectRackGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1567.     inline static EffectRackGuiFactory null() {return EffectRackGuiFactory((EffectRackGuiFactory_base*)0);}
  1568.     inline static EffectRackGuiFactory _from_base(EffectRackGuiFactory_base* b) {return EffectRackGuiFactory(b);}
  1569.     inline EffectRackGuiFactory& operator=(const EffectRackGuiFactory& target) {
  1570.         if (_pool == target._pool) return *this;
  1571.         _pool->Dec();
  1572.         _pool = target._pool;
  1573.         _cache = target._cache;
  1574.         _pool->Inc();
  1575.         return *this;
  1576.     }
  1577.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  1578.     inline EffectRackGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  1579.  
  1580.     inline Arts::Widget createGui(Arts::Object runningObject);
  1581. };
  1582.  
  1583. }
  1584. // Forward wrapper calls to _base classes:
  1585.  
  1586. inline void Arts::Environment::Context::addEntry(const std::string& name, Arts::Object obj)
  1587. {
  1588.      _cache?static_cast<Arts::Environment::Context_base*>(_cache)->addEntry(name, obj):static_cast<Arts::Environment::Context_base*>(_method_call())->addEntry(name, obj);
  1589. }
  1590.  
  1591. inline std::string Arts::Environment::Context::lookupEntry(Arts::Object obj)
  1592. {
  1593.     return _cache?static_cast<Arts::Environment::Context_base*>(_cache)->lookupEntry(obj):static_cast<Arts::Environment::Context_base*>(_method_call())->lookupEntry(obj);
  1594. }
  1595.  
  1596. inline void Arts::Environment::Context::removeEntry(Arts::Object obj)
  1597. {
  1598.      _cache?static_cast<Arts::Environment::Context_base*>(_cache)->removeEntry(obj):static_cast<Arts::Environment::Context_base*>(_method_call())->removeEntry(obj);
  1599. }
  1600.  
  1601. inline std::string Arts::Environment::Container::dataDirectory()
  1602. {
  1603.     return _cache?static_cast<Arts::Environment::Container_base*>(_cache)->dataDirectory():static_cast<Arts::Environment::Container_base*>(_method_call())->dataDirectory();
  1604. }
  1605.  
  1606. inline void Arts::Environment::Container::dataDirectory(const std::string& _newValue)
  1607. {
  1608.      _cache?static_cast<Arts::Environment::Container_base*>(_cache)->dataDirectory(_newValue):static_cast<Arts::Environment::Container_base*>(_method_call())->dataDirectory(_newValue);
  1609. }
  1610.  
  1611. inline Arts::Environment::Context Arts::Environment::Container::context()
  1612. {
  1613.     return _cache?static_cast<Arts::Environment::Container_base*>(_cache)->context():static_cast<Arts::Environment::Container_base*>(_method_call())->context();
  1614. }
  1615.  
  1616. inline void Arts::Environment::Container::context(Arts::Environment::Context _newValue)
  1617. {
  1618.      _cache?static_cast<Arts::Environment::Container_base*>(_cache)->context(_newValue):static_cast<Arts::Environment::Container_base*>(_method_call())->context(_newValue);
  1619. }
  1620.  
  1621. inline std::vector<Arts::Environment::Item> * Arts::Environment::Container::items()
  1622. {
  1623.     return _cache?static_cast<Arts::Environment::Container_base*>(_cache)->items():static_cast<Arts::Environment::Container_base*>(_method_call())->items();
  1624. }
  1625.  
  1626. inline std::vector<std::string> * Arts::Environment::Container::saveToList()
  1627. {
  1628.     return _cache?static_cast<Arts::Environment::Container_base*>(_cache)->saveToList():static_cast<Arts::Environment::Container_base*>(_method_call())->saveToList();
  1629. }
  1630.  
  1631. inline void Arts::Environment::Container::loadFromList(const std::vector<std::string>& strlist)
  1632. {
  1633.      _cache?static_cast<Arts::Environment::Container_base*>(_cache)->loadFromList(strlist):static_cast<Arts::Environment::Container_base*>(_method_call())->loadFromList(strlist);
  1634. }
  1635.  
  1636. inline void Arts::Environment::Container::addItem(Arts::Environment::Item item)
  1637. {
  1638.      _cache?static_cast<Arts::Environment::Container_base*>(_cache)->addItem(item):static_cast<Arts::Environment::Container_base*>(_method_call())->addItem(item);
  1639. }
  1640.  
  1641. inline Arts::Environment::Item Arts::Environment::Container::createItem(const std::string& name)
  1642. {
  1643.     return _cache?static_cast<Arts::Environment::Container_base*>(_cache)->createItem(name):static_cast<Arts::Environment::Container_base*>(_method_call())->createItem(name);
  1644. }
  1645.  
  1646. inline void Arts::Environment::Container::removeItem(Arts::Environment::Item item)
  1647. {
  1648.      _cache?static_cast<Arts::Environment::Container_base*>(_cache)->removeItem(item):static_cast<Arts::Environment::Container_base*>(_method_call())->removeItem(item);
  1649. }
  1650.  
  1651. inline bool Arts::Environment::Item::active()
  1652. {
  1653.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->active():static_cast<Arts::Environment::Item_base*>(_method_call())->active();
  1654. }
  1655.  
  1656. inline Arts::Environment::Container Arts::Environment::Item::parent()
  1657. {
  1658.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->parent():static_cast<Arts::Environment::Item_base*>(_method_call())->parent();
  1659. }
  1660.  
  1661. inline void Arts::Environment::Item::setContainer(Arts::Environment::Container container)
  1662. {
  1663.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->setContainer(container):static_cast<Arts::Environment::Item_base*>(_method_call())->setContainer(container);
  1664. }
  1665.  
  1666. inline std::vector<std::string> * Arts::Environment::Item::saveToList()
  1667. {
  1668.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->saveToList():static_cast<Arts::Environment::Item_base*>(_method_call())->saveToList();
  1669. }
  1670.  
  1671. inline void Arts::Environment::Item::loadFromList(const std::vector<std::string>& strlist)
  1672. {
  1673.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->loadFromList(strlist):static_cast<Arts::Environment::Item_base*>(_method_call())->loadFromList(strlist);
  1674. }
  1675.  
  1676. inline bool Arts::Environment::InstrumentItem::active()
  1677. {
  1678.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->active():static_cast<Arts::Environment::Item_base*>(_method_call())->active();
  1679. }
  1680.  
  1681. inline Arts::Environment::Container Arts::Environment::InstrumentItem::parent()
  1682. {
  1683.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->parent():static_cast<Arts::Environment::Item_base*>(_method_call())->parent();
  1684. }
  1685.  
  1686. inline void Arts::Environment::InstrumentItem::setContainer(Arts::Environment::Container container)
  1687. {
  1688.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->setContainer(container):static_cast<Arts::Environment::Item_base*>(_method_call())->setContainer(container);
  1689. }
  1690.  
  1691. inline std::vector<std::string> * Arts::Environment::InstrumentItem::saveToList()
  1692. {
  1693.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->saveToList():static_cast<Arts::Environment::Item_base*>(_method_call())->saveToList();
  1694. }
  1695.  
  1696. inline void Arts::Environment::InstrumentItem::loadFromList(const std::vector<std::string>& strlist)
  1697. {
  1698.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->loadFromList(strlist):static_cast<Arts::Environment::Item_base*>(_method_call())->loadFromList(strlist);
  1699. }
  1700.  
  1701. inline Arts::MidiPort Arts::Environment::InstrumentItem::port()
  1702. {
  1703.     return _cache?static_cast<Arts::Environment::InstrumentItem_base*>(_cache)->port():static_cast<Arts::Environment::InstrumentItem_base*>(_method_call())->port();
  1704. }
  1705.  
  1706. inline std::string Arts::Environment::InstrumentItem::filename()
  1707. {
  1708.     return _cache?static_cast<Arts::Environment::InstrumentItem_base*>(_cache)->filename():static_cast<Arts::Environment::InstrumentItem_base*>(_method_call())->filename();
  1709. }
  1710.  
  1711. inline void Arts::Environment::InstrumentItem::filename(const std::string& _newValue)
  1712. {
  1713.      _cache?static_cast<Arts::Environment::InstrumentItem_base*>(_cache)->filename(_newValue):static_cast<Arts::Environment::InstrumentItem_base*>(_method_call())->filename(_newValue);
  1714. }
  1715.  
  1716. inline std::string Arts::Environment::InstrumentItem::busname()
  1717. {
  1718.     return _cache?static_cast<Arts::Environment::InstrumentItem_base*>(_cache)->busname():static_cast<Arts::Environment::InstrumentItem_base*>(_method_call())->busname();
  1719. }
  1720.  
  1721. inline void Arts::Environment::InstrumentItem::busname(const std::string& _newValue)
  1722. {
  1723.      _cache?static_cast<Arts::Environment::InstrumentItem_base*>(_cache)->busname(_newValue):static_cast<Arts::Environment::InstrumentItem_base*>(_method_call())->busname(_newValue);
  1724. }
  1725.  
  1726. inline Arts::Widget Arts::Environment::InstrumentItemGuiFactory::createGui(Arts::Object runningObject)
  1727. {
  1728.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  1729. }
  1730.  
  1731. inline bool Arts::Environment::StereoEffectItem::active()
  1732. {
  1733.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->active():static_cast<Arts::Environment::Item_base*>(_method_call())->active();
  1734. }
  1735.  
  1736. inline Arts::Environment::Container Arts::Environment::StereoEffectItem::parent()
  1737. {
  1738.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->parent():static_cast<Arts::Environment::Item_base*>(_method_call())->parent();
  1739. }
  1740.  
  1741. inline void Arts::Environment::StereoEffectItem::setContainer(Arts::Environment::Container container)
  1742. {
  1743.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->setContainer(container):static_cast<Arts::Environment::Item_base*>(_method_call())->setContainer(container);
  1744. }
  1745.  
  1746. inline std::vector<std::string> * Arts::Environment::StereoEffectItem::saveToList()
  1747. {
  1748.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->saveToList():static_cast<Arts::Environment::Item_base*>(_method_call())->saveToList();
  1749. }
  1750.  
  1751. inline void Arts::Environment::StereoEffectItem::loadFromList(const std::vector<std::string>& strlist)
  1752. {
  1753.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->loadFromList(strlist):static_cast<Arts::Environment::Item_base*>(_method_call())->loadFromList(strlist);
  1754. }
  1755.  
  1756. inline Arts::SynthModule Arts::Environment::StereoEffectItem::effect()
  1757. {
  1758.     return _cache?static_cast<Arts::Environment::StereoEffectItem_base*>(_cache)->effect():static_cast<Arts::Environment::StereoEffectItem_base*>(_method_call())->effect();
  1759. }
  1760.  
  1761. inline void Arts::Environment::StereoEffectItem::effect(Arts::SynthModule _newValue)
  1762. {
  1763.      _cache?static_cast<Arts::Environment::StereoEffectItem_base*>(_cache)->effect(_newValue):static_cast<Arts::Environment::StereoEffectItem_base*>(_method_call())->effect(_newValue);
  1764. }
  1765.  
  1766. inline Arts::StereoEffectStack Arts::Environment::StereoEffectItem::stack()
  1767. {
  1768.     return _cache?static_cast<Arts::Environment::StereoEffectItem_base*>(_cache)->stack():static_cast<Arts::Environment::StereoEffectItem_base*>(_method_call())->stack();
  1769. }
  1770.  
  1771. inline void Arts::Environment::StereoEffectItem::stack(Arts::StereoEffectStack _newValue)
  1772. {
  1773.      _cache?static_cast<Arts::Environment::StereoEffectItem_base*>(_cache)->stack(_newValue):static_cast<Arts::Environment::StereoEffectItem_base*>(_method_call())->stack(_newValue);
  1774. }
  1775.  
  1776. inline Arts::AutoSuspendState Arts::Environment::MixerChannel::autoSuspend()
  1777. {
  1778.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1779. }
  1780.  
  1781. inline void Arts::Environment::MixerChannel::start()
  1782. {
  1783.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1784. }
  1785.  
  1786. inline void Arts::Environment::MixerChannel::stop()
  1787. {
  1788.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1789. }
  1790.  
  1791. inline void Arts::Environment::MixerChannel::streamInit()
  1792. {
  1793.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1794. }
  1795.  
  1796. inline void Arts::Environment::MixerChannel::streamStart()
  1797. {
  1798.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1799. }
  1800.  
  1801. inline void Arts::Environment::MixerChannel::streamEnd()
  1802. {
  1803.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1804. }
  1805.  
  1806. inline std::string Arts::Environment::MixerChannel::name()
  1807. {
  1808.     return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
  1809. }
  1810.  
  1811. inline void Arts::Environment::MixerChannel::name(const std::string& _newValue)
  1812. {
  1813.      _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
  1814. }
  1815.  
  1816. inline bool Arts::Environment::MixerItem::active()
  1817. {
  1818.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->active():static_cast<Arts::Environment::Item_base*>(_method_call())->active();
  1819. }
  1820.  
  1821. inline Arts::Environment::Container Arts::Environment::MixerItem::parent()
  1822. {
  1823.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->parent():static_cast<Arts::Environment::Item_base*>(_method_call())->parent();
  1824. }
  1825.  
  1826. inline void Arts::Environment::MixerItem::setContainer(Arts::Environment::Container container)
  1827. {
  1828.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->setContainer(container):static_cast<Arts::Environment::Item_base*>(_method_call())->setContainer(container);
  1829. }
  1830.  
  1831. inline std::vector<std::string> * Arts::Environment::MixerItem::saveToList()
  1832. {
  1833.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->saveToList():static_cast<Arts::Environment::Item_base*>(_method_call())->saveToList();
  1834. }
  1835.  
  1836. inline void Arts::Environment::MixerItem::loadFromList(const std::vector<std::string>& strlist)
  1837. {
  1838.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->loadFromList(strlist):static_cast<Arts::Environment::Item_base*>(_method_call())->loadFromList(strlist);
  1839. }
  1840.  
  1841. inline std::vector<Arts::Environment::MixerChannel> * Arts::Environment::MixerItem::channels()
  1842. {
  1843.     return _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->channels():static_cast<Arts::Environment::MixerItem_base*>(_method_call())->channels();
  1844. }
  1845.  
  1846. inline long Arts::Environment::MixerItem::channelCount()
  1847. {
  1848.     return _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->channelCount():static_cast<Arts::Environment::MixerItem_base*>(_method_call())->channelCount();
  1849. }
  1850.  
  1851. inline void Arts::Environment::MixerItem::channelCount(long _newValue)
  1852. {
  1853.      _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->channelCount(_newValue):static_cast<Arts::Environment::MixerItem_base*>(_method_call())->channelCount(_newValue);
  1854. }
  1855.  
  1856. inline std::string Arts::Environment::MixerItem::name()
  1857. {
  1858.     return _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->name():static_cast<Arts::Environment::MixerItem_base*>(_method_call())->name();
  1859. }
  1860.  
  1861. inline void Arts::Environment::MixerItem::name(const std::string& _newValue)
  1862. {
  1863.      _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerItem_base*>(_method_call())->name(_newValue);
  1864. }
  1865.  
  1866. inline std::string Arts::Environment::MixerItem::type()
  1867. {
  1868.     return _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->type():static_cast<Arts::Environment::MixerItem_base*>(_method_call())->type();
  1869. }
  1870.  
  1871. inline void Arts::Environment::MixerItem::type(const std::string& _newValue)
  1872. {
  1873.      _cache?static_cast<Arts::Environment::MixerItem_base*>(_cache)->type(_newValue):static_cast<Arts::Environment::MixerItem_base*>(_method_call())->type(_newValue);
  1874. }
  1875.  
  1876. inline bool Arts::Environment::EffectRackItem::active()
  1877. {
  1878.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->active():static_cast<Arts::Environment::Item_base*>(_method_call())->active();
  1879. }
  1880.  
  1881. inline Arts::Environment::Container Arts::Environment::EffectRackItem::parent()
  1882. {
  1883.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->parent():static_cast<Arts::Environment::Item_base*>(_method_call())->parent();
  1884. }
  1885.  
  1886. inline void Arts::Environment::EffectRackItem::setContainer(Arts::Environment::Container container)
  1887. {
  1888.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->setContainer(container):static_cast<Arts::Environment::Item_base*>(_method_call())->setContainer(container);
  1889. }
  1890.  
  1891. inline std::vector<std::string> * Arts::Environment::EffectRackItem::saveToList()
  1892. {
  1893.     return _cache?static_cast<Arts::Environment::Item_base*>(_cache)->saveToList():static_cast<Arts::Environment::Item_base*>(_method_call())->saveToList();
  1894. }
  1895.  
  1896. inline void Arts::Environment::EffectRackItem::loadFromList(const std::vector<std::string>& strlist)
  1897. {
  1898.      _cache?static_cast<Arts::Environment::Item_base*>(_cache)->loadFromList(strlist):static_cast<Arts::Environment::Item_base*>(_method_call())->loadFromList(strlist);
  1899. }
  1900.  
  1901. inline std::vector<Arts::StereoEffect> * Arts::Environment::EffectRackItem::effects()
  1902. {
  1903.     return _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->effects():static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->effects();
  1904. }
  1905.  
  1906. inline long Arts::Environment::EffectRackItem::effectCount()
  1907. {
  1908.     return _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->effectCount():static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->effectCount();
  1909. }
  1910.  
  1911. inline std::string Arts::Environment::EffectRackItem::name()
  1912. {
  1913.     return _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->name():static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->name();
  1914. }
  1915.  
  1916. inline void Arts::Environment::EffectRackItem::name(const std::string& _newValue)
  1917. {
  1918.      _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->name(_newValue);
  1919. }
  1920.  
  1921. inline Arts::StereoEffect Arts::Environment::EffectRackItem::createEffect(const std::string& type, const std::string& name)
  1922. {
  1923.     return _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->createEffect(type, name):static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->createEffect(type, name);
  1924. }
  1925.  
  1926. inline void Arts::Environment::EffectRackItem::delEffect(long pos)
  1927. {
  1928.      _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->delEffect(pos):static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->delEffect(pos);
  1929. }
  1930.  
  1931. inline void Arts::Environment::EffectRackItem::routeToMaster(long pos, bool tomaster)
  1932. {
  1933.      _cache?static_cast<Arts::Environment::EffectRackItem_base*>(_cache)->routeToMaster(pos, tomaster):static_cast<Arts::Environment::EffectRackItem_base*>(_method_call())->routeToMaster(pos, tomaster);
  1934. }
  1935.  
  1936. inline bool Arts::MixerItemGui::active()
  1937. {
  1938.     return _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->active():static_cast<Arts::MixerItemGui_base*>(_method_call())->active();
  1939. }
  1940.  
  1941. inline void Arts::MixerItemGui::active(bool _newValue)
  1942. {
  1943.      _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->active(_newValue):static_cast<Arts::MixerItemGui_base*>(_method_call())->active(_newValue);
  1944. }
  1945.  
  1946. inline long Arts::MixerItemGui::channelCount()
  1947. {
  1948.     return _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->channelCount():static_cast<Arts::MixerItemGui_base*>(_method_call())->channelCount();
  1949. }
  1950.  
  1951. inline void Arts::MixerItemGui::channelCount(long _newValue)
  1952. {
  1953.      _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->channelCount(_newValue):static_cast<Arts::MixerItemGui_base*>(_method_call())->channelCount(_newValue);
  1954. }
  1955.  
  1956. inline std::string Arts::MixerItemGui::type()
  1957. {
  1958.     return _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->type():static_cast<Arts::MixerItemGui_base*>(_method_call())->type();
  1959. }
  1960.  
  1961. inline void Arts::MixerItemGui::type(const std::string& _newValue)
  1962. {
  1963.      _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->type(_newValue):static_cast<Arts::MixerItemGui_base*>(_method_call())->type(_newValue);
  1964. }
  1965.  
  1966. inline Arts::Widget Arts::MixerItemGui::initialize(Arts::Environment::MixerItem item)
  1967. {
  1968.     return _cache?static_cast<Arts::MixerItemGui_base*>(_cache)->initialize(item):static_cast<Arts::MixerItemGui_base*>(_method_call())->initialize(item);
  1969. }
  1970.  
  1971. inline bool Arts::EffectRackItemGui::active()
  1972. {
  1973.     return _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->active():static_cast<Arts::EffectRackItemGui_base*>(_method_call())->active();
  1974. }
  1975.  
  1976. inline void Arts::EffectRackItemGui::active(bool _newValue)
  1977. {
  1978.      _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->active(_newValue):static_cast<Arts::EffectRackItemGui_base*>(_method_call())->active(_newValue);
  1979. }
  1980.  
  1981. inline std::string Arts::EffectRackItemGui::type()
  1982. {
  1983.     return _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->type():static_cast<Arts::EffectRackItemGui_base*>(_method_call())->type();
  1984. }
  1985.  
  1986. inline void Arts::EffectRackItemGui::type(const std::string& _newValue)
  1987. {
  1988.      _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->type(_newValue):static_cast<Arts::EffectRackItemGui_base*>(_method_call())->type(_newValue);
  1989. }
  1990.  
  1991. inline bool Arts::EffectRackItemGui::addeffect()
  1992. {
  1993.     return _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->addeffect():static_cast<Arts::EffectRackItemGui_base*>(_method_call())->addeffect();
  1994. }
  1995.  
  1996. inline void Arts::EffectRackItemGui::addeffect(bool _newValue)
  1997. {
  1998.      _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->addeffect(_newValue):static_cast<Arts::EffectRackItemGui_base*>(_method_call())->addeffect(_newValue);
  1999. }
  2000.  
  2001. inline void Arts::EffectRackItemGui::removeSlot(Arts::EffectRackSlot slot)
  2002. {
  2003.      _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->removeSlot(slot):static_cast<Arts::EffectRackItemGui_base*>(_method_call())->removeSlot(slot);
  2004. }
  2005.  
  2006. inline void Arts::EffectRackItemGui::routeToMaster(Arts::EffectRackSlot slot, bool tomaster)
  2007. {
  2008.      _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->routeToMaster(slot, tomaster):static_cast<Arts::EffectRackItemGui_base*>(_method_call())->routeToMaster(slot, tomaster);
  2009. }
  2010.  
  2011. inline Arts::Widget Arts::EffectRackItemGui::initialize(Arts::Environment::EffectRackItem item)
  2012. {
  2013.     return _cache?static_cast<Arts::EffectRackItemGui_base*>(_cache)->initialize(item):static_cast<Arts::EffectRackItemGui_base*>(_method_call())->initialize(item);
  2014. }
  2015.  
  2016. inline bool Arts::EffectRackSlot::removeslot()
  2017. {
  2018.     return _cache?static_cast<Arts::EffectRackSlot_base*>(_cache)->removeslot():static_cast<Arts::EffectRackSlot_base*>(_method_call())->removeslot();
  2019. }
  2020.  
  2021. inline void Arts::EffectRackSlot::removeslot(bool _newValue)
  2022. {
  2023.      _cache?static_cast<Arts::EffectRackSlot_base*>(_cache)->removeslot(_newValue):static_cast<Arts::EffectRackSlot_base*>(_method_call())->removeslot(_newValue);
  2024. }
  2025.  
  2026. inline bool Arts::EffectRackSlot::tomaster()
  2027. {
  2028.     return _cache?static_cast<Arts::EffectRackSlot_base*>(_cache)->tomaster():static_cast<Arts::EffectRackSlot_base*>(_method_call())->tomaster();
  2029. }
  2030.  
  2031. inline void Arts::EffectRackSlot::tomaster(bool _newValue)
  2032. {
  2033.      _cache?static_cast<Arts::EffectRackSlot_base*>(_cache)->tomaster(_newValue):static_cast<Arts::EffectRackSlot_base*>(_method_call())->tomaster(_newValue);
  2034. }
  2035.  
  2036. inline Arts::EffectRackSlot::EffectRackSlot(Arts::Widget parent, Arts::Widget effect, Arts::EffectRackItemGui effectrackgui)
  2037.         : Arts::Object(EffectRackSlot_base::_create())
  2038. {
  2039.     static_cast<Arts::EffectRackSlot_base*>(_method_call())->constructor(parent, effect, effectrackgui);
  2040. }
  2041.  
  2042. inline Arts::Widget Arts::MixerGuiFactory::createGui(Arts::Object runningObject)
  2043. {
  2044.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2045. }
  2046.  
  2047. inline Arts::Widget Arts::EffectRackGuiFactory::createGui(Arts::Object runningObject)
  2048. {
  2049.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  2050. }
  2051.  
  2052. #endif /* ARTSMODULESCOMMON_H */
  2053.