Undo project

build_tools/requirements.txt

@@ -38,4 +38,4 @@ zope
 requests
 
 # Alphabetized list of OS-specific packages
-pywin32; platform_system == "Windows"
+pywin32; platform_system == "Windows"

conftest.py

@@ -1,6 +1,10 @@
 import os
 import platform
 
+# Must be set before any Qt or matplotlib import so that matplotlib's
+# qt_compat.py selects PySide6 instead of raising an ImportError.
+os.environ.setdefault("QT_API", "pyside6")
+
 import pytest
 
 # Run the tests in offscreen mode

docs/sphinx-docs/source/user/menu_bar.rst

@@ -22,12 +22,38 @@ Edit
 ----
 The Edit option allows you to:
 
+- undo the most recent parameter change (``Ctrl+Z``);
+- redo a previously undone parameter change (``Ctrl+Y``);
 - copy and paste parameters between *SasView* analysis windows;
 - copy parameters from a *SasView* analysis window to the Clipboard as either tab-delimited text (compatible with Microsoft Excel) or LaTex-wrapped text;
 - generate a summary 'Report' of the most recent analysis performed;
 - reset parameter values in the P(r) Inversion analysis page;
 - freeze/copy fit results as separate data sets.
 
+The **Undo** and **Redo** commands are also available as buttons in the
+main toolbar, and their tooltips dynamically show which action will be
+reverted (e.g. "Undo Change radius").
+
+Undo/Redo is supported in the following perspectives:
+
+- **Model Fitting** – parameter changes in individual fit pages;
+- **P(r) Inversion** – parameter changes in each inversion page;
+- **Invariant** – parameter changes in the invariant calculator;
+- **Size Distribution** – parameter changes in the size distribution
+  calculator;
+- **Correlation Function** – parameter changes in the correlation
+  function analysis.
+
+Each tab or page maintains its own independent undo history, so
+switching between perspectives or fit pages preserves the undo/redo
+state of each. The default history depth is 200 actions per tab,
+configurable via the ``UNDO_STACK_MAX_DEPTH`` setting in
+:file:`src/sas/system/config/config.py`.
+
+.. note:: Undo/Redo is automatically suppressed during programmatic
+          operations such as loading a project or applying fit results,
+          to prevent spurious entries from cluttering the undo history.
+
 View
 ----
 The View option allows you to:

pyproject.toml

@@ -13,9 +13,6 @@ requires = [
     "periodictable",
     "pyopengl",
     "pyside6",
-    "qtconsole",
-    "scipy",
-    "superqt",
     "sasdata",
     "sasmodels",
     "twisted",

src/ascii_dialog/col_editor.py

@@ -0,0 +1,89 @@
+from typing import cast
+
+from PySide6.QtCore import Signal, Slot
+from PySide6.QtWidgets import QHBoxLayout, QWidget
+
+from sasdata.ascii_reader_metadata import bidirectional_pairings
+from sasdata.quantities.units import NamedUnit
+
+from ascii_dialog.column_unit import ColumnUnit
+
+
+class ColEditor(QWidget):
+    """An editor widget which allows the user to specify the columns of the data
+    from a set of options based on which dataset type has been selected."""
+    column_changed = Signal()
+
+    def __init__(self, cols: int, options: list[str]):
+        super().__init__()
+
+        self.cols = cols
+        self.options = options
+        self.layout = QHBoxLayout(self)
+        self.option_widgets: list[ColumnUnit] = []
+        for _ in range(cols):
+            new_widget = ColumnUnit(self.options)
+            new_widget.column_changed.connect(self.onColumnUpdate)
+            self.layout.addWidget(new_widget)
+            self.option_widgets.append(new_widget)
+
+    @Slot()
+    def onColumnUpdate(self):
+        column_changed = cast(ColumnUnit, self.sender())
+        pairing = bidirectional_pairings.get(column_changed.currentColumn)
+        if pairing is not None:
+            for col_unit in self.option_widgets:
+                # Second condition is important because otherwise, this event will keep being called, and the GUI will
+                # go into an infinite loop.
+                if col_unit.currentColumn == pairing and col_unit.currentUnit != column_changed.currentUnit:
+                    col_unit.currentUnit = column_changed.currentUnit
+
+    def setCols(self, new_cols: int):
+        """Set the amount of columns for the user to edit."""
+
+        # Decides whether we need to extend the current set of combo boxes, or
+        # remove some.
+        if self.cols < new_cols:
+            for _ in range(new_cols - self.cols):
+                new_widget = ColumnUnit(self.options)
+                new_widget.column_changed.connect(self.onColumnUpdate)
+                self.layout.addWidget(new_widget)
+                self.option_widgets.append(new_widget)
+
+            self.cols = new_cols
+        if self.cols > new_cols:
+            excess_cols = self.cols - new_cols
+            length = len(self.option_widgets)
+            excess_combo_boxes = self.option_widgets[length - excess_cols:length]
+            for box in excess_combo_boxes:
+                self.layout.removeWidget(box)
+                box.setParent(None)
+            self.option_widgets = self.option_widgets[0:length - excess_cols]
+            self.cols = new_cols
+        self.column_changed.emit()
+
+    def setColOrder(self, cols: list[str]):
+        """Sets the series of currently selected columns to be cols, in that
+        order. If there are not enough column widgets include as many of the
+        columns in cols as possible.
+
+        """
+        try:
+            for i, col_name in enumerate(cols):
+                self.option_widgets[i].setCurrentColumn(col_name)
+        except IndexError:
+            pass # Can ignore because it means we've run out of widgets.
+
+    def colNames(self) -> list[str]:
+        """Get a list of all of the currently selected columns."""
+        return [widget.currentColumn for widget in self.option_widgets]
+
+    @property
+    def columns(self) -> list[tuple[str, NamedUnit | None]]:
+        return [(widget.currentColumn, widget.currentUnit if widget.currentColumn != "<ignore>" else None) for widget in self.option_widgets]
+
+    def replaceOptions(self, new_options: list[str]) -> None:
+        """Replace options from which the user can choose for each column."""
+        self.options = new_options
+        for widget in self.option_widgets:
+            widget.replaceOptions(new_options)

src/ascii_dialog/column_unit.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+
+from PySide6.QtCore import Signal, Slot
+from PySide6.QtGui import QRegularExpressionValidator
+from PySide6.QtWidgets import QComboBox, QHBoxLayout, QSizePolicy, QWidget
+
+from sasdata.dataset_types import unit_kinds
+from sasdata.default_units import defaults_or_fallback
+from sasdata.quantities.units import NamedUnit
+
+from ascii_dialog.unit_selector import UnitSelector
+
+
+def configure_size_policy(combo_box: QComboBox) -> None:
+    policy = combo_box.sizePolicy()
+    policy.setHorizontalPolicy(QSizePolicy.Policy.Ignored)
+    combo_box.setSizePolicy(policy)
+
+class ColumnUnit(QWidget):
+    """Widget with 2 combo boxes: one allowing the user to pick a column, and
+    another to specify the units for that column."""
+    def __init__(self, options) -> None:
+        super().__init__()
+        self.col_widget = self.createColComboBox(options)
+        self.unit_widget = self.createUnitComboBox(self.col_widget.currentText())
+        self.layout = QHBoxLayout(self)
+        self.layout.addWidget(self.col_widget)
+        self.layout.addWidget(self.unit_widget)
+        self.current_option: str
+
+    column_changed = Signal()
+
+    def createColComboBox(self, options: list[str]) -> QComboBox:
+        """Create the combo box for specifying the column based on the given
+        options."""
+        new_combo_box = QComboBox()
+        configure_size_policy(new_combo_box)
+        for option in options:
+            new_combo_box.addItem(option)
+        new_combo_box.setEditable(True)
+        validator = QRegularExpressionValidator(r"[a-zA-Z0-9]+")
+        new_combo_box.setValidator(validator)
+        new_combo_box.currentTextChanged.connect(self.onOptionChange)
+        return new_combo_box
+
+    def createUnitComboBox(self, selected_option: str) -> QComboBox:
+        """Create the combo box for specifying the unit for selected_option"""
+        new_combo_box = QComboBox()
+        configure_size_policy(new_combo_box)
+        new_combo_box.setEditable(True)
+        self.updateUnits(new_combo_box, selected_option)
+        new_combo_box.currentTextChanged.connect(self.onUnitChange)
+        return new_combo_box
+
+    def updateUnits(self, unit_box: QComboBox, selected_option: str):
+        unit_box.clear()
+        self.current_option = selected_option
+        # Use the list of preferred units but fallback to the first 5 if there aren't any for this particular column.
+        if self.current_option == '<ignore>':
+            unit_box.setDisabled(True)
+        else:
+            unit_box.setDisabled(False)
+            unit_options = defaults_or_fallback(self.current_option)
+            option_symbols = [unit.symbol for unit in unit_options]
+            for option in option_symbols[:5]:
+                unit_box.addItem(option)
+            unit_box.addItem('Select More')
+
+
+    def replaceOptions(self, new_options) -> None:
+        """Replace the old options for the column with new_options"""
+        self.col_widget.clear()
+        self.col_widget.addItems(new_options)
+
+    def setCurrentColumn(self, new_column_value: str) -> None:
+        """Change the current selected column to new_column_value"""
+        self.col_widget.setCurrentText(new_column_value)
+        self.updateUnits(self.unit_widget, new_column_value)
+
+
+    @Slot()
+    def onOptionChange(self):
+        # If the new option is empty string, its probably because the current
+        # options have been removed. Can safely ignore this.
+        self.column_changed.emit()
+        new_option = self.col_widget.currentText()
+        if new_option == '':
+            return
+        try:
+            self.updateUnits(self.unit_widget, new_option)
+        except KeyError:
+            # Means the units for this column aren't known. This shouldn't be
+            # the case in the real version so for now we'll just clear the unit
+            # widget.
+            self.unit_widget.clear()
+
+    @Slot()
+    def onUnitChange(self):
+        new_text = self.unit_widget.currentText()
+        if new_text == 'Select More':
+            selector = UnitSelector(unit_kinds[self.col_widget.currentText()].name, False)
+            selector.exec()
+            # We need the selection unit in the list of options, or else QT has some dodgy behaviour.
+            self.unit_widget.insertItem(-1, selector.selected_unit.symbol)
+            self.unit_widget.setCurrentText(selector.selected_unit.symbol)
+        # This event could get triggered when the units have just been cleared, and not actually updated. We don't want
+        # to trigger it in this case.
+        elif not new_text == '':
+            self.column_changed.emit()
+
+    @property
+    def currentColumn(self):
+        """The currently selected column."""
+        return self.col_widget.currentText()
+
+    @property
+    def currentUnit(self) -> NamedUnit:
+        """The currently selected unit."""
+        current_unit_symbol = self.unit_widget.currentText()
+        for unit in unit_kinds[self.current_option].units:
+            if current_unit_symbol == unit.symbol:
+                return unit
+        # This error shouldn't really happen so if it does, it indicates there is a bug in the code.
+        raise ValueError("Current unit doesn't seem to exist")
+
+    @currentUnit.setter
+    def currentUnit(self, new_value: NamedUnit):
+        self.unit_widget.setCurrentText(new_value.symbol)

src/ascii_dialog/constants.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+
+TABLE_MAX_ROWS = 1000
+NOFILE_TEXT = "Click the button below to load a file."