Auto-apply changes for DictItem and FloatArrayItem editors

When editing dictionaries or arrays in a DataSetEditGroupBox (with Apply
button), changes are now automatically applied when the editor dialog is
validated. This eliminates the need for users to click both "Save & Close"
in the editor and then "Apply" in the dataset layout, providing a more
intuitive workflow.

Author: PierreRaybaut

CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Version 3.13.2 ##
 
+✨ New features:
+
+* **Auto-apply for DictItem and FloatArrayItem in DataSetEditGroupBox**: Improved user experience when editing dictionaries and arrays
+  * When a `DictItem` or `FloatArrayItem` is modified within a `DataSetEditGroupBox` (with an Apply button), changes are now automatically applied when the editor dialog is validated
+  * Previously, users had to click "Save & Close" in the dictionary/array editor, then click the "Apply" button in the dataset widget layout
+  * Now, clicking "Save & Close" automatically triggers the apply action, making changes immediately effective
+  * Implementation: The auto-apply trigger function is passed as an optional 5th parameter to button callbacks
+  * This behavior only applies to dataset layouts with an Apply button (DataSetEditGroupBox), not to standalone editors
+  * Provides more intuitive workflow and reduces the number of clicks required to apply changes
+  * Affects both `DictItem` (dictionary editor) and `FloatArrayItem` (array editor)
+
 🛠️ Bug fixes:
 
 * Fix the `AboutInfo.about` method: renamed parameter `addinfos` to `addinfo` for consistency

guidata/dataset/dataitems.py

