tksheet 7.1.8__py3-none-any.whl → 7.1.10__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.1.8"
+__version__ = "7.1.10"
 
 from .colors import (
     color_map,
@@ -49,6 +49,7 @@ from .functions import (
     get_n2a,
     get_new_indexes,
     get_seq_without_gaps_at_index,
+    insert_items,
     is_iterable,
     move_elements_by_mapping,
     move_elements_to,

tksheet/column_headers.py

@@ -1320,6 +1320,16 @@ class ColumnHeaders(tk.Canvas):
                 t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
             self.disp_checkbox[t] = True
 
+    def configure_scrollregion(self, last_col_line_pos: float) -> None:
+        self.configure(
+            scrollregion=(
+                0,
+                0,
+                last_col_line_pos + self.PAR.ops.empty_horizontal + 2,
+                self.current_height,
+            )
+        )
+
     def redraw_grid_and_text(
         self,
         last_col_line_pos,
@@ -1331,14 +1341,7 @@ class ColumnHeaders(tk.Canvas):
         col_pos_exists,
     ):
         try:
-            self.configure(
-                scrollregion=(
-                    0,
-                    0,
-                    last_col_line_pos + self.PAR.ops.empty_horizontal + 2,
-                    self.current_height,
-                )
-            )
+            self.configure_scrollregion(last_col_line_pos=last_col_line_pos)
         except Exception:
             return
         self.hidd_text.update(self.disp_text)

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/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(
@@ -2198,98 +2203,6 @@ class MainTable(tk.Canvas):
                         check_cell_visibility=False,
                     )
 
-    def key_bindings(self) -> None:
-        for widget in (self, self.RI, self.CH, self.TL):
-            for binding in self.PAR.ops.copy_bindings:
-                if self.copy_enabled:
-                    widget.bind(binding, self.ctrl_c)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.cut_bindings:
-                if self.cut_enabled:
-                    widget.bind(binding, self.ctrl_x)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.paste_bindings:
-                if self.paste_enabled:
-                    widget.bind(binding, self.ctrl_v)
-                else:
-                    widget.unbind(binding)
-
-            if self.undo_enabled:
-                for binding in self.PAR.ops.undo_bindings:
-                    widget.bind(binding, self.undo)
-                for binding in self.PAR.ops.redo_bindings:
-                    widget.bind(binding, self.redo)
-            else:
-                for binding in self.PAR.ops.undo_bindings:
-                    widget.unbind(binding)
-                for binding in self.PAR.ops.redo_bindings:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.delete_bindings:
-                if self.delete_key_enabled:
-                    widget.bind(binding, self.delete_key)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.select_all_bindings:
-                if self.select_all_enabled:
-                    widget.bind(binding, self.select_all)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.tab_bindings:
-                if self.tab_enabled:
-                    widget.bind(binding, self.tab_key)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.up_bindings:
-                if self.up_enabled:
-                    widget.bind(binding, self.arrowkey_UP)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.right_bindings:
-                if self.right_enabled:
-                    widget.bind(binding, self.arrowkey_RIGHT)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.down_bindings:
-                if self.down_enabled:
-                    widget.bind(binding, self.arrowkey_DOWN)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.left_bindings:
-                if self.left_enabled:
-                    widget.bind(binding, self.arrowkey_LEFT)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.prior_bindings:
-                if self.prior_enabled:
-                    widget.bind(binding, self.page_UP)
-                else:
-                    widget.unbind(binding)
-
-            for binding in self.PAR.ops.next_bindings:
-                if self.next_enabled:
-                    widget.bind(binding, self.page_DOWN)
-                else:
-                    widget.unbind(binding)
-
-        if self.edit_cell_enabled:
-            for w in (self, self.RI, self.CH):
-                w.bind("<Key>", self.open_cell)
-        else:
-            for w in (self, self.RI, self.CH):
-                w.unbind("<Key>")
-
     def menu_add_command(self, menu: tk.Menu, **kwargs) -> None:
         if "label" not in kwargs:
             return
@@ -2523,35 +2436,33 @@ class MainTable(tk.Canvas):
 
     def enable_bindings(self, bindings):
         if not bindings:
-            self.enable_bindings_internal("all")
+            self._enable_binding("all")
         elif isinstance(bindings, (list, tuple)):
             for binding in bindings:
                 if isinstance(binding, (list, tuple)):
                     for bind in binding:
-                        self.enable_bindings_internal(bind.lower())
+                        self._enable_binding(bind.lower())
                 elif isinstance(binding, str):
-                    self.enable_bindings_internal(binding.lower())
+                    self._enable_binding(binding.lower())
         elif isinstance(bindings, str):
-            self.enable_bindings_internal(bindings.lower())
+            self._enable_binding(bindings.lower())
         self.create_rc_menus()
-        self.key_bindings()
 
     def disable_bindings(self, bindings):
         if not bindings:
-            self.disable_bindings_internal("all")
+            self._disable_binding("all")
         elif isinstance(bindings, (list, tuple)):
             for binding in bindings:
                 if isinstance(binding, (list, tuple)):
                     for bind in binding:
-                        self.disable_bindings_internal(bind.lower())
+                        self._disable_binding(bind.lower())
                 elif isinstance(binding, str):
-                    self.disable_bindings_internal(binding.lower())
+                    self._disable_binding(binding.lower())
         elif isinstance(bindings, str):
-            self.disable_bindings_internal(bindings)
+            self._disable_binding(bindings)
         self.create_rc_menus()
-        self.key_bindings()
 
-    def enable_bindings_internal(self, binding):
+    def _enable_binding(self, binding):
         if binding == "enable_all":
             binding = "all"
         if binding in ("all", "single", "single_selection_mode", "single_select"):
@@ -2562,9 +2473,6 @@ class MainTable(tk.Canvas):
             self.single_selection_enabled = False
         if binding in ("all", "drag_select"):
             self.drag_selection_enabled = True
-        if binding in ("all", "select_all"):
-            self.select_all_enabled = True
-            self.TL.sa_state()
         if binding in ("all", "column_width_resize"):
             self.CH.width_resizing_enabled = True
         if binding in ("all", "column_select"):
@@ -2587,20 +2495,47 @@ class MainTable(tk.Canvas):
             self.RI.row_selection_enabled = True
         if binding in ("all", "row_drag_and_drop", "move_rows"):
             self.RI.drag_and_drop_enabled = True
+        if binding in ("all", "select_all"):
+            self.select_all_enabled = True
+            self.TL.sa_state()
+            self._tksheet_bind("select_all_bindings", self.select_all)
         if binding in ("all", "arrowkeys", "tab"):
             self.tab_enabled = True
+            self._tksheet_bind("tab_bindings", self.tab_key)
         if binding in ("all", "arrowkeys", "up"):
             self.up_enabled = True
+            self._tksheet_bind("up_bindings", self.arrowkey_UP)
         if binding in ("all", "arrowkeys", "right"):
             self.right_enabled = True
+            self._tksheet_bind("right_bindings", self.arrowkey_RIGHT)
         if binding in ("all", "arrowkeys", "down"):
             self.down_enabled = True
+            self._tksheet_bind("down_bindings", self.arrowkey_DOWN)
         if binding in ("all", "arrowkeys", "left"):
             self.left_enabled = True
+            self._tksheet_bind("left_bindings", self.arrowkey_LEFT)
         if binding in ("all", "arrowkeys", "prior"):
             self.prior_enabled = True
+            self._tksheet_bind("prior_bindings", self.page_UP)
         if binding in ("all", "arrowkeys", "next"):
             self.next_enabled = True
+            self._tksheet_bind("next_bindings", self.page_DOWN)
+        if binding in ("all", "copy", "edit_bindings", "edit"):
+            self.copy_enabled = True
+            self._tksheet_bind("copy_bindings", self.ctrl_c)
+        if binding in ("all", "cut", "edit_bindings", "edit"):
+            self.cut_enabled = True
+            self._tksheet_bind("cut_bindings", self.ctrl_x)
+        if binding in ("all", "paste", "edit_bindings", "edit"):
+            self.paste_enabled = True
+            self._tksheet_bind("paste_bindings", self.ctrl_v)
+        if binding in ("all", "delete", "edit_bindings", "edit"):
+            self.delete_key_enabled = True
+            self._tksheet_bind("delete_bindings", self.delete_key)
+        if binding in ("all", "undo", "redo", "edit_bindings", "edit"):
+            self.undo_enabled = True
+            self._tksheet_bind("undo_bindings", self.undo)
+            self._tksheet_bind("redo_bindings", self.redo)
         if binding in ("all", "rc_delete_column"):
             self.rc_delete_column_enabled = True
             self.rc_popup_menus_enabled = True
@@ -2617,23 +2552,15 @@ class MainTable(tk.Canvas):
             self.rc_insert_row_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
-        if binding in ("all", "copy", "edit_bindings"):
-            self.copy_enabled = True
-        if binding in ("all", "cut", "edit_bindings"):
-            self.cut_enabled = True
-        if binding in ("all", "paste", "edit_bindings"):
-            self.paste_enabled = True
-        if binding in ("all", "delete", "edit_bindings"):
-            self.delete_key_enabled = True
         if binding in ("all", "right_click_popup_menu", "rc_popup_menu"):
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
         if binding in ("all", "right_click_select", "rc_select"):
             self.rc_select_enabled = True
-        if binding in ("all", "undo", "edit_bindings"):
-            self.undo_enabled = True
-        if binding in ("all", "edit_cell", "edit_bindings"):
+        if binding in ("all", "edit_cell", "edit_bindings", "edit"):
             self.edit_cell_enabled = True
+            for w in (self, self.RI, self.CH):
+                w.bind("<Key>", self.open_cell)
         if binding in ("edit_header"):
             self.CH.edit_cell_enabled = True
         if binding in ("edit_index"):
@@ -2642,7 +2569,12 @@ class MainTable(tk.Canvas):
         if binding in ("ctrl_click_select", "ctrl_select"):
             self.ctrl_select_enabled = True
 
-    def disable_bindings_internal(self, binding):
+    def _tksheet_bind(self, bindings_key: str, func: Callable) -> None:
+        for widget in (self, self.RI, self.CH, self.TL):
+            for binding in self.PAR.ops[bindings_key]:
+                widget.bind(binding, func)
+
+    def _disable_binding(self, binding):
         if binding == "disable_all":
             binding = "all"
         if binding in ("all", "single", "single_selection_mode", "single_select"):
@@ -2653,9 +2585,6 @@ class MainTable(tk.Canvas):
             self.single_selection_enabled = False
         if binding in ("all", "drag_select"):
             self.drag_selection_enabled = False
-        if binding in ("all", "select_all"):
-            self.select_all_enabled = False
-            self.TL.sa_state("hidden")
         if binding in ("all", "column_width_resize"):
             self.CH.width_resizing_enabled = False
         if binding in ("all", "column_select"):
@@ -2678,20 +2607,6 @@ class MainTable(tk.Canvas):
             self.RI.row_selection_enabled = False
         if binding in ("all", "row_drag_and_drop", "move_rows"):
             self.RI.drag_and_drop_enabled = False
-        if binding in ("all", "arrowkeys", "tab"):
-            self.tab_enabled = False
-        if binding in ("all", "arrowkeys", "up"):
-            self.up_enabled = False
-        if binding in ("all", "arrowkeys", "right"):
-            self.right_enabled = False
-        if binding in ("all", "arrowkeys", "down"):
-            self.down_enabled = False
-        if binding in ("all", "arrowkeys", "left"):
-            self.left_enabled = False
-        if binding in ("all", "arrowkeys", "prior"):
-            self.prior_enabled = False
-        if binding in ("all", "arrowkeys", "next"):
-            self.next_enabled = False
         if binding in ("all", "rc_delete_column"):
             self.rc_delete_column_enabled = False
             self.rc_popup_menus_enabled = False
@@ -2708,29 +2623,67 @@ class MainTable(tk.Canvas):
             self.rc_insert_row_enabled = False
             self.rc_popup_menus_enabled = False
             self.rc_select_enabled = False
-        if binding in ("all", "copy", "edit_bindings"):
-            self.copy_enabled = False
-        if binding in ("all", "cut", "edit_bindings"):
-            self.cut_enabled = False
-        if binding in ("all", "paste", "edit_bindings"):
-            self.paste_enabled = False
-        if binding in ("all", "delete", "edit_bindings"):
-            self.delete_key_enabled = False
         if binding in ("all", "right_click_popup_menu", "rc_popup_menu"):
             self.rc_popup_menus_enabled = False
             self.rc_select_enabled = False
         if binding in ("all", "right_click_select", "rc_select"):
             self.rc_select_enabled = False
-        if binding in ("all", "undo", "edit_bindings"):
-            self.undo_enabled = False
-        if binding in ("all", "edit_cell", "edit_bindings"):
+        if binding in ("all", "edit_cell", "edit_bindings", "edit"):
             self.edit_cell_enabled = False
-        if binding in ("all", "edit_header", "edit_bindings"):
+            for w in (self, self.RI, self.CH):
+                w.unbind("<Key>")
+        if binding in ("all", "edit_header", "edit_bindings", "edit"):
             self.CH.edit_cell_enabled = False
-        if binding in ("all", "edit_index", "edit_bindings"):
+        if binding in ("all", "edit_index", "edit_bindings", "edit"):
             self.RI.edit_cell_enabled = False
         if binding in ("all", "ctrl_click_select", "ctrl_select"):
             self.ctrl_select_enabled = False
+        if binding in ("all", "select_all"):
+            self.select_all_enabled = False
+            self.TL.sa_state("hidden")
+            self._tksheet_unbind("select_all_bindings")
+        if binding in ("all", "copy", "edit_bindings", "edit"):
+            self.copy_enabled = False
+            self._tksheet_unbind("copy_bindings")
+        if binding in ("all", "cut", "edit_bindings", "edit"):
+            self.cut_enabled = False
+            self._tksheet_unbind("cut_bindings")
+        if binding in ("all", "paste", "edit_bindings", "edit"):
+            self.paste_enabled = False
+            self._tksheet_unbind("paste_bindings")
+        if binding in ("all", "delete", "edit_bindings", "edit"):
+            self.delete_key_enabled = False
+            self._tksheet_unbind("delete_bindings")
+        if binding in ("all", "arrowkeys", "tab"):
+            self.tab_enabled = False
+            self._tksheet_unbind("tab_bindings")
+        if binding in ("all", "arrowkeys", "up"):
+            self.up_enabled = False
+            self._tksheet_unbind("up_bindings")
+        if binding in ("all", "arrowkeys", "right"):
+            self.right_enabled = False
+            self._tksheet_unbind("right_bindings")
+        if binding in ("all", "arrowkeys", "down"):
+            self.down_enabled = False
+            self._tksheet_unbind("down_bindings")
+        if binding in ("all", "arrowkeys", "left"):
+            self.left_enabled = False
+            self._tksheet_unbind("left_bindings")
+        if binding in ("all", "arrowkeys", "prior"):
+            self.prior_enabled = False
+            self._tksheet_unbind("prior_bindings")
+        if binding in ("all", "arrowkeys", "next"):
+            self.next_enabled = False
+            self._tksheet_unbind("next_bindings")
+        if binding in ("all", "undo", "redo", "edit_bindings", "edit"):
+            self.undo_enabled = False
+            self._tksheet_unbind("undo_bindings", "redo_bindings")
+
+    def _tksheet_unbind(self, *keys) -> None:
+        for widget in (self, self.RI, self.CH, self.TL):
+            for bindings_key in keys:
+                for binding in self.PAR.ops[bindings_key]:
+                    widget.unbind(binding)
 
     def reset_mouse_motion_creations(self) -> None:
         if self.current_cursor != "":
@@ -2745,8 +2698,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 +2711,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 +2729,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 +2755,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 +2923,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 +3035,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 +3059,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:
@@ -3193,47 +3144,71 @@ class MainTable(tk.Canvas):
             self.y_move_synced_scrolls("moveto", self.yview()[0])
         return need_redraw
 
-    def x_move_synced_scrolls(self, *args, redraw: bool = True):
+    def x_move_synced_scrolls(self, *args, redraw: bool = True, use_scrollbar: bool = False):
         for widget in self.synced_scrolls:
             # try:
             if hasattr(widget, "MT"):
-                widget.MT.set_xviews(*args, move_synced=False, redraw=redraw)
+                if use_scrollbar:
+                    widget.MT._xscrollbar(*args, move_synced=False)
+                else:
+                    widget.MT.set_xviews(*args, move_synced=False, redraw=redraw)
             else:
                 widget.xview(*args)
             # except Exception:
             #     continue
 
-    def y_move_synced_scrolls(self, *args, redraw: bool = True):
+    def y_move_synced_scrolls(self, *args, redraw: bool = True, use_scrollbar: bool = False):
         for widget in self.synced_scrolls:
             # try:
             if hasattr(widget, "MT"):
-                widget.MT.set_yviews(*args, move_synced=False, redraw=redraw)
+                if use_scrollbar:
+                    widget.MT._yscrollbar(*args, move_synced=False)
+                else:
+                    widget.MT.set_yviews(*args, move_synced=False, redraw=redraw)
             else:
                 widget.yview(*args)
             # except Exception:
             #     continue
 
+    def _xscrollbar(self, *args, move_synced: bool = True):
+        self.xview(*args)
+        if self.show_header:
+            self.CH.xview(*args)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
+        if move_synced:
+            self.x_move_synced_scrolls(*args, use_scrollbar=True)
+
+    def _yscrollbar(self, *args, move_synced: bool = True):
+        self.yview(*args)
+        if self.show_index:
+            self.RI.yview(*args)
+        self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=True)
+        if move_synced:
+            self.y_move_synced_scrolls(*args, use_scrollbar=True)
+
     def set_xviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
         self.main_table_redraw_grid_and_text(setting_views=True)
         self.update_idletasks()
         self.xview(*args)
         if self.show_header:
+            self.CH.update_idletasks()
             self.CH.xview(*args)
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False)
         if move_synced:
             self.x_move_synced_scrolls(*args)
         self.fix_views()
