tksheet 7.2.6__tar.gz → 7.2.8__tar.gz

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

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

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

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

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

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

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

@@ -946,8 +946,10 @@ class ColumnHeaders(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        self.MT.deselect("all", redraw=False)
+        boxes_to_hide = tuple(iid for iid in 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)
         if redraw:
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         if run_binding_func:
@@ -1301,35 +1303,35 @@ class ColumnHeaders(tk.Canvas):
         tag: str | tuple[str],
         draw_outline: bool = True,
         draw_arrow: bool = True,
-        dd_is_open: bool = False,
+        open_: bool = False,
     ) -> None:
         if draw_outline and self.PAR.ops.show_dropdown_borders:
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.header_fg, tag=tag)
         if draw_arrow:
             mod = (self.MT.header_txt_height - 1) if self.MT.header_txt_height % 2 else self.MT.header_txt_height
-            half_mod = mod / 2
-            qtr_mod = mod / 4
-            mid_y = (
-                (self.MT.header_first_ln_ins - 1) if self.MT.header_first_ln_ins % 2 else self.MT.header_first_ln_ins
-            )
-            if dd_is_open:
+            small_mod = int(mod / 5)
+            mid_y = floor(self.MT.min_header_height / 2)
+            if open_:
+                # up arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y - qtr_mod,
+                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 3 - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
                     x2 - 3,
-                    y1 + mid_y + qtr_mod,
+                    y1 + mid_y + small_mod,
                 )
             else:
+                # down arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y + qtr_mod,
+                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 3 - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
                     x2 - 3,
-                    y1 + mid_y - qtr_mod,
+                    y1 + mid_y - small_mod,
                 )
+            
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
                 self.coords(t, points)
@@ -1502,7 +1504,7 @@ class ColumnHeaders(tk.Canvas):
                         tag="dd",
                         draw_outline=not dd_drawn,
                         draw_arrow=mw >= 5,
-                        dd_is_open=dd_coords == c,
+                        open_=dd_coords == c,
                     )
                 else:
                     mw = crightgridln - cleftgridln - 1
@@ -1521,7 +1523,7 @@ class ColumnHeaders(tk.Canvas):
                         tag="dd",
                         draw_outline=not dd_drawn,
                         draw_arrow=mw >= 5,
-                        dd_is_open=dd_coords == c,
+                        open_=dd_coords == c,
                     )
                 else:
                     mw = crightgridln - cleftgridln - 1
@@ -1541,7 +1543,7 @@ class ColumnHeaders(tk.Canvas):
                         tag="dd",
                         draw_outline=not dd_drawn,
                         draw_arrow=mw >= 5,
-                        dd_is_open=dd_coords == c,
+                        open_=dd_coords == c,
                     )
                 else:
                     mw = crightgridln - cleftgridln - 1
@@ -2022,7 +2024,7 @@ class ColumnHeaders(tk.Canvas):
             "height": win_h,
             "font": self.PAR.ops.header_font,
             "ops": self.PAR.ops,
-            "outline_color": self.PAR.ops.popup_menu_fg,
+            "outline_color": self.PAR.ops.header_selected_columns_bg,
             "align": self.get_cell_align(c),
             "values": kwargs["values"],
         }

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

@@ -1000,25 +1000,21 @@ class MainTable(tk.Canvas):
         else:
             disp_new_idxs = {}
         # at_least_cols should not be len in this case as move_to can be len
+        fix_len = (move_to - 1) if move_to else move_to
         if not self.all_columns_displayed and not data_indexes:
-            totalcols = self.equalize_data_row_lengths(at_least_cols=self.datacn(move_to))
-        else:
-            totalcols = self.equalize_data_row_lengths(at_least_cols=move_to)
+            fix_len = self.datacn(fix_len)
+        totalcols = self.equalize_data_row_lengths(at_least_cols=fix_len)
         data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         if not self.all_columns_displayed and not data_indexes:
-            moved = {self.displayed_columns[i] for i in to_move}
             data_new_idxs = dict(
-                filter(
-                    lambda tup: tup[0] in moved,
-                    zip(
-                        move_elements_by_mapping(
-                            self.displayed_columns,
-                            data_new_idxs,
-                            dict(zip(data_new_idxs.values(), data_new_idxs)),
-                        ),
+                zip(
+                    move_elements_by_mapping(
                         self.displayed_columns,
+                        data_new_idxs,
+                        dict(zip(data_new_idxs.values(), data_new_idxs)),
                     ),
-                )
+                    self.displayed_columns,
+                ),
             )
         return data_new_idxs, dict(zip(data_new_idxs.values(), data_new_idxs)), totalcols, disp_new_idxs
 
@@ -1108,6 +1104,7 @@ class MainTable(tk.Canvas):
                 tags: {full_new_idxs[k] for k in tagged} for tags, tagged in self.tagged_columns.items()
             }
             self.CH.cell_options = {full_new_idxs[k]: v for k, v in self.CH.cell_options.items()}
+            self.displayed_columns = sorted(full_new_idxs[k] for k in self.displayed_columns)
             if self.named_spans:
                 totalrows = self.total_data_rows()
                 new_ops = self.PAR.create_options_from_span
@@ -1206,8 +1203,6 @@ class MainTable(tk.Canvas):
                                         del self.cell_options[(r, full_new_idxs[k])][span["type_"]]
                     # finally, change the span coords
                     span["from_c"], span["upto_c"] = newfrom, newupto
-            if data_indexes:
-                self.displayed_columns = sorted(full_new_idxs[k] for k in self.displayed_columns)
         return data_new_idxs, disp_new_idxs, event_data
 
     def get_max_column_idx(self, maxidx: int | None = None) -> int:
@@ -1222,6 +1217,7 @@ class MainTable(tk.Canvas):
             max(map(max, self.tagged_columns.values()), default=maxidx),
             max((d.from_c for d in self.named_spans.values() if isinstance(d.from_c, int)), default=maxidx),
             max((d.upto_c for d in self.named_spans.values() if isinstance(d.upto_c, int)), default=maxidx),
+            self.displayed_columns[-1] if self.displayed_columns else maxidx,
         )
 
     def get_args_for_move_rows(
@@ -1235,27 +1231,22 @@ class MainTable(tk.Canvas):
         else:
             disp_new_idxs = {}
         # move_to can be len and fix_data_len() takes index so - 1
+        fix_len = (move_to - 1) if move_to else move_to
         if not self.all_rows_displayed and not data_indexes:
-            fix_len = self.datarn(move_to) - 1
-        else:
-            fix_len = move_to - 1
+            fix_len = self.datarn(fix_len)
         self.fix_data_len(fix_len)
         totalrows = max(self.total_data_rows(), len(self.row_positions) - 1)
         data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         if not self.all_rows_displayed and not data_indexes:
-            moved = {self.displayed_rows[i] for i in to_move}
             data_new_idxs = dict(
-                filter(
-                    lambda tup: tup[0] in moved,
-                    zip(
-                        move_elements_by_mapping(
-                            self.displayed_rows,
-                            data_new_idxs,
-                            dict(zip(data_new_idxs.values(), data_new_idxs)),
-                        ),
+                zip(
+                    move_elements_by_mapping(
                         self.displayed_rows,
+                        data_new_idxs,
+                        dict(zip(data_new_idxs.values(), data_new_idxs)),
                     ),
-                )
+                    self.displayed_rows,
+                ),
             )
         return data_new_idxs, dict(zip(data_new_idxs.values(), data_new_idxs)), totalrows, disp_new_idxs
 
@@ -1343,6 +1334,7 @@ class MainTable(tk.Canvas):
             self.row_options = {full_new_idxs[k]: v for k, v in self.row_options.items()}
             self.RI.cell_options = {full_new_idxs[k]: v for k, v in self.RI.cell_options.items()}
             self.RI.tree_rns = {v: full_new_idxs[k] for v, k in self.RI.tree_rns.items()}
+            self.displayed_rows = sorted(full_new_idxs[k] for k in self.displayed_rows)
             if self.named_spans:
                 totalcols = self.total_data_cols()
                 new_ops = self.PAR.create_options_from_span
@@ -1441,8 +1433,6 @@ class MainTable(tk.Canvas):
                                         del self.cell_options[(full_new_idxs[k], c)][span["type_"]]
                     # finally, change the span coords
                     span["from_r"], span["upto_r"] = newfrom, newupto
-            if data_indexes:
-                self.displayed_rows = sorted(full_new_idxs[k] for k in self.displayed_rows)
         return data_new_idxs, disp_new_idxs, event_data
 
     def get_max_row_idx(self, maxidx: int | None = None) -> int:
@@ -1457,6 +1447,7 @@ class MainTable(tk.Canvas):
             max(map(max, self.tagged_rows.values()), default=maxidx),
             max((d.from_r for d in self.named_spans.values() if isinstance(d.from_r, int)), default=maxidx),
             max((d.upto_r for d in self.named_spans.values() if isinstance(d.upto_r, int)), default=maxidx),
+            self.displayed_rows[-1] if self.displayed_rows else maxidx,
         )
 
     def get_full_new_idxs(
@@ -3319,7 +3310,7 @@ class MainTable(tk.Canvas):
             self.yview_scroll(-1, "units")
             self.RI.yview_scroll(-1, "units")
             self.y_move_synced_scrolls("moveto", self.yview()[0])
-        self.main_table_redraw_grid_and_text(redraw_row_index=True)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def shift_mousewheel(self, event: object) -> None:
         if event.delta < 0 or event.num == 5:
@@ -3332,7 +3323,7 @@ class MainTable(tk.Canvas):
             self.xview_scroll(-1, "units")
             self.CH.xview_scroll(-1, "units")
             self.x_move_synced_scrolls("moveto", self.xview()[0])
-        self.main_table_redraw_grid_and_text(redraw_header=True)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def ctrl_mousewheel(self, event):
         if event.delta < 0 or event.num == 5:
@@ -3697,7 +3688,11 @@ class MainTable(tk.Canvas):
             else:
                 return False
 
-    def set_all_cell_sizes_to_text(self, width: int | None = None, slim: bool = False) -> tuple[list[float], list[float]]:
+    def set_all_cell_sizes_to_text(
+        self,
+        width: int | None = None,
+        slim: bool = False,
+    ) -> tuple[list[float], list[float]]:
         min_column_width = int(self.min_column_width)
         min_rh = int(self.min_row_height)
         h = min_rh
@@ -5239,32 +5234,33 @@ class MainTable(tk.Canvas):
         tag,
         draw_outline=True,
         draw_arrow=True,
-        dd_is_open=False,
+        open_=False,
     ):
         if draw_outline and self.PAR.ops.show_dropdown_borders:
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg, tag=tag)
         if draw_arrow:
             mod = (self.table_txt_height - 1) if self.table_txt_height % 2 else self.table_txt_height
-            half_mod = mod / 2
-            qtr_mod = mod / 4
-            mid_y = (self.table_first_ln_ins - 1) if self.table_first_ln_ins % 2 else self.table_first_ln_ins
-            if dd_is_open:
+            small_mod = int(mod / 5)
+            mid_y = floor(self.min_row_height / 2)
+            if open_:
+                # up arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y - qtr_mod,
+                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 3 - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
                     x2 - 3,
-                    y1 + mid_y + qtr_mod,
+                    y1 + mid_y + small_mod,
                 )
             else:
+                # down arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y + qtr_mod,
+                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 3 - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
                     x2 - 3,
-                    y1 + mid_y - qtr_mod,
+                    y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
@@ -5609,7 +5605,7 @@ class MainTable(tk.Canvas):
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
                                 draw_arrow=mw >= 5,
-                                dd_is_open=dd_coords == (r, c),
+                                open_=dd_coords == (r, c),
                             )
                         else:
                             mw = crightgridln - cleftgridln - 1
@@ -5627,7 +5623,7 @@ class MainTable(tk.Canvas):
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
                                 draw_arrow=mw >= 5,
-                                dd_is_open=dd_coords == (r, c),
+                                open_=dd_coords == (r, c),
                             )
                         else:
                             mw = crightgridln - cleftgridln - 1
@@ -5646,7 +5642,7 @@ class MainTable(tk.Canvas):
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
                                 draw_arrow=mw >= 5,
-                                dd_is_open=dd_coords == (r, c),
+                                open_=dd_coords == (r, c),
                             )
                         else:
                             mw = crightgridln - cleftgridln - 1
@@ -6049,7 +6045,7 @@ class MainTable(tk.Canvas):
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if self.selection_boxes:
             self.itemconfig(next(reversed(self.selection_boxes)), state="normal")
-        x1, y1, x2, y2 = self.box_sheet_coords_x_canvas_coords(r1, c1, r2, c2, type_)
+        x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
         fill_iid = self.display_box(
             x1,
             y1,
@@ -6062,7 +6058,7 @@ class MainTable(tk.Canvas):
             width=1,
         )
         index_iid = self.RI.display_box(
-            1,
+            0,
             y1,
             self.RI.current_width - 1,
             y2,
@@ -6136,7 +6132,7 @@ class MainTable(tk.Canvas):
             if self.PAR.ops.show_selected_cells_border:
                 self.tag_raise(self.selected.iid)
 
-    def box_sheet_coords_x_canvas_coords(
+    def box_coords_x_canvas_coords(
         self,
         r1: int,
         c1: int,
@@ -6183,7 +6179,7 @@ class MainTable(tk.Canvas):
                 state = "normal"
         if self.selected.fill_iid == fill_iid:
             self.selected = self.selected._replace(box=Box_nt(r1, c1, r2, c2))
-        x1, y1, x2, y2 = self.box_sheet_coords_x_canvas_coords(r1, c1, r2, c2, type_)
+        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,

{tksheet-7.2.6 → tksheet-7.2.8}/tksheet/row_index.py

@@ -893,7 +893,7 @@ class RowIndex(tk.Canvas):
                     self.open_cell(event)
                 elif (iid := self.event_over_tree_arrow(r, canvasy, event.x)) is not None:
                     if self.MT.selection_boxes:
-                        self.select_row(r, redraw=False)
+                        self.select_row(r, ext=True, redraw=False)
                     self.PAR.item(iid, open_=iid not in self.tree_open_ids)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -957,9 +957,10 @@ class RowIndex(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        self.MT.deselect("all", redraw=False)
-        box = (r, 0, r + 1, len(self.MT.col_positions) - 1, "rows")
-        fill_iid = self.MT.create_selection_box(*box, ext=ext)
+        boxes_to_hide = tuple(iid for iid in 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)
         if redraw:
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         if run_binding_func:
@@ -1344,29 +1345,37 @@ class RowIndex(tk.Canvas):
         open_: bool = False,
     ) -> None:
         mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
-        half_mod = mod / 2
-        qtr_mod = mod / 4
-        small_mod = int(half_mod / 4) - 1
-        mid_y = int(self.MT.min_row_height / 2)
+        small_mod = int(mod / 5)
+        mid_y = floor(self.MT.min_row_height / 2)
         # up arrow
         if open_:
             points = (
-                x1 + 2 + indent,
-                y1 + mid_y + qtr_mod,
-                x1 + 2 + half_mod + indent,
-                y1 + mid_y - qtr_mod,
-                x1 + 2 + mod + indent,
-                y1 + mid_y + qtr_mod,
+                # 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,
             )
         # right pointing arrow
         else:
             points = (
-                x1 + half_mod + indent,
-                y1 + mid_y - half_mod + small_mod,
-                x1 + mod + indent - small_mod,
+                # 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,
-                x1 + half_mod + indent,
-                y1 + mid_y + half_mod - small_mod,
+                
+                # the bottom point
+                x1 + 5 + indent + small_mod + small_mod,
+                y1 + mid_y + small_mod + small_mod,
             )
         if self.hidd_tree_arrow:
             t, sh = self.hidd_tree_arrow.popitem()
@@ -1404,26 +1413,27 @@ class RowIndex(tk.Canvas):
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.index_fg, tag=tag)
         if draw_arrow:
             mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
-            half_mod = mod / 2
-            qtr_mod = mod / 4
-            mid_y = (self.MT.index_first_ln_ins - 1) if self.MT.index_first_ln_ins % 2 else self.MT.index_first_ln_ins
+            small_mod = int(mod / 5)
+            mid_y = floor(self.MT.min_row_height / 2)
             if open_:
+                # up arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y - qtr_mod,
+                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 3 - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
                     x2 - 3,
-                    y1 + mid_y + qtr_mod,
+                    y1 + mid_y + small_mod,
                 )
             else:
+                # down arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y + qtr_mod,
+                    x2 - 3 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 3 - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
                     x2 - 3,
-                    y1 + mid_y - qtr_mod,
+                    y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
@@ -1683,12 +1693,12 @@ class RowIndex(tk.Canvas):
                 iid = self.MT._row_index[datarn].iid
                 mw -= self.MT.index_txt_height
                 if align == "w":
-                    draw_x += self.MT.index_txt_height + 1
+                    draw_x += self.MT.index_txt_height + 3
                 indent = self.get_treeview_indent(iid)
                 draw_x += indent + 5
                 if self.tree[iid].children:
                     self.redraw_tree_arrow(
-                        0,
+                        2,
                         rtopgridln,
                         r=r,
                         fill=tree_arrow_fg,
@@ -2145,7 +2155,7 @@ class RowIndex(tk.Canvas):
             "height": win_h,
             "font": self.PAR.ops.index_font,
             "ops": self.PAR.ops,
-            "outline_color": self.PAR.ops.popup_menu_fg,
+            "outline_color": self.PAR.ops.index_selected_rows_bg,
             "align": self.get_cell_align(r),
             "values": kwargs["values"],
         }

{tksheet-7.2.6 → tksheet-7.2.8}/tksheet/themes.py

@@ -21,7 +21,7 @@ theme_light_blue: dict[str, str] = DotDict({
     "index_fg": "black",
     "index_selected_cells_bg": "#D3E3FD",
     "index_selected_cells_fg": "black",
-    "top_left_bg": "#FFFFFF",
+    "top_left_bg": "#F9FBFD",
     "top_left_fg": "#C7C7C7",
     "top_left_fg_highlight": "#747775",
     "table_bg": "#FFFFFF",
@@ -84,19 +84,19 @@ theme_light_green: dict[str, str] = DotDict({
     "popup_menu_highlight_fg": "#000000",
     "index_hidden_rows_expander_bg": "gray30",
     "header_hidden_columns_expander_bg": "gray30",
-    "header_bg": "#ECECEC",
+    "header_bg": "#F5F5F5",
     "header_border_fg": "#ababab",
     "header_grid_fg": "#ababab",
     "header_fg": "black",
-    "header_selected_cells_bg": "#d6d4d2",
+    "header_selected_cells_bg": "#CAEAD8",
     "header_selected_cells_fg": "#217346",
-    "index_bg": "#ECECEC",
+    "index_bg": "#F5F5F5",
     "index_border_fg": "#ababab",
     "index_grid_fg": "#ababab",
     "index_fg": "black",
-    "index_selected_cells_bg": "#d6d4d2",
+    "index_selected_cells_bg": "#CAEAD8",
     "index_selected_cells_fg": "#107C41",
-    "top_left_bg": "#ECECEC",
+    "top_left_bg": "#F5F5F5",
     "top_left_fg": "#b7b7b7",
     "top_left_fg_highlight": "#5f6368",
     "table_bg": "#FFFFFF",
@@ -171,7 +171,7 @@ theme_dark: dict[str, str] = DotDict({
     "index_fg": "gray70",
     "index_selected_cells_bg": "#545454",
     "index_selected_cells_fg": "#6aa2fc",
-    "top_left_bg": "#141414",
+    "top_left_bg": "#28282a",
     "top_left_fg": "#505054",
     "top_left_fg_highlight": "white",
     "table_bg": "#000000",
@@ -246,7 +246,7 @@ theme_black: dict[str, str] = DotDict({
     "index_fg": "#FBB86C",
     "index_selected_cells_bg": "#545454",
     "index_selected_cells_fg": "#FBB86C",
-    "top_left_bg": "#000000",
+    "top_left_bg": "#141416",
     "top_left_fg": "#505054",
     "top_left_fg_highlight": "#FBB86C",
     "table_bg": "#000000",

{tksheet-7.2.6 → tksheet-7.2.8}/tksheet/top_left_rectangle.py

@@ -163,6 +163,7 @@ 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:

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

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