suggestion to add an undo/redo system to widgets

[antrrax]

Is your feature request related to a problem? Please describe.

It would be interesting to have a global system linked to ttkbootstrap to control undo / redo when necessary. The suggested code was created by IA, but it is functional. I don't know if it needs any kind of correction or modification, so I'm posting it here and not as a pr

Describe the solution you'd like

The code below works with Entry, Spinbox, DateEntry, Text, tk ScrolledText and ttk ScrolledText, I don't know if there is any other widget that requires undo/redo:

undo_redo_manager.py

import tkinter as tk
from typing import List, Tuple

import ttkbootstrap as ttk
from ttkbootstrap.scrolled import ScrolledText
from ttkbootstrap.widgets import DateEntry


class UndoRedoManager:
    def __init__(self, widget, max_history: int = 20):
        """Initialize the undo/redo manager for a widget."""
        self.widget = widget
        self.max_history = max_history
        self.history: List[Tuple[str, int]] = []  # Stores (content, cursor_position)
        self.current_index = -1  # Current position in history
        self.is_undoing = False  # Flag to prevent recursion during undo/redo
        self._save_pending = False  # Flag for scheduled saves
        self._last_content = ""  # Used to detect actual changes

        self._save_state()
        self._bind_events()

    def _get_inner_widget(self):
        """Get the actual inner widget for different widget types."""
        if isinstance(self.widget, DateEntry):
            return self.widget.entry
        elif isinstance(self.widget, ScrolledText):
            return self.widget.text
        return self.widget

    def _get_content(self) -> str:
        """Get the current content of the widget."""
        w = self._get_inner_widget()
        try:
            if isinstance(w, (ttk.Entry, ttk.Spinbox, tk.Entry)):
                return w.get()
            elif isinstance(w, tk.Text):
                return w.get("1.0", "end-1c")
        except tk.TclError:
            pass
        return ""

    def _set_content(self, content: str):
        """Set the content of the widget."""
        w = self._get_inner_widget()
        try:
            if isinstance(w, (ttk.Entry, ttk.Spinbox, tk.Entry)):
                w.delete(0, "end")
                w.insert(0, content)
            elif isinstance(w, tk.Text):
                w.delete("1.0", "end")
                w.insert("1.0", content)
        except tk.TclError:
            pass

    def _get_cursor_pos(self) -> int:
        """Get the current cursor position."""
        w = self._get_inner_widget()
        try:
            if isinstance(w, (ttk.Entry, ttk.Spinbox, tk.Entry)):
                return w.index("insert")
            elif isinstance(w, tk.Text):
                return len(w.get("1.0", "insert"))
        except tk.TclError:
            pass
        return 0

    def _set_cursor_pos(self, pos: int):
        """Set the cursor position."""
        w = self._get_inner_widget()
        content = self._get_content()
        pos = max(0, min(pos, len(content)))

        try:
            if isinstance(w, (ttk.Entry, ttk.Spinbox, tk.Entry)):
                w.icursor(pos)
            elif isinstance(w, tk.Text):
                lines = content[:pos].split("\n")
                if lines:
                    line_num = len(lines)
                    col_num = len(lines[-1]) if lines else 0
                    index = f"{line_num}.{col_num}"
                    w.mark_set("insert", index)
        except tk.TclError:
            pass

    def _save_state(self):
        """Save the current state to history."""
        if self.is_undoing or self._save_pending:
            return

        content = self._get_content()
        cursor_pos = self._get_cursor_pos()

        # Don't save if content hasn't changed
        if (
            self.history
            and self.current_index >= 0
            and self.history[self.current_index][0] == content
        ):
            return

        # Truncate future history if we're in the middle
        self.history = self.history[: self.current_index + 1]
        self.history.append((content, cursor_pos))
        self.current_index = len(self.history) - 1

        # Keep only max history
        if len(self.history) > self.max_history:
            self.history = self.history[-self.max_history :]
            self.current_index = len(self.history) - 1

        # Update last known content
        self._last_content = content

    def _bind_events(self):
        """Bind events to widgets."""
        w = self._get_inner_widget()

        # Common events
        common_events = {
            "<KeyRelease>": self._on_change,
            "<ButtonRelease>": self._on_change,
            "<Control-v>": self._on_paste,
            "<Control-V>": self._on_paste,
            "<Control-z>": self._undo,
            "<Control-y>": self._redo,
            "<Control-Z>": self._undo,
            "<Control-Y>": self._redo,
        }

        for event, callback in common_events.items():
            # Use add=True to not overwrite existing bindings
            w.bind(event, callback, add=True)

        # Capture paste events (including right-click)
        paste_events = ["<<Paste>>", "<<Selection>>"]
        for event in paste_events:
            try:
                w.bind(event, self._on_paste_event, add=True)
            except tk.TclError:
                pass

        # Spinbox-specific events
        if isinstance(self.widget, ttk.Spinbox):
            for evt in ("<MouseWheel>", "<Button-4>", "<Button-5>"):
                self.widget.bind(evt, self._on_mousewheel, add=True)

        # DateEntry-specific events
        if isinstance(self.widget, DateEntry):
            self.widget.bind(
                "<<DateEntrySelected>>",
                lambda e: self.widget.after(10, self._save_state),
                add=True,
            )
            self.widget.bind("<FocusIn>", lambda e: self._save_state(), add=True)

        # Periodically monitor changes to capture right-click paste
        self._monitor_changes()

    def _monitor_changes(self):
        """Monitor content changes periodically."""
        if not self.is_undoing:
            current_content = self._get_content()
            if current_content != self._last_content:
                self._save_state()
                self._last_content = current_content

        # Schedule next check
        self.widget.after(100, self._monitor_changes)

    def _on_paste_event(self, event=None):
        """Handler for automatic paste events."""
        # Schedule save after paste is processed
        self.widget.after(10, self._save_state)
        return None

    def _on_paste(self, event=None):
        """Handler for paste events via Ctrl+V."""
        w = self._get_inner_widget()

        try:
            if isinstance(w, (ttk.Entry, ttk.Spinbox, tk.Entry)):
                if w.select_present():
                    start = w.index("sel.first")
                    end = w.index("sel.last")
                    w.delete(start, end)
                    w.icursor(start)
            elif isinstance(w, tk.Text):
                if w.tag_ranges("sel"):
                    start = w.index("sel.first")
                    end = w.index("sel.last")
                    w.delete(start, end)
                    w.mark_set("insert", start)
        except tk.TclError:
            pass

        # Schedule save after paste
        self.widget.after(10, self._save_state)
        return None

    def _on_change(self, event=None):
        """Handler for content changes."""
        if self.is_undoing:
            return

        # Ignore Ctrl+A (select all)
        if event and event.keysym.lower() == "a" and (event.state & 0x4):
            return

        self._schedule_save()

    def _on_mousewheel(self, event=None):
        """Handler for mouse wheel events in Spinbox."""
        if not self.is_undoing:
            self.widget.focus_set()
            self._schedule_save()

    def _schedule_save(self):
        """Schedule state save to avoid multiple operations."""
        if not self._save_pending:
            self._save_pending = True
            self.widget.after_idle(self._perform_save)

    def _perform_save(self):
        """Perform the actual state save."""
        self._save_pending = False
        if not self.is_undoing:
            self._save_state()

    def _undo(self, event=None):
        """Undo the last operation."""
        if self.current_index > 0:
            self.is_undoing = True
            try:
                self.current_index -= 1
                content, cursor_pos = self.history[self.current_index]
                self._set_content(content)
                self._set_cursor_pos(cursor_pos)
                self._last_content = content  # Update last known content
            finally:
                self.is_undoing = False
        return "break"

    def _redo(self, event=None):
        """Redo the next operation."""
        if self.current_index < len(self.history) - 1:
            self.is_undoing = True
            try:
                self.current_index += 1
                content, cursor_pos = self.history[self.current_index]
                self._set_content(content)
                self._set_cursor_pos(cursor_pos)
                self._last_content = content  # Update last known content
            finally:
                self.is_undoing = False
        return "break"

    def clear_history(self):
        """Clear undo/redo history."""
        self.history.clear()
        self.current_index = -1
        self._save_state()

    def can_undo(self) -> bool:
        """Check if undo is possible."""
        return self.current_index > 0

    def can_redo(self) -> bool:
        """Check if redo is possible."""
        return self.current_index < len(self.history) - 1

    def get_history_info(self) -> dict:
        """Return information about the history."""
        return {
            "total_states": len(self.history),
            "current_index": self.current_index,
            "can_undo": self.can_undo(),
            "can_redo": self.can_redo(),
            "max_history": self.max_history,
        }

