tksheet 7.2.9__tar.gz → 7.2.11__tar.gz

{tksheet-7.2.9/tksheet.egg-info → tksheet-7.2.11}/PKG-INFO

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

{tksheet-7.2.9 → tksheet-7.2.11}/pyproject.toml

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

{tksheet-7.2.9 → tksheet-7.2.11}/tksheet/__init__.py

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

{tksheet-7.2.9 → tksheet-7.2.11}/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
@@ -601,6 +599,10 @@ class ColumnHeaders(tk.Canvas):
             if need_redraw:
                 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:
@@ -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
@@ -1760,8 +1763,7 @@ class ColumnHeaders(tk.Canvas):
         if self.text_editor.open and c == self.text_editor.column:
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return
-        if self.text_editor.open:
-            self.hide_text_editor()
+        self.hide_text_editor()
         if not self.MT.see(r=0, c=c, keep_yscroll=True, check_cell_visibility=True):
             self.MT.refresh()
         x = self.MT.col_positions[c] + 1
@@ -1907,14 +1909,12 @@ class ColumnHeaders(tk.Canvas):
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def hide_text_editor(self, reason: None | str = None) -> None:
+    def hide_text_editor(self) -> None:
         if self.text_editor.open:
             for binding in text_editor_to_unbind:
                 self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
-        if reason == "Escape":
-            self.focus_set()
 
     # c is displayed col
     def close_text_editor(self, event: tk.Event) -> Literal["break"] | None:
@@ -1933,6 +1933,7 @@ class ColumnHeaders(tk.Canvas):
             return "break"
         if event.keysym == "Escape":
             self.hide_text_editor_and_dropdown()
+            self.focus_set()
             return
         # setting cell data with text editor value
         text_editor_value = self.text_editor.get()
@@ -2011,7 +2012,7 @@ class ColumnHeaders(tk.Canvas):
         dd_window.search_and_see(event)
 
     def open_dropdown_window(self, c: int, event: object = None) -> None:
-        self.hide_text_editor("Escape")
+        self.hide_text_editor()
         kwargs = self.get_cell_kwargs(self.MT.datacn(c), key="dropdown")
         if kwargs["state"] == "normal":
             if not self.open_text_editor(event=event, c=c, dropdown=True):
@@ -2075,8 +2076,9 @@ class ColumnHeaders(tk.Canvas):
                 return
             redraw = False
         else:
-            self.dropdown.window.bind("<FocusOut>", lambda _x: self.close_dropdown_window(c))
             self.update_idletasks()
+            self.dropdown.window.bind("<FocusOut>", lambda _x: self.close_dropdown_window(c))
+            self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
             self.dropdown.window.focus_set()
             redraw = True
         self.dropdown.open = True
@@ -2116,12 +2118,12 @@ class ColumnHeaders(tk.Canvas):
                 edited = self.set_cell_data_undo(c, datacn=datacn, value=selection, redraw=not redraw)
             if edited:
                 try_binding(self.extra_end_edit_cell_func, event_data)
-            self.focus_set()
             self.MT.recreate_all_selection_boxes()
+        self.focus_set()
         self.hide_text_editor_and_dropdown(redraw=redraw)
 
     def hide_text_editor_and_dropdown(self, redraw: bool = True) -> None:
-        self.hide_text_editor("Escape")
+        self.hide_text_editor()
         self.hide_dropdown_window()
         if redraw:
             self.MT.refresh()

{tksheet-7.2.9 → tksheet-7.2.11}/tksheet/main_table.py

@@ -1778,7 +1778,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
@@ -1796,9 +1801,7 @@ class MainTable(tk.Canvas):
     def cell_visible(self, r: int = 0, c: int = 0) -> bool:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
         x1, y1, x2, y2 = self.get_cell_coords(r, c)
-        if x1 <= cx2 or y1 <= cy2 or x2 >= cx1 or y2 >= cy1:
-            return True
-        return False
+        return x1 <= cx2 or y1 <= cy2 or x2 >= cx1 or y2 >= cy1
 
     def select_all(self, redraw: bool = True, run_binding_func: bool = True) -> None:
         selected = self.selected
@@ -1834,8 +1837,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:
@@ -2986,12 +2991,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
@@ -3029,12 +3032,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
@@ -5457,7 +5458,7 @@ class MainTable(tk.Canvas):
         if self.PAR.ops.auto_resize_row_index and redraw_row_index and self.show_index:
             changed_w = self.RI.auto_set_index_width(
                 end_row=grid_end_row,
-                only_rows=[self.datarn(r) for r in range(text_start_row, text_end_row)],
+                only_rows=map(self.datarn, range(text_start_row, text_end_row)),
             )
         if resized_cols or resized_rows or changed_w:
             self.recreate_all_selection_boxes()
@@ -6572,8 +6573,7 @@ class MainTable(tk.Canvas):
         if self.text_editor.open and (r, c) == self.text_editor.coords:
             self.text_editor.window.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return
-        if self.text_editor.open:
-            self.hide_text_editor()
+        self.hide_text_editor()
         if not self.see(r=r, c=c, check_cell_visibility=True):
             self.refresh()
         x = self.col_positions[c]
@@ -6707,14 +6707,12 @@ class MainTable(tk.Canvas):
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def hide_text_editor(self, reason: None | str = None) -> None:
+    def hide_text_editor(self) -> None:
         if self.text_editor.open:
             for binding in text_editor_to_unbind:
                 self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
-        if reason == "Escape":
-            self.focus_set()
 
     def close_text_editor(self, event: tk.Event) -> Literal["break"] | None:
         # checking if text editor should be closed or not
@@ -6732,6 +6730,7 @@ class MainTable(tk.Canvas):
             return "break"
         if event.keysym == "Escape":
             self.hide_text_editor_and_dropdown()
+            self.focus_set()
             return
         # setting cell data with text editor value
         text_editor_value = self.text_editor.get()
@@ -6944,7 +6943,7 @@ class MainTable(tk.Canvas):
         c: int,
         event: object = None,
     ) -> None:
-        self.hide_text_editor("Escape")
+        self.hide_text_editor()
         datarn = self.datarn(r)
         datacn = self.datacn(c)
         kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
@@ -7019,7 +7018,8 @@ class MainTable(tk.Canvas):
         else:
             self.update_idletasks()
             self.dropdown.window.bind("<FocusOut>", lambda _: self.close_dropdown_window(r, c))
-            self.dropdown.window.focus()
+            self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
+            self.dropdown.window.focus_set()
             redraw = True
         self.dropdown.open = True
         if redraw:
@@ -7075,12 +7075,12 @@ class MainTable(tk.Canvas):
                 )
             if edited:
                 try_binding(self.extra_end_edit_cell_func, event_data)
-            self.focus_set()
             self.recreate_all_selection_boxes()
+        self.focus_set()
         self.hide_text_editor_and_dropdown(redraw=redraw)
 
     def hide_text_editor_and_dropdown(self, redraw: bool = True) -> None:
-        self.hide_text_editor("Escape")
+        self.hide_text_editor()
         self.hide_dropdown_window()
         if redraw:
             self.refresh()

{tksheet-7.2.9 → tksheet-7.2.11}/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.9 → tksheet-7.2.11}/tksheet/row_index.py

@@ -358,7 +358,16 @@ class RowIndex(tk.Canvas):
                         self.MT.current_cursor = "sb_v_double_arrow"
                 else:
                     self.rsz_h = None
