tksheet 7.1.4__py3-none-any.whl → 7.1.6__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -13,13 +13,14 @@ from itertools import (
     islice,
 )
 from math import ceil, floor
+from typing import Literal
 
 from .colors import (
     color_map,
 )
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
-    consecutive_chunks,
+    consecutive_ranges,
     ev_stack_dict,
     event_dict,
     get_checkbox_points,
@@ -272,7 +273,9 @@ class ColumnHeaders(tk.Canvas):
                     if self.MT.selected and self.MT.selected.type_ == "columns":
                         r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
                         self.MT.deselect("all", redraw=False)
-                        self.being_drawn_item = self.MT.create_selection_box(*self.get_shift_select_box(c, c_to_sel), "columns")
+                        self.being_drawn_item = self.MT.create_selection_box(
+                            *self.get_shift_select_box(c, c_to_sel), "columns"
+                        )
                         self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
                     else:
                         self.being_drawn_item = self.select_col(c, run_binding_func=False)
@@ -685,10 +688,10 @@ class ColumnHeaders(tk.Canvas):
             tag="move_columns",
         )
         self.MT.create_resize_line(xpos, y1, xpos, y2, width=3, fill=self.PAR.ops.drag_and_drop_bg, tag="move_columns")
-        for chunk in consecutive_chunks(cols):
+        for boxst, boxend in consecutive_ranges(cols):
             self.MT.show_ctrl_outline(
-                start_cell=(chunk[0], 0),
-                end_cell=(chunk[-1] + 1, len(self.MT.row_positions) - 1),
+                start_cell=(boxst, 0),
+                end_cell=(boxend, len(self.MT.row_positions) - 1),
                 dash=(),
                 outline=self.PAR.ops.drag_and_drop_bg,
                 delete_on_timer=False,
@@ -854,8 +857,16 @@ class ColumnHeaders(tk.Canvas):
             ):
                 datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
                 canvasx = self.canvasx(event.x)
-                if self.event_over_dropdown(c, datacn, event, canvasx) or self.event_over_checkbox(
-                    c, datacn, event, canvasx
+                if self.event_over_dropdown(
+                    c,
+                    datacn,
+                    event,
+                    canvasx,
+                ) or self.event_over_checkbox(
+                    c,
+                    datacn,
+                    event,
+                    canvasx,
                 ):
                     self.open_cell(event)
             else:
@@ -970,15 +981,15 @@ class ColumnHeaders(tk.Canvas):
         qconf = self.MT.txt_measure_canvas.itemconfig
         qbbox = self.MT.txt_measure_canvas.bbox
         qtxtm = self.MT.txt_measure_canvas_text
+        qfont = self.PAR.ops.header_font
         new_height = self.MT.min_header_height
         default_header_height = self.MT.get_default_header_height()
         self.fix_header()
         if text is not None:
             if text:
-                qconf(qtxtm, text=text)
+                qconf(qtxtm, text=text, font=qfont)
                 b = qbbox(qtxtm)
-                h = b[3] - b[1] + 5
-                if h > new_height:
+                if (h := b[3] - b[1] + 5) > new_height:
                     new_height = h
         else:
             if self.MT.all_columns_displayed:
@@ -1002,7 +1013,7 @@ class ColumnHeaders(tk.Canvas):
                 for datacn in iterable:
                     txt = self.MT.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
                     if txt:
-                        qconf(qtxtm, text=txt)
+                        qconf(qtxtm, text=txt, font=qfont)
                         b = qbbox(qtxtm)
                         h = b[3] - b[1] + 5
                     else:
@@ -1014,7 +1025,7 @@ class ColumnHeaders(tk.Canvas):
                     if h > new_height:
                         new_height = h
         space_bot = self.MT.get_space_bot(0)
-        if new_height > space_bot:
+        if new_height > space_bot and space_bot > self.MT.min_header_height:
             new_height = space_bot
         if not only_increase or (only_increase and new_height > self.current_height):
             self.set_height(new_height, set_TL=True)
@@ -1612,14 +1623,13 @@ class ColumnHeaders(tk.Canvas):
     ) -> bool:
         text = None
         extra_func_key = "??"
-        datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
         if event is None or self.MT.event_opens_dropdown_or_checkbox(event):
             if event is not None:
                 if hasattr(event, "keysym") and event.keysym == "Return":
                     extra_func_key = "Return"
                 elif hasattr(event, "keysym") and event.keysym == "F2":
                     extra_func_key = "F2"
