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

ProjectExplorer/all: Re-organize BuildSteps/{Deploy,Build}Config setup

Browse Source 
This follow the rough pattern of recent *RunConfigurationFactory changes
for build and deploy configurations.

- Collapse the two lines of constructors similar to what
  890c1906e6 did for RunConfigurations
  * Deploy* was purely mechanical
  * Build* ctors are split in connects() in the ctor body
    to create "empty shell for clone" etc
    and build step additions in initialize() functions which
    are only used in the create() case.
  -- Allows to collapse the shared 'ctor()' functions, too.

- Move FooBuildConfigurationFactory::create() implementations
  to FooBuildConfiguration() constructor. That was a strange
  and unneeded ping-pong between factories and objects, and
  furthermore allows one level less of indirection (and for a
  later, left out here, some reduction of the
  FooBuildConfiguration interfaces that were only used to
  accommodate the *Factory::create() functions.

- Most {Build,Deploy}Configuration{,Factory} classes had a canHandle(),
  but there wasn't one in the base classses. Have one there.

- Most canHandle() functions were checking simple restrictions on
  e.g. project or target types, specify those by setters in the
  constructors instead and check them in the base canHandle()

- clone() is generally replaced by a creation of a "shell object"
  and a fromMap(source->toMap()), implemented in the base, there
  are two cases left for Android and Qbs that needed(?) some extra
  polish

- generally use canHandle() in base implementation, instead
  of doing that in all Derived::canFoo()

- as a result, canCreate/create/canClone/clone reimplementations
  are not needed anymore, keep the base implementation for
  now (could be inlined into their only users later), but
  de-virtualize them.

- Combine Ios{Preset,DSym}BuildStepFactory. There was only one
  'dsym' build step they could create.

- Split the 'mangled' id into the ProjectConfiguration subtype
  specific constant identifier, and a QString extraId() bit.
  Only maintain the mangled id in saved settings.

- Make ProjectConfiguration::m_id a constant member, adapt
  all constructors of derived classe.

Not done in this patch:

- Finish possible cosmetic changes on top

- Add a way to specify restrictions to supported Qt versions
  (used in Android/Ios), as the base implementation does not
  depend on the qtsupport plugin

- Combine the QList<X> availableFoo() + createFoo(X) function
  pairs to somthing like a direct
   QList<struct { X; std::function<X()>; }> fooCreators()
  to avoid e.g. the baseId.withSuffix() <-> id.suffixAfter(base)
  pingpong

- Remove the *Factories from the global object pool

- Do something about priority(). Falling back to plain
  qmake in android+qmake setup is not helpful.

Change-Id: I2be7d88d554c5aa8b7db8edf5b93278e1ae0112a
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
This commit is contained in:
hjk
2017-11-29 12:28:40 +01:00
parent 9d3c5c6ff5
commit 53a151074a
174 changed files with 2042 additions and 4705 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
src/plugins/qbsprojectmanager/qbsbuildconfiguration.cpp
View File

@@ -52,39 +52,70 @@
#include <QInputDialog>
using namespace ProjectExplorer;
using namespace Utils;
namespace QbsProjectManager {
namespace Internal {
static QString configNameKey() { return QStringLiteral("Qbs.configName"); }
const char QBS_BC_ID[] = "Qbs.QbsBuildConfiguration";
static FileName defaultBuildDirectory(const QString &projectFilePath, const Kit *k,
const QString &bcName,
BuildConfiguration::BuildType buildType)
{
const QString projectName = QFileInfo(projectFilePath).completeBaseName();
ProjectMacroExpander expander(projectFilePath, projectName, k, bcName, buildType);
QString projectDir = Project::projectDirectory(FileName::fromString(projectFilePath)).toString();
QString buildPath = expander.expand(Core::DocumentManager::buildDirectory());
return FileName::fromString(FileUtils::resolvePath(projectDir, buildPath));
}
// ---------------------------------------------------------------------------
// QbsBuildConfiguration:
// ---------------------------------------------------------------------------
QbsBuildConfiguration::QbsBuildConfiguration(Target *target) :
BuildConfiguration(target, Core::Id(QBS_BC_ID)),
m_isParsing(true),
m_parsingError(false)
QbsBuildConfiguration::QbsBuildConfiguration(Target *target)
: BuildConfiguration(target, Constants::QBS_BC_ID)
{
connect(project(), &Project::parsingStarted, this, &BuildConfiguration::enabledChanged);
connect(project(), &Project::parsingFinished, this, &BuildConfiguration::enabledChanged);
BuildStepList *bsl = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
connect(bsl, &BuildStepList::stepInserted, this, &QbsBuildConfiguration::buildStepInserted);
}
QbsBuildConfiguration::QbsBuildConfiguration(Target *target, Core::Id id) :
BuildConfiguration(target, id)
{ }
QbsBuildConfiguration::QbsBuildConfiguration(Target *target, QbsBuildConfiguration *source) :
BuildConfiguration(target, source)
void QbsBuildConfiguration::initialize(const BuildInfo *info)
{
m_configurationName = source->configurationName();
cloneSteps(source);
BuildConfiguration::initialize(info);
const QbsBuildInfo * const bi = static_cast<const QbsBuildInfo *>(info);
QVariantMap configData = bi->config;
configData.insert(QLatin1String(Constants::QBS_CONFIG_VARIANT_KEY),
(info->buildType == BuildConfiguration::Debug)
? QLatin1String(Constants::QBS_VARIANT_DEBUG)
: QLatin1String(Constants::QBS_VARIANT_RELEASE));
Utils::FileName buildDir = info->buildDirectory;
if (buildDir.isEmpty())
buildDir = defaultBuildDirectory(target()->project()->projectDirectory().toString(),
target()->kit(), info->displayName, info->buildType);
// Add the build configuration.
QVariantMap bd = configData;
QString configName = bd.take("configName").toString();
if (configName.isEmpty()) {
configName = "qtc_" + target()->kit()->fileSystemFriendlyName() + '_'
+ Utils::FileUtils::fileSystemFriendlyName(info->displayName);
}
setConfigurationName(configName);
BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
auto bs = new QbsBuildStep(buildSteps);
bs->setQbsConfiguration(bd);
buildSteps->appendStep(bs);
BuildStepList *cleanSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
cleanSteps->appendStep(new QbsCleanStep(cleanSteps));
connect(bs, &QbsBuildStep::qbsConfigurationChanged, this, &QbsBuildConfiguration::qbsConfigurationChanged);
emit qbsConfigurationChanged();
}
bool QbsBuildConfiguration::fromMap(const QVariantMap &map)
@@ -117,15 +148,6 @@ QVariantMap QbsBuildConfiguration::toMap() const
return map;
}
void QbsBuildConfiguration::buildStepInserted(int pos)
{
QbsBuildStep *step = qobject_cast<QbsBuildStep *>(stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD)->at(pos));
if (step) {
connect(step, &QbsBuildStep::qbsConfigurationChanged, this, &QbsBuildConfiguration::qbsConfigurationChanged);
emit qbsConfigurationChanged();
}
}
NamedWidget *QbsBuildConfiguration::createConfigWidget()
{
return new QbsBuildConfigurationWidget(this);
@@ -366,48 +388,15 @@ QString QbsBuildConfiguration::equivalentCommandLine(const BuildStep *buildStep)
return commandLine;
}
QbsBuildConfiguration *QbsBuildConfiguration::setup(Target *t,
const QString &defaultDisplayName,
const QString &displayName,
const QVariantMap &buildData,
const Utils::FileName &directory)
{
// Add the build configuration.
QbsBuildConfiguration *bc = new QbsBuildConfiguration(t);
bc->setDefaultDisplayName(defaultDisplayName);
bc->setDisplayName(displayName);
bc->setBuildDirectory(directory);
QVariantMap bd = buildData;
QString configName = bd.take("configName").toString();
if (configName.isEmpty()) {
configName = "qtc_" + t->kit()->fileSystemFriendlyName() + QLatin1Char('_')
+ Utils::FileUtils::fileSystemFriendlyName(displayName);
}
bc->setConfigurationName(configName);
BuildStepList *buildSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
QbsBuildStep *bs = new QbsBuildStep(buildSteps);
bs->setQbsConfiguration(bd);
buildSteps->insertStep(0, bs);
BuildStepList *cleanSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
QbsCleanStep *cs = new QbsCleanStep(cleanSteps);
cleanSteps->insertStep(0, cs);
return bc;
}
// ---------------------------------------------------------------------------
// QbsBuildConfigurationFactory:
// ---------------------------------------------------------------------------
QbsBuildConfigurationFactory::QbsBuildConfigurationFactory(QObject *parent) :
IBuildConfigurationFactory(parent)
{ }
bool QbsBuildConfigurationFactory::canHandle(const Target *t) const
QbsBuildConfigurationFactory::QbsBuildConfigurationFactory()
{
return qobject_cast<Internal::QbsProject *>(t->project());
registerBuildConfiguration<QbsBuildConfiguration>(Constants::QBS_BC_ID);
setSupportedProjectType(Constants::PROJECT_ID);
setSupportedProjectMimeTypeName(Constants::MIME_TYPE);
}
BuildInfo *QbsBuildConfigurationFactory::createBuildInfo(const Kit *k,
@@ -420,37 +409,9 @@ BuildInfo *QbsBuildConfigurationFactory::createBuildInfo(const Kit *k,
return info;
}
int QbsBuildConfigurationFactory::priority(const Target *parent) const
{
return canHandle(parent) ? 0 : -1;
}
QList<BuildInfo *> QbsBuildConfigurationFactory::availableBuilds(const Target *parent) const
{
QList<BuildInfo *> result;
BuildInfo *info = createBuildInfo(parent->kit(), BuildConfiguration::Debug);
result << info;
return result;
}
int QbsBuildConfigurationFactory::priority(const Kit *k, const QString &projectPath) const
{
if (k && Utils::mimeTypeForFile(projectPath).matchesName(Constants::MIME_TYPE))
return 0;
return -1;
}
static Utils::FileName defaultBuildDirectory(const QString &projectFilePath, const Kit *k,
const QString &bcName,
BuildConfiguration::BuildType buildType)
{
const QString projectName = QFileInfo(projectFilePath).completeBaseName();
ProjectMacroExpander expander(projectFilePath, projectName, k, bcName, buildType);
QString projectDir = Project::projectDirectory(Utils::FileName::fromString(projectFilePath)).toString();
QString buildPath = expander.expand(Core::DocumentManager::buildDirectory());
return Utils::FileName::fromString(Utils::FileUtils::resolvePath(projectDir, buildPath));
return {createBuildInfo(parent->kit(), BuildConfiguration::Debug)};
}
QList<BuildInfo *> QbsBuildConfigurationFactory::availableSetups(const Kit *k, const QString &projectPath) const
@@ -478,61 +439,5 @@ QList<BuildInfo *> QbsBuildConfigurationFactory::availableSetups(const Kit *k, c
return result;
}
BuildConfiguration *QbsBuildConfigurationFactory::create(Target *parent, const BuildInfo *info) const
{
QTC_ASSERT(info->factory() == this, return 0);
QTC_ASSERT(info->kitId == parent->kit()->id(), return 0);
QTC_ASSERT(!info->displayName.isEmpty(), return 0);
const QbsBuildInfo * const bi = static_cast<const QbsBuildInfo *>(info);
QVariantMap configData = bi->config;
configData.insert(QLatin1String(Constants::QBS_CONFIG_VARIANT_KEY),
(info->buildType == BuildConfiguration::Debug)
? QLatin1String(Constants::QBS_VARIANT_DEBUG)
: QLatin1String(Constants::QBS_VARIANT_RELEASE));
Utils::FileName buildDir = info->buildDirectory;
if (buildDir.isEmpty())
buildDir = defaultBuildDirectory(parent->project()->projectDirectory().toString(),
parent->kit(), info->displayName, info->buildType);
BuildConfiguration *bc
= QbsBuildConfiguration::setup(parent, info->displayName, info->displayName,
configData, buildDir);
return bc;
}
bool QbsBuildConfigurationFactory::canClone(const Target *parent, BuildConfiguration *source) const
{
return canHandle(parent) && qobject_cast<QbsBuildConfiguration *>(source);
}
BuildConfiguration *QbsBuildConfigurationFactory::clone(Target *parent, BuildConfiguration *source)
{
if (!canClone(parent, source))
return 0;
QbsBuildConfiguration *oldbc(static_cast<QbsBuildConfiguration *>(source));
return new QbsBuildConfiguration(parent, oldbc);
}
bool QbsBuildConfigurationFactory::canRestore(const Target *parent, const QVariantMap &map) const
{
if (!canHandle(parent))
return false;
return ProjectExplorer::idFromMap(map) == Core::Id(QBS_BC_ID);
}
BuildConfiguration *QbsBuildConfigurationFactory::restore(Target *parent, const QVariantMap &map)
{
if (!canRestore(parent, map))
return 0;
QbsBuildConfiguration *bc = new QbsBuildConfiguration(parent);
if (bc->fromMap(map))
return bc;
delete bc;
return 0;
}
} // namespace Internal
} // namespace QbsProjectManager

