feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ProjectExplorer: Register createes' base id in RunConfigurationFactory

Browse Source 
This shifts the resposibility of creation/splitting of RunConfiguration
ids into what are essentially "type ids" and "build targets" to the base
implementation, possibly opening the path of abandoning the mangled ids
in favor of explicitly storing their constituent parts.

Take advantage of base id split in RunConfigurations for availableIds
/displayNameForId and for canCreate/canRestore/canClone.

Change-Id: I19fefb32757407ab5053a2ae0e5a79438659f6ec
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
Reviewed-by: Filippo Cucchetto <filippocucchetto@gmail.com>
This commit is contained in:
hjk
2017-11-20 11:56:19 +01:00
parent dbd365afe6
commit 1697f97aff
32 changed files with 243 additions and 612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
src/plugins/baremetal/baremetalrunconfigurationfactory.cpp
View File

@@ -45,48 +45,26 @@ BareMetalRunConfigurationFactory::BareMetalRunConfigurationFactory(QObject *pare
IRunConfigurationFactory(parent)
{
setObjectName("BareMetalRunConfigurationFactory");
registerRunConfiguration<BareMetalRunConfiguration>();
registerRunConfiguration<BareMetalRunConfiguration>(BareMetalRunConfiguration::IdPrefix);
setSupportedTargetDeviceTypes({BareMetal::Constants::BareMetalOsType});
}
bool BareMetalRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool BareMetalRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
const QString targetName = BareMetalRunConfiguration::targetNameFromId(id);
return !parent->applicationTargets().targetFilePath(targetName).isEmpty();
const QString targetName = QFileInfo(buildTarget).fileName();
return parent->applicationTargets().hasTarget(targetName);
}
bool BareMetalRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
QList<QString> BareMetalRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
{
if (!canHandle(parent))
return false;
return idFromMap(map).name().startsWith(BareMetalRunConfiguration::IdPrefix);
return Utils::transform(parent->applicationTargets().list, [](const BuildTargetInfo &bti) {
return QString(bti.projectFilePath.toString() + '/' + bti.targetName);
});
}
bool BareMetalRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
QString BareMetalRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
auto bmrc = qobject_cast<BareMetalRunConfiguration *>(source);
return bmrc && canCreate(parent, source->id());
}
QList<Core::Id> BareMetalRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
Q_UNUSED(mode)
QList<Core::Id> result;
if (!canHandle(parent))
return result;
const Core::Id base = Core::Id(BareMetalRunConfiguration::IdPrefix);
foreach (const BuildTargetInfo &bti, parent->applicationTargets().list)
result << base.withSuffix(bti.projectFilePath.toString() + QLatin1Char('/') + bti.targetName);
return result;
}
QString BareMetalRunConfigurationFactory::displayNameForId(Core::Id id) const
{
return tr("%1 (on GDB server or hardware debugger)")
.arg(BareMetalRunConfiguration::targetNameFromId(id));
return tr("%1 (on GDB server or hardware debugger)").arg(QFileInfo(buildTarget).fileName());
}
@@ -96,43 +74,17 @@ BareMetalCustomRunConfigurationFactory::BareMetalCustomRunConfigurationFactory(Q
IRunConfigurationFactory(parent)
{
setObjectName("BareMetalCustomRunConfigurationFactory");
registerRunConfiguration<BareMetalCustomRunConfiguration>();
registerRunConfiguration<BareMetalCustomRunConfiguration>
(BareMetalCustomRunConfiguration::runConfigId());
setSupportedTargetDeviceTypes({BareMetal::Constants::BareMetalOsType});
}
bool BareMetalCustomRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
QList<QString> BareMetalCustomRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
{
if (!canHandle(parent))
return false;
return id == BareMetalCustomRunConfiguration::runConfigId();
return {QString()};
}
bool BareMetalCustomRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
if (!canHandle(parent))
return false;
const Core::Id id = idFromMap(map);
return id == BareMetalCustomRunConfiguration::runConfigId();
}
bool BareMetalCustomRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
auto bmrc = qobject_cast<BareMetalCustomRunConfiguration *>(source);
return bmrc && canCreate(parent, source->id());
}
QList<Core::Id> BareMetalCustomRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
Q_UNUSED(mode)
QList<Core::Id> result;
if (!canHandle(parent))
return result;
result << BareMetalCustomRunConfiguration::runConfigId();
return result;
}
QString BareMetalCustomRunConfigurationFactory::displayNameForId(Core::Id) const
QString BareMetalCustomRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
{
return BareMetalCustomRunConfiguration::runConfigDefaultDisplayName();
}

16
src/plugins/baremetal/baremetalrunconfigurationfactory.h
View File

@@ -37,12 +37,10 @@ class BareMetalRunConfigurationFactory : public ProjectExplorer::IRunConfigurati
public:
explicit BareMetalRunConfigurationFactory(QObject *parent = 0);
QString displayNameForId(Core::Id id) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
};
class BareMetalCustomRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
@@ -52,12 +50,8 @@ class BareMetalCustomRunConfigurationFactory : public ProjectExplorer::IRunConfi
public:
explicit BareMetalCustomRunConfigurationFactory(QObject *parent = 0);
QString displayNameForId(Core::Id id) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
};
} // namespace Internal

49
src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
View File

