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

ProjectExplorer: Make deploy configurations per build configuration

Browse Source 
The first step towards having the run settings "per configuration" instead
of "per target".
There is no syncing functionality yet.

Task-number: QTCREATORBUG-32380
Change-Id: Ia6086bacb8957e0b5dafe52a0d4e74e43a2c2292
Reviewed-by: hjk <hjk@qt.io>
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
This commit is contained in:
Christian Kandeler
2025-02-11 16:47:24 +01:00
parent 6cc81518e3
commit 4348a2fc56
20 changed files with 436 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
src/plugins/projectexplorer/buildconfiguration.cpp
View File

@@ -5,14 +5,18 @@
#include "buildaspects.h"
#include "buildinfo.h"
#include "buildmanager.h"
#include "buildpropertiessettings.h"
#include "buildsteplist.h"
#include "buildstepspage.h"
#include "buildsystem.h"
#include "customparser.h"
#include "deployconfiguration.h"
#include "devicesupport/devicekitaspects.h"
#include "environmentwidget.h"
#include "kit.h"
#include "miniprojecttargetselector.h"
#include "projectconfigurationmodel.h"
#include "projectexplorerconstants.h"
#include "projectexplorer.h"
#include "projectexplorertr.h"
@@ -33,6 +37,7 @@
#include <utils/macroexpander.h>
#include <utils/mimeutils.h>
#include <utils/qtcassert.h>
#include <utils/stringutils.h>
#include <utils/variablechooser.h>
#include <QCheckBox>
@@ -48,6 +53,10 @@ const char BUILD_STEP_LIST_PREFIX[] = "ProjectExplorer.BuildConfiguration.BuildS
const char CUSTOM_PARSERS_KEY[] = "ProjectExplorer.BuildConfiguration.CustomParsers";
const char PARSE_STD_OUT_KEY[] = "ProjectExplorer.BuildConfiguration.ParseStandardOutput";
const char ACTIVE_DC_KEY[] = "ProjectExplorer.Target.ActiveDeployConfiguration";
const char DC_KEY_PREFIX[] = "ProjectExplorer.Target.DeployConfiguration.";
const char DC_COUNT_KEY[] = "ProjectExplorer.Target.DeployConfigurationCount";
Q_LOGGING_CATEGORY(bcLog, "qtc.buildconfig", QtWarningMsg)
namespace ProjectExplorer {
@@ -136,6 +145,7 @@ public:
, m_buildDirectoryAspect(bc, bc)
, m_tooltipAspect(bc)
, m_buildSystem(bc->project()->createBuildSystem(bc))
, m_deployConfigurationModel(bc->target())
{}
~BuildConfigurationPrivate() { delete m_buildSystem; }
@@ -155,6 +165,10 @@ public:
bool m_parseStdOut = false;
QList<Utils::Id> m_customParsers;
BuildSystem * const m_buildSystem;
QList<DeployConfiguration *> m_deployConfigurations;
DeployConfiguration *m_activeDeployConfiguration = nullptr;
ProjectConfigurationModel m_deployConfigurationModel;
// FIXME: Remove.
BuildConfiguration::BuildType m_initialBuildType = BuildConfiguration::Unknown;
@@ -227,6 +241,7 @@ BuildConfiguration::BuildConfiguration(Target *target, Utils::Id id)
BuildConfiguration::~BuildConfiguration()
{
qDeleteAll(d->m_deployConfigurations);
delete d;
}
@@ -321,6 +336,66 @@ void BuildConfiguration::setInitializer(const std::function<void(const BuildInfo
d->m_initializer = initializer;
}
bool BuildConfiguration::addConfigurationsFromMap(
const Utils::Store &map, bool setActiveConfigurations)
{
bool ok = true;
int dcCount = map.value(DC_COUNT_KEY, 0).toInt(&ok);
if (!ok || dcCount < 0)
dcCount = 0;
int activeDc = map.value(ACTIVE_DC_KEY, 0).toInt(&ok);
if (!ok || 0 > activeDc || dcCount < activeDc)
activeDc = 0;
if (!setActiveConfigurations)
activeDc = -1;
for (int i = 0; i < dcCount; ++i) {
const Key key = numberedKey(DC_KEY_PREFIX, i);
if (!map.contains(key))
return false;
Store valueMap = storeFromVariant(map.value(key));
DeployConfiguration *dc = DeployConfigurationFactory::restore(this, valueMap);
if (!dc) {
Utils::Id id = idFromMap(valueMap);
qWarning("No factory found to restore deployment configuration of id '%s'!",
id.isValid() ? qPrintable(id.toString()) : "UNKNOWN");
continue;
}
QTC_CHECK(dc->id() == ProjectExplorer::idFromMap(valueMap));
addDeployConfiguration(dc);
if (i == activeDc)
setActiveDeployConfiguration(dc);
}
return true;
}
void BuildConfiguration::storeConfigurationsToMap(Utils::Store &map) const
{
const QList<DeployConfiguration *> dcs = deployConfigurations();
map.insert(ACTIVE_DC_KEY, dcs.indexOf(d->m_activeDeployConfiguration));
map.insert(DC_COUNT_KEY, dcs.size());
for (int i = 0; i < dcs.size(); ++i) {
Store data;
dcs.at(i)->toMap(data);
map.insert(numberedKey(DC_KEY_PREFIX, i), variantFromStore(data));
}
}
void BuildConfiguration::setActiveDeployConfiguration(DeployConfiguration *dc)
{
if (dc) {
QTC_ASSERT(d->m_deployConfigurations.contains(dc), return);
} else {
QTC_ASSERT(d->m_deployConfigurations.isEmpty(), return);
}
if (dc == d->m_activeDeployConfiguration)
return;
d->m_activeDeployConfiguration = dc;
if (this == target()->activeBuildConfiguration())
emit target()->activeDeployConfigurationChanged(d->m_activeDeployConfiguration);
}
QWidget *BuildConfiguration::createConfigWidget()
{
QWidget *named = new QWidget;
@@ -384,6 +459,139 @@ void BuildConfiguration::appendInitialCleanStep(Utils::Id id)
d->m_initialCleanSteps.append(id);
}
void BuildConfiguration::addDeployConfiguration(DeployConfiguration *dc)
{
QTC_ASSERT(dc && !d->m_deployConfigurations.contains(dc), return);
QTC_ASSERT(dc->buildConfiguration() == this, return);
// Check that we don't have a configuration with the same displayName
QString configurationDisplayName = dc->displayName();
QStringList displayNames = Utils::transform(d->m_deployConfigurations, &DeployConfiguration::displayName);
configurationDisplayName = Utils::makeUniquelyNumbered(configurationDisplayName, displayNames);
dc->setDisplayName(configurationDisplayName);
// add it
d->m_deployConfigurations.push_back(dc);
ProjectExplorerPlugin::targetSelector()->addedDeployConfiguration(dc); // TODO: Use signal instead?
d->m_deployConfigurationModel.addProjectConfiguration(dc);
if (this == target()->activeBuildConfiguration())
emit target()->addedDeployConfiguration(dc);
if (!d->m_activeDeployConfiguration)
setActiveDeployConfiguration(dc);
Q_ASSERT(activeDeployConfiguration());
}
bool BuildConfiguration::removeDeployConfiguration(DeployConfiguration *dc)
{
if (!d->m_deployConfigurations.contains(dc))
return false;
if (BuildManager::isBuilding(dc))
return false;
d->m_deployConfigurations.removeOne(dc);
if (activeDeployConfiguration() == dc) {
if (d->m_deployConfigurations.isEmpty())
setActiveDeployConfiguration(nullptr, SetActive::Cascade);
else
setActiveDeployConfiguration(d->m_deployConfigurations.at(0), SetActive::Cascade);
}
ProjectExplorerPlugin::targetSelector()->removedDeployConfiguration(dc);
d->m_deployConfigurationModel.removeProjectConfiguration(dc);
emit target()->removedDeployConfiguration(dc); // TODO: Own signal?
delete dc;
return true;
}
const QList<DeployConfiguration *> BuildConfiguration::deployConfigurations() const
{
return d->m_deployConfigurations;
}
DeployConfiguration *BuildConfiguration::activeDeployConfiguration() const
{
return d->m_activeDeployConfiguration;
}
void BuildConfiguration::setActiveDeployConfiguration(DeployConfiguration *dc, SetActive cascade)
{
QTC_ASSERT(project(), return);
if (project()->isShuttingDown() || target()->isShuttingDown()) // Do we need our own isShuttungDown()?
return;
setActiveDeployConfiguration(dc);
if (!dc)
return;
if (cascade != SetActive::Cascade || !ProjectManager::isProjectConfigurationCascading())
return;
Id kitId = kit()->id();
QString name = dc->displayName(); // We match on displayname
for (Project *otherProject : ProjectManager::projects()) {
if (otherProject == project())
continue;
Target *otherTarget = otherProject->activeTarget();
if (!otherTarget || otherTarget->kit()->id() != kitId)
continue;
for (BuildConfiguration *otherBc : otherTarget->buildConfigurations()) {
for (DeployConfiguration *otherDc : otherBc->deployConfigurations()) {
if (otherDc->displayName() == name) {
otherBc->setActiveDeployConfiguration(otherDc);
break;
}
}
}
}
}
void BuildConfiguration::updateDefaultDeployConfigurations()
{
const QList<DeployConfigurationFactory *> dcFactories = DeployConfigurationFactory::find(
target());
QTC_ASSERT(!dcFactories.isEmpty(), qDebug() << target()->id(); return);
QList<Utils::Id> dcIds;
for (const DeployConfigurationFactory *dcFactory : dcFactories)
dcIds.append(dcFactory->creationId());
const QList<DeployConfiguration *> dcList = deployConfigurations();
QList<Utils::Id> toCreate = dcIds;
for (DeployConfiguration *dc : dcList) {
if (dcIds.contains(dc->id()))
toCreate.removeOne(dc->id());
else
removeDeployConfiguration(dc);
}
for (Utils::Id id : std::as_const(toCreate)) {
for (DeployConfigurationFactory *dcFactory : dcFactories) {
if (dcFactory->creationId() == id) {
DeployConfiguration *dc = dcFactory->create(this);
if (dc) {
QTC_CHECK(dc->id() == id);
addDeployConfiguration(dc);
}
}
}
}
}
ProjectConfigurationModel *BuildConfiguration::deployConfigurationModel() const
{
return &d->m_deployConfigurationModel;
}
BuildConfiguration *BuildConfiguration::clone(Target *target) const
{
Store map;
@@ -405,6 +613,8 @@ void BuildConfiguration::toMap(Store &map) const
map.insert(PARSE_STD_OUT_KEY, d->m_parseStdOut);
map.insert(CUSTOM_PARSERS_KEY, transform(d->m_customParsers, &Id::toSetting));
storeConfigurationsToMap(map);
}
void BuildConfiguration::fromMap(const Store &map)
@@ -442,6 +652,7 @@ void BuildConfiguration::fromMap(const Store &map)
ProjectConfiguration::fromMap(map);
setToolTip(d->m_tooltipAspect());
addConfigurationsFromMap(map, true);
}
void BuildConfiguration::updateCacheAndEmitEnvironmentChanged()

15
src/plugins/projectexplorer/buildconfiguration.h
View File

@@ -5,6 +5,7 @@
#include "projectexplorer_export.h"
#include "projectconfiguration.h"
#include "target.h"
#include "task.h"
#include <utils/environment.h>
@@ -20,6 +21,7 @@ class BuildDirectoryAspect;
class BuildInfo;
class BuildSystem;
class BuildStepList;
class DeployConfiguration;
class Kit;
class Node;
class Project;
@@ -32,6 +34,7 @@ class PROJECTEXPLORER_EXPORT BuildConfiguration : public ProjectConfiguration
protected:
friend class BuildConfigurationFactory;
friend class Target;
explicit BuildConfiguration(Target *target, Utils::Id id);
public:
@@ -71,6 +74,14 @@ public:
void appendInitialBuildStep(Utils::Id id);
void appendInitialCleanStep(Utils::Id id);
void addDeployConfiguration(DeployConfiguration *dc);
bool removeDeployConfiguration(DeployConfiguration *dc);
const QList<DeployConfiguration *> deployConfigurations() const;
DeployConfiguration *activeDeployConfiguration() const;
void setActiveDeployConfiguration(DeployConfiguration *dc, SetActive cascade);
void updateDefaultDeployConfigurations();
ProjectConfigurationModel *deployConfigurationModel() const;
virtual BuildConfiguration *clone(Target *target) const;
void fromMap(const Utils::Store &map) override;
void toMap(Utils::Store &map) const override;
@@ -132,6 +143,10 @@ protected:
void setInitializer(const std::function<void(const BuildInfo &info)> &initializer);
private:
bool addConfigurationsFromMap(const Utils::Store &map, bool setActiveConfigurations);
void storeConfigurationsToMap(Utils::Store &map) const;
void setActiveDeployConfiguration(DeployConfiguration *dc);
void emitBuildDirectoryChanged();
Internal::BuildConfigurationPrivate *d = nullptr;
};

