tksheet 7.1.5__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.5"
+__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,
@@ -687,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,
@@ -1622,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)
         ):
@@ -1679,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(
@@ -1754,7 +1753,7 @@ class ColumnHeaders(tk.Canvas):
             not check_lines
             or self.MT.get_lines_cell_height(
                 self.text_editor.window.get_num_lines() + 1,
-                font=self.PAR.ops.header_font,
+                font=self.text_editor.tktext.cget("font"),
             )
             > curr_height
         ):
@@ -1774,36 +1773,45 @@ class ColumnHeaders(tk.Canvas):
                     )
                     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)
 
@@ -1901,11 +1909,9 @@ 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

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)

tksheet/main_table.py

@@ -49,7 +49,7 @@ from .formatters import (
     try_to_bool,
 )
 from .functions import (
-    consecutive_chunks,
+    consecutive_ranges,
     decompress_load,
     diff_gen,
     diff_list,
@@ -61,6 +61,7 @@ from .functions import (
     get_seq_without_gaps_at_index,
     index_exists,
     insert_items,
+    int_x_iter,
     is_iterable,
     is_type_int,
     len_to_idx,
@@ -960,12 +961,12 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
-                for chunk in consecutive_chunks(sorted(disp_new_idxs.values())):
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
                         0,
-                        chunk[0],
+                        boxst,
                         len(self.row_positions) - 1,
-                        chunk[-1] + 1,
+                        boxend,
                         "columns",
                         run_binding=True,
                     )
@@ -1181,11 +1182,11 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
-                for chunk in consecutive_chunks(sorted(disp_new_idxs.values())):
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
-                        chunk[0],
+                        boxst,
                         0,
-                        chunk[-1] + 1,
+                        boxend,
                         len(self.col_positions) - 1,
                         "rows",
                         run_binding=True,
@@ -1846,7 +1847,6 @@ class MainTable(tk.Canvas):
                                 "rows",
                                 set_current=resel and to_sel >= r + 1 and to_sel < r2,
                             )
-                    break
         elif isinstance(c, int) and r is None and cell is None:
             for item, box in self.get_selection_items(rows=False, cells=False):
                 r1, c1, r2, c2 = box.coords
@@ -1890,7 +1890,6 @@ class MainTable(tk.Canvas):
                                 "columns",
                                 set_current=resel and to_sel >= c + 1 and to_sel < c2,
                             )
-                    break
         elif (isinstance(r, int) and isinstance(c, int) and cell is None) or cell is not None:
             if cell is not None:
                 r, c = cell[0], cell[1]
@@ -1898,7 +1897,6 @@ class MainTable(tk.Canvas):
                 r1, c1, r2, c2 = box.coords
                 if r >= r1 and c >= c1 and r < r2 and c < c2:
                     self.hide_selection_box(item)
-                    break
         if redraw:
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
@@ -1906,7 +1904,51 @@ class MainTable(tk.Canvas):
             try_binding(self.deselection_binding_func, sel_event)
         self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
 
-    def page_UP(self, event=None):
+    def deselect_any(
+        self,
+        rows: Iterator[int] | int | None = None,
+        columns: Iterator[int] | int | None = None,
+        redraw: bool = True,
+    ) -> None:
+        rows = int_x_iter(rows)
+        columns = int_x_iter(columns)
+        if is_iterable(rows) and is_iterable(columns):
+            rows = tuple(consecutive_ranges(sorted(rows)))
+            columns = tuple(consecutive_ranges(sorted(columns)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                hidden = False
+                for rows_st, rows_end in rows:
+                    if hidden:
+                        break
+                    for cols_st, cols_end in columns:
+                        if ((rows_end >= r1 and rows_end <= r2) or (rows_st >= r1 and rows_st < r2)) and (
+                            (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2)
+                        ):
+                            hidden = self.hide_selection_box(item)
+                            break
+        elif is_iterable(rows):
+            rows = tuple(consecutive_ranges(sorted(rows)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                for rows_st, rows_end in rows:
+                    if (rows_end >= r1 and rows_end <= r2) or (rows_st >= r1 and rows_st < r2):
+                        self.hide_selection_box(item)
+                        break
+        elif is_iterable(columns):
+            columns = tuple(consecutive_ranges(sorted(columns)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                for cols_st, cols_end in columns:
+                    if (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2):
+                        self.hide_selection_box(item)
+                        break
+        else:
+            self.deselect()
+        if redraw:
+            self.refresh()
+
+    def page_UP(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto_y = top - height
@@ -1935,7 +1977,7 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def page_DOWN(self, event=None):
+    def page_DOWN(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto = top + height
@@ -1965,7 +2007,7 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def arrowkey_UP(self, event=None):
+    def arrowkey_UP(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -1989,7 +2031,7 @@ class MainTable(tk.Canvas):
                     self.select_cell(r - 1, c)
                     self.see(r - 1, c, keep_xscroll=True, check_cell_visibility=False)
 
-    def arrowkey_DOWN(self, event=None):
+    def arrowkey_DOWN(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -2068,7 +2110,7 @@ class MainTable(tk.Canvas):
                             check_cell_visibility=False,
                         )
 
-    def arrowkey_LEFT(self, event=None):
+    def arrowkey_LEFT(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "columns":
@@ -2100,7 +2142,7 @@ class MainTable(tk.Canvas):
                     self.select_cell(r, c - 1)
                     self.see(r, c - 1, keep_yscroll=True, check_cell_visibility=False)
 
-    def arrowkey_RIGHT(self, event=None):
+    def arrowkey_RIGHT(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -3222,8 +3264,6 @@ class MainTable(tk.Canvas):
 
     def ctrl_mousewheel(self, event):
         if event.delta < 0 or event.num == 5:
-            if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
-                return
             self.zoom_out()
         elif event.delta >= 0 or event.num == 4:
             self.zoom_in()
@@ -3231,16 +3271,22 @@ class MainTable(tk.Canvas):
     def zoom_in(self, event=None):
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] + 1, self.PAR.ops.table_font[2]),
+            (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] + 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] + 1, self.PAR.ops.header_font[2]),
+            "in",
         )
 
     def zoom_out(self, event=None):
+        if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
+            return
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] - 1, self.PAR.ops.table_font[2]),
+            (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] - 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] - 1, self.PAR.ops.header_font[2]),
+            "out",
         )
 
-    def zoom_font(self, table_font: tuple, header_font: tuple):
+    def zoom_font(self, table_font: tuple, index_font: tuple, header_font: tuple, zoom: Literal["in", "out"]) -> None:
         self.saved_column_widths = {}
         self.saved_row_heights = {}
         # should record position prior to change and then see after change
@@ -3262,7 +3308,7 @@ class MainTable(tk.Canvas):
             table_font,
             reset_row_positions=False,
         )
-        self.set_index_font(table_font)
+        self.set_index_font(index_font)
         self.set_header_font(header_font)
         if self.PAR.ops.set_cell_sizes_on_zoom:
             self.set_all_cell_sizes_to_text()
@@ -3290,18 +3336,18 @@ class MainTable(tk.Canvas):
             )
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             self.recreate_all_selection_boxes()
-        self.refresh_open_window_positions()
-        self.RI.refresh_open_window_positions()
-        self.CH.refresh_open_window_positions()
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        self.refresh_open_window_positions(zoom=zoom)
+        self.RI.refresh_open_window_positions(zoom=zoom)
+        self.CH.refresh_open_window_positions(zoom=zoom)
         self.see(
             r,
             c,
             check_cell_visibility=False,
-            redraw=False,
+            redraw=True,
             r_pc=r_pc,
             c_pc=c_pc,
         )
-        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def get_txt_w(self, txt, font=None):
         self.txt_measure_canvas.itemconfig(
@@ -4207,12 +4253,12 @@ class MainTable(tk.Canvas):
         )
         if create_selections:
             self.deselect("all")
-            for chunk in consecutive_chunks(tuple(reversed(column_widths))):
+            for boxst, boxend in consecutive_ranges(tuple(reversed(column_widths))):
                 self.create_selection_box(
                     0,
-                    chunk[0],
+                    boxst,
                     len(self.row_positions) - 1,
-                    chunk[-1] + 1,
+                    boxend,
                     "columns",
                     run_binding=True,
                 )
@@ -4336,11 +4382,11 @@ class MainTable(tk.Canvas):
         )
         if create_selections:
             self.deselect("all")
-            for chunk in consecutive_chunks(tuple(reversed(row_heights))):
+            for boxst, boxend in consecutive_ranges(tuple(reversed(row_heights))):
                 self.create_selection_box(
-                    chunk[0],
+                    boxst,
                     0,
-                    chunk[-1] + 1,
+                    boxend,
                     len(self.col_positions) - 1,
                     "rows",
                     run_binding=True,
@@ -5620,7 +5666,7 @@ class MainTable(tk.Canvas):
             if r2 < len(self.row_positions) and c2 < len(self.col_positions):
                 self.create_selection_box(r1, c1, r2, c2, v, run_binding=True)
         if selected:
-            self.set_currently_selected(selected.row, selected.column, box=selected.coords)
+            self.set_currently_selected(selected.row, selected.column, box=selected.box)
 
     def set_currently_selected(
         self,
@@ -5776,7 +5822,7 @@ class MainTable(tk.Canvas):
             self.hidd_boxes.add(item)
             self.itemconfig(item, state="hidden")
 
-    def hide_selection_box(self, item: int | None, set_current: bool = True) -> None:
+    def hide_selection_box(self, item: int | None, set_current: bool = True) -> bool:
         if item is None:
             return
         box = self.selection_boxes.pop(item)
@@ -5787,6 +5833,7 @@ class MainTable(tk.Canvas):
         if self.selected.fill_iid == item:
             self.hide_selected()
             self.set_current_to_last()
+        return True
 
     def hide_selected(self) -> None:
         if self.selected:
@@ -6372,13 +6419,11 @@ class MainTable(tk.Canvas):
                     extra_func_key = "Return"
                 elif hasattr(event, "keysym") and event.keysym == "F2":
                     extra_func_key = "F2"
-            datarn = r if self.all_rows_displayed else self.displayed_rows[r]
-            datacn = c if self.all_columns_displayed else self.displayed_columns[c]
             if event is not None and (hasattr(event, "keysym") and event.keysym == "BackSpace"):
                 extra_func_key = "BackSpace"
                 text = ""
             else:
-                text = f"{self.get_cell_data(datarn, datacn, none_to_empty_str = True)}"
+                text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         elif event is not None and (
             (hasattr(event, "char") and event.char.isalpha())
             or (hasattr(event, "char") and event.char.isdigit())
@@ -6422,9 +6467,7 @@ class MainTable(tk.Canvas):
         w = self.col_positions[c + 1] - x + 1
         h = self.row_positions[r + 1] - y + 1
         if text is None:
-            text = f"""{self.get_cell_data(r if self.all_rows_displayed else self.displayed_rows[r],
-                                           c if self.all_columns_displayed else self.displayed_columns[c],
-                                           none_to_empty_str = True)}"""
+            text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         bg, fg = self.PAR.ops.table_bg, self.PAR.ops.table_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -6483,7 +6526,14 @@ class MainTable(tk.Canvas):
         curr_height = self.text_editor.window.winfo_height()
         if curr_height < self.min_row_height:
             return
-        if not check_lines or self.get_lines_cell_height(self.text_editor.window.get_num_lines() + 1) > curr_height:
+        if (
+            not check_lines
+            or self.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.table_xtra_lines_increment
             space_bot = self.get_space_bot(r)
             if new_height > space_bot:
@@ -6508,24 +6558,30 @@ class MainTable(tk.Canvas):
                         )
                         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:
             r, c = self.text_editor.coords
             self.text_editor.window.config(height=self.row_positions[r + 1] - self.row_positions[r])
+            self.text_editor.tktext.config(font=self.PAR.ops.table_font)
             self.coords(
                 self.text_editor.canvas_id,
                 self.col_positions[c],
                 self.row_positions[r],
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             r, 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(r, c, text_editor_h)
             else:
-                text_editor_h = self.row_positions[r + 1] - self.row_positions[r]
+                text_editor_h = self.row_positions[r + 1] - self.row_positions[r] + 1
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.col_positions[c + 1] - self.col_positions[c] + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
@@ -6548,7 +6604,6 @@ class MainTable(tk.Canvas):
         if reason == "Escape":
             self.focus_set()
 
-    # c is displayed col
     def close_text_editor(
         self,
         editor_info: tuple | None = None,
@@ -6671,8 +6726,7 @@ class MainTable(tk.Canvas):
     def tab_key(self, event: object = None) -> str:
         if not self.selected:
             return
-        r = self.selected.row
-        c = self.selected.column
+        r, c = self.selected.row, self.selected.column
         r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
         numcols = c2 - c1
         numrows = r2 - r1
@@ -6803,7 +6857,7 @@ class MainTable(tk.Canvas):
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
-            self.itemconfig(self.dropdown.canvas_id, state="normal")
+            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, self.col_positions[c], ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
@@ -7100,7 +7154,12 @@ class MainTable(tk.Canvas):
         self.delete_row_format("all", clear_values=clear_values)
         self.delete_column_format("all", clear_values=clear_values)
 
-    def delete_cell_format(self, datarn: str | int = "all", datacn: int = 0, clear_values: bool = False) -> None:
+    def delete_cell_format(
+        self,
+        datarn: Literal["all"] | int = "all",
+        datacn: int = 0,
+        clear_values: bool = False,
+    ) -> None:
         if isinstance(datarn, str) and datarn.lower() == "all":
             itr = gen_formatted(self.cell_options)
         else:
@@ -7114,7 +7173,7 @@ class MainTable(tk.Canvas):
             if clear_values:
                 self.set_cell_data(*key, get_val(*key), expand_sheet=False)
 
-    def delete_row_format(self, datarn: str | int = "all", clear_values: bool = False) -> None:
+    def delete_row_format(self, datarn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
         if isinstance(datarn, str) and datarn.lower() == "all":
             itr = gen_formatted(self.row_options)
         else:
@@ -7129,7 +7188,7 @@ class MainTable(tk.Canvas):
                 for datacn in range(len(self.data[datarn])):
                     self.set_cell_data(datarn, datacn, get_val(datarn, datacn), expand_sheet=False)
 
-    def delete_column_format(self, datacn: str | int = "all", clear_values: bool = False) -> None:
+    def delete_column_format(self, datacn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
         if isinstance(datacn, str) and datacn.lower() == "all":
             itr = gen_formatted(self.col_options)
         else:

tksheet/row_index.py

@@ -18,6 +18,7 @@ from math import (
     ceil,
     floor,
 )
+from typing import Literal
 
 from .colors import (
     color_map,
@@ -866,6 +867,8 @@ 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.PAR.item(iid, open_=iid not in self.tree_open_ids)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -1014,11 +1017,10 @@ class RowIndex(tk.Canvas):
                     x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
                     start_col, end_col = self.MT.get_visible_columns(x1, x2)
                 else:
-                    start_col, end_col = (
-                        0,
-                        len(self.MT.data[row]) if self.MT.data else 0,
-                    )
-                iterable = range(start_col, end_col)
+                    if not self.MT.data or datarn >= len(self.MT.data):
+                        iterable = range(0, 0)
+                    else:
+                        iterable = range(0, len(self.MT.data[datarn]))
             else:
                 if displayed_only:
                     x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
@@ -1712,8 +1714,7 @@ class RowIndex(tk.Canvas):
                     extra_func_key = "Return"
                 elif hasattr(event, "keysym") and event.keysym == "F2":
                     extra_func_key = "F2"
-            datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
-            text = self.get_cell_data(datarn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datarn(r), 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)
         ):
@@ -1761,9 +1762,8 @@ class RowIndex(tk.Canvas):
         y = self.MT.row_positions[r]
         w = self.current_width + 1
         h = self.MT.row_positions[r + 1] - y + 1
-        datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
         if text is None:
-            text = self.get_cell_data(datarn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datarn(r), none_to_empty_str=True, redirect_int=True)
         bg, fg = self.PAR.ops.index_bg, self.PAR.ops.index_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -1820,7 +1820,7 @@ class RowIndex(tk.Canvas):
             not check_lines
             or self.MT.get_lines_cell_height(
                 self.text_editor.window.get_num_lines() + 1,
-                font=self.PAR.ops.index_font,
+                font=self.text_editor.tktext.cget("font"),
             )
             > curr_height
         ):
@@ -1851,24 +1851,30 @@ class RowIndex(tk.Canvas):
                         )
                         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:
             r = self.text_editor.row
             self.text_editor.window.config(height=self.MT.row_positions[r + 1] - self.MT.row_positions[r])
+            self.text_editor.tktext.config(font=self.PAR.ops.index_font)
             self.coords(
                 self.text_editor.canvas_id,
                 0,
                 self.MT.row_positions[r],
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             r = 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(r, text_editor_h)
             else:
-                text_editor_h = self.MT.row_positions[r + 1] - self.MT.row_positions[r]
+                text_editor_h = self.MT.row_positions[r + 1] - self.MT.row_positions[r] + 1
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.current_width + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
@@ -1956,15 +1962,22 @@ class RowIndex(tk.Canvas):
                 break
         if win_h > 500:
             win_h = 500
-        space_bot = self.MT.get_space_bot(0, text_editor_h)
+        space_bot = self.MT.get_space_bot(r, text_editor_h)
+        space_top = int(self.MT.row_positions[r])
+        anchor = "nw"
         win_h2 = int(win_h)
         if win_h > space_bot:
-            win_h = space_bot - 1
+            if space_bot >= space_top:
+                anchor = "nw"
+                win_h = space_bot - 1
+            elif space_top > space_bot:
+                anchor = "sw"
+                win_h = space_top - 1
         if win_h < self.MT.index_txt_height + 5:
             win_h = self.MT.index_txt_height + 5
         elif win_h > win_h2:
             win_h = win_h2
-        return win_h, "nw"
+        return win_h, anchor
 
     def dropdown_text_editor_modified(
         self,
@@ -1977,17 +1990,21 @@ class RowIndex(tk.Canvas):
         dd_window.search_and_see(event)
 
     # r is displayed row
-    def open_dropdown_window(self, r, datarn=None, event: object = None):
+    def open_dropdown_window(self, r, event: object = None):
         self.hide_text_editor("Escape")
-        if datarn is None:
-            datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown")
+        kwargs = self.get_cell_kwargs(self.MT.datarn(r), key="dropdown")
         if kwargs["state"] == "normal":
             if not self.open_text_editor(event=event, r=r, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(r)
-        win_w = self.current_width
-        ypos = self.MT.row_positions[r + 1]
+        win_w = self.current_width + 1
+        if anchor == "nw":
+            if kwargs["state"] == "normal":
+                ypos = self.MT.row_positions[r] + self.text_editor.window.winfo_height() - 1
+            else:
+                ypos = self.MT.row_positions[r + 1]
+        else:
+            ypos = self.MT.row_positions[r]
         reset_kwargs = {
             "r": r,
             "c": 0,
@@ -2001,7 +2018,7 @@ class RowIndex(tk.Canvas):
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
-            self.itemconfig(self.dropdown.canvas_id, state="normal")
+            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, 0, ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(

tksheet/sheet.py

@@ -1092,6 +1092,14 @@ class Sheet(tk.Frame):
             self.TL.focus_set()
         return self
 
+    def zoom_in(self) -> Sheet:
+        self.MT.zoom_in()
+        return self
+
+    def zoom_out(self) -> Sheet:
+        self.MT.zoom_out()
+        return self
+
     @property
     def event(self) -> EventDataDict:
         return self.last_event_data
@@ -3174,6 +3182,16 @@ class Sheet(tk.Frame):
         self.set_refresh_timer(redraw)
         return self
 
+    def deselect_any(
+        self,
+        rows: Iterator[int] | int | None,
+        columns: Iterator[int] | int | None,
+        redraw: bool = True,
+    ) -> Sheet:
+        self.MT.deselect_any(rows=rows, columns=columns, redraw=False)
+        self.set_refresh_timer(redraw)
+        return self
+
     # Row Heights and Column Widths
 
     def default_column_width(self, width: int | None = None) -> int:
@@ -3777,6 +3795,8 @@ class Sheet(tk.Frame):
         )
         if deselect_all:
             self.MT.deselect(redraw=False)
+        else:
+            self.MT.deselect_any(rows=rows, redraw=False)
         self.set_refresh_timer(redraw)
         return self
 

{tksheet-7.1.5.dist-info → tksheet-7.1.6.dist-info}/METADATA

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

tksheet-7.1.6.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=95JUoulFU3M59S4BSLtmbHtdYN9bUTph238FEb2u0S8,1874
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=2Y5QcT5WmxjXudPszKHcd7hHuTNRfxoRVyKx2bsBGZI,99449
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=OZdcbYcKpiU_2YhwPWASZ8QfyF3tRhGiwY80sh5Rbx4,39610
+tksheet/main_table.py,sha256=ThNsmwC_e2o5nEjB53RvIMLaj3rcWEfASeMtt2TTNl4,321201
+tksheet/other_classes.py,sha256=Hjr7c0kD2_880xjtGuFn9gQ-7ED5kSiNahniBeXcf84,13604
+tksheet/row_index.py,sha256=TsAYN0cBchH-diKzU3fuZXlgTOmrODq8EIeT2RcTblk,104750
+tksheet/sheet.py,sha256=_VotKhIMM1aAUmDNPZC4h0_q6NP-sB4nGRRIZ-iggSc,257417
+tksheet/sheet_options.py,sha256=Vcy4RxTKvf2HM-Yc53ex0lpBe6ATXc_pdx4oLhfjDgU,11906
+tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
+tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
+tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=Iukk7-MMT9X7vv0m3nQPKzbp2Iw2Pg1wJEW7js919Mo,2092
+tksheet-7.1.6.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.1.6.dist-info/METADATA,sha256=2ZtrwFvnlwzpFt9hY_C_Mpf5ghtHjmRPz65pfc5N1xI,6013
+tksheet-7.1.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.1.6.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.1.6.dist-info/RECORD,,

tksheet-7.1.5.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=bzXUATwg31SEbu5F3bS-MFBDpi4MAuMZ0TPh49RAonU,1874
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=9LOi8-Xr7_h0UlF277VDVg_UWQ3UGVwD9fufwq3SbMU,99272
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=PN2qanv32V4Hg221b-999fEH4yxYNoze925txUP5kA4,39245
-tksheet/main_table.py,sha256=QHFqCkCWkiecHBjbiGBJSJ0SoMp2htXBCpkLIMQEeWI,318511
-tksheet/other_classes.py,sha256=Hjr7c0kD2_880xjtGuFn9gQ-7ED5kSiNahniBeXcf84,13604
-tksheet/row_index.py,sha256=ZPBiKNB5NghU_Q-LEqWrC9-VqaVYj__DodenDSR_oeA,103990
-tksheet/sheet.py,sha256=ho4dGIco8GTCJluFZcJhOJNgnJTA_S_dMm-xU4cJPGo,256866
-tksheet/sheet_options.py,sha256=Vcy4RxTKvf2HM-Yc53ex0lpBe6ATXc_pdx4oLhfjDgU,11906
-tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
-tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
-tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=Iukk7-MMT9X7vv0m3nQPKzbp2Iw2Pg1wJEW7js919Mo,2092
-tksheet-7.1.5.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.1.5.dist-info/METADATA,sha256=WBm8p-qBsL207lJ6_tznMJE9Vo62iKaZmj-nmyj-UbE,6013
-tksheet-7.1.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.1.5.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.1.5.dist-info/RECORD,,