tksheet 7.2.10__tar.gz → 7.2.12__tar.gz

{tksheet-7.2.10/tksheet.egg-info → tksheet-7.2.12}/PKG-INFO

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

{tksheet-7.2.10 → tksheet-7.2.12}/pyproject.toml

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

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/__init__.py

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

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/column_headers.py

@@ -481,7 +481,6 @@ class ColumnHeaders(tk.Canvas):
             if y < self.MT.min_header_height:
                 y = int(self.MT.min_header_height)
             self.new_col_height = y
-            self.create_resize_line(x1, y, x2, y, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rhl")
         elif self.MT.identify_col(x=event.x, allow_end=False) is None:
             self.MT.deselect("all")
         elif self.col_selection_enabled and self.rsz_w is None and self.rsz_h is None:
@@ -540,22 +539,21 @@ class ColumnHeaders(tk.Canvas):
                     fill=self.PAR.ops.resizing_line_fg,
                     tag="rwl2",
                 )
+                self.drag_width_resize()
         elif self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             evy = event.y
-            self.hide_resize_and_ctrl_lines(ctrl_lines=False)
             if evy > self.current_height:
                 y = self.MT.canvasy(evy - self.current_height)
                 if evy > self.MT.max_header_height:
                     evy = int(self.MT.max_header_height)
                     y = self.MT.canvasy(evy - self.current_height)
                 self.new_col_height = evy
