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

**

** 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 "abstractformeditor.h"

#include "qtresourceeditordialog_p.h"

#include "ui_qtresourceeditordialog.h"

#include "qtresourcemodel_p.h"

#include "iconloader_p.h"

#include <abstractdialoggui_p.h>

#include <QtCore/QFileInfo>

#include <QtCore/QDir>

#include <QtCore/QCoreApplication>

#include <QtXml/QDomDocument>

#include <QtGui/QMenu>

#include <QtGui/QHeaderView>

#include <QtGui/QInputDialog>

#include <QtGui/QMessageBox>

#include <QtGui/QPushButton>

#include <QtGui/QStandardItemModel>

QT_BEGIN_NAMESPACE

static const char *rccRootTag = "RCC";

static const char *rccTag = "qresource";

static const char *rccFileTag = "file";

static const char *rccAliasAttribute = "alias";

static const char *rccPrefixAttribute = "prefix";

static const char *rccLangAttribute = "lang";

static const char *SplitterPosition = "SplitterPosition";

static const char *Geometry = "Geometry";

static const char *QrcDialogC = "QrcDialog";

static QString msgOverwrite(const QString &fname)

{

    return QApplication::translate("QtResourceEditorDialog", "%1 already exists.\nDo you want to replace it?", 0, QApplication::UnicodeUTF8).arg(fname);

}

static QString msgTagMismatch(const QString &got, const QString &expected)

{

    return QApplication::translate("QtResourceEditorDialog", "The file does not appear to be a resource file; element '%1' was found where '%2' was expected.").arg(got).arg(expected);

}

namespace {

// below 3 data classes should be derived from QSharedData and made implicit shared class

struct QtResourceFileData {

    QString path;

    QString alias;

    bool operator==(const QtResourceFileData &other) const {

        if (path == other.path && alias == other.alias)

            return true;

        return false;

    }

};

struct QtResourcePrefixData {

    QString prefix;

    QString language;

    QList<QtResourceFileData> resourceFileList;

    bool operator==(const QtResourcePrefixData &other) const {

        if (prefix == other.prefix && language == other.language && resourceFileList == other.resourceFileList)

            return true;

        return false;

    }

};

struct QtQrcFileData {

    QString qrcPath;

    QList<QtResourcePrefixData> resourceList;

    bool operator==(const QtQrcFileData &other) const {

        if (qrcPath == other.qrcPath && resourceList == other.resourceList)

            return true;

        return false;

    }

};

bool loadResourceFileData(const QDomElement &fileElem, QtResourceFileData *fileData, QString *errorMessage)

{

    if (!fileData)

        return false;

    if (fileElem.tagName() != QLatin1String(rccFileTag)) {

        *errorMessage = msgTagMismatch(fileElem.tagName(), QLatin1String(rccFileTag));

        return false;

    }

    QtResourceFileData &data = *fileData;

    data.path = fileElem.text();

    data.alias = fileElem.attribute(QLatin1String(rccAliasAttribute));

    return true;

}

static bool loadResourcePrefixData(const QDomElement &prefixElem, QtResourcePrefixData *prefixData, QString *errorMessage)

{

    if (!prefixData)

        return false;

    if (prefixElem.tagName() != QLatin1String(rccTag)) {

        *errorMessage = msgTagMismatch(prefixElem.tagName(), QLatin1String(rccTag));

        return false;

    }

    QtResourcePrefixData &data = *prefixData;

    data.prefix = prefixElem.attribute(QLatin1String(rccPrefixAttribute));

    data.language = prefixElem.attribute(QLatin1String(rccLangAttribute));

    QDomElement fileElem = prefixElem.firstChildElement();

    while (!fileElem.isNull()) {

        QtResourceFileData fileData;

        if (!loadResourceFileData(fileElem, &fileData, errorMessage))

            return false;

        data.resourceFileList.append(fileData);

        fileElem = fileElem.nextSiblingElement();

    }

    return true;

}

static bool loadQrcFileData(const QDomDocument &doc, const QString &path, QtQrcFileData *qrcFileData, QString *errorMessage)

{

    if (!qrcFileData)

        return false;

    QtQrcFileData &data = *qrcFileData;

    QDomElement docElem = doc.documentElement();

    if (docElem.tagName() != QLatin1String(rccRootTag)) {

        *errorMessage = msgTagMismatch(docElem.tagName(), QLatin1String(rccRootTag));

        return false;

    }

    QDomElement prefixElem = docElem.firstChildElement();

    while (!prefixElem.isNull()) {

        QtResourcePrefixData prefixData;

        if (!loadResourcePrefixData(prefixElem, &prefixData, errorMessage))

            return false;

        data.resourceList.append(prefixData);

        prefixElem = prefixElem.nextSiblingElement();

    }

    data.qrcPath = path;

    return true;

}

QDomElement saveResourceFileData(QDomDocument &doc, const QtResourceFileData &fileData)

{

    QDomElement fileElem = doc.createElement(QLatin1String(rccFileTag));

    if (!fileData.alias.isEmpty())

        fileElem.setAttribute(QLatin1String(rccAliasAttribute), fileData.alias);

    QDomText textElem = doc.createTextNode(fileData.path);

    fileElem.appendChild(textElem);

    return fileElem;

}

QDomElement saveResourcePrefixData(QDomDocument &doc, const QtResourcePrefixData &prefixData)

{

    QDomElement prefixElem = doc.createElement(QLatin1String(rccTag));

    if (!prefixData.prefix.isEmpty())

        prefixElem.setAttribute(QLatin1String(rccPrefixAttribute), prefixData.prefix);

    if (!prefixData.language.isEmpty())

        prefixElem.setAttribute(QLatin1String(rccLangAttribute), prefixData.language);

    QListIterator<QtResourceFileData> itFile(prefixData.resourceFileList);

    while (itFile.hasNext()) {

        QDomElement fileElem = saveResourceFileData(doc, itFile.next());

        prefixElem.appendChild(fileElem);

    }

    return prefixElem;

}

QDomDocument saveQrcFileData(const QtQrcFileData &qrcFileData)

{

    QDomDocument doc;

    QDomElement docElem = doc.createElement(QLatin1String(rccRootTag));

    QListIterator<QtResourcePrefixData> itPrefix(qrcFileData.resourceList);

    while (itPrefix.hasNext()) {

        QDomElement prefixElem = saveResourcePrefixData(doc, itPrefix.next());

        docElem.appendChild(prefixElem);

    }

    doc.appendChild(docElem);

    return doc;

}

// --------------- QtResourceFile

class QtResourceFile {

public:

    friend class QtQrcManager;

    QString path() const { return m_path; }

    QString alias() const { return m_alias; }

    QString fullPath() const { return m_fullPath; }

private:

    QtResourceFile() {}

    QString m_path;

    QString m_alias;

    QString m_fullPath;

};

class QtResourcePrefix {

public:

    friend class QtQrcManager;

    QString prefix() const { return m_prefix; }

    QString language() const { return m_language; }

    QList<QtResourceFile *> resourceFiles() const { return m_resourceFiles; }

private:

    QtResourcePrefix() {}

    QString m_prefix;

    QString m_language;

    QList<QtResourceFile *> m_resourceFiles;

};

// ------------------- QtQrcFile

class QtQrcFile {

public:

    friend class QtQrcManager;

    QString path() const { return m_path; }

    QString fileName() const { return m_fileName; }

    QList<QtResourcePrefix *> resourcePrefixList() const { return m_resourcePrefixes; }

    QtQrcFileData initialState() const { return m_initialState; }

private:

    QtQrcFile() { }

    void setPath(const QString &path) {

        m_path = path;

        QFileInfo fi(path);

        m_fileName = fi.fileName();

    }

    QString m_path;

    QString m_fileName;

    QList<QtResourcePrefix *> m_resourcePrefixes;

    QtQrcFileData m_initialState;

};

// ------------------ QtQrcManager

class QtQrcManager : public QObject

{

    Q_OBJECT

public:

    QtQrcManager(QObject *parent = 0);

    ~QtQrcManager();

    QList<QtQrcFile *> qrcFiles() const;

    // helpers

    QtQrcFile *qrcFileOf(const QString &path) const;

    QtQrcFile *qrcFileOf(QtResourcePrefix *resourcePrefix) const;

    QtQrcFile *qrcFileOf(QtResourceFile *resourceFile) const;

    QtResourcePrefix *resourcePrefixOf(QtResourceFile *resourceFile) const;

    QtQrcFile *importQrcFile(const QtQrcFileData &qrcFileData, QtQrcFile *beforeQrcFile = 0);

    void exportQrcFile(QtQrcFile *qrcFile, QtQrcFileData *qrcFileData) const;

    QList<QtResourceFile *> resourceFilesOf(const QString &resourceFullPath) const;

    QIcon icon(const QString &resourceFullPath) const;

    bool exists(const QString &resourceFullPath) const;

    bool exists(QtQrcFile *qrcFile) const;

    QtQrcFile *prevQrcFile(QtQrcFile *qrcFile) const;

    QtQrcFile *nextQrcFile(QtQrcFile *qrcFile) const;

    QtResourcePrefix *prevResourcePrefix(QtResourcePrefix *resourcePrefix) const;

