feat: enhance grid plan handling and x/y position management in MDASeq and PositionTable (#511)

feat: enhance grid plan handling and x/y position management in MDASequence and PositionTable

Author: tlambert03

src/pymmcore_widgets/mda/_core_mda.py

@@ -189,7 +189,12 @@ def value(self) -> MDASequence:
 
         # if there are no stage positions, use the current stage position
         if not val.stage_positions:
-            replace["stage_positions"] = (self._get_current_stage_position(),)
+            pos = self._get_current_stage_position()
+            # clear x/y if using a global absolute grid
+            # (they're meaningless and useq will warn if they're included)
+            if val.grid_plan is not None and not val.grid_plan.is_relative:
+                pos = pos.replace(x=None, y=None)
+            replace["stage_positions"] = (pos,)
             # if "p" is not in the axis order, we need to add it or the position will
             # not be in the event
             if "p" not in val.axis_order:

src/pymmcore_widgets/mda/_core_positions.py

@@ -441,6 +441,15 @@ def _perform_full_focus() -> None:
         self._mmc.waitForSystem()
         _perform_full_focus()
 
+    def _set_row_xy_enabled(self, row: int, enabled: bool, tip: str = "") -> None:
+        """Enable/disable the XY columns and button for a specific row."""
+        super()._set_row_xy_enabled(row, enabled, tip)
+        table = self.table()
+        xy_btn_col = table.indexOf(self._xy_btn_col)
+        if xy_btn := table.cellWidget(row, xy_btn_col):
+            xy_btn.setEnabled(enabled)
+            xy_btn.setToolTip(tip)
+
     def _on_include_z_toggled(self, checked: bool) -> None:
         z_btn_col = self.table().indexOf(self._z_btn_col)
         self.table().setColumnHidden(z_btn_col, not checked)

src/pymmcore_widgets/useq_widgets/_mda_sequence.py

@@ -347,7 +347,7 @@ def __init__(
         self.time_plan.valueChanged.connect(self.valueChanged)
         self.stage_positions.valueChanged.connect(self.valueChanged)
         self.z_plan.valueChanged.connect(self._validate_af_with_z_plan)
-        self.grid_plan.valueChanged.connect(self.valueChanged)
+        self.grid_plan.valueChanged.connect(self._on_grid_plan_value_changed)
         self.tab_wdg.tabChecked.connect(self._on_tab_checked)
         self.axis_order.currentTextChanged.connect(self.valueChanged)
         self.valueChanged.connect(self._update_time_estimate)
@@ -560,8 +560,22 @@ def _on_tab_checked(self, tab_idx: int) -> None:
             else:
                 self._enable_af(True)
 
+        if tab_idx in (
+            self.tab_wdg.indexOf(self.grid_plan),
+            self.tab_wdg.indexOf(self.stage_positions),
+        ):
+            with signals_blocked(self):
+                self._on_grid_plan_value_changed()
+
         self._update_available_axis_orders()
 
+    def _on_grid_plan_value_changed(self) -> None:
+        """Disable position X/Y when a global absolute grid is active."""
+        gp = self.grid_plan
+        has_abs_grid = self.tab_wdg.isChecked(gp) and not gp.value().is_relative
+        self.stage_positions.setXYEnabled(not has_abs_grid)
+        self.valueChanged.emit()
+
     def _on_af_toggled(self) -> None:
         # if the 'af_per_position' checkbox in the PositionTable is checked, set checked
         # also the autofocus p axis checkbox.

src/pymmcore_widgets/useq_widgets/_positions.py

@@ -171,6 +171,15 @@ class PositionTable(DataTableWidget):
     def __init__(self, rows: int = 0, parent: QWidget | None = None):
         super().__init__(rows, parent)
 
+        # track whether a global absolute grid disables all x/y
+        self._global_xy_disabled = False
+
+        # when a sub-sequence changes, update x/y enabled state for that row
+        if model := self.table().model():
+            model.rowsInserted.connect(self._on_table_rows_inserted)
+            if (rows := self.table().rowCount()) > 0:
+                self._on_table_rows_inserted(None, 0, rows - 1)
+
         self.include_z = QCheckBox("Include Z")
         self.include_z.setChecked(True)
         self.include_z.toggled.connect(self._on_include_z_toggled)
@@ -346,6 +355,64 @@ def load(self, file: str | Path | None = None) -> None:
         except Exception as e:  # pragma: no cover
             raise ValueError(f"Failed to load MDASequence file: {src}") from e
 
+    def setXYEnabled(self, enabled: bool) -> None:
+        """Disable or enable X/Y columns for all rows (e.g. global absolute grid)."""
+        self._global_xy_disabled = not enabled
+        table = self.table()
+        seq_col = table.indexOf(self.SEQ)
+        tip = "X/Y defined by the global absolute grid plan." if not enabled else ""
+        for row in range(table.rowCount()):
+            # skip rows that have their own absolute sub-sequence grid
+            if enabled:
+                wdg = table.cellWidget(row, seq_col)
+                if isinstance(wdg, MDAButton) and _seq_has_absolute_grid(wdg.value()):
+                    continue
+            self._set_row_xy_enabled(row, enabled, tip)
+
+    # ------------------- sub-sequence grid helpers -------------------
+
+    def _on_table_rows_inserted(self, parent: object, start: int, end: int) -> None:
+        """Connect MDAButton.valueChanged for newly inserted rows."""
+        table = self.table()
+        seq_col = table.indexOf(self.SEQ)
+        tip = "X/Y defined by the global absolute grid plan."
+        for row in range(start, end + 1):
+            wdg = table.cellWidget(row, seq_col)
+            if isinstance(wdg, MDAButton):
+                wdg.valueChanged.connect(self._on_sub_seq_changed)
+            # apply global disable to newly added rows
+            if self._global_xy_disabled:
+                self._set_row_xy_enabled(row, False, tip)
+
+    def _on_sub_seq_changed(self) -> None:
+        """Disable x/y for the row if its sub-sequence has an absolute grid."""
+        btn = self.sender()
+        if not isinstance(btn, MDAButton):
+            return
+        table = self.table()
+        seq_col = table.indexOf(self.SEQ)
+        for row in range(table.rowCount()):
+            if table.cellWidget(row, seq_col) is btn:
+                has_abs = _seq_has_absolute_grid(btn.value())
+                # global disable takes precedence
+                if self._global_xy_disabled and not has_abs:
+                    return
+                tip = (
+                    "X/Y defined by the absolute grid in the sub-sequence."
+                    if has_abs
+                    else ""
+                )
+                self._set_row_xy_enabled(row, not has_abs, tip)
+                break
+
+    def _set_row_xy_enabled(self, row: int, enabled: bool, tip: str = "") -> None:
+        """Enable/disable x/y widgets for a single row."""
+        table = self.table()
+        for col_info in (self.X, self.Y):
+            if wdg := table.cellWidget(row, table.indexOf(col_info)):
+                wdg.setEnabled(enabled)
+                wdg.setToolTip(tip)
+
     # ------------------------- Private API -------------------------
 
     def _on_include_z_toggled(self, checked: bool) -> None:
@@ -357,3 +424,8 @@ def _on_af_per_position_toggled(self, checked: bool) -> None:
         af_col = self.table().indexOf(self.AF)
         self.table().setColumnHidden(af_col, not checked)
         self.valueChanged.emit()
+
+
+def _seq_has_absolute_grid(seq: useq.MDASequence | None) -> bool:
+    """Return True if the sequence has an absolute grid plan."""
+    return bool(seq and seq.grid_plan and not seq.grid_plan.is_relative)