qt4nodes.cpp 39 KB
Newer Older
hjk's avatar
hjk committed
1
/**************************************************************************
con's avatar
con committed
2 3 4
**
** This file is part of Qt Creator
**
hjk's avatar
hjk committed
5
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
con's avatar
con committed
6
**
7
** Contact: Nokia Corporation (qt-info@nokia.com)
con's avatar
con committed
8
**
hjk's avatar
hjk committed
9
** Commercial Usage
10
**
hjk's avatar
hjk committed
11 12 13 14
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
15
**
hjk's avatar
hjk committed
16
** GNU Lesser General Public License Usage
17
**
hjk's avatar
hjk committed
18 19 20 21 22 23
** 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.
24
**
hjk's avatar
hjk committed
25
** If you are unsure which license is appropriate for your use, please
hjk's avatar
hjk committed
26
** contact the sales department at http://qt.nokia.com/contact.
con's avatar
con committed
27
**
hjk's avatar
hjk committed
28
**************************************************************************/
hjk's avatar
hjk committed
29

con's avatar
con committed
30
#include "proeditormodel.h"
hjk's avatar
hjk committed
31

con's avatar
con committed
32
#include "profilereader.h"
33
#include "prowriter.h"
con's avatar
con committed
34 35 36
#include "qt4nodes.h"
#include "qt4project.h"
#include "qt4projectmanager.h"
dt's avatar
dt committed
37
#include "qtuicodemodelsupport.h"
con's avatar
con committed
38 39

#include <projectexplorer/nodesvisitor.h>
40
#include <projectexplorer/filewatcher.h>
con's avatar
con committed
41 42

#include <coreplugin/editormanager/editormanager.h>
Jens Bache-Wiig's avatar
Jens Bache-Wiig committed
43
#include <coreplugin/fileiconprovider.h>
con's avatar
con committed
44 45 46 47 48 49
#include <coreplugin/filemanager.h>
#include <coreplugin/icore.h>
#include <coreplugin/iversioncontrol.h>
#include <coreplugin/vcsmanager.h>

#include <cpptools/cppmodelmanagerinterface.h>
50
#include <cplusplus/CppDocument.h>
51
#include <extensionsystem/pluginmanager.h>
52 53
#include <projectexplorer/projectexplorer.h>
#include <projectexplorer/buildmanager.h>
con's avatar
con committed
54

hjk's avatar
hjk committed
55 56
#include <utils/qtcassert.h>

con's avatar
con committed
57 58 59 60 61
#include <QtCore/QDebug>
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
#include <QtCore/QTimer>
hjk's avatar
hjk committed
62

Jens Bache-Wiig's avatar
Jens Bache-Wiig committed
63
#include <QtGui/QPainter>
con's avatar
con committed
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
#include <QtGui/QMainWindow>
#include <QtGui/QMessageBox>
#include <QtGui/QPushButton>

using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;

namespace {
    bool debug = false;
}

namespace {
    // sorting helper function
    bool sortProjectFilesByPath(ProFile *f1, ProFile *f2)
    {
        return f1->fileName() < f2->fileName();
    }
}

/*!
  \class Qt4PriFileNode
  Implements abstract ProjectNode class
  */

88
Qt4PriFileNode::Qt4PriFileNode(Qt4Project *project, Qt4ProFileNode* qt4ProFileNode, const QString &filePath)
con's avatar
con committed
89 90
        : ProjectNode(filePath),
          m_project(project),
91
          m_qt4ProFileNode(qt4ProFileNode),
92
          m_projectFilePath(QDir::fromNativeSeparators(filePath)),
93
          m_projectDir(QFileInfo(filePath).absolutePath()),
94
          m_fileWatcher(new ProjectExplorer::FileWatcher(this))
con's avatar
con committed
95
{
dt's avatar
dt committed
96
    Q_ASSERT(project);
97
    setFolderName(QFileInfo(filePath).completeBaseName());
Jens Bache-Wiig's avatar
Jens Bache-Wiig committed
98 99 100 101 102 103 104 105 106 107 108

    static QIcon dirIcon;
    if (dirIcon.isNull()) {
        // Create a custom Qt dir icon based on the system icon
        Core::FileIconProvider *iconProvider = Core::FileIconProvider::instance();
        QPixmap dirIconPixmap = iconProvider->overlayIcon(QStyle::SP_DirIcon,
                                                          QIcon(":/qt4projectmanager/images/qt_project.png"),
                                                          QSize(16, 16));
        dirIcon.addPixmap(dirIconPixmap);
    }
    setIcon(dirIcon);
109 110 111 112 113 114 115 116
    m_fileWatcher->addFile(filePath);
    connect(m_fileWatcher, SIGNAL(fileChanged(QString)),
            this, SLOT(scheduleUpdate()));
}

void Qt4PriFileNode::scheduleUpdate()
{
    m_qt4ProFileNode->scheduleUpdate();
con's avatar
con committed
117 118 119 120
}

