ProjectExplorer: Merge FolderNode's m_{file,folder}Node fields

One step closer to direct use of Utils::TreeNode.

Change-Id: Icd0dfd2fa4d12c2572a68f61ae43c5e906956a0e
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>

src/plugins/cmakeprojectmanager/builddirmanager.cpp

@@ -286,7 +286,7 @@ void BuildDirManager::generateProjectTree(CMakeListsNode *root, const QList<cons
 
     // Make sure the top level CMakeLists.txt is always visible:
     if (root->isEmpty())
-        root->addFileNode(new FileNode(projectFile, FileType::Project, false));
+        root->addNode(new FileNode(projectFile, FileType::Project, false));
 }
 
 QSet<Core::Id> BuildDirManager::updateCodeModel(CppTools::ProjectPartBuilder &ppBuilder)

src/plugins/cmakeprojectmanager/servermodereader.cpp

@@ -224,7 +224,7 @@ static void addCMakeVFolder(FolderNode *base, const Utils::FileName &basePath, i
         return;
     auto folder = new VirtualFolderNode(basePath, priority);
     folder->setDisplayName(displayName);
-    base->addFolderNode(folder);
+    base->addNode(folder);
     folder->buildTree(files);
 }
 
@@ -236,7 +236,7 @@ static void addCMakeInputs(CMakeListsNode *root,
                            QList<FileNode *> &rootInputs)
 {
     ProjectNode *cmakeVFolder = new CMakeInputsNode(root->filePath());
-    root->addProjectNode(cmakeVFolder);
+    root->addNode(cmakeVFolder);
 
     addCMakeVFolder(cmakeVFolder, sourceDir, 1000,
                     QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Source Directory>"),
@@ -550,14 +550,14 @@ void ServerModeReader::addCMakeLists(CMakeListsNode *root, const QList<FileNode
             cmln = static_cast<CMakeListsNode *>(parentNode->projectNode(fn->filePath()));
         if (!cmln) {
             cmln = new CMakeListsNode(fn->filePath());
-            parentNode->addProjectNode(cmln);
+            parentNode->addNode(cmln);
         }
 
         // Find or create CMakeLists.txt filenode below CMakeListsNode:
         FileNode *cmFn = cmln->fileNode(fn->filePath());
         if (!cmFn) {
             cmFn = fn;
-            cmln->addFileNode(cmFn);
+            cmln->addNode(cmFn);
         }
         // Update displayName of CMakeListsNode:
         const QString dn = prefix.isEmpty() ? k : k.mid(prefix.count() + 1);
@@ -601,7 +601,7 @@ static CMakeProjectNode *findOrCreateProjectNode(CMakeListsNode *root, const Uti
     CMakeProjectNode *pn = static_cast<CMakeProjectNode *>(cmln->projectNode(projectName));
     if (!pn) {
         pn = new CMakeProjectNode(projectName);
-        cmln->addProjectNode(pn);
+        cmln->addNode(pn);
     }
     pn->setDisplayName(displayName);
     return pn;
@@ -637,7 +637,7 @@ static CMakeTargetNode *findOrCreateTargetNode(CMakeListsNode *root, const Utils
     CMakeTargetNode *tn = static_cast<CMakeTargetNode *>(cmln->projectNode(targetName));
     if (!tn) {
         tn = new CMakeTargetNode(targetName);
-        cmln->addProjectNode(tn);
+        cmln->addNode(tn);
     }
     tn->setDisplayName(displayName);
     return tn;

src/plugins/projectexplorer/projectnodes.cpp

@@ -307,8 +307,7 @@ FolderNode::FolderNode(const Utils::FileName &folderPath, NodeType nodeType, con
 
 FolderNode::~FolderNode()
 {
-    qDeleteAll(m_folderNodes);
+    qDeleteAll(m_nodes);
-    qDeleteAll(m_fileNodes);
 }
 
 /*!
@@ -336,14 +335,20 @@ QIcon FolderNode::icon() const
 
 QList<FileNode*> FolderNode::fileNodes() const
 {
-    return m_fileNodes;
+    QList<FileNode *> result;
+    for (Node *n : m_nodes) {
+        if (FileNode *fn = n->asFileNode())
+            result.append(fn);
+    }
+    return result;
 }
 
 FileNode *FolderNode::fileNode(const Utils::FileName &file) const
 {
-    return Utils::findOrDefault(m_fileNodes, [&file](const FileNode *fn) {
+    return static_cast<FileNode *>(Utils::findOrDefault(m_nodes, [&file](const Node *n) {
-        return fn->filePath() == file;
+        const FileNode *fn = n->asFileNode();
-    });
+        return fn && fn->filePath() == file;
+    }));
 }
 
 FileNode *FolderNode::recursiveFileNode(const Utils::FileName &file) const
@@ -359,9 +364,10 @@ FileNode *FolderNode::recursiveFileNode(const Utils::FileName &file) const
     foreach (const QString &part, parts) {
         dir.appendPath(part);
         // Find folder in subFolders
-        parent = Utils::findOrDefault(parent->folderNodes(), [&dir](const FolderNode *fn) {
+        parent = static_cast<FolderNode *>(Utils::findOrDefault(parent->nodes(), [&dir](const Node *n) {
-            return fn->filePath() == dir;
+            const FolderNode *fn = n->asFolderNode();
-        });
+            return fn && fn->filePath() == dir;
+        }));
         if (!parent)
             return nullptr;
     }
@@ -378,14 +384,21 @@ QList<FileNode *> FolderNode::recursiveFileNodes() const
 
 QList<FolderNode*> FolderNode::folderNodes() const
 {
-    return m_folderNodes;
+    QList<FolderNode *> result;
+    for (Node *n : m_nodes) {
+        if (FolderNode *fn = n->asFolderNode())
+            result.append(fn);
+    }
+    return result;
 }
 
+
 FolderNode *FolderNode::folderNode(const Utils::FileName &directory) const
 {
-    return Utils::findOrDefault(m_folderNodes, [&directory](const FolderNode *fn) {
+    return static_cast<FolderNode *>(Utils::findOrDefault(m_nodes, [&directory](const Node *n) {
-        return fn->filePath() == directory;
+        const FolderNode *fn = n->asFolderNode();
-    });
+        return fn && fn->filePath() == directory;
+    }));
 }
 
 FolderNode *FolderNode::recursiveFindOrCreateFolderNode(const QString &directory,
@@ -412,7 +425,7 @@ FolderNode *FolderNode::recursiveFindOrCreateFolderNode(const QString &directory
             // No FolderNode yet, so create it
             auto tmp = new ProjectExplorer::FolderNode(path);
             tmp->setDisplayName(part);
-            parent->addFolderNode(tmp);
+            parent->addNode(tmp);
             next = tmp;
         }
         parent = next;
@@ -428,7 +441,7 @@ void FolderNode::buildTree(QList<FileNode *> &files, const Utils::FileName &over
         // Get relative path to rootNode
         QString parentDir = fn->filePath().toFileInfo().absolutePath();
         ProjectExplorer::FolderNode *folder = recursiveFindOrCreateFolderNode(parentDir, overrideBaseDir);
-        folder->addFileNode(fn);
+        folder->addNode(fn);
     }
 
     emitTreeChanged();
@@ -437,8 +450,10 @@ void FolderNode::buildTree(QList<FileNode *> &files, const Utils::FileName &over
 void FolderNode::accept(NodesVisitor *visitor)
 {
     visitor->visitFolderNode(this);
-    foreach (FolderNode *subFolder, m_folderNodes)
+    for (Node *n : m_nodes) {
+        if (FolderNode *subFolder = n->asFolderNode())
             subFolder->accept(visitor);
+    }
 }
 
 void FolderNode::setDisplayName(const QString &name)
@@ -506,22 +521,24 @@ FolderNode::AddNewInformation FolderNode::addNewInformation(const QStringList &f
 }
 
 /*!
-  Adds a file node specified by \a file to the internal list of the folder
+  Adds a node specified by \a node to the internal list of nodes.
-  and emits the corresponding signals from the projectNode.
-
-  This function should be called within an implementation of the public function
-  addFiles.
 */
 
-void FolderNode::addFileNode(FileNode *file)
+void FolderNode::addNode(Node *node)
 {
-    Q_ASSERT(managingProject());
+    QTC_ASSERT(!node->parentFolderNode(), qDebug("File node has already a parent folder"));
+    node->setParentFolderNode(this);
+    m_nodes.append(node);
+}
 
-    QTC_ASSERT(!file->parentFolderNode(),
+/*!
-               qDebug("File node has already a parent folder"));
+  Removes a node specified by \a node from the internal list of nodes.
+  The node object itself is not deleted.
+*/
 
-    file->setParentFolderNode(this);
+void FolderNode::removeNode(Node *node)
-    m_fileNodes.append(file);
+{
+    m_nodes.removeOne(node);
 }
 
 /*!
@@ -529,40 +546,20 @@ void FolderNode::addFileNode(FileNode *file)
   and emits the corresponding signals from the projectNode.
 */
 
-void FolderNode::setFileNodes(const QList<FileNode *> &files)
+void FolderNode::setNodes(const QList<Node *> &nodes)
 {
-    qDeleteAll(m_fileNodes);
+    qDeleteAll(m_nodes);
-    m_fileNodes = files;
+    m_nodes = nodes;
-    for (FileNode *node : m_fileNodes)
+    for (Node *node : m_nodes)
         node->setParentFolderNode(this);
 }
 
 /*!
-  Adds a folder node specified by \a folder to the node hierarchy below
+  Removes all files and subfolders from this folder node.
-  \a parentFolder and emits the corresponding signals.
 */
-void FolderNode::addFolderNode(FolderNode *folder)
-{
-    Q_ASSERT(managingProject());
-
-    QTC_ASSERT(!folder->parentFolderNode(),
-               qDebug("Project node has already a parent folder"));
-    folder->setParentFolderNode(this);
-    m_folderNodes.append(folder);
-}
-
-void FolderNode::setFolderNodes(const QList<FolderNode *> &folders)
-{
-    qDeleteAll(m_folderNodes);
-    m_folderNodes = folders;
-    for (FolderNode *node : m_folderNodes)
-        node->setParentFolderNode(this);
-}
-
 void FolderNode::makeEmpty()
 {
-    setFolderNodes({});
+    setNodes({});
-    setFileNodes({});
 }
 
 bool FolderNode::showInSimpleTree() const
@@ -688,7 +685,7 @@ QList<RunConfiguration *> ProjectNode::runConfigurations() const
 
 ProjectNode *ProjectNode::projectNode(const Utils::FileName &file) const
 {
-    for (FolderNode *node : m_folderNodes) {
+    for (Node *node : m_nodes) {
         if (ProjectNode *pnode = node->asProjectNode())
             if (pnode->filePath() == file)
                 return pnode;
@@ -699,31 +696,16 @@ ProjectNode *ProjectNode::projectNode(const Utils::FileName &file) const
 QList<ProjectNode*> FolderNode::projectNodes() const
 {
     QList<ProjectNode *> nodes;
-    for (FolderNode *node : m_folderNodes) {
+    for (Node *node : m_nodes) {
         if (ProjectNode *pnode = node->asProjectNode())
             nodes.append(pnode);
     }
     return nodes;
 }
 
-/*!
-  Adds project nodes specified by \a subProjects to the node hierarchy and
-  emits the corresponding signals.
-  */
-void ProjectNode::addProjectNode(ProjectNode *subProject)
-{
-    QTC_ASSERT(subProject, return);
-    QTC_ASSERT(!subProject->parentFolderNode(), return);
-
-    subProject->setParentFolderNode(this);
-    m_folderNodes.append(subProject);
-
-    Utils::sort(m_folderNodes);
-}
-
 bool FolderNode::isEmpty() const
 {
-    return m_fileNodes.isEmpty() && m_folderNodes.isEmpty();
+    return m_nodes.isEmpty();
 }
 
 /*!
@@ -750,18 +732,4 @@ QString SessionNode::addFileFilter() const
     return QString::fromLatin1("*.c; *.cc; *.cpp; *.cp; *.cxx; *.c++; *.h; *.hh; *.hpp; *.hxx;");
 }
 
-void SessionNode::addProjectNode(ProjectNode *projectNode)
-{
-    QTC_ASSERT(!projectNode->parentFolderNode(),
-               qDebug("Project node has already a parent folder"));
-    projectNode->setParentFolderNode(this);
-    m_folderNodes.append(projectNode);
-    Utils::sort(m_folderNodes);
-}
-
-void SessionNode::removeProjectNode(ProjectNode *projectNode)
-{
-    m_folderNodes.removeOne(projectNode);
-}
-
 } // namespace ProjectExplorer

src/plugins/projectexplorer/projectnodes.h

@@ -154,12 +154,12 @@ public:
     virtual const SessionNode *asSessionNode() const { return nullptr; }
 
     static bool sortByPath(const Node *a, const Node *b);
+    void setParentFolderNode(FolderNode *parentFolder);
 
 protected:
     Node(NodeType nodeType, const Utils::FileName &filePath, int line = -1);
 
     void setPriority(int priority);
-    void setParentFolderNode(FolderNode *parentFolder);
 
 private:
     FolderNode *m_parentFolderNode = nullptr;
@@ -206,6 +206,7 @@ public:
     QString displayName() const override;
     QIcon icon() const;
 
+    const QList<Node *> nodes() const { return m_nodes; }
     QList<FileNode *> fileNodes() const;
     FileNode *fileNode(const Utils::FileName &file) const;
     FileNode *recursiveFileNode(const Utils::FileName &file) const;
@@ -245,11 +246,9 @@ public:
     // determines if node will be shown in the flat view, by default folder and projects aren't shown
     virtual bool showInSimpleTree() const;
 
-    void addFileNode(FileNode *file);
+    void addNode(Node *node);
-    void setFileNodes(const QList<FileNode*> &files);
+    void removeNode(Node *node);
-
+    void setNodes(const QList<Node *> &nodes);
-    void addFolderNode(FolderNode *subFolder);
-    void setFolderNodes(const QList<FolderNode*> &folders);
 
     // all subFolders that are projects
     QList<ProjectNode*> projectNodes() const;
@@ -261,8 +260,7 @@ public:
     const FolderNode *asFolderNode() const override { return this; }
 
 protected:
-    QList<FolderNode*> m_folderNodes;
+    QList<Node *> m_nodes;
-    QList<FileNode*> m_fileNodes;
 
 private:
     QString m_displayName;
@@ -300,7 +298,6 @@ public:
     virtual QList<RunConfiguration *> runConfigurations() const;
 
     ProjectNode *projectNode(const Utils::FileName &file) const;
-    void addProjectNode(ProjectNode *subProject);
 
     ProjectNode *asProjectNode() final { return this; }
     const ProjectNode *asProjectNode() const final { return this; }
@@ -330,10 +327,6 @@ private:
 
     SessionNode *asSessionNode() final { return this; }
     const SessionNode *asSessionNode() const final { return this; }
-
-    friend class SessionManager;
-    void addProjectNode(ProjectNode *projectNode);
-    void removeProjectNode(ProjectNode *projectNode);
 };
 
 } // namespace ProjectExplorer

src/plugins/projectexplorer/session.cpp

@@ -381,7 +381,7 @@ void SessionManager::addProject(Project *pro)
     QTC_ASSERT(!d->m_projects.contains(pro), return);
 
     d->m_projects.append(pro);
-    d->m_sessionNode.addProjectNode(pro->rootProjectNode());
+    d->m_sessionNode.addNode(pro->rootProjectNode());
 
     connect(pro, &Project::fileListChanged,
             m_instance, &SessionManager::clearProjectFileCache);
@@ -738,7 +738,7 @@ void SessionManager::removeProjects(QList<Project *> remove)
                    m_instance, &SessionManager::clearProjectFileCache);
         d->m_projectFileCache.remove(pro);
 
-        d->m_sessionNode.removeProjectNode(pro->rootProjectNode());
+        d->m_sessionNode.removeNode(pro->rootProjectNode());
         emit m_instance->projectRemoved(pro);
         delete pro;
     }

src/plugins/qbsprojectmanager/qbsnodes.cpp

@@ -322,7 +322,7 @@ QbsGroupNode::QbsGroupNode(const qbs::GroupData &grp, const QString &productPath
 
     setIcon(m_groupIcon);
 
-    addFileNode(new QbsFileNode(Utils::FileName::fromString(grp.location().filePath()),
+    addNode(new QbsFileNode(Utils::FileName::fromString(grp.location().filePath()),
                             ProjectExplorer::FileType::Project, false,
                             grp.location().line()));
 
@@ -472,7 +472,7 @@ void QbsGroupNode::setupFolder(ProjectExplorer::FolderNode *root,
             }
             if (!fn) {
                 fn = new ProjectExplorer::FileNode(path, newFileType, generated);
-                root->addFileNode(fn);
+                root->addNode(fn);
             }
             continue;
         } else {
@@ -493,7 +493,7 @@ void QbsGroupNode::setupFolder(ProjectExplorer::FolderNode *root,
                                            ProjectExplorer::NodeType::Folder,
                                            displayNameFromPath(c->path(), baseDir), false);
                 }
-                root->addFolderNode(fn);
+                root->addNode(fn);
             } else {
                 fn->setDisplayName(displayNameFromPath(c->path(), baseDir));
             }
@@ -542,8 +542,8 @@ QbsProductNode::QbsProductNode(const qbs::Project &project, const qbs::ProductDa
 
     setIcon(m_productIcon);
 
-    addFolderNode(m_generatedFilesNode);
+    addNode(m_generatedFilesNode);
-    addFileNode(new QbsFileNode(Utils::FileName::fromString(prd.location().filePath()),
+    addNode(new QbsFileNode(Utils::FileName::fromString(prd.location().filePath()),
                             ProjectExplorer::FileType::Project, false,
                             prd.location().line()));
 
@@ -641,7 +641,7 @@ void QbsProductNode::setQbsProductData(const qbs::Project &project, const qbs::P
             QbsGroupNode::setupFiles(this, grp, grp.allFilePaths(), productPath, false);
             continue;
         }
-        addProjectNode(new QbsGroupNode(grp, productPath));
+        addNode(new QbsGroupNode(grp, productPath));
     }
 
     if (prd.isEnabled()) {
@@ -703,11 +703,11 @@ void QbsProjectNode::update(const qbs::Project &qbsProject, const qbs::ProjectDa
         auto subProject =
                 new QbsProjectNode(Utils::FileName::fromString(subData.location().filePath()));
         subProject->update(qbsProject, subData);
-        addProjectNode(subProject);
+        addNode(subProject);
     }
 
     foreach (const qbs::ProductData &prd, prjData.products())
-        addProjectNode(new QbsProductNode(qbsProject, prd));
+        addNode(new QbsProductNode(qbsProject, prd));
 
     if (!prjData.name().isEmpty())
         setDisplayName(prjData.name());
@@ -738,7 +738,7 @@ void QbsProjectNode::ctor()
         m_projectIcon = generateIcon(QString::fromLatin1(ProjectExplorer::Constants::FILEOVERLAY_QT));
 
     setIcon(m_projectIcon);
-    addFileNode(new ProjectExplorer::FileNode(filePath(), ProjectExplorer::FileType::Project, false));
+    addNode(new ProjectExplorer::FileNode(filePath(), ProjectExplorer::FileType::Project, false));
 }
 
 QbsProductNode *QbsProjectNode::findProductNode(const QString &uniqueName)
@@ -772,7 +772,7 @@ QbsRootProjectNode::QbsRootProjectNode(QbsProject *project) :
                                                        ProjectExplorer::NodeType::Folder,
                                                        QCoreApplication::translate("QbsRootProjectNode", "Qbs files")))
 {
-    addFolderNode(m_buildSystemFiles);
+    addNode(m_buildSystemFiles);
 }
 
 void QbsRootProjectNode::update()

src/plugins/qmakeprojectmanager/qmakenodes.cpp

@@ -405,19 +405,19 @@ struct InternalNode
                 if (contents.isEmpty())
                     vfs->readVirtualFile(file.toString(), QMakeVfs::VfsExact, &contents);
                 auto resourceNode = new ResourceEditor::ResourceTopLevelNode(file, contents, folder);
-                folder->addFolderNode(resourceNode);
+                folder->addNode(resourceNode);
                 resourceNode->addInternalNodes();
             }
         } else {
             for (const FileName &file : files)
-                folder->addFileNode(new FileNode(file, type, false));
+                folder->addNode(new FileNode(file, type, false));
         }
 
         // Virtual
         {
             for (InternalNode *node : virtualfolders) {
                 FolderNode *newNode = createFolderNode(node);
-                folder->addFolderNode(newNode);
+                folder->addNode(newNode);
                 node->addSubFolderContents(newNode);
             }
         }
@@ -427,7 +427,7 @@ struct InternalNode
             QMap<QString, InternalNode *>::const_iterator end = subnodes.constEnd();
             for ( ; it != end; ++it) {
                 FolderNode *newNode = createFolderNode(it.value());
-                folder->addFolderNode(newNode);
+                folder->addNode(newNode);
                 it.value()->addSubFolderContents(newNode);
             }
         }
@@ -591,8 +591,8 @@ void QmakePriFileNode::processValues(PriFileEvalResult &result)
 void QmakePriFileNode::update(const Internal::PriFileEvalResult &result)
 {
     // add project file node
-    if (m_fileNodes.isEmpty())
+    if (m_nodes.isEmpty())
-        addFileNode(new FileNode(m_projectFilePath, FileType::Project, false));
+        addNode(new FileNode(m_projectFilePath, FileType::Project, false));
 
     m_recursiveEnumerateFiles = result.recursiveEnumerateFiles;
     watchFolders(result.folders.toSet());
@@ -1979,14 +1979,14 @@ void QmakeProFileNode::applyEvaluate(EvalResult *evalResult)
 
             if (priFile->proFile) {
                 QmakePriFileNode *qmakePriFileNode = new QmakePriFileNode(m_project, this, priFile->name);
-                pn->addProjectNode(qmakePriFileNode);
+                pn->addNode(qmakePriFileNode);
                 qmakePriFileNode->setIncludedInExactParse(
                             (result->state == EvalResult::EvalOk) && pn->includedInExactParse());
                 qmakePriFileNode->update(priFile->result);
                 toCompare.append(qMakePair(qmakePriFileNode, priFile));
             } else {
                 QmakeProFileNode *qmakeProFileNode = new QmakeProFileNode(m_project, priFile->name);
-                pn->addProjectNode(qmakeProFileNode);
+                pn->addNode(qmakeProFileNode);
                 qmakeProFileNode->setIncludedInExactParse(
                             result->exactSubdirs.contains(qmakeProFileNode->filePath())
                             && pn->includedInExactParse());

src/plugins/resourceeditor/resourcenode.cpp

@@ -121,7 +121,7 @@ ResourceTopLevelNode::~ResourceTopLevelNode()
 
 void ResourceTopLevelNode::addInternalNodes()
 {
-    QMap<PrefixFolderLang, QList<ProjectExplorer::FileNode *>> filesToAdd;
+    QMap<PrefixFolderLang, QList<ProjectExplorer::Node *>> nodesToAdd;
     QMap<PrefixFolderLang, QList<ProjectExplorer::FolderNode *>> foldersToAddToFolders;
     QMap<PrefixFolderLang, QList<ProjectExplorer::FolderNode *>> foldersToAddToPrefix;
 
@@ -138,7 +138,7 @@ void ResourceTopLevelNode::addInternalNodes()
             PrefixFolderLang prefixId(prefix, QString(), lang);
             if (!prefixNodes.contains(prefixId)) {
                 ProjectExplorer::FolderNode *fn = new ResourceFolderNode(file.prefix(i), file.lang(i), this);
-                addFolderNode(fn);
+                addNode(fn);
                 prefixNodes.insert(prefixId, fn);
             }
             ResourceFolderNode *currentPrefixNode = static_cast<ResourceFolderNode*>(prefixNodes[prefixId]);
@@ -189,6 +189,7 @@ void ResourceTopLevelNode::addInternalNodes()
                             } else {
                                 PrefixFolderLang parentFolderId(prefix, parentFolderName, lang);
                                 foldersToAddToFolders[parentFolderId] << newNode;
+                                nodesToAdd[parentFolderId] << newNode;
                             }
                             folderNodes.insert(folderId, newNode);
                         }
@@ -198,9 +199,9 @@ void ResourceTopLevelNode::addInternalNodes()
 
                     const QString qrcPath = QDir::cleanPath(prefixWithSlash + alias);
                     fileNames.insert(fileName);
-                    filesToAdd[folderId]
+                    auto rn = new ResourceFileNode(Utils::FileName::fromString(fileName),
-                            << new ResourceFileNode(Utils::FileName::fromString(fileName),
                                                    qrcPath, displayName);
+                    nodesToAdd[folderId] << rn;
                 }
             }
         }
@@ -209,11 +210,10 @@ void ResourceTopLevelNode::addInternalNodes()
     foreach (FolderNode *sfn, folderNodes()) {
         ResourceFolderNode *srn = static_cast<ResourceFolderNode *>(sfn);
         PrefixFolderLang folderId(srn->prefix(), QString(), srn->lang());
-        srn->setFileNodes(filesToAdd[folderId]);
+        srn->setNodes(nodesToAdd[folderId]);
-        srn->setFolderNodes(foldersToAddToPrefix[folderId]);
         foreach (FolderNode* ssfn, sfn->folderNodes()) {
             SimpleResourceFolderNode *sssn = static_cast<SimpleResourceFolderNode *>(ssfn);
-            sssn->addFilesAndSubfolders(filesToAdd, foldersToAddToFolders, srn->prefix(), srn->lang());
+            sssn->addFilesAndSubfolders(foldersToAddToFolders, nodesToAdd, srn->prefix(), srn->lang());
         }
     }
 }
@@ -649,16 +649,13 @@ ResourceFolderNode *SimpleResourceFolderNode::prefixNode() const
     return m_prefixNode;
 }
 
-void SimpleResourceFolderNode::addFilesAndSubfolders(QMap<PrefixFolderLang,
+void SimpleResourceFolderNode::addFilesAndSubfolders(QMap<PrefixFolderLang, QList<ProjectExplorer::FolderNode*> > foldersToAdd,
-                                                     QList<ProjectExplorer::FileNode *>> filesToAdd,
+                                                     QMap<PrefixFolderLang, QList<ProjectExplorer::Node*> > nodesToAdd,
-                                                     QMap<PrefixFolderLang,
-                                                     QList<ProjectExplorer::FolderNode*> > foldersToAdd,
                                                      const QString &prefix, const QString &lang)
 {
-    setFileNodes(filesToAdd.value(PrefixFolderLang(prefix, m_folderName, lang)));
+    setNodes(nodesToAdd.value(PrefixFolderLang(prefix, m_folderName, lang)));
-    setFolderNodes(foldersToAdd.value(PrefixFolderLang(prefix, m_folderName, lang)));
     foreach (FolderNode* subNode, folderNodes()) {
         SimpleResourceFolderNode* sn = static_cast<SimpleResourceFolderNode*>(subNode);
-        sn->addFilesAndSubfolders(filesToAdd, foldersToAdd, prefix, lang);
+        sn->addFilesAndSubfolders(foldersToAdd, nodesToAdd, prefix, lang);
     }
 }

src/plugins/resourceeditor/resourcenode.h

@@ -122,8 +122,8 @@ public:
                      const QString &prefix, const QString &lang, Utils::FileName absolutePath,
                      ResourceTopLevelNode *topLevel, ResourceFolderNode *prefixNode);
     QList<ProjectExplorer::ProjectAction> supportedActions(ProjectExplorer::Node *node) const;
-    void addFilesAndSubfolders(QMap<PrefixFolderLang, QList<ProjectExplorer::FileNode *>> filesToAdd,
+    void addFilesAndSubfolders(QMap<PrefixFolderLang, QList<ProjectExplorer::FolderNode *>> foldersToAdd,
-                               QMap<PrefixFolderLang, QList<ProjectExplorer::FolderNode *>> foldersToAdd,
+                               QMap<PrefixFolderLang, QList<ProjectExplorer::Node *>> nodesToAdd,
                                const QString &prefix, const QString &lang);
     bool addFiles(const QStringList &filePaths, QStringList *notAdded);
     bool removeFiles(const QStringList &filePaths, QStringList *notRemoved);