@@ -232,57 +232,18 @@ CMakeRunConfigurationFactory::CMakeRunConfigurationFactory(QObject *parent) :
IRunConfigurationFactory(parent)
{
setObjectName("CMakeRunConfigurationFactory");
registerRunConfiguration<CMakeRunConfiguration>();
registerRunConfiguration<CMakeRunConfiguration>(CMAKE_RC_PREFIX);
setSupportedProjectType<CMakeProject>();
}
// used to show the list of possible additons to a project, returns a list of ids
QList<Core::Id> CMakeRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
QList<QString> CMakeRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
{
Q_UNUSED(mode)
if (!canHandle(parent))
return QList<Core::Id>();
CMakeProject *project = static_cast<CMakeProject *>(parent->project());
QList<Core::Id> allIds;
foreach (const QString &buildTarget, project->buildTargetTitles(true))
allIds << idFromBuildTarget(buildTarget);
return allIds;
return project->buildTargetTitles(true);
}
// used to translate the ids to names to display to the user
QString CMakeRunConfigurationFactory::displayNameForId(Core::Id id) const
bool CMakeRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
return buildTargetFromId(id);
}
bool CMakeRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
{
if (!canHandle(parent))
return false;
CMakeProject *project = static_cast<CMakeProject *>(parent->project());
return project->hasBuildTarget(buildTargetFromId(id));
}
bool CMakeRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
if (!canHandle(parent))
return false;
return source->id().name().startsWith(CMAKE_RC_PREFIX);
}
bool CMakeRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
if (!qobject_cast<CMakeProject *>(parent->project()))
return false;
return idFromMap(map).name().startsWith(CMAKE_RC_PREFIX);
}
QString CMakeRunConfigurationFactory::buildTargetFromId(Core::Id id)
{
return id.suffixAfter(CMAKE_RC_PREFIX);
}
Core::Id CMakeRunConfigurationFactory::idFromBuildTarget(const QString &target)
{
return Core::Id(CMAKE_RC_PREFIX).withSuffix(target);
return project->hasBuildTarget(buildTarget);
}

11
src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
View File

@@ -85,15 +85,8 @@ class CMakeRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFa
public:
explicit CMakeRunConfigurationFactory(QObject *parent = 0);
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
static Core::Id idFromBuildTarget(const QString &target);
static QString buildTargetFromId(Core::Id id);
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
};
} // namespace Internal

32
src/plugins/ios/iosrunfactories.cpp
View File

@@ -47,44 +47,26 @@ IosRunConfigurationFactory::IosRunConfigurationFactory(QObject *parent)
: QmakeRunConfigurationFactory(parent)
{
setObjectName("IosRunConfigurationFactory");
registerRunConfiguration<IosRunConfiguration>();
registerRunConfiguration<IosRunConfiguration>(Constants::IOS_RC_ID_PREFIX);
setSupportedProjectType<QmakeProject>();
}
bool IosRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool IosRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
return availableCreationIds(parent).contains(id);
return availableBuildTargets(parent, UserCreate).contains(buildTarget);
}
bool IosRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
QList<QString> IosRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
{
if (!canHandle(parent))
return false;
QString id = ProjectExplorer::idFromMap(map).toString();
return id.startsWith(Ios::Constants::IOS_RC_ID_PREFIX);
}
bool IosRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
return canCreate(parent, source->id());
}
QList<Core::Id> IosRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
if (!IosManager::supportsIos(parent))
return QList<Core::Id>();
auto project = static_cast<QmakeProject *>(parent->project());
return project->creationIds(Constants::IOS_RC_ID_PREFIX, mode, {ProjectType::ApplicationTemplate,
return project->buildTargets(mode, {ProjectType::ApplicationTemplate,
ProjectType::SharedLibraryTemplate,
ProjectType::AuxTemplate});
}
QString IosRunConfigurationFactory::displayNameForId(Core::Id id) const
QString IosRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
return IosRunConfiguration::pathFromId(id).toFileInfo().completeBaseName();
return QFileInfo(buildTarget).completeBaseName();
}
bool IosRunConfigurationFactory::canHandle(Target *t) const

13
src/plugins/ios/iosrunfactories.h
View File

@@ -43,17 +43,12 @@ class IosRunConfigurationFactory : public QmakeProjectManager::QmakeRunConfigura
public:
explicit IosRunConfigurationFactory(QObject *parent = 0);
QString displayNameForId(Core::Id id) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent,
ProjectExplorer::RunConfiguration *source) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canHandle(ProjectExplorer::Target *t) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
QList<ProjectExplorer::RunConfiguration *> runConfigurationsForNode(ProjectExplorer::Target *t,
const ProjectExplorer::Node *n
) override;

35
src/plugins/nim/project/nimrunconfigurationfactory.cpp
View File

@@ -38,43 +38,18 @@ namespace Nim {
NimRunConfigurationFactory::NimRunConfigurationFactory()
{
registerRunConfiguration<NimRunConfiguration>();
registerRunConfiguration<NimRunConfiguration>(Constants::C_NIMRUNCONFIGURATION_ID);
setSupportedProjectType<NimProject>();
}
QList<Core::Id> NimRunConfigurationFactory::availableCreationIds(Target *parent,
IRunConfigurationFactory::CreationMode mode) const
QList<QString> NimRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
{
Q_UNUSED(mode);
QList<Core::Id> result;
if (canHandle(parent))
result.append(Constants::C_NIMRUNCONFIGURATION_ID);
return result;
return {QString()};
}
QString NimRunConfigurationFactory::displayNameForId(Core::Id id) const
QString NimRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
return id.toString() + QStringLiteral("-TempRunConf");
}
bool NimRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
{
Q_UNUSED(id);
return canHandle(parent);
}
bool NimRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
Q_UNUSED(parent);
Q_UNUSED(map);
return canHandle(parent);
}
bool NimRunConfigurationFactory::canClone(Target *parent, RunConfiguration *product) const
{
QTC_ASSERT(parent, return false);
QTC_ASSERT(product, return false);
return canHandle(parent);
return buildTarget + "-TempRunConf";
}
}

9
src/plugins/nim/project/nimrunconfigurationfactory.h
View File

@@ -34,13 +34,8 @@ class NimRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
public:
NimRunConfigurationFactory();
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &) const override;
};
}

35
src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
View File

