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

tksheet/main_table.py

@@ -3,42 +3,17 @@ from __future__ import annotations
 import csv as csv
 import io
 import tkinter as tk
-from bisect import (
-    bisect_left,
-    bisect_right,
-)
-from collections import (
-    defaultdict,
-    deque,
-)
-from collections.abc import (
-    Callable,
-    Generator,
-    Hashable,
-    Sequence,
-)
-from functools import (
-    partial,
-)
-from itertools import (
-    accumulate,
-    chain,
-    cycle,
-    filterfalse,
-    islice,
-    repeat,
-)
-from math import (
-    ceil,
-    floor,
-)
+from bisect import bisect_left, bisect_right
+from collections import defaultdict, deque
+from collections.abc import Callable, Generator, Hashable, Sequence
+from functools import partial
+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 .colors import (
-    color_map,
-)
+from .colors import color_map
 from .constants import (
     USER_OS,
     bind_add_columns,
@@ -52,9 +27,7 @@ from .constants import (
     text_editor_to_unbind,
     val_modifying_options,
 )
-from .find_window import (
-    FindWindow,
-)
+from .find_window import FindWindow
 from .formatters import (
     data_to_str,
     format_data,
@@ -67,6 +40,7 @@ from .functions import (
     add_to_displayed,
     b_index,
     bisect_in,
+    box_gen_coords,
     box_is_single_cell,
     cell_right_within_box,
     color_tup,
@@ -78,6 +52,7 @@ from .functions import (
     event_has_char_key,
     event_opens_dropdown_or_checkbox,
     float_to_int,
+    gen_coords,
     gen_formatted,
     get_data_from_clipboard,
     get_new_indexes,
@@ -86,6 +61,7 @@ from .functions import (
     insert_items,
     int_x_iter,
     is_iterable,
+    is_last_cell,
     is_type_int,
     len_to_idx,
     mod_event_val,
@@ -93,6 +69,7 @@ from .functions import (
     mod_span_widget,
     move_elements_by_mapping,
     new_tk_event,
+    next_cell,
     rounded_box_coords,
     span_idxs_post_move,
     stored_event_dict,
@@ -115,12 +92,8 @@ from .other_classes import (
     SelectionBox,
     TextEditorStorage,
 )
-from .text_editor import (
-    TextEditor,
-)
-from .types import (
-    AnyIter,
-)
+from .text_editor import TextEditor
+from .types import AnyIter
 
 
 class MainTable(tk.Canvas):
@@ -358,10 +331,8 @@ class MainTable(tk.Canvas):
             reset_col_positions=False,
             deselect_all=False,
         )
+        self.rc_popup_menu, self.empty_rc_popup_menu = None, None
         self.reset_col_positions()
-
-        self.rc_popup_menu = None
-        self.empty_rc_popup_menu = None
         self.basic_bindings()
         self.create_rc_menus()
 
@@ -547,19 +518,25 @@ class MainTable(tk.Canvas):
             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]:
+    def find_see_and_set(
+        self,
+        coords: tuple[int, int, int | None] | None,
+        just_see: bool = False,
+    ) -> tuple[int, int]:
         if coords:
+            row, column, item = coords
             if not self.all_rows_displayed:
-                coords = (self.disprn(coords[0]), coords[1])
+                row = self.disprn(row)
             if not self.all_columns_displayed:
-                coords = (coords[0], self.dispcn(coords[1]))
+                column = self.dispcn(column)
             if not just_see:
                 if self.find_window.window.find_in_selection:
-                    self.set_currently_selected(*coords)
+                    self.set_currently_selected(row, column, item=item)
                 else:
-                    self.select_cell(*coords, redraw=False)
+                    self.select_cell(row, column, redraw=False)
             if not self.see(
-                *coords,
+                row,
+                column,
                 keep_yscroll=False,
                 keep_xscroll=False,
                 bottom_right_corner=False,
@@ -569,78 +546,6 @@ class MainTable(tk.Canvas):
                 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
@@ -653,41 +558,106 @@ class MainTable(tk.Canvas):
             )
         )
 
-    def find_within_sels(
+    def find_within_match(self, find: str, r: int, c: int) -> bool:
+        if not self.all_rows_displayed:
+            r = self.datarn(r)
+        if not self.all_columns_displayed:
+            c = self.datacn(c)
+        return self.find_match(find, r, c)
+
+    def find_within_current_box(
         self,
+        current_box: SelectionBox,
         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,
+        reverse: bool,
+    ) -> None | tuple[int, int]:
+        start_row, start_col = next_cell(
+            *current_box.coords,
+            self.selected.row,
+            self.selected.column,
+            reverse=reverse,
         )
-        _, _, 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)
+        _, _, r2, c2 = current_box.coords
+        for r, c in box_gen_coords(start_row, start_col, c2, r2, reverse=reverse):
+            if self.find_within_match(find, r, c):
+                return (r, c, current_box.fill_iid)
+        return None
+
+    def find_within_non_current_boxes(
+        self,
+        current_id: int,
+        find: str,
+        reverse: bool,
+    ) -> None | tuple[int, int]:
+        if reverse:
+            # iterate backwards through selection boxes from the box before current
+            idx = next(i for i, k in enumerate(reversed(self.selection_boxes)) if k == current_id)
+            for item, box in chain(
+                islice(reversed(self.selection_boxes.items()), idx + 1, None),
+                islice(reversed(self.selection_boxes.items()), 0, idx),
+            ):
+                for r, c in gen_coords(*box.coords, reverse=reverse):
+                    if self.find_within_match(find, r, c):
+                        return (r, c, item)
+        else:
+            # iterate forwards through selection boxes from the box after current
+            idx = next(i for i, k in enumerate(self.selection_boxes) if k == current_id)
+            for item, box in chain(
+                islice(self.selection_boxes.items(), idx + 1, None),
+                islice(self.selection_boxes.items(), 0, idx),
+            ):
+                for r, c in gen_coords(*box.coords, reverse=reverse):
+                    if self.find_within_match(find, r, c):
+                        return (r, c, item)
+        return None
+
+    def find_within(
+        self,
+        find: str,
+        reverse: bool = False,
+    ) -> tuple[int, int, int] | None:
+        if not self.selected:
+            return None
+        current_box = self.selection_boxes[self.selected.fill_iid]
+        current_id = self.selected.fill_iid
+        if is_last_cell(*current_box.coords, self.selected.row, self.selected.column, reverse=reverse):
+            if coord := self.find_within_non_current_boxes(current_id=current_id, find=find, reverse=reverse):
+                return coord
+            if coord := self.find_within_current_box(current_box=current_box, find=find, reverse=reverse):
+                return coord
+        else:
+            if coord := self.find_within_current_box(current_box=current_box, find=find, reverse=reverse):
+                return coord
+            if coord := self.find_within_non_current_boxes(current_id=current_id, find=find, reverse=reverse):
+                return coord
         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)
+    ) -> tuple[int, int, None] | None:
+        if self.selected:
+            row, col = next_cell(
+                0,
+                0,
+                len(self.row_positions) - 1,
+                len(self.col_positions) - 1,
+                self.selected.row,
+                self.selected.column,
+                reverse=reverse,
+            )
+        else:
+            row, col = 0, 0
         row, col = self.datarn(row), self.datacn(col)
-        return next(
+        result = next(
             (
                 (r, c)
-                for r, c in self.find_gen_all_cells(
+                for r, c in box_gen_coords(
                     start_row=row,
                     start_col=col,
                     total_cols=self.total_data_cols(include_header=False),
+                    total_rows=self.total_data_rows(include_index=False),
                     reverse=reverse,
                 )
                 if (
@@ -698,13 +668,16 @@ class MainTable(tk.Canvas):
             ),
             None,
         )
+        if result:
+            return result + (None,)
+        return 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))
+            self.find_see_and_set(self.find_within(find))
         else:
             self.find_see_and_set(self.find_all_cells(find))
         return "break"
@@ -714,7 +687,7 @@ class MainTable(tk.Canvas):
         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))
+            self.find_see_and_set(self.find_within(find, reverse=True))
         else:
             self.find_see_and_set(self.find_all_cells(find, reverse=True))
         return "break"
@@ -1216,25 +1189,24 @@ class MainTable(tk.Canvas):
         event_data["selection_boxes"] = boxes
         if not try_binding(self.extra_begin_delete_key_func, event_data, "begin_delete"):
             return
-        for r1, c1, r2, c2 in boxes:
-            for r in range(r1, r2):
-                for c in range(c1, c2):
-                    datarn, datacn = self.datarn(r), self.datacn(c)
-                    val = self.get_value_for_empty_cell(datarn, datacn)
-                    if (
-                        not self.edit_validation_func
-                        or not validation
-                        or (
-                            self.edit_validation_func
-                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
-                        )
-                    ):
-                        event_data = self.event_data_set_cell(
-                            datarn,
-                            datacn,
-                            val,
-                            event_data,
-                        )
+        for box in boxes:
+            for r, c in gen_coords(*box):
+                datarn, datacn = self.datarn(r), self.datacn(c)
+                val = self.get_value_for_empty_cell(datarn, datacn)
+                if (
+                    not self.edit_validation_func
+                    or not validation
+                    or (
+                        self.edit_validation_func
+                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                    )
+                ):
+                    event_data = self.event_data_set_cell(
+                        datarn,
+                        datacn,
+                        val,
+                        event_data,
+                    )
         if event_data["cells"]["table"]:
             self.refresh()
             self.undo_stack.append(stored_event_dict(event_data))
@@ -2011,9 +1983,9 @@ class MainTable(tk.Canvas):
                     need_redraw = True
             else:
                 if r is not None and not keep_yscroll:
-                    y = int(self.row_positions[r] + ((self.row_positions[r + 1] - self.row_positions[r]) * r_pc)) - 2
-                    if y < 0:
-                        y = 0
+                    y = max(
+                        0, int(self.row_positions[r] + ((self.row_positions[r + 1] - self.row_positions[r]) * r_pc)) - 2
+                    )
                     y = y / (self.row_positions[-1] + self.PAR.ops.empty_vertical)
                     args = [
                         "moveto",
@@ -2038,9 +2010,9 @@ class MainTable(tk.Canvas):
                     need_redraw = True
             else:
                 if c is not None and not keep_xscroll:
-                    x = int(self.col_positions[c] + ((self.col_positions[c + 1] - self.col_positions[c]) * c_pc)) - 2
-                    if x < 0:
-                        x = 0
+                    x = max(
+                        0, int(self.col_positions[c] + ((self.col_positions[c + 1] - self.col_positions[c]) * c_pc)) - 2
+                    )
                     x = x / (self.col_positions[-1] + self.PAR.ops.empty_horizontal)
                     args = [
                         "moveto",
@@ -2391,15 +2363,11 @@ class MainTable(tk.Canvas):
     def page_UP(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
-        scrollto_y = top - height
-        if scrollto_y < 0:
-            scrollto_y = 0
+        scrollto_y = max(0, top - height)
         if self.PAR.ops.page_up_down_select_row:
             r = bisect_left(self.row_positions, scrollto_y)
             if self.selected and self.selected.row == r:
-                r -= 1
-            if r < 0:
-                r = 0
+                r = max(0, r - 1)
             if self.RI.row_selection_enabled and (
                 self.anything_selected(exclude_columns=True, exclude_cells=True) or not self.anything_selected()
             ):
@@ -5492,7 +5460,7 @@ class MainTable(tk.Canvas):
         can_width: int | None,
         dont_blend: bool,
         alternate_color: Highlight | None,
-    ) -> str:
+    ) -> tuple[str, bool]:
         redrawn = False
         if (datarn, datacn) in self.progress_bars:
             kwargs = self.progress_bars[(datarn, datacn)]
@@ -5571,7 +5539,6 @@ class MainTable(tk.Canvas):
                         if self.get_cell_kwargs(datarn, datacn, key="dropdown") and self.PAR.ops.show_dropdown_borders
                         else ""
                     ),
-                    tag="hi",
                 )
                 if isinstance(kwargs, ProgressBar):
                     if kwargs.del_when_done and kwargs.percent >= 100:
@@ -5597,7 +5564,17 @@ class MainTable(tk.Canvas):
                 txtfg = self.PAR.ops.table_fg
         return txtfg, redrawn
 
-    def redraw_highlight(self, x1, y1, x2, y2, fill, outline, tag, can_width=None, pc=None):
+    def redraw_highlight(
+        self,
+        x1: int | float,
+        y1: int | float,
+        x2: int | float,
+        y2: int | float,
+        fill: str,
+        outline: str,
+        can_width: None | float = None,
+        pc: None | float = None,
+    ) -> bool:
         if not is_type_int(pc) or pc >= 100:
             coords = (
                 x1 - 1 if outline else x1,
@@ -5615,66 +5592,61 @@ class MainTable(tk.Canvas):
             if showing:
                 self.itemconfig(iid, fill=fill, outline=outline)
             else:
-                self.itemconfig(iid, fill=fill, outline=outline, tag=tag, state="normal")
+                self.itemconfig(iid, fill=fill, outline=outline, state="normal")
+            self.tag_raise(iid)
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline, tag=tag)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline)
         self.disp_high[iid] = True
         return True
 
-    def redraw_gridline(
-        self,
-        points,
-        fill,
-        width,
-        tag,
-    ):
-        if self.hidd_grid:
-            iid, sh = self.hidd_grid.popitem()
-            self.coords(iid, points)
-            if sh:
-                self.itemconfig(
-                    iid,
-                    fill=fill,
-                    width=width,
-                    capstyle=tk.BUTT,
-                    joinstyle=tk.ROUND,
-                )
+    def redraw_gridline(self, points: list[float]) -> None:
+        if points:
+            if self.hidd_grid:
+                iid, sh = self.hidd_grid.popitem()
+                self.coords(iid, points)
+                if sh:
+                    self.itemconfig(
+                        iid,
+                        fill=self.PAR.ops.table_grid_fg,
+                        width=1,
+                        capstyle=tk.BUTT,
+                        joinstyle=tk.ROUND,
+                    )
+                else:
+                    self.itemconfig(
+                        iid,
+                        fill=self.PAR.ops.table_grid_fg,
+                        width=1,
+                        capstyle=tk.BUTT,
+                        joinstyle=tk.ROUND,
+                        state="normal",
+                    )
+                self.tag_raise(iid)
             else:
-                self.itemconfig(
-                    iid,
-                    fill=fill,
-                    width=width,
+                iid = self.create_line(
+                    points,
+                    fill=self.PAR.ops.table_grid_fg,
+                    width=1,
                     capstyle=tk.BUTT,
                     joinstyle=tk.ROUND,
-                    state="normal",
+                    tag="g",
                 )
-        else:
-            iid = self.create_line(
-                points,
-                fill=fill,
-                width=width,
-                capstyle=tk.BUTT,
-                joinstyle=tk.ROUND,
-                tag=tag,
-            )
-        self.disp_grid[iid] = True
-        return iid
+            self.disp_grid[iid] = True
 
     def redraw_dropdown(
         self,
-        x1,
-        y1,
-        x2,
-        y2,
-        fill,
-        outline,
-        tag,
-        draw_outline=True,
-        draw_arrow=True,
-        open_=False,
-    ):
+        x1: int | float,
+        y1: int | float,
+        x2: int | float,
+        y2: int | float,
+        fill: str,
+        outline: str,
+        draw_outline: bool = True,
+        draw_arrow: bool = True,
+        open_: bool = False,
+    ) -> None:
         if draw_outline and self.PAR.ops.show_dropdown_borders:
-            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg, tag=tag)
+            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg)
         if draw_arrow:
             mod = (self.table_txt_height - 1) if self.table_txt_height % 2 else self.table_txt_height
             small_mod = int(mod / 5)
@@ -5705,13 +5677,12 @@ class MainTable(tk.Canvas):
                 if sh:
                     self.itemconfig(t, fill=fill)
                 else:
-                    self.itemconfig(t, fill=fill, tag=tag, state="normal")
+                    self.itemconfig(t, fill=fill, state="normal")
                 self.lift(t)
             else:
                 t = self.create_line(
                     points,
                     fill=fill,
-                    tag=tag,
                     width=2,
                     capstyle=tk.ROUND,
                     joinstyle=tk.BEVEL,
@@ -5726,7 +5697,6 @@ class MainTable(tk.Canvas):
         y2: int | float,
         fill: str,
         outline: str,
-        tag: str | tuple,
         draw_check: bool = False,
     ) -> None:
         points = rounded_box_coords(x1, y1, x2, y2)
@@ -5736,10 +5706,10 @@ class MainTable(tk.Canvas):
             if sh:
                 self.itemconfig(t, fill=outline, outline=fill)
             else:
-                self.itemconfig(t, fill=outline, outline=fill, tag=tag, state="normal")
+                self.itemconfig(t, fill=outline, outline=fill, state="normal")
             self.lift(t)
         else:
-            t = self.create_polygon(points, fill=outline, outline=fill, tag=tag, smooth=True)
+            t = self.create_polygon(points, fill=outline, outline=fill, smooth=True)
         self.disp_checkbox[t] = True
         if draw_check:
             x1 = x1 + 4
@@ -5753,28 +5723,13 @@ class MainTable(tk.Canvas):
                 if sh:
                     self.itemconfig(t, fill=fill, outline=outline)
                 else:
