tksheet 7.2.2__tar.gz → 7.2.4__tar.gz

{tksheet-7.2.2/tksheet.egg-info → tksheet-7.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.2
+Version: 7.2.4
 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.2 → tksheet-7.2.4}/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.2 → tksheet-7.2.4}/pyproject.toml

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

{tksheet-7.2.2 → tksheet-7.2.4}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.2.2"
+__version__ = "7.2.4"
 
 from .colors import (
     color_map,

{tksheet-7.2.2 → tksheet-7.2.4}/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.2 → tksheet-7.2.4}/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 = {}
@@ -852,6 +854,7 @@ class MainTable(tk.Canvas):
                     index=index,
                     row_heights=row_heights,
                     event_data=event_data,
+                    mod_event_boxes=False,
                 )
         if added_cols:
             ctr = 0
@@ -901,10 +904,8 @@ class MainTable(tk.Canvas):
                     header=headers,
                     column_widths=column_widths,
                     event_data=event_data,
+                    mod_event_boxes=False,
                 )
-        self.deselect("all", redraw=False)
-        if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
-            self.undo_stack.append(pickled_event_dict(event_data))
         if added_rows:
             selboxr = selected_r + new_data_numrows
         else:
@@ -913,6 +914,7 @@ class MainTable(tk.Canvas):
             selboxc = selected_c + new_data_numcols
         else:
             selboxc = selected_c_adjusted_new_data_numcols
+        self.deselect("all", redraw=False)
         self.create_selection_box(
             selected_r,
             selected_c,
@@ -921,6 +923,10 @@ class MainTable(tk.Canvas):
             "cells",
             run_binding=True,
         )
+        event_data["selection_boxes"] = self.get_boxes()
+        event_data["selected"] = self.selected
+        if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.see(
             r=selected_r,
             c=selected_c,
@@ -1098,6 +1104,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()
@@ -1337,6 +1344,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()}
@@ -1561,7 +1569,6 @@ class MainTable(tk.Canvas):
         event_data["selection_boxes"] = modification["selection_boxes"]
         event_data["selected"] = modification["selected"]
         saved_cells = False
-
         if modification["added"]["rows"] or modification["added"]["columns"]:
             event_data = self.save_cells_using_modification(modification, event_data)
             saved_cells = True
@@ -1627,11 +1634,6 @@ class MainTable(tk.Canvas):
                 event_data=event_data,
             )
             self.displayed_rows = modification["added"]["rows"]["displayed_rows"]
-            if len(self.row_positions) > 1:
-                self.reselect_from_get_boxes(
-                    modification["selection_boxes"],
-                    modification["selected"],
-                )
 
         if modification["added"]["columns"]:
             self.deselect("all", run_binding=False, redraw=False)
@@ -1644,13 +1646,8 @@ class MainTable(tk.Canvas):
                 event_data=event_data,
             )
             self.displayed_columns = modification["added"]["columns"]["displayed_columns"]
-            if len(self.col_positions) > 1:
-                self.reselect_from_get_boxes(
-                    modification["selection_boxes"],
-                    modification["selected"],
-                )
 
-        if modification["deleted"]["rows"]:
+        if modification["deleted"]["rows"] or modification["deleted"]["row_heights"]:
             self.add_rows(
                 rows=modification["deleted"]["rows"],
                 index=modification["deleted"]["index"],
@@ -1663,7 +1660,7 @@ class MainTable(tk.Canvas):
             )
             self.restore_options_named_spans(modification)
 
-        if modification["deleted"]["columns"]:
+        if modification["deleted"]["columns"] or modification["deleted"]["column_widths"]:
             self.add_columns(
                 columns=modification["deleted"]["columns"],
                 header=modification["deleted"]["header"],
@@ -1676,27 +1673,10 @@ class MainTable(tk.Canvas):
             )
             self.restore_options_named_spans(modification)
 
-        if modification["eventname"].startswith("edit") and (
-            modification["deleted"]["columns"] or modification["deleted"]["rows"]
-        ):
-            self.reselect_from_get_boxes(
-                modification["selection_boxes"],
-                modification["selected"],
-            )
-
         if modification["eventname"].startswith(("edit", "move")):
             if not saved_cells:
                 event_data = self.save_cells_using_modification(modification, event_data)
             event_data = self.edit_cells_using_modification(modification, event_data)
-            if (
-                not modification["deleted"]["columns"]
-                and not modification["deleted"]["rows"]
-                and not modification["eventname"].startswith("move")
-            ):
-                self.reselect_from_get_boxes(
-                    modification["selection_boxes"],
-                    modification["selected"],
-                )
 
         elif modification["eventname"].startswith("add"):
             event_data["eventname"] = modification["eventname"].replace("add", "delete")
@@ -1704,6 +1684,15 @@ class MainTable(tk.Canvas):
         elif modification["eventname"].startswith("delete"):
             event_data["eventname"] = modification["eventname"].replace("delete", "add")
 
+        if not modification["eventname"].startswith("move") and (
+            len(self.row_positions) > 1 or len(self.col_positions) > 1
+        ):
+            self.deselect("all", redraw=False)
+            self.reselect_from_get_boxes(
+                modification["selection_boxes"],
+                modification["selected"],
+            )
+
         if self.selected:
             self.see(
                 r=self.selected.row,
@@ -3749,9 +3738,10 @@ class MainTable(tk.Canvas):
         for datacn in itercols:
             if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w:
                 w = hw
+            else:
+                w = min_column_width
             for datarn in iterrows:
-                txt = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
-                if txt:
+                if txt := self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True):
                     qconf(qtxtm, text=txt, font=qfont)
                     b = qbbox(qtxtm)
                     tw = b[2] - b[0] + added_w_space
@@ -3995,6 +3985,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()
@@ -4064,6 +4057,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()
@@ -4153,6 +4149,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()
@@ -4233,6 +4237,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()
@@ -4300,6 +4312,7 @@ class MainTable(tk.Canvas):
         create_selections: bool = True,
         add_row_positions: bool = True,
         push_ops: bool = True,
+        mod_event_boxes: bool = True,
     ) -> EventDataDict:
         self.saved_column_widths = {}
         saved_displayed_columns = list(self.displayed_columns)
@@ -4330,18 +4343,26 @@ class MainTable(tk.Canvas):
         maxrn = 0
         for cn, rowdict in reversed(columns.items()):
             for rn, v in rowdict.items():
-                if rn >= len(self.data):
+                if rn < len(self.data) and cn > len(self.data[rn]):
+                    self.fix_row_len(rn, cn - 1)
+                elif rn >= len(self.data):
                     self.fix_data_len(rn, cn - 1)
                 if rn > maxrn:
                     maxrn = rn
                 self.data[rn].insert(cn, v)
         # if not hiding rows then we can extend row positions if necessary
-        if add_row_positions and self.all_rows_displayed and maxrn + 1 > len(self.row_positions) - 1:
-            default_row_height = self.get_default_row_height()
+        if add_row_positions and self.all_rows_displayed and maxrn >= len(self.row_positions) - 1:
+            default_height = self.get_default_row_height()
+            event_data["added"]["rows"] = {
+                "table": {},
+                "index": {},
+                "row_heights": {rn: default_height for rn in range(len(self.row_positions) - 1, maxrn + 1)},
+                "displayed_rows": self.displayed_rows,
+            }
             self.set_row_positions(
                 itr=chain(
                     self.gen_row_heights(),
-                    repeat(default_row_height, len(self.row_positions) - 1, maxrn + 1),
+                    repeat(default_height, maxrn + 1 - (len(self.row_positions) - 1)),
                 )
             )
         if isinstance(self._headers, list) and header:
@@ -4362,6 +4383,9 @@ class MainTable(tk.Canvas):
                     "columns",
                     run_binding=True,
                 )
+            if mod_event_boxes:
+                event_data["selection_boxes"] = self.get_boxes()
+                event_data["selected"] = self.selected
         event_data["added"]["columns"] = {
             "table": columns,
             "header": header,
@@ -4433,6 +4457,7 @@ class MainTable(tk.Canvas):
         create_selections: bool = True,
         add_col_positions: bool = True,
         push_ops: bool = True,
+        mod_event_boxes: bool = True,
     ) -> EventDataDict:
         self.saved_row_heights = {}
         saved_displayed_rows = list(self.displayed_rows)
@@ -4472,11 +4497,18 @@ class MainTable(tk.Canvas):
         if isinstance(self._row_index, list) and index:
             self._row_index = insert_items(self._row_index, index, self.RI.fix_index)
         # if not hiding columns then we can extend col positions if necessary
-        if add_col_positions and self.all_columns_displayed and maxcn + 1 > len(self.col_positions) - 1:
+        if add_col_positions and self.all_columns_displayed and maxcn >= len(self.col_positions) - 1:
+            default_width = self.PAR.ops.default_column_width
+            event_data["added"]["columns"] = {
+                "table": {},
+                "header": {},
+                "column_widths": {cn: default_width for cn in range(len(self.col_positions) - 1, maxcn + 1)},
+                "displayed_columns": self.displayed_columns,
+            }
             self.set_col_positions(
                 itr=chain(
                     self.gen_column_widths(),
-                    repeat(self.PAR.ops.default_column_width, len(self.col_positions) - 1, maxcn + 1),
+                    repeat(default_width, maxcn + 1 - (len(self.col_positions) - 1)),
                 )
             )
         if push_ops:
@@ -4495,6 +4527,9 @@ class MainTable(tk.Canvas):
                     "rows",
                     run_binding=True,
                 )
+            if mod_event_boxes:
+                event_data["selection_boxes"] = self.get_boxes()
+                event_data["selected"] = self.selected
         event_data["added"]["rows"] = {
             "table": rows,
             "index": index,
@@ -5050,7 +5085,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]]
@@ -5095,11 +5133,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
@@ -5107,8 +5146,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
@@ -5121,13 +5172,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:
@@ -5340,18 +5393,21 @@ class MainTable(tk.Canvas):
                         if i not in diffs:
                             heights[i] -= change
                 self.row_positions = list(accumulate(chain([0], heights)))
-        if self.PAR.ops.auto_resize_row_index is not True:
-            if can_width >= self.col_positions[-1] + self.PAR.ops.empty_horizontal and self.PAR.xscroll_showing:
-                self.PAR.xscroll.grid_forget()
-                self.PAR.xscroll_showing = False
-            elif (
-                can_width < self.col_positions[-1] + self.PAR.ops.empty_horizontal
-                and not self.PAR.xscroll_showing
-                and not self.PAR.xscroll_disabled
-                and can_height > 40
-            ):
-                self.PAR.xscroll.grid(row=2, column=0, columnspan=2, sticky="nswe")
-                self.PAR.xscroll_showing = True
+        if (
+            self.PAR.ops.auto_resize_row_index is not True
+            and can_width >= self.col_positions[-1] + self.PAR.ops.empty_horizontal
+            and self.PAR.xscroll_showing
+        ):
+            self.PAR.xscroll.grid_forget()
+            self.PAR.xscroll_showing = False
+        elif (
+            can_width < self.col_positions[-1] + self.PAR.ops.empty_horizontal
+            and not self.PAR.xscroll_showing
+            and not self.PAR.xscroll_disabled
+            and can_height > 40
+        ):
+            self.PAR.xscroll.grid(row=2, column=0, columnspan=2, sticky="nswe")
+            self.PAR.xscroll_showing = True
         if can_height >= self.row_positions[-1] + self.PAR.ops.empty_vertical and self.PAR.yscroll_showing:
             self.PAR.yscroll.grid_forget()
             self.PAR.yscroll_showing = False
@@ -5829,7 +5885,8 @@ class MainTable(tk.Canvas):
                     )
                     return
             # wasn't provided an item and couldn't find a box at coords so select cell
-            self.select_cell(r, c, redraw=True)
+            if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
+                self.select_cell(r, c, redraw=True)
 
     def set_current_to_last(self) -> None:
         if self.selection_boxes:

{tksheet-7.2.2 → tksheet-7.2.4}/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.2 → tksheet-7.2.4}/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(
                     (

{tksheet-7.2.2 → tksheet-7.2.4}/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
@@ -47,6 +53,7 @@ from .other_classes import (
     FontTuple,
     GeneratedMouseEvent,
     Node,
+    ProgressBar,
     Selected,
     SelectionBox,
     Span,
@@ -1503,6 +1510,7 @@ class Sheet(tk.Frame):
             self.MT.deselect(redraw=False)
         if sheet_options:
             self.ops = new_sheet_options()
+            self.change_theme(redraw=False)
         if tree:
             self.RI.tree_reset()
         if tree or row_heights or column_widths:
@@ -4291,6 +4299,9 @@ class Sheet(tk.Frame):
         if any(k in kwargs for k in scrollbar_options_keys):
             self.set_scrollbar_options()
         self.MT.create_rc_menus()
+        if "treeview" in kwargs:
+            self.set_options(auto_resize_row_index=True, redraw=False)
+            self.index_align("w", redraw=False)
         return self.set_refresh_timer(redraw)
 
     def set_scrollbar_options(self) -> Sheet:
@@ -4441,6 +4452,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(
@@ -4681,7 +4746,7 @@ class Sheet(tk.Frame):
                 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]:
         """
@@ -4793,9 +4858,11 @@ class Sheet(tk.Frame):
                         idx += sum(1 for _ in self.RI.get_iid_descendants(cid)) + 1
             else:
                 idx = len(self.MT._row_index)
+        if values is None:
+            values = []
         self.insert_rows(
             idx=idx,
-            rows=[[self.RI.tree[iid]] + [] if values is None else values],
+            rows=[[self.RI.tree[iid]] + values],
             row_index=True,
             create_selections=create_selections,
             fill=False,
@@ -4914,8 +4981,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:
         """
@@ -5004,8 +5070,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
 

{tksheet-7.2.2 → tksheet-7.2.4/tksheet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.2
+Version: 7.2.4
 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