The big rename for modules. Still some details remaining.

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

4 files changed, 247 insertions, 247 deletions

diff --git a/src/modules/classeditor/CMakeLists.txt b/src/modules/classeditor/CMakeLists.txt
index 94a459d5b..eb2d56d84 100644
--- a/src/modules/classeditor/CMakeLists.txt
+++ b/src/modules/classeditor/CMakeLists.txt
@@ -1,12 +1,12 @@
 # CMakeLists for src/modules/classeditor
 
 SET(kviclasseditor_MOC_HDRS
-	classeditor.h
+	ClassEditorWindow.h
 )
 
 SET(kviclasseditor_SRCS
 	libkviclasseditor.cpp
-	classeditor.cpp
+	ClassEditorWindow.cpp
 )
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
diff --git a/src/modules/classeditor/classeditor.cpp b/src/modules/classeditor/ClassEditorWindow.cpp
index 4d4569b0c..95ae67111 100644
--- a/src/modules/classeditor/classeditor.cpp
+++ b/src/modules/classeditor/ClassEditorWindow.cpp
@@ -1,6 +1,6 @@
 //=============================================================================
 //
-//   File : classeditor.cpp
+//   File : ClassEditorWindow.cpp
 //   Creation date : Mon Feb 15 2010 14:35:55 CEST by Carbone Alessandro
 //
 //   This file is part of the KVIrc irc client distribution
@@ -23,7 +23,7 @@
 //=============================================================================
 
 
-#include "classeditor.h"
+#include "ClassEditorWindow.h"
 
 #include "KviIconManager.h"
 #include "KviOptions.h"
@@ -62,10 +62,10 @@
 #include <QStringList>
 #include <QLabel>
 
-extern KviClassEditorWindow * g_pClassEditorWindow;
+extern ClassEditorWindow * g_pClassEditorWindow;
 extern KviModule * g_pClassEditorModule;
 
-KviClassEditorTreeWidget::KviClassEditorTreeWidget(QWidget * pParent)
+ClassEditorTreeWidget::ClassEditorTreeWidget(QWidget * pParent)
 : QTreeWidget(pParent)
 {
 	setColumnCount (1);
@@ -76,13 +76,13 @@ KviClassEditorTreeWidget::KviClassEditorTreeWidget(QWidget * pParent)
 	setAnimated(true);
 }
 
-KviClassEditorTreeWidget::~KviClassEditorTreeWidget()
+ClassEditorTreeWidget::~ClassEditorTreeWidget()
 {
 	//remove and delete all items
 	clear();
 }
 
-void KviClassEditorTreeWidget::mousePressEvent(QMouseEvent * e)
+void ClassEditorTreeWidget::mousePressEvent(QMouseEvent * e)
 {
 	if(e->button() == Qt::RightButton)
 	{
@@ -93,7 +93,7 @@ void KviClassEditorTreeWidget::mousePressEvent(QMouseEvent * e)
 	QTreeWidget::mousePressEvent(e);
 }
 
-KviClassEditorTreeWidgetItem::KviClassEditorTreeWidgetItem(QTreeWidget * pTreeWidget, Type eType, const QString & szName)
+ClassEditorTreeWidgetItem::ClassEditorTreeWidgetItem(QTreeWidget * pTreeWidget, Type eType, const QString & szName)
 : QTreeWidgetItem(pTreeWidget), KviHeapObject(), m_eType(eType)
 {
 	setName(szName);
@@ -103,7 +103,7 @@ KviClassEditorTreeWidgetItem::KviClassEditorTreeWidgetItem(QTreeWidget * pTreeWi
 	m_bClassModified      = false;
 	QPixmap * pIcon       = 0;
 	
-	if(eType == KviClassEditorTreeWidgetItem::Namespace)
+	if(eType == ClassEditorTreeWidgetItem::Namespace)
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE);
 	else
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_CLASS);
@@ -111,7 +111,7 @@ KviClassEditorTreeWidgetItem::KviClassEditorTreeWidgetItem(QTreeWidget * pTreeWi
 	setIcon(0,QIcon(*pIcon));
 }
 
-KviClassEditorTreeWidgetItem::KviClassEditorTreeWidgetItem(KviClassEditorTreeWidgetItem * pParentItem, Type eType, const QString & szName)
+ClassEditorTreeWidgetItem::ClassEditorTreeWidgetItem(ClassEditorTreeWidgetItem * pParentItem, Type eType, const QString & szName)
 : QTreeWidgetItem(pParentItem), m_eType(eType)
 {
 	setFlags(Qt::ItemIsEditable|Qt::ItemIsEnabled|Qt::ItemIsSelectable);
@@ -122,9 +122,9 @@ KviClassEditorTreeWidgetItem::KviClassEditorTreeWidgetItem(KviClassEditorTreeWid
 	m_bClassModified      = false;
 	QPixmap * pIcon       = 0;
 	
-	if(eType == KviClassEditorTreeWidgetItem::Namespace)
+	if(eType == ClassEditorTreeWidgetItem::Namespace)
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE);
-	else if(eType == KviClassEditorTreeWidgetItem::Class)
+	else if(eType == ClassEditorTreeWidgetItem::Class)
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_CLASS);
 	else
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_FUNCTION);
@@ -132,7 +132,7 @@ KviClassEditorTreeWidgetItem::KviClassEditorTreeWidgetItem(KviClassEditorTreeWid
 	setIcon(0,QIcon(*pIcon));
 }
 
-void KviClassEditorTreeWidgetItem::setClassNotBuilt(bool bModified)
+void ClassEditorTreeWidgetItem::setClassNotBuilt(bool bModified)
 {
 	m_bClassModified = bModified;
 	QPixmap * pIcon = 0;
@@ -145,20 +145,20 @@ void KviClassEditorTreeWidgetItem::setClassNotBuilt(bool bModified)
 	setIcon(0,QIcon(*pIcon));
 }
 
-void KviClassEditorTreeWidgetItem::setName(const QString & szName)
+void ClassEditorTreeWidgetItem::setName(const QString & szName)
 {
 	m_szName = szName;
 	setText(0,m_szName);
 }
 
-void KviClassEditorTreeWidgetItem::setType(Type eType)
+void ClassEditorTreeWidgetItem::setType(Type eType)
 {
 	m_eType = eType;
 	QPixmap * pIcon = 0;
 	
-	if(eType == KviClassEditorTreeWidgetItem::Namespace)
+	if(eType == ClassEditorTreeWidgetItem::Namespace)
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE);
-	else if(eType == KviClassEditorTreeWidgetItem::Class)
+	else if(eType == ClassEditorTreeWidgetItem::Class)
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_CLASS);
 	else
 		pIcon = g_pIconManager->getSmallIcon(KVI_SMALLICON_FUNCTION);
@@ -166,10 +166,10 @@ void KviClassEditorTreeWidgetItem::setType(Type eType)
 	setIcon(0,QIcon(*pIcon));
 }
 
-KviClassEditor::KviClassEditor(QWidget * pParent)
+ClassEditorWidget::ClassEditorWidget(QWidget * pParent)
 : QWidget(pParent)
 {
-	m_pClasses = new KviPointerHashTable<QString,KviClassEditorTreeWidgetItem>(100,false);
+	m_pClasses = new KviPointerHashTable<QString,ClassEditorTreeWidgetItem>(100,false);
 	m_pClasses->setAutoDelete(false);
 	m_pLastEditedItem = 0;
 	m_pLastClickedItem = 0;
@@ -184,7 +184,7 @@ KviClassEditor::KviClassEditor(QWidget * pParent)
 	KviTalVBox * pVBox = new KviTalVBox(m_pSplitter);
 	pVBox->setSpacing(0);
 	pVBox->setMargin(0);
-	m_pTreeWidget = new KviClassEditorTreeWidget(pVBox);
+	m_pTreeWidget = new ClassEditorTreeWidget(pVBox);
 
 	pVBox = new KviTalVBox(m_pSplitter);
 
@@ -228,18 +228,18 @@ KviClassEditor::KviClassEditor(QWidget * pParent)
 	currentItemChanged(0,0);
 }
 
-KviClassEditor::~KviClassEditor()
+ClassEditorWidget::~ClassEditorWidget()
 {
 	m_pClasses->clear();
 	delete m_pClasses;
 }
 
-void KviClassEditor::buildFullItemPath(KviClassEditorTreeWidgetItem * pItem, QString & szBuffer)
+void ClassEditorWidget::buildFullItemPath(ClassEditorTreeWidgetItem * pItem, QString & szBuffer)
 {
 	if(!pItem)
 		return;
 	szBuffer.prepend(pItem->name() + "::");
-	pItem = (KviClassEditorTreeWidgetItem *)pItem->parent();
+	pItem = (ClassEditorTreeWidgetItem *)pItem->parent();
 	while(pItem)
 	{
 		QString szTmp = pItem->name();
@@ -248,16 +248,16 @@ void KviClassEditor::buildFullItemPath(KviClassEditorTreeWidgetItem * pItem, QSt
 			szBuffer.prepend("::");
 			szBuffer.prepend(szTmp);
 		}
-		pItem = (KviClassEditorTreeWidgetItem *)pItem->parent();
+		pItem = (ClassEditorTreeWidgetItem *)pItem->parent();
 	}
 }
 
-QString KviClassEditor::buildFullClassName(KviClassEditorTreeWidgetItem * pItem)
+QString ClassEditorWidget::buildFullClassName(ClassEditorTreeWidgetItem * pItem)
 {
 	if(!pItem)
 		return QString();
 	QString szName = pItem->name();
-	KviClassEditorTreeWidgetItem * pNItem = (KviClassEditorTreeWidgetItem *)pItem->parent();
+	ClassEditorTreeWidgetItem * pNItem = (ClassEditorTreeWidgetItem *)pItem->parent();
 	while(pNItem)
 	{
 		QString szTmp = pNItem->name();
@@ -266,28 +266,28 @@ QString KviClassEditor::buildFullClassName(KviClassEditorTreeWidgetItem * pItem)
 			szName.prepend("::");
 			szName.prepend(szTmp);
 		}
-		pNItem = (KviClassEditorTreeWidgetItem *)pNItem->parent();
+		pNItem = (ClassEditorTreeWidgetItem *)pNItem->parent();
 	}
 	return szName;
 }
 
-KviClassEditorTreeWidgetItem * KviClassEditor::findTopLevelItem(const QString & szName)
+ClassEditorTreeWidgetItem * ClassEditorWidget::findTopLevelItem(const QString & szName)
 {
 	for(int i=0; i < m_pTreeWidget->topLevelItemCount(); i++)
 	{
 		if(KviQString::equalCI(m_pTreeWidget->topLevelItem(i)->text(0),szName))
-			return (KviClassEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i);
+			return (ClassEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i);
 	}
 	return 0;
 }
 
-KviClassEditorTreeWidgetItem * KviClassEditor::findItem(const QString & szFullName)
+ClassEditorTreeWidgetItem * ClassEditorWidget::findItem(const QString & szFullName)
 {
 	bool bFound;
 	QStringList lNamespaces = szFullName.split("::");
 	if(lNamespaces.count() == 0)
 		return 0;
-	KviClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
+	ClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
 	if(!pItem)
 		return 0;
 	
@@ -298,7 +298,7 @@ KviClassEditorTreeWidgetItem * KviClassEditor::findItem(const QString & szFullNa
 		{
 			if (KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i)))
 			{
-				pItem=( KviClassEditorTreeWidgetItem *)pItem->child(j);
+				pItem=( ClassEditorTreeWidgetItem *)pItem->child(j);
 				bFound = true;
 				break;
 			}
@@ -306,10 +306,10 @@ KviClassEditorTreeWidgetItem * KviClassEditor::findItem(const QString & szFullNa
 		if(!bFound)
 			return 0;
 	}
-	return (KviClassEditorTreeWidgetItem *)pItem;
+	return (ClassEditorTreeWidgetItem *)pItem;
 }
 
-KviClassEditorTreeWidgetItem * KviClassEditor::createFullItem(const QString & szFullName)
+ClassEditorTreeWidgetItem * ClassEditorWidget::createFullItem(const QString & szFullName)
 {
 	bool bFound;
 	int i;
@@ -319,14 +319,14 @@ KviClassEditorTreeWidgetItem * KviClassEditor::createFullItem(const QString & sz
 		return 0;
 	if(lNamespaces.count() == 1)
 	{
-		KviClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
+		ClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
 		if(pItem)
 			return pItem;
-		return new KviClassEditorTreeWidgetItem(m_pTreeWidget,KviClassEditorTreeWidgetItem::Class,lNamespaces.at(0));
+		return new ClassEditorTreeWidgetItem(m_pTreeWidget,ClassEditorTreeWidgetItem::Class,lNamespaces.at(0));
 	}
-	KviClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
+	ClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
 	if(!pItem)
-		pItem = new KviClassEditorTreeWidgetItem(m_pTreeWidget,KviClassEditorTreeWidgetItem::Namespace,lNamespaces.at(0));
+		pItem = new ClassEditorTreeWidgetItem(m_pTreeWidget,ClassEditorTreeWidgetItem::Namespace,lNamespaces.at(0));
 
 	for(i=1; i < lNamespaces.count()-1; i++)
 	{
@@ -335,18 +335,18 @@ KviClassEditorTreeWidgetItem * KviClassEditor::createFullItem(const QString & sz
 		{
 			if(KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i)))
 			{
-				pItem = (KviClassEditorTreeWidgetItem *)pItem->child(j);
+				pItem = (ClassEditorTreeWidgetItem *)pItem->child(j);
 				bFound = true;
 				break;
 			}
 		}
 		if(!bFound)
-			pItem = new KviClassEditorTreeWidgetItem(pItem,KviClassEditorTreeWidgetItem::Namespace,lNamespaces.at(i));
+			pItem = new ClassEditorTreeWidgetItem(pItem,ClassEditorTreeWidgetItem::Namespace,lNamespaces.at(i));
 	}
-	return new KviClassEditorTreeWidgetItem(pItem,KviClassEditorTreeWidgetItem::Class,lNamespaces.at(i));
+	return new ClassEditorTreeWidgetItem(pItem,ClassEditorTreeWidgetItem::Class,lNamespaces.at(i));
 }
 
-KviClassEditorTreeWidgetItem * KviClassEditor::createFullNamespace(const QString & szFullName)
+ClassEditorTreeWidgetItem * ClassEditorWidget::createFullNamespace(const QString & szFullName)
 {
 	bool bFound;
 	int i;
@@ -354,9 +354,9 @@ KviClassEditorTreeWidgetItem * KviClassEditor::createFullNamespace(const QString
 	QStringList lNamespaces = szFullName.split("::");
 	if(lNamespaces.count() == 0)
 		return 0;
-	KviClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
+	ClassEditorTreeWidgetItem * pItem = findTopLevelItem(lNamespaces.at(0));
 	if(!pItem)
-		pItem = new KviClassEditorTreeWidgetItem(m_pTreeWidget,KviClassEditorTreeWidgetItem::Namespace,lNamespaces.at(0));
+		pItem = new ClassEditorTreeWidgetItem(m_pTreeWidget,ClassEditorTreeWidgetItem::Namespace,lNamespaces.at(0));
 	if(lNamespaces.count() == 1)
 		return pItem;
 
@@ -365,20 +365,20 @@ KviClassEditorTreeWidgetItem * KviClassEditor::createFullNamespace(const QString
 		bFound = false;
 		for(int j=0;j<pItem->childCount();j++)
 		{
-			if(KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i)) && (( KviClassEditorTreeWidgetItem *)pItem->child(j))->isNamespace())
+			if(KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i)) && (( ClassEditorTreeWidgetItem *)pItem->child(j))->isNamespace())
 			{
-				pItem = (KviClassEditorTreeWidgetItem *)pItem->child(j);
+				pItem = (ClassEditorTreeWidgetItem *)pItem->child(j);
 				bFound = true;
 				break;
 			}
 		}
 		if(!bFound)
-			pItem = new KviClassEditorTreeWidgetItem(pItem,KviClassEditorTreeWidgetItem::Namespace,lNamespaces.at(i));
+			pItem = new ClassEditorTreeWidgetItem(pItem,ClassEditorTreeWidgetItem::Namespace,lNamespaces.at(i));
 	}
 	return pItem;
 }
 
-void KviClassEditor::oneTimeSetup()
+void ClassEditorWidget::oneTimeSetup()
 {
 	QStringList sl;
 	QString szClassName;
@@ -393,7 +393,7 @@ void KviClassEditor::oneTimeSetup()
 	KviPointerHashTableIterator<QString,KviKvsObjectClass> it(*KviKvsKernel::instance()->objectController()->classDict());
 	
 	KviKvsObjectClass * pClass = 0;
-	KviClassEditorTreeWidgetItem * pClassItem = 0;
+	ClassEditorTreeWidgetItem * pClassItem = 0;
 	while(KviKvsObjectClass * pClass = it.current())
 	{
 		if(pClass->isBuiltin())
@@ -430,7 +430,7 @@ void KviClassEditor::oneTimeSetup()
 	connect(m_pTreeWidget,SIGNAL(customContextMenuRequested(const QPoint &)),this,SLOT(customContextMenuRequested(const QPoint &)));
 }
 
-void KviClassEditor::createFullClass(KviKvsObjectClass * pClass, KviClassEditorTreeWidgetItem * pClassItem, const QString & szClassName)
+void ClassEditorWidget::createFullClass(KviKvsObjectClass * pClass, ClassEditorTreeWidgetItem * pClassItem, const QString & szClassName)
 {
 	KviPointerHashTableIterator<QString,KviKvsObjectFunctionHandler>  it(* pClass->getHandlers());
 	QStringList szFunctionsList;
@@ -440,7 +440,7 @@ void KviClassEditor::createFullClass(KviKvsObjectClass * pClass, KviClassEditorT
 		++it;
 	}
 	szFunctionsList.sort();
-	KviClassEditorTreeWidgetItem *pFunctionItem;
+	ClassEditorTreeWidgetItem *pFunctionItem;
 	m_pClasses->insert(szClassName,pClassItem);
 	KviKvsObjectClass * pParentClass = pClass->parentClass();
 	pClassItem->setInheritsClass(pParentClass->name());
@@ -451,7 +451,7 @@ void KviClassEditor::createFullClass(KviKvsObjectClass * pClass, KviClassEditorT
 		if (pClass->isScriptHandler(szFunctionsList.at(i)) && !pHandler->isClone())
 		{
 			pFunctionItem=findFunction(szFunctionsList.at(i), pClassItem);
-			if(!pFunctionItem) pFunctionItem = new KviClassEditorTreeWidgetItem(pClassItem,KviClassEditorTreeWidgetItem::Method,szFunctionsList.at(i));
+			if(!pFunctionItem) pFunctionItem = new ClassEditorTreeWidgetItem(pClassItem,ClassEditorTreeWidgetItem::Method,szFunctionsList.at(i));
 			pClass->getFunctionCode(szCode,*pHandler);
 			pFunctionItem->setBuffer(szCode);
 			pFunctionItem->setReminder(pClass->reminder(pHandler));
@@ -464,11 +464,11 @@ void KviClassEditor::createFullClass(KviKvsObjectClass * pClass, KviClassEditorT
 
 
 /*
-void KviClassEditor::classRefresh(const QString & szName)
+void ClassEditorWidget::classRefresh(const QString & szName)
 {
 	if(m_bSaving)
 		return;
-	KviClassEditorTreeWidgetItem * item;
+	ClassEditorTreeWidgetItem * item;
 	KviKvsScript * class = KviKvsClassManager::instance()->classDict()->find(szName);
 	item = createFullItem(szName);
 	if(item!=m_pLastEditedItem)
@@ -487,12 +487,12 @@ void KviClassEditor::classRefresh(const QString & szName)
 }
 */
 
-bool KviClassEditor::hasSelectedItems()
+bool ClassEditorWidget::hasSelectedItems()
 {
 	return m_pTreeWidget->selectedItems().count() ? 1 : 0;
 }
 
-bool KviClassEditor::classExists(QString & szFullItemName)
+bool ClassEditorWidget::classExists(QString & szFullItemName)
 {
 	if(m_pClasses->find(szFullItemName))
 		return true;
@@ -500,16 +500,16 @@ bool KviClassEditor::classExists(QString & szFullItemName)
 		return false;
 }
 
-void KviClassEditor::renameFunction()
+void ClassEditorWidget::renameFunction()
 {
 	if(!m_pLastEditedItem)
 		return;
-	KviClassEditorTreeWidgetItem * pFunction = m_pLastEditedItem;
-	QString szClassName = buildFullClassName((KviClassEditorTreeWidgetItem *)pFunction->parent());
+	ClassEditorTreeWidgetItem * pFunction = m_pLastEditedItem;
+	QString szClassName = buildFullClassName((ClassEditorTreeWidgetItem *)pFunction->parent());
 	QString szFunctionName = pFunction->name();
 	QString szReminder = pFunction->reminder();
 	QString szNewReminder = szReminder;
-	KviClassEditorTreeWidgetItem * pParentClass = (KviClassEditorTreeWidgetItem *) pFunction->parent();
+	ClassEditorTreeWidgetItem * pParentClass = (ClassEditorTreeWidgetItem *) pFunction->parent();
 
 	QString szNewFunctionName = szFunctionName;
 	bool bInternal = pFunction->isInternalFunction();
@@ -553,7 +553,7 @@ void KviClassEditor::renameFunction()
 	pFunction->setInternalFunction(bInternal);
 	pParentClass->setClassNotBuilt(true);
 	
-	KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
+	KviPointerList<ClassEditorTreeWidgetItem> lInheritedClasses;
 	lInheritedClasses.setAutoDelete(false);
 	searchInheritedClasses(szClassName,lInheritedClasses);
 	for(unsigned int i=0; i < lInheritedClasses.count(); i++)
@@ -561,17 +561,17 @@ void KviClassEditor::renameFunction()
 	activateItem(pFunction);
 }
 
-KviClassEditorTreeWidgetItem * KviClassEditor::findFunction(const QString & szFunctionName, KviClassEditorTreeWidgetItem * pClass)
+ClassEditorTreeWidgetItem * ClassEditorWidget::findFunction(const QString & szFunctionName, ClassEditorTreeWidgetItem * pClass)
 {
 	for(int i=0; i < pClass->childCount(); i++)
 	{
-		if(KviQString::equalCI(szFunctionName,((KviClassEditorTreeWidgetItem *)pClass->child(i))->name()))
-			return (KviClassEditorTreeWidgetItem *) pClass->child(i);
+		if(KviQString::equalCI(szFunctionName,((ClassEditorTreeWidgetItem *)pClass->child(i))->name()))
+			return (ClassEditorTreeWidgetItem *) pClass->child(i);
 	}
 	return 0;
 }
 
-void KviClassEditor::renameItem()
+void ClassEditorWidget::renameItem()
 {
 	if(!m_pLastEditedItem)
 		return;
@@ -581,13 +581,13 @@ void KviClassEditor::renameItem()
 		renameNamespace(m_pLastEditedItem);
 	else {
 		// is function
-		KviClassEditorTreeWidgetItem * pParent = (KviClassEditorTreeWidgetItem *)m_pLastEditedItem->parent();
+		ClassEditorTreeWidgetItem * pParent = (ClassEditorTreeWidgetItem *)m_pLastEditedItem->parent();
 		if(pParent->isClass())
 			renameClass(pParent);
 	}
 }
 
-void KviClassEditor::renameClass(KviClassEditorTreeWidgetItem * pClassItem)
+void ClassEditorWidget::renameClass(ClassEditorTreeWidgetItem * pClassItem)
 {
 	QString szClassName = buildFullClassName(pClassItem);
 	QString szNewClassName = szClassName;
@@ -618,7 +618,7 @@ void KviClassEditor::renameClass(KviClassEditorTreeWidgetItem * pClassItem)
 		szNewName = "";
 		continue;
 	}*/
-	KviClassEditorTreeWidgetItem * pNewItem = 0;
+	ClassEditorTreeWidgetItem * pNewItem = 0;
 	m_pClasses->removeRef(pClassItem);
 	cutItem(pClassItem);
 	if(szNewClassName.contains("::"))
@@ -634,7 +634,7 @@ void KviClassEditor::renameClass(KviClassEditorTreeWidgetItem * pClassItem)
 	pClassItem->setInheritsClass(szNewInheritsClassName);
 	pClassItem->setClassNotBuilt(true);
 	
-	KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
+	KviPointerList<ClassEditorTreeWidgetItem> lInheritedClasses;
 	lInheritedClasses.setAutoDelete(false);
 	searchInheritedClasses(szClassName,lInheritedClasses);
 	for(unsigned int i=0; i < lInheritedClasses.count(); i++)
@@ -659,18 +659,18 @@ void KviClassEditor::renameClass(KviClassEditorTreeWidgetItem * pClassItem)
 		KviKvsKernel::instance()->objectController()->deleteClass(pClass);
 }
 
-void KviClassEditor::cutItem(KviClassEditorTreeWidgetItem * pItem)
+void ClassEditorWidget::cutItem(ClassEditorTreeWidgetItem * pItem)
 {
 	int iIdx = m_pTreeWidget->indexOfTopLevelItem(pItem);
 	if(iIdx!=-1)
 		m_pTreeWidget->takeTopLevelItem(iIdx);
 	else {
-		KviClassEditorTreeWidgetItem * pParent = (KviClassEditorTreeWidgetItem *)pItem->parent();
+		ClassEditorTreeWidgetItem * pParent = (ClassEditorTreeWidgetItem *)pItem->parent();
 		pParent->removeChild(pItem);
 	}
 }
 
-void KviClassEditor::renameNamespace(KviClassEditorTreeWidgetItem * pOldNamespaceItem)
+void ClassEditorWidget::renameNamespace(ClassEditorTreeWidgetItem * pOldNamespaceItem)
 {
 	QString szOldNameSpaceName = buildFullClassName(m_pLastEditedItem);
 	QString szNewNameSpaceName;
@@ -678,7 +678,7 @@ void KviClassEditor::renameNamespace(KviClassEditorTreeWidgetItem * pOldNamespac
 		return;
 	if(KviQString::equalCI(szOldNameSpaceName,szNewNameSpaceName))
 		return;
-	KviClassEditorTreeWidgetItem * pNewItem = findItem(szNewNameSpaceName);
+	ClassEditorTreeWidgetItem * pNewItem = findItem(szNewNameSpaceName);
 	if(pNewItem)
 	{
 		g_pClassEditorModule->lock();
@@ -697,7 +697,7 @@ void KviClassEditor::renameNamespace(KviClassEditorTreeWidgetItem * pOldNamespac
 		g_pClassEditorModule->unlock();
 		return;
 	}
-	KviPointerList<KviClassEditorTreeWidgetItem> pList;
+	KviPointerList<ClassEditorTreeWidgetItem> pList;
 	pList.setAutoDelete(false);
 	appendAllClassItemsRecursive(&pList,pOldNamespaceItem);
 	cutItem(pOldNamespaceItem);
@@ -712,10 +712,10 @@ void KviClassEditor::renameNamespace(KviClassEditorTreeWidgetItem * pOldNamespac
 	}
 	for(unsigned int u=0; u < pList.count(); u++)
 	{
-		KviPointerHashTableEntry<QString,KviClassEditorTreeWidgetItem> * pEntry = m_pClasses->findRef(pList.at(u));
+		KviPointerHashTableEntry<QString,ClassEditorTreeWidgetItem> * pEntry = m_pClasses->findRef(pList.at(u));
 		if(pEntry)
 		{
-			KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
+			KviPointerList<ClassEditorTreeWidgetItem> lInheritedClasses;
 			lInheritedClasses.setAutoDelete(false);
 
 			QString szOldName = pEntry->key();
@@ -748,23 +748,23 @@ void KviClassEditor::renameNamespace(KviClassEditorTreeWidgetItem * pOldNamespac
 	//searchReplace(szOldNameSpaceName+"::",true,szNewNameSpaceName+"::");
 }
 
-void KviClassEditor::saveLastEditedItem()
+void ClassEditorWidget::saveLastEditedItem()
 {
 	if(!m_pLastEditedItem)
 		return;
 	if(!m_pEditor->isModified() || m_pLastEditedItem->isNamespace() || m_pLastEditedItem->isClass())
 		return;
-	((KviClassEditorTreeWidgetItem *)m_pLastEditedItem)->setCursorPosition(m_pEditor->getCursor());
+	((ClassEditorTreeWidgetItem *)m_pLastEditedItem)->setCursorPosition(m_pEditor->getCursor());
 	QString newCode;
 	m_pEditor->getText(newCode);
-	((KviClassEditorTreeWidgetItem *)m_pLastEditedItem)->setBuffer(newCode);
-	((KviClassEditorTreeWidgetItem *)m_pLastEditedItem->parent())->setClassNotBuilt(true);
+	((ClassEditorTreeWidgetItem *)m_pLastEditedItem)->setBuffer(newCode);
+	((ClassEditorTreeWidgetItem *)m_pLastEditedItem->parent())->setClassNotBuilt(true);
 }
 
-void KviClassEditor::currentItemChanged(QTreeWidgetItem * pTree, QTreeWidgetItem *)
+void ClassEditorWidget::currentItemChanged(QTreeWidgetItem * pTree, QTreeWidgetItem *)
 {
 	saveLastEditedItem();
-	m_pLastEditedItem = (KviClassEditorTreeWidgetItem *)pTree;
+	m_pLastEditedItem = (ClassEditorTreeWidgetItem *)pTree;
 	if(!m_pLastEditedItem)
 	{
 		m_pClassNameLabel->setText(__tr2qs_ctx("No item selected","editor"));
@@ -774,9 +774,9 @@ void KviClassEditor::currentItemChanged(QTreeWidgetItem * pTree, QTreeWidgetItem
 		return;
 	}
 	
-	KviClassEditorTreeWidgetItem * pClassItem = 0;
+	ClassEditorTreeWidgetItem * pClassItem = 0;
 	if(m_pLastEditedItem->isMethod())
-		pClassItem = (KviClassEditorTreeWidgetItem *)m_pLastEditedItem->parent();
+		pClassItem = (ClassEditorTreeWidgetItem *)m_pLastEditedItem->parent();
 	else
 		pClassItem = m_pLastEditedItem;
 	
@@ -844,13 +844,13 @@ void KviClassEditor::currentItemChanged(QTreeWidgetItem * pTree, QTreeWidgetItem
 		m_pTreeWidget->setFocus();
 		QString szBuffer;
 		QStringList szFunctionsList;
-		KviPointerHashTable<QString,KviClassEditorTreeWidgetItem> lFunctions;
+		KviPointerHashTable<QString,ClassEditorTreeWidgetItem> lFunctions;
 		lFunctions.setAutoDelete(false);
 		
-		KviClassEditorTreeWidgetItem * pItem = 0;
+		ClassEditorTreeWidgetItem * pItem = 0;
 		for(int i=0; i < pTree->childCount(); i++)
 		{
-			pItem = ((KviClassEditorTreeWidgetItem *)pTree->child(i));
+			pItem = ((ClassEditorTreeWidgetItem *)pTree->child(i));
 			szFunctionsList.append(pItem->name());
 			lFunctions.insert(pItem->name(),pItem);
 		}
@@ -867,17 +867,17 @@ void KviClassEditor::currentItemChanged(QTreeWidgetItem * pTree, QTreeWidgetItem
 		return;
 	}
 	m_pEditor->setReadOnly(false);
-	m_pEditor->setText(((KviClassEditorTreeWidgetItem *)pTree)->buffer());
+	m_pEditor->setText(((ClassEditorTreeWidgetItem *)pTree)->buffer());
 	m_pEditor->setFocus();
-	m_pEditor->setCursorPosition(((KviClassEditorTreeWidgetItem *)pTree)->cursorPosition());
+	m_pEditor->setCursorPosition(((ClassEditorTreeWidgetItem *)pTree)->cursorPosition());
 	m_pEditor->setEnabled(true);
 }
 
-void KviClassEditor::customContextMenuRequested(QPoint pnt)
+void ClassEditorWidget::customContextMenuRequested(QPoint pnt)
 {
 	m_pContextPopup->clear();
 
-	m_pLastClickedItem = (KviClassEditorTreeWidgetItem *)m_pTreeWidget->itemAt(pnt);
+	m_pLastClickedItem = (ClassEditorTreeWidgetItem *)m_pTreeWidget->itemAt(pnt);
 
 	int iId;
 	iId = m_pContextPopup->insertItem(
@@ -956,21 +956,21 @@ void KviClassEditor::customContextMenuRequested(QPoint pnt)
 	m_pContextPopup->popup(m_pTreeWidget->mapToGlobal(pnt));
 }
 
-void KviClassEditor::searchReplace(const QString & szSearch, bool bReplace, const QString & szReplace)
+void ClassEditorWidget::searchReplace(const QString & szSearch, bool bReplace, const QString & szReplace)
 {
-	KviPointerHashTableIterator<QString,KviClassEditorTreeWidgetItem> it (*m_pClasses);
+	KviPointerHashTableIterator<QString,ClassEditorTreeWidgetItem> it (*m_pClasses);
 	while(it.current())
 	{
-		KviClassEditorTreeWidgetItem * pItem = it.current();
+		ClassEditorTreeWidgetItem * pItem = it.current();
 		for(int j=0; j < pItem->childCount(); j++)
 		{
 			bool bOpened = false;
-			if(((KviClassEditorTreeWidgetItem *)pItem->child(j))->buffer().indexOf(szSearch,0,Qt::CaseInsensitive) != -1)
+			if(((ClassEditorTreeWidgetItem *)pItem->child(j))->buffer().indexOf(szSearch,0,Qt::CaseInsensitive) != -1)
 			{
 				pItem->child(j)->setBackground(0, QColor(255,0,0,128));
 				if(bReplace)
 				{
-					QString &buffer=(QString &)((KviClassEditorTreeWidgetItem *)pItem->child(j))->buffer();
+					QString &buffer=(QString &)((ClassEditorTreeWidgetItem *)pItem->child(j))->buffer();
 					pItem->setClassNotBuilt(true);
 					buffer.replace(szSearch,szReplace,Qt::CaseInsensitive);
 				}
@@ -987,7 +987,7 @@ void KviClassEditor::searchReplace(const QString & szSearch, bool bReplace, cons
 	}
 }
 
-void KviClassEditor::slotFind()
+void ClassEditorWidget::slotFind()
 {
 	g_pClassEditorModule->lock();
 	bool bOk;
@@ -1008,12 +1008,12 @@ void KviClassEditor::slotFind()
 	searchReplace(szSearch);
 }
 
-void KviClassEditor::slotFindWord(const QString & szSearch)
+void ClassEditorWidget::slotFindWord(const QString & szSearch)
 {
 	m_pEditor->setFindText(szSearch);
 }
 
-void KviClassEditor::recursiveCollapseItems(KviClassEditorTreeWidgetItem * pItem)
+void ClassEditorWidget::recursiveCollapseItems(ClassEditorTreeWidgetItem * pItem)
 {
 	if(!pItem)
 		return;
@@ -1022,36 +1022,36 @@ void KviClassEditor::recursiveCollapseItems(KviClassEditorTreeWidgetItem * pItem
 		if(pItem->child(i)->childCount())
 		{
 			pItem->child(i)->setExpanded(false);
-			recursiveCollapseItems((KviClassEditorTreeWidgetItem *)pItem->child(i));
+			recursiveCollapseItems((ClassEditorTreeWidgetItem *)pItem->child(i));
 		}
 	}
 }
 
-void KviClassEditor::slotCollapseItems()
+void ClassEditorWidget::slotCollapseItems()
 {
 	for(int i=0; i < m_pTreeWidget->topLevelItemCount(); i++)
 	{
 		if(m_pTreeWidget->topLevelItem(i)->childCount())
 		{
 			m_pTreeWidget->topLevelItem(i)->setExpanded(false);
-			recursiveCollapseItems((KviClassEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i));
+			recursiveCollapseItems((ClassEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i));
 		}
 	}
 }
 
-void KviClassEditor::slotReplaceAll(const QString & szFind, const QString & szReplace)
+void ClassEditorWidget::slotReplaceAll(const QString & szFind, const QString & szReplace)
 {
 	m_pEditor->setFindText(szReplace);
 	searchReplace(szFind,true,szReplace);
 	/*
 	for (int i=0;i<m_pTreeWidget->topLevelItemCount();i++)
 	{
-		recursiveSearchReplace(szFind,(KviClassEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i),true,szReplace);
+		recursiveSearchReplace(szFind,(ClassEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i),true,szReplace);
 	}
 	*/
 }
 
-void KviClassEditor::exportClassBuffer(QString & szBuffer, KviClassEditorTreeWidgetItem * pItem)
+void ClassEditorWidget::exportClassBuffer(QString & szBuffer, ClassEditorTreeWidgetItem * pItem)
 {
 	QString szTmp = pItem->buffer();
 	KviCommandFormatter::blockFromBuffer(szTmp);
@@ -1067,7 +1067,7 @@ void KviClassEditor::exportClassBuffer(QString & szBuffer, KviClassEditorTreeWid
 	szBuffer += "\")\n{\n";
 	for(int i=0; i < pItem->childCount(); i++)
 	{
-		KviClassEditorTreeWidgetItem * pFunction = (KviClassEditorTreeWidgetItem *)pItem->child(i);
+		ClassEditorTreeWidgetItem * pFunction = (ClassEditorTreeWidgetItem *)pItem->child(i);
 		if(pFunction->isMethod())
 		{
 			szBuffer += "\t";
@@ -1084,22 +1084,22 @@ void KviClassEditor::exportClassBuffer(QString & szBuffer, KviClassEditorTreeWid
 	szBuffer += "}\n";
 }
 
-void KviClassEditor::exportAll()
+void ClassEditorWidget::exportAll()
 {
 	exportClasses(false);
 }
 
-void KviClassEditor::exportSelectedSepFiles()
+void ClassEditorWidget::exportSelectedSepFiles()
 {
 	exportClasses(true,true);
 }
 
-void KviClassEditor::exportSelected()
+void ClassEditorWidget::exportSelected()
 {
 	exportClasses(true);
 }
 
-void KviClassEditor::exportSelectionInSinglesFiles(KviPointerList<KviClassEditorTreeWidgetItem> * pList)
+void ClassEditorWidget::exportSelectionInSinglesFiles(KviPointerList<ClassEditorTreeWidgetItem> * pList)
 {
 	bool bReplaceAll = false;
 	
@@ -1123,7 +1123,7 @@ void KviClassEditor::exportSelectionInSinglesFiles(KviPointerList<KviClassEditor
 	if(!m_szDir.endsWith(QString(KVI_PATH_SEPARATOR)))
 		m_szDir += KVI_PATH_SEPARATOR;
 
-	for(KviClassEditorTreeWidgetItem * pItem = pList->first(); pItem; pItem = pList->next())
+	for(ClassEditorTreeWidgetItem * pItem = pList->first(); pItem; pItem = pList->next())
 	{
 		QString szTmp;
 		exportClassBuffer(szTmp,pItem);
@@ -1148,7 +1148,7 @@ void KviClassEditor::exportSelectionInSinglesFiles(KviPointerList<KviClassEditor
 	g_pClassEditorModule->unlock();
 }
 
-void KviClassEditor::exportClasses(bool bSelectedOnly, bool bSingleFiles)
+void ClassEditorWidget::exportClasses(bool bSelectedOnly, bool bSingleFiles)
 {
 	QString szOut;
 	QString szNameFile;
@@ -1157,7 +1157,7 @@ void KviClassEditor::exportClasses(bool bSelectedOnly, bool bSingleFiles)
 	
 	saveLastEditedItem();
 
-	KviPointerList<KviClassEditorTreeWidgetItem> list;
+	KviPointerList<ClassEditorTreeWidgetItem> list;
 	list.setAutoDelete(false);
 
 	if(bSelectedOnly)
@@ -1171,8 +1171,8 @@ void KviClassEditor::exportClasses(bool bSelectedOnly, bool bSingleFiles)
 		return;
         }
 	
-	KviClassEditorTreeWidgetItem * pTempItem = 0;
-	for(KviClassEditorTreeWidgetItem * pItem = list.first(); pItem; pItem = list.next())
+	ClassEditorTreeWidgetItem * pTempItem = 0;
+	for(ClassEditorTreeWidgetItem * pItem = list.first(); pItem; pItem = list.next())
 	{
 		pTempItem = pItem;
 		iCount++;
@@ -1222,7 +1222,7 @@ void KviClassEditor::exportClasses(bool bSelectedOnly, bool bSingleFiles)
 	}
 }
 
-void KviClassEditor::saveProperties(KviConfigurationFile * pCfg)
+void ClassEditorWidget::saveProperties(KviConfigurationFile * pCfg)
 {
 	pCfg->writeEntry("Sizes",m_pSplitter->sizes());
 	QString szName;
@@ -1231,7 +1231,7 @@ void KviClassEditor::saveProperties(KviConfigurationFile * pCfg)
 	pCfg->writeEntry("LastClass",szName);
 }
 
-void KviClassEditor::loadProperties(KviConfigurationFile * pCfg)
+void ClassEditorWidget::loadProperties(KviConfigurationFile * pCfg)
 {
 	QList<int> def;
 	def.append(20);
@@ -1239,35 +1239,35 @@ void KviClassEditor::loadProperties(KviConfigurationFile * pCfg)
 	m_pSplitter->setSizes(pCfg->readIntListEntry("Sizes",def));
 	QString szTmp = pCfg->readEntry("LastClass",QString());
 
-	KviClassEditorTreeWidgetItem * pItem = findItem(szTmp);
+	ClassEditorTreeWidgetItem * pItem = findItem(szTmp);
 	activateItem(pItem);
 }
 
-void KviClassEditor::appendSelectedClassItems(KviPointerList<KviClassEditorTreeWidgetItem> * pList)
+void ClassEditorWidget::appendSelectedClassItems(KviPointerList<ClassEditorTreeWidgetItem> * pList)
 {
 	QList<QTreeWidgetItem *> list = m_pTreeWidget->selectedItems();
 	for(int i=0; i < list.count(); i++)
 	{
-		if(((KviClassEditorTreeWidgetItem *)list.at(i))->isClass())
-			pList->append((KviClassEditorTreeWidgetItem *)list.at(i));
+		if(((ClassEditorTreeWidgetItem *)list.at(i))->isClass())
+			pList->append((ClassEditorTreeWidgetItem *)list.at(i));
 		else appendSelectedClassItemsRecursive(pList,list.at(i));
 	}
 }
 
-void KviClassEditor::appendSelectedClassItemsRecursive(KviPointerList<KviClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom)
+void ClassEditorWidget::appendSelectedClassItemsRecursive(KviPointerList<ClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom)
 {
 	for(int i=0; i < pStartFrom->childCount(); i++)
 	{
-		if(((KviClassEditorTreeWidgetItem *)pStartFrom->child(i))->isClass())
-			pList->append(((KviClassEditorTreeWidgetItem *)pStartFrom->child(i)));
+		if(((ClassEditorTreeWidgetItem *)pStartFrom->child(i))->isClass())
+			pList->append(((ClassEditorTreeWidgetItem *)pStartFrom->child(i)));
 		else
 			appendSelectedClassItemsRecursive(pList,pStartFrom->child(i));
 	}
 }
 
-void KviClassEditor::appendAllClassItems(KviPointerList<KviClassEditorTreeWidgetItem> * pList)
+void ClassEditorWidget::appendAllClassItems(KviPointerList<ClassEditorTreeWidgetItem> * pList)
 {
-	KviPointerHashTableIterator<QString,KviClassEditorTreeWidgetItem> it (*m_pClasses);
+	KviPointerHashTableIterator<QString,ClassEditorTreeWidgetItem> it (*m_pClasses);
 	while(it.current())
 	{
 		pList->append(it.current());
@@ -1275,24 +1275,24 @@ void KviClassEditor::appendAllClassItems(KviPointerList<KviClassEditorTreeWidget
 	}
 }
 
-void KviClassEditor::appendAllClassItemsRecursive(KviPointerList<KviClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom)
+void ClassEditorWidget::appendAllClassItemsRecursive(KviPointerList<ClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom)
 {
 	for(int i=0; i < pStartFrom->childCount(); i++)
 	{
-		if(((KviClassEditorTreeWidgetItem *)pStartFrom->child(i))->isClass())
+		if(((ClassEditorTreeWidgetItem *)pStartFrom->child(i))->isClass())
 		{
-			pList->append((KviClassEditorTreeWidgetItem *)pStartFrom->child(i));
+			pList->append((ClassEditorTreeWidgetItem *)pStartFrom->child(i));
 		} else {
 			appendAllClassItemsRecursive(pList,pStartFrom->child(i));
 		}
 	}
 }
 
-void KviClassEditor::removeItemChildren(KviClassEditorTreeWidgetItem * pItem, KviPointerList <KviClassEditorTreeWidgetItem> & lRemovedItems)
+void ClassEditorWidget::removeItemChildren(ClassEditorTreeWidgetItem * pItem, KviPointerList <ClassEditorTreeWidgetItem> & lRemovedItems)
 {
 	if(pItem->isClass())
 	{
-		KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
+		KviPointerList<ClassEditorTreeWidgetItem> lInheritedClasses;
 		lInheritedClasses.setAutoDelete(false);
 		searchInheritedClasses(buildFullClassName(pItem),lInheritedClasses);
 		for(unsigned int u=0; u < lInheritedClasses.count(); u++)
@@ -1305,7 +1305,7 @@ void KviClassEditor::removeItemChildren(KviClassEditorTreeWidgetItem * pItem, Kv
 	
 	while(pItem->childCount() > 0)
 	{
-		KviClassEditorTreeWidgetItem * pChild = (KviClassEditorTreeWidgetItem *)(pItem->child(0));
+		ClassEditorTreeWidgetItem * pChild = (ClassEditorTreeWidgetItem *)(pItem->child(0));
 		if(pChild->childCount())
 			removeItemChildren(pChild,lRemovedItems);
 		if(pChild->isClass())
@@ -1322,7 +1322,7 @@ void KviClassEditor::removeItemChildren(KviClassEditorTreeWidgetItem * pItem, Kv
 	}
 }
 
-bool KviClassEditor::removeItem(KviClassEditorTreeWidgetItem * pItem, KviPointerList <KviClassEditorTreeWidgetItem> & lRemovedItems, bool * pbYesToAll)
+bool ClassEditorWidget::removeItem(ClassEditorTreeWidgetItem * pItem, KviPointerList <ClassEditorTreeWidgetItem> & lRemovedItems, bool * pbYesToAll)
 {
 	if(!pItem)
 		return true;
@@ -1392,17 +1392,17 @@ bool KviClassEditor::removeItem(KviClassEditorTreeWidgetItem * pItem, KviPointer
 	}
 	if(pItem->isMethod())
 	{
-		updateClassHierarchy((KviClassEditorTreeWidgetItem *)pItem->parent());
+		updateClassHierarchy((ClassEditorTreeWidgetItem *)pItem->parent());
 	}
 	lRemovedItems.append(pItem);
 	delete pItem;
 	return true;
 }
 
-void KviClassEditor::updateClassHierarchy(KviClassEditorTreeWidgetItem * pClass)
+void ClassEditorWidget::updateClassHierarchy(ClassEditorTreeWidgetItem * pClass)
 {
 	pClass->setClassNotBuilt(true);
-	KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
+	KviPointerList<ClassEditorTreeWidgetItem> lInheritedClasses;
 	lInheritedClasses.setAutoDelete(false);
 	searchInheritedClasses(pClass->name(),lInheritedClasses);
 	for(unsigned int u=0; u < lInheritedClasses.count(); u++)
@@ -1413,22 +1413,22 @@ void KviClassEditor::updateClassHierarchy(KviClassEditorTreeWidgetItem * pClass)
 	}
 }
 
-void KviClassEditor::removeSelectedItems()
+void ClassEditorWidget::removeSelectedItems()
 {
-	KviPointerList<KviClassEditorTreeWidgetItem> lRemovedItems;
+	KviPointerList<ClassEditorTreeWidgetItem> lRemovedItems;
 	lRemovedItems.setAutoDelete(false);
 	QList<QTreeWidgetItem *> list = m_pTreeWidget->selectedItems();
 	bool bYesToAll = false;
 	for(int i=0; i < list.count(); i++)
 	{
-		if(lRemovedItems.findRef((KviClassEditorTreeWidgetItem *) list.at(i)) != -1)
+		if(lRemovedItems.findRef((ClassEditorTreeWidgetItem *) list.at(i)) != -1)
 			continue;
-		if(!removeItem((KviClassEditorTreeWidgetItem *) list.at(i),lRemovedItems,&bYesToAll))
+		if(!removeItem((ClassEditorTreeWidgetItem *) list.at(i),lRemovedItems,&bYesToAll))
 			return;
 	}
 }
 
-bool KviClassEditor::askForClassName(QString & szClassName, QString & szInheritsClassName, bool bEdit)
+bool ClassEditorWidget::askForClassName(QString & szClassName, QString & szInheritsClassName, bool bEdit)
 {
 	KviClassEditorDialog * pDialog = new KviClassEditorDialog(this,"classdialog",m_pClasses,szClassName,szInheritsClassName,bEdit);
 	szClassName = "";
@@ -1446,7 +1446,7 @@ bool KviClassEditor::askForClassName(QString & szClassName, QString & szInherits
 	return false;
 }
 
-bool KviClassEditor::askForFunction(QString & szFunctionName, QString & szReminder, bool * bInternal, const QString & szClassName, bool bRenameMode)
+bool ClassEditorWidget::askForFunction(QString & szFunctionName, QString & szReminder, bool * bInternal, const QString & szClassName, bool bRenameMode)
 {
 	KviClassEditorFunctionDialog * pDialog = new KviClassEditorFunctionDialog(this,"function",szClassName,szFunctionName,szReminder,*bInternal, bRenameMode);
 	szFunctionName = "";
@@ -1465,7 +1465,7 @@ bool KviClassEditor::askForFunction(QString & szFunctionName, QString & szRemind
 	return false;
 }
 
-bool KviClassEditor::askForNamespaceName(const QString & szAction, const QString & szText, const QString & szInitialText, QString & szNewName)
+bool ClassEditorWidget::askForNamespaceName(const QString & szAction, const QString & szText, const QString & szInitialText, QString & szNewName)
 {
 	bool bOk = false;
 	while(szNewName.isEmpty())
@@ -1533,7 +1533,7 @@ bool KviClassEditor::askForNamespaceName(const QString & szAction, const QString
 	return true;
 }
 
-void KviClassEditor::openParentItems(QTreeWidgetItem * pItem)
+void ClassEditorWidget::openParentItems(QTreeWidgetItem * pItem)
 {
 	if(pItem->parent())
 	{
@@ -1542,7 +1542,7 @@ void KviClassEditor::openParentItems(QTreeWidgetItem * pItem)
 	}
 }
 
-void KviClassEditor::activateItem(QTreeWidgetItem * pItem)
+void ClassEditorWidget::activateItem(QTreeWidgetItem * pItem)
 {
 	if(!pItem)
 		return;
@@ -1550,14 +1550,14 @@ void KviClassEditor::activateItem(QTreeWidgetItem * pItem)
 	m_pTreeWidget->setCurrentItem(pItem);
 }
 
-void KviClassEditor::newClass()
+void ClassEditorWidget::newClass()
 {
 	QString szClassName;
 	QString szinheritsClassName;
 	askForClassName(szClassName,szinheritsClassName,false);
 	if(szClassName.isEmpty())
 		return;
-	KviClassEditorTreeWidgetItem * pItem = newItem(szClassName,KviClassEditorTreeWidgetItem::Class);
+	ClassEditorTreeWidgetItem * pItem = newItem(szClassName,ClassEditorTreeWidgetItem::Class);
 	
 	KviQString::escapeKvs(&szClassName, KviQString::EscapeSpace);
 	KviQString::escapeKvs(&szinheritsClassName, KviQString::EscapeSpace);
@@ -1571,25 +1571,25 @@ void KviClassEditor::newClass()
 	KviKvsScript::run(szClass,g_pActiveWindow);
 }
 
-void KviClassEditor::newNamespace()
+void ClassEditorWidget::newNamespace()
 {
 	QString szName;
 	if(!askForNamespaceName(__tr2qs_ctx("Add Namespace","editor"),__tr2qs_ctx("Please enter the name for the new namespace","editor"),"mynamespace",szName))
 		return;
 	if(szName.isEmpty())
 		return;
-	KviClassEditorTreeWidgetItem * pItem = newItem(szName,KviClassEditorTreeWidgetItem::Namespace);
+	ClassEditorTreeWidgetItem * pItem = newItem(szName,ClassEditorTreeWidgetItem::Namespace);
 	activateItem(pItem);
 }
 
-void KviClassEditor::newMemberFunction()
+void ClassEditorWidget::newMemberFunction()
 {
 	QString szFunctionName;
 	QString szClassName;
 	QString szReminder;
 	
 	if(m_pLastClickedItem->isMethod())
-		m_pLastClickedItem = (KviClassEditorTreeWidgetItem*)m_pLastClickedItem->parent();
+		m_pLastClickedItem = (ClassEditorTreeWidgetItem*)m_pLastClickedItem->parent();
 	szClassName = buildFullClassName(m_pLastClickedItem);
 	bool bInternal = false;
 	if(!askForFunction(szFunctionName, szReminder,&bInternal,szClassName,false))
@@ -1597,15 +1597,15 @@ void KviClassEditor::newMemberFunction()
 	if(szFunctionName.isEmpty())
 		return;
 	
-	KviClassEditorTreeWidgetItem * pItem = newItem(szFunctionName,KviClassEditorTreeWidgetItem::Method);
+	ClassEditorTreeWidgetItem * pItem = newItem(szFunctionName,ClassEditorTreeWidgetItem::Method);
 	pItem->setInternalFunction(bInternal);
 	if(!szReminder.isEmpty())
 		pItem->setReminder(szReminder);
 	activateItem(pItem);
-	((KviClassEditorTreeWidgetItem*)pItem->parent())->setClassNotBuilt(true);
+	((ClassEditorTreeWidgetItem*)pItem->parent())->setClassNotBuilt(true);
 }
 
-KviClassEditorTreeWidgetItem * KviClassEditor::newItem(QString & szName, KviClassEditorTreeWidgetItem::Type eType)
+ClassEditorTreeWidgetItem * ClassEditorWidget::newItem(QString & szName, ClassEditorTreeWidgetItem::Type eType)
 {
 	if(m_pLastClickedItem)
 		buildFullItemPath(m_pLastClickedItem,szName);
@@ -1622,24 +1622,24 @@ KviClassEditorTreeWidgetItem * KviClassEditor::newItem(QString & szName, KviClas
 		szName.append(szTmp);
 		iIdx++;
 	}
-	KviClassEditorTreeWidgetItem * pItem;
+	ClassEditorTreeWidgetItem * pItem;
 	pItem = createFullItem(szName);
 	pItem->setType(eType);
 	return pItem;
 }
 
-void KviClassEditor::build()
+void ClassEditorWidget::build()
 {
 	saveLastEditedItem();
-	KviPointerHashTableIterator<QString,KviClassEditorTreeWidgetItem> it (*m_pClasses);
-	KviPointerList<KviClassEditorTreeWidgetItem> linkedClasses;
+	KviPointerHashTableIterator<QString,ClassEditorTreeWidgetItem> it (*m_pClasses);
+	KviPointerList<ClassEditorTreeWidgetItem> linkedClasses;
 	linkedClasses.setAutoDelete(false);
-	KviPointerList<KviClassEditorTreeWidgetItem> skipClasses;
+	KviPointerList<ClassEditorTreeWidgetItem> skipClasses;
 	skipClasses.setAutoDelete(false);
 	bool bErrorWhilecompiling = false;
 	while(it.current())
 	{
-		KviClassEditorTreeWidgetItem * pClass = it.current();
+		ClassEditorTreeWidgetItem * pClass = it.current();
 		if(skipClasses.findRef(it.current()) != -1)
 		{
 			++it;
@@ -1648,7 +1648,7 @@ void KviClassEditor::build()
 		if(pClass->classNotBuilt())
 		{
 			//qDebug("compiling %s",pClass->name().toUtf8().data());
-			KviClassEditorTreeWidgetItem * pParentClass = m_pClasses->find(pClass->inheritsClass());
+			ClassEditorTreeWidgetItem * pParentClass = m_pClasses->find(pClass->inheritsClass());
 
 			linkedClasses.append(pClass);
 			//if (!pParentClass) qDebug("no parent class");
@@ -1673,7 +1673,7 @@ void KviClassEditor::build()
 					bErrorWhilecompiling = true;
 					QString szError = __tr2qs_ctx("Unable to compile class: ","editor");
 					szError += szFullClassName + "\n";
-					KviPointerList<KviClassEditorTreeWidgetItem> lInheritedClasses;
+					KviPointerList<ClassEditorTreeWidgetItem> lInheritedClasses;
 					lInheritedClasses.setAutoDelete(false);
 					searchInheritedClasses(szFullClassName,lInheritedClasses);
 					if(lInheritedClasses.count())
@@ -1711,7 +1711,7 @@ void KviClassEditor::build()
 	KviKvsKernel::instance()->objectController()->flushUserClasses();
 }
 
-void KviClassEditor::loadNotBuiltClasses()
+void ClassEditorWidget::loadNotBuiltClasses()
 {
 	QString szFileName = "libkviclasseditortmp.kvc";
 	QString szBuffer;
@@ -1731,7 +1731,7 @@ void KviClassEditor::loadNotBuiltClasses()
 	for(QString * pszTmp = l.first(); pszTmp; pszTmp = l.next())
 	{
 		cfg.setGroup(*pszTmp);
-		KviClassEditorTreeWidgetItem * pClassItem = createFullItem(*pszTmp);
+		ClassEditorTreeWidgetItem * pClassItem = createFullItem(*pszTmp);
 		m_pClasses->insert(*pszTmp,pClassItem);
 		pClassItem->setClassNotBuilt(true);
 		KviConfigurationFileGroup * pDict = cfg.dict()->find(*pszTmp);
@@ -1756,9 +1756,9 @@ void KviClassEditor::loadNotBuiltClasses()
                                 if((*pszTmp).left(9) == "@Reminder")
 					continue;
                                 QString szCode = cfg.readEntry(*pszTmp,"");
-				KviClassEditorTreeWidgetItem * pFunctionItem = findFunction(*pszTmp, pClassItem);
+				ClassEditorTreeWidgetItem * pFunctionItem = findFunction(*pszTmp, pClassItem);
 				if(!pFunctionItem)
-					pFunctionItem = new KviClassEditorTreeWidgetItem(pClassItem,KviClassEditorTreeWidgetItem::Method,*pszTmp);
+					pFunctionItem = new ClassEditorTreeWidgetItem(pClassItem,ClassEditorTreeWidgetItem::Method,*pszTmp);
 				pFunctionItem->setBuffer(szCode);
                                 QString szEntry = "@Reminder|" + (*pszTmp);
                                 QString szReminder = cfg.readEntry(szEntry,"");
@@ -1768,10 +1768,10 @@ void KviClassEditor::loadNotBuiltClasses()
 	}
 }
 
-void KviClassEditor::saveNotBuiltClasses()
+void ClassEditorWidget::saveNotBuiltClasses()
 {
 	saveLastEditedItem();
-	KviPointerHashTableIterator<QString,KviClassEditorTreeWidgetItem> it (*m_pClasses);
+	KviPointerHashTableIterator<QString,ClassEditorTreeWidgetItem> it (*m_pClasses);
 	QString szFileName = "libkviclasseditortmp.kvc";
 	QString szBuffer;
 	g_pApp->getLocalKvircDirectory(szBuffer,KviApplication::ConfigPlugins,szFileName);
@@ -1791,12 +1791,12 @@ void KviClassEditor::saveNotBuiltClasses()
 			QString szReminderEntry;
 			for(int i=0; i < it.current()->childCount(); i++)
 			{
-				if(!((KviClassEditorTreeWidgetItem *)it.current()->child(i))->reminder().isEmpty())
+				if(!((ClassEditorTreeWidgetItem *)it.current()->child(i))->reminder().isEmpty())
 				{
-					szReminderEntry="@Reminder|"+((KviClassEditorTreeWidgetItem *)it.current()->child(i))->name();
-					cfg.writeEntry(szReminderEntry,((KviClassEditorTreeWidgetItem *)it.current()->child(i))->reminder());
+					szReminderEntry="@Reminder|"+((ClassEditorTreeWidgetItem *)it.current()->child(i))->name();
+					cfg.writeEntry(szReminderEntry,((ClassEditorTreeWidgetItem *)it.current()->child(i))->reminder());
 				}
-				cfg.writeEntry(((KviClassEditorTreeWidgetItem *)it.current()->child(i))->name(),((KviClassEditorTreeWidgetItem *)it.current()->child(i))->buffer());
+				cfg.writeEntry(((ClassEditorTreeWidgetItem *)it.current()->child(i))->name(),((ClassEditorTreeWidgetItem *)it.current()->child(i))->buffer());
 			}
 		}
 		++it;
@@ -1804,9 +1804,9 @@ void KviClassEditor::saveNotBuiltClasses()
 	cfg.sync();
 }
 
-void KviClassEditor::searchInheritedClasses(const QString szClass, KviPointerList<KviClassEditorTreeWidgetItem> & lInheritedClasses)
+void ClassEditorWidget::searchInheritedClasses(const QString szClass, KviPointerList<ClassEditorTreeWidgetItem> & lInheritedClasses)
 {
-	KviPointerHashTableIterator<QString,KviClassEditorTreeWidgetItem> it (*m_pClasses);
+	KviPointerHashTableIterator<QString,ClassEditorTreeWidgetItem> it (*m_pClasses);
 	while(it.current())
 	{
 		if(KviQString::equalCI(szClass,it.current()->inheritsClass()))
@@ -1815,7 +1815,7 @@ void KviClassEditor::searchInheritedClasses(const QString szClass, KviPointerLis
 	}
 }
 
-KviClassEditorWindow::KviClassEditorWindow(KviMainWindow * pFrm)
+ClassEditorWindow::ClassEditorWindow(KviMainWindow * pFrm)
 : KviWindow(KVI_WINDOW_TYPE_SCRIPTEDITOR,pFrm,"classeditor",0)
 {
 	g_pClassEditorWindow = this;
@@ -1824,7 +1824,7 @@ KviClassEditorWindow::KviClassEditorWindow(KviMainWindow * pFrm)
 
 	QGridLayout * pLayout = new QGridLayout();
 
-	m_pEditor = new KviClassEditor(this);
+	m_pEditor = new ClassEditorWidget(this);
 	pLayout->addWidget(m_pEditor,0,0,1,4);
 
 	QPushButton * pBtn = new QPushButton(__tr2qs_ctx("&Build","editor"),this);
@@ -1847,47 +1847,47 @@ KviClassEditorWindow::KviClassEditorWindow(KviMainWindow * pFrm)
 	setLayout(pLayout);
 }
 
-KviClassEditorWindow::~KviClassEditorWindow()
+ClassEditorWindow::~ClassEditorWindow()
 {
 	g_pClassEditorWindow = 0;
 }
 
-void KviClassEditorWindow::buildClicked()
+void ClassEditorWindow::buildClicked()
 {
 	m_pEditor->build();
 }
 
-void KviClassEditorWindow::saveClicked()
+void ClassEditorWindow::saveClicked()
 {
 	m_pEditor->saveNotBuiltClasses();
 }
 
-void KviClassEditorWindow::cancelClicked()
+void ClassEditorWindow::cancelClicked()
 {
 	close();
 }
 
-QPixmap * KviClassEditorWindow::myIconPtr()
+QPixmap * ClassEditorWindow::myIconPtr()
 {
 	return g_pIconManager->getSmallIcon(KVI_SMALLICON_CLASSEDITOR);
 }
 
-void KviClassEditorWindow::configGroupName(QString &szName)
+void ClassEditorWindow::configGroupName(QString &szName)
 {
 	szName = "classeditor";
 }
 
-void KviClassEditorWindow::saveProperties(KviConfigurationFile * pCfg)
+void ClassEditorWindow::saveProperties(KviConfigurationFile * pCfg)
 {
 	m_pEditor->saveProperties(pCfg);
 }
 
-void KviClassEditorWindow::loadProperties(KviConfigurationFile * pCfg)
+void ClassEditorWindow::loadProperties(KviConfigurationFile * pCfg)
 {
 	m_pEditor->loadProperties(pCfg);
 }
 
-KviClassEditorDialog::KviClassEditorDialog(QWidget * pParent, const QString & szName, KviPointerHashTable<QString,KviClassEditorTreeWidgetItem> * pClasses, const QString & szClassName, const QString & szInheritsClassName, bool bRenameMode)
+KviClassEditorDialog::KviClassEditorDialog(QWidget * pParent, const QString & szName, KviPointerHashTable<QString,ClassEditorTreeWidgetItem> * pClasses, const QString & szClassName, const QString & szInheritsClassName, bool bRenameMode)
 : QDialog(pParent)
 {
 	setObjectName(szName);
@@ -1934,7 +1934,7 @@ KviClassEditorDialog::KviClassEditorDialog(QWidget * pParent, const QString & sz
 	m_pInheritsClassComboBox = new QComboBox(pHBox);
 	pLabel->setBuddy(m_pInheritsClassComboBox);
 
-	KviPointerHashTableIterator<QString,KviClassEditorTreeWidgetItem> pClassesIt(*pClasses);
+	KviPointerHashTableIterator<QString,ClassEditorTreeWidgetItem> pClassesIt(*pClasses);
 
 	QStringList szClasses;
 	while(pClassesIt.current())
diff --git a/src/modules/classeditor/classeditor.h b/src/modules/classeditor/ClassEditorWindow.h
index c04bd7da4..f13956c91 100644
--- a/src/modules/classeditor/classeditor.h
+++ b/src/modules/classeditor/ClassEditorWindow.h
@@ -2,7 +2,7 @@
 #define _CLASSEDITOR_H_
 //=============================================================================
 //
-//   File : classeditor.h
+//   File : ClassEditorWindow.h
 //   Creation date : Mon Feb 15 2010 14:35:55 CEST by Carbone Alessandro
 //
 //   This file is part of the KVIrc irc client distribution
@@ -25,7 +25,7 @@
 //=============================================================================
 
 /**
-* \file classeditor.h
+* \file ClassEditorWindow.h
 * \author Alessandro Carbone
 * \brief Class Editor window
 */
@@ -53,24 +53,24 @@ class QSplitter;
 class KviScriptEditor;
 
 /**
-* \class KviClassEditorTreeWidget
+* \class ClassEditorTreeWidget
 * \brief Describes the tree widget hierarchy
 */
-class KviClassEditorTreeWidget : public QTreeWidget
+class ClassEditorTreeWidget : public QTreeWidget
 {
 	Q_OBJECT
 public:
 	/**
 	* \brief Construct the tree widget
 	* \param pParent The parent widget
-	* \return KviClassEditorTreeWidget
+	* \return ClassEditorTreeWidget
 	*/
-	KviClassEditorTreeWidget(QWidget * pParent);
+	ClassEditorTreeWidget(QWidget * pParent);
 	
 	/**
 	* \brief Destroys the tree widget
 	*/
-	~KviClassEditorTreeWidget();
+	~ClassEditorTreeWidget();
 protected:
 	virtual void mousePressEvent(QMouseEvent * e);
 signals:
@@ -84,10 +84,10 @@ signals:
 };
 
 /**
-* \class KviClassEditorTreeWidgetItem
+* \class ClassEditorTreeWidgetItem
 * \brief Describes an item inside the class editor tree widget
 */
-class KviClassEditorTreeWidgetItem : public QTreeWidgetItem, public KviHeapObject
+class ClassEditorTreeWidgetItem : public QTreeWidgetItem, public KviHeapObject
 {
 public:
 	/**
@@ -106,23 +106,23 @@ public:
 	* \param pTreeWidget The parent tree widget
 	* \param eType The type of the item
 	* \param szName The name of the item
-	* \return KviClassEditorTreeWidgetItem
+	* \return ClassEditorTreeWidgetItem
 	*/
-	KviClassEditorTreeWidgetItem(QTreeWidget * pTreeWidget, Type eType, const QString & szName);
+	ClassEditorTreeWidgetItem(QTreeWidget * pTreeWidget, Type eType, const QString & szName);
 	
 	/**
 	* \brief Constructs the class editor tree widget item
 	* \param pParentItem The parent tree widget item
 	* \param eType The type of the item
 	* \param szName The name of the item
-	* \return KviClassEditorTreeWidgetItem
+	* \return ClassEditorTreeWidgetItem
 	*/
-	KviClassEditorTreeWidgetItem(KviClassEditorTreeWidgetItem * pParentItem, Type eType, const QString & szName);
+	ClassEditorTreeWidgetItem(ClassEditorTreeWidgetItem * pParentItem, Type eType, const QString & szName);
 	
 	/**
 	* \brief Destroys the class editor tree widget item
 	*/
-	~KviClassEditorTreeWidgetItem(){};
+	~ClassEditorTreeWidgetItem(){};
 protected:
 	Type    m_eType;
 	QString m_szName;
@@ -257,41 +257,41 @@ public:
 };
 
 /**
-* \class KviClassEditor
+* \class ClassEditorWidget
 * \brief The Class Editor module
 */
-class KviClassEditor : public QWidget
+class ClassEditorWidget : public QWidget
 {
 	Q_OBJECT
 public:
 	/**
 	* \brief Constructs the class editor object
 	* \param pParent The parent widget
-	* \return KviClassEditor
+	* \return ClassEditorWidget
 	*/
-	KviClassEditor(QWidget * pParent);
+	ClassEditorWidget(QWidget * pParent);
 	
 	/**
 	* \brief Destroys the class editor object
 	*/
-	~KviClassEditor();
+	~ClassEditorWidget();
 public:
 	KviScriptEditor              * m_pEditor;
-	KviClassEditorTreeWidget     * m_pTreeWidget;
+	ClassEditorTreeWidget     * m_pTreeWidget;
 	QLabel                       * m_pClassNameLabel;
 	QPushButton                  * m_pClassNameRenameButton;
 	QLabel                       * m_pFunctionNameLabel;
 	QPushButton                  * m_pFunctionNameRenameButton;
 	QLabel                       * m_pReminderLabel;
 
-	KviClassEditorTreeWidgetItem * m_pLastEditedItem;
-	KviClassEditorTreeWidgetItem * m_pLastClickedItem;
+	ClassEditorTreeWidgetItem * m_pLastEditedItem;
+	ClassEditorTreeWidgetItem * m_pLastClickedItem;
 	KviTalPopupMenu              * m_pContextPopup;
 	QSplitter                    * m_pSplitter;
 	QString                        m_szDir;
 	bool                           m_bSaving;
 protected:
-	KviPointerHashTable<QString,KviClassEditorTreeWidgetItem> * m_pClasses;
+	KviPointerHashTable<QString,ClassEditorTreeWidgetItem> * m_pClasses;
 public:
 	/**
 	* \brief Called to save the window properties
@@ -329,9 +329,9 @@ public:
 	* \brief Searches a function
 	* \param szFunctionName The name of the function
 	* \param pClass The class in which the function is
-	* \return KviClassEditorTreeWidgetItem *
+	* \return ClassEditorTreeWidgetItem *
 	*/
-	KviClassEditorTreeWidgetItem * findFunction(const QString & szFunctionName, KviClassEditorTreeWidgetItem * pClass);
+	ClassEditorTreeWidgetItem * findFunction(const QString & szFunctionName, ClassEditorTreeWidgetItem * pClass);
 
 	/**
 	* \brief Exports class to a file
@@ -346,28 +346,28 @@ public:
 	* \param pList The list of file to export
 	* \return void
 	*/
-	void exportSelectionInSinglesFiles(KviPointerList<KviClassEditorTreeWidgetItem> * pList);
+	void exportSelectionInSinglesFiles(KviPointerList<ClassEditorTreeWidgetItem> * pList);
 	
 	/**
 	* \brief Removes the item from the tree
 	* \param pItem The item to remove
 	* \return void
 	*/
-	void cutItem(KviClassEditorTreeWidgetItem * pItem);
+	void cutItem(ClassEditorTreeWidgetItem * pItem);
 protected:
-	//void recursiveSearchReplace(const QString &szSearch,KviClassEditorTreeWidgetItem * it,bool bReplace=false,const QString &szReplace="n");
+	//void recursiveSearchReplace(const QString &szSearch,ClassEditorTreeWidgetItem * it,bool bReplace=false,const QString &szReplace="n");
 
-	void exportClassBuffer(QString & szBuffer, KviClassEditorTreeWidgetItem * pItem);
+	void exportClassBuffer(QString & szBuffer, ClassEditorTreeWidgetItem * pItem);
 
 	void oneTimeSetup();
-	void createFullClass(KviKvsObjectClass * pClass, KviClassEditorTreeWidgetItem * pItem, const QString & szClassName);
+	void createFullClass(KviKvsObjectClass * pClass, ClassEditorTreeWidgetItem * pItem, const QString & szClassName);
 
 	void saveLastEditedItem();
-	void appendSelectedClassItems(KviPointerList<KviClassEditorTreeWidgetItem> * pList);
-	void appendSelectedClassItemsRecursive(KviPointerList<KviClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom);
+	void appendSelectedClassItems(KviPointerList<ClassEditorTreeWidgetItem> * pList);
+	void appendSelectedClassItemsRecursive(KviPointerList<ClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom);
 
-	void appendAllClassItems(KviPointerList<KviClassEditorTreeWidgetItem> * pList);
-	void appendAllClassItemsRecursive(KviPointerList<KviClassEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom);
+	void appendAllClassItems(KviPointerList<ClassEditorTreeWidgetItem> * pList);
+	void appendAllClassItemsRecursive(KviPointerList<ClassEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom);
 
 	void openParentItems(QTreeWidgetItem * pItem);
 	void activateItem(QTreeWidgetItem * pItem);
@@ -375,7 +375,7 @@ protected:
 	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, QString & szReminder, bool * pbInternal, const QString & szClassName, bool bRenameMode);
-	void searchInheritedClasses(const QString szClass, KviPointerList<KviClassEditorTreeWidgetItem> & lInheritsedClasses);
+	void searchInheritedClasses(const QString szClass, KviPointerList<ClassEditorTreeWidgetItem> & lInheritsedClasses);
 	
 	/**
 	* \brief Returns true if the class exists, false otherwise
@@ -389,35 +389,35 @@ protected:
 	* \param pClass The class to rename
 	* \return void
 	*/
-	void renameClass(KviClassEditorTreeWidgetItem * pClass);
+	void renameClass(ClassEditorTreeWidgetItem * pClass);
 	
 	/**
 	* \brief Renames a namespace
 	* \param pNamespace The namespace to rename
 	* \return void
 	*/
-	void renameNamespace(KviClassEditorTreeWidgetItem * pNamespace);
+	void renameNamespace(ClassEditorTreeWidgetItem * pNamespace);
 
-	bool removeItem(KviClassEditorTreeWidgetItem * pItem, KviPointerList <KviClassEditorTreeWidgetItem> & lRemovedItems, bool * pbYesToAll);
-	void updateClassHierarchy(KviClassEditorTreeWidgetItem * pClass);
+	bool removeItem(ClassEditorTreeWidgetItem * pItem, KviPointerList <ClassEditorTreeWidgetItem> & lRemovedItems, bool * pbYesToAll);
+	void updateClassHierarchy(ClassEditorTreeWidgetItem * pClass);
 
-	void removeItemChildren(KviClassEditorTreeWidgetItem * pItem, KviPointerList <KviClassEditorTreeWidgetItem> & lRemovedItems);
-	void buildFullItemPath(KviClassEditorTreeWidgetItem * pItem, QString & szBuffer);
-	QString buildFullClassName(KviClassEditorTreeWidgetItem * pItem);
-	KviClassEditorTreeWidgetItem * createFullItem(const QString & szFullName);
-	KviClassEditorTreeWidgetItem * createFullNamespace(const QString & szFullName);
+	void removeItemChildren(ClassEditorTreeWidgetItem * pItem, KviPointerList <ClassEditorTreeWidgetItem> & lRemovedItems);
+	void buildFullItemPath(ClassEditorTreeWidgetItem * pItem, QString & szBuffer);
+	QString buildFullClassName(ClassEditorTreeWidgetItem * pItem);
+	ClassEditorTreeWidgetItem * createFullItem(const QString & szFullName);
+	ClassEditorTreeWidgetItem * createFullNamespace(const QString & szFullName);
 
 	/**
 	* \brief Searches an item
 	* \param szName The name of the item to find
-	* \return KviClassEditorTreeWidgetItem *
+	* \return ClassEditorTreeWidgetItem *
 	*/
-	KviClassEditorTreeWidgetItem * findItem(const QString & szName);
+	ClassEditorTreeWidgetItem * findItem(const QString & szName);
 	
 	
 	
-	KviClassEditorTreeWidgetItem * findTopLevelItem(const QString & szName);
-	KviClassEditorTreeWidgetItem * createFullItemRecursive(QTreeWidgetItem * pCurrent, QStringList & lNameSpaces, int & iLevel, bool bCreateNameSpace = 0);
+	ClassEditorTreeWidgetItem * findTopLevelItem(const QString & szName);
+	ClassEditorTreeWidgetItem * createFullItemRecursive(QTreeWidgetItem * pCurrent, QStringList & lNameSpaces, int & iLevel, bool bCreateNameSpace = 0);
 protected slots:
 	void currentItemChanged(QTreeWidgetItem * pItem, QTreeWidgetItem *);
 	void customContextMenuRequested(QPoint);
@@ -425,7 +425,7 @@ protected slots:
 	void newNamespace();
 	void newMemberFunction();
 	void renameFunction();
-	KviClassEditorTreeWidgetItem * newItem(QString & szName, KviClassEditorTreeWidgetItem::Type eType);
+	ClassEditorTreeWidgetItem * newItem(QString & szName, ClassEditorTreeWidgetItem::Type eType);
 
 	void renameItem();
 
@@ -448,7 +448,7 @@ protected slots:
 	* \param pItem The starting item to collapse
 	* \return void
 	*/
-	void recursiveCollapseItems(KviClassEditorTreeWidgetItem * pItem);
+	void recursiveCollapseItems(ClassEditorTreeWidgetItem * pItem);
 
 	/**
 	* \brief Called when we want to remove all selected items
@@ -466,26 +466,26 @@ protected slots:
 };
 
 /**
-* \class KviClassEditorWindow
+* \class ClassEditorWindow
 * \brief This is the Class Editor window
 */
-class KviClassEditorWindow : public KviWindow
+class ClassEditorWindow : public KviWindow
 {
 	Q_OBJECT
 public:
 	/**
 	* \brief Constructs the class editor window
 	* \param pFrm The parent frame
-	* \return KviClassEditorWindow
+	* \return ClassEditorWindow
 	*/
-	KviClassEditorWindow(KviMainWindow * pFrm);
+	ClassEditorWindow(KviMainWindow * pFrm);
 	
 	/**
 	* \brief Destroys the class editor window
 	*/
-	~KviClassEditorWindow();
+	~ClassEditorWindow();
 protected:
-	KviClassEditor * m_pEditor;
+	ClassEditorWidget * m_pEditor;
 protected:
 	/**
 	* \brief Returns the class editor small icon
@@ -551,7 +551,7 @@ public:
 	* \param bRenameMode Whether the dialog is in rename mode
 	* \return KviClassEditorDialog
 	*/
-	KviClassEditorDialog(QWidget * pParent, const QString & szName, KviPointerHashTable<QString,KviClassEditorTreeWidgetItem> * pClasses, const QString & szClassName, const QString & szInheritsClassName, bool bRenameMode = false);
+	KviClassEditorDialog(QWidget * pParent, const QString & szName, KviPointerHashTable<QString,ClassEditorTreeWidgetItem> * pClasses, const QString & szClassName, const QString & szInheritsClassName, bool bRenameMode = false);
 	
 	/**
 	* \brief Destroys the class dialog
diff --git a/src/modules/classeditor/libkviclasseditor.cpp b/src/modules/classeditor/libkviclasseditor.cpp
index a0214b8d8..a45256029 100644
--- a/src/modules/classeditor/libkviclasseditor.cpp
+++ b/src/modules/classeditor/libkviclasseditor.cpp
@@ -22,14 +22,14 @@
 //
 //=============================================================================
 
-#include "classeditor.h"
+#include "ClassEditorWindow.h"
 
 #include "KviModule.h"
 #include "KviLocale.h"
 #include "KviMainWindow.h"
 
 
-KviClassEditorWindow * g_pClassEditorWindow = 0;
+ClassEditorWindow * g_pClassEditorWindow = 0;
 KviModule * g_pClassEditorModule = 0;
 
 
@@ -50,7 +50,7 @@ static bool classeditor_kvs_cmd_open(KviKvsModuleCommandCall * c)
 {
 	if(!g_pClassEditorWindow)
 	{
-		g_pClassEditorWindow = new KviClassEditorWindow(c->window()->frame());
+		g_pClassEditorWindow = new ClassEditorWindow(c->window()->frame());
 		c->window()->frame()->addWindow(g_pClassEditorWindow);
 	}