tksheet 7.1.11__py3-none-any.whl → 7.1.20__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.1.11"
+__version__ = "7.1.20"
 
 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/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)
@@ -1953,6 +1959,7 @@ class ColumnHeaders(tk.Canvas):
             self.dropdown.window.reset(**reset_kwargs)
             self.itemconfig(self.dropdown.canvas_id, state="normal")
             self.coords(self.dropdown.canvas_id, self.MT.col_positions[c], ypos)
+            self.dropdown.window.tkraise()
         else:
             self.dropdown.window = self.PAR.dropdown_class(
                 self.winfo_toplevel(),
@@ -2090,7 +2097,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/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:
@@ -204,8 +220,6 @@ def get_dropdown_kwargs(
 def get_dropdown_dict(**kwargs) -> dict:
     return {
         "values": kwargs["values"],
-        "window": "no dropdown open",
-        "canvas_id": "no dropdown open",
         "select_function": kwargs["selection_function"],
         "modified_function": kwargs["modified_function"],
         "search_function": kwargs["search_function"],
@@ -408,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)
@@ -1295,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/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,
@@ -91,6 +92,10 @@ from .text_editor import (
 )
 from .vars import (
     USER_OS,
+    bind_add_columns,
+    bind_add_rows,
+    bind_del_columns,
+    bind_del_rows,
     ctrl_key,
     rc_binding,
     symbols_set,
@@ -359,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),
@@ -381,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),
@@ -396,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])
@@ -406,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])
@@ -491,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]
@@ -513,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(
@@ -551,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(
@@ -582,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,
@@ -603,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,
@@ -616,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())
@@ -629,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
         ):
@@ -656,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):
@@ -745,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),
@@ -781,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
@@ -819,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
@@ -835,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,
@@ -857,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(
@@ -875,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,
@@ -886,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):
@@ -1366,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)
@@ -1446,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"],
@@ -1611,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,
@@ -2544,19 +2583,19 @@ class MainTable(tk.Canvas):
             self.undo_enabled = True
             self._tksheet_bind("undo_bindings", self.undo)
             self._tksheet_bind("redo_bindings", self.redo)
-        if binding in ("all", "rc_delete_column"):
+        if binding in bind_del_columns:
             self.rc_delete_column_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
-        if binding in ("all", "rc_delete_row"):
+        if binding in bind_del_rows:
             self.rc_delete_row_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
-        if binding in ("all", "rc_insert_column"):
+        if binding in bind_add_columns:
             self.rc_insert_column_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
-        if binding in ("all", "rc_insert_row"):
+        if binding in bind_add_rows:
             self.rc_insert_row_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
@@ -2615,25 +2654,16 @@ class MainTable(tk.Canvas):
             self.RI.row_selection_enabled = False
         if binding in ("all", "row_drag_and_drop", "move_rows"):
             self.RI.drag_and_drop_enabled = False
-        if binding in ("all", "rc_delete_column"):
+        if binding in bind_del_columns:
             self.rc_delete_column_enabled = False
-            self.rc_popup_menus_enabled = False
-            self.rc_select_enabled = False
-        if binding in ("all", "rc_delete_row"):
+        if binding in bind_del_rows:
             self.rc_delete_row_enabled = False
-            self.rc_popup_menus_enabled = False
-            self.rc_select_enabled = False
-        if binding in ("all", "rc_insert_column"):
+        if binding in bind_add_columns:
             self.rc_insert_column_enabled = False
-            self.rc_popup_menus_enabled = False
-            self.rc_select_enabled = False
-        if binding in ("all", "rc_insert_row"):
+        if binding in bind_add_rows:
             self.rc_insert_row_enabled = False
-            self.rc_popup_menus_enabled = False
-            self.rc_select_enabled = False
         if binding in ("all", "right_click_popup_menu", "rc_popup_menu"):
             self.rc_popup_menus_enabled = False
-            self.rc_select_enabled = False
         if binding in ("all", "right_click_select", "rc_select"):
             self.rc_select_enabled = False
         if binding in ("all", "edit_cell", "edit_bindings", "edit"):