@@ -316,44 +316,17 @@ CustomExecutableRunConfigurationFactory::CustomExecutableRunConfigurationFactory
IRunConfigurationFactory(parent)
{
setObjectName("CustomExecutableRunConfigurationFactory");
registerRunConfiguration<CustomExecutableRunConfiguration>();
registerRunConfiguration<CustomExecutableRunConfiguration>(CUSTOM_EXECUTABLE_ID);
}
bool CustomExecutableRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
QList<QString> CustomExecutableRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
{
if (!canHandle(parent))
return false;
return id == CUSTOM_EXECUTABLE_ID;
return {QString()};
}
bool CustomExecutableRunConfigurationFactory::canRestore(Target *parent,
const QVariantMap &map) const
QString CustomExecutableRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
{
if (!canHandle(parent))
return false;
Core::Id id(idFromMap(map));
return canCreate(parent, id);
}
bool CustomExecutableRunConfigurationFactory::canClone(Target *parent,
RunConfiguration *source) const
{
return canCreate(parent, source->id());
}
QList<Core::Id> CustomExecutableRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
Q_UNUSED(mode)
if (!canHandle(parent))
return QList<Core::Id>();
return QList<Core::Id>() << Core::Id(CUSTOM_EXECUTABLE_ID);
}
QString CustomExecutableRunConfigurationFactory::displayNameForId(Core::Id id) const
{
if (id == CUSTOM_EXECUTABLE_ID)
return tr("Custom Executable");
return QString();
}
} // namespace ProjectExplorer

8
src/plugins/projectexplorer/customexecutablerunconfiguration.h
View File

@@ -95,12 +95,8 @@ class CustomExecutableRunConfigurationFactory : public IRunConfigurationFactory
public:
explicit CustomExecutableRunConfigurationFactory(QObject *parent = 0);
QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
bool canCreate(Target *parent, Core::Id id) const override;
bool canRestore(Target *parent, const QVariantMap &map) const override;
bool canClone(Target *parent, RunConfiguration *product) const override;
QList<QString> availableBuildTargets(Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &) const override;
};
} // namespace ProjectExplorer

56
src/plugins/projectexplorer/runconfiguration.cpp
View File

