1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of Qt Creator.
7 **
8 ** Commercial License Usage
9 ** Licensees holding valid commercial Qt licenses may use this file in
10 ** accordance with the commercial license agreement provided with the
11 ** Software or, alternatively, in accordance with the terms contained in
12 ** a written agreement between you and The Qt Company. For licensing terms
13 ** and conditions see https://www.qt.io/terms-conditions. For further
14 ** information use the contact form at https://www.qt.io/contact-us.
15 **
16 ** GNU General Public License Usage
17 ** Alternatively, this file may be used under the terms of the GNU
18 ** General Public License version 3 as published by the Free Software
19 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
20 ** included in the packaging of this file. Please review the following
21 ** information to ensure the GNU General Public License requirements will
22 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
23 **
24 ****************************************************************************/
25
26 #include "buildconfiguration.h"
27
28 #include "buildaspects.h"
29 #include "buildinfo.h"
30 #include "buildsteplist.h"
31 #include "buildstepspage.h"
32 #include "buildsystem.h"
33 #include "customparser.h"
34 #include "environmentwidget.h"
35 #include "kit.h"
36 #include "kitinformation.h"
37 #include "kitmanager.h"
38 #include "namedwidget.h"
39 #include "projectexplorerconstants.h"
40 #include "projectexplorer.h"
41 #include "project.h"
42 #include "projectmacroexpander.h"
43 #include "projecttree.h"
44 #include "session.h"
45 #include "target.h"
46 #include "toolchain.h"
47
48 #include <coreplugin/icore.h>
49 #include <coreplugin/idocument.h>
50
51 #include <utils/algorithm.h>
52 #include <utils/detailswidget.h>
53 #include <utils/macroexpander.h>
54 #include <utils/mimetypes/mimedatabase.h>
55 #include <utils/mimetypes/mimetype.h>
56 #include <utils/layoutbuilder.h>
57 #include <utils/qtcassert.h>
58 #include <utils/variablechooser.h>
59
60 #include <QCheckBox>
61 #include <QDebug>
62 #include <QFormLayout>
63 #include <QVBoxLayout>
64
65 using namespace Utils;
66
67 const char BUILD_STEP_LIST_COUNT[] = "ProjectExplorer.BuildConfiguration.BuildStepListCount";
68 const char BUILD_STEP_LIST_PREFIX[] = "ProjectExplorer.BuildConfiguration.BuildStepList.";
69 const char CLEAR_SYSTEM_ENVIRONMENT_KEY[] = "ProjectExplorer.BuildConfiguration.ClearSystemEnvironment";
70 const char USER_ENVIRONMENT_CHANGES_KEY[] = "ProjectExplorer.BuildConfiguration.UserEnvironmentChanges";
71 const char CUSTOM_PARSERS_KEY[] = "ProjectExplorer.BuildConfiguration.CustomParsers";
72
73 namespace ProjectExplorer {
74 namespace Internal {
75
76 class BuildEnvironmentWidget : public NamedWidget
77 {
78 Q_DECLARE_TR_FUNCTIONS(ProjectExplorer::Internal::BuildEnvironmentWidget)
79
80 public:
BuildEnvironmentWidget(BuildConfiguration * bc)81 explicit BuildEnvironmentWidget(BuildConfiguration *bc)
82 : NamedWidget(tr("Build Environment"))
83 {
84 auto clearBox = new QCheckBox(tr("Clear system environment"), this);
85 clearBox->setChecked(!bc->useSystemEnvironment());
86
87 auto envWidget = new EnvironmentWidget(this, EnvironmentWidget::TypeLocal, clearBox);
88 envWidget->setBaseEnvironment(bc->baseEnvironment());
89 envWidget->setBaseEnvironmentText(bc->baseEnvironmentText());
90 envWidget->setUserChanges(bc->userEnvironmentChanges());
91
92 connect(envWidget, &EnvironmentWidget::userChangesChanged, this, [bc, envWidget] {
93 bc->setUserEnvironmentChanges(envWidget->userChanges());
94 });
95
96 connect(clearBox, &QAbstractButton::toggled, this, [bc, envWidget](bool checked) {
97 bc->setUseSystemEnvironment(!checked);
98 envWidget->setBaseEnvironment(bc->baseEnvironment());
99 envWidget->setBaseEnvironmentText(bc->baseEnvironmentText());
100 });
101
102 connect(bc, &BuildConfiguration::environmentChanged, this, [bc, envWidget] {
103 envWidget->setBaseEnvironment(bc->baseEnvironment());
104 envWidget->setBaseEnvironmentText(bc->baseEnvironmentText());
105 });
106
107 auto vbox = new QVBoxLayout(this);
108 vbox->setContentsMargins(0, 0, 0, 0);
109 vbox->addWidget(clearBox);
110 vbox->addWidget(envWidget);
111 }
112 };
113
114 class CustomParsersBuildWidget : public NamedWidget
115 {
116 Q_DECLARE_TR_FUNCTIONS(ProjectExplorer::Internal::CustomParsersBuildWidget)
117 public:
CustomParsersBuildWidget(BuildConfiguration * bc)118 CustomParsersBuildWidget(BuildConfiguration *bc) : NamedWidget(tr("Custom Output Parsers"))
119 {
120 const auto selectionWidget = new CustomParsersSelectionWidget(this);
121 const auto layout = new QVBoxLayout(this);
122 layout->setContentsMargins(0, 0, 0, 0);
123 layout->addWidget(selectionWidget);
124
125 connect(selectionWidget, &CustomParsersSelectionWidget::selectionChanged,
126 [selectionWidget, bc] {
127 bc->setCustomParsers(selectionWidget->selectedParsers());
128 });
129 selectionWidget->setSelectedParsers(bc->customParsers());
130 }
131 };
132
133
134 class BuildConfigurationPrivate
135 {
136 public:
BuildConfigurationPrivate(BuildConfiguration * bc)137 BuildConfigurationPrivate(BuildConfiguration *bc)
138 : m_buildSteps(bc, Constants::BUILDSTEPS_BUILD),
139 m_cleanSteps(bc, Constants::BUILDSTEPS_CLEAN)
140 {}
141
142 bool m_clearSystemEnvironment = false;
143 EnvironmentItems m_userEnvironmentChanges;
144 BuildStepList m_buildSteps;
145 BuildStepList m_cleanSteps;
146 BuildDirectoryAspect *m_buildDirectoryAspect = nullptr;
147 StringAspect *m_tooltipAspect = nullptr;
148 FilePath m_lastEmittedBuildDirectory;
149 mutable Environment m_cachedEnvironment;
150 QString m_configWidgetDisplayName;
151 bool m_configWidgetHasFrame = false;
152 QList<Utils::Id> m_initialBuildSteps;
153 QList<Utils::Id> m_initialCleanSteps;
154 Utils::MacroExpander m_macroExpander;
155 QList<Utils::Id> m_customParsers;
156
157 // FIXME: Remove.
158 BuildConfiguration::BuildType m_initialBuildType = BuildConfiguration::Unknown;
159 std::function<void(const BuildInfo &)> m_initializer;
160 };
161
162 } // Internal
163
BuildConfiguration(Target * target,Utils::Id id)164 BuildConfiguration::BuildConfiguration(Target *target, Utils::Id id)
165 : ProjectConfiguration(target, id), d(new Internal::BuildConfigurationPrivate(this))
166 {
167 QTC_CHECK(target && target == this->target());
168
169 MacroExpander *expander = macroExpander();
170 expander->setDisplayName(tr("Build Settings"));
171 expander->setAccumulating(true);
172 expander->registerSubProvider([target] { return target->macroExpander(); });
173
174 expander->registerVariable("buildDir", tr("Build directory"),
175 [this] { return buildDirectory().toUserOutput(); });
176
177 // TODO: Remove "Current" variants in ~4.16.
178 expander->registerVariable(Constants::VAR_CURRENTBUILD_NAME, tr("Name of current build"),
179 [this] { return displayName(); }, false);
180
181 expander->registerVariable("BuildConfig:Name", tr("Name of the build configuration"),
182 [this] { return displayName(); });
183
184 expander->registerPrefix(Constants::VAR_CURRENTBUILD_ENV,
185 tr("Variables in the current build environment"),
186 [this](const QString &var) { return environment().expandedValueForKey(var); }, false);
187 expander->registerPrefix("BuildConfig:Env",
188 tr("Variables in the build configuration's environment"),
189 [this](const QString &var) { return environment().expandedValueForKey(var); });
190
191 updateCacheAndEmitEnvironmentChanged();
192 connect(Core::ICore::instance(), &Core::ICore::systemEnvironmentChanged,
193 this, &BuildConfiguration::updateCacheAndEmitEnvironmentChanged);
194 connect(target, &Target::kitChanged,
195 this, &BuildConfiguration::updateCacheAndEmitEnvironmentChanged);
196 connect(this, &BuildConfiguration::environmentChanged,
197 this, &BuildConfiguration::emitBuildDirectoryChanged);
198 connect(target->project(), &Project::environmentChanged,
199 this, &BuildConfiguration::updateCacheAndEmitEnvironmentChanged);
200 // Many macroexpanders are based on the current project, so they may change the environment:
201 connect(ProjectTree::instance(), &ProjectTree::currentProjectChanged,
202 this, &BuildConfiguration::updateCacheAndEmitEnvironmentChanged);
203
204 d->m_buildDirectoryAspect = addAspect<BuildDirectoryAspect>(this);
205 d->m_buildDirectoryAspect->setBaseFileName(target->project()->projectDirectory());
206 d->m_buildDirectoryAspect->setEnvironment(environment());
207 d->m_buildDirectoryAspect->setMacroExpanderProvider([this] { return macroExpander(); });
208 connect(d->m_buildDirectoryAspect, &StringAspect::changed,
209 this, &BuildConfiguration::emitBuildDirectoryChanged);
210 connect(this, &BuildConfiguration::environmentChanged, this, [this] {
211 d->m_buildDirectoryAspect->setEnvironment(environment());
212 emit this->target()->buildEnvironmentChanged(this);
213 });
214
215 d->m_tooltipAspect = addAspect<StringAspect>();
216 d->m_tooltipAspect->setLabelText(tr("Tooltip in target selector:"));
217 d->m_tooltipAspect->setToolTip(tr("Appears as a tooltip when hovering the build configuration"));
218 d->m_tooltipAspect->setDisplayStyle(StringAspect::LineEditDisplay);
219 d->m_tooltipAspect->setSettingsKey("ProjectExplorer.BuildConfiguration.Tooltip");
220 connect(d->m_tooltipAspect, &StringAspect::changed, this, [this] {
221 setToolTip(d->m_tooltipAspect->value());
222 });
223
224 connect(target, &Target::parsingStarted, this, &BuildConfiguration::enabledChanged);
225 connect(target, &Target::parsingFinished, this, &BuildConfiguration::enabledChanged);
226 connect(this, &BuildConfiguration::enabledChanged, this, [this] {
227 if (isActive() && project() == SessionManager::startupProject()) {
228 ProjectExplorerPlugin::updateActions();
229 ProjectExplorerPlugin::updateRunActions();
230 }
231 });
232 }
233
~BuildConfiguration()234 BuildConfiguration::~BuildConfiguration()
235 {
236 delete d;
237 }
238
buildDirectory() const239 FilePath BuildConfiguration::buildDirectory() const
240 {
241 QString path = environment().expandVariables(d->m_buildDirectoryAspect->value().trimmed());
242 path = QDir::cleanPath(macroExpander()->expand(path));
243
244 const FilePath projectDir = target()->project()->projectDirectory();
245 const FilePath buildDir = projectDir.absoluteFilePath(FilePath::fromString(path));
246
247 return mapFromBuildDeviceToGlobalPath(buildDir);
248 }
249
rawBuildDirectory() const250 FilePath BuildConfiguration::rawBuildDirectory() const
251 {
252 return d->m_buildDirectoryAspect->filePath();
253 }
254
setBuildDirectory(const FilePath & dir)255 void BuildConfiguration::setBuildDirectory(const FilePath &dir)
256 {
257 if (dir == d->m_buildDirectoryAspect->filePath())
258 return;
259 d->m_buildDirectoryAspect->setFilePath(dir);
260 const FilePath fixedDir = BuildDirectoryAspect::fixupDir(buildDirectory());
261 if (!fixedDir.isEmpty())
262 d->m_buildDirectoryAspect->setFilePath(fixedDir);
263 emitBuildDirectoryChanged();
264 }
265
addConfigWidgets(const std::function<void (NamedWidget *)> & adder)266 void BuildConfiguration::addConfigWidgets(const std::function<void(NamedWidget *)> &adder)
267 {
268 if (NamedWidget *generalConfigWidget = createConfigWidget())
269 adder(generalConfigWidget);
270
271 adder(new Internal::BuildStepListWidget(buildSteps()));
272 adder(new Internal::BuildStepListWidget(cleanSteps()));
273
274 QList<NamedWidget *> subConfigWidgets = createSubConfigWidgets();
275 foreach (NamedWidget *subConfigWidget, subConfigWidgets)
276 adder(subConfigWidget);
277 }
278
doInitialize(const BuildInfo & info)279 void BuildConfiguration::doInitialize(const BuildInfo &info)
280 {
281 setDisplayName(info.displayName);
282 setDefaultDisplayName(info.displayName);
283 setBuildDirectory(info.buildDirectory);
284
285 d->m_initialBuildType = info.buildType;
286
287 for (Utils::Id id : qAsConst(d->m_initialBuildSteps))
288 d->m_buildSteps.appendStep(id);
289
290 for (Utils::Id id : qAsConst(d->m_initialCleanSteps))
291 d->m_cleanSteps.appendStep(id);
292
293 acquaintAspects();
294
295 if (d->m_initializer)
296 d->m_initializer(info);
297 }
298
macroExpander() const299 MacroExpander *BuildConfiguration::macroExpander() const
300 {
301 return &d->m_macroExpander;
302 }
303
createBuildDirectory()304 bool BuildConfiguration::createBuildDirectory()
305 {
306 const bool result = buildDirectory().ensureWritableDir();
307 buildDirectoryAspect()->validateInput();
308 return result;
309 }
310
setInitializer(const std::function<void (const BuildInfo &)> & initializer)311 void BuildConfiguration::setInitializer(const std::function<void(const BuildInfo &)> &initializer)
312 {
313 d->m_initializer = initializer;
314 }
315
createConfigWidget()316 NamedWidget *BuildConfiguration::createConfigWidget()
317 {
318 NamedWidget *named = new NamedWidget(d->m_configWidgetDisplayName);
319
320 QWidget *widget = nullptr;
321
322 if (d->m_configWidgetHasFrame) {
323 auto container = new DetailsWidget(named);
324 widget = new QWidget(container);
325 container->setState(DetailsWidget::NoSummary);
326 container->setWidget(widget);
327
328 auto vbox = new QVBoxLayout(named);
329 vbox->setContentsMargins(0, 0, 0, 0);
330 vbox->addWidget(container);
331 } else {
332 widget = named;
333 }
334
335 Layouting::Form builder;
336 for (BaseAspect *aspect : aspects()) {
337 if (aspect->isVisible())
338 aspect->addToLayout(builder.finishRow());
339 }
340 builder.attachTo(widget, false);
341
342 return named;
343 }
344
createSubConfigWidgets()345 QList<NamedWidget *> BuildConfiguration::createSubConfigWidgets()
346 {
347 return {
348 new Internal::BuildEnvironmentWidget(this),
349 new Internal::CustomParsersBuildWidget(this)
350 };
351 }
352
buildSystem() const353 BuildSystem *BuildConfiguration::buildSystem() const
354 {
355 QTC_CHECK(target()->fallbackBuildSystem());
356 return target()->fallbackBuildSystem();
357 }
358
buildSteps() const359 BuildStepList *BuildConfiguration::buildSteps() const
360 {
361 return &d->m_buildSteps;
362 }
363
cleanSteps() const364 BuildStepList *BuildConfiguration::cleanSteps() const
365 {
366 return &d->m_cleanSteps;
367 }
368
appendInitialBuildStep(Utils::Id id)369 void BuildConfiguration::appendInitialBuildStep(Utils::Id id)
370 {
371 d->m_initialBuildSteps.append(id);
372 }
373
appendInitialCleanStep(Utils::Id id)374 void BuildConfiguration::appendInitialCleanStep(Utils::Id id)
375 {
376 d->m_initialCleanSteps.append(id);
377 }
378
toMap() const379 QVariantMap BuildConfiguration::toMap() const
380 {
381 QVariantMap map = ProjectConfiguration::toMap();
382
383 map.insert(QLatin1String(CLEAR_SYSTEM_ENVIRONMENT_KEY), d->m_clearSystemEnvironment);
384 map.insert(QLatin1String(USER_ENVIRONMENT_CHANGES_KEY), EnvironmentItem::toStringList(d->m_userEnvironmentChanges));
385
386 map.insert(QLatin1String(BUILD_STEP_LIST_COUNT), 2);
387 map.insert(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(0), d->m_buildSteps.toMap());
388 map.insert(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(1), d->m_cleanSteps.toMap());
389
390 map.insert(CUSTOM_PARSERS_KEY, transform(d->m_customParsers,&Utils::Id::toSetting));
391
392 return map;
393 }
394
fromMap(const QVariantMap & map)395 bool BuildConfiguration::fromMap(const QVariantMap &map)
396 {
397 d->m_clearSystemEnvironment = map.value(QLatin1String(CLEAR_SYSTEM_ENVIRONMENT_KEY)).toBool();
398 d->m_userEnvironmentChanges = EnvironmentItem::fromStringList(map.value(QLatin1String(USER_ENVIRONMENT_CHANGES_KEY)).toStringList());
399
400 updateCacheAndEmitEnvironmentChanged();
401
402 d->m_buildSteps.clear();
403 d->m_cleanSteps.clear();
404
405 int maxI = map.value(QLatin1String(BUILD_STEP_LIST_COUNT), 0).toInt();
406 for (int i = 0; i < maxI; ++i) {
407 QVariantMap data = map.value(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(i)).toMap();
408 if (data.isEmpty()) {
409 qWarning() << "No data for build step list" << i << "found!";
410 continue;
411 }
412 Utils::Id id = idFromMap(data);
413 if (id == Constants::BUILDSTEPS_BUILD) {
414 if (!d->m_buildSteps.fromMap(data))
415 qWarning() << "Failed to restore build step list";
416 } else if (id == Constants::BUILDSTEPS_CLEAN) {
417 if (!d->m_cleanSteps.fromMap(data))
418 qWarning() << "Failed to restore clean step list";
419 } else {
420 qWarning() << "Ignoring unknown step list";
421 }
422 }
423
424 d->m_customParsers = transform(map.value(CUSTOM_PARSERS_KEY).toList(), &Utils::Id::fromSetting);
425
426 const bool res = ProjectConfiguration::fromMap(map);
427 setToolTip(d->m_tooltipAspect->value());
428 return res;
429 }
430
updateCacheAndEmitEnvironmentChanged()431 void BuildConfiguration::updateCacheAndEmitEnvironmentChanged()
432 {
433 Environment env = baseEnvironment();
434 env.modify(userEnvironmentChanges());
435 if (env == d->m_cachedEnvironment)
436 return;
437 d->m_cachedEnvironment = env;
438 emit environmentChanged(); // might trigger buildDirectoryChanged signal!
439 }
440
emitBuildDirectoryChanged()441 void BuildConfiguration::emitBuildDirectoryChanged()
442 {
443 if (buildDirectory() != d->m_lastEmittedBuildDirectory) {
444 d->m_lastEmittedBuildDirectory = buildDirectory();
445 emit buildDirectoryChanged();
446 }
447 }
448
buildDirectoryAspect() const449 ProjectExplorer::BuildDirectoryAspect *BuildConfiguration::buildDirectoryAspect() const
450 {
451 return d->m_buildDirectoryAspect;
452 }
453
setConfigWidgetDisplayName(const QString & display)454 void BuildConfiguration::setConfigWidgetDisplayName(const QString &display)
455 {
456 d->m_configWidgetDisplayName = display;
457 }
458
setBuildDirectoryHistoryCompleter(const QString & history)459 void BuildConfiguration::setBuildDirectoryHistoryCompleter(const QString &history)
460 {
461 d->m_buildDirectoryAspect->setHistoryCompleter(history);
462 }
463
setConfigWidgetHasFrame(bool configWidgetHasFrame)464 void BuildConfiguration::setConfigWidgetHasFrame(bool configWidgetHasFrame)
465 {
466 d->m_configWidgetHasFrame = configWidgetHasFrame;
467 }
468
setBuildDirectorySettingsKey(const QString & key)469 void BuildConfiguration::setBuildDirectorySettingsKey(const QString &key)
470 {
471 d->m_buildDirectoryAspect->setSettingsKey(key);
472 }
473
baseEnvironment() const474 Environment BuildConfiguration::baseEnvironment() const
475 {
476 Environment result;
477 if (useSystemEnvironment())
478 result = Environment::systemEnvironment();
479 addToEnvironment(result);
480 kit()->addToBuildEnvironment(result);
481 result.modify(project()->additionalEnvironment());
482 return result;
483 }
484
baseEnvironmentText() const485 QString BuildConfiguration::baseEnvironmentText() const
486 {
487 if (useSystemEnvironment())
488 return tr("System Environment");
489 else
490 return tr("Clean Environment");
491 }
492
environment() const493 Environment BuildConfiguration::environment() const
494 {
495 return d->m_cachedEnvironment;
496 }
497
setUseSystemEnvironment(bool b)498 void BuildConfiguration::setUseSystemEnvironment(bool b)
499 {
500 if (useSystemEnvironment() == b)
501 return;
502 d->m_clearSystemEnvironment = !b;
503 updateCacheAndEmitEnvironmentChanged();
504 }
505
addToEnvironment(Environment & env) const506 void BuildConfiguration::addToEnvironment(Environment &env) const
507 {
508 Q_UNUSED(env)
509 }
510
customParsers() const511 const QList<Utils::Id> BuildConfiguration::customParsers() const
512 {
513 return d->m_customParsers;
514 }
515
setCustomParsers(const QList<Utils::Id> & parsers)516 void BuildConfiguration::setCustomParsers(const QList<Utils::Id> &parsers)
517 {
518 d->m_customParsers = parsers;
519 }
520
useSystemEnvironment() const521 bool BuildConfiguration::useSystemEnvironment() const
522 {
523 return !d->m_clearSystemEnvironment;
524 }
525
userEnvironmentChanges() const526 EnvironmentItems BuildConfiguration::userEnvironmentChanges() const
527 {
528 return d->m_userEnvironmentChanges;
529 }
530
setUserEnvironmentChanges(const EnvironmentItems & diff)531 void BuildConfiguration::setUserEnvironmentChanges(const EnvironmentItems &diff)
532 {
533 if (d->m_userEnvironmentChanges == diff)
534 return;
535 d->m_userEnvironmentChanges = diff;
536 updateCacheAndEmitEnvironmentChanged();
537 }
538
isEnabled() const539 bool BuildConfiguration::isEnabled() const
540 {
541 return buildSystem()->hasParsingData();
542 }
543
disabledReason() const544 QString BuildConfiguration::disabledReason() const
545 {
546 if (!buildSystem()->hasParsingData())
547 return (tr("The project was not parsed successfully."));
548 return QString();
549 }
550
regenerateBuildFiles(Node * node)551 bool BuildConfiguration::regenerateBuildFiles(Node *node)
552 {
553 Q_UNUSED(node)
554 return false;
555 }
556
restrictNextBuild(const RunConfiguration * rc)557 void BuildConfiguration::restrictNextBuild(const RunConfiguration *rc)
558 {
559 Q_UNUSED(rc)
560 }
561
buildType() const562 BuildConfiguration::BuildType BuildConfiguration::buildType() const
563 {
564 return d->m_initialBuildType;
565 }
566
buildTypeName(BuildConfiguration::BuildType type)567 QString BuildConfiguration::buildTypeName(BuildConfiguration::BuildType type)
568 {
569 switch (type) {
570 case ProjectExplorer::BuildConfiguration::Debug:
571 return QLatin1String("debug");
572 case ProjectExplorer::BuildConfiguration::Profile:
573 return QLatin1String("profile");
574 case ProjectExplorer::BuildConfiguration::Release:
575 return QLatin1String("release");
576 case ProjectExplorer::BuildConfiguration::Unknown: // fallthrough
577 default:
578 return QLatin1String("unknown");
579 }
580 }
581
isActive() const582 bool BuildConfiguration::isActive() const
583 {
584 return target()->isActive() && target()->activeBuildConfiguration() == this;
585 }
586
587 ///
588 // IBuildConfigurationFactory
589 ///
590
591 static QList<BuildConfigurationFactory *> g_buildConfigurationFactories;
592
BuildConfigurationFactory()593 BuildConfigurationFactory::BuildConfigurationFactory()
594 {
595 // Note: Order matters as first-in-queue wins.
596 g_buildConfigurationFactories.prepend(this);
597 }
598
~BuildConfigurationFactory()599 BuildConfigurationFactory::~BuildConfigurationFactory()
600 {
601 g_buildConfigurationFactories.removeOne(this);
602 }
603
reportIssues(ProjectExplorer::Kit * kit,const QString & projectPath,const QString & buildDir) const604 const Tasks BuildConfigurationFactory::reportIssues(ProjectExplorer::Kit *kit, const QString &projectPath,
605 const QString &buildDir) const
606 {
607 if (m_issueReporter)
608 return m_issueReporter(kit, projectPath, buildDir);
609 return {};
610 }
611
allAvailableBuilds(const Target * parent) const612 const QList<BuildInfo> BuildConfigurationFactory::allAvailableBuilds(const Target *parent) const
613 {
614 QTC_ASSERT(m_buildGenerator, return {});
615 QList<BuildInfo> list = m_buildGenerator(parent->kit(), parent->project()->projectFilePath(), false);
616 for (BuildInfo &info : list) {
617 info.factory = this;
618 info.kitId = parent->kit()->id();
619 }
620 return list;
621 }
622
623 const QList<BuildInfo>
allAvailableSetups(const Kit * k,const FilePath & projectPath) const624 BuildConfigurationFactory::allAvailableSetups(const Kit *k, const FilePath &projectPath) const
625 {
626 QTC_ASSERT(m_buildGenerator, return {});
627 QList<BuildInfo> list = m_buildGenerator(k, projectPath, /* forSetup = */ true);
628 for (BuildInfo &info : list) {
629 info.factory = this;
630 info.kitId = k->id();
631 }
632 return list;
633 }
634
supportsTargetDeviceType(Utils::Id id) const635 bool BuildConfigurationFactory::supportsTargetDeviceType(Utils::Id id) const
636 {
637 if (m_supportedTargetDeviceTypes.isEmpty())
638 return true;
639 return m_supportedTargetDeviceTypes.contains(id);
640 }
641
642 // setup
find(const Kit * k,const FilePath & projectPath)643 BuildConfigurationFactory *BuildConfigurationFactory::find(const Kit *k, const FilePath &projectPath)
644 {
645 QTC_ASSERT(k, return nullptr);
646 const Utils::Id deviceType = DeviceTypeKitAspect::deviceTypeId(k);
647 for (BuildConfigurationFactory *factory : qAsConst(g_buildConfigurationFactories)) {
648 if (Utils::mimeTypeForFile(projectPath).matchesName(factory->m_supportedProjectMimeTypeName)
649 && factory->supportsTargetDeviceType(deviceType))
650 return factory;
651 }
652 return nullptr;
653 }
654
655 // create
find(Target * parent)656 BuildConfigurationFactory * BuildConfigurationFactory::find(Target *parent)
657 {
658 for (BuildConfigurationFactory *factory : qAsConst(g_buildConfigurationFactories)) {
659 if (factory->canHandle(parent))
660 return factory;
661 }
662 return nullptr;
663 }
664
setSupportedProjectType(Utils::Id id)665 void BuildConfigurationFactory::setSupportedProjectType(Utils::Id id)
666 {
667 m_supportedProjectType = id;
668 }
669
setSupportedProjectMimeTypeName(const QString & mimeTypeName)670 void BuildConfigurationFactory::setSupportedProjectMimeTypeName(const QString &mimeTypeName)
671 {
672 m_supportedProjectMimeTypeName = mimeTypeName;
673 }
674
addSupportedTargetDeviceType(Utils::Id id)675 void BuildConfigurationFactory::addSupportedTargetDeviceType(Utils::Id id)
676 {
677 m_supportedTargetDeviceTypes.append(id);
678 }
679
canHandle(const Target * target) const680 bool BuildConfigurationFactory::canHandle(const Target *target) const
681 {
682 if (m_supportedProjectType.isValid() && m_supportedProjectType != target->project()->id())
683 return false;
684
685 if (containsType(target->project()->projectIssues(target->kit()), Task::TaskType::Error))
686 return false;
687
688 if (!supportsTargetDeviceType(DeviceTypeKitAspect::deviceTypeId(target->kit())))
689 return false;
690
691 return true;
692 }
693
setBuildGenerator(const BuildGenerator & buildGenerator)694 void BuildConfigurationFactory::setBuildGenerator(const BuildGenerator &buildGenerator)
695 {
696 m_buildGenerator = buildGenerator;
697 }
698
setIssueReporter(const IssueReporter & issueReporter)699 void BuildConfigurationFactory::setIssueReporter(const IssueReporter &issueReporter)
700 {
701 m_issueReporter = issueReporter;
702 }
703
create(Target * parent,const BuildInfo & info) const704 BuildConfiguration *BuildConfigurationFactory::create(Target *parent, const BuildInfo &info) const
705 {
706 if (!canHandle(parent))
707 return nullptr;
708 QTC_ASSERT(m_creator, return nullptr);
709
710 BuildConfiguration *bc = m_creator(parent);
711 if (bc)
712 bc->doInitialize(info);
713
714 return bc;
715 }
716
restore(Target * parent,const QVariantMap & map)717 BuildConfiguration *BuildConfigurationFactory::restore(Target *parent, const QVariantMap &map)
718 {
719 const Utils::Id id = idFromMap(map);
720 for (BuildConfigurationFactory *factory : qAsConst(g_buildConfigurationFactories)) {
721 QTC_ASSERT(factory->m_creator, return nullptr);
722 if (!factory->canHandle(parent))
723 continue;
724 if (!id.name().startsWith(factory->m_buildConfigId.name()))
725 continue;
726 BuildConfiguration *bc = factory->m_creator(parent);
727 bc->acquaintAspects();
728 QTC_ASSERT(bc, return nullptr);
729 if (!bc->fromMap(map)) {
730 delete bc;
731 bc = nullptr;
732 }
733 return bc;
734 }
735 return nullptr;
736 }
737
clone(Target * parent,const BuildConfiguration * source)738 BuildConfiguration *BuildConfigurationFactory::clone(Target *parent,
739 const BuildConfiguration *source)
740 {
741 return restore(parent, source->toMap());
742 }
743
744 } // namespace ProjectExplorer
745