void Qt4PriFileNode::update(ProFile *includeFile, ProFileReader *reader)
{
dt's avatar
dt committed
121 122
    Q_ASSERT(includeFile);
    Q_ASSERT(reader);
con's avatar
con committed
123 124 125 126 127 128 129 130 131 132 133 134

    // add project file node
    if (m_fileNodes.isEmpty())
        addFileNodes(QList<FileNode*>() << new FileNode(m_projectFilePath, ProjectFileType, false), this);

    static QList<FileType> fileTypes =
               (QList<FileType>() << ProjectExplorer::HeaderType
                                  << ProjectExplorer::SourceType
                                  << ProjectExplorer::FormType
                                  << ProjectExplorer::ResourceType
                                  << ProjectExplorer::UnknownFileType);

135 136 137 138 139 140 141 142
    const QString &projectDir = m_qt4ProFileNode->m_projectDir;

    QStringList baseVPaths;
    baseVPaths += reader->absolutePathValues("VPATH", projectDir);
    baseVPaths << projectDir; // QMAKE_ABSOLUTE_SOURCE_PATH
    baseVPaths += reader->absolutePathValues("DEPENDPATH", projectDir);
    baseVPaths.removeDuplicates();

con's avatar
con committed
143 144 145 146 147
    // update files
    foreach (FileType type, fileTypes) {
        const QStringList qmakeVariables = varNames(type);

        QStringList newFilePaths;
148 149 150 151 152 153 154 155 156 157 158
        foreach (const QString &qmakeVariable, qmakeVariables) {
            QStringList vPaths;
            if (type == ProjectExplorer::SourceType)
                vPaths = reader->absolutePathValues("VPATH_" + qmakeVariable, projectDir);
            vPaths += baseVPaths;
            if (type == ProjectExplorer::HeaderType)
                vPaths += reader->absolutePathValues("INCLUDEPATH", projectDir);
            vPaths.removeDuplicates();
            newFilePaths += reader->absoluteFileValues(qmakeVariable, projectDir, vPaths, includeFile);
        }
        newFilePaths.removeDuplicates();
con's avatar
con committed
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205

        QList<FileNode*> existingFileNodes;
        foreach (FileNode *fileNode, fileNodes()) {
            if (fileNode->fileType() == type && !fileNode->isGenerated())
                existingFileNodes << fileNode;
        }

        QList<FileNode*> toRemove;
        QList<FileNode*> toAdd;

        qSort(newFilePaths);
        qSort(existingFileNodes.begin(), existingFileNodes.end(), ProjectNode::sortNodesByPath);

        QList<FileNode*>::const_iterator existingNodeIter = existingFileNodes.constBegin();
        QList<QString>::const_iterator newPathIter = newFilePaths.constBegin();
        while (existingNodeIter != existingFileNodes.constEnd()
               && newPathIter != newFilePaths.constEnd()) {
            if ((*existingNodeIter)->path() < *newPathIter) {
                toRemove << *existingNodeIter;
                ++existingNodeIter;
            } else if ((*existingNodeIter)->path() > *newPathIter) {
                toAdd << new FileNode(*newPathIter, type, false);
                ++newPathIter;
            } else { // *existingNodeIter->path() == *newPathIter
                ++existingNodeIter;
                ++newPathIter;
            }
        }
        while (existingNodeIter != existingFileNodes.constEnd()) {
            toRemove << *existingNodeIter;
            ++existingNodeIter;
        }
        while (newPathIter != newFilePaths.constEnd()) {
            toAdd << new FileNode(*newPathIter, type, false);
            ++newPathIter;
        }

        if (!toRemove.isEmpty())
            removeFileNodes(toRemove, this);
        if (!toAdd.isEmpty())
            addFileNodes(toAdd, this);
    }
}

QList<ProjectNode::ProjectAction> Qt4PriFileNode::supportedActions() const
{
    QList<ProjectAction> actions;
206 207 208 209 210

    const FolderNode *folderNode = this;
    const Qt4ProFileNode *proFileNode;
    while (!(proFileNode = qobject_cast<const Qt4ProFileNode*>(folderNode)))
        folderNode = folderNode->parentFolderNode();
dt's avatar
dt committed
211
    Q_ASSERT(proFileNode);
212 213 214 215 216 217 218 219 220 221 222

    switch (proFileNode->projectType()) {
    case ApplicationTemplate:
    case LibraryTemplate:
        actions << AddFile << RemoveFile;
        break;
    case SubDirsTemplate:
        actions << AddSubProject << RemoveSubProject;
        break;
    default:
        break;
con's avatar
con committed
223 224 225 226 227 228
    }
    return actions;
}

bool Qt4PriFileNode::addSubProjects(const QStringList &proFilePaths)
{
229
    Q_UNUSED(proFilePaths)
230
    return false; //changeIncludes(m_includeFile, proFilePaths, AddToProFile);
con's avatar
con committed
231 232 233 234
}

bool Qt4PriFileNode::removeSubProjects(const QStringList &proFilePaths)
{
235
    Q_UNUSED(proFilePaths)
236
    return false; //changeIncludes(m_includeFile, proFilePaths, RemoveFromProFile);
con's avatar
con committed
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
}

bool Qt4PriFileNode::addFiles(const FileType fileType, const QStringList &filePaths,
                           QStringList *notAdded)
{
    QStringList failedFiles;

    changeFiles(fileType, filePaths, &failedFiles, AddToProFile);
    if (notAdded)
        *notAdded = failedFiles;
    return failedFiles.isEmpty();
}

bool Qt4PriFileNode::removeFiles(const FileType fileType, const QStringList &filePaths,
                              QStringList *notRemoved)
{
    QStringList failedFiles;
    changeFiles(fileType, filePaths, &failedFiles, RemoveFromProFile);
    if (notRemoved)
        *notRemoved = failedFiles;
    return failedFiles.isEmpty();
}

bool Qt4PriFileNode::renameFile(const FileType fileType, const QString &filePath,
                             const QString &newFilePath)
{
263
    if (newFilePath.isEmpty())
con's avatar
con committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
        return false;

    if (!QFile::rename(filePath, newFilePath))
        return false;

    QStringList dummy;
    changeFiles(fileType, QStringList() << filePath, &dummy, RemoveFromProFile);
    if (!dummy.isEmpty())
        return false;
    changeFiles(fileType, QStringList() << newFilePath, &dummy, AddToProFile);
    if (!dummy.isEmpty())
        return false;
    return true;
}

bool Qt4PriFileNode::changeIncludes(ProFile *includeFile, const QStringList &proFilePaths,
                                    ChangeType change)
{
282 283 284
    Q_UNUSED(includeFile)
    Q_UNUSED(proFilePaths)
    Q_UNUSED(change)
con's avatar
con committed
285 286 287 288 289 290 291
    // TODO
    return false;
}

bool Qt4PriFileNode::priFileWritable(const QString &path)
{
    const QString dir = QFileInfo(path).dir().path();
292
    Core::ICore *core = Core::ICore::instance();
293 294
    Core::IVersionControl *versionControl = core->vcsManager()->findVersionControlForDirectory(dir);
    switch (Core::EditorManager::promptReadOnlyFile(path, versionControl, core->mainWindow(), false)) {
295
    case Core::EditorManager::RO_OpenVCS:
con's avatar
con committed
296
        if (!versionControl->vcsOpen(path)) {
297
            QMessageBox::warning(core->mainWindow(), tr("Failed!"), tr("Could not open the file for edit with SCC."));
con's avatar
con committed
298 299 300
            return false;
        }
        break;
301
    case Core::EditorManager::RO_MakeWriteable: {
con's avatar
con committed
302 303
        const bool permsOk = QFile::setPermissions(path, QFile::permissions(path) | QFile::WriteUser);
        if (!permsOk) {
304
            QMessageBox::warning(core->mainWindow(), tr("Failed!"),  tr("Could not set permissions to writable."));
con's avatar
con committed
305 306 307 308
            return false;
        }
        break;
    }
309 310
    case Core::EditorManager::RO_SaveAs:
    case Core::EditorManager::RO_Cancel:
con's avatar
con committed
311 312 313 314 315 316 317 318 319 320
        return false;
    }
    return true;
}

bool Qt4PriFileNode::saveModifiedEditors(const QString &path)
{
    QList<Core::IFile*> allFileHandles;
    QList<Core::IFile*> modifiedFileHandles;

321
    Core::ICore *core = Core::ICore::instance();
322 323

    foreach (Core::IFile *file, core->fileManager()->managedFiles(path)) {
con's avatar
con committed
324 325 326
        allFileHandles << file;
    }

327
    foreach (Core::IEditor *editor, core->editorManager()->editorsForFileName(path)) {
con's avatar
con committed
328 329 330 331 332 333 334 335
        if (Core::IFile *editorFile = editor->file()) {
            if (editorFile->isModified())
                modifiedFileHandles << editorFile;
        }
    }

    if (!modifiedFileHandles.isEmpty()) {
        bool cancelled;
336
        core->fileManager()->saveModifiedFiles(modifiedFileHandles, &cancelled,
con's avatar
con committed
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
                                         tr("There are unsaved changes for project file %1.").arg(path));
        if (cancelled)
            return false;
        // force instant reload
        foreach (Core::IFile *fileHandle, allFileHandles) {
            Core::IFile::ReloadBehavior reload = Core::IFile::ReloadAll;
            fileHandle->modified(&reload);
        }
    }
    return true;
}

void Qt4PriFileNode::changeFiles(const FileType fileType,
                                 const QStringList &filePaths,
                                 QStringList *notChanged,
                                 ChangeType change)
{
    if (filePaths.isEmpty())
        return;

357 358 359 360 361 362 363 364
    ProFileReader *reader = m_qt4ProFileNode->createProFileReader();
    if (!reader->readProFile(m_qt4ProFileNode->path())) {
        m_project->proFileParseError(tr("Error while parsing file %1. Giving up.").arg(m_projectFilePath));
        delete reader;
        return;
    }

    ProFile *includeFile = reader->proFileFor(m_projectFilePath);
hjk's avatar
hjk committed
365
    if (!includeFile) {
366 367 368
        m_project->proFileParseError(tr("Error while changing pro file %1.").arg(m_projectFilePath));
    }

con's avatar
con committed
369 370 371 372 373 374 375 376
    *notChanged = filePaths;

    // Check for modified editors
    if (!saveModifiedEditors(m_projectFilePath))
        return;

    // Check if file is readonly
    ProEditorModel proModel;
377
    proModel.setProFiles(QList<ProFile*>() << includeFile);
con's avatar
con committed
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409

    const QStringList vars = varNames(fileType);
    QDir priFileDir = QDir(m_projectDir);

    if (change == AddToProFile) {
        // root item "<Global Scope>"
        const QModelIndex root = proModel.index(0, 0);

        // Check if variable item exists as child of root item
        ProVariable *proVar = 0;
        int row = 0;
        for (; row < proModel.rowCount(root); ++row) {
            if ((proVar = proModel.proVariable(root.child(row, 0)))) {
                if (vars.contains(proVar->variable())
                    && proVar->variableOperator() != ProVariable::RemoveOperator
                    && proVar->variableOperator() != ProVariable::ReplaceOperator)
                    break;
                else
                    proVar = 0;
            }
        }

        if (!proVar) {
            // Create & append new variable item

            // TODO: This will always store e.g. a source file in SOURCES and not OBJECTIVE_SOURCES
            proVar = new ProVariable(vars.first(), proModel.proBlock(root));
            proVar->setVariableOperator(ProVariable::AddOperator);
            proModel.insertItem(proVar, row, root);
        }
        const QModelIndex varIndex = root.child(row, 0);

410
        const QString &proFilePath = includeFile->fileName();
con's avatar
con committed
411
        foreach (const QString &filePath, filePaths) {
412 413
            if (filePath == proFilePath)
                continue;
con's avatar
con committed
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
            const QString &relativeFilePath = priFileDir.relativeFilePath(filePath);
            proModel.insertItem(new ProValue(relativeFilePath, proVar),
                                proModel.rowCount(varIndex), varIndex);
            notChanged->removeOne(filePath);
        }
    } else { // RemoveFromProFile
        QList<QModelIndex> proVarIndexes = proModel.findVariables(vars);
        QList<QModelIndex> toRemove;

        QStringList relativeFilePaths;
        foreach (const QString &absoluteFilePath, filePaths)
            relativeFilePaths << priFileDir.relativeFilePath(absoluteFilePath);

        foreach (const QModelIndex &proVarIndex, proVarIndexes) {
            ProVariable *proVar = proModel.proVariable(proVarIndex);

            if (proVar->variableOperator() != ProVariable::RemoveOperator
                && proVar->variableOperator() != ProVariable::ReplaceOperator) {

                for (int row = proModel.rowCount(proVarIndex) - 1; row >= 0; --row) {
                    QModelIndex itemIndex = proModel.index(row, 0, proVarIndex);
                    ProItem *item = proModel.proItem(itemIndex);

                    if (item->kind() == ProItem::ValueKind) {
                        ProValue *val = static_cast<ProValue *>(item);
                        int index = relativeFilePaths.indexOf(val->value());
                        if (index != -1) {
                            toRemove.append(itemIndex);
                            notChanged->removeAt(index);
                        }
                    }
                }
            }
        }

        foreach (const QModelIndex &index, toRemove) {
            proModel.removeItem(index);
        }
    }

    // save file
455 456
    save(includeFile);
    delete reader;
con's avatar
con committed
457 458
}

