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, 181 insertions, 181 deletions

diff --git a/src/modules/aliaseditor/aliaseditor.cpp b/src/modules/aliaseditor/AliasEditorWindow.cpp
index 3fe332576..e53272448 100644
--- a/src/modules/aliaseditor/aliaseditor.cpp
+++ b/src/modules/aliaseditor/AliasEditorWindow.cpp
@@ -1,6 +1,6 @@
 //=============================================================================
 //
-//   File : aliaseditor.cpp
+//   File : AliasEditorWindow.cpp
 //   Creation date : Mon Dec 23 2002 14:36:18 by Szymon Stefanek
 //
 //   This file is part of the KVIrc irc client distribution
@@ -23,7 +23,7 @@
 //=============================================================================
 
 
-#include "aliaseditor.h"
+#include "AliasEditorWindow.h"
 
 #include "KviIconManager.h"
 #include "KviOptions.h"
@@ -58,42 +58,42 @@
 #include <QList>
 #include <QPainter>
 #include <QBrush>
-extern KviAliasEditorWindow * g_pAliasEditorWindow;
+extern AliasEditorWindow * g_pAliasEditorWindow;
 extern KviModule * g_pAliasEditorModule;
 
 
-KviAliasEditorTreeWidgetItem::KviAliasEditorTreeWidgetItem(QTreeWidget * pTreeWidget,Type eType,const QString &szName)
+AliasEditorTreeWidgetItem::AliasEditorTreeWidgetItem(QTreeWidget * pTreeWidget,Type eType,const QString &szName)
 : QTreeWidgetItem(pTreeWidget), KviHeapObject(), m_eType(eType), m_pParentItem(0)
 {
 	setName(szName);
 	m_cPos=0;
-	if(eType==KviAliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE))));
+	if(eType==AliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE))));
 	else setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS))));
 }
 
-KviAliasEditorTreeWidgetItem::KviAliasEditorTreeWidgetItem(KviAliasEditorTreeWidgetItem * pParentItem,Type eType,const QString &szName)
+AliasEditorTreeWidgetItem::AliasEditorTreeWidgetItem(AliasEditorTreeWidgetItem * pParentItem,Type eType,const QString &szName)
 : QTreeWidgetItem(pParentItem), m_eType(eType), m_pParentItem(pParentItem)
 {
 	setName(szName);
 	m_cPos=0;
 	setFlags(Qt::ItemIsEditable|Qt::ItemIsEnabled|Qt::ItemIsSelectable);
-	if(eType==KviAliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE))));
+	if(eType==AliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE))));
 	else setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS))));
 }
 
-void KviAliasEditorTreeWidgetItem::setName(const QString &szName)
+void AliasEditorTreeWidgetItem::setName(const QString &szName)
 {
 	m_szName = szName;
 	setText(0,m_szName);
 }
-void KviAliasEditorTreeWidgetItem::setType(Type t)
+void AliasEditorTreeWidgetItem::setType(Type t)
 {
 	m_eType=t;
-	if(t==KviAliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE))));
+	if(t==AliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE))));
 		else setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS))));
 }
 
-KviAliasEditorTreeWidget::KviAliasEditorTreeWidget(QWidget * par)
+AliasEditorTreeWidget::AliasEditorTreeWidget(QWidget * par)
 : QTreeWidget(par)
 {
 	setColumnCount (1);
@@ -104,17 +104,17 @@ KviAliasEditorTreeWidget::KviAliasEditorTreeWidget(QWidget * par)
 	setAnimated(true);
 }
 
-KviAliasEditorTreeWidget::~KviAliasEditorTreeWidget()
+AliasEditorTreeWidget::~AliasEditorTreeWidget()
 {
 	//remove and delete all items
 	clear();
 }
 
 
-KviAliasEditor::KviAliasEditor(QWidget * par)
+AliasEditorWidget::AliasEditorWidget(QWidget * par)
 : QWidget(par)
 {
-	m_pAliases=new KviPointerList<KviAliasEditorTreeWidgetItem>;
+	m_pAliases=new KviPointerList<AliasEditorTreeWidgetItem>;
 	m_pAliases->setAutoDelete(false);
 
 	m_bSaving = false;
@@ -132,7 +132,7 @@ KviAliasEditor::KviAliasEditor(QWidget * par)
 	box->setSpacing(0);
 	box->setMargin(0);
 
-	m_pTreeWidget = new KviAliasEditorTreeWidget(box);
+	m_pTreeWidget = new AliasEditorTreeWidget(box);
 
 	box = new KviTalVBox(m_pSplitter);
 	KviTalHBox * hbox = new KviTalHBox(box);
@@ -157,13 +157,13 @@ KviAliasEditor::KviAliasEditor(QWidget * par)
 	currentItemChanged(0,0);
 }
 
-KviAliasEditor::~KviAliasEditor()
+AliasEditorWidget::~AliasEditorWidget()
 {
 	KviScriptEditor::destroyInstance(m_pEditor);
 	delete m_pAliases;
 }
 
-void KviAliasEditor::buildFullItemPath(KviAliasEditorTreeWidgetItem * it,QString &szBuffer)
+void AliasEditorWidget::buildFullItemPath(AliasEditorTreeWidgetItem * it,QString &szBuffer)
 {
 	if (it->isAlias()) it=it->parentItem();
 	if (!it) return;
@@ -179,11 +179,11 @@ void KviAliasEditor::buildFullItemPath(KviAliasEditorTreeWidgetItem * it,QString
 	}
 }
 