-                self.MT.create_resize_line(x1, y, x2, y, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rhl")
             else:
                 y = evy
                 if y < self.MT.min_header_height:
                     y = int(self.MT.min_header_height)
                 self.new_col_height = y
-                self.create_resize_line(x1, y, x2, y, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rhl")
+            self.drag_height_resize()
         elif (
             self.drag_and_drop_enabled
             and self.col_selection_enabled
@@ -602,6 +600,10 @@ class ColumnHeaders(tk.Canvas):
                 self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
         try_binding(self.extra_b1_motion_func, event)
 
+    def drag_height_resize(self) -> None:
+        self.set_height(self.new_col_height, set_TL=True)
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+
     def get_b1_motion_box(self, start_col: int, end_col: int) -> tuple[int, int, int, int, Literal["columns"]]:
         if end_col >= start_col:
             return 0, start_col, len(self.MT.row_positions) - 1, end_col + 1, "columns"
@@ -779,6 +781,32 @@ class ColumnHeaders(tk.Canvas):
             return True
         return False
 
+    def drag_width_resize(self) -> None:
+        new_col_pos = int(self.coords("rwl")[0])
+        old_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
+        size = new_col_pos - self.MT.col_positions[self.rsz_w - 1]
+        if size < self.MT.min_column_width:
+            new_col_pos = ceil(self.MT.col_positions[self.rsz_w - 1] + self.MT.min_column_width)
+        elif size > self.MT.max_column_width:
+            new_col_pos = floor(self.MT.col_positions[self.rsz_w - 1] + self.MT.max_column_width)
+        increment = new_col_pos - self.MT.col_positions[self.rsz_w]
+        self.MT.col_positions[self.rsz_w + 1 :] = [
+            e + increment for e in islice(self.MT.col_positions, self.rsz_w + 1, None)
+        ]
+        self.MT.col_positions[self.rsz_w] = new_col_pos
+        new_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
+        self.MT.allow_auto_resize_columns = False
+        self.MT.recreate_all_selection_boxes()
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        if self.column_width_resize_func is not None and old_width != new_width:
+            self.column_width_resize_func(
+                event_dict(
+                    name="resize",
+                    sheet=self.PAR.name,
+                    resized_columns={self.rsz_w - 1: {"old_size": old_width, "new_size": new_width}},
+                )
+            )
+
     def b1_release(self, event: object) -> None:
         if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
@@ -795,37 +823,12 @@ class ColumnHeaders(tk.Canvas):
             self.being_drawn_item = None
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
+            self.drag_width_resize()
             self.currently_resizing_width = False
-            new_col_pos = int(self.coords("rwl")[0])
             self.hide_resize_and_ctrl_lines(ctrl_lines=False)
-            old_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
-            size = new_col_pos - self.MT.col_positions[self.rsz_w - 1]
-            if size < self.MT.min_column_width:
-                new_col_pos = ceil(self.MT.col_positions[self.rsz_w - 1] + self.MT.min_column_width)
-            elif size > self.MT.max_column_width:
-                new_col_pos = floor(self.MT.col_positions[self.rsz_w - 1] + self.MT.max_column_width)
-            increment = new_col_pos - self.MT.col_positions[self.rsz_w]
-            self.MT.col_positions[self.rsz_w + 1 :] = [
-                e + increment for e in islice(self.MT.col_positions, self.rsz_w + 1, len(self.MT.col_positions))
-            ]
-            self.MT.col_positions[self.rsz_w] = new_col_pos
-            new_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
-            self.MT.allow_auto_resize_columns = False
-            self.MT.recreate_all_selection_boxes()
-            self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-            if self.column_width_resize_func is not None and old_width != new_width:
-                self.column_width_resize_func(
-                    event_dict(
-                        name="resize",
-                        sheet=self.PAR.name,
-                        resized_columns={self.rsz_w - 1: {"old_size": old_width, "new_size": new_width}},
-                    )
-                )
         elif self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             self.currently_resizing_height = False
-            self.hide_resize_and_ctrl_lines(ctrl_lines=False)
-            self.set_height(self.new_col_height, set_TL=True)
-            self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+            self.drag_height_resize()
         elif (
             self.drag_and_drop_enabled
             and self.col_selection_enabled
@@ -2173,7 +2176,16 @@ class ColumnHeaders(tk.Canvas):
         )
         edited = False
         if isinstance(self.MT._headers, int):
-            edited = self.MT.set_cell_data_undo(r=self.MT._headers, c=c, datacn=datacn, value=value, undo=True)
+            disprn = self.MT.try_disprn(self.MT._headers)
+            edited = self.MT.set_cell_data_undo(
+                r=disprn if isinstance(disprn, int) else 0,
+                c=c,
+                datarn=self.MT._headers,
+                datacn=datacn,
+                value=value,
+                undo=True,
+                cell_resize=isinstance(disprn, int),
+            )
         else:
             self.fix_header(datacn)
             if not check_input_valid or self.input_valid_for_cell(datacn, value):

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/functions.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
-import bisect
 import csv
 import io
 import pickle
 import re
 import tkinter as tk
 import zlib
+from bisect import (
+    bisect_left,
+)
 from collections import deque
 from collections.abc import (
     Callable,
@@ -208,6 +210,16 @@ def len_to_idx(n: int) -> int:
     return n - 1
 
 
+def b_index(sorted_seq: Sequence[int], num_to_index: int) -> int:
+    """
+    Designed to be a faster way of finding the index of an int
+    in a sorted list of ints than list.index()
+    """
+    if (idx := bisect_left(sorted_seq, num_to_index)) == len(sorted_seq) or sorted_seq[idx] != num_to_index:
+        raise ValueError(f"{num_to_index} is not in Sequence")
+    return idx
+
+
 def get_dropdown_kwargs(
     values: list = [],
     set_value: object = None,
@@ -379,7 +391,7 @@ def get_seq_without_gaps_at_index(
     position: int,
     get_st_end: bool = False,
 ) -> tuple[int, int] | list[int]:
-    start_idx = bisect.bisect_left(seq, position)
+    start_idx = bisect_left(seq, position)
     forward_gap = get_index_of_gap_in_sorted_integer_seq_forward(seq, start_idx)
     reverse_gap = get_index_of_gap_in_sorted_integer_seq_reverse(seq, start_idx)
     if forward_gap is not None:

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/main_table.py

@@ -49,6 +49,7 @@ from .formatters import (
     try_to_bool,
 )
 from .functions import (
+    b_index,
     consecutive_ranges,
     decompress_load,
     diff_gen,
@@ -1778,7 +1779,12 @@ class MainTable(tk.Canvas):
             0 if not r else self.row_positions[r + 1],
         )
 
-    def cell_completely_visible(self, r: int = 0, c: int = 0, separate_axes: bool = False) -> bool:
+    def cell_completely_visible(
+        self,
+        r: int | None = 0,
+        c: int | None = 0,
+        separate_axes: bool = False,
+    ) -> bool:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
         x1, y1, x2, y2 = self.get_cell_coords(r, c)
         x_vis = True
@@ -1832,8 +1838,10 @@ class MainTable(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        self.deselect("all", redraw=False)
+        boxes_to_hide = tuple(self.selection_boxes)
         fill_iid = self.create_selection_box(r, c, r + 1, c + 1, state="hidden", ext=ext)
+        for iid in boxes_to_hide:
+            self.hide_selection_box(iid)
         if redraw:
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         if run_binding_func:
@@ -2984,12 +2992,10 @@ class MainTable(tk.Canvas):
                 and self.selected.type_ == "cells"
             ):
                 box = self.get_b1_motion_box(
-                    *(
-                        self.selected.row,
-                        self.selected.column,
-                        end_row,
-                        end_col,
-                    )
+                    self.selected.row,
+                    self.selected.column,
+                    end_row,
+                    end_col,
                 )
                 if (
                     box is not None
@@ -3027,12 +3033,10 @@ class MainTable(tk.Canvas):
                 and self.selected.type_ == "cells"
             ):
                 box = self.get_b1_motion_box(
-                    *(
-                        self.selected.row,
-                        self.selected.column,
-                        end_row,
-                        end_col,
-                    )
+                    self.selected.row,
+                    self.selected.column,
+                    end_row,
+                    end_col,
                 )
                 if (
                     box is not None
@@ -7457,3 +7461,21 @@ class MainTable(tk.Canvas):
 
     def datarn(self, r: int) -> int:
         return r if self.all_rows_displayed else self.displayed_rows[r]
+
+    def dispcn(self, datacn: int) -> int:
+        return datacn if self.all_columns_displayed else b_index(self.displayed_columns, datacn)
+
+    def try_dispcn(self, datacn: int) -> int | None:
+        try:
+            return self.dispcn(datacn)
+        except Exception:
+            return None
+
+    def disprn(self, datarn: int) -> int:
+        return datarn if self.all_rows_displayed else b_index(self.displayed_rows, datarn)
+
+    def try_disprn(self, datarn: int) -> int | None:
+        try:
+            return self.disprn(datarn)
+        except Exception:
+            return None

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/other_classes.py

@@ -6,6 +6,7 @@ from collections.abc import Callable, Generator, Hashable, Iterator
 from functools import partial
 from typing import Literal
 
+
 pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 
 FontTuple = namedtuple("FontTuple", "family size style")
@@ -152,18 +153,16 @@ class Span(dict):
         redraw: bool = True,
         **kwargs,
     ) -> Span:
-        self["widget"].format(
+        return self["widget"].format(
             self,
             formatter_options={"formatter": formatter_class, **formatter_options, **kwargs},
             formatter_class=formatter_class,
             redraw=redraw,
             **kwargs,
         )
-        return self
 
     def del_format(self) -> Span:
-        self["widget"].del_format(self)
-        return self
+        return self["widget"].del_format(self)
 
     def highlight(
         self,
@@ -173,7 +172,7 @@ class Span(dict):
         overwrite: bool = False,
         redraw: bool = True,
     ) -> Span:
-        self["widget"].highlight(
+        return self["widget"].highlight(
             self,
             bg=bg,
             fg=fg,
@@ -181,34 +180,74 @@ class Span(dict):
             overwrite=overwrite,
             redraw=redraw,
         )
-        return self
 
     def dehighlight(self, redraw: bool = True) -> Span:
-        self["widget"].dehighlight(self, redraw=redraw)
+        return self["widget"].dehighlight(self, redraw=redraw)
 
     del_highlight = dehighlight
 
     def readonly(self, readonly: bool = True) -> Span:
-        self["widget"].readonly(self, readonly=readonly)
-        return self
+        return self["widget"].readonly(self, readonly=readonly)
 
-    def dropdown(self, *args, **kwargs) -> Span:
-        self["widget"].dropdown(self, *args, **kwargs)
+    def dropdown(
+        self,
+        values: list = [],
+        edit_data: bool = True,
+        set_values: dict[tuple[int, int], object] = {},
+        set_value: object = None,
+        state: str = "normal",
+        redraw: bool = True,
+        selection_function: Callable | None = None,
+        modified_function: Callable | None = None,
+        search_function: Callable | None = None,
+        validate_input: bool = True,
+        text: None | str = None,
+    ) -> Span:
+        return self["widget"].dropdown(
+            self,
+            values=values,
+            edit_data=edit_data,
+            set_values=set_values,
+            set_value=set_value,
+            state=state,
+            redraw=redraw,
+            selection_function=selection_function,
+            modified_function=modified_function,
+            search_function=search_function,
+            validate_input=validate_input,
+            text=text,
+        )
 
     def del_dropdown(self) -> Span:
-        self["widget"].del_dropdown(self)
+        return self["widget"].del_dropdown(self)
 
-    def checkbox(self, *args, **kwargs) -> Span:
-        self["widget"].dropdown(self, *args, **kwargs)
+    def checkbox(
+        self,
+        edit_data: bool = True,
+        checked: bool | None = None,
+        state: str = "normal",
+        redraw: bool = True,
+        check_function: Callable | None = None,
+        text: str = "",
+    ) -> Span:
+        return self["widget"].checkbox(
+            self,
+            edit_data=edit_data,
+            checked=checked,
+            state=state,
+            redraw=redraw,
+            check_function=check_function,
+            text=text,
+        )
 
     def del_checkbox(self) -> Span:
-        self["widget"].del_checkbox(self)
+        return self["widget"].del_checkbox(self)
 
     def align(self, align: str | None, redraw: bool = True) -> Span:
-        self["widget"].align(self, align=align, redraw=redraw)
+        return self["widget"].align(self, align=align, redraw=redraw)
 
     def del_align(self, redraw: bool = True) -> Span:
-        self["widget"].del_align(self, redraw=redraw)
+        return self["widget"].del_align(self, redraw=redraw)
 
     def clear(self, undo: bool | None = None, redraw: bool = True) -> Span:
         if undo is not None:
@@ -304,7 +343,7 @@ class Span(dict):
         self["transposed"] = not self["transposed"]
         return self
 
-    def expand(self, direction: str = "both") -> Span:
+    def expand(self, direction: Literal["both", "table", "down", "right"] = "both") -> Span:
         if direction == "both" or direction == "table":
             self["upto_r"], self["upto_c"] = None, None
         elif direction == "down":

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/row_index.py

@@ -489,7 +489,6 @@ class RowIndex(tk.Canvas):
             if x < self.MT.min_column_width:
                 x = int(self.MT.min_column_width)
             self.new_row_width = x
-            self.create_resize_line(x, y1, x, y2, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rwl")
         elif self.MT.identify_row(y=event.y, allow_end=False) is None:
             self.MT.deselect("all")
         elif self.row_selection_enabled and self.rsz_h is None and self.rsz_w is None:
@@ -549,22 +548,21 @@ class RowIndex(tk.Canvas):
                     fill=self.PAR.ops.resizing_line_fg,
                     tag="rhl2",
                 )
+                self.drag_height_resize()
         elif self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             evx = event.x
-            self.hide_resize_and_ctrl_lines(ctrl_lines=False)
             if evx > self.current_width:
                 x = self.MT.canvasx(evx - self.current_width)
                 if evx > self.MT.max_index_width:
                     evx = int(self.MT.max_index_width)
                     x = self.MT.canvasx(evx - self.current_width)
                 self.new_row_width = evx
-                self.MT.create_resize_line(x, y1, x, y2, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rwl")
             else:
                 x = evx
                 if x < self.MT.min_column_width:
                     x = int(self.MT.min_column_width)
                 self.new_row_width = x
-                self.create_resize_line(x, y1, x, y2, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rwl")
+            self.drag_width_resize()
         if (
             self.drag_and_drop_enabled
             and self.row_selection_enabled
@@ -783,6 +781,36 @@ class RowIndex(tk.Canvas):
             and event.x < self.MT.index_txt_height + 4
         )
 
+    def drag_width_resize(self) -> None:
+        self.set_width(self.new_row_width, set_TL=True)
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+
+    def drag_height_resize(self) -> None:
+        new_row_pos = int(self.coords("rhl")[1])
+        old_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
+        size = new_row_pos - self.MT.row_positions[self.rsz_h - 1]
+        if size < self.MT.min_row_height:
+            new_row_pos = ceil(self.MT.row_positions[self.rsz_h - 1] + self.MT.min_row_height)
+        elif size > self.MT.max_row_height:
+            new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.MT.max_row_height)
+        increment = new_row_pos - self.MT.row_positions[self.rsz_h]
+        self.MT.row_positions[self.rsz_h + 1 :] = [
+            e + increment for e in islice(self.MT.row_positions, self.rsz_h + 1, None)
+        ]
+        self.MT.row_positions[self.rsz_h] = new_row_pos
+        new_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
+        self.MT.allow_auto_resize_rows = False
+        self.MT.recreate_all_selection_boxes()
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        if self.row_height_resize_func is not None and old_height != new_height:
+            self.row_height_resize_func(
+                event_dict(
+                    name="resize",
+                    sheet=self.PAR.name,
+                    resized_rows={self.rsz_h - 1: {"old_size": old_height, "new_size": new_height}},
+                )
+            )
+
     def b1_release(self, event: object) -> None:
         if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
@@ -799,37 +827,12 @@ class RowIndex(tk.Canvas):
             self.being_drawn_item = None
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
+            self.drag_height_resize()
             self.currently_resizing_height = False
-            new_row_pos = int(self.coords("rhl")[1])
             self.hide_resize_and_ctrl_lines(ctrl_lines=False)
-            old_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
-            size = new_row_pos - self.MT.row_positions[self.rsz_h - 1]
-            if size < self.MT.min_row_height:
-                new_row_pos = ceil(self.MT.row_positions[self.rsz_h - 1] + self.MT.min_row_height)
-            elif size > self.MT.max_row_height:
-                new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.MT.max_row_height)
-            increment = new_row_pos - self.MT.row_positions[self.rsz_h]
-            self.MT.row_positions[self.rsz_h + 1 :] = [
-                e + increment for e in islice(self.MT.row_positions, self.rsz_h + 1, len(self.MT.row_positions))
-            ]
-            self.MT.row_positions[self.rsz_h] = new_row_pos
-            new_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
-            self.MT.allow_auto_resize_rows = False
-            self.MT.recreate_all_selection_boxes()
-            self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-            if self.row_height_resize_func is not None and old_height != new_height:
-                self.row_height_resize_func(
-                    event_dict(
-                        name="resize",
-                        sheet=self.PAR.name,
-                        resized_rows={self.rsz_h - 1: {"old_size": old_height, "new_size": new_height}},
-                    )
-                )
         elif self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             self.currently_resizing_width = False
-            self.hide_resize_and_ctrl_lines(ctrl_lines=False)
-            self.set_width(self.new_row_width, set_TL=True)
-            self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+            self.drag_width_resize()
         if (
             self.drag_and_drop_enabled
             and self.MT.anything_selected(exclude_cells=True, exclude_columns=True)
@@ -1054,7 +1057,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) + 5
+            w += self.get_treeview_indent(self.MT._row_index[datarn].iid) + 10
         return w, h
 
     def get_row_text_height(
@@ -1134,9 +1137,6 @@ class RowIndex(tk.Canvas):
             isinstance(self.MT._row_index, int) and self.MT._row_index >= len(self.MT.data)
         ):
             return w
-        qconf = self.MT.txt_measure_canvas.itemconfig
-        qbbox = self.MT.txt_measure_canvas.bbox
-        qtxtm = self.MT.txt_measure_canvas_text
         if only_rows:
             iterable = only_rows
         elif self.MT.all_rows_displayed:
@@ -1146,19 +1146,8 @@ class RowIndex(tk.Canvas):
                 iterable = range(len(self.MT.data))
         else:
             iterable = self.MT.displayed_rows
-        if (
-            isinstance(self.MT._row_index, list)
-            and (tw := max(map(itemgetter(0), map(self.get_cell_dimensions, iterable)), default=w)) > w
-        ):
-            w = tw
-        elif isinstance(self.MT._row_index, int):
-            datacn = self.MT._row_index
-            for datarn in iterable:
-                if txt := self.MT.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True):
-                    qconf(qtxtm, text=txt)
-                    b = qbbox(qtxtm)
-                    if (tw := b[2] - b[0] + 10) > w:
-                        w = tw
+        if (new_w := max(map(itemgetter(0), map(self.get_cell_dimensions, iterable)), default=w)) > w:
+            w = new_w
         if w > self.MT.max_index_width:
             w = int(self.MT.max_index_width)
         return w
@@ -1713,7 +1702,6 @@ class RowIndex(tk.Canvas):
             lns = self.get_valid_cell_data_as_str(datarn, fix=False)
             if not lns:
                 continue
-            lns = lns.split("\n")
             draw_y = rtopgridln + self.MT.index_first_ln_ins
             if mw > 5:
                 draw_y = rtopgridln + self.MT.index_first_ln_ins
@@ -1721,6 +1709,7 @@ class RowIndex(tk.Canvas):
                 if start_ln < 0:
                     start_ln = 0
                 draw_y += start_ln * self.MT.index_xtra_lines_increment
+                lns = lns.split("\n")
                 if draw_y + self.MT.index_half_txt_height - 1 <= rbotgridln and len(lns) > start_ln:
                     for txt in islice(lns, start_ln, None):
                         if self.hidd_text:
@@ -2307,7 +2296,16 @@ class RowIndex(tk.Canvas):
         )
         edited = False
         if isinstance(self.MT._row_index, int):
-            edited = self.MT.set_cell_data_undo(r=r, c=self.MT._row_index, datarn=datarn, value=value, undo=True)
+            dispcn = self.MT.try_dispcn(self.MT._row_index)
+            edited = self.MT.set_cell_data_undo(
+                r=r,
+                c=dispcn if isinstance(dispcn, int) else 0,
+                datarn=datarn,
+                datacn=self.MT._row_index,
+                value=value,
+                undo=True,
+                cell_resize=isinstance(dispcn, int),
+            )
         else:
             self.fix_index(datarn)
             if not check_input_valid or self.input_valid_for_cell(datarn, value):
@@ -2442,7 +2440,7 @@ class RowIndex(tk.Canvas):
             elif isinstance(self.MT._row_index, int):
                 value = (
                     not self.MT.data[datarn][self.MT._row_index]
-                    if type(self.MT.data[datarn][self.MT._row_index], bool)
+                    if isinstance(self.MT.data[datarn][self.MT._row_index], bool)
                     else False
                 )
             else:
@@ -2487,8 +2485,7 @@ class RowIndex(tk.Canvas):
                 if iid not in self.tree_open_ids:
                     return False
             return True
-        else:
-            return all(iid in self.tree_open_ids for iid in self.get_iid_ancestors(iid))
+        return all(map(self.tree_open_ids.__contains__, self.get_iid_ancestors(iid)))
 
     def get_iid_ancestors(self, iid: str) -> Generator[str]:
         if self.tree[iid].parent:

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/sheet.py

@@ -1557,6 +1557,14 @@ class Sheet(tk.Frame):
     def data(self, value: list[list[object]]) -> None:
         self.data_reference(value)
 
+    def new_tksheet_event(self) -> EventDataDict:
+        return event_dict(
+            name="",
+            sheet=self.name,
+            widget=self,
+            selected=self.MT.selected,
+        )
+
     def set_data(
         self,
         *key: CreateSpanTypes,
@@ -2185,6 +2193,7 @@ class Sheet(tk.Frame):
         emit_event: bool = False,
         redraw: bool = True,
     ) -> EventDataDict:
+        self.MT.deselect("all", redraw=False)
         rows = [rows] if isinstance(rows, int) else sorted(rows)
         event_data = event_dict(
             name="delete_rows",
@@ -2213,7 +2222,6 @@ class Sheet(tk.Frame):
             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)
         self.set_refresh_timer(redraw)
         return event_data
 
@@ -2227,6 +2235,7 @@ class Sheet(tk.Frame):
         emit_event: bool = False,
         redraw: bool = True,
     ) -> EventDataDict:
+        self.MT.deselect("all", redraw=False)
         columns = [columns] if isinstance(columns, int) else sorted(columns)
         event_data = event_dict(
             name="delete_columns",
@@ -2255,7 +2264,6 @@ class Sheet(tk.Frame):
             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)
         self.set_refresh_timer(redraw)
         return event_data
 
@@ -2557,10 +2565,12 @@ class Sheet(tk.Frame):
         redraw: bool = True,
         selection_function: Callable | None = None,
         modified_function: Callable | None = None,
-        search_function: Callable = dropdown_search_function,
+        search_function: Callable | None = None,
         validate_input: bool = True,
         text: None | str = None,
     ) -> Span:
+        if not search_function:
+            search_function = dropdown_search_function
         v = set_value if set_value is not None else values[0] if values else ""
         kwargs = {
             "values": values,
@@ -3902,7 +3912,7 @@ class Sheet(tk.Frame):
             idx = bisect_left(self.MT.displayed_columns, column)
             if len(self.MT.displayed_columns) == idx or self.MT.displayed_columns[idx] != column:
                 self.MT.displayed_columns.insert(idx, column)
-                cws.insert(idx, self.MT.saved_column_widths.pop(column, self.PAR.ops.default_column_width))
+                cws.insert(idx, self.MT.saved_column_widths.pop(column, self.ops.default_column_width))
         self.MT.set_col_positions(cws)
         if deselect_all:
             self.MT.deselect(redraw=False)

{tksheet-7.2.10 → tksheet-7.2.12}/tksheet/themes.py

@@ -163,13 +163,13 @@ theme_dark: dict[str, str] = DotDict({
     "header_border_fg": "#505054",
     "header_grid_fg": "#8C8C8C",
     "header_fg": "gray70",
-    "header_selected_cells_bg": "#545454",
+    "header_selected_cells_bg": "#4b4b4b",
     "header_selected_cells_fg": "#6aa2fc",
     "index_bg": "#141414",
     "index_border_fg": "#505054",
     "index_grid_fg": "#8C8C8C",
     "index_fg": "gray70",
-    "index_selected_cells_bg": "#545454",
+    "index_selected_cells_bg": "#4b4b4b",
     "index_selected_cells_fg": "#6aa2fc",
     "top_left_bg": "#28282a",
     "top_left_fg": "#505054",
@@ -238,13 +238,13 @@ theme_black: dict[str, str] = DotDict({
     "header_border_fg": "#505054",
     "header_grid_fg": "#8C8C8C",
     "header_fg": "#FBB86C",
-    "header_selected_cells_bg": "#545454",
+    "header_selected_cells_bg": "#4b4b4b",
     "header_selected_cells_fg": "#FBB86C",
     "index_bg": "#000000",
     "index_border_fg": "#505054",
     "index_grid_fg": "#8C8C8C",
     "index_fg": "#FBB86C",
-    "index_selected_cells_bg": "#545454",
+    "index_selected_cells_bg": "#4b4b4b",
     "index_selected_cells_fg": "#FBB86C",
     "top_left_bg": "#141416",
     "top_left_fg": "#505054",

{tksheet-7.2.10 → tksheet-7.2.12/tksheet.egg-info}/PKG-INFO

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