tksheet 7.0.6__py3-none-any.whl → 7.1.1__py3-none-any.whl

tksheet/sheet.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import tkinter as tk
 from bisect import bisect_left
-from collections import deque
+from collections import defaultdict, deque
 from collections.abc import Callable, Generator, Iterator, Sequence
 from itertools import accumulate, chain, islice, product
+from timeit import default_timer
 from tkinter import ttk
 from typing import Literal
 from warnings import warn as WARNING
@@ -29,20 +30,23 @@ from .functions import (
     is_iterable,
     key_to_span,
     num2alpha,
+    pop_positions,
     set_align,
     set_readonly,
     span_froms,
     span_ranges,
     tksheet_type_error,
+    unpack,
 )
 from .main_table import MainTable
 from .other_classes import (
-    CurrentlySelectedClass,  # noqa: F401
     DotDict,
     EventDataDict,
     FontTuple,
     GeneratedMouseEvent,
+    Node,
     Span,
+    Selected,
 )
 from .row_index import RowIndex
 from .sheet_options import (
@@ -66,6 +70,7 @@ from .vars import (
     emitted_events,
     named_span_types,
     rc_binding,
+    scrollbar_options_keys,
 )
 
 
@@ -115,52 +120,6 @@ class Sheet(tk.Frame):
         all_columns_displayed: bool = True,
         displayed_rows: list[int] = [],
         all_rows_displayed: bool = True,
-        outline_thickness: int = 0,
-        outline_color: str = theme_light_blue["outline_color"],
-        theme: str = "light blue",
-        frame_bg: str = theme_light_blue["table_bg"],
-        popup_menu_fg: str = theme_light_blue["popup_menu_fg"],
-        popup_menu_bg: str = theme_light_blue["popup_menu_bg"],
-        popup_menu_highlight_bg: str = theme_light_blue["popup_menu_highlight_bg"],
-        popup_menu_highlight_fg: str = theme_light_blue["popup_menu_highlight_fg"],
-        table_grid_fg: str = theme_light_blue["table_grid_fg"],
-        table_bg: str = theme_light_blue["table_bg"],
-        table_fg: str = theme_light_blue["table_fg"],
-        table_selected_box_cells_fg: str = theme_light_blue["table_selected_box_cells_fg"],
-        table_selected_box_rows_fg: str = theme_light_blue["table_selected_box_rows_fg"],
-        table_selected_box_columns_fg: str = theme_light_blue["table_selected_box_columns_fg"],
-        table_selected_cells_border_fg: str = theme_light_blue["table_selected_cells_border_fg"],
-        table_selected_cells_bg: str = theme_light_blue["table_selected_cells_bg"],
-        table_selected_cells_fg: str = theme_light_blue["table_selected_cells_fg"],
-        table_selected_rows_border_fg: str = theme_light_blue["table_selected_rows_border_fg"],
-        table_selected_rows_bg: str = theme_light_blue["table_selected_rows_bg"],
-        table_selected_rows_fg: str = theme_light_blue["table_selected_rows_fg"],
-        table_selected_columns_border_fg: str = theme_light_blue["table_selected_columns_border_fg"],
-        table_selected_columns_bg: str = theme_light_blue["table_selected_columns_bg"],
-        table_selected_columns_fg: str = theme_light_blue["table_selected_columns_fg"],
-        resizing_line_fg: str = theme_light_blue["resizing_line_fg"],
-        drag_and_drop_bg: str = theme_light_blue["drag_and_drop_bg"],
-        index_bg: str = theme_light_blue["index_bg"],
-        index_border_fg: str = theme_light_blue["index_border_fg"],
-        index_grid_fg: str = theme_light_blue["index_grid_fg"],
-        index_fg: str = theme_light_blue["index_fg"],
-        index_selected_cells_bg: str = theme_light_blue["index_selected_cells_bg"],
-        index_selected_cells_fg: str = theme_light_blue["index_selected_cells_fg"],
-        index_selected_rows_bg: str = theme_light_blue["index_selected_rows_bg"],
-        index_selected_rows_fg: str = theme_light_blue["index_selected_rows_fg"],
-        index_hidden_rows_expander_bg: str = theme_light_blue["index_hidden_rows_expander_bg"],
-        header_bg: str = theme_light_blue["header_bg"],
-        header_border_fg: str = theme_light_blue["header_border_fg"],
-        header_grid_fg: str = theme_light_blue["header_grid_fg"],
-        header_fg: str = theme_light_blue["header_fg"],
-        header_selected_cells_bg: str = theme_light_blue["header_selected_cells_bg"],
-        header_selected_cells_fg: str = theme_light_blue["header_selected_cells_fg"],
-        header_selected_columns_bg: str = theme_light_blue["header_selected_columns_bg"],
-        header_selected_columns_fg: str = theme_light_blue["header_selected_columns_fg"],
-        header_hidden_columns_expander_bg: str = theme_light_blue["header_hidden_columns_expander_bg"],
-        top_left_bg: str = theme_light_blue["top_left_bg"],
-        top_left_fg: str = theme_light_blue["top_left_fg"],
-        top_left_fg_highlight: str = theme_light_blue["top_left_fg_highlight"],
         to_clipboard_delimiter: str = "\t",
         to_clipboard_quotechar: str = '"',
         to_clipboard_lineterminator: str = "\n",
@@ -174,7 +133,7 @@ class Sheet(tk.Frame):
         show_dropdown_borders: bool = False,
         arrow_key_down_right_scroll_page: bool = False,
         cell_auto_resize_enabled: bool = True,
-        auto_resize_row_index: bool = True,
+        auto_resize_row_index: bool | Literal["empty"] = "empty",
         auto_resize_columns: int | None = None,
         auto_resize_rows: int | None = None,
         set_cell_sizes_on_zoom: bool = False,
@@ -210,6 +169,91 @@ class Sheet(tk.Frame):
         show_horizontal_grid: bool = True,
         display_selected_fg_over_highlights: bool = False,
         show_selected_cells_border: bool = True,
+        treeview: bool = False,
+        # colors
+        outline_thickness: int = 0,
+        outline_color: str = theme_light_blue["outline_color"],
+        theme: str = "light blue",
+        frame_bg: str = theme_light_blue["table_bg"],
+        popup_menu_fg: str = theme_light_blue["popup_menu_fg"],
+        popup_menu_bg: str = theme_light_blue["popup_menu_bg"],
+        popup_menu_highlight_bg: str = theme_light_blue["popup_menu_highlight_bg"],
+        popup_menu_highlight_fg: str = theme_light_blue["popup_menu_highlight_fg"],
+        table_grid_fg: str = theme_light_blue["table_grid_fg"],
+        table_bg: str = theme_light_blue["table_bg"],
+        table_fg: str = theme_light_blue["table_fg"],
+        table_selected_box_cells_fg: str = theme_light_blue["table_selected_box_cells_fg"],
+        table_selected_box_rows_fg: str = theme_light_blue["table_selected_box_rows_fg"],
+        table_selected_box_columns_fg: str = theme_light_blue["table_selected_box_columns_fg"],
+        table_selected_cells_border_fg: str = theme_light_blue["table_selected_cells_border_fg"],
+        table_selected_cells_bg: str = theme_light_blue["table_selected_cells_bg"],
+        table_selected_cells_fg: str = theme_light_blue["table_selected_cells_fg"],
+        table_selected_rows_border_fg: str = theme_light_blue["table_selected_rows_border_fg"],
+        table_selected_rows_bg: str = theme_light_blue["table_selected_rows_bg"],
+        table_selected_rows_fg: str = theme_light_blue["table_selected_rows_fg"],
+        table_selected_columns_border_fg: str = theme_light_blue["table_selected_columns_border_fg"],
+        table_selected_columns_bg: str = theme_light_blue["table_selected_columns_bg"],
+        table_selected_columns_fg: str = theme_light_blue["table_selected_columns_fg"],
+        resizing_line_fg: str = theme_light_blue["resizing_line_fg"],
+        drag_and_drop_bg: str = theme_light_blue["drag_and_drop_bg"],
+        index_bg: str = theme_light_blue["index_bg"],
+        index_border_fg: str = theme_light_blue["index_border_fg"],
+        index_grid_fg: str = theme_light_blue["index_grid_fg"],
+        index_fg: str = theme_light_blue["index_fg"],
+        index_selected_cells_bg: str = theme_light_blue["index_selected_cells_bg"],
+        index_selected_cells_fg: str = theme_light_blue["index_selected_cells_fg"],
+        index_selected_rows_bg: str = theme_light_blue["index_selected_rows_bg"],
+        index_selected_rows_fg: str = theme_light_blue["index_selected_rows_fg"],
+        index_hidden_rows_expander_bg: str = theme_light_blue["index_hidden_rows_expander_bg"],
+        header_bg: str = theme_light_blue["header_bg"],
+        header_border_fg: str = theme_light_blue["header_border_fg"],
+        header_grid_fg: str = theme_light_blue["header_grid_fg"],
+        header_fg: str = theme_light_blue["header_fg"],
+        header_selected_cells_bg: str = theme_light_blue["header_selected_cells_bg"],
+        header_selected_cells_fg: str = theme_light_blue["header_selected_cells_fg"],
+        header_selected_columns_bg: str = theme_light_blue["header_selected_columns_bg"],
+        header_selected_columns_fg: str = theme_light_blue["header_selected_columns_fg"],
+        header_hidden_columns_expander_bg: str = theme_light_blue["header_hidden_columns_expander_bg"],
+        top_left_bg: str = theme_light_blue["top_left_bg"],
+        top_left_fg: str = theme_light_blue["top_left_fg"],
+        top_left_fg_highlight: str = theme_light_blue["top_left_fg_highlight"],
+        vertical_scroll_background: str = theme_light_blue["vertical_scroll_background"],
+        horizontal_scroll_background: str = theme_light_blue["horizontal_scroll_background"],
+        vertical_scroll_troughcolor: str = theme_light_blue["vertical_scroll_troughcolor"],
+        horizontal_scroll_troughcolor: str = theme_light_blue["horizontal_scroll_troughcolor"],
+        vertical_scroll_lightcolor: str = theme_light_blue["vertical_scroll_lightcolor"],
+        horizontal_scroll_lightcolor: str = theme_light_blue["horizontal_scroll_lightcolor"],
+        vertical_scroll_darkcolor: str = theme_light_blue["vertical_scroll_darkcolor"],
+        horizontal_scroll_darkcolor: str = theme_light_blue["horizontal_scroll_darkcolor"],
+        vertical_scroll_relief: str = theme_light_blue["vertical_scroll_relief"],
+        horizontal_scroll_relief: str = theme_light_blue["horizontal_scroll_relief"],
+        vertical_scroll_troughrelief: str = theme_light_blue["vertical_scroll_troughrelief"],
+        horizontal_scroll_troughrelief: str = theme_light_blue["horizontal_scroll_troughrelief"],
+        vertical_scroll_bordercolor: str = theme_light_blue["vertical_scroll_bordercolor"],
+        horizontal_scroll_bordercolor: str = theme_light_blue["horizontal_scroll_bordercolor"],
+        vertical_scroll_borderwidth: int = 1,
+        horizontal_scroll_borderwidth: int = 1,
+        vertical_scroll_gripcount: int = 0,
+        horizontal_scroll_gripcount: int = 0,
+        vertical_scroll_active_bg: str = theme_light_blue["vertical_scroll_active_bg"],
+        horizontal_scroll_active_bg: str = theme_light_blue["horizontal_scroll_active_bg"],
+        vertical_scroll_not_active_bg: str = theme_light_blue["vertical_scroll_not_active_bg"],
+        horizontal_scroll_not_active_bg: str = theme_light_blue["horizontal_scroll_not_active_bg"],
+        vertical_scroll_pressed_bg: str = theme_light_blue["vertical_scroll_pressed_bg"],
+        horizontal_scroll_pressed_bg: str = theme_light_blue["horizontal_scroll_pressed_bg"],
+        vertical_scroll_active_fg: str = theme_light_blue["vertical_scroll_active_fg"],
+        horizontal_scroll_active_fg: str = theme_light_blue["horizontal_scroll_active_fg"],
+        vertical_scroll_not_active_fg: str = theme_light_blue["vertical_scroll_not_active_fg"],
+        horizontal_scroll_not_active_fg: str = theme_light_blue["horizontal_scroll_not_active_fg"],
+        vertical_scroll_pressed_fg: str = theme_light_blue["vertical_scroll_pressed_fg"],
+        horizontal_scroll_pressed_fg: str = theme_light_blue["horizontal_scroll_pressed_fg"],
+        scrollbar_theme_inheritance: str = "default",
+        scrollbar_show_arrows: bool = True,
+        # changing the arrowsize (width) of the scrollbars
+        # is not working with 'default' theme
+        # use 'clam' theme instead if you want to change the width
+        vertical_scroll_arrowsize: str | int = "",
+        horizontal_scroll_arrowsize: str | int = "",
         # backwards compatibility
         column_width: int | None = None,
         header_height: str | int | None = None,
@@ -236,6 +280,9 @@ class Sheet(tk.Frame):
             default_row_height = row_height
         if row_index_width is not None:
             default_row_index_width = row_index_width
+        if treeview:
+            index_align = "w"
+            auto_resize_row_index = True
         for k, v in locals().items():
             if (xk := backwards_compatibility_keys.get(k, k)) in self.ops and v != self.ops[xk]:
                 self.ops[xk] = v
@@ -306,8 +353,64 @@ class Sheet(tk.Frame):
             row_index_canvas=self.RI,
             header_canvas=self.CH,
         )
-        self.yscroll = ttk.Scrollbar(self, command=self.MT.set_yviews, orient="vertical")
-        self.xscroll = ttk.Scrollbar(self, command=self.MT.set_xviews, orient="horizontal")
+        self.unique_id = f"{default_timer()}{self.winfo_id()}".replace(".", "")
+        style = ttk.Style()
+        for orientation in ("Vertical", "Horizontal"):
+            style.element_create(
+                f"Sheet{self.unique_id}.{orientation}.TScrollbar.trough",
+                "from",
+                scrollbar_theme_inheritance,
+            )
+            style.element_create(
+                f"Sheet{self.unique_id}.{orientation}.TScrollbar.thumb",
+                "from",
+                scrollbar_theme_inheritance,
+            )
+            style.element_create(
+                f"Sheet{self.unique_id}.{orientation}.TScrollbar.grip",
+                "from",
+                scrollbar_theme_inheritance,
+            )
+            if not scrollbar_show_arrows:
+                style.layout(
+                    f"Sheet{self.unique_id}.{orientation}.TScrollbar",
+                    [
+                        (
+                            f"Sheet{self.unique_id}.{orientation}.TScrollbar.trough",
+                            {
+                                "children": [
+                                    (
+                                        f"Sheet{self.unique_id}.{orientation}.TScrollbar.thumb",
+                                        {
+                                            "unit": "1",
+                                            "children": [
+                                                (
+                                                    f"Sheet{self.unique_id}.{orientation}.TScrollbar.grip",
+                                                    {"sticky": ""},
+                                                )
+                                            ],
+                                            "sticky": "nswe",
+                                        },
+                                    )
+                                ],
+                                "sticky": "ns" if orientation == "Vertical" else "ew",
+                            },
+                        )
+                    ],
+                )
+        self.set_scrollbar_options()
+        self.yscroll = ttk.Scrollbar(
+            self,
+            command=self.MT.set_yviews,
+            orient="vertical",
+            style=f"Sheet{self.unique_id}.Vertical.TScrollbar",
+        )
+        self.xscroll = ttk.Scrollbar(
+            self,
+            command=self.MT.set_xviews,
+            orient="horizontal",
+            style=f"Sheet{self.unique_id}.Horizontal.TScrollbar",
+        )
         if show_top_left:
             self.TL.grid(row=0, column=0)
         if show_table:
@@ -1343,9 +1446,11 @@ class Sheet(tk.Frame):
         row_heights: bool = True,
         column_widths: bool = True,
         cell_options: bool = True,
+        tags: bool = True,
         undo_stack: bool = True,
         selections: bool = True,
         sheet_options: bool = False,
+        tree: bool = True,
         redraw: bool = True,
     ) -> Sheet:
         if table:
@@ -1355,17 +1460,23 @@ class Sheet(tk.Frame):
         if index:
             self.MT._row_index = []
         if row_heights:
+            self.MT.saved_row_heights = {}
             self.MT.set_row_positions([])
         if column_widths:
+            self.MT.saved_column_widths = {}
             self.MT.set_col_positions([])
         if cell_options:
             self.reset_all_options()
+        if tags:
+            self.MT.reset_tags()
         if undo_stack:
             self.reset_undos()
         if selections:
             self.MT.deselect(redraw=False)
         if sheet_options:
             self.ops = new_sheet_options()
+        if tree:
+            self.RI.reset_tree()
         self.set_refresh_timer(redraw)
         return self
 
@@ -1470,7 +1581,7 @@ class Sheet(tk.Frame):
         event_data = event_dict(
             name="edit_table",
             sheet=self.name,
-            selected=self.MT.currently_selected(),
+            selected=self.MT.selected,
         )
         set_t = self.event_data_set_table_cell
         set_i, set_h = self.event_data_set_index_cell, self.event_data_set_header_cell
@@ -1700,7 +1811,7 @@ class Sheet(tk.Frame):
         event_data = event_dict(
             name="edit_table",
             sheet=self.name,
-            selected=self.MT.currently_selected(),
+            selected=self.MT.selected,
         )
         if index:
             for r in rows:
@@ -1811,6 +1922,7 @@ class Sheet(tk.Frame):
         fill: bool = True,
         undo: bool = False,
         emit_event: bool = False,
+        create_selections: bool = True,
         redraw: bool = True,
     ) -> EventDataDict:
         total_cols = None
@@ -1873,8 +1985,9 @@ class Sheet(tk.Frame):
                 name="add_rows",
                 sheet=self.name,
                 boxes=self.MT.get_boxes(),
-                selected=self.MT.currently_selected(),
+                selected=self.MT.selected,
             ),
+            create_selections=create_selections,
         )
         if undo:
             self.MT.undo_stack.append(ev_stack_dict(event_data))
@@ -1892,6 +2005,7 @@ class Sheet(tk.Frame):
         fill: bool = True,
         undo: bool = False,
         emit_event: bool = False,
+        create_selections: bool = True,
         redraw: bool = True,
     ) -> EventDataDict:
         old_total = self.MT.equalize_data_row_lengths()
@@ -1962,8 +2076,9 @@ class Sheet(tk.Frame):
                 name="add_columns",
                 sheet=self.name,
                 boxes=self.MT.get_boxes(),
-                selected=self.MT.currently_selected(),
+                selected=self.MT.selected,
             ),
+            create_selections=create_selections,
         )
         if undo:
             self.MT.undo_stack.append(ev_stack_dict(event_data))
@@ -2021,7 +2136,7 @@ class Sheet(tk.Frame):
             name="delete_rows",
             sheet=self.name,
             boxes=self.MT.get_boxes(),
-            selected=self.MT.currently_selected(),
+            selected=self.MT.selected,
         )
         if not data_indexes:
             event_data = self.MT.delete_rows_displayed(rows, event_data)
@@ -2062,7 +2177,7 @@ class Sheet(tk.Frame):
             name="delete_columns",
             sheet=self.name,
             boxes=self.MT.get_boxes(),
-            selected=self.MT.currently_selected(),
+            selected=self.MT.selected,
         )
         if not data_indexes:
             event_data = self.MT.delete_columns_displayed(columns, event_data)
@@ -2257,7 +2372,7 @@ class Sheet(tk.Frame):
         data_idxs, disp_idxs, event_data = self.MT.move_rows_adjust_options_dict(
             data_new_idxs=data_new_idxs,
             data_old_idxs=dict(zip(data_new_idxs.values(), data_new_idxs)),
-            totalcols=None,
+            totalrows=None,
             disp_new_idxs=disp_new_idxs,
             move_data=move_data,
             create_selections=create_selections,
@@ -2401,11 +2516,11 @@ class Sheet(tk.Frame):
     ) -> Span:
         span = self.span_from_key(*key)
         if span.table:
-            self.MT.destroy_opened_dropdown_window()
+            self.MT.hide_dropdown_window()
         if span.index:
-            self.RI.destroy_opened_dropdown_window()
+            self.RI.hide_dropdown_window()
         if span.header:
-            self.CH.destroy_opened_dropdown_window()
+            self.CH.hide_dropdown_window()
         self.del_options_using_span(span, "dropdown")
         self.set_refresh_timer(redraw)
         return span
@@ -2792,8 +2907,14 @@ class Sheet(tk.Frame):
 
     # Getting Selected Cells
 
-    def get_currently_selected(self) -> tuple[()] | CurrentlySelectedClass:
-        return self.MT.currently_selected()
+    def get_currently_selected(self) -> tuple[()] | Selected:
+        # if self.MT.selected:
+        #     return self.MT.selected._replace(type_=self.MT.selected.type_[:-1])
+        return self.MT.selected
+
+    @property
+    def selected(self) -> tuple[()] | Selected:
+        return self.MT.selected
 
     def get_selected_rows(
         self,
@@ -3179,7 +3300,7 @@ class Sheet(tk.Frame):
         canvas_positions: bool = False,
         reset: bool = False,
     ) -> Sheet:
-        if reset:
+        if reset or column_widths is None:
             self.MT.reset_col_positions()
         elif is_iterable(column_widths):
             if canvas_positions and isinstance(column_widths, list):
@@ -3194,9 +3315,9 @@ class Sheet(tk.Frame):
         canvas_positions: bool = False,
         reset: bool = False,
     ) -> Sheet:
-        if reset:
+        if reset or row_heights is None:
             self.MT.reset_row_positions()
-        if is_iterable(row_heights):
+        elif is_iterable(row_heights):
             if canvas_positions and isinstance(row_heights, list):
                 self.MT.row_positions = row_heights
             else:
@@ -3447,15 +3568,25 @@ class Sheet(tk.Frame):
     def cell_completely_visible(self, r: int, c: int, seperate_axes: bool = False) -> bool:
         return self.MT.cell_completely_visible(r, c, seperate_axes)
 
-    def set_xview(self, position: float, option: str = "moveto") -> Sheet:
-        self.MT.set_xviews(option, position)
-        return self
+    def set_xview(self, position: None | float = None, option: str = "moveto") -> Sheet | tuple[float, float]:
+        if position is not None:
+            self.MT.set_xviews(option, position)
+            return self
+        return self.MT.xview()
 
-    def set_yview(self, position: float, option: str = "moveto") -> Sheet:
-        self.MT.set_yviews(option, position)
-        return self
+    xview = set_xview
+    xview_moveto = set_xview
+
+    def set_yview(self, position: None | float = None, option: str = "moveto") -> Sheet | tuple[float, float]:
+        if position is not None:
+            self.MT.set_yviews(option, position)
+            return self
+        return self.MT.yview()
+
+    yview = set_yview
+    yview_moveto = set_yview
 
-    def set_view(self, x_args: [str, float], y_args: [str, float]) -> Sheet:
+    def set_view(self, x_args: list[str, float], y_args: list[str, float]) -> Sheet:
         self.MT.set_view(x_args, y_args)
         return self
 
@@ -3470,6 +3601,8 @@ class Sheet(tk.Frame):
     def displayed_column_to_data(self, c: int) -> int:
         return c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
 
