tksheet 7.4.7__py3-none-any.whl → 7.4.8__py3-none-any.whl

tksheet/find_window.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 import tkinter as tk
 from collections.abc import Callable
 from typing import Any, Literal
@@ -10,6 +11,8 @@ from .other_classes import DotDict
 
 
 class FindWindowTkText(tk.Text):
+    """Custom Text widget for the FindWindow class."""
+
     def __init__(
         self,
         parent: tk.Misc,
@@ -42,6 +45,7 @@ class FindWindowTkText(tk.Text):
         select_bg: str,
         select_fg: str,
     ) -> None:
+        """Reset the text widget's appearance and menu options."""
         self.config(
             font=font,
             background=bg,
@@ -84,10 +88,12 @@ class FindWindowTkText(tk.Text):
         )
 
     def rc(self, event: Any) -> None:
+        """Show the right-click popup menu."""
         self.focus_set()
         self.rc_popup_menu.tk_popup(event.x_root, event.y_root)
 
     def delete_key(self, event: Any = None) -> None:
+        """Handle the Delete key based on editor configuration."""
         if self.editor_del_key == "forward":
             return
         elif not self.editor_del_key:
@@ -101,38 +107,60 @@ class FindWindowTkText(tk.Text):
             return "break"
 
     def select_all(self, event: Any = None) -> Literal["break"]:
+        """Select all text in the widget."""
         self.tag_add(tk.SEL, "1.0", tk.END)
         self.mark_set(tk.INSERT, tk.END)
-        # self.see(tk.INSERT)
         return "break"
 
     def cut(self, event: Any = None) -> Literal["break"]:
+        """Cut selected text."""
         self.event_generate(f"<{ctrl_key}-x>")
         self.event_generate("<KeyRelease>")
         return "break"
 
     def copy(self, event: Any = None) -> Literal["break"]:
+        """Copy selected text."""
         self.event_generate(f"<{ctrl_key}-c>")
         return "break"
 
     def paste(self, event: Any = None) -> Literal["break"]:
+        """Paste text from clipboard."""
         self.event_generate(f"<{ctrl_key}-v>")
         self.event_generate("<KeyRelease>")
         return "break"
 
     def undo(self, event: Any = None) -> Literal["break"]:
+        """Undo the last action."""
         self.event_generate(f"<{ctrl_key}-z>")
         self.event_generate("<KeyRelease>")
         return "break"
 
 
+class Tooltip(tk.Toplevel):
+    def __init__(self, parent: tk.Misc, text: str, bg: str, fg: str) -> None:
+        super().__init__(parent)
+        self.withdraw()
+        self.overrideredirect(True)
+        self.label = tk.Label(self, text=text, background=bg, foreground=fg, relief="flat", borderwidth=0)
+        self.label.pack()
+        self.text = text
+        self.config(background=bg, highlightbackground=bg, highlightthickness=0)
+        self.update_idletasks()
+
+
 class FindWindow(tk.Frame):
+    """A frame containing find and replace functionality with label highlighting and tooltips."""
+
     def __init__(
         self,
         parent: tk.Misc,
         find_next_func: Callable,
         find_prev_func: Callable,
         close_func: Callable,
+        replace_func: Callable,
+        replace_all_func: Callable,
+        toggle_replace_func: Callable,
+        drag_func: Callable,
     ) -> None:
         super().__init__(
             parent,
@@ -140,81 +168,244 @@ class FindWindow(tk.Frame):
             height=0,
             bd=0,
         )
-        self.grid_columnconfigure(0, weight=1)
+        self.grid_columnconfigure(1, weight=1)
+        self.grid_columnconfigure(4, uniform="group1")
+        self.grid_columnconfigure(5, uniform="group2")
         self.grid_rowconfigure(0, weight=1)
+        self.grid_rowconfigure(2, weight=1)
         self.grid_propagate(False)
         self.parent = parent
+        self.tooltip_after_id = None
+        self.tooltip_last_x = None
+        self.tooltip_last_y = None
+        self.tooltip_widget = None  # Added to track the current widget
+        self.tooltip = None
+
+        self.find_next_func = find_next_func
+        self.find_prev_func = find_prev_func
+        self.replace_func = replace_func
+        self.toggle_replace_func = toggle_replace_func
+        self.drag_func = drag_func
+        self.close_func = close_func
+
+        self.toggle_replace = tk.Label(self, text="↓", cursor="sb_h_double_arrow", highlightthickness=1)
+        self.toggle_replace.grid(row=0, column=0, sticky="ns")
+        self.toggle_replace.grid_remove()
+
         self.tktext = FindWindowTkText(self)
