object module restyling/enhancement(work in progress)

git-svn-id: https://svn.kvirc.de/svn/trunk/kvirc@2689 17fca916-40b9-46aa-a4ea-0a15b648b75c

49 files changed, 1268 insertions, 1582 deletions

diff --git a/src/modules/objects/CMakeLists.txt b/src/modules/objects/CMakeLists.txt
index 80bfdd078..51baafb1e 100644
--- a/src/modules/objects/CMakeLists.txt
+++ b/src/modules/objects/CMakeLists.txt
@@ -15,7 +15,7 @@ SET(kviobjects_MOC_HDRS
 	class_ftp.h
 	class_http.h
 	class_lineedit.h
-	class_listbox.h
+	class_listwidget.h
 	class_multilineedit.h
 	class_painter.h
 	class_pixmap.h
@@ -56,7 +56,7 @@ SET(kviobjects_SRCS
 	class_lcd.cpp
 	class_lineedit.cpp
 	class_list.cpp
-	class_listbox.cpp
+	class_listwidget.cpp
 	class_mainwindow.cpp
 	class_menubar.cpp
 	class_multilineedit.cpp
diff --git a/src/modules/objects/class_button.cpp b/src/modules/objects/class_button.cpp
index 57b8158c2..99323cf98 100644
--- a/src/modules/objects/class_button.cpp
+++ b/src/modules/objects/class_button.cpp
@@ -24,28 +24,54 @@
 //=============================================================================
 
 #include "kvi_debug.h"
+#include "kvi_locale.h"
 #include "kvi_error.h"
 #include "kvi_iconmanager.h"
 #include "class_button.h"
+#include "class_pixmap.h"
 
 #include <QIcon>
 #include <QPushButton>
 
-KVSO_BEGIN_REGISTERCLASS(KviKvsObject_button,"button","widget")
+#include <kvi_file.h>
+
+
+/*
+	@doc:button
+	@title:
+		button class
+	@type:
+		class
+	@short:
+		Button widget.
+	@inherits:
+		[class]object[/class]
+		[class]button[/class]
+	@description:
+		This widget provides a push button 
+	@functions:
+		!fn: $setText([<text:string>])
+		Set the button text.[br]
+		See also [classfnc]$text[/classfnc]().
+		!fn: <string> $text()
+		Return the button text.[br]
+		See also [classfnc]$setText[/classfnc]().
+		!fn: $setImage(<image_id_or_pixmap_object>)
+		Sets the icon for this button.
+		See the [doc:image_id]image identifier[/doc] documentation for the explaination	of the <image_id> parameter.
+		@signals:
+		!sg: $clicked()
+		This signal is emitted by the default implementation of [classfnc]$clickEvent[/classfnc]().
+
+*/
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"setText", functionSetText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"text", functionText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"setAutoDefault", functionSetAutoDefault)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"setToggleButton", functionSetToggleButton)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"setOn", functionSetChecked)/*DEPRECATED*/
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"setChecked", functionSetChecked)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"isOn", functionIsChecked)/*DEPRECATED*/
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"isChecked", functionIsChecked)
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"toggle", functionToggle)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"clickEvent", functionclickEvent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_button,"setImage", functionSetImage)
+KVSO_BEGIN_REGISTERCLASS(KviKvsObject_button,"button","widget")
 
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_button,setText)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_button,text)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_button,clickEvent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_button,setImage)
 
 KVSO_END_REGISTERCLASS(KviKvsObject_button)
 
@@ -65,84 +91,62 @@ bool KviKvsObject_button::init(KviKvsRunTimeContext * pContext,KviKvsVariantList
 	return true;
 }
 
-bool KviKvsObject_button::functionText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(button,text)
 {
-	if(widget()) c->returnValue()->setString(((QPushButton *)widget())->text());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setString(((QPushButton *)widget())->text());
 	return true;
 }
 
-bool KviKvsObject_button::functionSetText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(button,setText)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
 	KVSO_PARAMETERS_END(c)
-	if (widget())
-		((QPushButton *)widget())->setText(szText);
-	return true;
-}
-bool KviKvsObject_button::functionSetAutoDefault(KviKvsObjectFunctionCall *c)
-{
-	bool bEnabled;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
-	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QPushButton *)widget())->setAutoDefault(bEnabled);
-	return true;
-}
-bool KviKvsObject_button::functionSetToggleButton(KviKvsObjectFunctionCall *c)
-{
-	bool bEnabled;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
-	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QPushButton *)widget())->setCheckable(bEnabled);
-	return true;
-}
-bool KviKvsObject_button::functionSetChecked(KviKvsObjectFunctionCall *c)
-{
-	bool bEnabled;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
-	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QPushButton *)widget())->setChecked(bEnabled);
-	return true;
-}
-
-
-//
-bool KviKvsObject_button::functionIsChecked(KviKvsObjectFunctionCall *c)
-{
-	if (widget()) c->returnValue()->setBoolean(((QPushButton *)widget())->isChecked());
-	return true;
-}
-bool KviKvsObject_button::functionToggle(KviKvsObjectFunctionCall *c)
-{
-	if(widget()) ((QPushButton *)widget())->toggle();
+	((QPushButton *)widget())->setText(szText);
 	return true;
 }
 
-bool KviKvsObject_button::functionSetImage(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(button,setImage)
 {
-	QString icon;
+	CHECK_INTERNAL_QPOINTER(widget())
+	KviKvsVariant icon;
 	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("icon",KVS_PT_STRING,0,icon)
+		KVSO_PARAMETER("icon_or_hobject",KVS_PT_VARIANT,0,icon)
 	KVSO_PARAMETERS_END(c)
-	if (!widget()) return true;
-	QPixmap * pix = g_pIconManager->getImage(icon);
+	if(icon.isHObject())
+	{
+		kvs_hobject_t hObj;
+		icon.asHObject(hObj);	
+		KviKvsObject *pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObj);
+		if (!pObject)
+		{
+			c->warning(__tr2qs("Pixmap parameter is not an object!"));
+			return true;
+		}
+		if(pObject->inherits("KviKvsObject_pixmap"))
+			((QPushButton *)widget())->setIcon(QIcon(*((KviKvsObject_pixmap *)pObject)->getPixmap()));
+		else{ 
+			c->warning(__tr2qs("Object Pixmap required!"));
+		}
+		return true;
+	}
+	QString szIcon;
+	icon.asString(szIcon);
+	QPixmap * pix = g_pIconManager->getImage(szIcon);
 	if(pix)	((QPushButton *)widget())->setIcon(*pix);
 	else((QPushButton *)widget())->setIcon(QIcon());
 	return true;
 }
-bool KviKvsObject_button::functionclickEvent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(button,clickEvent)
 {
 	emitSignal("clicked",c);
 	return true;
 }
 
+// slots
 void KviKvsObject_button::slotClicked()
 {
 	KviKvsVariantList *params=0;
diff --git a/src/modules/objects/class_button.h b/src/modules/objects/class_button.h
index e30ecb98d..e4ffe4c05 100644
--- a/src/modules/objects/class_button.h
+++ b/src/modules/objects/class_button.h
@@ -40,16 +40,11 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functionSetText(KviKvsObjectFunctionCall *c);
-	bool functionIsChecked(KviKvsObjectFunctionCall *c);
-	bool functionText(KviKvsObjectFunctionCall *c);
-	bool functionSetAutoDefault(KviKvsObjectFunctionCall *c);
-	bool functionSetToggleButton(KviKvsObjectFunctionCall *c);
-	bool functionSetChecked(KviKvsObjectFunctionCall *c);
-	bool functionisChecked(KviKvsObjectFunctionCall *c);
-	bool functionToggle(KviKvsObjectFunctionCall *c);
-	bool functionSetImage(KviKvsObjectFunctionCall *c);
-	bool functionclickEvent(KviKvsObjectFunctionCall *c);
+	bool setText(KviKvsObjectFunctionCall *c);
+	bool text(KviKvsObjectFunctionCall *c);
+
+	bool setImage(KviKvsObjectFunctionCall *c);
+	bool clickEvent(KviKvsObjectFunctionCall *c);
 
 protected slots:
 	void slotClicked();
diff --git a/src/modules/objects/class_buttongroup.cpp b/src/modules/objects/class_buttongroup.cpp
index 268382964..bbbd1df21 100644
--- a/src/modules/objects/class_buttongroup.cpp
+++ b/src/modules/objects/class_buttongroup.cpp
@@ -55,8 +55,8 @@
 */
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_buttongroup,"buttongroup","object")
-	KVSO_REGISTER_HANDLER(KviKvsObject_buttongroup,"addButton",functionAddButton)
-	KVSO_REGISTER_HANDLER(KviKvsObject_buttongroup,"checkedButton",functionCheckedButton)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_buttongroup,addButton)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_buttongroup,checkedButton)
 
 KVSO_END_REGISTERCLASS(KviKvsObject_buttongroup)
 
@@ -73,8 +73,9 @@ delete m_pButtonGroup;
 KVSO_END_CONSTRUCTOR(KviKvsObject_buttongroup)
 
 
-bool KviKvsObject_buttongroup::functionAddButton(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(buttongroup,addButton)
 {
+	CHECK_INTERNAL_QPOINTER(m_pButtonGroup)
 	KviKvsObject * pObject;
 	kvs_hobject_t hObject;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -108,8 +109,9 @@ bool KviKvsObject_buttongroup::functionAddButton(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-bool KviKvsObject_buttongroup::functionCheckedButton(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(buttongroup,checkedButton)
 {
+	CHECK_INTERNAL_QPOINTER(m_pButtonGroup)
 	int id=m_pButtonGroup->checkedId();
 	if (id!=-1) c->returnValue()->setHObject(btnDict.find(id)->handle());
 	else c->returnValue()->setNothing();
diff --git a/src/modules/objects/class_buttongroup.h b/src/modules/objects/class_buttongroup.h
index d8c3a1a17..a6cacd074 100644
--- a/src/modules/objects/class_buttongroup.h
+++ b/src/modules/objects/class_buttongroup.h
@@ -38,8 +38,8 @@ protected:
 	QButtonGroup *m_pButtonGroup;
 	int m_iId;
 	KviPointerHashTable<int ,KviKvsObject > btnDict;
-	bool functionAddButton(KviKvsObjectFunctionCall *c);
-	bool functionCheckedButton(KviKvsObjectFunctionCall *c);
+	bool addButton(KviKvsObjectFunctionCall *c);
+	bool checkedButton(KviKvsObjectFunctionCall *c);
 
 };
 #endif	//!_CLASS_GROUPBOX_H_
diff --git a/src/modules/objects/class_checkbox.cpp b/src/modules/objects/class_checkbox.cpp
index 5f687d3cd..45f22b815 100644
--- a/src/modules/objects/class_checkbox.cpp
+++ b/src/modules/objects/class_checkbox.cpp
@@ -63,11 +63,9 @@
 //---------------------------------------------------------------------------------
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_checkbox,"checkbox","button")
-	// appearance
-	KVSO_REGISTER_HANDLER(KviKvsObject_checkbox,"setChecked",function_setChecked)
-	KVSO_REGISTER_HANDLER(KviKvsObject_checkbox,"isChecked",function_isChecked)
-	KVSO_REGISTER_HANDLER(KviKvsObject_checkbox,"toggleEvent",function_toggleEvent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_checkbox,"setText",function_setText)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_checkbox,setChecked)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_checkbox,isChecked)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_checkbox,toggleEvent)
 KVSO_END_REGISTERCLASS(KviKvsObject_checkbox)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_checkbox,KviKvsObject_button)
@@ -89,38 +87,31 @@ bool KviKvsObject_checkbox::init(KviKvsRunTimeContext * pContext,KviKvsVariantLi
 	return true;
 }
 
-bool KviKvsObject_checkbox::function_isChecked(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(checkbox,isChecked)
 {
-	if(widget()) c->returnValue()->setBoolean(((QCheckBox *)widget())->isChecked());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setBoolean(((QCheckBox *)widget())->isChecked());
 	return true;
 }
 
-bool KviKvsObject_checkbox::function_setChecked(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(checkbox,setChecked)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bChecked;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bChecked",KVS_PT_BOOL,KVS_PF_OPTIONAL,bChecked)
 	KVSO_PARAMETERS_END(c)
-	if(widget()) ((QCheckBox *)widget())->setChecked(bChecked);
+	((QCheckBox *)widget())->setChecked(bChecked);
 	return true;
 }
 
-bool KviKvsObject_checkbox::function_setText(KviKvsObjectFunctionCall *c)
-{
-	QString szText;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
-	KVSO_PARAMETERS_END(c)
-	if(widget()) ((QCheckBox *)widget())->setText(szText);
-	return true;
-}
-
-bool KviKvsObject_checkbox::function_toggleEvent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(checkbox,toggleEvent)
 {
 	emitSignal("toggled",c,c->params());
 	return true;
 }
 
+//slots
 void KviKvsObject_checkbox::toggled(bool b)
 {
 	KviKvsVariantList params(new KviKvsVariant(b));
diff --git a/src/modules/objects/class_checkbox.h b/src/modules/objects/class_checkbox.h
index 74e0fd4fd..943f00b3b 100644
--- a/src/modules/objects/class_checkbox.h
+++ b/src/modules/objects/class_checkbox.h
@@ -40,10 +40,10 @@ public:
 	QWidget * widget() { return (QWidget *)object(); };
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
-	bool function_setChecked(KviKvsObjectFunctionCall *c);
-	bool function_isChecked(KviKvsObjectFunctionCall *c);
-	bool function_toggleEvent(KviKvsObjectFunctionCall *c);
-	bool function_setText(KviKvsObjectFunctionCall *c);
+	bool setChecked(KviKvsObjectFunctionCall *c);
+	bool isChecked(KviKvsObjectFunctionCall *c);
+	bool toggleEvent(KviKvsObjectFunctionCall *c);
+	bool setText(KviKvsObjectFunctionCall *c);
 protected slots:
 	void toggled(bool b);
 };
diff --git a/src/modules/objects/class_combobox.cpp b/src/modules/objects/class_combobox.cpp
index ace3bec27..6a2b54ea3 100644
--- a/src/modules/objects/class_combobox.cpp
+++ b/src/modules/objects/class_combobox.cpp
@@ -100,27 +100,27 @@
 
 */
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_combobox,"combobox","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"insertItem", functioninsertItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"changeItem", functionchangeItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"removeItem", functionremoveItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"clear", functionclear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"setMaxCount", functionsetMaxCount)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"maxCount", functionmaxCount)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"count", functioncount)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"current", functioncurrent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"currentItem", functioncurrentItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"setEditable", functionsetEditable);
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"editable", functioneditable)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"setEditText", functionsetEditText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"textAt", functiontextAt)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"textLineEdit", functiontextLineEdit)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"setTextLineEdit", functionsetTextLineEdit)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"setCurrentItem", functionsetCurrentItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"popup", functionpopup)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,insertItem)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,changeItem)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,removeItem)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,clear)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,setMaxCount)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,maxCount)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,count)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,current)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,currentItem)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,setEditable);
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,editable)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,setEditText)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,textAt)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,textLineEdit)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,setTextLineEdit)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,setCurrentItem)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,popup)
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"setInsertionPolicy", functionsetInsertionPolicy)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"textChangedEvent", functiontextChangedEvent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_combobox,"activatedEvent", functionactivatedEvent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,setInsertionPolicy)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,textChangedEvent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_combobox,activatedEvent)
 
 KVSO_END_REGISTERCLASS(KviKvsObject_combobox)
 
@@ -141,36 +141,36 @@ bool KviKvsObject_combobox::init(KviKvsRunTimeContext * pContext,KviKvsVariantLi
 	return true;
 }
 
-bool KviKvsObject_combobox::functioninsertItem(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,insertItem)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_int_t iIndex;
 	QString szItem;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("item",KVS_PT_STRING,0,szItem)
 		KVSO_PARAMETER("index",KVS_PT_INT,KVS_PF_OPTIONAL,iIndex)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		if(c->paramCount()==1)
-			((QComboBox *)widget())->addItem(szItem);
-		else
-			((QComboBox *)widget())->insertItem( iIndex,szItem);
+	if(c->paramCount()==1)
+		((QComboBox *)widget())->addItem(szItem);
+	else
+		((QComboBox *)widget())->insertItem( iIndex,szItem);
 	return true;
 }
-bool KviKvsObject_combobox::functionclear(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,clear)
 {
-	if (widget()) ((QComboBox *)widget())->clear();
+	CHECK_INTERNAL_QPOINTER(widget())
+	((QComboBox *)widget())->clear();
 	return true;
 }
-bool KviKvsObject_combobox::functionchangeItem(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,changeItem)
 {
-
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t uIndex,cnt;
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
 		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
 	if (szText.isEmpty()) c->warning(__tr2qs("No string parameter given - using empty string"));
 	if(uIndex >= (cnt = ((QComboBox *)widget())->count()))
 	{
@@ -178,20 +178,17 @@ bool KviKvsObject_combobox::functionchangeItem(KviKvsObjectFunctionCall *c)
 			"$count() - 1 [%d]"), uIndex, cnt);
 		uIndex = cnt - 1;
 	}
-
 	((QComboBox *)widget())->setItemText( uIndex,szText);
-
 	return true;
 
 }
-bool KviKvsObject_combobox::functionremoveItem(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,removeItem)
 {
-
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t uIndex,cnt;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
 	if(uIndex >= (cnt = ((QComboBox *)widget())->count()))
 	{
 		c->warning(__tr2qs("Item index [%d] is too big - defaulting to " \
@@ -204,121 +201,121 @@ bool KviKvsObject_combobox::functionremoveItem(KviKvsObjectFunctionCall *c)
 	return true;
 
 }
-bool KviKvsObject_combobox::functionsetMaxCount(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,setMaxCount)
 {
-
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t iMax;
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("count",KVS_PT_UNSIGNEDINTEGER,0,iMax)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QComboBox *)widget())->setMaxCount(iMax);
+	((QComboBox *)widget())->setMaxCount(iMax);
 	return true;
 }
-bool KviKvsObject_combobox::functionmaxCount(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,maxCount)
 {
-	if (widget()) c->returnValue()->setInteger(((QComboBox *)widget())->maxCount());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setInteger(((QComboBox *)widget())->maxCount());
 	return true;
 }
-bool KviKvsObject_combobox::functioncount(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,count)
 {
-	if (widget()) c->returnValue()->setInteger(((QComboBox *)widget())->count());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setInteger(((QComboBox *)widget())->count());
 	return true;
 }
-bool KviKvsObject_combobox::functioncurrent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,current)
 {
-	if (widget()) c->returnValue()->setString(((QComboBox *)widget())->currentText());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setString(((QComboBox *)widget())->currentText());
 	return true;
 }
-bool KviKvsObject_combobox::functioncurrentItem(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,currentItem)
 {
-	if (widget()) c->returnValue()->setInteger(((QComboBox *)widget())->currentIndex());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setInteger(((QComboBox *)widget())->currentIndex());
 	return true;
 }
-bool KviKvsObject_combobox::functiontextLineEdit(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,textLineEdit)
 {
-	if (widget()) c->returnValue()->setString(((QComboBox *)widget())->lineEdit()->text());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setString(((QComboBox *)widget())->lineEdit()->text());
 	return true;
 }
 
-bool KviKvsObject_combobox::functionsetEditable(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,setEditable)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bFlag;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bflag",KVS_PT_BOOLEAN,0,bFlag)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-	{
-		((QComboBox *)widget())->setEditable(bFlag);
-	}
-
+	((QComboBox *)widget())->setEditable(bFlag);
 	return true;
 }
-bool KviKvsObject_combobox::functionsetTextLineEdit(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,setTextLineEdit)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QComboBox *)widget())->lineEdit()->setText(szText);
+	((QComboBox *)widget())->lineEdit()->setText(szText);
 	return true;
 }
 
-bool KviKvsObject_combobox::functioneditable(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,editable)
 {
-	if(widget())
-		c->returnValue()->setBoolean(((QComboBox *)widget())->isEditable());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setBoolean(((QComboBox *)widget())->isEditable());
 	return true;
 }
-bool KviKvsObject_combobox::functionsetEditText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,setEditText)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szText;
 	bool bQuiet=false;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
 		KVSO_PARAMETER("quiet",KVS_PT_BOOLEAN,KVS_PF_OPTIONAL,bQuiet)
 	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
 	if (szText.isEmpty() && !bQuiet) c->warning("No string parameter given - using empty string");
 	((QComboBox *)widget())->setEditText(szText);
 	return true;
 }
-bool KviKvsObject_combobox::functiontextAt(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,textAt)
 {
-
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t uIndex;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		c->returnValue()->setString(((QComboBox *)widget())->itemText(uIndex));
+	c->returnValue()->setString(((QComboBox *)widget())->itemText(uIndex));
 	return true;
 }
-bool KviKvsObject_combobox::functionsetCurrentItem(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,setCurrentItem)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t uIndex;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QComboBox *)widget())->setCurrentIndex(uIndex);
+	((QComboBox *)widget())->setCurrentIndex(uIndex);
 	return true;
 }
-bool KviKvsObject_combobox::functionpopup(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,popup)
 {
 	if(widget())
 	   ((QComboBox *)widget())->showPopup();
 	return true;
 }
-bool KviKvsObject_combobox::functionsetInsertionPolicy(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,setInsertionPolicy)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szPolicy;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("policy",KVS_PT_STRING,0,szPolicy)
 	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
 	if(KviQString::equalCI(szPolicy,"NoInsertion"))
 			((QComboBox *)widget())->setInsertPolicy(QComboBox::NoInsert);
 	else if(KviQString::equalCI(szPolicy,"AtTop"))
@@ -335,28 +332,25 @@ bool KviKvsObject_combobox::functionsetInsertionPolicy(KviKvsObjectFunctionCall
 	return true;
 }
 
-
-
-bool KviKvsObject_combobox::functiontextChangedEvent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(combobox,textChangedEvent)
 {
-
 	emitSignal("textChanged",c,c->params());
 	return true;
-
 }
 
-void KviKvsObject_combobox::editTextChanged(const QString &text)
-{
-	KviKvsVariantList params(new KviKvsVariant(text));
-	callFunction(this,"textChangedEvent",&params);
-}
 
