Proper Find Replace Search (#72)

* Search Replace works for for observable table

* All observable Tables find/replace

* Toggling visibility

Author: PaulJonasJost

src/petab_gui/app.py

@@ -26,7 +26,7 @@ def __init__(self):
         super().__init__(sys.argv)
 
         # Load the styleshee
-        self.apply_stylesheet()
+        # self.apply_stylesheet()
         self.model = PEtabModel()
         self.view = MainWindow()
         self.controller = MainController(self.view, self.model)

src/petab_gui/controllers/mother_controller.py

@@ -229,13 +229,18 @@ def setup_actions(self):
         actions["save"].setShortcut("Ctrl+S")
         actions["save"].triggered.connect(self.save_model)
         # Find + Replace
+        actions["find"] = QAction(
+            qta.icon("mdi6.magnify"),
+            "Find", self.view
+        )
+        actions["find"].setShortcut("Ctrl+F")
+        actions["find"].triggered.connect(self.find)
         actions["find+replace"] = QAction(
             qta.icon("mdi6.find-replace"),
             "Find/Replace", self.view
         )
         actions["find+replace"].setShortcut("Ctrl+R")
-        actions["find+replace"].triggered.connect(
-            self.open_find_replace_dialog)
+        actions["find+replace"].triggered.connect(self.replace)
         # Copy / Paste
         actions["copy"] = QAction(
             qta.icon("mdi6.content-copy"),
@@ -731,3 +736,19 @@ def paste_from_clipboard(self):
         controller = self.active_controller()
         if controller:
             controller.paste_from_clipboard()
+
+    def set_docks_visible(self):
+        """Handles Visibility of docks."""
+        pass
+
+    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.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.toggle_replace()

src/petab_gui/controllers/table_controllers.py

@@ -1,10 +1,10 @@
 """Classes for the controllers of the tables in the GUI."""
 from PySide6.QtWidgets import QInputDialog, QMessageBox, QFileDialog, \
-    QCompleter
+    QCompleter, QAbstractItemView
 import numpy as np
 import pandas as pd
 import petab.v1 as petab
-from PySide6.QtCore import Signal, QObject, QModelIndex, Qt
+from PySide6.QtCore import Signal, QObject, QModelIndex, Qt, QTimer
 from pathlib import Path
 from ..models.pandas_table_model import PandasTableModel, \
     PandasTableFilterProxy
@@ -13,6 +13,7 @@
 from ..utils import get_selected, process_file
 from .utils import prompt_overwrite_or_append
 from ..C import COLUMN
+import re
 
 
 class TableController(QObject):
@@ -277,13 +278,6 @@ def add_column(self, column_name: str = None):
                 return
         self.model.insertColumn(column_name)
 
-    def replace_text(self, find_text, replace_text):
-        self.logger.log_message(
-            f"Replacing '{find_text}' with '{replace_text}' in selected tables",
-            color="green"
-        )
-        self.model.replace_text(find_text, replace_text)
-
     def set_index_on_new_row(self, index: QModelIndex):
         """Set the index of the model when a new row is added."""
         self.view.table_view.setCurrentIndex(index)
@@ -314,12 +308,143 @@ def paste_from_clipboard(self):
                 f"PEtab linter failed after copying: {str(e)}",
                 color="red"
             )
+
     def check_petab_lint(self, row_data):
         """Check a single row of the model with petablint."""
         raise NotImplementedError(
             "This method must be implemented in child classes."
         )
 
+    def find_text(
+        self, text, case_sensitive=False, regex=False, whole_cell=False
+    ):
+        """Efficiently find all matching cells."""
+        df = self.model.get_df()
+
+        # Search in the main DataFrame
+        if regex:
+            pattern = re.compile(text, 0 if case_sensitive else re.IGNORECASE)
+            mask = df.map(lambda cell: bool(pattern.fullmatch(str(cell))) if whole_cell else bool(pattern.search(str(cell))))
+        else:
+            text = text.lower() if not case_sensitive else text
+            mask = df.map(lambda cell: text == str(cell).lower() if whole_cell else text in str(cell).lower()) if not case_sensitive else \
+                   df.map(lambda cell: text == str(cell) if whole_cell else text in str(cell))
+
+        # Find matches
+        match_indices = list(zip(*mask.to_numpy().nonzero()))
+        table_matches = [(row, col + self.model.column_offset) for row, col in match_indices]
+
+        # Search in the index if it's named
+        index_matches = []
+        if isinstance(df.index, pd.Index) and df.index.name:
+            if regex:
+                index_mask = df.index.to_series().map(lambda idx: bool(pattern.fullmatch(str(idx))) if whole_cell else bool(pattern.search(str(idx))))
+            else:
+                index_mask = df.index.to_series().map(lambda idx: text == str(idx).lower() if whole_cell else text in str(idx).lower()) if not case_sensitive else \
+                             df.index.to_series().map(lambda idx: text == str(idx) if whole_cell else text in str(idx))
+
+            index_matches = [(df.index.get_loc(idx), 0) for idx in index_mask[index_mask].index]
+
+        all_matches = index_matches + table_matches
+
+        # 🔹 Highlight matched text
+        self.highlight_text(all_matches)
+        return all_matches
+
+    def highlight_text(self, matches):
+        """Color the text of all matched cells in yellow."""
+        self.model.highlighted_cells = set(matches)
+        top_left = self.model.index(0, 0)
+        bottom_right = self.model.index(self.model.rowCount() - 1,
+                                        self.model.columnCount() - 1)
+        self.model.dataChanged.emit(top_left, bottom_right,
+                                    [Qt.ForegroundRole])
+
+    def cleanse_highlighted_cells(self):
+        """Cleanses the highlighted cells."""
+        self.model.highlighted_cells = set()
+        top_left = self.model.index(0, 0)
+        bottom_right = self.model.index(self.model.rowCount() - 1,
+                                        self.model.columnCount() - 1)
+        self.model.dataChanged.emit(top_left, bottom_right,
+                                    [Qt.ForegroundRole])
+
+    def focus_match(self, match):
+        """Focus and select the given match in the table."""
+        if match is None:
+            self.view.table_view.clearSelection()
+            return
+        row, col = match
+        index = self.model.index(row, col)
+        if not index.isValid():
+            return
+        proxy_index = self.view.table_view.model().mapFromSource(index)
+        if not proxy_index.isValid():
+            return
+
+        self.view.table_view.setCurrentIndex(proxy_index)
+        self.view.table_view.setCurrentIndex(proxy_index)
+        self.view.table_view.scrollTo(
+                proxy_index, QAbstractItemView.EnsureVisible
+        )
+
+    def replace_text(self, row, col, replace_text, search_text, case_sensitive, regex):
+        """Replace the text in the given cell and update highlights."""
+        index = self.model.index(row, col)
+        original_text = self.model.data(index, Qt.DisplayRole)
+
+        if not original_text:
+            return
+
+        if regex:
+            pattern = re.compile(search_text, 0 if case_sensitive else re.IGNORECASE)
+            new_text = pattern.sub(replace_text, original_text)
+        else:
+            if not case_sensitive:
+                search_text = re.escape(search_text.lower())
+                new_text = re.sub(search_text, replace_text, original_text, flags=re.IGNORECASE)
+            else:
+                new_text = original_text.replace(search_text, replace_text)
+
+        if new_text != original_text:
+            self.model.setData(index, new_text, Qt.EditRole)
+            self.model.highlighted_cells.discard((row, col))
+            self.model.dataChanged.emit(index, index, [Qt.DisplayRole])
+
+    def replace_all(
+        self, search_text, replace_text, case_sensitive=False, regex=False
+    ):
+        """Replace all occurrences of the search term in the Model."""
+        if not search_text or not replace_text:
+            return
+
+        df = self.model._data_frame
+        if regex:
+            pattern = re.compile(search_text,
+                                 0 if case_sensitive else re.IGNORECASE)
+            df.replace(to_replace=pattern, value=replace_text, regex=True,
+                       inplace=True)
+        else:
+            if not case_sensitive:
+                df.replace(
+                    to_replace=re.escape(search_text),
+                    value=replace_text,
+                    regex=True,
+                    inplace=True
+                )
+            else:
+                df.replace(to_replace=search_text, value=replace_text,
+                           inplace=True)
+
+        # Replace in the index as well
+        if isinstance(df.index, pd.Index) and df.index.name:
+            index_map = {
+                idx: pattern.sub(replace_text, str(idx)) if regex else str(
+                    idx).replace(search_text, replace_text)
+                for idx in df.index if search_text in str(idx)}
+            if index_map:
+                df.rename(index=index_map, inplace=True)
+
 
 class MeasurementController(TableController):
     """Controller of the Measurement table."""

src/petab_gui/models/pandas_table_model.py

@@ -1,7 +1,7 @@
 import pandas as pd
 from PySide6.QtCore import (Qt, QAbstractTableModel, QModelIndex, Signal,
                             QSortFilterProxyModel, QMimeData)
-from PySide6.QtGui import QColor
+from PySide6.QtGui import QColor, QBrush
 
 from ..C import COLUMNS
 from ..utils import validate_value, create_empty_dataframe, is_invalid, \
@@ -22,6 +22,7 @@ def __init__(self, data_frame, allowed_columns, table_type, parent=None):
         self._allowed_columns = allowed_columns
         self.table_type = table_type
         self._invalid_cells = set()
+        self.highlighted_cells = set()
         self._has_named_index = False
         if data_frame is None:
             data_frame = create_empty_dataframe(allowed_columns, table_type)
@@ -57,6 +58,11 @@ def data(self, index, role=Qt.DisplayRole):
             return str(value)
         elif role == Qt.BackgroundRole:
             return self.determine_background_color(row, column)
+        elif role == Qt.ForegroundRole:
+            # Return yellow text if this cell is a match
+            if (row, column) in self.highlighted_cells:
+                return QBrush(QColor(255, 255, 0))  # Yellow color
+            return QBrush(QColor(0, 0, 0))  # Default black text
         return None
 
     def flags(self, index):
@@ -133,6 +139,10 @@ def insertColumn(self, column_name: str):
     def setData(self, index, value, role=Qt.EditRole):
         if not (index.isValid() and role == Qt.EditRole):
             return False
+
+        if role != Qt.EditRole:
+            return False
+
         if is_invalid(value) or value == "":
             value = None
         # check whether multiple rows but only one column is selected