-        self.PAR.set_refresh_timer(redraw)
 
     def set_yviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
         self.main_table_redraw_grid_and_text(setting_views=True)
         self.update_idletasks()
         self.yview(*args)
         if self.show_index:
+            self.RI.update_idletasks()
             self.RI.yview(*args)
+        self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=True)
         if move_synced:
             self.y_move_synced_scrolls(*args)
         self.fix_views()
-        self.PAR.set_refresh_timer(redraw)
 
     def set_view(self, x_args: list[str, float], y_args: list[str, float]) -> None:
         self.set_xviews(*x_args)
@@ -3329,7 +3304,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 +4251,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 +4837,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 +4865,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 +4873,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):
@@ -5197,8 +5166,7 @@ class MainTable(tk.Canvas):
         resized_cols = False
         resized_rows = False
         if self.PAR.ops.auto_resize_columns and self.allow_auto_resize_columns and col_pos_exists:
-            max_w = int(can_width)
-            max_w -= self.PAR.ops.empty_horizontal
+            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
             else:
@@ -5222,8 +5190,7 @@ class MainTable(tk.Canvas):
                             widths[i] -= change
                 self.set_col_positions(itr=widths)
         if self.PAR.ops.auto_resize_rows and self.allow_auto_resize_rows and row_pos_exists:
-            max_h = int(can_height)
-            max_h -= self.PAR.ops.empty_vertical
+            max_h = can_height - self.PAR.ops.empty_vertical
             if self.PAR.ops.auto_resize_rows < self.min_row_height:
                 min_row_height = self.min_row_height
             else:
@@ -5276,11 +5243,13 @@ class MainTable(tk.Canvas):
             last_col_line_pos + self.PAR.ops.empty_horizontal + 2,
             last_row_line_pos + self.PAR.ops.empty_vertical + 2,
         )
-        if scrollregion != self.scrollregion:
+        if setting_views or scrollregion != self.scrollregion:
             self.configure(scrollregion=scrollregion)
             self.scrollregion = scrollregion
-        if setting_views:
-            return False
+            self.CH.configure_scrollregion(last_col_line_pos)
+            self.RI.configure_scrollregion(last_row_line_pos)
+            if setting_views:
+                return False
         scrollpos_bot = self.canvasy(can_height)
         end_row = bisect_right(self.row_positions, scrollpos_bot)
         if not scrollpos_bot >= self.row_positions[-1]:

tksheet/row_index.py

@@ -391,13 +391,15 @@ class RowIndex(tk.Canvas):
                 )
         elif self.width_resizing_enabled and self.rsz_h is None and self.rsz_w is True:
             self.set_width_of_index_to_text()
-        elif self.row_selection_enabled and self.rsz_h is None and self.rsz_w is None:
+        elif (self.row_selection_enabled or self.PAR.ops.treeview) and self.rsz_h is None and self.rsz_w is None:
             r = self.MT.identify_row(y=event.y)
             if r < len(self.MT.row_positions) - 1:
-                if self.MT.single_selection_enabled:
-                    self.select_row(r, redraw=True)
-                elif self.MT.toggle_selection_enabled:
-                    self.toggle_select_row(r, redraw=True)
+                iid = self.event_over_tree_arrow(r, self.canvasy(event.y), event.x)
+                if self.row_selection_enabled:
+                    if self.MT.single_selection_enabled:
+                        self.select_row(r, redraw=iid is None)
+                    elif self.MT.toggle_selection_enabled:
+                        self.toggle_select_row(r, redraw=iid is None)
                 datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
                 if (
                     self.get_cell_kwargs(datarn, key="dropdown")
@@ -405,8 +407,8 @@ class RowIndex(tk.Canvas):
                     or self.edit_cell_enabled
                 ):
                     self.open_cell(event)
-                elif (iid := self.event_over_tree_arrow(r, self.canvasy(event.y), event.x)) is not None:
-                    self.PAR.item(iid, open_=iid not in self.tree_open_ids, redraw=False)
+                elif iid is not None:
+                    self.PAR.item(iid, open_=iid not in self.tree_open_ids)
         self.rsz_h = None
         self.mouse_motion(event)
         try_binding(self.extra_double_b1_func, event)
@@ -870,7 +872,7 @@ class RowIndex(tk.Canvas):
                 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, 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)
             self.b1_pressed_loc = None
@@ -1189,8 +1191,8 @@ class RowIndex(tk.Canvas):
                 new_w = self.set_width_of_index_to_text(only_rows=only_rows, set_width=False)
             else:
                 new_w = None
-            if new_w is not None and (sheet_w := floor(self.PAR.winfo_width() * 0.5)) < new_w:
-                new_w = sheet_w
+            if new_w is not None and (sheet_w_x := floor(self.PAR.winfo_width() * 0.8)) < new_w:
+                new_w = sheet_w_x
             if new_w and (self.current_width - new_w > 15 or new_w - self.current_width > 5):
                 self.set_width(new_w, set_TL=True)
                 return True
@@ -1392,9 +1394,19 @@ class RowIndex(tk.Canvas):
                 t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
             self.disp_checkbox[t] = True
 
+    def configure_scrollregion(self, last_row_line_pos: float) -> None:
+        self.configure(
+            scrollregion=(
+                0,
+                0,
+                self.current_width,
+                last_row_line_pos + self.PAR.ops.empty_vertical + 2,
+            )
+        )
+
     def redraw_grid_and_text(
         self,
-        last_row_line_pos: int,
+        last_row_line_pos: float,
         scrollpos_top: int,
         y_stop: int,
         start_row: int,
@@ -1403,14 +1415,7 @@ class RowIndex(tk.Canvas):
         row_pos_exists: bool,
     ) -> None:
         try:
-            self.configure(
-                scrollregion=(
-                    0,
-                    0,
-                    self.current_width,
-                    last_row_line_pos + self.PAR.ops.empty_vertical + 2,
-                )
-            )
+            self.configure_scrollregion(last_row_line_pos=last_row_line_pos)
         except Exception:
             return
         self.hidd_text.update(self.disp_text)

tksheet/sheet.py

@@ -46,6 +46,7 @@ from .other_classes import (
     GeneratedMouseEvent,
     Node,
     Selected,
+    SelectionBox,
     Span,
 )
 from .row_index import RowIndex
@@ -401,13 +402,13 @@ class Sheet(tk.Frame):
         self.set_scrollbar_options()
         self.yscroll = ttk.Scrollbar(
             self,
-            command=self.MT.set_yviews,
+            command=self.MT._yscrollbar,
             orient="vertical",
             style=f"Sheet{self.unique_id}.Vertical.TScrollbar",
         )
         self.xscroll = ttk.Scrollbar(
             self,
-            command=self.MT.set_xviews,
+            command=self.MT._xscrollbar,
             orient="horizontal",
             style=f"Sheet{self.unique_id}.Horizontal.TScrollbar",
         )
@@ -592,9 +593,12 @@ class Sheet(tk.Frame):
 
     def extra_bindings(
         self,
-        bindings: str | list | tuple,
+        bindings: str | list | tuple | None = None,
         func: Callable | None = None,
     ) -> Sheet:
+        # bindings is None, unbind all
+        if bindings is None:
+            bindings = "all"
         # bindings is str, func arg is None or Callable
         if isinstance(bindings, str):
             iterable = [(bindings, func)]
@@ -1070,6 +1074,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 +1406,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:
@@ -1927,6 +1938,7 @@ class Sheet(tk.Frame):
         undo: bool = False,
         emit_event: bool = False,
         create_selections: bool = True,
+        add_column_widths: bool = True,
         redraw: bool = True,
     ) -> EventDataDict:
         total_cols = None
@@ -1985,6 +1997,7 @@ class Sheet(tk.Frame):
                 heights=heights,
                 row_index=row_index,
             ),
+            add_col_positions=add_column_widths,
             event_data=event_dict(
                 name="add_rows",
                 sheet=self.name,
@@ -2010,6 +2023,7 @@ class Sheet(tk.Frame):
         undo: bool = False,
         emit_event: bool = False,
         create_selections: bool = True,
+        add_row_heights: bool = True,
         redraw: bool = True,
     ) -> EventDataDict:
         old_total = self.MT.equalize_data_row_lengths()
@@ -2076,6 +2090,7 @@ class Sheet(tk.Frame):
                 widths=widths,
                 headers=headers,
             ),
+            add_row_positions=add_row_heights,
             event_data=event_dict(
                 name="add_columns",
                 sheet=self.name,
@@ -2389,8 +2404,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 +3014,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 +3050,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,
@@ -4073,7 +4124,11 @@ class Sheet(tk.Frame):
     def set_options(self, redraw: bool = True, **kwargs) -> Sheet:
         for k, v in kwargs.items():
             if k in self.ops and v != self.ops[k]:
+                if k.endswith("bindings"):
+                    self.MT._disable_binding(k.split("_")[0])
                 self.ops[k] = v
+                if k.endswith("bindings"):
+                    self.MT._enable_binding(k.split("_")[0])
         if "from_clipboard_delimiters" in kwargs:
             self.ops.from_clipboard_delimiters = (
                 self.ops.from_clipboard_delimiters
@@ -4128,7 +4183,6 @@ class Sheet(tk.Frame):
         if any(k in kwargs for k in scrollbar_options_keys):
             self.set_scrollbar_options()
         self.MT.create_rc_menus()
-        self.MT.key_bindings()
         self.set_refresh_timer(redraw)
         return self
 
@@ -4436,7 +4490,9 @@ class Sheet(tk.Frame):
                     x += 1
                 tally_of_ids[iid] += 1
                 row[iid_column] = new
-            if iid not in self.RI.tree:
+            if iid in self.RI.tree:
+                self.RI.tree[iid].text = row[text_column]
+            else:
                 self.RI.tree[iid] = Node(row[text_column], iid, "")
             if iid == pid or self.RI.pid_causes_recursive_loop(iid, pid):
                 row[parent_column] = ""
@@ -4466,7 +4522,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
@@ -4487,7 +4543,6 @@ class Sheet(tk.Frame):
         Accepts set[str] of iids that are open in the treeview
         Closes everything else
         """
-        self.RI.tree_open_ids = open_ids if isinstance(open_ids, set) else set(open_ids)
         self.hide_rows(
             set(self.MT.displayed_rows),
             redraw=False,
@@ -4499,16 +4554,18 @@ class Sheet(tk.Frame):
             redraw=False,
             deselect_all=True,
         )
+        open_ids = set(filter(self.exists, map(str.lower, open_ids)))
+        self.RI.tree_open_ids = open_ids
         if open_ids:
-            self.tree_open(*open_ids)
+            self.tree_open(open_ids)
         return self
 
     def tree_open(self, *items) -> Sheet:
         """
         If used without args all items are opened
         """
-        if items:
-            for item in unpack(items):
+        if items := set(unpack(items)):
+            for item in filter(items.__contains__, self.get_children()):
                 self.item(item, open_=True)
         else:
             for item in self.get_children():
@@ -4553,9 +4610,6 @@ class Sheet(tk.Frame):
             text = iid
         parent_node = self.RI.tree[pid] if parent else ""
         self.RI.tree[iid] = Node(text, iid, parent_node)
-        if self.RI.pid_causes_recursive_loop(iid, pid):
-            del self.RI.tree[iid]
-            raise ValueError(f"iid '{iid}' causes a recursive loop with parent '{parent}'.")
         if parent_node:
             if isinstance(index, int):
                 idx = self.RI.tree_rns[pid] + index + 1
@@ -4622,24 +4676,25 @@ class Sheet(tk.Frame):
             if self.RI.tree[item].children:
                 if open_:
                     self.RI.tree_open_ids.add(item)
-                    self.show_rows(
-                        (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
-                        redraw=False,
-                        deselect_all=False,
-                    )
+                    if self.item_displayed(item):
+                        self.show_rows(
+                            rows=(self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
+                            redraw=False,
+                            deselect_all=False,
+                        )
                 else:
                     self.RI.tree_open_ids.discard(item)
-                    rows = {self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)}
-                    self.hide_rows(
-                        rows,
-                        redraw=False,
-                        deselect_all=False,
-                        data_indexes=True,
-                    )
+                    if self.item_displayed(item):
+                        self.hide_rows(
+                            rows={self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)},
+                            redraw=False,
+                            deselect_all=False,
+                            data_indexes=True,
+                        )
             else:
                 self.RI.tree_open_ids.discard(item)
         get = not (isinstance(iid, str) or isinstance(text, str) or isinstance(values, list) or isinstance(open_, bool))
-        self.set_refresh_timer(redraw=not get or redraw)
+        self.set_refresh_timer(redraw=not get and redraw)
         if get:
             return DotDict(
                 text=self.RI.tree[item].text,
@@ -4793,7 +4848,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 +5474,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.dist-info → tksheet-7.1.10.dist-info}/METADATA

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

tksheet-7.1.10.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=B-CIT1taBCzsRGcV4R7iv1vUtnLH5fwzUka5wQC2STQ,2014
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=UEnaaqTUy4eNsJw7uGMnqjNoZWnuu5HCMVBDeHYk4lQ,100325
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=ytmHQtSa8cN6dKYLFra5G0393-4sU7bivvT_U4wxksI,39697
+tksheet/main_table.py,sha256=NlEWXb5SEU89AkE0fdmULHW9FX6-GJ565lSxnCeVeDk,318311
+tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
+tksheet/row_index.py,sha256=BnQF-lxH50MfPWlXW94oYSEJXoPewoX29VS7j0X1Jwc,105895
+tksheet/sheet.py,sha256=dvYtZpNJsu6WfjdUKt6RKcwKeDY5c7wZ-tQfL1rjglQ,259484
+tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
+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=8Qxas-m5nU-yMaeAweO4Z30FM9cOQoRTiOsH4kgZp5s,2288
+tksheet-7.1.10.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.1.10.dist-info/METADATA,sha256=2xqqeNuI6pZOFMJ15XWePN15NBcLURYz0PLOvhleu3I,6014
+tksheet-7.1.10.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.1.10.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.1.10.dist-info/RECORD,,

tksheet-7.1.8.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=QkLl7gG86v_1GMYTSGmOr137dpoTBZE2IpCEgCB40d8,1994
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=u5SRsI3VAoqxpUpPQZfu2Zimmf2OmZUBD_hMJKso-pw,100204
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=__21LS0cft9quuzFXcJ0BMbB0DEntvS4NQvreGk2U8Y,39709
-tksheet/main_table.py,sha256=zY5RNV2AyJ3jM8JPMmYrwCXGsnefnVVlXcjaqYxdxvg,318290
-tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
-tksheet/row_index.py,sha256=wfOPHitGfipTysCMfQA-Nl4mJawmkv9gm5CAtIlKgxo,105673
-tksheet/sheet.py,sha256=WvCuIszL31oJLhf0XJpvc0kHxa1yMAwEjiPrjeLkAQ8,257298
-tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
-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=8Qxas-m5nU-yMaeAweO4Z30FM9cOQoRTiOsH4kgZp5s,2288
-tksheet-7.1.8.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.1.8.dist-info/METADATA,sha256=eyi1aRtOSI35o-qYZpAJSZMyYjisRqRyZk_qg1JWx74,6013
-tksheet-7.1.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.1.8.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.1.8.dist-info/RECORD,,