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

dataframe_textual/data_frame_table.py

@@ -104,8 +104,12 @@ class DataFrameTable(DataTable):
         - **F** - 📊 Show frequency distribution
         - **s** - 📈 Show statistics for current column
         - **S** - 📊 Show statistics for entire dataframe
-        - **K** - 🔄 Cycle cursor (cell → row → column → cell)
+        - **h** - 👁️ Hide current column
+        - **H** - 👀 Show all hidden rows/columns
+        - **z** - 📌 Freeze rows and columns
         - **~** - 🏷️ Toggle row labels
+        - **,** - 🔢 Toggle thousand separator for numeric display
+        - **K** - 🔄 Cycle cursor (cell → row → column → cell)
 
         ## ↕️ Sorting
         - **[** - 🔼 Sort column ascending
@@ -136,7 +140,7 @@ class DataFrameTable(DataTable):
         - **{** - ⬆️ Go to previous selected row
         - **}** - ⬇️ Go to next selected row
         - **"** - 📍 Filter to show only selected rows
-        - **T** - 🧹 Clear all selections
+        - **T** - 🧹 Clear all selections and matches
 
         ## ✏️ Edit & Modify
         - **Double-click** - ✍️ Edit cell or rename column header
@@ -144,13 +148,16 @@ class DataFrameTable(DataTable):
         - **E** - 📊 Edit entire column with expression
         - **a** - ➕ Add empty column after current
         - **A** - ➕ Add column with name and optional expression
-        - **x** - 🗑️ Delete current row
-        - **X** - ✨ Clear current cell (set to None)
-        - **D** - 📋 Duplicate current row
+        - **x** - ❌ Delete current row
+        - **X** - ❌ Delete row and those below
+        - **Ctrl+X** - ❌ Delete row and those above
+        - **delete** - ❌ Clear current cell (set to NULL)
         - **-** - ❌ Delete current column
+        - **_** - ❌ Delete column and those after
+        - **Ctrl+-** - ❌ Delete column and those before
         - **d** - 📋 Duplicate current column
-        - **h** - 👁️ Hide current column
-        - **H** - 👀 Show all hidden columns
+        - **D** - 📋 Duplicate current row
+
 
         ## 🎯 Reorder
         - **Shift+↑↓** - ⬆️⬇️ Move row up/down
@@ -166,32 +173,39 @@ class DataFrameTable(DataTable):
         - **@** - 🔗 Make URLs in current column clickable with Ctrl/Cmd
 
         ## 💾 Data Management
-        - **z** - 📌 Freeze rows and columns
-        - **,** - 🔢 Toggle thousand separator for numeric display
         - **c** - 📋 Copy cell to clipboard
         - **Ctrl+c** - 📊 Copy column to clipboard
         - **Ctrl+r** - 📝 Copy row to clipboard (tab-separated)
         - **Ctrl+s** - 💾 Save current tab to file
         - **u** - ↩️ Undo last action
-        - **U** - 🔄 Reset to original data
+        - **U** - 🔄 Redo last undone action
+        - **Ctrl+U** - 🔁 Reset to initial state
     """).strip()
 
     # fmt: off
     BINDINGS = [
+        # Navigation
         ("g", "jump_top", "Jump to top"),
         ("G", "jump_bottom", "Jump to bottom"),
+        # Display
         ("h", "hide_column", "Hide column"),
-        ("H", "show_column", "Show columns"),
+        ("H", "show_hidden_rows_columns", "Show hidden rows/columns"),
+        ("tilde", "toggle_row_labels", "Toggle row labels"),  # `~`
+        ("K", "cycle_cursor_type", "Cycle cursor mode"),  # `K`
+        ("z", "freeze_row_column", "Freeze rows/columns"),
+        ("comma", "show_thousand_separator", "Toggle thousand separator"),  # `,`
+        # Copy
         ("c", "copy_cell", "Copy cell to clipboard"),
         ("ctrl+c", "copy_column", "Copy column to clipboard"),
         ("ctrl+r", "copy_row", "Copy row to clipboard"),
+        # Save
         ("ctrl+s", "save_to_file", "Save to file"),
+        # Detail, Frequency, and Statistics
         ("enter", "view_row_detail", "View row details"),
-        # Frequency & Statistics
         ("F", "show_frequency", "Show frequency"),
         ("s", "show_statistics", "Show statistics for column"),
         ("S", "show_statistics('dataframe')", "Show statistics for dataframe"),
-        # Sorting
+        # Sort
         ("left_square_bracket", "sort_ascending", "Sort ascending"),  # `[`
         ("right_square_bracket", "sort_descending", "Sort descending"),  # `]`
         # View
@@ -215,16 +229,23 @@ class DataFrameTable(DataTable):
         # Selection
         ("apostrophe", "make_selections", "Toggle row selection"),  # `'`
         ("t", "toggle_selections", "Toggle all row selections"),
-        ("T", "clear_selections", "Clear selections"),
+        ("T", "clear_selections_and_matches", "Clear selections"),
         ("quotation_mark", "filter_selected_rows", "Filter selected"),  # `"`
-        # Edit
+        # Delete
+        ("delete", "clear_cell", "Clear cell"),
         ("minus", "delete_column", "Delete column"),  # `-`
+        ("underscore", "delete_column_and_after", "Delete column and those after"),  # `_`
+        ("ctrl+minus", "delete_column_and_before", "Delete column and those before"),  # `Ctrl+-`
         ("x", "delete_row", "Delete row"),
-        ("X", "clear_cell", "Clear cell"),
+        ("X", "delete_row_and_below", "Delete row and those below"),
+        ("ctrl+x", "delete_row_and_up", "Delete row and those up"),
+        # Duplicate
         ("d", "duplicate_column", "Duplicate column"),
         ("D", "duplicate_row", "Duplicate row"),
+        # Edit
         ("e", "edit_cell", "Edit cell"),
         ("E", "edit_column", "Edit column"),
+        # Add
         ("a", "add_column", "Add column"),
         ("A", "add_column_expr", "Add column with expression"),
         # Reorder
@@ -238,14 +259,10 @@ class DataFrameTable(DataTable):
         ("exclamation_mark", "cast_column_dtype('bool')", "Cast column dtype to bool"),  # `!`
         ("dollar_sign", "cast_column_dtype('string')", "Cast column dtype to string"),  # `$`
         ("at", "make_cell_clickable", "Make cell clickable"),  # `@`
-        # Misc
-        ("tilde", "toggle_row_labels", "Toggle row labels"),  # `~`
-        ("K", "cycle_cursor_type", "Cycle cursor mode"),  # `K`
-        ("z", "freeze_row_column", "Freeze rows/columns"),
-        ("comma", "show_thousand_separator", "Toggle thousand separator"),  # `,`
         # Undo/Redo
         ("u", "undo", "Undo"),
-        ("U", "reset", "Reset to original"),
+        ("U", "redo", "Redo"),
+        ("ctrl+u", "reset", "Reset to initial state"),
     ]
     # fmt: on
 
@@ -287,8 +304,10 @@ class DataFrameTable(DataTable):
         self.fixed_rows = 0  # Number of fixed rows
         self.fixed_columns = 0  # Number of fixed columns
 
-        # History stack for undo/redo
+        # History stack for undo
         self.histories: deque[History] = deque()
+        # Current history state for redo
+        self.history: History = None
 
         # Pending filename for save operations
         self._pending_filename = ""
@@ -391,17 +410,27 @@ class DataFrameTable(DataTable):
                 matches.append((ridx, cidx))
         return matches
 
-    def on_mount(self) -> None:
-        """Initialize table display when the widget is mounted.
+    def get_row_key(self, row_idx: int) -> RowKey:
+        """Get the row key for a given table row index.
 
-        Called by Textual when the widget is first added to the display tree.
-        Currently a placeholder as table setup is deferred until first use.
+        Args:
+            row_idx: Row index in the table display.
 
         Returns:
-            None
+            Corresponding row key as string.
         """
-        # self._setup_table()
-        pass
+        return self._row_locations.get_key(row_idx)
+
+    def get_column_key(self, col_idx: int) -> ColumnKey:
+        """Get the column key for a given table column index.
+
+        Args:
+            col_idx: Column index in the table display.
+
+        Returns:
+            Corresponding column key as string.
+        """
+        return self._column_locations.get_key(col_idx)
 
     def _should_highlight(self, cursor: Coordinate, target_cell: Coordinate, type_of_cursor: CursorType) -> bool:
         """Determine if the given cell should be highlighted because of the cursor.
@@ -475,10 +504,10 @@ class DataFrameTable(DataTable):
                 self.refresh_row(new_row)
             elif self.cursor_type == "row":
                 self.refresh_row(old_coordinate.row)
-                self.refresh_row(new_coordinate.row)
+                self._highlight_row(new_coordinate.row)
             elif self.cursor_type == "column":
                 self.refresh_column(old_coordinate.column)
-                self.refresh_column(new_coordinate.column)
+                self._highlight_column(new_coordinate.column)
 
             # Handle scrolling if needed
             if self._require_update_dimensions:
@@ -486,6 +515,30 @@ class DataFrameTable(DataTable):
             else:
                 self._scroll_cursor_into_view()
 
+    def move_cursor_to(self, ridx: int, cidx: int) -> None:
+        """Move cursor based on the dataframe indices.
+
+        Args:
+            ridx: Row index (0-based) in the dataframe.
+            cidx: Column index (0-based) in the dataframe.
+        """
+        row_key = str(ridx)
+        col_key = self.df.columns[cidx]
+        row_idx, col_idx = self.get_cell_coordinate(row_key, col_key)
+        self.move_cursor(row=row_idx, column=col_idx)
+
+    def on_mount(self) -> None:
+        """Initialize table display when the widget is mounted.
+
+        Called by Textual when the widget is first added to the display tree.
+        Currently a placeholder as table setup is deferred until first use.
+
+        Returns:
+            None
+        """
+        # self._setup_table()
+        pass
+
     def on_key(self, event) -> None:
         """Handle key press events for pagination.
 
@@ -544,13 +597,21 @@ class DataFrameTable(DataTable):
         """Delete the current column."""
         self._delete_column()
 
+    def action_delete_column_and_after(self) -> None:
+        """Delete the current column and those after."""
+        self._delete_column(more="after")
+
+    def action_delete_column_and_before(self) -> None:
+        """Delete the current column and those before."""
+        self._delete_column(more="before")
+
     def action_hide_column(self) -> None:
         """Hide the current column."""
         self._hide_column()
 
-    def action_show_column(self) -> None:
-        """Show all hidden columns."""
-        self._show_column()
+    def action_show_hidden_rows_columns(self) -> None:
+        """Show all hidden rows/columns."""
+        self._show_hidden_rows_columns()
 
     def action_sort_ascending(self) -> None:
         """Sort by current column in ascending order."""
@@ -656,6 +717,14 @@ class DataFrameTable(DataTable):
         """Delete the current row."""
         self._delete_row()
 
+    def action_delete_row_and_below(self) -> None:
+        """Delete the current row and those below."""
+        self._delete_row(more="below")
+
+    def action_delete_row_and_up(self) -> None:
+        """Delete the current row and those above."""
+        self._delete_row(more="above")
+
     def action_duplicate_column(self) -> None:
         """Duplicate the current column."""
         self._duplicate_column()
@@ -668,10 +737,14 @@ class DataFrameTable(DataTable):
         """Undo the last action."""
         self._undo()
 
+    def action_redo(self) -> None:
+        """Redo the last undone action."""
+        self._redo()
+
     def action_reset(self) -> None:
-        """Reset to the original data."""
+        """Reset to the initial state."""
         self._setup_table(reset=True)
-        self.notify("Restored original display", title="Reset")
+        self.notify("Restored initial state", title="Reset")
 
     def action_move_column_left(self) -> None:
         """Move the current column to the left."""
@@ -689,9 +762,9 @@ class DataFrameTable(DataTable):
         """Move the current row down."""
         self._move_row("down")
 
-    def action_clear_selections(self) -> None:
-        """Clear all row selections."""
-        self._clear_selections()
+    def action_clear_selections_and_matches(self) -> None:
+        """Clear all row selections and matches."""
+        self._clear_selections_and_matches()
 
     def action_cycle_cursor_type(self) -> None:
         """Cycle through cursor types."""
@@ -781,41 +854,6 @@ class DataFrameTable(DataTable):
         """Go to the previous selected row."""
         self._previous_selected_row()
 
-    def _make_cell_clickable(self) -> None:
-        """Make cells with URLs in the current column clickable.
-
-        Scans all loaded rows in the current column for cells containing URLs
-        (starting with 'http://' or 'https://') and applies Textual link styling
-        to make them clickable. Does not modify the dataframe.
-
-        Returns:
-            None
-        """
-        cidx = self.cursor_col_idx
-        col_key = self.cursor_col_key
-        dtype = self.df.dtypes[cidx]
-
-        # Only process string columns
-        if dtype != pl.String:
-            return
-
-        # Count how many URLs were made clickable
-        url_count = 0
-
-        # Iterate through all loaded rows and make URLs clickable
-        for row in self.ordered_rows:
-            cell_text: Text = self.get_cell(row.key, col_key)
-            if cell_text.plain.startswith(("http://", "https://")):
-                cell_text.style = f"#00afff link {cell_text.plain}"  # sky blue
-                self.update_cell(row.key, col_key, cell_text)
-                url_count += 1
-
-        if url_count:
-            self.notify(
-                f"Made [$accent]{url_count}[/] cell(s) clickable in column [$success]{col_key.value}[/]",
-                title="Make Clickable",
-            )
-
     def on_mouse_scroll_down(self, event) -> None:
         """Load more rows when scrolling down with mouse."""
         self._check_and_load_more()
@@ -909,6 +947,7 @@ class DataFrameTable(DataTable):
         for row_idx, row in enumerate(df_slice.rows(), start):
             if not self.visible_rows[row_idx]:
                 continue  # Skip hidden rows
+
             vals, dtypes = [], []
             for val, col, dtype in zip(row, self.df.columns, self.df.dtypes):
                 if col in self.hidden_columns:
@@ -916,6 +955,7 @@ class DataFrameTable(DataTable):
                 vals.append(val)
                 dtypes.append(dtype)
             formatted_row = format_row(vals, dtypes, thousand_separator=self.thousand_separator)
+
             # Always add labels so they can be shown/hidden via CSS
             self.add_row(*formatted_row, key=str(row_idx), label=str(row_idx + 1))
 
@@ -937,51 +977,59 @@ class DataFrameTable(DataTable):
         if bottom_visible_row >= self.loaded_rows - 10:
             self._load_rows(self.loaded_rows + self.BATCH_SIZE)
 
-    def _do_highlight(self, clear: bool = False) -> None:
+    def _do_highlight(self, force: bool = False) -> None:
         """Update all rows, highlighting selected ones and restoring others to default.
 
         Args:
-            clear: If True, clear all highlights.
+            force: If True, clear all highlights and restore default styles.
         """
-        if clear:
-            self.selected_rows = [False] * len(self.df)
-            self.matches = defaultdict(set)
-
         # Ensure all selected rows or matches are loaded
         stop = rindex(self.selected_rows, True) + 1
         stop = max(stop, max(self.matches.keys(), default=0) + 1)
 
         self._load_rows(stop)
-        self._highlight_table()
+        self._highlight_table(force)
 
-    def _highlight_table(self) -> None:
+    def _highlight_table(self, force: bool = False) -> None:
         """Highlight selected rows/cells in red."""
+        if not force and not any(self.selected_rows) and not self.matches:
+            return  # Nothing to highlight
+
         # Update all rows based on selected state
         for row in self.ordered_rows:
-            row_idx = int(row.key.value)  # 0-based index
-            is_selected = self.selected_rows[row_idx]
-            match_cols = self.matches.get(row_idx, set())
+            ridx = int(row.key.value)  # 0-based index
+            is_selected = self.selected_rows[ridx]
+            match_cols = self.matches.get(ridx, set())
+
+            if not force and not is_selected and not match_cols:
+                continue  # No highlight needed for this row
 
             # Update all cells in this row
             for col_idx, col in enumerate(self.ordered_columns):
-                cell_text: Text = self.get_cell(row.key, col.key)
+                if not force and not is_selected and col_idx not in match_cols:
+                    continue  # No highlight needed for this cell
 
-                # Get style config based on dtype
-                dtype = self.df.dtypes[col_idx]
-                dc = DtypeConfig(dtype)
-                cell_text.style = "red" if is_selected or col_idx in match_cols else dc.style
+                cell_text: Text = self.get_cell(row.key, col.key)
+                need_update = False
+
+                if is_selected or col_idx in match_cols:
+                    cell_text.style = "red"
+                    need_update = True
+                elif force:
+                    # Restore original style based on dtype
+                    dtype = self.df.schema[col.key.value]
+                    dc = DtypeConfig(dtype)
+                    cell_text.style = dc.style
+                    need_update = True
 
                 # Update the cell in the table
-                self.update_cell(row.key, col.key, cell_text)
+                if need_update:
+                    self.update_cell(row.key, col.key, cell_text)
 
     # History & Undo
-    def _add_history(self, description: str) -> None:
-        """Add the current state to the history stack.
-
-        Args:
-            description: Description of the action for this history entry.
-        """
-        history = History(
+    def _create_history(self, description: str) -> None:
+        """Create the initial history state."""
+        return History(
             description=description,
             df=self.df,
             filename=self.filename,
@@ -995,16 +1043,12 @@ class DataFrameTable(DataTable):
             cursor_coordinate=self.cursor_coordinate,
             matches={k: v.copy() for k, v in self.matches.items()},
         )
-        self.histories.append(history)
 
-    def _undo(self) -> None:
-        """Undo the last action."""
-        if not self.histories:
-            self.notify("No actions to undo", title="Undo", severity="warning")
+    def _apply_history(self, history: History) -> None:
+        """Apply the current history state to the table."""
+        if history is None:
             return
 
-        history = self.histories.pop()
-
         # Restore state
         self.df = history.df
         self.filename = history.filename
@@ -1016,13 +1060,54 @@ class DataFrameTable(DataTable):
         self.fixed_rows = history.fixed_rows
         self.fixed_columns = history.fixed_columns
         self.cursor_coordinate = history.cursor_coordinate
-        self.matches = {k: v.copy() for k, v in history.matches.items()}
+        self.matches = {k: v.copy() for k, v in history.matches.items()} if history.matches else defaultdict(set)
 
         # Recreate the table for display
         self._setup_table()
 
+    def _add_history(self, description: str) -> None:
+        """Add the current state to the history stack.
+
+        Args:
+            description: Description of the action for this history entry.
+        """
+        history = self._create_history(description)
+        self.histories.append(history)
+
+    def _undo(self) -> None:
+        """Undo the last action."""
+        if not self.histories:
+            self.notify("No actions to undo", title="Undo", severity="warning")
+            return
+
+        # Save current state for redo
+        self.history = self._create_history("Redo state")
+
+        # Pop the last history state for undo
+        history = self.histories.pop()
+
+        # Restore state
+        self._apply_history(history)
+
         # self.notify(f"Reverted: {history.description}", title="Undo")
 
+    def _redo(self) -> None:
+        """Redo the last undone action."""
+        if self.history is None:
+            self.notify("No actions to redo", title="Redo", severity="warning")
+            return
+
+        # Save current state for undo
+        self._add_history("Undo state")
+
+        # Restore state
+        self._apply_history(self.history)
+
+        # Clear redo state
+        self.history = None
+
+        # self.notify(f"Reapplied: {history.description}", title="Redo")
+
     # View
     def _view_row_detail(self) -> None:
         """Open a modal screen to view the selected row's details."""
@@ -1071,9 +1156,9 @@ class DataFrameTable(DataTable):
         self._add_history(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns")
 
         # Apply the pin settings to the table
-        if fixed_rows > 0:
+        if fixed_rows >= 0:
             self.fixed_rows = fixed_rows
-        if fixed_columns > 0:
+        if fixed_columns >= 0:
             self.fixed_columns = fixed_columns
 
         self.notify(
@@ -1082,38 +1167,69 @@ class DataFrameTable(DataTable):
         )
 
     # Delete & Move
-    def _delete_column(self) -> None:
+    def _delete_column(self, more: str = None) -> None:
         """Remove the currently selected column from the table."""
         # Get the column to remove
         col_idx = self.cursor_column
         col_name = self.cursor_col_name
         col_key = self.cursor_col_key
 
+        col_names_to_remove = []
+        col_keys_to_remove = []
+
+        # Remove all columns before the current column
+        if more == "before":
+            for i in range(col_idx + 1):
+                col_key = self.get_column_key(i)
+                col_names_to_remove.append(col_key.value)
+                col_keys_to_remove.append(col_key)
+
+            descr = f"Removed column [$success]{col_name}[/] and all columns before"
+
+        # Remove all columns after the current column
+        elif more == "after":
+            for i in range(col_idx, len(self.columns)):
+                col_key = self.get_column_key(i)
+                col_names_to_remove.append(col_key.value)
+                col_keys_to_remove.append(col_key)
+
+            descr = f"Removed column [$success]{col_name}[/] and all columns after"
+
+        # Remove only the current column
+        else:
+            col_names_to_remove.append(col_name)
+            col_keys_to_remove.append(col_key)
+            descr = f"Removed column [$success]{col_name}[/]"
+
         # Add to history
-        self._add_history(f"Removed column [$success]{col_name}[/]")
+        self._add_history(descr)
 
-        # Remove the column from the table display using the column name as key
-        self.remove_column(col_key)
+        # Remove the columns from the table display using the column names as keys
+        for ck in col_keys_to_remove:
+            self.remove_column(ck)
 
-        # Move cursor left if we deleted the last column
-        if col_idx >= len(self.columns):
-            self.move_cursor(column=len(self.columns) - 1)
+        # Move cursor left if we deleted the last column(s)
+        last_col_idx = len(self.columns) - 1
+        if col_idx > last_col_idx:
+            self.move_cursor(column=last_col_idx)
 
         # Remove from sorted columns if present
-        if col_name in self.sorted_columns:
-            del self.sorted_columns[col_name]
+        for col_name in col_names_to_remove:
+            if col_name in self.sorted_columns:
+                del self.sorted_columns[col_name]
 
         # Remove from matches
+        col_indices_to_remove = set(self.df.columns.index(name) for name in col_names_to_remove)
         for row_idx in list(self.matches.keys()):
-            self.matches[row_idx].discard(col_idx)
+            self.matches[row_idx].difference_update(col_indices_to_remove)
             # Remove empty entries
             if not self.matches[row_idx]:
                 del self.matches[row_idx]
 
         # Remove from dataframe
-        self.df = self.df.drop(col_name)
+        self.df = self.df.drop(col_names_to_remove)
 
-        self.notify(f"Removed column [$success]{col_name}[/]", title="Delete")
+        # self.notify(descr, title="Delete")
 
     def _hide_column(self) -> None:
         """Hide the currently selected column from the table display."""
@@ -1136,28 +1252,32 @@ class DataFrameTable(DataTable):
 
         # self.notify(f"Hid column [$accent]{col_name}[/]. Press [$success]H[/] to show hidden columns", title="Hide")
 
-    def _show_column(self) -> None:
-        """Show all hidden columns by recreating the table with all dataframe columns."""
+    def _show_hidden_rows_columns(self) -> None:
+        """Show all hidden rows/columns by recreating the table."""
         # Get currently visible columns
         visible_cols = set(col.key for col in self.ordered_columns)
 
-        # Find hidden columns (in dataframe but not in table)
-        hidden_cols = [col for col in self.df.columns if col not in visible_cols]
+        hidden_row_count = sum(0 if visible else 1 for visible in self.visible_rows)
+        hidden_col_count = sum(0 if col in visible_cols else 1 for col in self.df.columns)
 
-        if not hidden_cols:
-            self.notify("No hidden columns to show", title="Column", severity="warning")
+        if not hidden_row_count and not hidden_col_count:
+            self.notify("No hidden columns or rows to show", title="Show", severity="warning")
             return
 
         # Add to history
-        self._add_history(f"Showed {len(hidden_cols)} hidden column(s)")
+        self._add_history("Showed hidden rows/columns")
 
-        # Clear hidden columns tracking
+        # Clear hidden rows/columns tracking
+        self.visible_rows = [True] * len(self.df)
         self.hidden_columns.clear()
 
-        # Recreate table with all columns
+        # Recreate table for display
         self._setup_table()
 
-        self.notify(f"Showed [$accent]{len(hidden_cols)}[/] hidden column(s)", title="Column")
+        self.notify(
+            f"Showed [$accent]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] hidden column(s)",
+            title="Show",
+        )
 
     def _duplicate_column(self) -> None:
         """Duplicate the currently selected column, inserting it right after the current column."""
@@ -1179,6 +1299,18 @@ class DataFrameTable(DataTable):
             list(cols_before) + [new_col_name] + list(cols_after)
         )
 
+        # Update matches to account for new column
+        new_matches = defaultdict(set)
+        for row_idx, cols in self.matches.items():
+            new_cols = set()
+            for col_idx_in_set in cols:
+                if col_idx_in_set <= cidx:
+                    new_cols.add(col_idx_in_set)
+                else:
+                    new_cols.add(col_idx_in_set + 1)
+            new_matches[row_idx] = new_cols
+        self.matches = new_matches
+
         # Recreate the table for display
         self._setup_table()
 
@@ -1190,7 +1322,7 @@ class DataFrameTable(DataTable):
             title="Duplicate",
         )
 
-    def _delete_row(self) -> None:
+    def _delete_row(self, more: str = None) -> None:
         """Delete rows from the table and dataframe.
 
         Supports deleting multiple selected rows. If no rows are selected, deletes the row at the cursor.
@@ -1206,11 +1338,27 @@ class DataFrameTable(DataTable):
                 if selected:
                     predicates[ridx] = False
 
+        # Delete current row and those above
+        elif more == "above":
+            ridx = self.cursor_row_idx
+            history_desc = f"Deleted current row [$success]{ridx + 1}[/] and those above"
+            for i in range(ridx + 1):
+                predicates[i] = False
+
+        # Delete current row and those below
+        elif more == "below":
+            ridx = self.cursor_row_idx
+            history_desc = f"Deleted current row [$success]{ridx + 1}[/] and those below"
+            for i in range(ridx, len(self.df)):
+                if self.visible_rows[i]:
+                    predicates[i] = False
+
         # Delete the row at the cursor
         else:
             ridx = self.cursor_row_idx
             history_desc = f"Deleted row [$success]{ridx + 1}[/]"
-            predicates[ridx] = False
+            if self.visible_rows[ridx]:
+                predicates[ridx] = False
 
         # Add to history
         self._add_history(history_desc)
@@ -1238,7 +1386,7 @@ class DataFrameTable(DataTable):
 
         deleted_count = old_count - len(self.df)
         if deleted_count > 1:
-            self.notify(f"Deleted {deleted_count} row(s)", title="Delete")
+            self.notify(f"Deleted [$accent]{deleted_count}[/] row(s)", title="Delete")
 
     def _duplicate_row(self) -> None:
         """Duplicate the currently selected row, inserting it right after the current row."""
@@ -1263,8 +1411,14 @@ class DataFrameTable(DataTable):
         self.selected_rows = new_selected_rows
         self.visible_rows = new_visible_rows
 
-        # Clear all matches since row indices have changed
-        self.matches = defaultdict(set)
+        # Update matches to account for new row
+        new_matches = defaultdict(set)
+        for row_idx, cols in self.matches.items():
+            if row_idx <= ridx:
+                new_matches[row_idx] = cols
+            else:
+                new_matches[row_idx + 1] = cols
+        self.matches = new_matches
 
         # Recreate the table display
         self._setup_table()
@@ -2072,18 +2226,6 @@ class DataFrameTable(DataTable):
             title="Global Find",
         )
 
-    def _move_cursor(self, ridx: int, cidx: int) -> None:
-        """Move cursor based on the dataframe indices.
-
-        Args:
-            ridx: Row index (0-based) in the dataframe.
-            cidx: Column index (0-based) in the dataframe.
-        """
-        row_key = str(ridx)
-        col_key = self.df.columns[cidx]
-        row_idx, col_idx = self.get_cell_coordinate(row_key, col_key)
-        self.move_cursor(row=row_idx, column=col_idx)
-
     def _next_match(self) -> None:
         """Move cursor to the next match."""
         if not self.matches:
@@ -2099,12 +2241,12 @@ class DataFrameTable(DataTable):
         # Find the next match after current position
         for ridx, cidx in ordered_matches:
             if (ridx, cidx) > current_pos:
-                self._move_cursor(ridx, cidx)
+                self.move_cursor_to(ridx, cidx)
                 return
 
         # If no next match, wrap around to the first match
         first_ridx, first_cidx = ordered_matches[0]
-        self._move_cursor(first_ridx, first_cidx)
+        self.move_cursor_to(first_ridx, first_cidx)
 
     def _previous_match(self) -> None:
         """Move cursor to the previous match."""
@@ -2149,12 +2291,12 @@ class DataFrameTable(DataTable):
         # Find the next selected row after current position
         for ridx in selected_row_indices:
             if ridx > current_ridx:
-                self._move_cursor(ridx, self.cursor_col_idx)
+                self.move_cursor_to(ridx, self.cursor_col_idx)
                 return
 
         # If no next selected row, wrap around to the first selected row
         first_ridx = selected_row_indices[0]
-        self._move_cursor(first_ridx, self.cursor_col_idx)
+        self.move_cursor_to(first_ridx, self.cursor_col_idx)
 
     def _previous_selected_row(self) -> None:
         """Move cursor to the previous selected row."""
@@ -2171,12 +2313,12 @@ class DataFrameTable(DataTable):
         # Find the previous selected row before current position
         for ridx in reversed(selected_row_indices):
             if ridx < current_ridx:
-                self._move_cursor(ridx, self.cursor_col_idx)
+                self.move_cursor_to(ridx, self.cursor_col_idx)
                 return
 
         # If no previous selected row, wrap around to the last selected row
         last_ridx = selected_row_indices[-1]
-        self._move_cursor(last_ridx, self.cursor_col_idx)
+        self.move_cursor_to(last_ridx, self.cursor_col_idx)
 
     def _replace(self) -> None:
         """Open replace screen for current column."""
@@ -2459,8 +2601,8 @@ class DataFrameTable(DataTable):
                 title="Toggle",
             )
 
-        # Refresh the highlighting (also restores default styles for unselected rows)
-        self._do_highlight()
+        # Refresh the highlighting
+        self._do_highlight(force=True)
 
     def _make_selections(self) -> None:
         """Make selections based on current matches or toggle current row selection."""
@@ -2481,10 +2623,10 @@ class DataFrameTable(DataTable):
             self.notify(f"Selected [$accent]{new_selected_count}[/] rows", title="Toggle")
 
         # Refresh the highlighting (also restores default styles for unselected rows)
-        self._do_highlight()
+        self._do_highlight(force=True)
 
-    def _clear_selections(self) -> None:
-        """Clear all selected rows without removing them from the dataframe."""
+    def _clear_selections_and_matches(self) -> None:
+        """Clear all selected rows and matches without removing them from the dataframe."""
         # Check if any selected rows or matches
         if not any(self.selected_rows) and not self.matches:
             self.notify("No selections to clear", title="Clear", severity="warning")
@@ -2497,8 +2639,12 @@ class DataFrameTable(DataTable):
         # Save current state to history
         self._add_history("Cleared all selected rows")
 
-        # Clear all selections and refresh highlighting
-        self._do_highlight(clear=True)
+        # Clear all selections
+        self.selected_rows = [False] * len(self.df)
+        self.matches = defaultdict(set)
+
+        # Refresh the highlighting to remove all highlights
+        self._do_highlight(force=True)
 
         self.notify(f"Cleared selections for [$accent]{row_count}[/] rows", title="Clear")
 
@@ -2766,3 +2912,38 @@ class DataFrameTable(DataTable):
                 f"Saved current tab with [$accent]{len(self.df)}[/] rows to [$success]{filename}[/]",
                 title="Save",
             )
+
+    def _make_cell_clickable(self) -> None:
+        """Make cells with URLs in the current column clickable.
+
+        Scans all loaded rows in the current column for cells containing URLs
+        (starting with 'http://' or 'https://') and applies Textual link styling
+        to make them clickable. Does not modify the dataframe.
+
+        Returns:
+            None
+        """
+        cidx = self.cursor_col_idx
+        col_key = self.cursor_col_key
+        dtype = self.df.dtypes[cidx]
+
+        # Only process string columns
+        if dtype != pl.String:
+            return
+
+        # Count how many URLs were made clickable
+        url_count = 0
+
+        # Iterate through all loaded rows and make URLs clickable
+        for row in self.ordered_rows:
+            cell_text: Text = self.get_cell(row.key, col_key)
+            if cell_text.plain.startswith(("http://", "https://")):
+                cell_text.style = f"#00afff link {cell_text.plain}"  # sky blue
+                self.update_cell(row.key, col_key, cell_text)
+                url_count += 1
+
+        if url_count:
+            self.notify(
+                f"Made [$accent]{url_count}[/] cell(s) clickable in column [$success]{col_key.value}[/]",
+                title="Make Clickable",
+            )