tksheet 7.1.20__py3-none-any.whl → 7.1.22__py3-none-any.whl

tksheet/row_index.py

@@ -32,6 +32,7 @@ from .functions import (
     event_dict,
     get_n2a,
     is_contiguous,
+    new_tk_event,
     num2alpha,
     pickled_event_dict,
     rounded_box_coords,
@@ -48,9 +49,10 @@ from .text_editor import (
     TextEditor,
 )
 from .vars import (
-    USER_OS,
     rc_binding,
     symbols_set,
+    text_editor_close_bindings,
+    text_editor_newline_bindings,
     text_editor_to_unbind,
 )
 
@@ -117,6 +119,7 @@ class RowIndex(tk.Canvas):
         self.disp_resize_lines = {}
         self.disp_dropdown = {}
         self.disp_checkbox = {}
+        self.disp_tree_arrow = {}
         self.disp_boxes = set()
         self.hidd_text = {}
         self.hidd_high = {}
@@ -126,6 +129,7 @@ class RowIndex(tk.Canvas):
         self.hidd_resize_lines = {}
         self.hidd_dropdown = {}
         self.hidd_checkbox = {}
+        self.hidd_tree_arrow = {}
         self.hidd_boxes = set()
 
         self.align = kwargs["row_index_align"]
@@ -134,6 +138,13 @@ class RowIndex(tk.Canvas):
         self.tree_reset()
         self.basic_bindings()
 
+    def event_generate(self, *args, **kwargs) -> None:
+        for arg in args:
+            if self.MT and arg in self.MT.event_linker:
+                self.MT.event_linker[arg]()
+            else:
+                super().event_generate(*args, **kwargs)
+
     def basic_bindings(self, enable: bool = True) -> None:
         if enable:
             self.bind("<Motion>", self.mouse_motion)
@@ -833,6 +844,7 @@ class RowIndex(tk.Canvas):
                 event_data = event_dict(
                     name="move_rows",
                     sheet=self.PAR.name,
+                    widget=self,
                     boxes=self.MT.get_boxes(),
                     selected=self.MT.selected,
                     value=r,
@@ -844,6 +856,7 @@ class RowIndex(tk.Canvas):
                             to_move=self.dragged_row.to_move,
                         ),
                         move_data=self.PAR.ops.row_drag_and_drop_perform,
+                        move_heights=self.PAR.ops.row_drag_and_drop_perform,
                         event_data=event_data,
                     )
                     event_data["moved"]["rows"] = {
@@ -1009,7 +1022,7 @@ class RowIndex(tk.Canvas):
             w = self.PAR.ops.default_row_index_width
             h = self.MT.min_row_height
         if self.get_cell_kwargs(datarn, key="dropdown") or self.get_cell_kwargs(datarn, key="checkbox"):
-            w += self.MT.index_txt_height
+            w += self.MT.index_txt_height + 2
         if self.PAR.ops.treeview:
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
@@ -1017,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)
+            w += self.get_treeview_indent(self.MT._row_index[datarn].iid) + 4
         return w, h
 
     def set_row_height(
@@ -1191,9 +1204,9 @@ 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_x := floor(self.PAR.winfo_width() * 0.8)) < new_w:
+            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 > 5):
+            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)
                 return True
         return False
@@ -1205,7 +1218,7 @@ class RowIndex(tk.Canvas):
             if kwargs[0] is not None:
                 c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
             if "rows" in selections and r in selections["rows"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.index_selected_rows_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
@@ -1217,7 +1230,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(c_1[5:], 16) + int(c_3[5:], 16)) / 2):02X}"
                     )
             elif "cells" in selections and r in selections["cells"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.index_selected_cells_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
@@ -1229,7 +1242,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(c_1[5:], 16) + int(c_2[5:], 16)) / 2):02X}"
                     )
             else:
-                tf = self.PAR.ops.index_fg if kwargs[1] is None else kwargs[1]
+                txtfg = self.PAR.ops.index_fg if kwargs[1] is None else kwargs[1]
                 if kwargs[0] is not None:
                     fill = kwargs[0]
             if kwargs[0] is not None:
@@ -1246,14 +1259,18 @@ class RowIndex(tk.Canvas):
                     ),
                     tag="s",
                 )
+            tree_arrow_fg = txtfg
         elif not kwargs:
             if "rows" in selections and r in selections["rows"]:
-                tf = self.PAR.ops.index_selected_rows_fg
+                txtfg = self.PAR.ops.index_selected_rows_fg
+                tree_arrow_fg = self.PAR.ops.selected_rows_tree_arrow_fg
             elif "cells" in selections and r in selections["cells"]:
-                tf = self.PAR.ops.index_selected_cells_fg
+                txtfg = self.PAR.ops.index_selected_cells_fg
+                tree_arrow_fg = self.PAR.ops.selected_cells_tree_arrow_fg
             else:
-                tf = self.PAR.ops.index_fg
-        return tf, redrawn
+                txtfg = self.PAR.ops.index_fg
+                tree_arrow_fg = self.PAR.ops.tree_arrow_fg
+        return txtfg, tree_arrow_fg, redrawn
 
     def redraw_highlight(self, x1, y1, x2, y2, fill, outline, tag):
         coords = (x1, y1, x2, y2)
@@ -1281,6 +1298,56 @@ class RowIndex(tk.Canvas):
         else:
             self.disp_grid[self.create_line(points, fill=fill, width=width, tag=tag)] = True
 
+    def redraw_tree_arrow(
+        self,
+        x1,
+        y1,
+        r,
+        fill,
+        tag,
+        indent: float,
+        open_: bool = False,
+    ) -> None:
+        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
+        # up arrow
+        if open_:
+            points = (
+                x1 + 2 + indent,
+                y1 + mid_y + qtr_mod,
+                x1 + 2 + half_mod + indent,
+                y1 + mid_y - qtr_mod,
+                x1 + 2 + mod + indent,
+                y1 + mid_y + qtr_mod,
+            )
+        # right pointing arrow
+        else:
+            points = (
+                x1 + half_mod + indent,
+                y1 + mid_y - half_mod + 1,
+                x1 + mod + indent - 1,
+                y1 + mid_y,
+                x1 + half_mod + indent,
+                y1 + mid_y + half_mod - 1,
+            )
+        if self.hidd_tree_arrow:
+            t, sh = self.hidd_tree_arrow.popitem()
+            self.coords(t, points)
+            if sh:
+                self.itemconfig(t, fill=fill)
+            else:
+                self.itemconfig(t, fill=fill, tag=tag, state="normal")
+            self.lift(t)
+        else:
+            t = self.create_polygon(
+                points,
+                fill=fill,
+                tag=tag,
+            )
+        self.disp_tree_arrow[t] = True
+
     def redraw_dropdown(
         self,
         x1,
@@ -1293,7 +1360,6 @@ class RowIndex(tk.Canvas):
         draw_outline: bool = True,
         draw_arrow: bool = True,
         open_: bool = False,
-        indent: None | float = None,
     ) -> None:
         if draw_outline and self.PAR.ops.show_dropdown_borders:
             self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.index_fg, tag=tag)
@@ -1302,47 +1368,24 @@ class RowIndex(tk.Canvas):
             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
-            # treeview
-            if indent is not None:
-                # up arrow
-                if open_:
-                    points = (
-                        x1 + 2 + indent,
-                        y1 + mid_y + qtr_mod,
-                        x1 + 2 + half_mod + indent,
-                        y1 + mid_y - qtr_mod,
-                        x1 + 2 + mod + indent,
-                        y1 + mid_y + qtr_mod,
-                    )
-                # right pointing arrow
-                else:
-                    points = (
-                        x1 + half_mod + indent,
-                        y1 + mid_y - half_mod + 1,
-                        x1 + mod + indent - 1,
-                        y1 + mid_y,
-                        x1 + half_mod + indent,
-                        y1 + mid_y + half_mod - 1,
-                    )
+            if open_:
+                points = (
+                    x2 - 3 - mod,
+                    y1 + mid_y + qtr_mod,
+                    x2 - 3 - half_mod,
+                    y1 + mid_y - qtr_mod,
+                    x2 - 3,
+                    y1 + mid_y + qtr_mod,
+                )
             else:
-                if open_:
-                    points = (
-                        x2 - 3 - mod,
-                        y1 + mid_y + qtr_mod,
-                        x2 - 3 - half_mod,
-                        y1 + mid_y - qtr_mod,
-                        x2 - 3,
-                        y1 + mid_y + qtr_mod,
-                    )
-                else:
-                    points = (
-                        x2 - 3 - mod,
-                        y1 + mid_y - qtr_mod,
-                        x2 - 3 - half_mod,
-                        y1 + mid_y + qtr_mod,
-                        x2 - 3,
-                        y1 + mid_y - qtr_mod,
-                    )
+                points = (
+                    x2 - 3 - mod,
+                    y1 + mid_y - qtr_mod,
+                    x2 - 3 - half_mod,
+                    y1 + mid_y + qtr_mod,
+                    x2 - 3,
+                    y1 + mid_y - qtr_mod,
+                )
             if self.hidd_dropdown:
                 t, sh = self.hidd_dropdown.popitem()
                 self.coords(t, points)