-QString KviAliasEditor::buildFullItemName(KviAliasEditorTreeWidgetItem * it)
+QString AliasEditorWidget::buildFullItemName(AliasEditorTreeWidgetItem * it)
 {
 	if(!it) return QString();
 	QString szName = it->name();
-	KviAliasEditorTreeWidgetItem * nit = it->parentItem();
+	AliasEditorTreeWidgetItem * nit = it->parentItem();
 
 	while(nit)
 	{
@@ -199,23 +199,23 @@ QString KviAliasEditor::buildFullItemName(KviAliasEditorTreeWidgetItem * it)
 }
 
 //FIXME this should be called something like "findNamespace"
-KviAliasEditorTreeWidgetItem * KviAliasEditor::findTopLevelItem(const QString &szName)
+AliasEditorTreeWidgetItem * AliasEditorWidget::findTopLevelItem(const QString &szName)
 {
-	KviAliasEditorTreeWidgetItem *pItem =0;
+	AliasEditorTreeWidgetItem *pItem =0;
 	for(int i=0;i<m_pTreeWidget->topLevelItemCount();i++)
 	{
-		pItem = (KviAliasEditorTreeWidgetItem*) m_pTreeWidget->topLevelItem(i);
+		pItem = (AliasEditorTreeWidgetItem*) m_pTreeWidget->topLevelItem(i);
 		if (pItem->text(0)==szName && pItem->isNamespace())
-			return (KviAliasEditorTreeWidgetItem*)m_pTreeWidget->topLevelItem(i);
+			return (AliasEditorTreeWidgetItem*)m_pTreeWidget->topLevelItem(i);
 	}
 	return 0;
 }
 
-KviAliasEditorTreeWidgetItem * KviAliasEditor::findItem(const QString &szFullName)
+AliasEditorTreeWidgetItem * AliasEditorWidget::findItem(const QString &szFullName)
 {
 	QStringList lNamespaces=szFullName.split("::");
 	if(!lNamespaces.count()) return 0;
-	KviAliasEditorTreeWidgetItem *pItem=findTopLevelItem(lNamespaces.at(0));
+	AliasEditorTreeWidgetItem *pItem=findTopLevelItem(lNamespaces.at(0));
 	if (!pItem) return 0;
 	bool bFound;
 	int i;
@@ -227,24 +227,24 @@ KviAliasEditorTreeWidgetItem * KviAliasEditor::findItem(const QString &szFullNam
 		{
 			if (KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i)))
 			{
-				pItem=( KviAliasEditorTreeWidgetItem *)pItem->child(j);
+				pItem=( AliasEditorTreeWidgetItem *)pItem->child(j);
 				bFound=true;
 				break;
 			}
 		}
 		if (!bFound) return 0;
 	}
-	return (KviAliasEditorTreeWidgetItem *)pItem;
+	return (AliasEditorTreeWidgetItem *)pItem;
 }
 
 
-KviAliasEditorTreeWidgetItem * KviAliasEditor::createFullItem(const QString &szFullName)
+AliasEditorTreeWidgetItem * AliasEditorWidget::createFullItem(const QString &szFullName)
 {
 	QStringList lNamespaces=szFullName.split("::");
 	if(!lNamespaces.count()) return 0;
-	if (lNamespaces.count()==1) return new KviAliasEditorTreeWidgetItem(m_pTreeWidget,KviAliasEditorTreeWidgetItem::Alias,lNamespaces.at(0));
-	KviAliasEditorTreeWidgetItem *pItem=findTopLevelItem(lNamespaces.at(0));
-	if (!pItem) pItem=new KviAliasEditorTreeWidgetItem(m_pTreeWidget,KviAliasEditorTreeWidgetItem::Namespace,lNamespaces.at(0));
+	if (lNamespaces.count()==1) return new AliasEditorTreeWidgetItem(m_pTreeWidget,AliasEditorTreeWidgetItem::Alias,lNamespaces.at(0));
+	AliasEditorTreeWidgetItem *pItem=findTopLevelItem(lNamespaces.at(0));
+	if (!pItem) pItem=new AliasEditorTreeWidgetItem(m_pTreeWidget,AliasEditorTreeWidgetItem::Namespace,lNamespaces.at(0));
 	bool bFound;
 	int i;
 	for(i=1;i<lNamespaces.count()-1;i++)
@@ -254,26 +254,26 @@ KviAliasEditorTreeWidgetItem * KviAliasEditor::createFullItem(const QString &szF
 		{
 			if (KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i)))
 			{
-				pItem=( KviAliasEditorTreeWidgetItem *)pItem->child(j);
+				pItem=( AliasEditorTreeWidgetItem *)pItem->child(j);
 				bFound=true;
 				break;
 			}
 		}
 		if (!bFound)
-			pItem=new KviAliasEditorTreeWidgetItem(pItem,KviAliasEditorTreeWidgetItem::Namespace,lNamespaces.at(i));
+			pItem=new AliasEditorTreeWidgetItem(pItem,AliasEditorTreeWidgetItem::Namespace,lNamespaces.at(i));
 	}
-	return new KviAliasEditorTreeWidgetItem(pItem,KviAliasEditorTreeWidgetItem::Alias,lNamespaces.at(i));
+	return new AliasEditorTreeWidgetItem(pItem,AliasEditorTreeWidgetItem::Alias,lNamespaces.at(i));
 }
 
 
-void KviAliasEditor::oneTimeSetup()
+void AliasEditorWidget::oneTimeSetup()
 {
 	KviPointerHashTable<QString,KviKvsScript> * a = KviKvsAliasManager::instance()->aliasDict();
 	if(!a)return;
 
 	KviPointerHashTableIterator<QString,KviKvsScript> it(*a);
 
-	KviAliasEditorTreeWidgetItem * item;
+	AliasEditorTreeWidgetItem * item;
 	while(it.current())
 	{
 		KviKvsScript * alias = it.current();
@@ -291,18 +291,18 @@ void KviAliasEditor::oneTimeSetup()
 	m_pTreeWidget->sortItems(0,Qt::AscendingOrder);
 }
 
-void KviAliasEditor::aliasRefresh(const QString &szName)
+void AliasEditorWidget::aliasRefresh(const QString &szName)
 {
 	if(m_bSaving)
 		return;
-	KviAliasEditorTreeWidgetItem * item=0;
+	AliasEditorTreeWidgetItem * item=0;
 	KviKvsScript * alias = KviKvsAliasManager::instance()->aliasDict()->find(szName);
 
 	// search for old alias with same name
-	KviPointerList<KviAliasEditorTreeWidgetItem> l;
+	KviPointerList<AliasEditorTreeWidgetItem> l;
 	l.setAutoDelete(false);
-	appendAllItems(&l,KviAliasEditorTreeWidgetItem::Alias);
-	for(KviAliasEditorTreeWidgetItem * it = l.first();it;it = l.next())
+	appendAllItems(&l,AliasEditorTreeWidgetItem::Alias);
+	for(AliasEditorTreeWidgetItem * it = l.first();it;it = l.next())
 	{
 		if (KviQString::equalCI(buildFullItemName(it),szName))
 		{
@@ -330,14 +330,14 @@ void KviAliasEditor::aliasRefresh(const QString &szName)
 	item->setBuffer(alias->code());
 	m_pEditor->setText(alias->code());
 }
-void KviAliasEditor::itemRenamed(QTreeWidgetItem *it,int col)
+void AliasEditorWidget::itemRenamed(QTreeWidgetItem *it,int col)
 {
 	if(it!=m_pLastEditedItem) return;
 	
-	((KviAliasEditorTreeWidgetItem *)it)->setName(it->text(col));
-	QString szNam = buildFullItemName((KviAliasEditorTreeWidgetItem *)it);
+	((AliasEditorTreeWidgetItem *)it)->setName(it->text(col));
+	QString szNam = buildFullItemName((AliasEditorTreeWidgetItem *)it);
 	QString szLabelText;
-	if(((KviAliasEditorTreeWidgetItem *)it)->isNamespace())
+	if(((AliasEditorTreeWidgetItem *)it)->isNamespace())
 		szLabelText = __tr2qs_ctx("Namespace","editor");
 	else
 		szLabelText = __tr2qs_ctx("Alias","editor");
@@ -349,50 +349,50 @@ void KviAliasEditor::itemRenamed(QTreeWidgetItem *it,int col)
 
 
 
-bool KviAliasEditor::hasSelectedItems()
+bool AliasEditorWidget::hasSelectedItems()
 	{
 	return m_pTreeWidget->selectedItems().count()?1:0;
 }
 
-bool KviAliasEditor::itemExists(QTreeWidgetItem *pSearchFor)
+bool AliasEditorWidget::itemExists(QTreeWidgetItem *pSearchFor)
 {
 	if(!pSearchFor)return false;
-	if (m_pAliases->findRef((KviAliasEditorTreeWidgetItem*) pSearchFor)!=-1) return true;
+	if (m_pAliases->findRef((AliasEditorTreeWidgetItem*) pSearchFor)!=-1) return true;
 	else return false;
 }
 
-void KviAliasEditor::appendAllItems(KviPointerList<KviAliasEditorTreeWidgetItem> * l,KviAliasEditorTreeWidgetItem::Type eType)
+void AliasEditorWidget::appendAllItems(KviPointerList<AliasEditorTreeWidgetItem> * l,AliasEditorTreeWidgetItem::Type eType)
 {
 	for (int i=0;i<m_pTreeWidget->topLevelItemCount();i++)
 	{
-		if (((KviAliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->type()==eType)
+		if (((AliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->type()==eType)
 		{
-			l->append(((KviAliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i)));
+			l->append(((AliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i)));
 		} else {
 			appendAllItemsRecursive(l,m_pTreeWidget->topLevelItem(i),eType);
 		}
 	}
 }
 
-void KviAliasEditor::appendAllItemsRecursive(KviPointerList<KviAliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom,KviAliasEditorTreeWidgetItem::Type eType)
+void AliasEditorWidget::appendAllItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom,AliasEditorTreeWidgetItem::Type eType)
 {
 	for (int i=0;i<pStartFrom->childCount();i++)
 	{
-		if (((KviAliasEditorTreeWidgetItem *)pStartFrom->child(i))->type()==eType)
+		if (((AliasEditorTreeWidgetItem *)pStartFrom->child(i))->type()==eType)
 		{
-			l->append((KviAliasEditorTreeWidgetItem *)pStartFrom->child(i));
+			l->append((AliasEditorTreeWidgetItem *)pStartFrom->child(i));
 		} else {
 			appendAllItemsRecursive(l,pStartFrom->child(i),eType);
 		}
 	}
 }
 
-bool KviAliasEditor::aliasExists(QString &szFullItemName)
+bool AliasEditorWidget::aliasExists(QString &szFullItemName)
 {
-	KviPointerList<KviAliasEditorTreeWidgetItem> l;
+	KviPointerList<AliasEditorTreeWidgetItem> l;
 	l.setAutoDelete(false);
-	appendAllItems(&l,KviAliasEditorTreeWidgetItem::Alias);
-	for(KviAliasEditorTreeWidgetItem * it = l.first();it;it = l.next())
+	appendAllItems(&l,AliasEditorTreeWidgetItem::Alias);
+	for(AliasEditorTreeWidgetItem * it = l.first();it;it = l.next())
 	{
 		if (KviQString::equalCI(buildFullItemName(it),szFullItemName))
 		{
@@ -402,13 +402,13 @@ bool KviAliasEditor::aliasExists(QString &szFullItemName)
 	return false;
 }
 
-bool KviAliasEditor::namespaceExists(QString &szFullItemName)
+bool AliasEditorWidget::namespaceExists(QString &szFullItemName)
 {
-	KviPointerList<KviAliasEditorTreeWidgetItem> l;
+	KviPointerList<AliasEditorTreeWidgetItem> l;
 	l.setAutoDelete(false);
 
-	appendAllItems(&l,KviAliasEditorTreeWidgetItem::Namespace);
-	for(KviAliasEditorTreeWidgetItem * it = l.first();it;it = l.next())
+	appendAllItems(&l,AliasEditorTreeWidgetItem::Namespace);
+	for(AliasEditorTreeWidgetItem * it = l.first();it;it = l.next())
 	{
 		if (KviQString::equalCI(buildFullItemName(it),szFullItemName))
 		{
@@ -417,7 +417,7 @@ bool KviAliasEditor::namespaceExists(QString &szFullItemName)
 	}
 	return false;
 }
-void KviAliasEditor::renameItem()
+void AliasEditorWidget::renameItem()
 {
 	if(!m_pLastEditedItem)return;
 	//if(itemExists(m_pLastEditedItem))return; // dead ?
@@ -474,7 +474,7 @@ void KviAliasEditor::renameItem()
 
 	m_pLastEditedItem = 0; // make sure it's true (but it already should be because of removeItem())
 	m_pLastClickedItem = 0; // make sure it's true (but it already should be because of removeItem())
-	KviAliasEditorTreeWidgetItem * pItem = createFullItem(szNewName);
+	AliasEditorTreeWidgetItem * pItem = createFullItem(szNewName);
 	if(bAlias)
 	{
 		pItem->setBuffer(szCode);
@@ -483,7 +483,7 @@ void KviAliasEditor::renameItem()
 	} else {
 		for(int i=0;i<lChildren.count();i++)
 		{
-			((KviAliasEditorTreeWidgetItem*)lChildren.at(i))->setParentItem(pItem);
+			((AliasEditorTreeWidgetItem*)lChildren.at(i))->setParentItem(pItem);
 			pItem->insertChild(pItem->childCount(),lChildren.at(i));
 		}
 
@@ -495,22 +495,22 @@ void KviAliasEditor::renameItem()
 // warning: this saves ONLY the body, not the name!
 //          the name is changed explicitly with renameItem(), when needed
 
-void KviAliasEditor::saveLastEditedItem()
+void AliasEditorWidget::saveLastEditedItem()
 {
 	if(!m_pLastEditedItem)
 		return;
 	if(!itemExists(m_pLastEditedItem) || !m_pEditor->isModified() || m_pLastEditedItem->isNamespace())
 		return;
-	((KviAliasEditorTreeWidgetItem *)m_pLastEditedItem)->setCursorPosition(m_pEditor->getCursor());
+	((AliasEditorTreeWidgetItem *)m_pLastEditedItem)->setCursorPosition(m_pEditor->getCursor());
 	QString newCode;
 	m_pEditor->getText(newCode);
-	((KviAliasEditorTreeWidgetItem *)m_pLastEditedItem)->setBuffer(newCode);
+	((AliasEditorTreeWidgetItem *)m_pLastEditedItem)->setBuffer(newCode);
 }
 
-void KviAliasEditor::currentItemChanged(QTreeWidgetItem *it,QTreeWidgetItem *)
+void AliasEditorWidget::currentItemChanged(QTreeWidgetItem *it,QTreeWidgetItem *)
 {
 	saveLastEditedItem();
-	m_pLastEditedItem = (KviAliasEditorTreeWidgetItem *)it;
+	m_pLastEditedItem = (AliasEditorTreeWidgetItem *)it;
 
 	if(!m_pLastEditedItem)
 	{
@@ -542,18 +542,18 @@ void KviAliasEditor::currentItemChanged(QTreeWidgetItem *it,QTreeWidgetItem *)
 	szLabelText += "</b>";
 	m_pNameLabel->setText(szLabelText);
 	m_pRenameButton->setEnabled(true);
-	m_pEditor->setText(((KviAliasEditorTreeWidgetItem *)it)->buffer());
+	m_pEditor->setText(((AliasEditorTreeWidgetItem *)it)->buffer());
 
 	m_pEditor->setFocus();
-	m_pEditor->setCursorPosition(((KviAliasEditorTreeWidgetItem *)it)->cursorPosition());
+	m_pEditor->setCursorPosition(((AliasEditorTreeWidgetItem *)it)->cursorPosition());
 	m_pEditor->setEnabled(true);
 }
 
 
-void KviAliasEditor::customContextMenuRequested(const QPoint pnt)
+void AliasEditorWidget::customContextMenuRequested(const QPoint pnt)
 {
 	m_pContextPopup->clear();
-	m_pLastClickedItem = (KviAliasEditorTreeWidgetItem *)m_pTreeWidget->itemAt(pnt);
+	m_pLastClickedItem = (AliasEditorTreeWidgetItem *)m_pTreeWidget->itemAt(pnt);
 
 	int id;
 
@@ -616,11 +616,11 @@ void KviAliasEditor::customContextMenuRequested(const QPoint pnt)
 	m_pContextPopup->popup( m_pTreeWidget->mapToGlobal(pnt));
 }
 
-void KviAliasEditor::searchReplace(const QString &szSearch,bool bReplace,const QString &szReplace)
+void AliasEditorWidget::searchReplace(const QString &szSearch,bool bReplace,const QString &szReplace)
 {
 	for(unsigned int i=0;i<m_pAliases->count();i++)
 	{
-		KviAliasEditorTreeWidgetItem *pItem=m_pAliases->at(i);
+		AliasEditorTreeWidgetItem *pItem=m_pAliases->at(i);
 		if(pItem->buffer().indexOf(szSearch,0,Qt::CaseInsensitive) != -1)
 		{
 			pItem->setBackground(0, QColor(255,0,0,128));
@@ -632,7 +632,7 @@ void KviAliasEditor::searchReplace(const QString &szSearch,bool bReplace,const Q
 	}
 }
 
-void KviAliasEditor::slotFind()
+void AliasEditorWidget::slotFind()
 {
 
 	g_pAliasEditorModule->lock();
@@ -652,12 +652,12 @@ void KviAliasEditor::slotFind()
 	searchReplace(szSearch);
 }
 
-void KviAliasEditor::slotFindWord(const QString &szSearch)
+void AliasEditorWidget::slotFindWord(const QString &szSearch)
 {
 	m_pEditor->setFindText(szSearch);
 }
 
-void KviAliasEditor::recursiveCollapseNamespaces(KviAliasEditorTreeWidgetItem * it)
+void AliasEditorWidget::recursiveCollapseNamespaces(AliasEditorTreeWidgetItem * it)
 {
 	if(!it)return;
 	for (int i=0;i<it->childCount();i++)
@@ -665,29 +665,29 @@ void KviAliasEditor::recursiveCollapseNamespaces(KviAliasEditorTreeWidgetItem *
 		if(it->child(i)->childCount())
 		{
 			it->child(i)->setExpanded(false);
-			recursiveCollapseNamespaces((KviAliasEditorTreeWidgetItem *)it->child(i));
+			recursiveCollapseNamespaces((AliasEditorTreeWidgetItem *)it->child(i));
 		}
 	}
 }
 
-void KviAliasEditor::slotCollapseNamespaces()
+void AliasEditorWidget::slotCollapseNamespaces()
 {
 	for (int i=0;i<m_pTreeWidget->topLevelItemCount();i++)
 	{
 		if (m_pTreeWidget->topLevelItem(i)->childCount()){
 			m_pTreeWidget->topLevelItem(i)->setExpanded(false);
-			recursiveCollapseNamespaces((KviAliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i));
+			recursiveCollapseNamespaces((AliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i));
 		}
 	}
 }
 
-void KviAliasEditor::slotReplaceAll(const QString &szFind,const QString &szReplace)
+void AliasEditorWidget::slotReplaceAll(const QString &szFind,const QString &szReplace)
 {
 	m_pEditor->setFindText(szReplace);
 	searchReplace(szFind,true,szReplace);
 }
 
-void KviAliasEditor::getExportAliasBuffer(QString &buffer,KviAliasEditorTreeWidgetItem * it)
+void AliasEditorWidget::getExportAliasBuffer(QString &buffer,AliasEditorTreeWidgetItem * it)
 {
 	QString szBuf = it->buffer();
 	KviCommandFormatter::blockFromBuffer(szBuf);
@@ -700,22 +700,22 @@ void KviAliasEditor::getExportAliasBuffer(QString &buffer,KviAliasEditorTreeWidg
 	buffer += "\n";
 }
 
-void KviAliasEditor::exportAll()
+void AliasEditorWidget::exportAll()
 {
 	exportAliases(false);
 }
 
-void KviAliasEditor::exportSelectedSepFiles()
+void AliasEditorWidget::exportSelectedSepFiles()
 {
 	exportAliases (true,true);
 }
 
-void KviAliasEditor::exportSelected()
+void AliasEditorWidget::exportSelected()
 {
 	exportAliases(true);
 }
 
-void KviAliasEditor::exportSelectionInSinglesFiles(KviPointerList<KviAliasEditorTreeWidgetItem> *l)
+void AliasEditorWidget::exportSelectionInSinglesFiles(KviPointerList<AliasEditorTreeWidgetItem> *l)
 {
 	if(!m_szDir.endsWith(QString(KVI_PATH_SEPARATOR)))m_szDir += KVI_PATH_SEPARATOR;
 	if (!l->first())
@@ -736,7 +736,7 @@ void KviAliasEditor::exportSelectionInSinglesFiles(KviPointerList<KviAliasEditor
 
 	bool bReplaceAll=false;
 
-        for(KviAliasEditorTreeWidgetItem * it = l->first();it;it = l->next())
+        for(AliasEditorTreeWidgetItem * it = l->first();it;it = l->next())
 	{
 		QString tmp;
 		getExportAliasBuffer(tmp,it);
@@ -761,11 +761,11 @@ void KviAliasEditor::exportSelectionInSinglesFiles(KviPointerList<KviAliasEditor
 	g_pAliasEditorModule->unlock();
 }
 
-void KviAliasEditor::exportAliases(bool bSelectedOnly,bool bSingleFiles)
+void AliasEditorWidget::exportAliases(bool bSelectedOnly,bool bSingleFiles)
 {
 	saveLastEditedItem();
 
-	KviPointerList<KviAliasEditorTreeWidgetItem> l;
+	KviPointerList<AliasEditorTreeWidgetItem> l;
 	l.setAutoDelete(false);
 
 	if (bSelectedOnly) appendSelectedAliasItems(&l);
@@ -824,9 +824,9 @@ void KviAliasEditor::exportAliases(bool bSelectedOnly,bool bSingleFiles)
 		g_pAliasEditorModule->unlock();
 	}
 }
-void KviAliasEditor::buildAliasesFile(KviPointerList<KviAliasEditorTreeWidgetItem> *l, QString & szBuffer)
+void AliasEditorWidget::buildAliasesFile(KviPointerList<AliasEditorTreeWidgetItem> *l, QString & szBuffer)
 {
-	for(KviAliasEditorTreeWidgetItem * it = l->first();it;it = l->next())
+	for(AliasEditorTreeWidgetItem * it = l->first();it;it = l->next())
 	{
 		QString tmp;
 		getExportAliasBuffer(tmp,it);
@@ -835,7 +835,7 @@ void KviAliasEditor::buildAliasesFile(KviPointerList<KviAliasEditorTreeWidgetIte
 	}
 }
 
-void KviAliasEditor::saveProperties(KviConfigurationFile *cfg)
+void AliasEditorWidget::saveProperties(KviConfigurationFile *cfg)
 {
 	cfg->writeEntry("Sizes",m_pSplitter->sizes());
 	QString szName;
@@ -844,7 +844,7 @@ void KviAliasEditor::saveProperties(KviConfigurationFile *cfg)
 	cfg->writeEntry("LastAlias",szName);
 }
 
-void KviAliasEditor::loadProperties(KviConfigurationFile *cfg)
+void AliasEditorWidget::loadProperties(KviConfigurationFile *cfg)
 {
 	QList<int> def;
 	def.append(20);
@@ -852,61 +852,61 @@ void KviAliasEditor::loadProperties(KviConfigurationFile *cfg)
 	m_pSplitter->setSizes(cfg->readIntListEntry("Sizes",def));
 	QString tmp = cfg->readEntry("LastAlias",QString());
 
-	KviAliasEditorTreeWidgetItem * it = findItem(tmp);
+	AliasEditorTreeWidgetItem * it = findItem(tmp);
 	activateItem(it);
 }
 
-void KviAliasEditor::appendSelectedAliasItems(KviPointerList<KviAliasEditorTreeWidgetItem> * l)
+void AliasEditorWidget::appendSelectedAliasItems(KviPointerList<AliasEditorTreeWidgetItem> * l)
 {
 	QList<QTreeWidgetItem *> list=m_pTreeWidget->selectedItems();
 	for(int i=0;i<list.count();i++)
 	{
-		if (((KviAliasEditorTreeWidgetItem *)list.at(i))->isAlias())
+		if (((AliasEditorTreeWidgetItem *)list.at(i))->isAlias())
 		{
-			l->append((KviAliasEditorTreeWidgetItem *)list.at(i));
+			l->append((AliasEditorTreeWidgetItem *)list.at(i));
 		} else {
 			appendSelectedAliasItemsRecursive(l,list.at(i));
 		}
 	}
 }
-void KviAliasEditor::appendSelectedAliasItemsRecursive(KviPointerList<KviAliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom)
+void AliasEditorWidget::appendSelectedAliasItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom)
 {
 	for (int i=0;i<pStartFrom->childCount();i++)
 	{
-		if (((KviAliasEditorTreeWidgetItem *)pStartFrom->child(i))->isAlias())
-			l->append(((KviAliasEditorTreeWidgetItem *)pStartFrom->child(i)));
+		if (((AliasEditorTreeWidgetItem *)pStartFrom->child(i))->isAlias())
+			l->append(((AliasEditorTreeWidgetItem *)pStartFrom->child(i)));
 		else
 			appendSelectedAliasItemsRecursive(l,pStartFrom->child(i));
 	}
 }
 
 
-void KviAliasEditor::appendSelectedItems(KviPointerList<KviAliasEditorTreeWidgetItem> * l)
+void AliasEditorWidget::appendSelectedItems(KviPointerList<AliasEditorTreeWidgetItem> * l)
 {
 	QList<QTreeWidgetItem *> list=m_pTreeWidget->selectedItems();
 	for(int i=0;i<list.count();i++)
 	{
-		l->append((KviAliasEditorTreeWidgetItem *)list.at(i));
-		/* if (!((KviAliasEditorTreeWidgetItem *)list.at(i))->isAlias())
+		l->append((AliasEditorTreeWidgetItem *)list.at(i));
+		/* if (!((AliasEditorTreeWidgetItem *)list.at(i))->isAlias())
 			appendSelectedAliasItemsRecursive(l,list.at(i));*/
 	}
 
 }
-void KviAliasEditor::appendSelectedItemsRecursive(KviPointerList<KviAliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom)
+void AliasEditorWidget::appendSelectedItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom)
 {
 	for (int i=0;i<pStartFrom->childCount();i++)
 	{
-		l->append(((KviAliasEditorTreeWidgetItem *)pStartFrom->child(i)));
-		if (!((KviAliasEditorTreeWidgetItem *)pStartFrom->child(i))->isAlias())
+		l->append(((AliasEditorTreeWidgetItem *)pStartFrom->child(i)));
+		if (!((AliasEditorTreeWidgetItem *)pStartFrom->child(i))->isAlias())
 			appendSelectedAliasItemsRecursive(l,pStartFrom->child(i));
 	}
 }
 
-void KviAliasEditor::removeItemChildren(KviAliasEditorTreeWidgetItem *it)
+void AliasEditorWidget::removeItemChildren(AliasEditorTreeWidgetItem *it)
 {
 	while(it->childCount() > 0)
 	{
-		KviAliasEditorTreeWidgetItem * pChild = (KviAliasEditorTreeWidgetItem *)(it->child(0));
+		AliasEditorTreeWidgetItem * pChild = (AliasEditorTreeWidgetItem *)(it->child(0));
 		if(pChild->childCount())
 			removeItemChildren(pChild);
 		delete pChild;
@@ -914,7 +914,7 @@ void KviAliasEditor::removeItemChildren(KviAliasEditorTreeWidgetItem *it)
 	}
 }
 
-bool KviAliasEditor::removeItem(KviAliasEditorTreeWidgetItem *it,bool * pbYesToAll,bool)
+bool AliasEditorWidget::removeItem(AliasEditorTreeWidgetItem *it,bool * pbYesToAll,bool)
 {
 	if(!it)return true;
 	QString szMsg;
@@ -958,19 +958,19 @@ bool KviAliasEditor::removeItem(KviAliasEditorTreeWidgetItem *it,bool * pbYesToA
 	return true;
 }
 
-void KviAliasEditor::removeSelectedItems()
+void AliasEditorWidget::removeSelectedItems()
 {
-	KviPointerList<KviAliasEditorTreeWidgetItem> l;
+	KviPointerList<AliasEditorTreeWidgetItem> l;
 	l.setAutoDelete(false);
 	appendSelectedItems(&l);
 	bool bYesToAll = false;
-	for(KviAliasEditorTreeWidgetItem *it = l.first();it;it = l.next())
+	for(AliasEditorTreeWidgetItem *it = l.first();it;it = l.next())
 	{
 		if(!removeItem(it,&bYesToAll,false))return;
 	}
 }
 
-QString KviAliasEditor::askForAliasName(const QString &szAction,const QString &szText,const QString &szInitialText)
+QString AliasEditorWidget::askForAliasName(const QString &szAction,const QString &szText,const QString &szInitialText)
 {
 	bool bOk = false;
 	QString szNewName;
@@ -1038,7 +1038,7 @@ QString KviAliasEditor::askForAliasName(const QString &szAction,const QString &s
 	return szNewName;
 }
 
-QString KviAliasEditor::askForNamespaceName(const QString &szAction,const QString &szText,const QString &szInitialText)
+QString AliasEditorWidget::askForNamespaceName(const QString &szAction,const QString &szText,const QString &szInitialText)
 {
 	bool bOk = false;
 	QString szNewName;
@@ -1106,7 +1106,7 @@ QString KviAliasEditor::askForNamespaceName(const QString &szAction,const QStrin
 	return szNewName;
 }
 
-void KviAliasEditor::openParentItems(QTreeWidgetItem * it)
+void AliasEditorWidget::openParentItems(QTreeWidgetItem * it)
 {
 	if(it->parent())
 	{
@@ -1115,27 +1115,27 @@ void KviAliasEditor::openParentItems(QTreeWidgetItem * it)
 	}
 }
 
-void KviAliasEditor::activateItem(QTreeWidgetItem * it)
+void AliasEditorWidget::activateItem(QTreeWidgetItem * it)
 {
 	if (!it) return;
 	openParentItems(it);
 	m_pTreeWidget->setCurrentItem(it);
 }
-void KviAliasEditor::newAlias()
+void AliasEditorWidget::newAlias()
 {
 	QString szNewName = askForAliasName(__tr2qs_ctx("Add Alias","editor"),__tr2qs_ctx("Please enter the name for the new alias","editor"),"myfunction");
 	if(szNewName.isEmpty())return;
-	newItem(szNewName,KviAliasEditorTreeWidgetItem::Alias);
+	newItem(szNewName,AliasEditorTreeWidgetItem::Alias);
 }
 
-void KviAliasEditor::newNamespace()
+void AliasEditorWidget::newNamespace()
 {
 	QString szName = askForNamespaceName(__tr2qs_ctx("Add Namespace","editor"),__tr2qs_ctx("Please enter the name for the new namespace","editor"),"mynamespace");
 	if(szName.isEmpty())return;
-	newItem(szName,KviAliasEditorTreeWidgetItem::Namespace);
+	newItem(szName,AliasEditorTreeWidgetItem::Namespace);
 }
 
-void  KviAliasEditor::newItem(QString &szName,KviAliasEditorTreeWidgetItem::Type eType)
+void  AliasEditorWidget::newItem(QString &szName,AliasEditorTreeWidgetItem::Type eType)
 {
 	if(m_pLastClickedItem)
 		if(!itemExists(m_pLastClickedItem)) m_pLastClickedItem=0;
@@ -1150,14 +1150,14 @@ void  KviAliasEditor::newItem(QString &szName,KviAliasEditorTreeWidgetItem::Type
 		szName.append(szTmp);
 		idx++;
 	}
-	KviAliasEditorTreeWidgetItem * it;
+	AliasEditorTreeWidgetItem * it;
 	it=createFullItem(szName);
 	it->setType(eType);
 	m_pAliases->append(it);
 	activateItem(it);
 }
 
-void KviAliasEditor::commit()
+void AliasEditorWidget::commit()
 {
 	m_bSaving = true;
 	saveLastEditedItem();
@@ -1173,7 +1173,7 @@ void KviAliasEditor::commit()
 }
 
 
-KviAliasEditorWindow::KviAliasEditorWindow(KviMainWindow * lpFrm)
+AliasEditorWindow::AliasEditorWindow(KviMainWindow * lpFrm)
 : KviWindow(KVI_WINDOW_TYPE_SCRIPTEDITOR,lpFrm,"aliaseditor",0)
 {
 	g_pAliasEditorWindow = this;
@@ -1182,7 +1182,7 @@ KviAliasEditorWindow::KviAliasEditorWindow(KviMainWindow * lpFrm)
 
 	QGridLayout * g = new QGridLayout();
 
-	m_pEditor = new KviAliasEditor(this);
+	m_pEditor = new AliasEditorWidget(this);
 	g->addWidget(m_pEditor,0,0,1,4);
 	
 	QPushButton * btn = new QPushButton(__tr2qs_ctx("&OK","editor"),this);
@@ -1205,43 +1205,43 @@ KviAliasEditorWindow::KviAliasEditorWindow(KviMainWindow * lpFrm)
 	setLayout(g);
 }
 
-KviAliasEditorWindow::~KviAliasEditorWindow()
+AliasEditorWindow::~AliasEditorWindow()
 {
 	g_pAliasEditorWindow = 0;
 }
 
-void KviAliasEditorWindow::okClicked()
+void AliasEditorWindow::okClicked()
 {
 	m_pEditor->commit();
 	close();
 }
 
-void KviAliasEditorWindow::applyClicked()
+void AliasEditorWindow::applyClicked()
 {
 	m_pEditor->commit();
 }
 
-void KviAliasEditorWindow::cancelClicked()
+void AliasEditorWindow::cancelClicked()
 {
 	close();
 }
 
-QPixmap * KviAliasEditorWindow::myIconPtr()
+QPixmap * AliasEditorWindow::myIconPtr()
 {
 	return g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS);
 }
 
-void KviAliasEditorWindow::getConfigGroupName(QString &szName)
+void AliasEditorWindow::getConfigGroupName(QString &szName)
 {
 	szName = "aliaseditor";
 }
 
-void KviAliasEditorWindow::saveProperties(KviConfigurationFile *cfg)
+void AliasEditorWindow::saveProperties(KviConfigurationFile *cfg)
 {
 	m_pEditor->saveProperties(cfg);
 }
 
-void KviAliasEditorWindow::loadProperties(KviConfigurationFile *cfg)
+void AliasEditorWindow::loadProperties(KviConfigurationFile *cfg)
 {
 	m_pEditor->loadProperties(cfg);
 }
diff --git a/src/modules/aliaseditor/aliaseditor.h b/src/modules/aliaseditor/AliasEditorWindow.h
index 34fefcb47..a571562f6 100644
--- a/src/modules/aliaseditor/aliaseditor.h
+++ b/src/modules/aliaseditor/AliasEditorWindow.h
@@ -2,7 +2,7 @@
 #define _ALIASEDITOR_H_
 //=============================================================================
 //
-//   File : aliaseditor.h
+//   File : AliasEditorWindow.h
 //   Creation date : Mon Dec 23 2002 14:35:55 CEST by Szymon Stefanek
 //
 //   This file is part of the KVIrc irc client distribution
@@ -43,17 +43,17 @@ class KviScriptEditor;
 
 
 
-class KviAliasEditorTreeWidgetItem : public QTreeWidgetItem, public KviHeapObject
+class AliasEditorTreeWidgetItem : public QTreeWidgetItem, public KviHeapObject
 {
 public:
 	enum Type { Alias, Namespace };
 public:
-	KviAliasEditorTreeWidgetItem(QTreeWidget * pTreeWidget,Type eType,const QString &szName);
-	KviAliasEditorTreeWidgetItem(KviAliasEditorTreeWidgetItem * pParentItem,Type eType,const QString &szName);
-	~KviAliasEditorTreeWidgetItem(){};
+	AliasEditorTreeWidgetItem(QTreeWidget * pTreeWidget,Type eType,const QString &szName);
+	AliasEditorTreeWidgetItem(AliasEditorTreeWidgetItem * pParentItem,Type eType,const QString &szName);
+	~AliasEditorTreeWidgetItem(){};
 protected:
 	Type m_eType;
-	KviAliasEditorTreeWidgetItem * m_pParentItem;
+	AliasEditorTreeWidgetItem * m_pParentItem;
 	QString m_szName;
 	QString m_szBuffer;
 	int  m_cPos;
@@ -64,8 +64,8 @@ public:
 	void setType(Type t);
 	inline bool isAlias(){ return m_eType == Alias; };
 	inline bool isNamespace(){ return m_eType == Namespace; };
-	void setParentItem(KviAliasEditorTreeWidgetItem* it){ m_pParentItem=it; };
-	KviAliasEditorTreeWidgetItem * parentItem(){ return m_pParentItem; };
+	void setParentItem(AliasEditorTreeWidgetItem* it){ m_pParentItem=it; };
+	AliasEditorTreeWidgetItem * parentItem(){ return m_pParentItem; };
 	inline void setBuffer(const QString &szBuffer){ m_szBuffer = szBuffer; };
 	inline const QString & buffer(){ return m_szBuffer; };
 	inline const int & cursorPosition(){return m_cPos; };
@@ -75,27 +75,27 @@ public:
 
 
 
-class KviAliasEditorTreeWidget : public QTreeWidget
+class AliasEditorTreeWidget : public QTreeWidget
 {
 	Q_OBJECT
 public:
-	KviAliasEditorTreeWidget(QWidget*);
-	~KviAliasEditorTreeWidget();
+	AliasEditorTreeWidget(QWidget*);
+	~AliasEditorTreeWidget();
 };
 
-class KviAliasEditor : public QWidget
+class AliasEditorWidget : public QWidget
 {
 	Q_OBJECT
 public:
-	KviAliasEditor(QWidget * par);
-	~KviAliasEditor();
+	AliasEditorWidget(QWidget * par);
+	~AliasEditorWidget();
 public:
 	KviScriptEditor              * m_pEditor;
-	KviAliasEditorTreeWidget     * m_pTreeWidget;
+	AliasEditorTreeWidget     * m_pTreeWidget;
 	QLabel                       * m_pNameLabel;
 	QPushButton                  * m_pRenameButton;
-	KviAliasEditorTreeWidgetItem * m_pLastEditedItem;
-	KviAliasEditorTreeWidgetItem * m_pLastClickedItem;
+	AliasEditorTreeWidgetItem * m_pLastEditedItem;
+	AliasEditorTreeWidgetItem * m_pLastClickedItem;
 	KviTalPopupMenu              * m_pContextPopup;
 	QSplitter                    * m_pSplitter;
 	QString                        m_szDir;
@@ -104,7 +104,7 @@ public:
 	//bool modified(){ return m_bModified; };
 	void commit();
 	void exportAliases(bool,bool=false);
-	void exportSelectionInSinglesFiles(KviPointerList<KviAliasEditorTreeWidgetItem> *l);
+	void exportSelectionInSinglesFiles(KviPointerList<AliasEditorTreeWidgetItem> *l);
 
 	void saveProperties(KviConfigurationFile *);
 	void loadProperties(KviConfigurationFile *);
@@ -115,7 +115,7 @@ protected slots:
 	void newAlias();
 	void customContextMenuRequested(const QPoint pnt);
 	void newNamespace();
-	void newItem(QString &szName,KviAliasEditorTreeWidgetItem::Type eType);
+	void newItem(QString &szName,AliasEditorTreeWidgetItem::Type eType);
 
 	void exportAll();
 	void exportSelectedSepFiles();
@@ -130,24 +130,24 @@ protected slots:
 	void aliasRefresh(const QString &szName);
 
 protected:
-	KviPointerList<KviAliasEditorTreeWidgetItem> *m_pAliases;
-	void recursiveCollapseNamespaces(KviAliasEditorTreeWidgetItem * it);
+	KviPointerList<AliasEditorTreeWidgetItem> *m_pAliases;
+	void recursiveCollapseNamespaces(AliasEditorTreeWidgetItem * it);
 	void searchReplace(const QString &szSearch,bool bReplace=false,const QString &szReplace="n");
 
-	void getExportAliasBuffer(QString &buffer,KviAliasEditorTreeWidgetItem * it);
+	void getExportAliasBuffer(QString &buffer,AliasEditorTreeWidgetItem * it);
 	void oneTimeSetup();
 	void saveLastEditedItem();
-	void getUniqueItemName(KviAliasEditorTreeWidgetItem *item,QString &buffer,KviAliasEditorTreeWidgetItem::Type eType);
-	void appendSelectedAliasItems(KviPointerList<KviAliasEditorTreeWidgetItem> * l);
-	void appendSelectedAliasItemsRecursive(KviPointerList<KviAliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom);
-	void appendSelectedItems(KviPointerList<KviAliasEditorTreeWidgetItem> * l);
-	void appendSelectedItemsRecursive(KviPointerList<KviAliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom);
+	void getUniqueItemName(AliasEditorTreeWidgetItem *item,QString &buffer,AliasEditorTreeWidgetItem::Type eType);
+	void appendSelectedAliasItems(KviPointerList<AliasEditorTreeWidgetItem> * l);
+	void appendSelectedAliasItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom);
+	void appendSelectedItems(KviPointerList<AliasEditorTreeWidgetItem> * l);
+	void appendSelectedItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom);
 
 	void openParentItems(QTreeWidgetItem * it);
 	void activateItem(QTreeWidgetItem * it);
 
-	bool removeItem(KviAliasEditorTreeWidgetItem *it,bool * pbYesToAll,bool bDeleteEmptyTree);
-	void removeItemChildren(KviAliasEditorTreeWidgetItem *it);
+	bool removeItem(AliasEditorTreeWidgetItem *it,bool * pbYesToAll,bool bDeleteEmptyTree);
+	void removeItemChildren(AliasEditorTreeWidgetItem *it);
 
 	QString askForAliasName(const QString &szAction,const QString &szText,const QString &szInitialText);
 	QString askForNamespaceName(const QString &szAction,const QString &szText,const QString &szInitialText);
@@ -155,27 +155,27 @@ protected:
 	bool itemExists(QTreeWidgetItem *pSearchFor);
 	bool namespaceExists(QString &szFullItemName);
 	bool aliasExists(QString &szFullItemName);
-	void appendAllItems(KviPointerList<KviAliasEditorTreeWidgetItem> * l,KviAliasEditorTreeWidgetItem::Type);
-	void appendAllItemsRecursive(KviPointerList<KviAliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom,KviAliasEditorTreeWidgetItem::Type);
+	void appendAllItems(KviPointerList<AliasEditorTreeWidgetItem> * l,AliasEditorTreeWidgetItem::Type);
+	void appendAllItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom,AliasEditorTreeWidgetItem::Type);
 	bool hasSelectedItems();
-	void buildAliasesFile(KviPointerList<KviAliasEditorTreeWidgetItem> *l, QString & szBuffer);
+	void buildAliasesFile(KviPointerList<AliasEditorTreeWidgetItem> *l, QString & szBuffer);
 
-	void buildFullItemPath(KviAliasEditorTreeWidgetItem * it,QString &szBuffer);
-	KviAliasEditorTreeWidgetItem * findTopLevelItem(const QString &szName);
-	KviAliasEditorTreeWidgetItem * createFullItem(const QString &szFullName);
-	KviAliasEditorTreeWidgetItem * findItem(const QString &szName);
-	QString buildFullItemName(KviAliasEditorTreeWidgetItem * it);
+	void buildFullItemPath(AliasEditorTreeWidgetItem * it,QString &szBuffer);
+	AliasEditorTreeWidgetItem * findTopLevelItem(const QString &szName);
+	AliasEditorTreeWidgetItem * createFullItem(const QString &szFullName);
+	AliasEditorTreeWidgetItem * findItem(const QString &szName);
+	QString buildFullItemName(AliasEditorTreeWidgetItem * it);
 };
 
 
-class KviAliasEditorWindow : public KviWindow
+class AliasEditorWindow : public KviWindow
 {
 	Q_OBJECT
 public:
-	KviAliasEditorWindow(KviMainWindow * lpFrm);
-	~KviAliasEditorWindow();
+	AliasEditorWindow(KviMainWindow * lpFrm);
+	~AliasEditorWindow();
 protected:
-	KviAliasEditor * m_pEditor;
+	AliasEditorWidget * m_pEditor;
 protected:
 	virtual QPixmap * myIconPtr();
 	virtual void getConfigGroupName(QString &szName);
diff --git a/src/modules/aliaseditor/CMakeLists.txt b/src/modules/aliaseditor/CMakeLists.txt
index 2b0c789a8..10f2ee102 100644
--- a/src/modules/aliaseditor/CMakeLists.txt
+++ b/src/modules/aliaseditor/CMakeLists.txt
@@ -1,12 +1,12 @@
 # CMakeLists for src/modules/aliaseditor
 
 SET(kvialiaseditor_MOC_HDRS
-	aliaseditor.h
+	AliasEditorWindow.h
 )
 
 SET(kvialiaseditor_SRCS
 	libkvialiaseditor.cpp
-	aliaseditor.cpp
+	AliasEditorWindow.cpp
 )
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
diff --git a/src/modules/aliaseditor/libkvialiaseditor.cpp b/src/modules/aliaseditor/libkvialiaseditor.cpp
index 00f09ca5e..ffa63d704 100644
--- a/src/modules/aliaseditor/libkvialiaseditor.cpp
+++ b/src/modules/aliaseditor/libkvialiaseditor.cpp
@@ -22,14 +22,14 @@
 //
 //=============================================================================
 
-#include "aliaseditor.h"
+#include "AliasEditorWindow.h"
 
 #include "KviModule.h"
 #include "KviLocale.h"
 #include "KviMainWindow.h"
 
 
-KviAliasEditorWindow * g_pAliasEditorWindow = 0;
+AliasEditorWindow * g_pAliasEditorWindow = 0;
 KviModule * g_pAliasEditorModule = 0;
 
 
@@ -51,7 +51,7 @@ static bool aliaseditor_kvs_cmd_open(KviKvsModuleCommandCall * c)
 {
 	if(!g_pAliasEditorWindow)
 	{
-		g_pAliasEditorWindow = new KviAliasEditorWindow(c->window()->frame());
+		g_pAliasEditorWindow = new AliasEditorWindow(c->window()->frame());
 		c->window()->frame()->addWindow(g_pAliasEditorWindow);
 	}