10
src/plugins/projectexplorer/buildstep.cpp
View File

@@ -141,11 +141,12 @@ void BuildStep::toMap(Store &map) const
BuildConfiguration *BuildStep::buildConfiguration() const
{
auto config = qobject_cast<BuildConfiguration *>(projectConfiguration());
if (config)
return config;
if (const auto buildConfig = qobject_cast<BuildConfiguration *>(projectConfiguration()))
return buildConfig;
if (const auto deployConfig = qobject_cast<DeployConfiguration *>(projectConfiguration()))
return deployConfig->buildConfiguration();
// step is not part of a build configuration, use active build configuration of step's target
QTC_CHECK(false);
return target()->activeBuildConfiguration();
}
@@ -154,7 +155,6 @@ DeployConfiguration *BuildStep::deployConfiguration() const
auto config = qobject_cast<DeployConfiguration *>(projectConfiguration());
if (config)
return config;
// See comment in buildConfiguration()
QTC_CHECK(false);
// step is not part of a deploy configuration, use active deploy configuration of step's target
return target()->activeDeployConfiguration();

34
src/plugins/projectexplorer/deployconfiguration.cpp
View File

@@ -28,8 +28,9 @@ const char BUILD_STEP_LIST_PREFIX[] = "ProjectExplorer.BuildConfiguration.BuildS
const char USES_DEPLOYMENT_DATA[] = "ProjectExplorer.DeployConfiguration.CustomDataEnabled";
const char DEPLOYMENT_DATA[] = "ProjectExplorer.DeployConfiguration.CustomData";
DeployConfiguration::DeployConfiguration(Target *target, Id id)
: ProjectConfiguration(target, id)
DeployConfiguration::DeployConfiguration(BuildConfiguration *bc, Id id)
: ProjectConfiguration(bc->target(), id)
, m_buildConfiguration(bc)
, m_stepList(this, Constants::BUILDSTEPS_DEPLOY)
{
//: Default DeployConfiguration display name
@@ -39,10 +40,7 @@ DeployConfiguration::DeployConfiguration(Target *target, Id id)
MacroExpander &expander = *macroExpander();
expander.setDisplayName(Tr::tr("Run Settings"));
expander.setAccumulating(true);
expander.registerSubProvider([target] {
BuildConfiguration *bc = target->activeBuildConfiguration();
return bc ? bc->macroExpander() : target->macroExpander();
});
expander.registerSubProvider([bc] { return bc->macroExpander(); });
}
BuildStepList *DeployConfiguration::stepList()
@@ -178,47 +176,47 @@ void DeployConfigurationFactory::setConfigBaseId(Id deployConfigBaseId)
m_deployConfigBaseId = deployConfigBaseId;
}
DeployConfiguration *DeployConfigurationFactory::createDeployConfiguration(Target *t)
DeployConfiguration *DeployConfigurationFactory::createDeployConfiguration(BuildConfiguration *bc)
{
auto dc = new DeployConfiguration(t, m_deployConfigBaseId);
auto dc = new DeployConfiguration(bc, m_deployConfigBaseId);
dc->setDefaultDisplayName(m_defaultDisplayName);
dc->m_configWidgetCreator = m_configWidgetCreator;
return dc;
}
DeployConfiguration *DeployConfigurationFactory::create(Target *parent)
DeployConfiguration *DeployConfigurationFactory::create(BuildConfiguration *bc)
{
QTC_ASSERT(canHandle(parent), return nullptr);
DeployConfiguration *dc = createDeployConfiguration(parent);
QTC_ASSERT(canHandle(bc->target()), return nullptr);
DeployConfiguration *dc = createDeployConfiguration(bc);
QTC_ASSERT(dc, return nullptr);
BuildStepList *stepList = dc->stepList();
for (const BuildStepList::StepCreationInfo &info : std::as_const(m_initialSteps)) {
if (!info.condition || info.condition(parent))
if (!info.condition || info.condition(bc->target()))
stepList->appendStep(info.stepId);
}
return dc;
}
DeployConfiguration *DeployConfigurationFactory::clone(Target *parent,
DeployConfiguration *DeployConfigurationFactory::clone(BuildConfiguration *bc,
const DeployConfiguration *source)
{
Store map;
source->toMap(map);
return restore(parent, map);
return restore(bc, map);
}
DeployConfiguration *DeployConfigurationFactory::restore(Target *parent, const Store &map)
DeployConfiguration *DeployConfigurationFactory::restore(BuildConfiguration *bc, const Store &map)
{
const Id id = idFromMap(map);
DeployConfigurationFactory *factory = Utils::findOrDefault(g_deployConfigurationFactories,
[parent, id](DeployConfigurationFactory *f) {
if (!f->canHandle(parent))
[bc, id](DeployConfigurationFactory *f) {
if (!f->canHandle(bc->target()))
return false;
return id.name().startsWith(f->m_deployConfigBaseId.name());
});
if (!factory)
return nullptr;
DeployConfiguration *dc = factory->createDeployConfiguration(parent);
DeployConfiguration *dc = factory->createDeployConfiguration(bc);
QTC_ASSERT(dc, return nullptr);
dc->fromMap(map);
if (dc->hasError()) {

14
src/plugins/projectexplorer/deployconfiguration.h
View File

@@ -11,6 +11,7 @@
namespace ProjectExplorer {
class BuildConfiguration;
class BuildStepList;
class Target;
class DeployConfigurationFactory;
@@ -21,7 +22,7 @@ class PROJECTEXPLORER_EXPORT DeployConfiguration final : public ProjectConfigura
private:
friend class DeployConfigurationFactory;
explicit DeployConfiguration(Target *target, Utils::Id id);
explicit DeployConfiguration(BuildConfiguration *bc, Utils::Id id);
public:
~DeployConfiguration() override = default;
@@ -42,7 +43,10 @@ public:
DeploymentData customDeploymentData() const { return m_customDeploymentData; }
void setCustomDeploymentData(const DeploymentData &data) { m_customDeploymentData = data; }
BuildConfiguration *buildConfiguration() const { return m_buildConfiguration; }
private:
BuildConfiguration * const m_buildConfiguration;
BuildStepList m_stepList;
using WidgetCreator = std::function<QWidget *(DeployConfiguration *)>;
WidgetCreator m_configWidgetCreator;
@@ -63,11 +67,11 @@ public:
// the name to display to the user
QString defaultDisplayName() const;
DeployConfiguration *create(Target *parent);
DeployConfiguration *create(BuildConfiguration *bc);
static const QList<DeployConfigurationFactory *> find(Target *parent);
static DeployConfiguration *restore(Target *parent, const Utils::Store &map);
static DeployConfiguration *clone(Target *parent, const DeployConfiguration *dc);
static DeployConfiguration *restore(BuildConfiguration *bc, const Utils::Store &map);
static DeployConfiguration *clone(BuildConfiguration *bc, const DeployConfiguration *dc);
void addSupportedTargetDeviceType(Utils::Id id);
void setDefaultDisplayName(const QString &defaultDisplayName);
@@ -90,7 +94,7 @@ protected:
void setConfigBaseId(Utils::Id deployConfigBaseId);
private:
DeployConfiguration *createDeployConfiguration(Target *target);
DeployConfiguration *createDeployConfiguration(BuildConfiguration *bc);
Utils::Id m_deployConfigBaseId;
Utils::Id m_supportedProjectType;
QList<Utils::Id> m_supportedTargetDeviceTypes;

50
src/plugins/projectexplorer/miniprojecttargetselector.cpp
View File

@@ -737,7 +737,7 @@ MiniProjectTargetSelector::MiniProjectTargetSelector(QAction *targetSelectorActi
});
connect(m_listWidgets[DEPLOY], &GenericListWidget::changeActiveProjectConfiguration,
this, [this](QObject *pc) {
m_project->activeTarget()->setActiveDeployConfiguration(
m_project->activeBuildConfiguration()->setActiveDeployConfiguration(
static_cast<DeployConfiguration *>(pc), SetActive::Cascade);
});
connect(m_listWidgets[RUN], &GenericListWidget::changeActiveProjectConfiguration,
@@ -1027,8 +1027,6 @@ void MiniProjectTargetSelector::addedTarget(Target *target)
for (BuildConfiguration *bc : target->buildConfigurations())
addedBuildConfiguration(bc, false);
for (DeployConfiguration *dc : target->deployConfigurations())
addedDeployConfiguration(dc, false);
for (RunConfiguration *rc : target->runConfigurations())
addedRunConfiguration(rc, false);
}
@@ -1042,8 +1040,6 @@ void MiniProjectTargetSelector::removedTarget(Target *target)
for (BuildConfiguration *bc : target->buildConfigurations())
removedBuildConfiguration(bc, false);
for (DeployConfiguration *dc : target->deployConfigurations())
removedDeployConfiguration(dc, false);
for (RunConfiguration *rc : target->runConfigurations())
removedRunConfiguration(rc, false);
}
@@ -1053,6 +1049,9 @@ void MiniProjectTargetSelector::addedBuildConfiguration(BuildConfiguration *bc,
if (!m_project || bc->target() != m_project->activeTarget())
return;
for (DeployConfiguration *dc : bc->deployConfigurations())
addedDeployConfiguration(dc, false);
m_listWidgets[BUILD]->addProjectConfiguration(bc);
if (update)
updateBuildListVisible();
@@ -1063,6 +1062,9 @@ void MiniProjectTargetSelector::removedBuildConfiguration(BuildConfiguration *bc
if (!m_project || bc->target() != m_project->activeTarget())
return;
for (DeployConfiguration *dc : bc->deployConfigurations())
removedDeployConfiguration(dc, false);
m_listWidgets[BUILD]->removeProjectConfiguration(bc);
if (update)
updateBuildListVisible();
@@ -1070,7 +1072,7 @@ void MiniProjectTargetSelector::removedBuildConfiguration(BuildConfiguration *bc
void MiniProjectTargetSelector::addedDeployConfiguration(DeployConfiguration *dc, bool update)
{
if (!m_project || dc->target() != m_project->activeTarget())
if (!m_project || dc->buildConfiguration() != m_project->activeBuildConfiguration())
return;
m_listWidgets[DEPLOY]->addProjectConfiguration(dc);
@@ -1080,7 +1082,7 @@ void MiniProjectTargetSelector::addedDeployConfiguration(DeployConfiguration *dc
void MiniProjectTargetSelector::removedDeployConfiguration(DeployConfiguration *dc, bool update)
{
if (!m_project || dc->target() != m_project->activeTarget())
if (!m_project || dc->buildConfiguration() != m_project->activeBuildConfiguration())
return;
m_listWidgets[DEPLOY]->removeProjectConfiguration(dc);
@@ -1154,8 +1156,10 @@ void MiniProjectTargetSelector::updateDeployListVisible()
int maxCount = 0;
for (Project *p : ProjectManager::projects()) {
const QList<Target *> targets = p->targets();
for (Target *t : targets)
maxCount = qMax(t->deployConfigurations().size(), maxCount);
for (Target *t : targets) {
for (const BuildConfiguration * const bc : t->buildConfigurations())
maxCount = qMax(bc->deployConfigurations().size(), maxCount);
}
}
bool visible = maxCount > 1;
@@ -1246,25 +1250,13 @@ void MiniProjectTargetSelector::activeTargetChanged(Target *target)
for (BuildConfiguration *bc : target->buildConfigurations())
bl.append(bc);
m_listWidgets[BUILD]->setProjectConfigurations(bl, target->activeBuildConfiguration());
QObjectList dl;
for (DeployConfiguration *dc : target->deployConfigurations())
dl.append(dc);
m_listWidgets[DEPLOY]->setProjectConfigurations(dl, target->activeDeployConfiguration());
activeBuildConfigurationChanged(target->activeBuildConfiguration());
QObjectList rl;
for (RunConfiguration *rc : target->runConfigurations())
rl.append(rc);
m_listWidgets[RUN]->setProjectConfigurations(rl, target->activeRunConfiguration());
m_buildConfiguration = m_target->activeBuildConfiguration();
if (m_buildConfiguration)
connect(m_buildConfiguration, &ProjectConfiguration::displayNameChanged,
this, &MiniProjectTargetSelector::updateActionAndSummary);
m_deployConfiguration = m_target->activeDeployConfiguration();
if (m_deployConfiguration)
connect(m_deployConfiguration, &ProjectConfiguration::displayNameChanged,
this, &MiniProjectTargetSelector::updateActionAndSummary);
m_runConfiguration = m_target->activeRunConfiguration();
if (m_runConfiguration)
connect(m_runConfiguration, &ProjectConfiguration::displayNameChanged,
@@ -1299,13 +1291,25 @@ void MiniProjectTargetSelector::kitChanged(Kit *k)
void MiniProjectTargetSelector::activeBuildConfigurationChanged(BuildConfiguration *bc)
{
if (m_buildConfiguration)
if (m_buildConfiguration) {
disconnect(m_buildConfiguration, &ProjectConfiguration::displayNameChanged,
this, &MiniProjectTargetSelector::updateActionAndSummary);
}
m_buildConfiguration = bc;
if (m_buildConfiguration)
connect(m_buildConfiguration, &ProjectConfiguration::displayNameChanged,
this, &MiniProjectTargetSelector::updateActionAndSummary);
if (m_buildConfiguration) {
QObjectList dl;
for (DeployConfiguration *dc : bc->deployConfigurations())
dl.append(dc);
m_listWidgets[DEPLOY]->setProjectConfigurations(dl, bc->activeDeployConfiguration());
activeDeployConfigurationChanged(m_buildConfiguration->activeDeployConfiguration());
} else {
m_listWidgets[DEPLOY]->setProjectConfigurations({}, nullptr);
activeDeployConfigurationChanged(nullptr);
}
m_listWidgets[BUILD]->setActiveProjectConfiguration(bc);
updateActionAndSummary();
}

1
src/plugins/projectexplorer/miniprojecttargetselector.h
View File

@@ -40,6 +40,7 @@ public:
void nextOrShow();
private:
friend class ProjectExplorer::BuildConfiguration;
friend class ProjectExplorer::Target;
void projectAdded(ProjectExplorer::Project *project);
void projectRemoved(ProjectExplorer::Project *project);

34
src/plugins/projectexplorer/project.cpp
View File

@@ -299,7 +299,6 @@ Target *Project::addTargetForKit(Kit *kit)
t->updateDefaultBuildConfigurations();
QTC_ASSERT(!t->buildConfigurations().isEmpty(), return nullptr);
t->updateDefaultDeployConfigurations();
t->updateDefaultRunConfigurations();
addTarget(std::move(t));
@@ -541,6 +540,7 @@ bool Project::copySteps(Target *sourceTarget, Target *newTarget)
QStringList runconfigurationError;
const Project * const project = newTarget->project();
int dcCount = 0;
for (BuildConfiguration *sourceBc : sourceTarget->buildConfigurations()) {
BuildConfiguration *newBc = sourceBc->clone(newTarget);
if (!newBc) {
@@ -556,28 +556,29 @@ bool Project::copySteps(Target *sourceTarget, Target *newTarget)
newTarget->addBuildConfiguration(newBc);
if (sourceTarget->activeBuildConfiguration() == sourceBc)
newTarget->setActiveBuildConfiguration(newBc, SetActive::NoCascade);
}
if (!newTarget->activeBuildConfiguration()) {
QList<BuildConfiguration *> bcs = newTarget->buildConfigurations();
if (!bcs.isEmpty())
newTarget->setActiveBuildConfiguration(bcs.first(), SetActive::NoCascade);
}
for (DeployConfiguration *sourceDc : sourceTarget->deployConfigurations()) {
DeployConfiguration *newDc = DeployConfigurationFactory::clone(newTarget, sourceDc);
for (DeployConfiguration *sourceDc : sourceBc->deployConfigurations()) {
++dcCount;
DeployConfiguration *newDc = DeployConfigurationFactory::clone(newBc, sourceDc);
if (!newDc) {
deployconfigurationError << sourceDc->displayName();
continue;
}
newDc->setDisplayName(sourceDc->displayName());
newTarget->addDeployConfiguration(newDc);
if (sourceTarget->activeDeployConfiguration() == sourceDc)
newTarget->setActiveDeployConfiguration(newDc, SetActive::NoCascade);
newBc->addDeployConfiguration(newDc);
if (sourceBc->activeDeployConfiguration() == sourceDc)
newBc->setActiveDeployConfiguration(newDc, SetActive::NoCascade);
}
if (!newTarget->activeDeployConfiguration()) {
QList<DeployConfiguration *> dcs = newBc->deployConfigurations();
if (!dcs.isEmpty())
newBc->setActiveDeployConfiguration(dcs.first(), SetActive::NoCascade);
}
}
if (!newTarget->activeBuildConfiguration()) {
QList<DeployConfiguration *> dcs = newTarget->deployConfigurations();
if (!dcs.isEmpty())
newTarget->setActiveDeployConfiguration(dcs.first(), SetActive::NoCascade);
QList<BuildConfiguration *> bcs = newTarget->buildConfigurations();
if (!bcs.isEmpty())
newTarget->setActiveBuildConfiguration(bcs.first(), SetActive::NoCascade);
}
for (RunConfiguration *sourceRc : sourceTarget->runConfigurations()) {
@@ -600,7 +601,7 @@ bool Project::copySteps(Target *sourceTarget, Target *newTarget)
if (buildconfigurationError.count() == sourceTarget->buildConfigurations().count())
fatalError = true;
if (deployconfigurationError.count() == sourceTarget->deployConfigurations().count())
if (deployconfigurationError.count() == dcCount)
fatalError = true;
if (runconfigurationError.count() == sourceTarget->runConfigurations().count())
@@ -1134,7 +1135,6 @@ BuildConfiguration *Project::setup(const BuildInfo &info)
t->addBuildConfiguration(bc);
}
if (newTarget) {
newTarget->updateDefaultDeployConfigurations();
newTarget->updateDefaultRunConfigurations();
addTarget(std::move(newTarget));
}

79
src/plugins/projectexplorer/runsettingspropertiespage.cpp
View File

@@ -13,9 +13,6 @@
#include "runconfiguration.h"
#include "target.h"
#include <coreplugin/session.h>
#include <utils/algorithm.h>
#include <utils/guiutils.h>
#include <utils/qtcassert.h>
#include <utils/stringutils.h>
@@ -107,24 +104,12 @@ RunSettingsWidget::RunSettingsWidget(Target *target) :
m_deployLayout->setContentsMargins(0, 0, 0, 0);
m_deployLayout->setSpacing(5);
m_deployConfigurationCombo->setModel(m_target->deployConfigurationModel());
m_addDeployMenu = new QMenu(m_addDeployToolButton);
m_addDeployToolButton->setMenu(m_addDeployMenu);
updateDeployConfiguration(m_target->activeDeployConfiguration());
// Some projects may not support deployment, so we need this:
m_addDeployToolButton->setEnabled(m_target->activeDeployConfiguration());
m_deployConfigurationCombo->setEnabled(m_target->activeDeployConfiguration());
m_removeDeployToolButton->setEnabled(m_target->deployConfigurations().count() > 1);
m_renameDeployButton->setEnabled(m_target->activeDeployConfiguration());
initForActiveBuildConfig();
connect(m_addDeployMenu, &QMenu::aboutToShow,
this, &RunSettingsWidget::aboutToShowDeployMenu);
connect(m_deployConfigurationCombo, &QComboBox::currentIndexChanged,
this, &RunSettingsWidget::currentDeployConfigurationChanged);
connect(m_removeDeployToolButton, &QAbstractButton::clicked,
this, &RunSettingsWidget::removeDeployConfiguration);
connect(m_renameDeployButton, &QAbstractButton::clicked,
@@ -133,6 +118,9 @@ RunSettingsWidget::RunSettingsWidget(Target *target) :
connect(m_target, &Target::activeDeployConfigurationChanged,
this, &RunSettingsWidget::activeDeployConfigurationChanged);
connect(m_target, &Target::activeBuildConfigurationChanged,
this, &RunSettingsWidget::initForActiveBuildConfig);
// run part
runWidget->setContentsMargins(0, 10, 0, 0);
m_runLayout = new QVBoxLayout(runWidget);
@@ -315,10 +303,12 @@ void RunSettingsWidget::currentDeployConfigurationChanged(int index)
{
if (m_ignoreChanges.isLocked())
return;
if (index == -1)
m_target->setActiveDeployConfiguration(nullptr, SetActive::Cascade);
else
m_target->setActiveDeployConfiguration(qobject_cast<DeployConfiguration *>(m_target->deployConfigurationModel()->projectConfigurationAt(index)),
BuildConfiguration * const bc = m_target->activeBuildConfiguration();
QTC_ASSERT(bc, return);
QTC_ASSERT(index != -1, bc->setActiveDeployConfiguration(nullptr, SetActive::Cascade); return);
bc->setActiveDeployConfiguration(
qobject_cast<DeployConfiguration *>(
bc->deployConfigurationModel()->projectConfigurationAt(index)),
SetActive::Cascade);
}
@@ -329,12 +319,13 @@ void RunSettingsWidget::aboutToShowDeployMenu()
for (DeployConfigurationFactory *factory : DeployConfigurationFactory::find(m_target)) {
QAction *action = m_addDeployMenu->addAction(factory->defaultDisplayName());
connect(action, &QAction::triggered, this, [factory, this] {
DeployConfiguration *newDc = factory->create(m_target);
BuildConfiguration * const bc = m_target->activeBuildConfiguration();
DeployConfiguration *newDc = factory->create(bc);
if (!newDc)
return;
m_target->addDeployConfiguration(newDc);
m_target->setActiveDeployConfiguration(newDc, SetActive::Cascade);
m_removeDeployToolButton->setEnabled(m_target->deployConfigurations().size() > 1);
bc->addDeployConfiguration(newDc);
bc->setActiveDeployConfiguration(newDc, SetActive::Cascade);
m_removeDeployToolButton->setEnabled(bc->deployConfigurations().size() > 1);
});
}
}
@@ -364,9 +355,11 @@ void RunSettingsWidget::removeDeployConfiguration()
return;
}
m_target->removeDeployConfiguration(dc);
BuildConfiguration * const bc = m_target->activeBuildConfiguration();
QTC_ASSERT(bc, return);
bc->removeDeployConfiguration(dc);
m_removeDeployToolButton->setEnabled(m_target->deployConfigurations().size() > 1);
m_removeDeployToolButton->setEnabled(bc->deployConfigurations().size() > 1);
}
void RunSettingsWidget::activeDeployConfigurationChanged()
@@ -391,9 +384,31 @@ void RunSettingsWidget::renameDeployConfiguration()
m_target->activeDeployConfiguration()->setDisplayName(name);
}
void RunSettingsWidget::initForActiveBuildConfig()
{
disconnect(m_deployConfigurationCombo, &QComboBox::currentIndexChanged,
this, &RunSettingsWidget::currentDeployConfigurationChanged);
m_deployConfigurationCombo->setModel(
m_target->activeBuildConfiguration()->deployConfigurationModel());
connect(m_deployConfigurationCombo, &QComboBox::currentIndexChanged,
this, &RunSettingsWidget::currentDeployConfigurationChanged);
// Some projects may not support deployment, so we need this:
// FIXME: Not true anymore? There should always be an active deploy config.
m_addDeployToolButton->setEnabled(m_target->activeDeployConfiguration());
m_deployConfigurationCombo->setEnabled(m_target->activeDeployConfiguration());
m_renameDeployButton->setEnabled(m_target->activeDeployConfiguration());
m_removeDeployToolButton->setEnabled(
m_target->activeBuildConfiguration()->deployConfigurations().count() > 1);
updateDeployConfiguration(m_target->activeDeployConfiguration());
}
void RunSettingsWidget::updateRemoveToolButtons()
{
m_removeDeployToolButton->setEnabled(m_target->deployConfigurations().count() > 1);
const BuildConfiguration * const bc = m_target->activeBuildConfiguration();
QTC_ASSERT(bc, return);
m_removeDeployToolButton->setEnabled(bc->deployConfigurations().count() > 1);
const bool hasRunConfigs = !m_target->runConfigurations().isEmpty();
m_removeRunToolButton->setEnabled(hasRunConfigs);
m_removeAllRunConfigsButton->setEnabled(hasRunConfigs);
@@ -416,7 +431,9 @@ void RunSettingsWidget::updateDeployConfiguration(DeployConfiguration *dc)
if (!dc)
return;
int index = m_target->deployConfigurationModel()->indexFor(dc);
const BuildConfiguration * const bc = m_target->activeBuildConfiguration();
QTC_ASSERT(bc, return);
int index = bc->deployConfigurationModel()->indexFor(dc);
{
const Utils::GuardLocker locker(m_ignoreChanges);
@@ -457,9 +474,11 @@ QString RunSettingsWidget::uniqueDCName(const QString &name)
QString result = name.trimmed();
if (!result.isEmpty()) {
QStringList dcNames;
const QList<DeployConfiguration *> configurations = m_target->deployConfigurations();
const BuildConfiguration * const bc = m_target->activeBuildConfiguration();
QTC_ASSERT(bc, return name);
const QList<DeployConfiguration *> configurations = bc->deployConfigurations();
for (DeployConfiguration *dc : configurations) {
if (dc == m_target->activeDeployConfiguration())
if (dc == bc->activeDeployConfiguration())
continue;
dcNames.append(dc->displayName());
}

1
src/plugins/projectexplorer/runsettingspropertiespage.h
View File

@@ -49,6 +49,7 @@ private:
void removeDeployConfiguration();
void activeDeployConfigurationChanged();
void renameDeployConfiguration();
void initForActiveBuildConfig();
void updateRemoveToolButtons();

224
src/plugins/projectexplorer/target.cpp
View File

@@ -25,8 +25,6 @@
#include "projectmanager.h"
#include "runconfiguration.h"
#include <coreplugin/coreconstants.h>
#include <utils/algorithm.h>
#include <utils/commandline.h>
#include <utils/macroexpander.h>
@@ -37,8 +35,6 @@
#include <QIcon>
#include <QPainter>
#include <limits>
using namespace Utils;
namespace ProjectExplorer {
@@ -47,15 +43,13 @@ const char ACTIVE_BC_KEY[] = "ProjectExplorer.Target.ActiveBuildConfiguration";
const char BC_KEY_PREFIX[] = "ProjectExplorer.Target.BuildConfiguration.";
const char BC_COUNT_KEY[] = "ProjectExplorer.Target.BuildConfigurationCount";
const char ACTIVE_DC_KEY[] = "ProjectExplorer.Target.ActiveDeployConfiguration";
const char DC_KEY_PREFIX[] = "ProjectExplorer.Target.DeployConfiguration.";
const char DC_COUNT_KEY[] = "ProjectExplorer.Target.DeployConfigurationCount";
const char ACTIVE_RC_KEY[] = "ProjectExplorer.Target.ActiveRunConfiguration";
const char RC_KEY_PREFIX[] = "ProjectExplorer.Target.RunConfiguration.";
const char RC_COUNT_KEY[] = "ProjectExplorer.Target.RunConfigurationCount";
const char PLUGIN_SETTINGS_KEY[] = "ProjectExplorer.Target.PluginSettings";
const char HAS_PER_BC_DCS[] = "HasPerBcDcs";
static QString formatDeviceInfo(const ProjectExplorer::IDevice::DeviceInfo &input)
{
const QStringList lines
@@ -75,7 +69,6 @@ public:
TargetPrivate(Target *t, Kit *k) :
m_kit(k),
m_buildConfigurationModel(t),
m_deployConfigurationModel(t),
m_runConfigurationModel(t)
{ }
@@ -83,8 +76,6 @@ public:
QList<BuildConfiguration *> m_buildConfigurations;
QPointer<BuildConfiguration> m_activeBuildConfiguration;
QList<DeployConfiguration *> m_deployConfigurations;
DeployConfiguration *m_activeDeployConfiguration = nullptr;
QList<RunConfiguration *> m_runConfigurations;
RunConfiguration* m_activeRunConfiguration = nullptr;
Store m_pluginSettings;
@@ -93,7 +84,6 @@ public:
MacroExpander m_macroExpander;
ProjectConfigurationModel m_buildConfigurationModel;
ProjectConfigurationModel m_deployConfigurationModel;
ProjectConfigurationModel m_runConfigurationModel;
bool m_shuttingDown = false;
@@ -144,7 +134,6 @@ Target::Target(Project *project, Kit *k, _constructor_tag) :
Target::~Target()
{
qDeleteAll(d->m_buildConfigurations);
qDeleteAll(d->m_deployConfigurations);
qDeleteAll(d->m_runConfigurations);
}
@@ -254,38 +243,26 @@ void Target::setActiveBuildConfiguration(BuildConfiguration *bc, SetActive casca
}
}
void Target::setActiveDeployConfiguration(DeployConfiguration *dc, SetActive cascade)
void Target::setActiveDeployConfiguration(DeployConfiguration *dc)
{
QTC_ASSERT(project(), return);
if (project()->isShuttingDown() || isShuttingDown())
for (BuildConfiguration * const bc : std::as_const(d->m_buildConfigurations)) {
if (bc->deployConfigurations().contains(dc)) {
bc->setActiveDeployConfiguration(dc);
if (bc != d->m_activeBuildConfiguration)
setActiveBuildConfiguration(bc, SetActive::NoCascade);
return;
setActiveDeployConfiguration(dc);
if (!dc)
return;
if (cascade != SetActive::Cascade || !ProjectManager::isProjectConfigurationCascading())
return;
Id kitId = kit()->id();
QString name = dc->displayName(); // We match on displayname
for (Project *otherProject : ProjectManager::projects()) {
if (otherProject == project())
continue;
Target *otherTarget = otherProject->activeTarget();
if (!otherTarget || otherTarget->kit()->id() != kitId)
continue;
for (DeployConfiguration *otherDc : otherTarget->deployConfigurations()) {
if (otherDc->displayName() == name) {
otherTarget->setActiveDeployConfiguration(otherDc);
break;
}
}
}
}
QList<DeployConfiguration *> Target::deployConfigurations() const
{
QList<DeployConfiguration *> dcs;
for (BuildConfiguration * const bc : std::as_const(d->m_buildConfigurations))
dcs << bc->deployConfigurations();
return dcs;
}
Utils::Id Target::id() const
{
return d->m_kit->id();
@@ -327,6 +304,8 @@ void Target::addBuildConfiguration(BuildConfiguration *bc)
bc->setDisplayName(configurationDisplayName);
}
bc->updateDefaultDeployConfigurations();
// add it
d->m_buildConfigurations.push_back(bc);
@@ -374,6 +353,12 @@ BuildConfiguration *Target::activeBuildConfiguration() const
return d->m_activeBuildConfiguration;
}
DeployConfiguration *Target::activeDeployConfiguration() const
{
QTC_ASSERT(activeBuildConfiguration(), return nullptr);
return activeBuildConfiguration()->activeDeployConfiguration();
}
void Target::setActiveBuildConfiguration(BuildConfiguration *bc)
{
if ((!bc && d->m_buildConfigurations.isEmpty()) ||
@@ -385,80 +370,6 @@ void Target::setActiveBuildConfiguration(BuildConfiguration *bc)
}
}
void Target::addDeployConfiguration(DeployConfiguration *dc)
{
QTC_ASSERT(dc && !d->m_deployConfigurations.contains(dc), return);
Q_ASSERT(dc->target() == this);
// Check that we don't have a configuration with the same displayName
QString configurationDisplayName = dc->displayName();
QStringList displayNames = Utils::transform(d->m_deployConfigurations, &DeployConfiguration::displayName);
configurationDisplayName = Utils::makeUniquelyNumbered(configurationDisplayName, displayNames);
dc->setDisplayName(configurationDisplayName);
// add it
d->m_deployConfigurations.push_back(dc);
ProjectExplorerPlugin::targetSelector()->addedDeployConfiguration(dc);
d->m_deployConfigurationModel.addProjectConfiguration(dc);
emit addedDeployConfiguration(dc);
if (!d->m_activeDeployConfiguration)
setActiveDeployConfiguration(dc);
Q_ASSERT(activeDeployConfiguration());
}
bool Target::removeDeployConfiguration(DeployConfiguration *dc)
{
//todo: this might be error prone
if (!d->m_deployConfigurations.contains(dc))
return false;
if (BuildManager::isBuilding(dc))
return false;
d->m_deployConfigurations.removeOne(dc);
if (activeDeployConfiguration() == dc) {
if (d->m_deployConfigurations.isEmpty())
setActiveDeployConfiguration(nullptr, SetActive::Cascade);
else
setActiveDeployConfiguration(d->m_deployConfigurations.at(0), SetActive::Cascade);
}
ProjectExplorerPlugin::targetSelector()->removedDeployConfiguration(dc);
d->m_deployConfigurationModel.removeProjectConfiguration(dc);
emit removedDeployConfiguration(dc);
delete dc;
return true;
}
const QList<DeployConfiguration *> Target::deployConfigurations() const
{
return d->m_deployConfigurations;
}
DeployConfiguration *Target::activeDeployConfiguration() const
{
return d->m_activeDeployConfiguration;
}
void Target::setActiveDeployConfiguration(DeployConfiguration *dc)
{
if (dc) {
QTC_ASSERT(d->m_deployConfigurations.contains(dc), return);
} else {
QTC_ASSERT(d->m_deployConfigurations.isEmpty(), return);
}
if (dc == d->m_activeDeployConfiguration)
return;
d->m_activeDeployConfiguration = dc;
emit activeDeployConfigurationChanged(d->m_activeDeployConfiguration);
updateDeviceState(); // FIXME: Does not belong here?
}
const QList<RunConfiguration *> Target::runConfigurations() const
{
return d->m_runConfigurations;
@@ -592,14 +503,11 @@ Store Target::toMap() const
map.insert(numberedKey(BC_KEY_PREFIX, i), variantFromStore(data));
}
const QList<DeployConfiguration *> dcs = deployConfigurations();
map.insert(ACTIVE_DC_KEY, dcs.indexOf(d->m_activeDeployConfiguration));
map.insert(DC_COUNT_KEY, dcs.size());
for (int i = 0; i < dcs.size(); ++i) {
Store data;
dcs.at(i)->toMap(data);
map.insert(numberedKey(DC_KEY_PREFIX, i), variantFromStore(data));
}
// Forward compatibility for Qt Creator < 17: Store the active build configuration's
// deploy configurations as the target-global ones. A special tag signifies that
// we should not read these ourselves.
d->m_activeBuildConfiguration->storeConfigurationsToMap(map);
map.insert(HAS_PER_BC_DCS, true);
const QList<RunConfiguration *> rcs = runConfigurations();
map.insert(ACTIVE_RC_KEY, rcs.indexOf(d->m_activeRunConfiguration));
@@ -631,37 +539,8 @@ void Target::updateDefaultBuildConfigurations()
void Target::updateDefaultDeployConfigurations()
{
const QList<DeployConfigurationFactory *> dcFactories = DeployConfigurationFactory::find(this);
if (dcFactories.isEmpty()) {
qWarning("No deployment configuration factory found for target id '%s'.", qPrintable(id().toString()));
return;
}
QList<Utils::Id> dcIds;
for (const DeployConfigurationFactory *dcFactory : dcFactories)
dcIds.append(dcFactory->creationId());
const QList<DeployConfiguration *> dcList = deployConfigurations();
QList<Utils::Id> toCreate = dcIds;
for (DeployConfiguration *dc : dcList) {
if (dcIds.contains(dc->id()))
toCreate.removeOne(dc->id());
else
removeDeployConfiguration(dc);
}
for (Utils::Id id : std::as_const(toCreate)) {
for (DeployConfigurationFactory *dcFactory : dcFactories) {
if (dcFactory->creationId() == id) {
DeployConfiguration *dc = dcFactory->create(this);
if (dc) {
QTC_CHECK(dc->id() == id);
addDeployConfiguration(dc);
}
}
}
}
for (BuildConfiguration * const bc : std::as_const(d->m_buildConfigurations))
bc->updateDefaultDeployConfigurations();
}
void Target::updateDefaultRunConfigurations()
@@ -828,11 +707,6 @@ ProjectConfigurationModel *Target::buildConfigurationModel() const
return &d->m_buildConfigurationModel;
}
ProjectConfigurationModel *Target::deployConfigurationModel() const
{
return &d->m_deployConfigurationModel;
}
ProjectConfigurationModel *Target::runConfigurationModel() const
{
return &d->m_runConfigurationModel;
@@ -897,6 +771,7 @@ bool Target::addConfigurationsFromMap(const Utils::Store &map, bool setActiveCon
if (!setActiveConfigurations)
activeConfiguration = -1;
const bool hasDeployConfigsPerBuildConfig = map.value(HAS_PER_BC_DCS).toBool();
for (int i = 0; i < bcCount; ++i) {
const Key key = numberedKey(BC_KEY_PREFIX, i);
if (!map.contains(key))
@@ -908,38 +783,19 @@ bool Target::addConfigurationsFromMap(const Utils::Store &map, bool setActiveCon
continue;
}
QTC_CHECK(bc->id() == ProjectExplorer::idFromMap(valueMap));
// Pre-17 backward compatibility: Give each build config the formerly target-global deploy
// configurations.
if (!hasDeployConfigsPerBuildConfig) {
if (!bc->addConfigurationsFromMap(map, true))
return false;
}
addBuildConfiguration(bc);
if (i == activeConfiguration)
setActiveBuildConfiguration(bc);
}
int dcCount = map.value(DC_COUNT_KEY, 0).toInt(&ok);
if (!ok || dcCount < 0)
dcCount = 0;
activeConfiguration = map.value(ACTIVE_DC_KEY, 0).toInt(&ok);
if (!ok || 0 > activeConfiguration || dcCount < activeConfiguration)
activeConfiguration = 0;
if (!setActiveConfigurations)
activeConfiguration = -1;
for (int i = 0; i < dcCount; ++i) {
const Key key = numberedKey(DC_KEY_PREFIX, i);
if (!map.contains(key))
return false;
Store valueMap = storeFromVariant(map.value(key));
DeployConfiguration *dc = DeployConfigurationFactory::restore(this, valueMap);
if (!dc) {
Utils::Id id = idFromMap(valueMap);
qWarning("No factory found to restore deployment configuration of id '%s'!",
id.isValid() ? qPrintable(id.toString()) : "UNKNOWN");
continue;
}
QTC_CHECK(dc->id() == ProjectExplorer::idFromMap(valueMap));
addDeployConfiguration(dc);
if (i == activeConfiguration)
setActiveDeployConfiguration(dc);
}
int rcCount = map.value(RC_COUNT_KEY, 0).toInt(&ok);
if (!ok || rcCount < 0)
rcCount = 0;

13
src/plugins/projectexplorer/target.h
View File

@@ -64,12 +64,6 @@ public:
const QList<BuildConfiguration *> buildConfigurations() const;
BuildConfiguration *activeBuildConfiguration() const;
// DeployConfiguration
void addDeployConfiguration(DeployConfiguration *dc);
bool removeDeployConfiguration(DeployConfiguration *dc);
const QList<DeployConfiguration *> deployConfigurations() const;
DeployConfiguration *activeDeployConfiguration() const;
// Running
@@ -100,7 +94,6 @@ public:
Utils::MacroExpander *macroExpander() const;
ProjectConfigurationModel *buildConfigurationModel() const;
ProjectConfigurationModel *deployConfigurationModel() const;
ProjectConfigurationModel *runConfigurationModel() const;
DeploymentData deploymentData() const;
@@ -110,7 +103,10 @@ public:
QString activeBuildKey() const; // Build key of active run configuaration
void setActiveBuildConfiguration(BuildConfiguration *bc, SetActive cascade);
void setActiveDeployConfiguration(DeployConfiguration *dc, SetActive cascade);
// Do not use, only for QtAM.
void setActiveDeployConfiguration(DeployConfiguration *dc);
QList<DeployConfiguration *> deployConfigurations() const;
signals:
void targetEnabled(bool);
@@ -153,7 +149,6 @@ private:
void handleKitRemoval(ProjectExplorer::Kit *k);
void setActiveBuildConfiguration(BuildConfiguration *configuration);
void setActiveDeployConfiguration(DeployConfiguration *configuration);
const std::unique_ptr<TargetPrivate> d;
friend class Project;

4
src/plugins/qtapplicationmanager/appmanagercmakepackagestep.cpp
View File

@@ -11,7 +11,7 @@
#include <projectexplorer/buildstep.h>
#include <projectexplorer/deployconfiguration.h>
#include <projectexplorer/processparameters.h>
#include <projectexplorer/project.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/target.h>
@@ -31,7 +31,7 @@ public:
setExtraInit([] (BuildStep *step) {
// We update the build targets when the active run configuration changes
const auto updaterSlot = [step] {
const TargetInformation targetInformation(step->target());
const TargetInformation targetInformation(step->buildConfiguration());
step->setBuildTargets({targetInformation.cmakeBuildTarget});
step->setStepEnabled(!targetInformation.isBuiltin);
};

6
src/plugins/qtapplicationmanager/appmanagerdeployconfigurationautoswitcher.cpp
View File

@@ -80,7 +80,7 @@ void AppManagerDeployConfigurationAutoSwitcher::onActiveRunConfigurationChanged(
if (stored) {
// deploy selection stored -> restore
auto deployConfiguration = m_deployConfigurationsUsageHistory.value(runConfiguration, nullptr);
target->setActiveDeployConfiguration(deployConfiguration, SetActive::NoCascade);
target->setActiveDeployConfiguration(deployConfiguration);
} else if (auto activeDeployConfiguration = target->activeDeployConfiguration()) {
// active deploy configuration exists
if (isApplicationManagerRunConfiguration(runConfiguration)) {
@@ -91,7 +91,7 @@ void AppManagerDeployConfigurationAutoSwitcher::onActiveRunConfigurationChanged(
// find AM deploy configuration
if (isApplicationManagerDeployConfiguration(deployConfiguration)) {
// make it active
target->setActiveDeployConfiguration(deployConfiguration, SetActive::NoCascade);
target->setActiveDeployConfiguration(deployConfiguration);
break;
}
}
@@ -104,7 +104,7 @@ void AppManagerDeployConfigurationAutoSwitcher::onActiveRunConfigurationChanged(
// find not AM deploy configuration
if (!isApplicationManagerDeployConfiguration(deployConfiguration)) {
// make it active
target->setActiveDeployConfiguration(deployConfiguration, SetActive::NoCascade);
target->setActiveDeployConfiguration(deployConfiguration);
break;
}
}

4
src/plugins/qtapplicationmanager/appmanagerdeploypackagestep.cpp
View File

@@ -51,7 +51,7 @@ public:
if (customizeStep.value())
return;
const TargetInformation targetInformation(target());
const TargetInformation targetInformation(buildConfiguration());
packageFilePath.setValue(targetInformation.packageFilePath);
packageFilePath.setDefaultValue(packageFilePath.value());
@@ -75,7 +75,7 @@ public:
private:
bool init() final
{
return TargetInformation(target()).isValid();
return TargetInformation(buildConfiguration()).isValid();
}
GroupItem runRecipe() final

5
src/plugins/qtapplicationmanager/appmanagerinstallpackagestep.cpp
View File

@@ -17,7 +17,6 @@
#include <projectexplorer/deployconfiguration.h>
#include <projectexplorer/devicesupport/devicekitaspects.h>
#include <projectexplorer/devicesupport/idevice.h>
#include <projectexplorer/processparameters.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/target.h>
#include <projectexplorer/runconfigurationaspects.h>
@@ -72,7 +71,7 @@ AppManagerInstallPackageStep::AppManagerInstallPackageStep(BuildStepList *bsl, I
if (customizeStep.value())
return;
const TargetInformation targetInformation(target());
const TargetInformation targetInformation(buildConfiguration());
IDeviceConstPtr device = RunDeviceKitAspect::device(kit());
if (device && device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE) {
@@ -97,7 +96,7 @@ AppManagerInstallPackageStep::AppManagerInstallPackageStep(BuildStepList *bsl, I
GroupItem AppManagerInstallPackageStep::deployRecipe()
{
const TargetInformation targetInformation(target());
const TargetInformation targetInformation(buildConfiguration());
const FilePath controllerPath = controller().isEmpty() ?
FilePath::fromString(controller.defaultValue()) :

8
src/plugins/qtapplicationmanager/appmanagerrunconfiguration.cpp
View File

@@ -36,7 +36,8 @@ public:
setDefaultDisplayName(Tr::tr("Run an Application Manager Package"));
setUpdater([this, target] {
QList<TargetInformation> tis = TargetInformation::readFromProject(target, buildKey());
QList<TargetInformation> tis
= TargetInformation::readFromProject(target->activeBuildConfiguration(), buildKey());
if (tis.isEmpty())
return;
const TargetInformation targetInformation = tis.at(0);
@@ -87,7 +88,8 @@ public:
virtual bool supportsBuildKey(Target *target, const QString &key) const final
{
QList<TargetInformation> tis = TargetInformation::readFromProject(target, key);
QList<TargetInformation> tis
= TargetInformation::readFromProject(target->activeBuildConfiguration(), key);
return !tis.isEmpty();
}
@@ -103,7 +105,7 @@ public:
target->project(), &Project::displayNameChanged,
Qt::UniqueConnection);
const auto buildTargets = TargetInformation::readFromProject(target);
const auto buildTargets = TargetInformation::readFromProject(target->activeBuildConfiguration());
const auto filteredTargets = Utils::filtered(buildTargets, [this, target](const TargetInformation &ti) {
return filterTarget(target, ti);
});

6
src/plugins/qtapplicationmanager/appmanagerruncontrol.cpp
View File

@@ -13,7 +13,6 @@
#include <debugger/debuggerengine.h>
#include <debugger/debuggerruncontrol.h>
#include <debugger/debuggerkitaspect.h>
#include <perfprofiler/perfprofilerconstants.h>
@@ -28,13 +27,12 @@
#include <projectexplorer/runcontrol.h>
#include <projectexplorer/sysrootkitaspect.h>
#include <projectexplorer/target.h>
#include <projectexplorer/toolchain.h>
#include <qtsupport/baseqtversion.h>
#include <qtsupport/qtkitaspect.h>
#include <utils/algorithm.h>
#include <utils/qtcprocess.h>
#include <utils/qtcassert.h>
using namespace ProjectExplorer;
using namespace Utils;
@@ -126,7 +124,7 @@ private:
{
Target *target = runControl()->target();
const Internal::TargetInformation targetInformation(target);
const Internal::TargetInformation targetInformation(target->activeBuildConfiguration());
if (!targetInformation.isValid()) {
reportFailure(Tr::tr("Cannot debug: Invalid target information."));
return;

34
src/plugins/qtapplicationmanager/appmanagertargetinformation.cpp
View File

@@ -7,36 +7,34 @@
#include "appmanagerconstants.h"
#include <projectexplorer/buildconfiguration.h>
#include <projectexplorer/buildsystem.h>
#include <projectexplorer/environmentkitaspect.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/project.h>
#include <projectexplorer/runconfiguration.h>
#include <projectexplorer/runcontrol.h>
#include <projectexplorer/target.h>
#include <projectexplorer/taskhub.h>
#include <utils/qtcassert.h>
#include <qmakeprojectmanager/qmakeproject.h>
#include <qtsupport/profilereader.h>
#include <yaml-cpp/yaml.h>
using namespace ProjectExplorer;
using namespace QmakeProjectManager;
using namespace QtSupport;
using namespace Utils;
namespace AppManager {
namespace Internal {
QList<TargetInformation> TargetInformation::readFromProject(const Target *target , const QString &buildKey)
QList<TargetInformation> TargetInformation::readFromProject(
const BuildConfiguration *bc, const QString &buildKey)
{
if (!bc)
return {};
QList<TargetInformation> result;
if (!target->project()->rootProjectNode())
if (!bc->project()->rootProjectNode())
return result;
QVariantList packageTargets = target->project()->extraData(AppManager::Constants::APPMAN_PACKAGE_TARGETS).toList();
QVariantList packageTargets = bc->project()->extraData(AppManager::Constants::APPMAN_PACKAGE_TARGETS).toList();
// qDebug() << "APPMAN TARGETS" << packageTargets;
for (const auto &packageTarget : packageTargets) {
@@ -100,17 +98,17 @@ QList<TargetInformation> TargetInformation::readFromProject(const Target *target
return result;
}
TargetInformation::TargetInformation(const Target *target)
TargetInformation::TargetInformation(const BuildConfiguration *bc)
{
if (!target)
if (!bc)
return;
if (target->buildSystem() && target->buildSystem()->isParsing())
if (bc->buildSystem()->isParsing())
return;
auto project = target->project();
auto project = bc->project();
if (!project)
return;
const RunConfiguration *rc = target->activeRunConfiguration();
const RunConfiguration *rc = bc->target()->activeRunConfiguration();
if (!rc)
return;
if (rc->id() != Constants::RUNCONFIGURATION_ID &&
@@ -121,7 +119,7 @@ TargetInformation::TargetInformation(const Target *target)
if (buildKey.isEmpty())
return;
const auto targetInfoList = TargetInformation::readFromProject(target, buildKey);
const auto targetInfoList = TargetInformation::readFromProject(bc, buildKey);
if (targetInfoList.isEmpty())
return;

7
src/plugins/qtapplicationmanager/appmanagertargetinformation.h
View File

@@ -8,7 +8,7 @@
#include <projectexplorer/devicesupport/idevice.h>
#include <projectexplorer/runcontrol.h>
#include <cmakeprojectmanager/cmakebuildsystem.h>
namespace ProjectExplorer { class BuildConfiguration; }
namespace AppManager {
namespace Internal {
@@ -44,9 +44,10 @@ public:
bool isValid() const;
TargetInformation() = default;
TargetInformation(const ProjectExplorer::Target *target);
TargetInformation(const ProjectExplorer::BuildConfiguration *bc);
static QList<TargetInformation> readFromProject(const ProjectExplorer::Target *target, const QString &buildKey = QString());
static QList<TargetInformation> readFromProject(
const ProjectExplorer::BuildConfiguration *bc, const QString &buildKey = QString());
};
} // namespace Internal