tksheet 7.2.21__tar.gz → 7.2.22__tar.gz

{tksheet-7.2.21/tksheet.egg-info → tksheet-7.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.21
+Version: 7.2.22
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -46,7 +46,7 @@ License-File: LICENSE.txt
 
 # <div align="center">tksheet - python tkinter table widget</div>
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12|3.13-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![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/)
 

{tksheet-7.2.21 → tksheet-7.2.22}/README.md

@@ -4,7 +4,7 @@
 
 # <div align="center">tksheet - python tkinter table widget</div>
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12|3.13-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![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/)
 

{tksheet-7.2.21 → tksheet-7.2.22}/pyproject.toml

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

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/__init__.py

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

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/column_headers.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import tkinter as tk
 from collections import defaultdict
 from collections.abc import (
-    Callable,
     Hashable,
     Sequence,
 )
@@ -1190,45 +1189,44 @@ class ColumnHeaders(tk.Canvas):
         fc: float,
         sc: float,
         c: int,
-        c_2: str,
-        c_3: str,
+        sel_cells_bg: str,
+        sel_cols_bg: str,
         selections: dict,
         datacn: int,
     ) -> tuple[str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datacn, key="highlight")
         if kwargs:
-            if kwargs[0] is not None:
-                c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
+            fill = kwargs[0]
+            if fill and not fill.startswith("#"):
+                fill = color_map[fill]
             if "columns" in selections and c in selections["columns"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.header_selected_columns_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + int(c_3[1:3], 16)) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + int(c_3[3:5], 16)) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + int(c_3[5:], 16)) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + int(sel_cols_bg[1:3], 16)) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + int(sel_cols_bg[3:5], 16)) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + int(sel_cols_bg[5:], 16)) / 2):02X}"
                     )
             elif "cells" in selections and c in selections["cells"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.header_selected_cells_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + int(c_2[1:3], 16)) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + int(c_2[3:5], 16)) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + int(c_2[5:], 16)) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + int(sel_cells_bg[1:3], 16)) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + int(sel_cells_bg[3:5], 16)) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + int(sel_cells_bg[5:], 16)) / 2):02X}"
                     )
             else:
-                tf = self.PAR.ops.header_fg if kwargs[1] is None else kwargs[1]
-                if kwargs[0] is not None:
-                    fill = kwargs[0]
-            if kwargs[0] is not None:
+                txtfg = self.PAR.ops.header_fg if kwargs[1] is None else kwargs[1]
+            if fill:
                 redrawn = self.redraw_highlight(
                     fc + 1,
                     0,
@@ -1244,12 +1242,12 @@ class ColumnHeaders(tk.Canvas):
                 )
         elif not kwargs:
             if "columns" in selections and c in selections["columns"]:
-                tf = self.PAR.ops.header_selected_columns_fg
+                txtfg = self.PAR.ops.header_selected_columns_fg
             elif "cells" in selections and c in selections["cells"]:
-                tf = self.PAR.ops.header_selected_cells_fg
+                txtfg = self.PAR.ops.header_selected_cells_fg
             else:
-                tf = self.PAR.ops.header_fg
-        return tf, redrawn
+                txtfg = self.PAR.ops.header_fg
+        return txtfg, redrawn
 
     def redraw_highlight(
         self,
@@ -1463,12 +1461,12 @@ class ColumnHeaders(tk.Canvas):
                 )
             self.redraw_gridline(points=points, fill=self.PAR.ops.header_grid_fg, width=1, tag="v")
         top = self.canvasy(0)
