tksheet 7.2.17__py3-none-any.whl → 7.2.19__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.2.17"
+__version__ = "7.2.19"
 
 from .colors import (
     color_map,

tksheet/column_headers.py

@@ -290,8 +290,7 @@ class ColumnHeaders(tk.Canvas):
 
     def shift_b1_press(self, event: object) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
-        x = event.x
-        c = self.MT.identify_col(x=x)
+        c = self.MT.identify_col(x=event.x)
         if (self.drag_and_drop_enabled or self.col_selection_enabled) and self.rsz_h is None and self.rsz_w is None:
             if c < len(self.MT.col_positions) - 1:
                 c_selected = self.MT.col_selected(c)
@@ -316,7 +315,7 @@ class ColumnHeaders(tk.Canvas):
                     )
 
     def get_shift_select_box(self, c: int, min_c: int) -> tuple[int, int, int, int, str]:
-        if c > min_c:
+        if c >= min_c:
             return 0, min_c, len(self.MT.row_positions) - 1, c + 1
         elif c < min_c:
             return 0, c, len(self.MT.row_positions) - 1, min_c + 1

tksheet/formatters.py

@@ -66,7 +66,7 @@ def to_str(o: object, **kwargs: dict) -> str:
     return f"{o}"
 
 
-def float_to_str(v: int | float, **kwargs: dict) -> str:
+def float_to_str(v: object, **kwargs: dict) -> str:
     if isinstance(v, float):
         if v.is_integer():
             return f"{int(v)}"
@@ -77,7 +77,7 @@ def float_to_str(v: int | float, **kwargs: dict) -> str:
     return f"{v}"
 
 
-def percentage_to_str(v: int | float, **kwargs: dict) -> str:
+def percentage_to_str(v: object, **kwargs: dict) -> str:
     if isinstance(v, (int, float)):
         x = v * 100
         if isinstance(x, float):
@@ -87,7 +87,8 @@ def percentage_to_str(v: int | float, **kwargs: dict) -> str:
                 if kwargs["decimals"]:
                     return f"{round(x, kwargs['decimals'])}%"
                 return f"{int(round(x, kwargs['decimals']))}%"
-    return f"{x}%"
+        return f"{x}%"
+    return f"{v}%"
 
 
 def bool_to_str(v: object, **kwargs: dict) -> str:

tksheet/functions.py

@@ -18,6 +18,7 @@ from collections.abc import (
 )
 from functools import partial
 from itertools import islice, repeat
+from typing import Literal
 
 from .formatters import (
     to_bool,
@@ -324,16 +325,11 @@ def force_bool(o: object) -> bool:
         return False
 
 
-def str_to_coords(s: str) -> None | tuple[int]:
-    s = s.split(":")
-
-
 def alpha2idx(a: str) -> int | None:
     try:
-        a = a.upper()
         n = 0
         orda = ord("A")
-        for c in a:
+        for c in a.upper():
             n = n * 26 + ord(c) - orda + 1
         return n - 1
     except Exception:
@@ -363,12 +359,15 @@ def idx_param_to_int(idx: str | int | None) -> int | None:
     return alpha2idx(idx)
 
 
-def get_n2a(n: int = 0, _type: str = "numbers") -> str:
+def get_n2a(n: int = 0, _type: Literal["letters", "numbers", "both"] | None = "numbers") -> str:
     if _type == "letters":
         return num2alpha(n)
     elif _type == "numbers":
         return f"{n + 1}"
-    return f"{num2alpha(n)} {n + 1}"
+    elif _type == "both":
+        return f"{num2alpha(n)} {n + 1}"
+    elif _type is None:
+        return ""
 
 
 def get_index_of_gap_in_sorted_integer_seq_forward(
@@ -514,6 +513,14 @@ def index_exists(seq: Sequence[object], index: int) -> bool:
         return False
 
 
+def add_to_displayed(displayed: list[int], to_add: Iterator[int]) -> list[int]:
+    # assumes to_add is sorted in reverse
+    for i in reversed(to_add):
+        ins = bisect_left(displayed, i)
+        displayed[ins:] = [i] + [e + 1 for e in islice(displayed, ins, None)]
+    return displayed
+
+
 def move_elements_by_mapping(
     seq: list[object],
     new_idxs: dict[int, int],
@@ -581,7 +588,11 @@ def get_new_indexes(
     return new_idxs
 
 
-def insert_items(seq: list | tuple, to_insert: dict, seq_len_func: Callable | None = None) -> list:
+def insert_items(
+    seq: list[object] | tuple[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 = []
@@ -1411,7 +1422,7 @@ def mod_event_val(
 
 
 def pop_positions(
-    itr: Iterator[int],
+    itr: Callable,
     to_pop: dict[int, int],  # displayed index: data index
     save_to: dict[int, int],
 ) -> Iterator[int]:

tksheet/main_table.py

@@ -49,7 +49,9 @@ from .formatters import (
     try_to_bool,
 )
 from .functions import (
+    add_to_displayed,
     b_index,
+    cell_right_within_box,
     consecutive_ranges,
     decompress_load,
     diff_gen,
@@ -73,7 +75,6 @@ from .functions import (
     new_tk_event,
     pickle_obj,
     pickled_event_dict,
-    cell_right_within_box,
     rounded_box_coords,
     span_idxs_post_move,
     try_binding,
@@ -125,6 +126,7 @@ class MainTable(tk.Canvas):
         self.PAR_height = 0
         self.scrollregion = tuple()
         self.current_cursor = ""
+        self.ctrl_b1_pressed = False
         self.b1_pressed_loc = None
         self.closed_dropdown = None
         self.centre_alignment_text_mod_indexes = (slice(1, None), slice(None, -1))
@@ -715,7 +717,7 @@ class MainTable(tk.Canvas):
                     selected_c, selected_r = len(self.col_positions) - 1, 0
                 elif len(self.row_positions) > 1 and len(self.col_positions) > 1:
                     selected_c, selected_r = 0, len(self.row_positions) - 1
-                curr_coords = (selected_r, selected_c)
+            curr_coords = (selected_r, selected_c)
         try:
             data = get_data_from_clipboard(
                 widget=self,
@@ -1514,8 +1516,12 @@ class MainTable(tk.Canvas):
             self.purge_redo_stack()
 
     def edit_cells_using_modification(self, modification: dict, event_data: dict) -> EventDataDict:
-        for datarn, v in modification["cells"]["index"].items():
-            self._row_index[datarn] = v
+        if self.PAR.ops.treeview:
+            for datarn, v in modification["cells"]["index"].items():
+                self._row_index[datarn].text = v
+        else:
+            for datarn, v in modification["cells"]["index"].items():
+                self._row_index[datarn] = v
         for datacn, v in modification["cells"]["header"].items():
             self._headers[datacn] = v
         for (datarn, datacn), v in modification["cells"]["table"].items():
@@ -2311,6 +2317,102 @@ class MainTable(tk.Canvas):
                         check_cell_visibility=False,
                     )
 
+    def shift_arrowkey_select_box(
+        self,
+        r1: int,
+        c1: int,
+        r2: int,
+        c2: int,
+        current_r: int,
+        current_c: int,
+        see_r: int,
+        see_c: int,
+        keep_xscroll: bool = False,
+        keep_yscroll: bool = False,
+    ) -> None:
+        box_to_hide = self.selected.fill_iid
+        self.set_currently_selected(
+            current_r,
+            current_c,
+            self.create_selection_box(
+                r1,
+                c1,
+                r2,
+                c2,
+                self.selected.type_,
+                set_current=False,
+                run_binding=True,
+            ),
+            run_binding=False,
+        )
+        self.hide_selection_box(box_to_hide)
+        self.see(see_r, see_c, keep_xscroll=keep_xscroll, keep_yscroll=keep_yscroll, redraw=False)
+        self.refresh()
+
+    def shift_arrowkey_UP(self, event: object = None) -> None:
+        if not self.selected:
+            return
+        r1, c1, r2, c2 = self.selected.box
+        current_r, current_c = self.selected.row, self.selected.column
+        if not r1 and self.selected.row == r2 - 1:
+            return
+        if (r2 - r1 != 1 and self.selected.row != r1 and self.selected.row != r2 - 1) or (
+            r2 - r1 != 1 and self.selected.row == r1
+        ):
+            r2 -= 1
+            see_r = r2 - 1
+        else:
+            r1 -= 1
+            see_r = r1
+        self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, see_r, c1, keep_xscroll=True)
+
+    def shift_arrowkey_DOWN(self, event: object = None) -> None:
+        if not self.selected:
+            return
+        r1, c1, r2, c2 = self.selected.box
+        current_r, current_c = self.selected.row, self.selected.column
+        if r2 == len(self.row_positions) - 1 and self.selected.row == r1:
+            return
+        if r2 - r1 == 1 or self.selected.row == r1:
+            r2 += 1
+            see_r = r2 - 1
+        else:
+            r1 += 1
+            see_r = r1
+        self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, see_r, c1, keep_xscroll=True)
+
+    def shift_arrowkey_LEFT(self, event: object = None) -> None:
+        if not self.selected:
+            return
+        r1, c1, r2, c2 = self.selected.box
+        current_r, current_c = self.selected.row, self.selected.column
+        if not c1 and self.selected.column == c2 - 1:
+            return
+        if (c2 - c1 != 1 and self.selected.column != c1 and self.selected.column != c2 - 1) or (
+            c2 - c1 != 1 and self.selected.column == c1
+        ):
+            c2 -= 1
+            see_c = c2 - 1
+        else:
+            c1 -= 1
+            see_c = c1
+        self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, r1, see_c, keep_yscroll=True)
+
+    def shift_arrowkey_RIGHT(self, event: object = None) -> None:
+        if not self.selected:
+            return
+        r1, c1, r2, c2 = self.selected.box
+        current_r, current_c = self.selected.row, self.selected.column
+        if c2 == len(self.col_positions) - 1 and self.selected.column == c1:
+            return
+        if c2 - c1 == 1 or self.selected.column == c1:
+            c2 += 1
+            see_c = c2 - 1
+        else:
+            c1 += 1
+            see_c = c1
+        self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, r1, see_c, keep_yscroll=True)
+
     def menu_add_command(self, menu: tk.Menu, **kwargs) -> None:
         if "label" not in kwargs:
             return
@@ -2613,15 +2715,19 @@ class MainTable(tk.Canvas):
         if binding in ("all", "arrowkeys", "up"):
             self.up_enabled = True
             self._tksheet_bind("up_bindings", self.arrowkey_UP)
+            self._tksheet_bind("shift_up_bindings", self.shift_arrowkey_UP)
         if binding in ("all", "arrowkeys", "right"):
             self.right_enabled = True
             self._tksheet_bind("right_bindings", self.arrowkey_RIGHT)
+            self._tksheet_bind("shift_right_bindings", self.shift_arrowkey_RIGHT)
         if binding in ("all", "arrowkeys", "down"):
             self.down_enabled = True
             self._tksheet_bind("down_bindings", self.arrowkey_DOWN)
+            self._tksheet_bind("shift_down_bindings", self.shift_arrowkey_DOWN)
         if binding in ("all", "arrowkeys", "left"):
             self.left_enabled = True
             self._tksheet_bind("left_bindings", self.arrowkey_LEFT)
+            self._tksheet_bind("shift_left_bindings", self.shift_arrowkey_LEFT)
         if binding in ("all", "arrowkeys", "prior"):
             self.prior_enabled = True
             self._tksheet_bind("prior_bindings", self.page_UP)
@@ -2881,6 +2987,7 @@ class MainTable(tk.Canvas):
     def ctrl_b1_press(self, event=None):
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
+        self.ctrl_b1_pressed = True
         if self.ctrl_select_enabled and self.not_currently_resizing():
             self.b1_pressed_loc = None
             rowsel = int(self.identify_row(y=event.y))
@@ -2899,6 +3006,7 @@ class MainTable(tk.Canvas):
     def ctrl_shift_b1_press(self, event=None):
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
+        self.ctrl_b1_pressed = True
         if self.ctrl_select_enabled and self.drag_selection_enabled and self.not_currently_resizing():
             self.b1_pressed_loc = None
             rowsel = int(self.identify_row(y=event.y))
@@ -3129,6 +3237,7 @@ class MainTable(tk.Canvas):
                         self.open_cell(event)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases()
+        self.ctrl_b1_pressed = False
         self.b1_pressed_loc = None
         self.closed_dropdown = None
         try_binding(self.extra_b1_release_func, event)
@@ -4317,16 +4426,7 @@ class MainTable(tk.Canvas):
         if isinstance(displayed_columns, list):
             self.displayed_columns = displayed_columns
         elif not self.all_columns_displayed:
-            # push displayed indexes by one for every inserted column
-            self.displayed_columns.sort()
-            # highest index is first in columns
-            up_to = len(self.displayed_columns)
-            for cn in columns:
-                self.displayed_columns.insert((last_ins := bisect_left(self.displayed_columns, cn)), cn)
-                self.displayed_columns[last_ins + 1 : up_to] = [
-                    i + 1 for i in islice(self.displayed_columns, last_ins + 1, up_to)
-                ]
-                up_to = last_ins
+            self.displayed_columns = add_to_displayed(self.displayed_columns, columns)
         cws = self.get_column_widths()
         if column_widths and next(reversed(column_widths)) > len(cws):
             for i in reversed(range(len(cws), len(cws) + next(reversed(column_widths)) - len(cws))):
@@ -4417,7 +4517,7 @@ class MainTable(tk.Canvas):
         else:
             numcols = 1
             displayed_ins_col = len(self.col_positions) - 1
-            data_ins_col = int(displayed_ins_col)
+            data_ins_col = self.total_data_cols()
         if (
             isinstance(self.PAR.ops.paste_insert_column_limit, int)
             and self.PAR.ops.paste_insert_column_limit < displayed_ins_col + numcols
@@ -4462,16 +4562,7 @@ class MainTable(tk.Canvas):
         if isinstance(displayed_rows, list):
             self.displayed_rows = displayed_rows
         elif not self.all_rows_displayed:
-            # push displayed indexes by one for every inserted row
-            self.displayed_rows.sort()
-            # highest index is first in rows
-            up_to = len(self.displayed_rows)
-            for rn in rows:
-                self.displayed_rows.insert((last_ins := bisect_left(self.displayed_rows, rn)), rn)
-                self.displayed_rows[last_ins + 1 : up_to] = [
-                    i + 1 for i in islice(self.displayed_rows, last_ins + 1, up_to)
-                ]
-                up_to = last_ins
+            self.displayed_rows = add_to_displayed(self.displayed_rows, rows)
         rhs = self.get_row_heights()
         if row_heights and next(reversed(row_heights)) > len(rhs):
             default_row_height = self.get_default_row_height()
@@ -4561,7 +4652,7 @@ class MainTable(tk.Canvas):
         else:
             numrows = 1
             displayed_ins_row = len(self.row_positions) - 1
-            data_ins_row = int(displayed_ins_row)
+            data_ins_row = self.total_data_rows()
         if (
             isinstance(self.PAR.ops.paste_insert_row_limit, int)
             and self.PAR.ops.paste_insert_row_limit < displayed_ins_row + numrows
@@ -5847,6 +5938,7 @@ class MainTable(tk.Canvas):
         c: int | None = None,
         item: int | None = None,
         box: tuple[int, int, int, int] | None = None,
+        run_binding: bool = True,
     ) -> None:
         if isinstance(item, int) and item in self.selection_boxes:
             selection_box = self.selection_boxes[item]
@@ -5862,6 +5954,8 @@ class MainTable(tk.Canvas):
                     selection_box.type_,
                     selection_box.fill_iid,
                 )
+                if run_binding:
+                    self.run_selection_binding(selection_box.type_)
                 return
         # currently selected is pointed at any selection box with "box" coordinates
         if isinstance(box, tuple):
@@ -5878,6 +5972,8 @@ class MainTable(tk.Canvas):
                         selection_box.type_,
                         selection_box.fill_iid,
                     )
+                    if run_binding:
+                        self.run_selection_binding(selection_box.type_)
                     return
         # currently selected is just pointed at a coordinate
         # find the top most box there, requires r and c
@@ -5891,6 +5987,8 @@ class MainTable(tk.Canvas):
                         selection_box.type_,
                         selection_box.fill_iid,
                     )
+                    if run_binding:
+                        self.run_selection_binding(selection_box.type_)
                     return
             # wasn't provided an item and couldn't find a box at coords so select cell
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
@@ -6100,8 +6198,8 @@ class MainTable(tk.Canvas):
         bd_iid = None
         if self.PAR.ops.show_selected_cells_border and (
             ext
+            or self.ctrl_b1_pressed
             or (self.being_drawn_item is None and self.RI.being_drawn_item is None and self.CH.being_drawn_item is None)
-            or self.selection_boxes
         ):
             bd_iid = self.display_box(
                 x1,

tksheet/other_classes.py

@@ -6,7 +6,6 @@ from collections.abc import Callable, Generator, Hashable, Iterator
 from functools import partial
 from typing import Literal
 
-
 pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 
 FontTuple = namedtuple("FontTuple", "family size style")
@@ -39,6 +38,47 @@ TextCfg = namedtuple("TextCfg", "txt tf font align")
 DraggedRowColumn = namedtuple("DraggedRowColumn", "dragged to_move")
 
 
+class SelectionBox:
+    __slots__ = ("fill_iid", "bd_iid", "index", "header", "coords", "type_")
+
+    def __init__(
+        self,
+        fill_iid: int | None = None,
+        bd_iid: int | None = None,
+        index: int | None = None,
+        header: int | None = None,
+        coords: tuple[int, int, int, int] = None,
+        type_: Literal["cells", "rows", "columns"] = "cells",
+    ) -> None:
+        self.fill_iid = fill_iid
+        self.bd_iid = bd_iid
+        self.index = index
+        self.header = header
+        self.coords = coords
+        self.type_ = type_
+
+
+Selected = namedtuple(
+    "Selected",
+    (
+        "row",
+        "column",
+        "type_",
+        "box",
+        "iid",
+        "fill_iid",
+    ),
+    defaults=(
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+    ),
+)
+
+
 def num2alpha(n: int) -> str | None:
     try:
         s = ""
@@ -469,47 +509,6 @@ class TextEditorStorage:
         return self.window.c
 
 
-class SelectionBox:
-    __slots__ = ("fill_iid", "bd_iid", "index", "header", "coords", "type_")
-
-    def __init__(
-        self,
-        fill_iid: int | None = None,
-        bd_iid: int | None = None,
-        index: int | None = None,
-        header: int | None = None,
-        coords: tuple[int, int, int, int] = None,
-        type_: Literal["cells", "rows", "columns"] = "cells",
-    ) -> None:
-        self.fill_iid = fill_iid
-        self.bd_iid = bd_iid
-        self.index = index
-        self.header = header
-        self.coords = coords
-        self.type_ = type_
-
-
-Selected = namedtuple(
-    "Selected",
-    (
-        "row",
-        "column",
-        "type_",
-        "box",
-        "iid",
-        "fill_iid",
-    ),
-    defaults=(
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-    ),
-)
-
-
 class ProgressBar:
     __slots__ = ("bg", "fg", "name", "percent", "del_when_done")
 

tksheet/row_index.py

@@ -276,8 +276,7 @@ class RowIndex(tk.Canvas):
 
     def shift_b1_press(self, event: object) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
-        y = event.y
-        r = self.MT.identify_row(y=y)
+        r = self.MT.identify_row(y=event.y)
         if (self.drag_and_drop_enabled or self.row_selection_enabled) and self.rsz_h is None and self.rsz_w is None:
             if r < len(self.MT.row_positions) - 1:
                 r_selected = self.MT.row_selected(r)
@@ -302,7 +301,7 @@ class RowIndex(tk.Canvas):
                     )
 
     def get_shift_select_box(self, r: int, min_r: int) -> tuple[int, int, int, int, str]:
-        if r > min_r:
+        if r >= min_r:
             return min_r, 0, r + 1, len(self.MT.col_positions) - 1
         elif r < min_r:
             return r, 0, min_r + 1, len(self.MT.col_positions) - 1
@@ -1206,6 +1205,8 @@ class RowIndex(tk.Canvas):
                 new_w = self.MT.get_txt_w(f"{end_row}") + 20
             elif self.PAR.ops.default_row_index == "both":
                 new_w = self.MT.get_txt_w(f"{end_row + 1} {num2alpha(end_row)}") + 20
+            elif self.PAR.ops.default_row_index is None:
+                new_w = 20
         elif self.PAR.ops.auto_resize_row_index is True:
             new_w = self.get_index_text_width(only_rows=only_rows)
         else:
@@ -1380,7 +1381,7 @@ class RowIndex(tk.Canvas):
             #     x1 + 5 + indent + small_mod + small_mod,
             #     y1 + mid_y + small_mod + small_mod,
             # )
-            
+
             # POINTS FOR A LINE THAT STOPS AT ROW LINE
             # points = (
             #     # the upper point
@@ -1390,7 +1391,7 @@ class RowIndex(tk.Canvas):
             #     x1 + 5 + indent + small_mod + small_mod,
             #     y2 - mid_y + small_mod + small_mod,
             # )
-            
+
             # POINTS FOR A HORIZONTAL LINE
             points = (
                 # the left point
@@ -1400,7 +1401,7 @@ class RowIndex(tk.Canvas):
                 x1 + 5 + indent + small_mod + small_mod + small_mod + small_mod,
                 y1 + mid_y,
             )
-            
+
         if self.hidd_tree_arrow:
             t, sh = self.hidd_tree_arrow.popitem()
             self.coords(t, points)
@@ -2362,6 +2363,8 @@ class RowIndex(tk.Canvas):
             self.fix_index(datarn)
             if self.get_cell_kwargs(datarn, key="checkbox"):
                 self.MT._row_index[datarn] = try_to_bool(value)
+            elif self.PAR.ops.treeview:
+                self.MT._row_index[datarn].text = value
             else:
                 self.MT._row_index[datarn] = value
 
@@ -2402,6 +2405,8 @@ class RowIndex(tk.Canvas):
             or (self.MT._row_index[datarn] is None and none_to_empty_str)
         ):
             return ""
+        if self.PAR.ops.treeview:
+            return self.MT._row_index[datarn].text
         return self.MT._row_index[datarn]
 
     def get_valid_cell_data_as_str(self, datarn: int, fix: bool = True) -> str: