ClassEditorWindow.h

Go to the documentation of this file.

#ifndef _CLASSEDITOR_H_
#define _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
//   Copyright (C) 2010 Alessandro Carbone (elfonol at gmail dot com)
//
//   This program is FREE software. You can redistribute it and/or
//   modify it under the terms of the GNU General Public License
//   as published by the Free Software Foundation; either version 2
//   of the License, or (at your option) 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 "KviWindow.h"
#include "KviCString.h"
#include "KviPointerList.h"
#include "KviHeapObject.h"
#include "KviKvsObjectClass.h"

#include <QWidget>
#include <QComboBox>
#include <QDialog>
#include <QLineEdit>
#include <QCheckBox>
#include <QTreeWidget>
#include <QMenu>

class QLineEdit;
class QStringList;
class QPushButton;
class QCheckBox;
class QLabel;
class QSplitter;
class KviScriptEditor;

class ClassEditorTreeWidget : public QTreeWidget
{
        Q_OBJECT
public:
        ClassEditorTreeWidget(QWidget * pParent);

        ~ClassEditorTreeWidget();

protected:
        virtual void mousePressEvent(QMouseEvent * e);
signals:
        void rightButtonPressed(QTreeWidgetItem * pItem, QPoint pos);
};

class ClassEditorTreeWidgetItem : public QTreeWidgetItem, public KviHeapObject
{
public:
        enum Type
        {
                Class,     
                Namespace, 
                Method     
        };

public:
        ClassEditorTreeWidgetItem(QTreeWidget * pTreeWidget, Type eType, const QString & szName);

        ClassEditorTreeWidgetItem(ClassEditorTreeWidgetItem * pParentItem, Type eType, const QString & szName);

        ~ClassEditorTreeWidgetItem(){};

protected:
        Type m_eType;
        QString m_szName;
        QString m_szBuffer;
        QString m_szInheritsClassName;
        QString m_szReminder;
        bool m_bClassModified;
        bool m_bInternal;
        int m_iPos;

public:
        void setInheritsClass(QString szInheritsClassName) { m_szInheritsClassName = szInheritsClassName; };

        QString inheritsClass() { return m_szInheritsClassName; };

        const QString & name() { return m_szName; };

        void setName(const QString & szName);

        void setReminder(const QString & szRem) { m_szReminder = szRem; };

        QString reminder() { return m_szReminder; };

        void setClassNotBuilt(bool bModified);

        bool classNotBuilt() { return m_bClassModified; };

        void setInternalFunction(bool bInternal) { m_bInternal = bInternal; };

        bool isInternalFunction() { return m_bInternal; };

        Type type() { return m_eType; };

        void setType(Type eType);

        bool isClass() { return m_eType == Class; };

        bool isNamespace() { return m_eType == Namespace; };

        bool isMethod() { return m_eType == Method; };

        void setBuffer(const QString & szBuffer) { m_szBuffer = szBuffer; };

        const QString & buffer() { return m_szBuffer; };

        const int & cursorPosition() { return m_iPos; };

        void setCursorPosition(const int & iPos) { m_iPos = iPos; };
};

class ClassEditorWidget : public QWidget
{
        Q_OBJECT
public:
        ClassEditorWidget(QWidget * pParent);

        ~ClassEditorWidget();

public:
        KviScriptEditor * m_pEditor;
        ClassEditorTreeWidget * m_pTreeWidget;
        QLabel * m_pClassNameLabel;
        QPushButton * m_pClassNameRenameButton;
        QLabel * m_pFunctionNameLabel;
        QPushButton * m_pFunctionNameRenameButton;
        QLabel * m_pReminderLabel;

        ClassEditorTreeWidgetItem * m_pLastEditedItem;
        ClassEditorTreeWidgetItem * m_pLastClickedItem;
        QMenu * m_pContextPopup;
        QSplitter * m_pSplitter;
        QString m_szDir;
        bool m_bSaving;

protected:
        KviPointerHashTable<QString, ClassEditorTreeWidgetItem> * m_pClasses;

public:
        virtual void saveProperties(KviConfigurationFile * pCfg);

        virtual void loadProperties(KviConfigurationFile * pCfg);

        void build();

        void saveNotBuiltClasses();

        void loadNotBuiltClasses();

        ClassEditorTreeWidgetItem * findFunction(const QString & szFunctionName, ClassEditorTreeWidgetItem * pClass);

        void exportClasses(bool bSelectedOnly, bool bSingleFiles = false);

        void exportSelectionInSinglesFiles(KviPointerList<ClassEditorTreeWidgetItem> * pList);

        void cutItem(ClassEditorTreeWidgetItem * pItem);

protected:
        //void recursiveSearchReplace(const QString &szSearch,ClassEditorTreeWidgetItem * it,bool bReplace=false,const QString &szReplace="n");

        void exportClassBuffer(QString & szBuffer, ClassEditorTreeWidgetItem * pItem);

        void oneTimeSetup();
        void createFullClass(KviKvsObjectClass * pClass, ClassEditorTreeWidgetItem * pItem, const QString & szClassName);

        void saveLastEditedItem();
        void appendSelectedClassItems(KviPointerList<ClassEditorTreeWidgetItem> * pList);
        void appendSelectedClassItemsRecursive(KviPointerList<ClassEditorTreeWidgetItem> * pList, QTreeWidgetItem * pStartFrom);

        void appendAllClassItems(KviPointerList<ClassEditorTreeWidgetItem> * pList);
        void appendAllClassItemsRecursive(KviPointerList<ClassEditorTreeWidgetItem> * l, QTreeWidgetItem * pStartFrom);

        void openParentItems(QTreeWidgetItem * pItem);
        void activateItem(QTreeWidgetItem * pItem);
        bool hasSelectedItems();
        bool askForClassName(QString & szClassName, QString & szInheritsClassName, bool bEdit);
        bool askForNamespaceName(const QString & szAction, const QString & szText, const QString & szInitialText, QString & szNameBuffer);
        bool askForFunction(QString & szFunctionName, QString & szReminder, bool * pbInternal, const QString & szClassName, bool bRenameMode);
        void searchInheritedClasses(const QString szClass, KviPointerList<ClassEditorTreeWidgetItem> & lInheritsedClasses);

        bool classExists(QString & szName);

        void renameClass(ClassEditorTreeWidgetItem * pClass);

        void renameNamespace(ClassEditorTreeWidgetItem * pNamespace);

        bool removeItem(ClassEditorTreeWidgetItem * pItem, KviPointerList<ClassEditorTreeWidgetItem> & lRemovedItems, bool * pbYesToAll);
        void updateClassHierarchy(ClassEditorTreeWidgetItem * pClass);

        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);

        ClassEditorTreeWidgetItem * findItem(const QString & szName);

        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);
        void newClass();
        void newNamespace();
        void newMemberFunction();
        void renameFunction();
        ClassEditorTreeWidgetItem * newItem(QString & szName, ClassEditorTreeWidgetItem::Type eType);

        void renameItem();

        void exportAll();
        void exportSelectedSepFiles();
        void exportSelected();
        void slotFind();
        void slotFindWord(const QString &);
        void searchReplace(const QString & szSearch, bool bReplace = false, const QString & szReplace = "n");

        void slotCollapseItems();

        void recursiveCollapseItems(ClassEditorTreeWidgetItem * pItem);

        void removeSelectedItems();

        void slotReplaceAll(const QString & szBefore, const QString & szAfter);
};

class ClassEditorWindow : public KviWindow
{
        Q_OBJECT
public:
        ClassEditorWindow();

        ~ClassEditorWindow();

protected:
        ClassEditorWidget * m_pEditor;

protected:
        virtual QPixmap * myIconPtr();

        virtual void configGroupName(QString & szName);

        virtual void saveProperties(KviConfigurationFile * pCfg);

        virtual void loadProperties(KviConfigurationFile * pCfg);
protected slots:
        void cancelClicked();

        void buildClicked();

        void saveClicked();
};

class KviClassEditorDialog : public QDialog
{
        Q_OBJECT
public:
        KviClassEditorDialog(QWidget * pParent, const QString & szName, KviPointerHashTable<QString, ClassEditorTreeWidgetItem> * pClasses, const QString & szClassName, const QString & szInheritsClassName, bool bRenameMode = false);

        ~KviClassEditorDialog();

protected:
        QPushButton * m_pNewClassButton;
        QLineEdit * m_pClassNameLineEdit;
        QComboBox * m_pInheritsClassComboBox;

public:
        QString className() { return m_pClassNameLineEdit->text(); };

        QString inheritsClassName() { return m_pInheritsClassComboBox->currentText(); };
protected slots:
        void textChanged(const QString &);
};

class KviClassEditorFunctionDialog : public QDialog
{
        Q_OBJECT
public:
        KviClassEditorFunctionDialog(QWidget * pParent, const QString & szName, const QString & szClassName, const QString & szFunctionName, const QString & szReminder, bool bIsInternal, bool bRenameMode = false);

        ~KviClassEditorFunctionDialog();

protected:
        QPushButton * m_pNewFunctionButton;
        QLineEdit * m_pFunctionNameLineEdit;
        QLineEdit * m_pReminderLineEdit;
        QCheckBox * m_pInternalCheckBox;

public:
        QString functionName() { return m_pFunctionNameLineEdit->text(); };

        QString reminder() { return m_pReminderLineEdit->text(); };

        bool isInternalFunction() { return m_pInternalCheckBox->isChecked(); };
protected slots:
        void textChanged(const QString &);
};
#endif //_CLASSEDITOR_H_