tksheet 7.3.1__py3-none-any.whl → 7.3.2__py3-none-any.whl

tksheet/main_table.py

@@ -39,6 +39,22 @@ from typing import Literal
 from .colors import (
     color_map,
 )
+from .constants import (
+    USER_OS,
+    bind_add_columns,
+    bind_add_rows,
+    bind_del_columns,
+    bind_del_rows,
+    ctrl_key,
+    rc_binding,
+    text_editor_close_bindings,
+    text_editor_newline_bindings,
+    text_editor_to_unbind,
+    val_modifying_options,
+)
+from .find_window import (
+    FindWindow,
+)
 from .formatters import (
     data_to_str,
     format_data,
@@ -50,6 +66,7 @@ from .formatters import (
 from .functions import (
     add_to_displayed,
     b_index,
+    bisect_in,
     box_is_single_cell,
     cell_right_within_box,
     color_tup,
@@ -58,6 +75,8 @@ from .functions import (
     diff_list,
     down_cell_within_box,
     event_dict,
+    event_has_char_key,
+    event_opens_dropdown_or_checkbox,
     float_to_int,
     gen_formatted,
     get_data_from_clipboard,
@@ -86,6 +105,7 @@ from .other_classes import (
     Box_t,
     DotDict,
     DropdownStorage,
+    EditorStorageBase,
     EventDataDict,
     FontTuple,
     Highlight,
@@ -101,20 +121,6 @@ from .text_editor import (
 from .types import (
     AnyIter,
 )
-from .vars import (
-    USER_OS,
-    bind_add_columns,
-    bind_add_rows,
-    bind_del_columns,
-    bind_del_rows,
-    ctrl_key,
-    rc_binding,
-    symbols_set,
-    text_editor_close_bindings,
-    text_editor_newline_bindings,
-    text_editor_to_unbind,
-    val_modifying_options,
-)
 
 
 class MainTable(tk.Canvas):
@@ -140,6 +146,7 @@ class MainTable(tk.Canvas):
         self.synced_scrolls = set()
         self.dropdown = DropdownStorage()
         self.text_editor = TextEditorStorage()
+        self.find_window = EditorStorageBase()
         self.event_linker = {
             "<<Copy>>": self.ctrl_c,
             "<<Cut>>": self.ctrl_x,
@@ -248,6 +255,7 @@ class MainTable(tk.Canvas):
         self.drag_selection_enabled = False
         self.select_all_enabled = False
         self.undo_enabled = False
+        self.find_enabled = False
         self.cut_enabled = False
         self.copy_enabled = False
         self.paste_enabled = False
@@ -476,6 +484,250 @@ class MainTable(tk.Canvas):
         if delete_on_timer:
             self.after(1500, self.delete_ctrl_outlines)
 
+    def escape(self, event: tk.Misc | None) -> None:
+        if self.find_window.open:
+            self.close_find_window()
+        else:
+            self.deselect()
+
+    def get_find_window_dimensions_coords(self, w_width: int) -> tuple[int, int, int, int]:
+        width = min(self.get_txt_w("X" * 23), w_width - 7)
+        # w, h, x, y
+        return width, self.min_row_height, self.canvasx(max(0, w_width - width - 7)), self.canvasy(7)
+
+    def open_find_window(
+        self,
+        event: tk.Misc | None = None,
+        focus: bool = True,
+    ) -> Literal["break"]:
+        if self.find_window.open:
+            self.close_find_window()
+            return "break"
+        width, height, x, y = self.get_find_window_dimensions_coords(w_width=self.winfo_width())
+        if not self.find_window.window:
+            self.find_window.window = FindWindow(
+                self,
+                find_prev_func=self.find_previous,
+                find_next_func=self.find_next,
+                close_func=self.close_find_window,
+            )
+            self.find_window.canvas_id = self.create_window((x, y), window=self.find_window.window, anchor="nw")
+            for b in chain(self.PAR.ops.escape_bindings, self.PAR.ops.find_bindings):
+                self.find_window.tktext.bind(b, self.close_find_window)
+            for b in chain(self.PAR.ops.find_next_bindings, ("<Return>", "<KP_Enter>")):
+                self.find_window.tktext.bind(b, self.find_next)
+            for b in self.PAR.ops.find_previous_bindings:
+                self.find_window.tktext.bind(b, self.find_previous)
+        else:
+            self.coords(self.find_window.canvas_id, x, y)
+            if not self.find_window.open:
+                self.itemconfig(self.find_window.canvas_id, state="normal")
+        self.find_window.open = True
+        self.find_window.window.reset(
+            **{
+                "menu_kwargs": DotDict(
+                    {
+                        "font": self.PAR.ops.table_font,
+                        "foreground": self.PAR.ops.popup_menu_fg,
+                        "background": self.PAR.ops.popup_menu_bg,
+                        "activebackground": self.PAR.ops.popup_menu_highlight_bg,
+                        "activeforeground": self.PAR.ops.popup_menu_highlight_fg,
+                    }
+                ),
+                "sheet_ops": self.PAR.ops,
+                "border_color": self.PAR.ops.table_selected_box_cells_fg,
+                "bg": self.PAR.ops.table_editor_bg,
+                "fg": self.PAR.ops.table_editor_fg,
+                "select_bg": self.PAR.ops.table_editor_select_bg,
+                "select_fg": self.PAR.ops.table_editor_select_fg,
+            }
+        )
+        self.itemconfig(self.find_window.canvas_id, width=width, height=height)
+        if focus:
+            self.find_window.tktext.focus_set()
+        return "break"
+
+    def find_see_and_set(self, coords: tuple[int, int] | None, just_see: bool = False) -> tuple[int, int]:
+        if coords:
+            if not self.all_rows_displayed:
+                coords = (self.disprn(coords[0]), coords[1])
+            if not self.all_columns_displayed:
+                coords = (coords[0], self.dispcn(coords[1]))
+            if not just_see:
+                if self.find_window.window.find_in_selection:
+                    self.set_currently_selected(*coords)
+                else:
+                    self.select_cell(*coords, redraw=False)
+            if not self.see(
+                *coords,
+                keep_yscroll=False,
+                keep_xscroll=False,
+                bottom_right_corner=False,
+                check_cell_visibility=True,
+                redraw=True,
+            ):
+                self.refresh()
+        return coords
+
+    def find_gen_all_cells(
+        self,
+        start_row: int,
+        start_col: int,
+        total_cols: int | None = None,
+        reverse: bool = False,
+    ) -> Generator[tuple[int, int]]:
+        if total_cols is None:
+            total_cols = self.total_data_cols(include_header=False)
+        total_rows = self.total_data_rows(include_index=False)
+        if reverse:
+            # yield start cell
+            yield (start_row, start_col)
+            # yield any remaining cells in the starting row before the start column
+            if start_col:
+                for col in reversed(range(start_col)):
+                    yield (start_row, col)
+            # yield any cells above start row
+            for row in reversed(range(start_row)):
+                for col in reversed(range(total_cols)):
+                    yield (row, col)
+            # yield cells from bottom of table upward
+            for row in range(total_rows - 1, start_row, -1):
+                for col in reversed(range(total_cols)):
+                    yield (row, col)
+            # yield any remaining cells in start row
+            for col in range(total_cols - 1, start_col, -1):
+                yield (start_row, col)
+        else:
+            # Yield cells from the start position to the end of the current row
+            for col in range(start_col, total_cols):
+                yield (start_row, col)
+            # yield from the next row to the last row
+            for row in range(start_row + 1, total_rows):
+                for col in range(total_cols):
+                    yield (row, col)
+            # yield from the beginning up to the start
+            for row in range(start_row):
+                for col in range(total_cols):
+                    yield (row, col)
+            # yield any remaining cells in the starting row before the start column
+            for col in range(start_col):
+                yield (start_row, col)
+
+    def find_get_start_coords(
+        self,
+        plus_one: bool = True,
+        within: None | list = None,
+        reverse: bool = False,
+    ) -> tuple[int, int, int]:
+        selected = self.selected
+        if not selected:
+            return 0, 0, 0
+        max_row = len(self.row_positions) - 2
+        max_col = len(self.col_positions) - 2
+        row, col = selected.row, selected.column
+        if plus_one and within:
+            curridx = bisect_left(within, (row, col)) + (1 if not reverse else -1)
+            return row, col, curridx % len(within)
+        if plus_one:
+            if reverse:
+                if col == 0:
+                    col = max_col
+                    row = max_row if row == 0 else row - 1
+                else:
+                    col -= 1
+            else:
+                col = (col + 1) % (max_col + 1)
+                if col == 0:
+                    row = (row + 1) % (max_row + 1)
+        return row, col, 0
+
+    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()
+            )
+        )
+
+    def find_within_sels(
+        self,
+        find: str,
+        reverse: bool = False,
+    ) -> tuple[int, int] | None:
+        sels = self.PAR.get_selected_cells(
+            get_rows=True,
+            get_columns=True,
+            sort_by_row=True,
+            sort_by_column=True,
+        )
+        _, _, from_idx = self.find_get_start_coords(plus_one=True, within=sels, reverse=reverse)
+        for r, c in chain(islice(sels, from_idx, None), islice(sels, 0, from_idx)):
+            if not self.all_rows_displayed:
+                r = self.datarn(r)
+            if not self.all_columns_displayed:
+                c = self.datacn(c)
+            if self.find_match(find, r, c):
+                return (r, c)
+        return None
+
+    def find_all_cells(
+        self,
+        find: str,
+        reverse: bool = False,
+    ) -> tuple[int, int] | None:
+        row, col, _ = self.find_get_start_coords(plus_one=True, reverse=reverse)
+        row, col = self.datarn(row), self.datacn(col)
+        return next(
+            (
+                (r, c)
+                for r, c in self.find_gen_all_cells(
+                    start_row=row,
+                    start_col=col,
+                    total_cols=self.total_data_cols(include_header=False),
+                    reverse=reverse,
+                )
+                if (
+                    (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,
+        )
+
+    def find_next(self, event: tk.Misc | None = None) -> Literal["break"]:
+        find = self.find_window.get().lower()
+        if not self.find_window.open:
+            self.open_find_window(focus=False)
+        if self.find_window.window.find_in_selection:
+            self.find_see_and_set(self.find_within_sels(find))
+        else:
+            self.find_see_and_set(self.find_all_cells(find))
+        return "break"
+
+    def find_previous(self, event: tk.Misc | None = None) -> Literal["break"]:
+        find = self.find_window.get().lower()
+        if not self.find_window.open:
+            self.open_find_window(focus=False)
+        if self.find_window.window.find_in_selection:
+            self.find_see_and_set(self.find_within_sels(find, reverse=True))
+        else:
+            self.find_see_and_set(self.find_all_cells(find, reverse=True))
+        return "break"
+
+    def close_find_window(
+        self,
+        event: tk.Misc | None = None,
+    ) -> None:
+        if self.find_window.open:
+            self.itemconfig(self.find_window.canvas_id, state="hidden")
+            self.find_window.open = False
+            self.focus_set()
+
     def create_ctrl_outline(
         self,
         x1: int,
@@ -527,19 +779,19 @@ class MainTable(tk.Canvas):
                 self.hidd_ctrl_outline[t] = False
 
     def get_ctrl_x_c_boxes(self) -> tuple[dict[tuple[int, int, int, int], str], int]:
-        boxes = {}
         maxrows = 0
         if not self.selected:
-            return boxes, maxrows
+            return {}, maxrows
         if self.selected.type_ in ("cells", "columns"):
             curr_box = self.selection_boxes[self.selected.fill_iid].coords
             maxrows = curr_box[2] - curr_box[0]
-            for item, box in self.get_selection_items(rows=False):
-                if maxrows >= box.coords[2] - box.coords[0]:
-                    boxes[box.coords] = box.type_
+            boxes = {
+                box.coords: box.type_
+                for _, box in self.get_selection_items(rows=False)
+                if maxrows >= box.coords[2] - box.coords[0]
+            }
         else:
-            for item, box in self.get_selection_items(columns=False, cells=False):
-                boxes[box.coords] = "rows"
+            boxes = {box.coords: "rows" for _, box in self.get_selection_items(columns=False, cells=False)}
         return boxes, maxrows
 
     def io_csv_writer(self) -> tuple[io.StringIO, csv.writer]:
@@ -1750,23 +2002,23 @@ class MainTable(tk.Canvas):
                         y = self.row_positions[r]
                     else:
                         y = self.row_positions[r + 1] + 1 - winfo_height
+                    y = y / (self.row_positions[-1] + self.PAR.ops.empty_vertical)
                     args = [
                         "moveto",
-                        y / (self.row_positions[-1] + self.PAR.ops.empty_vertical),
+                        y - 1 if y > 1 else y,
                     ]
-                    if args[1] > 1:
-                        args[1] = args[1] - 1
                     self.set_yviews(*args, redraw=False)
                     need_redraw = True
             else:
                 if r is not None and not keep_yscroll:
-                    y = self.row_positions[r] + ((self.row_positions[r + 1] - self.row_positions[r]) * r_pc)
+                    y = int(self.row_positions[r] + ((self.row_positions[r + 1] - self.row_positions[r]) * r_pc)) - 2
+                    if y < 0:
+                        y = 0
+                    y = y / (self.row_positions[-1] + self.PAR.ops.empty_vertical)
                     args = [
                         "moveto",
-                        y / (self.row_positions[-1] + self.PAR.ops.empty_vertical),
+                        y - 1 if y > 1 else y,
                     ]
-                    if args[1] > 1:
-                        args[1] = args[1] - 1
                     self.set_yviews(*args, redraw=False)
                     need_redraw = True
         if not xvis and len(self.col_positions) > 1:
@@ -1777,18 +2029,22 @@ class MainTable(tk.Canvas):
                         x = self.col_positions[c]
                     else:
                         x = self.col_positions[c + 1] + 1 - winfo_width
+                    x = x / (self.col_positions[-1] + self.PAR.ops.empty_horizontal)
                     args = [
                         "moveto",
-                        x / (self.col_positions[-1] + self.PAR.ops.empty_horizontal),
+                        x - 1 if x > 1 else x,
                     ]
                     self.set_xviews(*args, redraw=False)
                     need_redraw = True
             else:
                 if c is not None and not keep_xscroll:
-                    x = self.col_positions[c] + ((self.col_positions[c + 1] - self.col_positions[c]) * c_pc)
+                    x = int(self.col_positions[c] + ((self.col_positions[c + 1] - self.col_positions[c]) * c_pc)) - 2
+                    if x < 0:
+                        x = 0
+                    x = x / (self.col_positions[-1] + self.PAR.ops.empty_horizontal)
                     args = [
                         "moveto",
-                        x / (self.col_positions[-1] + self.PAR.ops.empty_horizontal),
+                        x - 1 if x > 1 else x,
                     ]
                     self.set_xviews(*args, redraw=False)
                     need_redraw = True
@@ -1810,20 +2066,12 @@ class MainTable(tk.Canvas):
         r: int | None = 0,
         c: int | None = 0,
         separate_axes: bool = False,
-    ) -> bool:
+    ) -> bool | tuple[bool, bool]:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
         x1, y1, x2, y2 = self.get_cell_coords(r, c)
-        x_vis = True
-        y_vis = True
-        if cx1 > x1 or cx2 < x2:
-            x_vis = False
-        if cy1 > y1 or cy2 < y2:
-            y_vis = False
-        if separate_axes:
-            return y_vis, x_vis
-        if not y_vis or not x_vis:
-            return False
-        return True
+        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
 
     def cell_visible(self, r: int = 0, c: int = 0) -> bool:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
@@ -1877,13 +2125,13 @@ class MainTable(tk.Canvas):
 
     def select_row_start(self, event: object) -> None:
         if self.selected:
-            self.select_cell(self.selected.row, 0)
             self.see(self.selected.row, 0)
+            self.select_cell(self.selected.row, 0, redraw=True)
 
     def select_a1(self, event: object) -> None:
         if len(self.row_positions) > 1 and len(self.col_positions) > 1:
-            self.select_cell(0, 0)
             self.see(0, 0)
+            self.select_cell(0, 0, redraw=True)
 
     def select_cell(
         self,
@@ -2213,9 +2461,8 @@ class MainTable(tk.Canvas):
         elif self.selected.type_ in ("cells", "columns"):
             r = self.selected.row
             c = self.selected.column
-            if not r and self.CH.col_selection_enabled:
-                if not self.cell_completely_visible(r=r, c=0):
-                    self.see(r, c, check_cell_visibility=False)
+            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)
@@ -2229,32 +2476,18 @@ class MainTable(tk.Canvas):
         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=min(r + 2, len(self.row_positions) - 2), c=0):
+                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)
-                    if (
-                        r + 2 < len(self.row_positions) - 2
-                        and (self.row_positions[r + 3] - self.row_positions[r + 2])
-                        + (self.row_positions[r + 2] - self.row_positions[r + 1])
-                        + 5
-                        < self.winfo_height()
-                    ):
-                        self.see(
-                            r + 2,
-                            0,
-                            keep_xscroll=True,
-                            bottom_right_corner=True,
-                            check_cell_visibility=False,
-                        )
-                    elif not self.cell_completely_visible(r=r + 1, c=0):
-                        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,
-                        )
+                    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:
@@ -2275,32 +2508,17 @@ class MainTable(tk.Canvas):
             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=min(r + 2, len(self.row_positions) - 2), c=c):
+                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)
-                    if (
-                        r + 2 < len(self.row_positions) - 2
-                        and (self.row_positions[r + 3] - self.row_positions[r + 2])
-                        + (self.row_positions[r + 2] - self.row_positions[r + 1])
-                        + 5
-                        < self.winfo_height()
-                    ):
-                        self.see(
-                            r + 2,
-                            c,
-                            keep_xscroll=True,
-                            bottom_right_corner=True,
-                            check_cell_visibility=False,
-                        )
-                    elif not self.cell_completely_visible(r=r + 1, c=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 + 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,
+                    )
 
     def arrowkey_LEFT(self, event: object = None) -> None:
         if not self.selected:
@@ -2325,7 +2543,7 @@ class MainTable(tk.Canvas):
         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=0):
+            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):
@@ -2710,7 +2928,7 @@ class MainTable(tk.Canvas):
                 **mnkwgs,
             )
 
-    def enable_bindings(self, bindings):
+    def enable_bindings(self, bindings: object) -> None:
         if not bindings:
             self._enable_binding("all")
         elif isinstance(bindings, (list, tuple)):
@@ -2752,6 +2970,7 @@ class MainTable(tk.Canvas):
         ):
             self._tksheet_bind("row_start_bindings", self.select_row_start)
             self._tksheet_bind("table_start_bindings", self.select_a1)
+            self._tksheet_bind("escape_bindings", self.escape)
             if binding in ("all", "single", "single_selection_mode", "single_select"):
                 self.single_selection_enabled = True
                 self.toggle_selection_enabled = False
@@ -2829,6 +3048,11 @@ class MainTable(tk.Canvas):
             self.undo_enabled = True
             self._tksheet_bind("undo_bindings", self.undo)
             self._tksheet_bind("redo_bindings", self.redo)
+        if binding in ("find",):
+            self.find_enabled = True
+            self._tksheet_bind("find_bindings", self.open_find_window)
+            self._tksheet_bind("find_next_bindings", self.find_next)
+            self._tksheet_bind("find_previous_bindings", self.find_previous)
         if binding in bind_del_columns:
             self.rc_delete_column_enabled = True
             self.rc_popup_menus_enabled = True
@@ -2881,6 +3105,7 @@ class MainTable(tk.Canvas):
         ):
             self._tksheet_unbind("row_start_bindings")
             self._tksheet_unbind("table_start_bindings")
+            self._tksheet_unbind("escape_bindings")
             self.single_selection_enabled = False
             self.toggle_selection_enabled = False
         if binding in ("all", "drag_select"):
@@ -2971,6 +3196,12 @@ class MainTable(tk.Canvas):
         if binding in ("all", "undo", "redo", "edit_bindings", "edit"):
             self.undo_enabled = False
             self._tksheet_unbind("undo_bindings", "redo_bindings")
+        if binding in ("all", "find"):
+            self.find_enabled = False
+            self._tksheet_unbind("find_bindings")
+            self._tksheet_unbind("find_next_bindings")
+            self._tksheet_unbind("find_previous_bindings")
+            self.close_find_window()
 
     def _tksheet_unbind(self, *keys) -> None:
         for widget in (self, self.RI, self.CH, self.TL):
@@ -3457,26 +3688,42 @@ class MainTable(tk.Canvas):
         if move_synced:
             self.y_move_synced_scrolls(*args, use_scrollbar=True)
 
-    def set_xviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
+    def set_xviews(
+        self,
+        *args,
+        move_synced: bool = True,
+        redraw: bool = True,
+    ) -> None:
         self.main_table_redraw_grid_and_text(setting_views=True)
-        self.update_idletasks()
+        if not self.PAR._startup_complete:
+            self.update_idletasks()
         self.xview(*args)
         if self.show_header:
