tksheet 7.1.4__py3-none-any.whl → 7.1.6__py3-none-any.whl

tksheet/row_index.py

@@ -18,6 +18,7 @@ from math import (
     ceil,
     floor,
 )
+from typing import Literal
 
 from .colors import (
     color_map,
@@ -266,7 +267,9 @@ class RowIndex(tk.Canvas):
                     if self.MT.selected and self.MT.selected.type_ == "rows":
                         r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
                         self.MT.deselect("all", redraw=False)
-                        self.being_drawn_item = self.MT.create_selection_box(*self.get_shift_select_box(r, r_to_sel), "rows")
+                        self.being_drawn_item = self.MT.create_selection_box(
+                            *self.get_shift_select_box(r, r_to_sel), "rows"
+                        )
                         self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
                     else:
                         self.being_drawn_item = self.select_row(r, run_binding_func=False)
@@ -864,6 +867,8 @@ class RowIndex(tk.Canvas):
                 ):
                     self.open_cell(event)
                 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)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -1012,11 +1017,10 @@ class RowIndex(tk.Canvas):
                     x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
                     start_col, end_col = self.MT.get_visible_columns(x1, x2)
                 else:
-                    start_col, end_col = (
-                        0,
-                        len(self.MT.data[row]) if self.MT.data else 0,
-                    )
-                iterable = range(start_col, end_col)
+                    if not self.MT.data or datarn >= len(self.MT.data):
+                        iterable = range(0, 0)
+                    else:
+                        iterable = range(0, len(self.MT.data[datarn]))
             else:
                 if displayed_only:
                     x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
@@ -1710,8 +1714,7 @@ class RowIndex(tk.Canvas):
                     extra_func_key = "Return"
                 elif hasattr(event, "keysym") and event.keysym == "F2":
                     extra_func_key = "F2"
-            datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
-            text = self.get_cell_data(datarn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datarn(r), none_to_empty_str=True, redirect_int=True)
         elif event is not None and (
             (hasattr(event, "keysym") and event.keysym == "BackSpace") or event.keycode in (8, 855638143)
         ):
@@ -1756,12 +1759,11 @@ class RowIndex(tk.Canvas):
         if not self.MT.see(r=r, c=0, keep_yscroll=True, check_cell_visibility=True):
             self.MT.refresh()
         x = 0
-        y = self.MT.row_positions[r] + 1
+        y = self.MT.row_positions[r]
         w = self.current_width + 1
-        h = self.MT.row_positions[r + 1] - y
-        datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
+        h = self.MT.row_positions[r + 1] - y + 1
         if text is None:
-            text = self.get_cell_data(datarn, none_to_empty_str=True, redirect_int=True)
+            text = self.get_cell_data(self.MT.datarn(r), none_to_empty_str=True, redirect_int=True)
         bg, fg = self.PAR.ops.index_bg, self.PAR.ops.index_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -1774,12 +1776,12 @@ class RowIndex(tk.Canvas):
                 }
             ),
             "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.table_selected_cells_border_fg,
+            "border_color": self.PAR.ops.index_selected_rows_bg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
-            "show_border": self.PAR.ops.show_selected_cells_border,
+            "show_border": True,
             "bg": bg,
             "fg": fg,
             "align": self.get_cell_align(r),
@@ -1809,61 +1811,70 @@ class RowIndex(tk.Canvas):
         return True
 
     def text_editor_newline_binding(self, r=0, c=0, event: object = None, check_lines=True):
-        if self.height_resizing_enabled:
-            curr_height = self.text_editor.window.winfo_height()
-            if (
-                not check_lines
-                or self.MT.get_lines_cell_height(
-                    self.text_editor.window.get_num_lines() + 1,
-                    font=self.PAR.ops.index_font,
-                )
-                > curr_height
-            ):
-                new_height = curr_height + self.MT.index_xtra_lines_increment
-                space_bot = self.MT.get_space_bot(r)
-                if new_height > space_bot:
-                    new_height = space_bot
-                if new_height != curr_height:
-                    self.set_row_height(r, new_height)
-                    self.MT.refresh()
-                    self.text_editor.window.config(height=new_height)
-                    self.coords(self.text_editor.canvas_id, 0, self.MT.row_positions[r] + 1)
-                    if self.dropdown.open and self.dropdown.get_coords() == r:
-                        text_editor_h = self.text_editor.window.winfo_height()
-                        win_h, anchor = self.get_dropdown_height_anchor(r, text_editor_h)
-                        if anchor == "nw":
-                            self.coords(
-                                self.dropdown.canvas_id,
-                                self.MT.col_positions[c],
-                                self.MT.row_positions[r] + text_editor_h - 1,
-                            )
-                            self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
-                        elif anchor == "sw":
-                            self.coords(
-                                self.dropdown.canvas_id,
-                                self.MT.col_positions[c],
-                                self.MT.row_positions[r],
-                            )
-                            self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
+        if not self.height_resizing_enabled:
+            return
+        curr_height = self.text_editor.window.winfo_height()
+        if curr_height < self.MT.min_row_height:
+            return
+        if (
+            not check_lines
+            or self.MT.get_lines_cell_height(
+                self.text_editor.window.get_num_lines() + 1,
+                font=self.text_editor.tktext.cget("font"),
+            )
+            > curr_height
+        ):
+            new_height = curr_height + self.MT.index_xtra_lines_increment
+            space_bot = self.MT.get_space_bot(r)
+            if new_height > space_bot:
+                new_height = space_bot
+            if new_height != curr_height:
+                self.set_row_height(r, new_height)
+                self.MT.refresh()
+                self.text_editor.window.config(height=new_height)
+                self.coords(self.text_editor.canvas_id, 0, self.MT.row_positions[r] + 1)
+                if self.dropdown.open and self.dropdown.get_coords() == r:
+                    text_editor_h = self.text_editor.window.winfo_height()
+                    win_h, anchor = self.get_dropdown_height_anchor(r, text_editor_h)
+                    if anchor == "nw":
+                        self.coords(
+                            self.dropdown.canvas_id,
+                            self.MT.col_positions[c],
+                            self.MT.row_positions[r] + text_editor_h - 1,
+                        )
+                        self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
+                    elif anchor == "sw":
+                        self.coords(
+                            self.dropdown.canvas_id,
+                            self.MT.col_positions[c],
+                            self.MT.row_positions[r],
+                        )
+                        self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def refresh_open_window_positions(self):
+    def refresh_open_window_positions(self, zoom: Literal["in", "out"]):
         if self.text_editor.open:
             r = self.text_editor.row
             self.text_editor.window.config(height=self.MT.row_positions[r + 1] - self.MT.row_positions[r])
+            self.text_editor.tktext.config(font=self.PAR.ops.index_font)
             self.coords(
                 self.text_editor.canvas_id,
                 0,
                 self.MT.row_positions[r],
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             r = self.dropdown.get_coords()
             if self.text_editor.open:
                 text_editor_h = self.text_editor.window.winfo_height()
                 win_h, anchor = self.get_dropdown_height_anchor(r, text_editor_h)
             else:
-                text_editor_h = self.MT.row_positions[r + 1] - self.MT.row_positions[r]
+                text_editor_h = self.MT.row_positions[r + 1] - self.MT.row_positions[r] + 1
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.current_width + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
@@ -1951,15 +1962,22 @@ class RowIndex(tk.Canvas):
                 break
         if win_h > 500:
             win_h = 500
-        space_bot = self.MT.get_space_bot(0, text_editor_h)
+        space_bot = self.MT.get_space_bot(r, text_editor_h)
+        space_top = int(self.MT.row_positions[r])
+        anchor = "nw"
         win_h2 = int(win_h)
         if win_h > space_bot:
-            win_h = space_bot - 1
+            if space_bot >= space_top:
+                anchor = "nw"
+                win_h = space_bot - 1
+            elif space_top > space_bot:
+                anchor = "sw"
+                win_h = space_top - 1
         if win_h < self.MT.index_txt_height + 5:
             win_h = self.MT.index_txt_height + 5
         elif win_h > win_h2:
             win_h = win_h2
-        return win_h, "nw"
+        return win_h, anchor
 
     def dropdown_text_editor_modified(
         self,
@@ -1972,42 +1990,45 @@ class RowIndex(tk.Canvas):
         dd_window.search_and_see(event)
 
     # r is displayed row
-    def open_dropdown_window(self, r, datarn=None, event: object = None):
+    def open_dropdown_window(self, r, event: object = None):
         self.hide_text_editor("Escape")
-        if datarn is None:
-            datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown")
+        kwargs = self.get_cell_kwargs(self.MT.datarn(r), key="dropdown")
         if kwargs["state"] == "normal":
             if not self.open_text_editor(event=event, r=r, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(r)
-        ypos = self.MT.row_positions[r + 1]
-        if self.dropdown.window is not None:
-            self.dropdown.window.search_function = kwargs["search_function"]
-            self.dropdown.window.r = r
-            self.dropdown.window.row = -1
-            self.dropdown.window.set_options()
-            self.dropdown.window.values(kwargs["values"])
-            if not self.dropdown.open:
-                self.itemconfig(self.dropdown.canvas_id, state="normal")
+        win_w = self.current_width + 1
+        if anchor == "nw":
+            if kwargs["state"] == "normal":
+                ypos = self.MT.row_positions[r] + self.text_editor.window.winfo_height() - 1
+            else:
+                ypos = self.MT.row_positions[r + 1]
+        else:
+            ypos = self.MT.row_positions[r]
+        reset_kwargs = {
+            "r": r,
+            "c": 0,
+            "width": win_w,
+            "height": win_h,
+            "font": self.PAR.ops.index_font,
+            "ops": self.PAR.ops,
+            "outline_color": self.PAR.ops.popup_menu_fg,
+            "align": self.get_cell_align(r),
+            "values": kwargs["values"],
+        }
+        if self.dropdown.window:
+            self.dropdown.window.reset(**reset_kwargs)
+            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, 0, ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
-                self.MT.winfo_toplevel(),
-                r,
-                0,
-                width=self.current_width,
-                height=win_h,
-                font=self.PAR.ops.index_font,
-                ops=self.PAR.ops,
-                outline_color=self.PAR.ops.popup_menu_fg,
-                values=kwargs["values"],
+                self.winfo_toplevel(),
+                **reset_kwargs,
+                single_index="r",
                 close_dropdown_window=self.close_dropdown_window,
                 search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.MT.arrowkey_RIGHT,
                 arrowkey_LEFT=self.MT.arrowkey_LEFT,
-                align="w",
-                single_index="r",
             )
             self.dropdown.canvas_id = self.create_window(
                 (0, ypos),