@@ -2738,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):
@@ -3720,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)
 
@@ -3732,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",
@@ -4188,6 +4215,7 @@ class MainTable(tk.Canvas):
         create_ops: bool = True,
         create_selections: bool = True,
         add_row_positions: bool = True,
+        push_ops: bool = True,
     ) -> EventDataDict:
         self.saved_column_widths = {}
         saved_displayed_columns = list(self.displayed_columns)
@@ -4235,10 +4263,11 @@ class MainTable(tk.Canvas):
             )
         if isinstance(self._headers, list):
             self._headers = insert_items(self._headers, header, self.CH.fix_header)
-        self.adjust_options_post_add_columns(
-            cols=tuple(reversed(columns)),
-            create_ops=create_ops,
-        )
+        if push_ops:
+            self.adjust_options_post_add_columns(
+                cols=tuple(reversed(columns)),
+                create_ops=create_ops,
+            )
         if create_selections:
             self.deselect("all")
             for boxst, boxend in consecutive_ranges(tuple(reversed(column_widths))):
@@ -4304,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)
@@ -4319,6 +4348,7 @@ class MainTable(tk.Canvas):
         create_ops: bool = True,
         create_selections: bool = True,
         add_col_positions: bool = True,
+        push_ops: bool = True,
     ) -> EventDataDict:
         self.saved_row_heights = {}
         saved_displayed_rows = list(self.displayed_rows)
@@ -4364,10 +4394,11 @@ class MainTable(tk.Canvas):
                     (self.PAR.ops.default_column_width for i in range(len(self.col_positions) - 1, maxcn + 1)),
                 )
             )
-        self.adjust_options_post_add_rows(
-            rows=tuple(reversed(rows)),
-            create_ops=create_ops,
-        )
+        if push_ops:
+            self.adjust_options_post_add_rows(
+                rows=tuple(reversed(rows)),
+                create_ops=create_ops,
+            )
         if create_selections:
             self.deselect("all")
             for boxst, boxend in consecutive_ranges(tuple(reversed(row_heights))):
@@ -4433,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)
@@ -4605,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)
@@ -4659,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)
@@ -6752,6 +6783,7 @@ class MainTable(tk.Canvas):
         win_w = self.col_positions[c + 1] - self.col_positions[c] + 1
         if anchor == "nw":
             if kwargs["state"] == "normal":
+                self.text_editor.window.update_idletasks()
                 ypos = self.row_positions[r] + self.text_editor.window.winfo_height() - 1
             else:
                 ypos = self.row_positions[r + 1]
@@ -6770,8 +6802,9 @@ class MainTable(tk.Canvas):
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
-            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, self.col_positions[c], ypos)
+            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
+            self.dropdown.window.tkraise()
         else:
             self.dropdown.window = self.PAR.dropdown_class(
                 self.winfo_toplevel(),
@@ -6969,7 +7002,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/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,
 )
@@ -851,7 +851,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)
@@ -2029,6 +2029,7 @@ class RowIndex(tk.Canvas):
         win_w = self.current_width + 1
         if anchor == "nw":
             if kwargs["state"] == "normal":
+                self.text_editor.window.update_idletasks()
                 ypos = self.MT.row_positions[r] + self.text_editor.window.winfo_height() - 1
             else:
                 ypos = self.MT.row_positions[r + 1]
@@ -2049,6 +2050,7 @@ class RowIndex(tk.Canvas):
             self.dropdown.window.reset(**reset_kwargs)
             self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, 0, ypos)
+            self.dropdown.window.tkraise()
         else:
             self.dropdown.window = self.PAR.dropdown_class(
                 self.winfo_toplevel(),
@@ -2187,7 +2189,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/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)
@@ -1939,6 +1933,7 @@ class Sheet(tk.Frame):
         emit_event: bool = False,
         create_selections: bool = True,
         add_column_widths: bool = True,
+        push_ops: bool = True,
         redraw: bool = True,
     ) -> EventDataDict:
         total_cols = None
@@ -2005,9 +2000,10 @@ class Sheet(tk.Frame):
                 selected=self.MT.selected,
             ),
             create_selections=create_selections,
+            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)
@@ -2024,6 +2020,7 @@ class Sheet(tk.Frame):
         emit_event: bool = False,
         create_selections: bool = True,
         add_row_heights: bool = True,
+        push_ops: bool = True,
         redraw: bool = True,
     ) -> EventDataDict:
         old_total = self.MT.equalize_data_row_lengths()
@@ -2098,9 +2095,10 @@ class Sheet(tk.Frame):
                 selected=self.MT.selected,
             ),
             create_selections=create_selections,
+            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)
@@ -2174,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)
@@ -2215,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)
@@ -2316,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)
@@ -2344,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)
@@ -2371,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)
@@ -2398,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)
@@ -2571,7 +2569,7 @@ class Sheet(tk.Frame):
         self.MT.open_dropdown_window(r, c)
         return self
 
-    def close_dropdown(self, r: int, c: int) -> Sheet:
+    def close_dropdown(self, r: int | None = None, c: int | None = None) -> Sheet:
         self.MT.close_dropdown_window(r, c)
         return self
 
@@ -2579,7 +2577,7 @@ class Sheet(tk.Frame):
         self.CH.open_dropdown_window(c)
         return self
 
-    def close_header_dropdown(self, c: int) -> Sheet:
+    def close_header_dropdown(self, c: int | None = None) -> Sheet:
         self.CH.close_dropdown_window(c)
         return self
 
@@ -2587,7 +2585,7 @@ class Sheet(tk.Frame):
         self.RI.open_dropdown_window(r)
         return self
 
-    def close_index_dropdown(self, r: int) -> Sheet:
+    def close_index_dropdown(self, r: int | None = None) -> Sheet:
         self.RI.close_dropdown_window(r)
         return self
 
@@ -3442,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",
@@ -4249,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()
@@ -4470,6 +4478,7 @@ class Sheet(tk.Frame):
         iid_column: int,
         parent_column: int,
         text_column: None | int = None,
+        push_ops: bool = False,
     ) -> Sheet:
         if text_column is None:
             text_column = iid_column
@@ -4518,6 +4527,7 @@ class Sheet(tk.Frame):
             row_index=True,
             create_selections=False,
             fill=False,
+            push_ops=push_ops,
         )
         self.RI.tree_rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         self.hide_rows(
@@ -6231,8 +6241,8 @@ class Sheet(tk.Frame):
         kwargs = self.RI.get_cell_kwargs(r_, key="dropdown")
         if kwargs:
             kwargs["values"] = values
-            if self.RI.current_dropdown_window is not None:
-                self.RI.current_dropdown_window.values(values)
+            if self.RI.dropdown.open:
+                self.RI.dropdown.window.values(values)
             if set_value is not None:
                 self.MT.row_index(newindex=set_value, index=r_)
                 # here
@@ -6454,7 +6464,7 @@ class Dropdown(Sheet):
         width: int | None = None,
         height: int | None = None,
         font: None | tuple[str, int, str] = None,
-        outline_thickness: int = 1,
+        outline_thickness: int = 2,
         values: list[object] = [],
         close_dropdown_window: Callable | None = None,
         search_function: Callable = dropdown_search_function,
@@ -6512,6 +6522,7 @@ class Dropdown(Sheet):
         align: str,
         values: list[object] | None = None,
     ) -> None:
+        self.deselect(redraw=False)
         self.r = r
         self.c = c
         self.row = -1