example of use:

import locale
from tkinter.scrolledtext import ScrolledText as TkScrolledText

import ttkbootstrap as ttk
from ttkbootstrap.scrolled import ScrolledText
from ttkbootstrap.widgets import DateEntry
from undo_redo_manager import UndoRedoManager


class DemoApp:
    def __init__(self, root):
        self.root = root
        self.root.title("TTK Bootstrap Undo/Redo Demo")
        self.root.geometry("800x600")

        # Create main frame
        self.main_frame = ttk.Frame(self.root, padding=10)
        self.main_frame.pack(fill="both", expand=True)

        # Title and instructions
        self.title_label = ttk.Label(
            self.main_frame, text="Undo/Redo Demo", font=("Arial", 16, "bold")
        )
        self.title_label.pack(pady=(0, 10))

        self.instructions = ttk.Label(
            self.main_frame,
            text="Use Ctrl+Z to undo and Ctrl+Y to redo. All changes are tracked.",
            font=("Arial", 10),
        )
        self.instructions.pack(pady=(0, 15))

        # Entry widget
        self.entry_frame = ttk.LabelFrame(
            self.main_frame, text="Entry Widget", padding=5
        )
        self.entry_frame.pack(fill="x", pady=(0, 5))
        self.entry = ttk.Entry(self.entry_frame, font=("Arial", 12))
        self.entry.pack(fill="x", padx=5, pady=5)
        self.entry_manager = UndoRedoManager(self.entry)

        # Spinbox widget
        self.spinbox_frame = ttk.LabelFrame(
            self.main_frame, text="Spinbox Widget (use mouse wheel)", padding=5
        )
        self.spinbox_frame.pack(fill="x", pady=(0, 5))
        self.spinbox = ttk.Spinbox(
            self.spinbox_frame, from_=0, to=100, font=("Arial", 12)
        )
        self.spinbox.pack(fill="x", padx=5, pady=5)
        self.spinbox_manager = UndoRedoManager(self.spinbox)

        # DateEntry widget with system-native date format
        self.date_frame = ttk.LabelFrame(
            self.main_frame, text="DateEntry Widget", padding=10
        )
        self.date_frame.pack(fill="x", pady=(0, 10))

        try:
            locale.setlocale(locale.LC_ALL, "")
        except locale.Error:
            locale.setlocale(locale.LC_ALL, "C")

        self.date_entry = DateEntry(self.date_frame)
        self.date_entry.pack(fill="x")
        self.date_manager = UndoRedoManager(self.date_entry)

        # Text widget
        self.text_frame = ttk.LabelFrame(self.main_frame, text="Text Widget", padding=5)
        self.text_frame.pack(fill="x", pady=(0, 5))
        self.text_widget = ttk.Text(self.text_frame, height=2, font=("Arial", 12))
        self.text_widget.pack(fill="x", padx=5, pady=5)
        self.text_manager = UndoRedoManager(self.text_widget)

        # ScrolledText widget (ttkbootstrap)
        self.scrolled_frame = ttk.LabelFrame(
            self.main_frame, text="ScrolledText Widget (ttkbootstrap)", padding=5
        )
        self.scrolled_frame.pack(fill="x", pady=(0, 5))
        self.scrolled_text = ScrolledText(self.scrolled_frame, height=2, autohide=True)
        self.scrolled_text.pack(fill="x", padx=5, pady=5)
        self.scrolled_manager = UndoRedoManager(self.scrolled_text)

        # ScrolledText do Tkinter
        self.tk_scrolled_frame = ttk.LabelFrame(
            self.main_frame, text="ScrolledText Widget (Tkinter)", padding=5
        )
        self.tk_scrolled_frame.pack(fill="x", pady=(0, 5))

        self.tk_scrolled_text = TkScrolledText(
            self.tk_scrolled_frame, height=2, font=("Arial", 12)
        )
        self.tk_scrolled_text.pack(fill="x", padx=5, pady=5)
        self.tk_scrolled_manager = UndoRedoManager(self.tk_scrolled_text)


