tksheet 7.1.5__py3-none-any.whl → 7.1.7__py3-none-any.whl

tksheet/__init__.py

@@ -1,96 +1,99 @@
-# ruff: noqa: F401
-
-"""
-tksheet - A Python tkinter table widget
-"""
-
-__version__ = "7.1.5"
-
-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.7"
+
+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,
+    rounded_box_coords,
+    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 .listbox import (
+    ListBox,
+)
+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

@@ -13,16 +13,17 @@ from itertools import (
     islice,
 )
 from math import ceil, floor
+from typing import Literal
 
 from .colors import (
     color_map,
 )
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
-    consecutive_chunks,
+    consecutive_ranges,
     ev_stack_dict,
     event_dict,
-    get_checkbox_points,
+    rounded_box_coords,
     get_n2a,
     is_contiguous,
     try_binding,
@@ -687,10 +688,10 @@ class ColumnHeaders(tk.Canvas):
             tag="move_columns",
         )
         self.MT.create_resize_line(xpos, y1, xpos, y2, width=3, fill=self.PAR.ops.drag_and_drop_bg, tag="move_columns")
-        for chunk in consecutive_chunks(cols):
+        for boxst, boxend in consecutive_ranges(cols):
             self.MT.show_ctrl_outline(
-                start_cell=(chunk[0], 0),
-                end_cell=(chunk[-1] + 1, len(self.MT.row_positions) - 1),
+                start_cell=(boxst, 0),
+                end_cell=(boxend, len(self.MT.row_positions) - 1),
                 dash=(),
                 outline=self.PAR.ops.drag_and_drop_bg,
                 delete_on_timer=False,
@@ -934,14 +935,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=9 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:
@@ -1275,7 +1288,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)
@@ -1293,7 +1306,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)
@@ -1573,16 +1586,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):
@@ -1622,14 +1633,13 @@ class ColumnHeaders(tk.Canvas):
     ) -> bool:
         text = None
         extra_func_key = "??"
-        datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
         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(datacn, none_to_empty_str=True, redirect_int=True)
+            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)
         ):
@@ -1679,9 +1689,8 @@ class ColumnHeaders(tk.Canvas):
         y = 0
         w = self.MT.col_positions[c + 1] - x
         h = self.current_height + 1
-        datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
         if text is None:
-            text = self.get_cell_data(datacn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)
         bg, fg = self.PAR.ops.header_bg, self.PAR.ops.header_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -1754,7 +1763,7 @@ class ColumnHeaders(tk.Canvas):
             not check_lines
             or self.MT.get_lines_cell_height(
                 self.text_editor.window.get_num_lines() + 1,
-                font=self.PAR.ops.header_font,
+                font=self.text_editor.tktext.cget("font"),
             )
             > curr_height
         ):
@@ -1774,41 +1783,52 @@ class ColumnHeaders(tk.Canvas):
                     )
                     self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def refresh_open_window_positions(self):
+    def refresh_open_window_positions(self, zoom: Literal["in", "out"]):
         if self.text_editor.open:
             c = self.text_editor.column
-            self.text_editor.window.config(height=self.MT.col_positions[c + 1] - self.MT.col_positions[c])
+            self.text_editor.window.config(
+                height=self.current_height,
+                width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1,
+            )
+            self.text_editor.tktext.config(font=self.PAR.ops.header_font)
             self.coords(
                 self.text_editor.canvas_id,
-                0,
                 self.MT.col_positions[c],
+                0,
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             c = self.dropdown.get_coords()
             if self.text_editor.open:
                 text_editor_h = self.text_editor.window.winfo_height()
                 win_h, anchor = self.get_dropdown_height_anchor(c, text_editor_h)
             else:
-                text_editor_h = self.MT.col_positions[c + 1] - self.MT.col_positions[c]
+                text_editor_h = self.current_height
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
-                    0,
-                    self.MT.col_positions[c] + text_editor_h - 1,
+                    self.MT.col_positions[c],
+                    text_editor_h - 1,
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
             elif anchor == "sw":
                 self.coords(
                     self.dropdown.canvas_id,
-                    0,
                     self.MT.col_positions[c],
+                    0,
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
+            for b in ("<Alt-Return>", "<Option-Return>", "<Tab>", "<Return>", "<FocusOut>", "<Escape>"):
+                self.text_editor.tktext.unbind(b)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -1832,7 +1852,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(
@@ -1840,7 +1860,7 @@ 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,
             boxes=self.MT.get_boxes(),
             selected=self.MT.selected,
@@ -1853,11 +1873,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()
@@ -1901,11 +1921,9 @@ class ColumnHeaders(tk.Canvas):
             modified_func(event)
         dd_window.search_and_see(event)
 
-    def open_dropdown_window(self, c, datacn=None, event: object = None):
+    def open_dropdown_window(self, c, event: object = None):
         self.hide_text_editor("Escape")
-        if datacn is None:
-            datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown")
+        kwargs = self.get_cell_kwargs(self.MT.datacn(c), key="dropdown")
         if kwargs["state"] == "normal":
             if not self.open_text_editor(event=event, c=c, dropdown=True):
                 return
@@ -2031,6 +2049,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
 

tksheet/functions.py

@@ -245,6 +245,12 @@ def is_iterable(o: object) -> bool:
         return False
 
 
+def int_x_iter(i: Iterator[int] | int) -> Iterator[int]:
+    if isinstance(i, int):
+        return (i,)
+    return i
+
+
 def unpack(t: tuple[object] | tuple[Iterator[object]]) -> tuple[object]:
     if not len(t):
         return t
@@ -345,21 +351,27 @@ def get_seq_without_gaps_at_index(
     return seq
 
 
-def consecutive_chunks(seq: list[object]) -> Generator[object]:
-    if not seq:
-        yield seq
+def consecutive_chunks(seq: list[int]) -> Generator[list[int]]:
     start = 0
-    end = 0
-    for index, value in enumerate(seq):
-        if index < len(seq) - 1:
-            if seq[index + 1] > value + 1:
-                end = index + 1
-                yield seq[start:end]
-                start = end
-        else:
+    for index, value in enumerate(seq, 1):
+        try:
+            if seq[index] > value + 1:
+                yield seq[start : (start := index)]
+        except Exception:
             yield seq[start : len(seq)]
 
 
+def consecutive_ranges(seq: Sequence[int]) -> Generator[tuple[int, int]]:
+    start = 0
+    for index, value in enumerate(seq, 1):
+        try:
+            if seq[index] > value + 1:
+                yield seq[start], seq[index - 1] + 1
+                start = index
+        except Exception:
+            yield seq[start], seq[-1] + 1
+
+
 def is_contiguous(seq: list[int]) -> bool:
     itr = iter(seq)
     prev = next(itr)
@@ -492,14 +504,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,
@@ -540,7 +552,7 @@ def get_checkbox_points(
         y1 + radius,
         x1,
         y1,
-    ]
+    )
 
 
 def diff_list(seq: list[float]) -> list[int]:

tksheet/listbox.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+import tkinter as tk
+# from collections.abc import Callable, Generator, Iterator, Sequence
+
+from .sheet import (
+    Sheet,
+)
+
+
+class ListBox(Sheet):
+    def __init__(
+        self,
+        parent: tk.Misc,
+    ) -> None:
+        Sheet.__init__(
+            self,
+            parent=parent,
+        )
+        self.parent = parent