tksheet 7.1.12__tar.gz → 7.1.21__tar.gz

{tksheet-7.1.12/tksheet.egg-info → tksheet-7.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.1.12
+Version: 7.1.21
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -42,7 +42,7 @@ License-File: LICENSE.txt
 
 # tksheet
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8+-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![GitHub Release Date](https://img.shields.io/github/release-date-pre/ragardner/tksheet.svg)](https://github.com/ragardner/tksheet/releases) [![Downloads](https://img.shields.io/pypi/dm/tksheet.svg)](https://pypi.org/project/tksheet/)
 

{tksheet-7.1.12 → tksheet-7.1.21}/README.md

@@ -1,6 +1,6 @@
 # tksheet
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8+-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![GitHub Release Date](https://img.shields.io/github/release-date-pre/ragardner/tksheet.svg)](https://github.com/ragardner/tksheet/releases) [![Downloads](https://img.shields.io/pypi/dm/tksheet.svg)](https://pypi.org/project/tksheet/)
 

{tksheet-7.1.12 → tksheet-7.1.21}/pyproject.toml

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

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.1.12"
+__version__ = "7.1.21"
 
 from .colors import (
     color_map,
@@ -42,6 +42,7 @@ from .functions import (
     event_dict,
     get_checkbox_dict,
     get_checkbox_kwargs,
+    get_data_from_clipboard,
     get_dropdown_dict,
     get_dropdown_kwargs,
     get_index_of_gap_in_sorted_integer_seq_forward,

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/column_headers.py

@@ -22,10 +22,10 @@ from .colors import (
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
     consecutive_ranges,
-    ev_stack_dict,
     event_dict,
     get_n2a,
     is_contiguous,
+    pickled_event_dict,
     rounded_box_coords,
     try_binding,
 )
@@ -133,6 +133,9 @@ class ColumnHeaders(tk.Canvas):
             self.bind("<Double-Button-1>", self.double_b1)
             self.bind(rc_binding, self.rc)
             self.bind("<MouseWheel>", self.mousewheel)
+            if USER_OS == "linux":
+                self.bind("<Button-4>", self.mousewheel)
+                self.bind("<Button-5>", self.mousewheel)
         else:
             self.unbind("<Motion>")
             self.unbind("<ButtonPress-1>")
@@ -141,6 +144,9 @@ class ColumnHeaders(tk.Canvas):
             self.unbind("<Double-Button-1>")
             self.unbind(rc_binding)
             self.unbind("<MouseWheel>")
+            if USER_OS == "linux":
+                self.unbind("<Button-4>")
+                self.unbind("<Button-5>")
 
     def mousewheel(self, event: object):
         maxlines = 0
@@ -845,7 +851,7 @@ class ColumnHeaders(tk.Canvas):
                         "displayed": disp_new_idxs,
                     }
                     if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(ev_stack_dict(event_data))
+                        self.MT.undo_stack.append(pickled_event_dict(event_data))
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
                     try_binding(self.ch_extra_end_drag_drop_func, event_data, "end_move_columns")
                     self.MT.sheet_modified(event_data)
@@ -1278,12 +1284,9 @@ class ColumnHeaders(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_line(
+                t = self.create_polygon(
                     points,
                     fill=fill,
-                    width=2,
-                    capstyle=tk.ROUND,
-                    joinstyle=tk.ROUND,
                     tag=tag,
                 )
             self.disp_dropdown[t] = True
@@ -2091,7 +2094,7 @@ class ColumnHeaders(tk.Canvas):
             self.fix_header(datacn)
             if not check_input_valid or self.input_valid_for_cell(datacn, value):
                 if self.MT.undo_enabled and undo:
-                    self.MT.undo_stack.append(ev_stack_dict(event_data))
+                    self.MT.undo_stack.append(pickled_event_dict(event_data))
                 self.set_cell_data(datacn=datacn, value=value)
                 edited = True
         if edited and cell_resize and self.PAR.ops.cell_auto_resize_enabled:

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/functions.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
 import bisect
+import csv
+import io
 import pickle
 import re
+import tkinter as tk
 import zlib
 from collections import deque
 from collections.abc import (
@@ -19,6 +22,7 @@ from .other_classes import (
     DotDict,
     EventDataDict,
     Highlight,
+    Loc,
     Span,
 )
 
@@ -27,6 +31,21 @@ pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 unpickle_obj = pickle.loads
 
 
+def get_data_from_clipboard(
+    widget: tk.Misc,
+    delimiters: str,
+    lineterminator: str = "\n",
+) -> list[list[str]]:
+    data = widget.clipboard_get()
+    try:
+        dialect = csv.Sniffer().sniff(data, delimiters=delimiters)
+    except Exception:
+        dialect = csv.excel_tab
+    if dialect.delimiter in data or lineterminator in data:
+        return list(csv.reader(io.StringIO(data), dialect=dialect, skipinitialspace=True))
+    return [[data]]
+
+
 def pickle_compress(obj: object) -> bytes:
     return compress(pickle_obj(obj))
 
@@ -164,11 +183,8 @@ def change_eventname(event_dict: EventDataDict, newname: str) -> EventDataDict:
     return EventDataDict({**event_dict, **{"eventname": newname}})
 
 
-def ev_stack_dict(d: DotDict) -> DotDict:
-    return DotDict(
-        name=d["eventname"],
-        data=pickle_compress(d),
-    )
+def pickled_event_dict(d: DotDict) -> DotDict:
+    return DotDict(name=d["eventname"], data=pickle_compress(d))
 
 
 def len_to_idx(n: int) -> int:
@@ -406,11 +422,13 @@ def index_exists(seq: Sequence[object], index: int) -> bool:
 def move_elements_by_mapping(
     seq: list[object],
     new_idxs: dict[int, int],
-    old_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, ...}
+    if old_idxs is None:
+        old_idxs = dict(zip(new_idxs.values(), new_idxs))
 
     # create dummy list
     res = [0] * len(seq)
@@ -1293,10 +1311,12 @@ def mod_span_widget(span: Span, widget: object) -> Span:
 def mod_event_val(
     event_data: EventDataDict,
     val: object,
-    loc: tuple[int, int] | int,
+    loc: Loc | int,
 ) -> EventDataDict:
     event_data.value = val
-    event_data.loc = loc
+    event_data.loc = Loc(*loc)
+    event_data.row = loc[0]
+    event_data.column = loc[1]
     return event_data
 
 

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/main_table.py

@@ -52,9 +52,9 @@ from .functions import (
     decompress_load,
     diff_gen,
     diff_list,
-    ev_stack_dict,
     event_dict,
     gen_formatted,
+    get_data_from_clipboard,
     get_new_indexes,
     get_seq_without_gaps_at_index,
     index_exists,
@@ -68,6 +68,7 @@ from .functions import (
     mod_span_widget,
     move_elements_by_mapping,
     pickle_obj,
+    pickled_event_dict,
     rounded_box_coords,
     span_idxs_post_move,
     try_binding,
@@ -363,10 +364,10 @@ class MainTable(tk.Canvas):
             ("<ButtonRelease-1>", self, self.b1_release),
             ("<Double-Button-1>", self, self.double_b1),
             ("<MouseWheel>", self, self.mousewheel),
+            ("<MouseWheel>", self.RI, self.mousewheel),
             ("<Shift-ButtonPress-1>", self, self.shift_b1_press),
             ("<Shift-ButtonPress-1>", self.CH, self.CH.shift_b1_press),
             ("<Shift-ButtonPress-1>", self.RI, self.RI.shift_b1_press),
-            ("<MouseWheel>", self.RI, self.mousewheel),
             (rc_binding, self, self.rc),
             (f"<{ctrl_key}-ButtonPress-1>", self, self.ctrl_b1_press),
             (f"<{ctrl_key}-ButtonPress-1>", self.CH, self.CH.ctrl_b1_press),
@@ -385,9 +386,11 @@ class MainTable(tk.Canvas):
             ("<Control-equal>", self.zoom_in),
             ("<Control-minus>", self.zoom_out),
         )
-        all_canvas_linux_bindings = {
+        mt_ri_canvas_linux_bindings = {
             ("<Button-4>", self.mousewheel),
             ("<Button-5>", self.mousewheel),
+        }
+        all_canvas_linux_bindings = {
             ("<Shift-Button-4>", self.shift_mousewheel),
             ("<Shift-Button-5>", self.shift_mousewheel),
             ("<Control-Button-4>", self.ctrl_mousewheel),
@@ -400,6 +403,9 @@ class MainTable(tk.Canvas):
                 for canvas in (self, self.RI, self.CH):
                     canvas.bind(b[0], b[1])
             if USER_OS == "linux":
+                for b in mt_ri_canvas_linux_bindings:
+                    for canvas in (self, self.RI):
+                        canvas.bind(b[0], b[1])
                 for b in all_canvas_linux_bindings:
                     for canvas in (self, self.RI, self.CH):
                         canvas.bind(b[0], b[1])
@@ -410,6 +416,9 @@ class MainTable(tk.Canvas):
                 for canvas in (self, self.RI, self.CH):
                     canvas.unbind(b[0])
             if USER_OS == "linux":
+                for b in mt_ri_canvas_linux_bindings:
+                    for canvas in (self, self.RI):
+                        canvas.unbind(b[0])
                 for b in all_canvas_linux_bindings:
                     for canvas in (self, self.RI, self.CH):
                         canvas.unbind(b[0])
@@ -495,6 +504,8 @@ class MainTable(tk.Canvas):
     def get_ctrl_x_c_boxes(self) -> tuple[dict[tuple[int, int, int, int], str], int]:
         boxes = {}
         maxrows = 0
+        if not self.selected:
+            return boxes, maxrows
         if self.selected.type_ in ("cells", "columns"):
             curr_box = self.selection_boxes[self.selected.fill_iid].coords
             maxrows = curr_box[2] - curr_box[0]
@@ -517,7 +528,7 @@ class MainTable(tk.Canvas):
         )
         return s, writer
 
-    def ctrl_c(self, event=None) -> None:
+    def ctrl_c(self, event=None) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = event_dict(
@@ -555,14 +566,17 @@ class MainTable(tk.Canvas):
         for r1, c1, r2, c2 in boxes:
             self.show_ctrl_outline(canvas="table", start_cell=(c1, r1), end_cell=(c2, r2))
         self.clipboard_clear()
-        if len(event_data["cells"]["table"]) == 1:
+        if len(event_data["cells"]["table"]) == 1 and self.PAR.ops.to_clipboard_lineterminator not in next(
+            iter(event_data["cells"]["table"].values())
+        ):
             self.clipboard_append(next(iter(event_data["cells"]["table"].values())))
         else:
             self.clipboard_append(s.getvalue())
         self.update_idletasks()
         try_binding(self.extra_end_ctrl_c_func, event_data, "end_ctrl_c")
+        return event_data
 
-    def ctrl_x(self, event=None) -> None:
+    def ctrl_x(self, event=None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = event_dict(
@@ -586,10 +600,14 @@ class MainTable(tk.Canvas):
                         datacn = self.datacn(c)
                         row.append(self.get_cell_clipboard(datarn, datacn))
                         val = self.get_value_for_empty_cell(datarn, datacn)
-                        if not self.edit_validation_func or (
-                            self.edit_validation_func
-                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
-                            is not None
+                        if (
+                            not self.edit_validation_func
+                            or not validation
+                            or (
+                                self.edit_validation_func
+                                and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
+                                is not None
+                            )
                         ):
                             event_data = self.event_data_set_cell(
                                 datarn,
@@ -607,10 +625,14 @@ class MainTable(tk.Canvas):
                         datacn = self.datacn(c)
                         row.append(self.get_cell_clipboard(datarn, datacn))
                         val = self.get_value_for_empty_cell(datarn, datacn)
-                        if not self.edit_validation_func or (
-                            self.edit_validation_func
-                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
-                            is not None
+                        if (
+                            not self.edit_validation_func
+                            or not validation
+                            or (
+                                self.edit_validation_func
+                                and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
+                                is not None
+                            )
                         ):
                             event_data = self.event_data_set_cell(
                                 datarn,
@@ -620,9 +642,11 @@ class MainTable(tk.Canvas):
                             )
                     writer.writerow(row)
         if event_data["cells"]["table"]:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.clipboard_clear()
-        if len(event_data["cells"]["table"]) == 1:
+        if len(event_data["cells"]["table"]) == 1 and self.PAR.ops.to_clipboard_lineterminator not in next(
+            iter(event_data["cells"]["table"].values())
+        ):
             self.clipboard_append(next(iter(event_data["cells"]["table"].values())))
         else:
             self.clipboard_append(s.getvalue())
@@ -633,8 +657,9 @@ class MainTable(tk.Canvas):
         if event_data["cells"]["table"]:
             try_binding(self.extra_end_ctrl_x_func, event_data, "end_ctrl_x")
         self.sheet_modified(event_data)
+        return event_data
 
-    def ctrl_v(self, event: object = None) -> None:
+    def ctrl_v(self, event: object = None, validation: bool = True) -> None | EventDataDict:
         if not self.PAR.ops.expand_sheet_if_paste_too_big and (
             len(self.col_positions) == 1 or len(self.row_positions) == 1
         ):
@@ -660,18 +685,13 @@ class MainTable(tk.Canvas):
                 elif len(self.row_positions) > 1 and len(self.col_positions) > 1:
                     selected_c, selected_r = 0, len(self.row_positions) - 1
         try:
-            data = self.clipboard_get()
+            data = get_data_from_clipboard(
+                widget=self,
+                delimiters=self.PAR.ops.from_clipboard_delimiters,
+                lineterminator=self.PAR.ops.to_clipboard_lineterminator,
+            )
         except Exception:
             return
-        try:
-            dialect = csv.Sniffer().sniff(data, delimiters=self.PAR.ops.from_clipboard_delimiters)
-        except Exception:
-            dialect = csv.excel_tab
-        if dialect.delimiter in data:
-            if not (data := list(csv.reader(io.StringIO(data), dialect=dialect, skipinitialspace=True))):
-                return
-        else:
-            data = [[data]]
         new_data_numcols = max(map(len, data))
         new_data_numrows = len(data)
         for rn, r in enumerate(data):
@@ -749,9 +769,13 @@ class MainTable(tk.Canvas):
         for ndr, r in enumerate(range(selected_r, selected_r_adjusted_new_data_numrows)):
             for ndc, c in enumerate(range(selected_c, selected_c_adjusted_new_data_numcols)):
                 val = data[ndr][ndc]
-                if not self.edit_validation_func or (
-                    self.edit_validation_func
-                    and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                if (
+                    not self.edit_validation_func
+                    or not validation
+                    or (
+                        self.edit_validation_func
+                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                    )
                 ):
                     event_data = self.event_data_set_cell(
                         datarn=self.datarn(r),
@@ -785,10 +809,14 @@ class MainTable(tk.Canvas):
                 ):
                     val = data[ndr][ndc]
                     datacn = self.datacn(c)
-                    if not self.edit_validation_func or (
-                        self.edit_validation_func
-                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
-                        and self.input_valid_for_cell(r, datacn, val, ignore_empty=True)
+                    if (
+                        not self.edit_validation_func
+                        or not validation
+                        or (
+                            self.edit_validation_func
+                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                            and self.input_valid_for_cell(r, datacn, val, ignore_empty=True)
+                        )
                     ):
                         rows[r][datacn] = val
                         ctr += 1
@@ -823,10 +851,14 @@ class MainTable(tk.Canvas):
                 ):
                     val = data[ndr][ndc]
                     datarn = self.datarn(r)
-                    if not self.edit_validation_func or (
-                        self.edit_validation_func
-                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
-                        and self.input_valid_for_cell(datarn, c, val, ignore_empty=True)
+                    if (
+                        not self.edit_validation_func
+                        or not validation
+                        or (
+                            self.edit_validation_func
+                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                            and self.input_valid_for_cell(datarn, c, val, ignore_empty=True)
+                        )
                     ):
                         columns[c][datarn] = val
                         ctr += 1
@@ -839,7 +871,7 @@ class MainTable(tk.Canvas):
                 )
         self.deselect("all", redraw=False)
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.create_selection_box(
             selected_r,
             selected_c,
@@ -861,8 +893,9 @@ class MainTable(tk.Canvas):
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
             try_binding(self.extra_end_ctrl_v_func, event_data, "end_ctrl_v")
         self.sheet_modified(event_data)
+        return event_data
 
-    def delete_key(self, event: object = None) -> None:
+    def delete_key(self, event: object = None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = event_dict(
@@ -879,9 +912,13 @@ class MainTable(tk.Canvas):
                 for c in range(c1, c2):
                     datarn, datacn = self.datarn(r), self.datacn(c)
                     val = self.get_value_for_empty_cell(datarn, datacn)
-                    if not self.edit_validation_func or (
-                        self.edit_validation_func
-                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                    if (
+                        not self.edit_validation_func
+                        or not validation
+                        or (
+                            self.edit_validation_func
+                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                        )
                     ):
                         event_data = self.event_data_set_cell(
                             datarn,
@@ -890,10 +927,11 @@ class MainTable(tk.Canvas):
                             event_data,
                         )
         if event_data["cells"]["table"]:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
             try_binding(self.extra_end_delete_key_func, event_data, "end_delete")
         self.refresh()
         self.sheet_modified(event_data)
+        return event_data
 
     def event_data_set_cell(self, datarn: int, datacn: int, value: object, event_data: dict) -> EventDataDict:
         if self.input_valid_for_cell(datarn, datacn, value):
@@ -1370,39 +1408,36 @@ class MainTable(tk.Canvas):
         # all the way from 0 to max_idx
         if old_idxs is None:
             old_idxs = dict(zip(new_idxs.values(), new_idxs))
-        seq = tuple(range(max_idx + 1))
         return dict(
             zip(
-                move_elements_by_mapping(seq, new_idxs, old_idxs),
-                seq,
+                move_elements_by_mapping(tuple(range(max_idx + 1)), new_idxs, old_idxs),
+                range(max_idx + 1),
             )
         )
 
-    def undo(self, event: object = None) -> None:
+    def undo(self, event: object = None) -> None | EventDataDict:
         if not self.undo_stack:
             return
-        if isinstance(self.undo_stack[-1]["data"], dict):
-            modification = self.undo_stack[-1]["data"]
-        else:
-            modification = decompress_load(self.undo_stack[-1]["data"])
+        modification = decompress_load(self.undo_stack[-1]["data"])
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_undo"):
             return
-        self.redo_stack.append(self.undo_modification_invert_event(modification))
+        event_data = self.undo_modification_invert_event(modification)
+        self.redo_stack.append(pickled_event_dict(event_data))
         self.undo_stack.pop()
-        try_binding(self.extra_end_ctrl_z_func, modification, "end_undo")
+        try_binding(self.extra_end_ctrl_z_func, event_data, "end_undo")
+        return event_data
 
-    def redo(self, event: object = None) -> None:
+    def redo(self, event: object = None) -> None | EventDataDict:
         if not self.redo_stack:
             return
-        if isinstance(self.redo_stack[-1]["data"], dict):
-            modification = self.redo_stack[-1]["data"]
-        else:
-            modification = decompress_load(self.redo_stack[-1]["data"])
+        modification = decompress_load(self.redo_stack[-1]["data"])
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_redo"):
             return
-        self.undo_stack.append(self.undo_modification_invert_event(modification, name="redo"))
+        event_data = self.undo_modification_invert_event(modification, name="redo")
+        self.undo_stack.append(pickled_event_dict(event_data))
         self.redo_stack.pop()
-        try_binding(self.extra_end_ctrl_z_func, modification, "end_redo")
+        try_binding(self.extra_end_ctrl_z_func, event_data, "end_redo")
+        return event_data
 
     def sheet_modified(self, event_data: EventDataDict, purge_redo: bool = True) -> None:
         self.PAR.emit_event("<<SheetModified>>", event_data)
@@ -1450,7 +1485,7 @@ class MainTable(tk.Canvas):
             k: mod_span_widget(unpickle_obj(v), self.PAR) for k, v in modification["named_spans"].items()
         }
 
-    def undo_modification_invert_event(self, modification: EventDataDict, name: str = "undo") -> bytes | EventDataDict:
+    def undo_modification_invert_event(self, modification: EventDataDict, name: str = "undo") -> EventDataDict:
         self.deselect("all", redraw=False)
         event_data = event_dict(
             name=modification["eventname"],
@@ -1615,7 +1650,7 @@ class MainTable(tk.Canvas):
 
         self.sheet_modified(event_data, purge_redo=False)
         self.refresh()
-        return ev_stack_dict(event_data)
+        return event_data
 
     def see(
         self,
@@ -2733,9 +2768,10 @@ class MainTable(tk.Canvas):
                         popup_menu = self.rc_popup_menu
             else:
                 self.deselect("all")
-                popup_menu = self.empty_rc_popup_menu
+                if self.rc_popup_menus_enabled:
+                    popup_menu = self.empty_rc_popup_menu
         try_binding(self.extra_rc_func, event)
-        if popup_menu is not None:
+        if popup_menu:
             popup_menu.tk_popup(event.x_root, event.y_root)
 
     def b1_press(self, event=None):
@@ -3715,6 +3751,22 @@ class MainTable(tk.Canvas):
             del self.row_positions[idx]
             self.row_positions[idx:] = [e - w for e in islice(self.row_positions, idx, len(self.row_positions))]
 
+    def del_col_positions(self, idxs: Iterator[int] | None = None):
+        if idxs is None:
+            del self.col_positions[-1]
+        else:
+            if not isinstance(idxs, set):
+                idxs = set(idxs)
+            self.set_col_positions(itr=(w for i, w in enumerate(self.gen_column_widths()) if i not in idxs))
+
+    def del_row_positions(self, idxs: Iterator[int] | None = None):
+        if idxs is None:
+            del self.row_positions[-1]
+        else:
+            if not isinstance(idxs, set):
+                idxs = set(idxs)
+            self.set_row_positions(itr=(h for i, h in enumerate(self.gen_row_heights()) if i not in idxs))
+
     def get_column_widths(self) -> list[int]:
         return diff_list(self.col_positions)
 
@@ -3727,26 +3779,6 @@ class MainTable(tk.Canvas):
     def gen_row_heights(self) -> Generator[int]:
         return diff_gen(self.row_positions)
 
-    def del_col_positions(self, idx: int, num: int = 1, deselect_all: bool = False):
-        if deselect_all:
-            self.deselect("all", redraw=False)
-        if idx == "end" or len(self.col_positions) <= idx + 1:
-            del self.col_positions[-1]
-        else:
-            cws = self.get_column_widths()
-            cws[idx : idx + num] = []
-            self.set_col_positions(itr=cws)
-
-    def del_row_positions(self, idx: int, numrows: int = 1, deselect_all: bool = False):
-        if deselect_all:
-            self.deselect("all", redraw=False)
-        if idx == "end" or len(self.row_positions) <= idx + 1:
-            del self.row_positions[-1]
-        else:
-            rhs = self.get_row_heights()
-            rhs[idx : idx + numrows] = []
-            self.set_row_positions(itr=rhs)
-
     def insert_col_position(
         self,
         idx: Literal["end"] | int = "end",
@@ -4301,7 +4333,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.refresh()
         try_binding(self.extra_end_insert_cols_rc_func, event_data, "end_add_columns")
         self.sheet_modified(event_data)
@@ -4432,7 +4464,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.refresh()
         try_binding(self.extra_end_insert_rows_rc_func, event_data, "end_add_rows")
         self.sheet_modified(event_data)
@@ -4604,7 +4636,7 @@ class MainTable(tk.Canvas):
         data_cols = selected if self.all_columns_displayed else [self.displayed_columns[c] for c in selected]
         event_data = self.delete_columns_data(data_cols, event_data)
         if self.undo_enabled:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.deselect("all")
         try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
         self.sheet_modified(event_data)
@@ -4658,7 +4690,7 @@ class MainTable(tk.Canvas):
         data_rows = selected if self.all_rows_displayed else [self.displayed_rows[r] for r in selected]
         event_data = self.delete_rows_data(data_rows, event_data)
         if self.undo_enabled:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.deselect("all")
         try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
         self.sheet_modified(event_data)
@@ -4881,7 +4913,7 @@ class MainTable(tk.Canvas):
         if isinstance(at_least_cols, int) and at_least_cols > total_data_cols:
             total_data_cols = at_least_cols
         total_data_cols = max(total_data_cols, len(self.col_positions) - 1)
-        if include_header and total_data_cols > len(self._headers):
+        if not isinstance(self._headers, int) and include_header and total_data_cols > len(self._headers):
             self.CH.fix_header(total_data_cols)
         for rn, r in enumerate(self.data):
             if total_data_cols > (lnr := len(r)):
@@ -5105,12 +5137,9 @@ class MainTable(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_line(
+                t = self.create_polygon(
                     points,
                     fill=fill,
-                    width=2,
-                    capstyle=tk.ROUND,
-                    joinstyle=tk.ROUND,
                     tag=tag,
                 )
             self.disp_dropdown[t] = True
@@ -6970,7 +6999,7 @@ class MainTable(tk.Canvas):
         )
         if not check_input_valid or self.input_valid_for_cell(datarn, datacn, value):
             if self.undo_enabled and undo:
-                self.undo_stack.append(ev_stack_dict(event_data))
+                self.undo_stack.append(pickled_event_dict(event_data))
             self.set_cell_data(datarn, datacn, value)
             if cell_resize and self.PAR.ops.cell_auto_resize_enabled:
                 self.set_cell_size_to_text(r, c, only_set_if_too_small=True, redraw=redraw, run_binding=True)

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/row_index.py

@@ -29,11 +29,11 @@ from .formatters import (
 )
 from .functions import (
     consecutive_chunks,
-    ev_stack_dict,
     event_dict,
     get_n2a,
     is_contiguous,
     num2alpha,
+    pickled_event_dict,
     rounded_box_coords,
     try_binding,
 )
@@ -117,6 +117,7 @@ class RowIndex(tk.Canvas):
         self.disp_resize_lines = {}
         self.disp_dropdown = {}
         self.disp_checkbox = {}
+        self.disp_tree_arrow = {}
         self.disp_boxes = set()
         self.hidd_text = {}
         self.hidd_high = {}
@@ -126,6 +127,7 @@ class RowIndex(tk.Canvas):
         self.hidd_resize_lines = {}
         self.hidd_dropdown = {}
         self.hidd_checkbox = {}
+        self.hidd_tree_arrow = {}
         self.hidd_boxes = set()
 
         self.align = kwargs["row_index_align"]
@@ -851,7 +853,7 @@ class RowIndex(tk.Canvas):
                         "displayed": disp_new_idxs,
                     }
                     if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(ev_stack_dict(event_data))
+                        self.MT.undo_stack.append(pickled_event_dict(event_data))
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
                     try_binding(self.ri_extra_end_drag_drop_func, event_data, "end_move_rows")
                     self.MT.sheet_modified(event_data)
@@ -1017,7 +1019,7 @@ class RowIndex(tk.Canvas):
                 align = self.align
             if align == "w":
                 w += self.MT.index_txt_height
-            w += self.get_treeview_indent(self.MT._row_index[datarn].iid)
+            w += self.get_treeview_indent(self.MT._row_index[datarn].iid) + 4
         return w, h
 
     def set_row_height(
@@ -1205,7 +1207,7 @@ class RowIndex(tk.Canvas):
             if kwargs[0] is not None:
                 c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
             if "rows" in selections and r in selections["rows"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.index_selected_rows_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
@@ -1217,7 +1219,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(c_1[5:], 16) + int(c_3[5:], 16)) / 2):02X}"
                     )
             elif "cells" in selections and r in selections["cells"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.index_selected_cells_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
@@ -1229,7 +1231,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(c_1[5:], 16) + int(c_2[5:], 16)) / 2):02X}"
                     )
             else:
-                tf = self.PAR.ops.index_fg if kwargs[1] is None else kwargs[1]
+                txtfg = self.PAR.ops.index_fg if kwargs[1] is None else kwargs[1]
                 if kwargs[0] is not None:
                     fill = kwargs[0]
             if kwargs[0] is not None:
@@ -1246,14 +1248,18 @@ class RowIndex(tk.Canvas):
                     ),
                     tag="s",
                 )
+            tree_arrow_fg = txtfg
         elif not kwargs:
             if "rows" in selections and r in selections["rows"]:
-                tf = self.PAR.ops.index_selected_rows_fg
+                txtfg = self.PAR.ops.index_selected_rows_fg
+                tree_arrow_fg = self.PAR.ops.selected_rows_tree_arrow_fg
             elif "cells" in selections and r in selections["cells"]:
-                tf = self.PAR.ops.index_selected_cells_fg
+                txtfg = self.PAR.ops.index_selected_cells_fg
+                tree_arrow_fg = self.PAR.ops.selected_cells_tree_arrow_fg
             else:
-                tf = self.PAR.ops.index_fg
-        return tf, redrawn
+                txtfg = self.PAR.ops.index_fg
+                tree_arrow_fg = self.PAR.ops.tree_arrow_fg
+        return txtfg, tree_arrow_fg, redrawn
 
     def redraw_highlight(self, x1, y1, x2, y2, fill, outline, tag):
         coords = (x1, y1, x2, y2)
@@ -1281,6 +1287,56 @@ class RowIndex(tk.Canvas):
         else:
             self.disp_grid[self.create_line(points, fill=fill, width=width, tag=tag)] = True
 
+    def redraw_tree_arrow(
+        self,
+        x1,
+        y1,
+        r,
+        fill,
+        tag,
+        indent: float,
+        open_: bool = False,
+    ) -> None:
+        mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
+        half_mod = mod / 2
+        qtr_mod = mod / 4
+        mid_y = (self.MT.index_first_ln_ins - 1) if self.MT.index_first_ln_ins % 2 else self.MT.index_first_ln_ins
+        # up arrow
+        if open_:
+            points = (
+                x1 + 2 + indent,
+                y1 + mid_y + qtr_mod,
+                x1 + 2 + half_mod + indent,
+                y1 + mid_y - qtr_mod,
+                x1 + 2 + mod + indent,
+                y1 + mid_y + qtr_mod,
+            )
+        # right pointing arrow
+        else:
+            points = (
+                x1 + half_mod + indent,
+                y1 + mid_y - half_mod + 1,
+                x1 + mod + indent - 1,
+                y1 + mid_y,
+                x1 + half_mod + indent,
+                y1 + mid_y + half_mod - 1,
+            )
+        if self.hidd_tree_arrow:
+            t, sh = self.hidd_tree_arrow.popitem()
+            self.coords(t, points)
+            if sh:
+                self.itemconfig(t, fill=fill)
+            else:
+                self.itemconfig(t, fill=fill, tag=tag, state="normal")
+            self.lift(t)
+        else:
+            t = self.create_polygon(
+                points,
+                fill=fill,
+                tag=tag,
+            )
+        self.disp_tree_arrow[t] = True
+
     def redraw_dropdown(
         self,
         x1,
@@ -1293,7 +1349,6 @@ class RowIndex(tk.Canvas):
         draw_outline: bool = True,
         draw_arrow: bool = True,
         open_: bool = False,
-        indent: None | float = None,
     ) -> None:
         if draw_outline and self.PAR.ops.show_dropdown_borders:
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.index_fg, tag=tag)
@@ -1302,47 +1357,24 @@ class RowIndex(tk.Canvas):
             half_mod = mod / 2
             qtr_mod = mod / 4
             mid_y = (self.MT.index_first_ln_ins - 1) if self.MT.index_first_ln_ins % 2 else self.MT.index_first_ln_ins
-            # treeview
-            if indent is not None:
-                # up arrow
-                if open_:
-                    points = (
-                        x1 + 2 + indent,
-                        y1 + mid_y + qtr_mod,
-                        x1 + 2 + half_mod + indent,
-                        y1 + mid_y - qtr_mod,
-                        x1 + 2 + mod + indent,
-                        y1 + mid_y + qtr_mod,
-                    )
-                # right pointing arrow
-                else:
-                    points = (
-                        x1 + half_mod + indent,
-                        y1 + mid_y - half_mod + 1,
-                        x1 + mod + indent - 1,
-                        y1 + mid_y,
-                        x1 + half_mod + indent,
-                        y1 + mid_y + half_mod - 1,
-                    )
+            if open_:
+                points = (
+                    x2 - 3 - mod,
+                    y1 + mid_y + qtr_mod,
+                    x2 - 3 - half_mod,
+                    y1 + mid_y - qtr_mod,
+                    x2 - 3,
+                    y1 + mid_y + qtr_mod,
+                )
             else:
-                if open_:
-                    points = (
-                        x2 - 3 - mod,
-                        y1 + mid_y + qtr_mod,
-                        x2 - 3 - half_mod,
-                        y1 + mid_y - qtr_mod,
-                        x2 - 3,
-                        y1 + mid_y + qtr_mod,
-                    )
-                else:
-                    points = (
-                        x2 - 3 - mod,
-                        y1 + mid_y - qtr_mod,
-                        x2 - 3 - half_mod,
-                        y1 + mid_y + qtr_mod,
-                        x2 - 3,
-                        y1 + mid_y - qtr_mod,
-                    )
+                points = (
+                    x2 - 3 - mod,
+                    y1 + mid_y - qtr_mod,
+                    x2 - 3 - half_mod,
+                    y1 + mid_y + qtr_mod,
+                    x2 - 3,
+                    y1 + mid_y - qtr_mod,
+                )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
                 self.coords(t, points)
@@ -1352,12 +1384,9 @@ class RowIndex(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_line(
+                t = self.create_polygon(
                     points,
                     fill=fill,
-                    width=2,
-                    capstyle=tk.ROUND,
-                    joinstyle=tk.ROUND,
                     tag=tag,
                 )
             self.disp_dropdown[t] = True
@@ -1428,6 +1457,8 @@ class RowIndex(tk.Canvas):
         self.disp_dropdown = {}
         self.hidd_checkbox.update(self.disp_checkbox)
         self.disp_checkbox = {}
+        self.hidd_tree_arrow.update(self.disp_tree_arrow)
+        self.disp_tree_arrow = {}
         self.visible_row_dividers = {}
         draw_y = self.MT.row_positions[start_row]
         xend = self.current_width - 6
@@ -1484,7 +1515,15 @@ class RowIndex(tk.Canvas):
             if rbotgridln - rtopgridln < self.MT.index_txt_height:
                 continue
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
-            fill, dd_drawn = self.redraw_highlight_get_text_fg(rtopgridln, rbotgridln, r, c_2, c_3, selections, datarn)
+            fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
+                rtopgridln,
+                rbotgridln,
+                r,
+                c_2,
+                c_3,
+                selections,
+                datarn,
+            )
 
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
@@ -1584,20 +1623,16 @@ class RowIndex(tk.Canvas):
                 if align == "w":
                     draw_x += self.MT.index_txt_height + 1
                 indent = self.get_treeview_indent(iid)
-                draw_x += indent
+                draw_x += indent + 4
                 if self.tree[iid].children:
-                    self.redraw_dropdown(
+                    self.redraw_tree_arrow(
                         0,
                         rtopgridln,
-                        self.current_width - 1,
-                        rbotgridln - 1,
-                        fill=fill,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=False,
-                        draw_arrow=True,
-                        open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
+                        r=r,
+                        fill=tree_arrow_fg,
+                        tag="ta",
                         indent=indent,
+                        open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
                     )
             lns = self.get_valid_cell_data_as_str(datarn, fix=False)
             if not lns:
@@ -1677,7 +1712,14 @@ class RowIndex(tk.Canvas):
                         draw_y += self.MT.index_xtra_lines_increment
                         if draw_y + self.MT.index_half_txt_height - 1 > rbotgridln:
                             break
-        for dct in (self.hidd_text, self.hidd_high, self.hidd_grid, self.hidd_dropdown, self.hidd_checkbox):
+        for dct in (
+            self.hidd_text,
+            self.hidd_high,
+            self.hidd_grid,
+            self.hidd_dropdown,
+            self.hidd_checkbox,
+            self.hidd_tree_arrow,
+        ):
             for iid, showing in dct.items():
                 if showing:
                     self.itemconfig(iid, state="hidden")
@@ -2189,7 +2231,7 @@ class RowIndex(tk.Canvas):
             self.fix_index(datarn)
             if not check_input_valid or self.input_valid_for_cell(datarn, value):
                 if self.MT.undo_enabled and undo:
-                    self.MT.undo_stack.append(ev_stack_dict(event_data))
+                    self.MT.undo_stack.append(pickled_event_dict(event_data))
                 self.set_cell_data(datarn=datarn, value=value)
                 edited = True
         if edited and cell_resize and self.PAR.ops.cell_auto_resize_enabled:

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/sheet.py

@@ -19,7 +19,6 @@ from .functions import (
     del_named_span_options,
     del_named_span_options_nested,
     dropdown_search_function,
-    ev_stack_dict,
     event_dict,
     fix_format_kwargs,
     get_checkbox_dict,
@@ -30,6 +29,7 @@ from .functions import (
     is_iterable,
     key_to_span,
     num2alpha,
+    pickled_event_dict,
     pop_positions,
     set_align,
     set_readonly,
@@ -1050,29 +1050,23 @@ class Sheet(tk.Frame):
             canvas.basic_bindings(enable)
         return self
 
-    def cut(self, event: object = None) -> Sheet:
-        self.MT.ctrl_x(event)
-        return self
+    def cut(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+        return self.MT.ctrl_x(event, validation)
 
-    def copy(self, event: object = None) -> Sheet:
-        self.MT.ctrl_c(event)
-        return self
+    def copy(self, event: object = None) -> None | EventDataDict:
+        return self.MT.ctrl_c(event)
 
-    def paste(self, event: object = None) -> Sheet:
-        self.MT.ctrl_v(event)
-        return self
+    def paste(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+        return self.MT.ctrl_v(event, validation)
 
-    def delete(self, event: object = None) -> Sheet:
-        self.MT.delete_key(event)
-        return self
+    def delete(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+        return self.MT.delete_key(event, validation)
 
-    def undo(self, event: object = None) -> Sheet:
-        self.MT.undo(event)
-        return self
+    def undo(self, event: object = None) -> None | EventDataDict:
+        return self.MT.undo(event)
 
-    def redo(self, event: object = None) -> Sheet:
-        self.MT.redo(event)
-        return self
+    def redo(self, event: object = None) -> None | EventDataDict:
+        return self.MT.redo(event)
 
     def has_focus(
         self,
@@ -1801,7 +1795,7 @@ class Sheet(tk.Frame):
             or event_data["added"]["rows"]
         ):
             if undo is True or (undo is None and span.undo):
-                self.MT.undo_stack.append(ev_stack_dict(event_data))
+                self.MT.undo_stack.append(pickled_event_dict(event_data))
             if emit_event is True or (emit_event is None and span.emit_event):
                 self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -1840,7 +1834,7 @@ class Sheet(tk.Frame):
                     event_data = clear_t(r, c, quick_tval(r, c), event_data)
         if event_data["cells"]["table"] or event_data["cells"]["header"] or event_data["cells"]["index"]:
             if undo is True or (undo is None and span.undo):
-                self.MT.undo_stack.append(ev_stack_dict(event_data))
+                self.MT.undo_stack.append(pickled_event_dict(event_data))
             if emit_event is True or (emit_event is None and span.emit_event):
                 self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2009,7 +2003,7 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2104,7 +2098,7 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2178,7 +2172,7 @@ class Sheet(tk.Frame):
                 event_data,
             )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.MT.deselect("all", redraw=False)
@@ -2219,7 +2213,7 @@ class Sheet(tk.Frame):
                 event_data,
             )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.MT.deselect("all", redraw=False)
@@ -2320,7 +2314,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2348,7 +2342,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2375,7 +2369,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2402,7 +2396,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -3446,12 +3440,22 @@ class Sheet(tk.Frame):
 
     delete_row_position = del_row_position
 
+    def del_row_positions(self, idxs: Iterator[int] | None = None) -> Sheet:
+        self.MT.del_row_positions(idxs=idxs)
+        self.set_refresh_timer()
+        return self
+
     def del_column_position(self, idx: int, deselect_all: bool = False) -> Sheet:
         self.MT.del_col_position(idx, deselect_all=deselect_all)
         return self
 
     delete_column_position = del_column_position
 
+    def del_column_positions(self, idxs: Iterator[int] | None = None) -> Sheet:
+        self.MT.del_col_positions(idxs=idxs)
+        self.set_refresh_timer()
+        return self
+
     def insert_column_position(
         self,
         idx: Literal["end"] | int = "end",
@@ -4253,27 +4257,27 @@ class Sheet(tk.Frame):
             target = self.CH.cell_options
         if key is None:
             return target
-        return {k: v for k, v in target.items() if key in v}
+        return {k: v[key] for k, v in target.items() if key in v}
 
     def get_row_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.MT.row_options
-        return {k: v for k, v in self.MT.row_options.items() if key in v}
+        return {k: v[key] for k, v in self.MT.row_options.items() if key in v}
 
     def get_column_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.MT.col_options
-        return {k: v for k, v in self.MT.col_options.items() if key in v}
+        return {k: v[key] for k, v in self.MT.col_options.items() if key in v}
 
     def get_index_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.RI.cell_options
-        return {k: v for k, v in self.RI.cell_options.items() if key in v}
+        return {k: v[key] for k, v in self.RI.cell_options.items() if key in v}
 
     def get_header_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.CH.cell_options
-        return {k: v for k, v in self.CH.cell_options.items() if key in v}
+        return {k: v[key] for k, v in self.CH.cell_options.items() if key in v}
 
     def del_out_of_bounds_options(self) -> Sheet:
         maxc = self.total_columns()

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/sheet_options.py

@@ -149,6 +149,9 @@ def new_sheet_options() -> DotDict:
             "table_bg": theme_light_blue["table_bg"],
             "table_grid_fg": theme_light_blue["table_grid_fg"],
             "table_fg": theme_light_blue["table_fg"],
+            "tree_arrow_fg": theme_light_blue["tree_arrow_fg"],
+            "selected_cells_tree_arrow_fg": theme_light_blue["selected_cells_tree_arrow_fg"],
+            "selected_rows_tree_arrow_fg": theme_light_blue["selected_rows_tree_arrow_fg"],
             "table_selected_box_cells_fg": theme_light_blue["table_selected_box_cells_fg"],
             "table_selected_box_rows_fg": theme_light_blue["table_selected_box_rows_fg"],
             "table_selected_box_columns_fg": theme_light_blue["table_selected_box_columns_fg"],

{tksheet-7.1.12 → tksheet-7.1.21}/tksheet/themes.py

@@ -46,6 +46,9 @@ theme_light_blue: dict[str, str] = DotDict({
     "table_selected_columns_border_fg": "#0B57D0",
     "table_selected_columns_bg": "#E6EFFD",
     "table_selected_columns_fg": "black",
+    "tree_arrow_fg": "#C4C7C5",
+    "selected_cells_tree_arrow_fg": "#D3E3FD",
+    "selected_rows_tree_arrow_fg": "#FFFFFF",
     "vertical_scroll_background": "#FFFFFF",
     "horizontal_scroll_background": "#FFFFFF",
     "vertical_scroll_troughcolor": "#f9fbfd",
@@ -118,6 +121,9 @@ theme_light_green: dict[str, str] = DotDict({
     "table_selected_columns_border_fg": "#217346",
     "table_selected_columns_bg": "#E3E3E3",
     "table_selected_columns_fg": "black",
+    "tree_arrow_fg": "#ababab",
+    "selected_cells_tree_arrow_fg": "#217346",
+    "selected_rows_tree_arrow_fg": "#217346",
     "vertical_scroll_background": "#FFFFFF",
     "horizontal_scroll_background": "#FFFFFF",
     "vertical_scroll_troughcolor": "#f1f1f1",
@@ -190,6 +196,9 @@ theme_dark: dict[str, str] = DotDict({
     "table_selected_columns_border_fg": "#4489F7",
     "table_selected_columns_bg": "#404040",
     "table_selected_columns_fg": "#F7F7F7",
+    "tree_arrow_fg": "#8C8C8C",
+    "selected_cells_tree_arrow_fg": "#6aa2fc",
+    "selected_rows_tree_arrow_fg": "white",
     "vertical_scroll_background": "#3b3b3d",
     "horizontal_scroll_background": "#3b3b3d",
     "vertical_scroll_troughcolor": "#000000",
@@ -262,6 +271,9 @@ theme_black: dict[str, str] = DotDict({
     "table_selected_columns_border_fg": "#FBB86C",
     "table_selected_columns_bg": "#404040",
     "table_selected_columns_fg": "#F7F7F7",
+    "tree_arrow_fg": "#8C8C8C",
+    "selected_cells_tree_arrow_fg": "#8C8C8C",
+    "selected_rows_tree_arrow_fg": "#8C8C8C",
     "vertical_scroll_background": "#3b3a39",
     "horizontal_scroll_background": "#3b3a39",
     "vertical_scroll_troughcolor": "#000000",

{tksheet-7.1.12 → tksheet-7.1.21/tksheet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.1.12
+Version: 7.1.21
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -42,7 +42,7 @@ License-File: LICENSE.txt
 
 # tksheet
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8+-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![GitHub Release Date](https://img.shields.io/github/release-date-pre/ragardner/tksheet.svg)](https://github.com/ragardner/tksheet/releases) [![Downloads](https://img.shields.io/pypi/dm/tksheet.svg)](https://pypi.org/project/tksheet/)