-            self.CH.update_idletasks()
+            if not self.PAR._startup_complete:
+                self.CH.update_idletasks()
             self.CH.xview(*args)
-        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
+        if redraw:
+            self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
         if move_synced:
             self.x_move_synced_scrolls(*args)
         self.fix_views()
 
-    def set_yviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
+    def set_yviews(
+        self,
+        *args,
+        move_synced: bool = True,
+        redraw: bool = True,
+    ) -> None:
         self.main_table_redraw_grid_and_text(setting_views=True)
-        self.update_idletasks()
+        if not self.PAR._startup_complete:
+            self.update_idletasks()
         self.yview(*args)
         if self.show_index:
-            self.RI.update_idletasks()
+            if not self.PAR._startup_complete:
+                self.RI.update_idletasks()
             self.RI.yview(*args)
-        self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=True)
+        if redraw:
+            self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=True)
         if move_synced:
             self.y_move_synced_scrolls(*args)
         self.fix_views()
@@ -3618,7 +3865,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[3] - b[1]
 
-    def get_txt_dimensions(self, txt: str, font: None | FontTuple = None) -> int:
+    def get_txt_dimensions(self, txt: str, font: None | FontTuple = None) -> tuple[int, int]:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3639,7 +3886,6 @@ class MainTable(tk.Canvas):
     def set_min_column_width(self, width: int) -> None:
         if width:
             self.PAR.ops.min_column_width = width
