Fix tab setup to maintain current tab state after applying parameters; add tests to verify single tab presence for Creation and Processing tabs

Author: PierreRaybaut

datalab/gui/panel/base.py

@@ -456,11 +456,14 @@ def _values_equal(val1: Any, val2: Any) -> bool:
         # Handle regular comparison
         return val1 == val2
 
-    def setup_creation_tab(self, obj: SignalObj | ImageObj) -> bool:
+    def setup_creation_tab(
+        self, obj: SignalObj | ImageObj, set_current: bool = False
+    ) -> bool:
         """Setup the Creation tab with parameter editor for interactive object creation.
 
         Args:
             obj: Signal or Image object
+            set_current: If True, set the Creation tab as current after creation
 
         Returns:
             True if Creation tab was set up, False otherwise
@@ -495,6 +498,11 @@ def setup_creation_tab(self, obj: SignalObj | ImageObj) -> bool:
         self.creation_scroll.setWidgetResizable(True)
         self.creation_scroll.setWidget(editor)
         self.insertTab(0, self.creation_scroll, _("Creation"))
+
+        # Set as current tab if requested
+        if set_current:
+            self.setCurrentWidget(self.creation_scroll)
+
         return True
 
     def apply_creation_parameters(self) -> None:
@@ -551,19 +559,27 @@ def apply_creation_parameters(self) -> None:
 
         # Refresh the Creation tab with the new parameters
         # Use QTimer to defer this until after the current event is processed
+        # Set the Creation tab as current to keep it visible after refresh
         QC.QTimer.singleShot(
-            0, lambda: self.setup_creation_tab(self.current_creation_obj)
+            0,
+            lambda: self.setup_creation_tab(
+                self.current_creation_obj, set_current=True
+            ),
         )
 
     def setup_processing_tab(
-        self, obj: SignalObj | ImageObj, reset_params: bool = True
+        self,
+        obj: SignalObj | ImageObj,
+        reset_params: bool = True,
+        set_current: bool = False,
     ) -> bool:
         """Setup the Processing tab with parameter editor for re-processing.
 
         Args:
             obj: Signal or Image object
             reset_params: If True, call update_from_obj() to reset parameters from
                 source object. If False, use parameters as stored in metadata.
+            set_current: If True, set the Processing tab as current after creation
 
         Returns:
             True if Processing tab was set up, False otherwise
@@ -643,6 +659,11 @@ def setup_processing_tab(
 
         self.processing_scroll.setWidget(editor)
         self.insertTab(insert_index, self.processing_scroll, _("Processing"))
+
+        # Set as current tab if requested
+        if set_current:
+            self.setCurrentWidget(self.processing_scroll)
+
         return True
 
     def apply_processing_parameters(
@@ -755,8 +776,12 @@ def apply_processing_parameters(
 
             # Refresh the Processing tab with the new parameters
             # Don't reset parameters from source object - keep the user's values
+            # Set the Processing tab as current to keep it visible after refresh
             QC.QTimer.singleShot(
-                0, lambda: self.setup_processing_tab(obj, reset_params=False)
+                0,
+                lambda: self.setup_processing_tab(
+                    obj, reset_params=False, set_current=True
+                ),
             )
 
             if isinstance(obj, SignalObj):

datalab/tests/features/common/interactive_processing_test.py

@@ -262,7 +262,8 @@ def test_no_duplicate_creation_tabs():
 
     This test verifies the fix for the bug where clicking "Apply" in the
     Creation tab would create a new Creation tab instead of reusing the
-    existing one.
+    existing one. It also verifies that the Creation tab remains current
+    after applying changes.
     """
     with qt_app_context():
         with datalab_test_app_context() as win:
@@ -316,6 +317,12 @@ def test_no_duplicate_creation_tabs():
                     f"applying amplitude={amplitude}"
                 )
 
+                # Verify that the Creation tab is the current tab
+                assert objprop.currentWidget() is objprop.creation_scroll, (
+                    f"Creation tab should remain current after "
+                    f"applying amplitude={amplitude}"
+                )
+
 
 def test_no_creation_parameters_for_base_classes():
     """Test that creation parameters are NOT stored for base classes
@@ -480,6 +487,87 @@ def test_apply_processing_parameters_image():
             assert stored_param.value == v1
 
 
+def test_no_duplicate_processing_tabs():
+    """Test that applying processing parameters multiple times doesn't create
+    duplicate tabs.
+
+    This test verifies the fix for the bug where clicking "Apply" in the
+    Processing tab would create a new Processing tab instead of reusing the
+    existing one. It also verifies that the Processing tab remains current
+    after applying changes.
+    """
+    with qt_app_context():
+        with datalab_test_app_context() as win:
+            panel = win.imagepanel
+            processor = panel.processor
+            objprop = panel.objprop
+
+            # Create a default test image
+            panel.new_object(edit=False)
+            image = panel.objview.get_current_object()
+            assert image is not None
+
+            # Apply addition_constant with initial value
+            v0 = 7.0
+            processor.run_feature("addition_constant", ConstantParam.create(value=v0))
+
+            # Get the processed image
+            processed_ima = panel.objview.get_current_object()
+            assert processed_ima is not None
+
+            # Select the processed image to trigger setup_processing_tab
+            panel.objview.set_current_object(processed_ima)
+
+            # Verify Processing tab was set up
+            assert objprop.processing_param_editor is not None
+            assert objprop.processing_scroll is not None
+
+            # Count how many Processing tabs exist initially
+            initial_index = objprop.indexOf(objprop.processing_scroll)
+            assert initial_index >= 0, "Processing tab should be present"
+
+            # Count tabs by checking if they reference the same scroll widget
+            initial_count = sum(
+                1
+                for i in range(objprop.count())
+                if objprop.widget(i) is objprop.processing_scroll
+            )
+            assert initial_count == 1, (
+                "Should have exactly one Processing tab initially"
+            )
+
+            # Apply processing parameters multiple times
+            editor = objprop.processing_param_editor
+            for value in [10.0, 15.0, 20.0]:
+                editor.dataset.value = value
+                report = objprop.apply_processing_parameters()
+                assert report.success
+
+                # Wait for the deferred setup_processing_tab to complete
+                from qtpy.QtTest import QTest
+
+                QTest.qWait(100)
+
+                # Verify that processing_scroll reference still exists
+                assert objprop.processing_scroll is not None
+
+                # Count Processing tabs again - should still be just one
+                processing_count = sum(
+                    1
+                    for i in range(objprop.count())
+                    if objprop.widget(i) is objprop.processing_scroll
+                )
+                assert processing_count == 1, (
+                    f"Should still have exactly one Processing tab after "
+                    f"applying value={value}"
+                )
+
+                # Verify that the Processing tab is the current tab
+                assert objprop.currentWidget() is objprop.processing_scroll, (
+                    f"Processing tab should remain current after applying value={value}"
+                )
+
+
 def test_apply_processing_parameters_missing_source():
     """Test apply_processing_parameters when source object is missing"""
     with qt_app_context():
@@ -874,6 +962,7 @@ def test_select_source_objects_deleted_source():
     test_no_creation_parameters_for_base_classes()
     test_apply_processing_parameters_signal()
     test_apply_processing_parameters_image()
+    test_no_duplicate_processing_tabs()
     test_apply_processing_parameters_missing_source()
     test_cross_panel_image_to_signal()
     test_cross_panel_image_to_signal_group()