tksheet 7.5.10__py3-none-any.whl → 7.5.12__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -20,6 +20,7 @@ from .constants import (
 )
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
+    any_editor_or_dropdown_open,
     consecutive_ranges,
     event_dict,
     event_has_char_key,
@@ -49,7 +50,7 @@ from .tooltip import Tooltip
 
 
 class ColumnHeaders(tk.Canvas):
-    def __init__(self, parent, **kwargs):
+    def __init__(self, parent: tk.Misc, **kwargs) -> None:
         super().__init__(
             parent,
             background=parent.ops.header_bg,
@@ -72,6 +73,7 @@ class ColumnHeaders(tk.Canvas):
         )
         self.tooltip_widgets = widget_descendants(self.tooltip)
         self.tooltip_coords, self.tooltip_after_id, self.tooltip_showing = None, None, False
+        self.tooltip_cell_content = ""
         recursive_bind(self.tooltip, "<Leave>", self.close_tooltip_save)
         self.current_cursor = ""
         self.popup_menu_loc = None
@@ -1268,6 +1270,7 @@ class ColumnHeaders(tk.Canvas):
         selections: dict,
         datacn: int,
         has_dd: bool,
+        tags: str | tuple[str],
     ) -> tuple[str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datacn, key="highlight")
@@ -1294,6 +1297,7 @@ class ColumnHeaders(tk.Canvas):
                         + f"{int((int(high_bg[5:], 16) + int(sel_cols_bg[5:], 16)) / 2):02X}"
                     ),
                     outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             elif "cells" in selections and c in selections["cells"]:
                 txtfg = (
@@ -1314,6 +1318,7 @@ class ColumnHeaders(tk.Canvas):
                         + f"{int((int(high_bg[5:], 16) + int(sel_cells_bg[5:], 16)) / 2):02X}"
                     ),
                     outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             else:
                 txtfg = self.ops.header_fg if kwargs[1] is None else kwargs[1]
@@ -1325,6 +1330,7 @@ class ColumnHeaders(tk.Canvas):
                         self.current_height - 1,
                         fill=high_bg,
                         outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                        tags=tags,
                     )
         elif not kwargs:
             if "columns" in selections and c in selections["columns"]:
@@ -1336,6 +1342,7 @@ class ColumnHeaders(tk.Canvas):
                     self.current_height - 1,
                     fill=self.ops.header_selected_columns_bg,
                     outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             elif "cells" in selections and c in selections["cells"]:
                 txtfg = self.ops.header_selected_cells_fg
@@ -1346,9 +1353,19 @@ class ColumnHeaders(tk.Canvas):
                     self.current_height - 1,
                     fill=self.ops.header_selected_cells_bg,
                     outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             else:
                 txtfg = self.ops.header_fg
+                redrawn = self.redraw_highlight(
+                    fc + 1,
+                    0,
+                    sc,
+                    self.current_height - 1,
+                    fill="",
+                    outline=self.ops.header_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
+                )
         return txtfg, redrawn
 
     def redraw_highlight(
@@ -1359,17 +1376,18 @@ class ColumnHeaders(tk.Canvas):
         y2: float,
         fill: str,
         outline: str,
+        tags: str | tuple[str],
     ) -> bool:
         coords = (x1, y1, x2, y2)
         if self.hidd_high:
             iid, showing = self.hidd_high.popitem()
             self.coords(iid, coords)
             if showing:
-                self.itemconfig(iid, fill=fill, outline=outline)
+                self.itemconfig(iid, fill=fill, outline=outline, tags=tags)
             else:
-                self.itemconfig(iid, fill=fill, outline=outline, state="normal")
+                self.itemconfig(iid, fill=fill, outline=outline, state="normal", tags=tags)
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline, tags=tags)
         self.disp_high[iid] = True
         return True
 
@@ -1402,8 +1420,8 @@ class ColumnHeaders(tk.Canvas):
         draw_arrow: bool = True,
         open_: bool = False,
     ) -> None:
-        if draw_outline and self.ops.show_dropdown_borders:
-            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.header_fg)
+        # if draw_outline and self.ops.show_dropdown_borders:
+        #     self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.header_fg)
         if draw_arrow:
             mod = (self.MT.header_txt_height - 1) if self.MT.header_txt_height % 2 else self.MT.header_txt_height
             small_mod = int(mod / 5)
@@ -1506,15 +1524,15 @@ class ColumnHeaders(tk.Canvas):
             self.MT.char_widths[self.header_font][c] = wd
             return wd
 
-    def redraw_corner(self, x: float, y: float) -> None:
+    def redraw_corner(self, x: float, y: float, tags: str | tuple[str]) -> None:
         if self.hidd_corners:
             iid = self.hidd_corners.pop()
             self.coords(iid, x - 10, y, x, y, x, y + 10)
-            self.itemconfig(iid, fill=self.ops.header_grid_fg, state="normal")
+            self.itemconfig(iid, fill=self.ops.header_grid_fg, state="normal", tags=tags)
             self.disp_corners.add(iid)
         else:
             self.disp_corners.add(
-                self.create_polygon(x - 10, y, x, y, x, y + 10, fill=self.ops.header_grid_fg, tags="lift")
+                self.create_polygon(x - 10, y, x, y, x, y + 10, fill=self.ops.header_grid_fg, tags=tags)
             )
 
     def redraw_grid_and_text(
@@ -1552,7 +1570,6 @@ class ColumnHeaders(tk.Canvas):
             self.current_height,
         )
         top = self.canvasy(0)
-
         if (self.ops.show_vertical_grid or self.width_resizing_enabled) and col_pos_exists:
             yend = self.current_height - 5
             points = [
@@ -1580,7 +1597,6 @@ class ColumnHeaders(tk.Canvas):
                     )
                 )
             self.redraw_gridline(points=points, fill=self.ops.header_grid_fg, width=1)
-
         sel_cells_bg = (
             self.ops.header_selected_cells_bg
             if self.ops.header_selected_cells_bg.startswith("#")
@@ -1603,6 +1619,7 @@ class ColumnHeaders(tk.Canvas):
             crightgridln = self.MT.col_positions[c + 1]
             datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
             kwargs = self.get_cell_kwargs(datacn, key="dropdown")
+            tag = f"{c}"
             fill, dd_drawn = self.redraw_highlight_get_text_fg(
                 fc=cleftgridln,
                 sc=crightgridln,
@@ -1612,6 +1629,7 @@ class ColumnHeaders(tk.Canvas):
                 selections=selections,
                 datacn=datacn,
                 has_dd=bool(kwargs),
+                tags=("h", "c", tag),
             )
             if datacn in self.cell_options and "align" in self.cell_options[datacn]:
                 align = self.cell_options[datacn]["align"]
@@ -1675,10 +1693,9 @@ class ColumnHeaders(tk.Canvas):
                 or (align[-1] == "n" and cleftgridln + 5 > scrollpos_right)
             ):
                 continue
-
+            tags = ("lift", "c", tag)
             if note_corners and max_width > 5 and datacn in self.cell_options and "note" in self.cell_options[datacn]:
-                self.redraw_corner(crightgridln, 0)
-
+                self.redraw_corner(crightgridln, 0, tags)
             text = self.cell_str(datacn, fix=False)
             if not text:
                 continue
@@ -1701,7 +1718,7 @@ class ColumnHeaders(tk.Canvas):
                             fill=fill,
                             font=font,
                             anchor=align,
-                            tags=("lift", "t", f"{c}"),
+                            tags=tags,
                         )
                     else:
                         self.itemconfig(
@@ -1711,7 +1728,7 @@ class ColumnHeaders(tk.Canvas):
                             font=font,
                             anchor=align,
                             state="normal",
-                            tags=("lift", "t", f"{c}"),
+                            tags=tags,
                         )
                 else:
                     iid = self.create_text(
@@ -1721,7 +1738,7 @@ class ColumnHeaders(tk.Canvas):
                         fill=fill,
                         font=font,
                         anchor=align,
-                        tags=("lift", "t", f"{c}"),
+                        tags=tags,
                     )
                 self.disp_text[iid] = True
             else:
@@ -1736,7 +1753,7 @@ class ColumnHeaders(tk.Canvas):
                                 fill=fill,
                                 font=font,
                                 anchor=align,
-                                tags=("lift", "t", f"{c}"),
+                                tags=tags,
                             )
                         else:
                             self.itemconfig(
@@ -1746,7 +1763,7 @@ class ColumnHeaders(tk.Canvas):
                                 font=font,
                                 anchor=align,
                                 state="normal",
-                                tags=("lift", "t", f"{c}"),
+                                tags=tags,
                             )
                     else:
                         iid = self.create_text(
@@ -1756,7 +1773,7 @@ class ColumnHeaders(tk.Canvas):
                             fill=fill,
                             font=font,
                             anchor=align,
-                            tags=("lift", "t", f"{c}"),
+                            tags=tags,
                         )
                     self.disp_text[iid] = True
                     draw_y += self.MT.header_txt_height
@@ -1771,12 +1788,12 @@ class ColumnHeaders(tk.Canvas):
         self.tag_raise("lift")
         if self.disp_resize_lines:
             self.tag_raise("rw")
-        self.tag_bind("t", "<Enter>", self.enter_text)
-        self.tag_bind("t", "<Leave>", self.leave_text)
+        self.tag_bind("c", "<Enter>", self.enter_cell)
+        self.tag_bind("c", "<Leave>", self.leave_cell)
         return True
 
-    def enter_text(self, event: tk.Event | None = None) -> None:
-        if self.text_editor.open or self.dropdown.open:
+    def enter_cell(self, event: tk.Event | None = None) -> None:
+        if any_editor_or_dropdown_open(self.MT):
             return
         can_x, can_y = self.canvasx(event.x), self.canvasy(event.y)
         for i in self.find_overlapping(can_x - 1, can_y - 1, can_x + 1, can_y + 1):
@@ -1790,7 +1807,7 @@ class ColumnHeaders(tk.Canvas):
             except Exception:
                 continue
 
-    def leave_text(self, event: tk.Event | None = None) -> None:
+    def leave_cell(self, event: tk.Event | None = None) -> None:
         if self.tooltip_after_id is not None:
             self.after_cancel(self.tooltip_after_id)
             self.tooltip_after_id = None
@@ -1801,7 +1818,7 @@ class ColumnHeaders(tk.Canvas):
             self.tooltip_coords = None
 
     def start_tooltip_timer(self) -> None:
-        self.tooltip_after_id = self.after(1000, self.check_and_show_tooltip)
+        self.tooltip_after_id = self.after(self.ops.tooltip_hover_delay, self.check_and_show_tooltip)
 
     def check_and_show_tooltip(self, event: tk.Event | None = None) -> None:
         current_x, current_y = self.winfo_pointerx(), self.winfo_pointery()
@@ -1823,19 +1840,22 @@ class ColumnHeaders(tk.Canvas):
         kws = self.get_cell_kwargs(datacn, key="note")
         if not self.ops.tooltips and not kws and not self.ops.user_can_create_notes:
             return
+        self.MT.hide_tooltip()
+        self.RI.hide_tooltip()
         cell_readonly = self.get_cell_kwargs(datacn, "readonly") or not self.MT.index_edit_cell_enabled()
         if kws:
             note = kws["note"]
             note_readonly = kws["readonly"]
         elif self.ops.user_can_create_notes:
             note = ""
-            note_readonly = bool(cell_readonly)
+            note_readonly = False
         else:
             note = None
             note_readonly = True
+        self.tooltip_cell_content = f"{self.get_cell_data(datacn, none_to_empty_str=True)}"
         self.tooltip.reset(
             **{
-                "text": f"{self.get_cell_data(datacn, none_to_empty_str=True)}",
+                "text": self.tooltip_cell_content,
                 "cell_readonly": cell_readonly,
                 "note": note,
                 "note_readonly": note_readonly,
@@ -1855,25 +1875,18 @@ class ColumnHeaders(tk.Canvas):
     def close_tooltip_save(self, event: tk.Event | None = None) -> None:
         widget = self.winfo_containing(self.winfo_pointerx(), self.winfo_pointery())
         if any(widget == tw for tw in self.tooltip_widgets):
-            try:
-                if self.tooltip.notebook.index("current") == 0:
-                    self.tooltip.content_text.focus_set()
-                else:
-                    self.tooltip.note_text.focus_set()
-            except Exception:
-                self.tooltip.content_text.focus_set()
             return
         if not self.tooltip.cell_readonly or not self.tooltip.note_readonly:
             _, c, cell, note = self.tooltip.get()
             datacn = self.MT.datacn(c)
-            if not self.tooltip.cell_readonly:
+            if not self.tooltip.cell_readonly and cell != self.tooltip_cell_content:
                 event_data = self.new_single_edit_event(c, datacn, "??", self.get_cell_data(datacn), cell)
                 self.do_single_edit(c, datacn, event_data, cell)
             if not self.tooltip.note_readonly:
                 span = self.PAR.span(None, datacn, None, datacn + 1).options(table=False, header=True)
                 self.PAR.note(span, note=note if note else None, readonly=False)
+            self.MT.refresh()
         self.hide_tooltip()
-        self.MT.refresh()
         self.focus_set()
 
     def get_redraw_selections(self, startc: int, endc: int) -> dict[str, set[int]]:
@@ -1960,6 +1973,7 @@ class ColumnHeaders(tk.Canvas):
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
+        self.hide_tooltip()
         if not self.MT.see(0, c, keep_yscroll=True):
             self.MT.main_table_redraw_grid_and_text(True, True)
         x = self.MT.col_positions[c] + 1

tksheet/functions.py

@@ -841,11 +841,21 @@ def remove_duplicates_outside_section(strings: list[str], section_start: int, se
 
     section_end = section_start + section_size
     section_set = set(strings[section_start:section_end])
-    print(section_set, section_start, section_size)
 
     return [s for i, s in enumerate(strings) if (section_start <= i < section_end) or (s not in section_set)]
 
 
+def any_editor_or_dropdown_open(MT) -> bool:
+    return (
+        MT.dropdown.open
+        or MT.RI.dropdown.open
+        or MT.CH.dropdown.open
+        or MT.text_editor.open
+        or MT.RI.text_editor.open
+        or MT.CH.text_editor.open
+    )
+
+
 def get_new_indexes(
     move_to: int,
     to_move: Iterable[int],

tksheet/main_table.py

@@ -41,6 +41,7 @@ from .formatters import (
 )
 from .functions import (
     add_to_displayed,
+    any_editor_or_dropdown_open,
     b_index,
     bisect_in,
     box_gen_coords,
@@ -113,11 +114,11 @@ from .tooltip import Tooltip
 class MainTable(tk.Canvas):
     def __init__(
         self,
-        parent,
+        parent: tk.Misc,
         row_index_canvas: RowIndex,
         column_headers_canvas: ColumnHeaders,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(
             parent,
             background=parent.ops.table_bg,
@@ -148,6 +149,7 @@ class MainTable(tk.Canvas):
         )
         self.tooltip_widgets = widget_descendants(self.tooltip)
         self.tooltip_coords, self.tooltip_after_id, self.tooltip_showing = None, None, False
+        self.tooltip_cell_content = ""
         recursive_bind(self.tooltip, "<Leave>", self.close_tooltip_save)
         self.dropdown = DropdownStorage()
         self.text_editor = TextEditorStorage()
@@ -5695,7 +5697,8 @@ class MainTable(tk.Canvas):
         can_width: int | None,
         dont_blend: bool,
         alternate_color: Highlight | None,
-        has_dd: bool = False,
+        has_dd: bool,
+        tags: str | tuple[str],
     ) -> tuple[str, bool]:
         redrawn = False
         if (datarn, datacn) in self.progress_bars:
@@ -5745,6 +5748,7 @@ class MainTable(tk.Canvas):
                         )
                     ),
                     outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
                     can_width=None,
                     pc=None,
                 )
@@ -5771,6 +5775,7 @@ class MainTable(tk.Canvas):
                         )
                     ),
                     outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
                     can_width=None,
                     pc=None,
                 )
@@ -5797,6 +5802,7 @@ class MainTable(tk.Canvas):
                         )
                     ),
                     outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
                     can_width=None,
                     pc=None,
                 )
@@ -5813,6 +5819,7 @@ class MainTable(tk.Canvas):
                             y2=sr,
                             fill=high_bg,
                             outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                            tags=tags,
                             can_width=can_width if (len(kwargs) > 2 and kwargs[2]) else None,
                             pc=None,
                         )
@@ -5827,6 +5834,7 @@ class MainTable(tk.Canvas):
                                 y2=sr,
                                 fill=high_bg,
                                 outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                                tags=tags,
                                 can_width=None,
                                 pc=kwargs.percent,
                             )
@@ -5841,6 +5849,7 @@ class MainTable(tk.Canvas):
                     y2=sr,
                     fill=self.PAR.ops.table_selected_cells_bg,
                     outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
                     can_width=None,
                     pc=None,
                 )
@@ -5853,6 +5862,7 @@ class MainTable(tk.Canvas):
                     y2=sr,
                     fill=self.PAR.ops.table_selected_rows_bg,
                     outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
                     can_width=None,
                     pc=None,
                 )
@@ -5865,11 +5875,23 @@ class MainTable(tk.Canvas):
                     y2=sr,
                     fill=self.PAR.ops.table_selected_columns_bg,
                     outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
                     can_width=None,
                     pc=None,
                 )
             else:
                 txtfg = self.PAR.ops.table_fg
+                redrawn = self.redraw_highlight(
+                    x1=fc + 1,
+                    y1=fr + 1,
+                    x2=sc,
+                    y2=sr,
+                    fill="",
+                    outline=self.PAR.ops.table_fg if has_dd and self.PAR.ops.show_dropdown_borders else "",
+                    tags=tags,
+                    can_width=None,
+                    pc=None,
+                )
         return txtfg, redrawn
 
     def redraw_highlight(
@@ -5880,6 +5902,7 @@ class MainTable(tk.Canvas):
         y2: int | float,
         fill: str,
         outline: str,
+        tags: str | tuple[str],
         can_width: None | float = None,
         pc: None | float = None,
     ) -> bool:
@@ -5898,11 +5921,11 @@ class MainTable(tk.Canvas):
             iid, showing = self.hidd_high.popitem()
             self.coords(iid, coords)
             if showing:
-                self.itemconfig(iid, fill=fill, outline=outline)
+                self.itemconfig(iid, fill=fill, outline=outline, tags=tags)
             else:
-                self.itemconfig(iid, fill=fill, outline=outline, state="normal")
+                self.itemconfig(iid, fill=fill, outline=outline, state="normal", tags=tags)
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline, tags=tags)
         self.disp_high[iid] = True
         return True
 
@@ -6083,15 +6106,15 @@ class MainTable(tk.Canvas):
             self.char_widths[self.table_font][c] = wd
             return wd
 
-    def redraw_corner(self, x: float, y: float) -> None:
+    def redraw_corner(self, x: float, y: float, tags: str | tuple[str]) -> None:
         if self.hidd_corners:
             iid = self.hidd_corners.pop()
             self.coords(iid, x - 10, y, x, y, x, y + 10)
-            self.itemconfig(iid, fill=self.PAR.ops.table_grid_fg, state="normal")
+            self.itemconfig(iid, fill=self.PAR.ops.table_grid_fg, state="normal", tags=tags)
             self.disp_corners.add(iid)
         else:
             self.disp_corners.add(
-                self.create_polygon(x - 10, y, x, y, x, y + 10, fill=self.PAR.ops.table_grid_fg, tags="lift")
+                self.create_polygon(x - 10, y, x, y, x, y + 10, fill=self.PAR.ops.table_grid_fg, tags=tags)
             )
 
     def redraw_grid_and_text(
@@ -6210,15 +6233,14 @@ class MainTable(tk.Canvas):
             rtopgridln = self.row_positions[r]
             rbotgridln = self.row_positions[r + 1]
             datarn = cells["datarn"][r]
-
             for c in range(text_start_col, text_end_col):
                 cleftgridln = self.col_positions[c]
                 crightgridln = self.col_positions[c + 1]
                 datacn = cells["datacn"][c]
                 disp_loc = (r, c)
                 loc = (datarn, datacn)
-
-                fill, dd_drawn = self.redraw_highlight_get_text_fg(
+                tag = f"{r}_{c}"
+                fill, _ = self.redraw_highlight_get_text_fg(
                     r=r,
                     c=c,
                     fc=cleftgridln,
@@ -6235,6 +6257,7 @@ class MainTable(tk.Canvas):
                     dont_blend=disp_loc == dont_blend,
                     alternate_color=alternate_color,
                     has_dd=loc in cells["dropdown"],
+                    tags=("h", "c", tag),
                 )
                 if loc in self.cell_options and "align" in self.cell_options[(datarn, datacn)]:
                     align = self.cell_options[(datarn, datacn)]["align"]
@@ -6261,8 +6284,8 @@ class MainTable(tk.Canvas):
                     y1 = rtopgridln
                     x2 = crightgridln
                     y2 = self.row_positions[r + 1]
-                    if not dd_drawn and self.PAR.ops.show_dropdown_borders:
-                        self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg)
+                    # if not dd_drawn and self.PAR.ops.show_dropdown_borders:
+                    #     self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.table_fg)
                     if max_width >= 5:
                         if dd_coords == disp_loc:
                             # up arrow
@@ -6362,6 +6385,8 @@ class MainTable(tk.Canvas):
                     elif align[-1] == "n":
                         draw_x = cleftgridln + (crightgridln - cleftgridln) / 2
 
+                tags = ("lift", "c", tag)
+
                 if (
                     note_corners
                     and max_width > 5
@@ -6371,12 +6396,14 @@ class MainTable(tk.Canvas):
                         or (datacn in self.col_options and "note" in self.col_options[datacn])
                     )
                 ):
