blob: 2054a840c145677116114494883439a01ecd9147 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#pragma once
#include "buildtargetinfo.h"
#include "projectconfiguration.h"
#include "task.h"
#include <utils/aspects.h>
#include <utils/environment.h>
#include <utils/macroexpander.h>
#include <functional>
#include <memory>
namespace Utils {
class OutputFormatter;
class ProcessRunData;
}
namespace ProjectExplorer {
class BuildConfiguration;
class BuildSystem;
class GlobalOrProjectAspect;
class ProjectNode;
class RunConfigurationFactory;
class RunConfiguration;
class RunConfigurationCreationInfo;
class Target;
/**
* An interface to facilitate switching between hunks of
* global and per-project configuration data.
*
*/
class PROJECTEXPLORER_EXPORT GlobalOrProjectAspect : public Utils::BaseAspect
{
Q_OBJECT
public:
GlobalOrProjectAspect();
~GlobalOrProjectAspect() override;
void setProjectSettings(Utils::AspectContainer *settings);
void setGlobalSettings(Utils::AspectContainer *settings);
bool isUsingGlobalSettings() const { return m_useGlobalSettings; }
void setUsingGlobalSettings(bool value);
void resetProjectToGlobalSettings();
Utils::AspectContainer *projectSettings() const { return m_projectSettings; }
Utils::AspectContainer *currentSettings() const;
struct Data : Utils::BaseAspect::Data
{
Utils::AspectContainer *currentSettings = nullptr;
};
protected:
friend class RunConfiguration;
void fromMap(const Utils::Store &map) override;
void toMap(Utils::Store &data) const override;
void toActiveMap(Utils::Store &data) const override;
private:
bool m_useGlobalSettings = false;
Utils::AspectContainer *m_projectSettings = nullptr; // Owned if present.
Utils::AspectContainer *m_globalSettings = nullptr; // Not owned.
};
// Documentation inside.
class PROJECTEXPLORER_EXPORT RunConfiguration : public ProjectConfiguration
{
Q_OBJECT
public:
~RunConfiguration() override;
virtual QString disabledReason(Utils::Id runMode) const;
virtual bool isEnabled(Utils::Id runMode) const;
QWidget *createConfigurationWidget();
bool isConfigured() const;
bool isCustomized() const;
bool hasCreator() const;
virtual Tasks checkForIssues() const { return {}; }
void setPristineState();
using CommandLineGetter = std::function<Utils::CommandLine()>;
void setCommandLineGetter(const CommandLineGetter &cmdGetter);
Utils::CommandLine commandLine() const;
bool isPrintEnvironmentEnabled() const;
using RunnableModifier = std::function<void(Utils::ProcessRunData &)>;
void setRunnableModifier(const RunnableModifier &extraModifier);
virtual Utils::ProcessRunData runnable() const;
virtual QVariantHash extraData() const;
// Return a handle to the build system target that created this run configuration.
// May return an empty string if no target built the executable!
QString buildKey() const { return m_buildKey; }
// The BuildTargetInfo corresponding to the buildKey.
BuildTargetInfo buildTargetInfo() const;
ProjectExplorer::ProjectNode *productNode() const;
template <class T = Utils::AspectContainer> T *currentSettings(Utils::Id id) const
{
if (auto a = qobject_cast<GlobalOrProjectAspect *>(aspect(id)))
return qobject_cast<T *>(a->currentSettings());
return nullptr;
}
using ProjectConfiguration::registerAspect;
using AspectFactory = std::function<Utils::BaseAspect *(Target *)>;
template <class T> static void registerAspect()
{
addAspectFactory([](Target *target) { return new T(target); });
}
QMap<Utils::Id, Utils::Store> settingsData() const; // FIXME: Merge into aspectData?
Utils::AspectContainerData aspectData() const;
void update();
const Utils::MacroExpander *macroExpander() const { return &m_expander; }
signals:
void enabledChanged();
protected:
RunConfiguration(Target *target, Utils::Id id);
/// convenience function to get current build system. Try to avoid.
BuildSystem *activeBuildSystem() const;
using Updater = std::function<void()>;
void setUpdater(const Updater &updater);
Task createConfigurationIssue(const QString &description) const;
private:
// Any additional data should be handled by aspects.
void fromMap(const Utils::Store &map) final;
void toMap(Utils::Store &map) const final;
void toMapSimple(Utils::Store &map) const;
static void addAspectFactory(const AspectFactory &aspectFactory);
friend class RunConfigurationCreationInfo;
friend class RunConfigurationFactory;
friend class Target;
QString m_buildKey;
CommandLineGetter m_commandLineGetter;
RunnableModifier m_runnableModifier;
Updater m_updater;
Utils::MacroExpander m_expander;
Utils::Store m_pristineState;
bool m_customized = false;
};
class RunConfigurationCreationInfo
{
public:
enum CreationMode {AlwaysCreate, ManualCreationOnly};
RunConfiguration *create(Target *target) const;
const RunConfigurationFactory *factory = nullptr;
QString buildKey;
QString displayName;
QString displayNameUniquifier;
Utils::FilePath projectFilePath;
CreationMode creationMode = AlwaysCreate;
bool useTerminal = false;
};
class PROJECTEXPLORER_EXPORT RunConfigurationFactory
{
public:
RunConfigurationFactory();
RunConfigurationFactory(const RunConfigurationFactory &) = delete;
RunConfigurationFactory operator=(const RunConfigurationFactory &) = delete;
virtual ~RunConfigurationFactory();
static RunConfiguration *restore(Target *parent, const Utils::Store &map);
static RunConfiguration *clone(Target *parent, RunConfiguration *source);
static const QList<RunConfigurationCreationInfo> creatorsForTarget(Target *parent);
Utils::Id runConfigurationId() const { return m_runConfigurationId; }
static QString decoratedTargetName(const QString &targetName, Target *kit);
protected:
virtual QList<RunConfigurationCreationInfo> availableCreators(Target *target) const;
virtual bool supportsBuildKey(Target *target, const QString &key) const;
using RunConfigurationCreator = std::function<RunConfiguration *(Target *)>;
template <class RunConfig>
void registerRunConfiguration(Utils::Id runConfigurationId)
{
m_creator = [runConfigurationId](Target *t) -> RunConfiguration * {
return new RunConfig(t, runConfigurationId);
};
m_runConfigurationId = runConfigurationId;
}
void addSupportedProjectType(Utils::Id projectTypeId);
void addSupportedTargetDeviceType(Utils::Id deviceTypeId);
void setDecorateDisplayNames(bool on);
private:
bool canHandle(Target *target) const;
RunConfiguration *create(Target *target) const;
friend class RunConfigurationCreationInfo;
friend class RunConfiguration;
RunConfigurationCreator m_creator;
Utils::Id m_runConfigurationId;
QList<Utils::Id> m_supportedProjectTypes;
QList<Utils::Id> m_supportedTargetDeviceTypes;
bool m_decorateDisplayNames = false;
};
class PROJECTEXPLORER_EXPORT FixedRunConfigurationFactory : public RunConfigurationFactory
{
public:
explicit FixedRunConfigurationFactory(const QString &displayName,
bool addDeviceName = false);
private:
QList<RunConfigurationCreationInfo> availableCreators(Target *parent) const override;
bool supportsBuildKey(Target *target, const QString &key) const override;
const QString m_fixedBuildTarget;
const bool m_decorateTargetName;
};
} // namespace ProjectExplorer
|