-            if self.width_resizing_enabled and not mouse_over_resize:
+            if (
+                self.width_resizing_enabled
+                and not mouse_over_resize
+                and self.PAR.ops.auto_resize_row_index is not True
+                and not (
+                    self.PAR.ops.auto_resize_row_index == "empty"
+                    and not isinstance(self.MT._row_index, int)
+                    and not self.MT._row_index
+                )
+            ):
                 try:
                     x1, y1, x2, y2 = (
                         self.row_width_resize_bbox[0],
@@ -480,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:
@@ -540,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
@@ -761,22 +768,48 @@ class RowIndex(tk.Canvas):
             self.MT.set_yviews("moveto", 1)
 
     def event_over_dropdown(self, r: int, datarn: int, event: object, canvasy: float) -> bool:
-        if (
+        return (
             canvasy < self.MT.row_positions[r] + self.MT.index_txt_height
             and self.get_cell_kwargs(datarn, key="dropdown")
             and event.x > self.current_width - self.MT.index_txt_height - 4
-        ):
-            return True
-        return False
+        )
 
     def event_over_checkbox(self, r: int, datarn: int, event: object, canvasy: float) -> bool:
-        if (
+        return (
             canvasy < self.MT.row_positions[r] + self.MT.index_txt_height
             and self.get_cell_kwargs(datarn, key="checkbox")
             and event.x < self.MT.index_txt_height + 4
-        ):
-            return True
-        return False
+        )
+        
+    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)):
@@ -794,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)
@@ -1049,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(
@@ -1129,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:
@@ -1141,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
@@ -1708,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
@@ -1716,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:
@@ -1891,8 +1885,7 @@ class RowIndex(tk.Canvas):
         if self.text_editor.open and r == self.text_editor.row:
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return
-        if self.text_editor.open:
-            self.hide_text_editor()
+        self.hide_text_editor()
         if not self.MT.see(r=r, c=0, keep_yscroll=True, check_cell_visibility=True):
             self.MT.refresh()
         x = 0
@@ -2025,14 +2018,12 @@ class RowIndex(tk.Canvas):
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def hide_text_editor(self, reason: None | str = None) -> None:
+    def hide_text_editor(self) -> None:
         if self.text_editor.open:
             for binding in text_editor_to_unbind:
                 self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
-        if reason == "Escape":
-            self.focus_set()
 
     # r is displayed row
     def close_text_editor(self, event: tk.Event) -> Literal["break"] | None:
@@ -2051,6 +2042,7 @@ class RowIndex(tk.Canvas):
             return "break"
         if event.keysym == "Escape":
             self.hide_text_editor_and_dropdown()
+            self.focus_set()
             return
         text_editor_value = self.text_editor.get()
         r = self.text_editor.row
@@ -2132,7 +2124,7 @@ class RowIndex(tk.Canvas):
 
     # r is displayed row
     def open_dropdown_window(self, r: int, event: object = None) -> None:
-        self.hide_text_editor("Escape")
+        self.hide_text_editor()
         kwargs = self.get_cell_kwargs(self.MT.datarn(r), key="dropdown")
         if kwargs["state"] == "normal":
             if not self.open_text_editor(event=event, r=r, dropdown=True):
@@ -2203,8 +2195,9 @@ class RowIndex(tk.Canvas):
                 return
             redraw = False
         else:
-            self.dropdown.window.bind("<FocusOut>", lambda _x: self.close_dropdown_window(r))
             self.update_idletasks()
+            self.dropdown.window.bind("<FocusOut>", lambda _x: self.close_dropdown_window(r))
+            self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
             self.dropdown.window.focus_set()
             redraw = True
         self.dropdown.open = True
@@ -2245,12 +2238,12 @@ class RowIndex(tk.Canvas):
                 edited = self.set_cell_data_undo(r, datarn=datarn, value=selection, redraw=not redraw)
             if edited:
                 try_binding(self.extra_end_edit_cell_func, event_data)
-            self.focus_set()
             self.MT.recreate_all_selection_boxes()
+        self.focus_set()
         self.hide_text_editor_and_dropdown(redraw=redraw)
 
     def hide_text_editor_and_dropdown(self, redraw: bool = True) -> None:
-        self.hide_text_editor("Escape")
+        self.hide_text_editor()
         self.hide_dropdown_window()
         if redraw:
             self.MT.refresh()
@@ -2520,7 +2513,7 @@ class RowIndex(tk.Canvas):
             if not node.parent.children:
                 self.tree_open_ids.discard(node.parent)
 
-    def pid_causes_recursive_loop(self, iid: str, pid: str) -> bool:
+    def build_pid_causes_recursive_loop(self, iid: str, pid: str) -> bool:
         return any(
             i == pid
             for i in chain(
@@ -2528,3 +2521,8 @@ class RowIndex(tk.Canvas):
                 islice(self.get_iid_ancestors(iid), 1, None),
             )
         )
+
+    def move_pid_causes_recursive_loop(self, to_move_iid: str, move_to_parent: str) -> bool:
+        # if the parent the item is being moved under is one of the item's descendants
+        # then it is a recursive loop
+        return any(move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid))

{tksheet-7.2.9 → tksheet-7.2.11}/tksheet/sheet.py

@@ -1556,6 +1556,14 @@ class Sheet(tk.Frame):
     @data.setter
     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,
@@ -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)
@@ -4711,7 +4721,7 @@ class Sheet(tk.Frame):
                 self.RI.tree[iid].text = row[text_column]
             else:
                 self.RI.tree[iid] = Node(row[text_column], iid, "")
-            if safety and (iid == pid or self.RI.pid_causes_recursive_loop(iid, pid)):
+            if safety and (iid == pid or self.RI.build_pid_causes_recursive_loop(iid, pid)):
                 row[parent_column] = ""
                 pid = ""
             if pid:
@@ -5041,7 +5051,8 @@ class Sheet(tk.Frame):
     def move(self, item: str, parent: str, index: int | None = None) -> Sheet:
         """
         Moves item to be under parent as child at index
-        'parent' can be empty string which will make item a top node
+        'parent' can be an empty str which will put the item at top level
+        Performance is not great
         """
         if (item := item.lower()) and item not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
@@ -5050,25 +5061,61 @@ class Sheet(tk.Frame):
         mapping = {}
         to_show = []
         item_node = self.RI.tree[item]
+        item_r = self.RI.tree_rns[item]
         if parent:
-            if self.RI.pid_causes_recursive_loop(item, parent):
+            if self.RI.move_pid_causes_recursive_loop(item, parent):
                 raise ValueError(f"iid '{item}' causes a recursive loop with parent '{parent}'.")
             parent_node = self.RI.tree[parent]
             if parent_node.children:
                 if index is None or index >= len(parent_node.children):
-                    index = len(parent_node.children) - 1
-                item_r = self.RI.tree_rns[item]
-                new_r = self.RI.tree_rns[parent_node.children[index].iid]
-                new_r_desc = sum(1 for _ in self.RI.get_iid_descendants(parent_node.children[index].iid))
-                item_desc = sum(1 for _ in self.RI.get_iid_descendants(item))
-                if item_r < new_r:
-                    r_ctr = new_r + new_r_desc - item_desc
+                    index = len(parent_node.children)
+                    new_r = self.RI.tree_rns[parent] + sum(1 for _ in self.RI.get_iid_descendants(parent))
+                    # new parent has children
+                    # index is on end
+                    # item row is less than move to row
+                    if item_r < new_r:
+                        r_ctr = new_r - sum(1 for _ in self.RI.get_iid_descendants(item))
+
+                    # new parent has children
+                    # index is on end
+                    # item row is greater than move to row
+                    else:
+                        r_ctr = new_r + 1
                 else:
-                    r_ctr = new_r
+                    new_r = self.RI.tree_rns[parent_node.children[index].iid]
+                    # new parent has children
+                    # index is not end
+                    # item row is less than move to row
+                    if item_r < new_r:
+                        if self.RI.items_parent(item) == parent:
+                            r_ctr = (
+                                new_r
+                                + sum(1 for _ in self.RI.get_iid_descendants(parent_node.children[index].iid))
+                                - sum(1 for _ in self.RI.get_iid_descendants(item))
+                            )
+                        else:
+                            r_ctr = new_r - sum(1 for _ in self.RI.get_iid_descendants(item)) - 1
+
+                    # new parent has children
+                    # index is not end
+                    # item row is greater than move to row
+                    else:
+                        r_ctr = new_r
             else:
-                if index is None:
-                    index = 0
-                r_ctr = self.RI.tree_rns[parent_node.iid] + 1
+                index = 0
+                new_r = self.RI.tree_rns[parent_node.iid]
+
+                # new parent doesn't have children
+                # index always start
+                # item row is less than move to row
+                if item_r < new_r:
+                    r_ctr = new_r - sum(1 for _ in self.RI.get_iid_descendants(item))
+
+                # new parent doesn't have children
+                # index always start
+                # item row is greater than move to row
+                else:
+                    r_ctr = new_r + 1
             mapping[item_r] = r_ctr
             if parent in self.RI.tree_open_ids and self.item_displayed(parent):
                 to_show.append(r_ctr)
@@ -5091,11 +5138,12 @@ class Sheet(tk.Frame):
             else:
                 if (new_r := self.top_index_row(index)) is None:
                     new_r = self.top_index_row((sum(1 for _ in self.RI.gen_top_nodes()) - 1))
-            item_r = self.RI.tree_rns[item]
             if item_r < new_r:
-                par_desc = sum(1 for _ in self.RI.get_iid_descendants(self.rowitem(new_r, data_index=True)))
-                item_desc = sum(1 for _ in self.RI.get_iid_descendants(item))
-                r_ctr = new_r + par_desc - item_desc
+                r_ctr = (
+                    new_r
+                    + sum(1 for _ in self.RI.get_iid_descendants(self.rowitem(new_r, data_index=True)))
+                    - sum(1 for _ in self.RI.get_iid_descendants(item))
+                )
             else:
                 r_ctr = new_r
             mapping[item_r] = r_ctr
@@ -6258,13 +6306,7 @@ class Sheet(tk.Frame):
     ) -> Sheet:
         kwargs = get_dropdown_kwargs(*args, **kwargs)
         d = get_dropdown_dict(**kwargs)
-        if kwargs["set_value"] is None:
-            if kwargs["values"] and (v := self.MT.get_cell_data(r, c)) not in kwargs["values"]:
-                v = kwargs["values"][0]
-            else:
-                v == ""
-        else:
-            v = kwargs["set_value"]
+        v = kwargs["set_value"] if kwargs["set_value"] is not None else kwargs["values"][0] if kwargs["values"] else ""
         if isinstance(r, str) and r.lower() == "all" and isinstance(c, int):
             for r_ in range(self.MT.total_data_rows()):
                 self._create_dropdown(r_, c, v, d)

{tksheet-7.2.9 → tksheet-7.2.11}/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.9 → tksheet-7.2.11}/tksheet/top_left_rectangle.py

@@ -163,17 +163,16 @@ class TopLeftRectangle(tk.Canvas):
         recreate_selection_boxes: bool = True,
     ) -> None:
         try:
-            self.update_idletasks()
-            if new_h is None:
-                h = self.winfo_height()
-            if new_w is None:
-                w = self.winfo_width()
-            if new_w:
-                self.config(width=new_w)
-                w = new_w
-            if new_h:
-                self.config(height=new_h)
+            if isinstance(new_h, int):
                 h = new_h
+                self.config(height=h)
+            else:
+                h = self.CH.current_height
+            if isinstance(new_w, int):
+                w = new_w
+                self.config(width=w)
+            else:
+                w = self.RI.current_width
         except Exception:
             return
         self.coords(self.rw_box, 0, h - 5, w, h)

{tksheet-7.2.9 → tksheet-7.2.11/tksheet.egg-info}/PKG-INFO

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