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

tksheet/main_table.py

@@ -14,13 +14,16 @@ from tkinter import TclError
 from typing import Literal
 
 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,
@@ -45,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,
@@ -70,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,
@@ -92,20 +98,30 @@ from .other_classes import (
     SelectionBox,
     TextEditorStorage,
 )
+from .row_index import RowIndex
+from .sorting import sort_selection
 from .text_editor import TextEditor
-from .types import AnyIter
+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
@@ -176,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
 
@@ -239,50 +258,48 @@ 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
         self.align = kwargs["align"]
-
-        self.PAR.ops.table_font = [
+        self.PAR.ops.table_font = FontTuple(
             self.PAR.ops.table_font[0],
-            int(self.PAR.ops.table_font[1] * kwargs["zoom"] / 100),
+            max(1, int(self.PAR.ops.table_font[1] * kwargs["zoom"] / 100)),
             self.PAR.ops.table_font[2],
-        ]
-
-        self.PAR.ops.index_font = [
+        )
+        self.PAR.ops.index_font = FontTuple(
             self.PAR.ops.index_font[0],
-            int(self.PAR.ops.index_font[1] * kwargs["zoom"] / 100),
+            max(1, int(self.PAR.ops.index_font[1] * kwargs["zoom"] / 100)),
             self.PAR.ops.index_font[2],
-        ]
-
-        self.PAR.ops.header_font = [
+        )
+        self.PAR.ops.header_font = FontTuple(
             self.PAR.ops.header_font[0],
-            int(self.PAR.ops.header_font[1] * kwargs["zoom"] / 100),
+            max(1, int(self.PAR.ops.header_font[1] * kwargs["zoom"] / 100)),
             self.PAR.ops.header_font[2],
-        ]
-        for fnt in (self.PAR.ops.table_font, self.PAR.ops.index_font, self.PAR.ops.header_font):
-            if fnt[1] < 1:
-                fnt[1] = 1
-        self.PAR.ops.table_font = FontTuple(*self.PAR.ops.table_font)
-        self.PAR.ops.index_font = FontTuple(*self.PAR.ops.index_font)
-        self.PAR.ops.header_font = FontTuple(*self.PAR.ops.header_font)
-
+        )
         self.txt_measure_canvas = tk.Canvas(self)
         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"]
@@ -344,7 +361,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()
@@ -450,7 +467,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)
@@ -711,13 +728,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,
@@ -725,7 +742,7 @@ class MainTable(tk.Canvas):
                     dash=dash,
                     width=width,
                     outline=outline,
-                    tag=tag,
+                    tags=tags,
                     state="normal",
                 )
             self.lift(t)
@@ -739,7 +756,7 @@ class MainTable(tk.Canvas):
                 dash=dash,
                 width=width,
                 outline=outline,
-                tag=tag,
+                tags=tags,
             )
         self.disp_ctrl_outline[t] = True
 
@@ -778,15 +795,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()
@@ -831,12 +853,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()
@@ -912,17 +929,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
@@ -1081,7 +1145,7 @@ class MainTable(tk.Canvas):
             if ctr:
                 event_data = self.add_rows(
                     rows=rows,
-                    index=index,
+                    index=index if isinstance(self._row_index, list) and self._row_index else {},
                     row_heights=row_heights,
                     event_data=event_data,
                     mod_event_boxes=False,
@@ -1131,7 +1195,7 @@ class MainTable(tk.Canvas):
             if ctr:
                 event_data = self.add_columns(
                     columns=columns,
-                    header=headers,
+                    header=headers if isinstance(self._headers, list) and self._headers else {},
                     column_widths=column_widths,
                     event_data=event_data,
                     mod_event_boxes=False,
@@ -1179,12 +1243,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"):
@@ -1259,7 +1318,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 = {}
@@ -1268,22 +1326,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(),
@@ -1297,6 +1350,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,
@@ -1306,6 +1360,8 @@ class MainTable(tk.Canvas):
                         "columns",
                         run_binding=True,
                     )
+            else:
+                self.recreate_all_selection_boxes()
         if move_data:
             self.data = list(
                 map(
@@ -1459,29 +1515,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],
@@ -1491,8 +1572,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):
@@ -1502,54 +1584,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,
@@ -1567,6 +1628,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
@@ -1665,6 +1729,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:
@@ -1781,7 +1872,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"]:
@@ -1798,17 +1889,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
@@ -1839,7 +1938,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()))
@@ -1859,12 +1957,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)
@@ -1875,8 +1973,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)
@@ -1887,21 +1985,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(
@@ -1909,12 +2007,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:
@@ -1927,6 +2024,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
         ):
@@ -2819,7 +2918,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:
@@ -2845,7 +2944,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:
@@ -2867,6 +2966,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,
@@ -3037,6 +3229,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
@@ -3110,6 +3312,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"):
@@ -3255,12 +3467,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):
@@ -3768,38 +3980,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)
@@ -3843,13 +4031,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:
@@ -3880,62 +4075,95 @@ 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.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_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 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()
+                    ),
                 )
+            )
+        )
+
+    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.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)
+        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
@@ -3943,30 +4171,6 @@ class MainTable(tk.Canvas):
             self.PAR.ops.default_header_height = int(self.min_header_height)
         self.CH.set_height(self.get_default_header_height(), set_TL=True)
 
-    def 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')"
-                )
-            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 purge_undo_and_redo_stack(self):
         self.undo_stack = deque(maxlen=self.PAR.ops.max_undos)
         self.redo_stack = deque(maxlen=self.PAR.ops.max_undos)
@@ -4088,6 +4292,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,
@@ -4171,26 +4427,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:
@@ -4242,46 +4500,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",
@@ -4368,25 +4586,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
@@ -4436,32 +4642,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
@@ -4696,29 +4888,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()):
@@ -4737,14 +4927,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:
@@ -4770,7 +4960,6 @@ class MainTable(tk.Canvas):
             "table": columns,
             "header": header,
             "column_widths": column_widths,
-            "displayed_columns": saved_displayed_columns,
         }
         return event_data
 
@@ -4807,17 +4996,14 @@ 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
+        columns, headers, widths = self.get_args_for_add_columns(data_ins_col, displayed_ins_col, numcols)
         event_data = self.add_columns(
-            *self.get_args_for_add_columns(data_ins_col, displayed_ins_col, numcols),
+            columns=columns,
+            header=headers if isinstance(self._headers, list) and self._headers else {},
+            column_widths=widths,
             event_data=event_data,
         )
         if self.undo_enabled:
@@ -4828,34 +5014,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()):
@@ -4874,14 +5059,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)),
@@ -4905,8 +5090,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):
@@ -4942,17 +5128,14 @@ 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
+        rows, index, heights = self.get_args_for_add_rows(data_ins_row, displayed_ins_row, numrows)
         event_data = self.add_rows(
-            *self.get_args_for_add_rows(data_ins_row, displayed_ins_row, numrows),
+            rows=rows,
+            index=index if isinstance(self._row_index, list) and self._row_index else {},
+            row_heights=heights,
             event_data=event_data,
         )
         if self.undo_enabled:
@@ -5029,10 +5212,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()
@@ -5072,11 +5259,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):
@@ -5104,41 +5307,72 @@ 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,
+        if self.all_columns_displayed:
+            data_columns = columns
+            disp_columns = columns
+        else:
+            if data_indexes:
+                data_columns = columns
+                disp_columns = data_to_displayed_idxs(data_columns, self.displayed_columns)
+            else:
+                data_columns = [self.displayed_columns[c] for c in columns]
+                disp_columns = columns
+        event_data = self.delete_columns_displayed(
+            disp_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(
+            data_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):
@@ -5147,6 +5381,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,
@@ -5160,35 +5396,78 @@ 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 self.all_rows_displayed:
+            data_rows = rows
+            disp_rows = rows
+        else:
+            if data_indexes:
+                data_rows = rows
+                disp_rows = data_to_displayed_idxs(data_rows, self.displayed_rows)
+            else:
+                data_rows = [self.displayed_rows[r] for r in rows]
+                disp_rows = 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(
+            disp_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:
@@ -5593,9 +5872,8 @@ class MainTable(tk.Canvas):
                 self.itemconfig(iid, fill=fill, outline=outline)
             else:
                 self.itemconfig(iid, fill=fill, outline=outline, state="normal")
-            self.tag_raise(iid)
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline, tags="h")
         self.disp_high[iid] = True
         return True
 
@@ -5621,7 +5899,6 @@ class MainTable(tk.Canvas):
                         joinstyle=tk.ROUND,
                         state="normal",
                     )
-                self.tag_raise(iid)
             else:
                 iid = self.create_line(
                     points,
@@ -5811,12 +6088,67 @@ 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()
@@ -5838,29 +6170,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(
@@ -5873,7 +6209,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)
@@ -5883,19 +6222,71 @@ 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 = {}
-        x_stop = min(last_col_line_pos, scrollpos_right)
-        y_stop = min(last_row_line_pos, scrollpos_bot)
+        # 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:
+                    if last_col_line_pos > scrollpos_right:
+                        x_grid_stop = x_stop + 1
+                    else:
+                        x_grid_stop = x_stop - 1
+                self.redraw_gridline(
+                    points=tuple(
+                        chain.from_iterable(
+                            (
+                                scrollpos_left - 1,
+                                self.row_positions[r],
+                                x_grid_stop,
+                                self.row_positions[r],
+                                scrollpos_left - 1,
+                                self.row_positions[r],
+                                scrollpos_left - 1,
+                                self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
+                            )
+                            for r in range(grid_start_row, grid_end_row)
+                        )
+                    )
+                )
+            # manage vertical grid lines
+            if self.PAR.ops.show_vertical_grid and col_pos_exists:
+                if self.PAR.ops.vertical_grid_to_end_of_window:
+                    y_grid_stop = scrollpos_bot + can_height
+                else:
+                    if last_row_line_pos > scrollpos_bot:
+                        y_grid_stop = y_stop + 1
+                    else:
+                        y_grid_stop = y_stop - 1
+                self.redraw_gridline(
+                    points=tuple(
+                        chain.from_iterable(
+                            (
+                                self.col_positions[c],
+                                scrollpos_top - 1,
+                                self.col_positions[c],
+                                y_grid_stop,
+                                self.col_positions[c],
+                                scrollpos_top - 1,
+                                self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
+                                scrollpos_top - 1,
+                            )
+                            for c in range(grid_start_col, grid_end_col)
+                        )
+                    ),
+                )
             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)
@@ -5927,17 +6318,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]
-                if rbotgridln - rtopgridln < self.table_txt_height:
-                    continue
-                datarn = self.datarn(r)
+                datarn = cells["datarn"][r]
 
                 for c in range(text_start_col, text_end_col):
                     cleftgridln = self.col_positions[c]
                     crightgridln = self.col_positions[c + 1]
-                    datacn = self.datacn(c)
+                    datacn = cells["datacn"][c]
                     fill, dd_drawn = self.redraw_highlight_get_text_fg(
                         r=r,
                         c=c,
@@ -5957,13 +6354,14 @@ class MainTable(tk.Canvas):
                     )
                     if not (align := self.get_cell_kwargs(datarn, datacn, key="align")):
                         align = self.align
-                    if kwargs := self.get_cell_kwargs(datarn, datacn, key="dropdown"):
-                        mw = crightgridln - cleftgridln - self.table_txt_height - 2
-                        if align == "w":
-                            draw_x = cleftgridln + 3
-                        elif align == "e":
+
+                    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
-                        elif align == "center":
+                        elif align.endswith("n"):
                             draw_x = cleftgridln + ceil((crightgridln - cleftgridln - self.table_txt_height) / 2)
                         self.redraw_dropdown(
                             cleftgridln,
@@ -5973,25 +6371,27 @@ class MainTable(tk.Canvas):
                             fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
                             outline=fill,
                             draw_outline=not dd_drawn,
-                            draw_arrow=mw >= 5,
+                            draw_arrow=max_width >= 5,
                             open_=dd_coords == (r, c),
                         )
                     else:
-                        mw = crightgridln - cleftgridln - 1
-                        if align == "w":
-                            draw_x = cleftgridln + 3
-                        elif align == "e":
-                            draw_x = crightgridln - 3
-                        elif align == "center":
+                        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)
-                        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 = bool(self.data[datarn][datacn])
                             except Exception:
@@ -6005,27 +6405,77 @@ class MainTable(tk.Canvas):
                                 outline="",
                                 draw_check=draw_check,
                             )
-                    lines = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
+                    text = cells[(datarn, datacn)]
                     if (
-                        not lines
-                        or mw < self.table_txt_width
-                        or (align == "w" and draw_x > scrollpos_right)
-                        or (align == "e" and cleftgridln + 5 > scrollpos_right)
-                        or (align == "center" and cleftgridln + 5 > scrollpos_right)
+                        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)
                     ):
                         continue
-                    lines = lines.split("\n")
-                    start_ln = max(0, int((scrollpos_top - rtopgridln) / self.table_xtra_lines_increment))
-                    draw_y = rtopgridln + self.table_first_ln_ins + start_ln * self.table_xtra_lines_increment
-                    if draw_y + self.table_half_txt_height - 1 <= rbotgridln and len(lines) >= start_ln:
-                        for txt in islice(lines, start_ln, None):
+                    if 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=txt,
+                                        text=text,
                                         fill=fill,
                                         font=font,
                                         anchor=align,
@@ -6033,7 +6483,7 @@ class MainTable(tk.Canvas):
                                 else:
                                     self.itemconfig(
                                         iid,
-                                        text=txt,
+                                        text=text,
                                         fill=fill,
                                         font=font,
                                         anchor=align,
@@ -6044,96 +6494,14 @@ class MainTable(tk.Canvas):
                                 iid = self.create_text(
                                     draw_x,
                                     draw_y,
-                                    text=txt,
+                                    text=text,
                                     fill=fill,
                                     font=font,
                                     anchor=align,
-                                    tag="t",
+                                    tags="t",
                                 )
                             self.disp_text[iid] = True
-                            wd = self.bbox(iid)
-                            if (wd := wd[2] - wd[0]) > mw:
-                                if align == "w":
-                                    txt = txt[: int(len(txt) * (mw / wd))]
-                                    self.itemconfig(iid, text=txt)
-                                    wd = self.bbox(iid)
-                                    while wd[2] - wd[0] > mw:
-                                        txt = txt[:-1]
-                                        self.itemconfig(iid, text=txt)
-                                        wd = self.bbox(iid)
-                                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":
-                                    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
-            # manage horizontal grid lines
-            if self.PAR.ops.show_horizontal_grid and row_pos_exists:
-                if self.PAR.ops.horizontal_grid_to_end_of_window:
-                    x_grid_stop = scrollpos_right + can_width
-                else:
-                    if last_col_line_pos > scrollpos_right:
-                        x_grid_stop = x_stop + 1
-                    else:
-                        x_grid_stop = x_stop - 1
-                self.redraw_gridline(
-                    points=tuple(
-                        chain.from_iterable(
-                            (
-                                scrollpos_left - 1,
-                                self.row_positions[r],
-                                x_grid_stop,
-                                self.row_positions[r],
-                                scrollpos_left - 1,
-                                self.row_positions[r],
-                                scrollpos_left - 1,
-                                self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
-                            )
-                            for r in range(grid_start_row, grid_end_row)
-                        )
-                    )
-                )
-            # manage vertical grid lines
-            if self.PAR.ops.show_vertical_grid and col_pos_exists:
-                if self.PAR.ops.vertical_grid_to_end_of_window:
-                    y_grid_stop = scrollpos_bot + can_height
-                else:
-                    if last_row_line_pos > scrollpos_bot:
-                        y_grid_stop = y_stop + 1
-                    else:
-                        y_grid_stop = y_stop - 1
-                self.redraw_gridline(
-                    points=tuple(
-                        chain.from_iterable(
-                            (
-                                self.col_positions[c],
-                                scrollpos_top - 1,
-                                self.col_positions[c],
-                                y_grid_stop,
-                                self.col_positions[c],
-                                scrollpos_top - 1,
-                                self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
-                                scrollpos_top - 1,
-                            )
-                            for c in range(grid_start_col, grid_end_col)
-                        )
-                    ),
-                )
+                            draw_y += self.table_txt_height
             for dct in (
                 self.hidd_text,
                 self.hidd_high,
@@ -6166,6 +6534,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(
@@ -6178,6 +6547,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)
@@ -6902,7 +7272,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
@@ -6971,7 +7341,7 @@ class MainTable(tk.Canvas):
             > curr_height
         ):
             new_height = min(
-                curr_height + self.table_xtra_lines_increment,
+                curr_height + self.table_txt_height,
                 self.scrollregion[3] - self.scrollregion[1] - self.row_positions[r],
             )
             if new_height != curr_height:
@@ -7218,7 +7588,7 @@ 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:
@@ -7669,7 +8039,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,
@@ -7682,7 +8052,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