tksheet 7.4.11__py3-none-any.whl → 7.4.13__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
@@ -60,9 +59,11 @@ from .functions import (
     gen_formatted,
     get_bg_fg,
     get_data_from_clipboard,
+    get_horizontal_gridline_points,
     get_menu_kwargs,
     get_new_indexes,
     get_seq_without_gaps_at_index,
+    get_vertical_gridline_points,
     index_exists,
     insert_items,
     int_x_iter,
@@ -73,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,
@@ -149,6 +150,9 @@ class MainTable(tk.Canvas):
             "<<SelectAll>>": self.select_all,
         }
         self.enabled_bindings = set()
+        self.selection_box_ctr = 0
+        self.disp_selection_fills = set()
+        self.hidd_selection_fills = set()
 
         self.disp_ctrl_outline = {}
         self.disp_text = {}
@@ -318,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
@@ -1493,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"]:
@@ -1534,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()
             }
@@ -1726,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,
@@ -1785,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()
             }
@@ -1951,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
@@ -1958,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:
@@ -2662,58 +2667,37 @@ class MainTable(tk.Canvas):
             self.refresh()
 
     def page_UP(self, event: Any = None) -> None:
-        height = self.winfo_height()
-        top = self.canvasy(0)
-        scrollto_y = max(0, top - height)
+        r, end = self.visible_text_rows
+        if r == end - 1:
+            r = max(0, r - 1)
         if self.PAR.ops.page_up_down_select_row:
-            r = bisect_left(self.row_positions, scrollto_y)
-            if self.selected and self.selected.row == r:
-                r = max(0, r - 1)
             if self.RI.row_selection_enabled and (
-                self.anything_selected(exclude_columns=True, exclude_cells=True) or not self.anything_selected()
+                self.selected and self.selected.type_ == "rows" or not self.anything_selected()
             ):
-                self.RI.select_row(r)
-                self.see(r, 0, keep_xscroll=True, check_cell_visibility=False)
+                self.RI.select_row(r, redraw=False)
             elif (self.single_selection_enabled or self.toggle_selection_enabled) and self.anything_selected(
                 exclude_columns=True, exclude_rows=True
             ):
-                c = next(reversed(self.selection_boxes.values())).coords.from_c
-                self.see(r, c, keep_xscroll=True, check_cell_visibility=False)
-                self.select_cell(r, c)
-        else:
-            args = ("moveto", scrollto_y / (self.row_positions[-1] + 100))
-            self.yview(*args)
-            self.RI.yview(*args)
+                self.select_cell(r, self.selected.column, redraw=False)
+        if not self.see(r, keep_xscroll=True, bottom_right_corner=True):
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
     def page_DOWN(self, event: Any = None) -> None:
-        height = self.winfo_height()
-        top = self.canvasy(0)
-        scrollto = top + height
-        if self.PAR.ops.page_up_down_select_row and self.RI.row_selection_enabled:
-            r = bisect_left(self.row_positions, scrollto) - 1
-            if self.selected and self.selected.row == r:
-                r += 1
-            if r > len(self.row_positions) - 2:
-                r = len(self.row_positions) - 2
+        st, r = self.visible_text_rows
+        r -= 1
+        if st == r:
+            r = min(len(self.row_positions) - 2, r + 1)
+        if self.PAR.ops.page_up_down_select_row:
             if self.RI.row_selection_enabled and (
-                self.anything_selected(exclude_columns=True, exclude_cells=True) or not self.anything_selected()
+                self.selected and self.selected.type_ == "rows" or not self.anything_selected()
             ):
-                self.RI.select_row(r)
-                self.see(r, 0, keep_xscroll=True, check_cell_visibility=False)
+                self.RI.select_row(r, redraw=False)
+
             elif (self.single_selection_enabled or self.toggle_selection_enabled) and self.anything_selected(
                 exclude_columns=True, exclude_rows=True
             ):
-                c = next(reversed(self.selection_boxes.values())).coords.from_c
-                self.see(r, c, keep_xscroll=True, check_cell_visibility=False)
-                self.select_cell(r, c)
-        else:
-            end = self.row_positions[-1]
-            if scrollto > end + 100:
-                scrollto = end
-            args = ("moveto", scrollto / (end + 100))
-            self.yview(*args)
-            self.RI.yview(*args)
+                self.select_cell(r, self.selected.column, redraw=False)
+        if not self.see(r, keep_xscroll=True, bottom_right_corner=False):
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
     def arrowkey_UP(self, event: Any = None) -> None:
@@ -4063,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:
@@ -4076,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:
@@ -4457,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,
@@ -4465,7 +4449,7 @@ class MainTable(tk.Canvas):
                         datarn,
                     )
                 )
-            elif align.endswith("e"):
+            elif align[-1] == "e":
                 max_width += sum(
                     self._overflow(
                         self.cells_cache,
@@ -4784,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()
@@ -4793,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
@@ -5060,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(
@@ -5184,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(
@@ -5197,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,
@@ -5875,12 +5862,20 @@ class MainTable(tk.Canvas):
         can_width: int | None,
         dont_blend: bool,
         alternate_color: Highlight | None,
+        has_dd: bool = False,
     ) -> tuple[str, bool]:
         redrawn = False
         if (datarn, datacn) in self.progress_bars:
             kwargs = self.progress_bars[(datarn, datacn)]
         else:
-            kwargs = self.get_cell_kwargs(datarn, datacn, key="highlight")
+            if (datarn, datacn) in self.cell_options and "highlight" in self.cell_options[(datarn, datacn)]:
+                kwargs = self.cell_options[(datarn, datacn)]["highlight"]
+            elif datarn in self.row_options and "highlight" in self.row_options[datarn]:
+                kwargs = self.row_options[datarn]["highlight"]
+            elif datacn in self.col_options and "highlight" in self.col_options[datacn]:
+                kwargs = self.col_options[datacn]["highlight"]
+            else:
+                kwargs = {}
         if alt := bool(not kwargs and alternate_color and r % 2):
             kwargs = alternate_color
 
@@ -5942,39 +5937,68 @@ class MainTable(tk.Canvas):
                 txtfg = self.PAR.ops.table_fg if kwargs[1] is None else kwargs[1]
 
             if fill:
-                highlight_fn = partial(
-                    self.redraw_highlight,
-                    x1=fc + 1,
-                    y1=fr + 1,
-                    x2=sc,
-                    y2=sr,
-                    fill=fill,
-                    outline=(
-                        self.PAR.ops.table_fg
-                        if self.get_cell_kwargs(datarn, datacn, key="dropdown") and self.PAR.ops.show_dropdown_borders
-                        else ""
-                    ),
-                )
-                if isinstance(kwargs, ProgressBar):
+                if not isinstance(kwargs, ProgressBar):
+                    redrawn = self.redraw_highlight(
+                        x1=fc + 1,
+                        y1=fr + 1,
+                        x2=sc,
+                        y2=sr,
+                        fill=fill,
+                        outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                        can_width=can_width if (len(kwargs) > 2 and kwargs[2]) else None,
+                        pc=None,
+                    )
+                else:
                     if kwargs.del_when_done and kwargs.percent >= 100:
                         del self.progress_bars[(datarn, datacn)]
                     else:
-                        redrawn = highlight_fn(
+                        redrawn = self.redraw_highlight(
+                            x1=fc + 1,
+                            y1=fr + 1,
+                            x2=sc,
+                            y2=sr,
+                            fill=fill,
+                            outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
                             can_width=None,
                             pc=kwargs.percent,
                         )
-                else:
-                    redrawn = highlight_fn(
-                        can_width=can_width if (len(kwargs) > 2 and kwargs[2]) else None,
-                        pc=None,
-                    )
         elif not kwargs:
             if "cells" in selections and (r, c) in selections["cells"]:
                 txtfg = self.PAR.ops.table_selected_cells_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill=self.PAR.ops.table_selected_cells_bg,
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    can_width=None,
+                    pc=None,
+                )
             elif "rows" in selections and r in selections["rows"]:
                 txtfg = self.PAR.ops.table_selected_rows_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill=self.PAR.ops.table_selected_rows_bg,
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    can_width=None,
+                    pc=None,
+                )
             elif "columns" in selections and c in selections["columns"]:
                 txtfg = self.PAR.ops.table_selected_columns_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill=self.PAR.ops.table_selected_columns_bg,
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    can_width=None,
+                    pc=None,
+                )
             else:
                 txtfg = self.PAR.ops.table_fg
         return txtfg, redrawn
@@ -6063,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 = (
@@ -6257,11 +6281,30 @@ class MainTable(tk.Canvas):
                 else:
                     datacn = c if self.all_columns_displayed else self.displayed_columns[c]
                     cells["datacn"][c] = datacn
-                if kwargs := self.get_cell_kwargs(datarn, datacn, key="dropdown"):
-                    cells["dropdown"][(datarn, datacn)] = kwargs
-                elif kwargs := self.get_cell_kwargs(datarn, datacn, key="checkbox"):
-                    cells["checkbox"][(datarn, datacn)] = kwargs
-                cells[(datarn, datacn)] = self.cell_str(datarn, datacn, get_displayed=True)
+                t = (datarn, datacn)
+
+                # 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:
@@ -6346,7 +6389,7 @@ class MainTable(tk.Canvas):
             if changed_w:
                 for widget in (self, self.RI, self.CH, self.TL):
                     widget.update_idletasks()
-                return False
+                return
         # important vars
         x_stop = min(last_col_line_pos, scrollpos_right)
         y_stop = min(last_row_line_pos, scrollpos_bot)
@@ -6363,27 +6406,20 @@ class MainTable(tk.Canvas):
             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
-                self.redraw_gridline(
-                    points=tuple(
-                        chain.from_iterable(
-                            (
-                                scrollpos_left - 1,
-                                self.row_positions[r],
-                                x_grid_stop,
-                                self.row_positions[r],
-                                scrollpos_left - 1,
-                                self.row_positions[r],
-                                scrollpos_left - 1,
-                                self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
-                            )
-                            for r in range(grid_start_row, grid_end_row)
-                        )
+                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
@@ -6392,23 +6428,20 @@ class MainTable(tk.Canvas):
                     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
-                self.redraw_gridline(
-                    points=tuple(
-                        chain.from_iterable(
-                            (
-                                self.col_positions[c],
-                                scrollpos_top - 1,
-                                self.col_positions[c],
-                                y_grid_stop,
-                                self.col_positions[c],
-                                scrollpos_top - 1,
-                                self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
-                                scrollpos_top - 1,
-                            )
-                            for c in range(grid_start_col, grid_end_col)
-                        )
-                    ),
+                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)
@@ -6429,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(
@@ -6454,6 +6487,8 @@ class MainTable(tk.Canvas):
                     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,
@@ -6470,24 +6505,32 @@ class MainTable(tk.Canvas):
                         can_width=can_width,
                         dont_blend=(r, c) == dont_blend,
                         alternate_color=alternate_color,
+                        has_dd=t in cells["dropdown"],
                     )
-                    if not (align := self.get_cell_kwargs(datarn, datacn, key="align")):
+                    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
 
-                    if kwargs := cells["dropdown"].get((datarn, datacn), None):
+                    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,
                             crightgridln,
                             self.row_positions[r + 1],
-                            fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
+                            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,
@@ -6495,50 +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)
-
-                        if (
-                            kwargs := cells["checkbox"].get((datarn, datacn), None)
-                        ) 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 kwargs["state"] == "normal" else self.PAR.ops.table_grid_fg,
-                                outline="",
-                                draw_check=draw_check,
-                            )
-                    text = cells[(datarn, datacn)]
-                    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)
-                    ):
+                        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[-1] == "w" and draw_x > scrollpos_right) or cleftgridln + 5 > scrollpos_right:
                         continue
-                    if allow_overflow and not kwargs:
-                        if align.endswith("w"):
+                    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.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))
@@ -6552,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)
@@ -6573,7 +6609,6 @@ class MainTable(tk.Canvas):
                                     anchor=align,
                                     state="normal",
                                 )
-                            self.tag_raise(iid)
                         else:
                             iid = self.create_text(
                                 draw_x,
@@ -6586,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,
@@ -6602,18 +6637,17 @@ class MainTable(tk.Canvas):
                                 else:
                                     self.itemconfig(
                                         iid,
-                                        text=text,
+                                        text=t,
                                         fill=fill,
                                         font=font,
                                         anchor=align,
                                         state="normal",
                                     )
-                                self.tag_raise(iid)
                             else:
                                 iid = self.create_text(
                                     draw_x,
                                     draw_y,
-                                    text=text,
+                                    text=t,
                                     fill=fill,
                                     font=font,
                                     anchor=align,
@@ -6642,6 +6676,7 @@ class MainTable(tk.Canvas):
                 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,
@@ -6750,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:
@@ -6772,26 +6807,20 @@ class MainTable(tk.Canvas):
         c: int,
         type_: Literal["cells", "rows", "columns"],
         fill_iid: int,
-        lower_selection_boxes: bool = True,
     ) -> int:
-        fill, outline = self.get_selected_box_bg_fg(type_=type_)
+        _, outline = self.get_selected_box_bg_fg(type_=type_)
         x1 = self.col_positions[c] + 1
         y1 = self.row_positions[r] + 1
         x2 = self.col_positions[c + 1] if index_exists(self.col_positions, c + 1) else self.col_positions[c] + 1
         y2 = self.row_positions[r + 1] if index_exists(self.row_positions, r + 1) else self.row_positions[r] + 1
         self.hide_selected()
-        if self.PAR.ops.show_selected_cells_border:
-            fill = ""
-        else:
-            fill = outline
-            outline = ""
         iid = self.display_box(
             x1,
             y1,
             x2,
             y2,
-            fill=fill,
-            outline=outline,
+            fill="",
+            outline=outline if self.PAR.ops.show_selected_cells_border else "",
             state="normal",
             tags="selected",
             width=2,
@@ -6804,8 +6833,6 @@ class MainTable(tk.Canvas):
             iid=iid,
             fill_iid=fill_iid,
         )
-        if lower_selection_boxes:
-            self.lower_selection_boxes()
         return iid
 
     def display_box(
@@ -6856,14 +6883,17 @@ class MainTable(tk.Canvas):
             self.hidd_boxes.add(item)
             self.itemconfig(item, state="hidden")
 
+    def hide_box_fill(self, item: int | None) -> None:
+        if isinstance(item, int):
+            self.disp_selection_fills.discard(item)
+            self.hidd_selection_fills.add(item)
+
     def hide_selection_box(self, item: int | None) -> bool:
         if item is None or item is True or item not in self.selection_boxes:
             return False
         box = self.selection_boxes.pop(item)
-        self.hide_box(box.fill_iid)
+        self.hide_box_fill(box.fill_iid)
         self.hide_box(box.bd_iid)
-        self.RI.hide_box(box.index)
-        self.CH.hide_box(box.header)
         if self.selected.fill_iid == item:
             self.hide_selected()
             self.set_current_to_last()
@@ -6880,6 +6910,15 @@ class MainTable(tk.Canvas):
             self.hide_box(self.selected.iid)
             self.selected = ()
 
+    def get_selection_fill(self) -> int:
+        if self.hidd_selection_fills:
+            iid = self.hidd_selection_fills.pop()
+        else:
+            self.selection_box_ctr += 1
+            iid = self.selection_box_ctr
+        self.disp_selection_fills.add(iid)
+        return iid
+
     def create_selection_box(
         self,
         r1: int,
@@ -6899,52 +6938,35 @@ class MainTable(tk.Canvas):
             r1 = 0
             r2 = 0
         if type_ == "cells":
-            mt_bg = self.PAR.ops.table_selected_cells_bg
             mt_border_col = self.PAR.ops.table_selected_cells_border_fg
         elif type_ == "rows":
-            mt_bg = self.PAR.ops.table_selected_rows_bg
             mt_border_col = self.PAR.ops.table_selected_rows_border_fg
         elif type_ == "columns":
-            mt_bg = self.PAR.ops.table_selected_columns_bg
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if self.selection_boxes:
-            self.itemconfig(next(reversed(self.selection_boxes)), state="normal")
+            next(reversed(self.selection_boxes.values())).state = "normal"
         x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
-        fill_iid = self.display_box(
-            x1,
-            y1,
-            x2,
-            y2,
-            fill=mt_bg,
-            outline="",
-            state=state if self.PAR.ops.show_selected_cells_border else "normal",
-            tags=type_,
-            width=1,
-        )
-        index_iid = self.RI.display_box(
-            0,
-            y1,
-            self.RI.current_width - 1,
-            y2,
-            fill=self.PAR.ops.index_selected_rows_bg if type_ == "rows" else self.PAR.ops.index_selected_cells_bg,
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "columns" else type_,
-        )
-        header_iid = self.CH.display_box(
-            x1,
-            0,
-            self.col_positions[c2],
-            self.CH.current_height - 1,
-            fill=(
-                self.PAR.ops.header_selected_columns_bg if type_ == "columns" else self.PAR.ops.header_selected_cells_bg
-            ),
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "rows" else type_,
-        )
+        fill_iid = self.get_selection_fill()
         bd_iid = None
-        if self.PAR.ops.show_selected_cells_border and (
+        # fill might not display if canvas is wider than 32k pixels
+        if self.PAR.ops.selected_rows_to_end_of_window and type_ == "rows":
+            bd_iid = self.display_box(
+                x1,
+                y1,
+                x2,
+                y2,
+                fill=self.PAR.ops.table_selected_rows_bg,
+                outline=""
+                if self.PAR.name == "!SheetDropdown"
+                else mt_border_col
+                if self.PAR.ops.show_selected_cells_border
+                else "",
+                state="normal",
+                tags=f"{type_}bd",
+                width=1,
+            )
+            self.tag_lower(bd_iid)
+        elif self.PAR.ops.show_selected_cells_border and (
             ext
             or self.ctrl_b1_pressed
             or (self.being_drawn_item is None and self.RI.being_drawn_item is None and self.CH.being_drawn_item is None)
@@ -6964,10 +6986,11 @@ class MainTable(tk.Canvas):
         self.selection_boxes[fill_iid] = SelectionBox(
             fill_iid=fill_iid,
             bd_iid=bd_iid,
-            index=index_iid,
-            header=header_iid,
+            index=fill_iid,
+            header=fill_iid,
             coords=Box_nt(r1, c1, r2, c2),
             type_=type_,
+            state=state,
         )
         if set_current:
             if set_current is True:
@@ -6976,26 +6999,11 @@ class MainTable(tk.Canvas):
             elif isinstance(set_current, tuple):
                 curr_r = set_current[0]
                 curr_c = set_current[1]
-            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid, lower_selection_boxes=False)
-        self.lower_selection_boxes()
+            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid)
         if run_binding:
             self.run_selection_binding(type_)
         return fill_iid
 
-    def lower_selection_boxes(self) -> None:
-        if self.selected:
-            if not self.PAR.ops.show_selected_cells_border:
-                self.tag_lower(self.selected.iid)
-            self.tag_lower("rows")
-            self.tag_lower("columns")
-            self.tag_lower("cells")
-            self.RI.tag_lower("rows")
-            self.RI.tag_lower("cells")
-            self.CH.tag_lower("columns")
-            self.CH.tag_lower("cells")
-            if self.PAR.ops.show_selected_cells_border:
-                self.tag_raise(self.selected.iid)
-
     def box_coords_x_canvas_coords(
         self,
         r1: int,
@@ -7026,13 +7034,10 @@ class MainTable(tk.Canvas):
         type_ = self.selection_boxes[fill_iid].type_
         self.selection_boxes[fill_iid].coords = Box_nt(r1, c1, r2, c2)
         if type_ == "cells":
-            mt_bg = self.PAR.ops.table_selected_cells_bg
             mt_border_col = self.PAR.ops.table_selected_cells_border_fg
         elif type_ == "rows":
-            mt_bg = self.PAR.ops.table_selected_rows_bg
             mt_border_col = self.PAR.ops.table_selected_rows_border_fg
         elif type_ == "columns":
-            mt_bg = self.PAR.ops.table_selected_columns_bg
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if not state:
             if r2 - r1 > 1 or c2 - c1 > 1:
@@ -7044,31 +7049,7 @@ class MainTable(tk.Canvas):
         if self.selected.fill_iid == fill_iid:
             self.selected = self.selected._replace(box=Box_nt(r1, c1, r2, c2))
         x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
-        self.display_box(x1, y1, x2, y2, fill=mt_bg, outline="", state=state, tags=type_, width=1, iid=fill_iid)
-        self.RI.display_box(
-            0,
-            y1,
-            self.RI.current_width - 1,
-            y2,
-            fill=self.PAR.ops.index_selected_rows_bg if type_ == "rows" else self.PAR.ops.index_selected_cells_bg,
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "columns" else type_,
-            iid=self.selection_boxes[fill_iid].index,
-        )
-        self.CH.display_box(
-            x1,
-            0,
-            self.col_positions[c2],
-            self.CH.current_height - 1,
-            fill=(
-                self.PAR.ops.header_selected_columns_bg if type_ == "columns" else self.PAR.ops.header_selected_cells_bg
-            ),
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "rows" else type_,
-            iid=self.selection_boxes[fill_iid].header,
-        )
+        self.selection_boxes[fill_iid].state = state
         if bd_iid := self.selection_boxes[fill_iid].bd_iid:
             if self.PAR.ops.show_selected_cells_border:
                 self.display_box(
@@ -7140,21 +7121,23 @@ 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.type_ == "cells":
-                for r in range(startr, endr):
+            if box.state == "normal" or ignore_hidd_current:
+                if box.type_ == "cells":
+                    for r in range(startr, endr):
+                        for c in range(startc, endc):
+                            if r1 <= r and c1 <= c and r2 > r and c2 > c:
+                                d["cells"].add((r, c))
+                elif box.type_ == "rows":
+                    for r in range(startr, endr):
+                        if r1 <= r and r2 > r:
+                            d["rows"].add(r)
+                elif box.type_ == "columns":
                     for c in range(startc, endc):
-                        if r1 <= r and c1 <= c and r2 > r and c2 > c:
-                            d["cells"].add((r, c))
-            elif box.type_ == "rows":
-                for r in range(startr, endr):
-                    if r1 <= r and r2 > r:
-                        d["rows"].add(r)
-            elif box.type_ == "columns":
-                for c in range(startc, endc):
-                    if c1 <= c and c2 > c:
-                        d["columns"].add(c)
+                        if c1 <= c and c2 > c:
+                            d["columns"].add(c)
         return d
 
     def get_selected_min_max(self) -> tuple[int, int, int, int] | tuple[None, None, None, None]:
@@ -8001,8 +7984,8 @@ class MainTable(tk.Canvas):
         )
         if "checkbox" in kwargs:
             return False
-        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
-            return kwargs["values"][0]
+        elif "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and kwargs["dropdown"]["values"]:
+            return kwargs["dropdown"]["values"][0]
         else:
             return ""
 
@@ -8103,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__()
@@ -8128,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,
@@ -8168,7 +8177,7 @@ class MainTable(tk.Canvas):
         elif "format" in kwargs:
             return True
         elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty, check_fmt=False) or (
-            (dropdown := kwargs.get("dropdown", {})) and dropdown["validate_input"] and value not in dropdown["values"]
+            "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and value not in kwargs["dropdown"]["values"]
         ):
             return False
         elif "checkbox" in kwargs: