tksheet 7.2.8__tar.gz → 7.2.10__tar.gz

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

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

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

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

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

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

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

@@ -946,7 +946,7 @@ class ColumnHeaders(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        boxes_to_hide = tuple(iid for iid in self.MT.selection_boxes)
+        boxes_to_hide = tuple(self.MT.selection_boxes)
         fill_iid = self.MT.create_selection_box(0, c, len(self.MT.row_positions) - 1, c + 1, "columns", ext=ext)
         for iid in boxes_to_hide:
             self.MT.hide_selection_box(iid)
@@ -989,7 +989,7 @@ class ColumnHeaders(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=8 if self.PAR.ops.rounded_boxes else 0,
+            radius=5 if self.PAR.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1314,24 +1314,23 @@ class ColumnHeaders(tk.Canvas):
             if open_:
                 # up arrow
                 points = (
-                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
                     y1 + mid_y + small_mod,
-                    x2 - 3 - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod,
                     y1 + mid_y - small_mod,
-                    x2 - 3,
+                    x2 - 4,
                     y1 + mid_y + small_mod,
                 )
             else:
                 # down arrow
                 points = (
-                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
                     y1 + mid_y - small_mod,
-                    x2 - 3 - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod,
                     y1 + mid_y + small_mod,
-                    x2 - 3,
+                    x2 - 4,
                     y1 + mid_y - small_mod,
                 )
-            
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
                 self.coords(t, points)
@@ -1341,10 +1340,13 @@ class ColumnHeaders(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(
+                t = self.create_line(
                     points,
                     fill=fill,
                     tag=tag,
+                    width=2,
+                    capstyle=tk.ROUND,
+                    joinstyle=tk.BEVEL,
                 )
             self.disp_dropdown[t] = True
 
@@ -1758,8 +1760,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
@@ -1905,14 +1906,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:
@@ -1931,6 +1930,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()
@@ -2009,7 +2009,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):
@@ -2073,8 +2073,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
@@ -2114,12 +2115,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.8 → tksheet-7.2.10}/tksheet/functions.py

@@ -545,7 +545,7 @@ def rounded_box_coords(
     y1: float,
     x2: float,
     y2: float,
-    radius: int = 8,
+    radius: int = 5,
 ) -> tuple[float]:
     return (
         x1 + radius,

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

@@ -25,6 +25,7 @@ from itertools import (
     accumulate,
     chain,
     cycle,
+    filterfalse,
     islice,
     repeat,
 )
@@ -696,8 +697,9 @@ class MainTable(tk.Canvas):
             selected=self.selected,
         )
         if self.selected:
-            selected_r = self.selected.row
-            selected_c = self.selected.column
+            selected_r = self.selected.box.from_r
+            selected_c = self.selected.box.from_c
+            curr_coords = (self.selected.row, self.selected.column)
         elif not self.selected and not self.PAR.ops.paste_can_expand_x and not self.PAR.ops.paste_can_expand_y:
             return
         else:
@@ -710,6 +712,7 @@ class MainTable(tk.Canvas):
                     selected_c, selected_r = len(self.col_positions) - 1, 0
                 elif len(self.row_positions) > 1 and len(self.col_positions) > 1:
                     selected_c, selected_r = 0, len(self.row_positions) - 1
+                curr_coords = (selected_r, selected_c)
         try:
             data = get_data_from_clipboard(
                 widget=self,
@@ -915,13 +918,17 @@ class MainTable(tk.Canvas):
         else:
             selboxc = selected_c_adjusted_new_data_numcols
         self.deselect("all", redraw=False)
-        self.create_selection_box(
-            selected_r,
-            selected_c,
-            selboxr,
-            selboxc,
-            "cells",
-            run_binding=True,
+        self.set_currently_selected(
+            *curr_coords,
+            item=self.create_selection_box(
+                selected_r,
+                selected_c,
+                selboxr,
+                selboxc,
+                type_="cells",
+                set_current=False,
+                run_binding=True,
+            ),
         )
         event_data["selection_boxes"] = self.get_boxes()
         event_data["selected"] = self.selected
@@ -1789,9 +1796,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
@@ -3773,11 +3778,10 @@ class MainTable(tk.Canvas):
         colpos = self.PAR.ops.default_column_width
         if isinstance(ncols, int):
             self.set_col_positions(itr=repeat(colpos, ncols))
+        elif self.all_columns_displayed:
+            self.set_col_positions(itr=repeat(colpos, self.total_data_cols()))
         else:
-            if self.all_columns_displayed:
-                self.set_col_positions(itr=repeat(colpos, self.total_data_cols()))
-            else:
-                self.set_col_positions(itr=repeat(colpos, len(self.displayed_columns)))
+            self.set_col_positions(itr=repeat(colpos, len(self.displayed_columns)))
 
     def set_row_positions(self, itr: Iterator[float]) -> None:
         self.row_positions = list(accumulate(chain([0], itr)))
@@ -3786,11 +3790,10 @@ class MainTable(tk.Canvas):
         rowpos = self.get_default_row_height()
         if isinstance(nrows, int):
             self.set_row_positions(itr=repeat(rowpos, nrows))
+        elif self.all_rows_displayed:
+            self.set_row_positions(itr=repeat(rowpos, self.total_data_rows()))
         else:
-            if self.all_rows_displayed:
-                self.set_row_positions(itr=repeat(rowpos, self.total_data_rows()))
-            else:
-                self.set_row_positions(itr=repeat(rowpos, len(self.displayed_rows)))
+            self.set_row_positions(itr=repeat(rowpos, len(self.displayed_rows)))
 
     def del_col_position(self, idx: int, deselect_all: bool = False):
         if deselect_all:
@@ -4453,7 +4456,7 @@ class MainTable(tk.Canvas):
         if isinstance(displayed_rows, list):
             self.displayed_rows = displayed_rows
         elif not self.all_rows_displayed:
-            # push displayed indexes by one for every inserted column
+            # push displayed indexes by one for every inserted row
             self.displayed_rows.sort()
             # highest index is first in rows
             up_to = len(self.displayed_rows)
@@ -4718,9 +4721,10 @@ class MainTable(tk.Canvas):
             named_spans=self.get_spans_to_del_from_cols(cols=cols_set),
         )
         if not self.all_columns_displayed:
-            self.displayed_columns = [c for c in self.displayed_columns if c not in cols_set]
-            for c in cols:
-                self.displayed_columns = [dc if c > dc else dc - 1 for dc in self.displayed_columns]
+            self.displayed_columns = [
+                c if not (num := bisect_left(cols, c)) else c - num
+                for c in filterfalse(cols_set.__contains__, self.displayed_columns)
+            ]
         return event_data
 
     def delete_columns_displayed(self, cols: list, event_data: dict) -> EventDataDict:
@@ -4773,9 +4777,10 @@ class MainTable(tk.Canvas):
             named_spans=self.get_spans_to_del_from_rows(rows=rows_set),
         )
         if not self.all_rows_displayed:
-            self.displayed_rows = [r for r in self.displayed_rows if r not in rows_set]
-            for r in rows:
-                self.displayed_rows = [dr if r > dr else dr - 1 for dr in self.displayed_rows]
+            self.displayed_rows = [
+                r if not (num := bisect_left(rows, r)) else r - num
+                for r in filterfalse(rows_set.__contains__, self.displayed_rows)
+            ]
         return event_data
 
     def delete_rows_displayed(self, rows: list, event_data: dict) -> EventDataDict:
@@ -4847,20 +4852,23 @@ class MainTable(tk.Canvas):
     ) -> list[int] | None:
         if rows is None and all_rows_displayed is None:
             return list(range(self.total_data_rows())) if self.all_rows_displayed else self.displayed_rows
-        total_data_rows = None
-        if (rows is not None and rows != self.displayed_rows) or (all_rows_displayed and not self.all_rows_displayed):
-            self.purge_undo_and_redo_stack()
         if rows is not None and rows != self.displayed_rows:
+            self.purge_undo_and_redo_stack()
             self.displayed_rows = sorted(rows)
-        if all_rows_displayed:
-            if not self.all_rows_displayed:
-                total_data_rows = self.total_data_rows()
-                self.displayed_rows = list(range(total_data_rows))
-            self.all_rows_displayed = True
-        elif all_rows_displayed is not None and not all_rows_displayed:
-            self.all_rows_displayed = False
+        # setting all_rows_displayed
+        if all_rows_displayed is not None:
+            # setting it to True and it's currently False
+            if all_rows_displayed and not self.all_rows_displayed:
+                self.purge_undo_and_redo_stack()
+                self.all_rows_displayed = True
+            # setting it to False and it's currently True
+            elif not all_rows_displayed and self.all_rows_displayed:
+                # if rows is None then displayed_rows needs to be reset
+                if rows is None:
+                    self.displayed_rows = list(range(self.total_data_rows()))
+                self.all_rows_displayed = False
         if reset_row_positions:
-            self.reset_row_positions(nrows=total_data_rows)
+            self.reset_row_positions()
         if deselect_all:
             self.deselect("all", redraw=False)
 
@@ -4873,22 +4881,23 @@ class MainTable(tk.Canvas):
     ) -> list[int] | None:
         if columns is None and all_columns_displayed is None:
             return list(range(self.total_data_cols())) if self.all_columns_displayed else self.displayed_columns
-        total_data_cols = None
-        if (columns is not None and columns != self.displayed_columns) or (
-            all_columns_displayed and not self.all_columns_displayed
-        ):
-            self.purge_undo_and_redo_stack()
         if columns is not None and columns != self.displayed_columns:
+            self.purge_undo_and_redo_stack()
             self.displayed_columns = sorted(columns)
-        if all_columns_displayed:
-            if not self.all_columns_displayed:
-                total_data_cols = self.total_data_cols()
-                self.displayed_columns = list(range(total_data_cols))
-            self.all_columns_displayed = True
-        elif all_columns_displayed is not None and not all_columns_displayed:
-            self.all_columns_displayed = False
+        # setting all_columns_displayed
+        if all_columns_displayed is not None:
+            # setting it to True and it's currently False
+            if all_columns_displayed and not self.all_columns_displayed:
+                self.purge_undo_and_redo_stack()
+                self.all_columns_displayed = True
+            # setting it to False and it's currently True
+            elif not all_columns_displayed and self.all_columns_displayed:
+                # if columns is None then displayed_columns needs to be reset
+                if columns is None:
+                    self.displayed_columns = list(range(self.total_data_cols()))
+                self.all_columns_displayed = False
         if reset_col_positions:
-            self.reset_col_positions(ncols=total_data_cols)
+            self.reset_col_positions()
         if deselect_all:
             self.deselect("all", redraw=False)
 
@@ -5245,21 +5254,21 @@ class MainTable(tk.Canvas):
             if open_:
                 # up arrow
                 points = (
-                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
                     y1 + mid_y + small_mod,
-                    x2 - 3 - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod,
                     y1 + mid_y - small_mod,
-                    x2 - 3,
+                    x2 - 4,
                     y1 + mid_y + small_mod,
                 )
             else:
                 # down arrow
                 points = (
-                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
                     y1 + mid_y - small_mod,
-                    x2 - 3 - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod,
                     y1 + mid_y + small_mod,
-                    x2 - 3,
+                    x2 - 4,
                     y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
@@ -5271,10 +5280,13 @@ class MainTable(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(
+                t = self.create_line(
                     points,
                     fill=fill,
                     tag=tag,
+                    width=2,
+                    capstyle=tk.ROUND,
+                    joinstyle=tk.BEVEL,
                 )
             self.disp_dropdown[t] = True
 
@@ -5443,7 +5455,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()
@@ -5957,7 +5969,7 @@ class MainTable(tk.Canvas):
         if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1:
             radius = 0
         else:
-            radius = 8
+            radius = 5
         coords = rounded_box_coords(
             x1,
             y1,
@@ -6182,7 +6194,7 @@ class MainTable(tk.Canvas):
         x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
         self.display_box(x1, y1, x2, y2, fill=mt_bg, outline="", state=state, tags=type_, width=1, iid=fill_iid)
         self.RI.display_box(
-            1,
+            0,
             y1,
             self.RI.current_width - 1,
             y2,
@@ -6558,8 +6570,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]
@@ -6693,14 +6704,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
@@ -6718,6 +6727,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()
@@ -6930,7 +6940,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")
@@ -7005,7 +7015,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:
@@ -7061,12 +7072,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.8 → tksheet-7.2.10}/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],
@@ -761,22 +770,18 @@ 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 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)):
@@ -957,7 +962,7 @@ class RowIndex(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        boxes_to_hide = tuple(iid for iid in self.MT.selection_boxes)
+        boxes_to_hide = tuple(self.MT.selection_boxes)
         fill_iid = self.MT.create_selection_box(r, 0, r + 1, len(self.MT.col_positions) - 1, "rows", ext=ext)
         for iid in boxes_to_hide:
             self.MT.hide_selection_box(iid)
@@ -1000,7 +1005,7 @@ class RowIndex(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=8 if self.PAR.ops.rounded_boxes else 0,
+            radius=5 if self.PAR.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1353,11 +1358,9 @@ class RowIndex(tk.Canvas):
                 # the left hand downward point
                 x1 + 5 + indent,
                 y1 + mid_y + small_mod,
-                
                 # the middle upward point
                 x1 + 5 + indent + small_mod + small_mod,
                 y1 + mid_y - small_mod,
-                
                 # the right hand downward point
                 x1 + 5 + indent + small_mod + small_mod + small_mod + small_mod,
                 y1 + mid_y + small_mod,
@@ -1368,11 +1371,9 @@ class RowIndex(tk.Canvas):
                 # the upper point
                 x1 + 5 + indent + small_mod + small_mod,
                 y1 + mid_y - small_mod - small_mod,
-                
                 # the middle point
                 x1 + 5 + indent + small_mod + small_mod + small_mod + small_mod,
                 y1 + mid_y,
-                
                 # the bottom point
                 x1 + 5 + indent + small_mod + small_mod,
                 y1 + mid_y + small_mod + small_mod,
@@ -1418,21 +1419,21 @@ class RowIndex(tk.Canvas):
             if open_:
                 # up arrow
                 points = (
-                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
                     y1 + mid_y + small_mod,
-                    x2 - 3 - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod,
                     y1 + mid_y - small_mod,
-                    x2 - 3,
+                    x2 - 4,
                     y1 + mid_y + small_mod,
                 )
             else:
                 # down arrow
                 points = (
-                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
                     y1 + mid_y - small_mod,
-                    x2 - 3 - small_mod - small_mod,
+                    x2 - 4 - small_mod - small_mod,
                     y1 + mid_y + small_mod,
-                    x2 - 3,
+                    x2 - 4,
                     y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
@@ -1444,10 +1445,13 @@ class RowIndex(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(
+                t = self.create_line(
                     points,
                     fill=fill,
                     tag=tag,
+                    width=2,
+                    capstyle=tk.ROUND,
+                    joinstyle=tk.BEVEL,
                 )
             self.disp_dropdown[t] = True
 
@@ -1892,8 +1896,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
@@ -2026,14 +2029,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:
@@ -2052,6 +2053,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
@@ -2133,7 +2135,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):
@@ -2204,8 +2206,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
@@ -2246,12 +2249,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()
@@ -2521,7 +2524,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(
@@ -2529,3 +2532,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.8 → tksheet-7.2.10}/tksheet/sheet.py

@@ -10,7 +10,14 @@ from collections.abc import (
     Iterator,
     Sequence,
 )
-from itertools import accumulate, chain, islice, product, repeat
+from itertools import (
+    accumulate,
+    chain,
+    filterfalse,
+    islice,
+    product,
+    repeat,
+)
 from timeit import default_timer
 from tkinter import ttk
 from typing import Literal
@@ -3813,7 +3820,6 @@ class Sheet(tk.Frame):
         columns: None | Literal["all"] | Iterator[int] = None,
         all_columns_displayed: None | bool = None,
         reset_col_positions: bool = True,
-        refresh: bool = False,
         redraw: bool = False,
         deselect_all: bool = True,
         **kwargs,
@@ -3828,8 +3834,9 @@ class Sheet(tk.Frame):
             reset_col_positions=reset_col_positions,
             deselect_all=deselect_all,
         )
-        if refresh or redraw:
-            self.set_refresh_timer(redraw if redraw else refresh)
+        if "refresh" in kwargs:
+            redraw = kwargs["refresh"]
+        self.set_refresh_timer(redraw)
         return res
 
     def hide_columns(
@@ -3846,7 +3853,7 @@ class Sheet(tk.Frame):
             if not columns:
                 return
         if self.MT.all_columns_displayed:
-            self.MT.displayed_columns = [c for c in range(self.MT.total_data_cols()) if c not in columns]
+            self.MT.displayed_columns = list(filterfalse(columns.__contains__, range(self.MT.total_data_cols())))
             to_pop = {c: c for c in columns}
         else:
             to_pop = {}
@@ -3876,13 +3883,18 @@ class Sheet(tk.Frame):
             self.MT.deselect(redraw=False)
         return self.set_refresh_timer(redraw)
 
-    # uses data indexes
     def show_columns(
         self,
         columns: int | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
     ) -> Sheet:
+        """
+        'columns' argument must be data indexes
+        Function will return without action if Sheet.all_columns
+        """
+        if self.MT.all_columns_displayed:
+            return
         if isinstance(columns, int):
             columns = [columns]
         cws = self.MT.get_column_widths()
@@ -3908,7 +3920,10 @@ class Sheet(tk.Frame):
 
     @all_columns.setter
     def all_columns(self, a: bool) -> Sheet:
-        self.MT.all_columns_displayed = a
+        self.MT.display_columns(
+            columns=None,
+            all_columns_displayed=a,
+        )
         return self
 
     @property
@@ -3917,8 +3932,8 @@ class Sheet(tk.Frame):
 
     @displayed_columns.setter
     def displayed_columns(self, columns: list[int]) -> Sheet:
-        self.display_columns(columns=columns, reset_col_positions=False, redraw=True)
-        return self
+        self.display_columns(columns=columns, reset_col_positions=True, redraw=False)
+        return self.set_refresh_timer()
 
     # Hiding Rows
 
@@ -3933,7 +3948,6 @@ class Sheet(tk.Frame):
         rows: None | Literal["all"] | Iterator[int] = None,
         all_rows_displayed: None | bool = None,
         reset_row_positions: bool = True,
-        refresh: bool = False,
         redraw: bool = False,
         deselect_all: bool = True,
         **kwargs,
@@ -3946,8 +3960,9 @@ class Sheet(tk.Frame):
             reset_row_positions=reset_row_positions,
             deselect_all=deselect_all,
         )
-        if refresh or redraw:
-            self.set_refresh_timer(redraw if redraw else refresh)
+        if "refresh" in kwargs:
+            redraw = kwargs["refresh"]
+        self.set_refresh_timer(redraw)
         return res
 
     def hide_rows(
@@ -3965,7 +3980,7 @@ class Sheet(tk.Frame):
             if not rows:
                 return
         if self.MT.all_rows_displayed:
-            self.MT.displayed_rows = [r for r in range(self.MT.total_data_rows()) if r not in rows]
+            self.MT.displayed_rows = list(filterfalse(rows.__contains__, range(self.MT.total_data_rows())))
             to_pop = {r: r for r in rows}
         else:
             to_pop = {}
@@ -3996,13 +4011,18 @@ class Sheet(tk.Frame):
             self.MT.deselect(redraw=False)
         return self.set_refresh_timer(redraw)
 
-    # uses data indexes
     def show_rows(
         self,
         rows: int | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
     ) -> Sheet:
+        """
+        'rows' argument must be data indexes
+        Function will return without action if Sheet.all_rows
+        """
+        if self.MT.all_rows_displayed:
+            return
         if isinstance(rows, int):
             rows = [rows]
         rhs = self.MT.get_row_heights()
@@ -4028,7 +4048,10 @@ class Sheet(tk.Frame):
 
     @all_rows.setter
     def all_rows(self, a: bool) -> Sheet:
-        self.MT.all_rows_displayed = a
+        self.MT.display_rows(
+            rows=None,
+            all_rows_displayed=a,
+        )
         return self
 
     @property
@@ -4037,8 +4060,8 @@ class Sheet(tk.Frame):
 
     @displayed_rows.setter
     def displayed_rows(self, rows: list[int]) -> Sheet:
-        self.display_rows(rows=rows, reset_row_positions=False, redraw=True)
-        return self
+        self.display_rows(rows=rows, reset_row_positions=True, redraw=False)
+        return self.set_refresh_timer()
 
     # Hiding Sheet Elements
 
@@ -4688,7 +4711,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:
@@ -4747,7 +4770,7 @@ class Sheet(tk.Frame):
         Closes everything else
         """
         self.hide_rows(
-            set(rn for rn in self.MT.displayed_rows if self.MT._row_index[rn].parent),
+            rows={rn for rn in self.MT.displayed_rows if self.MT._row_index[rn].parent},
             redraw=False,
             deselect_all=False,
             data_indexes=True,
@@ -4768,13 +4791,15 @@ class Sheet(tk.Frame):
         """
         to_open = []
         disp_set = set(self.MT.displayed_rows)
-        quick_rns = self.RI.tree_rns
-        quick_open_ids = self.RI.tree_open_ids
+        tree = self.RI.tree
+        rns = self.RI.tree_rns
+        open_ids = self.RI.tree_open_ids
+        descendants = self.RI.get_iid_descendants
         for item in filter(items.__contains__, self.get_children()):
-            if self.RI.tree[item].children:
-                quick_open_ids.add(item)
-                if quick_rns[item] in disp_set:
-                    to_disp = [quick_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)]
+            if tree[item].children:
+                open_ids.add(item)
+                if rns[item] in disp_set:
+                    to_disp = [rns[did] for did in descendants(item, check_open=True)]
                     for i in to_disp:
                         disp_set.add(i)
                     to_open.extend(to_disp)
@@ -4921,7 +4946,7 @@ class Sheet(tk.Frame):
                     self.RI.tree_open_ids.add(item)
                     if self.item_displayed(item):
                         self.show_rows(
-                            rows=(self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
+                            rows=map(self.RI.tree_rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True)),
                             redraw=False,
                             deselect_all=False,
                         )
@@ -4929,7 +4954,9 @@ class Sheet(tk.Frame):
                     self.RI.tree_open_ids.discard(item)
                     if self.item_displayed(item):
                         self.hide_rows(
-                            rows={self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)},
+                            rows=set(
+                                map(self.RI.tree_rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True))
+                            ),
                             redraw=False,
                             deselect_all=False,
                             data_indexes=True,
@@ -5014,7 +5041,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.")
@@ -5023,25 +5051,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)
@@ -5064,11 +5128,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
@@ -5106,7 +5171,8 @@ class Sheet(tk.Frame):
         if (item := item.lower()) not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
         if not self.RI.tree[item].parent:
-            return next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == self.RI.tree[item])
+            find_node = self.RI.tree[item]
+            return next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == find_node)
         return self.RI.tree[item].parent.children.index(self.RI.tree[item])
 
     def item_displayed(self, item: str) -> bool:
@@ -5128,8 +5194,11 @@ class Sheet(tk.Frame):
         if (item := item.lower()) not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
         if self.RI.tree[item].parent:
-            for iid in self.RI.get_iid_ancestors(item):
-                self.item(iid, open_=True, redraw=False)
+            self.show_rows(
+                rows=self._tree_open(list(self.RI.get_iid_ancestors(item))),
+                redraw=False,
+                deselect_all=False,
+            )
         return self.set_refresh_timer(redraw)
 
     def scroll_to_item(self, item: str, redraw=False) -> Sheet:
@@ -5151,14 +5220,15 @@ class Sheet(tk.Frame):
         Get currently selected item ids
         """
         return [
-            self.MT._row_index[self.displayed_row_to_data(rn)].iid
-            for rn in self.get_selected_rows(get_cells_as_rows=cells)
+            self.MT._row_index[self.MT.displayed_rows[rn]].iid for rn in self.get_selected_rows(get_cells_as_rows=cells)
         ]
 
     def selection_set(self, *items, redraw: bool = True) -> Sheet:
         if any(item.lower() in self.RI.tree for item in unpack(items)):
-            self.deselect(redraw=False)
+            boxes_to_hide = tuple(self.MT.selection_boxes)
             self.selection_add(*items, redraw=False)
+            for iid in boxes_to_hide:
+                self.MT.hide_selection_box(iid)
         return self.set_refresh_timer(redraw)
 
     def selection_add(self, *items, redraw: bool = True) -> Sheet:
@@ -5220,7 +5290,7 @@ class Sheet(tk.Frame):
 
     # Functions not in docs
 
-    def event_generate(self, *args, **kwargs):
+    def event_generate(self, *args, **kwargs) -> None:
         self.MT.event_generate(*args, **kwargs)
 
     def emit_event(
@@ -6226,13 +6296,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.8 → tksheet-7.2.10}/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.8 → tksheet-7.2.10/tksheet.egg-info}/PKG-INFO

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