tksheet 7.1.6__py3-none-any.whl → 7.1.8__py3-none-any.whl

tksheet/__init__.py

@@ -1,96 +1,97 @@
-# ruff: noqa: F401
-
-"""
-tksheet - A Python tkinter table widget
-"""
-
-__version__ = "7.1.6"
-
-from .colors import (
-    color_map,
-)
-from .column_headers import ColumnHeaders
-from .formatters import (
-    Formatter,
-    bool_formatter,
-    data_to_str,
-    float_formatter,
-    float_to_str,
-    format_data,
-    formatter,
-    get_clipboard_data,
-    get_data_with_valid_check,
-    int_formatter,
-    is_bool_like,
-    is_none_like,
-    percentage_formatter,
-    percentage_to_str,
-    to_bool,
-    to_float,
-    to_int,
-    to_str,
-    try_to_bool,
-)
-from .functions import (
-    alpha2idx,
-    alpha2num,
-    consecutive_chunks,
-    data_to_displayed_idxs,
-    displayed_to_data_idxs,
-    dropdown_search_function,
-    event_dict,
-    get_checkbox_dict,
-    get_checkbox_kwargs,
-    get_checkbox_points,
-    get_dropdown_dict,
-    get_dropdown_kwargs,
-    get_index_of_gap_in_sorted_integer_seq_forward,
-    get_index_of_gap_in_sorted_integer_seq_reverse,
-    get_n2a,
-    get_new_indexes,
-    get_seq_without_gaps_at_index,
-    is_iterable,
-    move_elements_by_mapping,
-    move_elements_to,
-    num2alpha,
-    span_dict,
-    tksheet_type_error,
-)
-from .main_table import MainTable
-from .other_classes import (
-    DotDict,
-    DraggedRowColumn,
-    DrawnItem,
-    EventDataDict,
-    GeneratedMouseEvent,
-    Selected,
-    Span,
-    SpanRange,
-    TextCfg,
-)
-from .row_index import RowIndex
-from .sheet import Dropdown, Sheet
-from .sheet_options import new_sheet_options
-from .text_editor import (
-    TextEditor,
-    TextEditorTkText,
-)
-from .themes import (
-    theme_black,
-    theme_dark,
-    theme_dark_blue,
-    theme_dark_green,
-    theme_light_blue,
-    theme_light_green,
-)
-from .top_left_rectangle import TopLeftRectangle
-from .vars import (
-    USER_OS,
-    ctrl_key,
-    emitted_events,
-    falsy,
-    nonelike,
-    rc_binding,
-    symbols_set,
-    truthy,
-)
+# ruff: noqa: F401
+
+"""
+tksheet - A Python tkinter table widget
+"""
+
+__version__ = "7.1.8"
+
+from .colors import (
+    color_map,
+)
+from .column_headers import ColumnHeaders
+from .formatters import (
+    Formatter,
+    bool_formatter,
+    data_to_str,
+    float_formatter,
+    float_to_str,
+    format_data,
+    formatter,
+    get_clipboard_data,
+    get_data_with_valid_check,
+    int_formatter,
+    is_bool_like,
+    is_none_like,
+    percentage_formatter,
+    percentage_to_str,
+    to_bool,
+    to_float,
+    to_int,
+    to_str,
+    try_to_bool,
+)
+from .functions import (
+    alpha2idx,
+    alpha2num,
+    consecutive_chunks,
+    consecutive_ranges,
+    data_to_displayed_idxs,
+    displayed_to_data_idxs,
+    dropdown_search_function,
+    event_dict,
+    get_checkbox_dict,
+    get_checkbox_kwargs,
+    get_dropdown_dict,
+    get_dropdown_kwargs,
+    get_index_of_gap_in_sorted_integer_seq_forward,
+    get_index_of_gap_in_sorted_integer_seq_reverse,
+    get_n2a,
+    get_new_indexes,
+    get_seq_without_gaps_at_index,
+    is_iterable,
+    move_elements_by_mapping,
+    move_elements_to,
+    num2alpha,
+    rounded_box_coords,
+    span_dict,
+    tksheet_type_error,
+)
+from .main_table import MainTable
+from .other_classes import (
+    DotDict,
+    DraggedRowColumn,
+    DrawnItem,
+    EventDataDict,
+    GeneratedMouseEvent,
+    Selected,
+    Span,
+    SpanRange,
+    TextCfg,
+)
+from .row_index import RowIndex
+from .sheet import Dropdown, Sheet
+from .sheet_options import new_sheet_options
+from .text_editor import (
+    TextEditor,
+    TextEditorTkText,
+)
+from .themes import (
+    theme_black,
+    theme_dark,
+    theme_dark_blue,
+    theme_dark_green,
+    theme_light_blue,
+    theme_light_green,
+)
+from .top_left_rectangle import TopLeftRectangle
+from .vars import (
+    USER_OS,
+    ctrl_key,
+    emitted_events,
+    falsy,
+    nonelike,
+    rc_binding,
+    symbols_set,
+    truthy,
+)

tksheet/column_headers.py

@@ -23,9 +23,9 @@ from .functions import (
     consecutive_ranges,
     ev_stack_dict,
     event_dict,
-    get_checkbox_points,
     get_n2a,
     is_contiguous,
+    rounded_box_coords,
     try_binding,
 )
 from .other_classes import (
@@ -41,6 +41,7 @@ from .vars import (
     USER_OS,
     rc_binding,
     symbols_set,
+    text_editor_to_unbind,
 )
 
 
@@ -935,14 +936,26 @@ class ColumnHeaders(tk.Canvas):
         outline: str,
         state: str,
         tags: str | tuple[str],
+        iid: None | int = None,
     ) -> int:
-        if self.hidd_boxes:
-            iid = self.hidd_boxes.pop()
-            self.coords(iid, x1, y1, x2, y2)
+        coords = rounded_box_coords(
+            x1,
+            y1,
+            x2,
+            y2,
+            radius=8 if self.PAR.ops.rounded_boxes else 0,
+        )
+        if isinstance(iid, int):
+            self.coords(iid, coords)
             self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
         else:
-            iid = self.create_rectangle(x1, y1, x2, y2, fill=fill, outline=outline, state=state, tags=tags)
-        self.disp_boxes.add(iid)
+            if self.hidd_boxes:
+                iid = self.hidd_boxes.pop()
+                self.coords(iid, coords)
+                self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
+            else:
+                iid = self.create_polygon(coords, fill=fill, outline=outline, state=state, tags=tags, smooth=True)
+            self.disp_boxes.add(iid)
         return iid
 
     def hide_box(self, item: int) -> None:
@@ -1276,7 +1289,7 @@ class ColumnHeaders(tk.Canvas):
             self.disp_dropdown[t] = True
 
     def redraw_checkbox(self, x1, y1, x2, y2, fill, outline, tag, draw_check=False):
-        points = get_checkbox_points(x1, y1, x2, y2)
+        points = rounded_box_coords(x1, y1, x2, y2)
         if self.hidd_checkbox:
             t, sh = self.hidd_checkbox.popitem()
             self.coords(t, points)
@@ -1294,7 +1307,7 @@ class ColumnHeaders(tk.Canvas):
             y1 = y1 + 4
             x2 = x2 - 3
             y2 = y2 - 3
-            points = get_checkbox_points(x1, y1, x2, y2, radius=4)
+            points = rounded_box_coords(x1, y1, x2, y2, radius=4)
             if self.hidd_checkbox:
                 t, sh = self.hidd_checkbox.popitem()
                 self.coords(t, points)
@@ -1574,16 +1587,14 @@ class ColumnHeaders(tk.Canvas):
                     dct[iid] = False
         return True
 
-    def get_redraw_selections(self, startc, endc):
-        d = defaultdict(list)
+    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(rows=False):
-            d[box.type_].append(box.coords)
-        d2 = {}
-        if "cells" in d:
-            d2["cells"] = {c for c in range(startc, endc) for r1, c1, r2, c2 in d["cells"] if c1 <= c and c2 > c}
-        if "columns" in d:
-            d2["columns"] = {c for c in range(startc, endc) for r1, c1, r2, c2 in d["columns"] if c1 <= c and c2 > c}
-        return d2
+            r1, c1, r2, c2 = box.coords
+            for c in range(startc, endc):
+                if c1 <= c and c2 > c:
+                    d[box.type_].add(c)
+        return d
 
     def open_cell(self, event: object = None, ignore_existing_editor=False):
         if not self.MT.anything_selected() or (not ignore_existing_editor and self.text_editor.open):
@@ -1653,6 +1664,7 @@ class ColumnHeaders(tk.Canvas):
                         key=extra_func_key,
                         value=text,
                         loc=c,
+                        column=c,
                         boxes=self.MT.get_boxes(),
                         selected=self.MT.selected,
                     )
@@ -1716,12 +1728,14 @@ class ColumnHeaders(tk.Canvas):
             self.text_editor.tktext.focus_set()
             self.text_editor.window.scroll_to_bottom()
         self.text_editor.tktext.bind("<Alt-Return>", lambda _x: self.text_editor_newline_binding(c=c))
+        self.text_editor.tktext.bind("<Alt-KP_Enter>", lambda _x: self.text_editor_newline_binding(c=c))
         if USER_OS == "darwin":
             self.text_editor.tktext.bind("<Option-Return>", lambda _x: self.text_editor_newline_binding(c=c))
         for key, func in self.MT.text_editor_user_bound_keys.items():
             self.text_editor.tktext.bind(key, func)
         self.text_editor.tktext.bind("<Tab>", lambda _x: self.close_text_editor((c, "Tab")))
         self.text_editor.tktext.bind("<Return>", lambda _x: self.close_text_editor((c, "Return")))
+        self.text_editor.tktext.bind("<KP_Enter>", lambda _x: self.close_text_editor((c, "Return")))
         if not dropdown:
             self.text_editor.tktext.bind("<FocusOut>", lambda _x: self.close_text_editor((c, "FocusOut")))
         self.text_editor.tktext.bind("<Escape>", lambda _x: self.close_text_editor((c, "Escape")))
@@ -1817,6 +1831,8 @@ class ColumnHeaders(tk.Canvas):
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
+            for binding in text_editor_to_unbind:
+                self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -1840,7 +1856,7 @@ class ColumnHeaders(tk.Canvas):
             self.hide_text_editor_and_dropdown()
             return
         # setting cell data with text editor value
-        self.text_editor_value = self.text_editor.get()
+        text_editor_value = self.text_editor.get()
         c = editor_info[0]
         datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
         event_data = event_dict(
@@ -1848,8 +1864,9 @@ class ColumnHeaders(tk.Canvas):
             sheet=self.PAR.name,
             cells_header={datacn: self.get_cell_data(datacn)},
             key=editor_info[1] if len(editor_info) >= 2 else "FocusOut",
-            value=self.text_editor_value,
+            value=text_editor_value,
             loc=c,
+            column=c,
             boxes=self.MT.get_boxes(),
             selected=self.MT.selected,
         )
@@ -1861,11 +1878,11 @@ class ColumnHeaders(tk.Canvas):
             check_input_valid=False,
         )
         if self.MT.edit_validation_func:
