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

Core: Move SystemSettings page closer to current setup

Browse Source 
Also align items a bit and use BaseAspect::setEnabler() where
appropriate.

Change-Id: I7497e3ce82f3685582a84b1bf383e65892d76f96
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
This commit is contained in:
hjk
2023-07-26 18:29:20 +02:00
parent bc1ef0f158
commit 7f908d737b
7 changed files with 182 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/plugins/coreplugin/documentmanager.cpp
View File

@@ -22,6 +22,7 @@
#include <coreplugin/editormanager/ieditor.h>
#include <coreplugin/editormanager/ieditorfactory.h>
#include <coreplugin/editormanager/iexternaleditor.h>
#include <coreplugin/systemsettings.h>
#include <extensionsystem/pluginmanager.h>
@@ -1336,7 +1337,8 @@ void DocumentManager::addToRecentFiles(const FilePath &filePath, Id editorId)
Utils::erase(d->m_recentFiles, [fileKey](const RecentFile &file) {
return fileKey == filePathKey(file.first, DocumentManager::KeepLinks);
});
while (d->m_recentFiles.count() >= EditorManagerPrivate::maxRecentFiles())
const int maxRecentFiles = systemSettings().maxRecentFiles();
while (d->m_recentFiles.count() >= maxRecentFiles)
d->m_recentFiles.removeLast();
d->m_recentFiles.prepend(RecentFile(filePath, editorId));
}

164
src/plugins/coreplugin/editormanager/editormanager.cpp
View File

@@ -33,6 +33,7 @@
#include "../outputpanemanager.h"
#include "../rightpane.h"
#include "../settingsdatabase.h"
#include "../systemsettings.h"
#include "../vcsmanager.h"
#include <extensionsystem/pluginmanager.h>
@@ -90,15 +91,6 @@ static const char kCurrentDocumentYPos[] = "CurrentDocument:YPos";
static const char kMakeWritableWarning[] = "Core.EditorManager.MakeWritable";
static const char documentStatesKey[] = "EditorManager/DocumentStates";
static const char reloadBehaviorKey[] = "EditorManager/ReloadBehavior";
static const char autoSaveEnabledKey[] = "EditorManager/AutoSaveEnabled";
static const char autoSaveIntervalKey[] = "EditorManager/AutoSaveInterval";
static const char autoSaveAfterRefactoringKey[] = "EditorManager/AutoSaveAfterRefactoring";
static const char autoSuspendEnabledKey[] = "EditorManager/AutoSuspendEnabled";
static const char autoSuspendMinDocumentCountKey[] = "EditorManager/AutoSuspendMinDocuments";
static const char warnBeforeOpeningBigTextFilesKey[] = "EditorManager/WarnBeforeOpeningBigTextFiles";
static const char bigTextFileSizeLimitKey[] = "EditorManager/BigTextFileSizeLimitInMB";
static const char maxRecentFilesKey[] = "EditorManager/MaxRecentFiles";
static const char fileSystemCaseSensitivityKey[] = "Core/FileSystemCaseSensitivity";
static const char preferredEditorFactoriesKey[] = "EditorManager/PreferredEditorFactories";
@@ -732,7 +724,7 @@ EditorArea *EditorManagerPrivate::mainEditorArea()
bool EditorManagerPrivate::skipOpeningBigTextFile(const FilePath &filePath)
{
if (!d->m_settings.warnBeforeOpeningBigFilesEnabled)
if (!systemSettings().warnBeforeOpeningBigFiles())
return false;
if (!filePath.exists())
@@ -745,7 +737,7 @@ bool EditorManagerPrivate::skipOpeningBigTextFile(const FilePath &filePath)
const qint64 fileSize = filePath.fileSize();
const double fileSizeInMB = fileSize / 1000.0 / 1000.0;
if (fileSizeInMB > d->m_settings.bigFileSizeLimitInMB
if (fileSizeInMB > systemSettings().bigFileSizeLimitInMB()
&& fileSize < EditorManager::maxTextFileSize()) {
const QString title = ::Core::Tr::tr("Continue Opening Huge Text File?");
const QString text = ::Core::Tr::tr(
@@ -761,7 +753,7 @@ bool EditorManagerPrivate::skipOpeningBigTextFile(const FilePath &filePath)
QMessageBox::StandardButton clickedButton
= CheckableMessageBox::question(ICore::dialogParent(), title, text, decider);
setWarnBeforeOpeningBigFilesEnabled(askAgain);
systemSettings().warnBeforeOpeningBigFiles.setValue(askAgain);
return clickedButton != QMessageBox::Yes;
}
@@ -1217,51 +1209,14 @@ void EditorManagerPrivate::saveSettings()
{
ICore::settingsDatabase()->setValue(documentStatesKey, d->m_editorStates);
const Settings def;
QtcSettings *qsettings = ICore::settings();
qsettings->setValueWithDefault(reloadBehaviorKey,
int(d->m_settings.reloadSetting),
int(def.reloadSetting));
qsettings->setValueWithDefault(autoSaveEnabledKey,
d->m_settings.autoSaveEnabled,
def.autoSaveEnabled);
qsettings->setValueWithDefault(autoSaveIntervalKey,
d->m_settings.autoSaveInterval,
def.autoSaveInterval);
qsettings->setValueWithDefault(autoSaveAfterRefactoringKey,
d->m_settings.autoSaveAfterRefactoring,
def.autoSaveAfterRefactoring);
qsettings->setValueWithDefault(autoSuspendEnabledKey,
d->m_settings.autoSuspendEnabled,
def.autoSuspendEnabled);
qsettings->setValueWithDefault(autoSuspendMinDocumentCountKey,
d->m_settings.autoSuspendMinDocumentCount,
def.autoSuspendMinDocumentCount);
qsettings->setValueWithDefault(warnBeforeOpeningBigTextFilesKey,
d->m_settings.warnBeforeOpeningBigFilesEnabled,
def.warnBeforeOpeningBigFilesEnabled);
qsettings->setValueWithDefault(bigTextFileSizeLimitKey,
d->m_settings.bigFileSizeLimitInMB,
def.bigFileSizeLimitInMB);
qsettings->setValueWithDefault(maxRecentFilesKey,
d->m_settings.maxRecentFiles,
def.maxRecentFiles);
qsettings->setValueWithDefault(preferredEditorFactoriesKey,
toMap(userPreferredEditorTypes()));
}
void EditorManagerPrivate::readSettings()
{
Settings def;
QSettings *qs = ICore::settings();
d->m_settings.warnBeforeOpeningBigFilesEnabled
= qs->value(warnBeforeOpeningBigTextFilesKey, def.warnBeforeOpeningBigFilesEnabled).toBool();
d->m_settings.bigFileSizeLimitInMB
= qs->value(bigTextFileSizeLimitKey, def.bigFileSizeLimitInMB).toInt();
const int maxRecentFiles = qs->value(maxRecentFilesKey, def.maxRecentFiles).toInt();
if (maxRecentFiles > 0)
d->m_settings.maxRecentFiles = maxRecentFiles;
const Qt::CaseSensitivity defaultSensitivity = OsSpecificAspects::fileNameCaseSensitivity(
HostOsInfo::hostOs());
@@ -1281,19 +1236,6 @@ void EditorManagerPrivate::readSettings()
.value<QMap<QString, QVariant> >();
}
d->m_settings.reloadSetting = IDocument::ReloadSetting(
qs->value(reloadBehaviorKey, def.reloadSetting).toInt());
d->m_settings.autoSaveEnabled = qs->value(autoSaveEnabledKey, def.autoSaveEnabled).toBool();
d->m_settings.autoSaveInterval = qs->value(autoSaveIntervalKey, def.autoSaveInterval).toInt();
d->m_settings.autoSaveAfterRefactoring = qs->value(autoSaveAfterRefactoringKey,
def.autoSaveAfterRefactoring).toBool();
d->m_settings.autoSuspendEnabled = qs->value(autoSuspendEnabledKey, def.autoSuspendEnabled)
.toBool();
d->m_settings.autoSuspendMinDocumentCount
= qs->value(autoSuspendMinDocumentCountKey, def.autoSuspendMinDocumentCount).toInt();
updateAutoSave();
}
@@ -1325,88 +1267,6 @@ void EditorManagerPrivate::writeFileSystemSensitivity(Utils::QtcSettings *settin
HostOsInfo::hostOs())));
}
void EditorManagerPrivate::setAutoSaveEnabled(bool enabled)
{
d->m_settings.autoSaveEnabled = enabled;
updateAutoSave();
}
bool EditorManagerPrivate::autoSaveEnabled()
{
return d->m_settings.autoSaveEnabled;
}
void EditorManagerPrivate::setAutoSaveInterval(int interval)
{
d->m_settings.autoSaveInterval = interval;
updateAutoSave();
}
int EditorManagerPrivate::autoSaveInterval()
{
return d->m_settings.autoSaveInterval;
}
void EditorManagerPrivate::setAutoSaveAfterRefactoring(bool enabled)
{
d->m_settings.autoSaveAfterRefactoring = enabled;
}
bool EditorManagerPrivate::autoSaveAfterRefactoring()
{
return d->m_settings.autoSaveAfterRefactoring;
}
void EditorManagerPrivate::setAutoSuspendEnabled(bool enabled)
{
d->m_settings.autoSuspendEnabled = enabled;
}
bool EditorManagerPrivate::autoSuspendEnabled()
{
return d->m_settings.autoSuspendEnabled;
}
void EditorManagerPrivate::setAutoSuspendMinDocumentCount(int count)
{
d->m_settings.autoSuspendMinDocumentCount = count;
}
int EditorManagerPrivate::autoSuspendMinDocumentCount()
{
return d->m_settings.autoSuspendMinDocumentCount;
}
bool EditorManagerPrivate::warnBeforeOpeningBigFilesEnabled()
{
return d->m_settings.warnBeforeOpeningBigFilesEnabled;
}
void EditorManagerPrivate::setWarnBeforeOpeningBigFilesEnabled(bool enabled)
{
d->m_settings.warnBeforeOpeningBigFilesEnabled = enabled;
}
int EditorManagerPrivate::bigFileSizeLimit()
{
return d->m_settings.bigFileSizeLimitInMB;
}
void EditorManagerPrivate::setMaxRecentFiles(int count)
{
d->m_settings.maxRecentFiles = count;
}
int EditorManagerPrivate::maxRecentFiles()
{
return d->m_settings.maxRecentFiles;
}
void EditorManagerPrivate::setBigFileSizeLimit(int limitInMB)
{
d->m_settings.bigFileSizeLimitInMB = limitInMB;
}
EditorFactoryList EditorManagerPrivate::findFactories(Id editorId, const FilePath &filePath)
{
if (debugEditorManager)
@@ -2005,8 +1865,8 @@ void EditorManagerPrivate::addDocumentToRecentFiles(IDocument *document)
void EditorManagerPrivate::updateAutoSave()
{
if (d->m_settings.autoSaveEnabled)
d->m_autoSaveTimer->start(d->m_settings.autoSaveInterval * (60 * 1000));
if (systemSettings().autoSaveModifiedFiles())
d->m_autoSaveTimer->start(systemSettings().autoSaveInterval() * (60 * 1000));
else
d->m_autoSaveTimer->stop();
}
@@ -2595,20 +2455,21 @@ void EditorManagerPrivate::revertToSaved(IDocument *document)
void EditorManagerPrivate::autoSuspendDocuments()
{
if (!d->m_settings.autoSuspendEnabled)
if (!systemSettings().autoSuspendEnabled())
return;
auto visibleDocuments = Utils::transform<QSet>(EditorManager::visibleEditors(),
&IEditor::document);
int keptEditorCount = 0;
QList<IDocument *> documentsToSuspend;
const int minDocumentCount = systemSettings().autoSuspendMinDocumentCount();
for (const EditLocation &editLocation : std::as_const(d->m_globalHistory)) {
IDocument *document = editLocation.document;
if (!document || !document->isSuspendAllowed() || document->isModified()
|| document->isTemporary() || document->filePath().isEmpty()
|| visibleDocuments.contains(document))
continue;
if (keptEditorCount >= d->m_settings.autoSuspendMinDocumentCount)
if (keptEditorCount >= minDocumentCount)
documentsToSuspend.append(document);
else
++keptEditorCount;
@@ -3001,7 +2862,8 @@ void EditorManager::runWithTemporaryEditor(const Utils::FilePath &filePath,
*/
IDocument::ReloadSetting EditorManager::reloadSetting()
{
return d->m_settings.reloadSetting;
// FIXME: Used TypedSelectionAspect once we have that.
return IDocument::ReloadSetting(systemSettings().reloadSetting.value());
}
/*!
@@ -3011,7 +2873,7 @@ IDocument::ReloadSetting EditorManager::reloadSetting()
*/
void EditorManager::setReloadSetting(IDocument::ReloadSetting behavior)
{
d->m_settings.reloadSetting = behavior;
systemSettings().reloadSetting.setValue(behavior);
}
/*!
@@ -3228,7 +3090,7 @@ bool EditorManager::isAutoSaveFile(const QString &filePath)
bool EditorManager::autoSaveAfterRefactoring()
{
return EditorManagerPrivate::autoSaveAfterRefactoring();
return systemSettings().autoSaveAfterRefactoring();
}
/*!

36
src/plugins/coreplugin/editormanager/editormanager_p.h
View File

@@ -99,22 +99,6 @@ public:
static Qt::CaseSensitivity readFileSystemSensitivity(QSettings *settings);
static void writeFileSystemSensitivity(Utils::QtcSettings *settings,
Qt::CaseSensitivity sensitivity);
static void setAutoSaveEnabled(bool enabled);
static bool autoSaveEnabled();
static void setAutoSaveInterval(int interval);
static int autoSaveInterval();
static void setAutoSaveAfterRefactoring(bool enabled);
static bool autoSaveAfterRefactoring();
static void setAutoSuspendEnabled(bool enabled);
static bool autoSuspendEnabled();
static void setAutoSuspendMinDocumentCount(int count);
static int autoSuspendMinDocumentCount();
static void setWarnBeforeOpeningBigFilesEnabled(bool enabled);
static bool warnBeforeOpeningBigFilesEnabled();
static void setBigFileSizeLimit(int limitInMB);
static int bigFileSizeLimit();
static void setMaxRecentFiles(int count);
static int maxRecentFiles();
static EditorWindow *createEditorWindow();
static void splitNewWindow(Internal::EditorView *view);
@@ -132,6 +116,8 @@ public:
static void setPlaceholderText(const QString &text);
static QString placeholderText();
static void updateAutoSave();
public slots:
static bool saveDocument(Core::IDocument *document);
static bool saveDocumentAs(Core::IDocument *document);
@@ -191,7 +177,6 @@ private:
static EditorArea *findEditorArea(const EditorView *view, int *areaIndex = nullptr);
static IEditor *pickUnusedEditor(Internal::EditorView **foundView = nullptr);
static void addDocumentToRecentFiles(IDocument *document);
static void updateAutoSave();
static void updateMakeWritableWarning();
static void setupSaveActions(IDocument *document, QAction *saveAction,
QAction *saveAsAction, QAction *revertToSavedAction);
@@ -263,23 +248,6 @@ private:
EditorManager::WindowTitleHandler m_sessionTitleHandler;
EditorManager::WindowTitleHandler m_titleVcsTopicHandler;
struct Settings
{
IDocument::ReloadSetting reloadSetting = IDocument::AlwaysAsk;
bool autoSaveEnabled = true;
int autoSaveInterval = 5;
bool autoSuspendEnabled = true;
int autoSuspendMinDocumentCount = 10;
bool autoSaveAfterRefactoring = true;
bool warnBeforeOpeningBigFilesEnabled = true;
int bigFileSizeLimitInMB = 5;
int maxRecentFiles = 8;
};
Settings m_settings;
QString m_placeholderText;
QList<std::function<bool(IEditor *)>> m_closeEditorListeners;
};

22
src/plugins/coreplugin/mainwindow.cpp
View File

@@ -103,7 +103,6 @@ namespace Internal {
static const char settingsGroup[] = "MainWindow";
static const char colorKey[] = "Color";
static const char askBeforeExitKey[] = "AskBeforeExit";
static const char windowGeometryKey[] = "WindowGeometry";
static const char windowStateKey[] = "WindowState";
static const char modeSelectorLayoutKey[] = "ModeSelectorLayout";
@@ -129,7 +128,6 @@ MainWindow::MainWindow()
, m_jsExpander(JsExpander::createGlobalJsExpander())
, m_vcsManager(new VcsManager)
, m_modeStack(new FancyTabWidget(this))
, m_systemSettings(new SystemSettings)
, m_shortcutSettings(new ShortcutSettings)
, m_toolSettings(new ToolSettings)
, m_mimeTypeSettings(new MimeTypeSettings)
@@ -232,16 +230,6 @@ void MainWindow::setSidebarVisible(bool visible, Side side)
navigationWidget(side)->setShown(visible);
}
bool MainWindow::askConfirmationBeforeExit() const
{
return m_askConfirmationBeforeExit;
}
void MainWindow::setAskConfirmationBeforeExit(bool ask)
{
m_askConfirmationBeforeExit = ask;
}
void MainWindow::setOverrideColor(const QColor &color)
{
m_overrideColor = color;
@@ -275,8 +263,6 @@ MainWindow::~MainWindow()
m_messageManager = nullptr;
delete m_shortcutSettings;
m_shortcutSettings = nullptr;
delete m_systemSettings;
m_systemSettings = nullptr;
delete m_toolSettings;
m_toolSettings = nullptr;
delete m_mimeTypeSettings;
@@ -376,7 +362,7 @@ void MainWindow::closeEvent(QCloseEvent *event)
return;
}
if (m_askConfirmationBeforeExit
if (systemSettings().askBeforeExit()
&& (QMessageBox::question(this,
Tr::tr("Exit %1?").arg(QGuiApplication::applicationDisplayName()),
Tr::tr("Exit %1?").arg(QGuiApplication::applicationDisplayName()),
@@ -1181,8 +1167,6 @@ void MainWindow::readSettings()
QColor(StyleHelper::DEFAULT_BASE_COLOR)).value<QColor>());
}
m_askConfirmationBeforeExit = settings->value(askBeforeExitKey, askBeforeExitDefault).toBool();
{
ModeManager::Style modeStyle =
ModeManager::Style(settings->value(modeSelectorLayoutKey, int(ModeManager::Style::IconsAndText)).toInt());
@@ -1216,10 +1200,6 @@ void MainWindow::saveSettings()
StyleHelper::requestedBaseColor(),
QColor(StyleHelper::DEFAULT_BASE_COLOR));
settings->setValueWithDefault(askBeforeExitKey,
m_askConfirmationBeforeExit,
askBeforeExitDefault);
settings->endGroup();
DocumentManager::saveSettings();

6
src/plugins/coreplugin/mainwindow.h
View File

@@ -50,7 +50,6 @@ class MimeTypeSettings;
class VersionDialog;
class WindowSupport;
class SystemEditor;
class SystemSettings;
class MainWindow : public Utils::AppMainWindow
{
@@ -81,9 +80,6 @@ public:
void updateAdditionalContexts(const Context &remove, const Context &add,
ICore::ContextPriority priority);
bool askConfirmationBeforeExit() const;
void setAskConfirmationBeforeExit(bool ask);
void setOverrideColor(const QColor &color);
QStringList additionalAboutInformation() const;
@@ -160,7 +156,6 @@ private:
std::unordered_map<QWidget *, IContext *> m_contextWidgets;
SystemSettings *m_systemSettings = nullptr;
ShortcutSettings *m_shortcutSettings = nullptr;
ToolSettings *m_toolSettings = nullptr;
MimeTypeSettings *m_mimeTypeSettings = nullptr;
@@ -186,7 +181,6 @@ private:
QToolButton *m_toggleLeftSideBarButton = nullptr;
QToolButton *m_toggleRightSideBarButton = nullptr;
bool m_askConfirmationBeforeExit = false;
QColor m_overrideColor;
QList<std::function<bool()>> m_preCloseListeners;
};

254
src/plugins/coreplugin/systemsettings.cpp
View File

@@ -8,6 +8,7 @@
#include "coreplugintr.h"
#include "editormanager/editormanager_p.h"
#include "dialogs/restartdialog.h"
#include "dialogs/ioptionspage.h"
#include "fileutils.h"
#include "icore.h"
#include "iversioncontrol.h"
@@ -40,13 +41,9 @@
using namespace Utils;
using namespace Layouting;
namespace Core {
namespace Internal {
namespace Core::Internal {
#ifdef ENABLE_CRASHPAD
const char crashReportingEnabledKey[] = "CrashReportingEnabled";
const char showCrashButtonKey[] = "ShowCrashButton";
// TODO: move to somewhere in Utils
static QString formatSize(qint64 size)
{
@@ -63,55 +60,128 @@ static QString formatSize(qint64 size)
}
#endif // ENABLE_CRASHPAD
SystemSettings &systemSettings()
{
static SystemSettings theSettings;
return theSettings;
}
SystemSettings::SystemSettings()
{
setAutoApply(false);
autoSaveModifiedFiles.setSettingsKey("EditorManager/AutoSaveEnabled");
autoSaveModifiedFiles.setDefaultValue(true);
autoSaveModifiedFiles.setLabelText(Tr::tr("Auto-save modified files"));
autoSaveModifiedFiles.setLabelPlacement(
BoolAspect::LabelPlacement::AtCheckBoxWithoutDummyLabel);
autoSaveModifiedFiles.setToolTip(
Tr::tr("Automatically creates temporary copies of modified files. "
"If %1 is restarted after a crash or power failure, it asks whether to "
"recover the auto-saved content.")
.arg(QGuiApplication::applicationDisplayName()));
autoSaveInterval.setSettingsKey("EditorManager/AutoSaveInterval");
autoSaveInterval.setSuffix(Tr::tr("min"));
autoSaveInterval.setRange(1, 1000000);
autoSaveInterval.setDefaultValue(5);
autoSaveInterval.setEnabler(&autoSaveModifiedFiles);
autoSaveInterval.setLabelText(Tr::tr("Interval:"));
autoSaveAfterRefactoring.setSettingsKey("EditorManager/AutoSaveAfterRefactoring");
autoSaveAfterRefactoring.setDefaultValue(true);
autoSaveAfterRefactoring.setLabelPlacement(
BoolAspect::LabelPlacement::AtCheckBoxWithoutDummyLabel);
autoSaveAfterRefactoring.setLabelText(Tr::tr("Auto-save files after refactoring"));
autoSaveAfterRefactoring.setToolTip(
Tr::tr("Automatically saves all open files affected by a refactoring operation,\n"
"provided they were unmodified before the refactoring."));
autoSuspendEnabled.setSettingsKey("EditorManager/AutoSuspendEnabled");
autoSuspendEnabled.setDefaultValue(true);
autoSuspendEnabled.setLabelText(Tr::tr("Auto-suspend unmodified files"));
autoSuspendEnabled.setLabelPlacement(
BoolAspect::LabelPlacement::AtCheckBoxWithoutDummyLabel);
autoSuspendEnabled.setToolTip(
Tr::tr("Automatically free resources of old documents that are not visible and not "
"modified. They stay visible in the list of open documents."));
autoSuspendMinDocumentCount.setSettingsKey("EditorManager/AutoSuspendMinDocuments");
autoSuspendMinDocumentCount.setRange(1, 500);
autoSuspendMinDocumentCount.setDefaultValue(30);
autoSuspendMinDocumentCount.setEnabler(&autoSuspendEnabled);
autoSuspendMinDocumentCount.setLabelText(Tr::tr("Files to keep open:"));
autoSuspendMinDocumentCount.setToolTip(
Tr::tr("Minimum number of open documents that should be kept in memory. Increasing this "
"number will lead to greater resource usage when not manually closing documents."));
warnBeforeOpeningBigFiles.setSettingsKey("EditorManager/WarnBeforeOpeningBigTextFiles");
warnBeforeOpeningBigFiles.setDefaultValue(true);
warnBeforeOpeningBigFiles.setLabelPlacement(
BoolAspect::LabelPlacement::AtCheckBoxWithoutDummyLabel);
warnBeforeOpeningBigFiles.setLabelText(Tr::tr("Warn before opening text files greater than"));
bigFileSizeLimitInMB.setSettingsKey("EditorManager/BigTextFileSizeLimitInMB");
bigFileSizeLimitInMB.setSuffix(Tr::tr("MB"));
bigFileSizeLimitInMB.setRange(1, 500);
bigFileSizeLimitInMB.setDefaultValue(5);
bigFileSizeLimitInMB.setEnabler(&warnBeforeOpeningBigFiles);
maxRecentFiles.setSettingsKey("EditorManager/MaxRecentFiles");
maxRecentFiles.setRange(1, 99);
maxRecentFiles.setDefaultValue(8);
reloadSetting.setSettingsKey("EditorManager/ReloadBehavior");
reloadSetting.setDisplayStyle(SelectionAspect::DisplayStyle::ComboBox);
reloadSetting.addOption(Tr::tr("Always Ask"));
reloadSetting.addOption(Tr::tr("Reload All Unchanged Editors"));
reloadSetting.addOption(Tr::tr("Ignore Modifications"));
reloadSetting.setDefaultValue(IDocument::AlwaysAsk);
reloadSetting.setLabelText(Tr::tr("When files are externally modified:"));
askBeforeExit.setSettingsKey("AskBeforeExit");
askBeforeExit.setLabelText(Tr::tr("Ask for confirmation before exiting"));
askBeforeExit.setLabelPlacement(BoolAspect::LabelPlacement::AtCheckBoxWithoutDummyLabel);
#ifdef ENABLE_CRASHPAD
enableCrashReporting.setSettingsKey("CrashReportingEnabled");
enableCrashReporting.setLabelText(tr("Enable crash reporting"));
enableCrashReporting.setToolTip(
Tr::tr("Allow crashes to be automatically reported. Collected reports are "
"used for the sole purpose of fixing bugs."));
showCrashButton.setSettingsKey("ShowCrashButton");
#endif
const auto updateAutoSave = [] { EditorManagerPrivate::updateAutoSave(); };
connect(&autoSaveModifiedFiles, &BaseAspect::changed, this, updateAutoSave);
connect(&autoSaveInterval, &BaseAspect::changed, this, updateAutoSave);
readSettings();
}
class SystemSettingsWidget : public IOptionsPageWidget
{
public:
SystemSettingsWidget()
: m_fileSystemCaseSensitivityChooser(new QComboBox)
, m_autoSuspendMinDocumentCount(new QSpinBox)
, m_externalFileBrowserEdit(new QLineEdit)
, m_autoSuspendCheckBox(new QCheckBox(Tr::tr("Auto-suspend unmodified files")))
, m_maxRecentFilesSpinBox(new QSpinBox)
, m_enableCrashReportingCheckBox(new QCheckBox(Tr::tr("Enable crash reporting")))
, m_warnBeforeOpeningBigFiles(
new QCheckBox(Tr::tr("Warn before opening text files greater than")))
, m_bigFilesLimitSpinBox(new QSpinBox)
, m_terminalComboBox(new QComboBox)
, m_terminalOpenArgs(new QLineEdit)
, m_terminalExecuteArgs(new QLineEdit)
, m_patchChooser(new Utils::PathChooser)
, m_environmentChangesLabel(new Utils::ElidingLabel)
, m_askBeforeExitCheckBox(new QCheckBox(Tr::tr("Ask for confirmation before exiting")))
, m_reloadBehavior(new QComboBox)
, m_autoSaveCheckBox(new QCheckBox(Tr::tr("Auto-save modified files")))
, m_clearCrashReportsButton(new QPushButton(Tr::tr("Clear Local Crash Reports")))
, m_crashReportsSizeText(new QLabel)
, m_autoSaveInterval(new QSpinBox)
, m_autoSaveRefactoringCheckBox(new QCheckBox(Tr::tr("Auto-save files after refactoring")))
{
m_autoSuspendCheckBox->setToolTip(
Tr::tr("Automatically free resources of old documents that are not visible and not "
"modified. They stay visible in the list of open documents."));
m_autoSuspendMinDocumentCount->setMinimum(1);
m_autoSuspendMinDocumentCount->setMaximum(500);
m_autoSuspendMinDocumentCount->setValue(30);
m_enableCrashReportingCheckBox->setToolTip(
Tr::tr("Allow crashes to be automatically reported. Collected reports are "
"used for the sole purpose of fixing bugs."));
m_bigFilesLimitSpinBox->setSuffix(Tr::tr("MB"));
m_bigFilesLimitSpinBox->setMinimum(1);
m_bigFilesLimitSpinBox->setMaximum(500);
m_bigFilesLimitSpinBox->setValue(5);
SystemSettings &s = systemSettings();
m_terminalExecuteArgs->setToolTip(
Tr::tr("Command line arguments used for \"Run in terminal\"."));
QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
sizePolicy.setHorizontalStretch(5);
m_environmentChangesLabel->setSizePolicy(sizePolicy);
m_reloadBehavior->addItem(Tr::tr("Always Ask"));
m_reloadBehavior->addItem(Tr::tr("Reload All Unchanged Editors"));
m_reloadBehavior->addItem(Tr::tr("Ignore Modifications"));
m_autoSaveInterval->setSuffix(Tr::tr("min"));
QSizePolicy termSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
termSizePolicy.setHorizontalStretch(3);
m_terminalComboBox->setSizePolicy(termSizePolicy);
@@ -119,15 +189,10 @@ public:
m_terminalComboBox->setEditable(true);
m_terminalOpenArgs->setToolTip(
Tr::tr("Command line arguments used for \"%1\".").arg(FileUtils::msgTerminalHereAction()));
m_autoSaveInterval->setMinimum(1);
auto fileSystemCaseSensitivityLabel = new QLabel(Tr::tr("File system case sensitivity:"));
fileSystemCaseSensitivityLabel->setToolTip(
Tr::tr("Influences how file names are matched to decide if they are the same."));
auto autoSuspendLabel = new QLabel(Tr::tr("Files to keep open:"));
autoSuspendLabel->setToolTip(
Tr::tr("Minimum number of open documents that should be kept in memory. Increasing this "
"number will lead to greater resource usage when not manually closing documents."));
auto resetFileBrowserButton = new QPushButton(Tr::tr("Reset"));
resetFileBrowserButton->setToolTip(Tr::tr("Reset to default."));
auto helpExternalFileBrowserButton = new QToolButton;
@@ -164,21 +229,16 @@ public:
form.addRow({fileSystemCaseSensitivityLabel,
Span(2, Row{m_fileSystemCaseSensitivityChooser, st})});
}
form.addRow(
{Tr::tr("When files are externally modified:"), Span(2, Row{m_reloadBehavior, st})});
form.addRow(
{m_autoSaveCheckBox, Span(2, Row{Tr::tr("Interval:"), m_autoSaveInterval, st})});
form.addRow({Span(3, m_autoSaveRefactoringCheckBox)});
form.addRow({m_autoSuspendCheckBox,
Span(2, Row{autoSuspendLabel, m_autoSuspendMinDocumentCount, st})});
form.addRow({Span(3, Row{m_warnBeforeOpeningBigFiles, m_bigFilesLimitSpinBox, st})});
form.addRow({Span(3,
Row{Tr::tr("Maximum number of entries in \"Recent Files\":"),
m_maxRecentFilesSpinBox,
st})});
form.addRow({m_askBeforeExitCheckBox});
form.addRow({s.reloadSetting, st});
form.addRow({s.autoSaveModifiedFiles, Span(2, Row{s.autoSaveInterval, st})});
form.addRow({Span(3, s.autoSaveAfterRefactoring)});
form.addRow({s.autoSuspendEnabled, Span(2, Row{s.autoSuspendMinDocumentCount, st})});
form.addRow({s.warnBeforeOpeningBigFiles, Span(2, Row{s.bigFileSizeLimitInMB, st})});
form.addRow({Tr::tr("Maximum number of entries in \"Recent Files\":"),
Span(2, Row{s.maxRecentFiles, st})});
form.addRow({s.askBeforeExit});
#ifdef ENABLE_CRASHPAD
form.addRow({Span(3, Row{m_enableCrashReportingCheckBox, helpCrashReportingButton, st})});
form.addRow({Span(3, Row{s.enableCrashReporting, helpCrashReportingButton, st})});
form.addRow({Span(3, Row{m_clearCrashReportsButton, m_crashReportsSizeText, st})});
#endif
@@ -189,7 +249,6 @@ public:
}
}.attachTo(this);
m_reloadBehavior->setCurrentIndex(EditorManager::reloadSetting());
if (HostOsInfo::isAnyUnixHost()) {
const QVector<TerminalCommand> availableTerminals
= TerminalCommand::availableTerminalEmulators();
@@ -211,28 +270,9 @@ public:
m_patchChooser->setExpectedKind(PathChooser::ExistingCommand);
m_patchChooser->setHistoryCompleter(QLatin1String("General.PatchCommand.History"));
m_patchChooser->setFilePath(PatchTool::patchCommand());
m_autoSaveCheckBox->setChecked(EditorManagerPrivate::autoSaveEnabled());
m_autoSaveCheckBox->setToolTip(Tr::tr("Automatically creates temporary copies of "
"modified files. If %1 is restarted after "
"a crash or power failure, it asks whether to "
"recover the auto-saved content.")
.arg(QGuiApplication::applicationDisplayName()));
m_autoSaveRefactoringCheckBox->setChecked(EditorManager::autoSaveAfterRefactoring());
m_autoSaveRefactoringCheckBox->setToolTip(
Tr::tr("Automatically saves all open files "
"affected by a refactoring operation,\nprovided they were unmodified before the "
"refactoring."));
m_autoSaveInterval->setValue(EditorManagerPrivate::autoSaveInterval());
m_autoSuspendCheckBox->setChecked(EditorManagerPrivate::autoSuspendEnabled());
m_autoSuspendMinDocumentCount->setValue(EditorManagerPrivate::autoSuspendMinDocumentCount());
m_warnBeforeOpeningBigFiles->setChecked(
EditorManagerPrivate::warnBeforeOpeningBigFilesEnabled());
m_bigFilesLimitSpinBox->setValue(EditorManagerPrivate::bigFileSizeLimit());
m_maxRecentFilesSpinBox->setMinimum(1);
m_maxRecentFilesSpinBox->setMaximum(99);
m_maxRecentFilesSpinBox->setValue(EditorManagerPrivate::maxRecentFiles());
#ifdef ENABLE_CRASHPAD
if (ICore::settings()->value(showCrashButtonKey).toBool()) {
if (s.showCrashButton()) {
auto crashButton = new QPushButton("CRASH!!!");
crashButton->show();
connect(crashButton, &QPushButton::clicked, [] {
@@ -241,12 +281,10 @@ public:
});
}
m_enableCrashReportingCheckBox->setChecked(
ICore::settings()->value(crashReportingEnabledKey).toBool());
connect(helpCrashReportingButton, &QAbstractButton::clicked, this, [this] {
showHelpDialog(Tr::tr("Crash Reporting"), CorePlugin::msgCrashpadInformation());
});
connect(m_enableCrashReportingCheckBox, &QCheckBox::stateChanged, this, [this] {
connect(&s.enableCrashReporting, &BaseAspect::changed, this, [this] {
const QString restartText = Tr::tr("The change will take effect after restart.");
Core::RestartDialog restartDialog(Core::ICore::dialogParent(), restartText);
restartDialog.exec();
@@ -263,10 +301,6 @@ public:
});
#endif
m_askBeforeExitCheckBox->setChecked(
static_cast<Core::Internal::MainWindow *>(ICore::mainWindow())
->askConfirmationBeforeExit());
if (HostOsInfo::isAnyUnixHost()) {
connect(resetTerminalButton,
&QAbstractButton::clicked,
@@ -342,33 +376,24 @@ private:
void showHelpDialog(const QString &title, const QString &helpText);
QComboBox *m_fileSystemCaseSensitivityChooser;
QSpinBox *m_autoSuspendMinDocumentCount;
QLineEdit *m_externalFileBrowserEdit;
QCheckBox *m_autoSuspendCheckBox;
QSpinBox *m_maxRecentFilesSpinBox;
QCheckBox *m_enableCrashReportingCheckBox;
QCheckBox *m_warnBeforeOpeningBigFiles;
QSpinBox *m_bigFilesLimitSpinBox;
QComboBox *m_terminalComboBox;
QLineEdit *m_terminalOpenArgs;
QLineEdit *m_terminalExecuteArgs;
Utils::PathChooser *m_patchChooser;
Utils::ElidingLabel *m_environmentChangesLabel;
QCheckBox *m_askBeforeExitCheckBox;
QComboBox *m_reloadBehavior;
QCheckBox *m_autoSaveCheckBox;
QPushButton *m_clearCrashReportsButton;
QLabel *m_crashReportsSizeText;
QSpinBox *m_autoSaveInterval;
QCheckBox *m_autoSaveRefactoringCheckBox;
QPointer<QMessageBox> m_dialog;
EnvironmentItems m_environmentChanges;
};
void SystemSettingsWidget::apply()
{
systemSettings().apply();
systemSettings().writeSettings();
QtcSettings *settings = ICore::settings();
EditorManager::setReloadSetting(IDocument::ReloadSetting(m_reloadBehavior->currentIndex()));
if (HostOsInfo::isAnyUnixHost()) {
TerminalCommand::setTerminalEmulator({
FilePath::fromUserInput(m_terminalComboBox->lineEdit()->text()),
@@ -380,22 +405,6 @@ void SystemSettingsWidget::apply()
}
}
PatchTool::setPatchCommand(m_patchChooser->filePath());
EditorManagerPrivate::setAutoSaveEnabled(m_autoSaveCheckBox->isChecked());
EditorManagerPrivate::setAutoSaveInterval(m_autoSaveInterval->value());
EditorManagerPrivate::setAutoSaveAfterRefactoring(m_autoSaveRefactoringCheckBox->isChecked());
EditorManagerPrivate::setAutoSuspendEnabled(m_autoSuspendCheckBox->isChecked());
EditorManagerPrivate::setAutoSuspendMinDocumentCount(m_autoSuspendMinDocumentCount->value());
EditorManagerPrivate::setWarnBeforeOpeningBigFilesEnabled(
m_warnBeforeOpeningBigFiles->isChecked());
EditorManagerPrivate::setBigFileSizeLimit(m_bigFilesLimitSpinBox->value());
EditorManagerPrivate::setMaxRecentFiles(m_maxRecentFilesSpinBox->value());
#ifdef ENABLE_CRASHPAD
ICore::settings()->setValue(crashReportingEnabledKey,
m_enableCrashReportingCheckBox->isChecked());
#endif
static_cast<Core::Internal::MainWindow *>(ICore::mainWindow())
->setAskConfirmationBeforeExit(m_askBeforeExitCheckBox->isChecked());
if (HostOsInfo::isMacHost()) {
const Qt::CaseSensitivity sensitivity = EditorManagerPrivate::readFileSystemSensitivity(
@@ -487,13 +496,20 @@ void SystemSettingsWidget::showHelpForFileBrowser()
showHelpDialog(Tr::tr("Variables"), UnixUtils::fileBrowserHelpText());
}
SystemSettings::SystemSettings()
{
setId(Constants::SETTINGS_ID_SYSTEM);
setDisplayName(Tr::tr("System"));
setCategory(Constants::SETTINGS_CATEGORY_CORE);
setWidgetCreator([] { return new SystemSettingsWidget; });
}
// SystemSettingsPage
} // namespace Internal
} // namespace Core
class SystemSettingsPage final : public IOptionsPage
{
public:
SystemSettingsPage()
{
setId(Constants::SETTINGS_ID_SYSTEM);
setDisplayName(Tr::tr("System"));
setCategory(Constants::SETTINGS_CATEGORY_CORE);
setWidgetCreator([] { return new SystemSettingsWidget; });
}
};
const SystemSettingsPage settingsPage;
} // Core::Internal

34
src/plugins/coreplugin/systemsettings.h
View File

@@ -3,16 +3,38 @@
#pragma once
#include <coreplugin/dialogs/ioptionspage.h>
#include <utils/aspects.h>
namespace Core {
namespace Internal {
namespace Core::Internal {
class SystemSettings final : public IOptionsPage
class SystemSettings final : public Utils::AspectContainer
{
public:
SystemSettings();
Utils::BoolAspect autoSaveModifiedFiles{this};
Utils::IntegerAspect autoSaveInterval{this};
Utils::BoolAspect autoSaveAfterRefactoring{this};
Utils::BoolAspect autoSuspendEnabled{this};
Utils::IntegerAspect autoSuspendMinDocumentCount{this};
Utils::BoolAspect warnBeforeOpeningBigFiles{this};
Utils::IntegerAspect bigFileSizeLimitInMB{this};
Utils::IntegerAspect maxRecentFiles{this};
Utils::SelectionAspect reloadSetting{this};
#ifdef ENABLE_CRASHPAD
Utils::BoolAspect enableCrashReporting{this};
Utils::BoolAspect showCrashButton{this};
#endif
Utils::BoolAspect askBeforeExit{this};
};
} // namespace Internal
} // namespace Core
SystemSettings &systemSettings();
} // Core::Internal