Decoupled views from controllers (as much as possible). Put a FindReplaceController in place that works a s a functioning link between the finde replace bar. Should make testing much easier.

Author: PaulJonasJost

src/petab_gui/controllers/file_io_controller.py

@@ -283,9 +283,7 @@ def _open_file(self, actionable, file_path, sep, mode):
         elif actionable == "visualization":
             self.main.visualization_controller.open_table(file_path, sep, mode)
         elif actionable == "simulation":
-            self.main.simulation_table_controller.open_table(
-                file_path, sep, mode
-            )
+            self.main.simulation_controller.open_table(file_path, sep, mode)
         elif actionable == "data_matrix":
             self.main.measurement_controller.process_data_matrix_file(
                 file_path, mode, sep
@@ -554,7 +552,7 @@ def open_yaml_and_load_files(self, yaml_path=None, mode="overwrite"):
                 self.main.visualization_controller.clear_table()
 
             # Simulation should be cleared
-            self.main.simulation_table_controller.clear_table()
+            self.main.simulation_controller.clear_table()
 
             self.logger.log_message(
                 "All files opened successfully from the YAML configuration.",

src/petab_gui/controllers/find_replace_controller.py

@@ -0,0 +1,189 @@
+"""Find and Replace Controller.
+
+This controller mediates find/replace operations across multiple table
+controllers. It owns the coordination logic for searching, highlighting,
+and replacing across multiple tables.
+"""
+
+
+class FindReplaceController:
+    """Coordinates find/replace operations across multiple table controllers.
+
+    This controller provides a clean interface for the FindReplaceBar view to
+    search, highlight, focus, and replace text across multiple tables without
+    knowing about individual table controllers. It works as a mediator
+    encapsulating the coordination logic between multiple table controllers.
+    """
+
+    def __init__(self, table_controllers: dict):
+        """Initialize the find/replace controller.
+
+        Args:
+            table_controllers: Dictionary mapping table names to their
+            controllers.
+            Example: {"Measurement Table": measurement_controller, ...}
+        """
+        self.table_controllers = table_controllers
+
+    def get_table_names(self) -> list[str]:
+        """Get list of available table names.
+
+        Returns:
+            List of table names that can be searched.
+        """
+        return list(self.table_controllers.keys())
+
+    def find_text(
+        self,
+        search_text: str,
+        case_sensitive: bool,
+        regex: bool,
+        whole_cell: bool,
+        selected_table_names: list[str],
+    ) -> list[tuple]:
+        """Search for text across selected tables.
+
+        Args:
+            search_text: The text to search for
+            case_sensitive: Whether search is case-sensitive
+            regex: Whether to use regex matching
+            whole_cell: Whether to match whole cell only
+            selected_table_names: List of table names to search in
+
+        Returns:
+            List of tuples: (row, col, table_name, controller)
+            Each tuple represents a match with its location and associated
+            controller.
+        """
+        matches = []
+
+        for table_name in selected_table_names:
+            controller = self.table_controllers.get(table_name)
+            if controller is None:
+                continue
+
+            # Get matches from this table
+            table_matches = controller.find_text(
+                search_text, case_sensitive, regex, whole_cell
+            )
+
+            # Extend with table name and controller reference
+            for row, col in table_matches:
+                matches.append((row, col, table_name, controller))
+
+        return matches
+
+    def focus_match(
+        self, table_name: str, row: int, col: int, with_focus: bool = False
+    ):
+        """Focus on a specific match in a table.
+
+        Args:
+            table_name: Name of the table containing the match
+            row: Row index of the match
+            col: Column index of the match
+            with_focus: Whether to give the table widget focus
+        """
+        controller = self.table_controllers.get(table_name)
+        if controller:
+            controller.focus_match((row, col), with_focus=with_focus)
+
+    def unfocus_match(self, table_name: str):
+        """Remove focus from current match in a table.
+
+        Args:
+            table_name: Name of the table to unfocus
+        """
+        controller = self.table_controllers.get(table_name)
+        if controller:
+            controller.focus_match(None)
+
+    def replace_text(
+        self,
+        table_name: str,
+        row: int,
+        col: int,
+        replace_text: str,
+        search_text: str,
+        case_sensitive: bool,
+        regex: bool,
+    ):
+        """Replace text in a specific cell.
+
+        Args:
+            table_name: Name of the table containing the cell
+            row: Row index
+            col: Column index
+            replace_text: Text to replace with
+            search_text: Original search text (for validation)
+            case_sensitive: Whether the original search was case-sensitive
+            regex: Whether the original search used regex
+        """
+        controller = self.table_controllers.get(table_name)
+        if controller:
+            controller.replace_text(
+                row=row,
+                col=col,
+                replace_text=replace_text,
+                search_text=search_text,
+                case_sensitive=case_sensitive,
+                regex=regex,
+            )
+
+    def replace_all(
+        self,
+        search_text: str,
+        replace_text: str,
+        case_sensitive: bool,
+        regex: bool,
+        matches: list[tuple],
+    ):
+        """Replace all matches across tables.
+
+        Args:
+            search_text: Text to search for
+            replace_text: Text to replace with
+            case_sensitive: Whether search is case-sensitive
+            regex: Whether to use regex
+            matches: List of match tuples from find_text()
+        """
+        # Group matches by controller
+        controllers_to_update = {}
+        for row, col, _, controller in matches:
+            if controller not in controllers_to_update:
+                controllers_to_update[controller] = []
+            controllers_to_update[controller].append((row, col))
+
+        # Call replace_all on each unique controller
+        for controller, positions in controllers_to_update.items():
+            controller.replace_all(
+                search_text, replace_text, case_sensitive, regex
+            )
+            # Emit dataChanged for each affected cell
+            for row, col in positions:
+                controller.model.dataChanged.emit(
+                    controller.model.index(row, col),
+                    controller.model.index(row, col),
+                )
+
+    def cleanse_all_highlights(self):
+        """Clear highlights from all tables."""
+        for controller in self.table_controllers.values():
+            controller.cleanse_highlighted_cells()
+
+    def highlight_matches(self, matches: list[tuple]):
+        """Highlight matches in their respective tables.
+
+        Args:
+            matches: List of match tuples from find_text()
+        """
+        # Group matches by controller
+        by_controller = {}
+        for row, col, _, controller in matches:
+            if controller not in by_controller:
+                by_controller[controller] = []
+            by_controller[controller].append((row, col))
+
+        # Highlight in each table
+        for controller, positions in by_controller.items():
+            controller.highlight_text(positions)

src/petab_gui/controllers/mother_controller.py

@@ -44,6 +44,7 @@
 from ..views import TaskBar
 from ..views.dialogs import NextStepsPanel
 from .file_io_controller import FileIOController
+from .find_replace_controller import FindReplaceController
 from .logger_controller import LoggerController
 from .plot_coordinator import PlotCoordinator
 from .sbml_controller import SbmlController
@@ -122,7 +123,7 @@ def __init__(self, view, model: PEtabModel):
             self.undo_stack,
             self,
         )
-        self.simulation_table_controller = MeasurementController(
+        self.simulation_controller = MeasurementController(
             self.view.simulation_dock,
             self.model.simulation,
             self.logger,
@@ -139,7 +140,7 @@ def __init__(self, view, model: PEtabModel):
             self.condition_controller,
             self.sbml_controller,
             self.visualization_controller,
-            self.simulation_table_controller,
+            self.simulation_controller,
         ]
         # File I/O Controller
         self.file_io = FileIOController(self)
@@ -149,6 +150,17 @@ def __init__(self, view, model: PEtabModel):
         self.validation = ValidationController(self)
         # Simulation Controller
         self.simulation = SimulationController(self)
+        # Find/Replace Controller
+        self.find_replace_controller = FindReplaceController(
+            {
+                "Observable Table": self.observable_controller,
+                "Condition Table": self.condition_controller,
+                "Parameter Table": self.parameter_controller,
+                "Measurement Table": self.measurement_controller,
+                "Visualization Table": self.visualization_controller,
+                "Simulation Table": self.simulation_controller,
+            }
+        )
         # Recent Files
         self.recent_files_manager = RecentFilesManager(max_files=10)
         # Checkbox states for Find + Replace
@@ -290,11 +302,15 @@ def setup_connections(self):
             self.measurement_controller,
             self.condition_controller,
             self.visualization_controller,
-            self.simulation_table_controller,
+            self.simulation_controller,
         ]:
             controller.overwritten_df.connect(
                 self.plot_coordinator._schedule_plot_update
             )
+        self.view.file_open_requested.connect(
+            partial(self.file_io.open_file, mode="overwrite")
+        )
+        self.view.close_requested.connect(self.maybe_close)
 
     def setup_actions(self):
         """Setup actions for the main controller."""
@@ -646,7 +662,7 @@ def active_controller(self):
         if active_widget == self.view.visualization_dock.table_view:
             return self.visualization_controller
         if active_widget == self.view.simulation_dock.table_view:
-            return self.simulation_table_controller
+            return self.simulation_controller
         return None
 
     def delete_rows(self):
@@ -710,21 +726,21 @@ def open_settings(self):
             "measurement": self.measurement_controller.get_columns(),
             "condition": self.condition_controller.get_columns(),
             "visualization": self.visualization_controller.get_columns(),
-            "simulation": self.simulation_table_controller.get_columns(),
+            "simulation": self.simulation_controller.get_columns(),
         }
         settings_dialog = SettingsDialog(table_columns, self.view)
         settings_dialog.exec()
 
     def find(self):
         """Create a find replace bar if it is non existent."""
         if self.view.find_replace_bar is None:
-            self.view.create_find_replace_bar()
+            self.view.create_find_replace_bar(self.find_replace_controller)
         self.view.toggle_find()
 
     def replace(self):
         """Create a find replace bar if it is non existent."""
         if self.view.find_replace_bar is None:
-            self.view.create_find_replace_bar()
+            self.view.create_find_replace_bar(self.find_replace_controller)
         self.view.toggle_replace()
 
     def _toggle_whats_this_mode(self, on: bool):

src/petab_gui/controllers/plot_coordinator.py

@@ -69,7 +69,7 @@ def init_plotter(self):
         """
         self.view.plot_dock.initialize(
             self.main.measurement_controller.proxy_model,
-            self.main.simulation_table_controller.proxy_model,
+            self.main.simulation_controller.proxy_model,
             self.main.condition_controller.proxy_model,
             self.main.visualization_controller.proxy_model,
             self.model,
@@ -208,8 +208,8 @@ def _on_plot_point_clicked(self, x, y, label, data_type):
         proxy = self.main.measurement_controller.proxy_model
         view = self.main.measurement_controller.view.table_view
         if data_type == "simulation":
-            proxy = self.main.simulation_table_controller.proxy_model
-            view = self.main.simulation_table_controller.view.table_view
+            proxy = self.main.simulation_controller.proxy_model
+            view = self.main.simulation_controller.view.table_view
         obs = label
 
         x_axis_col = "time"
@@ -259,7 +259,7 @@ def column_index(name):
                 else:
                     self.plotter.highlight_from_selection(
                         [row],
-                        proxy=self.main.simulation_table_controller.proxy_model,
+                        proxy=self.main.simulation_controller.proxy_model,
                         y_axis_col="simulation",
                     )
 
@@ -340,7 +340,7 @@ def _on_simulation_selection_changed(self, selected, deselected):
             The newly deselected items.
         """
         self._handle_table_selection_changed(
-            self.main.simulation_table_controller.view.table_view,
-            proxy=self.main.simulation_table_controller.proxy_model,
+            self.main.simulation_controller.view.table_view,
+            proxy=self.main.simulation_controller.proxy_model,
             y_axis_col="simulation",
         )

src/petab_gui/controllers/simulation_controller.py

@@ -28,7 +28,7 @@ class SimulationController:
         The PEtab model being simulated.
     logger : LoggerController
         The logger for user feedback.
-    simulation_table_controller : MeasurementController
+    simulation_controller : MeasurementController
         The controller for the simulation results table.
     """
 
@@ -126,5 +126,5 @@ def simulate(self):
             sim_df = simulator.simulate()
 
         # assign to simulation table
-        self.main.simulation_table_controller.overwrite_df(sim_df)
-        self.main.simulation_table_controller.model.reset_invalid_cells()
+        self.main.simulation_controller.overwrite_df(sim_df)
+        self.main.simulation_controller.model.reset_invalid_cells()