tksheet 7.2.18__tar.gz → 7.2.19__tar.gz

{tksheet-7.2.18/tksheet.egg-info → tksheet-7.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.18
+Version: 7.2.19
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors

{tksheet-7.2.18 → tksheet-7.2.19}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet widget"
 readme = "README.md"
-version = "7.2.18"
+version = "7.2.19"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.2.18 → tksheet-7.2.19}/tksheet/__init__.py

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

{tksheet-7.2.18 → tksheet-7.2.19}/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-7.2.18 → tksheet-7.2.19}/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-7.2.18 → tksheet-7.2.19}/tksheet/functions.py

@@ -325,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:
@@ -522,9 +517,7 @@ 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:] = [e + 1 for e in islice(displayed, ins, None)]
-    for i in reversed(to_add):
-        displayed.insert(bisect_left(displayed, i), i)
+        displayed[ins:] = [i] + [e + 1 for e in islice(displayed, ins, None)]
     return displayed
 
 
@@ -595,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 = []
@@ -1425,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-7.2.18 → tksheet-7.2.19}/tksheet/main_table.py

@@ -126,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))
@@ -716,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,
@@ -1515,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():
@@ -2312,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
@@ -2614,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)
@@ -2882,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))
@@ -2900,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))
@@ -3130,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)
@@ -6090,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-7.2.18 → tksheet-7.2.19}/tksheet/other_classes.py

@@ -38,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 = ""
@@ -468,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-7.2.18 → tksheet-7.2.19}/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
@@ -2364,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
 
@@ -2404,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:

{tksheet-7.2.18 → tksheet-7.2.19}/tksheet/sheet.py

@@ -28,6 +28,7 @@ from .column_headers import ColumnHeaders
 from .functions import (
     add_highlight,
     add_to_options,
+    alpha2idx,
     consecutive_ranges,
     convert_align,
     data_to_displayed_idxs,
@@ -2907,10 +2908,16 @@ class Sheet(tk.Frame):
                         set_readonly(self.MT.cell_options, (r, c), readonly)
         elif span.kind == "row":
             for r in rows:
-                set_readonly(self.MT.row_options, r, readonly)
+                if index:
+                    set_readonly(self.RI.cell_options, r, readonly)
+                if table:
+                    set_readonly(self.MT.row_options, r, readonly)
         elif span.kind == "column":
             for c in cols:
-                set_readonly(self.MT.col_options, c, readonly)
+                if header:
+                    set_readonly(self.CH.cell_options, c, readonly)
+                if table:
+                    set_readonly(self.MT.col_options, c, readonly)
         return span
 
     # Text Font and Alignment
@@ -4152,6 +4159,7 @@ class Sheet(tk.Frame):
         canvas: Literal[
             "all",
             "row_index",
+            "index",
             "header",
             "top_left",
             "x_scrollbar",
@@ -4174,7 +4182,7 @@ class Sheet(tk.Frame):
             self.yscroll_showing = True
             self.xscroll_disabled = False
             self.yscroll_disabled = False
-        elif canvas == "row_index":
+        elif canvas in ("row_index", "index"):
             self.RI.grid(row=1, column=0, sticky="nswe")
             self.MT["yscrollcommand"] = self.yscroll.set
             self.RI["yscrollcommand"] = self.yscroll.set
@@ -4423,14 +4431,107 @@ class Sheet(tk.Frame):
             and event.widget == self.TL
         )
 
+    def props(
+        self,
+        row: int,
+        column: int | str,
+        key: None
+        | Literal[
+            "format",
+            "highlight",
+            "dropdown",
+            "checkbox",
+            "readonly",
+            "align",
+        ] = None,
+        cellops: bool = True,
+        rowops: bool = True,
+        columnops: bool = True,
+    ) -> dict:
+        """
+        Retrieve options (properties - props)
+        from a single cell in the main table
+
+        Also retrieves any row or column options
+        impacting that cell
+        """
+        if isinstance(column, str):
+            column = alpha2idx(column)
+        if key is not None:
+            return self.MT.get_cell_kwargs(
+                datarn=row,
+                datacn=column,
+                key=key,
+                cell=cellops,
+                row=rowops,
+                column=columnops,
+            )
+        if cellops and (row, column) in self.MT.cell_options:
+            return self.MT.cell_options[(row, column)]
+        if rowops and row in self.MT.row_options:
+            return self.MT.row_options[row]
+        if columnops and column in self.MT.col_options:
+            return self.MT.col_options[column]
+        return {}
+
+    def index_props(
+        self,
+        row: int,
+        key: None
+        | Literal[
+            "format",
+            "highlight",
+            "dropdown",
+            "checkbox",
+            "readonly",
+            "align",
+        ] = None,
+    ) -> dict:
+        """
+        Retrieve options (properties - props)
+        from a cell in the index
+        """
+        if key is not None:
+            return self.RI.get_cell_kwargs(
+                datarn=row,
+                key=key,
+            )
+        return self.RI.cell_options[row] if row in self.RI.cell_options else {}
+
+    def header_props(
+        self,
+        column: int | str,
+        key: None
+        | Literal[
+            "format",
+            "highlight",
+            "dropdown",
+            "checkbox",
+            "readonly",
+            "align",
+        ] = None,
+    ) -> dict:
+        """
+        Retrieve options (properties - props)
+        from a cell in the header
+        """
+        if isinstance(column, str):
+            column = alpha2idx(column)
+        if key is not None:
+            return self.CH.get_cell_kwargs(
+                datacn=column,
+                key=key,
+            )
+        return self.CH.cell_options[column] if column in self.CH.cell_options else {}
+
     def get_cell_options(
         self,
         key: None | str = None,
-        canvas: Literal["table", "row_index", "header"] = "table",
+        canvas: Literal["table", "row_index", "index", "header"] = "table",
     ) -> dict:
         if canvas == "table":
             target = self.MT.cell_options
-        elif canvas == "row_index":
+        elif canvas in ("row_index", "index"):
             target = self.RI.cell_options
         elif canvas == "header":
             target = self.CH.cell_options
@@ -6024,7 +6125,7 @@ class Sheet(tk.Frame):
         row: int | Literal["all"] = 0,
         column: int = 0,
         cells: list[tuple[int, int]] = [],
-        canvas: Literal["table", "row_index", "header"] = "table",
+        canvas: Literal["table", "row_index", "index", "header"] = "table",
         all_: bool = False,
         redraw: bool = True,
     ) -> Sheet:
@@ -6057,7 +6158,7 @@ class Sheet(tk.Frame):
                 for k in self.MT.cell_options:
                     if "highlight" in self.MT.cell_options[k]:
                         del self.MT.cell_options[k]["highlight"]
-        elif canvas == "row_index":
+        elif canvas in ("row_index", "index"):
             if cells and not all_:
                 for r in cells:
                     try:
@@ -6087,10 +6188,13 @@ class Sheet(tk.Frame):
                         del self.CH.cell_options[c]["highlight"]
         return self.set_refresh_timer(redraw)
 
-    def get_highlighted_cells(self, canvas: str = "table") -> dict | None:
+    def get_highlighted_cells(
+        self,
+        canvas: Literal["table", "row_index", "index", "header"] = "table",
+    ) -> dict | None:
         if canvas == "table":
             return {k: v["highlight"] for k, v in self.MT.cell_options.items() if "highlight" in v}
-        elif canvas == "row_index":
+        elif canvas in ("row_index", "index"):
             return {k: v["highlight"] for k, v in self.RI.cell_options.items() if "highlight" in v}
         elif canvas == "header":
             return {k: v["highlight"] for k, v in self.CH.cell_options.items() if "highlight" in v}

{tksheet-7.2.18 → tksheet-7.2.19}/tksheet/sheet_options.py

@@ -118,6 +118,18 @@ def new_sheet_options() -> DotDict:
             "left_bindings": [
                 "<Left>",
             ],
+            "shift_up_bindings": [
+                "<Shift-Up>",
+            ],
+            "shift_right_bindings": [
+                "<Shift-Right>",
+            ],
+            "shift_down_bindings": [
+                "<Shift-Down>",
+            ],
+            "shift_left_bindings": [
+                "<Shift-Left>",
+            ],
             "prior_bindings": [
                 "<Prior>",
             ],

{tksheet-7.2.18 → tksheet-7.2.19/tksheet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.18
+Version: 7.2.19
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors