IRunConfiguration: Remove BuildTargetInfo from the RC factory APIs

Change-Id: I1d77d22a1c1ce1cbcfca8af7855ae7b935ac1c2c
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
Reviewed-by: hjk <hjk@qt.io>

src/plugins/baremetal/baremetalrunconfigurationfactory.cpp

@@ -48,27 +48,24 @@ BareMetalRunConfigurationFactory::BareMetalRunConfigurationFactory(QObject *pare
     setSupportedTargetDeviceTypes({BareMetal::Constants::BareMetalOsType});
 }
 
-QList<BuildTargetInfo>
+QList<RunConfigurationCreationInfo> BareMetalRunConfigurationFactory::availableCreators(Target *parent, IRunConfigurationFactory::CreationMode mode) const
-    BareMetalRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
 {
-    return Utils::transform(parent->applicationTargets().list, [](BuildTargetInfo bti) {
+    Q_UNUSED(mode);
-        bti.displayName = tr("%1 (on GDB server or hardware debugger)")
+    return Utils::transform(parent->applicationTargets().list, [this](const BuildTargetInfo &bti) {
-                                .arg(QFileInfo(bti.targetName).fileName());
+        return convert(tr("%1 (on GDB server or hardware debugger)").arg(QFileInfo(bti.targetName).fileName()),
-        bti.targetName = bti.projectFilePath.toString() + '/' + bti.targetName;
+                       bti.projectFilePath.toString() + '/' + bti.targetName);
-        return bti;
     });
 }
 
 // BareMetalCustomRunConfigurationFactory
 
 BareMetalCustomRunConfigurationFactory::BareMetalCustomRunConfigurationFactory(QObject *parent) :
-    IRunConfigurationFactory(parent)
+    FixedRunConfigurationFactory(BareMetalCustomRunConfiguration::tr("Custom Executable (on GDB server or hardware debugger)"),
+                                 parent)
 {
     setObjectName("BareMetalCustomRunConfigurationFactory");
     registerRunConfiguration<BareMetalCustomRunConfiguration>("BareMetal.CustomRunConfig");
     setSupportedTargetDeviceTypes({BareMetal::Constants::BareMetalOsType});
-    addFixedBuildTarget(BareMetalCustomRunConfiguration::tr
-                        ("Custom Executable (on GDB server or hardware debugger)"));
 }
 
 } // namespace Internal

src/plugins/baremetal/baremetalrunconfigurationfactory.h

@@ -35,18 +35,18 @@ class BareMetalRunConfigurationFactory : public ProjectExplorer::IRunConfigurati
     Q_OBJECT
 
 public:
-    explicit BareMetalRunConfigurationFactory(QObject *parent = 0);
+    explicit BareMetalRunConfigurationFactory(QObject *parent = nullptr);
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
 };
 
-class BareMetalCustomRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
+class BareMetalCustomRunConfigurationFactory : public ProjectExplorer::FixedRunConfigurationFactory
 {
     Q_OBJECT
 
 public:
-    explicit BareMetalCustomRunConfigurationFactory(QObject *parent = 0);
+    explicit BareMetalCustomRunConfigurationFactory(QObject *parent = nullptr);
 };
 
 } // namespace Internal

src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp

@@ -241,17 +241,11 @@ CMakeRunConfigurationFactory::CMakeRunConfigurationFactory(QObject *parent) :
     addSupportedProjectType(CMakeProjectManager::Constants::CMAKEPROJECT_ID);
 }
 
-QList<BuildTargetInfo>
+QList<RunConfigurationCreationInfo> CMakeRunConfigurationFactory::availableCreators(Target *parent, IRunConfigurationFactory::CreationMode mode) const
-    CMakeRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
 {
     CMakeProject *project = static_cast<CMakeProject *>(parent->project());
     const QStringList titles = project->buildTargetTitles(true);
-    return Utils::transform(titles, [](const QString &title) {
+    return Utils::transform(titles, [this](const QString &title) { return convert(title, title); });
-        BuildTargetInfo bti;
-        bti.targetName = title;
-        bti.displayName = title;
-        return bti;
-    });
 }
 
 bool CMakeRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const

