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

ProjectExplorer: Rename KitInformation to KitAspect

Browse Source 
The name "KitInformation" does not properly convey the fact that it
represents a certain *aspect* of a kit. The same goes for
"KitConfigWidget", which in addition was inconsistent with
"KitInformation".
We now use "KitAspect" and "KitAspectWidget".

Change-Id: I9804ee4cedc4d61fad533ea1dd4e4720e67fde97
Reviewed-by: hjk <hjk@qt.io>
This commit is contained in:
Christian Kandeler
2019-02-06 12:50:51 +01:00
parent 46c287fee5
commit 83dd031960
156 changed files with 1156 additions and 1156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/android/androidbuildapkstep.cpp
View File

@@ -160,7 +160,7 @@ bool AndroidBuildApkStep::init()
OutputFormat::ErrorMessage);
}
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit());
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target()->kit());
if (!version)
return false;

26
src/plugins/android/androidconfigurations.cpp
View File

@@ -976,13 +976,13 @@ static bool matchToolChain(const ToolChain *atc, const ToolChain *btc)
static bool matchKits(const Kit *a, const Kit *b)
{
if (QtSupport::QtKitInformation::qtVersion(a) != QtSupport::QtKitInformation::qtVersion(b))
if (QtSupport::QtKitAspect::qtVersion(a) != QtSupport::QtKitAspect::qtVersion(b))
return false;
return matchToolChain(ToolChainKitInformation::toolChain(a, ProjectExplorer::Constants::CXX_LANGUAGE_ID),
ToolChainKitInformation::toolChain(b, ProjectExplorer::Constants::CXX_LANGUAGE_ID))
&& matchToolChain(ToolChainKitInformation::toolChain(a, ProjectExplorer::Constants::C_LANGUAGE_ID),
ToolChainKitInformation::toolChain(b, ProjectExplorer::Constants::C_LANGUAGE_ID));
return matchToolChain(ToolChainKitAspect::toolChain(a, ProjectExplorer::Constants::CXX_LANGUAGE_ID),
ToolChainKitAspect::toolChain(b, ProjectExplorer::Constants::CXX_LANGUAGE_ID))
&& matchToolChain(ToolChainKitAspect::toolChain(a, ProjectExplorer::Constants::C_LANGUAGE_ID),
ToolChainKitAspect::toolChain(b, ProjectExplorer::Constants::C_LANGUAGE_ID));
}
void AndroidConfigurations::registerNewToolChains()
@@ -1027,10 +1027,10 @@ static QVariant findOrRegisterDebugger(ToolChain *tc)
void AndroidConfigurations::updateAutomaticKitList()
{
const QList<Kit *> existingKits = Utils::filtered(KitManager::kits(), [](Kit *k) {
Core::Id deviceTypeId = DeviceTypeKitInformation::deviceTypeId(k);
Core::Id deviceTypeId = DeviceTypeKitAspect::deviceTypeId(k);
if (k->isAutoDetected() && !k->isSdkProvided()
&& deviceTypeId == Core::Id(Constants::ANDROID_DEVICE_TYPE)) {
if (!QtSupport::QtKitInformation::qtVersion(k))
if (!QtSupport::QtKitAspect::qtVersion(k))
KitManager::deregisterKit(k); // Remove autoDetected kits without Qt.
else
return true;
@@ -1076,11 +1076,11 @@ void AndroidConfigurations::updateAutomaticKitList()
auto initBasicKitData = [allLanguages, device](Kit *k, const QtSupport::BaseQtVersion *qt) {
k->setAutoDetected(true);
k->setAutoDetectionSource("AndroidConfiguration");
DeviceTypeKitInformation::setDeviceTypeId(k, Core::Id(Constants::ANDROID_DEVICE_TYPE));
DeviceTypeKitAspect::setDeviceTypeId(k, Core::Id(Constants::ANDROID_DEVICE_TYPE));
for (ToolChain *tc : allLanguages)
ToolChainKitInformation::setToolChain(k, tc);
QtSupport::QtKitInformation::setQtVersion(k, qt);
DeviceKitInformation::setDevice(k, device);
ToolChainKitAspect::setToolChain(k, tc);
QtSupport::QtKitAspect::setQtVersion(k, qt);
DeviceKitAspect::setDevice(k, device);
};
for (const QtSupport::BaseQtVersion *qt : qtVersionsForArch.value(tc->targetAbi())) {
@@ -1098,9 +1098,9 @@ void AndroidConfigurations::updateAutomaticKitList()
toSetup = existingKit;
}
Debugger::DebuggerKitInformation::setDebugger(toSetup, findOrRegisterDebugger(tc));
Debugger::DebuggerKitAspect::setDebugger(toSetup, findOrRegisterDebugger(tc));
AndroidGdbServerKitInformation::setGdbSever(toSetup, currentConfig().gdbServer(tc->targetAbi()));
AndroidGdbServerKitAspect::setGdbSever(toSetup, currentConfig().gdbServer(tc->targetAbi()));
toSetup->makeSticky();
toSetup->setUnexpandedDisplayName(tr("Android for %1 (Clang %2)")

2
src/plugins/android/androiddebugsupport.cpp
View File

@@ -167,7 +167,7 @@ void AndroidDebugSupport::start()
setUseTargetAsync(true);
}
QtSupport::BaseQtVersion *qtVersion = QtSupport::QtKitInformation::qtVersion(kit);
QtSupport::BaseQtVersion *qtVersion = QtSupport::QtKitAspect::qtVersion(kit);
if (isCppDebugging()) {
qCDebug(androidDebugSupportLog) << "C++ debugging enabled";

8
src/plugins/android/androiddeployqtstep.cpp
View File

@@ -149,7 +149,7 @@ AndroidDeployQtStep::AndroidDeployQtStep(ProjectExplorer::BuildStepList *parent)
: ProjectExplorer::BuildStep(parent, stepId())
{
setImmutable(true);
m_uninstallPreviousPackage = QtSupport::QtKitInformation::qtVersion(target()->kit())->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0);
m_uninstallPreviousPackage = QtSupport::QtKitAspect::qtVersion(target()->kit())->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0);
//: AndroidDeployQtStep default display name
setDefaultDisplayName(tr("Deploy to Android device"));
@@ -224,7 +224,7 @@ bool AndroidDeployQtStep::init()
emit addOutput(tr("Deploying to %1").arg(m_serialNumber), OutputFormat::Stdout);
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit());
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target()->kit());
if (!version)
return false;
@@ -527,7 +527,7 @@ void AndroidDeployQtStep::gatherFilesToPull()
if (m_deviceInfo.cpuAbi.contains(QLatin1String("arm64-v8a")) ||
m_deviceInfo.cpuAbi.contains(QLatin1String("x86_64"))) {
const Core::Id cxxLanguageId = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), cxxLanguageId);
ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(), cxxLanguageId);
if (tc && tc->targetAbi().wordWidth() == 64) {
m_filesToPull["/system/bin/app_process64"] = buildDir + "app_process";
libDirName = "lib64";
@@ -634,7 +634,7 @@ void AndroidDeployQtStep::setUninstallPreviousPackage(bool uninstall)
AndroidDeployQtStep::UninstallType AndroidDeployQtStep::uninstallPreviousPackage()
{
if (QtSupport::QtKitInformation::qtVersion(target()->kit())->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0))
if (QtSupport::QtKitAspect::qtVersion(target()->kit())->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0))
return ForceUnintall;
return m_uninstallPreviousPackage ? Uninstall : Keep;
}

78
src/plugins/android/androidgdbserverkitinformation.cpp
View File

@@ -50,43 +50,43 @@ using namespace Utils;
namespace Android {
namespace Internal {
AndroidGdbServerKitInformation::AndroidGdbServerKitInformation()
AndroidGdbServerKitAspect::AndroidGdbServerKitAspect()
{
setId(AndroidGdbServerKitInformation::id());
setId(AndroidGdbServerKitAspect::id());
setPriority(27999); // Just one less than Debugger!
}
QVariant AndroidGdbServerKitInformation::defaultValue(const Kit *kit) const
QVariant AndroidGdbServerKitAspect::defaultValue(const Kit *kit) const
{
return autoDetect(kit).toString();
}
QList<Task> AndroidGdbServerKitInformation::validate(const Kit *) const
QList<Task> AndroidGdbServerKitAspect::validate(const Kit *) const
{
return QList<Task>();
}
KitInformation::ItemList AndroidGdbServerKitInformation::toUserOutput(const Kit *kit) const
KitAspect::ItemList AndroidGdbServerKitAspect::toUserOutput(const Kit *kit) const
{
return KitInformation::ItemList()
<< qMakePair(tr("GDB server"), AndroidGdbServerKitInformation::gdbServer(kit).toUserOutput());
return KitAspect::ItemList()
<< qMakePair(tr("GDB server"), AndroidGdbServerKitAspect::gdbServer(kit).toUserOutput());
}
KitConfigWidget *AndroidGdbServerKitInformation::createConfigWidget(Kit *kit) const
KitAspectWidget *AndroidGdbServerKitAspect::createConfigWidget(Kit *kit) const
{
QTC_ASSERT(kit, return nullptr);
return new AndroidGdbServerKitInformationWidget(kit, this);
return new AndroidGdbServerKitAspectWidget(kit, this);
}
Core::Id AndroidGdbServerKitInformation::id()
Core::Id AndroidGdbServerKitAspect::id()
{
return "Android.GdbServer.Information";
}
bool AndroidGdbServerKitInformation::isAndroidKit(const Kit *kit)
bool AndroidGdbServerKitAspect::isAndroidKit(const Kit *kit)
{
QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(kit);
ToolChain *tc = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(kit);
ToolChain *tc = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (qt && tc)
return qt->type() == QLatin1String(Constants::ANDROIDQT)
&& tc->typeId() == Constants::ANDROID_TOOLCHAIN_ID;
@@ -94,21 +94,21 @@ bool AndroidGdbServerKitInformation::isAndroidKit(const Kit *kit)
}
FileName AndroidGdbServerKitInformation::gdbServer(const Kit *kit)
FileName AndroidGdbServerKitAspect::gdbServer(const Kit *kit)
{
QTC_ASSERT(kit, return FileName());
return FileName::fromString(kit->value(AndroidGdbServerKitInformation::id()).toString());
return FileName::fromString(kit->value(AndroidGdbServerKitAspect::id()).toString());
}
void AndroidGdbServerKitInformation::setGdbSever(Kit *kit, const FileName &gdbServerCommand)
void AndroidGdbServerKitAspect::setGdbSever(Kit *kit, const FileName &gdbServerCommand)
{
QTC_ASSERT(kit, return);
kit->setValue(AndroidGdbServerKitInformation::id(), gdbServerCommand.toString());
kit->setValue(AndroidGdbServerKitAspect::id(), gdbServerCommand.toString());
}
FileName AndroidGdbServerKitInformation::autoDetect(const Kit *kit)
FileName AndroidGdbServerKitAspect::autoDetect(const Kit *kit)
{
ToolChain *tc = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolChain *tc = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_ID)
return FileName();
auto atc = static_cast<AndroidToolChain *>(tc);
@@ -116,12 +116,12 @@ FileName AndroidGdbServerKitInformation::autoDetect(const Kit *kit)
}
///////////////
// AndroidGdbServerKitInformationWidget
// AndroidGdbServerKitAspectWidget
///////////////
AndroidGdbServerKitInformationWidget::AndroidGdbServerKitInformationWidget(Kit *kit, const KitInformation *ki) :
KitConfigWidget(kit, ki),
AndroidGdbServerKitAspectWidget::AndroidGdbServerKitAspectWidget(Kit *kit, const KitAspect *ki) :
KitAspectWidget(kit, ki),
m_label(new ElidingLabel),
m_button(new QPushButton(tr("Manage...")))
{
@@ -129,62 +129,62 @@ AndroidGdbServerKitInformationWidget::AndroidGdbServerKitInformationWidget(Kit *
auto buttonMenu = new QMenu(m_button);
QAction *autoDetectAction = buttonMenu->addAction(tr("Auto-detect"));
connect(autoDetectAction, &QAction::triggered,
this, &AndroidGdbServerKitInformationWidget::autoDetectDebugger);
this, &AndroidGdbServerKitAspectWidget::autoDetectDebugger);
QAction *changeAction = buttonMenu->addAction(tr("Edit..."));
connect(changeAction, &QAction::triggered,
this, &AndroidGdbServerKitInformationWidget::showDialog);
this, &AndroidGdbServerKitAspectWidget::showDialog);
m_button->setMenu(buttonMenu);
refresh();
}
AndroidGdbServerKitInformationWidget::~AndroidGdbServerKitInformationWidget()
AndroidGdbServerKitAspectWidget::~AndroidGdbServerKitAspectWidget()
{
delete m_button;
delete m_label;
}
QString AndroidGdbServerKitInformationWidget::displayName() const
QString AndroidGdbServerKitAspectWidget::displayName() const
{
return tr("Android GDB server");
}
QString AndroidGdbServerKitInformationWidget::toolTip() const
QString AndroidGdbServerKitAspectWidget::toolTip() const
{
return tr("The GDB server to use for this kit.");
}
void AndroidGdbServerKitInformationWidget::makeReadOnly()
void AndroidGdbServerKitAspectWidget::makeReadOnly()
{
m_button->setEnabled(false);
}
void AndroidGdbServerKitInformationWidget::refresh()
void AndroidGdbServerKitAspectWidget::refresh()
{
m_label->setText(AndroidGdbServerKitInformation::gdbServer(m_kit).toString());
m_label->setText(AndroidGdbServerKitAspect::gdbServer(m_kit).toString());
}
bool AndroidGdbServerKitInformationWidget::visibleInKit()
bool AndroidGdbServerKitAspectWidget::visibleInKit()
{
return DeviceKitInformation::deviceId(m_kit) == Constants::ANDROID_DEVICE_ID;
return DeviceKitAspect::deviceId(m_kit) == Constants::ANDROID_DEVICE_ID;
}
QWidget *AndroidGdbServerKitInformationWidget::mainWidget() const
QWidget *AndroidGdbServerKitAspectWidget::mainWidget() const
{
return m_label;
}
QWidget *AndroidGdbServerKitInformationWidget::buttonWidget() const
QWidget *AndroidGdbServerKitAspectWidget::buttonWidget() const
{
return m_button;
}
void AndroidGdbServerKitInformationWidget::autoDetectDebugger()
void AndroidGdbServerKitAspectWidget::autoDetectDebugger()
{
AndroidGdbServerKitInformation::setGdbSever(m_kit, AndroidGdbServerKitInformation::autoDetect(m_kit));
AndroidGdbServerKitAspect::setGdbSever(m_kit, AndroidGdbServerKitAspect::autoDetect(m_kit));
}
void AndroidGdbServerKitInformationWidget::showDialog()
void AndroidGdbServerKitAspectWidget::showDialog()
{
QDialog dialog;
auto layout = new QVBoxLayout(&dialog);
@@ -194,7 +194,7 @@ void AndroidGdbServerKitInformationWidget::showDialog()
auto binaryLabel = new QLabel(tr("&Binary:"));
auto chooser = new PathChooser;
chooser->setExpectedKind(PathChooser::ExistingCommand);
chooser->setPath(AndroidGdbServerKitInformation::gdbServer(m_kit).toString());
chooser->setPath(AndroidGdbServerKitAspect::gdbServer(m_kit).toString());
binaryLabel->setBuddy(chooser);
formLayout->addRow(binaryLabel, chooser);
layout->addLayout(formLayout);
@@ -207,7 +207,7 @@ void AndroidGdbServerKitInformationWidget::showDialog()
dialog.setWindowTitle(tr("GDB Server for \"%1\"").arg(m_kit->displayName()));
if (dialog.exec() == QDialog::Accepted)
AndroidGdbServerKitInformation::setGdbSever(m_kit, chooser->fileName());
AndroidGdbServerKitAspect::setGdbSever(m_kit, chooser->fileName());
}
} // namespace Internal

14
src/plugins/android/androidgdbserverkitinformation.h
View File

@@ -36,13 +36,13 @@ QT_END_NAMESPACE
namespace Android {
namespace Internal {
class AndroidGdbServerKitInformationWidget : public ProjectExplorer::KitConfigWidget
class AndroidGdbServerKitAspectWidget : public ProjectExplorer::KitAspectWidget
{
Q_OBJECT
public:
AndroidGdbServerKitInformationWidget(ProjectExplorer::Kit *kit,
const ProjectExplorer::KitInformation *ki);
~AndroidGdbServerKitInformationWidget() override;
AndroidGdbServerKitAspectWidget(ProjectExplorer::Kit *kit,
const ProjectExplorer::KitAspect *ki);
~AndroidGdbServerKitAspectWidget() override;
QString displayName() const override;
QString toolTip() const override;
@@ -61,11 +61,11 @@ private:
QPushButton *m_button;
};
class AndroidGdbServerKitInformation : public ProjectExplorer::KitInformation
class AndroidGdbServerKitAspect : public ProjectExplorer::KitAspect
{
Q_OBJECT
public:
AndroidGdbServerKitInformation();
AndroidGdbServerKitAspect();
QVariant defaultValue(const ProjectExplorer::Kit *) const override;
@@ -73,7 +73,7 @@ public:
ItemList toUserOutput(const ProjectExplorer::Kit *) const override;
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *) const override;
ProjectExplorer::KitAspectWidget *createConfigWidget(ProjectExplorer::Kit *) const override;
static Core::Id id();
static bool isAndroidKit(const ProjectExplorer::Kit *kit);

8
src/plugins/android/androidmanager.cpp
View File

@@ -235,7 +235,7 @@ int AndroidManager::minimumSDK(ProjectExplorer::Target *target)
int AndroidManager::minimumSDK(const ProjectExplorer::Kit *kit)
{
int minSDKVersion = -1;
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(kit);
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(kit);
if (version && version->targetDeviceTypes().contains(Constants::ANDROID_DEVICE_TYPE)) {
Utils::FileName stockManifestFilePath =
Utils::FileName::fromUserInput(version->qmakeProperty("QT_INSTALL_PREFIX") +
@@ -250,7 +250,7 @@ int AndroidManager::minimumSDK(const ProjectExplorer::Kit *kit)
int AndroidManager::minimumNDK(const Kit *kit)
{
auto qt = static_cast<AndroidQtVersion *>(QtSupport::QtKitInformation::qtVersion(kit));
auto qt = static_cast<AndroidQtVersion *>(QtSupport::QtKitAspect::qtVersion(kit));
return qt->mininmumNDK();
}
@@ -266,7 +266,7 @@ QString AndroidManager::buildTargetSDK(ProjectExplorer::Target *target)
QString AndroidManager::targetArch(ProjectExplorer::Target *target)
{
auto qt = static_cast<AndroidQtVersion *>(QtSupport::QtKitInformation::qtVersion(target->kit()));
auto qt = static_cast<AndroidQtVersion *>(QtSupport::QtKitAspect::qtVersion(target->kit()));
return qt->targetArch();
}
@@ -603,7 +603,7 @@ static bool mergeGradleProperties(const QString &path, GradleProperties properti
bool AndroidManager::updateGradleProperties(ProjectExplorer::Target *target)
{
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target->kit());
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target->kit());
if (!version)
return false;

4
src/plugins/android/androidmanifesteditorwidget.cpp
View File

@@ -91,7 +91,7 @@ Project *androidProject(const Utils::FileName &fileName)
if (!project->activeTarget())
continue;
Kit *kit = project->activeTarget()->kit();
if (DeviceTypeKitInformation::deviceTypeId(kit) == Android::Constants::ANDROID_DEVICE_TYPE
if (DeviceTypeKitAspect::deviceTypeId(kit) == Android::Constants::ANDROID_DEVICE_TYPE
&& fileName.isChildOf(project->projectDirectory()))
return project;
}
@@ -492,7 +492,7 @@ void AndroidManifestEditorWidget::updateTargetComboBox()
QStringList items;
if (project) {
Kit *kit = project->activeTarget()->kit();
if (DeviceTypeKitInformation::deviceTypeId(kit) == Constants::ANDROID_DEVICE_TYPE) {
if (DeviceTypeKitAspect::deviceTypeId(kit) == Constants::ANDROID_DEVICE_TYPE) {
ProjectNode *root = project->rootProjectNode();
root->forEachProjectNode([&items](const ProjectNode *projectNode) {
items << projectNode->targetApplications();

2
src/plugins/android/androidpackageinstallationstep.cpp
View File

@@ -66,7 +66,7 @@ bool AndroidPackageInstallationStep::init()
if (bc->environment().searchInPath("sh.exe").isEmpty())
dirPath = QDir::toNativeSeparators(dirPath);
ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(),
ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(),
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ProcessParameters *pp = processParameters();

6
src/plugins/android/androidplugin.cpp
View File

@@ -107,7 +107,7 @@ public:
void handleNewTarget(Target *target)
{
if (DeviceTypeKitInformation::deviceTypeId(target->kit()) != Android::Constants::ANDROID_DEVICE_TYPE)
if (DeviceTypeKitAspect::deviceTypeId(target->kit()) != Android::Constants::ANDROID_DEVICE_TYPE)
return;
for (BuildConfiguration *bc : target->buildConfigurations())
@@ -155,13 +155,13 @@ bool AndroidPlugin::initialize(const QStringList &arguments, QString *errorMessa
}, [](RunConfiguration *runConfig) {
return runConfig->isEnabled()
&& runConfig->id().name().startsWith("QmlProjectManager.QmlRunConfiguration")
&& DeviceTypeKitInformation::deviceTypeId(runConfig->target()->kit())
&& DeviceTypeKitAspect::deviceTypeId(runConfig->target()->kit())
== Android::Constants::ANDROID_DEVICE_TYPE;
});
d = new AndroidPluginPrivate;
KitManager::registerKitInformation<Internal::AndroidGdbServerKitInformation>();
KitManager::registerKitAspect<Internal::AndroidGdbServerKitAspect>();
connect(KitManager::instance(), &KitManager::kitsLoaded,
this, &AndroidPlugin::kitsRestored);

4
src/plugins/android/androidpotentialkit.cpp
View File

@@ -68,7 +68,7 @@ bool AndroidPotentialKit::isEnabled() const
{
QList<ProjectExplorer::Kit *> kits = ProjectExplorer::KitManager::kits();
foreach (ProjectExplorer::Kit *kit, kits) {
Core::Id deviceId = ProjectExplorer::DeviceKitInformation::deviceId(kit);
Core::Id deviceId = ProjectExplorer::DeviceKitAspect::deviceId(kit);
if (kit->isAutoDetected()
&& deviceId == Core::Id(Constants::ANDROID_DEVICE_ID)
&& !kit->isSdkProvided()) {
@@ -120,7 +120,7 @@ void AndroidPotentialKitWidget::recheck()
{
QList<ProjectExplorer::Kit *> kits = ProjectExplorer::KitManager::kits();
foreach (ProjectExplorer::Kit *kit, kits) {
Core::Id deviceId = ProjectExplorer::DeviceKitInformation::deviceId(kit);
Core::Id deviceId = ProjectExplorer::DeviceKitAspect::deviceId(kit);
if (kit->isAutoDetected()
&& deviceId == Core::Id(Constants::ANDROID_DEVICE_ID)
&& !kit->isSdkProvided()) {

4
src/plugins/android/androidrunnerworker.cpp
View File

@@ -223,8 +223,8 @@ AndroidRunnerWorker::AndroidRunnerWorker(RunWorker *runner, const QString &packa
<< "Extra Start Args:" << m_amStartExtraArgs
<< "Before Start ADB cmds:" << m_beforeStartAdbCommands
<< "After finish ADB cmds:" << m_afterFinishAdbCommands;
m_gdbserverPath = AndroidGdbServerKitInformation::gdbServer(target->kit()).toString();
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target->kit());
m_gdbserverPath = AndroidGdbServerKitAspect::gdbServer(target->kit()).toString();
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target->kit());
m_useAppParamsForQmlDebugger = version->qtVersion() >= QtSupport::QtVersionNumber(5, 12);
}

4
src/plugins/android/createandroidmanifestwizard.cpp
View File

@@ -215,7 +215,7 @@ CreateAndroidManifestWizard::CreateAndroidManifestWizard(ProjectExplorer::Target
setWindowTitle(tr("Create Android Template Files Wizard"));
const BuildTargetInfoList buildTargets = target->applicationTargets();
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target->kit());
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target->kit());
m_copyGradle = version && version->qtVersion() >= QtSupport::QtVersionNumber(5, 4, 0);
if (buildTargets.list.isEmpty()) {
@@ -319,7 +319,7 @@ void CreateAndroidManifestWizard::createAndroidTemplateFiles()
return;
QStringList addedFiles;
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(m_target->kit());
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(m_target->kit());
if (!version)
return;
if (version->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0)) {

4
src/plugins/autotest/autotestunittests.cpp
View File

@@ -64,11 +64,11 @@ void AutoTestUnitTests::initTestCase()
const QList<Kit *> allKits = KitManager::kits();
if (allKits.count() != 1)
QSKIP("This test requires exactly one kit to be present");
if (auto qtVersion = QtSupport::QtKitInformation::qtVersion(allKits.first()))
if (auto qtVersion = QtSupport::QtKitAspect::qtVersion(allKits.first()))
m_isQt4 = qtVersion->qtVersionString().startsWith('4');
else
QSKIP("Could not figure out which Qt version is used for default kit.");
const ToolChain * const toolchain = ToolChainKitInformation::toolChain(allKits.first(),
const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first(),
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain.");

2
src/plugins/autotest/testconfiguration.cpp
View File

@@ -57,7 +57,7 @@ static bool isLocal(RunConfiguration *runConfiguration)
{
Target *target = runConfiguration ? runConfiguration->target() : nullptr;
Kit *kit = target ? target->kit() : nullptr;
return DeviceTypeKitInformation::deviceTypeId(kit) == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
return DeviceTypeKitAspect::deviceTypeId(kit) == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
}
static QString ensureExeEnding(const QString& file)

2
src/plugins/autotest/testrunner.cpp
View File

@@ -579,7 +579,7 @@ void TestRunner::debugTests()
bool useOutputProcessor = true;
if (ProjectExplorer::Target *targ = config->project()->activeTarget()) {
if (Debugger::DebuggerKitInformation::engineType(targ->kit()) == Debugger::CdbEngineType) {
if (Debugger::DebuggerKitAspect::engineType(targ->kit()) == Debugger::CdbEngineType) {
emit testResultReady(TestResultPtr(new FaultyTestResult(Result::MessageWarn,
TestRunner::tr("Unable to display test results when using CDB."))));
useOutputProcessor = false;

2
src/plugins/clangtools/clangtidyclazytool.cpp
View File

@@ -423,7 +423,7 @@ void ClangTidyClazyTool::updateRunActions()
Target *target = project ? project->activeTarget() : nullptr;
const Core::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
bool canRun = target && project->projectLanguages().contains(cxx)
&& ToolChainKitInformation::toolChain(target->kit(), cxx);
&& ToolChainKitAspect::toolChain(target->kit(), cxx);
if (!canRun)
toolTip = tr("This is not a C++ project.");

2
src/plugins/clangtools/clangtoolruncontrol.cpp
View File

@@ -258,7 +258,7 @@ void ClangToolRunControl::init()
QTC_ASSERT(buildConfiguration, return);
m_environment = buildConfiguration->environment();
ToolChain *toolChain = ToolChainKitInformation::toolChain(m_target->kit(),
ToolChain *toolChain = ToolChainKitAspect::toolChain(m_target->kit(),
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QTC_ASSERT(toolChain, return);
m_targetTriple = toolChain->originalTargetTriple();

2
src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
View File

@@ -166,7 +166,7 @@ static QList<Target *> validTargets(Project *project)
return false;
}
const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const ToolChain * const toolchain = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QTC_ASSERT(toolchain, return false);
if (Core::ICore::clangExecutable(CLANG_BINDIR).isEmpty()) {

6
src/plugins/clangtools/clangtoolsunittests.cpp
View File

@@ -58,7 +58,7 @@ void ClangToolsUnitTests::initTestCase()
const QList<Kit *> allKits = KitManager::kits();
if (allKits.count() != 1)
QSKIP("This test requires exactly one kit to be present");
const ToolChain * const toolchain = ToolChainKitInformation::toolChain(allKits.first(),
const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first(),
Constants::CXX_LANGUAGE_ID);
if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain.");
@@ -94,8 +94,8 @@ void ClangToolsUnitTests::testProject()
QFETCH(int, expectedDiagCount);
if (projectFilePath.contains("mingw")) {
const ToolChain * const toolchain
= ToolChainKitInformation::toolChain(KitManager::kits().constFirst(),
Constants::CXX_LANGUAGE_ID);
= ToolChainKitAspect::toolChain(KitManager::kits().constFirst(),
Constants::CXX_LANGUAGE_ID);
if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID)
QSKIP("This test is mingw specific, does not run for other toolchains");
}

18
src/plugins/cmakeprojectmanager/builddirparameters.cpp
View File

@@ -61,25 +61,25 @@ BuildDirParameters::BuildDirParameters(CMakeBuildConfiguration *bc)
if (Utils::HostOsInfo::isAnyUnixHost())
environment.set("ICECC", "no");
cmakeToolId = CMakeKitInformation::cmakeToolId(k);
cmakeToolId = CMakeKitAspect::cmakeToolId(k);
auto tc = ToolChainKitInformation::toolChain(k, Constants::CXX_LANGUAGE_ID);
auto tc = ToolChainKitAspect::toolChain(k, Constants::CXX_LANGUAGE_ID);
if (tc)
cxxToolChainId = tc->id();
tc = ToolChainKitInformation::toolChain(k, Constants::C_LANGUAGE_ID);
tc = ToolChainKitAspect::toolChain(k, Constants::C_LANGUAGE_ID);
if (tc)
cToolChainId = tc->id();
sysRoot = SysRootKitInformation::sysRoot(k);
sysRoot = SysRootKitAspect::sysRoot(k);
expander = k->macroExpander();
configuration = bc->configurationForCMake();
generator = CMakeGeneratorKitInformation::generator(k);
extraGenerator = CMakeGeneratorKitInformation::extraGenerator(k);
platform = CMakeGeneratorKitInformation::platform(k);
toolset = CMakeGeneratorKitInformation::toolset(k);
generatorArguments = CMakeGeneratorKitInformation::generatorArguments(k);
generator = CMakeGeneratorKitAspect::generator(k);
extraGenerator = CMakeGeneratorKitAspect::extraGenerator(k);
platform = CMakeGeneratorKitAspect::platform(k);
toolset = CMakeGeneratorKitAspect::toolset(k);
generatorArguments = CMakeGeneratorKitAspect::generatorArguments(k);
}
bool BuildDirParameters::isValid() const { return buildConfiguration && cmakeTool(); }

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

@@ -344,7 +344,7 @@ void CMakeBuildConfiguration::setConfigurationForCMake(const CMakeConfig &config
m_configurationForCMake = removeDuplicates(config);
const Kit *k = target()->kit();
CMakeConfig kitConfig = CMakeConfigurationKitInformation::configuration(k);
CMakeConfig kitConfig = CMakeConfigurationKitAspect::configuration(k);
bool hasKitOverride = false;
foreach (const CMakeConfigItem &i, m_configurationForCMake) {
const QString b = CMakeConfigItem::expandedValueOf(k, i.key, kitConfig);
@@ -364,7 +364,7 @@ void CMakeBuildConfiguration::setConfigurationForCMake(const CMakeConfig &config
CMakeConfig CMakeBuildConfiguration::configurationForCMake() const
{
return removeDuplicates(CMakeConfigurationKitInformation::configuration(target()->kit()) + m_configurationForCMake);
return removeDuplicates(CMakeConfigurationKitAspect::configuration(target()->kit()) + m_configurationForCMake);
}
void CMakeBuildConfiguration::setError(const QString &message)
@@ -516,10 +516,10 @@ BuildInfo CMakeBuildConfigurationFactory::createBuildInfo(const Kit *k,
if (!buildTypeItem.isNull())
extra.configuration.append(buildTypeItem);
const QString sysRoot = SysRootKitInformation::sysRoot(k).toString();
const QString sysRoot = SysRootKitAspect::sysRoot(k).toString();
if (!sysRoot.isEmpty()) {
extra.configuration.append(CMakeConfigItem("CMAKE_SYSROOT", sysRoot.toUtf8()));
ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(
ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitAspect::toolChain(
k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (tc) {
const QByteArray targetTriple = tc->originalTargetTriple().toUtf8();

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

@@ -391,7 +391,7 @@ void CMakeBuildSettingsWidget::updateAdvancedCheckBox()
void CMakeBuildSettingsWidget::updateFromKit()
{
const ProjectExplorer::Kit *k = m_buildConfiguration->target()->kit();
const CMakeConfig config = CMakeConfigurationKitInformation::configuration(k);
const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
QHash<QString, QString> configHash;
for (const CMakeConfigItem &i : config)

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

@@ -164,7 +164,7 @@ bool CMakeBuildStep::init()
canInit = false;
}
CMakeTool *tool = CMakeKitInformation::cmakeTool(target()->kit());
CMakeTool *tool = CMakeKitAspect::cmakeTool(target()->kit());
if (!tool || !tool->isValid()) {
emit addTask(Task(Task::Error,
tr("A CMake tool must be set up for building. "
@@ -375,7 +375,7 @@ QString CMakeBuildStep::allArguments(const CMakeRunConfiguration *rc) const
QString CMakeBuildStep::cmakeCommand() const
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(target()->kit());
CMakeTool *tool = CMakeKitAspect::cmakeTool(target()->kit());
return tool ? tool->cmakeExecutable().toString() : QString();
}

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

@@ -64,7 +64,7 @@ IAssistProposal *CMakeFileCompletionAssist::perform(const AssistInterface *inter
if (!fileName.isEmpty() && QFileInfo(fileName).isFile()) {
Project *p = SessionManager::projectForFile(Utils::FileName::fromString(fileName));
if (p && p->activeTarget()) {
CMakeTool *cmake = CMakeKitInformation::cmakeTool(p->activeTarget()->kit());
CMakeTool *cmake = CMakeKitAspect::cmakeTool(p->activeTarget()->kit());
if (cmake && cmake->isValid())
kw = cmake->keywords();
}

144
src/plugins/cmakeprojectmanager/cmakekitconfigwidget.cpp
View File

@@ -54,14 +54,14 @@ namespace CMakeProjectManager {
namespace Internal {
// --------------------------------------------------------------------
// CMakeKitConfigWidget:
// CMakeKitAspectWidget:
// --------------------------------------------------------------------
CMakeKitConfigWidget::CMakeKitConfigWidget(Kit *kit,
const KitInformation *ki) :
KitConfigWidget(kit, ki),
CMakeKitAspectWidget::CMakeKitAspectWidget(Kit *kit,
const KitAspect *ki) :
KitAspectWidget(kit, ki),
m_comboBox(new QComboBox),
m_manageButton(new QPushButton(KitConfigWidget::msgManage()))
m_manageButton(new QPushButton(KitAspectWidget::msgManage()))
{
m_comboBox->setSizePolicy(QSizePolicy::Ignored, m_comboBox->sizePolicy().verticalPolicy());
m_comboBox->setEnabled(false);
@@ -74,60 +74,60 @@ CMakeKitConfigWidget::CMakeKitConfigWidget(Kit *kit,
refresh();
connect(m_comboBox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &CMakeKitConfigWidget::currentCMakeToolChanged);
this, &CMakeKitAspectWidget::currentCMakeToolChanged);
m_manageButton->setContentsMargins(0, 0, 0, 0);
connect(m_manageButton, &QPushButton::clicked,
this, &CMakeKitConfigWidget::manageCMakeTools);
this, &CMakeKitAspectWidget::manageCMakeTools);
CMakeToolManager *cmakeMgr = CMakeToolManager::instance();
connect(cmakeMgr, &CMakeToolManager::cmakeAdded,
this, &CMakeKitConfigWidget::cmakeToolAdded);
this, &CMakeKitAspectWidget::cmakeToolAdded);
connect(cmakeMgr, &CMakeToolManager::cmakeRemoved,
this, &CMakeKitConfigWidget::cmakeToolRemoved);
this, &CMakeKitAspectWidget::cmakeToolRemoved);
connect(cmakeMgr, &CMakeToolManager::cmakeUpdated,
this, &CMakeKitConfigWidget::cmakeToolUpdated);
this, &CMakeKitAspectWidget::cmakeToolUpdated);
}
CMakeKitConfigWidget::~CMakeKitConfigWidget()
CMakeKitAspectWidget::~CMakeKitAspectWidget()
{
delete m_comboBox;
delete m_manageButton;
}
QString CMakeKitConfigWidget::displayName() const
QString CMakeKitAspectWidget::displayName() const
{
return tr("CMake Tool");
}
void CMakeKitConfigWidget::makeReadOnly()
void CMakeKitAspectWidget::makeReadOnly()
{
m_comboBox->setEnabled(false);
}
void CMakeKitConfigWidget::refresh()
void CMakeKitAspectWidget::refresh()
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(m_kit);
CMakeTool *tool = CMakeKitAspect::cmakeTool(m_kit);
m_comboBox->setCurrentIndex(tool ? indexOf(tool->id()) : -1);
}
QWidget *CMakeKitConfigWidget::mainWidget() const
QWidget *CMakeKitAspectWidget::mainWidget() const
{
return m_comboBox;
}
QWidget *CMakeKitConfigWidget::buttonWidget() const
QWidget *CMakeKitAspectWidget::buttonWidget() const
{
return m_manageButton;
}
QString CMakeKitConfigWidget::toolTip() const
QString CMakeKitAspectWidget::toolTip() const
{
return tr("The CMake Tool to use when building a project with CMake.<br>"
"This setting is ignored when using other build systems.");
}
int CMakeKitConfigWidget::indexOf(const Core::Id &id)
int CMakeKitAspectWidget::indexOf(const Core::Id &id)
{
for (int i = 0; i < m_comboBox->count(); ++i) {
if (id == Core::Id::fromSetting(m_comboBox->itemData(i)))
@@ -136,7 +136,7 @@ int CMakeKitConfigWidget::indexOf(const Core::Id &id)
return -1;
}
void CMakeKitConfigWidget::cmakeToolAdded(const Core::Id &id)
void CMakeKitAspectWidget::cmakeToolAdded(const Core::Id &id)
{
const CMakeTool *tool = CMakeToolManager::findById(id);
QTC_ASSERT(tool, return);
@@ -146,7 +146,7 @@ void CMakeKitConfigWidget::cmakeToolAdded(const Core::Id &id)
refresh();
}
void CMakeKitConfigWidget::cmakeToolUpdated(const Core::Id &id)
void CMakeKitAspectWidget::cmakeToolUpdated(const Core::Id &id)
{
const int pos = indexOf(id);
QTC_ASSERT(pos >= 0, return);
@@ -157,7 +157,7 @@ void CMakeKitConfigWidget::cmakeToolUpdated(const Core::Id &id)
m_comboBox->setItemText(pos, tool->displayName());
}
void CMakeKitConfigWidget::cmakeToolRemoved(const Core::Id &id)
void CMakeKitAspectWidget::cmakeToolRemoved(const Core::Id &id)
{
const int pos = indexOf(id);
QTC_ASSERT(pos >= 0, return);
@@ -172,7 +172,7 @@ void CMakeKitConfigWidget::cmakeToolRemoved(const Core::Id &id)
refresh();
}
void CMakeKitConfigWidget::updateComboBox()
void CMakeKitAspectWidget::updateComboBox()
{
// remove unavailable cmake tool:
int pos = indexOf(Core::Id());
@@ -188,29 +188,29 @@ void CMakeKitConfigWidget::updateComboBox()
}
}
void CMakeKitConfigWidget::currentCMakeToolChanged(int index)
void CMakeKitAspectWidget::currentCMakeToolChanged(int index)
{
if (m_removingItem)
return;
const Core::Id id = Core::Id::fromSetting(m_comboBox->itemData(index));
CMakeKitInformation::setCMakeTool(m_kit, id);
CMakeKitAspect::setCMakeTool(m_kit, id);
}
void CMakeKitConfigWidget::manageCMakeTools()
void CMakeKitAspectWidget::manageCMakeTools()
{
Core::ICore::showOptionsDialog(Constants::CMAKE_SETTINGSPAGE_ID,
buttonWidget());
}
// --------------------------------------------------------------------
// CMakeGeneratorKitConfigWidget:
// CMakeGeneratorKitAspectWidget:
// --------------------------------------------------------------------
CMakeGeneratorKitConfigWidget::CMakeGeneratorKitConfigWidget(Kit *kit,
const KitInformation *ki) :
KitConfigWidget(kit, ki),
CMakeGeneratorKitAspectWidget::CMakeGeneratorKitAspectWidget(Kit *kit,
const KitAspect *ki) :
KitAspectWidget(kit, ki),
m_label(new QLabel),
m_changeButton(new QPushButton)
{
@@ -219,39 +219,39 @@ CMakeGeneratorKitConfigWidget::CMakeGeneratorKitConfigWidget(Kit *kit,
refresh();
connect(m_changeButton, &QPushButton::clicked,
this, &CMakeGeneratorKitConfigWidget::changeGenerator);
this, &CMakeGeneratorKitAspectWidget::changeGenerator);
}
CMakeGeneratorKitConfigWidget::~CMakeGeneratorKitConfigWidget()
CMakeGeneratorKitAspectWidget::~CMakeGeneratorKitAspectWidget()
{
delete m_label;
delete m_changeButton;
}
QString CMakeGeneratorKitConfigWidget::displayName() const
QString CMakeGeneratorKitAspectWidget::displayName() const
{
return tr("CMake generator");
}
void CMakeGeneratorKitConfigWidget::makeReadOnly()
void CMakeGeneratorKitAspectWidget::makeReadOnly()
{
m_changeButton->setEnabled(false);
}
void CMakeGeneratorKitConfigWidget::refresh()
void CMakeGeneratorKitAspectWidget::refresh()
{
if (m_ignoreChange)
return;
CMakeTool *const tool = CMakeKitInformation::cmakeTool(m_kit);
CMakeTool *const tool = CMakeKitAspect::cmakeTool(m_kit);
if (tool != m_currentTool)
m_currentTool = tool;
m_changeButton->setEnabled(m_currentTool);
const QString generator = CMakeGeneratorKitInformation::generator(kit());
const QString extraGenerator = CMakeGeneratorKitInformation::extraGenerator(kit());
const QString platform = CMakeGeneratorKitInformation::platform(kit());
const QString toolset = CMakeGeneratorKitInformation::toolset(kit());
const QString generator = CMakeGeneratorKitAspect::generator(kit());
const QString extraGenerator = CMakeGeneratorKitAspect::extraGenerator(kit());
const QString platform = CMakeGeneratorKitAspect::platform(kit());
const QString toolset = CMakeGeneratorKitAspect::toolset(kit());
const QString message = tr("%1 - %2, Platform: %3, Toolset: %4")
.arg(extraGenerator.isEmpty() ? tr("<none>") : extraGenerator)
@@ -261,23 +261,23 @@ void CMakeGeneratorKitConfigWidget::refresh()
m_label->setText(message);
}
QWidget *CMakeGeneratorKitConfigWidget::mainWidget() const
QWidget *CMakeGeneratorKitAspectWidget::mainWidget() const
{
return m_label;
}
QWidget *CMakeGeneratorKitConfigWidget::buttonWidget() const
QWidget *CMakeGeneratorKitAspectWidget::buttonWidget() const
{
return m_changeButton;
}
QString CMakeGeneratorKitConfigWidget::toolTip() const
QString CMakeGeneratorKitAspectWidget::toolTip() const
{
return tr("CMake generator defines how a project is built when using CMake.<br>"
"This setting is ignored when using other build systems.");
}
void CMakeGeneratorKitConfigWidget::changeGenerator()
void CMakeGeneratorKitAspectWidget::changeGenerator()
{
QPointer<QDialog> changeDialog = new QDialog(m_changeButton);
@@ -352,12 +352,12 @@ void CMakeGeneratorKitConfigWidget::changeGenerator()
toolsetEdit->setEnabled(it->supportsToolset);
};
updateDialog(CMakeGeneratorKitInformation::generator(kit()));
updateDialog(CMakeGeneratorKitAspect::generator(kit()));
generatorCombo->setCurrentText(CMakeGeneratorKitInformation::generator(kit()));
extraGeneratorCombo->setCurrentText(CMakeGeneratorKitInformation::extraGenerator(kit()));
platformEdit->setText(platformEdit->isEnabled() ? CMakeGeneratorKitInformation::platform(kit()) : QLatin1String("<unsupported>"));
toolsetEdit->setText(toolsetEdit->isEnabled() ? CMakeGeneratorKitInformation::toolset(kit()) : QLatin1String("<unsupported>"));
generatorCombo->setCurrentText(CMakeGeneratorKitAspect::generator(kit()));
extraGeneratorCombo->setCurrentText(CMakeGeneratorKitAspect::extraGenerator(kit()));
platformEdit->setText(platformEdit->isEnabled() ? CMakeGeneratorKitAspect::platform(kit()) : QLatin1String("<unsupported>"));
toolsetEdit->setText(toolsetEdit->isEnabled() ? CMakeGeneratorKitAspect::toolset(kit()) : QLatin1String("<unsupported>"));
connect(generatorCombo, &QComboBox::currentTextChanged, updateDialog);
@@ -365,7 +365,7 @@ void CMakeGeneratorKitConfigWidget::changeGenerator()
if (!changeDialog)
return;
CMakeGeneratorKitInformation::set(kit(), generatorCombo->currentText(),
CMakeGeneratorKitAspect::set(kit(), generatorCombo->currentText(),
extraGeneratorCombo->currentData().toString(),
platformEdit->isEnabled() ? platformEdit->text() : QString(),
toolsetEdit->isEnabled() ? toolsetEdit->text() : QString());
@@ -373,58 +373,58 @@ void CMakeGeneratorKitConfigWidget::changeGenerator()
}
// --------------------------------------------------------------------
// CMakeConfigurationKitConfigWidget:
// CMakeConfigurationKitAspectWidget:
// --------------------------------------------------------------------
CMakeConfigurationKitConfigWidget::CMakeConfigurationKitConfigWidget(Kit *kit,
const KitInformation *ki) :
KitConfigWidget(kit, ki),
CMakeConfigurationKitAspectWidget::CMakeConfigurationKitAspectWidget(Kit *kit,
const KitAspect *ki) :
KitAspectWidget(kit, ki),
m_summaryLabel(new Utils::ElidingLabel),
m_manageButton(new QPushButton)
{
refresh();
m_manageButton->setText(tr("Change..."));
connect(m_manageButton, &QAbstractButton::clicked,
this, &CMakeConfigurationKitConfigWidget::editConfigurationChanges);
this, &CMakeConfigurationKitAspectWidget::editConfigurationChanges);
}
QString CMakeConfigurationKitConfigWidget::displayName() const
QString CMakeConfigurationKitAspectWidget::displayName() const
{
return tr("CMake Configuration");
}
void CMakeConfigurationKitConfigWidget::makeReadOnly()
void CMakeConfigurationKitAspectWidget::makeReadOnly()
{
m_manageButton->setEnabled(false);
if (m_dialog)
m_dialog->reject();
}
void CMakeConfigurationKitConfigWidget::refresh()
void CMakeConfigurationKitAspectWidget::refresh()
{
const QStringList current = CMakeConfigurationKitInformation::toStringList(kit());
const QStringList current = CMakeConfigurationKitAspect::toStringList(kit());
m_summaryLabel->setText(current.join("; "));
if (m_editor)
m_editor->setPlainText(current.join('\n'));
}
QWidget *CMakeConfigurationKitConfigWidget::mainWidget() const
QWidget *CMakeConfigurationKitAspectWidget::mainWidget() const
{
return m_summaryLabel;
}
QWidget *CMakeConfigurationKitConfigWidget::buttonWidget() const
QWidget *CMakeConfigurationKitAspectWidget::buttonWidget() const
{
return m_manageButton;
}
QString CMakeConfigurationKitConfigWidget::toolTip() const
QString CMakeConfigurationKitAspectWidget::toolTip() const
{
return tr("Default configuration passed to CMake when setting up a project.");
}
void CMakeConfigurationKitConfigWidget::editConfigurationChanges()
void CMakeConfigurationKitAspectWidget::editConfigurationChanges()
{
if (m_dialog) {
m_dialog->activateWindow();
@@ -458,32 +458,32 @@ void CMakeConfigurationKitConfigWidget::editConfigurationChanges()
connect(buttons, &QDialogButtonBox::clicked, m_dialog, [buttons, this](QAbstractButton *button) {
if (button != buttons->button(QDialogButtonBox::Reset))
return;
CMakeConfigurationKitInformation::setConfiguration(kit(),
CMakeConfigurationKitInformation::defaultConfiguration(kit()));
CMakeConfigurationKitAspect::setConfiguration(kit(),
CMakeConfigurationKitAspect::defaultConfiguration(kit()));
});
connect(m_dialog, &QDialog::accepted, this, &CMakeConfigurationKitConfigWidget::acceptChangesDialog);
connect(m_dialog, &QDialog::rejected, this, &CMakeConfigurationKitConfigWidget::closeChangesDialog);
connect(m_dialog, &QDialog::accepted, this, &CMakeConfigurationKitAspectWidget::acceptChangesDialog);
connect(m_dialog, &QDialog::rejected, this, &CMakeConfigurationKitAspectWidget::closeChangesDialog);
connect(buttons->button(QDialogButtonBox::Apply), &QAbstractButton::clicked,
this, &CMakeConfigurationKitConfigWidget::applyChanges);
this, &CMakeConfigurationKitAspectWidget::applyChanges);
refresh();
m_dialog->show();
}
void CMakeConfigurationKitConfigWidget::applyChanges()
void CMakeConfigurationKitAspectWidget::applyChanges()
{
QTC_ASSERT(m_editor, return);
CMakeConfigurationKitInformation::fromStringList(kit(), m_editor->toPlainText().split(QLatin1Char('\n')));
CMakeConfigurationKitAspect::fromStringList(kit(), m_editor->toPlainText().split(QLatin1Char('\n')));
}
void CMakeConfigurationKitConfigWidget::closeChangesDialog()
void CMakeConfigurationKitAspectWidget::closeChangesDialog()
{
m_dialog->deleteLater();
m_dialog = nullptr;
m_editor = nullptr;
}
void CMakeConfigurationKitConfigWidget::acceptChangesDialog()
void CMakeConfigurationKitAspectWidget::acceptChangesDialog()
{
applyChanges();
closeChangesDialog();

30
src/plugins/cmakeprojectmanager/cmakekitconfigwidget.h
View File

@@ -37,7 +37,7 @@ QT_END_NAMESPACE
namespace ProjectExplorer {
class Kit;
class KitInformation;
class KitAspect;
} // namespace ProjectExplorer
namespace CMakeProjectManager {
@@ -47,17 +47,17 @@ class CMakeTool;
namespace Internal {
// --------------------------------------------------------------------
// CMakeKitConfigWidget:
// CMakeKitAspectWidget:
// --------------------------------------------------------------------
class CMakeKitConfigWidget : public ProjectExplorer::KitConfigWidget
class CMakeKitAspectWidget : public ProjectExplorer::KitAspectWidget
{
Q_OBJECT
public:
CMakeKitConfigWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitInformation *ki);
~CMakeKitConfigWidget() override;
CMakeKitAspectWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitAspect *ki);
~CMakeKitAspectWidget() override;
// KitConfigWidget interface
// KitAspectWidget interface
QString displayName() const override;
void makeReadOnly() override;
void refresh() override;
@@ -80,17 +80,17 @@ private:
};
// --------------------------------------------------------------------
// CMakeGeneratorKitConfigWidget:
// CMakeGeneratorKitAspectWidget:
// --------------------------------------------------------------------
class CMakeGeneratorKitConfigWidget : public ProjectExplorer::KitConfigWidget
class CMakeGeneratorKitAspectWidget : public ProjectExplorer::KitAspectWidget
{
Q_OBJECT
public:
CMakeGeneratorKitConfigWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitInformation *ki);
~CMakeGeneratorKitConfigWidget() override;
CMakeGeneratorKitAspectWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitAspect *ki);
~CMakeGeneratorKitAspectWidget() override;
// KitConfigWidget interface
// KitAspectWidget interface
QString displayName() const override;
void makeReadOnly() override;
void refresh() override;
@@ -108,16 +108,16 @@ private:
};
// --------------------------------------------------------------------
// CMakeConfigurationKitConfigWidget:
// CMakeConfigurationKitAspectWidget:
// --------------------------------------------------------------------
class CMakeConfigurationKitConfigWidget : public ProjectExplorer::KitConfigWidget
class CMakeConfigurationKitAspectWidget : public ProjectExplorer::KitAspectWidget
{
Q_OBJECT
public:
CMakeConfigurationKitConfigWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitInformation *ki);
CMakeConfigurationKitAspectWidget(ProjectExplorer::Kit *kit, const ProjectExplorer::KitAspect *ki);
// KitConfigWidget interface
// KitAspectWidget interface
QString displayName() const override;
void makeReadOnly() override;
void refresh() override;

130
src/plugins/cmakeprojectmanager/cmakekitinformation.cpp
View File

@@ -48,7 +48,7 @@ using namespace ProjectExplorer;
namespace CMakeProjectManager {
// --------------------------------------------------------------------
// CMakeKitInformation:
// CMakeKitAspect:
// --------------------------------------------------------------------
static Core::Id defaultCMakeToolId()
@@ -60,12 +60,12 @@ static Core::Id defaultCMakeToolId()
static const char TOOL_ID[] = "CMakeProjectManager.CMakeKitInformation";
// --------------------------------------------------------------------
// CMakeKitInformation:
// CMakeKitAspect:
// --------------------------------------------------------------------
CMakeKitInformation::CMakeKitInformation()
CMakeKitAspect::CMakeKitAspect()
{
setObjectName(QLatin1String("CMakeKitInformation"));
setObjectName(QLatin1String("CMakeKitAspect"));
setId(TOOL_ID);
setPriority(20000);
@@ -78,24 +78,24 @@ CMakeKitInformation::CMakeKitInformation()
[this]() { foreach (Kit *k, KitManager::kits()) fix(k); });
}
Core::Id CMakeKitInformation::id()
Core::Id CMakeKitAspect::id()
{
return TOOL_ID;
}
Core::Id CMakeKitInformation::cmakeToolId(const Kit *k)
Core::Id CMakeKitAspect::cmakeToolId(const Kit *k)
{
if (!k)
return {};
return Core::Id::fromSetting(k->value(TOOL_ID));
}
CMakeTool *CMakeKitInformation::cmakeTool(const Kit *k)
CMakeTool *CMakeKitAspect::cmakeTool(const Kit *k)
{
return CMakeToolManager::findById(cmakeToolId(k));
}
void CMakeKitInformation::setCMakeTool(Kit *k, const Core::Id id)
void CMakeKitAspect::setCMakeTool(Kit *k, const Core::Id id)
{
const Core::Id toSet = id.isValid() ? id : defaultCMakeToolId();
QTC_ASSERT(!id.isValid() || CMakeToolManager::findById(toSet), return);
@@ -103,16 +103,16 @@ void CMakeKitInformation::setCMakeTool(Kit *k, const Core::Id id)
k->setValue(TOOL_ID, toSet.toSetting());
}
QVariant CMakeKitInformation::defaultValue(const Kit *k) const
QVariant CMakeKitAspect::defaultValue(const Kit *k) const
{
const Core::Id id = k ? defaultCMakeToolId() : Core::Id();
return id.toSetting();
}
QList<Task> CMakeKitInformation::validate(const Kit *k) const
QList<Task> CMakeKitAspect::validate(const Kit *k) const
{
QList<Task> result;
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
CMakeTool *tool = CMakeKitAspect::cmakeTool(k);
if (tool) {
CMakeTool::Version version = tool->version();
if (version.major < 3) {
@@ -124,42 +124,42 @@ QList<Task> CMakeKitInformation::validate(const Kit *k) const
return result;
}
void CMakeKitInformation::setup(Kit *k)
void CMakeKitAspect::setup(Kit *k)
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
CMakeTool *tool = CMakeKitAspect::cmakeTool(k);
if (!tool)
setCMakeTool(k, defaultCMakeToolId());
}
void CMakeKitInformation::fix(Kit *k)
void CMakeKitAspect::fix(Kit *k)
{
if (!CMakeKitInformation::cmakeTool(k))
if (!CMakeKitAspect::cmakeTool(k))
setup(k);
}
KitInformation::ItemList CMakeKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList CMakeKitAspect::toUserOutput(const Kit *k) const
{
const CMakeTool *const tool = cmakeTool(k);
return ItemList() << qMakePair(tr("CMake"), tool ? tool->displayName() : tr("Unconfigured"));
}
KitConfigWidget *CMakeKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *CMakeKitAspect::createConfigWidget(Kit *k) const
{
QTC_ASSERT(k, return nullptr);
return new Internal::CMakeKitConfigWidget(k, this);
return new Internal::CMakeKitAspectWidget(k, this);
}
void CMakeKitInformation::addToMacroExpander(Kit *k, Utils::MacroExpander *expander) const
void CMakeKitAspect::addToMacroExpander(Kit *k, Utils::MacroExpander *expander) const
{
QTC_ASSERT(k, return);
expander->registerFileVariables("CMake:Executable", tr("Path to the cmake executable"),
[k]() -> QString {
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
CMakeTool *tool = CMakeKitAspect::cmakeTool(k);
return tool ? tool->cmakeExecutable().toString() : QString();
});
}
QSet<Core::Id> CMakeKitInformation::availableFeatures(const Kit *k) const
QSet<Core::Id> CMakeKitAspect::availableFeatures(const Kit *k) const
{
if (cmakeTool(k))
return { CMakeProjectManager::Constants::CMAKE_FEATURE_ID };
@@ -167,7 +167,7 @@ QSet<Core::Id> CMakeKitInformation::availableFeatures(const Kit *k) const
}
// --------------------------------------------------------------------
// CMakeGeneratorKitInformation:
// CMakeGeneratorKitAspect:
// --------------------------------------------------------------------
static const char GENERATOR_ID[] = "CMake.GeneratorKitInformation";
@@ -222,62 +222,62 @@ static void setGeneratorInfo(Kit *k, const GeneratorInfo &info)
k->setValue(GENERATOR_ID, info.toVariant());
}
CMakeGeneratorKitInformation::CMakeGeneratorKitInformation()
CMakeGeneratorKitAspect::CMakeGeneratorKitAspect()
{
setObjectName(QLatin1String("CMakeGeneratorKitInformation"));
setObjectName(QLatin1String("CMakeGeneratorKitAspect"));
setId(GENERATOR_ID);
setPriority(19000);
}
QString CMakeGeneratorKitInformation::generator(const Kit *k)
QString CMakeGeneratorKitAspect::generator(const Kit *k)
{
return generatorInfo(k).generator;
}
QString CMakeGeneratorKitInformation::extraGenerator(const Kit *k)
QString CMakeGeneratorKitAspect::extraGenerator(const Kit *k)
{
return generatorInfo(k).extraGenerator;
}
QString CMakeGeneratorKitInformation::platform(const Kit *k)
QString CMakeGeneratorKitAspect::platform(const Kit *k)
{
return generatorInfo(k).platform;
}
QString CMakeGeneratorKitInformation::toolset(const Kit *k)
QString CMakeGeneratorKitAspect::toolset(const Kit *k)
{
return generatorInfo(k).toolset;
}
void CMakeGeneratorKitInformation::setGenerator(Kit *k, const QString &generator)
void CMakeGeneratorKitAspect::setGenerator(Kit *k, const QString &generator)
{
GeneratorInfo info = generatorInfo(k);
info.generator = generator;
setGeneratorInfo(k, info);
}
void CMakeGeneratorKitInformation::setExtraGenerator(Kit *k, const QString &extraGenerator)
void CMakeGeneratorKitAspect::setExtraGenerator(Kit *k, const QString &extraGenerator)
{
GeneratorInfo info = generatorInfo(k);
info.extraGenerator = extraGenerator;
setGeneratorInfo(k, info);
}
void CMakeGeneratorKitInformation::setPlatform(Kit *k, const QString &platform)
void CMakeGeneratorKitAspect::setPlatform(Kit *k, const QString &platform)
{
GeneratorInfo info = generatorInfo(k);
info.platform = platform;
setGeneratorInfo(k, info);
}
void CMakeGeneratorKitInformation::setToolset(Kit *k, const QString &toolset)
void CMakeGeneratorKitAspect::setToolset(Kit *k, const QString &toolset)
{
GeneratorInfo info = generatorInfo(k);
info.toolset = toolset;
setGeneratorInfo(k, info);
}
void CMakeGeneratorKitInformation::set(Kit *k,
void CMakeGeneratorKitAspect::set(Kit *k,
const QString &generator, const QString &extraGenerator,
const QString &platform, const QString &toolset)
{
@@ -285,7 +285,7 @@ void CMakeGeneratorKitInformation::set(Kit *k,
setGeneratorInfo(k, info);
}
QStringList CMakeGeneratorKitInformation::generatorArguments(const Kit *k)
QStringList CMakeGeneratorKitAspect::generatorArguments(const Kit *k)
{
QStringList result;
GeneratorInfo info = generatorInfo(k);
@@ -307,11 +307,11 @@ QStringList CMakeGeneratorKitInformation::generatorArguments(const Kit *k)
return result;
}
QVariant CMakeGeneratorKitInformation::defaultValue(const Kit *k) const
QVariant CMakeGeneratorKitAspect::defaultValue(const Kit *k) const
{
QTC_ASSERT(k, return QVariant());
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
CMakeTool *tool = CMakeKitAspect::cmakeTool(k);
if (!tool)
return QVariant();
@@ -332,7 +332,7 @@ QVariant CMakeGeneratorKitInformation::defaultValue(const Kit *k) const
if (Utils::HostOsInfo::isWindowsHost()) {
// *sigh* Windows with its zoo of incompatible stuff again...
ToolChain *tc = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
it = std::find_if(known.constBegin(), known.constEnd(),
[extraGenerator](const CMakeTool::Generator &g) {
@@ -360,9 +360,9 @@ QVariant CMakeGeneratorKitInformation::defaultValue(const Kit *k) const
return GeneratorInfo({it->name, extraGenerator, QString(), QString()}).toVariant();
}
QList<Task> CMakeGeneratorKitInformation::validate(const Kit *k) const
QList<Task> CMakeGeneratorKitAspect::validate(const Kit *k) const
{
CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
CMakeTool *tool = CMakeKitAspect::cmakeTool(k);
GeneratorInfo info = generatorInfo(k);
QList<Task> result;
@@ -400,16 +400,16 @@ QList<Task> CMakeGeneratorKitInformation::validate(const Kit *k) const
return result;
}
void CMakeGeneratorKitInformation::setup(Kit *k)
void CMakeGeneratorKitAspect::setup(Kit *k)
{
GeneratorInfo info;
info.fromVariant(defaultValue(k));
setGeneratorInfo(k, info);
}
void CMakeGeneratorKitInformation::fix(Kit *k)
void CMakeGeneratorKitAspect::fix(Kit *k)
{
const CMakeTool *tool = CMakeKitInformation::cmakeTool(k);
const CMakeTool *tool = CMakeKitAspect::cmakeTool(k);
const GeneratorInfo info = generatorInfo(k);
if (!tool)
@@ -431,7 +431,7 @@ void CMakeGeneratorKitInformation::fix(Kit *k)
}
}
void CMakeGeneratorKitInformation::upgrade(Kit *k)
void CMakeGeneratorKitAspect::upgrade(Kit *k)
{
QTC_ASSERT(k, return);
@@ -450,7 +450,7 @@ void CMakeGeneratorKitInformation::upgrade(Kit *k)
}
}
KitInformation::ItemList CMakeGeneratorKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList CMakeGeneratorKitAspect::toUserOutput(const Kit *k) const
{
const GeneratorInfo info = generatorInfo(k);
QString message;
@@ -466,13 +466,13 @@ KitInformation::ItemList CMakeGeneratorKitInformation::toUserOutput(const Kit *k
return ItemList() << qMakePair(tr("CMake Generator"), message);
}
KitConfigWidget *CMakeGeneratorKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *CMakeGeneratorKitAspect::createConfigWidget(Kit *k) const
{
return new Internal::CMakeGeneratorKitConfigWidget(k, this);
return new Internal::CMakeGeneratorKitAspectWidget(k, this);
}
// --------------------------------------------------------------------
// CMakeConfigurationKitInformation:
// CMakeConfigurationKitAspect:
// --------------------------------------------------------------------
static const char CONFIGURATION_ID[] = "CMake.ConfigurationKitInformation";
@@ -482,14 +482,14 @@ static const char CMAKE_CXX_TOOLCHAIN_KEY[] = "CMAKE_CXX_COMPILER";
static const char CMAKE_QMAKE_KEY[] = "QT_QMAKE_EXECUTABLE";
static const char CMAKE_PREFIX_PATH_KEY[] = "CMAKE_PREFIX_PATH";
CMakeConfigurationKitInformation::CMakeConfigurationKitInformation()
CMakeConfigurationKitAspect::CMakeConfigurationKitAspect()
{
setObjectName(QLatin1String("CMakeConfigurationKitInformation"));
setObjectName(QLatin1String("CMakeConfigurationKitAspect"));
setId(CONFIGURATION_ID);
setPriority(18000);
}
CMakeConfig CMakeConfigurationKitInformation::configuration(const Kit *k)
CMakeConfig CMakeConfigurationKitAspect::configuration(const Kit *k)
{
if (!k)
return CMakeConfig();
@@ -497,7 +497,7 @@ CMakeConfig CMakeConfigurationKitInformation::configuration(const Kit *k)
return Utils::transform(tmp, &CMakeConfigItem::fromString);
}
void CMakeConfigurationKitInformation::setConfiguration(Kit *k, const CMakeConfig &config)
void CMakeConfigurationKitAspect::setConfiguration(Kit *k, const CMakeConfig &config)
{
if (!k)
return;
@@ -505,17 +505,17 @@ void CMakeConfigurationKitInformation::setConfiguration(Kit *k, const CMakeConfi
k->setValue(CONFIGURATION_ID, tmp);
}
QStringList CMakeConfigurationKitInformation::toStringList(const Kit *k)
QStringList CMakeConfigurationKitAspect::toStringList(const Kit *k)
{
QStringList current
= Utils::transform(CMakeConfigurationKitInformation::configuration(k),
= Utils::transform(CMakeConfigurationKitAspect::configuration(k),
[](const CMakeConfigItem &i) { return i.toString(); });
current = Utils::filtered(current, [](const QString &s) { return !s.isEmpty(); });
Utils::sort(current);
return current;
}
void CMakeConfigurationKitInformation::fromStringList(Kit *k, const QStringList &in)
void CMakeConfigurationKitAspect::fromStringList(Kit *k, const QStringList &in)
{
CMakeConfig result;
foreach (const QString &s, in) {
@@ -526,7 +526,7 @@ void CMakeConfigurationKitInformation::fromStringList(Kit *k, const QStringList
setConfiguration(k, result);
}
CMakeConfig CMakeConfigurationKitInformation::defaultConfiguration(const Kit *k)
CMakeConfig CMakeConfigurationKitAspect::defaultConfiguration(const Kit *k)
{
Q_UNUSED(k);
CMakeConfig config;
@@ -541,7 +541,7 @@ CMakeConfig CMakeConfigurationKitInformation::defaultConfiguration(const Kit *k)
return config;
}
QVariant CMakeConfigurationKitInformation::defaultValue(const Kit *k) const
QVariant CMakeConfigurationKitAspect::defaultValue(const Kit *k) const
{
Q_UNUSED(k);
@@ -552,13 +552,13 @@ QVariant CMakeConfigurationKitInformation::defaultValue(const Kit *k) const
return tmp;
}
QList<Task> CMakeConfigurationKitInformation::validate(const Kit *k) const
QList<Task> CMakeConfigurationKitAspect::validate(const Kit *k) const
{
QTC_ASSERT(k, return QList<Task>());
const QtSupport::BaseQtVersion *const version = QtSupport::QtKitInformation::qtVersion(k);
const ToolChain *const tcC = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
const ToolChain *const tcCxx = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const QtSupport::BaseQtVersion *const version = QtSupport::QtKitAspect::qtVersion(k);
const ToolChain *const tcC = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
const ToolChain *const tcCxx = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const CMakeConfig config = configuration(k);
const bool isQt4 = version && version->qtVersion() < QtSupport::QtVersionNumber(5, 0, 0);
@@ -650,28 +650,28 @@ QList<Task> CMakeConfigurationKitInformation::validate(const Kit *k) const
return result;
}
void CMakeConfigurationKitInformation::setup(Kit *k)
void CMakeConfigurationKitAspect::setup(Kit *k)
{
if (k && !k->hasValue(CONFIGURATION_ID))
k->setValue(CONFIGURATION_ID, defaultValue(k));
}
void CMakeConfigurationKitInformation::fix(Kit *k)
void CMakeConfigurationKitAspect::fix(Kit *k)
{
Q_UNUSED(k);
}
KitInformation::ItemList CMakeConfigurationKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList CMakeConfigurationKitAspect::toUserOutput(const Kit *k) const
{
const QStringList current = toStringList(k);
return ItemList() << qMakePair(tr("CMake Configuration"), current.join(QLatin1String("<br>")));
}
KitConfigWidget *CMakeConfigurationKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *CMakeConfigurationKitAspect::createConfigWidget(Kit *k) const
{
if (!k)
return nullptr;
return new Internal::CMakeConfigurationKitConfigWidget(k, this);
return new Internal::CMakeConfigurationKitAspectWidget(k, this);
}
} // namespace CMakeProjectManager

24
src/plugins/cmakeprojectmanager/cmakekitinformation.h
View File

@@ -35,11 +35,11 @@ namespace CMakeProjectManager {
class CMakeTool;
class CMAKE_EXPORT CMakeKitInformation : public ProjectExplorer::KitInformation
class CMAKE_EXPORT CMakeKitAspect : public ProjectExplorer::KitAspect
{
Q_OBJECT
public:
CMakeKitInformation();
CMakeKitAspect();
static Core::Id id();
@@ -47,24 +47,24 @@ public:
static CMakeTool *cmakeTool(const ProjectExplorer::Kit *k);
static void setCMakeTool(ProjectExplorer::Kit *k, const Core::Id id);
// KitInformation interface
// KitAspect interface
QVariant defaultValue(const ProjectExplorer::Kit *k) const final;
QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *k) const final;
void setup(ProjectExplorer::Kit *k) final;
void fix(ProjectExplorer::Kit *k) final;
ItemList toUserOutput(const ProjectExplorer::Kit *k) const final;
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *k) const final;
ProjectExplorer::KitAspectWidget *createConfigWidget(ProjectExplorer::Kit *k) const final;
void addToMacroExpander(ProjectExplorer::Kit *k, Utils::MacroExpander *expander) const final;
QSet<Core::Id> availableFeatures(const ProjectExplorer::Kit *k) const final;
};
class CMAKE_EXPORT CMakeGeneratorKitInformation : public ProjectExplorer::KitInformation
class CMAKE_EXPORT CMakeGeneratorKitAspect : public ProjectExplorer::KitAspect
{
Q_OBJECT
public:
CMakeGeneratorKitInformation();
CMakeGeneratorKitAspect();
static QString generator(const ProjectExplorer::Kit *k);
static QString extraGenerator(const ProjectExplorer::Kit *k);
@@ -78,21 +78,21 @@ public:
const QString &extraGenerator, const QString &platform, const QString &toolset);
static QStringList generatorArguments(const ProjectExplorer::Kit *k);
// KitInformation interface
// KitAspect interface
QVariant defaultValue(const ProjectExplorer::Kit *k) const final;
QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *k) const final;
void setup(ProjectExplorer::Kit *k) final;
void fix(ProjectExplorer::Kit *k) final;
void upgrade(ProjectExplorer::Kit *k) final;
ItemList toUserOutput(const ProjectExplorer::Kit *k) const final;
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *k) const final;
ProjectExplorer::KitAspectWidget *createConfigWidget(ProjectExplorer::Kit *k) const final;
};
class CMAKE_EXPORT CMakeConfigurationKitInformation : public ProjectExplorer::KitInformation
class CMAKE_EXPORT CMakeConfigurationKitAspect : public ProjectExplorer::KitAspect
{
Q_OBJECT
public:
CMakeConfigurationKitInformation();
CMakeConfigurationKitAspect();
static CMakeConfig configuration(const ProjectExplorer::Kit *k);
static void setConfiguration(ProjectExplorer::Kit *k, const CMakeConfig &config);
@@ -102,13 +102,13 @@ public:
static CMakeConfig defaultConfiguration(const ProjectExplorer::Kit *k);
// KitInformation interface
// KitAspect interface
QVariant defaultValue(const ProjectExplorer::Kit *k) const final;
QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *k) const final;
void setup(ProjectExplorer::Kit *k) final;
void fix(ProjectExplorer::Kit *k) final;
ItemList toUserOutput(const ProjectExplorer::Kit *k) const final;
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *k) const final;
ProjectExplorer::KitAspectWidget *createConfigWidget(ProjectExplorer::Kit *k) const final;
};
} // namespace CMakeProjectManager

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

@@ -360,9 +360,9 @@ QList<Task> CMakeProject::projectIssues(const Kit *k) const
{
QList<Task> result = Project::projectIssues(k);
if (!CMakeKitInformation::cmakeTool(k))
if (!CMakeKitAspect::cmakeTool(k))
result.append(createProjectTask(Task::TaskType::Error, tr("No cmake tool set.")));
if (ToolChainKitInformation::toolChains(k).isEmpty())
if (ToolChainKitAspect::toolChains(k).isEmpty())
result.append(createProjectTask(Task::TaskType::Warning, tr("No compilers set in kit.")));
return result;

38
src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
View File

@@ -107,7 +107,7 @@ namespace Internal {
CMakeProjectImporter::CMakeProjectImporter(const Utils::FileName &path) : QtProjectImporter(path)
{
useTemporaryKitInformation(CMakeKitInformation::id(),
useTemporaryKitAspect(CMakeKitAspect::id(),
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryCMake(k, vl); },
[this](Kit *k, const QVariantList &vl) { persistTemporaryCMake(k, vl); });
@@ -286,24 +286,24 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
{
const DirectoryData *data = static_cast<DirectoryData *>(directoryData);
CMakeTool *cm = CMakeKitInformation::cmakeTool(k);
CMakeTool *cm = CMakeKitAspect::cmakeTool(k);
if (!cm || cm->cmakeExecutable() != data->cmakeBinary)
return false;
if (CMakeGeneratorKitInformation::generator(k) != QString::fromUtf8(data->generator)
|| CMakeGeneratorKitInformation::extraGenerator(k) != QString::fromUtf8(data->extraGenerator)
|| CMakeGeneratorKitInformation::platform(k) != QString::fromUtf8(data->platform)
|| CMakeGeneratorKitInformation::toolset(k) != QString::fromUtf8(data->toolset))
if (CMakeGeneratorKitAspect::generator(k) != QString::fromUtf8(data->generator)
|| CMakeGeneratorKitAspect::extraGenerator(k) != QString::fromUtf8(data->extraGenerator)
|| CMakeGeneratorKitAspect::platform(k) != QString::fromUtf8(data->platform)
|| CMakeGeneratorKitAspect::toolset(k) != QString::fromUtf8(data->toolset))
return false;
if (SysRootKitInformation::sysRoot(k) != Utils::FileName::fromUtf8(data->sysroot))
if (SysRootKitAspect::sysRoot(k) != Utils::FileName::fromUtf8(data->sysroot))
return false;
if (data->qt.qt && QtSupport::QtKitInformation::qtVersionId(k) != data->qt.qt->uniqueId())
if (data->qt.qt && QtSupport::QtKitAspect::qtVersionId(k) != data->qt.qt->uniqueId())
return false;
for (const CMakeToolChainData &tcd : data->toolChains) {
ToolChain *tc = ToolChainKitInformation::toolChain(k, tcd.mapLanguageIdToQtC());
ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.mapLanguageIdToQtC());
if (!tc || tc->compilerCommand() != tcd.compilerPath)
return false;
}
@@ -321,14 +321,14 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
const CMakeToolData cmtd = findOrCreateCMakeTool(data->cmakeBinary);
QTC_ASSERT(cmtd.cmakeTool, return);
if (cmtd.isTemporary)
addTemporaryData(CMakeKitInformation::id(), cmtd.cmakeTool->id().toSetting(), k);
addTemporaryData(CMakeKitAspect::id(), cmtd.cmakeTool->id().toSetting(), k);
CMakeGeneratorKitInformation::setGenerator(k, QString::fromUtf8(data->generator));
CMakeGeneratorKitInformation::setExtraGenerator(k, QString::fromUtf8(data->extraGenerator));
CMakeGeneratorKitInformation::setPlatform(k, QString::fromUtf8(data->platform));
CMakeGeneratorKitInformation::setToolset(k, QString::fromUtf8(data->toolset));
CMakeGeneratorKitAspect::setGenerator(k, QString::fromUtf8(data->generator));
CMakeGeneratorKitAspect::setExtraGenerator(k, QString::fromUtf8(data->extraGenerator));
CMakeGeneratorKitAspect::setPlatform(k, QString::fromUtf8(data->platform));
CMakeGeneratorKitAspect::setToolset(k, QString::fromUtf8(data->toolset));
SysRootKitInformation::setSysRoot(k, Utils::FileName::fromUtf8(data->sysroot));
SysRootKitAspect::setSysRoot(k, Utils::FileName::fromUtf8(data->sysroot));
for (const CMakeToolChainData &cmtcd : data->toolChains) {
const ToolChainData tcd
@@ -337,10 +337,10 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
if (tcd.areTemporary) {
for (ToolChain *tc : tcd.tcs)
addTemporaryData(ToolChainKitInformation::id(), tc->id(), k);
addTemporaryData(ToolChainKitAspect::id(), tc->id(), k);
}
ToolChainKitInformation::setToolChain(k, tcd.tcs.at(0));
ToolChainKitAspect::setToolChain(k, tcd.tcs.at(0));
}
qCInfo(cmInputLog()) << "Temporary Kit created.";
@@ -388,7 +388,7 @@ void CMakeProjectImporter::cleanupTemporaryCMake(Kit *k, const QVariantList &vl)
if (vl.isEmpty())
return; // No temporary CMake
QTC_ASSERT(vl.count() == 1, return);
CMakeKitInformation::setCMakeTool(k, Core::Id()); // Always mark Kit as not using this Qt
CMakeKitAspect::setCMakeTool(k, Core::Id()); // Always mark Kit as not using this Qt
CMakeToolManager::deregisterCMakeTool(Core::Id::fromSetting(vl.at(0)));
qCDebug(cmInputLog()) << "Temporary CMake tool cleaned up.";
}
@@ -400,7 +400,7 @@ void CMakeProjectImporter::persistTemporaryCMake(Kit *k, const QVariantList &vl)
QTC_ASSERT(vl.count() == 1, return);
const QVariant data = vl.at(0);
CMakeTool *tmpCmake = CMakeToolManager::findById(Core::Id::fromSetting(data));
CMakeTool *actualCmake = CMakeKitInformation::cmakeTool(k);
CMakeTool *actualCmake = CMakeKitAspect::cmakeTool(k);
// User changed Kit away from temporary CMake that was set up:
if (tmpCmake && actualCmake != tmpCmake)

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

@@ -106,9 +106,9 @@ bool CMakeProjectPlugin::initialize(const QStringList & /*arguments*/, QString *
new CMakeToolManager(this);
KitManager::registerKitInformation<CMakeKitInformation>();
KitManager::registerKitInformation<CMakeGeneratorKitInformation>();
KitManager::registerKitInformation<CMakeConfigurationKitInformation>();
KitManager::registerKitAspect<CMakeKitAspect>();
KitManager::registerKitAspect<CMakeGeneratorKitAspect>();
KitManager::registerKitAspect<CMakeConfigurationKitAspect>();
//menus
ActionContainer *msubproject =

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

@@ -49,7 +49,7 @@ CMakeRunConfiguration::CMakeRunConfiguration(Target *target, Core::Id id)
return;
const Kit *k = target->kit();
const QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(k);
const QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(k);
if (qt)
env.prependOrSetPath(qt->qmakeProperty("QT_INSTALL_BINS"));
};
@@ -63,7 +63,7 @@ CMakeRunConfiguration::CMakeRunConfiguration(Target *target, Core::Id id)
connect(target->project(), &Project::parsingFinished,
this, &CMakeRunConfiguration::updateTargetInformation);
if (QtSupport::QtKitInformation::qtVersion(target->kit()))
if (QtSupport::QtKitAspect::qtVersion(target->kit()))
setOutputFormatter<QtSupport::QtOutputFormatter>();
}

8
src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp
View File

@@ -134,7 +134,7 @@ QString compilerPath(QString pathFlag)
ToolChain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Core::Id &language)
{
if (flags.empty())
return ToolChainKitInformation::toolChain(kit, language);
return ToolChainKitAspect::toolChain(kit, language);
// Try exact compiler match.
const Utils::FileName compiler = Utils::FileName::fromString(compilerPath(flags.front()));
@@ -157,7 +157,7 @@ ToolChain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Co
return toolchain;
}
toolchain = ToolChainKitInformation::toolChain(kit, language);
toolchain = ToolChainKitAspect::toolChain(kit, language);
qWarning() << "No matching toolchain found, use the default.";
return toolchain;
}
@@ -216,7 +216,7 @@ CppTools::RawProjectPart makeRawProjectPart(const Utils::FileName &projectFile,
if (!cToolchain) {
cToolchain = toolchainFromFlags(kit, originalFlags,
ProjectExplorer::Constants::C_LANGUAGE_ID);
ToolChainKitInformation::setToolChain(kit, cToolchain);
ToolChainKitAspect::setToolChain(kit, cToolchain);
}
addDriverModeFlagIfNeeded(cToolchain, flags);
rpp.setFlagsForC({cToolchain, flags});
@@ -224,7 +224,7 @@ CppTools::RawProjectPart makeRawProjectPart(const Utils::FileName &projectFile,
if (!cxxToolchain) {
cxxToolchain = toolchainFromFlags(kit, originalFlags,
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolChainKitInformation::setToolChain(kit, cxxToolchain);
ToolChainKitAspect::setToolChain(kit, cxxToolchain);
}
addDriverModeFlagIfNeeded(cxxToolchain, flags);
rpp.setFlagsForCxx({cxxToolchain, flags});

6
src/plugins/cpptools/cppkitinfo.cpp
View File

@@ -48,12 +48,12 @@ KitInfo::KitInfo(Project *project)
// Toolchains
if (kit) {
cToolChain = ToolChainKitInformation::toolChain(kit, Constants::C_LANGUAGE_ID);
cxxToolChain = ToolChainKitInformation::toolChain(kit, Constants::CXX_LANGUAGE_ID);
cToolChain = ToolChainKitAspect::toolChain(kit, Constants::C_LANGUAGE_ID);
cxxToolChain = ToolChainKitAspect::toolChain(kit, Constants::CXX_LANGUAGE_ID);
}
// Sysroot
sysRootPath = ProjectExplorer::SysRootKitInformation::sysRoot(kit).toString();
sysRootPath = ProjectExplorer::SysRootKitAspect::sysRoot(kit).toString();
}
bool KitInfo::isValid() const

4
src/plugins/debugger/analyzer/startremotedialog.cpp
View File

@@ -63,7 +63,7 @@ StartRemoteDialog::StartRemoteDialog(QWidget *parent)
d->kitChooser = new KitChooser(this);
d->kitChooser->setKitPredicate([](const Kit *kit) {
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return kit->isValid() && device && !device->sshParameters().host().isEmpty();
});
d->executable = new QLineEdit(this);
@@ -132,7 +132,7 @@ Runnable StartRemoteDialog::runnable() const
{
Kit *kit = d->kitChooser->currentKit();
Runnable r;
r.device = DeviceKitInformation::device(kit);
r.device = DeviceKitAspect::device(kit);
r.executable = d->executable->text();
r.commandLineArguments = d->arguments->text();
r.workingDirectory = d->workingDirectory->text();

14
src/plugins/debugger/debuggerdialogs.cpp
View File

@@ -109,21 +109,21 @@ DebuggerKitChooser::DebuggerKitChooser(Mode mode, QWidget *parent)
{
setKitPredicate([this](const Kit *k) {
// Match valid debuggers and restrict local debugging to compatible toolchains.
auto errors = DebuggerKitInformation::configurationErrors(k);
auto errors = DebuggerKitAspect::configurationErrors(k);
// we do not care for mismatched ABI if we want *any* debugging
if (m_mode == AnyDebugging && errors == DebuggerKitInformation::DebuggerDoesNotMatch)
errors = DebuggerKitInformation::NoConfigurationError;
if (m_mode == AnyDebugging && errors == DebuggerKitAspect::DebuggerDoesNotMatch)
errors = DebuggerKitAspect::NoConfigurationError;
if (errors)
return false;
if (m_mode == LocalDebugging)
return ToolChainKitInformation::targetAbi(k).os() == m_hostAbi.os();
return ToolChainKitAspect::targetAbi(k).os() == m_hostAbi.os();
return true;
});
}
QString DebuggerKitChooser::kitToolTip(Kit *k) const
{
return DebuggerKitInformation::displayString(k);
return DebuggerKitAspect::displayString(k);
}
///////////////////////////////////////////////////////////////////////
@@ -229,7 +229,7 @@ StartApplicationDialog::StartApplicationDialog(QWidget *parent)
d->kitChooser = new KitChooser(this);
d->kitChooser->setKitPredicate([](const Kit *k) {
return !DebuggerKitInformation::configurationErrors(k);
return !DebuggerKitAspect::configurationErrors(k);
});
d->kitChooser->populate();
@@ -403,7 +403,7 @@ void StartApplicationDialog::run(bool attachRemote)
return;
Kit *k = dialog.d->kitChooser->currentKit();
IDevice::ConstPtr dev = DeviceKitInformation::device(k);
IDevice::ConstPtr dev = DeviceKitAspect::device(k);
auto runControl = new RunControl(nullptr, ProjectExplorer::Constants::DEBUG_RUN_MODE);
auto debugger = new DebuggerRunTool(runControl, k);

10
src/plugins/debugger/debuggeritem.cpp
View File

@@ -303,14 +303,14 @@ QString DebuggerItem::displayName() const
return m_unexpandedDisplayName;
MacroExpander expander;
expander.registerVariable("Debugger:Type", DebuggerKitInformation::tr("Type of Debugger Backend"),
expander.registerVariable("Debugger:Type", DebuggerKitAspect::tr("Type of Debugger Backend"),
[this] { return engineTypeName(); });
expander.registerVariable("Debugger:Version", DebuggerKitInformation::tr("Debugger"),
expander.registerVariable("Debugger:Version", DebuggerKitAspect::tr("Debugger"),
[this] { return !m_version.isEmpty() ? m_version :
DebuggerKitInformation::tr("Unknown debugger version"); });
expander.registerVariable("Debugger:Abi", DebuggerKitInformation::tr("Debugger"),
DebuggerKitAspect::tr("Unknown debugger version"); });
expander.registerVariable("Debugger:Abi", DebuggerKitAspect::tr("Debugger"),
[this] { return !m_abis.isEmpty() ? abiNames().join(' ') :
DebuggerKitInformation::tr("Unknown debugger ABI"); });
DebuggerKitAspect::tr("Unknown debugger ABI"); });
return expander.expand(m_unexpandedDisplayName);
}

2
src/plugins/debugger/debuggeritemmanager.cpp
View File

@@ -790,7 +790,7 @@ void DebuggerItemManagerPrivate::readLegacyDebuggers(const FileName &file)
QVariantMap data1 = v.toMap();
QString kitName = data1.value("PE.Profile.Name").toString();
QVariantMap data2 = data1.value("PE.Profile.Data").toMap();
QVariant v3 = data2.value(DebuggerKitInformation::id().toString());
QVariant v3 = data2.value(DebuggerKitAspect::id().toString());
QString fn;
if (v3.type() == QVariant::String)
fn = v3.toString();

38
src/plugins/debugger/debuggerkitconfigwidget.cpp
View File

@@ -60,11 +60,11 @@ namespace Debugger {
namespace Internal {
// -----------------------------------------------------------------------
// DebuggerKitConfigWidget
// DebuggerKitAspectWidget
// -----------------------------------------------------------------------
DebuggerKitConfigWidget::DebuggerKitConfigWidget(Kit *workingCopy, const KitInformation *ki)
: KitConfigWidget(workingCopy, ki)
DebuggerKitAspectWidget::DebuggerKitAspectWidget(Kit *workingCopy, const KitAspect *ki)
: KitAspectWidget(workingCopy, ki)
{
m_comboBox = new QComboBox;
m_comboBox->setSizePolicy(QSizePolicy::Ignored, m_comboBox->sizePolicy().verticalPolicy());
@@ -72,37 +72,37 @@ DebuggerKitConfigWidget::DebuggerKitConfigWidget(Kit *workingCopy, const KitInfo
refresh();
connect(m_comboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &DebuggerKitConfigWidget::currentDebuggerChanged);
this, &DebuggerKitAspectWidget::currentDebuggerChanged);
m_manageButton = new QPushButton(KitConfigWidget::msgManage());
m_manageButton = new QPushButton(KitAspectWidget::msgManage());
m_manageButton->setContentsMargins(0, 0, 0, 0);
connect(m_manageButton, &QAbstractButton::clicked,
this, &DebuggerKitConfigWidget::manageDebuggers);
this, &DebuggerKitAspectWidget::manageDebuggers);
}
DebuggerKitConfigWidget::~DebuggerKitConfigWidget()
DebuggerKitAspectWidget::~DebuggerKitAspectWidget()
{
delete m_comboBox;
delete m_manageButton;
}
QString DebuggerKitConfigWidget::toolTip() const
QString DebuggerKitAspectWidget::toolTip() const
{
return tr("The debugger to use for this kit.");
}
QString DebuggerKitConfigWidget::displayName() const
QString DebuggerKitAspectWidget::displayName() const
{
return tr("Debugger");
}
void DebuggerKitConfigWidget::makeReadOnly()
void DebuggerKitAspectWidget::makeReadOnly()
{
m_manageButton->setEnabled(false);
m_comboBox->setEnabled(false);
}
void DebuggerKitConfigWidget::refresh()
void DebuggerKitAspectWidget::refresh()
{
m_ignoreChanges = true;
m_comboBox->clear();
@@ -111,43 +111,43 @@ void DebuggerKitConfigWidget::refresh()
for (const DebuggerItem &item : DebuggerItemManager::debuggers())
m_comboBox->addItem(item.displayName(), item.id());
const DebuggerItem *item = DebuggerKitInformation::debugger(m_kit);
const DebuggerItem *item = DebuggerKitAspect::debugger(m_kit);
updateComboBox(item ? item->id() : QVariant());
m_ignoreChanges = false;
}
QWidget *DebuggerKitConfigWidget::buttonWidget() const
QWidget *DebuggerKitAspectWidget::buttonWidget() const
{
return m_manageButton;
}
QWidget *DebuggerKitConfigWidget::mainWidget() const
QWidget *DebuggerKitAspectWidget::mainWidget() const
{
return m_comboBox;
}
void DebuggerKitConfigWidget::manageDebuggers()
void DebuggerKitAspectWidget::manageDebuggers()
{
Core::ICore::showOptionsDialog(ProjectExplorer::Constants::DEBUGGER_SETTINGS_PAGE_ID,
buttonWidget());
}
void DebuggerKitConfigWidget::currentDebuggerChanged(int)
void DebuggerKitAspectWidget::currentDebuggerChanged(int)
{
if (m_ignoreChanges)
return;
int currentIndex = m_comboBox->currentIndex();
QVariant id = m_comboBox->itemData(currentIndex);
m_kit->setValue(DebuggerKitInformation::id(), id);
m_kit->setValue(DebuggerKitAspect::id(), id);
}
QVariant DebuggerKitConfigWidget::currentId() const
QVariant DebuggerKitAspectWidget::currentId() const
{
return m_comboBox->itemData(m_comboBox->currentIndex());
}
void DebuggerKitConfigWidget::updateComboBox(const QVariant &id)
void DebuggerKitAspectWidget::updateComboBox(const QVariant &id)
{
for (int i = 0; i < m_comboBox->count(); ++i) {
if (id == m_comboBox->itemData(i)) {

10
src/plugins/debugger/debuggerkitconfigwidget.h
View File

@@ -45,17 +45,17 @@ namespace Debugger {
namespace Internal {
// -----------------------------------------------------------------------
// DebuggerKitConfigWidget
// DebuggerKitAspectWidget
// -----------------------------------------------------------------------
class DebuggerKitConfigWidget : public ProjectExplorer::KitConfigWidget
class DebuggerKitAspectWidget : public ProjectExplorer::KitAspectWidget
{
Q_OBJECT
public:
DebuggerKitConfigWidget(ProjectExplorer::Kit *workingCopy,
const ProjectExplorer::KitInformation *ki);
~DebuggerKitConfigWidget() override;
DebuggerKitAspectWidget(ProjectExplorer::Kit *workingCopy,
const ProjectExplorer::KitAspect *ki);
~DebuggerKitAspectWidget() override;
QString displayName() const override;
QString toolTip() const override;

66
src/plugins/debugger/debuggerkitinformation.cpp
View File

@@ -46,19 +46,19 @@ using namespace Utils;
namespace Debugger {
// --------------------------------------------------------------------------
// DebuggerKitInformation
// DebuggerKitAspect
// --------------------------------------------------------------------------
DebuggerKitInformation::DebuggerKitInformation()
DebuggerKitAspect::DebuggerKitAspect()
{
setObjectName("DebuggerKitInformation");
setId(DebuggerKitInformation::id());
setObjectName("DebuggerKitAspect");
setId(DebuggerKitAspect::id());
setPriority(28000);
}
QVariant DebuggerKitInformation::defaultValue(const Kit *k) const
QVariant DebuggerKitAspect::defaultValue(const Kit *k) const
{
const Abi toolChainAbi = ToolChainKitInformation::targetAbi(k);
const Abi toolChainAbi = ToolChainKitAspect::targetAbi(k);
const Utils::FileNameList paths = Environment::systemEnvironment().path();
QVariant nextBestFit;
for (const DebuggerItem &item : DebuggerItemManager::debuggers()) {
@@ -75,7 +75,7 @@ QVariant DebuggerKitInformation::defaultValue(const Kit *k) const
return nextBestFit;
}
void DebuggerKitInformation::setup(Kit *k)
void DebuggerKitAspect::setup(Kit *k)
{
QTC_ASSERT(k, return);
@@ -92,9 +92,9 @@ void DebuggerKitInformation::setup(Kit *k)
// <value type="QString" key="Binary">auto</value>
// <value type="int" key="EngineType">4</value>
// </valuemap>
const QVariant rawId = k->value(DebuggerKitInformation::id());
const QVariant rawId = k->value(DebuggerKitAspect::id());
const Abi tcAbi = ToolChainKitInformation::targetAbi(k);
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
// Get the best of the available debugger matching the kit's toolchain.
// The general idea is to find an item that exactly matches what
@@ -160,17 +160,17 @@ void DebuggerKitInformation::setup(Kit *k)
}
// Use the best id we found, or an invalid one.
k->setValue(DebuggerKitInformation::id(), bestLevel != DebuggerItem::DoesNotMatch ? bestItem.id() : QVariant());
k->setValue(DebuggerKitAspect::id(), bestLevel != DebuggerItem::DoesNotMatch ? bestItem.id() : QVariant());
}
// This handles the upgrade path from 2.8 to 3.0
void DebuggerKitInformation::fix(Kit *k)
void DebuggerKitAspect::fix(Kit *k)
{
QTC_ASSERT(k, return);
// This can be Id, binary path, but not "auto" anymore.
const QVariant rawId = k->value(DebuggerKitInformation::id());
const QVariant rawId = k->value(DebuggerKitAspect::id());
if (rawId.isNull()) // No debugger set, that is fine.
return;
@@ -179,7 +179,7 @@ void DebuggerKitInformation::fix(Kit *k)
if (!DebuggerItemManager::findById(rawId)) {
qWarning("Unknown debugger id %s in kit %s",
qPrintable(rawId.toString()), qPrintable(k->displayName()));
k->setValue(DebuggerKitInformation::id(), QVariant());
k->setValue(DebuggerKitAspect::id(), QVariant());
}
return; // All fine (now).
}
@@ -189,7 +189,7 @@ void DebuggerKitInformation::fix(Kit *k)
if (binary == "auto") {
// This should not happen as "auto" is handled by setup() already.
QTC_CHECK(false);
k->setValue(DebuggerKitInformation::id(), QVariant());
k->setValue(DebuggerKitAspect::id(), QVariant());
return;
}
@@ -198,21 +198,21 @@ void DebuggerKitInformation::fix(Kit *k)
if (!item) {
qWarning("Debugger command %s invalid in kit %s",
qPrintable(binary), qPrintable(k->displayName()));
k->setValue(DebuggerKitInformation::id(), QVariant());
k->setValue(DebuggerKitAspect::id(), QVariant());
return;
}
k->setValue(DebuggerKitInformation::id(), item->id());
k->setValue(DebuggerKitAspect::id(), item->id());
}
// Check the configuration errors and return a flag mask. Provide a quick check and
// a verbose one with a list of errors.
DebuggerKitInformation::ConfigurationErrors DebuggerKitInformation::configurationErrors(const Kit *k)
DebuggerKitAspect::ConfigurationErrors DebuggerKitAspect::configurationErrors(const Kit *k)
{
QTC_ASSERT(k, return NoDebugger);
const DebuggerItem *item = DebuggerKitInformation::debugger(k);
const DebuggerItem *item = DebuggerKitAspect::debugger(k);
if (!item)
return NoDebugger;
@@ -226,10 +226,10 @@ DebuggerKitInformation::ConfigurationErrors DebuggerKitInformation::configuratio
else if (!fi.isExecutable())
result |= DebuggerNotExecutable;
const Abi tcAbi = ToolChainKitInformation::targetAbi(k);
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
if (item->matchTarget(tcAbi) == DebuggerItem::DoesNotMatch) {
// currently restricting the check to desktop devices, may be extended to all device types
const IDevice::ConstPtr device = DeviceKitInformation::device(k);
const IDevice::ConstPtr device = DeviceKitAspect::device(k);
if (device && device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
result |= DebuggerDoesNotMatch;
}
@@ -247,14 +247,14 @@ DebuggerKitInformation::ConfigurationErrors DebuggerKitInformation::configuratio
return result;
}
const DebuggerItem *DebuggerKitInformation::debugger(const Kit *kit)
const DebuggerItem *DebuggerKitAspect::debugger(const Kit *kit)
{
QTC_ASSERT(kit, return nullptr);
const QVariant id = kit->value(DebuggerKitInformation::id());
const QVariant id = kit->value(DebuggerKitAspect::id());
return DebuggerItemManager::findById(id);
}
Runnable DebuggerKitInformation::runnable(const Kit *kit)
Runnable DebuggerKitAspect::runnable(const Kit *kit)
{
Runnable runnable;
if (const DebuggerItem *item = debugger(kit)) {
@@ -266,7 +266,7 @@ Runnable DebuggerKitInformation::runnable(const Kit *kit)
return runnable;
}
QList<Task> DebuggerKitInformation::validateDebugger(const Kit *k)
QList<Task> DebuggerKitAspect::validateDebugger(const Kit *k)
{
QList<Task> result;
@@ -303,12 +303,12 @@ QList<Task> DebuggerKitInformation::validateDebugger(const Kit *k)
return result;
}
KitConfigWidget *DebuggerKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *DebuggerKitAspect::createConfigWidget(Kit *k) const
{
return new Internal::DebuggerKitConfigWidget(k, this);
return new Internal::DebuggerKitAspectWidget(k, this);
}
void DebuggerKitInformation::addToMacroExpander(Kit *kit, MacroExpander *expander) const
void DebuggerKitAspect::addToMacroExpander(Kit *kit, MacroExpander *expander) const
{
QTC_ASSERT(kit, return);
expander->registerVariable("Debugger:Name", tr("Name of Debugger"),
@@ -339,19 +339,19 @@ void DebuggerKitInformation::addToMacroExpander(Kit *kit, MacroExpander *expande
});
}
KitInformation::ItemList DebuggerKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList DebuggerKitAspect::toUserOutput(const Kit *k) const
{
return ItemList() << qMakePair(tr("Debugger"), displayString(k));
}
DebuggerEngineType DebuggerKitInformation::engineType(const Kit *k)
DebuggerEngineType DebuggerKitAspect::engineType(const Kit *k)
{
const DebuggerItem *item = debugger(k);
QTC_ASSERT(item, return NoEngineType);
return item->engineType();
}
QString DebuggerKitInformation::displayString(const Kit *k)
QString DebuggerKitAspect::displayString(const Kit *k)
{
const DebuggerItem *item = debugger(k);
if (!item)
@@ -361,15 +361,15 @@ QString DebuggerKitInformation::displayString(const Kit *k)
return binary.isEmpty() ? tr("%1 <None>").arg(name) : tr("%1 using \"%2\"").arg(name, binary);
}
void DebuggerKitInformation::setDebugger(Kit *k, const QVariant &id)
void DebuggerKitAspect::setDebugger(Kit *k, const QVariant &id)
{
// Only register reasonably complete debuggers.
QTC_ASSERT(DebuggerItemManager::findById(id), return);
QTC_ASSERT(k, return);
k->setValue(DebuggerKitInformation::id(), id);
k->setValue(DebuggerKitAspect::id(), id);
}
Core::Id DebuggerKitInformation::id()
Core::Id DebuggerKitAspect::id()
{
return "Debugger.Information";
}

8
src/plugins/debugger/debuggerkitinformation.h
View File

@@ -34,17 +34,17 @@
namespace Debugger {
class DebuggerItem;
class DEBUGGER_EXPORT DebuggerKitInformation : public ProjectExplorer::KitInformation
class DEBUGGER_EXPORT DebuggerKitAspect : public ProjectExplorer::KitAspect
{
Q_OBJECT
public:
DebuggerKitInformation();
DebuggerKitAspect();
QVariant defaultValue(const ProjectExplorer::Kit *k) const override;
QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *k) const override
{ return DebuggerKitInformation::validateDebugger(k); }
{ return DebuggerKitAspect::validateDebugger(k); }
void setup(ProjectExplorer::Kit *k) override;
void fix(ProjectExplorer::Kit *k) override;
@@ -66,7 +66,7 @@ public:
static QList<ProjectExplorer::Task> validateDebugger(const ProjectExplorer::Kit *k);
static ConfigurationErrors configurationErrors(const ProjectExplorer::Kit *k);
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *k) const override;
ProjectExplorer::KitAspectWidget *createConfigWidget(ProjectExplorer::Kit *k) const override;
void addToMacroExpander(ProjectExplorer::Kit *kit, Utils::MacroExpander *expander) const override;
ItemList toUserOutput(const ProjectExplorer::Kit *k) const override;

36
src/plugins/debugger/debuggerplugin.cpp
View File

@@ -549,12 +549,12 @@ QWidget *addSearch(BaseTreeView *treeView)
static Kit::Predicate cdbPredicate(char wordWidth = 0)
{
return [wordWidth](const Kit *k) -> bool {
if (DebuggerKitInformation::engineType(k) != CdbEngineType
|| DebuggerKitInformation::configurationErrors(k)) {
if (DebuggerKitAspect::engineType(k) != CdbEngineType
|| DebuggerKitAspect::configurationErrors(k)) {
return false;
}
if (wordWidth)
return ToolChainKitInformation::targetAbi(k).wordWidth() == wordWidth;
return ToolChainKitAspect::targetAbi(k).wordWidth() == wordWidth;
return true;
};
}
@@ -810,14 +810,14 @@ static Kit *guessKitFromAbis(const QList<Abi> &abis)
if (!abis.isEmpty()) {
// Try exact abis.
kit = KitManager::kit([abis](const Kit *k) {
const Abi tcAbi = ToolChainKitInformation::targetAbi(k);
return abis.contains(tcAbi) && !DebuggerKitInformation::configurationErrors(k);
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
return abis.contains(tcAbi) && !DebuggerKitAspect::configurationErrors(k);
});
if (!kit) {
// Or something compatible.
kit = KitManager::kit([abis](const Kit *k) {
const Abi tcAbi = ToolChainKitInformation::targetAbi(k);
return !DebuggerKitInformation::configurationErrors(k)
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
return !DebuggerKitAspect::configurationErrors(k)
&& Utils::contains(abis, [tcAbi](const Abi &a) { return a.isCompatibleWith(tcAbi); });
});
}
@@ -882,7 +882,7 @@ bool DebuggerPluginPrivate::parseArgument(QStringList::const_iterator &it,
if (!kit)
kit = guessKitFromAbis(Abi::abisOfBinary(FileName::fromString(executable)));
IDevice::ConstPtr device = DeviceKitInformation::device(kit);
IDevice::ConstPtr device = DeviceKitAspect::device(kit);
auto runControl = new RunControl(device, ProjectExplorer::Constants::DEBUG_RUN_MODE);
auto debugger = new DebuggerRunTool(runControl, kit);
debugger->setInferiorExecutable(executable);
@@ -1577,7 +1577,7 @@ void DebuggerPluginPrivate::attachCore()
setConfigValue("LastExternalStartScript", dlg.overrideStartScript());
setConfigValue("LastForceLocalCoreFile", dlg.forcesLocalCoreFile());
IDevice::ConstPtr device = DeviceKitInformation::device(dlg.kit());
IDevice::ConstPtr device = DeviceKitAspect::device(dlg.kit());
auto runControl = new RunControl(device, ProjectExplorer::Constants::DEBUG_RUN_MODE);
auto debugger = new DebuggerRunTool(runControl, dlg.kit());
debugger->setInferiorExecutable(dlg.symbolFile());
@@ -1605,7 +1605,7 @@ void DebuggerPluginPrivate::startRemoteCdbSession()
return;
setConfigValue(connectionKey, dlg.connection());
IDevice::ConstPtr device = DeviceKitInformation::device(kit);
IDevice::ConstPtr device = DeviceKitAspect::device(kit);
auto runControl = new RunControl(device, ProjectExplorer::Constants::DEBUG_RUN_MODE);
auto debugger = new DebuggerRunTool(runControl, kit);
debugger->setStartMode(AttachToRemoteServer);
@@ -1620,7 +1620,7 @@ public:
RemoteAttachRunner(RunControl *runControl, Kit *kit, int pid)
: DebuggerRunTool(runControl, kit)
{
IDevice::ConstPtr device = DeviceKitInformation::device(kit);
IDevice::ConstPtr device = DeviceKitAspect::device(kit);
setId("AttachToRunningProcess");
setUsePortsGatherer(true, false);
portsGatherer()->setDevice(device);
@@ -1656,7 +1656,7 @@ void DebuggerPluginPrivate::attachToRunningApplication()
dlg->setAttribute(Qt::WA_DeleteOnClose);
Kit *kit = kitChooser->currentKit();
QTC_ASSERT(kit, return);
IDevice::ConstPtr device = DeviceKitInformation::device(kit);
IDevice::ConstPtr device = DeviceKitAspect::device(kit);
QTC_ASSERT(device, return);
DeviceProcessItem process = dlg->currentProcess();
@@ -1693,14 +1693,14 @@ RunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
DeviceProcessItem process, bool contAfterAttach)
{
QTC_ASSERT(kit, return nullptr);
IDevice::ConstPtr device = DeviceKitInformation::device(kit);
IDevice::ConstPtr device = DeviceKitAspect::device(kit);
QTC_ASSERT(device, return nullptr);
if (process.pid == 0) {
AsynchronousMessageBox::warning(tr("Warning"), tr("Cannot attach to process with PID 0"));
return nullptr;
}
const Abi tcAbi = ToolChainKitInformation::targetAbi(kit);
const Abi tcAbi = ToolChainKitAspect::targetAbi(kit);
const bool isWindows = (tcAbi.os() == Abi::WindowsOS);
if (isWindows && isWinProcessBeingDebugged(process.pid)) {
AsynchronousMessageBox::warning(
@@ -1795,7 +1795,7 @@ void DebuggerPluginPrivate::attachToQmlPort()
setConfigValue("LastQmlServerPort", dlg.port());
setConfigValue("LastProfile", kit->id().toSetting());
IDevice::ConstPtr device = DeviceKitInformation::device(kit);
IDevice::ConstPtr device = DeviceKitAspect::device(kit);
QTC_ASSERT(device, return);
auto runControl = new RunControl(nullptr, ProjectExplorer::Constants::DEBUG_RUN_MODE);
@@ -2073,7 +2073,7 @@ void DebuggerPluginPrivate::extensionsInitialized()
if (runnable.device && runnable.device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
return true;
if (DeviceTypeKitInformation::deviceTypeId(runConfig->target()->kit())
if (DeviceTypeKitAspect::deviceTypeId(runConfig->target()->kit())
== ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
return true;
@@ -2251,7 +2251,7 @@ bool DebuggerPlugin::initialize(const QStringList &arguments, QString *errorMess
mstart->addSeparator(Constants::G_GENERAL);
mstart->addSeparator(Constants::G_SPECIAL);
KitManager::registerKitInformation<DebuggerKitInformation>();
KitManager::registerKitAspect<DebuggerKitAspect>();
// Task integration.
//: Category under which Analyzer tasks are listed in Issues view
@@ -2460,7 +2460,7 @@ void DebuggerUnitTests::initTestCase()
// const QList<Kit *> allKits = KitManager::kits();
// if (allKits.count() != 1)
// QSKIP("This test requires exactly one kit to be present");
// const ToolChain * const toolchain = ToolChainKitInformation::toolChain(allKits.first());
// const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first());
// if (!toolchain)
// QSKIP("This test requires that there is a kit with a toolchain.");
// bool hasClangExecutable;

2
src/plugins/debugger/debuggerrunconfigurationaspect.cpp
View File

@@ -278,7 +278,7 @@ void DebuggerRunConfigurationAspect::setUseMultiProcess(bool value)
bool DebuggerRunConfigurationAspect::isQmlDebuggingSpinboxSuppressed() const
{
Kit *k = m_target->kit();
IDevice::ConstPtr dev = DeviceKitInformation::device(k);
IDevice::ConstPtr dev = DeviceKitAspect::device(k);
if (dev.isNull())
return false;
return dev->canAutoDetectPorts();

12
src/plugins/debugger/debuggerruncontrol.cpp
View File

@@ -912,12 +912,12 @@ DebuggerRunTool::DebuggerRunTool(RunControl *runControl, Kit *kit, bool allowTer
kit = runConfig->target()->kit();
QTC_ASSERT(kit, return);
m_runParameters.sysRoot = SysRootKitInformation::sysRoot(kit);
m_runParameters.sysRoot = SysRootKitAspect::sysRoot(kit);
m_runParameters.macroExpander = kit->macroExpander();
m_runParameters.debugger = DebuggerKitInformation::runnable(kit);
m_runParameters.cppEngineType = DebuggerKitInformation::engineType(kit);
m_runParameters.debugger = DebuggerKitAspect::runnable(kit);
m_runParameters.cppEngineType = DebuggerKitAspect::engineType(kit);
if (QtSupport::BaseQtVersion *qtVersion = QtSupport::QtKitInformation::qtVersion(kit))
if (QtSupport::BaseQtVersion *qtVersion = QtSupport::QtKitAspect::qtVersion(kit))
m_runParameters.qtPackageSourceLocation = qtVersion->qtPackageSourcePath().toString();
if (auto aspect = runConfig ? runConfig->aspect<DebuggerRunConfigurationAspect>() : nullptr) {
@@ -943,7 +943,7 @@ DebuggerRunTool::DebuggerRunTool(RunControl *runControl, Kit *kit, bool allowTer
m_runParameters.projectSourceFiles = project->files(Project::SourceFiles);
}
m_runParameters.toolChainAbi = ToolChainKitInformation::targetAbi(kit);
m_runParameters.toolChainAbi = ToolChainKitAspect::targetAbi(kit);
bool ok = false;
int nativeMixedOverride = qgetenv("QTC_DEBUGGER_NATIVE_MIXED").toInt(&ok);
@@ -952,7 +952,7 @@ DebuggerRunTool::DebuggerRunTool(RunControl *runControl, Kit *kit, bool allowTer
// This will only be shown in some cases, but we don't want to access
// the kit at that time anymore.
const QList<Task> tasks = DebuggerKitInformation::validateDebugger(kit);
const QList<Task> tasks = DebuggerKitAspect::validateDebugger(kit);
for (const Task &t : tasks) {
if (t.type != Task::Warning)
m_runParameters.validationErrors.append(t.description);

6
src/plugins/debugger/loadcoredialog.cpp
View File

@@ -137,7 +137,7 @@ void SelectRemoteFileDialog::attachToDevice(Kit *k)
{
m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
QTC_ASSERT(k, return);
IDevice::ConstPtr device = DeviceKitInformation::device(k);
IDevice::ConstPtr device = DeviceKitAspect::device(k);
QTC_ASSERT(device, return);
SshConnectionParameters sshParams = device->sshParameters();
m_fileSystemModel.setSshConnection(sshParams);
@@ -352,7 +352,7 @@ bool AttachCoreDialog::isLocalKit() const
{
Kit *k = d->kitChooser->currentKit();
QTC_ASSERT(k, return false);
IDevice::ConstPtr device = DeviceKitInformation::device(k);
IDevice::ConstPtr device = DeviceKitAspect::device(k);
QTC_ASSERT(device, return false);
return device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
}
@@ -367,7 +367,7 @@ void AttachCoreDialog::coreFileChanged(const QString &core)
if (!HostOsInfo::isWindowsHost() && QFile::exists(core)) {
Kit *k = d->kitChooser->currentKit();
QTC_ASSERT(k, return);
Runnable debugger = DebuggerKitInformation::runnable(k);
Runnable debugger = DebuggerKitAspect::runnable(k);
CoreInfo cinfo = CoreInfo::readExecutableNameFromCore(debugger, core);
if (!cinfo.foundExecutableName.isEmpty())
d->symbolFileName->setFileName(FileName::fromString(cinfo.foundExecutableName));

4
src/plugins/debugger/unstartedappwatcherdialog.cpp
View File

@@ -59,7 +59,7 @@ static bool isLocal(RunConfiguration *runConfiguration)
{
Target *target = runConfiguration ? runConfiguration->target() : nullptr;
Kit *kit = target ? target->kit() : nullptr;
return DeviceTypeKitInformation::deviceTypeId(kit) == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
return DeviceTypeKitAspect::deviceTypeId(kit) == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE;
}
/*!
@@ -275,7 +275,7 @@ void UnstartedAppWatcherDialog::stopAndCheckExecutable()
void UnstartedAppWatcherDialog::kitChanged()
{
const DebuggerItem *debugger = DebuggerKitInformation::debugger(m_kitChooser->currentKit());
const DebuggerItem *debugger = DebuggerKitAspect::debugger(m_kitChooser->currentKit());
if (!debugger)
return;
if (debugger->engineType() == Debugger::CdbEngineType) {

2
src/plugins/genericprojectmanager/genericbuildconfiguration.cpp
View File

@@ -122,7 +122,7 @@ BuildConfiguration::BuildType GenericBuildConfiguration::buildType() const
void GenericBuildConfiguration::addToEnvironment(Utils::Environment &env) const
{
prependCompilerPathToEnvironment(env);
const QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(target()->kit());
const QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(target()->kit());
if (qt)
env.prependOrSetPath(qt->binPath().toString());
}

4
src/plugins/ios/iosbuildconfiguration.cpp
View File

@@ -58,7 +58,7 @@ QList<ProjectExplorer::NamedWidget *> IosBuildConfiguration::createSubConfigWidg
{
auto subConfigWidgets = QmakeBuildConfiguration::createSubConfigWidgets();
Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(target()->kit());
Core::Id devType = ProjectExplorer::DeviceTypeKitAspect::deviceTypeId(target()->kit());
// Ownership of this widget is with BuildSettingsWidget
auto buildSettingsWidget = new IosBuildSettingsWidget(devType, m_signingIdentifier,
m_autoManagedSigning);
@@ -113,7 +113,7 @@ void IosBuildConfiguration::updateQmakeCommand()
if (!m_signingIdentifier.isEmpty() )
extraArgs << forceOverrideArg;
Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(target()->kit());
Core::Id devType = ProjectExplorer::DeviceTypeKitAspect::deviceTypeId(target()->kit());
if (devType == Constants::IOS_DEVICE_TYPE && !m_signingIdentifier.isEmpty()) {
if (m_autoManagedSigning) {
extraArgs << qmakeIosTeamSettings + m_signingIdentifier;

8
src/plugins/ios/iosbuildstep.cpp
View File

@@ -76,7 +76,7 @@ bool IosBuildStep::init()
if (!bc)
emit addTask(Task::buildConfigurationMissingTask());
ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolChain *tc = ToolChainKitAspect::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!tc)
emit addTask(Task::compilerMissingTask());
@@ -138,7 +138,7 @@ QStringList IosBuildStep::defaultArguments() const
{
QStringList res;
Kit *kit = target()->kit();
ToolChain *tc = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolChain *tc = ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
switch (buildConfiguration()->buildType()) {
case BuildConfiguration::Debug :
res << "-configuration" << "Debug";
@@ -158,8 +158,8 @@ QStringList IosBuildStep::defaultArguments() const
auto gtc = static_cast<GccToolChain *>(tc);
res << gtc->platformCodeGenFlags();
}
if (!SysRootKitInformation::sysRoot(kit).isEmpty())
res << "-sdk" << SysRootKitInformation::sysRoot(kit).toString();
if (!SysRootKitAspect::sysRoot(kit).isEmpty())
res << "-sdk" << SysRootKitAspect::sysRoot(kit).toString();
res << "SYMROOT=" + buildConfiguration()->buildDirectory().toString();
return res;
}

44
src/plugins/ios/iosconfigurations.cpp
View File

@@ -168,7 +168,7 @@ static QHash<XcodePlatform::ToolchainTarget, ToolChainPair> findToolChains(const
static QSet<Kit *> existingAutoDetectedIosKits()
{
return Utils::filtered(KitManager::kits(), [](Kit *kit) -> bool {
Core::Id deviceKind = DeviceTypeKitInformation::deviceTypeId(kit);
Core::Id deviceKind = DeviceTypeKitAspect::deviceTypeId(kit);
return kit->isAutoDetected() && (deviceKind == Constants::IOS_DEVICE_TYPE
|| deviceKind == Constants::IOS_SIMULATOR_TYPE);
}).toSet();
@@ -183,33 +183,33 @@ static void printKits(const QSet<Kit *> &kits)
static void setupKit(Kit *kit, Core::Id pDeviceType, const ToolChainPair& toolChains,
const QVariant &debuggerId, const Utils::FileName &sdkPath, BaseQtVersion *qtVersion)
{
DeviceTypeKitInformation::setDeviceTypeId(kit, pDeviceType);
DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
if (toolChains.first)
ToolChainKitInformation::setToolChain(kit, toolChains.first);
ToolChainKitAspect::setToolChain(kit, toolChains.first);
else
ToolChainKitInformation::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
if (toolChains.second)
ToolChainKitInformation::setToolChain(kit, toolChains.second);
ToolChainKitAspect::setToolChain(kit, toolChains.second);
else
ToolChainKitInformation::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QtKitInformation::setQtVersion(kit, qtVersion);
QtKitAspect::setQtVersion(kit, qtVersion);
// only replace debugger with the default one if we find an unusable one here
// (since the user could have changed it)
if ((!DebuggerKitInformation::debugger(kit)
|| !DebuggerKitInformation::debugger(kit)->isValid()
|| DebuggerKitInformation::debugger(kit)->engineType() != LldbEngineType)
if ((!DebuggerKitAspect::debugger(kit)
|| !DebuggerKitAspect::debugger(kit)->isValid()
|| DebuggerKitAspect::debugger(kit)->engineType() != LldbEngineType)
&& debuggerId.isValid())
DebuggerKitInformation::setDebugger(kit, debuggerId);
DebuggerKitAspect::setDebugger(kit, debuggerId);
kit->setMutable(DeviceKitInformation::id(), true);
kit->setSticky(QtKitInformation::id(), true);
kit->setSticky(ToolChainKitInformation::id(), true);
kit->setSticky(DeviceTypeKitInformation::id(), true);
kit->setSticky(SysRootKitInformation::id(), true);
kit->setSticky(DebuggerKitInformation::id(), false);
kit->setMutable(DeviceKitAspect::id(), true);
kit->setSticky(QtKitAspect::id(), true);
kit->setSticky(ToolChainKitAspect::id(), true);
kit->setSticky(DeviceTypeKitAspect::id(), true);
kit->setSticky(SysRootKitAspect::id(), true);
kit->setSticky(DebuggerKitAspect::id(), false);
SysRootKitInformation::setSysRoot(kit, sdkPath);
SysRootKitAspect::setSysRoot(kit, sdkPath);
}
static QVersionNumber findXcodeVersion(const Utils::FileName &developerPath)
@@ -287,10 +287,10 @@ void IosConfigurations::updateAutomaticKitList()
Kit *kit = Utils::findOrDefault(existingKits, [&pDeviceType, &platformToolchains, &qtVersion](const Kit *kit) {
// we do not compare the sdk (thus automatically upgrading it in place if a
// new Xcode is used). Change?
return DeviceTypeKitInformation::deviceTypeId(kit) == pDeviceType
&& ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID) == platformToolchains.second
&& ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID) == platformToolchains.first
&& QtKitInformation::qtVersion(kit) == qtVersion;
return DeviceTypeKitAspect::deviceTypeId(kit) == pDeviceType
&& ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID) == platformToolchains.second
&& ToolChainKitAspect::toolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID) == platformToolchains.first
&& QtKitAspect::qtVersion(kit) == qtVersion;
});
QTC_ASSERT(!resultingKits.contains(kit), continue);
if (kit) {

4
src/plugins/ios/iosdeploystep.cpp
View File

@@ -73,7 +73,7 @@ Core::Id IosDeployStep::stepId()
void IosDeployStep::updateDisplayNames()
{
IDevice::ConstPtr dev =
DeviceKitInformation::device(target()->kit());
DeviceKitAspect::device(target()->kit());
const QString devName = dev.isNull() ? IosDevice::name() : dev->displayName();
setDefaultDisplayName(tr("Deploy to %1").arg(devName));
setDisplayName(tr("Deploy to %1").arg(devName));
@@ -82,7 +82,7 @@ void IosDeployStep::updateDisplayNames()
bool IosDeployStep::init()
{
QTC_ASSERT(m_transferStatus == NoTransfer, return false);
m_device = DeviceKitInformation::device(target()->kit());
m_device = DeviceKitAspect::device(target()->kit());
auto runConfig = qobject_cast<const IosRunConfiguration *>(
this->target()->activeRunConfiguration());
QTC_ASSERT(runConfig, return false);

4
src/plugins/ios/iosdevice.cpp
View File

@@ -538,11 +538,11 @@ void IosDeviceManager::updateAvailableDevices(const QStringList &devices)
}
}
IosDevice::ConstPtr IosKitInformation::device(Kit *kit)
IosDevice::ConstPtr IosKitAspect::device(Kit *kit)
{
if (!kit)
return IosDevice::ConstPtr();
IDevice::ConstPtr dev = DeviceKitInformation::device(kit);
IDevice::ConstPtr dev = DeviceKitAspect::device(kit);
IosDevice::ConstPtr res = dev.dynamicCast<const IosDevice>();
return res;
}

2
src/plugins/ios/iosdevice.h
View File

@@ -103,7 +103,7 @@ private:
QStringList m_userModeDeviceIds;
};
namespace IosKitInformation {
namespace IosKitAspect {
IosDevice::ConstPtr device(ProjectExplorer::Kit *);
}

14
src/plugins/ios/iosrunconfiguration.cpp
View File

@@ -125,7 +125,7 @@ void IosDeviceTypeAspect::deviceChanges()
void IosDeviceTypeAspect::updateDeviceType()
{
if (DeviceTypeKitInformation::deviceTypeId(m_runConfiguration->target()->kit())
if (DeviceTypeKitAspect::deviceTypeId(m_runConfiguration->target()->kit())
== Constants::IOS_DEVICE_TYPE)
m_deviceType = IosDeviceType(IosDeviceType::IosDevice);
else if (m_deviceType.type == IosDeviceType::IosDevice)
@@ -134,7 +134,7 @@ void IosDeviceTypeAspect::updateDeviceType()
void IosRunConfiguration::updateDisplayNames()
{
IDevice::ConstPtr dev = DeviceKitInformation::device(target()->kit());
IDevice::ConstPtr dev = DeviceKitAspect::device(target()->kit());
const QString devName = dev.isNull() ? IosDevice::name() : dev->displayName();
setDefaultDisplayName(tr("Run on %1").arg(devName));
setDisplayName(tr("Run %1 on %2").arg(applicationName()).arg(devName));
@@ -144,12 +144,12 @@ void IosRunConfiguration::updateDisplayNames()
void IosRunConfiguration::updateEnabledState()
{
Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target()->kit());
Core::Id devType = DeviceTypeKitAspect::deviceTypeId(target()->kit());
if (devType != Constants::IOS_DEVICE_TYPE && devType != Constants::IOS_SIMULATOR_TYPE) {
setEnabled(false);
return;
}
IDevice::ConstPtr dev = DeviceKitInformation::device(target()->kit());
IDevice::ConstPtr dev = DeviceKitAspect::device(target()->kit());
if (dev.isNull() || dev->deviceState() != IDevice::DeviceReadyToUse) {
setEnabled(false);
return;
@@ -176,7 +176,7 @@ QString IosRunConfiguration::applicationName() const
FileName IosRunConfiguration::bundleDirectory() const
{
FileName res;
Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target()->kit());
Core::Id devType = DeviceTypeKitAspect::deviceTypeId(target()->kit());
bool isDevice = (devType == Constants::IOS_DEVICE_TYPE);
if (!isDevice && devType != Constants::IOS_SIMULATOR_TYPE) {
qCWarning(iosLog) << "unexpected device type in bundleDirForTarget: " << devType.toString();
@@ -238,10 +238,10 @@ void IosDeviceTypeAspect::toMap(QVariantMap &map) const
QString IosRunConfiguration::disabledReason() const
{
Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target()->kit());
Core::Id devType = DeviceTypeKitAspect::deviceTypeId(target()->kit());
if (devType != Constants::IOS_DEVICE_TYPE && devType != Constants::IOS_SIMULATOR_TYPE)
return tr("Kit has incorrect device type for running on iOS devices.");
IDevice::ConstPtr dev = DeviceKitInformation::device(target()->kit());
IDevice::ConstPtr dev = DeviceKitAspect::device(target()->kit());
QString validDevName;
bool hasConncetedDev = false;
if (devType == Constants::IOS_DEVICE_TYPE) {

4
src/plugins/ios/iosrunner.cpp
View File

@@ -81,7 +81,7 @@ static void stopRunningRunControl(RunControl *runControl)
RunConfiguration *runConfig = runControl->runConfiguration();
Target *target = runConfig->target();
Core::Id devId = DeviceKitInformation::deviceId(target->kit());
Core::Id devId = DeviceKitAspect::deviceId(target->kit());
// The device can only run an application at a time, if an app is running stop it.
if (activeRunControls.contains(devId)) {
@@ -101,7 +101,7 @@ IosRunner::IosRunner(RunControl *runControl)
auto runConfig = qobject_cast<IosRunConfiguration *>(runControl->runConfiguration());
m_bundleDir = runConfig->bundleDirectory().toString();
m_arguments = runConfig->aspect<ArgumentsAspect>()->arguments(runConfig->macroExpander());
m_device = DeviceKitInformation::device(runConfig->target()->kit());
m_device = DeviceKitAspect::device(runConfig->target()->kit());
m_deviceType = runConfig->deviceType();
}

2
src/plugins/ios/iossimulator.cpp
View File

@@ -144,7 +144,7 @@ IosSimulator::ConstPtr IosKitInformation::simulator(Kit *kit)
{
if (!kit)
return IosSimulator::ConstPtr();
IDevice::ConstPtr dev = DeviceKitInformation::device(kit);
IDevice::ConstPtr dev = DeviceKitAspect::device(kit);
IosSimulator::ConstPtr res = dev.dynamicCast<const IosSimulator>();
return res;
}

2
src/plugins/nim/project/nimcompilerbuildstep.cpp
View File

@@ -226,7 +226,7 @@ void NimCompilerBuildStep::updateCommand()
QTC_ASSERT(target(), return);
QTC_ASSERT(target()->kit(), return);
Kit *kit = target()->kit();
auto tc = dynamic_cast<NimToolChain*>(ToolChainKitInformation::toolChain(kit, Constants::C_NIMLANGUAGE_ID));
auto tc = dynamic_cast<NimToolChain*>(ToolChainKitAspect::toolChain(kit, Constants::C_NIMLANGUAGE_ID));
QTC_ASSERT(tc, return);
processParameters()->setCommand(tc->compilerCommand().toString());
}

2
src/plugins/nim/project/nimproject.cpp
View File

@@ -153,7 +153,7 @@ void NimProject::updateProject()
QList<Task> NimProject::projectIssues(const Kit *k) const
{
QList<Task> result = Project::projectIssues(k);
auto tc = dynamic_cast<NimToolChain *>(ToolChainKitInformation::toolChain(k,
auto tc = dynamic_cast<NimToolChain *>(ToolChainKitAspect::toolChain(k,
Constants::C_NIMLANGUAGE_ID));
if (!tc) {
result.append(createProjectTask(Task::TaskType::Error, tr("No Nim compiler set.")));

2
src/plugins/perfprofiler/perfconfigwidget.cpp
View File

@@ -147,7 +147,7 @@ void PerfConfigWidget::setTarget(ProjectExplorer::Target *target)
ProjectExplorer::IDevice::ConstPtr device;
if (target) {
if (ProjectExplorer::Kit *kit = target->kit())
device = ProjectExplorer::DeviceKitInformation::device(kit);
device = ProjectExplorer::DeviceKitAspect::device(kit);
}
if (device.isNull()) {

6
src/plugins/perfprofiler/perfdatareader.cpp
View File

@@ -291,7 +291,7 @@ QStringList PerfDataReader::collectArguments(const QString &executableDirPath,
if (!executableDirPath.isEmpty())
arguments << QLatin1String("--app") << executableDirPath;
if (QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(kit)) {
if (QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(kit)) {
arguments << QLatin1String("--extra") << QString::fromLatin1("%1%5%2%5%3%5%4")
.arg(QDir::toNativeSeparators(qt->libraryPath().toString()))
.arg(QDir::toNativeSeparators(qt->pluginPath().toString()))
@@ -300,7 +300,7 @@ QStringList PerfDataReader::collectArguments(const QString &executableDirPath,
.arg(QDir::listSeparator());
}
if (auto toolChain = ProjectExplorer::ToolChainKitInformation::toolChain(
if (auto toolChain = ProjectExplorer::ToolChainKitAspect::toolChain(
kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID)) {
ProjectExplorer::Abi::Architecture architecture = toolChain->targetAbi().architecture();
if (architecture == ProjectExplorer::Abi::ArmArchitecture &&
@@ -311,7 +311,7 @@ QStringList PerfDataReader::collectArguments(const QString &executableDirPath,
}
}
QString sysroot = ProjectExplorer::SysRootKitInformation::sysRoot(kit).toString();
QString sysroot = ProjectExplorer::SysRootKitAspect::sysRoot(kit).toString();
if (!sysroot.isEmpty())
arguments << QLatin1String("--sysroot") << sysroot;

4
src/plugins/perfprofiler/perfprofilertool.cpp
View File

@@ -553,7 +553,7 @@ void PerfProfilerTool::gotoSourceLocation(QString filePath, int lineNumber, int
static Utils::FileNameList collectQtIncludePaths(const ProjectExplorer::Kit *kit)
{
QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(kit);
QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(kit);
if (qt == nullptr)
return Utils::FileNameList();
Utils::FileNameList paths{qt->headerPath()};
@@ -568,7 +568,7 @@ static Utils::FileNameList collectQtIncludePaths(const ProjectExplorer::Kit *kit
static Utils::FileName sysroot(const Kit *kit)
{
return SysRootKitInformation::sysRoot(kit);
return SysRootKitAspect::sysRoot(kit);
}
static Utils::FileNameList sourceFiles(const Project *currentProject = nullptr)

2
src/plugins/perfprofiler/perftracepointdialog.cpp
View File

@@ -52,7 +52,7 @@ PerfTracePointDialog::PerfTracePointDialog() :
const Kit *kit = target->kit();
QTC_ASSERT(kit, return);
m_device = DeviceKitInformation::device(kit);
m_device = DeviceKitAspect::device(kit);
if (!m_device) {
m_ui->textEdit->setPlainText(tr("Error: No device available for active target."));
return;

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

@@ -307,7 +307,7 @@ void BuildConfiguration::prependCompilerPathToEnvironment(Utils::Environment &en
void BuildConfiguration::prependCompilerPathToEnvironment(Kit *k, Utils::Environment &env)
{
const ToolChain *tc
= ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
= ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!tc)
return;
@@ -363,7 +363,7 @@ bool BuildConfigurationFactory::supportsTargetDeviceType(Core::Id id) const
BuildConfigurationFactory *BuildConfigurationFactory::find(const Kit *k, const QString &projectPath)
{
QTC_ASSERT(k, return nullptr);
const Core::Id deviceType = DeviceTypeKitInformation::deviceTypeId(k);
const Core::Id deviceType = DeviceTypeKitAspect::deviceTypeId(k);
for (BuildConfigurationFactory *factory : g_buildConfigurationFactories) {
if (Utils::mimeTypeForFile(projectPath).matchesName(factory->m_supportedProjectMimeTypeName)
&& factory->supportsTargetDeviceType(deviceType))
@@ -405,7 +405,7 @@ bool BuildConfigurationFactory::canHandle(const Target *target) const
if (containsType(target->project()->projectIssues(target->kit()), Task::TaskType::Error))
return false;
if (!supportsTargetDeviceType(DeviceTypeKitInformation::deviceTypeId(target->kit())))
if (!supportsTargetDeviceType(DeviceTypeKitAspect::deviceTypeId(target->kit())))
return false;
return true;

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

@@ -299,7 +299,7 @@ bool BuildStepFactory::canHandle(BuildStepList *bsl) const
if (!m_supportedDeviceTypes.isEmpty()) {
Target *target = bsl->target();
QTC_ASSERT(target, return false);
Core::Id deviceType = DeviceTypeKitInformation::deviceTypeId(target->kit());
Core::Id deviceType = DeviceTypeKitAspect::deviceTypeId(target->kit());
if (!m_supportedDeviceTypes.contains(deviceType))
return false;
}

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

@@ -162,7 +162,7 @@ bool DeployConfigurationFactory::canHandle(Target *target) const
if (!m_supportedTargetDeviceTypes.isEmpty()) {
if (!m_supportedTargetDeviceTypes.contains(
DeviceTypeKitInformation::deviceTypeId(target->kit())))
DeviceTypeKitAspect::deviceTypeId(target->kit())))
return false;
}

6
src/plugins/projectexplorer/devicesupport/devicecheckbuildstep.cpp
View File

@@ -44,9 +44,9 @@ DeviceCheckBuildStep::DeviceCheckBuildStep(BuildStepList *bsl)
bool DeviceCheckBuildStep::init()
{
IDevice::ConstPtr device = DeviceKitInformation::device(target()->kit());
IDevice::ConstPtr device = DeviceKitAspect::device(target()->kit());
if (!device) {
Core::Id deviceTypeId = DeviceTypeKitInformation::deviceTypeId(target()->kit());
Core::Id deviceTypeId = DeviceTypeKitAspect::deviceTypeId(target()->kit());
IDeviceFactory *factory = IDeviceFactory::find(deviceTypeId);
if (!factory || !factory->canCreate()) {
emit addOutput(tr("No device configured."), BuildStep::OutputFormat::ErrorMessage);
@@ -71,7 +71,7 @@ bool DeviceCheckBuildStep::init()
DeviceManager *dm = DeviceManager::instance();
dm->addDevice(newDevice);
DeviceKitInformation::setDevice(target()->kit(), newDevice);
DeviceKitAspect::setDevice(target()->kit(), newDevice);
}
return true;

2
src/plugins/projectexplorer/devicesupport/deviceprocessesdialog.cpp
View File

@@ -267,7 +267,7 @@ void DeviceProcessesDialogPrivate::killProcess()
void DeviceProcessesDialogPrivate::updateDevice()
{
setDevice(DeviceKitInformation::device(kitChooser->currentKit()));
setDevice(DeviceKitAspect::device(kitChooser->currentKit()));
}
void DeviceProcessesDialogPrivate::handleProcessKilled()

2
src/plugins/projectexplorer/devicesupport/idevice.cpp
View File

@@ -249,7 +249,7 @@ Core::Id IDevice::id() const
*/
bool IDevice::isCompatibleWith(const Kit *k) const
{
return DeviceTypeKitInformation::deviceTypeId(k) == type();
return DeviceTypeKitAspect::deviceTypeId(k) == type();
}
void IDevice::addDeviceAction(const DeviceAction &deviceAction)

2
src/plugins/projectexplorer/extracompiler.cpp
View File

@@ -255,7 +255,7 @@ Utils::Environment ExtraCompiler::buildEnvironment() const
return bc->environment();
} else {
QList<Utils::EnvironmentItem> changes =
EnvironmentKitInformation::environmentChanges(target->kit());
EnvironmentKitAspect::environmentChanges(target->kit());
Utils::Environment env = Utils::Environment::systemEnvironment();
env.modify(changes);
return env;

38
src/plugins/projectexplorer/kit.cpp
View File

@@ -86,7 +86,7 @@ public:
[kit] { return kit->id().toString(); });
m_macroExpander.registerVariable("Kit:FileSystemName", tr("Kit filesystem-friendly name"),
[kit] { return kit->fileSystemFriendlyName(); });
foreach (KitInformation *ki, KitManager::kitInformation())
foreach (KitAspect *ki, KitManager::kitInformation())
ki->addToMacroExpander(kit, &m_macroExpander);
// This provides the same global fall back as the global expander
@@ -134,7 +134,7 @@ public:
Kit::Kit(Id id) :
d(std::make_unique<Internal::KitPrivate>(id, this))
{
foreach (KitInformation *sti, KitManager::kitInformation())
foreach (KitAspect *sti, KitManager::kitInformation())
d->m_data.insert(sti->id(), sti->defaultValue(this));
}
@@ -246,8 +246,8 @@ bool Kit::hasWarning() const
QList<Task> Kit::validate() const
{
QList<Task> result;
QList<KitInformation *> infoList = KitManager::kitInformation();
for (KitInformation *i : infoList) {
QList<KitAspect *> infoList = KitManager::kitInformation();
for (KitAspect *i : infoList) {
QList<Task> tmp = i->validate(this);
result.append(tmp);
}
@@ -262,7 +262,7 @@ QList<Task> Kit::validate() const
void Kit::fix()
{
KitGuard g(this);
foreach (KitInformation *i, KitManager::kitInformation())
foreach (KitAspect *i, KitManager::kitInformation())
i->fix(this);
}
@@ -271,7 +271,7 @@ void Kit::setup()
KitGuard g(this);
// Process the KitInfos in reverse order: They may only be based on other information lower in
// the stack.
QList<KitInformation *> info = KitManager::kitInformation();
QList<KitAspect *> info = KitManager::kitInformation();
for (int i = info.count() - 1; i >= 0; --i)
info.at(i)->setup(this);
}
@@ -281,7 +281,7 @@ void Kit::upgrade()
KitGuard g(this);
// Process the KitInfos in reverse order: They may only be based on other information lower in
// the stack.
for (KitInformation *ki : KitManager::kitInformation())
for (KitAspect *ki : KitManager::kitInformation())
ki->upgrade(this);
}
@@ -371,7 +371,7 @@ QIcon Kit::icon() const
return d->m_cachedIcon;
}
const Core::Id deviceType = DeviceTypeKitInformation::deviceTypeId(this);
const Core::Id deviceType = DeviceTypeKitAspect::deviceTypeId(this);
const QIcon deviceTypeIcon = iconForDeviceType(deviceType);
if (!deviceTypeIcon.isNull()) {
d->m_cachedIcon = deviceTypeIcon;
@@ -503,16 +503,16 @@ QVariantMap Kit::toMap() const
void Kit::addToEnvironment(Environment &env) const
{
QList<KitInformation *> infoList = KitManager::kitInformation();
foreach (KitInformation *ki, infoList)
QList<KitAspect *> infoList = KitManager::kitInformation();
foreach (KitAspect *ki, infoList)
ki->addToEnvironment(this, env);
}
IOutputParser *Kit::createOutputParser() const
{
auto first = new OsParser;
QList<KitInformation *> infoList = KitManager::kitInformation();
foreach (KitInformation *ki, infoList)
QList<KitAspect *> infoList = KitManager::kitInformation();
foreach (KitAspect *ki, infoList)
first->appendOutputParser(ki->createOutputParser(this));
return first;
}
@@ -528,10 +528,10 @@ QString Kit::toHtml(const QList<Task> &additional) const
str << "<p>" << ProjectExplorer::toHtml(additional + validate()) << "</p>";
str << "<table>";
QList<KitInformation *> infoList = KitManager::kitInformation();
foreach (KitInformation *ki, infoList) {
KitInformation::ItemList list = ki->toUserOutput(this);
foreach (const KitInformation::Item &j, list) {
QList<KitAspect *> infoList = KitManager::kitInformation();
foreach (KitAspect *ki, infoList) {
KitAspect::ItemList list = ki->toUserOutput(this);
foreach (const KitAspect::Item &j, list) {
QString contents = j.second;
if (contents.count() > 256) {
int pos = contents.lastIndexOf("<br>", 256);
@@ -573,7 +573,7 @@ void Kit::setSdkProvided(bool sdkProvided)
void Kit::makeSticky()
{
foreach (KitInformation *ki, KitManager::kitInformation()) {
foreach (KitAspect *ki, KitManager::kitInformation()) {
if (hasValue(ki->id()))
setSticky(ki->id(), true);
}
@@ -619,7 +619,7 @@ bool Kit::isMutable(Id id) const
QSet<Id> Kit::supportedPlatforms() const
{
QSet<Id> platforms;
foreach (const KitInformation *ki, KitManager::kitInformation()) {
foreach (const KitAspect *ki, KitManager::kitInformation()) {
const QSet<Id> ip = ki->supportedPlatforms(this);
if (ip.isEmpty())
continue;
@@ -634,7 +634,7 @@ QSet<Id> Kit::supportedPlatforms() const
QSet<Id> Kit::availableFeatures() const
{
QSet<Id> features;
foreach (const KitInformation *ki, KitManager::kitInformation())
foreach (const KitAspect *ki, KitManager::kitInformation())
features |= ki->availableFeatures(this);
return features;
}

2
src/plugins/projectexplorer/kit.h
View File

@@ -142,7 +142,7 @@ private:
const std::unique_ptr<Internal::KitPrivate> d;
friend class KitInformation;
friend class KitAspect;
friend class KitManager;
friend class Internal::KitManagerPrivate;
friend class Internal::KitModel; // needed for setAutoDetected() when cloning kits

2
src/plugins/projectexplorer/kitchooser.cpp
View File

@@ -52,7 +52,7 @@ KitChooser::KitChooser(QWidget *parent) :
{
m_chooser = new QComboBox(this);
m_chooser->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
m_manageButton = new QPushButton(KitConfigWidget::msgManage(), this);
m_manageButton = new QPushButton(KitAspectWidget::msgManage(), this);
auto layout = new QHBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);

14
src/plugins/projectexplorer/kitconfigwidget.cpp
View File

@@ -30,31 +30,31 @@
namespace ProjectExplorer {
KitConfigWidget::KitConfigWidget(Kit *kit, const KitInformation *ki) : m_kit(kit),
KitAspectWidget::KitAspectWidget(Kit *kit, const KitAspect *ki) : m_kit(kit),
m_kitInformation(ki), m_isSticky(kit->isSticky(ki->id()))
{ }
Core::Id KitConfigWidget::kitInformationId() const
Core::Id KitAspectWidget::kitInformationId() const
{
return m_kitInformation->id();
}
bool KitConfigWidget::isMutable() const
bool KitAspectWidget::isMutable() const
{
return m_kit->isMutable(m_kitInformation->id());
}
void KitConfigWidget::setMutable(bool b)
void KitAspectWidget::setMutable(bool b)
{
m_kit->setMutable(m_kitInformation->id(), b);
}
QString KitConfigWidget::msgManage()
QString KitAspectWidget::msgManage()
{
return tr("Manage...");
}
void KitConfigWidget::setPalette(const QPalette &p)
void KitAspectWidget::setPalette(const QPalette &p)
{
if (mainWidget())
mainWidget()->setPalette(p);
@@ -62,7 +62,7 @@ void KitConfigWidget::setPalette(const QPalette &p)
buttonWidget()->setPalette(p);
}
void KitConfigWidget::setStyle(QStyle *s)
void KitAspectWidget::setStyle(QStyle *s)
{
if (mainWidget())
mainWidget()->setStyle(s);

10
src/plugins/projectexplorer/kitconfigwidget.h
View File

@@ -34,18 +34,18 @@
namespace ProjectExplorer {
class Kit;
class KitInformation;
class KitAspect;
// --------------------------------------------------------------------------
// KitConfigWidget
// KitAspectWidget
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT KitConfigWidget : public QObject
class PROJECTEXPLORER_EXPORT KitAspectWidget : public QObject
{
Q_OBJECT
public:
KitConfigWidget(Kit *kit, const KitInformation *ki);
KitAspectWidget(Kit *kit, const KitAspect *ki);
Core::Id kitInformationId() const;
@@ -74,7 +74,7 @@ signals:
protected:
Kit *m_kit;
const KitInformation *m_kitInformation;
const KitAspect *m_kitInformation;
bool m_isSticky;
};

276
src/plugins/projectexplorer/kitinformation.cpp
View File

@@ -50,26 +50,26 @@ const char KITINFORMATION_ID_V2[] = "PE.Profile.ToolChains";
const char KITINFORMATION_ID_V3[] = "PE.Profile.ToolChainsV3";
// --------------------------------------------------------------------------
// SysRootKitInformation:
// SysRootKitAspect:
// --------------------------------------------------------------------------
SysRootKitInformation::SysRootKitInformation()
SysRootKitAspect::SysRootKitAspect()
{
setObjectName(QLatin1String("SysRootInformation"));
setId(SysRootKitInformation::id());
setId(SysRootKitAspect::id());
setPriority(31000);
}
QVariant SysRootKitInformation::defaultValue(const Kit *k) const
QVariant SysRootKitAspect::defaultValue(const Kit *k) const
{
Q_UNUSED(k)
return QString();
}
QList<Task> SysRootKitInformation::validate(const Kit *k) const
QList<Task> SysRootKitAspect::validate(const Kit *k) const
{
QList<Task> result;
const Utils::FileName dir = SysRootKitInformation::sysRoot(k);
const Utils::FileName dir = SysRootKitAspect::sysRoot(k);
if (dir.isEmpty())
return result;
@@ -91,41 +91,41 @@ QList<Task> SysRootKitInformation::validate(const Kit *k) const
return result;
}
KitConfigWidget *SysRootKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *SysRootKitAspect::createConfigWidget(Kit *k) const
{
QTC_ASSERT(k, return nullptr);
return new Internal::SysRootInformationConfigWidget(k, this);
return new Internal::SysRootKitAspectWidget(k, this);
}
KitInformation::ItemList SysRootKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList SysRootKitAspect::toUserOutput(const Kit *k) const
{
return ItemList() << qMakePair(tr("Sys Root"), sysRoot(k).toUserOutput());
}
void SysRootKitInformation::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
void SysRootKitAspect::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
{
QTC_ASSERT(kit, return);
expander->registerFileVariables("SysRoot", tr("Sys Root"), [kit]() -> QString {
return SysRootKitInformation::sysRoot(kit).toString();
return SysRootKitAspect::sysRoot(kit).toString();
});
}
Core::Id SysRootKitInformation::id()
Core::Id SysRootKitAspect::id()
{
return "PE.Profile.SysRoot";
}
Utils::FileName SysRootKitInformation::sysRoot(const Kit *k)
Utils::FileName SysRootKitAspect::sysRoot(const Kit *k)
{
if (!k)
return Utils::FileName();
if (!k->value(SysRootKitInformation::id()).toString().isEmpty())
return Utils::FileName::fromString(k->value(SysRootKitInformation::id()).toString());
if (!k->value(SysRootKitAspect::id()).toString().isEmpty())
return Utils::FileName::fromString(k->value(SysRootKitAspect::id()).toString());
for (ToolChain *tc : ToolChainKitInformation::toolChains(k)) {
for (ToolChain *tc : ToolChainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty())
return Utils::FileName::fromString(tc->sysRoot());
}
@@ -133,12 +133,12 @@ Utils::FileName SysRootKitInformation::sysRoot(const Kit *k)
return Utils::FileName();
}
void SysRootKitInformation::setSysRoot(Kit *k, const Utils::FileName &v)
void SysRootKitAspect::setSysRoot(Kit *k, const Utils::FileName &v)
{
if (!k)
return;
for (ToolChain *tc : ToolChainKitInformation::toolChains(k)) {
for (ToolChain *tc : ToolChainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty()) {
// It's the sysroot from toolchain, don't set it.
if (tc->sysRoot() == v.toString())
@@ -148,21 +148,21 @@ void SysRootKitInformation::setSysRoot(Kit *k, const Utils::FileName &v)
break;
}
}
k->setValue(SysRootKitInformation::id(), v.toString());
k->setValue(SysRootKitAspect::id(), v.toString());
}
// --------------------------------------------------------------------------
// ToolChainKitInformation:
// ToolChainKitAspect:
// --------------------------------------------------------------------------
ToolChainKitInformation::ToolChainKitInformation()
ToolChainKitAspect::ToolChainKitAspect()
{
setObjectName(QLatin1String("ToolChainInformation"));
setId(ToolChainKitInformation::id());
setId(ToolChainKitAspect::id());
setPriority(30000);
connect(KitManager::instance(), &KitManager::kitsLoaded,
this, &ToolChainKitInformation::kitsWereLoaded);
this, &ToolChainKitAspect::kitsWereLoaded);
}
// language id -> tool chain id
@@ -189,19 +189,19 @@ static QVariant defaultToolChainValue()
return result;
}
QVariant ToolChainKitInformation::defaultValue(const Kit *k) const
QVariant ToolChainKitAspect::defaultValue(const Kit *k) const
{
Q_UNUSED(k);
return defaultToolChainValue();
}
QList<Task> ToolChainKitInformation::validate(const Kit *k) const
QList<Task> ToolChainKitAspect::validate(const Kit *k) const
{
QList<Task> result;
const QList<ToolChain*> tcList = toolChains(k);
if (tcList.isEmpty()) {
result << Task(Task::Warning, ToolChainKitInformation::msgNoToolChainInTarget(),
result << Task(Task::Warning, ToolChainKitAspect::msgNoToolChainInTarget(),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM));
} else {
QSet<Abi> targetAbis;
@@ -218,7 +218,7 @@ QList<Task> ToolChainKitInformation::validate(const Kit *k) const
return result;
}
void ToolChainKitInformation::upgrade(Kit *k)
void ToolChainKitAspect::upgrade(Kit *k)
{
QTC_ASSERT(k, return);
@@ -238,7 +238,7 @@ void ToolChainKitInformation::upgrade(Kit *k)
// Used up to 4.1:
newValue.insert(Deprecated::Toolchain::languageId(Deprecated::Toolchain::Cxx), oldValue.toString());
const Core::Id typeId = DeviceTypeKitInformation::deviceTypeId(k);
const Core::Id typeId = DeviceTypeKitAspect::deviceTypeId(k);
if (typeId == Constants::DESKTOP_DEVICE_TYPE) {
// insert default C compiler which did not exist before
newValue.insert(Deprecated::Toolchain::languageId(Deprecated::Toolchain::C),
@@ -253,7 +253,7 @@ void ToolChainKitInformation::upgrade(Kit *k)
// upgrade 4.2 to 4.3 (keep old settings around for now)
{
const QVariant oldValue = k->value(oldIdV2);
const QVariant value = k->value(ToolChainKitInformation::id());
const QVariant value = k->value(ToolChainKitAspect::id());
if (value.isNull() && !oldValue.isNull()) {
QVariantMap newValue = oldValue.toMap();
QVariantMap::iterator it = newValue.find(Deprecated::Toolchain::languageId(Deprecated::Toolchain::C));
@@ -262,14 +262,14 @@ void ToolChainKitInformation::upgrade(Kit *k)
it = newValue.find(Deprecated::Toolchain::languageId(Deprecated::Toolchain::Cxx));
if (it != newValue.end())
newValue.insert(Core::Id(Constants::CXX_LANGUAGE_ID).toString(), it.value());
k->setValue(ToolChainKitInformation::id(), newValue);
k->setSticky(ToolChainKitInformation::id(), k->isSticky(oldIdV2));
k->setValue(ToolChainKitAspect::id(), newValue);
k->setSticky(ToolChainKitAspect::id(), k->isSticky(oldIdV2));
}
}
// upgrade 4.3-temporary-master-state to 4.3:
{
const QVariantMap valueMap = k->value(ToolChainKitInformation::id()).toMap();
const QVariantMap valueMap = k->value(ToolChainKitAspect::id()).toMap();
QVariantMap result;
for (const QString &key : valueMap.keys()) {
const int pos = key.lastIndexOf('.');
@@ -278,11 +278,11 @@ void ToolChainKitInformation::upgrade(Kit *k)
else
result.insert(key, valueMap.value(key));
}
k->setValue(ToolChainKitInformation::id(), result);
k->setValue(ToolChainKitAspect::id(), result);
}
}
void ToolChainKitInformation::fix(Kit *k)
void ToolChainKitAspect::fix(Kit *k)
{
QTC_ASSERT(ToolChainManager::isLoaded(), return);
foreach (const Core::Id& l, ToolChainManager::allLanguages()) {
@@ -303,12 +303,12 @@ static Core::Id findLanguage(const QString &ls)
[lsUpper](Core::Id l) { return lsUpper == l.toString().toUpper(); });
}
void ToolChainKitInformation::setup(Kit *k)
void ToolChainKitAspect::setup(Kit *k)
{
QTC_ASSERT(ToolChainManager::isLoaded(), return);
QTC_ASSERT(k, return);
const QVariantMap value = k->value(ToolChainKitInformation::id()).toMap();
const QVariantMap value = k->value(ToolChainKitAspect::id()).toMap();
for (auto i = value.constBegin(); i != value.constEnd(); ++i) {
Core::Id l = findLanguage(i.key());
@@ -333,32 +333,32 @@ void ToolChainKitInformation::setup(Kit *k)
}
}
KitConfigWidget *ToolChainKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *ToolChainKitAspect::createConfigWidget(Kit *k) const
{
QTC_ASSERT(k, return nullptr);
return new Internal::ToolChainInformationConfigWidget(k, this);
return new Internal::ToolChainKitAspectWidget(k, this);
}
QString ToolChainKitInformation::displayNamePostfix(const Kit *k) const
QString ToolChainKitAspect::displayNamePostfix(const Kit *k) const
{
ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
return tc ? tc->displayName() : QString();
}
KitInformation::ItemList ToolChainKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList ToolChainKitAspect::toUserOutput(const Kit *k) const
{
ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
return ItemList() << qMakePair(tr("Compiler"), tc ? tc->displayName() : tr("None"));
}
void ToolChainKitInformation::addToEnvironment(const Kit *k, Utils::Environment &env) const
void ToolChainKitAspect::addToEnvironment(const Kit *k, Utils::Environment &env) const
{
ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
if (tc)
tc->addToEnvironment(env);
}
void ToolChainKitInformation::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
void ToolChainKitAspect::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
{
QTC_ASSERT(kit, return);
@@ -388,7 +388,7 @@ void ToolChainKitInformation::addToMacroExpander(Kit *kit, Utils::MacroExpander
}
IOutputParser *ToolChainKitInformation::createOutputParser(const Kit *k) const
IOutputParser *ToolChainKitAspect::createOutputParser(const Kit *k) const
{
for (const Core::Id langId : {Constants::CXX_LANGUAGE_ID, Constants::C_LANGUAGE_ID}) {
if (const ToolChain * const tc = toolChain(k, langId))
@@ -397,7 +397,7 @@ IOutputParser *ToolChainKitInformation::createOutputParser(const Kit *k) const
return nullptr;
}
QSet<Core::Id> ToolChainKitInformation::availableFeatures(const Kit *k) const
QSet<Core::Id> ToolChainKitAspect::availableFeatures(const Kit *k) const
{
QSet<Core::Id> result;
for (ToolChain *tc : toolChains(k))
@@ -405,30 +405,30 @@ QSet<Core::Id> ToolChainKitInformation::availableFeatures(const Kit *k) const
return result;
}
Core::Id ToolChainKitInformation::id()
Core::Id ToolChainKitAspect::id()
{
return KITINFORMATION_ID_V3;
}
QByteArray ToolChainKitInformation::toolChainId(const Kit *k, Core::Id language)
QByteArray ToolChainKitAspect::toolChainId(const Kit *k, Core::Id language)
{
QTC_ASSERT(ToolChainManager::isLoaded(), return nullptr);
if (!k)
return QByteArray();
QVariantMap value = k->value(ToolChainKitInformation::id()).toMap();
QVariantMap value = k->value(ToolChainKitAspect::id()).toMap();
return value.value(language.toString(), QByteArray()).toByteArray();
}
ToolChain *ToolChainKitInformation::toolChain(const Kit *k, Core::Id language)
ToolChain *ToolChainKitAspect::toolChain(const Kit *k, Core::Id language)
{
return ToolChainManager::findToolChain(toolChainId(k, language));
}
QList<ToolChain *> ToolChainKitInformation::toolChains(const Kit *k)
QList<ToolChain *> ToolChainKitAspect::toolChains(const Kit *k)
{
QTC_ASSERT(k, return QList<ToolChain *>());
const QVariantMap value = k->value(ToolChainKitInformation::id()).toMap();
const QVariantMap value = k->value(ToolChainKitAspect::id()).toMap();
const QList<ToolChain *> tcList
= Utils::transform(ToolChainManager::allLanguages().toList(),
[&value](Core::Id l) -> ToolChain * {
@@ -437,18 +437,18 @@ QList<ToolChain *> ToolChainKitInformation::toolChains(const Kit *k)
return Utils::filtered(tcList, [](ToolChain *tc) { return tc; });
}
void ToolChainKitInformation::setToolChain(Kit *k, ToolChain *tc)
void ToolChainKitAspect::setToolChain(Kit *k, ToolChain *tc)
{
QTC_ASSERT(tc, return);
QTC_ASSERT(k, return);
QVariantMap result = k->value(ToolChainKitInformation::id()).toMap();
QVariantMap result = k->value(ToolChainKitAspect::id()).toMap();
result.insert(tc->language().toString(), tc->id());
k->setValue(id(), result);
}
/**
* @brief ToolChainKitInformation::setAllToolChainsToMatch
* @brief ToolChainKitAspect::setAllToolChainsToMatch
*
* Set up all toolchains to be similar to the one toolchain provided. Similar ideally means
* that all toolchains use the "same" compiler from the same installation, but we will
@@ -457,7 +457,7 @@ void ToolChainKitInformation::setToolChain(Kit *k, ToolChain *tc)
* @param k The kit to set up
* @param tc The toolchain to match other languages for.
*/
void ToolChainKitInformation::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
{
QTC_ASSERT(tc, return);
QTC_ASSERT(k, return);
@@ -465,7 +465,7 @@ void ToolChainKitInformation::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
const QList<ToolChain *> allTcList = ToolChainManager::toolChains();
QTC_ASSERT(allTcList.contains(tc), return);
QVariantMap result = k->value(ToolChainKitInformation::id()).toMap();
QVariantMap result = k->value(ToolChainKitAspect::id()).toMap();
result.insert(tc->language().toString(), tc->id());
for (Core::Id l : ToolChainManager::allLanguages()) {
@@ -496,17 +496,17 @@ void ToolChainKitInformation::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
k->setValue(id(), result);
}
void ToolChainKitInformation::clearToolChain(Kit *k, Core::Id language)
void ToolChainKitAspect::clearToolChain(Kit *k, Core::Id language)
{
QTC_ASSERT(language.isValid(), return);
QTC_ASSERT(k, return);
QVariantMap result = k->value(ToolChainKitInformation::id()).toMap();
QVariantMap result = k->value(ToolChainKitAspect::id()).toMap();
result.insert(language.toString(), QByteArray());
k->setValue(id(), result);
}
Abi ToolChainKitInformation::targetAbi(const Kit *k)
Abi ToolChainKitAspect::targetAbi(const Kit *k)
{
QList<ToolChain *> tcList = toolChains(k);
// Find the best possible ABI for all the tool chains...
@@ -539,29 +539,29 @@ Abi ToolChainKitInformation::targetAbi(const Kit *k)
return candidates.at(0); // Use basically a random Abi...
}
QString ToolChainKitInformation::msgNoToolChainInTarget()
QString ToolChainKitAspect::msgNoToolChainInTarget()
{
return tr("No compiler set in kit.");
}
void ToolChainKitInformation::kitsWereLoaded()
void ToolChainKitAspect::kitsWereLoaded()
{
foreach (Kit *k, KitManager::kits())
fix(k);
connect(ToolChainManager::instance(), &ToolChainManager::toolChainRemoved,
this, &ToolChainKitInformation::toolChainRemoved);
this, &ToolChainKitAspect::toolChainRemoved);
connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
this, &ToolChainKitInformation::toolChainUpdated);
this, &ToolChainKitAspect::toolChainUpdated);
}
void ToolChainKitInformation::toolChainUpdated(ToolChain *tc)
void ToolChainKitAspect::toolChainUpdated(ToolChain *tc)
{
for (Kit *k : KitManager::kits([tc](const Kit *k) { return toolChain(k, tc->language()) == tc; }))
notifyAboutUpdate(k);
}
void ToolChainKitInformation::toolChainRemoved(ToolChain *tc)
void ToolChainKitAspect::toolChainRemoved(ToolChain *tc)
{
Q_UNUSED(tc);
foreach (Kit *k, KitManager::kits())
@@ -569,35 +569,35 @@ void ToolChainKitInformation::toolChainRemoved(ToolChain *tc)
}
// --------------------------------------------------------------------------
// DeviceTypeKitInformation:
// DeviceTypeKitAspect:
// --------------------------------------------------------------------------
DeviceTypeKitInformation::DeviceTypeKitInformation()
DeviceTypeKitAspect::DeviceTypeKitAspect()
{
setObjectName(QLatin1String("DeviceTypeInformation"));
setId(DeviceTypeKitInformation::id());
setId(DeviceTypeKitAspect::id());
setPriority(33000);
}
QVariant DeviceTypeKitInformation::defaultValue(const Kit *k) const
QVariant DeviceTypeKitAspect::defaultValue(const Kit *k) const
{
Q_UNUSED(k);
return QByteArray(Constants::DESKTOP_DEVICE_TYPE);
}
QList<Task> DeviceTypeKitInformation::validate(const Kit *k) const
QList<Task> DeviceTypeKitAspect::validate(const Kit *k) const
{
Q_UNUSED(k);
return QList<Task>();
}
KitConfigWidget *DeviceTypeKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *DeviceTypeKitAspect::createConfigWidget(Kit *k) const
{
QTC_ASSERT(k, return nullptr);
return new Internal::DeviceTypeInformationConfigWidget(k, this);
return new Internal::DeviceTypeKitAspectWidget(k, this);
}
KitInformation::ItemList DeviceTypeKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList DeviceTypeKitAspect::toUserOutput(const Kit *k) const
{
QTC_ASSERT(k, return {});
Core::Id type = deviceTypeId(k);
@@ -609,57 +609,57 @@ KitInformation::ItemList DeviceTypeKitInformation::toUserOutput(const Kit *k) co
return ItemList() << qMakePair(tr("Device type"), typeDisplayName);
}
const Core::Id DeviceTypeKitInformation::id()
const Core::Id DeviceTypeKitAspect::id()
{
return "PE.Profile.DeviceType";
}
const Core::Id DeviceTypeKitInformation::deviceTypeId(const Kit *k)
const Core::Id DeviceTypeKitAspect::deviceTypeId(const Kit *k)
{
return k ? Core::Id::fromSetting(k->value(DeviceTypeKitInformation::id())) : Core::Id();
return k ? Core::Id::fromSetting(k->value(DeviceTypeKitAspect::id())) : Core::Id();
}
void DeviceTypeKitInformation::setDeviceTypeId(Kit *k, Core::Id type)
void DeviceTypeKitAspect::setDeviceTypeId(Kit *k, Core::Id type)
{
QTC_ASSERT(k, return);
k->setValue(DeviceTypeKitInformation::id(), type.toSetting());
k->setValue(DeviceTypeKitAspect::id(), type.toSetting());
}
Kit::Predicate DeviceTypeKitInformation::deviceTypePredicate(Core::Id type)
Kit::Predicate DeviceTypeKitAspect::deviceTypePredicate(Core::Id type)
{
return [type](const Kit *kit) { return type.isValid() && deviceTypeId(kit) == type; };
}
QSet<Core::Id> DeviceTypeKitInformation::supportedPlatforms(const Kit *k) const
QSet<Core::Id> DeviceTypeKitAspect::supportedPlatforms(const Kit *k) const
{
return {deviceTypeId(k)};
}
QSet<Core::Id> DeviceTypeKitInformation::availableFeatures(const Kit *k) const
QSet<Core::Id> DeviceTypeKitAspect::availableFeatures(const Kit *k) const
{
Core::Id id = DeviceTypeKitInformation::deviceTypeId(k);
Core::Id id = DeviceTypeKitAspect::deviceTypeId(k);
if (id.isValid())
return {id.withPrefix("DeviceType.")};
return QSet<Core::Id>();
}
// --------------------------------------------------------------------------
// DeviceKitInformation:
// DeviceKitAspect:
// --------------------------------------------------------------------------
DeviceKitInformation::DeviceKitInformation()
DeviceKitAspect::DeviceKitAspect()
{
setObjectName(QLatin1String("DeviceInformation"));
setId(DeviceKitInformation::id());
setId(DeviceKitAspect::id());
setPriority(32000);
connect(KitManager::instance(), &KitManager::kitsLoaded,
this, &DeviceKitInformation::kitsWereLoaded);
this, &DeviceKitAspect::kitsWereLoaded);
}
QVariant DeviceKitInformation::defaultValue(const Kit *k) const
QVariant DeviceKitAspect::defaultValue(const Kit *k) const
{
Core::Id type = DeviceTypeKitInformation::deviceTypeId(k);
Core::Id type = DeviceTypeKitAspect::deviceTypeId(k);
// Use default device if that is compatible:
IDevice::ConstPtr dev = DeviceManager::instance()->defaultDevice(type);
if (dev && dev->isCompatibleWith(k))
@@ -674,9 +674,9 @@ QVariant DeviceKitInformation::defaultValue(const Kit *k) const
return QString();
}
QList<Task> DeviceKitInformation::validate(const Kit *k) const
QList<Task> DeviceKitAspect::validate(const Kit *k) const
{
IDevice::ConstPtr dev = DeviceKitInformation::device(k);
IDevice::ConstPtr dev = DeviceKitAspect::device(k);
QList<Task> result;
if (dev.isNull())
result.append(Task(Task::Warning, tr("No device set."),
@@ -688,9 +688,9 @@ QList<Task> DeviceKitInformation::validate(const Kit *k) const
return result;
}
void DeviceKitInformation::fix(Kit *k)
void DeviceKitAspect::fix(Kit *k)
{
IDevice::ConstPtr dev = DeviceKitInformation::device(k);
IDevice::ConstPtr dev = DeviceKitAspect::device(k);
if (!dev.isNull() && !dev->isCompatibleWith(k)) {
qWarning("Device is no longer compatible with kit \"%s\", removing it.",
qPrintable(k->displayName()));
@@ -698,109 +698,109 @@ void DeviceKitInformation::fix(Kit *k)
}
}
void DeviceKitInformation::setup(Kit *k)
void DeviceKitAspect::setup(Kit *k)
{
QTC_ASSERT(DeviceManager::instance()->isLoaded(), return);
IDevice::ConstPtr dev = DeviceKitInformation::device(k);
IDevice::ConstPtr dev = DeviceKitAspect::device(k);
if (!dev.isNull() && dev->isCompatibleWith(k))
return;
setDeviceId(k, Core::Id::fromSetting(defaultValue(k)));
}
KitConfigWidget *DeviceKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *DeviceKitAspect::createConfigWidget(Kit *k) const
{
QTC_ASSERT(k, return nullptr);
return new Internal::DeviceInformationConfigWidget(k, this);
return new Internal::DeviceKitAspectWidget(k, this);
}
QString DeviceKitInformation::displayNamePostfix(const Kit *k) const
QString DeviceKitAspect::displayNamePostfix(const Kit *k) const
{
IDevice::ConstPtr dev = device(k);
return dev.isNull() ? QString() : dev->displayName();
}
KitInformation::ItemList DeviceKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList DeviceKitAspect::toUserOutput(const Kit *k) const
{
IDevice::ConstPtr dev = device(k);
return ItemList() << qMakePair(tr("Device"), dev.isNull() ? tr("Unconfigured") : dev->displayName());
}
void DeviceKitInformation::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
void DeviceKitAspect::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
{
QTC_ASSERT(kit, return);
expander->registerVariable("Device:HostAddress", tr("Host address"),
[kit]() -> QString {
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->sshParameters().host() : QString();
});
expander->registerVariable("Device:SshPort", tr("SSH port"),
[kit]() -> QString {
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? QString::number(device->sshParameters().port()) : QString();
});
expander->registerVariable("Device:UserName", tr("User name"),
[kit]() -> QString {
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->sshParameters().userName() : QString();
});
expander->registerVariable("Device:KeyFile", tr("Private key file"),
[kit]() -> QString {
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->sshParameters().privateKeyFile : QString();
});
expander->registerVariable("Device:Name", tr("Device name"),
[kit]() -> QString {
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->displayName() : QString();
});
}
Core::Id DeviceKitInformation::id()
Core::Id DeviceKitAspect::id()
{
return "PE.Profile.Device";
}
IDevice::ConstPtr DeviceKitInformation::device(const Kit *k)
IDevice::ConstPtr DeviceKitAspect::device(const Kit *k)
{
QTC_ASSERT(DeviceManager::instance()->isLoaded(), return IDevice::ConstPtr());
return DeviceManager::instance()->find(deviceId(k));
}
Core::Id DeviceKitInformation::deviceId(const Kit *k)
Core::Id DeviceKitAspect::deviceId(const Kit *k)
{
return k ? Core::Id::fromSetting(k->value(DeviceKitInformation::id())) : Core::Id();
return k ? Core::Id::fromSetting(k->value(DeviceKitAspect::id())) : Core::Id();
}
void DeviceKitInformation::setDevice(Kit *k, IDevice::ConstPtr dev)
void DeviceKitAspect::setDevice(Kit *k, IDevice::ConstPtr dev)
{
setDeviceId(k, dev ? dev->id() : Core::Id());
}
void DeviceKitInformation::setDeviceId(Kit *k, Core::Id id)
void DeviceKitAspect::setDeviceId(Kit *k, Core::Id id)
{
QTC_ASSERT(k, return);
k->setValue(DeviceKitInformation::id(), id.toSetting());
k->setValue(DeviceKitAspect::id(), id.toSetting());
}
void DeviceKitInformation::kitsWereLoaded()
void DeviceKitAspect::kitsWereLoaded()
{
foreach (Kit *k, KitManager::kits())
fix(k);
DeviceManager *dm = DeviceManager::instance();
connect(dm, &DeviceManager::deviceListReplaced, this, &DeviceKitInformation::devicesChanged);
connect(dm, &DeviceManager::deviceAdded, this, &DeviceKitInformation::devicesChanged);
connect(dm, &DeviceManager::deviceRemoved, this, &DeviceKitInformation::devicesChanged);
connect(dm, &DeviceManager::deviceUpdated, this, &DeviceKitInformation::deviceUpdated);
connect(dm, &DeviceManager::deviceListReplaced, this, &DeviceKitAspect::devicesChanged);
connect(dm, &DeviceManager::deviceAdded, this, &DeviceKitAspect::devicesChanged);
connect(dm, &DeviceManager::deviceRemoved, this, &DeviceKitAspect::devicesChanged);
connect(dm, &DeviceManager::deviceUpdated, this, &DeviceKitAspect::deviceUpdated);
connect(KitManager::instance(), &KitManager::kitUpdated,
this, &DeviceKitInformation::kitUpdated);
this, &DeviceKitAspect::kitUpdated);
connect(KitManager::instance(), &KitManager::unmanagedKitUpdated,
this, &DeviceKitInformation::kitUpdated);
this, &DeviceKitAspect::kitUpdated);
}
void DeviceKitInformation::deviceUpdated(Core::Id id)
void DeviceKitAspect::deviceUpdated(Core::Id id)
{
foreach (Kit *k, KitManager::kits()) {
if (deviceId(k) == id)
@@ -808,40 +808,40 @@ void DeviceKitInformation::deviceUpdated(Core::Id id)
}
}
void DeviceKitInformation::kitUpdated(Kit *k)
void DeviceKitAspect::kitUpdated(Kit *k)
{
setup(k); // Set default device if necessary
}
void DeviceKitInformation::devicesChanged()
void DeviceKitAspect::devicesChanged()
{
foreach (Kit *k, KitManager::kits())
setup(k); // Set default device if necessary
}
// --------------------------------------------------------------------------
// EnvironmentKitInformation:
// EnvironmentKitAspect:
// --------------------------------------------------------------------------
EnvironmentKitInformation::EnvironmentKitInformation()
EnvironmentKitAspect::EnvironmentKitAspect()
{
setObjectName(QLatin1String("EnvironmentKitInformation"));
setId(EnvironmentKitInformation::id());
setObjectName(QLatin1String("EnvironmentKitAspect"));
setId(EnvironmentKitAspect::id());
setPriority(29000);
}
QVariant EnvironmentKitInformation::defaultValue(const Kit *k) const
QVariant EnvironmentKitAspect::defaultValue(const Kit *k) const
{
Q_UNUSED(k)
return QStringList();
}
QList<Task> EnvironmentKitInformation::validate(const Kit *k) const
QList<Task> EnvironmentKitAspect::validate(const Kit *k) const
{
QList<Task> result;
QTC_ASSERT(k, return result);
const QVariant variant = k->value(EnvironmentKitInformation::id());
const QVariant variant = k->value(EnvironmentKitAspect::id());
if (!variant.isNull() && !variant.canConvert(QVariant::List)) {
result.append(Task(Task::Error, tr("The environment setting value is invalid."),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM)));
@@ -849,18 +849,18 @@ QList<Task> EnvironmentKitInformation::validate(const Kit *k) const
return result;
}
void EnvironmentKitInformation::fix(Kit *k)
void EnvironmentKitAspect::fix(Kit *k)
{
QTC_ASSERT(k, return);
const QVariant variant = k->value(EnvironmentKitInformation::id());
const QVariant variant = k->value(EnvironmentKitAspect::id());
if (!variant.isNull() && !variant.canConvert(QVariant::List)) {
qWarning("Kit \"%s\" has a wrong environment value set.", qPrintable(k->displayName()));
setEnvironmentChanges(k, QList<Utils::EnvironmentItem>());
}
}
void EnvironmentKitInformation::addToEnvironment(const Kit *k, Utils::Environment &env) const
void EnvironmentKitAspect::addToEnvironment(const Kit *k, Utils::Environment &env) const
{
const QStringList values
= Utils::transform(Utils::EnvironmentItem::toStringList(environmentChanges(k)),
@@ -868,34 +868,34 @@ void EnvironmentKitInformation::addToEnvironment(const Kit *k, Utils::Environmen
env.modify(Utils::EnvironmentItem::fromStringList(values));
}
KitConfigWidget *EnvironmentKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *EnvironmentKitAspect::createConfigWidget(Kit *k) const
{
QTC_ASSERT(k, return nullptr);
return new Internal::KitEnvironmentConfigWidget(k, this);
return new Internal::EnvironmentKitAspectWidget(k, this);
}
KitInformation::ItemList EnvironmentKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList EnvironmentKitAspect::toUserOutput(const Kit *k) const
{
return { qMakePair(tr("Environment"),
Utils::EnvironmentItem::toStringList(environmentChanges(k)).join("<br>")) };
}
Core::Id EnvironmentKitInformation::id()
Core::Id EnvironmentKitAspect::id()
{
return "PE.Profile.Environment";
}
QList<Utils::EnvironmentItem> EnvironmentKitInformation::environmentChanges(const Kit *k)
QList<Utils::EnvironmentItem> EnvironmentKitAspect::environmentChanges(const Kit *k)
{
if (k)
return Utils::EnvironmentItem::fromStringList(k->value(EnvironmentKitInformation::id()).toStringList());
return Utils::EnvironmentItem::fromStringList(k->value(EnvironmentKitAspect::id()).toStringList());
return QList<Utils::EnvironmentItem>();
}
void EnvironmentKitInformation::setEnvironmentChanges(Kit *k, const QList<Utils::EnvironmentItem> &changes)
void EnvironmentKitAspect::setEnvironmentChanges(Kit *k, const QList<Utils::EnvironmentItem> &changes)
{
if (k)
k->setValue(EnvironmentKitInformation::id(), Utils::EnvironmentItem::toStringList(changes));
k->setValue(EnvironmentKitAspect::id(), Utils::EnvironmentItem::toStringList(changes));
}
} // namespace ProjectExplorer

34
src/plugins/projectexplorer/kitinformation.h
View File

@@ -37,24 +37,24 @@
namespace ProjectExplorer {
class KitConfigWidget;
class KitAspectWidget;
// --------------------------------------------------------------------------
// SysRootInformation:
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT SysRootKitInformation : public KitInformation
class PROJECTEXPLORER_EXPORT SysRootKitAspect : public KitAspect
{
Q_OBJECT
public:
SysRootKitInformation();
SysRootKitAspect();
QVariant defaultValue(const Kit *k) const override;
QList<Task> validate(const Kit *k) const override;
KitConfigWidget *createConfigWidget(Kit *k) const override;
KitAspectWidget *createConfigWidget(Kit *k) const override;
ItemList toUserOutput(const Kit *k) const override;
void addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const override;
@@ -68,12 +68,12 @@ public:
// ToolChainInformation:
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT ToolChainKitInformation : public KitInformation
class PROJECTEXPLORER_EXPORT ToolChainKitAspect : public KitAspect
{
Q_OBJECT
public:
ToolChainKitInformation();
ToolChainKitAspect();
QVariant defaultValue(const Kit *k) const override;
@@ -82,7 +82,7 @@ public:
void fix(Kit *k) override;
void setup(Kit *k) override;
KitConfigWidget *createConfigWidget(Kit *k) const override;
KitAspectWidget *createConfigWidget(Kit *k) const override;
QString displayNamePostfix(const Kit *k) const override;
@@ -114,18 +114,18 @@ private:
// DeviceTypeInformation:
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT DeviceTypeKitInformation : public KitInformation
class PROJECTEXPLORER_EXPORT DeviceTypeKitAspect : public KitAspect
{
Q_OBJECT
public:
DeviceTypeKitInformation();
DeviceTypeKitAspect();
QVariant defaultValue(const Kit *k) const override;
QList<Task> validate(const Kit *k) const override;
KitConfigWidget *createConfigWidget(Kit *k) const override;
KitAspectWidget *createConfigWidget(Kit *k) const override;
ItemList toUserOutput(const Kit *k) const override;
@@ -143,12 +143,12 @@ public:
// DeviceInformation:
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT DeviceKitInformation : public KitInformation
class PROJECTEXPLORER_EXPORT DeviceKitAspect : public KitAspect
{
Q_OBJECT
public:
DeviceKitInformation();
DeviceKitAspect();
QVariant defaultValue(const Kit *k) const override;
@@ -156,7 +156,7 @@ public:
void fix(Kit *k) override;
void setup(Kit *k) override;
KitConfigWidget *createConfigWidget(Kit *k) const override;
KitAspectWidget *createConfigWidget(Kit *k) const override;
QString displayNamePostfix(const Kit *k) const override;
@@ -178,15 +178,15 @@ private:
};
// --------------------------------------------------------------------------
// EnvironmentKitInformation:
// EnvironmentKitAspect:
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT EnvironmentKitInformation : public KitInformation
class PROJECTEXPLORER_EXPORT EnvironmentKitAspect : public KitAspect
{
Q_OBJECT
public:
EnvironmentKitInformation();
EnvironmentKitAspect();
QVariant defaultValue(const Kit *k) const override;
@@ -194,7 +194,7 @@ public:
void fix(Kit *k) override;
void addToEnvironment(const Kit *k, Utils::Environment &env) const override;
KitConfigWidget *createConfigWidget(Kit *k) const override;
KitAspectWidget *createConfigWidget(Kit *k) const override;
ItemList toUserOutput(const Kit *k) const override;

174
src/plugins/projectexplorer/kitinformationconfigwidget.cpp
View File

@@ -61,76 +61,76 @@ namespace ProjectExplorer {
namespace Internal {
// --------------------------------------------------------------------------
// SysRootInformationConfigWidget:
// SysRootKitAspectWidget:
// --------------------------------------------------------------------------
SysRootInformationConfigWidget::SysRootInformationConfigWidget(Kit *k, const KitInformation *ki) :
KitConfigWidget(k, ki)
SysRootKitAspectWidget::SysRootKitAspectWidget(Kit *k, const KitAspect *ki) :
KitAspectWidget(k, ki)
{
m_chooser = new Utils::PathChooser;
m_chooser->setExpectedKind(Utils::PathChooser::ExistingDirectory);
m_chooser->setHistoryCompleter(QLatin1String("PE.SysRoot.History"));
m_chooser->setFileName(SysRootKitInformation::sysRoot(k));
m_chooser->setFileName(SysRootKitAspect::sysRoot(k));
connect(m_chooser, &Utils::PathChooser::pathChanged,
this, &SysRootInformationConfigWidget::pathWasChanged);
this, &SysRootKitAspectWidget::pathWasChanged);
}
SysRootInformationConfigWidget::~SysRootInformationConfigWidget()
SysRootKitAspectWidget::~SysRootKitAspectWidget()
{
delete m_chooser;
}
QString SysRootInformationConfigWidget::displayName() const
QString SysRootKitAspectWidget::displayName() const
{
return tr("Sysroot");
}
QString SysRootInformationConfigWidget::toolTip() const
QString SysRootKitAspectWidget::toolTip() const
{
return tr("The root directory of the system image to use.<br>"
"Leave empty when building for the desktop.");
}
void SysRootInformationConfigWidget::setPalette(const QPalette &p)
void SysRootKitAspectWidget::setPalette(const QPalette &p)
{
KitConfigWidget::setPalette(p);
KitAspectWidget::setPalette(p);
m_chooser->setOkColor(p.color(QPalette::Active, QPalette::Text));
}
void SysRootInformationConfigWidget::refresh()
void SysRootKitAspectWidget::refresh()
{
if (!m_ignoreChange)
m_chooser->setFileName(SysRootKitInformation::sysRoot(m_kit));
m_chooser->setFileName(SysRootKitAspect::sysRoot(m_kit));
}
void SysRootInformationConfigWidget::makeReadOnly()
void SysRootKitAspectWidget::makeReadOnly()
{
m_chooser->setReadOnly(true);
}
QWidget *SysRootInformationConfigWidget::mainWidget() const
QWidget *SysRootKitAspectWidget::mainWidget() const
{
return m_chooser->lineEdit();
}
QWidget *SysRootInformationConfigWidget::buttonWidget() const
QWidget *SysRootKitAspectWidget::buttonWidget() const
{
return m_chooser->buttonAtIndex(0);
}
void SysRootInformationConfigWidget::pathWasChanged()
void SysRootKitAspectWidget::pathWasChanged()
{
m_ignoreChange = true;
SysRootKitInformation::setSysRoot(m_kit, m_chooser->fileName());
SysRootKitAspect::setSysRoot(m_kit, m_chooser->fileName());
m_ignoreChange = false;
}
// --------------------------------------------------------------------------
// ToolChainInformationConfigWidget:
// ToolChainKitAspectWidget:
// --------------------------------------------------------------------------
ToolChainInformationConfigWidget::ToolChainInformationConfigWidget(Kit *k, const KitInformation *ki) :
KitConfigWidget(k, ki)
ToolChainKitAspectWidget::ToolChainKitAspectWidget(Kit *k, const KitAspect *ki) :
KitAspectWidget(k, ki)
{
m_mainWidget = new QWidget;
m_mainWidget->setContentsMargins(0, 0, 0, 0);
@@ -163,31 +163,31 @@ ToolChainInformationConfigWidget::ToolChainInformationConfigWidget(Kit *k, const
refresh();
m_manageButton = new QPushButton(KitConfigWidget::msgManage());
m_manageButton = new QPushButton(KitAspectWidget::msgManage());
m_manageButton->setContentsMargins(0, 0, 0, 0);
connect(m_manageButton, &QAbstractButton::clicked,
this, &ToolChainInformationConfigWidget::manageToolChains);
this, &ToolChainKitAspectWidget::manageToolChains);
}
ToolChainInformationConfigWidget::~ToolChainInformationConfigWidget()
ToolChainKitAspectWidget::~ToolChainKitAspectWidget()
{
delete m_mainWidget;
delete m_manageButton;
}
QString ToolChainInformationConfigWidget::displayName() const
QString ToolChainKitAspectWidget::displayName() const
{
return tr("Compiler");
}
QString ToolChainInformationConfigWidget::toolTip() const
QString ToolChainKitAspectWidget::toolTip() const
{
return tr("The compiler to use for building.<br>"
"Make sure the compiler will produce binaries compatible with the target device, "
"Qt version and other libraries used.");
}
void ToolChainInformationConfigWidget::refresh()
void ToolChainKitAspectWidget::refresh()
{
m_ignoreChanges = true;
@@ -203,13 +203,13 @@ void ToolChainInformationConfigWidget::refresh()
cb->addItem(tc->displayName(), tc->id());
cb->setEnabled(cb->count() > 1 && !m_isReadOnly);
const int index = indexOf(cb, ToolChainKitInformation::toolChain(m_kit, l));
const int index = indexOf(cb, ToolChainKitAspect::toolChain(m_kit, l));
cb->setCurrentIndex(index);
}
m_ignoreChanges = false;
}
void ToolChainInformationConfigWidget::makeReadOnly()
void ToolChainKitAspectWidget::makeReadOnly()
{
m_isReadOnly = true;
foreach (Core::Id l, m_languageComboboxMap.keys()) {
@@ -217,22 +217,22 @@ void ToolChainInformationConfigWidget::makeReadOnly()
}
}
QWidget *ToolChainInformationConfigWidget::mainWidget() const
QWidget *ToolChainKitAspectWidget::mainWidget() const
{
return m_mainWidget;
}
QWidget *ToolChainInformationConfigWidget::buttonWidget() const
QWidget *ToolChainKitAspectWidget::buttonWidget() const
{
return m_manageButton;
}
void ToolChainInformationConfigWidget::manageToolChains()
void ToolChainKitAspectWidget::manageToolChains()
{
ICore::showOptionsDialog(Constants::TOOLCHAIN_SETTINGS_PAGE_ID, buttonWidget());
}
void ToolChainInformationConfigWidget::currentToolChainChanged(Id language, int idx)
void ToolChainKitAspectWidget::currentToolChainChanged(Id language, int idx)
{
if (m_ignoreChanges || idx < 0)
return;
@@ -241,12 +241,12 @@ void ToolChainInformationConfigWidget::currentToolChainChanged(Id language, int
ToolChain *tc = ToolChainManager::findToolChain(id);
QTC_ASSERT(!tc || tc->language() == language, return);
if (tc)
ToolChainKitInformation::setToolChain(m_kit, tc);
ToolChainKitAspect::setToolChain(m_kit, tc);
else
ToolChainKitInformation::clearToolChain(m_kit, language);
ToolChainKitAspect::clearToolChain(m_kit, language);
}
int ToolChainInformationConfigWidget::indexOf(QComboBox *cb, const ToolChain *tc)
int ToolChainKitAspectWidget::indexOf(QComboBox *cb, const ToolChain *tc)
{
const QByteArray id = tc ? tc->id() : QByteArray();
for (int i = 0; i < cb->count(); ++i) {
@@ -257,11 +257,11 @@ int ToolChainInformationConfigWidget::indexOf(QComboBox *cb, const ToolChain *tc
}
// --------------------------------------------------------------------------
// DeviceTypeInformationConfigWidget:
// DeviceTypeKitAspectWidget:
// --------------------------------------------------------------------------
DeviceTypeInformationConfigWidget::DeviceTypeInformationConfigWidget(Kit *workingCopy, const KitInformation *ki) :
KitConfigWidget(workingCopy, ki), m_comboBox(new QComboBox)
DeviceTypeKitAspectWidget::DeviceTypeKitAspectWidget(Kit *workingCopy, const KitAspect *ki) :
KitAspectWidget(workingCopy, ki), m_comboBox(new QComboBox)
{
for (IDeviceFactory *factory : IDeviceFactory::allDeviceFactories())
m_comboBox->addItem(factory->displayName(), factory->deviceType().toSetting());
@@ -270,32 +270,32 @@ DeviceTypeInformationConfigWidget::DeviceTypeInformationConfigWidget(Kit *workin
refresh();
connect(m_comboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &DeviceTypeInformationConfigWidget::currentTypeChanged);
this, &DeviceTypeKitAspectWidget::currentTypeChanged);
}
DeviceTypeInformationConfigWidget::~DeviceTypeInformationConfigWidget()
DeviceTypeKitAspectWidget::~DeviceTypeKitAspectWidget()
{
delete m_comboBox;
}
QWidget *DeviceTypeInformationConfigWidget::mainWidget() const
QWidget *DeviceTypeKitAspectWidget::mainWidget() const
{
return m_comboBox;
}
QString DeviceTypeInformationConfigWidget::displayName() const
QString DeviceTypeKitAspectWidget::displayName() const
{
return tr("Device type");
}
QString DeviceTypeInformationConfigWidget::toolTip() const
QString DeviceTypeKitAspectWidget::toolTip() const
{
return tr("The type of device to run applications on.");
}
void DeviceTypeInformationConfigWidget::refresh()
void DeviceTypeKitAspectWidget::refresh()
{
Id devType = DeviceTypeKitInformation::deviceTypeId(m_kit);
Id devType = DeviceTypeKitAspect::deviceTypeId(m_kit);
if (!devType.isValid())
m_comboBox->setCurrentIndex(-1);
for (int i = 0; i < m_comboBox->count(); ++i) {
@@ -306,112 +306,112 @@ void DeviceTypeInformationConfigWidget::refresh()
}
}
void DeviceTypeInformationConfigWidget::makeReadOnly()
void DeviceTypeKitAspectWidget::makeReadOnly()
{
m_comboBox->setEnabled(false);
}
void DeviceTypeInformationConfigWidget::currentTypeChanged(int idx)
void DeviceTypeKitAspectWidget::currentTypeChanged(int idx)
{
Id type = idx < 0 ? Id() : Id::fromSetting(m_comboBox->itemData(idx));
DeviceTypeKitInformation::setDeviceTypeId(m_kit, type);
DeviceTypeKitAspect::setDeviceTypeId(m_kit, type);
}
// --------------------------------------------------------------------------
// DeviceInformationConfigWidget:
// DeviceKitAspectWidget:
// --------------------------------------------------------------------------
DeviceInformationConfigWidget::DeviceInformationConfigWidget(Kit *workingCopy, const KitInformation *ki) :
KitConfigWidget(workingCopy, ki),
DeviceKitAspectWidget::DeviceKitAspectWidget(Kit *workingCopy, const KitAspect *ki) :
KitAspectWidget(workingCopy, ki),
m_comboBox(new QComboBox),
m_model(new DeviceManagerModel(DeviceManager::instance()))
{
m_comboBox->setSizePolicy(QSizePolicy::Ignored, m_comboBox->sizePolicy().verticalPolicy());
m_comboBox->setModel(m_model);
m_manageButton = new QPushButton(KitConfigWidget::msgManage());
m_manageButton = new QPushButton(KitAspectWidget::msgManage());
refresh();
m_comboBox->setToolTip(toolTip());
connect(m_model, &QAbstractItemModel::modelAboutToBeReset,
this, &DeviceInformationConfigWidget::modelAboutToReset);
this, &DeviceKitAspectWidget::modelAboutToReset);
connect(m_model, &QAbstractItemModel::modelReset,
this, &DeviceInformationConfigWidget::modelReset);
this, &DeviceKitAspectWidget::modelReset);
connect(m_comboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &DeviceInformationConfigWidget::currentDeviceChanged);
this, &DeviceKitAspectWidget::currentDeviceChanged);
connect(m_manageButton, &QAbstractButton::clicked,
this, &DeviceInformationConfigWidget::manageDevices);
this, &DeviceKitAspectWidget::manageDevices);
}
DeviceInformationConfigWidget::~DeviceInformationConfigWidget()
DeviceKitAspectWidget::~DeviceKitAspectWidget()
{
delete m_comboBox;
delete m_model;
delete m_manageButton;
}
QWidget *DeviceInformationConfigWidget::mainWidget() const
QWidget *DeviceKitAspectWidget::mainWidget() const
{
return m_comboBox;
}
QString DeviceInformationConfigWidget::displayName() const
QString DeviceKitAspectWidget::displayName() const
{
return tr("Device");
}
QString DeviceInformationConfigWidget::toolTip() const
QString DeviceKitAspectWidget::toolTip() const
{
return tr("The device to run the applications on.");
}
void DeviceInformationConfigWidget::refresh()
void DeviceKitAspectWidget::refresh()
{
m_model->setTypeFilter(DeviceTypeKitInformation::deviceTypeId(m_kit));
m_comboBox->setCurrentIndex(m_model->indexOf(DeviceKitInformation::device(m_kit)));
m_model->setTypeFilter(DeviceTypeKitAspect::deviceTypeId(m_kit));
m_comboBox->setCurrentIndex(m_model->indexOf(DeviceKitAspect::device(m_kit)));
}
void DeviceInformationConfigWidget::makeReadOnly()
void DeviceKitAspectWidget::makeReadOnly()
{
m_comboBox->setEnabled(false);
}
QWidget *DeviceInformationConfigWidget::buttonWidget() const
QWidget *DeviceKitAspectWidget::buttonWidget() const
{
return m_manageButton;
}
void DeviceInformationConfigWidget::manageDevices()
void DeviceKitAspectWidget::manageDevices()
{
ICore::showOptionsDialog(Constants::DEVICE_SETTINGS_PAGE_ID, buttonWidget());
}
void DeviceInformationConfigWidget::modelAboutToReset()
void DeviceKitAspectWidget::modelAboutToReset()
{
m_selectedId = m_model->deviceId(m_comboBox->currentIndex());
m_ignoreChange = true;
}
void DeviceInformationConfigWidget::modelReset()
void DeviceKitAspectWidget::modelReset()
{
m_comboBox->setCurrentIndex(m_model->indexForId(m_selectedId));
m_ignoreChange = false;
}
void DeviceInformationConfigWidget::currentDeviceChanged()
void DeviceKitAspectWidget::currentDeviceChanged()
{
if (m_ignoreChange)
return;
DeviceKitInformation::setDeviceId(m_kit, m_model->deviceId(m_comboBox->currentIndex()));
DeviceKitAspect::setDeviceId(m_kit, m_model->deviceId(m_comboBox->currentIndex()));
}
// --------------------------------------------------------------------
// KitEnvironmentConfigWidget:
// EnvironmentKitAspectWidget:
// --------------------------------------------------------------------
KitEnvironmentConfigWidget::KitEnvironmentConfigWidget(Kit *workingCopy, const KitInformation *ki) :
KitConfigWidget(workingCopy, ki),
EnvironmentKitAspectWidget::EnvironmentKitAspectWidget(Kit *workingCopy, const KitAspect *ki) :
KitAspectWidget(workingCopy, ki),
m_summaryLabel(new QLabel),
m_manageButton(new QPushButton),
m_mainWidget(new QWidget)
@@ -427,25 +427,25 @@ KitEnvironmentConfigWidget::KitEnvironmentConfigWidget(Kit *workingCopy, const K
refresh();
m_manageButton->setText(tr("Change..."));
connect(m_manageButton, &QAbstractButton::clicked,
this, &KitEnvironmentConfigWidget::editEnvironmentChanges);
this, &EnvironmentKitAspectWidget::editEnvironmentChanges);
}
QWidget *KitEnvironmentConfigWidget::mainWidget() const
QWidget *EnvironmentKitAspectWidget::mainWidget() const
{
return m_mainWidget;
}
QString KitEnvironmentConfigWidget::displayName() const
QString EnvironmentKitAspectWidget::displayName() const
{
return tr("Environment");
}
QString KitEnvironmentConfigWidget::toolTip() const
QString EnvironmentKitAspectWidget::toolTip() const
{
return tr("Additional build environment settings when using this kit.");
}
void KitEnvironmentConfigWidget::refresh()
void EnvironmentKitAspectWidget::refresh()
{
const QList<Utils::EnvironmentItem> changes = currentEnvironment();
QString shortSummary = Utils::EnvironmentItem::toStringList(changes).join(QLatin1String("; "));
@@ -454,14 +454,14 @@ void KitEnvironmentConfigWidget::refresh()
m_summaryLabel->setText(shortSummary.isEmpty() ? tr("No changes to apply.") : shortSummary);
}
void KitEnvironmentConfigWidget::makeReadOnly()
void EnvironmentKitAspectWidget::makeReadOnly()
{
m_manageButton->setEnabled(false);
}
QList<Utils::EnvironmentItem> KitEnvironmentConfigWidget::currentEnvironment() const
QList<Utils::EnvironmentItem> EnvironmentKitAspectWidget::currentEnvironment() const
{
QList<Utils::EnvironmentItem> changes = EnvironmentKitInformation::environmentChanges(m_kit);
QList<Utils::EnvironmentItem> changes = EnvironmentKitAspect::environmentChanges(m_kit);
if (Utils::HostOsInfo::isWindowsHost()) {
const Utils::EnvironmentItem forceMSVCEnglishItem("VSLANG", "1033");
@@ -476,7 +476,7 @@ QList<Utils::EnvironmentItem> KitEnvironmentConfigWidget::currentEnvironment() c
return changes;
}
void KitEnvironmentConfigWidget::editEnvironmentChanges()
void EnvironmentKitAspectWidget::editEnvironmentChanges()
{
bool ok;
Utils::MacroExpander *expander = m_kit->macroExpander();
@@ -498,15 +498,15 @@ void KitEnvironmentConfigWidget::editEnvironmentChanges()
changes.append(forceMSVCEnglishItem);
}
EnvironmentKitInformation::setEnvironmentChanges(m_kit, changes);
EnvironmentKitAspect::setEnvironmentChanges(m_kit, changes);
}
QWidget *KitEnvironmentConfigWidget::buttonWidget() const
QWidget *EnvironmentKitAspectWidget::buttonWidget() const
{
return m_manageButton;
}
void KitEnvironmentConfigWidget::initMSVCOutputSwitch(QVBoxLayout *layout)
void EnvironmentKitAspectWidget::initMSVCOutputSwitch(QVBoxLayout *layout)
{
m_vslangCheckbox = new QCheckBox(tr("Force UTF-8 MSVC compiler output"));
layout->addWidget(m_vslangCheckbox);
@@ -515,13 +515,13 @@ void KitEnvironmentConfigWidget::initMSVCOutputSwitch(QVBoxLayout *layout)
"compiler)."));
connect(m_vslangCheckbox, &QCheckBox::toggled, this, [this](bool checked) {
QList<Utils::EnvironmentItem> changes
= EnvironmentKitInformation::environmentChanges(m_kit);
= EnvironmentKitAspect::environmentChanges(m_kit);
const Utils::EnvironmentItem forceMSVCEnglishItem("VSLANG", "1033");
if (!checked && changes.indexOf(forceMSVCEnglishItem) >= 0)
changes.removeAll(forceMSVCEnglishItem);
if (checked && changes.indexOf(forceMSVCEnglishItem) < 0)
changes.append(forceMSVCEnglishItem);
EnvironmentKitInformation::setEnvironmentChanges(m_kit, changes);
EnvironmentKitAspect::setEnvironmentChanges(m_kit, changes);
});
}

36
src/plugins/projectexplorer/kitinformationconfigwidget.h
View File

@@ -50,16 +50,16 @@ class DeviceManagerModel;
namespace Internal {
// --------------------------------------------------------------------------
// SysRootInformationConfigWidget:
// SysRootKitAspectWidget:
// --------------------------------------------------------------------------
class SysRootInformationConfigWidget : public KitConfigWidget
class SysRootKitAspectWidget : public KitAspectWidget
{
Q_OBJECT
public:
SysRootInformationConfigWidget(Kit *k, const KitInformation *ki);
~SysRootInformationConfigWidget() override;
SysRootKitAspectWidget(Kit *k, const KitAspect *ki);
~SysRootKitAspectWidget() override;
QString displayName() const override;
void refresh() override;
@@ -78,16 +78,16 @@ private:
};
// --------------------------------------------------------------------------
// ToolChainInformationConfigWidget:
// ToolChainKitAspectWidget:
// --------------------------------------------------------------------------
class ToolChainInformationConfigWidget : public KitConfigWidget
class ToolChainKitAspectWidget : public KitAspectWidget
{
Q_OBJECT
public:
ToolChainInformationConfigWidget(Kit *k, const KitInformation *ki);
~ToolChainInformationConfigWidget() override;
ToolChainKitAspectWidget(Kit *k, const KitAspect *ki);
~ToolChainKitAspectWidget() override;
QString displayName() const override;
void refresh() override;
@@ -110,16 +110,16 @@ private:
};
// --------------------------------------------------------------------------
// DeviceTypeInformationConfigWidget:
// DeviceTypeKitAspectWidget:
// --------------------------------------------------------------------------
class DeviceTypeInformationConfigWidget : public KitConfigWidget
class DeviceTypeKitAspectWidget : public KitAspectWidget
{
Q_OBJECT
public:
DeviceTypeInformationConfigWidget(Kit *workingCopy, const KitInformation *ki);
~DeviceTypeInformationConfigWidget() override;
DeviceTypeKitAspectWidget(Kit *workingCopy, const KitAspect *ki);
~DeviceTypeKitAspectWidget() override;
QWidget *mainWidget() const override;
QString displayName() const override;
@@ -134,16 +134,16 @@ private:
};
// --------------------------------------------------------------------------
// DeviceInformationConfigWidget:
// DeviceKitAspectWidget:
// --------------------------------------------------------------------------
class DeviceInformationConfigWidget : public KitConfigWidget
class DeviceKitAspectWidget : public KitAspectWidget
{
Q_OBJECT
public:
DeviceInformationConfigWidget(Kit *workingCopy, const KitInformation *ki);
~DeviceInformationConfigWidget() override;
DeviceKitAspectWidget(Kit *workingCopy, const KitAspect *ki);
~DeviceKitAspectWidget() override;
QWidget *mainWidget() const override;
QWidget *buttonWidget() const override;
@@ -166,12 +166,12 @@ private:
Core::Id m_selectedId;
};
class KitEnvironmentConfigWidget : public KitConfigWidget
class EnvironmentKitAspectWidget : public KitAspectWidget
{
Q_OBJECT
public:
KitEnvironmentConfigWidget(Kit *workingCopy, const KitInformation *ki);
EnvironmentKitAspectWidget(Kit *workingCopy, const KitAspect *ki);
QWidget *mainWidget() const override;
QWidget *buttonWidget() const override;

32
src/plugins/projectexplorer/kitmanager.cpp
View File

@@ -69,7 +69,7 @@ class KitManagerPrivate
public:
Kit *m_defaultKit = nullptr;
bool m_initialized = false;
std::vector<std::unique_ptr<KitInformation>> m_informationList;
std::vector<std::unique_ptr<KitAspect>> m_informationList;
std::vector<std::unique_ptr<Kit>> m_kitList;
std::unique_ptr<PersistentSettingsWriter> m_writer;
};
@@ -151,7 +151,7 @@ void KitManager::restoreKits()
Kit *ptr = i->get();
// Overwrite settings that the SDK sets to those values:
foreach (const KitInformation *ki, KitManager::kitInformation()) {
foreach (const KitAspect *ki, KitManager::kitInformation()) {
// Copy sticky settings over:
if (ptr->isSticky(ki->id())) {
ptr->setValue(ki->id(), toStore->value(ki->id()));
@@ -227,7 +227,7 @@ bool KitManager::isLoaded()
return d->m_initialized;
}
void KitManager::registerKitInformation(std::unique_ptr<KitInformation> &&ki)
void KitManager::registerKitAspect(std::unique_ptr<KitAspect> &&ki)
{
QTC_ASSERT(ki->id().isValid(), return );
QTC_ASSERT(!Utils::contains(d->m_informationList, ki.get()), return );
@@ -235,8 +235,8 @@ void KitManager::registerKitInformation(std::unique_ptr<KitInformation> &&ki)
auto it = std::lower_bound(std::begin(d->m_informationList),
std::end(d->m_informationList),
ki,
[](const std::unique_ptr<KitInformation> &a,
const std::unique_ptr<KitInformation> &b) {
[](const std::unique_ptr<KitAspect> &a,
const std::unique_ptr<KitAspect> &b) {
return a->priority() > b->priority();
});
d->m_informationList.insert(it, std::move(ki));
@@ -364,7 +364,7 @@ Kit *KitManager::defaultKit()
return d->m_defaultKit;
}
QList<KitInformation *> KitManager::kitInformation()
QList<KitAspect *> KitManager::kitInformation()
{
return Utils::toRawPointer<QList>(d->m_informationList);
}
@@ -372,7 +372,7 @@ QList<KitInformation *> KitManager::kitInformation()
KitManagerConfigWidget *KitManager::createConfigWidget(Kit *k)
{
auto *result = new KitManagerConfigWidget(k);
foreach (KitInformation *ki, kitInformation())
foreach (KitAspect *ki, kitInformation())
result->addConfigWidget(ki->createConfigWidget(result->workingCopy()));
result->updateVisibility();
@@ -442,7 +442,7 @@ void KitManager::completeKit(Kit *k)
{
QTC_ASSERT(k, return);
KitGuard g(k);
for (const std::unique_ptr<KitInformation> &ki : d->m_informationList) {
for (const std::unique_ptr<KitAspect> &ki : d->m_informationList) {
ki->upgrade(k);
if (!k->hasValue(ki->id()))
k->setValue(ki->id(), ki->defaultValue(k));
@@ -452,46 +452,46 @@ void KitManager::completeKit(Kit *k)
}
// --------------------------------------------------------------------
// KitInformation:
// KitAspect:
// --------------------------------------------------------------------
void KitInformation::addToEnvironment(const Kit *k, Environment &env) const
void KitAspect::addToEnvironment(const Kit *k, Environment &env) const
{
Q_UNUSED(k);
Q_UNUSED(env);
}
IOutputParser *KitInformation::createOutputParser(const Kit *k) const
IOutputParser *KitAspect::createOutputParser(const Kit *k) const
{
Q_UNUSED(k);
return nullptr;
}
QString KitInformation::displayNamePostfix(const Kit *k) const
QString KitAspect::displayNamePostfix(const Kit *k) const
{
Q_UNUSED(k);
return QString();
}
QSet<Id> KitInformation::supportedPlatforms(const Kit *k) const
QSet<Id> KitAspect::supportedPlatforms(const Kit *k) const
{
Q_UNUSED(k);
return QSet<Id>();
}
QSet<Id> KitInformation::availableFeatures(const Kit *k) const
QSet<Id> KitAspect::availableFeatures(const Kit *k) const
{
Q_UNUSED(k);
return QSet<Id>();
}
void KitInformation::addToMacroExpander(Kit *k, MacroExpander *expander) const
void KitAspect::addToMacroExpander(Kit *k, MacroExpander *expander) const
{
Q_UNUSED(k);
Q_UNUSED(expander);
}
void KitInformation::notifyAboutUpdate(Kit *k)
void KitAspect::notifyAboutUpdate(Kit *k)
{
if (k)
k->kitUpdated();

20
src/plugins/projectexplorer/kitmanager.h
View File

@@ -46,7 +46,7 @@ class MacroExpander;
namespace ProjectExplorer {
class Task;
class IOutputParser;
class KitConfigWidget;
class KitAspectWidget;
class KitManager;
namespace Internal {
@@ -55,13 +55,13 @@ class KitModel;
} // namespace Internal
/**
* @brief The KitInformation class
* @brief The KitAspect class
*
* One piece of information stored in the kit.
*
* This needs to get registered with the \a KitManager.
*/
class PROJECTEXPLORER_EXPORT KitInformation : public QObject
class PROJECTEXPLORER_EXPORT KitAspect : public QObject
{
Q_OBJECT
@@ -85,7 +85,7 @@ public:
virtual ItemList toUserOutput(const Kit *) const = 0;
virtual KitConfigWidget *createConfigWidget(Kit *) const = 0;
virtual KitAspectWidget *createConfigWidget(Kit *) const = 0;
virtual void addToEnvironment(const Kit *k, Utils::Environment &env) const;
virtual IOutputParser *createOutputParser(const Kit *k) const;
@@ -120,7 +120,7 @@ public:
static Kit *kit(Core::Id id);
static Kit *defaultKit();
static QList<KitInformation *> kitInformation();
static QList<KitAspect *> kitInformation();
static Internal::KitManagerConfigWidget *createConfigWidget(Kit *k);
@@ -129,8 +129,8 @@ public:
static void setDefaultKit(Kit *k);
template<typename KI, typename... Args>
static void registerKitInformation(Args&&... args) {
registerKitInformation(std::make_unique<KI>(std::forward<Args>(args)...));
static void registerKitAspect(Args&&... args) {
registerKitAspect(std::make_unique<KI>(std::forward<Args>(args)...));
}
static QSet<Core::Id> supportedPlatforms();
@@ -159,10 +159,10 @@ signals:
private:
explicit KitManager(QObject *parent = nullptr);
static void registerKitInformation(std::unique_ptr<KitInformation> &&ki);
static void registerKitAspect(std::unique_ptr<KitAspect> &&ki);
// Make sure the this is only called after all
// KitInformation are registered!
// KitAspects are registered!
void restoreKits();
class KitList
{
@@ -178,7 +178,7 @@ private:
friend class ProjectExplorerPlugin; // for constructor
friend class Kit;
friend class Internal::KitModel;
friend class KitInformation; // for notifyAbutUpdate
friend class KitAspect; // for notifyAbutUpdate
};
} // namespace ProjectExplorer

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

@@ -211,7 +211,7 @@ QString KitManagerConfigWidget::validityMessage() const
return m_modifiedKit->toHtml(tmp);
}
void KitManagerConfigWidget::addConfigWidget(KitConfigWidget *widget)
void KitManagerConfigWidget::addConfigWidget(KitAspectWidget *widget)
{
QTC_ASSERT(widget, return);
QTC_ASSERT(!m_widgets.contains(widget), return);
@@ -249,7 +249,7 @@ void KitManagerConfigWidget::updateVisibility()
{
int count = m_widgets.count();
for (int i = 0; i < count; ++i) {
KitConfigWidget *widget = m_widgets.at(i);
KitAspectWidget *widget = m_widgets.at(i);
bool visible = widget->visibleInKit();
widget->mainWidget()->setVisible(visible);
if (widget->buttonWidget())
@@ -265,7 +265,7 @@ void KitManagerConfigWidget::setHasUniqueName(bool unique)
void KitManagerConfigWidget::makeStickySubWidgetsReadOnly()
{
foreach (KitConfigWidget *w, m_widgets) {
foreach (KitAspectWidget *w, m_widgets) {
if (w->isSticky())
w->makeReadOnly();
}
@@ -348,7 +348,7 @@ void KitManagerConfigWidget::workingCopyWasUpdated(Kit *k)
k->fix();
m_fixingKit = false;
foreach (KitConfigWidget *w, m_widgets)
foreach (KitAspectWidget *w, m_widgets)
w->refresh();
m_cachedDisplayName.clear();
@@ -376,7 +376,7 @@ void KitManagerConfigWidget::kitWasUpdated(Kit *k)
void KitManagerConfigWidget::showEvent(QShowEvent *event)
{
Q_UNUSED(event);
foreach (KitConfigWidget *widget, m_widgets)
foreach (KitAspectWidget *widget, m_widgets)
widget->refresh();
}

4
src/plugins/projectexplorer/kitmanagerconfigwidget.h
View File

@@ -60,7 +60,7 @@ public:
bool isValid() const;
bool hasWarning() const;
QString validityMessage() const;
void addConfigWidget(KitConfigWidget *widget);
void addConfigWidget(KitAspectWidget *widget);
void makeStickySubWidgetsReadOnly();
Kit *workingCopy() const;
@@ -97,7 +97,7 @@ private:
QToolButton *m_iconButton;
QLineEdit *m_nameEdit;
QLineEdit *m_fileSystemFriendlyNameLineEdit;
QList<KitConfigWidget *> m_widgets;
QList<KitAspectWidget *> m_widgets;
QList<QLabel *> m_labels;
Kit *m_kit;
std::unique_ptr<Kit> m_modifiedKit;

2
src/plugins/projectexplorer/makestep.cpp
View File

@@ -126,7 +126,7 @@ QString MakeStep::defaultDisplayName()
static const QList<ToolChain *> preferredToolChains(const Kit *kit)
{
QList<ToolChain *> tcs = ToolChainKitInformation::toolChains(kit);
QList<ToolChain *> tcs = ToolChainKitAspect::toolChains(kit);
// prefer CXX, then C, then others
Utils::sort(tcs, [](ToolChain *tcA, ToolChain *tcB) {
if (tcA->language() == tcB->language())

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

@@ -579,7 +579,7 @@ KitAreaWidget::~KitAreaWidget()
void KitAreaWidget::setKit(Kit *k)
{
foreach (KitConfigWidget *w, m_widgets)
foreach (KitAspectWidget *w, m_widgets)
delete(w);
m_widgets.clear();
@@ -591,9 +591,9 @@ void KitAreaWidget::setKit(Kit *k)
m_labels.clear();
int row = 0;
foreach (KitInformation *ki, KitManager::kitInformation()) {
foreach (KitAspect *ki, KitManager::kitInformation()) {
if (k && k->isMutable(ki->id())) {
KitConfigWidget *widget = ki->createConfigWidget(k);
KitAspectWidget *widget = ki->createConfigWidget(k);
m_widgets << widget;
QLabel *label = new QLabel(widget->displayName());
m_labels << label;
@@ -619,9 +619,9 @@ void KitAreaWidget::updateKit(Kit *k)
return;
bool addedMutables = false;
QList<Core::Id> knownIdList = Utils::transform(m_widgets, &KitConfigWidget::kitInformationId);
QList<Core::Id> knownIdList = Utils::transform(m_widgets, &KitAspectWidget::kitInformationId);
foreach (KitInformation *ki, KitManager::kitInformation()) {
foreach (KitAspect *ki, KitManager::kitInformation()) {
Core::Id currentId = ki->id();
if (m_kit->isMutable(currentId) && !knownIdList.removeOne(currentId)) {
addedMutables = true;
@@ -635,7 +635,7 @@ void KitAreaWidget::updateKit(Kit *k)
setKit(m_kit);
} else {
// Refresh all widgets if the number of mutable settings did not change
foreach (KitConfigWidget *w, m_widgets)
foreach (KitAspectWidget *w, m_widgets)
w->refresh();
}
}

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

@@ -37,7 +37,7 @@ QT_END_NAMESPACE
namespace ProjectExplorer {
class Kit;
class KitConfigWidget;
class KitAspectWidget;
class Project;
class Target;
class BuildConfiguration;
@@ -101,7 +101,7 @@ private:
QGridLayout *m_layout;
Kit *m_kit = nullptr;
QList<KitConfigWidget *> m_widgets;
QList<KitAspectWidget *> m_widgets;
QList<QLabel *> m_labels;
};

22
src/plugins/projectexplorer/projectexplorer.cpp
View File

@@ -603,12 +603,12 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
IWizardFactory::registerFeatureProvider(new KitFeatureProvider);
// Register KitInformation:
KitManager::registerKitInformation<DeviceTypeKitInformation>();
KitManager::registerKitInformation<DeviceKitInformation>();
KitManager::registerKitInformation<ToolChainKitInformation>();
KitManager::registerKitInformation<SysRootKitInformation>();
KitManager::registerKitInformation<EnvironmentKitInformation>();
// Register KitAspects:
KitManager::registerKitAspect<DeviceTypeKitAspect>();
KitManager::registerKitAspect<DeviceKitAspect>();
KitManager::registerKitAspect<ToolChainKitAspect>();
KitManager::registerKitAspect<SysRootKitAspect>();
KitManager::registerKitAspect<EnvironmentKitAspect>();
IWizardFactory::registerFactoryCreator([]() -> QList<IWizardFactory *> {
QList<IWizardFactory *> result;
@@ -1535,7 +1535,7 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
tr("The host address of the device in the currently active kit."),
[]() -> QString {
Kit *kit = currentKit();
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->sshParameters().host() : QString();
});
@@ -1543,7 +1543,7 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
tr("The SSH port of the device in the currently active kit."),
[]() -> QString {
Kit *kit = currentKit();
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? QString::number(device->sshParameters().port()) : QString();
});
@@ -1551,7 +1551,7 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
tr("The username with which to log into the device in the currently active kit."),
[]() -> QString {
Kit *kit = currentKit();
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->sshParameters().userName() : QString();
});
@@ -1561,7 +1561,7 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
"in the currently active kit."),
[]() -> QString {
Kit *kit = currentKit();
const IDevice::ConstPtr device = DeviceKitInformation::device(kit);
const IDevice::ConstPtr device = DeviceKitAspect::device(kit);
return device ? device->sshParameters().privateKeyFile : QString();
});
@@ -2546,7 +2546,7 @@ int ProjectExplorerPluginPrivate::queue(QList<Project *> projects, QList<Id> ste
return false;
IDevice::ConstPtr device = rc->runnable().device;
if (device.isNull())
device = DeviceKitInformation::device(t->kit());
device = DeviceKitAspect::device(t->kit());
return !device.isNull() && device->type() == Core::Id(Constants::DESKTOP_DEVICE_TYPE);
});
}

16
src/plugins/projectexplorer/projectimporter.cpp
View File

@@ -73,7 +73,7 @@ static bool hasOtherUsers(Core::Id id, const QVariant &v, Kit *k)
ProjectImporter::ProjectImporter(const Utils::FileName &path) : m_projectPath(path)
{
useTemporaryKitInformation(ToolChainKitInformation::id(),
useTemporaryKitAspect(ToolChainKitAspect::id(),
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(k, vl); },
[this](Kit *k, const QVariantList &vl) { persistTemporaryToolChains(k, vl); });
}
@@ -167,7 +167,7 @@ Target *ProjectImporter::preferredTarget(const QList<Target *> &possibleTargets)
return t;
if (pickedFallback)
continue;
if (DeviceTypeKitInformation::deviceTypeId(t->kit()) == Constants::DESKTOP_DEVICE_TYPE) {
if (DeviceTypeKitAspect::deviceTypeId(t->kit()) == Constants::DESKTOP_DEVICE_TYPE) {
activeTarget = t;
pickedFallback = true;
}
@@ -294,12 +294,12 @@ Kit *ProjectImporter::createTemporaryKit(const KitSetupFunction &setup) const
k->setUnexpandedDisplayName(QCoreApplication::translate("ProjectExplorer::ProjectImporter", "Imported Kit"));;
// Set up values:
foreach (KitInformation *ki, KitManager::kitInformation())
foreach (KitAspect *ki, KitManager::kitInformation())
ki->setup(kptr);
setup(kptr);
foreach (KitInformation *ki, KitManager::kitInformation())
foreach (KitAspect *ki, KitManager::kitInformation())
ki->fix(kptr);
markKitAsTemporary(kptr);
@@ -326,7 +326,7 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
ToolChain *tc = toolChainFromVariant(v);
QTC_ASSERT(tc, continue);
ToolChainManager::deregisterToolChain(tc);
ToolChainKitInformation::setToolChain(k, nullptr);
ToolChainKitAspect::setToolChain(k, nullptr);
}
}
@@ -335,13 +335,13 @@ void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
for (const QVariant &v : vl) {
ToolChain *tmpTc = toolChainFromVariant(v);
QTC_ASSERT(tmpTc, continue);
ToolChain *actualTc = ToolChainKitInformation::toolChain(k, tmpTc->language());
ToolChain *actualTc = ToolChainKitAspect::toolChain(k, tmpTc->language());
if (tmpTc && actualTc != tmpTc)
ToolChainManager::deregisterToolChain(tmpTc);
}
}
void ProjectImporter::useTemporaryKitInformation(Core::Id id,
void ProjectImporter::useTemporaryKitAspect(Core::Id id,
ProjectImporter::CleanupFunction cleanup,
ProjectImporter::PersistFunction persist)
{
@@ -400,7 +400,7 @@ ProjectImporter::findOrCreateToolChains(const Utils::FileName &toolChainPath,
});
for (const ToolChain *tc : result.tcs) {
const QByteArray tcId = tc->id();
result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolChainKitInformation::id(), tcId);
result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolChainKitAspect::id(), tcId);
}
if (!result.tcs.isEmpty())
return result;

2
src/plugins/projectexplorer/projectimporter.h
View File

@@ -103,7 +103,7 @@ protected:
// Handle temporary additions to Kits (Qt Versions, ToolChains, etc.)
using CleanupFunction = std::function<void(Kit *, const QVariantList &)>;
using PersistFunction = std::function<void(Kit *, const QVariantList &)>;
void useTemporaryKitInformation(Core::Id id,
void useTemporaryKitAspect(Core::Id id,
CleanupFunction cleanup, PersistFunction persist);
void addTemporaryData(Core::Id id, const QVariant &cleanupData, Kit *k) const;
// Does *any* kit feature the requested data yet?

8
src/plugins/projectexplorer/runconfiguration.cpp
View File

@@ -435,9 +435,9 @@ QString RunConfigurationFactory::decoratedTargetName(const QString &targetName,
QString displayName;
if (!targetName.isEmpty())
displayName = QFileInfo(targetName).completeBaseName();
Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target->kit());
Core::Id devType = DeviceTypeKitAspect::deviceTypeId(target->kit());
if (devType != Constants::DESKTOP_DEVICE_TYPE) {
if (IDevice::ConstPtr dev = DeviceKitInformation::device(target->kit())) {
if (IDevice::ConstPtr dev = DeviceKitAspect::device(target->kit())) {
if (displayName.isEmpty()) {
//: Shown in Run configuration if no executable is given, %1 is device name
displayName = RunConfiguration::tr("Run on %1").arg(dev->displayName());
@@ -524,7 +524,7 @@ bool RunConfigurationFactory::canHandle(Target *target) const
if (!m_supportedTargetDeviceTypes.isEmpty())
if (!m_supportedTargetDeviceTypes.contains(
DeviceTypeKitInformation::deviceTypeId(kit)))
DeviceTypeKitAspect::deviceTypeId(kit)))
return false;
return true;
@@ -796,7 +796,7 @@ public:
outputFormatter = runConfiguration->createOutputFormatter();
device = runnable.device;
if (!device)
device = DeviceKitInformation::device(runConfiguration->target()->kit());
device = DeviceKitAspect::device(runConfiguration->target()->kit());
project = runConfiguration->target()->project();
} else {
outputFormatter = new OutputFormatter();

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

@@ -452,7 +452,7 @@ void Target::setOverlayIcon(const QIcon &icon)
QString Target::overlayIconToolTip()
{
IDevice::ConstPtr current = DeviceKitInformation::device(kit());
IDevice::ConstPtr current = DeviceKitAspect::device(kit());
return current.isNull() ? QString() : formatDeviceInfo(current->deviceInformation());
}
@@ -682,7 +682,7 @@ QVariant Target::additionalData(Core::Id id) const
void Target::updateDeviceState()
{
IDevice::ConstPtr current = DeviceKitInformation::device(kit());
IDevice::ConstPtr current = DeviceKitAspect::device(kit());
QIcon overlay;
static const QIcon disconnected = Icons::DEVICE_DISCONNECTED_INDICATOR_OVERLAY.icon();

2
src/plugins/projectexplorer/targetsetupwidget.cpp
View File

@@ -73,7 +73,7 @@ TargetSetupWidget::TargetSetupWidget(Kit *k, const QString &projectPath) :
auto panel = new Utils::FadingWidget(m_detailsWidget);
auto panelLayout = new QHBoxLayout(panel);
m_manageButton = new QPushButton(KitConfigWidget::msgManage());
m_manageButton = new QPushButton(KitAspectWidget::msgManage());
panelLayout->addWidget(m_manageButton);
m_detailsWidget->setToolWidget(panel);

10
src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
View File

@@ -76,7 +76,7 @@ static QString extractToolchainPrefix(QString *compilerName)
static QString targetPlatform(const ProjectExplorer::Abi &abi, const ProjectExplorer::Kit *k)
{
const Core::Id device = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(k);
const Core::Id device = ProjectExplorer::DeviceTypeKitAspect::deviceTypeId(k);
switch (abi.os()) {
case ProjectExplorer::Abi::WindowsOS:
return QLatin1String("windows");
@@ -195,7 +195,7 @@ QVariantMap DefaultPropertyProvider::properties(const ProjectExplorer::Kit *k,
{
QTC_ASSERT(k, return defaultData);
QVariantMap data = autoGeneratedProperties(k, defaultData);
const QVariantMap customProperties = QbsKitInformation::properties(k);
const QVariantMap customProperties = QbsKitAspect::properties(k);
for (QVariantMap::ConstIterator it = customProperties.constBegin();
it != customProperties.constEnd(); ++it) {
data.insert(it.key(), it.value());
@@ -222,14 +222,14 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
{
QVariantMap data = defaultData;
const QString sysroot = ProjectExplorer::SysRootKitInformation::sysRoot(k).toUserOutput();
const QString sysroot = ProjectExplorer::SysRootKitAspect::sysRoot(k).toUserOutput();
if (!sysroot.isEmpty())
data.insert(QLatin1String(QBS_SYSROOT), sysroot);
ProjectExplorer::ToolChain *tcC
= ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
= ProjectExplorer::ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
ProjectExplorer::ToolChain *tcCxx
= ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
= ProjectExplorer::ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!tcC && !tcCxx)
return data;

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

@@ -399,7 +399,7 @@ QbsBuildConfigurationFactory::QbsBuildConfigurationFactory()
setSupportedProjectType(Constants::PROJECT_ID);
setSupportedProjectMimeTypeName(Constants::MIME_TYPE);
setIssueReporter([](Kit *k, const QString &projectPath, const QString &buildDir) -> QList<Task> {
const QtSupport::BaseQtVersion * const version = QtSupport::QtKitInformation::qtVersion(k);
const QtSupport::BaseQtVersion * const version = QtSupport::QtKitAspect::qtVersion(k);
return version ? version->reportIssues(projectPath, buildDir)
: QList<ProjectExplorer::Task>();
});

42
src/plugins/qbsprojectmanager/qbskitinformation.cpp
View File

@@ -42,49 +42,49 @@ using namespace ProjectExplorer;
namespace QbsProjectManager {
namespace Internal {
class ConfigWidget final : public KitConfigWidget
class AspectWidget final : public KitAspectWidget
{
Q_OBJECT
public:
ConfigWidget(Kit *kit, const KitInformation *kitInfo)
: KitConfigWidget(kit, kitInfo),
AspectWidget(Kit *kit, const KitAspect *kitInfo)
: KitAspectWidget(kit, kitInfo),
m_contentLabel(new Utils::ElidingLabel),
m_changeButton(new QPushButton(tr("Change...")))
{
connect(m_changeButton, &QPushButton::clicked, this, &ConfigWidget::changeProperties);
connect(m_changeButton, &QPushButton::clicked, this, &AspectWidget::changeProperties);
}
private:
QString displayName() const override { return QbsKitInformation::displayName(); }
QString displayName() const override { return QbsKitAspect::displayName(); }
void makeReadOnly() override { m_changeButton->setEnabled(false); }
void refresh() override { m_contentLabel->setText(QbsKitInformation::representation(kit())); }
void refresh() override { m_contentLabel->setText(QbsKitAspect::representation(kit())); }
QWidget *mainWidget() const override { return m_contentLabel; }
QWidget *buttonWidget() const override { return m_changeButton; }
void changeProperties()
{
CustomQbsPropertiesDialog dlg(QbsKitInformation::properties(kit()));
CustomQbsPropertiesDialog dlg(QbsKitAspect::properties(kit()));
if (dlg.exec() == QDialog::Accepted)
QbsKitInformation::setProperties(kit(), dlg.properties());
QbsKitAspect::setProperties(kit(), dlg.properties());
}
QLabel * const m_contentLabel;
QPushButton * const m_changeButton;
};
QbsKitInformation::QbsKitInformation()
QbsKitAspect::QbsKitAspect()
{
setObjectName(QLatin1String("QbsKitInformation"));
setId(QbsKitInformation::id());
setObjectName(QLatin1String("QbsKitAspect"));
setId(QbsKitAspect::id());
setPriority(22000);
}
QString QbsKitInformation::displayName()
QString QbsKitAspect::displayName()
{
return tr("Additional Qbs Profile Settings");
}
QString QbsKitInformation::representation(const Kit *kit)
QString QbsKitAspect::representation(const Kit *kit)
{
const QVariantMap props = properties(kit);
QString repr;
@@ -96,34 +96,34 @@ QString QbsKitInformation::representation(const Kit *kit)
return repr;
}
QVariantMap QbsKitInformation::properties(const Kit *kit)
QVariantMap QbsKitAspect::properties(const Kit *kit)
{
QTC_ASSERT(kit, return QVariantMap());
return kit->value(id()).toMap();
}
void QbsKitInformation::setProperties(Kit *kit, const QVariantMap &properties)
void QbsKitAspect::setProperties(Kit *kit, const QVariantMap &properties)
{
QTC_ASSERT(kit, return);
kit->setValue(id(), properties);
}
Core::Id QbsKitInformation::id()
Core::Id QbsKitAspect::id()
{
return "Qbs.KitInformation";
}
QVariant QbsKitInformation::defaultValue(const Kit *) const { return QString(); }
QList<Task> QbsKitInformation::validate(const Kit *) const { return QList<Task>(); }
QVariant QbsKitAspect::defaultValue(const Kit *) const { return QString(); }
QList<Task> QbsKitAspect::validate(const Kit *) const { return QList<Task>(); }
KitInformation::ItemList QbsKitInformation::toUserOutput(const Kit *k) const
KitAspect::ItemList QbsKitAspect::toUserOutput(const Kit *k) const
{
return ItemList({qMakePair(displayName(), representation(k))});
}
KitConfigWidget *QbsKitInformation::createConfigWidget(Kit *k) const
KitAspectWidget *QbsKitAspect::createConfigWidget(Kit *k) const
{
return new ConfigWidget(k, this);
return new AspectWidget(k, this);
}
} // namespace Internal

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

@@ -30,12 +30,12 @@
namespace QbsProjectManager {
namespace Internal {
class QbsKitInformation final : public ProjectExplorer::KitInformation
class QbsKitAspect final : public ProjectExplorer::KitAspect
{
Q_OBJECT
public:
QbsKitInformation();
QbsKitAspect();
static QString displayName();
static QString representation(const ProjectExplorer::Kit *kit);
@@ -48,7 +48,7 @@ private:
QVariant defaultValue(const ProjectExplorer::Kit *) const override;
QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *) const override;
ItemList toUserOutput(const ProjectExplorer::Kit *) const override;
ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *) const override;
ProjectExplorer::KitAspectWidget *createConfigWidget(ProjectExplorer::Kit *) const override;
};
} // namespace Internal

2
src/plugins/qbsprojectmanager/qbsproject.cpp
View File

@@ -693,7 +693,7 @@ void QbsProject::configureAsExampleProject(const QSet<Id> &platforms)
};
foreach (Kit *k, kits) {
const QtSupport::BaseQtVersion * const qtVersion
= QtSupport::QtKitInformation::qtVersion(k);
= QtSupport::QtKitAspect::qtVersion(k);
if (!qtVersion || !qtVersionMatchesPlatform(qtVersion))
continue;
if (auto factory = BuildConfigurationFactory::find(k, projectFilePath().toString()))

14
src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
View File

@@ -163,14 +163,14 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
const auto * const bgData = static_cast<BuildGraphData *>(directoryData);
qCDebug(qbsPmLog) << "matching kit" << k->displayName() << "against imported build"
<< bgData->bgFilePath.toUserOutput();
if (ToolChainKitInformation::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
if (ToolChainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
&& bgData->cxxCompilerPath.isEmpty()) {
return true;
}
const ToolChain * const cToolchain
= ToolChainKitInformation::toolChain(k, Constants::C_LANGUAGE_ID);
= ToolChainKitAspect::toolChain(k, Constants::C_LANGUAGE_ID);
const ToolChain * const cxxToolchain
= ToolChainKitInformation::toolChain(k, Constants::CXX_LANGUAGE_ID);
= ToolChainKitAspect::toolChain(k, Constants::CXX_LANGUAGE_ID);
if (!bgData->cCompilerPath.isEmpty()) {
if (!cToolchain)
return false;
@@ -183,14 +183,14 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (bgData->cxxCompilerPath != cxxToolchain->compilerCommand())
return false;
}
const QtSupport::BaseQtVersion * const qtVersion = QtSupport::QtKitInformation::qtVersion(k);
const QtSupport::BaseQtVersion * const qtVersion = QtSupport::QtKitAspect::qtVersion(k);
if (!bgData->qtBinPath.isEmpty()) {
if (!qtVersion)
return false;
if (bgData->qtBinPath != qtVersion->binPath())
return false;
}
if (bgData->sysroot != SysRootKitInformation::sysRoot(k))
if (bgData->sysroot != SysRootKitAspect::sysRoot(k))
return false;
qCDebug(qbsPmLog) << "Kit matches";
@@ -215,9 +215,9 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
tcData << findOrCreateToolChains(bgData->cCompilerPath, Constants::C_LANGUAGE_ID);
foreach (const ToolChainData &tc, tcData) {
if (!tc.tcs.isEmpty())
ToolChainKitInformation::setToolChain(k, tc.tcs.first());
ToolChainKitAspect::setToolChain(k, tc.tcs.first());
}
SysRootKitInformation::setSysRoot(k, bgData->sysroot);
SysRootKitAspect::setSysRoot(k, bgData->sysroot);
});
}

2
src/plugins/qbsprojectmanager/qbsprojectmanager.cpp
View File

@@ -166,7 +166,7 @@ void QbsManager::addProfile(const QString &name, const QVariantMap &data)
void QbsManager::addQtProfileFromKit(const QString &profileName, const ProjectExplorer::Kit *k)
{
const QtSupport::BaseQtVersion * const qt = QtSupport::QtKitInformation::qtVersion(k);
const QtSupport::BaseQtVersion * const qt = QtSupport::QtKitAspect::qtVersion(k);
if (!qt)
return;

Some files were not shown because too many files have changed in this diff Show More