tksheet 7.2.22__py3-none-any.whl → 7.3.0__py3-none-any.whl

tksheet/main_table.py

@@ -59,6 +59,7 @@ from .functions import (
     diff_list,
     down_cell_within_box,
     event_dict,
+    float_to_int,
     gen_formatted,
     get_data_from_clipboard,
     get_new_indexes,
@@ -257,8 +258,6 @@ class MainTable(tk.Canvas):
         self.rc_insert_row_enabled = False
         self.rc_popup_menus_enabled = False
         self.edit_cell_enabled = False
-        self.new_row_width = 0
-        self.new_header_height = 0
         self.CH = kwargs["column_headers_canvas"]
         self.CH.MT = self
         self.CH.RI = kwargs["row_index_canvas"]
@@ -297,11 +296,6 @@ class MainTable(tk.Canvas):
         self.txt_measure_canvas = tk.Canvas(self)
         self.txt_measure_canvas_text = self.txt_measure_canvas.create_text(0, 0, text="", font=self.PAR.ops.table_font)
 
-        self.max_row_height = float(kwargs["max_row_height"])
-        self.max_index_width = float(kwargs["max_index_width"])
-        self.max_column_width = float(kwargs["max_column_width"])
-        self.max_header_height = float(kwargs["max_header_height"])
-
         self.RI.set_width(self.PAR.ops.default_row_index_width)
         self.set_table_font_help()
         self.set_header_font_help()
@@ -1514,25 +1508,49 @@ class MainTable(tk.Canvas):
             self.purge_redo_stack()
 
     def edit_cells_using_modification(self, modification: dict, event_data: dict) -> EventDataDict:
+        # row index
         if self.PAR.ops.treeview:
             for datarn, v in modification["cells"]["index"].items():
-                self._row_index[datarn].text = v
+                if not self.edit_validation_func or (
+                    self.edit_validation_func
+                    and (v := self.edit_validation_func(mod_event_val(event_data, v, row=datarn))) is not None
+                ):
+                    self._row_index[datarn].text = v
         else:
             for datarn, v in modification["cells"]["index"].items():
-                self._row_index[datarn] = v
+                if not self.edit_validation_func or (
+                    self.edit_validation_func
+                    and (v := self.edit_validation_func(mod_event_val(event_data, v, row=datarn))) is not None
+                ):
+                    self._row_index[datarn] = v
+
+        # header
         for datacn, v in modification["cells"]["header"].items():
-            self._headers[datacn] = v
-        for (datarn, datacn), v in modification["cells"]["table"].items():
-            self.set_cell_data(datarn, datacn, v)
+            if not self.edit_validation_func or (
+                self.edit_validation_func
+                and (v := self.edit_validation_func(mod_event_val(event_data, v, column=datacn))) is not None
+            ):
+                self._headers[datacn] = v
+
+        # table
+        for k, v in modification["cells"]["table"].items():
+            if not self.edit_validation_func or (
+                self.edit_validation_func
+                and (v := self.edit_validation_func(mod_event_val(event_data, v, loc=k))) is not None
+            ):
+                self.set_cell_data(k[0], k[1], v)
+
         return event_data
 
     def save_cells_using_modification(self, modification: EventDataDict, event_data: EventDataDict) -> EventDataDict:
-        for datarn, v in modification["cells"]["index"].items():
+        for datarn in modification["cells"]["index"]:
             event_data["cells"]["index"][datarn] = self.RI.get_cell_data(datarn)
-        for datacn, v in modification["cells"]["header"].items():
+
+        for datacn in modification["cells"]["header"]:
             event_data["cells"]["header"][datacn] = self.CH.get_cell_data(datacn)
-        for (datarn, datacn), v in modification["cells"]["table"].items():
-            event_data["cells"]["table"][(datarn, datacn)] = self.get_cell_data(datarn, datacn)
+
+        for k in modification["cells"]["table"]:
+            event_data["cells"]["table"][k] = self.get_cell_data(k[0], k[1])
         return event_data
 
     def restore_options_named_spans(self, modification: EventDataDict) -> None:
@@ -3167,9 +3185,10 @@ class MainTable(tk.Canvas):
             self.b1_motion(event)
 
     def b1_release(self, event=None):
+        to_hide = self.being_drawn_item
         if self.being_drawn_item is not None and (to_sel := self.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.selected.row, self.selected.column
-            self.hide_selection_box(self.being_drawn_item)
+            self.being_drawn_item = None
             self.set_currently_selected(
                 r_to_sel,
                 c_to_sel,
@@ -3182,26 +3201,9 @@ class MainTable(tk.Canvas):
                     ),
                     set_current=False,
                 ),
+                run_binding=False,
             )
-            sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-            try_binding(self.drag_selection_binding_func, sel_event)
-            self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
-        else:
-            self.being_drawn_item = None
-        if self.RI.width_resizing_enabled and self.RI.rsz_w is not None and self.RI.currently_resizing_width:
-            self.delete_resize_lines()
-            self.RI.delete_resize_lines()
-            self.RI.currently_resizing_width = False
-            self.RI.set_width(self.new_row_width, set_TL=True)
-            self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-            self.b1_pressed_loc = None
-        elif self.CH.height_resizing_enabled and self.CH.rsz_h is not None and self.CH.currently_resizing_height:
-            self.delete_resize_lines()
-            self.CH.delete_resize_lines()
-            self.CH.currently_resizing_height = False
-            self.CH.set_height(self.new_header_height, set_TL=True)
-            self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-            self.b1_pressed_loc = None
+        self.hide_selection_box(to_hide)
         self.RI.rsz_w = None
         self.CH.rsz_h = None
         if self.b1_pressed_loc is not None:
@@ -3524,7 +3526,7 @@ class MainTable(tk.Canvas):
             c_pc=c_pc,
         )
 
-    def get_txt_w(self, txt, font=None):
+    def get_txt_w(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3533,7 +3535,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[2] - b[0]
 
-    def get_txt_h(self, txt, font=None):
+    def get_txt_h(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3542,7 +3544,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[3] - b[1]
 
-    def get_txt_dimensions(self, txt, font=None):
+    def get_txt_dimensions(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3551,7 +3553,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[2] - b[0], b[3] - b[1]
 
-    def get_lines_cell_height(self, n, font=None):
+    def get_lines_cell_height(self, n: int, font: None | FontTuple = None) -> int:
         return (
             self.get_txt_h(
                 txt="\n".join("|" for _ in range(n)) if n > 1 else "|",
@@ -3560,15 +3562,17 @@ class MainTable(tk.Canvas):
             + 5
         )
 
-    def set_min_column_width(self):
-        self.min_column_width = 1
-        if self.min_column_width > self.max_column_width:
-            self.max_column_width = self.min_column_width + 20
+    def set_min_column_width(self, width: int) -> None:
+        if width:
+            self.PAR.ops.min_column_width = width
+
+        if self.PAR.ops.min_column_width > self.PAR.ops.max_column_width:
+            self.PAR.ops.max_column_width = self.PAR.ops.min_column_width + 20
         if (
             isinstance(self.PAR.ops.auto_resize_columns, (int, float))
-            and self.PAR.ops.auto_resize_columns < self.min_column_width
+            and self.PAR.ops.auto_resize_columns < self.PAR.ops.min_column_width
         ):
-            self.PAR.ops.auto_resize_columns = self.min_column_width
+            self.PAR.ops.auto_resize_columns = self.PAR.ops.min_column_width
 
     def get_default_row_height(self) -> int:
         if isinstance(self.PAR.ops.default_row_height, str):
@@ -3619,7 +3623,6 @@ class MainTable(tk.Canvas):
         self.table_xtra_lines_increment = int(self.table_txt_height)
         if self.min_row_height < 12:
             self.min_row_height = 12
-        self.set_min_column_width()
 
     def set_header_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
         if newfont:
@@ -3650,7 +3653,6 @@ class MainTable(tk.Canvas):
             and self.PAR.ops.default_header_height < self.min_header_height
         ):
             self.PAR.ops.default_header_height = int(self.min_header_height)
-        self.set_min_column_width()
         self.CH.set_height(self.get_default_header_height(), set_TL=True)
 
     def set_index_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
@@ -3720,15 +3722,15 @@ class MainTable(tk.Canvas):
             w = b[2] - b[0] + 7
             h = b[3] - b[1] + 5
         else:
-            w = self.min_column_width
+            w = self.PAR.ops.min_column_width
             h = self.min_row_height
         if self.get_cell_kwargs(datarn, datacn, key="dropdown") or self.get_cell_kwargs(datarn, datacn, key="checkbox"):
             return w + self.table_txt_height, h
         return w, h
 
     def set_cell_size_to_text(self, r, c, only_if_too_small=False, redraw: bool = True, run_binding=False):
-        min_column_width = int(self.min_column_width)
-        min_rh = int(self.min_row_height)
+        min_column_width = self.PAR.ops.min_column_width
+        min_rh = self.min_row_height
         w = min_column_width
         h = min_rh
         datacn = self.datacn(c)
@@ -3737,13 +3739,13 @@ class MainTable(tk.Canvas):
         if tw > w:
             w = tw
         if h < min_rh:
-            h = int(min_rh)
-        elif h > self.max_row_height:
-            h = int(self.max_row_height)
+            h = min_rh
+        elif h > self.PAR.ops.max_row_height:
+            h = int(self.PAR.ops.max_row_height)
         if w < min_column_width:
-            w = int(min_column_width)
-        elif w > self.max_column_width:
-            w = int(self.max_column_width)
+            w = min_column_width
+        elif w > self.PAR.ops.max_column_width:
+            w = int(self.PAR.ops.max_column_width)
         cell_needs_resize_w = False
         cell_needs_resize_h = False
         if only_if_too_small:
@@ -3803,8 +3805,10 @@ class MainTable(tk.Canvas):
         width: int | None = None,
         slim: bool = False,
     ) -> tuple[list[float], list[float]]:
-        min_column_width = int(self.min_column_width)
-        min_rh = int(self.min_row_height)
+        min_column_width = self.PAR.ops.min_column_width
+        max_column_width = float_to_int(self.PAR.ops.max_column_width)
+        max_row_height = float_to_int(self.PAR.ops.max_row_height)
+        min_rh = self.min_row_height
         h = min_rh
         rhs = defaultdict(lambda: int(min_rh))
         cws = []
@@ -3827,9 +3831,9 @@ class MainTable(tk.Canvas):
             for datarn in iterrows:
                 w_, h = self.RI.get_cell_dimensions(datarn)
                 if h < min_rh:
-                    h = int(min_rh)
-                elif h > self.max_row_height:
-                    h = int(self.max_row_height)
+                    h = min_rh
+                elif h > max_row_height:
+                    h = max_row_height
                 if h > rhs[datarn]:
                     rhs[datarn] = h
         added_w_space = 1 if slim else 7
@@ -3861,15 +3865,15 @@ class MainTable(tk.Canvas):
                 if tw > w:
                     w = tw
                 if h < min_rh:
-                    h = int(min_rh)
-                elif h > self.max_row_height:
-                    h = int(self.max_row_height)
+                    h = min_rh
+                elif h > max_row_height:
+                    h = max_row_height
                 if h > rhs[datarn]:
                     rhs[datarn] = h
             if w < min_column_width:
-                w = int(min_column_width)
-            elif w > self.max_column_width:
-                w = int(self.max_column_width)
+                w = min_column_width
+            elif w > max_column_width:
+                w = max_column_width
             cws.append(w)
         self.set_row_positions(itr=rhs.values())
         self.set_col_positions(itr=cws)
@@ -5453,8 +5457,8 @@ class MainTable(tk.Canvas):
         resized_rows = False
         if self.PAR.ops.auto_resize_columns and self.allow_auto_resize_columns and col_pos_exists:
             max_w = can_width - self.PAR.ops.empty_horizontal
-            if self.PAR.ops.auto_resize_columns < self.min_column_width:
-                min_column_width = self.column_width
+            if self.PAR.ops.auto_resize_columns < self.PAR.ops.min_column_width:
+                min_column_width = self.PAR.ops.min_column_width
             else:
                 min_column_width = self.PAR.ops.auto_resize_columns
             if (len(self.col_positions) - 1) * min_column_width < max_w:
@@ -5679,7 +5683,7 @@ class MainTable(tk.Canvas):
                     color_tup(self.PAR.ops.table_selected_cells_fg),
                     color_tup(self.PAR.ops.table_selected_columns_fg),
                     color_tup(self.PAR.ops.table_selected_rows_fg),
-                    )
+                )
             else:
                 override = tuple()
 