41
src/plugins/qbsprojectmanager/qbsbuildconfiguration.h
View File

@@ -32,16 +32,11 @@
#include <projectexplorer/buildconfiguration.h>
#include <qtsupport/baseqtversion.h>
namespace ProjectExplorer {
class BuildStep;
class FileNode;
}
namespace ProjectExplorer { class BuildStep; }
namespace QbsProjectManager {
namespace Internal {
class QbsBuildConfigurationFactory;
class QbsBuildConfigurationWidget;
class QbsBuildStep;
class QbsProject;
@@ -50,9 +45,11 @@ class QbsBuildConfiguration : public ProjectExplorer::BuildConfiguration
{
Q_OBJECT
public:
friend class ProjectExplorer::IBuildConfigurationFactory;
explicit QbsBuildConfiguration(ProjectExplorer::Target *target);
public:
void initialize(const ProjectExplorer::BuildInfo *info) override;
ProjectExplorer::NamedWidget *createConfigWidget() override;
QbsBuildStep *qbsStep() const;
@@ -86,29 +83,17 @@ public:
signals:
void qbsConfigurationChanged();
protected:
QbsBuildConfiguration(ProjectExplorer::Target *target, QbsBuildConfiguration *source);
QbsBuildConfiguration(ProjectExplorer::Target *target, Core::Id id);
private:
bool fromMap(const QVariantMap &map) override;
QVariantMap toMap() const override;
private:
void buildStepInserted(int pos);
static QbsBuildConfiguration *setup(ProjectExplorer::Target *t,
const QString &defaultDisplayName,
const QString &displayName,
const QVariantMap &buildData,
const Utils::FileName &directory);
bool m_isParsing;
bool m_parsingError;
bool m_isParsing = true;
bool m_parsingError = false;
QStringList m_changedFiles;
QStringList m_activeFileTags;
QStringList m_products;
QString m_configurationName;
friend class QbsBuildConfigurationFactory;
friend class QbsBuildConfigurationWidget;
};
@@ -117,23 +102,13 @@ class QbsBuildConfigurationFactory : public ProjectExplorer::IBuildConfiguration
Q_OBJECT
public:
explicit QbsBuildConfigurationFactory(QObject *parent = 0);
QbsBuildConfigurationFactory();
int priority(const ProjectExplorer::Target *parent) const override;
QList<ProjectExplorer::BuildInfo *> availableBuilds(const ProjectExplorer::Target *parent) const override;
int priority(const ProjectExplorer::Kit *k, const QString &projectPath) const override;
QList<ProjectExplorer::BuildInfo *> availableSetups(const ProjectExplorer::Kit *k,
const QString &projectPath) const override;
ProjectExplorer::BuildConfiguration *create(ProjectExplorer::Target *parent,
const ProjectExplorer::BuildInfo *info) const override;
bool canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *source) const override;
ProjectExplorer::BuildConfiguration *clone(ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *source) override;
bool canRestore(const ProjectExplorer::Target *parent, const QVariantMap &map) const override;
ProjectExplorer::BuildConfiguration *restore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
private:
bool canHandle(const ProjectExplorer::Target *t) const;
ProjectExplorer::BuildInfo *createBuildInfo(const ProjectExplorer::Kit *k,
ProjectExplorer::BuildConfiguration::BuildType type) const;
};

