Qt4ProjectManager: Rename Qt4Manager, QmakeProjectManagerPlugin, ...

Change-Id: I22dd15b10a6b06b380f19eda31925951f4566ecf
Reviewed-by: Eike Ziller <eike.ziller@digia.com>

18 files changed, 183 insertions, 184 deletions

diff --git a/src/plugins/qt4projectmanager/profileeditorfactory.cpp b/src/plugins/qt4projectmanager/profileeditorfactory.cpp
index fa6d37c264..3f75d5809d 100644
--- a/src/plugins/qt4projectmanager/profileeditorfactory.cpp
+++ b/src/plugins/qt4projectmanager/profileeditorfactory.cpp
@@ -42,7 +42,7 @@
 using namespace QmakeProjectManager;
 using namespace QmakeProjectManager::Internal;
 
-ProFileEditorFactory::ProFileEditorFactory(Qt4Manager *manager, TextEditor::TextEditorActionHandler *handler) :
+ProFileEditorFactory::ProFileEditorFactory(QmakeManager *manager, TextEditor::TextEditorActionHandler *handler) :
     m_manager(manager),
     m_actionHandler(handler)
 {
diff --git a/src/plugins/qt4projectmanager/profileeditorfactory.h b/src/plugins/qt4projectmanager/profileeditorfactory.h
index 1d50c8193a..07a2e5e21c 100644
--- a/src/plugins/qt4projectmanager/profileeditorfactory.h
+++ b/src/plugins/qt4projectmanager/profileeditorfactory.h
@@ -36,7 +36,7 @@ namespace TextEditor { class TextEditorActionHandler; }
 
 namespace QmakeProjectManager {
 
-class Qt4Manager;
+class QmakeManager;
 
 namespace Internal {
 
@@ -45,14 +45,14 @@ class ProFileEditorFactory : public Core::IEditorFactory
     Q_OBJECT
 
 public:
-    ProFileEditorFactory(Qt4Manager *parent, TextEditor::TextEditorActionHandler *handler);
+    ProFileEditorFactory(QmakeManager *parent, TextEditor::TextEditorActionHandler *handler);
 
     Core::IEditor *createEditor(QWidget *parent);
 
-    Qt4Manager *qt4ProjectManager() const { return m_manager; }
+    QmakeManager *qmakeProjectManager() const { return m_manager; }
 
 private:
-    Qt4Manager *m_manager;
+    QmakeManager *m_manager;
     TextEditor::TextEditorActionHandler *m_actionHandler;
 };
 
diff --git a/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp b/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp
index 13c818ef0d..89f87e5784 100644
--- a/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qmakebuildconfiguration.cpp
@@ -193,7 +193,7 @@ void QmakeBuildConfiguration::updateShadowBuild()
 
 NamedWidget *QmakeBuildConfiguration::createConfigWidget()
 {
-    return new Qt4ProjectConfigWidget(this);
+    return new QmakeProjectConfigWidget(this);
 }
 
 QString QmakeBuildConfiguration::defaultShadowBuildDirectory() const
diff --git a/src/plugins/qt4projectmanager/qmakebuildconfiguration.h b/src/plugins/qt4projectmanager/qmakebuildconfiguration.h
index 742350a439..235c5bcbff 100644
--- a/src/plugins/qt4projectmanager/qmakebuildconfiguration.h
+++ b/src/plugins/qt4projectmanager/qmakebuildconfiguration.h
@@ -45,7 +45,7 @@ class MakeStep;
 class QmakeBuildConfigurationFactory;
 class QmakeProFileNode;
 
-namespace Internal { class Qt4ProjectConfigWidget; }
+namespace Internal { class QmakeProjectConfigWidget; }
 
 class QT4PROJECTMANAGER_EXPORT QmakeBuildConfiguration : public ProjectExplorer::BuildConfiguration
 {
@@ -151,7 +151,7 @@ private:
     QmakeProjectManager::QmakeProFileNode *m_subNodeBuild;
     ProjectExplorer::FileNode *m_fileNodeBuild;
 
-    friend class Internal::Qt4ProjectConfigWidget;
+    friend class Internal::QmakeProjectConfigWidget;
     friend class QmakeBuildConfigurationFactory;
 };
 
diff --git a/src/plugins/qt4projectmanager/qmakeparser.cpp b/src/plugins/qt4projectmanager/qmakeparser.cpp
index d049d3d3f8..100d9a80cb 100644
--- a/src/plugins/qt4projectmanager/qmakeparser.cpp
+++ b/src/plugins/qt4projectmanager/qmakeparser.cpp
@@ -95,7 +95,7 @@ void QMakeParser::stdError(const QString &line)
 using namespace QmakeProjectManager::Internal;
 using namespace ProjectExplorer;
 
-void Qt4ProjectManagerPlugin::testQmakeOutputParsers_data()
+void QmakeProjectManagerPlugin::testQmakeOutputParsers_data()
 {
     const Core::Id categoryBuildSystem = Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM);
     QTest::addColumn<QString>("input");
@@ -163,7 +163,7 @@ void Qt4ProjectManagerPlugin::testQmakeOutputParsers_data()
             << QString();
 }
 
-void Qt4ProjectManagerPlugin::testQmakeOutputParsers()
+void QmakeProjectManagerPlugin::testQmakeOutputParsers()
 {
     OutputParserTester testbench;
     testbench.appendOutputParser(new QMakeParser);
diff --git a/src/plugins/qt4projectmanager/qmakeproject.cpp b/src/plugins/qt4projectmanager/qmakeproject.cpp
index 43254403f6..a9f396a174 100644
--- a/src/plugins/qt4projectmanager/qmakeproject.cpp
+++ b/src/plugins/qt4projectmanager/qmakeproject.cpp
@@ -92,12 +92,12 @@ void updateBoilerPlateCodeFiles(const AbstractMobileApp *app, const QString &pro
     const QList<AbstractGeneratedFileInfo> updates =
             app->fileUpdates(proFile);
     if (!updates.empty()) {
-        const QString title = Qt4Manager::tr("Update of Generated Files");
+        const QString title = QmakeManager::tr("Update of Generated Files");
         QStringList fileNames;
         foreach (const AbstractGeneratedFileInfo &info, updates)
             fileNames.append(QDir::toNativeSeparators(info.fileInfo.fileName()));
         const QString message =
-                Qt4Manager::tr("In project<br><br>%1<br><br>The following files are either "
+                QmakeManager::tr("In project<br><br>%1<br><br>The following files are either "
                                "outdated or have been modified:<br><br>%2<br><br>Do you want "
                                "Qt Creator to update the files? Any changes will be lost.")
                 .arg(proFile, fileNames.join(QLatin1String(", ")));
@@ -328,7 +328,7 @@ bool QmakeProjectFile::reload(QString *errorString, ReloadFlag flag, ChangeType
   QmakeProject manages information about an individual Qt 4 (.pro) project file.
   */
 
-QmakeProject::QmakeProject(Qt4Manager *manager, const QString &fileName) :
+QmakeProject::QmakeProject(QmakeManager *manager, const QString &fileName) :
     m_manager(manager),
     m_rootProjectNode(0),
     m_nodesWatcher(new Internal::QmakeNodesWatcher(this)),
@@ -870,7 +870,7 @@ ProjectExplorer::IProjectManager *QmakeProject::projectManager() const
     return m_manager;
 }
 
-Qt4Manager *QmakeProject::qt4ProjectManager() const
+QmakeManager *QmakeProject::qt4ProjectManager() const
 {
     return m_manager;
 }
diff --git a/src/plugins/qt4projectmanager/qmakeproject.h b/src/plugins/qt4projectmanager/qmakeproject.h
index 07a76bd04e..2d08a113e3 100644
--- a/src/plugins/qt4projectmanager/qmakeproject.h
+++ b/src/plugins/qt4projectmanager/qmakeproject.h
@@ -52,7 +52,7 @@ namespace QmakeProjectManager {
 class MakeStep;
 class QMakeStep;
 class QmakeBuildConfiguration;
-class Qt4Manager;
+class QmakeManager;
 class QmakePriFileNode;
 class QmakeProFileNode;
 class Qt4RunStep;
@@ -63,7 +63,7 @@ class CentralizedFolderWatcher;
 class FileItem;
 class GCCPreprocessor;
 class QmakeProjectFiles;
-class Qt4ProjectConfigWidget;
+class QmakeProjectConfigWidget;
 class QmakeProjectFile;
 class QmakeNodesWatcher;
 }
@@ -73,14 +73,14 @@ class  QT4PROJECTMANAGER_EXPORT QmakeProject : public ProjectExplorer::Project
     Q_OBJECT
 
 public:
-    QmakeProject(Qt4Manager *manager, const QString &proFile);
+    QmakeProject(QmakeManager *manager, const QString &proFile);
     virtual ~QmakeProject();
 
     QString displayName() const;
     Core::Id id() const;
     Core::IDocument *document() const;
     ProjectExplorer::IProjectManager *projectManager() const;
-    Qt4Manager *qt4ProjectManager() const;
+    QmakeManager *qt4ProjectManager() const;
 
     bool supportsKit(ProjectExplorer::Kit *k, QString *errorMesage) const;
 
@@ -184,7 +184,7 @@ private:
             ProjectExplorer::DeploymentData &deploymentData);
     QString destDirFor(const TargetInformation &ti);
 
-    Qt4Manager *m_manager;
+    QmakeManager *m_manager;
     QmakeProFileNode *m_rootProjectNode;
     Internal::QmakeNodesWatcher *m_nodesWatcher;
 
@@ -218,8 +218,8 @@ private:
     ProjectExplorer::Target *m_activeTarget;
 
     friend class Internal::QmakeProjectFile;
-    friend class Internal::Qt4ProjectConfigWidget;
-    friend class Qt4Manager; // to schedule a async update if the unconfigured settings change
+    friend class Internal::QmakeProjectConfigWidget;
+    friend class QmakeManager; // to schedule a async update if the unconfigured settings change
 };
 
 } // namespace QmakeProjectManager
diff --git a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp
index 542d468104..82292aea24 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.cpp
@@ -43,7 +43,7 @@ using namespace QmakeProjectManager;
 using namespace QmakeProjectManager::Internal;
 using namespace ProjectExplorer;
 
-Qt4ProjectConfigWidget::Qt4ProjectConfigWidget(QmakeBuildConfiguration *bc)
+QmakeProjectConfigWidget::QmakeProjectConfigWidget(QmakeBuildConfiguration *bc)
     : NamedWidget(),
       m_buildConfiguration(bc),
       m_ignoreChange(false)
@@ -60,7 +60,7 @@ Qt4ProjectConfigWidget::Qt4ProjectConfigWidget(QmakeBuildConfiguration *bc)
     vbox->addWidget(m_detailsContainer);
     QWidget *details = new QWidget(m_detailsContainer);
     m_detailsContainer->setWidget(details);
-    m_ui = new Ui::Qt4ProjectConfigWidget();
+    m_ui = new Ui::QmakeProjectConfigWidget();
     m_ui->setupUi(details);
 
     m_browseButton = m_ui->shadowBuildDirEdit->buttonAtIndex(0);
@@ -110,31 +110,31 @@ Qt4ProjectConfigWidget::Qt4ProjectConfigWidget(QmakeBuildConfiguration *bc)
     updateProblemLabel();
 }
 
-Qt4ProjectConfigWidget::~Qt4ProjectConfigWidget()
+QmakeProjectConfigWidget::~QmakeProjectConfigWidget()
 {
     delete m_ui;
 }
 
-void Qt4ProjectConfigWidget::updateDetails()
+void QmakeProjectConfigWidget::updateDetails()
 {
     m_detailsContainer->setSummaryText(
                 tr("building in <b>%1</b>")
                 .arg(m_buildConfiguration->buildDirectory().toUserOutput()));
 }
 
-void Qt4ProjectConfigWidget::setProblemLabel(const QString &text)
+void QmakeProjectConfigWidget::setProblemLabel(const QString &text)
 {
     m_ui->warningLabel->setVisible(!text.isEmpty());
     m_ui->problemLabel->setVisible(!text.isEmpty());
     m_ui->problemLabel->setText(text);
 }
 
-void Qt4ProjectConfigWidget::environmentChanged()
+void QmakeProjectConfigWidget::environmentChanged()
 {
     m_ui->shadowBuildDirEdit->setEnvironment(m_buildConfiguration->environment());
 }
 
-void Qt4ProjectConfigWidget::buildDirectoryChanged()
+void QmakeProjectConfigWidget::buildDirectoryChanged()
 {
     if (m_ignoreChange)
         return;
@@ -152,14 +152,14 @@ void Qt4ProjectConfigWidget::buildDirectoryChanged()
     updateProblemLabel();
 }
 
-void Qt4ProjectConfigWidget::onBeforeBeforeShadowBuildDirBrowsed()
+void QmakeProjectConfigWidget::onBeforeBeforeShadowBuildDirBrowsed()
 {
     QString initialDirectory = m_buildConfiguration->target()->project()->projectDirectory();
     if (!initialDirectory.isEmpty())
         m_ui->shadowBuildDirEdit->setInitialBrowsePathBackup(initialDirectory);
 }
 
-void Qt4ProjectConfigWidget::shadowBuildClicked(bool checked)
+void QmakeProjectConfigWidget::shadowBuildClicked(bool checked)
 {
     m_ui->shadowBuildDirEdit->setEnabled(checked);
     m_browseButton->setEnabled(checked);
@@ -178,7 +178,7 @@ void Qt4ProjectConfigWidget::shadowBuildClicked(bool checked)
     updateProblemLabel();
 }
 
-void Qt4ProjectConfigWidget::shadowBuildEdited()
+void QmakeProjectConfigWidget::shadowBuildEdited()
 {
     if (m_buildConfiguration->rawBuildDirectory().toString() == m_ui->shadowBuildDirEdit->rawPath())
         return;
@@ -188,7 +188,7 @@ void Qt4ProjectConfigWidget::shadowBuildEdited()
     m_ignoreChange = false;
 }
 
-void Qt4ProjectConfigWidget::updateProblemLabel()
+void QmakeProjectConfigWidget::updateProblemLabel()
 {
     m_ui->shadowBuildDirEdit->triggerChanged();
     ProjectExplorer::Kit *k = m_buildConfiguration->target()->kit();
diff --git a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h
index e8b74df8d8..95946d8c86 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.h
@@ -46,15 +46,15 @@ class QmakeProFileNode;
 
 namespace Internal {
 namespace Ui {
-class Qt4ProjectConfigWidget;
+class QmakeProjectConfigWidget;
 }
 
-class Qt4ProjectConfigWidget : public ProjectExplorer::NamedWidget
+class QmakeProjectConfigWidget : public ProjectExplorer::NamedWidget
 {
     Q_OBJECT
 public:
-    Qt4ProjectConfigWidget(QmakeBuildConfiguration *bc);
-    ~Qt4ProjectConfigWidget();
+    QmakeProjectConfigWidget(QmakeBuildConfiguration *bc);
+    ~QmakeProjectConfigWidget();
 
 private slots:
     // User changes in our widgets
@@ -71,7 +71,7 @@ private:
     void updateDetails();
     void setProblemLabel(const QString &text);
 
-    Ui::Qt4ProjectConfigWidget *m_ui;
+    Ui::QmakeProjectConfigWidget *m_ui;
     QAbstractButton *m_browseButton;
     QmakeBuildConfiguration *m_buildConfiguration;
     Utils::DetailsWidget *m_detailsContainer;
diff --git a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.ui b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.ui
index cef43d4129..c2383e587b 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.ui
+++ b/src/plugins/qt4projectmanager/qmakeprojectconfigwidget.ui
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>QmakeProjectManager::Internal::Qt4ProjectConfigWidget</class>
- <widget class="QWidget" name="QmakeProjectManager::Internal::Qt4ProjectConfigWidget">
+ <class>QmakeProjectManager::Internal::QmakeProjectConfigWidget</class>
+ <widget class="QWidget" name="QmakeProjectManager::Internal::QmakeProjectConfigWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp b/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp
index 1f6ecacd2d..bccffff2c0 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanager.cpp
@@ -63,7 +63,7 @@ static const char *qt4FileTypes[] = {
     "Qt4ResourceFiles"
 };
 
-Qt4Manager::Qt4Manager(Qt4ProjectManagerPlugin *plugin)
+QmakeManager::QmakeManager(QmakeProjectManagerPlugin *plugin)
   : m_plugin(plugin),
     m_contextNode(0),
     m_contextProject(0),
@@ -71,32 +71,32 @@ Qt4Manager::Qt4Manager(Qt4ProjectManagerPlugin *plugin)
 {
 }
 
-Qt4Manager::~Qt4Manager()
+QmakeManager::~QmakeManager()
 {
 }
 
-void Qt4Manager::registerProject(QmakeProject *project)
+void QmakeManager::registerProject(QmakeProject *project)
 {
     m_projects.append(project);
 }
 
-void Qt4Manager::unregisterProject(QmakeProject *project)
+void QmakeManager::unregisterProject(QmakeProject *project)
 {
     m_projects.removeOne(project);
 }
 
-void Qt4Manager::notifyChanged(const QString &name)
+void QmakeManager::notifyChanged(const QString &name)
 {
     foreach (QmakeProject *pro, m_projects)
         pro->notifyChanged(name);
 }
 
-QString Qt4Manager::mimeType() const
+QString QmakeManager::mimeType() const
 {
     return QLatin1String(QmakeProjectManager::Constants::PROFILE_MIMETYPE);
 }
 
-ProjectExplorer::Project *Qt4Manager::openProject(const QString &fileName, QString *errorString)
+ProjectExplorer::Project *QmakeManager::openProject(const QString &fileName, QString *errorString)
 {
     if (!QFileInfo(fileName).isFile()) {
         if (errorString)
@@ -108,37 +108,37 @@ ProjectExplorer::Project *Qt4Manager::openProject(const QString &fileName, QStri
     return new QmakeProject(this, fileName);
 }
 
-ProjectExplorer::Node *Qt4Manager::contextNode() const
+ProjectExplorer::Node *QmakeManager::contextNode() const
 {
     return m_contextNode;
 }
 
-void Qt4Manager::setContextNode(ProjectExplorer::Node *node)
+void QmakeManager::setContextNode(ProjectExplorer::Node *node)
 {
     m_contextNode = node;
 }
 
-ProjectExplorer::Project *Qt4Manager::contextProject() const
+ProjectExplorer::Project *QmakeManager::contextProject() const
 {
     return m_contextProject;
 }
 
-void Qt4Manager::setContextProject(ProjectExplorer::Project *project)
+void QmakeManager::setContextProject(ProjectExplorer::Project *project)
 {
     m_contextProject = project;
 }
 
-ProjectExplorer::FileNode *Qt4Manager::contextFile() const
+ProjectExplorer::FileNode *QmakeManager::contextFile() const
 {
     return m_contextFile;
 }
 
-void Qt4Manager::setContextFile(ProjectExplorer::FileNode *file)
+void QmakeManager::setContextFile(ProjectExplorer::FileNode *file)
 {
     m_contextFile = file;
 }
 
-void Qt4Manager::addLibrary()
+void QmakeManager::addLibrary()
 {
     ProFileEditorWidget *editor =
         qobject_cast<ProFileEditorWidget*>(Core::EditorManager::currentEditor()->widget());
@@ -146,14 +146,14 @@ void Qt4Manager::addLibrary()
         addLibrary(editor->editorDocument()->filePath(), editor);
 }
 
-void Qt4Manager::addLibraryContextMenu()
+void QmakeManager::addLibraryContextMenu()
 {
     ProjectExplorer::Node *node = ProjectExplorer::ProjectExplorerPlugin::instance()->currentNode();
     if (qobject_cast<QmakeProFileNode *>(node))
         addLibrary(node->path());
 }
 
-void Qt4Manager::addLibrary(const QString &fileName, ProFileEditorWidget *editor)
+void QmakeManager::addLibrary(const QString &fileName, ProFileEditorWidget *editor)
 {
     AddLibraryWizard wizard(fileName, Core::EditorManager::instance());
     if (wizard.exec() != QDialog::Accepted)
@@ -184,17 +184,17 @@ void Qt4Manager::addLibrary(const QString &fileName, ProFileEditorWidget *editor
 }
 
 
-void Qt4Manager::runQMake()
+void QmakeManager::runQMake()
 {
     runQMake(SessionManager::startupProject(), 0);
 }
 
-void Qt4Manager::runQMakeContextMenu()
+void QmakeManager::runQMakeContextMenu()
 {
     runQMake(m_contextProject, m_contextNode);
 }
 
-void Qt4Manager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *node)
+void QmakeManager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *node)
 {
     if (!ProjectExplorer::ProjectExplorerPlugin::instance()->saveModifiedFiles())
         return;
@@ -221,27 +221,27 @@ void Qt4Manager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *no
     bc->setSubNodeBuild(0);
 }
 
-void Qt4Manager::buildSubDirContextMenu()
+void QmakeManager::buildSubDirContextMenu()
 {
     handleSubDirContextMenu(BUILD, false);
 }
 
-void Qt4Manager::cleanSubDirContextMenu()
+void QmakeManager::cleanSubDirContextMenu()
 {
     handleSubDirContextMenu(CLEAN, false);
 }
 
-void Qt4Manager::rebuildSubDirContextMenu()
+void QmakeManager::rebuildSubDirContextMenu()
 {
     handleSubDirContextMenu(REBUILD, false);
 }
 
-void Qt4Manager::buildFileContextMenu()
+void QmakeManager::buildFileContextMenu()
 {
     handleSubDirContextMenu(BUILD, true);
 }
 
-void Qt4Manager::buildFile()
+void QmakeManager::buildFile()
 {
     if (Core::IDocument *currentDocument= Core::EditorManager::currentDocument()) {
         const QString file = currentDocument->filePath();
@@ -253,12 +253,12 @@ void Qt4Manager::buildFile()
     }
 }
 
-void Qt4Manager::handleSubDirContextMenu(Qt4Manager::Action action, bool isFileBuild)
+void QmakeManager::handleSubDirContextMenu(QmakeManager::Action action, bool isFileBuild)
 {
     handleSubDirContextMenu(action, isFileBuild, m_contextProject, m_contextNode, m_contextFile);
 }
 
-void Qt4Manager::handleSubDirContextMenu(Qt4Manager::Action action, bool isFileBuild,
+void QmakeManager::handleSubDirContextMenu(QmakeManager::Action action, bool isFileBuild,
                                          ProjectExplorer::Project *contextProject,
                                          ProjectExplorer::Node *contextNode,
                                          ProjectExplorer::FileNode *contextFile)
@@ -311,7 +311,7 @@ void Qt4Manager::handleSubDirContextMenu(Qt4Manager::Action action, bool isFileB
     bc->setFileNodeBuild(0);
 }
 
-QString Qt4Manager::fileTypeId(ProjectExplorer::FileType type)
+QString QmakeManager::fileTypeId(ProjectExplorer::FileType type)
 {
     switch (type) {
     case HeaderType:
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanager.h b/src/plugins/qt4projectmanager/qmakeprojectmanager.h
index d3950b0af3..515511c286 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanager.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanager.h
@@ -47,20 +47,19 @@ class ToolChain;
 namespace QmakeProjectManager {
 
 namespace Internal {
-class Qt4Builder;
 class ProFileEditorWidget;
-class Qt4ProjectManagerPlugin;
+class QmakeProjectManagerPlugin;
 } // namespace Internal
 
 class QmakeProject;
 
-class QT4PROJECTMANAGER_EXPORT Qt4Manager : public ProjectExplorer::IProjectManager
+class QT4PROJECTMANAGER_EXPORT QmakeManager : public ProjectExplorer::IProjectManager
 {
     Q_OBJECT
 
 public:
-    Qt4Manager(Internal::Qt4ProjectManagerPlugin *plugin);
-    ~Qt4Manager();
+    QmakeManager(Internal::QmakeProjectManagerPlugin *plugin);
+    ~QmakeManager();
 
     void registerProject(QmakeProject *project);
     void unregisterProject(QmakeProject *project);
@@ -96,14 +95,14 @@ public slots:
 private:
     QList<QmakeProject *> m_projects;
     void handleSubDirContextMenu(Action action, bool isFileBuild);
-    void handleSubDirContextMenu(Qt4Manager::Action action, bool isFileBuild,
+    void handleSubDirContextMenu(QmakeManager::Action action, bool isFileBuild,
                                  ProjectExplorer::Project *contextProject,
                                  ProjectExplorer::Node *contextNode,
                                  ProjectExplorer::FileNode *contextFile);
     void addLibrary(const QString &fileName, Internal::ProFileEditorWidget *editor = 0);
     void runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *node);
 
-    Internal::Qt4ProjectManagerPlugin *m_plugin;
+    Internal::QmakeProjectManagerPlugin *m_plugin;
     ProjectExplorer::Node *m_contextNode;
     ProjectExplorer::Project *m_contextProject;
     ProjectExplorer::FileNode *m_contextFile;
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp
index 58c1aaa71f..1ba5855f05 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.cpp
@@ -79,13 +79,13 @@ using namespace QmakeProjectManager::Internal;
 using namespace QmakeProjectManager;
 using namespace ProjectExplorer;
 
-Qt4ProjectManagerPlugin::Qt4ProjectManagerPlugin()
+QmakeProjectManagerPlugin::QmakeProjectManagerPlugin()
     : m_previousStartupProject(0), m_previousTarget(0)
 {
 
 }
 
-Qt4ProjectManagerPlugin::~Qt4ProjectManagerPlugin()
+QmakeProjectManagerPlugin::~QmakeProjectManagerPlugin()
 {
     //removeObject(m_embeddedPropertiesPage);
     //delete m_embeddedPropertiesPage;
@@ -96,7 +96,7 @@ Qt4ProjectManagerPlugin::~Qt4ProjectManagerPlugin()
     delete m_qt4ProjectManager;
 }
 
-bool Qt4ProjectManagerPlugin::initialize(const QStringList &arguments, QString *errorMessage)
+bool QmakeProjectManagerPlugin::initialize(const QStringList &arguments, QString *errorMessage)
 {
     Q_UNUSED(arguments)
     const Core::Context projectContext(QmakeProjectManager::Constants::PROJECT_ID);
@@ -108,7 +108,7 @@ bool Qt4ProjectManagerPlugin::initialize(const QStringList &arguments, QString *
     m_projectExplorer = ProjectExplorer::ProjectExplorerPlugin::instance();
 
     //create and register objects
-    m_qt4ProjectManager = new Qt4Manager(this);
+    m_qt4ProjectManager = new QmakeManager(this);
     addObject(m_qt4ProjectManager);
 
     TextEditor::TextEditorActionHandler *editorHandler
@@ -288,10 +288,10 @@ bool Qt4ProjectManagerPlugin::initialize(const QStringList &arguments, QString *
     return true;
 }
 
-void Qt4ProjectManagerPlugin::extensionsInitialized()
+void QmakeProjectManagerPlugin::extensionsInitialized()
 { }
 
-void Qt4ProjectManagerPlugin::startupProjectChanged()
+void QmakeProjectManagerPlugin::startupProjectChanged()
 {
     if (m_previousStartupProject)
         disconnect(m_previousStartupProject, SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
@@ -306,7 +306,7 @@ void Qt4ProjectManagerPlugin::startupProjectChanged()
     activeTargetChanged();
 }
 
-void Qt4ProjectManagerPlugin::activeTargetChanged()
+void QmakeProjectManagerPlugin::activeTargetChanged()
 {
     if (m_previousTarget)
         disconnect(m_previousTarget, SIGNAL(activeBuildConfigurationChanged(ProjectExplorer::BuildConfiguration*)),
@@ -321,7 +321,7 @@ void Qt4ProjectManagerPlugin::activeTargetChanged()
     updateRunQMakeAction();
 }
 
-void Qt4ProjectManagerPlugin::updateRunQMakeAction()
+void QmakeProjectManagerPlugin::updateRunQMakeAction()
 {
     bool enable = true;
     if (BuildManager::isBuilding(m_projectExplorer->currentProject()))
@@ -335,7 +335,7 @@ void Qt4ProjectManagerPlugin::updateRunQMakeAction()
     m_runQMakeAction->setEnabled(enable);
 }
 
-void Qt4ProjectManagerPlugin::updateContextActions(ProjectExplorer::Node *node, ProjectExplorer::Project *project)
+void QmakeProjectManagerPlugin::updateContextActions(ProjectExplorer::Node *node, ProjectExplorer::Project *project)
 {
     m_addLibraryActionContextMenu->setEnabled(qobject_cast<QmakeProFileNode *>(node));
 
@@ -395,7 +395,7 @@ void Qt4ProjectManagerPlugin::updateContextActions(ProjectExplorer::Node *node,
     m_buildFileContextMenu->setEnabled(buildFilePossible && !isBuilding);
 }
 
-void Qt4ProjectManagerPlugin::buildStateChanged(ProjectExplorer::Project *pro)
+void QmakeProjectManagerPlugin::buildStateChanged(ProjectExplorer::Project *pro)
 {
     ProjectExplorer::Project *currentProject = m_projectExplorer->currentProject();
     if (pro == currentProject) {
@@ -405,7 +405,7 @@ void Qt4ProjectManagerPlugin::buildStateChanged(ProjectExplorer::Project *pro)
     }
 }
 
-void Qt4ProjectManagerPlugin::updateBuildFileAction()
+void QmakeProjectManagerPlugin::updateBuildFileAction()
 {
     bool visible = false;
     bool enabled = false;
diff --git a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h
index 12311f001c..13d68073fa 100644
--- a/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h
+++ b/src/plugins/qt4projectmanager/qmakeprojectmanagerplugin.h
@@ -48,7 +48,7 @@ namespace Utils { class ParameterAction; }
 
 namespace QmakeProjectManager {
 
-class Qt4Manager;
+class QmakeManager;
 class QtVersionManager;
 class QmakeProject;
 
@@ -56,14 +56,14 @@ namespace Internal {
 
 class ProFileEditorFactory;
 
-class Qt4ProjectManagerPlugin : public ExtensionSystem::IPlugin
+class QmakeProjectManagerPlugin : public ExtensionSystem::IPlugin
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QtCreatorPlugin" FILE "Qt4ProjectManager.json")
 
 public:
-    Qt4ProjectManagerPlugin();
-    ~Qt4ProjectManagerPlugin();
+    QmakeProjectManagerPlugin();
+    ~QmakeProjectManagerPlugin();
     bool initialize(const QStringList &arguments, QString *errorMessage);
     void extensionsInitialized();
 
@@ -83,7 +83,7 @@ private slots:
 private:
     ProjectExplorer::ProjectExplorerPlugin *m_projectExplorer;
     ProFileEditorFactory *m_proFileEditorFactory;
-    Qt4Manager *m_qt4ProjectManager;
+    QmakeManager *m_qt4ProjectManager;
     QmakeProject *m_previousStartupProject;
     ProjectExplorer::Target *m_previousTarget;
 
diff --git a/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp b/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp
index 3e5edfd2e1..1022673af9 100644
--- a/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qmakerunconfiguration.cpp
@@ -81,7 +81,7 @@ QString pathFromId(Core::Id id)
 // Qt4RunConfiguration
 //
 
-Qt4RunConfiguration::Qt4RunConfiguration(ProjectExplorer::Target *parent, Core::Id id) :
+QmakeRunConfiguration::QmakeRunConfiguration(ProjectExplorer::Target *parent, Core::Id id) :
     LocalApplicationRunConfiguration(parent, id),
     m_proFilePath(pathFromId(id)),
     m_runMode(Gui),
@@ -94,7 +94,7 @@ Qt4RunConfiguration::Qt4RunConfiguration(ProjectExplorer::Target *parent, Core::
     ctor();
 }
 
-Qt4RunConfiguration::Qt4RunConfiguration(ProjectExplorer::Target *parent, Qt4RunConfiguration *source) :
+QmakeRunConfiguration::QmakeRunConfiguration(ProjectExplorer::Target *parent, QmakeRunConfiguration *source) :
     LocalApplicationRunConfiguration(parent, source),
     m_commandLineArguments(source->m_commandLineArguments),
     m_proFilePath(source->m_proFilePath),
@@ -107,16 +107,16 @@ Qt4RunConfiguration::Qt4RunConfiguration(ProjectExplorer::Target *parent, Qt4Run
     ctor();
 }
 
-Qt4RunConfiguration::~Qt4RunConfiguration()
+QmakeRunConfiguration::~QmakeRunConfiguration()
 {
 }
 
-bool Qt4RunConfiguration::isEnabled() const
+bool QmakeRunConfiguration::isEnabled() const
 {
     return m_parseSuccess && !m_parseInProgress;
 }
 
-QString Qt4RunConfiguration::disabledReason() const
+QString QmakeRunConfiguration::disabledReason() const
 {
     if (m_parseInProgress)
         return tr("The .pro file '%1' is currently being parsed.")
@@ -127,7 +127,7 @@ QString Qt4RunConfiguration::disabledReason() const
     return QString();
 }
 
-void Qt4RunConfiguration::proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress)
+void QmakeRunConfiguration::proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress)
 {
     ProjectExplorer::LocalEnvironmentAspect *aspect
             = extraAspect<ProjectExplorer::LocalEnvironmentAspect>();
@@ -155,7 +155,7 @@ void Qt4RunConfiguration::proFileUpdated(QmakeProjectManager::QmakeProFileNode *
     }
 }
 
-void Qt4RunConfiguration::ctor()
+void QmakeRunConfiguration::ctor()
 {
     setDefaultDisplayName(defaultDisplayName());
 
@@ -168,7 +168,7 @@ void Qt4RunConfiguration::ctor()
             this, SLOT(kitChanged()));
 }
 
-void Qt4RunConfiguration::kitChanged()
+void QmakeRunConfiguration::kitChanged()
 {
     QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit());
     m_forcedGuiMode = (version && version->type() == QLatin1String(QtSupport::Constants::SIMULATORQT));
@@ -179,9 +179,9 @@ void Qt4RunConfiguration::kitChanged()
 /// Qt4RunConfigurationWidget
 /////
 
-Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4RunConfiguration, QWidget *parent)
+QmakeRunConfigurationWidget::QmakeRunConfigurationWidget(QmakeRunConfiguration *qmakeRunConfiguration, QWidget *parent)
     : QWidget(parent),
-    m_qt4RunConfiguration(qt4RunConfiguration),
+    m_qmakeRunConfiguration(qmakeRunConfiguration),
     m_ignoreChange(false),
     m_usingDyldImageSuffix(0),
     m_isShown(false)
@@ -209,21 +209,21 @@ Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4Run
     toplayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
     toplayout->setMargin(0);
 
-    m_executableLineEdit = new QLineEdit(m_qt4RunConfiguration->executable(), this);
+    m_executableLineEdit = new QLineEdit(m_qmakeRunConfiguration->executable(), this);
     m_executableLineEdit->setEnabled(false);
     toplayout->addRow(tr("Executable:"), m_executableLineEdit);
 
     QLabel *argumentsLabel = new QLabel(tr("Arguments:"), this);
-    m_argumentsLineEdit = new QLineEdit(qt4RunConfiguration->rawCommandLineArguments(), this);
+    m_argumentsLineEdit = new QLineEdit(qmakeRunConfiguration->rawCommandLineArguments(), this);
     argumentsLabel->setBuddy(m_argumentsLineEdit);
     toplayout->addRow(argumentsLabel, m_argumentsLineEdit);
 
     m_workingDirectoryEdit = new Utils::PathChooser(this);
     m_workingDirectoryEdit->setExpectedKind(Utils::PathChooser::Directory);
-    m_workingDirectoryEdit->setPath(m_qt4RunConfiguration->baseWorkingDirectory());
-    m_workingDirectoryEdit->setBaseDirectory(m_qt4RunConfiguration->target()->project()->projectDirectory());
+    m_workingDirectoryEdit->setPath(m_qmakeRunConfiguration->baseWorkingDirectory());
+    m_workingDirectoryEdit->setBaseDirectory(m_qmakeRunConfiguration->target()->project()->projectDirectory());
     ProjectExplorer::EnvironmentAspect *aspect
-            = qt4RunConfiguration->extraAspect<ProjectExplorer::EnvironmentAspect>();
+            = qmakeRunConfiguration->extraAspect<ProjectExplorer::EnvironmentAspect>();
     if (aspect) {
         connect(aspect, SIGNAL(environmentChanged()), this, SLOT(environmentWasChanged()));
         environmentWasChanged();
@@ -242,13 +242,13 @@ Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4Run
 
     QHBoxLayout *innerBox = new QHBoxLayout();
     m_useTerminalCheck = new QCheckBox(tr("Run in terminal"), this);
-    m_useTerminalCheck->setChecked(m_qt4RunConfiguration->runMode() == ProjectExplorer::LocalApplicationRunConfiguration::Console);
-    m_useTerminalCheck->setVisible(!m_qt4RunConfiguration->forcedGuiMode());
+    m_useTerminalCheck->setChecked(m_qmakeRunConfiguration->runMode() == ProjectExplorer::LocalApplicationRunConfiguration::Console);
+    m_useTerminalCheck->setVisible(!m_qmakeRunConfiguration->forcedGuiMode());
     innerBox->addWidget(m_useTerminalCheck);
 
     m_useQvfbCheck = new QCheckBox(tr("Run on QVFb"), this);
     m_useQvfbCheck->setToolTip(tr("Check this option to run the application on a Qt Virtual Framebuffer."));
-    m_useQvfbCheck->setChecked(m_qt4RunConfiguration->runMode() == ProjectExplorer::LocalApplicationRunConfiguration::Console);
+    m_useQvfbCheck->setChecked(m_qmakeRunConfiguration->runMode() == ProjectExplorer::LocalApplicationRunConfiguration::Console);
     m_useQvfbCheck->setVisible(false);
     innerBox->addWidget(m_useQvfbCheck);
     innerBox->addStretch();
@@ -256,7 +256,7 @@ Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4Run
 
     if (Utils::HostOsInfo::isMacHost()) {
         m_usingDyldImageSuffix = new QCheckBox(tr("Use debug version of frameworks (DYLD_IMAGE_SUFFIX=_debug)"), this);
-        m_usingDyldImageSuffix->setChecked(m_qt4RunConfiguration->isUsingDyldImageSuffix());
+        m_usingDyldImageSuffix->setChecked(m_qmakeRunConfiguration->isUsingDyldImageSuffix());
         toplayout->addRow(QString(), m_usingDyldImageSuffix);
         connect(m_usingDyldImageSuffix, SIGNAL(toggled(bool)),
                 this, SLOT(usingDyldImageSuffixToggled(bool)));
@@ -277,143 +277,143 @@ Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4Run
     connect(m_useQvfbCheck, SIGNAL(toggled(bool)),
             this, SLOT(qvfbToggled(bool)));
 
-    connect(qt4RunConfiguration, SIGNAL(baseWorkingDirectoryChanged(QString)),
+    connect(qmakeRunConfiguration, SIGNAL(baseWorkingDirectoryChanged(QString)),
             this, SLOT(workingDirectoryChanged(QString)));
 
-    connect(qt4RunConfiguration, SIGNAL(commandLineArgumentsChanged(QString)),
+    connect(qmakeRunConfiguration, SIGNAL(commandLineArgumentsChanged(QString)),
             this, SLOT(commandLineArgumentsChanged(QString)));
-    connect(qt4RunConfiguration, SIGNAL(runModeChanged(ProjectExplorer::LocalApplicationRunConfiguration::RunMode)),
+    connect(qmakeRunConfiguration, SIGNAL(runModeChanged(ProjectExplorer::LocalApplicationRunConfiguration::RunMode)),
             this, SLOT(runModeChanged(ProjectExplorer::LocalApplicationRunConfiguration::RunMode)));
-    connect(qt4RunConfiguration, SIGNAL(usingDyldImageSuffixChanged(bool)),
+    connect(qmakeRunConfiguration, SIGNAL(usingDyldImageSuffixChanged(bool)),
             this, SLOT(usingDyldImageSuffixChanged(bool)));
-    connect(qt4RunConfiguration, SIGNAL(effectiveTargetInformationChanged()),
+    connect(qmakeRunConfiguration, SIGNAL(effectiveTargetInformationChanged()),
             this, SLOT(effectiveTargetInformationChanged()), Qt::QueuedConnection);
 
-    connect(qt4RunConfiguration, SIGNAL(enabledChanged()),
+    connect(qmakeRunConfiguration, SIGNAL(enabledChanged()),
             this, SLOT(runConfigurationEnabledChange()));
 }
 
-Qt4RunConfigurationWidget::~Qt4RunConfigurationWidget()
+QmakeRunConfigurationWidget::~QmakeRunConfigurationWidget()
 {
 }
 
-void Qt4RunConfigurationWidget::environmentWasChanged()
+void QmakeRunConfigurationWidget::environmentWasChanged()
 {
     ProjectExplorer::EnvironmentAspect *aspect
-            = m_qt4RunConfiguration->extraAspect<ProjectExplorer::EnvironmentAspect>();
+            = m_qmakeRunConfiguration->extraAspect<ProjectExplorer::EnvironmentAspect>();
     QTC_ASSERT(aspect, return);
     m_workingDirectoryEdit->setEnvironment(aspect->environment());
 }
 
-void Qt4RunConfigurationWidget::runConfigurationEnabledChange()
+void QmakeRunConfigurationWidget::runConfigurationEnabledChange()
 {
-    bool enabled = m_qt4RunConfiguration->isEnabled();
+    bool enabled = m_qmakeRunConfiguration->isEnabled();
     m_disabledIcon->setVisible(!enabled);
     m_disabledReason->setVisible(!enabled);
-    m_disabledReason->setText(m_qt4RunConfiguration->disabledReason());
+    m_disabledReason->setText(m_qmakeRunConfiguration->disabledReason());
 }
 
-void Qt4RunConfigurationWidget::workDirectoryEdited()
+void QmakeRunConfigurationWidget::workDirectoryEdited()
 {
     if (m_ignoreChange)
         return;
     m_ignoreChange = true;
-    m_qt4RunConfiguration->setBaseWorkingDirectory(m_workingDirectoryEdit->rawPath());
+    m_qmakeRunConfiguration->setBaseWorkingDirectory(m_workingDirectoryEdit->rawPath());
     m_ignoreChange = false;
 }
 
-void Qt4RunConfigurationWidget::workingDirectoryReseted()
+void QmakeRunConfigurationWidget::workingDirectoryReseted()
 {
     // This emits a signal connected to workingDirectoryChanged()
     // that sets the m_workingDirectoryEdit
-    m_qt4RunConfiguration->setBaseWorkingDirectory(QString());
+    m_qmakeRunConfiguration->setBaseWorkingDirectory(QString());
 }
 
-void Qt4RunConfigurationWidget::argumentsEdited(const QString &args)
+void QmakeRunConfigurationWidget::argumentsEdited(const QString &args)
 {
     m_ignoreChange = true;
-    m_qt4RunConfiguration->setCommandLineArguments(args);
+    m_qmakeRunConfiguration->setCommandLineArguments(args);
     m_ignoreChange = false;
 }
 
-void Qt4RunConfigurationWidget::termToggled(bool on)
+void QmakeRunConfigurationWidget::termToggled(bool on)
 {
     m_ignoreChange = true;
-    m_qt4RunConfiguration->setRunMode(on ? LocalApplicationRunConfiguration::Console
+    m_qmakeRunConfiguration->setRunMode(on ? LocalApplicationRunConfiguration::Console
                                          : LocalApplicationRunConfiguration::Gui);
     m_ignoreChange = false;
 }
 
-void Qt4RunConfigurationWidget::qvfbToggled(bool on)
+void QmakeRunConfigurationWidget::qvfbToggled(bool on)
 {
     Q_UNUSED(on);
     m_ignoreChange = true;
     m_ignoreChange = false;
 }
 
-void Qt4RunConfigurationWidget::usingDyldImageSuffixToggled(bool state)
+void QmakeRunConfigurationWidget::usingDyldImageSuffixToggled(bool state)
 {
     m_ignoreChange = true;
-    m_qt4RunConfiguration->setUsingDyldImageSuffix(state);
+    m_qmakeRunConfiguration->setUsingDyldImageSuffix(state);
     m_ignoreChange = false;
 }
 
-void Qt4RunConfigurationWidget::workingDirectoryChanged(const QString &workingDirectory)
+void QmakeRunConfigurationWidget::workingDirectoryChanged(const QString &workingDirectory)
 {
     if (!m_ignoreChange)
         m_workingDirectoryEdit->setPath(workingDirectory);
 }
 
-void Qt4RunConfigurationWidget::commandLineArgumentsChanged(const QString &args)
+void QmakeRunConfigurationWidget::commandLineArgumentsChanged(const QString &args)
 {
     if (m_ignoreChange)
         return;
     m_argumentsLineEdit->setText(args);
 }
 
-void Qt4RunConfigurationWidget::runModeChanged(LocalApplicationRunConfiguration::RunMode runMode)
+void QmakeRunConfigurationWidget::runModeChanged(LocalApplicationRunConfiguration::RunMode runMode)
 {
     if (!m_ignoreChange) {
-        m_useTerminalCheck->setVisible(!m_qt4RunConfiguration->forcedGuiMode());
+        m_useTerminalCheck->setVisible(!m_qmakeRunConfiguration->forcedGuiMode());
         m_useTerminalCheck->setChecked(runMode == LocalApplicationRunConfiguration::Console);
     }
 }
 
-void Qt4RunConfigurationWidget::usingDyldImageSuffixChanged(bool state)
+void QmakeRunConfigurationWidget::usingDyldImageSuffixChanged(bool state)
 {
     if (!m_ignoreChange && m_usingDyldImageSuffix)
         m_usingDyldImageSuffix->setChecked(state);
 }
 
-void Qt4RunConfigurationWidget::effectiveTargetInformationChanged()
+void QmakeRunConfigurationWidget::effectiveTargetInformationChanged()
 {
     if (m_isShown) {
-        m_executableLineEdit->setText(QDir::toNativeSeparators(m_qt4RunConfiguration->executable()));
+        m_executableLineEdit->setText(QDir::toNativeSeparators(m_qmakeRunConfiguration->executable()));
         m_ignoreChange = true;
-        m_workingDirectoryEdit->setPath(QDir::toNativeSeparators(m_qt4RunConfiguration->baseWorkingDirectory()));
+        m_workingDirectoryEdit->setPath(QDir::toNativeSeparators(m_qmakeRunConfiguration->baseWorkingDirectory()));
         m_ignoreChange = false;
     }
 }
 
-void Qt4RunConfigurationWidget::showEvent(QShowEvent *event)
+void QmakeRunConfigurationWidget::showEvent(QShowEvent *event)
 {
     m_isShown = true;
     effectiveTargetInformationChanged();
     QWidget::showEvent(event);
 }
 
-void Qt4RunConfigurationWidget::hideEvent(QHideEvent *event)
+void QmakeRunConfigurationWidget::hideEvent(QHideEvent *event)
 {
     m_isShown = false;
     QWidget::hideEvent(event);
 }
 
-QWidget *Qt4RunConfiguration::createConfigurationWidget()
+QWidget *QmakeRunConfiguration::createConfigurationWidget()
 {
-    return new Qt4RunConfigurationWidget(this, 0);
+    return new QmakeRunConfigurationWidget(this, 0);
 }
 
-QVariantMap Qt4RunConfiguration::toMap() const
+QVariantMap QmakeRunConfiguration::toMap() const
 {
     const QDir projectDir = QDir(target()->project()->projectDirectory());
     QVariantMap map(LocalApplicationRunConfiguration::toMap());
@@ -425,7 +425,7 @@ QVariantMap Qt4RunConfiguration::toMap() const
     return map;
 }
 
-bool Qt4RunConfiguration::fromMap(const QVariantMap &map)
+bool QmakeRunConfiguration::fromMap(const QVariantMap &map)
 {
     const QDir projectDir = QDir(target()->project()->projectDirectory());
     m_commandLineArguments = map.value(QLatin1String(COMMAND_LINE_ARGUMENTS_KEY)).toString();
@@ -441,37 +441,37 @@ bool Qt4RunConfiguration::fromMap(const QVariantMap &map)
     return LocalApplicationRunConfiguration::fromMap(map);
 }
 
-QString Qt4RunConfiguration::executable() const
+QString QmakeRunConfiguration::executable() const
 {
     QmakeProject *pro = static_cast<QmakeProject *>(target()->project());
     const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(m_proFilePath);
     return extractWorkingDirAndExecutable(node).second;
 }
 
-LocalApplicationRunConfiguration::RunMode Qt4RunConfiguration::runMode() const
+LocalApplicationRunConfiguration::RunMode QmakeRunConfiguration::runMode() const
 {
     if (m_forcedGuiMode)
         return LocalApplicationRunConfiguration::Gui;
     return m_runMode;
 }
 
-bool Qt4RunConfiguration::forcedGuiMode() const
+bool QmakeRunConfiguration::forcedGuiMode() const
 {
     return m_forcedGuiMode;
 }
 
-bool Qt4RunConfiguration::isUsingDyldImageSuffix() const
+bool QmakeRunConfiguration::isUsingDyldImageSuffix() const
 {
     return m_isUsingDyldImageSuffix;
 }
 
-void Qt4RunConfiguration::setUsingDyldImageSuffix(bool state)
+void QmakeRunConfiguration::setUsingDyldImageSuffix(bool state)
 {
     m_isUsingDyldImageSuffix = state;
     emit usingDyldImageSuffixChanged(state);
 }
 
-QString Qt4RunConfiguration::workingDirectory() const
+QString QmakeRunConfiguration::workingDirectory() const
 {
     ProjectExplorer::EnvironmentAspect *aspect
             = extraAspect<ProjectExplorer::EnvironmentAspect>();
@@ -480,7 +480,7 @@ QString Qt4RunConfiguration::workingDirectory() const
                 Utils::expandMacros(baseWorkingDirectory(), macroExpander())));
 }
 
-QString Qt4RunConfiguration::baseWorkingDirectory() const
+QString QmakeRunConfiguration::baseWorkingDirectory() const
 {
     // if the user overrode us, then return his working directory
     if (!m_userWorkingDirectory.isEmpty())
@@ -492,17 +492,17 @@ QString Qt4RunConfiguration::baseWorkingDirectory() const
     return extractWorkingDirAndExecutable(node).first;
 }
 
-QString Qt4RunConfiguration::commandLineArguments() const
+QString QmakeRunConfiguration::commandLineArguments() const
 {
     return Utils::QtcProcess::expandMacros(m_commandLineArguments, macroExpander());
 }
 
-QString Qt4RunConfiguration::rawCommandLineArguments() const
+QString QmakeRunConfiguration::rawCommandLineArguments() const
 {
     return m_commandLineArguments;
 }
 
-void Qt4RunConfiguration::setBaseWorkingDirectory(const QString &wd)
+void QmakeRunConfiguration::setBaseWorkingDirectory(const QString &wd)
 {
     const QString &oldWorkingDirectory = workingDirectory();
 
@@ -513,19 +513,19 @@ void Qt4RunConfiguration::setBaseWorkingDirectory(const QString &wd)
         emit baseWorkingDirectoryChanged(newWorkingDirectory);
 }
 
-void Qt4RunConfiguration::setCommandLineArguments(const QString &argumentsString)
+void QmakeRunConfiguration::setCommandLineArguments(const QString &argumentsString)
 {
     m_commandLineArguments = argumentsString;
     emit commandLineArgumentsChanged(argumentsString);
 }
 
-void Qt4RunConfiguration::setRunMode(RunMode runMode)
+void QmakeRunConfiguration::setRunMode(RunMode runMode)
 {
     m_runMode = runMode;
     emit runModeChanged(runMode);
 }
 
-void Qt4RunConfiguration::addToBaseEnvironment(Utils::Environment &env) const
+void QmakeRunConfiguration::addToBaseEnvironment(Utils::Environment &env) const
 {
     if (m_isUsingDyldImageSuffix)
         env.set(QLatin1String("DYLD_IMAGE_SUFFIX"), QLatin1String("_debug"));
@@ -553,22 +553,22 @@ void Qt4RunConfiguration::addToBaseEnvironment(Utils::Environment &env) const
         env.prependOrSetLibrarySearchPath(qtVersion->qmakeProperty("QT_INSTALL_LIBS"));
 }
 
-QString Qt4RunConfiguration::proFilePath() const
+QString QmakeRunConfiguration::proFilePath() const
 {
     return m_proFilePath;
 }
 
-QString Qt4RunConfiguration::dumperLibrary() const
+QString QmakeRunConfiguration::dumperLibrary() const
 {
     return QtSupport::QtKitInformation::dumperLibrary(target()->kit());
 }
 
-QStringList Qt4RunConfiguration::dumperLibraryLocations() const
+QStringList QmakeRunConfiguration::dumperLibraryLocations() const
 {
     return QtSupport::QtKitInformation::dumperLibraryLocations(target()->kit());
 }
 
-QString Qt4RunConfiguration::defaultDisplayName()
+QString QmakeRunConfiguration::defaultDisplayName()
 {
     QString defaultName;
     if (!m_proFilePath.isEmpty())
@@ -578,12 +578,12 @@ QString Qt4RunConfiguration::defaultDisplayName()
     return defaultName;
 }
 
-Utils::OutputFormatter *Qt4RunConfiguration::createOutputFormatter() const
+Utils::OutputFormatter *QmakeRunConfiguration::createOutputFormatter() const
 {
     return new QtSupport::QtOutputFormatter(target()->project());
 }
 
-QPair<QString, QString> Qt4RunConfiguration::extractWorkingDirAndExecutable(const QmakeProFileNode *node) const
+QPair<QString, QString> QmakeRunConfiguration::extractWorkingDirAndExecutable(const QmakeProFileNode *node) const
 {
     if (!node)
         return qMakePair(QString(), QString());
@@ -648,7 +648,7 @@ bool Qt4RunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, cons
 
 ProjectExplorer::RunConfiguration *Qt4RunConfigurationFactory::doCreate(ProjectExplorer::Target *parent, const Core::Id id)
 {
-    Qt4RunConfiguration *rc = new Qt4RunConfiguration(parent, id);
+    QmakeRunConfiguration *rc = new QmakeRunConfiguration(parent, id);
     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"))
@@ -668,7 +668,7 @@ bool Qt4RunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, con
 ProjectExplorer::RunConfiguration *Qt4RunConfigurationFactory::doRestore(ProjectExplorer::Target *parent,
                                                                          const QVariantMap &map)
 {
-    return new Qt4RunConfiguration(parent, ProjectExplorer::idFromMap(map));
+    return new QmakeRunConfiguration(parent, ProjectExplorer::idFromMap(map));
 }
 
 bool Qt4RunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const
@@ -680,8 +680,8 @@ ProjectExplorer::RunConfiguration *Qt4RunConfigurationFactory::clone(ProjectExpl
 {
     if (!canClone(parent, source))
         return 0;
-    Qt4RunConfiguration *old = static_cast<Qt4RunConfiguration *>(source);
-    return new Qt4RunConfiguration(parent, old);
+    QmakeRunConfiguration *old = static_cast<QmakeRunConfiguration *>(source);
+    return new QmakeRunConfiguration(parent, old);
 }
 
 QList<Core::Id> Qt4RunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent) const
@@ -716,7 +716,7 @@ QList<ProjectExplorer::RunConfiguration *> Qt4RunConfigurationFactory::runConfig
 {
     QList<ProjectExplorer::RunConfiguration *> result;
     foreach (ProjectExplorer::RunConfiguration *rc, t->runConfigurations())
-        if (Qt4RunConfiguration *qt4c = qobject_cast<Qt4RunConfiguration *>(rc))
+        if (QmakeRunConfiguration *qt4c = qobject_cast<QmakeRunConfiguration *>(rc))
             if (qt4c->proFilePath() == n->path())
                 result << rc;
     return result;
diff --git a/src/plugins/qt4projectmanager/qmakerunconfiguration.h b/src/plugins/qt4projectmanager/qmakerunconfiguration.h
index ba1a3cfa13..145194da3c 100644
--- a/src/plugins/qt4projectmanager/qmakerunconfiguration.h
+++ b/src/plugins/qt4projectmanager/qmakerunconfiguration.h
@@ -27,8 +27,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT4RUNCONFIGURATION_H
-#define QT4RUNCONFIGURATION_H
+#ifndef QMAKERUNCONFIGURATION_H
+#define QMAKERUNCONFIGURATION_H
 
 #include <qt4projectmanager/qmakerunconfigurationfactory.h>
 
@@ -61,16 +61,16 @@ class TargetInformation;
 namespace Internal {
 class Qt4RunConfigurationFactory;
 
-class Qt4RunConfiguration : public ProjectExplorer::LocalApplicationRunConfiguration
+class QmakeRunConfiguration : public ProjectExplorer::LocalApplicationRunConfiguration
 {
     Q_OBJECT
     // to change the display name and arguments and set the userenvironmentchanges
-    friend class Qt4RunConfigurationWidget;
+    friend class QmakeRunConfigurationWidget;
     friend class Qt4RunConfigurationFactory;
 
 public:
-    Qt4RunConfiguration(ProjectExplorer::Target *parent, Core::Id id);
-    virtual ~Qt4RunConfiguration();
+    QmakeRunConfiguration(ProjectExplorer::Target *parent, Core::Id id);
+    virtual ~QmakeRunConfiguration();
 
     virtual bool isEnabled() const;
     virtual QString disabledReason() const;
@@ -111,7 +111,7 @@ private slots:
     void proFileUpdated(QmakeProjectManager::QmakeProFileNode *pro, bool success, bool parseInProgress);
 
 protected:
-    Qt4RunConfiguration(ProjectExplorer::Target *parent, Qt4RunConfiguration *source);
+    QmakeRunConfiguration(ProjectExplorer::Target *parent, QmakeRunConfiguration *source);
     virtual bool fromMap(const QVariantMap &map);
 
 private:
@@ -138,13 +138,13 @@ private:
     bool m_parseInProgress;
 };
 
-class Qt4RunConfigurationWidget : public QWidget
+class QmakeRunConfigurationWidget : public QWidget
 {
     Q_OBJECT
 
 public:
-    Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4runconfigration, QWidget *parent);
-    ~Qt4RunConfigurationWidget();
+    QmakeRunConfigurationWidget(QmakeRunConfiguration *qmakeRunConfiguration, QWidget *parent);
+    ~QmakeRunConfigurationWidget();
 
 protected:
     void showEvent(QShowEvent *event);
@@ -168,7 +168,7 @@ private slots:
     void usingDyldImageSuffixChanged(bool);
 
 private:
-    Qt4RunConfiguration *m_qt4RunConfiguration;
+    QmakeRunConfiguration *m_qmakeRunConfiguration;
     bool m_ignoreChange;
     QLabel *m_disabledIcon;
     QLabel *m_disabledReason;
@@ -213,4 +213,4 @@ private:
 } // namespace Internal
 } // namespace QmakeProjectManager
 
-#endif // QT4RUNCONFIGURATION_H
+#endif // QMAKERUNCONFIGURATION_H
diff --git a/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp b/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
index d22369cf0f..fb8455d8c0 100644
--- a/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
@@ -212,8 +212,8 @@ bool AbstractMobileAppWizard::postGenerateFiles(const QWizard *w,
     Q_UNUSED(w)
     Q_UNUSED(l)
     Q_UNUSED(errorMessage)
-    Qt4Manager * const manager
-        = ExtensionSystem::PluginManager::getObject<Qt4Manager>();
+    QmakeManager * const manager
+        = ExtensionSystem::PluginManager::getObject<QmakeManager>();
     Q_ASSERT(manager);
     QmakeProject project(manager, app()->path(AbstractMobileApp::AppPro));
     bool success = true;
diff --git a/src/plugins/qt4projectmanager/wizards/qtwizard.cpp b/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
index bbd483bf68..af0f048e2d 100644
--- a/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
@@ -272,7 +272,7 @@ bool BaseQt4ProjectWizardDialog::writeUserFile(const QString &proFileName) const
     if (!m_targetSetupPage)
         return false;
 
-    Qt4Manager *manager = ExtensionSystem::PluginManager::getObject<Qt4Manager>();
+    QmakeManager *manager = ExtensionSystem::PluginManager::getObject<QmakeManager>();
     Q_ASSERT(manager);
 
     QmakeProject *pro = new QmakeProject(manager, proFileName);