459
void Qt4PriFileNode::save(ProFile *includeFile)
con's avatar
con committed
460
{
461
    Core::ICore *core = Core::ICore::instance();
462 463
    Core::FileManager *fileManager = core->fileManager();
    QList<Core::IFile *> allFileHandles = fileManager->managedFiles(includeFile->fileName());
dt's avatar
dt committed
464
    Core::IFile *modifiedFileHandle = 0;
hjk's avatar
hjk committed
465
    foreach (Core::IFile *file, allFileHandles)
466
        if (file->fileName() == includeFile->fileName())
dt's avatar
dt committed
467 468 469 470 471
            modifiedFileHandle = file;

    if (modifiedFileHandle)
        fileManager->blockFileChange(modifiedFileHandle);
    ProWriter pw;
472
    const bool ok = pw.write(includeFile, includeFile->fileName());
473
    Q_UNUSED(ok)
474 475
    includeFile->setModified(false);
    m_project->qt4ProjectManager()->notifyChanged(includeFile->fileName());
dt's avatar
dt committed
476 477
    if (modifiedFileHandle)
        fileManager->unblockFileChange(modifiedFileHandle);
con's avatar
con committed
478 479 480

    Core::IFile::ReloadBehavior tempBehavior =
            Core::IFile::ReloadAll;
dt's avatar
dt committed
481
    foreach (Core::IFile *file, allFileHandles)
con's avatar
con committed
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
        file->modified(&tempBehavior);
}

/*
  Deletes all subprojects/files/virtual folders
  */
void Qt4PriFileNode::clear()
{
    // delete files && folders && projects
    if (!fileNodes().isEmpty())
        removeFileNodes(fileNodes(), this);
    if (!subProjectNodes().isEmpty())
        removeProjectNodes(subProjectNodes());
    if (!subFolderNodes().isEmpty())
        removeFolderNodes(subFolderNodes(), this);
}

QStringList Qt4PriFileNode::varNames(FileType type)
{
    QStringList vars;
    switch (type) {
    case ProjectExplorer::HeaderType:
        vars << QLatin1String("HEADERS");
        break;
    case ProjectExplorer::SourceType:
        vars << QLatin1String("SOURCES");
        vars << QLatin1String("OBJECTIVE_SOURCES");
509 510
        vars << QLatin1String("LEXSOURCES");
        vars << QLatin1String("YACCSOURCES");
con's avatar
con committed
511 512 513 514 515 516 517 518 519 520 521 522 523 524
        break;
    case ProjectExplorer::ResourceType:
        vars << QLatin1String("RESOURCES");
        break;
    case ProjectExplorer::FormType:
        vars << QLatin1String("FORMS");
        break;
    default:
        vars << QLatin1String("OTHER_FILES");
        break;
    }
    return vars;
}

525 526 527 528 529 530 531 532 533 534
Qt4PriFileNode *Qt4PriFileNode::findProFileFor(const QString &fileName)
{
    if (fileName == path())
        return this;
    foreach (ProjectNode *pn, subProjectNodes())
        if (Qt4PriFileNode *qt4PriFileNode = qobject_cast<Qt4PriFileNode *>(pn))
            if (Qt4PriFileNode *result = qt4PriFileNode->findProFileFor(fileName))
                return result;
    return 0;
}
535

con's avatar
con committed
536 537 538 539 540 541 542
/*!
  \class Qt4ProFileNode
  Implements abstract ProjectNode class
  */
Qt4ProFileNode::Qt4ProFileNode(Qt4Project *project,
                               const QString &filePath,
                               QObject *parent)
543
        : Qt4PriFileNode(project, this, filePath),
con's avatar
con committed
544
          // own stuff
545
          m_projectType(InvalidProject)
con's avatar
con committed
546 547 548 549
{
    if (parent)
        setParent(parent);

550 551 552
    m_updateTimer.setInterval(100);
    m_updateTimer.setSingleShot(true);

con's avatar
con committed
553 554
    connect(m_project, SIGNAL(activeBuildConfigurationChanged()),
            this, SLOT(update()));
555 556
    connect(&m_updateTimer, SIGNAL(timeout()),
            this, SLOT(update()));
557 558 559

    connect(ProjectExplorer::ProjectExplorerPlugin::instance()->buildManager(), SIGNAL(buildStateChanged(ProjectExplorer::Project*)),
            this, SLOT(buildStateChanged(ProjectExplorer::Project*)));
con's avatar
con committed
560 561
}

dt's avatar
dt committed
562 563
Qt4ProFileNode::~Qt4ProFileNode()
{
dt's avatar
dt committed
564 565 566 567 568 569 570 571
    CppTools::CppModelManagerInterface *modelManager
            = ExtensionSystem::PluginManager::instance()->getObject<CppTools::CppModelManagerInterface>();
    QMap<QString, Qt4UiCodeModelSupport *>::const_iterator it, end;
    end = m_uiCodeModelSupport.constEnd();
    for (it = m_uiCodeModelSupport.constBegin(); it != end; ++it) {
        modelManager->removeEditorSupport(it.value());
        delete it.value();
    }
dt's avatar
dt committed
572 573
}

574 575
void Qt4ProFileNode::buildStateChanged(ProjectExplorer::Project *project)
{
dt's avatar
dt committed
576 577 578 579
    if (project == m_project && !ProjectExplorer::ProjectExplorerPlugin::instance()->buildManager()->isBuilding(m_project)) {
        QStringList filesToUpdate = updateUiFiles();
        updateCodeModelSupportFromBuild(filesToUpdate);
    }
580 581
}

con's avatar
con committed
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
bool Qt4ProFileNode::hasTargets() const
{
    return (projectType() == ApplicationTemplate) || (projectType() == LibraryTemplate);
}

Qt4ProjectType Qt4ProFileNode::projectType() const
{
    return m_projectType;
}

QStringList Qt4ProFileNode::variableValue(const Qt4Variable var) const
{
    return m_varValues.value(var);
}

597 598 599 600 601
void Qt4ProFileNode::scheduleUpdate()
{
    m_updateTimer.start();
}

con's avatar
con committed
602 603
void Qt4ProFileNode::update()
{
604 605
    ProFileReader *reader = createProFileReader();
    if (!reader->readProFile(m_projectFilePath)) {
con's avatar
con committed
606
        m_project->proFileParseError(tr("Error while parsing file %1. Giving up.").arg(m_projectFilePath));
607
        delete reader;
con's avatar
con committed
608 609 610 611 612 613 614 615
        invalidate();
        return;
    }

    if (debug)
        qDebug() << "Qt4ProFileNode - updating files for file " << m_projectFilePath;

    Qt4ProjectType projectType = InvalidProject;
616
    switch (reader->templateType()) {
con's avatar
con committed
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
    case ProFileEvaluator::TT_Unknown:
    case ProFileEvaluator::TT_Application: {
        projectType = ApplicationTemplate;
        break;
    }
    case ProFileEvaluator::TT_Library: {
        projectType = LibraryTemplate;
        break;
    }
    case ProFileEvaluator::TT_Script: {
        projectType = ScriptTemplate;
        break;
    }
    case ProFileEvaluator::TT_Subdirs:
        projectType = SubDirsTemplate;
        break;
    }
    if (projectType != m_projectType) {
        Qt4ProjectType oldType = m_projectType;
        // probably all subfiles/projects have changed anyway ...
        clear();
        m_projectType = projectType;
        foreach (NodesWatcher *watcher, watchers())
            if (Qt4NodesWatcher *qt4Watcher = qobject_cast<Qt4NodesWatcher*>(watcher))
                emit qt4Watcher->projectTypeChanged(this, oldType, projectType);
    }

    //
    // Add/Remove pri files, sub projects
    //

    QList<ProjectNode*> existingProjectNodes = subProjectNodes();

    QList<QString> newProjectFiles;
    QHash<QString, ProFile*> includeFiles;
    ProFile *fileForCurrentProject = 0;
    {
        if (projectType == SubDirsTemplate) {
655
            foreach (const QString &subDirProject, subDirsPaths(reader))
con's avatar
con committed
656 657 658
                newProjectFiles << subDirProject;
        }

659
        foreach (ProFile *includeFile, reader->includeFiles()) {
con's avatar
con committed
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
            if (includeFile->fileName() == m_projectFilePath) { // this file
                fileForCurrentProject = includeFile;
            } else {
                newProjectFiles << includeFile->fileName();
                includeFiles.insert(includeFile->fileName(), includeFile);
            }
        }
    }

    qSort(existingProjectNodes.begin(), existingProjectNodes.end(),
          sortNodesByPath);
    qSort(newProjectFiles.begin(), newProjectFiles.end());

    QList<ProjectNode*> toAdd;
    QList<ProjectNode*> toRemove;

    QList<ProjectNode*>::const_iterator existingNodeIter = existingProjectNodes.constBegin();
    QList<QString>::const_iterator newProjectFileIter = newProjectFiles.constBegin();
    while (existingNodeIter != existingProjectNodes.constEnd()
               && newProjectFileIter != newProjectFiles.constEnd()) {
        if ((*existingNodeIter)->path() < *newProjectFileIter) {
            toRemove << *existingNodeIter;
            ++existingNodeIter;
        } else if ((*existingNodeIter)->path() > *newProjectFileIter) {
            if (ProFile *file = includeFiles.value(*newProjectFileIter)) {
                Qt4PriFileNode *priFileNode
686
                    = new Qt4PriFileNode(m_project, this,
con's avatar
con committed
687
                                         *newProjectFileIter);
688
                priFileNode->update(file, reader);
con's avatar
con committed
689 690 691 692 693 694 695 696
                toAdd << priFileNode;
            } else {
                toAdd << createSubProFileNode(*newProjectFileIter);
            }
            ++newProjectFileIter;
        } else { // *existingNodeIter->path() == *newProjectFileIter
             if (ProFile *file = includeFiles.value(*newProjectFileIter)) {
                Qt4PriFileNode *priFileNode = static_cast<Qt4PriFileNode*>(*existingNodeIter);
697
                priFileNode->update(file, reader);
con's avatar
con committed
698 699 700 701 702 703 704 705 706 707 708 709 710
            }

            ++existingNodeIter;
            ++newProjectFileIter;
        }
    }
    while (existingNodeIter != existingProjectNodes.constEnd()) {
        toRemove << *existingNodeIter;
        ++existingNodeIter;
    }
    while (newProjectFileIter != newProjectFiles.constEnd()) {
        if (ProFile *file = includeFiles.value(*newProjectFileIter)) {
            Qt4PriFileNode *priFileNode
711
                    = new Qt4PriFileNode(m_project, this,
con's avatar
con committed
712
                                         *newProjectFileIter);
713
            priFileNode->update(file, reader);
con's avatar
con committed
714 715 716 717 718 719 720 721 722 723 724 725
            toAdd << priFileNode;
        } else {
            toAdd << createSubProFileNode(*newProjectFileIter);
        }
        ++newProjectFileIter;
    }

    if (!toRemove.isEmpty())
        removeProjectNodes(toRemove);
    if (!toAdd.isEmpty())
        addProjectNodes(toAdd);

726
    Qt4PriFileNode::update(fileForCurrentProject, reader);
con's avatar
con committed
727 728 729

    // update other variables
    QHash<Qt4Variable, QStringList> newVarValues;
730

731 732 733 734
    newVarValues[DefinesVar] = reader->values(QLatin1String("DEFINES"));
    newVarValues[IncludePathVar] = includePaths(reader);
    newVarValues[UiDirVar] = uiDirPaths(reader);
    newVarValues[MocDirVar] = mocDirPaths(reader);
735
    newVarValues[PkgConfigVar] = reader->values(QLatin1String("PKGCONFIG"));
con's avatar
con committed
736 737 738 739 740 741 742 743

    if (m_varValues != newVarValues) {
        m_varValues = newVarValues;
        foreach (NodesWatcher *watcher, watchers())
            if (Qt4NodesWatcher *qt4Watcher = qobject_cast<Qt4NodesWatcher*>(watcher))
                emit qt4Watcher->variablesChanged(this, m_varValues, newVarValues);
    }

dt's avatar
dt committed
744
    createUiCodeModelSupport();
dt's avatar
dt committed
745
    updateUiFiles();
con's avatar
con committed
746 747 748 749

    foreach (NodesWatcher *watcher, watchers())
        if (Qt4NodesWatcher *qt4Watcher = qobject_cast<Qt4NodesWatcher*>(watcher))
            emit qt4Watcher->proFileUpdated(this);
750 751

    delete reader;
con's avatar
con committed
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
}

