tksheet 7.4.11__py3-none-any.whl → 7.4.12__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -1058,44 +1058,6 @@ class ColumnHeaders(tk.Canvas):
             self.MT.run_selection_binding("columns")
         return fill_iid
 
-    def display_box(
-        self,
-        x1: int,
-        y1: int,
-        x2: int,
-        y2: int,
-        fill: str,
-        outline: str,
-        state: str,
-        tags: str | tuple[str],
-        iid: None | int = None,
-    ) -> int:
-        coords = rounded_box_coords(
-            x1,
-            y1,
-            x2,
-            y2,
-            radius=5 if self.ops.rounded_boxes else 0,
-        )
-        if isinstance(iid, int):
-            self.coords(iid, coords)
-            self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
-        else:
-            if self.hidd_boxes:
-                iid = self.hidd_boxes.pop()
-                self.coords(iid, coords)
-                self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
-            else:
-                iid = self.create_polygon(coords, fill=fill, outline=outline, state=state, tags=tags, smooth=True)
-            self.disp_boxes.add(iid)
-        return iid
-
-    def hide_box(self, item: int) -> None:
-        if isinstance(item, int):
-            self.disp_boxes.discard(item)
-            self.hidd_boxes.add(item)
-            self.itemconfig(item, state="hidden")
-
     def get_cell_dimensions(self, datacn: int) -> tuple[int, int]:
         txt = self.cell_str(datacn, fix=False)
         if txt:
@@ -1279,6 +1241,7 @@ class ColumnHeaders(tk.Canvas):
         sel_cols_bg: str,
         selections: dict,
         datacn: int,
+        has_dd: bool,
     ) -> tuple[str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datacn, key="highlight")
@@ -1319,18 +1282,32 @@ class ColumnHeaders(tk.Canvas):
                     sc,
                     self.current_height - 1,
                     fill=fill,
-                    outline=(
-                        self.ops.header_fg
-                        if self.get_cell_kwargs(datacn, key="dropdown") and self.ops.show_dropdown_borders
-                        else ""
-                    ),
+                    outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
                     tag="hi",
                 )
         elif not kwargs:
             if "columns" in selections and c in selections["columns"]:
                 txtfg = self.ops.header_selected_columns_fg
+                redrawn = self.redraw_highlight(
+                    fc + 1,
+                    0,
+                    sc,
+                    self.current_height - 1,
+                    fill=self.ops.header_selected_columns_bg,
+                    outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tag="hi",
+                )
             elif "cells" in selections and c in selections["cells"]:
                 txtfg = self.ops.header_selected_cells_fg
+                redrawn = self.redraw_highlight(
+                    fc + 1,
+                    0,
+                    sc,
+                    self.current_height - 1,
+                    fill=self.ops.header_selected_cells_bg,
+                    outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tag="hi",
+                )
             else:
                 txtfg = self.ops.header_fg
         return txtfg, redrawn
@@ -1559,6 +1536,7 @@ class ColumnHeaders(tk.Canvas):
             cleftgridln = self.MT.col_positions[c]
             crightgridln = self.MT.col_positions[c + 1]
             datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
+            kwargs = self.get_cell_kwargs(datacn, key="dropdown")
             fill, dd_drawn = self.redraw_highlight_get_text_fg(
                 fc=cleftgridln,
                 sc=crightgridln,
@@ -1567,12 +1545,13 @@ class ColumnHeaders(tk.Canvas):
                 sel_cols_bg=sel_cols_bg,
                 selections=selections,
                 datacn=datacn,
+                has_dd=bool(kwargs),
             )
             if datacn in self.cell_options and "align" in self.cell_options[datacn]:
                 align = self.cell_options[datacn]["align"]
             else:
                 align = self.align
-            if kwargs := self.get_cell_kwargs(datacn, key="dropdown"):
+            if kwargs:
                 max_width = crightgridln - cleftgridln - txt_h - 2
                 if align.endswith("w"):
                     draw_x = cleftgridln + 2
@@ -1664,7 +1643,6 @@ class ColumnHeaders(tk.Canvas):
                             anchor=align,
                             state="normal",
                         )
-                    self.tag_raise(iid)
                 else:
                     iid = self.create_text(
                         draw_x,
@@ -1709,6 +1687,7 @@ class ColumnHeaders(tk.Canvas):
                 if showing:
                     self.itemconfig(iid, state="hidden")
                     dct[iid] = False
+        self.tag_raise("t")
         if self.disp_resize_lines:
             self.tag_raise("rw")
         return True
@@ -2314,8 +2293,8 @@ class ColumnHeaders(tk.Canvas):
         kwargs = self.get_cell_kwargs(datacn, key=None, cell=c_ops)
         if "checkbox" in kwargs:
             return False
-        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
-            return kwargs["values"][0]
+        elif "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and kwargs["dropdown"]["values"]:
+            return kwargs["dropdown"]["values"][0]
         else:
             return ""
 

tksheet/functions.py

@@ -9,7 +9,7 @@ from bisect import bisect_left
 from collections import deque
 from collections.abc import Callable, Generator, Hashable, Iterable, Iterator, Sequence
 from difflib import SequenceMatcher
-from itertools import islice, repeat
+from itertools import chain, islice, repeat
 from typing import Any, Literal
 
 from .colors import color_map
@@ -31,34 +31,16 @@ def wrap_text(
     wrap: Literal["", "c", "w"] = "",
     start_line: int = 0,
 ) -> Generator[str]:
-    lines = (match.group() for match in lines_re.finditer(text))
-    current_line = []
     total_lines = 0
     line_width = 0
-
-    if not wrap:
-        for line in lines:
-            line_width = 0
-            current_line = []
-            for char in line:
-                char_width = widths.get(char, char_width_fn(char))
-                line_width += char_width
-                if line_width >= max_width:
-                    break
-                current_line.append(char)
-
-            if total_lines >= start_line:
-                yield "".join(current_line)
-
-            # Count the line whether it's empty or not
-            total_lines += 1
-            if total_lines >= max_lines:
-                return
-
-    elif wrap == "c":
-        for line in lines:
-            for char in line:
-                char_width = widths.get(char, char_width_fn(char))
+    if wrap == "c":
+        current_line = []
+        for match in lines_re.finditer(text):
+            for char in match.group():
+                try:
+                    char_width = widths[char]
+                except KeyError:
+                    char_width = char_width_fn(char)
 
                 # adding char to line would result in wrap
                 if line_width + char_width >= max_width:
@@ -89,11 +71,14 @@ def wrap_text(
             line_width = 0
 
     elif wrap == "w":
-        space_width = widths.get(" ", char_width_fn(" "))
+        try:
+            space_width = widths[" "]
+        except KeyError:
+            space_width = char_width_fn(" ")
+        current_line = []
 
-        for line in lines:
-            words = line.split()
-            for i, word in enumerate(words):
+        for match in lines_re.finditer(text):
+            for i, word in enumerate(match.group().split()):
                 # if we're going to next word and
                 # if a space fits on the end of the current line we add one
                 if i and line_width + space_width < max_width:
@@ -104,8 +89,12 @@ def wrap_text(
                 word_width = 0
                 word_char_widths = []
                 for char in word:
-                    word_char_widths.append((w := widths.get(char, char_width_fn(char))))
-                    word_width += w
+                    try:
+                        char_width = widths[char]
+                    except KeyError:
+                        char_width = char_width_fn(char)
+                    word_char_widths.append(char_width)
+                    word_width += char_width
 
                 # we only wrap by character if the whole word alone wont fit max width
                 # word won't fit at all we resort to char wrapping it
@@ -167,6 +156,28 @@ def wrap_text(
             current_line = []  # Reset for next line
             line_width = 0
 
+    else:
+        for match in lines_re.finditer(text):
+            line_width = 0
+            current_line = []
+            for char in match.group():
+                try:
+                    char_width = widths[char]
+                except KeyError:
+                    char_width = char_width_fn(char)
+                line_width += char_width
+                if line_width >= max_width:
+                    break
+                current_line.append(char)
+
+            if total_lines >= start_line:
+                yield "".join(current_line)
+
+            # Count the line whether it's empty or not
+            total_lines += 1
+            if total_lines >= max_lines:
+                return
+
 
 def get_csv_str_dialect(s: str, delimiters: str) -> csv.Dialect:
     if len(s) > 6000:
@@ -1684,3 +1695,51 @@ def pop_positions(
             save_to[to_pop[i]] = pos
         else:
             yield pos
+
+
+def get_horizontal_gridline_points(
+    left: float,
+    stop: float,
+    positions: list[float],
+    start: int,
+    end: int,
+) -> list[int | float]:
+    return list(
+        chain.from_iterable(
+            (
+                left - 1,
+                positions[r],
+                stop,
+                positions[r],
+                left - 1,
+                positions[r],
+                left - 1,
+                positions[r + 1] if len(positions) - 1 > r else positions[r],
+            )
+            for r in range(start, end)
+        )
+    )
+
+
+def get_vertical_gridline_points(
+    top: float,
+    stop: float,
+    positions: list[float],
+    start: int,
+    end: int,
+) -> list[float]:
+    return list(
+        chain.from_iterable(
+            (
+                positions[c],
+                top - 1,
+                positions[c],
+                stop,
+                positions[c],
+                top - 1,
+                positions[c + 1] if len(positions) - 1 > c else positions[c],
+                top - 1,
+            )
+            for c in range(start, end)
+        )
+    )

tksheet/main_table.py

@@ -60,9 +60,11 @@ from .functions import (
     gen_formatted,
     get_bg_fg,
     get_data_from_clipboard,
+    get_horizontal_gridline_points,
     get_menu_kwargs,
     get_new_indexes,
     get_seq_without_gaps_at_index,
+    get_vertical_gridline_points,
     index_exists,
     insert_items,
     int_x_iter,
@@ -149,6 +151,9 @@ class MainTable(tk.Canvas):
             "<<SelectAll>>": self.select_all,
         }
         self.enabled_bindings = set()
+        self.selection_box_ctr = 0
+        self.disp_selection_fills = set()
+        self.hidd_selection_fills = set()
 
         self.disp_ctrl_outline = {}
         self.disp_text = {}
@@ -2662,58 +2667,37 @@ class MainTable(tk.Canvas):
             self.refresh()
 
     def page_UP(self, event: Any = None) -> None:
-        height = self.winfo_height()
-        top = self.canvasy(0)
-        scrollto_y = max(0, top - height)
+        r, end = self.visible_text_rows
+        if r == end - 1:
+            r = max(0, r - 1)
         if self.PAR.ops.page_up_down_select_row:
-            r = bisect_left(self.row_positions, scrollto_y)
-            if self.selected and self.selected.row == r:
-                r = max(0, r - 1)
             if self.RI.row_selection_enabled and (
-                self.anything_selected(exclude_columns=True, exclude_cells=True) or not self.anything_selected()
+                self.selected and self.selected.type_ == "rows" or not self.anything_selected()
             ):
-                self.RI.select_row(r)
-                self.see(r, 0, keep_xscroll=True, check_cell_visibility=False)
+                self.RI.select_row(r, redraw=False)
             elif (self.single_selection_enabled or self.toggle_selection_enabled) and self.anything_selected(
                 exclude_columns=True, exclude_rows=True
             ):
-                c = next(reversed(self.selection_boxes.values())).coords.from_c
-                self.see(r, c, keep_xscroll=True, check_cell_visibility=False)
-                self.select_cell(r, c)
-        else:
-            args = ("moveto", scrollto_y / (self.row_positions[-1] + 100))
-            self.yview(*args)
-            self.RI.yview(*args)
+                self.select_cell(r, self.selected.column, redraw=False)
+        if not self.see(r, keep_xscroll=True, bottom_right_corner=True):
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
     def page_DOWN(self, event: Any = None) -> None:
-        height = self.winfo_height()
-        top = self.canvasy(0)
-        scrollto = top + height
-        if self.PAR.ops.page_up_down_select_row and self.RI.row_selection_enabled:
-            r = bisect_left(self.row_positions, scrollto) - 1
-            if self.selected and self.selected.row == r:
-                r += 1
-            if r > len(self.row_positions) - 2:
-                r = len(self.row_positions) - 2
+        st, r = self.visible_text_rows
+        r -= 1
+        if st == r:
+            r = min(len(self.row_positions) - 2, r + 1)
+        if self.PAR.ops.page_up_down_select_row:
             if self.RI.row_selection_enabled and (
-                self.anything_selected(exclude_columns=True, exclude_cells=True) or not self.anything_selected()
+                self.selected and self.selected.type_ == "rows" or not self.anything_selected()
             ):
-                self.RI.select_row(r)
-                self.see(r, 0, keep_xscroll=True, check_cell_visibility=False)
+                self.RI.select_row(r, redraw=False)
+
             elif (self.single_selection_enabled or self.toggle_selection_enabled) and self.anything_selected(
                 exclude_columns=True, exclude_rows=True
             ):
-                c = next(reversed(self.selection_boxes.values())).coords.from_c
-                self.see(r, c, keep_xscroll=True, check_cell_visibility=False)
-                self.select_cell(r, c)
-        else:
-            end = self.row_positions[-1]
-            if scrollto > end + 100:
-                scrollto = end
-            args = ("moveto", scrollto / (end + 100))
-            self.yview(*args)
-            self.RI.yview(*args)
+                self.select_cell(r, self.selected.column, redraw=False)
+        if not self.see(r, keep_xscroll=True, bottom_right_corner=False):
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
     def arrowkey_UP(self, event: Any = None) -> None:
@@ -5875,12 +5859,20 @@ class MainTable(tk.Canvas):
         can_width: int | None,
         dont_blend: bool,
         alternate_color: Highlight | None,
+        has_dd: bool = False,
     ) -> tuple[str, bool]:
         redrawn = False
         if (datarn, datacn) in self.progress_bars:
             kwargs = self.progress_bars[(datarn, datacn)]
         else:
-            kwargs = self.get_cell_kwargs(datarn, datacn, key="highlight")
+            if (datarn, datacn) in self.cell_options and "highlight" in self.cell_options[(datarn, datacn)]:
+                kwargs = self.cell_options[(datarn, datacn)]["highlight"]
+            elif datarn in self.row_options and "highlight" in self.row_options[datarn]:
+                kwargs = self.row_options[datarn]["highlight"]
+            elif datacn in self.col_options and "highlight" in self.col_options[datacn]:
+                kwargs = self.col_options[datacn]["highlight"]
+            else:
+                kwargs = {}
         if alt := bool(not kwargs and alternate_color and r % 2):
             kwargs = alternate_color
 
@@ -5942,39 +5934,68 @@ class MainTable(tk.Canvas):
                 txtfg = self.PAR.ops.table_fg if kwargs[1] is None else kwargs[1]
 
             if fill:
-                highlight_fn = partial(
-                    self.redraw_highlight,
-                    x1=fc + 1,
-                    y1=fr + 1,
-                    x2=sc,
-                    y2=sr,
-                    fill=fill,
-                    outline=(
-                        self.PAR.ops.table_fg
-                        if self.get_cell_kwargs(datarn, datacn, key="dropdown") and self.PAR.ops.show_dropdown_borders
-                        else ""
-                    ),
-                )
-                if isinstance(kwargs, ProgressBar):
+                if not isinstance(kwargs, ProgressBar):
+                    redrawn = self.redraw_highlight(
+                        x1=fc + 1,
+                        y1=fr + 1,
+                        x2=sc,
+                        y2=sr,
+                        fill=fill,
+                        outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                        can_width=can_width if (len(kwargs) > 2 and kwargs[2]) else None,
+                        pc=None,
+                    )
+                else:
                     if kwargs.del_when_done and kwargs.percent >= 100:
                         del self.progress_bars[(datarn, datacn)]
                     else:
-                        redrawn = highlight_fn(
+                        redrawn = self.redraw_highlight(
+                            x1=fc + 1,
+                            y1=fr + 1,
+                            x2=sc,
+                            y2=sr,
+                            fill=fill,
+                            outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
                             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"]:
                 txtfg = self.PAR.ops.table_selected_cells_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill=self.PAR.ops.table_selected_cells_bg,
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    can_width=None,
+                    pc=None,
+                )
             elif "rows" in selections and r in selections["rows"]:
                 txtfg = self.PAR.ops.table_selected_rows_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill=self.PAR.ops.table_selected_rows_bg,
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    can_width=None,
+                    pc=None,
+                )
             elif "columns" in selections and c in selections["columns"]:
                 txtfg = self.PAR.ops.table_selected_columns_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill=self.PAR.ops.table_selected_columns_bg,
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    can_width=None,
+                    pc=None,
+                )
             else:
                 txtfg = self.PAR.ops.table_fg
         return txtfg, redrawn
@@ -6257,11 +6278,24 @@ class MainTable(tk.Canvas):
                 else:
                     datacn = c if self.all_columns_displayed else self.displayed_columns[c]
                     cells["datacn"][c] = datacn
-                if kwargs := self.get_cell_kwargs(datarn, datacn, key="dropdown"):
-                    cells["dropdown"][(datarn, datacn)] = kwargs
-                elif kwargs := self.get_cell_kwargs(datarn, datacn, key="checkbox"):
-                    cells["checkbox"][(datarn, datacn)] = kwargs
-                cells[(datarn, datacn)] = self.cell_str(datarn, datacn, get_displayed=True)
+                t = (datarn, datacn)
+
+                # self.get_cell_kwargs not used here to boost performance
+                if t in self.cell_options and "dropdown" in self.cell_options[t]:
+                    cells["dropdown"][t] = self.cell_options[t]["dropdown"]
+                elif datarn in self.row_options and "dropdown" in self.row_options[datarn]:
+                    cells["dropdown"][t] = self.row_options[datarn]["dropdown"]
+                elif datacn in self.col_options and "dropdown" in self.col_options[datacn]:
+                    cells["dropdown"][t] = self.col_options[datacn]["dropdown"]
+                else:
+                    if t in self.cell_options and "checkbox" in self.cell_options[t]:
+                        cells["checkbox"][t] = self.cell_options[t]["checkbox"]
+                    elif datarn in self.row_options and "checkbox" in self.row_options[datarn]:
+                        cells["checkbox"][t] = self.row_options[datarn]["checkbox"]
+                    elif datacn in self.col_options and "checkbox" in self.col_options[datacn]:
+                        cells["checkbox"][t] = self.col_options[datacn]["checkbox"]
+
+                cells[t] = self.cell_str(datarn, datacn, get_displayed=True)
         return cells
 
     def wrap_get_char_w(self, c: str) -> int:
@@ -6346,7 +6380,6 @@ class MainTable(tk.Canvas):
             if changed_w:
                 for widget in (self, self.RI, self.CH, self.TL):
                     widget.update_idletasks()
-                return False
         # important vars
         x_stop = min(last_col_line_pos, scrollpos_right)
         y_stop = min(last_row_line_pos, scrollpos_bot)
@@ -6363,27 +6396,20 @@ class MainTable(tk.Canvas):
             self.disp_dropdown = {}
             self.hidd_checkbox.update(self.disp_checkbox)
             self.disp_checkbox = {}
+            points = []
             # manage horizontal grid lines
             if self.PAR.ops.show_horizontal_grid and row_pos_exists:
                 if self.PAR.ops.horizontal_grid_to_end_of_window:
                     x_grid_stop = scrollpos_right + can_width
                 else:
                     x_grid_stop = x_stop + 1 if last_col_line_pos > scrollpos_right else x_stop - 1
-                self.redraw_gridline(
-                    points=tuple(
-                        chain.from_iterable(
-                            (
-                                scrollpos_left - 1,
-                                self.row_positions[r],
-                                x_grid_stop,
-                                self.row_positions[r],
-                                scrollpos_left - 1,
-                                self.row_positions[r],
-                                scrollpos_left - 1,
-                                self.row_positions[r + 1] if len(self.row_positions) - 1 > r else self.row_positions[r],
-                            )
-                            for r in range(grid_start_row, grid_end_row)
-                        )
+                points.extend(
+                    get_horizontal_gridline_points(
+                        left=scrollpos_left,
+                        stop=x_grid_stop,
+                        positions=self.row_positions,
+                        start=grid_start_row,
+                        end=grid_end_row,
                     )
                 )
             # manage vertical grid lines
@@ -6392,23 +6418,20 @@ class MainTable(tk.Canvas):
                     y_grid_stop = scrollpos_bot + can_height
                 else:
                     y_grid_stop = y_stop + 1 if last_row_line_pos > scrollpos_bot else y_stop - 1
-                self.redraw_gridline(
-                    points=tuple(
-                        chain.from_iterable(
-                            (
-                                self.col_positions[c],
-                                scrollpos_top - 1,
-                                self.col_positions[c],
-                                y_grid_stop,
-                                self.col_positions[c],
-                                scrollpos_top - 1,
-                                self.col_positions[c + 1] if len(self.col_positions) - 1 > c else self.col_positions[c],
-                                scrollpos_top - 1,
-                            )
-                            for c in range(grid_start_col, grid_end_col)
-                        )
-                    ),
+                if self.PAR.ops.show_horizontal_grid:
+                    points.extend([scrollpos_left - 2, grid_end_row, grid_start_col - 2, scrollpos_top - 2])
+                points.extend(
+                    get_vertical_gridline_points(
+                        top=scrollpos_top,
+                        stop=y_grid_stop,
+                        positions=self.col_positions,
+                        start=grid_start_col,
+                        end=grid_end_col,
+                    )
                 )
+            if points:
+                self.redraw_gridline(points)
+
             font = self.PAR.ops.table_font
             dd_coords = self.dropdown.get_coords()
             selections = self.get_redraw_selections(text_start_row, grid_end_row, text_start_col, grid_end_col)
@@ -6454,6 +6477,8 @@ class MainTable(tk.Canvas):
                     cleftgridln = self.col_positions[c]
                     crightgridln = self.col_positions[c + 1]
                     datacn = cells["datacn"][c]
+                    t = (datarn, datacn)
+
                     fill, dd_drawn = self.redraw_highlight_get_text_fg(
                         r=r,
                         c=c,
@@ -6470,11 +6495,19 @@ class MainTable(tk.Canvas):
                         can_width=can_width,
                         dont_blend=(r, c) == dont_blend,
                         alternate_color=alternate_color,
+                        has_dd=t in cells["dropdown"],
                     )
-                    if not (align := self.get_cell_kwargs(datarn, datacn, key="align")):
+                    if t in self.cell_options and "align" in self.cell_options[(datarn, datacn)]:
+                        align = self.cell_options[(datarn, datacn)]["align"]
+                    elif datarn in self.row_options and "align" in self.row_options[datarn]:
+                        align = self.row_options[datarn]["align"]
+                    elif datacn in self.col_options and "align" in self.col_options[datacn]:
+                        align = self.col_options[datacn]["align"]
+                    else:
                         align = self.align
 
-                    if kwargs := cells["dropdown"].get((datarn, datacn), None):
+                    kws = cells["dropdown"][t] if t in cells["dropdown"] else None  # noqa: SIM401
+                    if kws:
                         max_width = crightgridln - cleftgridln - self.table_txt_height - 5
                         if align.endswith("w"):
                             draw_x = cleftgridln + 2
@@ -6487,7 +6520,7 @@ class MainTable(tk.Canvas):
                             rtopgridln,
                             crightgridln,
                             self.row_positions[r + 1],
-                            fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
+                            fill=fill if kws["state"] != "disabled" else self.PAR.ops.table_grid_fg,
                             outline=fill,
                             draw_outline=not dd_drawn,
                             draw_arrow=max_width >= 5,
@@ -6502,9 +6535,8 @@ class MainTable(tk.Canvas):
                         elif align.endswith("n"):
                             draw_x = cleftgridln + floor((crightgridln - cleftgridln) / 2)
 
-                        if (
-                            kwargs := cells["checkbox"].get((datarn, datacn), None)
-                        ) and max_width > self.table_txt_height + 1:
+                        kws = cells["checkbox"][t] if t in cells["checkbox"] else None  # noqa: SIM401
+                        if kws and max_width > self.table_txt_height + 1:
                             box_w = self.table_txt_height + 1
                             if align.endswith("w"):
                                 draw_x += box_w + 3
@@ -6520,11 +6552,11 @@ class MainTable(tk.Canvas):
                                 rtopgridln + 2,
                                 cleftgridln + self.table_txt_height + 3,
                                 rtopgridln + self.table_txt_height + 3,
-                                fill=fill if kwargs["state"] == "normal" else self.PAR.ops.table_grid_fg,
+                                fill=fill if kws["state"] == "normal" else self.PAR.ops.table_grid_fg,
                                 outline="",
                                 draw_check=draw_check,
                             )
-                    text = cells[(datarn, datacn)]
+                    text = cells[t]
                     if (
                         not text
                         or (align.endswith("w") and draw_x > scrollpos_right)
@@ -6532,7 +6564,7 @@ class MainTable(tk.Canvas):
                         or (align.endswith("n") and cleftgridln + 5 > scrollpos_right)
                     ):
                         continue
-                    if allow_overflow and not kwargs:
+                    if allow_overflow and not kws:
                         if align.endswith("w"):
                             max_width += sum(self._overflow(cells, range(c + 1, text_end_col), datarn))
                         elif align.endswith("e"):
@@ -6573,7 +6605,6 @@ class MainTable(tk.Canvas):
                                     anchor=align,
                                     state="normal",
                                 )
-                            self.tag_raise(iid)
                         else:
                             iid = self.create_text(
                                 draw_x,
@@ -6608,7 +6639,6 @@ class MainTable(tk.Canvas):
                                         anchor=align,
                                         state="normal",
                                     )
-                                self.tag_raise(iid)
                             else:
                                 iid = self.create_text(
                                     draw_x,
@@ -6638,6 +6668,7 @@ class MainTable(tk.Canvas):
                         self.tag_raise(box.bd_iid)
                 if self.selected:
                     self.tag_raise(self.selected.iid)
+            self.tag_raise("t")
             if self.RI.disp_resize_lines:
                 self.tag_raise("rh")
             if self.CH.disp_resize_lines:
@@ -6772,26 +6803,20 @@ class MainTable(tk.Canvas):
         c: int,
         type_: Literal["cells", "rows", "columns"],
         fill_iid: int,
-        lower_selection_boxes: bool = True,
     ) -> int:
-        fill, outline = self.get_selected_box_bg_fg(type_=type_)
+        _, outline = self.get_selected_box_bg_fg(type_=type_)
         x1 = self.col_positions[c] + 1
         y1 = self.row_positions[r] + 1
         x2 = self.col_positions[c + 1] if index_exists(self.col_positions, c + 1) else self.col_positions[c] + 1
         y2 = self.row_positions[r + 1] if index_exists(self.row_positions, r + 1) else self.row_positions[r] + 1
         self.hide_selected()
-        if self.PAR.ops.show_selected_cells_border:
-            fill = ""
-        else:
-            fill = outline
-            outline = ""
         iid = self.display_box(
             x1,
             y1,
             x2,
             y2,
-            fill=fill,
-            outline=outline,
+            fill="",
+            outline=outline if self.PAR.ops.show_selected_cells_border else "",
             state="normal",
             tags="selected",
             width=2,
@@ -6804,8 +6829,6 @@ class MainTable(tk.Canvas):
             iid=iid,
             fill_iid=fill_iid,
         )
-        if lower_selection_boxes:
-            self.lower_selection_boxes()
         return iid
 
     def display_box(
@@ -6856,14 +6879,17 @@ class MainTable(tk.Canvas):
             self.hidd_boxes.add(item)
             self.itemconfig(item, state="hidden")
 
+    def hide_box_fill(self, item: int | None) -> None:
+        if isinstance(item, int):
+            self.disp_selection_fills.discard(item)
+            self.hidd_selection_fills.add(item)
+
     def hide_selection_box(self, item: int | None) -> bool:
         if item is None or item is True or item not in self.selection_boxes:
             return False
         box = self.selection_boxes.pop(item)
-        self.hide_box(box.fill_iid)
+        self.hide_box_fill(box.fill_iid)
         self.hide_box(box.bd_iid)
-        self.RI.hide_box(box.index)
-        self.CH.hide_box(box.header)
         if self.selected.fill_iid == item:
             self.hide_selected()
             self.set_current_to_last()
@@ -6880,6 +6906,15 @@ class MainTable(tk.Canvas):
             self.hide_box(self.selected.iid)
             self.selected = ()
 
+    def get_selection_fill(self) -> int:
+        if self.hidd_selection_fills:
+            iid = self.hidd_selection_fills.pop()
+        else:
+            self.selection_box_ctr += 1
+            iid = self.selection_box_ctr
+        self.disp_selection_fills.add(iid)
+        return iid
+
     def create_selection_box(
         self,
         r1: int,
@@ -6899,52 +6934,35 @@ class MainTable(tk.Canvas):
             r1 = 0
             r2 = 0
         if type_ == "cells":
-            mt_bg = self.PAR.ops.table_selected_cells_bg
             mt_border_col = self.PAR.ops.table_selected_cells_border_fg
         elif type_ == "rows":
-            mt_bg = self.PAR.ops.table_selected_rows_bg
             mt_border_col = self.PAR.ops.table_selected_rows_border_fg
         elif type_ == "columns":
-            mt_bg = self.PAR.ops.table_selected_columns_bg
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if self.selection_boxes:
-            self.itemconfig(next(reversed(self.selection_boxes)), state="normal")
+            next(reversed(self.selection_boxes.values())).state = "normal"
         x1, y1, x2, y2 = self.box_coords_x_canvas_coords(r1, c1, r2, c2, type_)
-        fill_iid = self.display_box(
-            x1,
-            y1,
-            x2,
-            y2,
-            fill=mt_bg,
-            outline="",
-            state=state if self.PAR.ops.show_selected_cells_border else "normal",
-            tags=type_,
-            width=1,
-        )
-        index_iid = self.RI.display_box(
-            0,
-            y1,
-            self.RI.current_width - 1,
-            y2,
-            fill=self.PAR.ops.index_selected_rows_bg if type_ == "rows" else self.PAR.ops.index_selected_cells_bg,
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "columns" else type_,
-        )
-        header_iid = self.CH.display_box(
-            x1,
-            0,
-            self.col_positions[c2],
-            self.CH.current_height - 1,
-            fill=(
-                self.PAR.ops.header_selected_columns_bg if type_ == "columns" else self.PAR.ops.header_selected_cells_bg
-            ),
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "rows" else type_,
-        )
+        fill_iid = self.get_selection_fill()
         bd_iid = None
-        if self.PAR.ops.show_selected_cells_border and (
+        # fill might not display if canvas is wider than 32k pixels
+        if self.PAR.ops.selected_rows_to_end_of_window and type_ == "rows":
+            bd_iid = self.display_box(
+                x1,
+                y1,
+                x2,
+                y2,
+                fill=self.PAR.ops.table_selected_rows_bg,
+                outline=""
+                if self.PAR.name == "!SheetDropdown"
+                else mt_border_col
+                if self.PAR.ops.show_selected_cells_border
+                else "",
+                state="normal",
+                tags=f"{type_}bd",
+                width=1,
+            )
+            self.tag_lower(bd_iid)
+        elif self.PAR.ops.show_selected_cells_border and (
             ext
             or self.ctrl_b1_pressed
             or (self.being_drawn_item is None and self.RI.being_drawn_item is None and self.CH.being_drawn_item is None)
@@ -6964,10 +6982,11 @@ class MainTable(tk.Canvas):
         self.selection_boxes[fill_iid] = SelectionBox(
             fill_iid=fill_iid,
             bd_iid=bd_iid,
-            index=index_iid,
-            header=header_iid,
+            index=fill_iid,
+            header=fill_iid,
             coords=Box_nt(r1, c1, r2, c2),
             type_=type_,
+            state=state,
         )
         if set_current:
             if set_current is True:
@@ -6976,26 +6995,11 @@ class MainTable(tk.Canvas):
             elif isinstance(set_current, tuple):
                 curr_r = set_current[0]
                 curr_c = set_current[1]
-            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid, lower_selection_boxes=False)
-        self.lower_selection_boxes()
+            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid)
         if run_binding:
             self.run_selection_binding(type_)
         return fill_iid
 
-    def lower_selection_boxes(self) -> None:
-        if self.selected:
-            if not self.PAR.ops.show_selected_cells_border:
-                self.tag_lower(self.selected.iid)
-            self.tag_lower("rows")
-            self.tag_lower("columns")
-            self.tag_lower("cells")
-            self.RI.tag_lower("rows")
-            self.RI.tag_lower("cells")
-            self.CH.tag_lower("columns")
-            self.CH.tag_lower("cells")
-            if self.PAR.ops.show_selected_cells_border:
-                self.tag_raise(self.selected.iid)
-
     def box_coords_x_canvas_coords(
         self,
         r1: int,
@@ -7026,13 +7030,10 @@ class MainTable(tk.Canvas):
         type_ = self.selection_boxes[fill_iid].type_
         self.selection_boxes[fill_iid].coords = Box_nt(r1, c1, r2, c2)
         if type_ == "cells":
-            mt_bg = self.PAR.ops.table_selected_cells_bg
             mt_border_col = self.PAR.ops.table_selected_cells_border_fg
         elif type_ == "rows":
-            mt_bg = self.PAR.ops.table_selected_rows_bg
             mt_border_col = self.PAR.ops.table_selected_rows_border_fg
         elif type_ == "columns":
-            mt_bg = self.PAR.ops.table_selected_columns_bg
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if not state:
             if r2 - r1 > 1 or c2 - c1 > 1:
@@ -7044,31 +7045,7 @@ class MainTable(tk.Canvas):
         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_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(
-            0,
-            y1,
-            self.RI.current_width - 1,
-            y2,
-            fill=self.PAR.ops.index_selected_rows_bg if type_ == "rows" else self.PAR.ops.index_selected_cells_bg,
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "columns" else type_,
-            iid=self.selection_boxes[fill_iid].index,
-        )
-        self.CH.display_box(
-            x1,
-            0,
-            self.col_positions[c2],
-            self.CH.current_height - 1,
-            fill=(
-                self.PAR.ops.header_selected_columns_bg if type_ == "columns" else self.PAR.ops.header_selected_cells_bg
-            ),
-            outline="",
-            state="normal",
-            tags="cells" if type_ == "rows" else type_,
-            iid=self.selection_boxes[fill_iid].header,
-        )
+        self.selection_boxes[fill_iid].state = state
         if bd_iid := self.selection_boxes[fill_iid].bd_iid:
             if self.PAR.ops.show_selected_cells_border:
                 self.display_box(
@@ -7142,19 +7119,20 @@ class MainTable(tk.Canvas):
         d = defaultdict(set)
         for _, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
-            if box.type_ == "cells":
-                for r in range(startr, endr):
+            if box.state == "normal":
+                if box.type_ == "cells":
+                    for r in range(startr, endr):
+                        for c in range(startc, endc):
+                            if r1 <= r and c1 <= c and r2 > r and c2 > c:
+                                d["cells"].add((r, c))
+                elif box.type_ == "rows":
+                    for r in range(startr, endr):
+                        if r1 <= r and r2 > r:
+                            d["rows"].add(r)
+                elif box.type_ == "columns":
                     for c in range(startc, endc):
-                        if r1 <= r and c1 <= c and r2 > r and c2 > c:
-                            d["cells"].add((r, c))
-            elif box.type_ == "rows":
-                for r in range(startr, endr):
-                    if r1 <= r and r2 > r:
-                        d["rows"].add(r)
-            elif box.type_ == "columns":
-                for c in range(startc, endc):
-                    if c1 <= c and c2 > c:
-                        d["columns"].add(c)
+                        if c1 <= c and c2 > c:
+                            d["columns"].add(c)
         return d
 
     def get_selected_min_max(self) -> tuple[int, int, int, int] | tuple[None, None, None, None]:
@@ -8001,8 +7979,8 @@ class MainTable(tk.Canvas):
         )
         if "checkbox" in kwargs:
             return False
-        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
-            return kwargs["values"][0]
+        elif "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and kwargs["dropdown"]["values"]:
+            return kwargs["dropdown"]["values"][0]
         else:
             return ""
 
@@ -8168,7 +8146,7 @@ class MainTable(tk.Canvas):
         elif "format" in kwargs:
             return True
         elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty, check_fmt=False) or (
-            (dropdown := kwargs.get("dropdown", {})) and dropdown["validate_input"] and value not in dropdown["values"]
+            "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and value not in kwargs["dropdown"]["values"]
         ):
             return False
         elif "checkbox" in kwargs:

tksheet/other_classes.py

@@ -40,7 +40,7 @@ DraggedRowColumn = namedtuple("DraggedRowColumn", "dragged to_move")
 
 
 class SelectionBox:
-    __slots__ = ("fill_iid", "bd_iid", "index", "header", "coords", "type_")
+    __slots__ = ("fill_iid", "bd_iid", "index", "header", "coords", "type_", "state")
 
     def __init__(
         self,
@@ -50,6 +50,7 @@ class SelectionBox:
         header: int | None = None,
         coords: tuple[int, int, int, int] = None,
         type_: Literal["cells", "rows", "columns"] = "cells",
+        state: Literal["normal", "hidden"] = "normal",
     ) -> None:
         self.fill_iid = fill_iid
         self.bd_iid = bd_iid
@@ -57,6 +58,7 @@ class SelectionBox:
         self.header = header
         self.coords = coords
         self.type_ = type_
+        self.state = state
 
 
 Selected = namedtuple(

tksheet/row_index.py

@@ -1054,51 +1054,6 @@ class RowIndex(tk.Canvas):
             self.MT.run_selection_binding("rows")
         return fill_iid
 
-    def display_box(
-        self,
-        x1: int,
-        y1: int,
-        x2: int,
-        y2: int,
-        fill: str,
-        outline: str,
-        state: str,
-        tags: str | tuple[str],
-        iid: None | int = None,
-    ) -> int:
-        coords = rounded_box_coords(
-            x1,
-            y1,
-            x2,
-            y2,
-            radius=5 if self.ops.rounded_boxes else 0,
-        )
-        if isinstance(iid, int):
-            self.coords(iid, coords)
-            self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
-        else:
-            if self.hidd_boxes:
-                iid = self.hidd_boxes.pop()
-                self.coords(iid, coords)
-                self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags)
-            else:
-                iid = self.create_polygon(
-                    coords,
-                    fill=fill,
-                    outline=outline,
-                    state=state,
-                    tags=tags,
-                    smooth=True,
-                )
-            self.disp_boxes.add(iid)
-        return iid
-
-    def hide_box(self, item: int | None) -> None:
-        if isinstance(item, int):
-            self.disp_boxes.discard(item)
-            self.hidd_boxes.add(item)
-            self.itemconfig(item, state="hidden")
-
     def get_cell_dimensions(self, datarn: int) -> tuple[int, int]:
         txt = self.cell_str(datarn, fix=False)
         if txt:
@@ -1308,6 +1263,7 @@ class RowIndex(tk.Canvas):
         sel_rows_bg: str,
         selections: dict,
         datarn: int,
+        has_dd: bool,
     ) -> tuple[str, str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datarn, key="highlight")
@@ -1348,11 +1304,7 @@ class RowIndex(tk.Canvas):
                     self.current_width - 1,
                     sr,
                     fill=fill,
-                    outline=(
-                        self.ops.index_fg
-                        if self.get_cell_kwargs(datarn, key="dropdown") and self.ops.show_dropdown_borders
-                        else ""
-                    ),
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
                     tag="s",
                 )
             tree_arrow_fg = txtfg
@@ -1360,9 +1312,27 @@ class RowIndex(tk.Canvas):
             if "rows" in selections and r in selections["rows"]:
                 txtfg = self.ops.index_selected_rows_fg
                 tree_arrow_fg = self.ops.selected_rows_tree_arrow_fg
+                redrawn = self.redraw_highlight(
+                    0,
+                    fr + 1,
+                    self.current_width - 1,
+                    sr,
+                    fill=self.ops.index_selected_rows_bg,
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tag="s",
+                )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = self.ops.index_selected_cells_fg
                 tree_arrow_fg = self.ops.selected_cells_tree_arrow_fg
+                redrawn = self.redraw_highlight(
+                    0,
+                    fr + 1,
+                    self.current_width - 1,
+                    sr,
+                    fill=self.ops.index_selected_cells_bg,
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tag="s",
+                )
             else:
                 txtfg = self.ops.index_fg
                 tree_arrow_fg = self.ops.tree_arrow_fg
@@ -1686,6 +1656,7 @@ class RowIndex(tk.Canvas):
                 continue
             checkbox_kwargs = {}
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
+            dropdown_kwargs = self.get_cell_kwargs(datarn, key="dropdown")
             fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
                 fr=rtopgridln,
                 sr=rbotgridln,
@@ -1694,12 +1665,14 @@ class RowIndex(tk.Canvas):
                 sel_rows_bg=sel_rows_bg,
                 selections=selections,
                 datarn=datarn,
+                has_dd=bool(dropdown_kwargs),
             )
+
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
             else:
                 align = self.align
-            if dropdown_kwargs := self.get_cell_kwargs(datarn, key="dropdown"):
+            if dropdown_kwargs:
                 max_width = self.current_width - self.MT.index_txt_height - 2
                 if align.endswith("w"):
                     draw_x = 3
@@ -1811,7 +1784,6 @@ class RowIndex(tk.Canvas):
                             anchor=align,
                             state="normal",
                         )
-                    self.tag_raise(iid)
                 else:
                     iid = self.create_text(
                         draw_x,
@@ -1845,7 +1817,6 @@ class RowIndex(tk.Canvas):
                                 anchor=align,
                                 state="normal",
                             )
-                        self.tag_raise(iid)
                     else:
                         iid = self.create_text(
                             draw_x,
@@ -1898,6 +1869,7 @@ class RowIndex(tk.Canvas):
                 if showing:
                     self.itemconfig(iid, state="hidden")
                     dct[iid] = False
+        self.tag_raise("t")
         if self.disp_resize_lines:
             self.tag_raise("rh")
         return True
@@ -2505,8 +2477,8 @@ class RowIndex(tk.Canvas):
         kwargs = self.get_cell_kwargs(datarn, key=None, cell=r_ops)
         if "checkbox" in kwargs:
             return False
-        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
-            return kwargs["values"][0]
+        elif "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and kwargs["dropdown"]["values"]:
+            return kwargs["dropdown"]["values"][0]
         else:
             return ""
 
@@ -2760,7 +2732,7 @@ class RowIndex(tk.Canvas):
                 if new_loc_is_displayed:
                     if disp_insert_row is None:
                         if new_parent or insert_row > move_to_row:
-                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1
+                            disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1  # TODO: maybe issues here
                         else:
                             disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
                     if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:

{tksheet-7.4.11.dist-info → tksheet-7.4.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tksheet
-Version: 7.4.11
+Version: 7.4.12
 Summary: Tkinter table / sheet and treeview widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -63,11 +63,11 @@ License-File: LICENSE.txt
   <tbody>
     <tr>
       <td style="color: LightCoral">Versions 6.x.x &#8594;</td>
-      <td><a href="https://github.com/ragardner/tksheet/wiki/Version-6">Documentation Wiki</a></td>
+      <td><a href="https://github.com/ragardner/tksheet/wiki/Version-6">Documentation</a></td>
     </tr>
     <tr>
       <td style="color: lightgreen">Versions 7.x.x &#8594;</td>
-      <td><a href="https://github.com/ragardner/tksheet/wiki/Version-7">Documentation Wiki</a></td>
+      <td><a href="https://ragardner.github.io/tksheet/DOCUMENTATION.html">Documentation</a></td>
     </tr>
     <tr>
       <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/blob/master/docs/CHANGELOG.md">Changelog</a></td>

{tksheet-7.4.11.dist-info → tksheet-7.4.12.dist-info}/RECORD

@@ -1,13 +1,13 @@
-tksheet/__init__.py,sha256=1b9l4y5i0jLE4wVnad_Xu_WSHysrpf1dhK8uTjBH734,2327
+tksheet/__init__.py,sha256=6B6RTt5-41j4-VcGxzbvcO6Ggfd56Ooy0GwxL_kfLhI,2327
 tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
-tksheet/column_headers.py,sha256=tCIjq9sv5MfOfhC1hXzWU20RO1icdox1AvlYIESIQl4,103215
+tksheet/column_headers.py,sha256=CIQwGNY0PSWb8q3Yl5lOBCGckZ83BDefFH1e4qKoLfs,102720
 tksheet/constants.py,sha256=aiDvUSaPtl_TSNtRRJ_p87c9iTBz9ksMd5IsSXzz4Hk,13316
 tksheet/find_window.py,sha256=TvbSqO42cw1o1AO0tQ0Q1iZogouNr4ObMo7JfkZCxgA,19877
 tksheet/formatters.py,sha256=DGcRiMsDJnySNpQcjfiX84oJ7TmOSMdU6u9injIhA4g,10095
-tksheet/functions.py,sha256=Lfo605jYI87KLWo6okQhfUlr-c93ZxuOR5VJKCNY6UM,51019
-tksheet/main_table.py,sha256=0vArmPujf0Q8NI2GYDShp8Qys4A9qQ0dlru9Wg-fYlQ,363942
-tksheet/other_classes.py,sha256=pe9_Cj6d3rdeMif9nGvUz0MEUChf0l4d669RNqcNhY4,16578
-tksheet/row_index.py,sha256=_lCilwJfc5Eem22S7WZH_85zWQGGLGMa1upHUGCj_Y0,140328
+tksheet/functions.py,sha256=Ffw6yDHj83oubcp4P9VCQhTRWtGkMI2CBob4JFld91E,52567
+tksheet/main_table.py,sha256=40MAVfBxQ6FycJcuqm9ZsMOjVYKWhISjht3FFZ-UQOI,363608
+tksheet/other_classes.py,sha256=g6LYYHXO9RMy2mN_e-HmGa3Wuzhdxt5voO8-Ug19_Ag,16671
+tksheet/row_index.py,sha256=2aiADtsPskfHZeU0JK7fD4kZm-25ooSjO3mguG9vTM4,139671
 tksheet/sheet.py,sha256=ZgryLoqfkm2vtJDIVhXAvSUQ8G7TXztiID8Ftt3V2qo,269531
 tksheet/sheet_options.py,sha256=ob-XYgGfBoi2TaFAvUUmlWUkw9xB-yXmJw17gu9__Lw,9948
 tksheet/sorting.py,sha256=zcZPpRtP1h_xJGtGkG3E43H7deKQFnh9cMwZ1B2-aGc,17502
@@ -15,8 +15,8 @@ tksheet/text_editor.py,sha256=rU8Fz0-ltkM63W9io2DoZJPyzUGzCc9Z0qBtc4D1H40,7404
 tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
 tksheet/tksheet_types.py,sha256=1MjXR34EmvP1KfHlLTvKKVnf0VMz_LU_WOM2q4o5hfI,4598
 tksheet/top_left_rectangle.py,sha256=M52IrPIeMoYE3jSpooZmqw_0W5Fz_R-Yu1ZqA685EZ8,8557
-tksheet-7.4.11.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.4.11.dist-info/METADATA,sha256=-oNnevhplE5S5kakZod7QpcSOb4RQUf8ZTrSTVXNoKs,8006
-tksheet-7.4.11.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-tksheet-7.4.11.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.4.11.dist-info/RECORD,,
+tksheet-7.4.12.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.4.12.dist-info/METADATA,sha256=0WsLK9P5f8h788tKDhCSQjtYad1UD9mDmIOuFz7eNjE,7999
+tksheet-7.4.12.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+tksheet-7.4.12.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.4.12.dist-info/RECORD,,

{tksheet-7.4.11.dist-info → tksheet-7.4.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any