-        self.tktext.grid(row=0, column=0, sticky="nswe")
-        self.bg = None
-        self.fg = None
+        self.tktext.grid(row=0, column=1, sticky="nswe")
 
-        self.find_previous_arrow = tk.Label(self, text="▲", cursor="hand2", highlightthickness=1)
-        self.find_previous_arrow.bind("<Button-1>", find_prev_func)
-        self.find_previous_arrow.grid(row=0, column=1)
+        self.find_previous_arrow = tk.Label(self, text="↑", cursor="hand2", highlightthickness=1)
+        self.find_previous_arrow.grid(row=0, column=2)
 
-        self.find_next_arrow = tk.Label(self, text="▼", cursor="hand2", highlightthickness=1)
-        self.find_next_arrow.bind("<Button-1>", find_next_func)
-        self.find_next_arrow.grid(row=0, column=2)
+        self.find_next_arrow = tk.Label(self, text="↓", cursor="hand2", highlightthickness=1)
+        self.find_next_arrow.grid(row=0, column=3)
 
         self.find_in_selection = False
-        self.in_selection = tk.Label(self, text="🔎", cursor="hand2", highlightthickness=1)
-        self.in_selection.bind("<Button-1>", self.toggle_in_selection)
-        self.in_selection.grid(row=0, column=3)
+        self.in_selection = tk.Label(self, text="≡", cursor="hand2", highlightthickness=1)
+        self.in_selection.grid(row=0, column=4)
 
         self.close = tk.Label(self, text="✕", cursor="hand2", highlightthickness=1)
-        self.close.bind("<Button-1>", close_func)
-        self.close.grid(row=0, column=4)
+        self.close.grid(row=0, column=5, sticky="nswe")
 
-        for widget in (self.find_previous_arrow, self.find_next_arrow, self.in_selection, self.close):
-            widget.bind("<Enter>", lambda w, widget=widget: self.enter_label(widget=widget))
-            widget.bind("<Leave>", lambda w, widget=widget: self.leave_label(widget=widget))
+        self.separator = tk.Frame(self, height=1)
+        self.separator.grid(row=1, column=1, columnspan=3, sticky="we")
+        self.separator.grid_remove()
+
+        self.replace_tktext = FindWindowTkText(self)
+        self.replace_tktext.grid(row=2, column=1, columnspan=4, sticky="nswe")
+        self.replace_tktext.grid_remove()
+
+        self.replace_next = tk.Label(self, text="→", cursor="hand2", highlightthickness=1)
+        self.replace_next.grid(row=2, column=4, sticky="nswe")
+        self.replace_next.grid_remove()
+
+        self.replace_all = tk.Label(self, text="⟳", cursor="hand2", highlightthickness=1)
+        self.replace_all.grid(row=2, column=5, sticky="nswe")
+        self.replace_all.grid_remove()
+
+        self.tktext.bind("<Tab>", self.handle_tab)
+        self.replace_tktext.bind("<Tab>", self.handle_tab)
+        self.tktext.bind("<Return>", self.handle_return)
+        self.replace_tktext.bind("<Return>", self.handle_return)
+
+        self.bind_label(self.toggle_replace, self.toggle_replace_window, self.drag_func)
+        self.bind_label(self.find_previous_arrow, find_prev_func)
+        self.bind_label(self.find_next_arrow, find_next_func)
+        self.bind_label(self.in_selection, self.toggle_in_selection)
+        self.bind_label(self.close, close_func)
+        self.bind_label(self.replace_next, replace_func)
+        self.bind_label(self.replace_all, replace_all_func)
+
+        self.replace_visible = False
+        self.bg = None
+        self.fg = None
+        self.pressed_label = None
 
         for b in ("Option", "Alt"):
             for c in ("l", "L"):
                 recursive_bind(self, f"<{b}-{c}>", self.toggle_in_selection)
 
