dataframe-textual 0.3.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

dataframe_textual/yes_no_screen.py

@@ -1,12 +1,17 @@
 """Modal screens with Yes/No buttons and their specialized variants."""
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .data_frame_table import DataFrameTable
+
 import polars as pl
 from textual.app import ComposeResult
-from textual.containers import Horizontal
+from textual.containers import Container, Horizontal
 from textual.screen import ModalScreen
-from textual.widgets import Button, Input, Label, Static
+from textual.widgets import Button, Checkbox, Input, Label, Static
 
-from .common import DtypeConfig, parse_filter_expression
+from .common import NULL, DtypeConfig, tentative_expr, validate_expr
 
 
 class YesNoScreen(ModalScreen):
@@ -25,26 +30,57 @@ class YesNoScreen(ModalScreen):
 
         YesNoScreen > Static {
             width: auto;
-            min-width: 30;
+            min-width: 40;
             max-width: 60;
             height: auto;
-            border: solid $primary;
+            border: heavy $primary;
+            border-title-color: $primary-lighten-3;
             background: $surface;
-            padding: 2;
+            padding: 1 2;
+        }
+
+        YesNoScreen Container {
+            margin: 1 0 0 0;
+            height: auto;
+            width: 100%;
+        }
+
+        YesNoScreen Label {
+            width: 100%;
+            text-wrap: wrap;
         }
 
         YesNoScreen Input {
-            margin: 1 0;
+            margin: 1 0 0 0;
+        }
+
+        YesNoScreen Input:blur {
+            border: solid $secondary;
+        }
+
+        YesNoScreen #checkbox-container {
+            margin: 1 0 0 0;
+            height: auto;
+            align: left middle;
+        }
+
+        YesNoScreen Checkbox {
+            margin: 0;
+        }
+
+        YesNoScreen Checkbox:blur {
+            border: solid $secondary;
         }
 
         YesNoScreen #button-container {
+            margin: 1 0 0 0;
             width: 100%;
             height: 3;
             align: center middle;
         }
 
         YesNoScreen Button {
-            margin: 0 1;
+            margin: 0 2;
         }
     """
 
@@ -53,53 +89,126 @@ class YesNoScreen(ModalScreen):
         title: str = None,
         label: str | dict | Label = None,
         input: str | dict | Input = None,
+        label2: str | dict | Label = None,
+        input2: str | dict | Input = None,
+        checkbox: str | dict | Checkbox = None,
+        checkbox2: str | dict | Checkbox = None,
         yes: str | dict | Button = "Yes",
+        maybe: str | dict | Button = None,
         no: str | dict | Button = "No",
         on_yes_callback=None,
-    ):
+        on_maybe_callback=None,
+    ) -> None:
         """Initialize the modal screen.
 
+        Creates a customizable Yes/No dialog with optional input fields, labels, and checkboxes.
+
         Args:
-            title: The title to display in the border
-            label: Optional label to display below title as a Label
-            input: Optional input value to pre-fill an Input widget. If None, no Input is shown. If it is a 2-value tuple, the first value is the pre-filled input, and the second value is the type of input (e.g., "integer", "number", "text")
-            yes: Text for the Yes button. If None, hides the Yes button
-            no: Text for the No button. If None, hides the No button
-            on_yes_callback: Optional callable that takes no args and returns the value to dismiss with when Yes is pressed
+            title: The title to display in the border. Defaults to None.
+            label: Optional label to display below title as a Label. Defaults to None.
+            input: Optional input widget or value to pre-fill. If None, no Input is shown. Defaults to None.
+            label2: Optional second label widget. Defaults to None.
+            input2: Optional second input widget or value. Defaults to None.
+            checkbox: Optional checkbox widget or label. Defaults to None.
+            checkbox2: Optional second checkbox widget or label. Defaults to None.
+            yes: Text or dict for the Yes button. If None, hides the Yes button. Defaults to "Yes".
+            maybe: Optional Maybe button text/dict. Defaults to None.
+            no: Text or dict for the No button. If None, hides the No button. Defaults to "No".
+            on_yes_callback: Optional callable that takes no args and returns the value to dismiss with when Yes is pressed. Defaults to None.
+
+        Returns:
+            None
         """
         super().__init__()
         self.title = title
         self.label = label
         self.input = input
+        self.label2 = label2
+        self.input2 = input2
+        self.checkbox = checkbox
+        self.checkbox2 = checkbox2
         self.yes = yes
+        self.maybe = maybe
         self.no = no
         self.on_yes_callback = on_yes_callback
+        self.on_maybe_callback = on_maybe_callback
 
     def compose(self) -> ComposeResult:
+        """Compose the modal screen widget structure.
+
+        Builds the widget hierarchy with optional title, labels, inputs, checkboxes,
+        and action buttons based on initialization parameters.
+
+        Yields:
+            Widget: The components of the modal screen in rendering order.
+        """
         with Static(id="modal-container") as container:
             if self.title:
                 container.border_title = self.title
 
-            if self.label:
-                if isinstance(self.label, Label):
-                    pass
-                elif isinstance(self.label, dict):
-                    self.label = Label(**self.label)
-                else:
-                    self.label = Label(self.label)
-                yield self.label
-
-            if self.input:
-                if isinstance(self.input, Input):
-                    pass
-                elif isinstance(self.input, dict):
-                    self.input = Input(**self.input)
-                else:
-                    self.input = Input(self.input)
-                self.input.select_all()
-                yield self.input
-
-            if self.yes or self.no:
+            if self.label or self.input:
+                with Container(id="input-container"):
+                    if self.label:
+                        if isinstance(self.label, Label):
+                            pass
+                        elif isinstance(self.label, dict):
+                            self.label = Label(**self.label)
+                        else:
+                            self.label = Label(self.label)
+                        yield self.label
+
+                    if self.input:
+                        if isinstance(self.input, Input):
+                            pass
+                        elif isinstance(self.input, dict):
+                            self.input = Input(**self.input)
+                        else:
+                            self.input = Input(self.input)
+                        self.input.select_all()
+                        yield self.input
+
+            if self.label2 or self.input2:
+                with Container(id="input-container-2"):
+                    if self.label2:
+                        if isinstance(self.label2, Label):
+                            pass
+                        elif isinstance(self.label2, dict):
+                            self.label2 = Label(**self.label2)
+                        else:
+                            self.label2 = Label(self.label2)
+                        yield self.label2
+
+                    if self.input2:
+                        if isinstance(self.input2, Input):
+                            pass
+                        elif isinstance(self.input2, dict):
+                            self.input2 = Input(**self.input2)
+                        else:
+                            self.input2 = Input(self.input2)
+                        self.input2.select_all()
+                        yield self.input2
+
+            if self.checkbox or self.checkbox2:
+                with Horizontal(id="checkbox-container"):
+                    if self.checkbox:
+                        if isinstance(self.checkbox, Checkbox):
+                            pass
+                        elif isinstance(self.checkbox, dict):
+                            self.checkbox = Checkbox(**self.checkbox)
+                        else:
+                            self.checkbox = Checkbox(self.checkbox)
+                        yield self.checkbox
+
+                    if self.checkbox2:
+                        if isinstance(self.checkbox2, Checkbox):
+                            pass
+                        elif isinstance(self.checkbox2, dict):
+                            self.checkbox2 = Checkbox(**self.checkbox2)
+                        else:
+                            self.checkbox2 = Checkbox(self.checkbox2)
+                        yield self.checkbox2
+
+            if self.yes or self.no or self.maybe:
                 with Horizontal(id="button-container"):
                     if self.yes:
                         if isinstance(self.yes, Button):
@@ -110,6 +219,17 @@ class YesNoScreen(ModalScreen):
                             self.yes = Button(self.yes, id="yes", variant="success")
 
                         yield self.yes
+
+                    if self.maybe:
+                        if isinstance(self.maybe, Button):
+                            pass
+                        elif isinstance(self.maybe, dict):
+                            self.maybe = Button(**self.maybe, id="maybe", variant="warning")
+                        else:
+                            self.maybe = Button(self.maybe, id="maybe", variant="warning")
+
+                        yield self.maybe
+
                     if self.no:
                         if isinstance(self.no, Button):
                             pass
@@ -123,6 +243,8 @@ class YesNoScreen(ModalScreen):
     def on_button_pressed(self, event: Button.Pressed) -> None:
         if event.button.id == "yes":
             self._handle_yes()
+        elif event.button.id == "maybe":
+            self._handle_maybe()
         elif event.button.id == "no":
             self.dismiss(None)
 
@@ -142,6 +264,14 @@ class YesNoScreen(ModalScreen):
         else:
             self.dismiss(True)
 
+    def _handle_maybe(self) -> None:
+        """Handle Maybe button press."""
+        if self.on_maybe_callback:
+            result = self.on_maybe_callback()
+            self.dismiss(result)
+        else:
+            self.dismiss(False)
+
 
 class SaveFileScreen(YesNoScreen):
     """Modal screen to save the dataframe to a CSV file."""
@@ -157,9 +287,9 @@ class SaveFileScreen(YesNoScreen):
 
     def handle_save(self):
         if self.input:
-            filename_input = self.input.value.strip()
-            if filename_input:
-                return filename_input
+            input_filename = self.input.value.strip()
+            if input_filename:
+                return input_filename
             else:
                 self.notify("Filename cannot be empty", title="Save", severity="error")
                 return None
@@ -172,64 +302,126 @@ class ConfirmScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "ConfirmScreen")
 
-    def __init__(self, title: str):
+    def __init__(self, title: str, label=None, yes="Yes", maybe: str = None, no="No"):
         super().__init__(
             title=title,
-            on_yes_callback=self.handle_confirm,
+            label=label,
+            yes=yes,
+            maybe=maybe,
+            no=no,
+            on_yes_callback=self.handle_yes,
         )
 
-    def handle_confirm(self) -> None:
+    def handle_yes(self) -> bool:
         return True
 
+    def handle_maybe(self) -> bool:
+        return False
+
 
 class EditCellScreen(YesNoScreen):
     """Modal screen to edit a single cell value."""
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "EditCellScreen")
 
-    def __init__(self, row_key: str, col_idx: int, df: pl.DataFrame):
-        self.row_key = row_key
-        self.col_idx = col_idx
-        self.col_name = df.columns[col_idx]
-        self.col_dtype = str(df.dtypes[col_idx])
-
-        row_idx = int(row_key.value) - 1  # Convert to 0-based
+    def __init__(self, ridx: int, cidx: int, df: pl.DataFrame):
+        self.ridx = ridx
+        self.cidx = cidx
+        self.dtype = df.dtypes[cidx]
 
         # Label
-        content = f"[$primary]{self.col_name}[/] ([$accent]{self.col_dtype}[/])"
+        content = f"[$success]{df.columns[cidx]}[/] ([$accent]{self.dtype}[/])"
 
         # Input
-        df_value = df.item(row_idx, col_idx)
-        self.input_value = str(df_value) if df_value is not None else ""
+        df_value = df.item(ridx, cidx)
+        self.input_value = "" if df_value is None else str(df_value).strip()
 
         super().__init__(
             title="Edit Cell",
             label=content,
             input={
                 "value": self.input_value,
-                "type": DtypeConfig(self.col_dtype).itype,
+                "type": DtypeConfig(self.dtype).itype,
             },
-            on_yes_callback=self._save_edit,
+            on_yes_callback=self._validate_input,
         )
 
-    def _save_edit(self) -> None:
+    def _validate_input(self) -> None:
         """Validate and save the edited value."""
         new_value_str = self.input.value.strip()
 
+        # Handle empty input
+        if not new_value_str:
+            new_value = None
+            self.notify(
+                "Empty value provided. If you want to clear the cell, press [$accent]x[/].",
+                title="Edit",
+                severity="warning",
+            )
         # Check if value changed
-        if new_value_str == self.input_value:
+        elif new_value_str == self.input_value:
+            new_value = None
             self.notify("No changes made", title="Edit", severity="warning")
-            return None
-
-        # Parse and validate based on column dtype
-        try:
-            new_value = DtypeConfig(self.col_dtype).convert(new_value_str)
-        except Exception as e:
-            self.notify(f"Invalid value: {str(e)}", title="Edit", severity="error")
-            return None
+        else:
+            # Parse and validate based on column dtype
+            try:
+                new_value = DtypeConfig(self.dtype).convert(new_value_str)
+            except Exception as e:
+                self.notify(
+                    f"Failed to convert [$accent]{new_value_str}[/] to [$error]{self.dtype}[/]: {str(e)}",
+                    title="Edit",
+                    severity="error",
+                )
+                return None
 
         # New value
-        return self.row_key, self.col_idx, new_value
+        return self.ridx, self.cidx, new_value
+
+
+class RenameColumnScreen(YesNoScreen):
+    """Modal screen to rename a column."""
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "RenameColumnScreen")
+
+    def __init__(self, col_idx: int, col_name: str, existing_columns: list[str]):
+        self.col_idx = col_idx
+        self.col_name = col_name
+        self.existing_columns = [c for c in existing_columns if c != col_name]
+
+        # Label
+        content = f"Rename header [$success]{col_name}[/]"
+
+        super().__init__(
+            title="Rename Column",
+            label=content,
+            input={"value": col_name},
+            on_yes_callback=self._validate_input,
+        )
+
+    def _validate_input(self) -> None:
+        """Validate and save the new column name."""
+        new_name = self.input.value.strip()
+
+        # Check if name is empty
+        if not new_name:
+            self.notify("Column name cannot be empty", title="Rename", severity="error")
+
+        # Check if name changed
+        elif new_name == self.col_name:
+            self.notify("No changes made", title="Rename", severity="warning")
+            new_name = None
+
+        # Check if name already exists
+        elif new_name in self.existing_columns:
+            self.notify(
+                f"Column [$accent]{new_name}[/] already exists",
+                title="Rename",
+                severity="error",
+            )
+            new_name = None
+
+        # Return new name
+        return self.col_idx, self.col_name, new_name
 
 
 class SearchScreen(YesNoScreen):
@@ -237,34 +429,39 @@ class SearchScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "SearchScreen")
 
-    def __init__(
-        self,
-        term,
-        col_dtype: pl.DataType,
-        col_name: str | None = None,
-    ):
-        col_dtype = col_dtype if col_name else pl.String
-        label = f"Search [$primary]{term}[/] ([$accent]{col_dtype}[/])"
-        self.col_name = col_name
-        self.col_dtype = col_dtype
+    def __init__(self, title, term, df: pl.DataFrame, cidx: int):
+        self.cidx = cidx
+
+        EXPR = f"ABC, (?i)abc, ^abc$, {NULL}, $_ > 50, $1 < $HP, $_.str.contains('sub')"
+
+        if "Search" in title:
+            col_name = df.columns[cidx]
+            col_dtype = df.dtypes[cidx]
+            label = f"{title} in [$success]{col_name}[/] ([$warning]{col_dtype}[/]) with value or Polars expression, e.g., {EXPR}"
+        else:
+            label = f"{title} by value or Polars expression, e.g., {EXPR}"
 
         super().__init__(
-            title="Search" if col_name else "Global Search",
-            label=f"{label} in [$primary]{col_name}[/]" if col_name else label,
-            input={"value": term, "type": DtypeConfig(col_dtype).itype},
-            on_yes_callback=self._do_search,
+            title=title,
+            label=label,
+            input=term,
+            checkbox="Match Nocase",
+            checkbox2="Match Whole",
+            on_yes_callback=self._validate_input,
         )
 
-    def _do_search(self) -> None:
-        """Perform the search."""
+    def _validate_input(self) -> tuple[str, int, bool, bool]:
+        """Validate the input and return it."""
         term = self.input.value.strip()
 
         if not term:
-            self.notify("Search term cannot be empty", title="Search", severity="error")
+            self.notify("Term cannot be empty", title=self.title, severity="error")
             return
 
-        # Search term
-        return term, self.col_dtype, self.col_name
+        match_nocase = self.checkbox.value
+        match_whole = self.checkbox2.value
+
+        return term, self.cidx, match_nocase, match_whole
 
 
 class FilterScreen(YesNoScreen):
@@ -272,49 +469,25 @@ class FilterScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "FilterScreen")
 
-    def __init__(
-        self,
-        df: pl.DataFrame,
-        current_col_idx: int | None = None,
-        current_cell_value: str | None = None,
-    ):
+    def __init__(self, df: pl.DataFrame, cidx: int, input_value: str | None = None):
         self.df = df
-        self.current_col_idx = current_col_idx
+        self.cidx = cidx
         super().__init__(
             title="Filter by Expression",
-            label="e.g., $1 > 50, $name == 'text', $_ > 100, $a < $b",
-            input=f"$_ == {current_cell_value}",
-            on_yes_callback=self._validate_filter,
+            label="e.g., NULL, $1 > 50, $name == 'text', $_ > 100, $a < $b, $_.str.contains('sub')",
+            input=input_value,
+            checkbox="Match Nocase",
+            checkbox2="Match Whole",
+            on_yes_callback=self._get_input,
         )
 
-    def _validate_filter(self) -> pl.Expr | None:
-        """Validate and return the filter expression."""
-        expression = self.input.value.strip()
-
-        try:
-            # Try to parse the expression to ensure it's valid
-            expr_str = parse_filter_expression(
-                expression, self.df, self.current_col_idx
-            )
-
-            try:
-                # Test the expression by evaluating it
-                expr = eval(expr_str, {"pl": pl})
-
-                # Expression is valid
-                return expr, expr_str
-            except Exception as e:
-                self.notify(
-                    f"Error evaluating expression: {str(e)}",
-                    title="Filter",
-                    severity="error",
-                )
-        except ValueError as ve:
-            self.notify(
-                f"Invalid expression: {str(ve)}", title="Filter", severity="error"
-            )
+    def _get_input(self) -> tuple[str, int, bool, bool]:
+        """Get input."""
+        term = self.input.value.strip()
+        match_nocase = self.checkbox.value
+        match_whole = self.checkbox2.value
 
-        return None
+        return term, self.cidx, match_nocase, match_whole
 
 
 class FreezeScreen(YesNoScreen):
@@ -327,58 +500,28 @@ class FreezeScreen(YesNoScreen):
 
     def __init__(self):
         super().__init__(
-            title="Pin Rows and Columns",
-            label="Enter number of fixed rows and columns (space-separated)",
-            input="1",
-            on_yes_callback=self._parse_pin_input,
+            title="Pin Rows / Columns",
+            label="Enter number of fixed rows",
+            input={"value": "0", "type": "number"},
+            label2="Enter number of fixed columns",
+            input2={"value": "0", "type": "number"},
+            on_yes_callback=self._get_input,
         )
 
-    def _parse_pin_input(self) -> tuple[int, int] | None:
+    def _get_input(self) -> tuple[int, int] | None:
         """Parse and validate the pin input.
 
         Returns:
             Tuple of (fixed_rows, fixed_columns) or None if invalid.
         """
-        input_str = self.input.value.strip()
+        fixed_rows = int(self.input.value.strip())
+        fixed_cols = int(self.input2.value.strip())
 
-        if not input_str:
-            self.notify("Input cannot be empty", title="Pin", severity="error")
+        if fixed_rows < 0 or fixed_cols < 0:
+            self.notify("Values must be non-negative", title="Pin", severity="error")
             return None
 
-        parts = input_str.split()
-
-        if len(parts) == 1:
-            # Only fixed rows provided
-            try:
-                fixed_rows = int(parts[0])
-                if fixed_rows < 0:
-                    raise ValueError("must be non-negative")
-                return (fixed_rows, 0)
-            except ValueError as e:
-                self.notify(
-                    f"Invalid fixed rows value: {str(e)}", title="Pin", severity="error"
-                )
-                return None
-        elif len(parts) == 2:
-            # Both fixed rows and columns provided
-            try:
-                fixed_rows = int(parts[0])
-                fixed_cols = int(parts[1])
-                if fixed_rows < 0 or fixed_cols < 0:
-                    raise ValueError("values must be non-negative")
-                return (fixed_rows, fixed_cols)
-            except ValueError as e:
-                self.notify(
-                    f"Invalid input values: {str(e)}", title="Pin", severity="error"
-                )
-                return None
-        else:
-            self.notify(
-                "Provide one or two space-separated integers",
-                title="Pin",
-                severity="error",
-            )
-            return None
+        return fixed_rows, fixed_cols
 
 
 class OpenFileScreen(YesNoScreen):
@@ -404,4 +547,126 @@ class OpenFileScreen(YesNoScreen):
                 self.notify("Filename cannot be empty", title="Open", severity="error")
                 return None
 
-        return None
+
+class EditColumnScreen(YesNoScreen):
+    """Modal screen to edit an entire column with an expression."""
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "EditColumnScreen")
+
+    def __init__(self, cidx: int, df: pl.DataFrame):
+        self.cidx = cidx
+        self.df = df
+        super().__init__(
+            title="Edit Column",
+            label=f"by value or Polars expression, e.g., abc, pl.lit(7), {NULL}, $_ * 2, $1 + $2, $_.str.to_uppercase(), pl.arange(0, pl.len())",
+            input="$_",
+            on_yes_callback=self._get_input,
+        )
+
+    def _get_input(self) -> tuple[str, int]:
+        """Get input."""
+        term = self.input.value.strip()
+        return term, self.cidx
+
+
+class AddColumnScreen(YesNoScreen):
+    """Modal screen to add a new column with an expression."""
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "AddColumnScreen")
+
+    def __init__(self, cidx: int, df: pl.DataFrame):
+        self.cidx = cidx
+        self.df = df
+        self.existing_columns = set(df.columns)
+        super().__init__(
+            title="Add Column",
+            label="Enter column name",
+            input="column name",
+            label2="Enter value or Polars expression, e.g., 123, NULL, $_ * 2",
+            input2="column value or expression",
+            on_yes_callback=self._get_input,
+        )
+
+    def _get_input(self) -> tuple[int, str, str] | None:
+        """Validate and return the new column configuration."""
+        col_name = self.input.value.strip()
+        term = self.input2.value.strip()
+
+        # Validate column name
+        if not col_name:
+            self.notify("Column name cannot be empty", title="Add Column", severity="error")
+            return None
+
+        if col_name in self.existing_columns:
+            self.notify(
+                f"Column [$accent]{col_name}[/] already exists",
+                title="Add Column",
+                severity="error",
+            )
+            return None
+
+        if term == NULL:
+            return self.cidx, col_name, pl.lit(None)
+        elif tentative_expr(term):
+            try:
+                expr = validate_expr(term, self.df, self.cidx)
+                return self.cidx, col_name, expr
+            except ValueError as e:
+                self.notify(f"Invalid expression [$error]{term}[/]: {str(e)}", title="Add Column", severity="error")
+            return None
+        else:
+            # Treat as literal value
+            dtype = self.df.dtypes[self.cidx]
+            try:
+                value = DtypeConfig(dtype).convert(term)
+                return self.cidx, col_name, pl.lit(value)
+            except Exception:
+                self.notify(
+                    f"Unable to convert [$accent]{term}[/] to [$warning]{dtype}[/]. Cast to string.",
+                    title="Add Column",
+                    severity="warning",
+                )
+                return self.cidx, col_name, pl.lit(term)
+
+
+class FindReplaceScreen(YesNoScreen):
+    """Modal screen to replace column values with an expression."""
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "ReplaceScreen")
+
+    def __init__(self, dftable: DataFrameTable):
+        term_find = str(dftable.cursor_value)
+        super().__init__(
+            title="Find and Replace",
+            label="Find",
+            input=term_find,
+            label2="Replace with",
+            input2="new value or expression",
+            checkbox="Match Nocase",
+            checkbox2="Match Whole",
+            yes="Replace",
+            maybe="Replace All",
+            no="Cancel",
+            on_yes_callback=self._get_input,
+            on_maybe_callback=self._get_input_replace_all,
+        )
+
+    def _get_input(self) -> tuple[str, str, bool, bool, bool]:
+        """Get input."""
+        term_find = self.input.value.strip()
+        term_replace = self.input2.value.strip()
+        match_nocase = self.checkbox.value
+        match_whole = self.checkbox2.value
+        replace_all = False
+
+        return term_find, term_replace, match_nocase, match_whole, replace_all
+
+    def _get_input_replace_all(self) -> tuple[str, str, bool, bool, bool]:
+        """Get input for 'Replace All'."""
+        term_find = self.input.value.strip()
+        term_replace = self.input2.value.strip()
+        match_nocase = self.checkbox.value
+        match_whole = self.checkbox2.value
+        replace_all = True
+
+        return term_find, term_replace, match_nocase, match_whole, replace_all