Merge remote-tracking branch 'origin/3.0'

Conflicts: src/plugins/qmakeprojectmanager/qmakeproject.cpp Change-Id: Id6ac9051d2564788bb180e5a99243d588312ae99
2013-10-30 13:34:46 +01:00
parent bcd704d7bf 88c647ce68
commit 0ddb6cac29
341 changed files with 3480 additions and 2241 deletions
--- a/src/plugins/android/android.qbs
+++ b/src/plugins/android/android.qbs
@@ -7,7 +7,7 @@ QtcPlugin {

    Depends { name: "Core" }
    Depends { name: "ProjectExplorer" }
-    Depends { name: "Qt4ProjectManager" }
+    Depends { name: "QmakeProjectManager" }
    Depends { name: "Debugger" }
    Depends { name: "QmlDebug" }
    Depends { name: "QtSupport" }
--- a/src/plugins/android/android_dependencies.pri
+++ b/src/plugins/android/android_dependencies.pri
@@ -3,7 +3,7 @@ QTC_PLUGIN_DEPENDS += \
    coreplugin \
    debugger \
    projectexplorer \
-    qt4projectmanager \
+    qmakeprojectmanager \
    qtsupport \
    texteditor \
    analyzerbase
--- a/src/plugins/android/androiddebugsupport.cpp
+++ b/src/plugins/android/androiddebugsupport.cpp
@@ -43,9 +43,9 @@

 #include <projectexplorer/target.h>
 #include <projectexplorer/toolchain.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
-#include <qt4projectmanager/qmakenodes.h>
-#include <qt4projectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeproject.h>
 #include <qtsupport/qtkitinformation.h>

 #include <QDir>
@@ -86,7 +86,7 @@ static QStringList qtSoPaths(QtSupport::BaseQtVersion *qtVersion)
 RunControl *AndroidDebugSupport::createDebugRunControl(AndroidRunConfiguration *runConfig, QString *errorMessage)
 {
    Target *target = runConfig->target();
-    Qt4Project *project = static_cast<Qt4Project *>(target->project());
+    QmakeProject *project = static_cast<QmakeProject *>(target->project());

    DebuggerStartParameters params;
    params.startMode = AttachToRemoteServer;
@@ -102,11 +102,11 @@ RunControl *AndroidDebugSupport::createDebugRunControl(AndroidRunConfiguration *
        params.debuggerCommand = DebuggerKitInformation::debuggerCommand(kit).toString();
        if (ToolChain *tc = ToolChainKitInformation::toolChain(kit))
            params.toolChainAbi = tc->targetAbi();
-        params.executable = project->rootQt4ProjectNode()->buildDir() + QLatin1String("/app_process");
+        params.executable = project->rootQmakeProjectNode()->buildDir() + QLatin1String("/app_process");
        params.remoteChannel = runConfig->remoteChannel();
        params.solibSearchPath.clear();
-        QList<Qt4ProFileNode *> nodes = project->allProFiles();
-        foreach (Qt4ProFileNode *node, nodes)
+        QList<QmakeProFileNode *> nodes = project->allProFiles();
+        foreach (QmakeProFileNode *node, nodes)
            if (node->projectType() == ApplicationTemplate)
                params.solibSearchPath.append(node->targetInformation().buildDir);
        QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(kit);
@@ -121,8 +121,8 @@ RunControl *AndroidDebugSupport::createDebugRunControl(AndroidRunConfiguration *
        params.remoteSetupNeeded = true;
        //TODO: Not sure if these are the right paths.
        params.projectSourceDirectory = project->projectDirectory();
-        params.projectSourceFiles = project->files(Qt4Project::ExcludeGeneratedFiles);
-        params.projectBuildDirectory = project->rootQt4ProjectNode()->buildDir();
+        params.projectSourceFiles = project->files(QmakeProject::ExcludeGeneratedFiles);
+        params.projectBuildDirectory = project->rootQmakeProjectNode()->buildDir();
    }

    DebuggerRunControl * const debuggerRunControl
--- a/src/plugins/android/androiddeployconfiguration.cpp
+++ b/src/plugins/android/androiddeployconfiguration.cpp
@@ -39,7 +39,7 @@
 #include <projectexplorer/target.h>
 #include <projectexplorer/toolchain.h>

-#include <qt4projectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakeproject.h>
 #include <qtsupport/qtkitinformation.h>
 #include <qtsupport/qtsupportconstants.h>

@@ -124,7 +124,7 @@ DeployConfiguration *AndroidDeployConfigurationFactory::clone(Target *parent, De
 QList<Core::Id> AndroidDeployConfigurationFactory::availableCreationIds(Target *parent) const
 {
    QList<Core::Id> ids;
-    if (!qobject_cast<QmakeProjectManager::Qt4Project *>(parent->project()))
+    if (!qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project()))
        return ids;

    if (!parent->project()->supportsKit(parent->kit()))
--- a/src/plugins/android/androiddeployqtstep.cpp
+++ b/src/plugins/android/androiddeployqtstep.cpp
@@ -45,9 +45,9 @@
 #include <projectexplorer/target.h>
 #include <projectexplorer/project.h>
 #include <qtsupport/qtkitinformation.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
 #include <QInputDialog>
 #include <QMessageBox>

@@ -188,8 +188,8 @@ bool AndroidDeployQtStep::init()
        m_serialNumber = info.serialNumber;
    }

-    QmakeProjectManager::Qt4BuildConfiguration *bc
-            = static_cast<QmakeProjectManager::Qt4BuildConfiguration *>(target()->activeBuildConfiguration());
+    QmakeProjectManager::QmakeBuildConfiguration *bc
+            = static_cast<QmakeProjectManager::QmakeBuildConfiguration *>(target()->activeBuildConfiguration());

    if (m_signPackage) {
        // check keystore and certificate passwords
@@ -345,11 +345,11 @@ void AndroidDeployQtStep::runCommand(const QString &program, const QStringList &

 void AndroidDeployQtStep::updateInputFile()
 {
-    QmakeProjectManager::Qt4Project *pro = static_cast<QmakeProjectManager::Qt4Project *>(project());
-    QList<QmakeProjectManager::Qt4ProFileNode *> nodes = pro->applicationProFiles();
+    QmakeProjectManager::QmakeProject *pro = static_cast<QmakeProjectManager::QmakeProject *>(project());
+    QList<QmakeProjectManager::QmakeProFileNode *> nodes = pro->applicationProFiles();

    QStringList inputFiles;
-    foreach (QmakeProjectManager::Qt4ProFileNode *node, nodes)
+    foreach (QmakeProjectManager::QmakeProFileNode *node, nodes)
        inputFiles << node->singleVariableValue(QmakeProjectManager::AndroidDeploySettingsFile);

    if (!inputFiles.contains(m_inputFile))
--- a/src/plugins/android/androiddeployqtwidget.cpp
+++ b/src/plugins/android/androiddeployqtwidget.cpp
@@ -38,9 +38,9 @@
 #include "androidextralibrarylistmodel.h"

 #include <projectexplorer/target.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>

 #include <QFileDialog>

@@ -135,7 +135,7 @@ AndroidDeployQtWidget::AndroidDeployQtWidget(AndroidDeployQtStep *step)
    connect(m_ui->createAndroidManifestButton, SIGNAL(clicked()),
            this, SLOT(createManifestButton()));

-    m_extraLibraryListModel = new AndroidExtraLibraryListModel(static_cast<QmakeProjectManager::Qt4Project *>(m_step->project()),
+    m_extraLibraryListModel = new AndroidExtraLibraryListModel(static_cast<QmakeProjectManager::QmakeProject *>(m_step->project()),
                                                               this);
    m_ui->androidExtraLibsListView->setModel(m_extraLibraryListModel);

@@ -156,8 +156,8 @@ AndroidDeployQtWidget::~AndroidDeployQtWidget()

 void AndroidDeployQtWidget::checkProjectTemplate()
 {
-    QmakeProjectManager::Qt4Project *project = static_cast<QmakeProjectManager::Qt4Project *>(m_step->project());
-    if (project->rootQt4ProjectNode()->projectType() == QmakeProjectManager::ApplicationTemplate)
+    QmakeProjectManager::QmakeProject *project = static_cast<QmakeProjectManager::QmakeProject *>(m_step->project());
+    if (project->rootQmakeProjectNode()->projectType() == QmakeProjectManager::ApplicationTemplate)
        m_ui->additionalLibrariesGroupBox->setEnabled(true);
    else
        m_ui->additionalLibrariesGroupBox->setEnabled(false);
@@ -171,9 +171,9 @@ void AndroidDeployQtWidget::createManifestButton()

 void AndroidDeployQtWidget::updateInputFileUi()
 {
-    QmakeProjectManager::Qt4Project *project
-            = static_cast<QmakeProjectManager::Qt4Project *>(m_step->project());
-    QList<QmakeProjectManager::Qt4ProFileNode *> nodes = project->applicationProFiles();
+    QmakeProjectManager::QmakeProject *project
+            = static_cast<QmakeProjectManager::QmakeProject *>(m_step->project());
+    QList<QmakeProjectManager::QmakeProFileNode *> nodes = project->applicationProFiles();
    int size = nodes.size();
    if (size == 0 || size == 1) {
        // there's nothing to select, e.g. before parsing
@@ -185,7 +185,7 @@ void AndroidDeployQtWidget::updateInputFileUi()
        m_ui->inputFileComboBox->setVisible(true);

        m_ui->inputFileComboBox->clear();
-        foreach (QmakeProjectManager::Qt4ProFileNode *node, nodes) {
+        foreach (QmakeProjectManager::QmakeProFileNode *node, nodes) {
            QString file = node->singleVariableValue(QmakeProjectManager::AndroidDeploySettingsFile);
            m_ui->inputFileComboBox->addItem(node->displayName(), file);
        }
@@ -325,8 +325,8 @@ void AndroidDeployQtWidget::activeBuildConfigurationChanged()
        disconnect(m_currentBuildConfiguration, SIGNAL(qmakeBuildConfigurationChanged()),
                   this, SLOT(updateSigningWarning()));
    updateSigningWarning();
-    QmakeProjectManager::Qt4BuildConfiguration *bc
-            = qobject_cast<QmakeProjectManager::Qt4BuildConfiguration *>(m_step->target()->activeBuildConfiguration());
+    QmakeProjectManager::QmakeBuildConfiguration *bc
+            = qobject_cast<QmakeProjectManager::QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration());
    m_currentBuildConfiguration = bc;
    if (bc)
        connect(bc, SIGNAL(qmakeBuildConfigurationChanged()), this, SLOT(updateSigningWarning()));
@@ -335,7 +335,7 @@ void AndroidDeployQtWidget::activeBuildConfigurationChanged()

 void AndroidDeployQtWidget::updateSigningWarning()
 {
-    QmakeProjectManager::Qt4BuildConfiguration *bc = qobject_cast<QmakeProjectManager::Qt4BuildConfiguration *>(m_step->target()->activeBuildConfiguration());
+    QmakeProjectManager::QmakeBuildConfiguration *bc = qobject_cast<QmakeProjectManager::QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration());
    bool debug = bc && (bc->qmakeBuildConfiguration() & QtSupport::BaseQtVersion::DebugBuild);
    if (m_step->signPackage() && debug) {
        m_ui->signingDebugWarningIcon->setVisible(true);
--- a/src/plugins/android/androiddeployqtwidget.h
+++ b/src/plugins/android/androiddeployqtwidget.h
@@ -38,7 +38,7 @@ QT_BEGIN_NAMESPACE
 namespace Ui { class AndroidDeployQtWidget; }
 QT_END_NAMESPACE

-namespace QmakeProjectManager { class Qt4BuildConfiguration; }
+namespace QmakeProjectManager { class QmakeBuildConfiguration; }

 namespace Android {
 namespace Internal {
@@ -85,7 +85,7 @@ private:
    Ui::AndroidDeployQtWidget *m_ui;
    AndroidDeployQtStep *m_step;
    AndroidExtraLibraryListModel *m_extraLibraryListModel;
-    QmakeProjectManager::Qt4BuildConfiguration *m_currentBuildConfiguration;
+    QmakeProjectManager::QmakeBuildConfiguration *m_currentBuildConfiguration;
    bool m_ignoreChange;
 };

--- a/src/plugins/android/androiddeploystep.cpp
+++ b/src/plugins/android/androiddeploystep.cpp
@@ -44,9 +44,9 @@
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/buildsteplist.h>
 #include <projectexplorer/target.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>

 #include <qtsupport/qtkitinformation.h>

@@ -117,7 +117,7 @@ bool AndroidDeployStep::init()
    if (!version)
        return false;

-    const Qt4BuildConfiguration *bc = static_cast<Qt4BuildConfiguration *>(target()->activeBuildConfiguration());
+    const QmakeBuildConfiguration *bc = static_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration());
    if (!bc)
        return false;

@@ -134,7 +134,7 @@ bool AndroidDeployStep::init()
    m_androidDirPath = AndroidManager::dirPath(target());
    m_apkPathDebug = AndroidManager::apkPath(target(), AndroidManager::DebugBuild).toString();
    m_apkPathRelease = AndroidManager::apkPath(target(), AndroidManager::ReleaseBuildSigned).toString();
-    m_buildDirectory = static_cast<Qt4Project *>(target()->project())->rootQt4ProjectNode()->buildDir();
+    m_buildDirectory = static_cast<QmakeProject *>(target()->project())->rootQmakeProjectNode()->buildDir();
    m_runDeployAction = m_deployAction;
    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit());
    if (!tc || tc->type() != QLatin1String(Constants::ANDROID_TOOLCHAIN_TYPE)) {
@@ -143,7 +143,7 @@ bool AndroidDeployStep::init()
    }
    m_ndkToolChainVersion = static_cast<AndroidToolChain *>(tc)->ndkToolChainVersion();

-    QString arch = static_cast<Qt4Project *>(project())->rootQt4ProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);
+    QString arch = static_cast<QmakeProject *>(project())->rootQmakeProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);
    if (!arch.isEmpty())
        m_libgnustl = AndroidManager::libGnuStl(arch, m_ndkToolChainVersion);
    return true;
--- a/src/plugins/android/androidextralibrarylistmodel.cpp
+++ b/src/plugins/android/androidextralibrarylistmodel.cpp
@@ -29,13 +29,13 @@
 ****************************************************************************/

 #include "androidextralibrarylistmodel.h"
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>

 using namespace Android;
 using namespace Internal;

-AndroidExtraLibraryListModel::AndroidExtraLibraryListModel(QmakeProjectManager::Qt4Project *project,
+AndroidExtraLibraryListModel::AndroidExtraLibraryListModel(QmakeProjectManager::QmakeProject *project,
                                                           QObject *parent)
    : QAbstractItemModel(parent)
    , m_project(project)
@@ -77,18 +77,18 @@ QVariant AndroidExtraLibraryListModel::data(const QModelIndex &index, int role)

 void AndroidExtraLibraryListModel::reset()
 {
-    if (m_project->rootQt4ProjectNode()->projectType() != QmakeProjectManager::ApplicationTemplate)
+    if (m_project->rootQmakeProjectNode()->projectType() != QmakeProjectManager::ApplicationTemplate)
        return;

    beginResetModel();
-    QmakeProjectManager::Qt4ProFileNode *node = m_project->rootQt4ProjectNode();
+    QmakeProjectManager::QmakeProFileNode *node = m_project->rootQmakeProjectNode();
    m_entries = node->variableValue(QmakeProjectManager::AndroidExtraLibs);
    endResetModel();
 }

 void AndroidExtraLibraryListModel::addEntries(const QStringList &list)
 {
-    if (m_project->rootQt4ProjectNode()->projectType() != QmakeProjectManager::ApplicationTemplate)
+    if (m_project->rootQmakeProjectNode()->projectType() != QmakeProjectManager::ApplicationTemplate)
        return;

    beginInsertRows(QModelIndex(), m_entries.size(), m_entries.size() + list.size());
@@ -96,7 +96,7 @@ void AndroidExtraLibraryListModel::addEntries(const QStringList &list)
    foreach (QString path, list)
        m_entries += QDir(m_project->projectDirectory()).relativeFilePath(path);

-    QmakeProjectManager::Qt4ProFileNode *node = m_project->rootQt4ProjectNode();
+    QmakeProjectManager::QmakeProFileNode *node = m_project->rootQmakeProjectNode();
    node->setProVariable(QLatin1String("ANDROID_EXTRA_LIBS"), m_entries.join(QLatin1String(" ")));

    endInsertRows();
@@ -109,7 +109,7 @@ bool greaterModelIndexByRow(const QModelIndex &a, const QModelIndex &b)

 void AndroidExtraLibraryListModel::removeEntries(QModelIndexList list)
 {
-    if (list.isEmpty() || m_project->rootQt4ProjectNode()->projectType() != QmakeProjectManager::ApplicationTemplate)
+    if (list.isEmpty() || m_project->rootQmakeProjectNode()->projectType() != QmakeProjectManager::ApplicationTemplate)
        return;

    std::sort(list.begin(), list.end(), greaterModelIndexByRow);
@@ -128,6 +128,6 @@ void AndroidExtraLibraryListModel::removeEntries(QModelIndexList list)
        endRemoveRows();
    }

-    QmakeProjectManager::Qt4ProFileNode *node = m_project->rootQt4ProjectNode();
+    QmakeProjectManager::QmakeProFileNode *node = m_project->rootQmakeProjectNode();
    node->setProVariable(QLatin1String("ANDROID_EXTRA_LIBS"), m_entries.join(QLatin1String(" ")));
 }
--- a/src/plugins/android/androidextralibrarylistmodel.h
+++ b/src/plugins/android/androidextralibrarylistmodel.h
@@ -34,7 +34,7 @@
 #include <QAbstractItemModel>
 #include <QStringList>

-namespace QmakeProjectManager { class Qt4Project; }
+namespace QmakeProjectManager { class QmakeProject; }

 namespace Android {
 namespace Internal {
@@ -42,7 +42,7 @@ class AndroidExtraLibraryListModel : public QAbstractItemModel
 {
    Q_OBJECT
 public:
-    explicit AndroidExtraLibraryListModel(QmakeProjectManager::Qt4Project *project,
+    explicit AndroidExtraLibraryListModel(QmakeProjectManager::QmakeProject *project,
                                          QObject *parent = 0);

    QModelIndex index(int row, int column, const QModelIndex &parent) const;
@@ -58,7 +58,7 @@ private slots:
    void reset();

 private:
-    QmakeProjectManager::Qt4Project *m_project;
+    QmakeProjectManager::QmakeProject *m_project;
    QStringList m_entries;
 };

--- a/src/plugins/android/androidmanager.cpp
+++ b/src/plugins/android/androidmanager.cpp
@@ -42,10 +42,10 @@
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/session.h>
 #include <projectexplorer/target.h>
-#include <qt4projectmanager/qmakenodes.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakeprojectmanagerconstants.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
 #include <qtsupport/customexecutablerunconfiguration.h>
 #include <qtsupport/qtkitinformation.h>
 #include <qtsupport/qtsupportconstants.h>
@@ -127,7 +127,7 @@ namespace Internal {

 bool AndroidManager::supportsAndroid(ProjectExplorer::Target *target)
 {
-    if (!qobject_cast<QmakeProjectManager::Qt4Project *>(target->project()))
+    if (!qobject_cast<QmakeProjectManager::QmakeProject *>(target->project()))
        return false;
    QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target->kit());
    return version && version->platformName() == QLatin1String(QtSupport::Constants::ANDROID_PLATFORM);
@@ -259,10 +259,10 @@ bool AndroidManager::setBuildTargetSDK(ProjectExplorer::Target *target, const QS

 QString AndroidManager::targetArch(ProjectExplorer::Target *target)
 {
-    QmakeProjectManager::Qt4Project *pro = qobject_cast<QmakeProjectManager::Qt4Project *>(target->project());
+    QmakeProjectManager::QmakeProject *pro = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
    if (!pro)
        return QString();
-    QmakeProjectManager::Qt4ProFileNode *node = pro->rootQt4ProjectNode();
+    QmakeProjectManager::QmakeProFileNode *node = pro->rootQmakeProjectNode();
    if (!node)
        return QString();
    return node->singleVariableValue(QmakeProjectManager::AndroidArchVar);
@@ -330,10 +330,10 @@ Utils::FileName AndroidManager::apkPath(ProjectExplorer::Target *target, BuildTy
 QStringList AndroidManager::availableTargetApplications(ProjectExplorer::Target *target)
 {
    QStringList apps;
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(target->project());
-    if (!qt4Project)
+    QmakeProjectManager::QmakeProject *qmakeProject = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
+    if (!qmakeProject)
        return apps;
-    foreach (QmakeProjectManager::Qt4ProFileNode *proFile, qt4Project->applicationProFiles()) {
+    foreach (QmakeProjectManager::QmakeProFileNode *proFile, qmakeProject->applicationProFiles()) {
        if (proFile->projectType() == QmakeProjectManager::ApplicationTemplate) {
            if (proFile->targetInformation().target.startsWith(QLatin1String("lib"))
                    && proFile->targetInformation().target.endsWith(QLatin1String(".so")))
@@ -509,8 +509,8 @@ QString AndroidManager::targetApplicationPath(ProjectExplorer::Target *target)
    QString selectedApp = targetApplication(target);
    if (selectedApp.isEmpty())
        return QString();
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(target->project());
-    foreach (QmakeProjectManager::Qt4ProFileNode *proFile, qt4Project->applicationProFiles()) {
+    QmakeProjectManager::QmakeProject *qmakeProject = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
+    foreach (QmakeProjectManager::QmakeProFileNode *proFile, qmakeProject->applicationProFiles()) {
        if (proFile->projectType() == QmakeProjectManager::ApplicationTemplate) {
            if (proFile->targetInformation().target.startsWith(QLatin1String("lib"))
                    && proFile->targetInformation().target.endsWith(QLatin1String(".so"))) {
@@ -529,8 +529,8 @@ QString AndroidManager::targetApplicationPath(ProjectExplorer::Target *target)
 bool AndroidManager::createAndroidTemplatesIfNecessary(ProjectExplorer::Target *target)
 {
    QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target->kit());
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project*>(target->project());
-    if (!qt4Project || !qt4Project->rootProjectNode() || !version)
+    QmakeProjectManager::QmakeProject *qmakeProject = qobject_cast<QmakeProjectManager::QmakeProject*>(target->project());
+    if (!qmakeProject || !qmakeProject->rootProjectNode() || !version)
        return false;

    // TODO we should create the AndroidManifest.xml file for that version
@@ -540,7 +540,7 @@ bool AndroidManager::createAndroidTemplatesIfNecessary(ProjectExplorer::Target *
    Utils::FileName javaSrcPath
            = Utils::FileName::fromString(version->qmakeProperty("QT_INSTALL_PREFIX"))
            .appendPath(QLatin1String("src/android/java"));
-    QDir projectDir(qt4Project->projectDirectory());
+    QDir projectDir(qmakeProject->projectDirectory());
    Utils::FileName androidPath = dirPath(target);

    QStringList m_ignoreFiles;
@@ -607,7 +607,7 @@ bool AndroidManager::createAndroidTemplatesIfNecessary(ProjectExplorer::Target *
        }
    }
    if (!androidFiles.isEmpty())
-        qt4Project->rootProjectNode()->addFiles(androidFiles);
+        qmakeProject->rootProjectNode()->addFiles(androidFiles);

    int minApiLevel = 4;
    if (QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(target->kit()))
@@ -804,17 +804,17 @@ QVector<AndroidManager::Library> AndroidManager::availableQtLibsWithDependencies
    if (tc->type() != QLatin1String(Constants::ANDROID_TOOLCHAIN_TYPE))
        return QVector<AndroidManager::Library>();

-    QmakeProjectManager::Qt4Project *project = static_cast<QmakeProjectManager::Qt4Project *>(target->project());
-    QString arch = project->rootQt4ProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);
+    QmakeProjectManager::QmakeProject *project = static_cast<QmakeProjectManager::QmakeProject *>(target->project());
+    QString arch = project->rootQmakeProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);

    AndroidToolChain *atc = static_cast<AndroidToolChain *>(tc);
    QString libgnustl = libGnuStl(arch, atc->ndkToolChainVersion());

    Utils::FileName readelfPath = AndroidConfigurations::instance().readelfPath(target->activeRunConfiguration()->abi().architecture(),
                                                                                atc->ndkToolChainVersion());
-    const QmakeProjectManager::Qt4Project *const qt4Project
-            = qobject_cast<const QmakeProjectManager::Qt4Project *>(target->project());
-    if (!qt4Project || !version)
+    const QmakeProjectManager::QmakeProject *const qmakeProject
+            = qobject_cast<const QmakeProjectManager::QmakeProject *>(target->project());
+    if (!qmakeProject || !version)
        return QVector<AndroidManager::Library>();
    QString qtLibsPath = version->qmakeProperty("QT_INSTALL_LIBS");
    if (!readelfPath.toFileInfo().exists()) {
@@ -904,11 +904,11 @@ bool AndroidManager::setBundledInLib(ProjectExplorer::Target *target, const QStr
 QStringList AndroidManager::availablePrebundledLibs(ProjectExplorer::Target *target)
 {
    QStringList libs;
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(target->project());
-    if (!qt4Project)
+    QmakeProjectManager::QmakeProject *qmakeProject = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
+    if (!qmakeProject)
        return libs;

-    foreach (QmakeProjectManager::Qt4ProFileNode *node, qt4Project->allProFiles())
+    foreach (QmakeProjectManager::QmakeProFileNode *node, qmakeProject->allProFiles())
        if (node->projectType() == QmakeProjectManager::LibraryTemplate)
            libs << node->targetInformation().target;
    return libs;
--- a/src/plugins/android/androidmanifesteditorwidget.cpp
+++ b/src/plugins/android/androidmanifesteditorwidget.cpp
@@ -44,7 +44,7 @@
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/kitinformation.h>
 #include <texteditor/texteditoractionhandler.h>
-#include <qt4projectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakeproject.h>

 #include <QLineEdit>
 #include <QFileInfo>
--- a/src/plugins/android/androidpackagecreationstep.cpp
+++ b/src/plugins/android/androidpackagecreationstep.cpp
@@ -42,9 +42,9 @@
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/runconfiguration.h>
 #include <projectexplorer/target.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
 #include <qtsupport/qtkitinformation.h>

 #include <coreplugin/icore.h>
@@ -98,18 +98,18 @@ void AndroidPackageCreationStep::ctor()

 bool AndroidPackageCreationStep::init()
 {
-    const Qt4BuildConfiguration *bc = qobject_cast<Qt4BuildConfiguration *>(target()->activeBuildConfiguration());
+    const QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration());
    if (!bc) {
        raiseError(tr("Cannot create Android package: current build configuration is not Qt 4."));
        return false;
    }
-    Qt4Project *project = static_cast<Qt4Project *>(target()->project());
+    QmakeProject *project = static_cast<QmakeProject *>(target()->project());
    m_outputParser.setProjectFileList(project->files(Project::AllFiles));

    // Copying
    m_androidDir = AndroidManager::dirPath(target());
    Utils::FileName path = m_androidDir;
-    QString androidTargetArch = project->rootQt4ProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);
+    QString androidTargetArch = project->rootQmakeProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);
    if (androidTargetArch.isEmpty()) {
        raiseError(tr("Cannot create Android package: No ANDROID_TARGET_ARCH set in make spec."));
        return false;
@@ -434,8 +434,8 @@ void AndroidPackageCreationStep::collectFiles(QList<DeployItem> *deployList,
    if (!version)
        return;

-    Qt4Project *project = static_cast<Qt4Project *>(target()->project());
-    QString androidTargetArch = project->rootQt4ProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);
+    QmakeProject *project = static_cast<QmakeProject *>(target()->project());
+    QString androidTargetArch = project->rootQmakeProjectNode()->singleVariableValue(QmakeProjectManager::AndroidArchVar);

    QString androidAssetsPath = m_androidDir.toString() + QLatin1String("/assets/");
    QString androidJarPath = m_androidDir.toString() + QLatin1String("/libs/");
--- a/src/plugins/android/androidpackagecreationwidget.cpp
+++ b/src/plugins/android/androidpackagecreationwidget.cpp
@@ -41,8 +41,8 @@
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/buildmanager.h>
 #include <projectexplorer/projectexplorerconstants.h>
-#include <qt4projectmanager/qmakebuildconfiguration.h>
-#include <qt4projectmanager/qmakestep.h>
+#include <qmakeprojectmanager/qmakebuildconfiguration.h>
+#include <qmakeprojectmanager/qmakestep.h>

 #include <QTimer>

@@ -182,7 +182,7 @@ void AndroidPackageCreationWidget::initGui()

    // Make the buildconfiguration emit a evironmentChanged() signal
    // TODO find a better way
-    Qt4BuildConfiguration *bc = qobject_cast<Qt4BuildConfiguration *>(m_step->target()->activeBuildConfiguration());
+    QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration());
    if (!bc)
        return;
    bool use = bc->useSystemEnvironment();
@@ -196,7 +196,7 @@ void AndroidPackageCreationWidget::initGui()

 void AndroidPackageCreationWidget::updateSigningWarning()
 {
-    Qt4BuildConfiguration *bc = qobject_cast<Qt4BuildConfiguration *>(m_step->target()->activeBuildConfiguration());
+    QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration());
    bool debug = bc && (bc->qmakeBuildConfiguration() & QtSupport::BaseQtVersion::DebugBuild);
    if (m_step->signPackage() && debug) {
        m_ui->signingDebugWarningIcon->setVisible(true);
@@ -213,7 +213,7 @@ void AndroidPackageCreationWidget::activeBuildConfigurationChanged()
        disconnect(m_currentBuildConfiguration, SIGNAL(qmakeBuildConfigurationChanged()),
                   this, SLOT(updateSigningWarning()));
    updateSigningWarning();
-    Qt4BuildConfiguration *bc = qobject_cast<Qt4BuildConfiguration *>(m_step->target()->activeBuildConfiguration());
+    QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration());
    m_currentBuildConfiguration = bc;
    if (bc)
        connect(bc, SIGNAL(qmakeBuildConfigurationChanged()), this, SLOT(updateSigningWarning()));
@@ -243,7 +243,7 @@ void AndroidPackageCreationWidget::updateAndroidProjectInfo()
 void AndroidPackageCreationWidget::setTargetSDK(const QString &sdk)
 {
    AndroidManager::setBuildTargetSDK(m_step->target(), sdk);
-    Qt4BuildConfiguration *bc = qobject_cast<Qt4BuildConfiguration *>(m_step->target()->activeBuildConfiguration());
+    QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(m_step->target()->activeBuildConfiguration());
    if (!bc)
        return;
    QMakeStep *qs = bc->qmakeStep();
--- a/src/plugins/android/androidpackagecreationwidget.h
+++ b/src/plugins/android/androidpackagecreationwidget.h
@@ -41,7 +41,7 @@ class QFileSystemWatcher;
 namespace Ui { class AndroidPackageCreationWidget; }
 QT_END_NAMESPACE

-namespace QmakeProjectManager { class Qt4BuildConfiguration; }
+namespace QmakeProjectManager { class QmakeBuildConfiguration; }

 namespace Android {
 namespace Internal {
@@ -112,7 +112,7 @@ private:
    CheckModel *m_qtLibsModel;
    CheckModel *m_prebundledLibs;
    QFileSystemWatcher *m_fileSystemWatcher;
-    QmakeProjectManager::Qt4BuildConfiguration *m_currentBuildConfiguration;
+    QmakeProjectManager::QmakeBuildConfiguration *m_currentBuildConfiguration;
 };

 } // namespace Internal
--- a/src/plugins/android/androidpackageinstallationstep.cpp
+++ b/src/plugins/android/androidpackageinstallationstep.cpp
@@ -37,7 +37,7 @@
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/gnumakeparser.h>
 #include <utils/hostosinfo.h>
-#include <qt4projectmanager/qmakeparser.h>
+#include <qmakeprojectmanager/qmakeparser.h>

 #include <QDir>

--- a/src/plugins/android/androidqtversion.cpp
+++ b/src/plugins/android/androidqtversion.cpp
@@ -35,8 +35,8 @@
 #include <utils/environment.h>
 #include <utils/hostosinfo.h>

-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakeprojectmanagerconstants.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>

 #include <qtsupport/qtkitinformation.h>
 #include <qtsupport/qtsupportconstants.h>
@@ -109,12 +109,12 @@ void AndroidQtVersion::addToEnvironment(const ProjectExplorer::Kit *k, Utils::En
    env.set(QLatin1String("ANDROID_NDK_HOST"), AndroidConfigurations::instance().config().toolchainHost);
    env.set(QLatin1String("ANDROID_NDK_ROOT"), AndroidConfigurations::instance().config().ndkLocation.toUserOutput());

-    Qt4Project *qt4pro = qobject_cast<QmakeProjectManager::Qt4Project *>(ProjectExplorerPlugin::instance()->currentProject());
-    if (!qt4pro || !qt4pro->activeTarget()
+    QmakeProject *qmakeProject = qobject_cast<QmakeProjectManager::QmakeProject *>(ProjectExplorerPlugin::instance()->currentProject());
+    if (!qmakeProject || !qmakeProject->activeTarget()
            || QtSupport::QtKitInformation::qtVersion(k)->type() != QLatin1String(Constants::ANDROIDQT))
        return;

-    Target *target = qt4pro->activeTarget();
+    Target *target = qmakeProject->activeTarget();
    if (DeviceTypeKitInformation::deviceTypeId(target->kit()) != Constants::ANDROID_DEVICE_TYPE)
        return;
    if (AndroidConfigurations::instance().config().ndkLocation.isEmpty()
--- a/src/plugins/android/androidrunconfiguration.cpp
+++ b/src/plugins/android/androidrunconfiguration.cpp
@@ -37,8 +37,8 @@
 #include <projectexplorer/target.h>
 #include <qtsupport/qtoutputformatter.h>
 #include <qtsupport/qtkitinformation.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>

 #include <utils/qtcassert.h>

@@ -47,7 +47,7 @@ const char PRO_FILE_KEY[] = "Qt4ProjectManager.Qt4RunConfiguration.ProFile";
 }

 using namespace ProjectExplorer;
-using QmakeProjectManager::Qt4Project;
+using QmakeProjectManager::QmakeProject;

 namespace Android {
 namespace Internal {
@@ -56,7 +56,7 @@ AndroidRunConfiguration::AndroidRunConfiguration(Target *parent, Core::Id id, co
    : RunConfiguration(parent, id)
    , m_proFilePath(path)
 {
-    Qt4Project *project = static_cast<Qt4Project *>(parent->project());
+    QmakeProject *project = static_cast<QmakeProject *>(parent->project());
    m_parseSuccess = project->validParse(m_proFilePath);
    m_parseInProgress = project->parseInProgress(m_proFilePath);
    init();
@@ -74,16 +74,16 @@ AndroidRunConfiguration::AndroidRunConfiguration(Target *parent, AndroidRunConfi
 void AndroidRunConfiguration::init()
 {
    setDefaultDisplayName(defaultDisplayName());
-    connect(target()->project(), SIGNAL(proFileUpdated(QmakeProjectManager::Qt4ProFileNode*,bool,bool)),
-            this, SLOT(proFileUpdated(QmakeProjectManager::Qt4ProFileNode*,bool,bool)));
+    connect(target()->project(), SIGNAL(proFileUpdated(QmakeProjectManager::QmakeProFileNode*,bool,bool)),
+            this, SLOT(proFileUpdated(QmakeProjectManager::QmakeProFileNode*,bool,bool)));
 }

 bool AndroidRunConfiguration::fromMap(const QVariantMap &map)
 {
    const QDir projectDir = QDir(target()->project()->projectDirectory());
    m_proFilePath = QDir::cleanPath(projectDir.filePath(map.value(QLatin1String(PRO_FILE_KEY)).toString()));
-    m_parseSuccess = static_cast<Qt4Project *>(target()->project())->validParse(m_proFilePath);
-    m_parseInProgress = static_cast<Qt4Project *>(target()->project())->parseInProgress(m_proFilePath);
+    m_parseSuccess = static_cast<QmakeProject *>(target()->project())->validParse(m_proFilePath);
+    m_parseInProgress = static_cast<QmakeProject *>(target()->project())->parseInProgress(m_proFilePath);

    return RunConfiguration::fromMap(map);
 }
@@ -108,11 +108,11 @@ QString AndroidRunConfiguration::disabledReason() const
                .arg(QFileInfo(m_proFilePath).fileName());

    if (!m_parseSuccess)
-        return static_cast<Qt4Project *>(target()->project())->disabledReasonForRunConfiguration(m_proFilePath);
+        return static_cast<QmakeProject *>(target()->project())->disabledReasonForRunConfiguration(m_proFilePath);
    return QString();
 }

-void AndroidRunConfiguration::proFileUpdated(QmakeProjectManager::Qt4ProFileNode *pro, bool success, bool parseInProgress)
+void AndroidRunConfiguration::proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress)
 {
    if (m_proFilePath != pro->path())
        return;
--- a/src/plugins/android/androidrunconfiguration.h
+++ b/src/plugins/android/androidrunconfiguration.h
@@ -35,7 +35,7 @@

 #include <projectexplorer/runconfiguration.h>

-namespace QmakeProjectManager { class Qt4ProFileNode; }
+namespace QmakeProjectManager { class QmakeProFileNode; }

 namespace Android {
 namespace Internal {
@@ -70,7 +70,7 @@ protected:
    bool fromMap(const QVariantMap &map);
    QVariantMap toMap() const;
 private slots:
-    void proFileUpdated(QmakeProjectManager::Qt4ProFileNode *pro, bool success, bool parseInProgress);
+    void proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress);
 private:
    void init();

--- a/src/plugins/android/androidrunfactories.cpp
+++ b/src/plugins/android/androidrunfactories.cpp
@@ -40,8 +40,8 @@
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/target.h>
 #include <debugger/debuggerconstants.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
 #include <qtsupport/customexecutablerunconfiguration.h>
 #include <qtsupport/qtkitinformation.h>
 #include <qtsupport/qtsupportconstants.h>
@@ -90,9 +90,9 @@ QList<Core::Id> AndroidRunConfigurationFactory::availableCreationIds(Target *par
    QList<Core::Id> ids;
    if (!AndroidManager::supportsAndroid(parent))
        return ids;
-    QList<Qt4ProFileNode *> nodes = static_cast<Qt4Project *>(parent->project())->allProFiles();
+    QList<QmakeProFileNode *> nodes = static_cast<QmakeProject *>(parent->project())->allProFiles();
    const Core::Id base = Core::Id(ANDROID_RC_ID_PREFIX);
-    foreach (Qt4ProFileNode *node, nodes)
+    foreach (QmakeProFileNode *node, nodes)
        if (node->projectType() == ApplicationTemplate || node->projectType() == LibraryTemplate)
            ids << base.withSuffix(node->path());
    return ids;
--- a/src/plugins/android/androidrunfactories.h
+++ b/src/plugins/android/androidrunfactories.h
@@ -31,7 +31,7 @@
 #define ANDROIDRUNFACTORIES_H

 #include <projectexplorer/runconfiguration.h>
-#include <qt4projectmanager/qmakerunconfigurationfactory.h>
+#include <qmakeprojectmanager/qmakerunconfigurationfactory.h>

 namespace ProjectExplorer {
 class RunControl;
--- a/src/plugins/android/createandroidmanifestwizard.cpp
+++ b/src/plugins/android/createandroidmanifestwizard.cpp
@@ -30,8 +30,8 @@
 #include "createandroidmanifestwizard.h"

 #include <projectexplorer/target.h>
-#include <qt4projectmanager/qmakeproject.h>
-#include <qt4projectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
 #include <proparser/prowriter.h>
 #include <QComboBox>
 #include <QFormLayout>
@@ -43,8 +43,8 @@

 using namespace Android;
 using namespace Android::Internal;
-using QmakeProjectManager::Qt4Project;
-using QmakeProjectManager::Qt4ProFileNode;
+using QmakeProjectManager::QmakeProject;
+using QmakeProjectManager::QmakeProFileNode;

 //
 // NoApplicationProFilePage
@@ -63,7 +63,7 @@ NoApplicationProFilePage::NoApplicationProFilePage(CreateAndroidManifestWizard *
 //
 // ChooseProFilePage
 //
-ChooseProFilePage::ChooseProFilePage(CreateAndroidManifestWizard *wizard, const QList<Qt4ProFileNode *> &nodes)
+ChooseProFilePage::ChooseProFilePage(CreateAndroidManifestWizard *wizard, const QList<QmakeProFileNode *> &nodes)
    : m_wizard(wizard)
 {
    QFormLayout *fl = new QFormLayout(this);
@@ -73,7 +73,7 @@ ChooseProFilePage::ChooseProFilePage(CreateAndroidManifestWizard *wizard, const
    fl->addRow(label);

    m_comboBox = new QComboBox(this);
-    foreach (Qt4ProFileNode *node, nodes)
+    foreach (QmakeProFileNode *node, nodes)
        m_comboBox->addItem(node->displayName(), QVariant::fromValue(static_cast<void *>(node))); // TODO something more?

    connect(m_comboBox, SIGNAL(currentIndexChanged(int)),
@@ -86,7 +86,7 @@ ChooseProFilePage::ChooseProFilePage(CreateAndroidManifestWizard *wizard, const
 void ChooseProFilePage::nodeSelected(int index)
 {
    Q_UNUSED(index)
-    m_wizard->setNode(static_cast<Qt4ProFileNode *>(m_comboBox->itemData(m_comboBox->currentIndex()).value<void *>()));
+    m_wizard->setNode(static_cast<QmakeProFileNode *>(m_comboBox->itemData(m_comboBox->currentIndex()).value<void *>()));
 }


@@ -133,8 +133,8 @@ CreateAndroidManifestWizard::CreateAndroidManifestWizard(ProjectExplorer::Target
 {
    setWindowTitle(tr("Create Android Manifest Wizard"));

-    Qt4Project *project = static_cast<Qt4Project *>(target->project());
-    QList<Qt4ProFileNode *> nodes = project->applicationProFiles();
+    QmakeProject *project = static_cast<QmakeProject *>(target->project());
+    QList<QmakeProFileNode *> nodes = project->applicationProFiles();
    if (nodes.isEmpty()) {
        // oh uhm can't create anything
        addPage(new NoApplicationProFilePage(this));
@@ -147,12 +147,12 @@ CreateAndroidManifestWizard::CreateAndroidManifestWizard(ProjectExplorer::Target
    }
 }

-QmakeProjectManager::Qt4ProFileNode *CreateAndroidManifestWizard::node() const
+QmakeProjectManager::QmakeProFileNode *CreateAndroidManifestWizard::node() const
 {
    return m_node;
 }

-void CreateAndroidManifestWizard::setNode(QmakeProjectManager::Qt4ProFileNode *node)
+void CreateAndroidManifestWizard::setNode(QmakeProjectManager::QmakeProFileNode *node)
 {
    m_node = node;
 }
--- a/src/plugins/android/createandroidmanifestwizard.h
+++ b/src/plugins/android/createandroidmanifestwizard.h
@@ -37,7 +37,7 @@ class QComboBox;
 QT_END_NAMESPACE

 namespace ProjectExplorer { class Target; }
-namespace QmakeProjectManager { class Qt4ProFileNode; }
+namespace QmakeProjectManager { class QmakeProFileNode; }

 namespace Android {
 namespace Internal {
@@ -57,7 +57,7 @@ class ChooseProFilePage : public QWizardPage
 {
    Q_OBJECT
 public:
-    ChooseProFilePage(CreateAndroidManifestWizard *wizard, const QList<QmakeProjectManager::Qt4ProFileNode *> &nodes);
+    ChooseProFilePage(CreateAndroidManifestWizard *wizard, const QList<QmakeProjectManager::QmakeProFileNode *> &nodes);
 private slots:
    void nodeSelected(int index);
 private:
@@ -81,8 +81,8 @@ class CreateAndroidManifestWizard : public Utils::Wizard
 public:
    CreateAndroidManifestWizard(ProjectExplorer::Target *target);

-    QmakeProjectManager::Qt4ProFileNode *node() const;
-    void setNode(QmakeProjectManager::Qt4ProFileNode *node);
+    QmakeProjectManager::QmakeProFileNode *node() const;
+    void setNode(QmakeProjectManager::QmakeProFileNode *node);

    QString sourceFileName() const;

@@ -93,7 +93,7 @@ public slots:
 private:
    void createAndroidManifestFile();
    ProjectExplorer::Target *m_target;
-    QmakeProjectManager::Qt4ProFileNode *m_node;
+    QmakeProjectManager::QmakeProFileNode *m_node;
    QString m_directory;
 };
 }