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

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
@@ -492,7 +491,7 @@ class MainTable(tk.Canvas):
     def get_find_window_dimensions_coords(self, w_width: int | None) -> tuple[int, int, int, int]:
         if w_width is None:
             w_width = self.winfo_width()
-        width = min(self.get_txt_w("X" * 23), w_width - 7)
+        width = min(self.wrap_get_char_w("X") * 23, w_width - 7)
         height = self.min_row_height
         if self.find_window.window and self.find_window.window.replace_visible:
             height *= 2
@@ -707,36 +706,55 @@ class MainTable(tk.Canvas):
             return find in str(value).lower()
 
     def find_within_current_box(
-        self, current_box: SelectionBox, find: str, reverse: bool
+        self,
+        current_box: SelectionBox,
+        find: str,
+        reverse: bool,
+        stop: None | tuple[int, int] = None,
     ) -> None | tuple[int, int, int]:
-        start_r, start_c = next_cell(
+        if stop:
+            start_r, start_c = current_box.coords[0], current_box.coords[1]
+        else:
+            start_r, start_c = next_cell(
+                *current_box.coords,
+                self.selected.row,
+                self.selected.column,
+                reverse=reverse,
+            )
+        iterable = box_gen_coords(
             *current_box.coords,
-            self.selected.row,
-            self.selected.column,
+            start_r,
+            start_c,
             reverse=reverse,
+            all_rows_displayed=self.all_rows_displayed,
+            all_cols_displayed=self.all_columns_displayed,
+            displayed_rows=self.displayed_rows,
+            displayed_cols=self.displayed_columns,
+            no_wrap=True,
         )
-        return next(
-            (
-                (r, c, current_box.fill_iid)
-                for r, c in box_gen_coords(
-                    *current_box.coords,
-                    start_r,
-                    start_c,
-                    reverse=reverse,
-                    all_rows_displayed=self.all_rows_displayed,
-                    all_cols_displayed=self.all_columns_displayed,
-                    displayed_rows=self.displayed_rows,
-                    displayed_cols=self.displayed_columns,
-                    no_wrap=True,
-                )
-                if (
+        if stop:
+            for r, c in iterable:
+                if (r, c) == stop:
+                    return None
+                elif (
                     self.find_match(find, r, c)  # will not show hidden rows
                     and (self.all_rows_displayed or bisect_in(self.displayed_rows, r))
                     and (self.all_columns_displayed or bisect_in(self.displayed_columns, c))
-                )
-            ),
-            None,
-        )
+                ):
+                    return (r, c, current_box.fill_iid)
+        else:
+            return next(
+                (
+                    (r, c, current_box.fill_iid)
+                    for r, c in iterable
+                    if (
+                        self.find_match(find, r, c)  # will not show hidden rows
+                        and (self.all_rows_displayed or bisect_in(self.displayed_rows, r))
+                        and (self.all_columns_displayed or bisect_in(self.displayed_columns, c))
+                    )
+                ),
+                None,
+            )
 
     def find_within_non_current_boxes(self, current_id: int, find: str, reverse: bool) -> None | tuple[int, int, int]:
         fn = partial(
@@ -792,15 +810,20 @@ class MainTable(tk.Canvas):
         current_box = self.selection_boxes[self.selected.fill_iid]
         current_id = self.selected.fill_iid
         if is_last_cell(*current_box.coords, self.selected.row, self.selected.column, reverse=reverse):
-            if coord := self.find_within_non_current_boxes(current_id=current_id, find=find, reverse=reverse):
-                return coord
-            if coord := self.find_within_current_box(current_box=current_box, find=find, reverse=reverse):
+            if (coord := self.find_within_non_current_boxes(current_id=current_id, find=find, reverse=reverse)) or (
+                coord := self.find_within_current_box(current_box=current_box, find=find, reverse=reverse)
+            ):
                 return coord
         else:
-            if coord := self.find_within_current_box(current_box=current_box, find=find, reverse=reverse):
-                return coord
-            if coord := self.find_within_non_current_boxes(current_id=current_id, find=find, reverse=reverse):
+            if (coord := self.find_within_current_box(current_box=current_box, find=find, reverse=reverse)) or (
+                coord := self.find_within_non_current_boxes(current_id=current_id, find=find, reverse=reverse)
+            ):
                 return coord
+            elif self.selected.row != current_box.coords[0] or self.selected.column != current_box.coords[1]:
+                stop = (self.datarn(self.selected.row), self.datacn(self.selected.column))
+                coord = self.find_within_current_box(current_box=current_box, find=find, reverse=reverse, stop=stop)
+                if coord:
+                    return coord
         return None
 
     def find_all_cells(self, find: str, reverse: bool = False) -> tuple[int, int, None] | None:
@@ -1498,11 +1521,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 +1557,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 +1749,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 +1808,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 +1974,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 +1982,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 +4071,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 +4084,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:
@@ -4235,6 +4259,27 @@ class MainTable(tk.Canvas):
         self.table_txt_width, self.table_txt_height = self.get_txt_dimensions("|", self.PAR.ops.table_font)
         self.min_row_height = max(6, self.table_txt_height, self.index_txt_height) + 6
 
+        # dropdown stuff
+        mod = (self.table_txt_height - 1) if self.table_txt_height % 2 else self.table_txt_height
+        small_mod = int(mod / 5)
+        mid_y = int(self.min_row_height / 2)
+        self.dd_up_arrow = (
+            4 + 4 * small_mod,
+            mid_y + small_mod,
+            4 + 2 * small_mod,
+            mid_y - small_mod,
+            4,
+            mid_y + small_mod,
+        )
+        self.dd_down_arrow = (
+            4 + 4 * small_mod,
+            mid_y - small_mod,
+            4 + 2 * small_mod,
+            mid_y + small_mod,
+            4,
+            mid_y - small_mod,
+        )
+
     def set_index_font(self, newfont: tuple | None = None, row_heights: bool = True) -> tuple[str, int, str]:
         if newfont:
             self.check_font(newfont)
@@ -4441,7 +4486,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 +4494,7 @@ class MainTable(tk.Canvas):
                         datarn,
                     )
                 )
-            elif align.endswith("e"):
+            elif align[-1] == "e":
                 max_width += sum(
                     self._overflow(
                         self.cells_cache,
@@ -4520,14 +4565,21 @@ class MainTable(tk.Canvas):
                 else:
                     tw = min_column_width
                     h = min_rh
-                if self.get_cell_kwargs(
-                    datarn,
-                    datacn,
-                    key="dropdown",
-                ) or self.get_cell_kwargs(
-                    datarn,
-                    datacn,
-                    key="checkbox",
+                # self.get_cell_kwargs not used here to boost performance
+                if (
+                    (datarn, datacn) in self.cell_options
+                    and "dropdown" in self.cell_options[(datarn, datacn)]
+                    or datarn in self.row_options
+                    and "dropdown" in self.row_options[datarn]
+                    or datacn in self.col_options
+                    and "dropdown" in self.col_options[datacn]
+                ) or (
+                    (datarn, datacn) in self.cell_options
+                    and "checkbox" in self.cell_options[(datarn, datacn)]
+                    or datarn in self.row_options
+                    and "checkbox" in self.row_options[datarn]
+                    or datacn in self.col_options
+                    and "checkbox" in self.col_options[datacn]
                 ):
                     tw += qtxth
                 if tw > w:
@@ -4768,6 +4820,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 +4830,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 +5098,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 +5222,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 +5235,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,
@@ -5798,7 +5853,7 @@ class MainTable(tk.Canvas):
                 if (lnr := len(r)) > total_columns:
                     r = r[:total_columns]
                 elif lnr < total_columns:
-                    r += self.get_empty_row_seq(rn, end=total_columns, start=lnr)
+                    r.extend(self.gen_empty_row_seq(rn, end=total_columns, start=lnr))
 
     def equalize_data_row_lengths(
         self,
@@ -5813,9 +5868,10 @@ class MainTable(tk.Canvas):
         total_data_cols = max(total_data_cols, len(self.col_positions) - 1)
         if not isinstance(self._headers, int) and include_header and total_data_cols > len(self._headers):
             self.CH.fix_header(total_data_cols - 1)
+        empty_v = self.get_value_for_empty_cell
         for rn, r in enumerate(self.data):
             if total_data_cols > (lnr := len(r)):
-                r += self.get_empty_row_seq(rn, end=total_data_cols, start=lnr)
+                r.extend(empty_v(rn, c, r_ops=True, c_ops=True) for c in range(lnr, total_data_cols))
         return total_data_cols
 
     def get_canvas_visible_area(self) -> tuple[float, float, float, float]:
@@ -6030,7 +6086,7 @@ class MainTable(tk.Canvas):
             else:
                 self.itemconfig(iid, fill=fill, outline=outline, state="normal")
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline, tags="h")
+            iid = self.create_rectangle(coords, fill=fill, outline=outline)
         self.disp_high[iid] = True
         return True
 
@@ -6040,129 +6096,22 @@ class MainTable(tk.Canvas):
                 iid, sh = self.hidd_grid.popitem()
                 self.coords(iid, points)
                 if sh:
-                    self.itemconfig(
-                        iid,
-                        fill=self.PAR.ops.table_grid_fg,
-                        width=1,
-                        capstyle=tk.BUTT,
-                        joinstyle=tk.ROUND,
-                    )
+                    self.itemconfig(iid, fill=self.PAR.ops.table_grid_fg, width=1, capstyle="butt", joinstyle="round")
                 else:
                     self.itemconfig(
                         iid,
                         fill=self.PAR.ops.table_grid_fg,
                         width=1,
-                        capstyle=tk.BUTT,
-                        joinstyle=tk.ROUND,
+                        capstyle="butt",
+                        joinstyle="round",
                         state="normal",
                     )
             else:
                 iid = self.create_line(
-                    points,
-                    fill=self.PAR.ops.table_grid_fg,
-                    width=1,
-                    capstyle=tk.BUTT,
-                    joinstyle=tk.ROUND,
-                    tag="g",
+                    points, fill=self.PAR.ops.table_grid_fg, width=1, capstyle="butt", joinstyle="round"
                 )
             self.disp_grid[iid] = True
 
-    def redraw_dropdown(
-        self,
-        x1: int | float,
-        y1: int | float,
-        x2: int | float,
-        y2: int | float,
-        fill: str,
-        outline: str,
-        draw_outline: bool = True,
-        draw_arrow: bool = True,
-        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.table_fg)
-        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)
-            if open_:
-                # up arrow
-                points = (
-                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
-                    y1 + mid_y + small_mod,
-                    x2 - 4 - small_mod - small_mod,
-                    y1 + mid_y - small_mod,
-                    x2 - 4,
-                    y1 + mid_y + small_mod,
-                )
-            else:
-                # down arrow
-                points = (
-                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
-                    y1 + mid_y - small_mod,
-                    x2 - 4 - small_mod - small_mod,
-                    y1 + mid_y + small_mod,
-                    x2 - 4,
-                    y1 + mid_y - small_mod,
-                )
-            if self.hidd_dropdown:
-                t, sh = self.hidd_dropdown.popitem()
-                self.coords(t, points)
-                if sh:
-                    self.itemconfig(t, fill=fill)
-                else:
-                    self.itemconfig(t, fill=fill, state="normal")
-                self.lift(t)
-            else:
-                t = self.create_line(
-                    points,
-                    fill=fill,
-                    width=2,
-                    capstyle=tk.ROUND,
-                    joinstyle=tk.BEVEL,
-                )
-            self.disp_dropdown[t] = True
-
-    def redraw_checkbox(
-        self,
-        x1: int | float,
-        y1: int | float,
-        x2: int | float,
-        y2: int | float,
-        fill: str,
-        outline: str,
-        draw_check: bool = False,
-    ) -> None:
-        points = rounded_box_coords(x1, y1, x2, y2)
-        if self.hidd_checkbox:
-            t, sh = self.hidd_checkbox.popitem()
-            self.coords(t, points)
-            if sh:
-                self.itemconfig(t, fill=outline, outline=fill)
-            else:
-                self.itemconfig(t, fill=outline, outline=fill, state="normal")
-            self.lift(t)
-        else:
-            t = self.create_polygon(points, fill=outline, outline=fill, smooth=True)
-        self.disp_checkbox[t] = True
-        if draw_check:
-            x1 = x1 + 4
-            y1 = y1 + 4
-            x2 = x2 - 3
-            y2 = y2 - 3
-            points = rounded_box_coords(x1, y1, x2, y2, radius=4)
-            if self.hidd_checkbox:
-                t, sh = self.hidd_checkbox.popitem()
-                self.coords(t, points)
-                if sh:
-                    self.itemconfig(t, fill=fill, outline=outline)
-                else:
-                    self.itemconfig(t, fill=fill, outline=outline, state="normal")
-                self.lift(t)
-            else:
-                t = self.create_polygon(points, fill=fill, outline=outline, smooth=True)
-            self.disp_checkbox[t] = True
-
     def _auto_resize_columns(self, can_width: float, col_pos_exists: bool) -> bool:
         if self.PAR.ops.auto_resize_columns and self.allow_auto_resize_columns and col_pos_exists:
             max_w = can_width - self.PAR.ops.empty_horizontal
@@ -6283,35 +6232,380 @@ 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:
-        self.txt_measure_canvas.itemconfig(
-            self.txt_measure_canvas_text,
-            text=_test_str + c,
-            font=self.table_font,
-        )
-        b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         if c in self.char_widths[self.table_font]:
             return self.char_widths[self.table_font][c]
         else:
+            self.txt_measure_canvas.itemconfig(
+                self.txt_measure_canvas_text,
+                text=_test_str + c,
+                font=self.table_font,
+            )
+            b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
             wd = b[2] - b[0] - self.table_test_str_w
             self.char_widths[self.table_font][c] = wd
             return wd
 
+    def redraw_grid_and_text(
+        self,
+        last_row_line_pos: float,
+        last_col_line_pos: float,
+        scrollpos_top: int,
+        scrollpos_bot: int,
+        scrollpos_left: int,
+        scrollpos_right: int,
+        x_stop: int | float,
+        y_stop: int | float,
+        col_pos_exists: bool,
+        row_pos_exists: bool,
+        can_width: int,
+        can_height: int,
+        grid_start_row: int,
+        grid_end_row: int,
+        grid_start_col: int,
+        grid_end_col: int,
+        text_start_row: int,
+        text_end_row: int,
+        text_start_col: int,
+        text_end_col: int,
+    ) -> None:
+        # reset canvas item storage
+        self.hidd_text.update(self.disp_text)
+        self.disp_text = {}
+        self.hidd_high.update(self.disp_high)
+        self.disp_high = {}
+        self.hidd_grid.update(self.disp_grid)
+        self.disp_grid = {}
+        self.hidd_dropdown.update(self.disp_dropdown)
+        self.disp_dropdown = {}
+        self.hidd_checkbox.update(self.disp_checkbox)
+        self.disp_checkbox = {}
+        points = []
+        # manage horizontal grid lines
+        if self.PAR.ops.show_horizontal_grid and row_pos_exists:
+            if self.PAR.ops.horizontal_grid_to_end_of_window:
+                x_grid_stop = scrollpos_right + can_width
+            else:
+                x_grid_stop = x_stop + 1 if last_col_line_pos > scrollpos_right else x_stop - 1
+            points.extend(
+                get_horizontal_gridline_points(
+                    left=scrollpos_left,
+                    stop=x_grid_stop,
+                    positions=self.row_positions,
+                    start=grid_start_row,
+                    end=grid_end_row,
+                )
+            )
+        # manage vertical grid lines
+        if self.PAR.ops.show_vertical_grid and col_pos_exists:
+            if self.PAR.ops.vertical_grid_to_end_of_window:
+                y_grid_stop = scrollpos_bot + can_height
+            else:
+                y_grid_stop = y_stop + 1 if last_row_line_pos > scrollpos_bot else y_stop - 1
+            if self.PAR.ops.show_horizontal_grid:
+                points.extend([scrollpos_left - 2, grid_end_row, grid_start_col - 2, scrollpos_top - 2])
+            points.extend(
+                get_vertical_gridline_points(
+                    top=scrollpos_top,
+                    stop=y_grid_stop,
+                    positions=self.col_positions,
+                    start=grid_start_col,
+                    end=grid_end_col,
+                )
+            )
+        if points:
+            self.redraw_gridline(points)
+
+        font = self.PAR.ops.table_font
+        dd_coords = self.dropdown.get_coords()
+        selections = self.get_redraw_selections(text_start_row, grid_end_row, text_start_col, grid_end_col)
+        sel_cells_bg = color_tup(self.PAR.ops.table_selected_cells_bg)
+        sel_cols_bg = color_tup(self.PAR.ops.table_selected_columns_bg)
+        sel_rows_bg = color_tup(self.PAR.ops.table_selected_rows_bg)
+        current_loc = (self.selected.row, self.selected.column) if self.selected else ()
+        if self.PAR.ops.alternate_color:
+            alternate_color = Highlight(
+                bg=self.PAR.ops.alternate_color,
+                fg=None,
+                end=False,
+            )
+            if self.selected and box_is_single_cell(*self.selected.box) and self.PAR.ops.show_selected_cells_border:
+                dont_blend = current_loc
+            else:
+                dont_blend = ()
+        else:
+            alternate_color = None
+            dont_blend = ()
+        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),
+            )
+        allow_overflow = self.PAR.ops.allow_cell_overflow
+        wrap = self.PAR.ops.table_wrap
+        cells = self._redraw_precache_cells(
+            text_start_row=text_start_row,
+            text_end_row=text_end_row,
+            text_start_col=text_start_col,
+            text_end_col=text_end_col,
+        )
+
+        # This is a little messy but
+        # we try to avoid any function use to maximise performance
+
+        for r in range(text_start_row, text_end_row):
+            rtopgridln = self.row_positions[r]
+            rbotgridln = self.row_positions[r + 1]
+            datarn = cells["datarn"][r]
+
+            for c in range(text_start_col, text_end_col):
+                cleftgridln = self.col_positions[c]
+                crightgridln = self.col_positions[c + 1]
+                datacn = cells["datacn"][c]
+                disp_loc = (r, c)
+                loc = (datarn, datacn)
+
+                fill, dd_drawn = self.redraw_highlight_get_text_fg(
+                    r=r,
+                    c=c,
+                    fc=cleftgridln,
+                    fr=rtopgridln,
+                    sc=crightgridln,
+                    sr=rbotgridln,
+                    sel_cells_bg=override[0] if override and disp_loc == current_loc else sel_cells_bg,
+                    sel_cols_bg=override[1] if override and disp_loc == current_loc else sel_cols_bg,
+                    sel_rows_bg=override[2] if override and disp_loc == current_loc else sel_rows_bg,
+                    selections=selections,
+                    datarn=datarn,
+                    datacn=datacn,
+                    can_width=can_width,
+                    dont_blend=disp_loc == dont_blend,
+                    alternate_color=alternate_color,
+                    has_dd=loc in cells["dropdown"],
+                )
+                if loc in self.cell_options and "align" in self.cell_options[(datarn, datacn)]:
+                    align = self.cell_options[(datarn, datacn)]["align"]
+                elif datarn in self.row_options and "align" in self.row_options[datarn]:
+                    align = self.row_options[datarn]["align"]
+                elif datacn in self.col_options and "align" in self.col_options[datacn]:
+                    align = self.col_options[datacn]["align"]
+                else:
+                    align = self.align
+
+                kws = cells["dropdown"][loc] if loc in cells["dropdown"] else None
+                if kws:
+                    max_width = crightgridln - cleftgridln - self.table_txt_height - 5
+                    if align[-1] == "w":
+                        draw_x = cleftgridln + 2
+                    elif align[-1] == "e":
+                        draw_x = crightgridln - 5 - self.table_txt_height
+                    elif align[-1] == "n":
+                        draw_x = cleftgridln + (crightgridln - cleftgridln - self.table_txt_height) / 2
+
+                    # redraw dropdown
+
+                    x1 = cleftgridln
+                    y1 = rtopgridln
+                    x2 = crightgridln
+                    y2 = self.row_positions[r + 1]
+                    if not dd_drawn and self.PAR.ops.show_dropdown_borders:
+                        self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg)
+                    if max_width >= 5:
+                        if dd_coords == disp_loc:
+                            # up arrow
+                            points = (
+                                x2 - self.dd_up_arrow[0],
+                                y1 + self.dd_up_arrow[1],
+                                x2 - self.dd_up_arrow[2],
+                                y1 + self.dd_up_arrow[3],
+                                x2 - self.dd_up_arrow[4],
+                                y1 + self.dd_up_arrow[5],
+                            )
+                        else:
+                            # down arrow
+                            points = (
+                                x2 - self.dd_down_arrow[0],
+                                y1 + self.dd_down_arrow[1],
+                                x2 - self.dd_down_arrow[2],
+                                y1 + self.dd_down_arrow[3],
+                                x2 - self.dd_down_arrow[4],
+                                y1 + self.dd_down_arrow[5],
+                            )
+                        _fill = fill if kws["state"] != "disabled" else self.PAR.ops.table_grid_fg
+                        if self.hidd_dropdown:
+                            cid, sh = self.hidd_dropdown.popitem()
+                            self.coords(cid, points)
+                            if sh:
+                                self.itemconfig(cid, fill=_fill)
+                            else:
+                                self.itemconfig(cid, fill=_fill, state="normal")
+                        else:
+                            cid = self.create_line(
+                                points, fill=_fill, width=2, capstyle="round", joinstyle="bevel", tag="lift"
+                            )
+                        self.disp_dropdown[cid] = True
+
+                elif loc in cells["checkbox"]:
+                    kws = cells["checkbox"][loc]
+
+                    if align[-1] == "w":
+                        draw_x = cleftgridln + 2
+                    elif align[-1] == "e":
+                        draw_x = crightgridln - 2
+                    elif align[-1] == "n":
+                        draw_x = cleftgridln + (crightgridln - cleftgridln) / 2
+
+                    max_width = crightgridln - cleftgridln - 2
+
+                    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
+
+                        # redraw checkbox
+
+                        x1 = cleftgridln + 2
+                        y1 = rtopgridln + 2
+                        x2 = cleftgridln + self.table_txt_height + 3
+                        y2 = rtopgridln + self.table_txt_height + 3
+                        points = rounded_box_coords(x1, y1, x2, y2)
+                        _fill = fill if kws["state"] == "normal" else self.PAR.ops.table_grid_fg
+                        if self.hidd_checkbox:
+                            cid, sh = self.hidd_checkbox.popitem()
+                            self.coords(cid, points)
+                            if sh:
+                                self.itemconfig(cid, fill="", outline=_fill)
+                            else:
+                                self.itemconfig(cid, fill="", outline=_fill, state="normal")
+                        else:
+                            cid = self.create_polygon(points, fill="", outline=_fill, smooth=True, tag="lift")
+                        self.disp_checkbox[cid] = True
+                        if draw_check:
+                            points = rounded_box_coords(x1 + 4, y1 + 4, x2 - 3, y2 - 3, radius=4)
+                            if self.hidd_checkbox:
+                                cid, sh = self.hidd_checkbox.popitem()
+                                self.coords(cid, points)
+                                if sh:
+                                    self.itemconfig(cid, fill=_fill, outline="")
+                                else:
+                                    self.itemconfig(cid, fill=_fill, outline="", state="normal")
+                            else:
+                                cid = self.create_polygon(points, fill=_fill, outline="", smooth=True, tag="lift")
+                            self.disp_checkbox[cid] = True
+
+                else:
+                    max_width = crightgridln - cleftgridln - 2
+                    if align[-1] == "w":
+                        draw_x = cleftgridln + 2
+                    elif align[-1] == "e":
+                        draw_x = crightgridln - 2
+                    elif align[-1] == "n":
+                        draw_x = cleftgridln + (crightgridln - cleftgridln) / 2
+
+                # redraw text
+
+                text = cells[loc]
+                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[-1] == "w":
+                        max_width += sum(self._overflow(cells, range(c + 1, text_end_col), datarn))
+                    elif align[-1] == "e":
+                        max_width += sum(self._overflow(cells, reversed(range(text_start_col, c)), datarn))
+                if max_width <= 1:
+                    continue
+                start_line = max(0, int((scrollpos_top - rtopgridln) / self.table_txt_height))
+                draw_y = rtopgridln + 3 + (start_line * self.table_txt_height)
+                gen_lines = wrap_text(
+                    text=text,
+                    max_width=max_width,
+                    max_lines=int((rbotgridln - rtopgridln - 2) / self.table_txt_height),
+                    char_width_fn=self.wrap_get_char_w,
+                    widths=self.char_widths[font],
+                    wrap=wrap,
+                    start_line=start_line,
+                )
+                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)
+                        if showing:
+                            self.itemconfig(iid, text="\n".join(gen_lines), fill=fill, font=font, anchor=align)
+                        else:
+                            self.itemconfig(
+                                iid, text="\n".join(gen_lines), fill=fill, font=font, anchor=align, state="normal"
+                            )
+                    else:
+                        iid = self.create_text(
+                            draw_x, draw_y, text="\n".join(gen_lines), fill=fill, font=font, anchor=align, tag="lift"
+                        )
+                    self.disp_text[iid] = True
+
+                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=t, fill=fill, font=font, anchor=align)
+                            else:
+                                self.itemconfig(iid, text=t, fill=fill, font=font, anchor=align, state="normal")
+                        else:
+                            iid = self.create_text(
+                                draw_x, draw_y, text=t, fill=fill, font=font, anchor=align, tag="lift"
+                            )
+                        self.disp_text[iid] = True
+                        draw_y += self.table_txt_height
+        for dct in (
+            self.hidd_text,
+            self.hidd_high,
+            self.hidd_grid,
+            self.hidd_dropdown,
+            self.hidd_checkbox,
+        ):
+            for iid, showing in dct.items():
+                if showing:
+                    self.itemconfig(iid, state="hidden")
+                    dct[iid] = False
+        if self.PAR.ops.show_selected_cells_border:
+            for _, box in self.selection_boxes.items():
+                if box.bd_iid:
+                    self.tag_raise(box.bd_iid)
+            if self.selected:
+                self.tag_raise(self.selected.iid)
+        self.lift("lift")
+
     def main_table_redraw_grid_and_text(
         self,
         redraw_header: bool = False,
@@ -6352,7 +6646,6 @@ class MainTable(tk.Canvas):
                 or setting_views
             ):
                 return False
-
         scrollpos_top = self.canvasy(0)
         scrollpos_bot = self.canvasy(can_height)
         scrollpos_left = self.canvasx(0)
@@ -6365,7 +6658,7 @@ class MainTable(tk.Canvas):
         text_end_row = grid_end_row - 1 if grid_end_row == len(self.row_positions) else grid_end_row
         text_start_col = grid_start_col - 1 if grid_start_col else grid_start_col
         text_end_col = grid_end_col - 1 if grid_end_col == len(self.col_positions) else grid_end_col
-        # manage find window
+
         if self.find_window.open:
             self.reposition_find_window()
         # check if auto resizing row index
@@ -6377,302 +6670,8 @@ class MainTable(tk.Canvas):
             )
         if resized_cols or resized_rows or changed_w:
             self.recreate_all_selection_boxes()
-            if changed_w:
-                for widget in (self, self.RI, self.CH, self.TL):
-                    widget.update_idletasks()
-        # important vars
         x_stop = min(last_col_line_pos, scrollpos_right)
         y_stop = min(last_row_line_pos, scrollpos_bot)
-        # redraw table
-        if redraw_table:
-            # reset canvas item storage
-            self.hidd_text.update(self.disp_text)
-            self.disp_text = {}
-            self.hidd_high.update(self.disp_high)
-            self.disp_high = {}
-            self.hidd_grid.update(self.disp_grid)
-            self.disp_grid = {}
-            self.hidd_dropdown.update(self.disp_dropdown)
-            self.disp_dropdown = {}
-            self.hidd_checkbox.update(self.disp_checkbox)
-            self.disp_checkbox = {}
-            points = []
-            # manage horizontal grid lines
-            if self.PAR.ops.show_horizontal_grid and row_pos_exists:
-                if self.PAR.ops.horizontal_grid_to_end_of_window:
-                    x_grid_stop = scrollpos_right + can_width
-                else:
-                    x_grid_stop = x_stop + 1 if last_col_line_pos > scrollpos_right else x_stop - 1
-                points.extend(
-                    get_horizontal_gridline_points(
-                        left=scrollpos_left,
-                        stop=x_grid_stop,
-                        positions=self.row_positions,
-                        start=grid_start_row,
-                        end=grid_end_row,
-                    )
-                )
-            # manage vertical grid lines
-            if self.PAR.ops.show_vertical_grid and col_pos_exists:
-                if self.PAR.ops.vertical_grid_to_end_of_window:
-                    y_grid_stop = scrollpos_bot + can_height
-                else:
-                    y_grid_stop = y_stop + 1 if last_row_line_pos > scrollpos_bot else y_stop - 1
-                if self.PAR.ops.show_horizontal_grid:
-                    points.extend([scrollpos_left - 2, grid_end_row, grid_start_col - 2, scrollpos_top - 2])
-                points.extend(
-                    get_vertical_gridline_points(
-                        top=scrollpos_top,
-                        stop=y_grid_stop,
-                        positions=self.col_positions,
-                        start=grid_start_col,
-                        end=grid_end_col,
-                    )
-                )
-            if points:
-                self.redraw_gridline(points)
-
-            font = self.PAR.ops.table_font
-            dd_coords = self.dropdown.get_coords()
-            selections = self.get_redraw_selections(text_start_row, grid_end_row, text_start_col, grid_end_col)
-            sel_cells_bg = color_tup(self.PAR.ops.table_selected_cells_bg)
-            sel_cols_bg = color_tup(self.PAR.ops.table_selected_columns_bg)
-            sel_rows_bg = color_tup(self.PAR.ops.table_selected_rows_bg)
-            current_loc = (self.selected.row, self.selected.column) if self.selected else ()
-            if self.PAR.ops.alternate_color:
-                alternate_color = Highlight(
-                    bg=self.PAR.ops.alternate_color,
-                    fg=None,
-                    end=False,
-                )
-                if self.selected and box_is_single_cell(*self.selected.box) and self.PAR.ops.show_selected_cells_border:
-                    dont_blend = current_loc
-                else:
-                    dont_blend = ()
-            else:
-                alternate_color = None
-                dont_blend = ()
-            if not self.PAR.ops.show_selected_cells_border:
-                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(
-                text_start_row=text_start_row,
-                text_end_row=text_end_row,
-                text_start_col=text_start_col,
-                text_end_col=text_end_col,
-            )
-            for r in range(text_start_row, text_end_row):
-                rtopgridln = self.row_positions[r]
-                rbotgridln = self.row_positions[r + 1]
-                datarn = cells["datarn"][r]
-
-                for c in range(text_start_col, text_end_col):
-                    cleftgridln = self.col_positions[c]
-                    crightgridln = self.col_positions[c + 1]
-                    datacn = cells["datacn"][c]
-                    t = (datarn, datacn)
-
-                    fill, dd_drawn = self.redraw_highlight_get_text_fg(
-                        r=r,
-                        c=c,
-                        fc=cleftgridln,
-                        fr=rtopgridln,
-                        sc=crightgridln,
-                        sr=rbotgridln,
-                        sel_cells_bg=override[0] if override and (r, c) == current_loc else sel_cells_bg,
-                        sel_cols_bg=override[1] if override and (r, c) == current_loc else sel_cols_bg,
-                        sel_rows_bg=override[2] if override and (r, c) == current_loc else sel_rows_bg,
-                        selections=selections,
-                        datarn=datarn,
-                        datacn=datacn,
-                        can_width=can_width,
-                        dont_blend=(r, c) == dont_blend,
-                        alternate_color=alternate_color,
-                        has_dd=t in cells["dropdown"],
-                    )
-                    if t in self.cell_options and "align" in self.cell_options[(datarn, datacn)]:
-                        align = self.cell_options[(datarn, datacn)]["align"]
-                    elif datarn in self.row_options and "align" in self.row_options[datarn]:
-                        align = self.row_options[datarn]["align"]
-                    elif datacn in self.col_options and "align" in self.col_options[datacn]:
-                        align = self.col_options[datacn]["align"]
-                    else:
-                        align = self.align
-
-                    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"):
-                            draw_x = cleftgridln + 2
-                        elif align.endswith("e"):
-                            draw_x = crightgridln - 5 - self.table_txt_height
-                        elif align.endswith("n"):
-                            draw_x = cleftgridln + ceil((crightgridln - cleftgridln - self.table_txt_height) / 2)
-                        self.redraw_dropdown(
-                            cleftgridln,
-                            rtopgridln,
-                            crightgridln,
-                            self.row_positions[r + 1],
-                            fill=fill if kws["state"] != "disabled" else self.PAR.ops.table_grid_fg,
-                            outline=fill,
-                            draw_outline=not dd_drawn,
-                            draw_arrow=max_width >= 5,
-                            open_=dd_coords == (r, c),
-                        )
-                    else:
-                        max_width = crightgridln - cleftgridln - 2
-                        if align.endswith("w"):
-                            draw_x = cleftgridln + 2
-                        elif align.endswith("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,
-                            )
-                    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)
-                    ):
-                        continue
-                    if allow_overflow and not kws:
-                        if align.endswith("w"):
-                            max_width += sum(self._overflow(cells, range(c + 1, text_end_col), datarn))
-                        elif align.endswith("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))
-                    draw_y = rtopgridln + 3 + (start_line * self.table_txt_height)
-                    gen_lines = wrap_text(
-                        text=text,
-                        max_width=max_width,
-                        max_lines=int((rbotgridln - rtopgridln - 2) / self.table_txt_height),
-                        char_width_fn=self.wrap_get_char_w,
-                        widths=self.char_widths[font],
-                        wrap=wrap,
-                        start_line=start_line,
-                    )
-                    if align.endswith(("w", "e")):
-                        if self.hidd_text:
-                            iid, showing = self.hidd_text.popitem()
-                            self.coords(iid, draw_x, draw_y)
-                            if showing:
-                                self.itemconfig(
-                                    iid,
-                                    text="\n".join(gen_lines),
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                )
-                            else:
-                                self.itemconfig(
-                                    iid,
-                                    text="\n".join(gen_lines),
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                    state="normal",
-                                )
-                        else:
-                            iid = self.create_text(
-                                draw_x,
-                                draw_y,
-                                text="\n".join(gen_lines),
-                                fill=fill,
-                                font=font,
-                                anchor=align,
-                                tags="t",
-                            )
-                        self.disp_text[iid] = True
-
-                    elif align.endswith("n"):
-                        for text 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,
-                                        fill=fill,
-                                        font=font,
-                                        anchor=align,
-                                    )
-                                else:
-                                    self.itemconfig(
-                                        iid,
-                                        text=text,
-                                        fill=fill,
-                                        font=font,
-                                        anchor=align,
-                                        state="normal",
-                                    )
-                            else:
-                                iid = self.create_text(
-                                    draw_x,
-                                    draw_y,
-                                    text=text,
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                    tags="t",
-                                )
-                            self.disp_text[iid] = True
-                            draw_y += self.table_txt_height
-            for dct in (
-                self.hidd_text,
-                self.hidd_high,
-                self.hidd_grid,
-                self.hidd_dropdown,
-                self.hidd_checkbox,
-            ):
-                for iid, showing in dct.items():
-                    if showing:
-                        self.itemconfig(iid, state="hidden")
-                        dct[iid] = False
-            if self.PAR.ops.show_selected_cells_border:
-                for _, box in self.selection_boxes.items():
-                    if box.bd_iid:
-                        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")
         if redraw_header and self.show_header:
             self.CH.redraw_grid_and_text(
                 last_col_line_pos=last_col_line_pos,
@@ -6699,6 +6698,29 @@ class MainTable(tk.Canvas):
                 row_pos_exists=row_pos_exists,
                 set_scrollregion=set_scrollregion,
             )
+        if redraw_table:
+            self.redraw_grid_and_text(
+                last_row_line_pos=last_row_line_pos,
+                last_col_line_pos=last_col_line_pos,
+                scrollpos_top=scrollpos_top,
+                scrollpos_bot=scrollpos_bot,
+                scrollpos_left=scrollpos_left,
+                scrollpos_right=scrollpos_right,
+                x_stop=x_stop,
+                y_stop=y_stop,
+                col_pos_exists=col_pos_exists,
+                row_pos_exists=row_pos_exists,
+                can_width=can_width,
+                can_height=can_height,
+                grid_start_row=grid_start_row,
+                grid_end_row=grid_end_row,
+                grid_start_col=grid_start_col,
+                grid_end_col=grid_end_col,
+                text_start_row=text_start_row,
+                text_end_row=text_end_row,
+                text_start_col=text_start_col,
+                text_end_col=text_end_col,
+            )
         event_data = {"sheetname": "", "header": redraw_header, "row_index": redraw_row_index, "table": redraw_table}
         self.PAR.emit_event("<<SheetRedrawn>>", data=event_data)
         return True
@@ -6781,7 +6803,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 +7139,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):
@@ -7985,15 +8008,15 @@ class MainTable(tk.Canvas):
             return ""
 
     def get_empty_row_seq(
-        self,
-        datarn: int,
-        end: int,
-        start: int = 0,
-        r_ops: bool = True,
-        c_ops: bool = True,
+        self, datarn: int, end: int, start: int = 0, r_ops: bool = True, c_ops: bool = True
     ) -> list[Any]:
         return [self.get_value_for_empty_cell(datarn, datacn, r_ops=r_ops, c_ops=c_ops) for datacn in range(start, end)]
 
+    def gen_empty_row_seq(
+        self, datarn: int, end: int, start: int = 0, r_ops: bool = True, c_ops: bool = True
+    ) -> Generator[Any]:
+        yield from (self.get_value_for_empty_cell(datarn, c, r_ops=r_ops, c_ops=c_ops) for c in range(start, end))
+
     def fix_row_len(self, datarn: int, datacn: int) -> None:
         self.data[datarn].extend(self.get_empty_row_seq(datarn, end=datacn + 1, start=len(self.data[datarn])))
 
@@ -8081,23 +8104,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 +8155,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,