src/plugins/cmakeprojectmanager/cmakerunconfiguration.h

@@ -83,8 +83,8 @@ class CMakeRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFa
 public:
     explicit CMakeRunConfigurationFactory(QObject *parent = 0);
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
     bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };
 

src/plugins/ios/iosrunfactories.cpp

@@ -51,22 +51,25 @@ IosRunConfigurationFactory::IosRunConfigurationFactory(QObject *parent)
     addSupportedProjectType(QmakeProjectManager::Constants::QMAKEPROJECT_ID);
 }
 
+QList<RunConfigurationCreationInfo>
+IosRunConfigurationFactory::availableCreators(Target *parent, CreationMode mode) const
+{
+    auto project = static_cast<QmakeProject *>(parent->project());
+    return Utils::transform(project->buildTargets(mode, {ProjectType::ApplicationTemplate,
+                                                         ProjectType::SharedLibraryTemplate}),
+                            [this](const BuildTargetInfo &ti) { return convert(ti); });
+}
+
 bool IosRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    const QList<BuildTargetInfo> buildTargets = availableBuildTargets(parent, UserCreate);
+    auto project = static_cast<QmakeProject *>(parent->project());
+    const QList<BuildTargetInfo> buildTargets = project->buildTargets(UserCreate, {ProjectType::ApplicationTemplate,
+                                                                                   ProjectType::SharedLibraryTemplate});
     return Utils::contains(buildTargets, [buildTarget](const BuildTargetInfo &bti) {
         return bti.targetName == buildTarget;
     });
 }
 
-QList<BuildTargetInfo>
-    IosRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
-{
-    auto project = static_cast<QmakeProject *>(parent->project());
-    return project->buildTargets(mode, {ProjectType::ApplicationTemplate,
-                                        ProjectType::SharedLibraryTemplate});
-}
-
 bool IosRunConfigurationFactory::hasRunConfigForProFile(RunConfiguration *rc, const Utils::FileName &n) const
 {
     auto iosRc = qobject_cast<IosRunConfiguration *>(rc);

src/plugins/ios/iosrunfactories.h

@@ -43,8 +43,8 @@ class IosRunConfigurationFactory : public QmakeProjectManager::QmakeRunConfigura
 public:
     explicit IosRunConfigurationFactory(QObject *parent = 0);
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
 
     bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 

src/plugins/nim/project/nimrunconfiguration.cpp

@@ -132,11 +132,10 @@ void NimRunConfiguration::setActiveBuildConfiguration(NimBuildConfiguration *act
 
 // NimRunConfigurationFactory
 
-NimRunConfigurationFactory::NimRunConfigurationFactory()
+NimRunConfigurationFactory::NimRunConfigurationFactory() : FixedRunConfigurationFactory("-TempRunConf")
 {
     registerRunConfiguration<NimRunConfiguration>(Constants::C_NIMRUNCONFIGURATION_ID);
     addSupportedProjectType(Constants::C_NIMPROJECT_ID);
-    addFixedBuildTarget("-TempRunConf");
 }
 
 }

src/plugins/nim/project/nimrunconfiguration.h

@@ -62,7 +62,7 @@ private:
     ProjectExplorer::LocalEnvironmentAspect* m_localEnvironmentAspect;
 };
 
-class NimRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
+class NimRunConfigurationFactory : public ProjectExplorer::FixedRunConfigurationFactory
 {
 public:
     NimRunConfigurationFactory();

src/plugins/projectexplorer/customexecutablerunconfiguration.cpp

@@ -302,11 +302,10 @@ Abi CustomExecutableRunConfiguration::abi() const
 // Factory
 
 CustomExecutableRunConfigurationFactory::CustomExecutableRunConfigurationFactory(QObject *parent) :
-    IRunConfigurationFactory(parent)
+    FixedRunConfigurationFactory(tr("Custom Executable"), parent)
 {
     setObjectName("CustomExecutableRunConfigurationFactory");
     registerRunConfiguration<CustomExecutableRunConfiguration>(CUSTOM_EXECUTABLE_ID);
-    addFixedBuildTarget(tr("Custom Executable"));
 }
 
 } // namespace ProjectExplorer

src/plugins/projectexplorer/customexecutablerunconfiguration.h

@@ -84,12 +84,12 @@ private:
     CustomExecutableDialog *m_dialog = nullptr;
 };
 
-class CustomExecutableRunConfigurationFactory : public IRunConfigurationFactory
+class CustomExecutableRunConfigurationFactory : public FixedRunConfigurationFactory
 {
     Q_OBJECT
 
 public:
-    explicit CustomExecutableRunConfigurationFactory(QObject *parent = 0);
+    explicit CustomExecutableRunConfigurationFactory(QObject *parent = nullptr);
 };
 
 } // namespace ProjectExplorer

src/plugins/projectexplorer/runconfiguration.cpp

@@ -449,40 +449,13 @@ const QList<IRunConfigurationFactory *> IRunConfigurationFactory::allRunConfigur
 }
 
 QList<RunConfigurationCreationInfo>
-    IRunConfigurationFactory::availableCreators(Target *parent, CreationMode mode) const
+IRunConfigurationFactory::availableCreators(Target *parent, IRunConfigurationFactory::CreationMode mode) const
 {
-    if (!canHandle(parent))
+    Q_UNUSED(mode);
-        return {};
+    return Utils::transform(parent->applicationTargets().list, [this](const BuildTargetInfo &ti) {
-
+        return RunConfigurationCreationInfo(this, m_runConfigBaseId, ti.targetName, ti.displayName);
-    QList<RunConfigurationCreationInfo> result;
+    });
-
-    const QList<BuildTargetInfo> buildTargets = m_fixedBuildTargets.isEmpty()
-            ? availableBuildTargets(parent, mode)
-            : m_fixedBuildTargets;
-
-    for (const BuildTargetInfo &bt : buildTargets) {
-        QString displayName = bt.displayName;
-        if (displayName.isEmpty())
-            displayName = QFileInfo(bt.targetName).completeBaseName();
-        if (displayName.isEmpty())
-            displayName = bt.targetName;
-        if (!m_displayNamePattern.isEmpty()) {
-            displayName = m_displayNamePattern.contains("%1")
-                ? m_displayNamePattern.arg(bt.targetName)
-                : m_displayNamePattern;
 }
-        RunConfigurationCreationInfo rci(this, m_runConfigBaseId, bt.targetName, displayName);
-        result.append(rci);
-    }
-
-    return result;
-}
-
-QList<BuildTargetInfo> IRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
-{
-    return parent->applicationTargets().list;
-}
-
 
 /*!
     Specifies a list of device types for which this RunConfigurationFactory
@@ -500,29 +473,16 @@ void IRunConfigurationFactory::addSupportedProjectType(Core::Id id)
     m_supportedProjectTypes.append(id);
 }
 
-void IRunConfigurationFactory::addFixedBuildTarget(const QString &displayName)
+RunConfigurationCreationInfo
+IRunConfigurationFactory::convert(const BuildTargetInfo &ti) const
 {
-    BuildTargetInfo bt;
+    return convert(ti.displayName, ti.targetName);
-    bt.displayName = displayName;
-    m_fixedBuildTargets.append(bt);
 }
 
-/*!
+RunConfigurationCreationInfo
-    \internal
+IRunConfigurationFactory::convert(const QString &displayName, const QString &targetName) const
-
-    Convenience function to specify a pattern for the name that is displayed for this
-    RunConfiguration.
-
-    A fixed string is used as-is, a "%1" is replaced by the BuildTargetInfo's targetName.
-
-    This simplistic patterns covers all currently existing uses, if anything more
-    complex is required, the display name can be set directly when creating the
-    BuildTargetInfo objects as part of the RunConfiguration's availableBuildTarget()
-    implementation.
-*/
-void IRunConfigurationFactory::setDisplayNamePattern(const QString &pattern)
 {
-    m_displayNamePattern = pattern;
+    return RunConfigurationCreationInfo(this, runConfigurationBaseId(), targetName, displayName);
 }
 
 bool IRunConfigurationFactory::canHandle(Target *target) const
@@ -639,10 +599,25 @@ QList<IRunConfigurationFactory *> IRunConfigurationFactory::find(Target *parent)
 {
     return Utils::filtered(g_runConfigurationFactories,
         [&parent](IRunConfigurationFactory *factory) {
-            return !factory->availableCreators(parent).isEmpty();
+            return factory->canHandle(parent) && !factory->availableCreators(parent).isEmpty();
         });
 }
 
+FixedRunConfigurationFactory::FixedRunConfigurationFactory(const QString &displayName,
+                                                           QObject *parent) :
+    IRunConfigurationFactory(parent), m_fixedBuildTarget(displayName)
+{ }
+
+QList<RunConfigurationCreationInfo>
+FixedRunConfigurationFactory::availableCreators(Target *parent, CreationMode mode) const
+{
+    Q_UNUSED(mode);
+    if (!canHandle(parent))
+        return {};
+
+    return {RunConfigurationCreationInfo(this, runConfigurationBaseId(), QString(), m_fixedBuildTarget)};
+}
+
 using WorkerFactories = std::vector<RunControl::WorkerFactory>;
 
 static WorkerFactories &theWorkerFactories()

src/plugins/projectexplorer/runconfiguration.h

@@ -302,7 +302,7 @@ public:
 
     enum CreationMode {UserCreate, AutoCreate};
 
-    QList<RunConfigurationCreationInfo> availableCreators(Target *parent,
+    virtual QList<RunConfigurationCreationInfo> availableCreators(Target *parent,
                                                                   CreationMode mode = UserCreate) const;
 
     virtual bool canHandle(Target *target) const;
@@ -318,8 +318,6 @@ public:
     static QList<IRunConfigurationFactory *> find(Target *parent);
 
 protected:
-    virtual QList<BuildTargetInfo> availableBuildTargets(Target *parent, CreationMode mode = UserCreate) const;
-
     virtual bool canCreateHelper(Target *parent, const QString &buildTarget) const;
 
     using RunConfigurationCreator = std::function<RunConfiguration *(Target *)>;
@@ -333,16 +331,32 @@ protected:
 
     void addSupportedProjectType(Core::Id id);
     void setSupportedTargetDeviceTypes(const QList<Core::Id> &ids);
-    void addFixedBuildTarget(const QString &displayName);
     void setDisplayNamePattern(const QString &pattern);
 
+    Core::Id runConfigurationBaseId() const { return m_runConfigBaseId; }
+
+    RunConfigurationCreationInfo convert(const BuildTargetInfo &ti) const;
+    RunConfigurationCreationInfo convert(const QString &displayName, const QString &targetName = QString()) const;
+
 private:
     RunConfigurationCreator m_creator;
     Core::Id m_runConfigBaseId;
     QList<Core::Id> m_supportedProjectTypes;
     QList<Core::Id> m_supportedTargetDeviceTypes;
-    QList<BuildTargetInfo> m_fixedBuildTargets;
+};
-    QString m_displayNamePattern;
+
+class PROJECTEXPLORER_EXPORT FixedRunConfigurationFactory : public IRunConfigurationFactory
+{
+    Q_OBJECT
+
+public:
+    explicit FixedRunConfigurationFactory(const QString &displayName, QObject *parent = nullptr);
+
+    QList<RunConfigurationCreationInfo> availableCreators(Target *parent,
+                                                          CreationMode mode = UserCreate) const override;
+
+private:
+    const QString m_fixedBuildTarget;
 };
 
 class PROJECTEXPLORER_EXPORT RunConfigWidget : public QWidget

src/plugins/pythoneditor/pythoneditorplugin.cpp

@@ -271,13 +271,12 @@ public:
         addSupportedProjectType(PythonProjectId);
     }
 
-    QList<BuildTargetInfo> availableBuildTargets(Target *parent, CreationMode mode) const override
+    QList<RunConfigurationCreationInfo> availableCreators(Target *parent,
+                                                          CreationMode mode) const override
     {
         Q_UNUSED(mode);
-        return Utils::transform(parent->project()->files(Project::AllFiles), [](const FileName &fn) {
+        return Utils::transform(parent->project()->files(Project::AllFiles),[this](const FileName &fn) {
-            BuildTargetInfo bti;
+            return convert(fn.toString(), fn.toString());
-            bti.targetName = fn.toString();
-            return bti;
         });
     }
 

src/plugins/qbsprojectmanager/qbsrunconfiguration.cpp

@@ -384,7 +384,8 @@ bool QbsRunConfigurationFactory::canCreateHelper(Target *parent, const QString &
     return findProduct(project->qbsProjectData(), product).isValid();
 }
 
-QList<BuildTargetInfo> QbsRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
+QList<RunConfigurationCreationInfo>
+QbsRunConfigurationFactory::availableCreators(Target *parent, CreationMode mode) const
 {
     QList<qbs::ProductData> products;
 
@@ -406,12 +407,10 @@ QList<BuildTargetInfo> QbsRunConfigurationFactory::availableBuildTargets(Target
             Utils::erase(products, std::not1(hasQtcRunnable));
     }
 
-    return Utils::transform(products, [project](const qbs::ProductData &product) {
+    return Utils::transform(products, [this, project](const qbs::ProductData &product) {
-        QString displayName = QbsProject::productDisplayName(project->qbsProject(), product);
+        const QString displayName = QbsProject::productDisplayName(project->qbsProject(), product);
-        BuildTargetInfo bti;
+        const QString targetName = QbsProject::uniqueProductName(product) + rcNameSeparator() + displayName;
-        bti.targetName = QbsProject::uniqueProductName(product) + rcNameSeparator() + displayName;
+        return convert(displayName, targetName);
-        bti.displayName = displayName;
-        return bti;
     });
 }
 

src/plugins/qbsprojectmanager/qbsrunconfiguration.h

@@ -118,8 +118,8 @@ public:
 
     bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
 };
 
 } // namespace Internal

src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.cpp

@@ -56,11 +56,12 @@ QmakeAndroidRunConfigurationFactory::QmakeAndroidRunConfigurationFactory(QObject
     setSupportedTargetDeviceTypes({Android::Constants::ANDROID_DEVICE_TYPE});
 }
 
-QList<BuildTargetInfo>
+QList<RunConfigurationCreationInfo> QmakeAndroidRunConfigurationFactory::availableCreators(Target *parent, IRunConfigurationFactory::CreationMode mode) const
-    QmakeAndroidRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
     auto project = static_cast<QmakeProject *>(parent->project());
-    return project->buildTargets(mode, {ProjectType::ApplicationTemplate, ProjectType::SharedLibraryTemplate});
+    return Utils::transform(project->buildTargets(mode, {ProjectType::ApplicationTemplate, ProjectType::SharedLibraryTemplate}),
+                            [this](const BuildTargetInfo &ti) { return convert(ti); });
+
 }
 
 } // namespace Internal

src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.h

@@ -39,8 +39,8 @@ class QmakeAndroidRunConfigurationFactory : public ProjectExplorer::IRunConfigur
 public:
     explicit QmakeAndroidRunConfigurationFactory(QObject *parent = nullptr);
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const;
 };
 
 } // namespace Internal

src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.cpp

@@ -443,11 +443,11 @@ bool DesktopQmakeRunConfigurationFactory::canCreateHelper(Target *parent, const
     return project->hasApplicationProFile(Utils::FileName::fromString(buildTarget));
 }
 
-QList<BuildTargetInfo>
+QList<RunConfigurationCreationInfo>
-    DesktopQmakeRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
+DesktopQmakeRunConfigurationFactory::availableCreators(Target *parent, CreationMode mode) const
 {
     QmakeProject *project = static_cast<QmakeProject *>(parent->project());
-    return project->buildTargets(mode);
+    return Utils::transform(project->buildTargets(mode), [this](const BuildTargetInfo &ti) { return convert(ti); });
 }
 
 bool DesktopQmakeRunConfigurationFactory::hasRunConfigForProFile(RunConfiguration *rc, const Utils::FileName &n) const

src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.h

@@ -140,8 +140,8 @@ public:
 
     bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
 
     bool hasRunConfigForProFile(ProjectExplorer::RunConfiguration *rc, const Utils::FileName &n) const override;
 };

src/plugins/qmakeprojectmanager/qmakerunconfigurationfactory.h

@@ -38,7 +38,7 @@ class QMAKEPROJECTMANAGER_EXPORT QmakeRunConfigurationFactory : public ProjectEx
     Q_OBJECT
 
 public:
-    explicit QmakeRunConfigurationFactory(QObject *parent = 0);
+    explicit QmakeRunConfigurationFactory(QObject *parent = nullptr);
 
     virtual bool hasRunConfigForProFile(ProjectExplorer::RunConfiguration *rc, const Utils::FileName &n) const = 0;
 };

src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.cpp

@@ -32,12 +32,12 @@ namespace QmlProjectManager {
 namespace Internal {
 
 QmlProjectRunConfigurationFactory::QmlProjectRunConfigurationFactory(QObject *parent) :
-    ProjectExplorer::IRunConfigurationFactory(parent)
+    ProjectExplorer::FixedRunConfigurationFactory(tr("QML Scene"), parent)
 {
     setObjectName("QmlProjectRunConfigurationFactory");
     registerRunConfiguration<QmlProjectRunConfiguration>(Constants::QML_SCENE_RC_ID);
     addSupportedProjectType(QmlProjectManager::Constants::QML_PROJECT_ID);
-    addFixedBuildTarget(tr("QML Scene"));
+    setSupportedTargetDeviceTypes({ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE});
 }
 
 } // namespace Internal

src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.h

@@ -30,12 +30,12 @@
 namespace QmlProjectManager {
 namespace Internal {
 
-class QmlProjectRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
+class QmlProjectRunConfigurationFactory : public ProjectExplorer::FixedRunConfigurationFactory
 {
     Q_OBJECT
 
 public:
-    explicit QmlProjectRunConfigurationFactory(QObject *parent = 0);
+    explicit QmlProjectRunConfigurationFactory(QObject *parent = nullptr);
 };
 
 } // namespace Internal

src/plugins/qnx/qnxrunconfigurationfactory.cpp

@@ -45,14 +45,11 @@ QnxRunConfigurationFactory::QnxRunConfigurationFactory(QObject *parent) :
     setSupportedTargetDeviceTypes({Constants::QNX_QNX_OS_TYPE});
 }
 
-QList<ProjectExplorer::BuildTargetInfo>
+QList<RunConfigurationCreationInfo> QnxRunConfigurationFactory::availableCreators(Target *parent, IRunConfigurationFactory::CreationMode mode) const
-   QnxRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
     auto project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
-    const QList<BuildTargetInfo> buildTargets = project->buildTargets(mode);
+    return Utils::transform(project->buildTargets(mode), [this](const BuildTargetInfo &bti) {
-    return Utils::transform(buildTargets, [](BuildTargetInfo bti) {
+        return convert(tr("%1 on QNX Device").arg(QFileInfo(bti.targetName).completeBaseName()));
-        bti.displayName = tr("%1 on QNX Device").arg(QFileInfo(bti.targetName).completeBaseName());
-        return bti;
     });
 }
 

src/plugins/qnx/qnxrunconfigurationfactory.h

@@ -36,10 +36,10 @@ class QnxRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
 {
     Q_OBJECT
 public:
-    explicit QnxRunConfigurationFactory(QObject *parent = 0);
+    explicit QnxRunConfigurationFactory(QObject *parent = nullptr);
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
 
     bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };

src/plugins/remotelinux/remotelinuxrunconfigurationfactory.cpp

@@ -46,7 +46,6 @@ RemoteLinuxRunConfigurationFactory::RemoteLinuxRunConfigurationFactory(QObject *
     setObjectName("RemoteLinuxRunConfigurationFactory");
     registerRunConfiguration<RemoteLinuxRunConfiguration>(RemoteLinuxRunConfiguration::IdPrefix);
     setSupportedTargetDeviceTypes({RemoteLinux::Constants::GenericLinuxOsType});
-    setDisplayNamePattern(tr("%1 (on Remote Generic Linux Host)"));
 }
 
 bool RemoteLinuxRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
@@ -54,16 +53,25 @@ bool RemoteLinuxRunConfigurationFactory::canCreateHelper(Target *parent, const Q
     return parent->applicationTargets().hasTarget(buildTarget);
 }
 
+QList<RunConfigurationCreationInfo>
+    RemoteLinuxRunConfigurationFactory::availableCreators(Target *parent, CreationMode mode) const
+{
+    Q_UNUSED(mode);
+    return Utils::transform(parent->applicationTargets().list, [this](const BuildTargetInfo &bti) {
+        return convert(tr("%1 (on Remote Generic Linux Host)").arg(bti.displayName), bti.targetName);
+     });
+ }
+
+
 // RemoteLinuxCustomRunConfigurationFactory
 
 RemoteLinuxCustomRunConfigurationFactory::RemoteLinuxCustomRunConfigurationFactory(QObject *parent)
-    : IRunConfigurationFactory(parent)
+    : FixedRunConfigurationFactory(RemoteLinuxCustomRunConfiguration::runConfigDefaultDisplayName(), parent)
 {
     setObjectName("RemoteLinuxCustomRunConfiguration");
     registerRunConfiguration<RemoteLinuxCustomRunConfiguration>
             (RemoteLinuxCustomRunConfiguration::runConfigId());
     setSupportedTargetDeviceTypes({RemoteLinux::Constants::GenericLinuxOsType});
-    addFixedBuildTarget(RemoteLinuxCustomRunConfiguration::runConfigDefaultDisplayName());
 }
 
 } // namespace Internal

src/plugins/remotelinux/remotelinuxrunconfigurationfactory.h

@@ -35,17 +35,19 @@ class RemoteLinuxRunConfigurationFactory : public ProjectExplorer::IRunConfigura
     Q_OBJECT
 
 public:
-    explicit RemoteLinuxRunConfigurationFactory(QObject *parent = 0);
+    explicit RemoteLinuxRunConfigurationFactory(QObject *parent = nullptr);
 
     bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
+        availableCreators(ProjectExplorer::Target *parent, CreationMode mode) const override;
 };
 
-class RemoteLinuxCustomRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
+class RemoteLinuxCustomRunConfigurationFactory : public ProjectExplorer::FixedRunConfigurationFactory
 {
     Q_OBJECT
 
 public:
-    explicit RemoteLinuxCustomRunConfigurationFactory(QObject *parent = 0);
+    explicit RemoteLinuxCustomRunConfigurationFactory(QObject *parent = nullptr);
 };
 
 } // namespace Internal

src/plugins/winrt/winrtrunfactories.cpp

@@ -50,14 +50,12 @@ WinRtRunConfigurationFactory::WinRtRunConfigurationFactory()
                                    Constants::WINRT_DEVICE_TYPE_EMULATOR});
 }
 
-QList<BuildTargetInfo>
+QList<RunConfigurationCreationInfo> WinRtRunConfigurationFactory::availableCreators(Target *parent, IRunConfigurationFactory::CreationMode mode) const
-    WinRtRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
     QmakeProject *project = static_cast<QmakeProject *>(parent->project());
     const QList<BuildTargetInfo> buildTargets = project->buildTargets(mode);
-    return Utils::transform(buildTargets, [](BuildTargetInfo bti) {
+    return Utils::transform(project->buildTargets(mode), [this](const BuildTargetInfo &bti) {
-        bti.displayName = tr("Run App Package");
+        return convert(tr("Run App Package"), bti.targetName);
-        return bti;
     });
 }
 

src/plugins/winrt/winrtrunfactories.h

@@ -38,8 +38,8 @@ class WinRtRunConfigurationFactory  : public ProjectExplorer::IRunConfigurationF
 public:
     WinRtRunConfigurationFactory();
 
-    QList<ProjectExplorer::BuildTargetInfo>
+    QList<ProjectExplorer::RunConfigurationCreationInfo>
-        availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    availableCreators(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
 };
 
 } // namespace Internal