tksheet 7.2.3__tar.gz → 7.2.5__tar.gz

{tksheet-7.2.3/tksheet.egg-info → tksheet-7.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.3
+Version: 7.2.5
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 
 <p align="center" width="100%">
-    <img width="33%" src="https://github.com/ragardner/tksheet/assets/26602401/4124c3ce-cf62-4925-9158-c5bdf712765b"> 
+    <img width="33%" src="https://github.com/ragardner/tksheet/assets/26602401/4124c3ce-cf62-4925-9158-c5bdf712765b">
 </p>
 
 # <div align="center">tksheet - python tkinter table widget</div>
@@ -82,7 +82,7 @@ This library is maintained with the help of **[others](https://github.com/ragard
 - Expand row heights and column widths
 - Change fonts and font size (not for individual cells)
 - Change any colors in the sheet
-- Create an unlimited number of high performance dropdown and check boxes
+- Dropdowns, check boxes, progress bars
 - [Hide rows and/or columns](https://github.com/ragardner/tksheet/wiki/Version-7#example-header-dropdown-boxes-and-row-filtering)
 - Left `"w"`, Center `"center"` or Right `"e"` text alignment for any cell/row/column
 

{tksheet-7.2.3 → tksheet-7.2.5}/README.md

@@ -1,5 +1,5 @@
 <p align="center" width="100%">
-    <img width="33%" src="https://github.com/ragardner/tksheet/assets/26602401/4124c3ce-cf62-4925-9158-c5bdf712765b"> 
+    <img width="33%" src="https://github.com/ragardner/tksheet/assets/26602401/4124c3ce-cf62-4925-9158-c5bdf712765b">
 </p>
 
 # <div align="center">tksheet - python tkinter table widget</div>
@@ -40,7 +40,7 @@ This library is maintained with the help of **[others](https://github.com/ragard
 - Expand row heights and column widths
 - Change fonts and font size (not for individual cells)
 - Change any colors in the sheet
-- Create an unlimited number of high performance dropdown and check boxes
+- Dropdowns, check boxes, progress bars
 - [Hide rows and/or columns](https://github.com/ragardner/tksheet/wiki/Version-7#example-header-dropdown-boxes-and-row-filtering)
 - Left `"w"`, Center `"center"` or Right `"e"` text alignment for any cell/row/column
 

{tksheet-7.2.3 → tksheet-7.2.5}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet widget"
 readme = "README.md"
-version = "7.2.3"
+version = "7.2.5"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.2.3"
+__version__ = "7.2.5"
 
 from .colors import (
     color_map,
@@ -53,6 +53,7 @@ from .functions import (
     get_new_indexes,
     get_seq_without_gaps_at_index,
     insert_items,
+    is_contiguous,
     is_iterable,
     move_elements_by_mapping,
     move_elements_to,

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/column_headers.py

@@ -1440,7 +1440,7 @@ class ColumnHeaders(tk.Canvas):
             ]
             for c in range(grid_start_col, grid_end_col):
                 draw_x = self.MT.col_positions[c]
-                if self.width_resizing_enabled:
+                if c and self.width_resizing_enabled:
                     self.visible_col_dividers[c] = (draw_x - 2, 1, draw_x + 2, yend)
                 points.extend(
                     (

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/functions.py

@@ -412,8 +412,8 @@ def consecutive_ranges(seq: Sequence[int]) -> Generator[tuple[int, int]]:
             yield seq[start], seq[-1] + 1
 
 
-def is_contiguous(seq: list[int]) -> bool:
-    itr = iter(seq)
+def is_contiguous(iterable: Iterator[int]) -> bool:
+    itr = iter(iterable)
     prev = next(itr)
     return all(i == (prev := prev + 1) for i in itr)
 
@@ -485,7 +485,6 @@ def move_elements_to(
     return move_elements_by_mapping(
         seq,
         *get_new_indexes(
-            len(seq),
             move_to,
             to_move,
             get_inverse=True,
@@ -494,19 +493,15 @@ def move_elements_to(
 
 
 def get_new_indexes(
-    seqlen: int,
     move_to: int,
     to_move: list[int],
-    keep_len: bool = True,
     get_inverse: bool = False,
 ) -> tuple[dict]:
-    # returns
-    # {old idx: new idx, ...}
-    offset = len(to_move) - 1
-    if move_to <= to_move[0]:
-        new_idxs = range(move_to, move_to + len(to_move))
-    else:
-        new_idxs = range(move_to - offset, move_to - offset + len(to_move))
+    """
+    returns {old idx: new idx, ...}
+    """
+    offset = sum(1 for i in to_move if i < move_to)
+    new_idxs = range(move_to - offset, move_to - offset + len(to_move))
     new_idxs = {old: new for old, new in zip(to_move, new_idxs)}
     if get_inverse:
         return new_idxs, dict(zip(new_idxs.values(), new_idxs))

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/main_table.py

@@ -84,6 +84,7 @@ from .other_classes import (
     EventDataDict,
     FontTuple,
     Loc,
+    ProgressBar,
     Selected,
     SelectionBox,
     TextEditorStorage,
@@ -165,6 +166,7 @@ class MainTable(tk.Canvas):
         self.col_options = {}
         self.row_options = {}
         self.purge_undo_and_redo_stack()
+        self.progress_bars = {}
 
         self.extra_table_rc_menu_funcs = {}
         self.extra_index_rc_menu_funcs = {}
@@ -994,18 +996,15 @@ 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(
-                seqlen=len(self.col_positions) - 1,
-                move_to=move_to,
-                to_move=to_move,
-            )
+            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         else:
             disp_new_idxs = {}
-        totalcols = self.equalize_data_row_lengths(at_least_cols=move_to + 1)
-        if self.all_columns_displayed or data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=totalcols, move_to=move_to, to_move=to_move)
-        elif not self.all_columns_displayed and not data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=len(self.displayed_columns), move_to=move_to, to_move=to_move)
+        if not self.all_columns_displayed and not data_indexes:
+            totalcols = self.equalize_data_row_lengths(at_least_cols=self.datacn(move_to) + 1)
+        else:
+            totalcols = self.equalize_data_row_lengths(at_least_cols=move_to + 1)
+        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+        if not self.all_columns_displayed and not data_indexes:
             moved = {self.displayed_columns[i] for i in to_move}
             data_new_idxs = dict(
                 filter(
@@ -1102,6 +1101,7 @@ class MainTable(tk.Canvas):
                 tags: {(k[0], full_new_idxs[k[1]]) for k in tagged} for tags, tagged in self.tagged_cells.items()
             }
             self.cell_options = {(k[0], full_new_idxs[k[1]]): v for k, v in self.cell_options.items()}
+            self.progress_bars = {(k[0], full_new_idxs[k[1]]): v for k, v in self.progress_bars.items()}
             self.col_options = {full_new_idxs[k]: v for k, v in self.col_options.items()}
             self.tagged_columns = {
                 tags: {full_new_idxs[k] for k in tagged} for tags, tagged in self.tagged_columns.items()
@@ -1230,22 +1230,13 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
     ) -> tuple[dict[int, int], dict[int, int], int, dict[int, int]]:
         if not data_indexes or self.all_rows_displayed:
-            disp_new_idxs = get_new_indexes(
-                seqlen=len(self.row_positions) - 1,
-                move_to=move_to,
-                to_move=to_move,
-            )
+            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         else:
             disp_new_idxs = {}
-        self.fix_data_len(move_to)
-        totalrows = max(
-            self.total_data_rows(),
-            len(self.row_positions) - 1,
-        )
-        if self.all_rows_displayed or data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=totalrows, move_to=move_to, to_move=to_move)
-        elif not self.all_rows_displayed and not data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=len(self.displayed_rows), move_to=move_to, to_move=to_move)
+        self.fix_data_len(self.datarn(move_to) if not self.all_rows_displayed and not data_indexes else move_to)
+        totalrows = max(self.total_data_rows(), len(self.row_positions) - 1)
+        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+        if not self.all_rows_displayed and not data_indexes:
             moved = {self.displayed_rows[i] for i in to_move}
             data_new_idxs = dict(
                 filter(
@@ -1281,7 +1272,7 @@ class MainTable(tk.Canvas):
                 len(self.row_positions) - 1,
                 max(data_new_idxs.values(), default=0),
             )
-            self.fix_data_len(totalrows)
+            self.fix_data_len(totalrows - 1)
         if event_data is None:
             event_data = event_dict(
                 name="move_rows",
@@ -1341,6 +1332,7 @@ class MainTable(tk.Canvas):
                 tags: {(full_new_idxs[k[0]], k[1]) for k in tagged} for tags, tagged in self.tagged_cells.items()
             }
             self.cell_options = {(full_new_idxs[k[0]], k[1]): v for k, v in self.cell_options.items()}
+            self.progress_bars = {(full_new_idxs[k[0]], k[1]): v for k, v in self.progress_bars.items()}
             self.tagged_rows = {tags: {full_new_idxs[k] for k in tagged} for tags, tagged in self.tagged_rows.items()}
             self.row_options = {full_new_idxs[k]: v for k, v in self.row_options.items()}
             self.RI.cell_options = {full_new_idxs[k]: v for k, v in self.RI.cell_options.items()}
@@ -3981,6 +3973,9 @@ class MainTable(tk.Canvas):
         self.cell_options = {
             (r, c if not (num := bisect_right(cols, c)) else c + num): v for (r, c), v in self.cell_options.items()
         }
+        self.progress_bars = {
+            (r, c if not (num := bisect_right(cols, c)) else c + num): v for (r, c), v in self.progress_bars.items()
+        }
         self.tagged_columns = {
             tags: {c if not (num := bisect_right(cols, c)) else c + num for c in tagged}
             for tags, tagged in self.tagged_columns.items()
@@ -4050,6 +4045,9 @@ class MainTable(tk.Canvas):
         self.cell_options = {
             (r if not (num := bisect_right(rows, r)) else r + num, c): v for (r, c), v in self.cell_options.items()
         }
+        self.progress_bars = {
+            (r if not (num := bisect_right(rows, r)) else r + num, c): v for (r, c), v in self.progress_bars.items()
+        }
         self.tagged_rows = {
             tags: {r if not (num := bisect_right(rows, r)) else r + num for r in tagged}
             for tags, tagged in self.tagged_rows.items()
@@ -4139,6 +4137,14 @@ class MainTable(tk.Canvas):
             for (r, c), v in self.cell_options.items()
             if c not in to_del
         }
+        self.progress_bars = {
+            (
+                r,
+                c if not (num := bisect_left(to_bis, c)) else c - num,
+            ): v
+            for (r, c), v in self.progress_bars.items()
+            if c not in to_del
+        }
         self.tagged_columns = {
             tags: {c if not (num := bisect_left(to_bis, c)) else c - num for c in tagged if c not in to_del}
             for tags, tagged in self.tagged_columns.items()
@@ -4219,6 +4225,14 @@ class MainTable(tk.Canvas):
             for (r, c), v in self.cell_options.items()
             if r not in to_del
         }
+        self.progress_bars = {
+            (
+                r if not (num := bisect_left(to_bis, r)) else r - num,
+                c,
+            ): v
+            for (r, c), v in self.progress_bars.items()
+            if r not in to_del
+        }
         self.tagged_rows = {
             tags: {r if not (num := bisect_left(to_bis, r)) else r - num for r in tagged if r not in to_del}
             for tags, tagged in self.tagged_rows.items()
@@ -4347,7 +4361,7 @@ class MainTable(tk.Canvas):
                 create_ops=create_ops,
             )
         if create_selections:
-            self.deselect("all")
+            self.deselect("all", redraw=False)
             for boxst, boxend in consecutive_ranges(tuple(reversed(column_widths))):
                 self.create_selection_box(
                     0,
@@ -4491,7 +4505,7 @@ class MainTable(tk.Canvas):
                 create_ops=create_ops,
             )
         if create_selections:
-            self.deselect("all")
+            self.deselect("all", redraw=False)
             for boxst, boxend in consecutive_ranges(tuple(reversed(row_heights))):
                 self.create_selection_box(
                     boxst,
@@ -5059,7 +5073,10 @@ class MainTable(tk.Canvas):
         can_width: int | None,
     ) -> str:
         redrawn = False
-        kwargs = self.get_cell_kwargs(datarn, datacn, key="highlight")
+        if (datarn, datacn) in self.progress_bars:
+            kwargs = self.progress_bars[(datarn, datacn)]
+        else:
+            kwargs = self.get_cell_kwargs(datarn, datacn, key="highlight")
         if kwargs:
             if kwargs[0] is not None:
                 c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
@@ -5104,11 +5121,12 @@ class MainTable(tk.Canvas):
                 if kwargs[0] is not None:
                     fill = kwargs[0]
             if kwargs[0] is not None:
-                redrawn = self.redraw_highlight(
-                    fc + 1,
-                    fr + 1,
-                    sc,
-                    sr,
+                highlight_fn = partial(
+                    self.redraw_highlight,
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
                     fill=fill,
                     outline=(
                         self.PAR.ops.table_fg
@@ -5116,8 +5134,20 @@ class MainTable(tk.Canvas):
                         else ""
                     ),
                     tag="hi",
-                    can_width=can_width if (len(kwargs) > 2 and kwargs[2]) else None,
                 )
+                if isinstance(kwargs, ProgressBar):
+                    if kwargs.del_when_done and kwargs.percent >= 100:
+                        del self.progress_bars[(datarn, datacn)]
+                    else:
+                        redrawn = highlight_fn(
+                            can_width=None,
+                            pc=kwargs.percent,
+                        )
+                else:
+                    redrawn = highlight_fn(
+                        can_width=can_width if (len(kwargs) > 2 and kwargs[2]) else None,
+                        pc=None,
+                    )
         elif not kwargs:
             if "cells" in selections and (r, c) in selections["cells"]:
                 tf = self.PAR.ops.table_selected_cells_fg
@@ -5130,13 +5160,15 @@ class MainTable(tk.Canvas):
         return tf, redrawn
 
     def redraw_highlight(self, x1, y1, x2, y2, fill, outline, tag, can_width=None, pc=None):
-        if not is_type_int(pc) or pc >= 100 or pc <= 0:
+        if not is_type_int(pc) or pc >= 100:
             coords = (
                 x1 - 1 if outline else x1,
                 y1 - 1 if outline else y1,
                 x2 if can_width is None else x2 + can_width,
                 y2,
             )
+        elif pc <= 0:
+            coords = (x1, y1, x1, y2)
         else:
             coords = (x1, y1, (x2 - x1) * (pc / 100), y2)
         if self.hidd_high:
@@ -6334,6 +6366,18 @@ class MainTable(tk.Canvas):
             for c in range(box.coords.from_c, box.coords.upto_c)
         }
 
+    def gen_selected_cells(
+        self,
+        get_rows: bool = False,
+        get_cols: bool = False,
+    ) -> Generator[tuple[int, int]]:
+        yield from (
+            (r, c)
+            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols)
+            for r in range(box.coords.from_r, box.coords.upto_r)
+            for c in range(box.coords.from_c, box.coords.upto_c)
+        )
+
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
         return tuple(box.coords for item, box in self.get_selection_items())
 

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/other_classes.py

@@ -36,7 +36,6 @@ Highlight = namedtuple(
 DrawnItem = namedtuple("DrawnItem", "iid showing")
 TextCfg = namedtuple("TextCfg", "txt tf font align")
 DraggedRowColumn = namedtuple("DraggedRowColumn", "dragged to_move")
-ProgressBar = namedtuple("ProgressBar", "bg fg pc name")
 
 
 def num2alpha(n: int) -> str | None:
@@ -470,3 +469,31 @@ Selected = namedtuple(
         None,
     ),
 )
+
+
+class ProgressBar:
+    __slots__ = ("bg", "fg", "name", "percent", "del_when_done")
+
+    def __init__(self, bg: str, fg: str, name: Hashable, percent: int, del_when_done: bool) -> None:
+        self.bg = bg
+        self.fg = fg
+        self.name = name
+        self.percent = percent
+        self.del_when_done = del_when_done
+
+    def __len__(self):
+        return 2
+
+    def __getitem__(self, key: Hashable) -> object:
+        if key == 0:
+            return self.bg
+        elif key == 1:
+            return self.fg
+        elif key == 2:
+            return self.name
+        elif key == 3:
+            return self.percent
+        elif key == 4:
+            return self.del_when_done
+        else:
+            return self.__getattribute__(key)

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/row_index.py

@@ -1539,7 +1539,7 @@ class RowIndex(tk.Canvas):
             ]
             for r in range(grid_start_row, grid_end_row):
                 draw_y = self.MT.row_positions[r]
-                if self.height_resizing_enabled:
+                if r and self.height_resizing_enabled:
                     self.visible_row_dividers[r] = (1, draw_y - 2, xend, draw_y + 2)
                 points.extend(
                     (
@@ -2488,6 +2488,14 @@ class RowIndex(tk.Canvas):
             ):
                 yield from self.get_iid_descendants(cnode.iid, check_open)
 
+    def items_parent(self, iid: str) -> str:
+        if self.tree[iid].parent:
+            return self.tree[iid].parent.iid
+        return ""
+
+    def gen_top_nodes(self) -> Generator[Node]:
+        yield from (node for node in self.MT._row_index if node.parent == "")
+
     def get_treeview_indent(self, iid: str) -> int:
         if isinstance(self.PAR.ops.treeview_indent, str):
             indent = self.MT.index_txt_width * int(self.PAR.ops.treeview_indent)

{tksheet-7.2.3 → tksheet-7.2.5}/tksheet/sheet.py

@@ -3,7 +3,13 @@ from __future__ import annotations
 import tkinter as tk
 from bisect import bisect_left
 from collections import defaultdict, deque
-from collections.abc import Callable, Generator, Iterator, Sequence
+from collections.abc import (
+    Callable,
+    Generator,
+    Hashable,
+    Iterator,
+    Sequence,
+)
 from itertools import accumulate, chain, islice, product, repeat
 from timeit import default_timer
 from tkinter import ttk
@@ -13,6 +19,7 @@ from .column_headers import ColumnHeaders
 from .functions import (
     add_highlight,
     add_to_options,
+    consecutive_ranges,
     convert_align,
     data_to_displayed_idxs,
     del_from_options,
@@ -47,6 +54,7 @@ from .other_classes import (
     FontTuple,
     GeneratedMouseEvent,
     Node,
+    ProgressBar,
     Selected,
     SelectionBox,
     Span,
@@ -2433,23 +2441,29 @@ class Sheet(tk.Frame):
             include_header=include_header,
         )
 
-    def full_move_rows_idxs(self, data_idxs: dict[int, int]) -> dict[int, int]:
+    def full_move_rows_idxs(self, data_idxs: dict[int, int], max_idx: int | None = None) -> dict[int, int]:
         """
         Converts the dict provided by moving rows event data
         Under the keys ['moved']['rows']['data']
         Into a dict of {old index: new index} for every row
         Includes row numbers in cell options, spans, etc.
         """
-        return self.MT.get_full_new_idxs(self.MT.get_max_row_idx(), data_idxs)
+        return self.MT.get_full_new_idxs(
+            self.MT.get_max_row_idx() if max_idx is None else max_idx,
+            data_idxs,
+        )
 
-    def full_move_columns_idxs(self, data_idxs: dict[int, int]) -> dict[int, int]:
+    def full_move_columns_idxs(self, data_idxs: dict[int, int], max_idx: int | None = None) -> dict[int, int]:
         """
         Converts the dict provided by moving columns event data
         Under the keys ['moved']['columns']['data']
         Into a dict of {old index: new index} for every column
         Includes column numbers in cell options, spans, etc.
         """
-        return self.MT.get_full_new_idxs(self.MT.get_max_column_idx(), data_idxs)
+        return self.MT.get_full_new_idxs(
+            self.MT.get_max_column_idx() if max_idx is None else max_idx,
+            data_idxs,
+        )
 
     # Highlighting Cells
 
@@ -2998,8 +3012,8 @@ class Sheet(tk.Frame):
                 box=selected[3],
             )
         else:
-            self.MT.deselect()
-        return self
+            self.MT.deselect(redraw=False)
+        return self.set_refresh_timer()
 
     def get_selected_rows(
         self,
@@ -3046,6 +3060,13 @@ class Sheet(tk.Frame):
             )
         return self.MT.get_selected_cells(get_rows=get_rows, get_cols=get_columns)
 
+    def gen_selected_cells(
+        self,
+        get_rows: bool = False,
+        get_columns: bool = False,
+    ) -> Generator[tuple[int, int]]:
+        yield from self.MT.gen_selected_cells(get_rows=get_rows, get_cols=get_columns)
+
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
         return self.MT.get_all_selection_boxes()
 
@@ -3058,11 +3079,11 @@ class Sheet(tk.Frame):
 
     @boxes.setter
     def boxes(self, boxes: Sequence[tuple[tuple[int, int, int, int], str]]) -> Sheet:
-        self.MT.deselect()
+        self.MT.deselect(redraw=False)
         self.MT.reselect_from_get_boxes(
             boxes={box[0] if isinstance(box[0], tuple) else tuple(box[0]): box[1] for box in boxes}
         )
-        return self
+        return self.set_refresh_timer()
 
     @property
     def canvas_boxes(self) -> dict[int, SelectionBox]:
@@ -4445,6 +4466,60 @@ class Sheet(tk.Frame):
 
     refresh = redraw
 
+    # Progress Bars
+
+    def create_progress_bar(
+        self,
+        row: int,
+        column: int,
+        bg: str,
+        fg: str,
+        name: Hashable,
+        percent: int = 0,
+        del_when_done: bool = False,
+    ) -> Sheet:
+        self.MT.progress_bars[(row, column)] = ProgressBar(
+            bg=bg,
+            fg=fg,
+            name=name,
+            percent=percent,
+            del_when_done=del_when_done,
+        )
+        return self.set_refresh_timer()
+
+    def progress_bar(
+        self,
+        name: Hashable | None = None,
+        cell: tuple[int, int] | None = None,
+        percent: int | None = None,
+        bg: str | None = None,
+        fg: str | None = None,
+    ) -> Sheet:
+        if name is not None:
+            bars = (bar for bar in self.MT.progress_bars.values() if bar.name == name)
+        elif cell is not None:
+            bars = (self.MT.progress_bars[cell],)
+        for bar in bars:
+            if isinstance(percent, int):
+                bar.percent = percent
+            if isinstance(bg, str):
+                bar.bg = bg
+            if isinstance(fg, str):
+                bar.fg = fg
+        return self.set_refresh_timer()
+
+    def del_progress_bar(
+        self,
+        name: Hashable | None = None,
+        cell: tuple[int, int] | None = None,
+    ) -> Sheet:
+        if name is not None:
+            for cell in tuple(cell for cell, bar in self.MT.progress_bars.items() if bar.name == name):
+                del self.MT.progress_bars[cell]
+        elif cell is not None:
+            del self.MT.progress_bars[cell]
+        return self.set_refresh_timer()
+
     # Tags
 
     def tag(
@@ -4639,6 +4714,7 @@ class Sheet(tk.Frame):
             create_selections=False,
             fill=False,
             push_ops=push_ops,
+            redraw=False,
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
@@ -4679,13 +4755,12 @@ class Sheet(tk.Frame):
         open_ids = set(filter(self.exists, map(str.lower, open_ids)))
         self.RI.tree_open_ids = set()
         if open_ids:
-            to_open = self._tree_open(open_ids)
             self.show_rows(
-                rows=to_open,
+                rows=self._tree_open(open_ids),
                 redraw=False,
                 deselect_all=False,
             )
-        return self.set_refresh_timer(True)
+        return self.set_refresh_timer()
 
     def _tree_open(self, items: set[str]) -> list[int]:
         """
@@ -4920,8 +4995,7 @@ class Sheet(tk.Frame):
             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
+        return self.set_refresh_timer()
 
     def set_children(self, parent: str, *newchildren) -> Sheet:
         """
@@ -4931,13 +5005,11 @@ class Sheet(tk.Frame):
             self.move(iid, parent)
         return self
 
-    def find_rn_at_top_index(self, index: int) -> int:
-        wo_par = 0
-        for rn, n in enumerate(self.MT._row_index):
-            if not n.parent:
-                if wo_par == index:
-                    return rn
-                wo_par += 1
+    def top_index_row(self, index: int) -> int:
+        try:
+            return next(self.RI.tree_rns[n.iid] for i, n in enumerate(self.RI.gen_top_nodes()) if i == index)
+        except Exception:
+            return None
 
     def move(self, item: str, parent: str, index: int | None = None) -> Sheet:
         """
@@ -4960,8 +5032,6 @@ class Sheet(tk.Frame):
                     index = len(parent_node.children) - 1
                 item_r = self.RI.tree_rns[item]
                 new_r = self.RI.tree_rns[parent_node.children[index].iid]
-                if item_node not in parent_node.children:
-                    new_r += 1
                 new_r_desc = sum(1 for _ in self.RI.get_iid_descendants(parent_node.children[index].iid))
                 item_desc = sum(1 for _ in self.RI.get_iid_descendants(item))
                 if item_r < new_r:
@@ -4969,6 +5039,8 @@ class Sheet(tk.Frame):
                 else:
                     r_ctr = new_r
             else:
+                if index is None:
+                    index = 0
                 r_ctr = self.RI.tree_rns[parent_node.iid] + 1
             mapping[item_r] = r_ctr
             if parent in self.RI.tree_open_ids and self.item_displayed(parent):
@@ -4979,11 +5051,19 @@ class Sheet(tk.Frame):
                 if to_show and self.RI.ancestors_all_open(did, item_node.parent):
                     to_show.append(r_ctr)
                 r_ctr += 1
-            self.RI.remove_node_from_parents_children(item_node)
-            item_node.parent = parent_node
-            parent_node.children.append(item_node)
+            if parent == self.RI.items_parent(item):
+                pop_index = parent_node.children.index(item_node)
+                parent_node.children.insert(index, parent_node.children.pop(pop_index))
+            else:
+                self.RI.remove_node_from_parents_children(item_node)
+                item_node.parent = parent_node
+                parent_node.children.insert(index, item_node)
         else:
-            new_r = self.find_rn_at_top_index((sum(1 for _ in self.get_children("")) - 1) if index is None else index)
+            if index is None:
+                new_r = self.top_index_row((sum(1 for _ in self.RI.gen_top_nodes()) - 1))
+            else:
+                if (new_r := self.top_index_row(index)) is None:
+                    new_r = self.top_index_row((sum(1 for _ in self.RI.gen_top_nodes()) - 1))
             item_r = self.RI.tree_rns[item]
             if item_r < new_r:
                 par_desc = sum(1 for _ in self.RI.get_iid_descendants(self.rowitem(new_r, data_index=True)))
@@ -5010,8 +5090,7 @@ class Sheet(tk.Frame):
         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
+        return self.set_refresh_timer()
 
     reattach = move
 
@@ -5027,7 +5106,7 @@ class Sheet(tk.Frame):
         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 next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == self.RI.tree[item])
         return self.RI.tree[item].parent.children.index(self.RI.tree[item])
 
     def item_displayed(self, item: str) -> bool:
@@ -5039,7 +5118,7 @@ class Sheet(tk.Frame):
             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:
+    def display_item(self, item: str, redraw=False) -> Sheet:
         """
         Ensure that item is displayed in the tree
         - Opens all of an item's ancestors
@@ -5050,16 +5129,22 @@ class Sheet(tk.Frame):
             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)
+                self.item(iid, open_=True, redraw=False)
+        return self.set_refresh_timer(redraw)
 
-    def scroll_to_item(self, item: str) -> Sheet:
+    def scroll_to_item(self, item: str, redraw=False) -> 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)
+        self.display_item(item, redraw=False)
+        self.see(
+            row=bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]),
+            keep_xscroll=True,
+            redraw=False,
+        )
+        return self.set_refresh_timer(redraw)
 
     def selection(self, cells: bool = False) -> list[str]:
         """
@@ -5070,45 +5155,68 @@ class Sheet(tk.Frame):
             for rn in self.get_selected_rows(get_cells_as_rows=cells)
         ]
 
-    def selection_set(self, *items) -> Sheet:
+    def selection_set(self, *items, redraw: bool = True) -> Sheet:
         if any(item.lower() in self.RI.tree for item in unpack(items)):
-            self.deselect()
-            self.selection_add(*items)
-        return self
+            self.deselect(redraw=False)
+            self.selection_add(*items, redraw=False)
+        return self.set_refresh_timer(redraw)
 
-    def selection_add(self, *items) -> Sheet:
+    def selection_add(self, *items, redraw: bool = True) -> Sheet:
+        to_open = []
+        quick_displayed_check = set(self.MT.displayed_rows)
         for item in unpack(items):
-            if (item := item.lower()) not in self.RI.tree:
-                continue
-            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
+            if self.RI.tree_rns[(item := item.lower())] not in quick_displayed_check and self.RI.tree[item].parent:
+                to_open.extend(list(self.RI.get_iid_ancestors(item)))
+        if to_open:
+            self.show_rows(
+                rows=self._tree_open(to_open),
+                redraw=False,
+                deselect_all=False,
+            )
+        for startr, endr in consecutive_ranges(
+            sorted(
+                bisect_left(
+                    self.MT.displayed_rows,
+                    self.RI.tree_rns[item.lower()],
+                )
+                for item in unpack(items)
+            )
+        ):
+            self.MT.create_selection_box(
+                startr,
+                0,
+                endr,
+                len(self.MT.col_positions) - 1,
+                "rows",
+                set_current=True,
+                ext=True,
+            )
+        self.MT.run_selection_binding("rows")
+        return self.set_refresh_timer(redraw)
 
-    def selection_remove(self, *items) -> Sheet:
+    def selection_remove(self, *items, redraw: bool = True) -> Sheet:
         for item in unpack(items):
             if (item := item.lower()) not in self.RI.tree:
                 continue
             try:
-                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
+                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]), redraw=False)
             except Exception:
                 continue
-        return self
+        return self.set_refresh_timer(redraw)
 
-    def selection_toggle(self, *items) -> Sheet:
+    def selection_toggle(self, *items, redraw: bool = True) -> 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
+            if (item := item.lower()) in self.RI.tree:
+                if item in selected:
+                    remove.append(item)
+                else:
+                    add.append(item)
+        self.selection_remove(*remove, redraw=False)
+        self.selection_add(*add, redraw=False)
+        return self.set_refresh_timer(redraw)
 
     # Functions not in docs
 

{tksheet-7.2.3 → tksheet-7.2.5/tksheet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.3
+Version: 7.2.5
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 
 <p align="center" width="100%">
-    <img width="33%" src="https://github.com/ragardner/tksheet/assets/26602401/4124c3ce-cf62-4925-9158-c5bdf712765b"> 
+    <img width="33%" src="https://github.com/ragardner/tksheet/assets/26602401/4124c3ce-cf62-4925-9158-c5bdf712765b">
 </p>
 
 # <div align="center">tksheet - python tkinter table widget</div>
@@ -82,7 +82,7 @@ This library is maintained with the help of **[others](https://github.com/ragard
 - Expand row heights and column widths
 - Change fonts and font size (not for individual cells)
 - Change any colors in the sheet
-- Create an unlimited number of high performance dropdown and check boxes
+- Dropdowns, check boxes, progress bars
 - [Hide rows and/or columns](https://github.com/ragardner/tksheet/wiki/Version-7#example-header-dropdown-boxes-and-row-filtering)
 - Left `"w"`, Center `"center"` or Right `"e"` text alignment for any cell/row/column