-        c_2 = (
+        sel_cols_bg = (
             self.PAR.ops.header_selected_cells_bg
             if self.PAR.ops.header_selected_cells_bg.startswith("#")
             else color_map[self.PAR.ops.header_selected_cells_bg]
         )
-        c_3 = (
+        sel_cells_bg = (
             self.PAR.ops.header_selected_columns_bg
             if self.PAR.ops.header_selected_columns_bg.startswith("#")
             else color_map[self.PAR.ops.header_selected_columns_bg]
@@ -1482,7 +1480,13 @@ 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]
             fill, dd_drawn = self.redraw_highlight_get_text_fg(
-                cleftgridln, crightgridln, c, c_2, c_3, selections, datacn
+                fc=cleftgridln,
+                sc=crightgridln,
+                c=c,
+                sel_cells_bg=sel_cells_bg,
+                sel_cols_bg=sel_cols_bg,
+                selections=selections,
+                datacn=datacn,
             )
 
             if datacn in self.cell_options and "align" in self.cell_options[datacn]:
@@ -1500,7 +1504,7 @@ class ColumnHeaders(tk.Canvas):
                         0,
                         crightgridln,
                         self.current_height - 1,
-                        fill=fill,
+                        fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.header_grid_fg,
                         outline=fill,
                         tag="dd",
                         draw_outline=not dd_drawn,
@@ -1519,7 +1523,7 @@ class ColumnHeaders(tk.Canvas):
                         0,
                         crightgridln,
                         self.current_height - 1,
-                        fill=fill,
+                        fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.header_grid_fg,
                         outline=fill,
                         tag="dd",
                         draw_outline=not dd_drawn,
@@ -1539,7 +1543,7 @@ class ColumnHeaders(tk.Canvas):
                         0,
                         crightgridln,
                         self.current_height - 1,
-                        fill=fill,
+                        fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.header_grid_fg,
                         outline=fill,
                         tag="dd",
                         draw_outline=not dd_drawn,
@@ -1999,20 +2003,42 @@ class ColumnHeaders(tk.Canvas):
 
     def dropdown_text_editor_modified(
         self,
-        dd_window: object,
-        event: dict,
-        modified_func: Callable | None,
+        event: tk.Misc,
     ) -> None:
-        if modified_func:
-            modified_func(event)
-        dd_window.search_and_see(event)
+        c = self.dropdown.get_coords()
+        event_data = event_dict(
+            name="table_dropdown_modified",
+            sheet=self.PAR.name,
+            value=self.text_editor.get(),
+            loc=c,
+            row=0,
+            column=c,
+            boxes=self.MT.get_boxes(),
+            selected=self.MT.selected,
+        )
+        try_binding(self.dropdown.window.modified_function, event_data)
+        val = self.dropdown.window.search_and_see(event_data)
+        # return to tk.Text action if control/command is held down
+        # or keysym was not a character
+        if (hasattr(event, "state") and event.state & (0x0004 | 0x00000010)) or (
+            hasattr(event, "keysym") and len(event.keysym) > 2
+        ):
+            return
+        self.text_editor.tktext.unbind("<KeyRelease>")
+        self.text_editor.autocomplete(val)
+        self.text_editor.tktext.bind(
+            "<KeyRelease>",
+            self.dropdown_text_editor_modified,
+        )
+        return "break"
 
     def open_dropdown_window(self, c: int, event: object = None) -> None:
         self.hide_text_editor()
         kwargs = self.get_cell_kwargs(self.MT.datacn(c), key="dropdown")
-        if kwargs["state"] == "normal":
-            if not self.open_text_editor(event=event, c=c, dropdown=True):
-                return
+        if kwargs["state"] == "disabled":
+            return
+        if kwargs["state"] == "normal" and not self.open_text_editor(event=event, c=c, dropdown=True):
+            return
         win_h, anchor = self.get_dropdown_height_anchor(c)
         win_w = self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1
         ypos = self.current_height - 1
@@ -2026,6 +2052,8 @@ class ColumnHeaders(tk.Canvas):
             "outline_color": self.PAR.ops.header_selected_columns_bg,
             "align": self.get_cell_align(c),
             "values": kwargs["values"],
+            "search_function": kwargs["search_function"],
+            "modified_function": kwargs["modified_function"],
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
@@ -2038,7 +2066,6 @@ class ColumnHeaders(tk.Canvas):
                 **reset_kwargs,
                 single_index="c",
                 close_dropdown_window=self.close_dropdown_window,
-                search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.MT.arrowkey_RIGHT,
                 arrowkey_LEFT=self.MT.arrowkey_LEFT,
             )
@@ -2049,20 +2076,8 @@ class ColumnHeaders(tk.Canvas):
             )
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
-                "<<TextModified>>",
-                lambda _x: self.dropdown_text_editor_modified(
-                    self.dropdown.window,
-                    event_dict(
-                        name="header_dropdown_modified",
-                        sheet=self.PAR.name,
-                        value=self.text_editor.get(),
-                        loc=c,
-                        column=c,
-                        boxes=self.MT.get_boxes(),
-                        selected=self.MT.selected,
-                    ),
-                    kwargs["modified_function"],
-                ),
+                "<KeyRelease>",
+                self.dropdown_text_editor_modified,
             )
             self.update_idletasks()
             try:

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/functions.py

@@ -18,6 +18,7 @@ from collections.abc import (
 from itertools import islice, repeat
 from typing import Literal
 
+from .colors import color_map
 from .formatters import (
     to_bool,
 )
@@ -426,6 +427,20 @@ def is_contiguous(iterable: Iterator[int]) -> bool:
     return all(i == (prev := prev + 1) for i in itr)
 
 
+def box_is_single_cell(
+    r1: int,
+    c1: int,
+    r2: int,
+    c2: int,
+) -> bool:
+    return r2 - r1 == 1 and c2 - c1 == 1
+
+
+def color_tup(color: str) -> tuple[int, int, int]:
+    res = color if color.startswith("#") else color_map[color]
+    return int(res[1:3], 16), int(res[3:5], 16), int(res[5:], 16)
+
+
 def down_cell_within_box(
     r: int,
     c: int,

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/main_table.py

@@ -51,7 +51,9 @@ from .formatters import (
 from .functions import (
     add_to_displayed,
     b_index,
+    box_is_single_cell,
     cell_right_within_box,
+    color_tup,
     consecutive_ranges,
     diff_gen,
     diff_list,
@@ -72,9 +74,9 @@ from .functions import (
     mod_span_widget,
     move_elements_by_mapping,
     new_tk_event,
-    stored_event_dict,
     rounded_box_coords,
     span_idxs_post_move,
+    stored_event_dict,
     try_binding,
     unpickle_obj,
 )
@@ -2760,7 +2762,7 @@ class MainTable(tk.Canvas):
             self.rc_insert_row_enabled = True
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
-        if binding in ("all", "right_click_popup_menu", "rc_popup_menu"):
+        if binding in ("all", "right_click_popup_menu", "rc_popup_menu", "rc_menu"):
             self.rc_popup_menus_enabled = True
             self.rc_select_enabled = True
         if binding in ("all", "right_click_select", "rc_select"):
@@ -2823,7 +2825,7 @@ class MainTable(tk.Canvas):
             self.rc_insert_column_enabled = False
         if binding in bind_add_rows:
             self.rc_insert_row_enabled = False
-        if binding in ("all", "right_click_popup_menu", "rc_popup_menu"):
+        if binding in ("all", "right_click_popup_menu", "rc_popup_menu", "rc_menu"):
             self.rc_popup_menus_enabled = False
         if binding in ("all", "right_click_select", "rc_select"):
             self.rc_select_enabled = False
@@ -5157,69 +5159,82 @@ class MainTable(tk.Canvas):
         fr: int | float,
         sc: int | float,
         sr: int | float,
-        c_2_: tuple[int, int, int],
-        c_3_: tuple[int, int, int],
-        c_4_: tuple[int, int, int],
+        sel_cells_bg: tuple[int, int, int],
+        sel_cols_bg: tuple[int, int, int],
+        sel_rows_bg: tuple[int, int, int],
         selections: dict,
         datarn: int,
         datacn: int,
         can_width: int | None,
+        dont_blend: bool,
+        alternate_color: Highlight | None,
     ) -> str:
         redrawn = False
         if (datarn, datacn) in self.progress_bars:
             kwargs = self.progress_bars[(datarn, datacn)]
         else:
             kwargs = self.get_cell_kwargs(datarn, datacn, key="highlight")
-        if not kwargs and (self.PAR.ops.alternate_color and r % 2):
-            kwargs = Highlight(
-                bg=self.PAR.ops.alternate_color,
-                fg=None,
-                end=False,
-            )
+        if alt := bool(not kwargs and alternate_color and r % 2):
+            kwargs = alternate_color
+
         if kwargs:
-            if kwargs[0] is not None:
-                c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
-            if "cells" in selections and (r, c) in selections["cells"]:
-                tf = (
+            fill = kwargs[0]
+            if fill and not fill.startswith("#"):
+                fill = color_map[fill]
+
+            # cell is a single currently selected cell box
+            #         not highlighted
+            #         on an alternate row color
+            if alt and dont_blend:
+                txtfg = self.PAR.ops.table_fg
+
+            # cell is highlighted and cell selected
+            elif "cells" in selections and (r, c) in selections["cells"]:
+                txtfg = (
                     self.PAR.ops.table_selected_cells_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + c_2_[0]) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + c_2_[1]) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + c_2_[2]) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + sel_cells_bg[0]) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + sel_cells_bg[1]) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + sel_cells_bg[2]) / 2):02X}"
                     )
+
+            # cell is highlighted and row selected
             elif "rows" in selections and r in selections["rows"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.table_selected_rows_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + c_4_[0]) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + c_4_[1]) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + c_4_[2]) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + sel_rows_bg[0]) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + sel_rows_bg[1]) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + sel_rows_bg[2]) / 2):02X}"
                     )
+
+            # cell is highlighted and column selected
             elif "columns" in selections and c in selections["columns"]:
-                tf = (
+                txtfg = (
                     self.PAR.ops.table_selected_columns_fg
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + c_3_[0]) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + c_3_[1]) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + c_3_[2]) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + sel_cols_bg[0]) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + sel_cols_bg[1]) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + sel_cols_bg[2]) / 2):02X}"
                     )
+
+            # cell is just highlighted
             else:
-                tf = self.PAR.ops.table_fg if kwargs[1] is None else kwargs[1]
-                if kwargs[0] is not None:
-                    fill = kwargs[0]
-            if kwargs[0] is not None:
+                txtfg = self.PAR.ops.table_fg if kwargs[1] is None else kwargs[1]
+
+            if fill:
                 highlight_fn = partial(
                     self.redraw_highlight,
                     x1=fc + 1,
@@ -5249,14 +5264,14 @@ class MainTable(tk.Canvas):
                     )
         elif not kwargs:
             if "cells" in selections and (r, c) in selections["cells"]:
-                tf = self.PAR.ops.table_selected_cells_fg
+                txtfg = self.PAR.ops.table_selected_cells_fg
             elif "rows" in selections and r in selections["rows"]:
-                tf = self.PAR.ops.table_selected_rows_fg
+                txtfg = self.PAR.ops.table_selected_rows_fg
             elif "columns" in selections and c in selections["columns"]:
-                tf = self.PAR.ops.table_selected_columns_fg
+                txtfg = self.PAR.ops.table_selected_columns_fg
             else:
-                tf = self.PAR.ops.table_fg
-        return tf, redrawn
+                txtfg = self.PAR.ops.table_fg
+        return txtfg, redrawn
 
     def redraw_highlight(self, x1, y1, x2, y2, fill, outline, tag, can_width=None, pc=None):
         if not is_type_int(pc) or pc >= 100:
@@ -5638,24 +5653,36 @@ class MainTable(tk.Canvas):
                 )
         if redraw_table:
             selections = self.get_redraw_selections(text_start_row, grid_end_row, text_start_col, grid_end_col)
-            c_2 = (
-                self.PAR.ops.table_selected_cells_bg
-                if self.PAR.ops.table_selected_cells_bg.startswith("#")
-                else color_map[self.PAR.ops.table_selected_cells_bg]
-            )
-            c_2_ = (int(c_2[1:3], 16), int(c_2[3:5], 16), int(c_2[5:], 16))
-            c_3 = (
-                self.PAR.ops.table_selected_columns_bg
-                if self.PAR.ops.table_selected_columns_bg.startswith("#")
-                else color_map[self.PAR.ops.table_selected_columns_bg]
-            )
-            c_3_ = (int(c_3[1:3], 16), int(c_3[3:5], 16), int(c_3[5:], 16))
-            c_4 = (
-                self.PAR.ops.table_selected_rows_bg
-                if self.PAR.ops.table_selected_rows_bg.startswith("#")
-                else color_map[self.PAR.ops.table_selected_rows_bg]
-            )
-            c_4_ = (int(c_4[1:3], 16), int(c_4[3:5], 16), int(c_4[5:], 16))
+            sel_cells_bg = color_tup(self.PAR.ops.table_selected_cells_bg)
+            sel_cols_bg = color_tup(self.PAR.ops.table_selected_columns_bg)
+            sel_rows_bg = color_tup(self.PAR.ops.table_selected_rows_bg)
+            if self.selected:
+                current_loc = (self.selected.row, self.selected.column)
+            else:
+                current_loc = tuple()
+            if self.PAR.ops.alternate_color:
+                alternate_color = Highlight(
+                    bg=self.PAR.ops.alternate_color,
+                    fg=None,
+                    end=False,
+                )
+                if self.selected and box_is_single_cell(*self.selected.box) and self.PAR.ops.show_selected_cells_border:
+                    dont_blend = current_loc
+                else:
+                    dont_blend = tuple()
+            else:
+                alternate_color = None
+                dont_blend = tuple()
+
+            if not self.PAR.ops.show_selected_cells_border:
+                override = (
+                    color_tup(self.PAR.ops.table_selected_cells_fg),
+                    color_tup(self.PAR.ops.table_selected_columns_fg),
+                    color_tup(self.PAR.ops.table_selected_rows_fg),
+                    )
+            else:
+                override = tuple()
+
             rows_ = tuple(range(text_start_row, text_end_row))
             font = self.PAR.ops.table_font
             dd_coords = self.dropdown.get_coords()
@@ -5672,19 +5699,21 @@ class MainTable(tk.Canvas):
                     datacn = self.datacn(c)
 
                     fill, dd_drawn = self.redraw_highlight_get_text_fg(
-                        r,
-                        c,
-                        cleftgridln,
-                        rtopgridln,
-                        crightgridln,
-                        rbotgridln,
-                        c_2_,
-                        c_3_,
-                        c_4_,
-                        selections,
-                        datarn,
-                        datacn,
-                        can_width,
+                        r=r,
+                        c=c,
+                        fc=cleftgridln,
+                        fr=rtopgridln,
+                        sc=crightgridln,
+                        sr=rbotgridln,
+                        sel_cells_bg=override[0] if override and (r, c) == current_loc else sel_cells_bg,
+                        sel_cols_bg=override[1] if override and (r, c) == current_loc else sel_cols_bg,
+                        sel_rows_bg=override[2] if override and (r, c) == current_loc else sel_rows_bg,
+                        selections=selections,
+                        datarn=datarn,
+                        datacn=datacn,
+                        can_width=can_width,
+                        dont_blend=(r, c) == dont_blend,
+                        alternate_color=alternate_color,
                     )
                     align = self.get_cell_kwargs(datarn, datacn, key="align")
                     if align:
@@ -5701,7 +5730,7 @@ class MainTable(tk.Canvas):
                                 rtopgridln,
                                 crightgridln,
                                 self.row_positions[r + 1],
-                                fill=fill,
+                                fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
                                 outline=fill,
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
@@ -5719,7 +5748,7 @@ class MainTable(tk.Canvas):
                                 rtopgridln,
                                 crightgridln,
                                 self.row_positions[r + 1],
-                                fill=fill,
+                                fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
                                 outline=fill,
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
@@ -5738,7 +5767,7 @@ class MainTable(tk.Canvas):
                                 rtopgridln,
                                 crightgridln,
                                 self.row_positions[r + 1],
-                                fill=fill,
+                                fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.table_grid_fg,
                                 outline=fill,
                                 tag=f"dd_{r}_{c}",
                                 draw_outline=not dd_drawn,
@@ -6904,6 +6933,8 @@ class MainTable(tk.Canvas):
                         new_r, new_c = down_cell_within_box(r, c, r1, c1, r2, c2, numrows, numcols)
                     else:
                         new_r, new_c = None, None
+                else:
+                    new_r, new_c = None, None
                 if isinstance(new_r, int):
                     self.set_currently_selected(new_r, new_c, item=self.selected.fill_iid)
                     self.see(
@@ -6958,6 +6989,8 @@ class MainTable(tk.Canvas):
             bottom_right_corner=True,
             check_cell_visibility=True,
         )
+        if not self.PAR.ops.show_selected_cells_border:
+            self.refresh()
         return "break"
 
     def get_space_bot(self, r: int, text_editor_h: int | None = None) -> int:
@@ -7015,13 +7048,34 @@ class MainTable(tk.Canvas):
 
     def dropdown_text_editor_modified(
         self,
-        dd_window: object,
-        event: dict,
-        modified_func: Callable | None,
+        event: tk.Misc,
     ) -> None:
-        if modified_func:
-            modified_func(event)
-        dd_window.search_and_see(event)
+        r, c = self.dropdown.get_coords()
+        event_data = event_dict(
+            name="table_dropdown_modified",
+            sheet=self.PAR.name,
+            value=self.text_editor.get(),
+            loc=Loc(r, c),
+            row=r,
+            column=c,
+            boxes=self.get_boxes(),
+            selected=self.selected,
+        )
+        try_binding(self.dropdown.window.modified_function, event_data)
+        val = self.dropdown.window.search_and_see(event_data)
+        # return to tk.Text action if control/command is held down
+        # or keysym was not a character
+        if (hasattr(event, "state") and event.state & (0x0004 | 0x00000010)) or (
+            hasattr(event, "keysym") and len(event.keysym) > 2
+        ):
+            return
+        self.text_editor.tktext.unbind("<KeyRelease>")
+        self.text_editor.autocomplete(val)
+        self.text_editor.tktext.bind(
+            "<KeyRelease>",
+            self.dropdown_text_editor_modified,
+        )
+        return "break"
 
     # c is displayed col
     def open_dropdown_window(
@@ -7034,9 +7088,10 @@ class MainTable(tk.Canvas):
         datarn = self.datarn(r)
         datacn = self.datacn(c)
         kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
-        if kwargs["state"] == "normal":
-            if not self.open_text_editor(event=event, r=r, c=c, dropdown=True):
-                return
+        if kwargs["state"] == "disabled":
+            return
+        if kwargs["state"] == "normal" and not self.open_text_editor(event=event, r=r, c=c, dropdown=True):
+            return
         win_h, anchor = self.get_dropdown_height_anchor(r, c)
         win_w = self.col_positions[c + 1] - self.col_positions[c] + 1
         if anchor == "nw":
@@ -7057,6 +7112,8 @@ class MainTable(tk.Canvas):
             "outline_color": self.get_selected_box_bg_fg(type_="cells")[1],
             "align": self.get_cell_align(r, c),
             "values": kwargs["values"],
+            "search_function": kwargs["search_function"],
+            "modified_function": kwargs["modified_function"],
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
@@ -7068,7 +7125,6 @@ class MainTable(tk.Canvas):
                 self.winfo_toplevel(),
                 **reset_kwargs,
                 close_dropdown_window=self.close_dropdown_window,
-                search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.arrowkey_RIGHT,
                 arrowkey_LEFT=self.arrowkey_LEFT,
             )
@@ -7079,22 +7135,9 @@ class MainTable(tk.Canvas):
             )
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
-                "<<TextModified>>",
-                lambda _: self.dropdown.window.search_and_see(
-                    event_dict(
-                        name="table_dropdown_modified",
-                        sheet=self.PAR.name,
-                        value=self.text_editor.get(),
-                        loc=Loc(r, c),
-                        row=r,
-                        column=c,
-                        boxes=self.get_boxes(),
-                        selected=self.selected,
-                    )
-                ),
+                "<KeyRelease>",
+                self.dropdown_text_editor_modified,
             )
-            if kwargs["modified_function"] is not None:
-                self.dropdown.window.modified_function = kwargs["modified_function"]
             self.update_idletasks()
             try:
                 self.after(1, lambda: self.text_editor.tktext.focus())

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/other_classes.py

@@ -489,6 +489,25 @@ class TextEditorStorage:
         if self.window:
             return self.window.get()
         return ""
+    
+    def set(self, value: str) -> None:
+        if not self.window:
+            return
+        self.window.set_text(value)
+        
+    def highlight_from(self, r: int | str, c: int | str) -> None:
+        index = self.window.tktext.index(f"{r}.{c}")
+        self.window.tktext.tag_add('sel', index, 'end')
+        self.window.tktext.mark_set('insert', f"{r}.{c}")
+        
+    def autocomplete(self, value: str | None) -> None:
+        current_val = self.get()
+        if not value or len(current_val) >= len(value) or current_val != value[:len(current_val)]:
+            return
+        cursor_pos = self.tktext.index('insert')
+        line, column = cursor_pos.split('.')
+        self.window.set_text(value)
+        self.highlight_from(line, column)
 
     @property
     def tktext(self) -> object:

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/row_index.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import tkinter as tk
 from collections import defaultdict
 from collections.abc import (
-    Callable,
     Generator,
     Hashable,
     Iterator,
@@ -1222,27 +1221,28 @@ class RowIndex(tk.Canvas):
         fr: float,
         sr: float,
         r: int,
-        c_2: str,
-        c_3: str,
+        sel_cells_bg: str,
+        sel_rows_bg: str,
         selections: dict,
         datarn: int,
     ) -> tuple[str, str, bool]:
         redrawn = False
         kwargs = self.get_cell_kwargs(datarn, key="highlight")
         if kwargs:
-            if kwargs[0] is not None:
-                c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
+            fill = kwargs[0]
+            if fill and not fill.startswith("#"):
+                fill = color_map[fill]
             if "rows" in selections and r in selections["rows"]:
                 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]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + int(c_3[1:3], 16)) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + int(c_3[3:5], 16)) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + int(c_3[5:], 16)) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + int(sel_rows_bg[1:3], 16)) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + int(sel_rows_bg[3:5], 16)) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + int(sel_rows_bg[5:], 16)) / 2):02X}"
                     )
             elif "cells" in selections and r in selections["cells"]:
                 txtfg = (
@@ -1250,17 +1250,15 @@ class RowIndex(tk.Canvas):
                     if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
-                if kwargs[0] is not None:
+                if fill:
                     fill = (
-                        f"#{int((int(c_1[1:3], 16) + int(c_2[1:3], 16)) / 2):02X}"
-                        + f"{int((int(c_1[3:5], 16) + int(c_2[3:5], 16)) / 2):02X}"
-                        + f"{int((int(c_1[5:], 16) + int(c_2[5:], 16)) / 2):02X}"
+                        f"#{int((int(fill[1:3], 16) + int(sel_cells_bg[1:3], 16)) / 2):02X}"
+                        + f"{int((int(fill[3:5], 16) + int(sel_cells_bg[3:5], 16)) / 2):02X}"
+                        + f"{int((int(fill[5:], 16) + int(sel_cells_bg[5:], 16)) / 2):02X}"
                     )
             else:
                 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:
+            if fill:
                 redrawn = self.redraw_highlight(
                     0,
                     fr + 1,
@@ -1592,12 +1590,12 @@ class RowIndex(tk.Canvas):
                     )
                 )
             self.redraw_gridline(points=points, fill=self.PAR.ops.index_grid_fg, width=1, tag="h")
-        c_2 = (
+        sel_cells_bg = (
             self.PAR.ops.index_selected_cells_bg
             if self.PAR.ops.index_selected_cells_bg.startswith("#")
             else color_map[self.PAR.ops.index_selected_cells_bg]
         )
-        c_3 = (
+        sel_rows_bg = (
             self.PAR.ops.index_selected_rows_bg
             if self.PAR.ops.index_selected_rows_bg.startswith("#")
             else color_map[self.PAR.ops.index_selected_rows_bg]
@@ -1614,13 +1612,13 @@ class RowIndex(tk.Canvas):
                 continue
             datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
             fill, tree_arrow_fg, dd_drawn = self.redraw_highlight_get_text_fg(
-                rtopgridln,
-                rbotgridln,
-                r,
-                c_2,
-                c_3,
-                selections,
-                datarn,
+                fr=rtopgridln,
+                sr=rbotgridln,
+                r=r,
+                sel_cells_bg=sel_cells_bg,
+                sel_rows_bg=sel_rows_bg,
+                selections=selections,
+                datarn=datarn,
             )
 
             if datarn in self.cell_options and "align" in self.cell_options[datarn]:
@@ -1637,7 +1635,7 @@ class RowIndex(tk.Canvas):
                         rtopgridln,
                         self.current_width - 1,
                         rbotgridln - 1,
-                        fill=fill,
+                        fill=fill if dropdown_kwargs["state"] != "disabled" else self.PAR.ops.index_grid_fg,
                         outline=fill,
                         tag="dd",
                         draw_outline=not dd_drawn,
@@ -1656,7 +1654,7 @@ class RowIndex(tk.Canvas):
                         rtopgridln,
                         self.current_width - 1,
                         rbotgridln - 1,
-                        fill=fill,
+                        fill=fill if dropdown_kwargs["state"] != "disabled" else self.PAR.ops.index_grid_fg,
                         outline=fill,
                         tag="dd",
                         draw_outline=not dd_drawn,
@@ -1676,7 +1674,7 @@ class RowIndex(tk.Canvas):
                         rtopgridln,
                         self.current_width - 1,
                         rbotgridln - 1,
-                        fill=fill,
+                        fill=fill if dropdown_kwargs["state"] != "disabled" else self.PAR.ops.index_grid_fg,
                         outline=fill,
                         tag="dd",
                         draw_outline=not dd_drawn,
@@ -2148,21 +2146,43 @@ class RowIndex(tk.Canvas):
 
     def dropdown_text_editor_modified(
         self,
-        dd_window: object,
-        event: dict,
-        modified_func: Callable | None,
+        event: tk.Misc,
     ) -> None:
-        if modified_func:
-            modified_func(event)
-        dd_window.search_and_see(event)
+        r = self.dropdown.get_coords()
+        event_data = event_dict(
+            name="table_dropdown_modified",
+            sheet=self.PAR.name,
+            value=self.text_editor.get(),
+            loc=r,
+            row=r,
+            column=0,
+            boxes=self.MT.get_boxes(),
+            selected=self.MT.selected,
+        )
+        try_binding(self.dropdown.window.modified_function, event_data)
+        val = self.dropdown.window.search_and_see(event_data)
+        # return to tk.Text action if control/command is held down
+        # or keysym was not a character
+        if (hasattr(event, "state") and event.state & (0x0004 | 0x00000010)) or (
+            hasattr(event, "keysym") and len(event.keysym) > 2
+        ):
+            return
+        self.text_editor.tktext.unbind("<KeyRelease>")
+        self.text_editor.autocomplete(val)
+        self.text_editor.tktext.bind(
+            "<KeyRelease>",
+            self.dropdown_text_editor_modified,
+        )
+        return "break"
 
     # r is displayed row
     def open_dropdown_window(self, r: int, event: object = None) -> None:
         self.hide_text_editor()
         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
+        if kwargs["state"] == "disabled":
+            return
+        if kwargs["state"] == "normal" and not self.open_text_editor(event=event, r=r, dropdown=True):
+            return
         win_h, anchor = self.get_dropdown_height_anchor(r)
         win_w = self.current_width + 1
         if anchor == "nw":
@@ -2183,6 +2203,8 @@ class RowIndex(tk.Canvas):
             "outline_color": self.PAR.ops.index_selected_rows_bg,
             "align": self.get_cell_align(r),
             "values": kwargs["values"],
+            "search_function": kwargs["search_function"],
+            "modified_function": kwargs["modified_function"],
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
@@ -2195,7 +2217,6 @@ class RowIndex(tk.Canvas):
                 **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,
             )
@@ -2206,20 +2227,8 @@ class RowIndex(tk.Canvas):
             )
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
-                "<<TextModified>>",
-                lambda _x: self.dropdown_text_editor_modified(
-                    self.dropdown.window,
-                    event_dict(
-                        name="index_dropdown_modified",
-                        sheet=self.PAR.name,
-                        value=self.text_editor.get(),
-                        loc=r,
-                        row=r,
-                        boxes=self.MT.get_boxes(),
-                        selected=self.MT.selected,
-                    ),
-                    kwargs["modified_function"],
-                ),
+                "<KeyRelease>",
+                self.dropdown_text_editor_modified,
             )
             self.update_idletasks()
             try:

{tksheet-7.2.21 → tksheet-7.2.22}/tksheet/sheet.py

@@ -607,6 +607,46 @@ class Sheet(tk.Frame):
     # Bindings and Functionality
 
     def enable_bindings(self, *bindings: str) -> Sheet:
+        """
+        List of available bindings:
+        - "all"
+        - "single_select"
+        - "toggle_select"
+        - "drag_select"
+        - "select_all"
+        - "column_drag_and_drop" / "move_columns"
+        - "row_drag_and_drop" / "move_rows"
+        - "column_select"
+        - "row_select"
+        - "column_width_resize"
+        - "double_click_column_resize"
+        - "row_width_resize"
+        - "column_height_resize"
+        - "arrowkeys" # all arrowkeys including page up and down
+        - "up"
+        - "down"
+        - "left"
+        - "right"
+        - "prior" # page up
+        - "next" # page down
+        - "row_height_resize"
+        - "double_click_row_resize"
+        - "right_click_popup_menu" / "rc_popup_menu" / "rc_menu"
+        - "rc_select"
+        - "rc_insert_column"
+        - "rc_delete_column"
+        - "rc_insert_row"
+        - "rc_delete_row"
+        - "ctrl_click_select" / "ctrl_select"
+        - "copy"
+        - "cut"
+        - "paste"
+        - "delete"
+        - "undo"
+        - "edit_cell"
+        - "edit_header"
+        - "edit_index"
+        """
         self.MT.enable_bindings(bindings)
         return self
 
@@ -619,6 +659,57 @@ class Sheet(tk.Frame):
         bindings: str | list | tuple | None = None,
         func: Callable | None = None,
     ) -> Sheet:
+        """
+        List of available bindings:
+        - "begin_copy", "begin_ctrl_c"
+        - "ctrl_c", "end_copy", "end_ctrl_c", "copy"
+        - "begin_cut", "begin_ctrl_x"
+        - "ctrl_x", "end_cut", "end_ctrl_x", "cut"
+        - "begin_paste", "begin_ctrl_v"
+        - "ctrl_v", "end_paste", "end_ctrl_v", "paste"
+        - "begin_undo", "begin_ctrl_z"
+        - "ctrl_z", "end_undo", "end_ctrl_z", "undo"
+        - "begin_delete_key", "begin_delete"
+        - "delete_key", "end_delete", "end_delete_key", "delete"
+        - "begin_edit_cell", "begin_edit_table"
+        - "end_edit_cell", "edit_cell", "edit_table"
+        - "begin_edit_header"
+        - "end_edit_header", "edit_header"
+        - "begin_edit_index"
+        - "end_edit_index", "edit_index"
+        - "begin_row_index_drag_drop", "begin_move_rows"
+        - "row_index_drag_drop", "move_rows", "end_move_rows", "end_row_index_drag_drop"
+        - "begin_column_header_drag_drop", "begin_move_columns"
+        - "column_header_drag_drop", "move_columns", "end_move_columns", "end_column_header_drag_drop"
+        - "begin_rc_delete_row", "begin_delete_rows"
+        - "rc_delete_row", "end_rc_delete_row", "end_delete_rows", "delete_rows"
+        - "begin_rc_delete_column", "begin_delete_columns"
+        - "rc_delete_column", "end_rc_delete_column","end_delete_columns", "delete_columns"
+        - "begin_rc_insert_column", "begin_insert_column", "begin_insert_columns", "begin_add_column","begin_rc_add_column", "begin_add_columns"
+        - "rc_insert_column", "end_rc_insert_column", "end_insert_column", "end_insert_columns", "rc_add_column", "end_rc_add_column", "end_add_column", "end_add_columns"
+        - "begin_rc_insert_row", "begin_insert_row", "begin_insert_rows", "begin_rc_add_row", "begin_add_row", "begin_add_rows"
+        - "rc_insert_row", "end_rc_insert_row", "end_insert_row", "end_insert_rows", "rc_add_row", "end_rc_add_row", "end_add_row", "end_add_rows"
+        - "row_height_resize"
+        - "column_width_resize"
+        - "cell_select"
+        - "select_all"
+        - "row_select"
+        - "column_select"
+        - "drag_select_cells"
+        - "drag_select_rows"
+        - "drag_select_columns"
+        - "shift_cell_select"
+        - "shift_row_select"
+        - "shift_column_select"
+        - "ctrl_cell_select"
+        - "ctrl_row_select"
+        - "ctrl_column_select"
+        - "deselect"
+        - "all_select_events", "select", "selectevents", "select_events"
+        - "all_modified_events", "sheetmodified", "sheet_modified" "modified_events", "modified"
+        - "bind_all"
+        - "unbind_all"
+        """
         # bindings is None, unbind all
         if bindings is None:
             bindings = "all"
@@ -2564,7 +2655,7 @@ class Sheet(tk.Frame):
         edit_data: bool = True,
         set_values: dict[tuple[int, int], object] = {},
         set_value: object = None,
-        state: str = "normal",
+        state: Literal["normal", "readonly", "disabled"] = "normal",
         redraw: bool = True,
         selection_function: Callable | None = None,
         modified_function: Callable | None = None,
@@ -2675,7 +2766,7 @@ class Sheet(tk.Frame):
         *key: CreateSpanTypes,
         edit_data: bool = True,
         checked: bool | None = None,
-        state: str = "normal",
+        state: Literal["normal", "disabled"] = "normal",
         redraw: bool = True,
         check_function: Callable | None = None,
         text: str = "",
@@ -5477,7 +5568,7 @@ class Sheet(tk.Frame):
     def selection_add(self, *items, run_binding: bool = True, redraw: bool = True) -> Sheet:
         to_open = []
         quick_displayed_check = set(self.MT.displayed_rows)
-        for item in unpack(items):
+        for item in filter(self.RI.tree.__contains__, unpack(items)):
             if self.RI.tree_rns[item] not in quick_displayed_check and self.RI.tree[item].parent:
                 to_open.extend(list(self.RI.get_iid_ancestors(item)))
         if to_open:
@@ -5492,7 +5583,7 @@ class Sheet(tk.Frame):
                     self.MT.displayed_rows,
                     self.RI.tree_rns[item],
                 )
-                for item in unpack(items)
+                for item in filter(self.RI.tree.__contains__, unpack(items))
             )
         ):
             self.MT.create_selection_box(
@@ -7067,6 +7158,7 @@ class Dropdown(Sheet):
         values: list[object] = [],
         close_dropdown_window: Callable | None = None,
         search_function: Callable = dropdown_search_function,
+        modified_function: None | Callable = None,
         arrowkey_RIGHT: Callable | None = None,
         arrowkey_LEFT: Callable | None = None,
         align: str = "w",
@@ -7096,6 +7188,7 @@ class Dropdown(Sheet):
         self.parent = parent
         self.close_dropdown_window = close_dropdown_window
         self.search_function = search_function
+        self.modified_function = modified_function
         self.arrowkey_RIGHT = arrowkey_RIGHT
         self.arrowkey_LEFT = arrowkey_LEFT
         self.single_index = single_index
@@ -7122,11 +7215,15 @@ class Dropdown(Sheet):
         outline_color: str,
         align: str,
         values: list[object] | None = None,
+        search_function: Callable = dropdown_search_function,
+        modified_function: None | Callable = None,
     ) -> None:
         self.deselect(redraw=False)
         self.r = r
         self.c = c
         self.row = -1
+        self.search_function = search_function
+        self.modified_function = modified_function
         self.height_and_width(height=height, width=width)
         self.table_align(align)
         self.set_options(
@@ -7160,13 +7257,14 @@ class Dropdown(Sheet):
         self.see(self.row, 0, redraw=False)
         self.select_row(self.row)
 
-    def search_and_see(self, event: object = None) -> None:
+    def search_and_see(self, event: object = None) -> str:
         if self.search_function is not None:
             rn = self.search_function(search_for=rf"{event['value']}".lower(), data=self.MT.data)
-            if rn is not None:
+            if isinstance(rn, int):
                 self.row = rn
                 self.see(self.row, 0, redraw=False)
                 self.select_row(self.row)
+                return self.MT.data[rn][0]
 
     def mouse_motion(self, event: object) -> None:
         row = self.identify_row(event, exclude_index=True, allow_end=False)

{tksheet-7.2.21 → tksheet-7.2.22/tksheet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.21
+Version: 7.2.22
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -46,7 +46,7 @@ License-File: LICENSE.txt
 
 # <div align="center">tksheet - python tkinter table widget</div>
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12|3.13-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![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/)