tksheet 7.4.24__py3-none-any.whl → 7.5.1__py3-none-any.whl

tksheet/main_table.py

@@ -71,6 +71,7 @@ from .functions import (
     is_last_cell,
     is_type_int,
     len_to_idx,
+    menu_item_exists,
     mod_event_val,
     mod_span,
     move_elements_by_mapping_gen,
@@ -285,19 +286,24 @@ class MainTable(tk.Canvas):
         self.align = kwargs["align"]
         self.PAR.ops.table_font = FontTuple(
             self.PAR.ops.table_font[0],
-            max(1, int(self.PAR.ops.table_font[1] * kwargs["zoom"] / 100)),
+            max(1, int(round(self.PAR.ops.table_font[1]) * kwargs["zoom"] / 100)),
             self.PAR.ops.table_font[2],
         )
         self.PAR.ops.index_font = FontTuple(
             self.PAR.ops.index_font[0],
-            max(1, int(self.PAR.ops.index_font[1] * kwargs["zoom"] / 100)),
+            max(1, int(round(self.PAR.ops.index_font[1]) * kwargs["zoom"] / 100)),
             self.PAR.ops.index_font[2],
         )
         self.PAR.ops.header_font = FontTuple(
             self.PAR.ops.header_font[0],
-            max(1, int(self.PAR.ops.header_font[1] * kwargs["zoom"] / 100)),
+            max(1, int(round(self.PAR.ops.header_font[1]) * kwargs["zoom"] / 100)),
             self.PAR.ops.header_font[2],
         )
+        self.PAR.ops.popup_menu_font = FontTuple(
+            self.PAR.ops.popup_menu_font[0],
+            max(1, int(round(self.PAR.ops.popup_menu_font[1]) * kwargs["zoom"] / 100)),
+            self.PAR.ops.popup_menu_font[2],
+        )
         self.txt_measure_canvas = tk.Canvas(self)
         self.txt_measure_canvas_text = self.txt_measure_canvas.create_text(0, 0, text="", font=self.PAR.ops.table_font)
 
@@ -456,28 +462,84 @@ class MainTable(tk.Canvas):
         self.tagged_rows = {}
         self.tagged_columns = {}
 
+    def create_ctrl_outline(
+        self,
+        x1: int,
+        y1: int,
+        x2: int,
+        y2: int,
+        fill: str,
+        dash: tuple[int, int],
+        width: int,
+        outline: str,
+        tags: str | tuple[str, ...],
+    ) -> int:
+        if self.hidd_ctrl_outline:
+            t, sh = self.hidd_ctrl_outline.popitem()
+            self.coords(t, x1, y1, x2, y2)
+            if sh:
+                self.itemconfig(t, fill=fill, dash=dash, width=width, outline=outline, tags=tags)
+            else:
+                self.itemconfig(
+                    t,
+                    fill=fill,
+                    dash=dash,
+                    width=width,
+                    outline=outline,
+                    tags=tags,
+                    state="normal",
+                )
+        else:
+            t = self.create_rectangle(
+                x1,
+                y1,
+                x2,
+                y2,
+                fill=fill,
+                dash=dash,
+                width=width,
+                outline=outline,
+                tags=tags,
+            )
+        self.lift(t)
+        self.disp_ctrl_outline[t] = True
+        return t
+
+    def delete_ctrl_outlines(self, iid: int | None = None) -> None:
+        if isinstance(iid, int) and iid in self.disp_ctrl_outline:
+            self.hidd_ctrl_outline[iid] = self.disp_ctrl_outline.pop(iid)
+            self.itemconfig(iid, state="hidden")
+            self.hidd_ctrl_outline[iid] = False
+        else:
+            self.hidd_ctrl_outline.update(self.disp_ctrl_outline)
+            self.disp_ctrl_outline = {}
+            for t, sh in self.hidd_ctrl_outline.items():
+                if sh:
+                    self.itemconfig(t, state="hidden")
+                    self.hidd_ctrl_outline[t] = False
+
     def show_ctrl_outline(
         self,
         canvas: Literal["table"] = "table",
         start_cell: tuple[int, int] = (0, 0),
         end_cell: tuple[int, int] = (0, 0),
-        dash: tuple[int, int] = (20, 20),
+        dash: tuple[int, int] = (15, 15),
         outline: str | None = None,
         delete_on_timer: bool = True,
     ) -> None:
-        self.create_ctrl_outline(
+        iid = self.create_ctrl_outline(
             self.col_positions[start_cell[0]] + 1,
             self.row_positions[start_cell[1]] + 1,
-            self.col_positions[end_cell[0]] - 1,
-            self.row_positions[end_cell[1]] - 1,
+            self.col_positions[end_cell[0]],
+            self.row_positions[end_cell[1]],
             fill="",
             dash=dash,
-            width=3,
+            width=2,
             outline=self.PAR.ops.resizing_line_fg if outline is None else outline,
-            tags="ctrl",
+            tags="lift",
         )
         if delete_on_timer:
-            self.after(1500, self.delete_ctrl_outlines)
+            self.after(1500, lambda: self.delete_ctrl_outlines(iid))
 
     def escape(self, event: tk.Misc | None) -> None:
         if self.find_window.open:
@@ -895,56 +957,6 @@ class MainTable(tk.Canvas):
             self.find_window.open = False
             self.focus_set()
 
-    def create_ctrl_outline(
-        self,
-        x1: int,
-        y1: int,
-        x2: int,
-        y2: int,
-        fill: str,
-        dash: tuple[int, int],
-        width: int,
-        outline: str,
-        tags: str | tuple[str, ...],
-    ) -> None:
-        if self.hidd_ctrl_outline:
-            t, sh = self.hidd_ctrl_outline.popitem()
-            self.coords(t, x1, y1, x2, y2)
-            if sh:
-                self.itemconfig(t, fill=fill, dash=dash, width=width, outline=outline, tags=tags)
-            else:
-                self.itemconfig(
-                    t,
-                    fill=fill,
-                    dash=dash,
-                    width=width,
-                    outline=outline,
-                    tags=tags,
-                    state="normal",
-                )
-            self.lift(t)
-        else:
-            t = self.create_rectangle(
-                x1,
-                y1,
-                x2,
-                y2,
-                fill=fill,
-                dash=dash,
-                width=width,
-                outline=outline,
-                tags=tags,
-            )
-        self.disp_ctrl_outline[t] = True
-
-    def delete_ctrl_outlines(self) -> None:
-        self.hidd_ctrl_outline.update(self.disp_ctrl_outline)
-        self.disp_ctrl_outline = {}
-        for t, sh in self.hidd_ctrl_outline.items():
-            if sh:
-                self.itemconfig(t, state="hidden")
-                self.hidd_ctrl_outline[t] = False
-
     def get_ctrl_x_c_boxes(self) -> tuple[dict[tuple[int, int, int, int], str], int]:
         maxrows = 0
         if not self.selected:
@@ -1410,6 +1422,7 @@ class MainTable(tk.Canvas):
             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)
+            self.show_ctrl_outline("table", (selected_c, selected_r), (selboxc, selboxr), dash=())
         return event_data
 
     def delete_key(self, event: Any = None, validation: bool = True) -> None | EventDataDict:
@@ -1446,6 +1459,8 @@ class MainTable(tk.Canvas):
             try_binding(self.extra_end_delete_key_func, event_data, "end_delete")
             self.sheet_modified(event_data)
             self.PAR.emit_event("<<Delete>>", event_data)
+            for r1, c1, r2, c2 in boxes:
+                self.show_ctrl_outline(canvas="table", start_cell=(c1, r1), end_cell=(c2, r2))
         return event_data
 
     def event_data_set_cell(self, datarn: int, datacn: int, value: Any, event_data: EventDataDict) -> EventDataDict:
@@ -2910,6 +2925,27 @@ class MainTable(tk.Canvas):
             pass
         menu.add_command(**kwargs)
 
+    def table_edit_cell_enabled(self) -> bool:
+        return (
+            self.rc_popup_menus_enabled
+            and self.edit_cell_enabled
+            and any(x in self.enabled_bindings_menu_entries for x in ("all", "edit_cell", "edit_bindings", "edit"))
+        )
+
+    def index_edit_cell_enabled(self) -> bool:
+        return (
+            self.rc_popup_menus_enabled
+            and self.RI.edit_cell_enabled
+            and "edit_index" in self.enabled_bindings_menu_entries
+        )
+
+    def header_edit_cell_enabled(self) -> bool:
+        return (
+            self.rc_popup_menus_enabled
+            and self.CH.edit_cell_enabled
+            and "edit_header" in self.enabled_bindings_menu_entries
+        )
+
     def create_rc_menus(self) -> None:
         if not self.rc_popup_menu:
             self.rc_popup_menu = tk.Menu(self, tearoff=0, background=self.PAR.ops.popup_menu_bg)
@@ -2927,37 +2963,31 @@ class MainTable(tk.Canvas):
         ):
             menu.delete(0, "end")
         mnkwgs = get_menu_kwargs(self.PAR.ops)
-        if (
-            self.rc_popup_menus_enabled
-            and self.CH.edit_cell_enabled
-            and "edit_header" in self.enabled_bindings_menu_entries
-        ):
+        if self.header_edit_cell_enabled():
             self.menu_add_command(
                 self.CH.ch_rc_popup_menu,
                 label=self.PAR.ops.edit_header_label,
                 command=lambda: self.CH.open_cell(event="rc"),
+                image=self.PAR.ops.edit_header_image,
+                compound=self.PAR.ops.edit_header_compound,
                 **mnkwgs,
             )
-        if (
-            self.rc_popup_menus_enabled
-            and self.RI.edit_cell_enabled
-            and "edit_index" in self.enabled_bindings_menu_entries
-        ):
+        if self.index_edit_cell_enabled():
             self.menu_add_command(
                 self.RI.ri_rc_popup_menu,
                 label=self.PAR.ops.edit_index_label,
                 command=lambda: self.RI.open_cell(event="rc"),
+                image=self.PAR.ops.edit_index_image,
+                compound=self.PAR.ops.edit_index_compound,
                 **mnkwgs,
             )
-        if (
-            self.rc_popup_menus_enabled
-            and self.edit_cell_enabled
-            and any(x in self.enabled_bindings_menu_entries for x in ("all", "edit_cell", "edit_bindings", "edit"))
-        ):
+        if self.table_edit_cell_enabled():
             self.menu_add_command(
                 self.rc_popup_menu,
                 label=self.PAR.ops.edit_cell_label,
                 command=lambda: self.open_cell(event="rc"),
+                image=self.PAR.ops.edit_cell_image,
+                compound=self.PAR.ops.edit_cell_compound,
                 **mnkwgs,
             )
         if self.cut_enabled and any(
@@ -2968,6 +2998,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.cut_label,
                 accelerator=self.PAR.ops.cut_accelerator,
                 command=self.ctrl_x,
+                image=self.PAR.ops.cut_image,
+                compound=self.PAR.ops.cut_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -2975,6 +3007,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.cut_contents_label,
                 accelerator=self.PAR.ops.cut_contents_accelerator,
                 command=self.ctrl_x,
+                image=self.PAR.ops.cut_contents_image,
+                compound=self.PAR.ops.cut_contents_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -2982,6 +3016,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.cut_contents_label,
                 accelerator=self.PAR.ops.cut_contents_accelerator,
                 command=self.ctrl_x,
+                image=self.PAR.ops.cut_contents_image,
+                compound=self.PAR.ops.cut_contents_compound,
                 **mnkwgs,
             )
         if self.copy_enabled and any(
@@ -2992,6 +3028,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.copy_label,
                 accelerator=self.PAR.ops.copy_accelerator,
                 command=self.ctrl_c,
+                image=self.PAR.ops.copy_image,
+                compound=self.PAR.ops.copy_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -2999,6 +3037,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.copy_contents_label,
                 accelerator=self.PAR.ops.copy_contents_accelerator,
                 command=self.ctrl_c,
+                image=self.PAR.ops.copy_contents_image,
+                compound=self.PAR.ops.copy_contents_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3006,6 +3046,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.copy_contents_label,
                 accelerator=self.PAR.ops.copy_contents_accelerator,
                 command=self.ctrl_c,
+                image=self.PAR.ops.copy_contents_image,
+                compound=self.PAR.ops.copy_contents_compound,
                 **mnkwgs,
             )
         if self.paste_enabled and any(
@@ -3016,6 +3058,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.paste_label,
                 accelerator=self.PAR.ops.paste_accelerator,
                 command=self.ctrl_v,
+                image=self.PAR.ops.paste_image,
+                compound=self.PAR.ops.paste_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3023,6 +3067,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.paste_label,
                 accelerator=self.PAR.ops.paste_accelerator,
                 command=self.ctrl_v,
+                image=self.PAR.ops.paste_image,
+                compound=self.PAR.ops.paste_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3030,6 +3076,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.paste_label,
                 accelerator=self.PAR.ops.paste_accelerator,
                 command=self.ctrl_v,
+                image=self.PAR.ops.paste_image,
+                compound=self.PAR.ops.paste_compound,
                 **mnkwgs,
             )
             if self.PAR.ops.paste_can_expand_x or self.PAR.ops.paste_can_expand_y:
@@ -3038,6 +3086,8 @@ class MainTable(tk.Canvas):
                     label=self.PAR.ops.paste_label,
                     accelerator=self.PAR.ops.paste_accelerator,
                     command=self.ctrl_v,
+                    image=self.PAR.ops.paste_image,
+                    compound=self.PAR.ops.paste_compound,
                     **mnkwgs,
                 )
         if self.delete_key_enabled and any(
@@ -3048,6 +3098,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.delete_label,
                 accelerator=self.PAR.ops.delete_accelerator,
                 command=self.delete_key,
+                image=self.PAR.ops.delete_image,
+                compound=self.PAR.ops.delete_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3055,6 +3107,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.clear_contents_label,
                 accelerator=self.PAR.ops.clear_contents_accelerator,
                 command=self.delete_key,
+                image=self.PAR.ops.clear_contents_image,
+                compound=self.PAR.ops.clear_contents_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3062,6 +3116,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.clear_contents_label,
                 accelerator=self.PAR.ops.clear_contents_accelerator,
                 command=self.delete_key,
+                image=self.PAR.ops.clear_contents_image,
+                compound=self.PAR.ops.clear_contents_compound,
                 **mnkwgs,
             )
         if self.rc_delete_column_enabled:
@@ -3069,6 +3125,8 @@ class MainTable(tk.Canvas):
                 self.CH.ch_rc_popup_menu,
                 label=self.PAR.ops.delete_columns_label,
                 command=self.delete_columns,
+                image=self.PAR.ops.delete_columns_image,
+                compound=self.PAR.ops.delete_columns_compound,
                 **mnkwgs,
             )
         if self.rc_insert_column_enabled:
@@ -3076,18 +3134,24 @@ class MainTable(tk.Canvas):
                 self.CH.ch_rc_popup_menu,
                 label=self.PAR.ops.insert_columns_left_label,
                 command=lambda: self.rc_add_columns("left"),
+                image=self.PAR.ops.insert_columns_left_image,
+                compound=self.PAR.ops.insert_columns_left_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
                 self.CH.ch_rc_popup_menu,
                 label=self.PAR.ops.insert_columns_right_label,
                 command=lambda: self.rc_add_columns("right"),
+                image=self.PAR.ops.insert_columns_right_image,
+                compound=self.PAR.ops.insert_columns_right_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
                 self.empty_rc_popup_menu,
                 label=self.PAR.ops.insert_column_label,
                 command=lambda: self.rc_add_columns("left"),
+                image=self.PAR.ops.insert_column_image,
+                compound=self.PAR.ops.insert_column_compound,
                 **mnkwgs,
             )
         if self.rc_delete_row_enabled:
@@ -3095,6 +3159,8 @@ class MainTable(tk.Canvas):
                 self.RI.ri_rc_popup_menu,
                 label=self.PAR.ops.delete_rows_label,
                 command=self.delete_rows,
