tksheet 7.4.4__py3-none-any.whl → 7.4.6__py3-none-any.whl

tksheet/main_table.py

@@ -11,7 +11,7 @@ from itertools import accumulate, chain, cycle, filterfalse, islice, repeat
 from math import ceil, floor
 from operator import itemgetter
 from tkinter import TclError
-from typing import Literal
+from typing import Any, Literal
 
 from .colors import color_map
 from .column_headers import ColumnHeaders
@@ -101,7 +101,7 @@ from .other_classes import (
 from .row_index import RowIndex
 from .sorting import sort_selection
 from .text_editor import TextEditor
-from .tksheet_types import AnyIter
+from .tksheet_types import AnyIter, Binding
 
 
 class MainTable(tk.Canvas):
@@ -122,7 +122,7 @@ class MainTable(tk.Canvas):
         self.PAR_height = 0
         self.cells_cache = None
         self.table_txt_height, self.index_txt_height, self.header_txt_height = 0, 0, 0
-        self.scrollregion = tuple()
+        self.scrollregion = ()
         self.current_cursor = ""
         self.ctrl_b1_pressed = False
         self.b1_pressed_loc = None
@@ -164,7 +164,7 @@ class MainTable(tk.Canvas):
         self.hidd_boxes = set()
 
         self.selection_boxes = {}
-        self.selected = tuple()
+        self.selected = ()
         self.named_spans = {}
         self.reset_tags()
         self.cell_options = {}
@@ -305,14 +305,13 @@ class MainTable(tk.Canvas):
             self.data = kwargs["data_reference"]
         else:
             self.data = []
-        if not self.data:
-            if (
-                isinstance(kwargs["total_rows"], int)
-                and isinstance(kwargs["total_cols"], int)
-                and kwargs["total_rows"] > 0
-                and kwargs["total_cols"] > 0
-            ):
-                self.data = [list(repeat("", kwargs["total_cols"])) for i in range(kwargs["total_rows"])]
+        if not self.data and (
+            isinstance(kwargs["total_rows"], int)
+            and isinstance(kwargs["total_cols"], int)
+            and kwargs["total_rows"] > 0
+            and kwargs["total_cols"] > 0
+        ):
+            self.data = [list(repeat("", kwargs["total_cols"])) for i in range(kwargs["total_rows"])]
         _header = kwargs["header"] if kwargs["header"] is not None else kwargs["headers"]
         if isinstance(_header, int):
             self._headers = _header
@@ -336,14 +335,14 @@ class MainTable(tk.Canvas):
         self.set_col_positions(itr=[])
         self.set_row_positions(itr=[])
         self.display_rows(
-            rows=kwargs["displayed_rows"],
+            rows=kwargs["displayed_rows"] if isinstance(kwargs["displayed_rows"], list) else [],
             all_rows_displayed=kwargs["all_rows_displayed"],
             reset_row_positions=False,
             deselect_all=False,
         )
         self.reset_row_positions()
         self.display_columns(
-            columns=kwargs["displayed_columns"],
+            columns=kwargs["displayed_columns"] if isinstance(kwargs["displayed_columns"], list) else [],
             all_columns_displayed=kwargs["all_columns_displayed"],
             reset_col_positions=False,
             deselect_all=False,
@@ -360,10 +359,10 @@ class MainTable(tk.Canvas):
             else:
                 super().event_generate(*args, **kwargs)
 
-    def refresh(self, event: object = None) -> None:
+    def refresh(self, event: Any = None) -> None:
         self.PAR.set_refresh_timer()
 
-    def window_configured(self, event: object) -> None:
+    def window_configured(self, event: Any) -> None:
         w = self.PAR.winfo_width()
         if w != self.PAR_width:
             self.PAR_width = w
@@ -551,15 +550,7 @@ class MainTable(tk.Canvas):
                     self.set_currently_selected(row, column, item=item)
                 else:
                     self.select_cell(row, column, redraw=False)
-            if not self.see(
-                row,
-                column,
-                keep_yscroll=False,
-                keep_xscroll=False,
-                bottom_right_corner=False,
-                check_cell_visibility=True,
-                redraw=True,
-            ):
+            if not self.see(row, column):
                 self.refresh()
         return coords
 
@@ -817,7 +808,7 @@ class MainTable(tk.Canvas):
         if self.selected.type_ in ("cells", "columns"):
             for rn in range(maxrows):
                 row = []
-                for r1, c1, r2, c2 in boxes:
+                for r1, c1, _, c2 in boxes:
                     datarn = (r1 + rn) if self.all_rows_displayed else self.displayed_rows[r1 + rn]
                     for c in range(c1, c2):
                         datacn = self.datacn(c)
@@ -983,7 +974,7 @@ class MainTable(tk.Canvas):
             self.refresh()
         return event_data
 
-    def ctrl_v(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+    def ctrl_v(self, event: Any = None, validation: bool = True) -> None | EventDataDict:
         if not self.PAR.ops.paste_can_expand_x and len(self.col_positions) == 1:
             return
         if not self.PAR.ops.paste_can_expand_y and len(self.row_positions) == 1:
@@ -1043,23 +1034,21 @@ class MainTable(tk.Canvas):
         added_rows = 0
         added_cols = 0
         total_data_cols = None
-        if self.PAR.ops.paste_can_expand_x:
-            if selected_c + new_data_numcols > len(self.col_positions) - 1:
-                total_data_cols = self.equalize_data_row_lengths()
-                added_cols = selected_c + new_data_numcols - len(self.col_positions) + 1
-                if (
-                    isinstance(self.PAR.ops.paste_insert_column_limit, int)
-                    and self.PAR.ops.paste_insert_column_limit < len(self.col_positions) - 1 + added_cols
-                ):
-                    added_cols = self.PAR.ops.paste_insert_column_limit - len(self.col_positions) - 1
-        if self.PAR.ops.paste_can_expand_y:
-            if selected_r + new_data_numrows > len(self.row_positions) - 1:
-                added_rows = selected_r + new_data_numrows - len(self.row_positions) + 1
-                if (
-                    isinstance(self.PAR.ops.paste_insert_row_limit, int)
-                    and self.PAR.ops.paste_insert_row_limit < len(self.row_positions) - 1 + added_rows
-                ):
-                    added_rows = self.PAR.ops.paste_insert_row_limit - len(self.row_positions) - 1
+        if self.PAR.ops.paste_can_expand_x and selected_c + new_data_numcols > len(self.col_positions) - 1:
+            total_data_cols = self.equalize_data_row_lengths()
+            added_cols = selected_c + new_data_numcols - len(self.col_positions) + 1
+            if (
+                isinstance(self.PAR.ops.paste_insert_column_limit, int)
+                and self.PAR.ops.paste_insert_column_limit < len(self.col_positions) - 1 + added_cols
+            ):
+                added_cols = self.PAR.ops.paste_insert_column_limit - len(self.col_positions) - 1
+        if self.PAR.ops.paste_can_expand_y and selected_r + new_data_numrows > len(self.row_positions) - 1:
+            added_rows = selected_r + new_data_numrows - len(self.row_positions) + 1
+            if (
+                isinstance(self.PAR.ops.paste_insert_row_limit, int)
+                and self.PAR.ops.paste_insert_row_limit < len(self.row_positions) - 1 + added_rows
+            ):
+                added_rows = self.PAR.ops.paste_insert_row_limit - len(self.row_positions) - 1
         if selected_c + new_data_numcols > len(self.col_positions) - 1:
             adjusted_new_data_numcols = len(self.col_positions) - 1 - selected_c
         else:
@@ -1202,14 +1191,8 @@ class MainTable(tk.Canvas):
                     event_data=event_data,
                     mod_event_boxes=False,
                 )
-        if added_rows:
-            selboxr = selected_r + new_data_numrows
-        else:
-            selboxr = selected_r_adjusted_new_data_numrows
-        if added_cols:
-            selboxc = selected_c + new_data_numcols
-        else:
-            selboxc = selected_c_adjusted_new_data_numcols
+        selboxr = selected_r + new_data_numrows if added_rows else selected_r_adjusted_new_data_numrows
+        selboxc = selected_c + new_data_numcols if added_cols else selected_c_adjusted_new_data_numcols
         self.deselect("all", redraw=False)
         self.set_currently_selected(
             *curr_coords,
@@ -1225,15 +1208,7 @@ class MainTable(tk.Canvas):
         )
         event_data["selection_boxes"] = self.get_boxes()
         event_data["selected"] = self.selected
-        self.see(
-            r=selected_r,
-            c=selected_c,
-            keep_yscroll=False,
-            keep_xscroll=False,
-            bottom_right_corner=False,
-            check_cell_visibility=True,
-            redraw=False,
-        )
+        self.see(selected_r, selected_c, redraw=False)
         self.refresh()
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
             self.undo_stack.append(stored_event_dict(event_data))
@@ -1242,7 +1217,7 @@ class MainTable(tk.Canvas):
             self.PAR.emit_event("<<Paste>>", event_data)
         return event_data
 
-    def delete_key(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+    def delete_key(self, event: Any = None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = self.new_event_dict("edit_table")
@@ -1276,7 +1251,7 @@ class MainTable(tk.Canvas):
             self.PAR.emit_event("<<Delete>>", event_data)
         return event_data
 
-    def event_data_set_cell(self, datarn: int, datacn: int, value: object, event_data: dict) -> EventDataDict:
+    def event_data_set_cell(self, datarn: int, datacn: int, value: Any, event_data: dict) -> EventDataDict:
         if self.input_valid_for_cell(datarn, datacn, value):
             event_data["cells"]["table"][(datarn, datacn)] = self.get_cell_data(datarn, datacn)
             self.set_cell_data(datarn, datacn, value)
@@ -1421,7 +1396,7 @@ class MainTable(tk.Canvas):
                         "c",
                     )
                     # add cell/col kwargs for columns that are new to the span
-                    old_span_idxs = set(full_new_idxs[k] for k in range(span["from_c"], oldupto_colrange))
+                    old_span_idxs = {full_new_idxs[k] for k in range(span["from_c"], oldupto_colrange)}
                     for k in range(newfrom, newupto_colrange):
                         if k not in old_span_idxs:
                             oldidx = full_old_idxs[k]
@@ -1659,7 +1634,7 @@ class MainTable(tk.Canvas):
                         "r",
                     )
                     # add cell/row kwargs for rows that are new to the span
-                    old_span_idxs = set(full_new_idxs[k] for k in range(span["from_r"], oldupto_rowrange))
+                    old_span_idxs = {full_new_idxs[k] for k in range(span["from_r"], oldupto_rowrange)}
                     for k in range(newfrom, newupto_rowrange):
                         if k not in old_span_idxs:
                             oldidx = full_old_idxs[k]
@@ -1742,7 +1717,7 @@ class MainTable(tk.Canvas):
                     # finally, change the span coords
                     span["from_r"], span["upto_r"] = newfrom, newupto
 
-        if move_heights and disp_new_idxs:
+        if (not self.PAR.ops.treeview or not undo_modification) and (move_heights and disp_new_idxs):
             self.set_row_positions(
                 itr=move_elements_by_mapping_gen(
                     self.get_row_heights(),
@@ -1805,7 +1780,7 @@ class MainTable(tk.Canvas):
             )
         )
 
-    def undo(self, event: object = None) -> None | EventDataDict:
+    def undo(self, event: Any = None) -> None | EventDataDict:
         if not self.undo_stack:
             return
         modification = self.undo_stack[-1]["data"]
@@ -1819,7 +1794,7 @@ class MainTable(tk.Canvas):
         self.PAR.emit_event("<<Undo>>", event_data)
         return event_data
 
-    def redo(self, event: object = None) -> None | EventDataDict:
+    def redo(self, event: Any = None) -> None | EventDataDict:
         if not self.redo_stack:
             return
         modification = self.redo_stack[-1]["data"]
@@ -2048,15 +2023,7 @@ class MainTable(tk.Canvas):
             )
 
         if self.selected:
-            self.see(
-                r=self.selected.row,
-                c=self.selected.column,
-                keep_yscroll=False,
-                keep_xscroll=False,
-                bottom_right_corner=False,
-                check_cell_visibility=True,
-                redraw=False,
-            )
+            self.see(self.selected.row, self.selected.column, redraw=False)
 
         self.refresh()
         return event_data
@@ -2067,18 +2034,27 @@ class MainTable(tk.Canvas):
         c: int | None = None,
         keep_yscroll: bool = False,
         keep_xscroll: bool = False,
-        bottom_right_corner: bool = False,
+        bottom_right_corner: bool | None = None,
         check_cell_visibility: bool = True,
         redraw: bool = True,
         r_pc: float = 0.0,
         c_pc: float = 0.0,
     ) -> bool:
         need_redraw = False
-        yvis, xvis = False, False
-        if check_cell_visibility:
-            yvis, xvis = self.cell_completely_visible(r=r, c=c, separate_axes=True)
-        if not yvis and len(self.row_positions) > 1:
-            if bottom_right_corner:
+        vis_info = self.cell_visibility_info(r, c)
+        yvis, xvis = vis_info["yvis"], vis_info["xvis"]
+        top_left_x, top_left_y, bottom_right_x, bottom_right_y = vis_info["visible_region"]
+        x1, y1, x2, y2 = vis_info["cell_coords"]
+        # y scroll
+        if not check_cell_visibility or (check_cell_visibility and not yvis) and len(self.row_positions) > 1:
+            if bottom_right_corner is None:
+                both_above = y1 < top_left_y and y2 < top_left_y
+                y1_above_y2_below = y1 < top_left_y and y2 > bottom_right_y
+                y1_above_y2_visible = y1 < top_left_y and top_left_y <= y2 <= bottom_right_y
+                brc = not (both_above or y1_above_y2_below or y1_above_y2_visible)
+            else:
+                brc = bottom_right_corner
+            if brc:
                 if r is not None and not keep_yscroll:
                     winfo_height = self.winfo_height()
                     if self.row_positions[r + 1] - self.row_positions[r] > winfo_height:
@@ -2104,8 +2080,16 @@ class MainTable(tk.Canvas):
                     ]
                     self.set_yviews(*args, redraw=False)
                     need_redraw = True
-        if not xvis and len(self.col_positions) > 1:
-            if bottom_right_corner:
+        # x scroll
+        if not check_cell_visibility or (check_cell_visibility and not xvis) and len(self.col_positions) > 1:
+            if bottom_right_corner is None:
+                both_left = x1 < top_left_x and x2 < top_left_x
+                x1_left_x2_right = x1 < top_left_x and x2 > bottom_right_x
+                x1_left_x2_visible = x1 < top_left_x and top_left_x <= x2 <= bottom_right_x
+                brc = not (both_left or x1_left_x2_right or x1_left_x2_visible)
+            else:
+                brc = bottom_right_corner
+            if brc:
                 if c is not None and not keep_xscroll:
                     winfo_width = self.winfo_width()
                     if self.col_positions[c + 1] - self.col_positions[c] > winfo_width:
@@ -2144,17 +2128,24 @@ class MainTable(tk.Canvas):
             0 if not r else self.row_positions[r + 1],
         )
 
-    def cell_completely_visible(
+    def cell_completely_visible(self, r: int | None = 0, c: int | None = 0) -> bool:
+        cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
+        x1, y1, x2, y2 = self.get_cell_coords(r, c)
+        return cy1 <= y1 and cy2 >= y2 and cx1 <= x1 and cx2 >= x2
+
+    def cell_visibility_info(
         self,
-        r: int | None = 0,
-        c: int | None = 0,
-        separate_axes: bool = False,
-    ) -> bool | tuple[bool, bool]:
+        r: int,
+        c: int,
+    ) -> dict[Literal["yvis", "xvis", "visible_region", "cell_coords"], bool | tuple[int, int, int, int]]:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
         x1, y1, x2, y2 = self.get_cell_coords(r, c)
-        x_vis = cx1 <= x1 and cx2 >= x2
-        y_vis = cy1 <= y1 and cy2 >= y2
-        return (y_vis, x_vis) if separate_axes else y_vis and x_vis
+        return {
+            "yvis": cy1 <= y1 and cy2 >= y2,
+            "xvis": cx1 <= x1 and cx2 >= x2,
+            "visible_region": (cx1, cy1, cx2, cy2),
+            "cell_coords": (x1, y1, x2, y2),
+        }
 
     def cell_visible(self, r: int = 0, c: int = 0) -> bool:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
@@ -2184,7 +2175,7 @@ class MainTable(tk.Canvas):
                 self.PAR.emit_event("<<SheetSelect>>", data=event_data)
                 self.PAR.emit_event("<<SelectAll>>", data=event_data)
 
-    def select_columns(self, event: object) -> None:
+    def select_columns(self, event: Any) -> None:
         if not self.selected:
             return
         r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
@@ -2195,7 +2186,7 @@ class MainTable(tk.Canvas):
             item=self.CH.select_col(range(c1, c2), redraw=True),
         )
 
-    def select_rows(self, event: object) -> None:
+    def select_rows(self, event: Any) -> None:
         if not self.selected:
             return
         r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
@@ -2206,12 +2197,12 @@ class MainTable(tk.Canvas):
             item=self.RI.select_row(range(r1, r2), redraw=True),
         )
 
-    def select_row_start(self, event: object) -> None:
+    def select_row_start(self, event: Any) -> None:
         if self.selected:
             self.see(self.selected.row, 0)
             self.select_cell(self.selected.row, 0, redraw=True)
 
-    def select_a1(self, event: object) -> None:
+    def select_a1(self, event: Any) -> None:
         if len(self.row_positions) > 1 and len(self.col_positions) > 1:
             self.see(0, 0)
             self.select_cell(0, 0, redraw=True)
@@ -2301,10 +2292,10 @@ class MainTable(tk.Canvas):
         curr_box = self.selected.fill_iid
         if r == "all" or (r is None and c is None and cell is None):
             self.hide_dropdown_editor_all_canvases()
-            for item, box in self.get_selection_items():
+            for item, _ in self.get_selection_items():
                 self.hide_selection_box(item)
         elif r in ("allrows", "allcols"):
-            for item, box in self.get_selection_items(
+            for item, _ in self.get_selection_items(
                 columns=r == "allcols",
                 rows=r == "allrows",
                 cells=False,
@@ -2471,7 +2462,7 @@ class MainTable(tk.Canvas):
         if redraw:
             self.refresh()
 
-    def page_UP(self, event: object = None) -> None:
+    def page_UP(self, event: Any = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto_y = max(0, top - height)
@@ -2496,7 +2487,7 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def page_DOWN(self, event: object = None) -> None:
+    def page_DOWN(self, event: Any = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto = top + height
@@ -2526,159 +2517,85 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def arrowkey_UP(self, event: object = None) -> None:
+    def arrowkey_UP(self, event: Any = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if r and self.RI.row_selection_enabled:
-                if self.cell_completely_visible(r=r - 1, c=0):
-                    self.RI.select_row(r - 1, redraw=True)
-                else:
-                    self.RI.select_row(r - 1)
-                    self.see(r - 1, 0, keep_xscroll=True, check_cell_visibility=False)
-        elif self.selected.type_ in ("cells", "columns"):
-            r = self.selected.row
-            c = self.selected.column
-            if not r and self.CH.col_selection_enabled and not self.cell_completely_visible(r=r, c=c):
-                self.see(r, c, check_cell_visibility=False)
-            elif r and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r - 1, c=c):
-                    self.select_cell(r - 1, c, redraw=True)
-                else:
-                    self.select_cell(r - 1, c)
-                    self.see(r - 1, c, keep_xscroll=True, check_cell_visibility=False)
+        r = self.selected.row
+        c = self.selected.column
+        if not r:
+            self.see(r, c)
+        else:
+            self.see(r - 1, c, redraw=False)
+            if self.selected.type_ == "rows" and self.RI.row_selection_enabled:
+                self.RI.select_row(r - 1, redraw=True)
+
+            elif self.selected.type_ in ("cells", "columns") and (
+                self.single_selection_enabled or self.toggle_selection_enabled
+            ):
+                self.select_cell(r - 1, c, redraw=True)
 
-    def arrowkey_DOWN(self, event: object = None) -> None:
+    def arrowkey_LEFT(self, event: Any = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if r < len(self.row_positions) - 2 and self.RI.row_selection_enabled:
-                if self.cell_completely_visible(r=r + 1, c=0):
-                    self.RI.select_row(r + 1, redraw=True)
-                else:
-                    self.RI.select_row(r + 1)
-                    self.see(
-                        r + 1,
-                        0,
-                        keep_xscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
-
-        elif self.selected.type_ == "columns":
-            c = self.selected.column
-            if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.selected.row == len(self.row_positions) - 2:
-                    r = self.selected.row
-                else:
-                    r = self.selected.row + 1
-                if self.cell_completely_visible(r=r, c=c):
-                    self.select_cell(r, c, redraw=True)
-                else:
-                    self.select_cell(r, c)
-                    self.see(
-                        r,
-                        c,
-                        check_cell_visibility=False,
-                    )
+        r = self.selected.row
+        c = self.selected.column
+        if not c:
+            self.see(r, c)
         else:
-            r = self.selected.row
-            c = self.selected.column
-            if r < len(self.row_positions) - 2 and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r + 1, c=c):
-                    self.select_cell(r + 1, c, redraw=True)
-                else:
-                    self.select_cell(r + 1, c)
-                    self.see(
-                        r + 1,
-                        c,
-                        keep_xscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
+            self.see(r, c - 1, redraw=False)
+            if self.selected.type_ == "columns" and self.CH.col_selection_enabled:
+                self.CH.select_col(c - 1, redraw=True)
+
+            elif self.selected.type_ in ("cells", "rows") and (
+                self.single_selection_enabled or self.toggle_selection_enabled
+            ):
+                self.select_cell(r, c - 1, redraw=True)
 
-    def arrowkey_LEFT(self, event: object = None) -> None:
+    def arrowkey_DOWN(self, event: Any = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "columns":
-            c = self.selected.column
-            if c and self.CH.col_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c - 1):
-                    self.CH.select_col(c - 1, redraw=True)
-                else:
-                    self.CH.select_col(c - 1)
-                    self.see(
-                        0,
-                        c - 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=True,
-                        check_cell_visibility=False,
-                    )
-        elif self.selected.type_ == "rows" and self.selected.column:
-            self.select_cell(self.selected.row, self.selected.column - 1)
-            self.see(self.selected.row, self.selected.column, check_cell_visibility=True)
-        elif self.selected.type_ == "cells":
-            r = self.selected.row
-            c = self.selected.column
-            if not c and not self.cell_completely_visible(r=r, c=c):
-                self.see(r, c, keep_yscroll=True, check_cell_visibility=False)
-            elif c and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r, c=c - 1):
-                    self.select_cell(r, c - 1, redraw=True)
-                else:
-                    self.select_cell(r, c - 1)
-                    self.see(r, c - 1, keep_yscroll=True, check_cell_visibility=False)
+        r = self.selected.row
+        c = self.selected.column
+        if self.selected.row == len(self.row_positions) - 2:
+            self.see(r, c)
+        else:
+            brc = False if self.PAR.ops.arrow_key_down_right_scroll_page else None
+            self.see(
+                r + 1,
+                c,
+                bottom_right_corner=brc,
+                redraw=False,
+            )
+            if self.selected.type_ == "rows" and self.RI.row_selection_enabled:
+                self.RI.select_row(r + 1, redraw=True)
+
+            elif self.selected.type_ in ("cells", "columns") and (
+                self.single_selection_enabled or self.toggle_selection_enabled
+            ):
+                self.select_cell(r + 1, c, redraw=True)
 
-    def arrowkey_RIGHT(self, event: object = None) -> None:
+    def arrowkey_RIGHT(self, event: Any = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.selected.column == len(self.col_positions) - 2:
-                    c = self.selected.column
-                else:
-                    c = self.selected.column + 1
-                if self.cell_completely_visible(r=r, c=c):
-                    self.select_cell(r, c, redraw=True)
-                else:
-                    self.select_cell(r, c)
-                    self.see(
-                        r,
-                        c,
-                        check_cell_visibility=False,
-                    )
-        elif self.selected.type_ == "columns":
-            c = self.selected.column
-            if c < len(self.col_positions) - 2 and self.CH.col_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c + 1):
-                    self.CH.select_col(c + 1, redraw=True)
-                else:
-                    self.CH.select_col(c + 1)
-                    self.see(
-                        0,
-                        c + 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
+        r = self.selected.row
+        c = self.selected.column
+        if self.selected.column == len(self.col_positions) - 2:
+            self.see(r, c)
         else:
-            r = self.selected.row
-            c = self.selected.column
-            if c < len(self.col_positions) - 2 and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r, c=c + 1):
-                    self.select_cell(r, c + 1, redraw=True)
-                else:
-                    self.select_cell(r, c + 1)
-                    self.see(
-                        r,
-                        c + 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
+            brc = False if self.PAR.ops.arrow_key_down_right_scroll_page else None
+            self.see(
+                r,
+                c + 1,
+                bottom_right_corner=brc,
+                redraw=False,
+            )
+            if self.selected.type_ == "columns" and self.CH.col_selection_enabled:
+                self.CH.select_col(c + 1, redraw=True)
+
+            elif self.selected.type_ in ("cells", "rows") and (
+                self.single_selection_enabled or self.toggle_selection_enabled
+            ):
+                self.select_cell(r, c + 1, redraw=True)
 
     def shift_arrowkey_select_box(
         self,
@@ -2712,7 +2629,7 @@ class MainTable(tk.Canvas):
         self.see(see_r, see_c, keep_xscroll=keep_xscroll, keep_yscroll=keep_yscroll, redraw=False)
         self.refresh()
 
-    def shift_arrowkey_UP(self, event: object = None) -> None:
+    def shift_arrowkey_UP(self, event: Any = None) -> None:
         if not self.selected:
             return
         r1, c1, r2, c2 = self.selected.box
@@ -2729,7 +2646,7 @@ class MainTable(tk.Canvas):
             see_r = r1
         self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, see_r, c1, keep_xscroll=True)
 
-    def shift_arrowkey_DOWN(self, event: object = None) -> None:
+    def shift_arrowkey_DOWN(self, event: Any = None) -> None:
         if not self.selected:
             return
         r1, c1, r2, c2 = self.selected.box
@@ -2744,7 +2661,7 @@ class MainTable(tk.Canvas):
             see_r = r1
         self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, see_r, c1, keep_xscroll=True)
 
-    def shift_arrowkey_LEFT(self, event: object = None) -> None:
+    def shift_arrowkey_LEFT(self, event: Any = None) -> None:
         if not self.selected:
             return
         r1, c1, r2, c2 = self.selected.box
@@ -2761,7 +2678,7 @@ class MainTable(tk.Canvas):
             see_c = c1
         self.shift_arrowkey_select_box(r1, c1, r2, c2, current_r, current_c, r1, see_c, keep_yscroll=True)
 
-    def shift_arrowkey_RIGHT(self, event: object = None) -> None:
+    def shift_arrowkey_RIGHT(self, event: Any = None) -> None:
         if not self.selected:
             return
         r1, c1, r2, c2 = self.selected.box
@@ -3100,7 +3017,7 @@ class MainTable(tk.Canvas):
                 **mnkwgs,
             )
 
-    def enable_bindings(self, bindings: object) -> None:
+    def enable_bindings(self, bindings: Any) -> None:
         if not bindings:
             self._enable_binding("all")
         elif isinstance(bindings, (list, tuple)):
@@ -3114,7 +3031,7 @@ class MainTable(tk.Canvas):
             self._enable_binding(bindings.lower())
         self.create_rc_menus()
 
-    def disable_bindings(self, bindings: object) -> None:
+    def disable_bindings(self, bindings: Any) -> None:
         if not bindings:
             self._disable_binding("all")
         elif isinstance(bindings, (list, tuple)):
@@ -3128,7 +3045,7 @@ class MainTable(tk.Canvas):
             self._disable_binding(bindings)
         self.create_rc_menus()
 
-    def _enable_binding(self, binding: str) -> None:
+    def _enable_binding(self, binding: Binding) -> None:
         if binding == "enable_all":
             binding = "all"
         if binding in (
@@ -3273,7 +3190,7 @@ class MainTable(tk.Canvas):
             for binding in self.PAR.ops[bindings_key]:
                 widget.bind(binding, func)
 
-    def _disable_binding(self, binding: str) -> None:
+    def _disable_binding(self, binding: Binding) -> None:
         if binding == "disable_all":
             binding = "all"
         if binding in (
@@ -3412,14 +3329,14 @@ class MainTable(tk.Canvas):
         self.CH.rsz_w = None
         self.CH.rsz_h = None
 
-    def mouse_motion(self, event: object):
+    def mouse_motion(self, event: Any) -> None:
         self.reset_mouse_motion_creations()
         try_binding(self.extra_motion_func, event)
 
     def not_currently_resizing(self) -> bool:
         return all(v is None for v in (self.RI.rsz_h, self.RI.rsz_w, self.CH.rsz_h, self.CH.rsz_w))
 
-    def rc(self, event=None):
+    def rc(self, event: Any = None) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         popup_menu = None
@@ -3452,7 +3369,7 @@ class MainTable(tk.Canvas):
         if popup_menu:
             popup_menu.tk_popup(event.x_root, event.y_root)
 
-    def b1_press(self, event=None):
+    def b1_press(self, event: Any = None) -> None:
         self.closed_dropdown = self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         if (
@@ -3474,7 +3391,9 @@ class MainTable(tk.Canvas):
         self.b1_pressed_loc = (r, c)
         try_binding(self.extra_b1_press_func, event)
 
-    def create_resize_line(self, x1, y1, x2, y2, width, fill, tag):
+    def create_resize_line(
+        self, x1: int, y1: int, x2: int, y2: int, width: int, fill: str, tag: str | tuple[str]
+    ) -> None:
         if self.hidd_resize_lines:
             t, sh = self.hidd_resize_lines.popitem()
             self.coords(t, x1, y1, x2, y2)
@@ -3487,7 +3406,7 @@ class MainTable(tk.Canvas):
             t = self.create_line(x1, y1, x2, y2, width=width, fill=fill, tags=tag)
         self.disp_resize_lines[t] = True
 
-    def delete_resize_lines(self):
+    def delete_resize_lines(self) -> None:
         self.hidd_resize_lines.update(self.disp_resize_lines)
         self.disp_resize_lines = {}
         for t, sh in self.hidd_resize_lines.items():
@@ -3495,7 +3414,7 @@ class MainTable(tk.Canvas):
                 self.itemconfig(t, state="hidden")
                 self.hidd_resize_lines[t] = False
 
-    def ctrl_b1_press(self, event=None):
+    def ctrl_b1_press(self, event: Any = None) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         self.ctrl_b1_pressed = True
@@ -3513,7 +3432,7 @@ class MainTable(tk.Canvas):
         elif not self.ctrl_select_enabled:
             self.b1_press(event)
 
-    def ctrl_shift_b1_press(self, event=None):
+    def ctrl_shift_b1_press(self, event: Any = None) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         self.ctrl_b1_pressed = True
@@ -3541,7 +3460,7 @@ class MainTable(tk.Canvas):
         elif not self.ctrl_select_enabled:
             self.shift_b1_press(event)
 
-    def shift_b1_press(self, event=None):
+    def shift_b1_press(self, event: Any = None) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         if self.drag_selection_enabled and self.not_currently_resizing():
@@ -3568,7 +3487,7 @@ class MainTable(tk.Canvas):
                 try_binding(self.shift_selection_binding_func, sel_event)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
 
-    def get_shift_select_box(self, min_r: int, rowsel: int, min_c: int, colsel: int):
+    def get_shift_select_box(self, min_r: int, rowsel: int, min_c: int, colsel: int) -> tuple[int, int, int, int]:
         if rowsel >= min_r and colsel >= min_c:
             return min_r, min_c, rowsel + 1, colsel + 1
         elif rowsel >= min_r and min_c >= colsel:
@@ -3578,7 +3497,13 @@ class MainTable(tk.Canvas):
         elif min_r >= rowsel and min_c >= colsel:
             return rowsel, colsel, min_r + 1, min_c + 1
 
-    def get_b1_motion_box(self, start_row: int, start_col: int, end_row: int, end_col: int):
+    def get_b1_motion_box(
+        self,
+        start_row: int,
+        start_col: int,
+        end_row: int,
+        end_col: int,
+    ) -> tuple[int, int, int, int, Literal["cells"]]:
         if end_row >= start_row and end_col >= start_col and (end_row - start_row or end_col - start_col):
             return start_row, start_col, end_row + 1, end_col + 1, "cells"
         elif end_row >= start_row and end_col < start_col and (end_row - start_row or start_col - end_col):
@@ -3590,7 +3515,7 @@ class MainTable(tk.Canvas):
         else:
             return start_row, start_col, start_row + 1, start_col + 1, "cells"
 
-    def b1_motion(self, event: object):
+    def b1_motion(self, event: Any) -> None:
         if self.drag_selection_enabled and all(
             v is None
             for v in (
@@ -3638,7 +3563,7 @@ class MainTable(tk.Canvas):
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
         try_binding(self.extra_b1_motion_func, event)
 
-    def ctrl_b1_motion(self, event: object):
+    def ctrl_b1_motion(self, event: Any) -> None:
         if self.ctrl_select_enabled and self.drag_selection_enabled and self.not_currently_resizing():
             need_redraw = False
             end_row = self.identify_row(y=event.y)
@@ -3681,7 +3606,7 @@ class MainTable(tk.Canvas):
         elif not self.ctrl_select_enabled:
             self.b1_motion(event)
 
-    def b1_release(self, event=None):
+    def b1_release(self, event: Any = None) -> None:
         to_hide = self.being_drawn_item
         if self.being_drawn_item is not None and (to_sel := self.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.selected.row, self.selected.column
@@ -3731,7 +3656,7 @@ class MainTable(tk.Canvas):
         self.closed_dropdown = None
         try_binding(self.extra_b1_release_func, event)
 
-    def double_b1(self, event=None):
+    def double_b1(self, event: Any = None) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         if (
@@ -3755,7 +3680,7 @@ class MainTable(tk.Canvas):
                     self.open_cell(event)
         try_binding(self.extra_double_b1_func, event)
 
-    def identify_row(self, event=None, y=None, allow_end=True):
+    def identify_row(self, event: Any = None, y: int | None = None, allow_end: bool = True) -> int | None:
         if event is None:
             y2 = self.canvasy(y)
         elif y is None:
@@ -3767,7 +3692,7 @@ class MainTable(tk.Canvas):
             return None
         return r
 
-    def identify_col(self, event=None, x=None, allow_end=True):
+    def identify_col(self, event: Any = None, x: int | None = None, allow_end: bool = True) -> int | None:
         if event is None:
             x2 = self.canvasx(x)
         elif x is None:
@@ -3799,7 +3724,7 @@ class MainTable(tk.Canvas):
             if self.show_index:
                 self.RI.yview("moveto", 1)
 
-    def scroll_if_event_offscreen(self, event: object) -> bool:
+    def scroll_if_event_offscreen(self, event: Any) -> bool:
         need_redraw = False
         if self.data:
             xcheck = self.xview()
@@ -3838,7 +3763,7 @@ class MainTable(tk.Canvas):
             self.y_move_synced_scrolls("moveto", self.yview()[0])
         return need_redraw
 
-    def x_move_synced_scrolls(self, *args, redraw: bool = True, use_scrollbar: bool = False):
+    def x_move_synced_scrolls(self, *args: Any, redraw: bool = True, use_scrollbar: bool = False) -> None:
         for widget in self.synced_scrolls:
             # try:
             if hasattr(widget, "MT"):
@@ -3851,7 +3776,7 @@ class MainTable(tk.Canvas):
             # except Exception:
             #     continue
 
-    def y_move_synced_scrolls(self, *args, redraw: bool = True, use_scrollbar: bool = False):
+    def y_move_synced_scrolls(self, *args: Any, redraw: bool = True, use_scrollbar: bool = False) -> None:
         for widget in self.synced_scrolls:
             # try:
             if hasattr(widget, "MT"):
@@ -3864,7 +3789,7 @@ class MainTable(tk.Canvas):
             # except Exception:
             #     continue
 
-    def _xscrollbar(self, *args, move_synced: bool = True):
+    def _xscrollbar(self, *args: Any, move_synced: bool = True) -> None:
         self.xview(*args)
         if self.show_header:
             self.CH.xview(*args)
@@ -3872,7 +3797,7 @@ class MainTable(tk.Canvas):
         if move_synced:
             self.x_move_synced_scrolls(*args, use_scrollbar=True)
 
-    def _yscrollbar(self, *args, move_synced: bool = True):
+    def _yscrollbar(self, *args: Any, move_synced: bool = True) -> None:
         self.yview(*args)
         if self.show_index:
             self.RI.yview(*args)
@@ -3882,7 +3807,7 @@ class MainTable(tk.Canvas):
 
     def set_xviews(
         self,
-        *args,
+        *args: Any,
         move_synced: bool = True,
         redraw: bool = True,
     ) -> None:
@@ -3902,7 +3827,7 @@ class MainTable(tk.Canvas):
 
     def set_yviews(
         self,
-        *args,
+        *args: Any,
         move_synced: bool = True,
         redraw: bool = True,
     ) -> None:
@@ -3924,7 +3849,7 @@ class MainTable(tk.Canvas):
         self.set_xviews(*x_args)
         self.set_yviews(*y_args)
 
-    def mousewheel(self, event: object) -> None:
+    def mousewheel(self, event: Any) -> None:
         if event.delta < 0 or event.num == 5:
             self.yview_scroll(1, "units")
             self.RI.yview_scroll(1, "units")
@@ -3937,7 +3862,7 @@ class MainTable(tk.Canvas):
             self.y_move_synced_scrolls("moveto", self.yview()[0])
         self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
-    def shift_mousewheel(self, event: object) -> None:
+    def shift_mousewheel(self, event: Any) -> None:
         if event.delta < 0 or event.num == 5:
             self.xview_scroll(1, "units")
             self.CH.xview_scroll(1, "units")
@@ -3950,13 +3875,13 @@ class MainTable(tk.Canvas):
             self.x_move_synced_scrolls("moveto", self.xview()[0])
         self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
-    def ctrl_mousewheel(self, event):
+    def ctrl_mousewheel(self, event: Any) -> None:
         if event.delta < 0 or event.num == 5:
             self.zoom_out()
         elif event.delta >= 0 or event.num == 4:
             self.zoom_in()
 
-    def zoom_in(self, event=None):
+    def zoom_in(self, event: Any = None) -> None:
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] + 1, self.PAR.ops.table_font[2]),
             (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] + 1, self.PAR.ops.index_font[2]),
@@ -3964,7 +3889,7 @@ class MainTable(tk.Canvas):
             "in",
         )
 
-    def zoom_out(self, event=None):
+    def zoom_out(self, event: Any = None) -> None:
         if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
             return
         self.zoom_font(
@@ -3974,7 +3899,13 @@ class MainTable(tk.Canvas):
             "out",
         )
 
-    def zoom_font(self, table_font: tuple, index_font: tuple, header_font: tuple, zoom: Literal["in", "out"]) -> None:
+    def zoom_font(
+        self,
+        table_font: FontTuple,
+        index_font: FontTuple,
+        header_font: FontTuple,
+        zoom: Literal["in", "out"],
+    ) -> None:
         self.saved_column_widths = {}
         self.saved_row_heights = {}
         # should record position prior to change and then see after change
@@ -4129,7 +4060,7 @@ class MainTable(tk.Canvas):
                 self.recreate_all_selection_boxes()
         return self.PAR.ops.index_font
 
-    def set_index_font_help(self):
+    def set_index_font_help(self) -> None:
         self.RI.index_font = self.PAR.ops.index_font
         if self.PAR.ops.index_font not in self.char_widths:
             self.char_widths[self.PAR.ops.index_font] = {}
@@ -4169,7 +4100,7 @@ class MainTable(tk.Canvas):
             self.recreate_all_selection_boxes()
         return self.PAR.ops.header_font
 
-    def set_header_font_help(self):
+    def set_header_font_help(self) -> None:
         self.CH.header_font = self.PAR.ops.header_font
         if self.PAR.ops.header_font not in self.char_widths:
             self.char_widths[self.PAR.ops.header_font] = {}
@@ -4183,11 +4114,11 @@ class MainTable(tk.Canvas):
             self.PAR.ops.default_header_height = int(self.min_header_height)
         self.CH.set_height(self.get_default_header_height(), set_TL=True)
 
-    def purge_undo_and_redo_stack(self):
+    def purge_undo_and_redo_stack(self) -> None:
         self.undo_stack = deque(maxlen=self.PAR.ops.max_undos)
         self.redo_stack = deque(maxlen=self.PAR.ops.max_undos)
 
-    def purge_redo_stack(self):
+    def purge_redo_stack(self) -> None:
         self.redo_stack = deque(maxlen=self.PAR.ops.max_undos)
 
     def data_reference(
@@ -4198,7 +4129,7 @@ class MainTable(tk.Canvas):
         redraw: bool = False,
         return_id: bool = True,
         keep_formatting: bool = True,
-    ) -> object:
+    ) -> Any:
         if isinstance(newdataref, (list, tuple)):
             self.hide_dropdown_editor_all_canvases()
             self.data = newdataref
@@ -4218,7 +4149,7 @@ class MainTable(tk.Canvas):
         else:
             return self.data
 
-    def get_cell_dimensions(self, datarn, datacn):
+    def get_cell_dimensions(self, datarn: int, datacn: int) -> tuple[int, int]:
         txt = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
         if txt:
             self.txt_measure_canvas.itemconfig(self.txt_measure_canvas_text, text=txt, font=self.PAR.ops.table_font)
@@ -4232,7 +4163,9 @@ class MainTable(tk.Canvas):
             return w + self.table_txt_height, h
         return w, h
 
-    def set_cell_size_to_text(self, r, c, only_if_too_small=False, redraw: bool = True, run_binding=False):
+    def set_cell_size_to_text(
+        self, r: int, c: int, only_if_too_small: bool = False, redraw: bool = True, run_binding: bool = False
+    ) -> bool:
         min_column_width = self.PAR.ops.min_column_width
         min_rh = self.min_row_height
         w = min_column_width
@@ -4303,6 +4236,7 @@ class MainTable(tk.Canvas):
                 return True
             else:
                 return False
+        return False
 
     def get_cell_max_width(self, datarn: int, dispcn: int) -> int:
         datacn = self.datacn(dispcn)
@@ -4375,14 +4309,8 @@ class MainTable(tk.Canvas):
         qfont = self.PAR.ops.table_font
         numrows = self.total_data_rows()
         numcols = self.total_data_cols()
-        if self.all_columns_displayed:
-            itercols = range(numcols)
-        else:
-            itercols = self.displayed_columns
-        if self.all_rows_displayed:
-            iterrows = range(numrows)
-        else:
-            iterrows = self.displayed_rows
+        itercols = range(numcols) if self.all_columns_displayed else self.displayed_columns
+        iterrows = range(numrows) if self.all_rows_displayed else self.displayed_rows
         if is_iterable(self._row_index):
             for datarn in iterrows:
                 w_, h = self.RI.get_cell_dimensions(datarn)
@@ -4395,10 +4323,7 @@ class MainTable(tk.Canvas):
         added_w_space = 1 if slim else 7
         for datacn in itercols:
             w = min_column_width if width is None else width
-            if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w:
-                w = hw
-            else:
-                w = min_column_width
+            w = hw if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w else min_column_width
             for datarn in iterrows:
                 if txt := self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True):
                     qconf(qtxtm, text=txt, font=qfont)
@@ -4462,7 +4387,7 @@ class MainTable(tk.Canvas):
         else:
             self.set_row_positions(itr=repeat(height, len(self.displayed_rows)))
 
-    def del_col_position(self, idx: int, deselect_all: bool = False):
+    def del_col_position(self, idx: int, deselect_all: bool = False) -> None:
         if deselect_all:
             self.deselect("all", redraw=False)
         if idx == "end" or len(self.col_positions) <= idx + 1:
@@ -4473,7 +4398,7 @@ class MainTable(tk.Canvas):
             del self.col_positions[idx]
             self.col_positions[idx:] = [e - w for e in islice(self.col_positions, idx, len(self.col_positions))]
 
-    def del_row_position(self, idx: int, deselect_all: bool = False):
+    def del_row_position(self, idx: int, deselect_all: bool = False) -> None:
         if deselect_all:
             self.deselect("all", redraw=False)
         if idx == "end" or len(self.row_positions) <= idx + 1:
@@ -4484,7 +4409,7 @@ class MainTable(tk.Canvas):
             del self.row_positions[idx]
             self.row_positions[idx:] = [e - w for e in islice(self.row_positions, idx, len(self.row_positions))]
 
-    def del_col_positions(self, idxs: AnyIter[int] | None = None):
+    def del_col_positions(self, idxs: AnyIter[int] | None = None) -> None:
         if idxs is None:
             del self.col_positions[-1]
         else:
@@ -4492,7 +4417,7 @@ class MainTable(tk.Canvas):
                 idxs = set(idxs)
             self.set_col_positions(itr=(w for i, w in enumerate(self.gen_column_widths()) if i not in idxs))
 
-    def del_row_positions(self, idxs: AnyIter[int] | None = None):
+    def del_row_positions(self, idxs: AnyIter[int] | None = None) -> None:
         if idxs is None:
             del self.row_positions[-1]
         else:
@@ -4715,9 +4640,9 @@ class MainTable(tk.Canvas):
 
     def adjust_options_post_delete_columns(
         self,
-        to_del: None | set = None,
-        to_bis: None | list = None,
-        named_spans: None | set = None,
+        to_del: None | set[int] = None,
+        to_bis: None | list[int] = None,
+        named_spans: None | set[str] = None,
     ) -> list[int]:
         if to_del is None:
             to_del = set()
@@ -4773,7 +4698,7 @@ class MainTable(tk.Canvas):
 
     def del_columns_from_named_spans(
         self,
-        to_del: set,
+        to_del: set[int],
         to_bis: list,
         named_spans: None | set = None,
     ) -> None:
@@ -4789,10 +4714,7 @@ class MainTable(tk.Canvas):
                     if isinstance(span["upto_c"], int) and span["upto_c"] > c:
                         span["upto_c"] -= 1
 
-    def get_spans_to_del_from_cols(
-        self,
-        cols: set,
-    ) -> set:
+    def get_spans_to_del_from_cols(self, cols: set[int]) -> set[str]:
         total = self.total_data_cols()
         return {
             nm
@@ -4803,9 +4725,9 @@ class MainTable(tk.Canvas):
 
     def adjust_options_post_delete_rows(
         self,
-        to_del: None | set = None,
-        to_bis: None | list = None,
-        named_spans: None | set = None,
+        to_del: None | set[int] = None,
+        to_bis: None | list[int] = None,
+        named_spans: None | set[str] = None,
     ) -> list[int]:
         if to_del is None:
             to_del = set()
@@ -4868,7 +4790,7 @@ class MainTable(tk.Canvas):
         self,
         to_del: set,
         to_bis: list,
-        named_spans: None | set = None,
+        named_spans: None | set[str] = None,
     ) -> None:
         if named_spans is None:
             named_spans = self.get_spans_to_del_from_rows(rows=to_del)
@@ -4882,10 +4804,7 @@ class MainTable(tk.Canvas):
                     if isinstance(span["upto_r"], int) and span["upto_r"] > r:
                         span["upto_r"] -= 1
 
-    def get_spans_to_del_from_rows(
-        self,
-        rows: set,
-    ) -> set:
+    def get_spans_to_del_from_rows(self, rows: set[int]) -> set[str]:
         total = self.total_data_rows()
         return {
             nm
@@ -4979,7 +4898,7 @@ class MainTable(tk.Canvas):
             try_binding(self.extra_end_insert_cols_rc_func, event_data, "end_add_columns")
         return event_data
 
-    def rc_add_columns(self, event: object = None) -> None:
+    def rc_add_columns(self, event: Any = None) -> None:
         rowlen = self.equalize_data_row_lengths()
         selcols = sorted(self.get_selected_cols())
         if (
@@ -5028,8 +4947,8 @@ class MainTable(tk.Canvas):
 
     def add_rows(
         self,
-        rows: dict[int, list[object]],
-        index: dict[int, object],
+        rows: dict[int, list[Any]],
+        index: dict[int, Any],
         row_heights: dict[int, float | int],
         event_data: EventDataDict,
         create_ops: bool = True,
@@ -5113,7 +5032,7 @@ class MainTable(tk.Canvas):
             try_binding(self.extra_end_insert_rows_rc_func, event_data, "end_add_rows")
         return event_data
 
-    def rc_add_rows(self, event: object = None) -> None:
+    def rc_add_rows(self, event: Any = None) -> None:
         total_data_rows = self.total_data_rows()
         selrows = sorted(self.get_selected_rows())
         if (
@@ -5165,7 +5084,7 @@ class MainTable(tk.Canvas):
         data_ins_col: int,
         displayed_ins_col: int,
         numcols: int,
-        columns: list[list[object]] | None = None,
+        columns: list[list[Any]] | None = None,
         widths: list[int] | tuple[int] | None = None,
         headers: bool = False,
     ) -> tuple[dict, dict, dict]:
@@ -5190,12 +5109,9 @@ class MainTable(tk.Canvas):
                 for datacn in reversed(range(data_ins_col, data_ins_col + numcols))
             }
         else:
-            if headers:
-                start = 1
-            else:
-                start = 0
+            start = 1 if headers else 0
             columns = {
-                datacn: {datarn: v for datarn, v in enumerate(islice(column, start, None))}
+                datacn: dict(enumerate(islice(column, start, None)))
                 for datacn, column in zip(reversed(range(data_ins_col, data_ins_col + numcols)), reversed(columns))
             }
         if widths is None:
@@ -5204,10 +5120,7 @@ class MainTable(tk.Canvas):
                 for c in reversed(range(displayed_ins_col, displayed_ins_col + numcols))
             }
         else:
-            widths = {
-                c: width
-                for c, width in zip(reversed(range(displayed_ins_col, displayed_ins_col + numcols)), reversed(widths))
-            }
+            widths = dict(zip(reversed(range(displayed_ins_col, displayed_ins_col + numcols)), reversed(widths)))
         return columns, header_data, widths
 
     def get_args_for_add_rows(
@@ -5215,7 +5128,7 @@ class MainTable(tk.Canvas):
         data_ins_row: int,
         displayed_ins_row: int,
         numrows: int,
-        rows: list[list[object]] | None = None,
+        rows: list[list[Any]] | None = None,
         heights: list[int] | tuple[int] | None = None,
         row_index: bool = False,
         total_data_cols: int | None = None,
@@ -5245,10 +5158,7 @@ class MainTable(tk.Canvas):
                 for datarn in reversed(range(data_ins_row, data_ins_row + numrows))
             }
         else:
-            if row_index:
-                start = 1
-            else:
-                start = 0
+            start = 1 if row_index else 0
             rows = {
                 datarn: v[start:] if start and v else v
                 for datarn, v in zip(reversed(range(data_ins_row, data_ins_row + numrows)), reversed(rows))
@@ -5257,10 +5167,7 @@ class MainTable(tk.Canvas):
             default_row_height = self.get_default_row_height()
             heights = {r: default_row_height for r in reversed(range(displayed_ins_row, displayed_ins_row + numrows))}
         else:
-            heights = {
-                r: height
-                for r, height in zip(reversed(range(displayed_ins_row, displayed_ins_row + numrows)), reversed(heights))
-            }
+            heights = dict(zip(reversed(range(displayed_ins_row, displayed_ins_row + numrows)), reversed(heights)))
         return rows, index_data, heights
 
     def copy_options(self) -> dict:
@@ -5345,16 +5252,15 @@ class MainTable(tk.Canvas):
 
     def delete_columns(
         self,
-        event: object = None,
+        event: Any = None,
         columns: list[int] | None = None,
         data_indexes: bool = False,
         undo: bool = True,
         emit_event: bool = True,
     ) -> EventDataDict:
         event_data = self.new_event_dict("delete_columns", state=True)
-        if not columns:
-            if not (columns := sorted(self.get_selected_cols())):
-                return event_data
+        if not columns and not (columns := sorted(self.get_selected_cols())):
+            return event_data
         if not try_binding(self.extra_begin_del_cols_rc_func, event_data, "begin_delete_columns"):
             return
         if self.all_columns_displayed:
@@ -5432,16 +5338,15 @@ class MainTable(tk.Canvas):
 
     def delete_rows(
         self,
-        event: object = None,
+        event: Any = None,
         rows: list[int] | None = None,
         data_indexes: bool = False,
         undo: bool = True,
         emit_event: bool = True,
-    ) -> EventDataDict:
+    ) -> None | EventDataDict:
         event_data = self.new_event_dict("delete_rows", state=True)
-        if not rows:
-            if not (rows := sorted(self.get_selected_rows())):
-                return
+        if not rows and not (rows := sorted(self.get_selected_rows())):
+            return
         if not try_binding(self.extra_begin_del_rows_rc_func, event_data, "begin_delete_rows"):
             return
         if self.all_rows_displayed:
@@ -5571,12 +5476,12 @@ class MainTable(tk.Canvas):
 
     def headers(
         self,
-        newheaders: object = None,
+        newheaders: Any = None,
         index: int | None = None,
         reset_col_positions: bool = False,
         show_headers_if_not_sheet: bool = True,
         redraw: bool = False,
-    ) -> object:
+    ) -> Any:
         if newheaders is not None:
             if isinstance(newheaders, (list, tuple)):
                 self._headers = list(newheaders) if isinstance(newheaders, tuple) else newheaders
@@ -5589,13 +5494,13 @@ class MainTable(tk.Canvas):
             elif not isinstance(newheaders, (list, tuple, int)) and index is None:
                 try:
                     self._headers = list(newheaders)
-                except Exception:
+                except ValueError as error:
                     raise ValueError(
                         """
                         New header must be iterable or int \
                         (use int to use a row as the header
                         """
-                    )
+                    ) from error
             if reset_col_positions:
                 self.reset_col_positions()
             elif (
@@ -5618,12 +5523,12 @@ class MainTable(tk.Canvas):
 
     def row_index(
         self,
-        newindex: object = None,
+        newindex: Any = None,
         index: int | None = None,
         reset_row_positions: bool = False,
         show_index_if_not_sheet: bool = True,
         redraw: bool = False,
-    ) -> object:
+    ) -> Any:
         if newindex is not None:
             if not self._row_index and not isinstance(self._row_index, int):
                 self.RI.set_width(self.PAR.ops.default_row_index_width, set_TL=True)
@@ -5638,13 +5543,13 @@ class MainTable(tk.Canvas):
             elif not isinstance(newindex, (list, tuple, int)) and index is None:
                 try:
                     self._row_index = list(newindex)
-                except Exception:
+                except ValueError as error:
                     raise ValueError(
                         """
                         New index must be iterable or int \
                         (use int to use a column as the index
                         """
-                    )
+                    ) from error
             if reset_row_positions:
                 self.reset_row_positions()
             elif (
@@ -6038,7 +5943,7 @@ class MainTable(tk.Canvas):
                         widths[i] = min_column_width
                 if diffs and len(diffs) < len(widths):
                     change = sum(diffs.values()) / (len(widths) - len(diffs))
-                    for i, w in enumerate(widths):
+                    for i in range(len(widths)):
                         if i not in diffs:
                             widths[i] -= change
                 self.col_positions = list(accumulate(chain([0], widths)))
@@ -6065,7 +5970,7 @@ class MainTable(tk.Canvas):
                         heights[i] = min_row_height
                 if diffs and len(diffs) < len(heights):
                     change = sum(diffs.values()) / (len(heights) - len(diffs))
-                    for i, h in enumerate(heights):
+                    for i in range(len(heights)):
                         if i not in diffs:
                             heights[i] -= change
                 self.row_positions = list(accumulate(chain([0], heights)))
@@ -6252,10 +6157,7 @@ class MainTable(tk.Canvas):
                 if self.PAR.ops.horizontal_grid_to_end_of_window:
                     x_grid_stop = scrollpos_right + can_width
                 else:
-                    if last_col_line_pos > scrollpos_right:
-                        x_grid_stop = x_stop + 1
-                    else:
-                        x_grid_stop = x_stop - 1
+                    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(
@@ -6278,10 +6180,7 @@ class MainTable(tk.Canvas):
                 if self.PAR.ops.vertical_grid_to_end_of_window:
                     y_grid_stop = scrollpos_bot + can_height
                 else:
-                    if last_row_line_pos > scrollpos_bot:
-                        y_grid_stop = y_stop + 1
-                    else:
-                        y_grid_stop = y_stop - 1
+                    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(
@@ -6305,10 +6204,7 @@ class MainTable(tk.Canvas):
             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)
-            if self.selected:
-                current_loc = (self.selected.row, self.selected.column)
-            else:
-                current_loc = tuple()
+            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,
@@ -6318,10 +6214,10 @@ class MainTable(tk.Canvas):
                 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 = tuple()
+                    dont_blend = ()
             else:
                 alternate_color = None
-                dont_blend = tuple()
+                dont_blend = ()
             if not self.PAR.ops.show_selected_cells_border:
                 override = (
                     color_tup(self.PAR.ops.table_selected_cells_fg),
@@ -6329,7 +6225,7 @@ class MainTable(tk.Canvas):
                     color_tup(self.PAR.ops.table_selected_rows_fg),
                 )
             else:
-                override = tuple()
+                override = ()
             allow_overflow = self.PAR.ops.allow_cell_overflow
             wrap = self.PAR.ops.table_wrap
             cells = self._redraw_precache_cells(
@@ -6526,7 +6422,7 @@ class MainTable(tk.Canvas):
                         self.itemconfig(iid, state="hidden")
                         dct[iid] = False
             if self.PAR.ops.show_selected_cells_border:
-                for iid, box in self.selection_boxes.items():
+                for _, box in self.selection_boxes.items():
                     if box.bd_iid:
                         self.tag_raise(box.bd_iid)
                 if self.selected:
@@ -6588,7 +6484,7 @@ class MainTable(tk.Canvas):
     def reselect_from_get_boxes(
         self,
         boxes: dict,
-        selected: tuple = tuple(),
+        selected: tuple = (),
     ) -> None:
         for (r1, c1, r2, c2), v in boxes.items():
             if r2 < len(self.row_positions) and c2 < len(self.col_positions):
@@ -6622,14 +6518,15 @@ class MainTable(tk.Canvas):
 
         # set current to any existing selection box with coordinates: box
         if isinstance(box, tuple):
-            for item, selection_box in self.get_selection_items(reverse=True):
-                if box == selection_box.coords:
-                    if box_created(box[0] if r is None else r, box[1] if c is None else c, selection_box):
-                        return
+            for _, selection_box in self.get_selection_items(reverse=True):
+                if box == selection_box.coords and box_created(
+                    box[0] if r is None else r, box[1] if c is None else c, selection_box
+                ):
+                    return
 
         # set current to a coordinate, find the top most box there
         if isinstance(r, int) and isinstance(c, int):
-            for item, selection_box in self.get_selection_items(reverse=True):
+            for _, selection_box in self.get_selection_items(reverse=True):
                 if box_created(r, c, selection_box):
                     return
 
@@ -6648,15 +6545,15 @@ class MainTable(tk.Canvas):
     def coords_and_type(self, item: int) -> tuple:
         if item in self.selection_boxes:
             return Box_t(*(self.selection_boxes[item].coords + (self.selection_boxes[item].type_,)))
-        return tuple()
+        return ()
 
     def get_selected_box_bg_fg(self, type_: str) -> tuple:
-        if type_ == "cells":
-            return self.PAR.ops.table_selected_cells_bg, self.PAR.ops.table_selected_box_cells_fg
-        elif type_ == "rows":
-            return self.PAR.ops.table_selected_rows_bg, self.PAR.ops.table_selected_box_rows_fg
-        elif type_ == "columns":
-            return self.PAR.ops.table_selected_columns_bg, self.PAR.ops.table_selected_box_columns_fg
+        type_map = {
+            "cells": (self.PAR.ops.table_selected_cells_bg, self.PAR.ops.table_selected_box_cells_fg),
+            "rows": (self.PAR.ops.table_selected_rows_bg, self.PAR.ops.table_selected_box_rows_fg),
+            "columns": (self.PAR.ops.table_selected_columns_bg, self.PAR.ops.table_selected_box_columns_fg),
+        }
+        return type_map[type_]
 
     def create_currently_selected_box(
         self,
@@ -6713,10 +6610,7 @@ class MainTable(tk.Canvas):
         width: int,
         iid: None | int = None,
     ) -> int:
-        if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1:
-            radius = 0
-        else:
-            radius = 5
+        radius = 0 if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1 else 5
         coords = rounded_box_coords(
             x1,
             y1,
@@ -6773,7 +6667,7 @@ class MainTable(tk.Canvas):
     def hide_selected(self) -> None:
         if self.selected:
             self.hide_box(self.selected.iid)
-            self.selected = tuple()
+            self.selected = ()
 
     def create_selection_box(
         self,
@@ -7203,7 +7097,7 @@ class MainTable(tk.Canvas):
 
     def open_cell(
         self,
-        event: object = None,
+        event: Any = None,
         ignore_existing_editor: bool = False,
     ) -> None:
         if not self.anything_selected() or (not ignore_existing_editor and self.text_editor.open):
@@ -7238,7 +7132,7 @@ class MainTable(tk.Canvas):
     # displayed indexes
     def open_text_editor(
         self,
-        event: object = None,
+        event: Any = None,
         r: int = 0,
         c: int = 0,
         text: str | None = None,
@@ -7283,7 +7177,7 @@ class MainTable(tk.Canvas):
             self.text_editor.window.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
-        if not self.see(r=r, c=c, check_cell_visibility=True):
+        if not self.see(r, c):
             self.main_table_redraw_grid_and_text(True, True)
         x = self.col_positions[c]
         y = self.row_positions[r]
@@ -7337,7 +7231,7 @@ class MainTable(tk.Canvas):
     # displayed indexes
     def text_editor_newline_binding(
         self,
-        event: object = None,
+        event: Any = None,
         check_lines: bool = True,
     ) -> None:
         r, c = self.text_editor.coords
@@ -7517,13 +7411,7 @@ class MainTable(tk.Canvas):
                     new_r, new_c = None, None
                 if isinstance(new_r, int):
                     self.set_currently_selected(new_r, new_c, item=self.selected.fill_iid)
-                    self.see(
-                        new_r,
-                        new_c,
-                        keep_xscroll=False,
-                        bottom_right_corner=True,
-                        check_cell_visibility=True,
-                    )
+                    self.see(new_r, new_c)
         self.recreate_all_selection_boxes()
         self.hide_text_editor_and_dropdown()
         if event.keysym != "FocusOut":
@@ -7536,19 +7424,13 @@ class MainTable(tk.Canvas):
             r,
             c + 1 if c < len(self.col_positions) - 2 else c,
             bottom_right_corner=True,
-            check_cell_visibility=True,
         )
 
     def select_down(self, r: int, c: int) -> None:
         self.select_cell(r + 1 if r < len(self.row_positions) - 2 else r, c)
-        self.see(
-            r + 1 if r < len(self.row_positions) - 2 else r,
-            c,
-            bottom_right_corner=True,
-            check_cell_visibility=True,
-        )
+        self.see(r + 1 if r < len(self.row_positions) - 2 else r, c)
 
-    def tab_key(self, event: object = None) -> str:
+    def tab_key(self, event: Any = None) -> str:
         if not self.selected:
             return
         r, c = self.selected.row, self.selected.column
@@ -7562,13 +7444,7 @@ class MainTable(tk.Canvas):
         else:
             new_r, new_c = cell_right_within_box(r, c, r1, c1, r2, c2, numrows, numcols)
             self.set_currently_selected(new_r, new_c, item=self.selected.fill_iid)
-        self.see(
-            new_r,
-            new_c,
-            keep_xscroll=False,
-            bottom_right_corner=True,
-            check_cell_visibility=True,
-        )
+        self.see(new_r, new_c, bottom_right_corner=True)
         if not self.PAR.ops.show_selected_cells_border:
             self.refresh()
         return "break"
@@ -7652,7 +7528,7 @@ class MainTable(tk.Canvas):
         self,
         r: int,
         c: int,
-        event: object = None,
+        event: Any = None,
     ) -> None:
         self.hide_text_editor()
         datarn = self.datarn(r)
@@ -7733,7 +7609,7 @@ class MainTable(tk.Canvas):
         self,
         r: int | None = None,
         c: int | None = None,
-        selection: object = None,
+        selection: Any = None,
         redraw: bool = True,
     ) -> None:
         if r is not None and c is not None and selection is not None:
@@ -7878,8 +7754,8 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        value: object,
-        kwargs: dict = {},
+        value: Any,
+        kwargs: dict | None = None,
         expand_sheet: bool = True,
     ) -> None:
         if expand_sheet:
@@ -7904,7 +7780,7 @@ class MainTable(tk.Canvas):
                 else:
                     self.data[datarn][datacn] = value
 
-    def get_value_for_empty_cell(self, datarn: int, datacn: int, r_ops: bool = True, c_ops: bool = True) -> object:
+    def get_value_for_empty_cell(self, datarn: int, datacn: int, r_ops: bool = True, c_ops: bool = True) -> Any:
         kwargs = self.get_cell_kwargs(
             datarn,
             datacn,
@@ -7927,7 +7803,7 @@ class MainTable(tk.Canvas):
         start: int = 0,
         r_ops: bool = True,
         c_ops: bool = True,
-    ) -> list[object]:
+    ) -> 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 fix_row_len(self, datarn: int, datacn: int) -> None:
@@ -7987,10 +7863,7 @@ class MainTable(tk.Canvas):
                 self.set_cell_data(*key, get_val(*key), expand_sheet=False)
 
     def delete_row_format(self, datarn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
-        if isinstance(datarn, str) and datarn.lower() == "all":
-            itr = gen_formatted(self.row_options)
-        else:
-            itr = (datarn,)
+        itr = gen_formatted(self.row_options) if isinstance(datarn, str) and datarn.lower() == "all" else (datarn,)
         get_val = self.get_value_for_empty_cell
         for datarn in itr:
             try:
@@ -8002,10 +7875,7 @@ class MainTable(tk.Canvas):
                     self.set_cell_data(datarn, datacn, get_val(datarn, datacn), expand_sheet=False)
 
     def delete_column_format(self, datacn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
-        if isinstance(datacn, str) and datacn.lower() == "all":
-            itr = gen_formatted(self.col_options)
-        else:
-            itr = (datacn,)
+        itr = gen_formatted(self.col_options) if isinstance(datacn, str) and datacn.lower() == "all" else (datacn,)
         get_val = self.get_value_for_empty_cell
         for datacn in itr:
             try:
@@ -8055,7 +7925,7 @@ class MainTable(tk.Canvas):
         none_to_empty_str: bool = False,
         fmt_kw: dict | None = None,
         **kwargs,
-    ) -> object:
+    ) -> Any:
         if get_displayed:
             return self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
         value = (
@@ -8074,7 +7944,7 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        value: object,
+        value: Any,
         check_readonly: bool = True,
         ignore_empty: bool = False,
     ) -> bool:
@@ -8083,9 +7953,7 @@ class MainTable(tk.Canvas):
             return False
         elif "format" in kwargs:
             return True
-        elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty):
-            return False
-        elif (
+        elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty) or (
             (dropdown := kwargs.get("dropdown", {})) and dropdown["validate_input"] and value not in dropdown["values"]
         ):
             return False
@@ -8094,7 +7962,7 @@ class MainTable(tk.Canvas):
         else:
             return True
 
-    def cell_equal_to(self, datarn: int, datacn: int, value: object, ignore_empty: bool = False, **kwargs) -> bool:
+    def cell_equal_to(self, datarn: int, datacn: int, value: Any, ignore_empty: bool = False, **kwargs) -> bool:
         v = self.get_cell_data(datarn, datacn)
         kwargs = self.get_cell_kwargs(datarn, datacn, key="format")
         if kwargs and kwargs["formatter"] is None:
@@ -8132,16 +8000,30 @@ class MainTable(tk.Canvas):
         row: bool = True,
         column: bool = True,
     ) -> dict:
-        if cell and (datarn, datacn) in self.cell_options:
-            return (
-                self.cell_options[(datarn, datacn)] if key is None else self.cell_options[(datarn, datacn)].get(key, {})
-            )
-        elif row and datarn in self.row_options:
-            return self.row_options[datarn] if key is None else self.row_options[datarn].get(key, {})
-        elif column and datacn in self.col_options:
-            return self.col_options[datacn] if key is None else self.col_options[datacn].get(key, {})
+        if key is None:
+            if cell and (datarn, datacn) in self.cell_options:
+                return self.cell_options[(datarn, datacn)]
+
+            elif row and datarn in self.row_options:
+                return self.row_options[datarn]
+
+            elif column and datacn in self.col_options:
+                return self.col_options[datacn]
+
+            else:
+                return {}
         else:
-            return {}
+            if cell and (datarn, datacn) in self.cell_options and key in self.cell_options[(datarn, datacn)]:
+                return self.cell_options[(datarn, datacn)][key]
+
+            elif row and datarn in self.row_options and key in self.row_options[datarn]:
+                return self.row_options[datarn][key]
+
+            elif column and datacn in self.col_options and key in self.col_options[datacn]:
+                return self.col_options[datacn][key]
+
+            else:
+                return {}
 
     def datacn(self, c: int) -> int:
         return c if self.all_columns_displayed else self.displayed_columns[c]