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

tksheet/row_index.py

@@ -2,83 +2,61 @@ from __future__ import annotations
 
 import tkinter as tk
 from collections import defaultdict
-from collections.abc import (
-    Generator,
-    Hashable,
-    Sequence,
-)
-from functools import (
-    partial,
-)
-from itertools import (
-    chain,
-    cycle,
-    islice,
-    repeat,
-)
-from math import (
-    ceil,
-    floor,
-)
-from operator import (
-    itemgetter,
-)
+from collections.abc import Callable, Generator, Hashable, Sequence
+from functools import partial
+from itertools import chain, cycle, islice, repeat
+from math import ceil, floor
+from operator import itemgetter
 from typing import Literal
 
-from .colors import (
-    color_map,
-)
+from .colors import color_map
 from .constants import (
+    _test_str,
     rc_binding,
     text_editor_close_bindings,
     text_editor_newline_bindings,
     text_editor_to_unbind,
 )
-from .formatters import (
-    is_bool_like,
-    try_to_bool,
-)
+from .formatters import is_bool_like, try_to_bool
 from .functions import (
     consecutive_chunks,
     consecutive_ranges,
+    del_placeholder_dict_key,
     event_dict,
     event_has_char_key,
     event_opens_dropdown_or_checkbox,
     get_n2a,
+    get_new_indexes,
     int_x_tuple,
     is_contiguous,
+    mod_event_val,
     new_tk_event,
     num2alpha,
     rounded_box_coords,
     stored_event_dict,
+    try_b_index,
     try_binding,
+    wrap_text,
 )
-from .other_classes import (
-    DotDict,
-    DraggedRowColumn,
-    DropdownStorage,
-    Node,
-    TextEditorStorage,
-)
-from .text_editor import (
-    TextEditor,
-)
-from .types import (
-    AnyIter,
-)
+from .other_classes import DotDict, DraggedRowColumn, DropdownStorage, EventDataDict, Node, TextEditorStorage
+from .sorting import sort_columns_by_row, sort_row
+from .text_editor import TextEditor
+from .tksheet_types import AnyIter
 
 
 class RowIndex(tk.Canvas):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, parent, **kwargs):
         super().__init__(
-            kwargs["parent"],
-            background=kwargs["parent"].ops.index_bg,
+            parent,
+            background=parent.ops.index_bg,
             highlightthickness=0,
         )
-        self.PAR = kwargs["parent"]
+        self.PAR = parent
+        self.ops = self.PAR.ops
         self.MT = None  # is set from within MainTable() __init__
         self.CH = None  # is set from within MainTable() __init__
         self.TL = None  # is set from within TopLeftRectangle() __init__
+        self.new_iid_ctr = -1
         self.current_width = None
         self.popup_menu_loc = None
         self.extra_begin_edit_cell_func = None
@@ -99,6 +77,8 @@ class RowIndex(tk.Canvas):
         self.drag_selection_binding_func = None
         self.ri_extra_begin_drag_drop_func = None
         self.ri_extra_end_drag_drop_func = None
+        self.ri_extra_begin_sort_cols_func = None
+        self.ri_extra_end_sort_cols_func = None
         self.extra_double_b1_func = None
         self.row_height_resize_func = None
         self.cell_options = {}
@@ -170,18 +150,6 @@ class RowIndex(tk.Canvas):
             self.unbind("<Double-Button-1>")
             self.unbind(rc_binding)
 
-    def tree_reset(self) -> None:
-        # treeview mode
-        self.tree = {}
-        self.tree_open_ids = set()
-        self.tree_rns = {}
-        if self.MT:
-            self.MT.displayed_rows = []
-            self.MT._row_index = []
-            self.MT.data = []
-            self.MT.row_positions = [0]
-            self.MT.saved_row_heights = {}
-
     def set_width(self, new_width: int, set_TL: bool = False, recreate_selection_boxes: bool = True) -> None:
         try:
             self.config(width=new_width)
@@ -364,9 +332,9 @@ class RowIndex(tk.Canvas):
             if (
                 self.width_resizing_enabled
                 and not mouse_over_resize
-                and self.PAR.ops.auto_resize_row_index is not True
+                and self.ops.auto_resize_row_index is not True
                 and not (
-                    self.PAR.ops.auto_resize_row_index == "empty"
+                    self.ops.auto_resize_row_index == "empty"
                     and not isinstance(self.MT._row_index, int)
                     and not self.MT._row_index
                 )
@@ -421,7 +389,7 @@ class RowIndex(tk.Canvas):
                 )
         elif self.width_resizing_enabled and self.rsz_h is None and self.rsz_w is True:
             self.set_width_of_index_to_text()
-        elif (self.row_selection_enabled or self.PAR.ops.treeview) and self.rsz_h is None and self.rsz_w is None:
+        elif (self.row_selection_enabled or self.ops.treeview) and self.rsz_h is None and self.rsz_w is None:
             r = self.MT.identify_row(y=event.y)
             if r < len(self.MT.row_positions) - 1:
                 iid = self.event_over_tree_arrow(r, self.canvasy(event.y), event.x)
@@ -471,20 +439,22 @@ class RowIndex(tk.Canvas):
                 self.current_width,
                 y,
                 width=1,
-                fill=self.PAR.ops.resizing_line_fg,
-                tag="rhl",
+                fill=self.ops.resizing_line_fg,
+                tag=("rh", "rhl"),
             )
-            self.MT.create_resize_line(x1, y, x2, y, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rhl")
+            self.MT.create_resize_line(x1, y, x2, y, width=1, fill=self.ops.resizing_line_fg, tag=("rh", "rhl"))
             self.create_resize_line(
                 0,
                 line2y,
                 self.current_width,
                 line2y,
                 width=1,
-                fill=self.PAR.ops.resizing_line_fg,
-                tag="rhl2",
+                fill=self.ops.resizing_line_fg,
+                tag=("rh", "rhl2"),
+            )
+            self.MT.create_resize_line(
+                x1, line2y, x2, line2y, width=1, fill=self.ops.resizing_line_fg, tag=("rh", "rhl2")
             )
-            self.MT.create_resize_line(x1, line2y, x2, line2y, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rhl2")
         elif self.width_resizing_enabled and self.rsz_h is None and self.rsz_w is True:
             self.currently_resizing_width = True
         elif self.MT.identify_row(y=event.y, allow_end=False) is None:
@@ -515,7 +485,7 @@ class RowIndex(tk.Canvas):
         if self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             y = self.canvasy(event.y)
             size = y - self.MT.row_positions[self.rsz_h - 1]
-            if size >= self.MT.min_row_height and size < self.PAR.ops.max_row_height:
+            if size >= self.MT.min_row_height and size < self.ops.max_row_height:
                 self.hide_resize_and_ctrl_lines(ctrl_lines=False)
                 line2y = self.MT.row_positions[self.rsz_h - 1]
                 self.create_resize_line(
@@ -524,18 +494,18 @@ class RowIndex(tk.Canvas):
                     self.current_width,
                     y,
                     width=1,
-                    fill=self.PAR.ops.resizing_line_fg,
-                    tag="rhl",
+                    fill=self.ops.resizing_line_fg,
+                    tag=("rh", "rhl"),
                 )
-                self.MT.create_resize_line(x1, y, x2, y, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rhl")
+                self.MT.create_resize_line(x1, y, x2, y, width=1, fill=self.ops.resizing_line_fg, tag=("rh", "rhl"))
                 self.create_resize_line(
                     0,
                     line2y,
                     self.current_width,
                     line2y,
                     width=1,
-                    fill=self.PAR.ops.resizing_line_fg,
-                    tag="rhl2",
+                    fill=self.ops.resizing_line_fg,
+                    tag=("rh", "rhl2"),
                 )
                 self.MT.create_resize_line(
                     x1,
@@ -543,19 +513,19 @@ class RowIndex(tk.Canvas):
                     x2,
                     line2y,
                     width=1,
-                    fill=self.PAR.ops.resizing_line_fg,
-                    tag="rhl2",
+                    fill=self.ops.resizing_line_fg,
+                    tag=("rh", "rhl2"),
                 )
                 self.drag_height_resize()
         elif self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             evx = event.x
             if evx > self.current_width:
-                if evx > self.PAR.ops.max_index_width:
-                    evx = int(self.PAR.ops.max_index_width)
+                if evx > self.ops.max_index_width:
+                    evx = int(self.ops.max_index_width)
                 self.drag_width_resize(evx)
             else:
-                if evx < self.PAR.ops.min_column_width:
-                    evx = self.PAR.ops.min_column_width
+                if evx < self.ops.min_column_width:
+                    evx = self.ops.min_column_width
                 self.drag_width_resize(evx)
         elif (
             self.drag_and_drop_enabled
@@ -712,16 +682,16 @@ class RowIndex(tk.Canvas):
             self.current_width,
             ypos,
             width=3,
-            fill=self.PAR.ops.drag_and_drop_bg,
+            fill=self.ops.drag_and_drop_bg,
             tag="move_rows",
         )
-        self.MT.create_resize_line(x1, ypos, x2, ypos, width=3, fill=self.PAR.ops.drag_and_drop_bg, tag="move_rows")
+        self.MT.create_resize_line(x1, ypos, x2, ypos, width=3, fill=self.ops.drag_and_drop_bg, tag="move_rows")
         for chunk in consecutive_chunks(rows):
             self.MT.show_ctrl_outline(
                 start_cell=(0, chunk[0]),
                 end_cell=(len(self.MT.col_positions) - 1, chunk[-1] + 1),
                 dash=(),
-                outline=self.PAR.ops.drag_and_drop_bg,
+                outline=self.ops.drag_and_drop_bg,
                 delete_on_timer=False,
             )
 
@@ -785,8 +755,8 @@ class RowIndex(tk.Canvas):
         size = new_row_pos - self.MT.row_positions[self.rsz_h - 1]
         if size < self.MT.min_row_height:
             new_row_pos = ceil(self.MT.row_positions[self.rsz_h - 1] + self.MT.min_row_height)
-        elif size > self.PAR.ops.max_row_height:
-            new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.PAR.ops.max_row_height)
+        elif size > self.ops.max_row_height:
+            new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.ops.max_row_height)
         increment = new_row_pos - self.MT.row_positions[self.rsz_h]
         self.MT.row_positions[self.rsz_h + 1 :] = [
             e + increment for e in islice(self.MT.row_positions, self.rsz_h + 1, None)
@@ -795,7 +765,7 @@ class RowIndex(tk.Canvas):
         new_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
         self.MT.allow_auto_resize_rows = False
         self.MT.recreate_all_selection_boxes()
-        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, set_scrollregion=False)
         if self.row_height_resize_func is not None and old_height != new_height:
             self.row_height_resize_func(
                 event_dict(
@@ -821,6 +791,7 @@ class RowIndex(tk.Canvas):
         if self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             self.drag_height_resize()
             self.hide_resize_and_ctrl_lines(ctrl_lines=False)
+            self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         elif (
             self.drag_and_drop_enabled
             and self.MT.anything_selected(exclude_cells=True, exclude_columns=True)
@@ -846,33 +817,28 @@ class RowIndex(tk.Canvas):
                     r += 1
                 if r > len(self.MT.row_positions) - 1:
                     r = len(self.MT.row_positions) - 1
-                event_data = event_dict(
-                    name="move_rows",
-                    sheet=self.PAR.name,
-                    widget=self,
-                    boxes=self.MT.get_boxes(),
-                    selected=self.MT.selected,
-                    value=r,
-                )
+                event_data = self.MT.new_event_dict("move_rows", state=True)
+                event_data["value"] = r
                 if try_binding(self.ri_extra_begin_drag_drop_func, event_data, "begin_move_rows"):
                     data_new_idxs, disp_new_idxs, event_data = self.MT.move_rows_adjust_options_dict(
                         *self.MT.get_args_for_move_rows(
                             move_to=r,
                             to_move=self.dragged_row.to_move,
                         ),
-                        move_data=self.PAR.ops.row_drag_and_drop_perform,
-                        move_heights=self.PAR.ops.row_drag_and_drop_perform,
+                        move_data=self.ops.row_drag_and_drop_perform,
+                        move_heights=self.ops.row_drag_and_drop_perform,
                         event_data=event_data,
                     )
-                    event_data["moved"]["rows"] = {
-                        "data": data_new_idxs,
-                        "displayed": disp_new_idxs,
-                    }
-                    if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(stored_event_dict(event_data))
-                    self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-                    try_binding(self.ri_extra_end_drag_drop_func, event_data, "end_move_rows")
-                    self.MT.sheet_modified(event_data)
+                    if data_new_idxs and disp_new_idxs:
+                        event_data["moved"]["rows"] = {
+                            "data": data_new_idxs,
+                            "displayed": disp_new_idxs,
+                        }
+                        if self.MT.undo_enabled:
+                            self.MT.undo_stack.append(stored_event_dict(event_data))
+                        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+                        try_binding(self.ri_extra_end_drag_drop_func, event_data, "end_move_rows")
+                        self.MT.sheet_modified(event_data)
         elif self.b1_pressed_loc is not None and self.rsz_w is None and self.rsz_h is None:
             r = self.MT.identify_row(y=event.y)
             if (
@@ -909,7 +875,7 @@ class RowIndex(tk.Canvas):
         canvasy: float,
         eventx: int,
     ) -> bool:
-        if self.PAR.ops.treeview and (
+        if self.ops.treeview and (
             canvasy < self.MT.row_positions[r] + self.MT.index_txt_height + 5
             and isinstance(self.MT._row_index, list)
             and (datarn := self.MT.datarn(r)) < len(self.MT._row_index)
@@ -920,6 +886,96 @@ class RowIndex(tk.Canvas):
             return iid
         return None
 
+    def _sort_rows(
+        self,
+        event: tk.Event | None = None,
+        rows: AnyIter[int] | None = None,
+        reverse: bool = False,
+        validation: bool = True,
+        key: Callable | None = None,
+        undo: bool = True,
+    ) -> EventDataDict:
+        if rows is None:
+            rows = self.MT.get_selected_rows()
+        if not rows:
+            rows = list(range(0, len(self.MT.row_positions) - 1))
+        event_data = self.MT.new_event_dict("edit_table")
+        try_binding(self.MT.extra_begin_sort_cells_func, event_data)
+        for r in rows:
+            datarn = self.MT.datarn(r)
+            for c, val in enumerate(sort_row(self.MT.data[datarn], reverse=reverse, key=key)):
+                if (
+                    not self.MT.edit_validation_func
+                    or not validation
+                    or (
+                        self.MT.edit_validation_func
+                        and (val := self.MT.edit_validation_func(mod_event_val(event_data, val, (datarn, c))))
+                        is not None
+                    )
+                ):
+                    event_data = self.MT.event_data_set_cell(
+                        datarn=datarn,
+                        datacn=c,
+                        value=val,
+                        event_data=event_data,
+                    )
+        if event_data["cells"]["table"]:
+            if undo and self.MT.undo_enabled:
+                self.MT.undo_stack.append(stored_event_dict(event_data))
+            try_binding(self.MT.extra_end_sort_cells_func, event_data, "end_edit_table")
+            self.MT.sheet_modified(event_data)
+            self.PAR.emit_event("<<SheetModified>>", event_data)
+            self.MT.refresh()
+        return event_data
+
+    def _sort_columns_by_row(
+        self,
+        event: tk.Event | None = None,
+        row: int | None = None,
+        reverse: bool = False,
+        key: Callable | None = None,
+        undo: bool = True,
+    ) -> EventDataDict:
+        event_data = self.MT.new_event_dict("sort_columns", state=True)
+        if not self.MT.data:
+            return event_data
+        if row is None:
+            if not self.MT.selected:
+                return event_data
+            row = self.MT.selected.row
+        if try_binding(self.ri_extra_begin_sort_cols_func, event_data, "begin_sort_columns"):
+            sorted_indices, data_new_idxs = sort_columns_by_row(self.MT.data, row=row, reverse=reverse, key=key)
+            disp_new_idxs = {}
+            if self.MT.all_columns_displayed:
+                disp_new_idxs = data_new_idxs
+            else:
+                col_ctr = 0
+                # idx is the displayed index, can just do range
+                for old_idx in sorted_indices:
+                    if (idx := try_b_index(self.MT.displayed_columns, old_idx)) is not None:
+                        disp_new_idxs[idx] = col_ctr
+                        col_ctr += 1
+            data_new_idxs, disp_new_idxs, _ = self.PAR.mapping_move_columns(
+                data_new_idxs=data_new_idxs,
+                disp_new_idxs=disp_new_idxs,
+                move_data=True,
+                create_selections=False,
+                undo=False,
+                emit_event=False,
+                redraw=True,
+            )
+            event_data["moved"]["columns"] = {
+                "data": data_new_idxs,
+                "displayed": disp_new_idxs,
+            }
+            if undo and self.MT.undo_enabled:
+                self.MT.undo_stack.append(stored_event_dict(event_data))
+            try_binding(self.ri_extra_end_sort_cols_func, event_data, "end_sort_columns")
+            self.MT.sheet_modified(event_data)
+            self.PAR.emit_event("<<SheetModified>>", event_data)
+            self.MT.refresh()
+        return event_data
+
     def toggle_select_row(
         self,
         row: int,
@@ -1008,7 +1064,7 @@ class RowIndex(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=5 if self.PAR.ops.rounded_boxes else 0,
+            radius=5 if self.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1039,27 +1095,42 @@ class RowIndex(tk.Canvas):
     def get_cell_dimensions(self, datarn: int) -> tuple[int, int]:
         txt = self.get_valid_cell_data_as_str(datarn, fix=False)
         if txt:
-            self.MT.txt_measure_canvas.itemconfig(
-                self.MT.txt_measure_canvas_text, text=txt, font=self.PAR.ops.index_font
-            )
+            self.MT.txt_measure_canvas.itemconfig(self.MT.txt_measure_canvas_text, text=txt, font=self.ops.index_font)
             b = self.MT.txt_measure_canvas.bbox(self.MT.txt_measure_canvas_text)
             w = b[2] - b[0] + 7
             h = b[3] - b[1] + 5
         else:
-            w = self.PAR.ops.default_row_index_width
+            w = self.ops.default_row_index_width
             h = self.MT.min_row_height
         if self.get_cell_kwargs(datarn, key="dropdown") or self.get_cell_kwargs(datarn, key="checkbox"):
             w += self.MT.index_txt_height + 2
-        if self.PAR.ops.treeview:
+        if self.ops.treeview:
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
             else:
                 align = self.align
-            if align == "w":
+            if align.endswith("w"):
                 w += self.MT.index_txt_height
             w += self.get_iid_indent(self.MT._row_index[datarn].iid) + 10
         return w, h
 
+    def get_wrapped_cell_height(self, datarn: int) -> int:
+        n_lines = max(
+            1,
+            sum(
+                1
+                for _ in wrap_text(
+                    text=self.get_valid_cell_data_as_str(datarn, fix=False),
+                    max_width=self.current_width,
+                    max_lines=float("inf"),
+                    char_width_fn=self.wrap_get_char_w,
+                    widths=self.MT.char_widths[self.index_font],
+                    wrap=self.ops.index_wrap,
+                )
+            ),
+        )
+        return 3 + (n_lines * self.MT.index_txt_height)
+
     def get_row_text_height(
         self,
         row: int,
@@ -1069,7 +1140,7 @@ class RowIndex(tk.Canvas):
         h = self.MT.min_row_height
         datarn = row if self.MT.all_rows_displayed else self.MT.displayed_rows[row]
         # index
-        _w, ih = self.get_cell_dimensions(datarn)
+        ih = self.get_wrapped_cell_height(datarn)
         # table
         if self.MT.data:
             if self.MT.all_columns_displayed:
@@ -1086,20 +1157,22 @@ class RowIndex(tk.Canvas):
                 else:
                     start_col, end_col = 0, len(self.MT.displayed_columns)
                 iterable = self.MT.displayed_columns[start_col:end_col]
-            for datacn in iterable:
-                if (txt := self.MT.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)) and (
-                    th := self.MT.get_txt_h(txt) + 5
-                ) > h:
-                    h = th
-        if ih > h:
-            h = ih
+            h = max(
+                h,
+                max(
+                    self.MT.get_wrapped_cell_height(
+                        datarn,
+                        datacn,
+                    )
+                    for datacn in iterable
+                ),
+            )
+            self.MT.cells_cache = None
+        h = max(h, ih)
         if only_if_too_small and h < self.MT.row_positions[row + 1] - self.MT.row_positions[row]:
             return self.MT.row_positions[row + 1] - self.MT.row_positions[row]
-        if h < self.MT.min_row_height:
-            h = int(self.MT.min_row_height)
-        elif h > self.PAR.ops.max_row_height:
-            h = int(self.PAR.ops.max_row_height)
-        return h
+        else:
+            return max(int(min(h, self.ops.max_row_height)), self.MT.min_row_height)
 
     def set_row_height(
         self,
@@ -1113,8 +1186,8 @@ class RowIndex(tk.Canvas):
             height = self.get_row_text_height(row=row, visible_only=visible_only)
         if height < self.MT.min_row_height:
             height = int(self.MT.min_row_height)
-        elif height > self.PAR.ops.max_row_height:
-            height = int(self.PAR.ops.max_row_height)
+        elif height > self.ops.max_row_height:
+            height = int(self.ops.max_row_height)
         if only_if_too_small and height <= self.MT.row_positions[row + 1] - self.MT.row_positions[row]:
             return self.MT.row_positions[row + 1] - self.MT.row_positions[row]
         new_row_pos = self.MT.row_positions[row] + height
@@ -1132,7 +1205,7 @@ class RowIndex(tk.Canvas):
         only_rows: AnyIter[int] | None = None,
     ) -> int:
         self.fix_index()
-        w = self.PAR.ops.default_row_index_width
+        w = self.ops.default_row_index_width
         if (not self.MT._row_index and isinstance(self.MT._row_index, list)) or (
             isinstance(self.MT._row_index, int) and self.MT._row_index >= len(self.MT.data)
         ):
@@ -1148,8 +1221,8 @@ class RowIndex(tk.Canvas):
             iterable = self.MT.displayed_rows
         if (new_w := max(map(itemgetter(0), map(self.get_cell_dimensions, iterable)), default=w)) > w:
             w = new_w
-        if w > self.PAR.ops.max_index_width:
-            w = int(self.PAR.ops.max_index_width)
+        if w > self.ops.max_index_width:
+            w = int(self.ops.max_index_width)
         return w
 
     def set_width_of_index_to_text(
@@ -1158,7 +1231,7 @@ class RowIndex(tk.Canvas):
         only_rows: list = [],
     ) -> int:
         self.fix_index()
-        w = self.PAR.ops.default_row_index_width
+        w = self.ops.default_row_index_width
         if (text is None and isinstance(self.MT._row_index, list) and not self.MT._row_index) or (
             isinstance(self.MT._row_index, int) and self.MT._row_index >= len(self.MT.data)
         ):
@@ -1170,8 +1243,8 @@ class RowIndex(tk.Canvas):
                 w = tw
         elif text is None:
             w = self.get_index_text_width(only_rows=only_rows)
-        if w > self.PAR.ops.max_index_width:
-            w = int(self.PAR.ops.max_index_width)
+        if w > self.ops.max_index_width:
+            w = int(self.ops.max_index_width)
         self.set_width(w, set_TL=True)
         self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         return w
@@ -1200,15 +1273,15 @@ class RowIndex(tk.Canvas):
 
     def auto_set_index_width(self, end_row: int, only_rows: list) -> bool:
         if not isinstance(self.MT._row_index, int) and not self.MT._row_index:
-            if self.PAR.ops.default_row_index == "letters":
-                new_w = self.MT.get_txt_w(f"{num2alpha(end_row)}") + 20
-            elif self.PAR.ops.default_row_index == "numbers":
-                new_w = self.MT.get_txt_w(f"{end_row}") + 20
-            elif self.PAR.ops.default_row_index == "both":
-                new_w = self.MT.get_txt_w(f"{end_row + 1} {num2alpha(end_row)}") + 20
-            elif self.PAR.ops.default_row_index is None:
+            if self.ops.default_row_index == "letters":
+                new_w = self.MT.get_txt_w(f"{num2alpha(end_row)}", self.index_font) + 20
+            elif self.ops.default_row_index == "numbers":
+                new_w = self.MT.get_txt_w(f"{end_row}", self.index_font) + 20
+            elif self.ops.default_row_index == "both":
+                new_w = self.MT.get_txt_w(f"{end_row + 1} {num2alpha(end_row)}", self.index_font) + 20
+            elif self.ops.default_row_index is None:
                 new_w = 20
-        elif self.PAR.ops.auto_resize_row_index is True:
+        elif self.ops.auto_resize_row_index is True:
             new_w = self.get_index_text_width(only_rows=only_rows)
         else:
             new_w = None
@@ -1239,8 +1312,8 @@ class RowIndex(tk.Canvas):
                 fill = color_map[fill]
             if "rows" in selections and r in selections["rows"]:
                 txtfg = (
-                    self.PAR.ops.index_selected_rows_fg
-                    if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
+                    self.ops.index_selected_rows_fg
+                    if kwargs[1] is None or self.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
                 if fill:
@@ -1251,8 +1324,8 @@ class RowIndex(tk.Canvas):
                     )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = (
-                    self.PAR.ops.index_selected_cells_fg
-                    if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
+                    self.ops.index_selected_cells_fg
+                    if kwargs[1] is None or self.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
                 if fill:
@@ -1262,7 +1335,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(fill[5:], 16) + int(sel_cells_bg[5:], 16)) / 2):02X}"
                     )
             else:
-                txtfg = self.PAR.ops.index_fg if kwargs[1] is None else kwargs[1]
+                txtfg = self.ops.index_fg if kwargs[1] is None else kwargs[1]
             if fill:
                 redrawn = self.redraw_highlight(
                     0,
@@ -1271,8 +1344,8 @@ class RowIndex(tk.Canvas):
                     sr,
                     fill=fill,
                     outline=(
-                        self.PAR.ops.index_fg
-                        if self.get_cell_kwargs(datarn, key="dropdown") and self.PAR.ops.show_dropdown_borders
+                        self.ops.index_fg
+                        if self.get_cell_kwargs(datarn, key="dropdown") and self.ops.show_dropdown_borders
                         else ""
                     ),
                     tag="s",
@@ -1280,14 +1353,14 @@ class RowIndex(tk.Canvas):
             tree_arrow_fg = txtfg
         elif not kwargs:
             if "rows" in selections and r in selections["rows"]:
-                txtfg = self.PAR.ops.index_selected_rows_fg
-                tree_arrow_fg = self.PAR.ops.selected_rows_tree_arrow_fg
+                txtfg = self.ops.index_selected_rows_fg
+                tree_arrow_fg = self.ops.selected_rows_tree_arrow_fg
             elif "cells" in selections and r in selections["cells"]:
-                txtfg = self.PAR.ops.index_selected_cells_fg
-                tree_arrow_fg = self.PAR.ops.selected_cells_tree_arrow_fg
+                txtfg = self.ops.index_selected_cells_fg
+                tree_arrow_fg = self.ops.selected_cells_tree_arrow_fg
             else:
-                txtfg = self.PAR.ops.index_fg
-                tree_arrow_fg = self.PAR.ops.tree_arrow_fg
+                txtfg = self.ops.index_fg
+                tree_arrow_fg = self.ops.tree_arrow_fg
         return txtfg, tree_arrow_fg, redrawn
 
     def redraw_highlight(
@@ -1308,6 +1381,7 @@ class RowIndex(tk.Canvas):
                 self.itemconfig(iid, fill=fill, outline=outline)
             else:
                 self.itemconfig(iid, fill=fill, outline=outline, tag=tag, state="normal")
+            self.tag_raise(iid)
         else:
             iid = self.create_rectangle(coords, fill=fill, outline=outline, tag=tag)
         self.disp_high[iid] = True
@@ -1408,14 +1482,14 @@ class RowIndex(tk.Canvas):
             t, sh = self.hidd_tree_arrow.popitem()
             self.coords(t, points)
             if sh:
-                self.itemconfig(t, fill=fill if has_children else self.PAR.ops.index_grid_fg)
+                self.itemconfig(t, fill=fill if has_children else self.ops.index_grid_fg)
             else:
-                self.itemconfig(t, fill=fill if has_children else self.PAR.ops.index_grid_fg, tag=tag, state="normal")
+                self.itemconfig(t, fill=fill if has_children else self.ops.index_grid_fg, tag=tag, state="normal")
             self.lift(t)
         else:
             t = self.create_line(
                 points,
-                fill=fill if has_children else self.PAR.ops.index_grid_fg,
+                fill=fill if has_children else self.ops.index_grid_fg,
                 tag=tag,
                 width=2,
                 capstyle=tk.ROUND,
@@ -1436,8 +1510,8 @@ class RowIndex(tk.Canvas):
         draw_arrow: bool = True,
         open_: bool = False,
     ) -> None:
-        if draw_outline and self.PAR.ops.show_dropdown_borders:
-            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.index_fg, tag=tag)
+        if draw_outline and self.ops.show_dropdown_borders:
+            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.index_fg, tag=tag)
         if draw_arrow:
             mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
             small_mod = int(mod / 5)
@@ -1523,15 +1597,33 @@ class RowIndex(tk.Canvas):
                 t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
             self.disp_checkbox[t] = True
 
-    def configure_scrollregion(self, last_row_line_pos: float) -> None:
-        self.configure(
-            scrollregion=(
-                0,
-                0,
-                self.current_width,
-                last_row_line_pos + self.PAR.ops.empty_vertical + 2,
+    def configure_scrollregion(self, last_row_line_pos: float) -> bool:
+        try:
+            self.configure(
+                scrollregion=(
+                    0,
+                    0,
+                    self.current_width,
+                    last_row_line_pos + self.ops.empty_vertical + 2,
+                )
             )
+            return True
+        except Exception:
+            return False
+
+    def wrap_get_char_w(self, c: str) -> int:
+        self.MT.txt_measure_canvas.itemconfig(
+            self.MT.txt_measure_canvas_text,
+            text=_test_str + c,
+            font=self.index_font,
         )
+        b = self.MT.txt_measure_canvas.bbox(self.MT.txt_measure_canvas_text)
+        if c in self.MT.char_widths[self.index_font]:
+            return self.MT.char_widths[self.index_font][c]
+        else:
+            wd = b[2] - b[0] - self.index_test_str_w
+            self.MT.char_widths[self.index_font][c] = wd
+            return wd
 
     def redraw_grid_and_text(
         self,
@@ -1544,11 +1636,11 @@ class RowIndex(tk.Canvas):
         text_end_row: int,
         scrollpos_bot: int,
         row_pos_exists: bool,
-    ) -> None:
-        try:
-            self.configure_scrollregion(last_row_line_pos=last_row_line_pos)
-        except Exception:
-            return
+        set_scrollregion: bool,
+    ) -> bool:
+        if set_scrollregion:
+            if not self.configure_scrollregion(last_row_line_pos=last_row_line_pos):
+                return False
         self.hidd_text.update(self.disp_text)
         self.disp_text = {}
         self.hidd_high.update(self.disp_high)
@@ -1562,59 +1654,33 @@ class RowIndex(tk.Canvas):
         self.hidd_tree_arrow.update(self.disp_tree_arrow)
         self.disp_tree_arrow = {}
         self.visible_row_dividers = {}
-        xend = self.current_width - 6
         self.row_width_resize_bbox = (
             self.current_width - 2,
             scrollpos_top,
             self.current_width,
             scrollpos_bot,
         )
-        if (self.PAR.ops.show_horizontal_grid or self.height_resizing_enabled) and row_pos_exists:
-            points = [
-                self.current_width - 1,
-                y_stop - 1,
-                self.current_width - 1,
-                scrollpos_top - 1,
-                -1,
-                scrollpos_top - 1,
-            ]
-            for r in range(grid_start_row, grid_end_row):
-                draw_y = self.MT.row_positions[r]
-                if r and self.height_resizing_enabled:
-                    self.visible_row_dividers[r] = (1, draw_y - 2, xend, draw_y + 2)
-                points.extend(
-                    (
-                        -1,
-                        draw_y,
-                        self.current_width,
-                        draw_y,
-                        -1,
-                        draw_y,
-                        -1,
-                        self.MT.row_positions[r + 1] if len(self.MT.row_positions) - 1 > r else draw_y,
-                    )
-                )
-            self.redraw_gridline(points=points, fill=self.PAR.ops.index_grid_fg, width=1, tag="h")
         sel_cells_bg = (
-            self.PAR.ops.index_selected_cells_bg
-            if self.PAR.ops.index_selected_cells_bg.startswith("#")
-            else color_map[self.PAR.ops.index_selected_cells_bg]
+            self.ops.index_selected_cells_bg
+            if self.ops.index_selected_cells_bg.startswith("#")
+            else color_map[self.ops.index_selected_cells_bg]
         )
         sel_rows_bg = (
-            self.PAR.ops.index_selected_rows_bg
-            if self.PAR.ops.index_selected_rows_bg.startswith("#")
-            else color_map[self.PAR.ops.index_selected_rows_bg]
+            self.ops.index_selected_rows_bg
+            if self.ops.index_selected_rows_bg.startswith("#")
+            else color_map[self.ops.index_selected_rows_bg]
         )
-        font = self.PAR.ops.index_font
+        font = self.ops.index_font
         selections = self.get_redraw_selections(text_start_row, grid_end_row)
         dd_coords = self.dropdown.get_coords()
-        treeview = self.PAR.ops.treeview
-
+        treeview = self.ops.treeview
+        wrap = self.ops.index_wrap
         for r in range(text_start_row, text_end_row):
             rtopgridln = self.MT.row_positions[r]
             rbotgridln = self.MT.row_positions[r + 1]
             if rbotgridln - rtopgridln < self.MT.index_txt_height:
                 continue
+            checkbox_kwargs = {}
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
             fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
                 fr=rtopgridln,
@@ -1625,103 +1691,71 @@ class RowIndex(tk.Canvas):
                 selections=selections,
                 datarn=datarn,
             )
-
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
             else:
                 align = self.align
-            dropdown_kwargs = self.get_cell_kwargs(datarn, key="dropdown")
-            if align == "w":
-                draw_x = 3
-                if dropdown_kwargs:
-                    mw = self.current_width - self.MT.index_txt_height - 2
-                    self.redraw_dropdown(
-                        0,
-                        rtopgridln,
-                        self.current_width - 1,
-                        rbotgridln - 1,
-                        fill=fill if dropdown_kwargs["state"] != "disabled" else self.PAR.ops.index_grid_fg,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=not dd_drawn,
-                        draw_arrow=True,
-                        open_=dd_coords == r,
-                    )
-                else:
-                    mw = self.current_width - 2
-
-            elif align == "e":
-                if dropdown_kwargs:
-                    mw = self.current_width - self.MT.index_txt_height - 2
+            if dropdown_kwargs := self.get_cell_kwargs(datarn, key="dropdown"):
+                max_width = self.current_width - self.MT.index_txt_height - 2
+                if align.endswith("w"):
+                    draw_x = 3
+                elif align.endswith("e"):
                     draw_x = self.current_width - 5 - self.MT.index_txt_height
-                    self.redraw_dropdown(
-                        0,
-                        rtopgridln,
-                        self.current_width - 1,
-                        rbotgridln - 1,
-                        fill=fill if dropdown_kwargs["state"] != "disabled" else self.PAR.ops.index_grid_fg,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=not dd_drawn,
-                        draw_arrow=True,
-                        open_=dd_coords == r,
-                    )
-                else:
-                    mw = self.current_width - 2
-                    draw_x = self.current_width - 3
-
-            elif align == "center":
-                if dropdown_kwargs:
-                    mw = self.current_width - self.MT.index_txt_height - 2
+                elif align.endswith("n"):
                     draw_x = ceil((self.current_width - self.MT.index_txt_height) / 2)
-                    self.redraw_dropdown(
-                        0,
-                        rtopgridln,
-                        self.current_width - 1,
-                        rbotgridln - 1,
-                        fill=fill if dropdown_kwargs["state"] != "disabled" else self.PAR.ops.index_grid_fg,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=not dd_drawn,
-                        draw_arrow=True,
-                        open_=dd_coords == r,
-                    )
-                else:
-                    mw = self.current_width - 1
+                self.redraw_dropdown(
+                    0,
+                    rtopgridln,
+                    self.current_width - 1,
+                    rbotgridln - 1,
+                    fill=fill if dropdown_kwargs["state"] != "disabled" else self.ops.index_grid_fg,
+                    outline=fill,
+                    tag="dd",
+                    draw_outline=not dd_drawn,
+                    draw_arrow=True,
+                    open_=dd_coords == r,
+                )
+            else:
+                max_width = self.current_width - 2
+                if align.endswith("w"):
+                    draw_x = 3
+                elif align.endswith("e"):
+                    draw_x = self.current_width - 3
+                elif align.endswith("n"):
                     draw_x = floor(self.current_width / 2)
-            checkbox_kwargs = self.get_cell_kwargs(datarn, key="checkbox")
-            if checkbox_kwargs and not dropdown_kwargs and mw > self.MT.index_txt_height + 1:
-                box_w = self.MT.index_txt_height + 1
-                if align == "w":
-                    draw_x += box_w + 3
-                    mw -= box_w + 3
-                elif align == "center":
-                    draw_x += ceil(box_w / 2) + 1
-                    mw -= box_w + 2
-                else:
-                    mw -= box_w + 1
-                try:
-                    draw_check = (
-                        self.MT._row_index[datarn]
-                        if isinstance(self.MT._row_index, (list, tuple))
-                        else self.MT.data[datarn][self.MT._row_index]
+                if (
+                    (checkbox_kwargs := self.get_cell_kwargs(datarn, key="checkbox"))
+                    and not dropdown_kwargs
+                    and max_width > self.MT.index_txt_height + 1
+                ):
+                    box_w = self.MT.index_txt_height + 1
+                    if align.endswith("w"):
+                        draw_x += box_w + 3
+                    elif align.endswith("n"):
+                        draw_x += ceil(box_w / 2) + 1
+                    max_width -= box_w + 4
+                    try:
+                        draw_check = (
+                            self.MT._row_index[datarn]
+                            if isinstance(self.MT._row_index, (list, tuple))
+                            else self.MT.data[datarn][self.MT._row_index]
+                        )
+                    except Exception:
+                        draw_check = False
+                    self.redraw_checkbox(
+                        2,
+                        rtopgridln + 2,
+                        self.MT.index_txt_height + 3,
+                        rtopgridln + self.MT.index_txt_height + 3,
+                        fill=fill if checkbox_kwargs["state"] == "normal" else self.ops.index_grid_fg,
+                        outline="",
+                        tag="cb",
+                        draw_check=draw_check,
                     )
-                except Exception:
-                    draw_check = False
-                self.redraw_checkbox(
-                    2,
-                    rtopgridln + 2,
-                    self.MT.index_txt_height + 3,
-                    rtopgridln + self.MT.index_txt_height + 3,
-                    fill=fill if checkbox_kwargs["state"] == "normal" else self.PAR.ops.index_grid_fg,
-                    outline="",
-                    tag="cb",
-                    draw_check=draw_check,
-                )
             if treeview and isinstance(self.MT._row_index, list) and len(self.MT._row_index) > datarn:
                 iid = self.MT._row_index[datarn].iid
-                mw -= self.MT.index_txt_height
-                if align == "w":
+                max_width -= self.MT.index_txt_height
+                if align.endswith("w"):
                     draw_x += self.MT.index_txt_height + 3
                 level, indent = self.get_iid_level_indent(iid)
                 draw_x += indent + 5
@@ -1736,84 +1770,118 @@ class RowIndex(tk.Canvas):
                     open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
                     level=level,
                 )
-            lns = self.get_valid_cell_data_as_str(datarn, fix=False)
-            if not lns:
+            if max_width <= 1:
                 continue
-            draw_y = rtopgridln + self.MT.index_first_ln_ins
-            if mw > 5:
-                draw_y = rtopgridln + self.MT.index_first_ln_ins
-                start_ln = int((scrollpos_top - rtopgridln) / self.MT.index_xtra_lines_increment)
-                if start_ln < 0:
-                    start_ln = 0
-                draw_y += start_ln * self.MT.index_xtra_lines_increment
-                lns = lns.split("\n")
-                if draw_y + self.MT.index_half_txt_height - 1 <= rbotgridln and len(lns) > start_ln:
-                    for txt in islice(lns, start_ln, None):
-                        if self.hidd_text:
-                            iid, showing = self.hidd_text.popitem()
-                            self.coords(iid, draw_x, draw_y)
-                            if showing:
-                                self.itemconfig(
-                                    iid,
-                                    text=txt,
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                )
-                            else:
-                                self.itemconfig(
-                                    iid,
-                                    text=txt,
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                    state="normal",
-                                )
-                            self.tag_raise(iid)
+            text = self.get_valid_cell_data_as_str(datarn, fix=False)
+            if not text:
+                continue
+            start_line = max(0, int((scrollpos_top - rtopgridln) / self.MT.index_txt_height))
+            draw_y = rtopgridln + 3 + (start_line * self.MT.index_txt_height)
+            gen_lines = wrap_text(
+                text=text,
+                max_width=max_width,
+                max_lines=int((rbotgridln - rtopgridln - 2) / self.MT.index_txt_height),
+                char_width_fn=self.wrap_get_char_w,
+                widths=self.MT.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
+            else:
+                for text in gen_lines:
+                    if self.hidd_text:
+                        iid, showing = self.hidd_text.popitem()
+                        self.coords(iid, draw_x, draw_y)
+                        if showing:
+                            self.itemconfig(
+                                iid,
+                                text=text,
+                                fill=fill,
+                                font=font,
+                                anchor=align,
+                            )
                         else:
-                            iid = self.create_text(
-                                draw_x,
-                                draw_y,
-                                text=txt,
+                            self.itemconfig(
+                                iid,
+                                text=text,
                                 fill=fill,
                                 font=font,
                                 anchor=align,
-                                tag="t",
+                                state="normal",
                             )
-                        self.disp_text[iid] = True
-                        wd = self.bbox(iid)
-                        wd = wd[2] - wd[0]
-                        if wd > mw:
-                            if align == "w" and dropdown_kwargs:
-                                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" and checkbox_kwargs:
-                                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" and (dropdown_kwargs or checkbox_kwargs):
-                                tmod = ceil((len(txt) - int(len(txt) * (mw / wd))) / 2)
-                                txt = txt[tmod - 1 : -tmod]
-                                self.itemconfig(iid, text=txt)
-                                wd = self.bbox(iid)
-                                self.c_align_cyc = cycle(self.centre_alignment_text_mod_indexes)
-                                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.MT.index_xtra_lines_increment
-                        if draw_y + self.MT.index_half_txt_height - 1 > rbotgridln:
-                            break
+                        self.tag_raise(iid)
+                    else:
+                        iid = self.create_text(
+                            draw_x,
+                            draw_y,
+                            text=text,
+                            fill=fill,
+                            font=font,
+                            anchor=align,
+                            tags="t",
+                        )
+                    self.disp_text[iid] = True
+                    draw_y += self.MT.header_txt_height
+
+        xend = self.current_width - 6
+        if (self.ops.show_horizontal_grid or self.height_resizing_enabled) and row_pos_exists:
+            points = [
+                self.current_width - 1,
+                y_stop - 1,
+                self.current_width - 1,
+                scrollpos_top - 1,
+                -1,
+                scrollpos_top - 1,
+            ]
+            for r in range(grid_start_row, grid_end_row):
+                draw_y = self.MT.row_positions[r]
+                if r and self.height_resizing_enabled:
+                    self.visible_row_dividers[r] = (1, draw_y - 2, xend, draw_y + 2)
+                points.extend(
+                    (
+                        -1,
+                        draw_y,
+                        self.current_width,
+                        draw_y,
+                        -1,
+                        draw_y,
+                        -1,
+                        self.MT.row_positions[r + 1] if len(self.MT.row_positions) - 1 > r else draw_y,
+                    )
+                )
+            self.redraw_gridline(points=points, fill=self.ops.index_grid_fg, width=1, tag="h")
         for dct in (
             self.hidd_text,
             self.hidd_high,
@@ -1826,6 +1894,8 @@ class RowIndex(tk.Canvas):
                 if showing:
                     self.itemconfig(iid, state="hidden")
                     dct[iid] = False
+        if self.disp_resize_lines:
+            self.tag_raise("rh")
         return True
 
     def get_redraw_selections(self, startr: int, endr: int) -> dict[str, set[int]]:
@@ -1904,14 +1974,14 @@ class RowIndex(tk.Canvas):
                 return False
             else:
                 text = text if isinstance(text, str) else f"{text}"
-        if self.PAR.ops.cell_auto_resize_enabled:
+        if self.ops.cell_auto_resize_enabled:
             self.set_row_height_run_binding(r)
         if self.text_editor.open and r == self.text_editor.row:
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
         if not self.MT.see(r=r, c=0, keep_yscroll=True, check_cell_visibility=True):
-            self.MT.refresh()
+            self.MT.main_table_redraw_grid_and_text(True, True)
         x = 0
         y = self.MT.row_positions[r]
         w = self.current_width + 1
@@ -1919,24 +1989,24 @@ class RowIndex(tk.Canvas):
         kwargs = {
             "menu_kwargs": DotDict(
                 {
-                    "font": self.PAR.ops.table_font,
-                    "foreground": self.PAR.ops.popup_menu_fg,
-                    "background": self.PAR.ops.popup_menu_bg,
-                    "activebackground": self.PAR.ops.popup_menu_highlight_bg,
-                    "activeforeground": self.PAR.ops.popup_menu_highlight_fg,
+                    "font": self.ops.index_font,
+                    "foreground": self.ops.popup_menu_fg,
+                    "background": self.ops.popup_menu_bg,
+                    "activebackground": self.ops.popup_menu_highlight_bg,
+                    "activeforeground": self.ops.popup_menu_highlight_fg,
                 }
             ),
-            "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.index_selected_rows_bg,
+            "sheet_ops": self.ops,
+            "border_color": self.ops.index_selected_rows_bg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
             "show_border": True,
-            "bg": self.PAR.ops.index_editor_bg,
-            "fg": self.PAR.ops.index_editor_fg,
-            "select_bg": self.PAR.ops.index_editor_select_bg,
-            "select_fg": self.PAR.ops.index_editor_select_fg,
+            "bg": self.ops.index_editor_bg,
+            "fg": self.ops.index_editor_fg,
+            "select_bg": self.ops.index_editor_select_bg,
+            "select_fg": self.ops.index_editor_select_fg,
             "align": self.get_cell_align(r),
             "r": r,
         }
@@ -1975,13 +2045,13 @@ class RowIndex(tk.Canvas):
             > curr_height
         ):
             r = self.text_editor.row
-            new_height = curr_height + self.MT.index_xtra_lines_increment
+            new_height = curr_height + self.MT.index_txt_height
             space_bot = self.MT.get_space_bot(r)
             if new_height > space_bot:
                 new_height = space_bot
             if new_height != curr_height:
                 self.set_row_height(r, new_height)
-                self.MT.refresh()
+                self.MT.main_table_redraw_grid_and_text(True, True)
                 self.text_editor.window.config(height=new_height)
                 self.coords(self.text_editor.canvas_id, 0, self.MT.row_positions[r] + 1)
                 if self.dropdown.open and self.dropdown.get_coords() == r:
@@ -2006,7 +2076,7 @@ class RowIndex(tk.Canvas):
         if self.text_editor.open:
             r = self.text_editor.row
             self.text_editor.window.config(height=self.MT.row_positions[r + 1] - self.MT.row_positions[r])
-            self.text_editor.tktext.config(font=self.PAR.ops.index_font)
+            self.text_editor.tktext.config(font=self.ops.index_font)
             self.coords(
                 self.text_editor.canvas_id,
                 0,
@@ -2109,15 +2179,12 @@ class RowIndex(tk.Canvas):
         for i, v in enumerate(self.get_cell_kwargs(datarn, 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.MT.index_first_ln_ins + (v_numlines * self.MT.index_xtra_lines_increment) + 5
-                )  # end of cell
+                win_h += self.MT.index_txt_height + (v_numlines * self.MT.index_txt_height) + 5  # end of cell
             else:
                 win_h += self.MT.min_row_height
             if i == 5:
                 break
-        if win_h > 500:
-            win_h = 500
+        win_h = min(win_h, 500)
         space_bot = self.MT.get_space_bot(r, text_editor_h)
         space_top = int(self.MT.row_positions[r])
         anchor = "nw"
@@ -2180,15 +2247,15 @@ class RowIndex(tk.Canvas):
         reset_kwargs = {
             "r": r,
             "c": 0,
-            "bg": self.PAR.ops.index_editor_bg,
-            "fg": self.PAR.ops.index_editor_fg,
-            "select_bg": self.PAR.ops.index_editor_select_bg,
-            "select_fg": self.PAR.ops.index_editor_select_fg,
+            "bg": self.ops.index_editor_bg,
+            "fg": self.ops.index_editor_fg,
+            "select_bg": self.ops.index_editor_select_bg,
+            "select_fg": self.ops.index_editor_select_fg,
             "width": win_w,
             "height": win_h,
-            "font": self.PAR.ops.index_font,
-            "ops": self.PAR.ops,
-            "outline_color": self.PAR.ops.index_selected_rows_bg,
+            "font": self.ops.index_font,
+            "ops": self.ops,
+            "outline_color": self.ops.index_selected_rows_bg,
             "align": self.get_cell_align(r),
             "values": kwargs["values"],
             "search_function": kwargs["search_function"],
@@ -2200,7 +2267,7 @@ class RowIndex(tk.Canvas):
             self.coords(self.dropdown.canvas_id, 0, ypos)
             self.dropdown.window.tkraise()
         else:
-            self.dropdown.window = self.PAR.dropdown_class(
+            self.dropdown.window = self.PAR._dropdown_cls(
                 self.winfo_toplevel(),
                 **reset_kwargs,
                 single_index="r",
@@ -2244,13 +2311,11 @@ class RowIndex(tk.Canvas):
         if r is not None and selection is not None:
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
             kwargs = self.get_cell_kwargs(datarn, key="dropdown")
-            pre_edit_value = self.get_cell_data(datarn)
-            edited = False
             event_data = event_dict(
                 name="end_edit_index",
                 sheet=self.PAR.name,
                 widget=self,
-                cells_header={datarn: pre_edit_value},
+                cells_header={datarn: self.get_cell_data(datarn)},
                 key="??",
                 value=selection,
                 loc=r,
@@ -2258,16 +2323,12 @@ class RowIndex(tk.Canvas):
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )
-            if kwargs["select_function"] is not None:
-                kwargs["select_function"](event_data)
-            if self.MT.edit_validation_func:
-                selection = self.MT.edit_validation_func(event_data)
-                if selection is not None:
-                    edited = self.set_cell_data_undo(r, datarn=datarn, value=selection, redraw=not redraw)
-            else:
+            try_binding(kwargs["select_function"], event_data)
+            selection = selection if not self.MT.edit_validation_func else self.MT.edit_validation_func(event_data)
+            if selection is not None:
                 edited = self.set_cell_data_undo(r, datarn=datarn, value=selection, redraw=not redraw)
-            if edited:
-                try_binding(self.extra_end_edit_cell_func, event_data)
+                if edited:
+                    try_binding(self.extra_end_edit_cell_func, event_data)
             self.MT.recreate_all_selection_boxes()
         self.focus_set()
         self.hide_text_editor_and_dropdown(redraw=redraw)
@@ -2343,7 +2404,7 @@ class RowIndex(tk.Canvas):
                     self.MT.undo_stack.append(stored_event_dict(event_data))
                 self.set_cell_data(datarn=datarn, value=value)
                 edited = True
-        if edited and cell_resize and self.PAR.ops.cell_auto_resize_enabled:
+        if edited and cell_resize and self.ops.cell_auto_resize_enabled:
             self.set_row_height_run_binding(r, only_if_too_small=False)
         if redraw:
             self.MT.refresh()
@@ -2358,7 +2419,7 @@ class RowIndex(tk.Canvas):
             self.fix_index(datarn)
             if self.get_cell_kwargs(datarn, key="checkbox"):
                 self.MT._row_index[datarn] = try_to_bool(value)
-            elif self.PAR.ops.treeview:
+            elif self.ops.treeview:
                 self.MT._row_index[datarn].text = value
             else:
                 self.MT._row_index[datarn] = value
@@ -2400,7 +2461,7 @@ class RowIndex(tk.Canvas):
             or (self.MT._row_index[datarn] is None and none_to_empty_str)
         ):
             return ""
-        if self.PAR.ops.treeview:
+        if self.ops.treeview:
             return self.MT._row_index[datarn].text
         return self.MT._row_index[datarn]
 
@@ -2418,14 +2479,23 @@ class RowIndex(tk.Canvas):
         if fix:
             self.fix_index(datarn)
         try:
-            value = "" if self.MT._row_index[datarn] is None else f"{self.MT._row_index[datarn]}"
+            value = self.MT._row_index[datarn]
+            if value is None:
+                value = ""
+            elif isinstance(value, Node):
+                value = value.text
+            elif not isinstance(value, str):
+                value = f"{value}"
         except Exception:
             value = ""
-        if not value and self.PAR.ops.show_default_index_for_empty:
-            value = get_n2a(datarn, self.PAR.ops.default_row_index)
+        if not value and self.ops.show_default_index_for_empty:
+            value = get_n2a(datarn, self.ops.default_row_index)
         return value
 
     def get_value_for_empty_cell(self, datarn: int, r_ops: bool = True) -> object:
+        if self.ops.treeview:
+            iid = self.new_iid()
+            return Node(text=iid, iid=iid, parent=self.get_row_parent(datarn))
         if self.get_cell_kwargs(datarn, key="checkbox", cell=r_ops):
             return False
         kwargs = self.get_cell_kwargs(datarn, key="dropdown", cell=r_ops)
@@ -2505,63 +2575,378 @@ class RowIndex(tk.Canvas):
 
     # Treeview Mode
 
+    def tree_reset(self) -> None:
+        self.tree: dict[str, Node] = {}
+        self.tree_open_ids = set()
+        self.tree_rns = {}
+        if self.MT:
+            self.MT.displayed_rows = []
+            self.MT._row_index = []
+            self.MT.data = []
+            self.MT.row_positions = [0]
+            self.MT.saved_row_heights = {}
+
+    def new_iid(self) -> str:
+        self.new_iid_ctr += 1
+        while (iid := f"{num2alpha(self.new_iid_ctr)}") in self.tree:
+            self.new_iid_ctr += 1
+        return iid
+
+    def get_row_parent(self, r: int) -> str:
+        if r >= len(self.MT._row_index):
+            return ""
+        else:
+            return self.MT._row_index[r].parent
+
+    def tree_del_rows(self, event_data: EventDataDict) -> EventDataDict:
+        event_data["treeview"]["nodes"] = {}
+        for node in reversed(event_data["deleted"]["index"].values()):
+            iid = node.iid
+            if parent_node := self.parent_node(iid):
+                if parent_node.iid not in event_data["treeview"]["nodes"]:
+                    event_data["treeview"]["nodes"][parent_node.iid] = Node(
+                        text=parent_node.text,
+                        iid=parent_node.iid,
+                        parent=parent_node.parent,
+                        children=parent_node.children.copy(),
+                    )
+                self.remove_iid_from_parents_children(iid)
+        for node in reversed(event_data["deleted"]["index"].values()):
+            iid = node.iid
+            for did in self.get_iid_descendants(iid):
+                self.tree_open_ids.discard(did)
+                del self.tree[did]
+            self.tree_open_ids.discard(iid)
+            del self.tree[iid]
+        return event_data
+
+    def tree_add_rows(self, event_data: EventDataDict) -> EventDataDict:
+        for rn, node in event_data["added"]["rows"]["index"].items():
+            self.tree[node.iid] = node
+            self.tree_rns[node.iid] = rn
+        if event_data["treeview"]["nodes"]:
+            self.restore_nodes(event_data=event_data)
+        else:
+            row, a_node = next(reversed(event_data["added"]["rows"]["index"].items()))
+            if parent := a_node.parent:
+                if self.tree[parent].children:
+                    index = next(
+                        (i for i, cid in enumerate(self.tree[parent].children) if self.tree_rns[cid] >= row),
+                        len(self.tree[parent].children),
+                    )
+                    self.tree[parent].children[index:index] = [
+                        n.iid for n in reversed(event_data["added"]["rows"]["index"].values())
+                    ]
+                else:
+                    self.tree[parent].children.extend(
+                        n.iid for n in reversed(event_data["added"]["rows"]["index"].values())
+                    )
+                if not self.PAR.item_displayed(parent) or parent not in self.tree_open_ids:
+                    self.PAR.hide_rows(event_data["added"]["rows"]["index"], data_indexes=True)
+        return event_data
+
+    def move_rows_mod_nodes(
+        self,
+        data_new_idxs: dict[int, int],
+        data_old_idxs: dict[int, int],
+        disp_new_idxs: dict[int, int],
+        maxidx: int,
+        event_data: EventDataDict,
+        undo_modification: EventDataDict | None = None,
+        node_change: tuple[str, str, int] | None = None,
+    ) -> Generator[tuple[dict[int, int], dict[int, int], dict[str, int], EventDataDict]] | None:
+        # data_new_idxs is {old: new, old: new}
+        # data_old_idxs is {new: old, new: old}
+        if not event_data["treeview"]["nodes"]:
+            if undo_modification:
+                """
+                Used by undo/redo
+                """
+                event_data = self.copy_nodes(undo_modification["treeview"]["nodes"], event_data)
+                self.restore_nodes(undo_modification)
+
+            elif event_data["moved"]["rows"]:
+                if node_change:
+                    item = node_change[0]
+                    moved_rows = [self.tree_rns[item]]
+                    new_parent = node_change[1]
+                    move_to_index = node_change[2]
+                    if new_parent:
+                        move_to_index = (
+                            move_to_index if isinstance(move_to_index, int) else len(self.tree[new_parent].children)
+                        )
+                        move_to_row = self.tree_rns[new_parent] + max(
+                            0, min(move_to_index, len(self.tree[new_parent].children))
+                        )
+                    else:
+                        num_top_nodes = sum(1 for _ in self.gen_top_nodes())
+                        if move_to_index is None:
+                            move_to_row = self.PAR.top_index_row(num_top_nodes - 1)
+                            move_to_index = num_top_nodes
+                        else:
+                            move_to_row = self.PAR.top_index_row(move_to_index)
+                            if move_to_row is None:
+                                move_to_row = self.PAR.top_index_row(num_top_nodes - 1)
+                                move_to_index = num_top_nodes
+
+                    move_to_iid = self.MT._row_index[move_to_row].iid
+                    insert_row = move_to_row + 1
+                    disp_insert_row = None
+
+                else:
+                    iids = set(self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"])
+                    iids_descendants = {iid: set(self.get_iid_descendants(iid)) for iid in iids}
+
+                    # remove descendants in iids to move
+                    iids -= set.union(*iids_descendants.values()) & iids
+                    moved_rows = sorted(map(self.tree_rns.__getitem__, iids))
+                    item = self.MT._row_index[moved_rows[0]].iid
+
+                    if isinstance(event_data.value, int):
+                        disp_insert_row = event_data.value
+                        if disp_insert_row >= len(self.MT.displayed_rows):
+                            insert_row = len(self.MT._row_index)
+                        else:
+                            insert_row = self.MT.datarn(disp_insert_row)
+                        move_to_iid = self.MT._row_index[min(insert_row, len(self.MT._row_index) - 1)].iid
+
+                    else:
+                        disp_insert_row = None
+                        min_from = min(event_data["moved"]["rows"]["data"])
+                        # max_from = max(event_data.moved.rows)
+                        min_to = min(event_data["moved"]["rows"]["data"].values())
+                        max_to = max(event_data["moved"]["rows"]["data"].values())
+                        if min_from <= min_to:
+                            insert_row = max_to
+                        else:
+                            insert_row = min_to
+                        move_to_iid = self.MT._row_index[insert_row].iid
+
+                    move_to_index = self.PAR.index(move_to_iid)
+                    new_parent = self.items_parent(move_to_iid)
+
+                event_data["moved"]["rows"]["data"] = {moved_rows[0]: insert_row}
+
+                new_loc_is_displayed = not new_parent or (
+                    new_parent and new_parent in self.tree_open_ids and self.PAR.item_displayed(new_parent)
+                )
+                # deal with displayed mapping
+                event_data["moved"]["rows"]["displayed"] = {}
+                if new_loc_is_displayed:
+                    if disp_insert_row is None:
+                        if new_parent == self.tree[item].parent:
+                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid]) + 1
+                        else:
+                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid]) + 1
+                    if (disp_from_row := self.MT.try_disprn(self.tree_rns[item])) is not None:
+                        event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
+                    else:
+                        event_data["moved"]["rows"]["displayed"] = {tuple(): disp_insert_row}
+
+                if any(self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows):
+                    event_data["moved"]["rows"] = {}
+                    data_new_idxs, data_old_idxs, disp_new_idxs = {}, {}, {}
+
+                else:
+                    for r in moved_rows:
+                        iid = self.MT._row_index[r].iid
+                        event_data = self.move_node(
+                            event_data=event_data,
+                            item=iid,
+                            parent=new_parent,
+                            index=move_to_index,
+                        )
+                        move_to_index += 1
+
+                    event_data["moved"]["rows"]["data"] = get_new_indexes(
+                        insert_row,
+                        event_data["moved"]["rows"]["data"],
+                    )
+                    data_new_idxs = event_data["moved"]["rows"]["data"]
+                    data_old_idxs = dict(zip(data_new_idxs.values(), data_new_idxs))
+
+                    if tuple() in event_data["moved"]["rows"]["displayed"]:
+                        del event_data["moved"]["rows"]["displayed"][tuple()]
+
+                    if event_data["moved"]["rows"]["displayed"]:
+                        event_data["moved"]["rows"]["displayed"] = get_new_indexes(
+                            disp_insert_row,
+                            event_data["moved"]["rows"]["displayed"],
+                        )
+                    disp_new_idxs = event_data["moved"]["rows"]["displayed"]
+
+        if data_new_idxs:
+            self.MT.move_rows_data(data_new_idxs, data_old_idxs, maxidx)
+
+        yield data_new_idxs, data_old_idxs, disp_new_idxs, event_data
+
+        if not undo_modification and data_new_idxs:
+            if new_parent and (not self.PAR.item_displayed(new_parent) or new_parent not in self.tree_open_ids):
+                self.PAR.hide_rows(set(data_new_idxs.values()), data_indexes=True)
+
+            if new_loc_is_displayed:
+                self.PAR.show_rows(
+                    (r for r in data_new_idxs.values() if self.ancestors_all_open(self.MT._row_index[r].iid))
+                )
+
+        yield None
+
+    def move_node(
+        self,
+        event_data: EventDataDict,
+        item: str,
+        parent: str | None = None,
+        index: int = 0,
+    ) -> EventDataDict:
+        # also backs up nodes
+        if parent is None:
+            parent = self.items_parent(item)
+
+        item_node = self.tree[item]
+
+        # new parent is an item
+        if parent:
+            parent_node = self.tree[parent]
+            # its the same parent, we're just moving index
+            if parent == item_node.parent:
+                event_data = self.copy_nodes((item, parent), event_data)
+                pop_index = parent_node.children.index(item)
+                parent_node.children.insert(index, parent_node.children.pop(pop_index))
+
+            else:
+                if item_node.parent:
+                    event_data = self.copy_nodes((item, item_node.parent, parent), event_data)
+                else:
+                    event_data = self.copy_nodes((item, parent), event_data)
+                self.remove_iid_from_parents_children(item)
+                item_node.parent = parent_node.iid
+                parent_node.children.insert(index, item)
+
+        # no new parent
+        else:
+            if item_node.parent:
+                event_data = self.copy_nodes((item, item_node.parent), event_data)
+            else:
+                event_data = self.copy_nodes((item,), event_data)
+            self.remove_iid_from_parents_children(item)
+            self.tree[item].parent = ""
+
+        # last row in mapping is where to start from +1
+        mapping = event_data["moved"]["rows"]["data"]
+        row_ctr = next(reversed(mapping.values())) + 1
+
+        if disp_mapping := event_data["moved"]["rows"]["displayed"]:
+            if tuple() in disp_mapping:
+                disp_row_ctr = next(reversed(disp_mapping.values()))
+            else:
+                disp_row_ctr = next(reversed(disp_mapping.values())) + 1
+
+        rn = self.tree_rns[item]
+        if rn not in mapping:
+            mapping[rn] = row_ctr
+            row_ctr += 1
+            if disp_mapping and (disp_from := self.MT.try_disprn(rn)) is not None:
+                disp_mapping = del_placeholder_dict_key(disp_mapping, disp_from, disp_row_ctr)
+                disp_row_ctr += 1
+
+        for did in self.get_iid_descendants(item):
+            mapping[self.tree_rns[did]] = row_ctr
+            row_ctr += 1
+            if disp_mapping and (disp_from := self.MT.try_disprn(self.tree_rns[did])) is not None:
+                disp_mapping = del_placeholder_dict_key(disp_mapping, disp_from, disp_row_ctr)
+                disp_row_ctr += 1
+
+        event_data["moved"]["rows"]["data"] = mapping
+        event_data["moved"]["rows"]["displayed"] = disp_mapping
+
+        return event_data
+
+    def restore_nodes(self, event_data: EventDataDict) -> None:
+        for iid, node in event_data["treeview"]["nodes"].items():
+            self.MT._row_index[self.tree_rns[iid]] = node
+            self.tree[iid] = node
+
+    def copy_node(self, item: str) -> Node:
+        n = self.tree[item]
+        return Node(
+            text=n.text,
+            iid=n.iid,
+            parent=n.parent,
+            children=n.children.copy(),
+        )
+
+    def copy_nodes(self, items: AnyIter[str], event_data: EventDataDict) -> EventDataDict:
+        nodes = event_data["treeview"]["nodes"]
+        for iid in items:
+            if iid not in nodes:
+                n = self.tree[iid]
+                nodes[iid] = Node(
+                    text=n.text,
+                    iid=n.iid,
+                    parent=n.parent,
+                    children=n.children.copy(),
+                )
+        return event_data
+
     def get_node_level(self, node: Node, level: int = 0) -> Generator[int]:
         yield level
         if node.parent:
-            yield from self.get_node_level(node.parent, level + 1)
+            yield from self.get_node_level(self.tree[node.parent], level + 1)
 
-    def ancestors_all_open(self, iid: str, stop_at: str | Node = "") -> bool:
+    def ancestors_all_open(self, iid: str, stop_at: str = "") -> bool:
         if stop_at:
-            stop_at = stop_at.iid
             for iid in self.get_iid_ancestors(iid):
                 if iid == stop_at:
                     return True
-                if iid not in self.tree_open_ids:
+                elif iid not in self.tree_open_ids:
                     return False
             return True
         return all(map(self.tree_open_ids.__contains__, self.get_iid_ancestors(iid)))
 
     def get_iid_ancestors(self, iid: str) -> Generator[str]:
         if self.tree[iid].parent:
-            yield self.tree[iid].parent.iid
-            yield from self.get_iid_ancestors(self.tree[iid].parent.iid)
+            yield self.tree[iid].parent
+            yield from self.get_iid_ancestors(self.tree[iid].parent)
 
     def get_iid_descendants(self, iid: str, check_open: bool = False) -> Generator[str]:
-        for cnode in self.tree[iid].children:
-            yield cnode.iid
-            if (check_open and cnode.children and cnode.iid in self.tree_open_ids) or (
-                not check_open and cnode.children
-            ):
-                yield from self.get_iid_descendants(cnode.iid, check_open)
+        for ciid in self.tree[iid].children:
+            yield ciid
+            if self.tree[ciid].children and (not check_open or ciid in self.tree_open_ids):
+                yield from self.get_iid_descendants(ciid, check_open)
 
     def items_parent(self, iid: str) -> str:
         if self.tree[iid].parent:
-            return self.tree[iid].parent.iid
+            return self.tree[iid].parent
+        return ""
+
+    def parent_node(self, iid: str) -> Node:
+        if self.tree[iid].parent:
+            return self.tree[self.tree[iid].parent]
         return ""
 
     def gen_top_nodes(self) -> Generator[Node]:
         yield from (node for node in self.MT._row_index if node.parent == "")
 
     def get_iid_indent(self, iid: str) -> int:
-        if isinstance(self.PAR.ops.treeview_indent, str):
-            indent = self.MT.index_txt_width * int(self.PAR.ops.treeview_indent)
+        if isinstance(self.ops.treeview_indent, str):
+            indent = self.MT.index_txt_width * int(self.ops.treeview_indent)
         else:
-            indent = self.PAR.ops.treeview_indent
+            indent = self.ops.treeview_indent
         return indent * max(self.get_node_level(self.tree[iid]))
 
     def get_iid_level_indent(self, iid: str) -> tuple[int, int]:
-        if isinstance(self.PAR.ops.treeview_indent, str):
-            indent = self.MT.index_txt_width * int(self.PAR.ops.treeview_indent)
+        if isinstance(self.ops.treeview_indent, str):
+            indent = self.MT.index_txt_width * int(self.ops.treeview_indent)
         else:
-            indent = self.PAR.ops.treeview_indent
+            indent = self.ops.treeview_indent
         level = max(self.get_node_level(self.tree[iid]))
         return level, indent * level
 
-    def remove_node_from_parents_children(self, node: Node) -> None:
-        if node.parent:
-            node.parent.children.remove(node)
-            if not node.parent.children:
-                self.tree_open_ids.discard(node.parent)
+    def remove_iid_from_parents_children(self, iid: str) -> None:
+        if parent_node := self.parent_node(iid):
+            parent_node.children.remove(iid)
+            if not parent_node.children:
+                self.tree_open_ids.discard(parent_node.iid)
 
     def build_pid_causes_recursive_loop(self, iid: str, pid: str) -> bool:
         return any(
@@ -2575,4 +2960,121 @@ class RowIndex(tk.Canvas):
     def move_pid_causes_recursive_loop(self, to_move_iid: str, move_to_parent: str) -> bool:
         # if the parent the item is being moved under is one of the item's descendants
         # then it is a recursive loop
-        return any(move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid))
+        return to_move_iid == move_to_parent or any(
+            move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid)
+        )
+
+    def tree_build(
+        self,
+        data: list[list[object]],
+        iid_column: int,
+        parent_column: int,
+        text_column: None | int | list[str] = None,
+        push_ops: bool = False,
+        row_heights: Sequence[int] | None | False = None,
+        open_ids: AnyIter[str] | None = None,
+        safety: bool = True,
+        ncols: int | None = None,
+        lower: bool = False,
+        include_iid_column: bool = True,
+        include_parent_column: bool = True,
+        include_text_column: bool = True,
+    ) -> None:
+        self.PAR.reset(cell_options=False, column_widths=False, header=False, redraw=False)
+        if text_column is None:
+            text_column = iid_column
+        tally_of_ids = defaultdict(lambda: -1)
+        if not isinstance(ncols, int):
+            ncols = max(map(len, data), default=0)
+        for rn, row in enumerate(data):
+            if safety and ncols > (lnr := len(row)):
+                row += self.MT.get_empty_row_seq(rn, end=ncols, start=lnr)
+            if lower:
+                iid = row[iid_column].lower()
+                pid = row[parent_column].lower()
+            else:
+                iid = row[iid_column]
+                pid = row[parent_column]
+            if safety:
+                if not iid:
+                    continue
+                tally_of_ids[iid] += 1
+                if tally_of_ids[iid]:
+                    x = 1
+                    while iid in tally_of_ids:
+                        new = f"{row[iid_column]}_DUPLICATED_{x}"
+                        iid = new.lower() if lower else new
+                        x += 1
+                    tally_of_ids[iid] += 1
+                    row[iid_column] = new
+            if iid in self.tree:
+                self.tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            else:
+                self.tree[iid] = Node(row[text_column] if isinstance(text_column, int) else text_column[rn], iid, "")
+            if safety and (iid == pid or self.build_pid_causes_recursive_loop(iid, pid)):
+                row[parent_column] = ""
+                pid = ""
+            if pid:
+                if pid in self.tree:
+                    self.tree[pid].children.append(iid)
+                else:
+                    self.tree[pid] = Node(
+                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                        iid=pid,
+                        children=[iid],
+                    )
+                self.tree[iid].parent = pid
+            else:
+                self.tree[iid].parent = ""
+            self.tree_rns[iid] = rn
+        if safety:
+            for n in self.tree.values():
+                if n.parent is None:
+                    n.parent = ""
+                    newrow = self.MT.get_empty_row_seq(len(data), ncols)
+                    newrow[iid_column] = n.iid
+                    self.tree_rns[n.iid] = len(data)
+                    data.append(newrow)
+        insert_rows = partial(
+            self.PAR.insert_rows,
+            idx=0,
+            heights={} if row_heights is False else row_heights,
+            row_index=True,
+            create_selections=False,
+            fill=False,
+            undo=False,
+            push_ops=push_ops,
+            redraw=False,
+        )
+        exclude = set()
+        if not include_iid_column:
+            exclude.add(iid_column)
+        if not include_parent_column:
+            exclude.add(parent_column)
+        if isinstance(text_column, int) and not include_text_column:
+            exclude.add(text_column)
+        if exclude:
+            insert_rows(
+                rows=[
+                    [self.tree[iid]] + [e for i, e in enumerate(data[self.tree_rns[iid]]) if i not in exclude]
+                    for iid in self.PAR.get_iids()
+                ],
+                tree=False,
+            )
+        else:
+            insert_rows(
+                rows=[[self.tree[iid]] + data[self.tree_rns[iid]] for iid in self.PAR.get_iids()],
+                tree=False,
+            )
+        self.MT.all_rows_displayed = False
+        self.MT.displayed_rows = list(range(len(self.MT._row_index)))
+        self.tree_rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
+        if open_ids:
+            self.PAR.tree_set_open(open_ids=open_ids)
+        else:
+            self.PAR.hide_rows(
+                {self.tree_rns[iid] for iid in self.PAR.get_children() if self.tree[iid].parent},
+                deselect_all=False,
+                data_indexes=True,
+                row_heights=False if row_heights is False else True,
+            )