/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the tools applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qttoolbardialog.h"

#include "ui_qttoolbardialog.h"

#include <QtCore/QSet>

#include <QtGui/QtEvents>

#include <QtGui/QAction>

#include <QtGui/QToolBar>

#include <QtGui/QMainWindow>

#include <QtGui/QHeaderView>

#include <QtGui/QPushButton>

QT_BEGIN_NAMESPACE

class QtFullToolBarManagerPrivate;

class QtFullToolBarManager : public QObject

{

    Q_OBJECT

public:

    QtFullToolBarManager(QObject *parent);

    ~QtFullToolBarManager();

    void setMainWindow(QMainWindow *mainWindow);

    QMainWindow *mainWindow() const;

    void addCategory(const QString &category);

    bool hasCategory(const QString &category) const;

    QStringList categories() const;

    QList<QAction *> categoryActions(const QString &category) const;

    QString actionCategory(QAction *action) const;

    // only non-separator

    void addAction(QAction *action, const QString &category);

    void removeAction(QAction *action);

    QSet<QAction *> actions() const;

    bool isWidgetAction(QAction *action) const;

    /*

    Adds (registers) toolBar. Adds (registers) actions that already exists in toolBar.

    Remembers toolbar and its actions as a default.

    */

    void addDefaultToolBar(QToolBar *toolBar, const QString &category);

    void removeDefaultToolBar(QToolBar *toolBar);

    // NULL on action list means separator.

    QMap<QToolBar *, QList<QAction *> > defaultToolBars() const;

    bool isDefaultToolBar(QToolBar *toolBar) const;

    QToolBar *createToolBar(const QString &toolBarName);

    void deleteToolBar(QToolBar *toolBar); // only those which were created, not added

    QList<QAction *> actions(QToolBar *toolBar) const;

    void setToolBars(const QMap<QToolBar *, QList<QAction *> > &actions);

    void setToolBar(QToolBar *toolBar, const QList<QAction *> &actions);

    QMap<QToolBar *, QList<QAction *> > toolBarsActions() const;

    QByteArray saveState(int version = 0) const;

    bool restoreState(const QByteArray &state, int version = 0);

public slots:

    void resetToolBar(QToolBar *toolBar);

    void resetAllToolBars();

signals:

    void toolBarCreated(QToolBar *toolBar);

    void toolBarRemoved(QToolBar *toolBar);

    /*

    If QToolBarWidgetAction was in another tool bar and is inserted into

    this toolBar, toolBarChanged is first emitted for other toolbar - without

    that action. (Another approach may be that user first must call setToolBar

    without that action for old tool bar)

    */

    void toolBarChanged(QToolBar *toolBar, const QList<QAction *> &actions);

private:

    QScopedPointer<QtFullToolBarManagerPrivate> d_ptr;

    Q_DECLARE_PRIVATE(QtFullToolBarManager)

    Q_DISABLE_COPY(QtFullToolBarManager)

};

class QtFullToolBarManagerPrivate

{

    class QtFullToolBarManager *q_ptr;

    Q_DECLARE_PUBLIC(QtFullToolBarManager)

public:

    QToolBar *toolBarWidgetAction(QAction *action) const;

    void removeWidgetActions(const QMap<QToolBar *, QList<QAction *> > &actions);

    enum {

        VersionMarker = 0xff,

        ToolBarMarker = 0xfe,

        CustomToolBarMarker = 0xfd,

    };

    void saveState(QDataStream &stream) const;

    bool restoreState(QDataStream &stream) const;

    QToolBar *findDefaultToolBar(const QString &objectName) const;

    QAction *findAction(const QString &actionName) const;

    QToolBar *toolBarByName(const QString &toolBarName) const;

    QtFullToolBarManagerPrivate();

    QMap<QString, QList<QAction *> > categoryToActions;

    QMap<QAction *, QString>         actionToCategory;

    QSet<QAction *> allActions;

    QMap<QAction *, QToolBar *> widgetActions;

    QSet<QAction *> regularActions;

    QMap<QAction *, QList<QToolBar *> > actionToToolBars;

    QMap<QToolBar *, QList<QAction *> > toolBars;

    QMap<QToolBar *, QList<QAction *> > toolBarsWithSeparators;

    QMap<QToolBar *, QList<QAction *> > defaultToolBars;

    QList<QToolBar *> customToolBars;

    QMainWindow *theMainWindow;

};

QtFullToolBarManagerPrivate::QtFullToolBarManagerPrivate()

    : theMainWindow(0)

{

}

QToolBar *QtFullToolBarManagerPrivate::toolBarWidgetAction(QAction *action) const

{

    if (widgetActions.contains(action))

        return widgetActions.value(action);

    return 0;

}

void QtFullToolBarManagerPrivate::removeWidgetActions(const QMap<QToolBar *, QList<QAction *> >

            &actions)

{

    QMap<QToolBar *, QList<QAction *> >::ConstIterator itToolBar = actions.constBegin();

    while (itToolBar != actions.constEnd()) {

        QToolBar *toolBar = itToolBar.key();

        QList<QAction *> newActions = toolBars.value(toolBar);

        QList<QAction *> newActionsWithSeparators = toolBarsWithSeparators.value(toolBar);

        QList<QAction *> removedActions;

        QList<QAction *> actionList = itToolBar.value();

        QListIterator<QAction *> itAction(actionList);

        while (itAction.hasNext()) {

            QAction *action = itAction.next();

            if (newActions.contains(action) && toolBarWidgetAction(action) == toolBar) {

                newActions.removeAll(action);

                newActionsWithSeparators.removeAll(action);

                removedActions.append(action);

            }

        }

        //emit q_ptr->toolBarChanged(toolBar, newActions);

        toolBars.insert(toolBar, newActions);

        toolBarsWithSeparators.insert(toolBar, newActionsWithSeparators);

        QListIterator<QAction *> itRemovedAction(removedActions);

        while (itRemovedAction.hasNext()) {

            QAction *oldAction = itRemovedAction.next();

            widgetActions.insert(oldAction, 0);

            actionToToolBars[oldAction].removeAll(toolBar);

        }

        ++itToolBar;

    }

}

void QtFullToolBarManagerPrivate::saveState(QDataStream &stream) const

{

    stream << (uchar) ToolBarMarker;

    stream << defaultToolBars.size();

    QMap<QToolBar *, QList<QAction *> >::ConstIterator itToolBar =

                defaultToolBars.constBegin();

    while (itToolBar != defaultToolBars.constEnd()) {

        QToolBar *tb = itToolBar.key();

        if (tb->objectName().isEmpty()) {

            qWarning("QtToolBarManager::saveState(): 'objectName' not set for QToolBar "

                "%p '%s', using 'windowTitle' instead",

            tb, tb->windowTitle().toLocal8Bit().constData());

            stream << tb->windowTitle();

        } else {

            stream << tb->objectName();

        }

        stream << toolBars[tb].size();

        QListIterator<QAction *> itAction(toolBars[tb]);

        while (itAction.hasNext()) {

            QAction *action = itAction.next();

            if (action) {

                if (action->objectName().isEmpty()) {

                    qWarning("QtToolBarManager::saveState(): 'objectName' not set for QAction "

                                "%p '%s', using 'text' instead",

                            action, action->text().toLocal8Bit().constData());

                    stream << action->text();

                } else {

                    stream << action->objectName();

                }

            } else {

                stream << QString();

            }

        }

        ++itToolBar;

    }

    stream << (uchar) CustomToolBarMarker;

    stream << toolBars.size() - defaultToolBars.size();

    itToolBar = toolBars.constBegin();

    while (itToolBar != toolBars.constEnd()) {

        QToolBar *tb = itToolBar.key();

        if (!defaultToolBars.contains(tb)) {

            stream << tb->objectName();

            stream << tb->windowTitle();

            stream << toolBars[tb].size();

            QListIterator<QAction *> itAction(toolBars[tb]);

            while (itAction.hasNext()) {

                QAction *action = itAction.next();

                if (action) {

                    if (action->objectName().isEmpty()) {

                        qWarning("QtToolBarManager::saveState(): 'objectName' not set for QAction "

                                    "%p '%s', using 'text' instead",

                                action, action->text().toLocal8Bit().constData());

                        stream << action->text();

                    } else {

                        stream << action->objectName();

                    }

                } else {

                    stream << QString();

                }

            }

        }

        ++itToolBar;

    }

}

bool QtFullToolBarManagerPrivate::restoreState(QDataStream &stream) const

{

    uchar tmarker;

    stream >> tmarker;

    if (tmarker != ToolBarMarker)

        return false;

    int toolBars;

    stream >> toolBars;

    for (int i = 0; i < toolBars; i++) {

        QString objectName;

        stream >> objectName;

        int actionCount;

        stream >> actionCount;

        QList<QAction *> actions;

        for (int j = 0; j < actionCount; j++) {

            QString actionName;

            stream >> actionName;

            if (actionName.isEmpty())

                actions.append(0);

            else {

                QAction *action = findAction(actionName);

                if (action)

                    actions.append(action);

            }

        }

        QToolBar *toolBar = findDefaultToolBar(objectName);

        if (toolBar)

            q_ptr->setToolBar(toolBar, actions);

    }

    uchar ctmarker;

    stream >> ctmarker;

    if (ctmarker != CustomToolBarMarker)

        return false;

    QList<QToolBar *> oldCustomToolBars = customToolBars;

    stream >> toolBars;

    for (int i = 0; i < toolBars; i++) {

        QString objectName;

        QString toolBarName;

        int actionCount;

        stream >> objectName;

        stream >> toolBarName;

        stream >> actionCount;

        QList<QAction *> actions;

        for (int j = 0; j < actionCount; j++) {

            QString actionName;

            stream >> actionName;

            if (actionName.isEmpty())

                actions.append(0);

            else {

                QAction *action = findAction(actionName);

                if (action)

                    actions.append(action);

            }

        }

        QToolBar *toolBar = toolBarByName(objectName);

        if (toolBar) {

            toolBar->setWindowTitle(toolBarName);

            oldCustomToolBars.removeAll(toolBar);

        }

        else

            toolBar = q_ptr->createToolBar(toolBarName);

        if (toolBar) {

            toolBar->setObjectName(objectName);

            q_ptr->setToolBar(toolBar, actions);

        }

    }

    QListIterator<QToolBar *> itToolBar(oldCustomToolBars);

    while (itToolBar.hasNext())

        q_ptr->deleteToolBar(itToolBar.next());

    return true;

}

QToolBar *QtFullToolBarManagerPrivate::findDefaultToolBar(const QString &objectName) const

{

    QMap<QToolBar *, QList<QAction *> >::ConstIterator itToolBar =

                defaultToolBars.constBegin();

    while (itToolBar != defaultToolBars.constEnd()) {

        QToolBar *tb = itToolBar.key();

        if (tb->objectName() == objectName)

            return tb;

        ++itToolBar;

    }

    qWarning("QtToolBarManager::restoreState(): cannot find a QToolBar named "

        "'%s', trying to match using 'windowTitle' instead.",

        objectName.toLocal8Bit().constData());

    itToolBar = defaultToolBars.constBegin();

    while (itToolBar != defaultToolBars.constEnd()) {

        QToolBar *tb = itToolBar.key();

        if (tb->windowTitle() == objectName)

            return tb;

        ++itToolBar;

    }

    qWarning("QtToolBarManager::restoreState(): cannot find a QToolBar with "

        "matching 'windowTitle' (looking for '%s').",

        objectName.toLocal8Bit().constData());

    return 0;

}

QAction *QtFullToolBarManagerPrivate::findAction(const QString &actionName) const

{

    QSetIterator<QAction *> itAction(allActions);

    while (itAction.hasNext()) {

        QAction *action = itAction.next();

        if (action->objectName() == actionName)

            return action;

    }

    qWarning("QtToolBarManager::restoreState(): cannot find a QAction named "

        "'%s', trying to match using 'text' instead.",

        actionName.toLocal8Bit().constData());

    itAction.toFront();

    while (itAction.hasNext()) {

        QAction *action = itAction.next();

        if (action->text() == actionName)

            return action;

    }

    qWarning("QtToolBarManager::restoreState(): cannot find a QAction with "

        "matching 'text' (looking for '%s').",

        actionName.toLocal8Bit().constData());

    return 0;

}

QToolBar *QtFullToolBarManagerPrivate::toolBarByName(const QString &toolBarName) const

{

    QMap<QToolBar *, QList<QAction *> >::ConstIterator itToolBar = toolBars.constBegin();

    while (itToolBar != toolBars.constEnd()) {

        QToolBar *toolBar = itToolBar.key();

        if (toolBar->objectName() == toolBarName)

            return toolBar;

        ++itToolBar;

    }

    return 0;

}

//////////////////////////////

QtFullToolBarManager::QtFullToolBarManager(QObject *parent)

    : QObject(parent), d_ptr(new QtFullToolBarManagerPrivate)

{

    d_ptr->q_ptr = this;

}

QtFullToolBarManager::~QtFullToolBarManager()

{

}

void QtFullToolBarManager::setMainWindow(QMainWindow *mainWindow)

{

    d_ptr->theMainWindow = mainWindow;

}

QMainWindow *QtFullToolBarManager::mainWindow() const

{

    return d_ptr->theMainWindow;

}

void QtFullToolBarManager::addCategory(const QString &category)

{

    d_ptr->categoryToActions[category] = QList<QAction *>();

}

bool QtFullToolBarManager::hasCategory(const QString &category) const

{

    return d_ptr->categoryToActions.contains(category);

}

QStringList QtFullToolBarManager::categories() const

{

    return d_ptr->categoryToActions.keys();

}

QList<QAction *> QtFullToolBarManager::categoryActions(const QString &category) const

{

    QMap<QString, QList<QAction *> >::ConstIterator it =

                d_ptr->categoryToActions.find(category);

    if (it != d_ptr->categoryToActions.constEnd())

        return it.value();

    return QList<QAction *>();

}

QString QtFullToolBarManager::actionCategory(QAction *action) const

{

    QMap<QAction *, QString>::ConstIterator it = d_ptr->actionToCategory.find(action);

    if (it != d_ptr->actionToCategory.constEnd())

        return it.value();

    return QString();

}

void QtFullToolBarManager::addAction(QAction *action, const QString &category)

{

    if (!action)

        return;

    if (action->isSeparator())

        return;

    if (d_ptr->allActions.contains(action))

        return;

    if (QLatin1String(action->metaObject()->className()) ==

                QLatin1String("QToolBarWidgetAction"))

        d_ptr->widgetActions.insert(action, 0);

    else

        d_ptr->regularActions.insert(action);

    d_ptr->allActions.insert(action);

    d_ptr->categoryToActions[category].append(action);

    d_ptr->actionToCategory[action] = category;

}

void QtFullToolBarManager::removeAction(QAction *action)

{

    if (!d_ptr->allActions.contains(action))

        return;

    QList<QToolBar *> toolBars = d_ptr->actionToToolBars[action];

    QListIterator<QToolBar *> itToolBar(toolBars);

    while (itToolBar.hasNext()) {

        QToolBar *toolBar = itToolBar.next();

        d_ptr->toolBars[toolBar].removeAll(action);

        d_ptr->toolBarsWithSeparators[toolBar].removeAll(action);

        toolBar->removeAction(action);