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

#ifndef ARTSGUI_H
#define ARTSGUI_H

#include "common.h"

namespace Arts {
class GraphPoint : public Arts::Type {
public:
	GraphPoint();
	GraphPoint(float _a_x, float _a_y);
	GraphPoint(Arts::Buffer& stream);
	GraphPoint(const GraphPoint& copyType);
	GraphPoint& operator=(const GraphPoint& assignType);
	float x;
	float y;

// marshalling functions
	void readType(Arts::Buffer& stream);
	void writeType(Arts::Buffer& stream) const;
	std::string _typeName() const;
};

};
namespace Arts {
class Widget;
class HBox;
class VBox;
class Button;
class Poti;
class Fader;
class LineEdit;
class SpinBox;
class ComboBox;
class Graph;
class GraphLine;
class GuiFactory;
class GenericGuiFactory;

class Widget_base : virtual public Arts::Object_base {
public:
	static unsigned long _IID; // interface ID

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

	static Widget_base *_fromDynamicCast(const Arts::Object& object);
	inline Widget_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);

	virtual long widgetID() = 0;
	virtual Arts::Widget parent() = 0;
	virtual void parent(Arts::Widget newValue) = 0;
	virtual long x() = 0;
	virtual void x(long newValue) = 0;
	virtual long y() = 0;
	virtual void y(long newValue) = 0;
	virtual long width() = 0;
	virtual void width(long newValue) = 0;
	virtual long height() = 0;
	virtual void height(long newValue) = 0;
	virtual bool visible() = 0;
	virtual void visible(bool newValue) = 0;
	virtual void show() = 0;
	virtual void hide() = 0;
};

class Widget_stub : virtual public Widget_base, virtual public Arts::Object_stub {
protected:
	Widget_stub();

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

	long widgetID();
	Arts::Widget parent();
	void parent(Arts::Widget newValue);
	long x();
	void x(long newValue);
	long y();
	void y(long newValue);
	long width();
	void width(long newValue);
	long height();
	void height(long newValue);
	bool visible();
	void visible(bool newValue);
	void show();
	void hide();
};