+        action_labels = [
+            (self.toggle_replace, "Toggle Replace"),
+            (self.find_previous_arrow, "Previous Match"),
+            (self.find_next_arrow, "Next Match"),
+            (self.in_selection, "Find in Selection"),
+            (self.close, "Close"),
+            (self.replace_next, "Replace"),
+            (self.replace_all, "Replace All"),
+        ]
+        for widget, text in action_labels:
+            widget.tooltip_text = text
+            widget.bind("<Enter>", self.on_enter)
+            widget.bind("<Leave>", self.on_leave)
+
+    def bind_label(self, label: tk.Label, func: Callable, motion_func: Callable | None = None) -> None:
+        """Bind press, release, and optional motion events with highlight changes."""
+
+        def on_press(event: tk.Event) -> None:
+            label.config(highlightbackground=self.border_color, highlightcolor=self.border_color)
+            self.pressed_label = label
+
+        def on_release(event: tk.Event) -> None:
+            self.pressed_label = None
+            if 0 <= event.x < label.winfo_width() and 0 <= event.y < label.winfo_height():
+                label.config(highlightbackground=self.fg, highlightcolor=self.fg)
+                func(event)
+            else:
+                label.config(highlightbackground=self.bg, highlightcolor=self.fg)
+
+        label.bind("<Button-1>", on_press)
+        label.bind("<ButtonRelease-1>", on_release)
+        if motion_func:
+            label.bind("<B1-Motion>", motion_func)
+
+    def on_enter(self, event: tk.Event) -> None:
+        """Handle mouse entering a widget."""
+        widget = event.widget
+        self.enter_label(widget)
+        self.tooltip_widget = widget
+        self.tooltip_last_x, self.tooltip_last_y = get_mouse_coords(widget)
+        self.start_tooltip_timer()
+
+    def on_leave(self, event: tk.Event) -> None:
+        """Handle mouse leaving a widget."""
+        widget = event.widget
+        self.leave_label(widget)
+        self.hide_tooltip()
+        self.cancel_tooltip()
+        self.tooltip_widget = None
+
     def enter_label(self, widget: tk.Misc) -> None:
-        widget.config(
-            highlightbackground=self.fg,
-            highlightcolor=self.fg,
-        )
+        """Highlight label on hover if no label is pressed."""
+        if self.pressed_label is None:
+            widget.config(highlightbackground=self.fg, highlightcolor=self.fg)
 
     def leave_label(self, widget: tk.Misc) -> None:
-        if widget == self.in_selection and self.find_in_selection:
-            return
-        widget.config(
-            highlightbackground=self.bg,
-            highlightcolor=self.fg,
-        )
+        """Remove highlight on leave unless toggled or pressed."""
+        if self.pressed_label is None:
+            if widget == self.in_selection and self.find_in_selection:
+                return
+            widget.config(highlightbackground=self.bg, highlightcolor=self.fg)
+
+    def focus_find(self, event: tk.Misc = None) -> Literal["break"]:
+        widget = self.focus_get()
+        if widget == self.tktext:
+            self.tktext.select_all()
+        else:
+            self.tktext.focus_set()
+        return "break"
+
+    def focus_replace(self, event: tk.Misc = None) -> Literal["break"]:
+        widget = self.focus_get()
+        if widget == self.replace_tktext:
+            self.replace_tktext.select_all()
+        else:
+            self.replace_tktext.focus_set()
+        return "break"
+
+    def toggle_replace_window(self, event: tk.Misc = None) -> None:
+        """Toggle visibility of the replace window."""
+        if self.replace_visible:
+            self.replace_tktext.grid_remove()
+            self.replace_next.grid_remove()
+            self.replace_all.grid_remove()
+            self.separator.grid_remove()
+            self.toggle_replace.config(text="↓")
+            self.toggle_replace.grid(row=0, column=0, rowspan=1, sticky="ns")
+            self.replace_visible = False
+        elif self.replace_enabled:
+            self.separator.grid()
+            self.replace_tktext.grid()
+            self.replace_next.grid()
+            self.replace_all.grid()
+            self.toggle_replace.config(text="↑")
+            self.toggle_replace.grid(row=0, column=0, rowspan=3, sticky="ns")
+            self.replace_visible = True
+        self.toggle_replace_func()
 
     def toggle_in_selection(self, event: tk.Misc) -> None:
+        """Toggle the find-in-selection state."""
         self.find_in_selection = not self.find_in_selection
         self.enter_label(self.in_selection)
         self.leave_label(self.in_selection)
 
+    def handle_tab(self, event: tk.Event) -> Literal["break"]:
+        """Switch focus between find and replace text widgets."""
+        if not self.replace_visible:
+            self.toggle_replace_window()
+        if event.widget == self.tktext:
+            self.replace_tktext.focus_set()
+        elif event.widget == self.replace_tktext:
+            self.tktext.focus_set()
+        return "break"
+
+    def handle_return(self, event: tk.Event) -> Literal["break"]:
+        """Trigger find or replace based on focused widget."""
+        if event.widget == self.tktext:
+            self.find_next_func()
+        elif event.widget == self.replace_tktext:
+            self.replace_func()
+        return "break"
+
     def get(self) -> str:
+        """Return the find text."""
         return self.tktext.get("1.0", "end-1c")
 
+    def get_replace(self) -> str:
+        """Return the replace text."""
+        return self.replace_tktext.get("1.0", "end-1c")
+
     def get_num_lines(self) -> int:
+        """Return the number of lines in the find text."""
         return int(self.tktext.index("end-1c").split(".")[0])
 
     def set_text(self, text: str = "") -> None:
+        """Set the find text."""
         self.tktext.delete(1.0, "end")
         self.tktext.insert(1.0, text)
 
     def reset(
         self,
         border_color: str,
+        grid_color: str,
         menu_kwargs: DotDict,
         sheet_ops: DotDict,
         bg: str,
         fg: str,
         select_bg: str,
         select_fg: str,
+        replace_enabled: bool,
     ) -> None:
+        """Reset styles and configurations."""
+        self.replace_enabled = replace_enabled
+        if replace_enabled:
+            self.toggle_replace.grid()
+        else:
+            self.toggle_replace.grid_remove()
         self.bg = bg
         self.fg = fg
+        self.border_color = border_color
         self.tktext.reset(
             menu_kwargs=menu_kwargs,
             sheet_ops=sheet_ops,
@@ -224,7 +415,24 @@ class FindWindow(tk.Frame):
             select_bg=select_bg,
             select_fg=select_fg,
         )
-        for widget in (self.find_previous_arrow, self.find_next_arrow, self.in_selection, self.close):
+        self.replace_tktext.reset(
+            menu_kwargs=menu_kwargs,
+            sheet_ops=sheet_ops,
+            font=menu_kwargs.font,
+            bg=bg,
+            fg=fg,
+            select_bg=select_bg,
+            select_fg=select_fg,
+        )
+        for widget in (
+            self.find_previous_arrow,
+            self.find_next_arrow,
+            self.in_selection,
+            self.close,
+            self.toggle_replace,
+            self.replace_next,
+            self.replace_all,
+        ):
             widget.config(
                 font=menu_kwargs.font,
                 bg=bg,
@@ -240,3 +448,89 @@ class FindWindow(tk.Frame):
             highlightcolor=border_color,
             highlightthickness=1,
         )
+        self.separator.config(background=grid_color)
+
+        for b in sheet_ops.find_bindings:
+            recursive_bind(self, b, self.focus_find)
+        for b in sheet_ops.toggle_replace_bindings:
+            recursive_bind(self, b, self.focus_replace)
+
+        for b in sheet_ops.escape_bindings:
+            recursive_bind(self, b, self.close_func)
+
+        for b in sheet_ops.find_next_bindings:
+            recursive_bind(self, b, self.find_next_func)
+        for b in sheet_ops.find_previous_bindings:
+            recursive_bind(self, b, self.find_prev_func)
+
+    def start_tooltip_timer(self) -> None:
+        self.tooltip_after_id = self.after(400, self.check_and_show_tooltip)
+
+    def check_and_show_tooltip(self) -> None:
+        """Check if the mouse position has changed and show tooltip if stationary."""
+        if self.tooltip_widget is None:
+            return
+        current_x, current_y = get_mouse_coords(self.tooltip_widget)
+        if current_x < 0 or current_y < 0:  # Mouse outside window
+            return
+        # Allow 2-pixel tolerance for minor movements
+        if abs(current_x - self.tooltip_last_x) <= 2 and abs(current_y - self.tooltip_last_y) <= 2:
+            self.show_tooltip(self.tooltip_widget)
+        else:
+            self.tooltip_last_x = current_x
+            self.tooltip_last_y = current_y
+            self.tooltip_after_id = self.after(400, self.check_and_show_tooltip)
+
+    def show_tooltip(self, widget: tk.Misc) -> None:
+        """Show the tooltip at the specified position."""
+        bg = self.bg if self.bg is not None else "white"
+        fg = self.fg if self.fg is not None else "black"
+        self.tooltip = Tooltip(self, widget.tooltip_text, bg, fg)
+        # Use current mouse position instead of recorded position
+        self.tooltip.deiconify()
+        show_x = max(0, self.winfo_toplevel().winfo_pointerx() - self.tooltip.winfo_width() - 5)
+        show_y = self.winfo_toplevel().winfo_pointery()
+        self.tooltip.wm_geometry(f"+{show_x}+{show_y - 10}")
+
+    def cancel_tooltip(self):
+        """Cancel any scheduled tooltip."""
+        if self.tooltip_after_id is not None:
+            self.after_cancel(self.tooltip_after_id)
+            self.tooltip_after_id = None
+
+    def hide_tooltip(self):
+        """Hide the tooltip."""
+        if self.tooltip is not None:
+            self.tooltip.destroy()
+            self.tooltip = None
+
+
+def replacer(find: str, replace: str, current: str) -> Callable[[re.Match], str]:
+    """Create a replacement function for re.sub with special empty string handling."""
+
+    def _replacer(match: re.Match) -> str:
+        if find:
+            return replace
+        else:
+            if len(current) == 0:
+                return replace
+            else:
+                return match.group(0)
+
+    return _replacer
+
+
+def get_mouse_coords(widget: tk.Misc) -> tuple[int, int]:
+    # Get absolute mouse coordinates (relative to screen)
+    mouse_x = widget.winfo_pointerx()
+    mouse_y = widget.winfo_pointery()
+
+    # Get widget's position relative to the screen
+    widget_x = widget.winfo_rootx()
+    widget_y = widget.winfo_rooty()
+
+    # Calculate coordinates relative to the widget
+    relative_x = mouse_x - widget_x
+    relative_y = mouse_y - widget_y
+
+    return relative_x, relative_y

tksheet/functions.py

@@ -203,6 +203,12 @@ def recursive_bind(widget: tk.Misc, event: str, callback: Callable) -> None:
         recursive_bind(child, event, callback)
 
 
+def recursive_unbind(widget: tk.Misc, event: str) -> None:
+    widget.unbind(event)
+    for child in widget.winfo_children():
+        recursive_unbind(child, event)
+
+
 def tksheet_type_error(kwarg: str, valid_types: list[str], not_type: Any) -> str:
     valid_types = ", ".join(f"{type_}" for type_ in valid_types)
     return f"Argument '{kwarg}' must be one of the following types: {valid_types}, not {type(not_type)}."
@@ -334,7 +340,7 @@ def event_dict(
         selection_boxes={} if boxes is None else boxes,
         selected=() if selected is None else selected,
         being_selected=() if being_selected is None else being_selected,
-        data=[] if data is None else data,
+        data={} if data is None else data,
         key="" if key is None else key,
         value=None if value is None else value,
         loc=() if loc is None else loc,
@@ -414,6 +420,27 @@ def push_n(num: int, sorted_seq: Sequence[int]) -> int:
         return num + lo
 
 
+def get_menu_kwargs(ops: DotDict[str, Any]) -> DotDict[str, Any]:
+    return DotDict(
+        {
+            "font": ops.table_font,
+            "foreground": ops.popup_menu_fg,
+            "background": ops.popup_menu_bg,
+            "activebackground": ops.popup_menu_highlight_bg,
+            "activeforeground": ops.popup_menu_highlight_fg,
+        }
+    )
+
+
+def get_bg_fg(ops: DotDict[str, Any]) -> dict[str, str]:
+    return {
+        "bg": ops.table_editor_bg,
+        "fg": ops.table_editor_fg,
+        "select_bg": ops.table_editor_select_bg,
+        "select_fg": ops.table_editor_select_fg,
+    }
+
+
 def get_dropdown_kwargs(
     values: list[Any] | None = None,
     set_value: Any = None,
@@ -645,7 +672,7 @@ def color_tup(color: str) -> tuple[int, int, int]:
     return int(res[1:3], 16), int(res[3:5], 16), int(res[5:], 16)
 
 
-def down_cell_within_box(
+def cell_down_within_box(
     r: int,
     c: int,
     r1: int,
@@ -909,45 +936,68 @@ def gen_coords(
 
 
 def box_gen_coords(
-    start_row: int,
-    start_col: int,
-    total_cols: int,
-    total_rows: int,
-    reverse: bool = False,
+    from_r: int,
+    from_c: int,
+    upto_r: int,
+    upto_c: int,
+    start_r: int,
+    start_c: int,
+    reverse: bool,
+    all_rows_displayed: bool = True,
+    all_cols_displayed: bool = True,
+    displayed_cols: list[int] | None = None,
+    displayed_rows: list[int] | None = None,
+    no_wrap: bool = False,
 ) -> Generator[tuple[int, int]]:
-    if reverse:
-        # yield start cell
-        yield (start_row, start_col)
-        # yield any remaining cells in the starting row before the start column
-        if start_col:
-            for col in reversed(range(start_col)):
-                yield (start_row, col)
-        # yield any cells above start row
-        for row in reversed(range(start_row)):
-            for col in reversed(range(total_cols)):
-                yield (row, col)
-        # yield cells from bottom of table upward
-        for row in range(total_rows - 1, start_row, -1):
-            for col in reversed(range(total_cols)):
-                yield (row, col)
-        # yield any remaining cells in start row
-        for col in range(total_cols - 1, start_col, -1):
-            yield (start_row, col)
+    # Initialize empty lists if None
+    if displayed_rows is None:
+        displayed_rows = []
+    if displayed_cols is None:
+        displayed_cols = []
+
+    # Adjust row indices based on displayed_rows
+    if not all_rows_displayed:
+        from_r = displayed_rows[from_r]
+        upto_r = displayed_rows[upto_r - 1] + 1
+        start_r = displayed_rows[start_r]
+    # Adjust column indices based on displayed_cols (fixing original bug)
+    if not all_cols_displayed:
+        from_c = displayed_cols[from_c]
+        upto_c = displayed_cols[upto_c - 1] + 1
+        start_c = displayed_cols[start_c]
+
+    if not reverse:
+        # Forward direction
+        # Part 1: From (start_r, start_c) to the end of the box
+        for c in range(start_c, upto_c):
+            yield (start_r, c)
+        for r in range(start_r + 1, upto_r):
+            for c in range(from_c, upto_c):
+                yield (r, c)
+        if not no_wrap:
+            # Part 2: Wrap around from beginning to just before (start_r, start_c)
+            for r in range(from_r, start_r):
+                for c in range(from_c, upto_c):
+                    yield (r, c)
+            if start_c > from_c:  # Only if there are columns before start_c
+                for c in range(from_c, start_c):
+                    yield (start_r, c)
     else:
-        # Yield cells from the start position to the end of the current row
-        for col in range(start_col, total_cols):
-            yield (start_row, col)
-        # yield from the next row to the last row
-        for row in range(start_row + 1, total_rows):
-            for col in range(total_cols):
-                yield (row, col)
-        # yield from the beginning up to the start
-        for row in range(start_row):
-            for col in range(total_cols):
-                yield (row, col)
-        # yield any remaining cells in the starting row before the start column
-        for col in range(start_col):
-            yield (start_row, col)
+        # Reverse direction
+        # Part 1: From (start_r, start_c) backwards to the start of the box
+        for c in range(start_c, from_c - 1, -1):
+            yield (start_r, c)
+        for r in range(start_r - 1, from_r - 1, -1):
+            for c in range(upto_c - 1, from_c - 1, -1):
+                yield (r, c)
+        if not no_wrap:
+            # Part 2: Wrap around from end to just after (start_r, start_c)
+            for r in range(upto_r - 1, start_r, -1):
+                for c in range(upto_c - 1, from_c - 1, -1):
+                    yield (r, c)
+            if start_c < upto_c - 1:  # Only if there are columns after start_c
+                for c in range(upto_c - 1, start_c, -1):
+                    yield (start_r, c)
 
 
 def next_cell(