1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the Qt Designer of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "abstractsettings_p.h"

    43 #include "abstractformeditor.h"

    44 #include "qtresourceeditordialog_p.h"

    45 #include "ui_qtresourceeditordialog.h"

    46 #include "qtresourcemodel_p.h"

    47 #include "iconloader_p.h"

    48 

    49 #include <abstractdialoggui_p.h>

    50 

    51 #include <QtCore/QFileInfo>

    52 #include <QtCore/QDir>

    53 #include <QtCore/QCoreApplication>

    54 #include <QtXml/QDomDocument>

    55 #include <QtGui/QMenu>

    56 #include <QtGui/QHeaderView>

    57 #include <QtGui/QInputDialog>

    58 #include <QtGui/QMessageBox>

    59 #include <QtGui/QPushButton>

    60 #include <QtGui/QStandardItemModel>

    61 

    62 QT_BEGIN_NAMESPACE

    63 

    64 static const char *rccRootTag = "RCC";

    65 static const char *rccTag = "qresource";

    66 static const char *rccFileTag = "file";

    67 static const char *rccAliasAttribute = "alias";

    68 static const char *rccPrefixAttribute = "prefix";

    69 static const char *rccLangAttribute = "lang";

    70 static const char *SplitterPosition = "SplitterPosition";

    71 static const char *Geometry = "Geometry";

    72 static const char *QrcDialogC = "QrcDialog";

    73 

    74 static QString msgOverwrite(const QString &fname)

    75 {

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

    77 }

    78 

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

    80 {

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

    82 }

    83 

    84 namespace {

    85 

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

    87 struct QtResourceFileData {

    88     QString path;

    89     QString alias;

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

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

    92             return true;

    93         return false;

    94     }

    95 };

    96 

    97 struct QtResourcePrefixData {

    98     QString prefix;

    99     QString language;

   100     QList<QtResourceFileData> resourceFileList;

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

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

   103             return true;

   104         return false;

   105     }

   106 };

   107 

   108 struct QtQrcFileData {

   109     QString qrcPath;

   110     QList<QtResourcePrefixData> resourceList;

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

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

   113             return true;

   114         return false;

   115     }

   116 };

   117 

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

   119 {

   120     if (!fileData)

   121         return false;

   122 

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

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

   125         return false;

   126     }

   127 

   128     QtResourceFileData &data = *fileData;

   129 

   130     data.path = fileElem.text();

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

   132 

   133     return true;

   134 }

   135 

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

   137 {

   138     if (!prefixData)

   139         return false;

   140 

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

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

   143         return false;

   144     }

   145 

   146     QtResourcePrefixData &data = *prefixData;

   147 

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

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

   150     QDomElement fileElem = prefixElem.firstChildElement();

   151     while (!fileElem.isNull()) {

   152         QtResourceFileData fileData;

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

   154             return false;

   155         data.resourceFileList.append(fileData);

   156         fileElem = fileElem.nextSiblingElement();

   157     }

   158     return true;

   159 }

   160 

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

   162 {

   163     if (!qrcFileData)

   164         return false;

   165 

   166     QtQrcFileData &data = *qrcFileData;

   167 

   168     QDomElement docElem = doc.documentElement();

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

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

   171         return false;

   172     }

   173 

   174     QDomElement prefixElem = docElem.firstChildElement();

   175     while (!prefixElem.isNull()) {

   176         QtResourcePrefixData prefixData;

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

   178             return false;

   179         data.resourceList.append(prefixData);

   180         prefixElem = prefixElem.nextSiblingElement();

   181     }

   182 

   183     data.qrcPath = path;

   184 

   185     return true;

   186 }

   187 

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

   189 {

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

   191     if (!fileData.alias.isEmpty())

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

   193 

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

   195     fileElem.appendChild(textElem);

   196 

   197     return fileElem;

   198 }

   199 

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

   201 {

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

   203     if (!prefixData.prefix.isEmpty())

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

   205     if (!prefixData.language.isEmpty())

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

   207 

   208     QListIterator<QtResourceFileData> itFile(prefixData.resourceFileList);

   209     while (itFile.hasNext()) {

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

   211         prefixElem.appendChild(fileElem);

   212     }

   213 

   214     return prefixElem;

   215 }

   216 

   217 QDomDocument saveQrcFileData(const QtQrcFileData &qrcFileData)

   218 {

   219     QDomDocument doc;

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

   221     QListIterator<QtResourcePrefixData> itPrefix(qrcFileData.resourceList);

   222     while (itPrefix.hasNext()) {

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

   224 

   225         docElem.appendChild(prefixElem);

   226     }

   227     doc.appendChild(docElem);

   228 

   229     return doc;

   230 }

   231 // --------------- QtResourceFile

   232 class QtResourceFile {

   233 public:

   234     friend class QtQrcManager;

   235 

   236     QString path() const { return m_path; }

   237     QString alias() const { return m_alias; }

   238     QString fullPath() const { return m_fullPath; }

   239 private:

   240     QtResourceFile() {}

   241 

   242     QString m_path;

   243     QString m_alias;

   244     QString m_fullPath;

   245 };

   246 

   247 class QtResourcePrefix {

   248 public:

   249     friend class QtQrcManager;

   250 

   251     QString prefix() const { return m_prefix; }

   252     QString language() const { return m_language; }

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

   254 private:

   255     QtResourcePrefix() {}

   256 

   257     QString m_prefix;

   258     QString m_language;

   259     QList<QtResourceFile *> m_resourceFiles;

   260 

   261 };

   262 // ------------------- QtQrcFile

   263 class QtQrcFile {

   264 public:

   265     friend class QtQrcManager;

   266 

   267     QString path() const { return m_path; }

   268     QString fileName() const { return m_fileName; }

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

   270     QtQrcFileData initialState() const { return m_initialState; }

   271 

   272 private:

   273     QtQrcFile() { }

   274 

   275     void setPath(const QString &path) {

   276         m_path = path;

   277         QFileInfo fi(path);

   278         m_fileName = fi.fileName();

   279     }

   280 

   281     QString m_path;

   282     QString m_fileName;

   283     QList<QtResourcePrefix *> m_resourcePrefixes;

   284     QtQrcFileData m_initialState;

   285 };

   286 

   287 // ------------------ QtQrcManager

   288 class QtQrcManager : public QObject

   289 {

   290     Q_OBJECT

   291 public:

   292     QtQrcManager(QObject *parent = 0);

   293     ~QtQrcManager();

   294 

   295     QList<QtQrcFile *> qrcFiles() const;

   296 

   297     // helpers

   298     QtQrcFile *qrcFileOf(const QString &path) const;

   299     QtQrcFile *qrcFileOf(QtResourcePrefix *resourcePrefix) const;

   300     QtQrcFile *qrcFileOf(QtResourceFile *resourceFile) const;

   301     QtResourcePrefix *resourcePrefixOf(QtResourceFile *resourceFile) const;

   302 

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

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

   305 

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

   307     QIcon icon(const QString &resourceFullPath) const;

   308     bool exists(const QString &resourceFullPath) const;

   309     bool exists(QtQrcFile *qrcFile) const;

   310 

   311     QtQrcFile *prevQrcFile(QtQrcFile *qrcFile) const;

   312     QtQrcFile *nextQrcFile(QtQrcFile *qrcFile) const;

   313     QtResourcePrefix *prevResourcePrefix(QtResourcePrefix *resourcePrefix) const;

   314     QtResourcePrefix *nextResourcePrefix(QtResourcePrefix *resourcePrefix) const;

   315     QtResourceFile *prevResourceFile(QtResourceFile *resourceFile) const;

   316     QtResourceFile *nextResourceFile(QtResourceFile *resourceFile) const;

   317 

   318     void clear();

   319 

   320 public slots:

   321 

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

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

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

   325     void removeQrcFile(QtQrcFile *qrcFile);

   326 

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

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

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

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

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

   332     void removeResourcePrefix(QtResourcePrefix *resourcePrefix);

   333 

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

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

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

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

   338     void removeResourceFile(QtResourceFile *resourceFile);

   339 

   340 signals:

   341     void qrcFileInserted(QtQrcFile *qrcFile);

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

   343     void qrcFileRemoved(QtQrcFile *qrcFile);

   344 

   345     void resourcePrefixInserted(QtResourcePrefix *resourcePrefix);

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

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

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

   349     void resourcePrefixRemoved(QtResourcePrefix *resourcePrefix);

   350 

   351     void resourceFileInserted(QtResourceFile *resourceFile);

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

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

   354     void resourceFileRemoved(QtResourceFile *resourceFile);

   355 private:

   356 

   357     QList<QtQrcFile *> m_qrcFiles;

   358     QMap<QString, QtQrcFile *> m_pathToQrc;

   359     QMap<QtQrcFile *, bool> m_qrcFileToExists;

   360     QMap<QtResourcePrefix *, QtQrcFile *> m_prefixToQrc;

   361     QMap<QtResourceFile *, QtResourcePrefix *> m_fileToPrefix;

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

   363     QMap<QString, QIcon> m_fullPathToIcon;

   364     QMap<QString, bool> m_fullPathToExists;

   365 };

   366 

   367 QtQrcManager::QtQrcManager(QObject *parent)

   368     : QObject(parent)

   369 {

   370 

   371 }

   372 

   373 QtQrcManager::~QtQrcManager()

   374 {

   375     clear();

   376 }

   377 

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

   379 {

   380     return m_qrcFiles;

   381 }

   382 

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

   384 {

   385     return m_pathToQrc.value(path);

   386 }

   387 

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

   389 {

   390     return m_prefixToQrc.value(resourcePrefix);

   391 }

   392 

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

   394 {

   395     return qrcFileOf(resourcePrefixOf(resourceFile));

   396 }

   397 

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

   399 {

   400     return m_fileToPrefix.value(resourceFile);

   401 }

   402 

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

   404 {

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

   406     if (!qrcFile)

   407         return 0;

   408     QListIterator<QtResourcePrefixData> itPrefix(qrcFileData.resourceList);

   409     while (itPrefix.hasNext()) {

   410         const QtResourcePrefixData &prefixData = itPrefix.next();

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

   412         QListIterator<QtResourceFileData> itFile(prefixData.resourceFileList);

   413         while (itFile.hasNext()) {

   414             const QtResourceFileData &fileData = itFile.next();

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

   416         }

   417     }

   418     setInitialState(qrcFile, qrcFileData);

   419     return qrcFile;

   420 }

   421 

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

   423 {

   424     if (!qrcFileData)

   425         return;

   426 

   427     if (!qrcFile)

   428         return;

   429 

   430     QtQrcFileData &data = *qrcFileData;

   431 

   432     QList<QtResourcePrefixData> resourceList;

   433 

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

   435     QListIterator<QtResourcePrefix *> itPrefix(resourcePrefixes);

   436     while (itPrefix.hasNext()) {

   437         QList<QtResourceFileData> resourceFileList;

   438 

   439         QtResourcePrefix *prefix = itPrefix.next();

   440 

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

   442         QListIterator<QtResourceFile *> itFile(resourceFiles);

   443         while (itFile.hasNext()) {

   444             QtResourceFile *file = itFile.next();

   445             QtResourceFileData fileData;

   446             fileData.path = file->path();

   447             fileData.alias = file->alias();

   448             resourceFileList << fileData;

   449         }

   450         QtResourcePrefixData prefixData;

   451         prefixData.prefix = prefix->prefix();

   452         prefixData.language = prefix->language();

   453         prefixData.resourceFileList = resourceFileList;

   454 

   455         resourceList << prefixData;

   456     }

   457     data = QtQrcFileData();

   458     data.qrcPath = qrcFile->path();

   459     data.resourceList = resourceList;

   460 }

   461 

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

   463 {

   464     return m_fullPathToResourceFiles.value(resourcePath);

   465 }

   466 

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

   468 {

   469     return m_fullPathToIcon.value(resourceFullPath);

   470 }

   471 

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

   473 {

   474     return m_fullPathToExists.value(resourceFullPath, false);

   475 }

   476 

   477 bool QtQrcManager::exists(QtQrcFile *qrcFile) const

   478 {

   479     return m_qrcFileToExists.value(qrcFile, false);

   480 }

   481 

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

   483 {

   484     if (!qrcFile)

   485         return 0;

   486     const int idx = m_qrcFiles.indexOf(qrcFile);

   487     if (idx <= 0)

   488         return 0;

   489     return m_qrcFiles.at(idx - 1);

   490 }

   491 

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

   493 {

   494     if (!qrcFile)

   495         return 0;

   496     const int idx = m_qrcFiles.indexOf(qrcFile);

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

   498         return 0;

   499     return m_qrcFiles.at(idx + 1);

   500 }

   501 

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

   503 {

   504     if (!resourcePrefix)

   505         return 0;

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

   507     const int idx = prefixes.indexOf(resourcePrefix);

   508     if (idx <= 0)

   509         return 0;

   510     return prefixes.at(idx - 1);

   511 }

   512 

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

   514 {

   515     if (!resourcePrefix)

   516         return 0;

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

   518     const int idx = prefixes.indexOf(resourcePrefix);

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

   520         return 0;

   521     return prefixes.at(idx + 1);

   522 }

   523 

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

   525 {

   526     if (!resourceFile)

   527         return 0;

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

   529     const int idx = files.indexOf(resourceFile);

   530     if (idx <= 0)

   531         return 0;

   532     return files.at(idx - 1);

   533 }

   534 

   535 QtResourceFile *QtQrcManager::nextResourceFile(QtResourceFile *resourceFile) const

   536 {

   537     if (!resourceFile)

   538         return 0;

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

   540     const int idx = files.indexOf(resourceFile);

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

   542         return 0;

   543     return files.at(idx + 1);

   544 }

   545 

   546 void QtQrcManager::clear()

   547 {

   548     QList<QtQrcFile *> oldQrcFiles = qrcFiles();

   549     QListIterator<QtQrcFile *> it(oldQrcFiles);

   550     while (it.hasNext())

   551         removeQrcFile(it.next());

   552 }

   553 

   554 QtQrcFile *QtQrcManager::insertQrcFile(const QString &path, QtQrcFile *beforeQrcFile, bool newFile)

   555 {

   556     if (m_pathToQrc.contains(path))

   557         return 0;

   558 

   559     int idx = m_qrcFiles.indexOf(beforeQrcFile);

   560     if (idx < 0)

   561         idx = m_qrcFiles.size();

   562 

   563     QtQrcFile *qrcFile = new QtQrcFile();

   564     qrcFile->setPath(path);

   565 

   566     m_qrcFiles.insert(idx, qrcFile);

   567     m_pathToQrc[path] = qrcFile;

   568 

   569     const QFileInfo fi(path);

   570     m_qrcFileToExists[qrcFile] = fi.exists() || newFile;

   571 

   572     emit qrcFileInserted(qrcFile);

   573     return qrcFile;

   574 }

   575 

   576 void QtQrcManager::moveQrcFile(QtQrcFile *qrcFile, QtQrcFile *beforeQrcFile)

   577 {

   578     if (qrcFile == beforeQrcFile)

   579         return;

   580 

   581     const int idx = m_qrcFiles.indexOf(qrcFile);

   582     if (idx < 0)

   583         return;

   584 

   585     int beforeIdx = m_qrcFiles.indexOf(beforeQrcFile);

   586     if (beforeIdx < 0)

   587         beforeIdx = m_qrcFiles.size();

   588 

   589     if (idx == beforeIdx - 1) // the same position, nothing changes

   590         return;

   591 

   592     QtQrcFile *oldBefore = 0;

   593     if (idx < m_qrcFiles.size() - 1)

   594         oldBefore = m_qrcFiles.at(idx + 1);

   595 

   596     m_qrcFiles.removeAt(idx);

   597     if (idx < beforeIdx)

   598         beforeIdx -= 1;

   599 

   600     m_qrcFiles.insert(beforeIdx, qrcFile);

   601 

   602     emit qrcFileMoved(qrcFile, oldBefore);

   603 }

   604 

   605 void QtQrcManager::setInitialState(QtQrcFile *qrcFile, const QtQrcFileData &initialState)

   606 {

   607     qrcFile->m_initialState = initialState;

   608 }

   609 

   610 void QtQrcManager::removeQrcFile(QtQrcFile *qrcFile)

   611 {

   612     const int idx = m_qrcFiles.indexOf(qrcFile);

   613     if (idx < 0)

   614         return;

   615 

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

   617     QListIterator<QtResourcePrefix *> it(resourcePrefixes);

   618     while (it.hasNext())

   619         removeResourcePrefix(it.next());

   620 

   621     emit qrcFileRemoved(qrcFile);

   622 

   623     m_qrcFiles.removeAt(idx);

   624     m_pathToQrc.remove(qrcFile->path());

   625     m_qrcFileToExists.remove(qrcFile);

   626     delete qrcFile;

   627 }

   628 

   629 QtResourcePrefix *QtQrcManager::insertResourcePrefix(QtQrcFile *qrcFile, const QString &prefix,

   630         const QString &language, QtResourcePrefix *beforeResourcePrefix)

   631 {

   632     if (!qrcFile)

   633         return 0;

   634 

   635     int idx = qrcFile->m_resourcePrefixes.indexOf(beforeResourcePrefix);

   636     if (idx < 0)

   637         idx = qrcFile->m_resourcePrefixes.size();

   638 

   639     QtResourcePrefix *resourcePrefix = new QtResourcePrefix();

   640     resourcePrefix->m_prefix = prefix;

   641     resourcePrefix->m_language = language;

   642 

   643     qrcFile->m_resourcePrefixes.insert(idx, resourcePrefix);

   644     m_prefixToQrc[resourcePrefix] = qrcFile;

   645 

   646     emit resourcePrefixInserted(resourcePrefix);

   647     return resourcePrefix;

   648 }

   649 

   650 void QtQrcManager::moveResourcePrefix(QtResourcePrefix *resourcePrefix, QtResourcePrefix *beforeResourcePrefix)

   651 {

   652     if (resourcePrefix == beforeResourcePrefix)

   653         return;

   654 

   655     QtQrcFile *qrcFile = qrcFileOf(resourcePrefix);

   656     if (!qrcFile)

   657         return;

   658 

   659     if (beforeResourcePrefix && qrcFileOf(beforeResourcePrefix) != qrcFile)

   660         return;

   661 

   662     const int idx = qrcFile->m_resourcePrefixes.indexOf(resourcePrefix);

   663 

   664     int beforeIdx = qrcFile->m_resourcePrefixes.indexOf(beforeResourcePrefix);

   665     if (beforeIdx < 0)

   666         beforeIdx = qrcFile->m_resourcePrefixes.size();

   667 

   668     if (idx == beforeIdx - 1) // the same position, nothing changes

   669         return;

   670 

   671     QtResourcePrefix *oldBefore = 0;

   672     if (idx < qrcFile->m_resourcePrefixes.size() - 1)

   673         oldBefore = qrcFile->m_resourcePrefixes.at(idx + 1);

   674 

   675     qrcFile->m_resourcePrefixes.removeAt(idx);

   676     if (idx < beforeIdx)

   677         beforeIdx -= 1;

   678 

   679     qrcFile->m_resourcePrefixes.insert(beforeIdx, resourcePrefix);

   680 

   681     emit resourcePrefixMoved(resourcePrefix, oldBefore);

   682 }

   683 

   684 void QtQrcManager::changeResourcePrefix(QtResourcePrefix *resourcePrefix, const QString &newPrefix)

   685 {

   686     if (!resourcePrefix)

   687         return;

   688 

   689     const QString oldPrefix = resourcePrefix->m_prefix;

   690     if (oldPrefix == newPrefix)

   691         return;

   692 

   693     resourcePrefix->m_prefix = newPrefix;

   694 

   695     emit resourcePrefixChanged(resourcePrefix, oldPrefix);

   696 }

   697 

   698 void QtQrcManager::changeResourceLanguage(QtResourcePrefix *resourcePrefix, const QString &newLanguage)

   699 {

   700     if (!resourcePrefix)

   701         return;

   702 

   703     const QString oldLanguage = resourcePrefix->m_language;

   704     if (oldLanguage == newLanguage)

   705         return;

   706 

   707     resourcePrefix->m_language = newLanguage;

   708 

   709     emit resourceLanguageChanged(resourcePrefix, oldLanguage);

   710 }

   711 

   712 void QtQrcManager::removeResourcePrefix(QtResourcePrefix *resourcePrefix)

   713 {

   714     QtQrcFile *qrcFile = qrcFileOf(resourcePrefix);

   715     if (!qrcFile)

   716         return;

   717 

   718     const int idx = qrcFile->m_resourcePrefixes.indexOf(resourcePrefix);

   719 

   720     QList<QtResourceFile *> resourceFiles = resourcePrefix->resourceFiles();

   721     QListIterator<QtResourceFile *> it(resourceFiles);

   722     while (it.hasNext())

   723         removeResourceFile(it.next());

   724 

   725     emit resourcePrefixRemoved(resourcePrefix);

   726 

   727     qrcFile->m_resourcePrefixes.removeAt(idx);

   728     m_prefixToQrc.remove(resourcePrefix);

   729     delete resourcePrefix;

   730 }

   731 

   732 QtResourceFile *QtQrcManager::insertResourceFile(QtResourcePrefix *resourcePrefix, const QString &path,

   733         const QString &alias, QtResourceFile *beforeResourceFile)

   734 {

   735     if (!resourcePrefix)

   736         return 0;

   737 

   738     int idx = resourcePrefix->m_resourceFiles.indexOf(beforeResourceFile);

   739     if (idx < 0)

   740         idx = resourcePrefix->m_resourceFiles.size();

   741 

   742     QtResourceFile *resourceFile = new QtResourceFile();

   743     resourceFile->m_path = path;

   744     resourceFile->m_alias = alias;

   745     const QFileInfo fi(qrcFileOf(resourcePrefix)->path());

   746     const QDir dir(fi.absolutePath());

   747     const QString fullPath = dir.absoluteFilePath(path);

   748     resourceFile->m_fullPath = fullPath;

   749 

   750     resourcePrefix->m_resourceFiles.insert(idx, resourceFile);

   751     m_fileToPrefix[resourceFile] = resourcePrefix;

   752     m_fullPathToResourceFiles[fullPath].append(resourceFile);

   753     if (!m_fullPathToIcon.contains(fullPath)) {

   754         m_fullPathToIcon[fullPath] = QIcon(fullPath);

   755         const QFileInfo fullInfo(fullPath);

   756         m_fullPathToExists[fullPath] = fullInfo.exists();

   757     }

   758 

   759     emit resourceFileInserted(resourceFile);

   760     return resourceFile;

   761 }

   762 

   763 void QtQrcManager::moveResourceFile(QtResourceFile *resourceFile, QtResourceFile *beforeResourceFile)

   764 {

   765     if (resourceFile == beforeResourceFile)

   766         return;

   767 

   768     QtResourcePrefix *resourcePrefix = resourcePrefixOf(resourceFile);

   769     if (!resourcePrefix)

   770         return;

   771 

   772     if (beforeResourceFile && resourcePrefixOf(beforeResourceFile) != resourcePrefix)

   773         return;

   774 

   775     const int idx = resourcePrefix->m_resourceFiles.indexOf(resourceFile);

   776 

   777     int beforeIdx = resourcePrefix->m_resourceFiles.indexOf(beforeResourceFile);

   778     if (beforeIdx < 0)

   779         beforeIdx = resourcePrefix->m_resourceFiles.size();

   780 

   781     if (idx == beforeIdx - 1) // the same position, nothing changes

   782         return;

   783 

   784     QtResourceFile *oldBefore = 0;

   785     if (idx < resourcePrefix->m_resourceFiles.size() - 1)

   786         oldBefore = resourcePrefix->m_resourceFiles.at(idx + 1);

   787 

   788     resourcePrefix->m_resourceFiles.removeAt(idx);

   789     if (idx < beforeIdx)

   790         beforeIdx -= 1;

   791 

   792     resourcePrefix->m_resourceFiles.insert(beforeIdx, resourceFile);

   793 

   794     emit resourceFileMoved(resourceFile, oldBefore);

   795 }

   796 

   797 void QtQrcManager::changeResourceAlias(QtResourceFile *resourceFile, const QString &newAlias)

   798 {

   799     if (!resourceFile)

   800         return;

   801 

   802     const QString oldAlias = resourceFile->m_alias;

   803     if (oldAlias == newAlias)

   804         return;

   805 

   806     resourceFile->m_alias = newAlias;

   807 

   808     emit resourceAliasChanged(resourceFile, oldAlias);

   809 }

   810 

   811 void QtQrcManager::removeResourceFile(QtResourceFile *resourceFile)

   812 {

   813     QtResourcePrefix *resourcePrefix = resourcePrefixOf(resourceFile);

   814     if (!resourcePrefix)

   815         return;

   816 

   817     const int idx = resourcePrefix->m_resourceFiles.indexOf(resourceFile);

   818 

   819     emit resourceFileRemoved(resourceFile);

   820 

   821     resourcePrefix->m_resourceFiles.removeAt(idx);

   822     m_fileToPrefix.remove(resourceFile);

   823     const QString fullPath = resourceFile->fullPath();

   824     m_fullPathToResourceFiles[fullPath].removeAll(resourceFile); // optimize me

   825     if (m_fullPathToResourceFiles[fullPath].isEmpty()) {

   826         m_fullPathToResourceFiles.remove(fullPath);

   827         m_fullPathToIcon.remove(fullPath);

   828         m_fullPathToExists.remove(fullPath);

   829     }

   830     delete resourceFile;

   831 }

   832 

   833 

   834 

   835 }

   836 

   837 // ----------------- QtResourceEditorDialogPrivate

   838 class QtResourceEditorDialogPrivate

   839 {

   840     QtResourceEditorDialog *q_ptr;

   841     Q_DECLARE_PUBLIC(QtResourceEditorDialog)

   842 public:

   843     QtResourceEditorDialogPrivate();

   844 

   845     void slotQrcFileInserted(QtQrcFile *qrcFile);

   846     void slotQrcFileMoved(QtQrcFile *qrcFile);

   847     void slotQrcFileRemoved(QtQrcFile *qrcFile);

   848 

   849     QStandardItem *insertResourcePrefix(QtResourcePrefix *resourcePrefix);

   850 

   851     void slotResourcePrefixInserted(QtResourcePrefix *resourcePrefix) { insertResourcePrefix(resourcePrefix); }

   852     void slotResourcePrefixMoved(QtResourcePrefix *resourcePrefix);

   853     void slotResourcePrefixChanged(QtResourcePrefix *resourcePrefix);

   854     void slotResourceLanguageChanged(QtResourcePrefix *resourcePrefix);

   855     void slotResourcePrefixRemoved(QtResourcePrefix *resourcePrefix);

   856     void slotResourceFileInserted(QtResourceFile *resourceFile);

   857     void slotResourceFileMoved(QtResourceFile *resourceFile);

   858     void slotResourceAliasChanged(QtResourceFile *resourceFile);

   859     void slotResourceFileRemoved(QtResourceFile *resourceFile);

   860 

   861     void slotCurrentQrcFileChanged(QListWidgetItem *item);

   862     void slotCurrentTreeViewItemChanged(const QModelIndex &index);

   863     void slotListWidgetContextMenuRequested(const QPoint &pos);

   864     void slotTreeViewContextMenuRequested(const QPoint &pos);

   865     void slotTreeViewItemChanged(QStandardItem *item);

   866 

   867     void slotNewQrcFile();

   868     void slotImportQrcFile();

   869     void slotRemoveQrcFile();

   870     void slotMoveUpQrcFile();

   871     void slotMoveDownQrcFile();

   872 

   873     void slotNewPrefix();

   874     void slotAddFiles();

   875     void slotChangePrefix();

   876     void slotChangeLanguage();

   877     void slotChangeAlias();

   878     void slotClonePrefix();

   879     void slotRemove();

   880     void slotMoveUp();

   881     void slotMoveDown();

   882 

   883     bool loadQrcFile(const QString &path, QtQrcFileData *qrcFileData, QString *errorMessage);

   884     bool loadQrcFile(const QString &path, QtQrcFileData *qrcFileData);

   885     bool saveQrcFile(const QtQrcFileData &qrcFileData);

   886 

   887     QString qrcFileText(QtQrcFile *qrcFile) const;

   888 

   889     QMessageBox::StandardButton warning(const QString &title, const QString &text, QMessageBox::StandardButtons buttons = QMessageBox::Ok,

   890                                         QMessageBox::StandardButton defaultButton = QMessageBox::NoButton) const;

   891 

   892     QString browseForNewLocation(const QString &resourceFile, const QDir &rootDir) const;

   893     QString copyResourceFile(const QString &resourceFile, const QString &destPath) const;

   894     QtResourceFile *getCurrentResourceFile() const;

   895     QtResourcePrefix *getCurrentResourcePrefix() const;

   896     void selectTreeRow(QStandardItem *item);

   897     QString getSaveFileNameWithExtension(QWidget *parent,

   898             const QString &title, QString dir, const QString &filter, const QString &extension) const;

   899     QString qrcStartDirectory() const;

   900 

   901     Ui::QtResourceEditorDialog m_ui;

   902     QDesignerFormEditorInterface *m_core;

   903     QtResourceModel *m_resourceModel;

   904     QDesignerDialogGuiInterface *m_dlgGui;

   905     QtQrcManager *m_qrcManager;

   906     QList<QtQrcFileData> m_initialState;

   907 

   908     QMap<QtQrcFile *, QListWidgetItem *> m_qrcFileToItem;

   909     QMap<QListWidgetItem *, QtQrcFile *> m_itemToQrcFile;

   910     QMap<QtResourcePrefix *, QStandardItem *> m_resourcePrefixToPrefixItem;

   911     QMap<QtResourcePrefix *, QStandardItem *> m_resourcePrefixToLanguageItem;

   912     QMap<QStandardItem *, QtResourcePrefix *> m_prefixItemToResourcePrefix;

   913     QMap<QStandardItem *, QtResourcePrefix *> m_languageItemToResourcePrefix;

   914     QMap<QtResourceFile *, QStandardItem *> m_resourceFileToPathItem;

   915     QMap<QtResourceFile *, QStandardItem *> m_resourceFileToAliasItem;

   916     QMap<QStandardItem *, QtResourceFile *> m_pathItemToResourceFile;

   917     QMap<QStandardItem *, QtResourceFile *> m_aliasItemToResourceFile;

   918 

   919     bool m_ignoreCurrentChanged;

   920     bool m_firstQrcFileDialog;

   921     QtQrcFile *m_currentQrcFile;

   922 

   923     QAction *m_newQrcFileAction;

   924     QAction *m_importQrcFileAction;

   925     QAction *m_removeQrcFileAction;

   926     QAction *m_moveUpQrcFileAction;

   927     QAction *m_moveDownQrcFileAction;

   928 

   929     QAction *m_newPrefixAction;

   930     QAction *m_addResourceFileAction;

   931     QAction *m_changePrefixAction;

   932     QAction *m_changeLanguageAction;

   933     QAction *m_changeAliasAction;

   934     QAction *m_clonePrefixAction;

   935     QAction *m_moveUpAction;

   936     QAction *m_moveDownAction;

   937     QAction *m_removeAction;

   938 

   939     QStandardItemModel *m_treeModel;

   940     QItemSelectionModel *m_treeSelection;

   941 };

   942 

   943 QtResourceEditorDialogPrivate::QtResourceEditorDialogPrivate() :

   944     q_ptr(0),

   945     m_core(0),

   946     m_resourceModel(0),

   947     m_dlgGui(0),

   948     m_qrcManager(0),

   949     m_ignoreCurrentChanged(false),

   950     m_firstQrcFileDialog(true),

   951     m_currentQrcFile(0),

   952     m_newQrcFileAction(0),

   953     m_importQrcFileAction(0),

   954     m_removeQrcFileAction(0),

   955     m_moveUpQrcFileAction(0),

   956     m_moveDownQrcFileAction(0),

   957     m_newPrefixAction(0),

   958     m_addResourceFileAction(0),

   959     m_changePrefixAction(0),

   960     m_changeLanguageAction(0),

   961     m_changeAliasAction(0),

   962     m_clonePrefixAction(0),

   963     m_moveUpAction(0),

   964     m_moveDownAction(0),

   965     m_removeAction(0),

   966     m_treeModel(0),

   967     m_treeSelection(0)

   968 {

   969 }

   970 

   971 QMessageBox::StandardButton QtResourceEditorDialogPrivate::warning(const QString &title, const QString &text, QMessageBox::StandardButtons buttons,

   972                                                                    QMessageBox::StandardButton defaultButton) const

   973 {

   974     return m_dlgGui->message(q_ptr, QDesignerDialogGuiInterface::ResourceEditorMessage, QMessageBox::Warning, title, text, buttons, defaultButton);

   975 }

   976 

   977 QString QtResourceEditorDialogPrivate::qrcFileText(QtQrcFile *qrcFile) const

   978 {

   979     const QString path = qrcFile->path();

   980     const QString fileName = qrcFile->fileName();

   981     const QFileInfo fi(path);

   982     if (fi.exists() && !fi.isWritable())

   983         return QApplication::translate("QtResourceEditorDialog", "%1 [read-only]").arg(fileName);

   984     if (!m_qrcManager->exists(qrcFile))

   985         return QApplication::translate("QtResourceEditorDialog", "%1 [missing]").arg(fileName);

   986     return fileName;

   987 }

   988 

   989 void QtResourceEditorDialogPrivate::slotQrcFileInserted(QtQrcFile *qrcFile)

   990 {

   991     QListWidgetItem *currentItem = m_ui.qrcFileList->currentItem();

   992     int idx = m_ui.qrcFileList->count();

   993     QtQrcFile *nextQrcFile = m_qrcManager->nextQrcFile(qrcFile);

   994     QListWidgetItem *nextItem = m_qrcFileToItem.value(nextQrcFile);

   995     if (nextItem) {

   996         const int row = m_ui.qrcFileList->row(nextItem);

   997         if (row >= 0)

   998             idx = row;

   999     }

  1000     const QString path = qrcFile->path();

  1001     QListWidgetItem *item = new QListWidgetItem(qrcFileText(qrcFile));

  1002     item->setToolTip(path);

  1003     m_ignoreCurrentChanged = true;

  1004     m_ui.qrcFileList->insertItem(idx, item);

  1005     m_ui.qrcFileList->setCurrentItem(currentItem);

  1006     m_ignoreCurrentChanged = false;

  1007     m_qrcFileToItem[qrcFile] = item;

  1008     m_itemToQrcFile[item] = qrcFile;

  1009     if (!m_qrcManager->exists(qrcFile))

  1010         item->setForeground(QBrush(Qt::red));

  1011 }

  1012 

  1013 void QtResourceEditorDialogPrivate::slotQrcFileMoved(QtQrcFile *qrcFile)

  1014 {

  1015     QListWidgetItem *currentItem = m_ui.qrcFileList->currentItem();

  1016     QListWidgetItem *item = m_qrcFileToItem.value(qrcFile);

  1017     m_ignoreCurrentChanged = true;

  1018     m_ui.qrcFileList->takeItem(m_ui.qrcFileList->row(item));

  1019 

  1020     int idx = m_ui.qrcFileList->count();

  1021     QtQrcFile *nextQrcFile = m_qrcManager->nextQrcFile(qrcFile);

  1022     QListWidgetItem *nextItem = m_qrcFileToItem.value(nextQrcFile);

  1023     if (nextItem) {

  1024         int row = m_ui.qrcFileList->row(nextItem);

  1025         if (row >= 0)

  1026             idx = row;

  1027     }

  1028     m_ui.qrcFileList->insertItem(idx, item);

  1029     if (currentItem == item)

  1030         m_ui.qrcFileList->setCurrentItem(item);

  1031     m_ignoreCurrentChanged = false;

  1032 }

  1033 

  1034 void QtResourceEditorDialogPrivate::slotQrcFileRemoved(QtQrcFile *qrcFile)

  1035 {

  1036     QListWidgetItem *item = m_qrcFileToItem.value(qrcFile);

  1037     if (item == m_ui.qrcFileList->currentItem())

  1038         m_ui.qrcFileList->setCurrentItem(0); // this should trigger list view signal currentItemChanged(0), and slot should set m_currentQrcFile to 0

  1039     m_ignoreCurrentChanged = true;

  1040     delete item;

  1041     m_ignoreCurrentChanged = false;

  1042     m_itemToQrcFile.remove(item);

  1043     m_qrcFileToItem.remove(qrcFile);

  1044 }

  1045 

  1046 QStandardItem *QtResourceEditorDialogPrivate::insertResourcePrefix(QtResourcePrefix *resourcePrefix)

  1047 {

  1048     if (m_qrcManager->qrcFileOf(resourcePrefix) != m_currentQrcFile)

  1049         return 0;

  1050 

  1051     QtResourcePrefix *prevResourcePrefix = m_qrcManager->prevResourcePrefix(resourcePrefix);

  1052     QStandardItem *prevItem = m_resourcePrefixToPrefixItem.value(prevResourcePrefix);

  1053 

  1054     int row = 0;

  1055     if (prevItem)

  1056         row = m_treeModel->indexFromItem(prevItem).row() + 1;

  1057 

  1058     QStandardItem *prefixItem = new QStandardItem();

  1059     QStandardItem *languageItem = new QStandardItem();

  1060     QList<QStandardItem *> items;

  1061     items << prefixItem;

  1062     items << languageItem;

  1063     m_treeModel->insertRow(row, items);

  1064     const QModelIndex newIndex = m_treeModel->indexFromItem(prefixItem);

  1065     m_ui.resourceTreeView->setExpanded(newIndex, true);

  1066     prefixItem->setFlags(prefixItem->flags() | Qt::ItemIsEditable);

  1067     languageItem->setFlags(languageItem->flags() | Qt::ItemIsEditable);

  1068     m_resourcePrefixToPrefixItem[resourcePrefix] = prefixItem;

  1069     m_resourcePrefixToLanguageItem[resourcePrefix] = languageItem;

  1070     m_prefixItemToResourcePrefix[prefixItem] = resourcePrefix;

  1071     m_languageItemToResourcePrefix[languageItem] = resourcePrefix;

  1072     slotResourcePrefixChanged(resourcePrefix);

  1073     slotResourceLanguageChanged(resourcePrefix);

  1074     return prefixItem;

  1075 }

  1076 

  1077 void QtResourceEditorDialogPrivate::slotResourcePrefixMoved(QtResourcePrefix *resourcePrefix)

  1078 {

  1079     QStandardItem *prefixItem = m_resourcePrefixToPrefixItem.value(resourcePrefix);

  1080     if (!prefixItem)

  1081         return;

  1082 

  1083     QStandardItem *languageItem = m_resourcePrefixToLanguageItem.value(resourcePrefix);

  1084     if (!languageItem)

  1085         return;

  1086 

  1087     const QModelIndex index = m_treeModel->indexFromItem(prefixItem);

  1088     const bool expanded = m_ui.resourceTreeView->isExpanded(index);

  1089     m_ignoreCurrentChanged = true;

  1090     const QList<QStandardItem *> items = m_treeModel->takeRow(index.row());

  1091 

  1092     int row = m_treeModel->rowCount();

  1093     QtResourcePrefix *nextResourcePrefix = m_qrcManager->nextResourcePrefix(resourcePrefix);

  1094     QStandardItem *nextItem = m_resourcePrefixToPrefixItem.value(nextResourcePrefix);

  1095     if (nextItem)

  1096         row = m_treeModel->indexFromItem(nextItem).row();

  1097     m_treeModel->insertRow(row, items);

  1098     m_ignoreCurrentChanged = false;

  1099     m_ui.resourceTreeView->setExpanded(m_treeModel->indexFromItem(items.at(0)), expanded);

  1100 }

  1101 

  1102 void QtResourceEditorDialogPrivate::slotResourcePrefixChanged(QtResourcePrefix *resourcePrefix)

  1103 {

  1104     QStandardItem *item = m_resourcePrefixToPrefixItem.value(resourcePrefix);

  1105     if (!item)

  1106         return;

  1107 

  1108     m_ignoreCurrentChanged = true;

  1109     QString prefix = resourcePrefix->prefix();

  1110     if (prefix.isEmpty())

  1111         prefix = QApplication::translate("QtResourceEditorDialog", "<no prefix>", 0, QApplication::UnicodeUTF8);

  1112     item->setText(prefix);

  1113     item->setToolTip(prefix);

  1114     m_ignoreCurrentChanged = false;

  1115 }

  1116 

  1117 void QtResourceEditorDialogPrivate::slotResourceLanguageChanged(QtResourcePrefix *resourcePrefix)

  1118 {

  1119     QStandardItem *item = m_resourcePrefixToLanguageItem.value(resourcePrefix);

  1120     if (!item)

  1121         return;

  1122 

  1123     m_ignoreCurrentChanged = true;

  1124     const QString language = resourcePrefix->language();

  1125     item->setText(language);

  1126     item->setToolTip(language);

  1127 

  1128     m_ignoreCurrentChanged = false;

  1129 }

  1130 

  1131 void QtResourceEditorDialogPrivate::slotResourcePrefixRemoved(QtResourcePrefix *resourcePrefix)

  1132 {

  1133     QStandardItem *prefixItem = m_resourcePrefixToPrefixItem.value(resourcePrefix);

  1134     if (!prefixItem)