added layers widget

fixed absorption saving

fixed tests

Author: alexhroom

rascal2/widgets/delegates.py

@@ -76,3 +76,28 @@ def setEditorData(self, editor: AdaptiveDoubleSpinBox, index):
     def setModelData(self, editor, model, index):
         data = editor.value()
         model.setData(index, data, QtCore.Qt.ItemDataRole.EditRole)
+
+
+class ParametersDelegate(QtWidgets.QStyledItemDelegate):
+    """Item delegate to choose from existing draft project parameters."""
+
+    def __init__(self, project_widget, parent):
+        super().__init__(parent)
+        self.project_widget = project_widget
+
+    def createEditor(self, parent, option, index):
+        widget = QtWidgets.QComboBox(parent)
+        parameters = self.project_widget.draft_project["parameters"]
+        names = [p.name for p in parameters]
+        widget.addItems(names)
+        widget.setCurrentText(index.data(QtCore.Qt.ItemDataRole.DisplayRole))
+
+        return widget
+
+    def setEditorData(self, editor: QtWidgets.QWidget, index):
+        data = index.data(QtCore.Qt.ItemDataRole.DisplayRole)
+        editor.setCurrentText(data)
+
+    def setModelData(self, editor, model, index):
+        data = editor.currentText()
+        model.setData(index, data, QtCore.Qt.ItemDataRole.EditRole)

rascal2/widgets/project/models.py

@@ -8,7 +8,7 @@
 from RATapi.utils.enums import Procedures
 
 from rascal2.config import path_for
-from rascal2.widgets.delegates import ValidatedInputDelegate, ValueSpinBoxDelegate
+from rascal2.widgets.delegates import ParametersDelegate, ValidatedInputDelegate, ValueSpinBoxDelegate
 
 
 class ClassListModel(QtCore.QAbstractTableModel):
@@ -28,12 +28,21 @@ class ClassListModel(QtCore.QAbstractTableModel):
     def __init__(self, classlist: RATapi.ClassList, parent: QtWidgets.QWidget):
         super().__init__(parent)
         self.parent = parent
+
+        self.classlist: RATapi.ClassList
+        self.item_type: type
+        self.headers: list[str]
+
+        self.setup_classlist(classlist)
+        self.edit_mode = False
+
+    def setup_classlist(self, classlist: RATapi.ClassList):
+        """Setup the ClassList, type and headers for the model."""
         self.classlist = classlist
         self.item_type = classlist._class_handle
         if not issubclass(self.item_type, pydantic.BaseModel):
             raise NotImplementedError("ClassListModel only works for classlists of Pydantic models!")
         self.headers = list(self.item_type.model_fields)
-        self.edit_mode = False
 
     def rowCount(self, parent=None) -> int:
         return len(self.classlist)
@@ -296,3 +305,104 @@ def edit(self):
         for i in range(0, self.model.rowCount()):
             if i in self.model.protected_indices:
                 self.table.setIndexWidget(self.model.index(i, 0), None)
+
+
+class LayersModel(ClassListModel):
+    """Classlist model for Layers."""
+
+    def __init__(self, classlist: RATapi.ClassList, parent: QtWidgets.QWidget):
+        super().__init__(classlist, parent)
+        self.absorption = classlist._class_handle == RATapi.models.AbsorptionLayer
+        self.SLD_imags = {}
+
+    def flags(self, index):
+        flags = super().flags(index)
+        if self.edit_mode:
+            flags |= QtCore.Qt.ItemFlag.ItemIsEditable
+        return flags
+
+    def append_item(self):
+        kwargs = {"thickness": "", "SLD": "", "roughness": ""}
+        if self.absorption:
+            kwargs["SLD_imaginary"] = ""
+        self.classlist.append(self.item_type(**kwargs))
+        self.endResetModel()
+
+    def set_absorption(self, absorption: bool):
+        """Set whether the project is using absorption or not.
+
+        Parameters
+        ----------
+        absorption : bool
+            Whether the project is using absorption.
+
+        """
+        if self.absorption != absorption:
+            self.beginResetModel()
+            self.absorption = absorption
+            if absorption:
+                classlist = RATapi.ClassList(
+                    [
+                        RATapi.models.AbsorptionLayer(
+                            **dict(layer),
+                            SLD_imaginary=self.SLD_imags.get(layer.name, ""),
+                        )
+                        for layer in self.classlist
+                    ]
+                )
+                # set handle manually for if classlist is empty
+                classlist._class_handle = RATapi.models.AbsorptionLayer
+            else:
+                # we save the SLD_imaginary values so that they aren't lost if the
+                # user accidentally toggles absorption off and on!
+                self.SLD_imags = {layer.name: layer.SLD_imaginary for layer in self.classlist}
+                classlist = RATapi.ClassList(
+                    [
+                        RATapi.models.Layer(
+                            name=layer.name,
+                            thickness=layer.thickness,
+                            SLD=layer.SLD_real,
+                            roughness=layer.roughness,
+                            hydration=layer.hydration,
+                            hydrate_with=layer.hydrate_with,
+                        )
+                        for layer in self.classlist
+                    ]
+                )
+                classlist._class_handle = RATapi.models.Layer
+            self.setup_classlist(classlist)
+            self.parent.parent.parent.update_draft_project({"layers": classlist})
+            self.endResetModel()
+
+
+class LayerFieldWidget(ProjectFieldWidget):
+    """Project field widget for Layer objects."""
+
+    classlist_model = LayersModel
+
+    def __init__(self, field, parent):
+        super().__init__(field, parent)
+        self.project_widget = parent.parent
+
+    def set_item_delegates(self):
+        for i in range(1, self.model.columnCount()):
+            if i in [1, self.model.columnCount() - 1]:
+                header = self.model.headers[i - 1]
+                self.table.setItemDelegateForColumn(
+                    i, ValidatedInputDelegate(self.model.item_type.model_fields[header], self.table)
+                )
+            else:
+                self.table.setItemDelegateForColumn(i, ParametersDelegate(self.project_widget, self.table))
+
+    def set_absorption(self, absorption: bool):
+        """Set whether the classlist uses AbsorptionLayers.
+
+        Parameters
+        ----------
+        absorption : bool
+            Whether the classlist should use AbsorptionLayers.
+
+        """
+        self.model.set_absorption(absorption)
+        if self.model.edit_mode:
+            self.edit()

rascal2/widgets/project/project.py

@@ -7,7 +7,7 @@
 from RATapi.utils.enums import Calculations, Geometries, LayerModels
 
 from rascal2.config import path_for
-from rascal2.widgets.project.models import ParameterFieldWidget, ProjectFieldWidget
+from rascal2.widgets.project.models import LayerFieldWidget, ParameterFieldWidget, ProjectFieldWidget
 
 
 class ProjectWidget(QtWidgets.QWidget):
@@ -34,7 +34,7 @@ def __init__(self, parent):
         self.tabs = {
             "Parameters": ["parameters"],
             "Experimental Parameters": ["scalefactors", "bulk_in", "bulk_out"],
-            "Layers": [],
+            "Layers": ["layers"],
             "Data": [],
             "Backgrounds": [],
             "Contrasts": [],
@@ -62,49 +62,66 @@ def __init__(self, parent):
     def create_project_view(self) -> None:
         """Creates the project (non-edit) view"""
         project_widget = QtWidgets.QWidget()
-        main_layout = QtWidgets.QGridLayout()
-        main_layout.setVerticalSpacing(20)
+        main_layout = QtWidgets.QVBoxLayout()
+        main_layout.setSpacing(20)
 
         self.edit_project_button = QtWidgets.QPushButton(
             "Edit Project", self, objectName="bluebutton", icon=QtGui.QIcon(path_for("edit.png"))
         )
         self.edit_project_button.clicked.connect(self.show_edit_view)
-        main_layout.addWidget(self.edit_project_button, 0, 5)
+        button_layout = QtWidgets.QHBoxLayout()
+        button_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
+        button_layout.addWidget(self.edit_project_button)
+
+        main_layout.addLayout(button_layout)
+
+        settings_layout = QtWidgets.QHBoxLayout()
+        settings_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignHCenter)
+
+        absorption_label = QtWidgets.QLabel("Absorption:", self, objectName="boldlabel")
+        self.absorption_checkbox = QtWidgets.QCheckBox()
+        # this is how you make a checkbox read-only but still checkable from inside code...
+        self.absorption_checkbox.setAttribute(QtCore.Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+
+        settings_layout.addWidget(absorption_label)
+        settings_layout.addWidget(self.absorption_checkbox)
 
         self.calculation_label = QtWidgets.QLabel("Calculation:", self, objectName="boldlabel")
 
         self.calculation_type = QtWidgets.QLineEdit(self)
         self.calculation_type.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
         self.calculation_type.setReadOnly(True)
 
-        main_layout.addWidget(self.calculation_label, 1, 0, 1, 1)
-        main_layout.addWidget(self.calculation_type, 1, 1, 1, 1)
+        settings_layout.addWidget(self.calculation_label)
+        settings_layout.addWidget(self.calculation_type)
 
         self.model_type_label = QtWidgets.QLabel("Model Type:", self, objectName="boldlabel")
 
         self.model_type = QtWidgets.QLineEdit(self)
         self.model_type.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
         self.model_type.setReadOnly(True)
 
-        main_layout.addWidget(self.model_type_label, 1, 2, 1, 1)
-        main_layout.addWidget(self.model_type, 1, 3, 1, 1)
+        settings_layout.addWidget(self.model_type_label)
+        settings_layout.addWidget(self.model_type)
 
         self.geometry_label = QtWidgets.QLabel("Geometry:", self, objectName="boldlabel")
 
         self.geometry_type = QtWidgets.QLineEdit(self)
         self.geometry_type.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
         self.geometry_type.setReadOnly(True)
 
-        main_layout.addWidget(self.geometry_label, 1, 4, 1, 1)
-        main_layout.addWidget(self.geometry_type, 1, 5, 1, 1)
+        settings_layout.addWidget(self.geometry_label)
+        settings_layout.addWidget(self.geometry_type)
+
+        main_layout.addLayout(settings_layout)
 
         self.project_tab = QtWidgets.QTabWidget()
 
         for tab, fields in self.tabs.items():
             widget = self.view_tabs[tab] = ProjectTabWidget(fields, self)
             self.project_tab.addTab(widget, tab)
 
-        main_layout.addWidget(self.project_tab, 2, 0, 1, 6)
+        main_layout.addWidget(self.project_tab)
         project_widget.setLayout(main_layout)
 
         return project_widget
@@ -124,38 +141,58 @@ def create_edit_view(self) -> None:
         self.cancel_button.setIcon(QtGui.QIcon(path_for("cancel-dark.png")))
         self.cancel_button.clicked.connect(self.cancel_changes)
 
-        layout = QtWidgets.QHBoxLayout()
-        layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
-        layout.addWidget(self.save_project_button)
-        layout.addWidget(self.cancel_button)
-        main_layout.addLayout(layout)
+        buttons_layout = QtWidgets.QHBoxLayout()
+        buttons_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
+        buttons_layout.addWidget(self.save_project_button)
+        buttons_layout.addWidget(self.cancel_button)
+        main_layout.addLayout(buttons_layout)
+
+        settings_layout = QtWidgets.QHBoxLayout()
+        settings_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignHCenter)
+
+        absorption_label = QtWidgets.QLabel("Absorption:", self, objectName="boldlabel")
+        self.edit_absorption_checkbox = QtWidgets.QCheckBox()
+
+        settings_layout.addWidget(absorption_label)
+        settings_layout.addWidget(self.edit_absorption_checkbox)
 
         self.edit_calculation_label = QtWidgets.QLabel("Calculation:", self, objectName="boldlabel")
 
         self.calculation_combobox = QtWidgets.QComboBox(self)
+        self.calculation_combobox.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.MinimumExpanding, QtWidgets.QSizePolicy.Policy.Fixed
+        )
         self.calculation_combobox.addItems([calc for calc in Calculations])
 
-        layout = QtWidgets.QHBoxLayout()
-        layout.addWidget(self.edit_calculation_label)
-        layout.addWidget(self.calculation_combobox)
+        settings_layout.addWidget(self.edit_calculation_label)
+        settings_layout.addWidget(self.calculation_combobox)
 
         self.edit_model_type_label = QtWidgets.QLabel("Model Type:", self, objectName="boldlabel")
 
         self.model_combobox = QtWidgets.QComboBox(self)
+        self.model_combobox.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.MinimumExpanding, QtWidgets.QSizePolicy.Policy.Fixed
+        )
         self.model_combobox.addItems([model for model in LayerModels])
 
-        layout.addWidget(self.edit_model_type_label)
-        layout.addWidget(self.model_combobox)
+        settings_layout.addWidget(self.edit_model_type_label)
+        settings_layout.addWidget(self.model_combobox)
 
         self.edit_geometry_label = QtWidgets.QLabel("Geometry:", self, objectName="boldlabel")
 
         self.geometry_combobox = QtWidgets.QComboBox(self)
+        self.geometry_combobox.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.MinimumExpanding, QtWidgets.QSizePolicy.Policy.Fixed
+        )
         self.geometry_combobox.addItems([geo for geo in Geometries])
 
-        layout.addWidget(self.edit_geometry_label)
-        layout.addWidget(self.geometry_combobox)
-        main_layout.addLayout(layout)
+        settings_layout.addWidget(self.edit_geometry_label)
+        settings_layout.addWidget(self.geometry_combobox)
+        main_layout.addLayout(settings_layout)
 
+        self.edit_absorption_checkbox.checkStateChanged.connect(
+            lambda s: self.update_draft_project({"absorption": s == QtCore.Qt.CheckState.Checked})
+        )
         self.calculation_combobox.currentTextChanged.connect(lambda s: self.update_draft_project({"calculation": s}))
         self.calculation_combobox.currentTextChanged.connect(lambda: self.handle_domains_tab())
         self.model_combobox.currentTextChanged.connect(lambda s: self.update_draft_project({"model": s}))
@@ -166,6 +203,10 @@ def create_edit_view(self) -> None:
             widget = self.edit_tabs[tab] = ProjectTabWidget(fields, self, edit_mode=True)
             self.edit_project_tab.addTab(widget, tab)
 
+        self.edit_absorption_checkbox.checkStateChanged.connect(
+            lambda s: self.edit_tabs["Layers"].tables["layers"].set_absorption(s == QtCore.Qt.CheckState.Checked)
+        )
+
         main_layout.addWidget(self.edit_project_tab)
 
         edit_project_widget.setLayout(main_layout)
@@ -178,10 +219,12 @@ def update_project_view(self) -> None:
         # because we don't want validation errors going off while editing the model is in-progress
         self.draft_project: dict = create_draft_project(self.parent_model.project)
 
+        self.absorption_checkbox.setChecked(self.parent_model.project.absorption)
         self.calculation_type.setText(self.parent_model.project.calculation)
         self.model_type.setText(self.parent_model.project.model)
         self.geometry_type.setText(self.parent_model.project.geometry)
 
+        self.edit_absorption_checkbox.setChecked(self.parent_model.project.absorption)
         self.calculation_combobox.setCurrentText(self.parent_model.project.calculation)
         self.model_combobox.setCurrentText(self.parent_model.project.model)
         self.geometry_combobox.setCurrentText(self.parent_model.project.geometry)
@@ -271,6 +314,8 @@ def __init__(self, fields: list[str], parent, edit_mode: bool = False):
         for field in self.fields:
             if field in RATapi.project.parameter_class_lists:
                 self.tables[field] = ParameterFieldWidget(field, self)
+            elif field == "layers":
+                self.tables[field] = LayerFieldWidget(field, self)
             else:
                 self.tables[field] = ProjectFieldWidget(field, self)
             layout.addWidget(self.tables[field])
@@ -302,6 +347,8 @@ def update_model(self, new_model):
             table.update_model(classlist)
             if self.edit_mode:
                 table.edit()
+            if "layers" in self.tables:
+                self.tables["layers"].set_absorption(new_model["absorption"])
 
     def handle_controls_update(self, controls):
         """Reflect changes to the Controls object."""