CMakeProjectManager: Rework CMakeFormatter

Use PagedSettings, make setup more local, remove Q_OBJECT

Change-Id: I9e91f9e63ed8ad15749323bd039d118562dba1a6
Reviewed-by: Cristian Adam <cristian.adam@qt.io>

src/plugins/cmakeprojectmanager/cmakeformatter.cpp

@@ -4,7 +4,6 @@
 
 #include "cmakeformatter.h"
 
-#include "cmakeformattersettings.h"
 #include "cmakeprojectconstants.h"
 #include "cmakeprojectmanagertr.h"
 
@@ -12,62 +11,198 @@
 #include <coreplugin/actionmanager/actionmanager.h>
 #include <coreplugin/actionmanager/command.h>
 #include <coreplugin/coreconstants.h>
+#include <coreplugin/dialogs/ioptionspage.h>
 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/editormanager/ieditor.h>
+#include <coreplugin/icore.h>
 #include <coreplugin/idocument.h>
 
 #include <projectexplorer/project.h>
 #include <projectexplorer/projectnodes.h>
 #include <projectexplorer/projecttree.h>
 
+#include <texteditor/command.h>
 #include <texteditor/formattexteditor.h>
 #include <texteditor/texteditor.h>
 
-#include <QAction>
-#include <QVersionNumber>
+#include <utils/algorithm.h>
+#include <utils/genericconstants.h>
+#include <utils/layoutbuilder.h>
+#include <utils/mimeutils.h>
 
+#include <QMenu>
+
+using namespace Core;
 using namespace TextEditor;
+using namespace Utils;
 
-namespace CMakeProjectManager {
-namespace Internal {
+namespace CMakeProjectManager::Internal {
 
-void CMakeFormatter::updateActions(Core::IEditor *editor)
+class CMakeFormatterPrivate : public PagedSettings
 {
-    const bool enabled = editor && CMakeFormatterSettings::instance()->isApplicable(editor->document());
-    m_formatFile->setEnabled(enabled);
+public:
+    CMakeFormatterPrivate()
+    {
+        setSettingsGroups(Constants::CMAKEFORMATTER_SETTINGS_GROUP,
+                          Constants::CMAKEFORMATTER_GENERAL_GROUP);
+
+        setId(Constants::Settings::FORMATTER_ID);
+        setDisplayName(Tr::tr("Formatter"));
+        setDisplayCategory("CMake");
+        setCategory(Constants::Settings::CATEGORY);
+
+        registerAspect(&command);
+        command.setSettingsKey("autoFormatCommand");
+        command.setDisplayStyle(StringAspect::PathChooserDisplay);
+        command.setDefaultValue("cmake-format");
+        command.setExpectedKind(PathChooser::ExistingCommand);
+
+        registerAspect(&autoFormatOnSave);
+        autoFormatOnSave.setSettingsKey("autoFormatOnSave");
+        autoFormatOnSave.setLabelText(Tr::tr("Enable auto format on file save"));
+
+        registerAspect(&autoFormatOnlyCurrentProject);
+        autoFormatOnlyCurrentProject.setSettingsKey("autoFormatOnlyCurrentProject");
+        autoFormatOnlyCurrentProject.setDefaultValue(true);
+        autoFormatOnlyCurrentProject.setLabelText(Tr::tr("Restrict to files contained in the current project"));
+
+        registerAspect(&autoFormatMime);
+        autoFormatMime.setSettingsKey("autoFormatMime");
+        autoFormatMime.setDefaultValue("text/x-cmake");
+        autoFormatMime.setLabelText(Tr::tr("Restrict to MIME types:"));
+
+        setLayouter([this](QWidget *widget) {
+            using namespace Layouting;
+            Column {
+                Row { Tr::tr("CMakeFormat command:"), command },
+                Space(10),
+                Group {
+                    title(Tr::tr("Automatic Formatting on File Save")),
+                    autoFormatOnSave.groupChecker(),
+                    Form {
+                        autoFormatMime, br,
+                        Span(2, autoFormatOnlyCurrentProject)
+                    }
+                },
+                st
+            }.attachTo(widget);
+        });
+
+        ActionContainer *menu = ActionManager::createMenu(Constants::CMAKEFORMATTER_MENU_ID);
+        menu->menu()->setTitle(Tr::tr("CMakeFormatter"));
+        menu->setOnAllDisabledBehavior(ActionContainer::Show);
+        ActionManager::actionContainer(Core::Constants::M_TOOLS)->addMenu(menu);
+
+        Core::Command *cmd = ActionManager::registerAction(&formatFile, Constants::CMAKEFORMATTER_ACTION_ID);
+        connect(&formatFile, &QAction::triggered, this, [this] {
+            TextEditor::formatCurrentFile(formatCommand());
+        });
+
+        ActionManager::actionContainer(Constants::CMAKEFORMATTER_MENU_ID)->addAction(cmd);
+
+        auto updateActions = [this] {
+            auto editor = EditorManager::currentEditor();
+            formatFile.setEnabled(editor && isApplicable(editor->document()));
+        };
+
+        connect(&autoFormatMime, &Utils::StringAspect::changed,
+                this, updateActions);
+        connect(EditorManager::instance(), &EditorManager::currentEditorChanged,
+                this, updateActions);
+        connect(EditorManager::instance(), &EditorManager::aboutToSave,
+                this, &CMakeFormatterPrivate::applyIfNecessary);
+
+        readSettings(ICore::settings());
+    }
+
+    bool isApplicable(const IDocument *document) const;
+
+    void applyIfNecessary(IDocument *document) const;
+
+    TextEditor::Command formatCommand() const
+    {
+        TextEditor::Command cmd;
+        cmd.setExecutable(command.filePath());
+        cmd.setProcessing(TextEditor::Command::FileProcessing);
+        cmd.addOption("--in-place");
+        cmd.addOption("%file");
+        return cmd;
+    }
+
+    StringAspect command;
+    BoolAspect autoFormatOnSave;
+    BoolAspect autoFormatOnlyCurrentProject;
+    StringAspect autoFormatMime;
+
+    QAction formatFile{Tr::tr("Format &Current File")};
+};
+
+bool CMakeFormatterPrivate::isApplicable(const IDocument *document) const
+{
+    if (!document)
+        return false;
+
+    if (autoFormatMime.value().isEmpty())
+        return true;
+
+    const QStringList allowedMimeTypes = autoFormatMime.value().split(';');
+    const MimeType documentMimeType = Utils::mimeTypeForName(document->mimeType());
+
+    return anyOf(allowedMimeTypes, [&documentMimeType](const QString &mime) {
+        return documentMimeType.inherits(mime);
+    });
 }
 
-void CMakeFormatter::formatFile()
+void CMakeFormatterPrivate::applyIfNecessary(IDocument *document) const
 {
-    formatCurrentFile(command());
+    if (!autoFormatOnSave.value())
+        return;
+
+    if (!document)
+        return;
+
+    if (!isApplicable(document))
+        return;
+
+    // Check if file is contained in the current project (if wished)
+    if (autoFormatOnlyCurrentProject.value()) {
+        const ProjectExplorer::Project *pro = ProjectExplorer::ProjectTree::currentProject();
+        if (!pro || pro->files([document](const ProjectExplorer::Node *n) {
+                      return ProjectExplorer::Project::SourceFiles(n)
+                             && n->filePath() == document->filePath();
+                  }).isEmpty()) {
+            return;
+        }
+    }
+
+    TextEditor::Command command = formatCommand();
+    if (!command.isValid())
+        return;
+
+    const QList<IEditor *> editors = DocumentModel::editorsForDocument(document);
+    if (editors.isEmpty())
+        return;
+
+    IEditor *currentEditor = EditorManager::currentEditor();
+    IEditor *editor = editors.contains(currentEditor) ? currentEditor : editors.first();
+    if (auto widget = TextEditorWidget::fromEditor(editor))
+        TextEditor::formatEditor(widget, command);
 }
 
-Command CMakeFormatter::command() const
+// CMakeFormatter
+
+CMakeFormatter::CMakeFormatter()
+    : d(new CMakeFormatterPrivate)
+{}
+
+CMakeFormatter::~CMakeFormatter()
 {
-    Command command;
-    command.setExecutable(CMakeFormatterSettings::instance()->command());
-    command.setProcessing(Command::FileProcessing);
-    command.addOption("--in-place");
-    command.addOption("%file");
-    return command;
+    delete d;
 }
 
-bool CMakeFormatter::isApplicable(const Core::IDocument *document) const
+void CMakeFormatter::applyIfNecessary(IDocument *document) const
 {
-    return CMakeFormatterSettings::instance()->isApplicable(document);
+    d->applyIfNecessary(document);
 }
 
-void CMakeFormatter::initialize()
-{
-    m_formatFile = new QAction(Tr::tr("Format &Current File"), this);
-    Core::Command *cmd = Core::ActionManager::registerAction(m_formatFile, Constants::CMAKEFORMATTER_ACTION_ID);
-    connect(m_formatFile, &QAction::triggered, this, &CMakeFormatter::formatFile);
-
-    Core::ActionManager::actionContainer(Constants::CMAKEFORMATTER_MENU_ID)->addAction(cmd);
-
-    connect(CMakeFormatterSettings::instance(), &CMakeFormatterSettings::supportedMimeTypesChanged,
-            [this] { updateActions(Core::EditorManager::currentEditor()); });
-}
-
-} // namespace Internal
-} // namespace CMakeProjectManager
+} // CMakeProjectManager::Internal