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

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>();
}