tksheet 7.1.23__tar.gz → 7.2.0__tar.gz

{tksheet-7.1.23/tksheet.egg-info → tksheet-7.2.0}/PKG-INFO

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

{tksheet-7.1.23 → tksheet-7.2.0}/pyproject.toml

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

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/__init__.py

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

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/column_headers.py

@@ -771,11 +771,9 @@ class ColumnHeaders(tk.Canvas):
         return False
 
     def b1_release(self, event: object) -> None:
-        if self.being_drawn_item is not None:
-            to_sel = self.MT.coords_and_type(self.being_drawn_item)
+        if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
             self.MT.hide_selection_box(self.being_drawn_item)
-            self.being_drawn_item = None
             self.MT.set_currently_selected(
                 r_to_sel,
                 c_to_sel,
@@ -784,6 +782,8 @@ class ColumnHeaders(tk.Canvas):
             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)
+        else:
+            self.being_drawn_item = None
         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
@@ -1607,11 +1607,11 @@ class ColumnHeaders(tk.Canvas):
 
     def get_redraw_selections(self, startc: int, endc: int) -> dict[str, set[int]]:
         d = defaultdict(set)
-        for item, box in self.MT.get_selection_items(rows=False):
+        for item, box in self.MT.get_selection_items():
             r1, c1, r2, c2 = box.coords
             for c in range(startc, endc):
                 if c1 <= c and c2 > c:
-                    d[box.type_].add(c)
+                    d[box.type_ if box.type_ != "rows" else "cells"].add(c)
         return d
 
     def open_cell(self, event: object = None, ignore_existing_editor=False):

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/main_table.py

@@ -683,9 +683,9 @@ class MainTable(tk.Canvas):
         return event_data
 
     def ctrl_v(self, event: object = None, validation: bool = True) -> None | EventDataDict:
-        if not self.PAR.ops.expand_sheet_if_paste_too_big and (
-            len(self.col_positions) == 1 or len(self.row_positions) == 1
-        ):
+        if not self.PAR.ops.paste_can_expand_x and len(self.col_positions) == 1:
+            return
+        if not self.PAR.ops.paste_can_expand_y and len(self.row_positions) == 1:
             return
         event_data = event_dict(
             name="edit_table",
@@ -696,7 +696,7 @@ class MainTable(tk.Canvas):
         if self.selected:
             selected_r = self.selected.row
             selected_c = self.selected.column
-        elif not self.selected and not self.PAR.ops.expand_sheet_if_paste_too_big:
+        elif not self.selected and not self.PAR.ops.paste_can_expand_x and not self.PAR.ops.paste_can_expand_y:
             return
         else:
             if not self.data:
@@ -721,32 +721,31 @@ class MainTable(tk.Canvas):
         for rn, r in enumerate(data):
             if len(r) < new_data_numcols:
                 data[rn] += list(repeat("", new_data_numcols - len(r)))
-        (
-            lastbox_r1,
-            lastbox_c1,
-            lastbox_r2,
-            lastbox_c2,
-        ) = self.selection_boxes[self.selected.fill_iid].coords
-        lastbox_numrows = lastbox_r2 - lastbox_r1
-        lastbox_numcols = lastbox_c2 - lastbox_c1
-        if lastbox_numrows > new_data_numrows and not lastbox_numrows % new_data_numrows:
-            nd = []
-            for _ in range(int(lastbox_numrows / new_data_numrows)):
-                nd.extend(r.copy() for r in data)
-            data.extend(nd)
-            new_data_numrows *= int(lastbox_numrows / new_data_numrows)
-
-        if lastbox_numcols > new_data_numcols and not lastbox_numcols % new_data_numcols:
-            for rn, r in enumerate(data):
-                for _ in range(int(lastbox_numcols / new_data_numcols)):
-                    data[rn].extend(r.copy())
-            new_data_numcols *= int(lastbox_numcols / new_data_numcols)
+        if self.selected:
+            (
+                lastbox_r1,
+                lastbox_c1,
+                lastbox_r2,
+                lastbox_c2,
+            ) = self.selection_boxes[self.selected.fill_iid].coords
+            lastbox_numrows = lastbox_r2 - lastbox_r1
+            lastbox_numcols = lastbox_c2 - lastbox_c1
+            if lastbox_numrows > new_data_numrows and not lastbox_numrows % new_data_numrows:
+                nd = []
+                for _ in range(int(lastbox_numrows / new_data_numrows)):
+                    nd.extend(r.copy() for r in data)
+                data.extend(nd)
+                new_data_numrows *= int(lastbox_numrows / new_data_numrows)
+            if lastbox_numcols > new_data_numcols and not lastbox_numcols % new_data_numcols:
+                for rn, r in enumerate(data):
+                    for _ in range(int(lastbox_numcols / new_data_numcols)):
+                        data[rn].extend(r.copy())
+                new_data_numcols *= int(lastbox_numcols / new_data_numcols)
         event_data["data"] = data
         added_rows = 0
         added_cols = 0
         total_data_cols = None
-        if self.PAR.ops.expand_sheet_if_paste_too_big:
-            # determine number of columns and/or rows to add to sheet
+        if self.PAR.ops.paste_can_expand_x:
             if selected_c + new_data_numcols > len(self.col_positions) - 1:
                 total_data_cols = self.equalize_data_row_lengths()
                 added_cols = selected_c + new_data_numcols - len(self.col_positions) + 1
@@ -755,6 +754,7 @@ class MainTable(tk.Canvas):
                     and self.PAR.ops.paste_insert_column_limit < len(self.col_positions) - 1 + added_cols
                 ):
                     added_cols = self.PAR.ops.paste_insert_column_limit - len(self.col_positions) - 1
+        if self.PAR.ops.paste_can_expand_y:
             if selected_r + new_data_numrows > len(self.row_positions) - 1:
                 added_rows = selected_r + new_data_numrows - len(self.row_positions) + 1
                 if (
@@ -772,6 +772,7 @@ class MainTable(tk.Canvas):
             adjusted_new_data_numrows = new_data_numrows
         selected_r_adjusted_new_data_numrows = selected_r + adjusted_new_data_numrows
         selected_c_adjusted_new_data_numcols = selected_c + adjusted_new_data_numcols
+        endrow = selected_r_adjusted_new_data_numrows
         boxes = {
             (
                 selected_r,
@@ -807,7 +808,7 @@ class MainTable(tk.Canvas):
                         value=val,
                         event_data=event_data,
                     )
-        if added_rows > 0:
+        if added_rows:
             ctr = 0
             data_ins_row = len(self.data)
             displayed_ins_row = len(self.row_positions) - 1
@@ -817,6 +818,7 @@ class MainTable(tk.Canvas):
                 data_ins_row=data_ins_row,
                 displayed_ins_row=displayed_ins_row,
                 numrows=added_rows,
+                total_data_cols=total_data_cols,
             )
             for ndr, r in zip(
                 range(
@@ -851,8 +853,10 @@ class MainTable(tk.Canvas):
                     row_heights=row_heights,
                     event_data=event_data,
                 )
-        if added_cols > 0:
+        if added_cols:
             ctr = 0
+            if total_data_cols is None:
+                total_data_cols = self.total_data_cols()
             data_ins_col = total_data_cols
             displayed_ins_col = len(self.col_positions) - 1
             columns, headers, column_widths = self.get_args_for_add_columns(
@@ -860,10 +864,15 @@ class MainTable(tk.Canvas):
                 displayed_ins_col=displayed_ins_col,
                 numcols=added_cols,
             )
+            # only add the extra rows if expand_y is allowed
+            if self.PAR.ops.paste_can_expand_x and self.PAR.ops.paste_can_expand_y:
+                endrow = selected_r + new_data_numrows
+            else:
+                endrow = selected_r + adjusted_new_data_numrows
             for ndr, r in enumerate(
                 range(
                     selected_r,
-                    selected_r + new_data_numrows,
+                    endrow,
                 )
             ):
                 for ndc, c in zip(
@@ -896,11 +905,19 @@ class MainTable(tk.Canvas):
         self.deselect("all", redraw=False)
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
             self.undo_stack.append(pickled_event_dict(event_data))
+        if added_rows:
+            selboxr = selected_r + new_data_numrows
+        else:
+            selboxr = selected_r_adjusted_new_data_numrows
+        if added_cols:
+            selboxc = selected_c + new_data_numcols
+        else:
+            selboxc = selected_c_adjusted_new_data_numcols
         self.create_selection_box(
             selected_r,
             selected_c,
-            selected_r_adjusted_new_data_numrows,
-            selected_c_adjusted_new_data_numcols,
+            selboxr,
+            selboxc,
             "cells",
             run_binding=True,
         )
@@ -1260,7 +1277,7 @@ class MainTable(tk.Canvas):
                 len(self.row_positions) - 1,
                 max(data_new_idxs.values(), default=0),
             )
-            totalrows = self.fix_data_len(totalrows)
+            self.fix_data_len(totalrows)
         if event_data is None:
             event_data = event_dict(
                 name="move_rows",
@@ -2421,7 +2438,7 @@ class MainTable(tk.Canvas):
                 command=self.ctrl_v,
                 **mnkwgs,
             )
-            if self.PAR.ops.expand_sheet_if_paste_too_big:
+            if self.PAR.ops.paste_can_expand_x or self.PAR.ops.paste_can_expand_y:
                 self.menu_add_command(
                     self.empty_rc_popup_menu,
                     label=self.PAR.ops.paste_label,
@@ -3062,11 +3079,9 @@ class MainTable(tk.Canvas):
             self.b1_motion(event)
 
     def b1_release(self, event=None):
-        if self.being_drawn_item is not None:
-            to_sel = self.coords_and_type(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,
@@ -3084,6 +3099,8 @@ class MainTable(tk.Canvas):
             if self.drag_selection_binding_func:
                 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()
@@ -3449,7 +3466,7 @@ class MainTable(tk.Canvas):
     def get_lines_cell_height(self, n, font=None):
         return (
             self.get_txt_h(
-                txt="\n".join("|" for lines in range(n)) if n > 1 else "|",
+                txt="\n".join("|" for _ in range(n)) if n > 1 else "|",
                 font=self.PAR.ops.table_font if font is None else font,
             )
             + 5
@@ -3467,12 +3484,20 @@ class MainTable(tk.Canvas):
 
     def get_default_row_height(self) -> int:
         if isinstance(self.PAR.ops.default_row_height, str):
-            return self.get_lines_cell_height(int(self.PAR.ops.default_row_height))
+            if int(self.PAR.ops.default_row_height) == 1:
+                return self.min_row_height
+            else:
+                return self.min_row_height + self.get_lines_cell_height(int(self.PAR.ops.default_row_height) - 1)
         return self.PAR.ops.default_row_height
 
     def get_default_header_height(self) -> int:
         if isinstance(self.PAR.ops.default_header_height, str):
-            return self.get_lines_cell_height(int(self.PAR.ops.default_header_height), font=self.PAR.ops.header_font)
+            if int(self.PAR.ops.default_header_height) == 1:
+                return self.min_header_height
+            else:
+                return self.min_header_height + self.get_lines_cell_height(
+                    int(self.PAR.ops.default_header_height) - 1, font=self.PAR.ops.header_font
+                )
         return self.PAR.ops.default_header_height
 
     def set_table_font(self, newfont: tuple | None = None, reset_row_positions: bool = False) -> tuple[str, int, str]:
@@ -3502,8 +3527,8 @@ class MainTable(tk.Canvas):
             self.table_first_ln_ins = self.table_half_txt_height + 2
         else:
             self.table_first_ln_ins = self.table_half_txt_height + 3
+        self.min_row_height = int(self.table_first_ln_ins * 2.25)
         self.table_xtra_lines_increment = int(self.table_txt_height)
-        self.min_row_height = self.table_txt_height + 5
         if self.min_row_height < 12:
             self.min_row_height = 12
         self.set_min_column_width()
@@ -3531,7 +3556,7 @@ class MainTable(tk.Canvas):
         else:
             self.header_first_ln_ins = self.header_half_txt_height + 3
         self.header_xtra_lines_increment = self.header_txt_height
-        self.min_header_height = self.header_txt_height + 5
+        self.min_header_height = int(self.header_first_ln_ins * 2.25)
         if (
             isinstance(self.PAR.ops.default_header_height, int)
             and self.PAR.ops.default_header_height < self.min_header_height
@@ -4295,13 +4320,12 @@ class MainTable(tk.Canvas):
                 column_widths,
             )
         )
-        # we're inserting so we can use indexes == len for
-        # fix functions, the values will go on the end
+        # rn needed for indexing but cn insert
         maxrn = 0
         for cn, rowdict in reversed(columns.items()):
             for rn, v in rowdict.items():
-                if rn > len(self.data):
-                    self.fix_data_len(rn - 1, cn - 1)
+                if rn >= len(self.data):
+                    self.fix_data_len(rn, cn - 1)
                 if rn > maxrn:
                     maxrn = rn
                 self.data[rn].insert(cn, v)
@@ -4314,7 +4338,7 @@ class MainTable(tk.Canvas):
                     (default_row_height for i in range(len(self.row_positions) - 1, maxrn + 1)),
                 )
             )
-        if isinstance(self._headers, list):
+        if isinstance(self._headers, list) and header:
             self._headers = insert_items(self._headers, header, self.CH.fix_header)
         if push_ops:
             self.adjust_options_post_add_columns(
@@ -4431,6 +4455,7 @@ class MainTable(tk.Canvas):
             )
         )
         maxcn = 0
+        # rn needed for insert but cn indexing
         for rn, row in reversed(rows.items()):
             cn = len(row) - 1
             if rn > len(self.data):
@@ -4438,7 +4463,7 @@ class MainTable(tk.Canvas):
             self.data.insert(rn, row)
             if cn > maxcn:
                 maxcn = cn
-        if isinstance(self._row_index, list):
+        if isinstance(self._row_index, list) and index:
             self._row_index = insert_items(self._row_index, index, self.RI.fix_index)
         # if not hiding columns then we can extend col positions if necessary
         if add_col_positions and self.all_columns_displayed and maxcn + 1 > len(self.col_positions) - 1:
@@ -4540,16 +4565,16 @@ class MainTable(tk.Canvas):
                     datacn: column[0]
                     for datacn, column in zip(reversed(range(data_ins_col, data_ins_col + numcols)), reversed(columns))
                 }
-            elif columns:
+            else:
                 header_data = {
                     datacn: self.CH.get_value_for_empty_cell(datacn, c_ops=False)
                     for datacn in reversed(range(data_ins_col, data_ins_col + numcols))
                 }
         if columns is None:
+            rowrange = len(self.data) if self.data else 1
             columns = {
                 datacn: {
-                    datarn: self.get_value_for_empty_cell(datarn, datacn, c_ops=False)
-                    for datarn in range(len(self.data))
+                    datarn: self.get_value_for_empty_cell(datarn, datacn, c_ops=False) for datarn in range(rowrange)
                 }
                 for datacn in reversed(range(data_ins_col, data_ins_col + numcols))
             }
@@ -4591,7 +4616,7 @@ class MainTable(tk.Canvas):
                     datarn: v[0]
                     for datarn, v in zip(reversed(range(data_ins_row, data_ins_row + numrows)), reversed(rows))
                 }
-            elif rows:
+            else:
                 index_data = {
                     datarn: self.RI.get_value_for_empty_cell(datarn, r_ops=False)
                     for datarn in reversed(range(data_ins_row, data_ins_row + numrows))
@@ -4599,8 +4624,9 @@ class MainTable(tk.Canvas):
         if rows is None:
             if total_data_cols is None:
                 total_data_cols = self.total_data_cols()
+            colrange = total_data_cols if total_data_cols else 1
             rows = {
-                datarn: [self.get_value_for_empty_cell(datarn, c, c_ops=False) for c in range(total_data_cols)]
+                datarn: [self.get_value_for_empty_cell(datarn, c, c_ops=False) for c in range(colrange)]
                 for datarn in reversed(range(data_ins_row, data_ins_row + numrows))
             }
         else:
@@ -4971,7 +4997,7 @@ class MainTable(tk.Canvas):
             total_data_cols = at_least_cols
         total_data_cols = max(total_data_cols, len(self.col_positions) - 1)
         if not isinstance(self._headers, int) and include_header and total_data_cols > len(self._headers):
-            self.CH.fix_header(total_data_cols)
+            self.CH.fix_header(total_data_cols - 1)
         for rn, r in enumerate(self.data):
             if total_data_cols > (lnr := len(r)):
                 r += self.get_empty_row_seq(rn, end=total_data_cols, start=lnr)
@@ -5363,6 +5389,10 @@ class MainTable(tk.Canvas):
         if resized_cols or resized_rows or changed_w:
             self.recreate_all_selection_boxes()
             if changed_w:
+                self.update_idletasks()
+                self.RI.update_idletasks()
+                self.CH.update_idletasks()
+                self.TL.update_idletasks()
                 return False
         self.hidd_text.update(self.disp_text)
         self.disp_text = {}
@@ -5916,6 +5946,8 @@ class MainTable(tk.Canvas):
         if self.selected.fill_iid == item:
             self.hide_selected()
             self.set_current_to_last()
+        if item == self.being_drawn_item:
+            self.being_drawn_item = None
         return True
 
     def hide_selected(self) -> None:
@@ -6978,9 +7010,9 @@ class MainTable(tk.Canvas):
         return self.mouseclick_outside_editor_or_dropdown()
 
     def hide_dropdown_editor_all_canvases(self):
-        self.hide_text_editor_and_dropdown()
-        self.RI.hide_text_editor_and_dropdown()
-        self.CH.hide_text_editor_and_dropdown()
+        self.hide_text_editor_and_dropdown(redraw=False)
+        self.RI.hide_text_editor_and_dropdown(redraw=False)
+        self.CH.hide_text_editor_and_dropdown(redraw=False)
 
     def hide_dropdown_window(self) -> None:
         if self.dropdown.open:

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/row_index.py

@@ -173,14 +173,14 @@ class RowIndex(tk.Canvas):
             self.MT.row_positions = [0]
             self.MT.saved_row_heights = {}
 
-    def set_width(self, new_width: int, set_TL: bool = False) -> None:
+    def set_width(self, new_width: int, set_TL: bool = False, recreate_selection_boxes: bool = True) -> None:
         self.current_width = new_width
         try:
             self.config(width=new_width)
         except Exception:
             return
         if set_TL:
-            self.TL.set_dimensions(new_w=new_width)
+            self.TL.set_dimensions(new_w=new_width, recreate_selection_boxes=recreate_selection_boxes)
 
     def rc(self, event: object) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -772,11 +772,9 @@ class RowIndex(tk.Canvas):
         return False
 
     def b1_release(self, event: object) -> None:
-        if self.being_drawn_item is not None:
-            to_sel = self.MT.coords_and_type(self.being_drawn_item)
+        if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
             self.MT.hide_selection_box(self.being_drawn_item)
-            self.being_drawn_item = None
             self.MT.set_currently_selected(
                 r_to_sel,
                 c_to_sel,
@@ -785,6 +783,8 @@ class RowIndex(tk.Canvas):
             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)
+        else:
+            self.being_drawn_item = None
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             self.currently_resizing_height = False
@@ -1030,7 +1030,7 @@ class RowIndex(tk.Canvas):
                 align = self.align
             if align == "w":
                 w += self.MT.index_txt_height
-            w += self.get_treeview_indent(self.MT._row_index[datarn].iid) + 4
+            w += self.get_treeview_indent(self.MT._row_index[datarn].iid) + 5
         return w, h
 
     def set_row_height(
@@ -1205,8 +1205,8 @@ class RowIndex(tk.Canvas):
             new_w = None
         if new_w is not None and (sheet_w_x := floor(self.PAR.winfo_width() * 0.7)) < new_w:
             new_w = sheet_w_x
-        if new_w and (self.current_width - new_w > 15 or new_w - self.current_width > 3):
-            self.set_width(new_w, set_TL=True)
+        if new_w and (self.current_width - new_w > 20 or new_w - self.current_width > 3):
+            self.set_width(new_w, set_TL=True, recreate_selection_boxes=False)
             return True
         return False
 
@@ -1310,7 +1310,8 @@ class RowIndex(tk.Canvas):
         mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
         half_mod = mod / 2
         qtr_mod = mod / 4
-        mid_y = (self.MT.index_first_ln_ins - 1) if self.MT.index_first_ln_ins % 2 else self.MT.index_first_ln_ins
+        small_mod = int(half_mod / 4) - 1
+        mid_y = int(self.MT.min_row_height / 2)
         # up arrow
         if open_:
             points = (
@@ -1325,11 +1326,11 @@ class RowIndex(tk.Canvas):
         else:
             points = (
                 x1 + half_mod + indent,
-                y1 + mid_y - half_mod + 1,
-                x1 + mod + indent - 1,
+                y1 + mid_y - half_mod + small_mod,
+                x1 + mod + indent - small_mod,
                 y1 + mid_y,
                 x1 + half_mod + indent,
-                y1 + mid_y + half_mod - 1,
+                y1 + mid_y + half_mod - small_mod,
             )
         if self.hidd_tree_arrow:
             t, sh = self.hidd_tree_arrow.popitem()
@@ -1340,10 +1341,13 @@ class RowIndex(tk.Canvas):
                 self.itemconfig(t, fill=fill, tag=tag, state="normal")
             self.lift(t)
         else:
-            t = self.create_polygon(
+            t = self.create_line(
                 points,
                 fill=fill,
                 tag=tag,
+                width=2,
+                capstyle=tk.ROUND,
+                joinstyle=tk.BEVEL,
             )
         self.disp_tree_arrow[t] = True
 
@@ -1633,7 +1637,7 @@ class RowIndex(tk.Canvas):
                 if align == "w":
                     draw_x += self.MT.index_txt_height + 1
                 indent = self.get_treeview_indent(iid)
-                draw_x += indent + 4
+                draw_x += indent + 5
                 if self.tree[iid].children:
                     self.redraw_tree_arrow(
                         0,
@@ -1738,11 +1742,11 @@ class RowIndex(tk.Canvas):
 
     def get_redraw_selections(self, startr: int, endr: int) -> dict[str, set[int]]:
         d = defaultdict(set)
-        for item, box in self.MT.get_selection_items(columns=False):
+        for item, box in self.MT.get_selection_items():
             r1, c1, r2, c2 = box.coords
             for r in range(startr, endr):
                 if r1 <= r and r2 > r:
-                    d[box.type_].add(r)
+                    d[box.type_ if box.type_ != "columns" else "cells"].add(r)
         return d
 
     def open_cell(self, event: object = None, ignore_existing_editor=False):

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/sheet.py

@@ -130,7 +130,8 @@ class Sheet(tk.Frame):
         show_default_header_for_empty: bool = True,
         show_default_index_for_empty: bool = True,
         page_up_down_select_row: bool = True,
-        expand_sheet_if_paste_too_big: bool = False,
+        paste_can_expand_x: bool = False,
+        paste_can_expand_y: bool = False,
         paste_insert_column_limit: int | None = None,
         paste_insert_row_limit: int | None = None,
         show_dropdown_borders: bool = False,
@@ -265,6 +266,7 @@ class Sheet(tk.Frame):
         header_height: str | int | None = None,
         row_height: str | int | None = None,
         row_index_width: int | None = None,
+        expand_sheet_if_paste_too_big: bool | None = None,
     ) -> None:
         tk.Frame.__init__(
             self,
@@ -283,6 +285,9 @@ class Sheet(tk.Frame):
             default_row_height = row_height
         if row_index_width is not None:
             default_row_index_width = row_index_width
+        if expand_sheet_if_paste_too_big is not None:
+            paste_can_expand_x = expand_sheet_if_paste_too_big
+            paste_can_expand_y = expand_sheet_if_paste_too_big
         if treeview:
             index_align = "w"
             auto_resize_row_index = True
@@ -1459,6 +1464,8 @@ class Sheet(tk.Frame):
         undo_stack: bool = True,
         selections: bool = True,
         sheet_options: bool = False,
+        displayed_rows: bool = True,
+        displayed_columns: bool = True,
         tree: bool = True,
         redraw: bool = True,
     ) -> Sheet:
@@ -1471,6 +1478,12 @@ class Sheet(tk.Frame):
         if index:
             self.RI.hide_text_editor_and_dropdown(redraw=False)
             self.MT._row_index = []
+        if displayed_columns:
+            self.MT.displayed_columns = []
+            self.MT.all_columns_displayed = True
+        if displayed_rows:
+            self.MT.displayed_rows = []
+            self.MT.all_rows_displayed = True
         if row_heights:
             self.MT.saved_row_heights = {}
             self.MT.set_row_positions([])
@@ -3579,6 +3592,20 @@ class Sheet(tk.Frame):
             z < self.MT.min_column_width or not isinstance(z, int) or isinstance(z, bool) for z in column_widths
         )
 
+    def valid_row_height(self, height: int) -> int:
+        if height < self.MT.min_row_height:
+            return self.MT.min_row_height
+        elif height > self.MT.max_row_height:
+            return self.MT.max_row_height
+        return height
+
+    def valid_column_width(self, width: int) -> int:
+        if width < self.MT.min_column_width:
+            return self.MT.min_column_width
+        elif width > self.MT.max_column_width:
+            return self.MT.max_column_width
+        return width
+
     # Identifying Bound Event Mouse Position
 
     def identify_region(self, event: object) -> Literal["table", "index", "header", "top left"]:
@@ -4178,10 +4205,13 @@ class Sheet(tk.Frame):
             self.MT.max_header_height = float(kwargs["max_header_height"])
         if "max_index_width" in kwargs:
             self.MT.max_index_width = float(kwargs["max_index_width"])
+        if "expand_sheet_if_paste_too_big" in kwargs:
+            self.ops.paste_can_expand_x = kwargs["expand_sheet_if_paste_too_big"]
+            self.ops.paste_can_expand_y = kwargs["expand_sheet_if_paste_too_big"]
         if "font" in kwargs:
             self.MT.set_table_font(kwargs["font"])
         elif "table_font" in kwargs:
-            self.MT.set_table_font(kwargs["font"])
+            self.MT.set_table_font(kwargs["table_font"])
         if "header_font" in kwargs:
             self.MT.set_header_font(kwargs["header_font"])
         if "index_font" in kwargs:
@@ -4504,6 +4534,7 @@ class Sheet(tk.Frame):
         safety: bool = True,
         ncols: int | None = None,
     ) -> Sheet:
+        self.reset(cell_options=False, column_widths=False, header=False, redraw=False)
         if text_column is None:
             text_column = iid_column
         tally_of_ids = defaultdict(lambda: -1)
@@ -4556,6 +4587,8 @@ class Sheet(tk.Frame):
             fill=False,
             push_ops=push_ops,
         )
+        self.MT.all_rows_displayed = False
+        self.MT.displayed_rows = list(range(len(self.MT._row_index)))
         self.RI.tree_rns = {n.iid: i for i, n in enumerate(self.MT._row_index)}
         if open_ids:
             self.tree_set_open(open_ids=open_ids)
@@ -4600,16 +4633,23 @@ class Sheet(tk.Frame):
                 deselect_all=False,
             )
         return self.set_refresh_timer(True)