39
src/plugins/qbsprojectmanager/qbsbuildstep.cpp
View File

@@ -124,18 +124,11 @@ private:
// --------------------------------------------------------------------
QbsBuildStep::QbsBuildStep(ProjectExplorer::BuildStepList *bsl) :
ProjectExplorer::BuildStep(bsl, Core::Id(Constants::QBS_BUILDSTEP_ID)),
m_job(0), m_parser(0), m_parsingProject(false)
ProjectExplorer::BuildStep(bsl, Constants::QBS_BUILDSTEP_ID)
{
setDisplayName(tr("Qbs Build"));
setQbsConfiguration(QVariantMap());
}
QbsBuildStep::QbsBuildStep(ProjectExplorer::BuildStepList *bsl, const QbsBuildStep *other) :
ProjectExplorer::BuildStep(bsl, Core::Id(Constants::QBS_BUILDSTEP_ID)),
m_qbsBuildOptions(other->m_qbsBuildOptions), m_job(0), m_parser(0), m_parsingProject(false)
{
setQbsConfiguration(other->qbsConfiguration(PreserveVariables));
// setQbsConfiguration(other->qbsConfiguration(PreserveVariables));
}
QbsBuildStep::~QbsBuildStep()
@@ -846,29 +839,13 @@ bool QbsBuildStepConfigWidget::validateProperties(Utils::FancyLineEdit *edit, QS
// QbsBuildStepFactory:
// --------------------------------------------------------------------
QbsBuildStepFactory::QbsBuildStepFactory(QObject *parent) :
ProjectExplorer::IBuildStepFactory(parent)
{ }
QList<ProjectExplorer::BuildStepInfo> QbsBuildStepFactory::availableSteps(ProjectExplorer::BuildStepList *parent) const
QbsBuildStepFactory::QbsBuildStepFactory()
{
if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_BUILD
&& qobject_cast<QbsBuildConfiguration *>(parent->parent())
&& qobject_cast<QbsProject *>(parent->target()->project()))
return {{Constants::QBS_BUILDSTEP_ID, tr("Qbs Build")}};
return {};
}
ProjectExplorer::BuildStep *QbsBuildStepFactory::create(ProjectExplorer::BuildStepList *parent, Core::Id id)
{
Q_UNUSED(id);
return new QbsBuildStep(parent);
}
ProjectExplorer::BuildStep *QbsBuildStepFactory::clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product)
{
return new QbsBuildStep(parent, static_cast<QbsBuildStep *>(product));
registerStep<QbsBuildStep>(Constants::QBS_BUILDSTEP_ID);
setDisplayName(tr("Qbs Build"));
setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
setSupportedConfiguration(Constants::QBS_BC_ID);
setSupportedProjectType(Constants::PROJECT_ID);
}
} // namespace Internal

23
src/plugins/qbsprojectmanager/qbsbuildstep.h
View File

@@ -52,7 +52,6 @@ public:
};
explicit QbsBuildStep(ProjectExplorer::BuildStepList *bsl);
QbsBuildStep(ProjectExplorer::BuildStepList *bsl, const QbsBuildStep *other);
~QbsBuildStep() override;
bool init(QList<const BuildStep *> &earlierSteps) override;
@@ -81,14 +80,14 @@ public:
bool isQmlDebuggingEnabled() const;
bool fromMap(const QVariantMap &map) override;
QVariantMap toMap() const override;
signals:
void qbsConfigurationChanged();
void qbsBuildOptionsChanged();
private:
bool fromMap(const QVariantMap &map) override;
QVariantMap toMap() const override;
void buildingDone(bool success);
void reparsingDone(bool success);
void handleTaskStarted(const QString &desciption, int max);
@@ -124,27 +123,21 @@ private:
QStringList m_products;
QFutureInterface<bool> *m_fi;
qbs::BuildJob *m_job;
qbs::BuildJob *m_job = nullptr;
int m_progressBase;
bool m_lastWasSuccess;
ProjectExplorer::IOutputParser *m_parser;
bool m_parsingProject;
ProjectExplorer::IOutputParser *m_parser = nullptr;
bool m_parsingProject = false;
friend class QbsBuildStepConfigWidget;
};
class QbsBuildStepFactory : public ProjectExplorer::IBuildStepFactory
class QbsBuildStepFactory : public ProjectExplorer::BuildStepFactory
{
Q_OBJECT
public:
explicit QbsBuildStepFactory(QObject *parent = 0);
QList<ProjectExplorer::BuildStepInfo>
availableSteps(ProjectExplorer::BuildStepList *parent) const override;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) override;
QbsBuildStepFactory();
};
} // namespace Internal

38
src/plugins/qbsprojectmanager/qbscleanstep.cpp
View File

@@ -41,10 +41,6 @@
static const char QBS_DRY_RUN[] = "Qbs.DryRun";
static const char QBS_KEEP_GOING[] = "Qbs.DryKeepGoing";
// --------------------------------------------------------------------
// Constants:
// --------------------------------------------------------------------
namespace QbsProjectManager {
namespace Internal {
@@ -53,18 +49,11 @@ namespace Internal {
// --------------------------------------------------------------------
QbsCleanStep::QbsCleanStep(ProjectExplorer::BuildStepList *bsl) :
ProjectExplorer::BuildStep(bsl, Core::Id(Constants::QBS_CLEANSTEP_ID)),
m_job(0), m_showCompilerOutput(true), m_parser(0)
ProjectExplorer::BuildStep(bsl, Constants::QBS_CLEANSTEP_ID)
{
setDisplayName(tr("Qbs Clean"));
}
QbsCleanStep::QbsCleanStep(ProjectExplorer::BuildStepList *bsl, const QbsCleanStep *other) :
ProjectExplorer::BuildStep(bsl, Core::Id(Constants::QBS_CLEANSTEP_ID)),
m_qbsCleanOptions(other->m_qbsCleanOptions), m_job(0),
m_showCompilerOutput(other->m_showCompilerOutput), m_parser(0)
{ }
QbsCleanStep::~QbsCleanStep()
{
cancel();
@@ -303,27 +292,12 @@ void QbsCleanStepConfigWidget::changeJobCount(int count)
// QbsCleanStepFactory:
// --------------------------------------------------------------------
QbsCleanStepFactory::QbsCleanStepFactory(QObject *parent) :
ProjectExplorer::IBuildStepFactory(parent)
{ }
QList<ProjectExplorer::BuildStepInfo> QbsCleanStepFactory::availableSteps(ProjectExplorer::BuildStepList *parent) const
QbsCleanStepFactory::QbsCleanStepFactory()
{
if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_CLEAN
&& qobject_cast<QbsBuildConfiguration *>(parent->parent()))
return {{Constants::QBS_CLEANSTEP_ID, tr("Qbs Clean")}};
return {};
}
ProjectExplorer::BuildStep *QbsCleanStepFactory::create(ProjectExplorer::BuildStepList *parent, Core::Id id)
{
Q_UNUSED(id);
return new QbsCleanStep(parent);
}
ProjectExplorer::BuildStep *QbsCleanStepFactory::clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product)
{
return new QbsCleanStep(parent, static_cast<QbsCleanStep *>(product));
registerStep<QbsCleanStep>(Constants::QBS_CLEANSTEP_ID);
setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
setSupportedConfiguration(Constants::QBS_BC_ID);
setDisplayName(tr("Qbs Clean"));
}
} // namespace Internal

19
src/plugins/qbsprojectmanager/qbscleanstep.h
View File

@@ -43,7 +43,6 @@ class QbsCleanStep : public ProjectExplorer::BuildStep
public:
explicit QbsCleanStep(ProjectExplorer::BuildStepList *bsl);
QbsCleanStep(ProjectExplorer::BuildStepList *bsl, const QbsCleanStep *other);
~QbsCleanStep() override;
bool init(QList<const BuildStep *> &earlierSteps) override;
@@ -80,11 +79,11 @@ private:
qbs::CleanOptions m_qbsCleanOptions;
QStringList m_products;
QFutureInterface<bool> *m_fi;
qbs::CleanJob *m_job;
QFutureInterface<bool> *m_fi = nullptr;
qbs::CleanJob *m_job = nullptr;
int m_progressBase;
bool m_showCompilerOutput;
ProjectExplorer::IOutputParser *m_parser;
bool m_showCompilerOutput = true;
ProjectExplorer::IOutputParser *m_parser = nullptr;
friend class QbsCleanStepConfigWidget;
};
@@ -113,18 +112,12 @@ private:
QString m_summary;
};
class QbsCleanStepFactory : public ProjectExplorer::IBuildStepFactory
class QbsCleanStepFactory : public ProjectExplorer::BuildStepFactory
{
Q_OBJECT
public:
explicit QbsCleanStepFactory(QObject *parent = 0);
QList<ProjectExplorer::BuildStepInfo>
availableSteps(ProjectExplorer::BuildStepList *parent) const override;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) override;
QbsCleanStepFactory();
};
} // namespace Internal

113
src/plugins/qbsprojectmanager/qbsdeployconfigurationfactory.cpp
View File

