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 / artsmidi.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-24  |  56.2 KB  |  1,619 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSMIDI_H
  4. #define ARTSMIDI_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsflow.h"
  12.  
  13. namespace Arts {
  14. enum MidiCommandStatus {mcsCommandMask = 240, mcsChannelMask = 15, mcsNoteOff = 128, mcsNoteOn = 144, mcsKeyPressure = 160, mcsParameter = 176, mcsProgram = 192, mcsChannelPressure = 208, mcsPitchWheel = 224};
  15. enum MidiCommandParameter {mcpSustain = 64, mcpAllNotesOff = 123};
  16. enum MidiClientDirection {mcdPlay = 0, mcdRecord = 1};
  17. enum MidiClientType {mctDestination = 0, mctApplication = 1};
  18. }
  19. namespace Arts {
  20. class ARTS_EXPORT TimeStamp : public Arts::Type {
  21. public:
  22.     TimeStamp();
  23.     TimeStamp(long _a_sec, long _a_usec);
  24.     TimeStamp(Arts::Buffer& stream);
  25.     TimeStamp(const TimeStamp& copyType);
  26.     TimeStamp& operator=(const TimeStamp& assignType);
  27.     long sec;
  28.     long usec;
  29.  
  30. // marshalling functions
  31.     void readType(Arts::Buffer& stream);
  32.     void writeType(Arts::Buffer& stream) const;
  33.     std::string _typeName() const;
  34. };
  35.  
  36. class ARTS_EXPORT MidiCommand : public Arts::Type {
  37. public:
  38.     MidiCommand();
  39.     MidiCommand(Arts::mcopbyte _a_status, Arts::mcopbyte _a_data1, Arts::mcopbyte _a_data2);
  40.     MidiCommand(Arts::Buffer& stream);
  41.     MidiCommand(const MidiCommand& copyType);
  42.     MidiCommand& operator=(const MidiCommand& assignType);
  43.     Arts::mcopbyte status;
  44.     Arts::mcopbyte data1;
  45.     Arts::mcopbyte data2;
  46.  
  47. // marshalling functions
  48.     void readType(Arts::Buffer& stream);
  49.     void writeType(Arts::Buffer& stream) const;
  50.     std::string _typeName() const;
  51. };
  52.  
  53. class ARTS_EXPORT MidiEvent : public Arts::Type {
  54. public:
  55.     MidiEvent();
  56.     MidiEvent(const Arts::TimeStamp& _a_time, const Arts::MidiCommand& _a_command);
  57.     MidiEvent(Arts::Buffer& stream);
  58.     MidiEvent(const MidiEvent& copyType);
  59.     MidiEvent& operator=(const MidiEvent& assignType);
  60.     Arts::TimeStamp time;
  61.     Arts::MidiCommand command;
  62.  
  63. // marshalling functions
  64.     void readType(Arts::Buffer& stream);
  65.     void writeType(Arts::Buffer& stream) const;
  66.     std::string _typeName() const;
  67. };
  68.  
  69. class ARTS_EXPORT MidiClientInfo : public Arts::Type {
  70. public:
  71.     MidiClientInfo();
  72.     MidiClientInfo(long _a_ID, const std::vector<long>& _a_connections, Arts::MidiClientDirection _a_direction, Arts::MidiClientType _a_type, const std::string& _a_title, const std::string& _a_autoRestoreID);
  73.     MidiClientInfo(Arts::Buffer& stream);
  74.     MidiClientInfo(const MidiClientInfo& copyType);
  75.     MidiClientInfo& operator=(const MidiClientInfo& assignType);
  76.     long ID;
  77.     std::vector<long> connections;
  78.     Arts::MidiClientDirection direction;
  79.     Arts::MidiClientType type;
  80.     std::string title;
  81.     std::string autoRestoreID;
  82.  
  83. // marshalling functions
  84.     void readType(Arts::Buffer& stream);
  85.     void writeType(Arts::Buffer& stream) const;
  86.     std::string _typeName() const;
  87. };
  88.  
  89. }
  90. namespace Arts {
  91. class MidiPort;
  92. class MidiClient;
  93. class MidiSyncGroup;
  94. class MidiManager;
  95. class MidiTest;
  96. class RawMidiPort;
  97. class AlsaMidiGateway;
  98. class AlsaMidiPort;
  99. class AudioSync;
  100. class MidiTimer;
  101. class SystemMidiTimer;
  102. class AudioMidiTimer;
  103.  
  104. class ARTS_EXPORT MidiPort_base : virtual public Arts::Object_base {
  105. public:
  106.     static unsigned long _IID; // interface ID
  107.  
  108.     static MidiPort_base *_create(const std::string& subClass = "Arts::MidiPort");
  109.     static MidiPort_base *_fromString(const std::string& objectref);
  110.     static MidiPort_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  111.  
  112.     static MidiPort_base *_fromDynamicCast(const Arts::Object& object);
  113.     inline MidiPort_base *_copy() {
  114.         assert(_refCnt > 0);
  115.         _refCnt++;
  116.         return this;
  117.     }
  118.  
  119.     virtual std::vector<std::string> _defaultPortsIn() const;
  120.     virtual std::vector<std::string> _defaultPortsOut() const;
  121.  
  122.     void *_cast(unsigned long iid);
  123.  
  124.     virtual Arts::TimeStamp time() = 0;
  125.     virtual Arts::TimeStamp playTime() = 0;
  126.     virtual void processCommand(const Arts::MidiCommand& command) = 0;
  127.     virtual void processEvent(const Arts::MidiEvent& event) = 0;
  128. };
  129.  
  130. class ARTS_EXPORT MidiPort_stub : virtual public MidiPort_base, virtual public Arts::Object_stub {
  131. protected:
  132.     MidiPort_stub();
  133.  
  134. public:
  135.     MidiPort_stub(Arts::Connection *connection, long objectID);
  136.  
  137.     Arts::TimeStamp time();
  138.     Arts::TimeStamp playTime();
  139.     void processCommand(const Arts::MidiCommand& command);
  140.     void processEvent(const Arts::MidiEvent& event);
  141. };
  142.  
  143. class ARTS_EXPORT MidiPort_skel : virtual public MidiPort_base, virtual public Arts::Object_skel {
  144. public:
  145.     MidiPort_skel();
  146.  
  147.     static std::string _interfaceNameSkel();
  148.     std::string _interfaceName();
  149.     bool _isCompatibleWith(const std::string& interfacename);
  150.     void _buildMethodTable();
  151.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  152. };
  153.  
  154. }
  155. #include "reference.h"
  156. namespace Arts {
  157. class ARTS_EXPORT MidiPort : public Arts::Object {
  158. private:
  159.     static Arts::Object_base* _Creator();
  160.     MidiPort_base *_cache;
  161.     inline MidiPort_base *_method_call() {
  162.         _pool->checkcreate();
  163.         if(_pool->base) {
  164.             _cache=(MidiPort_base *)_pool->base->_cast(MidiPort_base::_IID);
  165.             assert(_cache);
  166.         }
  167.         return _cache;
  168.     }
  169.  
  170. protected:
  171.     inline MidiPort(MidiPort_base* b) : Arts::Object(b), _cache(0) {}
  172.  
  173.  
  174. public:
  175.     typedef MidiPort_base _base_class;
  176.  
  177.     inline MidiPort() : Arts::Object(_Creator), _cache(0) {}
  178.     inline MidiPort(const Arts::SubClass& s) :
  179.         Arts::Object(MidiPort_base::_create(s.string())), _cache(0) {}
  180.     inline MidiPort(const Arts::Reference &r) :
  181.         Arts::Object(r.isString()?(MidiPort_base::_fromString(r.string())):(MidiPort_base::_fromReference(r.reference(),true))), _cache(0) {}
  182.     inline MidiPort(const Arts::DynamicCast& c) : Arts::Object(MidiPort_base::_fromDynamicCast(c.object())), _cache(0) {}
  183.     inline MidiPort(const MidiPort& target) : Arts::Object(target._pool), _cache(target._cache) {}
  184.     inline MidiPort(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  185.     inline static MidiPort null() {return MidiPort((MidiPort_base*)0);}
  186.     inline static MidiPort _from_base(MidiPort_base* b) {return MidiPort(b);}
  187.     inline MidiPort& operator=(const MidiPort& target) {
  188.         if (_pool == target._pool) return *this;
  189.         _pool->Dec();
  190.         _pool = target._pool;
  191.         _cache = target._cache;
  192.         _pool->Inc();
  193.         return *this;
  194.     }
  195.     inline MidiPort_base* _base() {return _cache?_cache:_method_call();}
  196.  
  197.     inline Arts::TimeStamp time();
  198.     inline Arts::TimeStamp playTime();
  199.     inline void processCommand(const Arts::MidiCommand& command);
  200.     inline void processEvent(const Arts::MidiEvent& event);
  201. };
  202.  
  203. class ARTS_EXPORT MidiClient_base : virtual public Arts::Object_base {
  204. public:
  205.     static unsigned long _IID; // interface ID
  206.  
  207.     static MidiClient_base *_create(const std::string& subClass = "Arts::MidiClient");
  208.     static MidiClient_base *_fromString(const std::string& objectref);
  209.     static MidiClient_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  210.  
  211.     static MidiClient_base *_fromDynamicCast(const Arts::Object& object);
  212.     inline MidiClient_base *_copy() {
  213.         assert(_refCnt > 0);
  214.         _refCnt++;
  215.         return this;
  216.     }
  217.  
  218.     virtual std::vector<std::string> _defaultPortsIn() const;
  219.     virtual std::vector<std::string> _defaultPortsOut() const;
  220.  
  221.     void *_cast(unsigned long iid);
  222.  
  223.     virtual Arts::MidiClientInfo info() = 0;
  224.     virtual std::string title() = 0;
  225.     virtual void title(const std::string& newValue) = 0;
  226.     virtual void addInputPort(Arts::MidiPort port) = 0;
  227.     virtual Arts::MidiPort addOutputPort() = 0;
  228.     virtual void removePort(Arts::MidiPort port) = 0;
  229. };
  230.  
  231. class ARTS_EXPORT MidiClient_stub : virtual public MidiClient_base, virtual public Arts::Object_stub {
  232. protected:
  233.     MidiClient_stub();
  234.  
  235. public:
  236.     MidiClient_stub(Arts::Connection *connection, long objectID);
  237.  
  238.     Arts::MidiClientInfo info();
  239.     std::string title();
  240.     void title(const std::string& newValue);
  241.     void addInputPort(Arts::MidiPort port);
  242.     Arts::MidiPort addOutputPort();
  243.     void removePort(Arts::MidiPort port);
  244. };
  245.  
  246. class ARTS_EXPORT MidiClient_skel : virtual public MidiClient_base, virtual public Arts::Object_skel {
  247. protected:
  248.     // emitters for change notifications
  249.     inline void title_changed(const std::string& newValue) {
  250.         _emit_changed("title_changed",newValue);
  251.     }
  252.  
  253. public:
  254.     MidiClient_skel();
  255.  
  256.     static std::string _interfaceNameSkel();
  257.     std::string _interfaceName();
  258.     bool _isCompatibleWith(const std::string& interfacename);
  259.     void _buildMethodTable();
  260.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  261. };
  262.  
  263. }
  264. #include "reference.h"
  265. namespace Arts {
  266. class ARTS_EXPORT MidiClient : public Arts::Object {
  267. private:
  268.     static Arts::Object_base* _Creator();
  269.     MidiClient_base *_cache;
  270.     inline MidiClient_base *_method_call() {
  271.         _pool->checkcreate();
  272.         if(_pool->base) {
  273.             _cache=(MidiClient_base *)_pool->base->_cast(MidiClient_base::_IID);
  274.             assert(_cache);
  275.         }
  276.         return _cache;
  277.     }
  278.  
  279. protected:
  280.     inline MidiClient(MidiClient_base* b) : Arts::Object(b), _cache(0) {}
  281.  
  282.  
  283. public:
  284.     typedef MidiClient_base _base_class;
  285.  
  286.     inline MidiClient() : Arts::Object(_Creator), _cache(0) {}
  287.     inline MidiClient(const Arts::SubClass& s) :
  288.         Arts::Object(MidiClient_base::_create(s.string())), _cache(0) {}
  289.     inline MidiClient(const Arts::Reference &r) :
  290.         Arts::Object(r.isString()?(MidiClient_base::_fromString(r.string())):(MidiClient_base::_fromReference(r.reference(),true))), _cache(0) {}
  291.     inline MidiClient(const Arts::DynamicCast& c) : Arts::Object(MidiClient_base::_fromDynamicCast(c.object())), _cache(0) {}
  292.     inline MidiClient(const MidiClient& target) : Arts::Object(target._pool), _cache(target._cache) {}
  293.     inline MidiClient(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  294.     inline static MidiClient null() {return MidiClient((MidiClient_base*)0);}
  295.     inline static MidiClient _from_base(MidiClient_base* b) {return MidiClient(b);}
  296.     inline MidiClient& operator=(const MidiClient& target) {
  297.         if (_pool == target._pool) return *this;
  298.         _pool->Dec();
  299.         _pool = target._pool;
  300.         _cache = target._cache;
  301.         _pool->Inc();
  302.         return *this;
  303.     }
  304.     inline MidiClient_base* _base() {return _cache?_cache:_method_call();}
  305.  
  306.     inline Arts::MidiClientInfo info();
  307.     inline std::string title();
  308.     inline void title(const std::string& _newValue);
  309.     inline void addInputPort(Arts::MidiPort port);
  310.     inline Arts::MidiPort addOutputPort();
  311.     inline void removePort(Arts::MidiPort port);
  312. };
  313.  
  314. class ARTS_EXPORT MidiSyncGroup_base : virtual public Arts::Object_base {
  315. public:
  316.     static unsigned long _IID; // interface ID
  317.  
  318.     static MidiSyncGroup_base *_create(const std::string& subClass = "Arts::MidiSyncGroup");
  319.     static MidiSyncGroup_base *_fromString(const std::string& objectref);
  320.     static MidiSyncGroup_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  321.  
  322.     static MidiSyncGroup_base *_fromDynamicCast(const Arts::Object& object);
  323.     inline MidiSyncGroup_base *_copy() {
  324.         assert(_refCnt > 0);
  325.         _refCnt++;
  326.         return this;
  327.     }
  328.  
  329.     virtual std::vector<std::string> _defaultPortsIn() const;
  330.     virtual std::vector<std::string> _defaultPortsOut() const;
  331.  
  332.     void *_cast(unsigned long iid);
  333.  
  334.     virtual void addClient(Arts::MidiClient client) = 0;
  335.     virtual void removeClient(Arts::MidiClient client) = 0;
  336.     virtual void addAudioSync(Arts::AudioSync audioSync) = 0;
  337.     virtual void removeAudioSync(Arts::AudioSync audioSync) = 0;
  338. };
  339.  
  340. class ARTS_EXPORT MidiSyncGroup_stub : virtual public MidiSyncGroup_base, virtual public Arts::Object_stub {
  341. protected:
  342.     MidiSyncGroup_stub();
  343.  
  344. public:
  345.     MidiSyncGroup_stub(Arts::Connection *connection, long objectID);
  346.  
  347.     void addClient(Arts::MidiClient client);
  348.     void removeClient(Arts::MidiClient client);
  349.     void addAudioSync(Arts::AudioSync audioSync);
  350.     void removeAudioSync(Arts::AudioSync audioSync);
  351. };
  352.  
  353. class ARTS_EXPORT MidiSyncGroup_skel : virtual public MidiSyncGroup_base, virtual public Arts::Object_skel {
  354. public:
  355.     MidiSyncGroup_skel();
  356.  
  357.     static std::string _interfaceNameSkel();
  358.     std::string _interfaceName();
  359.     bool _isCompatibleWith(const std::string& interfacename);
  360.     void _buildMethodTable();
  361.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  362. };
  363.  
  364. }
  365. #include "reference.h"
  366. namespace Arts {
  367. class ARTS_EXPORT MidiSyncGroup : public Arts::Object {
  368. private:
  369.     static Arts::Object_base* _Creator();
  370.     MidiSyncGroup_base *_cache;
  371.     inline MidiSyncGroup_base *_method_call() {
  372.         _pool->checkcreate();
  373.         if(_pool->base) {
  374.             _cache=(MidiSyncGroup_base *)_pool->base->_cast(MidiSyncGroup_base::_IID);
  375.             assert(_cache);
  376.         }
  377.         return _cache;
  378.     }
  379.  
  380. protected:
  381.     inline MidiSyncGroup(MidiSyncGroup_base* b) : Arts::Object(b), _cache(0) {}
  382.  
  383.  
  384. public:
  385.     typedef MidiSyncGroup_base _base_class;
  386.  
  387.     inline MidiSyncGroup() : Arts::Object(_Creator), _cache(0) {}
  388.     inline MidiSyncGroup(const Arts::SubClass& s) :
  389.         Arts::Object(MidiSyncGroup_base::_create(s.string())), _cache(0) {}
  390.     inline MidiSyncGroup(const Arts::Reference &r) :
  391.         Arts::Object(r.isString()?(MidiSyncGroup_base::_fromString(r.string())):(MidiSyncGroup_base::_fromReference(r.reference(),true))), _cache(0) {}
  392.     inline MidiSyncGroup(const Arts::DynamicCast& c) : Arts::Object(MidiSyncGroup_base::_fromDynamicCast(c.object())), _cache(0) {}
  393.     inline MidiSyncGroup(const MidiSyncGroup& target) : Arts::Object(target._pool), _cache(target._cache) {}
  394.     inline MidiSyncGroup(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  395.     inline static MidiSyncGroup null() {return MidiSyncGroup((MidiSyncGroup_base*)0);}
  396.     inline static MidiSyncGroup _from_base(MidiSyncGroup_base* b) {return MidiSyncGroup(b);}
  397.     inline MidiSyncGroup& operator=(const MidiSyncGroup& target) {
  398.         if (_pool == target._pool) return *this;
  399.         _pool->Dec();
  400.         _pool = target._pool;
  401.         _cache = target._cache;
  402.         _pool->Inc();
  403.         return *this;
  404.     }
  405.     inline MidiSyncGroup_base* _base() {return _cache?_cache:_method_call();}
  406.  
  407.     inline void addClient(Arts::MidiClient client);
  408.     inline void removeClient(Arts::MidiClient client);
  409.     inline void addAudioSync(Arts::AudioSync audioSync);
  410.     inline void removeAudioSync(Arts::AudioSync audioSync);
  411. };
  412.  
  413. class ARTS_EXPORT MidiManager_base : virtual public Arts::Object_base {
  414. public:
  415.     static unsigned long _IID; // interface ID
  416.  
  417.     static MidiManager_base *_create(const std::string& subClass = "Arts::MidiManager");
  418.     static MidiManager_base *_fromString(const std::string& objectref);
  419.     static MidiManager_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  420.  
  421.     static MidiManager_base *_fromDynamicCast(const Arts::Object& object);
  422.     inline MidiManager_base *_copy() {
  423.         assert(_refCnt > 0);
  424.         _refCnt++;
  425.         return this;
  426.     }
  427.  
  428.     virtual std::vector<std::string> _defaultPortsIn() const;
  429.     virtual std::vector<std::string> _defaultPortsOut() const;
  430.  
  431.     void *_cast(unsigned long iid);
  432.  
  433.     virtual std::vector<Arts::MidiClientInfo> * clients() = 0;
  434.     virtual Arts::MidiClient addClient(Arts::MidiClientDirection direction, Arts::MidiClientType type, const std::string& title, const std::string& autoRestoreID) = 0;
  435.     virtual void connect(long clientID, long destinationID) = 0;
  436.     virtual void disconnect(long clientID, long destinationID) = 0;
  437.     virtual Arts::MidiSyncGroup addSyncGroup() = 0;
  438. };
  439.  
  440. class ARTS_EXPORT MidiManager_stub : virtual public MidiManager_base, virtual public Arts::Object_stub {
  441. protected:
  442.     MidiManager_stub();
  443.  
  444. public:
  445.     MidiManager_stub(Arts::Connection *connection, long objectID);
  446.  
  447.     std::vector<Arts::MidiClientInfo> * clients();
  448.     Arts::MidiClient addClient(Arts::MidiClientDirection direction, Arts::MidiClientType type, const std::string& title, const std::string& autoRestoreID);
  449.     void connect(long clientID, long destinationID);
  450.     void disconnect(long clientID, long destinationID);
  451.     Arts::MidiSyncGroup addSyncGroup();
  452. };
  453.  
  454. class ARTS_EXPORT MidiManager_skel : virtual public MidiManager_base, virtual public Arts::Object_skel {
  455. public:
  456.     MidiManager_skel();
  457.  
  458.     static std::string _interfaceNameSkel();
  459.     std::string _interfaceName();
  460.     bool _isCompatibleWith(const std::string& interfacename);
  461.     void _buildMethodTable();
  462.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  463. };
  464.  
  465. }
  466. #include "reference.h"
  467. namespace Arts {
  468. class ARTS_EXPORT MidiManager : public Arts::Object {
  469. private:
  470.     static Arts::Object_base* _Creator();
  471.     MidiManager_base *_cache;
  472.     inline MidiManager_base *_method_call() {
  473.         _pool->checkcreate();
  474.         if(_pool->base) {
  475.             _cache=(MidiManager_base *)_pool->base->_cast(MidiManager_base::_IID);
  476.             assert(_cache);
  477.         }
  478.         return _cache;
  479.     }
  480.  
  481. protected:
  482.     inline MidiManager(MidiManager_base* b) : Arts::Object(b), _cache(0) {}
  483.  
  484.  
  485. public:
  486.     typedef MidiManager_base _base_class;
  487.  
  488.     inline MidiManager() : Arts::Object(_Creator), _cache(0) {}
  489.     inline MidiManager(const Arts::SubClass& s) :
  490.         Arts::Object(MidiManager_base::_create(s.string())), _cache(0) {}
  491.     inline MidiManager(const Arts::Reference &r) :
  492.         Arts::Object(r.isString()?(MidiManager_base::_fromString(r.string())):(MidiManager_base::_fromReference(r.reference(),true))), _cache(0) {}
  493.     inline MidiManager(const Arts::DynamicCast& c) : Arts::Object(MidiManager_base::_fromDynamicCast(c.object())), _cache(0) {}
  494.     inline MidiManager(const MidiManager& target) : Arts::Object(target._pool), _cache(target._cache) {}
  495.     inline MidiManager(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  496.     inline static MidiManager null() {return MidiManager((MidiManager_base*)0);}
  497.     inline static MidiManager _from_base(MidiManager_base* b) {return MidiManager(b);}
  498.     inline MidiManager& operator=(const MidiManager& target) {
  499.         if (_pool == target._pool) return *this;
  500.         _pool->Dec();
  501.         _pool = target._pool;
  502.         _cache = target._cache;
  503.         _pool->Inc();
  504.         return *this;
  505.     }
  506.     inline MidiManager_base* _base() {return _cache?_cache:_method_call();}
  507.  
  508.     inline std::vector<Arts::MidiClientInfo> * clients();
  509.     inline Arts::MidiClient addClient(Arts::MidiClientDirection direction, Arts::MidiClientType type, const std::string& title, const std::string& autoRestoreID);
  510.     inline void connect(long clientID, long destinationID);
  511.     inline void disconnect(long clientID, long destinationID);
  512.     inline Arts::MidiSyncGroup addSyncGroup();
  513. };
  514.  
  515. class ARTS_EXPORT MidiTest_base : virtual public Arts::MidiPort_base {
  516. public:
  517.     static unsigned long _IID; // interface ID
  518.  
  519.     static MidiTest_base *_create(const std::string& subClass = "Arts::MidiTest");
  520.     static MidiTest_base *_fromString(const std::string& objectref);
  521.     static MidiTest_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  522.  
  523.     static MidiTest_base *_fromDynamicCast(const Arts::Object& object);
  524.     inline MidiTest_base *_copy() {
  525.         assert(_refCnt > 0);
  526.         _refCnt++;
  527.         return this;
  528.     }
  529.  
  530.     virtual std::vector<std::string> _defaultPortsIn() const;
  531.     virtual std::vector<std::string> _defaultPortsOut() const;
  532.  
  533.     void *_cast(unsigned long iid);
  534.  
  535. };
  536.  
  537. class ARTS_EXPORT MidiTest_stub : virtual public MidiTest_base, virtual public Arts::MidiPort_stub {
  538. protected:
  539.     MidiTest_stub();
  540.  
  541. public:
  542.     MidiTest_stub(Arts::Connection *connection, long objectID);
  543.  
  544. };
  545.  
  546. class ARTS_EXPORT MidiTest_skel : virtual public MidiTest_base, virtual public Arts::MidiPort_skel {
  547. public:
  548.     MidiTest_skel();
  549.  
  550.     static std::string _interfaceNameSkel();
  551.     std::string _interfaceName();
  552.     bool _isCompatibleWith(const std::string& interfacename);
  553.     void _buildMethodTable();
  554.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  555. };
  556.  
  557. }
  558. #include "reference.h"
  559. namespace Arts {
  560. class ARTS_EXPORT MidiTest : public Arts::Object {
  561. private:
  562.     static Arts::Object_base* _Creator();
  563.     MidiTest_base *_cache;
  564.     inline MidiTest_base *_method_call() {
  565.         _pool->checkcreate();
  566.         if(_pool->base) {
  567.             _cache=(MidiTest_base *)_pool->base->_cast(MidiTest_base::_IID);
  568.             assert(_cache);
  569.         }
  570.         return _cache;
  571.     }
  572.  
  573. protected:
  574.     inline MidiTest(MidiTest_base* b) : Arts::Object(b), _cache(0) {}
  575.  
  576.  
  577. public:
  578.     typedef MidiTest_base _base_class;
  579.  
  580.     inline MidiTest() : Arts::Object(_Creator), _cache(0) {}
  581.     inline MidiTest(const Arts::SubClass& s) :
  582.         Arts::Object(MidiTest_base::_create(s.string())), _cache(0) {}
  583.     inline MidiTest(const Arts::Reference &r) :
  584.         Arts::Object(r.isString()?(MidiTest_base::_fromString(r.string())):(MidiTest_base::_fromReference(r.reference(),true))), _cache(0) {}
  585.     inline MidiTest(const Arts::DynamicCast& c) : Arts::Object(MidiTest_base::_fromDynamicCast(c.object())), _cache(0) {}
  586.     inline MidiTest(const MidiTest& target) : Arts::Object(target._pool), _cache(target._cache) {}
  587.     inline MidiTest(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  588.     inline static MidiTest null() {return MidiTest((MidiTest_base*)0);}
  589.     inline static MidiTest _from_base(MidiTest_base* b) {return MidiTest(b);}
  590.     inline MidiTest& operator=(const MidiTest& target) {
  591.         if (_pool == target._pool) return *this;
  592.         _pool->Dec();
  593.         _pool = target._pool;
  594.         _cache = target._cache;
  595.         _pool->Inc();
  596.         return *this;
  597.     }
  598.     inline operator Arts::MidiPort() const { return Arts::MidiPort(*_pool); }
  599.     inline MidiTest_base* _base() {return _cache?_cache:_method_call();}
  600.  
  601.     inline Arts::TimeStamp time();
  602.     inline Arts::TimeStamp playTime();
  603.     inline void processCommand(const Arts::MidiCommand& command);
  604.     inline void processEvent(const Arts::MidiEvent& event);
  605. };
  606.  
  607. class ARTS_EXPORT RawMidiPort_base : virtual public Arts::MidiPort_base {
  608. public:
  609.     static unsigned long _IID; // interface ID
  610.  
  611.     static RawMidiPort_base *_create(const std::string& subClass = "Arts::RawMidiPort");
  612.     static RawMidiPort_base *_fromString(const std::string& objectref);
  613.     static RawMidiPort_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  614.  
  615.     static RawMidiPort_base *_fromDynamicCast(const Arts::Object& object);
  616.     inline RawMidiPort_base *_copy() {
  617.         assert(_refCnt > 0);
  618.         _refCnt++;
  619.         return this;
  620.     }
  621.  
  622.     virtual std::vector<std::string> _defaultPortsIn() const;
  623.     virtual std::vector<std::string> _defaultPortsOut() const;
  624.  
  625.     void *_cast(unsigned long iid);
  626.  
  627.     virtual std::string device() = 0;
  628.     virtual void device(const std::string& newValue) = 0;
  629.     virtual bool input() = 0;
  630.     virtual void input(bool newValue) = 0;
  631.     virtual bool output() = 0;
  632.     virtual void output(bool newValue) = 0;
  633.     virtual bool running() = 0;
  634.     virtual void running(bool newValue) = 0;
  635.     virtual bool open() = 0;
  636. };
  637.  
  638. class ARTS_EXPORT RawMidiPort_stub : virtual public RawMidiPort_base, virtual public Arts::MidiPort_stub {
  639. protected:
  640.     RawMidiPort_stub();
  641.  
  642. public:
  643.     RawMidiPort_stub(Arts::Connection *connection, long objectID);
  644.  
  645.     std::string device();
  646.     void device(const std::string& newValue);
  647.     bool input();
  648.     void input(bool newValue);
  649.     bool output();
  650.     void output(bool newValue);
  651.     bool running();
  652.     void running(bool newValue);
  653.     bool open();
  654. };
  655.  
  656. class ARTS_EXPORT RawMidiPort_skel : virtual public RawMidiPort_base, virtual public Arts::MidiPort_skel {
  657. protected:
  658.     // emitters for change notifications
  659.     inline void device_changed(const std::string& newValue) {
  660.         _emit_changed("device_changed",newValue);
  661.     }
  662.     inline void input_changed(bool newValue) {
  663.         _emit_changed("input_changed",newValue);
  664.     }
  665.     inline void output_changed(bool newValue) {
  666.         _emit_changed("output_changed",newValue);
  667.     }
  668.     inline void running_changed(bool newValue) {
  669.         _emit_changed("running_changed",newValue);
  670.     }
  671.  
  672. public:
  673.     RawMidiPort_skel();
  674.  
  675.     static std::string _interfaceNameSkel();
  676.     std::string _interfaceName();
  677.     bool _isCompatibleWith(const std::string& interfacename);
  678.     void _buildMethodTable();
  679.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  680. };
  681.  
  682. }
  683. #include "reference.h"
  684. namespace Arts {
  685. class ARTS_EXPORT RawMidiPort : public Arts::Object {
  686. private:
  687.     static Arts::Object_base* _Creator();
  688.     RawMidiPort_base *_cache;
  689.     inline RawMidiPort_base *_method_call() {
  690.         _pool->checkcreate();
  691.         if(_pool->base) {
  692.             _cache=(RawMidiPort_base *)_pool->base->_cast(RawMidiPort_base::_IID);
  693.             assert(_cache);
  694.         }
  695.         return _cache;
  696.     }
  697.  
  698. protected:
  699.     inline RawMidiPort(RawMidiPort_base* b) : Arts::Object(b), _cache(0) {}
  700.  
  701.  
  702. public:
  703.     typedef RawMidiPort_base _base_class;
  704.  
  705.     inline RawMidiPort() : Arts::Object(_Creator), _cache(0) {}
  706.     inline RawMidiPort(const Arts::SubClass& s) :
  707.         Arts::Object(RawMidiPort_base::_create(s.string())), _cache(0) {}
  708.     inline RawMidiPort(const Arts::Reference &r) :
  709.         Arts::Object(r.isString()?(RawMidiPort_base::_fromString(r.string())):(RawMidiPort_base::_fromReference(r.reference(),true))), _cache(0) {}
  710.     inline RawMidiPort(const Arts::DynamicCast& c) : Arts::Object(RawMidiPort_base::_fromDynamicCast(c.object())), _cache(0) {}
  711.     inline RawMidiPort(const RawMidiPort& target) : Arts::Object(target._pool), _cache(target._cache) {}
  712.     inline RawMidiPort(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  713.     inline static RawMidiPort null() {return RawMidiPort((RawMidiPort_base*)0);}
  714.     inline static RawMidiPort _from_base(RawMidiPort_base* b) {return RawMidiPort(b);}
  715.     inline RawMidiPort& operator=(const RawMidiPort& target) {
  716.         if (_pool == target._pool) return *this;
  717.         _pool->Dec();
  718.         _pool = target._pool;
  719.         _cache = target._cache;
  720.         _pool->Inc();
  721.         return *this;
  722.     }
  723.     inline operator Arts::MidiPort() const { return Arts::MidiPort(*_pool); }
  724.     inline RawMidiPort_base* _base() {return _cache?_cache:_method_call();}
  725.  
  726.     inline Arts::TimeStamp time();
  727.     inline Arts::TimeStamp playTime();
  728.     inline void processCommand(const Arts::MidiCommand& command);
  729.     inline void processEvent(const Arts::MidiEvent& event);
  730.     inline std::string device();
  731.     inline void device(const std::string& _newValue);
  732.     inline bool input();
  733.     inline void input(bool _newValue);
  734.     inline bool output();
  735.     inline void output(bool _newValue);
  736.     inline bool running();
  737.     inline void running(bool _newValue);
  738.     inline bool open();
  739. };
  740.  
  741. class ARTS_EXPORT AlsaMidiGateway_base : virtual public Arts::Object_base {
  742. public:
  743.     static unsigned long _IID; // interface ID
  744.  
  745.     static AlsaMidiGateway_base *_create(const std::string& subClass = "Arts::AlsaMidiGateway");
  746.     static AlsaMidiGateway_base *_fromString(const std::string& objectref);
  747.     static AlsaMidiGateway_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  748.  
  749.     static AlsaMidiGateway_base *_fromDynamicCast(const Arts::Object& object);
  750.     inline AlsaMidiGateway_base *_copy() {
  751.         assert(_refCnt > 0);
  752.         _refCnt++;
  753.         return this;
  754.     }
  755.  
  756.     virtual std::vector<std::string> _defaultPortsIn() const;
  757.     virtual std::vector<std::string> _defaultPortsOut() const;
  758.  
  759.     void *_cast(unsigned long iid);
  760.  
  761.     virtual bool rescan() = 0;
  762. };
  763.  
  764. class ARTS_EXPORT AlsaMidiGateway_stub : virtual public AlsaMidiGateway_base, virtual public Arts::Object_stub {
  765. protected:
  766.     AlsaMidiGateway_stub();
  767.  
  768. public:
  769.     AlsaMidiGateway_stub(Arts::Connection *connection, long objectID);
  770.  
  771.     bool rescan();
  772. };
  773.  
  774. class ARTS_EXPORT AlsaMidiGateway_skel : virtual public AlsaMidiGateway_base, virtual public Arts::Object_skel {
  775. public:
  776.     AlsaMidiGateway_skel();
  777.  
  778.     static std::string _interfaceNameSkel();
  779.     std::string _interfaceName();
  780.     bool _isCompatibleWith(const std::string& interfacename);
  781.     void _buildMethodTable();
  782.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  783. };
  784.  
  785. }
  786. #include "reference.h"
  787. namespace Arts {
  788. class ARTS_EXPORT AlsaMidiGateway : public Arts::Object {
  789. private:
  790.     static Arts::Object_base* _Creator();
  791.     AlsaMidiGateway_base *_cache;
  792.     inline AlsaMidiGateway_base *_method_call() {
  793.         _pool->checkcreate();
  794.         if(_pool->base) {
  795.             _cache=(AlsaMidiGateway_base *)_pool->base->_cast(AlsaMidiGateway_base::_IID);
  796.             assert(_cache);
  797.         }
  798.         return _cache;
  799.     }
  800.  
  801. protected:
  802.     inline AlsaMidiGateway(AlsaMidiGateway_base* b) : Arts::Object(b), _cache(0) {}
  803.  
  804.  
  805. public:
  806.     typedef AlsaMidiGateway_base _base_class;
  807.  
  808.     inline AlsaMidiGateway() : Arts::Object(_Creator), _cache(0) {}
  809.     inline AlsaMidiGateway(const Arts::SubClass& s) :
  810.         Arts::Object(AlsaMidiGateway_base::_create(s.string())), _cache(0) {}
  811.     inline AlsaMidiGateway(const Arts::Reference &r) :
  812.         Arts::Object(r.isString()?(AlsaMidiGateway_base::_fromString(r.string())):(AlsaMidiGateway_base::_fromReference(r.reference(),true))), _cache(0) {}
  813.     inline AlsaMidiGateway(const Arts::DynamicCast& c) : Arts::Object(AlsaMidiGateway_base::_fromDynamicCast(c.object())), _cache(0) {}
  814.     inline AlsaMidiGateway(const AlsaMidiGateway& target) : Arts::Object(target._pool), _cache(target._cache) {}
  815.     inline AlsaMidiGateway(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  816.     inline static AlsaMidiGateway null() {return AlsaMidiGateway((AlsaMidiGateway_base*)0);}
  817.     inline static AlsaMidiGateway _from_base(AlsaMidiGateway_base* b) {return AlsaMidiGateway(b);}
  818.     inline AlsaMidiGateway& operator=(const AlsaMidiGateway& target) {
  819.         if (_pool == target._pool) return *this;
  820.         _pool->Dec();
  821.         _pool = target._pool;
  822.         _cache = target._cache;
  823.         _pool->Inc();
  824.         return *this;
  825.     }
  826.     inline AlsaMidiGateway_base* _base() {return _cache?_cache:_method_call();}
  827.  
  828.     inline bool rescan();
  829. };
  830.  
  831. class ARTS_EXPORT AlsaMidiPort_base : virtual public Arts::MidiPort_base {
  832. public:
  833.     static unsigned long _IID; // interface ID
  834.  
  835.     static AlsaMidiPort_base *_create(const std::string& subClass = "Arts::AlsaMidiPort");
  836.     static AlsaMidiPort_base *_fromString(const std::string& objectref);
  837.     static AlsaMidiPort_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  838.  
  839.     static AlsaMidiPort_base *_fromDynamicCast(const Arts::Object& object);
  840.     inline AlsaMidiPort_base *_copy() {
  841.         assert(_refCnt > 0);
  842.         _refCnt++;
  843.         return this;
  844.     }
  845.  
  846.     virtual std::vector<std::string> _defaultPortsIn() const;
  847.     virtual std::vector<std::string> _defaultPortsOut() const;
  848.  
  849.     void *_cast(unsigned long iid);
  850.  
  851.     virtual long client() = 0;
  852.     virtual void client(long newValue) = 0;
  853.     virtual long port() = 0;
  854.     virtual void port(long newValue) = 0;
  855.     virtual bool open() = 0;
  856. };
  857.  
  858. class ARTS_EXPORT AlsaMidiPort_stub : virtual public AlsaMidiPort_base, virtual public Arts::MidiPort_stub {
  859. protected:
  860.     AlsaMidiPort_stub();
  861.  
  862. public:
  863.     AlsaMidiPort_stub(Arts::Connection *connection, long objectID);
  864.  
  865.     long client();
  866.     void client(long newValue);
  867.     long port();
  868.     void port(long newValue);
  869.     bool open();
  870. };
  871.  
  872. class ARTS_EXPORT AlsaMidiPort_skel : virtual public AlsaMidiPort_base, virtual public Arts::MidiPort_skel {
  873. protected:
  874.     // emitters for change notifications
  875.     inline void client_changed(long newValue) {
  876.         _emit_changed("client_changed",newValue);
  877.     }
  878.     inline void port_changed(long newValue) {
  879.         _emit_changed("port_changed",newValue);
  880.     }
  881.  
  882. public:
  883.     AlsaMidiPort_skel();
  884.  
  885.     static std::string _interfaceNameSkel();
  886.     std::string _interfaceName();
  887.     bool _isCompatibleWith(const std::string& interfacename);
  888.     void _buildMethodTable();
  889.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  890. };
  891.  
  892. }
  893. #include "reference.h"
  894. namespace Arts {
  895. class ARTS_EXPORT AlsaMidiPort : public Arts::Object {
  896. private:
  897.     static Arts::Object_base* _Creator();
  898.     AlsaMidiPort_base *_cache;
  899.     inline AlsaMidiPort_base *_method_call() {
  900.         _pool->checkcreate();
  901.         if(_pool->base) {
  902.             _cache=(AlsaMidiPort_base *)_pool->base->_cast(AlsaMidiPort_base::_IID);
  903.             assert(_cache);
  904.         }
  905.         return _cache;
  906.     }
  907.  
  908. protected:
  909.     inline AlsaMidiPort(AlsaMidiPort_base* b) : Arts::Object(b), _cache(0) {}
  910.  
  911.  
  912. public:
  913.     typedef AlsaMidiPort_base _base_class;
  914.  
  915.     inline AlsaMidiPort() : Arts::Object(_Creator), _cache(0) {}
  916.     inline AlsaMidiPort(const Arts::SubClass& s) :
  917.         Arts::Object(AlsaMidiPort_base::_create(s.string())), _cache(0) {}
  918.     inline AlsaMidiPort(const Arts::Reference &r) :
  919.         Arts::Object(r.isString()?(AlsaMidiPort_base::_fromString(r.string())):(AlsaMidiPort_base::_fromReference(r.reference(),true))), _cache(0) {}
  920.     inline AlsaMidiPort(const Arts::DynamicCast& c) : Arts::Object(AlsaMidiPort_base::_fromDynamicCast(c.object())), _cache(0) {}
  921.     inline AlsaMidiPort(const AlsaMidiPort& target) : Arts::Object(target._pool), _cache(target._cache) {}
  922.     inline AlsaMidiPort(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  923.     inline static AlsaMidiPort null() {return AlsaMidiPort((AlsaMidiPort_base*)0);}
  924.     inline static AlsaMidiPort _from_base(AlsaMidiPort_base* b) {return AlsaMidiPort(b);}
  925.     inline AlsaMidiPort& operator=(const AlsaMidiPort& target) {
  926.         if (_pool == target._pool) return *this;
  927.         _pool->Dec();
  928.         _pool = target._pool;
  929.         _cache = target._cache;
  930.         _pool->Inc();
  931.         return *this;
  932.     }
  933.     inline operator Arts::MidiPort() const { return Arts::MidiPort(*_pool); }
  934.     inline AlsaMidiPort_base* _base() {return _cache?_cache:_method_call();}
  935.  
  936.     inline Arts::TimeStamp time();
  937.     inline Arts::TimeStamp playTime();
  938.     inline void processCommand(const Arts::MidiCommand& command);
  939.     inline void processEvent(const Arts::MidiEvent& event);
  940.     inline long client();
  941.     inline void client(long _newValue);
  942.     inline long port();
  943.     inline void port(long _newValue);
  944.     inline bool open();
  945. };
  946.  
  947. class ARTS_EXPORT AudioSync_base : virtual public Arts::Object_base {
  948. public:
  949.     static unsigned long _IID; // interface ID
  950.  
  951.     static AudioSync_base *_create(const std::string& subClass = "Arts::AudioSync");
  952.     static AudioSync_base *_fromString(const std::string& objectref);
  953.     static AudioSync_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  954.  
  955.     static AudioSync_base *_fromDynamicCast(const Arts::Object& object);
  956.     inline AudioSync_base *_copy() {
  957.         assert(_refCnt > 0);
  958.         _refCnt++;
  959.         return this;
  960.     }
  961.  
  962.     virtual std::vector<std::string> _defaultPortsIn() const;
  963.     virtual std::vector<std::string> _defaultPortsOut() const;
  964.  
  965.     void *_cast(unsigned long iid);
  966.  
  967.     virtual Arts::TimeStamp time() = 0;
  968.     virtual Arts::TimeStamp playTime() = 0;
  969.     virtual void queueStart(Arts::SynthModule synthModule) = 0;
  970.     virtual void queueStop(Arts::SynthModule synthModule) = 0;
  971.     virtual void execute() = 0;
  972.     virtual void executeAt(const Arts::TimeStamp& timeStamp) = 0;
  973. };
  974.  
  975. class ARTS_EXPORT AudioSync_stub : virtual public AudioSync_base, virtual public Arts::Object_stub {
  976. protected:
  977.     AudioSync_stub();
  978.  
  979. public:
  980.     AudioSync_stub(Arts::Connection *connection, long objectID);
  981.  
  982.     Arts::TimeStamp time();
  983.     Arts::TimeStamp playTime();
  984.     void queueStart(Arts::SynthModule synthModule);
  985.     void queueStop(Arts::SynthModule synthModule);
  986.     void execute();
  987.     void executeAt(const Arts::TimeStamp& timeStamp);
  988. };
  989.  
  990. class ARTS_EXPORT AudioSync_skel : virtual public AudioSync_base, virtual public Arts::Object_skel {
  991. public:
  992.     AudioSync_skel();
  993.  
  994.     static std::string _interfaceNameSkel();
  995.     std::string _interfaceName();
  996.     bool _isCompatibleWith(const std::string& interfacename);
  997.     void _buildMethodTable();
  998.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  999. };
  1000.  
  1001. }
  1002. #include "reference.h"
  1003. namespace Arts {
  1004. class ARTS_EXPORT AudioSync : public Arts::Object {
  1005. private:
  1006.     static Arts::Object_base* _Creator();
  1007.     AudioSync_base *_cache;
  1008.     inline AudioSync_base *_method_call() {
  1009.         _pool->checkcreate();
  1010.         if(_pool->base) {
  1011.             _cache=(AudioSync_base *)_pool->base->_cast(AudioSync_base::_IID);
  1012.             assert(_cache);
  1013.         }
  1014.         return _cache;
  1015.     }
  1016.  
  1017. protected:
  1018.     inline AudioSync(AudioSync_base* b) : Arts::Object(b), _cache(0) {}
  1019.  
  1020.  
  1021. public:
  1022.     typedef AudioSync_base _base_class;
  1023.  
  1024.     inline AudioSync() : Arts::Object(_Creator), _cache(0) {}
  1025.     inline AudioSync(const Arts::SubClass& s) :
  1026.         Arts::Object(AudioSync_base::_create(s.string())), _cache(0) {}
  1027.     inline AudioSync(const Arts::Reference &r) :
  1028.         Arts::Object(r.isString()?(AudioSync_base::_fromString(r.string())):(AudioSync_base::_fromReference(r.reference(),true))), _cache(0) {}
  1029.     inline AudioSync(const Arts::DynamicCast& c) : Arts::Object(AudioSync_base::_fromDynamicCast(c.object())), _cache(0) {}
  1030.     inline AudioSync(const AudioSync& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1031.     inline AudioSync(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1032.     inline static AudioSync null() {return AudioSync((AudioSync_base*)0);}
  1033.     inline static AudioSync _from_base(AudioSync_base* b) {return AudioSync(b);}
  1034.     inline AudioSync& operator=(const AudioSync& target) {
  1035.         if (_pool == target._pool) return *this;
  1036.         _pool->Dec();
  1037.         _pool = target._pool;
  1038.         _cache = target._cache;
  1039.         _pool->Inc();
  1040.         return *this;
  1041.     }
  1042.     inline AudioSync_base* _base() {return _cache?_cache:_method_call();}
  1043.  
  1044.     inline Arts::TimeStamp time();
  1045.     inline Arts::TimeStamp playTime();
  1046.     inline void queueStart(Arts::SynthModule synthModule);
  1047.     inline void queueStop(Arts::SynthModule synthModule);
  1048.     inline void execute();
  1049.     inline void executeAt(const Arts::TimeStamp& timeStamp);
  1050. };
  1051.  
  1052. class ARTS_EXPORT MidiTimer_base : virtual public Arts::Object_base {
  1053. public:
  1054.     static unsigned long _IID; // interface ID
  1055.  
  1056.     static MidiTimer_base *_create(const std::string& subClass = "Arts::MidiTimer");
  1057.     static MidiTimer_base *_fromString(const std::string& objectref);
  1058.     static MidiTimer_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1059.  
  1060.     static MidiTimer_base *_fromDynamicCast(const Arts::Object& object);
  1061.     inline MidiTimer_base *_copy() {
  1062.         assert(_refCnt > 0);
  1063.         _refCnt++;
  1064.         return this;
  1065.     }
  1066.  
  1067.     virtual std::vector<std::string> _defaultPortsIn() const;
  1068.     virtual std::vector<std::string> _defaultPortsOut() const;
  1069.  
  1070.     void *_cast(unsigned long iid);
  1071.  
  1072.     virtual Arts::TimeStamp time() = 0;
  1073.     virtual void queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event) = 0;
  1074. };
  1075.  
  1076. class ARTS_EXPORT MidiTimer_stub : virtual public MidiTimer_base, virtual public Arts::Object_stub {
  1077. protected:
  1078.     MidiTimer_stub();
  1079.  
  1080. public:
  1081.     MidiTimer_stub(Arts::Connection *connection, long objectID);
  1082.  
  1083.     Arts::TimeStamp time();
  1084.     void queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event);
  1085. };
  1086.  
  1087. class ARTS_EXPORT MidiTimer_skel : virtual public MidiTimer_base, virtual public Arts::Object_skel {
  1088. public:
  1089.     MidiTimer_skel();
  1090.  
  1091.     static std::string _interfaceNameSkel();
  1092.     std::string _interfaceName();
  1093.     bool _isCompatibleWith(const std::string& interfacename);
  1094.     void _buildMethodTable();
  1095.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1096. };
  1097.  
  1098. }
  1099. #include "reference.h"
  1100. namespace Arts {
  1101. class ARTS_EXPORT MidiTimer : public Arts::Object {
  1102. private:
  1103.     static Arts::Object_base* _Creator();
  1104.     MidiTimer_base *_cache;
  1105.     inline MidiTimer_base *_method_call() {
  1106.         _pool->checkcreate();
  1107.         if(_pool->base) {
  1108.             _cache=(MidiTimer_base *)_pool->base->_cast(MidiTimer_base::_IID);
  1109.             assert(_cache);
  1110.         }
  1111.         return _cache;
  1112.     }
  1113.  
  1114. protected:
  1115.     inline MidiTimer(MidiTimer_base* b) : Arts::Object(b), _cache(0) {}
  1116.  
  1117.  
  1118. public:
  1119.     typedef MidiTimer_base _base_class;
  1120.  
  1121.     inline MidiTimer() : Arts::Object(_Creator), _cache(0) {}
  1122.     inline MidiTimer(const Arts::SubClass& s) :
  1123.         Arts::Object(MidiTimer_base::_create(s.string())), _cache(0) {}
  1124.     inline MidiTimer(const Arts::Reference &r) :
  1125.         Arts::Object(r.isString()?(MidiTimer_base::_fromString(r.string())):(MidiTimer_base::_fromReference(r.reference(),true))), _cache(0) {}
  1126.     inline MidiTimer(const Arts::DynamicCast& c) : Arts::Object(MidiTimer_base::_fromDynamicCast(c.object())), _cache(0) {}
  1127.     inline MidiTimer(const MidiTimer& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1128.     inline MidiTimer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1129.     inline static MidiTimer null() {return MidiTimer((MidiTimer_base*)0);}
  1130.     inline static MidiTimer _from_base(MidiTimer_base* b) {return MidiTimer(b);}
  1131.     inline MidiTimer& operator=(const MidiTimer& target) {
  1132.         if (_pool == target._pool) return *this;
  1133.         _pool->Dec();
  1134.         _pool = target._pool;
  1135.         _cache = target._cache;
  1136.         _pool->Inc();
  1137.         return *this;
  1138.     }
  1139.     inline MidiTimer_base* _base() {return _cache?_cache:_method_call();}
  1140.  
  1141.     inline Arts::TimeStamp time();
  1142.     inline void queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event);
  1143. };
  1144.  
  1145. class ARTS_EXPORT SystemMidiTimer_base : virtual public Arts::MidiTimer_base {
  1146. public:
  1147.     static unsigned long _IID; // interface ID
  1148.  
  1149.     static SystemMidiTimer_base *_create(const std::string& subClass = "Arts::SystemMidiTimer");
  1150.     static SystemMidiTimer_base *_fromString(const std::string& objectref);
  1151.     static SystemMidiTimer_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1152.  
  1153.     static SystemMidiTimer_base *_fromDynamicCast(const Arts::Object& object);
  1154.     inline SystemMidiTimer_base *_copy() {
  1155.         assert(_refCnt > 0);
  1156.         _refCnt++;
  1157.         return this;
  1158.     }
  1159.  
  1160.     virtual std::vector<std::string> _defaultPortsIn() const;
  1161.     virtual std::vector<std::string> _defaultPortsOut() const;
  1162.  
  1163.     void *_cast(unsigned long iid);
  1164.  
  1165. };
  1166.  
  1167. class ARTS_EXPORT SystemMidiTimer_stub : virtual public SystemMidiTimer_base, virtual public Arts::MidiTimer_stub {
  1168. protected:
  1169.     SystemMidiTimer_stub();
  1170.  
  1171. public:
  1172.     SystemMidiTimer_stub(Arts::Connection *connection, long objectID);
  1173.  
  1174. };
  1175.  
  1176. class ARTS_EXPORT SystemMidiTimer_skel : virtual public SystemMidiTimer_base, virtual public Arts::MidiTimer_skel {
  1177. public:
  1178.     SystemMidiTimer_skel();
  1179.  
  1180.     static std::string _interfaceNameSkel();
  1181.     std::string _interfaceName();
  1182.     bool _isCompatibleWith(const std::string& interfacename);
  1183.     void _buildMethodTable();
  1184.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1185. };
  1186.  
  1187. }
  1188. #include "reference.h"
  1189. namespace Arts {
  1190. class ARTS_EXPORT SystemMidiTimer : public Arts::Object {
  1191. private:
  1192.     static Arts::Object_base* _Creator();
  1193.     SystemMidiTimer_base *_cache;
  1194.     inline SystemMidiTimer_base *_method_call() {
  1195.         _pool->checkcreate();
  1196.         if(_pool->base) {
  1197.             _cache=(SystemMidiTimer_base *)_pool->base->_cast(SystemMidiTimer_base::_IID);
  1198.             assert(_cache);
  1199.         }
  1200.         return _cache;
  1201.     }
  1202.  
  1203. protected:
  1204.     inline SystemMidiTimer(SystemMidiTimer_base* b) : Arts::Object(b), _cache(0) {}
  1205.  
  1206.  
  1207. public:
  1208.     typedef SystemMidiTimer_base _base_class;
  1209.  
  1210.     inline SystemMidiTimer() : Arts::Object(_Creator), _cache(0) {}
  1211.     inline SystemMidiTimer(const Arts::SubClass& s) :
  1212.         Arts::Object(SystemMidiTimer_base::_create(s.string())), _cache(0) {}
  1213.     inline SystemMidiTimer(const Arts::Reference &r) :
  1214.         Arts::Object(r.isString()?(SystemMidiTimer_base::_fromString(r.string())):(SystemMidiTimer_base::_fromReference(r.reference(),true))), _cache(0) {}
  1215.     inline SystemMidiTimer(const Arts::DynamicCast& c) : Arts::Object(SystemMidiTimer_base::_fromDynamicCast(c.object())), _cache(0) {}
  1216.     inline SystemMidiTimer(const SystemMidiTimer& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1217.     inline SystemMidiTimer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1218.     inline static SystemMidiTimer null() {return SystemMidiTimer((SystemMidiTimer_base*)0);}
  1219.     inline static SystemMidiTimer _from_base(SystemMidiTimer_base* b) {return SystemMidiTimer(b);}
  1220.     inline SystemMidiTimer& operator=(const SystemMidiTimer& target) {
  1221.         if (_pool == target._pool) return *this;
  1222.         _pool->Dec();
  1223.         _pool = target._pool;
  1224.         _cache = target._cache;
  1225.         _pool->Inc();
  1226.         return *this;
  1227.     }
  1228.     inline operator Arts::MidiTimer() const { return Arts::MidiTimer(*_pool); }
  1229.     inline SystemMidiTimer_base* _base() {return _cache?_cache:_method_call();}
  1230.  
  1231.     inline Arts::TimeStamp time();
  1232.     inline void queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event);
  1233. };
  1234.  
  1235. class ARTS_EXPORT AudioMidiTimer_base : virtual public Arts::MidiTimer_base {
  1236. public:
  1237.     static unsigned long _IID; // interface ID
  1238.  
  1239.     static AudioMidiTimer_base *_create(const std::string& subClass = "Arts::AudioMidiTimer");
  1240.     static AudioMidiTimer_base *_fromString(const std::string& objectref);
  1241.     static AudioMidiTimer_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1242.  
  1243.     static AudioMidiTimer_base *_fromDynamicCast(const Arts::Object& object);
  1244.     inline AudioMidiTimer_base *_copy() {
  1245.         assert(_refCnt > 0);
  1246.         _refCnt++;
  1247.         return this;
  1248.     }
  1249.  
  1250.     virtual std::vector<std::string> _defaultPortsIn() const;
  1251.     virtual std::vector<std::string> _defaultPortsOut() const;
  1252.  
  1253.     void *_cast(unsigned long iid);
  1254.  
  1255. };
  1256.  
  1257. class ARTS_EXPORT AudioMidiTimer_stub : virtual public AudioMidiTimer_base, virtual public Arts::MidiTimer_stub {
  1258. protected:
  1259.     AudioMidiTimer_stub();
  1260.  
  1261. public:
  1262.     AudioMidiTimer_stub(Arts::Connection *connection, long objectID);
  1263.  
  1264. };
  1265.  
  1266. class ARTS_EXPORT AudioMidiTimer_skel : virtual public AudioMidiTimer_base, virtual public Arts::MidiTimer_skel {
  1267. public:
  1268.     AudioMidiTimer_skel();
  1269.  
  1270.     static std::string _interfaceNameSkel();
  1271.     std::string _interfaceName();
  1272.     bool _isCompatibleWith(const std::string& interfacename);
  1273.     void _buildMethodTable();
  1274.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1275. };
  1276.  
  1277. }
  1278. #include "reference.h"
  1279. namespace Arts {
  1280. class ARTS_EXPORT AudioMidiTimer : public Arts::Object {
  1281. private:
  1282.     static Arts::Object_base* _Creator();
  1283.     AudioMidiTimer_base *_cache;
  1284.     inline AudioMidiTimer_base *_method_call() {
  1285.         _pool->checkcreate();
  1286.         if(_pool->base) {
  1287.             _cache=(AudioMidiTimer_base *)_pool->base->_cast(AudioMidiTimer_base::_IID);
  1288.             assert(_cache);
  1289.         }
  1290.         return _cache;
  1291.     }
  1292.  
  1293. protected:
  1294.     inline AudioMidiTimer(AudioMidiTimer_base* b) : Arts::Object(b), _cache(0) {}
  1295.  
  1296.  
  1297. public:
  1298.     typedef AudioMidiTimer_base _base_class;
  1299.  
  1300.     inline AudioMidiTimer() : Arts::Object(_Creator), _cache(0) {}
  1301.     inline AudioMidiTimer(const Arts::SubClass& s) :
  1302.         Arts::Object(AudioMidiTimer_base::_create(s.string())), _cache(0) {}
  1303.     inline AudioMidiTimer(const Arts::Reference &r) :
  1304.         Arts::Object(r.isString()?(AudioMidiTimer_base::_fromString(r.string())):(AudioMidiTimer_base::_fromReference(r.reference(),true))), _cache(0) {}
  1305.     inline AudioMidiTimer(const Arts::DynamicCast& c) : Arts::Object(AudioMidiTimer_base::_fromDynamicCast(c.object())), _cache(0) {}
  1306.     inline AudioMidiTimer(const AudioMidiTimer& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1307.     inline AudioMidiTimer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1308.     inline static AudioMidiTimer null() {return AudioMidiTimer((AudioMidiTimer_base*)0);}
  1309.     inline static AudioMidiTimer _from_base(AudioMidiTimer_base* b) {return AudioMidiTimer(b);}
  1310.     inline AudioMidiTimer& operator=(const AudioMidiTimer& target) {
  1311.         if (_pool == target._pool) return *this;
  1312.         _pool->Dec();
  1313.         _pool = target._pool;
  1314.         _cache = target._cache;
  1315.         _pool->Inc();
  1316.         return *this;
  1317.     }
  1318.     inline operator Arts::MidiTimer() const { return Arts::MidiTimer(*_pool); }
  1319.     inline AudioMidiTimer_base* _base() {return _cache?_cache:_method_call();}
  1320.  
  1321.     inline Arts::TimeStamp time();
  1322.     inline void queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event);
  1323. };
  1324.  
  1325. }
  1326. // Forward wrapper calls to _base classes:
  1327.  
  1328. inline Arts::TimeStamp Arts::MidiPort::time()
  1329. {
  1330.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->time():static_cast<Arts::MidiPort_base*>(_method_call())->time();
  1331. }
  1332.  
  1333. inline Arts::TimeStamp Arts::MidiPort::playTime()
  1334. {
  1335.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->playTime():static_cast<Arts::MidiPort_base*>(_method_call())->playTime();
  1336. }
  1337.  
  1338. inline void Arts::MidiPort::processCommand(const Arts::MidiCommand& command)
  1339. {
  1340.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processCommand(command):static_cast<Arts::MidiPort_base*>(_method_call())->processCommand(command);
  1341. }
  1342.  
  1343. inline void Arts::MidiPort::processEvent(const Arts::MidiEvent& event)
  1344. {
  1345.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processEvent(event):static_cast<Arts::MidiPort_base*>(_method_call())->processEvent(event);
  1346. }
  1347.  
  1348. inline Arts::MidiClientInfo Arts::MidiClient::info()
  1349. {
  1350.     return _cache?static_cast<Arts::MidiClient_base*>(_cache)->info():static_cast<Arts::MidiClient_base*>(_method_call())->info();
  1351. }
  1352.  
  1353. inline std::string Arts::MidiClient::title()
  1354. {
  1355.     return _cache?static_cast<Arts::MidiClient_base*>(_cache)->title():static_cast<Arts::MidiClient_base*>(_method_call())->title();
  1356. }
  1357.  
  1358. inline void Arts::MidiClient::title(const std::string& _newValue)
  1359. {
  1360.      _cache?static_cast<Arts::MidiClient_base*>(_cache)->title(_newValue):static_cast<Arts::MidiClient_base*>(_method_call())->title(_newValue);
  1361. }
  1362.  
  1363. inline void Arts::MidiClient::addInputPort(Arts::MidiPort port)
  1364. {
  1365.      _cache?static_cast<Arts::MidiClient_base*>(_cache)->addInputPort(port):static_cast<Arts::MidiClient_base*>(_method_call())->addInputPort(port);
  1366. }
  1367.  
  1368. inline Arts::MidiPort Arts::MidiClient::addOutputPort()
  1369. {
  1370.     return _cache?static_cast<Arts::MidiClient_base*>(_cache)->addOutputPort():static_cast<Arts::MidiClient_base*>(_method_call())->addOutputPort();
  1371. }
  1372.  
  1373. inline void Arts::MidiClient::removePort(Arts::MidiPort port)
  1374. {
  1375.      _cache?static_cast<Arts::MidiClient_base*>(_cache)->removePort(port):static_cast<Arts::MidiClient_base*>(_method_call())->removePort(port);
  1376. }
  1377.  
  1378. inline void Arts::MidiSyncGroup::addClient(Arts::MidiClient client)
  1379. {
  1380.      _cache?static_cast<Arts::MidiSyncGroup_base*>(_cache)->addClient(client):static_cast<Arts::MidiSyncGroup_base*>(_method_call())->addClient(client);
  1381. }
  1382.  
  1383. inline void Arts::MidiSyncGroup::removeClient(Arts::MidiClient client)
  1384. {
  1385.      _cache?static_cast<Arts::MidiSyncGroup_base*>(_cache)->removeClient(client):static_cast<Arts::MidiSyncGroup_base*>(_method_call())->removeClient(client);
  1386. }
  1387.  
  1388. inline void Arts::MidiSyncGroup::addAudioSync(Arts::AudioSync audioSync)
  1389. {
  1390.      _cache?static_cast<Arts::MidiSyncGroup_base*>(_cache)->addAudioSync(audioSync):static_cast<Arts::MidiSyncGroup_base*>(_method_call())->addAudioSync(audioSync);
  1391. }
  1392.  
  1393. inline void Arts::MidiSyncGroup::removeAudioSync(Arts::AudioSync audioSync)
  1394. {
  1395.      _cache?static_cast<Arts::MidiSyncGroup_base*>(_cache)->removeAudioSync(audioSync):static_cast<Arts::MidiSyncGroup_base*>(_method_call())->removeAudioSync(audioSync);
  1396. }
  1397.  
  1398. inline std::vector<Arts::MidiClientInfo> * Arts::MidiManager::clients()
  1399. {
  1400.     return _cache?static_cast<Arts::MidiManager_base*>(_cache)->clients():static_cast<Arts::MidiManager_base*>(_method_call())->clients();
  1401. }
  1402.  
  1403. inline Arts::MidiClient Arts::MidiManager::addClient(Arts::MidiClientDirection direction, Arts::MidiClientType type, const std::string& title, const std::string& autoRestoreID)
  1404. {
  1405.     return _cache?static_cast<Arts::MidiManager_base*>(_cache)->addClient(direction, type, title, autoRestoreID):static_cast<Arts::MidiManager_base*>(_method_call())->addClient(direction, type, title, autoRestoreID);
  1406. }
  1407.  
  1408. inline void Arts::MidiManager::connect(long clientID, long destinationID)
  1409. {
  1410.      _cache?static_cast<Arts::MidiManager_base*>(_cache)->connect(clientID, destinationID):static_cast<Arts::MidiManager_base*>(_method_call())->connect(clientID, destinationID);
  1411. }
  1412.  
  1413. inline void Arts::MidiManager::disconnect(long clientID, long destinationID)
  1414. {
  1415.      _cache?static_cast<Arts::MidiManager_base*>(_cache)->disconnect(clientID, destinationID):static_cast<Arts::MidiManager_base*>(_method_call())->disconnect(clientID, destinationID);
  1416. }
  1417.  
  1418. inline Arts::MidiSyncGroup Arts::MidiManager::addSyncGroup()
  1419. {
  1420.     return _cache?static_cast<Arts::MidiManager_base*>(_cache)->addSyncGroup():static_cast<Arts::MidiManager_base*>(_method_call())->addSyncGroup();
  1421. }
  1422.  
  1423. inline Arts::TimeStamp Arts::MidiTest::time()
  1424. {
  1425.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->time():static_cast<Arts::MidiPort_base*>(_method_call())->time();
  1426. }
  1427.  
  1428. inline Arts::TimeStamp Arts::MidiTest::playTime()
  1429. {
  1430.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->playTime():static_cast<Arts::MidiPort_base*>(_method_call())->playTime();
  1431. }
  1432.  
  1433. inline void Arts::MidiTest::processCommand(const Arts::MidiCommand& command)
  1434. {
  1435.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processCommand(command):static_cast<Arts::MidiPort_base*>(_method_call())->processCommand(command);
  1436. }
  1437.  
  1438. inline void Arts::MidiTest::processEvent(const Arts::MidiEvent& event)
  1439. {
  1440.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processEvent(event):static_cast<Arts::MidiPort_base*>(_method_call())->processEvent(event);
  1441. }
  1442.  
  1443. inline Arts::TimeStamp Arts::RawMidiPort::time()
  1444. {
  1445.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->time():static_cast<Arts::MidiPort_base*>(_method_call())->time();
  1446. }
  1447.  
  1448. inline Arts::TimeStamp Arts::RawMidiPort::playTime()
  1449. {
  1450.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->playTime():static_cast<Arts::MidiPort_base*>(_method_call())->playTime();
  1451. }
  1452.  
  1453. inline void Arts::RawMidiPort::processCommand(const Arts::MidiCommand& command)
  1454. {
  1455.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processCommand(command):static_cast<Arts::MidiPort_base*>(_method_call())->processCommand(command);
  1456. }
  1457.  
  1458. inline void Arts::RawMidiPort::processEvent(const Arts::MidiEvent& event)
  1459. {
  1460.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processEvent(event):static_cast<Arts::MidiPort_base*>(_method_call())->processEvent(event);
  1461. }
  1462.  
  1463. inline std::string Arts::RawMidiPort::device()
  1464. {
  1465.     return _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->device():static_cast<Arts::RawMidiPort_base*>(_method_call())->device();
  1466. }
  1467.  
  1468. inline void Arts::RawMidiPort::device(const std::string& _newValue)
  1469. {
  1470.      _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->device(_newValue):static_cast<Arts::RawMidiPort_base*>(_method_call())->device(_newValue);
  1471. }
  1472.  
  1473. inline bool Arts::RawMidiPort::input()
  1474. {
  1475.     return _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->input():static_cast<Arts::RawMidiPort_base*>(_method_call())->input();
  1476. }
  1477.  
  1478. inline void Arts::RawMidiPort::input(bool _newValue)
  1479. {
  1480.      _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->input(_newValue):static_cast<Arts::RawMidiPort_base*>(_method_call())->input(_newValue);
  1481. }
  1482.  
  1483. inline bool Arts::RawMidiPort::output()
  1484. {
  1485.     return _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->output():static_cast<Arts::RawMidiPort_base*>(_method_call())->output();
  1486. }
  1487.  
  1488. inline void Arts::RawMidiPort::output(bool _newValue)
  1489. {
  1490.      _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->output(_newValue):static_cast<Arts::RawMidiPort_base*>(_method_call())->output(_newValue);
  1491. }
  1492.  
  1493. inline bool Arts::RawMidiPort::running()
  1494. {
  1495.     return _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->running():static_cast<Arts::RawMidiPort_base*>(_method_call())->running();
  1496. }
  1497.  
  1498. inline void Arts::RawMidiPort::running(bool _newValue)
  1499. {
  1500.      _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->running(_newValue):static_cast<Arts::RawMidiPort_base*>(_method_call())->running(_newValue);
  1501. }
  1502.  
  1503. inline bool Arts::RawMidiPort::open()
  1504. {
  1505.     return _cache?static_cast<Arts::RawMidiPort_base*>(_cache)->open():static_cast<Arts::RawMidiPort_base*>(_method_call())->open();
  1506. }
  1507.  
  1508. inline bool Arts::AlsaMidiGateway::rescan()
  1509. {
  1510.     return _cache?static_cast<Arts::AlsaMidiGateway_base*>(_cache)->rescan():static_cast<Arts::AlsaMidiGateway_base*>(_method_call())->rescan();
  1511. }
  1512.  
  1513. inline Arts::TimeStamp Arts::AlsaMidiPort::time()
  1514. {
  1515.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->time():static_cast<Arts::MidiPort_base*>(_method_call())->time();
  1516. }
  1517.  
  1518. inline Arts::TimeStamp Arts::AlsaMidiPort::playTime()
  1519. {
  1520.     return _cache?static_cast<Arts::MidiPort_base*>(_cache)->playTime():static_cast<Arts::MidiPort_base*>(_method_call())->playTime();
  1521. }
  1522.  
  1523. inline void Arts::AlsaMidiPort::processCommand(const Arts::MidiCommand& command)
  1524. {
  1525.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processCommand(command):static_cast<Arts::MidiPort_base*>(_method_call())->processCommand(command);
  1526. }
  1527.  
  1528. inline void Arts::AlsaMidiPort::processEvent(const Arts::MidiEvent& event)
  1529. {
  1530.      _cache?static_cast<Arts::MidiPort_base*>(_cache)->processEvent(event):static_cast<Arts::MidiPort_base*>(_method_call())->processEvent(event);
  1531. }
  1532.  
  1533. inline long Arts::AlsaMidiPort::client()
  1534. {
  1535.     return _cache?static_cast<Arts::AlsaMidiPort_base*>(_cache)->client():static_cast<Arts::AlsaMidiPort_base*>(_method_call())->client();
  1536. }
  1537.  
  1538. inline void Arts::AlsaMidiPort::client(long _newValue)
  1539. {
  1540.      _cache?static_cast<Arts::AlsaMidiPort_base*>(_cache)->client(_newValue):static_cast<Arts::AlsaMidiPort_base*>(_method_call())->client(_newValue);
  1541. }
  1542.  
  1543. inline long Arts::AlsaMidiPort::port()
  1544. {
  1545.     return _cache?static_cast<Arts::AlsaMidiPort_base*>(_cache)->port():static_cast<Arts::AlsaMidiPort_base*>(_method_call())->port();
  1546. }
  1547.  
  1548. inline void Arts::AlsaMidiPort::port(long _newValue)
  1549. {
  1550.      _cache?static_cast<Arts::AlsaMidiPort_base*>(_cache)->port(_newValue):static_cast<Arts::AlsaMidiPort_base*>(_method_call())->port(_newValue);
  1551. }
  1552.  
  1553. inline bool Arts::AlsaMidiPort::open()
  1554. {
  1555.     return _cache?static_cast<Arts::AlsaMidiPort_base*>(_cache)->open():static_cast<Arts::AlsaMidiPort_base*>(_method_call())->open();
  1556. }
  1557.  
  1558. inline Arts::TimeStamp Arts::AudioSync::time()
  1559. {
  1560.     return _cache?static_cast<Arts::AudioSync_base*>(_cache)->time():static_cast<Arts::AudioSync_base*>(_method_call())->time();
  1561. }
  1562.  
  1563. inline Arts::TimeStamp Arts::AudioSync::playTime()
  1564. {
  1565.     return _cache?static_cast<Arts::AudioSync_base*>(_cache)->playTime():static_cast<Arts::AudioSync_base*>(_method_call())->playTime();
  1566. }
  1567.  
  1568. inline void Arts::AudioSync::queueStart(Arts::SynthModule synthModule)
  1569. {
  1570.      _cache?static_cast<Arts::AudioSync_base*>(_cache)->queueStart(synthModule):static_cast<Arts::AudioSync_base*>(_method_call())->queueStart(synthModule);
  1571. }
  1572.  
  1573. inline void Arts::AudioSync::queueStop(Arts::SynthModule synthModule)
  1574. {
  1575.      _cache?static_cast<Arts::AudioSync_base*>(_cache)->queueStop(synthModule):static_cast<Arts::AudioSync_base*>(_method_call())->queueStop(synthModule);
  1576. }
  1577.  
  1578. inline void Arts::AudioSync::execute()
  1579. {
  1580.      _cache?static_cast<Arts::AudioSync_base*>(_cache)->execute():static_cast<Arts::AudioSync_base*>(_method_call())->execute();
  1581. }
  1582.  
  1583. inline void Arts::AudioSync::executeAt(const Arts::TimeStamp& timeStamp)
  1584. {
  1585.      _cache?static_cast<Arts::AudioSync_base*>(_cache)->executeAt(timeStamp):static_cast<Arts::AudioSync_base*>(_method_call())->executeAt(timeStamp);
  1586. }
  1587.  
  1588. inline Arts::TimeStamp Arts::MidiTimer::time()
  1589. {
  1590.     return _cache?static_cast<Arts::MidiTimer_base*>(_cache)->time():static_cast<Arts::MidiTimer_base*>(_method_call())->time();
  1591. }
  1592.  
  1593. inline void Arts::MidiTimer::queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event)
  1594. {
  1595.      _cache?static_cast<Arts::MidiTimer_base*>(_cache)->queueEvent(port, event):static_cast<Arts::MidiTimer_base*>(_method_call())->queueEvent(port, event);
  1596. }
  1597.  
  1598. inline Arts::TimeStamp Arts::SystemMidiTimer::time()
  1599. {
  1600.     return _cache?static_cast<Arts::MidiTimer_base*>(_cache)->time():static_cast<Arts::MidiTimer_base*>(_method_call())->time();
  1601. }
  1602.  
  1603. inline void Arts::SystemMidiTimer::queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event)
  1604. {
  1605.      _cache?static_cast<Arts::MidiTimer_base*>(_cache)->queueEvent(port, event):static_cast<Arts::MidiTimer_base*>(_method_call())->queueEvent(port, event);
  1606. }
  1607.  
  1608. inline Arts::TimeStamp Arts::AudioMidiTimer::time()
  1609. {
  1610.     return _cache?static_cast<Arts::MidiTimer_base*>(_cache)->time():static_cast<Arts::MidiTimer_base*>(_method_call())->time();
  1611. }
  1612.  
  1613. inline void Arts::AudioMidiTimer::queueEvent(Arts::MidiPort port, const Arts::MidiEvent& event)
  1614. {
  1615.      _cache?static_cast<Arts::MidiTimer_base*>(_cache)->queueEvent(port, event):static_cast<Arts::MidiTimer_base*>(_method_call())->queueEvent(port, event);
  1616. }
  1617.  
  1618. #endif /* ARTSMIDI_H */
  1619.