tksheet 7.1.8__tar.gz → 7.1.9__tar.gz

{tksheet-7.1.8/tksheet.egg-info → tksheet-7.1.9}/PKG-INFO

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

{tksheet-7.1.8 → tksheet-7.1.9}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet widget"
 readme = "README.md"
-version = "7.1.8"
+version = "7.1.9"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.1.8 → tksheet-7.1.9}/tksheet/__init__.py

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

{tksheet-7.1.8 → tksheet-7.1.9}/tksheet/functions.py

@@ -614,7 +614,7 @@ def try_binding(
     event: dict,
     new_name: None | str = None,
 ) -> bool:
-    if binding is not None:
+    if binding:
         try:
             if new_name is None:
                 binding(event)

{tksheet-7.1.8 → tksheet-7.1.9}/tksheet/main_table.py

@@ -1130,7 +1130,11 @@ class MainTable(tk.Canvas):
             )
         else:
             disp_new_idxs = {}
-        totalrows = self.fix_data_len(move_to)
+        self.fix_data_len(move_to)
+        totalrows = max(
+            self.total_data_rows(),
+            len(self.row_positions) - 1,
+        )
         if self.all_rows_displayed or data_indexes:
             data_new_idxs = get_new_indexes(seqlen=totalrows, move_to=move_to, to_move=to_move)
         elif not self.all_rows_displayed and not data_indexes:
@@ -1157,7 +1161,12 @@ class MainTable(tk.Canvas):
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_row_heights = {}
         if not isinstance(totalrows, int):
-            totalrows = self.fix_data_len(max(data_new_idxs.values(), default=0))
+            totalrows = max(
+                self.total_data_rows(),
+                len(self.row_positions) - 1,
+                max(data_new_idxs.values(), default=0),
+            )
+            totalrows = self.fix_data_len(totalrows)
         if event_data is None:
             event_data = event_dict(
                 name="move_rows",
@@ -1444,9 +1453,7 @@ class MainTable(tk.Canvas):
             saved_cells = True
 
         if modification["moved"]["columns"]:
-            totalcols = self.equalize_data_row_lengths()
-            if totalcols < (mx_k := max(modification["moved"]["columns"]["data"].values())):
-                totalcols = mx_k
+            totalcols = max(self.equalize_data_row_lengths(), max(modification["moved"]["columns"]["data"].values()))
             data_new_idxs, disp_new_idxs, event_data = self.move_columns_adjust_options_dict(
                 data_new_idxs=dict(
                     zip(
@@ -1471,9 +1478,7 @@ class MainTable(tk.Canvas):
             self.restore_options_named_spans(modification)
 
         if modification["moved"]["rows"]:
-            totalrows = self.total_data_rows()
-            if totalrows < (mx_k := max(modification["moved"]["rows"]["data"].values())):
-                totalrows = mx_k
+            totalrows = max(self.total_data_rows(), max(modification["moved"]["rows"]["data"].values()))
             data_new_idxs, disp_new_idxs, event_data = self.move_rows_adjust_options_dict(
                 data_new_idxs=dict(
                     zip(
@@ -2745,8 +2750,7 @@ class MainTable(tk.Canvas):
 
     def mouse_motion(self, event: object):
         self.reset_mouse_motion_creations()
-        if self.extra_motion_func:
-            self.extra_motion_func(event)
+        try_binding(self.extra_motion_func, event)
 
     def not_currently_resizing(self) -> bool:
         return all(v is None for v in (self.RI.rsz_h, self.RI.rsz_w, self.CH.rsz_h, self.CH.rsz_w))
@@ -2759,12 +2763,15 @@ class MainTable(tk.Canvas):
             r = self.identify_row(y=event.y)
             c = self.identify_col(x=event.x)
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                if self.col_selected(c) and self.rc_popup_menus_enabled:
-                    popup_menu = self.CH.ch_rc_popup_menu
-                elif self.row_selected(r) and self.rc_popup_menus_enabled:
-                    popup_menu = self.RI.ri_rc_popup_menu
-                elif self.cell_selected(r, c) and self.rc_popup_menus_enabled:
-                    popup_menu = self.rc_popup_menu
+                if self.col_selected(c):
+                    if self.rc_popup_menus_enabled:
+                        popup_menu = self.CH.ch_rc_popup_menu
+                elif self.row_selected(r):
+                    if self.rc_popup_menus_enabled:
+                        popup_menu = self.RI.ri_rc_popup_menu
+                elif self.cell_selected(r, c):
+                    if self.rc_popup_menus_enabled:
+                        popup_menu = self.rc_popup_menu
                 else:
                     if self.rc_select_enabled:
                         if self.single_selection_enabled:
@@ -2774,9 +2781,9 @@ class MainTable(tk.Canvas):
                     if self.rc_popup_menus_enabled:
                         popup_menu = self.rc_popup_menu
             else:
+                self.deselect("all")
                 popup_menu = self.empty_rc_popup_menu
-        if self.extra_rc_func:
-            self.extra_rc_func(event)
+        try_binding(self.extra_rc_func, event)
         if popup_menu is not None:
             popup_menu.tk_popup(event.x_root, event.y_root)
 
@@ -2800,8 +2807,7 @@ class MainTable(tk.Canvas):
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
                 self.toggle_select_cell(r, c, redraw=True)
         self.b1_pressed_loc = (r, c)
-        if self.extra_b1_press_func:
-            self.extra_b1_press_func(event)
+        try_binding(self.extra_b1_press_func, event)
 
     def create_resize_line(self, x1, y1, x2, y2, width, fill, tag):
         if self.hidd_resize_lines:
@@ -2969,8 +2975,7 @@ class MainTable(tk.Canvas):
                 need_redraw = True
             if need_redraw:
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
-        if self.extra_b1_motion_func:
-            self.extra_b1_motion_func(event)
+        try_binding(self.extra_b1_motion_func, event)
 
     def ctrl_b1_motion(self, event: object):
         if self.ctrl_select_enabled and self.drag_selection_enabled and self.not_currently_resizing():
@@ -3082,8 +3087,7 @@ class MainTable(tk.Canvas):
                 self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.b1_pressed_loc = None
         self.closed_dropdown = None
-        if self.extra_b1_release_func:
-            self.extra_b1_release_func(event)
+        try_binding(self.extra_b1_release_func, event)
 
     def double_b1(self, event=None):
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
@@ -3107,8 +3111,7 @@ class MainTable(tk.Canvas):
                 self.toggle_select_cell(r, c, redraw=True)
                 if self.edit_cell_enabled:
                     self.open_cell(event)
-        if self.extra_double_b1_func:
-            self.extra_double_b1_func(event)
+        try_binding(self.extra_double_b1_func, event)
 
     def identify_row(self, event=None, y=None, allow_end=True):
         if event is None:
@@ -3329,7 +3332,9 @@ class MainTable(tk.Canvas):
                                 else (
                                     default_row_height
                                     if h == old_default_row_height
-                                    else self.min_row_height if h < self.min_row_height else h
+                                    else self.min_row_height
+                                    if h < self.min_row_height
+                                    else h
                                 )
                             )
                             for h in self.gen_row_heights()
@@ -4274,7 +4279,7 @@ class MainTable(tk.Canvas):
         return event_data
 
     def rc_add_columns(self, event: object = None):
-        rowlen = self.equalize_data_row_lengths(include_header=False)
+        rowlen = self.equalize_data_row_lengths()
         selcols = sorted(self.get_selected_cols())
         if (
             selcols
@@ -4860,24 +4865,15 @@ class MainTable(tk.Canvas):
                 return self._row_index
 
     def total_data_cols(self, include_header: bool = True) -> int:
-        h_total = 0
-        d_total = 0
-        if include_header:
-            if isinstance(self._headers, (list, tuple)):
-                h_total = len(self._headers)
-        # map() for some reason is 15% faster than max(key=len)
-        # using python 3.11 windows 11
+        h_total = len(self._headers) if include_header and isinstance(self._headers, (list, tuple)) else 0
+        # map() for some reason is 15% faster than max(key=len) using python 3.11 windows 11
         d_total = max(map(len, self.data), default=0)
-        return h_total if h_total > d_total else d_total
+        return max(h_total, d_total)
 
     def total_data_rows(self, include_index: bool = True) -> int:
-        i_total = 0
-        d_total = 0
-        if include_index:
-            if isinstance(self._row_index, (list, tuple)):
-                i_total = len(self._row_index)
+        i_total = len(self._row_index) if include_index and isinstance(self._row_index, (list, tuple)) else 0
         d_total = len(self.data)
-        return i_total if i_total > d_total else d_total
+        return max(i_total, d_total)
 
     def data_dimensions(self, total_rows: int | None = None, total_columns: int | None = None):
         if total_rows is None and total_columns is None:
@@ -4897,7 +4893,7 @@ class MainTable(tk.Canvas):
 
     def equalize_data_row_lengths(
         self,
-        include_header: bool = False,
+        include_header: bool = True,
         total_data_cols: int | None = None,
         at_least_cols: int | None = None,
     ) -> int:
@@ -4905,6 +4901,7 @@ class MainTable(tk.Canvas):
             total_data_cols = self.total_data_cols(include_header=include_header)
         if isinstance(at_least_cols, int) and at_least_cols > total_data_cols:
             total_data_cols = at_least_cols
+        total_data_cols = max(total_data_cols, len(self.col_positions) - 1)
         if include_header and total_data_cols > len(self._headers):
             self.CH.fix_header(total_data_cols)
         for rn, r in enumerate(self.data):

{tksheet-7.1.8 → tksheet-7.1.9}/tksheet/sheet.py

@@ -46,6 +46,7 @@ from .other_classes import (
     GeneratedMouseEvent,
     Node,
     Selected,
+    SelectionBox,
     Span,
 )
 from .row_index import RowIndex
@@ -1070,6 +1071,17 @@ class Sheet(tk.Frame):
         self.MT.redo(event)
         return self
 
+    def has_focus(
+        self,
+    ) -> bool:
+        """
+        Check if any Sheet widgets have focus
+        Includes child widgets such as scroll bars
+        Returns bool
+        """
+        widget = self.focus_get()
+        return widget == self or any(widget == c for c in self.children.values())
+
     def focus_set(
         self,
         canvas: Literal[
@@ -1391,11 +1403,7 @@ class Sheet(tk.Frame):
             # retrieving a list of index cells or
             elif (index and not span.transposed and not table and not header) or (
                 # it's a column that's spread across sublists
-                table
-                and res
-                and not span.transposed
-                and len(res[0]) == 1
-                and len(res[-1]) == 1
+                table and res and not span.transposed and len(res[0]) == 1 and len(res[-1]) == 1
             ):
                 res = list(chain.from_iterable(res))
         elif span.ndim == 1:
@@ -2389,8 +2397,31 @@ class Sheet(tk.Frame):
         self.set_refresh_timer(redraw)
         return data_idxs, disp_idxs, event_data
 
-    def equalize_data_row_lengths(self, include_header: bool = False) -> int:
-        return self.MT.equalize_data_row_lengths(include_header=include_header)
+    def equalize_data_row_lengths(
+        self,
+        include_header: bool = True,
+    ) -> int:
+        return self.MT.equalize_data_row_lengths(
+            include_header=include_header,
+        )
+
+    def full_move_rows_idxs(self, data_idxs: dict[int, int]) -> dict[int, int]:
+        """
+        Converts the dict provided by moving rows event data
+        Under the keys ['moved']['rows']['data']
+        Into a dict of {old index: new index} for every row
+        Includes row numbers in cell options, spans, etc.
+        """
+        return self.MT.get_full_new_idxs(self.MT.get_max_row_idx(), data_idxs)
+
+    def full_move_columns_idxs(self, data_idxs: dict[int, int]) -> dict[int, int]:
+        """
+        Converts the dict provided by moving columns event data
+        Under the keys ['moved']['columns']['data']
+        Into a dict of {old index: new index} for every column
+        Includes column numbers in cell options, spans, etc.
+        """
+        return self.MT.get_full_new_idxs(self.MT.get_max_column_idx(), data_idxs)
 
     # Highlighting Cells
 
@@ -2976,6 +3007,10 @@ class Sheet(tk.Frame):
         )
         return self
 
+    @property
+    def canvas_boxes(self) -> dict[int, SelectionBox]:
+        return self.MT.selection_boxes
+
     def cell_selected(
         self,
         r: int,
@@ -3008,8 +3043,17 @@ class Sheet(tk.Frame):
     def all_selected(self) -> bool:
         return self.MT.all_selected()
 
-    def get_ctrl_x_c_boxes(self) -> tuple[dict[tuple[int, int, int, int], str], int]:
-        return self.MT.get_ctrl_x_c_boxes()
+    def get_ctrl_x_c_boxes(
+        self,
+        nrows: bool = True,
+    ) -> tuple[dict[tuple[int, int, int, int], str], int] | dict[tuple[int, int, int, int], str]:
+        if nrows:
+            return self.MT.get_ctrl_x_c_boxes()
+        return self.MT.get_ctrl_x_c_boxes()[0]
+
+    @property
+    def ctrl_boxes(self) -> dict[tuple[int, int, int, int], str]:
+        return self.MT.get_ctrl_x_c_boxes()[0]
 
     def get_selected_min_max(
         self,
@@ -4466,7 +4510,7 @@ class Sheet(tk.Frame):
         self.RI.tree_rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         self.hide_rows(
             set(self.RI.tree_rns[iid] for iid in self.get_children() if self.RI.tree[iid].parent),
-            deselect_all=True,
+            deselect_all=False,
             data_indexes=True,
         )
         return self
@@ -4793,7 +4837,7 @@ class Sheet(tk.Frame):
     reattach = move
 
     def exists(self, item: str) -> bool:
-        return item in self.RI.tree
+        return item.lower() in self.RI.tree
 
     def parent(self, item: str) -> str:
         if (item := item.lower()) not in self.RI.tree:
@@ -5419,7 +5463,7 @@ class Sheet(tk.Frame):
         row: int = 0,
         column: int = 0,
         cells: list = [],
-        canvas: str = "table",
+        canvas: Literal["table", "index", "header"] = "table",
         bg: bool | None | str = False,
         fg: bool | None | str = False,
         redraw: bool = True,

{tksheet-7.1.8 → tksheet-7.1.9/tksheet.egg-info}/PKG-INFO

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