← Back to branch summary

~ubuntu-branches/ubuntu/hoary/kdemultimedia/hoary

« back to all changes in this revision

Viewing changes to noatun/noatun/modules/artseffects/artseffects.h

  • Committer: Bazaar Package Importer
  • Author(s): Martin Schulze
  • Date: 2003-01-22 15:00:51 UTC
  • Revision ID: james.westby@ubuntu.com-20030122150051-uihwkdoxf15mi1tn
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
noatun/noatun/modules/artseffects/artseffects.h
 
1
/* this file was generated by the MCOP idl compiler - DO NOT EDIT */
 
2
 
 
3
#ifndef ARTSEFFECTS_H
 
4
#define ARTSEFFECTS_H
 
5
 
 
6
#include "common.h"
 
7
 
 
8
// includes of other idl definitions
 
9
#include "artsflow.h"
 
10
#include "artsgui.h"
 
11
 
 
12
class ExtraStereo;
 
13
class VoiceRemoval;
 
14
class RawWriter;
 
15
class ExtraStereoGuiFactory;
 
16
 
 
17
class ExtraStereo_base : virtual public Arts::StereoEffect_base {
 
18
public:
 
19
        static unsigned long _IID; // interface ID
 
20
 
 
21
        static ExtraStereo_base *_create(const std::string& subClass = "ExtraStereo");
 
22
        static ExtraStereo_base *_fromString(std::string objectref);
 
23
        static ExtraStereo_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
 
24
 
 
25
        static ExtraStereo_base *_fromDynamicCast(const Arts::Object& object);
 
26
        inline ExtraStereo_base *_copy() {
 
27
                assert(_refCnt > 0);
 
28
                _refCnt++;
 
29
                return this;
 
30
        }
 
31
 
 
32
        virtual std::vector<std::string> _defaultPortsIn() const;
 
33
        virtual std::vector<std::string> _defaultPortsOut() const;
 
34
 
 
35
        void *_cast(unsigned long iid);
 
36
 
 
37
        virtual float intensity() = 0;
 
38
        virtual void intensity(float newValue) = 0;
 
39
};
 
40
 
 
41
class ExtraStereo_stub : virtual public ExtraStereo_base, virtual public Arts::StereoEffect_stub {
 
42
protected:
 
43
        ExtraStereo_stub();
 
44
 
 
45
public:
 
46
        ExtraStereo_stub(Arts::Connection *connection, long objectID);
 
47
 
 
48
        float intensity();
 
49
        void intensity(float newValue);
 
50
};
 
51
 
 
52
class ExtraStereo_skel : virtual public ExtraStereo_base, virtual public Arts::StereoEffect_skel {
 
53
protected:
 
54
        // emitters for change notifications
 
55
        inline void intensity_changed(float newValue) {
 
56
                _emit_changed("intensity_changed",newValue);
 
57
        }
 
58
 
 
59
public:
 
60
        ExtraStereo_skel();
 
61
 
 
62
        static std::string _interfaceNameSkel();
 
63
        std::string _interfaceName();
 
64
        bool _isCompatibleWith(const std::string& interfacename);
 
65
        void _buildMethodTable();
 
66
        void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
 
67
};
 
68
 
 
69
#include "reference.h"
 
70
class ExtraStereo : public Arts::Object {
 
71
private:
 
72
        static Arts::Object_base* _Creator();
 
73
        ExtraStereo_base *_cache;
 
74
        inline ExtraStereo_base *_method_call() {
 
75
                _pool->checkcreate();
 
76
                if(_pool->base) {
 
77
                        _cache=(ExtraStereo_base *)_pool->base->_cast(ExtraStereo_base::_IID);
 
78
                        assert(_cache);
 
79
                }
 
80
                return _cache;
 
81
        }
 
82
 
 
83
protected:
 
84
        inline ExtraStereo(ExtraStereo_base* b) : Arts::Object(b), _cache(0) {}
 
85
 
 
86
 
 
87
public:
 
88
        typedef ExtraStereo_base _base_class;
 
89
 
 
90
        inline ExtraStereo() : Arts::Object(_Creator), _cache(0) {}
 
91
        inline ExtraStereo(const Arts::SubClass& s) :
 
92
                Arts::Object(ExtraStereo_base::_create(s.string())), _cache(0) {}
 
93
        inline ExtraStereo(const Arts::Reference &r) :
 
94
                Arts::Object(r.isString()?(ExtraStereo_base::_fromString(r.string())):(ExtraStereo_base::_fromReference(r.reference(),true))), _cache(0) {}
 
95
        inline ExtraStereo(const Arts::DynamicCast& c) : Arts::Object(ExtraStereo_base::_fromDynamicCast(c.object())), _cache(0) {}
 
96
        inline ExtraStereo(const ExtraStereo& target) : Arts::Object(target._pool), _cache(target._cache) {}
 
97
        inline ExtraStereo(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
 
98
        inline static ExtraStereo null() {return ExtraStereo((ExtraStereo_base*)0);}
 
99
        inline static ExtraStereo _from_base(ExtraStereo_base* b) {return ExtraStereo(b);}
 
100
        inline ExtraStereo& operator=(const ExtraStereo& target) {
 
101
                if (_pool == target._pool) return *this;
 
102
                _pool->Dec();
 
103
                _pool = target._pool;
 
104
                _cache = target._cache;
 
105
                _pool->Inc();
 
106
                return *this;
 
107
        }
 
108
        inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
 
109
        inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
 
110
        inline ExtraStereo_base* _base() {return _cache?_cache:_method_call();}
 
111
 
 
112
        inline Arts::AutoSuspendState autoSuspend();
 
113
        inline void start();
 
114
        inline void stop();
 
115
        inline void streamInit();
 
116
        inline void streamStart();
 
117
        inline void streamEnd();
 
118
        inline float intensity();
 
119
        inline void intensity(float _newValue);
 
120
};
 
121
 
 
122
class VoiceRemoval_base : virtual public Arts::StereoEffect_base {
 
123
public:
 
124
        static unsigned long _IID; // interface ID
 
125
 
 
126
        static VoiceRemoval_base *_create(const std::string& subClass = "VoiceRemoval");
 
127
        static VoiceRemoval_base *_fromString(std::string objectref);
 
128
        static VoiceRemoval_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
 
129
 
 
130
        static VoiceRemoval_base *_fromDynamicCast(const Arts::Object& object);
 
131
        inline VoiceRemoval_base *_copy() {
 
132
                assert(_refCnt > 0);
 
133
                _refCnt++;
 
134
                return this;
 
135
        }
 
136
 
 
137
        virtual std::vector<std::string> _defaultPortsIn() const;
 
138
        virtual std::vector<std::string> _defaultPortsOut() const;
 
139
 
 
140
        void *_cast(unsigned long iid);
 
141
 
 
142
};
 
143
 
 
144
class VoiceRemoval_stub : virtual public VoiceRemoval_base, virtual public Arts::StereoEffect_stub {
 
145
protected:
 
146
        VoiceRemoval_stub();
 
147
 
 
148
public:
 
149
        VoiceRemoval_stub(Arts::Connection *connection, long objectID);
 
150
 
 
151
};
 
152
 
 
153
class VoiceRemoval_skel : virtual public VoiceRemoval_base, virtual public Arts::StereoEffect_skel {
 
154
public:
 
155
        VoiceRemoval_skel();
 
156
 
 
157
        static std::string _interfaceNameSkel();
 
158
        std::string _interfaceName();
 
159
        bool _isCompatibleWith(const std::string& interfacename);
 
160
        void _buildMethodTable();
 
161
        void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
 
162
};
 
163
 
 
164
#include "reference.h"
 
165
class VoiceRemoval : public Arts::Object {
 
166
private:
 
167
        static Arts::Object_base* _Creator();
 
168
        VoiceRemoval_base *_cache;
 
169
        inline VoiceRemoval_base *_method_call() {
 
170
                _pool->checkcreate();
 
171
                if(_pool->base) {
 
172
                        _cache=(VoiceRemoval_base *)_pool->base->_cast(VoiceRemoval_base::_IID);
 
173
                        assert(_cache);
 
174
                }
 
175
                return _cache;
 
176
        }
 
177
 
 
178
protected:
 
179
        inline VoiceRemoval(VoiceRemoval_base* b) : Arts::Object(b), _cache(0) {}
 
180
 
 
181
 
 
182
public:
 
183
        typedef VoiceRemoval_base _base_class;
 
184
 
 
185
        inline VoiceRemoval() : Arts::Object(_Creator), _cache(0) {}
 
186
        inline VoiceRemoval(const Arts::SubClass& s) :
 
187
                Arts::Object(VoiceRemoval_base::_create(s.string())), _cache(0) {}
 
188
        inline VoiceRemoval(const Arts::Reference &r) :
 
189
                Arts::Object(r.isString()?(VoiceRemoval_base::_fromString(r.string())):(VoiceRemoval_base::_fromReference(r.reference(),true))), _cache(0) {}
 
190
        inline VoiceRemoval(const Arts::DynamicCast& c) : Arts::Object(VoiceRemoval_base::_fromDynamicCast(c.object())), _cache(0) {}
 
191
        inline VoiceRemoval(const VoiceRemoval& target) : Arts::Object(target._pool), _cache(target._cache) {}
 
192
        inline VoiceRemoval(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
 
193
        inline static VoiceRemoval null() {return VoiceRemoval((VoiceRemoval_base*)0);}
 
194
        inline static VoiceRemoval _from_base(VoiceRemoval_base* b) {return VoiceRemoval(b);}
 
195
        inline VoiceRemoval& operator=(const VoiceRemoval& target) {
 
196
                if (_pool == target._pool) return *this;
 
197
                _pool->Dec();
 
198
                _pool = target._pool;
 
199
                _cache = target._cache;
 
200
                _pool->Inc();
 
201
                return *this;
 
202
        }
 
203
        inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
 
204
        inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
 
205
        inline VoiceRemoval_base* _base() {return _cache?_cache:_method_call();}
 
206
 
 
207
        inline Arts::AutoSuspendState autoSuspend();
 
208
        inline void start();
 
209
        inline void stop();
 
210
        inline void streamInit();
 
211
        inline void streamStart();
 
212
        inline void streamEnd();
 
213
};
 
214
 
 
215
class RawWriter_base : virtual public Arts::StereoEffect_base {
 
216
public:
 
217
        static unsigned long _IID; // interface ID
 
218
 
 
219
        static RawWriter_base *_create(const std::string& subClass = "RawWriter");
 
220
        static RawWriter_base *_fromString(std::string objectref);
 
221
        static RawWriter_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
 
222
 
 
223
        static RawWriter_base *_fromDynamicCast(const Arts::Object& object);
 
224
        inline RawWriter_base *_copy() {
 
225
                assert(_refCnt > 0);
 
226
                _refCnt++;
 
227
                return this;
 
228
        }
 
229
 
 
230
        virtual std::vector<std::string> _defaultPortsIn() const;
 
231
        virtual std::vector<std::string> _defaultPortsOut() const;
 
232
 
 
233
        void *_cast(unsigned long iid);
 
234
 
 
235
};
 
236
 
 
237
class RawWriter_stub : virtual public RawWriter_base, virtual public Arts::StereoEffect_stub {
 
238
protected:
 
239
        RawWriter_stub();
 
240
 
 
241
public:
 
242
        RawWriter_stub(Arts::Connection *connection, long objectID);
 
243
 
 
244
};
 
245
 
 
246
class RawWriter_skel : virtual public RawWriter_base, virtual public Arts::StereoEffect_skel {
 
247
public:
 
248
        RawWriter_skel();
 
249
 
 
250
        static std::string _interfaceNameSkel();
 
251
        std::string _interfaceName();
 
252
        bool _isCompatibleWith(const std::string& interfacename);
 
253
        void _buildMethodTable();
 
254
        void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
 
255
};
 
256
 
 
257
#include "reference.h"
 
258
class RawWriter : public Arts::Object {
 
259
private:
 
260
        static Arts::Object_base* _Creator();
 
261
        RawWriter_base *_cache;
 
262
        inline RawWriter_base *_method_call() {
 
263
                _pool->checkcreate();
 
264
                if(_pool->base) {
 
265
                        _cache=(RawWriter_base *)_pool->base->_cast(RawWriter_base::_IID);
 
266
                        assert(_cache);
 
267
                }
 
268
                return _cache;
 
269
        }
 
270
 
 
271
protected:
 
272
        inline RawWriter(RawWriter_base* b) : Arts::Object(b), _cache(0) {}
 
273
 
 
274
 
 
275
public:
 
276
        typedef RawWriter_base _base_class;
 
277
 
 
278
        inline RawWriter() : Arts::Object(_Creator), _cache(0) {}
 
279
        inline RawWriter(const Arts::SubClass& s) :
 
280
                Arts::Object(RawWriter_base::_create(s.string())), _cache(0) {}
 
281
        inline RawWriter(const Arts::Reference &r) :
 
282
                Arts::Object(r.isString()?(RawWriter_base::_fromString(r.string())):(RawWriter_base::_fromReference(r.reference(),true))), _cache(0) {}
 
283
        inline RawWriter(const Arts::DynamicCast& c) : Arts::Object(RawWriter_base::_fromDynamicCast(c.object())), _cache(0) {}
 
284
        inline RawWriter(const RawWriter& target) : Arts::Object(target._pool), _cache(target._cache) {}
 
285
        inline RawWriter(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
 
286
        inline static RawWriter null() {return RawWriter((RawWriter_base*)0);}
 
287
        inline static RawWriter _from_base(RawWriter_base* b) {return RawWriter(b);}
 
288
        inline RawWriter& operator=(const RawWriter& target) {
 
289
                if (_pool == target._pool) return *this;
 
290
                _pool->Dec();
 
291
                _pool = target._pool;
 
292
                _cache = target._cache;
 
293
                _pool->Inc();
 
294
                return *this;
 
295
        }
 
296
        inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
 
297
        inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
 
298
        inline RawWriter_base* _base() {return _cache?_cache:_method_call();}
 
299
 
 
300
        inline Arts::AutoSuspendState autoSuspend();
 
301
        inline void start();
 
302
        inline void stop();
 
303
        inline void streamInit();
 
304
        inline void streamStart();
 
305
        inline void streamEnd();
 
306
};
 
307
 
 
308
class ExtraStereoGuiFactory_base : virtual public Arts::GuiFactory_base {
 
309
public:
 
310
        static unsigned long _IID; // interface ID
 
311
 
 
312
        static ExtraStereoGuiFactory_base *_create(const std::string& subClass = "ExtraStereoGuiFactory");
 
313
        static ExtraStereoGuiFactory_base *_fromString(std::string objectref);
 
314
        static ExtraStereoGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
 
315
 
 
316
        static ExtraStereoGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
 
317
        inline ExtraStereoGuiFactory_base *_copy() {
 
318
                assert(_refCnt > 0);
 
319
                _refCnt++;
 
320
                return this;
 
321
        }
 
322
 
 
323
        virtual std::vector<std::string> _defaultPortsIn() const;
 
324
        virtual std::vector<std::string> _defaultPortsOut() const;
 
325
 
 
326
        void *_cast(unsigned long iid);
 
327
 
 
328
};
 
329
 
 
330
class ExtraStereoGuiFactory_stub : virtual public ExtraStereoGuiFactory_base, virtual public Arts::GuiFactory_stub {
 
331
protected:
 
332
        ExtraStereoGuiFactory_stub();
 
333
 
 
334
public:
 
335
        ExtraStereoGuiFactory_stub(Arts::Connection *connection, long objectID);
 
336
 
 
337
};
 
338
 
 
339
class ExtraStereoGuiFactory_skel : virtual public ExtraStereoGuiFactory_base, virtual public Arts::GuiFactory_skel {
 
340
public:
 
341
        ExtraStereoGuiFactory_skel();
 
342
 
 
343
        static std::string _interfaceNameSkel();
 
344
        std::string _interfaceName();
 
345
        bool _isCompatibleWith(const std::string& interfacename);
 
346
        void _buildMethodTable();
 
347
        void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
 
348
};
 
349
 
 
350
#include "reference.h"
 
351
class ExtraStereoGuiFactory : public Arts::Object {
 
352
private:
 
353
        static Arts::Object_base* _Creator();
 
354
        ExtraStereoGuiFactory_base *_cache;
 
355
        inline ExtraStereoGuiFactory_base *_method_call() {
 
356
                _pool->checkcreate();
 
357
                if(_pool->base) {
 
358
                        _cache=(ExtraStereoGuiFactory_base *)_pool->base->_cast(ExtraStereoGuiFactory_base::_IID);
 
359
                        assert(_cache);
 
360
                }
 
361
                return _cache;
 
362
        }
 
363
 
 
364
protected:
 
365
        inline ExtraStereoGuiFactory(ExtraStereoGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
 
366
 
 
367
 
 
368
public:
 
369
        typedef ExtraStereoGuiFactory_base _base_class;
 
370
 
 
371
        inline ExtraStereoGuiFactory() : Arts::Object(_Creator), _cache(0) {}
 
372
        inline ExtraStereoGuiFactory(const Arts::SubClass& s) :
 
373
                Arts::Object(ExtraStereoGuiFactory_base::_create(s.string())), _cache(0) {}
 
374
        inline ExtraStereoGuiFactory(const Arts::Reference &r) :
 
375
                Arts::Object(r.isString()?(ExtraStereoGuiFactory_base::_fromString(r.string())):(ExtraStereoGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
 
376
        inline ExtraStereoGuiFactory(const Arts::DynamicCast& c) : Arts::Object(ExtraStereoGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
 
377
        inline ExtraStereoGuiFactory(const ExtraStereoGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
 
378
        inline ExtraStereoGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
 
379
        inline static ExtraStereoGuiFactory null() {return ExtraStereoGuiFactory((ExtraStereoGuiFactory_base*)0);}
 
380
        inline static ExtraStereoGuiFactory _from_base(ExtraStereoGuiFactory_base* b) {return ExtraStereoGuiFactory(b);}
 
381
        inline ExtraStereoGuiFactory& operator=(const ExtraStereoGuiFactory& target) {
 
382
                if (_pool == target._pool) return *this;
 
383
                _pool->Dec();
 
384
                _pool = target._pool;
 
385
                _cache = target._cache;
 
386
                _pool->Inc();
 
387
                return *this;
 
388
        }
 
389
        inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
 
390
        inline ExtraStereoGuiFactory_base* _base() {return _cache?_cache:_method_call();}
 
391
 
 
392
        inline Arts::Widget createGui(Arts::Object runningObject);
 
393
};
 
394
 
 
395
// Forward wrapper calls to _base classes:
 
396
 
 
397
inline Arts::AutoSuspendState ExtraStereo::autoSuspend()
 
398
{
 
399
        return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
 
400
}
 
401
 
 
402
inline void ExtraStereo::start()
 
403
{
 
404
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
 
405
}
 
406
 
 
407
inline void ExtraStereo::stop()
 
408
{
 
409
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
 
410
}
 
411
 
 
412
inline void ExtraStereo::streamInit()
 
413
{
 
414
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
 
415
}
 
416
 
 
417
inline void ExtraStereo::streamStart()
 
418
{
 
419
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
 
420
}
 
421
 
 
422
inline void ExtraStereo::streamEnd()
 
423
{
 
424
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
 
425
}
 
426
 
 
427
inline float ExtraStereo::intensity()
 
428
{
 
429
        return _cache?static_cast<ExtraStereo_base*>(_cache)->intensity():static_cast<ExtraStereo_base*>(_method_call())->intensity();
 
430
}
 
431
 
 
432
inline void ExtraStereo::intensity(float _newValue)
 
433
{
 
434
         _cache?static_cast<ExtraStereo_base*>(_cache)->intensity(_newValue):static_cast<ExtraStereo_base*>(_method_call())->intensity(_newValue);
 
435
}
 
436
 
 
437
inline Arts::AutoSuspendState VoiceRemoval::autoSuspend()
 
438
{
 
439
        return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
 
440
}
 
441
 
 
442
inline void VoiceRemoval::start()
 
443
{
 
444
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
 
445
}
 
446
 
 
447
inline void VoiceRemoval::stop()
 
448
{
 
449
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
 
450
}
 
451
 
 
452
inline void VoiceRemoval::streamInit()
 
453
{
 
454
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
 
455
}
 
456
 
 
457
inline void VoiceRemoval::streamStart()
 
458
{
 
459
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
 
460
}
 
461
 
 
462
inline void VoiceRemoval::streamEnd()
 
463
{
 
464
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
 
465
}
 
466
 
 
467
inline Arts::AutoSuspendState RawWriter::autoSuspend()
 
468
{
 
469
        return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
 
470
}
 
471
 
 
472
inline void RawWriter::start()
 
473
{
 
474
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
 
475
}
 
476
 
 
477
inline void RawWriter::stop()
 
478
{
 
479
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
 
480
}
 
481
 
 
482
inline void RawWriter::streamInit()
 
483
{
 
484
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
 
485
}
 
486
 
 
487
inline void RawWriter::streamStart()
 
488
{
 
489
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
 
490
}
 
491
 
 
492
inline void RawWriter::streamEnd()
 
493
{
 
494
         _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
 
495
}
 
496
 
 
497
inline Arts::Widget ExtraStereoGuiFactory::createGui(Arts::Object runningObject)
 
498
{
 
499
        return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
 
500
}
 
501
 
 
502
#endif /* ARTSEFFECTS_H */