namespace {
    // find all ui files in project
    class FindUiFileNodesVisitor : public ProjectExplorer::NodesVisitor {
    public:
        void visitProjectNode(ProjectNode *projectNode)
        {
            visitFolderNode(projectNode);
        }
        void visitFolderNode(FolderNode *folderNode)
        {
            foreach (FileNode *fileNode, folderNode->fileNodes()) {
                if (fileNode->fileType() == ProjectExplorer::FormType)
                    uiFileNodes << fileNode;
            }
        }
        QList<FileNode*> uiFileNodes;
    };
}

773 774 775
// This function is triggered after a build, and updates the state ui files
// It does so by storing a modification time for each ui file we know about.

dt's avatar
dt committed
776
// TODO this function should also be called if the build directory is changed
dt's avatar
dt committed
777
QStringList Qt4ProFileNode::updateUiFiles()
con's avatar
con committed
778
{
dt's avatar
dt committed
779
//    qDebug()<<"Qt4ProFileNode::updateUiFiles()";
780
    // Only those two project types can have ui files for us
con's avatar
con committed
781 782
    if (m_projectType != ApplicationTemplate
        && m_projectType != LibraryTemplate)
dt's avatar
dt committed
783
        return QStringList();
con's avatar
con committed
784

785
    // Find all ui files
con's avatar
con committed
786 787 788 789
    FindUiFileNodesVisitor uiFilesVisitor;
    this->accept(&uiFilesVisitor);
    const QList<FileNode*> uiFiles = uiFilesVisitor.uiFileNodes;

790
    // Find the UiDir, there can only ever be one
791
    QString uiDir = buildDir();
792 793 794
    QStringList tmp = m_varValues[UiDirVar];
    if (tmp.size() != 0)
        uiDir = tmp.first();
con's avatar
con committed
795

796
    // Collect all existing generated files
con's avatar
con committed
797 798 799 800 801
    QList<FileNode*> existingFileNodes;
    foreach (FileNode *file, fileNodes()) {
        if (file->isGenerated())
            existingFileNodes << file;
    }
802 803

    // Convert uiFile to uiHeaderFilePath, find all headers that correspond
804
    // and try to find them in uiDir
con's avatar
con committed
805
    QStringList newFilePaths;
806 807
    foreach (FileNode *uiFile, uiFiles) {
        const QString uiHeaderFilePath
808
                = QString("%1/ui_%2.h").arg(uiDir, QFileInfo(uiFile->path()).completeBaseName());
809 810
        if (QFileInfo(uiHeaderFilePath).exists())
            newFilePaths << uiHeaderFilePath;
con's avatar
con committed
811 812
    }

813
    // Create a diff between those lists
con's avatar
con committed
814 815
    QList<FileNode*> toRemove;
    QList<FileNode*> toAdd;
816 817
    // The list of files for which we call updateSourceFile
    QStringList toUpdate;
con's avatar
con committed
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832

    qSort(newFilePaths);
    qSort(existingFileNodes.begin(), existingFileNodes.end(), ProjectNode::sortNodesByPath);

    QList<FileNode*>::const_iterator existingNodeIter = existingFileNodes.constBegin();
    QList<QString>::const_iterator newPathIter = newFilePaths.constBegin();
    while (existingNodeIter != existingFileNodes.constEnd()
           && newPathIter != newFilePaths.constEnd()) {
        if ((*existingNodeIter)->path() < *newPathIter) {
            toRemove << *existingNodeIter;
            ++existingNodeIter;
        } else if ((*existingNodeIter)->path() > *newPathIter) {
            toAdd << new FileNode(*newPathIter, ProjectExplorer::HeaderType, true);
            ++newPathIter;
        } else { // *existingNodeIter->path() == *newPathIter
833 834 835 836 837 838 839
            QString fileName = (*existingNodeIter)->path();
            QMap<QString, QDateTime>::const_iterator it = m_uitimestamps.find(fileName);
            QDateTime lastModified = QFileInfo(fileName).lastModified();
            if (it == m_uitimestamps.constEnd() || it.value() < lastModified) {
                toUpdate << fileName;
                m_uitimestamps[fileName] = lastModified;
            }
con's avatar
con committed
840 841 842 843 844 845 846 847 848 849 850 851 852
            ++existingNodeIter;
            ++newPathIter;
        }
    }
    while (existingNodeIter != existingFileNodes.constEnd()) {
        toRemove << *existingNodeIter;
        ++existingNodeIter;
    }
    while (newPathIter != newFilePaths.constEnd()) {
        toAdd << new FileNode(*newPathIter, ProjectExplorer::HeaderType, true);
        ++newPathIter;
    }

853
    // Update project tree
con's avatar
con committed
854 855
    if (!toRemove.isEmpty()) {
        foreach (FileNode *file, toRemove)
856
            m_uitimestamps.remove(file->path());
con's avatar
con committed
857 858
        removeFileNodes(toRemove, this);
    }
859 860 861 862

    CppTools::CppModelManagerInterface *modelManager =
        ExtensionSystem::PluginManager::instance()->getObject<CppTools::CppModelManagerInterface>();

con's avatar
con committed
863
    if (!toAdd.isEmpty()) {
864 865 866 867
        foreach (FileNode *file, toAdd) {
            m_uitimestamps.insert(file->path(), QFileInfo(file->path()).lastModified());
            toUpdate << file->path();

dt's avatar
dt committed
868 869
            // Also adding files depending on that
            // We only need to do that for files that were newly created
870 871 872 873 874 875 876 877
            QString fileName = QFileInfo(file->path()).fileName();
            foreach (CPlusPlus::Document::Ptr doc, modelManager->snapshot()) {
                if (doc->includedFiles().contains(fileName)) {
                    if (!toUpdate.contains(doc->fileName()))
                        toUpdate << doc->fileName();
                }
            }
        }
con's avatar
con committed
878 879
        addFileNodes(toAdd, this);
    }
dt's avatar
dt committed
880
    return toUpdate;
con's avatar
con committed
881 882
}

