ui-state

Author: tlambert03

src/pymmcore_widgets/config_presets/_config_groups_editor.py

@@ -43,6 +43,26 @@ def _copy_named_obj(obj: T, new_name: str) -> T:
     return obj
 
 
+# State management for groupbox and property checkbox states
+class _GroupboxState:
+    """Stores the state of a groupbox and its contained property checkboxes."""
+
+    def __init__(self) -> None:
+        self.groupbox_checked: bool = True
+        # (device, property) -> checked
+        self.property_states: dict[tuple[str, str], bool] = {}
+        self.active_device: str = ""  # For active camera/shutter
+
+
+class _PresetUIState:
+    """Stores UI state for all groupboxes in a specific preset."""
+
+    def __init__(self) -> None:
+        self.light_path: _GroupboxState = _GroupboxState()
+        self.camera: _GroupboxState = _GroupboxState()
+        self.objective: _GroupboxState = _GroupboxState()
+
+
 class ConfigGroupsEditor(QWidget):
     """Widget for managing configuration groups and presets.
 
@@ -63,6 +83,10 @@ def __init__(
     ) -> None:
         super().__init__(parent)
 
+        # State management for groupbox and property checkbox states
+        # Key: (group_name, preset_name), Value: _PresetUIState
+        self._ui_states: dict[tuple[str, str], _PresetUIState] = {}
+
         self.groups = MapManager(
             ConfigGroup, clone_function=_copy_named_obj, parent=self, base_key="Group"
         )
@@ -120,6 +144,11 @@ def __init__(
         self._cam_group.valueChanged.connect(self._update_model_from_gui)
         self._obj_group.valueChanged.connect(self._update_model_from_gui)
 
+        # Connect groupbox toggle signals to save state when toggled
+        self._light_path_group.toggled.connect(self._on_groupbox_toggled)
+        self._cam_group.toggled.connect(self._on_groupbox_toggled)
+        self._obj_group.toggled.connect(self._on_groupbox_toggled)
+
     # Public API -------------------------------------------------------
 
     def setData(self, data: Iterable[ConfigGroup]) -> None:
@@ -175,6 +204,15 @@ def currentSettings(self) -> Collection[Setting]:
                 }
             )
 
+        if self._obj_group.isChecked():
+            settings.update(
+                {
+                    (dev, prop): val
+                    for dev, prop, val in self._obj_group.settings()
+                    if val not in ("", None)
+                }
+            )
+
         return [Setting(k[0], k[1], v) for k, v in settings.items()]
 
     def setCurrentSettings(self, settings: Iterable[Setting]) -> None:
@@ -219,6 +257,8 @@ def update_options_from_core(self, core: CMMCorePlus) -> None:
     # PRIVATE -----------------------------------------------------------
 
     def _on_current_group_changed(self) -> None:
+        # Save current state before switching
+        self._save_current_state()
         with signals_blocked(self.presets):
             if config_group := self.groups.currentValue():
                 self.presets.setRoot(config_group.presets)
@@ -234,11 +274,150 @@ def _selected_preset(self) -> ConfigPreset | None:
     def _update_gui_from_model(self) -> None:
         if preset := self._selected_preset():
             self.setCurrentSettings(preset.settings)
+        # Restore the UI state for this preset
+        self._restore_state()
 
     def _update_model_from_gui(self) -> None:
         if preset := self._selected_preset():
             preset.settings = list(self.currentSettings())
 
+    # State management methods ----------------------------------------
+
+    def _get_preset_state_key(self) -> tuple[str, str] | None:
+        """Get the current state key (group_name, preset_name)."""
+        group_name = self.groups.currentKey()
+        preset_name = self.presets.currentKey()
+        if group_name is not None and preset_name is not None:
+            return (group_name, preset_name)
+        return None
+
+    def _get_current_ui_state(self) -> _PresetUIState:
+        """Get or create the UI state for the current group/preset."""
+        key = self._get_preset_state_key()
+        if key is None:
+            return _PresetUIState()
+        return self._ui_states.setdefault(key, _PresetUIState())
+
+    def _save_current_state(self) -> None:
+        """Save the current UI state for the current group/preset."""
+        key = self._get_preset_state_key()
+        if key is None:
+            return
+
+        ui_state = self._ui_states.setdefault(key, _PresetUIState())
+
+        # Save light path state
+        ui_state.light_path.groupbox_checked = self._light_path_group.isChecked()
+        ui_state.light_path.active_device = (
+            self._light_path_group.active_shutter.currentText()
+        )
+        ui_state.light_path.property_states.clear()
+        # Save all property checkbox states, regardless of groupbox state
+        for row in range(self._light_path_group.props.rowCount()):
+            item = self._light_path_group.props.item(row, 0)
+            if item is not None:
+                # Extract device and property from item text (format: "device-property")
+                text = item.text()
+                if "-" in text:
+                    parts = text.split("-", 1)  # Split only on first dash
+                    if len(parts) == 2:
+                        dev, prop = parts
+                        ui_state.light_path.property_states[(dev, prop)] = (
+                            item.checkState() == Qt.CheckState.Checked
+                        )
+
+        # Save camera state
+        ui_state.camera.groupbox_checked = self._cam_group.isChecked()
+        ui_state.camera.active_device = self._cam_group.active_camera.currentText()
+        ui_state.camera.property_states.clear()
+        # Save all property checkbox states, regardless of groupbox state
+        for row in range(self._cam_group.props.rowCount()):
+            item = self._cam_group.props.item(row, 0)
+            if item is not None:
+                # Extract device and property from item text: "device-property"
+                text = item.text()
+                if "-" in text:
+                    parts = text.split("-", 1)  # Split only on first dash
+                    if len(parts) == 2:
+                        dev, prop = parts
+                        ui_state.camera.property_states[(dev, prop)] = (
+                            item.checkState() == Qt.CheckState.Checked
+                        )
+
+        # Save objective state
+        ui_state.objective.groupbox_checked = self._obj_group.isChecked()
+        # Note: ObjectiveGroupBox doesn't have props yet, will need to add
+
+    def _restore_state(self) -> None:
+        """Restore the UI state for the current group/preset."""
+        ui_state = self._get_current_ui_state()
+
+        # Block signals to prevent triggering valueChanged during restoration
+        with (
+            signals_blocked(self._light_path_group),
+            signals_blocked(self._cam_group),
+            signals_blocked(self._obj_group),
+        ):
+            # Restore light path state
+            self._light_path_group.setChecked(ui_state.light_path.groupbox_checked)
+            if ui_state.light_path.active_device:
+                self._light_path_group.active_shutter.setCurrentText(
+                    ui_state.light_path.active_device
+                )
+
+            # Restore light path property checkboxes
+            for row in range(self._light_path_group.props.rowCount()):
+                item = self._light_path_group.props.item(row, 0)
+                if item is not None:
+                    text = item.text()
+                    if "-" in text:
+                        parts = text.split("-", 1)
+                        if len(parts) == 2:
+                            dev, prop = parts
+                            if (dev, prop) in ui_state.light_path.property_states:
+                                checked = ui_state.light_path.property_states[
+                                    (dev, prop)
+                                ]
+                                check_state = (
+                                    Qt.CheckState.Checked
+                                    if checked
+                                    else Qt.CheckState.Unchecked
+                                )
+                                item.setCheckState(check_state)
+
+            # Restore camera state
+            self._cam_group.setChecked(ui_state.camera.groupbox_checked)
+            if ui_state.camera.active_device:
+                self._cam_group.active_camera.setCurrentText(
+                    ui_state.camera.active_device
+                )
+
+            # Restore camera property checkboxes
+            for row in range(self._cam_group.props.rowCount()):
+                item = self._cam_group.props.item(row, 0)
+                if item is not None:
+                    text = item.text()
+                    if "-" in text:
+                        parts = text.split("-", 1)
+                        if len(parts) == 2:
+                            dev, prop = parts
+                            if (dev, prop) in ui_state.camera.property_states:
+                                checked = ui_state.camera.property_states[(dev, prop)]
+                                check_state = (
+                                    Qt.CheckState.Checked
+                                    if checked
+                                    else Qt.CheckState.Unchecked
+                                )
+                                item.setCheckState(check_state)
+
+            # Restore objective state
+            self._obj_group.setChecked(ui_state.objective.groupbox_checked)
+
+    def _on_groupbox_toggled(self) -> None:
+        """Handle groupbox toggle events - save state and update model."""
+        self._save_current_state()
+        self._update_model_from_gui()
+
 
 def _is_not_objective(item: QTableWidgetItem, prop: DeviceProperty) -> bool:
     return not any(x in prop.device for x in prop.core.guessObjectiveDevices())
@@ -383,3 +562,9 @@ def __init__(self, parent: QWidget | None = None) -> None:
         layout = QVBoxLayout(self)
         layout.addWidget(self._obj_wdg)
         layout.setContentsMargins(12, 0, 12, 0)
+
+    def settings(self) -> Iterable[tuple[str, str, str]]:
+        """Return settings from the objectives widget."""
+        # For now, return empty as ObjectivesWidget doesn't expose settings
+        # This can be expanded when ObjectivesWidget is properly implemented
+        return []