From 99e9643dea3871f26c5a09e4a1715ba84c9103e9 Mon Sep 17 00:00:00 2001 From: Benjamin Zeller Date: Wed, 4 Feb 2015 17:54:46 +0100 Subject: [PATCH] Make it possible to register multiple cmake instances This patch add the CMakeToolManager, a central repository for cmake instances. One instance is always the currently used "default". By that its possible to switch between different cmake installations. The next step will be adding it to the Kits. Change-Id: I310fdd805e0ed239077a5632303e891dbd1d9ea1 Reviewed-by: Leena Miettinen Reviewed-by: Daniel Teske --- .../cmakeprojectmanager/cmake_global.h | 41 ++ .../cmakeprojectmanager/cmakeeditor.cpp | 4 +- src/plugins/cmakeprojectmanager/cmakeeditor.h | 2 +- .../cmakefilecompletionassist.cpp | 11 +- .../cmakefilecompletionassist.h | 5 +- .../cmakeopenprojectwizard.cpp | 9 +- .../cmakeprojectmanager.cpp | 31 +- .../cmakeprojectmanager/cmakeprojectmanager.h | 4 +- .../cmakeprojectmanager.pro | 8 +- .../cmakeprojectmanager.qbs | 3 + .../cmakeprojectplugin.cpp | 13 +- .../cmakeprojectmanager/cmakeprojectplugin.h | 3 + .../cmakeprojectmanager/cmakesettingspage.cpp | 616 ++++++++++++++---- .../cmakeprojectmanager/cmakesettingspage.h | 24 +- src/plugins/cmakeprojectmanager/cmaketool.cpp | 85 ++- src/plugins/cmakeprojectmanager/cmaketool.h | 38 +- .../cmakeprojectmanager/cmaketoolmanager.cpp | 392 +++++++++++ .../cmakeprojectmanager/cmaketoolmanager.h | 71 ++ 18 files changed, 1173 insertions(+), 187 deletions(-) create mode 100644 src/plugins/cmakeprojectmanager/cmake_global.h create mode 100644 src/plugins/cmakeprojectmanager/cmaketoolmanager.cpp create mode 100644 src/plugins/cmakeprojectmanager/cmaketoolmanager.h diff --git a/src/plugins/cmakeprojectmanager/cmake_global.h b/src/plugins/cmakeprojectmanager/cmake_global.h new file mode 100644 index 00000000000..5c22d41e930 --- /dev/null +++ b/src/plugins/cmakeprojectmanager/cmake_global.h @@ -0,0 +1,41 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Canonical Ltd. +** Contact: http://www.qt.io/licensing +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms and +** conditions see http://www.qt.io/terms-conditions. For further information +** use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 or version 3 as published by the Free +** Software Foundation and appearing in the file LICENSE.LGPLv21 and +** LICENSE.LGPLv3 included in the packaging of this file. Please review the +** following information to ensure the GNU Lesser General Public License +** requirements will be met: https://www.gnu.org/licenses/lgpl.html and +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, The Qt Company gives you certain additional +** rights. These rights are described in The Qt Company LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +****************************************************************************/ +#ifndef CMAKE_GLOBAL_H +#define CMAKE_GLOBAL_H + +#include + +#if defined(CMAKEPROJECTMANAGER_LIBRARY) +# define CMAKE_EXPORT Q_DECL_EXPORT +#else +# define CMAKE_EXPORT Q_DECL_IMPORT +#endif + +#endif // CMAKE_GLOBAL_H diff --git a/src/plugins/cmakeprojectmanager/cmakeeditor.cpp b/src/plugins/cmakeprojectmanager/cmakeeditor.cpp index 09907fff529..967f23946ce 100644 --- a/src/plugins/cmakeprojectmanager/cmakeeditor.cpp +++ b/src/plugins/cmakeprojectmanager/cmakeeditor.cpp @@ -264,7 +264,7 @@ QString CMakeDocument::suggestedFileName() const // CMakeEditorFactory // -CMakeEditorFactory::CMakeEditorFactory(CMakeSettingsPage *settingsPage) +CMakeEditorFactory::CMakeEditorFactory() { setId(Constants::CMAKE_EDITOR_ID); setDisplayName(tr(Constants::CMAKE_EDITOR_DISPLAY_NAME)); @@ -278,7 +278,7 @@ CMakeEditorFactory::CMakeEditorFactory(CMakeSettingsPage *settingsPage) setCommentStyle(Utils::CommentDefinition::HashStyle); setCodeFoldingSupported(true); - setCompletionAssistProvider(new CMakeFileCompletionAssistProvider(settingsPage)); + setCompletionAssistProvider(new CMakeFileCompletionAssistProvider); setEditorActionHandlers(TextEditorActionHandler::UnCommentSelection | TextEditorActionHandler::JumpToFileUnderCursor); diff --git a/src/plugins/cmakeprojectmanager/cmakeeditor.h b/src/plugins/cmakeprojectmanager/cmakeeditor.h index d56d689b5a5..d8bdb289189 100644 --- a/src/plugins/cmakeprojectmanager/cmakeeditor.h +++ b/src/plugins/cmakeprojectmanager/cmakeeditor.h @@ -58,7 +58,7 @@ class CMakeEditorFactory : public TextEditor::TextEditorFactory Q_OBJECT public: - CMakeEditorFactory(CMakeSettingsPage *settingsPage); + CMakeEditorFactory(); }; } // namespace Internal diff --git a/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.cpp b/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.cpp index f5bdc88cf33..76e1d4bb268 100644 --- a/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.cpp +++ b/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.cpp @@ -32,6 +32,7 @@ #include "cmakeprojectconstants.h" #include "cmakeprojectmanager.h" #include "cmakesettingspage.h" +#include "cmaketoolmanager.h" #include @@ -41,8 +42,7 @@ using namespace TextEditor; // ------------------------------- // CMakeFileCompletionAssistProvider // ------------------------------- -CMakeFileCompletionAssistProvider::CMakeFileCompletionAssistProvider(CMakeSettingsPage *settingsPage) - : m_settingsPage(settingsPage) +CMakeFileCompletionAssistProvider::CMakeFileCompletionAssistProvider() {} CMakeFileCompletionAssistProvider::~CMakeFileCompletionAssistProvider() @@ -55,5 +55,10 @@ bool CMakeFileCompletionAssistProvider::supportsEditor(Core::Id editorId) const IAssistProcessor *CMakeFileCompletionAssistProvider::createProcessor() const { - return new KeywordsCompletionAssistProcessor(m_settingsPage->keywords()); + TextEditor::Keywords keywords = TextEditor::Keywords(QStringList(), QStringList(), QMap()); + CMakeTool *cmake = CMakeToolManager::defaultCMakeTool(); + if (cmake && cmake->isValid()) + keywords = cmake->keywords(); + + return new KeywordsCompletionAssistProcessor(keywords); } diff --git a/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.h b/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.h index 6f1a4721047..ee99c5a18e6 100644 --- a/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.h +++ b/src/plugins/cmakeprojectmanager/cmakefilecompletionassist.h @@ -43,14 +43,11 @@ class CMakeFileCompletionAssistProvider : public TextEditor::CompletionAssistPro Q_OBJECT public: - CMakeFileCompletionAssistProvider(CMakeSettingsPage *settingsPage); + CMakeFileCompletionAssistProvider(); ~CMakeFileCompletionAssistProvider(); bool supportsEditor(Core::Id editorId) const; TextEditor::IAssistProcessor *createProcessor() const; - -private: - CMakeSettingsPage *m_settingsPage; }; } // Internal diff --git a/src/plugins/cmakeprojectmanager/cmakeopenprojectwizard.cpp b/src/plugins/cmakeprojectmanager/cmakeopenprojectwizard.cpp index 554f22f52e0..df465c099bc 100644 --- a/src/plugins/cmakeprojectmanager/cmakeopenprojectwizard.cpp +++ b/src/plugins/cmakeprojectmanager/cmakeopenprojectwizard.cpp @@ -30,6 +30,7 @@ #include "cmakeopenprojectwizard.h" #include "cmakeprojectmanager.h" +#include "cmaketoolmanager.h" #include "cmakebuildconfiguration.h" #include "cmakebuildinfo.h" #include "generatorinfo.h" @@ -386,7 +387,13 @@ void ChooseCMakePage::updateErrorText() void ChooseCMakePage::cmakeExecutableChanged() { - m_cmakeWizard->cmakeManager()->setCMakeExecutable(m_cmakeExecutable->path()); + CMakeTool *cmake = CMakeToolManager::defaultCMakeTool(); + if (!cmake) { + Core::Id id = CMakeToolManager::registerOrFindCMakeTool(m_cmakeExecutable->fileName()); + CMakeToolManager::setDefaultCMakeTool(id); + } else { + cmake->setCMakeExecutable(m_cmakeExecutable->fileName()); + } updateErrorText(); emit completeChanged(); } diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp index 2f5c2714992..c319321c7b3 100644 --- a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp +++ b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp @@ -33,6 +33,7 @@ #include "cmakeprojectconstants.h" #include "cmakeproject.h" #include "cmakesettingspage.h" +#include "cmaketoolmanager.h" #include @@ -47,8 +48,7 @@ using namespace CMakeProjectManager::Internal; -CMakeManager::CMakeManager(CMakeSettingsPage *cmakeSettingsPage) - : m_settingsPage(cmakeSettingsPage) +CMakeManager::CMakeManager() { ProjectExplorer::ProjectTree *tree = ProjectExplorer::ProjectTree::instance(); connect(tree, &ProjectExplorer::ProjectTree::aboutToShowContextMenu, @@ -130,32 +130,39 @@ QString CMakeManager::mimeType() const QString CMakeManager::cmakeExecutable() const { - return m_settingsPage->cmakeExecutable(); + CMakeTool *cmake = CMakeToolManager::defaultCMakeTool(); + if (cmake) + return cmake->cmakeExecutable().toString(); + return QString(); } bool CMakeManager::isCMakeExecutableValid() const { - return m_settingsPage->isCMakeExecutableValid(); -} - -void CMakeManager::setCMakeExecutable(const QString &executable) -{ - m_settingsPage->setCMakeExecutable(executable); + CMakeTool *cmake = CMakeToolManager::defaultCMakeTool(); + if (cmake) + return cmake->isValid(); + return false; } bool CMakeManager::hasCodeBlocksMsvcGenerator() const { - return m_settingsPage->hasCodeBlocksMsvcGenerator(); + CMakeTool *cmake = CMakeToolManager::defaultCMakeTool(); + if (cmake) + return cmake->hasCodeBlocksMsvcGenerator(); + return false; } bool CMakeManager::hasCodeBlocksNinjaGenerator() const { - return m_settingsPage->hasCodeBlocksNinjaGenerator(); + CMakeTool *cmake = CMakeToolManager::defaultCMakeTool(); + if (cmake) + return cmake->hasCodeBlocksNinjaGenerator(); + return false; } bool CMakeManager::preferNinja() const { - return m_settingsPage->preferNinja(); + return CMakeToolManager::preferNinja(); } // need to refactor this out diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.h b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.h index bd0bd527cac..4008cd9bb40 100644 --- a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.h +++ b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.h @@ -53,7 +53,7 @@ class CMakeManager : public ProjectExplorer::IProjectManager { Q_OBJECT public: - CMakeManager(CMakeSettingsPage *cmakeSettingsPage); + CMakeManager(); virtual ProjectExplorer::Project *openProject(const QString &fileName, QString *errorString); virtual QString mimeType() const; @@ -61,8 +61,6 @@ public: QString cmakeExecutable() const; bool isCMakeExecutableValid() const; - void setCMakeExecutable(const QString &executable); - void createXmlFile(Utils::QtcProcess *process, const QString &arguments, const QString &sourceDirectory, diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.pro b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.pro index 4f3eff9da54..5143d555aea 100644 --- a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.pro +++ b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.pro @@ -1,3 +1,4 @@ +DEFINES += CMAKEPROJECTMANAGER_LIBRARY include(../../qtcreatorplugin.pri) HEADERS = cmakebuildinfo.h \ @@ -16,7 +17,9 @@ HEADERS = cmakebuildinfo.h \ cmaketool.h \ cmakeparser.h \ generatorinfo.h \ - cmakesettingspage.h + cmakesettingspage.h \ + cmaketoolmanager.h \ + cmake_global.h SOURCES = cmakeproject.cpp \ cmakeprojectplugin.cpp \ @@ -32,7 +35,8 @@ SOURCES = cmakeproject.cpp \ cmaketool.cpp \ cmakeparser.cpp \ generatorinfo.cpp \ - cmakesettingspage.cpp + cmakesettingspage.cpp \ + cmaketoolmanager.cpp RESOURCES += cmakeproject.qrc diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.qbs b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.qbs index 2415f71e548..c7311627140 100644 --- a/src/plugins/cmakeprojectmanager/cmakeprojectmanager.qbs +++ b/src/plugins/cmakeprojectmanager/cmakeprojectmanager.qbs @@ -18,6 +18,7 @@ QtcPlugin { ] files: [ + "cmake_global.h", "cmakebuildconfiguration.cpp", "cmakebuildconfiguration.h", "cmakebuildinfo.h", @@ -45,6 +46,8 @@ QtcPlugin { "cmakerunconfiguration.h", "cmaketool.cpp", "cmaketool.h", + "cmaketoolmanager.cpp", + "cmaketoolmanager.h", "makestep.cpp", "makestep.h", "cmakesettingspage.h", diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectplugin.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectplugin.cpp index 7215e36a8bd..49301277595 100644 --- a/src/plugins/cmakeprojectmanager/cmakeprojectplugin.cpp +++ b/src/plugins/cmakeprojectmanager/cmakeprojectplugin.cpp @@ -39,6 +39,7 @@ #include "cmakelocatorfilter.h" #include "cmakefilecompletionassist.h" #include "cmakesettingspage.h" +#include "cmaketoolmanager.h" #include #include @@ -62,15 +63,17 @@ bool CMakeProjectPlugin::initialize(const QStringList & /*arguments*/, QString * Q_UNUSED(errorMessage) Utils::MimeDatabase::addMimeTypes(QLatin1String(":cmakeproject/CMakeProjectManager.mimetypes.xml")); - CMakeSettingsPage *cmp = new CMakeSettingsPage(); - addAutoReleasedObject(cmp); - addAutoReleasedObject(new CMakeManager(cmp)); + addAutoReleasedObject(new CMakeSettingsPage); + addAutoReleasedObject(new CMakeManager); addAutoReleasedObject(new MakeStepFactory); addAutoReleasedObject(new CMakeRunConfigurationFactory); addAutoReleasedObject(new CMakeBuildConfigurationFactory); - addAutoReleasedObject(new CMakeEditorFactory(cmp)); + addAutoReleasedObject(new CMakeEditorFactory); addAutoReleasedObject(new CMakeLocatorFilter); - addAutoReleasedObject(new CMakeFileCompletionAssistProvider(cmp)); + addAutoReleasedObject(new CMakeFileCompletionAssistProvider); + + new CMakeToolManager(this); + CMakeToolManager::restoreCMakeTools(); return true; } diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectplugin.h b/src/plugins/cmakeprojectmanager/cmakeprojectplugin.h index f8e5c74893b..11929d55f10 100644 --- a/src/plugins/cmakeprojectmanager/cmakeprojectplugin.h +++ b/src/plugins/cmakeprojectmanager/cmakeprojectplugin.h @@ -36,6 +36,9 @@ #include namespace CMakeProjectManager { + +class CMakeToolManager; + namespace Internal { class CMakeProjectPlugin diff --git a/src/plugins/cmakeprojectmanager/cmakesettingspage.cpp b/src/plugins/cmakeprojectmanager/cmakesettingspage.cpp index c32c07ddcbb..e763d469816 100644 --- a/src/plugins/cmakeprojectmanager/cmakesettingspage.cpp +++ b/src/plugins/cmakeprojectmanager/cmakesettingspage.cpp @@ -28,28 +28,516 @@ ** ****************************************************************************/ #include "cmakesettingspage.h" +#include "cmaketoolmanager.h" #include +#include #include #include +#include +#include +#include +#include -#include -#include -#include #include -#include +#include +#include +#include +#include +#include +#include +#include #include +using namespace Utils; + namespace CMakeProjectManager { namespace Internal { +class CMakeToolTreeItem; + +// -------------------------------------------------------------------------- +// CMakeToolItemModel +// -------------------------------------------------------------------------- + +class CMakeToolItemModel : public TreeModel +{ + Q_DECLARE_TR_FUNCTIONS(CMakeProjectManager::CMakeSettingsPage) + +public: + CMakeToolItemModel(); + + CMakeToolTreeItem *cmakeToolItem(const Core::Id &id) const; + CMakeToolTreeItem *cmakeToolItem(const QModelIndex &index) const; + QModelIndex addCMakeTool(const QString &name, const FileName &executable, const bool isAutoDetected); + QModelIndex addCMakeTool(const CMakeTool *item, bool changed); + TreeItem *autoGroupItem() const; + TreeItem *manualGroupItem() const; + void reevaluateChangedFlag(CMakeToolTreeItem *item) const; + void updateCMakeTool(const Core::Id &id, const QString &displayName, const FileName &executable); + void removeCMakeTool(const Core::Id &id); + void apply(); + + Core::Id defaultItemId() const; + void setDefaultItemId(const Core::Id &id); + + QString uniqueDisplayName(const QString &base) const; +private: + Core::Id m_defaultItemId; + QList m_removedItems; +}; + +class CMakeToolTreeItem : public TreeItem +{ + Q_DECLARE_TR_FUNCTIONS(CMakeProjectManager::CMakeSettingsPage) + +public: + CMakeToolTreeItem(const CMakeTool *item, bool changed) : + m_id(item->id()), + m_name(item->displayName()), + m_executable(item->cmakeExecutable()), + m_autodetected(item->isAutoDetected()), + m_changed(changed) + {} + + CMakeToolTreeItem(const QString &name, const Utils::FileName &executable, bool autodetected) : + m_id(Core::Id::fromString(QUuid::createUuid().toString())), + m_name(name), + m_executable(executable), + m_autodetected(autodetected), + m_changed(true) + {} + + CMakeToolTreeItem() : m_autodetected(false), m_changed(true) {} + + CMakeToolItemModel *model() const { return static_cast(TreeItem::model()); } + + QVariant data(int column, int role) const + { + switch (role) { + case Qt::DisplayRole: + switch (column) { + case 0: { + QString name = m_name; + if (model()->defaultItemId() == m_id) + name += tr(" (Default)"); + return name; + } + case 1: return m_executable.toUserOutput(); + } + + case Qt::FontRole: { + QFont font; + font.setBold(m_changed); + font.setItalic(model()->defaultItemId() == m_id); + return font; + } + } + return QVariant(); + } + + Core::Id m_id; + QString m_name; + FileName m_executable; + bool m_autodetected; + bool m_changed; +}; + +CMakeToolItemModel::CMakeToolItemModel() +{ + setHeader(QStringList() << tr("Name") << tr("Location")); + rootItem()->appendChild(new TreeItem(QStringList() << tr("Auto-detected") << QString() << QString())); + rootItem()->appendChild(new TreeItem(QStringList() << tr("Manual") << QString() << QString())); + + foreach (const CMakeTool *item, CMakeToolManager::cmakeTools()) + addCMakeTool(item, false); + + CMakeTool *defTool = CMakeToolManager::defaultCMakeTool(); + m_defaultItemId = defTool ? defTool->id() : Core::Id(); +} + +QModelIndex CMakeToolItemModel::addCMakeTool(const QString &name, const FileName &executable, const bool isAutoDetected) +{ + CMakeToolTreeItem *item = new CMakeToolTreeItem(name, executable, isAutoDetected); + if (isAutoDetected) + autoGroupItem()->appendChild(item); + else + manualGroupItem()->appendChild(item); + + return item->index(); +} + +QModelIndex CMakeToolItemModel::addCMakeTool(const CMakeTool *item, bool changed) +{ + CMakeToolTreeItem *treeItem = new CMakeToolTreeItem(item, changed); + if (item->isAutoDetected()) + autoGroupItem()->appendChild(treeItem); + else + manualGroupItem()->appendChild(treeItem); + + return treeItem->index(); +} + +TreeItem *CMakeToolItemModel::autoGroupItem() const +{ + return rootItem()->child(0); +} + +TreeItem *CMakeToolItemModel::manualGroupItem() const +{ + return rootItem()->child(1); +} + +void CMakeToolItemModel::reevaluateChangedFlag(CMakeToolTreeItem *item) const +{ + CMakeTool *orig = CMakeToolManager::findById(item->m_id); + item->m_changed = !orig || orig->displayName() != item->m_name + || orig->cmakeExecutable() != item->m_executable; + + //make sure the item is marked as changed when the default cmake was changed + CMakeTool *origDefTool = CMakeToolManager::defaultCMakeTool(); + Core::Id origDefault = origDefTool ? origDefTool->id() : Core::Id(); + if (origDefault != m_defaultItemId) { + if (item->m_id == origDefault || item->m_id == m_defaultItemId) + item->m_changed = true; + } + + item->update(); // Notify views. +} + +void CMakeToolItemModel::updateCMakeTool(const Core::Id &id, const QString &displayName, + const FileName &executable) +{ + CMakeToolTreeItem *treeItem = cmakeToolItem(id); + QTC_ASSERT(treeItem, return); + + treeItem->m_name = displayName; + treeItem->m_executable = executable; + + reevaluateChangedFlag(treeItem); +} + +CMakeToolTreeItem *CMakeToolItemModel::cmakeToolItem(const Core::Id &id) const +{ + auto matcher = [id](CMakeToolTreeItem *n) { return n->m_id == id; }; + return findItemAtLevel(2, matcher); +} + +CMakeToolTreeItem *CMakeToolItemModel::cmakeToolItem(const QModelIndex &index) const +{ + TreeItem *item = itemFromIndex(index); + if (item->level() == 2) + return static_cast(item); + return 0; +} + +void CMakeToolItemModel::removeCMakeTool(const Core::Id &id) +{ + CMakeToolTreeItem *treeItem = cmakeToolItem(id); + QTC_ASSERT(treeItem, return); + + removeItem(treeItem); + m_removedItems.append(id); + + delete treeItem; +} + +void CMakeToolItemModel::apply() +{ + foreach (const Core::Id &id, m_removedItems) + CMakeToolManager::deregisterCMakeTool(id); + + foreach (auto item, treeLevelItems(2)) { + item->m_changed = false; + + bool isNew = false; + CMakeTool *cmake = CMakeToolManager::findById(item->m_id); + if (!cmake) { + isNew = true; + CMakeTool::Detection detection = item->m_autodetected ? CMakeTool::AutoDetection + : CMakeTool::ManualDetection; + cmake = new CMakeTool(detection, item->m_id); + } + + cmake->setDisplayName(item->m_name); + cmake->setCMakeExecutable(item->m_executable); + + if (isNew) { + if (!CMakeToolManager::registerCMakeTool(cmake)) { + delete cmake; + item->m_changed = true; + } + } + } + + CMakeToolManager::setDefaultCMakeTool(defaultItemId()); +} + +Core::Id CMakeToolItemModel::defaultItemId() const +{ + return m_defaultItemId; +} + +void CMakeToolItemModel::setDefaultItemId(const Core::Id &id) +{ + if (m_defaultItemId == id) + return; + + Core::Id oldDefaultId = m_defaultItemId; + m_defaultItemId = id; + + CMakeToolTreeItem *newDefault = cmakeToolItem(id); + if (newDefault) + reevaluateChangedFlag(newDefault); + + CMakeToolTreeItem *oldDefault = cmakeToolItem(oldDefaultId); + if (oldDefault) + reevaluateChangedFlag(oldDefault); +} + + +QString CMakeToolItemModel::uniqueDisplayName(const QString &base) const +{ + QStringList names; + foreach (CMakeToolTreeItem *item, treeLevelItems(2)) + names << item->m_name; + + return ProjectExplorer::Project::makeUnique(base, names); +} + +// ----------------------------------------------------------------------- +// CMakeToolItemConfigWidget +// ----------------------------------------------------------------------- + +class CMakeToolItemConfigWidget : public QWidget +{ + Q_DECLARE_TR_FUNCTIONS(CMakeProjectManager::CMakeSettingsPage) + +public: + explicit CMakeToolItemConfigWidget(CMakeToolItemModel *model); + void load(const CMakeToolTreeItem *item); + void store() const; + +private: + CMakeToolItemModel *m_model; + QLineEdit *m_displayNameLineEdit; + PathChooser *m_binaryChooser; + bool m_autodetected; + Core::Id m_id; + bool m_loadingItem; +}; + +CMakeToolItemConfigWidget::CMakeToolItemConfigWidget(CMakeToolItemModel *model) + : m_model(model), m_loadingItem(false) +{ + m_displayNameLineEdit = new QLineEdit(this); + + m_binaryChooser = new PathChooser(this); + m_binaryChooser->setExpectedKind(PathChooser::ExistingCommand); + m_binaryChooser->setMinimumWidth(400); + m_binaryChooser->setHistoryCompleter(QLatin1String("Cmake.Command.History")); + + QFormLayout *formLayout = new QFormLayout(this); + formLayout->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow); + formLayout->addRow(new QLabel(tr("Name:")), m_displayNameLineEdit); + formLayout->addRow(new QLabel(tr("Path:")), m_binaryChooser); + + connect(m_binaryChooser, &PathChooser::changed, + this, &CMakeToolItemConfigWidget::store); + connect(m_displayNameLineEdit, &QLineEdit::textChanged, + this, &CMakeToolItemConfigWidget::store); +} + +void CMakeToolItemConfigWidget::store() const +{ + if (!m_loadingItem && m_id.isValid()) + m_model->updateCMakeTool(m_id, m_displayNameLineEdit->text(), m_binaryChooser->fileName()); +} + +void CMakeToolItemConfigWidget::load(const CMakeToolTreeItem *item) +{ + m_loadingItem = true; // avoid intermediate signal handling + m_id = Core::Id(); + if (!item) { + m_loadingItem = false; + return; + } + + // Set values: + m_displayNameLineEdit->setEnabled(!item->m_autodetected); + m_displayNameLineEdit->setText(item->m_name); + + m_binaryChooser->setReadOnly(item->m_autodetected); + m_binaryChooser->setFileName(item->m_executable); + + m_id = item->m_id; + m_loadingItem = false; +} + +// -------------------------------------------------------------------------- +// CMakeToolConfigWidget +// -------------------------------------------------------------------------- + +class CMakeToolConfigWidget : public QWidget +{ +public: + CMakeToolConfigWidget() : m_currentItem(0) + { + m_addButton = new QPushButton(tr("Add"), this); + + m_cloneButton = new QPushButton(tr("Clone"), this); + m_cloneButton->setEnabled(false); + + m_delButton = new QPushButton(tr("Remove"), this); + m_delButton->setEnabled(false); + + m_makeDefButton = new QPushButton(tr("Make Default"), this); + m_makeDefButton->setEnabled(false); + + m_preferNinjaCheckBox = new QCheckBox(tr("Prefer Ninja generator (CMake 2.8.9 or higher required)")); + m_preferNinjaCheckBox->setChecked(CMakeToolManager::preferNinja()); + + m_container = new DetailsWidget(this); + m_container->setState(DetailsWidget::NoSummary); + m_container->setVisible(false); + + m_cmakeToolsView = new QTreeView(this); + m_cmakeToolsView->setModel(&m_model); + m_cmakeToolsView->setUniformRowHeights(true); + m_cmakeToolsView->setRootIsDecorated(false); + m_cmakeToolsView->setSelectionMode(QAbstractItemView::SingleSelection); + m_cmakeToolsView->setSelectionBehavior(QAbstractItemView::SelectRows); + m_cmakeToolsView->expandAll(); + + QHeaderView *header = m_cmakeToolsView->header(); + header->setStretchLastSection(false); + header->setSectionResizeMode(0, QHeaderView::ResizeToContents); + header->setSectionResizeMode(1, QHeaderView::Stretch); + + QVBoxLayout *buttonLayout = new QVBoxLayout(); + buttonLayout->setContentsMargins(0, 0, 0, 0); + buttonLayout->addWidget(m_addButton); + buttonLayout->addWidget(m_cloneButton); + buttonLayout->addWidget(m_delButton); + buttonLayout->addWidget(m_makeDefButton); + buttonLayout->addItem(new QSpacerItem(10, 40, QSizePolicy::Minimum, QSizePolicy::Expanding)); + + QVBoxLayout *verticalLayout = new QVBoxLayout(); + verticalLayout->addWidget(m_cmakeToolsView); + verticalLayout->addWidget(m_container); + verticalLayout->addWidget(m_preferNinjaCheckBox); + + QHBoxLayout *horizontalLayout = new QHBoxLayout(this); + horizontalLayout->addLayout(verticalLayout); + horizontalLayout->addLayout(buttonLayout); + + connect(m_cmakeToolsView->selectionModel(), &QItemSelectionModel::currentChanged, + this, &CMakeToolConfigWidget::currentCMakeToolChanged, Qt::QueuedConnection); + + connect(m_addButton, &QAbstractButton::clicked, + this, &CMakeToolConfigWidget::addCMakeTool); + connect(m_cloneButton, &QAbstractButton::clicked, + this, &CMakeToolConfigWidget::cloneCMakeTool); + connect(m_delButton, &QAbstractButton::clicked, + this, &CMakeToolConfigWidget::removeCMakeTool); + connect(m_makeDefButton, &QAbstractButton::clicked, + this, &CMakeToolConfigWidget::setDefaultCMakeTool); + + m_itemConfigWidget = new CMakeToolItemConfigWidget(&m_model); + m_container->setWidget(m_itemConfigWidget); + } + + void apply(); + void cloneCMakeTool(); + void addCMakeTool(); + void removeCMakeTool(); + void setDefaultCMakeTool(); + void currentCMakeToolChanged(const QModelIndex &newCurrent); + + CMakeToolItemModel m_model; + QTreeView *m_cmakeToolsView; + QPushButton *m_addButton; + QPushButton *m_cloneButton; + QPushButton *m_delButton; + QPushButton *m_makeDefButton; + QCheckBox *m_preferNinjaCheckBox; + DetailsWidget *m_container; + CMakeToolItemConfigWidget *m_itemConfigWidget; + CMakeToolTreeItem *m_currentItem; +}; + +void CMakeToolConfigWidget::apply() +{ + m_model.apply(); + CMakeToolManager::setPreferNinja(m_preferNinjaCheckBox->checkState() == Qt::Checked); +} + +void CMakeToolConfigWidget::cloneCMakeTool() +{ + if (!m_currentItem) + return; + + QModelIndex newItem = m_model.addCMakeTool(tr("Clone of %1").arg(m_currentItem->m_name), + m_currentItem->m_executable, + false); + + m_cmakeToolsView->setCurrentIndex(newItem); +} + +void CMakeToolConfigWidget::addCMakeTool() +{ + QModelIndex newItem = m_model.addCMakeTool(m_model.uniqueDisplayName(tr("New CMake")), + FileName(), false); + + m_cmakeToolsView->setCurrentIndex(newItem); +} + +void CMakeToolConfigWidget::removeCMakeTool() +{ + bool delDef = m_model.defaultItemId() == m_currentItem->m_id; + m_model.removeCMakeTool(m_currentItem->m_id); + m_currentItem = 0; + + if (delDef) { + CMakeToolTreeItem *it = static_cast(m_model.autoGroupItem()->firstChild()); + if (!it) + it = static_cast(m_model.manualGroupItem()->firstChild()); + if (it) + m_model.setDefaultItemId(it->m_id); + } + + TreeItem *newCurrent = m_model.manualGroupItem()->lastChild(); + if (!newCurrent) + newCurrent = m_model.autoGroupItem()->lastChild(); + + if (newCurrent) + m_cmakeToolsView->setCurrentIndex(newCurrent->index()); +} + +void CMakeToolConfigWidget::setDefaultCMakeTool() +{ + if (!m_currentItem) + return; + + m_model.setDefaultItemId(m_currentItem->m_id); + m_makeDefButton->setEnabled(false); +} + +void CMakeToolConfigWidget::currentCMakeToolChanged(const QModelIndex &newCurrent) +{ + m_currentItem = m_model.cmakeToolItem(newCurrent); + m_itemConfigWidget->load(m_currentItem); + m_container->setVisible(m_currentItem); + m_cloneButton->setEnabled(m_currentItem); + m_delButton->setEnabled(m_currentItem && !m_currentItem->m_autodetected); + m_makeDefButton->setEnabled(m_currentItem && (!m_model.defaultItemId().isValid() || m_currentItem->m_id != m_model.defaultItemId())); +} + ///// // CMakeSettingsPage //// - -CMakeSettingsPage::CMakeSettingsPage() - : m_pathchooser(0), m_preferNinja(0) +CMakeSettingsPage::CMakeSettingsPage() : m_widget(0) { setId("Z.CMake"); setDisplayName(tr("CMake")); @@ -57,132 +545,30 @@ CMakeSettingsPage::CMakeSettingsPage() setDisplayCategory(QCoreApplication::translate("ProjectExplorer", ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_TR_CATEGORY)); setCategoryIcon(QLatin1String(ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_CATEGORY_ICON)); - - QSettings *settings = Core::ICore::settings(); - settings->beginGroup(QLatin1String("CMakeSettings")); - m_cmakeValidatorForUser.setCMakeExecutable(settings->value(QLatin1String("cmakeExecutable")).toString()); - settings->endGroup(); - - m_cmakeValidatorForSystem.setCMakeExecutable(findCmakeExecutable()); -} - -bool CMakeSettingsPage::isCMakeExecutableValid() const -{ - if (m_cmakeValidatorForUser.isValid()) - return true; - - return m_cmakeValidatorForSystem.isValid(); } CMakeSettingsPage::~CMakeSettingsPage() { - m_cmakeValidatorForUser.cancel(); - m_cmakeValidatorForSystem.cancel(); -} - -QString CMakeSettingsPage::findCmakeExecutable() const -{ - return Utils::Environment::systemEnvironment().searchInPath(QLatin1String("cmake")).toString(); } QWidget *CMakeSettingsPage::widget() { - if (!m_widget) { - m_widget = new QWidget; - QFormLayout *formLayout = new QFormLayout(m_widget); - formLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow); - m_pathchooser = new Utils::PathChooser; - m_pathchooser->setExpectedKind(Utils::PathChooser::ExistingCommand); - m_pathchooser->setHistoryCompleter(QLatin1String("Cmake.Command.History")); - formLayout->addRow(tr("Executable:"), m_pathchooser); - formLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Ignored, QSizePolicy::MinimumExpanding)); - - m_preferNinja = new QCheckBox(tr("Prefer Ninja generator (CMake 2.8.9 or higher required)")); - formLayout->addRow(m_preferNinja); - } - m_pathchooser->setPath(m_cmakeValidatorForUser.cmakeExecutable()); - m_preferNinja->setChecked(preferNinja()); + if (!m_widget) + m_widget = new CMakeToolConfigWidget; return m_widget; } -void CMakeSettingsPage::saveSettings() const -{ - QSettings *settings = Core::ICore::settings(); - settings->beginGroup(QLatin1String("CMakeSettings")); - settings->setValue(QLatin1String("cmakeExecutable"), m_cmakeValidatorForUser.cmakeExecutable()); - settings->setValue(QLatin1String("preferNinja"), m_preferNinja->isChecked()); - settings->endGroup(); -} - void CMakeSettingsPage::apply() { - if (!m_pathchooser) // page was never shown - return; - if (m_cmakeValidatorForUser.cmakeExecutable() != m_pathchooser->path()) - m_cmakeValidatorForUser.setCMakeExecutable(m_pathchooser->path()); - saveSettings(); + QTC_ASSERT(m_widget, return); + m_widget->m_itemConfigWidget->store(); + m_widget->m_model.apply(); } void CMakeSettingsPage::finish() { delete m_widget; -} - -QString CMakeSettingsPage::cmakeExecutable() const -{ - if (!isCMakeExecutableValid()) - return QString(); - - if (m_cmakeValidatorForUser.isValid()) - return m_cmakeValidatorForUser.cmakeExecutable(); - if (m_cmakeValidatorForSystem.isValid()) - return m_cmakeValidatorForSystem.cmakeExecutable(); - return QString(); -} - -void CMakeSettingsPage::setCMakeExecutable(const QString &executable) -{ - if (m_cmakeValidatorForUser.cmakeExecutable() == executable) - return; - m_cmakeValidatorForUser.setCMakeExecutable(executable); -} - -bool CMakeSettingsPage::hasCodeBlocksMsvcGenerator() const -{ - if (m_cmakeValidatorForUser.isValid()) - return m_cmakeValidatorForUser.hasCodeBlocksMsvcGenerator(); - if (m_cmakeValidatorForSystem.isValid()) - return m_cmakeValidatorForSystem.hasCodeBlocksMsvcGenerator(); - return false; -} - -bool CMakeSettingsPage::hasCodeBlocksNinjaGenerator() const -{ - if (m_cmakeValidatorForUser.isValid()) - return m_cmakeValidatorForUser.hasCodeBlocksNinjaGenerator(); - if (m_cmakeValidatorForSystem.isValid()) - return m_cmakeValidatorForSystem.hasCodeBlocksNinjaGenerator(); - return false; -} - -bool CMakeSettingsPage::preferNinja() const -{ - QSettings *settings = Core::ICore::settings(); - settings->beginGroup(QLatin1String("CMakeSettings")); - const bool r = settings->value(QLatin1String("preferNinja"), false).toBool(); - settings->endGroup(); - return r; -} - -TextEditor::Keywords CMakeSettingsPage::keywords() -{ - if (m_cmakeValidatorForUser.isValid()) - return m_cmakeValidatorForUser.keywords(); - - if (m_cmakeValidatorForSystem.isValid()) - return m_cmakeValidatorForSystem.keywords(); - - return TextEditor::Keywords(QStringList(), QStringList(), QMap()); + m_widget = 0; } } // namespace Internal diff --git a/src/plugins/cmakeprojectmanager/cmakesettingspage.h b/src/plugins/cmakeprojectmanager/cmakesettingspage.h index 813482169c4..1ff868f485c 100644 --- a/src/plugins/cmakeprojectmanager/cmakesettingspage.h +++ b/src/plugins/cmakeprojectmanager/cmakesettingspage.h @@ -32,18 +32,16 @@ #include #include -#include #include #include "cmaketool.h" -QT_FORWARD_DECLARE_CLASS(QLabel) -QT_FORWARD_DECLARE_CLASS(QCheckBox) - namespace CMakeProjectManager { namespace Internal { +class CMakeToolConfigWidget; + class CMakeSettingsPage : public Core::IOptionsPage { Q_OBJECT @@ -56,24 +54,8 @@ public: void apply(); void finish(); - QString cmakeExecutable() const; - void setCMakeExecutable(const QString &executable); - bool isCMakeExecutableValid() const; - bool hasCodeBlocksMsvcGenerator() const; - bool hasCodeBlocksNinjaGenerator() const; - bool preferNinja() const; - - TextEditor::Keywords keywords(); - private: - void saveSettings() const; - QString findCmakeExecutable() const; - - QPointer m_widget; - Utils::PathChooser *m_pathchooser; - QCheckBox *m_preferNinja; - CMakeTool m_cmakeValidatorForUser; - CMakeTool m_cmakeValidatorForSystem; + CMakeToolConfigWidget *m_widget; }; } // namespace Internal diff --git a/src/plugins/cmakeprojectmanager/cmaketool.cpp b/src/plugins/cmakeprojectmanager/cmaketool.cpp index 70206d46bf6..ac136673892 100644 --- a/src/plugins/cmakeprojectmanager/cmaketool.cpp +++ b/src/plugins/cmakeprojectmanager/cmaketool.cpp @@ -30,19 +30,49 @@ #include "cmaketool.h" +#include + #include #include #include +#include -using namespace CMakeProjectManager::Internal; +using namespace CMakeProjectManager; + +const char CMAKE_INFORMATION_ID[] = "Id"; +const char CMAKE_INFORMATION_COMMAND[] = "Binary"; +const char CMAKE_INFORMATION_DISPLAYNAME[] = "DisplayName"; +const char CMAKE_INFORMATION_AUTODETECTED[] = "AutoDetected"; /////////////////////////// // CMakeTool /////////////////////////// -CMakeTool::CMakeTool() - : m_state(Invalid), m_process(0), m_hasCodeBlocksMsvcGenerator(false), m_hasCodeBlocksNinjaGenerator(false) +CMakeTool::CMakeTool(Detection d, const Core::Id &id) + : m_state(Invalid), m_process(0), + m_isAutoDetected(d == AutoDetection), + m_hasCodeBlocksMsvcGenerator(false), + m_hasCodeBlocksNinjaGenerator(false), + m_id(id) { + //make sure every CMakeTool has a valid ID + if (!m_id.isValid()) + createId(); +} +CMakeTool::CMakeTool(const QVariantMap &map, bool fromSdk) + : m_state(Invalid), m_process(0), + m_isAutoDetected(fromSdk), + m_hasCodeBlocksMsvcGenerator(false), + m_hasCodeBlocksNinjaGenerator(false) +{ + m_id = Core::Id::fromSetting(map.value(QLatin1String(CMAKE_INFORMATION_ID))); + m_displayName = map.value(QLatin1String(CMAKE_INFORMATION_DISPLAYNAME)).toString(); + + //loading a CMakeTool from SDK is always autodetection + if (!fromSdk) + m_isAutoDetected = map.value(QLatin1String(CMAKE_INFORMATION_AUTODETECTED), false).toBool(); + + setCMakeExecutable(Utils::FileName::fromUserInput(map.value(QLatin1String(CMAKE_INFORMATION_COMMAND)).toString())); } CMakeTool::~CMakeTool() @@ -60,14 +90,14 @@ void CMakeTool::cancel() } } -void CMakeTool::setCMakeExecutable(const QString &executable) +void CMakeTool::setCMakeExecutable(const Utils::FileName &executable) { cancel(); m_process = new QProcess(); connect(m_process, static_cast(&QProcess::finished), this, &CMakeTool::finished); m_executable = executable; - QFileInfo fi(m_executable); + QFileInfo fi = m_executable.toFileInfo(); if (fi.exists() && fi.isExecutable()) { // Run it to find out more m_state = CMakeTool::RunningBasic; @@ -121,20 +151,39 @@ void CMakeTool::finished(int exitCode) bool CMakeTool::isValid() const { - if (m_state == CMakeTool::Invalid) + if (m_state == CMakeTool::Invalid || !m_id.isValid()) return false; - if (m_state == CMakeTool::RunningBasic) - m_process->waitForFinished(); + if (m_state == CMakeTool::RunningBasic) { + if (!m_process->waitForFinished(10000)) { + return false; + } + } return (m_state != CMakeTool::Invalid); } +void CMakeTool::createId() +{ + QTC_ASSERT(!m_id.isValid(), return); + m_id = Core::Id::fromString(QUuid::createUuid().toString()); +} + +QVariantMap CMakeTool::toMap() const +{ + QVariantMap data; + data.insert(QLatin1String(CMAKE_INFORMATION_DISPLAYNAME), m_displayName); + data.insert(QLatin1String(CMAKE_INFORMATION_ID), m_id.toSetting()); + data.insert(QLatin1String(CMAKE_INFORMATION_COMMAND), m_executable.toString()); + data.insert(QLatin1String(CMAKE_INFORMATION_AUTODETECTED), m_isAutoDetected); + return data; +} + bool CMakeTool::startProcess(const QStringList &args) { - m_process->start(m_executable, args); + m_process->start(m_executable.toString(), args); return m_process->waitForStarted(2000); } -QString CMakeTool::cmakeExecutable() const +Utils::FileName CMakeTool::cmakeExecutable() const { return m_executable; } @@ -165,6 +214,11 @@ TextEditor::Keywords CMakeTool::keywords() return TextEditor::Keywords(m_variables, m_functions, m_functionArgs); } +bool CMakeTool::isAutoDetected() const +{ + return m_isAutoDetected; +} + static void extractKeywords(const QByteArray &input, QStringList *destination) { if (!destination) @@ -212,6 +266,17 @@ QString CMakeTool::formatFunctionDetails(const QString &command, const QString & .arg(command.toHtmlEscaped(), args.toHtmlEscaped()); } +QString CMakeTool::displayName() const +{ + return m_displayName; +} + +void CMakeTool::setDisplayName(const QString &displayName) +{ + m_displayName = displayName; +} + + void CMakeTool::parseFunctionDetailsOutput(const QByteArray &output) { QStringList cmakeFunctionsList = m_functions; diff --git a/src/plugins/cmakeprojectmanager/cmaketool.h b/src/plugins/cmakeprojectmanager/cmaketool.h index 1609d4407b9..9c98c0949e7 100644 --- a/src/plugins/cmakeprojectmanager/cmaketool.h +++ b/src/plugins/cmakeprojectmanager/cmaketool.h @@ -31,21 +31,31 @@ #ifndef CMAKEVALIDATOR_H #define CMAKEVALIDATOR_H +#include "cmake_global.h" + +#include +#include +#include + #include #include #include -#include QT_FORWARD_DECLARE_CLASS(QProcess) namespace CMakeProjectManager { -namespace Internal { -class CMakeTool : public QObject +class CMAKE_EXPORT CMakeTool : public QObject { Q_OBJECT public: - CMakeTool(); + enum Detection { + ManualDetection, + AutoDetection + }; + + explicit CMakeTool(Detection d, const Core::Id &id = Core::Id()); + explicit CMakeTool(const QVariantMap &map, bool fromSdk); ~CMakeTool(); enum State { Invalid, RunningBasic, RunningFunctionList, RunningFunctionDetails, @@ -53,15 +63,23 @@ public: void cancel(); bool isValid() const; - void setCMakeExecutable(const QString &executable); - QString cmakeExecutable() const; + Core::Id id() const { return m_id; } + QVariantMap toMap () const; + + void setCMakeExecutable(const Utils::FileName &executable); + Utils::FileName cmakeExecutable() const; bool hasCodeBlocksMsvcGenerator() const; bool hasCodeBlocksNinjaGenerator() const; TextEditor::Keywords keywords(); + bool isAutoDetected() const; + QString displayName() const; + void setDisplayName(const QString &displayName); + private slots: void finished(int exitCode); private: + void createId(); void finishStep(); void startNextStep(); bool startProcess(const QStringList &args); @@ -73,16 +91,20 @@ private: State m_state; QProcess *m_process; + Utils::FileName m_executable; + + bool m_isAutoDetected; bool m_hasCodeBlocksMsvcGenerator; bool m_hasCodeBlocksNinjaGenerator; - QString m_executable; QMap m_functionArgs; QStringList m_variables; QStringList m_functions; + + Core::Id m_id; + QString m_displayName; }; -} // namespace Internal } // namespace CMakeProjectManager #endif // CMAKEVALIDATOR_H diff --git a/src/plugins/cmakeprojectmanager/cmaketoolmanager.cpp b/src/plugins/cmakeprojectmanager/cmaketoolmanager.cpp new file mode 100644 index 00000000000..15d7cf48302 --- /dev/null +++ b/src/plugins/cmakeprojectmanager/cmaketoolmanager.cpp @@ -0,0 +1,392 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Canonical Ltd. +** Contact: http://www.qt.io/licensing +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms and +** conditions see http://www.qt.io/terms-conditions. For further information +** use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 or version 3 as published by the Free +** Software Foundation and appearing in the file LICENSE.LGPLv21 and +** LICENSE.LGPLv3 included in the packaging of this file. Please review the +** following information to ensure the GNU Lesser General Public License +** requirements will be met: https://www.gnu.org/licenses/lgpl.html and +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, The Qt Company gives you certain additional +** rights. These rights are described in The Qt Company LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +****************************************************************************/ + +#include "cmaketoolmanager.h" + +#include +#include +#include +#include +#include + +#include +#include +#include + +using namespace Core; +using namespace Utils; + +namespace CMakeProjectManager { + +const char CMAKETOOL_COUNT_KEY[] = "CMakeTools.Count"; +const char CMAKETOOL_DEFAULT_KEY[] = "CMakeTools.Default"; +const char CMAKETOOL_PREFER_NINJA_KEY[] = "CMakeTools.PreferNinja"; +const char CMAKETOOL_DATA_KEY[] = "CMakeTools."; +const char CMAKETOOL_FILE_VERSION_KEY[] = "Version"; +const char CMAKETOOL_FILENAME[] = "/qtcreator/cmaketools.xml"; + +class CMakeToolManagerPrivate +{ + +public: + CMakeToolManagerPrivate() : + m_preferNinja(false), + m_writer(0) + {} + + bool m_preferNinja; + Id m_defaultCMake; + QList m_cmakeTools; + PersistentSettingsWriter *m_writer; +}; +static CMakeToolManagerPrivate *d = 0; + +static void addCMakeTool(CMakeTool *item) +{ + QTC_ASSERT(item->id().isValid(), return); + + //set the first registered cmake tool as default if there is not already one + if (!d->m_defaultCMake.isValid()) + d->m_defaultCMake = item->id(); + + d->m_cmakeTools.append(item); +} + +static FileName userSettingsFileName() +{ + QFileInfo settingsLocation(ICore::settings()->fileName()); + return FileName::fromString(settingsLocation.absolutePath() + QLatin1String(CMAKETOOL_FILENAME)); +} + +static QList readCMakeTools(const FileName &fileName, Core::Id *defaultId, bool fromSDK) +{ + PersistentSettingsReader reader; + if (!reader.load(fileName)) + return QList(); + + QVariantMap data = reader.restoreValues(); + + // Check version + int version = data.value(QLatin1String(CMAKETOOL_FILE_VERSION_KEY), 0).toInt(); + if (version < 1) + return QList(); + + QList loaded; + + int count = data.value(QLatin1String(CMAKETOOL_COUNT_KEY), 0).toInt(); + for (int i = 0; i < count; ++i) { + const QString key = QString::fromLatin1(CMAKETOOL_DATA_KEY) + QString::number(i); + if (!data.contains(key)) + continue; + + const QVariantMap dbMap = data.value(key).toMap(); + CMakeTool *item = new CMakeTool(dbMap,fromSDK); + if (item->isAutoDetected()) { + if (!item->cmakeExecutable().toFileInfo().isExecutable()) { + qWarning() << QString::fromLatin1("CMakeTool \"%1\" (%2) read from \"%3\" dropped since the command is not executable.") + .arg(item->cmakeExecutable().toUserOutput(), item->id().toString(), fileName.toUserOutput()); + delete item; + continue; + } + } + + loaded.append(item); + } + + *defaultId = Id::fromSetting(data.value(QLatin1String(CMAKETOOL_DEFAULT_KEY), defaultId->toSetting())); + d->m_preferNinja= data.value(QLatin1String(CMAKETOOL_PREFER_NINJA_KEY), d->m_preferNinja).toBool(); + + return loaded; +} + +static void readAndDeleteLegacyCMakeSettings () +{ + // restore the legacy cmake + QSettings *settings = ICore::settings(); + settings->beginGroup(QLatin1String("CMakeSettings")); + + FileName exec = FileName::fromUserInput(settings->value(QLatin1String("cmakeExecutable")).toString()); + if (!exec.toFileInfo().isExecutable()) + return; + + CMakeTool *item = CMakeToolManager::findByCommand(exec); + if (!item) { + item = new CMakeTool(CMakeTool::ManualDetection); + item->setCMakeExecutable(exec); + item->setDisplayName(CMakeToolManager::tr("CMake at %1").arg(item->cmakeExecutable().toUserOutput())); + + if (!CMakeToolManager::registerCMakeTool(item)) { + delete item; + item = 0; + } + } + + //this setting used to be the default cmake, make sure it is again + if (item) + d->m_defaultCMake = item->id(); + + //read the legacy ninja setting, if its not available use the current value + d->m_preferNinja = settings->value(QLatin1String("preferNinja"), d->m_preferNinja).toBool(); + + settings->remove(QString()); + settings->endGroup(); +} + +static QList autoDetectCMakeTools() +{ + QStringList filters; + filters.append(QStringLiteral("cmake")); + + QList suspects; + + QStringList path = Environment::systemEnvironment().path(); + path.removeDuplicates(); + QDir dir; + dir.setNameFilters(filters); + dir.setFilter(QDir::Files | QDir::Executable); + foreach (const QString &base, path) { + dir.setPath(base); + foreach (const QString &entry, dir.entryList()) + suspects.append(FileName::fromString(dir.absoluteFilePath(entry))); + } + + QList found; + foreach (const FileName &command, suspects) { + CMakeTool *item = new CMakeTool(CMakeTool::AutoDetection); + item->setCMakeExecutable(command); + item->setDisplayName(CMakeToolManager::tr("System CMake at %1").arg(command.toUserOutput())); + + found.append(item); + } + + return found; +} + +CMakeToolManager::CMakeToolManager(QObject *parent) : QObject(parent) +{ + d = new CMakeToolManagerPrivate; + d->m_writer = new PersistentSettingsWriter(userSettingsFileName(), QStringLiteral("QtCreatorCMakeTools")); + connect(ICore::instance(), &ICore::saveSettingsRequested, + this, &CMakeToolManager::saveCMakeTools); +} + +CMakeToolManager::~CMakeToolManager() +{ + delete d->m_writer; + delete d; + d = 0; +} + +QList CMakeToolManager::cmakeTools() +{ + return d->m_cmakeTools; +} + +void CMakeToolManager::setPreferNinja(bool set) +{ + d->m_preferNinja = set; +} + +bool CMakeToolManager::preferNinja() +{ + return d->m_preferNinja; +} + +Id CMakeToolManager::registerOrFindCMakeTool(const FileName &command) +{ + CMakeTool *cmake = findByCommand(command); + if (cmake) + return cmake->id(); + + cmake = new CMakeTool(CMakeTool::ManualDetection); + cmake->setCMakeExecutable(command); + cmake->setDisplayName(tr("CMake at %1").arg(command.toUserOutput())); + addCMakeTool(cmake); + + return cmake->id(); +} + +bool CMakeToolManager::registerCMakeTool(CMakeTool *tool) +{ + if (!tool || d->m_cmakeTools.contains(tool)) + return true; + + QTC_ASSERT(tool->id().isValid(),return false); + + //make sure the same id was not used before + foreach (CMakeTool *current, d->m_cmakeTools) { + if (tool->id() == current->id()) + return false; + } + + addCMakeTool(tool); + return true; +} + +void CMakeToolManager::deregisterCMakeTool(const Id &id) +{ + int idx = Utils::indexOf(d->m_cmakeTools, Utils::equal(&CMakeTool::id, id)); + if (idx >= 0) { + CMakeTool *toRemove = d->m_cmakeTools.takeAt(idx); + if (toRemove->id() == d->m_defaultCMake) { + if (d->m_cmakeTools.isEmpty()) + d->m_defaultCMake = Id(); + else + d->m_defaultCMake = d->m_cmakeTools.first()->id(); + } + delete toRemove; + } +} + +CMakeTool *CMakeToolManager::defaultCMakeTool() +{ + CMakeTool *tool = findById(d->m_defaultCMake); + if (!tool) { + //if the id is not valid, we set the firstly registered one as default + if (!d->m_cmakeTools.isEmpty()) { + d->m_defaultCMake = d->m_cmakeTools.first()->id(); + return d->m_cmakeTools.first(); + } + } + return tool; +} + +void CMakeToolManager::setDefaultCMakeTool(const Id &id) +{ + if (d->m_defaultCMake == id) + return; + + if (findById(id)) + d->m_defaultCMake = id; +} + +CMakeTool *CMakeToolManager::findByCommand(const FileName &command) +{ + return Utils::findOrDefault(d->m_cmakeTools, Utils::equal(&CMakeTool::cmakeExecutable, command)); +} + +CMakeTool *CMakeToolManager::findById(const Id &id) +{ + return Utils::findOrDefault(d->m_cmakeTools, Utils::equal(&CMakeTool::id, id)); +} + +void CMakeToolManager::restoreCMakeTools() +{ + Core::Id defaultId; + + QFileInfo systemSettingsFile(ICore::settings(QSettings::SystemScope)->fileName()); + FileName sdkSettingsFile = FileName::fromString(systemSettingsFile.absolutePath() + + QLatin1String(CMAKETOOL_FILENAME)); + + QList toolsToRegister = readCMakeTools(sdkSettingsFile, &defaultId, true); + + //read the tools from the user settings file + QList readTools = readCMakeTools(userSettingsFileName(), &defaultId, false); + + //autodetect tools + QList autoDetected = autoDetectCMakeTools(); + + //filter out the tools that were stored in SDK + for (int i = readTools.size() - 1; i >= 0; i--) { + CMakeTool *currTool = readTools.takeAt(i); + if (Utils::anyOf(toolsToRegister, Utils::equal(&CMakeTool::id, currTool->id()))) { + delete currTool; + } else { + //if the current tool is marked as autodetected and NOT in the autodetected list, + //it is a leftover SDK provided tool. The user will not be able to edit it, + //so we automatically drop it + if (currTool->isAutoDetected()) { + if (!Utils::anyOf(autoDetected, + Utils::equal(&CMakeTool::cmakeExecutable, currTool->cmakeExecutable()))) { + + qWarning() << QString::fromLatin1("Previously SDK provided CMakeTool \"%1\" (%2) dropped.") + .arg(currTool->cmakeExecutable().toUserOutput(), currTool->id().toString()); + + delete currTool; + continue; + } + } + toolsToRegister.append(currTool); + } + } + + //filter out the tools that are already known + for (int i = autoDetected.size() - 1; i >= 0; i--) { + CMakeTool *currTool = autoDetected.takeAt(i); + if (Utils::anyOf(toolsToRegister, + Utils::equal(&CMakeTool::cmakeExecutable, currTool->cmakeExecutable()))) + delete currTool; + else + toolsToRegister.append(currTool); + } + + // Store all tools + foreach (CMakeTool *current, toolsToRegister) { + if (!registerCMakeTool(current)) { + //this should never happen, but lets make sure we do not leak memory + qWarning() << QString::fromLatin1("CMakeTool \"%1\" (%2) dropped.") + .arg(current->cmakeExecutable().toUserOutput(), current->id().toString()); + + delete current; + } + } + + if (CMakeToolManager::findById(defaultId)) + d->m_defaultCMake = defaultId; + + // restore the legacy cmake settings only once and keep them around + readAndDeleteLegacyCMakeSettings(); +} + +void CMakeToolManager::saveCMakeTools() +{ + QTC_ASSERT(d->m_writer, return); + QVariantMap data; + data.insert(QLatin1String(CMAKETOOL_FILE_VERSION_KEY), 1); + data.insert(QLatin1String(CMAKETOOL_DEFAULT_KEY), d->m_defaultCMake.toSetting()); + data.insert(QLatin1String(CMAKETOOL_PREFER_NINJA_KEY), d->m_preferNinja); + + int count = 0; + foreach (CMakeTool *item, d->m_cmakeTools) { + QFileInfo fi = item->cmakeExecutable().toFileInfo(); + + if (fi.isExecutable()) { + QVariantMap tmp = item->toMap(); + if (tmp.isEmpty()) + continue; + data.insert(QString::fromLatin1(CMAKETOOL_DATA_KEY) + QString::number(count), tmp); + ++count; + } + } + data.insert(QLatin1String(CMAKETOOL_COUNT_KEY), count); + d->m_writer->save(data, ICore::mainWindow()); +} + +} // namespace CMakeProjectManager diff --git a/src/plugins/cmakeprojectmanager/cmaketoolmanager.h b/src/plugins/cmakeprojectmanager/cmaketoolmanager.h new file mode 100644 index 00000000000..8fb104f0d87 --- /dev/null +++ b/src/plugins/cmakeprojectmanager/cmaketoolmanager.h @@ -0,0 +1,71 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Canonical Ltd. +** Contact: http://www.qt.io/licensing +** +** This file is part of Qt Creator. +** +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms and +** conditions see http://www.qt.io/terms-conditions. For further information +** use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 or version 3 as published by the Free +** Software Foundation and appearing in the file LICENSE.LGPLv21 and +** LICENSE.LGPLv3 included in the packaging of this file. Please review the +** following information to ensure the GNU Lesser General Public License +** requirements will be met: https://www.gnu.org/licenses/lgpl.html and +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, The Qt Company gives you certain additional +** rights. These rights are described in The Qt Company LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +****************************************************************************/ + +#ifndef CMAKEPROJECTMANAGER_CMAKETOOLMANAGER_H +#define CMAKEPROJECTMANAGER_CMAKETOOLMANAGER_H + +#include "cmake_global.h" +#include "cmaketool.h" + +#include +#include + +#include + +namespace CMakeProjectManager { + +class CMAKE_EXPORT CMakeToolManager : public QObject +{ + Q_OBJECT +public: + CMakeToolManager(QObject *parent); + ~CMakeToolManager(); + + static QList cmakeTools(); + static void setPreferNinja(bool set); + static bool preferNinja(); + + static Core::Id registerOrFindCMakeTool(const Utils::FileName &command); + static bool registerCMakeTool(CMakeTool *tool); + static void deregisterCMakeTool(const Core::Id &id); + + static CMakeTool *defaultCMakeTool(); + static void setDefaultCMakeTool(const Core::Id &id); + static CMakeTool *findByCommand(const Utils::FileName &command); + static CMakeTool *findById(const Core::Id &id); + static void restoreCMakeTools(); + +private: + static void saveCMakeTools(); +}; + +} // namespace CMakeProjectManager + +#endif // CMAKEPROJECTMANAGER_CMAKETOOLMANAGER_H