tksheet 7.2.7__py3-none-any.whl → 7.2.9__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -946,8 +946,10 @@ class ColumnHeaders(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        self.MT.deselect("all", redraw=False)
+        boxes_to_hide = tuple(self.MT.selection_boxes)
         fill_iid = self.MT.create_selection_box(0, c, len(self.MT.row_positions) - 1, c + 1, "columns", ext=ext)
+        for iid in boxes_to_hide:
+            self.MT.hide_selection_box(iid)
         if redraw:
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         if run_binding_func:
@@ -987,7 +989,7 @@ class ColumnHeaders(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=8 if self.PAR.ops.rounded_boxes else 0,
+            radius=5 if self.PAR.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1301,34 +1303,33 @@ class ColumnHeaders(tk.Canvas):
         tag: str | tuple[str],
         draw_outline: bool = True,
         draw_arrow: bool = True,
-        dd_is_open: bool = False,
+        open_: bool = False,
     ) -> None:
         if draw_outline and self.PAR.ops.show_dropdown_borders:
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.header_fg, tag=tag)
         if draw_arrow:
             mod = (self.MT.header_txt_height - 1) if self.MT.header_txt_height % 2 else self.MT.header_txt_height
-            half_mod = mod / 2
-            qtr_mod = mod / 4
-            mid_y = (
-                (self.MT.header_first_ln_ins - 1) if self.MT.header_first_ln_ins % 2 else self.MT.header_first_ln_ins
-            )
-            if dd_is_open:
+            small_mod = int(mod / 5)
+            mid_y = floor(self.MT.min_header_height / 2)
+            if open_:
+                # up arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3,
-                    y1 + mid_y + qtr_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 4 - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 4,
+                    y1 + mid_y + small_mod,
                 )
             else:
+                # down arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3,
-                    y1 + mid_y - qtr_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 4 - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 4,
+                    y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
@@ -1339,10 +1340,13 @@ class ColumnHeaders(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(
+                t = self.create_line(
                     points,
                     fill=fill,
                     tag=tag,
+                    width=2,
+                    capstyle=tk.ROUND,
+                    joinstyle=tk.BEVEL,
                 )
             self.disp_dropdown[t] = True
 
@@ -1502,7 +1506,7 @@ class ColumnHeaders(tk.Canvas):
                         tag="dd",
                         draw_outline=not dd_drawn,
                         draw_arrow=mw >= 5,
-                        dd_is_open=dd_coords == c,
+                        open_=dd_coords == c,
                     )
                 else:
                     mw = crightgridln - cleftgridln - 1
@@ -1521,7 +1525,7 @@ class ColumnHeaders(tk.Canvas):
                         tag="dd",
                         draw_outline=not dd_drawn,
                         draw_arrow=mw >= 5,
-                        dd_is_open=dd_coords == c,
+                        open_=dd_coords == c,
                     )
                 else:
                     mw = crightgridln - cleftgridln - 1
@@ -1541,7 +1545,7 @@ class ColumnHeaders(tk.Canvas):
                         tag="dd",
                         draw_outline=not dd_drawn,
                         draw_arrow=mw >= 5,
-                        dd_is_open=dd_coords == c,
+                        open_=dd_coords == c,
                     )
                 else:
                     mw = crightgridln - cleftgridln - 1
@@ -2022,7 +2026,7 @@ class ColumnHeaders(tk.Canvas):
             "height": win_h,
             "font": self.PAR.ops.header_font,
             "ops": self.PAR.ops,
-            "outline_color": self.PAR.ops.popup_menu_fg,
+            "outline_color": self.PAR.ops.header_selected_columns_bg,
             "align": self.get_cell_align(c),
             "values": kwargs["values"],
         }

tksheet/functions.py

@@ -545,7 +545,7 @@ def rounded_box_coords(
     y1: float,
     x2: float,
     y2: float,
-    radius: int = 8,
+    radius: int = 5,
 ) -> tuple[float]:
     return (
         x1 + radius,

tksheet/main_table.py

@@ -25,6 +25,7 @@ from itertools import (
     accumulate,
     chain,
     cycle,
+    filterfalse,
     islice,
     repeat,
 )
@@ -696,8 +697,9 @@ class MainTable(tk.Canvas):
             selected=self.selected,
         )
         if self.selected:
-            selected_r = self.selected.row
-            selected_c = self.selected.column
+            selected_r = self.selected.box.from_r
+            selected_c = self.selected.box.from_c
+            curr_coords = (self.selected.row, self.selected.column)
         elif not self.selected and not self.PAR.ops.paste_can_expand_x and not self.PAR.ops.paste_can_expand_y:
             return
         else:
@@ -710,6 +712,7 @@ class MainTable(tk.Canvas):
                     selected_c, selected_r = len(self.col_positions) - 1, 0
                 elif len(self.row_positions) > 1 and len(self.col_positions) > 1:
                     selected_c, selected_r = 0, len(self.row_positions) - 1
+                curr_coords = (selected_r, selected_c)
         try:
             data = get_data_from_clipboard(
                 widget=self,
@@ -915,13 +918,17 @@ class MainTable(tk.Canvas):
         else:
             selboxc = selected_c_adjusted_new_data_numcols
         self.deselect("all", redraw=False)
-        self.create_selection_box(
-            selected_r,
-            selected_c,
-            selboxr,
-            selboxc,
-            "cells",
-            run_binding=True,
+        self.set_currently_selected(
+            *curr_coords,
+            item=self.create_selection_box(
+                selected_r,
+                selected_c,
+                selboxr,
+                selboxc,
+                type_="cells",
+                set_current=False,
+                run_binding=True,
+            ),
         )
         event_data["selection_boxes"] = self.get_boxes()
         event_data["selected"] = self.selected
@@ -3310,7 +3317,7 @@ class MainTable(tk.Canvas):
             self.yview_scroll(-1, "units")
             self.RI.yview_scroll(-1, "units")
             self.y_move_synced_scrolls("moveto", self.yview()[0])
-        self.main_table_redraw_grid_and_text(redraw_row_index=True)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def shift_mousewheel(self, event: object) -> None:
         if event.delta < 0 or event.num == 5:
@@ -3323,7 +3330,7 @@ class MainTable(tk.Canvas):
             self.xview_scroll(-1, "units")
             self.CH.xview_scroll(-1, "units")
             self.x_move_synced_scrolls("moveto", self.xview()[0])
-        self.main_table_redraw_grid_and_text(redraw_header=True)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def ctrl_mousewheel(self, event):
         if event.delta < 0 or event.num == 5:
@@ -3773,11 +3780,10 @@ class MainTable(tk.Canvas):
         colpos = self.PAR.ops.default_column_width
         if isinstance(ncols, int):
             self.set_col_positions(itr=repeat(colpos, ncols))
+        elif self.all_columns_displayed:
+            self.set_col_positions(itr=repeat(colpos, self.total_data_cols()))
         else:
-            if self.all_columns_displayed:
-                self.set_col_positions(itr=repeat(colpos, self.total_data_cols()))
-            else:
-                self.set_col_positions(itr=repeat(colpos, len(self.displayed_columns)))
+            self.set_col_positions(itr=repeat(colpos, len(self.displayed_columns)))
 
     def set_row_positions(self, itr: Iterator[float]) -> None:
         self.row_positions = list(accumulate(chain([0], itr)))
@@ -3786,11 +3792,10 @@ class MainTable(tk.Canvas):
         rowpos = self.get_default_row_height()
         if isinstance(nrows, int):
             self.set_row_positions(itr=repeat(rowpos, nrows))
+        elif self.all_rows_displayed:
+            self.set_row_positions(itr=repeat(rowpos, self.total_data_rows()))
         else:
-            if self.all_rows_displayed:
-                self.set_row_positions(itr=repeat(rowpos, self.total_data_rows()))
-            else:
-                self.set_row_positions(itr=repeat(rowpos, len(self.displayed_rows)))
+            self.set_row_positions(itr=repeat(rowpos, len(self.displayed_rows)))
 
     def del_col_position(self, idx: int, deselect_all: bool = False):
         if deselect_all:
@@ -4453,7 +4458,7 @@ class MainTable(tk.Canvas):
         if isinstance(displayed_rows, list):
             self.displayed_rows = displayed_rows
         elif not self.all_rows_displayed:
-            # push displayed indexes by one for every inserted column
+            # push displayed indexes by one for every inserted row
             self.displayed_rows.sort()
             # highest index is first in rows
             up_to = len(self.displayed_rows)
@@ -4718,9 +4723,10 @@ class MainTable(tk.Canvas):
             named_spans=self.get_spans_to_del_from_cols(cols=cols_set),
         )
         if not self.all_columns_displayed:
-            self.displayed_columns = [c for c in self.displayed_columns if c not in cols_set]
-            for c in cols:
-                self.displayed_columns = [dc if c > dc else dc - 1 for dc in self.displayed_columns]
+            self.displayed_columns = [
+                c if not (num := bisect_left(cols, c)) else c - num
+                for c in filterfalse(cols_set.__contains__, self.displayed_columns)
+            ]
         return event_data
 
     def delete_columns_displayed(self, cols: list, event_data: dict) -> EventDataDict:
@@ -4773,9 +4779,10 @@ class MainTable(tk.Canvas):
             named_spans=self.get_spans_to_del_from_rows(rows=rows_set),
         )
         if not self.all_rows_displayed:
-            self.displayed_rows = [r for r in self.displayed_rows if r not in rows_set]
-            for r in rows:
-                self.displayed_rows = [dr if r > dr else dr - 1 for dr in self.displayed_rows]
+            self.displayed_rows = [
+                r if not (num := bisect_left(rows, r)) else r - num
+                for r in filterfalse(rows_set.__contains__, self.displayed_rows)
+            ]
         return event_data
 
     def delete_rows_displayed(self, rows: list, event_data: dict) -> EventDataDict:
@@ -4847,20 +4854,23 @@ class MainTable(tk.Canvas):
     ) -> list[int] | None:
         if rows is None and all_rows_displayed is None:
             return list(range(self.total_data_rows())) if self.all_rows_displayed else self.displayed_rows
-        total_data_rows = None
-        if (rows is not None and rows != self.displayed_rows) or (all_rows_displayed and not self.all_rows_displayed):
-            self.purge_undo_and_redo_stack()
         if rows is not None and rows != self.displayed_rows:
+            self.purge_undo_and_redo_stack()
             self.displayed_rows = sorted(rows)
-        if all_rows_displayed:
-            if not self.all_rows_displayed:
-                total_data_rows = self.total_data_rows()
-                self.displayed_rows = list(range(total_data_rows))
-            self.all_rows_displayed = True
-        elif all_rows_displayed is not None and not all_rows_displayed:
-            self.all_rows_displayed = False
+        # setting all_rows_displayed
+        if all_rows_displayed is not None:
+            # setting it to True and it's currently False
+            if all_rows_displayed and not self.all_rows_displayed:
+                self.purge_undo_and_redo_stack()
+                self.all_rows_displayed = True
+            # setting it to False and it's currently True
+            elif not all_rows_displayed and self.all_rows_displayed:
+                # if rows is None then displayed_rows needs to be reset
+                if rows is None:
+                    self.displayed_rows = list(range(self.total_data_rows()))
+                self.all_rows_displayed = False
         if reset_row_positions:
-            self.reset_row_positions(nrows=total_data_rows)
+            self.reset_row_positions()
         if deselect_all:
             self.deselect("all", redraw=False)
 
@@ -4873,22 +4883,23 @@ class MainTable(tk.Canvas):
     ) -> list[int] | None:
         if columns is None and all_columns_displayed is None:
             return list(range(self.total_data_cols())) if self.all_columns_displayed else self.displayed_columns
-        total_data_cols = None
-        if (columns is not None and columns != self.displayed_columns) or (
-            all_columns_displayed and not self.all_columns_displayed
-        ):
-            self.purge_undo_and_redo_stack()
         if columns is not None and columns != self.displayed_columns:
+            self.purge_undo_and_redo_stack()
             self.displayed_columns = sorted(columns)
-        if all_columns_displayed:
-            if not self.all_columns_displayed:
-                total_data_cols = self.total_data_cols()
-                self.displayed_columns = list(range(total_data_cols))
-            self.all_columns_displayed = True
-        elif all_columns_displayed is not None and not all_columns_displayed:
-            self.all_columns_displayed = False
+        # setting all_columns_displayed
+        if all_columns_displayed is not None:
+            # setting it to True and it's currently False
+            if all_columns_displayed and not self.all_columns_displayed:
+                self.purge_undo_and_redo_stack()
+                self.all_columns_displayed = True
+            # setting it to False and it's currently True
+            elif not all_columns_displayed and self.all_columns_displayed:
+                # if columns is None then displayed_columns needs to be reset
+                if columns is None:
+                    self.displayed_columns = list(range(self.total_data_cols()))
+                self.all_columns_displayed = False
         if reset_col_positions:
-            self.reset_col_positions(ncols=total_data_cols)
+            self.reset_col_positions()
         if deselect_all:
             self.deselect("all", redraw=False)
 
@@ -5234,32 +5245,33 @@ class MainTable(tk.Canvas):
         tag,
         draw_outline=True,
         draw_arrow=True,
-        dd_is_open=False,
+        open_=False,
     ):
         if draw_outline and self.PAR.ops.show_dropdown_borders:
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg, tag=tag)
         if draw_arrow:
             mod = (self.table_txt_height - 1) if self.table_txt_height % 2 else self.table_txt_height
-            half_mod = mod / 2
-            qtr_mod = mod / 4
-            mid_y = (self.table_first_ln_ins - 1) if self.table_first_ln_ins % 2 else self.table_first_ln_ins
-            if dd_is_open:
+            small_mod = int(mod / 5)
+            mid_y = floor(self.min_row_height / 2)
+            if open_:
+                # up arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3,
-                    y1 + mid_y + qtr_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 4 - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 4,
+                    y1 + mid_y + small_mod,
                 )
             else:
+                # down arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3,
-                    y1 + mid_y - qtr_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 4 - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 4,
+                    y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
@@ -5270,10 +5282,13 @@ class MainTable(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(
+                t = self.create_line(
                     points,
                     fill=fill,
                     tag=tag,
+                    width=2,
+                    capstyle=tk.ROUND,
+                    joinstyle=tk.BEVEL,
                 )
             self.disp_dropdown[t] = True
 
@@ -5604,7 +5619,7 @@ class MainTable(tk.Canvas):
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
                                 draw_arrow=mw >= 5,
-                                dd_is_open=dd_coords == (r, c),
+                                open_=dd_coords == (r, c),
                             )
                         else:
                             mw = crightgridln - cleftgridln - 1
@@ -5622,7 +5637,7 @@ class MainTable(tk.Canvas):
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
                                 draw_arrow=mw >= 5,
-                                dd_is_open=dd_coords == (r, c),
+                                open_=dd_coords == (r, c),
                             )
                         else:
                             mw = crightgridln - cleftgridln - 1