-bool KviKvsObject_combobox::functionactivatedEvent(KviKvsObjectFunctionCall *c)
-{
 
+KVSO_CLASS_FUNCTION(combobox,activatedEvent)
+{
 	emitSignal("activated",c,c->params());
 	return true;
+}
 
+//slots
+void KviKvsObject_combobox::editTextChanged(const QString &text)
+{
+	KviKvsVariantList params(new KviKvsVariant(text));
+	callFunction(this,"textChangedEvent",&params);
 }
 
 void KviKvsObject_combobox::slotActivated(int i)
diff --git a/src/modules/objects/class_combobox.h b/src/modules/objects/class_combobox.h
index 7f1f440b4..366424bec 100644
--- a/src/modules/objects/class_combobox.h
+++ b/src/modules/objects/class_combobox.h
@@ -41,31 +41,31 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 	
-	bool functioninsertItem(KviKvsObjectFunctionCall *c);
-	bool functionchangeItem(KviKvsObjectFunctionCall *c);
-	bool functionremoveItem(KviKvsObjectFunctionCall *c);
-	bool functionclear(KviKvsObjectFunctionCall *c);
+	bool insertItem(KviKvsObjectFunctionCall *c);
+	bool changeItem(KviKvsObjectFunctionCall *c);
+	bool removeItem(KviKvsObjectFunctionCall *c);
+	bool clear(KviKvsObjectFunctionCall *c);
 //#warning "$insertPixItem"
 //#warning "$changePixItem"
 
-	bool functioncount(KviKvsObjectFunctionCall *c);
-	bool functionsetMaxCount(KviKvsObjectFunctionCall *c);
-	bool functionmaxCount(KviKvsObjectFunctionCall *c);
-	bool functioncurrent(KviKvsObjectFunctionCall *c);
-	bool functioncurrentItem(KviKvsObjectFunctionCall *c);
-	bool functionsetEditable(KviKvsObjectFunctionCall *c);
-	bool functioneditable(KviKvsObjectFunctionCall *c);
-	bool functionsetEditText(KviKvsObjectFunctionCall *c);
-	bool functiontextAt(KviKvsObjectFunctionCall *c);
-	bool functiontextLineEdit(KviKvsObjectFunctionCall *c);
-	bool functionsetTextLineEdit(KviKvsObjectFunctionCall *c);
+	bool count(KviKvsObjectFunctionCall *c);
+	bool setMaxCount(KviKvsObjectFunctionCall *c);
+	bool maxCount(KviKvsObjectFunctionCall *c);
+	bool current(KviKvsObjectFunctionCall *c);
+	bool currentItem(KviKvsObjectFunctionCall *c);
+	bool setEditable(KviKvsObjectFunctionCall *c);
+	bool editable(KviKvsObjectFunctionCall *c);
+	bool setEditText(KviKvsObjectFunctionCall *c);
+	bool textAt(KviKvsObjectFunctionCall *c);
+	bool textLineEdit(KviKvsObjectFunctionCall *c);
+	bool setTextLineEdit(KviKvsObjectFunctionCall *c);
 
-	bool functionsetInsertionPolicy(KviKvsObjectFunctionCall *c);
+	bool setInsertionPolicy(KviKvsObjectFunctionCall *c);
 
-	bool functionsetCurrentItem(KviKvsObjectFunctionCall *c);
-	bool functionpopup(KviKvsObjectFunctionCall *c);
-	bool functiontextChangedEvent(KviKvsObjectFunctionCall *c);
-	bool functionactivatedEvent(KviKvsObjectFunctionCall *c);
+	bool setCurrentItem(KviKvsObjectFunctionCall *c);
+	bool popup(KviKvsObjectFunctionCall *c);
+	bool textChangedEvent(KviKvsObjectFunctionCall *c);
+	bool activatedEvent(KviKvsObjectFunctionCall *c);
 protected slots:
 	void editTextChanged(const QString &);
 	void slotActivated(int);
diff --git a/src/modules/objects/class_dialog.cpp b/src/modules/objects/class_dialog.cpp
index e34eb6ccb..cbd10ea99 100644
--- a/src/modules/objects/class_dialog.cpp
+++ b/src/modules/objects/class_dialog.cpp
@@ -54,7 +54,7 @@
 */
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_dialog,"dialog","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_dialog,"setModal",functionSetModal)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_dialog,setModal)
 KVSO_END_REGISTERCLASS(KviKvsObject_dialog)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_dialog,KviKvsObject_widget)
@@ -76,14 +76,14 @@ bool KviKvsObject_dialog::init(KviKvsRunTimeContext * pContext,KviKvsVariantList
 	setObject(d);
 	return true;
 }
-bool KviKvsObject_dialog::functionSetModal(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(dialog,setModal)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QDialog *)widget())->setModal(bEnabled);
+	((QDialog *)widget())->setModal(bEnabled);
 	return true;
 }
 
diff --git a/src/modules/objects/class_dialog.h b/src/modules/objects/class_dialog.h
index fe345c167..77aab18b8 100644
--- a/src/modules/objects/class_dialog.h
+++ b/src/modules/objects/class_dialog.h
@@ -36,7 +36,7 @@ public:
 	QWidget * widget() { return (QWidget *)object(); };
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
-	bool functionSetModal(KviKvsObjectFunctionCall *c);
+	bool setModal(KviKvsObjectFunctionCall *c);
 };
 
 #endif // !_CLASS_DIALOG_H_
diff --git a/src/modules/objects/class_dockwindow.cpp b/src/modules/objects/class_dockwindow.cpp
index 44768bb47..c787733a6 100644
--- a/src/modules/objects/class_dockwindow.cpp
+++ b/src/modules/objects/class_dockwindow.cpp
@@ -64,11 +64,11 @@
 
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_dockwindow,"dockwindow","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_dockwindow,"addWidget",function_addWidget)
-	KVSO_REGISTER_HANDLER(KviKvsObject_dockwindow,"resizeEnabled",function_resizeEnabled)
-	KVSO_REGISTER_HANDLER(KviKvsObject_dockwindow,"setResizeEnabled",function_setResizeEnabled)
-	KVSO_REGISTER_HANDLER(KviKvsObject_dockwindow,"setAllowedDockAreas",function_setAllowedDockAreas)
-	KVSO_REGISTER_HANDLER(KviKvsObject_dockwindow,"dock",function_dock)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_dockwindow,addWidget)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_dockwindow,resizeEnabled)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_dockwindow,setResizeEnabled)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_dockwindow,setAllowedDockAreas)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_dockwindow,dock)
 KVSO_END_REGISTERCLASS(KviKvsObject_dockwindow)
 
 
@@ -89,15 +89,13 @@ bool KviKvsObject_dockwindow::init(KviKvsRunTimeContext * pContext,KviKvsVariant
 	return true;
 }
 
-bool KviKvsObject_dockwindow::function_addWidget(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(dockwindow,addWidget)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_hobject_t hWidget;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("widget",KVS_PT_HOBJECT,0,hWidget)
 	KVSO_PARAMETERS_END(c)
-
-	if(!widget())return true; // hum ? dead ?
-
 	if(hWidget == (kvs_hobject_t)0)
 	{
 		// null widget ?
@@ -133,33 +131,31 @@ bool KviKvsObject_dockwindow::function_addWidget(KviKvsObjectFunctionCall *c)
 	return true;
 }
 // Fix me
-bool KviKvsObject_dockwindow::function_resizeEnabled(KviKvsObjectFunctionCall * c)
+KVSO_CLASS_FUNCTION(dockwindow,resizeEnabled)
 {
-	if(!widget())return true; // hum ? dead ?
+	CHECK_INTERNAL_QPOINTER(widget())
 	c->returnValue()->setBoolean(false);
 	return true;
 }
 
 // Fix me
-bool KviKvsObject_dockwindow::function_setResizeEnabled(KviKvsObjectFunctionCall * c)
+KVSO_CLASS_FUNCTION(dockwindow,setResizeEnabled)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bResizeEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bResizeEnabled)
 	KVSO_PARAMETERS_END(c)
-	if(!widget())return true; // hum ? dead ?
 	return true;
 }
 
-bool KviKvsObject_dockwindow::function_setAllowedDockAreas(KviKvsObjectFunctionCall * c)
+KVSO_CLASS_FUNCTION(dockwindow,setAllowedDockAreas)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szFlags;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("docks",KVS_PT_STRING,0,szFlags)
 	KVSO_PARAMETERS_END(c)
-
-	if(!widget())return true; // hum ? dead ?
-
 	Qt::DockWidgetAreas fAreas = Qt::NoDockWidgetArea;
 	if(szFlags.indexOf('t',Qt::CaseInsensitive))fAreas |= Qt::TopDockWidgetArea;
 	if(szFlags.indexOf('l',Qt::CaseInsensitive))fAreas |= Qt::LeftDockWidgetArea;
@@ -179,14 +175,13 @@ bool KviKvsObject_dockwindow::function_setAllowedDockAreas(KviKvsObjectFunctionC
 }
 
 
-bool KviKvsObject_dockwindow::function_dock(KviKvsObjectFunctionCall * c)
+KVSO_CLASS_FUNCTION(dockwindow,dock)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szDock;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("dock",KVS_PT_STRING,0,szDock)
 	KVSO_PARAMETERS_END(c)
-
-	if(!widget())return true; // hum ? dead ?
 	g_pFrame->removeDockWidget(_pDockWindow);
 	if(szDock.indexOf('m',Qt::CaseInsensitive) == -1)_pDockWindow->setFloating(false);
 	if(szDock.indexOf('t',Qt::CaseInsensitive) != -1)g_pFrame->addDockWidget(Qt::TopDockWidgetArea,_pDockWindow);
diff --git a/src/modules/objects/class_dockwindow.h b/src/modules/objects/class_dockwindow.h
index f288190cb..da9ae4a01 100644
--- a/src/modules/objects/class_dockwindow.h
+++ b/src/modules/objects/class_dockwindow.h
@@ -36,13 +36,13 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 	
-	bool function_addWidget(KviKvsObjectFunctionCall *c);
-	bool function_orientation(KviKvsObjectFunctionCall *c);
-	bool function_setOrientation(KviKvsObjectFunctionCall *c);
-	bool function_resizeEnabled(KviKvsObjectFunctionCall *c);
-	bool function_setResizeEnabled(KviKvsObjectFunctionCall * c);
-	bool function_setAllowedDockAreas(KviKvsObjectFunctionCall * c);
-	bool function_dock(KviKvsObjectFunctionCall * c);
+	bool addWidget(KviKvsObjectFunctionCall *c);
+	bool orientation(KviKvsObjectFunctionCall *c);
+	bool setOrientation(KviKvsObjectFunctionCall *c);
+	bool resizeEnabled(KviKvsObjectFunctionCall *c);
+	bool setResizeEnabled(KviKvsObjectFunctionCall * c);
+	bool setAllowedDockAreas(KviKvsObjectFunctionCall * c);
+	bool dock(KviKvsObjectFunctionCall * c);
 };
 
 #endif //!_CLASS_DOCKWINDOW_H_
diff --git a/src/modules/objects/class_file.cpp b/src/modules/objects/class_file.cpp
index 31cf10916..4494c5afb 100644
--- a/src/modules/objects/class_file.cpp
+++ b/src/modules/objects/class_file.cpp
@@ -1,11 +1,11 @@
 //=============================================================================
 //
-//   File : class_file.cpp
-//   Creation date : Thu Sep 21 04:42:16 CEST 2000 by Krzysztof Godlewski
+//   File : class_memorybuffer.cpp
+//   Creation date : Fri Mar 18 21:30:48 CEST 2005
+//   by Tonino Imbesi(Grifisx) and Alessandro Carbone(Noldor)
 //
 //   This file is part of the KVirc irc client distribution
-//   Copyright (C) 2000 Krzysztof Godlewski
-//   Copyright (C) 2000-2008 Szymon Stefanek (pragma at kvirc dot net)
+//   Copyright (C) 2005-2008 Alessandro Carbone (elfonol at gmail dot com)
 //
 //   This program is FREE software. You can redistribute it and/or
 //   modify it under the terms of the GNU General Public License
@@ -23,20 +23,19 @@
 //
 //=============================================================================
 
-//#warning "Add QFILEINFO to this stuff ?"
 
 #include "class_file.h"
 #include "kvi_debug.h"
 #include "kvi_locale.h"
 #include "kvi_error.h"
+#include "kvi_file.h"
 #include "kvi_fileutils.h"
+#include "class_memorybuffer.h"
 
 #include <QStringList>
-#include <QFile>
+//#include <QFile>
 #include <QTextStream>
 
-
-
 // needed for $open()
 const char * const mod_tbl[] =	{
 					"Raw",
@@ -46,20 +45,14 @@ const char * const mod_tbl[] =	{
 					"Append",
 					"Truncate"
 				  };
-#define	IO_RAW QIODevice::Unbuffered
-#define IO_READONLY QIODevice::ReadOnly
-#define IO_WRITEONLY QIODevice::WriteOnly
-#define IO_READWRITE QIODevice::ReadWrite
-#define IO_APPEND QIODevice::Append
-#define IO_TRUNCATE QIODevice::Truncate
-//#define IO_TRANSLATE QIODevice::Text
+
 const QIODevice::OpenMode mod_cod[] = {
-				IO_RAW,
-				IO_READONLY,
-				IO_WRITEONLY,
-				IO_READWRITE,
-				IO_APPEND,
-				IO_TRUNCATE
+				QIODevice::Unbuffered,
+				QIODevice::ReadOnly,
+				QIODevice::WriteOnly,
+				QIODevice::ReadWrite,
+				QIODevice::Append,
+				QIODevice::Truncate
 			};
 
 #define mod_num			(sizeof(mod_tbl) / sizeof(mod_tbl[0]))
@@ -155,45 +148,53 @@ const QIODevice::OpenMode mod_cod[] = {
 */
 
 
-//---------------------------------------------------------------------------------
-
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_file,"file","object")
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"setName", functionsetName)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"name", functionname)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"open", functionopen)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"isOpen", functionisOpen)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"close", functionclose)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"flush", functionflush)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"size", functionsize)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"atEnd", functionatEnd)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"where", functionwhere)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"setName",setName)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"name",name)
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"seek", functionseek)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"putch", functionputch)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"getch", functiongetch)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"ungetch", functionunGetch)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readBlock", functionreadBlock)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"open",open)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"isOpen",isOpen)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"close",close)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"flush",flush)
+	
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"size",size)
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readHexBlock", functionreadHexBlock)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeHexBlock", functionwriteHexBlock)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"atEnd",atEnd)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"where",where)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"seek",seek)
+	
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"putch",putch)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"getch",getch)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"ungetch",unGetch)
+	
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readBlock",readBlock)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeBlock", writeBlock)
+
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readHexBlock",readHexBlock)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeHexBlock",writeHexBlock)
+
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readLine",readLine)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeLine",writeLine)
+
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"write",write)
+	KVSO_REGISTER_HANDLER(KviKvsObject_file,"read",read)
+	
 	
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeBlock", functionwriteBlock)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"readLine", functionreadLine)
-	KVSO_REGISTER_HANDLER(KviKvsObject_file,"writeLine", functionwriteLine)
 KVSO_END_REGISTERCLASS(KviKvsObject_file)
 
+
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_file,KviKvsObject)
-	m_pFile = new QFile();
-KVSO_END_CONSTRUCTOR(KviKvsObject_file)
 
-KVSO_BEGIN_DESTRUCTOR(KviKvsObject_file)
-if (m_pFile) delete m_pFile;
-m_pFile=0;
+	m_pFile = new KviFile();
 
 KVSO_END_CONSTRUCTOR(KviKvsObject_file)
 
+KVSO_BEGIN_DESTRUCTOR(KviKvsObject_file)
+
+	if (m_pFile) delete m_pFile;
 
-bool KviKvsObject_file::functionsetName(KviKvsObjectFunctionCall *c)
+KVSO_END_CONSTRUCTOR(KviKvsObject_file)
+KVSO_CLASS_FUNCTION(file,setName)
 {
 	QString szName;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -202,26 +203,29 @@ bool KviKvsObject_file::functionsetName(KviKvsObjectFunctionCall *c)
 	if (m_pFile) m_pFile->setFileName(szName);
 	return true;
 }
-bool KviKvsObject_file::functionname(KviKvsObjectFunctionCall *c)
+
+KVSO_CLASS_FUNCTION(file,name)
 {
-	if (m_pFile) c->returnValue()->setString(m_pFile->fileName());
+	CHECK_INTERNAL_QPOINTER(m_pFile)
+	c->returnValue()->setString(m_pFile->fileName());
 	return true;
 }
 
-bool KviKvsObject_file::functionopen(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,open)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	QStringList modes;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("file_mode",KVS_PT_STRINGLIST,KVS_PF_OPTIONAL,modes)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
+	
 	if(m_pFile->fileName().isEmpty())
 	{
 		c->warning(__tr2qs("Empty filename string"));
 		return true;
 	}
 	QIODevice::OpenMode mod,sum;
-	if (modes.empty()) sum = IO_READONLY; // if no parameters given, default to ReadWrite | Append
+	if (modes.empty()) sum = QIODevice::ReadWrite|QIODevice::Append; // if no parameters given, default to ReadWrite | Append
 	else
 	{
 		for ( int idx=0;idx<modes.count();idx++)
@@ -246,75 +250,77 @@ bool KviKvsObject_file::functionopen(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_file::functionisOpen(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,isOpen)
 {
-	if (m_pFile) c->returnValue()->setBoolean(m_pFile->isOpen());
+	CHECK_INTERNAL_QPOINTER(m_pFile)
+	c->returnValue()->setBoolean(m_pFile->isOpen());
 	return true;
 }
 
-bool KviKvsObject_file::functionclose(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,close)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	if (!m_pFile->isOpen()) c->warning(__tr2qs("File is not open!"));
 	else m_pFile->close();
 	return true;
 }
-bool KviKvsObject_file::functionflush(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,flush)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	if (!m_pFile->isOpen()) c->warning(__tr2qs("File is not open!"));
 	else m_pFile->flush();
 	return true;
 }
 
-bool KviKvsObject_file::functionsize(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,size)
 {
-	if (m_pFile) c->returnValue()->setInteger((kvs_int_t)(m_pFile->size()));
+	CHECK_INTERNAL_QPOINTER(m_pFile)
+	c->returnValue()->setInteger((kvs_int_t)(m_pFile->size()));
 	return true;
 }
-bool KviKvsObject_file::functionatEnd(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,atEnd)
 {
-	if (m_pFile) c->returnValue()->setInteger((kvs_int_t)(m_pFile->atEnd()));
+	CHECK_INTERNAL_QPOINTER(m_pFile)
+	c->returnValue()->setInteger((kvs_int_t)(m_pFile->atEnd()));
 	return true;
 }
 
 
-bool KviKvsObject_file::functionwhere(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,where)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	if (!m_pFile->isOpen()) c->warning(__tr2qs("File is not open!"));
 	else c->returnValue()->setInteger((kvs_int_t)(m_pFile->pos()));
 	return true;
 }
-bool KviKvsObject_file::functionseek(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,seek)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	kvs_uint_t uIndex;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
 		c->warning(__tr2qs("File is not open !"));
 	else m_pFile->seek(uIndex);
 	return true;
 }
 
-bool KviKvsObject_file::functionputch(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,putch)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	QString szChar;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("char",KVS_PT_STRING,0,szChar)
 	KVSO_PARAMETERS_END(c)
-	if (m_pFile)
-	{
-		if (szChar.length()>1)c->warning(__tr2qs("Argument to long, using only first char"));
-		const char *ch=szChar.toUtf8().data();
-
-		if (!m_pFile->putChar(ch[0])) c->warning(__tr2qs("Write error occured !"));
-	}
-
+	if (szChar.length()>1)c->warning(__tr2qs("Argument to long, using only first char"));
+	const char *ch=szChar.toUtf8().data();
+	if (!m_pFile->putChar(ch[0])) c->warning(__tr2qs("Write error occured !"));
 	return true;
 }
