bootstack 0.1.8__tar.gz → 0.2.1__tar.gz

{bootstack-0.1.8/src/bootstack.egg-info → bootstack-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.1.8
+Version: 0.2.1
 Summary: Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate.
 Author-email: Israel Dryer <israel.dryer@gmail.com>
 License-Expression: MIT

{bootstack-0.1.8 → bootstack-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bootstack"
-version = "0.1.8"
+version = "0.2.1"
 description = "Build desktop GUI apps in pure Python and ship them as a standalone executable — built on Tk, no Tkinter boilerplate."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -114,7 +114,7 @@ where = ["src"]
 ]
 
 [tool.bumpversion]
-current_version = "0.1.8"
+current_version = "0.2.1"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)((?P<pre>a|b|rc)(?P<pre_n>\\d+))?"
 serialize = [
     "{major}.{minor}.{patch}{pre}{pre_n}",

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/_runtime/base_window.py

@@ -34,14 +34,29 @@ def on_visibility_alpha(event: tkinter.Event) -> None:
     X11 requires alpha to be set after the window is visible, so we bind
     to the <Visibility> event and set alpha then, unbinding after first use.
 
+    Being woken by this event at all is what proves the precondition: X11
+    reports visibility only for a window that is already on screen, so the very
+    first delivery is a valid moment to apply alpha. Whether that first report
+    says obscured or unobscured makes no difference — opacity is a property of
+    the window, not of how much of it happens to be uncovered.
+
+    Alpha is therefore applied before the binding is released, so first use is
+    genuinely the last one needed. Applying first also means that if the request
+    itself fails, the binding is still in place and the next visibility change
+    tries again — the one failure where a retry could help (#398).
+
     Args:
         event: The visibility event containing the widget.
     """
     widget = event.widget
     if hasattr(widget, 'alpha') and hasattr(widget, 'alpha_bind'):
-        if widget.alpha_bind:
-            widget.unbind(widget.alpha_bind)
         widget.attributes("-alpha", widget.alpha)
+        if widget.alpha_bind:
+            # `alpha_bind` is the id `bind` returned, so it is the *funcid*
+            # argument — passing it as the sequence removes nothing at all and
+            # raises nothing either, which is how this stayed unnoticed (#398).
+            widget.unbind("<Visibility>", widget.alpha_bind)
+            widget.alpha_bind = None
 
 
 class BaseWindow:

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/_runtime/events.py

@@ -32,6 +32,7 @@ Note:
     applied globally and affect all tkinter widgets in the application.
 """
 
+import itertools
 import tkinter as tk
 import uuid
 import weakref
@@ -43,9 +44,35 @@ from typing import Any, Callable, Optional, Union
 _event_data_cache: OrderedDict[str, Any] = OrderedDict()
 _MAX_CACHE_SIZE = 100  # Prevent unbounded growth
 
+# Serial number used to give every registered handler a unique name. See
+# `_unique_name` for why the stock naming scheme is not safe here.
+_binding_seq = itertools.count()
+
+
+def _unique_name(prefix: str) -> str:
+    """Return a handler name that can never collide with a previous one.
+
+    Tkinter names the Tcl command behind a binding `repr(id(f)) + f.__name__`,
+    where `f` is a bound method created for that registration alone. Nothing
+    else refers to it, so releasing the command frees the method and CPython is
+    free to hand the very same address to the next one — measured at 498 out of
+    499 consecutive bind/cancel/bind cycles. Every wrapper registered here has
+    the same `__name__`, so the whole name would repeat with it.
+
+    That is harmless while removals delete the command immediately, but
+    `_patched_unbind` defers the deletion to the next idle point. A repeated
+    name means a binding created in the meantime inherits the name a deletion is
+    already pending on, and that deletion then takes out a live handler — the
+    #392 failure again, on a new trigger. A serial number in the name keeps the
+    two apart no matter what the allocator does.
+    """
+    return '%s%d' % (prefix, next(_binding_seq))
+
+
 # Store original tkinter methods before patching
 _original_event_generate: Callable = tk.Misc.event_generate
 _original_bind: Callable = tk.Misc.bind
+_original_unbind: Callable = tk.Misc.unbind
 
 
 def _patched_event_generate(
@@ -219,23 +246,60 @@ def _patched_bind(
                 # Attach custom data (don't pop yet - multiple handlers may need it)
                 if data_guid and data_guid in _event_data_cache:
                     event.data = _event_data_cache[data_guid]
-                    # Schedule cleanup after all handlers have run
-                    widget.after_idle(lambda: _event_data_cache.pop(data_guid, None))
+                    # Schedule cleanup after all handlers have run. On the root,
+                    # not on `widget`: deferred work owned by a widget is torn
+                    # down with it, so a handler that destroys its own widget
+                    # would leave this callback pointing at a command destroy()
+                    # had already swept — a silent background error. The root
+                    # outlives every widget. (Same rule as `_patched_unbind`.)
+                    try:
+                        widget._root().after_idle(
+                            lambda: _event_data_cache.pop(data_guid, None)
+                        )
+                    except (tk.TclError, AttributeError):
+                        # No event loop left to defer onto; the LRU cap reclaims
+                        # the entry instead.
+                        pass
                 else:
                     # Data might have been evicted from cache already
                     event.data = None
 
                 return func(event)
 
-            # Register wrapper function with tkinter
+            # Register wrapper function with tkinter. The name tkinter builds
+            # ends with the function's `__name__`, so making that unique is
+            # enough to keep a deferred deletion off a later binding.
+            wrapper.__name__ = _unique_name('bsvirtual')
             name = self._register(wrapper)
 
-            # Build command with all substitutions including %d for data GUID
+            # Build the binding script. Its exact shape is load-bearing, and
+            # this must stay byte-for-byte what stock `Misc._bind` emits:
+            #
+            #   * Removing a single handler works by matching the line prefix
+            #     `if {"[<funcid> ` — note the TRAILING SPACE, which means the
+            #     substitution list below must never be empty. A script in any
+            #     other shape is invisible to the matcher, so the handler
+            #     survives while its command is deleted, leaving an orphan that
+            #     aborts every handler after it. All handlers for an event share
+            #     ONE concatenated script, so that took out every handler
+            #     registered after the cancelled one (#392).
+            #   * The `if {...} == "break"` test is what lets a handler return
+            #     'break' to stop the remaining handlers for that event.
+            #
+            # (The trailing newline only separates this line from the next
+            # handler's; Tk inserts its own separator when appending a `+`
+            # script. It is kept to match stock exactly.)
+            #
+            # The substitution list carries %d (our data token) ahead of the
+            # standard values; its order must match `wrapper`'s parameters.
             # Substitution codes: https://tcl.tk/man/tcl8.6/TkCmd/bind.htm
-            cmd = f'{name} %d %# %b %h %w %k %s %t %x %y %X %Y %A %K %N %T %E %D'
+            subst = '%d %# %b %h %w %k %s %t %x %y %X %Y %A %K %N %T %E %D'
+            cmd = '%sif {"[%s %s]" == "break"} break\n' % (
+                '+' if add else '', name, subst
+            )
 
             # Bind to widget
-            self.tk.call('bind', self._w, sequence, cmd if not add else '+' + cmd)
+            self.tk.call('bind', self._w, sequence, cmd)
 
             return name
         else:
@@ -246,12 +310,126 @@ def _patched_bind(
                     event.data = None
                 return func(event)
 
+            # Real events are removed by the same patched `unbind`, so they need
+            # the same protection from a recycled name. See `_unique_name`.
+            regular_wrapper.__name__ = _unique_name('bsregular')
             return _original_bind(self, sequence, regular_wrapper, add)
 
     # No function or sequence provided, pass through to original
     return _original_bind(self, sequence, func, add)
 
 
+def _patched_unbind(
+    self: tk.Misc,
+    sequence: str,
+    funcid: Optional[str] = None
+) -> None:
+    """Enhanced unbind that cannot disturb the other handlers for an event.
+
+    Stock tkinter removes one handler in two steps: rewrite the binding script
+    without that handler's line, then delete the Tcl command behind it. The
+    rewrite is correct, but the deletion is immediate — and all handlers for an
+    event share ONE script, so if the removal happens *while that script is
+    running* (a handler cancelling another handler's subscription), execution
+    later reaches the deleted command and the whole script aborts. Every handler
+    after the cancelled one is skipped for that dispatch, and the error surfaces
+    nowhere Python can see it.
+
+    This version neutralizes the command in place instead, then deletes it once
+    the current dispatch has finished. An already-running script then evaluates
+    a harmless no-op where the cancelled handler used to be and carries on to
+    the handlers after it.
+
+    Args:
+        self: The widget instance (automatically provided)
+        sequence: Event sequence the handler was bound to
+        funcid: Identifier returned by `bind`. When omitted, every handler for
+            the sequence is removed and the original implementation is used.
+    """
+    if funcid is None:
+        # Removing everything replaces the whole script, so there is no
+        # surviving line that could reference a deleted command.
+        return _original_unbind(self, sequence)
+
+    what = ('bind', self._w, sequence)
+    try:
+        script = self.tk.call(what)
+    except tk.TclError:
+        # Reading the script is the one step whose failure is expected: the
+        # widget is gone, and its bindings and commands went with it. Nothing
+        # to remove and nothing to leak.
+        return
+
+    lines = str(script).split('\n')
+    # Must match what `_patched_bind` emits (and stock `Misc._bind`).
+    prefix = 'if {"[%s ' % funcid
+    keep = [line for line in lines if not line.startswith(prefix)]
+    if len(keep) == len(lines):
+        # This funcid is not bound to this widget and sequence, so it is
+        # not ours to delete — the live binding may be somewhere else, and
+        # deleting its command would orphan it. Leave everything alone.
+        #
+        # Correct, but it means the command and its closure survive for the
+        # life of the interpreter, invisibly. Surface it in development so the
+        # drift that produced it can be found (#399).
+        #
+        # Reported, not warned. This runs inside event dispatch and on the
+        # teardown path behind `Subscription.cancel()` and its `__exit__`, both
+        # documented as safe to call on a dead or already-removed handler. A
+        # `warnings.warn` here becomes an exception out of both under
+        # `-W error`, which is a worse outcome than the leak it describes.
+        from bootstack._runtime.utility import debug_log
+        debug_log(
+            f"unbind({sequence!r}, {funcid!r}) on {self._w!r} matched no "
+            "binding, so its Tcl command cannot safely be released and will "
+            "leak. The usual cause is an unbind that targeted a different "
+            "widget than the bind did; hold the Subscription that bind() "
+            "returned instead of re-deriving the target."
+        )
+        return
+
+    remaining = '\n'.join(keep)
+    # Deliberately NOT guarded: if the rewrite fails the handler is still bound
+    # and still firing, and swallowing that would report a successful
+    # cancellation for a live handler — a silent wrong answer (#400).
+    self.tk.call(*what, remaining if remaining.strip() else '')
+
+    try:
+        # Replace the command rather than deleting it, so an in-flight copy of
+        # the concatenated script has something harmless to call.
+        self.tk.createcommand(funcid, lambda *args: '')
+    except tk.TclError:
+        # The binding line is already gone, so the handler is genuinely removed
+        # and an in-flight script would find the original command rather than a
+        # deleted one. Fall through to the deferred delete instead of returning,
+        # which would strand the command forever (#400).
+        pass
+
+    def _delete_command() -> None:
+        try:
+            self.deletecommand(funcid)
+        except (tk.TclError, AttributeError):
+            # Already swept, most likely because the widget was destroyed
+            # before the interpreter went idle. `AttributeError` is that same
+            # case seen from the other side: destroy() clears the widget's
+            # command bookkeeping, which `deletecommand` then cannot update.
+            pass
+
+    try:
+        # Deliberately scheduled on the root, not on `self`. Deferred work owned
+        # by a widget is torn down with it, and destroying a widget between the
+        # cancellation and the next idle point would leave the pending callback
+        # referring to a command that destroy() had already deleted — a silent
+        # error of exactly the kind this function exists to avoid. The root
+        # outlives every widget, and when the root itself goes the pending
+        # callback goes with it, which is equally fine: there is nothing left to
+        # clean up.
+        self._root().after_idle(_delete_command)
+    except (tk.TclError, AttributeError):
+        # No event loop left to defer onto; nothing can be mid-dispatch either.
+        _delete_command()
+
+
 def cleanup_event_cache() -> None:
     """Manually clear the entire event data cache.
 
@@ -342,9 +520,10 @@ def get_cache_size() -> int:
 def install_enhanced_events() -> None:
     """Install the enhanced event system by patching tkinter methods.
 
-    This function applies monkey patches to tkinter's Misc class,
-    replacing event_generate and bind with enhanced versions that
-    support passing custom data through virtual events.
+    This function applies monkey patches to tkinter's Misc class, replacing
+    event_generate and bind with enhanced versions that support passing custom
+    data through virtual events, and unbind with a version that cannot disturb
+    the other handlers for an event while one is being removed.
 
     The patches are applied globally and affect all tkinter widgets
     in the application. This function is called automatically when
@@ -364,6 +543,7 @@ def install_enhanced_events() -> None:
     """
     tk.Misc.event_generate = _patched_event_generate
     tk.Misc.bind = _patched_bind
+    tk.Misc.unbind = _patched_unbind
 
 
 def uninstall_enhanced_events() -> None:
@@ -387,6 +567,7 @@ def uninstall_enhanced_events() -> None:
     """
     tk.Misc.event_generate = _original_event_generate
     tk.Misc.bind = _original_bind
+    tk.Misc.unbind = _original_unbind
     cleanup_event_cache()
 
 

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/_runtime/shortcuts.py

@@ -57,13 +57,21 @@ _WIN_NAMES = {
 }
 
 # Tkinter binding modifiers
+#
+# `command` and `option` are platform-mapped for the same reason `mod` and `alt`
+# are. Off macOS the toolkit resolves the words "Command" and "Option" to its
+# generic Mod1 and Mod2 slots, and Windows reports NumLock as Mod1 — so a
+# `Command+S` binding fired on a bare `s` for anyone with NumLock switched on,
+# while the menu beside it read "Ctrl+S". Naming the modifier the display has
+# always claimed keeps the two from disagreeing (#405, and the same trap as
+# #403).
 _BINDING_MODIFIERS = {
     'mod': 'Command' if IS_MAC else 'Control',
-    'command': 'Command',
+    'command': 'Command' if IS_MAC else 'Control',
     'ctrl': 'Control',
     'control': 'Control',
     'alt': 'Option' if IS_MAC else 'Alt',
-    'option': 'Option',
+    'option': 'Option' if IS_MAC else 'Alt',
     'shift': 'Shift',
 }
 

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/_runtime/utility.py

@@ -344,6 +344,28 @@ def _debug_enabled() -> bool:
     return str(os.environ.get("BOOTSTACK_DEBUG", "")).lower() in {"1", "true", "yes"}
 
 
+def debug_log(message: str) -> None:
+    """Print a diagnostic message if debug is enabled.
+
+    For reporting a condition that has no exception behind it. Use
+    `debug_log_exception` when there is one.
+
+    Never raises, and deliberately does not use `warnings.warn`: these fire from
+    inside event dispatch and teardown, where a warning filter set to `error`
+    would turn a diagnostic into a failure on a path documented as safe.
+
+    Args:
+        message: The text to print.
+    """
+    if not _debug_enabled():
+        return
+    try:
+        print(f"bootstack DEBUG: {message}")
+    except Exception:
+        # Never raise from debug logging
+        pass
+
+
 def debug_log_exception(message: str = "") -> None:
     """Print the current exception traceback if debug is enabled.
 

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/dialogs/_impl/colorchooser.py

@@ -15,7 +15,10 @@ from PIL import ImageColor
 from bootstack.constants import *
 from bootstack._core import colorutils
 from bootstack._core.colorutils import HEX, HSL, HUE, LUM, RGB, SAT
-from bootstack.dialogs._impl.dialog import Dialog
+from bootstack.events import Subscription
+from bootstack.dialogs._impl.dialog import (
+    DIALOG_RESULT, Dialog, emit_dialog_result, result_target,
+)
 from bootstack.i18n import MessageCatalog
 from bootstack._runtime import utility
 from bootstack.style.style import get_style, get_theme_color
@@ -554,35 +557,28 @@ class ColorChooserDialog:
         if not self._emitted_result:
             self._emit_result(confirmed=self.result is not None)
 
-    def on_dialog_result(self, callback: Callable[[Any], None]) -> Optional[str]:
-        """Bind a callback fired when the dialog produces a result."""
-        target = self._master or self._dialog.toplevel
+    def on_dialog_result(self, callback: Callable[[Any], None]) -> "Optional[Subscription]":
+        """Bind a callback fired when the dialog produces a result.
+
+        Returns:
+            A `Subscription`, or `None` if there is no widget to bind to.
+            Cancel it with `.cancel()`.
+        """
+        target = result_target(self._dialog, self._master)
         if target is None:
             return None
 
         def handler(event):
             callback(getattr(event, "data", None))
 
-        return target.bind("<<DialogResult>>", handler, add="+")
-
-    def off_dialog_result(self, funcid: str) -> None:
-        """Unbind a previously bound dialog result callback."""
-        target = self._master or self._dialog.toplevel
-        if target is None:
-            return
-        target.unbind("<<DialogResult>>", funcid)
+        # The Subscription remembers the widget it bound to — see #397.
+        bind_id = target.bind(DIALOG_RESULT, handler, add="+")
+        return Subscription(target, DIALOG_RESULT, bind_id)
 
     # helpers ------------------------------------------------------------------
     def _emit_result(self, confirmed: bool) -> None:
-        payload = {"result": self.result, "confirmed": confirmed}
-        target = self._master or self._dialog.toplevel
-        if not target:
-            return
-        try:
-            target.event_generate("<<DialogResult>>", data=payload)
-        except Exception:
-            try:
-                target.event_generate("<<DialogResult>>")
-            except Exception:
-                pass
+        emit_dialog_result(
+            result_target(self._dialog, self._master),
+            {"result": self.result, "confirmed": confirmed},
+        )
         self._emitted_result = True

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/dialogs/_impl/datedialog.py

@@ -14,7 +14,10 @@ from tkinter import Widget
 
 from bootstack.widgets._impl.primitives import Frame
 from bootstack.constants import BOTH, YES
-from bootstack.dialogs._impl.dialog import Dialog, DialogButton
+from bootstack.events import Subscription
+from bootstack.dialogs._impl.dialog import (
+    DIALOG_RESULT, Dialog, DialogButton, emit_dialog_result, result_target,
+)
 from bootstack._runtime.window_utilities import AnchorPoint
 from bootstack.widgets._impl.composites.calendar import Calendar
 
@@ -404,7 +407,7 @@ class DateDialog:
         """The selected date (single mode) or `(start, end)` tuple (range mode), or None if cancelled."""
         return self._dialog.result
 
-    def on_result(self, callback: Callable[[date], None]) -> Optional[str]:
+    def on_result(self, callback: Callable[[date], None]) -> Optional[Subscription]:
         """Bind a callback fired when a result is produced.
 
         The callback receives `event.data["result"]` (a `datetime.date`).
@@ -413,38 +416,23 @@ class DateDialog:
             callback: Callable that receives the selected `datetime.date`.
 
         Returns:
-            The Tk binding identifier, which can be used with `off_result`.
+            A `Subscription`, or `None` if there is no widget to bind to.
+            Cancel it with `.cancel()`.
         """
-        target = self._dialog.toplevel or self._master
+        target = result_target(self._dialog, self._master)
         if target is None:
             return None
 
         def handler(event: tkinter.Event) -> None:
             callback(getattr(event, "data", None))
 
-        return target.bind("<<DialogResult>>", handler, add="+")
-
-    def off_result(self, funcid: str) -> None:
-        """Unbind a previously bound `on_result` callback.
-
-        Args:
-            funcid: Binding identifier returned by `on_result`.
-        """
-        target = self._dialog.toplevel or self._master
-        if target is None:
-            return
-        target.unbind("<<DialogResult>>", funcid)
+        # The Subscription remembers the widget it bound to — see #397.
+        bind_id = target.bind(DIALOG_RESULT, handler, add="+")
+        return Subscription(target, DIALOG_RESULT, bind_id)
 
     def _emit_result(self, value: date, confirmed: bool) -> None:
         """Emit a virtual Tk event with the dialog result."""
-        target = self._dialog.toplevel or self._master
-        if not target:
-            return
-        payload = {"result": value, "confirmed": confirmed}
-        try:
-            target.event_generate("<<DialogResult>>", data=payload)
-        except Exception:
-            try:
-                target.event_generate("<<DialogResult>>")
-            except Exception:
-                pass
+        emit_dialog_result(
+            result_target(self._dialog, self._master),
+            {"result": value, "confirmed": confirmed},
+        )

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/dialogs/_impl/dialog.py

@@ -127,6 +127,58 @@ class ShowOptions(TypedDict, total=False):
     auto_flip: Union[bool, Literal['vertical', 'horizontal']]
 
 
+# --- Dialog result delivery -------------------------------------------------
+
+DIALOG_RESULT = "<<DialogResult>>"
+
+
+def result_target(dialog: "Dialog", master: Optional[tkinter.Misc]) -> Optional[tkinter.Misc]:
+    """The widget `<<DialogResult>>` is bound on and fired from.
+
+    Binding and firing both route through here so the two cannot resolve
+    differently. That mattered: `Dialog.toplevel` is `None` before `show()`
+    and a *destroyed* widget after it, because nothing resets `_toplevel`
+    when the modal wait ends. A target derived from it is therefore never
+    live at both ends — subscribers bound to the master while the result
+    fired at a dead toplevel, where `event_generate` raised and the error
+    was swallowed (#397).
+
+    `master` comes first for that reason: it outlives the dialog.
+
+    Args:
+        dialog: The dialog producing the result.
+        master: The dialog's master widget, if it has one.
+
+    Returns:
+        A live widget, or `None` when there is nothing left to fire on.
+    """
+    if master is not None:
+        return master
+    top = dialog.toplevel
+    if top is not None and top.winfo_exists():
+        return top
+    return None
+
+
+def emit_dialog_result(target: Optional[tkinter.Misc], payload: dict) -> None:
+    """Fire `<<DialogResult>>` on `target` with `payload` attached.
+
+    Args:
+        target: The widget from `result_target`, or `None` to do nothing.
+        payload: Mapping with `result` and `confirmed` keys.
+    """
+    if target is None:
+        return
+    try:
+        target.event_generate(DIALOG_RESULT, data=payload)
+    except tkinter.TclError:
+        # `result_target` hands back a live widget, so reaching here means it
+        # was destroyed in between. Nothing can receive the result; surface it
+        # in development rather than letting it vanish the way it used to.
+        from bootstack._runtime.utility import debug_log_exception
+        debug_log_exception(f"could not deliver {DIALOG_RESULT}")
+
+
 # --- Dialog ----------------------------------------------------------------
 
 class Dialog:

{bootstack-0.1.8 → bootstack-0.2.1}/src/bootstack/dialogs/_impl/message.py

@@ -10,7 +10,10 @@ from bootstack.widgets._impl.primitives import Frame, Label
 from bootstack._core.images import _ImageService
 from bootstack.constants import *
 from bootstack.i18n import MessageCatalog
-from .dialog import ButtonRole, Dialog, DialogButton
+from bootstack.events import Subscription
+from .dialog import (
+    DIALOG_RESULT, ButtonRole, Dialog, DialogButton, emit_dialog_result, result_target,
+)
 
 ttk = SimpleNamespace(Frame=Frame, Label=Label)
 
@@ -198,23 +201,17 @@ class MessageDialog:
             position: x and y coordinates to position the dialog. If None, centers on parent.
         """
         self._dialog.show(position=position, modal=True)
-        target = self._dialog.toplevel or self._master
-        if target:
-            payload = {"result": self._dialog.result, "confirmed": self._dialog.result is not None}
-            try:
-                target.event_generate("<<DialogResult>>", data=payload)
-            except Exception:
-                try:
-                    target.event_generate("<<DialogResult>>")
-                except Exception:
-                    pass
+        emit_dialog_result(
+            result_target(self._dialog, self._master),
+            {"result": self._dialog.result, "confirmed": self._dialog.result is not None},
+        )
 
     @property
     def result(self) -> Any:
         """The dialog result value (the text of the button pressed)."""
         return self._dialog.result
 
-    def on_dialog_result(self, callback: Callable[[Any], None]) -> Optional[str]:
+    def on_dialog_result(self, callback: Callable[[Any], None]) -> "Optional[Subscription]":
         """Bind a callback fired when the dialog produces a result.
 
         The callback receives `event.data["result"]` when available.
@@ -223,23 +220,22 @@ class MessageDialog:
             callback: Callable that receives the result payload.
 
         Returns:
-            Binding identifier for use with `off_dialog_result`.
+            A `Subscription`, or `None` if there is no widget to bind to.
+            Cancel it with `.cancel()`.
         """
-        target = self._dialog.toplevel or self._master
+        target = result_target(self._dialog, self._master)
         if target is None:
             return None
 
         def handler(event):
             callback(getattr(event, "data", None))
 
-        return target.bind("<<DialogResult>>", handler, add="+")
-
-    def off_dialog_result(self, funcid: str) -> None:
-        """Unbind a previously bound dialog result callback."""
-        target = self._dialog.toplevel or self._master
-        if target is None:
-            return
-        target.unbind("<<DialogResult>>", funcid)
+        # The Subscription remembers the widget it bound to. Resolving the
+        # target a second time to unbind would not: `_dialog.toplevel` is None
+        # until show(), so subscribing before and cancelling after resolved to
+        # two different widgets and the removal silently matched nothing (#397).
+        bind_id = target.bind(DIALOG_RESULT, handler, add="+")
+        return Subscription(target, DIALOG_RESULT, bind_id)
 
 
 class MessageBox: