tksheet 7.1.3__py3-none-any.whl → 7.1.5__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -197,8 +197,7 @@ class ColumnHeaders(tk.Canvas):
                         self.toggle_select_col(c, redraw=True)
                     if self.MT.rc_popup_menus_enabled:
                         popup_menu = self.ch_rc_popup_menu
-        if self.extra_rc_func is not None:
-            self.extra_rc_func(event)
+        try_binding(self.extra_rc_func, event)
         if popup_menu is not None:
             self.popup_menu_loc = c
             popup_menu.tk_popup(event.x_root, event.y_root)
@@ -218,10 +217,9 @@ class ColumnHeaders(tk.Canvas):
                     self.being_drawn_item = True
                     self.being_drawn_item = self.add_selection(c, set_as_current=True, run_binding_func=False)
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-                    if self.ctrl_selection_binding_func is not None:
-                        self.ctrl_selection_binding_func(
-                            self.MT.get_select_event(being_drawn_item=self.being_drawn_item),
-                        )
+                    sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
+                    try_binding(self.ctrl_selection_binding_func, sel_event)
+                    self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
                 elif c_selected:
                     self.MT.deselect(c=c)
         elif not self.MT.ctrl_select_enabled:
@@ -252,10 +250,9 @@ class ColumnHeaders(tk.Canvas):
                             set_as_current=True,
                         )
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-                    if self.ctrl_selection_binding_func is not None:
-                        self.ctrl_selection_binding_func(
-                            self.MT.get_select_event(being_drawn_item=self.being_drawn_item),
-                        )
+                    sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
+                    try_binding(self.ctrl_selection_binding_func, sel_event)
+                    self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
                 elif c_selected:
                     self.dragged_col = DraggedRowColumn(
                         dragged=c,
@@ -275,15 +272,16 @@ 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))
+                        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)
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-                    if self.shift_selection_binding_func is not None:
-                        self.shift_selection_binding_func(
-                            self.MT.get_select_event(being_drawn_item=self.being_drawn_item),
-                        )
+                    sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
+                    try_binding(self.shift_selection_binding_func, sel_event)
+                    self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
                 elif c_selected:
                     self.dragged_col = DraggedRowColumn(
                         dragged=c,
@@ -371,8 +369,7 @@ class ColumnHeaders(tk.Canvas):
                         self.MT.current_cursor = "hand2"
             if not mouse_over_resize and not mouse_over_selected:
                 self.MT.reset_mouse_motion_creations()
-        if self.extra_motion_func is not None:
-            self.extra_motion_func(event)
+        try_binding(self.extra_motion_func, event)
 
     def double_b1(self, event: object):
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -412,8 +409,7 @@ class ColumnHeaders(tk.Canvas):
                     self.open_cell(event)
         self.rsz_w = None
         self.mouse_motion(event)
-        if self.extra_double_b1_func is not None:
-            self.extra_double_b1_func(event)
+        try_binding(self.extra_double_b1_func, event)
 
     def b1_press(self, event: object):
         self.MT.unbind("<MouseWheel>")
@@ -478,8 +474,7 @@ class ColumnHeaders(tk.Canvas):
                         self.being_drawn_item = self.select_col(c, redraw=True)
                     elif self.MT.toggle_selection_enabled:
                         self.toggle_select_col(c, redraw=True)
-        if self.extra_b1_press_func is not None:
-            self.extra_b1_press_func(event)
+        try_binding(self.extra_b1_press_func, event)
 
     def b1_motion(self, event: object):
         x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
@@ -570,16 +565,14 @@ class ColumnHeaders(tk.Canvas):
                         else:
                             self.being_drawn_item = self.select_col(self.MT.selected.column, run_binding_func=False)
                         need_redraw = True
-                        if self.drag_selection_binding_func is not None:
-                            self.drag_selection_binding_func(
-                                self.MT.get_select_event(being_drawn_item=self.being_drawn_item),
-                            )
+                        sel_event = self.MT.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)
                 if self.scroll_if_event_offscreen(event):
                     need_redraw = True
             if need_redraw:
                 self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
-        if self.extra_b1_motion_func is not None:
-            self.extra_b1_motion_func(event)
+        try_binding(self.extra_b1_motion_func, event)
 
     def get_b1_motion_box(self, start_col, end_col):
         if end_col >= start_col:
@@ -631,10 +624,9 @@ class ColumnHeaders(tk.Canvas):
                             self.MT.hide_selection_box(self.MT.selected.fill_iid)
                             self.being_drawn_item = self.add_selection(box[1], run_binding_func=False)
                         need_redraw = True
-                        if self.drag_selection_binding_func is not None:
-                            self.drag_selection_binding_func(
-                                self.MT.get_select_event(being_drawn_item=self.being_drawn_item),
-                            )
+                        sel_event = self.MT.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)
                 if self.scroll_if_event_offscreen(event):
                     need_redraw = True
             if need_redraw:
@@ -770,10 +762,9 @@ class ColumnHeaders(tk.Canvas):
                 c_to_sel,
                 item=self.MT.create_selection_box(*to_sel, set_current=False),
             )
-            if self.drag_selection_binding_func is not None:
-                self.drag_selection_binding_func(
-                    self.MT.get_select_event(being_drawn_item=self.being_drawn_item),
-                )
+            sel_event = self.MT.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)
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             self.currently_resizing_width = False
@@ -865,8 +856,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:
@@ -879,8 +878,7 @@ class ColumnHeaders(tk.Canvas):
         self.rsz_w = None
         self.rsz_h = None
         self.mouse_motion(event)
-        if self.extra_b1_release_func is not None:
-            self.extra_b1_release_func(event)
+        try_binding(self.extra_b1_release_func, event)
 
     def toggle_select_col(
         self,
@@ -982,15 +980,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:
@@ -1014,7 +1012,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:
@@ -1026,7 +1024,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)
@@ -1646,7 +1644,7 @@ class ColumnHeaders(tk.Canvas):
             text = event.char
         else:
             return False
-        if self.extra_begin_edit_cell_func is not None:
+        if self.extra_begin_edit_cell_func:
             try:
                 text = self.extra_begin_edit_cell_func(
                     event_dict(
@@ -1696,12 +1694,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),
@@ -1747,31 +1745,34 @@ 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.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)
 
     def refresh_open_window_positions(self):
         if self.text_editor.open:
@@ -1909,33 +1910,32 @@ class ColumnHeaders(tk.Canvas):
             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

@@ -1146,6 +1146,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],