-                    self.itemconfig(t, fill=fill, outline=outline, tag=tag, state="normal")
+                    self.itemconfig(t, fill=fill, outline=outline, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
+                t = self.create_polygon(points, fill=fill, outline=outline, smooth=True)
             self.disp_checkbox[t] = True
 
-    def main_table_redraw_grid_and_text(
-        self,
-        redraw_header: bool = False,
-        redraw_row_index: bool = False,
-        redraw_table: bool = True,
-        setting_views: bool = False,
-    ) -> bool:
-        try:
-            can_width = self.winfo_width()
-            can_height = self.winfo_height()
-        except Exception:
-            return False
-        row_pos_exists = self.row_positions != [0] and self.row_positions
-        col_pos_exists = self.col_positions != [0] and self.col_positions
-        resized_cols = False
-        resized_rows = False
+    def _auto_resize_columns(self, can_width: float, col_pos_exists: bool) -> bool:
         if self.PAR.ops.auto_resize_columns and self.allow_auto_resize_columns and col_pos_exists:
             max_w = can_width - self.PAR.ops.empty_horizontal
             if self.PAR.ops.auto_resize_columns < self.PAR.ops.min_column_width:
@@ -5782,7 +5737,6 @@ class MainTable(tk.Canvas):
             else:
                 min_column_width = self.PAR.ops.auto_resize_columns
             if (len(self.col_positions) - 1) * min_column_width < max_w:
-                resized_cols = True
                 change = int((max_w - self.col_positions[-1]) / (len(self.col_positions) - 1))
                 widths = [
                     int(b - a) + change - 1
@@ -5799,6 +5753,10 @@ class MainTable(tk.Canvas):
                         if i not in diffs:
                             widths[i] -= change
                 self.col_positions = list(accumulate(chain([0], widths)))
+                return True
+        return False
+
+    def _auto_resize_rows(self, can_height: float, row_pos_exists: bool) -> bool:
         if self.PAR.ops.auto_resize_rows and self.allow_auto_resize_rows and row_pos_exists:
             max_h = can_height - self.PAR.ops.empty_vertical
             if self.PAR.ops.auto_resize_rows < self.min_row_height:
@@ -5806,7 +5764,6 @@ class MainTable(tk.Canvas):
             else:
                 min_row_height = self.PAR.ops.auto_resize_rows
             if (len(self.row_positions) - 1) * min_row_height < max_h:
-                resized_rows = True
                 change = int((max_h - self.row_positions[-1]) / (len(self.row_positions) - 1))
                 heights = [
                     int(b - a) + change - 1
@@ -5823,6 +5780,10 @@ class MainTable(tk.Canvas):
                         if i not in diffs:
                             heights[i] -= change
                 self.row_positions = list(accumulate(chain([0], heights)))
+                return True
+        return False
+
+    def _manage_scroll_bars(self, can_height: float, can_width: float) -> None:
         if (
             self.PAR.ops.auto_resize_row_index is not True
             and can_width >= self.col_positions[-1] + self.PAR.ops.empty_horizontal
@@ -5849,6 +5810,26 @@ class MainTable(tk.Canvas):
         ):
             self.PAR.yscroll.grid(row=0, column=2, rowspan=3, sticky="nswe")
             self.PAR.yscroll_showing = True
+
+    def main_table_redraw_grid_and_text(
+        self,
+        redraw_header: bool = False,
+        redraw_row_index: bool = False,
+        redraw_table: bool = True,
+        setting_views: bool = False,
+    ) -> bool:
+        try:
+            can_width = self.winfo_width()
+            can_height = self.winfo_height()
+        except Exception:
+            return False
+        row_pos_exists = self.row_positions != [0] and self.row_positions
+        col_pos_exists = self.col_positions != [0] and self.col_positions
+
+        resized_cols = self._auto_resize_columns(can_width=can_width, col_pos_exists=col_pos_exists)
+        resized_rows = self._auto_resize_rows(can_height=can_height, row_pos_exists=row_pos_exists)
+        self._manage_scroll_bars(can_height=can_height, can_width=can_width)
+
         last_col_line_pos = self.col_positions[-1] + 1
         last_row_line_pos = self.row_positions[-1] + 1
         scrollregion = (
@@ -5864,6 +5845,7 @@ class MainTable(tk.Canvas):
             self.RI.configure_scrollregion(last_row_line_pos)
             if setting_views:
                 return False
+
         scrollpos_top = self.canvasy(0)
         scrollpos_bot = self.canvasy(can_height)
         scrollpos_left = self.canvasx(0)
@@ -5891,6 +5873,7 @@ class MainTable(tk.Canvas):
                 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)
@@ -5910,79 +5893,11 @@ class MainTable(tk.Canvas):
         self.disp_dropdown = {}
         self.hidd_checkbox.update(self.disp_checkbox)
         self.disp_checkbox = {}
-        if last_col_line_pos > scrollpos_right:
-            x_stop = scrollpos_right
-        else:
-            x_stop = last_col_line_pos
-        if last_row_line_pos > scrollpos_bot:
-            y_stop = scrollpos_bot
-        else:
-            y_stop = last_row_line_pos
-        if redraw_table and self.PAR.ops.show_horizontal_grid and row_pos_exists:
-            if self.PAR.ops.horizontal_grid_to_end_of_window:
-                x_grid_stop = scrollpos_right + can_width
-            else:
-                if last_col_line_pos > scrollpos_right:
-                    x_grid_stop = x_stop + 1
-                else:
-                    x_grid_stop = x_stop - 1
-            points = list(
-                chain.from_iterable(
-                    [
-                        (
-                            scrollpos_left - 1,
-                            self.row_positions[r],
-                            x_grid_stop,
-                            self.row_positions[r],
-                            scrollpos_left - 1,
-                            self.row_positions[r],
-                            scrollpos_left - 1,
-                            self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
-                        )
-                        for r in range(grid_start_row, grid_end_row)
-                    ]
-                )
-            )
-            if points:
-                self.redraw_gridline(
-                    points=points,
-                    fill=self.PAR.ops.table_grid_fg,
-                    width=1,
-                    tag="g",
-                )
-        if redraw_table and self.PAR.ops.show_vertical_grid and col_pos_exists:
-            if self.PAR.ops.vertical_grid_to_end_of_window:
-                y_grid_stop = scrollpos_bot + can_height
-            else:
-                if last_row_line_pos > scrollpos_bot:
-                    y_grid_stop = y_stop + 1
-                else:
-                    y_grid_stop = y_stop - 1
-            points = list(
-                chain.from_iterable(
-                    [
-                        (
-                            self.col_positions[c],
-                            scrollpos_top - 1,
-                            self.col_positions[c],
-                            y_grid_stop,
-                            self.col_positions[c],
-                            scrollpos_top - 1,
-                            self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
-                            scrollpos_top - 1,
-                        )
-                        for c in range(grid_start_col, grid_end_col)
-                    ]
-                )
-            )
-            if points:
-                self.redraw_gridline(
-                    points=points,
-                    fill=self.PAR.ops.table_grid_fg,
-                    width=1,
-                    tag="g",
-                )
+        x_stop = min(last_col_line_pos, scrollpos_right)
+        y_stop = min(last_row_line_pos, scrollpos_bot)
         if redraw_table:
+            font = self.PAR.ops.table_font
+            dd_coords = self.dropdown.get_coords()
             selections = self.get_redraw_selections(text_start_row, grid_end_row, text_start_col, grid_end_col)
             sel_cells_bg = color_tup(self.PAR.ops.table_selected_cells_bg)
             sel_cols_bg = color_tup(self.PAR.ops.table_selected_columns_bg)
@@ -6004,7 +5919,6 @@ class MainTable(tk.Canvas):
             else:
                 alternate_color = None
                 dont_blend = tuple()
-
             if not self.PAR.ops.show_selected_cells_border:
                 override = (
                     color_tup(self.PAR.ops.table_selected_cells_fg),
@@ -6013,22 +5927,17 @@ class MainTable(tk.Canvas):
                 )
             else:
                 override = tuple()
+            for r in range(text_start_row, text_end_row):
+                rtopgridln = self.row_positions[r]
+                rbotgridln = self.row_positions[r + 1]
+                if rbotgridln - rtopgridln < self.table_txt_height:
+                    continue
+                datarn = self.datarn(r)
 
-            rows_ = tuple(range(text_start_row, text_end_row))
-            font = self.PAR.ops.table_font
-            dd_coords = self.dropdown.get_coords()
-            for c in range(text_start_col, text_end_col):
-                for r in rows_:
-                    rtopgridln = self.row_positions[r]
-                    rbotgridln = self.row_positions[r + 1]
-                    if rbotgridln - rtopgridln < self.table_txt_height:
-                        continue
+                for c in range(text_start_col, text_end_col):
                     cleftgridln = self.col_positions[c]
                     crightgridln = self.col_positions[c + 1]
-
-                    datarn = self.datarn(r)
                     datacn = self.datacn(c)
-
                     fill, dd_drawn = self.redraw_highlight_get_text_fg(
                         r=r,
                         c=c,
@@ -6046,69 +5955,35 @@ class MainTable(tk.Canvas):
                         dont_blend=(r, c) == dont_blend,
                         alternate_color=alternate_color,
                     )
-                    align = self.get_cell_kwargs(datarn, datacn, key="align")
-                    if align:
-                        align = align
-                    else:
+                    if not (align := self.get_cell_kwargs(datarn, datacn, key="align")):
                         align = self.align
-                    kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
-                    if align == "w":
-                        draw_x = cleftgridln + 3
-                        if kwargs:
-                            mw = crightgridln - cleftgridln - self.table_txt_height - 2
-                            self.redraw_dropdown(
-                                cleftgridln,
-                                rtopgridln,
-                                crightgridln,
-                                self.row_positions[r + 1],
-                                fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
-                                outline=fill,
-                                tag=f"dd_{r}_{c}",
-                                draw_outline=not dd_drawn,
-                                draw_arrow=mw >= 5,
-                                open_=dd_coords == (r, c),
-                            )
-                        else:
-                            mw = crightgridln - cleftgridln - 1
-                    elif align == "e":
-                        if kwargs:
-                            mw = crightgridln - cleftgridln - self.table_txt_height - 2
+                    if kwargs := self.get_cell_kwargs(datarn, datacn, key="dropdown"):
+                        mw = crightgridln - cleftgridln - self.table_txt_height - 2
+                        if align == "w":
+                            draw_x = cleftgridln + 3
+                        elif align == "e":
                             draw_x = crightgridln - 5 - self.table_txt_height
-                            self.redraw_dropdown(
-                                cleftgridln,
-                                rtopgridln,
-                                crightgridln,
-                                self.row_positions[r + 1],
-                                fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
-                                outline=fill,
-                                tag=f"dd_{r}_{c}",
-                                draw_outline=not dd_drawn,
-                                draw_arrow=mw >= 5,
-                                open_=dd_coords == (r, c),
-                            )
-                        else:
-                            mw = crightgridln - cleftgridln - 1
-                            draw_x = crightgridln - 3
-                    elif align == "center":
-                        if kwargs:
-                            mw = crightgridln - cleftgridln - self.table_txt_height - 2
+                        elif align == "center":
                             draw_x = cleftgridln + ceil((crightgridln - cleftgridln - self.table_txt_height) / 2)
-                            self.redraw_dropdown(
-                                cleftgridln,
-                                rtopgridln,
-                                crightgridln,
-                                self.row_positions[r + 1],
-                                fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
-                                outline=fill,
-                                tag=f"dd_{r}_{c}",
-                                draw_outline=not dd_drawn,
-                                draw_arrow=mw >= 5,
-                                open_=dd_coords == (r, c),
-                            )
-                        else:
-                            mw = crightgridln - cleftgridln - 1
+                        self.redraw_dropdown(
+                            cleftgridln,
+                            rtopgridln,
+                            crightgridln,
+                            self.row_positions[r + 1],
+                            fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
+                            outline=fill,
+                            draw_outline=not dd_drawn,
+                            draw_arrow=mw >= 5,
+                            open_=dd_coords == (r, c),
+                        )
+                    else:
+                        mw = crightgridln - cleftgridln - 1
+                        if align == "w":
+                            draw_x = cleftgridln + 3
+                        elif align == "e":
+                            draw_x = crightgridln - 3
+                        elif align == "center":
                             draw_x = cleftgridln + floor((crightgridln - cleftgridln) / 2)
-                    if not kwargs:
                         kwargs = self.get_cell_kwargs(datarn, datacn, key="checkbox")
                         if kwargs and mw > self.table_txt_height + 1:
                             box_w = self.table_txt_height + 1
@@ -6118,7 +5993,7 @@ class MainTable(tk.Canvas):
                                 draw_x += ceil(box_w / 2) + 1
                             mw -= box_w + 3
                             try:
-                                draw_check = self.data[datarn][datacn]
+                                draw_check = bool(self.data[datarn][datacn])
                             except Exception:
                                 draw_check = False
                             self.redraw_checkbox(
@@ -6128,92 +6003,137 @@ class MainTable(tk.Canvas):
                                 rtopgridln + self.table_txt_height + 3,
                                 fill=fill if kwargs["state"] == "normal" else self.PAR.ops.table_grid_fg,
                                 outline="",
-                                tag="cb",
                                 draw_check=draw_check,
                             )
-                    lns = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True).split("\n")
+                    lines = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
                     if (
-                        lns != [""]
-                        and mw > self.table_txt_width
-                        and not (
-                            (align == "w" and draw_x > scrollpos_right)
-                            or (align == "e" and cleftgridln + 5 > scrollpos_right)
-                            or (align == "center" and cleftgridln + 5 > scrollpos_right)
-                        )
+                        not lines
+                        or mw < self.table_txt_width
+                        or (align == "w" and draw_x > scrollpos_right)
+                        or (align == "e" and cleftgridln + 5 > scrollpos_right)
+                        or (align == "center" and cleftgridln + 5 > scrollpos_right)
                     ):
-                        draw_y = rtopgridln + self.table_first_ln_ins
-                        start_ln = int((scrollpos_top - rtopgridln) / self.table_xtra_lines_increment)
-                        if start_ln < 0:
-                            start_ln = 0
-                        draw_y += start_ln * self.table_xtra_lines_increment
-                        if draw_y + self.table_half_txt_height - 1 <= rbotgridln and len(lns) > start_ln:
-                            for txt in islice(lns, start_ln, None):
-                                if self.hidd_text:
-                                    iid, showing = self.hidd_text.popitem()
-                                    self.coords(iid, draw_x, draw_y)
-                                    if showing:
-                                        self.itemconfig(
-                                            iid,
-                                            text=txt,
-                                            fill=fill,
-                                            font=font,
-                                            anchor=align,
-                                        )
-                                    else:
-                                        self.itemconfig(
-                                            iid,
-                                            text=txt,
-                                            fill=fill,
-                                            font=font,
-                                            anchor=align,
-                                            state="normal",
-                                        )
-                                    self.tag_raise(iid)
+                        continue
+                    lines = lines.split("\n")
+                    start_ln = max(0, int((scrollpos_top - rtopgridln) / self.table_xtra_lines_increment))
+                    draw_y = rtopgridln + self.table_first_ln_ins + start_ln * self.table_xtra_lines_increment
+                    if draw_y + self.table_half_txt_height - 1 <= rbotgridln and len(lines) >= start_ln:
+                        for txt in islice(lines, start_ln, None):
+                            if self.hidd_text:
+                                iid, showing = self.hidd_text.popitem()
+                                self.coords(iid, draw_x, draw_y)
+                                if showing:
+                                    self.itemconfig(
+                                        iid,
+                                        text=txt,
+                                        fill=fill,
+                                        font=font,
+                                        anchor=align,
+                                    )
                                 else:
-                                    iid = self.create_text(
-                                        draw_x,
-                                        draw_y,
+                                    self.itemconfig(
+                                        iid,
                                         text=txt,
                                         fill=fill,
                                         font=font,
                                         anchor=align,
-                                        tag="t",
+                                        state="normal",
                                     )
-                                self.disp_text[iid] = True
-                                wd = self.bbox(iid)
-                                wd = wd[2] - wd[0]
-                                if wd > mw:
-                                    if align == "w":
-                                        txt = txt[: int(len(txt) * (mw / wd))]
+                                self.tag_raise(iid)
+                            else:
+                                iid = self.create_text(
+                                    draw_x,
+                                    draw_y,
+                                    text=txt,
+                                    fill=fill,
+                                    font=font,
+                                    anchor=align,
+                                    tag="t",
+                                )
+                            self.disp_text[iid] = True
+                            wd = self.bbox(iid)
+                            if (wd := wd[2] - wd[0]) > mw:
+                                if align == "w":
+                                    txt = txt[: int(len(txt) * (mw / wd))]
+                                    self.itemconfig(iid, text=txt)
+                                    wd = self.bbox(iid)
+                                    while wd[2] - wd[0] > mw:
+                                        txt = txt[:-1]
                                         self.itemconfig(iid, text=txt)
                                         wd = self.bbox(iid)
-                                        while wd[2] - wd[0] > mw:
-                                            txt = txt[:-1]
-                                            self.itemconfig(iid, text=txt)
-                                            wd = self.bbox(iid)
-                                    elif align == "e":
-                                        txt = txt[len(txt) - int(len(txt) * (mw / wd)) :]
+                                elif align == "e":
+                                    txt = txt[len(txt) - int(len(txt) * (mw / wd)) :]
+                                    self.itemconfig(iid, text=txt)
+                                    wd = self.bbox(iid)
+                                    while wd[2] - wd[0] > mw:
+                                        txt = txt[1:]
                                         self.itemconfig(iid, text=txt)
                                         wd = self.bbox(iid)
-                                        while wd[2] - wd[0] > mw:
-                                            txt = txt[1:]
-                                            self.itemconfig(iid, text=txt)
-                                            wd = self.bbox(iid)
-                                    elif align == "center":
-                                        self.c_align_cyc = cycle(self.centre_alignment_text_mod_indexes)
-                                        tmod = ceil((len(txt) - int(len(txt) * (mw / wd))) / 2)
-                                        txt = txt[tmod - 1 : -tmod]
+                                elif align == "center":
+                                    tmod = ceil((len(txt) - int(len(txt) * (mw / wd))) / 2)
+                                    txt = txt[tmod - 1 : -tmod]
+                                    self.itemconfig(iid, text=txt)
+                                    wd = self.bbox(iid)
+                                    while wd[2] - wd[0] > mw:
+                                        txt = txt[next(self.c_align_cyc)]
                                         self.itemconfig(iid, text=txt)
                                         wd = self.bbox(iid)
-                                        while wd[2] - wd[0] > mw:
-                                            txt = txt[next(self.c_align_cyc)]
-                                            self.itemconfig(iid, text=txt)
-                                            wd = self.bbox(iid)
-                                        self.coords(iid, draw_x, draw_y)
-                                draw_y += self.table_xtra_lines_increment
-                                if draw_y + self.table_half_txt_height - 1 > rbotgridln:
-                                    break
-        if redraw_table:
+                                    self.coords(iid, draw_x, draw_y)
+                            draw_y += self.table_xtra_lines_increment
+                            if draw_y + self.table_half_txt_height - 1 > rbotgridln:
+                                break
+            # manage horizontal grid lines
+            if self.PAR.ops.show_horizontal_grid and row_pos_exists:
+                if self.PAR.ops.horizontal_grid_to_end_of_window:
+                    x_grid_stop = scrollpos_right + can_width
+                else:
+                    if last_col_line_pos > scrollpos_right:
+                        x_grid_stop = x_stop + 1
+                    else:
+                        x_grid_stop = x_stop - 1
+                self.redraw_gridline(
+                    points=tuple(
+                        chain.from_iterable(
+                            (
+                                scrollpos_left - 1,
+                                self.row_positions[r],
+                                x_grid_stop,
+                                self.row_positions[r],
+                                scrollpos_left - 1,
+                                self.row_positions[r],
+                                scrollpos_left - 1,
+                                self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
+                            )
+                            for r in range(grid_start_row, grid_end_row)
+                        )
+                    )
+                )
+            # manage vertical grid lines
+            if self.PAR.ops.show_vertical_grid and col_pos_exists:
+                if self.PAR.ops.vertical_grid_to_end_of_window:
+                    y_grid_stop = scrollpos_bot + can_height
+                else:
+                    if last_row_line_pos > scrollpos_bot:
+                        y_grid_stop = y_stop + 1
+                    else:
+                        y_grid_stop = y_stop - 1
+                self.redraw_gridline(
+                    points=tuple(
+                        chain.from_iterable(
+                            (
+                                self.col_positions[c],
+                                scrollpos_top - 1,
+                                self.col_positions[c],
+                                y_grid_stop,
+                                self.col_positions[c],
+                                scrollpos_top - 1,
+                                self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
+                                scrollpos_top - 1,
+                            )
+                            for c in range(grid_start_col, grid_end_col)
+                        )
+                    ),
+                )
             for dct in (
                 self.hidd_text,
                 self.hidd_high,
@@ -6231,6 +6151,10 @@ class MainTable(tk.Canvas):
                         self.tag_raise(box.bd_iid)
                 if self.selected:
                     self.tag_raise(self.selected.iid)
+            if self.RI.disp_resize_lines:
+                self.tag_raise("rh")
+            if self.CH.disp_resize_lines:
+                self.tag_raise("rw")
         if redraw_header and self.show_header:
             self.CH.redraw_grid_and_text(
                 last_col_line_pos=last_col_line_pos,
@@ -6310,7 +6234,7 @@ class MainTable(tk.Canvas):
         # 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
+            r1, c1, _, _ = selection_box.coords
             if box_created(r1 if r is None else r, c1 if c is None else c, selection_box):
                 return
 
@@ -6729,7 +6653,7 @@ class MainTable(tk.Canvas):
 
     def get_redraw_selections(self, startr: int, endr: int, startc: int, endc: int) -> dict:
         d = defaultdict(set)
-        for item, box in self.get_selection_items():
+        for _, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
             if box.type_ == "cells":
                 for r in range(startr, endr):
@@ -6767,7 +6691,7 @@ class MainTable(tk.Canvas):
         if get_cells:
             s = {
                 (r, c)
-                for item, box in self.get_selection_items(cells=False, columns=False)
+                for _, box in self.get_selection_items(cells=False, columns=False)
                 for r in range(box.coords.from_r, box.coords.upto_r)
                 for c in range(0, len(self.col_positions) - 1)
             }
@@ -6776,7 +6700,7 @@ class MainTable(tk.Canvas):
         else:
             s = {
                 r
-                for item, box in self.get_selection_items(cells=False, columns=False)
+                for _, box in self.get_selection_items(cells=False, columns=False)
                 for r in range(box.coords.from_r, box.coords.upto_r)
             }
             if get_cells_as_rows:
@@ -6791,7 +6715,7 @@ class MainTable(tk.Canvas):
         if get_cells:
             s = {
                 (r, c)
-                for item, box in self.get_selection_items(cells=False, rows=False)
+                for _, box in self.get_selection_items(cells=False, rows=False)
                 for r in range(0, len(self.row_positions) - 1)
                 for c in range(box.coords.from_c, box.coords.upto_c)
             }
@@ -6800,7 +6724,7 @@ class MainTable(tk.Canvas):
         else:
             s = {
                 c
-                for item, box in self.get_selection_items(cells=False, rows=False)
+                for _, box in self.get_selection_items(cells=False, rows=False)
                 for c in range(box.coords.from_c, box.coords.upto_c)
             }
             if get_cells_as_cols:
@@ -6814,7 +6738,7 @@ class MainTable(tk.Canvas):
     ) -> set[tuple[int, int]]:
         return {
             (r, c)
-            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols)
+            for _, box in self.get_selection_items(rows=get_rows, columns=get_cols)
             for r in range(box.coords.from_r, box.coords.upto_r)
             for c in range(box.coords.from_c, box.coords.upto_c)
         }
@@ -6826,16 +6750,16 @@ class MainTable(tk.Canvas):
     ) -> Generator[tuple[int, int]]:
         yield from (
             (r, c)
-            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols)
+            for _, box in self.get_selection_items(rows=get_rows, columns=get_cols)
             for r in range(box.coords.from_r, box.coords.upto_r)
             for c in range(box.coords.from_c, box.coords.upto_c)
         )
 
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
-        return tuple(box.coords for item, box in self.get_selection_items())
+        return tuple(box.coords for _, box in self.get_selection_items())
 
     def get_all_selection_boxes_with_types(self) -> list[tuple[tuple[int, int, int, int], str]]:
-        return [Box_st(box.coords, box.type_) for item, box in self.get_selection_items()]
+        return [Box_st(box.coords, box.type_) for _, box in self.get_selection_items()]
 
     def all_selected(self) -> bool:
         return any(
@@ -6855,7 +6779,7 @@ class MainTable(tk.Canvas):
             and isinstance(c, int)
             and any(
                 box.coords.from_r <= r and box.coords.upto_r > r and box.coords.from_c <= c and box.coords.upto_c > c
-                for item, box in self.get_selection_items(
+                for _, box in self.get_selection_items(
                     rows=inc_rows,
                     columns=inc_cols,
                 )
@@ -6865,7 +6789,7 @@ class MainTable(tk.Canvas):
     def col_selected(self, c: int, cells: bool = False) -> bool:
         return isinstance(c, int) and any(
             box.coords.from_c <= c and box.coords.upto_c > c
-            for item, box in self.get_selection_items(
+            for _, box in self.get_selection_items(
                 cells=cells,
                 rows=False,
             )
@@ -6874,7 +6798,7 @@ class MainTable(tk.Canvas):
     def row_selected(self, r: int, cells: bool = False) -> bool:
         return isinstance(r, int) and any(
             box.coords.from_r <= r and box.coords.upto_r > r
-            for item, box in self.get_selection_items(
+            for _, box in self.get_selection_items(
                 cells=cells,
                 columns=False,
             )
@@ -6888,7 +6812,7 @@ class MainTable(tk.Canvas):
     ) -> list[int]:
         return [
             item
-            for item, box in self.get_selection_items(
+            for item, _ in self.get_selection_items(
                 columns=not exclude_columns,
                 rows=not exclude_rows,
                 cells=not exclude_cells,
@@ -7046,10 +6970,10 @@ class MainTable(tk.Canvas):
             )
             > curr_height
         ):
-            new_height = curr_height + self.table_xtra_lines_increment
-            space_bot = self.get_space_bot(r)
-            if new_height > space_bot:
-                new_height = space_bot
+            new_height = min(
+                curr_height + self.table_xtra_lines_increment,
+                self.scrollregion[3] - self.scrollregion[1] - self.row_positions[r],
+            )
             if new_height != curr_height:
                 self.text_editor.window.config(height=new_height)
                 if self.dropdown.open and self.dropdown.get_coords() == (r, c):
@@ -7284,10 +7208,8 @@ class MainTable(tk.Canvas):
                 sheet_h = int(
                     self.row_positions[-1] + 1 + self.PAR.ops.empty_vertical - (self.row_positions[r] + text_editor_h)
                 )
-        if win_h > 0:
-            win_h -= 1
-        if sheet_h > 0:
-            sheet_h -= 1
+        win_h = max(0, win_h - 1)
+        sheet_h = max(0, sheet_h - 1)
         return win_h if win_h >= sheet_h else sheet_h
 
     def get_dropdown_height_anchor(self, r: int, c: int, text_editor_h: int | None = None) -> tuple:
@@ -7301,8 +7223,7 @@ class MainTable(tk.Canvas):
                 win_h += self.min_row_height
             if i == 5:
                 break
-        if win_h > 500:
-            win_h = 500
+        win_h = min(win_h, 500)
         space_bot = self.get_space_bot(r, text_editor_h)
         space_top = int(self.row_positions[r])
         anchor = "nw"
@@ -7392,7 +7313,7 @@ class MainTable(tk.Canvas):
             self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.dropdown.window.tkraise()
         else:
-            self.dropdown.window = self.PAR.dropdown_class(
+            self.dropdown.window = self.PAR._dropdown_cls(
                 self.winfo_toplevel(),
                 **reset_kwargs,
                 close_dropdown_window=self.close_dropdown_window,
@@ -7437,12 +7358,11 @@ class MainTable(tk.Canvas):
             datacn = self.datacn(c)
             datarn = self.datarn(r)
             kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
-            pre_edit_value = self.get_cell_data(datarn, datacn)
             event_data = event_dict(
                 name="end_edit_table",
                 sheet=self.PAR.name,
                 widget=self,
-                cells_table={(datarn, datacn): pre_edit_value},
+                cells_table={(datarn, datacn): self.get_cell_data(datarn, datacn)},
                 key="??",
                 value=selection,
                 loc=Loc(r, c),
@@ -7451,30 +7371,12 @@ class MainTable(tk.Canvas):
                 boxes=self.get_boxes(),
                 selected=self.selected,
             )
-            if kwargs["select_function"] is not None:
-                kwargs["select_function"](event_data)
-            if self.edit_validation_func:
-                selection, edited = self.edit_validation_func(event_data), False
-                if selection is not None:
-                    edited = self.set_cell_data_undo(
-                        r,
-                        c,
-                        datarn=datarn,
-                        datacn=datacn,
-                        value=selection,
-                        redraw=not redraw,
-                    )
-            else:
-                edited = self.set_cell_data_undo(
-                    r,
-                    c,
-                    datarn=datarn,
-                    datacn=datacn,
-                    value=selection,
-                    redraw=not redraw,
-                )
-            if edited:
-                try_binding(self.extra_end_edit_cell_func, event_data)
+            try_binding(kwargs["select_function"], event_data)
+            selection = selection if not self.edit_validation_func else self.edit_validation_func(event_data)
+            if selection is not None:
+                edited = self.set_cell_data_undo(r, c, datarn=datarn, datacn=datacn, value=selection, redraw=not redraw)
+                if edited:
+                    try_binding(self.extra_end_edit_cell_func, event_data)
             self.recreate_all_selection_boxes()
         self.focus_set()
         self.hide_text_editor_and_dropdown(redraw=redraw)