-
         if self.PAR.ops.min_column_width > self.PAR.ops.max_column_width:
             self.PAR.ops.max_column_width = self.PAR.ops.min_column_width + 20
         if (
@@ -3669,12 +3915,12 @@ class MainTable(tk.Canvas):
     def set_table_font(self, newfont: tuple | None = None, reset_row_positions: bool = False) -> tuple[str, int, str]:
         if newfont:
             if not isinstance(newfont, tuple):
-                raise ValueError("Argument must be tuple e.g. " "('Carlito', 12, 'normal')")
+                raise ValueError("Argument must be tuple e.g. ('Carlito', 12, 'normal')")
             if len(newfont) != 3:
                 raise ValueError("Argument must be three-tuple")
             if not isinstance(newfont[0], str) or not isinstance(newfont[1], int) or not isinstance(newfont[2], str):
                 raise ValueError(
-                    "Argument must be font, size and 'normal', 'bold' or" "'italic' e.g. ('Carlito',12,'normal')"
+                    "Argument must be font, size and 'normal', 'bold' or'italic' e.g. ('Carlito',12,'normal')"
                 )
             self.PAR.ops.table_font = FontTuple(*newfont)
             self.set_table_font_help()
@@ -3706,7 +3952,7 @@ class MainTable(tk.Canvas):
                 raise ValueError("Argument must be three-tuple")
             if not isinstance(newfont[0], str) or not isinstance(newfont[1], int) or not isinstance(newfont[2], str):
                 raise ValueError(
-                    "Argument must be font, size and 'normal', 'bold' or" "'italic' e.g. ('Carlito',12,'normal')"
+                    "Argument must be font, size and 'normal', 'bold' or'italic' e.g. ('Carlito',12,'normal')"
                 )
             self.PAR.ops.header_font = FontTuple(*newfont)
             self.set_header_font_help()
@@ -3737,7 +3983,7 @@ class MainTable(tk.Canvas):
                 raise ValueError("Argument must be three-tuple")
             if not isinstance(newfont[0], str) or not isinstance(newfont[1], int) or not isinstance(newfont[2], str):
                 raise ValueError(
-                    "Argument must be font, size and 'normal', 'bold' or" "'italic' e.g. ('Carlito',12,'normal')"
+                    "Argument must be font, size and 'normal', 'bold' or'italic' e.g. ('Carlito',12,'normal')"
                 )
             self.PAR.ops.index_font = FontTuple(*newfont)
             self.set_index_font_help()
@@ -4752,8 +4998,8 @@ class MainTable(tk.Canvas):
         data_ins_col: int,
         displayed_ins_col: int,
         numcols: int,
-        columns: list | None = None,
-        widths: list | None = None,
+        columns: list[list[object]] | None = None,
+        widths: list[int] | tuple[int] | None = None,
         headers: bool = False,
     ) -> tuple[dict, dict, dict]:
         header_data = {}