-                    self.redraw_corner(crightgridln, rtopgridln)
+                    self.redraw_corner(crightgridln, rtopgridln, tags)
 
                 # redraw text
-
-                text = cells[loc]
-                if (align[-1] == "w" and draw_x > scrollpos_right) or cleftgridln + 5 > scrollpos_right:
+                if (
+                    not cells[loc]
+                    or (align[-1] == "w" and draw_x > scrollpos_right)
+                    or cleftgridln + 5 > scrollpos_right
+                ):
                     continue
                 if allow_overflow and not kws:
                     if align[-1] == "w":
@@ -6388,7 +6415,7 @@ class MainTable(tk.Canvas):
                 start_line = max(0, int((scrollpos_top - rtopgridln) / self.table_txt_height))
                 draw_y = rtopgridln + 3 + (start_line * self.table_txt_height)
                 gen_lines = wrap_text(
-                    text=text,
+                    text=cells[loc],
                     max_width=max_width,
                     max_lines=int((rbotgridln - rtopgridln - 2) / self.table_txt_height),
                     char_width_fn=self.wrap_get_char_w,
@@ -6407,7 +6434,7 @@ class MainTable(tk.Canvas):
                                 fill=fill,
                                 font=font,
                                 anchor=align,
-                                tags=("lift", "t", f"{r}_{c}"),
+                                tags=tags,
                             )
                         else:
                             self.itemconfig(
@@ -6417,7 +6444,7 @@ class MainTable(tk.Canvas):
                                 font=font,
                                 anchor=align,
                                 state="normal",
-                                tags=("lift", "t", f"{r}_{c}"),
+                                tags=tags,
                             )
                     else:
                         iid = self.create_text(
@@ -6427,7 +6454,7 @@ class MainTable(tk.Canvas):
                             fill=fill,
                             font=font,
                             anchor=align,
-                            tags=("lift", "t", f"{r}_{c}"),
+                            tags=tags,
                         )
                     self.disp_text[iid] = True
 
@@ -6443,7 +6470,7 @@ class MainTable(tk.Canvas):
                                     fill=fill,
                                     font=font,
                                     anchor=align,
-                                    tags=("lift", "t", f"{r}_{c}"),
+                                    tags=tags,
                                 )
                             else:
                                 self.itemconfig(
@@ -6453,7 +6480,7 @@ class MainTable(tk.Canvas):
                                     font=font,
                                     anchor=align,
                                     state="normal",
-                                    tags=("lift", "t", f"{r}_{c}"),
+                                    tags=tags,
                                 )
                         else:
                             iid = self.create_text(
@@ -6463,7 +6490,7 @@ class MainTable(tk.Canvas):
                                 fill=fill,
                                 font=font,
                                 anchor=align,
-                                tags=("lift", "t", f"{r}_{c}"),
+                                tags=tags,
                             )
                         self.disp_text[iid] = True
                         draw_y += self.table_txt_height
@@ -6487,10 +6514,12 @@ class MainTable(tk.Canvas):
             if self.selected:
                 self.tag_raise(self.selected.iid)
         self.lift("lift")
-        self.tag_bind("t", "<Enter>", self.enter_text)
-        self.tag_bind("t", "<Leave>", self.leave_text)
+        self.tag_bind("c", "<Enter>", self.enter_cell)
+        self.tag_bind("c", "<Leave>", self.leave_cell)
 
-    def enter_text(self, event: tk.Event | None = None) -> None:
+    def enter_cell(self, event: tk.Event | None = None) -> None:
+        if any_editor_or_dropdown_open(self):
+            return
         can_x, can_y = self.canvasx(event.x), self.canvasy(event.y)
         for i in self.find_overlapping(can_x - 1, can_y - 1, can_x + 1, can_y + 1):
             try:
@@ -6503,7 +6532,7 @@ class MainTable(tk.Canvas):
             except Exception:
                 continue
 
-    def leave_text(self, event: tk.Event | None = None) -> None:
+    def leave_cell(self, event: tk.Event | None = None) -> None:
         if self.tooltip_after_id is not None:
             self.after_cancel(self.tooltip_after_id)
             self.tooltip_after_id = None
@@ -6514,7 +6543,7 @@ class MainTable(tk.Canvas):
             self.tooltip_coords = None
 
     def start_tooltip_timer(self) -> None:
-        self.tooltip_after_id = self.after(1000, self.check_and_show_tooltip)
+        self.tooltip_after_id = self.after(self.PAR.ops.tooltip_hover_delay, self.check_and_show_tooltip)
 
     def check_and_show_tooltip(self, event: tk.Event | None = None) -> None:
         current_x, current_y = self.winfo_pointerx(), self.winfo_pointery()
@@ -6539,20 +6568,23 @@ class MainTable(tk.Canvas):
         kws = self.get_cell_kwargs(datarn, datacn, key="note")
         if not self.PAR.ops.tooltips and not kws and not self.PAR.ops.user_can_create_notes:
             return
+        self.CH.hide_tooltip()
+        self.RI.hide_tooltip()
         cell_readonly = self.get_cell_kwargs(datarn, datacn, "readonly") or not self.table_edit_cell_enabled()
         if kws:
             note = kws["note"]
             note_readonly = kws["readonly"]
         elif self.PAR.ops.user_can_create_notes:
             note = ""
-            note_readonly = bool(cell_readonly)
+            note_readonly = False
         else:
             note = None
             note_readonly = True
         note_only = not self.PAR.ops.tooltips and isinstance(note, str)
+        self.tooltip_cell_content = f"{self.get_cell_data(datarn, datacn, none_to_empty_str=True)}"
         self.tooltip.reset(
             **{
-                "text": f"{self.get_cell_data(datarn, datacn, none_to_empty_str=True)}",
+                "text": self.tooltip_cell_content,
                 "cell_readonly": cell_readonly,
                 "note": note,
                 "note_readonly": note_readonly,
@@ -6572,30 +6604,22 @@ class MainTable(tk.Canvas):
     def close_tooltip_save(self, event: tk.Event | None = None) -> None:
         widget = self.winfo_containing(self.winfo_pointerx(), self.winfo_pointery())
         if any(widget == tw for tw in self.tooltip_widgets):
-            try:
-                if self.tooltip.notebook.index("current") == 0:
-                    self.tooltip.content_text.focus_set()
-                else:
-                    self.tooltip.note_text.focus_set()
-            except Exception:
-                self.tooltip.content_text.focus_set()
             return
         if not self.tooltip.cell_readonly or not self.tooltip.note_readonly:
             r, c, cell, note = self.tooltip.get()
             datarn, datacn = self.datarn(r), self.datacn(c)
-            if not self.tooltip.cell_readonly:
+            if not self.tooltip.cell_readonly and cell != self.tooltip_cell_content:
                 event_data = self.new_single_edit_event(
                     r, c, datarn, datacn, "??", self.get_cell_data(datarn, datacn), cell
                 )
                 value, event_data = self.single_edit_run_validation(datarn, datacn, event_data)
-                if value is not None and (
+                if value is not None:
                     self.set_cell_data_undo(r=r, c=c, datarn=datarn, datacn=datacn, value=value, redraw=False)
-                ):
                     try_binding(self.extra_end_edit_cell_func, event_data)
             if not self.tooltip.note_readonly:
                 self.PAR.note(datarn, datacn, note=note if note else None, readonly=False)
+            self.refresh()
         self.hide_tooltip()
-        self.refresh()
         self.focus_set()
 
     def main_table_redraw_grid_and_text(
@@ -7344,6 +7368,7 @@ class MainTable(tk.Canvas):
             self.text_editor.window.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
+        self.hide_tooltip()
         if not self.see(r, c):
             self.main_table_redraw_grid_and_text(True, True)
         x = self.col_positions[c]

tksheet/row_index.py

@@ -20,6 +20,7 @@ from .constants import (
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
     add_to_displayed,
+    any_editor_or_dropdown_open,
     consecutive_ranges,
     event_dict,
     event_has_char_key,
@@ -52,7 +53,7 @@ from .tooltip import Tooltip
 
 
 class RowIndex(tk.Canvas):
-    def __init__(self, parent, **kwargs):
+    def __init__(self, parent: tk.Misc, **kwargs) -> None:
         super().__init__(
             parent,
             background=parent.ops.index_bg,
@@ -74,6 +75,7 @@ class RowIndex(tk.Canvas):
         )
         self.tooltip_widgets = widget_descendants(self.tooltip)
         self.tooltip_coords, self.tooltip_after_id, self.tooltip_showing = None, None, False
+        self.tooltip_cell_content = ""
         recursive_bind(self.tooltip, "<Leave>", self.close_tooltip_save)
         self.current_cursor = ""
         self.new_iid_ctr = -1
@@ -1311,6 +1313,7 @@ class RowIndex(tk.Canvas):
         selections: dict,
         datarn: int,
         has_dd: bool,
+        tags: str | tuple[str],
     ) -> tuple[str, str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datarn, key="highlight")
@@ -1337,6 +1340,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(high_bg[5:], 16) + int(sel_rows_bg[5:], 16)) / 2):02X}"
                     ),
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = (
@@ -1357,6 +1361,7 @@ class RowIndex(tk.Canvas):
                         + f"{int((int(high_bg[5:], 16) + int(sel_cells_bg[5:], 16)) / 2):02X}"
                     ),
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             else:
                 txtfg = self.ops.index_fg if kwargs[1] is None else kwargs[1]
@@ -1368,6 +1373,7 @@ class RowIndex(tk.Canvas):
                         sr,
                         fill=high_bg,
                         outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                        tags=tags,
                     )
             tree_arrow_fg = txtfg
         elif not kwargs:
@@ -1381,6 +1387,7 @@ class RowIndex(tk.Canvas):
                     sr,
                     fill=self.ops.index_selected_rows_bg,
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = self.ops.index_selected_cells_fg
@@ -1392,10 +1399,20 @@ class RowIndex(tk.Canvas):
                     sr,
                     fill=self.ops.index_selected_cells_bg,
                     outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
                 )
             else:
                 txtfg = self.ops.index_fg
                 tree_arrow_fg = self.ops.tree_arrow_fg
+                redrawn = self.redraw_highlight(
+                    0,
+                    fr + 1,
+                    self.current_width - 1,
+                    sr,
+                    fill="",
+                    outline=self.ops.index_fg if has_dd and self.ops.show_dropdown_borders else "",
+                    tags=tags,
+                )
         return txtfg, tree_arrow_fg, redrawn
 
     def redraw_highlight(
@@ -1406,17 +1423,18 @@ class RowIndex(tk.Canvas):
         y2: float,
         fill: str,
         outline: str,
+        tags: str | tuple[str],
     ) -> bool:
         coords = (x1, y1, x2, y2)
         if self.hidd_high:
             iid, showing = self.hidd_high.popitem()
             self.coords(iid, coords)
             if showing:
-                self.itemconfig(iid, fill=fill, outline=outline)
+                self.itemconfig(iid, fill=fill, outline=outline, tags=tags)
             else:
-                self.itemconfig(iid, fill=fill, outline=outline, state="normal")
+                self.itemconfig(iid, fill=fill, outline=outline, state="normal", tags=tags)
         else:
-            iid = self.create_rectangle(coords, fill=fill, outline=outline)
+            iid = self.create_rectangle(coords, fill=fill, outline=outline, tags=tags)
         self.disp_high[iid] = True
         return True
 
@@ -1539,8 +1557,8 @@ class RowIndex(tk.Canvas):
         draw_arrow: bool = True,
         open_: bool = False,
     ) -> None:
-        if draw_outline and self.ops.show_dropdown_borders:
-            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.index_fg)
+        # if draw_outline and self.ops.show_dropdown_borders:
+        #     self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.index_fg)
         if draw_arrow:
             mod = (self.MT.index_txt_height - 1) if self.MT.index_txt_height % 2 else self.MT.index_txt_height
             small_mod = int(mod / 5)
@@ -1650,15 +1668,15 @@ class RowIndex(tk.Canvas):
             self.MT.char_widths[self.index_font][c] = wd
             return wd
 
-    def redraw_corner(self, x: float, y: float) -> None:
+    def redraw_corner(self, x: float, y: float, tags: str | tuple[str]) -> None:
         if self.hidd_corners:
             iid = self.hidd_corners.pop()
             self.coords(iid, x - 10, y, x, y, x, y + 10)
-            self.itemconfig(iid, fill=self.ops.index_grid_fg, state="normal")
+            self.itemconfig(iid, fill=self.ops.index_grid_fg, state="normal", tags=tags)
             self.disp_corners.add(iid)
         else:
             self.disp_corners.add(
-                self.create_polygon(x - 10, y, x, y, x, y + 10, fill=self.ops.index_grid_fg, tags="lift")
+                self.create_polygon(x - 10, y, x, y, x, y + 10, fill=self.ops.index_grid_fg, tags=tags)
             )
 
     def redraw_grid_and_text(
@@ -1697,7 +1715,6 @@ class RowIndex(tk.Canvas):
             self.current_width,
             scrollpos_bot,
         )
-
         if (self.ops.show_horizontal_grid or self.height_resizing_enabled) and row_pos_exists:
             xend = self.current_width - 6
             points = [
@@ -1725,7 +1742,6 @@ class RowIndex(tk.Canvas):
                     )
                 )
             self.redraw_gridline(points=points, fill=self.ops.index_grid_fg, width=1)
-
         sel_cells_bg = (
             self.ops.index_selected_cells_bg
             if self.ops.index_selected_cells_bg.startswith("#")
@@ -1750,6 +1766,7 @@ class RowIndex(tk.Canvas):
             checkbox_kwargs = {}
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
             dropdown_kwargs = self.get_cell_kwargs(datarn, key="dropdown")
+            tag = f"{r}"
             fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
                 fr=rtopgridln,
                 sr=rbotgridln,
@@ -1759,8 +1776,8 @@ class RowIndex(tk.Canvas):
                 selections=selections,
                 datarn=datarn,
                 has_dd=bool(dropdown_kwargs),
+                tags=("h", "c", tag),
             )
-
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
                 align = self.cell_options[datarn]["align"]
             else:
@@ -1837,10 +1854,9 @@ class RowIndex(tk.Canvas):
                     open_=self.MT._row_index[datarn].iid in self.tree_open_ids,
                     level=level,
                 )
-
+            tags = ("lift", "c", tag)
             if note_corners and max_width > 5 and datarn in self.cell_options and "note" in self.cell_options[datarn]:
-                self.redraw_corner(self.current_width, rtopgridln)
-
+                self.redraw_corner(self.current_width, rtopgridln, tags)
             if max_width <= 1:
                 continue
             text = self.cell_str(datarn, fix=False)
@@ -1868,7 +1884,7 @@ class RowIndex(tk.Canvas):
                             fill=fill,
                             font=font,
                             anchor=align,
-                            tags=("lift", "t", f"{r}"),
+                            tags=tags,
                         )
                     else:
                         self.itemconfig(
@@ -1878,7 +1894,7 @@ class RowIndex(tk.Canvas):
                             font=font,
                             anchor=align,
                             state="normal",
-                            tags=("lift", "t", f"{r}"),
+                            tags=tags,
                         )
                 else:
                     iid = self.create_text(
@@ -1888,7 +1904,7 @@ class RowIndex(tk.Canvas):
                         fill=fill,
                         font=font,
                         anchor=align,
-                        tags=("lift", "t", f"{r}"),
+                        tags=tags,
                     )
                 self.disp_text[iid] = True
             else:
@@ -1903,7 +1919,7 @@ class RowIndex(tk.Canvas):
                                 fill=fill,
                                 font=font,
                                 anchor=align,
-                                tags=("lift", "t", f"{r}"),
+                                tags=tags,
                             )
                         else:
                             self.itemconfig(
@@ -1913,7 +1929,7 @@ class RowIndex(tk.Canvas):
                                 font=font,
                                 anchor=align,
                                 state="normal",
-                                tags=("lift", "t", f"{r}"),
+                                tags=tags,
                             )
                     else:
                         iid = self.create_text(
@@ -1923,7 +1939,7 @@ class RowIndex(tk.Canvas):
                             fill=fill,
                             font=font,
                             anchor=align,
-                            tags=("lift", "t", f"{r}"),
+                            tags=tags,
                         )
                     self.disp_text[iid] = True
                     draw_y += self.MT.header_txt_height
@@ -1945,12 +1961,12 @@ class RowIndex(tk.Canvas):
         self.tag_raise("lift")
         if self.disp_resize_lines:
             self.tag_raise("rh")
-        self.tag_bind("t", "<Enter>", self.enter_text)
-        self.tag_bind("t", "<Leave>", self.leave_text)
+        self.tag_bind("c", "<Enter>", self.enter_cell)
+        self.tag_bind("c", "<Leave>", self.leave_cell)
         return True
 
-    def enter_text(self, event: tk.Event | None = None) -> None:
-        if self.text_editor.open or self.dropdown.open:
+    def enter_cell(self, event: tk.Event | None = None) -> None:
+        if any_editor_or_dropdown_open(self.MT):
             return
         can_x, can_y = self.canvasx(event.x), self.canvasy(event.y)
         for i in self.find_overlapping(can_x - 1, can_y - 1, can_x + 1, can_y + 1):
@@ -1964,7 +1980,7 @@ class RowIndex(tk.Canvas):
             except Exception:
                 continue
 
-    def leave_text(self, event: tk.Event | None = None) -> None:
+    def leave_cell(self, event: tk.Event | None = None) -> None:
         if self.tooltip_after_id is not None:
             self.after_cancel(self.tooltip_after_id)
             self.tooltip_after_id = None
@@ -1975,7 +1991,7 @@ class RowIndex(tk.Canvas):
             self.tooltip_coords = None
 
     def start_tooltip_timer(self) -> None:
-        self.tooltip_after_id = self.after(1000, self.check_and_show_tooltip)
+        self.tooltip_after_id = self.after(self.ops.tooltip_hover_delay, self.check_and_show_tooltip)
 
     def check_and_show_tooltip(self, event: tk.Event | None = None) -> None:
         current_x, current_y = self.winfo_pointerx(), self.winfo_pointery()
@@ -1997,19 +2013,22 @@ class RowIndex(tk.Canvas):
         kws = self.get_cell_kwargs(datarn, key="note")
         if not self.ops.tooltips and not kws and not self.ops.user_can_create_notes:
             return
+        self.MT.hide_tooltip()
+        self.CH.hide_tooltip()
         cell_readonly = self.get_cell_kwargs(datarn, "readonly") or not self.MT.index_edit_cell_enabled()
         if kws:
             note = kws["note"]
             note_readonly = kws["readonly"]
         elif self.ops.user_can_create_notes:
             note = ""
-            note_readonly = bool(cell_readonly)
+            note_readonly = False
         else:
             note = None
             note_readonly = True
+        self.tooltip_cell_content = f"{self.get_cell_data(datarn, none_to_empty_str=True)}"
         self.tooltip.reset(
             **{
-                "text": f"{self.get_cell_data(datarn, none_to_empty_str=True)}",
+                "text": self.tooltip_cell_content,
                 "cell_readonly": cell_readonly,
                 "note": note,
                 "note_readonly": note_readonly,
@@ -2029,25 +2048,18 @@ class RowIndex(tk.Canvas):
     def close_tooltip_save(self, event: tk.Event | None = None) -> None:
         widget = self.winfo_containing(self.winfo_pointerx(), self.winfo_pointery())
         if any(widget == tw for tw in self.tooltip_widgets):
-            try:
-                if self.tooltip.notebook.index("current") == 0:
-                    self.tooltip.content_text.focus_set()
-                else:
-                    self.tooltip.note_text.focus_set()
-            except Exception:
-                self.tooltip.content_text.focus_set()
             return
         if not self.tooltip.cell_readonly or not self.tooltip.note_readonly:
             r, _, cell, note = self.tooltip.get()
             datarn = self.MT.datarn(r)
-            if not self.tooltip.cell_readonly:
+            if not self.tooltip.cell_readonly and cell != self.tooltip_cell_content:
                 event_data = self.new_single_edit_event(r, datarn, "??", self.get_cell_data(datarn), cell)
                 self.do_single_edit(r, datarn, event_data, cell)
             if not self.tooltip.note_readonly:
                 span = self.PAR.span(datarn).options(table=False, index=True)
                 self.PAR.note(span, note=note if note else None, readonly=False)
+            self.MT.refresh()
         self.hide_tooltip()
-        self.MT.refresh()
         self.focus_set()
 
     def get_redraw_selections(self, startr: int, endr: int) -> dict[str, set[int]]:
@@ -2132,6 +2144,7 @@ class RowIndex(tk.Canvas):
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
+        self.hide_tooltip()
         if not self.MT.see(r, 0, keep_yscroll=True):
             self.MT.main_table_redraw_grid_and_text(True, True)
         x = 0

tksheet/sheet.py

@@ -206,6 +206,7 @@ class Sheet(tk.Frame):
         note_corners: bool = False,
         tooltip_width: int = 210,
         tooltip_height: int = 210,
+        tooltip_hover_delay: int = 1200,
         # colors
         outline_thickness: int = 0,
         theme: str = "light blue",
@@ -4669,51 +4670,52 @@ class Sheet(tk.Frame):
             deselect_all=False,
             data_indexes=True,
         )
-        open_ids = set(filter(self.exists, open_ids))
         self.RI.tree_open_ids = set()
-        if open_ids:
-            self.show_rows(
-                rows=self._tree_open(open_ids),
-                redraw=False,
-                deselect_all=False,
-            )
+        open_ids = filter(self.exists, open_ids)
+        try:
+            first_id = next(open_ids)
+        except StopIteration:
+            return self.set_refresh_timer()
+        self.show_rows(
+            rows=self._tree_open(chain((first_id,), open_ids)),
+            redraw=False,
+            deselect_all=False,
+        )
         return self.set_refresh_timer()
 
-    def _tree_open(self, items: set[str]) -> list[int]:
+    def _tree_open(self, items: Iterator[str]) -> Generator[int]:
         """
         Only meant for internal use
         """
-        to_open = []
         disp_set = set(self.MT.displayed_rows)
         index = self.MT._row_index
         rns = self.RI.rns
         open_ids = self.RI.tree_open_ids
         descendants = self.RI.get_iid_descendants
-        for item in filter(items.__contains__, self.get_children()):
-            if index[rns[item]].children:
+        for item in items:
+            if item in rns and index[rns[item]].children:
                 open_ids.add(item)
                 if rns[item] in disp_set:
                     for did in descendants(item, check_open=True):
                         disp_set.add(rns[did])
-                        to_open.append(rns[did])
-        return to_open
+                        yield rns[did]
 
-    def tree_open(self, *items, redraw: bool = True) -> Sheet:
+    def tree_open(self, *items: str, redraw: bool = True) -> Sheet:
         """
         If used without args all items are opened
         """
-        to_open = self._tree_open(items) if (items := set(unpack(items))) else self._tree_open(set(self.get_children()))
+        to_show = self._tree_open(items) if (items := set(unpack(items))) else self._tree_open(self.get_children())
         return self.show_rows(
-            rows=to_open,
+            rows=to_show,
             redraw=redraw,
             deselect_all=False,
         )
 
-    def _tree_close(self, items: Iterator[str]) -> list[int]:
+    def _tree_close(self, items: Iterator[str]) -> set[int]:
         """
         Only meant for internal use
         """
-        to_close = set()
+        to_hide = set()
         disp_set = set(self.MT.displayed_rows)
         index = self.MT._row_index
         rns = self.RI.rns
@@ -4724,16 +4726,16 @@ class Sheet(tk.Frame):
                 open_ids.discard(item)
                 if rns[item] in disp_set:
                     for did in descendants(item, check_open=True):
-                        to_close.add(rns[did])
-        return to_close
+                        to_hide.add(rns[did])
+        return to_hide
 
-    def tree_close(self, *items, redraw: bool = True) -> Sheet:
+    def tree_close(self, *items: str, redraw: bool = True) -> Sheet:
         """
         If used without args all items are closed
         """
-        to_close = self._tree_close(unpack(items)) if items else self._tree_close(self.get_children())
+        to_hide = self._tree_close(unpack(items)) if items else self._tree_close(self.get_children())
         return self.hide_rows(
-            rows=to_close,
+            rows=to_hide,
             redraw=redraw,
             deselect_all=False,
             data_indexes=True,
@@ -5109,7 +5111,7 @@ class Sheet(tk.Frame):
         """
         if not self.item_displayed(item) and self.RI.iid_parent(item):
             self.show_rows(
-                rows=self._tree_open(list(self.RI.get_iid_ancestors(item))),
+                rows=self._tree_open(self.RI.get_iid_ancestors(item)),
                 redraw=False,
                 deselect_all=False,
             )
@@ -5154,11 +5156,11 @@ class Sheet(tk.Frame):
         return self.set_refresh_timer(redraw)
 
     def selection_add(self, *items, run_binding: bool = True, redraw: bool = True) -> Sheet:
-        to_open = []
+        to_open = set()
         quick_displayed_check = set(self.MT.displayed_rows)
         for item in filter(self.RI.rns.__contains__, unpack(items)):
             if self.RI.rns[item] not in quick_displayed_check and self.RI.iid_parent(item):
-                to_open.extend(list(self.RI.get_iid_ancestors(item)))
+                to_open.update(self.RI.get_iid_ancestors(item))
         if to_open:
             self.show_rows(
                 rows=self._tree_open(to_open),

tksheet/sheet_options.py

@@ -370,5 +370,6 @@ def new_sheet_options() -> DotDict:
             "note_corners": False,
             "tooltip_width": 210,
             "tooltip_height": 210,
+            "tooltip_hover_delay": 1200,
         }
     )

tksheet/tooltip.py

@@ -217,7 +217,7 @@ class Tooltip(tk.Toplevel):
         self.note_scrollbar.configure(command=self.note_text.yview)
         self.note_text.configure(yscrollcommand=self.note_scrollbar.set)
 
-    def setup_note_only_mode(self):
+    def setup_note_only_mode(self) -> None:
         """Configure the tooltip to show only the note text widget."""
         self.notebook.pack_forget()  # Remove notebook from layout
         for tab in self.notebook.tabs():  # Clear all tabs to free the frames
@@ -225,7 +225,7 @@ class Tooltip(tk.Toplevel):
         self.content_frame.pack_forget()  # Ensure content_frame is not directly packed
         self.note_frame.pack(fill="both", expand=True)  # Show note_frame directly
 
-    def setup_single_text_mode(self):
+    def setup_single_text_mode(self) -> None:
         """Configure the tooltip to show only the content text widget."""
         self.notebook.pack_forget()  # Remove notebook from layout
         for tab in self.notebook.tabs():  # Clear all tabs
@@ -233,7 +233,7 @@ class Tooltip(tk.Toplevel):
         self.note_frame.pack_forget()  # Ensure note_frame is not directly packed
         self.content_frame.pack(fill="both", expand=True)  # Show content_frame directly
 
-    def setup_notebook_mode(self):
+    def setup_notebook_mode(self) -> None:
         """Configure the tooltip to show a notebook with Cell and Note tabs."""
         self.content_frame.pack_forget()  # Ensure content_frame is not directly packed
         self.note_frame.pack_forget()  # Ensure note_frame is not directly packed

{tksheet-7.5.10.dist-info → tksheet-7.5.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tksheet
-Version: 7.5.10
+Version: 7.5.12
 Summary: Tkinter table / sheet and treeview widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -77,6 +77,8 @@ Dynamic: license-file
 
 [![GitHub Release Date](https://img.shields.io/github/release-date-pre/ragardner/tksheet.svg)](https://github.com/ragardner/tksheet/releases) [![Downloads](https://img.shields.io/pypi/dm/tksheet.svg)](https://pypi.org/project/tksheet/)
 
+With apologies, development of this library has ceased except for bug fixes or behavioral issues. Pull requests for other changes are unlikely to be merged.
+
 <table>
   <thead>
     <tr>
@@ -95,14 +97,11 @@ Dynamic: license-file
     <tr>
       <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/blob/master/docs/CHANGELOG.md" target="_blank">Changelog</a></td>
     </tr>
-    <tr>
-      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#asking-questions" target="_blank">Questions</a></td>
-    </tr>
     <tr>
       <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#issues" target="_blank">Issues</a></td>
     </tr>
     <tr>
-      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#enhancements-or-suggestions" target="_blank">Suggestions and Contributors</a></td>
+      <td align="right" colspan="2"><a href="https://github.com/ragardner/tksheet/wiki/Version-7#contributions-and-special-thanks" target="_blank">Contributions and Thanks</a></td>
     </tr>
   </tbody>
 </table>

{tksheet-7.5.10.dist-info → tksheet-7.5.12.dist-info}/RECORD

@@ -1,24 +1,24 @@
-tksheet/__init__.py,sha256=3Ue-5hmalzD8JxLLXk1WoBPBWdZ3MWkFfs_3wx0S2w8,2533
+tksheet/__init__.py,sha256=fD70jpRTugB9VWfpt6BManIsp4vrlXl9UK5RU74jmYc,2533
 tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
-tksheet/column_headers.py,sha256=-i8LMCUW1UuKpyurWySJRyjiCqisgFrjm9l8U58bFAY,110720
+tksheet/column_headers.py,sha256=CkJBfgLu3qcXDJWhYT8mWniH81kMDeWsqcCoRko_FHo,111362
 tksheet/constants.py,sha256=4cpU_PmOgN0isBVPWwCwBwqD8Fxnu4HJgDSSjfxjiPo,25467
 tksheet/find_window.py,sha256=aV2U-IDFL6xNRhF4VomdrXEML4qw6QBqlfrVskuiTNY,20954
 tksheet/formatters.py,sha256=r2vjgmKs_xWBYlfqVhPPNKQc67zCawOIl4dp4XAEzYg,10182
-tksheet/functions.py,sha256=O74jt9Kq-JgtWaI7fHBXbIbCTdi79B3eHidR-wfiAZ0,56585
-tksheet/main_table.py,sha256=awMX6ABc_LW-gzhZh9MKnyMv9-ZKpBEQUcEylwKjVMA,368162
+tksheet/functions.py,sha256=l4iwL-0RT0NrQTP1AKb6QGzAF01Sk-I6Kp5TaWb8ARw,56795
+tksheet/main_table.py,sha256=XeonBS6BeuVb057TAbvphcULWPTL0mkTqLMVWLeXPh4,369093
 tksheet/menus.py,sha256=sRHZRgnYWddBtlzvbyWFSN2cVhlmUWyA9zf4vpqun7I,19431
 tksheet/other_classes.py,sha256=6LpexHAxj23ZweuL3a4yCcdMSj_iXP38S7WRNQAehe0,18354
-tksheet/row_index.py,sha256=wmoQylsUJQMnbONIndeRM_gW9eHJg-DdmX6MjxqlQlk,146892
-tksheet/sheet.py,sha256=gYm2o_chSI9vCtxY4r5j9soKQXXWFgvuH2FrEd3IGc4,273109
-tksheet/sheet_options.py,sha256=dhHY4jUULGXH2b_VOjoAfKXm3PAz7QL5CrVnHA0byho,14697
+tksheet/row_index.py,sha256=RG9Z59ssefTVFmOR_kuu5LiUlRcSz1vO6KhM1pIWUYo,147530
+tksheet/sheet.py,sha256=l2wmgl2gHmL1G2RDPm-qRlwGShRHLQQMHzbdeoTzkfk,273171
+tksheet/sheet_options.py,sha256=Lse8YQK9GvCoqaEcRWAVqZrg9FyW-2CKgLwo7t9ee_I,14739
 tksheet/sorting.py,sha256=zcZPpRtP1h_xJGtGkG3E43H7deKQFnh9cMwZ1B2-aGc,17502
 tksheet/text_editor.py,sha256=Ksz4kT7TrCIzDhRZK9EM54M7R_5CvrwC1aeTrUPNOTg,8391
 tksheet/themes.py,sha256=kUUCUmvgu8vUlzfVNk9a3BEbeBcU3asNwPB_u-OejCY,18471
 tksheet/tksheet_types.py,sha256=qthH565jq60QCAeczvIWttIa4X5rFfLWPSwWBMDPilw,4611
-tksheet/tooltip.py,sha256=TTWk3HW5Sltamish9GCnAECwZLa9Rm6QC8-RCDDtQnE,12374
+tksheet/tooltip.py,sha256=Ns7MhhSzx0-5v18TDE7kl5jvOnZ6v57Qh5DOs_Lvc5s,12398
 tksheet/top_left_rectangle.py,sha256=A4wWL8PFl57Pn2Ek71rASCE1-bW844cTl7bgt4tLWzI,8499
-tksheet-7.5.10.dist-info/licenses/LICENSE.txt,sha256=n1UvJHBr-AYNOf6ExICDsEggh9R7U4V4m_gH7FD-y-o,2305
-tksheet-7.5.10.dist-info/METADATA,sha256=GI9d24XzxknLTYE8ITC4_dWUii4pG2r_P-jczO3Sb6I,9475
-tksheet-7.5.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tksheet-7.5.10.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.5.10.dist-info/RECORD,,
+tksheet-7.5.12.dist-info/licenses/LICENSE.txt,sha256=n1UvJHBr-AYNOf6ExICDsEggh9R7U4V4m_gH7FD-y-o,2305
+tksheet-7.5.12.dist-info/METADATA,sha256=Ea9FCFWptle102ucKjdC8dIV2s2Ze-tQ-Lxaz-AAS5Y,9465
+tksheet-7.5.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tksheet-7.5.12.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.5.12.dist-info/RECORD,,