@@ -1415,8 +1415,22 @@ def __init__(
 
     @staticmethod
     # pylint: disable=unused-argument
-    def __dictedit(instance: DataSet, item: DataItem, value: dict, parent):
-        """Open a dictionary editor"""
+    def __dictedit(
+        instance: DataSet,
+        item: DataItem,
+        value: dict,
+        parent,
+        trigger_apply=None,
+    ):
+        """Open a dictionary editor
+
+        Args:
+            instance: DataSet instance
+            item: DataItem instance
+            value: Current dictionary value
+            parent: Parent widget
+            trigger_apply: Optional callback to trigger auto-apply
+        """
         # pylint: disable=import-outside-toplevel
         from guidata.qthelpers import exec_dialog
         from guidata.widgets.collectionseditor import CollectionsEditor
@@ -1426,8 +1440,13 @@ def __dictedit(instance: DataSet, item: DataItem, value: dict, parent):
         if value_was_none:
             value = {}
         editor.setup(value, readonly=instance.is_readonly())
-        if exec_dialog(editor):
-            return editor.get_value()
+        result = exec_dialog(editor)
+        if result:
+            new_value = editor.get_value()
+            # Auto-apply changes if trigger function was provided
+            if trigger_apply is not None:
+                trigger_apply()
+            return new_value
         if value_was_none:
             return None
         return value

guidata/dataset/qtitemwidgets.py

@@ -230,6 +230,35 @@ def notify_value_change(self) -> None:
         if not self.build_mode:
             self.parent_layout.widget_value_changed()
 
+    def _trigger_auto_apply(self) -> None:
+        """Automatically trigger the apply action if in DataSetEditGroupBox context.
+
+        This method checks if the parent layout is part of a DataSetEditGroupBox
+        (which has an Apply button), and if so, automatically triggers the apply
+        action. This provides a better user experience for editors like the dictionary
+        and array editors, where users expect changes to be applied when they click
+        "Save & Close" rather than requiring an additional "Apply" button click.
+
+        The apply is deferred to the next event loop iteration to ensure that the
+        callback has finished updating the widget's value before apply is triggered.
+        """
+        # pylint: disable=import-outside-toplevel
+        from qtpy.QtCore import QTimer
+
+        from guidata.dataset.qtwidgets import DataSetEditGroupBox
+
+        # Walk up the widget hierarchy to find DataSetEditGroupBox
+        # The parent_layout.parent may not directly be the DataSetEditGroupBox,
+        # especially when the layout is embedded in tabs or other containers
+        current = self.parent_layout.parent
+        while current is not None:
+            if isinstance(current, DataSetEditGroupBox):
+                # Defer the apply to the next event loop iteration to ensure the
+                # callback has finished updating the value
+                QTimer.singleShot(0, lambda gb=current: gb.set(check=False))
+                return
+            current = current.parent() if hasattr(current, "parent") else None
+
     def retrieve_top_level_layout(self) -> DataSetEditLayout:
         """Retrieve the top-level layout associated with this widget.
 
@@ -1370,6 +1399,8 @@ def edit_array(self) -> None:
         ):
             self.update(self.arr)
             self.notify_value_change()
+            # Auto-apply changes if in a DataSetEditGroupBox context
+            self._trigger_auto_apply()
 
     def get(self) -> None:
         """Update widget contents from data item value"""
@@ -1524,8 +1555,13 @@ def clicked(self, *args) -> None:
         """
         self.parent_layout.update_dataitems()
         callback = self.item.get_prop_value("display", "callback")
+        # Pass auto-apply trigger function as optional 5th parameter
         self.cb_value = callback(
-            self.item.instance, self.item.item, self.cb_value, self.button.parent()
+            self.item.instance,
+            self.item.item,
+            self.cb_value,
+            self.button.parent(),
+            self._trigger_auto_apply,
         )
         self.set()
         self.parent_layout.update_widgets()

guidata/tests/dataset/test_auto_apply.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see guidata/LICENSE for details)
+
+"""
+Auto-apply functionality test
+
+This test verifies that DictItem and FloatArrayItem editors automatically
+trigger the apply action when used within a DataSetEditGroupBox context.
+"""
+
+# guitest: show
+
+import numpy as np
+
+import guidata.dataset as gds
+from guidata.dataset.qtwidgets import DataSetEditGroupBox
+from guidata.env import execenv
+from guidata.qthelpers import qt_app_context
+
+
+class AutoApplyDataSet(gds.DataSet):
+    """Test dataset with DictItem and FloatArrayItem"""
+
+    dictionary = gds.DictItem("Dictionary", default={"a": 1, "b": 2, "c": 3})
+    array = gds.FloatArrayItem("Array", default=np.array([[1, 2], [3, 4]]))
+    string = gds.StringItem("String", default="test")
+
+
+class AutoApplySignalChecker:
+    """Helper class to track signal emissions"""
+
+    def __init__(self, groupbox: DataSetEditGroupBox):
+        self.groupbox = groupbox
+        self.signal_received = False
+        groupbox.SIG_APPLY_BUTTON_CLICKED.connect(self.on_signal)
+
+    def on_signal(self):
+        """Signal handler"""
+        self.signal_received = True
+        execenv.print("Signal received: SIG_APPLY_BUTTON_CLICKED")
+
+    def reset(self):
+        """Reset the checker state"""
+        self.signal_received = False
+
+
+def test_auto_apply_dictitem():
+    """Test that DictItem widget has auto-apply functionality"""
+    with qt_app_context():
+        # Create the groupbox and signal checker
+        groupbox = DataSetEditGroupBox("Test", AutoApplyDataSet)
+        checker = AutoApplySignalChecker(groupbox)
+
+        # Get the DictItem widget - widget.item is a DataItemVariable,
+        # widget.item.item is the actual DataItem with the type/name info
+        dict_widget = None
+        for widget in groupbox.edit.widgets:
+            if (
+                hasattr(widget, "item")
+                and hasattr(widget.item, "item")
+                and isinstance(widget.item.item, gds.DictItem)
+            ):
+                dict_widget = widget
+                break
+
+        assert dict_widget is not None, "DictItem widget not found"
+
+        # Verify the widget has the _trigger_auto_apply method
+        assert hasattr(dict_widget, "_trigger_auto_apply"), (
+            "DictItem widget missing _trigger_auto_apply method"
+        )
+
+        # Call _trigger_auto_apply to simulate what the dictionary editor does
+        dict_widget._trigger_auto_apply()
+
+        # Process events to allow deferred execution
+        from qtpy.QtWidgets import QApplication
+
+        QApplication.processEvents()
+
+        # Verify signal was received
+        assert checker.signal_received, "Signal was not emitted after auto-apply"
+        execenv.print("✓ DictItem auto-apply triggered signal")
+
+        # Verify button is disabled after processing events
+        assert not groupbox.apply_button.isEnabled(), (
+            "Apply button should be disabled after auto-apply"
+        )
+        execenv.print("✓ Apply button is disabled after auto-apply")
+
+
+def test_auto_apply_floatarrayitem():
+    """Test that FloatArrayItem widget has auto-apply functionality"""
+    with qt_app_context():
+        # Create the groupbox and signal checker
+        groupbox = DataSetEditGroupBox("Test", AutoApplyDataSet)
+        checker = AutoApplySignalChecker(groupbox)
+
+        # Get the FloatArrayItem widget
+        array_widget = None
+        for widget in groupbox.edit.widgets:
+            if (
+                hasattr(widget, "item")
+                and hasattr(widget.item, "item")
+                and isinstance(widget.item.item, gds.FloatArrayItem)
+            ):
+                array_widget = widget
+                break
+
+        assert array_widget is not None, "FloatArrayItem widget not found"
+
+        # Verify the widget has the _trigger_auto_apply method
+        assert hasattr(array_widget, "_trigger_auto_apply"), (
+            "FloatArrayItem widget missing _trigger_auto_apply method"
+        )
+
+        # Call _trigger_auto_apply to simulate what the array editor does
+        array_widget._trigger_auto_apply()
+
+        # Process events to allow deferred execution
+        from qtpy.QtWidgets import QApplication
+
+        QApplication.processEvents()
+
+        # Verify signal was received
+        assert checker.signal_received, "Signal was not emitted after auto-apply"
+        execenv.print("✓ FloatArrayItem auto-apply triggered signal")
+
+        # Verify button is disabled after processing events
+        assert not groupbox.apply_button.isEnabled(), (
+            "Apply button should be disabled after auto-apply"
+        )
+        execenv.print("✓ Apply button is disabled after auto-apply")
+
+
+def test_auto_apply_widget_hierarchy():
+    """Test auto-apply works when DataSetEditGroupBox is in widget hierarchy"""
+    with qt_app_context():
+        from qtpy.QtWidgets import QFrame, QStackedWidget, QTabWidget, QVBoxLayout
+
+        # Create a complex widget hierarchy similar to DataLab's Properties panel
+        tab_widget = QTabWidget()
+        stacked = QStackedWidget()
+        frame1 = QFrame()
+        frame2 = QFrame()
+
+        # Create the groupbox inside the hierarchy
+        groupbox = DataSetEditGroupBox("Test", AutoApplyDataSet)
+        checker = AutoApplySignalChecker(groupbox)
+
+        # Build the hierarchy
+        layout = QVBoxLayout()
+        layout.addWidget(groupbox)
+        frame2.setLayout(layout)
+        frame1_layout = QVBoxLayout()
+        frame1_layout.addWidget(frame2)
+        frame1.setLayout(frame1_layout)
+        stacked.addWidget(frame1)
+        tab_widget.addTab(stacked, "Test Tab")
+
+        # Get the widget and trigger auto-apply
+        dict_widget = None
+        for widget in groupbox.edit.widgets:
+            if (
+                hasattr(widget, "item")
+                and hasattr(widget.item, "item")
+                and isinstance(widget.item.item, gds.DictItem)
+            ):
+                dict_widget = widget
+                break
+
+        assert dict_widget is not None, "DictItem widget not found"
+
+        # Simulate dictionary update and auto-apply
+        dict_widget._trigger_auto_apply()
+
+        # Process events
+        from qtpy.QtWidgets import QApplication
+
+        QApplication.processEvents()
+
+        # Verify it still works even with complex hierarchy
+        assert checker.signal_received, "Signal was not emitted in complex hierarchy"
+        assert not groupbox.apply_button.isEnabled(), (
+            "Apply button should be disabled after auto-apply"
+        )
+        execenv.print("✓ Auto-apply works correctly in complex widget hierarchy")
+
+
+if __name__ == "__main__":
+    # Run all tests
+    test_auto_apply_dictitem()
+    execenv.print("\n" + "=" * 80 + "\n")
+    test_auto_apply_floatarrayitem()
+    execenv.print("\n" + "=" * 80 + "\n")
+    test_auto_apply_widget_hierarchy()
+    execenv.print("\nAll tests passed!")