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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the Qt Designer 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 "abstractsettings_p.h"

#include "qtresourceview_p.h"

#include "qtresourcemodel_p.h"

#include "qtresourceeditordialog_p.h"

#include "iconloader_p.h"

#include "filterwidget_p.h" // For FilterWidget

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtGui/QToolBar>

#include <QtGui/QAction>

#include <QtGui/QSplitter>

#include <QtGui/QTreeWidget>

#include <QtGui/QListWidget>

#include <QtGui/QHeaderView>

#include <QtGui/QVBoxLayout>

#include <QtGui/QPainter>

#include <QtCore/QFileInfo>

#include <QtCore/QDir>

#include <QtCore/QQueue>

#include <QtGui/QPainter>

#include <QtGui/QDialogButtonBox>

#include <QtGui/QPushButton>

#include <QtGui/QMessageBox>

#include <QtGui/QApplication>

#include <QtGui/QClipboard>

#include <QtGui/QMenu>

#include <QtGui/QDrag>

#include <QtCore/QMimeData>

#include <QtXml/QDomDocument>

QT_BEGIN_NAMESPACE

static const char *elementResourceData = "resource";

static const char *typeAttribute = "type";

static const char *typeImage = "image";

static const char *typeStyleSheet = "stylesheet";

static const char *typeOther = "other";

static const char *fileAttribute = "file";

static const char *SplitterPosition = "SplitterPosition";

static const char *Geometry = "Geometry";

static const char *ResourceViewDialogC = "ResourceDialog";

// ---------------- ResourceListWidget: A list widget that has drag enabled

class ResourceListWidget : public QListWidget {

public:

    ResourceListWidget(QWidget *parent = 0);

protected:

    virtual void startDrag(Qt::DropActions supportedActions);

};

ResourceListWidget::ResourceListWidget(QWidget *parent) :

    QListWidget(parent)

{

    setDragEnabled(true);

}

void ResourceListWidget::startDrag(Qt::DropActions supportedActions)

{

    if (supportedActions == Qt::MoveAction)

        return;

    QListWidgetItem *item = currentItem();

    if (!item)

        return;

    const QString filePath = item->data(Qt::UserRole).toString();

    const QIcon icon = item->icon();

    QMimeData *mimeData = new QMimeData;

    const QtResourceView::ResourceType type = icon.isNull() ? QtResourceView::ResourceOther : QtResourceView::ResourceImage;

    mimeData->setText(QtResourceView::encodeMimeData(type , filePath));

    QDrag *drag = new QDrag(this);

    if (!icon.isNull()) {

        const QSize size = icon.actualSize(iconSize());

        drag->setPixmap(icon.pixmap(size));

        drag->setHotSpot(QPoint(size.width() / 2, size.height() / 2));

    }

    drag->setMimeData(mimeData);

    drag->exec(Qt::CopyAction);

}

/* TODO

   1) load the icons in separate thread...Hmm..if Qt is configured with threads....

*/

// ---------------------------- QtResourceViewPrivate

class QtResourceViewPrivate

{

    QtResourceView *q_ptr;

    Q_DECLARE_PUBLIC(QtResourceView)

public:

    QtResourceViewPrivate(QDesignerFormEditorInterface *core);

    void slotResourceSetActivated(QtResourceSet *resourceSet);

    void slotCurrentPathChanged(QTreeWidgetItem *);

    void slotCurrentResourceChanged(QListWidgetItem *);

    void slotResourceActivated(QListWidgetItem *);

    void slotEditResources();

    void slotReloadResources();

    void slotCopyResourcePath();

    void slotListWidgetContextMenuRequested(const QPoint &pos);

    void slotFilterChanged(const QString &pattern);

    void createPaths();

    QTreeWidgetItem *createPath(const QString &path, QTreeWidgetItem *parent);

    void createResources(const QString &path);

    void storeExpansionState();

    void applyExpansionState();

    void restoreSettings();

    void saveSettings();

    void updateActions();

    void filterOutResources();

    QPixmap makeThumbnail(const QPixmap &pix) const;

    QDesignerFormEditorInterface *m_core;

    QtResourceModel *m_resourceModel;

    QToolBar *m_toolBar;

    qdesigner_internal::FilterWidget *m_filterWidget;

    QTreeWidget *m_treeWidget;

    QListWidget *m_listWidget;

    QSplitter *m_splitter;

    QMap<QString, QStringList>       m_pathToContents; // full path to contents file names (full path to its resource filenames)

    QMap<QString, QString>           m_pathToParentPath; // full path to full parent path

    QMap<QString, QStringList>       m_pathToSubPaths; // full path to full sub paths

    QMap<QString, QTreeWidgetItem *> m_pathToItem;

    QMap<QTreeWidgetItem *, QString> m_itemToPath;

    QMap<QString, QListWidgetItem *> m_resourceToItem;

    QMap<QListWidgetItem *, QString> m_itemToResource;

    QAction *m_editResourcesAction;

    QAction *m_reloadResourcesAction;

    QAction *m_copyResourcePathAction;

    QMap<QString, bool> m_expansionState;

    bool m_ignoreGuiSignals;

    QString m_settingsKey;

    bool m_resourceEditingEnabled;

    QString m_filterPattern;

};

QtResourceViewPrivate::QtResourceViewPrivate(QDesignerFormEditorInterface *core) :

    q_ptr(0),

    m_core(core),

    m_resourceModel(0),

    m_toolBar(new QToolBar),

    m_treeWidget(new QTreeWidget),

    m_listWidget(new ResourceListWidget),

    m_splitter(0),

    m_editResourcesAction(0),

    m_reloadResourcesAction(0),

    m_copyResourcePathAction(0),

    m_ignoreGuiSignals(false),

    m_resourceEditingEnabled(true)

{

}

void QtResourceViewPrivate::restoreSettings()

{

    if (m_settingsKey.isEmpty())

        return;

    QDesignerSettingsInterface *settings = m_core->settingsManager();

    settings->beginGroup(m_settingsKey);

    m_splitter->restoreState(settings->value(QLatin1String(SplitterPosition)).toByteArray());

    settings->endGroup();

}

void QtResourceViewPrivate::saveSettings()

{

    if (m_settingsKey.isEmpty())

        return;

    QDesignerSettingsInterface *settings = m_core->settingsManager();

    settings->beginGroup(m_settingsKey);

    settings->setValue(QLatin1String(SplitterPosition), m_splitter->saveState());

    settings->endGroup();

}

void QtResourceViewPrivate::slotEditResources()

{

    const QString selectedResource

            = QtResourceEditorDialog::editResources(m_core, m_resourceModel,

                                                    m_core->dialogGui(), q_ptr);

    if (!selectedResource.isEmpty())

        q_ptr->selectResource(selectedResource);

}

void QtResourceViewPrivate::slotReloadResources()

{

    if (m_resourceModel) {

        int errorCount;

        QString errorMessages;

        m_resourceModel->reload(&errorCount, &errorMessages);

        if (errorCount)

            QtResourceEditorDialog::displayResourceFailures(errorMessages, m_core->dialogGui(), q_ptr);

    }

}

void QtResourceViewPrivate::slotCopyResourcePath()

{

    const QString path = q_ptr->selectedResource();

    QClipboard *clipboard = QApplication::clipboard();

    clipboard->setText(path);

}

void QtResourceViewPrivate::slotListWidgetContextMenuRequested(const QPoint &pos)

{

    QMenu menu(q_ptr);

    menu.addAction(m_copyResourcePathAction);

    menu.exec(m_listWidget->mapToGlobal(pos));

}

void QtResourceViewPrivate::slotFilterChanged(const QString &pattern)

{

    m_filterPattern = pattern;

    filterOutResources();

}

void QtResourceViewPrivate::storeExpansionState()

{

    QMapIterator<QString, QTreeWidgetItem *> it(m_pathToItem);

    while (it.hasNext()) {

        it.next();

        m_expansionState[it.key()] = it.value()->isExpanded();

    }

}

void QtResourceViewPrivate::applyExpansionState()

{

    QMapIterator<QString, QTreeWidgetItem *> it(m_pathToItem);

    while (it.hasNext()) {

        it.next();

        it.value()->setExpanded(m_expansionState.value(it.key(), true));

    }

}

QPixmap QtResourceViewPrivate::makeThumbnail(const QPixmap &pix) const

{

    int w = qMax(48, pix.width());

    int h = qMax(48, pix.height());

    QRect imgRect(0, 0, w, h);

    QImage img(w, h, QImage::Format_ARGB32_Premultiplied);

    img.fill(0);

    if (!pix.isNull()) {

        QRect r(0, 0, pix.width(), pix.height());

        r.moveCenter(imgRect.center());

        QPainter p(&img);

        p.drawPixmap(r.topLeft(), pix);

    }

    return QPixmap::fromImage(img);

}

void QtResourceViewPrivate::updateActions()

{

    bool resourceActive = false;

    if (m_resourceModel)

        resourceActive = m_resourceModel->currentResourceSet();

    m_editResourcesAction->setVisible(m_resourceEditingEnabled);

    m_editResourcesAction->setEnabled(resourceActive);

    m_reloadResourcesAction->setEnabled(resourceActive);

    m_filterWidget->setEnabled(resourceActive);

}

void QtResourceViewPrivate::slotResourceSetActivated(QtResourceSet *resourceSet)

{

    Q_UNUSED(resourceSet)

    updateActions();

    storeExpansionState();

    const QString currentPath = m_itemToPath.value(m_treeWidget->currentItem());

    const QString currentResource = m_itemToResource.value(m_listWidget->currentItem());

    m_treeWidget->clear();

    m_pathToContents.clear();

    m_pathToParentPath.clear();

    m_pathToSubPaths.clear();

    m_pathToItem.clear();

    m_itemToPath.clear();

    m_listWidget->clear();

    m_resourceToItem.clear();

    m_itemToResource.clear();

    createPaths();

    applyExpansionState();

    if (!currentResource.isEmpty())

        q_ptr->selectResource(currentResource);

    else if (!currentPath.isEmpty())

        q_ptr->selectResource(currentPath);

    filterOutResources();

}

void QtResourceViewPrivate::slotCurrentPathChanged(QTreeWidgetItem *item)

{

    if (m_ignoreGuiSignals)

        return;

    m_listWidget->clear();

    m_resourceToItem.clear();

    m_itemToResource.clear();

    if (!item)

        return;

    const QString currentPath = m_itemToPath.value(item);

    createResources(currentPath);

}

void QtResourceViewPrivate::slotCurrentResourceChanged(QListWidgetItem *item)

{

    m_copyResourcePathAction->setEnabled(item);

    if (m_ignoreGuiSignals)

        return;

    emit q_ptr->resourceSelected(m_itemToResource.value(item));

}

void QtResourceViewPrivate::slotResourceActivated(QListWidgetItem *item)

{

    if (m_ignoreGuiSignals)

        return;

    emit q_ptr->resourceActivated(m_itemToResource.value(item));

}

void QtResourceViewPrivate::createPaths()

{

    if (!m_resourceModel)

        return;

    const QString root(QLatin1Char(':'));

    QMap<QString, QString> contents = m_resourceModel->contents();

    QMapIterator<QString, QString> itContents(contents);

    while (itContents.hasNext()) {

        const QString filePath = itContents.next().key();

        const QFileInfo fi(filePath);

        QString dirPath = fi.absolutePath();

        m_pathToContents[dirPath].append(fi.fileName());

        while (!m_pathToParentPath.contains(dirPath) && dirPath != root) { // create all parent paths

            const QFileInfo fd(dirPath);

            const QString parentDirPath = fd.absolutePath();

            m_pathToParentPath[dirPath] = parentDirPath;

            m_pathToSubPaths[parentDirPath].append(dirPath);

            dirPath = parentDirPath;

        }

    }

    QQueue<QPair<QString, QTreeWidgetItem *> > pathToParentItemQueue;

    pathToParentItemQueue.enqueue(qMakePair(root, static_cast<QTreeWidgetItem *>(0)));

    while (!pathToParentItemQueue.isEmpty()) {

        QPair<QString, QTreeWidgetItem *> pathToParentItem = pathToParentItemQueue.dequeue();

        const QString path = pathToParentItem.first;

        QTreeWidgetItem *item = createPath(path, pathToParentItem.second);

        QStringList subPaths = m_pathToSubPaths.value(path);

        QStringListIterator itSubPaths(subPaths);

        while (itSubPaths.hasNext())

            pathToParentItemQueue.enqueue(qMakePair(itSubPaths.next(), item));

    }

}

void QtResourceViewPrivate::filterOutResources()

{

    QMap<QString, bool> pathToMatchingContents; // true means the path has any matching contents

    QMap<QString, bool> pathToVisible; // true means the path has to be shown

    // 1) we go from root path recursively.

    // 2) we check every path if it contains at least one matching resource - if empty we add it

    //                 to pathToMatchingContents and pathToVisible with false, if non empty

    //                 we add it with true and change every parent path in pathToVisible to true.

    // 3) we hide these items which has pathToVisible value false.

    const bool matchAll = m_filterPattern.isEmpty();

    const QString root(QLatin1Char(':'));

    QQueue<QString> pathQueue;

    pathQueue.enqueue(root);

    while (!pathQueue.isEmpty()) {

        const QString path = pathQueue.dequeue();

        QStringList fileNames = m_pathToContents.value(path);

        QStringListIterator it(fileNames);

        bool hasContents = matchAll;

        if (!matchAll) { // the case filter is not empty - we check if the path contains anything

            while (it.hasNext()) {

                QString fileName = it.next();

                hasContents = fileName.contains(m_filterPattern, Qt::CaseInsensitive);

                if (hasContents) // the path contains at least one resource which matches the filter

                    break;

            }

        }

        pathToMatchingContents[path] = hasContents;

        pathToVisible[path] = hasContents;

        if (hasContents) { // if the path is going to be shown we need to show all its parent paths

            QString parentPath = m_pathToParentPath.value(path);

            while (!parentPath.isEmpty()) {

                QString p = parentPath;

                if (pathToVisible.value(p)) // parent path is already shown, we break the loop

                    break;

                pathToVisible[p] = true;

                parentPath = m_pathToParentPath.value(p);

            }

        }

        QStringList subPaths = m_pathToSubPaths.value(path); // we do the same for children paths

        QStringListIterator itSubPaths(subPaths);

        while (itSubPaths.hasNext())

            pathQueue.enqueue(itSubPaths.next());

    }

    // we setup here new path and resource to be activated

    const QString currentPath = m_itemToPath.value(m_treeWidget->currentItem());

    QString newCurrentPath = currentPath;

    QString currentResource = m_itemToResource.value(m_listWidget->currentItem());

    if (!matchAll) {

        bool searchForNewPathWithContents = true;

        if (!currentPath.isEmpty()) { // if the currentPath is empty we will search for a new path too

            QMap<QString, bool>::ConstIterator it = pathToMatchingContents.constFind(currentPath);

            if (it != pathToMatchingContents.constEnd() && it.value()) // the current item has contents, we don't need to search for another path

                searchForNewPathWithContents = false;

        }

        if (searchForNewPathWithContents) {

            // we find the first path with the matching contents

            QMap<QString, bool>::ConstIterator itContents = pathToMatchingContents.constBegin();

            while (itContents != pathToMatchingContents.constEnd()) {

                if (itContents.value()) {

                    newCurrentPath = itContents.key(); // the new path will be activated

                    break;

                }

                itContents++;

            }

        }

        QFileInfo fi(currentResource);

        if (!fi.fileName().contains(m_filterPattern, Qt::CaseInsensitive)) { // the case when the current resource is filtered out

            const QStringList fileNames = m_pathToContents.value(newCurrentPath);

            QStringListIterator it(fileNames);

            while (it.hasNext()) { // we try to select the first matching resource from the newCurrentPath

                QString fileName = it.next();

                if (fileName.contains(m_filterPattern, Qt::CaseInsensitive)) {

                    QDir dirPath(newCurrentPath);

                    currentResource = dirPath.absoluteFilePath(fileName); // the new resource inside newCurrentPath will be activated

                    break;

                }

            }

        }

    }

    QTreeWidgetItem *newCurrentItem = m_pathToItem.value(newCurrentPath);

    if (currentPath != newCurrentPath)

        m_treeWidget->setCurrentItem(newCurrentItem);

    else

        slotCurrentPathChanged(newCurrentItem); // trigger filtering on the current path

    QListWidgetItem *currentResourceItem = m_resourceToItem.value(currentResource);

    if (currentResourceItem) {

        m_listWidget->setCurrentItem(currentResourceItem);

        m_listWidget->scrollToItem(currentResourceItem);

    }

    QMapIterator<QString, bool> it(pathToVisible); // hide all paths filtered out

    while (it.hasNext()) {

        const QString path = it.next().key();

        QTreeWidgetItem *item = m_pathToItem.value(path);

        if (item)

            item->setHidden(!it.value());

    }

}

QTreeWidgetItem *QtResourceViewPrivate::createPath(const QString &path, QTreeWidgetItem *parent)

{

    QTreeWidgetItem *item = 0;

    if (parent)

        item = new QTreeWidgetItem(parent);