tksheet 7.4.5__py3-none-any.whl → 7.4.7__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):
@@ -359,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
@@ -555,16 +555,31 @@ class MainTable(tk.Canvas):
         return coords
 
     def find_match(self, find: str, r: int, c: int) -> bool:
-        return (
-            not find
-            and (not self.get_valid_cell_data_as_str(r, c, True).lower() or not f"{self.get_cell_data(r, c)}".lower())
-        ) or (
-            find
-            and (
-                find in self.get_valid_cell_data_as_str(r, c, True).lower()
-                or find in f"{self.get_cell_data(r, c)}".lower()
-            )
-        )
+        try:
+            value = self.data[r][c]
+        except Exception:
+            value = ""
+        kwargs = self.get_cell_kwargs(r, c, key=None)
+        if kwargs:
+            if "dropdown" in kwargs:
+                kwargs = kwargs["dropdown"]
+                if kwargs["text"] is not None and find in str(kwargs["text"]).lower():
+                    return True
+            elif "checkbox" in kwargs:
+                kwargs = kwargs["checkbox"]
+                if find in str(kwargs["text"]).lower() or (not find and find in "False"):
+                    return True
+            elif "format" in kwargs:
+                if kwargs["formatter"] is None:
+                    if find in data_to_str(value, **kwargs).lower():
+                        return True
+                # assumed given formatter class has __str__() or value attribute
+                elif find in str(value).lower() or find in str(value.value).lower():
+                    return True
+        if value is None:
+            return find == ""
+        else:
+            return find in str(value).lower()
 
     def find_within_match(self, find: str, r: int, c: int) -> bool:
         if not self.all_rows_displayed:
@@ -669,9 +684,9 @@ class MainTable(tk.Canvas):
                     reverse=reverse,
                 )
                 if (
-                    (self.all_rows_displayed or bisect_in(self.displayed_rows, r))
+                    self.find_match(find, r, c)
+                    and (self.all_rows_displayed or bisect_in(self.displayed_rows, r))
                     and (self.all_columns_displayed or bisect_in(self.displayed_columns, c))
-                    and self.find_match(find, r, c)
                 )
             ),
             None,
@@ -974,7 +989,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:
@@ -1217,7 +1232,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")
@@ -1251,7 +1266,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)
@@ -1780,7 +1795,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"]
@@ -1794,7 +1809,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"]
@@ -2039,8 +2054,10 @@ class MainTable(tk.Canvas):
         redraw: bool = True,
         r_pc: float = 0.0,
         c_pc: float = 0.0,
+        index: bool = True,
     ) -> bool:
-        need_redraw = False
+        need_y_redraw = False
+        need_x_redraw = False
         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"]
@@ -2067,7 +2084,7 @@ class MainTable(tk.Canvas):
                         y - 1 if y > 1 else y,
                     ]
                     self.set_yviews(*args, redraw=False)
-                    need_redraw = True
+                    need_y_redraw = True
             else:
                 if r is not None and not keep_yscroll:
                     y = max(
@@ -2079,7 +2096,7 @@ class MainTable(tk.Canvas):
                         y - 1 if y > 1 else y,
                     ]
                     self.set_yviews(*args, redraw=False)
-                    need_redraw = True
+                    need_y_redraw = True
         # 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:
@@ -2102,7 +2119,7 @@ class MainTable(tk.Canvas):
                         x - 1 if x > 1 else x,
                     ]
                     self.set_xviews(*args, redraw=False)
-                    need_redraw = True
+                    need_x_redraw = True
             else:
                 if c is not None and not keep_xscroll:
                     x = max(
@@ -2114,8 +2131,22 @@ class MainTable(tk.Canvas):
                         x - 1 if x > 1 else x,
                     ]
                     self.set_xviews(*args, redraw=False)
-                    need_redraw = True
-        if redraw and need_redraw:
+                    need_x_redraw = True
+            # the index may have resized after scrolling making x calculation wrong
+            if need_x_redraw and index and self.PAR.ops.auto_resize_row_index and self.show_index:
+                self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=False, redraw_table=False)
+                self.see(
+                    r=r,
+                    c=c,
+                    keep_yscroll=keep_yscroll,
+                    keep_xscroll=keep_xscroll,
+                    check_cell_visibility=check_cell_visibility,
+                    redraw=redraw,
+                    r_pc=r_pc,
+                    c_pc=c_pc,
+                    index=False,
+                )
+        if redraw and (need_y_redraw or need_x_redraw):
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             return True
         return False
@@ -2175,7 +2206,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
@@ -2186,7 +2217,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
@@ -2197,12 +2228,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)
@@ -2462,7 +2493,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)
@@ -2487,7 +2518,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
@@ -2517,7 +2548,7 @@ 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
         r = self.selected.row
@@ -2534,7 +2565,7 @@ class MainTable(tk.Canvas):
             ):
                 self.select_cell(r - 1, c, redraw=True)
 
-    def arrowkey_LEFT(self, event: object = None) -> None:
+    def arrowkey_LEFT(self, event: Any = None) -> Literal["break"]:
         if not self.selected:
             return
         r = self.selected.row
@@ -2543,13 +2574,16 @@ class MainTable(tk.Canvas):
             self.see(r, c)
         else:
             self.see(r, c - 1, redraw=False)
-            if self.selected.type_ == "columns":
+            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"):
+            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)
+        return "break"
 
-    def arrowkey_DOWN(self, event: object = None) -> None:
+    def arrowkey_DOWN(self, event: Any = None) -> None:
         if not self.selected:
             return
         r = self.selected.row
@@ -2564,13 +2598,15 @@ class MainTable(tk.Canvas):
                 bottom_right_corner=brc,
                 redraw=False,
             )
-            if self.selected.type_ == "rows":
+            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"):
+            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
         r = self.selected.row
@@ -2585,10 +2621,12 @@ class MainTable(tk.Canvas):
                 bottom_right_corner=brc,
                 redraw=False,
             )
-            if self.selected.type_ == "columns":
+            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"):
+            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(
@@ -2623,7 +2661,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
@@ -2640,7 +2678,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
@@ -2655,7 +2693,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
@@ -2672,7 +2710,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
@@ -3011,7 +3049,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)):
@@ -3025,7 +3063,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)):
@@ -3039,7 +3077,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 (
@@ -3184,7 +3222,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 (
@@ -3323,14 +3361,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
@@ -3363,7 +3401,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 (
@@ -3385,7 +3423,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)
@@ -3398,7 +3438,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():
@@ -3406,7 +3446,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
@@ -3424,7 +3464,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
@@ -3452,7 +3492,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():
@@ -3479,7 +3519,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:
@@ -3489,7 +3529,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):
@@ -3501,7 +3547,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 (
@@ -3549,7 +3595,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)
@@ -3592,7 +3638,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
@@ -3642,7 +3688,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 (
@@ -3666,7 +3712,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:
@@ -3678,7 +3724,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:
@@ -3710,7 +3756,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()
@@ -3749,7 +3795,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"):
@@ -3762,7 +3808,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"):
@@ -3775,7 +3821,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)
@@ -3783,7 +3829,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)
@@ -3793,7 +3839,7 @@ class MainTable(tk.Canvas):
 
     def set_xviews(
         self,
-        *args,
+        *args: Any,
         move_synced: bool = True,
         redraw: bool = True,
     ) -> None:
@@ -3813,7 +3859,7 @@ class MainTable(tk.Canvas):
 
     def set_yviews(
         self,
-        *args,
+        *args: Any,
         move_synced: bool = True,
         redraw: bool = True,
     ) -> None:
@@ -3835,7 +3881,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")
@@ -3848,7 +3894,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")
@@ -3861,13 +3907,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]),
@@ -3875,7 +3921,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(
@@ -3885,7 +3931,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
@@ -4040,7 +4092,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] = {}
@@ -4080,7 +4132,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] = {}
@@ -4094,11 +4146,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(
@@ -4109,7 +4161,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
@@ -4129,7 +4181,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)
@@ -4143,7 +4195,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
@@ -4214,6 +4268,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)
@@ -4364,7 +4419,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:
@@ -4375,7 +4430,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:
@@ -4386,7 +4441,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:
@@ -4394,7 +4449,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:
@@ -4617,9 +4672,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()
@@ -4675,7 +4730,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:
@@ -4691,10 +4746,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
@@ -4705,9 +4757,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()
@@ -4770,7 +4822,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)
@@ -4784,10 +4836,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
@@ -4881,7 +4930,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 (
@@ -4930,8 +4979,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,
@@ -5015,7 +5064,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 (
@@ -5067,7 +5116,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]:
@@ -5111,7 +5160,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,
@@ -5235,7 +5284,7 @@ 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,
@@ -5321,7 +5370,7 @@ 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,
@@ -5459,12 +5508,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
@@ -5506,12 +5555,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)
@@ -5555,8 +5604,7 @@ class MainTable(tk.Canvas):
 
     def total_data_cols(self, include_header: bool = True) -> int:
         h_total = len(self._headers) if include_header and isinstance(self._headers, (list, tuple)) else 0
-        # map() for some reason is 15% faster than max(key=len) using python 3.11 windows 11
-        d_total = max(map(len, self.data), default=0)
+        d_total = max(map(len, self.data), default=0)  # max(map(len, )) is faster
         return max(h_total, d_total)
 
     def total_data_rows(self, include_index: bool = True) -> int:
@@ -6098,7 +6146,7 @@ class MainTable(tk.Canvas):
 
         # check if auto resizing row index
         changed_w = False
-        if self.PAR.ops.auto_resize_row_index and redraw_row_index and self.show_index:
+        if self.PAR.ops.auto_resize_row_index and self.show_index:
             changed_w = self.RI.auto_set_index_width(
                 end_row=grid_end_row,
                 only_rows=map(self.datarn, range(text_start_row, text_end_row)),
@@ -7080,7 +7128,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):
@@ -7115,7 +7163,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,
@@ -7214,7 +7262,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
@@ -7413,7 +7461,7 @@ class MainTable(tk.Canvas):
         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)
 
-    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
@@ -7511,7 +7559,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)
@@ -7592,7 +7640,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:
@@ -7636,12 +7684,12 @@ class MainTable(tk.Canvas):
         self.focus_set()
         return closed_dd_coords
 
-    def mouseclick_outside_editor_or_dropdown_all_canvases(self):
+    def mouseclick_outside_editor_or_dropdown_all_canvases(self) -> tuple[int, int] | None:
         self.CH.mouseclick_outside_editor_or_dropdown()
         self.RI.mouseclick_outside_editor_or_dropdown()
         return self.mouseclick_outside_editor_or_dropdown()
 
-    def hide_dropdown_editor_all_canvases(self):
+    def hide_dropdown_editor_all_canvases(self) -> None:
         self.hide_text_editor_and_dropdown(redraw=False)
         self.RI.hide_text_editor_and_dropdown(redraw=False)
         self.CH.hide_text_editor_and_dropdown(redraw=False)
@@ -7737,7 +7785,7 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        value: object,
+        value: Any,
         kwargs: dict | None = None,
         expand_sheet: bool = True,
     ) -> None:
@@ -7763,7 +7811,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,
@@ -7786,7 +7834,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:
@@ -7908,7 +7956,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 = (
@@ -7927,7 +7975,7 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        value: object,
+        value: Any,
         check_readonly: bool = True,
         ignore_empty: bool = False,
     ) -> bool:
@@ -7945,7 +7993,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:
@@ -7983,16 +8031,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]