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 / artsmodules.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-24  |  9.8 KB  |  285 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSMODULES_H
  4. #define ARTSMODULES_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsflow.h"
  12. #include "artsmidi.h"
  13. #include "artsgui.h"
  14. #include "artsmodulescommon.h"
  15. #include "artsmodulessynth.h"
  16. #include "artsmoduleseffects.h"
  17. #include "artsmodulesmixers.h"
  18.  
  19. namespace Arts {
  20. class Interface_MIDI_NOTE;
  21. class Synth_STRUCT_KILL;
  22.  
  23. class ARTS_EXPORT Interface_MIDI_NOTE_base : virtual public Arts::SynthModule_base {
  24. public:
  25.     static unsigned long _IID; // interface ID
  26.  
  27.     static Interface_MIDI_NOTE_base *_create(const std::string& subClass = "Arts::Interface_MIDI_NOTE");
  28.     static Interface_MIDI_NOTE_base *_fromString(const std::string& objectref);
  29.     static Interface_MIDI_NOTE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  30.  
  31.     static Interface_MIDI_NOTE_base *_fromDynamicCast(const Arts::Object& object);
  32.     inline Interface_MIDI_NOTE_base *_copy() {
  33.         assert(_refCnt > 0);
  34.         _refCnt++;
  35.         return this;
  36.     }
  37.  
  38.     virtual std::vector<std::string> _defaultPortsIn() const;
  39.     virtual std::vector<std::string> _defaultPortsOut() const;
  40.  
  41.     void *_cast(unsigned long iid);
  42.  
  43. };
  44.  
  45. class ARTS_EXPORT Interface_MIDI_NOTE_stub : virtual public Interface_MIDI_NOTE_base, virtual public Arts::SynthModule_stub {
  46. protected:
  47.     Interface_MIDI_NOTE_stub();
  48.  
  49. public:
  50.     Interface_MIDI_NOTE_stub(Arts::Connection *connection, long objectID);
  51.  
  52. };
  53.  
  54. class ARTS_EXPORT Interface_MIDI_NOTE_skel : virtual public Interface_MIDI_NOTE_base, virtual public Arts::SynthModule_skel {
  55. protected:
  56.     // variables for streams
  57.     float *frequency;                         // outgoing stream
  58.     float *velocity;                          // outgoing stream
  59.     float *pressed;                           // outgoing stream
  60.  
  61. public:
  62.     Interface_MIDI_NOTE_skel();
  63.  
  64.     static std::string _interfaceNameSkel();
  65.     std::string _interfaceName();
  66.     bool _isCompatibleWith(const std::string& interfacename);
  67.     void _buildMethodTable();
  68.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  69. };
  70.  
  71. }
  72. #include "reference.h"
  73. namespace Arts {
  74. class ARTS_EXPORT Interface_MIDI_NOTE : public Arts::Object {
  75. private:
  76.     static Arts::Object_base* _Creator();
  77.     Interface_MIDI_NOTE_base *_cache;
  78.     inline Interface_MIDI_NOTE_base *_method_call() {
  79.         _pool->checkcreate();
  80.         if(_pool->base) {
  81.             _cache=(Interface_MIDI_NOTE_base *)_pool->base->_cast(Interface_MIDI_NOTE_base::_IID);
  82.             assert(_cache);
  83.         }
  84.         return _cache;
  85.     }
  86.  
  87. protected:
  88.     inline Interface_MIDI_NOTE(Interface_MIDI_NOTE_base* b) : Arts::Object(b), _cache(0) {}
  89.  
  90.  
  91. public:
  92.     typedef Interface_MIDI_NOTE_base _base_class;
  93.  
  94.     inline Interface_MIDI_NOTE() : Arts::Object(_Creator), _cache(0) {}
  95.     inline Interface_MIDI_NOTE(const Arts::SubClass& s) :
  96.         Arts::Object(Interface_MIDI_NOTE_base::_create(s.string())), _cache(0) {}
  97.     inline Interface_MIDI_NOTE(const Arts::Reference &r) :
  98.         Arts::Object(r.isString()?(Interface_MIDI_NOTE_base::_fromString(r.string())):(Interface_MIDI_NOTE_base::_fromReference(r.reference(),true))), _cache(0) {}
  99.     inline Interface_MIDI_NOTE(const Arts::DynamicCast& c) : Arts::Object(Interface_MIDI_NOTE_base::_fromDynamicCast(c.object())), _cache(0) {}
  100.     inline Interface_MIDI_NOTE(const Interface_MIDI_NOTE& target) : Arts::Object(target._pool), _cache(target._cache) {}
  101.     inline Interface_MIDI_NOTE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  102.     inline static Interface_MIDI_NOTE null() {return Interface_MIDI_NOTE((Interface_MIDI_NOTE_base*)0);}
  103.     inline static Interface_MIDI_NOTE _from_base(Interface_MIDI_NOTE_base* b) {return Interface_MIDI_NOTE(b);}
  104.     inline Interface_MIDI_NOTE& operator=(const Interface_MIDI_NOTE& target) {
  105.         if (_pool == target._pool) return *this;
  106.         _pool->Dec();
  107.         _pool = target._pool;
  108.         _cache = target._cache;
  109.         _pool->Inc();
  110.         return *this;
  111.     }
  112.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  113.     inline Interface_MIDI_NOTE_base* _base() {return _cache?_cache:_method_call();}
  114.  
  115.     inline Arts::AutoSuspendState autoSuspend();
  116.     inline void start();
  117.     inline void stop();
  118.     inline void streamInit();
  119.     inline void streamStart();
  120.     inline void streamEnd();
  121. };
  122.  
  123. class ARTS_EXPORT Synth_STRUCT_KILL_base : virtual public Arts::SynthModule_base {
  124. public:
  125.     static unsigned long _IID; // interface ID
  126.  
  127.     static Synth_STRUCT_KILL_base *_create(const std::string& subClass = "Arts::Synth_STRUCT_KILL");
  128.     static Synth_STRUCT_KILL_base *_fromString(const std::string& objectref);
  129.     static Synth_STRUCT_KILL_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  130.  
  131.     static Synth_STRUCT_KILL_base *_fromDynamicCast(const Arts::Object& object);
  132.     inline Synth_STRUCT_KILL_base *_copy() {
  133.         assert(_refCnt > 0);
  134.         _refCnt++;
  135.         return this;
  136.     }
  137.  
  138.     virtual std::vector<std::string> _defaultPortsIn() const;
  139.     virtual std::vector<std::string> _defaultPortsOut() const;
  140.  
  141.     void *_cast(unsigned long iid);
  142.  
  143. };
  144.  
  145. class ARTS_EXPORT Synth_STRUCT_KILL_stub : virtual public Synth_STRUCT_KILL_base, virtual public Arts::SynthModule_stub {
  146. protected:
  147.     Synth_STRUCT_KILL_stub();
  148.  
  149. public:
  150.     Synth_STRUCT_KILL_stub(Arts::Connection *connection, long objectID);
  151.  
  152. };
  153.  
  154. class ARTS_EXPORT Synth_STRUCT_KILL_skel : virtual public Synth_STRUCT_KILL_base, virtual public Arts::SynthModule_skel {
  155. protected:
  156.     // variables for streams
  157.     float *ready;                             // incoming stream
  158.  
  159. public:
  160.     Synth_STRUCT_KILL_skel();
  161.  
  162.     static std::string _interfaceNameSkel();
  163.     std::string _interfaceName();
  164.     bool _isCompatibleWith(const std::string& interfacename);
  165.     void _buildMethodTable();
  166.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  167. };
  168.  
  169. }
  170. #include "reference.h"
  171. namespace Arts {
  172. class ARTS_EXPORT Synth_STRUCT_KILL : public Arts::Object {
  173. private:
  174.     static Arts::Object_base* _Creator();
  175.     Synth_STRUCT_KILL_base *_cache;
  176.     inline Synth_STRUCT_KILL_base *_method_call() {
  177.         _pool->checkcreate();
  178.         if(_pool->base) {
  179.             _cache=(Synth_STRUCT_KILL_base *)_pool->base->_cast(Synth_STRUCT_KILL_base::_IID);
  180.             assert(_cache);
  181.         }
  182.         return _cache;
  183.     }
  184.  
  185. protected:
  186.     inline Synth_STRUCT_KILL(Synth_STRUCT_KILL_base* b) : Arts::Object(b), _cache(0) {}
  187.  
  188.  
  189. public:
  190.     typedef Synth_STRUCT_KILL_base _base_class;
  191.  
  192.     inline Synth_STRUCT_KILL() : Arts::Object(_Creator), _cache(0) {}
  193.     inline Synth_STRUCT_KILL(const Arts::SubClass& s) :
  194.         Arts::Object(Synth_STRUCT_KILL_base::_create(s.string())), _cache(0) {}
  195.     inline Synth_STRUCT_KILL(const Arts::Reference &r) :
  196.         Arts::Object(r.isString()?(Synth_STRUCT_KILL_base::_fromString(r.string())):(Synth_STRUCT_KILL_base::_fromReference(r.reference(),true))), _cache(0) {}
  197.     inline Synth_STRUCT_KILL(const Arts::DynamicCast& c) : Arts::Object(Synth_STRUCT_KILL_base::_fromDynamicCast(c.object())), _cache(0) {}
  198.     inline Synth_STRUCT_KILL(const Synth_STRUCT_KILL& target) : Arts::Object(target._pool), _cache(target._cache) {}
  199.     inline Synth_STRUCT_KILL(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  200.     inline static Synth_STRUCT_KILL null() {return Synth_STRUCT_KILL((Synth_STRUCT_KILL_base*)0);}
  201.     inline static Synth_STRUCT_KILL _from_base(Synth_STRUCT_KILL_base* b) {return Synth_STRUCT_KILL(b);}
  202.     inline Synth_STRUCT_KILL& operator=(const Synth_STRUCT_KILL& target) {
  203.         if (_pool == target._pool) return *this;
  204.         _pool->Dec();
  205.         _pool = target._pool;
  206.         _cache = target._cache;
  207.         _pool->Inc();
  208.         return *this;
  209.     }
  210.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  211.     inline Synth_STRUCT_KILL_base* _base() {return _cache?_cache:_method_call();}
  212.  
  213.     inline Arts::AutoSuspendState autoSuspend();
  214.     inline void start();
  215.     inline void stop();
  216.     inline void streamInit();
  217.     inline void streamStart();
  218.     inline void streamEnd();
  219. };
  220.  
  221. }
  222. // Forward wrapper calls to _base classes:
  223.  
  224. inline Arts::AutoSuspendState Arts::Interface_MIDI_NOTE::autoSuspend()
  225. {
  226.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  227. }
  228.  
  229. inline void Arts::Interface_MIDI_NOTE::start()
  230. {
  231.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  232. }
  233.  
  234. inline void Arts::Interface_MIDI_NOTE::stop()
  235. {
  236.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  237. }
  238.  
  239. inline void Arts::Interface_MIDI_NOTE::streamInit()
  240. {
  241.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  242. }
  243.  
  244. inline void Arts::Interface_MIDI_NOTE::streamStart()
  245. {
  246.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  247. }
  248.  
  249. inline void Arts::Interface_MIDI_NOTE::streamEnd()
  250. {
  251.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  252. }
  253.  
  254. inline Arts::AutoSuspendState Arts::Synth_STRUCT_KILL::autoSuspend()
  255. {
  256.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  257. }
  258.  
  259. inline void Arts::Synth_STRUCT_KILL::start()
  260. {
  261.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  262. }
  263.  
  264. inline void Arts::Synth_STRUCT_KILL::stop()
  265. {
  266.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  267. }
  268.  
  269. inline void Arts::Synth_STRUCT_KILL::streamInit()
  270. {
  271.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  272. }
  273.  
  274. inline void Arts::Synth_STRUCT_KILL::streamStart()
  275. {
  276.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  277. }
  278.  
  279. inline void Arts::Synth_STRUCT_KILL::streamEnd()
  280. {
  281.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  282. }
  283.  
  284. #endif /* ARTSMODULES_H */
  285.