def main():
    root = ttk.Window(themename="cosmo")
    app = DemoApp(root)
    root.mainloop() 

if __name__ == "__main__":
    main()

Describe alternatives you've considered

another usage example, with context menu - example_advanced_context_menu.py:

import tkinter as tk

import ttkbootstrap as ttk
from undo_redo_manager import UndoRedoManager


class DemoApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Advanced Context Menu")
        self.root.geometry("500x200")

        self.entry = ttk.Entry(self.root, font=("Arial", 12))
        self.entry.pack(fill="x", padx=20, pady=50)

        self.undo_manager = UndoRedoManager(self.entry)
        self.context_menu = tk.Menu(self.root, tearoff=0)
        self.setup_events()

    def setup_events(self):
        self.entry.bind("<Button-3>", self.show_context_menu)
        self.entry.bind("<Key>", self.on_key_press)

        # Modificado para forçar atualização do undo/redo
        self.entry.bind("<<Paste>>", self.handle_paste)
        self.entry.bind("<<Cut>>", lambda e: self.close_context_menu())
        self.entry.bind("<<Clear>>", lambda e: self.close_context_menu())

        self.root.bind("<Button-1>", lambda e: self.close_context_menu())
        self.root.bind("<FocusOut>", lambda e: self.close_context_menu())
        self.root.bind("<Unmap>", lambda e: self.close_context_menu())

    def handle_paste(self, event):
        """Handler especial para colagem com atualização do estado"""
        self.close_context_menu()
        self.entry.after(10, self.force_undo_update)

    def force_undo_update(self):
        """Força atualização do estado do undo/redo"""
        if hasattr(self.undo_manager, "_save_state"):
            self.undo_manager._save_state()

    def on_key_press(self, event):
        if event.keysym not in [
            "Shift_L",
            "Shift_R",
            "Control_L",
            "Control_R",
            "Alt_L",
            "Alt_R",
            "Tab",
            "Up",
            "Down",
            "Left",
            "Right",
        ]:
            self.close_context_menu()

    def show_context_menu(self, event):
        # Verificação imediata do estado
        can_undo = self.undo_manager.current_index > 0
        can_redo = self.undo_manager.current_index < len(self.undo_manager.history) - 1

        self.context_menu.delete(0, "end")
        commands = [
            ("Desfazer (Ctrl+Z)", self.undo, can_undo),
            ("Refazer (Ctrl+Y)", self.redo, can_redo),
            ("Recortar (Ctrl+X)", self.cut, self.entry.selection_present()),
            ("Copiar (Ctrl+C)", self.copy, self.entry.selection_present()),
            ("Colar (Ctrl+V)", self.paste, self.check_clipboard()),
            ("Excluir", self.delete, self.entry.selection_present()),
            ("Selecionar Tudo (Ctrl+A)", self.select_all, bool(self.entry.get())),
        ]

        for i, (label, cmd, condition) in enumerate(commands):
            if i == 2:
                self.context_menu.add_separator()
            self.context_menu.add_command(
                label=label, command=cmd, state="normal" if condition else "disabled"
            )

        self.context_menu.post(event.x_root, event.y_root)

    def check_clipboard(self):
        try:
            return bool(self.root.clipboard_get())
        except tk.TclError:
            return False

    def close_context_menu(self, event=None):
        if self.context_menu.winfo_ismapped():
            self.context_menu.unpost()

    # Métodos de comandos (mantidos originais)
    def undo(self):
        self.undo_manager._undo()

    def redo(self):
        self.undo_manager._redo()

    def cut(self):
        self.entry.event_generate("<<Cut>>")

    def copy(self):
        self.entry.event_generate("<<Copy>>")

    def paste(self):
        self.entry.event_generate("<<Paste>>")

    def delete(self):
        if self.entry.selection_present():
            self.entry.delete(tk.SEL_FIRST, tk.SEL_LAST)

    def select_all(self):
        self.entry.select_range(0, tk.END)
        self.entry.icursor(tk.END)


if __name__ == "__main__":
    root = ttk.Window(themename="cosmo")
    app = DemoApp(root)
    root.mainloop()

Additional context

No response

[antrrax]

another suggestion is a menu system with integrated undo/redo

text_context_menu.py

import tkinter as tk
import weakref
from typing import Any, Callable, Dict, List, Optional, Union

import ttkbootstrap as ttk
from ttkbootstrap.scrolled import ScrolledText
from ttkbootstrap.widgets import DateEntry


class TextContextMenu:
    """A comprehensive context menu for text widgets with undo/redo support."""

    _open_menus: List[
        weakref.ReferenceType
    ] = []  # Use weak references to prevent memory leaks
    _global_handler_registered = False

    def __init__(
        self,
        widget: Union[
            tk.Text,
            ttk.Text,
            tk.Entry,
            ttk.Entry,
            DateEntry,
            ScrolledText,
            tk.Spinbox,
            ttk.Spinbox,
        ],
        undo_manager: Optional[object] = None,
        menu_items: Optional[List[Dict[str, Any]]] = None,
        default_items: bool = True,
        style: Optional[str] = None,
    ):
        """
        Initialize the TextContextMenu.

        Args:
            widget: The widget to attach the context menu to
            undo_manager: Optional undo manager object with can_undo(), can_redo(), _undo(), _redo() methods
            menu_items: Custom menu items list
            default_items: Whether to include default menu items
            style: Optional style for the menu
        """
        self.widget = widget
        self.undo_manager = undo_manager
        self._menu_ref: Optional[weakref.ReferenceType] = None

        # Create menu with optional styling
        menu_kwargs = {"tearoff": 0}
        if style:
            menu_kwargs["style"] = style
        self.menu = tk.Menu(widget, **menu_kwargs)
        self._menu_ref = weakref.ref(self.menu)

        # Store reference to this context menu in the widget for cleanup
        widget._textcontextmenu = self

        # Initialize menu items
        if menu_items is None and default_items:
            self.menu_items = self._get_default_menu_items()
        else:
            self.menu_items = menu_items or []

        self._setup_bindings()
        self._register_global_handler()

    def _get_default_menu_items(self) -> List[Dict[str, Any]]:
        """Get the default menu items for text operations."""
        return [
            {
                "label": "Desfazer (Ctrl+Z)",
                "command": "undo",
                "condition": lambda: self._can_undo(),
                "separator_before": False,
                "accelerator": "Ctrl+Z",
            },
            {
                "label": "Refazer (Ctrl+Y)",
                "command": "redo",
                "condition": lambda: self._can_redo(),
                "separator_before": False,
                "accelerator": "Ctrl+Y",
            },
            {
                "label": "Recortar (Ctrl+X)",
                "command": "cut",
                "condition": lambda: self._has_selection(),
                "separator_before": True,
                "accelerator": "Ctrl+X",
            },
            {
                "label": "Copiar (Ctrl+C)",
                "command": "copy",
                "condition": lambda: self._has_selection(),
                "separator_before": False,
                "accelerator": "Ctrl+C",
            },
            {
                "label": "Colar (Ctrl+V)",
                "command": "paste",
                "condition": lambda: self._clipboard_has_content(),
                "separator_before": False,
                "accelerator": "Ctrl+V",
            },
            {
                "label": "Excluir",
                "command": "delete",
                "condition": lambda: self._has_selection(),
                "separator_before": False,
                "accelerator": "Del",
            },
            {
                "label": "Selecionar Tudo (Ctrl+A)",
                "command": "select_all",
                "condition": lambda: bool(self._get_widget_content()),
                "separator_before": True,
                "accelerator": "Ctrl+A",
            },
        ]

    def _setup_bindings(self):
        """Set up event bindings for the widget."""
        # Right-click to show menu
        self.widget.bind("<Button-3>", self._on_right_click)

        # Events that should close the menu
        close_events = [
            "<Button-1>",
            "<Button-2>",
            "<FocusOut>",
            "<Unmap>",
            "<<Paste>>",
            "<<Cut>>",
            "<<Clear>>",
            "<Key>",
        ]

        for event in close_events:
            self.widget.bind(event, self._close_menu_on_event, add=True)

    def _register_global_handler(self):
        """Register global click handler only once."""
        if not TextContextMenu._global_handler_registered:
            self.widget.winfo_toplevel().bind_all(
                "<Button>", self._global_click_handler
            )
            TextContextMenu._global_handler_registered = True

    def _on_right_click(self, event):
        """Handle right-click to show context menu."""
        try:
            self.show_menu(event)
            return "break"  # Prevent default behavior
        except Exception as e:
            print(f"Error showing context menu: {e}")
            return None

    def _global_click_handler(self, event):
        """Handle all mouse clicks in the application."""
        if event.num == 3:  # Right click
            return

        # Get widget under mouse pointer
        try:
            widget_under_cursor = event.widget.winfo_containing(
                event.x_root, event.y_root
            )
        except (tk.TclError, AttributeError):
            widget_under_cursor = None

        # Close menu if click was not on this widget, menu, or another text widget with context menu
        if not self._should_keep_menu_open(widget_under_cursor):
            self.close_all_menus()

    def _should_keep_menu_open(self, widget_under_cursor) -> bool:
        """Determine if the menu should stay open based on the clicked widget."""
        if widget_under_cursor is None:
            return False

        # Keep open if clicked on this widget
        if widget_under_cursor == self.widget:
            return True

        # Keep open if clicked on the menu itself
        if isinstance(widget_under_cursor, tk.Menu):
            return True

        # Keep open if clicked on another text widget with context menu
        if hasattr(widget_under_cursor, "_textcontextmenu") and hasattr(
            widget_under_cursor._textcontextmenu, "menu"
        ):
            return True

        return False

    @classmethod
    def close_all_menus(cls):
        """Close all open context menus."""
        for menu_ref in cls._open_menus[:]:  # Iterate over a copy
            menu = menu_ref()
            if menu is not None:
                try:
                    if menu.winfo_ismapped():
                        menu.unpost()
                except tk.TclError:
                    pass
            cls._open_menus.remove(menu_ref)

    def _get_inner_widget(self):
        """Get the actual text widget for composite widgets."""
        if isinstance(self.widget, DateEntry):
            return self.widget.entry
        elif isinstance(self.widget, ScrolledText):
            return self.widget.text
        return self.widget

    def _get_widget_content(self) -> str:
        """Get the content of the widget."""
        widget = self._get_inner_widget()
        try:
            if isinstance(widget, (ttk.Entry, ttk.Spinbox, tk.Entry, tk.Spinbox)):
                return widget.get()
            elif isinstance(widget, (tk.Text, ttk.Text)):
                return widget.get("1.0", "end-1c")
        except tk.TclError:
            pass
        return ""

    def _has_selection(self) -> bool:
        """Check if the widget has selected text."""
        widget = self._get_inner_widget()
        try:
            if isinstance(widget, (ttk.Entry, ttk.Spinbox, tk.Entry, tk.Spinbox)):
                return widget.select_present()
            elif isinstance(widget, (tk.Text, ttk.Text)):
                return bool(widget.tag_ranges("sel"))
        except tk.TclError:
            pass
        return False

    def _clipboard_has_content(self) -> bool:
        """Check if clipboard has content."""
        try:
            content = self.widget.clipboard_get()
            return bool(content and content.strip())
        except tk.TclError:
            return False

    def _can_undo(self) -> bool:
        """Check if undo is available."""
        return (
            self.undo_manager is not None
            and hasattr(self.undo_manager, "can_undo")
            and self.undo_manager.can_undo()
        )

    def _can_redo(self) -> bool:
        """Check if redo is available."""
        return (
            self.undo_manager is not None
            and hasattr(self.undo_manager, "can_redo")
            and self.undo_manager.can_redo()
        )

    def _execute_command(self, command: Union[str, Callable]):
        """Execute a menu command."""
        try:
            if isinstance(command, str):
                self._execute_string_command(command)
            elif callable(command):
                command()
                self._save_undo_state()
        except Exception as e:
            print(f"Error executing command '{command}': {e}")

    def _execute_string_command(self, command: str):
        """Execute a string-based command."""
        command_map = {
            "undo": self._execute_undo,
            "redo": self._execute_redo,
            "cut": self._execute_cut,
            "copy": self._execute_copy,
            "paste": self._execute_paste,
            "delete": self._execute_delete,
            "select_all": self._execute_select_all,
        }

        if command in command_map:
            command_map[command]()
        else:
            print(f"Unknown command: {command}")

    def _execute_undo(self):
        """Execute undo command."""
        if self.undo_manager and hasattr(self.undo_manager, "_undo"):
            self.undo_manager._undo()

    def _execute_redo(self):
        """Execute redo command."""
        if self.undo_manager and hasattr(self.undo_manager, "_redo"):
            self.undo_manager._redo()

    def _execute_cut(self):
        """Execute cut command."""
        self.widget.event_generate("<<Cut>>")
        self._save_undo_state()

    def _execute_copy(self):
        """Execute copy command."""
        self.widget.event_generate("<<Copy>>")

    def _execute_paste(self):
        """Execute paste command."""
        self.widget.event_generate("<<Paste>>")
        self._save_undo_state()

    def _execute_delete(self):
        """Execute delete command."""
        if not self._has_selection():
            return

        widget = self._get_inner_widget()
        try:
            if isinstance(widget, (ttk.Entry, ttk.Spinbox, tk.Entry, tk.Spinbox)):
                widget.delete(tk.SEL_FIRST, tk.SEL_LAST)
            elif isinstance(widget, (tk.Text, ttk.Text)):
                widget.delete("sel.first", "sel.last")
            self._save_undo_state()
        except tk.TclError:
            pass

    def _execute_select_all(self):
        """Execute select all command."""
        widget = self._get_inner_widget()
        try:
            if isinstance(widget, (ttk.Entry, ttk.Spinbox, tk.Entry, tk.Spinbox)):
                widget.select_range(0, tk.END)
                widget.icursor(tk.END)
            elif isinstance(widget, (tk.Text, ttk.Text)):
                widget.tag_add("sel", "1.0", "end")
                widget.mark_set("insert", "end")
        except tk.TclError:
            pass

    def _save_undo_state(self):
        """Save state for undo manager."""
        if self.undo_manager and hasattr(self.undo_manager, "_save_state"):
            self.widget.after(10, self.undo_manager._save_state)

    def show_menu(self, event):
        """Show the context menu."""
        self.close_all_menus()
        self._build_menu()

        # Add to open menus list
        if self._menu_ref not in TextContextMenu._open_menus:
            TextContextMenu._open_menus.append(self._menu_ref)

        try:
            self.menu.post(event.x_root, event.y_root)
            self.widget.focus_set()  # Maintain focus
        except tk.TclError as e:
            print(f"Error posting menu: {e}")

    def _build_menu(self):
        """Build the menu from menu items."""
        self.menu.delete(0, "end")

        for item in self.menu_items:
            condition = item.get("condition", lambda: True)
            if not callable(condition):
                condition = lambda c=condition: bool(c)

            # Add separator if requested
            if item.get("separator_before", False):
                self.menu.add_separator()

            # Determine state
            state = "normal" if self._evaluate_condition(condition) else "disabled"

            # Add menu item
            menu_kwargs = {
                "label": item["label"],
                "command": lambda cmd=item["command"]: self._execute_command(cmd),
                "state": state,
            }

            # Add accelerator if provided
            if "accelerator" in item:
                menu_kwargs["accelerator"] = item["accelerator"]

            self.menu.add_command(**menu_kwargs)

    def _evaluate_condition(self, condition: Callable) -> bool:
        """Safely evaluate a condition function."""
        try:
            return condition()
        except Exception as e:
            print(f"Error evaluating menu condition: {e}")
            return False

    def _close_menu_on_event(self, event=None):
        """Close menu on specific events."""
        self.close_menu()

    def close_menu(self, event=None):
        """Close this specific menu."""
        if self._menu_ref in TextContextMenu._open_menus:
            TextContextMenu._open_menus.remove(self._menu_ref)
        try:
            if self.menu.winfo_ismapped():
                self.menu.unpost()
        except tk.TclError:
            pass

    def add_item(self, item: Dict[str, Any], index: Optional[int] = None):
        """Add a custom item to the menu."""
        if not isinstance(item, dict) or "label" not in item or "command" not in item:
            raise ValueError("Menu item must be a dict with 'label' and 'command' keys")

        if index is None:
            self.menu_items.append(item)
        else:
            self.menu_items.insert(index, item)

    def remove_item(self, label: str):
        """Remove an item from the menu by label."""
        self.menu_items = [
            item for item in self.menu_items if item.get("label") != label
        ]

    def update_item(self, label: str, new_config: Dict[str, Any]):
        """Update an existing menu item."""
        for item in self.menu_items:
            if item.get("label") == label:
                item.update(new_config)
                return True
        return False

    def clear_items(self):
        """Clear all menu items."""
        self.menu_items = []

    def set_items(self, items: List[Dict[str, Any]]):
        """Replace all menu items with new ones."""
        self.menu_items = items[:]

    def get_items(self) -> List[Dict[str, Any]]:
        """Get a copy of current menu items."""
        return self.menu_items[:]

    def destroy(self):
        """Clean up the context menu."""
        self.close_menu()
        if hasattr(self.widget, "_textcontextmenu"):
            delattr(self.widget, "_textcontextmenu")
        try:
            self.menu.destroy()
        except tk.TclError:
            pass

    def __del__(self):
        """Cleanup when object is garbage collected."""
        try:
            self.destroy()
        except:
            pass

