Qt4ProjectManager: Rename {Qt4,Qmake}{Project,Pr{i,o}FileNode}

Change-Id: I27139d8ccc17b665853bec4a37e80568680b5fcc
Reviewed-by: Eike Ziller <eike.ziller@digia.com>
Reviewed-by: David Schulz <david.schulz@digia.com>

55 files changed, 546 insertions, 546 deletions

diff --git a/src/plugins/android/androiddebugsupport.cpp b/src/plugins/android/androiddebugsupport.cpp
index f623b7e1b6..58194b1488 100644
--- a/src/plugins/android/androiddebugsupport.cpp
+++ b/src/plugins/android/androiddebugsupport.cpp
@@ -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
diff --git a/src/plugins/android/androiddeployconfiguration.cpp b/src/plugins/android/androiddeployconfiguration.cpp
index 1dfac6e0d8..45d26130f9 100644
--- a/src/plugins/android/androiddeployconfiguration.cpp
+++ b/src/plugins/android/androiddeployconfiguration.cpp
@@ -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()))
diff --git a/src/plugins/android/androiddeployqtstep.cpp b/src/plugins/android/androiddeployqtstep.cpp
index fabffa7c82..fb2e38afe0 100644
--- a/src/plugins/android/androiddeployqtstep.cpp
+++ b/src/plugins/android/androiddeployqtstep.cpp
@@ -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))
diff --git a/src/plugins/android/androiddeployqtwidget.cpp b/src/plugins/android/androiddeployqtwidget.cpp
index 62af372e4c..5572cb490a 100644
--- a/src/plugins/android/androiddeployqtwidget.cpp
+++ b/src/plugins/android/androiddeployqtwidget.cpp
@@ -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);
         }
diff --git a/src/plugins/android/androiddeploystep.cpp b/src/plugins/android/androiddeploystep.cpp
index 24aaa444e8..d89ef48279 100644
--- a/src/plugins/android/androiddeploystep.cpp
+++ b/src/plugins/android/androiddeploystep.cpp
@@ -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;
diff --git a/src/plugins/android/androidextralibrarylistmodel.cpp b/src/plugins/android/androidextralibrarylistmodel.cpp
index 8d51017866..848d41e902 100644
--- a/src/plugins/android/androidextralibrarylistmodel.cpp
+++ b/src/plugins/android/androidextralibrarylistmodel.cpp
@@ -35,7 +35,7 @@
 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(" ")));
 }
diff --git a/src/plugins/android/androidextralibrarylistmodel.h b/src/plugins/android/androidextralibrarylistmodel.h
index d343acbaf4..c768b7de65 100644
--- 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;
 };
 
diff --git a/src/plugins/android/androidmanager.cpp b/src/plugins/android/androidmanager.cpp
index 1b0a1d503f..0ec38c5d9f 100644
--- a/src/plugins/android/androidmanager.cpp
+++ b/src/plugins/android/androidmanager.cpp
@@ -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());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
     if (!qt4Project)
         return apps;
-    foreach (QmakeProjectManager::Qt4ProFileNode *proFile, qt4Project->applicationProFiles()) {
+    foreach (QmakeProjectManager::QmakeProFileNode *proFile, qt4Project->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 *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
+    foreach (QmakeProjectManager::QmakeProFileNode *proFile, qt4Project->applicationProFiles()) {
         if (proFile->projectType() == QmakeProjectManager::ApplicationTemplate) {
             if (proFile->targetInformation().target.startsWith(QLatin1String("lib"))
                     && proFile->targetInformation().target.endsWith(QLatin1String(".so"))) {
@@ -529,7 +529,7 @@ 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());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject*>(target->project());
     if (!qt4Project || !qt4Project->rootProjectNode() || !version)
         return false;
 
@@ -804,16 +804,16 @@ 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());
+    const QmakeProjectManager::QmakeProject *const qt4Project
+            = qobject_cast<const QmakeProjectManager::QmakeProject *>(target->project());
     if (!qt4Project || !version)
         return QVector<AndroidManager::Library>();
     QString qtLibsPath = version->qmakeProperty("QT_INSTALL_LIBS");
@@ -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());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(target->project());
     if (!qt4Project)
         return libs;
 
-    foreach (QmakeProjectManager::Qt4ProFileNode *node, qt4Project->allProFiles())
+    foreach (QmakeProjectManager::QmakeProFileNode *node, qt4Project->allProFiles())
         if (node->projectType() == QmakeProjectManager::LibraryTemplate)
             libs << node->targetInformation().target;
     return libs;
diff --git a/src/plugins/android/androidpackagecreationstep.cpp b/src/plugins/android/androidpackagecreationstep.cpp
index a8082d1935..5730e1aeba 100644
--- a/src/plugins/android/androidpackagecreationstep.cpp
+++ b/src/plugins/android/androidpackagecreationstep.cpp
@@ -103,13 +103,13 @@ bool AndroidPackageCreationStep::init()
         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/");
diff --git a/src/plugins/android/androidqtversion.cpp b/src/plugins/android/androidqtversion.cpp
index 6298812797..1b882501cd 100644
--- a/src/plugins/android/androidqtversion.cpp
+++ b/src/plugins/android/androidqtversion.cpp
@@ -109,7 +109,7 @@ 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());
+    QmakeProject *qt4pro = qobject_cast<QmakeProjectManager::QmakeProject *>(ProjectExplorerPlugin::instance()->currentProject());
     if (!qt4pro || !qt4pro->activeTarget()
             || QtSupport::QtKitInformation::qtVersion(k)->type() != QLatin1String(Constants::ANDROIDQT))
         return;
diff --git a/src/plugins/android/androidrunconfiguration.cpp b/src/plugins/android/androidrunconfiguration.cpp
index 5625358d84..818e3ad102 100644
--- a/src/plugins/android/androidrunconfiguration.cpp
+++ b/src/plugins/android/androidrunconfiguration.cpp
@@ -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;
diff --git a/src/plugins/android/androidrunconfiguration.h b/src/plugins/android/androidrunconfiguration.h
index 523e4936e8..a8bbb65e43 100644
--- 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();
 
diff --git a/src/plugins/android/androidrunfactories.cpp b/src/plugins/android/androidrunfactories.cpp
index 170b860318..a555dea7e8 100644
--- a/src/plugins/android/androidrunfactories.cpp
+++ b/src/plugins/android/androidrunfactories.cpp
@@ -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;
diff --git a/src/plugins/android/createandroidmanifestwizard.cpp b/src/plugins/android/createandroidmanifestwizard.cpp
index 6a7912b6db..8855d98ae0 100644
--- a/src/plugins/android/createandroidmanifestwizard.cpp
+++ b/src/plugins/android/createandroidmanifestwizard.cpp
@@ -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;
 }
diff --git a/src/plugins/android/createandroidmanifestwizard.h b/src/plugins/android/createandroidmanifestwizard.h
index 348090333c..e32445ee0f 100644
--- 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;
 };
 }
diff --git a/src/plugins/ios/iosdebugsupport.cpp b/src/plugins/ios/iosdebugsupport.cpp
index d9ea84ac15..72c8d18943 100644
--- a/src/plugins/ios/iosdebugsupport.cpp
+++ b/src/plugins/ios/iosdebugsupport.cpp
@@ -68,7 +68,7 @@ RunControl *IosDebugSupport::createDebugRunControl(IosRunConfiguration *runConfi
     ProjectExplorer::IDevice::ConstPtr device = DeviceKitInformation::device(target->kit());
     if (device.isNull())
         return 0;
-    Qt4Project *project = static_cast<Qt4Project *>(target->project());
+    QmakeProject *project = static_cast<QmakeProject *>(target->project());
 
     DebuggerStartParameters params;
     if (device->type() == Core::Id(Ios::Constants::IOS_DEVICE_TYPE))
@@ -98,8 +98,8 @@ RunControl *IosDebugSupport::createDebugRunControl(IosRunConfiguration *runConfi
         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
diff --git a/src/plugins/ios/iosdeployconfiguration.cpp b/src/plugins/ios/iosdeployconfiguration.cpp
index ef54b45ac4..5da44b93ea 100644
--- a/src/plugins/ios/iosdeployconfiguration.cpp
+++ b/src/plugins/ios/iosdeployconfiguration.cpp
@@ -112,7 +112,7 @@ DeployConfiguration *IosDeployConfigurationFactory::clone(Target *parent, Deploy
 QList<Core::Id> IosDeployConfigurationFactory::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()))
         return ids;
diff --git a/src/plugins/ios/iosmanager.cpp b/src/plugins/ios/iosmanager.cpp
index 3afe5d4253..5228ae8513 100644
--- a/src/plugins/ios/iosmanager.cpp
+++ b/src/plugins/ios/iosmanager.cpp
@@ -58,7 +58,7 @@ namespace Internal {
 
 bool IosManager::supportsIos(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->type() == QLatin1String(Ios::Constants::IOSQT);
diff --git a/src/plugins/ios/iosrunconfiguration.cpp b/src/plugins/ios/iosrunconfiguration.cpp
index f155d50245..81c9da41fe 100644
--- a/src/plugins/ios/iosrunconfiguration.cpp
+++ b/src/plugins/ios/iosrunconfiguration.cpp
@@ -144,9 +144,9 @@ QString IosRunConfiguration::profilePath() const
 
 QString IosRunConfiguration::appName() const
 {
-    Qt4Project *pro = qobject_cast<Qt4Project *>(target()->project());
+    QmakeProject *pro = qobject_cast<QmakeProject *>(target()->project());
     if (pro) {
-        const Qt4ProFileNode *node = pro->rootQt4ProjectNode()->findProFileFor(profilePath());
+        const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(profilePath());
         if (node) {
             TargetInformation ti = node->targetInformation();
             if (ti.valid) {
diff --git a/src/plugins/ios/iosrunfactories.cpp b/src/plugins/ios/iosrunfactories.cpp
index 5f9acfb5e3..84e6ca05a0 100644
--- a/src/plugins/ios/iosrunfactories.cpp
+++ b/src/plugins/ios/iosrunfactories.cpp
@@ -97,8 +97,8 @@ QList<Core::Id> IosRunConfigurationFactory::availableCreationIds(Target *parent)
     if (!IosManager::supportsIos(parent))
         return ids;
     Core::Id baseId(IOS_RC_ID_PREFIX);
-    QList<Qt4ProFileNode *> nodes = static_cast<Qt4Project *>(parent->project())->allProFiles();
-    foreach (Qt4ProFileNode *node, nodes)
+    QList<QmakeProFileNode *> nodes = static_cast<QmakeProject *>(parent->project())->allProFiles();
+    foreach (QmakeProFileNode *node, nodes)
         if (node->projectType() == ApplicationTemplate || node->projectType() == LibraryTemplate
                 || node->projectType() == AuxTemplate)
             ids << baseId.withSuffix(node->path());
diff --git a/src/plugins/qnx/blackberrydeployconfiguration.cpp b/src/plugins/qnx/blackberrydeployconfiguration.cpp
index 4e171df898..f6bf5078f7 100644
--- a/src/plugins/qnx/blackberrydeployconfiguration.cpp
+++ b/src/plugins/qnx/blackberrydeployconfiguration.cpp
@@ -90,8 +90,8 @@ void BlackBerryDeployConfiguration::setupBarDescriptor()
     QString projectName = target()->project()->displayName();
 
     QString targetName;
-    QmakeProjectManager::Qt4Project *project =  static_cast<QmakeProjectManager::Qt4Project *>(target()->project());
-    foreach (QmakeProjectManager::Qt4ProFileNode *node, project->applicationProFiles()) {
+    QmakeProjectManager::QmakeProject *project =  static_cast<QmakeProjectManager::QmakeProject *>(target()->project());
+    foreach (QmakeProjectManager::QmakeProFileNode *node, project->applicationProFiles()) {
         QString target = node->targetInformation().target;
         if (!target.isEmpty()) {
             targetName = target;
diff --git a/src/plugins/qnx/blackberrydeployconfigurationfactory.cpp b/src/plugins/qnx/blackberrydeployconfigurationfactory.cpp
index 03e51a24d7..40a0a3d47b 100644
--- a/src/plugins/qnx/blackberrydeployconfigurationfactory.cpp
+++ b/src/plugins/qnx/blackberrydeployconfigurationfactory.cpp
@@ -60,7 +60,7 @@ QList<Core::Id> BlackBerryDeployConfigurationFactory::availableCreationIds(Proje
 {
     QList<Core::Id> result;
 
-    QmakeProjectManager::Qt4Project *project = qobject_cast<QmakeProjectManager::Qt4Project *>(parent->project());
+    QmakeProjectManager::QmakeProject *project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
     if (!project)
         return result;
 
diff --git a/src/plugins/qnx/blackberrydeployinformation.cpp b/src/plugins/qnx/blackberrydeployinformation.cpp
index b02a44fc1a..e841b48d58 100644
--- a/src/plugins/qnx/blackberrydeployinformation.cpp
+++ b/src/plugins/qnx/blackberrydeployinformation.cpp
@@ -241,8 +241,8 @@ void BlackBerryDeployInformation::updateModel()
 
     beginResetModel();
     QList<BarPackageDeployInformation> keep;
-    QList<QmakeProjectManager::Qt4ProFileNode *> appNodes = project()->applicationProFiles();
-    foreach (QmakeProjectManager::Qt4ProFileNode *node, appNodes) {
+    QList<QmakeProjectManager::QmakeProFileNode *> appNodes = project()->applicationProFiles();
+    foreach (QmakeProjectManager::QmakeProFileNode *node, appNodes) {
         bool nodeFound = false;
         for (int i = 0; i < m_deployInformation.size(); ++i) {
             if (m_deployInformation[i].proFilePath == node->path()
@@ -264,9 +264,9 @@ void BlackBerryDeployInformation::updateModel()
     endResetModel();
 }
 
-QmakeProjectManager::Qt4Project *BlackBerryDeployInformation::project() const
+QmakeProjectManager::QmakeProject *BlackBerryDeployInformation::project() const
 {
-    return static_cast<QmakeProjectManager::Qt4Project *>(m_target->project());
+    return static_cast<QmakeProjectManager::QmakeProject *>(m_target->project());
 }
 
 void BlackBerryDeployInformation::initModel()
@@ -282,7 +282,7 @@ void BlackBerryDeployInformation::initModel()
         return;
     }
 
-    const QmakeProjectManager::Qt4ProFileNode *const rootNode = project()->rootQt4ProjectNode();
+    const QmakeProjectManager::QmakeProFileNode *const rootNode = project()->rootQmakeProjectNode();
     if (!rootNode || rootNode->parseInProgress()) // Can be null right after project creation by wizard.
         return;
 
@@ -291,15 +291,15 @@ void BlackBerryDeployInformation::initModel()
     beginResetModel();
     m_deployInformation.clear();
 
-    QList<QmakeProjectManager::Qt4ProFileNode *> appNodes = project()->applicationProFiles();
-    foreach (QmakeProjectManager::Qt4ProFileNode *node, appNodes)
+    QList<QmakeProjectManager::QmakeProFileNode *> appNodes = project()->applicationProFiles();
+    foreach (QmakeProjectManager::QmakeProFileNode *node, appNodes)
         m_deployInformation << deployInformationFromNode(node);
 
     endResetModel();
     connect(project(), SIGNAL(proFilesEvaluated()), this, SLOT(updateModel()));
 }
 
-BarPackageDeployInformation BlackBerryDeployInformation::deployInformationFromNode(QmakeProjectManager::Qt4ProFileNode *node) const
+BarPackageDeployInformation BlackBerryDeployInformation::deployInformationFromNode(QmakeProjectManager::QmakeProFileNode *node) const
 {
     QmakeProjectManager::TargetInformation ti = node->targetInformation();
 
diff --git a/src/plugins/qnx/blackberrydeployinformation.h b/src/plugins/qnx/blackberrydeployinformation.h
index 7edd37c7bb..1080496ba5 100644
--- a/src/plugins/qnx/blackberrydeployinformation.h
+++ b/src/plugins/qnx/blackberrydeployinformation.h
@@ -38,8 +38,8 @@ class Target;
 }
 
 namespace QmakeProjectManager {
-class Qt4ProFileNode;
-class Qt4Project;
+class QmakeProFileNode;
+class QmakeProject;
 }
 
 namespace Qnx {
@@ -102,10 +102,10 @@ private:
         ColumnCount // Always have last
     };
 
-    QmakeProjectManager::Qt4Project *project() const;
+    QmakeProjectManager::QmakeProject *project() const;
 
     void initModel();
-    BarPackageDeployInformation deployInformationFromNode(QmakeProjectManager::Qt4ProFileNode *node) const;
+    BarPackageDeployInformation deployInformationFromNode(QmakeProjectManager::QmakeProFileNode *node) const;
 
     ProjectExplorer::Target *m_target;
 
diff --git a/src/plugins/qnx/blackberryrunconfiguration.h b/src/plugins/qnx/blackberryrunconfiguration.h
index c9a2e374fb..16b5d96ec1 100644
--- a/src/plugins/qnx/blackberryrunconfiguration.h
+++ b/src/plugins/qnx/blackberryrunconfiguration.h
@@ -40,7 +40,7 @@ class Target;
 
 namespace QmakeProjectManager {
 class QmakeBuildConfiguration;
-class Qt4Project;
+class QmakeProject;
 }
 
 namespace Qnx {
diff --git a/src/plugins/qnx/blackberryrunconfigurationfactory.cpp b/src/plugins/qnx/blackberryrunconfigurationfactory.cpp
index 2f18cad99a..80e125286f 100644
--- a/src/plugins/qnx/blackberryrunconfigurationfactory.cpp
+++ b/src/plugins/qnx/blackberryrunconfigurationfactory.cpp
@@ -57,7 +57,7 @@ QList<Core::Id> BlackBerryRunConfigurationFactory::availableCreationIds(ProjectE
     if (!canHandle(parent))
         return ids;
 
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(parent->project());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
     if (!qt4Project)
         return ids;
 
@@ -85,7 +85,7 @@ bool BlackBerryRunConfigurationFactory::canCreate(ProjectExplorer::Target *paren
     if (!canHandle(parent))
         return false;
 
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(parent->project());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
     if (!qt4Project)
         return false;
 
@@ -140,7 +140,7 @@ bool BlackBerryRunConfigurationFactory::canHandle(ProjectExplorer::Target *t) co
 {
     if (!t->project()->supportsKit(t->kit()))
         return false;
-    if (!qobject_cast<QmakeProjectManager::Qt4Project *>(t->project()))
+    if (!qobject_cast<QmakeProjectManager::QmakeProject *>(t->project()))
         return false;
 
     Core::Id deviceType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(t->kit());
diff --git a/src/plugins/qnx/qnxrunconfigurationfactory.cpp b/src/plugins/qnx/qnxrunconfigurationfactory.cpp
index ad85c5146d..f6e4eda20b 100644
--- a/src/plugins/qnx/qnxrunconfigurationfactory.cpp
+++ b/src/plugins/qnx/qnxrunconfigurationfactory.cpp
@@ -58,7 +58,7 @@ QList<Core::Id> QnxRunConfigurationFactory::availableCreationIds(ProjectExplorer
     if (!canHandle(parent))
         return ids;
 
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(parent->project());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
     if (!qt4Project)
         return ids;
 
@@ -85,7 +85,7 @@ bool QnxRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, cons
     if (!canHandle(parent) || !id.name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX))
         return false;
 
-    QmakeProjectManager::Qt4Project *qt4Project = qobject_cast<QmakeProjectManager::Qt4Project *>(parent->project());
+    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
     if (!qt4Project)
         return false;
 
diff --git a/src/plugins/qt4projectmanager/externaleditors.cpp b/src/plugins/qt4projectmanager/externaleditors.cpp
index 0915056bd6..d2e05ffe74 100644
--- a/src/plugins/qt4projectmanager/externaleditors.cpp
+++ b/src/plugins/qt4projectmanager/externaleditors.cpp
@@ -52,10 +52,10 @@ namespace QmakeProjectManager {
 namespace Internal {
 
 // Figure out the Qt4 project used by the file if any
-static Qt4Project *qt4ProjectFor(const QString &fileName)
+static QmakeProject *qt4ProjectFor(const QString &fileName)
 {
     if (ProjectExplorer::Project *baseProject = ProjectExplorer::SessionManager::projectForFile(fileName))
-        if (Qt4Project *project = qobject_cast<Qt4Project*>(baseProject))
+        if (QmakeProject *project = qobject_cast<QmakeProject*>(baseProject))
             return project;
     return 0;
 }
@@ -138,7 +138,7 @@ bool ExternalQtEditor::getEditorLaunchData(const QString &fileName,
                                            QString *errorMessage) const
 {
     // Get the binary either from the current Qt version of the project or Path
-    if (const Qt4Project *project = qt4ProjectFor(fileName)) {
+    if (const QmakeProject *project = qt4ProjectFor(fileName)) {
         if (const ProjectExplorer::Target *target = project->activeTarget()) {
             if (const QtSupport::BaseQtVersion *qtVersion = QtSupport::QtKitInformation::qtVersion(target->kit())) {
                 data->binary = (qtVersion->*commandAccessor)();
diff --git a/src/plugins/qt4projectmanager/findqmakeprofiles.cpp b/src/plugins/qt4projectmanager/findqmakeprofiles.cpp
index 286c1030b1..2dfc208d3b 100644
--- a/src/plugins/qt4projectmanager/findqmakeprofiles.cpp
+++ b/src/plugins/qt4projectmanager/findqmakeprofiles.cpp
@@ -33,15 +33,15 @@
 using namespace QmakeProjectManager;
 using namespace QmakeProjectManager::Internal;
 
-QList<Qt4ProFileNode *> FindQt4ProFiles::operator()(ProjectExplorer::ProjectNode *root)
+QList<QmakeProFileNode *> FindQmakeProFiles::operator()(ProjectExplorer::ProjectNode *root)
 {
     m_proFiles.clear();
     root->accept(this);
     return m_proFiles;
 }
 
-void FindQt4ProFiles::visitProjectNode(ProjectExplorer::ProjectNode *projectNode)
+void FindQmakeProFiles::visitProjectNode(ProjectExplorer::ProjectNode *projectNode)
 {
-    if (Qt4ProFileNode *pro = qobject_cast<Qt4ProFileNode *>(projectNode))
+    if (QmakeProFileNode *pro = qobject_cast<QmakeProFileNode *>(projectNode))
         m_proFiles.append(pro);
 }
diff --git a/src/plugins/qt4projectmanager/findqmakeprofiles.h b/src/plugins/qt4projectmanager/findqmakeprofiles.h
index a9defa62f1..267499c0da 100644
--- a/src/plugins/qt4projectmanager/findqmakeprofiles.h
+++ b/src/plugins/qt4projectmanager/findqmakeprofiles.h
@@ -33,17 +33,17 @@
 #include <projectexplorer/nodesvisitor.h>
 
 namespace QmakeProjectManager {
-class Qt4ProFileNode;
+class QmakeProFileNode;
 namespace Internal {
 
-class FindQt4ProFiles: protected ProjectExplorer::NodesVisitor {
-
+class FindQmakeProFiles: protected ProjectExplorer::NodesVisitor
+{
 public:
-    QList<Qt4ProFileNode *> operator()(ProjectExplorer::ProjectNode *root);
+    QList<QmakeProFileNode *> operator()(ProjectExplorer::ProjectNode *root);
 protected:
     virtual void visitProjectNode(ProjectExplorer::ProjectNode *projectNode);
 private:
-    QList<Qt4ProFileNode *> m_proFiles;
+    QList<QmakeProFileNode *> m_proFiles;
 };
 
 } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/librarydetailscontroller.cpp b/src/plugins/qt4projectmanager/librarydetailscontroller.cpp
index 3f79461f3c..8a144ef622 100644
--- a/src/plugins/qt4projectmanager/librarydetailscontroller.cpp
+++ b/src/plugins/qt4projectmanager/librarydetailscontroller.cpp
@@ -884,11 +884,11 @@ bool PackageLibraryDetailsController::isLinkPackageGenerated() const
     if (!project)
         return false;
 
-    const Qt4ProFileNode *rootProject = qobject_cast<const Qt4ProFileNode *>(project->rootProjectNode());
+    const QmakeProFileNode *rootProject = qobject_cast<const QmakeProFileNode *>(project->rootProjectNode());
     if (!rootProject)
         return false;
 
-    const Qt4ProFileNode *currentProject = rootProject->findProFileFor(proFile());
+    const QmakeProFileNode *currentProject = rootProject->findProFileFor(proFile());
     if (!currentProject)
         return false;
 
@@ -980,7 +980,7 @@ AddLibraryWizard::LinkageType InternalLibraryDetailsController::suggestedLinkage
     const int currentIndex = libraryDetailsWidget()->libraryComboBox->currentIndex();
     AddLibraryWizard::LinkageType type = AddLibraryWizard::NoLinkage;
     if (currentIndex >= 0) {
-        Qt4ProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
+        QmakeProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
         const QStringList configVar = proFileNode->variableValue(ConfigVar);
         if (configVar.contains(QLatin1String("staticlib"))
                 || configVar.contains(QLatin1String("static")))
@@ -996,7 +996,7 @@ AddLibraryWizard::MacLibraryType InternalLibraryDetailsController::suggestedMacL
     const int currentIndex = libraryDetailsWidget()->libraryComboBox->currentIndex();
     AddLibraryWizard::MacLibraryType type = AddLibraryWizard::NoLibraryType;
     if (currentIndex >= 0) {
-        Qt4ProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
+        QmakeProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
         const QStringList configVar = proFileNode->variableValue(ConfigVar);
         if (configVar.contains(QLatin1String("lib_bundle")))
             type = AddLibraryWizard::FrameworkType;
@@ -1011,7 +1011,7 @@ QString InternalLibraryDetailsController::suggestedIncludePath() const
     const int currentIndex = libraryDetailsWidget()->libraryComboBox->currentIndex();
     QString includePath;
     if (currentIndex >= 0) {
-        Qt4ProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
+        QmakeProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
         QFileInfo fi(proFileNode->path());
         includePath = fi.absolutePath();
     }
@@ -1042,9 +1042,9 @@ void InternalLibraryDetailsController::updateProFile()
     QFileInfo fi(rootProject->path());
     m_rootProjectPath = fi.absolutePath();
     QDir rootDir(m_rootProjectPath);
-    FindQt4ProFiles findQt4ProFiles;
-    QList<Qt4ProFileNode *> proFiles = findQt4ProFiles(rootProject);
-    foreach (Qt4ProFileNode *proFileNode, proFiles) {
+    FindQmakeProFiles findQt4ProFiles;
+    QList<QmakeProFileNode *> proFiles = findQt4ProFiles(rootProject);
+    foreach (QmakeProFileNode *proFileNode, proFiles) {
         const QString proFilePath = proFileNode->path();
         if (proFileNode->projectType() == LibraryTemplate) {
             const QStringList configVar = proFileNode->variableValue(ConfigVar);
@@ -1071,7 +1071,7 @@ void InternalLibraryDetailsController::slotCurrentLibraryChanged()
         libraryDetailsWidget()->libraryComboBox->setToolTip(
                     libraryDetailsWidget()->libraryComboBox->itemData(
                         currentIndex, Qt::ToolTipRole).toString());
-        Qt4ProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
+        QmakeProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
         const QStringList configVar = proFileNode->variableValue(ConfigVar);
         if (creatorPlatform() == CreatorWindows) {
             bool useSubfolders = false;
@@ -1133,7 +1133,7 @@ QString InternalLibraryDetailsController::snippet() const
     QDir projectSrcDir(fi.absolutePath());
 
     // project node which we want to link against
-    Qt4ProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
+    QmakeProFileNode *proFileNode = m_proFileNodes.at(currentIndex);
     TargetInformation targetInfo = proFileNode->targetInformation();
 
     const QString targetRelativePath = appendSeparator(projectBuildDir.relativeFilePath(targetInfo.buildDir));
diff --git a/src/plugins/qt4projectmanager/librarydetailscontroller.h b/src/plugins/qt4projectmanager/librarydetailscontroller.h
index b23bf4acb2..504e51c7ca 100644
--- a/src/plugins/qt4projectmanager/librarydetailscontroller.h
+++ b/src/plugins/qt4projectmanager/librarydetailscontroller.h
@@ -33,7 +33,7 @@
 #include "addlibrarywizard.h"
 
 namespace QmakeProjectManager {
-class Qt4ProFileNode;
+class QmakeProFileNode;
 namespace Internal {
 
 namespace Ui {
@@ -196,7 +196,7 @@ private slots:
     void updateProFile();
 private:
     QString m_rootProjectPath;
-    QVector<Qt4ProFileNode *> m_proFileNodes;
+    QVector<QmakeProFileNode *> m_proFileNodes;
 };
 
 } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/makestep.cpp b/src/plugins/qt4projectmanager/makestep.cpp
index 49e988db42..a377477f16 100644
--- a/src/plugins/qt4projectmanager/makestep.cpp
+++ b/src/plugins/qt4projectmanager/makestep.cpp
@@ -188,7 +188,7 @@ bool MakeStep::init()
 
     QString args;
 
-    QmakeProjectManager::Qt4ProFileNode *subNode = bc->subNodeBuild();
+    QmakeProjectManager::QmakeProFileNode *subNode = bc->subNodeBuild();
     if (subNode) {
         QString makefile = subNode->makefile();
         if (makefile.isEmpty())
@@ -262,7 +262,7 @@ bool MakeStep::init()
     appendOutputParser(new QMakeParser); // make may cause qmake to be run, add last to make sure
                                          // it has a low priority.
 
-    m_scriptTarget = (static_cast<Qt4Project *>(bc->target()->project())->rootQt4ProjectNode()->projectType() == ScriptTemplate);
+    m_scriptTarget = (static_cast<QmakeProject *>(bc->target()->project())->rootQmakeProjectNode()->projectType() == ScriptTemplate);
 
     return AbstractProcessStep::init();
 }
diff --git a/src/plugins/qt4projectmanager/makestep.h b/src/plugins/qt4projectmanager/makestep.h
index b9d5c1dd95..77086016be 100644
--- a/src/plugins/qt4projectmanager/makestep.h
+++ b/src/plugins/qt4projectmanager/makestep.h
@@ -69,7 +69,7 @@ public:
 };
 } //namespace Internal
 
-class Qt4Project;
+class QmakeProject;
 
 class QT4PROJECTMANAGER_EXPORT MakeStep : public ProjectExplorer::AbstractProcessStep
 {
diff --git a/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp b/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp
index 94ee5d0bde..13c818ef0d 100644
--- a/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp
@@ -67,7 +67,7 @@ static Utils::FileName defaultBuildDirectory(bool supportsShadowBuild,
                                              const QString &suffix)
 {
     if (supportsShadowBuild)
-        return Utils::FileName::fromString(Qt4Project::shadowBuildDirectory(projectPath, k, suffix));
+        return Utils::FileName::fromString(QmakeProject::shadowBuildDirectory(projectPath, k, suffix));
     return Utils::FileName::fromString(ProjectExplorer::Project::projectDirectory(projectPath));
 }
 
@@ -199,7 +199,7 @@ NamedWidget *QmakeBuildConfiguration::createConfigWidget()
 QString QmakeBuildConfiguration::defaultShadowBuildDirectory() const
 {
     // todo displayName isn't ideal
-    return Qt4Project::shadowBuildDirectory(target()->project()->projectFilePath(),
+    return QmakeProject::shadowBuildDirectory(target()->project()->projectFilePath(),
                                             target()->kit(), displayName());
 }
 
@@ -212,7 +212,7 @@ bool QmakeBuildConfiguration::supportsShadowBuilds()
 /// If only a sub tree should be build this function returns which sub node
 /// should be build
 /// \see QMakeBuildConfiguration::setSubNodeBuild
-Qt4ProFileNode *QmakeBuildConfiguration::subNodeBuild() const
+QmakeProFileNode *QmakeBuildConfiguration::subNodeBuild() const
 {
     return m_subNodeBuild;
 }
@@ -223,7 +223,7 @@ Qt4ProFileNode *QmakeBuildConfiguration::subNodeBuild() const
 /// calling BuildManager::buildProject( BuildConfiguration * )
 /// and reset immediately afterwards
 /// That is m_subNodesBuild is set only temporarly
-void QmakeBuildConfiguration::setSubNodeBuild(Qt4ProFileNode *node)
+void QmakeBuildConfiguration::setSubNodeBuild(QmakeProFileNode *node)
 {
     m_subNodeBuild = node;
 }
@@ -260,7 +260,7 @@ void QmakeBuildConfiguration::setBuildDirectory(const FileName &directory)
 
 QString QmakeBuildConfiguration::makefile() const
 {
-    return static_cast<Qt4Project *>(target()->project())->rootQt4ProjectNode()->makefile();
+    return static_cast<QmakeProject *>(target()->project())->rootQmakeProjectNode()->makefile();
 }
 
 BaseQtVersion::QmakeBuildConfigs QmakeBuildConfiguration::qmakeBuildConfiguration() const
@@ -283,7 +283,7 @@ void QmakeBuildConfiguration::emitProFileEvaluateNeeded()
     Target *t = target();
     Project *p = t->project();
     if (t->activeBuildConfiguration() == this && p->activeTarget() == t)
-        static_cast<Qt4Project *>(p)->scheduleAsyncUpdate();
+        static_cast<QmakeProject *>(p)->scheduleAsyncUpdate();
 }
 
 void QmakeBuildConfiguration::emitQMakeBuildConfigurationChanged()
@@ -544,7 +544,7 @@ bool QmakeBuildConfigurationFactory::canHandle(const Target *t) const
 {
     if (!t->project()->supportsKit(t->kit()))
         return false;
-    return qobject_cast<Qt4Project *>(t->project());
+    return qobject_cast<QmakeProject *>(t->project());
 }
 
 QmakeBuildInfo *QmakeBuildConfigurationFactory::createBuildInfo(const Kit *k,
diff --git a/src/plugins/qt4projectmanager/qmakebuildconfiguration.h b/src/plugins/qt4projectmanager/qmakebuildconfiguration.h
index 02fbaedc84..742350a439 100644
--- a/src/plugins/qt4projectmanager/qmakebuildconfiguration.h
+++ b/src/plugins/qt4projectmanager/qmakebuildconfiguration.h
@@ -43,7 +43,7 @@ class QmakeBuildInfo;
 class QMakeStep;
 class MakeStep;
 class QmakeBuildConfigurationFactory;
-class Qt4ProFileNode;
+class QmakeProFileNode;
 
 namespace Internal { class Qt4ProjectConfigWidget; }
 
@@ -58,8 +58,8 @@ public:
     ProjectExplorer::NamedWidget *createConfigWidget();
     bool isShadowBuild() const;
 
-    void setSubNodeBuild(QmakeProjectManager::Qt4ProFileNode *node);
-    QmakeProjectManager::Qt4ProFileNode *subNodeBuild() const;
+    void setSubNodeBuild(QmakeProjectManager::QmakeProFileNode *node);
+    QmakeProjectManager::QmakeProFileNode *subNodeBuild() const;
 
     ProjectExplorer::FileNode *fileNodeBuild() const;
     void setFileNodeBuild(ProjectExplorer::FileNode *node);
@@ -148,7 +148,7 @@ private:
     bool m_isEnabled;
     bool m_qtVersionSupportsShadowBuilds;
     QtSupport::BaseQtVersion::QmakeBuildConfigs m_qmakeBuildConfiguration;
-    QmakeProjectManager::Qt4ProFileNode *m_subNodeBuild;
+    QmakeProjectManager::QmakeProFileNode *m_subNodeBuild;
     ProjectExplorer::FileNode *m_fileNodeBuild;
 
     friend class Internal::Qt4ProjectConfigWidget;
diff --git a/src/plugins/qt4projectmanager/qmakenodes.cpp b/src/plugins/qt4projectmanager/qmakenodes.cpp
index 60de1d02c1..41872dd259 100644
--- a/src/plugins/qt4projectmanager/qmakenodes.cpp
+++ b/src/plugins/qt4projectmanager/qmakenodes.cpp
@@ -143,7 +143,7 @@ Qt4NodeStaticData::Qt4NodeStaticData()
                                                     overlayIcon, desiredSize);
         QIcon folderIcon;
         folderIcon.addPixmap(folderPixmap);
-        const QString desc = QmakeProjectManager::Qt4PriFileNode::tr(fileTypeDataStorage[i].typeName);
+        const QString desc = QmakeProjectManager::QmakePriFileNode::tr(fileTypeDataStorage[i].typeName);
         fileTypeData.push_back(Qt4NodeStaticData::FileTypeData(fileTypeDataStorage[i].type,
                                                                desc, folderIcon));
     }
@@ -170,13 +170,13 @@ enum { debug = 0 };
 using namespace QmakeProjectManager;
 using namespace QmakeProjectManager::Internal;
 
-Qt4PriFile::Qt4PriFile(QmakeProjectManager::Qt4PriFileNode *qt4PriFile)
-    : IDocument(qt4PriFile), m_priFile(qt4PriFile)
+QmakePriFile::QmakePriFile(QmakeProjectManager::QmakePriFileNode *qmakePriFile)
+    : IDocument(qmakePriFile), m_priFile(qmakePriFile)
 {
     setFilePath(m_priFile->path());
 }
 
-bool Qt4PriFile::save(QString *errorString, const QString &fileName, bool autoSave)
+bool QmakePriFile::save(QString *errorString, const QString &fileName, bool autoSave)
 {
     Q_UNUSED(errorString);
     Q_UNUSED(fileName);
@@ -184,39 +184,39 @@ bool Qt4PriFile::save(QString *errorString, const QString &fileName, bool autoSa
     return false;
 }
 
-QString Qt4PriFile::defaultPath() const
+QString QmakePriFile::defaultPath() const
 {
     return QString();
 }
 
-QString Qt4PriFile::suggestedFileName() const
+QString QmakePriFile::suggestedFileName() const
 {
     return QString();
 }
 
-QString Qt4PriFile::mimeType() const
+QString QmakePriFile::mimeType() const
 {
     return QLatin1String(QmakeProjectManager::Constants::PROFILE_MIMETYPE);
 }
 
-bool Qt4PriFile::isModified() const
+bool QmakePriFile::isModified() const
 {
     return false;
 }
 
-bool Qt4PriFile::isSaveAsAllowed() const
+bool QmakePriFile::isSaveAsAllowed() const
 {
     return false;
 }
 
-Core::IDocument::ReloadBehavior Qt4PriFile::reloadBehavior(ChangeTrigger state, ChangeType type) const
+Core::IDocument::ReloadBehavior QmakePriFile::reloadBehavior(ChangeTrigger state, ChangeType type) const
 {
     Q_UNUSED(state)
     Q_UNUSED(type)
     return BehaviorSilent;
 }
 
-bool Qt4PriFile::reload(QString *errorString, ReloadFlag flag, ChangeType type)
+bool QmakePriFile::reload(QString *errorString, ReloadFlag flag, ChangeType type)
 {
     Q_UNUSED(errorString)
     Q_UNUSED(flag)
@@ -233,32 +233,32 @@ bool Qt4PriFile::reload(QString *errorString, ReloadFlag flag, ChangeType type)
 
 namespace QmakeProjectManager {
 
-Qt4PriFileNode::Qt4PriFileNode(Qt4Project *project, Qt4ProFileNode* qt4ProFileNode, const QString &filePath)
+QmakePriFileNode::QmakePriFileNode(QmakeProject *project, QmakeProFileNode* qt4ProFileNode, const QString &filePath)
         : ProjectNode(filePath),
           m_project(project),
-          m_qt4ProFileNode(qt4ProFileNode),
+          m_qmakeProFileNode(qt4ProFileNode),
           m_projectFilePath(QDir::fromNativeSeparators(filePath)),
           m_projectDir(QFileInfo(filePath).absolutePath()),
           m_includedInExactParse(true)
 {
     Q_ASSERT(project);
-    m_qt4PriFile = new Qt4PriFile(this);
-    Core::DocumentManager::addDocument(m_qt4PriFile);
+    m_qmakePriFile = new QmakePriFile(this);
+    Core::DocumentManager::addDocument(m_qmakePriFile);
 
     setDisplayName(QFileInfo(filePath).completeBaseName());
 
     setIcon(qt4NodeStaticData()->projectIcon);
 }
 
-Qt4PriFileNode::~Qt4PriFileNode()
+QmakePriFileNode::~QmakePriFileNode()
 {
     watchFolders(QSet<QString>());
 }
 
-void Qt4PriFileNode::scheduleUpdate()
+void QmakePriFileNode::scheduleUpdate()
 {
     QtSupport::ProFileCacheManager::instance()->discardFile(m_projectFilePath);
-    m_qt4ProFileNode->scheduleUpdate();
+    m_qmakeProFileNode->scheduleUpdate();
 }
 
 namespace Internal {
@@ -385,7 +385,7 @@ struct InternalNode
     }
 
     // Makes the projectNode's subtree below the given folder match this internal node's subtree
-    void updateSubFolders(QmakeProjectManager::Qt4PriFileNode *projectNode, ProjectExplorer::FolderNode *folder)
+    void updateSubFolders(QmakeProjectManager::QmakePriFileNode *projectNode, ProjectExplorer::FolderNode *folder)
     {
         updateFiles(projectNode, folder, type);
 
@@ -476,7 +476,7 @@ struct InternalNode
     }
 
     // Makes the folder's files match this internal node's file list
-    void updateFiles(QmakeProjectManager::Qt4PriFileNode *projectNode, FolderNode *folder, FileType type)
+    void updateFiles(QmakeProjectManager::QmakePriFileNode *projectNode, FolderNode *folder, FileType type)
     {
         QList<FileNode*> existingFileNodes;
         foreach (FileNode *fileNode, folder->fileNodes()) {
@@ -522,7 +522,7 @@ struct InternalNode
 };
 }
 
-QStringList Qt4PriFileNode::baseVPaths(QtSupport::ProFileReader *reader, const QString &projectDir, const QString &buildDir) const
+QStringList QmakePriFileNode::baseVPaths(QtSupport::ProFileReader *reader, const QString &projectDir, const QString &buildDir) const
 {
     QStringList result;
     if (!reader)
@@ -534,7 +534,7 @@ QStringList Qt4PriFileNode::baseVPaths(QtSupport::ProFileReader *reader, const Q
     return result;
 }
 
-QStringList Qt4PriFileNode::fullVPaths(const QStringList &baseVPaths, QtSupport::ProFileReader *reader,
+QStringList QmakePriFileNode::fullVPaths(const QStringList &baseVPaths, QtSupport::ProFileReader *reader,
                                        const QString &qmakeVariable, const QString &projectDir) const
 {
     QStringList vPaths;
@@ -546,7 +546,7 @@ QStringList Qt4PriFileNode::fullVPaths(const QStringList &baseVPaths, QtSupport:
     return vPaths;
 }
 
-QSet<Utils::FileName> Qt4PriFileNode::recursiveEnumerate(const QString &folder)
+QSet<Utils::FileName> QmakePriFileNode::recursiveEnumerate(const QString &folder)
 {
     QSet<Utils::FileName> result;
     QFileInfo fi(folder);
@@ -566,13 +566,13 @@ QSet<Utils::FileName> Qt4PriFileNode::recursiveEnumerate(const QString &folder)
     return result;
 }
 
-void Qt4PriFileNode::update(ProFile *includeFileExact, QtSupport::ProFileReader *readerExact, ProFile *includeFileCumlative, QtSupport::ProFileReader *readerCumulative)
+void QmakePriFileNode::update(ProFile *includeFileExact, QtSupport::ProFileReader *readerExact, ProFile *includeFileCumlative, QtSupport::ProFileReader *readerCumulative)
 {
     // add project file node
     if (m_fileNodes.isEmpty())
         addFileNodes(QList<FileNode*>() << new ProjectExplorer::FileNode(m_projectFilePath, ProjectExplorer::ProjectFileType, false), this);
 
-    const QString &projectDir = m_qt4ProFileNode->m_projectDir;
+    const QString &projectDir = m_qmakeProFileNode->m_projectDir;
 
     InternalNode contents;
 
@@ -630,10 +630,10 @@ void Qt4PriFileNode::update(ProFile *includeFileExact, QtSupport::ProFileReader
 
     QStringList baseVPathsExact;
     if (includeFileExact)
-        baseVPathsExact = baseVPaths(readerExact, projectDir, m_qt4ProFileNode->buildDir());
+        baseVPathsExact = baseVPaths(readerExact, projectDir, m_qmakeProFileNode->buildDir());
     QStringList baseVPathsCumulative;
     if (includeFileCumlative)
-        baseVPathsCumulative = baseVPaths(readerCumulative, projectDir, m_qt4ProFileNode->buildDir());
+        baseVPathsCumulative = baseVPaths(readerCumulative, projectDir, m_qmakeProFileNode->buildDir());
 
     const QVector<Qt4NodeStaticData::FileTypeData> &fileTypes = qt4NodeStaticData()->fileTypeData;
 
@@ -699,7 +699,7 @@ void Qt4PriFileNode::update(ProFile *includeFileExact, QtSupport::ProFileReader
     contents.updateSubFolders(this, this);
 }
 
-void Qt4PriFileNode::watchFolders(const QSet<QString> &folders)
+void QmakePriFileNode::watchFolders(const QSet<QString> &folders)
 {
     QSet<QString> toUnwatch = m_watchedFolders;
     toUnwatch.subtract(folders);
@@ -715,7 +715,7 @@ void Qt4PriFileNode::watchFolders(const QSet<QString> &folders)
     m_watchedFolders = folders;
 }
 
-bool Qt4PriFileNode::folderChanged(const QString &changedFolder, const QSet<Utils::FileName> &newFiles)
+bool QmakePriFileNode::folderChanged(const QString &changedFolder, const QSet<Utils::FileName> &newFiles)
 {
     //qDebug()<<"########## Qt4PriFileNode::folderChanged";
     // So, we need to figure out which files changed.
@@ -777,7 +777,7 @@ bool Qt4PriFileNode::folderChanged(const QString &changedFolder, const QSet<Util
     return true;
 }
 
-bool Qt4PriFileNode::deploysFolder(const QString &folder) const
+bool QmakePriFileNode::deploysFolder(const QString &folder) const
 {
     QString f = folder;
     const QChar slash = QLatin1Char('/');
@@ -792,7 +792,7 @@ bool Qt4PriFileNode::deploysFolder(const QString &folder) const
     return false;
 }
 
-QList<ProjectExplorer::RunConfiguration *> Qt4PriFileNode::runConfigurationsFor(Node *node)
+QList<ProjectExplorer::RunConfiguration *> QmakePriFileNode::runConfigurationsFor(Node *node)
 {
     QmakeRunConfigurationFactory *factory = QmakeRunConfigurationFactory::find(m_project->activeTarget());
     if (factory)
@@ -800,39 +800,39 @@ QList<ProjectExplorer::RunConfiguration *> Qt4PriFileNode::runConfigurationsFor(
     return QList<ProjectExplorer::RunConfiguration *>();
 }
 
-QList<Qt4PriFileNode *> Qt4PriFileNode::subProjectNodesExact() const
+QList<QmakePriFileNode *> QmakePriFileNode::subProjectNodesExact() const
 {
-    QList<Qt4PriFileNode *> nodes;
+    QList<QmakePriFileNode *> nodes;
     foreach (ProjectNode *node, subProjectNodes()) {
-        Qt4PriFileNode *n = qobject_cast<Qt4PriFileNode *>(node);
+        QmakePriFileNode *n = qobject_cast<QmakePriFileNode *>(node);
         if (n && n->includedInExactParse())
             nodes << n;
     }
     return nodes;
 }
 
-Qt4ProFileNode *Qt4PriFileNode::proFileNode() const
+QmakeProFileNode *QmakePriFileNode::proFileNode() const
 {
-    return m_qt4ProFileNode;
+    return m_qmakeProFileNode;
 }
 
-bool Qt4PriFileNode::includedInExactParse() const
+bool QmakePriFileNode::includedInExactParse() const
 {
     return m_includedInExactParse;
 }
 
-void Qt4PriFileNode::setIncludedInExactParse(bool b)
+void QmakePriFileNode::setIncludedInExactParse(bool b)
 {
     m_includedInExactParse = b;
 }
 
-QList<ProjectNode::ProjectAction> Qt4PriFileNode::supportedActions(Node *node) const
+QList<ProjectNode::ProjectAction> QmakePriFileNode::supportedActions(Node *node) const
 {
     QList<ProjectAction> actions;
 
     const FolderNode *folderNode = this;
-    const Qt4ProFileNode *proFileNode;
-    while (!(proFileNode = qobject_cast<const Qt4ProFileNode*>(folderNode)))
+    const QmakeProFileNode *proFileNode;
+    while (!(proFileNode = qobject_cast<const QmakeProFileNode*>(folderNode)))
         folderNode = folderNode->parentFolderNode();
     Q_ASSERT(proFileNode);
 
@@ -890,7 +890,7 @@ QList<ProjectNode::ProjectAction> Qt4PriFileNode::supportedActions(Node *node) c
     return actions;
 }
 
-bool Qt4PriFileNode::canAddSubProject(const QString &proFilePath) const
+bool QmakePriFileNode::canAddSubProject(const QString &proFilePath) const
 {
     QFileInfo fi(proFilePath);
     if (fi.suffix() == QLatin1String("pro")
@@ -911,7 +911,7 @@ static QString simplifyProFilePath(const QString &proFilePath)
     return proFilePath;
 }
 
-bool Qt4PriFileNode::addSubProjects(const QStringList &proFilePaths)
+bool QmakePriFileNode::addSubProjects(const QStringList &proFilePaths)
 {
     ProjectExplorer::FindAllFilesVisitor visitor;
     accept(&visitor);
@@ -928,7 +928,7 @@ bool Qt4PriFileNode::addSubProjects(const QStringList &proFilePaths)
     return failedFiles.isEmpty();
 }
 
-bool Qt4PriFileNode::removeSubProjects(const QStringList &proFilePaths)
+bool QmakePriFileNode::removeSubProjects(const QStringList &proFilePaths)
 {
     QStringList failedOriginalFiles;
     changeFiles(QLatin1String(Constants::PROFILE_MIMETYPE), proFilePaths, &failedOriginalFiles, RemoveFromProFile);
@@ -943,7 +943,7 @@ bool Qt4PriFileNode::removeSubProjects(const QStringList &proFilePaths)
     return failedSimplifiedFiles.isEmpty();
 }
 
-bool Qt4PriFileNode::addFiles(const QStringList &filePaths, QStringList *notAdded)
+bool QmakePriFileNode::addFiles(const QStringList &filePaths, QStringList *notAdded)
 {
     // If a file is already referenced in the .pro file then we don't add them.
     // That ignores scopes and which variable was used to reference the file
@@ -997,7 +997,7 @@ bool Qt4PriFileNode::addFiles(const QStringList &filePaths, QStringList *notAdde
     return failedFiles.isEmpty();
 }
 
-bool Qt4PriFileNode::removeFiles(const QStringList &filePaths,
+bool QmakePriFileNode::removeFiles(const QStringList &filePaths,
                               QStringList *notRemoved)
 {
     QStringList failedFiles;
@@ -1017,7 +1017,7 @@ bool Qt4PriFileNode::removeFiles(const QStringList &filePaths,
     return failedFiles.isEmpty();
 }
 
-bool Qt4PriFileNode::deleteFiles(const QStringList &filePaths)
+bool QmakePriFileNode::deleteFiles(const QStringList &filePaths)
 {
     QStringList failedFiles;
     typedef QMap<QString, QStringList> TypeFileMap;
@@ -1034,7 +1034,7 @@ bool Qt4PriFileNode::deleteFiles(const QStringList &filePaths)
     return true;
 }
 
-bool Qt4PriFileNode::renameFile(const QString &filePath, const QString &newFilePath)
+bool QmakePriFileNode::renameFile(const QString &filePath, const QString &newFilePath)
 {
     if (newFilePath.isEmpty())
         return false;
@@ -1052,14 +1052,14 @@ bool Qt4PriFileNode::renameFile(const QString &filePath, const QString &newFileP
     return true;
 }
 
-bool Qt4PriFileNode::priFileWritable(const QString &path)
+bool QmakePriFileNode::priFileWritable(const QString &path)
 {
     Core::Internal::ReadOnlyFilesDialog roDialog(path, Core::ICore::mainWindow());
     roDialog.setShowFailWarning(true);
     return roDialog.exec() != Core::Internal::ReadOnlyFilesDialog::RO_Cancel;
 }
 
-bool Qt4PriFileNode::saveModifiedEditors()
+bool QmakePriFileNode::saveModifiedEditors()
 {
     Core::IDocument *document
             = Core::EditorManager::documentModel()->documentForFilePath(m_projectFilePath);
@@ -1077,7 +1077,7 @@ bool Qt4PriFileNode::saveModifiedEditors()
     return true;
 }
 
-QStringList Qt4PriFileNode::formResources(const QString &formFile) const
+QStringList QmakePriFileNode::formResources(const QString &formFile) const
 {
     QStringList resourceFiles;
     QFile file(formFile);
@@ -1112,7 +1112,7 @@ QStringList Qt4PriFileNode::formResources(const QString &formFile) const
     return resourceFiles;
 }
 
-bool Qt4PriFileNode::ensureWriteableProFile(const QString &file)
+bool QmakePriFileNode::ensureWriteableProFile(const QString &file)
 {
     // Ensure that the file is not read only
     QFileInfo fi(file);
@@ -1132,7 +1132,7 @@ bool Qt4PriFileNode::ensureWriteableProFile(const QString &file)
     return true;
 }
 
-QPair<ProFile *, QStringList> Qt4PriFileNode::readProFile(const QString &file)
+QPair<ProFile *, QStringList> QmakePriFileNode::readProFile(const QString &file)
 {
     QStringList lines;
     ProFile *includeFile = 0;
@@ -1141,7 +1141,7 @@ QPair<ProFile *, QStringList> Qt4PriFileNode::readProFile(const QString &file)
         {
             Utils::FileReader reader;
             if (!reader.fetch(file, QIODevice::Text)) {
-                Qt4Project::proFileParseError(reader.errorString());
+                QmakeProject::proFileParseError(reader.errorString());
                 return qMakePair(includeFile, lines);
             }
             contents = QString::fromLocal8Bit(reader.data());
@@ -1156,7 +1156,7 @@ QPair<ProFile *, QStringList> Qt4PriFileNode::readProFile(const QString &file)
     return qMakePair(includeFile, lines);
 }
 
-void Qt4PriFileNode::changeFiles(const QString &mimeType,
+void QmakePriFileNode::changeFiles(const QString &mimeType,
                                  const QStringList &filePaths,
                                  QStringList *notChanged,
                                  ChangeType change)
@@ -1179,7 +1179,7 @@ void Qt4PriFileNode::changeFiles(const QString &mimeType,
     if (!includeFile)
         return;
 
-    QDir priFileDir = QDir(m_qt4ProFileNode->m_projectDir);
+    QDir priFileDir = QDir(m_qmakeProFileNode->m_projectDir);
 
     if (change == AddToProFile) {
         // Use the first variable for adding.
@@ -1194,7 +1194,7 @@ void Qt4PriFileNode::changeFiles(const QString &mimeType,
     includeFile->deref();
 }
 
-bool Qt4PriFileNode::setProVariable(const QString &var, const QString &value)
+bool QmakePriFileNode::setProVariable(const QString &var, const QString &value)
 {
     if (!ensureWriteableProFile(m_projectFilePath))
         return false;
@@ -1213,7 +1213,7 @@ bool Qt4PriFileNode::setProVariable(const QString &var, const QString &value)
     return true;
 }
 
-void Qt4PriFileNode::save(const QStringList &lines)
+void QmakePriFileNode::save(const QStringList &lines)
 {
     Core::DocumentManager::expectFileChange(m_projectFilePath);
     Utils::FileSaver saver(m_projectFilePath, QIODevice::Text);
@@ -1239,7 +1239,7 @@ void Qt4PriFileNode::save(const QStringList &lines)
                              errorStrings.join(QLatin1String("\n")));
 }
 
-QStringList Qt4PriFileNode::varNames(ProjectExplorer::FileType type)
+QStringList QmakePriFileNode::varNames(ProjectExplorer::FileType type)
 {
     QStringList vars;
     switch (type) {
@@ -1279,7 +1279,7 @@ QStringList Qt4PriFileNode::varNames(ProjectExplorer::FileType type)
 //! \return the qmake variable name for the mime type
 //! Note: Only used for adding.
 //!
-QString Qt4PriFileNode::varNameForAdding(const QString &mimeType)
+QString QmakePriFileNode::varNameForAdding(const QString &mimeType)
 {
     if (mimeType == QLatin1String(ProjectExplorer::Constants::CPP_HEADER_MIMETYPE)
             || mimeType == QLatin1String(ProjectExplorer::Constants::C_HEADER_MIMETYPE)) {
@@ -1314,7 +1314,7 @@ QString Qt4PriFileNode::varNameForAdding(const QString &mimeType)
 //! \return all qmake variables which are displayed in the project tree
 //! Note: Only used for removing.
 //!
-QStringList Qt4PriFileNode::varNamesForRemoving()
+QStringList QmakePriFileNode::varNamesForRemoving()
 {
     QStringList vars;
     vars << QLatin1String("HEADERS");
@@ -1330,7 +1330,7 @@ QStringList Qt4PriFileNode::varNamesForRemoving()
     return vars;
 }
 
-QStringList Qt4PriFileNode::dynamicVarNames(QtSupport::ProFileReader *readerExact, QtSupport::ProFileReader *readerCumulative,
+QStringList QmakePriFileNode::dynamicVarNames(QtSupport::ProFileReader *readerExact, QtSupport::ProFileReader *readerCumulative,
                                             QtSupport::BaseQtVersion *qtVersion)
 {
     QStringList result;
@@ -1365,7 +1365,7 @@ QStringList Qt4PriFileNode::dynamicVarNames(QtSupport::ProFileReader *readerExac
     return result;
 }
 
-QSet<Utils::FileName> Qt4PriFileNode::filterFilesProVariables(ProjectExplorer::FileType fileType, const QSet<Utils::FileName> &files)
+QSet<Utils::FileName> QmakePriFileNode::filterFilesProVariables(ProjectExplorer::FileType fileType, const QSet<Utils::FileName> &files)
 {
     if (fileType != ProjectExplorer::QMLType && fileType != ProjectExplorer::UnknownFileType)
         return files;
@@ -1382,7 +1382,7 @@ QSet<Utils::FileName> Qt4PriFileNode::filterFilesProVariables(ProjectExplorer::F
     return result;
 }
 
-QSet<Utils::FileName> Qt4PriFileNode::filterFilesRecursiveEnumerata(ProjectExplorer::FileType fileType, const QSet<Utils::FileName> &files)
+QSet<Utils::FileName> QmakePriFileNode::filterFilesRecursiveEnumerata(ProjectExplorer::FileType fileType, const QSet<Utils::FileName> &files)
 {
     QSet<Utils::FileName> result;
     if (fileType != ProjectExplorer::QMLType && fileType != ProjectExplorer::UnknownFileType)
@@ -1439,40 +1439,40 @@ namespace {
     };
 }
 
-Qt4NodesWatcher::Qt4NodesWatcher(QObject *parent)
+QmakeNodesWatcher::QmakeNodesWatcher(QObject *parent)
         : NodesWatcher(parent)
 {
 }
 
-const Qt4ProFileNode *Qt4ProFileNode::findProFileFor(const QString &fileName) const
+const QmakeProFileNode *QmakeProFileNode::findProFileFor(const QString &fileName) const
 {
     if (fileName == path())
         return this;
     foreach (ProjectNode *pn, subProjectNodes())
-        if (Qt4ProFileNode *qt4ProFileNode = qobject_cast<Qt4ProFileNode *>(pn))
-            if (const Qt4ProFileNode *result = qt4ProFileNode->findProFileFor(fileName))
+        if (QmakeProFileNode *qt4ProFileNode = qobject_cast<QmakeProFileNode *>(pn))
+            if (const QmakeProFileNode *result = qt4ProFileNode->findProFileFor(fileName))
                 return result;
     return 0;
 }
 
-QString Qt4ProFileNode::makefile() const
+QString QmakeProFileNode::makefile() const
 {
     return singleVariableValue(Makefile);
 }
 
-QString Qt4ProFileNode::objectExtension() const
+QString QmakeProFileNode::objectExtension() const
 {
     if (m_varValues[ObjectExt].isEmpty())
         return Utils::HostOsInfo::isWindowsHost() ? QLatin1String(".obj") : QLatin1String(".o");
     return m_varValues[ObjectExt].first();
 }
 
-QString Qt4ProFileNode::objectsDirectory() const
+QString QmakeProFileNode::objectsDirectory() const
 {
     return singleVariableValue(ObjectsDir);
 }
 
-QByteArray Qt4ProFileNode::cxxDefines() const
+QByteArray QmakeProFileNode::cxxDefines() const
 {
     QByteArray result;
     foreach (const QString &def, variableValue(DefinesVar)) {
@@ -1493,7 +1493,7 @@ QByteArray Qt4ProFileNode::cxxDefines() const
     return result;
 }
 
-bool Qt4ProFileNode::isDeployable() const
+bool QmakeProFileNode::isDeployable() const
 {
     return m_isDeployable;
 }
@@ -1502,10 +1502,10 @@ bool Qt4ProFileNode::isDeployable() const
   \class Qt4ProFileNode
   Implements abstract ProjectNode class
   */
-Qt4ProFileNode::Qt4ProFileNode(Qt4Project *project,
+QmakeProFileNode::QmakeProFileNode(QmakeProject *project,
                                const QString &filePath,
                                QObject *parent)
-        : Qt4PriFileNode(project, this, filePath),
+        : QmakePriFileNode(project, this, filePath),
           m_validParse(false),
           m_parseInProgress(true),
           m_projectType(InvalidProject),
@@ -1519,7 +1519,7 @@ Qt4ProFileNode::Qt4ProFileNode(Qt4Project *project,
             this, SLOT(applyAsyncEvaluate()));
 }
 
-Qt4ProFileNode::~Qt4ProFileNode()
+QmakeProFileNode::~QmakeProFileNode()
 {
     m_parseFutureWatcher.waitForFinished();
     if (m_readerExact) {
@@ -1529,127 +1529,127 @@ Qt4ProFileNode::~Qt4ProFileNode()
     }
 }
 
-bool Qt4ProFileNode::isParent(Qt4ProFileNode *node)
+bool QmakeProFileNode::isParent(QmakeProFileNode *node)
 {
-    while ((node = qobject_cast<Qt4ProFileNode *>(node->parentFolderNode()))) {
+    while ((node = qobject_cast<QmakeProFileNode *>(node->parentFolderNode()))) {
         if (node == this)
             return true;
     }
     return false;
 }
 
-bool Qt4ProFileNode::hasBuildTargets() const
+bool QmakeProFileNode::hasBuildTargets() const
 {
     return hasBuildTargets(projectType());
 }
 
-bool Qt4ProFileNode::hasBuildTargets(Qt4ProjectType projectType) const
+bool QmakeProFileNode::hasBuildTargets(Qt4ProjectType projectType) const
 {
     return (projectType == ApplicationTemplate || projectType == LibraryTemplate);
 }
 
-bool Qt4ProFileNode::isDebugAndRelease() const
+bool QmakeProFileNode::isDebugAndRelease() const
 {
     const QStringList configValues = m_varValues.value(ConfigVar);
     return configValues.contains(QLatin1String("debug_and_release"));
 }
 
-Qt4ProjectType Qt4ProFileNode::projectType() const
+Qt4ProjectType QmakeProFileNode::projectType() const
 {
     return m_projectType;
 }
 
-QStringList Qt4ProFileNode::variableValue(const Qt4Variable var) const
+QStringList QmakeProFileNode::variableValue(const Qt4Variable var) const
 {
     return m_varValues.value(var);
 }
 
-QString Qt4ProFileNode::singleVariableValue(const Qt4Variable var) const
+QString QmakeProFileNode::singleVariableValue(const Qt4Variable var) const
 {
     const QStringList &values = variableValue(var);
     return values.isEmpty() ? QString() : values.first();
 }
 
-QHash<QString, QString> Qt4ProFileNode::uiFiles() const
+QHash<QString, QString> QmakeProFileNode::uiFiles() const
 {
     return m_uiFiles;
 }
 
-void Qt4ProFileNode::emitProFileUpdatedRecursive()
+void QmakeProFileNode::emitProFileUpdatedRecursive()
 {
     foreach (ProjectExplorer::NodesWatcher *watcher, watchers())
-        if (Internal::Qt4NodesWatcher *qt4Watcher = qobject_cast<Internal::Qt4NodesWatcher*>(watcher))
+        if (Internal::QmakeNodesWatcher *qt4Watcher = qobject_cast<Internal::QmakeNodesWatcher*>(watcher))
             emit qt4Watcher->proFileUpdated(this, m_validParse, m_parseInProgress);
 
     foreach (ProjectNode *subNode, subProjectNodes()) {
-        if (Qt4ProFileNode *node = qobject_cast<Qt4ProFileNode *>(subNode))
+        if (QmakeProFileNode *node = qobject_cast<QmakeProFileNode *>(subNode))
             node->emitProFileUpdatedRecursive();
     }
 }
 
-void Qt4ProFileNode::setParseInProgressRecursive(bool b)
+void QmakeProFileNode::setParseInProgressRecursive(bool b)
 {
     setParseInProgress(b);
     foreach (ProjectNode *subNode, subProjectNodes()) {
-        if (Qt4ProFileNode *node = qobject_cast<Qt4ProFileNode *>(subNode))
+        if (QmakeProFileNode *node = qobject_cast<QmakeProFileNode *>(subNode))
             node->setParseInProgressRecursive(b);
     }
 }
 
-void Qt4ProFileNode::setParseInProgress(bool b)
+void QmakeProFileNode::setParseInProgress(bool b)
 {
     if (m_parseInProgress == b)
         return;
     m_parseInProgress = b;
     foreach (ProjectExplorer::NodesWatcher *watcher, watchers())
-        if (Internal::Qt4NodesWatcher *qt4Watcher = qobject_cast<Internal::Qt4NodesWatcher*>(watcher))
+        if (Internal::QmakeNodesWatcher *qt4Watcher = qobject_cast<Internal::QmakeNodesWatcher*>(watcher))
             emit qt4Watcher->proFileUpdated(this, m_validParse, m_parseInProgress);
 }
 
-void Qt4ProFileNode::setValidParseRecursive(bool b)
+void QmakeProFileNode::setValidParseRecursive(bool b)
 {
     setValidParse(b);
     foreach (ProjectNode *subNode, subProjectNodes()) {
-        if (Qt4ProFileNode *node = qobject_cast<Qt4ProFileNode *>(subNode))
+        if (QmakeProFileNode *node = qobject_cast<QmakeProFileNode *>(subNode))
             node->setValidParseRecursive(b);
     }
 }
 
 // Do note the absence of signal emission, always set validParse
 // before setParseInProgress, as that will emit the signals
-void Qt4ProFileNode::setValidParse(bool b)
+void QmakeProFileNode::setValidParse(bool b)
 {
     if (m_validParse == b)
         return;
     m_validParse = b;
 }
 
-bool Qt4ProFileNode::validParse() const
+bool QmakeProFileNode::validParse() const
 {
     return m_validParse;
 }
 
-bool Qt4ProFileNode::parseInProgress() const
+bool QmakeProFileNode::parseInProgress() const
 {
     return m_parseInProgress;
 }
 
-void Qt4ProFileNode::scheduleUpdate()
+void QmakeProFileNode::scheduleUpdate()
 {
     setParseInProgressRecursive(true);
     m_project->scheduleAsyncUpdate(this);
 }
 
-void Qt4ProFileNode::asyncUpdate()
+void QmakeProFileNode::asyncUpdate()
 {
     m_project->incrementPendingEvaluateFutures();
     setupReader();
     m_parseFutureWatcher.waitForFinished();
-    QFuture<EvalResult> future = QtConcurrent::run(&Qt4ProFileNode::asyncEvaluate, this);
+    QFuture<EvalResult> future = QtConcurrent::run(&QmakeProFileNode::asyncEvaluate, this);
     m_parseFutureWatcher.setFuture(future);
 }
 
-void Qt4ProFileNode::update()
+void QmakeProFileNode::update()
 {
     setParseInProgressRecursive(true);
     setupReader();
@@ -1657,7 +1657,7 @@ void Qt4ProFileNode::update()
     applyEvaluate(evalResult, false);
 }
 
-void Qt4ProFileNode::setupReader()
+void QmakeProFileNode::setupReader()
 {
     Q_ASSERT(!m_readerExact);
     Q_ASSERT(!m_readerCumulative);
@@ -1668,7 +1668,7 @@ void Qt4ProFileNode::setupReader()
     m_readerCumulative->setCumulative(true);
 }
 
-Qt4ProFileNode::EvalResult Qt4ProFileNode::evaluate()
+QmakeProFileNode::EvalResult QmakeProFileNode::evaluate()
 {
     EvalResult evalResult = EvalOk;
     if (ProFile *pro = m_readerExact->parsedProFile(m_projectFilePath)) {
@@ -1683,13 +1683,13 @@ Qt4ProFileNode::EvalResult Qt4ProFileNode::evaluate()
     return evalResult;
 }
 
-void Qt4ProFileNode::asyncEvaluate(QFutureInterface<EvalResult> &fi)
+void QmakeProFileNode::asyncEvaluate(QFutureInterface<EvalResult> &fi)
 {
     EvalResult evalResult = evaluate();
     fi.reportResult(evalResult);
 }
 
-void Qt4ProFileNode::applyAsyncEvaluate()
+void QmakeProFileNode::applyAsyncEvaluate()
 {
     applyEvaluate(m_parseFutureWatcher.result(), true);
     m_project->decrementPendingEvaluateFutures();
@@ -1700,7 +1700,7 @@ bool sortByNodes(Node *a, Node *b)
     return a->path() < b->path();
 }
 
-void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
+void QmakeProFileNode::applyEvaluate(EvalResult evalResult, bool async)
 {
     if (!m_readerExact)
         return;
@@ -1713,7 +1713,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
         setParseInProgressRecursive(false);
 
         if (evalResult == EvalFail) {
-            Qt4Project::proFileParseError(tr("Error while parsing file %1. Giving up.").arg(m_projectFilePath));
+            QmakeProject::proFileParseError(tr("Error while parsing file %1. Giving up.").arg(m_projectFilePath));
             if (m_projectType == InvalidProject)
                 return;
 
@@ -1727,7 +1727,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
             m_projectType = InvalidProject;
 
             foreach (ProjectExplorer::NodesWatcher *watcher, watchers())
-                if (Internal::Qt4NodesWatcher *qt4Watcher = qobject_cast<Internal::Qt4NodesWatcher*>(watcher))
+                if (Internal::QmakeNodesWatcher *qt4Watcher = qobject_cast<Internal::QmakeNodesWatcher*>(watcher))
                     emit qt4Watcher->projectTypeChanged(this, oldType, InvalidProject);
         }
         return;
@@ -1743,7 +1743,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
         // probably all subfiles/projects have changed anyway
         // delete files && folders && projects
         foreach (ProjectNode *projectNode, subProjectNodes()) {
-            if (Qt4ProFileNode *qt4ProFileNode = qobject_cast<Qt4ProFileNode *>(projectNode)) {
+            if (QmakeProFileNode *qt4ProFileNode = qobject_cast<QmakeProFileNode *>(projectNode)) {
                 qt4ProFileNode->setValidParseRecursive(false);
                 qt4ProFileNode->setParseInProgressRecursive(false);
             }
@@ -1766,7 +1766,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
         // really emit here? or at the end? Nobody is connected to this signal at the moment
         // so we kind of can ignore that question for now
         foreach (ProjectExplorer::NodesWatcher *watcher, watchers())
-            if (Internal::Qt4NodesWatcher *qt4Watcher = qobject_cast<Internal::Qt4NodesWatcher*>(watcher))
+            if (Internal::QmakeNodesWatcher *qt4Watcher = qobject_cast<Internal::QmakeNodesWatcher*>(watcher))
                 emit qt4Watcher->projectTypeChanged(this, oldType, projectType);
     }
 
@@ -1882,14 +1882,14 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
             ProFile *fileExact = includeFilesExact.value((*existingIt)->path());
             ProFile *fileCumlative = includeFilesCumlative.value((*existingIt)->path());
             if (fileExact || fileCumlative) {
-                Qt4PriFileNode *priFileNode = static_cast<Qt4PriFileNode *>(*existingIt);
+                QmakePriFileNode *priFileNode = static_cast<QmakePriFileNode *>(*existingIt);
                 priFileNode->update(fileExact, m_readerExact, fileCumlative, m_readerCumulative);
                 priFileNode->setIncludedInExactParse(fileExact != 0 && includedInExactParse());
             } else {
                 // We always parse exactly, because we later when async parsing don't know whether
                 // the .pro file is included in this .pro file
                 // So to compare that later parse with the sync one
-                Qt4ProFileNode *proFileNode = static_cast<Qt4ProFileNode *>(*existingIt);
+                QmakeProFileNode *proFileNode = static_cast<QmakeProFileNode *>(*existingIt);
                 proFileNode->setIncludedInExactParse(exactSubdirs.contains(proFileNode->path()) && includedInExactParse());
                 if (async)
                     proFileNode->asyncUpdate();
@@ -1909,7 +1909,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
             bool loop = false;
             ProjectExplorer::Node *n = this;
             while ((n = n->parentFolderNode())) {
-                if (qobject_cast<Qt4PriFileNode *>(n) && n->path() == nodeToAdd) {
+                if (qobject_cast<QmakePriFileNode *>(n) && n->path() == nodeToAdd) {
                     loop = true;
                     break;
                 }
@@ -1918,13 +1918,13 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
             if (loop) {
                 // Do nothing
             } else if (fileExact || fileCumlative) {
-                Qt4PriFileNode *qt4PriFileNode = new Qt4PriFileNode(m_project, this, nodeToAdd);
+                QmakePriFileNode *qt4PriFileNode = new QmakePriFileNode(m_project, this, nodeToAdd);
                 qt4PriFileNode->setParentFolderNode(this); // Needed for loop detection
                 qt4PriFileNode->setIncludedInExactParse(fileExact != 0 && includedInExactParse());
                 qt4PriFileNode->update(fileExact, m_readerExact, fileCumlative, m_readerCumulative);
                 toAdd << qt4PriFileNode;
             } else {
-                Qt4ProFileNode *qt4ProFileNode = new Qt4ProFileNode(m_project, nodeToAdd);
+                QmakeProFileNode *qt4ProFileNode = new QmakeProFileNode(m_project, nodeToAdd);
                 qt4ProFileNode->setParentFolderNode(this); // Needed for loop detection
                 qt4ProFileNode->setIncludedInExactParse(exactSubdirs.contains(qt4ProFileNode->path()) && includedInExactParse());
                 if (async)
@@ -1937,7 +1937,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
     } // for
 
     foreach (ProjectNode *node, toRemove) {
-        if (Qt4ProFileNode *qt4ProFileNode = qobject_cast<Qt4ProFileNode *>(node)) {
+        if (QmakeProFileNode *qt4ProFileNode = qobject_cast<QmakeProFileNode *>(node)) {
             qt4ProFileNode->setValidParseRecursive(false);
             qt4ProFileNode->setParseInProgressRecursive(false);
         }
@@ -1948,7 +1948,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
     if (!toAdd.isEmpty())
         addProjectNodes(toAdd);
 
-    Qt4PriFileNode::update(fileForCurrentProjectExact, m_readerExact, fileForCurrentProjectCumlative, m_readerCumulative);
+    QmakePriFileNode::update(fileForCurrentProjectExact, m_readerExact, fileForCurrentProjectCumlative, m_readerCumulative);
 
     m_validParse = (evalResult == EvalOk);
     if (m_validParse) {
@@ -2023,7 +2023,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
             m_varValues = newVarValues;
 
             foreach (ProjectExplorer::NodesWatcher *watcher, watchers())
-                if (Internal::Qt4NodesWatcher *qt4Watcher = qobject_cast<Internal::Qt4NodesWatcher*>(watcher))
+                if (Internal::QmakeNodesWatcher *qt4Watcher = qobject_cast<Internal::QmakeNodesWatcher*>(watcher))
                     emit qt4Watcher->variablesChanged(this, oldValues, m_varValues);
         }
     } // evalResult == EvalOk
@@ -2039,7 +2039,7 @@ void Qt4ProFileNode::applyEvaluate(EvalResult evalResult, bool async)
     m_readerCumulative = 0;
 }
 
-QStringList Qt4ProFileNode::fileListForVar(QtSupport::ProFileReader *readerExact, QtSupport::ProFileReader *readerCumulative,
+QStringList QmakeProFileNode::fileListForVar(QtSupport::ProFileReader *readerExact, QtSupport::ProFileReader *readerCumulative,
                                            const QString &varName, const QString &projectDir, const QString &buildDir) const
 {
     QStringList baseVPathsExact = baseVPaths(readerExact, projectDir, buildDir);
@@ -2062,7 +2062,7 @@ QStringList Qt4ProFileNode::fileListForVar(QtSupport::ProFileReader *readerExact
     return result;
 }
 
-QString Qt4ProFileNode::uiDirPath(QtSupport::ProFileReader *reader) const
+QString QmakeProFileNode::uiDirPath(QtSupport::ProFileReader *reader) const
 {
     QString path = reader->value(QLatin1String("UI_DIR"));
     if (QFileInfo(path).isRelative())
@@ -2070,7 +2070,7 @@ QString Qt4ProFileNode::uiDirPath(QtSupport::ProFileReader *reader) const
     return path;
 }
 
-QString Qt4ProFileNode::mocDirPath(QtSupport::ProFileReader *reader) const
+QString QmakeProFileNode::mocDirPath(QtSupport::ProFileReader *reader) const
 {
     QString path = reader->value(QLatin1String("MOC_DIR"));
     if (QFileInfo(path).isRelative())
@@ -2078,7 +2078,7 @@ QString Qt4ProFileNode::mocDirPath(QtSupport::ProFileReader *reader) const
     return path;
 }
 
-QStringList Qt4ProFileNode::includePaths(QtSupport::ProFileReader *reader) const
+QStringList QmakeProFileNode::includePaths(QtSupport::ProFileReader *reader) const
 {
     QStringList paths;
     foreach (const QString &cxxflags, m_readerExact->values(QLatin1String("QMAKE_CXXFLAGS"))) {
@@ -2098,7 +2098,7 @@ QStringList Qt4ProFileNode::includePaths(QtSupport::ProFileReader *reader) const
     return paths;
 }
 
-QStringList Qt4ProFileNode::libDirectories(QtSupport::ProFileReader *reader) const
+QStringList QmakeProFileNode::libDirectories(QtSupport::ProFileReader *reader) const
 {
     QStringList result;
     foreach (const QString &str, reader->values(QLatin1String("LIBS"))) {
@@ -2108,7 +2108,7 @@ QStringList Qt4ProFileNode::libDirectories(QtSupport::ProFileReader *reader) con
     return result;
 }
 
-QStringList Qt4ProFileNode::subDirsPaths(QtSupport::ProFileReader *reader, QStringList *subProjectsNotToDeploy,
+QStringList QmakeProFileNode::subDirsPaths(QtSupport::ProFileReader *reader, QStringList *subProjectsNotToDeploy,
                                          bool silent) const
 {
     QStringList subProjectPaths;
@@ -2153,7 +2153,7 @@ QStringList Qt4ProFileNode::subDirsPaths(QtSupport::ProFileReader *reader, QStri
             }
         } else {
             if (!silent)
-                Qt4Project::proFileParseError(tr("Could not find .pro file for sub dir '%1' in '%2'")
+                QmakeProject::proFileParseError(tr("Could not find .pro file for sub dir '%1' in '%2'")
                                               .arg(subDirVar).arg(realDir));
         }
     }
@@ -2162,7 +2162,7 @@ QStringList Qt4ProFileNode::subDirsPaths(QtSupport::ProFileReader *reader, QStri
     return subProjectPaths;
 }
 
-TargetInformation Qt4ProFileNode::targetInformation(QtSupport::ProFileReader *reader) const
+TargetInformation QmakeProFileNode::targetInformation(QtSupport::ProFileReader *reader) const
 {
     TargetInformation result;
     if (!reader)
@@ -2220,17 +2220,17 @@ TargetInformation Qt4ProFileNode::targetInformation(QtSupport::ProFileReader *re
     return result;
 }
 
-TargetInformation Qt4ProFileNode::targetInformation() const
+TargetInformation QmakeProFileNode::targetInformation() const
 {
     return m_qt4targetInformation;
 }
 
-QString Qt4ProFileNode::resolvedMkspecPath() const
+QString QmakeProFileNode::resolvedMkspecPath() const
 {
     return m_resolvedMkspecPath;
 }
 
-void Qt4ProFileNode::setupInstallsList(const QtSupport::ProFileReader *reader)
+void QmakeProFileNode::setupInstallsList(const QtSupport::ProFileReader *reader)
 {
     m_installsList.clear();
     if (!reader)
@@ -2273,19 +2273,19 @@ void Qt4ProFileNode::setupInstallsList(const QtSupport::ProFileReader *reader)
     }
 }
 
-InstallsList Qt4ProFileNode::installsList() const
+InstallsList QmakeProFileNode::installsList() const
 {
     return m_installsList;
 }
 
-QString Qt4ProFileNode::sourceDir() const
+QString QmakeProFileNode::sourceDir() const
 {
     return m_projectDir;
 }
 
-QString Qt4ProFileNode::buildDir(QmakeBuildConfiguration *bc) const
+QString QmakeProFileNode::buildDir(QmakeBuildConfiguration *bc) const
 {
-    const QDir srcDirRoot = m_project->rootQt4ProjectNode()->sourceDir();
+    const QDir srcDirRoot = m_project->rootQmakeProjectNode()->sourceDir();
     const QString relativeDir = srcDirRoot.relativeFilePath(m_projectDir);
     if (!bc && m_project->activeTarget())
         bc = static_cast<QmakeBuildConfiguration *>(m_project->activeTarget()->activeBuildConfiguration());
@@ -2294,7 +2294,7 @@ QString Qt4ProFileNode::buildDir(QmakeBuildConfiguration *bc) const
     return QDir::cleanPath(QDir(bc->buildDirectory().toString()).absoluteFilePath(relativeDir));
 }
 
-QString Qt4ProFileNode::uiDirectory() const
+QString QmakeProFileNode::uiDirectory() const
 {
     const Qt4VariablesHash::const_iterator it = m_varValues.constFind(UiDirVar);
     if (it != m_varValues.constEnd() && !it.value().isEmpty())
@@ -2302,7 +2302,7 @@ QString Qt4ProFileNode::uiDirectory() const
     return buildDir();
 }
 
-QString Qt4ProFileNode::uiHeaderFile(const QString &uiDir, const QString &formFile)
+QString QmakeProFileNode::uiHeaderFile(const QString &uiDir, const QString &formFile)
 {
     QString uiHeaderFilePath = uiDir;
     uiHeaderFilePath += QLatin1String("/ui_");
@@ -2311,7 +2311,7 @@ QString Qt4ProFileNode::uiHeaderFile(const QString &uiDir, const QString &formFi
     return QDir::cleanPath(uiHeaderFilePath);
 }
 
-void Qt4ProFileNode::updateUiFiles()
+void QmakeProFileNode::updateUiFiles()
 {
     m_uiFiles.clear();
 
diff --git a/src/plugins/qt4projectmanager/qmakenodes.h b/src/plugins/qt4projectmanager/qmakenodes.h
index 738f02ac35..ea24928c50 100644
--- a/src/plugins/qt4projectmanager/qmakenodes.h
+++ b/src/plugins/qt4projectmanager/qmakenodes.h
@@ -65,8 +65,8 @@ class Project;
 
 namespace QmakeProjectManager {
 class QmakeBuildConfiguration;
-class Qt4ProFileNode;
-class Qt4Project;
+class QmakeProFileNode;
+class QmakeProject;
 
 //  Type of projects
 enum Qt4ProjectType {
@@ -130,18 +130,18 @@ using ProjectExplorer::ProjectFileType;
 using ProjectExplorer::FileType;
 
 namespace Internal {
-class Qt4PriFile;
+class QmakePriFile;
 struct InternalNode;
 }
 
 // Implements ProjectNode for qt4 pro files
-class QT4PROJECTMANAGER_EXPORT Qt4PriFileNode : public ProjectExplorer::ProjectNode
+class QT4PROJECTMANAGER_EXPORT QmakePriFileNode : public ProjectExplorer::ProjectNode
 {
     Q_OBJECT
 
 public:
-    Qt4PriFileNode(Qt4Project *project, Qt4ProFileNode* qt4ProFileNode, const QString &filePath);
-    ~Qt4PriFileNode();
+    QmakePriFileNode(QmakeProject *project, QmakeProFileNode* qt4ProFileNode, const QString &filePath);
+    ~QmakePriFileNode();
 
     void update(ProFile *includeFileExact, QtSupport::ProFileReader *readerExact, ProFile *includeFileCumlative, QtSupport::ProFileReader *readerCumalative);
 
@@ -168,8 +168,8 @@ public:
     bool deploysFolder(const QString &folder) const;
     QList<ProjectExplorer::RunConfiguration *> runConfigurationsFor(Node *node);
 
-    QList<Qt4PriFileNode*> subProjectNodesExact() const;
-    Qt4ProFileNode *proFileNode() const;
+    QmakeProFileNode *proFileNode() const;
+    QList<QmakePriFileNode*> subProjectNodesExact() const;
 
     // Set by parent
     bool includedInExactParse() const;
@@ -208,13 +208,13 @@ private:
     QStringList fullVPaths(const QStringList &baseVPaths, QtSupport::ProFileReader *reader, const QString &qmakeVariable, const QString &projectDir) const;
     void watchFolders(const QSet<QString> &folders);
 
-    Qt4Project *m_project;
-    Qt4ProFileNode *m_qt4ProFileNode;
+    QmakeProject *m_project;
+    QmakeProFileNode *m_qmakeProFileNode;
     QString m_projectFilePath;
     QString m_projectDir;
 
     QMap<QString, QtSupport::UiCodeModelSupport *> m_uiCodeModelSupport;
-    Internal::Qt4PriFile *m_qt4PriFile;
+    Internal::QmakePriFile *m_qmakePriFile;
 
     // Memory is cheap...
     QMap<ProjectExplorer::FileType, QSet<Utils::FileName> > m_files;
@@ -223,18 +223,18 @@ private:
     bool m_includedInExactParse;
 
     // managed by Qt4ProFileNode
-    friend class QmakeProjectManager::Qt4ProFileNode;
-    friend class Internal::Qt4PriFile; // for scheduling updates on modified
+    friend class QmakeProjectManager::QmakeProFileNode;
+    friend class Internal::QmakePriFile; // for scheduling updates on modified
     // internal temporary subtree representation
     friend struct Internal::InternalNode;
 };
 
 namespace Internal {
-class Qt4PriFile : public Core::IDocument
+class QmakePriFile : public Core::IDocument
 {
     Q_OBJECT
 public:
-    Qt4PriFile(Qt4PriFileNode *qt4PriFile);
+    QmakePriFile(QmakePriFileNode *qmakePriFile);
     virtual bool save(QString *errorString, const QString &fileName, bool autoSave);
 
     virtual QString defaultPath() const;
@@ -248,31 +248,31 @@ public:
     bool reload(QString *errorString, ReloadFlag flag, ChangeType type);
 
 private:
-    Qt4PriFileNode *m_priFile;
+    QmakePriFileNode *m_priFile;
 };
 
-class Qt4NodesWatcher : public ProjectExplorer::NodesWatcher
+class QmakeNodesWatcher : public ProjectExplorer::NodesWatcher
 {
     Q_OBJECT
 
 public:
-    Qt4NodesWatcher(QObject *parent = 0);
+    QmakeNodesWatcher(QObject *parent = 0);
 
 signals:
-    void projectTypeChanged(QmakeProjectManager::Qt4ProFileNode *projectNode,
+    void projectTypeChanged(QmakeProjectManager::QmakeProFileNode *projectNode,
                             const QmakeProjectManager::Qt4ProjectType oldType,
                             const QmakeProjectManager::Qt4ProjectType newType);
 
-    void variablesChanged(Qt4ProFileNode *projectNode,
+    void variablesChanged(QmakeProFileNode *projectNode,
                           const QHash<Qt4Variable, QStringList> &oldValues,
                           const QHash<Qt4Variable, QStringList> &newValues);
 
-    void proFileUpdated(QmakeProjectManager::Qt4ProFileNode *projectNode, bool success, bool parseInProgress);
+    void proFileUpdated(QmakeProjectManager::QmakeProFileNode *projectNode, bool success, bool parseInProgress);
 
 private:
     // let them emit signals
-    friend class QmakeProjectManager::Qt4ProFileNode;
-    friend class Qt4PriFileNode;
+    friend class QmakeProjectManager::QmakeProFileNode;
+    friend class QmakePriFileNode;
 };
 
 class ProVirtualFolderNode : public ProjectExplorer::VirtualFolderNode
@@ -355,17 +355,17 @@ struct QT4PROJECTMANAGER_EXPORT ProjectVersion {
 };
 
 // Implements ProjectNode for qt4 pro files
-class QT4PROJECTMANAGER_EXPORT Qt4ProFileNode : public Qt4PriFileNode
+class QT4PROJECTMANAGER_EXPORT QmakeProFileNode : public QmakePriFileNode
 {
     Q_OBJECT
 
 public:
-    Qt4ProFileNode(Qt4Project *project,
+    QmakeProFileNode(QmakeProject *project,
                    const QString &filePath,
                    QObject *parent = 0);
-    ~Qt4ProFileNode();
+    ~QmakeProFileNode();
 
-    bool isParent(Qt4ProFileNode *node);
+    bool isParent(QmakeProFileNode *node);
 
     bool hasBuildTargets() const;
 
@@ -385,7 +385,7 @@ public:
     static QString uiHeaderFile(const QString &uiDir, const QString &formFile);
     QHash<QString, QString> uiFiles() const;
 
-    const Qt4ProFileNode *findProFileFor(const QString &string) const;
+    const QmakeProFileNode *findProFileFor(const QString &string) const;
     TargetInformation targetInformation() const;
 
     InstallsList installsList() const;
diff --git a/src/plugins/qt4projectmanager/qmakeproject.cpp b/src/plugins/qt4projectmanager/qmakeproject.cpp
index 6fc7241d75..43254403f6 100644
--- a/src/plugins/qt4projectmanager/qmakeproject.cpp
+++ b/src/plugins/qt4projectmanager/qmakeproject.cpp
@@ -114,12 +114,12 @@ void updateBoilerPlateCodeFiles(const AbstractMobileApp *app, const QString &pro
 namespace QmakeProjectManager {
 namespace Internal {
 
-class Qt4ProjectFile : public Core::IDocument
+class QmakeProjectFile : public Core::IDocument
 {
     Q_OBJECT
 
 public:
-    Qt4ProjectFile(const QString &filePath, QObject *parent = 0);
+    QmakeProjectFile(const QString &filePath, QObject *parent = 0);
 
     bool save(QString *errorString, const QString &fileName, bool autoSave);
 
@@ -137,7 +137,7 @@ private:
     const QString m_mimeType;
 };
 
-/// Watches folders for Qt4PriFile nodes
+/// Watches folders for QmakePriFile nodes
 /// use one file system watcher to watch all folders
 /// such minimizing system ressouce usage
 
@@ -145,10 +145,10 @@ class CentralizedFolderWatcher : public QObject
 {
     Q_OBJECT
 public:
-    CentralizedFolderWatcher(Qt4Project *parent);
+    CentralizedFolderWatcher(QmakeProject *parent);
     ~CentralizedFolderWatcher();
-    void watchFolders(const QList<QString> &folders, QmakeProjectManager::Qt4PriFileNode *node);
-    void unwatchFolders(const QList<QString> &folders, QmakeProjectManager::Qt4PriFileNode *node);
+    void watchFolders(const QList<QString> &folders, QmakeProjectManager::QmakePriFileNode *node);
+    void unwatchFolders(const QList<QString> &folders, QmakeProjectManager::QmakePriFileNode *node);
 
 private slots:
     void folderChanged(const QString &folder);
@@ -156,28 +156,28 @@ private slots:
     void delayedFolderChanged(const QString &folder);
 
 private:
-    Qt4Project *m_project;
+    QmakeProject *m_project;
     QSet<QString> recursiveDirs(const QString &folder);
     QFileSystemWatcher m_watcher;
-    QMultiMap<QString, QmakeProjectManager::Qt4PriFileNode *> m_map;
+    QMultiMap<QString, QmakeProjectManager::QmakePriFileNode *> m_map;
 
     QSet<QString> m_recursiveWatchedFolders;
     QTimer m_compressTimer;
     QSet<QString> m_changedFolders;
 };
 
-// Qt4ProjectFiles: Struct for (Cached) lists of files in a project
-class Qt4ProjectFiles {
+// QmakeProjectFiles: Struct for (Cached) lists of files in a project
+class QmakeProjectFiles {
 public:
     void clear();
-    bool equals(const Qt4ProjectFiles &f) const;
+    bool equals(const QmakeProjectFiles &f) const;
 
     QStringList files[ProjectExplorer::FileTypeSize];
     QStringList generatedFiles[ProjectExplorer::FileTypeSize];
     QStringList proFiles;
 };
 
-void Qt4ProjectFiles::clear()
+void QmakeProjectFiles::clear()
 {
     for (int i = 0; i < FileTypeSize; ++i) {
         files[i].clear();
@@ -186,7 +186,7 @@ void Qt4ProjectFiles::clear()
     proFiles.clear();
 }
 
-bool Qt4ProjectFiles::equals(const Qt4ProjectFiles &f) const
+bool QmakeProjectFiles::equals(const QmakeProjectFiles &f) const
 {
     for (int i = 0; i < FileTypeSize; ++i)
         if (files[i] != f.files[i] || generatedFiles[i] != f.generatedFiles[i])
@@ -196,43 +196,43 @@ bool Qt4ProjectFiles::equals(const Qt4ProjectFiles &f) const
     return true;
 }
 
-inline bool operator==(const Qt4ProjectFiles &f1, const Qt4ProjectFiles &f2)
+inline bool operator==(const QmakeProjectFiles &f1, const QmakeProjectFiles &f2)
 {       return f1.equals(f2); }
 
-inline bool operator!=(const Qt4ProjectFiles &f1, const Qt4ProjectFiles &f2)
+inline bool operator!=(const QmakeProjectFiles &f1, const QmakeProjectFiles &f2)
 {       return !f1.equals(f2); }
 
-QDebug operator<<(QDebug d, const  Qt4ProjectFiles &f)
+QDebug operator<<(QDebug d, const  QmakeProjectFiles &f)
 {
     QDebug nsp = d.nospace();
-    nsp << "Qt4ProjectFiles: proFiles=" <<  f.proFiles << '\n';
+    nsp << "QmakeProjectFiles: proFiles=" <<  f.proFiles << '\n';
     for (int i = 0; i < FileTypeSize; ++i)
         nsp << "Type " << i << " files=" << f.files[i] <<  " generated=" << f.generatedFiles[i] << '\n';
     return d;
 }
 
-// A visitor to collect all files of a project in a Qt4ProjectFiles struct
+// A visitor to collect all files of a project in a QmakeProjectFiles struct
 class ProjectFilesVisitor : public ProjectExplorer::NodesVisitor
 {
-    ProjectFilesVisitor(Qt4ProjectFiles *files);
+    ProjectFilesVisitor(QmakeProjectFiles *files);
 
 public:
 
-    static void findProjectFiles(Qt4ProFileNode *rootNode, Qt4ProjectFiles *files);
+    static void findProjectFiles(QmakeProFileNode *rootNode, QmakeProjectFiles *files);
 
     void visitProjectNode(ProjectNode *projectNode);
     void visitFolderNode(FolderNode *folderNode);
 
 private:
-    Qt4ProjectFiles *m_files;
+    QmakeProjectFiles *m_files;
 };
 
-ProjectFilesVisitor::ProjectFilesVisitor(Qt4ProjectFiles *files) :
+ProjectFilesVisitor::ProjectFilesVisitor(QmakeProjectFiles *files) :
     m_files(files)
 {
 }
 
-void ProjectFilesVisitor::findProjectFiles(Qt4ProFileNode *rootNode, Qt4ProjectFiles *files)
+void ProjectFilesVisitor::findProjectFiles(QmakeProFileNode *rootNode, QmakeProjectFiles *files)
 {
     files->clear();
     ProjectFilesVisitor visitor(files);
@@ -265,54 +265,54 @@ void ProjectFilesVisitor::visitFolderNode(FolderNode *folderNode)
 
 }
 
-// ----------- Qt4ProjectFile
+// ----------- QmakeProjectFile
 namespace Internal {
-Qt4ProjectFile::Qt4ProjectFile(const QString &filePath, QObject *parent)
+QmakeProjectFile::QmakeProjectFile(const QString &filePath, QObject *parent)
     : Core::IDocument(parent),
       m_mimeType(QLatin1String(QmakeProjectManager::Constants::PROFILE_MIMETYPE))
 {
     setFilePath(filePath);
 }
 
-bool Qt4ProjectFile::save(QString *, const QString &, bool)
+bool QmakeProjectFile::save(QString *, const QString &, bool)
 {
     // This is never used
     return false;
 }
 
-QString Qt4ProjectFile::defaultPath() const
+QString QmakeProjectFile::defaultPath() const
 {
     return QString();
 }
 
-QString Qt4ProjectFile::suggestedFileName() const
+QString QmakeProjectFile::suggestedFileName() const
 {
     return QString();
 }
 
-QString Qt4ProjectFile::mimeType() const
+QString QmakeProjectFile::mimeType() const
 {
     return m_mimeType;
 }
 
-bool Qt4ProjectFile::isModified() const
+bool QmakeProjectFile::isModified() const
 {
     return false; // we save after changing anyway
 }
 
-bool Qt4ProjectFile::isSaveAsAllowed() const
+bool QmakeProjectFile::isSaveAsAllowed() const
 {
     return false;
 }
 
-Core::IDocument::ReloadBehavior Qt4ProjectFile::reloadBehavior(ChangeTrigger state, ChangeType type) const
+Core::IDocument::ReloadBehavior QmakeProjectFile::reloadBehavior(ChangeTrigger state, ChangeType type) const
 {
     Q_UNUSED(state)
     Q_UNUSED(type)
     return BehaviorSilent;
 }
 
-bool Qt4ProjectFile::reload(QString *errorString, ReloadFlag flag, ChangeType type)
+bool QmakeProjectFile::reload(QString *errorString, ReloadFlag flag, ChangeType type)
 {
     Q_UNUSED(errorString)
     Q_UNUSED(flag)
@@ -323,17 +323,17 @@ bool Qt4ProjectFile::reload(QString *errorString, ReloadFlag flag, ChangeType ty
 } // namespace Internal
 
 /*!
-  \class Qt4Project
+  \class QmakeProject
 
-  Qt4Project manages information about an individual Qt 4 (.pro) project file.
+  QmakeProject manages information about an individual Qt 4 (.pro) project file.
   */
 
-Qt4Project::Qt4Project(Qt4Manager *manager, const QString& fileName) :
+QmakeProject::QmakeProject(Qt4Manager *manager, const QString &fileName) :
     m_manager(manager),
     m_rootProjectNode(0),
-    m_nodesWatcher(new Internal::Qt4NodesWatcher(this)),
-    m_fileInfo(new Qt4ProjectFile(fileName, this)),
-    m_projectFiles(new Qt4ProjectFiles),
+    m_nodesWatcher(new Internal::QmakeNodesWatcher(this)),
+    m_fileInfo(new QmakeProjectFile(fileName, this)),
+    m_projectFiles(new QmakeProjectFiles),
     m_qmakeVfs(new QMakeVfs),
     m_qmakeGlobals(0),
     m_asyncUpdateFutureInterface(0),
@@ -354,7 +354,7 @@ Qt4Project::Qt4Project(Qt4Manager *manager, const QString& fileName) :
             SLOT(buildFinished(bool)));
 }
 
-Qt4Project::~Qt4Project()
+QmakeProject::~QmakeProject()
 {
     m_codeModelFuture.cancel();
     m_asyncUpdateState = ShuttingDown;
@@ -364,14 +364,14 @@ Qt4Project::~Qt4Project()
     m_cancelEvaluate = true;
     // Deleting the root node triggers a few things, make sure rootProjectNode
     // returns 0 already
-    Qt4ProFileNode *root = m_rootProjectNode;
+    QmakeProFileNode *root = m_rootProjectNode;
     m_rootProjectNode = 0;
     delete root;
 }
 
-void Qt4Project::updateFileList()
+void QmakeProject::updateFileList()
 {
-    Qt4ProjectFiles newFiles;
+    QmakeProjectFiles newFiles;
     ProjectFilesVisitor::findProjectFiles(m_rootProjectNode, &newFiles);
     if (newFiles != *m_projectFiles) {
         *m_projectFiles = newFiles;
@@ -381,7 +381,7 @@ void Qt4Project::updateFileList()
     }
 }
 
-bool Qt4Project::fromMap(const QVariantMap &map)
+bool QmakeProject::fromMap(const QVariantMap &map)
 {
     if (!Project::fromMap(map))
         return false;
@@ -398,7 +398,7 @@ bool Qt4Project::fromMap(const QVariantMap &map)
 
     m_manager->registerProject(this);
 
-    m_rootProjectNode = new Qt4ProFileNode(this, m_fileInfo->filePath(), this);
+    m_rootProjectNode = new QmakeProFileNode(this, m_fileInfo->filePath(), this);
     m_rootProjectNode->registerWatcher(m_nodesWatcher);
 
     update();
@@ -407,8 +407,8 @@ bool Qt4Project::fromMap(const QVariantMap &map)
     updateCodeModels();
 
     // We have the profile nodes now, so we know the runconfigs!
-    connect(m_nodesWatcher, SIGNAL(proFileUpdated(QmakeProjectManager::Qt4ProFileNode*,bool,bool)),
-            this, SIGNAL(proFileUpdated(QmakeProjectManager::Qt4ProFileNode*,bool,bool)));
+    connect(m_nodesWatcher, SIGNAL(proFileUpdated(QmakeProjectManager::QmakeProFileNode*,bool,bool)),
+            this, SIGNAL(proFileUpdated(QmakeProjectManager::QmakeProFileNode*,bool,bool)));
 
     // Now we emit update once :)
     m_rootProjectNode->emitProFileUpdatedRecursive();
@@ -426,7 +426,7 @@ bool Qt4Project::fromMap(const QVariantMap &map)
     QtQuickApp qtQuickApp;
     const Html5App html5App;
 
-    foreach (Qt4ProFileNode *node, applicationProFiles(Qt4Project::ExactAndCumulativeParse)) {
+    foreach (QmakeProFileNode *node, applicationProFiles(QmakeProject::ExactAndCumulativeParse)) {
         const QString path = node->path();
 
         qtQuickApp.setComponentSet(QtQuickApp::QtQuick10Components);
@@ -441,7 +441,7 @@ bool Qt4Project::fromMap(const QVariantMap &map)
 /// equalFileList compares two file lists ignoring
 /// <configuration> without generating temporary lists
 
-bool Qt4Project::equalFileList(const QStringList &a, const QStringList &b)
+bool QmakeProject::equalFileList(const QStringList &a, const QStringList &b)
 {
     if (abs(a.length() - b.length()) > 1)
         return false;
@@ -463,10 +463,10 @@ bool Qt4Project::equalFileList(const QStringList &a, const QStringList &b)
     return (ait == aend && bit == bend);
 }
 
-void Qt4Project::updateCodeModels()
+void QmakeProject::updateCodeModels()
 {
     if (debug)
-        qDebug()<<"Qt4Project::updateCodeModel()";
+        qDebug() << "QmakeProject::updateCodeModel()";
 
     if (activeTarget() && !activeTarget()->activeBuildConfiguration())
         return;
@@ -475,7 +475,7 @@ void Qt4Project::updateCodeModels()
     updateQmlJSCodeModel();
 }
 
-void Qt4Project::updateCppCodeModel()
+void QmakeProject::updateCppCodeModel()
 {
     typedef CppTools::ProjectPart ProjectPart;
     typedef CppTools::ProjectFile ProjectFile;
@@ -494,8 +494,8 @@ void Qt4Project::updateCppCodeModel()
     if (!modelmanager)
         return;
 
-    FindQt4ProFiles findQt4ProFiles;
-    QList<Qt4ProFileNode *> proFiles = findQt4ProFiles(rootProjectNode());
+    FindQmakeProFiles findQmakeProFiles;
+    QList<QmakeProFileNode *> proFiles = findQmakeProFiles(rootProjectNode());
 
     CppTools::CppModelManagerInterface::ProjectInfo pinfo = modelmanager->projectInfo(this);
     pinfo.clearProjectParts();
@@ -509,7 +509,7 @@ void Qt4Project::updateCppCodeModel()
 
     QHash<QString, QString> uiCodeModelData;
     QStringList allFiles;
-    foreach (Qt4ProFileNode *pro, proFiles) {
+    foreach (QmakeProFileNode *pro, proFiles) {
         ProjectPart::Ptr part(new ProjectPart);
         part->project = this;
         part->displayName = pro->displayName();
@@ -543,7 +543,7 @@ void Qt4Project::updateCppCodeModel()
                 part->frameworkPaths.append(qtVersion->frameworkInstallPath());
         }
 
-        if (Qt4ProFileNode *node = rootQt4ProjectNode())
+        if (QmakeProFileNode *node = rootQmakeProjectNode())
             part->includePaths.append(node->resolvedMkspecPath());
 
         // part->precompiledHeaders
@@ -591,7 +591,7 @@ void Qt4Project::updateCppCodeModel()
     m_codeModelFuture = modelmanager->updateProjectInfo(pinfo);
 }
 
-void Qt4Project::updateQmlJSCodeModel()
+void QmakeProject::updateQmlJSCodeModel()
 {
     QmlJS::ModelManagerInterface *modelManager = QmlJS::ModelManagerInterface::instance();
     if (!modelManager)
@@ -600,13 +600,13 @@ void Qt4Project::updateQmlJSCodeModel()
     QmlJS::ModelManagerInterface::ProjectInfo projectInfo =
             QmlJSTools::defaultProjectInfoForProject(this);
 
-    FindQt4ProFiles findQt4ProFiles;
-    QList<Qt4ProFileNode *> proFiles = findQt4ProFiles(rootProjectNode());
+    FindQmakeProFiles findQt4ProFiles;
+    QList<QmakeProFileNode *> proFiles = findQt4ProFiles(rootProjectNode());
 
     projectInfo.importPaths.clear();
 
     bool hasQmlLib = false;
-    foreach (Qt4ProFileNode *node, proFiles) {
+    foreach (QmakeProFileNode *node, proFiles) {
         projectInfo.importPaths.append(node->variableValue(QmlImportPathVar));
         projectInfo.activeResourceFiles.append(node->variableValue(ExactResourceVar));
         projectInfo.allResourceFiles.append(node->variableValue(ResourceVar));
@@ -639,7 +639,7 @@ void Qt4Project::updateQmlJSCodeModel()
 ///*!
 //  Updates complete project
 //  */
-void Qt4Project::update()
+void QmakeProject::update()
 {
     if (debug)
         qDebug()<<"Doing sync update";
@@ -654,13 +654,13 @@ void Qt4Project::update()
     emit proFilesEvaluated();
 }
 
-void Qt4Project::updateRunConfigurations()
+void QmakeProject::updateRunConfigurations()
 {
     if (activeTarget())
         activeTarget()->updateDefaultRunConfigurations();
 }
 
-void Qt4Project::scheduleAsyncUpdate(Qt4ProFileNode *node)
+void QmakeProject::scheduleAsyncUpdate(QmakeProFileNode *node)
 {
     if (m_asyncUpdateState == ShuttingDown)
         return;
@@ -692,7 +692,7 @@ void Qt4Project::scheduleAsyncUpdate(Qt4ProFileNode *node)
         // Add the node
         m_asyncUpdateState = AsyncPartialUpdatePending;
 
-        QList<Qt4ProFileNode *>::iterator it;
+        QList<QmakeProFileNode *>::iterator it;
         bool add = true;
         if (debug)
             qDebug()<<"scheduleAsyncUpdate();"<<m_partialEvaluate.size()<<"nodes";
@@ -732,7 +732,7 @@ void Qt4Project::scheduleAsyncUpdate(Qt4ProFileNode *node)
     }
 }
 
-void Qt4Project::scheduleAsyncUpdate()
+void QmakeProject::scheduleAsyncUpdate()
 {
     if (debug)
         qDebug()<<"scheduleAsyncUpdate";
@@ -769,7 +769,7 @@ void Qt4Project::scheduleAsyncUpdate()
 }
 
 
-void Qt4Project::incrementPendingEvaluateFutures()
+void QmakeProject::incrementPendingEvaluateFutures()
 {
     ++m_pendingEvaluateFuturesCount;
     if (debug)
@@ -779,7 +779,7 @@ void Qt4Project::incrementPendingEvaluateFutures()
                                                   m_asyncUpdateFutureInterface->progressMaximum() + 1);
 }
 
-void Qt4Project::decrementPendingEvaluateFutures()
+void QmakeProject::decrementPendingEvaluateFutures()
 {
     --m_pendingEvaluateFuturesCount;
 
@@ -819,12 +819,12 @@ void Qt4Project::decrementPendingEvaluateFutures()
     }
 }
 
-bool Qt4Project::wasEvaluateCanceled()
+bool QmakeProject::wasEvaluateCanceled()
 {
     return m_cancelEvaluate;
 }
 
-void Qt4Project::asyncUpdate()
+void QmakeProject::asyncUpdate()
 {
     if (debug)
         qDebug()<<"async update, timer expired, doing now";
@@ -849,7 +849,7 @@ void Qt4Project::asyncUpdate()
     } else {
         if (debug)
             qDebug()<<"  partial update,"<<m_partialEvaluate.size()<<"nodes to update";
-        foreach (Qt4ProFileNode *node, m_partialEvaluate)
+        foreach (QmakeProFileNode *node, m_partialEvaluate)
             node->asyncUpdate();
     }
 
@@ -859,23 +859,23 @@ void Qt4Project::asyncUpdate()
     m_asyncUpdateState = AsyncUpdateInProgress;
 }
 
-void Qt4Project::buildFinished(bool success)
+void QmakeProject::buildFinished(bool success)
 {
     if (success)
         m_qmakeVfs->invalidateContents();
 }
 
-ProjectExplorer::IProjectManager *Qt4Project::projectManager() const
+ProjectExplorer::IProjectManager *QmakeProject::projectManager() const
 {
     return m_manager;
 }
 
-Qt4Manager *Qt4Project::qt4ProjectManager() const
+Qt4Manager *QmakeProject::qt4ProjectManager() const
 {
     return m_manager;
 }
 
-bool Qt4Project::supportsKit(Kit *k, QString *errorMessage) const
+bool QmakeProject::supportsKit(Kit *k, QString *errorMessage) const
 {
     QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k);
     if (!version && errorMessage)
@@ -883,22 +883,22 @@ bool Qt4Project::supportsKit(Kit *k, QString *errorMessage) const
     return version;
 }
 
-QString Qt4Project::displayName() const
+QString QmakeProject::displayName() const
 {
     return QFileInfo(projectFilePath()).completeBaseName();
 }
 
-Core::Id Qt4Project::id() const
+Core::Id QmakeProject::id() const
 {
     return Core::Id(Constants::QT4PROJECT_ID);
 }
 
-Core::IDocument *Qt4Project::document() const
+Core::IDocument *QmakeProject::document() const
 {
     return m_fileInfo;
 }
 
-QStringList Qt4Project::files(FilesMode fileMode) const
+QStringList QmakeProject::files(FilesMode fileMode) const
 {
     QStringList files;
     for (int i = 0; i < FileTypeSize; ++i) {
@@ -923,30 +923,30 @@ static FolderNode *folderOf(FolderNode *in, FileType fileType, const QString &fi
 
 // Find the Qt4ProFileNode that contains a file of a certain type.
 // First recurse down to folder, then find the pro-file.
-static Qt4ProFileNode *proFileNodeOf(Qt4ProFileNode *in, FileType fileType, const QString &fileName)
+static QmakeProFileNode *proFileNodeOf(QmakeProFileNode *in, FileType fileType, const QString &fileName)
 {
     for (FolderNode *folder =  folderOf(in, fileType, fileName); folder; folder = folder->parentFolderNode())
-        if (Qt4ProFileNode *proFile = qobject_cast<Qt4ProFileNode *>(folder))
+        if (QmakeProFileNode *proFile = qobject_cast<QmakeProFileNode *>(folder))
             return proFile;
     return 0;
 }
 
-QString Qt4Project::generatedUiHeader(const QString &formFile) const
+QString QmakeProject::generatedUiHeader(const QString &formFile) const
 {
     // Look in sub-profiles as SessionManager::projectForFile returns
     // the top-level project only.
     if (m_rootProjectNode)
-        if (const Qt4ProFileNode *pro = proFileNodeOf(m_rootProjectNode, FormType, formFile))
-            return Qt4ProFileNode::uiHeaderFile(pro->uiDirectory(), formFile);
+        if (const QmakeProFileNode *pro = proFileNodeOf(m_rootProjectNode, FormType, formFile))
+            return QmakeProFileNode::uiHeaderFile(pro->uiDirectory(), formFile);
     return QString();
 }
 
-void Qt4Project::proFileParseError(const QString &errorMessage)
+void QmakeProject::proFileParseError(const QString &errorMessage)
 {
     Core::MessageManager::write(errorMessage);
 }
 
-QtSupport::ProFileReader *Qt4Project::createProFileReader(const Qt4ProFileNode *qt4ProFileNode, QmakeBuildConfiguration *bc)
+QtSupport::ProFileReader *QmakeProject::createProFileReader(const QmakeProFileNode *qmakeProFileNode, QmakeBuildConfiguration *bc)
 {
     if (!m_qmakeGlobals) {
         m_qmakeGlobals = new ProFileGlobals;
@@ -992,17 +992,17 @@ QtSupport::ProFileReader *Qt4Project::createProFileReader(const Qt4ProFileNode *
 
     QtSupport::ProFileReader *reader = new QtSupport::ProFileReader(m_qmakeGlobals, m_qmakeVfs);
 
-    reader->setOutputDir(qt4ProFileNode->buildDir());
+    reader->setOutputDir(qmakeProFileNode->buildDir());
 
     return reader;
 }
 
-ProFileGlobals *Qt4Project::qmakeGlobals()
+ProFileGlobals *QmakeProject::qmakeGlobals()
 {
     return m_qmakeGlobals;
 }
 
-void Qt4Project::destroyProFileReader(QtSupport::ProFileReader *reader)
+void QmakeProject::destroyProFileReader(QtSupport::ProFileReader *reader)
 {
     delete reader;
     if (!--m_qmakeGlobalsRefCnt) {
@@ -1017,44 +1017,44 @@ void Qt4Project::destroyProFileReader(QtSupport::ProFileReader *reader)
     }
 }
 
-ProjectExplorer::ProjectNode *Qt4Project::rootProjectNode() const
+ProjectExplorer::ProjectNode *QmakeProject::rootProjectNode() const
 {
     return m_rootProjectNode;
 }
 
-Qt4ProFileNode *Qt4Project::rootQt4ProjectNode() const
+QmakeProFileNode *QmakeProject::rootQmakeProjectNode() const
 {
     return m_rootProjectNode;
 }
 
-bool Qt4Project::validParse(const QString &proFilePath) const
+bool QmakeProject::validParse(const QString &proFilePath) const
 {
     if (!m_rootProjectNode)
         return false;
-    const Qt4ProFileNode *node = m_rootProjectNode->findProFileFor(proFilePath);
+    const QmakeProFileNode *node = m_rootProjectNode->findProFileFor(proFilePath);
     return node && node->validParse();
 }
 
-bool Qt4Project::parseInProgress(const QString &proFilePath) const
+bool QmakeProject::parseInProgress(const QString &proFilePath) const
 {
     if (!m_rootProjectNode)
         return false;
-    const Qt4ProFileNode *node = m_rootProjectNode->findProFileFor(proFilePath);
+    const QmakeProFileNode *node = m_rootProjectNode->findProFileFor(proFilePath);
     return node && node->parseInProgress();
 }
 
-void Qt4Project::collectAllfProFiles(QList<Qt4ProFileNode *> &list, Qt4ProFileNode *node, Parsing parse)
+void QmakeProject::collectAllfProFiles(QList<QmakeProFileNode *> &list, QmakeProFileNode *node, Parsing parse)
 {
     if (parse == ExactAndCumulativeParse || node->includedInExactParse())
         list.append(node);
     foreach (ProjectNode *n, node->subProjectNodes()) {
-        Qt4ProFileNode *qt4ProFileNode = qobject_cast<Qt4ProFileNode *>(n);
+        QmakeProFileNode *qt4ProFileNode = qobject_cast<QmakeProFileNode *>(n);
         if (qt4ProFileNode)
             collectAllfProFiles(list, qt4ProFileNode, parse);
     }
 }
 
-void Qt4Project::collectApplicationProFiles(QList<Qt4ProFileNode *> &list, Qt4ProFileNode *node, Parsing parse)
+void QmakeProject::collectApplicationProFiles(QList<QmakeProFileNode *> &list, QmakeProFileNode *node, Parsing parse)
 {
     if (node->projectType() == ApplicationTemplate
         || node->projectType() == ScriptTemplate) {
@@ -1062,51 +1062,51 @@ void Qt4Project::collectApplicationProFiles(QList<Qt4ProFileNode *> &list, Qt4Pr
             list.append(node);
     }
     foreach (ProjectNode *n, node->subProjectNodes()) {
-        Qt4ProFileNode *qt4ProFileNode = qobject_cast<Qt4ProFileNode *>(n);
+        QmakeProFileNode *qt4ProFileNode = qobject_cast<QmakeProFileNode *>(n);
         if (qt4ProFileNode)
             collectApplicationProFiles(list, qt4ProFileNode, parse);
     }
 }
 
-QList<Qt4ProFileNode *> Qt4Project::allProFiles(Parsing parse) const
+QList<QmakeProFileNode *> QmakeProject::allProFiles(Parsing parse) const
 {
-    QList<Qt4ProFileNode *> list;
+    QList<QmakeProFileNode *> list;
     if (!rootProjectNode())
         return list;
-    collectAllfProFiles(list, rootQt4ProjectNode(), parse);
+    collectAllfProFiles(list, rootQmakeProjectNode(), parse);
     return list;
 }
 
-QList<Qt4ProFileNode *> Qt4Project::applicationProFiles(Parsing parse) const
+QList<QmakeProFileNode *> QmakeProject::applicationProFiles(Parsing parse) const
 {
-    QList<Qt4ProFileNode *> list;
+    QList<QmakeProFileNode *> list;
     if (!rootProjectNode())
         return list;
-    collectApplicationProFiles(list, rootQt4ProjectNode(), parse);
+    collectApplicationProFiles(list, rootQmakeProjectNode(), parse);
     return list;
 }
 
-bool Qt4Project::hasApplicationProFile(const QString &path) const
+bool QmakeProject::hasApplicationProFile(const QString &path) const
 {
     if (path.isEmpty())
         return false;
 
-    QList<Qt4ProFileNode *> list = applicationProFiles();
-    foreach (Qt4ProFileNode * node, list)
+    QList<QmakeProFileNode *> list = applicationProFiles();
+    foreach (QmakeProFileNode * node, list)
         if (node->path() == path)
             return true;
     return false;
 }
 
-QStringList Qt4Project::applicationProFilePathes(const QString &prepend, Parsing parse) const
+QStringList QmakeProject::applicationProFilePathes(const QString &prepend, Parsing parse) const
 {
     QStringList proFiles;
-    foreach (Qt4ProFileNode *node, applicationProFiles(parse))
+    foreach (QmakeProFileNode *node, applicationProFiles(parse))
         proFiles.append(prepend + node->path());
     return proFiles;
 }
 
-void Qt4Project::activeTargetWasChanged()
+void QmakeProject::activeTargetWasChanged()
 {
     if (m_activeTarget) {
         disconnect(m_activeTarget, SIGNAL(activeBuildConfigurationChanged(ProjectExplorer::BuildConfiguration*)),
@@ -1124,14 +1124,14 @@ void Qt4Project::activeTargetWasChanged()
     scheduleAsyncUpdate();
 }
 
-bool Qt4Project::hasSubNode(Qt4PriFileNode *root, const QString &path)
+bool QmakeProject::hasSubNode(QmakePriFileNode *root, const QString &path)
 {
     if (root->path() == path)
         return true;
     foreach (FolderNode *fn, root->subFolderNodes()) {
-        if (qobject_cast<Qt4ProFileNode *>(fn)) {
+        if (qobject_cast<QmakeProFileNode *>(fn)) {
             // we aren't interested in pro file nodes
-        } else if (Qt4PriFileNode *qt4prifilenode = qobject_cast<Qt4PriFileNode *>(fn)) {
+        } else if (QmakePriFileNode *qt4prifilenode = qobject_cast<QmakePriFileNode *>(fn)) {
             if (hasSubNode(qt4prifilenode, path))
                 return true;
         }
@@ -1139,22 +1139,22 @@ bool Qt4Project::hasSubNode(Qt4PriFileNode *root, const QString &path)
     return false;
 }
 
-void Qt4Project::findProFile(const QString& fileName, Qt4ProFileNode *root, QList<Qt4ProFileNode *> &list)
+void QmakeProject::findProFile(const QString& fileName, QmakeProFileNode *root, QList<QmakeProFileNode *> &list)
 {
     if (hasSubNode(root, fileName))
         list.append(root);
 
     foreach (FolderNode *fn, root->subFolderNodes())
-        if (Qt4ProFileNode *qt4proFileNode =  qobject_cast<Qt4ProFileNode *>(fn))
+        if (QmakeProFileNode *qt4proFileNode =  qobject_cast<QmakeProFileNode *>(fn))
             findProFile(fileName, qt4proFileNode, list);
 }
 
-void Qt4Project::notifyChanged(const QString &name)
+void QmakeProject::notifyChanged(const QString &name)
 {
-    if (files(Qt4Project::ExcludeGeneratedFiles).contains(name)) {
-        QList<Qt4ProFileNode *> list;
-        findProFile(name, rootQt4ProjectNode(), list);
-        foreach (Qt4ProFileNode *node, list) {
+    if (files(QmakeProject::ExcludeGeneratedFiles).contains(name)) {
+        QList<QmakeProFileNode *> list;
+        findProFile(name, rootQmakeProjectNode(), list);
+        foreach (QmakeProFileNode *node, list) {
             QtSupport::ProFileCacheManager::instance()->discardFile(name);
             node->update();
         }
@@ -1162,7 +1162,7 @@ void Qt4Project::notifyChanged(const QString &name)
     }
 }
 
-void Qt4Project::watchFolders(const QStringList &l, Qt4PriFileNode *node)
+void QmakeProject::watchFolders(const QStringList &l, QmakePriFileNode *node)
 {
     if (l.isEmpty())
         return;
@@ -1171,7 +1171,7 @@ void Qt4Project::watchFolders(const QStringList &l, Qt4PriFileNode *node)
     m_centralizedFolderWatcher->watchFolders(l, node);
 }
 
-void Qt4Project::unwatchFolders(const QStringList &l, Qt4PriFileNode *node)
+void QmakeProject::unwatchFolders(const QStringList &l, QmakePriFileNode *node)
 {
     if (m_centralizedFolderWatcher && !l.isEmpty())
         m_centralizedFolderWatcher->unwatchFolders(l, node);
@@ -1187,7 +1187,7 @@ namespace {
     bool debugCFW = false;
 }
 
-CentralizedFolderWatcher::CentralizedFolderWatcher(Qt4Project *parent)
+CentralizedFolderWatcher::CentralizedFolderWatcher(QmakeProject *parent)
     : QObject(parent), m_project(parent)
 {
     m_compressTimer.setSingleShot(true);
@@ -1216,7 +1216,7 @@ QSet<QString> CentralizedFolderWatcher::recursiveDirs(const QString &folder)
     return result;
 }
 
-void CentralizedFolderWatcher::watchFolders(const QList<QString> &folders, QmakeProjectManager::Qt4PriFileNode *node)
+void CentralizedFolderWatcher::watchFolders(const QList<QString> &folders, QmakeProjectManager::QmakePriFileNode *node)
 {
     if (debugCFW)
         qDebug()<<"CFW::watchFolders()"<<folders<<"for node"<<node->path();
@@ -1241,7 +1241,7 @@ void CentralizedFolderWatcher::watchFolders(const QList<QString> &folders, Qmake
     }
 }
 
-void CentralizedFolderWatcher::unwatchFolders(const QList<QString> &folders, QmakeProjectManager::Qt4PriFileNode *node)
+void CentralizedFolderWatcher::unwatchFolders(const QList<QString> &folders, QmakeProjectManager::QmakePriFileNode *node)
 {
     if (debugCFW)
         qDebug()<<"CFW::unwatchFolders()"<<folders<<"for node"<<node->path();
@@ -1265,7 +1265,7 @@ void CentralizedFolderWatcher::unwatchFolders(const QList<QString> &folders, Qma
                 // So the rwf is a subdirectory of a folder we aren't watching
                 // but maybe someone else wants us to watch
                 bool needToWatch = false;
-                QMultiMap<QString, QmakeProjectManager::Qt4PriFileNode *>::const_iterator it, end;
+                QMultiMap<QString, QmakeProjectManager::QmakePriFileNode *>::const_iterator it, end;
                 end = m_map.constEnd();
                 for (it = m_map.constEnd(); it != end; ++it) {
                     if (rwf.startsWith(it.key())) {
@@ -1314,12 +1314,12 @@ void CentralizedFolderWatcher::delayedFolderChanged(const QString &folder)
     while (true) {
         if (!dir.endsWith(slash))
             dir.append(slash);
-        QList<QmakeProjectManager::Qt4PriFileNode *> nodes = m_map.values(dir);
+        QList<QmakeProjectManager::QmakePriFileNode *> nodes = m_map.values(dir);
         if (!nodes.isEmpty()) {
             // Collect all the files
             QSet<Utils::FileName> newFiles;
-            newFiles += Qt4PriFileNode::recursiveEnumerate(folder);
-            foreach (QmakeProjectManager::Qt4PriFileNode *node, nodes) {
+            newFiles += QmakePriFileNode::recursiveEnumerate(folder);
+            foreach (QmakeProjectManager::QmakePriFileNode *node, nodes) {
                 newOrRemovedFiles = newOrRemovedFiles
                         || node->folderChanged(folder, newFiles);
             }
@@ -1360,12 +1360,12 @@ void CentralizedFolderWatcher::delayedFolderChanged(const QString &folder)
     }
 }
 
-bool Qt4Project::needsConfiguration() const
+bool QmakeProject::needsConfiguration() const
 {
     return targets().isEmpty();
 }
 
-void Qt4Project::configureAsExampleProject(const QStringList &platforms)
+void QmakeProject::configureAsExampleProject(const QStringList &platforms)
 {
     QList<const BuildInfo *> infoList;
     QList<Kit *> kits = ProjectExplorer::KitManager::kits();
@@ -1387,7 +1387,7 @@ void Qt4Project::configureAsExampleProject(const QStringList &platforms)
     ProjectExplorer::ProjectExplorerPlugin::instance()->requestProjectModeUpdate(this);
 }
 
-bool Qt4Project::supportsNoTargetPanel() const
+bool QmakeProject::supportsNoTargetPanel() const
 {
     return true;
 }
@@ -1395,7 +1395,7 @@ bool Qt4Project::supportsNoTargetPanel() const
 // All the Qt4 run configurations should share code.
 // This is a rather suboptimal way to do that for disabledReason()
 // but more pratical then duplicated the code everywhere
-QString Qt4Project::disabledReasonForRunConfiguration(const QString &proFilePath)
+QString QmakeProject::disabledReasonForRunConfiguration(const QString &proFilePath)
 {
     if (!QFileInfo(proFilePath).exists())
         return tr("The .pro file '%1' does not exist.")
@@ -1412,7 +1412,7 @@ QString Qt4Project::disabledReasonForRunConfiguration(const QString &proFilePath
             .arg(QFileInfo(proFilePath).fileName());
 }
 
-QString Qt4Project::shadowBuildDirectory(const QString &proFilePath, const Kit *k, const QString &suffix)
+QString QmakeProject::shadowBuildDirectory(const QString &proFilePath, const Kit *k, const QString &suffix)
 {
     if (proFilePath.isEmpty())
         return QString();
@@ -1429,7 +1429,7 @@ QString Qt4Project::shadowBuildDirectory(const QString &proFilePath, const Kit *
     return QDir::cleanPath(projectDir.absoluteFilePath(buildPath));
 }
 
-QString Qt4Project::buildNameFor(const Kit *k)
+QString QmakeProject::buildNameFor(const Kit *k)
 {
     if (!k)
         return QLatin1String("unknown");
@@ -1437,12 +1437,12 @@ QString Qt4Project::buildNameFor(const Kit *k)
     return k->fileSystemFriendlyName();
 }
 
-void Qt4Project::updateBuildSystemData()
+void QmakeProject::updateBuildSystemData()
 {
     Target * const target = activeTarget();
     if (!target)
         return;
-    const Qt4ProFileNode * const rootNode = rootQt4ProjectNode();
+    const QmakeProFileNode * const rootNode = rootQmakeProjectNode();
     if (!rootNode || rootNode->parseInProgress())
         return;
 
@@ -1451,12 +1451,12 @@ void Qt4Project::updateBuildSystemData()
     target->setDeploymentData(deploymentData);
 
     BuildTargetInfoList appTargetList;
-    foreach (const Qt4ProFileNode * const node, applicationProFiles())
+    foreach (const QmakeProFileNode * const node, applicationProFiles())
         appTargetList.list << BuildTargetInfo(executableFor(node), node->path());
     target->setApplicationTargets(appTargetList);
 }
 
-void Qt4Project::collectData(const Qt4ProFileNode *node, DeploymentData &deploymentData)
+void QmakeProject::collectData(const QmakeProFileNode *node, DeploymentData &deploymentData)
 {
     if (!node->isSubProjectDeployable(node->path()))
         return;
@@ -1477,8 +1477,8 @@ void Qt4Project::collectData(const Qt4ProFileNode *node, DeploymentData &deploym
         break;
     case SubDirsTemplate:
         foreach (const ProjectNode * const subProject, node->subProjectNodesExact()) {
-            const Qt4ProFileNode * const qt4SubProject
-                    = qobject_cast<const Qt4ProFileNode *>(subProject);
+            const QmakeProFileNode * const qt4SubProject
+                    = qobject_cast<const QmakeProFileNode *>(subProject);
             if (!qt4SubProject)
                 continue;
             collectData(qt4SubProject, deploymentData);
@@ -1489,7 +1489,7 @@ void Qt4Project::collectData(const Qt4ProFileNode *node, DeploymentData &deploym
     }
 }
 
-void Qt4Project::collectApplicationData(const Qt4ProFileNode *node, DeploymentData &deploymentData)
+void QmakeProject::collectApplicationData(const QmakeProFileNode *node, DeploymentData &deploymentData)
 {
     QString executable = executableFor(node);
     if (!executable.isEmpty())
@@ -1497,7 +1497,7 @@ void Qt4Project::collectApplicationData(const Qt4ProFileNode *node, DeploymentDa
                                DeployableFile::TypeExecutable);
 }
 
-void Qt4Project::collectLibraryData(const Qt4ProFileNode *node, DeploymentData &deploymentData)
+void QmakeProject::collectLibraryData(const QmakeProFileNode *node, DeploymentData &deploymentData)
 {
     const QString targetPath = node->installsList().targetPath;
     if (targetPath.isEmpty())
@@ -1582,7 +1582,7 @@ void Qt4Project::collectLibraryData(const Qt4ProFileNode *node, DeploymentData &
     }
 }
 
-QString Qt4Project::destDirFor(const TargetInformation &ti)
+QString QmakeProject::destDirFor(const TargetInformation &ti)
 {
     if (ti.destDir.isEmpty())
         return ti.buildDir;
@@ -1591,7 +1591,7 @@ QString Qt4Project::destDirFor(const TargetInformation &ti)
     return ti.destDir;
 }
 
-QString Qt4Project::executableFor(const Qt4ProFileNode *node)
+QString QmakeProject::executableFor(const QmakeProFileNode *node)
 {
     const ProjectExplorer::Kit * const kit = activeTarget()->kit();
     const ProjectExplorer::ToolChain * const toolchain
@@ -1620,17 +1620,17 @@ QString Qt4Project::executableFor(const Qt4ProFileNode *node)
     }
 }
 
-void Qt4Project::emitBuildDirectoryInitialized()
+void QmakeProject::emitBuildDirectoryInitialized()
 {
     emit buildDirectoryInitialized();
 }
 
-ProjectImporter *Qt4Project::createProjectImporter() const
+ProjectImporter *QmakeProject::createProjectImporter() const
 {
     return new QmakeProjectImporter(projectFilePath());
 }
 
-KitMatcher *Qt4Project::createRequiredKitMatcher() const
+KitMatcher *QmakeProject::createRequiredKitMatcher() const
 {
     return new QtSupport::QtVersionKitMatcher;
 }
diff --git a/src/plugins/qt4projectmanager/qmakeproject.h b/src/plugins/qt4projectmanager/qmakeproject.h
index e917a465c8..07a76bd04e 100644
--- a/src/plugins/qt4projectmanager/qmakeproject.h
+++ b/src/plugins/qt4projectmanager/qmakeproject.h
@@ -53,8 +53,8 @@ class MakeStep;
 class QMakeStep;
 class QmakeBuildConfiguration;
 class Qt4Manager;
-class Qt4PriFileNode;
-class Qt4ProFileNode;
+class QmakePriFileNode;
+class QmakeProFileNode;
 class Qt4RunStep;
 class TargetInformation;
 
@@ -62,19 +62,19 @@ namespace Internal {
 class CentralizedFolderWatcher;
 class FileItem;
 class GCCPreprocessor;
-class Qt4ProjectFiles;
+class QmakeProjectFiles;
 class Qt4ProjectConfigWidget;
-class Qt4ProjectFile;
-class Qt4NodesWatcher;
+class QmakeProjectFile;
+class QmakeNodesWatcher;
 }
 
-class  QT4PROJECTMANAGER_EXPORT Qt4Project : public ProjectExplorer::Project
+class  QT4PROJECTMANAGER_EXPORT QmakeProject : public ProjectExplorer::Project
 {
     Q_OBJECT
 
 public:
-    Qt4Project(Qt4Manager *manager, const QString &proFile);
-    virtual ~Qt4Project();
+    QmakeProject(Qt4Manager *manager, const QString &proFile);
+    virtual ~QmakeProject();
 
     QString displayName() const;
     Core::Id id() const;
@@ -85,7 +85,7 @@ public:
     bool supportsKit(ProjectExplorer::Kit *k, QString *errorMesage) const;
 
     ProjectExplorer::ProjectNode *rootProjectNode() const;
-    Qt4ProFileNode *rootQt4ProjectNode() const;
+    QmakeProFileNode *rootQmakeProjectNode() const;
     bool validParse(const QString &proFilePath) const;
     bool parseInProgress(const QString &proFilePath) const;
 
@@ -93,22 +93,22 @@ public:
     virtual QString generatedUiHeader(const QString &formFile) const;
 
     enum Parsing {ExactParse, ExactAndCumulativeParse };
-    QList<Qt4ProFileNode *> allProFiles(Parsing parse = ExactParse) const;
-    QList<Qt4ProFileNode *> applicationProFiles(Parsing parse = ExactParse) const;
+    QList<QmakeProFileNode *> allProFiles(Parsing parse = ExactParse) const;
+    QList<QmakeProFileNode *> applicationProFiles(Parsing parse = ExactParse) const;
     bool hasApplicationProFile(const QString &path) const;
     QStringList applicationProFilePathes(const QString &prepend = QString(), Parsing parse = ExactParse) const;
 
     void notifyChanged(const QString &name);
 
     /// \internal
-    QtSupport::ProFileReader *createProFileReader(const Qt4ProFileNode *qt4ProFileNode, QmakeBuildConfiguration *bc = 0);
+    QtSupport::ProFileReader *createProFileReader(const QmakeProFileNode *qmakeProFileNode, QmakeBuildConfiguration *bc = 0);
     /// \internal
     ProFileGlobals *qmakeGlobals();
     /// \internal
     void destroyProFileReader(QtSupport::ProFileReader *reader);
 
     /// \internal
-    void scheduleAsyncUpdate(QmakeProjectManager::Qt4ProFileNode *node);
+    void scheduleAsyncUpdate(QmakeProjectManager::QmakeProFileNode *node);
     /// \internal
     void incrementPendingEvaluateFutures();
     /// \internal
@@ -116,12 +116,12 @@ public:
     /// \internal
     bool wasEvaluateCanceled();
 
-    // For Qt4ProFileNode after a on disk change
+    // For QmakeProFileNode after a on disk change
     void updateFileList();
     void updateCodeModels();
 
-    void watchFolders(const QStringList &l, Qt4PriFileNode *node);
-    void unwatchFolders(const QStringList &l, Qt4PriFileNode *node);
+    void watchFolders(const QStringList &l, QmakePriFileNode *node);
+    void unwatchFolders(const QStringList &l, QmakePriFileNode *node);
 
     bool needsConfiguration() const;
 
@@ -145,7 +145,7 @@ public:
 
     ProjectExplorer::KitMatcher *createRequiredKitMatcher() const;
 signals:
-    void proFileUpdated(QmakeProjectManager::Qt4ProFileNode *node, bool, bool);
+    void proFileUpdated(QmakeProjectManager::QmakeProFileNode *node, bool, bool);
     void buildDirectoryInitialized();
     void proFilesEvaluated();
 
@@ -163,39 +163,39 @@ private slots:
     void activeTargetWasChanged();
 
 private:
-    QString executableFor(const Qt4ProFileNode *node);
+    QString executableFor(const QmakeProFileNode *node);
     void updateRunConfigurations();
 
     void updateCppCodeModel();
     void updateQmlJSCodeModel();
 
-    static void collectAllfProFiles(QList<Qt4ProFileNode *> &list, Qt4ProFileNode *node, Parsing parse);
-    static void collectApplicationProFiles(QList<Qt4ProFileNode *> &list, Qt4ProFileNode *node, Parsing parse);
-    static void findProFile(const QString& fileName, Qt4ProFileNode *root, QList<Qt4ProFileNode *> &list);
-    static bool hasSubNode(Qt4PriFileNode *root, const QString &path);
+    static void collectAllfProFiles(QList<QmakeProFileNode *> &list, QmakeProFileNode *node, Parsing parse);
+    static void collectApplicationProFiles(QList<QmakeProFileNode *> &list, QmakeProFileNode *node, Parsing parse);
+    static void findProFile(const QString& fileName, QmakeProFileNode *root, QList<QmakeProFileNode *> &list);
+    static bool hasSubNode(QmakePriFileNode *root, const QString &path);
 
     static bool equalFileList(const QStringList &a, const QStringList &b);
 
     void updateBuildSystemData();
-    void collectData(const Qt4ProFileNode *node, ProjectExplorer::DeploymentData &deploymentData);
-    void collectApplicationData(const Qt4ProFileNode *node,
+    void collectData(const QmakeProFileNode *node, ProjectExplorer::DeploymentData &deploymentData);
+    void collectApplicationData(const QmakeProFileNode *node,
                                 ProjectExplorer::DeploymentData &deploymentData);
-    void collectLibraryData(const Qt4ProFileNode *node,
+    void collectLibraryData(const QmakeProFileNode *node,
             ProjectExplorer::DeploymentData &deploymentData);
     QString destDirFor(const TargetInformation &ti);
 
     Qt4Manager *m_manager;
-    Qt4ProFileNode *m_rootProjectNode;
-    Internal::Qt4NodesWatcher *m_nodesWatcher;
+    QmakeProFileNode *m_rootProjectNode;
+    Internal::QmakeNodesWatcher *m_nodesWatcher;
 
-    Internal::Qt4ProjectFile *m_fileInfo;
+    Internal::QmakeProjectFile *m_fileInfo;
 
     // Current configuration
     QString m_oldQtIncludePath;
     QString m_oldQtLibsPath;
 
     // cached lists of all of files
-    Internal::Qt4ProjectFiles *m_projectFiles;
+    Internal::QmakeProjectFiles *m_projectFiles;
 
     QMakeVfs *m_qmakeVfs;
 
@@ -209,7 +209,7 @@ private:
     enum AsyncUpdateState { NoState, Base, AsyncFullUpdatePending, AsyncPartialUpdatePending, AsyncUpdateInProgress, ShuttingDown };
     AsyncUpdateState m_asyncUpdateState;
     bool m_cancelEvaluate;
-    QList<Qt4ProFileNode *> m_partialEvaluate;
+    QList<QmakeProFileNode *> m_partialEvaluate;
 
     QFuture<void> m_codeModelFuture;
 
@@ -217,7 +217,7 @@ private:
 
     ProjectExplorer::Target *m_activeTarget;
 
-    friend class Internal::Qt4ProjectFile;
+    friend class Internal::QmakeProjectFile;
     friend class Internal::Qt4ProjectConfigWidget;
     friend class Qt4Manager; // to schedule a async update if the unconfigured settings change
 };
diff --git a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp
index aac19b8ae3..542d468104 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp
@@ -49,7 +49,7 @@ Qt4ProjectConfigWidget::Qt4ProjectConfigWidget(QmakeBuildConfiguration *bc)
       m_ignoreChange(false)
 {
     m_defaultShadowBuildDir
-            = Qt4Project::shadowBuildDirectory(bc->target()->project()->projectFilePath(),
+            = QmakeProject::shadowBuildDirectory(bc->target()->project()->projectFilePath(),
                                                bc->target()->kit(),
                                                Utils::FileUtils::fileSystemFriendlyName(bc->displayName()));
 
@@ -92,7 +92,7 @@ Qt4ProjectConfigWidget::Qt4ProjectConfigWidget(QmakeBuildConfiguration *bc)
     connect(m_ui->shadowBuildDirEdit, SIGNAL(changed(QString)),
             this, SLOT(shadowBuildEdited()));
 
-    Qt4Project *project = static_cast<Qt4Project *>(bc->target()->project());
+    QmakeProject *project = static_cast<QmakeProject *>(bc->target()->project());
     connect(project, SIGNAL(environmentChanged()), this, SLOT(environmentChanged()));
     connect(project, SIGNAL(buildDirectoryInitialized()), this, SLOT(updateProblemLabel()));
     connect(project, SIGNAL(proFilesEvaluated()), this, SLOT(updateProblemLabel()));
@@ -201,8 +201,8 @@ void Qt4ProjectConfigWidget::updateProblemLabel()
         return;
     }
 
-    Qt4Project *p = static_cast<Qt4Project *>(m_buildConfiguration->target()->project());
-    if (p->rootQt4ProjectNode()->parseInProgress() || !p->rootQt4ProjectNode()->validParse()) {
+    QmakeProject *p = static_cast<QmakeProject *>(m_buildConfiguration->target()->project());
+    if (p->rootQmakeProjectNode()->parseInProgress() || !p->rootQmakeProjectNode()->validParse()) {
         setProblemLabel(QString());
         return;
     }
diff --git a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h
index daf0da1823..e8b74df8d8 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h
@@ -42,7 +42,7 @@ namespace Utils {
 
 namespace QmakeProjectManager {
 class QmakeBuildConfiguration;
-class Qt4ProFileNode;
+class QmakeProFileNode;
 
 namespace Internal {
 namespace Ui {
diff --git a/src/plugins/qt4projectmanager/qmakeprojectimporter.cpp b/src/plugins/qt4projectmanager/qmakeprojectimporter.cpp
index 7693538fdc..1a2395b5ef 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectimporter.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectimporter.cpp
@@ -186,7 +186,7 @@ QStringList QmakeProjectImporter::importCandidates(const Utils::FileName &projec
 
     QList<ProjectExplorer::Kit *> kitList = ProjectExplorer::KitManager::kits();
     foreach (ProjectExplorer::Kit *k, kitList) {
-        QFileInfo fi(Qt4Project::shadowBuildDirectory(projectPath.toString(), k, QString()));
+        QFileInfo fi(QmakeProject::shadowBuildDirectory(projectPath.toString(), k, QString()));
         const QString baseDir = fi.absolutePath();
 
         foreach (const QString &dir, QDir(baseDir).entryList()) {
diff --git a/src/plugins/qt4projectmanager/qmakeprojectimporter.h b/src/plugins/qt4projectmanager/qmakeprojectimporter.h
index 36078c6277..328b7175fe 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectimporter.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectimporter.h
@@ -36,7 +36,7 @@ namespace QtSupport { class BaseQtVersion; }
 
 namespace QmakeProjectManager {
 
-class Qt4Project;
+class QmakeProject;
 
 namespace Internal {
 
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp b/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp
index 4006d991b8..1f6ecacd2d 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp
@@ -75,19 +75,19 @@ Qt4Manager::~Qt4Manager()
 {
 }
 
-void Qt4Manager::registerProject(Qt4Project *project)
+void Qt4Manager::registerProject(QmakeProject *project)
 {
     m_projects.append(project);
 }
 
-void Qt4Manager::unregisterProject(Qt4Project *project)
+void Qt4Manager::unregisterProject(QmakeProject *project)
 {
     m_projects.removeOne(project);
 }
 
 void Qt4Manager::notifyChanged(const QString &name)
 {
-    foreach (Qt4Project *pro, m_projects)
+    foreach (QmakeProject *pro, m_projects)
         pro->notifyChanged(name);
 }
 
@@ -105,7 +105,7 @@ ProjectExplorer::Project *Qt4Manager::openProject(const QString &fileName, QStri
         return 0;
     }
 
-    return new Qt4Project(this, fileName);
+    return new QmakeProject(this, fileName);
 }
 
 ProjectExplorer::Node *Qt4Manager::contextNode() const
@@ -149,7 +149,7 @@ void Qt4Manager::addLibrary()
 void Qt4Manager::addLibraryContextMenu()
 {
     ProjectExplorer::Node *node = ProjectExplorer::ProjectExplorerPlugin::instance()->currentNode();
-    if (qobject_cast<Qt4ProFileNode *>(node))
+    if (qobject_cast<QmakeProFileNode *>(node))
         addLibrary(node->path());
 }
 
@@ -198,7 +198,7 @@ void Qt4Manager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *no
 {
     if (!ProjectExplorer::ProjectExplorerPlugin::instance()->saveModifiedFiles())
         return;
-    Qt4Project *qt4pro = qobject_cast<Qt4Project *>(p);
+    QmakeProject *qt4pro = qobject_cast<QmakeProject *>(p);
     QTC_ASSERT(qt4pro, return);
 
     if (!qt4pro->activeTarget() ||
@@ -214,7 +214,7 @@ void Qt4Manager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *no
     qs->setForced(true);
 
     if (node != 0 && node != qt4pro->rootProjectNode())
-        if (Qt4ProFileNode *profile = qobject_cast<Qt4ProFileNode *>(node))
+        if (QmakeProFileNode *profile = qobject_cast<QmakeProFileNode *>(node))
             bc->setSubNodeBuild(profile);
 
     BuildManager::appendStep(qs, tr("QMake"));
@@ -263,7 +263,7 @@ void Qt4Manager::handleSubDirContextMenu(Qt4Manager::Action action, bool isFileB
                                          ProjectExplorer::Node *contextNode,
                                          ProjectExplorer::FileNode *contextFile)
 {
-    Qt4Project *qt4pro = qobject_cast<Qt4Project *>(contextProject);
+    QmakeProject *qt4pro = qobject_cast<QmakeProject *>(contextProject);
     QTC_ASSERT(qt4pro, return);
 
     if (!qt4pro->activeTarget() ||
@@ -277,8 +277,8 @@ void Qt4Manager::handleSubDirContextMenu(Qt4Manager::Action action, bool isFileB
         return;
 
     if (contextNode) {
-        if (Qt4PriFileNode *prifile = qobject_cast<Qt4PriFileNode *>(contextNode)) {
-            if (Qt4ProFileNode *profile = prifile->proFileNode()) {
+        if (QmakePriFileNode *prifile = qobject_cast<QmakePriFileNode *>(contextNode)) {
+            if (QmakeProFileNode *profile = prifile->proFileNode()) {
                 if (profile != qt4pro->rootProjectNode() || isFileBuild)
                     bc->setSubNodeBuild(profile);
             }
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanager.h b/src/plugins/qt4projectmanager/qmakeprojectmanager.h
index 4e76d347fd..d3950b0af3 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanager.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanager.h
@@ -52,7 +52,7 @@ class ProFileEditorWidget;
 class Qt4ProjectManagerPlugin;
 } // namespace Internal
 
-class Qt4Project;
+class QmakeProject;
 
 class QT4PROJECTMANAGER_EXPORT Qt4Manager : public ProjectExplorer::IProjectManager
 {
@@ -62,8 +62,8 @@ public:
     Qt4Manager(Internal::Qt4ProjectManagerPlugin *plugin);
     ~Qt4Manager();
 
-    void registerProject(Qt4Project *project);
-    void unregisterProject(Qt4Project *project);
+    void registerProject(QmakeProject *project);
+    void unregisterProject(QmakeProject *project);
     void notifyChanged(const QString &name);
 
     virtual QString mimeType() const;
@@ -94,7 +94,7 @@ public slots:
     void buildFile();
 
 private:
-    QList<Qt4Project *> m_projects;
+    QList<QmakeProject *> m_projects;
     void handleSubDirContextMenu(Action action, bool isFileBuild);
     void handleSubDirContextMenu(Qt4Manager::Action action, bool isFileBuild,
                                  ProjectExplorer::Project *contextProject,
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp
index 1327e62f7f..58c1aaa71f 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp
@@ -297,7 +297,7 @@ void Qt4ProjectManagerPlugin::startupProjectChanged()
         disconnect(m_previousStartupProject, SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
                    this, SLOT(activeTargetChanged()));
 
-    m_previousStartupProject = qobject_cast<Qt4Project *>(SessionManager::startupProject());
+    m_previousStartupProject = qobject_cast<QmakeProject *>(SessionManager::startupProject());
 
     if (m_previousStartupProject)
         connect(m_previousStartupProject, SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
@@ -326,7 +326,7 @@ void Qt4ProjectManagerPlugin::updateRunQMakeAction()
     bool enable = true;
     if (BuildManager::isBuilding(m_projectExplorer->currentProject()))
         enable = false;
-    Qt4Project *pro = qobject_cast<Qt4Project *>(m_projectExplorer->currentProject());
+    QmakeProject *pro = qobject_cast<QmakeProject *>(m_projectExplorer->currentProject());
     if (!pro
             || !pro->activeTarget()
             || !pro->activeTarget()->activeBuildConfiguration())
@@ -337,13 +337,13 @@ void Qt4ProjectManagerPlugin::updateRunQMakeAction()
 
 void Qt4ProjectManagerPlugin::updateContextActions(ProjectExplorer::Node *node, ProjectExplorer::Project *project)
 {
-    m_addLibraryActionContextMenu->setEnabled(qobject_cast<Qt4ProFileNode *>(node));
+    m_addLibraryActionContextMenu->setEnabled(qobject_cast<QmakeProFileNode *>(node));
 
-    Qt4ProFileNode *proFileNode = qobject_cast<Qt4ProFileNode *>(node);
-    Qt4Project *qt4Project = qobject_cast<Qt4Project *>(project);
-    Qt4ProFileNode *subProjectNode = 0;
+    QmakeProFileNode *proFileNode = qobject_cast<QmakeProFileNode *>(node);
+    QmakeProject *qt4Project = qobject_cast<QmakeProject *>(project);
+    QmakeProFileNode *subProjectNode = 0;
     if (node) {
-        if (Qt4PriFileNode *subPriFileNode = qobject_cast<Qt4PriFileNode *>(node->projectNode()))
+        if (QmakePriFileNode *subPriFileNode = qobject_cast<QmakePriFileNode *>(node->projectNode()))
             subProjectNode = subPriFileNode->proFileNode();
     }
     ProjectExplorer::FileNode *fileNode = qobject_cast<ProjectExplorer::FileNode *>(node);
@@ -415,9 +415,9 @@ void Qt4ProjectManagerPlugin::updateBuildFileAction()
         Node *node  = SessionManager::nodeForFile(file);
         Project *project = SessionManager::projectForFile(file);
         m_buildFileAction->setParameter(QFileInfo(file).fileName());
-        visible = qobject_cast<Qt4Project *>(project)
+        visible = qobject_cast<QmakeProject *>(project)
                 && node
-                && qobject_cast<Qt4PriFileNode *>(node->projectNode());
+                && qobject_cast<QmakePriFileNode *>(node->projectNode());
 
         enabled = !BuildManager::isBuilding(project);
     }
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h
index 935bd9be84..12311f001c 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h
@@ -50,7 +50,7 @@ namespace QmakeProjectManager {
 
 class Qt4Manager;
 class QtVersionManager;
-class Qt4Project;
+class QmakeProject;
 
 namespace Internal {
 
@@ -84,7 +84,7 @@ private:
     ProjectExplorer::ProjectExplorerPlugin *m_projectExplorer;
     ProFileEditorFactory *m_proFileEditorFactory;
     Qt4Manager *m_qt4ProjectManager;
-    Qt4Project *m_previousStartupProject;
+    QmakeProject *m_previousStartupProject;
     ProjectExplorer::Target *m_previousTarget;
 
     QAction *m_runQMakeAction;
diff --git a/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp b/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp
index dc66e8e056..3e5edfd2e1 100644
--- a/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp
@@ -87,7 +87,7 @@ Qt4RunConfiguration::Qt4RunConfiguration(ProjectExplorer::Target *parent, Core::
     m_runMode(Gui),
     m_isUsingDyldImageSuffix(false)
 {
-    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);
 
@@ -123,11 +123,11 @@ QString Qt4RunConfiguration::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 Qt4RunConfiguration::proFileUpdated(QmakeProjectManager::Qt4ProFileNode *pro, bool success, bool parseInProgress)
+void Qt4RunConfiguration::proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress)
 {
     ProjectExplorer::LocalEnvironmentAspect *aspect
             = extraAspect<ProjectExplorer::LocalEnvironmentAspect>();
@@ -162,8 +162,8 @@ void Qt4RunConfiguration::ctor()
     QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit());
     m_forcedGuiMode = (version && version->type() == QLatin1String(QtSupport::Constants::SIMULATORQT));
 
-    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)));
     connect(target(), SIGNAL(kitChanged()),
             this, SLOT(kitChanged()));
 }
@@ -435,16 +435,16 @@ bool Qt4RunConfiguration::fromMap(const QVariantMap &map)
 
     m_userWorkingDirectory = map.value(QLatin1String(USER_WORKING_DIRECTORY_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 LocalApplicationRunConfiguration::fromMap(map);
 }
 
 QString Qt4RunConfiguration::executable() const
 {
-    Qt4Project *pro = static_cast<Qt4Project *>(target()->project());
-    const Qt4ProFileNode *node = pro->rootQt4ProjectNode()->findProFileFor(m_proFilePath);
+    QmakeProject *pro = static_cast<QmakeProject *>(target()->project());
+    const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(m_proFilePath);
     return extractWorkingDirAndExecutable(node).second;
 }
 
@@ -487,8 +487,8 @@ QString Qt4RunConfiguration::baseWorkingDirectory() const
         return m_userWorkingDirectory;
 
     // else what the pro file reader tells us
-    Qt4Project *pro = static_cast<Qt4Project *>(target()->project());
-    const Qt4ProFileNode *node = pro->rootQt4ProjectNode()->findProFileFor(m_proFilePath);
+    QmakeProject *pro = static_cast<QmakeProject *>(target()->project());
+    const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(m_proFilePath);
     return extractWorkingDirAndExecutable(node).first;
 }
 
@@ -533,7 +533,7 @@ void Qt4RunConfiguration::addToBaseEnvironment(Utils::Environment &env) const
     // The user could be linking to a library found via a -L/some/dir switch
     // to find those libraries while actually running we explicitly prepend those
     // dirs to the library search path
-    const Qt4ProFileNode *node = static_cast<Qt4Project *>(target()->project())->rootQt4ProjectNode()->findProFileFor(m_proFilePath);
+    const QmakeProFileNode *node = static_cast<QmakeProject *>(target()->project())->rootQmakeProjectNode()->findProFileFor(m_proFilePath);
     if (node) {
         const QStringList libDirectories = node->variableValue(LibDirectoriesVar);
         if (!libDirectories.isEmpty()) {
@@ -583,7 +583,7 @@ Utils::OutputFormatter *Qt4RunConfiguration::createOutputFormatter() const
     return new QtSupport::QtOutputFormatter(target()->project());
 }
 
-QPair<QString, QString> Qt4RunConfiguration::extractWorkingDirAndExecutable(const Qt4ProFileNode *node) const
+QPair<QString, QString> Qt4RunConfiguration::extractWorkingDirAndExecutable(const QmakeProFileNode *node) const
 {
     if (!node)
         return qMakePair(QString(), QString());
@@ -642,14 +642,14 @@ bool Qt4RunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, cons
 {
     if (!canHandle(parent))
         return false;
-    Qt4Project *project = static_cast<Qt4Project *>(parent->project());
+    QmakeProject *project = static_cast<QmakeProject *>(parent->project());
     return project->hasApplicationProFile(pathFromId(id));
 }
 
 ProjectExplorer::RunConfiguration *Qt4RunConfigurationFactory::doCreate(ProjectExplorer::Target *parent, const Core::Id id)
 {
     Qt4RunConfiguration *rc = new Qt4RunConfiguration(parent, id);
-    const Qt4ProFileNode *node = static_cast<Qt4Project *>(parent->project())->rootQt4ProjectNode()->findProFileFor(rc->proFilePath());
+    const QmakeProFileNode *node = static_cast<QmakeProject *>(parent->project())->rootQmakeProjectNode()->findProFileFor(rc->proFilePath());
     if (node) // should always be found
         rc->setRunMode(node->variableValue(ConfigVar).contains(QLatin1String("console"))
                        && !node->variableValue(QtVar).contains(QLatin1String("testlib"))
@@ -690,7 +690,7 @@ QList<Core::Id> Qt4RunConfigurationFactory::availableCreationIds(ProjectExplorer
     if (!canHandle(parent))
         return result;
 
-    Qt4Project *project = static_cast<Qt4Project *>(parent->project());
+    QmakeProject *project = static_cast<QmakeProject *>(parent->project());
     QStringList proFiles = project->applicationProFilePathes(QLatin1String(QT4_RC_PREFIX));
     foreach (const QString &pf, proFiles)
         result << Core::Id::fromString(pf);
@@ -706,7 +706,7 @@ bool Qt4RunConfigurationFactory::canHandle(ProjectExplorer::Target *t) const
 {
     if (!t->project()->supportsKit(t->kit()))
         return false;
-    if (!qobject_cast<Qt4Project *>(t->project()))
+    if (!qobject_cast<QmakeProject *>(t->project()))
         return false;
     Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(t->kit());
     return devType == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
diff --git a/src/plugins/qt4projectmanager/qmakerunconfiguration.h b/src/plugins/qt4projectmanager/qmakerunconfiguration.h
index 6208cfc704..ba1a3cfa13 100644
--- a/src/plugins/qt4projectmanager/qmakerunconfiguration.h
+++ b/src/plugins/qt4projectmanager/qmakerunconfiguration.h
@@ -53,9 +53,9 @@ class DetailsWidget;
 
 namespace QmakeProjectManager {
 
-class Qt4Project;
-class Qt4ProFileNode;
-class Qt4PriFileNode;
+class QmakeProject;
+class QmakeProFileNode;
+class QmakePriFileNode;
 class TargetInformation;
 
 namespace Internal {
@@ -108,14 +108,14 @@ signals:
 
 private slots:
     void kitChanged();
-    void proFileUpdated(QmakeProjectManager::Qt4ProFileNode *pro, bool success, bool parseInProgress);
+    void proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress);
 
 protected:
     Qt4RunConfiguration(ProjectExplorer::Target *parent, Qt4RunConfiguration *source);
     virtual bool fromMap(const QVariantMap &map);
 
 private:
-    QPair<QString, QString> extractWorkingDirAndExecutable(const Qt4ProFileNode *node) const;
+    QPair<QString, QString> extractWorkingDirAndExecutable(const QmakeProFileNode *node) const;
     void setBaseWorkingDirectory(const QString &workingDirectory);
     QString baseWorkingDirectory() const;
     void setCommandLineArguments(const QString &argumentsString);
diff --git a/src/plugins/qt4projectmanager/qmakestep.cpp b/src/plugins/qt4projectmanager/qmakestep.cpp
index 1aaf931f1b..397eef5a38 100644
--- a/src/plugins/qt4projectmanager/qmakestep.cpp
+++ b/src/plugins/qt4projectmanager/qmakestep.cpp
@@ -277,7 +277,7 @@ bool QMakeStep::init()
 
     setOutputParser(new QMakeParser);
 
-    Qt4ProFileNode *node = static_cast<Qt4Project *>(qt4bc->target()->project())->rootQt4ProjectNode();
+    QmakeProFileNode *node = static_cast<QmakeProject *>(qt4bc->target()->project())->rootQmakeProjectNode();
     if (qt4bc->subNodeBuild())
         node = qt4bc->subNodeBuild();
     QString proFile = node->path();
@@ -353,7 +353,7 @@ bool QMakeStep::processSucceeded(int exitCode, QProcess::ExitStatus status)
     bool result = AbstractProcessStep::processSucceeded(exitCode, status);
     if (!result)
         m_needToRunQMake = true;
-    Qt4Project *project = static_cast<Qt4Project *>(qmakeBuildConfiguration()->target()->project());
+    QmakeProject *project = static_cast<QmakeProject *>(qmakeBuildConfiguration()->target()->project());
     project->emitBuildDirectoryInitialized();
     return result;
 }
diff --git a/src/plugins/qt4projectmanager/qmakestep.h b/src/plugins/qt4projectmanager/qmakestep.h
index cf3a6db4d9..826e440db1 100644
--- a/src/plugins/qt4projectmanager/qmakestep.h
+++ b/src/plugins/qt4projectmanager/qmakestep.h
@@ -45,7 +45,7 @@ class Project;
 
 namespace QmakeProjectManager {
 class QmakeBuildConfiguration;
-class Qt4Project;
+class QmakeProject;
 
 namespace Internal {
 
diff --git a/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp b/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
index ffee57a04b..d22369cf0f 100644
--- a/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
@@ -215,7 +215,7 @@ bool AbstractMobileAppWizard::postGenerateFiles(const QWizard *w,
     Qt4Manager * const manager
         = ExtensionSystem::PluginManager::getObject<Qt4Manager>();
     Q_ASSERT(manager);
-    Qt4Project project(manager, app()->path(AbstractMobileApp::AppPro));
+    QmakeProject project(manager, app()->path(AbstractMobileApp::AppPro));
     bool success = true;
     if (wizardDialog()->m_targetsPage) {
         success = wizardDialog()->m_targetsPage->setupProject(&project);
diff --git a/src/plugins/qt4projectmanager/wizards/qtwizard.cpp b/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
index 8d10bf02c9..bbd483bf68 100644
--- a/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
@@ -275,7 +275,7 @@ bool BaseQt4ProjectWizardDialog::writeUserFile(const QString &proFileName) const
     Qt4Manager *manager = ExtensionSystem::PluginManager::getObject<Qt4Manager>();
     Q_ASSERT(manager);
 
-    Qt4Project *pro = new Qt4Project(manager, proFileName);
+    QmakeProject *pro = new QmakeProject(manager, proFileName);
     bool success = m_targetSetupPage->setupProject(pro);
     if (success)
         pro->saveSettings();
@@ -283,7 +283,7 @@ bool BaseQt4ProjectWizardDialog::writeUserFile(const QString &proFileName) const
     return success;
 }
 
-bool BaseQt4ProjectWizardDialog::setupProject(Qt4Project *project) const
+bool BaseQt4ProjectWizardDialog::setupProject(QmakeProject *project) const
 {
     if (!m_targetSetupPage)
         return true;
diff --git a/src/plugins/qt4projectmanager/wizards/qtwizard.h b/src/plugins/qt4projectmanager/wizards/qtwizard.h
index de266f071e..eace93c04e 100644
--- a/src/plugins/qt4projectmanager/wizards/qtwizard.h
+++ b/src/plugins/qt4projectmanager/wizards/qtwizard.h
@@ -41,7 +41,7 @@ class TargetSetupPage;
 
 namespace QmakeProjectManager {
 
-class Qt4Project;
+class QmakeProject;
 
 namespace Internal {
 
@@ -131,7 +131,7 @@ public:
     void setDeselectedModules(const QString &);
 
     bool writeUserFile(const QString &proFileName) const;
-    bool setupProject(Qt4Project *project) const;
+    bool setupProject(QmakeProject *project) const;
     bool isQtPlatformSelected(const QString &platform) const;
     QList<Core::Id> selectedKits() const;