+    data_c = displayed_column_to_data
+
     def display_columns(
         self,
         columns: None | Literal["all"] | Iterator[int] = None,
@@ -3494,31 +3627,70 @@ class Sheet(tk.Frame):
             self.set_refresh_timer(redraw if redraw else refresh)
         return res
 
-    # uses displayed indexes
     def hide_columns(
         self,
-        columns: int | set | Iterator[int] = set(),
+        columns: int | set[int] | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
+        data_indexes: bool = False,
     ) -> Sheet:
         if isinstance(columns, int):
-            _columns = {columns}
-        elif isinstance(columns, set):
-            _columns = columns
-        else:
-            _columns = set(columns)
-        if not _columns:
-            return
+            columns = {columns}
+        elif not isinstance(columns, set):
+            columns = set(columns)
+            if not columns:
+                return
         if self.MT.all_columns_displayed:
-            _columns = [c for c in range(self.MT.total_data_cols()) if c not in _columns]
+            self.MT.displayed_columns = [c for c in range(self.MT.total_data_cols()) if c not in columns]
+            to_pop = {c: c for c in columns}
         else:
-            _columns = [e for c, e in enumerate(self.MT.displayed_columns) if c not in _columns]
-        self.display_columns(
-            columns=_columns,
-            all_columns_displayed=False,
-            redraw=redraw,
-            deselect_all=deselect_all,
+            to_pop = {}
+            new_disp = []
+            if data_indexes:
+                for i, c in enumerate(self.MT.displayed_columns):
+                    if c not in columns:
+                        new_disp.append(c)
+                    else:
+                        to_pop[i] = c
+            else:
+                for i, c in enumerate(self.MT.displayed_columns):
+                    if i not in columns:
+                        new_disp.append(c)
+                    else:
+                        to_pop[i] = c
+            self.MT.displayed_columns = new_disp
+        self.MT.all_columns_displayed = False
+        self.MT.set_col_positions(
+            pop_positions(
+                itr=self.MT.gen_column_widths,
+                to_pop=to_pop,
+                save_to=self.MT.saved_column_widths,
+            ),
         )
+        if deselect_all:
+            self.MT.deselect(redraw=False)
+        self.set_refresh_timer(redraw)
+        return self
+
+    # uses data indexes
+    def show_columns(
+        self,
+        columns: int | Iterator[int],
+        redraw: bool = True,
+        deselect_all: bool = True,
+    ) -> Sheet:
+        if isinstance(columns, int):
+            columns = [columns]
+        cws = self.MT.get_column_widths()
+        for column in columns:
+            idx = bisect_left(self.MT.displayed_columns, column)
+            if len(self.MT.displayed_columns) == idx or self.MT.displayed_columns[idx] != column:
+                self.MT.displayed_columns.insert(idx, column)
+                cws.insert(idx, self.MT.saved_column_widths.pop(column, self.PAR.ops.default_column_width))
+        self.MT.set_col_positions(cws)
+        if deselect_all:
+            self.MT.deselect(redraw=False)
+        self.set_refresh_timer(redraw)
         return self
 
     def all_columns_displayed(self, a: bool | None = None) -> bool:
@@ -3536,6 +3708,8 @@ class Sheet(tk.Frame):
     def displayed_row_to_data(self, r: int) -> int:
         return r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
 
+    data_r = displayed_row_to_data
+
     def display_rows(
         self,
         rows: None | Literal["all"] | Iterator[int] = None,
@@ -3558,31 +3732,70 @@ class Sheet(tk.Frame):
             self.set_refresh_timer(redraw if redraw else refresh)
         return res
 
-    # uses displayed indexes
     def hide_rows(
         self,
-        rows: int | set | Iterator[int] = set(),
+        rows: int | set[int] | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
+        data_indexes: bool = False,
     ) -> Sheet:
         if isinstance(rows, int):
-            _rows = {rows}
-        elif isinstance(rows, set):
-            _rows = rows
-        else:
-            _rows = set(rows)
-        if not _rows:
-            return
+            rows = {rows}
+        elif not isinstance(rows, set):
+            rows = set(rows)
+            if not rows:
+                return
         if self.MT.all_rows_displayed:
-            _rows = [r for r in range(self.MT.total_data_rows()) if r not in _rows]
+            self.MT.displayed_rows = [r for r in range(self.MT.total_data_rows()) if r not in rows]
+            to_pop = {r: r for r in rows}
         else:
-            _rows = [e for r, e in enumerate(self.MT.displayed_rows) if r not in _rows]
-        self.display_rows(
-            rows=_rows,
-            all_rows_displayed=False,
-            redraw=redraw,
-            deselect_all=deselect_all,
+            to_pop = {}
+            new_disp = []
+            if data_indexes:
+                for i, r in enumerate(self.MT.displayed_rows):
+                    if r not in rows:
+                        new_disp.append(r)
+                    else:
+                        to_pop[i] = r
+            else:
+                for i, r in enumerate(self.MT.displayed_rows):
+                    if i not in rows:
+                        new_disp.append(r)
+                    else:
+                        to_pop[i] = r
+            self.MT.displayed_rows = new_disp
+        self.MT.all_rows_displayed = False
+        self.MT.set_row_positions(
+            pop_positions(
+                itr=self.MT.gen_row_heights,
+                to_pop=to_pop,
+                save_to=self.MT.saved_row_heights,
+            ),
         )
+        if deselect_all:
+            self.MT.deselect(redraw=False)
+        self.set_refresh_timer(redraw)
+        return self
+
+    # uses data indexes
+    def show_rows(
+        self,
+        rows: int | Iterator[int],
+        redraw: bool = True,
+        deselect_all: bool = True,
+    ) -> Sheet:
+        if isinstance(rows, int):
+            rows = [rows]
+        rhs = self.MT.get_row_heights()
+        for row in rows:
+            idx = bisect_left(self.MT.displayed_rows, row)
+            if len(self.MT.displayed_rows) == idx or self.MT.displayed_rows[idx] != row:
+                self.MT.displayed_rows.insert(idx, row)
+                rhs.insert(idx, self.MT.saved_row_heights.pop(row, self.MT.get_default_row_height()))
+        self.MT.set_row_positions(rhs)
+        if deselect_all:
+            self.MT.deselect(redraw=False)
+        self.set_refresh_timer(redraw)
         return self
 
     def all_rows_displayed(self, a: bool | None = None) -> bool:
@@ -3734,22 +3947,34 @@ class Sheet(tk.Frame):
     def set_text_editor_value(
         self,
         text: str = "",
-        r: int | None = None,
-        c: int | None = None,
     ) -> Sheet:
-        if self.MT.text_editor is not None and r is None and c is None:
-            self.MT.text_editor.set_text(text)
-        elif self.MT.text_editor is not None and self.MT.text_editor_loc == (r, c):
-            self.MT.text_editor.set_text(text)
+        if self.MT.text_editor.open:
+            self.MT.text_editor.window.set_text(text)
+        return self
+
+    def set_index_text_editor_value(
+        self,
+        text: str = "",
+    ) -> Sheet:
+        if self.RI.text_editor.open:
+            self.RI.text_editor.window.set_text(text)
+        return self
+
+    def set_header_text_editor_value(
+        self,
+        text: str = "",
+    ) -> Sheet:
+        if self.CH.text_editor.open:
+            self.CH.text_editor.window.set_text(text)
         return self
 
     def destroy_text_editor(self, event: object = None) -> Sheet:
-        self.MT.destroy_text_editor(event=event)
+        self.MT.hide_text_editor(event=event)
         return self
 
     def get_text_editor_widget(self, event: object = None) -> tk.Text | None:
         try:
-            return self.MT.text_editor.textedit
+            return self.MT.text_editor.tktext
         except Exception:
             return None
 
@@ -3761,7 +3986,7 @@ class Sheet(tk.Frame):
         if key == "all":
             for key in self.MT.text_editor_user_bound_keys:
                 try:
-                    self.MT.text_editor.textedit.unbind(key)
+                    self.MT.text_editor.tktext.unbind(key)
                 except Exception:
                     pass
             self.MT.text_editor_user_bound_keys = {}
@@ -3769,19 +3994,18 @@ class Sheet(tk.Frame):
             if key in self.MT.text_editor_user_bound_keys:
                 del self.MT.text_editor_user_bound_keys[key]
             try:
-                self.MT.text_editor.textedit.unbind(key)
+                self.MT.text_editor.tktext.unbind(key)
             except Exception:
                 pass
         return self
 
     def get_text_editor_value(self) -> str | None:
-        if self.MT.text_editor:
-            return self.MT.text_editor.get()
+        return self.MT.text_editor.get()
 
     def close_text_editor(self, set_data: bool = True) -> Sheet:
-        if self.MT.text_editor:
+        if self.MT.text_editor.open:
             event = ("ButtonPress-1",) if set_data else ("Escape",)
-            self.MT.close_text_editor(editor_info=self.MT.text_editor_loc + event)
+            self.MT.close_text_editor(editor_info=self.MT.text_editor.coords + event)
         return self
 
     # Sheet Options and Other Functions
@@ -3841,11 +4065,44 @@ class Sheet(tk.Frame):
                 highlightbackground=kwargs["outline_color"],
                 highlightcolor=kwargs["outline_color"],
             )
+        if any(k in kwargs for k in scrollbar_options_keys):
+            self.set_scrollbar_options()
         self.MT.create_rc_menus()
         self.MT.key_bindings()
         self.set_refresh_timer(redraw)
         return self
 
+    def set_scrollbar_options(self) -> Sheet:
+        style = ttk.Style()
+        for orientation in ("vertical", "horizontal"):
+            style.configure(
+                f"Sheet{self.unique_id}.{orientation.capitalize()}.TScrollbar",
+                background=self.ops[f"{orientation}_scroll_background"],
+                troughcolor=self.ops[f"{orientation}_scroll_troughcolor"],
+                lightcolor=self.ops[f"{orientation}_scroll_lightcolor"],
+                darkcolor=self.ops[f"{orientation}_scroll_darkcolor"],
+                relief=self.ops[f"{orientation}_scroll_relief"],
+                troughrelief=self.ops[f"{orientation}_scroll_troughrelief"],
+                bordercolor=self.ops[f"{orientation}_scroll_bordercolor"],
+                borderwidth=self.ops[f"{orientation}_scroll_borderwidth"],
+                gripcount=self.ops[f"{orientation}_scroll_gripcount"],
+                arrowsize=self.ops[f"{orientation}_scroll_arrowsize"],
+            )
+            style.map(
+                f"Sheet{self.unique_id}.{orientation.capitalize()}.TScrollbar",
+                foreground=[
+                    ("!active", self.ops[f"{orientation}_scroll_not_active_fg"]),
+                    ("pressed", self.ops[f"{orientation}_scroll_pressed_fg"]),
+                    ("active", self.ops[f"{orientation}_scroll_active_fg"]),
+                ],
+                background=[
+                    ("!active", self.ops[f"{orientation}_scroll_not_active_bg"]),
+                    ("pressed", self.ops[f"{orientation}_scroll_pressed_bg"]),
+                    ("active", self.ops[f"{orientation}_scroll_active_bg"]),
+                ],
+            )
+        return self
+
     def get_cell_options(
         self,
         key: None | str = None,
@@ -3946,6 +4203,570 @@ class Sheet(tk.Frame):
         self.MT.main_table_redraw_grid_and_text(redraw_header=redraw_header, redraw_row_index=redraw_row_index)
         return self
 
+    # Tags
+
+    def tag(
+        self,
+        *key: CreateSpanTypes,
+        tags: Iterator[str] | str = "",
+    ) -> Sheet:
+        span = self.span_from_key(*key)
+        rows, cols = self.ranges_from_span(span)
+        if isinstance(tags, str):
+            tags = (tags,)
+        if span.kind == "cell":
+            for tag in tags:
+                if tag not in self.MT.tagged_cells:
+                    self.MT.tagged_cells[tag] = set()
+                for r in rows:
+                    for c in cols:
+                        self.MT.tagged_cells[tag].add((r, c))
+        elif span.kind == "row":
+            for tag in tags:
+                if tag not in self.MT.tagged_rows:
+                    self.MT.tagged_rows[tag] = set()
+                self.MT.tagged_rows[tag].update(set(rows))
+        elif span.kind == "column":
+            for tag in tags:
+                if tag not in self.MT.tagged_columns:
+                    self.MT.tagged_columns[tag] = set()
+                self.MT.tagged_columns[tag].update(set(cols))
+        return self
+
+    def tag_cell(
+        self,
+        cell: tuple[int, int],
+        *tags,
+    ) -> Sheet:
+        if (
+            not isinstance(cell, tuple)
+            or not len(cell) == 2
+            or not isinstance(cell[0], int)
+            or not isinstance(cell[1], int)
+        ):
+            raise ValueError("'cell' argument must be tuple[int, int].")
+        for tag in unpack(tags):
+            if tag not in self.MT.tagged_cells:
+                self.MT.tagged_cells[tag] = set()
+            self.MT.tagged_cells[tag].add(cell)
+        return self
+
+    def tag_rows(
+        self,
+        rows: int | Iterator[int],
+        *tags,
+    ) -> Sheet:
+        if isinstance(rows, int):
+            rows = [rows]
+        for tag in unpack(tags):
+            if tag not in self.MT.tagged_rows:
+                self.MT.tagged_rows[tag] = set()
+            self.MT.tagged_rows[tag].update(rows)
+        return self
+
+    def tag_columns(
+        self,
+        columns: int | Iterator[int],
+        *tags,
+    ) -> Sheet:
+        if isinstance(columns, int):
+            columns = [columns]
+        for tag in unpack(tags):
+            if tag not in self.MT.tagged_columns:
+                self.MT.tagged_columns[tag] = set()
+            self.MT.tagged_columns[tag].update(columns)
+        return self
+
+    def untag(
+        self,
+        cell: tuple[int, int] | None = None,
+        rows: int | Iterator[int] | None = None,
+        columns: int | Iterator[int] | None = None,
+    ) -> Sheet:
+        if isinstance(cell, tuple):
+            for tagged in self.MT.tagged_cells.values():
+                tagged.discard(cell)
+        if isinstance(rows, int):
+            rows = (rows,)
+        if is_iterable(rows):
+            for tagged in self.MT.tagged_rows.values():
+                for row in rows:
+                    tagged.discard(row)
+        if isinstance(columns, int):
+            columns = (columns,)
+        if is_iterable(columns):
+            for tagged in self.MT.tagged_columns.values():
+                for column in columns:
+                    tagged.discard(column)
+        return self
+
+    def tag_del(
+        self,
+        *tags,
+        cells: bool = True,
+        rows: bool = True,
+        columns: bool = True,
+    ) -> Sheet:
+        for tag in unpack(tags):
+            if cells and tag in self.MT.tagged_cells:
+                del self.MT.tagged_cells[tag]
+            if rows and tag in self.MT.tagged_rows:
+                del self.MT.tagged_rows[tag]
+            if columns and tag in self.MT.tagged_columns:
+                del self.MT.tagged_columns[tag]
+        return self
+
+    def tag_has(
+        self,
+        *tags,
+    ) -> DotDict:
+        res = DotDict(
+            cells=set(),
+            rows=set(),
+            columns=set(),
+        )
+        for tag in unpack(tags):
+            res.cells.update(self.MT.tagged_cells[tag] if tag in self.MT.tagged_cells else set())
+            res.rows.update(self.MT.tagged_rows[tag] if tag in self.MT.tagged_rows else set())
+            res.columns.update(self.MT.tagged_columns[tag] if tag in self.MT.tagged_columns else set())
+        return res
+
+    # Treeview Mode
+
+    def tree_build(
+        self,
+        data: list[list[object]],
+        iid_column: int,
+        parent_column: int,
+    ) -> Sheet:
+        tally_of_ids = defaultdict(lambda: -1)
+        ncols = max(map(len, data), default=0)
+        for rn, row in enumerate(data):
+            if ncols > (lnr := len(row)):
+                row += self.MT.get_empty_row_seq(rn, end=ncols, start=lnr)
+            iid, pid = row[iid_column].lower(), row[parent_column].lower()
+            if not iid:
+                continue
+            tally_of_ids[iid] += 1
+            if tally_of_ids[iid] > 0:
+                x = 1
+                while iid in tally_of_ids:
+                    new = f"{row[iid_column]}_DUPLICATED_{x}"
+                    iid = new.lower()
+                    x += 1
+                tally_of_ids[iid] += 1
+                row[iid_column] = new
+            if iid not in self.RI.tree:
+                self.RI.tree[iid] = Node(row[iid_column], iid, "")
+            if iid == pid or self.RI.pid_causes_recursive_loop(iid, pid):
+                row[parent_column] = ""
+                pid = ""
+            if pid:
+                if pid not in self.RI.tree:
+                    self.RI.tree[pid] = Node(row[parent_column], pid)
+                self.RI.tree[iid].parent = self.RI.tree[pid]
+                self.RI.tree[pid].children.append(self.RI.tree[iid])
+            else:
+                self.RI.tree[iid].parent = ""
+            self.RI.tree_rns[iid] = rn
+        for n in self.RI.tree.values():
+            if n.parent is None:
+                n.parent = ""
+                newrow = self.MT.get_empty_row_seq(len(data), ncols)
+                newrow[iid_column] = n.text
+                self.RI.tree_rns[n.iid] = len(data)
+                data.append(newrow)
+        self.insert_rows(
+            idx=0,
+            rows=[[self.RI.tree[iid]] + data[self.RI.tree_rns[iid]] for iid in self.get_children()],
+            row_index=True,
+            create_selections=False,
+            fill=False,
+        )
+        self.RI.tree_rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
+        self.hide_rows(
+            set(self.RI.tree_rns[iid] for iid in self.get_children() if self.RI.tree[iid].parent),
+            deselect_all=True,
+            data_indexes=True,
+        )
+        return self
+
+    def insert(
+        self,
+        parent: str = "",
+        index: None | int | Literal["end"] = None,
+        iid: None | str = None,
+        text: None | str = None,
+        values: None | list = None,
+        create_selections: bool = False,
+    ) -> str:
+        if iid is None:
+            i = 0
+            while (iid := f"{i}") in self.RI.tree:
+                i += 1
+        iid, pid = iid.lower(), parent.lower()
+        if not iid:
+            raise ValueError("iid cannot be empty string.")
+        if iid in self.RI.tree:
+            raise ValueError(f"iid '{iid}' already exists.")
+        if iid == pid:
+            raise ValueError(f"iid '{iid}' cannot be equal to parent '{pid}'.")
+        if pid and pid not in self.RI.tree:
+            raise ValueError(f"parent '{parent}' does not exist.")
+        if text is None:
+            text = iid
+        parent_node = self.RI.tree[pid] if parent else ""
+        self.RI.tree[iid] = Node(text, iid, parent_node)
+        if self.RI.pid_causes_recursive_loop(iid, pid):
+            del self.RI.tree[iid]
+            raise ValueError(f"iid '{iid}' causes a recursive loop with parent '{parent}'.")
+        if parent_node:
+            if isinstance(index, int):
+                idx = self.RI.tree_rns[pid] + index + 1
+                for count, cid in enumerate(self.get_children(pid)):
+                    if count >= index:
+                        break
+                    idx += sum(1 for _ in self.RI.get_iid_descendants(cid))
+                self.RI.tree[pid].children.insert(index, self.RI.tree[iid])
+            else:
+                idx = self.RI.tree_rns[pid] + sum(1 for _ in self.RI.get_iid_descendants(pid)) + 1
+                self.RI.tree[pid].children.append(self.RI.tree[iid])
+        else:
+            if isinstance(index, int):
+                idx = index
+                if index:
+                    for count, cid in enumerate(self.get_children("")):
+                        if count >= index:
+                            break
+                        idx += sum(1 for _ in self.RI.get_iid_descendants(cid)) + 1
+            else:
+                idx = len(self.MT._row_index)
+        self.insert_rows(
+            idx=idx,
+            rows=[[self.RI.tree[iid]] + [] if values is None else values],
+            row_index=True,
+            create_selections=create_selections,
+            fill=False,
+        )
+        self.RI.tree_rns[iid] = idx
+        if pid and (pid not in self.RI.tree_open_ids or not self.item_displayed(pid)):
+            self.hide_rows(idx, deselect_all=False, data_indexes=True)
+        return iid
+
+    def item(
+        self,
+        item: str,
+        iid: str | None = None,
+        text: str | None = None,
+        values: list | None = None,
+        open_: bool | None = None,
+    ) -> DotDict:
+        if not (item := item.lower()) or item not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        if isinstance(iid, str):
+            if not (iid := iid.lower()):
+                raise ValueError(f"iid '{iid}' does not exist.")
+            if iid in self.RI.tree:
+                raise ValueError(f"Cannot rename '{iid}', it already exists.")
+            iid = iid.lower()
+            self.RI.tree[item].iid = iid
+            self.RI.tree[iid] = self.RI.tree.pop(item)
+            self.RI.tree_rns[iid] = self.RI.tree_rns.pop(item)
+            if iid in self.RI.tree_open_ids:
+                self.RI.tree_open_ids[iid] = self.RI.tree_open_ids.pop(item)
+        if isinstance(text, str):
+            self.RI.tree[item].text = text
+        if isinstance(values, list):
+            self.set_data(self.RI.tree_rns[item], values)
+        if isinstance(open_, bool):
+            if not self.RI.tree[item].children or not open_:
+                self.RI.tree_open_ids.discard(item)
+            if open_:
+                self.RI.tree_open_ids.add(item)
+                self.show_rows(
+                    (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
+                    redraw=False,
+                    deselect_all=False,
+                )
+            elif self.RI.tree[item].children:
+                self.hide_rows(
+                    (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item)),
+                    redraw=False,
+                    deselect_all=False,
+                    data_indexes=True,
+                )
+        self.set_refresh_timer(isinstance(text, str) or isinstance(values, list) or isinstance(open_, bool))
+        return DotDict(
+            text=self.RI.tree[item].text,
+            values=self[self.RI.tree_rns[item]].options(ndim=1).data,
+            open_=item in self.RI.tree_open_ids,
+        )
+
+    def itemrow(self, item: str) -> int:
+        return self.RI.tree_rns[item.lower()]
+
+    def rowitem(self, row: int) -> str | None:
+        if len(self.MT._row_index) > row:
+            return self.MT._row_index[row].iid
+        return None
+
+    def get_children(self, item: None | str = None) -> Generator[str]:
+        if item is None:
+            for n in self.RI.tree.values():
+                if not n.parent:
+                    yield n.iid
+                    for iid in self.RI.get_iid_descendants(n.iid):
+                        yield iid
+        elif item == "":
+            yield from (n.iid for n in self.RI.tree.values() if not n.parent)
+        else:
+            yield from (n.iid for n in self.RI.tree[item].children)
+
+    def reset_tree(self) -> Sheet:
+        self.deselect()
+        self.RI.reset_tree()
+        return self
+
+    def del_items(self, *items) -> Sheet:
+        """
+        Also deletes all descendants of items
+        """
+        rows_to_del = []
+        iids_to_del = []
+        for item in unpack(items):
+            item = item.lower()
+            if item not in self.RI.tree:
+                continue
+            rows_to_del.append(self.RI.tree_rns[item])
+            iids_to_del.append(item)
+            for did in self.RI.get_iid_descendants(item):
+                rows_to_del.append(self.RI.tree_rns[did])
+                iids_to_del.append(did)
+        for item in unpack(items):
+            self.RI.remove_node_from_parents_children(self.RI.tree[item])
+        self.del_rows(rows_to_del)
+        for iid in iids_to_del:
+            self.RI.tree_open_ids.discard(iid)
+            if self.RI.tree[iid].parent and len(self.RI.tree[iid].parent.children) == 1:
+                self.RI.tree_open_ids.discard(self.RI.tree[iid].parent.iid)
+            del self.RI.tree[iid]
+        self.set_refresh_timer(True)
+        return self
+
+    def set_children(self, item: str, *newchildren) -> Sheet:
+        """
+        Moves everything in '*newchildren' under 'item'
+        """
+        if (item := item.lower()) and item not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        mapping = {}
+        to_show = []
+        if item:
+            new_parent = self.RI.tree[item]
+            if new_parent.children:
+                ctr = self.RI.tree_rns[new_parent.children[-1].iid] + 1
+            else:
+                ctr = self.RI.tree_rns[new_parent.iid] + 1
+            for cid in unpack(newchildren):
+                if self.RI.pid_causes_recursive_loop(cid, item):
+                    raise ValueError(f"iid '{cid}' causes a recursive loop with parent '{item}'.")
+                cid_node = self.RI.tree[cid]
+                mapping[self.RI.tree_rns[cid]] = ctr
+                if item in self.RI.tree_open_ids and self.item_displayed(item):
+                    to_show.append(ctr)
+                ctr += 1
+                for did in self.RI.get_iid_descendants(cid):
+                    mapping[self.RI.tree_rns[did]] = ctr
+                    if to_show and self.RI.ancestors_all_open(did, self.RI.tree[cid].parent):
+                        to_show.append(ctr)
+                    ctr += 1
+                self.RI.remove_node_from_parents_children(cid_node)
+                cid_node.parent = new_parent
+                new_parent.children.append(cid_node)
+        else:
+            ctr = (
+                len(self.MT._row_index)
+                - len(newchildren)
+                - sum(1 for cid in unpack(newchildren) for _ in self.RI.get_iid_descendants(cid))
+            )
+            for cid in unpack(newchildren):
+                cid_node = self.RI.tree[cid]
+                mapping[self.RI.tree_rns[cid]] = ctr
+                to_show.append(ctr)
+                ctr += 1
+                for did in self.RI.get_iid_descendants(cid):
+                    mapping[self.RI.tree_rns[did]] = ctr
+                    if self.RI.ancestors_all_open(did, cid_node.parent):
+                        to_show.append(ctr)
+                    ctr += 1
+                self.RI.remove_node_from_parents_children(cid_node)
+                self.RI.tree[cid].parent = ""
+        self.mapping_move_rows(
+            data_new_idxs=mapping,
+            data_indexes=True,
+            create_selections=False,
+            redraw=False,
+        )
+        if item and (item not in self.RI.tree_open_ids or not self.item_displayed(item)):
+            self.hide_rows(set(mapping.values()), data_indexes=True)
+        self.show_rows(to_show)
+        self.set_refresh_timer(True)
+        return self
+
+    def move(self, item: str, parent: str, index: int = 0) -> Sheet:
+        """
+        Moves item to be under parent as child at index
+        'parent' can be empty string which will make item a top node
+        """
+        if (item := item.lower()) and item not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        if (parent := parent.lower()) and parent not in self.RI.tree:
+            raise ValueError(f"Parent '{parent}' does not exist.")
+        mapping = {}
+        to_show = []
+        item_node = self.RI.tree[item]
+        if parent:
+            if self.RI.pid_causes_recursive_loop(item, parent):
+                raise ValueError(f"iid '{item}' causes a recursive loop with parent '{parent}'.")
+            parent_node = self.RI.tree[parent]
+            if parent_node.children:
+                if len(parent_node.children) < index:
+                    index = len(parent_node.children)
+                ctr = self.RI.tree_rns[parent_node.children[index].iid]
+            else:
+                ctr = self.RI.tree_rns[parent_node.iid] + 1
+            mapping[self.RI.tree_rns[item]] = ctr
+            if parent in self.RI.tree_open_ids and self.item_displayed(parent):
+                to_show.append(ctr)
+            ctr += 1
+            for did in self.RI.get_iid_descendants(item):
+                mapping[self.RI.tree_rns[did]] = ctr
+                if to_show and self.RI.ancestors_all_open(did, item_node.parent):
+                    to_show.append(ctr)
+                ctr += 1
+            self.RI.remove_node_from_parents_children(item_node)
+            item_node.parent = parent_node
+            parent_node.children.append(item_node)
+        else:
+            if len(self.MT._row_index) < index:
+                index = len(self.MT._row_index)
+            ctr = index
+            mapping[self.RI.tree_rns[item]] = ctr
+            to_show.append(ctr)
+            ctr += 1
+            for did in self.RI.get_iid_descendants(item):
+                mapping[self.RI.tree_rns[did]] = ctr
+                if to_show and self.RI.ancestors_all_open(did, item_node.parent):
+                    to_show.append(ctr)
+                ctr += 1
+            self.RI.remove_node_from_parents_children(item_node)
+            self.RI.tree[item].parent = ""
+        self.mapping_move_rows(
+            data_new_idxs=mapping,
+            data_indexes=True,
+            create_selections=False,
+            redraw=False,
+        )
+        if parent and (parent not in self.RI.tree_open_ids or not self.item_displayed(parent)):
+            self.hide_rows(set(mapping.values()), data_indexes=True)
+        self.show_rows(to_show)
+        self.set_refresh_timer(True)
+        return self
+
+    reattach = move
+
+    def exists(self, item: str) -> bool:
+        return item in self.RI.tree
+
+    def parent(self, item: str) -> str:
+        if (item := item.lower()) not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        return self.RI.tree[item].parent.iid if self.RI.tree[item].parent else self.RI.tree[item].parent
+
+    def index(self, item: str) -> int:
+        if (item := item.lower()) not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        if not self.RI.tree[item].parent:
+            return sorted(self.RI.tree_rns[iid] for iid in self.get_children("")).index(self.RI.tree_rns[item])
+        return self.RI.tree[item].parent.children.index(self.RI.tree[item])
+
+    def item_displayed(self, item: str) -> bool:
+        """
+        Check if an item (row) is currently displayed on the sheet
+        - Does not check if the item is visible to the user
+        """
+        if (item := item.lower()) not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        return self.RI.tree_rns[item] in self.MT.displayed_rows
+
+    def display_item(self, item: str) -> Sheet:
+        """
+        Ensure that item is displayed in the tree
+        - Opens all of an item's ancestors
+        - Unlike the ttk treeview 'see' function
+          this function does **NOT** scroll to the item
+        """
+        if (item := item.lower()) not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        if self.RI.tree[item].parent:
+            for iid in self.RI.get_iid_ancestors(item):
+                self.item(iid, open_=True)
+
+    def scroll_to_item(self, item: str) -> Sheet:
+        """
+        Scrolls to an item and ensures that it is displayed
+        """
+        if (item := item.lower()) not in self.RI.tree:
+            raise ValueError(f"Item '{item}' does not exist.")
+        self.display_item(item)
+        self.see(row=bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]), keep_xscroll=True)
+
+    def selection(self) -> list[str]:
+        """
+        Get currently selected item ids
+        - Only includes selected rows
+        """
+        return [self.MT._row_index[self.displayed_row_to_data(rn)].iid for rn in self.get_selected_rows()]
+
+    def selection_set(self, *items) -> Sheet:
+        self.deselect()
+        self.selection_add(*items)
+        return self
+
+    def selection_add(self, *items) -> Sheet:
+        for item in unpack(items):
+            if (item := item.lower()) not in self.RI.tree:
+                raise ValueError(f"Item '{item}' does not exist.")
+            if not self.item_displayed(item):
+                self.display_item(item)
+            self.add_row_selection(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
+        return self
+
+    def selection_remove(self, *items) -> Sheet:
+        for item in unpack(items):
+            if (item := item.lower()) not in self.RI.tree:
+                raise ValueError(f"Item '{item}' does not exist.")
+            try:
+                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
+            except Exception:
+                continue
+        return self
+
+    def selection_toggle(self, *items) -> Sheet:
+        selected = set(self.MT._row_index[self.displayed_row_to_data(rn)].iid for rn in self.get_selected_rows())
+        add = []
+        remove = []
+        for item in unpack(items):
+            if (item := item.lower()) not in self.RI.tree:
+                continue
+            if item in selected:
+                remove.append(item)
+            else:
+                add.append(item)
+        self.selection_remove(*remove)
+        self.selection_add(*add)
+        return self
+
     # Functions not in docs
 
     def emit_event(
@@ -3983,10 +4804,10 @@ class Sheet(tk.Frame):
         table, index, header = span.table, span.index, span.header
         # index header
         if header and span.kind in ("cell", "column"):
-            self.CH.destroy_opened_dropdown_window()
+            self.CH.hide_dropdown_window()
             del_from_options(self.CH.cell_options, key, cols)
         if index and span.kind in ("cell", "row"):
-            self.RI.destroy_opened_dropdown_window()
+            self.RI.hide_dropdown_window()
             del_from_options(self.RI.cell_options, key, rows)
         # table
         if table and span.kind == "cell":
@@ -4001,7 +4822,7 @@ class Sheet(tk.Frame):
     #  ##########       TABLE       ##########
 
     def del_cell_options_dropdown(self, datarn: int, datacn: int) -> None:
-        self.MT.destroy_opened_dropdown_window()
+        self.MT.hide_dropdown_window()
         if (datarn, datacn) in self.MT.cell_options and "dropdown" in self.MT.cell_options[(datarn, datacn)]:
             del self.MT.cell_options[(datarn, datacn)]["dropdown"]
 
@@ -4014,7 +4835,7 @@ class Sheet(tk.Frame):
         self.del_cell_options_checkbox(datarn, datacn)
 
     def del_row_options_dropdown(self, datarn: int) -> None:
-        self.MT.destroy_opened_dropdown_window()
+        self.MT.hide_dropdown_window()
         if datarn in self.MT.row_options and "dropdown" in self.MT.row_options[datarn]:
             del self.MT.row_options[datarn]["dropdown"]
 
@@ -4027,7 +4848,7 @@ class Sheet(tk.Frame):
         self.del_row_options_checkbox(datarn)
 
     def del_column_options_dropdown(self, datacn: int) -> None:
-        self.MT.destroy_opened_dropdown_window()
+        self.MT.hide_dropdown_window()
         if datacn in self.MT.col_options and "dropdown" in self.MT.col_options[datacn]:
             del self.MT.col_options[datacn]["dropdown"]
 
@@ -4042,7 +4863,7 @@ class Sheet(tk.Frame):
     #  ##########       INDEX       ##########
 
     def del_index_cell_options_dropdown(self, datarn: int) -> None:
-        self.RI.destroy_opened_dropdown_window(datarn=datarn)
+        self.RI.hide_dropdown_window()
         if datarn in self.RI.cell_options and "dropdown" in self.RI.cell_options[datarn]:
             del self.RI.cell_options[datarn]["dropdown"]
 
@@ -4057,7 +4878,7 @@ class Sheet(tk.Frame):
     #  ##########       HEADER       ##########
 
     def del_header_cell_options_dropdown(self, datacn: int) -> None:
-        self.CH.destroy_opened_dropdown_window(datacn=datacn)
+        self.CH.hide_dropdown_window()
         if datacn in self.CH.cell_options and "dropdown" in self.CH.cell_options[datacn]:
             del self.CH.cell_options[datacn]["dropdown"]
 
@@ -4390,13 +5211,11 @@ class Sheet(tk.Frame):
 
     def dehighlight_rows(
         self,
-        rows: list | str = [],
+        rows: list[int] | Literal["all"] = [],
         redraw: bool = True,
     ) -> None:
         if isinstance(rows, int):
             rows = [rows]
-        else:
-            rows = rows
         if not rows or rows == "all":
             for r in self.MT.row_options:
                 if "highlight" in self.MT.row_options[r]:
@@ -4417,11 +5236,13 @@ class Sheet(tk.Frame):
                     pass
         self.set_refresh_timer(redraw)
 
-    def dehighlight_columns(self, columns: list | str = [], redraw: bool = True) -> None:
+    def dehighlight_columns(
+        self,
+        columns: list[int] | Literal["all"] = [],
+        redraw: bool = True,
+    ) -> None:
         if isinstance(columns, int):
             columns = [columns]
-        else:
-            columns = columns
         if not columns or columns == "all":
             for c in self.MT.col_options:
                 if "highlight" in self.MT.col_options[c]:
@@ -4444,7 +5265,7 @@ class Sheet(tk.Frame):
 
     def highlight_rows(
         self,
-        rows: list = [],
+        rows: Iterator[int] | int,
         bg: None | str = None,
         fg: None | str = None,
         highlight_index: bool = True,
@@ -4462,7 +5283,7 @@ class Sheet(tk.Frame):
 
     def highlight_columns(
         self,
-        columns: list = [],
+        columns: Iterator[int] | int,
         bg: bool | None | str = False,
         fg: bool | None | str = False,
         highlight_header: bool = True,
@@ -4924,26 +5745,17 @@ class Sheet(tk.Frame):
         return self
 
     def get_checkboxes(self) -> dict:
-        d = {
+        return {
             **{k: v["checkbox"] for k, v in self.MT.cell_options.items() if "checkbox" in v},
             **{k: v["checkbox"] for k, v in self.MT.row_options.items() if "checkbox" in v},
             **{k: v["checkbox"] for k, v in self.MT.col_options.items() if "checkbox" in v},
         }
-        if "checkbox" in self.MT.options:
-            return {**d, "checkbox": self.MT.options["checkbox"]}
-        return d
 
     def get_header_checkboxes(self) -> dict:
-        d = {k: v["checkbox"] for k, v in self.CH.cell_options.items() if "checkbox" in v}
-        if "checkbox" in self.CH.options:
-            return {**d, "checkbox": self.CH.options["checkbox"]}
-        return d
+        return {k: v["checkbox"] for k, v in self.CH.cell_options.items() if "checkbox" in v}
 
     def get_index_checkboxes(self) -> dict:
-        d = {k: v["checkbox"] for k, v in self.RI.cell_options.items() if "checkbox" in v}
-        if "checkbox" in self.RI.options:
-            return {**d, "checkbox": self.RI.options["checkbox"]}
-        return d
+        return {k: v["checkbox"] for k, v in self.RI.cell_options.items() if "checkbox" in v}
 
     def create_dropdown(
         self,
@@ -5190,9 +6002,8 @@ class Sheet(tk.Frame):
         set_value: object = None,
     ) -> Sheet:
         if set_existing_dropdown:
-            if self.MT.existing_dropdown_window is not None:
-                r_ = self.MT.existing_dropdown_window.r
-                c_ = self.MT.existing_dropdown_window.c
+            if self.MT.dropdown.open:
+                r_, c_ = self.MT.dropdown.get_coords()
             else:
                 raise Exception("No dropdown box is currently open")
         else:
@@ -5200,16 +6011,12 @@ class Sheet(tk.Frame):
             c_ = c
         kwargs = self.MT.get_cell_kwargs(r, c, key="dropdown")
         kwargs["values"] = values
-        if kwargs["window"] != "no dropdown open":
-            kwargs["window"].values(values)
+        if self.MT.dropdown.open:
+            self.MT.dropdown.window.values(values)
         if set_value is not None:
             self.set_cell_data(r_, c_, set_value)
-            if (
-                kwargs["window"] != "no dropdown open"
-                and self.MT.text_editor_loc is not None
-                and self.MT.text_editor is not None
-            ):
-                self.MT.text_editor.set_text(set_value)
+            if self.MT.dropdown.open:
+                self.MT.text_editor.window.set_text(set_value)
         return self
 
     def set_header_dropdown_values(
@@ -5220,8 +6027,8 @@ class Sheet(tk.Frame):
         set_value: object = None,
     ) -> Sheet:
         if set_existing_dropdown:
-            if self.CH.existing_dropdown_window is not None:
-                c_ = self.CH.existing_dropdown_window.c
+            if self.CH.dropdown.open:
+                c_ = self.CH.dropdown.get_coords()
             else:
                 raise Exception("No dropdown box is currently open")
         else:
@@ -5229,10 +6036,11 @@ class Sheet(tk.Frame):
         kwargs = self.CH.get_cell_kwargs(c_, key="dropdown")
         if kwargs:
             kwargs["values"] = values
-            if kwargs["window"] != "no dropdown open":
-                kwargs["window"].values(values)
+            if self.CH.dropdown.open:
+                self.CH.dropdown.window.values(values)
             if set_value is not None:
                 self.MT.headers(newheaders=set_value, index=c_)
+
         return self
 
     def set_index_dropdown_values(
@@ -5243,8 +6051,8 @@ class Sheet(tk.Frame):
         set_value: object = None,
     ) -> Sheet:
         if set_existing_dropdown:
-            if self.RI.existing_dropdown_window is not None:
-                r_ = self.RI.existing_dropdown_window.r
+            if self.RI.current_dropdown_window is not None:
+                r_ = self.RI.current_dropdown_window.r
             else:
                 raise Exception("No dropdown box is currently open")
         else:
@@ -5252,10 +6060,11 @@ class Sheet(tk.Frame):
         kwargs = self.RI.get_cell_kwargs(r_, key="dropdown")
         if kwargs:
             kwargs["values"] = values
-            if kwargs["window"] != "no dropdown open":
-                kwargs["window"].values(values)
+            if self.RI.current_dropdown_window is not None:
+                self.RI.current_dropdown_window.values(values)
             if set_value is not None:
                 self.MT.row_index(newindex=set_value, index=r_)
+                # here
         return self
 
     def get_dropdown_values(self, r: int = 0, c: int = 0) -> None | list:
@@ -5469,7 +6278,7 @@ class Dropdown(Sheet):
         parent: tk.Misc,
         r: int,
         c: int,
-        colors: dict[str, str],
+        ops: dict,
         outline_color: str,
         width: int | None = None,
         height: int | None = None,
@@ -5481,7 +6290,9 @@ class Dropdown(Sheet):
         arrowkey_RIGHT: Callable | None = None,
         arrowkey_LEFT: Callable | None = None,
         align: str = "w",
-        # False for using r, c "r" for r "c" for c
+        # False for using r, c
+        # "r" for r
+        # "c" for c
         single_index: str | bool = False,
     ) -> None:
         Sheet.__init__(
@@ -5489,7 +6300,7 @@ class Dropdown(Sheet):
             parent=parent,
             outline_thickness=outline_thickness,
             outline_color=outline_color,
-            table_grid_fg=colors["fg"],
+            table_grid_fg=ops.popup_menu_fg,
             show_horizontal_grid=True,
             show_vertical_grid=False,
             show_header=False,
@@ -5503,24 +6314,23 @@ class Dropdown(Sheet):
             horizontal_grid_to_end_of_window=True,
             set_cell_sizes_on_zoom=True,
             show_selected_cells_border=False,
-            table_selected_cells_border_fg=colors["fg"],
-            table_selected_cells_bg=colors["highlight_bg"],
-            table_selected_rows_border_fg=colors["fg"],
-            table_selected_rows_bg=colors["highlight_bg"],
-            table_selected_rows_fg=colors["highlight_fg"],
+            table_selected_cells_border_fg=ops.popup_menu_fg,
+            table_selected_cells_bg=ops.popup_menu_highlight_bg,
+            table_selected_rows_border_fg=ops.popup_menu_fg,
+            table_selected_rows_bg=ops.popup_menu_highlight_bg,
+            table_selected_rows_fg=ops.popup_menu_highlight_fg,
             width=width,
             height=height,
             font=font if font else self.ops.table_font,
-            table_fg=colors["fg"],
-            table_bg=colors["bg"],
+            table_fg=ops.popup_menu_fg,
+            table_bg=ops.popup_menu_bg,
+            **{k: ops[k] for k in scrollbar_options_keys},
         )
         self.parent = parent
         self.close_dropdown_window = close_dropdown_window
         self.search_function = search_function
         self.arrowkey_RIGHT = arrowkey_RIGHT
         self.arrowkey_LEFT = arrowkey_LEFT
-        self.h_ = height
-        self.w_ = width
         self.r = r
         self.c = c
         self.row = -1
@@ -5599,6 +6409,13 @@ class Dropdown(Sheet):
             else:
                 self.close_dropdown_window(self.r, self.c, self.get_cell_data(row, 0))
 
+    def get_coords(self) -> int | tuple[int, int]:
+        if self.single_index == "r":
+            return self.r
+        elif self.single_index == "c":
+            return self.c
+        return self.r, self.c
+
     def values(self, values: list = [], redraw: bool = True) -> None:
         self.set_sheet_data(
             [[v] for v in values],