-    
+
     def _tree_open(self, items: set[str]) -> list[int]:
         """
         Only meant for internal use
         """
         to_open = []
+        disp_set = set(self.MT.displayed_rows)
+        quick_rns = self.RI.tree_rns
+        quick_open_ids = self.RI.tree_open_ids
         for item in filter(items.__contains__, self.get_children()):
             if self.RI.tree[item].children:
-                self.RI.tree_open_ids.add(item)
-                to_open.extend(self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True))
+                quick_open_ids.add(item)
+                if quick_rns[item] in disp_set:
+                    to_disp = [quick_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)]
+                    for i in to_disp:
+                        disp_set.add(i)
+                    to_open.extend(to_disp)
         return to_open
 
     def tree_open(self, *items, redraw: bool = True) -> Sheet:
@@ -4619,36 +4659,37 @@ class Sheet(tk.Frame):
         if items := set(unpack(items)):
             to_open = self._tree_open(items)
         else:
-            to_open = []
-            for item in self.get_children():
-                if self.RI.tree[item].children:
-                    self.RI.tree_open_ids.add(item)
-                    to_open.extend(self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True))
+            to_open = self._tree_open(set(self.get_children()))
         return self.show_rows(
             rows=to_open,
             redraw=redraw,
             deselect_all=False,
         )
 
+    def _tree_close(self, items: Iterator[str]) -> list[int]:
+        """
+        Only meant for internal use
+        """
+        to_close = set()
+        disp_set = set(self.MT.displayed_rows)
+        quick_rns = self.RI.tree_rns
+        quick_open_ids = self.RI.tree_open_ids
+        for item in items:
+            if self.RI.tree[item].children:
+                quick_open_ids.discard(item)
+                if quick_rns[item] in disp_set:
+                    for did in self.RI.get_iid_descendants(item, check_open=True):
+                        to_close.add(quick_rns[did])
+        return to_close
+
     def tree_close(self, *items, redraw: bool = True) -> Sheet:
         """
         If used without args all items are closed
         """
-        to_close = set()
         if items:
-            for item in unpack(items):
-                if self.RI.tree[item].children:
-                    self.RI.tree_open_ids.discard(item)
-                    if self.RI.tree_rns[item] in self.MT.displayed_rows:
-                        for did in self.RI.get_iid_descendants(item, check_open=True):
-                            to_close.add(self.RI.tree_rns[did])
+            to_close = self._tree_close(unpack(items))
         else:
-            for item in self.get_children():
-                if self.RI.tree[item].children:
-                    self.RI.tree_open_ids.discard(item)
-                    if self.RI.tree_rns[item] in self.MT.displayed_rows:
-                        for did in self.RI.get_iid_descendants(item, check_open=True):
-                            to_close.add(self.RI.tree_rns[did])
+            to_close = self._tree_close(self.get_children())
         return self.hide_rows(
             rows=to_close,
             redraw=redraw,

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/sheet_options.py

@@ -218,7 +218,8 @@ def new_sheet_options() -> DotDict:
             "default_column_width": 120,
             "default_row_index_width": 70,
             "page_up_down_select_row": True,
-            "expand_sheet_if_paste_too_big": False,
+            "paste_can_expand_x": False,
+            "paste_can_expand_y": False,
             "paste_insert_column_limit": None,
             "paste_insert_row_limit": None,
             "arrow_key_down_right_scroll_page": False,

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/text_editor.py

@@ -26,7 +26,7 @@ class TextEditorTkText(tk.Text):
             self,
             parent,
             spacing1=0,
-            spacing2=0,
+            spacing2=1,
             spacing3=0,
             bd=0,
             highlightthickness=0,

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/themes.py

@@ -46,8 +46,8 @@ theme_light_blue: dict[str, str] = DotDict({
     "table_selected_columns_border_fg": "#0B57D0",
     "table_selected_columns_bg": "#E6EFFD",
     "table_selected_columns_fg": "black",
-    "tree_arrow_fg": "#C4C7C5",
-    "selected_cells_tree_arrow_fg": "#D3E3FD",
+    "tree_arrow_fg": "black",
+    "selected_cells_tree_arrow_fg": "black",
     "selected_rows_tree_arrow_fg": "#FFFFFF",
     "vertical_scroll_background": "#FFFFFF",
     "horizontal_scroll_background": "#FFFFFF",
@@ -121,7 +121,7 @@ theme_light_green: dict[str, str] = DotDict({
     "table_selected_columns_border_fg": "#107C41",
     "table_selected_columns_bg": "#E3E3E3",
     "table_selected_columns_fg": "black",
-    "tree_arrow_fg": "#ababab",
+    "tree_arrow_fg": "black",
     "selected_cells_tree_arrow_fg": "#107C41",
     "selected_rows_tree_arrow_fg": "#FFFFFF",
     "vertical_scroll_background": "#FFFFFF",
@@ -272,8 +272,8 @@ theme_black: dict[str, str] = DotDict({
     "table_selected_columns_bg": "#404040",
     "table_selected_columns_fg": "#F7F7F7",
     "tree_arrow_fg": "#8C8C8C",
-    "selected_cells_tree_arrow_fg": "#8C8C8C",
-    "selected_rows_tree_arrow_fg": "#8C8C8C",
+    "selected_cells_tree_arrow_fg": "#FBB86C",
+    "selected_rows_tree_arrow_fg": "#000000",
     "vertical_scroll_background": "#3b3a39",
     "horizontal_scroll_background": "#3b3a39",
     "vertical_scroll_troughcolor": "#000000",

{tksheet-7.1.23 → tksheet-7.2.0}/tksheet/top_left_rectangle.py

@@ -156,7 +156,7 @@ class TopLeftRectangle(tk.Canvas):
             self.unbind("<Double-Button-1>")
             self.unbind(rc_binding)
 
-    def set_dimensions(self, new_w=None, new_h=None) -> None:
+    def set_dimensions(self, new_w=None, new_h=None, recreate_selection_boxes: bool = True) -> None:
         try:
             if new_h is None:
                 h = self.winfo_height()
@@ -182,7 +182,8 @@ class TopLeftRectangle(tk.Canvas):
             h - 7,
         )
         self.coords(self.select_all_box, 0, 0, w - 5, h - 5)
-        self.MT.recreate_all_selection_boxes()
+        if recreate_selection_boxes:
+            self.MT.recreate_all_selection_boxes()
 
     def mouse_motion(self, event: object = None) -> None:
         self.MT.reset_mouse_motion_creations()

{tksheet-7.1.23 → tksheet-7.2.0/tksheet.egg-info}/PKG-INFO

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