-            text = self.get_cell_data(datacn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)
         elif event is not None and (
             (hasattr(event, "keysym") and event.keysym == "BackSpace") or event.keycode in (8, 855638143)
         ):
@@ -1669,9 +1679,8 @@ class ColumnHeaders(tk.Canvas):
         y = 0
         w = self.MT.col_positions[c + 1] - x
         h = self.current_height + 1
-        datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
         if text is None:
-            text = self.get_cell_data(datacn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)
         bg, fg = self.PAR.ops.header_bg, self.PAR.ops.header_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -1684,12 +1693,12 @@ class ColumnHeaders(tk.Canvas):
                 }
             ),
             "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.table_selected_cells_border_fg,
+            "border_color": self.PAR.ops.header_selected_columns_bg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
-            "show_border": self.PAR.ops.show_selected_cells_border,
+            "show_border": True,
             "bg": bg,
             "fg": fg,
             "align": self.get_cell_align(c),
@@ -1735,62 +1744,74 @@ class ColumnHeaders(tk.Canvas):
 
     # displayed indexes
     def text_editor_newline_binding(self, r=0, c=0, event: object = None, check_lines=True):
-        if self.height_resizing_enabled:
-            curr_height = self.text_editor.window.winfo_height()
-            if (
-                not check_lines
-                or self.MT.get_lines_cell_height(
-                    self.text_editor.window.get_num_lines() + 1,
-                    font=self.PAR.ops.header_font,
-                )
-                > curr_height
-            ):
-                new_height = curr_height + self.MT.header_xtra_lines_increment
-                space_bot = self.MT.get_space_bot(0)
-                if new_height > space_bot:
-                    new_height = space_bot
-                if new_height != curr_height:
-                    self.text_editor.window.config(height=new_height)
-                    self.set_height(new_height, set_TL=True)
-                    if self.dropdown.open and self.dropdown.get_coords() == c:
-                        win_h, anchor = self.get_dropdown_height_anchor(c, new_height)
-                        self.coords(
-                            self.dropdown.canvas_id,
-                            self.MT.col_positions[c],
-                            new_height - 1,
-                        )
-                        self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
+        if not self.height_resizing_enabled:
+            return
+        curr_height = self.text_editor.window.winfo_height()
+        if curr_height < self.MT.min_header_height:
+            return
+        if (
+            not check_lines
+            or self.MT.get_lines_cell_height(
+                self.text_editor.window.get_num_lines() + 1,
+                font=self.text_editor.tktext.cget("font"),
+            )
+            > curr_height
+        ):
+            new_height = curr_height + self.MT.header_xtra_lines_increment
+            space_bot = self.MT.get_space_bot(0)
+            if new_height > space_bot:
+                new_height = space_bot
+            if new_height != curr_height:
+                self.text_editor.window.config(height=new_height)
+                self.set_height(new_height, set_TL=True)
+                if self.dropdown.open and self.dropdown.get_coords() == c:
+                    win_h, anchor = self.get_dropdown_height_anchor(c, new_height)
+                    self.coords(
+                        self.dropdown.canvas_id,
+                        self.MT.col_positions[c],
+                        new_height - 1,
+                    )
+                    self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def refresh_open_window_positions(self):
+    def refresh_open_window_positions(self, zoom: Literal["in", "out"]):
         if self.text_editor.open:
             c = self.text_editor.column
-            self.text_editor.window.config(height=self.MT.col_positions[c + 1] - self.MT.col_positions[c])
+            self.text_editor.window.config(
+                height=self.current_height,
+                width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1,
+            )
+            self.text_editor.tktext.config(font=self.PAR.ops.header_font)
             self.coords(
                 self.text_editor.canvas_id,
-                0,
                 self.MT.col_positions[c],
+                0,
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             c = self.dropdown.get_coords()
             if self.text_editor.open:
                 text_editor_h = self.text_editor.window.winfo_height()
                 win_h, anchor = self.get_dropdown_height_anchor(c, text_editor_h)
             else:
-                text_editor_h = self.MT.col_positions[c + 1] - self.MT.col_positions[c]
+                text_editor_h = self.current_height
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
-                    0,
-                    self.MT.col_positions[c] + text_editor_h - 1,
+                    self.MT.col_positions[c],
+                    text_editor_h - 1,
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
             elif anchor == "sw":
                 self.coords(
                     self.dropdown.canvas_id,
-                    0,
                     self.MT.col_positions[c],
+                    0,
                 )
                 # self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
@@ -1888,42 +1909,39 @@ class ColumnHeaders(tk.Canvas):
             modified_func(event)
         dd_window.search_and_see(event)
 
-    def open_dropdown_window(self, c, datacn=None, event: object = None):
+    def open_dropdown_window(self, c, event: object = None):
         self.hide_text_editor("Escape")
-        if datacn is None:
-            datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown")
+        kwargs = self.get_cell_kwargs(self.MT.datacn(c), key="dropdown")
         if kwargs["state"] == "normal":
             if not self.open_text_editor(event=event, c=c, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(c)
+        win_w = self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1
         ypos = self.current_height - 1
-        if self.dropdown.window is not None:
-            self.dropdown.window.search_function = kwargs["search_function"]
-            self.dropdown.window.c = c
-            self.dropdown.window.row = -1
-            self.dropdown.window.set_options()
-            self.dropdown.window.values(kwargs["values"])
-            if not self.dropdown.open:
-                self.itemconfig(self.dropdown.canvas_id, state="normal")
+        reset_kwargs = {
+            "r": 0,
+            "c": c,
+            "width": win_w,
+            "height": win_h,
+            "font": self.PAR.ops.header_font,
+            "ops": self.PAR.ops,
+            "outline_color": self.PAR.ops.popup_menu_fg,
+            "align": self.get_cell_align(c),
+            "values": kwargs["values"],
+        }
+        if self.dropdown.window:
+            self.dropdown.window.reset(**reset_kwargs)
+            self.itemconfig(self.dropdown.canvas_id, state="normal")
             self.coords(self.dropdown.canvas_id, self.MT.col_positions[c], ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
-                self.MT.winfo_toplevel(),
-                0,
-                c,
-                width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1,
-                height=win_h,
-                font=self.PAR.ops.header_font,
-                ops=self.PAR.ops,
-                outline_color=self.PAR.ops.popup_menu_fg,
-                values=kwargs["values"],
+                self.winfo_toplevel(),
+                **reset_kwargs,
+                single_index="c",
                 close_dropdown_window=self.close_dropdown_window,
                 search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.MT.arrowkey_RIGHT,
                 arrowkey_LEFT=self.MT.arrowkey_LEFT,
-                align="w",
-                single_index="c",
             )
             self.dropdown.canvas_id = self.create_window(
                 (self.MT.col_positions[c], ypos),

tksheet/functions.py

@@ -245,6 +245,12 @@ def is_iterable(o: object) -> bool:
         return False
 
 
+def int_x_iter(i: Iterator[int] | int) -> Iterator[int]:
+    if isinstance(i, int):
+        return (i,)
+    return i
+
+
 def unpack(t: tuple[object] | tuple[Iterator[object]]) -> tuple[object]:
     if not len(t):
         return t
@@ -345,21 +351,27 @@ def get_seq_without_gaps_at_index(
     return seq
 
 
-def consecutive_chunks(seq: list[object]) -> Generator[object]:
-    if not seq:
-        yield seq
+def consecutive_chunks(seq: list[int]) -> Generator[list[int]]:
     start = 0
-    end = 0
-    for index, value in enumerate(seq):
-        if index < len(seq) - 1:
-            if seq[index + 1] > value + 1:
-                end = index + 1
-                yield seq[start:end]
-                start = end
-        else:
+    for index, value in enumerate(seq, 1):
+        try:
+            if seq[index] > value + 1:
+                yield seq[start:(start := index)]
+        except Exception:
             yield seq[start : len(seq)]
 
 
+def consecutive_ranges(seq: Sequence[int]) -> Generator[tuple[int, int]]:
+    start = 0
+    for index, value in enumerate(seq, 1):
+        try:
+            if seq[index] > value + 1:
+                yield seq[start], seq[index - 1] + 1
+                start = index
+        except Exception:
+            yield seq[start], seq[-1] + 1
+
+
 def is_contiguous(seq: list[int]) -> bool:
     itr = iter(seq)
     prev = next(itr)
@@ -1146,6 +1158,22 @@ def set_readonly(
     return options
 
 
+def convert_align(align: str | None) -> str | None:
+    if isinstance(align, str):
+        a = align.lower()
+        if a == "global":
+            return None
+        elif a in ("c", "center", "centre"):
+            return "center"
+        elif a in ("w", "west", "left"):
+            return "w"
+        elif a in ("e", "east", "right"):
+            return "e"
+    elif align is None:
+        return None
+    raise ValueError("Align must be one of the following values: c, center, w, west, left, e, east, right")
+
+
 def set_align(
     options: dict,
     key: int | tuple[int, int],