tksheet/themes.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-theme_light_blue: dict[str, str] = {
+from .other_classes import DotDict
+
+theme_light_blue: dict[str, str] = DotDict({
     "popup_menu_fg": "#000000",
     "popup_menu_bg": "#FFFFFF",
     "popup_menu_highlight_bg": "#DCDEE0",
@@ -70,9 +72,9 @@ theme_light_blue: dict[str, str] = {
     "horizontal_scroll_not_active_fg": "#DADCE0",
     "vertical_scroll_pressed_fg": "#bdc1c6",
     "horizontal_scroll_pressed_fg": "#bdc1c6",
-}
+})
 
-theme_light_green: dict[str, str] = {
+theme_light_green: dict[str, str] = DotDict({
     "popup_menu_fg": "#000000",
     "popup_menu_bg": "#FFFFFF",
     "popup_menu_highlight_bg": "#DCDEE0",
@@ -142,9 +144,9 @@ theme_light_green: dict[str, str] = {
     "horizontal_scroll_not_active_fg": "#c1c1c1",
     "vertical_scroll_pressed_fg": "#707070",
     "horizontal_scroll_pressed_fg": "#707070",
-}
+})
 
-theme_dark: dict[str, str] = {
+theme_dark: dict[str, str] = DotDict({
     "popup_menu_fg": "white",
     "popup_menu_bg": "gray15",
     "popup_menu_highlight_bg": "gray40",
@@ -214,9 +216,9 @@ theme_dark: dict[str, str] = {
     "horizontal_scroll_not_active_fg": "#3b3b3d",
     "vertical_scroll_pressed_fg": "#a0a0a0",
     "horizontal_scroll_pressed_fg": "#a0a0a0",
-}
+})
 
-theme_black: dict[str, str] = {
+theme_black: dict[str, str] = DotDict({
     "popup_menu_fg": "white",
     "popup_menu_bg": "gray15",
     "popup_menu_highlight_bg": "gray40",
@@ -286,9 +288,9 @@ theme_black: dict[str, str] = {
     "horizontal_scroll_not_active_fg": "#3b3a39",
     "vertical_scroll_pressed_fg": "#a0a0a0",
     "horizontal_scroll_pressed_fg": "#a0a0a0",
-}
+})
 
-theme_dark_blue: dict[str, str] = theme_black.copy()
+theme_dark_blue: dict[str, str] = DotDict(theme_black.copy())
 theme_dark_blue["header_fg"] = "#6ACAD8"
 theme_dark_blue["header_selected_cells_fg"] = "#6ACAD8"
 theme_dark_blue["index_fg"] = "#6ACAD8"
@@ -303,7 +305,7 @@ theme_dark_blue["index_selected_rows_bg"] = "#6ACAD8"
 theme_dark_blue["table_selected_rows_border_fg"] = "#6ACAD8"
 theme_dark_blue["table_selected_columns_border_fg"] = "#6ACAD8"
 
-theme_dark_green: dict[str, str] = theme_black.copy()
+theme_dark_green: dict[str, str] = DotDict(theme_black.copy())
 theme_dark_green["header_fg"] = "#66FFBF"
 theme_dark_green["header_selected_cells_fg"] = "#66FFBF"
 theme_dark_green["index_fg"] = "#66FFBF"

tksheet/vars.py

@@ -9,23 +9,28 @@ symbols_set: set[str] = set("""!#$%&'()*+,-./:;"@[]^_`{|}~>?= \\""")
 nonelike: set[object] = {None, "none", ""}
 truthy: set[object] = {True, "true", "t", "yes", "y", "on", "1", 1, 1.0}
 falsy: set[object] = {False, "false", "f", "no", "n", "off", "0", 0, 0.0}
+
 val_modifying_options: set[str, str, str] = {"checkbox", "format", "dropdown"}
-named_span_types = (
+
+named_span_types: set[str] = {
     "format",
     "highlight",
     "dropdown",
     "checkbox",
     "readonly",
     "align",
-)
+}
+
 emitted_events: set[str] = {
     "<<SheetModified>>",
     "<<SheetRedrawn>>",
     "<<SheetSelect>>",
 }
+
 backwards_compatibility_keys: dict[str, str] = {
     "font": "table_font",
 }
+
 text_editor_to_unbind: tuple[str] = (
     "<Alt-Return>",
     "<Alt-KP_Enter>",
@@ -36,6 +41,7 @@ text_editor_to_unbind: tuple[str] = (
     "<FocusOut>",
     "<Escape>",
 )
+
 scrollbar_options_keys: set[str] = {
     "vertical_scroll_background",
     "horizontal_scroll_background",
@@ -70,3 +76,47 @@ scrollbar_options_keys: set[str] = {
     "vertical_scroll_pressed_fg",
     "horizontal_scroll_pressed_fg",
 }
+
+bind_add_columns: set[str] = {
+    "all",
+    "rc_insert_column",
+    "insert_column",
+    "add_column",
+    "insert_columns",
+    "add_columns",
+    "insert column",
+    "add column",
+}
+
+bind_del_columns: set[str] = {
+    "all",
+    "rc_delete_column",
+    "delete_column",
+    "del_column",
+    "delete_columns",
+    "del_columns",
+    "delete columns",
+    "del columns",
+}
+
+bind_add_rows: set[str] = {
+    "all",
+    "rc_insert_row",
+    "insert_row",
+    "add_row",
+    "insert_rows",
+    "add_rows",
+    "insert row",
+    "add row",
+}
+
+bind_del_rows: set[str] = {
+    "all",
+    "rc_delete_row",
+    "delete_row",
+    "del_row",
+    "delete_rows",
+    "del_rows",
+    "delete rows",
+    "del rows",
+}

{tksheet-7.1.11.dist-info → tksheet-7.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.1.11
+Version: 7.1.20
 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.20.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=n15iE0L6zsiYW5IhLE5m3yb867QM9gl2SBrdQk_bjLc,2044
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=Kzu_nIMt3oFZO6F00iHBmjv5L0STsVN7Gc34wzwKDJ4,100785
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=Vm_tCPCaos8C_or_70OGpSrXKmFnE8OxODchfrUJBMM,40281
+tksheet/main_table.py,sha256=DrRC3WLGiS6JkAS4Ir-8c1n_4C4l4Coe6jb45Uceekc,320235
+tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
+tksheet/row_index.py,sha256=57cWphhUGsghh9UiHtAHi0m9S403-9MrYiMtTzK7h8E,106014
+tksheet/sheet.py,sha256=TLWV_C-C3XiweHbPdskCnT9v6Zr6Dxym2Ijv-CULgWs,260302
+tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
+tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
+tksheet/themes.py,sha256=0XY97zB9e26edyxMWutofNarNon8Pp5lpprHYeL_4b0,13490
+tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=Nb0mhxJt-SXipi3cE9J9Ea1H1iPqC8PRvUR9CqqMlVA,3062
+tksheet-7.1.20.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.1.20.dist-info/METADATA,sha256=C_WIADFKe41LVlFXKzK7QFO6vQIi0ym2Uk40WiNx9zM,6032
+tksheet-7.1.20.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.1.20.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.1.20.dist-info/RECORD,,

tksheet-7.1.11.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=w1YOGIZHF7gjLLEWIH-XLK-ftzuYgSiLTvMUg6ORTYM,2014
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=6yYncfnKKKlSGTln35eP74e2Oom9A2XX85SrIsDeq9g,100452
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=ytmHQtSa8cN6dKYLFra5G0393-4sU7bivvT_U4wxksI,39697
-tksheet/main_table.py,sha256=1K-JpLixwx_cnqp5IXeghRWyzaMdQiP6BPm6QVOtfzs,319012
-tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
-tksheet/row_index.py,sha256=BnQF-lxH50MfPWlXW94oYSEJXoPewoX29VS7j0X1Jwc,105895
-tksheet/sheet.py,sha256=dvYtZpNJsu6WfjdUKt6RKcwKeDY5c7wZ-tQfL1rjglQ,259484
-tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
-tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
-tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
-tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=8Qxas-m5nU-yMaeAweO4Z30FM9cOQoRTiOsH4kgZp5s,2288
-tksheet-7.1.11.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.1.11.dist-info/METADATA,sha256=SRDk-Is6G0UmdJ6PAMgPzkwumb4PLOFETNplec7bkbE,6014
-tksheet-7.1.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.1.11.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.1.11.dist-info/RECORD,,