Implementation feature #882 (work in progress)

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

17 files changed, 242 insertions, 77 deletions

diff --git a/src/kvirc/kvs/kvi_kvs_object.cpp b/src/kvirc/kvs/kvi_kvs_object.cpp
index 183f8aa1c..73e4447cf 100644
--- a/src/kvirc/kvs/kvi_kvs_object.cpp
+++ b/src/kvirc/kvs/kvi_kvs_object.cpp
@@ -1712,7 +1712,7 @@ void KviKvsObject::registerPrivateImplementation(const QString &szFunctionName,c
 		szContext += "[privateimpl]::";
 		szContext += szFunctionName;
 
-		m_pFunctionHandlers->replace(szFunctionName,new KviKvsObjectScriptFunctionHandler(szContext,szCode));
+                m_pFunctionHandlers->replace(szFunctionName,new KviKvsObjectScriptFunctionHandler(szContext,szCode,QString("")));
 	}
 }
 
diff --git a/src/kvirc/kvs/kvi_kvs_object_class.cpp b/src/kvirc/kvs/kvi_kvs_object_class.cpp
index bff940176..8e3624cb0 100644
--- a/src/kvirc/kvs/kvi_kvs_object_class.cpp
+++ b/src/kvirc/kvs/kvi_kvs_object_class.cpp
@@ -97,12 +97,12 @@ void KviKvsObjectClass::registerFunctionHandler(const QString & szFunctionName,K
 	m_pFunctionHandlers->replace(szFunctionName,new KviKvsObjectCoreCallFunctionHandler(pProc,uFlags));
 }
 
-void KviKvsObjectClass::registerFunctionHandler(const QString & szFunctionName,const QString &szBuffer,unsigned int uFlags)
+void KviKvsObjectClass::registerFunctionHandler(const QString & szFunctionName,const QString &szBuffer,const QString &szReminder,unsigned int uFlags)
 {
 	QString szContext = m_szName;
 	szContext += "::";
 	szContext += szFunctionName;
-	m_pFunctionHandlers->replace(szFunctionName,new KviKvsObjectScriptFunctionHandler(szContext,szBuffer,uFlags));
+        m_pFunctionHandlers->replace(szFunctionName,new KviKvsObjectScriptFunctionHandler(szContext,szBuffer,szReminder,uFlags));
 }
 
 void KviKvsObjectClass::registerStandardNothingReturnFunctionHandler(const QString &szFunctionName)
@@ -193,7 +193,7 @@ bool KviKvsObjectClass::save(const QString &szFileName)
 			szBuffer += "internal ";
 			szBuffer += "function ";
 			szBuffer += it.currentKey();
-			szBuffer += "()\n";
+                        szBuffer += "("+h->reminder()+")\n";
 			QString szCode = h->scriptHandlerCode();
 			KviCommandFormatter::blockFromBuffer(szCode);
 			KviCommandFormatter::indent(szCode);
@@ -212,7 +212,14 @@ void KviKvsObjectClass::getFunctionCode(QString &szCode,KviKvsObjectFunctionHand
 	szCode=h.scriptHandlerCode();
 }
 
-
+void KviKvsObjectClass::setReminder(const QString &szReminder,KviKvsObjectFunctionHandler *h)
+{
+        h->setReminder(szReminder);
+}
+QString KviKvsObjectClass::reminder(KviKvsObjectFunctionHandler *h)
+{
+        return h->reminder();
+}
 
 bool KviKvsObjectClass::load(const QString &szFileName)
 {
diff --git a/src/kvirc/kvs/kvi_kvs_object_class.h b/src/kvirc/kvs/kvi_kvs_object_class.h
index 2de64a9bc..c5dc20a9f 100644
--- a/src/kvirc/kvs/kvi_kvs_object_class.h
+++ b/src/kvirc/kvs/kvi_kvs_object_class.h
@@ -81,11 +81,15 @@ public:
             if (pFunctionHandler) return pFunctionHandler->isScriptHandler();
             else return false;
         };
+        void setReminder(const QString &szReminder,KviKvsObjectFunctionHandler *h);
+        QString reminder(KviKvsObjectFunctionHandler *h);
+
+
 	const QString & name(){ return m_szName; };
 	KviKvsObjectClass * parentClass(){ return m_pParentClass; };
 	// pProc CAN'T be zero here!
 	void registerFunctionHandler(const QString & szFunctionName,KviKvsObjectFunctionHandlerProc pProc,unsigned int uFlags = 0);
-	void registerFunctionHandler(const QString & szFunctionName,const QString &szBuffer,unsigned int uFlags = 0);
+        void registerFunctionHandler(const QString & szFunctionName,const QString &szBuffer,const QString &szReminder,unsigned int uFlags = 0);
 
 	// registers an empty handler that returns "nothing"
 	void registerStandardNothingReturnFunctionHandler(const QString & szFunc);
diff --git a/src/kvirc/kvs/kvi_kvs_object_functionhandler.cpp b/src/kvirc/kvs/kvi_kvs_object_functionhandler.cpp
index 543ce1477..49e84f1c5 100644
--- a/src/kvirc/kvs/kvi_kvs_object_functionhandler.cpp
+++ b/src/kvirc/kvs/kvi_kvs_object_functionhandler.cpp
@@ -45,6 +45,14 @@ QString KviKvsObjectFunctionHandler::scriptHandlerCode()
 {
 	return QString();
 }
+QString KviKvsObjectFunctionHandler::reminder()
+{
+        return QString();
+}
+void KviKvsObjectFunctionHandler::setReminder(const QString &)
+{
+}
+
 bool KviKvsObjectFunctionHandler::isClone()
 {
 	return m_bClone;
diff --git a/src/kvirc/kvs/kvi_kvs_object_functionhandler.h b/src/kvirc/kvs/kvi_kvs_object_functionhandler.h
index e7b9b9f76..e5d6626fb 100644
--- a/src/kvirc/kvs/kvi_kvs_object_functionhandler.h
+++ b/src/kvirc/kvs/kvi_kvs_object_functionhandler.h
@@ -52,7 +52,9 @@ public:
 protected:
 	virtual bool isScriptHandler();
 	virtual QString scriptHandlerCode();
-	virtual KviKvsObjectFunctionHandler * clone() = 0;
+	virtual QString reminder();
+        virtual void setReminder(const QString &szReminder);
+        virtual KviKvsObjectFunctionHandler * clone() = 0;
 	virtual bool call(KviKvsObject * pObject,KviKvsObjectFunctionCall * pCall) = 0;
 };
 
diff --git a/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.cpp b/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.cpp
index 61c050b5c..583c84257 100644
--- a/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.cpp
+++ b/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.cpp
@@ -102,10 +102,11 @@ bool KviKvsObjectCoreCallFunctionHandler::call(KviKvsObject * pObject,KviKvsObje
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-KviKvsObjectScriptFunctionHandler::KviKvsObjectScriptFunctionHandler(const QString &szScriptContext,const QString &szCode,unsigned int uFlags)
+KviKvsObjectScriptFunctionHandler::KviKvsObjectScriptFunctionHandler(const QString &szScriptContext,const QString &szCode,const QString &szReminder,unsigned int uFlags)
 : KviKvsObjectFunctionHandler(uFlags)
 {
 	m_pHandler = new KviKvsScript(szScriptContext,szCode,KviKvsScript::InstructionList);
+        m_szReminder = szReminder;
 }
 
 KviKvsObjectScriptFunctionHandler::KviKvsObjectScriptFunctionHandler(const KviKvsObjectScriptFunctionHandler &h)
@@ -129,6 +130,10 @@ QString KviKvsObjectScriptFunctionHandler::scriptHandlerCode()
 {
 	return m_pHandler->code();
 }
+QString KviKvsObjectScriptFunctionHandler::reminder()
+{
+        return m_szReminder;
+}
 
 KviKvsObjectFunctionHandler * KviKvsObjectScriptFunctionHandler::clone()
 {
diff --git a/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.h b/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.h
index 527be32be..542b633e7 100644
--- a/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.h
+++ b/src/kvirc/kvs/kvi_kvs_object_functionhandlerimpl.h
@@ -57,16 +57,20 @@ class KVIRC_API KviKvsObjectScriptFunctionHandler : public KviKvsObjectFunctionH
 	friend class KviKvsObject;
 	friend class KviKvsObjectClass;
 protected:
-	KviKvsObjectScriptFunctionHandler(const QString &szScriptContext,const QString &szCode,unsigned int uFlags = 0);
+        KviKvsObjectScriptFunctionHandler(const QString &szScriptContext,const QString &szCode,const QString &szReminder,unsigned int uFlags = 0);
 	KviKvsObjectScriptFunctionHandler(const KviKvsObjectScriptFunctionHandler &h);
 public:
 	virtual ~KviKvsObjectScriptFunctionHandler();
 protected:
 	KviKvsScript * m_pHandler;
+        QString m_szReminder;
 protected:
 	virtual bool isScriptHandler();
 	virtual QString scriptHandlerCode();
-	virtual KviKvsObjectFunctionHandler * clone();
+        virtual QString reminder();
+        virtual void setReminder(const QString &szReminder){m_szReminder=szReminder;};
+
+        virtual KviKvsObjectFunctionHandler * clone();
 	virtual bool call(KviKvsObject * pObject,KviKvsObjectFunctionCall * pCall);
 };
 
diff --git a/src/kvirc/kvs/kvi_kvs_parser_specialcommands.cpp b/src/kvirc/kvs/kvi_kvs_parser_specialcommands.cpp
index fbaf973dd..f0b6cf2dc 100644
--- a/src/kvirc/kvs/kvi_kvs_parser_specialcommands.cpp
+++ b/src/kvirc/kvs/kvi_kvs_parser_specialcommands.cpp
@@ -544,11 +544,13 @@ KviKvsTreeNodeCommand * KviKvsParser::parseSpecialCommandClass()
 			delete pClass;
 			return 0;
 		}
-
+                QString szReminder;
 		if(KVSP_curCharUnicode == '(')
 		{
-			while((!(KVSP_curCharIsEndOfBuffer)) && (KVSP_curCharUnicode != ')'))
-				KVSP_skipChar;
+                        KVSP_skipChar;
+                        const QChar * pReminderBegin = KVSP_curCharPointer;
+                        while((!(KVSP_curCharIsEndOfBuffer)) && (KVSP_curCharUnicode != ')'))
+                        KVSP_skipChar;
 
 			if(KVSP_curCharIsEndOfBuffer)
 			{
@@ -556,7 +558,7 @@ KviKvsTreeNodeCommand * KviKvsParser::parseSpecialCommandClass()
 				delete pClass;
 				return 0;
 			}
-
+                        szReminder = QString(pReminderBegin,KVSP_curCharPointer - pReminderBegin);
 			KVSP_skipChar;
 
 			if(!skipSpacesAndNewlines())
@@ -600,7 +602,7 @@ KviKvsTreeNodeCommand * KviKvsParser::parseSpecialCommandClass()
 			KviCommandFormatter::bufferFromBlock(szInstruction);
 		}
 
-		pClass->addFunctionDefinition(new KviKvsTreeNodeSpecialCommandClassFunctionDefinition(pLabelBegin,szLabel,szInstruction,uHandlerFlags));
+                pClass->addFunctionDefinition(new KviKvsTreeNodeSpecialCommandClassFunctionDefinition(pLabelBegin,szLabel,szInstruction,szReminder,uHandlerFlags));
 
 		if(!skipSpacesAndNewlines())
 		{
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.cpp b/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.cpp
index ccc9e8e6b..8d1772413 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.cpp
+++ b/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.cpp
@@ -29,11 +29,12 @@
 #include "kvi_kvs_object_controller.h"
 #include "kvi_kvs_object_class.h"
 
-KviKvsTreeNodeSpecialCommandClassFunctionDefinition::KviKvsTreeNodeSpecialCommandClassFunctionDefinition(const QChar * pLocation,const QString &szName,const QString &szBuffer,unsigned int uHandlerFlags)
+KviKvsTreeNodeSpecialCommandClassFunctionDefinition::KviKvsTreeNodeSpecialCommandClassFunctionDefinition(const QChar * pLocation,const QString &szName,const QString &szBuffer,const QString &szReminder,unsigned int uHandlerFlags)
 : KviKvsTreeNode(pLocation)
 {
 	m_uHandlerFlags = uHandlerFlags;
 	m_szName = szName;
+        m_szReminder = szReminder;
 	m_szBuffer = szBuffer;
 }
 
@@ -156,7 +157,7 @@ bool KviKvsTreeNodeSpecialCommandClass::execute(KviKvsRunTimeContext * c)
 
 	for(KviKvsTreeNodeSpecialCommandClassFunctionDefinition * d = m_pFunctions->first();d;d = m_pFunctions->next())
 	{
-		pActualClass->registerFunctionHandler(d->name(),d->buffer(),d->handlerFlags());
+                pActualClass->registerFunctionHandler(d->name(),d->buffer(),d->reminder(),d->handlerFlags());
 	}
 	return true;
 }
diff --git a/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.h b/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.h
index 9507c5fcc..b8bec5945 100644
--- a/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.h
+++ b/src/kvirc/kvs/kvi_kvs_treenode_specialcommandclass.h
@@ -35,15 +35,17 @@ class KviKvsRunTimeContext;
 class KVIRC_API KviKvsTreeNodeSpecialCommandClassFunctionDefinition : public KviKvsTreeNode
 {
 public:
-	KviKvsTreeNodeSpecialCommandClassFunctionDefinition(const QChar * pLocation,const QString &szName,const QString &szBuffer,unsigned int uHandlerFlags);
-	virtual ~KviKvsTreeNodeSpecialCommandClassFunctionDefinition(){};
+        KviKvsTreeNodeSpecialCommandClassFunctionDefinition(const QChar * pLocation,const QString &szName,const QString &szBuffer, const QString &szReminder,unsigned int uHandlerFlags);
+        virtual ~KviKvsTreeNodeSpecialCommandClassFunctionDefinition(){};
 protected:
 	QString m_szName;
+        QString m_szReminder;
 	QString m_szBuffer;
 	unsigned int m_uHandlerFlags;
 public:
 	unsigned int handlerFlags(){ return m_uHandlerFlags; };
 	const QString & name(){ return m_szName; };
+        const QString & reminder(){ return m_szReminder; };
 	const QString & buffer(){ return m_szBuffer; };
 	virtual void contextDescription(QString &szBuffer);
 	virtual void dump(const char * prefix);
@@ -55,7 +57,7 @@ class KVIRC_API KviKvsTreeNodeSpecialCommandClass : public KviKvsTreeNodeSpecial
 {
 public:
 	KviKvsTreeNodeSpecialCommandClass(const QChar * pLocation,KviKvsTreeNodeDataList * pParams);
-	virtual ~KviKvsTreeNodeSpecialCommandClass();
+        virtual ~KviKvsTreeNodeSpecialCommandClass();
 protected:
 	KviKvsTreeNodeDataList * m_pParams;
 	KviPointerList<KviKvsTreeNodeSpecialCommandClassFunctionDefinition> * m_pFunctions;
diff --git a/src/kvirc/ui/kvi_scripteditor.cpp b/src/kvirc/ui/kvi_scripteditor.cpp
index 021ac7e65..4051b3ad8 100644
--- a/src/kvirc/ui/kvi_scripteditor.cpp
+++ b/src/kvirc/ui/kvi_scripteditor.cpp
@@ -63,7 +63,12 @@ void KviScriptEditor::setInfoText(const QString &)
 void KviScriptEditor::setFindLineeditReadOnly(bool)
 {
 }
-
+void KviScriptEditor::setReadOnly(bool)
+{
+}
+void KviScriptEditor::setUnHighlightedText(const QString & szText)
+{
+}
 void KviScriptEditor::getText(QByteArray &)
 {
 }
diff --git a/src/kvirc/ui/kvi_scripteditor.h b/src/kvirc/ui/kvi_scripteditor.h
index 138f30600..8a730e4e2 100644
--- a/src/kvirc/ui/kvi_scripteditor.h
+++ b/src/kvirc/ui/kvi_scripteditor.h
@@ -58,9 +58,11 @@ public:
 	virtual void setInfoText(const QString &text);
 	virtual void setFindText(const QString &text);
 	virtual void setCursorPosition(int);
+	virtual void setReadOnly(bool bReadonly);
 	virtual int getCursor();
 	virtual void setFindLineeditReadOnly(bool b);
 	virtual bool isModified();
+	virtual void setUnHighlightedText(const QString & szText);
 	virtual void setModified(bool){};
 	static KviScriptEditor * getDummyEditor(QWidget * par);
 	static KviScriptEditor * createInstance(QWidget * par);
diff --git a/src/modules/classeditor/classeditor.cpp b/src/modules/classeditor/classeditor.cpp
index a1f739d35..a4c21a54f 100644
--- a/src/modules/classeditor/classeditor.cpp
+++ b/src/modules/classeditor/classeditor.cpp
@@ -185,15 +185,16 @@ KviClassEditor::KviClassEditor(QWidget * par)
 	hbox = new KviTalHBox(box);
 	hbox->setSpacing(0);
 	hbox->setMargin(0);
-	m_pMemberFunctionNameLabel = new QLabel(__tr2qs_ctx("No item selected","editor"),hbox);
-	m_pMemberFunctionNameRenameButton = new QPushButton(__tr2qs_ctx("Rename","editor"),hbox);
-	m_pMemberFunctionNameRenameButton->setEnabled(false);
-	connect(m_pMemberFunctionNameRenameButton,SIGNAL(clicked()),this,SLOT(renameFunction()));
-	hbox->setStretchFactor(m_pMemberFunctionNameLabel,2);
-	m_pMemberFunctionNameRenameButton->setToolTip(__tr2qs_ctx("Edit the function member name","editor"));
-
-
+        m_pFunctionNameLabel = new QLabel(__tr2qs_ctx("No item selected","editor"),hbox);
+        m_pFunctionNameRenameButton = new QPushButton(__tr2qs_ctx("Rename","editor"),hbox);
+        m_pFunctionNameRenameButton->setEnabled(false);
+        connect(m_pFunctionNameRenameButton,SIGNAL(clicked()),this,SLOT(renameFunction()));
+        hbox->setStretchFactor(m_pFunctionNameLabel,2);
+        m_pFunctionNameRenameButton->setToolTip(__tr2qs_ctx("Edit the function member name","editor"));
 
+        m_pReminderLabel = new QLabel(__tr2qs_ctx("No item selected","editor"),box);
+        m_pReminderLabel->hide();
+        m_pReminderLabel->setWordWrap(1);
 	m_pEditor = KviScriptEditor::createInstance(box);
 	m_pEditor->setFocus();
 
@@ -404,7 +405,8 @@ void KviClassEditor::createFullClass(KviKvsObjectClass *pClass, KviClassEditorTr
 			if(!pFunctionItem) pFunctionItem = new KviClassEditorTreeWidgetItem(pClassItem,KviClassEditorTreeWidgetItem::Method,it.currentKey());
 			pClass->getFunctionCode(szCode,*handler);
 			pFunctionItem->setBuffer(szCode);
-			if(handler->flags() & KviKvsObjectFunctionHandler::Internal) pFunctionItem->setInternalFunction(true);
+                        pFunctionItem->setReminder(pClass->reminder(handler));
+                        if(handler->flags() & KviKvsObjectFunctionHandler::Internal) pFunctionItem->setInternalFunction(true);
 		}
 		++it;
 	}
@@ -453,14 +455,38 @@ void KviClassEditor::renameFunction()
 {
 	if(!m_pLastEditedItem)return;
 	KviClassEditorTreeWidgetItem *pFunction=m_pLastEditedItem;
-	QString szClassName = ((KviClassEditorTreeWidgetItem*)pFunction->parent())->name();
+        QString szClassName = buildFullClassName((KviClassEditorTreeWidgetItem*)pFunction->parent());
 	QString szFunctionName = pFunction->name();
+        QString szReminder = pFunction->reminder();
+        QString szNewReminder=szReminder;
 	KviClassEditorTreeWidgetItem *pParentClass = (KviClassEditorTreeWidgetItem*) pFunction->parent();
 
 	QString szNewFunctionName = szFunctionName;
 	bool bInternal=pFunction->isInternalFunction();
-	if(!askForFunction(szNewFunctionName, &bInternal,szClassName, true)) return;
-	if(KviQString::equalCI(szFunctionName,szNewFunctionName) && bInternal==pFunction->isInternalFunction()) return;
+        if(!askForFunction(szNewFunctionName,szNewReminder,&bInternal,szClassName, true)) return;
+        if(KviQString::equalCI(szFunctionName,szNewFunctionName) && bInternal==pFunction->isInternalFunction())
+        {
+           if(!KviQString::equalCI(szNewReminder,szReminder))
+           {
+                pFunction->setReminder(szNewReminder);
+                KviKvsObjectClass *pClass = KviKvsKernel::instance()->objectController()->lookupClass(szClassName);
+                if (pClass){
+                    KviKvsObjectFunctionHandler *pHandler=pClass->lookupFunctionHandler(szFunctionName);
+                    if (pHandler){
+                        pClass->setReminder(szNewReminder,pHandler);
+                        QString szPath;
+                        QString szFileName = szClassName.toLower();
+                        szFileName += ".kvs";
+                        szFileName.replace("::","--");
+                        g_pApp->getLocalKvircDirectory(szPath,KviApp::Classes,szFileName);
+                        pClass->save(szPath);
+                    }
+                }
+                currentItemChanged(pFunction,pFunction);
+
+            }
+           return;
+        }
 	if (findFunction(szNewFunctionName,pParentClass) && !KviQString::equalCI(szFunctionName,szNewFunctionName))
 	{
 		g_pClassEditorModule->lock();
@@ -472,7 +498,8 @@ void KviClassEditor::renameFunction()
 		return;
 	}
 	pFunction->setName(szNewFunctionName);
-	currentItemChanged(pFunction,pFunction);
+        pFunction->setReminder(szNewReminder);
+        currentItemChanged(pFunction,pFunction);
 	pFunction->setInternalFunction(bInternal);
 	pParentClass->setClassNotBuilt(true);
 	KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
@@ -653,7 +680,7 @@ void KviClassEditor::renameNamespace(KviClassEditorTreeWidgetItem *pOldNamespace
 
 	if (pNewItem)
 	{
-		activateItem(pNewItem);
+                activateItem(pNewItem);
 		pNewItem->setExpanded(true);
 	} else {
 		activateItem(pOldNamespaceItem);
@@ -685,6 +712,14 @@ void KviClassEditor::currentItemChanged(QTreeWidgetItem * it, QTreeWidgetItem *)
 		m_pEditor->setEnabled(false);
 		return;
 	}
+/*	szLabelText += m_pLastEditedItem->text(0);
+	szLabelText += "</b>";
+	m_pFunctionNameRenameButton->setEnabled(true);
+	if(!m_pLastEditedItem->reminder().isEmpty())
+	szLabelText += m_pLastEditedItem->text(0);
+	szLabelText += "</b>";
+	m_pFunctionNameRenameButton->setEnabled(true);
+	if(!m_pLastEditedItem->reminder().isEmpty())*/
 	KviClassEditorTreeWidgetItem * pClassItem;
 	if(m_pLastEditedItem->isMethod()) pClassItem=(KviClassEditorTreeWidgetItem *)m_pLastEditedItem->parent();
 	else pClassItem=m_pLastEditedItem;
@@ -697,9 +732,9 @@ void KviClassEditor::currentItemChanged(QTreeWidgetItem * it, QTreeWidgetItem *)
 		szLabelText += "</b>";
 		m_pClassNameLabel->setText(szLabelText);
 		m_pClassNameRenameButton->setEnabled(true);
-		m_pMemberFunctionNameRenameButton->setEnabled(false);
+                m_pFunctionNameRenameButton->setEnabled(false);
 		m_pInheritsClassNameLabel->setText("");
-		m_pMemberFunctionNameLabel->setText("");
+                m_pFunctionNameLabel->setText("");
 		m_pEditor->setText("");
 		m_pEditor->setEnabled(false);
 		m_pTreeWidget->setFocus();
@@ -723,19 +758,46 @@ void KviClassEditor::currentItemChanged(QTreeWidgetItem * it, QTreeWidgetItem *)
 		szLabelText += ": <b>";
 		szLabelText += m_pLastEditedItem->text(0);
 		szLabelText += "</b>";
-		m_pMemberFunctionNameRenameButton->setEnabled(true);
-	}
-	else m_pClassNameRenameButton->setEnabled(true);
-	m_pMemberFunctionNameLabel->setText(szLabelText);
-	if(m_pLastEditedItem->isClass())
+                m_pFunctionNameRenameButton->setEnabled(true);
+                if(!m_pLastEditedItem->reminder().isEmpty())
+                {
+                        QString szReminderText =__tr2qs_ctx("Reminder text.","editor");
+                        szReminderText += ": <b>";
+                        szReminderText += m_pLastEditedItem->reminder();
+                        szReminderText += "</b>";
+			m_pReminderLabel->setText(szReminderText);
+                        m_pReminderLabel->show();
+                 }
+                 else m_pReminderLabel->hide();
+		 m_pFunctionNameLabel->setText(szLabelText);
+		 m_pFunctionNameLabel->show();
+		 m_pFunctionNameRenameButton->show();
+        }
+        else{
+            m_pReminderLabel->hide();
+	    m_pFunctionNameLabel->hide();
+            m_pClassNameRenameButton->setEnabled(true);
+	    m_pFunctionNameRenameButton->hide();
+        }
+//        m_pFunctionNameLabel->setText(szLabelText);
+        if(m_pLastEditedItem->isClass())
 	{
-		m_pMemberFunctionNameRenameButton->setEnabled(false);
+                m_pFunctionNameRenameButton->setEnabled(false);
 		m_pEditor->setText("");
-		m_pEditor->setEnabled(false);
+		m_pEditor->setEnabled(true);
 		m_pTreeWidget->setFocus();
+		QString szBuffer;
+		for(int i=0;i<it->childCount();i++)
+		{
+		    KviClassEditorTreeWidgetItem *item=((KviClassEditorTreeWidgetItem *)it->child(i));
+		    szBuffer+="Member Function: <b>$"+item->name()+"</b><br>";
+		    szBuffer+="Parameters reminder: "+item->reminder()+"<br><br>";
+		}
+		m_pEditor->setUnHighlightedText(szBuffer);
+		m_pEditor->setReadOnly(true);
 		return;
 	}
-
+	m_pEditor->setReadOnly(false);
 	m_pEditor->setText(((KviClassEditorTreeWidgetItem *)it)->buffer());
 	m_pEditor->setFocus();
 	m_pEditor->setCursorPosition(((KviClassEditorTreeWidgetItem *)it)->cursorPosition());
@@ -931,7 +993,8 @@ void KviClassEditor::getExportClassBuffer(QString &buffer,KviClassEditorTreeWidg
 			if (pFunction->isInternalFunction()) buffer+="internal ";
 			buffer += "function ";
 			buffer += pFunction->name();
-			buffer += "\n\t{\n";
+                        buffer += "("+pFunction->reminder()+")";
+                        buffer += "\n\t{\n";
 			buffer += pFunction->buffer();
 			buffer += "\n\t}\n";
 		}
@@ -1280,9 +1343,9 @@ bool KviClassEditor::askForClassName(QString &szClassName,QString &szInheritsCla
 	return false;
 }
 
-bool KviClassEditor::askForFunction(QString &szFunctionName,bool * bInternal,const QString &szClassName, bool bRenameMode)
+bool KviClassEditor::askForFunction(QString &szFunctionName,QString &szReminder,bool * bInternal,const QString &szClassName, bool bRenameMode)
 {
-	KviClassEditorFunctionDialog *pDialog=new KviClassEditorFunctionDialog(this,"function",szClassName,szFunctionName, *bInternal, bRenameMode);
+        KviClassEditorFunctionDialog *pDialog=new KviClassEditorFunctionDialog(this,"function",szClassName,szFunctionName,szReminder,*bInternal, bRenameMode);
 	szFunctionName="";
 	g_pClassEditorModule->lock();
 	bool bOk=pDialog->exec();
@@ -1290,7 +1353,8 @@ bool KviClassEditor::askForFunction(QString &szFunctionName,bool * bInternal,con
 	if(bOk)
 	{
 		szFunctionName=pDialog->getFunctionName();
-		*bInternal=pDialog->isInternalFunction();
+                szReminder=pDialog->getReminder();
+                *bInternal=pDialog->isInternalFunction();
 		delete pDialog;
 		return true;
 	}
@@ -1406,15 +1470,16 @@ void KviClassEditor::newNamespace()
 
 void KviClassEditor::newMemberFunction()
 {
-	QString szFunctionName,szClassName;
+        QString szFunctionName,szClassName,szReminder;
 	if(m_pLastClickedItem->isMethod()) m_pLastClickedItem= (KviClassEditorTreeWidgetItem*)m_pLastClickedItem->parent();
 	szClassName=buildFullClassName(m_pLastClickedItem);
 	bool bInternal= false;
-	if(!askForFunction(szFunctionName, &bInternal,szClassName, false)) return;
+        if(!askForFunction(szFunctionName, szReminder,&bInternal,szClassName, false)) return;
 	if(szFunctionName.isEmpty())return;
-	KviClassEditorTreeWidgetItem *it=newItem(szFunctionName,KviClassEditorTreeWidgetItem::Method);
+        KviClassEditorTreeWidgetItem *it=newItem(szFunctionName,KviClassEditorTreeWidgetItem::Method);
 	it->setInternalFunction(bInternal);
-	activateItem(it);
+        if(!szReminder.isEmpty()) it->setReminder(szReminder);
+        activateItem(it);
 	((KviClassEditorTreeWidgetItem*)it->parent())->setClassNotBuilt(true);
 }
 
@@ -1433,9 +1498,8 @@ KviClassEditorTreeWidgetItem *  KviClassEditor::newItem(QString &szName,KviClass
 		idx++;
 	}
 	KviClassEditorTreeWidgetItem * it;
-	it=createFullItem(szName);
+        it=createFullItem(szName);
 	it->setType(eType);
-
 	return it;
 }
 
@@ -1555,15 +1619,20 @@ void KviClassEditor::loadNotBuiltClasses()
 			}
 			for(QString * s = names.first(); s; s = names.next())
 			{
+
 				if (KviQString::equalCI(*s,"@Inherits"))
 				{
 					pClassItem->setInheritsClass(cfg.readQStringEntry(*s,""));
 					continue;
 				}
-				QString szCode = cfg.readQStringEntry(*s,"");
+                                if ((*s).left(9)=="@Reminder") continue;
+                                QString szCode = cfg.readQStringEntry(*s,"");
 				KviClassEditorTreeWidgetItem *pFunctionItem=findFunction(*s, pClassItem);
 				if(!pFunctionItem) pFunctionItem = new KviClassEditorTreeWidgetItem(pClassItem,KviClassEditorTreeWidgetItem::Method,*s);
 				pFunctionItem->setBuffer(szCode);
+                                QString szEntry="@Reminder|"+(*s);
+                                QString szReminder = cfg.readQStringEntry(szEntry,"");
+                                pFunctionItem->setReminder(szReminder);
 			}
 		}
 	}
@@ -1588,9 +1657,16 @@ void KviClassEditor::saveNotBuiltClasses()
 
 			cfg.setGroup(it.currentKey());
 			cfg.writeEntry("@Inherits",it.current()->InheritsClass());
-			for(int i=0;i<it.current()->childCount();i++)
-				cfg.writeEntry(((KviClassEditorTreeWidgetItem*)it.current()->child(i))->name(),((KviClassEditorTreeWidgetItem*)it.current()->child(i))->buffer());
-		}
+                        QString szReminderEntry;
+                        for(int i=0;i<it.current()->childCount();i++){
+                            if(!((KviClassEditorTreeWidgetItem*)it.current()->child(i))->reminder().isEmpty())
+                            {
+                                szReminderEntry="@Reminder|"+((KviClassEditorTreeWidgetItem*)it.current()->child(i))->name();
+                                cfg.writeEntry(szReminderEntry,((KviClassEditorTreeWidgetItem*)it.current()->child(i))->reminder());
+                            }
+                            cfg.writeEntry(((KviClassEditorTreeWidgetItem*)it.current()->child(i))->name(),((KviClassEditorTreeWidgetItem*)it.current()->child(i))->buffer());
+                        }
+                 }
 		++it;
         }
         cfg.sync();
@@ -1796,7 +1872,7 @@ void KviClassEditorDialog::textChanged(const QString & szText)
 	m_pNewClassButton->setEnabled(!szText.isEmpty());
 }
 
-KviClassEditorFunctionDialog::KviClassEditorFunctionDialog(QWidget * pParent, const QString & szName, const QString &szClassName, const QString &szFunctionName, bool bIsInternal, bool bRenameMode)
+KviClassEditorFunctionDialog::KviClassEditorFunctionDialog(QWidget * pParent, const QString & szName, const QString &szClassName, const QString &szFunctionName, const QString &szReminder,bool bIsInternal, bool bRenameMode)
 : QDialog(pParent)
 {
 	setObjectName(szName);
@@ -1831,10 +1907,22 @@ KviClassEditorFunctionDialog::KviClassEditorFunctionDialog(QWidget * pParent, co
 	m_pFunctionNameLineEdit->setToolTip(__tr2qs_ctx("Function names can contain only letters, digits and underscores","editor"));
 	m_pFunctionNameLineEdit->setText(szFunctionName);
 
+        hbox = new KviTalHBox(this);
+        hbox->setSpacing(0);
+        hbox->setMargin(0);
+        pLayout->addWidget(hbox,2,0);
+
+        QLabel * pReminderLabel = new QLabel(hbox);
+        pReminderLabel->setObjectName("reminderlabel");
+        pReminderLabel->setWordWrap(1);
+        pReminderLabel->setText(__tr2qs_ctx("Please enter the optional reminder string for the member function:","editor"));
+
+        m_pReminderLineEdit = new QLineEdit(hbox);
+        m_pReminderLineEdit->setText(szReminder);
 	hbox = new KviTalHBox(this);
 	hbox->setSpacing(0);
 	hbox->setMargin(0);
-	pLayout->addWidget(hbox,2,0);
+        pLayout->addWidget(hbox,3,0);
 
 
 	QLabel * pFunctionInternalLabel = new QLabel(hbox);
diff --git a/src/modules/classeditor/classeditor.h b/src/modules/classeditor/classeditor.h
index 2892b8d98..ddd2cf5ab 100644
--- a/src/modules/classeditor/classeditor.h
+++ b/src/modules/classeditor/classeditor.h
@@ -58,13 +58,16 @@ protected:
 	QString m_szName;
         QString m_szBuffer;
         bool m_bClassModified, m_bInternal;
-	QString m_szInheritsClassName;
+        QString m_szInheritsClassName,m_szReminder;
         int  m_cPos;
 public:
 	void setInheritsClass(QString szInheritsClassName){m_szInheritsClassName=szInheritsClassName;};
 	QString InheritsClass(){return m_szInheritsClassName;};
 	const QString & name(){ return m_szName; };
 	void setName(const QString &szName);
+        void setReminder(const QString &szName){m_szReminder=szName;};
+        QString reminder(){return m_szReminder;};
+
         void setClassNotBuilt(bool bModified);
         bool classNotBuilt(){return m_bClassModified;};
         void setInternalFunction(bool bInternal){m_bInternal=bInternal;};
@@ -109,8 +112,9 @@ public:
         QLabel                       * m_pClassNameLabel;
 	QLabel                       * m_pInheritsClassNameLabel;
         QPushButton                  * m_pClassNameRenameButton;
-        QLabel                       * m_pMemberFunctionNameLabel;
-        QPushButton                  * m_pMemberFunctionNameRenameButton;
+        QLabel                       * m_pFunctionNameLabel;
+        QPushButton                  * m_pFunctionNameRenameButton;
+        QLabel                       * m_pReminderLabel;
 
 	KviClassEditorTreeWidgetItem * m_pLastEditedItem;
 	KviClassEditorTreeWidgetItem * m_pLastClickedItem;
@@ -184,7 +188,7 @@ protected:
         bool hasSelectedItems();
 	bool askForClassName(QString &szClassName,QString &szInheritsClassName,bool bEdit);
 	bool askForNamespaceName(const QString &szAction,const QString &szText,const QString &szInitialText, QString &szNameBuffer);
-	bool askForFunction(QString &szFunctionName,bool * bInternal, const QString &szClassName, bool bRenameMode);
+        bool askForFunction(QString &szFunctionName,QString &szReminder,bool * bInternal, const QString &szClassName, bool bRenameMode);
 	void searchInheritedClasses(const QString szClass,KviPointerList<KviClassEditorTreeWidgetItem> & lInheritsedClasses);
 	bool classExists(QString &szFullItemName);
 	void renameClass(KviClassEditorTreeWidgetItem *pClassItem);
@@ -246,15 +250,18 @@ class KviClassEditorFunctionDialog: public QDialog
 {
         Q_OBJECT
 public:
-	KviClassEditorFunctionDialog(QWidget * pParent, const QString & szName, const QString & szClassName,const QString &szFunctionName, bool bIsInternal, bool bRenameMode=false);
+        KviClassEditorFunctionDialog(QWidget * pParent, const QString & szName, const QString & szClassName,const QString &szFunctionName, const QString &szReminder,bool bIsInternal, bool bRenameMode=false);
 
         ~KviClassEditorFunctionDialog();
 public:
         QString getFunctionName(){return m_pFunctionNameLineEdit->text();};
+        QString getReminder(){return m_pReminderLineEdit->text();};
+
         bool isInternalFunction(){return m_pInternalCheckBox->isChecked();};
 protected:
         QPushButton * m_pNewFunctionButton;
         QLineEdit * m_pFunctionNameLineEdit;
+        QLineEdit * m_pReminderLineEdit;
         QCheckBox * m_pInternalCheckBox;
 protected slots:
         void textChanged(const QString &);
diff --git a/src/modules/editor/scripteditor.cpp b/src/modules/editor/scripteditor.cpp
index 7753af41c..de782add6 100644
--- a/src/modules/editor/scripteditor.cpp
+++ b/src/modules/editor/scripteditor.cpp
@@ -119,6 +119,7 @@ KviScriptEditorWidget::~KviScriptEditorWidget()
 {
 	if(m_pCompleter)
 		delete m_pCompleter;
+	disableSyntaxHighlighter();
 }
 
 void KviScriptEditorWidget::checkReadyCompleter()
@@ -272,6 +273,18 @@ void KviScriptEditorWidget::slotHelp()
 {
 	contextSensitiveHelp();
 }
+void KviScriptEditorWidget::enableSyntaxHighlighter()
+{
+	// we currently delete and re-create the m_pSyntaxHighlighter
+	// as a trick to ensure proper re-highlightning to occur
+	if (!m_pSyntaxHighlighter)
+	    m_pSyntaxHighlighter = new KviScriptEditorSyntaxHighlighter(this);
+}
+void KviScriptEditorWidget::disableSyntaxHighlighter()
+{
+	if (m_pSyntaxHighlighter) delete m_pSyntaxHighlighter;
+	m_pSyntaxHighlighter = 0;
+}
 
 void KviScriptEditorWidget::updateOptions()
 {
@@ -281,10 +294,8 @@ void KviScriptEditorWidget::updateOptions()
 	setPalette(p);
 	setFont(g_fntNormal);
 	setTextColor(g_clrNormalText);
-	// we currently delete and re-create the m_pSyntaxHighlighter
-	// as a trick to ensure proper re-highlightning to occur
-	if (m_pSyntaxHighlighter) delete m_pSyntaxHighlighter;
-	m_pSyntaxHighlighter = new KviScriptEditorSyntaxHighlighter(this);
+	disableSyntaxHighlighter();
+	enableSyntaxHighlighter();
 
 	p = ((KviScriptEditorImplementation*)m_pParent)->findLineEdit()->palette();
 	p.setColor(foregroundRole(),g_clrFind);
@@ -889,14 +900,21 @@ void KviScriptEditorImplementation::setText(const char * txt)
 {
 	setText(QByteArray(txt));
 }
-
+void KviScriptEditorImplementation::setUnHighlightedText(const QString & szText)
+{
+	m_pEditor->disableSyntaxHighlighter();
+	m_pEditor->setText(szText);
+}
 void KviScriptEditorImplementation::setText(const QByteArray & szText)
 {
-        m_pEditor->setPlainText(szText.data());
+	m_pEditor->setPlainText(szText.data());
 	m_pEditor->document()->setModified(false);
 	updateRowColLabel();
 }
-
+void KviScriptEditorImplementation::setReadOnly(bool bReadOnly)
+{
+	m_pEditor->setReadOnly(bReadOnly);
+}
 void KviScriptEditorImplementation::getText(QByteArray & szText)
 {
 	szText = m_pEditor->toPlainText().toUtf8();
@@ -904,6 +922,7 @@ void KviScriptEditorImplementation::getText(QByteArray & szText)
 
 void KviScriptEditorImplementation::setText(const QString & szText)
 {
+	m_pEditor->enableSyntaxHighlighter();
 	m_pEditor->setPlainText(szText);
 	QTextCursor cur=m_pEditor->textCursor();
 	cur.movePosition(QTextCursor::End);
diff --git a/src/modules/editor/scripteditor.h b/src/modules/editor/scripteditor.h
index cc9be301c..27c2d58e0 100644
--- a/src/modules/editor/scripteditor.h
+++ b/src/modules/editor/scripteditor.h
@@ -64,6 +64,9 @@ protected:
 	QString       m_szHelp;
 public:
 	KviScriptEditorSyntaxHighlighter * syntaxHighlighter(){return m_pSyntaxHighlighter;};
+	void disableSyntaxHighlighter();
+	void enableSyntaxHighlighter();
+
 	void createCompleter(QStringList &list);
 
 	void loadCompleterFromFile();
@@ -157,6 +160,10 @@ public:
 	virtual void getText(QByteArray & szText);
 	virtual void setFindText(const QString & szText);
 	virtual void setEnabled(bool bEnabled);
+	virtual void setReadOnly(bool bReadOnly);
+	void setUnHighlightedText(const QString & szText);
+
+
 	virtual void setFocus();
 	virtual bool isModified();
 	virtual void setModified(bool);
diff --git a/src/modules/objects/class_socket.cpp b/src/modules/objects/class_socket.cpp
index 8256fa3e2..87c54389e 100644
--- a/src/modules/objects/class_socket.cpp
+++ b/src/modules/objects/class_socket.cpp
@@ -1130,11 +1130,13 @@ void KviKvsObject_socket::readNotifierFired(int)
 	// readLength > 0
 	m_uInDataLen += readLength;
 
-
+       KviKvsVariant *param=new KviKvsVariant((kvs_int_t)readLength);
+       KviKvsVariantList *lParams=new KviKvsVariantList(param);
 	unsigned int uOldConnectionId = m_uConnectionId;
-	KviKvsVariantList lParams;
-	lParams.append(new KviKvsVariant((kvs_int_t)readLength));
-	callFunction(this,"dataAvailableEvent",&lParams);
+        callFunction(this,"dataAvailableEvent",lParams);
+        //delete param;
+        delete lParams;
+        //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)