@@ -5641,7 +5656,7 @@ class MainTable(tk.Canvas):
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
                                 draw_arrow=mw >= 5,
-                                dd_is_open=dd_coords == (r, c),
+                                open_=dd_coords == (r, c),
                             )
                         else:
                             mw = crightgridln - cleftgridln - 1
@@ -5956,7 +5971,7 @@ class MainTable(tk.Canvas):
         if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1:
             radius = 0
         else:
-            radius = 8
+            radius = 5
         coords = rounded_box_coords(
             x1,
             y1,
@@ -6044,7 +6059,7 @@ class MainTable(tk.Canvas):
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if self.selection_boxes:
             self.itemconfig(next(reversed(self.selection_boxes)), state="normal")
-        x1, y1, x2, y2 = self.box_sheet_coords_x_canvas_coords(r1, c1, r2, c2, type_)
+        x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
         fill_iid = self.display_box(
             x1,
             y1,
@@ -6057,7 +6072,7 @@ class MainTable(tk.Canvas):
             width=1,
         )
         index_iid = self.RI.display_box(
-            1,
+            0,
             y1,
             self.RI.current_width - 1,
             y2,
@@ -6131,7 +6146,7 @@ class MainTable(tk.Canvas):
             if self.PAR.ops.show_selected_cells_border:
                 self.tag_raise(self.selected.iid)
 
-    def box_sheet_coords_x_canvas_coords(
+    def box_coords_x_canvas_coords(
         self,
         r1: int,
         c1: int,
@@ -6178,10 +6193,10 @@ class MainTable(tk.Canvas):
                 state = "normal"
         if self.selected.fill_iid == fill_iid:
             self.selected = self.selected._replace(box=Box_nt(r1, c1, r2, c2))
-        x1, y1, x2, y2 = self.box_sheet_coords_x_canvas_coords(r1, c1, r2, c2, type_)
+        x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
         self.display_box(x1, y1, x2, y2, fill=mt_bg, outline="", state=state, tags=type_, width=1, iid=fill_iid)
         self.RI.display_box(
-            1,
+            0,
             y1,
             self.RI.current_width - 1,
             y2,

tksheet/row_index.py

@@ -893,7 +893,7 @@ class RowIndex(tk.Canvas):
                     self.open_cell(event)
                 elif (iid := self.event_over_tree_arrow(r, canvasy, event.x)) is not None:
                     if self.MT.selection_boxes:
-                        self.select_row(r, redraw=False)
+                        self.select_row(r, ext=True, redraw=False)
                     self.PAR.item(iid, open_=iid not in self.tree_open_ids)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -957,9 +957,10 @@ class RowIndex(tk.Canvas):
         run_binding_func: bool = True,
         ext: bool = False,
     ) -> int:
-        self.MT.deselect("all", redraw=False)
-        box = (r, 0, r + 1, len(self.MT.col_positions) - 1, "rows")
-        fill_iid = self.MT.create_selection_box(*box, ext=ext)
+        boxes_to_hide = tuple(self.MT.selection_boxes)
+        fill_iid = self.MT.create_selection_box(r, 0, r + 1, len(self.MT.col_positions) - 1, "rows", ext=ext)
+        for iid in boxes_to_hide:
+            self.MT.hide_selection_box(iid)
         if redraw:
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         if run_binding_func:
@@ -999,7 +1000,7 @@ class RowIndex(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=8 if self.PAR.ops.rounded_boxes else 0,
+            radius=5 if self.PAR.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1344,29 +1345,33 @@ class RowIndex(tk.Canvas):
         open_: bool = False,
     ) -> None:
         mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
-        half_mod = mod / 2
-        qtr_mod = mod / 4
-        small_mod = int(half_mod / 4) - 1
-        mid_y = int(self.MT.min_row_height / 2)
+        small_mod = int(mod / 5)
+        mid_y = floor(self.MT.min_row_height / 2)
         # up arrow
         if open_:
             points = (
-                x1 + 2 + indent,
-                y1 + mid_y + qtr_mod,
-                x1 + 2 + half_mod + indent,
-                y1 + mid_y - qtr_mod,
-                x1 + 2 + mod + indent,
-                y1 + mid_y + qtr_mod,
+                # the left hand downward point
+                x1 + 5 + indent,
+                y1 + mid_y + small_mod,
+                # the middle upward point
+                x1 + 5 + indent + small_mod + small_mod,
+                y1 + mid_y - small_mod,
+                # the right hand downward point
+                x1 + 5 + indent + small_mod + small_mod + small_mod + small_mod,
+                y1 + mid_y + small_mod,
             )
         # right pointing arrow
         else:
             points = (
-                x1 + half_mod + indent,
-                y1 + mid_y - half_mod + small_mod,
-                x1 + mod + indent - small_mod,
+                # the upper point
+                x1 + 5 + indent + small_mod + small_mod,
+                y1 + mid_y - small_mod - small_mod,
+                # the middle point
+                x1 + 5 + indent + small_mod + small_mod + small_mod + small_mod,
                 y1 + mid_y,
-                x1 + half_mod + indent,
-                y1 + mid_y + half_mod - small_mod,
+                # the bottom point
+                x1 + 5 + indent + small_mod + small_mod,
+                y1 + mid_y + small_mod + small_mod,
             )
         if self.hidd_tree_arrow:
             t, sh = self.hidd_tree_arrow.popitem()
@@ -1404,26 +1409,27 @@ class RowIndex(tk.Canvas):
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.index_fg, tag=tag)
         if draw_arrow:
             mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
-            half_mod = mod / 2
-            qtr_mod = mod / 4
-            mid_y = (self.MT.index_first_ln_ins - 1) if self.MT.index_first_ln_ins % 2 else self.MT.index_first_ln_ins
+            small_mod = int(mod / 5)
+            mid_y = floor(self.MT.min_row_height / 2)
             if open_:
+                # up arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3,
-                    y1 + mid_y + qtr_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 4 - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 4,
+                    y1 + mid_y + small_mod,
                 )
             else:
+                # down arrow
                 points = (
-                    x2 - 3 - mod,
-                    y1 + mid_y - qtr_mod,
-                    x2 - 3 - half_mod,
-                    y1 + mid_y + qtr_mod,
-                    x2 - 3,
-                    y1 + mid_y - qtr_mod,
+                    x2 - 4 - small_mod - small_mod - small_mod - small_mod,
+                    y1 + mid_y - small_mod,
+                    x2 - 4 - small_mod - small_mod,
+                    y1 + mid_y + small_mod,
+                    x2 - 4,
+                    y1 + mid_y - small_mod,
                 )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
@@ -1434,10 +1440,13 @@ class RowIndex(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_polygon(
+                t = self.create_line(
                     points,
                     fill=fill,
                     tag=tag,
+                    width=2,
+                    capstyle=tk.ROUND,
+                    joinstyle=tk.BEVEL,
                 )
             self.disp_dropdown[t] = True
 
@@ -1683,12 +1692,12 @@ class RowIndex(tk.Canvas):
                 iid = self.MT._row_index[datarn].iid
                 mw -= self.MT.index_txt_height
                 if align == "w":
-                    draw_x += self.MT.index_txt_height + 1
+                    draw_x += self.MT.index_txt_height + 3
                 indent = self.get_treeview_indent(iid)
                 draw_x += indent + 5
                 if self.tree[iid].children:
                     self.redraw_tree_arrow(
-                        0,
+                        2,
                         rtopgridln,
                         r=r,
                         fill=tree_arrow_fg,
@@ -2145,7 +2154,7 @@ class RowIndex(tk.Canvas):
             "height": win_h,
             "font": self.PAR.ops.index_font,
             "ops": self.PAR.ops,
-            "outline_color": self.PAR.ops.popup_menu_fg,
+            "outline_color": self.PAR.ops.index_selected_rows_bg,
             "align": self.get_cell_align(r),
             "values": kwargs["values"],
         }

tksheet/sheet.py

@@ -10,7 +10,14 @@ from collections.abc import (
     Iterator,
     Sequence,
 )
-from itertools import accumulate, chain, islice, product, repeat
+from itertools import (
+    accumulate,
+    chain,
+    filterfalse,
+    islice,
+    product,
+    repeat,
+)
 from timeit import default_timer
 from tkinter import ttk
 from typing import Literal
@@ -3813,7 +3820,6 @@ class Sheet(tk.Frame):
         columns: None | Literal["all"] | Iterator[int] = None,
         all_columns_displayed: None | bool = None,
         reset_col_positions: bool = True,
-        refresh: bool = False,
         redraw: bool = False,
         deselect_all: bool = True,
         **kwargs,
@@ -3828,8 +3834,9 @@ class Sheet(tk.Frame):
             reset_col_positions=reset_col_positions,
             deselect_all=deselect_all,
         )
-        if refresh or redraw:
-            self.set_refresh_timer(redraw if redraw else refresh)
+        if "refresh" in kwargs:
+            redraw = kwargs["refresh"]
+        self.set_refresh_timer(redraw)
         return res
 
     def hide_columns(
@@ -3846,7 +3853,7 @@ class Sheet(tk.Frame):
             if not columns:
                 return
         if self.MT.all_columns_displayed:
-            self.MT.displayed_columns = [c for c in range(self.MT.total_data_cols()) if c not in columns]
+            self.MT.displayed_columns = list(filterfalse(columns.__contains__, range(self.MT.total_data_cols())))
             to_pop = {c: c for c in columns}
         else:
             to_pop = {}
@@ -3876,13 +3883,18 @@ class Sheet(tk.Frame):
             self.MT.deselect(redraw=False)
         return self.set_refresh_timer(redraw)
 
-    # uses data indexes
     def show_columns(
         self,
         columns: int | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
     ) -> Sheet:
+        """
+        'columns' argument must be data indexes
+        Function will return without action if Sheet.all_columns
+        """
+        if self.MT.all_columns_displayed:
+            return
         if isinstance(columns, int):
             columns = [columns]
         cws = self.MT.get_column_widths()
@@ -3908,7 +3920,10 @@ class Sheet(tk.Frame):
 
     @all_columns.setter
     def all_columns(self, a: bool) -> Sheet:
-        self.MT.all_columns_displayed = a
+        self.MT.display_columns(
+            columns=None,
+            all_columns_displayed=a,
+        )
         return self
 
     @property
@@ -3917,8 +3932,8 @@ class Sheet(tk.Frame):
 
     @displayed_columns.setter
     def displayed_columns(self, columns: list[int]) -> Sheet:
-        self.display_columns(columns=columns, reset_col_positions=False, redraw=True)
-        return self
+        self.display_columns(columns=columns, reset_col_positions=True, redraw=False)
+        return self.set_refresh_timer()
 
     # Hiding Rows
 
@@ -3933,7 +3948,6 @@ class Sheet(tk.Frame):
         rows: None | Literal["all"] | Iterator[int] = None,
         all_rows_displayed: None | bool = None,
         reset_row_positions: bool = True,
-        refresh: bool = False,
         redraw: bool = False,
         deselect_all: bool = True,
         **kwargs,
@@ -3946,8 +3960,9 @@ class Sheet(tk.Frame):
             reset_row_positions=reset_row_positions,
             deselect_all=deselect_all,
         )
-        if refresh or redraw:
-            self.set_refresh_timer(redraw if redraw else refresh)
+        if "refresh" in kwargs:
+            redraw = kwargs["refresh"]
+        self.set_refresh_timer(redraw)
         return res
 
     def hide_rows(
@@ -3965,7 +3980,7 @@ class Sheet(tk.Frame):
             if not rows:
                 return
         if self.MT.all_rows_displayed:
-            self.MT.displayed_rows = [r for r in range(self.MT.total_data_rows()) if r not in rows]
+            self.MT.displayed_rows = list(filterfalse(rows.__contains__, range(self.MT.total_data_rows())))
             to_pop = {r: r for r in rows}
         else:
             to_pop = {}
@@ -3996,13 +4011,18 @@ class Sheet(tk.Frame):
             self.MT.deselect(redraw=False)
         return self.set_refresh_timer(redraw)
 
-    # uses data indexes
     def show_rows(
         self,
         rows: int | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
     ) -> Sheet:
+        """
+        'rows' argument must be data indexes
+        Function will return without action if Sheet.all_rows
+        """
+        if self.MT.all_rows_displayed:
+            return
         if isinstance(rows, int):
             rows = [rows]
         rhs = self.MT.get_row_heights()
@@ -4028,7 +4048,10 @@ class Sheet(tk.Frame):
 
     @all_rows.setter
     def all_rows(self, a: bool) -> Sheet:
-        self.MT.all_rows_displayed = a
+        self.MT.display_rows(
+            rows=None,
+            all_rows_displayed=a,
+        )
         return self
 
     @property
@@ -4037,8 +4060,8 @@ class Sheet(tk.Frame):
 
     @displayed_rows.setter
     def displayed_rows(self, rows: list[int]) -> Sheet:
-        self.display_rows(rows=rows, reset_row_positions=False, redraw=True)
-        return self
+        self.display_rows(rows=rows, reset_row_positions=True, redraw=False)
+        return self.set_refresh_timer()
 
     # Hiding Sheet Elements
 
@@ -4747,7 +4770,7 @@ class Sheet(tk.Frame):
         Closes everything else
         """
         self.hide_rows(
-            set(rn for rn in self.MT.displayed_rows if self.MT._row_index[rn].parent),
+            rows={rn for rn in self.MT.displayed_rows if self.MT._row_index[rn].parent},
             redraw=False,
             deselect_all=False,
             data_indexes=True,
@@ -4768,13 +4791,15 @@ class Sheet(tk.Frame):
         """
         to_open = []
         disp_set = set(self.MT.displayed_rows)
-        quick_rns = self.RI.tree_rns
-        quick_open_ids = self.RI.tree_open_ids
+        tree = self.RI.tree
+        rns = self.RI.tree_rns
+        open_ids = self.RI.tree_open_ids
+        descendants = self.RI.get_iid_descendants
         for item in filter(items.__contains__, self.get_children()):
-            if self.RI.tree[item].children:
-                quick_open_ids.add(item)
-                if quick_rns[item] in disp_set:
-                    to_disp = [quick_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)]
+            if tree[item].children:
+                open_ids.add(item)
+                if rns[item] in disp_set:
+                    to_disp = [rns[did] for did in descendants(item, check_open=True)]
                     for i in to_disp:
                         disp_set.add(i)
                     to_open.extend(to_disp)
@@ -4921,7 +4946,7 @@ class Sheet(tk.Frame):
                     self.RI.tree_open_ids.add(item)
                     if self.item_displayed(item):
                         self.show_rows(
-                            rows=(self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
+                            rows=map(self.RI.tree_rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True)),
                             redraw=False,
                             deselect_all=False,
                         )
@@ -4929,7 +4954,9 @@ class Sheet(tk.Frame):
                     self.RI.tree_open_ids.discard(item)
                     if self.item_displayed(item):
                         self.hide_rows(
-                            rows={self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)},
+                            rows=set(
+                                map(self.RI.tree_rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True))
+                            ),
                             redraw=False,
                             deselect_all=False,
                             data_indexes=True,
@@ -5106,7 +5133,8 @@ 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 next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == self.RI.tree[item])
+            find_node = self.RI.tree[item]
+            return next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == find_node)
         return self.RI.tree[item].parent.children.index(self.RI.tree[item])
 
     def item_displayed(self, item: str) -> bool:
@@ -5128,8 +5156,11 @@ class Sheet(tk.Frame):
         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, redraw=False)
+            self.show_rows(
+                rows=self._tree_open(list(self.RI.get_iid_ancestors(item))),
+                redraw=False,
+                deselect_all=False,
+            )
         return self.set_refresh_timer(redraw)
 
     def scroll_to_item(self, item: str, redraw=False) -> Sheet:
@@ -5151,14 +5182,15 @@ class Sheet(tk.Frame):
         Get currently selected item ids
         """
         return [
-            self.MT._row_index[self.displayed_row_to_data(rn)].iid
-            for rn in self.get_selected_rows(get_cells_as_rows=cells)
+            self.MT._row_index[self.MT.displayed_rows[rn]].iid for rn in self.get_selected_rows(get_cells_as_rows=cells)
         ]
 
     def selection_set(self, *items, redraw: bool = True) -> Sheet:
         if any(item.lower() in self.RI.tree for item in unpack(items)):
-            self.deselect(redraw=False)
+            boxes_to_hide = tuple(self.MT.selection_boxes)
             self.selection_add(*items, redraw=False)
+            for iid in boxes_to_hide:
+                self.MT.hide_selection_box(iid)
         return self.set_refresh_timer(redraw)
 
     def selection_add(self, *items, redraw: bool = True) -> Sheet:
@@ -5220,7 +5252,7 @@ class Sheet(tk.Frame):
 
     # Functions not in docs
 
-    def event_generate(self, *args, **kwargs):
+    def event_generate(self, *args, **kwargs) -> None:
         self.MT.event_generate(*args, **kwargs)
 
     def emit_event(

tksheet/themes.py

@@ -21,7 +21,7 @@ theme_light_blue: dict[str, str] = DotDict({
     "index_fg": "black",
     "index_selected_cells_bg": "#D3E3FD",
     "index_selected_cells_fg": "black",
-    "top_left_bg": "#FFFFFF",
+    "top_left_bg": "#F9FBFD",
     "top_left_fg": "#C7C7C7",
     "top_left_fg_highlight": "#747775",
     "table_bg": "#FFFFFF",
@@ -84,19 +84,19 @@ theme_light_green: dict[str, str] = DotDict({
     "popup_menu_highlight_fg": "#000000",
     "index_hidden_rows_expander_bg": "gray30",
     "header_hidden_columns_expander_bg": "gray30",
-    "header_bg": "#ECECEC",
+    "header_bg": "#F5F5F5",
     "header_border_fg": "#ababab",
     "header_grid_fg": "#ababab",
     "header_fg": "black",
-    "header_selected_cells_bg": "#d6d4d2",
+    "header_selected_cells_bg": "#CAEAD8",
     "header_selected_cells_fg": "#217346",
-    "index_bg": "#ECECEC",
+    "index_bg": "#F5F5F5",
     "index_border_fg": "#ababab",
     "index_grid_fg": "#ababab",
     "index_fg": "black",
-    "index_selected_cells_bg": "#d6d4d2",
+    "index_selected_cells_bg": "#CAEAD8",
     "index_selected_cells_fg": "#107C41",
-    "top_left_bg": "#ECECEC",
+    "top_left_bg": "#F5F5F5",
     "top_left_fg": "#b7b7b7",
     "top_left_fg_highlight": "#5f6368",
     "table_bg": "#FFFFFF",
@@ -171,7 +171,7 @@ theme_dark: dict[str, str] = DotDict({
     "index_fg": "gray70",
     "index_selected_cells_bg": "#545454",
     "index_selected_cells_fg": "#6aa2fc",
-    "top_left_bg": "#141414",
+    "top_left_bg": "#28282a",
     "top_left_fg": "#505054",
     "top_left_fg_highlight": "white",
     "table_bg": "#000000",
@@ -246,7 +246,7 @@ theme_black: dict[str, str] = DotDict({
     "index_fg": "#FBB86C",
     "index_selected_cells_bg": "#545454",
     "index_selected_cells_fg": "#FBB86C",
-    "top_left_bg": "#000000",
+    "top_left_bg": "#141416",
     "top_left_fg": "#505054",
     "top_left_fg_highlight": "#FBB86C",
     "table_bg": "#000000",

tksheet/top_left_rectangle.py

@@ -163,6 +163,7 @@ class TopLeftRectangle(tk.Canvas):
         recreate_selection_boxes: bool = True,
     ) -> None:
         try:
+            self.update_idletasks()
             if new_h is None:
                 h = self.winfo_height()
             if new_w is None:

{tksheet-7.2.7.dist-info → tksheet-7.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.7
+Version: 7.2.9
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors

tksheet-7.2.9.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=CsvPUSqncRztCcOp7ke7wcU9HI6vtZhS7NdDrltgRyU,2144
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=HlMCcwEz2e2L7j93mpkhtlXbIMu_yRTWFIXr9f1Sch8,102430
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=PgigHSO_cnQoWSXFSfJ5YlPbyOVd2BYUHU4UBbUCCFE,40706
+tksheet/main_table.py,sha256=4jdk2ro5pyooMr_BKiv2PkS-sxnWLZe0HcgX69NH7Y8,328195
+tksheet/other_classes.py,sha256=CDN38ZjKxZro9YOS_g0DjMC82-Mi9udedny4wdd90W0,14347
+tksheet/row_index.py,sha256=to6EPvmh7NV9YjGfrLOYgrMqDiSMdTjwOWa6Umh0_wA,109206
+tksheet/sheet.py,sha256=d3HnnJeaEkhZ7ID2t8M2g87hLg66iJmUWV60rGz_OaY,273221
+tksheet/sheet_options.py,sha256=Azo7_-H0e0ssYEoU7Mq_OWy3S-U05rp4_6Q2E2Ffuu8,12262
+tksheet/text_editor.py,sha256=aRm1Y5GfORiEAJthtN1uQ30CT3VoF8mRWvR-SIXPrJU,6548
+tksheet/themes.py,sha256=ijEG5xsrNZR04r5aZaVDHO9_ZFW5q6bzw6NxIjkKIR4,14474
+tksheet/top_left_rectangle.py,sha256=ZptxpfkkYL09d6ILDkY_u6RLv8PB-AGHOkBz-K0mJ0E,8473
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=86ubZZElsnQuC6Lv6bW2lt2NhD9wAp6PxtkK7ufKqq0,3452
+tksheet-7.2.9.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.2.9.dist-info/METADATA,sha256=sNAOmKjkUJ-PKgZ7koeO3rqc0-cJn5_ppeXXDjpJdJ4,6284
+tksheet-7.2.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.2.9.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.2.9.dist-info/RECORD,,

tksheet-7.2.7.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=x_4i9xHuhs0udU1k7z8-4bY0maNfh98XfaGxCktPPKY,2144
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=OTK9av3WkPF3ToXAALsa12TqltEFw_-c3kBUv_MTcok,102189
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=Ie53z5GWbGoUXUiTf0DtoyOadWFbMFXMFwUjM67vetI,40706
-tksheet/main_table.py,sha256=12LMFBbZr_eWJih45tG_RQ2LCZCEPnkWsil4RG0tCJc,327526
-tksheet/other_classes.py,sha256=CDN38ZjKxZro9YOS_g0DjMC82-Mi9udedny4wdd90W0,14347
-tksheet/row_index.py,sha256=Owsa7YKVZc9TY7W5nfs-M0I1RdFvuoyXhpuyCi5kleo,108606
-tksheet/sheet.py,sha256=xMctRdAC9npUPPEMXFfH4qCE_vyrUV7BJFrCumaOmU0,272368
-tksheet/sheet_options.py,sha256=Azo7_-H0e0ssYEoU7Mq_OWy3S-U05rp4_6Q2E2Ffuu8,12262
-tksheet/text_editor.py,sha256=aRm1Y5GfORiEAJthtN1uQ30CT3VoF8mRWvR-SIXPrJU,6548
-tksheet/themes.py,sha256=N9nAj6vcWk4UdcrAakvz2LPbJEJWXdv3j7Om6AnvX5k,14474
-tksheet/top_left_rectangle.py,sha256=o-M6i5NjaJwo60tV-BDP9SbaT1CzQNoPjuoC7p-nb5Q,8436
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=86ubZZElsnQuC6Lv6bW2lt2NhD9wAp6PxtkK7ufKqq0,3452
-tksheet-7.2.7.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.2.7.dist-info/METADATA,sha256=S4tF46fSc18hhRz-8v2P9vJD8M3JtXlRTJRpuH7vQpY,6284
-tksheet-7.2.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.2.7.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.2.7.dist-info/RECORD,,