    QtResourcePrefix *nextResourcePrefix(QtResourcePrefix *resourcePrefix) const;

    QtResourceFile *prevResourceFile(QtResourceFile *resourceFile) const;

    QtResourceFile *nextResourceFile(QtResourceFile *resourceFile) const;

    void clear();

public slots:

    QtQrcFile *insertQrcFile(const QString &path, QtQrcFile *beforeQrcFile = 0, bool newFile = false);

    void moveQrcFile(QtQrcFile *qrcFile, QtQrcFile *beforeQrcFile);

    void setInitialState(QtQrcFile *qrcFile, const QtQrcFileData &initialState);

    void removeQrcFile(QtQrcFile *qrcFile);

    QtResourcePrefix *insertResourcePrefix(QtQrcFile *qrcFile, const QString &prefix,

                    const QString &language, QtResourcePrefix *beforeResourcePrefix = 0);

    void moveResourcePrefix(QtResourcePrefix *resourcePrefix, QtResourcePrefix *beforeResourcePrefix); // the same qrc file???

    void changeResourcePrefix(QtResourcePrefix *resourcePrefix, const QString &newPrefix);

    void changeResourceLanguage(QtResourcePrefix *resourcePrefix, const QString &newLanguage);

    void removeResourcePrefix(QtResourcePrefix *resourcePrefix);

    QtResourceFile *insertResourceFile(QtResourcePrefix *resourcePrefix, const QString &path,

                    const QString &alias, QtResourceFile *beforeResourceFile = 0);

    void moveResourceFile(QtResourceFile *resourceFile, QtResourceFile *beforeResourceFile); // the same prefix???

    void changeResourceAlias(QtResourceFile *resourceFile, const QString &newAlias);

    void removeResourceFile(QtResourceFile *resourceFile);

signals:

    void qrcFileInserted(QtQrcFile *qrcFile);

    void qrcFileMoved(QtQrcFile *qrcFile, QtQrcFile *oldBeforeQrcFile);

    void qrcFileRemoved(QtQrcFile *qrcFile);

    void resourcePrefixInserted(QtResourcePrefix *resourcePrefix);

    void resourcePrefixMoved(QtResourcePrefix *resourcePrefix, QtResourcePrefix *oldBeforeResourcePrefix);

    void resourcePrefixChanged(QtResourcePrefix *resourcePrefix, const QString &oldPrefix);

    void resourceLanguageChanged(QtResourcePrefix *resourcePrefix, const QString &oldLanguage);

    void resourcePrefixRemoved(QtResourcePrefix *resourcePrefix);

    void resourceFileInserted(QtResourceFile *resourceFile);

    void resourceFileMoved(QtResourceFile *resourceFile, QtResourceFile *oldBeforeResourceFile);

    void resourceAliasChanged(QtResourceFile *resourceFile, const QString &oldAlias);

    void resourceFileRemoved(QtResourceFile *resourceFile);

private:

    QList<QtQrcFile *> m_qrcFiles;

    QMap<QString, QtQrcFile *> m_pathToQrc;

    QMap<QtQrcFile *, bool> m_qrcFileToExists;

    QMap<QtResourcePrefix *, QtQrcFile *> m_prefixToQrc;

    QMap<QtResourceFile *, QtResourcePrefix *> m_fileToPrefix;

    QMap<QString, QList<QtResourceFile *> > m_fullPathToResourceFiles;

    QMap<QString, QIcon> m_fullPathToIcon;

    QMap<QString, bool> m_fullPathToExists;

};

QtQrcManager::QtQrcManager(QObject *parent)

    : QObject(parent)

{

}

QtQrcManager::~QtQrcManager()

{

    clear();

}

QList<QtQrcFile *> QtQrcManager::qrcFiles() const

{

    return m_qrcFiles;

}

QtQrcFile *QtQrcManager::qrcFileOf(const QString &path) const

{

    return m_pathToQrc.value(path);

}

QtQrcFile *QtQrcManager::qrcFileOf(QtResourcePrefix *resourcePrefix) const

{

    return m_prefixToQrc.value(resourcePrefix);

}

QtQrcFile *QtQrcManager::qrcFileOf(QtResourceFile *resourceFile) const

{

    return qrcFileOf(resourcePrefixOf(resourceFile));

}

QtResourcePrefix *QtQrcManager::resourcePrefixOf(QtResourceFile *resourceFile) const

{

    return m_fileToPrefix.value(resourceFile);

}

QtQrcFile *QtQrcManager::importQrcFile(const QtQrcFileData &qrcFileData, QtQrcFile *beforeQrcFile)

{

    QtQrcFile *qrcFile = insertQrcFile(qrcFileData.qrcPath, beforeQrcFile);

    if (!qrcFile)

        return 0;

    QListIterator<QtResourcePrefixData> itPrefix(qrcFileData.resourceList);

    while (itPrefix.hasNext()) {

        const QtResourcePrefixData &prefixData = itPrefix.next();

        QtResourcePrefix *resourcePrefix = insertResourcePrefix(qrcFile, prefixData.prefix, prefixData.language, 0);

        QListIterator<QtResourceFileData> itFile(prefixData.resourceFileList);

        while (itFile.hasNext()) {

            const QtResourceFileData &fileData = itFile.next();

            insertResourceFile(resourcePrefix, fileData.path, fileData.alias, 0);

        }

    }

    setInitialState(qrcFile, qrcFileData);

    return qrcFile;

}

void QtQrcManager::exportQrcFile(QtQrcFile *qrcFile, QtQrcFileData *qrcFileData) const

{

    if (!qrcFileData)

        return;

    if (!qrcFile)

        return;

    QtQrcFileData &data = *qrcFileData;

    QList<QtResourcePrefixData> resourceList;

    QList<QtResourcePrefix *> resourcePrefixes = qrcFile->resourcePrefixList();

    QListIterator<QtResourcePrefix *> itPrefix(resourcePrefixes);

    while (itPrefix.hasNext()) {

        QList<QtResourceFileData> resourceFileList;

        QtResourcePrefix *prefix = itPrefix.next();

        QList<QtResourceFile *> resourceFiles = prefix->resourceFiles();

        QListIterator<QtResourceFile *> itFile(resourceFiles);

        while (itFile.hasNext()) {

            QtResourceFile *file = itFile.next();

            QtResourceFileData fileData;

            fileData.path = file->path();

            fileData.alias = file->alias();

            resourceFileList << fileData;

        }

        QtResourcePrefixData prefixData;

        prefixData.prefix = prefix->prefix();

        prefixData.language = prefix->language();

        prefixData.resourceFileList = resourceFileList;

        resourceList << prefixData;

    }

    data = QtQrcFileData();

    data.qrcPath = qrcFile->path();

    data.resourceList = resourceList;

}

QList<QtResourceFile *> QtQrcManager::resourceFilesOf(const QString &resourcePath) const

{

    return m_fullPathToResourceFiles.value(resourcePath);

}

QIcon QtQrcManager::icon(const QString &resourceFullPath) const

{

    return m_fullPathToIcon.value(resourceFullPath);

}

bool QtQrcManager::exists(const QString &resourceFullPath) const

{

    return m_fullPathToExists.value(resourceFullPath, false);

}

bool QtQrcManager::exists(QtQrcFile *qrcFile) const

{

    return m_qrcFileToExists.value(qrcFile, false);

}

QtQrcFile *QtQrcManager::prevQrcFile(QtQrcFile *qrcFile) const

{

    if (!qrcFile)

        return 0;

    const int idx = m_qrcFiles.indexOf(qrcFile);

    if (idx <= 0)

        return 0;

    return m_qrcFiles.at(idx - 1);

}

QtQrcFile *QtQrcManager::nextQrcFile(QtQrcFile *qrcFile) const

{

    if (!qrcFile)

        return 0;

    const int idx = m_qrcFiles.indexOf(qrcFile);

    if (idx < 0 || idx == m_qrcFiles.size() - 1)

        return 0;

    return m_qrcFiles.at(idx + 1);

}

QtResourcePrefix *QtQrcManager::prevResourcePrefix(QtResourcePrefix *resourcePrefix) const

{

    if (!resourcePrefix)

        return 0;

    QList<QtResourcePrefix *> prefixes = qrcFileOf(resourcePrefix)->resourcePrefixList();

    const int idx = prefixes.indexOf(resourcePrefix);

    if (idx <= 0)

        return 0;

    return prefixes.at(idx - 1);

}

QtResourcePrefix *QtQrcManager::nextResourcePrefix(QtResourcePrefix *resourcePrefix) const

{

    if (!resourcePrefix)

        return 0;

    QList<QtResourcePrefix *> prefixes = qrcFileOf(resourcePrefix)->resourcePrefixList();

    const int idx = prefixes.indexOf(resourcePrefix);

    if (idx < 0 || idx == prefixes.size() - 1)

        return 0;

    return prefixes.at(idx + 1);

}

QtResourceFile *QtQrcManager::prevResourceFile(QtResourceFile *resourceFile) const

{

    if (!resourceFile)

        return 0;

    QList<QtResourceFile *> files = resourcePrefixOf(resourceFile)->resourceFiles();