tksheet 7.3.0__py3-none-any.whl → 7.3.2__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.3.0"
+__version__ = "7.3.2"
 
 from .colors import (
     color_map,
@@ -96,7 +96,7 @@ from .themes import (
     theme_light_green,
 )
 from .top_left_rectangle import TopLeftRectangle
-from .vars import (
+from .constants import (
     USER_OS,
     ctrl_key,
     emitted_events,

tksheet/column_headers.py

@@ -23,15 +23,25 @@ from typing import Literal
 from .colors import (
     color_map,
 )
+from .constants import (
+    USER_OS,
+    rc_binding,
+    text_editor_close_bindings,
+    text_editor_newline_bindings,
+    text_editor_to_unbind,
+)
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
     consecutive_ranges,
     event_dict,
+    event_has_char_key,
+    event_opens_dropdown_or_checkbox,
     get_n2a,
+    int_x_tuple,
     is_contiguous,
     new_tk_event,
-    stored_event_dict,
     rounded_box_coords,
+    stored_event_dict,
     try_binding,
 )
 from .other_classes import (
@@ -43,13 +53,8 @@ from .other_classes import (
 from .text_editor import (
     TextEditor,
 )
-from .vars import (
-    USER_OS,
-    rc_binding,
-    symbols_set,
-    text_editor_close_bindings,
-    text_editor_newline_bindings,
-    text_editor_to_unbind,
+from .types import (
+    AnyIter,
 )
 
 
@@ -928,20 +933,31 @@ class ColumnHeaders(tk.Canvas):
 
     def select_col(
         self,
-        c: int,
+        c: int | AnyIter[int],
         redraw: bool = False,
         run_binding_func: bool = True,
         ext: bool = False,
-    ) -> int:
+    ) -> int | list[int]:
         boxes_to_hide = tuple(self.MT.selection_boxes)
-        fill_iid = self.MT.create_selection_box(0, c, len(self.MT.row_positions) - 1, c + 1, "columns", ext=ext)
+        fill_iids = [
+            self.MT.create_selection_box(
+                0,
+                start,
+                len(self.MT.row_positions) - 1,
+                end,
+                "columns",
+                set_current=True,
+                ext=ext,
+            )
+            for start, end in consecutive_ranges(int_x_tuple(c))
+        ]
         for iid in boxes_to_hide:
             self.MT.hide_selection_box(iid)
         if redraw:
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         if run_binding_func:
             self.MT.run_selection_binding("columns")
-        return fill_iid
+        return fill_iids[0] if len(fill_iids) == 1 else fill_iids
 
     def add_selection(
         self,
@@ -1657,8 +1673,8 @@ class ColumnHeaders(tk.Canvas):
 
     def get_redraw_selections(self, startc: int, endc: int) -> dict[str, set[int]]:
         d = defaultdict(set)
-        for item, box in self.MT.get_selection_items():
-            r1, c1, r2, c2 = box.coords
+        for _, box in self.MT.get_selection_items():
+            _, c1, _, c2 = box.coords
             for c in range(startc, endc):
                 if c1 <= c and c2 > c:
                     d[box.type_ if box.type_ != "rows" else "cells"].add(c)
@@ -1674,7 +1690,7 @@ class ColumnHeaders(tk.Canvas):
         if self.get_cell_kwargs(datacn, key="readonly"):
             return
         elif self.get_cell_kwargs(datacn, key="dropdown") or self.get_cell_kwargs(datacn, key="checkbox"):
-            if self.MT.event_opens_dropdown_or_checkbox(event):
+            if event_opens_dropdown_or_checkbox(event):
                 if self.get_cell_kwargs(datacn, key="dropdown"):
                     self.open_dropdown_window(c, event=event)
                 elif self.get_cell_kwargs(datacn, key="checkbox"):
@@ -1700,28 +1716,16 @@ class ColumnHeaders(tk.Canvas):
         state: str = "normal",
         dropdown: bool = False,
     ) -> bool:
-        text = None
+        text = f"{self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)}"
         extra_func_key = "??"
-        if event is None or self.MT.event_opens_dropdown_or_checkbox(event):
-            if event is not None:
-                if hasattr(event, "keysym") and event.keysym == "Return":
-                    extra_func_key = "Return"
-                elif hasattr(event, "keysym") and event.keysym == "F2":
-                    extra_func_key = "F2"
-            text = self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)
-        elif event is not None and (
-            (hasattr(event, "keysym") and event.keysym == "BackSpace") or event.keycode in (8, 855638143)
-        ):
-            extra_func_key = "BackSpace"
-            text = ""
-        elif event is not None and (
-            (hasattr(event, "char") and event.char.isalpha())
-            or (hasattr(event, "char") and event.char.isdigit())
-            or (hasattr(event, "char") and event.char in symbols_set)
-        ):
-            extra_func_key = event.char
-            text = event.char
-        else:
+        if event_opens_dropdown_or_checkbox(event):
+            if hasattr(event, "keysym") and event.keysym in ("Return", "F2", "BackSpace"):
+                extra_func_key = event.keysym
+                if event.keysym == "BackSpace":
+                    text = ""
+        elif event_has_char_key(event):
+            extra_func_key = text = event.char
+        elif event is not None:
             return False
         if self.extra_begin_edit_cell_func:
             try:
@@ -1743,14 +1747,13 @@ class ColumnHeaders(tk.Canvas):
                 return False
             else:
                 text = text if isinstance(text, str) else f"{text}"
-        text = "" if text is None else text
         if self.PAR.ops.cell_auto_resize_enabled:
             if self.height_resizing_enabled:
                 self.set_height_of_header_to_text(text)
             self.set_col_width_run_binding(c)
         if self.text_editor.open and c == self.text_editor.column:
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
-            return
+            return False
         self.hide_text_editor()
         if not self.MT.see(r=0, c=c, keep_yscroll=True, check_cell_visibility=True):
             self.MT.refresh()
@@ -1758,8 +1761,6 @@ class ColumnHeaders(tk.Canvas):
         y = 0
         w = self.MT.col_positions[c + 1] - x
         h = self.current_height + 1
-        if text is None:
-            text = self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)
         kwargs = {
             "menu_kwargs": DotDict(
                 {

tksheet/find_window.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import tkinter as tk
+from collections.abc import (
+    Callable,
+)
+from typing import Literal
+
+from .other_classes import (
+    DotDict,
+)
+from .constants import (
+    ctrl_key,
+    rc_binding,
+)
+from .functions import (
+    recursive_bind,
+)
+
+
+class FindWindowTkText(tk.Text):
+    def __init__(
+        self,
+        parent: tk.Misc,
+    ) -> None:
+        super().__init__(
+            parent,
+            spacing1=0,
+            spacing2=1,
+            spacing3=0,
+            bd=0,
+            highlightthickness=0,
+            undo=True,
+            maxundo=30,
+        )
+        self.parent = parent
+        self.rc_popup_menu = tk.Menu(self, tearoff=0)
+        self.bind("<1>", lambda event: self.focus_set())
+        self.bind(rc_binding, self.rc)
+        self.bind(f"<{ctrl_key}-a>", self.select_all)
+        self.bind(f"<{ctrl_key}-A>", self.select_all)
+        self.bind("<Delete>", self.delete_key)
+
+    def reset(
+        self,
+        menu_kwargs: dict,
+        sheet_ops: dict,
+        font: tuple,
+        bg: str,
+        fg: str,
+        select_bg: str,
+        select_fg: str,
+    ) -> None:
+        self.config(
+            font=font,
+            background=bg,
+            foreground=fg,
+            insertbackground=fg,
+            selectbackground=select_bg,
+            selectforeground=select_fg,
+        )
+        self.editor_del_key = sheet_ops.editor_del_key
+        self.rc_popup_menu.delete(0, "end")
+        self.rc_popup_menu.add_command(
+            label=sheet_ops.select_all_label,
+            accelerator=sheet_ops.select_all_accelerator,
+            command=self.select_all,
+            **menu_kwargs,
+        )
+        self.rc_popup_menu.add_command(
+            label=sheet_ops.cut_label,
+            accelerator=sheet_ops.cut_accelerator,
+            command=self.cut,
+            **menu_kwargs,
+        )
+        self.rc_popup_menu.add_command(
+            label=sheet_ops.copy_label,
+            accelerator=sheet_ops.copy_accelerator,
+            command=self.copy,
+            **menu_kwargs,
+        )
+        self.rc_popup_menu.add_command(
+            label=sheet_ops.paste_label,
+            accelerator=sheet_ops.paste_accelerator,
+            command=self.paste,
+            **menu_kwargs,
+        )
+        self.rc_popup_menu.add_command(
+            label=sheet_ops.undo_label,
+            accelerator=sheet_ops.undo_accelerator,
+            command=self.undo,
+            **menu_kwargs,
+        )
+
+    def rc(self, event: object) -> None:
+        self.focus_set()
+        self.rc_popup_menu.tk_popup(event.x_root, event.y_root)
+
+    def delete_key(self, event: object = None) -> None:
+        if self.editor_del_key == "forward":
+            return
+        elif not self.editor_del_key:
+            return "break"
+        elif self.editor_del_key == "backward":
+            if self.tag_ranges("sel"):
+                return
+            if self.index("insert") == "1.0":
+                return "break"
+            self.delete("insert-1c")
+            return "break"
+
+    def select_all(self, event: object = None) -> Literal["break"]:
+        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: object = None) -> Literal["break"]:
+        self.event_generate(f"<{ctrl_key}-x>")
+        self.event_generate("<KeyRelease>")
+        return "break"
+
+    def copy(self, event: object = None) -> Literal["break"]:
+        self.event_generate(f"<{ctrl_key}-c>")
+        return "break"
+
+    def paste(self, event: object = None) -> Literal["break"]:
+        self.event_generate(f"<{ctrl_key}-v>")
+        self.event_generate("<KeyRelease>")
+        return "break"
+
+    def undo(self, event: object = None) -> Literal["break"]:
+        self.event_generate(f"<{ctrl_key}-z>")
+        self.event_generate("<KeyRelease>")
+        return "break"
+
+
+class FindWindow(tk.Frame):
+    def __init__(
+        self,
+        parent: tk.Misc,
+        find_next_func: Callable,
+        find_prev_func: Callable,
+        close_func: Callable,
+    ) -> None:
+        super().__init__(
+            parent,
+            width=0,
+            height=0,
+            bd=0,
+        )
+        self.grid_columnconfigure(0, weight=1)
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_propagate(False)
+        self.parent = parent
+        self.tktext = FindWindowTkText(self)
+        self.tktext.grid(row=0, column=0, sticky="nswe")
+        self.bg = None
+        self.fg = None
+
+        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_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_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.close = tk.Label(self, text="✕", cursor="hand2", highlightthickness=1)
+        self.close.bind("<Button-1>", close_func)
+        self.close.grid(row=0, column=4)
+
+        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))
+
+        for b in ("Option", "Alt"):
+            for c in ("l", "L"):
+                recursive_bind(self, f"<{b}-{c}>", self.toggle_in_selection)
+
+    def enter_label(self, widget: tk.Misc) -> 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,
+        )
+
+    def toggle_in_selection(self, event: tk.Misc) -> None:
+        self.find_in_selection = not self.find_in_selection
+        self.enter_label(self.in_selection)
+        self.leave_label(self.in_selection)
+
+    def get(self) -> str:
+        return self.tktext.get("1.0", "end-1c")
+
+    def get_num_lines(self) -> int:
+        return int(self.tktext.index("end-1c").split(".")[0])
+
+    def set_text(self, text: str = "") -> None:
+        self.tktext.delete(1.0, "end")
+        self.tktext.insert(1.0, text)
+
+    def reset(
+        self,
+        border_color: str,
+        menu_kwargs: DotDict,
+        sheet_ops: DotDict,
+        bg: str,
+        fg: str,
+        select_bg: str,
+        select_fg: str,
+    ) -> None:
+        self.bg = bg
+        self.fg = fg
+        self.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):
+            widget.config(
+                font=menu_kwargs.font,
+                bg=bg,
+                fg=fg,
+                highlightbackground=bg,
+                highlightcolor=fg,
+            )
+        if self.find_in_selection:
+            self.enter_label(self.in_selection)
+        self.config(
+            background=bg,
+            highlightbackground=border_color,
+            highlightcolor=border_color,
+            highlightthickness=1,
+        )

tksheet/formatters.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 
-from .vars import falsy, nonelike, truthy
+from .constants import falsy, nonelike, truthy
 
 
 def is_none_like(o: object) -> bool:

tksheet/functions.py

@@ -12,6 +12,8 @@ from collections import deque
 from collections.abc import (
     Callable,
     Generator,
+    Hashable,
+    Iterable,
     Iterator,
     Sequence,
 )
@@ -30,6 +32,12 @@ from .other_classes import (
     Loc,
     Span,
 )
+from .types import (
+    AnyIter,
+)
+from .constants import (
+    symbols_set,
+)
 
 unpickle_obj = pickle.loads
 
@@ -62,9 +70,15 @@ def get_data_from_clipboard(
     return [[data]]
 
 
+def recursive_bind(widget: tk.Misc, event: str, callback: Callable) -> None:
+    widget.bind(event, callback)
+    for child in widget.winfo_children():
+        recursive_bind(child, event, callback)
+
+
 def tksheet_type_error(kwarg: str, valid_types: list[str], not_type: object) -> str:
     valid_types = ", ".join(f"{type_}" for type_ in valid_types)
-    return f"Argument '{kwarg}' must be one of the following types: {valid_types}, " f"not {type(not_type)}."
+    return f"Argument '{kwarg}' must be one of the following types: {valid_types}, not {type(not_type)}."
 
 
 def new_tk_event(keysym: str) -> tk.Event:
@@ -73,6 +87,25 @@ def new_tk_event(keysym: str) -> tk.Event:
     return event
 
 
+def event_has_char_key(event: object) -> bool:
+    return (
+        event and hasattr(event, "char") and (event.char.isalpha() or event.char.isdigit() or event.char in symbols_set)
+    )
+
+
+def event_opens_dropdown_or_checkbox(event=None) -> bool:
+    if event is None:
+        return False
+    elif event == "rc":
+        return True
+    return (
+        (hasattr(event, "keysym") and event.keysym in {"Return", "F2", "BackSpace"})
+        or (
+            hasattr(event, "keycode") and event.keycode == "??" and hasattr(event, "num") and event.num == 1
+        )  # mouseclick
+    )
+
+
 def dropdown_search_function(
     search_for: object,
     data: Sequence[object],
@@ -225,6 +258,16 @@ def b_index(sorted_seq: Sequence[int], num_to_index: int) -> int:
     return idx
 
 
+def bisect_in(sorted_seq: Sequence[int], num: int) -> bool:
+    """
+    Faster than 'num in sorted_seq'
+    """
+    try:
+        return sorted_seq[bisect_left(sorted_seq, num)] == num
+    except Exception:
+        return False
+
+
 def get_dropdown_kwargs(
     values: list = [],
     set_value: object = None,
@@ -295,13 +338,19 @@ def is_iterable(o: object) -> bool:
         return False
 
 
-def int_x_iter(i: Iterator[int] | int) -> Iterator[int]:
+def int_x_iter(i: AnyIter[int] | int) -> AnyIter[int]:
     if isinstance(i, int):
         return (i,)
     return i
 
 
-def unpack(t: tuple[object] | tuple[Iterator[object]]) -> tuple[object]:
+def int_x_tuple(i: AnyIter[int] | int) -> tuple[int]:
+    if isinstance(i, int):
+        return (i,)
+    return tuple(i)
+
+
+def unpack(t: tuple[object] | tuple[AnyIter[object]]) -> tuple[object]:
     if not len(t):
         return t
     if is_iterable(t[0]) and len(t) == 1:
@@ -427,7 +476,7 @@ def consecutive_ranges(seq: Sequence[int]) -> Generator[tuple[int, int]]:
             yield seq[start], seq[-1] + 1
 
 
-def is_contiguous(iterable: Iterator[int]) -> bool:
+def is_contiguous(iterable: Iterable[int]) -> bool:
     itr = iter(iterable)
     prev = next(itr)
     return all(i == (prev := prev + 1) for i in itr)
@@ -500,7 +549,7 @@ def cell_right_within_box(
 
 
 def get_last(
-    it: Iterator,
+    it: AnyIter[object],
 ) -> object:
     if hasattr(it, "__reversed__"):
         try:
@@ -522,7 +571,7 @@ def index_exists(seq: Sequence[object], index: int) -> bool:
         return False
 
 
-def add_to_displayed(displayed: list[int], to_add: Iterator[int]) -> list[int]:
+def add_to_displayed(displayed: list[int], to_add: Iterable[int]) -> list[int]:
     # assumes to_add is sorted in reverse
     for i in reversed(to_add):
         ins = bisect_left(displayed, i)
@@ -535,35 +584,23 @@ def move_elements_by_mapping(
     new_idxs: dict[int, int],
     old_idxs: dict[int, int] | None = None,
 ) -> list[object]:
-    # move elements of a list around, displacing
-    # other elements based on mapping
-    # of {old index: new index, ...}
+    # move elements of a list around
+    # displacing other elements based on mapping
+    # new_idxs = {old index: new index, ...}
+    # old_idxs = {new index: old index, ...}
     if old_idxs is None:
         old_idxs = dict(zip(new_idxs.values(), new_idxs))
 
-    # create dummy list
     res = [0] * len(seq)
 
-    # create generator of values yet to be put into res
-    remaining = (e for i, e in enumerate(seq) if i not in new_idxs)
+    remaining_values = (e for i, e in enumerate(seq) if i not in new_idxs)
+    for i in range(len(res)):
+        if i in old_idxs:
+            res[i] = seq[old_idxs[i]]
+        else:
+            res[i] = next(remaining_values)
 
-    # goes over res twice:
-    # once to put elements being moved in new spots
-    # then to fill remaining spots with remaining elements
-
-    # fill new indexes in res
-    if len(new_idxs) > int(len(seq) / 2) - 1:
-        # if moving a lot of items better to do comprehension
-        return [
-            next(remaining) if i_ not in old_idxs else e_
-            for i_, e_ in enumerate(seq[old_idxs[i]] if i in old_idxs else e for i, e in enumerate(res))
-        ]
-    else:
-        # if just moving a few items assignments are fine
-        for old, new in new_idxs.items():
-            res[new] = seq[old]
-        # fill remaining indexes
-        return [next(remaining) if i not in old_idxs else e for i, e in enumerate(res)]
+    return res
 
 
 def move_elements_to(
@@ -598,23 +635,15 @@ def get_new_indexes(
 
 
 def insert_items(
-    seq: list[object] | tuple[object],
+    seq: list[object],
     to_insert: dict[int, object],
     seq_len_func: Callable | None = None,
-) -> list:
-    # inserts many items into a list using a dict of reverse sorted order of
-    # {index: value, index: value, ...}
-    res = []
-    extended = 0
-    for i, (idx, v) in enumerate(reversed(to_insert.items())):
-        # need to extend seq if it's not long enough
-        if seq_len_func and idx - i > len(seq):
-            seq_len_func(idx - i - 1)
-        res.extend(seq[extended : idx - i])
-        extended += idx - i - extended
-        res.append(v)
-    res.extend(seq[extended:])
-    seq = res
+) -> list[object]:
+    if to_insert:
+        if seq_len_func and next(iter(to_insert)) >= len(seq) + len(to_insert):
+            seq_len_func(next(iter(to_insert)) - len(to_insert))
+        for idx, v in reversed(to_insert.items()):
+            seq[idx:idx] = [v]
     return seq
 
 
@@ -622,8 +651,7 @@ def data_to_displayed_idxs(
     to_convert: list[int],
     displayed: list[int],
 ) -> list[int]:
-    data_indexes = set(to_convert)
-    return [i for i, e in enumerate(displayed) if e in data_indexes]
+    return [i for i, e in enumerate(displayed) if bisect_in(to_convert, e)]
 
 
 def displayed_to_data_idxs(
@@ -640,6 +668,8 @@ def rounded_box_coords(
     y2: float,
     radius: int = 5,
 ) -> tuple[float]:
+    if y2 - y1 < 2 or x2 - x1 < 2:
+        return x1, y1, x2, y1, x2, y2, x1, y2
     return (
         x1 + radius,
         y1,
@@ -704,7 +734,7 @@ def diff_gen(seq: list[float]) -> Generator[int]:
     )
 
 
-def zip_fill_2nd_value(x: Iterator, o: object) -> Generator[object, object]:
+def zip_fill_2nd_value(x: AnyIter[object], o: object) -> Generator[object, object]:
     return zip(x, repeat(o))
 
 
@@ -1233,13 +1263,13 @@ def span_froms(
     return from_r, from_c
 
 
-def del_named_span_options(options: dict, itr: Iterator, type_: str) -> None:
+def del_named_span_options(options: dict, itr: AnyIter[Hashable], type_: str) -> None:
     for k in itr:
         if k in options and type_ in options[k]:
             del options[k][type_]
 
 
-def del_named_span_options_nested(options: dict, itr1: Iterator, itr2: Iterator, type_: str) -> None:
+def del_named_span_options_nested(options: dict, itr1: AnyIter[Hashable], itr2: AnyIter[Hashable], type_: str) -> None:
     for k1 in itr1:
         for k2 in itr2:
             k = (k1, k2)
@@ -1320,7 +1350,7 @@ def set_align(
 def del_from_options(
     options: dict,
     key: str,
-    coords: int | Iterator | None = None,
+    coords: int | AnyIter[int | tuple[int, int]] | None = None,
 ) -> dict:
     if isinstance(coords, int):
         if coords in options and key in options[coords]: