qt4nodes.cpp 38.9 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
26
** contact the sales department at http://www.qtsoftware.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 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 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

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

    // update files
    const QDir projectDir = QFileInfo(m_projectFilePath).dir();
    foreach (FileType type, fileTypes) {
        const QStringList qmakeVariables = varNames(type);

        QStringList newFilePaths;
        foreach (const QString &qmakeVariable, qmakeVariables)
            newFilePaths += reader->absolutePathValues(qmakeVariable, projectDir.path(), ProFileReader::ExistingFilePaths, includeFile);

        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;
190 191 192 193 194

    const FolderNode *folderNode = this;
    const Qt4ProFileNode *proFileNode;
    while (!(proFileNode = qobject_cast<const Qt4ProFileNode*>(folderNode)))
        folderNode = folderNode->parentFolderNode();
dt's avatar
dt committed
195
    Q_ASSERT(proFileNode);
196 197 198 199 200 201 202 203 204 205 206

    switch (proFileNode->projectType()) {
    case ApplicationTemplate:
    case LibraryTemplate:
        actions << AddFile << RemoveFile;
        break;
    case SubDirsTemplate:
        actions << AddSubProject << RemoveSubProject;
        break;
    default:
        break;
con's avatar
con committed
207 208 209 210 211 212
    }
    return actions;
}

bool Qt4PriFileNode::addSubProjects(const QStringList &proFilePaths)
{
213 214
    Q_UNUSED(proFilePaths);
    return false; //changeIncludes(m_includeFile, proFilePaths, AddToProFile);
con's avatar
con committed
215 216 217 218
}

bool Qt4PriFileNode::removeSubProjects(const QStringList &proFilePaths)
{
219 220
    Q_UNUSED(proFilePaths);
    return false; //changeIncludes(m_includeFile, proFilePaths, RemoveFromProFile);
con's avatar
con committed
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
}

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)
{
247
    if (newFilePath.isEmpty())
con's avatar
con committed
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
        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)
{
    Q_UNUSED(includeFile);
    Q_UNUSED(proFilePaths);
    Q_UNUSED(change);
    // TODO
    return false;
}

bool Qt4PriFileNode::priFileWritable(const QString &path)
{
    const QString dir = QFileInfo(path).dir().path();
276
    Core::ICore *core = Core::ICore::instance();
277 278
    Core::IVersionControl *versionControl = core->vcsManager()->findVersionControlForDirectory(dir);
    switch (Core::EditorManager::promptReadOnlyFile(path, versionControl, core->mainWindow(), false)) {
279
    case Core::EditorManager::RO_OpenVCS:
con's avatar
con committed
280
        if (!versionControl->vcsOpen(path)) {
281
            QMessageBox::warning(core->mainWindow(), tr("Failed!"), tr("Could not open the file for edit with SCC."));
con's avatar
con committed
282 283 284
            return false;
        }
        break;
285
    case Core::EditorManager::RO_MakeWriteable: {
con's avatar
con committed
286 287
        const bool permsOk = QFile::setPermissions(path, QFile::permissions(path) | QFile::WriteUser);
        if (!permsOk) {
288
            QMessageBox::warning(core->mainWindow(), tr("Failed!"),  tr("Could not set permissions to writable."));
con's avatar
con committed
289 290 291 292
            return false;
        }
        break;
    }
293 294
    case Core::EditorManager::RO_SaveAs:
    case Core::EditorManager::RO_Cancel:
con's avatar
con committed
295 296 297 298 299 300 301 302 303 304
        return false;
    }
    return true;
}

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

305
    Core::ICore *core = Core::ICore::instance();
306 307

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

311
    foreach (Core::IEditor *editor, core->editorManager()->editorsForFileName(path)) {
con's avatar
con committed
312 313 314 315 316 317 318 319
        if (Core::IFile *editorFile = editor->file()) {
            if (editorFile->isModified())
                modifiedFileHandles << editorFile;
        }
    }

    if (!modifiedFileHandles.isEmpty()) {
        bool cancelled;
320
        core->fileManager()->saveModifiedFiles(modifiedFileHandles, &cancelled,
con's avatar
con committed
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
                                         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;

341 342 343 344 345 346 347 348
    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
349
    if (!includeFile) {
350 351 352
        m_project->proFileParseError(tr("Error while changing pro file %1.").arg(m_projectFilePath));
    }

con's avatar
con committed
353 354 355 356 357 358 359 360
    *notChanged = filePaths;

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

    // Check if file is readonly
    ProEditorModel proModel;
361
    proModel.setProFiles(QList<ProFile*>() << includeFile);
con's avatar
con committed
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393

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

394
        const QString &proFilePath = includeFile->fileName();
con's avatar
con committed
395
        foreach (const QString &filePath, filePaths) {
396 397
            if (filePath == proFilePath)
                continue;
con's avatar
con committed
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 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
            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
439 440
    save(includeFile);
    delete reader;
con's avatar
con committed
441 442
}

443
void Qt4PriFileNode::save(ProFile *includeFile)
con's avatar
con committed
444
{
445
    Core::ICore *core = Core::ICore::instance();
446 447
    Core::FileManager *fileManager = core->fileManager();
    QList<Core::IFile *> allFileHandles = fileManager->managedFiles(includeFile->fileName());
dt's avatar
dt committed
448
    Core::IFile *modifiedFileHandle = 0;
hjk's avatar
hjk committed
449
    foreach (Core::IFile *file, allFileHandles)
450
        if (file->fileName() == includeFile->fileName())
dt's avatar
dt committed
451 452 453 454 455
            modifiedFileHandle = file;

    if (modifiedFileHandle)
        fileManager->blockFileChange(modifiedFileHandle);
    ProWriter pw;
456
    const bool ok = pw.write(includeFile, includeFile->fileName());
457
    Q_UNUSED(ok)
458 459
    includeFile->setModified(false);
    m_project->qt4ProjectManager()->notifyChanged(includeFile->fileName());
dt's avatar
dt committed
460 461
    if (modifiedFileHandle)
        fileManager->unblockFileChange(modifiedFileHandle);
con's avatar
con committed
462 463 464

    Core::IFile::ReloadBehavior tempBehavior =
            Core::IFile::ReloadAll;
dt's avatar
dt committed
465
    foreach (Core::IFile *file, allFileHandles)
con's avatar
con committed
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
        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");
493 494
        vars << QLatin1String("LEXSOURCES");
        vars << QLatin1String("YACCSOURCES");
con's avatar
con committed
495 496 497 498 499 500 501 502 503 504 505 506 507 508
        break;
    case ProjectExplorer::ResourceType:
        vars << QLatin1String("RESOURCES");
        break;
    case ProjectExplorer::FormType:
        vars << QLatin1String("FORMS");
        break;
    default:
        vars << QLatin1String("OTHER_FILES");
        break;
    }
    return vars;
}

509 510 511 512 513 514 515 516 517 518
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;
}
519

con's avatar
con committed
520 521 522 523 524 525 526
/*!
  \class Qt4ProFileNode
  Implements abstract ProjectNode class
  */
Qt4ProFileNode::Qt4ProFileNode(Qt4Project *project,
                               const QString &filePath,
                               QObject *parent)
527
        : Qt4PriFileNode(project, this, filePath),
con's avatar
con committed
528 529
          // own stuff
          m_projectType(InvalidProject),
530
          m_isQBuildProject(false)
con's avatar
con committed
531 532 533 534
{
    if (parent)
        setParent(parent);

535 536 537
    m_updateTimer.setInterval(100);
    m_updateTimer.setSingleShot(true);

con's avatar
con committed
538 539
    connect(m_project, SIGNAL(activeBuildConfigurationChanged()),
            this, SLOT(update()));
540 541
    connect(&m_updateTimer, SIGNAL(timeout()),
            this, SLOT(update()));
542 543 544

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

dt's avatar
dt committed
547 548
Qt4ProFileNode::~Qt4ProFileNode()
{
dt's avatar
dt committed
549 550 551 552 553 554 555 556
    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
557 558
}

559 560
void Qt4ProFileNode::buildStateChanged(ProjectExplorer::Project *project)
{
dt's avatar
dt committed
561 562 563 564
    if (project == m_project && !ProjectExplorer::ProjectExplorerPlugin::instance()->buildManager()->isBuilding(m_project)) {
        QStringList filesToUpdate = updateUiFiles();
        updateCodeModelSupportFromBuild(filesToUpdate);
    }
565 566
}

con's avatar
con committed
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
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);
}

582 583 584 585 586
void Qt4ProFileNode::scheduleUpdate()
{
    m_updateTimer.start();
}

con's avatar
con committed
587 588
void Qt4ProFileNode::update()
{
589 590
    ProFileReader *reader = createProFileReader();
    if (!reader->readProFile(m_projectFilePath)) {
con's avatar
con committed
591
        m_project->proFileParseError(tr("Error while parsing file %1. Giving up.").arg(m_projectFilePath));
592
        delete reader;
con's avatar
con committed
593 594 595 596 597 598 599 600 601 602 603 604 605 606
        invalidate();
        return;
    }

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

#ifdef QTEXTENDED_QBUILD_SUPPORT
    if (m_projectFilePath.endsWith("qbuild.pro")) {
        m_isQBuildProject = true;
    }
#endif

    Qt4ProjectType projectType = InvalidProject;
607
    switch (reader->templateType()) {
con's avatar
con committed
608 609 610 611 612 613 614 615 616 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
    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) {
646
            foreach (const QString &subDirProject, subDirsPaths(reader))
con's avatar
con committed
647 648 649
                newProjectFiles << subDirProject;
        }

650
        foreach (ProFile *includeFile, reader->includeFiles()) {
con's avatar
con committed
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
            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
677
                    = new Qt4PriFileNode(m_project, this,
con's avatar
con committed
678
                                         *newProjectFileIter);
679
                priFileNode->update(file, reader);
con's avatar
con committed
680 681 682 683 684 685 686 687
                toAdd << priFileNode;
            } else {
                toAdd << createSubProFileNode(*newProjectFileIter);
            }
            ++newProjectFileIter;
        } else { // *existingNodeIter->path() == *newProjectFileIter
             if (ProFile *file = includeFiles.value(*newProjectFileIter)) {
                Qt4PriFileNode *priFileNode = static_cast<Qt4PriFileNode*>(*existingNodeIter);
688
                priFileNode->update(file, reader);
con's avatar
con committed
689 690 691 692 693 694 695 696 697 698 699 700 701
            }

            ++existingNodeIter;
            ++newProjectFileIter;
        }
    }
    while (existingNodeIter != existingProjectNodes.constEnd()) {
        toRemove << *existingNodeIter;
        ++existingNodeIter;
    }
    while (newProjectFileIter != newProjectFiles.constEnd()) {
        if (ProFile *file = includeFiles.value(*newProjectFileIter)) {
            Qt4PriFileNode *priFileNode
702
                    = new Qt4PriFileNode(m_project, this,
con's avatar
con committed
703
                                         *newProjectFileIter);
704
            priFileNode->update(file, reader);
con's avatar
con committed
705 706 707 708 709 710 711 712 713 714 715 716
            toAdd << priFileNode;
        } else {
            toAdd << createSubProFileNode(*newProjectFileIter);
        }
        ++newProjectFileIter;
    }

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

717
    Qt4PriFileNode::update(fileForCurrentProject, reader);
con's avatar
con committed
718 719 720

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

722 723 724 725
    newVarValues[DefinesVar] = reader->values(QLatin1String("DEFINES"));
    newVarValues[IncludePathVar] = includePaths(reader);
    newVarValues[UiDirVar] = uiDirPaths(reader);
    newVarValues[MocDirVar] = mocDirPaths(reader);
726
    newVarValues[PkgConfigVar] = reader->values(QLatin1String("PKGCONFIG"));
con's avatar
con committed
727 728 729 730 731 732 733 734

    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
735
    createUiCodeModelSupport();
dt's avatar
dt committed
736
    updateUiFiles();
con's avatar
con committed
737 738 739 740

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

    delete reader;
con's avatar
con committed
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
}

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;
    };
}

764 765 766
// 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
767
// TODO this function should also be called if the build directory is changed
dt's avatar
dt committed
768
QStringList Qt4ProFileNode::updateUiFiles()
con's avatar
con committed
769
{
dt's avatar
dt committed
770
//    qDebug()<<"Qt4ProFileNode::updateUiFiles()";
771
    // Only those two project types can have ui files for us
con's avatar
con committed
772 773
    if (m_projectType != ApplicationTemplate
        && m_projectType != LibraryTemplate)
dt's avatar
dt committed
774
        return QStringList();
con's avatar
con committed
775

776
    // Find all ui files
con's avatar
con committed
777 778 779 780
    FindUiFileNodesVisitor uiFilesVisitor;
    this->accept(&uiFilesVisitor);
    const QList<FileNode*> uiFiles = uiFilesVisitor.uiFileNodes;

781
    // Find the UiDir, there can only ever be one
782
    QString uiDir = buildDir();
783 784 785
    QStringList tmp = m_varValues[UiDirVar];
    if (tmp.size() != 0)
        uiDir = tmp.first();
con's avatar
con committed
786

787
    // Collect all existing generated files
con's avatar
con committed
788 789 790 791 792
    QList<FileNode*> existingFileNodes;
    foreach (FileNode *file, fileNodes()) {
        if (file->isGenerated())
            existingFileNodes << file;
    }
793 794

    // Convert uiFile to uiHeaderFilePath, find all headers that correspond
795
    // and try to find them in uiDir
con's avatar
con committed
796
    QStringList newFilePaths;
797 798
    foreach (FileNode *uiFile, uiFiles) {
        const QString uiHeaderFilePath
799
                = QString("%1/ui_%2.h").arg(uiDir, QFileInfo(uiFile->path()).completeBaseName());
800 801
        if (QFileInfo(uiHeaderFilePath).exists())
            newFilePaths << uiHeaderFilePath;
con's avatar
con committed
802 803
    }

804
    // Create a diff between those lists
con's avatar
con committed
805 806
    QList<FileNode*> toRemove;
    QList<FileNode*> toAdd;
807 808
    // The list of files for which we call updateSourceFile
    QStringList toUpdate;
con's avatar
con committed
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823

    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
824 825 826 827 828 829 830
            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
831 832 833 834 835 836 837 838 839 840 841 842 843
            ++existingNodeIter;
            ++newPathIter;
        }
    }
    while (existingNodeIter != existingFileNodes.constEnd()) {
        toRemove << *existingNodeIter;
        ++existingNodeIter;
    }
    while (newPathIter != newFilePaths.constEnd()) {
        toAdd << new FileNode(*newPathIter, ProjectExplorer::HeaderType, true);
        ++newPathIter;
    }

844
    // Update project tree
con's avatar
con committed
845 846
    if (!toRemove.isEmpty()) {
        foreach (FileNode *file, toRemove)
847
            m_uitimestamps.remove(file->path());
con's avatar
con committed
848 849
        removeFileNodes(toRemove, this);
    }
850 851 852 853

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

con's avatar
con committed
854
    if (!toAdd.isEmpty()) {
855 856 857 858
        foreach (FileNode *file, toAdd) {
            m_uitimestamps.insert(file->path(), QFileInfo(file->path()).lastModified());
            toUpdate << file->path();

dt's avatar
dt committed
859 860
            // Also adding files depending on that
            // We only need to do that for files that were newly created
861 862 863 864 865 866 867 868
            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
869 870
        addFileNodes(toAdd, this);
    }
dt's avatar
dt committed
871
    return toUpdate;
con's avatar
con committed
872 873
}

874
ProFileReader *Qt4PriFileNode::createProFileReader() const
con's avatar
con committed
875
{
dt's avatar
dt committed
876
    ProFileReader *reader = new ProFileReader();
877 878
    connect(reader, SIGNAL(errorFound(QString)),
            m_project, SLOT(proFileParseError(QString)));
con's avatar
con committed
879 880

    QtVersion *version = m_project->qtVersion(m_project->activeBuildConfiguration());
881
    if (version->isValid())
con's avatar
con committed
882 883
        reader->setQtVersion(version);

884
    reader->setOutputDir(m_qt4ProFileNode->buildDir());
con's avatar
con committed
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932

    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"),
                                                        buildDir(),
                                                        ProFileReader::ExistingPaths);
    return candidates;
}

QStringList Qt4ProFileNode::mocDirPaths(ProFileReader *reader) const
{
    QStringList candidates = reader->absolutePathValues(QLatin1String("MOC_DIR"),
                                                        buildDir(),
                                                        ProFileReader::ExistingPaths);
    return candidates;
}

QStringList Qt4ProFileNode::includePaths(ProFileReader *reader) const
{
    QStringList paths;
    paths = reader->absolutePathValues(QLatin1String("INCLUDEPATH"),
                                       m_projectDir,
                                       ProFileReader::ExistingPaths);
    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
933 934 935
        // or
        //   "SUBDIR = subid
        //    subid.file = realdir/realfile.pro"
con's avatar
con committed
936 937 938 939

        QString realDir;
        QString realFile;
        const QString subDirKey = subDirVar + QLatin1String(".subdir");
con's avatar
con committed
940
        const QString subDirFileKey = subDirVar + QLatin1String(".file");
con's avatar
con committed
941
        if (reader->contains(subDirKey))
942
            realDir = QFileInfo(reader->value(subDirKey)).filePath();
con's avatar
con committed
943 944 945
        else if (reader->contains(subDirFileKey))
            realDir = QFileInfo(reader->value(subDirFileKey)).filePath();
        else
con's avatar
con committed
946 947 948
            realDir = subDirVar;
        QFileInfo info(realDir);
        if (!info.isAbsolute())
949
            realDir = m_projectDir + "/" + realDir;
con's avatar
con committed
950 951 952 953 954 955 956 957 958 959 960 961 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

#ifdef QTEXTENDED_QBUILD_SUPPORT
        // QBuild only uses project files named qbuild.pro, and subdirs are implied
        if (m_isQBuildProject)
            return qBuildSubDirsPaths(realDir);
#endif
        if (info.suffix().isEmpty() || info.isDir()) {
            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;
}

1004
QString Qt4PriFileNode::buildDir() const
con's avatar
con committed
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
{
    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
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
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
1057
//    qDebug()<<"creatUiCodeModelSupport()";
dt's avatar
dt committed
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
    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) {
1080
            QString uiHeaderFilePath
dt's avatar
dt committed
1081
                    = QString("%1/ui_%2.h").arg(uiDir, QFileInfo(uiFile->path()).completeBaseName());
1082
	    uiHeaderFilePath = QDir::cleanPath(uiHeaderFilePath);
dt's avatar
dt committed
1083

dt's avatar
dt committed
1084
//            qDebug()<<"code model support for "<<uiFile->path()<<" "<<uiHeaderFilePath;
dt's avatar
dt committed
1085 1086
            QMap<QString, Qt4UiCodeModelSupport *>::iterator it = oldCodeModelSupport.find(uiFile->path());
            if (it != oldCodeModelSupport.end()) {
dt's avatar
dt committed
1087
//                qDebug()<<"updated old codemodelsupport";
dt's avatar
dt committed
1088 1089 1090 1091 1092
                Qt4UiCodeModelSupport *cms = it.value();
                cms->setFileName(uiHeaderFilePath);
                m_uiCodeModelSupport.insert(it.key(), cms);
                oldCodeModelSupport.erase(it);
            } else {
dt's avatar
dt committed
1093
//                qDebug()<<"adding new codemodelsupport";
dt's avatar
dt committed
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
                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
1108

con's avatar
con committed
1109 1110 1111 1112
Qt4NodesWatcher::Qt4NodesWatcher(QObject *parent)
        : NodesWatcher(parent)
{
}