tksheet 7.4.2__py3-none-any.whl → 7.4.4__py3-none-any.whl

tksheet/main_table.py

@@ -50,7 +50,6 @@ from .functions import (
     consecutive_ranges,
     data_to_displayed_idxs,
     diff_gen,
-    diff_list,
     down_cell_within_box,
     event_dict,
     event_has_char_key,
@@ -72,6 +71,7 @@ from .functions import (
     mod_span,
     mod_span_widget,
     move_elements_by_mapping,
+    move_elements_by_mapping_gen,
     new_tk_event,
     next_cell,
     push_n,
@@ -932,19 +932,21 @@ class MainTable(tk.Canvas):
     def sort_boxes(
         self,
         event: tk.Event | None = None,
-        boxes: AnyIter[int, int, int, int] | None = None,
+        boxes: dict[tuple[int, int, int, int], Literal["cells", "rows", "columns"]] | None = None,
         reverse: bool = False,
         row_wise: bool = False,
         validation: bool = True,
         key: Callable | None = None,
         undo: bool = True,
     ) -> EventDataDict:
-        if boxes is None:
+        if not boxes:
             boxes = self.get_boxes()
         if not boxes:
-            boxes = [(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1)]
+            boxes = {Box_nt(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1): "cells"}
         event_data = self.new_event_dict("edit_table", boxes=boxes)
         try_binding(self.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for r1, c1, r2, c2 in boxes:
             data = sort_selection(
                 [[self.get_cell_data(self.datarn(r), self.datacn(c)) for c in range(c1, c2)] for r in range(r1, r2)],
@@ -1287,26 +1289,36 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
     ) -> tuple[dict[int, int], dict[int, int], int, dict[int, int]]:
         if not data_indexes or self.all_columns_displayed:
-            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+            disp_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
+            data_new_idxs = dict(disp_new_idxs)
         else:
             disp_new_idxs = {}
+            data_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
         # at_least_cols should not be len in this case as move_to can be len
         fix_len = (move_to - 1) if move_to else move_to
         if not self.all_columns_displayed and not data_indexes:
             fix_len = self.datacn(fix_len)
         totalcols = self.equalize_data_row_lengths(at_least_cols=fix_len)
-        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         if not self.all_columns_displayed and not data_indexes:
-            data_new_idxs = dict(
-                zip(
-                    move_elements_by_mapping(
+            keep = set(map(self.datacn, to_move))
+            data_new_idxs = {
+                k: v
+                for k, v in zip(
+                    move_elements_by_mapping_gen(
                         self.displayed_columns,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
                     ),
                     self.displayed_columns,
-                ),
-            )
+                )
+                if k in keep
+            }
         return data_new_idxs, dict(zip(data_new_idxs.values(), data_new_idxs)), totalcols, disp_new_idxs
 
     def move_columns_adjust_options_dict(
@@ -1338,7 +1350,7 @@ class MainTable(tk.Canvas):
 
         if move_widths and disp_new_idxs:
             self.set_col_positions(
-                itr=move_elements_by_mapping(
+                itr=move_elements_by_mapping_gen(
                     self.get_column_widths(),
                     disp_new_idxs,
                     dict(
@@ -1537,7 +1549,7 @@ class MainTable(tk.Canvas):
             data_new_idxs = {
                 k: v
                 for k, v in zip(
-                    move_elements_by_mapping(
+                    move_elements_by_mapping_gen(
                         self.displayed_rows,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
@@ -1732,7 +1744,7 @@ class MainTable(tk.Canvas):
 
         if move_heights and disp_new_idxs:
             self.set_row_positions(
-                itr=move_elements_by_mapping(
+                itr=move_elements_by_mapping_gen(
                     self.get_row_heights(),
                     disp_new_idxs,
                     dict(
@@ -1788,7 +1800,7 @@ class MainTable(tk.Canvas):
             old_idxs = dict(zip(new_idxs.values(), new_idxs))
         return dict(
             zip(
-                move_elements_by_mapping(tuple(range(max_idx + 1)), new_idxs, old_idxs),
+                move_elements_by_mapping_gen(tuple(range(max_idx + 1)), new_idxs, old_idxs),
                 range(max_idx + 1),
             )
         )
@@ -1973,7 +1985,7 @@ class MainTable(tk.Canvas):
             event_data = self.delete_rows_displayed(
                 rows=tuple(reversed(modification["added"]["rows"]["row_heights"])),
                 event_data=event_data,
-                restored_state=True,
+                from_undo=True,
             )
 
         if modification["added"]["columns"]:
@@ -1985,7 +1997,7 @@ class MainTable(tk.Canvas):
             event_data = self.delete_columns_displayed(
                 cols=tuple(reversed(modification["added"]["columns"]["column_widths"])),
                 event_data=event_data,
-                restored_state=True,
+                from_undo=True,
             )
 
         if modification["deleted"]["rows"] or modification["deleted"]["row_heights"]:
@@ -1998,7 +2010,7 @@ class MainTable(tk.Canvas):
                 create_ops=False,
                 create_selections=False,
                 add_col_positions=False,
-                restored_state=True,
+                from_undo=True,
             )
 
         if modification["deleted"]["columns"] or modification["deleted"]["column_widths"]:
@@ -2010,7 +2022,7 @@ class MainTable(tk.Canvas):
                 create_ops=False,
                 create_selections=False,
                 add_row_positions=False,
-                restored_state=True,
+                from_undo=True,
             )
 
         if modification["eventname"].startswith(("edit", "move")):
@@ -4489,10 +4501,10 @@ class MainTable(tk.Canvas):
             self.set_row_positions(itr=(h for i, h in enumerate(self.gen_row_heights()) if i not in idxs))
 
     def get_column_widths(self) -> list[int]:
-        return diff_list(self.col_positions)
+        return list(diff_gen(self.col_positions))
 
     def get_row_heights(self) -> list[int]:
-        return diff_list(self.row_positions)
+        return list(diff_gen(self.row_positions))
 
     def gen_column_widths(self) -> Generator[int]:
         return diff_gen(self.col_positions)
@@ -4893,16 +4905,18 @@ class MainTable(tk.Canvas):
         add_row_positions: bool = True,
         push_ops: bool = True,
         mod_event_boxes: bool = True,
-        restored_state: bool = False,
-    ) -> EventDataDict:
+        from_undo: bool = False,
+    ) -> EventDataDict | None:
+        if not from_undo and not try_binding(self.extra_begin_insert_cols_rc_func, event_data, "begin_add_columns"):
+            return
         self.saved_column_widths = {}
-        if not restored_state and not self.all_columns_displayed:
+        if not from_undo and not self.all_columns_displayed:
             self.displayed_columns = add_to_displayed(self.displayed_columns, columns)
         cws = self.get_column_widths()
         if column_widths and next(reversed(column_widths)) > len(cws):
             for i in reversed(range(len(cws), len(cws) + next(reversed(column_widths)) - len(cws))):
                 column_widths[i] = self.PAR.ops.default_column_width
-        if not restored_state:
+        if not from_undo:
             self.set_col_positions(
                 itr=insert_items(
                     cws,
@@ -4928,7 +4942,7 @@ class MainTable(tk.Canvas):
                 "index": {},
                 "row_heights": {rn: default_height for rn in range(len(self.row_positions) - 1, maxrn + 1)},
             }
-            if not restored_state:
+            if not from_undo:
                 self.set_row_positions(
                     itr=chain(
                         self.gen_row_heights(),
@@ -4961,9 +4975,11 @@ class MainTable(tk.Canvas):
             "header": header,
             "column_widths": column_widths,
         }
+        if not from_undo:
+            try_binding(self.extra_end_insert_cols_rc_func, event_data, "end_add_columns")
         return event_data
 
-    def rc_add_columns(self, event: object = None):
+    def rc_add_columns(self, event: object = None) -> None:
         rowlen = self.equalize_data_row_lengths()
         selcols = sorted(self.get_selected_cols())
         if (
@@ -4997,8 +5013,6 @@ class MainTable(tk.Canvas):
             if numcols < 1:
                 return
         event_data = self.new_event_dict("add_columns", state=True)
-        if not try_binding(self.extra_begin_insert_cols_rc_func, event_data, "begin_add_columns"):
-            return
         columns, headers, widths = self.get_args_for_add_columns(data_ins_col, displayed_ins_col, numcols)
         event_data = self.add_columns(
             columns=columns,
@@ -5006,11 +5020,11 @@ class MainTable(tk.Canvas):
             column_widths=widths,
             event_data=event_data,
         )
-        if self.undo_enabled:
-            self.undo_stack.append(stored_event_dict(event_data))
-        self.refresh()
-        try_binding(self.extra_end_insert_cols_rc_func, event_data, "end_add_columns")
-        self.sheet_modified(event_data)
+        if event_data:
+            if self.undo_enabled:
+                self.undo_stack.append(stored_event_dict(event_data))
+            self.refresh()
+            self.sheet_modified(event_data)
 
     def add_rows(
         self,
@@ -5024,17 +5038,19 @@ class MainTable(tk.Canvas):
         push_ops: bool = True,
         tree: bool = True,
         mod_event_boxes: bool = True,
-        restored_state: bool = False,
-    ) -> EventDataDict:
+        from_undo: bool = False,
+    ) -> EventDataDict | None:
+        if not from_undo and not try_binding(self.extra_begin_insert_rows_rc_func, event_data, "begin_add_rows"):
+            return
         self.saved_row_heights = {}
-        if not restored_state and not self.all_rows_displayed:
+        if not from_undo and not self.all_rows_displayed:
             self.displayed_rows = add_to_displayed(self.displayed_rows, rows)
         rhs = self.get_row_heights()
         if row_heights and next(reversed(row_heights)) > len(rhs):
             default_row_height = self.get_default_row_height()
             for i in reversed(range(len(rhs), len(rhs) + next(reversed(row_heights)) - len(rhs))):
                 row_heights[i] = default_row_height
-        if not restored_state:
+        if not from_undo:
             self.set_row_positions(
                 itr=insert_items(
                     rhs,
@@ -5060,7 +5076,7 @@ class MainTable(tk.Canvas):
                 "header": {},
                 "column_widths": {cn: default_width for cn in range(len(self.col_positions) - 1, maxcn + 1)},
             }
-            if not restored_state:
+            if not from_undo:
                 self.set_col_positions(
                     itr=chain(
                         self.gen_column_widths(),
@@ -5093,9 +5109,11 @@ class MainTable(tk.Canvas):
         }
         if tree and self.PAR.ops.treeview:
             event_data = self.RI.tree_add_rows(event_data=event_data)
+        if not from_undo:
+            try_binding(self.extra_end_insert_rows_rc_func, event_data, "end_add_rows")
         return event_data
 
-    def rc_add_rows(self, event: object = None):
+    def rc_add_rows(self, event: object = None) -> None:
         total_data_rows = self.total_data_rows()
         selrows = sorted(self.get_selected_rows())
         if (
@@ -5129,8 +5147,6 @@ class MainTable(tk.Canvas):
             if numrows < 1:
                 return
         event_data = self.new_event_dict("add_rows", state=True)
-        if not try_binding(self.extra_begin_insert_rows_rc_func, event_data, "begin_add_rows"):
-            return
         rows, index, heights = self.get_args_for_add_rows(data_ins_row, displayed_ins_row, numrows)
         event_data = self.add_rows(
             rows=rows,
@@ -5138,11 +5154,11 @@ class MainTable(tk.Canvas):
             row_heights=heights,
             event_data=event_data,
         )
-        if self.undo_enabled:
-            self.undo_stack.append(stored_event_dict(event_data))
-        self.refresh()
-        try_binding(self.extra_end_insert_rows_rc_func, event_data, "end_add_rows")
-        self.sheet_modified(event_data)
+        if event_data:
+            if self.undo_enabled:
+                self.undo_stack.append(stored_event_dict(event_data))
+            self.refresh()
+            self.sheet_modified(event_data)
 
     def get_args_for_add_columns(
         self,
@@ -5311,7 +5327,7 @@ class MainTable(tk.Canvas):
         self,
         cols: list[int],
         event_data: EventDataDict | None = None,
-        restored_state: bool = False,
+        from_undo: bool = False,
     ) -> EventDataDict:
         if not event_data:
             event_data = self.new_event_dict("delete_columns", state=True)
@@ -5320,7 +5336,7 @@ class MainTable(tk.Canvas):
             for c in reversed(cols):
                 if len(self.col_positions) > c + 1:
                     event_data["deleted"]["column_widths"][c] = self.col_positions[c + 1] - self.col_positions[c]
-            if not restored_state:
+            if not from_undo:
                 cols_set = set(cols)
                 self.set_col_positions(
                     itr=(width for c, width in enumerate(self.gen_column_widths()) if c not in cols_set)
@@ -5334,13 +5350,12 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
         undo: bool = True,
         emit_event: bool = True,
-        ext: bool = False,
     ) -> EventDataDict:
         event_data = self.new_event_dict("delete_columns", state=True)
         if not columns:
             if not (columns := sorted(self.get_selected_cols())):
                 return event_data
-        if not ext and not try_binding(self.extra_begin_del_cols_rc_func, event_data, "begin_delete_columns"):
+        if not try_binding(self.extra_begin_del_cols_rc_func, event_data, "begin_delete_columns"):
             return
         if self.all_columns_displayed:
             data_columns = columns
@@ -5362,8 +5377,7 @@ class MainTable(tk.Canvas):
         )
         if undo and self.undo_enabled:
             self.undo_stack.append(stored_event_dict(event_data))
-        if not ext:
-            try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
+        try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
         if emit_event:
             self.sheet_modified(event_data)
         self.deselect("all")
@@ -5400,7 +5414,7 @@ class MainTable(tk.Canvas):
         self,
         rows: list[int],
         event_data: EventDataDict | None = None,
-        restored_state: bool = False,
+        from_undo: bool = False,
     ) -> EventDataDict:
         if not event_data:
             event_data = self.new_event_dict("delete_rows", state=True)
@@ -5409,7 +5423,7 @@ class MainTable(tk.Canvas):
             for r in reversed(rows):
                 if len(self.row_positions) > r + 1:
                     event_data["deleted"]["row_heights"][r] = self.row_positions[r + 1] - self.row_positions[r]
-            if not restored_state:
+            if not from_undo:
                 rows_set = set(rows)
                 self.set_row_positions(
                     itr=(height for r, height in enumerate(self.gen_row_heights()) if r not in rows_set)
@@ -5423,13 +5437,12 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
         undo: bool = True,
         emit_event: bool = True,
-        ext: bool = False,
     ) -> EventDataDict:
         event_data = self.new_event_dict("delete_rows", state=True)
         if not rows:
             if not (rows := sorted(self.get_selected_rows())):
                 return
-        if not ext and not try_binding(self.extra_begin_del_rows_rc_func, event_data, "begin_delete_rows"):
+        if not try_binding(self.extra_begin_del_rows_rc_func, event_data, "begin_delete_rows"):
             return
         if self.all_rows_displayed:
             data_rows = rows
@@ -5462,8 +5475,7 @@ class MainTable(tk.Canvas):
         )
         if undo and self.undo_enabled:
             self.undo_stack.append(stored_event_dict(event_data))
-        if not ext:
-            try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
+        try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
         if emit_event:
             self.sheet_modified(event_data)
         self.deselect("all")
@@ -7893,26 +7905,20 @@ class MainTable(tk.Canvas):
                     self.data[datarn][datacn] = value
 
     def get_value_for_empty_cell(self, datarn: int, datacn: int, r_ops: bool = True, c_ops: bool = True) -> object:
-        if self.get_cell_kwargs(
-            datarn,
-            datacn,
-            key="checkbox",
-            cell=r_ops and c_ops,
-            row=r_ops,
-            column=c_ops,
-        ):
-            return False
         kwargs = self.get_cell_kwargs(
             datarn,
             datacn,
-            key="dropdown",
+            key=None,
             cell=r_ops and c_ops,
             row=r_ops,
             column=c_ops,
         )
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        if "checkbox" in kwargs:
+            return False
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_row_seq(
         self,
@@ -8072,18 +8078,21 @@ class MainTable(tk.Canvas):
         check_readonly: bool = True,
         ignore_empty: bool = False,
     ) -> bool:
-        if check_readonly and self.get_cell_kwargs(datarn, datacn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datarn, datacn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datarn, datacn, key="format"):
+        elif "format" in kwargs:
             return True
-        if self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty):
+        elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty):
             return False
-        kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif (
+            (dropdown := kwargs.get("dropdown", {})) and dropdown["validate_input"] and value not in dropdown["values"]
+        ):
             return False
-        if self.get_cell_kwargs(datarn, datacn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datarn: int, datacn: int, value: object, ignore_empty: bool = False, **kwargs) -> bool:
         v = self.get_cell_data(datarn, datacn)
@@ -8118,18 +8127,21 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        key: Hashable = "format",
+        key: Hashable | None = "format",
         cell: bool = True,
         row: bool = True,
         column: bool = True,
     ) -> dict:
-        if cell and (datarn, datacn) in self.cell_options and key in self.cell_options[(datarn, datacn)]:
-            return self.cell_options[(datarn, datacn)][key]
-        if row and datarn in self.row_options and key in self.row_options[datarn]:
-            return self.row_options[datarn][key]
-        if column and datacn in self.col_options and key in self.col_options[datacn]:
-            return self.col_options[datacn][key]
-        return {}
+        if cell and (datarn, datacn) in self.cell_options:
+            return (
+                self.cell_options[(datarn, datacn)] if key is None else self.cell_options[(datarn, datacn)].get(key, {})
+            )
+        elif row and datarn in self.row_options:
+            return self.row_options[datarn] if key is None else self.row_options[datarn].get(key, {})
+        elif column and datacn in self.col_options:
+            return self.col_options[datacn] if key is None else self.col_options[datacn].get(key, {})
+        else:
+            return {}
 
     def datacn(self, c: int) -> int:
         return c if self.all_columns_displayed else self.displayed_columns[c]

tksheet/row_index.py

@@ -19,7 +19,6 @@ from .constants import (
 )
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
-    consecutive_chunks,
     consecutive_ranges,
     del_placeholder_dict_key,
     event_dict,
@@ -686,10 +685,10 @@ class RowIndex(tk.Canvas):
             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):
+        for boxst, boxend in consecutive_ranges(rows):
             self.MT.show_ctrl_outline(
-                start_cell=(0, chunk[0]),
-                end_cell=(len(self.MT.col_positions) - 1, chunk[-1] + 1),
+                start_cell=(0, boxst),
+                end_cell=(len(self.MT.col_positions) - 1, boxend),
                 dash=(),
                 outline=self.ops.drag_and_drop_bg,
                 delete_on_timer=False,
@@ -901,6 +900,8 @@ class RowIndex(tk.Canvas):
             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)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for r in rows:
             datarn = self.MT.datarn(r)
             for c, val in enumerate(sort_row(self.MT.data[datarn], reverse=reverse, key=key)):
@@ -944,6 +945,8 @@ class RowIndex(tk.Canvas):
                 return event_data
             row = self.MT.selected.row
         if try_binding(self.ri_extra_begin_sort_cols_func, event_data, "begin_move_columns"):
+            if key is None:
+                key = self.PAR.ops.sort_key
             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:
@@ -2425,16 +2428,17 @@ class RowIndex(tk.Canvas):
                 self.MT._row_index[datarn] = value
 
     def input_valid_for_cell(self, datarn: int, value: object, check_readonly: bool = True) -> bool:
-        if check_readonly and self.get_cell_kwargs(datarn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datarn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datarn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        if self.cell_equal_to(datarn, value):
+        elif self.cell_equal_to(datarn, value):
             return False
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and value not in kwargs["values"]:
             return False
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datarn: int, value: object) -> bool:
         self.fix_index(datarn)
@@ -2496,12 +2500,13 @@ class RowIndex(tk.Canvas):
         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):
+        kwargs = self.get_cell_kwargs(datarn, key=None, cell=r_ops)
+        if "checkbox" in kwargs:
             return False
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown", cell=r_ops)
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_index_seq(self, end: int, start: int = 0, r_ops: bool = True) -> list[object]:
         return [self.get_value_for_empty_cell(datarn, r_ops=r_ops) for datarn in range(start, end)]
@@ -2568,10 +2573,11 @@ class RowIndex(tk.Canvas):
         if redraw:
             self.MT.refresh()
 
-    def get_cell_kwargs(self, datarn: int, key: Hashable = "dropdown", cell: bool = True) -> dict:
-        if cell and datarn in self.cell_options and key in self.cell_options[datarn]:
-            return self.cell_options[datarn][key]
-        return {}
+    def get_cell_kwargs(self, datarn: int, key: Hashable | None = "dropdown", cell: bool = True) -> dict:
+        if cell and datarn in self.cell_options:
+            return self.cell_options[datarn] if key is None else self.cell_options[datarn].get(key, {})
+        else:
+            return {}
 
     # Treeview Mode
 
@@ -2672,25 +2678,33 @@ class RowIndex(tk.Canvas):
                     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))
-                        )
+                        if isinstance(move_to_index, int):
+                            move_to_index = min(move_to_index, len(self.tree[new_parent].children))
+                        else:
+                            move_to_index = len(self.tree[new_parent].children)
+                        move_to_row = self.tree_rns[new_parent]
+                        if new_parent == self.tree[item].parent:
+                            move_to_index += 1
+                        for i, ciid in enumerate(self.tree[new_parent].children):
+                            if i == move_to_index:
+                                break
+                            move_to_row += sum(1 for _ in self.get_iid_descendants(ciid)) + 1
+                        insert_row = move_to_row + 1
                     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
+                            insert_row = move_to_row
                         else:
                             move_to_row = self.PAR.top_index_row(move_to_index)
+                            insert_row = move_to_row
                             if move_to_row is None:
                                 move_to_row = self.PAR.top_index_row(num_top_nodes - 1)
                                 move_to_index = num_top_nodes
+                                insert_row = move_to_row + 1
 
                     move_to_iid = self.MT._row_index[move_to_row].iid
-                    insert_row = move_to_row + 1
                     disp_insert_row = None
 
                 else:
@@ -2734,10 +2748,10 @@ class RowIndex(tk.Canvas):
                 event_data["moved"]["rows"]["displayed"] = {}
                 if new_loc_is_displayed:
                     if disp_insert_row is None:
-                        if new_parent == self.tree[item].parent:
+                        if new_parent or insert_row > move_to_row:
                             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
+                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid])
                     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:
@@ -2757,7 +2771,6 @@ class RowIndex(tk.Canvas):
                             index=move_to_index,
                         )
                         move_to_index += 1
-
                     event_data["moved"]["rows"]["data"] = get_new_indexes(
                         insert_row,
                         event_data["moved"]["rows"]["data"],
@@ -2783,7 +2796,6 @@ class RowIndex(tk.Canvas):
         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))
@@ -2960,9 +2972,7 @@ 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 to_move_iid == move_to_parent or any(
-            move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid)
-        )
+        return any(move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid))
 
     def tree_build(
         self,