-            self.text_editor_value = self.MT.edit_validation_func(event_data)
-            if self.text_editor_value is not None and self.input_valid_for_cell(datacn, self.text_editor_value):
-                edited = set_data(value=self.text_editor_value)
-        elif self.input_valid_for_cell(datacn, self.text_editor_value):
-            edited = set_data(value=self.text_editor_value)
+            text_editor_value = self.MT.edit_validation_func(event_data)
+            if text_editor_value is not None and self.input_valid_for_cell(datacn, text_editor_value):
+                edited = set_data(value=text_editor_value)
+        elif self.input_valid_for_cell(datacn, text_editor_value):
+            edited = set_data(value=text_editor_value)
         if edited:
             try_binding(self.extra_end_edit_cell_func, event_data)
         self.MT.recreate_all_selection_boxes()
@@ -1958,6 +1975,7 @@ class ColumnHeaders(tk.Canvas):
                         sheet=self.PAR.name,
                         value=self.text_editor.get(),
                         loc=c,
+                        column=c,
                         boxes=self.MT.get_boxes(),
                         selected=self.MT.selected,
                     ),
@@ -1993,6 +2011,7 @@ class ColumnHeaders(tk.Canvas):
                 key="??",
                 value=selection,
                 loc=c,
+                column=c,
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )
@@ -2037,6 +2056,7 @@ class ColumnHeaders(tk.Canvas):
 
     def hide_dropdown_window(self) -> None:
         if self.dropdown.open:
+            self.dropdown.window.unbind("<FocusOut>")
             self.itemconfig(self.dropdown.canvas_id, state="hidden")
             self.dropdown.open = False
 
@@ -2217,6 +2237,7 @@ class ColumnHeaders(tk.Canvas):
                 key="??",
                 value=value,
                 loc=c,
+                column=c,
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )

tksheet/functions.py

@@ -102,6 +102,8 @@ def event_dict(
     key: None | str = None,
     value: object = None,
     loc: None | int | tuple[int] = None,
+    row: None | int = None,
+    column: None | int = None,
     resized_rows: None | dict = None,
     resized_columns: None | dict = None,
     # resized_index: None, dict] = None,
@@ -147,6 +149,8 @@ def event_dict(
         key="" if key is None else key,
         value=None if value is None else value,
         loc=tuple() if loc is None else loc,
+        row=row,
+        column=column,
         resized=DotDict(
             rows=DotDict() if resized_rows is None else resized_rows,
             columns=DotDict() if resized_columns is None else resized_columns,
@@ -356,7 +360,7 @@ def consecutive_chunks(seq: list[int]) -> Generator[list[int]]:
     for index, value in enumerate(seq, 1):
         try:
             if seq[index] > value + 1:
-                yield seq[start:(start := index)]
+                yield seq[start : (start := index)]
         except Exception:
             yield seq[start : len(seq)]
 
@@ -403,8 +407,8 @@ def index_exists(seq: Sequence[object], index: int) -> bool:
 
 def move_elements_by_mapping(
     seq: list[object],
-    new_idxs: dict,
-    old_idxs: dict,
+    new_idxs: dict[int, int],
+    old_idxs: dict[int, int],
 ) -> list[object]:
     # move elements of a list around, displacing
     # other elements based on mapping
@@ -472,8 +476,7 @@ def get_new_indexes(
 
 
 def insert_items(seq: list | tuple, to_insert: dict, seq_len_func: Callable | None = None) -> list:
-    # faster method of inserting many items into a list
-    # using a dict of reverse sorted order of
+    # inserts many items into a list using a dict of reverse sorted order of
     # {index: value, index: value, ...}
     res = []
     extended = 0
@@ -504,14 +507,14 @@ def displayed_to_data_idxs(
     return [displayed[e] for e in to_convert]
 
 
-def get_checkbox_points(
+def rounded_box_coords(
     x1: float,
     y1: float,
     x2: float,
     y2: float,
     radius: int = 8,
-) -> list[float]:
-    return [
+) -> tuple[float]:
+    return (
         x1 + radius,
         y1,
         x1 + radius,
@@ -552,7 +555,7 @@ def get_checkbox_points(
         y1 + radius,
         x1,
         y1,
-    ]
+    )
 
 
 def diff_list(seq: list[float]) -> list[int]: