tksheet 7.2.22__py3-none-any.whl → 7.2.23__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -804,19 +804,17 @@ class ColumnHeaders(tk.Canvas):
             )
 
     def b1_release(self, event: object) -> None:
+        to_hide = self.being_drawn_item
         if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
-            self.MT.hide_selection_box(self.being_drawn_item)
+            self.being_drawn_item = None
             self.MT.set_currently_selected(
                 r_to_sel,
                 c_to_sel,
                 item=self.MT.create_selection_box(*to_sel, set_current=False),
+                run_binding=False,
             )
-            sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
-            try_binding(self.drag_selection_binding_func, sel_event)
-            self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
-        else:
-            self.being_drawn_item = None
+        self.MT.hide_selection_box(to_hide)
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             self.drag_width_resize()
@@ -1772,7 +1770,6 @@ class ColumnHeaders(tk.Canvas):
         h = self.current_height + 1
         if text is None:
             text = self.get_cell_data(self.MT.datacn(c), none_to_empty_str=True, redirect_int=True)
-        bg, fg = self.PAR.ops.header_bg, self.PAR.ops.header_fg
         kwargs = {
             "menu_kwargs": DotDict(
                 {
@@ -1790,8 +1787,10 @@ class ColumnHeaders(tk.Canvas):
             "width": w,
             "height": h,
             "show_border": True,
-            "bg": bg,
-            "fg": fg,
+            "bg": self.PAR.ops.header_editor_bg,
+            "fg": self.PAR.ops.header_editor_fg,
+            "select_bg": self.PAR.ops.header_editor_select_bg,
+            "select_fg": self.PAR.ops.header_editor_select_fg,
             "align": self.get_cell_align(c),
             "c": c,
         }
@@ -2017,19 +2016,13 @@ class ColumnHeaders(tk.Canvas):
             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
+            hasattr(event, "keysym") and len(event.keysym) > 2 and event.keysym != "space"
         ):
             return
-        self.text_editor.tktext.unbind("<KeyRelease>")
-        self.text_editor.autocomplete(val)
-        self.text_editor.tktext.bind(
-            "<KeyRelease>",
-            self.dropdown_text_editor_modified,
-        )
+        self.text_editor.autocomplete(self.dropdown.window.search_and_see(event_data))
         return "break"
 
     def open_dropdown_window(self, c: int, event: object = None) -> None:
@@ -2045,6 +2038,10 @@ class ColumnHeaders(tk.Canvas):
         reset_kwargs = {
             "r": 0,
             "c": c,
+            "bg": self.PAR.ops.header_editor_bg,
+            "fg": self.PAR.ops.header_editor_fg,
+            "select_bg": self.PAR.ops.header_editor_select_bg,
+            "select_fg": self.PAR.ops.header_editor_select_fg,
             "width": win_w,
             "height": win_h,
             "font": self.PAR.ops.header_font,
@@ -2074,12 +2071,12 @@ class ColumnHeaders(tk.Canvas):
                 window=self.dropdown.window,
                 anchor=anchor,
             )
+        self.update_idletasks()
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
                 "<KeyRelease>",
                 self.dropdown_text_editor_modified,
             )
-            self.update_idletasks()
             try:
                 self.after(1, lambda: self.text_editor.tktext.focus())
                 self.after(2, self.text_editor.window.scroll_to_bottom())
@@ -2087,7 +2084,6 @@ class ColumnHeaders(tk.Canvas):
                 return
             redraw = False
         else:
-            self.update_idletasks()
             self.dropdown.window.bind("<FocusOut>", lambda _x: self.close_dropdown_window(c))
             self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
             self.dropdown.window.focus_set()

tksheet/functions.py

@@ -1415,12 +1415,24 @@ def mod_span_widget(span: Span, widget: object) -> Span:
 def mod_event_val(
     event_data: EventDataDict,
     val: object,
-    loc: Loc | int,
+    loc: Loc | None = None,
+    row: int | None = None,
+    column: int | None = None,
 ) -> EventDataDict:
     event_data.value = val
-    event_data.loc = Loc(*loc)
-    event_data.row = loc[0]
-    event_data.column = loc[1]
+    if isinstance(loc, tuple):
+        event_data.loc = Loc(*loc)
+        event_data.row = loc[0]
+        event_data.column = loc[1]
+
+    elif isinstance(row, int):
+        event_data.loc = Loc(row=row)
+        event_data.row = row
+
+    elif isinstance(column, int):
+        event_data.loc = Loc(column=column)
+        event_data.column = column
+
     return event_data
 
 

tksheet/main_table.py

@@ -1514,25 +1514,49 @@ class MainTable(tk.Canvas):
             self.purge_redo_stack()
 
     def edit_cells_using_modification(self, modification: dict, event_data: dict) -> EventDataDict:
+        # row index
         if self.PAR.ops.treeview:
             for datarn, v in modification["cells"]["index"].items():
-                self._row_index[datarn].text = v
+                if not self.edit_validation_func or (
+                    self.edit_validation_func
+                    and (v := self.edit_validation_func(mod_event_val(event_data, v, row=datarn))) is not None
+                ):
+                    self._row_index[datarn].text = v
         else:
             for datarn, v in modification["cells"]["index"].items():
-                self._row_index[datarn] = v
+                if not self.edit_validation_func or (
+                    self.edit_validation_func
+                    and (v := self.edit_validation_func(mod_event_val(event_data, v, row=datarn))) is not None
+                ):
+                    self._row_index[datarn] = v
+
+        # header
         for datacn, v in modification["cells"]["header"].items():
-            self._headers[datacn] = v
-        for (datarn, datacn), v in modification["cells"]["table"].items():
-            self.set_cell_data(datarn, datacn, v)
+            if not self.edit_validation_func or (
+                self.edit_validation_func
+                and (v := self.edit_validation_func(mod_event_val(event_data, v, column=datacn))) is not None
+            ):
+                self._headers[datacn] = v
+
+        # table
+        for k, v in modification["cells"]["table"].items():
+            if not self.edit_validation_func or (
+                self.edit_validation_func
+                and (v := self.edit_validation_func(mod_event_val(event_data, v, loc=k))) is not None
+            ):
+                self.set_cell_data(k[0], k[1], v)
+
         return event_data
 
     def save_cells_using_modification(self, modification: EventDataDict, event_data: EventDataDict) -> EventDataDict:
-        for datarn, v in modification["cells"]["index"].items():
+        for datarn in modification["cells"]["index"]:
             event_data["cells"]["index"][datarn] = self.RI.get_cell_data(datarn)
-        for datacn, v in modification["cells"]["header"].items():
+
+        for datacn in modification["cells"]["header"]:
             event_data["cells"]["header"][datacn] = self.CH.get_cell_data(datacn)
-        for (datarn, datacn), v in modification["cells"]["table"].items():
-            event_data["cells"]["table"][(datarn, datacn)] = self.get_cell_data(datarn, datacn)
+
+        for k in modification["cells"]["table"]:
+            event_data["cells"]["table"][k] = self.get_cell_data(k[0], k[1])
         return event_data
 
     def restore_options_named_spans(self, modification: EventDataDict) -> None:
@@ -3167,9 +3191,10 @@ class MainTable(tk.Canvas):
             self.b1_motion(event)
 
     def b1_release(self, event=None):
+        to_hide = self.being_drawn_item
         if self.being_drawn_item is not None and (to_sel := self.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.selected.row, self.selected.column
-            self.hide_selection_box(self.being_drawn_item)
+            self.being_drawn_item = None
             self.set_currently_selected(
                 r_to_sel,
                 c_to_sel,
@@ -3182,12 +3207,9 @@ class MainTable(tk.Canvas):
                     ),
                     set_current=False,
                 ),
+                run_binding=False,
             )
-            sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-            try_binding(self.drag_selection_binding_func, sel_event)
-            self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
-        else:
-            self.being_drawn_item = None
+        self.hide_selection_box(to_hide)
         if self.RI.width_resizing_enabled and self.RI.rsz_w is not None and self.RI.currently_resizing_width:
             self.delete_resize_lines()
             self.RI.delete_resize_lines()