@@ -450,6 +450,25 @@ IRunConfigurationFactory::IRunConfigurationFactory(QObject *parent) :
{
}
QList<Core::Id> IRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
if (!canHandle(parent))
return {};
return Utils::transform(availableBuildTargets(parent, mode), [this](const QString &suffix) {
return m_runConfigBaseId.withSuffix(suffix);
});
}
QString IRunConfigurationFactory::displayNameForId(Core::Id id) const
{
return displayNameForBuildTarget(id.suffixAfter(m_runConfigBaseId));
}
QString IRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
return buildTarget;
}
/*!
Specifies a list of device types for which this RunConfigurationFactory
can create RunConfiguration.
@@ -477,6 +496,20 @@ bool IRunConfigurationFactory::canHandle(Target *target) const
return true;
}
bool IRunConfigurationFactory::canCreateHelper(Target *, const QString &) const
{
return true;
}
bool IRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
{
if (!canHandle(parent))
return false;
if (!id.name().startsWith(m_runConfigBaseId.name()))
return false;
return canCreateHelper(parent, id.suffixAfter(m_runConfigBaseId));
}
RunConfiguration *IRunConfigurationFactory::create(Target *parent, Core::Id id)
{
if (!canCreate(parent, id))
@@ -489,6 +522,21 @@ RunConfiguration *IRunConfigurationFactory::create(Target *parent, Core::Id id)
return rc;
}
bool IRunConfigurationFactory::canCloneHelper(Target *, RunConfiguration *) const
{
return true;
}
bool IRunConfigurationFactory::canClone(Target *parent, RunConfiguration *product) const
{
if (!canHandle(parent))
return false;
const Core::Id id = product->id();
if (!id.name().startsWith(m_runConfigBaseId.name()))
return false;
return canCloneHelper(parent, product);
}
RunConfiguration *IRunConfigurationFactory::restore(Target *parent, const QVariantMap &map)
{
if (!canRestore(parent, map))
@@ -504,6 +552,14 @@ RunConfiguration *IRunConfigurationFactory::restore(Target *parent, const QVaria
return rc;
}
bool IRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
if (!canHandle(parent))
return false;
const Core::Id id = idFromMap(map);
return id.name().startsWith(m_runConfigBaseId.name());
}
RunConfiguration *IRunConfigurationFactory::clone(Target *parent, RunConfiguration *product)
{
QTC_ASSERT(m_creator, return nullptr);

21
src/plugins/projectexplorer/runconfiguration.h
View File

@@ -285,15 +285,16 @@ public:
explicit IRunConfigurationFactory(QObject *parent = nullptr);
enum CreationMode {UserCreate, AutoCreate};
virtual QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode = UserCreate) const = 0;
virtual QString displayNameForId(Core::Id id) const = 0;
QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode = UserCreate) const;
QString displayNameForId(Core::Id id) const;
virtual bool canHandle(Target *target) const;
virtual bool canCreate(Target *parent, Core::Id id) const = 0;
bool canCreate(Target *parent, Core::Id id) const;
RunConfiguration *create(Target *parent, Core::Id id);
virtual bool canRestore(Target *parent, const QVariantMap &map) const = 0;
bool canRestore(Target *parent, const QVariantMap &map) const;
RunConfiguration *restore(Target *parent, const QVariantMap &map);
virtual bool canClone(Target *parent, RunConfiguration *product) const = 0;
bool canClone(Target *parent, RunConfiguration *product) const;
RunConfiguration *clone(Target *parent, RunConfiguration *product);
static IRunConfigurationFactory *find(Target *parent, const QVariantMap &map);
@@ -304,12 +305,19 @@ signals:
void availableCreationIdsChanged();
protected:
virtual QList<QString> availableBuildTargets(Target *parent, CreationMode mode = UserCreate) const = 0;
virtual QString displayNameForBuildTarget(const QString &buildTarget) const;
virtual bool canCreateHelper(Target *parent, const QString &buildTarget) const;
virtual bool canCloneHelper(Target *parent, RunConfiguration *product) const;
using RunConfigurationCreator = std::function<RunConfiguration *(Target *)>;
template <class RunConfig>
void registerRunConfiguration()
void registerRunConfiguration(Core::Id runConfigBaseId)
{
m_creator = [](Target *t) -> RunConfiguration * { return new RunConfig(t); };
m_runConfigBaseId = runConfigBaseId;
}
using ProjectTypeChecker = std::function<bool(Project *)>;
@@ -324,6 +332,7 @@ protected:
private:
RunConfigurationCreator m_creator;
Core::Id m_runConfigBaseId;
ProjectTypeChecker m_projectTypeChecker;
QList<Core::Id> m_supportedTargetDeviceTypes;
};

41
src/plugins/pythoneditor/pythoneditorplugin.cpp
View File

@@ -84,11 +84,6 @@ static QString scriptFromId(Core::Id id)
return id.suffixAfter(PythonRunConfigurationPrefix);
}
static Core::Id idFromScript(const QString &target)
{
return Core::Id(PythonRunConfigurationPrefix).withSuffix(target);
}
class PythonProject : public Project
{
Q_OBJECT
@@ -279,52 +274,26 @@ public:
PythonRunConfigurationFactory()
{
setObjectName("PythonRunConfigurationFactory");
registerRunConfiguration<PythonRunConfiguration>();
registerRunConfiguration<PythonRunConfiguration>(PythonRunConfigurationPrefix);
setSupportedProjectType<PythonProject>();
}
QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode) const override
QList<QString> availableBuildTargets(Target *parent, CreationMode mode) const override
{
Q_UNUSED(mode);
if (!canHandle(parent))
return {};
//return { Core::Id(PythonExecutableId) };
PythonProject *project = static_cast<PythonProject *>(parent->project());
QList<Core::Id> allIds;
foreach (const QString &file, project->files(ProjectExplorer::Project::AllFiles))
allIds.append(idFromScript(file));
return allIds;
return project->files(ProjectExplorer::Project::AllFiles);
}
QString displayNameForId(Core::Id id) const override
bool canCreateHelper(Target *parent, const QString &buildTarget) const override
{
return scriptFromId(id);
}
bool canCreate(Target *parent, Core::Id id) const override
{
if (!canHandle(parent))
return false;
PythonProject *project = static_cast<PythonProject *>(parent->project());
const QString script = scriptFromId(id);
const QString script = buildTarget;
if (script.endsWith(".pyqtc"))
return false;
return project->files(ProjectExplorer::Project::AllFiles).contains(script);
}
bool canRestore(Target *parent, const QVariantMap &map) const override
{
Q_UNUSED(parent);
return idFromMap(map).name().startsWith(PythonRunConfigurationPrefix);
}
bool canClone(Target *parent, RunConfiguration *source) const override
{
if (!canHandle(parent))
return false;
return source->id().name().startsWith(PythonRunConfigurationPrefix);
}
};
PythonProject::PythonProject(const FileName &fileName) :

47
src/plugins/qbsprojectmanager/qbsrunconfiguration.cpp
View File

@@ -72,14 +72,6 @@ const char QBS_RC_PREFIX[] = "Qbs.RunConfiguration:";
static QString rcNameSeparator() { return QLatin1String("---Qbs.RC.NameSeparator---"); }
static Core::Id idFromProduct(const QbsProject *project, const qbs::ProductData &product)
{
QString id = QLatin1String(QBS_RC_PREFIX);
id.append(QbsProject::uniqueProductName(product)).append(rcNameSeparator())
.append(QbsProject::productDisplayName(project->qbsProject(), product));
return Core::Id::fromString(id);
}
static QString uniqueProductNameFromId(Core::Id id)
{
const QString suffix = id.suffixAfter(QBS_RC_PREFIX);
@@ -353,42 +345,25 @@ QbsRunConfigurationFactory::QbsRunConfigurationFactory(QObject *parent) :
IRunConfigurationFactory(parent)
{
setObjectName("QbsRunConfigurationFactory");
registerRunConfiguration<QbsRunConfiguration>();
registerRunConfiguration<QbsRunConfiguration>(QBS_RC_PREFIX);
setSupportedProjectType<QbsProject>();
setSupportedTargetDeviceTypes({Constants::DESKTOP_DEVICE_TYPE});
}
bool QbsRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool QbsRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
QbsProject *project = static_cast<QbsProject *>(parent->project());
return findProduct(project->qbsProjectData(), uniqueProductNameFromId(id)).isValid();
QString product = buildTarget.left(buildTarget.indexOf(rcNameSeparator()));
return findProduct(project->qbsProjectData(), product).isValid();
}
bool QbsRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
if (!canHandle(parent))
return false;
return idFromMap(map).toString().startsWith(QLatin1String(QBS_RC_PREFIX));
}
bool QbsRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
return canCreate(parent, source->id());
}
QList<Core::Id> QbsRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
QList<QString> QbsRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
{
QList<qbs::ProductData> products;
if (!canHandle(parent))
return QList<Core::Id>();
QbsProject *project = static_cast<QbsProject *>(parent->project());
if (!project || !project->qbsProject().isValid())
return QList<Core::Id>();
return {};
foreach (const qbs::ProductData &product, project->qbsProjectData().allProducts()) {
if (product.isRunnable() && product.isEnabled())
@@ -405,13 +380,17 @@ QList<Core::Id> QbsRunConfigurationFactory::availableCreationIds(Target *parent,
}
return Utils::transform(products, [project](const qbs::ProductData &product) {
return idFromProduct(project, product);
return QString(QbsProject::uniqueProductName(product) + rcNameSeparator()
+ QbsProject::productDisplayName(project->qbsProject(), product));
});
}
QString QbsRunConfigurationFactory::displayNameForId(Core::Id id) const
QString QbsRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
return productDisplayNameFromId(id);
const int sepPos = buildTarget.indexOf(rcNameSeparator());
if (sepPos == -1)
return buildTarget;
return buildTarget.mid(sepPos + rcNameSeparator().count());
}
} // namespace Internal

8
src/plugins/qbsprojectmanager/qbsrunconfiguration.h
View File

@@ -108,12 +108,10 @@ class QbsRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
public:
explicit QbsRunConfigurationFactory(QObject *parent = 0);
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
};
} // namespace Internal

7
src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.cpp
View File

@@ -97,7 +97,7 @@ QString QmakeAndroidRunConfiguration::defaultDisplayName()
return node->displayName();
}
return displayNameForId(id());
return QString();
}
QString QmakeAndroidRunConfiguration::disabledReason() const
@@ -116,11 +116,6 @@ QString QmakeAndroidRunConfiguration::buildSystemTarget() const
return qmakeProject()->mapProFilePathToTarget(m_proFilePath);
}
QString QmakeAndroidRunConfiguration::displayNameForId(Core::Id id)
{
return pathFromId(id).toFileInfo().completeBaseName();
}
QmakeProject *QmakeAndroidRunConfiguration::qmakeProject() const
{
Target *t = target();

2
src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.h
View File

@@ -50,8 +50,6 @@ public:
QString buildSystemTarget() const final;
static QString displayNameForId(Core::Id id);
private:
friend class ProjectExplorer::IRunConfigurationFactory;
void initialize(Core::Id id) override;

32
src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.cpp
View File

@@ -49,42 +49,24 @@ static const char ANDROID_RC_ID_PREFIX[] = "Qt4ProjectManager.AndroidRunConfigur
QmakeAndroidRunConfigurationFactory::QmakeAndroidRunConfigurationFactory(QObject *parent)
: IRunConfigurationFactory(parent)
{
registerRunConfiguration<QmakeAndroidRunConfiguration>();
registerRunConfiguration<QmakeAndroidRunConfiguration>(ANDROID_RC_ID_PREFIX);
setSupportedProjectType<QmakeProject>();
}
QString QmakeAndroidRunConfigurationFactory::displayNameForId(Core::Id id) const
QString QmakeAndroidRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
return QmakeAndroidRunConfiguration::displayNameForId(id);
return QFileInfo(buildTarget).completeBaseName();
}
bool QmakeAndroidRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool QmakeAndroidRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
return availableCreationIds(parent).contains(id);
return availableBuildTargets(parent, UserCreate).contains(buildTarget);
}
bool QmakeAndroidRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
QList<QString> QmakeAndroidRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
{
if (!canHandle(parent))
return false;
return ProjectExplorer::idFromMap(map).name().startsWith(ANDROID_RC_ID_PREFIX);
}
bool QmakeAndroidRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
return canCreate(parent, source->id());
}
QList<Core::Id> QmakeAndroidRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
if (!canHandle(parent))
return QList<Core::Id>();
auto project = static_cast<QmakeProject *>(parent->project());
return project->creationIds(ANDROID_RC_ID_PREFIX, mode,
{ProjectType::ApplicationTemplate, ProjectType::SharedLibraryTemplate});
return project->buildTargets(mode, {ProjectType::ApplicationTemplate, ProjectType::SharedLibraryTemplate});
}
bool QmakeAndroidRunConfigurationFactory::canHandle(Target *t) const

8
src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.h
View File

@@ -43,12 +43,10 @@ class QmakeAndroidRunConfigurationFactory : public ProjectExplorer::IRunConfigur
public:
explicit QmakeAndroidRunConfigurationFactory(QObject *parent = 0);
QString displayNameForId(Core::Id id) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
QList<ProjectExplorer::RunConfiguration *> runConfigurationsForNode(ProjectExplorer::Target *t,
ProjectExplorer::Node *n);

38
src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.cpp
View File

@@ -67,11 +67,6 @@ const char PRO_FILE_KEY[] = "Qt4ProjectManager.Qt4RunConfiguration.ProFile";
const char USE_DYLD_IMAGE_SUFFIX_KEY[] = "Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix";
const char USE_LIBRARY_SEARCH_PATH[] = "QmakeProjectManager.QmakeRunConfiguration.UseLibrarySearchPath";
static Utils::FileName pathFromId(Core::Id id)
{
return Utils::FileName::fromString(id.suffixAfter(QMAKE_RC_PREFIX));
}
//
// QmakeRunConfiguration
//
@@ -96,7 +91,7 @@ DesktopQmakeRunConfiguration::DesktopQmakeRunConfiguration(Target *target)
void DesktopQmakeRunConfiguration::initialize(Core::Id id)
{
RunConfiguration::initialize(id);
m_proFilePath = pathFromId(id);
m_proFilePath = FileName::fromString(id.suffixAfter(QMAKE_RC_PREFIX));
updateTargetInformation();
}
@@ -440,43 +435,26 @@ DesktopQmakeRunConfigurationFactory::DesktopQmakeRunConfigurationFactory(QObject
QmakeRunConfigurationFactory(parent)
{
setObjectName("DesktopQmakeRunConfigurationFactory");
registerRunConfiguration<DesktopQmakeRunConfiguration>();
registerRunConfiguration<DesktopQmakeRunConfiguration>(QMAKE_RC_PREFIX);
setSupportedProjectType<QmakeProject>();
setSupportedTargetDeviceTypes({Constants::DESKTOP_DEVICE_TYPE});
}
bool DesktopQmakeRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool DesktopQmakeRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
QmakeProject *project = static_cast<QmakeProject *>(parent->project());
return project->hasApplicationProFile(pathFromId(id));
return project->hasApplicationProFile(Utils::FileName::fromString(buildTarget));
}
bool DesktopQmakeRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
QList<QString> DesktopQmakeRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
{
if (!canHandle(parent))
return false;
return idFromMap(map).toString().startsWith(QLatin1String(QMAKE_RC_PREFIX));
}
bool DesktopQmakeRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
return canCreate(parent, source->id());
}
QList<Core::Id> DesktopQmakeRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
if (!canHandle(parent))
return QList<Core::Id>();
QmakeProject *project = static_cast<QmakeProject *>(parent->project());
return project->creationIds(QMAKE_RC_PREFIX, mode);
return project->buildTargets(mode);
}
QString DesktopQmakeRunConfigurationFactory::displayNameForId(Core::Id id) const
QString DesktopQmakeRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
return pathFromId(id).toFileInfo().completeBaseName();
return QFileInfo(buildTarget).completeBaseName();
}
QList<RunConfiguration *> DesktopQmakeRunConfigurationFactory::runConfigurationsForNode(Target *t, const Node *n)

8
src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.h
View File

@@ -140,12 +140,10 @@ class DesktopQmakeRunConfigurationFactory : public QmakeRunConfigurationFactory
public:
explicit DesktopQmakeRunConfigurationFactory(QObject *parent = 0);
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
QList<ProjectExplorer::RunConfiguration *> runConfigurationsForNode(ProjectExplorer::Target *t,
const ProjectExplorer::Node *n) override;

7
src/plugins/qmakeprojectmanager/qmakeproject.cpp
View File

@@ -773,8 +773,7 @@ bool QmakeProject::hasApplicationProFile(const FileName &path) const
return Utils::contains(list, Utils::equal(&QmakeProFile::filePath, path));
}
QList<Core::Id> QmakeProject::creationIds(Core::Id base,
IRunConfigurationFactory::CreationMode mode,
QList<QString> QmakeProject::buildTargets(IRunConfigurationFactory::CreationMode mode,
const QList<ProjectType> &projectTypes)
{
QList<ProjectType> realTypes = projectTypes;
@@ -790,9 +789,7 @@ QList<Core::Id> QmakeProject::creationIds(Core::Id base,
temp = filtered.isEmpty() ? files : filtered;
}
return Utils::transform(temp, [&base](QmakeProFile *f) {
return base.withSuffix(f->filePath().toString());
});
return Utils::transform(temp, [](QmakeProFile *f) { return f->filePath().toString(); });
}
void QmakeProject::activeTargetWasChanged()

9
src/plugins/qmakeprojectmanager/qmakeproject.h
View File

@@ -48,12 +48,8 @@ namespace ProjectExplorer { class DeploymentData; }
namespace QtSupport { class ProFileReader; }
namespace QmakeProjectManager {
class QmakeBuildConfiguration;
namespace Internal {
class CentralizedFolderWatcher;
class QmakeProjectFiles;
}
namespace Internal { class CentralizedFolderWatcher; }
class QMAKEPROJECTMANAGER_EXPORT QmakeProject : public ProjectExplorer::Project
{
@@ -77,8 +73,7 @@ public:
QList<QmakeProFile *> applicationProFiles(Parsing parse = ExactParse) const;
bool hasApplicationProFile(const Utils::FileName &path) const;
QList<Core::Id> creationIds(Core::Id base,
ProjectExplorer::IRunConfigurationFactory::CreationMode mode,
QList<QString> buildTargets(ProjectExplorer::IRunConfigurationFactory::CreationMode mode,
const QList<ProjectType> &projectTypes = {});
static void notifyChanged(const Utils::FileName &name);

2
src/plugins/qmlprojectmanager/qmlprojectmanagerconstants.h
View File

@@ -30,6 +30,8 @@
namespace QmlProjectManager {
namespace Constants {
const char QML_RC_ID[] = "QmlProjectManager.QmlRunConfiguration";
const char QML_VIEWER_RC_ID[] = "QmlProjectManager.QmlRunConfiguration";
const char QML_SCENE_RC_ID[] = "QmlProjectManager.QmlRunConfiguration.QmlScene";
const char QML_VIEWER_ARGUMENTS_KEY[] = "QmlProjectManager.QmlRunConfiguration.QDeclarativeViewerArguments";

59
src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.cpp
View File

@@ -36,67 +36,58 @@
namespace QmlProjectManager {
namespace Internal {
const char QML_VIEWER_SUFFIX[] = "";
const char QML_SCENE_SUFFIX[] = ".QmlScene";
QmlProjectRunConfigurationFactory::QmlProjectRunConfigurationFactory(QObject *parent) :
ProjectExplorer::IRunConfigurationFactory(parent)
{
setObjectName("QmlProjectRunConfigurationFactory");
registerRunConfiguration<QmlProjectRunConfiguration>();
registerRunConfiguration<QmlProjectRunConfiguration>(Constants::QML_RC_ID);
setSupportedProjectType<QmlProject>();
setSupportedTargetDeviceTypes({ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE});
}
QList<Core::Id> QmlProjectRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const
QList<QString> QmlProjectRunConfigurationFactory::availableBuildTargets(ProjectExplorer::Target *parent, CreationMode) const
{
Q_UNUSED(mode)
if (!canHandle(parent))
return QList<Core::Id>();
QtSupport::BaseQtVersion *version
= QtSupport::QtKitInformation::qtVersion(parent->kit());
const QString viewer = QML_VIEWER_SUFFIX;
const QString scene = QML_SCENE_SUFFIX;
// First id will be the default run configuration
QList<Core::Id> list;
if (version && version->qtVersion() >= QtSupport::QtVersionNumber(5, 0, 0)) {
QmlProject *project = static_cast<QmlProject*>(parent->project());
switch (project->defaultImport()) {
case QmlProject::QtQuick1Import:
list << Core::Id(Constants::QML_VIEWER_RC_ID);
break;
return {viewer};
case QmlProject::QtQuick2Import:
list << Core::Id(Constants::QML_SCENE_RC_ID);
break;
return {scene};
case QmlProject::UnknownImport:
default:
list << Core::Id(Constants::QML_SCENE_RC_ID);
list << Core::Id(Constants::QML_VIEWER_RC_ID);
break;
return {scene, viewer};
}
} else {
list << Core::Id(Constants::QML_VIEWER_RC_ID);
}
return {viewer};
}
return list;
}
QString QmlProjectRunConfigurationFactory::displayNameForId(Core::Id id) const
QString QmlProjectRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
if (id == Constants::QML_VIEWER_RC_ID)
if (buildTarget == QML_VIEWER_SUFFIX)
return tr("QML Viewer");
if (id == Constants::QML_SCENE_RC_ID)
if (buildTarget == QML_SCENE_SUFFIX)
return tr("QML Scene");
return QString();
}
bool QmlProjectRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent,
const Core::Id id) const
bool QmlProjectRunConfigurationFactory::canCreateHelper(ProjectExplorer::Target *parent,
const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
if (id == Constants::QML_VIEWER_RC_ID)
if (buildTarget == QML_VIEWER_SUFFIX)
return true;
if (id == Constants::QML_SCENE_RC_ID) {
if (buildTarget == QML_SCENE_SUFFIX) {
// only support qmlscene if it's Qt5
QtSupport::BaseQtVersion *version
= QtSupport::QtKitInformation::qtVersion(parent->kit());
@@ -105,16 +96,6 @@ bool QmlProjectRunConfigurationFactory::canCreate(ProjectExplorer::Target *paren
return false;
}
bool QmlProjectRunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const
{
return parent && canCreate(parent, ProjectExplorer::idFromMap(map));
}
bool QmlProjectRunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const
{
return canCreate(parent, source->id());
}
} // namespace Internal
} // namespace QmlProjectManager

8
src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.h
View File

@@ -37,12 +37,10 @@ class QmlProjectRunConfigurationFactory : public ProjectExplorer::IRunConfigurat
public:
explicit QmlProjectRunConfigurationFactory(QObject *parent = 0);
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
};
} // namespace Internal

55
src/plugins/qnx/qnxrunconfigurationfactory.cpp
View File

@@ -36,64 +36,33 @@
namespace Qnx {
namespace Internal {
static Utils::FileName pathFromId(Core::Id id)
{
return Utils::FileName::fromString(id.suffixAfter(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX));
}
QnxRunConfigurationFactory::QnxRunConfigurationFactory(QObject *parent) :
ProjectExplorer::IRunConfigurationFactory(parent)
{
registerRunConfiguration<QnxRunConfiguration>();
registerRunConfiguration<QnxRunConfiguration>(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX);
setSupportedTargetDeviceTypes({Constants::QNX_QNX_OS_TYPE});
}
QList<Core::Id> QnxRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const
QList<QString> QnxRunConfigurationFactory::availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const
{
using QmakeProjectManager::QmakeProject;
if (!canHandle(parent))
return QList<Core::Id>();
auto project = qobject_cast<QmakeProject *>(parent->project());
auto project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
if (!project)
return QList<Core::Id>();
return project->creationIds(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX, mode);
return {};
return project->buildTargets(mode);
}
QString QnxRunConfigurationFactory::displayNameForId(Core::Id id) const
QString QnxRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
const Utils::FileName path = pathFromId(id);
if (path.isEmpty())
return QString();
if (id.name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX))
return tr("%1 on QNX Device").arg(path.toFileInfo().completeBaseName());
if (buildTarget.isEmpty())
return QString();
return tr("%1 on QNX Device").arg(QFileInfo(buildTarget).completeBaseName());
}
bool QnxRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, Core::Id id) const
bool QnxRunConfigurationFactory::canCreateHelper(ProjectExplorer::Target *parent,
const QString &buildTarget) const
{
if (!canHandle(parent) || !id.name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX))
return false;
QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
if (!qt4Project)
return false;
return qt4Project->hasApplicationProFile(pathFromId(id));
}
bool QnxRunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const
{
return canHandle(parent)
&& ProjectExplorer::idFromMap(map).name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX);
}
bool QnxRunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const
{
return canCreate(parent, source->id());
auto project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
return project->hasApplicationProFile(Utils::FileName::fromString(buildTarget));
}
} // namespace Internal

8
src/plugins/qnx/qnxrunconfigurationfactory.h
View File

@@ -38,12 +38,10 @@ class QnxRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
public:
explicit QnxRunConfigurationFactory(QObject *parent = 0);
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
};
} // namespace Internal

90
src/plugins/remotelinux/remotelinuxrunconfigurationfactory.cpp
View File

@@ -30,73 +30,40 @@
#include "remotelinuxrunconfiguration.h"
#include <projectexplorer/buildtargetinfo.h>
#include <projectexplorer/kitinformation.h>
#include <projectexplorer/project.h>
#include <projectexplorer/target.h>
#include <utils/qtcassert.h>
#include <QString>
using namespace ProjectExplorer;
namespace RemoteLinux {
namespace Internal {
static QString stringFromId(Core::Id id)
{
QByteArray idStr = id.name();
if (!idStr.startsWith(RemoteLinuxRunConfiguration::IdPrefix))
return QString();
return QString::fromUtf8(idStr.mid(int(strlen(RemoteLinuxRunConfiguration::IdPrefix))));
}
// RemoteLinuxRunConfigurationFactory
RemoteLinuxRunConfigurationFactory::RemoteLinuxRunConfigurationFactory(QObject *parent)
: IRunConfigurationFactory(parent)
{
setObjectName("RemoteLinuxRunConfigurationFactory");
registerRunConfiguration<RemoteLinuxRunConfiguration>();
registerRunConfiguration<RemoteLinuxRunConfiguration>(RemoteLinuxRunConfiguration::IdPrefix);
setSupportedTargetDeviceTypes({RemoteLinux::Constants::GenericLinuxOsType});
}
bool RemoteLinuxRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool RemoteLinuxRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
{
if (!canHandle(parent))
return false;
return parent->applicationTargets().hasTarget(stringFromId(id));
return parent->applicationTargets().hasTarget(buildTarget);
}
bool RemoteLinuxRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
QList<QString>
RemoteLinuxRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
{
if (!canHandle(parent))
return false;
const Core::Id id = idFromMap(map);
return id.name().startsWith(RemoteLinuxRunConfiguration::IdPrefix);
return Utils::transform(parent->applicationTargets().list, [](const BuildTargetInfo &bti) {
return bti.targetName;
});
}
bool RemoteLinuxRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
QString RemoteLinuxRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
{
auto rlrc = qobject_cast<RemoteLinuxRunConfiguration *>(source);
return rlrc && canCreate(parent, source->id());
}
QList<Core::Id> RemoteLinuxRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
Q_UNUSED(mode)
QList<Core::Id> result;
if (!canHandle(parent))
return result;
const Core::Id base = Core::Id(RemoteLinuxRunConfiguration::IdPrefix);
foreach (const BuildTargetInfo &bti, parent->applicationTargets().list)
result << base.withSuffix(bti.targetName);
return result;
}
QString RemoteLinuxRunConfigurationFactory::displayNameForId(Core::Id id) const
{
return stringFromId(id) + QLatin1Char(' ') + tr("(on Remote Generic Linux Host)");
return buildTarget + ' ' + tr("(on Remote Generic Linux Host)");
}
// RemoteLinuxCustomRunConfigurationFactory
@@ -105,42 +72,17 @@ RemoteLinuxCustomRunConfigurationFactory::RemoteLinuxCustomRunConfigurationFacto
: IRunConfigurationFactory(parent)
{
setObjectName("RemoteLinuxCustomRunConfiguration");
registerRunConfiguration<RemoteLinuxCustomRunConfiguration>();
registerRunConfiguration<RemoteLinuxCustomRunConfiguration>
(RemoteLinuxCustomRunConfiguration::runConfigId());
}
bool RemoteLinuxCustomRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
QList<QString>
RemoteLinuxCustomRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
{
if (!canHandle(parent))
return false;
return id == RemoteLinuxCustomRunConfiguration::runConfigId();
return {QString()};
}
bool RemoteLinuxCustomRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
if (!canHandle(parent))
return false;
const Core::Id id = idFromMap(map);
return id == RemoteLinuxCustomRunConfiguration::runConfigId();
}
bool RemoteLinuxCustomRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
{
auto rlrc = qobject_cast<RemoteLinuxCustomRunConfiguration *>(source);
return rlrc && canCreate(parent, source->id());
}
QList<Core::Id> RemoteLinuxCustomRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
{
Q_UNUSED(mode)
QList<Core::Id> result;
if (!canHandle(parent))
return result;
result << RemoteLinuxCustomRunConfiguration::runConfigId();
return result;
}
QString RemoteLinuxCustomRunConfigurationFactory::displayNameForId(Core::Id) const
QString RemoteLinuxCustomRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
{
return RemoteLinuxCustomRunConfiguration::runConfigDefaultDisplayName();
}

16
src/plugins/remotelinux/remotelinuxrunconfigurationfactory.h
View File

@@ -37,12 +37,10 @@ class RemoteLinuxRunConfigurationFactory : public ProjectExplorer::IRunConfigura
public:
explicit RemoteLinuxRunConfigurationFactory(QObject *parent = 0);
QString displayNameForId(Core::Id id) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
};
class RemoteLinuxCustomRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
@@ -52,12 +50,8 @@ class RemoteLinuxCustomRunConfigurationFactory : public ProjectExplorer::IRunCon
public:
explicit RemoteLinuxCustomRunConfigurationFactory(QObject *parent = 0);
QString displayNameForId(Core::Id id) const override;
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
};
} // namespace Internal

32
src/plugins/winrt/winrtrunfactories.cpp
View File

@@ -43,48 +43,28 @@ namespace Internal {
WinRtRunConfigurationFactory::WinRtRunConfigurationFactory()
{
registerRunConfiguration<WinRtRunConfiguration>();
registerRunConfiguration<WinRtRunConfiguration>(Constants::WINRT_RC_PREFIX);
setSupportedProjectType<QmakeProject>();
setSupportedTargetDeviceTypes({Constants::WINRT_DEVICE_TYPE_LOCAL,
Constants::WINRT_DEVICE_TYPE_PHONE,
Constants::WINRT_DEVICE_TYPE_EMULATOR});
}
QList<Core::Id> WinRtRunConfigurationFactory::availableCreationIds(Target *parent,
QList<QString> WinRtRunConfigurationFactory::availableBuildTargets(Target *parent,
CreationMode mode) const
{
if (!canHandle(parent))
return QList<Core::Id>();
QmakeProject *project = static_cast<QmakeProject *>(parent->project());
return project->creationIds(Constants::WINRT_RC_PREFIX, mode);
return project->buildTargets(mode);
}
QString WinRtRunConfigurationFactory::displayNameForId(Core::Id id) const
QString WinRtRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
{
Q_UNUSED(id);
return tr("Run App Package");
}
bool WinRtRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
bool WinRtRunConfigurationFactory::canCloneHelper(Target *, RunConfiguration *) const
{
Q_UNUSED(id);
return canHandle(parent);
}
bool WinRtRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
if (!canHandle(parent))
return false;
return idFromMap(map).toString().startsWith(QLatin1String(Constants::WINRT_RC_PREFIX));
}
bool WinRtRunConfigurationFactory::canClone(Target *parent, RunConfiguration *product) const
{
Q_UNUSED(parent);
Q_UNUSED(product);
return false;
return false; // FIXME: Are they really unclonable?
}
} // namespace Internal

9
src/plugins/winrt/winrtrunfactories.h
View File

@@ -38,11 +38,10 @@ class WinRtRunConfigurationFactory : public ProjectExplorer::IRunConfigurationF
public:
WinRtRunConfigurationFactory();
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForId(Core::Id id) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
QString displayNameForBuildTarget(const QString &buildTarget) const override;
bool canCloneHelper(ProjectExplorer::Target *, ProjectExplorer::RunConfiguration *) const override;
};
} // namespace Internal