diff options
Diffstat (limited to 'src/modules/aliaseditor/AliasEditorWindow.cpp')
| -rw-r--r-- | src/modules/aliaseditor/AliasEditorWindow.cpp | 1247 |
1 files changed, 1247 insertions, 0 deletions
diff --git a/src/modules/aliaseditor/AliasEditorWindow.cpp b/src/modules/aliaseditor/AliasEditorWindow.cpp new file mode 100644 index 000000000..e53272448 --- /dev/null +++ b/src/modules/aliaseditor/AliasEditorWindow.cpp @@ -0,0 +1,1247 @@ +//============================================================================= +// +// 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 +// Copyright (C) 2002-2010 Szymon Stefanek (pragma at kvirc dot net) +// +// This program is FREE software. You can redistribute it and/or +// modify it under the linkss of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your opinion) any later version. +// +// This program is distributed in the HOPE that it will be USEFUL, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +// See the GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, write to the Free Software Foundation, +// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +// +//============================================================================= + + +#include "AliasEditorWindow.h" + +#include "KviIconManager.h" +#include "KviOptions.h" +#include "KviLocale.h" +#include "KviImageDialog.h" +#include "KviConfigurationFile.h" +#include "KviFileDialog.h" +#include "KviFileUtils.h" +#include "KviScriptEditor.h" +#include "kvi_debug.h" +#include "KviApplication.h" +#include "KviMainWindow.h" +#include "KviQString.h" +#include "KviKvsAliasManager.h" +#include "KviFileDialog.h" +#include "KviCommandFormatter.h" +#include "KviModule.h" +#include "KviTalVBox.h" +#include "kvi_fileextensions.h" + +#include <QList> +#include <QSplitter> +#include <QLayout> +#include <QToolTip> +#include <QPushButton> +#include <QDir> +#include <QMessageBox> +#include <QInputDialog> +#include <QRegExp> +#include <QTreeWidget> +#include <QMouseEvent> +#include <QList> +#include <QPainter> +#include <QBrush> +extern AliasEditorWindow * g_pAliasEditorWindow; +extern KviModule * g_pAliasEditorModule; + + +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==AliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE)))); + else setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS)))); +} + +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==AliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE)))); + else setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS)))); +} + +void AliasEditorTreeWidgetItem::setName(const QString &szName) +{ + m_szName = szName; + setText(0,m_szName); +} +void AliasEditorTreeWidgetItem::setType(Type t) +{ + m_eType=t; + if(t==AliasEditorTreeWidgetItem::Namespace) setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE)))); + else setIcon(0,QIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS)))); +} + +AliasEditorTreeWidget::AliasEditorTreeWidget(QWidget * par) +: QTreeWidget(par) +{ + setColumnCount (1); + setHeaderLabel(__tr2qs_ctx("Alias","editor")); + setSelectionMode(QAbstractItemView::ExtendedSelection); + setSortingEnabled(true); + setRootIsDecorated(true); + setAnimated(true); +} + +AliasEditorTreeWidget::~AliasEditorTreeWidget() +{ + //remove and delete all items + clear(); +} + + +AliasEditorWidget::AliasEditorWidget(QWidget * par) +: QWidget(par) +{ + m_pAliases=new KviPointerList<AliasEditorTreeWidgetItem>; + m_pAliases->setAutoDelete(false); + + m_bSaving = false; + m_pLastEditedItem = 0; + m_pLastClickedItem = 0; + m_szDir = QDir::homePath(); + + QGridLayout * l = new QGridLayout(this); + + m_pSplitter = new QSplitter(Qt::Horizontal,this); + m_pSplitter->setChildrenCollapsible(false); + l->addWidget(m_pSplitter,0,0); + + KviTalVBox * box = new KviTalVBox(m_pSplitter); + box->setSpacing(0); + box->setMargin(0); + + m_pTreeWidget = new AliasEditorTreeWidget(box); + + box = new KviTalVBox(m_pSplitter); + KviTalHBox * hbox = new KviTalHBox(box); + hbox->setSpacing(0); + hbox->setMargin(0); + m_pNameLabel = new QLabel(__tr2qs_ctx("No item selected","editor"),hbox); + m_pRenameButton = new QPushButton(__tr2qs_ctx("Rename","editor"),hbox); + m_pRenameButton->setEnabled(false); + connect(m_pRenameButton,SIGNAL(clicked()),this,SLOT(renameItem())); + hbox->setStretchFactor(m_pNameLabel,2); + m_pRenameButton->setToolTip(__tr2qs_ctx("Edit the alias or namespace name","editor")); + m_pEditor = KviScriptEditor::createInstance(box); + m_pEditor->setFocus(); + + connect(m_pEditor,SIGNAL(find(const QString &)),this,SLOT(slotFindWord(const QString &))); + connect(m_pEditor,SIGNAL(replaceAll(const QString &,const QString &)),this,SLOT(slotReplaceAll(const QString &,const QString &))); + + m_pContextPopup = new KviTalPopupMenu(this); + + oneTimeSetup(); + + currentItemChanged(0,0); +} + +AliasEditorWidget::~AliasEditorWidget() +{ + KviScriptEditor::destroyInstance(m_pEditor); + delete m_pAliases; +} + +void AliasEditorWidget::buildFullItemPath(AliasEditorTreeWidgetItem * it,QString &szBuffer) +{ + if (it->isAlias()) it=it->parentItem(); + if (!it) return; + while(it) + { + QString tmp = it->name(); + if(!tmp.isEmpty()) + { + szBuffer.prepend("::"); + szBuffer.prepend(tmp); + } + it = it->parentItem(); + } +} + +QString AliasEditorWidget::buildFullItemName(AliasEditorTreeWidgetItem * it) +{ + if(!it) return QString(); + QString szName = it->name(); + AliasEditorTreeWidgetItem * nit = it->parentItem(); + + while(nit) + { + QString tmp = nit->name(); + if(!tmp.isEmpty()) + { + szName.prepend("::"); + szName.prepend(tmp); + } + nit = nit->parentItem(); + } + return szName; +} + +//FIXME this should be called something like "findNamespace" +AliasEditorTreeWidgetItem * AliasEditorWidget::findTopLevelItem(const QString &szName) +{ + AliasEditorTreeWidgetItem *pItem =0; + for(int i=0;i<m_pTreeWidget->topLevelItemCount();i++) + { + pItem = (AliasEditorTreeWidgetItem*) m_pTreeWidget->topLevelItem(i); + if (pItem->text(0)==szName && pItem->isNamespace()) + return (AliasEditorTreeWidgetItem*)m_pTreeWidget->topLevelItem(i); + } + return 0; +} + +AliasEditorTreeWidgetItem * AliasEditorWidget::findItem(const QString &szFullName) +{ + QStringList lNamespaces=szFullName.split("::"); + if(!lNamespaces.count()) return 0; + AliasEditorTreeWidgetItem *pItem=findTopLevelItem(lNamespaces.at(0)); + if (!pItem) return 0; + bool bFound; + int i; + int j; + for(i=1;i<lNamespaces.count();i++) + { + bFound=false; + for(j=0;j<pItem->childCount();j++) + { + if (KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i))) + { + pItem=( AliasEditorTreeWidgetItem *)pItem->child(j); + bFound=true; + break; + } + } + if (!bFound) return 0; + } + return (AliasEditorTreeWidgetItem *)pItem; +} + + +AliasEditorTreeWidgetItem * AliasEditorWidget::createFullItem(const QString &szFullName) +{ + QStringList lNamespaces=szFullName.split("::"); + if(!lNamespaces.count()) return 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++) + { + bFound=false; + for(int j=0;j<pItem->childCount();j++) + { + if (KviQString::equalCI(pItem->child(j)->text(0),lNamespaces.at(i))) + { + pItem=( AliasEditorTreeWidgetItem *)pItem->child(j); + bFound=true; + break; + } + } + if (!bFound) + pItem=new AliasEditorTreeWidgetItem(pItem,AliasEditorTreeWidgetItem::Namespace,lNamespaces.at(i)); + } + return new AliasEditorTreeWidgetItem(pItem,AliasEditorTreeWidgetItem::Alias,lNamespaces.at(i)); +} + + +void AliasEditorWidget::oneTimeSetup() +{ + KviPointerHashTable<QString,KviKvsScript> * a = KviKvsAliasManager::instance()->aliasDict(); + if(!a)return; + + KviPointerHashTableIterator<QString,KviKvsScript> it(*a); + + AliasEditorTreeWidgetItem * item; + while(it.current()) + { + KviKvsScript * alias = it.current(); + item = createFullItem(alias->name()); + item->setBuffer(alias->code()); + m_pAliases->append(item); + ++it; + } + + connect(m_pTreeWidget,SIGNAL(currentItemChanged(QTreeWidgetItem *,QTreeWidgetItem *)),this,SLOT(currentItemChanged(QTreeWidgetItem *,QTreeWidgetItem *))); + m_pTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu); + connect(m_pTreeWidget,SIGNAL(customContextMenuRequested(const QPoint &)),this,SLOT(customContextMenuRequested(const QPoint &))); + connect(m_pTreeWidget,SIGNAL(itemChanged(QTreeWidgetItem *,int)),this,SLOT(itemRenamed(QTreeWidgetItem *,int))); + connect(KviKvsAliasManager::instance(),SIGNAL(aliasRefresh(const QString &)),this,SLOT(aliasRefresh(const QString &))); + m_pTreeWidget->sortItems(0,Qt::AscendingOrder); +} + +void AliasEditorWidget::aliasRefresh(const QString &szName) +{ + if(m_bSaving) + return; + AliasEditorTreeWidgetItem * item=0; + KviKvsScript * alias = KviKvsAliasManager::instance()->aliasDict()->find(szName); + + // search for old alias with same name + KviPointerList<AliasEditorTreeWidgetItem> l; + l.setAutoDelete(false); + appendAllItems(&l,AliasEditorTreeWidgetItem::Alias); + for(AliasEditorTreeWidgetItem * it = l.first();it;it = l.next()) + { + if (KviQString::equalCI(buildFullItemName(it),szName)) + { + item=it; + break; + } + } + if(!item) + { + item = createFullItem(szName); + m_pAliases->append(item); + } + + if(item!=m_pLastEditedItem) + { + item->setBuffer(alias->code()); + return; + } + if( + QMessageBox::warning(0,__tr2qs_ctx("OverWrite Current Alias","editor"), + __tr2qs_ctx("An external script has changed the alias you are currently editing. Do you want to accept the external changes?","editor"), + QMessageBox::Yes,QMessageBox::No|QMessageBox::Default|QMessageBox::Escape) != QMessageBox::Yes + ) + return; + item->setBuffer(alias->code()); + m_pEditor->setText(alias->code()); +} +void AliasEditorWidget::itemRenamed(QTreeWidgetItem *it,int col) +{ + if(it!=m_pLastEditedItem) return; + + ((AliasEditorTreeWidgetItem *)it)->setName(it->text(col)); + QString szNam = buildFullItemName((AliasEditorTreeWidgetItem *)it); + QString szLabelText; + if(((AliasEditorTreeWidgetItem *)it)->isNamespace()) + szLabelText = __tr2qs_ctx("Namespace","editor"); + else + szLabelText = __tr2qs_ctx("Alias","editor"); + szLabelText += ": <b>"; + szLabelText += szNam; + szLabelText += "</b>"; + m_pNameLabel->setText(szLabelText); +} + + + +bool AliasEditorWidget::hasSelectedItems() + { + return m_pTreeWidget->selectedItems().count()?1:0; +} + +bool AliasEditorWidget::itemExists(QTreeWidgetItem *pSearchFor) +{ + if(!pSearchFor)return false; + if (m_pAliases->findRef((AliasEditorTreeWidgetItem*) pSearchFor)!=-1) return true; + else return false; +} + +void AliasEditorWidget::appendAllItems(KviPointerList<AliasEditorTreeWidgetItem> * l,AliasEditorTreeWidgetItem::Type eType) +{ + for (int i=0;i<m_pTreeWidget->topLevelItemCount();i++) + { + if (((AliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))->type()==eType) + { + l->append(((AliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i))); + } else { + appendAllItemsRecursive(l,m_pTreeWidget->topLevelItem(i),eType); + } + } +} + +void AliasEditorWidget::appendAllItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom,AliasEditorTreeWidgetItem::Type eType) +{ + for (int i=0;i<pStartFrom->childCount();i++) + { + if (((AliasEditorTreeWidgetItem *)pStartFrom->child(i))->type()==eType) + { + l->append((AliasEditorTreeWidgetItem *)pStartFrom->child(i)); + } else { + appendAllItemsRecursive(l,pStartFrom->child(i),eType); + } + } +} + +bool AliasEditorWidget::aliasExists(QString &szFullItemName) +{ + KviPointerList<AliasEditorTreeWidgetItem> l; + l.setAutoDelete(false); + appendAllItems(&l,AliasEditorTreeWidgetItem::Alias); + for(AliasEditorTreeWidgetItem * it = l.first();it;it = l.next()) + { + if (KviQString::equalCI(buildFullItemName(it),szFullItemName)) + { + return true; + } + } + return false; +} + +bool AliasEditorWidget::namespaceExists(QString &szFullItemName) +{ + KviPointerList<AliasEditorTreeWidgetItem> l; + l.setAutoDelete(false); + + appendAllItems(&l,AliasEditorTreeWidgetItem::Namespace); + for(AliasEditorTreeWidgetItem * it = l.first();it;it = l.next()) + { + if (KviQString::equalCI(buildFullItemName(it),szFullItemName)) + { + return true; + } + } + return false; +} +void AliasEditorWidget::renameItem() +{ + if(!m_pLastEditedItem)return; + //if(itemExists(m_pLastEditedItem))return; // dead ? + QString szName = buildFullItemName(m_pLastEditedItem); + QString szNewName; + + bool bAlias = m_pLastEditedItem->isAlias(); + + if(bAlias) + szNewName = askForAliasName(__tr2qs_ctx("Rename Alias","editor"),__tr2qs_ctx("Please enter the new name for the alias","editor"),szName); + else + szNewName = askForNamespaceName(__tr2qs_ctx("Rename Namespace","editor"),__tr2qs_ctx("Please enter the new name for the namespace","editor"),szName); + if(szNewName.isEmpty())return; + + if(szName == szNewName)return; + + // check if there is already an alias with this name + if (bAlias) + { + if (aliasExists(szNewName)) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Alias already exists","editor"), + __tr2qs_ctx("This name is already in use. Please choose another one.","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + return; + } + } else { + // check if there is already a namespace with this name + if (namespaceExists(szNewName)) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Namespace already exists","editor"), + __tr2qs_ctx("This name is already in use. Please choose another one.","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + return; + } + } + + QString szCode; + int pntCursor; + if(bAlias) + { + m_pEditor->getText(szCode); + pntCursor = m_pEditor->getCursor(); + } + QList<QTreeWidgetItem*> lChildren= m_pLastEditedItem->takeChildren(); + bool bYesToAll = true; + removeItem(m_pLastEditedItem,&bYesToAll,true); + + 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()) + AliasEditorTreeWidgetItem * pItem = createFullItem(szNewName); + if(bAlias) + { + pItem->setBuffer(szCode); + pItem->setCursorPosition(pntCursor); + + } else { + for(int i=0;i<lChildren.count();i++) + { + ((AliasEditorTreeWidgetItem*)lChildren.at(i))->setParentItem(pItem); + pItem->insertChild(pItem->childCount(),lChildren.at(i)); + } + + } + activateItem(pItem); + m_pAliases->append(pItem); +} + +// warning: this saves ONLY the body, not the name! +// the name is changed explicitly with renameItem(), when needed + +void AliasEditorWidget::saveLastEditedItem() +{ + if(!m_pLastEditedItem) + return; + if(!itemExists(m_pLastEditedItem) || !m_pEditor->isModified() || m_pLastEditedItem->isNamespace()) + return; + ((AliasEditorTreeWidgetItem *)m_pLastEditedItem)->setCursorPosition(m_pEditor->getCursor()); + QString newCode; + m_pEditor->getText(newCode); + ((AliasEditorTreeWidgetItem *)m_pLastEditedItem)->setBuffer(newCode); +} + +void AliasEditorWidget::currentItemChanged(QTreeWidgetItem *it,QTreeWidgetItem *) +{ + saveLastEditedItem(); + m_pLastEditedItem = (AliasEditorTreeWidgetItem *)it; + + if(!m_pLastEditedItem) + { + m_pNameLabel->setText(__tr2qs_ctx("No item selected","editor")); + m_pRenameButton->setEnabled(false); + m_pEditor->setText(""); + m_pEditor->setEnabled(false); + return; + } + + QString szNam = buildFullItemName(m_pLastEditedItem); + if(m_pLastEditedItem->isNamespace()) + { + QString szLabelText = __tr2qs_ctx("Namespace","editor"); + szLabelText += ": <b>"; + szLabelText += szNam; + szLabelText += "</b>"; + m_pNameLabel->setText(szLabelText); + m_pRenameButton->setEnabled(true); + m_pEditor->setText(""); + m_pEditor->setEnabled(false); + m_pTreeWidget->setFocus(); + return; + } + + QString szLabelText = __tr2qs_ctx("Alias","editor"); + szLabelText += ": <b>"; + szLabelText += szNam; + szLabelText += "</b>"; + m_pNameLabel->setText(szLabelText); + m_pRenameButton->setEnabled(true); + m_pEditor->setText(((AliasEditorTreeWidgetItem *)it)->buffer()); + + m_pEditor->setFocus(); + m_pEditor->setCursorPosition(((AliasEditorTreeWidgetItem *)it)->cursorPosition()); + m_pEditor->setEnabled(true); +} + + +void AliasEditorWidget::customContextMenuRequested(const QPoint pnt) +{ + m_pContextPopup->clear(); + m_pLastClickedItem = (AliasEditorTreeWidgetItem *)m_pTreeWidget->itemAt(pnt); + + int id; + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS)), + __tr2qs_ctx("Add Alias","editor"), + this,SLOT(newAlias())); + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS)), + __tr2qs_ctx("Add Namespace","editor"), + this,SLOT(newNamespace())); + + bool bHasItems = m_pTreeWidget->topLevelItemCount(); + bool bHasSelected = hasSelectedItems(); + + m_pContextPopup->insertSeparator(); + + id = m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_QUIT)), + __tr2qs_ctx("Remove Selected","editor"), + this,SLOT(removeSelectedItems())); + m_pContextPopup->setItemEnabled(id,bHasSelected); + + m_pContextPopup->insertSeparator(); + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_FOLDER)), + __tr2qs_ctx("Export Selected...","editor"), + this,SLOT(exportSelected())); + m_pContextPopup->setItemEnabled(id,bHasSelected); + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_FOLDER)), + __tr2qs_ctx("Export Selected in singles files...","editor"), + this,SLOT(exportSelectedSepFiles())); + + m_pContextPopup->setItemEnabled(id,bHasSelected); + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_FOLDER)), + __tr2qs_ctx("Export All...","editor"), + this,SLOT(exportAll())); + m_pContextPopup->setItemEnabled(id,bHasItems); + + m_pContextPopup->insertSeparator(); + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_SEARCH)), + __tr2qs_ctx("Find In Aliases...","editor"), + this,SLOT(slotFind())); + m_pContextPopup->setItemEnabled(id,bHasItems); + + m_pContextPopup->insertItem( + *(g_pIconManager->getSmallIcon(KVI_SMALLICON_NAMESPACE)), + __tr2qs_ctx("Collapse All Namespaces","editor"), + this,SLOT(slotCollapseNamespaces())); + + m_pContextPopup->setItemEnabled(id,bHasItems); + m_pContextPopup->popup( m_pTreeWidget->mapToGlobal(pnt)); +} + +void AliasEditorWidget::searchReplace(const QString &szSearch,bool bReplace,const QString &szReplace) +{ + for(unsigned int i=0;i<m_pAliases->count();i++) + { + AliasEditorTreeWidgetItem *pItem=m_pAliases->at(i); + if(pItem->buffer().indexOf(szSearch,0,Qt::CaseInsensitive) != -1) + { + pItem->setBackground(0, QColor(255,0,0,128)); + if (bReplace) ((QString &)pItem->buffer()).replace(szSearch,szReplace,Qt::CaseInsensitive); + openParentItems(pItem); + } else { + pItem->setBackground(0, QColor(255,255,255)); + } + } +} + +void AliasEditorWidget::slotFind() +{ + + g_pAliasEditorModule->lock(); + bool bOk; + + QString szSearch = QInputDialog::getText(this, + __tr2qs_ctx("Find In Aliases","editor"), + __tr2qs_ctx("Please enter the text to be searched for. The matching aliases will be highlighted.","editor"), + QLineEdit::Normal, + "", + &bOk); + + g_pAliasEditorModule->unlock(); + if(!bOk)return; + if(szSearch.isEmpty())return; + m_pEditor->setFindText(szSearch); + searchReplace(szSearch); +} + +void AliasEditorWidget::slotFindWord(const QString &szSearch) +{ + m_pEditor->setFindText(szSearch); +} + +void AliasEditorWidget::recursiveCollapseNamespaces(AliasEditorTreeWidgetItem * it) +{ + if(!it)return; + for (int i=0;i<it->childCount();i++) + { + if(it->child(i)->childCount()) + { + it->child(i)->setExpanded(false); + recursiveCollapseNamespaces((AliasEditorTreeWidgetItem *)it->child(i)); + } + } +} + +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((AliasEditorTreeWidgetItem *)m_pTreeWidget->topLevelItem(i)); + } + } +} + +void AliasEditorWidget::slotReplaceAll(const QString &szFind,const QString &szReplace) +{ + m_pEditor->setFindText(szReplace); + searchReplace(szFind,true,szReplace); +} + +void AliasEditorWidget::getExportAliasBuffer(QString &buffer,AliasEditorTreeWidgetItem * it) +{ + QString szBuf = it->buffer(); + KviCommandFormatter::blockFromBuffer(szBuf); + QString szNam = buildFullItemName(it); + + buffer = "alias("; + buffer += szNam; + buffer += ")\n"; + buffer += szBuf; + buffer += "\n"; +} + +void AliasEditorWidget::exportAll() +{ + exportAliases(false); +} + +void AliasEditorWidget::exportSelectedSepFiles() +{ + exportAliases (true,true); +} + +void AliasEditorWidget::exportSelected() +{ + exportAliases(true); +} + +void AliasEditorWidget::exportSelectionInSinglesFiles(KviPointerList<AliasEditorTreeWidgetItem> *l) +{ + if(!m_szDir.endsWith(QString(KVI_PATH_SEPARATOR)))m_szDir += KVI_PATH_SEPARATOR; + if (!l->first()) + { + g_pAliasEditorModule->lock(); + QMessageBox::warning(this,__tr2qs_ctx("Alias Export","editor"),__tr2qs_ctx("There is no selection!","editor"),__tr2qs_ctx("OK","editor")); + g_pAliasEditorModule->unlock(); + return; + } + g_pAliasEditorModule->lock(); + + if(!KviFileDialog::askForDirectoryName(m_szDir,__tr2qs_ctx("Choose a Directory - KVIrc","editor"),m_szDir)){ + g_pAliasEditorModule->unlock(); + return; + } + + if(!m_szDir.endsWith(QString(KVI_PATH_SEPARATOR)))m_szDir += KVI_PATH_SEPARATOR; + + bool bReplaceAll=false; + + for(AliasEditorTreeWidgetItem * it = l->first();it;it = l->next()) + { + QString tmp; + getExportAliasBuffer(tmp,it); + QString szFileName=buildFullItemName(it); + szFileName += ".kvs"; + szFileName.replace("::","_"); + QString szCompletePath=m_szDir+szFileName; + if (KviFileUtils::fileExists(szCompletePath) && !bReplaceAll) + { + QString szMsg; + KviQString::sprintf(szMsg,__tr2qs_ctx("The file \"%Q\" exists. Do you want to replace it ?","editor"),&szFileName); + int ret = QMessageBox::question(this,__tr2qs_ctx("Replace file","editor"),szMsg,__tr2qs_ctx("Yes","editor"),__tr2qs_ctx("Yes to All","editor"),__tr2qs_ctx("No","editor")); + if (ret!=2) + { + KviFileUtils::writeFile(szCompletePath,tmp); + if (ret==1) bReplaceAll=true; + } + } else { + KviFileUtils::writeFile(szCompletePath,tmp); + } + } + g_pAliasEditorModule->unlock(); +} + +void AliasEditorWidget::exportAliases(bool bSelectedOnly,bool bSingleFiles) +{ + saveLastEditedItem(); + + KviPointerList<AliasEditorTreeWidgetItem> l; + l.setAutoDelete(false); + + if (bSelectedOnly) appendSelectedAliasItems(&l); + if (bSingleFiles) + { + exportSelectionInSinglesFiles(&l); + return; + } + QString szOut; + int count; + + if (bSelectedOnly) + { + count=l.count(); + buildAliasesFile(&l,szOut); + } else { + count=m_pAliases->count(); + buildAliasesFile(m_pAliases,szOut); + } + QString szNameFile; + if(szOut.isEmpty()) + { + g_pAliasEditorModule->lock(); + QMessageBox::warning(this,__tr2qs_ctx("Alias Export","editor"),__tr2qs_ctx("The exported file would be empty: cowardly refusing to write it","editor"),__tr2qs_ctx("OK","editor")); + g_pAliasEditorModule->unlock(); + return; + } + + QString szName = m_szDir; + + if(!szName.endsWith(QString(KVI_PATH_SEPARATOR)))szName += KVI_PATH_SEPARATOR; + QString szFile; + g_pAliasEditorModule->lock(); + + if (count==1) + { + QString tmp=buildFullItemName(l.at(0)); + szNameFile = tmp.replace("::","_"); + } else { + szNameFile="aliases"; + } + szName += szNameFile; + szName += ".kvs"; + if(!KviFileDialog::askForSaveFileName(szFile,__tr2qs_ctx("Choose a Filename - KVIrc","editor"),szName,KVI_FILTER_SCRIPT,false,true,true)) + { + g_pAliasEditorModule->unlock(); + return; + } + m_szDir=QFileInfo(szFile).absolutePath(); + g_pAliasEditorModule->unlock(); + + if(!KviFileUtils::writeFile(szFile,szOut)) + { + g_pAliasEditorModule->lock(); + QMessageBox::warning(this,__tr2qs_ctx("Write Failed - KVIrc","editor"),__tr2qs_ctx("Unable to write to the alias file.","editor"),__tr2qs_ctx("OK","editor")); + g_pAliasEditorModule->unlock(); + } +} +void AliasEditorWidget::buildAliasesFile(KviPointerList<AliasEditorTreeWidgetItem> *l, QString & szBuffer) +{ + for(AliasEditorTreeWidgetItem * it = l->first();it;it = l->next()) + { + QString tmp; + getExportAliasBuffer(tmp,it); + szBuffer += tmp; + szBuffer += "\n"; + } +} + +void AliasEditorWidget::saveProperties(KviConfigurationFile *cfg) +{ + cfg->writeEntry("Sizes",m_pSplitter->sizes()); + QString szName; + if(m_pLastEditedItem) + szName = buildFullItemName(m_pLastEditedItem); + cfg->writeEntry("LastAlias",szName); +} + +void AliasEditorWidget::loadProperties(KviConfigurationFile *cfg) +{ + QList<int> def; + def.append(20); + def.append(80); + m_pSplitter->setSizes(cfg->readIntListEntry("Sizes",def)); + QString tmp = cfg->readEntry("LastAlias",QString()); + + AliasEditorTreeWidgetItem * it = findItem(tmp); + activateItem(it); +} + +void AliasEditorWidget::appendSelectedAliasItems(KviPointerList<AliasEditorTreeWidgetItem> * l) +{ + QList<QTreeWidgetItem *> list=m_pTreeWidget->selectedItems(); + for(int i=0;i<list.count();i++) + { + if (((AliasEditorTreeWidgetItem *)list.at(i))->isAlias()) + { + l->append((AliasEditorTreeWidgetItem *)list.at(i)); + } else { + appendSelectedAliasItemsRecursive(l,list.at(i)); + } + } +} +void AliasEditorWidget::appendSelectedAliasItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom) +{ + for (int i=0;i<pStartFrom->childCount();i++) + { + if (((AliasEditorTreeWidgetItem *)pStartFrom->child(i))->isAlias()) + l->append(((AliasEditorTreeWidgetItem *)pStartFrom->child(i))); + else + appendSelectedAliasItemsRecursive(l,pStartFrom->child(i)); + } +} + + +void AliasEditorWidget::appendSelectedItems(KviPointerList<AliasEditorTreeWidgetItem> * l) +{ + QList<QTreeWidgetItem *> list=m_pTreeWidget->selectedItems(); + for(int i=0;i<list.count();i++) + { + l->append((AliasEditorTreeWidgetItem *)list.at(i)); + /* if (!((AliasEditorTreeWidgetItem *)list.at(i))->isAlias()) + appendSelectedAliasItemsRecursive(l,list.at(i));*/ + } + +} +void AliasEditorWidget::appendSelectedItemsRecursive(KviPointerList<AliasEditorTreeWidgetItem> * l,QTreeWidgetItem * pStartFrom) +{ + for (int i=0;i<pStartFrom->childCount();i++) + { + l->append(((AliasEditorTreeWidgetItem *)pStartFrom->child(i))); + if (!((AliasEditorTreeWidgetItem *)pStartFrom->child(i))->isAlias()) + appendSelectedAliasItemsRecursive(l,pStartFrom->child(i)); + } +} + +void AliasEditorWidget::removeItemChildren(AliasEditorTreeWidgetItem *it) +{ + while(it->childCount() > 0) + { + AliasEditorTreeWidgetItem * pChild = (AliasEditorTreeWidgetItem *)(it->child(0)); + if(pChild->childCount()) + removeItemChildren(pChild); + delete pChild; + m_pAliases->removeRef(pChild); + } +} + +bool AliasEditorWidget::removeItem(AliasEditorTreeWidgetItem *it,bool * pbYesToAll,bool) +{ + if(!it)return true; + QString szMsg; + QString szName = it->name(); + + if(!*pbYesToAll) + { + if(it->isAlias()) + KviQString::sprintf(szMsg,__tr2qs_ctx("Do you really want to remove the alias \"%Q\" ?","editor"),&szName); + else { + KviQString::sprintf(szMsg,__tr2qs_ctx("Do you really want to remove the namespace \"%Q\" ?","editor"),&szName); + szMsg += "<br>"; + szMsg += __tr2qs_ctx("Please note that all the children items will be deleted too.","editor"); + } + + g_pAliasEditorModule->lock(); + int ret = QMessageBox::question(this,__tr2qs_ctx("Remove item","editor"),szMsg,__tr2qs_ctx("Yes","editor"),__tr2qs_ctx("Yes to All","editor"),__tr2qs_ctx("No","editor")); + g_pAliasEditorModule->unlock(); + switch(ret) + { + case 0: + // nothing + break; + case 1: + *pbYesToAll = true; + break; + default: + return false; + break; + } + } + + if(it == m_pLastEditedItem) + m_pLastEditedItem = 0; + if(it == m_pLastClickedItem) + m_pLastClickedItem = 0; + if (it->childCount()) + removeItemChildren(it); + delete it; + m_pAliases->removeRef(it); + return true; +} + +void AliasEditorWidget::removeSelectedItems() +{ + KviPointerList<AliasEditorTreeWidgetItem> l; + l.setAutoDelete(false); + appendSelectedItems(&l); + bool bYesToAll = false; + for(AliasEditorTreeWidgetItem *it = l.first();it;it = l.next()) + { + if(!removeItem(it,&bYesToAll,false))return; + } +} + +QString AliasEditorWidget::askForAliasName(const QString &szAction,const QString &szText,const QString &szInitialText) +{ + bool bOk = false; + QString szNewName; + while(szNewName.isEmpty()) + { + g_pAliasEditorModule->lock(); + szNewName = QInputDialog::getText(this, + szAction, + szText, + QLineEdit::Normal, + szInitialText, + &bOk); + g_pAliasEditorModule->unlock(); + if(!bOk)return QString(); + if(szNewName.isEmpty()) + { + g_pAliasEditorModule->lock(); + QMessageBox::warning(this, + __tr2qs_ctx("Missing Alias Name","editor"), + __tr2qs_ctx("You must specify a valid name for the alias","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + continue; + } + + // we allow only [\w:]+ + QRegExp re("[\\w:]+"); + if(!re.exactMatch(szNewName)) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Bad Alias Name","editor"), + __tr2qs_ctx("Alias names can contain only letters, digits, underscores and '::' namespace separators","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + szNewName = ""; + continue; + } + // make sure that we have only doubled "::" and not ":" or ":::..." + QString tmp = szNewName; + tmp.replace("::","@"); // @ is not allowed by the rule above + if(tmp.indexOf(":",Qt::CaseInsensitive) != -1) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Bad Alias Name","editor"), + __tr2qs_ctx("Stray ':' character in alias name: did you mean ...<namespace>::<name> ?","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + szNewName = ""; + continue; + } + if(tmp.indexOf("@@",Qt::CaseInsensitive) != -1) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Bad Alias Name","editor"), + __tr2qs_ctx("Found an empty namespace in alias name","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + szNewName = ""; + continue; + } + } + return szNewName; +} + +QString AliasEditorWidget::askForNamespaceName(const QString &szAction,const QString &szText,const QString &szInitialText) +{ + bool bOk = false; + QString szNewName; + while(szNewName.isEmpty()) + { + g_pAliasEditorModule->lock(); + szNewName = QInputDialog::getText(this, + szAction, + szText, + QLineEdit::Normal, + szInitialText, + &bOk); + g_pAliasEditorModule->unlock(); + if(!bOk)return QString(); + if(szNewName.isEmpty()) + { + g_pAliasEditorModule->lock(); + QMessageBox::warning(this, + __tr2qs_ctx("Missing Namespace Name","editor"), + __tr2qs_ctx("You must specify a valid name for the namespace","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + continue; + } + + // we allow only [\w:]+ + QRegExp re("[\\w:]+"); + if(!re.exactMatch(szNewName)) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Bad Namespace Name","editor"), + __tr2qs_ctx("Namespace names can contain only letters, digits, underscores and '::' namespace separators","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + szNewName = ""; + continue; + } + // make sure that we have only doubled "::" and not ":" or ":::..." + QString tmp = szNewName; + tmp.replace("::","@"); // @ is not allowed by the rule above + if(tmp.indexOf(":",Qt::CaseInsensitive) != -1) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Bad Namespace Name","editor"), + __tr2qs_ctx("Stray ':' character in namespace name: did you mean ...<namespace>::<name> ?","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + szNewName = ""; + continue; + } + if(tmp.indexOf("@@",Qt::CaseInsensitive) != -1) + { + g_pAliasEditorModule->lock(); + QMessageBox::information(this, + __tr2qs_ctx("Bad Namespace Name","editor"), + __tr2qs_ctx("Found an empty namespace in namespace name","editor"), + __tr2qs_ctx("Ok, Let me try again...","editor")); + g_pAliasEditorModule->unlock(); + szNewName = ""; + continue; + } + } + return szNewName; +} + +void AliasEditorWidget::openParentItems(QTreeWidgetItem * it) +{ + if(it->parent()) + { + it->parent()->setExpanded(true); + openParentItems(it->parent()); + } +} + +void AliasEditorWidget::activateItem(QTreeWidgetItem * it) +{ + if (!it) return; + openParentItems(it); + m_pTreeWidget->setCurrentItem(it); +} +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,AliasEditorTreeWidgetItem::Alias); +} + +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,AliasEditorTreeWidgetItem::Namespace); +} + +void AliasEditorWidget::newItem(QString &szName,AliasEditorTreeWidgetItem::Type eType) +{ + if(m_pLastClickedItem) + if(!itemExists(m_pLastClickedItem)) m_pLastClickedItem=0; + if(m_pLastClickedItem) buildFullItemPath(m_pLastClickedItem,szName); + int idx=1; + QString szTmp; + if(findItem(szName)) szName.append("1"); + while(findItem(szName)) + { + szTmp.setNum(idx); + szName.chop(szTmp.length()); + szName.append(szTmp); + idx++; + } + AliasEditorTreeWidgetItem * it; + it=createFullItem(szName); + it->setType(eType); + m_pAliases->append(it); + activateItem(it); +} + +void AliasEditorWidget::commit() +{ + m_bSaving = true; + saveLastEditedItem(); + KviKvsAliasManager::instance()->clear(); + for(unsigned int i=0;i<m_pAliases->count();i++) + { + QString szName = buildFullItemName(m_pAliases->at(i)); + KviKvsScript * a = new KviKvsScript(szName,m_pAliases->at(i)->buffer()); + KviKvsAliasManager::instance()->add(szName,a); + } + g_pApp->saveAliases(); + m_bSaving = false; +} + + +AliasEditorWindow::AliasEditorWindow(KviMainWindow * lpFrm) +: KviWindow(KVI_WINDOW_TYPE_SCRIPTEDITOR,lpFrm,"aliaseditor",0) +{ + g_pAliasEditorWindow = this; + + setFixedCaption(__tr2qs_ctx("Alias Editor","editor")); + + QGridLayout * g = new QGridLayout(); + + m_pEditor = new AliasEditorWidget(this); + g->addWidget(m_pEditor,0,0,1,4); + + QPushButton * btn = new QPushButton(__tr2qs_ctx("&OK","editor"),this); + connect(btn,SIGNAL(clicked()),this,SLOT(okClicked())); + btn->setIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ACCEPT))); + g->addWidget(btn,1,1); + + btn = new QPushButton(__tr2qs_ctx("&Apply","editor"),this); + connect(btn,SIGNAL(clicked()),this,SLOT(applyClicked())); + btn->setIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_ACCEPT))); + g->addWidget(btn,1,2); + + btn = new QPushButton(__tr2qs_ctx("Cancel","editor"),this); + connect(btn,SIGNAL(clicked()),this,SLOT(cancelClicked())); + btn->setIcon(*(g_pIconManager->getSmallIcon(KVI_SMALLICON_DISCARD))); + g->addWidget(btn,1,3); + + g->setRowStretch(0,1); + g->setColumnStretch(0,1); + setLayout(g); +} + +AliasEditorWindow::~AliasEditorWindow() +{ + g_pAliasEditorWindow = 0; +} + +void AliasEditorWindow::okClicked() +{ + m_pEditor->commit(); + close(); +} + +void AliasEditorWindow::applyClicked() +{ + m_pEditor->commit(); +} + +void AliasEditorWindow::cancelClicked() +{ + close(); +} + +QPixmap * AliasEditorWindow::myIconPtr() +{ + return g_pIconManager->getSmallIcon(KVI_SMALLICON_ALIAS); +} + +void AliasEditorWindow::getConfigGroupName(QString &szName) +{ + szName = "aliaseditor"; +} + +void AliasEditorWindow::saveProperties(KviConfigurationFile *cfg) +{ + m_pEditor->saveProperties(cfg); +} + +void AliasEditorWindow::loadProperties(KviConfigurationFile *cfg) +{ + m_pEditor->loadProperties(cfg); +} |