@@ -1352,12 +1395,9 @@ class RowIndex(tk.Canvas):
                     self.itemconfig(t, fill=fill, tag=tag, state="normal")
                 self.lift(t)
             else:
-                t = self.create_line(
+                t = self.create_polygon(
                     points,
                     fill=fill,
-                    width=2,
-                    capstyle=tk.ROUND,
-                    joinstyle=tk.ROUND,
                     tag=tag,
                 )
             self.disp_dropdown[t] = True
@@ -1428,6 +1468,8 @@ class RowIndex(tk.Canvas):
         self.disp_dropdown = {}
         self.hidd_checkbox.update(self.disp_checkbox)
         self.disp_checkbox = {}
+        self.hidd_tree_arrow.update(self.disp_tree_arrow)
+        self.disp_tree_arrow = {}
         self.visible_row_dividers = {}
         draw_y = self.MT.row_positions[start_row]
         xend = self.current_width - 6
@@ -1484,7 +1526,15 @@ class RowIndex(tk.Canvas):
             if rbotgridln - rtopgridln < self.MT.index_txt_height:
                 continue
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
-            fill, dd_drawn = self.redraw_highlight_get_text_fg(rtopgridln, rbotgridln, r, c_2, c_3, selections, datarn)
+            fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
+                rtopgridln,
+                rbotgridln,
+                r,
+                c_2,
+                c_3,
+                selections,
+                datarn,
+            )
 
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
@@ -1584,20 +1634,16 @@ class RowIndex(tk.Canvas):
                 if align == "w":
                     draw_x += self.MT.index_txt_height + 1
                 indent = self.get_treeview_indent(iid)
-                draw_x += indent
+                draw_x += indent + 4
                 if self.tree[iid].children:
-                    self.redraw_dropdown(
+                    self.redraw_tree_arrow(
                         0,
                         rtopgridln,
-                        self.current_width - 1,
-                        rbotgridln - 1,
-                        fill=fill,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=False,
-                        draw_arrow=True,
-                        open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
+                        r=r,
+                        fill=tree_arrow_fg,
+                        tag="ta",
                         indent=indent,
+                        open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
                     )
             lns = self.get_valid_cell_data_as_str(datarn, fix=False)
             if not lns:
@@ -1677,7 +1723,14 @@ class RowIndex(tk.Canvas):
                         draw_y += self.MT.index_xtra_lines_increment
                         if draw_y + self.MT.index_half_txt_height - 1 > rbotgridln:
                             break
-        for dct in (self.hidd_text, self.hidd_high, self.hidd_grid, self.hidd_dropdown, self.hidd_checkbox):
+        for dct in (
+            self.hidd_text,
+            self.hidd_high,
+            self.hidd_grid,
+            self.hidd_dropdown,
+            self.hidd_checkbox,
+            self.hidd_tree_arrow,
+        ):
             for iid, showing in dct.items():
                 if showing:
                     self.itemconfig(iid, state="hidden")
@@ -1819,24 +1872,19 @@ class RowIndex(tk.Canvas):
             self.itemconfig(self.text_editor.canvas_id, state="normal")
             self.text_editor.open = True
         self.coords(self.text_editor.canvas_id, x, y)
+        for b in text_editor_newline_bindings:
+            self.text_editor.tktext.bind(b, self.text_editor_newline_binding)
+        for b in text_editor_close_bindings:
+            self.text_editor.tktext.bind(b, self.close_text_editor)
         if not dropdown:
             self.text_editor.tktext.focus_set()
             self.text_editor.window.scroll_to_bottom()
-        self.text_editor.tktext.bind("<Alt-Return>", lambda _x: self.text_editor_newline_binding(r=r))
-        self.text_editor.tktext.bind("<Alt-KP_Enter>", lambda _x: self.text_editor_newline_binding(r=r))
-        if USER_OS == "darwin":
-            self.text_editor.tktext.bind("<Option-Return>", lambda _x: self.text_editor_newline_binding(r=r))
+            self.text_editor.tktext.bind("<FocusOut>", self.close_text_editor)
         for key, func in self.MT.text_editor_user_bound_keys.items():
             self.text_editor.tktext.bind(key, func)
-        self.text_editor.tktext.bind("<Tab>", lambda _x: self.close_text_editor((r, "Tab")))
-        self.text_editor.tktext.bind("<Return>", lambda _x: self.close_text_editor((r, "Return")))
-        self.text_editor.tktext.bind("<KP_Enter>", lambda _x: self.close_text_editor((r, "Return")))
-        if not dropdown:
-            self.text_editor.tktext.bind("<FocusOut>", lambda _x: self.close_text_editor((r, "FocusOut")))
-        self.text_editor.tktext.bind("<Escape>", lambda _x: self.close_text_editor((r, "Escape")))
         return True
 
-    def text_editor_newline_binding(self, r=0, c=0, event: object = None, check_lines=True):
+    def text_editor_newline_binding(self, event: object = None, check_lines=True):
         if not self.height_resizing_enabled:
             return
         curr_height = self.text_editor.window.winfo_height()
@@ -1850,6 +1898,7 @@ class RowIndex(tk.Canvas):
             )
             > curr_height
         ):
+            r = self.text_editor.row
             new_height = curr_height + self.MT.index_xtra_lines_increment
             space_bot = self.MT.get_space_bot(r)
             if new_height > space_bot:
@@ -1865,14 +1914,14 @@ class RowIndex(tk.Canvas):
                     if anchor == "nw":
                         self.coords(
                             self.dropdown.canvas_id,
-                            self.MT.col_positions[c],
+                            0,
                             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],
+                            0,
                             self.MT.row_positions[r],
                         )
                         self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
@@ -1926,29 +1975,32 @@ class RowIndex(tk.Canvas):
             self.focus_set()
 
     # r is displayed row
-    def close_text_editor(
-        self,
-        editor_info: tuple | None = None,
-    ) -> str | None:
-        focused = self.focus_get()
+    def close_text_editor(self, event: tk.Event) -> Literal["break"] | None:
+        # checking if text editor should be closed or not
+        # errors if __tk_filedialog is open
+        try:
+            focused = self.focus_get()
+        except Exception:
+            focused = None
         try:
             if focused == self.text_editor.tktext.rc_popup_menu:
                 return "break"
         except Exception:
             pass
-        if focused is None and editor_info:
+        if focused is None:
             return "break"
-        if editor_info is not None and len(editor_info) >= 2 and editor_info[1] == "Escape":
+        if event.keysym == "Escape":
             self.hide_text_editor_and_dropdown()
             return
         text_editor_value = self.text_editor.get()
-        r = editor_info[0]
+        r = self.text_editor.row
         datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
         event_data = event_dict(
             name="end_edit_index",
             sheet=self.PAR.name,
+            widget=self,
             cells_index={datarn: self.get_cell_data(datarn)},
-            key=editor_info[1] if len(editor_info) >= 2 else "FocusOut",
+            key=event.keysym,
             value=text_editor_value,
             loc=r,
             row=r,
@@ -1972,7 +2024,7 @@ class RowIndex(tk.Canvas):
             try_binding(self.extra_end_edit_cell_func, event_data)
         self.MT.recreate_all_selection_boxes()
         self.hide_text_editor_and_dropdown()
-        if editor_info[1] != "FocusOut":
+        if event.keysym != "FocusOut":
             self.focus_set()
         return "break"
 
@@ -2109,6 +2161,7 @@ class RowIndex(tk.Canvas):
             event_data = event_dict(
                 name="end_edit_index",
                 sheet=self.PAR.name,
+                widget=self,
                 cells_header={datarn: pre_edit_value},
                 key="??",
                 value=selection,
@@ -2140,7 +2193,7 @@ class RowIndex(tk.Canvas):
     def mouseclick_outside_editor_or_dropdown(self, inside: bool = False):
         closed_dd_coords = self.dropdown.get_coords()
         if self.text_editor.open:
-            self.close_text_editor((self.text_editor.row, "ButtonPress-1"))
+            self.close_text_editor(new_tk_event("ButtonPress-1"))
         if closed_dd_coords is not None:
             self.hide_dropdown_window()
             if inside:
@@ -2178,6 +2231,7 @@ class RowIndex(tk.Canvas):
         event_data = event_dict(
             name="edit_index",
             sheet=self.PAR.name,
+            widget=self,
             cells_index={datarn: self.get_cell_data(datarn)},
             boxes=self.MT.get_boxes(),
             selected=self.MT.selected,
@@ -2332,6 +2386,7 @@ class RowIndex(tk.Canvas):
             event_data = event_dict(
                 name="end_edit_index",
                 sheet=self.PAR.name,
+                widget=self,
                 cells_index={datarn: pre_edit_value},
                 key="??",
                 value=value,
@@ -2385,7 +2440,7 @@ class RowIndex(tk.Canvas):
 
     def get_treeview_indent(self, iid: str) -> int:
         if isinstance(self.PAR.ops.treeview_indent, str):
-            indent = self.MT.index_txt_height * int(self.PAR.ops.treeview_indent)
+            indent = self.MT.index_txt_width * int(self.PAR.ops.treeview_indent)
         else:
             indent = self.PAR.ops.treeview_indent
         return indent * max(self.get_node_level(self.tree[iid]))