+                image=self.PAR.ops.delete_rows_image,
+                compound=self.PAR.ops.delete_rows_compound,
                 **mnkwgs,
             )
         if self.rc_insert_row_enabled:
@@ -3102,18 +3168,24 @@ class MainTable(tk.Canvas):
                 self.RI.ri_rc_popup_menu,
                 label=self.PAR.ops.insert_rows_above_label,
                 command=lambda: self.rc_add_rows("above"),
+                image=self.PAR.ops.insert_rows_above_image,
+                compound=self.PAR.ops.insert_rows_above_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
                 self.RI.ri_rc_popup_menu,
                 label=self.PAR.ops.insert_rows_below_label,
                 command=lambda: self.rc_add_rows("below"),
+                image=self.PAR.ops.insert_rows_below_image,
+                compound=self.PAR.ops.insert_rows_below_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
                 self.empty_rc_popup_menu,
                 label=self.PAR.ops.insert_row_label,
                 command=lambda: self.rc_add_rows("below"),
+                image=self.PAR.ops.insert_row_image,
+                compound=self.PAR.ops.insert_row_compound,
                 **mnkwgs,
             )
         if self.rc_sort_cells_enabled:
@@ -3122,6 +3194,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_cells_label,
                 accelerator=self.PAR.ops.sort_cells_accelerator,
                 command=self.sort_boxes,
+                image=self.PAR.ops.sort_cells_image,
+                compound=self.PAR.ops.sort_cells_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3129,6 +3203,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_cells_reverse_label,
                 accelerator=self.PAR.ops.sort_cells_reverse_accelerator,
                 command=lambda: self.sort_boxes(reverse=True),
+                image=self.PAR.ops.sort_cells_reverse_image,
+                compound=self.PAR.ops.sort_cells_reverse_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3136,6 +3212,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_cells_x_label,
                 accelerator=self.PAR.ops.sort_cells_x_accelerator,
                 command=lambda: self.sort_boxes(row_wise=True),
+                image=self.PAR.ops.sort_cells_x_image,
+                compound=self.PAR.ops.sort_cells_x_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3143,6 +3221,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_cells_x_reverse_label,
                 accelerator=self.PAR.ops.sort_cells_x_reverse_accelerator,
                 command=lambda: self.sort_boxes(reverse=True, row_wise=True),
+                image=self.PAR.ops.sort_cells_x_reverse_image,
+                compound=self.PAR.ops.sort_cells_x_reverse_compound,
                 **mnkwgs,
             )
         # row index sort rows cells
@@ -3152,6 +3232,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_row_label,
                 accelerator=self.PAR.ops.sort_row_accelerator,
                 command=self.RI._sort_rows,
+                image=self.PAR.ops.sort_row_image,
+                compound=self.PAR.ops.sort_row_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3159,6 +3241,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_row_reverse_label,
                 accelerator=self.PAR.ops.sort_row_reverse_accelerator,
                 command=lambda: self.RI._sort_rows(reverse=True),
+                image=self.PAR.ops.sort_row_reverse_image,
+                compound=self.PAR.ops.sort_row_reverse_compound,
                 **mnkwgs,
             )
         # header sort columns cells
@@ -3168,6 +3252,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_column_label,
                 accelerator=self.PAR.ops.sort_column_accelerator,
                 command=self.CH._sort_columns,
+                image=self.PAR.ops.sort_column_image,
+                compound=self.PAR.ops.sort_column_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3175,6 +3261,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_column_reverse_label,
                 accelerator=self.PAR.ops.sort_column_reverse_accelerator,
                 command=lambda: self.CH._sort_columns(reverse=True),
+                image=self.PAR.ops.sort_column_reverse_image,
+                compound=self.PAR.ops.sort_column_reverse_compound,
                 **mnkwgs,
             )
         # row index sort columns by row
@@ -3184,6 +3272,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_columns_label,
                 accelerator=self.PAR.ops.sort_columns_accelerator,
                 command=self.RI._sort_columns_by_row,
+                image=self.PAR.ops.sort_columns_image,
+                compound=self.PAR.ops.sort_columns_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3191,6 +3281,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_columns_reverse_label,
                 accelerator=self.PAR.ops.sort_columns_reverse_accelerator,
                 command=lambda: self.RI._sort_columns_by_row(reverse=True),
+                image=self.PAR.ops.sort_columns_reverse_image,
+                compound=self.PAR.ops.sort_columns_reverse_compound,
                 **mnkwgs,
             )
         # header sort rows by column
@@ -3200,6 +3292,8 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_rows_label,
                 accelerator=self.PAR.ops.sort_rows_accelerator,
                 command=self.CH._sort_rows_by_column,
+                image=self.PAR.ops.sort_rows_image,
+                compound=self.PAR.ops.sort_rows_compound,
                 **mnkwgs,
             )
             self.menu_add_command(
@@ -3207,36 +3301,46 @@ class MainTable(tk.Canvas):
                 label=self.PAR.ops.sort_rows_reverse_label,
                 accelerator=self.PAR.ops.sort_rows_reverse_accelerator,
                 command=lambda: self.CH._sort_rows_by_column(reverse=True),
+                image=self.PAR.ops.sort_rows_reverse_image,
+                compound=self.PAR.ops.sort_rows_reverse_compound,
                 **mnkwgs,
             )
-        for label, func in self.extra_table_rc_menu_funcs.items():
-            self.menu_add_command(
+        if self.undo_enabled and any(
+            x in self.enabled_bindings_menu_entries for x in ("all", "undo", "redo", "edit_bindings", "edit")
+        ):
+            for menu in (
                 self.rc_popup_menu,
-                label=label,
-                command=func,
-                **mnkwgs,
-            )
-        for label, func in self.extra_index_rc_menu_funcs.items():
-            self.menu_add_command(
                 self.RI.ri_rc_popup_menu,
-                label=label,
-                command=func,
-                **mnkwgs,
-            )
-        for label, func in self.extra_header_rc_menu_funcs.items():
-            self.menu_add_command(
                 self.CH.ch_rc_popup_menu,
-                label=label,
-                command=func,
-                **mnkwgs,
-            )
-        for label, func in self.extra_empty_space_rc_menu_funcs.items():
-            self.menu_add_command(
                 self.empty_rc_popup_menu,
-                label=label,
-                command=func,
-                **mnkwgs,
-            )
+            ):
+                self.menu_add_command(
+                    menu,
+                    label=self.PAR.ops.undo_label,
+                    accelerator=self.PAR.ops.undo_accelerator,
+                    command=self.undo,
+                    image=self.PAR.ops.undo_image,
+                    compound=self.PAR.ops.undo_compound,
+                    **mnkwgs,
+                )
+                self.menu_add_command(
+                    menu,
+                    label=self.PAR.ops.redo_label,
+                    accelerator=self.PAR.ops.redo_accelerator,
+                    command=self.redo,
+                    image=self.PAR.ops.redo_image,
+                    compound=self.PAR.ops.redo_compound,
+                    **mnkwgs,
+                )
+        # Added popup menu commands
+        for label, kws in self.extra_table_rc_menu_funcs.items():
+            self.menu_add_command(self.rc_popup_menu, label=label, **{**mnkwgs, **kws})
+        for label, kws in self.extra_index_rc_menu_funcs.items():
+            self.menu_add_command(self.RI.ri_rc_popup_menu, label=label, **{**mnkwgs, **kws})
+        for label, kws in self.extra_header_rc_menu_funcs.items():
+            self.menu_add_command(self.CH.ch_rc_popup_menu, label=label, **{**mnkwgs, **kws})
+        for label, kws in self.extra_empty_space_rc_menu_funcs.items():
+            self.menu_add_command(self.empty_rc_popup_menu, label=label, **{**mnkwgs, **kws})
 
     def enable_bindings(self, bindings: Any, menu: bool = True) -> None:
         if not bindings:
@@ -3567,6 +3671,65 @@ class MainTable(tk.Canvas):
     def not_currently_resizing(self) -> bool:
         return all(v is None for v in (self.RI.rsz_h, self.RI.rsz_w, self.CH.rsz_h, self.CH.rsz_w))
 
+    def is_readonly(self, datarn: int, datacn: int) -> bool:
+        return (
+            ((datarn, datacn) in self.cell_options and "readonly" in self.cell_options[(datarn, datacn)])
+            or (datarn in self.row_options and "readonly" in self.row_options[datarn])
+            or (datacn in self.col_options and "readonly" in self.col_options[datacn])
+        )
+
+    def popup_menu_disable_edit_if_readonly(self, popup_menu: tk.Menu) -> None:
+        # table
+        if (
+            self.selected
+            and self.index_edit_cell_enabled()
+            and menu_item_exists(popup_menu, self.PAR.ops.edit_cell_label)
+        ):
+            datarn, datacn = self.datarn(self.selected.row), self.datacn(self.selected.column)
+            if self.is_readonly(datarn, datacn):
+                popup_menu.entryconfig(self.PAR.ops.edit_cell_label, image="", state="disabled")
+            else:
+                popup_menu.entryconfig(self.PAR.ops.edit_cell_label, image=self.PAR.ops.edit_cell_image, state="normal")
+        # index
+        if (
+            self.selected
+            and self.index_edit_cell_enabled()
+            and menu_item_exists(popup_menu, self.PAR.ops.edit_index_label)
+        ):
+            datarn = self.datarn(self.selected.row)
+            if self.RI.is_readonly(datarn):
+                popup_menu.entryconfig(self.PAR.ops.edit_index_label, image="", state="disabled")
+            else:
+                popup_menu.entryconfig(
+                    self.PAR.ops.edit_index_label, image=self.PAR.ops.edit_index_image, state="normal"
+                )
+        # header
+        if (
+            self.selected
+            and self.header_edit_cell_enabled()
+            and menu_item_exists(popup_menu, self.PAR.ops.edit_header_label)
+        ):
+            datacn = self.datacn(self.selected.column)
+            if self.CH.is_readonly(datacn):
+                popup_menu.entryconfig(self.PAR.ops.edit_header_label, image="", state="disabled")
+            else:
+                popup_menu.entryconfig(
+                    self.PAR.ops.edit_header_label, image=self.PAR.ops.edit_header_image, state="normal"
+                )
+
+    def popup_menu_disable_undo_redo(self, popup_menu: tk.Menu) -> None:
+        if not self.undo_enabled:
+            return
+        if menu_item_exists(popup_menu, self.PAR.ops.undo_label):
+            if not self.undo_stack:
+                popup_menu.entryconfig(self.PAR.ops.undo_label, image="", state="disabled")
+            else:
+                popup_menu.entryconfig(self.PAR.ops.undo_label, image=self.PAR.ops.undo_image, state="normal")
+            if not self.redo_stack:
+                popup_menu.entryconfig(self.PAR.ops.redo_label, image="", state="disabled")
+            else:
+                popup_menu.entryconfig(self.PAR.ops.redo_label, image=self.PAR.ops.redo_image, state="normal")
+
     def rc(self, event: Any = None) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
@@ -3598,6 +3761,8 @@ class MainTable(tk.Canvas):
                     popup_menu = self.empty_rc_popup_menu
         try_binding(self.extra_rc_func, event)
         if popup_menu:
+            self.popup_menu_disable_edit_if_readonly(popup_menu)
+            self.popup_menu_disable_undo_redo(popup_menu)
             popup_menu.tk_popup(event.x_root, event.y_root)
 
     def b1_press(self, event: Any = None) -> None:
@@ -4117,16 +4282,23 @@ class MainTable(tk.Canvas):
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] + 1, self.PAR.ops.table_font[2]),
             (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] + 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] + 1, self.PAR.ops.header_font[2]),
+            (self.PAR.ops.popup_menu_font[0], self.PAR.ops.popup_menu_font[1] + 1, self.PAR.ops.popup_menu_font[2]),
             "in",
         )
 
     def zoom_out(self, event: Any = None) -> None:
-        if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
+        if (
+            self.PAR.ops.table_font[1] < 2
+            or self.PAR.ops.index_font[1] < 2
+            or self.PAR.ops.header_font[1] < 2
+            or self.PAR.ops.popup_menu_font[1] < 2
+        ):
             return
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] - 1, self.PAR.ops.table_font[2]),
             (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] - 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] - 1, self.PAR.ops.header_font[2]),
+            (self.PAR.ops.popup_menu_font[0], self.PAR.ops.popup_menu_font[1] - 1, self.PAR.ops.popup_menu_font[2]),
             "out",
         )
 
@@ -4135,6 +4307,7 @@ class MainTable(tk.Canvas):
         table_font: FontTuple,
         index_font: FontTuple,
         header_font: FontTuple,
+        popup_font: FontTuple,
         zoom: Literal["in", "out"],
     ) -> None:
         self.saved_column_widths = {}
@@ -4157,6 +4330,7 @@ class MainTable(tk.Canvas):
         self.set_table_font(table_font, row_heights=False)
         self.set_index_font(index_font, row_heights=False)
         self.set_header_font(header_font)
+        self.PAR.ops.popup_menu_font = FontTuple(*popup_font)
         if self.PAR.ops.set_cell_sizes_on_zoom:
             self.set_all_cell_sizes_to_text()
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
@@ -4176,6 +4350,7 @@ class MainTable(tk.Canvas):
             r_pc=r_pc,
             c_pc=c_pc,
         )
+        self.create_rc_menus()
 
     def get_txt_w(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
@@ -4254,7 +4429,7 @@ class MainTable(tk.Canvas):
             not isinstance(newfont, tuple)
             or len(newfont) != 3
             or not isinstance(newfont[0], str)
-            or not isinstance(newfont[1], int)
+            or not isinstance(newfont[1], (int, float))
             or not isinstance(newfont[2], str)
         ):
             raise ValueError(font_value_error)
@@ -4262,7 +4437,7 @@ class MainTable(tk.Canvas):
     def set_table_font(self, newfont: tuple | None = None, row_heights: bool = True) -> tuple[str, int, str]:
         if newfont:
             self.check_font(newfont)
-            self.PAR.ops.table_font = FontTuple(*newfont)
+            self.PAR.ops.table_font = FontTuple(*(newfont[0], int(round(newfont[1])), newfont[2]))
             old_min_row_height = int(self.min_row_height)
             old_default_row_height = int(self.get_default_row_height())
             self.set_table_font_help()
@@ -4303,7 +4478,7 @@ class MainTable(tk.Canvas):
     def set_index_font(self, newfont: tuple | None = None, row_heights: bool = True) -> tuple[str, int, str]:
         if newfont:
             self.check_font(newfont)
-            self.PAR.ops.index_font = FontTuple(*newfont)
+            self.PAR.ops.index_font = FontTuple(*(newfont[0], int(round(newfont[1])), newfont[2]))
             old_min_row_height = int(self.min_row_height)
             old_default_row_height = int(self.get_default_row_height())
             self.set_index_font_help()
@@ -4347,7 +4522,7 @@ class MainTable(tk.Canvas):
     def set_header_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
         if newfont:
             self.check_font(newfont)
-            self.PAR.ops.header_font = FontTuple(*newfont)
+            self.PAR.ops.header_font = FontTuple(*(newfont[0], int(round(newfont[1])), newfont[2]))
             self.set_header_font_help()
             self.recreate_all_selection_boxes()
         return self.PAR.ops.header_font