tksheet 7.3.3__py3-none-any.whl → 7.4.0__py3-none-any.whl

tksheet/main_table.py

@@ -3,58 +3,34 @@ 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 .column_headers import ColumnHeaders
 from .constants import (
     USER_OS,
+    _test_str,
     bind_add_columns,
     bind_add_rows,
     bind_del_columns,
     bind_del_rows,
     ctrl_key,
+    font_value_error,
     rc_binding,
     text_editor_close_bindings,
     text_editor_newline_bindings,
     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,
@@ -72,6 +48,7 @@ from .functions import (
     cell_right_within_box,
     color_tup,
     consecutive_ranges,
+    data_to_displayed_idxs,
     diff_gen,
     diff_list,
     down_cell_within_box,
@@ -97,11 +74,13 @@ from .functions import (
     move_elements_by_mapping,
     new_tk_event,
     next_cell,
+    push_n,
     rounded_box_coords,
     span_idxs_post_move,
     stored_event_dict,
     try_binding,
     unpickle_obj,
+    wrap_text,
 )
 from .other_classes import (
     Box_nt,
@@ -119,24 +98,30 @@ from .other_classes import (
     SelectionBox,
     TextEditorStorage,
 )
-from .text_editor import (
-    TextEditor,
-)
-from .types import (
-    AnyIter,
-)
+from .row_index import RowIndex
+from .sorting import sort_selection
+from .text_editor import TextEditor
+from .tksheet_types import AnyIter
 
 
 class MainTable(tk.Canvas):
-    def __init__(self, *args, **kwargs):
+    def __init__(
+        self,
+        parent,
+        row_index_canvas: RowIndex,
+        column_headers_canvas: ColumnHeaders,
+        **kwargs,
+    ):
         super().__init__(
-            kwargs["parent"],
-            background=kwargs["parent"].ops.table_bg,
+            parent,
+            background=parent.ops.table_bg,
             highlightthickness=0,
         )
-        self.PAR = kwargs["parent"]
+        self.PAR = parent
         self.PAR_width = 0
         self.PAR_height = 0
+        self.cells_cache = None
+        self.table_txt_height, self.index_txt_height, self.header_txt_height = 0, 0, 0
         self.scrollregion = tuple()
         self.current_cursor = ""
         self.ctrl_b1_pressed = False
@@ -207,6 +192,9 @@ class MainTable(tk.Canvas):
 
         self.edit_validation_func = None
 
+        self.extra_begin_sort_cells_func = None
+        self.extra_end_sort_cells_func = None
+
         self.extra_begin_ctrl_c_func = None
         self.extra_end_ctrl_c_func = None
 
@@ -270,14 +258,19 @@ class MainTable(tk.Canvas):
         self.rc_insert_column_enabled = False
         self.rc_delete_row_enabled = False
         self.rc_insert_row_enabled = False
+        self.rc_sort_cells_enabled = False
+        self.rc_sort_row_enabled = False
+        self.rc_sort_column_enabled = False
+        self.rc_sort_rows_enabled = False
+        self.rc_sort_columns_enabled = False
         self.rc_popup_menus_enabled = False
         self.edit_cell_enabled = False
-        self.CH = kwargs["column_headers_canvas"]
+        self.CH = column_headers_canvas
         self.CH.MT = self
-        self.CH.RI = kwargs["row_index_canvas"]
-        self.RI = kwargs["row_index_canvas"]
+        self.CH.RI = row_index_canvas
+        self.RI = row_index_canvas
         self.RI.MT = self
-        self.RI.CH = kwargs["column_headers_canvas"]
+        self.RI.CH = column_headers_canvas
         self.TL = None  # is set from within TopLeftRectangle() __init__
         self.all_columns_displayed = True
         self.all_rows_displayed = True
@@ -311,9 +304,12 @@ class MainTable(tk.Canvas):
         self.txt_measure_canvas_text = self.txt_measure_canvas.create_text(0, 0, text="", font=self.PAR.ops.table_font)
 
         self.RI.set_width(self.PAR.ops.default_row_index_width)
+
+        self.char_widths = {}
         self.set_table_font_help()
         self.set_header_font_help()
         self.set_index_font_help()
+
         self.data = kwargs["data_reference"]
         if isinstance(self.data, (list, tuple)):
             self.data = kwargs["data_reference"]
@@ -362,10 +358,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()
 
@@ -377,7 +371,7 @@ class MainTable(tk.Canvas):
                 super().event_generate(*args, **kwargs)
 
     def refresh(self, event: object = None) -> None:
-        self.main_table_redraw_grid_and_text(True, True)
+        self.PAR.set_refresh_timer()
 
     def window_configured(self, event: object) -> None:
         w = self.PAR.winfo_width()
@@ -483,7 +477,7 @@ class MainTable(tk.Canvas):
             dash=dash,
             width=3,
             outline=self.PAR.ops.resizing_line_fg if outline is None else outline,
-            tag="ctrl",
+            tags="ctrl",
         )
         if delete_on_timer:
             self.after(1500, self.delete_ctrl_outlines)
@@ -649,6 +643,8 @@ class MainTable(tk.Canvas):
         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):
@@ -742,13 +738,13 @@ class MainTable(tk.Canvas):
         dash: tuple[int, int],
         width: int,
         outline: str,
-        tag: str | tuple[str, ...],
+        tags: str | tuple[str, ...],
     ) -> None:
         if self.hidd_ctrl_outline:
             t, sh = self.hidd_ctrl_outline.popitem()
             self.coords(t, x1, y1, x2, y2)
             if sh:
-                self.itemconfig(t, fill=fill, dash=dash, width=width, outline=outline, tag=tag)
+                self.itemconfig(t, fill=fill, dash=dash, width=width, outline=outline, tags=tags)
             else:
                 self.itemconfig(
                     t,
@@ -756,7 +752,7 @@ class MainTable(tk.Canvas):
                     dash=dash,
                     width=width,
                     outline=outline,
-                    tag=tag,
+                    tags=tags,
                     state="normal",
                 )
             self.lift(t)
@@ -770,7 +766,7 @@ class MainTable(tk.Canvas):
                 dash=dash,
                 width=width,
                 outline=outline,
-                tag=tag,
+                tags=tags,
             )
         self.disp_ctrl_outline[t] = True
 
@@ -809,15 +805,20 @@ class MainTable(tk.Canvas):
         )
         return s, writer
 
-    def ctrl_c(self, event=None) -> None | EventDataDict:
-        if not self.selected:
-            return
-        event_data = event_dict(
-            name="begin_ctrl_c",
+    def new_event_dict(self, name: str, boxes: dict | None = None, state: bool = False) -> EventDataDict:
+        return event_dict(
+            name=name,
             sheet=self.PAR.name,
             widget=self,
+            boxes=self.get_boxes() if boxes is None else boxes,
             selected=self.selected,
+            sheet_state=self.copy_sheet_state() if state else None,
         )
+
+    def ctrl_c(self, event=None) -> None | EventDataDict:
+        if not self.selected:
+            return
+        event_data = self.new_event_dict("begin_ctrl_c")
         boxes, maxrows = self.get_ctrl_x_c_boxes()
         event_data["selection_boxes"] = boxes
         s, writer = self.io_csv_writer()
@@ -862,12 +863,7 @@ class MainTable(tk.Canvas):
     def ctrl_x(self, event=None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
-        event_data = event_dict(
-            name="edit_table",
-            sheet=self.PAR.name,
-            widget=self,
-            selected=self.selected,
-        )
+        event_data = self.new_event_dict("edit_table")
         boxes, maxrows = self.get_ctrl_x_c_boxes()
         event_data["selection_boxes"] = boxes
         s, writer = self.io_csv_writer()
@@ -943,17 +939,64 @@ class MainTable(tk.Canvas):
             self.PAR.emit_event("<<Cut>>", event_data)
         return event_data
 
+    def sort_boxes(
+        self,
+        event: tk.Event | None = None,
+        boxes: AnyIter[int, int, int, int] | None = None,
+        reverse: bool = False,
+        row_wise: bool = False,
+        validation: bool = True,
+        key: Callable | None = None,
+        undo: bool = True,
+    ) -> EventDataDict:
+        if boxes is None:
+            boxes = self.get_boxes()
+        if not boxes:
+            boxes = [(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1)]
+        event_data = self.new_event_dict("edit_table", boxes=boxes)
+        try_binding(self.extra_begin_sort_cells_func, event_data)
+        for r1, c1, r2, c2 in boxes:
+            data = sort_selection(
+                [[self.get_cell_data(self.datarn(r), self.datacn(c)) for c in range(c1, c2)] for r in range(r1, r2)],
+                reverse=reverse,
+                key=key,
+                row_wise=row_wise,
+            )
+            for ir, r in enumerate(range(r1, r2)):
+                data_r = self.datarn(r)
+                for ic, c in enumerate(range(c1, c2)):
+                    data_c = self.datacn(c)
+                    val = data[ir][ic]
+                    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, (data_r, data_c))))
+                            is not None
+                        )
+                    ):
+                        event_data = self.event_data_set_cell(
+                            datarn=data_r,
+                            datacn=data_c,
+                            value=val,
+                            event_data=event_data,
+                        )
+        if event_data["cells"]["table"]:
+            if undo and self.undo_enabled:
+                self.undo_stack.append(stored_event_dict(event_data))
+            try_binding(self.extra_end_sort_cells_func, event_data, "end_edit_table")
+            self.sheet_modified(event_data)
+            self.PAR.emit_event("<<SheetModified>>", event_data)
+            self.refresh()
+        return event_data
+
     def ctrl_v(self, event: object = None, validation: bool = True) -> None | EventDataDict:
         if not self.PAR.ops.paste_can_expand_x and len(self.col_positions) == 1:
             return
         if not self.PAR.ops.paste_can_expand_y and len(self.row_positions) == 1:
             return
-        event_data = event_dict(
-            name="edit_table",
-            sheet=self.PAR.name,
-            widget=self,
-            selected=self.selected,
-        )
+        event_data = self.new_event_dict("edit_table", state=True)
         if self.selected:
             selected_r = self.selected.box.from_r
             selected_c = self.selected.box.from_c