@@ -4802,10 +5048,10 @@ class MainTable(tk.Canvas):
         data_ins_row: int,
         displayed_ins_row: int,
         numrows: int,
-        rows: list | None = None,
-        heights: list | None = None,
+        rows: list[list[object]] | None = None,
+        heights: list[int] | tuple[int] | None = None,
         row_index: bool = False,
-        total_data_cols=None,
+        total_data_cols: int | None = None,
     ) -> tuple[dict, dict, dict]:
         index_data = {}
         if isinstance(self._row_index, list):
@@ -5008,7 +5254,7 @@ class MainTable(tk.Canvas):
 
     def display_rows(
         self,
-        rows: int | AnyIter | None = None,
+        rows: int | AnyIter[int] | None = None,
         all_rows_displayed: bool | None = None,
         reset_row_positions: bool = True,
         deselect_all: bool = True,
@@ -5037,7 +5283,7 @@ class MainTable(tk.Canvas):
 
     def display_columns(
         self,
-        columns: int | AnyIter | None = None,
+        columns: int | AnyIter[int] | None = None,
         all_columns_displayed: bool | None = None,
         reset_col_positions: bool = True,
         deselect_all: bool = True,
@@ -5642,11 +5888,18 @@ class MainTable(tk.Canvas):
         if resized_cols or resized_rows or changed_w:
             self.recreate_all_selection_boxes()
             if changed_w:
-                self.update_idletasks()
-                self.RI.update_idletasks()
-                self.CH.update_idletasks()
-                self.TL.update_idletasks()
+                for widget in (self, self.RI, self.CH, self.TL):
+                    widget.update_idletasks()
                 return False
+        if self.find_window.open:
+            w, h, x, y = self.get_find_window_dimensions_coords(w_width=self.winfo_width())
+            self.coords(self.find_window.canvas_id, x, y)
+            self.itemconfig(
+                self.find_window.canvas_id,
+                width=w,
+                height=h,
+                state="normal",
+            )
         self.hidd_text.update(self.disp_text)
         self.disp_text = {}
         self.hidd_high.update(self.disp_high)
@@ -5677,13 +5930,13 @@ class MainTable(tk.Canvas):
                 chain.from_iterable(
                     [
                         (
-                            self.canvasx(0) - 1,
+                            scrollpos_left - 1,
                             self.row_positions[r],
                             x_grid_stop,
                             self.row_positions[r],
-                            self.canvasx(0) - 1,
+                            scrollpos_left - 1,
                             self.row_positions[r],
-                            self.canvasx(0) - 1,
+                            scrollpos_left - 1,
                             self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
                         )
                         for r in range(grid_start_row, grid_end_row)
@@ -6045,56 +6298,35 @@ class MainTable(tk.Canvas):
         box: tuple[int, int, int, int] | None = None,
         run_binding: bool = True,
     ) -> None:
+        def box_created(r: int, c: int, box: SelectionBox) -> bool:
+            r1, c1, r2, c2 = box.coords
+            if r1 <= r and c1 <= c and r2 >= r and c2 >= c:
+                self.create_currently_selected_box(r, c, box.type_, box.fill_iid)
+                if run_binding:
+                    self.run_selection_binding(box.type_)
+                return True
+            return False
+
+        # set current to a particular existing selection box
         if isinstance(item, int) and item in self.selection_boxes:
             selection_box = self.selection_boxes[item]
             r1, c1, r2, c2 = selection_box.coords
-            if r is None:
-                r = r1
-            if c is None:
-                c = c1
-            if r1 <= r and c1 <= c and r2 >= r and c2 >= c:
-                self.create_currently_selected_box(
-                    r,
-                    c,
-                    selection_box.type_,
-                    selection_box.fill_iid,
-                )
-                if run_binding:
-                    self.run_selection_binding(selection_box.type_)
+            if box_created(r1 if r is None else r, c1 if c is None else c, selection_box):
                 return
-        # currently selected is pointed at any selection box with "box" coordinates
+
+        # set current to any existing selection box with coordinates: box
         if isinstance(box, tuple):
-            if r is None:
-                r = box[0]
-            if c is None:
-                c = box[1]
             for item, selection_box in self.get_selection_items(reverse=True):
-                r1, c1, r2, c2 = selection_box.coords
-                if box == (r1, c1, r2, c2) and r1 <= r and c1 <= c and r2 >= r and c2 >= c:
-                    self.create_currently_selected_box(
-                        r,
-                        c,
-                        selection_box.type_,
-                        selection_box.fill_iid,
-                    )
-                    if run_binding:
-                        self.run_selection_binding(selection_box.type_)
-                    return
-        # currently selected is just pointed at a coordinate
-        # find the top most box there, requires r and c
-        if r is not None and c is not None:
+                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
+
+        # 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):
-                r1, c1, r2, c2 = selection_box.coords
-                if r1 <= r and c1 <= c and r2 >= r and c2 >= c:
-                    self.create_currently_selected_box(
-                        r,
-                        c,
-                        selection_box.type_,
-                        selection_box.fill_iid,
-                    )
-                    if run_binding:
-                        self.run_selection_binding(selection_box.type_)
+                if box_created(r, c, selection_box):
                     return
+
             # wasn't provided an item and couldn't find a box at coords so select cell
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
                 self.select_cell(r, c, redraw=True)
@@ -6215,7 +6447,7 @@ class MainTable(tk.Canvas):
 
     def hide_selection_box(self, item: int | None) -> bool:
         if item is None or item is True or item not in self.selection_boxes:
-            return
+            return False
         box = self.selection_boxes.pop(item)
         self.hide_box(box.fill_iid)
         self.hide_box(box.bd_iid)
@@ -6465,50 +6697,30 @@ class MainTable(tk.Canvas):
     def recreate_all_selection_boxes(self) -> None:
         if not self.selected:
             return
+
         modified = False
+        row_limit = len(self.row_positions) - 1
+        col_limit = len(self.col_positions) - 1
+
         for item, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
-            if not modified:
-                modified = (
-                    r1 >= len(self.row_positions) - 1
-                    or c1 >= len(self.col_positions) - 1
-                    or r2 > len(self.row_positions) - 1
-                    or c2 > len(self.col_positions) - 1
-                )
-            if r1 >= len(self.row_positions) - 1:
-                if len(self.row_positions) > 1:
-                    r1 = len(self.row_positions) - 2
-                else:
-                    r1 = 0
-            if c1 >= len(self.col_positions) - 1:
-                if len(self.col_positions) > 1:
-                    c1 = len(self.col_positions) - 2
-                else:
-                    c1 = 0
-            if r2 > len(self.row_positions) - 1:
-                r2 = len(self.row_positions) - 1
-            if c2 > len(self.col_positions) - 1:
-                c2 = len(self.col_positions) - 1
+            # check coordinates
+            r1 = min(r1, row_limit - (1 if row_limit > 0 else 0))
+            c1 = min(c1, col_limit - (1 if col_limit > 0 else 0))
+            r2 = min(r2, row_limit)
+            c2 = min(c2, col_limit)
+
+            modified = modified or (r1 >= row_limit or c1 >= col_limit or r2 > row_limit or c2 > col_limit)
             self.recreate_selection_box(r1, c1, r2, c2, item, run_binding=False)
 
         if self.selected:
-            r = self.selected.row
-            c = self.selected.column
-            if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                self.set_currently_selected(
-                    r,
-                    c,
-                    item=self.selected.fill_iid,
-                    run_binding=False,
-                )
+            r, c = self.selected.row, self.selected.column
+            if r < row_limit and c < col_limit:
+                self.set_currently_selected(r, c, item=self.selected.fill_iid, run_binding=False)
             else:
                 box = self.selection_boxes[self.selected.fill_iid]
-                self.set_currently_selected(
-                    box.coords.from_r,
-                    box.coords.from_c,
-                    item=box.fill_iid,
-                    run_binding=False,
-                )
+                self.set_currently_selected(box.coords[0], box.coords[1], item=box.fill_iid, run_binding=False)
+
         if modified:
             self.PAR.emit_event(
                 "<<SheetSelect>>",
@@ -6535,23 +6747,17 @@ class MainTable(tk.Canvas):
         return d
 
     def get_selected_min_max(self) -> tuple[int, int, int, int] | tuple[None, None, None, None]:
-        min_x = float("inf")
-        min_y = float("inf")
-        max_x = 0
-        max_y = 0
-        for item, box in self.get_selection_items():
+        if not self.get_selection_items():
+            return None, None, None, None
+        min_y, min_x = float("inf"), float("inf")
+        max_y, max_x = 0, 0
+
+        for _, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
-            if r1 < min_y:
-                min_y = r1
-            if c1 < min_x:
-                min_x = c1
-            if r2 > max_y:
-                max_y = r2
-            if c2 > max_x:
-                max_x = c2
-        if min_x != float("inf") and min_y != float("inf") and max_x > 0 and max_y > 0:
-            return min_y, min_x, max_y, max_x
-        return None, None, None, None
+            min_y, min_x = min(min_y, r1), min(min_x, c1)
+            max_y, max_x = max(max_y, r2), max(max_x, c2)
+
+        return (min_y, min_x, max_y, max_x) if min_y != float("inf") else (None, None, None, None)
 
     def get_selected_rows(
         self,
@@ -6706,7 +6912,7 @@ class MainTable(tk.Canvas):
         elif self.get_cell_kwargs(datarn, datacn, key="dropdown") or self.get_cell_kwargs(
             datarn, datacn, key="checkbox"
         ):
-            if self.event_opens_dropdown_or_checkbox(event):
+            if event_opens_dropdown_or_checkbox(event):
                 if self.get_cell_kwargs(datarn, datacn, key="dropdown"):
                     self.open_dropdown_window(r, c, event=event)
                 elif self.get_cell_kwargs(datarn, datacn, key="checkbox"):
@@ -6714,27 +6920,6 @@ class MainTable(tk.Canvas):
         else:
             self.open_text_editor(event=event, r=r, c=c, dropdown=False)
 
-    def event_opens_dropdown_or_checkbox(self, event=None) -> bool:
-        if event is None:
-            return False
-        elif event == "rc":
-            return True
-        elif (
-            (hasattr(event, "keysym") and event.keysym == "Return")
-            or (hasattr(event, "keysym") and event.keysym == "F2")
-            or (
-                event is not None
-                and hasattr(event, "keycode")
-                and event.keycode == "??"
-                and hasattr(event, "num")
-                and event.num == 1
-            )  # mouseclick
-            or (hasattr(event, "keysym") and event.keysym == "BackSpace")
-        ):
-            return True
-        else:
-            return False
-
     # displayed indexes
     def get_cell_align(self, r: int, c: int) -> str:
         datarn = self.datarn(r)
@@ -6754,27 +6939,16 @@ class MainTable(tk.Canvas):
         state: str = "normal",
         dropdown: bool = False,
     ) -> bool:
-        text = None
+        text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str=True)}"
         extra_func_key = "??"
-        if event is None or self.event_opens_dropdown_or_checkbox(event):
-            if event is not None:
-                if hasattr(event, "keysym") and event.keysym == "Return":
-                    extra_func_key = "Return"
-                elif hasattr(event, "keysym") and event.keysym == "F2":
-                    extra_func_key = "F2"
-            if event is not None and (hasattr(event, "keysym") and event.keysym == "BackSpace"):
-                extra_func_key = "BackSpace"
-                text = ""
-            else:
-                text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
-        elif event is not None and (
-            (hasattr(event, "char") and event.char.isalpha())
-            or (hasattr(event, "char") and event.char.isdigit())
-            or (hasattr(event, "char") and event.char in symbols_set)
-        ):
-            extra_func_key = event.char
-            text = event.char
-        else:
+        if event_opens_dropdown_or_checkbox(event):
+            if hasattr(event, "keysym") and event.keysym in ("Return", "F2", "BackSpace"):
+                extra_func_key = event.keysym
+                if event.keysym == "BackSpace":
+                    text = ""
+        elif event_has_char_key(event):
+            extra_func_key = text = event.char
+        elif event is not None:
             return False
         if self.extra_begin_edit_cell_func:
             try:
@@ -6797,12 +6971,11 @@ class MainTable(tk.Canvas):
                 return False
             else:
                 text = text if isinstance(text, str) else f"{text}"
-        text = "" if text is None else text
         if self.PAR.ops.cell_auto_resize_enabled:
             self.set_cell_size_to_text(r, c, only_if_too_small=True, redraw=True, run_binding=True)
         if self.text_editor.open and (r, c) == self.text_editor.coords:
             self.text_editor.window.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
-            return
+            return False
         self.hide_text_editor()
         if not self.see(r=r, c=c, check_cell_visibility=True):
             self.refresh()
@@ -6810,8 +6983,6 @@ class MainTable(tk.Canvas):
         y = self.row_positions[r]
         w = self.col_positions[c + 1] - x + 1
         h = self.row_positions[r + 1] - y + 1
-        if text is None:
-            text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         kwargs = {
             "menu_kwargs": DotDict(
                 {