883
ProFileReader *Qt4PriFileNode::createProFileReader() const
con's avatar
con committed
884
{
dt's avatar
dt committed
885
    ProFileReader *reader = new ProFileReader();
886 887
    connect(reader, SIGNAL(errorFound(QString)),
            m_project, SLOT(proFileParseError(QString)));
con's avatar
con committed
888 889

    QtVersion *version = m_project->qtVersion(m_project->activeBuildConfiguration());
890
    if (version->isValid())
con's avatar
con committed
891 892
        reader->setQtVersion(version);

893
    reader->setOutputDir(m_qt4ProFileNode->buildDir());
con's avatar
con committed
894 895 896 897 898 899 900 901 902 903 904 905 906 907

    return reader;
}

Qt4ProFileNode *Qt4ProFileNode::createSubProFileNode(const QString &path)
{
    Qt4ProFileNode *subProFileNode = new Qt4ProFileNode(m_project, path);
    subProFileNode->update();
    return subProFileNode;
}

QStringList Qt4ProFileNode::uiDirPaths(ProFileReader *reader) const
{
    QStringList candidates = reader->absolutePathValues(QLatin1String("UI_DIR"),
908 909
                                                        buildDir());
    candidates.removeDuplicates();
con's avatar
con committed
910 911 912 913 914 915
    return candidates;
}

QStringList Qt4ProFileNode::mocDirPaths(ProFileReader *reader) const
{
    QStringList candidates = reader->absolutePathValues(QLatin1String("MOC_DIR"),
916 917
                                                        buildDir());
    candidates.removeDuplicates();
con's avatar
con committed
918 919 920 921 922 923 924
    return candidates;
}

QStringList Qt4ProFileNode::includePaths(ProFileReader *reader) const
{
    QStringList paths;
    paths = reader->absolutePathValues(QLatin1String("INCLUDEPATH"),
925
                                       m_projectDir);
con's avatar
con committed
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
    paths << uiDirPaths(reader) << mocDirPaths(reader);
    paths.removeDuplicates();
    return paths;
}

QStringList Qt4ProFileNode::subDirsPaths(ProFileReader *reader) const
{
    QStringList subProjectPaths;

    const QStringList subDirVars = reader->values(QLatin1String("SUBDIRS"));

    foreach (const QString &subDirVar, subDirVars) {
        // Special case were subdir is just an identifier:
        //   "SUBDIR = subid
        //    subid.subdir = realdir"
con's avatar
con committed
941 942 943
        // or
        //   "SUBDIR = subid
        //    subid.file = realdir/realfile.pro"
con's avatar
con committed
944 945 946

        QString realDir;
        const QString subDirKey = subDirVar + QLatin1String(".subdir");
con's avatar
con committed
947
        const QString subDirFileKey = subDirVar + QLatin1String(".file");
con's avatar
con committed
948
        if (reader->contains(subDirKey))
949
            realDir = QFileInfo(reader->value(subDirKey)).filePath();
con's avatar
con committed
950 951 952
        else if (reader->contains(subDirFileKey))
            realDir = QFileInfo(reader->value(subDirFileKey)).filePath();
        else
con's avatar
con committed
953 954
            realDir = subDirVar;
        QFileInfo info(realDir);
955 956
        if (!info.isAbsolute()) {
            info.setFile(m_projectDir + "/" + realDir);
957
            realDir = m_projectDir + "/" + realDir;
958
        }
con's avatar
con committed
959

960 961
        QString realFile;
        if (info.isDir()) {
con's avatar
con committed
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
            realFile = QString("%1/%2.pro").arg(realDir, info.fileName());
            if (!QFile::exists(realFile)) {
                // parse directory for pro files - if there is only one, use that
                QDir dir(realDir);
                QStringList files = dir.entryList(QStringList() << "*.pro", QDir::Files);
                if (files.size() == 1) {
                    realFile = QString("%1/%2").arg(realDir, files.first());
                } else {
                    m_project->proFileParseError(tr("Could not find .pro file for sub dir '%1' in '%2'")
                            .arg(subDirVar).arg(realDir));
                    realFile = QString::null;
                }
            }
        } else {
            realFile = realDir;
        }

        if (!realFile.isEmpty() && !subProjectPaths.contains(realFile))
            subProjectPaths << realFile;
    }

    return subProjectPaths;
}

QStringList Qt4ProFileNode::qBuildSubDirsPaths(const QString &scanDir) const
{
    QStringList subProjectPaths;

    // With QBuild we only look for project files named qbuild.pro
    QString realFile = scanDir + "/qbuild.pro";
    if (QFile::exists(realFile))
        subProjectPaths << realFile;

    // With QBuild 'subdirs' are implied
    QDir dir(scanDir);
    QStringList subDirs = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
    foreach (QString subDir, subDirs) {
        // 'tests' sub directories are an exception to the 'QBuild scans everything' rule.
        // Tests are only build with the 'make test' command, in which case QBuild WILL look
        // for a tests subdir and run everything in there.
        if (subDir != "tests")
            subProjectPaths += qBuildSubDirsPaths(scanDir + "/" + subDir);
    }

    return subProjectPaths;
}

1009
QString Qt4PriFileNode::buildDir() const
con's avatar
con committed
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
{
    const QDir srcDirRoot = QFileInfo(m_project->rootProjectNode()->path()).absoluteDir();
    const QString relativeDir = srcDirRoot.relativeFilePath(m_projectDir);
    return QDir(m_project->buildDirectory(m_project->activeBuildConfiguration())).absoluteFilePath(relativeDir);
}

/*
  Sets project type to InvalidProject & deletes all subprojects/files/virtual folders
  */
void Qt4ProFileNode::invalidate()
{
    if (m_projectType == InvalidProject)
        return;

    clear();

    // change project type
    Qt4ProjectType oldType = m_projectType;
    m_projectType = InvalidProject;


    foreach (NodesWatcher *watcher, watchers())
        if (Qt4NodesWatcher *qt4Watcher = qobject_cast<Qt4NodesWatcher*>(watcher))
            emit qt4Watcher->projectTypeChanged(this, oldType, InvalidProject);
}

dt's avatar
dt committed
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
void Qt4ProFileNode::updateCodeModelSupportFromBuild(const QStringList &files)
{
    foreach (const QString &file, files) {
        QMap<QString, Qt4UiCodeModelSupport *>::const_iterator it, end;
        end = m_uiCodeModelSupport.constEnd();
        for (it = m_uiCodeModelSupport.constBegin(); it != end; ++it) {
            if (it.value()->fileName() == file)
                it.value()->updateFromBuild();
        }
    }
}

void Qt4ProFileNode::updateCodeModelSupportFromEditor(const QString &uiFileName, Designer::Internal::FormWindowEditor *fw)
{
    QMap<QString, Qt4UiCodeModelSupport *>::const_iterator it;
    it = m_uiCodeModelSupport.constFind(uiFileName);
    if (it != m_uiCodeModelSupport.constEnd()) {
        it.value()->updateFromEditor(fw);
    }
    foreach (ProjectExplorer::ProjectNode *pro, subProjectNodes())
        if (Qt4ProFileNode *qt4proFileNode = qobject_cast<Qt4ProFileNode *>(pro))
            qt4proFileNode->updateCodeModelSupportFromEditor(uiFileName, fw);
}

void Qt4ProFileNode::createUiCodeModelSupport()
{
dt's avatar
dt committed
1062
//    qDebug()<<"creatUiCodeModelSupport()";
dt's avatar
dt committed
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
    CppTools::CppModelManagerInterface *modelManager
            = ExtensionSystem::PluginManager::instance()->getObject<CppTools::CppModelManagerInterface>();

    // First move all to
    QMap<QString, Qt4UiCodeModelSupport *> oldCodeModelSupport;
    oldCodeModelSupport = m_uiCodeModelSupport;
    m_uiCodeModelSupport.clear();

    // Only those two project types can have ui files for us
    if (m_projectType == ApplicationTemplate || m_projectType == LibraryTemplate) {
        // Find all ui files
        FindUiFileNodesVisitor uiFilesVisitor;
        this->accept(&uiFilesVisitor);
        const QList<FileNode*> uiFiles = uiFilesVisitor.uiFileNodes;

        // Find the UiDir, there can only ever be one
        QString uiDir = buildDir();
        QStringList tmp = m_varValues[UiDirVar];
        if (tmp.size() != 0)
            uiDir = tmp.first();

        foreach (FileNode *uiFile, uiFiles) {
1085
            QString uiHeaderFilePath
dt's avatar
dt committed
1086
                    = QString("%1/ui_%2.h").arg(uiDir, QFileInfo(uiFile->path()).completeBaseName());
1087
	    uiHeaderFilePath = QDir::cleanPath(uiHeaderFilePath);
dt's avatar
dt committed
1088

dt's avatar
dt committed
1089
//            qDebug()<<"code model support for "<<uiFile->path()<<" "<<uiHeaderFilePath;
dt's avatar
dt committed
1090 1091
            QMap<QString, Qt4UiCodeModelSupport *>::iterator it = oldCodeModelSupport.find(uiFile->path());
            if (it != oldCodeModelSupport.end()) {
dt's avatar
dt committed
1092
//                qDebug()<<"updated old codemodelsupport";
dt's avatar
dt committed
1093 1094 1095 1096 1097
                Qt4UiCodeModelSupport *cms = it.value();
                cms->setFileName(uiHeaderFilePath);
                m_uiCodeModelSupport.insert(it.key(), cms);
                oldCodeModelSupport.erase(it);
            } else {
dt's avatar
dt committed
1098
//                qDebug()<<"adding new codemodelsupport";
dt's avatar
dt committed
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
                Qt4UiCodeModelSupport *cms = new Qt4UiCodeModelSupport(modelManager, m_project, uiFile->path(), uiHeaderFilePath);
                m_uiCodeModelSupport.insert(uiFile->path(), cms);
                modelManager->addEditorSupport(cms);
            }
        }
    }
    // Remove old
    QMap<QString, Qt4UiCodeModelSupport *>::const_iterator it, end;
    end = oldCodeModelSupport.constEnd();
    for (it = oldCodeModelSupport.constBegin(); it!=end; ++it) {
        modelManager->removeEditorSupport(it.value());
        delete it.value();
    }
}
dt's avatar
dt committed
1113

con's avatar
con committed
1114 1115 1116 1117
Qt4NodesWatcher::Qt4NodesWatcher(QObject *parent)
        : NodesWatcher(parent)
{
}