/* this file was generated by the MCOP idl compiler - DO NOT EDIT */

#ifndef XINEPLAYOBJECT_H
#define XINEPLAYOBJECT_H

#include "common.h"

#include "arts_export.h"

// includes of other idl definitions
#include "kmedia2.h"
#include "artsflow.h"
#include "soundserver.h"
#include "core.h"

class xinePlayObject;
class xineAudioPlayObject;
class xineVideoPlayObject;

class ARTS_EXPORT xinePlayObject_base : virtual public Arts::PlayObject_base,
	virtual public Arts::SynthModule_base {
public:
	static unsigned long _IID; // interface ID

	static xinePlayObject_base *_create(const std::string& subClass = "xinePlayObject");
	static xinePlayObject_base *_fromString(const std::string& objectref);
	static xinePlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static xinePlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline xinePlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT xinePlayObject_stub : virtual public xinePlayObject_base, virtual public Arts::PlayObject_stub,
	virtual public Arts::SynthModule_stub {
protected:
	xinePlayObject_stub();

public:
	xinePlayObject_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT xinePlayObject_skel : virtual public xinePlayObject_base, virtual public Arts::PlayObject_skel,
	virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *left;                              // outgoing stream
	float *right;                             // outgoing stream

public:
	xinePlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class ARTS_EXPORT xinePlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	xinePlayObject_base *_cache;
	inline xinePlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(xinePlayObject_base *)_pool->base->_cast(xinePlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline xinePlayObject(xinePlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef xinePlayObject_base _base_class;

	inline xinePlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline xinePlayObject(const Arts::SubClass& s) :
		Arts::Object(xinePlayObject_base::_create(s.string())), _cache(0) {}
	inline xinePlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(xinePlayObject_base::_fromString(r.string())):(xinePlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline xinePlayObject(const Arts::DynamicCast& c) : Arts::Object(xinePlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline xinePlayObject(const xinePlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline xinePlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static xinePlayObject null() {return xinePlayObject((xinePlayObject_base*)0);}
	inline static xinePlayObject _from_base(xinePlayObject_base* b) {return xinePlayObject(b);}
	inline xinePlayObject& operator=(const xinePlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline xinePlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
};

class ARTS_EXPORT xineAudioPlayObject_base : virtual public xinePlayObject_base,
	virtual public Arts::PlayObject_base,
	virtual public Arts::SynthModule_base {
public:
	static unsigned long _IID; // interface ID

	static xineAudioPlayObject_base *_create(const std::string& subClass = "xineAudioPlayObject");
	static xineAudioPlayObject_base *_fromString(const std::string& objectref);
	static xineAudioPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static xineAudioPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline xineAudioPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT xineAudioPlayObject_stub : virtual public xineAudioPlayObject_base, virtual public xinePlayObject_stub,
	virtual public Arts::PlayObject_stub,
	virtual public Arts::SynthModule_stub {
protected:
	xineAudioPlayObject_stub();

public:
	xineAudioPlayObject_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT xineAudioPlayObject_skel : virtual public xineAudioPlayObject_base, virtual public xinePlayObject_skel,
	virtual public Arts::PlayObject_skel,
	virtual public Arts::SynthModule_skel {
public:
	xineAudioPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class ARTS_EXPORT xineAudioPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	xineAudioPlayObject_base *_cache;
	inline xineAudioPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(xineAudioPlayObject_base *)_pool->base->_cast(xineAudioPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline xineAudioPlayObject(xineAudioPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef xineAudioPlayObject_base _base_class;

	inline xineAudioPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline xineAudioPlayObject(const Arts::SubClass& s) :
		Arts::Object(xineAudioPlayObject_base::_create(s.string())), _cache(0) {}
	inline xineAudioPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(xineAudioPlayObject_base::_fromString(r.string())):(xineAudioPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline xineAudioPlayObject(const Arts::DynamicCast& c) : Arts::Object(xineAudioPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline xineAudioPlayObject(const xineAudioPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline xineAudioPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static xineAudioPlayObject null() {return xineAudioPlayObject((xineAudioPlayObject_base*)0);}
	inline static xineAudioPlayObject _from_base(xineAudioPlayObject_base* b) {return xineAudioPlayObject(b);}
	inline xineAudioPlayObject& operator=(const xineAudioPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator xinePlayObject() const { return xinePlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline xineAudioPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
};

class ARTS_EXPORT xineVideoPlayObject_base : virtual public xinePlayObject_base,
	virtual public Arts::PlayObject_base,
	virtual public Arts::VideoPlayObject_base,
	virtual public Arts::SynthModule_base {
public:
	static unsigned long _IID; // interface ID

	static xineVideoPlayObject_base *_create(const std::string& subClass = "xineVideoPlayObject");
	static xineVideoPlayObject_base *_fromString(const std::string& objectref);
	static xineVideoPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static xineVideoPlayObject_base *_fromDynamicCast(const Arts::Object& object);
	inline xineVideoPlayObject_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT xineVideoPlayObject_stub : virtual public xineVideoPlayObject_base, virtual public xinePlayObject_stub,
	virtual public Arts::PlayObject_stub,
	virtual public Arts::VideoPlayObject_stub,
	virtual public Arts::SynthModule_stub {
protected:
	xineVideoPlayObject_stub();

public:
	xineVideoPlayObject_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT xineVideoPlayObject_skel : virtual public xineVideoPlayObject_base, virtual public xinePlayObject_skel,
	virtual public Arts::PlayObject_skel,
	virtual public Arts::VideoPlayObject_skel,
	virtual public Arts::SynthModule_skel {
public:
	xineVideoPlayObject_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

#include "reference.h"
class ARTS_EXPORT xineVideoPlayObject : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	xineVideoPlayObject_base *_cache;
	inline xineVideoPlayObject_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(xineVideoPlayObject_base *)_pool->base->_cast(xineVideoPlayObject_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline xineVideoPlayObject(xineVideoPlayObject_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef xineVideoPlayObject_base _base_class;

	inline xineVideoPlayObject() : Arts::Object(_Creator), _cache(0) {}
	inline xineVideoPlayObject(const Arts::SubClass& s) :
		Arts::Object(xineVideoPlayObject_base::_create(s.string())), _cache(0) {}
	inline xineVideoPlayObject(const Arts::Reference &r) :
		Arts::Object(r.isString()?(xineVideoPlayObject_base::_fromString(r.string())):(xineVideoPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline xineVideoPlayObject(const Arts::DynamicCast& c) : Arts::Object(xineVideoPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline xineVideoPlayObject(const xineVideoPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline xineVideoPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static xineVideoPlayObject null() {return xineVideoPlayObject((xineVideoPlayObject_base*)0);}
	inline static xineVideoPlayObject _from_base(xineVideoPlayObject_base* b) {return xineVideoPlayObject(b);}
	inline xineVideoPlayObject& operator=(const xineVideoPlayObject& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator xinePlayObject() const { return xinePlayObject(*_pool); }
	inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
	inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline operator Arts::VideoPlayObject() const { return Arts::VideoPlayObject(*_pool); }
	inline xineVideoPlayObject_base* _base() {return _cache?_cache:_method_call();}

	inline std::string description();
	inline Arts::poTime currentTime();
	inline Arts::poTime overallTime();
	inline Arts::poCapabilities capabilities();
	inline std::string mediaName();
	inline Arts::poState state();
	inline void play();
	inline void seek(const Arts::poTime& newTime);
	inline void pause();
	inline void halt();
	inline bool loadMedia(const std::string& filename);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline long x11WindowId();
	inline void x11WindowId(long _newValue);
	inline long x11Snapshot();
};

// Forward wrapper calls to _base classes:

inline std::string xinePlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime xinePlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime xinePlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities xinePlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string xinePlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState xinePlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void xinePlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void xinePlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void xinePlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void xinePlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool xinePlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState xinePlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void xinePlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void xinePlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void xinePlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void xinePlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void xinePlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline std::string xineAudioPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime xineAudioPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime xineAudioPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities xineAudioPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string xineAudioPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState xineAudioPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void xineAudioPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void xineAudioPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void xineAudioPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void xineAudioPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool xineAudioPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState xineAudioPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void xineAudioPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void xineAudioPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void xineAudioPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void xineAudioPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void xineAudioPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline std::string xineVideoPlayObject::description()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
}

inline Arts::poTime xineVideoPlayObject::currentTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
}

inline Arts::poTime xineVideoPlayObject::overallTime()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
}

inline Arts::poCapabilities xineVideoPlayObject::capabilities()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
}

inline std::string xineVideoPlayObject::mediaName()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
}

inline Arts::poState xineVideoPlayObject::state()
{
	return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
}

inline void xineVideoPlayObject::play()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
}

inline void xineVideoPlayObject::seek(const Arts::poTime& newTime)
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
}

inline void xineVideoPlayObject::pause()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
}

inline void xineVideoPlayObject::halt()
{
	 _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
}

inline bool xineVideoPlayObject::loadMedia(const std::string& filename)
{
	return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
}

inline Arts::AutoSuspendState xineVideoPlayObject::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void xineVideoPlayObject::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void xineVideoPlayObject::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void xineVideoPlayObject::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void xineVideoPlayObject::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void xineVideoPlayObject::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline long xineVideoPlayObject::x11WindowId()
{
	return _cache?static_cast<Arts::VideoPlayObject_base*>(_cache)->x11WindowId():static_cast<Arts::VideoPlayObject_base*>(_method_call())->x11WindowId();
}

inline void xineVideoPlayObject::x11WindowId(long _newValue)
{
	 _cache?static_cast<Arts::VideoPlayObject_base*>(_cache)->x11WindowId(_newValue):static_cast<Arts::VideoPlayObject_base*>(_method_call())->x11WindowId(_newValue);
}

inline long xineVideoPlayObject::x11Snapshot()
{
	return _cache?static_cast<Arts::VideoPlayObject_base*>(_cache)->x11Snapshot():static_cast<Arts::VideoPlayObject_base*>(_method_call())->x11Snapshot();
}

#endif /* XINEPLAYOBJECT_H */
