bootstack 0.4.6__tar.gz → 0.4.8__tar.gz

{bootstack-0.4.6/src/bootstack.egg-info → bootstack-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.4.6
+Version: 0.4.8
 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.4.6 → bootstack-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bootstack"
-version = "0.4.6"
+version = "0.4.8"
 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.4.6"
+current_version = "0.4.8"
 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.4.6 → bootstack-0.4.8}/src/bootstack/_core/localization.py

@@ -10,7 +10,10 @@ a thin glue layer.
 
 from __future__ import annotations
 
-from typing import Any, TYPE_CHECKING
+import itertools
+import weakref
+from tkinter import TclError
+from typing import Any, Callable, TYPE_CHECKING
 
 from bootstack.i18n.msgcat import MessageCatalog
 from bootstack.i18n.specs import (
@@ -177,6 +180,91 @@ def get_current_locale() -> str:
     return MessageCatalog.locale()
 
 
+# =============================================================================
+# Locale Change Propagation
+# =============================================================================
+
+_LOCALE_EVENT = "<<LocaleChanged>>"
+
+
+# Don't bind a widget's refresh directly on the window: nothing removes it
+# when the widget is destroyed.
+class _LocaleRefreshers:
+    """The refresh methods one toplevel calls on a locale change."""
+
+    def __init__(self, toplevel: Any) -> None:
+        self._toplevel = toplevel
+        self._refreshers: dict[int, weakref.WeakMethod] = {}
+        self._keys = itertools.count()
+        self._funcid: str | None = None
+
+    def add(self, refresh: Callable[[], Any]) -> None:
+        """Register `refresh`, a bound method of a widget on this toplevel."""
+        self._ensure_bound()
+        key = next(self._keys)
+        refreshers = self._refreshers
+        # Drop the entry when the widget is collected, so a window whose
+        # locale never changes does not accumulate dead references either.
+        refreshers[key] = weakref.WeakMethod(
+            refresh, lambda _ref: refreshers.pop(key, None)
+        )
+
+    def _ensure_bound(self) -> None:
+        """Bind the dispatcher, or bind it again if something replaced it.
+
+        A `bind` of the event without `add` on this toplevel replaces every
+        binding for it, the dispatcher included, which would silently stop
+        every widget on the window from refreshing.
+        """
+        toplevel = self._toplevel
+        if self._funcid is not None:
+            script = str(toplevel.tk.call("bind", toplevel._w, _LOCALE_EVENT))
+            # The line prefix `_patched_bind` emits, as `_patched_unbind` matches it.
+            if ('if {"[%s ' % self._funcid) in script:
+                return
+        self._funcid = toplevel.bind(_LOCALE_EVENT, self._dispatch, add="+")
+
+    def _dispatch(self, _event: Any = None) -> None:
+        """Call each live widget's refresh, in the order they registered."""
+        for key, ref in list(self._refreshers.items()):
+            refresh = ref()
+            if refresh is None:
+                continue
+            widget = refresh.__self__
+            try:
+                alive = widget.winfo_exists()
+            except TclError:
+                alive = False
+            if not alive:
+                # Destroyed, but still referenced from somewhere else.
+                self._refreshers.pop(key, None)
+                continue
+            try:
+                refresh()
+            except Exception:
+                # Report and carry on, as a handler bound on its own would:
+                # one failing widget must not stop the rest from refreshing.
+                widget._report_exception()
+
+
+def bind_locale_refresh(refresh: Callable[[], Any]) -> None:
+    """Call `refresh` on every locale change for as long as its widget exists.
+
+    The locale-change event is generated on the root; `refresh` is called,
+    with no arguments, when the event reaches the toplevel of the widget it is
+    bound to, after the widgets registered before it. A destroyed widget is
+    never called, and registering holds no strong reference to it.
+
+    Args:
+        refresh: A bound method of the widget to refresh.
+    """
+    toplevel = refresh.__self__.winfo_toplevel()
+    refreshers = toplevel.__dict__.get("_bs_locale_refreshers")
+    if refreshers is None:
+        refreshers = toplevel._bs_locale_refreshers = _LocaleRefreshers(toplevel)
+    refreshers.add(refresh)
+
+
 # =============================================================================
 # Signal Formatting
 # =============================================================================
@@ -227,5 +315,6 @@ __all__ = [
     "resolve_variable_text",
     "apply_spec",
     "get_current_locale",
+    "bind_locale_refresh",
     "create_formatted_signal",
 ]

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/style/style_builder_ttk.py

@@ -9,6 +9,7 @@ from bootstack._core.exceptions import StyleBuilderError
 from bootstack.style.style_builder_base import StyleBuilderBase
 from bootstack.style.element import Element, ElementImage
 from bootstack.style.theme_provider import ThemeProvider
+from bootstack.style.utility import pretile_element_image
 
 
 class BuilderCallable(Protocol):
@@ -344,8 +345,37 @@ class StyleBuilderTtk(StyleBuilderBase):
         if name in existing:
             # Element already exists; avoid duplicate creation error on theme rebuilds
             return
+        try:
+            args, kwargs = self._pretile_element_images(args, kwargs)
+        except Exception:
+            # Pre-tiling only speeds painting up; the element draws from its own images.
+            from bootstack._runtime.utility import debug_log_exception
+            debug_log_exception(f"could not pre-tile the images of element {name!r}")
         self.style.element_create(name, "image", *args, **kwargs)
 
+    def _pretile_element_images(self, args: list, kwargs: dict) -> tuple[list, dict]:
+        """Swap an element's images for copies that paint a wide parcel in few repeats.
+
+        Only an element that stretches horizontally is pre-tiled; one that does
+        not is drawn at its image's own width, so a wider image would draw wider.
+        No `sticky` means `nsew`.
+        """
+        sticky = kwargs.get("sticky")
+        if sticky is not None and not ("e" in sticky and "w" in sticky):
+            return args, kwargs
+
+        master = self.style.master
+        border = kwargs.get("border", 0)
+        default, *specs = args
+        tiled = [pretile_element_image(default, border, master)]
+        tiled += [(state, pretile_element_image(image, border, master)) for state, image in specs]
+
+        if tiled[0] != default and "width" not in kwargs:
+            # The element's minimum width defaults to its image's width, so pin
+            # it to the original image's.
+            kwargs = {**kwargs, "width": int(self.style.tk.call("image", "width", default))}
+        return tiled, kwargs
+
     def create_style_layout(self, ttk_style: str, element: Element | list[Element]):
         if isinstance(element, list):
             self.style.layout(ttk_style, [e.spec() for e in element])

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/style/utility.py

@@ -1,3 +1,4 @@
+import tkinter
 from colorsys import hls_to_rgb, rgb_to_hls
 from dataclasses import dataclass
 from pathlib import Path
@@ -553,6 +554,73 @@ def recolor_element_image(
     return ElementImageResult(image=photo_image, meta=meta)
 
 
+PRETILE_SPAN = 256
+"""The width, in pixels, an element image's middle column is repeated to."""
+
+
+def pretile_element_image(
+    image: str,
+    border: int | tuple[int, ...] | list[int],
+    master: tkinter.Misc,
+) -> str:
+    """Return a copy of an element image with its middle column repeated.
+
+    A stretched image element is drawn by repeating its middle column across the
+    parcel, one draw per repeat, so an element image only a few pixels wide makes
+    a wide widget slow to paint. The copy repeats the column to at least
+    `PRETILE_SPAN` pixels, in whole repeats starting at the column's left edge as
+    the element's own drawing does, so it draws the same pixels in fewer repeats.
+    The left and right columns are copied unchanged.
+
+    Copies are cached by source image and border, so elements that share an image
+    share its copy.
+
+    Args:
+        image: Name of the source photo image.
+        border: The element's border: one value, or up to four in the order left,
+            top, right, bottom, where right defaults to left.
+        master: Widget whose interpreter owns `image`.
+
+    Returns:
+        The name of the copy, or `image` itself when its middle column is already
+        at least `PRETILE_SPAN` pixels wide or has no width.
+    """
+    values = [border] if isinstance(border, int) else list(border)
+    left = int(values[0]) if values else 0
+    right = int(values[2]) if len(values) > 2 else left
+
+    cache_key = ("element-pretile", str(image), left, right)
+    cached = ImageService.get_cached(cache_key)
+    if cached is not None:
+        return str(cached)
+
+    tk = master.tk
+    width = int(tk.call("image", "width", image))
+    height = int(tk.call("image", "height", image))
+    middle = width - left - right
+    if middle <= 0 or middle >= PRETILE_SPAN:
+        return str(image)
+
+    span = middle * -(-PRETILE_SPAN // middle)
+    tiled = tkinter.PhotoImage(master=master, width=left + span + right, height=height)
+
+    def copy(x0: int, x1: int, *to: int) -> None:
+        tk.call(
+            tiled, "copy", image, "-from", x0, 0, x1, height,
+            "-to", *to, "-compositingrule", "set",
+        )
+
+    if left:
+        copy(0, left, 0, 0)
+    # A -to rectangle larger than the -from region repeats the region across it.
+    copy(left, left + middle, left, 0, left + span, height)
+    if right:
+        copy(width - right, width, left + span, 0)
+
+    ImageService.set_cached(cache_key, tiled)
+    return str(tiled)
+
+
 def should_darken(bg_hex: str) -> bool:
     """Determine whether to darken or lighten based on luminance and saturation."""
     r, g, b = [v / 255.0 for v in ImageColor.getrgb(bg_hex)]

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_core/base.py

@@ -446,8 +446,14 @@ class PublicWidgetBase:
         if placement.method == "flex":
             # The FlexFrame's managed list IS the attached-sibling order, so the
             # current managed index is the slot a plain attach() should restore.
+            from bootstack.widgets._core.container import snapshot_flex_slot
+
             idx = placement.master.index_of(self._internal)
-            placement.index = idx if idx >= 0 else None
+            if idx >= 0:
+                snapshot_flex_slot(placement, placement.master, idx)
+            else:
+                placement.index = None
+                placement.preceding = ()
             placement.master.remove_child(self._internal)
         elif placement.method == "pack":
             slaves = list(placement.master.pack_slaves())
@@ -485,7 +491,7 @@ class PublicWidgetBase:
         """
         from bootstack.widgets._core.container import (
             PACK_KEYS, GRID_KEYS, PLACE_KEYS, normalize_fill, _expand_margin, _flex_child_opts,
-            _reject_legacy_child_kwargs, resolve_pack_order
+            _reject_legacy_child_kwargs, resolve_pack_order, restored_flex_index
         )
 
         placement = getattr(self, "_placement", None)
@@ -503,7 +509,10 @@ class PublicWidgetBase:
         options = dict(placement.options)
 
         if placement.method == "flex":
-            index = kwargs.pop("index", placement.index)
+            if "index" in kwargs:
+                index = kwargs.pop("index")
+            else:
+                index = restored_flex_index(placement)
             if kwargs:
                 _reject_legacy_child_kwargs(kwargs, type(self).__name__, "flex child")
                 _expand_margin(kwargs)

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_core/container.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import tkinter
+import weakref
 from typing import Any, Literal
 
 PACK_KEYS = frozenset({
@@ -101,11 +102,12 @@ class Placement:
     Recorded on the child at layout time by `guide_layout`; consumed by
     `PublicWidgetBase.detach`/`attach` to remove and re-insert the widget
     without re-running its constructor. `options` holds the resolved Tk
-    geometry-manager options (no ordering refs); `index` is the pack position
-    among siblings, snapshotted afresh on each `detach`.
+    geometry-manager options (no ordering refs); `index` is the position among
+    siblings, snapshotted afresh on each `detach`. For a flex child, set it
+    with `snapshot_flex_slot`, which keeps `preceding` in step with it.
     """
 
-    __slots__ = ("method", "master", "options", "index")
+    __slots__ = ("method", "master", "options", "index", "preceding")
 
     def __init__(
         self,
@@ -114,10 +116,31 @@ class Placement:
         options: dict,
         index: int | None = None,
     ) -> None:
-        self.method = method      # "pack" | "grid" | "place"
+        self.method = method      # "pack" | "grid" | "place" | "flex"
         self.master = master      # the Tk master the child is placed in
         self.options = options    # resolved Tk options (no before/after/index)
         self.index = index        # pack order among siblings (snapshot at detach)
+        self.preceding: tuple = ()  # weakrefs to the flex siblings before `index`
+
+
+def snapshot_flex_slot(placement: Placement, frame: Any, index: int) -> None:
+    """Record `index` in `frame` as the slot a plain `attach()` restores.
+
+    The siblings before the slot are kept by weak reference so that one
+    destroyed before the attach no longer counts toward the index.
+    """
+    placement.index = index
+    placement.preceding = tuple(weakref.ref(w) for w, _ in frame._managed[:index])
+
+
+def restored_flex_index(placement: Placement) -> int | None:
+    """The snapshotted slot, less the preceding siblings destroyed since."""
+    from bootstack.widgets._impl.primitives.flexframe import _alive
+
+    if placement.index is None:
+        return None
+    gone = sum(1 for ref in placement.preceding if not ((w := ref()) and _alive(w)))
+    return max(placement.index - gone, 0)
 
 
 def resolve_pack_order(order: dict, master: tkinter.Misc) -> dict:
@@ -441,8 +464,11 @@ def place_flex_child(
         frame.add_child(child._internal, opts, index=index)
         child._placement = Placement("flex", frame, opts)
     else:
-        # Record the slot a later attach() restores: an explicit index, else the
-        # natural append position (current child count).
-        if index is None:
-            index = len(frame._managed)
+        # Record the slot a later attach() restores: an explicit index as given,
+        # else the natural append position (current child count).
         child._placement = Placement("flex", frame, opts, index=index)
+        if index is None:
+            # Prune first: a dead sibling left in `_managed` would be counted
+            # twice, once in the count and again when attach() discounts it.
+            frame._prune_destroyed()
+            snapshot_flex_slot(child._placement, frame, len(frame._managed))

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/_parts/spinnerentry_part.py

@@ -8,6 +8,7 @@ both text and numeric values.
 from tkinter import Event, TclError
 from typing import Any, Callable
 
+from bootstack._core.localization import bind_locale_refresh
 from bootstack.events import ChangeEvent, InputEvent
 from bootstack.i18n import MessageCatalog, IntlFormatter
 from bootstack.widgets._impl.primitives.spinbox import Spinbox
@@ -131,7 +132,7 @@ class SpinnerEntryPart(ValidationMixin, Spinbox):
         self.bind('<FocusIn>', self._store_prev_value, add=True)
         self.bind('<FocusOut>', self._handle_focus_out, add=True)
         self.bind('<Return>', self._handle_return, add=True)
-        self.winfo_toplevel().bind('<<LocaleChanged>>', self._on_locale_changed, add='+')
+        bind_locale_refresh(self._on_locale_changed)
 
         # Set initial focus
         if initial_focus:

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/_parts/textentry_part.py

@@ -1,6 +1,7 @@
 from tkinter import Event, TclError
 from typing import Any, Callable
 
+from bootstack._core.localization import bind_locale_refresh
 from bootstack.events import ChangeEvent, InputEvent
 from bootstack.i18n import MessageCatalog, IntlFormatter
 from bootstack.widgets._impl.primitives.entry import Entry
@@ -102,7 +103,7 @@ class TextEntryPart(ValidationMixin, Entry):
         self.bind('<FocusIn>', self._store_prev_value, add=True)
         self.bind('<FocusOut>', self._handle_focus_out, add=True)
         self.bind('<Return>', self._handle_return, add=True)
-        self.winfo_toplevel().bind('<<LocaleChanged>>', self._on_locale_changed, add='+')
+        bind_locale_refresh(self._on_locale_changed)
 
         # set initial focus
         if initial_focus:

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/composites/contextmenu.py

@@ -4,6 +4,7 @@ Provides a customizable context menu with support for commands, checkbuttons,
 radiobuttons, and separators.
 """
 
+import weakref
 from tkinter import BooleanVar, IntVar, Misc, StringVar, TclError, Toplevel, Widget
 from typing_extensions import Unpack
 from typing import Any, Callable, Literal
@@ -42,6 +43,23 @@ On Windows and Linux the result is the created widget. On macOS (native
 # explicitly" (no target — no positioning, no auto-trigger).
 _TARGET_DEFAULT: Any = object()
 
+# Themed menus currently shown. Weak, so a new menu torn down with its parent
+# is not pinned here (it's destroy()) is never called.
+_OPEN_MENUS: "weakref.WeakSet[_ToplevelContextMenu]" = weakref.WeakSet()
+
+
+def hide_open_menus() -> None:
+    """Hide every open themed context menu.
+
+    Call this from a click handler that returns 'break': the break stops the
+    click before the window-level outside-click handler can close the menu.
+    """
+    for menu in list(_OPEN_MENUS):
+        try:
+            menu.hide()
+        except TclError:
+            _OPEN_MENUS.discard(menu)
+
 
 class _CommandItemFrame(CompositeFrame):
     """Container frame for command items that delegates to the inner button.
@@ -648,6 +666,7 @@ class _ToplevelContextMenu(CustomConfigMixin):
         self._toplevel.attributes('-topmost', True)
         self._toplevel.lift()
         self._toplevel.focus_force()
+        _OPEN_MENUS.add(self)
 
         # Start with no item highlighted (keyboard nav will highlight on first arrow key)
         self._highlighted_index = -1
@@ -737,6 +756,7 @@ class _ToplevelContextMenu(CustomConfigMixin):
 
     def hide(self) -> None:
         """Hide the context menu."""
+        _OPEN_MENUS.discard(self)
         # Unbind click handler first
         self._cancel_click_outside_after()
         self._unbind_click_outside_handler()
@@ -756,6 +776,7 @@ class _ToplevelContextMenu(CustomConfigMixin):
 
     def destroy(self) -> None:
         """Destroy the context menu and cleanup resources."""
+        _OPEN_MENUS.discard(self)
         # Unbind click handler
         self._cancel_click_outside_after()
         self._unbind_click_outside_handler()

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/composites/selectbox.py

@@ -4,6 +4,7 @@ from typing_extensions import Unpack
 
 from typing import Any
 
+from bootstack._core.localization import bind_locale_refresh
 from bootstack.events import ChangeEvent
 from bootstack.widgets._core.options import (
     cluster_records,
@@ -139,7 +140,7 @@ class SelectBox(Field):
         self._entry._get_validation_value = self._validation_value
 
         # Re-translate the displayed text + option maps on a live locale switch.
-        self.winfo_toplevel().bind('<<LocaleChanged>>', self._on_locale_changed_refresh, add='+')
+        bind_locale_refresh(self._on_locale_changed_refresh)
 
         self._group_by = group_by
         self._max_visible_items = max_visible_items
@@ -391,7 +392,48 @@ class SelectBox(Field):
         text = self.entry_widget.get()
         if text in self._value_by_text and self._value_by_text[text] != text:
             return self._value_by_text[text]
-        return self._entry_live_validation_value()
+        return self._decode_custom_text(text, self._entry_live_validation_value)
+
+    def _numeric_option_kind(self):
+        """`int` or `float` when every option value shares that type, else None."""
+        # type(), not isinstance: bool never reads as int here, so a bool option
+        # list falls out as "not numeric" without a special case.
+        kinds = {type(rec.value) for rec in self._records}
+        if len(kinds) != 1:
+            return None
+        kind = kinds.pop()
+        return kind if kind in (int, float) else None
+
+    def _decode_custom_text(self, text, fallback):
+        """Decode text that names no option: the options' own type when they share one.
+
+        A value typed by the user arrives as text with nothing to parse it,
+        while one assigned from code arrives already typed. When every option
+        value is an `int`, or every one a `float`, numeric text is parsed to
+        that type so both routes agree. Anything else — a mixed or empty
+        list, `str` or `bool` options, text that is not a number, an entry
+        that parses through its own `value_format` — is handed to `fallback`,
+        which is what the entry reported before.
+
+        A whole-number `float` narrows to `int` for `int` options; `'6.5'`
+        against `int` options stays `6.5` rather than being truncated.
+        """
+        if self.entry_widget._value_format is not None:
+            return fallback()
+        if getattr(self.entry_widget, "_showing_placeholder", False):
+            return fallback()
+        kind = self._numeric_option_kind()
+        if kind is None:
+            return fallback()
+        try:
+            parsed = self.entry_widget._fmt.parse(text, "decimal")
+        except ValueError:
+            return fallback()
+        if parsed is None:
+            return fallback()
+        if kind is int and not parsed.is_integer():
+            return parsed
+        return kind(parsed)
 
     def _register_retired_value(self, value: Any) -> None:
         """Make a value that is not in the option list decodable.
@@ -1185,16 +1227,17 @@ class SelectBox(Field):
         """The selected value, or None when the field is empty.
 
         For a decoupled option (its display text differs from its value) this
-        returns the option's value. Otherwise it returns the entry's own raw
-        value, so `value_format` parsing — e.g. TimeField's `datetime.time` —
-        is preserved.
+        returns the option's value. A custom value typed by the user takes the
+        type the options share when that is `int` or `float`. Otherwise it
+        returns the entry's own raw value, so `value_format` parsing — e.g.
+        TimeField's `datetime.time` — is preserved.
         """
         text = self.entry_widget.get()
         if text == "":
             return None
         if text in self._value_by_text and self._value_by_text[text] != text:
             return self._value_by_text[text]
-        return Field.value.fget(self)
+        return self._decode_custom_text(text, lambda: Field.value.fget(self))
 
     @value.setter
     def value(self, value):

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/composites/tableview/tableview.py

@@ -30,7 +30,7 @@ from bootstack.data.sqlite_source import SqliteDataSource
 from bootstack.data.query import col, any_of, all_of
 from bootstack.widgets._impl.primitives.button import Button
 from bootstack._runtime.utility import bind_right_click, debug_log_exception
-from bootstack.widgets._impl.composites.contextmenu import ContextMenu
+from bootstack.widgets._impl.composites.contextmenu import ContextMenu, hide_open_menus
 from bootstack.widgets._impl.composites.tooltip import ToolTip
 from bootstack.widgets._impl.composites.dropdownbutton import DropdownButton
 from bootstack.widgets._impl.primitives.entry import Entry
@@ -1644,6 +1644,7 @@ class TableView(Frame):
     # ------------------------------------------------------------------ Row context menu
     def _dismiss_context_menus(self) -> None:
         """Hide any open built-in row/header context menu (idempotent)."""
+        hide_open_menus()
         for menu in (self._row_menu, self._header_menu):
             if menu is not None:
                 try:

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/composites/tabs/tabview.py

@@ -17,6 +17,7 @@ from bootstack.events import (
 from bootstack.widgets._impl.composites.pagestack import PageStack
 from bootstack.widgets.types import Master
 from bootstack._core import NavigationError
+from bootstack._core.localization import bind_locale_refresh
 
 
 class TabView(Frame):
@@ -121,9 +122,7 @@ class TabView(Frame):
         self._trace_id = self._tab_variable.trace_add('write', self._on_tab_selected)
 
         # Locale retranslation
-        self.winfo_toplevel().bind(
-            "<<LocaleChanged>>", self._on_locale_changed, add='+'
-        )
+        bind_locale_refresh(self._on_locale_changed)
 
         # Clean up trace on destroy
         self.bind('<Destroy>', self._on_destroy, add='+')

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/composites/textarea/core.py

@@ -524,26 +524,15 @@ class _MultilineCore(tk.Frame):
 
     # ── convenience: forward common Text API to self ──────────────────────
 
-    def bind(self, sequence=None, func=None, add=None):
-        return self.text.bind(sequence, func, add)
-
-    def unbind(self, sequence, funcid=None):
-        return self.text.unbind(sequence, funcid)
-
     def focus_set(self):
         self.text.focus_set()
 
     # ── cleanup ───────────────────────────────────────────────────────────
 
     def _on_destroy(self, event: tk.Event) -> None:
-        # Released for any Destroy in this subtree, not just our own: the event
-        # this handler receives names the inner Text, never the core, so gating
-        # the release on `is self` releases nothing and the subscription outlives
-        # the widget. The rest of the block stays behind the guard -- it has
-        # never run, and starting it here is not this change's business.
-        self._unbind_signal()
         if event.widget is not self:
             return
+        self._unbind_signal()
         self._chain.destroy()
         try:
             for seq in wheel.wheel_sequences(self):

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/composites/tree/treeitem.py

@@ -14,6 +14,7 @@ from tkinter import TclError
 from typing import Any, Optional
 
 from bootstack.widgets._impl.composites.compositeframe import CompositeFrame
+from bootstack.widgets._impl.composites.contextmenu import hide_open_menus
 from bootstack.widgets._impl.primitives.button import Button
 from bootstack.widgets._impl.primitives.frame import Frame
 from bootstack.widgets._impl.primitives.label import Label
@@ -193,6 +194,9 @@ class TreeItem(CompositeFrame):
             self._emit("<<TreeItemSelect>>", self._node)
 
     def _on_ctrl_click(self, event=None) -> str:
+        # The 'break' below stops the click before an open menu's outside-click
+        # handler sees it, so close the open menus here
+        hide_open_menus()
         if self._node is not None:
             if self._focusable:
                 self.focus()
@@ -209,6 +213,9 @@ class TreeItem(CompositeFrame):
         return "break"
 
     def _on_right_click(self, event) -> str:
+        # The 'break' below stops the click before an open menu's outside-click
+        # handler sees it, so close open menus before this row opens its own
+        hide_open_menus()
         if self._node is not None:
             self._emit(
                 "<<TreeItemRightClick>>",

{bootstack-0.4.6 → bootstack-0.4.8}/src/bootstack/widgets/_impl/mixins/localization_mixin.py

@@ -18,6 +18,7 @@ from bootstack._core.localization import (
     resolve_text,
     resolve_variable_text,
     apply_spec,
+    bind_locale_refresh,
     create_formatted_signal,
 )
 from bootstack.i18n.specs import (
@@ -67,8 +68,7 @@ class LocalizationMixin(Misc):
         self._localize_mode = localize
         self._default_value_format = value_format
 
-        root = self.winfo_toplevel()  # event is generated on root
-        root.bind("<<LocaleChanged>>", self._on_locale_changed, add="+")
+        bind_locale_refresh(self._on_locale_changed)
 
         # Check if widget has a textsignal or textvariable with value_format
         if value_format and self._has_signal_or_variable():