@@ -1210,12 +1253,7 @@ class MainTable(tk.Canvas):
     def delete_key(self, event: object = None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
-        event_data = event_dict(
-            name="edit_table",
-            sheet=self.PAR.name,
-            widget=self,
-            selected=self.selected,
-        )
+        event_data = self.new_event_dict("edit_table")
         boxes = self.get_boxes()
         event_data["selection_boxes"] = boxes
         if not try_binding(self.extra_begin_delete_key_func, event_data, "begin_delete"):
@@ -1290,7 +1328,6 @@ class MainTable(tk.Canvas):
         move_data: bool = True,
         move_widths: bool = True,
         create_selections: bool = True,
-        data_indexes: bool = False,
         event_data: EventDataDict | None = None,
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_column_widths = {}
@@ -1299,22 +1336,17 @@ class MainTable(tk.Canvas):
             if totalcols:
                 totalcols += 1
             totalcols = self.equalize_data_row_lengths(at_least_cols=totalcols)
-        if event_data is None:
-            event_data = event_dict(
-                name="move_columns",
-                sheet=self.PAR.name,
-                widget=self,
-                boxes=self.get_boxes(),
-                selected=self.selected,
-            )
+        if not event_data:
+            event_data = self.new_event_dict("move_columns", state=True)
+        if not event_data["moved"]["columns"]:
             event_data["moved"]["columns"] = {
                 "data": data_new_idxs,
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
         event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
-        if move_widths and disp_new_idxs and (not data_indexes or self.all_columns_displayed):
-            self.deselect("all", run_binding=False, redraw=False)
+
+        if move_widths and disp_new_idxs:
             self.set_col_positions(
                 itr=move_elements_by_mapping(
                     self.get_column_widths(),
@@ -1328,6 +1360,7 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
+                self.deselect("all", run_binding=False, redraw=False)
                 for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
                         0,
@@ -1337,6 +1370,8 @@ class MainTable(tk.Canvas):
                         "columns",
                         run_binding=True,
                     )
+            else:
+                self.recreate_all_selection_boxes()
         if move_data:
             self.data = list(
                 map(
@@ -1490,29 +1525,54 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
     ) -> tuple[dict[int, int], dict[int, int], int, dict[int, int]]:
         if not data_indexes or self.all_rows_displayed:
-            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+            disp_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
+            data_new_idxs = dict(disp_new_idxs)
         else:
             disp_new_idxs = {}
+            data_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
         # move_to can be len and fix_data_len() takes index so - 1
         fix_len = (move_to - 1) if move_to else move_to
         if not self.all_rows_displayed and not data_indexes:
             fix_len = self.datarn(fix_len)
         self.fix_data_len(fix_len)
         totalrows = max(self.total_data_rows(), len(self.row_positions) - 1)
-        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         if not self.all_rows_displayed and not data_indexes:
-            data_new_idxs = dict(
-                zip(
+            keep = set(map(self.datarn, to_move))
+            data_new_idxs = {
+                k: v
+                for k, v in zip(
                     move_elements_by_mapping(
                         self.displayed_rows,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
                     ),
                     self.displayed_rows,
-                ),
-            )
+                )
+                if k in keep
+            }
         return data_new_idxs, dict(zip(data_new_idxs.values(), data_new_idxs)), totalrows, disp_new_idxs
 
+    def move_rows_data(
+        self,
+        data_new_idxs: dict[int, int],
+        data_old_idxs: dict[int, int],
+        maxidx: int,
+    ) -> None:
+        self.data = move_elements_by_mapping(
+            self.data,
+            data_new_idxs,
+            data_old_idxs,
+        )
+        self.RI.fix_index(maxidx)
+        if isinstance(self._row_index, list) and self._row_index:
+            self._row_index = move_elements_by_mapping(self._row_index, data_new_idxs, data_old_idxs)
+
     def move_rows_adjust_options_dict(
         self,
         data_new_idxs: dict[int, int],
@@ -1522,8 +1582,9 @@ class MainTable(tk.Canvas):
         move_data: bool = True,
         move_heights: bool = True,
         create_selections: bool = True,
-        data_indexes: bool = False,
         event_data: EventDataDict | None = None,
+        undo_modification: EventDataDict | None = None,
+        node_change: None | tuple[str, str, int] = None,
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_row_heights = {}
         if not isinstance(totalrows, int):
@@ -1533,54 +1594,33 @@ class MainTable(tk.Canvas):
                 max(data_new_idxs.values(), default=0),
             )
             self.fix_data_len(totalrows - 1)
-        if event_data is None:
-            event_data = event_dict(
-                name="move_rows",
-                sheet=self.PAR.name,
-                widget=self,
-                boxes=self.get_boxes(),
-                selected=self.selected,
-            )
+        if not event_data:
+            event_data = self.new_event_dict("move_rows", state=True)
+        if not event_data["moved"]["rows"]:
             event_data["moved"]["rows"] = {
                 "data": data_new_idxs,
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
         event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
-        if move_heights and disp_new_idxs and (not data_indexes or self.all_rows_displayed):
-            self.deselect("all", run_binding=False, redraw=False)
-            self.set_row_positions(
-                itr=move_elements_by_mapping(
-                    self.get_row_heights(),
-                    disp_new_idxs,
-                    dict(
-                        zip(
-                            disp_new_idxs.values(),
-                            disp_new_idxs,
-                        )
-                    ),
-                )
-            )
-            if create_selections:
-                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
-                    self.create_selection_box(
-                        boxst,
-                        0,
-                        boxend,
-                        len(self.col_positions) - 1,
-                        "rows",
-                        run_binding=True,
-                    )
+
         if move_data:
-            self.data = move_elements_by_mapping(
-                self.data,
-                data_new_idxs,
-                data_old_idxs,
-            )
             maxidx = len_to_idx(totalrows)
-            self.RI.fix_index(maxidx)
-            if isinstance(self._row_index, list) and self._row_index:
-                self._row_index = move_elements_by_mapping(self._row_index, data_new_idxs, data_old_idxs)
+            if self.PAR.ops.treeview:
+                two_step_move = self.RI.move_rows_mod_nodes(
+                    data_new_idxs=data_new_idxs,
+                    data_old_idxs=data_old_idxs,
+                    disp_new_idxs=disp_new_idxs,
+                    maxidx=maxidx,
+                    event_data=event_data,
+                    undo_modification=undo_modification,
+                    node_change=node_change,
+                )
+                data_new_idxs, data_old_idxs, disp_new_idxs, event_data = next(two_step_move)
+                if not data_new_idxs and not disp_new_idxs:
+                    return data_new_idxs, disp_new_idxs, event_data
+            else:
+                self.move_rows_data(data_new_idxs, data_old_idxs, maxidx)
             maxidx = self.get_max_row_idx(maxidx)
             full_new_idxs = self.get_full_new_idxs(
                 max_idx=maxidx,
@@ -1598,6 +1638,9 @@ class MainTable(tk.Canvas):
             self.RI.cell_options = {full_new_idxs[k]: v for k, v in self.RI.cell_options.items()}
             self.RI.tree_rns = {v: full_new_idxs[k] for v, k in self.RI.tree_rns.items()}
             self.displayed_rows = sorted(full_new_idxs[k] for k in self.displayed_rows)
+            if self.PAR.ops.treeview:
+                next(two_step_move)
+
             if self.named_spans:
                 totalcols = self.total_data_cols()
                 new_ops = self.PAR.create_options_from_span
@@ -1696,6 +1739,33 @@ class MainTable(tk.Canvas):
                                         del self.cell_options[(full_new_idxs[k], c)][span["type_"]]
                     # finally, change the span coords
                     span["from_r"], span["upto_r"] = newfrom, newupto
+
+        if move_heights and disp_new_idxs:
+            self.set_row_positions(
+                itr=move_elements_by_mapping(
+                    self.get_row_heights(),
+                    disp_new_idxs,
+                    dict(
+                        zip(
+                            disp_new_idxs.values(),
+                            disp_new_idxs,
+                        )
+                    ),
+                )
+            )
+            if create_selections:
+                self.deselect("all", run_binding=False, redraw=False)
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
+                    self.create_selection_box(
+                        boxst,
+                        0,
+                        boxend,
+                        len(self.col_positions) - 1,
+                        "rows",
+                        run_binding=True,
+                    )
+            else:
+                self.recreate_all_selection_boxes()
         return data_new_idxs, disp_new_idxs, event_data
 
     def get_max_row_idx(self, maxidx: int | None = None) -> int:
@@ -1812,7 +1882,7 @@ class MainTable(tk.Canvas):
             event_data["cells"]["table"][k] = self.get_cell_data(k[0], k[1])
         return event_data
 
-    def restore_options_named_spans(self, modification: EventDataDict) -> None:
+    def restore_sheet_state(self, modification: EventDataDict) -> None:
         if "cell_options" in modification["options"]:
             self.cell_options = modification["options"]["cell_options"]
         if "column_options" in modification["options"]:
@@ -1829,17 +1899,25 @@ class MainTable(tk.Canvas):
             self.tagged_rows = modification["options"]["tagged_rows"]
         if "tagged_columns" in modification["options"]:
             self.tagged_columns = modification["options"]["tagged_columns"]
-        self.named_spans = {
-            k: mod_span_widget(unpickle_obj(v), self.PAR) for k, v in modification["named_spans"].items()
-        }
+        if modification["named_spans"]:
+            self.named_spans = {
+                k: mod_span_widget(unpickle_obj(v), self.PAR) for k, v in modification["named_spans"].items()
+            }
+        if modification["sheet_state"]:
+            self.RI.tree_open_ids = modification["sheet_state"]["tree_open_ids"]
+            self.row_positions = modification["sheet_state"]["row_positions"]
+            self.col_positions = modification["sheet_state"]["col_positions"]
+            self.displayed_rows = modification["sheet_state"]["displayed_rows"]
+            self.displayed_columns = modification["sheet_state"]["displayed_columns"]
+            self.all_rows_displayed = modification["sheet_state"]["all_rows_displayed"]
+            self.all_columns_displayed = modification["sheet_state"]["all_columns_displayed"]
+            self.saved_row_heights = modification["sheet_state"]["saved_row_heights"]
+            self.saved_column_widths = modification["sheet_state"]["saved_column_widths"]
+            self.recreate_all_selection_boxes()
 
     def undo_modification_invert_event(self, modification: EventDataDict, name: str = "undo") -> EventDataDict:
         self.deselect("all", redraw=False)
-        event_data = event_dict(
-            name=modification["eventname"],
-            sheet=self.PAR.name,
-            widget=self,
-        )
+        event_data = self.new_event_dict(modification["eventname"], state=True)
         event_data["selection_boxes"] = modification["selection_boxes"]
         event_data["selected"] = modification["selected"]
         saved_cells = False
@@ -1870,7 +1948,6 @@ class MainTable(tk.Canvas):
                 "data": data_new_idxs,
                 "displayed": disp_new_idxs,
             }
-            self.restore_options_named_spans(modification)
 
         if modification["moved"]["rows"]:
             totalrows = max(self.total_data_rows(), max(modification["moved"]["rows"]["data"].values()))
@@ -1890,12 +1967,12 @@ class MainTable(tk.Canvas):
                     )
                 ),
                 event_data=event_data,
+                undo_modification=modification,
             )
             event_data["moved"]["rows"] = {
                 "data": data_new_idxs,
                 "displayed": disp_new_idxs,
             }
-            self.restore_options_named_spans(modification)
 
         if modification["added"]["rows"]:
             self.deselect("all", run_binding=False, redraw=False)
@@ -1906,8 +1983,8 @@ class MainTable(tk.Canvas):
             event_data = self.delete_rows_displayed(
                 rows=tuple(reversed(modification["added"]["rows"]["row_heights"])),
                 event_data=event_data,
+                restored_state=True,
             )
-            self.displayed_rows = modification["added"]["rows"]["displayed_rows"]
 
         if modification["added"]["columns"]:
             self.deselect("all", run_binding=False, redraw=False)
@@ -1918,21 +1995,21 @@ class MainTable(tk.Canvas):
             event_data = self.delete_columns_displayed(
                 cols=tuple(reversed(modification["added"]["columns"]["column_widths"])),
                 event_data=event_data,
+                restored_state=True,
             )
-            self.displayed_columns = modification["added"]["columns"]["displayed_columns"]
 
         if modification["deleted"]["rows"] or modification["deleted"]["row_heights"]:
+            event_data["treeview"] = modification["treeview"]
             self.add_rows(
                 rows=modification["deleted"]["rows"],
                 index=modification["deleted"]["index"],
                 row_heights=modification["deleted"]["row_heights"],
                 event_data=event_data,
-                displayed_rows=modification["deleted"]["displayed_rows"],
                 create_ops=False,
-                create_selections=not modification["eventname"].startswith("edit"),
+                create_selections=False,
                 add_col_positions=False,
+                restored_state=True,
             )
-            self.restore_options_named_spans(modification)
 
         if modification["deleted"]["columns"] or modification["deleted"]["column_widths"]:
             self.add_columns(
@@ -1940,12 +2017,11 @@ class MainTable(tk.Canvas):
                 header=modification["deleted"]["header"],
                 column_widths=modification["deleted"]["column_widths"],
                 event_data=event_data,
-                displayed_columns=modification["deleted"]["displayed_columns"],
                 create_ops=False,
-                create_selections=not modification["eventname"].startswith("edit"),
+                create_selections=False,
                 add_row_positions=False,
+                restored_state=True,
             )
-            self.restore_options_named_spans(modification)
 
         if modification["eventname"].startswith(("edit", "move")):
             if not saved_cells:
@@ -1958,6 +2034,8 @@ class MainTable(tk.Canvas):
         elif modification["eventname"].startswith("delete"):
             event_data["eventname"] = modification["eventname"].replace("delete", "add")
 
+        self.restore_sheet_state(modification)
+
         if not modification["eventname"].startswith("move") and (
             len(self.row_positions) > 1 or len(self.col_positions) > 1
         ):
@@ -2014,9 +2092,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",
@@ -2041,9 +2119,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",
@@ -2394,15 +2472,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()
             ):
@@ -2854,7 +2928,7 @@ class MainTable(tk.Canvas):
             self.menu_add_command(
                 self.CH.ch_rc_popup_menu,
                 label=self.PAR.ops.delete_columns_label,
-                command=self.rc_delete_columns,
+                command=self.delete_columns,
                 **mnkwgs,
             )
         if self.rc_insert_column_enabled:
@@ -2880,7 +2954,7 @@ class MainTable(tk.Canvas):
             self.menu_add_command(
                 self.RI.ri_rc_popup_menu,
                 label=self.PAR.ops.delete_rows_label,
-                command=self.rc_delete_rows,
+                command=self.delete_rows,
                 **mnkwgs,
             )
         if self.rc_insert_row_enabled:
@@ -2902,6 +2976,99 @@ class MainTable(tk.Canvas):
                 command=lambda: self.rc_add_rows("below"),
                 **mnkwgs,
             )
+        if self.rc_sort_cells_enabled:
+            self.menu_add_command(
+                self.rc_popup_menu,
+                label=self.PAR.ops.sort_cells_label,
+                accelerator=self.PAR.ops.sort_cells_accelerator,
+                command=self.sort_boxes,
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.rc_popup_menu,
+                label=self.PAR.ops.sort_cells_reverse_label,
+                accelerator=self.PAR.ops.sort_cells_reverse_accelerator,
+                command=lambda: self.sort_boxes(reverse=True),
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.rc_popup_menu,
+                label=self.PAR.ops.sort_cells_x_label,
+                accelerator=self.PAR.ops.sort_cells_x_accelerator,
+                command=lambda: self.sort_boxes(row_wise=True),
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.rc_popup_menu,
+                label=self.PAR.ops.sort_cells_x_reverse_label,
+                accelerator=self.PAR.ops.sort_cells_x_reverse_accelerator,
+                command=lambda: self.sort_boxes(reverse=True, row_wise=True),
+                **mnkwgs,
+            )
+        # row index sort rows cells
+        if self.rc_sort_row_enabled:
+            self.menu_add_command(
+                self.RI.ri_rc_popup_menu,
+                label=self.PAR.ops.sort_row_label,
+                accelerator=self.PAR.ops.sort_row_accelerator,
+                command=self.RI._sort_rows,
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.RI.ri_rc_popup_menu,
+                label=self.PAR.ops.sort_row_reverse_label,
+                accelerator=self.PAR.ops.sort_row_reverse_accelerator,
+                command=lambda: self.RI._sort_rows(reverse=True),
+                **mnkwgs,
+            )
+        # header sort columns cells
+        if self.rc_sort_column_enabled:
+            self.menu_add_command(
+                self.CH.ch_rc_popup_menu,
+                label=self.PAR.ops.sort_column_label,
+                accelerator=self.PAR.ops.sort_column_accelerator,
+                command=self.CH._sort_columns,
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.CH.ch_rc_popup_menu,
+                label=self.PAR.ops.sort_column_reverse_label,
+                accelerator=self.PAR.ops.sort_column_reverse_accelerator,
+                command=lambda: self.CH._sort_columns(reverse=True),
+                **mnkwgs,
+            )
+        # row index sort columns by row
+        if self.rc_sort_columns_enabled:
+            self.menu_add_command(
+                self.RI.ri_rc_popup_menu,
+                label=self.PAR.ops.sort_columns_label,
+                accelerator=self.PAR.ops.sort_columns_accelerator,
+                command=self.RI._sort_columns_by_row,
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.RI.ri_rc_popup_menu,
+                label=self.PAR.ops.sort_columns_reverse_label,
+                accelerator=self.PAR.ops.sort_columns_reverse_accelerator,
+                command=lambda: self.RI._sort_columns_by_row(reverse=True),
+                **mnkwgs,
+            )
+        # header sort rows by column
+        if self.rc_sort_rows_enabled:
+            self.menu_add_command(
+                self.CH.ch_rc_popup_menu,
+                label=self.PAR.ops.sort_rows_label,
+                accelerator=self.PAR.ops.sort_rows_accelerator,
+                command=self.CH._sort_rows_by_column,
+                **mnkwgs,
+            )
+            self.menu_add_command(
+                self.CH.ch_rc_popup_menu,
+                label=self.PAR.ops.sort_rows_reverse_label,
+                accelerator=self.PAR.ops.sort_rows_reverse_accelerator,
+                command=lambda: self.CH._sort_rows_by_column(reverse=True),
+                **mnkwgs,
+            )
         for label, func in self.extra_table_rc_menu_funcs.items():
             self.menu_add_command(
                 self.rc_popup_menu,
@@ -3072,6 +3239,16 @@ class MainTable(tk.Canvas):
             self.rc_insert_row_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
+        if binding in ("all", "sort_cells"):
+            self.rc_sort_cells_enabled = True
+        if binding in ("all", "sort_row"):
+            self.rc_sort_row_enabled = True
+        if binding in ("all", "sort_column", "sort_col"):
+            self.rc_sort_column_enabled = True
+        if binding in ("all", "sort_columns", "sort_cols"):
+            self.rc_sort_columns_enabled = True
+        if binding in ("all", "sort_rows"):
+            self.rc_sort_rows_enabled = True
         if binding in ("all", "right_click_popup_menu", "rc_popup_menu", "rc_menu"):
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
@@ -3145,6 +3322,16 @@ class MainTable(tk.Canvas):
             self.rc_insert_column_enabled = False
         if binding in bind_add_rows:
             self.rc_insert_row_enabled = False
+        if binding in ("all", "sort_cells"):
+            self.rc_sort_cells_enabled = False
+        if binding in ("all", "sort_row"):
+            self.rc_sort_row_enabled = False
+        if binding in ("all", "sort_column", "sort_col"):
+            self.rc_sort_column_enabled = False
+        if binding in ("all", "sort_columns", "sort_cols"):
+            self.rc_sort_columns_enabled = False
+        if binding in ("all", "sort_rows"):
+            self.rc_sort_rows_enabled = False
         if binding in ("all", "right_click_popup_menu", "rc_popup_menu", "rc_menu"):
             self.rc_popup_menus_enabled = False
         if binding in ("all", "right_click_select", "rc_select"):
@@ -3290,12 +3477,12 @@ class MainTable(tk.Canvas):
             t, sh = self.hidd_resize_lines.popitem()
             self.coords(t, x1, y1, x2, y2)
             if sh:
-                self.itemconfig(t, width=width, fill=fill, tag=tag)
+                self.itemconfig(t, width=width, fill=fill, tags=tag)
             else:
-                self.itemconfig(t, width=width, fill=fill, tag=tag, state="normal")
+                self.itemconfig(t, width=width, fill=fill, tags=tag, state="normal")
             self.lift(t)
         else:
-            t = self.create_line(x1, y1, x2, y2, width=width, fill=fill, tag=tag)
+            t = self.create_line(x1, y1, x2, y2, width=width, fill=fill, tags=tag)
         self.disp_resize_lines[t] = True
 
     def delete_resize_lines(self):
@@ -3803,38 +3990,14 @@ class MainTable(tk.Canvas):
             c_pc = 0.0
         old_min_row_height = int(self.min_row_height)
         old_default_row_height = int(self.get_default_row_height())
-        self.set_table_font(
-            table_font,
-            reset_row_positions=False,
-        )
-        self.set_index_font(index_font)
+        self.set_table_font(table_font, row_heights=False)
+        self.set_index_font(index_font, row_heights=False)
         self.set_header_font(header_font)
         if self.PAR.ops.set_cell_sizes_on_zoom:
             self.set_all_cell_sizes_to_text()
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         elif not self.PAR.ops.set_cell_sizes_on_zoom:
-            default_row_height = self.get_default_row_height()
-            self.row_positions = list(
-                accumulate(
-                    chain(
-                        [0],
-                        (
-                            (
-                                self.min_row_height
-                                if h == old_min_row_height
-                                else (
-                                    default_row_height
-                                    if h == old_default_row_height
-                                    else self.min_row_height
-                                    if h < self.min_row_height
-                                    else h
-                                )
-                            )
-                            for h in self.gen_row_heights()
-                        ),
-                    )
-                )
-            )
+            self.change_font_manage_row_heights(old_min_row_height, old_default_row_height)
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             self.recreate_all_selection_boxes()
         self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
@@ -3878,13 +4041,20 @@ class MainTable(tk.Canvas):
         return b[2] - b[0], b[3] - b[1]
 
     def get_lines_cell_height(self, n: int, font: None | FontTuple = None) -> int:
-        return (
-            self.get_txt_h(
+        if font == self.PAR.ops.table_font:
+            return 3 + (n * self.table_txt_height)
+
+        elif font == self.PAR.ops.index_font:
+            return 3 + (n * self.index_txt_height)
+
+        elif font == self.PAR.ops.header_font:
+            return 3 + (n * self.header_txt_height)
+
+        else:
+            return 3 + self.get_txt_h(
                 txt="\n".join("|" for _ in range(n)) if n > 1 else "|",
-                font=self.PAR.ops.table_font if font is None else font,
+                font=font,
             )
-            + 5
-        )
 
     def set_min_column_width(self, width: int) -> None:
         if width:
@@ -3915,92 +4085,101 @@ class MainTable(tk.Canvas):
                 )
         return self.PAR.ops.default_header_height
 
-    def set_table_font(self, newfont: tuple | None = None, reset_row_positions: bool = False) -> tuple[str, int, str]:
+    def check_font(self, newfont: tuple) -> None:
+        if (
+            not isinstance(newfont, tuple)
+            or len(newfont) != 3
+            or not isinstance(newfont[0], str)
+            or not isinstance(newfont[1], int)
+            or not isinstance(newfont[2], str)
+        ):
+            raise ValueError(font_value_error)
+
+    def set_table_font(self, newfont: tuple | None = None, row_heights: bool = True) -> tuple[str, int, str]:
         if newfont:
-            if not isinstance(newfont, tuple):
-                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')"
-                )
+            self.check_font(newfont)
             self.PAR.ops.table_font = FontTuple(*newfont)
+            old_min_row_height = int(self.min_row_height)
+            old_default_row_height = int(self.get_default_row_height())
             self.set_table_font_help()
-            if reset_row_positions:
-                if isinstance(reset_row_positions, bool):
-                    self.reset_row_positions()
-                else:
-                    self.set_row_positions(itr=reset_row_positions)
+            if row_heights:
+                self.change_font_manage_row_heights(old_min_row_height, old_default_row_height)
                 self.recreate_all_selection_boxes()
         return self.PAR.ops.table_font
 
     def set_table_font_help(self):
+        self.table_font = self.PAR.ops.table_font
+        if self.PAR.ops.table_font not in self.char_widths:
+            self.char_widths[self.PAR.ops.table_font] = {}
+        self.table_test_str_w = self.get_txt_w(_test_str)
         self.table_txt_width, self.table_txt_height = self.get_txt_dimensions("|", self.PAR.ops.table_font)
-        self.table_half_txt_height = ceil(self.table_txt_height / 2)
-        if not self.table_half_txt_height % 2:
-            self.table_first_ln_ins = self.table_half_txt_height + 2
-        else:
-            self.table_first_ln_ins = self.table_half_txt_height + 3
-        self.min_row_height = int(self.table_first_ln_ins * 2.22)
-        self.table_xtra_lines_increment = int(self.table_txt_height)
-        if self.min_row_height < 12:
-            self.min_row_height = 12
+        self.min_row_height = max(6, self.table_txt_height, self.index_txt_height) + 6
 
-    def set_header_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
+    def set_index_font(self, newfont: tuple | None = None, row_heights: bool = True) -> tuple[str, int, str]:
         if newfont:
-            if not isinstance(newfont, tuple):
-                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')"
-                )
-            self.PAR.ops.header_font = FontTuple(*newfont)
-            self.set_header_font_help()
-            self.recreate_all_selection_boxes()
-        return self.PAR.ops.header_font
+            self.check_font(newfont)
+            self.PAR.ops.index_font = FontTuple(*newfont)
+            old_min_row_height = int(self.min_row_height)
+            old_default_row_height = int(self.get_default_row_height())
+            self.set_index_font_help()
+            if row_heights:
+                self.change_font_manage_row_heights(old_min_row_height, old_default_row_height)
+                self.recreate_all_selection_boxes()
+        return self.PAR.ops.index_font
 
-    def set_header_font_help(self):
-        self.header_txt_width, self.header_txt_height = self.get_txt_dimensions("|", self.PAR.ops.header_font)
-        self.header_half_txt_height = ceil(self.header_txt_height / 2)
-        if not self.header_half_txt_height % 2:
-            self.header_first_ln_ins = self.header_half_txt_height + 2
-        else:
-            self.header_first_ln_ins = self.header_half_txt_height + 3
-        self.header_xtra_lines_increment = self.header_txt_height
-        self.min_header_height = int(self.header_first_ln_ins * 2.22)
-        if (
-            isinstance(self.PAR.ops.default_header_height, int)
-            and self.PAR.ops.default_header_height < self.min_header_height
-        ):
-            self.PAR.ops.default_header_height = int(self.min_header_height)
-        self.CH.set_height(self.get_default_header_height(), set_TL=True)
+    def set_index_font_help(self):
+        self.RI.index_font = self.PAR.ops.index_font
+        if self.PAR.ops.index_font not in self.char_widths:
+            self.char_widths[self.PAR.ops.index_font] = {}
+        self.RI.index_test_str_w = self.get_txt_w(_test_str, self.PAR.ops.index_font)
+        self.index_txt_width, self.index_txt_height = self.get_txt_dimensions("|", self.PAR.ops.index_font)
+        self.min_row_height = max(6, self.table_txt_height, self.index_txt_height) + 6
 
-    def set_index_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
-        if newfont:
-            if not isinstance(newfont, tuple):
-                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')"
+    def change_font_manage_row_heights(self, old_min_row_height: int, old_default_row_height: int) -> None:
+        default_row_height = self.get_default_row_height()
+        self.row_positions = list(
+            accumulate(
+                chain(
+                    [0],
+                    (
+                        (
+                            self.min_row_height
+                            if h == old_min_row_height
+                            else (
+                                default_row_height
+                                if h == old_default_row_height
+                                else self.min_row_height
+                                if h < self.min_row_height
+                                else h
+                            )
+                        )
+                        for h in self.gen_row_heights()
+                    ),
                 )
-            self.PAR.ops.index_font = FontTuple(*newfont)
-            self.set_index_font_help()
-        return self.PAR.ops.index_font
+            )
+        )
 
-    def set_index_font_help(self):
-        self.index_txt_width, self.index_txt_height = self.get_txt_dimensions("|", self.PAR.ops.index_font)
-        self.index_half_txt_height = ceil(self.index_txt_height / 2)
-        if not self.index_half_txt_height % 2:
-            self.index_first_ln_ins = self.index_half_txt_height + 2
-        else:
-            self.index_first_ln_ins = self.index_half_txt_height + 3
-        self.index_xtra_lines_increment = self.index_txt_height
-        self.min_index_width = 5
+    def set_header_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
+        if newfont:
+            self.check_font(newfont)
+            self.PAR.ops.header_font = FontTuple(*newfont)
+            self.set_header_font_help()
+            self.recreate_all_selection_boxes()
+        return self.PAR.ops.header_font
+
+    def set_header_font_help(self):
+        self.CH.header_font = self.PAR.ops.header_font
+        if self.PAR.ops.header_font not in self.char_widths:
+            self.char_widths[self.PAR.ops.header_font] = {}
+        self.CH.header_test_str_w = self.get_txt_w(_test_str, self.PAR.ops.header_font)
+        self.header_txt_width, self.header_txt_height = self.get_txt_dimensions("|", self.PAR.ops.header_font)
+        self.min_header_height = self.header_txt_height + 6
+        if (
+            isinstance(self.PAR.ops.default_header_height, int)
+            and self.PAR.ops.default_header_height < self.min_header_height
+        ):
+            self.PAR.ops.default_header_height = int(self.min_header_height)
+        self.CH.set_height(self.get_default_header_height(), set_TL=True)
 
     def purge_undo_and_redo_stack(self):
         self.undo_stack = deque(maxlen=self.PAR.ops.max_undos)
@@ -4123,6 +4302,58 @@ class MainTable(tk.Canvas):
             else:
                 return False
 
+    def get_cell_max_width(self, datarn: int, dispcn: int) -> int:
+        datacn = self.datacn(dispcn)
+        col_width = self.col_positions[dispcn + 1] - self.col_positions[dispcn]
+        if kwargs := self.get_cell_kwargs(datarn, datacn, "dropdown"):
+            max_width = col_width - self.table_txt_height - 5
+        else:
+            max_width = col_width - 2
+            if (kwargs := self.get_cell_kwargs(datarn, datacn, "dropdown")) and max_width > self.table_txt_height + 1:
+                box_w = self.table_txt_height + 1
+                max_width -= box_w + 4
+        if self.PAR.ops.allow_cell_overflow and not kwargs:
+            if self.cells_cache is None:
+                disprn = self.disprn(datarn)
+                self.cells_cache = self._redraw_precache_cells(disprn, disprn + 1, 0, len(self.col_positions) - 1)
+            if not (align := self.get_cell_kwargs(datarn, datacn, key="align")):
+                align = self.align
+            if align.endswith("w"):
+                max_width += sum(
+                    self._overflow(
+                        self.cells_cache,
+                        range(dispcn + 1, len(self.col_positions) - 1),
+                        datarn,
+                    )
+                )
+            elif align.endswith("e"):
+                max_width += sum(
+                    self._overflow(
+                        self.cells_cache,
+                        reversed(range(0, dispcn)),
+                        datarn,
+                    )
+                )
+        return max_width
+
+    def get_wrapped_cell_height(self, datarn: int, datacn: int) -> int:
+        dispcn = self.dispcn(datacn)
+        n_lines = max(
+            1,
+            sum(
+                1
+                for _ in wrap_text(
+                    text=self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True),
+                    max_width=self.get_cell_max_width(datarn, dispcn),
+                    max_lines=float("inf"),
+                    char_width_fn=self.wrap_get_char_w,
+                    widths=self.char_widths[self.table_font],
+                    wrap=self.PAR.ops.table_wrap,
+                )
+            ),
+        )
+        return 3 + (n_lines * self.table_txt_height)
+
     def set_all_cell_sizes_to_text(
         self,
         width: int | None = None,
@@ -4206,26 +4437,28 @@ class MainTable(tk.Canvas):
     def set_col_positions(self, itr: AnyIter[float]) -> None:
         self.col_positions = list(accumulate(chain([0], itr)))
 
-    def reset_col_positions(self, ncols: int | None = None):
-        colpos = self.PAR.ops.default_column_width
+    def reset_col_positions(self, ncols: int | None = None, width: int | None = None) -> None:
+        if width is None:
+            width = self.PAR.ops.default_column_width
         if isinstance(ncols, int):
-            self.set_col_positions(itr=repeat(colpos, ncols))
+            self.set_col_positions(itr=repeat(width, ncols))
         elif self.all_columns_displayed:
-            self.set_col_positions(itr=repeat(colpos, self.total_data_cols()))
+            self.set_col_positions(itr=repeat(width, self.total_data_cols()))
         else:
-            self.set_col_positions(itr=repeat(colpos, len(self.displayed_columns)))
+            self.set_col_positions(itr=repeat(width, len(self.displayed_columns)))
 
     def set_row_positions(self, itr: AnyIter[float]) -> None:
         self.row_positions = list(accumulate(chain([0], itr)))
 
-    def reset_row_positions(self, nrows: int | None = None):
-        rowpos = self.get_default_row_height()
+    def reset_row_positions(self, nrows: int | None = None, height: int | None = None) -> None:
+        if height is None:
+            height = self.get_default_row_height()
         if isinstance(nrows, int):
-            self.set_row_positions(itr=repeat(rowpos, nrows))
+            self.set_row_positions(itr=repeat(height, nrows))
         elif self.all_rows_displayed:
-            self.set_row_positions(itr=repeat(rowpos, self.total_data_rows()))
+            self.set_row_positions(itr=repeat(height, self.total_data_rows()))
         else:
-            self.set_row_positions(itr=repeat(rowpos, len(self.displayed_rows)))
+            self.set_row_positions(itr=repeat(height, len(self.displayed_rows)))
 
     def del_col_position(self, idx: int, deselect_all: bool = False):
         if deselect_all:
@@ -4277,46 +4510,6 @@ class MainTable(tk.Canvas):
     def gen_row_heights(self) -> Generator[int]:
         return diff_gen(self.row_positions)
 
-    def insert_col_position(
-        self,
-        idx: Literal["end"] | int = "end",
-        width: int | None = None,
-        deselect_all: bool = False,
-    ) -> None:
-        if deselect_all:
-            self.deselect("all", redraw=False)
-        if width is None:
-            w = self.PAR.ops.default_column_width
-        else:
-            w = width
-        if idx == "end" or len(self.col_positions) == idx + 1:
-            self.col_positions.append(self.col_positions[-1] + w)
-        else:
-            idx += 1
-            self.col_positions.insert(idx, self.col_positions[idx - 1] + w)
-            idx += 1
-            self.col_positions[idx:] = [e + w for e in islice(self.col_positions, idx, len(self.col_positions))]
-
-    def insert_row_position(
-        self,
-        idx: Literal["end"] | int = "end",
-        height: int | None = None,
-        deselect_all: bool = False,
-    ) -> None:
-        if deselect_all:
-            self.deselect("all", redraw=False)
-        if height is None:
-            h = self.get_default_row_height()
-        else:
-            h = height
-        if idx == "end" or len(self.row_positions) == idx + 1:
-            self.row_positions.append(self.row_positions[-1] + h)
-        else:
-            idx += 1
-            self.row_positions.insert(idx, self.row_positions[idx - 1] + h)
-            idx += 1
-            self.row_positions[idx:] = [e + h for e in islice(self.row_positions, idx, len(self.row_positions))]
-
     def insert_col_positions(
         self,
         idx: Literal["end"] | int = "end",
@@ -4403,25 +4596,13 @@ class MainTable(tk.Canvas):
         create_ops: bool = True,
     ) -> None:
         self.tagged_cells = {
-            tags: {(r, c if not (num := bisect_right(cols, c)) else c + num) for (r, c) in tagged}
-            for tags, tagged in self.tagged_cells.items()
-        }
-        self.cell_options = {
-            (r, c if not (num := bisect_right(cols, c)) else c + num): v for (r, c), v in self.cell_options.items()
-        }
-        self.progress_bars = {
-            (r, c if not (num := bisect_right(cols, c)) else c + num): v for (r, c), v in self.progress_bars.items()
-        }
-        self.tagged_columns = {
-            tags: {c if not (num := bisect_right(cols, c)) else c + num for c in tagged}
-            for tags, tagged in self.tagged_columns.items()
-        }
-        self.col_options = {
-            c if not (num := bisect_right(cols, c)) else c + num: v for c, v in self.col_options.items()
-        }
-        self.CH.cell_options = {
-            c if not (num := bisect_right(cols, c)) else c + num: v for c, v in self.CH.cell_options.items()
+            tags: {(r, push_n(c, cols)) for (r, c) in tagged} for tags, tagged in self.tagged_cells.items()
         }
+        self.cell_options = {(r, push_n(c, cols)): v for (r, c), v in self.cell_options.items()}
+        self.progress_bars = {(r, push_n(c, cols)): v for (r, c), v in self.progress_bars.items()}
+        self.tagged_columns = {tags: {push_n(c, cols) for c in tagged} for tags, tagged in self.tagged_columns.items()}
+        self.col_options = {push_n(c, cols): v for c, v in self.col_options.items()}
+        self.CH.cell_options = {push_n(c, cols): v for c, v in self.CH.cell_options.items()}
         # if there are named spans where columns were added
         # add options to gap which was created by adding columns
         totalrows = None
@@ -4471,32 +4652,18 @@ class MainTable(tk.Canvas):
 
     def adjust_options_post_add_rows(
         self,
-        rows: list | tuple,
+        rows: list[int] | tuple[int],
         create_ops: bool = True,
     ) -> None:
         self.tagged_cells = {
-            tags: {(r if not (num := bisect_right(rows, r)) else r + num, c) for (r, c) in tagged}
-            for tags, tagged in self.tagged_cells.items()
-        }
-        self.cell_options = {
-            (r if not (num := bisect_right(rows, r)) else r + num, c): v for (r, c), v in self.cell_options.items()
-        }
-        self.progress_bars = {
-            (r if not (num := bisect_right(rows, r)) else r + num, c): v for (r, c), v in self.progress_bars.items()
-        }
-        self.tagged_rows = {
-            tags: {r if not (num := bisect_right(rows, r)) else r + num for r in tagged}
-            for tags, tagged in self.tagged_rows.items()
-        }
-        self.row_options = {
-            r if not (num := bisect_right(rows, r)) else r + num: v for r, v in self.row_options.items()
-        }
-        self.RI.cell_options = {
-            r if not (num := bisect_right(rows, r)) else r + num: v for r, v in self.RI.cell_options.items()
-        }
-        self.RI.tree_rns = {
-            v: r if not (num := bisect_right(rows, r)) else r + num for v, r in self.RI.tree_rns.items()
+            tags: {(push_n(r, rows), c) for (r, c) in tagged} for tags, tagged in self.tagged_cells.items()
         }
+        self.cell_options = {(push_n(r, rows), c): v for (r, c), v in self.cell_options.items()}
+        self.progress_bars = {(push_n(r, rows), c): v for (r, c), v in self.progress_bars.items()}
+        self.tagged_rows = {tags: {push_n(r, rows) for r in tagged} for tags, tagged in self.tagged_rows.items()}
+        self.row_options = {push_n(r, rows): v for r, v in self.row_options.items()}
+        self.RI.cell_options = {push_n(r, rows): v for r, v in self.RI.cell_options.items()}
+        self.RI.tree_rns = {k: push_n(r, rows) for k, r in self.RI.tree_rns.items()}
         # if there are named spans where rows were added
         # add options to gap which was created by adding rows
         totalcols = None
@@ -4731,29 +4898,27 @@ class MainTable(tk.Canvas):
         header: dict,
         column_widths: dict,
         event_data: dict,
-        displayed_columns: None | list[int] = None,
         create_ops: bool = True,
         create_selections: bool = True,
         add_row_positions: bool = True,
         push_ops: bool = True,
         mod_event_boxes: bool = True,
+        restored_state: bool = False,
     ) -> EventDataDict:
         self.saved_column_widths = {}
-        saved_displayed_columns = list(self.displayed_columns)
-        if isinstance(displayed_columns, list):
-            self.displayed_columns = displayed_columns
-        elif not self.all_columns_displayed:
+        if not restored_state and not self.all_columns_displayed:
             self.displayed_columns = add_to_displayed(self.displayed_columns, columns)
         cws = self.get_column_widths()
         if column_widths and next(reversed(column_widths)) > len(cws):
             for i in reversed(range(len(cws), len(cws) + next(reversed(column_widths)) - len(cws))):
                 column_widths[i] = self.PAR.ops.default_column_width
-        self.set_col_positions(
-            itr=insert_items(
-                cws,
-                column_widths,
+        if not restored_state:
+            self.set_col_positions(
+                itr=insert_items(
+                    cws,
+                    column_widths,
+                )
             )
-        )
         # rn needed for indexing but cn insert
         maxrn = 0
         for cn, rowdict in reversed(columns.items()):
@@ -4772,14 +4937,14 @@ class MainTable(tk.Canvas):
                 "table": {},
                 "index": {},
                 "row_heights": {rn: default_height for rn in range(len(self.row_positions) - 1, maxrn + 1)},
-                "displayed_rows": self.displayed_rows,
             }
-            self.set_row_positions(
-                itr=chain(
-                    self.gen_row_heights(),
-                    repeat(default_height, maxrn + 1 - (len(self.row_positions) - 1)),
+            if not restored_state:
+                self.set_row_positions(
+                    itr=chain(
+                        self.gen_row_heights(),
+                        repeat(default_height, maxrn + 1 - (len(self.row_positions) - 1)),
+                    )
                 )
-            )
         if isinstance(self._headers, list) and header:
             self._headers = insert_items(self._headers, header, self.CH.fix_header)
         if push_ops:
@@ -4805,7 +4970,6 @@ class MainTable(tk.Canvas):
             "table": columns,
             "header": header,
             "column_widths": column_widths,
-            "displayed_columns": saved_displayed_columns,
         }
         return event_data
 
@@ -4842,13 +5006,7 @@ class MainTable(tk.Canvas):
             numcols = self.PAR.ops.paste_insert_column_limit - len(self.col_positions) - 1
             if numcols < 1:
                 return
-        event_data = event_dict(
-            name="add_columns",
-            sheet=self.PAR.name,
-            widget=self,
-            boxes=self.get_boxes(),
-            selected=self.selected,
-        )
+        event_data = self.new_event_dict("add_columns", state=True)
         if not try_binding(self.extra_begin_insert_cols_rc_func, event_data, "begin_add_columns"):
             return
         event_data = self.add_columns(
@@ -4863,34 +5021,33 @@ class MainTable(tk.Canvas):
 
     def add_rows(
         self,
-        rows: dict,
-        index: dict,
-        row_heights: dict,
-        event_data: dict,
-        displayed_rows: None | list[int] = None,
+        rows: dict[int, list[object]],
+        index: dict[int, object],
+        row_heights: dict[int, float | int],
+        event_data: EventDataDict,
         create_ops: bool = True,
         create_selections: bool = True,
         add_col_positions: bool = True,
         push_ops: bool = True,
+        tree: bool = True,
         mod_event_boxes: bool = True,
+        restored_state: bool = False,
     ) -> EventDataDict:
         self.saved_row_heights = {}
-        saved_displayed_rows = list(self.displayed_rows)
-        if isinstance(displayed_rows, list):
-            self.displayed_rows = displayed_rows
-        elif not self.all_rows_displayed:
+        if not restored_state and not self.all_rows_displayed:
             self.displayed_rows = add_to_displayed(self.displayed_rows, rows)
         rhs = self.get_row_heights()
         if row_heights and next(reversed(row_heights)) > len(rhs):
             default_row_height = self.get_default_row_height()
             for i in reversed(range(len(rhs), len(rhs) + next(reversed(row_heights)) - len(rhs))):
                 row_heights[i] = default_row_height
-        self.set_row_positions(
-            itr=insert_items(
-                rhs,
-                row_heights,
+        if not restored_state:
+            self.set_row_positions(
+                itr=insert_items(
+                    rhs,
+                    row_heights,
+                )
             )
-        )
         maxcn = 0
         # rn needed for insert but cn indexing
         for rn, row in reversed(rows.items()):
@@ -4909,14 +5066,14 @@ class MainTable(tk.Canvas):
                 "table": {},
                 "header": {},
                 "column_widths": {cn: default_width for cn in range(len(self.col_positions) - 1, maxcn + 1)},
-                "displayed_columns": self.displayed_columns,
             }
-            self.set_col_positions(
-                itr=chain(
-                    self.gen_column_widths(),
-                    repeat(default_width, maxcn + 1 - (len(self.col_positions) - 1)),
+            if not restored_state:
+                self.set_col_positions(
+                    itr=chain(
+                        self.gen_column_widths(),
+                        repeat(default_width, maxcn + 1 - (len(self.col_positions) - 1)),
+                    )
                 )
-            )
         if push_ops:
             self.adjust_options_post_add_rows(
                 rows=tuple(reversed(rows)),
@@ -4940,8 +5097,9 @@ class MainTable(tk.Canvas):
             "table": rows,
             "index": index,
             "row_heights": row_heights,
-            "displayed_rows": saved_displayed_rows,
         }
+        if tree and self.PAR.ops.treeview:
+            event_data = self.RI.tree_add_rows(event_data=event_data)
         return event_data
 
     def rc_add_rows(self, event: object = None):
@@ -4977,13 +5135,7 @@ class MainTable(tk.Canvas):
             numrows = self.PAR.ops.paste_insert_row_limit - len(self.row_positions) - 1
             if numrows < 1:
                 return
-        event_data = event_dict(
-            name="add_rows",
-            sheet=self.PAR.name,
-            widget=self,
-            boxes=self.get_boxes(),
-            selected=self.selected,
-        )
+        event_data = self.new_event_dict("add_rows", state=True)
         if not try_binding(self.extra_begin_insert_rows_rc_func, event_data, "begin_add_rows"):
             return
         event_data = self.add_rows(
@@ -5064,10 +5216,14 @@ class MainTable(tk.Canvas):
                     for datarn, v in zip(reversed(range(data_ins_row, data_ins_row + numrows)), reversed(rows))
                 }
             else:
-                index_data = {
-                    datarn: self.RI.get_value_for_empty_cell(datarn, r_ops=False)
-                    for datarn in reversed(range(data_ins_row, data_ins_row + numrows))
-                }
+                if self.PAR.ops.treeview:
+                    nodes = [self.RI.get_value_for_empty_cell(data_ins_row, r_ops=False) for _ in range(numrows)]
+                    index_data = dict(zip(reversed(range(data_ins_row, data_ins_row + numrows)), reversed(nodes)))
+                else:
+                    index_data = {
+                        datarn: self.RI.get_value_for_empty_cell(datarn, r_ops=False)
+                        for datarn in reversed(range(data_ins_row, data_ins_row + numrows))
+                    }
         if rows is None:
             if total_data_cols is None:
                 total_data_cols = self.total_data_cols()
@@ -5107,11 +5263,27 @@ class MainTable(tk.Canvas):
             "tagged_columns": {f"{tag}": set(s) for tag, s in self.tagged_columns.items()},
         }
 
-    def delete_columns_data(self, cols: list, event_data: dict) -> EventDataDict:
+    def copy_sheet_state(self) -> dict:
+        return {
+            "row_positions": list(self.row_positions),
+            "col_positions": list(self.col_positions),
+            "displayed_rows": int(self.displayed_rows)
+            if isinstance(self.displayed_rows, int)
+            else list(self.displayed_rows),
+            "displayed_columns": int(self.displayed_columns)
+            if isinstance(self.displayed_columns, int)
+            else list(self.displayed_columns),
+            "all_rows_displayed": bool(self.all_rows_displayed),
+            "saved_row_heights": dict(self.saved_row_heights),
+            "saved_column_widths": dict(self.saved_column_widths),
+            "all_columns_displayed": bool(self.all_columns_displayed),
+            "tree_open_ids": set(self.RI.tree_open_ids),
+        }
+
+    def delete_columns_data(self, cols: list[int], event_data: EventDataDict | None = None) -> EventDataDict:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
-        event_data["deleted"]["displayed_columns"] = (
-            list(self.displayed_columns) if not isinstance(self.displayed_columns, int) else int(self.displayed_columns)
-        )
+        if not event_data:
+            event_data = self.new_event_dict("delete_columns", state=True)
         event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         for datacn in reversed(cols):
@@ -5139,41 +5311,62 @@ class MainTable(tk.Canvas):
             ]
         return event_data
 
-    def delete_columns_displayed(self, cols: list, event_data: dict) -> EventDataDict:
+    def delete_columns_displayed(
+        self,
+        cols: list[int],
+        event_data: EventDataDict | None = None,
+        restored_state: bool = False,
+    ) -> EventDataDict:
+        if not event_data:
+            event_data = self.new_event_dict("delete_columns", state=True)
         self.saved_column_widths = {}
-        cols_set = set(cols)
-        for c in reversed(cols):
-            event_data["deleted"]["column_widths"][c] = self.col_positions[c + 1] - self.col_positions[c]
-        self.set_col_positions(itr=(width for c, width in enumerate(self.gen_column_widths()) if c not in cols_set))
+        if cols:
+            for c in reversed(cols):
+                if len(self.col_positions) > c + 1:
+                    event_data["deleted"]["column_widths"][c] = self.col_positions[c + 1] - self.col_positions[c]
+            if not restored_state:
+                cols_set = set(cols)
+                self.set_col_positions(
+                    itr=(width for c, width in enumerate(self.gen_column_widths()) if c not in cols_set)
+                )
         return event_data
 
-    def rc_delete_columns(self, event: object = None):
-        selected = sorted(self.get_selected_cols())
-        if not self.selected:
+    def delete_columns(
+        self,
+        event: object = None,
+        columns: list[int] | None = None,
+        data_indexes: bool = False,
+        undo: bool = True,
+        emit_event: bool = True,
+        ext: bool = False,
+    ) -> EventDataDict:
+        event_data = self.new_event_dict("delete_columns", state=True)
+        if not columns:
+            if not (columns := sorted(self.get_selected_cols())):
+                return event_data
+        if not ext and not try_binding(self.extra_begin_del_cols_rc_func, event_data, "begin_delete_columns"):
             return
-        event_data = event_dict(
-            name="delete_columns",
-            sheet=self.PAR.name,
-            widget=self,
-            boxes=self.get_boxes(),
-            selected=self.selected,
+        event_data = self.delete_columns_displayed(
+            data_to_displayed_idxs(columns, self.MT.displayed_columns) if data_indexes else columns,
+            event_data,
         )
-        if not try_binding(self.extra_begin_del_cols_rc_func, event_data, "begin_delete_columns"):
-            return
-        event_data = self.delete_columns_displayed(selected, event_data)
-        data_cols = selected if self.all_columns_displayed else [self.displayed_columns[c] for c in selected]
-        event_data = self.delete_columns_data(data_cols, event_data)
-        if self.undo_enabled:
+        event_data = self.delete_columns_data(
+            columns if data_indexes or self.all_columns_displayed else [self.displayed_columns[c] for c in columns],
+            event_data,
+        )
+        if undo and self.undo_enabled:
             self.undo_stack.append(stored_event_dict(event_data))
+        if not ext:
+            try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
+        if emit_event:
+            self.sheet_modified(event_data)
         self.deselect("all")
-        try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
-        self.sheet_modified(event_data)
+        return event_data
 
-    def delete_rows_data(self, rows: list, event_data: dict) -> EventDataDict:
+    def delete_rows_data(self, rows: list[int], event_data: EventDataDict | None = None) -> EventDataDict:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
-        event_data["deleted"]["displayed_rows"] = (
-            list(self.displayed_rows) if not isinstance(self.displayed_rows, int) else int(self.displayed_rows)
-        )
+        if not event_data:
+            event_data = self.new_event_dict("delete_rows", state=True)
         event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         for datarn in reversed(rows):
@@ -5182,6 +5375,8 @@ class MainTable(tk.Canvas):
                 event_data["deleted"]["index"][datarn] = self._row_index.pop(datarn)
             except Exception:
                 continue
+        if self.PAR.ops.treeview:
+            event_data = self.RI.tree_del_rows(event_data=event_data)
         rows_set = set(rows)
         self.adjust_options_post_delete_rows(
             to_del=rows_set,
@@ -5195,35 +5390,72 @@ class MainTable(tk.Canvas):
             ]
         return event_data
 
-    def delete_rows_displayed(self, rows: list, event_data: dict) -> EventDataDict:
+    def delete_rows_displayed(
+        self,
+        rows: list[int],
+        event_data: EventDataDict | None = None,
+        restored_state: bool = False,
+    ) -> EventDataDict:
+        if not event_data:
+            event_data = self.new_event_dict("delete_rows", state=True)
         self.saved_row_heights = {}
-        rows_set = set(rows)
-        for r in reversed(rows):
-            event_data["deleted"]["row_heights"][r] = self.row_positions[r + 1] - self.row_positions[r]
-        self.set_row_positions(itr=(height for r, height in enumerate(self.gen_row_heights()) if r not in rows_set))
+        if rows:
+            for r in reversed(rows):
+                if len(self.row_positions) > r + 1:
+                    event_data["deleted"]["row_heights"][r] = self.row_positions[r + 1] - self.row_positions[r]
+            if not restored_state:
+                rows_set = set(rows)
+                self.set_row_positions(
+                    itr=(height for r, height in enumerate(self.gen_row_heights()) if r not in rows_set)
+                )
         return event_data
 
-    def rc_delete_rows(self, event: object = None):
-        selected = sorted(self.get_selected_rows())
-        if not self.selected:
+    def delete_rows(
+        self,
+        event: object = None,
+        rows: list[int] | None = None,
+        data_indexes: bool = False,
+        undo: bool = True,
+        emit_event: bool = True,
+        ext: bool = False,
+    ) -> EventDataDict:
+        event_data = self.new_event_dict("delete_rows", state=True)
+        if not rows:
+            if not (rows := sorted(self.get_selected_rows())):
+                return
+        if not ext and not try_binding(self.extra_begin_del_rows_rc_func, event_data, "begin_delete_rows"):
             return
-        event_data = event_dict(
-            name="delete_rows",
-            sheet=self.PAR.name,
-            widget=self,
-            boxes=self.get_boxes(),
-            selected=self.selected,
+        if data_indexes or self.all_rows_displayed:
+            data_rows = rows
+        else:
+            data_rows = [self.displayed_rows[r] for r in rows]
+        if self.PAR.ops.treeview:
+            data_rows = sorted(
+                chain(
+                    data_rows,
+                    (
+                        self.RI.tree_rns[did]
+                        for r in data_rows
+                        for did in self.RI.get_iid_descendants(self._row_index[r].iid)
+                    ),
+                )
+            )
+        event_data = self.delete_rows_displayed(
+            data_to_displayed_idxs(data_rows, self.displayed_rows) if self.PAR.ops.treeview or data_indexes else rows,
+            event_data,
         )
-        if not try_binding(self.extra_begin_del_rows_rc_func, event_data, "begin_delete_rows"):
-            return
-        event_data = self.delete_rows_displayed(selected, event_data)
-        data_rows = selected if self.all_rows_displayed else [self.displayed_rows[r] for r in selected]
-        event_data = self.delete_rows_data(data_rows, event_data)
-        if self.undo_enabled:
+        event_data = self.delete_rows_data(
+            data_rows,
+            event_data,
+        )
+        if undo and self.undo_enabled:
             self.undo_stack.append(stored_event_dict(event_data))
+        if not ext:
+            try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
+        if emit_event:
+            self.sheet_modified(event_data)
         self.deselect("all")
-        try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
-        self.sheet_modified(event_data)
+        return event_data
 
     def move_row_position(self, idx1: int, idx2: int):
         if not len(self.row_positions) <= 2:
@@ -5495,7 +5727,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)]
@@ -5574,7 +5806,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:
@@ -5600,7 +5831,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,
@@ -5618,66 +5859,59 @@ 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")
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline, tag=tag)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline, tags="h")
         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",
+                    )
             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)
@@ -5708,13 +5942,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,
@@ -5729,7 +5962,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)
@@ -5739,10 +5971,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
@@ -5756,28 +5988,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:
@@ -5785,7 +6002,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
@@ -5802,6 +6018,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:
@@ -5809,7 +6029,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
@@ -5826,6 +6045,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
@@ -5852,6 +6075,81 @@ class MainTable(tk.Canvas):
         ):
             self.PAR.yscroll.grid(row=0, column=2, rowspan=3, sticky="nswe")
             self.PAR.yscroll_showing = True
+
+    def _overflow(
+        self,
+        cells: dict,
+        rnge: Generator[int],
+        datarn: int,
+    ) -> Generator[float]:
+        for c_ in rnge:
+            if (
+                cells[(datarn, cells["datacn"][c_])]
+                or (datarn, cells["datacn"][c_]) in cells["dropdown"]
+                or (datarn, cells["datacn"][c_]) in cells["checkbox"]
+            ):
+                return
+            else:
+                yield self.col_positions[c_ + 1] - self.col_positions[c_]
+
+    def _redraw_precache_cells(
+        self,
+        text_start_row: int,
+        text_end_row: int,
+        text_start_col: int,
+        text_end_col: int,
+    ) -> dict:
+        cells = {"datarn": {}, "datacn": {}, "dropdown": {}, "checkbox": {}}
+        for r in range(text_start_row, text_end_row):
+            datarn = r if self.all_rows_displayed else self.displayed_rows[r]
+            cells["datarn"][r] = datarn
+            for c in range(text_start_col, text_end_col):
+                if c in cells["datacn"]:
+                    datacn = cells["datacn"][c]
+                else:
+                    datacn = c if self.all_columns_displayed else self.displayed_columns[c]
+                    cells["datacn"][c] = datacn
+                if kwargs := self.get_cell_kwargs(datarn, datacn, key="dropdown"):
+                    cells["dropdown"][(datarn, datacn)] = kwargs
+                elif kwargs := self.get_cell_kwargs(datarn, datacn, key="checkbox"):
+                    cells["checkbox"][(datarn, datacn)] = kwargs
+                cells[(datarn, datacn)] = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
+        return cells
+
+    def wrap_get_char_w(self, c: str) -> int:
+        self.txt_measure_canvas.itemconfig(
+            self.txt_measure_canvas_text,
+            text=_test_str + c,
+            font=self.table_font,
+        )
+        b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
+        if c in self.char_widths[self.table_font]:
+            return self.char_widths[self.table_font][c]
+        else:
+            wd = b[2] - b[0] - self.table_test_str_w
+            self.char_widths[self.table_font][c] = wd
+            return wd
+
+    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,
+        set_scrollregion: bool = True,
+    ) -> 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 = (
@@ -5860,28 +6158,33 @@ class MainTable(tk.Canvas):
             last_col_line_pos + self.PAR.ops.empty_horizontal + 2,
             last_row_line_pos + self.PAR.ops.empty_vertical + 2,
         )
-        if setting_views or scrollregion != self.scrollregion:
-            self.configure(scrollregion=scrollregion)
+        if set_scrollregion and (setting_views or scrollregion != self.scrollregion):
+            try:
+                self.configure(scrollregion=scrollregion)
+            except Exception:
+                return False
             self.scrollregion = scrollregion
-            self.CH.configure_scrollregion(last_col_line_pos)
-            self.RI.configure_scrollregion(last_row_line_pos)
-            if setting_views:
+            if (
+                not self.CH.configure_scrollregion(last_col_line_pos)
+                or not self.RI.configure_scrollregion(last_row_line_pos)
+                or setting_views
+            ):
                 return False
+
         scrollpos_top = self.canvasy(0)
         scrollpos_bot = self.canvasy(can_height)
         scrollpos_left = self.canvasx(0)
         scrollpos_right = self.canvasx(can_width)
-
         grid_start_row = bisect_left(self.row_positions, scrollpos_top)
         grid_end_row = bisect_right(self.row_positions, scrollpos_bot)
         grid_start_col = bisect_left(self.col_positions, scrollpos_left)
         grid_end_col = bisect_right(self.col_positions, scrollpos_right)
-
         text_start_row = grid_start_row - 1 if grid_start_row else grid_start_row
         text_end_row = grid_end_row - 1 if grid_end_row == len(self.row_positions) else grid_end_row
         text_start_col = grid_start_col - 1 if grid_start_col else grid_start_col
         text_end_col = grid_end_col - 1 if grid_end_col == len(self.col_positions) else grid_end_col
 
+        # check if auto resizing row index
         changed_w = False
         if self.PAR.ops.auto_resize_row_index and redraw_row_index and self.show_index:
             changed_w = self.RI.auto_set_index_width(
@@ -5894,6 +6197,10 @@ class MainTable(tk.Canvas):
                 for widget in (self, self.RI, self.CH, self.TL):
                     widget.update_idletasks()
                 return False
+        # important vars
+        x_stop = min(last_col_line_pos, scrollpos_right)
+        y_stop = min(last_row_line_pos, scrollpos_bot)
+        # manage find window
         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)
@@ -5903,89 +6210,73 @@ class MainTable(tk.Canvas):
                 height=h,
                 state="normal",
             )
-        self.hidd_text.update(self.disp_text)
-        self.disp_text = {}
-        self.hidd_high.update(self.disp_high)
-        self.disp_high = {}
-        self.hidd_grid.update(self.disp_grid)
-        self.disp_grid = {}
-        self.hidd_dropdown.update(self.disp_dropdown)
-        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
+        # redraw table
+        if redraw_table:
+            # reset canvas item storage
+            self.hidd_text.update(self.disp_text)
+            self.disp_text = {}
+            self.hidd_high.update(self.disp_high)
+            self.disp_high = {}
+            self.hidd_grid.update(self.disp_grid)
+            self.disp_grid = {}
+            self.hidd_dropdown.update(self.disp_dropdown)
+            self.disp_dropdown = {}
+            self.hidd_checkbox.update(self.disp_checkbox)
+            self.disp_checkbox = {}
+            # manage horizontal grid lines
+            if self.PAR.ops.show_horizontal_grid and row_pos_exists:
+                if self.PAR.ops.horizontal_grid_to_end_of_window:
+                    x_grid_stop = scrollpos_right + can_width
                 else:
-                    x_grid_stop = x_stop - 1
-            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:
+                    if last_col_line_pos > scrollpos_right:
+                        x_grid_stop = x_stop + 1
+                    else:
+                        x_grid_stop = x_stop - 1
                 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,
+                    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)
                         )
-                        for c in range(grid_start_col, grid_end_col)
-                    ]
+                    )
                 )
-            )
-            if points:
+            # 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=points,
-                    fill=self.PAR.ops.table_grid_fg,
-                    width=1,
-                    tag="g",
+                    points=tuple(
+                        chain.from_iterable(
+                            (
+                                self.col_positions[c],
+                                scrollpos_top - 1,
+                                self.col_positions[c],
+                                y_grid_stop,
+                                self.col_positions[c],
+                                scrollpos_top - 1,
+                                self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
+                                scrollpos_top - 1,
+                            )
+                            for c in range(grid_start_col, grid_end_col)
+                        )
+                    ),
                 )
-        if 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)
@@ -6007,7 +6298,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),
@@ -6016,22 +6306,23 @@ class MainTable(tk.Canvas):
                 )
             else:
                 override = tuple()
+            allow_overflow = self.PAR.ops.allow_cell_overflow
+            wrap = self.PAR.ops.table_wrap
+            cells = self._redraw_precache_cells(
+                text_start_row=text_start_row,
+                text_end_row=text_end_row,
+                text_start_col=text_start_col,
+                text_end_col=text_end_col,
+            )
+            for r in range(text_start_row, text_end_row):
+                rtopgridln = self.row_positions[r]
+                rbotgridln = self.row_positions[r + 1]
+                datarn = cells["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)
-
+                    datacn = cells["datacn"][c]
                     fill, dd_drawn = self.redraw_highlight_get_text_fg(
                         r=r,
                         c=c,
@@ -6049,79 +6340,48 @@ 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 := cells["dropdown"].get((datarn, datacn), None):
+                        max_width = crightgridln - cleftgridln - self.table_txt_height - 5
+                        if align.endswith("w"):
+                            draw_x = cleftgridln + 2
+                        elif align.endswith("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.endswith("n"):
                             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=max_width >= 5,
+                            open_=dd_coords == (r, c),
+                        )
+                    else:
+                        max_width = crightgridln - cleftgridln - 2
+                        if align.endswith("w"):
+                            draw_x = cleftgridln + 2
+                        elif align.endswith("e"):
+                            draw_x = crightgridln - 2
+                        elif align.endswith("n"):
                             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:
+
+                        if (
+                            kwargs := cells["checkbox"].get((datarn, datacn), None)
+                        ) and max_width > self.table_txt_height + 1:
                             box_w = self.table_txt_height + 1
-                            if align == "w":
+                            if align.endswith("w"):
                                 draw_x += box_w + 3
-                            elif align == "center":
+                            elif align.endswith("n"):
                                 draw_x += ceil(box_w / 2) + 1
-                            mw -= box_w + 3
+                            max_width -= box_w + 4
                             try:
-                                draw_check = self.data[datarn][datacn]
+                                draw_check = bool(self.data[datarn][datacn])
                             except Exception:
                                 draw_check = False
                             self.redraw_checkbox(
@@ -6131,92 +6391,105 @@ 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")
+                    text = cells[(datarn, datacn)]
                     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 text
+                        or (align.endswith("w") and draw_x > scrollpos_right)
+                        or (align.endswith("e") and cleftgridln + 5 > scrollpos_right)
+                        or (align.endswith("n") and cleftgridln + 5 > scrollpos_right)
                     ):
-                        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
+                    if allow_overflow and not kwargs:
+                        if align.endswith("w"):
+                            max_width += sum(self._overflow(cells, range(c + 1, text_end_col), datarn))
+                        elif align.endswith("e"):
+                            max_width += sum(self._overflow(cells, reversed(range(text_start_col, c)), datarn))
+                        elif align.endswith("n"):
+                            ...
+                    if max_width <= 1:
+                        continue
+                    start_line = max(0, int((scrollpos_top - rtopgridln) / self.table_txt_height))
+                    draw_y = rtopgridln + 3 + (start_line * self.table_txt_height)
+                    gen_lines = wrap_text(
+                        text=text,
+                        max_width=max_width,
+                        max_lines=int((rbotgridln - rtopgridln - 2) / self.table_txt_height),
+                        char_width_fn=self.wrap_get_char_w,
+                        widths=self.char_widths[font],
+                        wrap=wrap,
+                        start_line=start_line,
+                    )
+                    if align.endswith(("w", "e")):
+                        if self.hidd_text:
+                            iid, showing = self.hidd_text.popitem()
+                            self.coords(iid, draw_x, draw_y)
+                            if showing:
+                                self.itemconfig(
+                                    iid,
+                                    text="\n".join(gen_lines),
+                                    fill=fill,
+                                    font=font,
+                                    anchor=align,
+                                )
+                            else:
+                                self.itemconfig(
+                                    iid,
+                                    text="\n".join(gen_lines),
+                                    fill=fill,
+                                    font=font,
+                                    anchor=align,
+                                    state="normal",
+                                )
+                            self.tag_raise(iid)
+                        else:
+                            iid = self.create_text(
+                                draw_x,
+                                draw_y,
+                                text="\n".join(gen_lines),
+                                fill=fill,
+                                font=font,
+                                anchor=align,
+                                tags="t",
+                            )
+                        self.disp_text[iid] = True
+
+                    elif align.endswith("n"):
+                        for text in gen_lines:
+                            if self.hidd_text:
+                                iid, showing = self.hidd_text.popitem()
+                                self.coords(iid, draw_x, draw_y)
+                                if showing:
+                                    self.itemconfig(
+                                        iid,
+                                        text=text,
+                                        fill=fill,
+                                        font=font,
+                                        anchor=align,
+                                    )
                                 else:
-                                    iid = self.create_text(
-                                        draw_x,
-                                        draw_y,
-                                        text=txt,
+                                    self.itemconfig(
+                                        iid,
+                                        text=text,
                                         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.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)) :]
-                                        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]
-                                        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.tag_raise(iid)
+                            else:
+                                iid = self.create_text(
+                                    draw_x,
+                                    draw_y,
+                                    text=text,
+                                    fill=fill,
+                                    font=font,
+                                    anchor=align,
+                                    tags="t",
+                                )
+                            self.disp_text[iid] = True
+                            draw_y += self.table_txt_height
             for dct in (
                 self.hidd_text,
                 self.hidd_high,
@@ -6234,6 +6507,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,
@@ -6245,6 +6522,7 @@ class MainTable(tk.Canvas):
                 text_end_col=text_end_col,
                 scrollpos_right=scrollpos_right,
                 col_pos_exists=col_pos_exists,
+                set_scrollregion=set_scrollregion,
             )
         if redraw_row_index and self.show_index:
             self.RI.redraw_grid_and_text(
@@ -6257,6 +6535,7 @@ class MainTable(tk.Canvas):
                 text_end_row=text_end_row,
                 scrollpos_bot=scrollpos_bot,
                 row_pos_exists=row_pos_exists,
+                set_scrollregion=set_scrollregion,
             )
         event_data = {"sheetname": "", "header": redraw_header, "row_index": redraw_row_index, "table": redraw_table}
         self.PAR.emit_event("<<SheetRedrawn>>", data=event_data)
@@ -6313,7 +6592,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
 
@@ -6732,7 +7011,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):
@@ -6770,7 +7049,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)
             }
@@ -6779,7 +7058,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:
@@ -6794,7 +7073,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)
             }
@@ -6803,7 +7082,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:
@@ -6817,7 +7096,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)
         }
@@ -6829,16 +7108,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(
@@ -6858,7 +7137,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,
                 )
@@ -6868,7 +7147,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,
             )
@@ -6877,7 +7156,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,
             )
@@ -6891,7 +7170,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,
@@ -6981,7 +7260,7 @@ class MainTable(tk.Canvas):
             return False
         self.hide_text_editor()
         if not self.see(r=r, c=c, check_cell_visibility=True):
-            self.refresh()
+            self.main_table_redraw_grid_and_text(True, True)
         x = self.col_positions[c]
         y = self.row_positions[r]
         w = self.col_positions[c + 1] - x + 1
@@ -7049,10 +7328,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_txt_height,
+                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):
@@ -7287,10 +7566,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:
@@ -7299,13 +7576,12 @@ class MainTable(tk.Canvas):
         for i, v in enumerate(self.get_cell_kwargs(datarn, datacn, key="dropdown")["values"]):
             v_numlines = len(v.split("\n") if isinstance(v, str) else f"{v}".split("\n"))
             if v_numlines > 1:
-                win_h += self.table_first_ln_ins + (v_numlines * self.table_xtra_lines_increment) + 5  # end of cell
+                win_h += 8 + (v_numlines * self.table_txt_height)  # end of cell
             else:
                 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"
@@ -7395,7 +7671,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,
@@ -7440,12 +7716,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),
@@ -7454,30 +7729,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)
@@ -7770,7 +8027,7 @@ class MainTable(tk.Canvas):
                 else:
                     # assumed given formatter class has get_data_with_valid_check()
                     return f"{value.get_data_with_valid_check()}"
-        return "" if value is None else f"{value}"
+        return "" if value is None else value if isinstance(value, str) else f"{value}"
 
     def get_cell_data(
         self,
@@ -7783,7 +8040,11 @@ class MainTable(tk.Canvas):
     ) -> object:
         if get_displayed:
             return self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
-        value = self.data[datarn][datacn] if len(self.data) > datarn and len(self.data[datarn]) > datacn else ""
+        value = (
+            self.data[datarn][datacn]
+            if len(self.data) > datarn and len(self.data[datarn]) > datacn
+            else self.get_value_for_empty_cell(datarn, datacn)
+        )
         kwargs = self.get_cell_kwargs(datarn, datacn, key="format")
         if kwargs and kwargs["formatter"] is not None:
             value = value.value  # assumed given formatter class has value attribute