qplotter 1.6.0b3__py3-none-any.whl

qplot/windows/_preferences.py

@@ -0,0 +1,635 @@
+import os
+from copy import deepcopy
+
+from PyQt6 import (
+    QtCore,
+    QtGui,
+)
+from PyQt6 import (
+    QtWidgets as qtw,
+)
+
+from ._commands import create_action
+from ._config_persistence import persist_config_values
+from ._window_controls import (
+    CONFIRM_CLOSE_ALL_KEY,
+    CONFIRM_QUIT_KEY,
+)
+
+THEME_OPTIONS = (
+    ("Light", "light"),
+    ("Dark", "dark"),
+    ("PyQt", "pyqt"),
+    )
+
+MOUSE_MODE_KEY = "user_preference.mouse_mode"
+MOUSE_MODE_OPTIONS = (
+    ("Rectangle zoom (1 button)", "rect"),
+    ("Pan (3 button)", "pan"),
+)
+
+COPY_PLOT_IMAGE_RESOLUTION_KEY = "user_preference.copy_plot_image_resolution"
+COPY_PLOT_IMAGE_RESOLUTION_SCREEN = "screen"
+COPY_PLOT_IMAGE_RESOLUTION_300_DPI = "dpi_300"
+COPY_PLOT_IMAGE_RESOLUTION_SVG = "svg"
+COPY_PLOT_IMAGE_RESOLUTION_OPTIONS = (
+    ("Screen resolution", COPY_PLOT_IMAGE_RESOLUTION_SCREEN),
+    ("300 dpi", COPY_PLOT_IMAGE_RESOLUTION_300_DPI),
+    ("Vector SVG", COPY_PLOT_IMAGE_RESOLUTION_SVG),
+)
+
+COLORBAR_WIDTH_KEY = "user_preference.colorbar_width"
+AXIS_TICK_WIDTH_KEY = "user_preference.axis_tick_width"
+AXIS_MAJOR_TICK_COUNT_KEY = "user_preference.axis_major_tick_count"
+
+PREFERENCE_KEYS = (
+    "user_preference.theme",
+    COLORBAR_WIDTH_KEY,
+    AXIS_TICK_WIDTH_KEY,
+    AXIS_MAJOR_TICK_COUNT_KEY,
+    "GUI.preview_size",
+    MOUSE_MODE_KEY,
+    COPY_PLOT_IMAGE_RESOLUTION_KEY,
+    "file.default_load_path",
+    "user_preference.default_refresh_rate",
+    CONFIRM_CLOSE_ALL_KEY,
+    CONFIRM_QUIT_KEY,
+    "runtime_settings.max_threads",
+    "runtime_settings.max_full_heatmap_points",
+    "runtime_settings.max_heatmap_grid_cells",
+    "runtime_settings.max_heatmap_grid_side",
+    "runtime_settings.del_grace_period",
+    "runtime_settings.cloud_sync_timeout",
+    )
+
+
+class PreferencesDialog(qtw.QDialog):
+    """
+    Dialog for editing common config-backed qPlot preferences.
+
+    """
+    preferencesApplied = QtCore.pyqtSignal()
+
+    def __init__(self, config, parent=None):
+        super().__init__(parent)
+        self.config = config
+
+        self.setWindowTitle("Preferences")
+        self.setModal(True)
+        self.setMinimumWidth(420)
+
+        self._build_ui()
+        self._edited_preference_keys: set[str] = set()
+        for key, widget in zip(PREFERENCE_KEYS, self._preference_controls(), strict=True):
+            mark_edited = lambda _value, key=key: self._edited_preference_keys.add(key)
+            if isinstance(widget, (qtw.QSpinBox, qtw.QDoubleSpinBox)):
+                signal = widget.valueChanged
+                line_edit = widget.lineEdit()
+                if line_edit is not None:
+                    # Typing the same rounded display is still an explicit
+                    # edit, even when the numeric valueChanged signal is silent.
+                    line_edit.textEdited.connect(mark_edited)
+            elif isinstance(widget, qtw.QComboBox):
+                signal = widget.currentIndexChanged
+            elif isinstance(widget, qtw.QLineEdit):
+                signal = widget.textChanged
+            else:
+                signal = widget.toggled
+            signal.connect(mark_edited)
+        self.load_from_config()
+
+    def _build_ui(self):
+        layout = qtw.QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(10)
+
+        tabs = qtw.QTabWidget(self)
+        tabs.addTab(self._appearance_tab(), "Appearance")
+        tabs.addTab(self._interaction_tab(), "Interaction")
+        tabs.addTab(self._files_tab(), "Files")
+        tabs.addTab(self._confirmations_tab(), "Confirmations")
+        tabs.addTab(self._runtime_tab(), "Runtime")
+        layout.addWidget(tabs)
+
+        self.buttonBox = qtw.QDialogButtonBox(
+            qtw.QDialogButtonBox.StandardButton.Ok
+            | qtw.QDialogButtonBox.StandardButton.Cancel
+            | qtw.QDialogButtonBox.StandardButton.Apply
+            | qtw.QDialogButtonBox.StandardButton.RestoreDefaults,
+            self,
+            )
+        self.buttonBox.accepted.connect(self._accept_preferences)
+        self.buttonBox.rejected.connect(self.reject)
+        apply_button = self.buttonBox.button(qtw.QDialogButtonBox.StandardButton.Apply)
+        if apply_button is None:
+            raise RuntimeError("Preferences dialog Apply button is not available.")
+        apply_button.clicked.connect(self.apply_preferences)
+        self.restoreDefaultsButton = self.buttonBox.button(
+            qtw.QDialogButtonBox.StandardButton.RestoreDefaults
+            )
+        if self.restoreDefaultsButton is None:
+            raise RuntimeError(
+                "Preferences dialog Restore Defaults button is not available."
+                )
+        self.restoreDefaultsButton.setObjectName("restorePreferenceDefaultsButton")
+        self.restoreDefaultsButton.setAccessibleName("Restore preference defaults")
+        self.restoreDefaultsButton.setToolTip(
+            "Restore the preferences shown here to their defaults"
+            )
+        self.restoreDefaultsButton.clicked.connect(self.restore_defaults)
+        layout.addWidget(self.buttonBox)
+
+    def _appearance_tab(self):
+        tab = qtw.QWidget(self)
+        form = qtw.QFormLayout(tab)
+        form.setFieldGrowthPolicy(qtw.QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
+        form.setContentsMargins(8, 8, 8, 8)
+        form.setSpacing(8)
+
+        self.themeCombo = qtw.QComboBox(tab)
+        self.themeCombo.setObjectName("themePreferenceCombo")
+        self.themeCombo.setAccessibleName("Theme")
+        for label, value in THEME_OPTIONS:
+            self.themeCombo.addItem(label, value)
+        self._add_row(form, "&Theme:", self.themeCombo)
+
+        self.colorbarWidthSpin = qtw.QSpinBox(tab)
+        self.colorbarWidthSpin.setObjectName("colorbarWidthPreferenceSpin")
+        self.colorbarWidthSpin.setAccessibleName("Color scale width")
+        self.colorbarWidthSpin.setRange(1, 500)
+        self.colorbarWidthSpin.setSuffix(" px")
+        self.colorbarWidthSpin.setToolTip(
+            "Width of heatmap colour scale bars"
+            )
+        self._add_row(form, "Color scale &width:", self.colorbarWidthSpin)
+
+        self.axisTickWidthSpin = qtw.QDoubleSpinBox(tab)
+        self.axisTickWidthSpin.setObjectName("axisTickWidthPreferenceSpin")
+        self.axisTickWidthSpin.setAccessibleName("Axis and tick width")
+        self.axisTickWidthSpin.setRange(0.5, 10.0)
+        self.axisTickWidthSpin.setSingleStep(0.5)
+        self.axisTickWidthSpin.setDecimals(1)
+        self.axisTickWidthSpin.setSuffix(" px")
+        self.axisTickWidthSpin.setToolTip(
+            "Line width for every plot axis and major and minor tick mark, "
+            "including colour scales"
+            )
+        self._add_row(form, "Axis and tick &width:", self.axisTickWidthSpin)
+
+        self.axisMajorTickCountSpin = qtw.QSpinBox(tab)
+        self.axisMajorTickCountSpin.setObjectName("axisMajorTickCountPreferenceSpin")
+        self.axisMajorTickCountSpin.setAccessibleName("Target labels per axis")
+        self.axisMajorTickCountSpin.setRange(2, 10)
+        self.axisMajorTickCountSpin.setToolTip(
+            "Target number of labelled major ticks on each axis, including "
+            "the heatmap colour scale"
+            )
+        self._add_row(form, "&Target labels per axis:", self.axisMajorTickCountSpin)
+
+        self.previewSizeSpin = qtw.QSpinBox(tab)
+        self.previewSizeSpin.setObjectName("previewSizePreferenceSpin")
+        self.previewSizeSpin.setAccessibleName("Preview size")
+        self.previewSizeSpin.setRange(50, 1000)
+        self.previewSizeSpin.setSingleStep(50)
+        self.previewSizeSpin.setSuffix(" px")
+        self._add_row(form, "&Preview size:", self.previewSizeSpin)
+
+        self.refreshRateSpin = qtw.QDoubleSpinBox(tab)
+        self.refreshRateSpin.setObjectName("refreshRatePreferenceSpin")
+        self.refreshRateSpin.setAccessibleName("Default refresh interval")
+        self.refreshRateSpin.setRange(0.0, 10_000.0)
+        self.refreshRateSpin.setSingleStep(0.1)
+        self.refreshRateSpin.setDecimals(1)
+        self.refreshRateSpin.setSuffix(" s")
+        self._add_row(form, "&Default refresh interval:", self.refreshRateSpin)
+
+        return tab
+
+    def _interaction_tab(self):
+        tab = qtw.QWidget(self)
+        form = qtw.QFormLayout(tab)
+        form.setFieldGrowthPolicy(qtw.QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
+        form.setContentsMargins(8, 8, 8, 8)
+        form.setSpacing(8)
+
+        self.mouseModeCombo = qtw.QComboBox(tab)
+        self.mouseModeCombo.setObjectName("mouseModePreferenceCombo")
+        self.mouseModeCombo.setAccessibleName("Mouse mode")
+        for label, value in MOUSE_MODE_OPTIONS:
+            self.mouseModeCombo.addItem(label, value)
+        self._add_row(form, "&Mouse mode:", self.mouseModeCombo)
+
+        self.copyPlotImageResolutionCombo = qtw.QComboBox(tab)
+        self.copyPlotImageResolutionCombo.setObjectName(
+            "copyPlotImageResolutionPreferenceCombo"
+            )
+        self.copyPlotImageResolutionCombo.setAccessibleName(
+            "Copy plot image resolution"
+            )
+        for label, value in COPY_PLOT_IMAGE_RESOLUTION_OPTIONS:
+            self.copyPlotImageResolutionCombo.addItem(label, value)
+        self._add_row(
+            form,
+            "&Copy plot image:",
+            self.copyPlotImageResolutionCombo,
+            )
+
+        return tab
+
+    def _files_tab(self):
+        tab = qtw.QWidget(self)
+        form = qtw.QFormLayout(tab)
+        form.setFieldGrowthPolicy(qtw.QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
+        form.setContentsMargins(8, 8, 8, 8)
+        form.setSpacing(8)
+
+        path_widget = qtw.QWidget(tab)
+        path_layout = qtw.QHBoxLayout(path_widget)
+        path_layout.setContentsMargins(0, 0, 0, 0)
+        path_layout.setSpacing(6)
+
+        self.defaultLoadPathEdit = qtw.QLineEdit(tab)
+        self.defaultLoadPathEdit.setObjectName("defaultLoadPathPreferenceEdit")
+        self.defaultLoadPathEdit.setAccessibleName("Default load location")
+        self.defaultLoadPathEdit.setPlaceholderText("No default folder")
+        path_layout.addWidget(self.defaultLoadPathEdit, 1)
+
+        self.defaultLoadPathButton = qtw.QToolButton(tab)
+        self.defaultLoadPathButton.setObjectName("defaultLoadPathPreferenceButton")
+        style = self.style()
+        if style is not None:
+            self.defaultLoadPathButton.setIcon(
+                style.standardIcon(qtw.QStyle.StandardPixmap.SP_DirOpenIcon)
+                )
+        self.defaultLoadPathButton.setToolTip("Choose default load location")
+        self.defaultLoadPathButton.setAccessibleName(
+            "Choose default load location"
+            )
+        self.defaultLoadPathButton.clicked.connect(self.choose_default_load_path)
+        path_layout.addWidget(self.defaultLoadPathButton)
+
+        self._add_row(
+            form,
+            "&Default load location:",
+            path_widget,
+            self.defaultLoadPathEdit,
+            )
+
+        return tab
+
+    def _confirmations_tab(self):
+        tab = qtw.QWidget(self)
+        layout = qtw.QVBoxLayout(tab)
+        layout.setContentsMargins(8, 8, 8, 8)
+        layout.setSpacing(8)
+
+        self.confirmCloseAllCheck = qtw.QCheckBox(
+            "Confirm before closing all plot windows",
+            tab,
+            )
+        self.confirmCloseAllCheck.setObjectName("confirmCloseAllPreferenceCheck")
+        self.confirmCloseAllCheck.setAccessibleName(
+            "Confirm before closing all plot windows"
+            )
+        layout.addWidget(self.confirmCloseAllCheck)
+
+        self.confirmQuitCheck = qtw.QCheckBox("Confirm before quit", tab)
+        self.confirmQuitCheck.setObjectName("confirmQuitPreferenceCheck")
+        self.confirmQuitCheck.setAccessibleName("Confirm before quit")
+        layout.addWidget(self.confirmQuitCheck)
+
+        layout.addStretch(1)
+        return tab
+
+    def _runtime_tab(self):
+        tab = qtw.QWidget(self)
+        form = qtw.QFormLayout(tab)
+        form.setFieldGrowthPolicy(qtw.QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
+        form.setContentsMargins(8, 8, 8, 8)
+        form.setSpacing(8)
+
+        self.maxThreadsSpin = qtw.QSpinBox(tab)
+        self.maxThreadsSpin.setObjectName("maxThreadsPreferenceSpin")
+        self.maxThreadsSpin.setAccessibleName("Maximum worker threads")
+        self.maxThreadsSpin.setRange(1, 999)
+        self._add_row(form, "&Maximum worker threads:", self.maxThreadsSpin)
+
+        self.maxFullHeatmapPointsSpin = qtw.QSpinBox(tab)
+        self.maxFullHeatmapPointsSpin.setObjectName(
+            "maxFullHeatmapPointsPreferenceSpin"
+            )
+        self.maxFullHeatmapPointsSpin.setAccessibleName(
+            "Maximum full-resolution heatmap points"
+            )
+        self.maxFullHeatmapPointsSpin.setRange(1, 2_000_000_000)
+        self.maxFullHeatmapPointsSpin.setSingleStep(100_000)
+        self.maxFullHeatmapPointsSpin.setSuffix(" points")
+        if hasattr(self.maxFullHeatmapPointsSpin, "setGroupSeparatorShown"):
+            self.maxFullHeatmapPointsSpin.setGroupSeparatorShown(True)
+        self.maxFullHeatmapPointsSpin.setToolTip(
+            "Use full-resolution heatmap loading up to this many points; "
+            "larger heatmaps use SQL spatial aggregation."
+            )
+        self._add_row(
+            form,
+            "Full-resolution &heatmap limit:",
+            self.maxFullHeatmapPointsSpin,
+            )
+
+        self.maxHeatmapGridCellsSpin = qtw.QSpinBox(tab)
+        self.maxHeatmapGridCellsSpin.setObjectName(
+            "maxHeatmapGridCellsPreferenceSpin"
+            )
+        self.maxHeatmapGridCellsSpin.setAccessibleName(
+            "Maximum heatmap display grid cells"
+            )
+        self.maxHeatmapGridCellsSpin.setRange(1, 2_000_000_000)
+        self.maxHeatmapGridCellsSpin.setSingleStep(10_000)
+        self.maxHeatmapGridCellsSpin.setSuffix(" cells")
+        if hasattr(self.maxHeatmapGridCellsSpin, "setGroupSeparatorShown"):
+            self.maxHeatmapGridCellsSpin.setGroupSeparatorShown(True)
+        self.maxHeatmapGridCellsSpin.setToolTip(
+            "Maximum cells in a downsampled heatmap display grid."
+            )
+        self._add_row(
+            form,
+            "Heatmap display grid &cells:",
+            self.maxHeatmapGridCellsSpin,
+            )
+
+        self.maxHeatmapGridSideSpin = qtw.QSpinBox(tab)
+        self.maxHeatmapGridSideSpin.setObjectName(
+            "maxHeatmapGridSidePreferenceSpin"
+            )
+        self.maxHeatmapGridSideSpin.setAccessibleName(
+            "Maximum heatmap display grid bins per axis"
+            )
+        self.maxHeatmapGridSideSpin.setRange(1, 2_000_000_000)
+        self.maxHeatmapGridSideSpin.setSingleStep(100)
+        self.maxHeatmapGridSideSpin.setSuffix(" bins")
+        if hasattr(self.maxHeatmapGridSideSpin, "setGroupSeparatorShown"):
+            self.maxHeatmapGridSideSpin.setGroupSeparatorShown(True)
+        self.maxHeatmapGridSideSpin.setToolTip(
+            "Maximum bins on either axis of a downsampled heatmap display grid."
+            )
+        self._add_row(
+            form,
+            "Heatmap display grid &side:",
+            self.maxHeatmapGridSideSpin,
+            )
+
+        self.delGracePeriodSpin = qtw.QDoubleSpinBox(tab)
+        self.delGracePeriodSpin.setObjectName("deleteGracePreferenceSpin")
+        self.delGracePeriodSpin.setAccessibleName("Dataset release grace period")
+        self.delGracePeriodSpin.setRange(0.0, 300.0)
+        self.delGracePeriodSpin.setSingleStep(1.0)
+        self.delGracePeriodSpin.setDecimals(1)
+        self.delGracePeriodSpin.setSuffix(" s")
+        self._add_row(
+            form,
+            "Dataset release &grace period:",
+            self.delGracePeriodSpin,
+            )
+
+        self.cloudSyncTimeoutSpin = qtw.QDoubleSpinBox(tab)
+        self.cloudSyncTimeoutSpin.setObjectName("cloudSyncPreferenceSpin")
+        self.cloudSyncTimeoutSpin.setAccessibleName("Cloud sync timeout")
+        self.cloudSyncTimeoutSpin.setRange(1.0, 3600.0)
+        self.cloudSyncTimeoutSpin.setSingleStep(10.0)
+        self.cloudSyncTimeoutSpin.setDecimals(1)
+        self.cloudSyncTimeoutSpin.setSuffix(" s")
+        self._add_row(form, "&Cloud sync timeout:", self.cloudSyncTimeoutSpin)
+
+        return tab
+
+    def _add_row(self, form, label_text, widget, buddy=None):
+        label = qtw.QLabel(label_text, self)
+        label.setBuddy(buddy or widget)
+        form.addRow(label, widget)
+
+    def load_from_config(self):
+        """
+        Loads current config values into the dialog widgets.
+
+        """
+        self.set_preference_values({
+            key: self.config.get(key)
+            for key in PREFERENCE_KEYS
+            })
+        self._loaded_control_values = self.preference_values()
+        self._edited_preference_keys.clear()
+
+    def _preference_controls(self):
+        """Return the controls in the same order as their preference keys."""
+        return (
+            self.themeCombo,
+            self.colorbarWidthSpin,
+            self.axisTickWidthSpin,
+            self.axisMajorTickCountSpin,
+            self.previewSizeSpin,
+            self.mouseModeCombo,
+            self.copyPlotImageResolutionCombo,
+            self.defaultLoadPathEdit,
+            self.refreshRateSpin,
+            self.confirmCloseAllCheck,
+            self.confirmQuitCheck,
+            self.maxThreadsSpin,
+            self.maxFullHeatmapPointsSpin,
+            self.maxHeatmapGridCellsSpin,
+            self.maxHeatmapGridSideSpin,
+            self.delGracePeriodSpin,
+            self.cloudSyncTimeoutSpin,
+            )
+
+    def set_preference_values(self, values):
+        """
+        Loads preference values into the dialog widgets.
+
+        """
+        widgets = self._preference_controls()
+        blocked_states = [widget.blockSignals(True) for widget in widgets]
+        try:
+            theme_index = self.themeCombo.findData(values["user_preference.theme"])
+            self.themeCombo.setCurrentIndex(max(theme_index, 0))
+
+            self.colorbarWidthSpin.setValue(int(values[COLORBAR_WIDTH_KEY]))
+            self.axisTickWidthSpin.setValue(float(values[AXIS_TICK_WIDTH_KEY]))
+            self.axisMajorTickCountSpin.setValue(
+                int(values[AXIS_MAJOR_TICK_COUNT_KEY])
+                )
+
+            self.previewSizeSpin.setValue(int(values["GUI.preview_size"]))
+            mouse_mode_index = self.mouseModeCombo.findData(values[MOUSE_MODE_KEY])
+            self.mouseModeCombo.setCurrentIndex(max(mouse_mode_index, 0))
+            copy_resolution_index = self.copyPlotImageResolutionCombo.findData(
+                values[COPY_PLOT_IMAGE_RESOLUTION_KEY]
+                )
+            self.copyPlotImageResolutionCombo.setCurrentIndex(
+                max(copy_resolution_index, 0)
+                )
+            self.defaultLoadPathEdit.setText(str(values["file.default_load_path"]))
+            self.refreshRateSpin.setValue(
+                float(values["user_preference.default_refresh_rate"])
+                )
+            self.confirmCloseAllCheck.setChecked(
+                bool(values[CONFIRM_CLOSE_ALL_KEY])
+                )
+            self.confirmQuitCheck.setChecked(
+                bool(values[CONFIRM_QUIT_KEY])
+                )
+            self.maxThreadsSpin.setValue(
+                int(values["runtime_settings.max_threads"])
+                )
+            self.maxFullHeatmapPointsSpin.setValue(
+                int(values["runtime_settings.max_full_heatmap_points"])
+                )
+            self.maxHeatmapGridCellsSpin.setValue(
+                int(values["runtime_settings.max_heatmap_grid_cells"])
+                )
+            self.maxHeatmapGridSideSpin.setValue(
+                int(values["runtime_settings.max_heatmap_grid_side"])
+                )
+            self.delGracePeriodSpin.setValue(
+                float(values["runtime_settings.del_grace_period"])
+                )
+            self.cloudSyncTimeoutSpin.setValue(
+                float(values["runtime_settings.cloud_sync_timeout"])
+                )
+        finally:
+            for widget, signals_were_blocked in zip(
+                    widgets,
+                    blocked_states,
+                    strict=True,
+                    ):
+                widget.blockSignals(signals_were_blocked)
+
+    def preference_values(self):
+        """
+        Returns the current widget values keyed by config path.
+
+        """
+        values = {
+            "user_preference.theme": self.themeCombo.currentData(),
+            COLORBAR_WIDTH_KEY: int(self.colorbarWidthSpin.value()),
+            AXIS_TICK_WIDTH_KEY: float(self.axisTickWidthSpin.value()),
+            AXIS_MAJOR_TICK_COUNT_KEY: int(self.axisMajorTickCountSpin.value()),
+            "GUI.preview_size": int(self.previewSizeSpin.value()),
+            MOUSE_MODE_KEY: self.mouseModeCombo.currentData(),
+            COPY_PLOT_IMAGE_RESOLUTION_KEY: (
+                self.copyPlotImageResolutionCombo.currentData()
+                ),
+            "file.default_load_path": self.defaultLoadPathEdit.text().strip(),
+            "user_preference.default_refresh_rate": self.refreshRateSpin.value(),
+            CONFIRM_CLOSE_ALL_KEY: self.confirmCloseAllCheck.isChecked(),
+            CONFIRM_QUIT_KEY: self.confirmQuitCheck.isChecked(),
+            "runtime_settings.max_threads": int(self.maxThreadsSpin.value()),
+            "runtime_settings.max_full_heatmap_points": int(
+                self.maxFullHeatmapPointsSpin.value()
+                ),
+            "runtime_settings.max_heatmap_grid_cells": int(
+                self.maxHeatmapGridCellsSpin.value()
+                ),
+            "runtime_settings.max_heatmap_grid_side": int(
+                self.maxHeatmapGridSideSpin.value()
+                ),
+            "runtime_settings.del_grace_period": self.delGracePeriodSpin.value(),
+            "runtime_settings.cloud_sync_timeout": self.cloudSyncTimeoutSpin.value(),
+            }
+        return {
+            key: values[key]
+            for key in PREFERENCE_KEYS
+            }
+
+    def default_preference_values(self):
+        """
+        Returns schema defaults for the preferences shown in this dialog.
+
+        """
+        return {
+            key: self._schema_default(key)
+            for key in PREFERENCE_KEYS
+            }
+
+    def _schema_default(self, key):
+        section, name = key.split(".")
+        schema = self.config.schema["properties"][section]["properties"][name]
+        return deepcopy(schema["default"])
+
+    def apply_preferences(self):
+        """
+        Persists the dialog values and emits preferencesApplied on success.
+
+        """
+        control_values = self.preference_values()
+        # Display precision and text normalization may differ from valid saved
+        # values. Only an actual edit may replace those exact saved values.
+        changed_values = {
+            key: value
+            for key, value in control_values.items()
+            if self.config.get(key) != value and (
+                key in self._edited_preference_keys
+                or value != self._loaded_control_values[key]
+                )
+            }
+        if changed_values and not persist_config_values(
+                self,
+                self.config,
+                changed_values,
+                "the preferences",
+                self.load_from_config,
+                ):
+            return False
+
+        self._loaded_control_values = control_values
+        self._edited_preference_keys.clear()
+        self.preferencesApplied.emit()
+        return True
+
+    def restore_defaults(self):
+        """
+        Restores the preferences shown in this dialog to schema defaults.
+
+        """
+        reply = qtw.QMessageBox.question(
+            self,
+            "Restore Preference Defaults",
+            "Restore the preferences shown in this dialog to their defaults?",
+            qtw.QMessageBox.StandardButton.Yes | qtw.QMessageBox.StandardButton.No,
+            qtw.QMessageBox.StandardButton.No,
+            )
+        if reply != qtw.QMessageBox.StandardButton.Yes:
+            return False
+
+        self.set_preference_values(self.default_preference_values())
+        # Reset is explicit consent to defaults, even when the old value had
+        # the same rounded representation in its control.
+        self._edited_preference_keys.update(PREFERENCE_KEYS)
+        return True
+
+    def choose_default_load_path(self):
+        current_path = self.defaultLoadPathEdit.text().strip()
+        if not os.path.isdir(current_path):
+            current_path = ""
+
+        folder = qtw.QFileDialog.getExistingDirectory(
+            self,
+            "Default Load Location",
+            current_path,
+            )
+        if folder:
+            self.defaultLoadPathEdit.setText(folder)
+
+    def _accept_preferences(self):
+        if self.apply_preferences():
+            self.accept()
+
+
+def create_preferences_action(window, triggered):
+    """
+    Creates the shared Preferences action used by main and plot windows.
+
+    """
+    action = create_action("preferences.open", window)
+    action.setMenuRole(QtGui.QAction.MenuRole.PreferencesRole)
+    action.triggered.connect(triggered)
+    return action