@@ -25,121 +25,30 @@
#include "qbsdeployconfigurationfactory.h"
#include "qbsprojectmanagerconstants.h"
#include "qbsinstallstep.h"
#include "qbsproject.h"
#include <projectexplorer/buildsteplist.h>
#include <projectexplorer/kitinformation.h>
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/target.h>
namespace QbsProjectManager {
namespace Internal {
// --------------------------------------------------------------------
// Helpers:
// --------------------------------------------------------------------
const char QBS_DEPLOYCONFIG_ID[] = "Qbs.Deploy";
static QString genericQbsDisplayName() {
return QCoreApplication::translate("Qbs", "Qbs Install");
QbsDeployConfiguration::QbsDeployConfiguration(ProjectExplorer::Target *target) :
ProjectExplorer::DeployConfiguration(target, QBS_DEPLOYCONFIG_ID)
{
}
static Core::Id genericQbsDeployConfigurationId()
QbsDeployConfigurationFactory::QbsDeployConfigurationFactory()
{
return "Qbs.Deploy";
}
// --------------------------------------------------------------------
// QbsDeployConfiguration:
// --------------------------------------------------------------------
QbsDeployConfiguration::QbsDeployConfiguration(ProjectExplorer::Target *target, Core::Id id) :
ProjectExplorer::DeployConfiguration(target, id)
{ }
QbsDeployConfiguration::QbsDeployConfiguration(ProjectExplorer::Target *target,
ProjectExplorer::DeployConfiguration *source) :
ProjectExplorer::DeployConfiguration(target, source)
{
cloneSteps(source);
}
// --------------------------------------------------------------------
// QbsDeployConfigurationFactory:
// --------------------------------------------------------------------
QbsDeployConfigurationFactory::QbsDeployConfigurationFactory(QObject *parent) :
ProjectExplorer::DeployConfigurationFactory(parent)
{
setObjectName(QLatin1String("QbsDeployConfiguration"));
}
QList<Core::Id> QbsDeployConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent) const
{
QList<Core::Id> ids;
const Core::Id deviceId = ProjectExplorer::DeviceKitInformation::deviceId(parent->kit());
if (qobject_cast<QbsProject *>(parent->project())
&& deviceId == ProjectExplorer::Constants::DESKTOP_DEVICE_ID) {
ids << genericQbsDeployConfigurationId();
}
return ids;
}
QString QbsDeployConfigurationFactory::displayNameForId(Core::Id id) const
{
if (id == genericQbsDeployConfigurationId())
return genericQbsDisplayName();
return QString();
}
bool QbsDeployConfigurationFactory::canCreate(ProjectExplorer::Target *parent,
const Core::Id id) const
{
return availableCreationIds(parent).contains(id);
}
ProjectExplorer::DeployConfiguration
*QbsDeployConfigurationFactory::create(ProjectExplorer::Target *parent, Core::Id id)
{
Q_ASSERT(canCreate(parent, id));
QbsDeployConfiguration *dc = new QbsDeployConfiguration(parent, id);
dc->setDisplayName(genericQbsDisplayName());
return dc;
}
bool QbsDeployConfigurationFactory::canRestore(ProjectExplorer::Target *parent,
const QVariantMap &map) const
{
return canCreate(parent, ProjectExplorer::idFromMap(map));
}
ProjectExplorer::DeployConfiguration
*QbsDeployConfigurationFactory::restore(ProjectExplorer::Target *parent, const QVariantMap &map)
{
if (!canRestore(parent, map))
return 0;
Core::Id id = ProjectExplorer::idFromMap(map);
QbsDeployConfiguration *dc = new QbsDeployConfiguration(parent, id);
if (!dc->fromMap(map)) {
delete dc;
return 0;
}
return dc;
}
bool QbsDeployConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::DeployConfiguration *product) const
{
return canCreate(parent, product->id());
}
ProjectExplorer::DeployConfiguration
*QbsDeployConfigurationFactory::clone(ProjectExplorer::Target *parent,
ProjectExplorer::DeployConfiguration *product)
{
if (!canClone(parent, product))
return 0;
return new QbsDeployConfiguration(parent, qobject_cast<QbsDeployConfiguration *>(product));
setObjectName("QbsDeployConfiguration");
registerDeployConfiguration<QbsDeployConfiguration>(QBS_DEPLOYCONFIG_ID);
setSupportedTargetDeviceTypes({ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE});
setSupportedProjectType(Constants::PROJECT_ID);
setDefaultDisplayName(QCoreApplication::translate("Qbs", "Qbs Install"));
}
} // namespace Internal

24
src/plugins/qbsprojectmanager/qbsdeployconfigurationfactory.h
View File

@@ -28,22 +28,14 @@
#include <projectexplorer/deployconfiguration.h>
namespace QbsProjectManager {
namespace Internal {
class QbsDeployConfigurationFactory;
class QbsDeployConfiguration : public ProjectExplorer::DeployConfiguration
{
Q_OBJECT
private:
QbsDeployConfiguration(ProjectExplorer::Target *target, Core::Id id);
QbsDeployConfiguration(ProjectExplorer::Target *target,
ProjectExplorer::DeployConfiguration *source);
friend class QbsDeployConfigurationFactory;
public:
explicit QbsDeployConfiguration(ProjectExplorer::Target *target);
};
class QbsDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
@@ -51,17 +43,7 @@ class QbsDeployConfigurationFactory : public ProjectExplorer::DeployConfiguratio
Q_OBJECT
public:
explicit QbsDeployConfigurationFactory(QObject *parent = 0);
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent) const override;
QString displayNameForId(Core::Id id) const override;
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
ProjectExplorer::DeployConfiguration *create(ProjectExplorer::Target *parent, Core::Id id) override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
ProjectExplorer::DeployConfiguration *restore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::DeployConfiguration *product) const override;
ProjectExplorer::DeployConfiguration *clone(ProjectExplorer::Target *parent,
ProjectExplorer::DeployConfiguration *product) override;
QbsDeployConfigurationFactory();
};
} // namespace Internal

58
src/plugins/qbsprojectmanager/qbsinstallstep.cpp
View File

@@ -58,19 +58,17 @@ namespace Internal {
// --------------------------------------------------------------------
QbsInstallStep::QbsInstallStep(ProjectExplorer::BuildStepList *bsl) :
ProjectExplorer::BuildStep(bsl, Core::Id(Constants::QBS_INSTALLSTEP_ID)),
m_job(0), m_showCompilerOutput(true), m_parser(0)
ProjectExplorer::BuildStep(bsl, Constants::QBS_INSTALLSTEP_ID)
{
setDisplayName(tr("Qbs Install"));
ctor();
}
QbsInstallStep::QbsInstallStep(ProjectExplorer::BuildStepList *bsl, const QbsInstallStep *other) :
ProjectExplorer::BuildStep(bsl, Core::Id(Constants::QBS_INSTALLSTEP_ID)),
m_qbsInstallOptions(other->m_qbsInstallOptions), m_job(0),
m_showCompilerOutput(other->m_showCompilerOutput), m_parser(0)
{
ctor();
const QbsBuildConfiguration * const bc = buildConfig();
connect(bc, &QbsBuildConfiguration::qbsConfigurationChanged,
this, &QbsInstallStep::handleBuildConfigChanged);
if (bc->qbsStep()) {
connect(bc->qbsStep(), &QbsBuildStep::qbsBuildOptionsChanged,
this, &QbsInstallStep::handleBuildConfigChanged);
}
}
QbsInstallStep::~QbsInstallStep()
@@ -146,17 +144,6 @@ bool QbsInstallStep::keepGoing() const
return m_qbsInstallOptions.keepGoing();
}
void QbsInstallStep::ctor()
{
const QbsBuildConfiguration * const bc = buildConfig();
connect(bc, &QbsBuildConfiguration::qbsConfigurationChanged,
this, &QbsInstallStep::handleBuildConfigChanged);
if (bc->qbsStep()) {
connect(bc->qbsStep(), &QbsBuildStep::qbsBuildOptionsChanged,
this, &QbsInstallStep::handleBuildConfigChanged);
}
}
const QbsBuildConfiguration *QbsInstallStep::buildConfig() const
{
return static_cast<QbsBuildConfiguration *>(
@@ -346,30 +333,13 @@ void QbsInstallStepConfigWidget::changeKeepGoing(bool kg)
// QbsInstallStepFactory:
// --------------------------------------------------------------------
QbsInstallStepFactory::QbsInstallStepFactory(QObject *parent) :
ProjectExplorer::IBuildStepFactory(parent)
{ }
QList<ProjectExplorer::BuildStepInfo> QbsInstallStepFactory::availableSteps(ProjectExplorer::BuildStepList *parent) const
QbsInstallStepFactory::QbsInstallStepFactory()
{
if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_DEPLOY
&& qobject_cast<ProjectExplorer::DeployConfiguration *>(parent->parent())
&& qobject_cast<QbsProject *>(parent->target()->project()))
return {{ Constants::QBS_INSTALLSTEP_ID, tr("Qbs Install") }};
return {};
}
ProjectExplorer::BuildStep *QbsInstallStepFactory::create(ProjectExplorer::BuildStepList *parent,
const Core::Id id)
{
Q_UNUSED(id);
return new QbsInstallStep(parent);
}
ProjectExplorer::BuildStep *QbsInstallStepFactory::clone(ProjectExplorer::BuildStepList *parent,
ProjectExplorer::BuildStep *product)
{
return new QbsInstallStep(parent, static_cast<QbsInstallStep *>(product));
registerStep<QbsInstallStep>(Constants::QBS_INSTALLSTEP_ID);
setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_DEPLOY);
setSupportedDeviceType(ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE);
setSupportedProjectType(Constants::PROJECT_ID);
setDisplayName(tr("Qbs Install"));
}
} // namespace Internal

20
src/plugins/qbsprojectmanager/qbsinstallstep.h
View File

@@ -43,7 +43,6 @@ class QbsInstallStep : public ProjectExplorer::BuildStep
public:
explicit QbsInstallStep(ProjectExplorer::BuildStepList *bsl);
QbsInstallStep(ProjectExplorer::BuildStepList *bsl, const QbsInstallStep *other);
~QbsInstallStep() override;
bool init(QList<const BuildStep *> &earlierSteps) override;
@@ -68,7 +67,6 @@ signals:
void changed();
private:
void ctor();
const QbsBuildConfiguration *buildConfig() const;
void installDone(bool success);
void handleTaskStarted(const QString &desciption, int max);
@@ -84,11 +82,11 @@ private:
qbs::InstallOptions m_qbsInstallOptions;
QFutureInterface<bool> *m_fi;
qbs::InstallJob *m_job;
QFutureInterface<bool> *m_fi = nullptr;
qbs::InstallJob *m_job = nullptr;
int m_progressBase;
bool m_showCompilerOutput;
ProjectExplorer::IOutputParser *m_parser;
bool m_showCompilerOutput = true;
ProjectExplorer::IOutputParser *m_parser = nullptr;
friend class QbsInstallStepConfigWidget;
};
@@ -119,18 +117,12 @@ private:
bool m_ignoreChange;
};
class QbsInstallStepFactory : public ProjectExplorer::IBuildStepFactory
class QbsInstallStepFactory : public ProjectExplorer::BuildStepFactory
{
Q_OBJECT
public:
explicit QbsInstallStepFactory(QObject *parent = 0);
QList<ProjectExplorer::BuildStepInfo>
availableSteps(ProjectExplorer::BuildStepList *parent) const override;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) override;
QbsInstallStepFactory();
};
} // namespace Internal

1
src/plugins/qbsprojectmanager/qbsprojectmanagerconstants.h
View File

@@ -58,6 +58,7 @@ const char ACTION_REBUILD_SUBPROJECT[] = "Qbs.RebuildSubproject";
const char QBS_BUILDSTEP_ID[] = "Qbs.BuildStep";
const char QBS_CLEANSTEP_ID[] = "Qbs.CleanStep";
const char QBS_INSTALLSTEP_ID[] = "Qbs.InstallStep";
const char QBS_BC_ID[] = "Qbs.QbsBuildConfiguration";
// QBS strings:
const char QBS_VARIANT_DEBUG[] = "debug";

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

@@ -72,21 +72,6 @@ const char QBS_RC_PREFIX[] = "Qbs.RunConfiguration:";
static QString rcNameSeparator() { return QLatin1String("---Qbs.RC.NameSeparator---"); }
static QString uniqueProductNameFromId(Core::Id id)
{
const QString suffix = id.suffixAfter(QBS_RC_PREFIX);
return suffix.left(suffix.indexOf(rcNameSeparator()));
}
static QString productDisplayNameFromId(Core::Id id)
{
const QString suffix = id.suffixAfter(QBS_RC_PREFIX);
const int sepPos = suffix.indexOf(rcNameSeparator());
if (sepPos == -1)
return suffix;
return suffix.mid(sepPos + rcNameSeparator().count());
}
const qbs::ProductData findProduct(const qbs::ProjectData &pro, const QString &uniqeName)
{
foreach (const qbs::ProductData &product, pro.allProducts()) {
@@ -101,7 +86,7 @@ const qbs::ProductData findProduct(const qbs::ProjectData &pro, const QString &u
// --------------------------------------------------------------------
QbsRunConfiguration::QbsRunConfiguration(Target *target)
: RunConfiguration(target)
: RunConfiguration(target, QBS_RC_PREFIX)
{
auto envAspect = new LocalEnvironmentAspect(this,
[](RunConfiguration *rc, Environment &env) {
@@ -138,14 +123,30 @@ QbsRunConfiguration::QbsRunConfiguration(Target *target)
this, &QbsRunConfiguration::installStepChanged);
}
void QbsRunConfiguration::initialize(Core::Id id)
bool QbsRunConfiguration::fromMap(const QVariantMap &map)
{
RunConfiguration::initialize(id);
if (!RunConfiguration::fromMap(map))
return false;
QString extraId = ProjectExplorer::idFromMap(map).suffixAfter(id());
if (!extraId.isEmpty()) {
const int sepPos = extraId.indexOf(rcNameSeparator());
m_uniqueProductName = extraId.left(sepPos);
m_productDisplayName = sepPos == -1 ? QString() : extraId.mid(sepPos + rcNameSeparator().size());
}
setDefaultDisplayName(defaultDisplayName());
installStepChanged();
return true;
}
QString QbsRunConfiguration::extraId() const
{
return m_uniqueProductName + rcNameSeparator() + m_productDisplayName;
}
QWidget *QbsRunConfiguration::createConfigurationWidget()
{
return new QbsRunConfigurationWidget(this);
@@ -266,17 +267,17 @@ void QbsRunConfiguration::addToBaseEnvironment(Utils::Environment &env) const
QString QbsRunConfiguration::buildSystemTarget() const
{
return productDisplayNameFromId(id());
return m_productDisplayName;
}
QString QbsRunConfiguration::uniqueProductName() const
{
return uniqueProductNameFromId(id());
return m_uniqueProductName;
}
QString QbsRunConfiguration::defaultDisplayName()
{
QString defaultName = productDisplayNameFromId(id());
QString defaultName = m_productDisplayName;
if (defaultName.isEmpty())
defaultName = tr("Qbs Run Configuration");
return defaultName;

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

@@ -68,9 +68,9 @@ signals:
void targetInformationChanged();
void usingDyldImageSuffixChanged(bool);
private:
void initialize(Core::Id id) override;
bool fromMap(const QVariantMap &map) final;
QString extraId() const final;
void installStepChanged();
void installStepToBeRemoved(int pos);
@@ -81,6 +81,8 @@ private:
QbsInstallStep *m_currentInstallStep = nullptr; // We do not take ownership!
ProjectExplorer::BuildStepList *m_currentBuildStepList = nullptr; // We do not take ownership!
QString m_uniqueProductName;
QString m_productDisplayName;
};
class QbsRunConfigurationWidget : public QWidget