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

tksheet/main_table.py

@@ -51,9 +51,10 @@ from .formatters import (
 from .functions import (
     add_to_displayed,
     b_index,
+    box_is_single_cell,
     cell_right_within_box,
+    color_tup,
     consecutive_ranges,
-    decompress_load,
     diff_gen,
     diff_list,
     down_cell_within_box,
@@ -73,10 +74,9 @@ from .functions import (
     mod_span_widget,
     move_elements_by_mapping,
     new_tk_event,
-    pickle_obj,
-    pickled_event_dict,
     rounded_box_coords,
     span_idxs_post_move,
+    stored_event_dict,
     try_binding,
     unpickle_obj,
 )
@@ -88,6 +88,7 @@ from .other_classes import (
     DropdownStorage,
     EventDataDict,
     FontTuple,
+    Highlight,
     Loc,
     ProgressBar,
     Selected,
@@ -682,7 +683,7 @@ class MainTable(tk.Canvas):
         for r1, c1, r2, c2 in boxes:
             self.show_ctrl_outline(canvas="table", start_cell=(c1, r1), end_cell=(c2, r2))
         if event_data["cells"]["table"]:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
             try_binding(self.extra_end_ctrl_x_func, event_data, "end_ctrl_x")
             self.sheet_modified(event_data)
             self.PAR.emit_event("<<Cut>>", event_data)
@@ -946,7 +947,7 @@ class MainTable(tk.Canvas):
         )
         self.refresh()
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
             try_binding(self.extra_end_ctrl_v_func, event_data, "end_ctrl_v")
             self.sheet_modified(event_data)
             self.PAR.emit_event("<<Paste>>", event_data)
@@ -986,7 +987,7 @@ class MainTable(tk.Canvas):
                         )
         if event_data["cells"]["table"]:
             self.refresh()
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
             try_binding(self.extra_end_delete_key_func, event_data, "end_delete")
             self.sheet_modified(event_data)
             self.PAR.emit_event("<<Delete>>", event_data)
@@ -1057,7 +1058,7 @@ class MainTable(tk.Canvas):
                 "data": data_new_idxs,
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         if move_widths and disp_new_idxs and (not data_indexes or self.all_columns_displayed):
             self.deselect("all", run_binding=False, redraw=False)
@@ -1291,7 +1292,7 @@ class MainTable(tk.Canvas):
                 "data": data_new_idxs,
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         if move_heights and disp_new_idxs and (not data_indexes or self.all_rows_displayed):
             self.deselect("all", run_binding=False, redraw=False)
@@ -1482,11 +1483,11 @@ class MainTable(tk.Canvas):
     def undo(self, event: object = None) -> None | EventDataDict:
         if not self.undo_stack:
             return
-        modification = decompress_load(self.undo_stack[-1]["data"])
+        modification = self.undo_stack[-1]["data"]
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_undo"):
             return
         event_data = self.undo_modification_invert_event(modification)
-        self.redo_stack.append(pickled_event_dict(event_data))
+        self.redo_stack.append(stored_event_dict(event_data))
         self.undo_stack.pop()
         self.sheet_modified(event_data, purge_redo=False)
         try_binding(self.extra_end_ctrl_z_func, event_data, "end_undo")
@@ -1496,11 +1497,11 @@ class MainTable(tk.Canvas):
     def redo(self, event: object = None) -> None | EventDataDict:
         if not self.redo_stack:
             return
-        modification = decompress_load(self.redo_stack[-1]["data"])
+        modification = self.redo_stack[-1]["data"]
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_redo"):
             return
         event_data = self.undo_modification_invert_event(modification, name="redo")
-        self.undo_stack.append(pickled_event_dict(event_data))
+        self.undo_stack.append(stored_event_dict(event_data))
         self.redo_stack.pop()
         self.sheet_modified(event_data, purge_redo=False)
         try_binding(self.extra_end_ctrl_z_func, event_data, "end_redo")
@@ -1535,8 +1536,6 @@ class MainTable(tk.Canvas):
         return event_data
 
     def restore_options_named_spans(self, modification: EventDataDict) -> None:
-        if not isinstance(modification["options"], dict):
-            modification["options"] = unpickle_obj(modification["options"])
         if "cell_options" in modification["options"]:
             self.cell_options = modification["options"]["cell_options"]
         if "column_options" in modification["options"]:
@@ -2763,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"):
@@ -2826,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
@@ -2993,8 +2992,7 @@ class MainTable(tk.Canvas):
                 self.being_drawn_item = True
                 self.being_drawn_item = self.add_selection(rowsel, colsel, set_as_current=True, run_binding_func=False)
                 sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                if self.ctrl_selection_binding_func:
-                    self.ctrl_selection_binding_func(sel_event)
+                try_binding(self.ctrl_selection_binding_func, sel_event)
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
         elif not self.ctrl_select_enabled:
@@ -3023,8 +3021,7 @@ class MainTable(tk.Canvas):
                     )
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                if self.shift_selection_binding_func:
-                    self.shift_selection_binding_func(sel_event)
+                try_binding(self.shift_selection_binding_func, sel_event)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
         elif not self.ctrl_select_enabled:
             self.shift_b1_press(event)
@@ -3053,8 +3050,7 @@ class MainTable(tk.Canvas):
                     )
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                if self.shift_selection_binding_func:
-                    self.shift_selection_binding_func(sel_event)
+                try_binding(self.shift_selection_binding_func, sel_event)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
 
     def get_shift_select_box(self, min_r: int, rowsel: int, min_c: int, colsel: int):
@@ -3119,8 +3115,7 @@ class MainTable(tk.Canvas):
                         )
                     need_redraw = True
                     sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                    if self.drag_selection_binding_func:
-                        self.drag_selection_binding_func(sel_event)
+                    try_binding(self.drag_selection_binding_func, sel_event)
                     self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
             if self.scroll_if_event_offscreen(event):
                 need_redraw = True
@@ -3162,8 +3157,7 @@ class MainTable(tk.Canvas):
                         )
                     need_redraw = True
                     sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                    if self.drag_selection_binding_func:
-                        self.drag_selection_binding_func(sel_event)
+                    try_binding(self.drag_selection_binding_func, sel_event)
                     self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
             if self.scroll_if_event_offscreen(event):
                 need_redraw = True
@@ -3190,8 +3184,7 @@ class MainTable(tk.Canvas):
                 ),
             )
             sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-            if self.drag_selection_binding_func:
-                self.drag_selection_binding_func(sel_event)
+            try_binding(self.drag_selection_binding_func, sel_event)
             self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
         else:
             self.being_drawn_item = None
@@ -4536,7 +4529,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.refresh()
         try_binding(self.extra_end_insert_cols_rc_func, event_data, "end_add_columns")
         self.sheet_modified(event_data)
@@ -4671,7 +4664,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.refresh()
         try_binding(self.extra_end_insert_rows_rc_func, event_data, "end_add_rows")
         self.sheet_modified(event_data)
@@ -4775,26 +4768,24 @@ class MainTable(tk.Canvas):
             }
         return rows, index_data, heights
 
-    def pickle_options(self) -> bytes:
-        return pickle_obj(
-            {
-                "cell_options": self.cell_options,
-                "column_options": self.col_options,
-                "row_options": self.row_options,
-                "CH_cell_options": self.CH.cell_options,
-                "RI_cell_options": self.RI.cell_options,
-                "tagged_cells": self.tagged_cells,
-                "tagged_rows": self.tagged_rows,
-                "tagged_columns": self.tagged_columns,
-            }
-        )
+    def copy_options(self) -> dict:
+        return {
+            "cell_options": dict(self.cell_options),
+            "column_options": dict(self.col_options),
+            "row_options": dict(self.row_options),
+            "CH_cell_options": dict(self.CH.cell_options),
+            "RI_cell_options": dict(self.RI.cell_options),
+            "tagged_cells": {f"{tag}": set(s) for tag, s in self.tagged_cells.items()},
+            "tagged_rows": {f"{tag}": set(s) for tag, s in self.tagged_rows.items()},
+            "tagged_columns": {f"{tag}": set(s) for tag, s in self.tagged_columns.items()},
+        }
 
     def delete_columns_data(self, cols: list, event_data: dict) -> EventDataDict:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         event_data["deleted"]["displayed_columns"] = (
             list(self.displayed_columns) if not isinstance(self.displayed_columns, int) else int(self.displayed_columns)
         )
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         for datacn in reversed(cols):
             for rn in range(len(self.data)):
@@ -4846,7 +4837,7 @@ class MainTable(tk.Canvas):
         data_cols = selected if self.all_columns_displayed else [self.displayed_columns[c] for c in selected]
         event_data = self.delete_columns_data(data_cols, event_data)
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.deselect("all")
         try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
         self.sheet_modified(event_data)
@@ -4856,7 +4847,7 @@ class MainTable(tk.Canvas):
         event_data["deleted"]["displayed_rows"] = (
             list(self.displayed_rows) if not isinstance(self.displayed_rows, int) else int(self.displayed_rows)
         )
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         for datarn in reversed(rows):
             event_data["deleted"]["rows"][datarn] = self.data.pop(datarn)
@@ -4902,7 +4893,7 @@ class MainTable(tk.Canvas):
         data_rows = selected if self.all_rows_displayed else [self.displayed_rows[r] for r in selected]
         event_data = self.delete_rows_data(data_rows, event_data)
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.deselect("all")
         try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
         self.sheet_modified(event_data)
@@ -5168,63 +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 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,
@@ -5254,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:
@@ -5643,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()
@@ -5677,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:
@@ -5706,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,
@@ -5724,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,
@@ -5743,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,
@@ -5859,7 +5883,13 @@ class MainTable(tk.Canvas):
                                 if draw_y + self.table_half_txt_height - 1 > rbotgridln:
                                     break
         if redraw_table:
-            for dct in (self.hidd_text, self.hidd_high, self.hidd_grid, self.hidd_dropdown, self.hidd_checkbox):
+            for dct in (
+                self.hidd_text,
+                self.hidd_high,
+                self.hidd_grid,
+                self.hidd_dropdown,
+                self.hidd_checkbox,
+            ):
                 for iid, showing in dct.items():
                     if showing:
                         self.itemconfig(iid, state="hidden")
@@ -6903,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(
@@ -6957,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:
@@ -7014,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(
@@ -7033,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":
@@ -7056,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)
@@ -7067,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,
             )
@@ -7078,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())
@@ -7268,7 +7312,7 @@ class MainTable(tk.Canvas):
         )
         if not check_input_valid or self.input_valid_for_cell(datarn, datacn, value):
             if self.undo_enabled and undo:
-                self.undo_stack.append(pickled_event_dict(event_data))
+                self.undo_stack.append(stored_event_dict(event_data))
             self.set_cell_data(datarn, datacn, value)
             if cell_resize and self.PAR.ops.cell_auto_resize_enabled:
                 self.set_cell_size_to_text(r, c, only_if_too_small=True, redraw=redraw, run_binding=True)