Merge branch 'master' of git@scm.dev.nokia.troll.no:creator/mainline

src/plugins/cpptools/cppmodelmanager.cpp

@@ -988,13 +988,16 @@ void CppModelManager::parse(QFutureInterface<void> &future,
     Core::MimeType cSourceTy = db->findByType(QLatin1String("text/x-csrc"));
     Core::MimeType cppSourceTy = db->findByType(QLatin1String("text/x-c++src"));
 
+    Core::MimeType cHeaderTy = db->findByType(QLatin1String("text/x-hdr"));
+    Core::MimeType cppHeaderTy = db->findByType(QLatin1String("text/x-c++hdr"));
+
     foreach (const QString &file, files) {
         const QFileInfo fileInfo(file);
 
         if (cSourceTy.matchesFile(fileInfo) || cppSourceTy.matchesFile(fileInfo))
             sources.append(file);
 
-        else
+        else if (cHeaderTy.matchesFile(fileInfo) || cppHeaderTy.matchesFile(fileInfo))
             headers.append(file);
     }
 

src/plugins/cpptools/cpptoolsplugin.cpp

@@ -231,7 +231,7 @@ QString CppToolsPlugin::correspondingHeaderOrSourceI(const QString &fileName) co
         return QString();
 
     const QDir absoluteDir = fi.absoluteDir();
-    const QString baseName = fi.baseName();
+    const QString baseName = fi.completeBaseName();
     const QStringList suffixes = matchingCandidateSuffixes(mimeDatase, type);
 
     const QString privateHeaderSuffix = QLatin1String("_p");

src/plugins/genericprojectmanager/GenericProject.mimetypes.xml

+<?xml version="1.0"?>
+
+<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
+  <mime-type type="text/x-generic-project">
+    <sub-class-of type="text/plain"/>
+    <comment>Generic Qt Creator Project file</comment>
+    <glob pattern="*.creator"/>
+  </mime-type>
+
+  <mime-type type="application/vnd.nokia.qt.generic.files">
+    <sub-class-of type="text/plain"/>
+    <comment>Generic Project Files</comment>
+    <glob pattern="*.files"/>
+  </mime-type>
+
+  <mime-type type="application/vnd.nokia.qt.generic.includes">
+    <sub-class-of type="text/plain"/>
+    <comment>Generic Project Include Paths</comment>
+    <glob pattern="*.includes"/>
+  </mime-type>
+
+  <mime-type type="application/vnd.nokia.qt.generic.config">
+    <sub-class-of type="text/plain"/>
+    <comment>Generic Project Configuration File</comment>
+    <glob pattern="*.config"/>
+  </mime-type>
+
+</mime-info>

src/plugins/genericprojectmanager/GenericProjectManager.pluginspec

+<plugin name="GenericProjectManager" version="1.0.80" compatVersion="1.0.80">
+    <vendor>Nokia Corporation</vendor>
+    <copyright>(C) 2008-2009 Nokia Corporation</copyright>
+    <license>
+Commercial Usage
+
+Licensees holding valid Qt Commercial licenses may use this plugin 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.
+
+GNU Lesser General Public License Usage
+
+Alternatively, this plugin may be used under the terms of the GNU Lesser
+General Public License version 2.1 as published by the Free Software
+Foundation.  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.</license>
+    <description>Generic support</description>
+    <url>http://www.qtsoftware.com</url>
+    <dependencyList>
+        <dependency name="TextEditor" version="1.0.80"/>
+        <dependency name="ProjectExplorer" version="1.0.80"/>
+        <dependency name="CppTools" version="1.0.80"/>
+        <dependency name="CppEditor" version="1.0.80"/>
+        <dependency name="Help" version="1.0.80"/>
+    </dependencyList>
+</plugin>

src/plugins/genericprojectmanager/genericproject.cpp

+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact:  Qt Software Information (qt-info@nokia.com)
+**
+** Commercial Usage
+**
+** 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.
+**
+** GNU Lesser General Public License Usage
+**
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+**
+**************************************************************************/
+
+#include "genericproject.h"
+#include "genericprojectconstants.h"
+#include "genericprojectnodes.h"
+#include "makestep.h"
+
+#include <projectexplorer/projectexplorerconstants.h>
+#include <cpptools/cppmodelmanagerinterface.h>
+#include <extensionsystem/pluginmanager.h>
+#include <utils/qtcassert.h>
+#include <coreplugin/icore.h>
+
+#include <cpptools/cppmodelmanagerinterface.h>
+
+#include <QtCore/QtDebug>
+#include <QtCore/QDir>
+#include <QtCore/QSettings>
+#include <QtCore/QProcess>
+
+#include <QtGui/QFormLayout>
+#include <QtGui/QMainWindow>
+#include <QtGui/QComboBox>
+#include <QtGui/QStringListModel>
+#include <QtGui/QListWidget>
+#include <QtGui/QPushButton>
+
+using namespace GenericProjectManager;
+using namespace GenericProjectManager::Internal;
+
+////////////////////////////////////////////////////////////////////////////////////
+// GenericProject
+////////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+class ListModel: public QStringListModel
+{
+public:
+    ListModel(QObject *parent)
+        : QStringListModel(parent) {}
+
+    virtual ~ListModel() {}
+
+    virtual int rowCount(const QModelIndex &parent) const
+    { return 1 + QStringListModel::rowCount(parent); }
+
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const
+    { return QStringListModel::flags(index) | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled; }
+
+    virtual QModelIndex index(int row, int column, const QModelIndex &parent) const
+    {
+        if (row == stringList().size())
+            return createIndex(row, column);
+
+        return QStringListModel::index(row, column, parent);
+    }
+
+    virtual QVariant data(const QModelIndex &index, int role) const
+    {
+        if (role == Qt::DisplayRole || role == Qt::EditRole) {
+            if (index.row() == stringList().size())
+                return tr("<new>");
+        }
+
+        return QStringListModel::data(index, role);
+    }
+
+    virtual bool setData(const QModelIndex &index, const QVariant &value, int role)
+    {
+        if (role == Qt::EditRole && index.row() == stringList().size())
+            insertRow(index.row(), QModelIndex());
+
+        return QStringListModel::setData(index, value, role);
+    }
+};
+
+} // end of anonymous namespace
+
+GenericProject::GenericProject(Manager *manager, const QString &fileName)
+    : _manager(manager),
+      _fileName(fileName),
+      _toolChain(0)
+{
+    QFileInfo fileInfo(_fileName);
+    const QString projectBaseName = fileInfo.baseName();
+    QDir dir = fileInfo.dir();
+
+    _filesFileName    = QFileInfo(dir, projectBaseName + QLatin1String(".files")).absoluteFilePath();
+    _includesFileName = QFileInfo(dir, projectBaseName + QLatin1String(".includes")).absoluteFilePath();
+    _configFileName   = QFileInfo(dir, projectBaseName + QLatin1String(".config")).absoluteFilePath();
+
+    _file = new GenericProjectFile(this, fileName);
+    _rootNode = new GenericProjectNode(this, _file);
+
+    _manager->registerProject(this);
+}
+
+GenericProject::~GenericProject()
+{
+    _manager->unregisterProject(this);
+
+    delete _rootNode;
+    delete _toolChain;
+}
+
+QString GenericProject::filesFileName() const
+{ return _filesFileName; }
+
+QString GenericProject::includesFileName() const
+{ return _includesFileName; }
+
+QString GenericProject::configFileName() const
+{ return _configFileName; }
+
+QStringList GenericProject::readLines(const QString &absoluteFileName) const
+{
+    QStringList lines;
+
+    QFile file(absoluteFileName);
+    if (file.open(QFile::ReadOnly)) {
+        QTextStream stream(&file);
+
+        forever {
+            QString line = stream.readLine();
+            if (line.isNull())
+                break;
+
+            line = line.trimmed();
+            if (line.isEmpty())
+                continue;
+
+            lines.append(line);
+        }
+    }
+
+    return lines;
+}
+
+
+void GenericProject::parseProject()
+{
+    const QFileInfo projectFileInfo(_fileName);
+
+    QSettings projectInfo(_fileName, QSettings::IniFormat);
+
+    _files = convertToAbsoluteFiles(readLines(filesFileName()));
+    _files.removeDuplicates();
+
+    _projectIncludePaths = readLines(includesFileName());
+    _projectIncludePaths.removeDuplicates();
+
+    _generated = convertToAbsoluteFiles(projectInfo.value(QLatin1String("generated")).toStringList());
+
+    _defines.clear();
+
+    QFile configFn(configFileName());
+    if (configFn.open(QFile::ReadOnly))
+        _defines = configFn.readAll();
+
+    emit fileListChanged();
+}
+
+void GenericProject::refresh()
+{
+    parseProject();
+
+    _rootNode->refresh();
+
+    CppTools::CppModelManagerInterface *modelManager =
+        ExtensionSystem::PluginManager::instance()->getObject<CppTools::CppModelManagerInterface>();
+
+    if (_toolChain && modelManager) {
+        const QByteArray predefinedMacros = _toolChain->predefinedMacros();
+        const QList<ProjectExplorer::HeaderPath> systemHeaderPaths = _toolChain->systemHeaderPaths();
+
+        CppTools::CppModelManagerInterface::ProjectInfo pinfo = modelManager->projectInfo(this);
+        pinfo.defines = predefinedMacros;
+        pinfo.defines += '\n';
+        pinfo.defines += _defines;
+
+        QStringList allIncludePaths, allFrameworkPaths;
+
+        foreach (const ProjectExplorer::HeaderPath &headerPath, _toolChain->systemHeaderPaths()) {
+            if (headerPath.kind() == ProjectExplorer::HeaderPath::FrameworkHeaderPath)
+                allFrameworkPaths.append(headerPath.path());
+
+            else
+                allIncludePaths.append(headerPath.path());
+        }
+
+        allIncludePaths += this->allIncludePaths();
+
+        pinfo.frameworkPaths = allFrameworkPaths;
+        pinfo.includePaths = allIncludePaths;
+
+        // ### add _defines.
+        pinfo.sourceFiles = files();
+        pinfo.sourceFiles += generated();
+
+        modelManager->updateProjectInfo(pinfo);
+        modelManager->updateSourceFiles(pinfo.sourceFiles);
+    }
+}
+
+QStringList GenericProject::convertToAbsoluteFiles(const QStringList &paths) const
+{
+    const QDir projectDir(QFileInfo(_fileName).dir());
+    QStringList absolutePaths;
+    foreach (const QString &file, paths) {
+        QFileInfo fileInfo(projectDir, file);
+        absolutePaths.append(fileInfo.absoluteFilePath());
+    }
+    absolutePaths.removeDuplicates();
+    return absolutePaths;
+}
+
+QStringList GenericProject::allIncludePaths() const
+{
+    QStringList paths;
+    paths += _includePaths;
+    paths += _projectIncludePaths;
+    paths.removeDuplicates();
+    return paths;
+}
+
+QStringList GenericProject::projectIncludePaths() const
+{ return _projectIncludePaths; }
+
+QStringList GenericProject::files() const
+{ return _files; }
+
+QStringList GenericProject::generated() const
+{ return _generated; }
+
+QStringList GenericProject::includePaths() const
+{ return _includePaths; }
+
+void GenericProject::setIncludePaths(const QStringList &includePaths)
+{ _includePaths = includePaths; }
+
+QByteArray GenericProject::defines() const
+{ return _defines; }
+
+void GenericProject::setToolChainId(const QString &toolChainId)
+{
+    using namespace ProjectExplorer;
+
+    _toolChainId = toolChainId;
+
+    delete _toolChain;
+    _toolChain = 0;
+
+    if (toolChainId == QLatin1String("mingw")) {
+        const QLatin1String qmake_cxx("g++"); // ### FIXME
+        const QString mingwDirectory; // ### FIXME
+
+        _toolChain = ToolChain::createMinGWToolChain(qmake_cxx, mingwDirectory);
+
+    } else if (toolChainId == QLatin1String("msvc")) {
+        const QString msvcVersion; // ### FIXME
+        _toolChain = ToolChain::createMSVCToolChain(msvcVersion);
+
+    } else if (toolChainId == QLatin1String("wince")) {
+        const QString msvcVersion, wincePlatform; // ### FIXME
+        _toolChain = ToolChain::createWinCEToolChain(msvcVersion, wincePlatform);
+
+    } else if (toolChainId == QLatin1String("gcc") || toolChainId == QLatin1String("icc")) {
+        const QLatin1String qmake_cxx("g++"); // ### FIXME
+        _toolChain = ToolChain::createGccToolChain(qmake_cxx);
+    }
+}
+
+QString GenericProject::buildParser(const QString &buildConfiguration) const
+{
+    if (_toolChain) {
+        switch (_toolChain->type()) {
+        case ProjectExplorer::ToolChain::GCC:
+        case ProjectExplorer::ToolChain::LinuxICC:
+        case ProjectExplorer::ToolChain::MinGW:
+            return QLatin1String(ProjectExplorer::Constants::BUILD_PARSER_GCC);
+
+        case ProjectExplorer::ToolChain::MSVC:
+        case ProjectExplorer::ToolChain::WINCE:
+            return ProjectExplorer::Constants::BUILD_PARSER_MSVC;
+
+        default:
+            break;
+        } // switch
+    }
+
+    return QString();
+}
+
+QString GenericProject::toolChainId() const
+{ return _toolChainId; }
+
+QString GenericProject::name() const
+{
+    return _projectName;
+}
+
+Core::IFile *GenericProject::file() const
+{
+    return _file;
+}
+
+ProjectExplorer::IProjectManager *GenericProject::projectManager() const
+{
+    return _manager;
+}
+
+QList<ProjectExplorer::Project *> GenericProject::dependsOn()
+{
+    return QList<Project *>();
+}
+
+bool GenericProject::isApplication() const
+{
+    return true;
+}
+
+ProjectExplorer::Environment GenericProject::environment(const QString &) const
+{
+    return ProjectExplorer::Environment::systemEnvironment();
+}
+
+QString GenericProject::buildDirectory(const QString &buildConfiguration) const
+{
+    QString buildDirectory = value(buildConfiguration, "buildDirectory").toString();
+
+    if (buildDirectory.isEmpty()) {
+        QFileInfo fileInfo(_fileName);
+
+        buildDirectory = fileInfo.absolutePath();
+    }
+
+    return buildDirectory;
+}
+
+ProjectExplorer::BuildStepConfigWidget *GenericProject::createConfigWidget()
+{
+    return new GenericBuildSettingsWidget(this);
+}
+
+QList<ProjectExplorer::BuildStepConfigWidget*> GenericProject::subConfigWidgets()
+{
+    return QList<ProjectExplorer::BuildStepConfigWidget*>();
+}
+
+ void GenericProject::newBuildConfiguration(const QString &buildConfiguration)
+ {
+     makeStep()->setBuildTarget(buildConfiguration, "all", true);
+ }
+
+GenericProjectNode *GenericProject::rootProjectNode() const
+{
+    return _rootNode;
+}
+
+QStringList GenericProject::files(FilesMode fileMode) const
+{
+    return _files; // ### TODO: handle generated files here.
+}
+
+QStringList GenericProject::targets() const
+{
+    QStringList targets;
+    targets.append(QLatin1String("all"));
+    targets.append(QLatin1String("clean"));
+    return targets;
+}
+
+MakeStep *GenericProject::makeStep() const
+{
+    foreach (ProjectExplorer::BuildStep *bs, buildSteps()) {
+        if (MakeStep *ms = qobject_cast<MakeStep *>(bs))
+            return ms;
+    }
+
+    return 0;
+}
+
+void GenericProject::restoreSettingsImpl(ProjectExplorer::PersistentSettingsReader &reader)
+{
+    Project::restoreSettingsImpl(reader);
+
+    if (buildConfigurations().isEmpty()) {
+        MakeStep *makeStep = new MakeStep(this);
+        insertBuildStep(0, makeStep);
+
+        const QLatin1String all("all");
+
+        addBuildConfiguration(all);
+        setActiveBuildConfiguration(all);
+        makeStep->setBuildTarget(all, all, /* on = */ true);
+
+        const QLatin1String buildDirectory("buildDirectory");
+
+        const QFileInfo fileInfo(file()->fileName());
+        setValue(all, buildDirectory, fileInfo.absolutePath());
+    }
+
+    QString toolChainId = reader.restoreValue(QLatin1String("toolChain")).toString();
+    if (toolChainId.isEmpty())
+        toolChainId = QLatin1String("gcc");
+
+    setToolChainId(toolChainId.toLower()); // ### move
+
+    const QStringList userIncludePaths =
+            reader.restoreValue(QLatin1String("includePaths")).toStringList();
+
+    setIncludePaths(allIncludePaths());
+
+    parseProject();
+    refresh();
+}
+
+void GenericProject::saveSettingsImpl(ProjectExplorer::PersistentSettingsWriter &writer)
+{
+    Project::saveSettingsImpl(writer);
+
+    writer.saveValue(QLatin1String("toolChain"), _toolChainId);
+    writer.saveValue(QLatin1String("includePaths"), _includePaths);
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// GenericBuildSettingsWidget
+////////////////////////////////////////////////////////////////////////////////////
+GenericBuildSettingsWidget::GenericBuildSettingsWidget(GenericProject *project)
+    : _project(project)
+{
+    QFormLayout *fl = new QFormLayout(this);
+
+    // build directory
+    _pathChooser = new Core::Utils::PathChooser(this);
+    _pathChooser->setEnabled(true);
+    fl->addRow(tr("Build directory:"), _pathChooser);
+    connect(_pathChooser, SIGNAL(changed()), this, SLOT(buildDirectoryChanged()));
+
+    // tool chain
+    QComboBox *toolChainChooser = new QComboBox;
+    toolChainChooser->addItems(ProjectExplorer::ToolChain::supportedToolChains());
+    toolChainChooser->setCurrentIndex(toolChainChooser->findText(_project->toolChainId()));
+    fl->addRow(tr("Tool chain:"), toolChainChooser);
+    connect(toolChainChooser, SIGNAL(activated(QString)), _project, SLOT(setToolChainId(QString)));
+}
+
+GenericBuildSettingsWidget::~GenericBuildSettingsWidget()
+{ }
+
+QString GenericBuildSettingsWidget::displayName() const
+{ return tr("Generic Manager"); }
+
+void GenericBuildSettingsWidget::init(const QString &buildConfiguration)
+{
+    _buildConfiguration = buildConfiguration;
+    _pathChooser->setPath(_project->buildDirectory(buildConfiguration));
+}
+
+void GenericBuildSettingsWidget::buildDirectoryChanged()
+{
+    _project->setValue(_buildConfiguration, "buildDirectory", _pathChooser->path());
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// GenericProjectFile
+////////////////////////////////////////////////////////////////////////////////////
+GenericProjectFile::GenericProjectFile(GenericProject *parent, QString fileName)
+    : Core::IFile(parent),
+      _project(parent),
+      _fileName(fileName)
+{ }
+
+GenericProjectFile::~GenericProjectFile()
+{ }
+
+bool GenericProjectFile::save(const QString &)
+{