@@ -5679,7 +5701,7 @@ class MainTable(tk.Canvas):
                     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()
 
@@ -6136,7 +6158,7 @@ class MainTable(tk.Canvas):
             self.itemconfig(item, state="hidden")
 
     def hide_selection_box(self, item: int | None) -> bool:
-        if item is None or item is True:
+        if item is None or item is True or item not in self.selection_boxes:
             return
         box = self.selection_boxes.pop(item)
         self.hide_box(box.fill_iid)
@@ -6710,7 +6732,6 @@ class MainTable(tk.Canvas):
         h = self.row_positions[r + 1] - y + 1
         if text is None:
             text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
-        bg, fg = self.PAR.ops.table_bg, self.PAR.ops.table_fg
         kwargs = {
             "menu_kwargs": DotDict(
                 {
@@ -6728,8 +6749,10 @@ class MainTable(tk.Canvas):
             "width": w,
             "height": h,
             "show_border": True,
-            "bg": bg,
-            "fg": fg,
+            "bg": self.PAR.ops.table_editor_bg,
+            "fg": self.PAR.ops.table_editor_fg,
+            "select_bg": self.PAR.ops.table_editor_select_bg,
+            "select_fg": self.PAR.ops.table_editor_select_fg,
             "align": self.get_cell_align(r, c),
             "r": r,
             "c": c,
@@ -7062,22 +7085,15 @@ class MainTable(tk.Canvas):
             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
+            hasattr(event, "keysym") and len(event.keysym) > 2 and event.keysym != "space"
         ):
             return
-        self.text_editor.tktext.unbind("<KeyRelease>")
-        self.text_editor.autocomplete(val)
-        self.text_editor.tktext.bind(
-            "<KeyRelease>",
-            self.dropdown_text_editor_modified,
-        )
+        self.text_editor.autocomplete(self.dropdown.window.search_and_see(event_data))
         return "break"
 
-    # c is displayed col
     def open_dropdown_window(
         self,
         r: int,
@@ -7105,6 +7121,10 @@ class MainTable(tk.Canvas):
         reset_kwargs = {
             "r": r,
             "c": c,
+            "bg": self.PAR.ops.table_editor_bg,
+            "fg": self.PAR.ops.table_editor_fg,
+            "select_bg": self.PAR.ops.table_editor_select_bg,
+            "select_fg": self.PAR.ops.table_editor_select_fg,
             "width": win_w,
             "height": win_h,
             "font": self.PAR.ops.table_font,
@@ -7133,12 +7153,12 @@ class MainTable(tk.Canvas):
                 window=self.dropdown.window,
                 anchor=anchor,
             )
+        self.update_idletasks()
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
                 "<KeyRelease>",
                 self.dropdown_text_editor_modified,
             )
-            self.update_idletasks()
             try:
                 self.after(1, lambda: self.text_editor.tktext.focus())
                 self.after(2, self.text_editor.window.scroll_to_bottom())
@@ -7146,7 +7166,6 @@ class MainTable(tk.Canvas):
                 return
             redraw = False
         else:
-            self.update_idletasks()
             self.dropdown.window.bind("<FocusOut>", lambda _: self.close_dropdown_window(r, c))
             self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
             self.dropdown.window.focus_set()

tksheet/other_classes.py

@@ -5,6 +5,7 @@ from collections import namedtuple
 from collections.abc import Callable, Generator, Hashable, Iterator
 from functools import partial
 from typing import Literal
+import tkinter as tk
 
 pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 
@@ -18,7 +19,7 @@ Box_t = namedtuple(
     "from_r from_c upto_r upto_c type_",
 )
 Box_st = namedtuple("Box_st", "coords type_")
-Loc = namedtuple("Loc", "row column")
+Loc = namedtuple("Loc", "row column", defaults=(None, None))
 
 Highlight = namedtuple(
     "Highlight",
@@ -489,25 +490,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 highlight_from(self, index: tk.Misc, r: int | str, c: int | str) -> None:
+        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)]:
+        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)
+        cursor_pos = self.tktext.index("insert")
+        line, column = cursor_pos.split(".")
+        index = self.window.tktext.index(f"{line}.{column}")
+        self.tktext.insert(index, value[len(current_val) :])
+        self.highlight_from(index, line, column)
 
     @property
     def tktext(self) -> object:

tksheet/row_index.py

@@ -808,19 +808,17 @@ class RowIndex(tk.Canvas):
             )
 
     def b1_release(self, event: object) -> None:
+        to_hide = self.being_drawn_item
         if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
-            self.MT.hide_selection_box(self.being_drawn_item)
+            self.being_drawn_item = None
             self.MT.set_currently_selected(
                 r_to_sel,
                 c_to_sel,
                 item=self.MT.create_selection_box(*to_sel, set_current=False),
+                run_binding=False,
             )
-            sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
-            try_binding(self.drag_selection_binding_func, sel_event)
-            self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
-        else:
-            self.being_drawn_item = None
+        self.MT.hide_selection_box(to_hide)
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             self.drag_height_resize()
@@ -1926,7 +1924,6 @@ class RowIndex(tk.Canvas):
         h = self.MT.row_positions[r + 1] - y + 1
         if text is None:
             text = self.get_cell_data(self.MT.datarn(r), none_to_empty_str=True, redirect_int=True)
-        bg, fg = self.PAR.ops.index_bg, self.PAR.ops.index_fg
         kwargs = {
             "menu_kwargs": DotDict(
                 {
@@ -1944,8 +1941,10 @@ class RowIndex(tk.Canvas):
             "width": w,
             "height": h,
             "show_border": True,
-            "bg": bg,
-            "fg": fg,
+            "bg": self.PAR.ops.index_editor_bg,
+            "fg": self.PAR.ops.index_editor_fg,
+            "select_bg": self.PAR.ops.index_editor_select_bg,
+            "select_fg": self.PAR.ops.index_editor_select_fg,
             "align": self.get_cell_align(r),
             "r": r,
         }
@@ -2160,22 +2159,15 @@ class RowIndex(tk.Canvas):
             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
+            hasattr(event, "keysym") and len(event.keysym) > 2 and event.keysym != "space"
         ):
             return
-        self.text_editor.tktext.unbind("<KeyRelease>")
-        self.text_editor.autocomplete(val)
-        self.text_editor.tktext.bind(
-            "<KeyRelease>",
-            self.dropdown_text_editor_modified,
-        )
+        self.text_editor.autocomplete(self.dropdown.window.search_and_see(event_data))
         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")
@@ -2196,6 +2188,10 @@ class RowIndex(tk.Canvas):
         reset_kwargs = {
             "r": r,
             "c": 0,
+            "bg": self.PAR.ops.index_editor_bg,
+            "fg": self.PAR.ops.index_editor_fg,
+            "select_bg": self.PAR.ops.index_editor_select_bg,
+            "select_fg": self.PAR.ops.index_editor_select_fg,
             "width": win_w,
             "height": win_h,
             "font": self.PAR.ops.index_font,
@@ -2225,12 +2221,12 @@ class RowIndex(tk.Canvas):
                 window=self.dropdown.window,
                 anchor=anchor,
             )
+        self.update_idletasks()
         if kwargs["state"] == "normal":
             self.text_editor.tktext.bind(
                 "<KeyRelease>",
                 self.dropdown_text_editor_modified,
             )
-            self.update_idletasks()
             try:
                 self.after(1, lambda: self.text_editor.tktext.focus())
                 self.after(2, self.text_editor.window.scroll_to_bottom())
@@ -2238,7 +2234,6 @@ class RowIndex(tk.Canvas):
                 return
             redraw = False
         else:
-            self.update_idletasks()
             self.dropdown.window.bind("<FocusOut>", lambda _x: self.close_dropdown_window(r))
             self.dropdown.window.bind("<Escape>", self.close_dropdown_window)
             self.dropdown.window.focus_set()

tksheet/sheet.py

@@ -200,8 +200,8 @@ class Sheet(tk.Frame):
         alternate_color: str = "",
         # colors
         outline_thickness: int = 0,
-        outline_color: str = theme_light_blue["outline_color"],
         theme: str = "light blue",
+        outline_color: str = theme_light_blue["outline_color"],
         frame_bg: str = theme_light_blue["table_bg"],
         popup_menu_fg: str = theme_light_blue["popup_menu_fg"],
         popup_menu_bg: str = theme_light_blue["popup_menu_bg"],
@@ -210,6 +210,10 @@ class Sheet(tk.Frame):
         table_grid_fg: str = theme_light_blue["table_grid_fg"],
         table_bg: str = theme_light_blue["table_bg"],
         table_fg: str = theme_light_blue["table_fg"],
+        table_editor_bg: str = theme_light_blue["table_editor_bg"],
+        table_editor_fg: str = theme_light_blue["table_editor_fg"],
+        table_editor_select_bg: str = theme_light_blue["table_editor_select_bg"],
+        table_editor_select_fg: str = theme_light_blue["table_editor_select_fg"],
         table_selected_box_cells_fg: str = theme_light_blue["table_selected_box_cells_fg"],
         table_selected_box_rows_fg: str = theme_light_blue["table_selected_box_rows_fg"],
         table_selected_box_columns_fg: str = theme_light_blue["table_selected_box_columns_fg"],
@@ -228,6 +232,10 @@ class Sheet(tk.Frame):
         index_border_fg: str = theme_light_blue["index_border_fg"],
         index_grid_fg: str = theme_light_blue["index_grid_fg"],
         index_fg: str = theme_light_blue["index_fg"],
+        index_editor_bg: str = theme_light_blue["index_editor_bg"],
+        index_editor_fg: str = theme_light_blue["index_editor_fg"],
+        index_editor_select_bg: str = theme_light_blue["index_editor_select_bg"],
+        index_editor_select_fg: str = theme_light_blue["index_editor_select_fg"],
         index_selected_cells_bg: str = theme_light_blue["index_selected_cells_bg"],
         index_selected_cells_fg: str = theme_light_blue["index_selected_cells_fg"],
         index_selected_rows_bg: str = theme_light_blue["index_selected_rows_bg"],
@@ -237,6 +245,10 @@ class Sheet(tk.Frame):
         header_border_fg: str = theme_light_blue["header_border_fg"],
         header_grid_fg: str = theme_light_blue["header_grid_fg"],
         header_fg: str = theme_light_blue["header_fg"],
+        header_editor_bg: str = theme_light_blue["header_editor_bg"],
+        header_editor_fg: str = theme_light_blue["header_editor_fg"],
+        header_editor_select_bg: str = theme_light_blue["header_editor_select_bg"],
+        header_editor_select_fg: str = theme_light_blue["header_editor_select_fg"],
         header_selected_cells_bg: str = theme_light_blue["header_selected_cells_bg"],
         header_selected_cells_fg: str = theme_light_blue["header_selected_cells_fg"],
         header_selected_columns_bg: str = theme_light_blue["header_selected_columns_bg"],
@@ -259,10 +271,6 @@ class Sheet(tk.Frame):
         horizontal_scroll_troughrelief: str = theme_light_blue["horizontal_scroll_troughrelief"],
         vertical_scroll_bordercolor: str = theme_light_blue["vertical_scroll_bordercolor"],
         horizontal_scroll_bordercolor: str = theme_light_blue["horizontal_scroll_bordercolor"],
-        vertical_scroll_borderwidth: int = 1,
-        horizontal_scroll_borderwidth: int = 1,
-        vertical_scroll_gripcount: int = 0,
-        horizontal_scroll_gripcount: int = 0,
         vertical_scroll_active_bg: str = theme_light_blue["vertical_scroll_active_bg"],
         horizontal_scroll_active_bg: str = theme_light_blue["horizontal_scroll_active_bg"],
         vertical_scroll_not_active_bg: str = theme_light_blue["vertical_scroll_not_active_bg"],
@@ -275,6 +283,10 @@ class Sheet(tk.Frame):
         horizontal_scroll_not_active_fg: str = theme_light_blue["horizontal_scroll_not_active_fg"],
         vertical_scroll_pressed_fg: str = theme_light_blue["vertical_scroll_pressed_fg"],
         horizontal_scroll_pressed_fg: str = theme_light_blue["horizontal_scroll_pressed_fg"],
+        vertical_scroll_borderwidth: int = 1,
+        horizontal_scroll_borderwidth: int = 1,
+        vertical_scroll_gripcount: int = 0,
+        horizontal_scroll_gripcount: int = 0,
         scrollbar_theme_inheritance: str = "default",
         scrollbar_show_arrows: bool = True,
         # changing the arrowsize (width) of the scrollbars
@@ -1035,6 +1047,21 @@ class Sheet(tk.Frame):
         func: Callable,
         add: str | None = None,
     ) -> Sheet:
+        """
+        In addition to normal use, the following special tksheet bindings can be used:
+        - "<<SheetModified>>"
+        - "<<SheetRedrawn>>"
+        - "<<SheetSelect>>"
+        - "<<Copy>>"
+        - "<<Cut>>"
+        - "<<Paste>>"
+        - "<<Delete>>"
+        - "<<Undo>>"
+        - "<<Redo>>"
+        - "<<SelectAll>>"
+
+        Use `add` parameter to bind to multiple functions
+        """
         if binding == "<ButtonPress-1>":
             self.MT.extra_b1_press_func = func
             self.CH.extra_b1_press_func = func
@@ -7149,6 +7176,10 @@ class Dropdown(Sheet):
         parent: tk.Misc,
         r: int,
         c: int,
+        bg: str,
+        fg: str,
+        select_bg: str,
+        select_fg: str,
         ops: dict,
         outline_color: str,
         width: int | None = None,
@@ -7187,8 +7218,6 @@ 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
@@ -7202,12 +7231,32 @@ class Dropdown(Sheet):
         self.bind("<Prior>", self.arrowkey_UP)
         self.bind("<Next>", self.arrowkey_DOWN)
         self.bind("<Return>", self.b1)
-        self.reset(r, c, width, height, font, ops, outline_color, align, values)
+        self.reset(
+            r=r,
+            c=c,
+            bg=bg,
+            fg=fg,
+            select_bg=select_bg,
+            select_fg=select_fg,
+            width=width,
+            height=height,
+            font=font,
+            ops=ops,
+            outline_color=outline_color,
+            align=align,
+            values=values,
+            search_function=search_function,
+            modified_function=modified_function,
+        )
 
     def reset(
         self,
         r: int,
         c: int,
+        bg: str,
+        fg: str,
+        select_bg: str,
+        select_fg: str,
         width: int,
         height: int,
         font: tuple[str, int, str],
@@ -7228,17 +7277,17 @@ class Dropdown(Sheet):
         self.table_align(align)
         self.set_options(
             outline_color=outline_color,
-            table_grid_fg=ops.popup_menu_fg,
-            table_selected_cells_border_fg=ops.popup_menu_fg,
-            table_selected_cells_bg=ops.popup_menu_highlight_bg,
-            table_selected_rows_border_fg=ops.popup_menu_fg,
-            table_selected_rows_bg=ops.popup_menu_highlight_bg,
-            table_selected_rows_fg=ops.popup_menu_highlight_fg,
-            table_selected_box_cells_fg=ops.popup_menu_highlight_bg,
-            table_selected_box_rows_fg=ops.popup_menu_highlight_bg,
+            table_grid_fg=fg,
+            table_selected_cells_border_fg=fg,
+            table_selected_cells_bg=select_bg,
+            table_selected_rows_border_fg=fg,
+            table_selected_rows_bg=select_bg,
+            table_selected_rows_fg=select_fg,
+            table_selected_box_cells_fg=select_bg,
+            table_selected_box_rows_fg=select_bg,
             font=font,
-            table_fg=ops.popup_menu_fg,
-            table_bg=ops.popup_menu_bg,
+            table_fg=fg,
+            table_bg=bg,
             **{k: ops[k] for k in scrollbar_options_keys},
         )
         self.values(values, width=width - self.yscroll.winfo_width() - 4)