@@ -5934,7 +5938,7 @@ class MainTable(tk.Canvas):
         rows: bool = True,
         columns: bool = True,
         reverse: bool = False,
-    ) -> Generator[int]:
+    ) -> tuple[tuple[int, SelectionBox]]:
         """
         Most recent selection box should be last
         """
@@ -6136,7 +6140,7 @@ class MainTable(tk.Canvas):
             self.itemconfig(item, state="hidden")
 
     def hide_selection_box(self, item: int | None) -> bool:
-        if item is None or item is True:
+        if item is None or item is True or item not in self.selection_boxes:
             return
         box = self.selection_boxes.pop(item)
         self.hide_box(box.fill_iid)
@@ -6387,31 +6391,55 @@ class MainTable(tk.Canvas):
     def recreate_all_selection_boxes(self) -> None:
         if not self.selected:
             return
+        modified = False
         for item, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
+            if not modified:
+                modified = (
+                    r1 >= len(self.row_positions) - 1
+                    or c1 >= len(self.col_positions) - 1
+                    or r2 > len(self.row_positions) - 1
+                    or c2 > len(self.col_positions) - 1
+                )
             if r1 >= len(self.row_positions) - 1:
                 if len(self.row_positions) > 1:
                     r1 = len(self.row_positions) - 2
                 else:
-                    r1 = len(self.row_positions) - 1
+                    r1 = 0
             if c1 >= len(self.col_positions) - 1:
                 if len(self.col_positions) > 1:
                     c1 = len(self.col_positions) - 2
                 else:
-                    c1 = len(self.col_positions) - 1
+                    c1 = 0
             if r2 > len(self.row_positions) - 1:
                 r2 = len(self.row_positions) - 1
             if c2 > len(self.col_positions) - 1:
                 c2 = len(self.col_positions) - 1
-            self.recreate_selection_box(r1, c1, r2, c2, item)
+            self.recreate_selection_box(r1, c1, r2, c2, item, run_binding=False)
+
         if self.selected:
             r = self.selected.row
             c = self.selected.column
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                self.set_currently_selected(r, c, item=self.selected.fill_iid)
+                self.set_currently_selected(
+                    r,
+                    c,
+                    item=self.selected.fill_iid,
+                    run_binding=False,
+                )
             else:
                 box = self.selection_boxes[self.selected.fill_iid]
-                self.set_currently_selected(box.coords.from_r, box.coords.from_c, item=box.fill_iid)
+                self.set_currently_selected(
+                    box.coords.from_r,
+                    box.coords.from_c,
+                    item=box.fill_iid,
+                    run_binding=False,
+                )
+        if modified:
+            self.PAR.emit_event(
+                "<<SheetSelect>>",
+                data=self.get_select_event(self.being_drawn_item),
+            )
 
     def get_redraw_selections(self, startr: int, endr: int, startc: int, endc: int) -> dict:
         d = defaultdict(set)