Basic Usage with Default Items:

import ttkbootstrap as ttk
from text_context_menu import TextContextMenu
from undo_redo_manager import UndoRedoManager

root = ttk.Window()
entry = ttk.Entry(root)
entry.focus_set()
entry.pack()

undo_manager = UndoRedoManager(entry)
context_menu = TextContextMenu(entry, undo_manager)

root.mainloop()

Custom Menu Items

import ttkbootstrap as ttk
from text_context_menu import TextContextMenu

root = ttk.Window()
text = ttk.Text(root)
text.focus_set()
text.pack()

custom_items = [
    {
        "label": "Uppercase",
        "command": lambda: text.replace(
            "sel.first", "sel.last", text.get("sel.first", "sel.last").upper()
        ),
        "condition": lambda: bool(text.tag_ranges("sel")),
        "separator_before": False,
    },
    {
        "label": "Lowercase",
        "command": lambda: text.replace(
            "sel.first", "sel.last", text.get("sel.first", "sel.last").lower()
        ),
        "condition": lambda: bool(text.tag_ranges("sel")),
        "separator_before": False,
    },
    {
        "label": "Clear All",
        "command": lambda: text.delete("1.0", "end"),
        "condition": lambda: bool(text.get("1.0", "end-1c")),
        "separator_before": True,
    },
]

context_menu = TextContextMenu(text, menu_items=custom_items, default_items=False)
root.mainloop()

Adding Items Dynamically

import ttkbootstrap as ttk
from text_context_menu import TextContextMenu
from undo_redo_manager import UndoRedoManager

root = ttk.Window(themename="mint-y-royal")
spinbox = ttk.Spinbox(root, from_=0, to=100)
spinbox.focus_set()
spinbox.pack()

undo_manager = UndoRedoManager(spinbox)
context_menu = TextContextMenu(spinbox, undo_manager=undo_manager)

context_menu.add_item(
    {
        "label": "Set to 50",
        "command": lambda: spinbox.set(50),
        "condition": lambda: True,
        "separator_before": True,
    }
)

root.mainloop()