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

CMake: Move MakeStep to CMakeBuildStep

Browse Source 
Change-Id: I2a3432acd90cc27fb444ab30c3239497a51e01df
Reviewed-by: Cristian Adam <cristian.adam@gmail.com>
Reviewed-by: Niels Weber <niels.weber@theqtcompany.com>
This commit is contained in:
Tobias Hunger
2016-01-07 12:33:52 +01:00
parent 2ce52e3288
commit e4cdad309d
8 changed files with 141 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
View File

@@ -31,12 +31,12 @@
#include "cmakebuildconfiguration.h" #include "cmakebuildconfiguration.h"
#include "cmakebuildinfo.h" #include "cmakebuildinfo.h"
#include "cmakebuildstep.h"
#include "cmakeopenprojectwizard.h" #include "cmakeopenprojectwizard.h"
#include "cmakeproject.h" #include "cmakeproject.h"
#include "cmakeprojectconstants.h" #include "cmakeprojectconstants.h"
#include "cmakebuildsettingswidget.h" #include "cmakebuildsettingswidget.h"
#include "cmakeprojectmanager.h" #include "cmakeprojectmanager.h"
#include "makestep.h"
#include <coreplugin/documentmanager.h> #include <coreplugin/documentmanager.h>
#include <coreplugin/icore.h> #include <coreplugin/icore.h>
@@ -232,19 +232,19 @@ ProjectExplorer::BuildConfiguration *CMakeBuildConfigurationFactory::create(Proj
ProjectExplorer::BuildStepList *buildSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD); ProjectExplorer::BuildStepList *buildSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
ProjectExplorer::BuildStepList *cleanSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN); ProjectExplorer::BuildStepList *cleanSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
MakeStep *makeStep = new MakeStep(buildSteps); auto buildStep = new CMakeBuildStep(buildSteps);
buildSteps->insertStep(0, makeStep); buildSteps->insertStep(0, buildStep);
MakeStep *cleanMakeStep = new MakeStep(cleanSteps); auto cleanStep = new CMakeBuildStep(cleanSteps);
cleanSteps->insertStep(0, cleanMakeStep); cleanSteps->insertStep(0, cleanStep);
cleanMakeStep->setBuildTarget(MakeStep::cleanTarget(), true); cleanStep->setBuildTarget(CMakeBuildStep::cleanTarget(), true);
bc->setBuildDirectory(copy.buildDirectory); bc->setBuildDirectory(copy.buildDirectory);
bc->setInitialArguments(copy.arguments); bc->setInitialArguments(copy.arguments);
// Default to all // Default to all
if (project->hasBuildTarget(QLatin1String("all"))) if (project->hasBuildTarget(QLatin1String("all")))
makeStep->setBuildTarget(QLatin1String("all"), true); buildStep->setBuildTarget(QLatin1String("all"), true);
return bc; return bc;
} }

201
src/plugins/cmakeprojectmanager/makestep.cpp → src/plugins/cmakeprojectmanager/cmakebuildstep.cpp
View File

@@ -28,7 +28,7 @@
** **
****************************************************************************/ ****************************************************************************/
#include "makestep.h" #include "cmakebuildstep.h"
#include "cmakebuildconfiguration.h" #include "cmakebuildconfiguration.h"
#include "cmakeparser.h" #include "cmakeparser.h"
@@ -72,19 +72,19 @@ const char MAKE_COMMAND_KEY[] = "CMakeProjectManager.MakeStep.MakeCommand";
const char ADD_RUNCONFIGURATION_TEXT[] = "Current executable"; const char ADD_RUNCONFIGURATION_TEXT[] = "Current executable";
} }
MakeStep::MakeStep(BuildStepList *bsl) : CMakeBuildStep::CMakeBuildStep(BuildStepList *bsl) :
AbstractProcessStep(bsl, Core::Id(MS_ID)), m_addRunConfigurationArgument(false) AbstractProcessStep(bsl, Core::Id(MS_ID)), m_addRunConfigurationArgument(false)
{ {
ctor(); ctor();
} }
MakeStep::MakeStep(BuildStepList *bsl, Core::Id id) : CMakeBuildStep::CMakeBuildStep(BuildStepList *bsl, Core::Id id) :
AbstractProcessStep(bsl, id), m_addRunConfigurationArgument(false) AbstractProcessStep(bsl, id), m_addRunConfigurationArgument(false)
{ {
ctor(); ctor();
} }
MakeStep::MakeStep(BuildStepList *bsl, MakeStep *bs) : CMakeBuildStep::CMakeBuildStep(BuildStepList *bsl, CMakeBuildStep *bs) :
AbstractProcessStep(bsl, bs), AbstractProcessStep(bsl, bs),
m_buildTargets(bs->m_buildTargets), m_buildTargets(bs->m_buildTargets),
m_additionalArguments(bs->m_additionalArguments), m_additionalArguments(bs->m_additionalArguments),
@@ -94,7 +94,7 @@ MakeStep::MakeStep(BuildStepList *bsl, MakeStep *bs) :
ctor(); ctor();
} }
void MakeStep::ctor() void CMakeBuildStep::ctor()
{ {
m_percentProgress = QRegExp(QLatin1String("^\\[\\s*(\\d*)%\\]")); m_percentProgress = QRegExp(QLatin1String("^\\[\\s*(\\d*)%\\]"));
m_ninjaProgress = QRegExp(QLatin1String("^\\[\\s*(\\d*)/\\s*(\\d*)")); m_ninjaProgress = QRegExp(QLatin1String("^\\[\\s*(\\d*)/\\s*(\\d*)"));
@@ -105,48 +105,48 @@ void MakeStep::ctor()
CMakeBuildConfiguration *bc = cmakeBuildConfiguration(); CMakeBuildConfiguration *bc = cmakeBuildConfiguration();
if (bc) { if (bc) {
m_activeConfiguration = 0; m_activeConfiguration = 0;
connect(bc, &CMakeBuildConfiguration::useNinjaChanged, this, &MakeStep::makeCommandChanged); connect(bc, &CMakeBuildConfiguration::useNinjaChanged, this, &CMakeBuildStep::makeCommandChanged);
} else { } else {
// That means the step is in the deploylist, so we listen to the active build config // That means the step is in the deploylist, so we listen to the active build config
// changed signal and react to the activeBuildConfigurationChanged() signal of the buildconfiguration // changed signal and react to the activeBuildConfigurationChanged() signal of the buildconfiguration
m_activeConfiguration = targetsActiveBuildConfiguration(); m_activeConfiguration = targetsActiveBuildConfiguration();
connect(target(), &Target::activeBuildConfigurationChanged, this, &MakeStep::activeBuildConfigurationChanged); connect(target(), &Target::activeBuildConfigurationChanged, this, &CMakeBuildStep::activeBuildConfigurationChanged);
activeBuildConfigurationChanged(); activeBuildConfigurationChanged();
} }
connect(static_cast<CMakeProject *>(project()), &CMakeProject::buildTargetsChanged, connect(static_cast<CMakeProject *>(project()), &CMakeProject::buildTargetsChanged,
this, &MakeStep::buildTargetsChanged); this, &CMakeBuildStep::buildTargetsChanged);
} }
CMakeBuildConfiguration *MakeStep::cmakeBuildConfiguration() const CMakeBuildConfiguration *CMakeBuildStep::cmakeBuildConfiguration() const
{ {
return static_cast<CMakeBuildConfiguration *>(buildConfiguration()); return static_cast<CMakeBuildConfiguration *>(buildConfiguration());
} }
CMakeBuildConfiguration *MakeStep::targetsActiveBuildConfiguration() const CMakeBuildConfiguration *CMakeBuildStep::targetsActiveBuildConfiguration() const
{ {
return static_cast<CMakeBuildConfiguration *>(target()->activeBuildConfiguration()); return static_cast<CMakeBuildConfiguration *>(target()->activeBuildConfiguration());
} }
CMakeRunConfiguration *MakeStep::targetsActiveRunConfiguration() const CMakeRunConfiguration *CMakeBuildStep::targetsActiveRunConfiguration() const
{ {
return qobject_cast<CMakeRunConfiguration *>(target()->activeRunConfiguration()); return qobject_cast<CMakeRunConfiguration *>(target()->activeRunConfiguration());
} }
void MakeStep::activeBuildConfigurationChanged() void CMakeBuildStep::activeBuildConfigurationChanged()
{ {
if (m_activeConfiguration) if (m_activeConfiguration)
disconnect(m_activeConfiguration, &CMakeBuildConfiguration::useNinjaChanged, this, &MakeStep::makeCommandChanged); disconnect(m_activeConfiguration, &CMakeBuildConfiguration::useNinjaChanged, this, &CMakeBuildStep::makeCommandChanged);
m_activeConfiguration = targetsActiveBuildConfiguration(); m_activeConfiguration = targetsActiveBuildConfiguration();
if (m_activeConfiguration) if (m_activeConfiguration)
connect(m_activeConfiguration, &CMakeBuildConfiguration::useNinjaChanged, this, &MakeStep::makeCommandChanged); connect(m_activeConfiguration, &CMakeBuildConfiguration::useNinjaChanged, this, &CMakeBuildStep::makeCommandChanged);
emit makeCommandChanged(); emit makeCommandChanged();
} }
void MakeStep::buildTargetsChanged() void CMakeBuildStep::buildTargetsChanged()
{ {
QStringList filteredTargets; QStringList filteredTargets;
foreach (const QString &t, static_cast<CMakeProject *>(project())->buildTargetTitles()) { foreach (const QString &t, static_cast<CMakeProject *>(project())->buildTargetTitles()) {
@@ -156,7 +156,7 @@ void MakeStep::buildTargetsChanged()
setBuildTargets(filteredTargets); setBuildTargets(filteredTargets);
} }
QVariantMap MakeStep::toMap() const QVariantMap CMakeBuildStep::toMap() const
{ {
QVariantMap map(AbstractProcessStep::toMap()); QVariantMap map(AbstractProcessStep::toMap());
map.insert(QLatin1String(BUILD_TARGETS_KEY), m_buildTargets); map.insert(QLatin1String(BUILD_TARGETS_KEY), m_buildTargets);
@@ -166,10 +166,10 @@ QVariantMap MakeStep::toMap() const
return map; return map;
} }
bool MakeStep::fromMap(const QVariantMap &map) bool CMakeBuildStep::fromMap(const QVariantMap &map)
{ {
if (map.value(QLatin1String(CLEAN_KEY), false).toBool()) { if (map.value(QLatin1String(CLEAN_KEY), false).toBool()) {
m_buildTargets = QStringList({ MakeStep::cleanTarget() }); m_buildTargets = QStringList({ CMakeBuildStep::cleanTarget() });
} else { } else {
m_buildTargets = map.value(QLatin1String(BUILD_TARGETS_KEY)).toStringList(); m_buildTargets = map.value(QLatin1String(BUILD_TARGETS_KEY)).toStringList();
m_additionalArguments = map.value(QLatin1String(ADDITIONAL_ARGUMENTS_KEY)).toString(); m_additionalArguments = map.value(QLatin1String(ADDITIONAL_ARGUMENTS_KEY)).toString();
@@ -181,7 +181,7 @@ bool MakeStep::fromMap(const QVariantMap &map)
} }
bool MakeStep::init(QList<const BuildStep *> &earlierSteps) bool CMakeBuildStep::init(QList<const BuildStep *> &earlierSteps)
{ {
CMakeBuildConfiguration *bc = cmakeBuildConfiguration(); CMakeBuildConfiguration *bc = cmakeBuildConfiguration();
if (!bc) if (!bc)
@@ -221,7 +221,7 @@ bool MakeStep::init(QList<const BuildStep *> &earlierSteps)
Utils::QtcProcess::addArgs(&arguments, m_buildTargets); Utils::QtcProcess::addArgs(&arguments, m_buildTargets);
Utils::QtcProcess::addArgs(&arguments, additionalArguments()); Utils::QtcProcess::addArgs(&arguments, additionalArguments());
setIgnoreReturnValue(m_buildTargets.contains(MakeStep::cleanTarget())); setIgnoreReturnValue(m_buildTargets.contains(CMakeBuildStep::cleanTarget()));
ProcessParameters *pp = processParameters(); ProcessParameters *pp = processParameters();
pp->setMacroExpander(bc->macroExpander()); pp->setMacroExpander(bc->macroExpander());
@@ -246,22 +246,22 @@ bool MakeStep::init(QList<const BuildStep *> &earlierSteps)
return AbstractProcessStep::init(earlierSteps); return AbstractProcessStep::init(earlierSteps);
} }
void MakeStep::run(QFutureInterface<bool> &fi) void CMakeBuildStep::run(QFutureInterface<bool> &fi)
{ {
AbstractProcessStep::run(fi); AbstractProcessStep::run(fi);
} }
BuildStepConfigWidget *MakeStep::createConfigWidget() BuildStepConfigWidget *CMakeBuildStep::createConfigWidget()
{ {
return new MakeStepConfigWidget(this); return new CMakeBuildStepConfigWidget(this);
} }
bool MakeStep::immutable() const bool CMakeBuildStep::immutable() const
{ {
return false; return false;
} }
void MakeStep::stdOutput(const QString &line) void CMakeBuildStep::stdOutput(const QString &line)
{ {
if (m_percentProgress.indexIn(line) != -1) { if (m_percentProgress.indexIn(line) != -1) {
bool ok = false; bool ok = false;
@@ -285,12 +285,12 @@ void MakeStep::stdOutput(const QString &line)
AbstractProcessStep::stdOutput(line); AbstractProcessStep::stdOutput(line);
} }
QStringList MakeStep::buildTargets() const QStringList CMakeBuildStep::buildTargets() const
{ {
return m_buildTargets; return m_buildTargets;
} }
bool MakeStep::buildsBuildTarget(const QString &target) const bool CMakeBuildStep::buildsBuildTarget(const QString &target) const
{ {
if (target == tr(ADD_RUNCONFIGURATION_TEXT)) if (target == tr(ADD_RUNCONFIGURATION_TEXT))
return addRunConfigurationArgument(); return addRunConfigurationArgument();
@@ -298,7 +298,7 @@ bool MakeStep::buildsBuildTarget(const QString &target) const
return m_buildTargets.contains(target); return m_buildTargets.contains(target);
} }
void MakeStep::setBuildTarget(const QString &buildTarget, bool on) void CMakeBuildStep::setBuildTarget(const QString &buildTarget, bool on)
{ {
if (buildTarget == tr(ADD_RUNCONFIGURATION_TEXT)) { if (buildTarget == tr(ADD_RUNCONFIGURATION_TEXT)) {
setAddRunConfigurationArgument(on); setAddRunConfigurationArgument(on);
@@ -312,7 +312,7 @@ void MakeStep::setBuildTarget(const QString &buildTarget, bool on)
} }
} }
void MakeStep::setBuildTargets(const QStringList &targets) void CMakeBuildStep::setBuildTargets(const QStringList &targets)
{ {
if (targets != m_buildTargets) { if (targets != m_buildTargets) {
m_buildTargets = targets; m_buildTargets = targets;
@@ -320,32 +320,32 @@ void MakeStep::setBuildTargets(const QStringList &targets)
} }
} }
void MakeStep::clearBuildTargets() void CMakeBuildStep::clearBuildTargets()
{ {
m_buildTargets.clear(); m_buildTargets.clear();
} }
QString MakeStep::additionalArguments() const QString CMakeBuildStep::additionalArguments() const
{ {
return m_additionalArguments; return m_additionalArguments;
} }
void MakeStep::setAdditionalArguments(const QString &list) void CMakeBuildStep::setAdditionalArguments(const QString &list)
{ {
m_additionalArguments = list; m_additionalArguments = list;
} }
bool MakeStep::addRunConfigurationArgument() const bool CMakeBuildStep::addRunConfigurationArgument() const
{ {
return m_addRunConfigurationArgument; return m_addRunConfigurationArgument;
} }
void MakeStep::setAddRunConfigurationArgument(bool add) void CMakeBuildStep::setAddRunConfigurationArgument(bool add)
{ {
m_addRunConfigurationArgument = add; m_addRunConfigurationArgument = add;
} }
QString MakeStep::makeCommand(ProjectExplorer::ToolChain *tc, const Utils::Environment &env) const QString CMakeBuildStep::makeCommand(ToolChain *tc, const Utils::Environment &env) const
{ {
if (!m_makeCmd.isEmpty()) if (!m_makeCmd.isEmpty())
return m_makeCmd; return m_makeCmd;
@@ -361,27 +361,27 @@ QString MakeStep::makeCommand(ProjectExplorer::ToolChain *tc, const Utils::Envir
return QLatin1String("make"); return QLatin1String("make");
} }
void MakeStep::setUserMakeCommand(const QString &make) void CMakeBuildStep::setUserMakeCommand(const QString &make)
{ {
m_makeCmd = make; m_makeCmd = make;
} }
QString MakeStep::userMakeCommand() const QString CMakeBuildStep::userMakeCommand() const
{ {
return m_makeCmd; return m_makeCmd;
} }
QString MakeStep::cleanTarget() QString CMakeBuildStep::cleanTarget()
{ {
return QLatin1String("clean"); return QLatin1String("clean");
} }
// //
// MakeStepConfigWidget // CMakeBuildStepConfigWidget
// //
MakeStepConfigWidget::MakeStepConfigWidget(MakeStep *makeStep) CMakeBuildStepConfigWidget::CMakeBuildStepConfigWidget(CMakeBuildStep *buildStep)
: m_makeStep(makeStep) : m_buildStep(buildStep)
{ {
QFormLayout *fl = new QFormLayout(this); QFormLayout *fl = new QFormLayout(this);
fl->setMargin(0); fl->setMargin(0);
@@ -392,13 +392,13 @@ MakeStepConfigWidget::MakeStepConfigWidget(MakeStep *makeStep)
m_makePathChooser->setExpectedKind(Utils::PathChooser::ExistingCommand); m_makePathChooser->setExpectedKind(Utils::PathChooser::ExistingCommand);
m_makePathChooser->setBaseDirectory(Utils::PathChooser::homePath()); m_makePathChooser->setBaseDirectory(Utils::PathChooser::homePath());
m_makePathChooser->setHistoryCompleter(QLatin1String("PE.MakeCommand.History")); m_makePathChooser->setHistoryCompleter(QLatin1String("PE.MakeCommand.History"));
m_makePathChooser->setPath(m_makeStep->userMakeCommand()); m_makePathChooser->setPath(m_buildStep->userMakeCommand());
fl->addRow(tr("Override command:"), m_makePathChooser); fl->addRow(tr("Override command:"), m_makePathChooser);
m_additionalArguments = new QLineEdit(this); m_additionalArguments = new QLineEdit(this);
fl->addRow(tr("Additional arguments:"), m_additionalArguments); fl->addRow(tr("Additional arguments:"), m_additionalArguments);
m_additionalArguments->setText(m_makeStep->additionalArguments()); m_additionalArguments->setText(m_buildStep->additionalArguments());
m_buildTargetsList = new QListWidget; m_buildTargetsList = new QListWidget;
m_buildTargetsList->setFrameStyle(QFrame::NoFrame); m_buildTargetsList->setFrameStyle(QFrame::NoFrame);
@@ -415,203 +415,202 @@ MakeStepConfigWidget::MakeStepConfigWidget(MakeStep *makeStep)
auto itemAddRunConfigurationArgument = new QListWidgetItem(tr(ADD_RUNCONFIGURATION_TEXT), m_buildTargetsList); auto itemAddRunConfigurationArgument = new QListWidgetItem(tr(ADD_RUNCONFIGURATION_TEXT), m_buildTargetsList);
itemAddRunConfigurationArgument->setFlags(itemAddRunConfigurationArgument->flags() | Qt::ItemIsUserCheckable); itemAddRunConfigurationArgument->setFlags(itemAddRunConfigurationArgument->flags() | Qt::ItemIsUserCheckable);
itemAddRunConfigurationArgument->setCheckState(m_makeStep->addRunConfigurationArgument() ? Qt::Checked : Qt::Unchecked); itemAddRunConfigurationArgument->setCheckState(m_buildStep->addRunConfigurationArgument() ? Qt::Checked : Qt::Unchecked);
QFont f; QFont f;
f.setItalic(true); f.setItalic(true);
itemAddRunConfigurationArgument->setFont(f); itemAddRunConfigurationArgument->setFont(f);
CMakeProject *pro = static_cast<CMakeProject *>(m_makeStep->project()); CMakeProject *pro = static_cast<CMakeProject *>(m_buildStep->project());
QStringList targetList = pro->buildTargetTitles(); QStringList targetList = pro->buildTargetTitles();
targetList.sort(); targetList.sort();
foreach (const QString &buildTarget, targetList) { foreach (const QString &buildTarget, targetList) {
QListWidgetItem *item = new QListWidgetItem(buildTarget, m_buildTargetsList); QListWidgetItem *item = new QListWidgetItem(buildTarget, m_buildTargetsList);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable); item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(m_makeStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked); item->setCheckState(m_buildStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked);
} }
updateDetails(); updateDetails();
connect(m_makePathChooser, &Utils::PathChooser::rawPathChanged, this, &MakeStepConfigWidget::makeEdited); connect(m_makePathChooser, &Utils::PathChooser::rawPathChanged, this, &CMakeBuildStepConfigWidget::makeEdited);
connect(m_additionalArguments, &QLineEdit::textEdited, this, &MakeStepConfigWidget::additionalArgumentsEdited); connect(m_additionalArguments, &QLineEdit::textEdited, this, &CMakeBuildStepConfigWidget::additionalArgumentsEdited);
connect(m_buildTargetsList, &QListWidget::itemChanged, this, &MakeStepConfigWidget::itemChanged); connect(m_buildTargetsList, &QListWidget::itemChanged, this, &CMakeBuildStepConfigWidget::itemChanged);
connect(ProjectExplorer::ProjectExplorerPlugin::instance(), &ProjectExplorerPlugin::settingsChanged, connect(ProjectExplorerPlugin::instance(), &ProjectExplorerPlugin::settingsChanged,
this, &MakeStepConfigWidget::updateDetails); this, &CMakeBuildStepConfigWidget::updateDetails);
connect(pro, &CMakeProject::buildTargetsChanged, this, &MakeStepConfigWidget::buildTargetsChanged); connect(pro, &CMakeProject::buildTargetsChanged, this, &CMakeBuildStepConfigWidget::buildTargetsChanged);
connect(m_makeStep, &MakeStep::targetsToBuildChanged, this, &MakeStepConfigWidget::selectedBuildTargetsChanged); connect(m_buildStep, &CMakeBuildStep::targetsToBuildChanged, this, &CMakeBuildStepConfigWidget::selectedBuildTargetsChanged);
connect(pro, &CMakeProject::environmentChanged, this, &MakeStepConfigWidget::updateDetails); connect(pro, &CMakeProject::environmentChanged, this, &CMakeBuildStepConfigWidget::updateDetails);
connect(m_makeStep, &MakeStep::makeCommandChanged, this, &MakeStepConfigWidget::updateDetails); connect(m_buildStep, &CMakeBuildStep::makeCommandChanged, this, &CMakeBuildStepConfigWidget::updateDetails);
} }
void MakeStepConfigWidget::makeEdited() void CMakeBuildStepConfigWidget::makeEdited()
{ {
m_makeStep->setUserMakeCommand(m_makePathChooser->rawPath()); m_buildStep->setUserMakeCommand(m_makePathChooser->rawPath());
updateDetails(); updateDetails();
} }
void MakeStepConfigWidget::additionalArgumentsEdited() void CMakeBuildStepConfigWidget::additionalArgumentsEdited()
{ {
m_makeStep->setAdditionalArguments(m_additionalArguments->text()); m_buildStep->setAdditionalArguments(m_additionalArguments->text());
updateDetails(); updateDetails();
} }
void MakeStepConfigWidget::itemChanged(QListWidgetItem *item) void CMakeBuildStepConfigWidget::itemChanged(QListWidgetItem *item)
{ {
m_makeStep->setBuildTarget(item->text(), item->checkState() & Qt::Checked); m_buildStep->setBuildTarget(item->text(), item->checkState() & Qt::Checked);
updateDetails(); updateDetails();
} }
QString MakeStepConfigWidget::displayName() const QString CMakeBuildStepConfigWidget::displayName() const
{ {
return tr("Make", "CMakeProjectManager::MakeStepConfigWidget display name."); return tr("Make", "CMakeProjectManager::CMakeBuildStepConfigWidget display name.");
} }
void MakeStepConfigWidget::buildTargetsChanged() void CMakeBuildStepConfigWidget::buildTargetsChanged()
{ {
disconnect(m_buildTargetsList, &QListWidget::itemChanged, this, &MakeStepConfigWidget::itemChanged); disconnect(m_buildTargetsList, &QListWidget::itemChanged, this, &CMakeBuildStepConfigWidget::itemChanged);
auto *addRunConfigurationArgumentItem = m_buildTargetsList->takeItem(0); auto *addRunConfigurationArgumentItem = m_buildTargetsList->takeItem(0);
m_buildTargetsList->clear(); m_buildTargetsList->clear();
m_buildTargetsList->insertItem(0, addRunConfigurationArgumentItem); m_buildTargetsList->insertItem(0, addRunConfigurationArgumentItem);
CMakeProject *pro = static_cast<CMakeProject *>(m_makeStep->target()->project()); CMakeProject *pro = static_cast<CMakeProject *>(m_buildStep->target()->project());
foreach (const QString& buildTarget, pro->buildTargetTitles()) { foreach (const QString& buildTarget, pro->buildTargetTitles()) {
QListWidgetItem *item = new QListWidgetItem(buildTarget, m_buildTargetsList); QListWidgetItem *item = new QListWidgetItem(buildTarget, m_buildTargetsList);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable); item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(m_makeStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked); item->setCheckState(m_buildStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked);
} }
connect(m_buildTargetsList, &QListWidget::itemChanged, this, &MakeStepConfigWidget::itemChanged); connect(m_buildTargetsList, &QListWidget::itemChanged, this, &CMakeBuildStepConfigWidget::itemChanged);
updateSummary(); updateSummary();
} }
void MakeStepConfigWidget::selectedBuildTargetsChanged() void CMakeBuildStepConfigWidget::selectedBuildTargetsChanged()
{ {
disconnect(m_buildTargetsList, &QListWidget::itemChanged, this, &MakeStepConfigWidget::itemChanged); disconnect(m_buildTargetsList, &QListWidget::itemChanged, this, &CMakeBuildStepConfigWidget::itemChanged);
for (int y = 0; y < m_buildTargetsList->count(); ++y) { for (int y = 0; y < m_buildTargetsList->count(); ++y) {
QListWidgetItem *item = m_buildTargetsList->item(y); QListWidgetItem *item = m_buildTargetsList->item(y);
item->setCheckState(m_makeStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked); item->setCheckState(m_buildStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked);
} }
connect(m_buildTargetsList, &QListWidget::itemChanged, this, &MakeStepConfigWidget::itemChanged); connect(m_buildTargetsList, &QListWidget::itemChanged, this, &CMakeBuildStepConfigWidget::itemChanged);
updateSummary(); updateSummary();
} }
void MakeStepConfigWidget::updateDetails() void CMakeBuildStepConfigWidget::updateDetails()
{ {
BuildConfiguration *bc = m_makeStep->buildConfiguration(); BuildConfiguration *bc = m_buildStep->buildConfiguration();
if (!bc) if (!bc)
bc = m_makeStep->target()->activeBuildConfiguration(); bc = m_buildStep->target()->activeBuildConfiguration();
if (!bc) { if (!bc) {
m_summaryText = tr("<b>No build configuration found on this kit.</b>"); m_summaryText = tr("<b>No build configuration found on this kit.</b>");
updateSummary(); updateSummary();
return; return;
} }
ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(m_makeStep->target()->kit()); ToolChain *tc = ToolChainKitInformation::toolChain(m_buildStep->target()->kit());
if (tc) { if (tc) {
QString arguments; QString arguments;
if (m_makeStep->addRunConfigurationArgument()) if (m_buildStep->addRunConfigurationArgument())
arguments = QLatin1String("<i>&lt;") + tr(ADD_RUNCONFIGURATION_TEXT) + QLatin1String("&gt;</i>"); arguments = QLatin1String("<i>&lt;") + tr(ADD_RUNCONFIGURATION_TEXT) + QLatin1String("&gt;</i>");
Utils::QtcProcess::addArgs(&arguments, Utils::QtcProcess::joinArgs(m_makeStep->buildTargets())); Utils::QtcProcess::addArgs(&arguments, Utils::QtcProcess::joinArgs(m_buildStep->buildTargets()));
Utils::QtcProcess::addArgs(&arguments, m_makeStep->additionalArguments()); Utils::QtcProcess::addArgs(&arguments, m_buildStep->additionalArguments());
ProcessParameters param; ProcessParameters param;
param.setMacroExpander(bc->macroExpander()); param.setMacroExpander(bc->macroExpander());
param.setEnvironment(bc->environment()); param.setEnvironment(bc->environment());
param.setWorkingDirectory(bc->buildDirectory().toString()); param.setWorkingDirectory(bc->buildDirectory().toString());
param.setCommand(m_makeStep->makeCommand(tc, bc->environment())); param.setCommand(m_buildStep->makeCommand(tc, bc->environment()));
param.setArguments(arguments); param.setArguments(arguments);
m_summaryText = param.summary(displayName()); m_summaryText = param.summary(displayName());
} else { } else {
m_summaryText = QLatin1String("<b>") + ProjectExplorer::ToolChainKitInformation::msgNoToolChainInTarget() + QLatin1String("</b>"); m_summaryText = QLatin1String("<b>") + ToolChainKitInformation::msgNoToolChainInTarget() + QLatin1String("</b>");
} }
emit updateSummary(); emit updateSummary();
} }
QString MakeStepConfigWidget::summaryText() const QString CMakeBuildStepConfigWidget::summaryText() const
{ {
return m_summaryText; return m_summaryText;
} }
// //
// MakeStepFactory // CMakeBuildStepFactory
// //
MakeStepFactory::MakeStepFactory(QObject *parent) : CMakeBuildStepFactory::CMakeBuildStepFactory(QObject *parent) : IBuildStepFactory(parent)
ProjectExplorer::IBuildStepFactory(parent)
{ {
} }
MakeStepFactory::~MakeStepFactory() CMakeBuildStepFactory::~CMakeBuildStepFactory()
{ {
} }
bool MakeStepFactory::canCreate(BuildStepList *parent, Core::Id id) const bool CMakeBuildStepFactory::canCreate(BuildStepList *parent, Core::Id id) const
{ {
if (parent->target()->project()->id() == Constants::CMAKEPROJECT_ID) if (parent->target()->project()->id() == Constants::CMAKEPROJECT_ID)
return id == MS_ID; return id == MS_ID;
return false; return false;
} }
BuildStep *MakeStepFactory::create(BuildStepList *parent, Core::Id id) BuildStep *CMakeBuildStepFactory::create(BuildStepList *parent, Core::Id id)
{ {
if (!canCreate(parent, id)) if (!canCreate(parent, id))
return 0; return 0;
MakeStep *step = new MakeStep(parent); CMakeBuildStep *step = new CMakeBuildStep(parent);
if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_CLEAN) if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_CLEAN)
step->setBuildTarget(MakeStep::cleanTarget(), true); step->setBuildTarget(CMakeBuildStep::cleanTarget(), true);
return step; return step;
} }
bool MakeStepFactory::canClone(BuildStepList *parent, BuildStep *source) const bool CMakeBuildStepFactory::canClone(BuildStepList *parent, BuildStep *source) const
{ {
return canCreate(parent, source->id()); return canCreate(parent, source->id());
} }
BuildStep *MakeStepFactory::clone(BuildStepList *parent, BuildStep *source) BuildStep *CMakeBuildStepFactory::clone(BuildStepList *parent, BuildStep *source)
{ {
if (!canClone(parent, source)) if (!canClone(parent, source))
return 0; return 0;
return new MakeStep(parent, static_cast<MakeStep *>(source)); return new CMakeBuildStep(parent, static_cast<CMakeBuildStep *>(source));
} }
bool MakeStepFactory::canRestore(BuildStepList *parent, const QVariantMap &map) const bool CMakeBuildStepFactory::canRestore(BuildStepList *parent, const QVariantMap &map) const
{ {
return canCreate(parent, idFromMap(map)); return canCreate(parent, idFromMap(map));
} }
BuildStep *MakeStepFactory::restore(BuildStepList *parent, const QVariantMap &map) BuildStep *CMakeBuildStepFactory::restore(BuildStepList *parent, const QVariantMap &map)
{ {
if (!canRestore(parent, map)) if (!canRestore(parent, map))
return 0; return 0;
MakeStep *bs(new MakeStep(parent)); CMakeBuildStep *bs(new CMakeBuildStep(parent));
if (bs->fromMap(map)) if (bs->fromMap(map))
return bs; return bs;
delete bs; delete bs;
return 0; return 0;
} }
QList<Core::Id> MakeStepFactory::availableCreationIds(ProjectExplorer::BuildStepList *parent) const QList<Core::Id> CMakeBuildStepFactory::availableCreationIds(BuildStepList *parent) const
{ {
if (parent->target()->project()->id() == Constants::CMAKEPROJECT_ID) if (parent->target()->project()->id() == Constants::CMAKEPROJECT_ID)
return QList<Core::Id>() << Core::Id(MS_ID); return QList<Core::Id>() << Core::Id(MS_ID);
return QList<Core::Id>(); return QList<Core::Id>();
} }
QString MakeStepFactory::displayNameForId(Core::Id id) const QString CMakeBuildStepFactory::displayNameForId(Core::Id id) const
{ {
if (id == MS_ID) if (id == MS_ID)
return tr("Make", "Display name for CMakeProjectManager::MakeStep id."); return tr("Make", "Display name for CMakeProjectManager::CMakeBuildStep id.");
return QString(); return QString();
} }
void MakeStep::processStarted() void CMakeBuildStep::processStarted()
{ {
futureInterface()->setProgressRange(0, 100); futureInterface()->setProgressRange(0, 100);
AbstractProcessStep::processStarted(); AbstractProcessStep::processStarted();
} }
void MakeStep::processFinished(int exitCode, QProcess::ExitStatus status) void CMakeBuildStep::processFinished(int exitCode, QProcess::ExitStatus status)
{ {
AbstractProcessStep::processFinished(exitCode, status); AbstractProcessStep::processFinished(exitCode, status);
futureInterface()->setProgressValue(100); futureInterface()->setProgressValue(100);

30
src/plugins/cmakeprojectmanager/makestep.h → src/plugins/cmakeprojectmanager/cmakebuildstep.h
View File

@@ -28,8 +28,8 @@
** **
****************************************************************************/ ****************************************************************************/
#ifndef MAKESTEP_H #ifndef CMAKEBUILDSTEP_H
#define MAKESTEP_H #define CMAKEBUILDSTEP_H
#include <projectexplorer/abstractprocessstep.h> #include <projectexplorer/abstractprocessstep.h>
@@ -48,15 +48,15 @@ namespace Internal {
class CMakeBuildConfiguration; class CMakeBuildConfiguration;
class CMakeRunConfiguration; class CMakeRunConfiguration;
class MakeStepFactory; class CMakeBuildStepFactory;
class MakeStep : public ProjectExplorer::AbstractProcessStep class CMakeBuildStep : public ProjectExplorer::AbstractProcessStep
{ {
Q_OBJECT Q_OBJECT
friend class MakeStepFactory; friend class CMakeBuildStepFactory;
public: public:
explicit MakeStep(ProjectExplorer::BuildStepList *bsl); explicit CMakeBuildStep(ProjectExplorer::BuildStepList *bsl);
CMakeBuildConfiguration *cmakeBuildConfiguration() const; CMakeBuildConfiguration *cmakeBuildConfiguration() const;
@@ -100,8 +100,8 @@ protected:
void processStarted() override; void processStarted() override;
void processFinished(int exitCode, QProcess::ExitStatus status) override; void processFinished(int exitCode, QProcess::ExitStatus status) override;
MakeStep(ProjectExplorer::BuildStepList *bsl, MakeStep *bs); CMakeBuildStep(ProjectExplorer::BuildStepList *bsl, CMakeBuildStep *bs);
MakeStep(ProjectExplorer::BuildStepList *bsl, Core::Id id); CMakeBuildStep(ProjectExplorer::BuildStepList *bsl, Core::Id id);
bool fromMap(const QVariantMap &map) override; bool fromMap(const QVariantMap &map) override;
@@ -124,11 +124,11 @@ private:
QString m_makeCmd; QString m_makeCmd;
}; };
class MakeStepConfigWidget : public ProjectExplorer::BuildStepConfigWidget class CMakeBuildStepConfigWidget : public ProjectExplorer::BuildStepConfigWidget
{ {
Q_OBJECT Q_OBJECT
public: public:
MakeStepConfigWidget(MakeStep *makeStep); CMakeBuildStepConfigWidget(CMakeBuildStep *buildStep);
virtual QString displayName() const; virtual QString displayName() const;
virtual QString summaryText() const; virtual QString summaryText() const;
@@ -141,20 +141,20 @@ private:
void selectedBuildTargetsChanged(); void selectedBuildTargetsChanged();
private: private:
MakeStep *m_makeStep; CMakeBuildStep *m_buildStep;
Utils::PathChooser *m_makePathChooser; Utils::PathChooser *m_makePathChooser;
QListWidget *m_buildTargetsList; QListWidget *m_buildTargetsList;
QLineEdit *m_additionalArguments; QLineEdit *m_additionalArguments;
QString m_summaryText; QString m_summaryText;
}; };
class MakeStepFactory : public ProjectExplorer::IBuildStepFactory class CMakeBuildStepFactory : public ProjectExplorer::IBuildStepFactory
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit MakeStepFactory(QObject *parent = 0); explicit CMakeBuildStepFactory(QObject *parent = 0);
virtual ~MakeStepFactory(); virtual ~CMakeBuildStepFactory();
bool canCreate(ProjectExplorer::BuildStepList *parent, Core::Id id) const; bool canCreate(ProjectExplorer::BuildStepList *parent, Core::Id id) const;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id); ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id);
@@ -170,4 +170,4 @@ public:
} // namespace Internal } // namespace Internal
} // namespace CMakeProjectManager } // namespace CMakeProjectManager
#endif // MAKESTEP_H #endif // CMAKEBUILDSTEP_H

24
src/plugins/cmakeprojectmanager/cmakelocatorfilter.cpp
View File

@@ -29,16 +29,17 @@
****************************************************************************/ ****************************************************************************/
#include "cmakelocatorfilter.h" #include "cmakelocatorfilter.h"
#include "cmakebuildstep.h"
#include "cmakeproject.h" #include "cmakeproject.h"
#include "makestep.h"
#include <projectexplorer/projectexplorer.h> #include <projectexplorer/projectexplorer.h>
#include <projectexplorer/session.h> #include <projectexplorer/session.h>
#include <projectexplorer/target.h> #include <projectexplorer/target.h>
#include <projectexplorer/projectexplorerconstants.h> #include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/buildsteplist.h> #include <projectexplorer/buildsteplist.h>
#include <utils/fileutils.h>
#include <utils/algorithm.h>
#include <utils/fileutils.h>
using namespace CMakeProjectManager; using namespace CMakeProjectManager;
using namespace CMakeProjectManager::Internal; using namespace CMakeProjectManager::Internal;
@@ -111,25 +112,22 @@ void CMakeLocatorFilter::accept(Core::LocatorFilterEntry selection) const
return; return;
// Find the make step // Find the make step
MakeStep *makeStep = 0;
ProjectExplorer::BuildStepList *buildStepList = cmakeProject->activeTarget()->activeBuildConfiguration() ProjectExplorer::BuildStepList *buildStepList = cmakeProject->activeTarget()->activeBuildConfiguration()
->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD); ->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
for (int i = 0; i < buildStepList->count(); ++i) { auto buildStep
makeStep = qobject_cast<MakeStep *>(buildStepList->at(i)); = qobject_cast<CMakeBuildStep *>(findOrDefault(buildStepList->steps(),
if (makeStep) [](BuildStep *s) -> bool { return qobject_cast<CMakeBuildStep *>(s); }));
break; if (!buildStep)
}
if (!makeStep)
return; return;
// Change the make step to build only the given target // Change the make step to build only the given target
QStringList oldTargets = makeStep->buildTargets(); QStringList oldTargets = buildStep->buildTargets();
makeStep->clearBuildTargets(); buildStep->clearBuildTargets();
makeStep->setBuildTarget(selection.displayName, true); buildStep->setBuildTarget(selection.displayName, true);
// Build // Build
ProjectExplorerPlugin::buildProject(cmakeProject); ProjectExplorerPlugin::buildProject(cmakeProject);
makeStep->setBuildTargets(oldTargets); buildStep->setBuildTargets(oldTargets);
} }
void CMakeLocatorFilter::refresh(QFutureInterface<void> &future) void CMakeLocatorFilter::refresh(QFutureInterface<void> &future)

2
src/plugins/cmakeprojectmanager/cmakeproject.cpp
View File

@@ -31,10 +31,10 @@
#include "cmakeproject.h" #include "cmakeproject.h"
#include "cmakebuildconfiguration.h" #include "cmakebuildconfiguration.h"
#include "cmakebuildstep.h"
#include "cmakeprojectconstants.h" #include "cmakeprojectconstants.h"
#include "cmakeprojectnodes.h" #include "cmakeprojectnodes.h"
#include "cmakerunconfiguration.h" #include "cmakerunconfiguration.h"
#include "makestep.h"
#include "cmakeopenprojectwizard.h" #include "cmakeopenprojectwizard.h"
#include "cmakecbpparser.h" #include "cmakecbpparser.h"
#include "cmakefile.h" #include "cmakefile.h"

6
src/plugins/cmakeprojectmanager/cmakeprojectmanager.pro
View File

@@ -2,12 +2,12 @@ DEFINES += CMAKEPROJECTMANAGER_LIBRARY
include(../../qtcreatorplugin.pri) include(../../qtcreatorplugin.pri)
HEADERS = cmakebuildinfo.h \ HEADERS = cmakebuildinfo.h \
cmakebuildstep.h \
cmakeproject.h \ cmakeproject.h \
cmakeprojectplugin.h \ cmakeprojectplugin.h \
cmakeprojectmanager.h \ cmakeprojectmanager.h \
cmakeprojectconstants.h \ cmakeprojectconstants.h \
cmakeprojectnodes.h \ cmakeprojectnodes.h \
makestep.h \
cmakerunconfiguration.h \ cmakerunconfiguration.h \
cmakeopenprojectwizard.h \ cmakeopenprojectwizard.h \
cmakebuildconfiguration.h \ cmakebuildconfiguration.h \
@@ -30,11 +30,11 @@ HEADERS = cmakebuildinfo.h \
cmakepreloadcachekitinformation.h \ cmakepreloadcachekitinformation.h \
cmakepreloadcachekitconfigwidget.h cmakepreloadcachekitconfigwidget.h
SOURCES = cmakeproject.cpp \ SOURCES = cmakebuildstep.cpp \
cmakeproject.cpp \
cmakeprojectplugin.cpp \ cmakeprojectplugin.cpp \
cmakeprojectmanager.cpp \ cmakeprojectmanager.cpp \
cmakeprojectnodes.cpp \ cmakeprojectnodes.cpp \
makestep.cpp \
cmakerunconfiguration.cpp \ cmakerunconfiguration.cpp \
cmakeopenprojectwizard.cpp \ cmakeopenprojectwizard.cpp \
cmakebuildconfiguration.cpp \ cmakebuildconfiguration.cpp \

4
src/plugins/cmakeprojectmanager/cmakeprojectmanager.qbs
View File

@@ -23,6 +23,8 @@ QtcPlugin {
"cmakebuildinfo.h", "cmakebuildinfo.h",
"cmakebuildsettingswidget.cpp", "cmakebuildsettingswidget.cpp",
"cmakebuildsettingswidget.h", "cmakebuildsettingswidget.h",
"cmakebuildstep.cpp",
"cmakebuildstep.h",
"cmakecbpparser.cpp", "cmakecbpparser.cpp",
"cmakecbpparser.h", "cmakecbpparser.h",
"cmakeeditor.cpp", "cmakeeditor.cpp",
@@ -61,8 +63,6 @@ QtcPlugin {
"cmaketool.h", "cmaketool.h",
"cmaketoolmanager.cpp", "cmaketoolmanager.cpp",
"cmaketoolmanager.h", "cmaketoolmanager.h",
"makestep.cpp",
"makestep.h",
"cmakesettingspage.h", "cmakesettingspage.h",
"cmakesettingspage.cpp", "cmakesettingspage.cpp",
"generatorinfo.h", "generatorinfo.h",

4
src/plugins/cmakeprojectmanager/cmakeprojectplugin.cpp
View File

@@ -31,10 +31,10 @@
#include "cmakeprojectplugin.h" #include "cmakeprojectplugin.h"
#include "cmakeeditor.h" #include "cmakeeditor.h"
#include "cmakebuildstep.h"
#include "cmakeprojectmanager.h" #include "cmakeprojectmanager.h"
#include "cmakebuildconfiguration.h" #include "cmakebuildconfiguration.h"
#include "cmakerunconfiguration.h" #include "cmakerunconfiguration.h"
#include "makestep.h"
#include "cmakeprojectconstants.h" #include "cmakeprojectconstants.h"
#include "cmakelocatorfilter.h" #include "cmakelocatorfilter.h"
#include "cmakesettingspage.h" #include "cmakesettingspage.h"
@@ -67,7 +67,7 @@ bool CMakeProjectPlugin::initialize(const QStringList & /*arguments*/, QString *
addAutoReleasedObject(new CMakeSettingsPage); addAutoReleasedObject(new CMakeSettingsPage);
addAutoReleasedObject(new CMakeManager); addAutoReleasedObject(new CMakeManager);
addAutoReleasedObject(new MakeStepFactory); addAutoReleasedObject(new CMakeBuildStepFactory);
addAutoReleasedObject(new CMakeRunConfigurationFactory); addAutoReleasedObject(new CMakeRunConfigurationFactory);
addAutoReleasedObject(new CMakeBuildConfigurationFactory); addAutoReleasedObject(new CMakeBuildConfigurationFactory);
addAutoReleasedObject(new CMakeEditorFactory); addAutoReleasedObject(new CMakeEditorFactory);