@@ -6710,7 +6738,6 @@ class MainTable(tk.Canvas):
         h = self.row_positions[r + 1] - y + 1
         if text is None:
             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(
                 {
@@ -6728,8 +6755,10 @@ class MainTable(tk.Canvas):
             "width": w,
             "height": h,
             "show_border": True,
-            "bg": bg,
-            "fg": fg,
+            "bg": self.PAR.ops.table_editor_bg,
+            "fg": self.PAR.ops.table_editor_fg,
+            "select_bg": self.PAR.ops.table_editor_select_bg,
+            "select_fg": self.PAR.ops.table_editor_select_fg,
             "align": self.get_cell_align(r, c),
             "r": r,
             "c": c,
@@ -6868,7 +6897,7 @@ class MainTable(tk.Canvas):
             name="end_edit_table",
             sheet=self.PAR.name,
             widget=self,
-            cells_table={(datarn, datacn): text_editor_value},
+            cells_table={(datarn, datacn): self.get_cell_data(datarn, datacn)},
             key=event.keysym,
             value=text_editor_value,
             loc=Loc(r, c),
@@ -7062,22 +7091,15 @@ class MainTable(tk.Canvas):
             selected=self.selected,
         )
         try_binding(self.dropdown.window.modified_function, event_data)
-        val = self.dropdown.window.search_and_see(event_data)
         # return to tk.Text action if control/command is held down
         # or keysym was not a character
         if (hasattr(event, "state") and event.state & (0x0004 | 0x00000010)) or (
-            hasattr(event, "keysym") and len(event.keysym) > 2
+            hasattr(event, "keysym") and len(event.keysym) > 2 and event.keysym != "space"
         ):
             return
-        self.text_editor.tktext.unbind("<KeyRelease>")
-        self.text_editor.autocomplete(val)
-        self.text_editor.tktext.bind(
-            "<KeyRelease>",
-            self.dropdown_text_editor_modified,
-        )
+        self.text_editor.autocomplete(self.dropdown.window.search_and_see(event_data))
         return "break"
 
-    # c is displayed col
     def open_dropdown_window(
         self,
         r: int,
@@ -7105,6 +7127,10 @@ class MainTable(tk.Canvas):
         reset_kwargs = {
             "r": r,
             "c": c,
+            "bg": self.PAR.ops.table_editor_bg,
+            "fg": self.PAR.ops.table_editor_fg,
+            "select_bg": self.PAR.ops.table_editor_select_bg,
+            "select_fg": self.PAR.ops.table_editor_select_fg,
             "width": win_w,
             "height": win_h,
             "font": self.PAR.ops.table_font,
@@ -7133,12 +7159,12 @@ class MainTable(tk.Canvas):
                 window=self.dropdown.window,
                 anchor=anchor,
             )
+        self.update_idletasks()
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
                 "<KeyRelease>",
                 self.dropdown_text_editor_modified,
             )
-            self.update_idletasks()
             try:
                 self.after(1, lambda: self.text_editor.tktext.focus())
                 self.after(2, self.text_editor.window.scroll_to_bottom())
@@ -7146,7 +7172,6 @@ class MainTable(tk.Canvas):
                 return
             redraw = False
         else:
-            self.update_idletasks()
             self.dropdown.window.bind("<FocusOut>", lambda _: self.close_dropdown_window(r, c))
             self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
             self.dropdown.window.focus_set()

tksheet/other_classes.py

@@ -5,6 +5,7 @@ from collections import namedtuple
 from collections.abc import Callable, Generator, Hashable, Iterator
 from functools import partial
 from typing import Literal
+import tkinter as tk
 
 pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 
@@ -18,7 +19,7 @@ Box_t = namedtuple(
     "from_r from_c upto_r upto_c type_",
 )
 Box_st = namedtuple("Box_st", "coords type_")
-Loc = namedtuple("Loc", "row column")
+Loc = namedtuple("Loc", "row column", defaults=(None, None))
 
 Highlight = namedtuple(
     "Highlight",
@@ -489,25 +490,25 @@ class TextEditorStorage:
         if self.window:
             return self.window.get()
         return ""
-    
+
     def set(self, value: str) -> None:
         if not self.window:
             return
         self.window.set_text(value)
-        
-    def highlight_from(self, r: int | str, c: int | str) -> None:
-        index = self.window.tktext.index(f"{r}.{c}")
-        self.window.tktext.tag_add('sel', index, 'end')
-        self.window.tktext.mark_set('insert', f"{r}.{c}")
-        
+
+    def highlight_from(self, index: tk.Misc, r: int | str, c: int | str) -> None:
+        self.window.tktext.tag_add("sel", index, "end")
+        self.window.tktext.mark_set("insert", f"{r}.{c}")
+
     def autocomplete(self, value: str | None) -> None:
         current_val = self.get()
-        if not value or len(current_val) >= len(value) or current_val != value[:len(current_val)]:
+        if not value or len(current_val) >= len(value) or current_val != value[: len(current_val)]:
             return
-        cursor_pos = self.tktext.index('insert')
-        line, column = cursor_pos.split('.')
-        self.window.set_text(value)
-        self.highlight_from(line, column)
+        cursor_pos = self.tktext.index("insert")
+        line, column = cursor_pos.split(".")
+        index = self.window.tktext.index(f"{line}.{column}")
+        self.tktext.insert(index, value[len(current_val) :])
+        self.highlight_from(index, line, column)
 
     @property
     def tktext(self) -> object: