tksheet 7.4.12__py3-none-any.whl → 7.4.13__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -5,7 +5,7 @@ from collections import defaultdict
 from collections.abc import Callable, Hashable, Iterator, Sequence
 from functools import partial
 from itertools import cycle, islice, repeat
-from math import ceil, floor
+from math import ceil
 from operator import itemgetter
 from typing import Any, Literal
 
@@ -741,7 +741,7 @@ class ColumnHeaders(tk.Canvas):
         if size < self.ops.min_column_width:
             new_col_pos = ceil(self.MT.col_positions[self.rsz_w - 1] + self.ops.min_column_width)
         elif size > self.ops.max_column_width:
-            new_col_pos = floor(self.MT.col_positions[self.rsz_w - 1] + self.ops.max_column_width)
+            new_col_pos = int(self.MT.col_positions[self.rsz_w - 1] + self.ops.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)
@@ -1373,7 +1373,7 @@ class ColumnHeaders(tk.Canvas):
         if draw_arrow:
             mod = (self.MT.header_txt_height - 1) if self.MT.header_txt_height % 2 else self.MT.header_txt_height
             small_mod = int(mod / 5)
-            mid_y = floor(self.MT.min_header_height / 2)
+            mid_y = int(self.MT.min_header_height / 2)
             if open_:
                 # up arrow
                 points = (
@@ -1552,13 +1552,13 @@ class ColumnHeaders(tk.Canvas):
             else:
                 align = self.align
             if kwargs:
-                max_width = crightgridln - cleftgridln - txt_h - 2
-                if align.endswith("w"):
+                max_width = crightgridln - cleftgridln - txt_h - 5
+                if align[-1] == "w":
                     draw_x = cleftgridln + 2
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = crightgridln - 5 - txt_h
-                elif align.endswith("n"):
-                    draw_x = cleftgridln + ceil((crightgridln - cleftgridln - txt_h) / 2)
+                elif align[-1] == "n":
+                    draw_x = cleftgridln + (crightgridln - cleftgridln - txt_h) / 2
                 self.redraw_dropdown(
                     cleftgridln,
                     0,
@@ -1573,18 +1573,18 @@ class ColumnHeaders(tk.Canvas):
                 )
             else:
                 max_width = crightgridln - cleftgridln - 2
-                if align.endswith("w"):
+                if align[-1] == "w":
                     draw_x = cleftgridln + 2
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = crightgridln - 2
-                elif align.endswith("n"):
-                    draw_x = cleftgridln + floor((crightgridln - cleftgridln) / 2)
+                elif align[-1] == "n":
+                    draw_x = cleftgridln + (crightgridln - cleftgridln) / 2
                 if (kwargs := self.get_cell_kwargs(datacn, key="checkbox")) and max_width > txt_h + 1:
                     box_w = txt_h + 1
-                    if align.endswith("w"):
+                    if align[-1] == "w":
                         draw_x += box_w + 3
-                    elif align.endswith("n"):
-                        draw_x += ceil(box_w / 2) + 1
+                    elif align[-1] == "n":
+                        draw_x += box_w / 2 + 1
                     max_width -= box_w + 4
                     try:
                         draw_check = (
@@ -1606,9 +1606,9 @@ class ColumnHeaders(tk.Canvas):
                     )
             if (
                 max_width < self.MT.header_txt_width
-                or (align.endswith("w") and draw_x > scrollpos_right)
-                or (align.endswith("e") and cleftgridln + 5 > scrollpos_right)
-                or (align.endswith("n") and cleftgridln + 5 > scrollpos_right)
+                or (align[-1] == "w" and draw_x > scrollpos_right)
+                or (align[-1] == "e" and cleftgridln + 5 > scrollpos_right)
+                or (align[-1] == "n" and cleftgridln + 5 > scrollpos_right)
             ):
                 continue
             text = self.cell_str(datacn, fix=False)

tksheet/functions.py

@@ -793,6 +793,11 @@ def move_elements_by_mapping_gen(
     return (seq[old_idxs[i]] if i in old_idxs else next(remaining_values) for i in range(len(seq)))
 
 
+def move_fast(seq: list[Any], new_idxs: dict[int, int], old_idxs: dict[int, int]) -> list[Any]:
+    remaining_values = (e for i, e in enumerate(seq) if i not in new_idxs)
+    return [seq[old_idxs[i]] if i in old_idxs else next(remaining_values) for i in range(len(seq))]
+
+
 def move_elements_to(
     seq: list[Any],
     move_to: int,
@@ -819,10 +824,17 @@ def get_new_indexes(
     returns {old idx: new idx, ...}
     """
     offset = sum(1 for i in to_move if i < move_to)
-    new_idxs = dict(zip(to_move, range(move_to - offset, move_to - offset + len(to_move))))
-    if get_inverse:
-        return new_idxs, dict(zip(new_idxs.values(), new_idxs))
-    return new_idxs
+    correct_move_to = move_to - offset
+    if not get_inverse:
+        return {elem: correct_move_to + i for i, elem in enumerate(to_move)}
+    else:
+        new_idxs = {}
+        old_idxs = {}
+        for i, elem in enumerate(to_move):
+            value = correct_move_to + i
+            new_idxs[elem] = value
+            old_idxs[value] = elem
+        return new_idxs, old_idxs
 
 
 def insert_items(
@@ -833,7 +845,7 @@ def insert_items(
     """
     seq: list[Any]
     to_insert: keys are ints sorted, representing list indexes to insert items.
-               Values are any, e.g. {1: 200, 0: 200}
+               Values are any, e.g. {0: 200, 1: 200}
     """
     if to_insert:
         if seq_len_func and next(reversed(to_insert)) >= len(seq) + len(to_insert):

tksheet/main_table.py

@@ -8,7 +8,6 @@ from collections import defaultdict, deque
 from collections.abc import Callable, Generator, Hashable, Iterator, Sequence
 from functools import partial
 from itertools import accumulate, chain, cycle, filterfalse, islice, repeat
-from math import ceil, floor
 from operator import itemgetter
 from re import IGNORECASE, escape, sub
 from tkinter import TclError
@@ -75,8 +74,8 @@ from .functions import (
     mod_event_val,
     mod_span,
     mod_span_widget,
-    move_elements_by_mapping,
     move_elements_by_mapping_gen,
+    move_fast,
     new_tk_event,
     next_cell,
     push_n,
@@ -323,7 +322,7 @@ class MainTable(tk.Canvas):
             and kwargs["total_rows"] > 0
             and kwargs["total_cols"] > 0
         ):
-            self.data = [list(repeat("", kwargs["total_cols"])) for i in range(kwargs["total_rows"])]
+            self.data = [list(repeat("", kwargs["total_cols"])) for _ in range(kwargs["total_rows"])]
         _header = kwargs["header"] if kwargs["header"] is not None else kwargs["headers"]
         if isinstance(_header, int):
             self._headers = _header
@@ -1498,11 +1497,6 @@ class MainTable(tk.Canvas):
         event_data: EventDataDict | None = None,
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_column_widths = {}
-        if not isinstance(totalcols, int):
-            totalcols = max(data_new_idxs.values(), default=0)
-            if totalcols:
-                totalcols += 1
-            totalcols = self.equalize_data_row_lengths(at_least_cols=totalcols)
         if not event_data:
             event_data = self.new_event_dict("move_columns", state=True)
         if not event_data["moved"]["columns"]:
@@ -1539,26 +1533,26 @@ class MainTable(tk.Canvas):
                     )
             else:
                 self.recreate_all_selection_boxes()
+
         if move_data:
-            self.data = list(
-                map(
-                    move_elements_by_mapping,
-                    self.data,
-                    repeat(data_new_idxs),
-                    repeat(data_old_idxs),
-                ),
-            )
+            if not isinstance(totalcols, int):
+                totalcols = max(data_new_idxs.values(), default=0)
+                if totalcols:
+                    totalcols += 1
+                totalcols = self.equalize_data_row_lengths(at_least_cols=totalcols)
+
+            self.data = [move_fast(k, data_new_idxs, data_old_idxs) for k in self.data]
             maxidx = len_to_idx(totalcols)
             self.CH.fix_header(maxidx)
             if isinstance(self._headers, list) and self._headers:
-                self._headers = move_elements_by_mapping(self._headers, data_new_idxs, data_old_idxs)
+                self._headers = move_fast(self._headers, data_new_idxs, data_old_idxs)
             maxidx = self.get_max_column_idx(maxidx)
-            full_new_idxs = self.get_full_new_idxs(
+            full_new_idxs, full_old_idxs = self.get_full_new_idxs(
                 max_idx=maxidx,
                 new_idxs=data_new_idxs,
                 old_idxs=data_old_idxs,
+                get_inverse=True,
             )
-            full_old_idxs = dict(zip(full_new_idxs.values(), full_new_idxs))
             self.tagged_cells = {
                 tags: {(k[0], full_new_idxs[k[1]]) for k in tagged} for tags, tagged in self.tagged_cells.items()
             }
@@ -1731,14 +1725,14 @@ class MainTable(tk.Canvas):
         data_old_idxs: dict[int, int],
         maxidx: int,
     ) -> None:
-        self.data = move_elements_by_mapping(
+        self.data = move_fast(
             self.data,
             data_new_idxs,
             data_old_idxs,
         )
         self.RI.fix_index(maxidx)
         if isinstance(self._row_index, list) and self._row_index:
-            self._row_index = move_elements_by_mapping(self._row_index, data_new_idxs, data_old_idxs)
+            self._row_index = move_fast(self._row_index, data_new_idxs, data_old_idxs)
 
     def move_rows_adjust_options_dict(
         self,
@@ -1790,12 +1784,12 @@ class MainTable(tk.Canvas):
             else:
                 self.move_rows_data(data_new_idxs, data_old_idxs, maxidx)
             maxidx = self.get_max_row_idx(maxidx)
-            full_new_idxs = self.get_full_new_idxs(
+            full_new_idxs, full_old_idxs = self.get_full_new_idxs(
                 max_idx=maxidx,
                 new_idxs=data_new_idxs,
                 old_idxs=data_old_idxs,
+                get_inverse=True,
             )
-            full_old_idxs = dict(zip(full_new_idxs.values(), full_new_idxs))
             self.tagged_cells = {
                 tags: {(full_new_idxs[k[0]], k[1]) for k in tagged} for tags, tagged in self.tagged_cells.items()
             }
@@ -1956,6 +1950,7 @@ class MainTable(tk.Canvas):
         max_idx: int,
         new_idxs: dict[int, int],
         old_idxs: None | dict[int, int] = None,
+        get_inverse: bool = False,
     ) -> dict[int, int]:
         # return a dict of all row or column indexes
         # old indexes and new indexes, not just the
@@ -1963,13 +1958,18 @@ class MainTable(tk.Canvas):
         # {old index: new index, ...}
         # all the way from 0 to max_idx
         if old_idxs is None:
-            old_idxs = dict(zip(new_idxs.values(), new_idxs))
-        return dict(
-            zip(
-                move_elements_by_mapping_gen(tuple(range(max_idx + 1)), new_idxs, old_idxs),
-                range(max_idx + 1),
-            )
-        )
+            old_idxs = {v: k for k, v in new_idxs.items()}
+        if get_inverse:
+            d = {}
+            d_in = {}
+            for v, k in enumerate(move_elements_by_mapping_gen(tuple(range(max_idx + 1)), new_idxs, old_idxs)):
+                d[k] = v
+                d_in[v] = k
+            return d, d_in
+        else:
+            return {
+                k: v for v, k in enumerate(move_elements_by_mapping_gen(tuple(range(max_idx + 1)), new_idxs, old_idxs))
+            }
 
     def undo(self, event: Any = None) -> None | EventDataDict:
         if not self.undo_stack:
@@ -4047,7 +4047,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_header=True, redraw_row_index=True)
+        self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=True)
 
     def shift_mousewheel(self, event: Any) -> None:
         if event.delta < 0 or event.num == 5:
@@ -4060,7 +4060,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, redraw_row_index=True)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
 
     def ctrl_mousewheel(self, event: Any) -> None:
         if event.delta < 0 or event.num == 5:
@@ -4441,7 +4441,7 @@ class MainTable(tk.Canvas):
                 self.cells_cache = self._redraw_precache_cells(disprn, disprn + 1, 0, len(self.col_positions) - 1)
             if not (align := self.get_cell_kwargs(datarn, datacn, key="align")):
                 align = self.align
-            if align.endswith("w"):
+            if align[-1] == "w":
                 max_width += sum(
                     self._overflow(
                         self.cells_cache,
@@ -4449,7 +4449,7 @@ class MainTable(tk.Canvas):
                         datarn,
                     )
                 )
-            elif align.endswith("e"):
+            elif align[-1] == "e":
                 max_width += sum(
                     self._overflow(
                         self.cells_cache,
@@ -4768,6 +4768,7 @@ class MainTable(tk.Canvas):
         self,
         rows: list[int] | tuple[int],
         create_ops: bool = True,
+        tree: bool = True,
     ) -> None:
         self.tagged_cells = {
             tags: {(push_n(r, rows), c) for (r, c) in tagged} for tags, tagged in self.tagged_cells.items()
@@ -4777,7 +4778,8 @@ class MainTable(tk.Canvas):
         self.tagged_rows = {tags: {push_n(r, rows) for r in tagged} for tags, tagged in self.tagged_rows.items()}
         self.row_options = {push_n(r, rows): v for r, v in self.row_options.items()}
         self.RI.cell_options = {push_n(r, rows): v for r, v in self.RI.cell_options.items()}
-        self.RI.rns = {k: push_n(r, rows) for k, r in self.RI.rns.items()}
+        if tree:
+            self.RI.rns = {k: push_n(r, rows) for k, r in self.RI.rns.items()}
         # if there are named spans where rows were added
         # add options to gap which was created by adding rows
         totalcols = None
@@ -5044,7 +5046,7 @@ class MainTable(tk.Canvas):
             event_data["added"]["rows"] = {
                 "table": {},
                 "index": {},
-                "row_heights": {rn: default_height for rn in range(len(self.row_positions) - 1, maxrn + 1)},
+                "row_heights": dict.fromkeys(range(len(self.row_positions) - 1, maxrn + 1), default_height),
             }
             if not from_undo:
                 self.set_row_positions(
@@ -5168,7 +5170,7 @@ class MainTable(tk.Canvas):
             event_data["added"]["columns"] = {
                 "table": {},
                 "header": {},
-                "column_widths": {cn: default_width for cn in range(len(self.col_positions) - 1, maxcn + 1)},
+                "column_widths": dict.fromkeys(range(len(self.col_positions) - 1, maxcn + 1), default_width),
             }
             if not from_undo:
                 self.set_col_positions(
@@ -5181,6 +5183,7 @@ class MainTable(tk.Canvas):
             self.adjust_options_post_add_rows(
                 rows=tuple(rows),
                 create_ops=create_ops,
+                tree=tree,
             )
         event_data["added"]["rows"] = {
             "table": rows,
@@ -6084,7 +6087,7 @@ class MainTable(tk.Canvas):
         if draw_arrow:
             mod = (self.table_txt_height - 1) if self.table_txt_height % 2 else self.table_txt_height
             small_mod = int(mod / 5)
-            mid_y = floor(self.min_row_height / 2)
+            mid_y = int(self.min_row_height / 2)
             if open_:
                 # up arrow
                 points = (
@@ -6283,19 +6286,25 @@ class MainTable(tk.Canvas):
                 # self.get_cell_kwargs not used here to boost performance
                 if t in self.cell_options and "dropdown" in self.cell_options[t]:
                     cells["dropdown"][t] = self.cell_options[t]["dropdown"]
+
                 elif datarn in self.row_options and "dropdown" in self.row_options[datarn]:
                     cells["dropdown"][t] = self.row_options[datarn]["dropdown"]
+
                 elif datacn in self.col_options and "dropdown" in self.col_options[datacn]:
                     cells["dropdown"][t] = self.col_options[datacn]["dropdown"]
+
                 else:
                     if t in self.cell_options and "checkbox" in self.cell_options[t]:
                         cells["checkbox"][t] = self.cell_options[t]["checkbox"]
+
                     elif datarn in self.row_options and "checkbox" in self.row_options[datarn]:
                         cells["checkbox"][t] = self.row_options[datarn]["checkbox"]
+
                     elif datacn in self.col_options and "checkbox" in self.col_options[datacn]:
                         cells["checkbox"][t] = self.col_options[datacn]["checkbox"]
 
                 cells[t] = self.cell_str(datarn, datacn, get_displayed=True)
+
         return cells
 
     def wrap_get_char_w(self, c: str) -> int:
@@ -6380,6 +6389,7 @@ class MainTable(tk.Canvas):
             if changed_w:
                 for widget in (self, self.RI, self.CH, self.TL):
                     widget.update_idletasks()
+                return
         # important vars
         x_stop = min(last_col_line_pos, scrollpos_right)
         y_stop = min(last_row_line_pos, scrollpos_bot)
@@ -6452,14 +6462,14 @@ class MainTable(tk.Canvas):
             else:
                 alternate_color = None
                 dont_blend = ()
-            if not self.PAR.ops.show_selected_cells_border:
+            if self.PAR.ops.show_selected_cells_border:
+                override = ()
+            else:
                 override = (
                     color_tup(self.PAR.ops.table_selected_cells_fg),
                     color_tup(self.PAR.ops.table_selected_columns_fg),
                     color_tup(self.PAR.ops.table_selected_rows_fg),
                 )
-            else:
-                override = ()
             allow_overflow = self.PAR.ops.allow_cell_overflow
             wrap = self.PAR.ops.table_wrap
             cells = self._redraw_precache_cells(
@@ -6509,12 +6519,12 @@ class MainTable(tk.Canvas):
                     kws = cells["dropdown"][t] if t in cells["dropdown"] else None  # noqa: SIM401
                     if kws:
                         max_width = crightgridln - cleftgridln - self.table_txt_height - 5
-                        if align.endswith("w"):
+                        if align[-1] == "w":
                             draw_x = cleftgridln + 2
-                        elif align.endswith("e"):
+                        elif align[-1] == "e":
                             draw_x = crightgridln - 5 - self.table_txt_height
-                        elif align.endswith("n"):
-                            draw_x = cleftgridln + ceil((crightgridln - cleftgridln - self.table_txt_height) / 2)
+                        elif align[-1] == "n":
+                            draw_x = cleftgridln + (crightgridln - cleftgridln - self.table_txt_height) / 2
                         self.redraw_dropdown(
                             cleftgridln,
                             rtopgridln,
@@ -6528,49 +6538,43 @@ class MainTable(tk.Canvas):
                         )
                     else:
                         max_width = crightgridln - cleftgridln - 2
-                        if align.endswith("w"):
+                        if align[-1] == "w":
                             draw_x = cleftgridln + 2
-                        elif align.endswith("e"):
+                        elif align[-1] == "e":
                             draw_x = crightgridln - 2
-                        elif align.endswith("n"):
-                            draw_x = cleftgridln + floor((crightgridln - cleftgridln) / 2)
-
-                        kws = cells["checkbox"][t] if t in cells["checkbox"] else None  # noqa: SIM401
-                        if kws and max_width > self.table_txt_height + 1:
-                            box_w = self.table_txt_height + 1
-                            if align.endswith("w"):
-                                draw_x += box_w + 3
-                            elif align.endswith("n"):
-                                draw_x += ceil(box_w / 2) + 1
-                            max_width -= box_w + 4
-                            try:
-                                draw_check = bool(self.data[datarn][datacn])
-                            except Exception:
-                                draw_check = False
-                            self.redraw_checkbox(
-                                cleftgridln + 2,
-                                rtopgridln + 2,
-                                cleftgridln + self.table_txt_height + 3,
-                                rtopgridln + self.table_txt_height + 3,
-                                fill=fill if kws["state"] == "normal" else self.PAR.ops.table_grid_fg,
-                                outline="",
-                                draw_check=draw_check,
-                            )
+                        elif align[-1] == "n":
+                            draw_x = cleftgridln + (crightgridln - cleftgridln) / 2
+
+                        if t in cells["checkbox"]:
+                            kws = cells["checkbox"][t]
+                            if max_width > self.table_txt_height + 1:
+                                box_w = self.table_txt_height + 1
+                                if align[-1] == "w":
+                                    draw_x += box_w + 3
+                                elif align[-1] == "n":
+                                    draw_x += box_w / 2 + 1
+                                max_width -= box_w + 4
+                                try:
+                                    draw_check = bool(self.data[datarn][datacn])
+                                except Exception:
+                                    draw_check = False
+                                self.redraw_checkbox(
+                                    cleftgridln + 2,
+                                    rtopgridln + 2,
+                                    cleftgridln + self.table_txt_height + 3,
+                                    rtopgridln + self.table_txt_height + 3,
+                                    fill=fill if kws["state"] == "normal" else self.PAR.ops.table_grid_fg,
+                                    outline="",
+                                    draw_check=draw_check,
+                                )
                     text = cells[t]
-                    if (
-                        not text
-                        or (align.endswith("w") and draw_x > scrollpos_right)
-                        or (align.endswith("e") and cleftgridln + 5 > scrollpos_right)
-                        or (align.endswith("n") and cleftgridln + 5 > scrollpos_right)
-                    ):
+                    if not text or (align[-1] == "w" and draw_x > scrollpos_right) or cleftgridln + 5 > scrollpos_right:
                         continue
                     if allow_overflow and not kws:
-                        if align.endswith("w"):
+                        if align[-1] == "w":
                             max_width += sum(self._overflow(cells, range(c + 1, text_end_col), datarn))
-                        elif align.endswith("e"):
+                        elif align[-1] == "e":
                             max_width += sum(self._overflow(cells, reversed(range(text_start_col, c)), datarn))
-                        elif align.endswith("n"):
-                            ...
                     if max_width <= 1:
                         continue
                     start_line = max(0, int((scrollpos_top - rtopgridln) / self.table_txt_height))
@@ -6584,7 +6588,7 @@ class MainTable(tk.Canvas):
                         wrap=wrap,
                         start_line=start_line,
                     )
-                    if align.endswith(("w", "e")):
+                    if align[-1] == "w" or align[-1] == "e":
                         if self.hidd_text:
                             iid, showing = self.hidd_text.popitem()
                             self.coords(iid, draw_x, draw_y)
@@ -6617,15 +6621,15 @@ class MainTable(tk.Canvas):
                             )
                         self.disp_text[iid] = True
 
-                    elif align.endswith("n"):
-                        for text in gen_lines:
+                    elif align[-1] == "n":
+                        for t in gen_lines:
                             if self.hidd_text:
                                 iid, showing = self.hidd_text.popitem()
                                 self.coords(iid, draw_x, draw_y)
                                 if showing:
                                     self.itemconfig(
                                         iid,
-                                        text=text,
+                                        text=t,
                                         fill=fill,
                                         font=font,
                                         anchor=align,
@@ -6633,7 +6637,7 @@ class MainTable(tk.Canvas):
                                 else:
                                     self.itemconfig(
                                         iid,
-                                        text=text,
+                                        text=t,
                                         fill=fill,
                                         font=font,
                                         anchor=align,
@@ -6643,7 +6647,7 @@ class MainTable(tk.Canvas):
                                 iid = self.create_text(
                                     draw_x,
                                     draw_y,
-                                    text=text,
+                                    text=t,
                                     fill=fill,
                                     font=font,
                                     anchor=align,
@@ -6668,11 +6672,11 @@ class MainTable(tk.Canvas):
                         self.tag_raise(box.bd_iid)
                 if self.selected:
                     self.tag_raise(self.selected.iid)
-            self.tag_raise("t")
             if self.RI.disp_resize_lines:
                 self.tag_raise("rh")
             if self.CH.disp_resize_lines:
                 self.tag_raise("rw")
+            self.tag_raise("t")
         if redraw_header and self.show_header:
             self.CH.redraw_grid_and_text(
                 last_col_line_pos=last_col_line_pos,
@@ -6781,7 +6785,7 @@ class MainTable(tk.Canvas):
             box = next(iter(reversed(self.selection_boxes.values())))
             r1, c1, r2, c2 = box.coords
             if r2 - r1 == 1 and c2 - c1 == 1:
-                self.itemconfig(box.fill_iid, state="hidden")
+                box.state = "hidden"
             self.set_currently_selected(item=box.fill_iid)
 
     def coords_and_type(self, item: int) -> tuple:
@@ -7117,9 +7121,10 @@ class MainTable(tk.Canvas):
 
     def get_redraw_selections(self, startr: int, endr: int, startc: int, endc: int) -> dict:
         d = defaultdict(set)
+        ignore_hidd_current = not self.PAR.ops.show_selected_cells_border
         for _, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
-            if box.state == "normal":
+            if box.state == "normal" or ignore_hidd_current:
                 if box.type_ == "cells":
                     for r in range(startr, endr):
                         for c in range(startc, endc):
@@ -8081,23 +8086,49 @@ class MainTable(tk.Canvas):
         cell value is not in datatypes kwarg
         if get displayed is true then Nones are replaced by
         """
-        kwargs = self.get_cell_kwargs(datarn, datacn, key=None)
         if get_displayed:
-            if kwargs and "dropdown" in kwargs:
-                if kwargs["dropdown"]["text"] is not None:
-                    return f"{kwargs['dropdown']['text']}"
-            elif kwargs and "checkbox" in kwargs:
-                return f"{kwargs['checkbox']['text']}"
+            # check for dropdown
+            if (datarn, datacn) in self.cell_options and "dropdown" in self.cell_options[(datarn, datacn)]:
+                kws = self.cell_options[(datarn, datacn)]["dropdown"]
+            elif datarn in self.row_options and "dropdown" in self.row_options[datarn]:
+                kws = self.row_options[datarn]["dropdown"]
+            elif datacn in self.col_options and "dropdown" in self.col_options[datacn]:
+                kws = self.col_options[datacn]["dropdown"]
+            else:
+                kws = None
+            if kws and kws["text"] is not None:
+                return f"{kws['text']}"
+
+            # check for checkbox
+            if (datarn, datacn) in self.cell_options and "checkbox" in self.cell_options[(datarn, datacn)]:
+                kws = self.cell_options[(datarn, datacn)]["checkbox"]
+            elif datarn in self.row_options and "checkbox" in self.row_options[datarn]:
+                kws = self.row_options[datarn]["checkbox"]
+            elif datacn in self.col_options and "checkbox" in self.col_options[datacn]:
+                kws = self.col_options[datacn]["checkbox"]
+            else:
+                kws = None
+            if kws:
+                return f"{kws['text']}"
         try:
             value = self.data[datarn][datacn]
         except Exception:
             value = ""
-        if "format" in kwargs:
-            if kwargs["format"]["formatter"] is None:
+        # check for format
+        if (datarn, datacn) in self.cell_options and "format" in self.cell_options[(datarn, datacn)]:
+            kws = self.cell_options[(datarn, datacn)]["format"]
+        elif datarn in self.row_options and "format" in self.row_options[datarn]:
+            kws = self.row_options[datarn]["format"]
+        elif datacn in self.col_options and "format" in self.col_options[datacn]:
+            kws = self.col_options[datacn]["format"]
+        else:
+            kws = None
+        if kws:
+            if kws["formatter"] is None:
                 if get_displayed:
-                    return data_to_str(value, **kwargs["format"])
+                    return data_to_str(value, **kws)
                 else:
-                    return f"{get_data_with_valid_check(value, **kwargs['format'])}"
+                    return f"{get_data_with_valid_check(value, **kws)}"
             else:
                 if get_displayed:
                     # assumed given formatter class has __str__()
@@ -8106,7 +8137,7 @@ class MainTable(tk.Canvas):
                     # assumed given formatter class has get_data_with_valid_check()
                     return f"{value.get_data_with_valid_check()}"
         else:
-            return "" if value is None else value if isinstance(value, str) else f"{value}"
+            return "" if value is None else str(value)
 
     def get_cell_data(
         self,

tksheet/other_classes.py

@@ -448,7 +448,7 @@ class Node:
         self,
         text: str,
         iid: str,
-        parent: str | None = None,
+        parent: str = "",
         children: list[str] | None = None,
     ) -> None:
         self.text = text

tksheet/row_index.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import tkinter as tk
 from collections import defaultdict
 from collections.abc import Callable, Generator, Hashable, Iterator, Sequence
+from contextlib import suppress
 from functools import partial
-from itertools import chain, cycle, islice, repeat
-from math import ceil, floor
+from itertools import cycle, islice, repeat
+from math import ceil
 from operator import itemgetter
 from typing import Any, Literal
 
@@ -758,7 +759,7 @@ class RowIndex(tk.Canvas):
         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.ops.max_row_height:
-            new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.ops.max_row_height)
+            new_row_pos = int(self.MT.row_positions[self.rsz_h - 1] + self.ops.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)
@@ -1071,7 +1072,7 @@ class RowIndex(tk.Canvas):
                 align = self.cell_options[datarn]["align"]
             else:
                 align = self.align
-            if align.endswith("w"):
+            if align[-1] == "w":
                 w += self.MT.index_txt_height
             w += self.get_iid_indent(self.MT._row_index[datarn].iid) + 10
         return w, h
@@ -1245,7 +1246,7 @@ class RowIndex(tk.Canvas):
             new_w = self.get_index_text_width(only_rows=only_rows)
         else:
             new_w = None
-        if new_w is not None and (sheet_w_x := floor(self.PAR.winfo_width() * 0.7)) < new_w:
+        if new_w is not None and (sheet_w_x := int(self.PAR.winfo_width() * 0.7)) < new_w:
             new_w = sheet_w_x
         if new_w and (self.current_width - new_w > 20 or new_w - self.current_width > 3):
             if self.MT.find_window.open:
@@ -1394,7 +1395,7 @@ class RowIndex(tk.Canvas):
     ) -> None:
         mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
         small_mod = int(mod / 5)
-        mid_y = floor(self.MT.min_row_height / 2)
+        mid_y = int(self.MT.min_row_height / 2)
         if has_children:
             # up arrow
             if open_:
@@ -1490,7 +1491,7 @@ class RowIndex(tk.Canvas):
         if draw_arrow:
             mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
             small_mod = int(mod / 5)
-            mid_y = floor(self.MT.min_row_height / 2)
+            mid_y = int(self.MT.min_row_height / 2)
             if open_:
                 # up arrow
                 points = (
@@ -1673,13 +1674,13 @@ class RowIndex(tk.Canvas):
             else:
                 align = self.align
             if dropdown_kwargs:
-                max_width = self.current_width - self.MT.index_txt_height - 2
-                if align.endswith("w"):
+                max_width = self.current_width - self.MT.index_txt_height - 5
+                if align[-1] == "w":
                     draw_x = 3
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = self.current_width - 5 - self.MT.index_txt_height
-                elif align.endswith("n"):
-                    draw_x = ceil((self.current_width - self.MT.index_txt_height) / 2)
+                elif align[-1] == "n":
+                    draw_x = (self.current_width - self.MT.index_txt_height) / 2
                 self.redraw_dropdown(
                     0,
                     rtopgridln,
@@ -1694,22 +1695,22 @@ class RowIndex(tk.Canvas):
                 )
             else:
                 max_width = self.current_width - 2
-                if align.endswith("w"):
+                if align[-1] == "w":
                     draw_x = 3
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = self.current_width - 3
-                elif align.endswith("n"):
-                    draw_x = floor(self.current_width / 2)
+                elif align[-1] == "n":
+                    draw_x = self.current_width / 2
                 if (
                     (checkbox_kwargs := self.get_cell_kwargs(datarn, key="checkbox"))
                     and not dropdown_kwargs
                     and max_width > self.MT.index_txt_height + 1
                 ):
                     box_w = self.MT.index_txt_height + 1
-                    if align.endswith("w"):
+                    if align[-1] == "w":
                         draw_x += box_w + 3
-                    elif align.endswith("n"):
-                        draw_x += ceil(box_w / 2) + 1
+                    elif align[-1] == "n":
+                        draw_x += box_w / 2 + 1
                     max_width -= box_w + 4
                     try:
                         draw_check = (
@@ -1732,7 +1733,7 @@ class RowIndex(tk.Canvas):
             if treeview and isinstance(self.MT._row_index, list) and len(self.MT._row_index) > datarn:
                 iid = self.MT._row_index[datarn].iid
                 max_width -= self.MT.index_txt_height
-                if align.endswith("w"):
+                if align[-1] == "w":
                     draw_x += self.MT.index_txt_height + 3
                 level, indent = self.get_iid_level_indent(iid)
                 draw_x += indent + 5
@@ -2729,16 +2730,17 @@ class RowIndex(tk.Canvas):
                 )
                 # deal with displayed mapping
                 event_data["moved"]["rows"]["displayed"] = {}
-                if new_loc_is_displayed:
-                    if disp_insert_row is None:
-                        if new_parent or insert_row > move_to_row:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1  # TODO: maybe issues here
+                with suppress(Exception):
+                    if new_loc_is_displayed:
+                        if disp_insert_row is None:
+                            if new_parent or insert_row > move_to_row:
+                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1
+                            else:
+                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
+                        if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
+                            event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
                         else:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
-                    if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
-                        event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
-                    else:
-                        event_data["moved"]["rows"]["displayed"] = {(): disp_insert_row}
+                            event_data["moved"]["rows"]["displayed"] = {(): disp_insert_row}
 
                 if any(self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows):
                     event_data["moved"]["rows"] = {}
@@ -2759,7 +2761,7 @@ class RowIndex(tk.Canvas):
                         event_data["moved"]["rows"]["data"],
                     )
                     data_new_idxs = event_data["moved"]["rows"]["data"]
-                    data_old_idxs = dict(zip(data_new_idxs.values(), data_new_idxs))
+                    data_old_idxs = {v: k for k, v in data_new_idxs.items()}
 
                     if () in event_data["moved"]["rows"]["displayed"]:
                         del event_data["moved"]["rows"]["displayed"][()]
@@ -2988,15 +2990,6 @@ class RowIndex(tk.Canvas):
             if not parent_node.children:
                 self.tree_open_ids.discard(parent_node.iid)
 
-    def build_pid_causes_recursive_loop(self, iid: str, pid: str) -> bool:
-        return any(
-            i == pid
-            for i in chain(
-                self.get_iid_descendants(iid),
-                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
@@ -3017,8 +3010,8 @@ class RowIndex(tk.Canvas):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> None:
-        index = self.MT._row_index
         data_rns = {}
+        tree = {}
         if text_column is None:
             text_column = iid_column
         if not isinstance(ncols, int):
@@ -3030,33 +3023,27 @@ class RowIndex(tk.Canvas):
             else:
                 iid = row[iid_column]
                 pid = row[parent_column]
-            if iid in self.rns:
-                index[self.rns[iid]].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            if iid in tree:
+                tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
             else:
-                index.append(
-                    Node(
-                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
-                        iid=iid,
-                        parent="",
-                    )
+                tree[iid] = Node(
+                    text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                    iid=iid,
+                    parent="",
                 )
-                self.rns[iid] = len(index) - 1
             data_rns[iid] = rn
             if pid:
-                if pid in self.rns:
-                    index[self.rns[pid]].children.append(iid)
+                if pid in tree:
+                    tree[pid].children.append(iid)
                 else:
-                    index.append(
-                        Node(
-                            text=pid,
-                            iid=pid,
-                            children=[iid],
-                        )
+                    tree[pid] = Node(
+                        text=pid,
+                        iid=pid,
+                        children=[iid],
                     )
-                    self.rns[pid] = len(index) - 1
-                index[self.rns[iid]].parent = pid
+                tree[iid].parent = pid
             else:
-                index[self.rns[iid]].parent = ""
+                tree[iid].parent = ""
         exclude = set()
         if not include_iid_column:
             exclude.add(iid_column)
@@ -3065,18 +3052,35 @@ class RowIndex(tk.Canvas):
         if isinstance(text_column, int) and not include_text_column:
             exclude.add(text_column)
         rows = []
+        ctr = 0
         if exclude:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
-                rows.append(row)
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(e for i, e in enumerate(data[data_rns[diid]]) if i not in exclude)
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         else:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                row.extend(data[data_rns[iid]])
-                rows.append(row)
-        self.MT._row_index = []
-        self.rns = {}
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    row.extend(data[data_rns[iid]])
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(data[data_rns[diid]])
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         self.PAR.insert_rows(
             rows=rows,
             idx=0,
@@ -3091,7 +3095,6 @@ class RowIndex(tk.Canvas):
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
-        self.rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         if open_ids:
             self.PAR.tree_set_open(open_ids=open_ids)
         else:
@@ -3118,8 +3121,8 @@ class RowIndex(tk.Canvas):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> None:
-        index = self.MT._row_index
         data_rns = {}
+        tree = {}
         iids_missing_rows = set()
         if text_column is None:
             text_column = iid_column
@@ -3146,43 +3149,36 @@ class RowIndex(tk.Canvas):
                     x += 1
                 tally_of_ids[iid] += 1
                 row[iid_column] = new
-            if iid in self.rns:
-                index[self.rns[iid]].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            if iid in tree:
+                tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
             else:
-                index.append(
-                    Node(
-                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
-                        iid=iid,
-                        parent="",
-                    )
+                tree[iid] = Node(
+                    text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                    iid=iid,
+                    parent="",
                 )
-                self.rns[iid] = len(index) - 1
             if iid in iids_missing_rows:
                 iids_missing_rows.discard(iid)
             data_rns[iid] = rn
-            if iid == pid or self.build_pid_causes_recursive_loop(iid, pid):
+            if iid == pid or self.build_pid_causes_recursive_loop(iid, pid, tree):
                 row[parent_column] = ""
                 pid = ""
             if pid:
-                if pid in self.rns:
-                    index[self.rns[pid]].children.append(iid)
+                if pid in tree:
+                    tree[pid].children.append(iid)
                 else:
-                    index.append(
-                        Node(
-                            text=pid,
-                            iid=pid,
-                            children=[iid],
-                        )
+                    tree[pid] = Node(
+                        text=pid,
+                        iid=pid,
+                        children=[iid],
                     )
                     iids_missing_rows.add(pid)
-                    self.rns[pid] = len(index) - 1
-                index[self.rns[iid]].parent = pid
+                tree[iid].parent = pid
             else:
-                index[self.rns[iid]].parent = ""
+                tree[iid].parent = ""
         empty_rows = {}
         for iid in iids_missing_rows:
-            node = index[self.rns[iid]]
-            node.parent = ""
+            node = tree[iid]
             newrow = self.MT.get_empty_row_seq(len(data), ncols)
             newrow[iid_column] = node.iid
             empty_rows[node.iid] = newrow
@@ -3194,24 +3190,41 @@ class RowIndex(tk.Canvas):
         if isinstance(text_column, int) and not include_text_column:
             exclude.add(text_column)
         rows = []
+        ctr = 0
         if exclude:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                if iid in empty_rows:
-                    row.extend(e for i, e in enumerate(empty_rows[iid]) if i not in exclude)
-                else:
-                    row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
-                rows.append(row)
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    if iid in empty_rows:
+                        row.extend(e for i, e in enumerate(empty_rows[iid]) if i not in exclude)
+                    else:
+                        row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(e for i, e in enumerate(data[data_rns[diid]]) if i not in exclude)
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         else:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                if iid in empty_rows:
-                    row.extend(empty_rows[iid])
-                else:
-                    row.extend(data[data_rns[iid]])
-                rows.append(row)
-        self.MT._row_index = []
-        self.rns = {}
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    if iid in empty_rows:
+                        row.extend(empty_rows[iid])
+                    else:
+                        row.extend(data[data_rns[iid]])
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(data[data_rns[diid]])
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         self.PAR.insert_rows(
             rows=rows,
             idx=0,
@@ -3226,7 +3239,6 @@ class RowIndex(tk.Canvas):
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
-        self.rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         if open_ids:
             self.PAR.tree_set_open(open_ids=open_ids)
         else:
@@ -3237,3 +3249,29 @@ class RowIndex(tk.Canvas):
                 data_indexes=True,
                 row_heights=row_heights is not False,
             )
+
+    def _build_get_descendants(self, iid: str, tree: dict[str, Node]) -> Generator[str]:
+        stack = [iter(tree[iid].children)]
+        while stack:
+            top_iterator = stack[-1]
+            try:
+                ciid = next(top_iterator)
+                yield ciid
+                if tree[ciid].children:
+                    stack.append(iter(tree[ciid].children))
+            except StopIteration:
+                stack.pop()
+
+    def build_pid_causes_recursive_loop(self, iid: str, pid: str, tree: dict[str, Node]) -> bool:
+        # check descendants
+        for diid in self._build_get_descendants(iid, tree):
+            if diid == pid:
+                return True
+        # check ancestors
+        current_iid = iid
+        while tree[current_iid].parent:
+            parent_iid = tree[current_iid].parent
+            if parent_iid == pid:
+                return True
+            current_iid = parent_iid
+        return False

tksheet/sheet.py

@@ -127,7 +127,7 @@ class Sheet(tk.Frame):
         max_row_height: float = float("inf"),
         max_header_height: float = float("inf"),
         max_index_width: float = float("inf"),
-        after_redraw_time_ms: int = 20,
+        after_redraw_time_ms: int = 16,
         set_all_heights_and_widths: bool = False,
         zoom: int = 100,
         align: str = "nw",
@@ -4647,10 +4647,9 @@ class Sheet(tk.Frame):
             if index[rns[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)
+                    for did in descendants(item, check_open=True):
+                        disp_set.add(rns[did])
+                        to_open.append(rns[did])
         return to_open
 
     def tree_open(self, *items, redraw: bool = True) -> Sheet:
@@ -4924,7 +4923,7 @@ class Sheet(tk.Frame):
         """
         Also deletes all descendants of items
         """
-        rows = list(map(self.RI.rns.get, filter(self.exists, unpack(items))))
+        rows = list(map(self.RI.rns.__getitem__, filter(self.exists, unpack(items))))
         if rows:
             self.del_rows(rows, data_indexes=True, undo=undo)
         return self.set_refresh_timer(rows)
@@ -5138,13 +5137,20 @@ class Sheet(tk.Frame):
         for func in self.bound_events[event]:
             func(data)
 
-    def set_refresh_timer(self, redraw: bool = True) -> Sheet:
+    def set_refresh_timer(
+        self,
+        redraw: bool = True,
+        index: bool = True,
+        header: bool = True,
+    ) -> Sheet:
         if redraw and self.after_redraw_id is None:
-            self.after_redraw_id = self.after(self.after_redraw_time_ms, self.after_redraw)
+            self.after_redraw_id = self.after(
+                self.after_redraw_time_ms, lambda: self.after_redraw(index=index, header=header)
+            )
         return self
 
-    def after_redraw(self) -> None:
-        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+    def after_redraw(self, index: bool = True, header: bool = True) -> None:
+        self.MT.main_table_redraw_grid_and_text(redraw_header=header, redraw_row_index=index)
         self.after_redraw_id = None
 
     def del_options_using_span(

{tksheet-7.4.12.dist-info → tksheet-7.4.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tksheet
-Version: 7.4.12
+Version: 7.4.13
 Summary: Tkinter table / sheet and treeview widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -63,23 +63,23 @@ License-File: LICENSE.txt
   <tbody>
     <tr>
       <td style="color: LightCoral">Versions 6.x.x &#8594;</td>
-      <td><a href="https://github.com/ragardner/tksheet/wiki/Version-6">Documentation</a></td>
+      <td><a href="https://github.com/ragardner/tksheet/wiki/Version-6" target="_blank">Documentation</a></td>
     </tr>
     <tr>
       <td style="color: lightgreen">Versions 7.x.x &#8594;</td>
-      <td><a href="https://ragardner.github.io/tksheet/DOCUMENTATION.html">Documentation</a></td>
+      <td><a href="https://ragardner.github.io/tksheet/DOCUMENTATION.html" target="_blank">Documentation</a></td>
     </tr>
     <tr>
-      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/blob/master/docs/CHANGELOG.md">Changelog</a></td>
+      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/blob/master/docs/CHANGELOG.md" target="_blank">Changelog</a></td>
     </tr>
     <tr>
-      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#asking-questions">Questions</a></td>
+      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#asking-questions" target="_blank">Questions</a></td>
     </tr>
     <tr>
-      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#issues">Issues</a></td>
+      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#issues" target="_blank">Issues</a></td>
     </tr>
     <tr>
-      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#enhancements-or-suggestions">Suggestions and Contributors</a></td>
+      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#enhancements-or-suggestions" target="_blank">Suggestions and Contributors</a></td>
     </tr>
   </tbody>
 </table>

tksheet-7.4.13.dist-info/RECORD

@@ -0,0 +1,22 @@
+tksheet/__init__.py,sha256=CdTPPFo67goThv2unHBQc8yvXaJncIkDk6fZVh6jpEk,2327
+tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
+tksheet/column_headers.py,sha256=Ztr5QvTo3u9ANbZXheECMzRwZ9KvYnQQu-fncOJfNGg,102657
+tksheet/constants.py,sha256=aiDvUSaPtl_TSNtRRJ_p87c9iTBz9ksMd5IsSXzz4Hk,13316
+tksheet/find_window.py,sha256=TvbSqO42cw1o1AO0tQ0Q1iZogouNr4ObMo7JfkZCxgA,19877
+tksheet/formatters.py,sha256=DGcRiMsDJnySNpQcjfiX84oJ7TmOSMdU6u9injIhA4g,10095
+tksheet/functions.py,sha256=qks2dLqBE9GMAuEXaA4qiU-rrL-dzmz4-tkmkp6_ETk,53037
+tksheet/main_table.py,sha256=rm1ZeVRXTv-CwxKirFrssjIz4fvrxNH7pw0JAwUOcH4,364840
+tksheet/other_classes.py,sha256=B2SrUAviztDUOPGoWkcu-AixqAaKwItshoVZPGe1_Tc,16662
+tksheet/row_index.py,sha256=aQOQh6d4x6bGeu4Kn1KMKU5F9hwSFFinAsh5hddC3Ho,141241
+tksheet/sheet.py,sha256=6XOlCb6uhofSwylInVHk2UYufZn4sHXFsQggJ40uAaE,269689
+tksheet/sheet_options.py,sha256=ob-XYgGfBoi2TaFAvUUmlWUkw9xB-yXmJw17gu9__Lw,9948
+tksheet/sorting.py,sha256=zcZPpRtP1h_xJGtGkG3E43H7deKQFnh9cMwZ1B2-aGc,17502
+tksheet/text_editor.py,sha256=rU8Fz0-ltkM63W9io2DoZJPyzUGzCc9Z0qBtc4D1H40,7404
+tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
+tksheet/tksheet_types.py,sha256=1MjXR34EmvP1KfHlLTvKKVnf0VMz_LU_WOM2q4o5hfI,4598
+tksheet/top_left_rectangle.py,sha256=M52IrPIeMoYE3jSpooZmqw_0W5Fz_R-Yu1ZqA685EZ8,8557
+tksheet-7.4.13.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.4.13.dist-info/METADATA,sha256=ch2OK72gHX9RudQZpnF4JuYDE3KyR0OQTvl3WYtJpsw,8095
+tksheet-7.4.13.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+tksheet-7.4.13.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.4.13.dist-info/RECORD,,

tksheet-7.4.12.dist-info/RECORD

@@ -1,22 +0,0 @@
-tksheet/__init__.py,sha256=6B6RTt5-41j4-VcGxzbvcO6Ggfd56Ooy0GwxL_kfLhI,2327
-tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
-tksheet/column_headers.py,sha256=CIQwGNY0PSWb8q3Yl5lOBCGckZ83BDefFH1e4qKoLfs,102720
-tksheet/constants.py,sha256=aiDvUSaPtl_TSNtRRJ_p87c9iTBz9ksMd5IsSXzz4Hk,13316
-tksheet/find_window.py,sha256=TvbSqO42cw1o1AO0tQ0Q1iZogouNr4ObMo7JfkZCxgA,19877
-tksheet/formatters.py,sha256=DGcRiMsDJnySNpQcjfiX84oJ7TmOSMdU6u9injIhA4g,10095
-tksheet/functions.py,sha256=Ffw6yDHj83oubcp4P9VCQhTRWtGkMI2CBob4JFld91E,52567
-tksheet/main_table.py,sha256=40MAVfBxQ6FycJcuqm9ZsMOjVYKWhISjht3FFZ-UQOI,363608
-tksheet/other_classes.py,sha256=g6LYYHXO9RMy2mN_e-HmGa3Wuzhdxt5voO8-Ug19_Ag,16671
-tksheet/row_index.py,sha256=2aiADtsPskfHZeU0JK7fD4kZm-25ooSjO3mguG9vTM4,139671
-tksheet/sheet.py,sha256=ZgryLoqfkm2vtJDIVhXAvSUQ8G7TXztiID8Ftt3V2qo,269531
-tksheet/sheet_options.py,sha256=ob-XYgGfBoi2TaFAvUUmlWUkw9xB-yXmJw17gu9__Lw,9948
-tksheet/sorting.py,sha256=zcZPpRtP1h_xJGtGkG3E43H7deKQFnh9cMwZ1B2-aGc,17502
-tksheet/text_editor.py,sha256=rU8Fz0-ltkM63W9io2DoZJPyzUGzCc9Z0qBtc4D1H40,7404
-tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
-tksheet/tksheet_types.py,sha256=1MjXR34EmvP1KfHlLTvKKVnf0VMz_LU_WOM2q4o5hfI,4598
-tksheet/top_left_rectangle.py,sha256=M52IrPIeMoYE3jSpooZmqw_0W5Fz_R-Yu1ZqA685EZ8,8557
-tksheet-7.4.12.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.4.12.dist-info/METADATA,sha256=0WsLK9P5f8h788tKDhCSQjtYad1UD9mDmIOuFz7eNjE,7999
-tksheet-7.4.12.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-tksheet-7.4.12.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.4.12.dist-info/RECORD,,