tksheet 7.4.12__py3-none-any.whl → 7.4.14__py3-none-any.whl

tksheet/row_index.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import tkinter as tk
 from collections import defaultdict
 from collections.abc import Callable, Generator, Hashable, Iterator, Sequence
+from contextlib import suppress
 from functools import partial
-from itertools import chain, cycle, islice, repeat
-from math import ceil, floor
-from operator import itemgetter
+from itertools import cycle, islice, repeat
+from math import ceil
+from re import findall
 from typing import Any, Literal
 
 from .colors import color_map
@@ -758,7 +759,7 @@ class RowIndex(tk.Canvas):
         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.ops.max_row_height:
-            new_row_pos = floor(self.MT.row_positions[self.rsz_h - 1] + self.ops.max_row_height)
+            new_row_pos = int(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)
@@ -1057,25 +1058,48 @@ class RowIndex(tk.Canvas):
     def get_cell_dimensions(self, datarn: int) -> tuple[int, int]:
         txt = self.cell_str(datarn, fix=False)
         if txt:
-            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
+            lines = findall(r"[^\n]+", txt)
+            h = self.MT.index_txt_height * len(lines) + 5
+            w = max(sum(self.wrap_get_char_w(c) for c in line) for line in lines) + 8
         else:
             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"):
+        # self.get_cell_kwargs not used here to boost performance
+        if (datarn in self.cell_options and "dropdown" in self.cell_options[datarn]) or (
+            datarn in self.cell_options and "checkbox" in self.cell_options[datarn]
+        ):
             w += self.MT.index_txt_height + 2
         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.endswith("w"):
+            if align[-1] == "w":
                 w += self.MT.index_txt_height
             w += self.get_iid_indent(self.MT._row_index[datarn].iid) + 10
         return w, h
 
+    def get_cell_width(self, datarn: int) -> int:
+        txt = self.cell_str(datarn, fix=False)
+        if txt:
+            w = max(sum(self.wrap_get_char_w(c) for c in line) for line in findall(r"[^\n]+", txt)) + 8
+        else:
+            w = self.ops.default_row_index_width
+        # self.get_cell_kwargs not used here to boost performance
+        if (datarn in self.cell_options and "dropdown" in self.cell_options[datarn]) or (
+            datarn in self.cell_options and "checkbox" in self.cell_options[datarn]
+        ):
+            w += self.MT.index_txt_height + 2
+        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[-1] == "w":
+                w += self.MT.index_txt_height
+            w += self.get_iid_indent(self.MT._row_index[datarn].iid) + 10
+        return w
+
     def get_wrapped_cell_height(self, datarn: int) -> int:
         n_lines = max(
             1,
@@ -1160,10 +1184,7 @@ class RowIndex(tk.Canvas):
             self.MT.recreate_all_selection_boxes()
         return height
 
-    def get_index_text_width(
-        self,
-        only_rows: Iterator[int] | None = None,
-    ) -> int:
+    def get_index_text_width(self, only_rows: Iterator[int] | None = None) -> int:
         self.fix_index()
         w = self.ops.default_row_index_width
         if (not self.MT._row_index and isinstance(self.MT._row_index, list)) or (
@@ -1179,7 +1200,7 @@ class RowIndex(tk.Canvas):
                 iterable = range(len(self.MT.data))
         else:
             iterable = self.MT.displayed_rows
-        if (new_w := max(map(itemgetter(0), map(self.get_cell_dimensions, iterable)), default=w)) > w:
+        if (new_w := max(map(self.get_cell_width, iterable), default=w)) > w:
             w = new_w
         if w > self.ops.max_index_width:
             w = int(self.ops.max_index_width)
@@ -1234,18 +1255,18 @@ 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.ops.default_row_index == "letters":
-                new_w = self.MT.get_txt_w(f"{num2alpha(end_row)}", self.index_font) + 20
+                new_w = sum(self.wrap_get_char_w(c) for c in num2alpha(end_row)) + 20
             elif self.ops.default_row_index == "numbers":
-                new_w = self.MT.get_txt_w(f"{end_row}", self.index_font) + 20
+                new_w = sum(self.wrap_get_char_w(c) for c in str(end_row)) + 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
+                new_w = sum(self.wrap_get_char_w(c) for c in f"{end_row + 1} {num2alpha(end_row)}") + 20
             elif self.ops.default_row_index is None:
                 new_w = 20
         elif self.ops.auto_resize_row_index is True:
             new_w = self.get_index_text_width(only_rows=only_rows)
         else:
             new_w = None
-        if new_w is not None and (sheet_w_x := floor(self.PAR.winfo_width() * 0.7)) < new_w:
+        if new_w is not None and (sheet_w_x := int(self.PAR.winfo_width() * 0.7)) < new_w:
             new_w = sheet_w_x
         if new_w and (self.current_width - new_w > 20 or new_w - self.current_width > 3):
             if self.MT.find_window.open:
@@ -1305,7 +1326,6 @@ class RowIndex(tk.Canvas):
                     sr,
                     fill=fill,
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
-                    tag="s",
                 )
             tree_arrow_fg = txtfg
         elif not kwargs:
@@ -1319,7 +1339,6 @@ class RowIndex(tk.Canvas):
                     sr,
                     fill=self.ops.index_selected_rows_bg,
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
-                    tag="s",
                 )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = self.ops.index_selected_cells_fg
@@ -1331,7 +1350,6 @@ class RowIndex(tk.Canvas):
                     sr,
                     fill=self.ops.index_selected_cells_bg,
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
-                    tag="s",
                 )
             else:
                 txtfg = self.ops.index_fg
@@ -1346,7 +1364,6 @@ class RowIndex(tk.Canvas):
         y2: float,
         fill: str,
         outline: str,
-        tag: str | tuple[str],
     ) -> bool:
         coords = (x1, y1, x2, y2)
         if self.hidd_high:
@@ -1355,10 +1372,9 @@ class RowIndex(tk.Canvas):
             if showing:
                 self.itemconfig(iid, fill=fill, outline=outline)
             else:
-                self.itemconfig(iid, fill=fill, outline=outline, tag=tag, state="normal")
-            self.tag_raise(iid)
+                self.itemconfig(iid, fill=fill, outline=outline, state="normal")
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline, tag=tag)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline)
         self.disp_high[iid] = True
         return True
 
@@ -1367,18 +1383,17 @@ class RowIndex(tk.Canvas):
         points: tuple[float],
         fill: str,
         width: int,
-        tag: str | tuple[str],
     ) -> None:
         if self.hidd_grid:
             t, sh = self.hidd_grid.popitem()
             self.coords(t, points)
             if sh:
-                self.itemconfig(t, fill=fill, width=width, tag=tag)
+                self.itemconfig(t, fill=fill, width=width)
             else:
-                self.itemconfig(t, fill=fill, width=width, tag=tag, state="normal")
+                self.itemconfig(t, fill=fill, width=width, state="normal")
             self.disp_grid[t] = True
         else:
-            self.disp_grid[self.create_line(points, fill=fill, width=width, tag=tag)] = True
+            self.disp_grid[self.create_line(points, fill=fill, width=width)] = True
 
     def redraw_tree_arrow(
         self,
@@ -1386,7 +1401,6 @@ class RowIndex(tk.Canvas):
         y1: float,
         y2: float,
         fill: str,
-        tag: str | tuple[str],
         indent: float,
         has_children: bool = False,
         open_: bool = False,
@@ -1394,7 +1408,7 @@ class RowIndex(tk.Canvas):
     ) -> None:
         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)
-        mid_y = floor(self.MT.min_row_height / 2)
+        mid_y = int(self.MT.min_row_height / 2)
         if has_children:
             # up arrow
             if open_:
@@ -1459,16 +1473,15 @@ class RowIndex(tk.Canvas):
             if sh:
                 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.ops.index_grid_fg, tag=tag, state="normal")
-            self.lift(t)
+                self.itemconfig(t, fill=fill if has_children else self.ops.index_grid_fg, state="normal")
         else:
             t = self.create_line(
                 points,
                 fill=fill if has_children else self.ops.index_grid_fg,
-                tag=tag,
                 width=2,
                 capstyle=tk.ROUND,
                 joinstyle=tk.BEVEL,
+                tag="lift",
             )
         self.disp_tree_arrow[t] = True
 
@@ -1480,17 +1493,16 @@ class RowIndex(tk.Canvas):
         y2: float,
         fill: str,
         outline: str,
-        tag: str | tuple[str],
         draw_outline: bool = True,
         draw_arrow: bool = True,
         open_: bool = False,
     ) -> None:
         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)
+            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.index_fg)
         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)
-            mid_y = floor(self.MT.min_row_height / 2)
+            mid_y = int(self.MT.min_row_height / 2)
             if open_:
                 # up arrow
                 points = (
@@ -1517,16 +1529,15 @@ class RowIndex(tk.Canvas):
                 if sh:
                     self.itemconfig(t, fill=fill)
                 else:
-                    self.itemconfig(t, fill=fill, tag=tag, state="normal")
-                self.lift(t)
+                    self.itemconfig(t, fill=fill, state="normal")
             else:
                 t = self.create_line(
                     points,
                     fill=fill,
-                    tag=tag,
                     width=2,
                     capstyle=tk.ROUND,
                     joinstyle=tk.BEVEL,
+                    tag="lift",
                 )
             self.disp_dropdown[t] = True
 
@@ -1538,7 +1549,6 @@ class RowIndex(tk.Canvas):
         y2: float,
         fill: str,
         outline: str,
-        tag: str | tuple[str],
         draw_check: bool = False,
     ) -> None:
         points = rounded_box_coords(x1, y1, x2, y2)
@@ -1548,10 +1558,9 @@ class RowIndex(tk.Canvas):
             if sh:
                 self.itemconfig(t, fill=outline, outline=fill)
             else:
-                self.itemconfig(t, fill=outline, outline=fill, tag=tag, state="normal")
-            self.lift(t)
+                self.itemconfig(t, fill=outline, outline=fill, state="normal")
         else:
-            t = self.create_polygon(points, fill=outline, outline=fill, tag=tag, smooth=True)
+            t = self.create_polygon(points, fill=outline, outline=fill, smooth=True, tag="lift")
         self.disp_checkbox[t] = True
         if draw_check:
             # draw filled box
@@ -1566,10 +1575,9 @@ class RowIndex(tk.Canvas):
                 if sh:
                     self.itemconfig(t, fill=fill, outline=outline)
                 else:
-                    self.itemconfig(t, fill=fill, outline=outline, tag=tag, state="normal")
-                self.lift(t)
+                    self.itemconfig(t, fill=fill, outline=outline, state="normal")
             else:
-                t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
+                t = self.create_polygon(points, fill=fill, outline=outline, smooth=True, tag="lift")
             self.disp_checkbox[t] = True
 
     def configure_scrollregion(self, last_row_line_pos: float) -> bool:
@@ -1587,15 +1595,15 @@ class RowIndex(tk.Canvas):
             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:
+            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)
             wd = b[2] - b[0] - self.index_test_str_w
             self.MT.char_widths[self.index_font][c] = wd
             return wd
@@ -1634,6 +1642,35 @@ class RowIndex(tk.Canvas):
             self.current_width,
             scrollpos_bot,
         )
+
+        if (self.ops.show_horizontal_grid or self.height_resizing_enabled) and row_pos_exists:
+            xend = self.current_width - 6
+            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)
+
         sel_cells_bg = (
             self.ops.index_selected_cells_bg
             if self.ops.index_selected_cells_bg.startswith("#")
@@ -1673,13 +1710,13 @@ class RowIndex(tk.Canvas):
             else:
                 align = self.align
             if dropdown_kwargs:
-                max_width = self.current_width - self.MT.index_txt_height - 2
-                if align.endswith("w"):
+                max_width = self.current_width - self.MT.index_txt_height - 5
+                if align[-1] == "w":
                     draw_x = 3
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = self.current_width - 5 - self.MT.index_txt_height
-                elif align.endswith("n"):
-                    draw_x = ceil((self.current_width - self.MT.index_txt_height) / 2)
+                elif align[-1] == "n":
+                    draw_x = (self.current_width - self.MT.index_txt_height) / 2
                 self.redraw_dropdown(
                     0,
                     rtopgridln,
@@ -1687,29 +1724,28 @@ class RowIndex(tk.Canvas):
                     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"):
+                if align[-1] == "w":
                     draw_x = 3
-                elif align.endswith("e"):
+                elif align[-1] == "e":
                     draw_x = self.current_width - 3
-                elif align.endswith("n"):
-                    draw_x = floor(self.current_width / 2)
+                elif align[-1] == "n":
+                    draw_x = self.current_width / 2
                 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"):
+                    if align[-1] == "w":
                         draw_x += box_w + 3
-                    elif align.endswith("n"):
-                        draw_x += ceil(box_w / 2) + 1
+                    elif align[-1] == "n":
+                        draw_x += box_w / 2 + 1
                     max_width -= box_w + 4
                     try:
                         draw_check = (
@@ -1726,13 +1762,12 @@ class RowIndex(tk.Canvas):
                         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,
                     )
             if treeview and isinstance(self.MT._row_index, list) and len(self.MT._row_index) > datarn:
                 iid = self.MT._row_index[datarn].iid
                 max_width -= self.MT.index_txt_height
-                if align.endswith("w"):
+                if align[-1] == "w":
                     draw_x += self.MT.index_txt_height + 3
                 level, indent = self.get_iid_level_indent(iid)
                 draw_x += indent + 5
@@ -1741,7 +1776,6 @@ class RowIndex(tk.Canvas):
                     rtopgridln,
                     rbotgridln - 1,
                     fill=tree_arrow_fg,
-                    tag="ta",
                     indent=indent,
                     has_children=bool(self.MT._row_index[datarn].children),
                     open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
@@ -1763,7 +1797,7 @@ class RowIndex(tk.Canvas):
                 wrap=wrap,
                 start_line=start_line,
             )
-            if align.endswith(("w", "e")):
+            if align[-1] == "w" or align[-1] == "e":
                 if self.hidd_text:
                     iid, showing = self.hidd_text.popitem()
                     self.coords(iid, draw_x, draw_y)
@@ -1792,18 +1826,18 @@ class RowIndex(tk.Canvas):
                         fill=fill,
                         font=font,
                         anchor=align,
-                        tags="t",
+                        tag="lift",
                     )
                 self.disp_text[iid] = True
             else:
-                for text in gen_lines:
+                for line 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,
+                                text=line,
                                 fill=fill,
                                 font=font,
                                 anchor=align,
@@ -1811,7 +1845,7 @@ class RowIndex(tk.Canvas):
                         else:
                             self.itemconfig(
                                 iid,
-                                text=text,
+                                text=line,
                                 fill=fill,
                                 font=font,
                                 anchor=align,
@@ -1821,42 +1855,15 @@ class RowIndex(tk.Canvas):
                         iid = self.create_text(
                             draw_x,
                             draw_y,
-                            text=text,
+                            text=line,
                             fill=fill,
                             font=font,
                             anchor=align,
-                            tags="t",
+                            tag="lift",
                         )
                     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,
@@ -1869,7 +1876,7 @@ class RowIndex(tk.Canvas):
                 if showing:
                     self.itemconfig(iid, state="hidden")
                     dct[iid] = False
-        self.tag_raise("t")
+        self.tag_raise("lift")
         if self.disp_resize_lines:
             self.tag_raise("rh")
         return True
@@ -2729,16 +2736,17 @@ class RowIndex(tk.Canvas):
                 )
                 # deal with displayed mapping
                 event_data["moved"]["rows"]["displayed"] = {}
-                if new_loc_is_displayed:
-                    if disp_insert_row is None:
-                        if new_parent or insert_row > move_to_row:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1  # TODO: maybe issues here
+                with suppress(Exception):
+                    if new_loc_is_displayed:
+                        if disp_insert_row is None:
+                            if new_parent or insert_row > move_to_row:
+                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1
+                            else:
+                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
+                        if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
+                            event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
                         else:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
-                    if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
-                        event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
-                    else:
-                        event_data["moved"]["rows"]["displayed"] = {(): disp_insert_row}
+                            event_data["moved"]["rows"]["displayed"] = {(): 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"] = {}
@@ -2759,7 +2767,7 @@ class RowIndex(tk.Canvas):
                         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))
+                    data_old_idxs = {v: k for k, v in data_new_idxs.items()}
 
                     if () in event_data["moved"]["rows"]["displayed"]:
                         del event_data["moved"]["rows"]["displayed"][()]
@@ -2988,15 +2996,6 @@ class RowIndex(tk.Canvas):
             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(
-            i == pid
-            for i in chain(
-                self.get_iid_descendants(iid),
-                islice(self.get_iid_ancestors(iid), 1, None),
-            )
-        )
-
     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
@@ -3017,8 +3016,8 @@ class RowIndex(tk.Canvas):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> None:
-        index = self.MT._row_index
         data_rns = {}
+        tree = {}
         if text_column is None:
             text_column = iid_column
         if not isinstance(ncols, int):
@@ -3030,33 +3029,27 @@ class RowIndex(tk.Canvas):
             else:
                 iid = row[iid_column]
                 pid = row[parent_column]
-            if iid in self.rns:
-                index[self.rns[iid]].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            if iid in tree:
+                tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
             else:
-                index.append(
-                    Node(
-                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
-                        iid=iid,
-                        parent="",
-                    )
+                tree[iid] = Node(
+                    text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                    iid=iid,
+                    parent="",
                 )
-                self.rns[iid] = len(index) - 1
             data_rns[iid] = rn
             if pid:
-                if pid in self.rns:
-                    index[self.rns[pid]].children.append(iid)
+                if pid in tree:
+                    tree[pid].children.append(iid)
                 else:
-                    index.append(
-                        Node(
-                            text=pid,
-                            iid=pid,
-                            children=[iid],
-                        )
+                    tree[pid] = Node(
+                        text=pid,
+                        iid=pid,
+                        children=[iid],
                     )
-                    self.rns[pid] = len(index) - 1
-                index[self.rns[iid]].parent = pid
+                tree[iid].parent = pid
             else:
-                index[self.rns[iid]].parent = ""
+                tree[iid].parent = ""
         exclude = set()
         if not include_iid_column:
             exclude.add(iid_column)
@@ -3065,18 +3058,35 @@ class RowIndex(tk.Canvas):
         if isinstance(text_column, int) and not include_text_column:
             exclude.add(text_column)
         rows = []
+        ctr = 0
         if exclude:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
-                rows.append(row)
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(e for i, e in enumerate(data[data_rns[diid]]) if i not in exclude)
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         else:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                row.extend(data[data_rns[iid]])
-                rows.append(row)
-        self.MT._row_index = []
-        self.rns = {}
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    row.extend(data[data_rns[iid]])
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(data[data_rns[diid]])
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         self.PAR.insert_rows(
             rows=rows,
             idx=0,
@@ -3091,7 +3101,6 @@ class RowIndex(tk.Canvas):
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
-        self.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:
@@ -3118,8 +3127,8 @@ class RowIndex(tk.Canvas):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> None:
-        index = self.MT._row_index
         data_rns = {}
+        tree = {}
         iids_missing_rows = set()
         if text_column is None:
             text_column = iid_column
@@ -3146,43 +3155,36 @@ class RowIndex(tk.Canvas):
                     x += 1
                 tally_of_ids[iid] += 1
                 row[iid_column] = new
-            if iid in self.rns:
-                index[self.rns[iid]].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
+            if iid in tree:
+                tree[iid].text = row[text_column] if isinstance(text_column, int) else text_column[rn]
             else:
-                index.append(
-                    Node(
-                        text=row[text_column] if isinstance(text_column, int) else text_column[rn],
-                        iid=iid,
-                        parent="",
-                    )
+                tree[iid] = Node(
+                    text=row[text_column] if isinstance(text_column, int) else text_column[rn],
+                    iid=iid,
+                    parent="",
                 )
-                self.rns[iid] = len(index) - 1
             if iid in iids_missing_rows:
                 iids_missing_rows.discard(iid)
             data_rns[iid] = rn
-            if iid == pid or self.build_pid_causes_recursive_loop(iid, pid):
+            if iid == pid or self.build_pid_causes_recursive_loop(iid, pid, tree):
                 row[parent_column] = ""
                 pid = ""
             if pid:
-                if pid in self.rns:
-                    index[self.rns[pid]].children.append(iid)
+                if pid in tree:
+                    tree[pid].children.append(iid)
                 else:
-                    index.append(
-                        Node(
-                            text=pid,
-                            iid=pid,
-                            children=[iid],
-                        )
+                    tree[pid] = Node(
+                        text=pid,
+                        iid=pid,
+                        children=[iid],
                     )
                     iids_missing_rows.add(pid)
-                    self.rns[pid] = len(index) - 1
-                index[self.rns[iid]].parent = pid
+                tree[iid].parent = pid
             else:
-                index[self.rns[iid]].parent = ""
+                tree[iid].parent = ""
         empty_rows = {}
         for iid in iids_missing_rows:
-            node = index[self.rns[iid]]
-            node.parent = ""
+            node = tree[iid]
             newrow = self.MT.get_empty_row_seq(len(data), ncols)
             newrow[iid_column] = node.iid
             empty_rows[node.iid] = newrow
@@ -3194,24 +3196,41 @@ class RowIndex(tk.Canvas):
         if isinstance(text_column, int) and not include_text_column:
             exclude.add(text_column)
         rows = []
+        ctr = 0
         if exclude:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                if iid in empty_rows:
-                    row.extend(e for i, e in enumerate(empty_rows[iid]) if i not in exclude)
-                else:
-                    row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
-                rows.append(row)
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    if iid in empty_rows:
+                        row.extend(e for i, e in enumerate(empty_rows[iid]) if i not in exclude)
+                    else:
+                        row.extend(e for i, e in enumerate(data[data_rns[iid]]) if i not in exclude)
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(e for i, e in enumerate(data[data_rns[diid]]) if i not in exclude)
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         else:
-            for iid in self.PAR.tree_traverse():
-                row = [index[self.rns[iid]]]
-                if iid in empty_rows:
-                    row.extend(empty_rows[iid])
-                else:
-                    row.extend(data[data_rns[iid]])
-                rows.append(row)
-        self.MT._row_index = []
-        self.rns = {}
+            for iid, node in tree.items():
+                if node.parent == "":
+                    row = [tree[iid]]
+                    if iid in empty_rows:
+                        row.extend(empty_rows[iid])
+                    else:
+                        row.extend(data[data_rns[iid]])
+                    rows.append(row)
+                    self.rns[iid] = ctr
+                    ctr += 1
+                    for diid in self._build_get_descendants(iid, tree):
+                        row = [tree[diid]]
+                        row.extend(data[data_rns[diid]])
+                        rows.append(row)
+                        self.rns[diid] = ctr
+                        ctr += 1
         self.PAR.insert_rows(
             rows=rows,
             idx=0,
@@ -3226,7 +3245,6 @@ class RowIndex(tk.Canvas):
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
-        self.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:
@@ -3237,3 +3255,29 @@ class RowIndex(tk.Canvas):
                 data_indexes=True,
                 row_heights=row_heights is not False,
             )
+
+    def _build_get_descendants(self, iid: str, tree: dict[str, Node]) -> Generator[str]:
+        stack = [iter(tree[iid].children)]
+        while stack:
+            top_iterator = stack[-1]
+            try:
+                ciid = next(top_iterator)
+                yield ciid
+                if tree[ciid].children:
+                    stack.append(iter(tree[ciid].children))
+            except StopIteration:
+                stack.pop()
+
+    def build_pid_causes_recursive_loop(self, iid: str, pid: str, tree: dict[str, Node]) -> bool:
+        # check descendants
+        for diid in self._build_get_descendants(iid, tree):
+            if diid == pid:
+                return True
+        # check ancestors
+        current_iid = iid
+        while tree[current_iid].parent:
+            parent_iid = tree[current_iid].parent
+            if parent_iid == pid:
+                return True
+            current_iid = parent_iid
+        return False