-bool KviKvsObject_file::functiongetch(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,getch)
 {
-	if (!m_pFile) return true;
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	if(!m_pFile->isOpen())
 		c->warning(__tr2qs("File is not open !"));
 	else
@@ -326,13 +332,13 @@ bool KviKvsObject_file::functiongetch(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-bool KviKvsObject_file::functionunGetch(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,unGetch)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	QString szChar;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("char",KVS_PT_STRING,0,szChar)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
 	if(!m_pFile->isOpen())
 		c->warning(__tr2qs("File is not open !"));
 	else
@@ -343,49 +349,198 @@ bool KviKvsObject_file::functionunGetch(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-bool KviKvsObject_file::functionreadBlock(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,readBlock)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	kvs_uint_t uLen;
+	KviKvsObject * pObject;
+	kvs_hobject_t hObject;
 	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,0,uLen)
+		KVSO_PARAMETER("length",KVS_PT_UNSIGNEDINTEGER,0,uLen)
+		KVSO_PARAMETER("hobject",KVS_PT_HOBJECT,KVS_PF_OPTIONAL,hObject)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
 	if(!m_pFile->isOpen()){
 		c->warning(__tr2qs("File is not open !"));
 	}
 	else
 	{
+		if (uLen>(kvs_uint_t)m_pFile->size()) uLen=m_pFile->size();
+		if (hObject)
+		{
+			pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+			if (!pObject)
+			{
+				c->warning(__tr2qs("Buffer parameter is not an object"));
+				return true;
+			}
+			if (!pObject->inherits("KviKvsObject_memorybuffer"))
+			{
+				debug ("Classname %s",pObject->metaObject()->className());
+				c->warning(__tr2qs("Buffer parameter is not a memorybuffer object"));
+				return true;
+			}
+			//m_pFile->flush();
+			((KviKvsObject_memorybuffer *)pObject)->pBuffer()->append(m_pFile->read(uLen));
+			return true;
+		}
+		else
+		{
+			char * buff = new char[uLen + 1];
+			//m_pFile->flush(); // advice from QFile man page (to avoid trash)
+			int rlen = m_pFile->read(buff, uLen);
+			buff[rlen] = '\0';
+			QString szBlock(buff);
+			c->returnValue()->setString(szBlock);
+		}
+	}
+	return true;
+}
+KVSO_CLASS_FUNCTION(file,read)
+{
+	CHECK_INTERNAL_QPOINTER(m_pFile)
+	QString szType;
+	KVSO_PARAMETERS_BEGIN(c)
+			KVSO_PARAMETER("type",KVS_PT_STRING,0,szType)
+	KVSO_PARAMETERS_END(c)
+	if(!m_pFile->isOpen()){
+		c->warning(__tr2qs("File is not open !"));
+	}
+	else
+	{
+		if(KviQString::equalCI(szType, "String"))
+		{
+			QString szStr;
+			m_pFile->load((QString)szStr);
+			c->returnValue()->setString(szStr);
+		}
+		else if(KviQString::equalCI(szType, "Integer"))
+		{
+			int iValue;
+			m_pFile->load(iValue);
+			c->returnValue()->setInteger(iValue);
+		}
+		if(KviQString::equalCI(szType, "Array"))
+		{
+			QString szData;
+			m_pFile->load(szData);
+			KviKvsVariant *pVar = KviKvsVariant::unserialize(szData);
+			if (pVar->isArray())
+				c->returnValue()->setArray(pVar->array());
+			else
+				c->warning(__tr2qs("The incoming data doesn't an array"));
+		}
+		if(KviQString::equalCI(szType, "Dict"))
+		{
+			QString szData;
+			m_pFile->load(szData);
+			KviKvsVariant *pVar = KviKvsVariant::unserialize(szData);
+			if (pVar->isHash())
+				c->returnValue()->setHash(pVar->hash());
+			else
+				c->warning(__tr2qs("The incoming data doesn't a Dictionary"));
+		}
+		if(KviQString::equalCI(szType, "String"))
+		{
+			QString szStr;
+			m_pFile->load(szStr);
+			c->returnValue()->setString(szStr);
+		}
+	}
+	return true;
+}
+KVSO_CLASS_FUNCTION(file,write)
+{
+	CHECK_INTERNAL_QPOINTER(m_pFile)
+	KviKvsVariant * pVariantData;
+	KVSO_PARAMETERS_BEGIN(c)
+			KVSO_PARAMETER("variant_data",KVS_PT_VARIANT,0,pVariantData)
+	KVSO_PARAMETERS_END(c)
+	if(!m_pFile->isOpen())c->warning(__tr2qs("File is not open !"));
+	else
+	{
+		if (pVariantData->isInteger()) 
+		{
+			kvs_int_t num;
+			pVariantData->asInteger(num);
+			m_pFile->save(num);
+		}
+		if (pVariantData->isHash() || pVariantData->isArray() || pVariantData->isString())
+		{
+			QString szTmp;
+			pVariantData->serialize(szTmp);
+			m_pFile->save(szTmp);
+		}
 
-		char * buff = new char[uLen + 1];
-		m_pFile->flush(); // advice from QFile man page (to avoid trash)
-		int rlen = m_pFile->read(buff, uLen);
-		buff[rlen] = '\0';
-		QString szBlock(buff);
-		c->returnValue()->setString(szBlock);
 	}
 	return true;
 }
 
-bool KviKvsObject_file::functionwriteBlock(KviKvsObjectFunctionCall *c)
+
+KVSO_CLASS_FUNCTION(file,writeBlock)
 {
-	QString szBlock;
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	kvs_uint_t uLen;
+	KviKvsObject * pObject;
+	KviKvsVariant * pVariantData;
+	kvs_hobject_t hObject;
 	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,0,uLen)
-		KVSO_PARAMETER("text_block",KVS_PT_STRING,0,szBlock)
+			KVSO_PARAMETER("string_or_hobject",KVS_PT_VARIANT,0,pVariantData)
+			KVSO_PARAMETER("length",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
-	if(!m_pFile->isOpen())
-		c->warning(__tr2qs("File is not open !"));
-	const char *block=szBlock.toUtf8().data();
-	int rlen = m_pFile->write(block, uLen);
-	c->returnValue()->setInteger(rlen);
-	m_pFile->flush();
+	if(!m_pFile->isOpen())c->warning(__tr2qs("File is not open !"));
+	else
+	{
+		if (pVariantData->isHObject())
+		{
+			pVariantData->asHObject(hObject);
+			pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+			if (!pObject)
+			{
+				c->warning(__tr2qs("Buffer parameter is not an object"));
+				return true;
+			}
+			if (pObject->inherits("KviKvsObject_memorybuffer"))
+			{
+				if (!uLen)
+				{
+					if (((KviKvsObject_memorybuffer *)pObject)->pBuffer()->size())
+						uLen=((KviKvsObject_memorybuffer *)pObject)->pBuffer()->size();
+					else
+					{
+						c->warning(__tr2qs("The memoryBuffer object is empty: nothing will be saved"));
+					}
+				}
+				const char *pData=((KviKvsObject_memorybuffer *)pObject)->pBuffer()->data();
+				int rlen=m_pFile->write(pData,uLen);
+				c->returnValue()->setInteger(rlen);
+				//m_pFile->flush();
+			}
+			else
+			{
+				c->warning(__tr2qs("Buffer parameter is not a memorybufferobject"));
+				return true;
+			}
+		
+		}
+		else
+		{
+			if (!pVariantData->isString()){
+				c->warning(__tr2qs("Block must been a string or a memorybufferobject"));
+				return true;
+			}
+			QString szBlock;
+			pVariantData->asString(szBlock);
+			const char *block=szBlock.toUtf8().data();
+			int rlen = m_pFile->write(block, uLen);
+			c->returnValue()->setInteger(rlen);
+			//m_pFile->flush();
+		}
+	}
 	return true;
 }
-bool KviKvsObject_file::functionreadLine(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,readLine)
 {
-	if (!m_pFile) return true;
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	if(!m_pFile->isOpen())
 		c->warning(__tr2qs("File is not open !"));
 	else
@@ -396,13 +551,14 @@ bool KviKvsObject_file::functionreadLine(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-bool KviKvsObject_file::functionwriteLine(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,writeLine)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	QString szLine;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("text_line",KVS_PT_STRING,0,szLine)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
+	
 	if(!m_pFile->isOpen())
 		c->warning(__tr2qs("File is not open !"));
 	else
@@ -412,18 +568,19 @@ bool KviKvsObject_file::functionwriteLine(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-bool KviKvsObject_file::functionreadHexBlock(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,readHexBlock)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	kvs_uint_t uLen;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,0,uLen)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
+	
 	if(!m_pFile->isOpen())
 		c->warning(__tr2qs("File is not open !"));
 	else
 	{
-		if (uLen>m_pFile->size()) uLen=m_pFile->size();
+		if (uLen>(kvs_uint_t)m_pFile->size()) uLen=m_pFile->size();
 		char * buff = new char[uLen];
 		char * str = new char [(uLen*2)+1];
 		m_pFile->flush(); // advice from QFile man page (to avoid trash)
@@ -448,15 +605,16 @@ bool KviKvsObject_file::functionreadHexBlock(KviKvsObjectFunctionCall *c)
 	}
 	return true;
 }
-bool KviKvsObject_file::functionwriteHexBlock(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(file,writeHexBlock)
 {
+	CHECK_INTERNAL_QPOINTER(m_pFile)
 	QString szBlock;
 	kvs_uint_t uLen;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("text_block",KVS_PT_STRING,0,szBlock)
 		KVSO_PARAMETER("lenght",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
 	KVSO_PARAMETERS_END(c)
-	if (!m_pFile) return true;
+	
 	if(!m_pFile->isOpen()){
 		c->warning(__tr2qs("File is not open !"));
 		return true;
@@ -490,7 +648,6 @@ bool KviKvsObject_file::functionwriteHexBlock(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-
 #ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
 #include "m_class_file.moc"
 #endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
diff --git a/src/modules/objects/class_file.h b/src/modules/objects/class_file.h
index 09d1702a0..a7b42fcc3 100644
--- a/src/modules/objects/class_file.h
+++ b/src/modules/objects/class_file.h
@@ -1,13 +1,13 @@
-#ifndef	_CLASS_FILE_H_
-#define	_CLASS_FILE_H_
+#ifndef _CLASS_FILE_H_
+#define _CLASS_FILE_H_
 //=============================================================================
 //
-//   File : class_file.h
-//   Creation date : Thu Sep 21 04:43:01 CEST 2000 by Krzysztof Godlewski
+//   File : class_memorybuffer.h
+//   Creation date : Fri Mar 18 21:30:48 CEST 2005
+//   by Tonino Imbesi(Grifisx) and Alessandro Carbone(Noldor)
 //
 //   This file is part of the KVirc irc client distribution
-//   Copyright (C) 2000 Krzysztof Godlewski
-//   Copyright (C) 2000-2008 Szymon Stefanek (pragma at kvirc dot net)
+//   Copyright (C) 2005-2008 Alessandro Carbone (elfonol at gmail dot com)
 //
 //   This program is FREE software. You can redistribute it and/or
 //   modify it under the terms of the GNU General Public License
@@ -25,93 +25,53 @@
 //
 //=============================================================================
 
+#include "kvi_file.h"
 
-#include "kvi_string.h"
+#include "object_macros.h"
 
-#include <QFile>
 
-/*
-//class KviCommand;
-class KviParameterList;
 
-class KviScriptFileObject : public KviScriptObject
+class KviKvsObject_file : public KviKvsObject
 {
 	Q_OBJECT
 public:
-	KviScriptFileObject(KviScriptObjectClass *, KviScriptObject *, const char *);
-	virtual ~KviScriptFileObject();
-
-	static void registerSelf();
-	static void unregisterSelf();
-
+	KVSO_DECLARE_OBJECT(KviKvsObject_file)
 protected:
-	bool functionSetName(KviCommand *, KviParameterList *, KviStr &);
-	bool functionName(KviCommand *, KviParameterList *, KviStr &);
-	bool functionOpen(KviCommand *, KviParameterList *, KviStr &);
-	bool functionIsOpen(KviCommand *, KviParameterList *, KviStr &);
-	bool functionClose(KviCommand *, KviParameterList *, KviStr &);
-	bool functionFlush(KviCommand *, KviParameterList *, KviStr &);
-	bool functionSize(KviCommand *, KviParameterList *, KviStr &);
+	KviFile* m_pFile;
+public:
+	KviFile *pFile(){return m_pFile;};
+  	bool setName(KviKvsObjectFunctionCall *c);
+	bool name(KviKvsObjectFunctionCall *c);
+	bool open(KviKvsObjectFunctionCall *c);
+	bool isOpen(KviKvsObjectFunctionCall *c);
+	bool close(KviKvsObjectFunctionCall *c);
+	bool flush(KviKvsObjectFunctionCall *c);
+	bool size(KviKvsObjectFunctionCall *c);
 	
-	bool functionAtEnd(KviCommand *, KviParameterList *, KviStr &);
+	bool atEnd(KviKvsObjectFunctionCall *c);
 		// int QFile at() const
-	bool functionWhere(KviCommand *, KviParameterList *, KviStr &);
+	bool where(KviKvsObjectFunctionCall *c);
 		// void QFile at(int)
-	bool functionSeek(KviCommand *, KviParameterList *, KviStr &);
-	bool functionPutch(KviCommand *, KviParameterList *, KviStr &);
-	bool functionGetch(KviCommand *, KviParameterList *, KviStr &);
-	bool functionUngetch(KviCommand *, KviParameterList *, KviStr &);
+	bool seek(KviKvsObjectFunctionCall *c);
+	bool putch(KviKvsObjectFunctionCall *c);
+	bool getch(KviKvsObjectFunctionCall *c);
+	bool unGetch(KviKvsObjectFunctionCall *c);
 	
-	bool functionReadBlock(KviCommand *, KviParameterList *, KviStr &);
-	bool functionWriteBlock(KviCommand *, KviParameterList *, KviStr &);
+	bool readBlock(KviKvsObjectFunctionCall *c);
+	bool writeBlock(KviKvsObjectFunctionCall *c);
 
-	bool functionReadLine(KviCommand *, KviParameterList *, KviStr &);
-	bool functionWriteLine(KviCommand *, KviParameterList *, KviStr &);
-	bool functionHexWrite(KviCommand *, KviParameterList *, KviStr &);
-	bool functionHexRead(KviCommand *, KviParameterList *, KviStr &);
-	
-protected:
-	QFile * m_pFile;
-};
+	bool readLine(KviKvsObjectFunctionCall *c);
+	bool writeLine(KviKvsObjectFunctionCall *c);
+
+	bool readHexBlock(KviKvsObjectFunctionCall *c);
+	bool writeHexBlock(KviKvsObjectFunctionCall *c);
+
+	bool write(KviKvsObjectFunctionCall *c);
+	bool read(KviKvsObjectFunctionCall *c);
 
-*/
 
-#include "object_macros.h"
 
-class KviKvsObject_file : public KviKvsObject
-{
-public:
-	KVSO_DECLARE_OBJECT(KviKvsObject_file)
-protected:
-  	bool functionsetName(KviKvsObjectFunctionCall *c);
-	bool functionname(KviKvsObjectFunctionCall *c);
-	bool functionopen(KviKvsObjectFunctionCall *c);
-	bool functionisOpen(KviKvsObjectFunctionCall *c);
-	bool functionclose(KviKvsObjectFunctionCall *c);
-	bool functionflush(KviKvsObjectFunctionCall *c);
-	bool functionsize(KviKvsObjectFunctionCall *c);
-	
-	bool functionatEnd(KviKvsObjectFunctionCall *c);
-		// int QFile at() const
-	bool functionwhere(KviKvsObjectFunctionCall *c);
-		// void QFile at(int)
-	bool functionseek(KviKvsObjectFunctionCall *c);
-	bool functionputch(KviKvsObjectFunctionCall *c);
-	bool functiongetch(KviKvsObjectFunctionCall *c);
-	bool functionunGetch(KviKvsObjectFunctionCall *c);
-	
-	bool functionreadBlock(KviKvsObjectFunctionCall *c);
-	bool functionwriteBlock(KviKvsObjectFunctionCall *c);
 
-	bool functionreadLine(KviKvsObjectFunctionCall *c);
-	bool functionwriteLine(KviKvsObjectFunctionCall *c);
-/*	bool functionHexWrite(KviKvsObjectFunctionCall *c);
-	bool functionHexRead(KviKvsObjectFunctionCall *c);
-*/
-	bool functionreadHexBlock(KviKvsObjectFunctionCall *c);
-	
-bool functionwriteHexBlock(KviKvsObjectFunctionCall *c);
-protected:
-	QFile * m_pFile;
 };
+
 #endif	// !_CLASS_FILE_H_
diff --git a/src/modules/objects/class_ftp.cpp b/src/modules/objects/class_ftp.cpp
index 90760e0ae..c9a45cc33 100644
--- a/src/modules/objects/class_ftp.cpp
+++ b/src/modules/objects/class_ftp.cpp
@@ -74,6 +74,7 @@ KVSO_END_REGISTERCLASS(KviKvsObject_ftp)
 
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_ftp,KviKvsObject)
+debug("this %s",this->metaObject()->className());
 	m_pFtp = new QFtp();
 	m_pFile=0;
 	connect(m_pFtp,SIGNAL(commandFinished(int,bool)),this,SLOT(slotCommandFinished(int,bool)));
diff --git a/src/modules/objects/class_groupbox.cpp b/src/modules/objects/class_groupbox.cpp
index 6271ef533..86f80ce00 100644
--- a/src/modules/objects/class_groupbox.cpp
+++ b/src/modules/objects/class_groupbox.cpp
@@ -148,23 +148,23 @@ const int align_cod[] = {
 */
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_groupbox,"groupbox","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setTitle", functionSetTitle)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"title", functionTitle)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setFlat", functionSetFlat)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"isFlat", functionIsFlat)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setCheckable", functionSetCheckable)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"isCheckable", functionIsCheckable)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setInsideMargin", functionSetInsideMargin)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"insideMargin", functionInsideMargin)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setInsideSpacing", functionSetInsideSpacing)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"insideSpacing", functionInsideSpacing)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"addSpace", functionAddSpace)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"alignment", functionAlignment)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setAlignment", functionSetAlignment)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setOrientation", functionSetOrientation)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setLayoutOrientation", functionSetOrientation)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"isChecked", functionIsChecked)
-	KVSO_REGISTER_HANDLER(KviKvsObject_groupbox,"setChecked", functionSetChecked)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setTitle)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,title)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setFlat)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,isFlat)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setCheckable)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,isCheckable)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setInsideMargin)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,insideMargin)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setInsideSpacing)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,insideSpacing)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,addSpace)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,alignment)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setAlignment)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setOrientation)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setOrientation)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,isChecked)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_groupbox,setChecked)
 
 KVSO_END_REGISTERCLASS(KviKvsObject_groupbox)
 
@@ -187,7 +187,7 @@ bool KviKvsObject_groupbox::init(KviKvsRunTimeContext * pContext,KviKvsVariantLi
 	return true;
 }
 
-bool KviKvsObject_groupbox::functionSetTitle(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setTitle)
 {
 	QString szTitle;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -197,102 +197,110 @@ bool KviKvsObject_groupbox::functionSetTitle(KviKvsObjectFunctionCall *c)
 		((KviTalGroupBox *)widget())->setTitle(szTitle);
 	return true;
 }
-bool KviKvsObject_groupbox::functionTitle(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,title)
 {
 	if (widget()) c->returnValue()->setString(((KviTalGroupBox *)widget())->title());
 	return true;
 }
-bool KviKvsObject_groupbox::functionSetFlat(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setFlat)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bFlag",KVS_PT_BOOL,0,bEnabled)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((KviTalGroupBox *)widget())->setFlat(bEnabled);
+	((KviTalGroupBox *)widget())->setFlat(bEnabled);
 	return true;
 }
-bool KviKvsObject_groupbox::functionIsFlat(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,isFlat)
 {
-	if (widget()) c->returnValue()->setBoolean(((KviTalGroupBox *)widget())->isFlat());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setBoolean(((KviTalGroupBox *)widget())->isFlat());
 	return true;
 }
-bool KviKvsObject_groupbox::functionSetCheckable(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setCheckable)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bFlag",KVS_PT_BOOL,0,bEnabled)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((KviTalGroupBox *)widget())->setCheckable(bEnabled);
+	((KviTalGroupBox *)widget())->setCheckable(bEnabled);
 	return true;
 }
-bool KviKvsObject_groupbox::functionIsCheckable(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,isCheckable)
 {
-	if (widget()) c->returnValue()->setBoolean(((KviTalGroupBox *)widget())->isCheckable());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setBoolean(((KviTalGroupBox *)widget())->isCheckable());
 	return true;
 }
-bool KviKvsObject_groupbox::functionSetChecked(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setChecked)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	bool bEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("bFlag",KVS_PT_BOOL,0,bEnabled)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((KviTalGroupBox *)widget())->setChecked(bEnabled);
+	((KviTalGroupBox *)widget())->setChecked(bEnabled);
 	return true;
 }
-bool KviKvsObject_groupbox::functionIsChecked(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,isChecked)
 {
-	if (widget()) c->returnValue()->setBoolean(((KviTalGroupBox *)widget())->isChecked());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setBoolean(((KviTalGroupBox *)widget())->isChecked());
 	return true;
 }
-bool KviKvsObject_groupbox::functionSetInsideMargin(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setInsideMargin)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t uMargin;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("margin",KVS_PT_UNSIGNEDINTEGER,0,uMargin)
 	KVSO_PARAMETERS_END(c)
-    if (widget()) ((KviTalGroupBox *)widget())->setInsideMargin(uMargin);
+	((KviTalGroupBox *)widget())->setInsideMargin(uMargin);
 	return true;
 }
-bool KviKvsObject_groupbox::functionInsideMargin(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,insideMargin)
 {
-	if (widget()) c->returnValue()->setInteger(((KviTalGroupBox *)widget())->insideMargin());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setInteger(((KviTalGroupBox *)widget())->insideMargin());
 	return true;
 }
-bool KviKvsObject_groupbox::functionSetInsideSpacing(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setInsideSpacing)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t uSpacing;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("spacing",KVS_PT_UNSIGNEDINTEGER,0,uSpacing)
 	KVSO_PARAMETERS_END(c)
-    if (widget()) ((KviTalGroupBox *)widget())->setInsideSpacing(uSpacing);
+    ((KviTalGroupBox *)widget())->setInsideSpacing(uSpacing);
 	return true;
 }
-bool KviKvsObject_groupbox::functionInsideSpacing(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,insideSpacing)
 {
-	if (widget()) c->returnValue()->setInteger(((KviTalGroupBox *)widget())->insideSpacing());
+	CHECK_INTERNAL_QPOINTER(widget())
+	c->returnValue()->setInteger(((KviTalGroupBox *)widget())->insideSpacing());
 	return true;
 }
 
-bool KviKvsObject_groupbox::functionAddSpace(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,addSpace)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	kvs_uint_t iSpace;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("colums",KVS_PT_UNSIGNEDINTEGER,0,iSpace)
 	KVSO_PARAMETERS_END(c)
-	if (widget()) (((KviTalGroupBox *)widget())->addSpace(iSpace));
+	(((KviTalGroupBox *)widget())->addSpace(iSpace));
 	return true;
 }
 
-bool KviKvsObject_groupbox::functionSetAlignment(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setAlignment)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szAlign;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("alignment",KVS_PT_STRING,0,szAlign)
 	KVSO_PARAMETERS_END(c)
-	if (!widget()) return true;
 	for(unsigned int i = 0; i < align_num; i++)
 	{
 		if(KviQString::equalCI(szAlign, align_tbl[i]))
@@ -305,8 +313,9 @@ bool KviKvsObject_groupbox::functionSetAlignment(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_groupbox::functionAlignment(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,alignment)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	int mode = ((KviTalGroupBox *)widget())->alignment();
 	QString szAlignment="";
 	for(unsigned int i = 0; i < align_num; i++)
@@ -321,13 +330,13 @@ bool KviKvsObject_groupbox::functionAlignment(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_groupbox::functionSetOrientation(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(groupbox,setOrientation)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szMode;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("orientation",KVS_PT_STRING,0,szMode)
 	KVSO_PARAMETERS_END(c)
-	if(!widget())return true;
 	if(KviQString::equalCI(szMode, "Horizontal"))
 		((KviTalGroupBox *)widget())->setOrientation(Qt::Vertical);
 	else
diff --git a/src/modules/objects/class_groupbox.h b/src/modules/objects/class_groupbox.h
index ed1d6d23f..f76d45c17 100644
--- a/src/modules/objects/class_groupbox.h
+++ b/src/modules/objects/class_groupbox.h
@@ -41,22 +41,22 @@ protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
 	
-	bool functionSetTitle(KviKvsObjectFunctionCall *c);
-	bool functionTitle(KviKvsObjectFunctionCall *c);
-	bool functionSetFlat(KviKvsObjectFunctionCall *c);
-	bool functionIsFlat(KviKvsObjectFunctionCall *c);
-	bool functionSetCheckable(KviKvsObjectFunctionCall *c);
-	bool functionIsCheckable(KviKvsObjectFunctionCall *c);
-	bool functionSetInsideMargin(KviKvsObjectFunctionCall *c);
-	bool functionInsideMargin(KviKvsObjectFunctionCall *c);
-	bool functionSetInsideSpacing(KviKvsObjectFunctionCall *c);
-	bool functionInsideSpacing(KviKvsObjectFunctionCall *c);
-	bool functionAddSpace(KviKvsObjectFunctionCall *c);
-	bool functionAlignment(KviKvsObjectFunctionCall *c);
-	bool functionSetAlignment(KviKvsObjectFunctionCall *c);
-	bool functionSetOrientation(KviKvsObjectFunctionCall *c);
-	bool functionIsChecked(KviKvsObjectFunctionCall *c);
-	bool functionSetChecked(KviKvsObjectFunctionCall *c);
+	bool setTitle(KviKvsObjectFunctionCall *c);
+	bool title(KviKvsObjectFunctionCall *c);
+	bool setFlat(KviKvsObjectFunctionCall *c);
+	bool isFlat(KviKvsObjectFunctionCall *c);
+	bool setCheckable(KviKvsObjectFunctionCall *c);
+	bool isCheckable(KviKvsObjectFunctionCall *c);
+	bool setInsideMargin(KviKvsObjectFunctionCall *c);
+	bool insideMargin(KviKvsObjectFunctionCall *c);
+	bool setInsideSpacing(KviKvsObjectFunctionCall *c);
+	bool insideSpacing(KviKvsObjectFunctionCall *c);
+	bool addSpace(KviKvsObjectFunctionCall *c);
+	bool alignment(KviKvsObjectFunctionCall *c);
+	bool setAlignment(KviKvsObjectFunctionCall *c);
+	bool setOrientation(KviKvsObjectFunctionCall *c);
+	bool isChecked(KviKvsObjectFunctionCall *c);
+	bool setChecked(KviKvsObjectFunctionCall *c);
 
 };
 #endif //!_CLASS_GROUPBOX_H_
diff --git a/src/modules/objects/class_hbox.cpp b/src/modules/objects/class_hbox.cpp
index 0bfc52e51..340cfa8f7 100644
--- a/src/modules/objects/class_hbox.cpp
+++ b/src/modules/objects/class_hbox.cpp
@@ -84,11 +84,11 @@ const int align_cod[] = {
 
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_hbox,"hbox","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setMargin", functionsetMargin)
-	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setSpacing", functionsetSpacing)
-	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setStretchFactor", functionsetStretchFactor )
-	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"addStretch", functionaddStretch )
-	KVSO_REGISTER_HANDLER(KviKvsObject_hbox,"setAlignment", functionsetAlignment )
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_hbox,setMargin)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_hbox,setSpacing)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_hbox,setStretchFactor )
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_hbox,addStretch )
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_hbox,setAlignment )
 KVSO_END_REGISTERCLASS(KviKvsObject_hbox)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_hbox,KviKvsObject_widget)
@@ -107,7 +107,7 @@ bool KviKvsObject_hbox::init(KviKvsRunTimeContext * pContext,KviKvsVariantList *
 	return true;
 }
 
-bool KviKvsObject_hbox::functionsetMargin(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(hbox,setMargin)
 {
 	kvs_uint_t uMargin;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -117,7 +117,7 @@ bool KviKvsObject_hbox::functionsetMargin(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_hbox::functionsetSpacing(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(hbox,setSpacing)
 {
 	kvs_uint_t uSpacing;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -127,7 +127,7 @@ bool KviKvsObject_hbox::functionsetSpacing(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_hbox::functionsetStretchFactor(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(hbox,setStretchFactor)
 {
 	KviKvsObject * pObject;
 	kvs_hobject_t hObject;
@@ -161,7 +161,7 @@ bool KviKvsObject_hbox::functionsetStretchFactor(KviKvsObjectFunctionCall *c)
 	((KviTalHBox *)widget())->setStretchFactor(((QWidget *)(pObject->object())),uStretch);
 	return true;
 }
-bool KviKvsObject_hbox::functionaddStretch(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(hbox,addStretch)
 {
 	kvs_int_t iStretch;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -170,7 +170,7 @@ bool KviKvsObject_hbox::functionaddStretch(KviKvsObjectFunctionCall *c)
 	if (widget()) ((KviTalHBox *)widget())->addStretch(iStretch);
 	return true;
 }
-bool KviKvsObject_hbox::functionsetAlignment(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(hbox,setAlignment)
 {
 	QStringList alignment;
 	KviKvsObject * pObject;
diff --git a/src/modules/objects/class_hbox.h b/src/modules/objects/class_hbox.h
index 5cf06ac37..ce2993b63 100644
--- a/src/modules/objects/class_hbox.h
+++ b/src/modules/objects/class_hbox.h
@@ -36,11 +36,11 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functionsetMargin(KviKvsObjectFunctionCall *c);
-	bool functionsetSpacing(KviKvsObjectFunctionCall *c);
-	bool functionsetStretchFactor(KviKvsObjectFunctionCall *c);
-	bool functionaddStretch(KviKvsObjectFunctionCall *c);
-	bool functionsetAlignment(KviKvsObjectFunctionCall *c);
+	bool setMargin(KviKvsObjectFunctionCall *c);
+	bool setSpacing(KviKvsObjectFunctionCall *c);
+	bool setStretchFactor(KviKvsObjectFunctionCall *c);
+	bool addStretch(KviKvsObjectFunctionCall *c);
+	bool setAlignment(KviKvsObjectFunctionCall *c);
 
 
 };
diff --git a/src/modules/objects/class_label.cpp b/src/modules/objects/class_label.cpp
index 800ac6acf..74332236e 100644
--- a/src/modules/objects/class_label.cpp
+++ b/src/modules/objects/class_label.cpp
@@ -186,18 +186,16 @@ const int frame_cod[] = {
 
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_label,"label","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"setText",functionSetText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"text", functionText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"margin", functionMargin)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"setMargin", functionSetMargin)
-//	KVSO_REGISTER_HANDLER(KviKvsObject_label,"autoResize", functionAutoResize)
-//	KVSO_REGISTER_HANDLER(KviKvsObject_label,"setAutoResize", functionSetAutoResize)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"alignment", functionAlignment)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"setAlignment", functionSetAlignment)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"clear", functionClear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"frameStyle", functionFrameStyle)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"setFrameStyle", functionSetFrameStyle)
-	KVSO_REGISTER_HANDLER(KviKvsObject_label,"setImage", functionSetImage)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,setText)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,text)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,margin)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,setMargin)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,alignment)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,setAlignment)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,clear)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,frameStyle)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,setFrameStyle)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_label,setImage)
 KVSO_END_REGISTERCLASS(KviKvsObject_label)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_label,KviKvsObject_widget)
@@ -215,7 +213,7 @@ bool KviKvsObject_label::init(KviKvsRunTimeContext * pContext,KviKvsVariantList
 	return true;
 }
 
-bool KviKvsObject_label::functionSetText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,setText)
 {
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -225,13 +223,13 @@ bool KviKvsObject_label::functionSetText(KviKvsObjectFunctionCall *c)
 		((QLabel *)widget())->setText(szText);
 	return true;
 }
-bool KviKvsObject_label::functionText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,text)
 {
 	if (widget()) c->returnValue()->setString(((QLabel *)widget())->text());
 	return true;
 }
 
-bool KviKvsObject_label::functionSetMargin(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,setMargin)
 {
 	kvs_uint_t iMargin;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -240,7 +238,7 @@ bool KviKvsObject_label::functionSetMargin(KviKvsObjectFunctionCall *c)
     if (widget()) ((QLabel *)widget())->setMargin(iMargin);
 	return true;
 }
-bool KviKvsObject_label::functionMargin(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,margin)
 {
 	if (widget()) c->returnValue()->setInteger(((QLabel *)widget())->margin());
 	return true;
@@ -265,7 +263,7 @@ bool KviKvsObject_label::functionAutoResize(KviKvsObjectFunctionCall *c)
 }
 */
 
-bool KviKvsObject_label::functionSetAlignment(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,setAlignment)
 {
 	QStringList alignment;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -294,7 +292,7 @@ bool KviKvsObject_label::functionSetAlignment(KviKvsObjectFunctionCall *c)
 	((QLabel *)widget())->setAlignment((Qt::Alignment)sum);
 	return true;
 }
-bool KviKvsObject_label::functionAlignment(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,alignment)
 {
 	int mode = ((QLabel *)widget())->alignment();
 	QString szAlignment="";
@@ -309,7 +307,7 @@ bool KviKvsObject_label::functionAlignment(KviKvsObjectFunctionCall *c)
 	c->returnValue()->setString(szAlignment);
 	return true;
 }
-bool KviKvsObject_label::functionClear(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,clear)
 {
 	if(widget())
 		((QLabel *)widget())->clear();
@@ -317,7 +315,7 @@ bool KviKvsObject_label::functionClear(KviKvsObjectFunctionCall *c)
 }
 
 
-bool KviKvsObject_label::functionSetFrameStyle(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,setFrameStyle)
 {
 
 	QStringList style;
@@ -350,7 +348,7 @@ bool KviKvsObject_label::functionSetFrameStyle(KviKvsObjectFunctionCall *c)
 
 
 }
-bool KviKvsObject_label::functionFrameStyle(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,frameStyle)
 {
 	int mode = ((QLabel *)widget())->frameStyle();
 	QString szStyle="";
@@ -365,7 +363,7 @@ bool KviKvsObject_label::functionFrameStyle(KviKvsObjectFunctionCall *c)
 	c->returnValue()->setString(szStyle);
 	return true;
 }
-bool KviKvsObject_label::functionSetImage(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(label,setImage)
 {
 	
 	QString icon;
diff --git a/src/modules/objects/class_label.h b/src/modules/objects/class_label.h
index 5920bf803..a64c7a85f 100644
--- a/src/modules/objects/class_label.h
+++ b/src/modules/objects/class_label.h
@@ -38,16 +38,16 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functionSetTitle(KviKvsObjectFunctionCall *c);
-	bool functionSetText(KviKvsObjectFunctionCall *c);
-	bool functionText(KviKvsObjectFunctionCall *c);
-	bool functionMargin(KviKvsObjectFunctionCall *c);
-	bool functionSetMargin(KviKvsObjectFunctionCall *c);
-	bool functionAlignment(KviKvsObjectFunctionCall *c);
-	bool functionSetAlignment(KviKvsObjectFunctionCall *c);
-	bool functionClear(KviKvsObjectFunctionCall *c);
-	bool functionFrameStyle(KviKvsObjectFunctionCall *c);
-	bool functionSetFrameStyle(KviKvsObjectFunctionCall *c);
-	bool functionSetImage(KviKvsObjectFunctionCall *c);
+	bool setTitle(KviKvsObjectFunctionCall *c);
+	bool setText(KviKvsObjectFunctionCall *c);
+	bool text(KviKvsObjectFunctionCall *c);
+	bool margin(KviKvsObjectFunctionCall *c);
+	bool setMargin(KviKvsObjectFunctionCall *c);
+	bool alignment(KviKvsObjectFunctionCall *c);
+	bool setAlignment(KviKvsObjectFunctionCall *c);
+	bool clear(KviKvsObjectFunctionCall *c);
+	bool frameStyle(KviKvsObjectFunctionCall *c);
+	bool setFrameStyle(KviKvsObjectFunctionCall *c);
+	bool setImage(KviKvsObjectFunctionCall *c);
 };
 #endif	// !_CLASS_LABEL_H_
diff --git a/src/modules/objects/class_layout.cpp b/src/modules/objects/class_layout.cpp
index 6e9942948..8989c5882 100644
--- a/src/modules/objects/class_layout.cpp
+++ b/src/modules/objects/class_layout.cpp
@@ -28,10 +28,7 @@
 #include "class_layout.h"
 
 #include <QGridLayout>
-#define QLAYOUT_AUTO_CONSTRAINT QLayout::SetDefaultConstraint
-#define QLAYOUT_FIXED QLayout::SetFixedSize
-#define QLAYOUT_FREE_RESIZE QLayout::SetNoConstraint
-#define QLAYOUT_MINIMUM QLayout::SetMinimumSize
+
 
 
 // Tables used in $setAlignment & $alignment
@@ -111,16 +108,16 @@ const int align_cod[] = {
 
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_layout,"layout","object")
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"addWidget", functionAddWidget)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"addMultiCellWidget", functionAddMultiCellWidget)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setRowStretch", functionSetRowStretch)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setColumnStretch", functionSetColumnStretch)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"addRowSpacing", functionAddRowSpacing)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"addColSpacing", functionAddColSpacing)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setMargin", functionSetMargin)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setSpacing", functionSetSpacing)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setResizeMode", functionSetResizeMode)
-	KVSO_REGISTER_HANDLER(KviKvsObject_layout,"setAlignment", functionsetAlignment )
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,addWidget)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,addMultiCellWidget)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,setRowStretch)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,setColumnStretch)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,addRowSpacing)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,addColSpacing)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,setMargin)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,setSpacing)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,setResizeMode)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_layout,setAlignment )
 KVSO_END_REGISTERCLASS(KviKvsObject_layout)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_layout,KviKvsObject)
@@ -146,7 +143,7 @@ bool KviKvsObject_layout::init(KviKvsRunTimeContext * pContext,KviKvsVariantList
 	return true;
 }
 
-bool KviKvsObject_layout::functionAddWidget(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,addWidget)
 {
 	KviKvsObject * pObject;
 	kvs_hobject_t hObject;
@@ -177,7 +174,7 @@ bool KviKvsObject_layout::functionAddWidget(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionAddMultiCellWidget(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,addMultiCellWidget)
 {
 	KviKvsObject * pObject;
 	kvs_hobject_t hObject;
@@ -211,7 +208,7 @@ bool KviKvsObject_layout::functionAddMultiCellWidget(KviKvsObjectFunctionCall *c
 	return true;
 }
 
-bool KviKvsObject_layout::functionSetRowStretch(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,setRowStretch)
 {
 	kvs_uint_t uRow,uStretch;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -223,7 +220,7 @@ bool KviKvsObject_layout::functionSetRowStretch(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionSetColumnStretch(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,setColumnStretch)
 {
 	kvs_uint_t uCol,uStretch;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -235,7 +232,7 @@ bool KviKvsObject_layout::functionSetColumnStretch(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionSetMargin(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,setMargin)
 {
 	kvs_uint_t uMargin;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -245,7 +242,7 @@ bool KviKvsObject_layout::functionSetMargin(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionSetSpacing(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,setSpacing)
 {
 	kvs_uint_t uSpacing;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -255,7 +252,7 @@ bool KviKvsObject_layout::functionSetSpacing(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionAddRowSpacing(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,addRowSpacing)
 {
 	kvs_uint_t uSpacing,uRow;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -267,7 +264,7 @@ bool KviKvsObject_layout::functionAddRowSpacing(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionAddColSpacing(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,addColSpacing)
 {
 	kvs_uint_t uSpacing,uCol;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -278,24 +275,24 @@ bool KviKvsObject_layout::functionAddColSpacing(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_layout::functionSetResizeMode(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,setResizeMode)
 {
 	QString szMode;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("resize_mode",KVS_PT_STRING,0,szMode)
 	KVSO_PARAMETERS_END(c)
 	if(!widget())return true;
-	QLayout::SizeConstraint r = QLAYOUT_AUTO_CONSTRAINT;
-	if(KviQString::equalCI(szMode,"FreeResize")) r = QLAYOUT_FREE_RESIZE;
-	else if(KviQString::equalCI(szMode,"Minimum")) r = QLAYOUT_MINIMUM;
-	else if(KviQString::equalCI(szMode,"Fixed"))r = QLAYOUT_FIXED;
+	QLayout::SizeConstraint r = QLayout::SetDefaultConstraint;
+	if(KviQString::equalCI(szMode,"FreeResize")) r = QLayout::SetNoConstraint;
+	else if(KviQString::equalCI(szMode,"Minimum")) r = QLayout::SetMinimumSize;
+	else if(KviQString::equalCI(szMode,"Fixed"))r = QLayout::SetFixedSize;
 	else c->warning(__tr2qs("Invalid resize mode defaulting to Auto"));
 	((QGridLayout *)object())->setSizeConstraint(r);
 	return true;
 
 }
 
-bool KviKvsObject_layout::functionsetAlignment(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(layout,setAlignment)
 {
 	QStringList alignment;
 	KviKvsObject * pObject;
diff --git a/src/modules/objects/class_layout.h b/src/modules/objects/class_layout.h
index 7b25938f0..54bcbe2de 100644
--- a/src/modules/objects/class_layout.h
+++ b/src/modules/objects/class_layout.h
@@ -35,16 +35,16 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functionAddWidget(KviKvsObjectFunctionCall *c);
-	bool functionAddMultiCellWidget(KviKvsObjectFunctionCall *c);
-	bool functionSetRowStretch(KviKvsObjectFunctionCall *c);
-	bool functionSetColumnStretch(KviKvsObjectFunctionCall *c);
-	bool functionSetMargin(KviKvsObjectFunctionCall *c);
-	bool functionSetSpacing(KviKvsObjectFunctionCall *c);
-	bool functionAddRowSpacing(KviKvsObjectFunctionCall *c);
-	bool functionAddColSpacing(KviKvsObjectFunctionCall *c);
-	bool functionSetResizeMode(KviKvsObjectFunctionCall *c);
-	bool functionsetAlignment(KviKvsObjectFunctionCall *c);
+	bool addWidget(KviKvsObjectFunctionCall *c);
+	bool addMultiCellWidget(KviKvsObjectFunctionCall *c);
+	bool setRowStretch(KviKvsObjectFunctionCall *c);
+	bool setColumnStretch(KviKvsObjectFunctionCall *c);
+	bool setMargin(KviKvsObjectFunctionCall *c);
+	bool setSpacing(KviKvsObjectFunctionCall *c);
+	bool addRowSpacing(KviKvsObjectFunctionCall *c);
+	bool addColSpacing(KviKvsObjectFunctionCall *c);
+	bool setResizeMode(KviKvsObjectFunctionCall *c);
+	bool setAlignment(KviKvsObjectFunctionCall *c);
 
 
 };
diff --git a/src/modules/objects/class_lcd.cpp b/src/modules/objects/class_lcd.cpp
index 88231beb3..2ee34b6f0 100644
--- a/src/modules/objects/class_lcd.cpp
+++ b/src/modules/objects/class_lcd.cpp
@@ -70,14 +70,14 @@
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_lcd,"lcdnumber","widget")
 	
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setDisplayStr", functiondisplayStr)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setDisplayInt", functiondisplayInt)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setDisplayDouble", functiondisplayDouble)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setMode", functionsetMode)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setSegmentStyle", functionsetSegmentStyle)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setNumDigits", functionsetNumDigits)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"setSmallDecimalPoint",functionsetSmallDecimalPoint)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lcd,"checkOverflow", functioncheckOverflow)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,displayStr)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,displayInt)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,displayDouble)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,setMode)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,setSegmentStyle)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,setNumDigits)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,setSmallDecimalPoint)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lcd,checkOverflow)
 KVSO_END_REGISTERCLASS(KviKvsObject_lcd)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_lcd,KviKvsObject_widget)
@@ -94,8 +94,7 @@ bool KviKvsObject_lcd::init(KviKvsRunTimeContext * pContext,KviKvsVariantList *p
 	SET_OBJECT(QLCDNumber)
 	return true;
 }
-
-bool KviKvsObject_lcd::functiondisplayInt(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,displayInt)
 {
 	kvs_int_t iDigit;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -105,7 +104,7 @@ bool KviKvsObject_lcd::functiondisplayInt(KviKvsObjectFunctionCall *c)
     return true;
 }
 
-bool KviKvsObject_lcd::functiondisplayStr(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,displayStr)
 {
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -115,7 +114,7 @@ bool KviKvsObject_lcd::functiondisplayStr(KviKvsObjectFunctionCall *c)
     return true;
 }
 
-bool KviKvsObject_lcd::functiondisplayDouble(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,displayDouble)
 {
 	kvs_real_t dDigit;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -124,7 +123,7 @@ bool KviKvsObject_lcd::functiondisplayDouble(KviKvsObjectFunctionCall *c)
     if(widget()) ((QLCDNumber *)widget())->display(dDigit);
     return true;
 }
-bool KviKvsObject_lcd::functionsetMode(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,setMode)
 {
 	QString szMode;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -138,7 +137,7 @@ bool KviKvsObject_lcd::functionsetMode(KviKvsObjectFunctionCall *c)
 	else c->warning( __tr2qs("Unknown mode "));
 	return true;
 }
-bool KviKvsObject_lcd::functionsetSegmentStyle(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,setSegmentStyle)
 {
 	QString szStyle;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -151,7 +150,7 @@ bool KviKvsObject_lcd::functionsetSegmentStyle(KviKvsObjectFunctionCall *c)
 	else c->warning( __tr2qs("Unknown segment style "));
 	return true;
 }
-bool KviKvsObject_lcd::functionsetNumDigits(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,setNumDigits)
 {
 	kvs_real_t digit;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -160,7 +159,7 @@ bool KviKvsObject_lcd::functionsetNumDigits(KviKvsObjectFunctionCall *c)
     if(widget()) ((QLCDNumber *)widget())->setNumDigits(digit);
     return true;
 }
-bool KviKvsObject_lcd::functionsetSmallDecimalPoint(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,setSmallDecimalPoint)
 {
 	bool bFlag;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -169,7 +168,7 @@ bool KviKvsObject_lcd::functionsetSmallDecimalPoint(KviKvsObjectFunctionCall *c)
     if(widget()) ((QLCDNumber *)widget())->setSmallDecimalPoint(bFlag);
 	return true;
 }
-bool KviKvsObject_lcd::functioncheckOverflow(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lcd,checkOverflow)
 {
 	kvs_real_t iDigit;
 	KVSO_PARAMETERS_BEGIN(c)
diff --git a/src/modules/objects/class_lcd.h b/src/modules/objects/class_lcd.h
index 387f42116..a0b8de1af 100644
--- a/src/modules/objects/class_lcd.h
+++ b/src/modules/objects/class_lcd.h
@@ -39,14 +39,14 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functiondisplayStr(KviKvsObjectFunctionCall *c);
-    bool functionsetMode(KviKvsObjectFunctionCall *c);
-    bool functionsetSegmentStyle(KviKvsObjectFunctionCall *c);
-    bool functionsetNumDigits(KviKvsObjectFunctionCall *c);
-    bool functionsetSmallDecimalPoint(KviKvsObjectFunctionCall *c);
-    bool functioncheckOverflow(KviKvsObjectFunctionCall *c);
-    bool functiondisplayInt(KviKvsObjectFunctionCall *c);
-    bool functiondisplayDouble(KviKvsObjectFunctionCall *c);
+	bool displayStr(KviKvsObjectFunctionCall *c);
+    bool setMode(KviKvsObjectFunctionCall *c);
+    bool setSegmentStyle(KviKvsObjectFunctionCall *c);
+    bool setNumDigits(KviKvsObjectFunctionCall *c);
+    bool setSmallDecimalPoint(KviKvsObjectFunctionCall *c);
+    bool checkOverflow(KviKvsObjectFunctionCall *c);
+    bool displayInt(KviKvsObjectFunctionCall *c);
+    bool displayDouble(KviKvsObjectFunctionCall *c);
 };
 
 #endif        // !_CLASS_LCD_H_
diff --git a/src/modules/objects/class_lineedit.cpp b/src/modules/objects/class_lineedit.cpp
index 22aeef20a..30f96d5b6 100644
--- a/src/modules/objects/class_lineedit.cpp
+++ b/src/modules/objects/class_lineedit.cpp
@@ -179,33 +179,29 @@ static const int mode_cod[] =  {
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_lineedit,"lineedit","widget")
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"text", functionText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setText", functionSetText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"maxLength", functionMaxLength)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setMaxLength", functionSetMaxLength)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"frame", functionFrame)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setCursorPosition", functionSetCursorPosition)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"cursorPosition", functionCursorPosition)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setFrame", functionSetFrame)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"selectAll" , functionSelectAll)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setSelection", functionSetSelection)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"copy", functionCopy)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"cut", functionCut)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"paste", functionPaste)
-
-
-
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"echoMode", functionEchoMode)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setEchoMode", functionSetEchoMode)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"clear", functionClear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setDragEnabled", functionDragAndDrop)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setInputMask", functionSetInputMask)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setReadOnly", functionSetReadOnly)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"returnPressedEvent", functionreturnPressedEvent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"lostFocusEvent", functionlostFocusEvent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"textChangedEvent", functiontextChangedEvent)
-
-	KVSO_REGISTER_HANDLER(KviKvsObject_lineedit,"setInputValidator", functionsetInputValidator)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,text)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setText)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,maxLength)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setMaxLength)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,frame)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setCursorPosition)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,cursorPosition)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setFrame)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,selectAll)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setSelection)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,copy)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,cut)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,paste)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,echoMode)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setEchoMode)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,clear)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,dragAndDrop)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setInputMask)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setReadOnly)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,returnPressedEvent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,lostFocusEvent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,textChangedEvent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_lineedit,setInputValidator)
 
 
 KVSO_END_REGISTERCLASS(KviKvsObject_lineedit)
@@ -230,14 +226,14 @@ bool KviKvsObject_lineedit::init(KviKvsRunTimeContext * pContext,KviKvsVariantLi
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,text)
 {
 	if(widget())
 		c->returnValue()->setString(((QLineEdit *)widget())->text());
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetText(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setText)
 {
 	QString szText;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -247,7 +243,7 @@ bool KviKvsObject_lineedit::functionSetText(KviKvsObjectFunctionCall *c)
 		((QLineEdit *)widget())->setText(szText);
 	return true;
 }
-bool KviKvsObject_lineedit::functionsetInputValidator(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setInputValidator)
 {
 	QString szReg;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -257,14 +253,14 @@ bool KviKvsObject_lineedit::functionsetInputValidator(KviKvsObjectFunctionCall *
 		((QLineEdit *)widget())->setValidator(new QRegExpValidator(QRegExp(szReg),((QLineEdit *)widget())));
 	return true;
 }
-bool KviKvsObject_lineedit::functionMaxLength(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,maxLength)
 {
 	if(widget())
 		c->returnValue()->setInteger(((QLineEdit *)widget())->maxLength());
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetMaxLength(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setMaxLength)
 {
 	kvs_uint_t iMaxlen;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -275,14 +271,14 @@ bool KviKvsObject_lineedit::functionSetMaxLength(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionFrame(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,frame)
 {
 	if(widget())
 		c->returnValue()->setBoolean(((QLineEdit *)widget())->hasFrame());
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetFrame(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setFrame)
 {
 	bool bFrame;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -293,14 +289,14 @@ bool KviKvsObject_lineedit::functionSetFrame(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionCursorPosition(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,cursorPosition)
 {
 	if(widget())
 		c->returnValue()->setInteger(((QLineEdit *)widget())->cursorPosition());
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetCursorPosition(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setCursorPosition)
 {
 	kvs_uint_t iPos;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -311,14 +307,14 @@ bool KviKvsObject_lineedit::functionSetCursorPosition(KviKvsObjectFunctionCall *
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSelectAll(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,selectAll)
 {
 	if(widget())
 		((QLineEdit *)widget())->selectAll();
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetSelection(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setSelection)
 {
 	kvs_uint_t uStart,uLen;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -330,28 +326,28 @@ bool KviKvsObject_lineedit::functionSetSelection(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionCopy(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,copy)
 {
 	if(widget())
 		((QLineEdit *)widget())->copy();
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionCut(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,cut)
 {
 	if(widget())
 		((QLineEdit *)widget())->cut();
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionPaste(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,paste)
 {
 	if(widget())
 		((QLineEdit *)widget())->paste();
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionEchoMode(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,echoMode)
 {
 	int mode = ((QLineEdit *)widget())->echoMode();
 	QString szEchomode="";
@@ -367,7 +363,7 @@ bool KviKvsObject_lineedit::functionEchoMode(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetEchoMode(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setEchoMode)
 {
 	QString szMode;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -387,7 +383,7 @@ bool KviKvsObject_lineedit::functionSetEchoMode(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionClear(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,clear)
 {
 	if(widget())
 		((QLineEdit *)widget())->clear();
@@ -395,7 +391,7 @@ bool KviKvsObject_lineedit::functionClear(KviKvsObjectFunctionCall *c)
 }
 
 //-| Grifisx & Noldor |-Start:
-bool KviKvsObject_lineedit::functionDragAndDrop(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,dragAndDrop)
 {
 	bool bEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -406,7 +402,7 @@ bool KviKvsObject_lineedit::functionDragAndDrop(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetReadOnly(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setReadOnly)
 {
 	bool bEnabled;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -417,7 +413,7 @@ bool KviKvsObject_lineedit::functionSetReadOnly(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionSetInputMask(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,setInputMask)
 {
 	QString szMask;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -428,7 +424,7 @@ bool KviKvsObject_lineedit::functionSetInputMask(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_lineedit::functionreturnPressedEvent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,returnPressedEvent)
 {
 
 	emitSignal("returnPressed",c);
@@ -443,7 +439,7 @@ void KviKvsObject_lineedit::slotreturnPressed()
 
 }
 // FIND ME
-bool KviKvsObject_lineedit::functionlostFocusEvent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,lostFocusEvent)
 {
 
 
@@ -458,7 +454,7 @@ void KviKvsObject_lineedit::slotlostFocus()
 	callFunction(this,"lostFocusEvent",params);
 }
 /////
-bool KviKvsObject_lineedit::functiontextChangedEvent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(lineedit,textChangedEvent)
 {
 	emitSignal("textChanged",c,c->params());
 	return true;
diff --git a/src/modules/objects/class_lineedit.h b/src/modules/objects/class_lineedit.h
index 695f26f1b..ab19251f0 100644
--- a/src/modules/objects/class_lineedit.h
+++ b/src/modules/objects/class_lineedit.h
@@ -45,35 +45,35 @@ protected:
 
 	
 
-	bool functionText(KviKvsObjectFunctionCall *c);
-	bool functionSetText(KviKvsObjectFunctionCall *c);
-	bool functionMaxLength(KviKvsObjectFunctionCall *c);
-	bool functionSetMaxLength(KviKvsObjectFunctionCall *c);
-	bool functionFrame(KviKvsObjectFunctionCall *c);
-	bool functionSetCursorPosition(KviKvsObjectFunctionCall *c);
-	bool functionCursorPosition(KviKvsObjectFunctionCall *c);
-	bool functionSetFrame(KviKvsObjectFunctionCall *c);
-	bool functionSelectAll(KviKvsObjectFunctionCall *c);
-	bool functionSetSelection(KviKvsObjectFunctionCall *c);
-	bool functionCopy(KviKvsObjectFunctionCall *c);
-	bool functionCut(KviKvsObjectFunctionCall *c);
+	bool text(KviKvsObjectFunctionCall *c);
+	bool setText(KviKvsObjectFunctionCall *c);
+	bool maxLength(KviKvsObjectFunctionCall *c);
+	bool setMaxLength(KviKvsObjectFunctionCall *c);
+	bool frame(KviKvsObjectFunctionCall *c);
+	bool setCursorPosition(KviKvsObjectFunctionCall *c);
+	bool cursorPosition(KviKvsObjectFunctionCall *c);
+	bool setFrame(KviKvsObjectFunctionCall *c);
+	bool selectAll(KviKvsObjectFunctionCall *c);
+	bool setSelection(KviKvsObjectFunctionCall *c);
+	bool copy(KviKvsObjectFunctionCall *c);
+	bool cut(KviKvsObjectFunctionCall *c);
 
-	bool functionPaste(KviKvsObjectFunctionCall *c);
-	bool functionEchoMode(KviKvsObjectFunctionCall *c);
-	bool functionSetEchoMode(KviKvsObjectFunctionCall *c);
-	bool functionClear(KviKvsObjectFunctionCall *c);
-	bool functionDragAndDrop(KviKvsObjectFunctionCall *c);
-	bool functionSetInputMask(KviKvsObjectFunctionCall *c);
-	bool functionSetReadOnly(KviKvsObjectFunctionCall *c);
+	bool paste(KviKvsObjectFunctionCall *c);
+	bool echoMode(KviKvsObjectFunctionCall *c);
+	bool setEchoMode(KviKvsObjectFunctionCall *c);
+	bool clear(KviKvsObjectFunctionCall *c);
+	bool dragAndDrop(KviKvsObjectFunctionCall *c);
+	bool setInputMask(KviKvsObjectFunctionCall *c);
+	bool setReadOnly(KviKvsObjectFunctionCall *c);
 
-	bool functionreturnPressedEvent(KviKvsObjectFunctionCall *c);
+	bool returnPressedEvent(KviKvsObjectFunctionCall *c);
 
-	bool functionlostFocusEvent(KviKvsObjectFunctionCall *c);
+	bool lostFocusEvent(KviKvsObjectFunctionCall *c);
 
-	bool functiontextChangedEvent(KviKvsObjectFunctionCall *c);
+	bool textChangedEvent(KviKvsObjectFunctionCall *c);
 
 
-	bool functionsetInputValidator(KviKvsObjectFunctionCall *c);
+	bool setInputValidator(KviKvsObjectFunctionCall *c);
 protected slots:
 	void slotreturnPressed();
 	void slotlostFocus();
diff --git a/src/modules/objects/class_list.cpp b/src/modules/objects/class_list.cpp
index 3b2a0608c..935250cf3 100644
--- a/src/modules/objects/class_list.cpp
+++ b/src/modules/objects/class_list.cpp
@@ -137,27 +137,27 @@
 
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_list,"list","object")
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"count",function_count)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"isEmpty",function_isEmpty)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"clear",function_clear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"removeAll",function_clear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"append",function_append)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"prepend",function_prepend)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"insert",function_insert)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"add",function_insert)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"at",function_at)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"item",function_at)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"remove",function_remove)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"removeFirst",function_removeFirst)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"removeLast",function_removeLast)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"removeCurrent",function_removeCurrent)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"moveFirst",function_moveFirst)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"moveNext",function_moveNext)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"movePrev",function_movePrev)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"moveLast",function_moveLast)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"sort",function_sort)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"eof",function_eof)
-	KVSO_REGISTER_HANDLER(KviKvsObject_list,"current",function_current)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,count)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,isEmpty)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,clear)
+	KVSO_REGISTER_HANDLER(KviKvsObject_list,"removeAll",clear)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,append)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,prepend)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,insert)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,insert)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,at)
+	KVSO_REGISTER_HANDLER(KviKvsObject_list,"item",at)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,remove)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,removeFirst)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,removeLast)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,removeCurrent)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,moveFirst)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,moveNext)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,movePrev)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,moveLast)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,sort)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,eof)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_list,current)
 KVSO_END_REGISTERCLASS(KviKvsObject_list)
 
 
@@ -172,9 +172,10 @@ KVSO_BEGIN_DESTRUCTOR(KviKvsObject_list)
 	m_pDataList = 0;
 KVSO_END_CONSTRUCTOR(KviKvsObject_list)
 
-bool KviKvsObject_list::function_current(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,current)
 {
-	if(!m_pDataList|!m_pDataList->count())
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
+	if(!m_pDataList->count())
 	{
 		c->returnValue()->setNothing();
 		return true;
@@ -185,79 +186,51 @@ bool KviKvsObject_list::function_current(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_list::function_eof(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,eof)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(true);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->current() != 0);
 	return true;
 }
 
-bool KviKvsObject_list::function_moveLast(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,moveLast)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->last() != 0);
 	return true;
 }
 
-bool KviKvsObject_list::function_movePrev(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,movePrev)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->prev() != 0);
 	return true;
 }
 
-bool KviKvsObject_list::function_moveNext(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,moveNext)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->next() != 0);
 	return true;
 }
 
-bool KviKvsObject_list::function_moveFirst(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,moveFirst)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->first() != 0);
 	return true;
 }
 
-bool KviKvsObject_list::function_removeLast(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,removeLast)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->removeLast());
 	return true;
 }
 
-bool KviKvsObject_list::function_removeCurrent(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,removeCurrent)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	if(m_pDataList->current())
 	{
 		m_pDataList->removeCurrent();
@@ -268,89 +241,76 @@ bool KviKvsObject_list::function_removeCurrent(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_list::function_removeFirst(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,removeFirst)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->removeFirst());
 	return true;
 }
 
-bool KviKvsObject_list::function_remove(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,remove)
 {
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	kvs_uint_t uIndex;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UINT,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(false);
-		return true;
-	}
 	c->returnValue()->setBoolean(m_pDataList->remove(uIndex));
 	return true;
 }
 
-bool KviKvsObject_list::function_at(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,at)
 {
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	kvs_uint_t uIndex;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UINT,0,uIndex)
 	KVSO_PARAMETERS_END(c)
-	if(!m_pDataList)
-	{
-		c->returnValue()->setNothing();
-		return true;
-	}
 	KviKvsVariant * v = m_pDataList->at(uIndex);
 	if(v)c->returnValue()->copyFrom(*v);
 	else c->returnValue()->setNothing();
 	return true;
 }
 
-bool KviKvsObject_list::function_insert(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,insert)
 {
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	kvs_uint_t uIndex;
 	KviKvsVariant * pVar;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("index",KVS_PT_UINT,0,uIndex)
 		KVSO_PARAMETER("item",KVS_PT_VARIANT,0,pVar)
 	KVSO_PARAMETERS_END(c)
-	if(!m_pDataList)return true;
 	m_pDataList->insert(uIndex,new KviKvsVariant(*pVar));
 	return true;
 }
 
-bool KviKvsObject_list::function_prepend(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,prepend)
 {
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	KviKvsVariant * pVar;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("item",KVS_PT_VARIANT,0,pVar)
 	KVSO_PARAMETERS_END(c)
-	if(!m_pDataList)return true;
 	m_pDataList->prepend(new KviKvsVariant(*pVar));
 	return true;
 }
 
-bool KviKvsObject_list::function_append(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,append)
 {
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	KviKvsVariant * pVar;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("item",KVS_PT_VARIANT,0,pVar)
 	KVSO_PARAMETERS_END(c)
-	if(!m_pDataList)return true;
 	m_pDataList->append(new KviKvsVariant(*pVar));
 	if (m_pDataList->count()==1) m_pDataList->first();
-
 	return true;
 }
 
-bool KviKvsObject_list::function_clear(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,clear)
 {
-	if(!m_pDataList)return true;
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	m_pDataList->clear();
 	return true;
 }
@@ -360,31 +320,23 @@ inline int kvi_compare(const KviKvsVariant * p1,const KviKvsVariant * p2)
 	return p1->compare(p2);
 }
 
-bool KviKvsObject_list::function_sort(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,sort)
 {
-	if(!m_pDataList)return true;
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	m_pDataList->sort();
 	return true;
 }
 
-bool KviKvsObject_list::function_isEmpty(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,isEmpty)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setBoolean(true);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setBoolean(m_pDataList->isEmpty());
 	return true;
 }
 
-bool KviKvsObject_list::function_count(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(list,count)
 {
-	if(!m_pDataList)
-	{
-		c->returnValue()->setInteger(0);
-		return true;
-	}
+	CHECK_INTERNAL_QPOINTER(m_pDataList)
 	c->returnValue()->setInteger(m_pDataList->count());
 	return true;
 }
diff --git a/src/modules/objects/class_list.h b/src/modules/objects/class_list.h
index 3e7377b89..36bac829c 100644
--- a/src/modules/objects/class_list.h
+++ b/src/modules/objects/class_list.h
@@ -40,24 +40,24 @@ protected:
 protected:
 	KviPointerList<KviKvsVariant> * dataList() const { return m_pDataList; };
 public:
-	bool function_count(KviKvsObjectFunctionCall *c);
-	bool function_isEmpty(KviKvsObjectFunctionCall *c);
-	bool function_clear(KviKvsObjectFunctionCall *c);
-	bool function_append(KviKvsObjectFunctionCall *c);
-	bool function_prepend(KviKvsObjectFunctionCall *c);
-	bool function_insert(KviKvsObjectFunctionCall *c);
-	bool function_at(KviKvsObjectFunctionCall *c);
-	bool function_remove(KviKvsObjectFunctionCall *c);
-	bool function_removeFirst(KviKvsObjectFunctionCall *c);
-	bool function_removeLast(KviKvsObjectFunctionCall *c);
-	bool function_removeCurrent(KviKvsObjectFunctionCall *c);
-	bool function_moveFirst(KviKvsObjectFunctionCall *c);
-	bool function_moveNext(KviKvsObjectFunctionCall *c);
-	bool function_movePrev(KviKvsObjectFunctionCall *c);
-	bool function_moveLast(KviKvsObjectFunctionCall *c);
-	bool function_eof(KviKvsObjectFunctionCall *c);
-	bool function_current(KviKvsObjectFunctionCall *c);
-	bool function_sort(KviKvsObjectFunctionCall *c);
+	bool count(KviKvsObjectFunctionCall *c);
+	bool isEmpty(KviKvsObjectFunctionCall *c);
+	bool clear(KviKvsObjectFunctionCall *c);
+	bool append(KviKvsObjectFunctionCall *c);
+	bool prepend(KviKvsObjectFunctionCall *c);
+	bool insert(KviKvsObjectFunctionCall *c);
+	bool at(KviKvsObjectFunctionCall *c);
+	bool remove(KviKvsObjectFunctionCall *c);
+	bool removeFirst(KviKvsObjectFunctionCall *c);
+	bool removeLast(KviKvsObjectFunctionCall *c);
+	bool removeCurrent(KviKvsObjectFunctionCall *c);
+	bool moveFirst(KviKvsObjectFunctionCall *c);
+	bool moveNext(KviKvsObjectFunctionCall *c);
+	bool movePrev(KviKvsObjectFunctionCall *c);
+	bool moveLast(KviKvsObjectFunctionCall *c);
+	bool eof(KviKvsObjectFunctionCall *c);
+	bool current(KviKvsObjectFunctionCall *c);
+	bool sort(KviKvsObjectFunctionCall *c);
 };
 
 
diff --git a/src/modules/objects/class_listbox.cpp b/src/modules/objects/class_listbox.cpp
deleted file mode 100644
index 97e978617..000000000
--- a/src/modules/objects/class_listbox.cpp
+++ /dev/null
@@ -1,432 +0,0 @@
-//=============================================================================
-//
-//   File : class_listbox.cpp
-//   Creation date : Sat Oct 2 03:40:28 CET 2004 by Szymon Stefanek
-//
-//   This file is part of the KVirc irc client distribution
-//   Copyright (C) 2004-2008 Szymon Stefanek (pragma at kvirc dot net)
-//
-//   This program is FREE software. You can redistribute it and/or
-//   modify it under the terms of the GNU General Public License
-//   as published by the Free Software Foundation; either version 2
-//   of the License, or (at your opinion) any later version.
-//
-//   This program is distributed in the HOPE that it will be USEFUL,
-//   but WITHOUT ANY WARRANTY; without even the implied warranty of
-//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-//   See the GNU General Public License for more details.
-//
-//   You should have received a copy of the GNU General Public License
-//   along with this program. If not, write to the Free Software Foundation,
-//   Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-//
-//=============================================================================
-
-#include "kvi_error.h"
-#include "kvi_locale.h"
-#include "kvi_debug.h"
-#include "class_list.h"
-#include "class_listbox.h"
-
-#include <QListWidget>
-/*
-	@doc: listbox
-	@keyterms:
-		listbox object class
-	@title:
-		listbox class
-	@type:
-		class
-	@short:
-		A widget displaying a list of items
-	@inherits:
-		[class]object[/class]
-		[class]widget[/class]
-	@description:
-		The listbox class is a widget displaying a list of string items.[br]
-		The listbox can operate in four selection modes: single, multi, extended
-		and none. In the "single" mode only one item can be selected at a time
-		and that item is also the current one. In the "multi" mode multiple
-		items can be selected and unselected and the current item may or may not
-		be one of the selected items. In the "extended" mode multiple items
-		can be selected but they must be selected in a single mouse action
-		or by keeping the shift button pressed while clicking on the item.
-		In this mode the current item is always one of the selected items.[br]
-		In the "none" mode no items can be selected and the current item
-		may be any item in the list.[br]
-		In most situations you will operate the listbox in "single" mode
-		(and this is the default mode set at widget creation).
-	@functions:
-		!fn: $setSelectionMode(<selection_mode:string>)
-		Sets the current selection mode specified by the parameter <mode>
-		that can be one of the following string:[br]
-		"single" : only one item can be selected at a time[br]
-		"multi" : multiple items can be selected at a time[br]
-		"extended" : multiple items can be selected but only in a single mouse interaction[br]
-		"none" : no items can be selected[br]
-		The default mode is "single"
-		!fn: <string> $selectionMode()
-		Returns the current selection mode
-		!fn: $insertItem(<text:string>, <index:uint>)
-		Inserts a text item at position <index>. If index is negative or
-		not specified the item is appended.
-		!fn: $changeItem(<text:string>, <index:uint>)
-		Changes text of item at <index> to <text>.
-		!fn: $removeItem(<index:iIndex>)
-		Removes item at given index.
-		!fn: $count()
-		Returns number of items in the widget.
-		!fn: <string> $currentText()
-		Returns the text of the currently selected item.
-		!fn: <integer> $currentItem()
-		Returns index of current item or -1 if no item is current.
-		!fn: $textAt(<index:integer>)
-		Returns item at given index.
-		!fn: $setCurrentItem(<index:integer>)
-		Sets the current listbox item.
-		!fn: $clear()
-		Removes all the items
-		!fn: $selectionChangeEvent()
-		This function is called by KVIrc when the selection in the listbox changes.
-		!fn: $currentItemChangeEvent()
-		This function is called by KVIrc when the current item changes.
-		!fn: <index:integer> $onItemEvent()
-		This function is called by KVIrc when the current item pointed by the mouse changes and gives in $0 the item index.
-		!fn: <array:x,y,width,height> $itemRect(<item:index>)
-		Returns the rectangle on the screen that item occupies, or an invalid rectangle if item is 0 or is not currently visible. 
-
-		@signals:
-		!sg: <string> $currentItemChange()
-		This signal is emitted by the default implementation of [classfnc]$currentItemChangeEvent[/classfnc]().[br]
-		!sg: <string> $onItem()
-		This signal is emitted by the default implementation of [classfnc]$onItemEvent[/classfnc]().[br]
-
-		*/
-
-
-KVSO_BEGIN_REGISTERCLASS(KviKvsObject_listbox,"listbox","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"insertItem", functioninsertItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"insertWidgetItem", functioninsertWidgetItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"changeItem", functionchangeItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"removeItem", functionremoveItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"clear", functionclear)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"count", functioncount)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"currentText", functioncurrentText)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"currentItem", functioncurrentItem)
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"textAt", functiontextAt);
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"itemAt", functionitemAt);
-//	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"itemRect", functionitemRect);
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"setCurrentItem", functionsetCurrentItem);
-
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"selectedItems",function_selectedItems)
-
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"setSelectionMode",functionsetSelectionMode);
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"selectionMode",functionselectionMode);
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"currentItemChangeEvent",functioncurrentItemChangeEvent);
-	KVSO_REGISTER_HANDLER(KviKvsObject_listbox,"onItemEvent",functiononItemEvent);
-
-
-	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_listbox,"selectionChangeEvent")
-
-
-KVSO_END_REGISTERCLASS(KviKvsObject_listbox)
-
-KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_listbox,KviKvsObject_widget)
-
-KVSO_END_CONSTRUCTOR(KviKvsObject_listbox)
-
-
-KVSO_BEGIN_DESTRUCTOR(KviKvsObject_listbox)
-
-KVSO_END_CONSTRUCTOR(KviKvsObject_listbox)
-
-bool KviKvsObject_listbox::init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams)
-{
-	//KviTalListBox * b = new KviTalListBox(parentScriptWidget());
-	SET_OBJECT(QListWidget)
-	obj->setSelectionMode(QAbstractItemView::SingleSelection);
-	connect(obj,SIGNAL(itemSelectionChanged()),this,SLOT(selectionChanged()));
-	connect(obj,SIGNAL(currentItemChanged(QListWidgetItem *,QListWidgetItem *)),this,SLOT(currentItemChanged(QListWidgetItem *,QListWidgetItem *)));
-//	connect(obj,SIGNAL(onItem(QListWidgetItem *)),this,SLOT(onItem(QListWidgetItem *)));
-	return true;
-}
-
-bool KviKvsObject_listbox::functioninsertItem(KviKvsObjectFunctionCall *c)
-{
-	if(!widget()) return true;
-	kvs_int_t iRow;
-	QString szText;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
-		KVSO_PARAMETER("index",KVS_PT_INT,KVS_PF_OPTIONAL,iRow)
-	KVSO_PARAMETERS_END(c)
-	if (c->parameterCount()==2) ((QListWidget *)widget())->insertItem(iRow, szText);
-	else ((QListWidget *)widget())->addItem(szText);
-	return true;
-}
-
-bool KviKvsObject_listbox::functionclear(KviKvsObjectFunctionCall *c)
-{
-	if (widget()) ((QListWidget *)widget())->clear();
-	return true;
-}
-
-bool KviKvsObject_listbox::functionchangeItem(KviKvsObjectFunctionCall *c)
-{
-
-	kvs_int_t iIndex,cnt;
-	QString szText;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("text",KVS_PT_STRING,0,szText)
-		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,iIndex)
-	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
-	if (szText.isEmpty()) c->warning(__tr2qs("No string parameter given - using empty string"));
-	if(iIndex >= (cnt = ((QListWidget *)widget())->count()))
-	{
-		c->warning(__tr2qs("Item index [%d] is too big - defaulting to " \
-			"$count() - 1 [%d]"), iIndex, cnt);
-		iIndex = cnt - 1;
-	}
-
-	//((QListWidget *)widget())->removeItem(iIndex);
-	((QListWidget *)widget())->item(iIndex)->setText(szText);
-
-	return true;
-
-}
-
-
-bool KviKvsObject_listbox::functionremoveItem(KviKvsObjectFunctionCall *c)
-{
-
-	kvs_uint_t iIndex,cnt;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,iIndex)
-	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
-	if(iIndex >= (cnt = ((QListWidget *)widget())->count()))
-	{
-		c->warning(__tr2qs("Item index [%d] is too big - defaulting to " \
-			"$count() - 1 [%d]"), iIndex, cnt);
-		iIndex = cnt - 1;
-	}
-
-	delete ((QListWidget *)widget())->takeItem(iIndex);
-
-	return true;
-
-}
-
-bool KviKvsObject_listbox::functioncount(KviKvsObjectFunctionCall *c)
-{
-	if (widget()) c->returnValue()->setInteger(((QListWidget *)widget())->count());
-	return true;
-}
-bool KviKvsObject_listbox::functioncurrentText(KviKvsObjectFunctionCall *c)
-{
-	QString text;
-	QListWidgetItem *item=((QListWidget *)widget())->currentItem();
-	if (item) text=item->text();
-	else text="";
-	if (widget()) c->returnValue()->setString(text);
-	return true;
-}
-bool KviKvsObject_listbox::functioncurrentItem(KviKvsObjectFunctionCall *c)
-{
-	if (widget()) c->returnValue()->setInteger(((QListWidget *)widget())->currentRow());
-	return true;
-}
-
-bool KviKvsObject_listbox::functiontextAt(KviKvsObjectFunctionCall *c)
-{
-
-	kvs_uint_t iIndex;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,iIndex)
-	KVSO_PARAMETERS_END(c)
-	if(widget())
-		c->returnValue()->setString(((QListWidget *)widget())->item(iIndex)->text());
-	return true;
-}
-bool KviKvsObject_listbox::functionsetCurrentItem(KviKvsObjectFunctionCall *c)
-{
-	kvs_uint_t iIndex;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,iIndex)
-	KVSO_PARAMETERS_END(c)
-	if(widget())
-		((QListWidget *)widget())->setCurrentRow(iIndex);
-	return true;
-}
-bool KviKvsObject_listbox::functionsetSelectionMode(KviKvsObjectFunctionCall *c)
-{
-	QString szMode;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("selection_mode",KVS_PT_STRING,0,szMode)
-	KVSO_PARAMETERS_END(c)
-	if(!widget()) return true;
-	QAbstractItemView::SelectionMode iMode = QAbstractItemView::SingleSelection;
-
-	if(KviQString::equalCI(szMode,"single")) iMode = QAbstractItemView::SingleSelection;
-
-	else if(KviQString::equalCI(szMode,"multi")) iMode = QAbstractItemView::MultiSelection;
-
-	else if(KviQString::equalCI(szMode,"extended")) iMode = QAbstractItemView::ExtendedSelection;
-
-	else if(KviQString::equalCI(szMode,"none")) iMode = QAbstractItemView::NoSelection;
-
-	else  c->warning(__tr2qs("Invalid selection mode '%Q' assuming single"),&szMode);
-	((QListWidget *)widget())->setSelectionMode(iMode);
-
-	return true;
-}
-bool KviKvsObject_listbox::functionselectionMode(KviKvsObjectFunctionCall *c)
-{
-
-	if(!widget()) return true;
-	switch(((QListWidget *)widget())->selectionMode())
-	{
-		case QAbstractItemView::SingleSelection: c->returnValue()->setString("single"); break;
-		case QAbstractItemView::MultiSelection: c->returnValue()->setString("multi"); break;
-		case QAbstractItemView::ExtendedSelection: c->returnValue()->setString("extended"); break;
-		case QAbstractItemView::NoSelection: c->returnValue()->setString("none"); break;
-		default: c->returnValue()->setString("single"); break;
-	}
-	return true;
-}
-
-bool KviKvsObject_listbox::functioninsertWidgetItem(KviKvsObjectFunctionCall *c)
-{
-	KviKvsObject *pObject;
-	kvs_int_t iIndex;
-	kvs_hobject_t hWid;
-
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("widget",KVS_PT_HOBJECT,0,hWid)
-		KVSO_PARAMETER("index",KVS_PT_INT,0,iIndex)
-	KVSO_PARAMETERS_END(c)
-
-	pObject=KviKvsKernel::instance()->objectController()->lookupObject(hWid);
-	if(pObject==this) 
-	{
-		c->warning(__tr2qs("Can't insert the listbox itelf!"));
-		return true;
-	}
-
-	if(!pObject->object()->isWidgetType())
-	{
-		c->warning(__tr2qs("Can't insert a non-widget object"));
-		return true;
-	}
-
-	QWidget *wi=((QWidget *)(pObject->object()));
-	QListWidgetItem *item=((QListWidget *)widget())->item(iIndex);
-	((QListWidget *)widget())->setItemWidget(item,wi);
-	return true;
-}
-bool KviKvsObject_listbox::function_selectedItems(KviKvsObjectFunctionCall *c)
-{
-	if(widget())
-	{
-		QList<QListWidgetItem *> list=((QListWidget *)widget())->selectedItems();
-		KviKvsArray * pArray = new KviKvsArray();
-		c->returnValue()->setArray(pArray);
-		for (int i=0;i<list.count();i++){
-			kvs_int_t index=((QListWidget *)widget())->row(list.at(i));
-			pArray->set(i,new KviKvsVariant(index));
-		}
-	}
-	else
-		c->returnValue()->setNothing();
-	return true;
-}
-
-/*
-bool KviKvsObject_listbox::functionsetSelected(KviKvsObjectFunctionCall *c)
-{
-	bool bSel;
-	kvs_uint_t iIndex;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("index",KVS_PT_UNSIGNEDINTEGER,0,iIndex)
-		KVSO_PARAMETER("benabled",KVS_PT_BOOLEAN,0,bSel)
-	KVSO_PARAMETERS_END(c)
-	if(widget()) ((QListWidget *)widget())->setSelected(iIndex,bSel);
-	return true;
-}
-*/
-bool KviKvsObject_listbox::functionitemAt(KviKvsObjectFunctionCall *c)
-{
-	kvs_uint_t uX,uY;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("uX",KVS_PT_UNSIGNEDINTEGER,0,uX)
-		KVSO_PARAMETER("uY",KVS_PT_UNSIGNEDINTEGER,0,uY)
-	KVSO_PARAMETERS_END(c)
-	if(widget()) 
-		c->returnValue()->setInteger(((QListWidget *)widget())->row(((QListWidget *)widget())->itemAt(QPoint(uX,uY))));
-	return true;
-}
-
-bool KviKvsObject_listbox::functioncurrentItemChangeEvent(KviKvsObjectFunctionCall *c)
-{
-	emitSignal("currentItemChange",c,c->params());
-
-	return true;
-}
-
-void KviKvsObject_listbox::selectionChanged()
-{
-	KviKvsVariantList *params=0;
-	callFunction(this,"selectionChangeEvent",0,0);
-}
-
-void KviKvsObject_listbox::currentItemChanged(QListWidgetItem *currentItem,QListWidgetItem *previousItem)
-{
-	if (!currentItem) callFunction(this,"currentItemChangeEvent",0,0);
-	else
-	{
-		KviKvsVariantList params(new KviKvsVariant(currentItem->text()));
-		callFunction(this,"currentItemChangeEvent",0,&params);
-	}
-
-}
-bool KviKvsObject_listbox::functiononItemEvent(KviKvsObjectFunctionCall *c)
-{
-	emitSignal("onItem",c,c->params());
-
-	return true;
-}
-
-void KviKvsObject_listbox::onItem(QListWidgetItem *item)
-{
-		/*QListWidget *lbx = (QListWidget *)(item->listBox());
-		KviKvsVariantList params(new KviKvsVariant((kvs_int_t)lbx->index(item)));
-		callFunction(this,"onItemEvent",0,&params);
-		*/
-}
-/*
-
-bool KviKvsObject_listbox::functionitemRect(KviKvsObjectFunctionCall *c)
-{
-kvs_uint_t iIndex;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("iIndex",KVS_PT_UNSIGNEDINTEGER,0,iIndex)
-	KVSO_PARAMETERS_END(c)
-	if(widget())
-	{
-		QRect rect=((KviTalListBox *)widget())->itemRect(((KviTalListBox *)widget())->item(iIndex));
-		KviKvsArray * a = new KviKvsArray();
-		a->set(0,new KviKvsVariant((kvs_int_t)rect.left()));
-		a->set(1,new KviKvsVariant((kvs_int_t)rect.top()));
-		a->set(2,new KviKvsVariant((kvs_int_t)rect.width()));
-		a->set(3,new KviKvsVariant((kvs_int_t)rect.height()));
-		c->returnValue()->setArray(a);
-	}
-		return true;
-}
-
-*/
-#ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
-#include "m_class_listbox.moc"
-#endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
-
diff --git a/src/modules/objects/class_listbox.h b/src/modules/objects/class_listbox.h
deleted file mode 100644
index 6302d4ee4..000000000
--- a/src/modules/objects/class_listbox.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#ifndef _CLASS_LISTBOX_H_
-#define _CLASS_LISTBOX_H_
-//=============================================================================
-//
-//   File : class_listbox.h
-//   Creation date : Sat Oct 2 03:40:28 CET 2004 by Szymon Stefanek
-//
-//   This file is part of the KVirc irc client distribution
-//   Copyright (C) 2004-2008 Szymon Stefanek (pragma at kvirc dot net)
-//
-//   This program is FREE software. You can redistribute it and/or
-//   modify it under the terms of the GNU General Public License
-//   as published by the Free Software Foundation; either version 2
-//   of the License, or (at your opinion) any later version.
-//
-//   This program is distributed in the HOPE that it will be USEFUL,
-//   but WITHOUT ANY WARRANTY; without even the implied warranty of
-//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-//   See the GNU General Public License for more details.
-//
-//   You should have received a copy of the GNU General Public License
-//   along with this program. If not, write to the Free Software Foundation,
-//   Inc. ,59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-//
-//=============================================================================
-
-
-#include "class_widget.h"
-#include <QListWidget>
-
-//class KviTalListBox;
-//class KviTalListBoxItem;
-
-#include "object_macros.h"
-
-class KviKvsObject_listbox: public KviKvsObject_widget
-{
-	Q_OBJECT
-public:
-	KVSO_DECLARE_OBJECT(KviKvsObject_listbox)
-public:
-	QWidget * widget() { return (QWidget *)object(); };
-protected:
-	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
-	
-
-	bool functioninsertItem(KviKvsObjectFunctionCall *c);
-	bool functionchangeItem(KviKvsObjectFunctionCall *c);
-	bool functionremoveItem(KviKvsObjectFunctionCall *c);
-	bool functioncount(KviKvsObjectFunctionCall *c);
-	bool functioncurrentText(KviKvsObjectFunctionCall *c);
-	bool functioncurrentItem(KviKvsObjectFunctionCall *c);
-	bool functiontextAt(KviKvsObjectFunctionCall *c);
-	bool functionsetCurrentItem(KviKvsObjectFunctionCall *c);
-	bool functionclear(KviKvsObjectFunctionCall *c);
-	bool functionsetSelectionMode(KviKvsObjectFunctionCall *c);
-	bool functionselectionMode(KviKvsObjectFunctionCall *c);
-	bool functioninsertWidgetItem(KviKvsObjectFunctionCall *c);
-	/*bool functionisSelected(KviKvsObjectFunctionCall *c);
-	*/
-	bool function_selectedItems(KviKvsObjectFunctionCall *c);
-	bool functioncurrentItemChangeEvent(KviKvsObjectFunctionCall *c);
-	bool functiononItemEvent(KviKvsObjectFunctionCall *c);
-
-	bool functionitemAt(KviKvsObjectFunctionCall *c);
-	//bool functionitemRect(KviKvsObjectFunctionCall *c);
-protected slots:
-	void selectionChanged();
-	void currentItemChanged(QListWidgetItem *,QListWidgetItem *);
-	void onItem(QListWidgetItem *);
-};
-
-
-#endif	// !_CLASS_COMBOBOX_H_
diff --git a/src/modules/objects/class_mainwindow.cpp b/src/modules/objects/class_mainwindow.cpp
index 03854530b..824f48635 100644
--- a/src/modules/objects/class_mainwindow.cpp
+++ b/src/modules/objects/class_mainwindow.cpp
@@ -52,9 +52,9 @@
 */
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_mainwindow,"mainwindow","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_mainwindow,"setCentralWidget",functionsetCentralWidget)
-	KVSO_REGISTER_HANDLER(KviKvsObject_mainwindow,"setDockEnabled",functionsetDockEnabled)
-	KVSO_REGISTER_HANDLER(KviKvsObject_mainwindow,"isDockEnabled",functionisDockEnabled)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_mainwindow,setCentralWidget)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_mainwindow,setDockEnabled)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_mainwindow,isDockEnabled)
 
 KVSO_END_REGISTERCLASS(KviKvsObject_mainwindow)
 
@@ -73,8 +73,9 @@ bool KviKvsObject_mainwindow::init(KviKvsRunTimeContext * pContext,KviKvsVariant
 	return true;
 }
 
-bool KviKvsObject_mainwindow::functionsetCentralWidget(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(mainwindow,setCentralWidget)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	KviKvsObject * pObject;
 	kvs_hobject_t hObject;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -96,37 +97,38 @@ bool KviKvsObject_mainwindow::functionsetCentralWidget(KviKvsObjectFunctionCall
 		c->warning(__tr2qs("Widget object required"));
         return TRUE;
     }
-	if(widget()) ((KviTalMainWindow *)widget())->setCentralWidget(((QWidget  *)(pObject->object())));
+	((KviTalMainWindow *)widget())->setCentralWidget(((QWidget  *)(pObject->object())));
 	return true;	
 }
 //FIX ME
-bool KviKvsObject_mainwindow::functionsetDockEnabled(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(mainwindow,setDockEnabled)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szDockarea;
 	bool bFlag;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("dock area",KVS_PT_STRING,0,szDockarea)
 		KVSO_PARAMETER("bool enabled",KVS_PT_BOOL,0,bFlag)
 	KVSO_PARAMETERS_END(c)
-	if(widget())
+/*	if(widget())
 	{
 
 	}
+*/
 	return true;
 
 }
 
 //FIX ME
-bool KviKvsObject_mainwindow::functionisDockEnabled(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(mainwindow,isDockEnabled)
 {
-	
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szDockarea;
 	bool bFlag = false;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("dock_area",KVS_PT_STRING,0,szDockarea)
 	KVSO_PARAMETERS_END(c)
-    if(!widget()) return true;
-	c->returnValue()->setBoolean(bFlag);
+   c->returnValue()->setBoolean(bFlag);
 	return true;		
 
 }
diff --git a/src/modules/objects/class_mainwindow.h b/src/modules/objects/class_mainwindow.h
index 0775cc9e6..612917bd6 100644
--- a/src/modules/objects/class_mainwindow.h
+++ b/src/modules/objects/class_mainwindow.h
@@ -38,9 +38,9 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functionsetCentralWidget(KviKvsObjectFunctionCall *c);
-	bool functionsetDockEnabled(KviKvsObjectFunctionCall *c);
-	bool functionisDockEnabled(KviKvsObjectFunctionCall *c);
+	bool setCentralWidget(KviKvsObjectFunctionCall *c);
+	bool setDockEnabled(KviKvsObjectFunctionCall *c);
+	bool isDockEnabled(KviKvsObjectFunctionCall *c);
 
 };
 
diff --git a/src/modules/objects/class_menubar.cpp b/src/modules/objects/class_menubar.cpp
index 5f3c9cac3..652297b89 100644
--- a/src/modules/objects/class_menubar.cpp
+++ b/src/modules/objects/class_menubar.cpp
@@ -47,7 +47,7 @@
 */
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_menubar,"menubar","widget")
-	KVSO_REGISTER_HANDLER(KviKvsObject_menubar,"inserItem",functionInsertItem)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_menubar,insertItem)
 KVSO_END_REGISTERCLASS(KviKvsObject_menubar)
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_menubar,KviKvsObject_widget)
@@ -65,12 +65,13 @@ bool KviKvsObject_menubar::init(KviKvsRunTimeContext * pContext,KviKvsVariantLis
 	return true;
 }
 
-bool KviKvsObject_menubar::functionInsertItem(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(menubar,insertItem)
 {
+	CHECK_INTERNAL_QPOINTER(widget())
 	QString szItem;
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("item",KVS_PT_STRING,0,szItem)
 	KVSO_PARAMETERS_END(c)
-	if (widget()) ((QMenuBar *)widget())->addAction(szItem);
+	((QMenuBar *)widget())->addAction(szItem);
 	return true;
 }
diff --git a/src/modules/objects/class_menubar.h b/src/modules/objects/class_menubar.h
index 572820bf0..48de16dd1 100644
--- a/src/modules/objects/class_menubar.h
+++ b/src/modules/objects/class_menubar.h
@@ -37,6 +37,6 @@ public:
 protected:
 	virtual bool init(KviKvsRunTimeContext * pContext,KviKvsVariantList *pParams);
 
-	bool functionInsertItem(KviKvsObjectFunctionCall *c);
+	bool insertItem(KviKvsObjectFunctionCall *c);
 };
 #endif	// !_CLASS_MENUBAR_H_
diff --git a/src/modules/objects/class_multilineedit.cpp b/src/modules/objects/class_multilineedit.cpp
index e924d5e7b..3b2f9d232 100644
--- a/src/modules/objects/class_multilineedit.cpp
+++ b/src/modules/objects/class_multilineedit.cpp
@@ -33,7 +33,7 @@
 #include <QTextDocument>
 #include <QTextEdit>
 #include <QTextStream>
-
+ #include <QTextCursor>
 
 #include "class_multilineedit.h"
 
@@ -329,6 +329,8 @@ KVSO_REGISTER_HANDLER(KviKvsObject_textedit,"addwidget", functionAddWidget)
 	KVSO_REGISTER_HANDLER(KviKvsObject_textedit,"linesOfParagraph" , functionlinesOfParagraph)
 	KVSO_REGISTER_HANDLER(KviKvsObject_textedit,"selectAll" , functionselectAll)
 	*/
+
+	KVSO_REGISTER_HANDLER(KviKvsObject_textedit,"insertTable",functionInsertTable)
 KVSO_END_REGISTERCLASS(KviKvsObject_textedit)
 
 
@@ -375,7 +377,21 @@ bool KviKvsObject_textedit::functionAddWidget(KviKvsObjectFunctionCall * c)
 	((QTextEdit *)object())->addScrollBarWidget(((QWidget *)(pObject->object())),Qt::AlignLeft);
 	return true;
 }
+bool KviKvsObject_textedit::functionInsertTable(KviKvsObjectFunctionCall * c)
+{
+	if(widget()){
+		QTextCursor cur= ((QTextEdit *)widget())->textCursor();
+		QTextTableFormat tableModel;
+		tableModel.setBorderStyle(QTextFrameFormat::BorderStyle_Solid);
+		tableModel.setCellPadding(0);
+		tableModel.setCellSpacing(0);
+		tableModel.setBorderBrush(QColor(255,255,255));
 
+		cur.insertTable(3,3,tableModel);
+		((QTextEdit *)widget())->setTextCursor(cur);
+	}
+	return true;
+}
 bool KviKvsObject_textedit::functionSetReadOnly(KviKvsObjectFunctionCall * c)
 {
 	bool bEnabled;
diff --git a/src/modules/objects/class_multilineedit.h b/src/modules/objects/class_multilineedit.h
index a128553c4..57d246e73 100644
--- a/src/modules/objects/class_multilineedit.h
+++ b/src/modules/objects/class_multilineedit.h
@@ -115,6 +115,8 @@ protected:
 
 	bool functionAddWidget(KviKvsObjectFunctionCall *c);
 
+	bool functionInsertTable(KviKvsObjectFunctionCall * c);
+
 };
 
 #endif	//!_CLASS_MULTILINEEDIT_H_
diff --git a/src/modules/objects/class_painter.cpp b/src/modules/objects/class_painter.cpp
index 67c64a427..82bafc023 100644
--- a/src/modules/objects/class_painter.cpp
+++ b/src/modules/objects/class_painter.cpp
@@ -37,6 +37,27 @@
 #include <QTextDocument>
 #include <QIcon>
 
+#define PAINTER_ROTATE(__angle)\
+	 QMatrix matrix;\
+     matrix.rotate(__angle);\
+     m_pPainter->setWorldMatrix(matrix,true);
+
+#define PAINTER_TRANSLATE(__x,__y)\
+	 QMatrix matrix;\
+     matrix.translate(__x,__y);\
+     m_pPainter->setWorldMatrix(matrix,true);
+
+#define PAINTER_SHEAR(__sH,__sV)\
+	 QMatrix matrix;\
+     matrix.shear(__sH,__sV);\
+     m_pPainter->setWorldMatrix(matrix,true);
+
+#define PAINTER_SCALE(__sX,__sY)\
+	 QMatrix matrix;\
+     matrix.scale(__sX,__sY);\
+     m_pPainter->setWorldMatrix(matrix,true);
+
+
 const Qt::PenStyle penstyles_cod[] = {
 	Qt::NoPen,
 	Qt::SolidLine,
@@ -1136,9 +1157,7 @@ bool KviKvsObject_painter::functionrotateMatrix(KviKvsObjectFunctionCall *c)
 		KVSO_PARAMETER("angle",KVS_PT_DOUBLE,0,dAngle)
 	KVSO_PARAMETERS_END(c)
 	if(!m_pPainter)return true;
-	//m_pMatrix.rotate(dAngle);
-	//m_pPainter->setWorldMatrix( m_pMatrix,false );
-	m_pPainter->rotate(dAngle);
+	PAINTER_ROTATE(dAngle)
 	return true;
 }
 
@@ -1150,12 +1169,13 @@ bool KviKvsObject_painter::functiontranslateMatrix(KviKvsObjectFunctionCall *c)
 		KVSO_PARAMETER("trasl_y",KVS_PT_DOUBLE,0,dYtrasl)
 	KVSO_PARAMETERS_END(c)
 	if(!m_pPainter)return true;
+	PAINTER_TRANSLATE(dXtrasl,dYtrasl)
 	//QWMatrix tmpMatrix;
 	//tmpMatrix.translate(dXtrasl,dYtrasl);
 	//tmpMatrix = m_pMatrix * tmpMatrix;
 	//m_pPainter->setWorldMatrix( tmpMatrix );
 	//m_pMatrix=tmpMatrix;
-	m_pPainter->translate(dXtrasl,dYtrasl);
+	//m_pPainter->translate(dXtrasl,dYtrasl);
 	return true;
 }
 
@@ -1167,9 +1187,10 @@ bool KviKvsObject_painter::functionshearMatrix(KviKvsObjectFunctionCall *c)
 		KVSO_PARAMETER("shear_v",KVS_PT_DOUBLE,0,dShearv)
 	KVSO_PARAMETERS_END(c)
 	if(!m_pPainter)return true;
+	PAINTER_SHEAR(dShearh,dShearv);
 	//m_pMatrix.shear(dShearh,dShearv);
 	//m_pPainter->setWorldMatrix(m_pMatrix);
-	m_pPainter->shear(dShearh,dShearv);
+	//m_pPainter->shear(dShearh,dShearv);
 	return true;
 }
 
@@ -1181,9 +1202,11 @@ bool KviKvsObject_painter::functionscaleMatrix(KviKvsObjectFunctionCall *c)
 		KVSO_PARAMETER("scale_y",KVS_PT_DOUBLE,0,dScaley)
 	KVSO_PARAMETERS_END(c)
 	if(!m_pPainter)return true;
+	PAINTER_SCALE(dScalex,dScaley);
+	
 	//m_pMatrix.scale(dScalex,dScaley);
 	//m_pPainter->setWorldMatrix(m_pMatrix);
-	m_pPainter->scale(dScalex,dScaley);
+	//m_pPainter->scale(dScalex,dScaley);
 	return true;
 }
 
@@ -1648,3 +1671,6 @@ bool KviKvsObject_painter::functionresetPath(KviKvsObjectFunctionCall *c)
 #ifndef COMPILE_USE_STANDALONE_MOC_SOURCES
 #include "m_class_painter.moc"
 #endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
+
+
+
diff --git a/src/modules/objects/class_pixmap.cpp b/src/modules/objects/class_pixmap.cpp
index 1f15a5fc3..a2f0eb9cd 100644
--- a/src/modules/objects/class_pixmap.cpp
+++ b/src/modules/objects/class_pixmap.cpp
@@ -24,6 +24,8 @@
 //=============================================================================
 
 #include "class_pixmap.h"
+#include "class_memorybuffer.h"
+
 #include "kvi_debug.h"
 #include "kvi_locale.h"
 
@@ -76,7 +78,10 @@ KVSO_BEGIN_REGISTERCLASS(KviKvsObject_pixmap,"pixmap","object")
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"fill",functionfill)
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"resize",functionresize)
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"load",functionload)
+	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"loadFromMemoryBuffer",functionloadFromMemoryBuffer)
+
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"height",functionheight)
+
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"width",functionwidth)
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"setOpacity",functionsetOpacity)
 	KVSO_REGISTER_HANDLER(KviKvsObject_pixmap,"scale",functionscale)
@@ -200,6 +205,32 @@ bool KviKvsObject_pixmap::functionload(KviKvsObjectFunctionCall *c)
 	bPixmapModified=true;
 	return true;
 }
+bool KviKvsObject_pixmap::functionloadFromMemoryBuffer(KviKvsObjectFunctionCall *c)
+{
+	KviKvsObject * pObject;
+	kvs_hobject_t hObject;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("hobject",KVS_PT_HOBJECT,0,hObject)
+	KVSO_PARAMETERS_END(c)
+	pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+	if (!pObject)
+	{
+		c->warning(__tr2qs("Buffer parameter is not an object"));
+		return true;
+	}
+	if (!pObject->inherits("KviKvsObjet_memorybuffer"))
+	{
+		c->warning(__tr2qs("Buffer parameter is not a memorybuffer object"));
+		return true;
+	}
+
+	m_pPixmap->loadFromData(((KviKvsObject_memorybuffer *)pObject)->dataBuffer());
+
+	bPixmapModified=true;
+
+	return true;
+}
+
 bool KviKvsObject_pixmap::functionheight(KviKvsObjectFunctionCall *c)
 {
 	c->returnValue()->setInteger(m_pPixmap->height());	
@@ -224,7 +255,6 @@ bool KviKvsObject_pixmap::functionsetOpacity(KviKvsObjectFunctionCall *c)
 	KVSO_PARAMETERS_BEGIN(c)
 			KVSO_PARAMETER("opacity_factor",KVS_PT_DOUBLE,0,dOpacity)	
 			KVSO_PARAMETER("destination",KVS_PT_HOBJECT,0,hObject)
-
 			KVSO_PARAMETER("x_offset",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uXoffset)
 			KVSO_PARAMETER("y_offset",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uYoffset)
 			KVSO_PARAMETER("width",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uWidth)
diff --git a/src/modules/objects/class_pixmap.h b/src/modules/objects/class_pixmap.h
index 2ecd33f15..1591ff394 100644
--- a/src/modules/objects/class_pixmap.h
+++ b/src/modules/objects/class_pixmap.h
@@ -65,6 +65,8 @@ protected:
 	bool functionheight(KviKvsObjectFunctionCall *c);
 	bool functionwidth(KviKvsObjectFunctionCall *c);
 	bool functionsetOpacity(KviKvsObjectFunctionCall *c);
+	bool functionloadFromMemoryBuffer(KviKvsObjectFunctionCall *c);
+
 
   };
 
diff --git a/src/modules/objects/class_socket.cpp b/src/modules/objects/class_socket.cpp
index bd763a789..786040786 100644
--- a/src/modules/objects/class_socket.cpp
+++ b/src/modules/objects/class_socket.cpp
@@ -24,11 +24,13 @@
 
 #include "kvi_settings.h"
 #include "kvi_qstring.h"
-
+#include "class_memorybuffer.h"
+#include "class_file.h"
 #define _KVI_DEBUG_CHECK_RANGE_
 #include "kvi_debug.h"
 
-
+#include "kvi_file.h"
+#include "kvi_fileutils.h"
 #include "kvi_locale.h"
 #include "kvi_error.h"
 #include "kvi_netutils.h"
@@ -277,22 +279,22 @@
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_socket,"socket","object")
 
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"status",functionStatus)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"remotePort",functionRemotePort)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"remoteIp",functionRemoteIp)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"localIp",functionLocalIp)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"localPort",functionLocalPort)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,status)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,remotePort)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,remoteIp)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,localIp)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,localPort)
 	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"connect",functionConnect)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"connectTimeout",functionConnectTimeout)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"setConnectTimeout",functionSetConnectTimeout)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"close",functionClose)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"read",functionRead)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"readHex",functionReadHex)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"write",functionWrite)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"writeHex",functionWriteHex)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"setProtocol",functionSetProtocol)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"listen",functionListen)
-	KVSO_REGISTER_HANDLER(KviKvsObject_socket,"accept",functionAccept)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,connectTimeout)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,setConnectTimeout)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,close)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,read)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,readHex)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,write)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,writeHex)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,setProtocol)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,listen)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_socket,accept)
 
 	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_socket,"connectEvent")
 	KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_socket,"connectFailedEvent")
@@ -304,8 +306,6 @@ KVSO_END_REGISTERCLASS(KviKvsObject_socket)
 
 
 KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_socket,KviKvsObject)
-
-
 	m_bUdp = false;
 	m_uConnectionId = 0;
 	m_sock = KVI_INVALID_SOCKET;
@@ -333,6 +333,7 @@ KVSO_BEGIN_DESTRUCTOR(KviKvsObject_socket)
 	m_pOutBuffer=0;
 	m_pFlushTimer=0;
 
+	
 	if(m_pInBuffer)kvi_free(m_pInBuffer);
 	if(m_pDelayTimer)delete m_pDelayTimer;
 	if(m_pDns)delete m_pDns;
@@ -343,13 +344,13 @@ KVSO_END_DESTRUCTOR(KviKvsObject_socket)
 //----------------------
 
 
-bool KviKvsObject_socket::functionStatus(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,status)
 {
 	c->returnValue()->setInteger(m_iStatus);
 	return true;
 }
 
-bool KviKvsObject_socket::functionClose(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,close)
 {
 	if (!m_pOutBuffer) return true;
 	if((m_pOutBuffer->size() != 0) && (m_iStatus == KVI_SCRIPT_SOCKET_STATUS_CONNECTED))
@@ -359,13 +360,13 @@ bool KviKvsObject_socket::functionClose(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_socket::functionConnectTimeout(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,connectTimeout)
 {
 	c->returnValue()->setInteger(m_uConnectTimeout);
 	return true;
 }
 
-bool KviKvsObject_socket::functionSetConnectTimeout(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,setConnectTimeout)
 {
 	kvs_uint_t uTimeout;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -375,31 +376,182 @@ bool KviKvsObject_socket::functionSetConnectTimeout(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_socket::functionRemotePort(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,remotePort)
 {
 	c->returnValue()->setInteger(m_uRemotePort);
 	return true;
 }
 
-bool KviKvsObject_socket::functionRemoteIp(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,remoteIp)
 {
 	c->returnValue()->setString(m_szRemoteIp);
 	return true;
 }
 
-bool KviKvsObject_socket::functionLocalPort(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,localPort)
 {
 	c->returnValue()->setInteger(m_uLocalPort);
 	return true;
 }
 
-bool KviKvsObject_socket::functionLocalIp(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,localIp)
 {
 	c->returnValue()->setString(m_szLocalIp);
 	return true;
 }
 
-bool KviKvsObject_socket::functionAccept(KviKvsObjectFunctionCall *c)
+unsigned int KviKvsObject_socket::readGetLength(KviKvsObjectFunctionCall * c)
+{
+	kvs_uint_t uLen;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("length",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
+	KVSO_PARAMETERS_END(c)
+	if (uLen>m_uInDataLen || !uLen) return m_uInDataLen;
+	else return uLen;
+}
+
+KVSO_CLASS_FUNCTION(socket,read)
+{
+	kvs_uint_t uLen;
+	KviKvsObject * pObject;
+	kvs_hobject_t hObject;
+	KVSO_PARAMETERS_BEGIN(c)
+		KVSO_PARAMETER("length",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
+		KVSO_PARAMETER("hobject",KVS_PT_HOBJECT,KVS_PF_OPTIONAL,hObject)
+	KVSO_PARAMETERS_END(c)
+	if (uLen>m_uInDataLen || !uLen) uLen=m_uInDataLen;
+	if (hObject)
+	{
+		pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+		if (!pObject)
+		{
+			c->warning(__tr2qs("Buffer parameter is not an object"));
+			return true;
+		}
+		if (!pObject->inherits("KviKvsObject_memorybuffer"))
+		{
+			c->warning(__tr2qs("Buffer parameter is not a memorybuffer object"));
+			return true;
+		}
+
+		QByteArray *pBuffer=((KviKvsObject_memorybuffer *)pObject)->pBuffer();
+		int oldsize=pBuffer->size();
+		pBuffer->resize(oldsize+uLen);
+		kvi_memmove(pBuffer->data()+oldsize,m_pInBuffer,uLen);
+		eatInData(uLen);
+		return true;
+	}
+	if(uLen > 0)
+	{
+		// convert NULLS to char 255
+		for(unsigned int i = 0;i < uLen;i++)
+		{
+			if(!m_pInBuffer[i])m_pInBuffer[i] = (char)(255);
+		}
+		QString tmpBuffer = QString::fromUtf8(m_pInBuffer,uLen);
+		c->returnValue()->setString(tmpBuffer);
+
+		eatInData(uLen);
+	}
+	return true;
+}
+
+// FIXME: obsolete?
+KVSO_CLASS_FUNCTION(socket,readHex)
+{
+	unsigned int uLen = readGetLength(c);
+	char * str = new char[(uLen*2) + 1];
+	int index=0;
+	unsigned char byte,msb,lsb=0;
+	for (int i=0;i<uLen;i++)
+	{
+		byte=(unsigned char)m_pInBuffer[i];
+		lsb=byte & 0x0f;
+		msb=byte>>4;
+		msb>9?msb+='7':msb+='0'; 
+		lsb>9?lsb+='7':lsb+='0'; 
+		str[index++]=msb; 
+		str[index++]=lsb;
+	}
+	str[index]='\0';
+	c->returnValue()->setString(str);
+	eatInData(uLen);
+	delete str;
+	return true;
+}
+
+KVSO_CLASS_FUNCTION(socket,write)
+{
+	kvs_uint_t uLen;
+	KviKvsObject * pObject;
+	KviKvsVariant * pVariantData;
+	kvs_hobject_t hObject;
+	KVSO_PARAMETERS_BEGIN(c)
+			KVSO_PARAMETER("data_or_file_or_",KVS_PT_VARIANT,0,pVariantData)
+			KVSO_PARAMETER("length",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
+	KVSO_PARAMETERS_END(c)
+	if (pVariantData->isHObject())
+	{
+		pVariantData->asHObject(hObject);
+		pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+		if (!pObject)
+		{
+			c->warning(__tr2qs("Buffer parameter is not an object"));
+			return true;
+		}
+		if (pObject->inherits("KviKvsObject_memorybuffer"))
+		{
+			QByteArray *p=((KviKvsObject_memorybuffer *)pObject)->pBuffer();
+			m_pOutBuffer->append((const unsigned char*)p->data(),p->size());
+		}
+		else if (pObject->inherits("KviKvsObject_file"))
+		{
+			KviFile *pFile=((KviKvsObject_file *)pObject)->pFile();
+			if (!pFile->isOpen()) 
+			{
+				c->warning(__tr2qs("File is not open !"));
+				return true;
+			}
+			if (!uLen) uLen=pFile->size();
+			kvs_int_t siz=pFile->size();
+			pFile->flush();
+			m_pOutBuffer->append((const unsigned char*)pFile->read(uLen).data(),uLen);
+			c->returnValue()->setBoolean((siz-pFile->pos()==0));
+		}
+		else
+		{
+			c->warning(__tr2qs("Buffer parameter is not a memorybuffer or file object"));
+			return true;
+		}
+		
+	}
+	else
+	{
+		QString szData;
+		pVariantData->asString(szData);
+		if(!KviFileUtils::fileExists(szData))
+		{
+			KviQCString szData8 = szData.toUtf8();
+			if(szData8.length() > 0)
+			{
+					m_pOutBuffer->append((const unsigned char*)szData8.data(),szData8.length());
+			}
+		}
+		else
+		{
+			KviFile f(szData);
+			f.open(QIODevice::ReadOnly);
+			QByteArray ar= f.readAll();
+			m_pOutBuffer->append((const unsigned char*)ar.data(),ar.size());
+			f.close();
+		}
+	}
+	delayedFlush(0);
+	return true;
+}
+
+
+KVSO_CLASS_FUNCTION(socket,accept)
 {
 	KviKvsObject * pObject;
 	kvs_hobject_t hObject;
@@ -435,7 +587,7 @@ bool KviKvsObject_socket::functionAccept(KviKvsObjectFunctionCall *c)
 }
 
 
-bool  KviKvsObject_socket::functionSetProtocol(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,setProtocol)
 {
 	QString m_szHex;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -446,7 +598,8 @@ bool  KviKvsObject_socket::functionSetProtocol(KviKvsObjectFunctionCall *c)
 	return false;
 }
 
-bool  KviKvsObject_socket::functionWriteHex(KviKvsObjectFunctionCall *c)
+// FIXME: obsolete?
+KVSO_CLASS_FUNCTION(socket,writeHex)
 {
 	QString m_szHex;
 	KVSO_PARAMETERS_BEGIN(c)
@@ -485,10 +638,7 @@ bool  KviKvsObject_socket::functionWriteHex(KviKvsObjectFunctionCall *c)
 }
 
 
-
-
-
-bool  KviKvsObject_socket::functionConnect(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,functionConnect)
 {
 	KVSO_PARAMETERS_BEGIN(c)
 		KVSO_PARAMETER("remote_ip",KVS_PT_STRING,0,m_szRemoteIp)
@@ -531,11 +681,7 @@ bool  KviKvsObject_socket::functionConnect(KviKvsObjectFunctionCall *c)
 }
 
 
-
-
-
-
-bool KviKvsObject_socket::functionListen(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(socket,listen)
 {
 	if((m_sock != KVI_INVALID_SOCKET) || (m_iStatus != KVI_SCRIPT_SOCKET_STATUS_DISCONNECTED))
 	{
@@ -795,9 +941,7 @@ void KviKvsObject_socket::doConnect()
 		KviQString::sprintf(tmp,__tr2qs("Invalid ip address (%Q)"),&m_szRemoteIp);
 		params.append(new KviKvsVariant(tmp));
 		callFunction(this,"connectFailedEvent",&params);
-	/*	callEventFunction("connectFailedEvent",0,new KviParameterList(
-			new KviStr(KviStr::Format,__tr("Invalid ip address (%s)"),m_szRemoteIp.ptr())));
-	*/	if(m_uConnectionId == uOldConnectionId)reset();
+		if(m_uConnectionId == uOldConnectionId)reset();
 		// else it has already been called!
 		return;
 	}
@@ -852,12 +996,9 @@ debug ("Socket created");
 			QString callBackError=__tr2qs("Connect failure: ");
 
 			callBackError.append((KviError::getDescription(KviError::translateSystemError(sockError)).toUtf8().data()));
-			callFunction(this,"connectFailedEvent",new KviKvsVariantList(
-			new KviKvsVariant(callBackError)));
+			callFunction(this,"connectFailedEvent",new KviKvsVariantList(new KviKvsVariant(callBackError)));
 
-/*			callEventFunction("connectFailedEvent",0,new KviParameterList(
-				new KviStr(KviStr::Format,__tr("Connect failure: %s"),KviError::getDescription(KviError::translateSystemError(sockError)).toUtf8().data())));
-*/			if(m_uConnectionId == uOldConnectionId)reset();
+			if(m_uConnectionId == uOldConnectionId)reset();
 			// else it has already been called!
 			return;
 		}
@@ -938,7 +1079,6 @@ void KviKvsObject_socket::lookupDone(KviDns *pDns)
 
 void KviKvsObject_socket::writeNotifierFired(int)
 {
-	debug ("Here in the writeNotifierFired");
 	if(m_pSn)
 	{
 		delete m_pSn;
@@ -995,14 +1135,15 @@ void KviKvsObject_socket::writeNotifierFired(int)
 
 void KviKvsObject_socket::readNotifierFired(int)
 {
-	debug ("here in the readNotifierFired");
-	//read data
+	//read da
 	if((m_uInBufferLen - m_uInDataLen) < KVI_READ_CHUNK)
 	{
 		m_uInBufferLen += KVI_IN_BUFFER_ALLOC_CHUNK;
+		//m_pInBuffer->resize(m_uInBufferLen);
 		m_pInBuffer = (char *)kvi_realloc(m_pInBuffer,m_uInBufferLen);
 	}
 
+	//int readLength = kvi_socket_recv(m_sock,m_pInBuffer->data() + m_uInDataLen,KVI_READ_CHUNK);
 	int readLength = kvi_socket_recv(m_sock,m_pInBuffer + m_uInDataLen,KVI_READ_CHUNK);
 
 	if(readLength <= 0)
@@ -1046,13 +1187,9 @@ void KviKvsObject_socket::readNotifierFired(int)
 	// readLength > 0
 	m_uInDataLen += readLength;
 
-	//KviStr * s = new KviStr();
-	QString s;
-	s.setNum(m_uInDataLen);
-
-
+	
 	unsigned int uOldConnectionId = m_uConnectionId;
-	callFunction(this,"dataAvailableEvent",new KviKvsVariantList(new KviKvsVariant(s)));
+	callFunction(this,"dataAvailableEvent",new KviKvsVariantList(new KviKvsVariant((kvs_int_t)readLength)));
 	if(m_uConnectionId == uOldConnectionId)
 	{
 		if(m_uInDataLen > (4096 * 1024)) // too much data in buffer (not reading)
@@ -1181,73 +1318,6 @@ void KviKvsObject_socket::reset()
 	m_szLocalIp="";
 	m_bIPv6 = false;
 }
-unsigned int KviKvsObject_socket::readGetLength(KviKvsObjectFunctionCall *c)
-{
-	kvs_uint_t uLen;
-	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("length",KVS_PT_UNSIGNEDINTEGER,KVS_PF_OPTIONAL,uLen)
-	KVSO_PARAMETERS_END(c)
-	if (uLen>m_uInDataLen || !uLen) return m_uInDataLen;
-	else return uLen;
-	}
-
-bool KviKvsObject_socket::functionRead(KviKvsObjectFunctionCall *c)
-{
-	unsigned int uLen = readGetLength(c);
-
-	if(uLen > 0)
-	{
-		// convert NULLS to char 255
-		for(unsigned int i = 0;i < uLen;i++)
-		{
-			if(!m_pInBuffer[i])m_pInBuffer[i] = (char)(255);
-		}
-		QString tmpBuffer = QString::fromUtf8(m_pInBuffer,uLen);
-		c->returnValue()->setString(tmpBuffer);
-
-		eatInData(uLen);
-	}
-	return true;
-}
-
-bool KviKvsObject_socket::functionReadHex(KviKvsObjectFunctionCall *c)
-{
-	unsigned int uLen = readGetLength(c);
-	char * str = new char[(uLen*2) + 1];
-	int index=0;
-	unsigned char byte,msb,lsb=0;
-	for (int i=0;i<uLen;i++)
-	{
-		byte=(unsigned char)m_pInBuffer[i];
-		lsb=byte & 0x0f;
-		msb=byte>>4;
-		msb>9?msb+='7':msb+='0'; 
-		lsb>9?lsb+='7':lsb+='0'; 
-		str[index++]=msb; 
-		str[index++]=lsb;
-	}
-	str[index]='\0';
-	c->returnValue()->setString(str);
-	eatInData(uLen);
-	delete str;
-	return true;
-}
-
-bool KviKvsObject_socket::functionWrite(KviKvsObjectFunctionCall *c)
-{
- QString szData;
- KVSO_PARAMETERS_BEGIN(c)
-  KVSO_PARAMETER("szData",KVS_PT_STRING,0,szData)
- KVSO_PARAMETERS_END(c)
-
-KviQCString szData8 = szData.toUtf8();
- if(szData8.length() > 0)
- {
-  m_pOutBuffer->append((const unsigned char*)szData8.data(),szData8.length());
-  delayedFlush(0);
- }
- return true;
-}
 
 
 
@@ -1257,3 +1327,6 @@ KviQCString szData8 = szData.toUtf8();
 #include "m_class_socket.moc"
 #endif //!COMPILE_USE_STANDALONE_MOC_SOURCES
 
+
+
+
diff --git a/src/modules/objects/class_socket.h b/src/modules/objects/class_socket.h
index 792e8a1a9..950305209 100644
--- a/src/modules/objects/class_socket.h
+++ b/src/modules/objects/class_socket.h
@@ -38,78 +38,6 @@
 
 class KviDns;
 class KviDataBuffer;
-/*
-class KviScriptSocketObject : public KviScriptObject
-{
-	Q_OBJECT
-public:
-	KviScriptSocketObject(KviScriptObjectClass * cla,KviScriptObject * par,const char * nam);
-	virtual ~KviScriptSocketObject();
-protected:
-	kvi_socket_t       m_sock;
-	int                m_iStatus;
-	KviStr             m_szRemoteIp;
-	unsigned short int m_uRemotePort;
-	KviStr             m_szLocalIp;
-	unsigned short int m_uLocalPort;
-	unsigned int       m_uConnectTimeout;
-	QSocketNotifier  * m_pSn;
-	KviDns           * m_pDns;
-	QTimer           * m_pDelayTimer;
-	char             * m_pInBuffer;
-	unsigned int       m_uInBufferLen;
-	unsigned int       m_uInDataLen;
-	bool               m_bIPv6;
-	unsigned int       m_uConnectionId;
-
-	KviDataBuffer    * m_pOutBuffer;
-	QTimer           * m_pFlushTimer;
-
-	kvi_socket_t       m_secondarySock;
-	unsigned short int m_uSecondaryPort;
-	KviStr             m_szSecondaryIp;
-protected:
-	bool functionStatus(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionRemotePort(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionRemoteIp(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionLocalPort(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionLocalIp(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionConnect(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionSetConnectTimeout(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionConnectTimeout(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionClose(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionRead(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionReadHex(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionWrite(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionWriteHex(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionListen(KviCommand *c,KviParameterList * params,KviStr &buffer);
-	bool functionAccept(KviCommand *c,KviParameterList * params,KviStr &buffer);
-
-	void delayedConnect();
-	void delayedLookupRemoteIp();
-	void delayedFlush(unsigned int uTimeout);
-
-	void eatInData(unsigned int uLen);
-	unsigned int readGetLength(KviParameterList * params);
-
-	void acceptConnection(kvi_socket_t s,unsigned short int uPort,const char * szIp);
-
-	void reset();
-protected slots:
-	void doConnect();
-	void lookupRemoteIp();
-	void lookupDone(KviDns * pDns);
-	void connectTimeout();
-	void writeNotifierFired(int);
-	void readNotifierFired(int);
-	void tryFlush();
-	void incomingConnection(int);
-public:
-	static void registerSelf();
-	static void unregisterSelf();
-};
-*/
-//===============================================================
 #include "object_macros.h"
 
 
@@ -130,7 +58,7 @@ protected:
 	QSocketNotifier  * m_pSn;
 	KviDns           * m_pDns;
 	QTimer           * m_pDelayTimer;
-	char             * m_pInBuffer;
+	char				* m_pInBuffer;
 	unsigned int       m_uInBufferLen;
 	unsigned int       m_uInDataLen;
 	bool               m_bIPv6;
@@ -143,25 +71,25 @@ protected:
 	kvi_u32_t          m_uSecondaryPort;
 	QString             m_szSecondaryIp;
 protected:
-	bool functionStatus(KviKvsObjectFunctionCall *c);
-	bool functionRemotePort(KviKvsObjectFunctionCall *c);
-	bool functionRemoteIp(KviKvsObjectFunctionCall *c);
-	bool functionLocalPort(KviKvsObjectFunctionCall *c);
-	bool functionLocalIp(KviKvsObjectFunctionCall *c);
+	bool status(KviKvsObjectFunctionCall *c);
+	bool remotePort(KviKvsObjectFunctionCall *c);
+	bool remoteIp(KviKvsObjectFunctionCall *c);
+	bool localPort(KviKvsObjectFunctionCall *c);
+	bool localIp(KviKvsObjectFunctionCall *c);
 	bool functionConnect(KviKvsObjectFunctionCall *c);
-	bool functionSetConnectTimeout(KviKvsObjectFunctionCall *c);
-	bool functionConnectTimeout(KviKvsObjectFunctionCall *c);
+	bool setConnectTimeout(KviKvsObjectFunctionCall *c);
+	bool connectTimeout(KviKvsObjectFunctionCall *c);
 
-	bool functionClose(KviKvsObjectFunctionCall *c);
-	bool functionRead(KviKvsObjectFunctionCall *c);
-	bool functionReadHex(KviKvsObjectFunctionCall *c);
-	bool functionWrite(KviKvsObjectFunctionCall *c);
-	bool functionWriteHex(KviKvsObjectFunctionCall *c);
+	bool close(KviKvsObjectFunctionCall *c);
+	bool read(KviKvsObjectFunctionCall *c);
+	bool readHex(KviKvsObjectFunctionCall *c);
+	bool write(KviKvsObjectFunctionCall *c);
+	bool writeHex(KviKvsObjectFunctionCall *c);
 
-	bool functionSetProtocol(KviKvsObjectFunctionCall *c);
+	bool setProtocol(KviKvsObjectFunctionCall *c);
 
-	bool functionListen(KviKvsObjectFunctionCall *c);
-	bool functionAccept(KviKvsObjectFunctionCall *c);
+	bool listen(KviKvsObjectFunctionCall *c);
+	bool accept(KviKvsObjectFunctionCall *c);
 
 	void delayedConnect();
 	void delayedLookupRemoteIp();
diff --git a/src/modules/objects/class_widget.cpp b/src/modules/objects/class_widget.cpp
index 2ba146bb0..7272dbc08 100644
--- a/src/modules/objects/class_widget.cpp
+++ b/src/modules/objects/class_widget.cpp
@@ -556,11 +556,11 @@ const Qt::WindowType widgettypes_cod[] = {
 			%Widget->%combobox->$insertItem("This is a combobox")
 			%Widget->%combobox->$insertItem("This is a combobox's item")
 
-			%Widget->%listbox = $new(listbox,%Widget)
-			%Widget->%listbox->$setGeometry(10,180,150,40)
-			%Widget->%listbox->$insertItem("This is another item")
-			%Widget->%listbox->$insertItem("This is a listbox's item")
-			%Widget->%listbox->$insertItem("This is a listbox")
+			%Widget->%listwidget = $new(listwidget,%Widget)
+			%Widget->%listwidget->$setGeometry(10,180,150,40)
+			%Widget->%listwidget->$insertItem("This is another item")
+			%Widget->%listwidget->$insertItem("This is a listwidget's item")
+			%Widget->%listwidget->$insertItem("This is a listwidget")
 
 			%Widget->%radiobutton = $new(radiobutton,%Widget)
 			%Widget->%radiobutton->$setGeometry(10,230,150,20)
diff --git a/src/modules/objects/class_xmlreader.cpp b/src/modules/objects/class_xmlreader.cpp
index d3f8cf8fe..4438df709 100644
--- a/src/modules/objects/class_xmlreader.cpp
+++ b/src/modules/objects/class_xmlreader.cpp
@@ -23,7 +23,7 @@
 //=============================================================================
 
 #include "class_xmlreader.h"
-
+#include "class_memorybuffer.h"
 #include "kvi_locale.h"
 
 #include "kvi_kvs_variantlist.h"
@@ -53,7 +53,7 @@
 		during the execution of [classfnc:xmlparser]$parse[/classfnc]() in an order
 		reflecting the order of elements in the parsed document.
 	@functions:
-		!fn: <boolean> $parse(<xml_data:string>)
+		!fn: <boolean> $parse(<xml_data:string_or_memorybuffer_object>)
 		Call this function to parse a string that contains an XML document.
 		A typical call for this method will look like:
 		[example]
@@ -277,8 +277,8 @@ public:
 
 
 KVSO_BEGIN_REGISTERCLASS(KviKvsObject_xmlreader,"xmlreader","object")
-	KVSO_REGISTER_HANDLER(KviKvsObject_xmlreader,"lastError",function_lastError)
-	KVSO_REGISTER_HANDLER(KviKvsObject_xmlreader,"parse",function_parse)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_xmlreader,lastError)
+	KVSO_REGISTER_HANDLER_NEW(KviKvsObject_xmlreader,parse)
 
 	KVSO_REGISTER_STANDARD_TRUERETURN_HANDLER(KviKvsObject_xmlreader,"onDocumentStart")
 	KVSO_REGISTER_STANDARD_TRUERETURN_HANDLER(KviKvsObject_xmlreader,"onDocumentEnd")
@@ -304,28 +304,60 @@ void KviKvsObject_xmlreader::fatalError(const QString &szError)
 	callFunction(this,"onError",&vArgs);
 }
 
-bool KviKvsObject_xmlreader::function_parse(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(xmlreader,parse)
 {
-	QString szString;
+	KviKvsVariant * pVariantData;
+
 	KVSO_PARAMETERS_BEGIN(c)
-		KVSO_PARAMETER("string",KVS_PT_STRING,0,szString)
+			KVSO_PARAMETER("string_or_memorybuffer_object",KVS_PT_VARIANT,0,pVariantData)
 	KVSO_PARAMETERS_END(c)
-
-#ifdef QT_NO_XML
+	#ifdef QT_NO_XML
 	fatalError(__tr2qs("XML support not available in the Qt library"));
 	c->returnValue()->setBoolean(false);
-#else
+	#else
 	m_szLastError = "";
 	KviXmlHandler handler(this);
 	QXmlInputSource source;
-	// We have a problem here.. most kvirc functions already interpret the data
-	// read from files. We should have binary data handling features to get this to work correctly.
-	// The following snippet of code tries to provide a best-effort workaround.
-	KviQCString utf8data = KviQString::toUtf8(szString);
-	QByteArray data = utf8data;
-	data.truncate(utf8data.length()); // don't include the null terminator in data
-	source.setData(data);
-	//debug("PARSING(%s) LEN(%d)",szString.toUtf8().data(),szString.toUtf8().length());
+		
+	if (pVariantData->isHObject())
+	{
+		KviKvsObject * pObject;
+		kvs_hobject_t hObject;
+		pVariantData->asHObject(hObject);
+		pObject=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
+		if (!pObject)
+		{
+			c->warning(__tr2qs("Data parameter is not an object"));
+			return true;
+		}
+		if (pObject->inherits("KviKvsObject_memorybuffer"))
+		{
+			source.setData(*((KviKvsObject_memorybuffer *)pObject)->pBuffer());
+		}
+		else
+		{
+			c->warning(__tr2qs("Data parameter is not a memorybuffer object"));
+			return true;
+		}
+	}
+	else if(pVariantData->isString())
+	{
+		QString szString;
+		pVariantData->asString(szString);
+		// We have a problem here.. most kvirc functions already interpret the data
+		// read from files. We should have binary data handling features to get this to work correctly.
+		// The following snippet of code tries to provide a best-effort workaround.
+		KviQCString utf8data = KviQString::toUtf8(szString);
+		QByteArray data = utf8data;
+		data.truncate(utf8data.length()); // don't include the null terminator in data
+		source.setData(data);
+		//debug("PARSING(%s) LEN(%d)",szString.toUtf8().data(),szString.toUtf8().length());
+	}
+	else
+	{
+		c->warning(__tr2qs("Data is not a memorybuffer object or string"));
+		return true;
+	}
 	QXmlSimpleReader reader;
 	reader.setContentHandler(&handler);
 	reader.setErrorHandler(&handler);
@@ -334,7 +366,7 @@ bool KviKvsObject_xmlreader::function_parse(KviKvsObjectFunctionCall *c)
 	return true;
 }
 
-bool KviKvsObject_xmlreader::function_lastError(KviKvsObjectFunctionCall *c)
+KVSO_CLASS_FUNCTION(xmlreader,lastError)
 {
 	c->returnValue()->setString(m_szLastError);
 	return true;
diff --git a/src/modules/objects/class_xmlreader.h b/src/modules/objects/class_xmlreader.h
index 0249fbf39..b12ac0d6d 100644
--- a/src/modules/objects/class_xmlreader.h
+++ b/src/modules/objects/class_xmlreader.h
@@ -35,8 +35,8 @@ class KviKvsObject_xmlreader : public KviKvsObject
 public:
 	KVSO_DECLARE_OBJECT(KviKvsObject_xmlreader)
 public:
-	bool function_parse(KviKvsObjectFunctionCall *c);
-	bool function_lastError(KviKvsObjectFunctionCall *c);
+	bool parse(KviKvsObjectFunctionCall *c);
+	bool lastError(KviKvsObjectFunctionCall *c);
 	
 	void fatalError(const QString &szError);
 protected:
diff --git a/src/modules/objects/libkviobjects.cpp b/src/modules/objects/libkviobjects.cpp
index 11db54be2..5a3cf5fe9 100644
--- a/src/modules/objects/libkviobjects.cpp
+++ b/src/modules/objects/libkviobjects.cpp
@@ -38,8 +38,9 @@
 #include "class_lcd.h"
 #include "class_lineedit.h"
 #include "class_list.h"
-#include "class_listbox.h"
+#include "class_listwidget.h"
 #include "class_mainwindow.h"
+#include "class_memorybuffer.h"
 #include "class_menubar.h"
 #include "class_multilineedit.h"
 #include "class_painter.h"
@@ -88,6 +89,9 @@ static bool objects_module_cleanup(KviModule *m)
 {
 	// Don't attempt to change the order of these calls.
 	// Derived classes must be unregistered before the base ones.
+	
+	KviKvsObject_memorybuffer::unregisterSelf();
+	
 	KviKvsObject_process::unregisterSelf();
 	KviKvsObject_ftp::unregisterSelf();
 	KviKvsObject_http::unregisterSelf();
@@ -111,7 +115,7 @@ static bool objects_module_cleanup(KviModule *m)
 	KviKvsObject_mainwindow::unregisterSelf();
 	KviKvsObject_treewidgetitem::unregisterSelf();
 	KviKvsObject_treewidget::unregisterSelf();
-	KviKvsObject_listbox::unregisterSelf();
+	KviKvsObject_listwidget::unregisterSelf();
 	KviKvsObject_combobox::unregisterSelf();
 	KviKvsObject_workspace::unregisterSelf();
 	KviKvsObject_menubar::unregisterSelf();
@@ -970,7 +974,7 @@ static bool objects_module_init(KviModule * m)
 	KviKvsObject_menubar::registerSelf();
 	KviKvsObject_workspace::registerSelf();
 	KviKvsObject_combobox::registerSelf();
-	KviKvsObject_listbox::registerSelf();
+	KviKvsObject_listwidget::registerSelf();
 	KviKvsObject_treewidget::registerSelf();
 	KviKvsObject_treewidgetitem::registerSelf();
 	KviKvsObject_mainwindow::registerSelf();
@@ -995,6 +999,7 @@ static bool objects_module_init(KviModule * m)
 	KviKvsObject_ftp::registerSelf();
 
 	KviKvsObject_process::registerSelf();
+	KviKvsObject_memorybuffer::registerSelf();
 
 	return true;
 }
diff --git a/src/modules/objects/object_macros.h b/src/modules/objects/object_macros.h
index 23af8c578..86e62701e 100644
--- a/src/modules/objects/object_macros.h
+++ b/src/modules/objects/object_macros.h
@@ -44,6 +44,11 @@
 #define KVSO_REGISTER_HANDLER(__className,__szName,__proc) \
 	g_pKvs##__className##Class->registerFunctionHandler(__szName,(KviKvsObjectFunctionHandlerProc)(KVI_PTR2MEMBER(__className::__proc)));
 
+// TEST
+#define KVSO_REGISTER_HANDLER_NEW(__className,__szName) \
+	g_pKvs##__className##Class->registerFunctionHandler("##__szName##",(KviKvsObjectFunctionHandlerProc)(KVI_PTR2MEMBER(__className::__szName)));
+
+
 #define KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(__className,__szName) \
 	g_pKvs##__className##Class->registerStandardNothingReturnFunctionHandler(__szName);
 
@@ -89,6 +94,9 @@
 
 #define KVSO_END_DESTRUCTOR(__className) \
 	}
-
-
+#define KVSO_CLASS_FUNCTION(__className,__functionName)\
+	bool KviKvsObject_##__className##::##__functionName##(KviKvsObjectFunctionCall *c)
+#define CHECK_INTERNAL_QPOINTER(__pointer)\
+	if (!__pointer) {c->error(__tr2qs("Internal error: no valid pointer for this object"));return false;}
 #endif
+
diff --git a/src/modules/objects/objects_QT4_vc05.vcproj b/src/modules/objects/objects_QT4_vc05.vcproj
index 989819623..ff61fb11a 100644
--- a/src/modules/objects/objects_QT4_vc05.vcproj
+++ b/src/modules/objects/objects_QT4_vc05.vcproj
@@ -273,7 +273,7 @@
 				>
 			</File>
 			<File
-				RelativePath=".\class_listbox.cpp"
+				RelativePath=".\class_listwidget.cpp"
 				>
 			</File>
 			<File
@@ -281,6 +281,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\class_memorybuffer.cpp"
+				>
+			</File>
+			<File
 				RelativePath=".\class_menubar.cpp"
 				>
 			</File>
@@ -548,7 +552,7 @@
 					>
 					<Tool
 						Name="VCCustomBuildTool"
-						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;"
+						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;&#x0D;&#x0A;"
 						Outputs="$(InputDir)\m_$(InputName).moc"
 					/>
 				</FileConfiguration>
@@ -596,7 +600,7 @@
 					>
 					<Tool
 						Name="VCCustomBuildTool"
-						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;"
+						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;&#x0D;&#x0A;"
 						Outputs="$(InputDir)\m_$(InputName).moc"
 					/>
 				</FileConfiguration>
@@ -712,7 +716,7 @@
 				</FileConfiguration>
 			</File>
 			<File
-				RelativePath=".\class_listbox.h"
+				RelativePath=".\class_listwidget.h"
 				>
 				<FileConfiguration
 					Name="Debug|Win32"
@@ -756,6 +760,19 @@
 				</FileConfiguration>
 			</File>
 			<File
+				RelativePath=".\class_memorybuffer.h"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCustomBuildTool"
+						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;&#x0D;&#x0A;"
+						Outputs="$(InputDir)\m_$(InputName).moc"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
 				RelativePath=".\class_menubar.h"
 				>
 				<FileConfiguration
@@ -1102,7 +1119,7 @@
 					>
 					<Tool
 						Name="VCCustomBuildTool"
-						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;"
+						CommandLine="$(QTDIR)\bin\moc -o &quot;$(InputDir)\m_$(InputName).moc&quot; &quot;$(InputDir)\$(InputFileName)&quot;&#x0D;&#x0A;"
 						Outputs="$(InputDir)\m_$(InputName).moc"
 					/>
 				</FileConfiguration>