class Widget_skel : virtual public Widget_base, virtual public Arts::Object_skel {
protected:
	// emitters for change notifications
	inline void widgetID_changed(long newValue) {
		_emit_changed("widgetID_changed",newValue);
	}
	inline void x_changed(long newValue) {
		_emit_changed("x_changed",newValue);
	}
	inline void y_changed(long newValue) {
		_emit_changed("y_changed",newValue);
	}
	inline void width_changed(long newValue) {
		_emit_changed("width_changed",newValue);
	}
	inline void height_changed(long newValue) {
		_emit_changed("height_changed",newValue);
	}
	inline void visible_changed(bool newValue) {
		_emit_changed("visible_changed",newValue);
	}

public:
	Widget_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"
namespace Arts {
class Widget : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Widget_base *_cache;
	inline Widget_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Widget_base *)_pool->base->_cast(Widget_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Widget(Widget_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Widget_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
};

class HBox_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static HBox_base *_fromDynamicCast(const Arts::Object& object);
	inline HBox_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 HBox_stub : virtual public HBox_base, virtual public Arts::Widget_stub {
protected:
	HBox_stub();

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

};

class HBox_skel : virtual public HBox_base, virtual public Arts::Widget_skel {
public:
	HBox_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"
namespace Arts {
class HBox : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	HBox_base *_cache;
	inline HBox_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(HBox_base *)_pool->base->_cast(HBox_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline HBox(HBox_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef HBox_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
};

class VBox_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static VBox_base *_fromDynamicCast(const Arts::Object& object);
	inline VBox_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 VBox_stub : virtual public VBox_base, virtual public Arts::Widget_stub {
protected:
	VBox_stub();

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

};

class VBox_skel : virtual public VBox_base, virtual public Arts::Widget_skel {
public:
	VBox_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"
namespace Arts {
class VBox : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	VBox_base *_cache;
	inline VBox_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(VBox_base *)_pool->base->_cast(VBox_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline VBox(VBox_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef VBox_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
};

class Button_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static Button_base *_fromDynamicCast(const Arts::Object& object);
	inline Button_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);

	virtual std::string text() = 0;
	virtual void text(const std::string& newValue) = 0;
	virtual bool toggle() = 0;
	virtual void toggle(bool newValue) = 0;
	virtual bool pressed() = 0;
};

class Button_stub : virtual public Button_base, virtual public Arts::Widget_stub {
protected:
	Button_stub();

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

	std::string text();
	void text(const std::string& newValue);
	bool toggle();
	void toggle(bool newValue);
	bool pressed();
};

class Button_skel : virtual public Button_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void text_changed(const std::string& newValue) {
		_emit_changed("text_changed",newValue);
	}
	inline void toggle_changed(bool newValue) {
		_emit_changed("toggle_changed",newValue);
	}
	inline void pressed_changed(bool newValue) {
		_emit_changed("pressed_changed",newValue);
	}

public:
	Button_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"
namespace Arts {
class Button : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Button_base *_cache;
	inline Button_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Button_base *)_pool->base->_cast(Button_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Button(Button_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Button_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string text();
	inline void text(const std::string& _newValue);
	inline bool toggle();
	inline void toggle(bool _newValue);
	inline bool pressed();
};

class Poti_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static Poti_base *_fromDynamicCast(const Arts::Object& object);
	inline Poti_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);

	virtual std::string caption() = 0;
	virtual void caption(const std::string& newValue) = 0;
	virtual std::string color() = 0;
	virtual void color(const std::string& newValue) = 0;
	virtual float min() = 0;
	virtual void min(float newValue) = 0;
	virtual float max() = 0;
	virtual void max(float newValue) = 0;
	virtual float value() = 0;
	virtual void value(float newValue) = 0;
	virtual float logarithmic() = 0;
	virtual void logarithmic(float newValue) = 0;
	virtual long range() = 0;
	virtual void range(long newValue) = 0;
};

class Poti_stub : virtual public Poti_base, virtual public Arts::Widget_stub {
protected:
	Poti_stub();

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

	std::string caption();
	void caption(const std::string& newValue);
	std::string color();
	void color(const std::string& newValue);
	float min();
	void min(float newValue);
	float max();
	void max(float newValue);
	float value();
	void value(float newValue);
	float logarithmic();
	void logarithmic(float newValue);
	long range();
	void range(long newValue);
};

class Poti_skel : virtual public Poti_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void caption_changed(const std::string& newValue) {
		_emit_changed("caption_changed",newValue);
	}
	inline void color_changed(const std::string& newValue) {
		_emit_changed("color_changed",newValue);
	}
	inline void min_changed(float newValue) {
		_emit_changed("min_changed",newValue);
	}
	inline void max_changed(float newValue) {
		_emit_changed("max_changed",newValue);
	}
	inline void value_changed(float newValue) {
		_emit_changed("value_changed",newValue);
	}
	inline void logarithmic_changed(float newValue) {
		_emit_changed("logarithmic_changed",newValue);
	}
	inline void range_changed(long newValue) {
		_emit_changed("range_changed",newValue);
	}

public:
	Poti_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"
namespace Arts {
class Poti : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Poti_base *_cache;
	inline Poti_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Poti_base *)_pool->base->_cast(Poti_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Poti(Poti_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Poti_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string caption();
	inline void caption(const std::string& _newValue);
	inline std::string color();
	inline void color(const std::string& _newValue);
	inline float min();
	inline void min(float _newValue);
	inline float max();
	inline void max(float _newValue);
	inline float value();
	inline void value(float _newValue);
	inline float logarithmic();
	inline void logarithmic(float _newValue);
	inline long range();
	inline void range(long _newValue);
};

class Fader_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static Fader_base *_fromDynamicCast(const Arts::Object& object);
	inline Fader_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);

	virtual std::string caption() = 0;
	virtual void caption(const std::string& newValue) = 0;
	virtual std::string color() = 0;
	virtual void color(const std::string& newValue) = 0;
	virtual float min() = 0;
	virtual void min(float newValue) = 0;
	virtual float max() = 0;
	virtual void max(float newValue) = 0;
	virtual float value() = 0;
	virtual void value(float newValue) = 0;
	virtual float logarithmic() = 0;
	virtual void logarithmic(float newValue) = 0;
};

class Fader_stub : virtual public Fader_base, virtual public Arts::Widget_stub {
protected:
	Fader_stub();

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

	std::string caption();
	void caption(const std::string& newValue);
	std::string color();
	void color(const std::string& newValue);
	float min();
	void min(float newValue);
	float max();
	void max(float newValue);
	float value();
	void value(float newValue);
	float logarithmic();
	void logarithmic(float newValue);
};

class Fader_skel : virtual public Fader_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void caption_changed(const std::string& newValue) {
		_emit_changed("caption_changed",newValue);
	}
	inline void color_changed(const std::string& newValue) {
		_emit_changed("color_changed",newValue);
	}
	inline void min_changed(float newValue) {
		_emit_changed("min_changed",newValue);
	}
	inline void max_changed(float newValue) {
		_emit_changed("max_changed",newValue);
	}
	inline void value_changed(float newValue) {
		_emit_changed("value_changed",newValue);
	}
	inline void logarithmic_changed(float newValue) {
		_emit_changed("logarithmic_changed",newValue);
	}

public:
	Fader_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"
namespace Arts {
class Fader : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Fader_base *_cache;
	inline Fader_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Fader_base *)_pool->base->_cast(Fader_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Fader(Fader_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Fader_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string caption();
	inline void caption(const std::string& _newValue);
	inline std::string color();
	inline void color(const std::string& _newValue);
	inline float min();
	inline void min(float _newValue);
	inline float max();
	inline void max(float _newValue);
	inline float value();
	inline void value(float _newValue);
	inline float logarithmic();
	inline void logarithmic(float _newValue);
};

class LineEdit_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static LineEdit_base *_fromDynamicCast(const Arts::Object& object);
	inline LineEdit_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);

	virtual std::string caption() = 0;
	virtual void caption(const std::string& newValue) = 0;
	virtual std::string text() = 0;
	virtual void text(const std::string& newValue) = 0;
};

class LineEdit_stub : virtual public LineEdit_base, virtual public Arts::Widget_stub {
protected:
	LineEdit_stub();

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

	std::string caption();
	void caption(const std::string& newValue);
	std::string text();
	void text(const std::string& newValue);
};

class LineEdit_skel : virtual public LineEdit_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void caption_changed(const std::string& newValue) {
		_emit_changed("caption_changed",newValue);
	}
	inline void text_changed(const std::string& newValue) {
		_emit_changed("text_changed",newValue);
	}

public:
	LineEdit_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"
namespace Arts {
class LineEdit : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	LineEdit_base *_cache;
	inline LineEdit_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(LineEdit_base *)_pool->base->_cast(LineEdit_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline LineEdit(LineEdit_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef LineEdit_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string caption();
	inline void caption(const std::string& _newValue);
	inline std::string text();
	inline void text(const std::string& _newValue);
};

class SpinBox_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static SpinBox_base *_fromDynamicCast(const Arts::Object& object);
	inline SpinBox_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);

	virtual std::string caption() = 0;
	virtual void caption(const std::string& newValue) = 0;
	virtual long min() = 0;
	virtual void min(long newValue) = 0;
	virtual long max() = 0;
	virtual void max(long newValue) = 0;
	virtual long value() = 0;
	virtual void value(long newValue) = 0;
};

class SpinBox_stub : virtual public SpinBox_base, virtual public Arts::Widget_stub {
protected:
	SpinBox_stub();

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

	std::string caption();
	void caption(const std::string& newValue);
	long min();
	void min(long newValue);
	long max();
	void max(long newValue);
	long value();
	void value(long newValue);
};

class SpinBox_skel : virtual public SpinBox_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void caption_changed(const std::string& newValue) {
		_emit_changed("caption_changed",newValue);
	}
	inline void min_changed(long newValue) {
		_emit_changed("min_changed",newValue);
	}
	inline void max_changed(long newValue) {
		_emit_changed("max_changed",newValue);
	}
	inline void value_changed(long newValue) {
		_emit_changed("value_changed",newValue);
	}

public:
	SpinBox_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"
namespace Arts {
class SpinBox : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	SpinBox_base *_cache;
	inline SpinBox_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(SpinBox_base *)_pool->base->_cast(SpinBox_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline SpinBox(SpinBox_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef SpinBox_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string caption();
	inline void caption(const std::string& _newValue);
	inline long min();
	inline void min(long _newValue);
	inline long max();
	inline void max(long _newValue);
	inline long value();
	inline void value(long _newValue);
};

class ComboBox_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static ComboBox_base *_fromDynamicCast(const Arts::Object& object);
	inline ComboBox_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);

	virtual std::string caption() = 0;
	virtual void caption(const std::string& newValue) = 0;
	virtual std::vector<std::string> * choices() = 0;
	virtual void choices(const std::vector<std::string>& newValue) = 0;
	virtual std::string value() = 0;
	virtual void value(const std::string& newValue) = 0;
};

class ComboBox_stub : virtual public ComboBox_base, virtual public Arts::Widget_stub {
protected:
	ComboBox_stub();

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

	std::string caption();
	void caption(const std::string& newValue);
	std::vector<std::string> * choices();
	void choices(const std::vector<std::string>& newValue);
	std::string value();
	void value(const std::string& newValue);
};

class ComboBox_skel : virtual public ComboBox_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void caption_changed(const std::string& newValue) {
		_emit_changed("caption_changed",newValue);
	}
	inline void choices_changed(const std::vector<std::string>& newValue) {
		_emit_changed("choices_changed",newValue);
	}
	inline void value_changed(const std::string& newValue) {
		_emit_changed("value_changed",newValue);
	}

public:
	ComboBox_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"
namespace Arts {
class ComboBox : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	ComboBox_base *_cache;
	inline ComboBox_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(ComboBox_base *)_pool->base->_cast(ComboBox_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline ComboBox(ComboBox_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef ComboBox_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string caption();
	inline void caption(const std::string& _newValue);
	inline std::vector<std::string> * choices();
	inline void choices(const std::vector<std::string>& _newValue);
	inline std::string value();
	inline void value(const std::string& _newValue);
};

class Graph_base : virtual public Arts::Widget_base {
public:
	static unsigned long _IID; // interface ID

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

	static Graph_base *_fromDynamicCast(const Arts::Object& object);
	inline Graph_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);

	virtual std::string caption() = 0;
	virtual void caption(const std::string& newValue) = 0;
	virtual float minx() = 0;
	virtual void minx(float newValue) = 0;
	virtual float maxx() = 0;
	virtual void maxx(float newValue) = 0;
	virtual float miny() = 0;
	virtual void miny(float newValue) = 0;
	virtual float maxy() = 0;
	virtual void maxy(float newValue) = 0;
};

class Graph_stub : virtual public Graph_base, virtual public Arts::Widget_stub {
protected:
	Graph_stub();

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

	std::string caption();
	void caption(const std::string& newValue);
	float minx();
	void minx(float newValue);
	float maxx();
	void maxx(float newValue);
	float miny();
	void miny(float newValue);
	float maxy();
	void maxy(float newValue);
};

class Graph_skel : virtual public Graph_base, virtual public Arts::Widget_skel {
protected:
	// emitters for change notifications
	inline void caption_changed(const std::string& newValue) {
		_emit_changed("caption_changed",newValue);
	}
	inline void minx_changed(float newValue) {
		_emit_changed("minx_changed",newValue);
	}
	inline void maxx_changed(float newValue) {
		_emit_changed("maxx_changed",newValue);
	}
	inline void miny_changed(float newValue) {
		_emit_changed("miny_changed",newValue);
	}
	inline void maxy_changed(float newValue) {
		_emit_changed("maxy_changed",newValue);
	}

public:
	Graph_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"
namespace Arts {
class Graph : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Graph_base *_cache;
	inline Graph_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Graph_base *)_pool->base->_cast(Graph_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Graph(Graph_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Graph_base _base_class;

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

	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline void show();
	inline void hide();
	inline std::string caption();
	inline void caption(const std::string& _newValue);
	inline float minx();
	inline void minx(float _newValue);
	inline float maxx();
	inline void maxx(float _newValue);
	inline float miny();
	inline void miny(float _newValue);
	inline float maxy();
	inline void maxy(float _newValue);
};

class GraphLine_base : virtual public Arts::Object_base {
public:
	static unsigned long _IID; // interface ID

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

	static GraphLine_base *_fromDynamicCast(const Arts::Object& object);
	inline GraphLine_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);

	virtual Arts::Graph graph() = 0;
	virtual void graph(Arts::Graph newValue) = 0;
	virtual bool editable() = 0;
	virtual void editable(bool newValue) = 0;
	virtual std::string color() = 0;
	virtual void color(const std::string& newValue) = 0;
	virtual std::vector<Arts::GraphPoint> * points() = 0;
	virtual void points(const std::vector<Arts::GraphPoint>& newValue) = 0;
};

class GraphLine_stub : virtual public GraphLine_base, virtual public Arts::Object_stub {
protected:
	GraphLine_stub();

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

	Arts::Graph graph();
	void graph(Arts::Graph newValue);
	bool editable();
	void editable(bool newValue);
	std::string color();
	void color(const std::string& newValue);
	std::vector<Arts::GraphPoint> * points();
	void points(const std::vector<Arts::GraphPoint>& newValue);
};

class GraphLine_skel : virtual public GraphLine_base, virtual public Arts::Object_skel {
protected:
	// emitters for change notifications
	inline void editable_changed(bool newValue) {
		_emit_changed("editable_changed",newValue);
	}
	inline void color_changed(const std::string& newValue) {
		_emit_changed("color_changed",newValue);
	}

public:
	GraphLine_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"
namespace Arts {
class GraphLine : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	GraphLine_base *_cache;
	inline GraphLine_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(GraphLine_base *)_pool->base->_cast(GraphLine_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline GraphLine(GraphLine_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef GraphLine_base _base_class;

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

	inline Arts::Graph graph();
	inline void graph(Arts::Graph _newValue);
	inline bool editable();
	inline void editable(bool _newValue);
	inline std::string color();
	inline void color(const std::string& _newValue);
	inline std::vector<Arts::GraphPoint> * points();
	inline void points(const std::vector<Arts::GraphPoint>& _newValue);
};

class GuiFactory_base : virtual public Arts::Object_base {
public:
	static unsigned long _IID; // interface ID

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

	static GuiFactory_base *_fromDynamicCast(const Arts::Object& object);
	inline GuiFactory_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);

	virtual Arts::Widget createGui(Arts::Object runningObject) = 0;
};

class GuiFactory_stub : virtual public GuiFactory_base, virtual public Arts::Object_stub {
protected:
	GuiFactory_stub();

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

	Arts::Widget createGui(Arts::Object runningObject);
};

class GuiFactory_skel : virtual public GuiFactory_base, virtual public Arts::Object_skel {
public:
	GuiFactory_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"
namespace Arts {
class GuiFactory : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	GuiFactory_base *_cache;
	inline GuiFactory_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(GuiFactory_base *)_pool->base->_cast(GuiFactory_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline GuiFactory(GuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef GuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class GenericGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

	static GenericGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
	inline GenericGuiFactory_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 GenericGuiFactory_stub : virtual public GenericGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	GenericGuiFactory_stub();

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

};

class GenericGuiFactory_skel : virtual public GenericGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	GenericGuiFactory_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"
namespace Arts {
class GenericGuiFactory : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	GenericGuiFactory_base *_cache;
	inline GenericGuiFactory_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(GenericGuiFactory_base *)_pool->base->_cast(GenericGuiFactory_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline GenericGuiFactory(GenericGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef GenericGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

};
// Forward wrapper calls to _base classes:

inline long Arts::Widget::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::Widget::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::Widget::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::Widget::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::Widget::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::Widget::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::Widget::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::Widget::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::Widget::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::Widget::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::Widget::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::Widget::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::Widget::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::Widget::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::Widget::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline long Arts::HBox::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::HBox::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::HBox::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::HBox::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::HBox::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::HBox::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::HBox::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::HBox::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::HBox::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::HBox::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::HBox::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::HBox::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::HBox::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::HBox::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::HBox::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline long Arts::VBox::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::VBox::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::VBox::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::VBox::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::VBox::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::VBox::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::VBox::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::VBox::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::VBox::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::VBox::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::VBox::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::VBox::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::VBox::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::VBox::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::VBox::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline long Arts::Button::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::Button::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::Button::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::Button::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::Button::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::Button::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::Button::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::Button::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::Button::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::Button::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::Button::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::Button::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::Button::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::Button::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::Button::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::Button::text()
{
	return _cache?static_cast<Arts::Button_base*>(_cache)->text():static_cast<Arts::Button_base*>(_method_call())->text();
}

inline void Arts::Button::text(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Button_base*>(_cache)->text(_newValue):static_cast<Arts::Button_base*>(_method_call())->text(_newValue);
}

inline bool Arts::Button::toggle()
{
	return _cache?static_cast<Arts::Button_base*>(_cache)->toggle():static_cast<Arts::Button_base*>(_method_call())->toggle();
}

inline void Arts::Button::toggle(bool _newValue)
{
	 _cache?static_cast<Arts::Button_base*>(_cache)->toggle(_newValue):static_cast<Arts::Button_base*>(_method_call())->toggle(_newValue);
}

inline bool Arts::Button::pressed()
{
	return _cache?static_cast<Arts::Button_base*>(_cache)->pressed():static_cast<Arts::Button_base*>(_method_call())->pressed();
}

inline long Arts::Poti::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::Poti::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::Poti::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::Poti::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::Poti::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::Poti::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::Poti::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::Poti::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::Poti::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::Poti::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::Poti::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::Poti::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::Poti::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::Poti::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::Poti::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::Poti::caption()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->caption():static_cast<Arts::Poti_base*>(_method_call())->caption();
}

inline void Arts::Poti::caption(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->caption(_newValue):static_cast<Arts::Poti_base*>(_method_call())->caption(_newValue);
}

inline std::string Arts::Poti::color()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->color():static_cast<Arts::Poti_base*>(_method_call())->color();
}

inline void Arts::Poti::color(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->color(_newValue):static_cast<Arts::Poti_base*>(_method_call())->color(_newValue);
}

inline float Arts::Poti::min()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->min():static_cast<Arts::Poti_base*>(_method_call())->min();
}

inline void Arts::Poti::min(float _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->min(_newValue):static_cast<Arts::Poti_base*>(_method_call())->min(_newValue);
}

inline float Arts::Poti::max()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->max():static_cast<Arts::Poti_base*>(_method_call())->max();
}

inline void Arts::Poti::max(float _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->max(_newValue):static_cast<Arts::Poti_base*>(_method_call())->max(_newValue);
}

inline float Arts::Poti::value()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->value():static_cast<Arts::Poti_base*>(_method_call())->value();
}

inline void Arts::Poti::value(float _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->value(_newValue):static_cast<Arts::Poti_base*>(_method_call())->value(_newValue);
}

inline float Arts::Poti::logarithmic()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->logarithmic():static_cast<Arts::Poti_base*>(_method_call())->logarithmic();
}

inline void Arts::Poti::logarithmic(float _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->logarithmic(_newValue):static_cast<Arts::Poti_base*>(_method_call())->logarithmic(_newValue);
}

inline long Arts::Poti::range()
{
	return _cache?static_cast<Arts::Poti_base*>(_cache)->range():static_cast<Arts::Poti_base*>(_method_call())->range();
}

inline void Arts::Poti::range(long _newValue)
{
	 _cache?static_cast<Arts::Poti_base*>(_cache)->range(_newValue):static_cast<Arts::Poti_base*>(_method_call())->range(_newValue);
}

inline long Arts::Fader::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::Fader::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::Fader::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::Fader::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::Fader::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::Fader::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::Fader::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::Fader::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::Fader::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::Fader::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::Fader::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::Fader::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::Fader::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::Fader::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::Fader::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::Fader::caption()
{
	return _cache?static_cast<Arts::Fader_base*>(_cache)->caption():static_cast<Arts::Fader_base*>(_method_call())->caption();
}

inline void Arts::Fader::caption(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Fader_base*>(_cache)->caption(_newValue):static_cast<Arts::Fader_base*>(_method_call())->caption(_newValue);
}

inline std::string Arts::Fader::color()
{
	return _cache?static_cast<Arts::Fader_base*>(_cache)->color():static_cast<Arts::Fader_base*>(_method_call())->color();
}

inline void Arts::Fader::color(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Fader_base*>(_cache)->color(_newValue):static_cast<Arts::Fader_base*>(_method_call())->color(_newValue);
}

inline float Arts::Fader::min()
{
	return _cache?static_cast<Arts::Fader_base*>(_cache)->min():static_cast<Arts::Fader_base*>(_method_call())->min();
}

inline void Arts::Fader::min(float _newValue)
{
	 _cache?static_cast<Arts::Fader_base*>(_cache)->min(_newValue):static_cast<Arts::Fader_base*>(_method_call())->min(_newValue);
}

inline float Arts::Fader::max()
{
	return _cache?static_cast<Arts::Fader_base*>(_cache)->max():static_cast<Arts::Fader_base*>(_method_call())->max();
}

inline void Arts::Fader::max(float _newValue)
{
	 _cache?static_cast<Arts::Fader_base*>(_cache)->max(_newValue):static_cast<Arts::Fader_base*>(_method_call())->max(_newValue);
}

inline float Arts::Fader::value()
{
	return _cache?static_cast<Arts::Fader_base*>(_cache)->value():static_cast<Arts::Fader_base*>(_method_call())->value();
}

inline void Arts::Fader::value(float _newValue)
{
	 _cache?static_cast<Arts::Fader_base*>(_cache)->value(_newValue):static_cast<Arts::Fader_base*>(_method_call())->value(_newValue);
}

inline float Arts::Fader::logarithmic()
{
	return _cache?static_cast<Arts::Fader_base*>(_cache)->logarithmic():static_cast<Arts::Fader_base*>(_method_call())->logarithmic();
}

inline void Arts::Fader::logarithmic(float _newValue)
{
	 _cache?static_cast<Arts::Fader_base*>(_cache)->logarithmic(_newValue):static_cast<Arts::Fader_base*>(_method_call())->logarithmic(_newValue);
}

inline long Arts::LineEdit::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::LineEdit::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::LineEdit::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::LineEdit::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::LineEdit::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::LineEdit::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::LineEdit::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::LineEdit::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::LineEdit::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::LineEdit::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::LineEdit::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::LineEdit::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::LineEdit::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::LineEdit::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::LineEdit::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::LineEdit::caption()
{
	return _cache?static_cast<Arts::LineEdit_base*>(_cache)->caption():static_cast<Arts::LineEdit_base*>(_method_call())->caption();
}

inline void Arts::LineEdit::caption(const std::string& _newValue)
{
	 _cache?static_cast<Arts::LineEdit_base*>(_cache)->caption(_newValue):static_cast<Arts::LineEdit_base*>(_method_call())->caption(_newValue);
}

inline std::string Arts::LineEdit::text()
{
	return _cache?static_cast<Arts::LineEdit_base*>(_cache)->text():static_cast<Arts::LineEdit_base*>(_method_call())->text();
}

inline void Arts::LineEdit::text(const std::string& _newValue)
{
	 _cache?static_cast<Arts::LineEdit_base*>(_cache)->text(_newValue):static_cast<Arts::LineEdit_base*>(_method_call())->text(_newValue);
}

inline long Arts::SpinBox::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::SpinBox::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::SpinBox::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::SpinBox::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::SpinBox::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::SpinBox::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::SpinBox::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::SpinBox::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::SpinBox::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::SpinBox::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::SpinBox::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::SpinBox::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::SpinBox::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::SpinBox::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::SpinBox::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::SpinBox::caption()
{
	return _cache?static_cast<Arts::SpinBox_base*>(_cache)->caption():static_cast<Arts::SpinBox_base*>(_method_call())->caption();
}

inline void Arts::SpinBox::caption(const std::string& _newValue)
{
	 _cache?static_cast<Arts::SpinBox_base*>(_cache)->caption(_newValue):static_cast<Arts::SpinBox_base*>(_method_call())->caption(_newValue);
}

inline long Arts::SpinBox::min()
{
	return _cache?static_cast<Arts::SpinBox_base*>(_cache)->min():static_cast<Arts::SpinBox_base*>(_method_call())->min();
}

inline void Arts::SpinBox::min(long _newValue)
{
	 _cache?static_cast<Arts::SpinBox_base*>(_cache)->min(_newValue):static_cast<Arts::SpinBox_base*>(_method_call())->min(_newValue);
}

inline long Arts::SpinBox::max()
{
	return _cache?static_cast<Arts::SpinBox_base*>(_cache)->max():static_cast<Arts::SpinBox_base*>(_method_call())->max();
}

inline void Arts::SpinBox::max(long _newValue)
{
	 _cache?static_cast<Arts::SpinBox_base*>(_cache)->max(_newValue):static_cast<Arts::SpinBox_base*>(_method_call())->max(_newValue);
}

inline long Arts::SpinBox::value()
{
	return _cache?static_cast<Arts::SpinBox_base*>(_cache)->value():static_cast<Arts::SpinBox_base*>(_method_call())->value();
}

inline void Arts::SpinBox::value(long _newValue)
{
	 _cache?static_cast<Arts::SpinBox_base*>(_cache)->value(_newValue):static_cast<Arts::SpinBox_base*>(_method_call())->value(_newValue);
}

inline long Arts::ComboBox::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::ComboBox::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::ComboBox::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::ComboBox::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::ComboBox::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::ComboBox::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::ComboBox::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::ComboBox::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::ComboBox::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::ComboBox::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::ComboBox::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::ComboBox::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::ComboBox::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::ComboBox::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::ComboBox::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::ComboBox::caption()
{
	return _cache?static_cast<Arts::ComboBox_base*>(_cache)->caption():static_cast<Arts::ComboBox_base*>(_method_call())->caption();
}

inline void Arts::ComboBox::caption(const std::string& _newValue)
{
	 _cache?static_cast<Arts::ComboBox_base*>(_cache)->caption(_newValue):static_cast<Arts::ComboBox_base*>(_method_call())->caption(_newValue);
}

inline std::vector<std::string> * Arts::ComboBox::choices()
{
	return _cache?static_cast<Arts::ComboBox_base*>(_cache)->choices():static_cast<Arts::ComboBox_base*>(_method_call())->choices();
}

inline void Arts::ComboBox::choices(const std::vector<std::string>& _newValue)
{
	 _cache?static_cast<Arts::ComboBox_base*>(_cache)->choices(_newValue):static_cast<Arts::ComboBox_base*>(_method_call())->choices(_newValue);
}

inline std::string Arts::ComboBox::value()
{
	return _cache?static_cast<Arts::ComboBox_base*>(_cache)->value():static_cast<Arts::ComboBox_base*>(_method_call())->value();
}

inline void Arts::ComboBox::value(const std::string& _newValue)
{
	 _cache?static_cast<Arts::ComboBox_base*>(_cache)->value(_newValue):static_cast<Arts::ComboBox_base*>(_method_call())->value(_newValue);
}

inline long Arts::Graph::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::Graph::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::Graph::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::Graph::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::Graph::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::Graph::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::Graph::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::Graph::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::Graph::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::Graph::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::Graph::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::Graph::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::Graph::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline void Arts::Graph::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::Graph::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::Graph::caption()
{
	return _cache?static_cast<Arts::Graph_base*>(_cache)->caption():static_cast<Arts::Graph_base*>(_method_call())->caption();
}

inline void Arts::Graph::caption(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Graph_base*>(_cache)->caption(_newValue):static_cast<Arts::Graph_base*>(_method_call())->caption(_newValue);
}

inline float Arts::Graph::minx()
{
	return _cache?static_cast<Arts::Graph_base*>(_cache)->minx():static_cast<Arts::Graph_base*>(_method_call())->minx();
}

inline void Arts::Graph::minx(float _newValue)
{
	 _cache?static_cast<Arts::Graph_base*>(_cache)->minx(_newValue):static_cast<Arts::Graph_base*>(_method_call())->minx(_newValue);
}

inline float Arts::Graph::maxx()
{
	return _cache?static_cast<Arts::Graph_base*>(_cache)->maxx():static_cast<Arts::Graph_base*>(_method_call())->maxx();
}

inline void Arts::Graph::maxx(float _newValue)
{
	 _cache?static_cast<Arts::Graph_base*>(_cache)->maxx(_newValue):static_cast<Arts::Graph_base*>(_method_call())->maxx(_newValue);
}

inline float Arts::Graph::miny()
{
	return _cache?static_cast<Arts::Graph_base*>(_cache)->miny():static_cast<Arts::Graph_base*>(_method_call())->miny();
}

inline void Arts::Graph::miny(float _newValue)
{
	 _cache?static_cast<Arts::Graph_base*>(_cache)->miny(_newValue):static_cast<Arts::Graph_base*>(_method_call())->miny(_newValue);
}

inline float Arts::Graph::maxy()
{
	return _cache?static_cast<Arts::Graph_base*>(_cache)->maxy():static_cast<Arts::Graph_base*>(_method_call())->maxy();
}

inline void Arts::Graph::maxy(float _newValue)
{
	 _cache?static_cast<Arts::Graph_base*>(_cache)->maxy(_newValue):static_cast<Arts::Graph_base*>(_method_call())->maxy(_newValue);
}

inline Arts::Graph Arts::GraphLine::graph()
{
	return _cache?static_cast<Arts::GraphLine_base*>(_cache)->graph():static_cast<Arts::GraphLine_base*>(_method_call())->graph();
}

inline void Arts::GraphLine::graph(Arts::Graph _newValue)
{
	 _cache?static_cast<Arts::GraphLine_base*>(_cache)->graph(_newValue):static_cast<Arts::GraphLine_base*>(_method_call())->graph(_newValue);
}

inline bool Arts::GraphLine::editable()
{
	return _cache?static_cast<Arts::GraphLine_base*>(_cache)->editable():static_cast<Arts::GraphLine_base*>(_method_call())->editable();
}

inline void Arts::GraphLine::editable(bool _newValue)
{
	 _cache?static_cast<Arts::GraphLine_base*>(_cache)->editable(_newValue):static_cast<Arts::GraphLine_base*>(_method_call())->editable(_newValue);
}

inline std::string Arts::GraphLine::color()
{
	return _cache?static_cast<Arts::GraphLine_base*>(_cache)->color():static_cast<Arts::GraphLine_base*>(_method_call())->color();
}

inline void Arts::GraphLine::color(const std::string& _newValue)
{
	 _cache?static_cast<Arts::GraphLine_base*>(_cache)->color(_newValue):static_cast<Arts::GraphLine_base*>(_method_call())->color(_newValue);
}

inline std::vector<Arts::GraphPoint> * Arts::GraphLine::points()
{
	return _cache?static_cast<Arts::GraphLine_base*>(_cache)->points():static_cast<Arts::GraphLine_base*>(_method_call())->points();
}

inline void Arts::GraphLine::points(const std::vector<Arts::GraphPoint>& _newValue)
{
	 _cache?static_cast<Arts::GraphLine_base*>(_cache)->points(_newValue):static_cast<Arts::GraphLine_base*>(_method_call())->points(_newValue);
}

inline Arts::Widget Arts::GuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

inline Arts::Widget Arts::GenericGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

#endif /* ARTSGUI_H */
