bootstack 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

bootstack/dialogs/_impl/datedialog.py

@@ -16,7 +16,8 @@ from bootstack.widgets._impl.primitives import Frame
 from bootstack.constants import BOTH, YES
 from bootstack.events import Subscription
 from bootstack.dialogs._impl.dialog import (
-    DIALOG_RESULT, Dialog, DialogButton, emit_dialog_result, result_target,
+    DIALOG_RESULT, Dialog, DialogButton, capture_grab, emit_dialog_result, restore_grab,
+    result_target,
 )
 from bootstack._runtime.window_utilities import AnchorPoint
 from bootstack.widgets._impl.composites.calendar import Calendar
@@ -78,6 +79,22 @@ class _ChromeDialog(Dialog):
         self._build_content()
         self._build_footer()
 
+        # This override duplicates `Dialog.show()` rather than extending it, so
+        # the initial-focus resolution has to be repeated here — see
+        # `Dialog._focus_when_mapped` (issue #439).
+        #
+        # This reaches only RANGE mode. Single-date mode commits the moment a
+        # date is clicked and so builds no footer buttons (see `__init__`),
+        # leaving `_default_button` None; nothing sets `_focus_target` for the
+        # raw calendar content either. So `ask_date()` still opens with focus on
+        # the toplevel itself, exactly as before — measured, not assumed. Giving
+        # the single-date calendar a real focus target is a separate change,
+        # since it would put a focus ring on a day cell and make the arrow keys
+        # move the selection.
+        focus_target = self._focus_target or self._default_button
+        if focus_target is not None:
+            self._focus_when_mapped(focus_target)
+
         self._position_dialog(
             position=position,
             anchor_to=anchor_to,
@@ -110,9 +127,17 @@ class _ChromeDialog(Dialog):
         if modal:
             # transient() is already called in Dialog._create_toplevel()
             # Don't call it again here as it breaks mica effect on Windows
+            previous_grab = None
             if self._mode == "modal":
+                # Remember who held the grab, and how, so it can be handed back
+                # — a nested modal must not leave its opener non-modal (#440),
+                # nor narrow an app-modal window to a local grab.
+                previous_grab = capture_grab(self._toplevel)
                 self._toplevel.grab_set()
-            self._master.wait_window(self._toplevel)
+            try:
+                self._master.wait_window(self._toplevel)
+            finally:
+                restore_grab(previous_grab)
 
     def _on_focus_out(self, event: tkinter.Event):
         if self._suppress_focus_out:

bootstack/dialogs/_impl/dialog.py

@@ -182,6 +182,187 @@ def emit_dialog_result(target: Optional[tkinter.Misc], payload: dict) -> None:
 
 # --- Dialog ----------------------------------------------------------------
 
+def capture_grab(widget: Any) -> tuple[Any, str | None] | None:
+    """Record who holds the modal grab and HOW, for `restore_grab` to hand back.
+
+    Returns `None` when nothing holds the grab — the outermost case, which needs
+    no restore. Otherwise returns the holder paired with its grab KIND.
+
+    ⚠ Call this BEFORE taking the grab. Once another window grabs, the previous
+    holder's `grab_status()` reads `None`, so a kind read afterwards is always
+    wrong — measured, and the reason this pairing exists as one function rather
+    than two steps a caller has to sequence correctly.
+
+    The kind matters because Tk has two: `bs.Window(modal="app")` takes a GLOBAL
+    grab, and restoring that as a local one silently narrows the window's
+    modality (it would block only this application). Reading the kind back from
+    Tk rather than assuming it keeps this correct on every window system without
+    a platform branch — whatever Tk reported, we hand back.
+    """
+    holder = widget.grab_current()
+    if holder is None:
+        return None
+    try:
+        kind = holder.grab_status()
+    except (AttributeError, tkinter.TclError):
+        # Fall back to the narrower grab rather than guessing global.
+        kind = "local"
+    return (holder, kind)
+
+
+def restore_grab(previous: tuple[Any, str | None] | None) -> None:
+    """Hand the modal grab back to whatever held it before this dialog took it.
+
+    Tk releases a grab when the window holding it is destroyed, but it does NOT
+    restore the grab that window displaced. So a modal opened from inside
+    another modal — `bs.alert()` from a dialog button command, or
+    `QueryDialog._on_submit` — took the grab over and then dropped it on the
+    floor when it closed. The OUTER dialog was left on screen and still
+    blocking its caller inside `show()`, yet holding no grab at all: the user
+    could click straight back into the main window and drive the app
+    underneath it, against a dialog that was modal in appearance only
+    (issue #440).
+
+    Pass the token `capture_grab()` returned. `None` means nothing held the
+    grab, which is the outermost case and needs no restore.
+
+    A failure here is deliberately swallowed. This runs on a teardown path,
+    where the previous holder may itself have been destroyed while the inner
+    dialog was up, or the whole interpreter may be going down — and a dialog
+    that has already closed must not raise on its way out. It is LOGGED rather
+    than passed over in silence, because a failed restore is the very defect
+    this function exists to prevent (#440): the outer dialog stays on screen
+    holding nothing.
+
+    ⚠ A global restore can fail where a local one cannot — `grab set -global`
+    is the call Tk's viewability rule guards, and on X11 it can also lose to
+    another client. That is the one way this is riskier than always restoring
+    a local grab, so a failed global restore DEGRADES TO LOCAL rather than to
+    nothing: modal within the application is imperfect, but it is not the #440
+    symptom.
+    """
+    if previous is None:
+        return
+    holder, kind = previous
+    try:
+        if not holder.winfo_exists():
+            return
+        if kind == "global":
+            try:
+                holder.grab_set_global()
+            except tkinter.TclError:
+                _log_grab_failure("could not restore a global grab; falling back to local")
+                holder.grab_set()
+        else:
+            holder.grab_set()
+    except (AttributeError, tkinter.TclError):
+        _log_grab_failure("could not restore the previous dialog's grab")
+
+
+def _log_grab_failure(message: str) -> None:
+    """Report a grab failure without ever raising from a teardown path."""
+    from bootstack._runtime.utility import debug_log_exception
+
+    debug_log_exception(message)
+
+
+# Bindtags whose widgets treat Enter as CONTENT rather than as a command.
+# `Text` is Tk's multi-line text class, which `TextArea` and `CodeEditor` are
+# both built on — naming the class covers them, and anything else Text-backed,
+# without listing widgets.
+_ENTER_IS_CONTENT = frozenset({"Text"})
+
+
+def _key_was_consumed(widget: Any, keysym: str) -> bool:
+    """Did `widget` already answer this Enter key by the time it reached us?
+
+    A dialog binds Return on its TOPLEVEL so the default button can be pressed
+    from an input field. The toplevel is last in the bindtag walk, so by the
+    time that binding runs a widget-level or class-level handler has already
+    had the key — and firing the default button on top of it either invokes the
+    same button twice or runs the default button's command over the one the
+    user actually pressed.
+
+    Two kinds of widget answer Enter, and the rule names the intent rather than
+    inferring it:
+
+    * a **button** invokes. bootstack installs `TButton <Key-Return>` ->
+      `button_default_binding` at app construction (`_runtime/app.py:151`).
+    * a **multi-line text widget** inserts a newline. That is issue #441: the
+      newline went in and the dialog then closed on top of it, because the
+      guard recognized only buttons.
+
+    In both cases a DISABLED widget is the exception: its class binding runs
+    but does nothing — `invoke` is a no-op on a disabled button, and
+    `tk::TextInsert` returns early on a disabled text (both measured,
+    `development/probe_441_key_already_handled.py`). Nothing answered the key,
+    so the default button should still get it. Standing down there would leave
+    the keyboard dead for the whole dialog.
+
+    ⚠ THE KEY MATTERS, NOT ONLY THE WIDGET — which is why `keysym` is required
+    rather than defaulted. The two Enter keys are equivalent to a button and are
+    NOT equivalent to a text widget. Measured against the live binding table:
+
+        TButton  <Key-Return> -> button_default_binding
+        TButton  <Key-KP_Enter> -> button_default_binding   (both, app.py:150)
+        Text     <Key-Return> -> tk::TextInsert
+        Text     <Key-KP_Enter> -> '# nothing'
+
+    Tk binds `Text <KP_Enter>` to the literal script `# nothing`
+    (`tk8.6/text.tcl:308`, unconditional — it is in the block that stops the
+    generic `<Key>` binding inserting `%A`, which for that key is `\r` rather
+    than `\n`). So wherever the keypad key arrives as its own keysym a text
+    widget inserts NOTHING, and reporting it consumed would leave that key dead
+    for the whole dialog. Windows never reaches this: it FOLDS the keypad key
+    into `Return` (see the binding site below), so `keysym` is `Return` there
+    and the text branch behaves as it always has. X11 reports `KP_Enter`
+    separately and is the case this scoping exists for. Aqua is unmeasured and
+    needs no measurement — both of its possible answers are handled.
+
+    ⚠ The text branch tests `keysym != "KP_Enter"` rather than
+    `keysym == "Return"`, deliberately. An unrecognized keysym then reads as
+    CONSUMED, which is the conservative answer for a text widget: standing down
+    wrongly costs a dead key, while firing wrongly costs #441 itself — the
+    dialog closing on top of a newline the user just typed. The button branch
+    has no such asymmetry, both keys invoking there.
+
+    ⚠ INTERROGATING THE BINDINGS INSTEAD WAS TRIED AND IS WRONG — do not
+    re-propose it as the "general" rule. Asking whether any bindtag carries a
+    real binding for the key looks principled and misclassifies the control:
+    bootstack's own `TextField` binds `<Return>` as an instance binding to emit
+    its `submit` event, so a plain entry reads as "already handled" and
+    `ask_string()` stops submitting. Tk also binds `TEntry <Return>` to the
+    literal script `# nothing`, so a non-empty script does not mean the key was
+    handled either. Binding inspection cannot separate binds-to-notify from
+    binds-to-consume; the class name is where that intent is recorded.
+    """
+    try:
+        tags = {str(tag) for tag in widget.bindtags()}
+    except (AttributeError, tkinter.TclError):
+        # Nothing identifiable answered the key, so let the default button run
+        # rather than silently swallowing Enter for the whole dialog.
+        return False
+
+    if "TButton" in tags:
+        try:
+            return not widget.instate(["disabled"])
+        except (AttributeError, tkinter.TclError):
+            return True
+
+    if tags & _ENTER_IS_CONTENT:
+        if keysym == "KP_Enter":
+            # `Text <KP_Enter>` is the literal script `# nothing`, so nothing
+            # was inserted whatever the widget's state — the default button
+            # should still get the key rather than it dying here.
+            return False
+        try:
+            return str(widget.cget("state")) == "normal"
+        except (AttributeError, tkinter.TclError):
+            return True
+
+    return False
+
+
 class Dialog:
     """A flexible dialog window using the builder pattern.
 
@@ -283,6 +464,13 @@ class Dialog:
         self._footer: _Frame | None = None
         self._border_frame: _Frame | None = None
 
+        # Who gets focus when the window comes up. `_focus_target` is the
+        # override a content builder can claim (QueryDialog's entry); the
+        # default button is the fallback. Resolved once in `show()`, after
+        # content is built, so the two cannot race — see `_focus_when_mapped`.
+        self._default_button: _Button | None = None
+        self._focus_target: Widget | None = None
+
         self.result: Any = None
 
     # --------------------------------------------------------------- API
@@ -333,6 +521,16 @@ class Dialog:
         self._create_toplevel(modal=modal)
         self._build_footer()
         self._build_content()
+
+        # Resolve initial focus once, now that both halves exist. A content
+        # widget that claimed `_focus_target` wins; otherwise the default
+        # button takes it, which is what `DialogButton.default` promises.
+        # Deferred to <Map> because the window is still withdrawn here and
+        # `focus_set()` is a silent no-op until it is not (issue #439).
+        focus_target = self._focus_target or self._default_button
+        if focus_target is not None:
+            self._focus_when_mapped(focus_target)
+
         self._position_dialog(
             position=position,
             anchor_to=_resolve_anchor_target(anchor_to),
@@ -353,9 +551,18 @@ class Dialog:
             # sheet window class; calling grab_set on top of that is fine
             # but unnecessary. Plain modal mode still uses grab to block
             # interaction with the parent on platforms without a sheet.
+            previous_grab = None
             if self._mode in ("modal", "sheet"):
+                # Remember who held the grab, and how, so it can be handed back
+                # — a nested modal must not leave its opener non-modal (#440),
+                # nor narrow an app-modal window to a local grab. Captured
+                # before grab_set(), which is the only order that works.
+                previous_grab = capture_grab(self._toplevel)
                 self._toplevel.grab_set()
-            self._master.wait_window(self._toplevel)
+            try:
+                self._master.wait_window(self._toplevel)
+            finally:
+                restore_grab(previous_grab)
 
     @property
     def toplevel(self) -> Toplevel | None:
@@ -541,7 +748,10 @@ class Dialog:
             return
 
         if default_button is not None:
-            default_button.focus_set()
+            # Recorded, not focused here: `show()` resolves focus after the
+            # content is built, so a content widget asking for initial focus
+            # is not overruled by build order (issue #439).
+            self._default_button = default_button
             top = self._toplevel
 
             def press_default(event: Any, b: Any = default_button) -> None:
@@ -563,18 +773,46 @@ class Dialog:
                 leave the keyboard dead for the whole dialog — which is what a
                 content button that greys itself out on click would cause.
 
+                A multi-line text widget answers Enter too, by inserting a
+                newline, and standing down for it is issue #441 — the newline
+                went in and the dialog closed on top of it. `_key_was_consumed`
+                owns that decision for both kinds of widget.
+
+                It is handed the KEYSYM as well as the widget because a text
+                widget answers only the main Enter key: Tk binds its keypad
+                twin to a no-op script, so standing down for that one would
+                leave it dead. A button answers both.
+
                 The remaining case is the one this binding exists for — focus
                 in an entry, as in `QueryDialog`, where nothing else would
                 answer the key.
                 """
-                pressed = event.widget
-                if "TButton" in pressed.bindtags() and not pressed.instate(["disabled"]):
+                if _key_was_consumed(event.widget, event.keysym):
                     return
                 b.invoke()
 
-            # The keypad Enter key reports `KP_Enter`, a separate keysym from
-            # `Return` on Windows, X11 and Aqua alike, so it needs its own
-            # binding to reach the default button from an input field.
+            # The keypad Enter key needs its own binding to reach the default
+            # button from an input field -- but only where the window system
+            # reports it separately, which is NOT everywhere. Measured with a
+            # real keypress, alternating against the main Enter key as a
+            # control (`development/probe_441_kp_enter_platform.py`):
+            #
+            # * Windows FOLDS it into `Return` -- keysym `Return`, keycode 13,
+            #   char `\r`, byte-identical to the main Enter key -- so this
+            #   binding never fires there. Synthesis is no help either: win32
+            #   cannot map the keysym back to a keycode and `event_generate`
+            #   delivers keysym `??` with keycode 0, matching no binding at
+            #   all. Both routes to this path are closed on Windows, so no
+            #   test there can cover it.
+            # * X11 reports `KP_Enter` as a distinct keysym. That is the case
+            #   this binding exists for.
+            # * Aqua is unmeasured.
+            #
+            # Binding both is harmless where the two coincide. Where they do
+            # NOT, the keysym is threaded into `_key_was_consumed` so a text
+            # widget stands down only for the key it actually inserts for --
+            # Tk's `Text <KP_Enter>` is a no-op script, so treating the two
+            # alike would kill the keypad key inside a dialog TextArea.
             for key in ("<Return>", "<KP_Enter>"):
                 self._toplevel.bind(key, press_default)
 
@@ -583,6 +821,54 @@ class Dialog:
         else:
             self._toplevel.bind("<Escape>", lambda e: self._toplevel.destroy())
 
+    @staticmethod
+    def _focus_when_mapped(widget: Widget) -> None:
+        """Focus `widget` once it is actually mapped.
+
+        `focus_set()` is a SILENT no-op while the widget's toplevel is
+        withdrawn: `TkSetFocusWin` walks the ancestry and returns without
+        setting anything, reporting nothing. Footer buttons are built from
+        `_build_footer`, which runs while `_create_toplevel` still has the
+        window withdrawn, so focusing the default button there never took —
+        `focus_lastfor()` kept naming the toplevel, leaving keyboard users
+        with no focus ring and a Tab order starting from nowhere, in a dialog
+        documented as focusing its default button (issue #439).
+
+        Waiting for the widget's own `<Map>` states that precondition instead
+        of guessing a delay. Measured on Windows
+        (`development/probe_439_focus_timing.py`): the button is still
+        unmapped once `deiconify()` AND `update_idletasks()` have both
+        returned, so neither is a usable barrier. Asking after the toplevel is
+        deiconified happens to work — Tk defers a request made against a
+        mapped toplevel — but that deferral is a Tk implementation detail and
+        window managers map asynchronously, so the explicit wait is what
+        travels off this box.
+
+        Binding on the widget rather than scheduling on the root is
+        deliberate: a `<Map>` binding is torn down with the widget it is on,
+        so a dialog closed before it ever maps leaves nothing pending. An
+        `after` timer would outlive the widget and fire as an orphan.
+        """
+        if widget.winfo_ismapped():
+            widget.focus_set()
+            return
+
+        def on_map(_event: Any = None) -> None:
+            # One-shot: the default button should not reclaim focus every time
+            # the dialog is unmapped and remapped (minimize/restore), which
+            # would yank focus off whatever the user had tabbed to.
+            try:
+                widget.unbind("<Map>", bind_id)
+            except tkinter.TclError:
+                pass
+            try:
+                if widget.winfo_exists():
+                    widget.focus_set()
+            except tkinter.TclError:
+                pass
+
+        bind_id = widget.bind("<Map>", on_map, add="+")
+
     def _position_dialog(
             self,
             position: Optional[Tuple[int, int]] = None,

bootstack/dialogs/_impl/query.py

@@ -161,16 +161,18 @@ class QueryDialog:
         # anyway: focus goes to `entry.entry_widget`, and the composite frame is
         # not in that widget's bindtags, so Tk would never reach it.
 
-        # Focus the entry field
-        def _focus():
-            if hasattr(entry, 'entry_widget'):
-                entry.entry_widget.focus_set()
-            else:
-                entry.focus_set()
-
-        _focus()
-        # Ensure focus after dialog buttons set their own focus
-        entry.after_idle(_focus)
+        # Claim initial focus for the entry, so the user can type straight
+        # away. `Dialog` applies this once the window is mapped, in preference
+        # to the default button.
+        #
+        # This used to be a bare `focus_set()` plus an `after_idle` repeat to
+        # "ensure focus after dialog buttons set their own focus". Both ran
+        # while the toplevel was still withdrawn, where `focus_set()` is a
+        # silent no-op, so neither ever took and the entry was never actually
+        # focused — measured in `development/probe_439_default_button_focus.py`
+        # against pre-fix code, where focus sat on the toplevel. Handing the
+        # target to `Dialog` replaces the race with an ordering (issue #439).
+        self._dialog._focus_target = getattr(entry, "entry_widget", entry)
 
         frame.pack(fill=X, expand=True)
         self._entry_widget = entry

bootstack/widgets/_core/base.py

@@ -492,7 +492,7 @@ class PublicWidgetBase:
         if placement.method == "flex":
             index = kwargs.pop("index", placement.index)
             if kwargs:
-                _reject_legacy_child_kwargs(kwargs, type(self).__name__)
+                _reject_legacy_child_kwargs(kwargs, type(self).__name__, "flex child")
                 _expand_margin(kwargs)
                 options.update(_flex_child_opts(self, kwargs))
             master.add_child(self._internal, options, index=index)

bootstack/widgets/_core/container.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import tkinter
-from typing import Any
+from typing import Any, Literal
 
 PACK_KEYS = frozenset({
     "side", "fill", "expand", "anchor",
@@ -218,16 +218,73 @@ class PublicContainer(PublicWidgetBase):
 # ---  Flex engine (Row / Column)  --------------------------------------------
 
 
-def _reject_legacy_child_kwargs(layout_kw: dict, where: str) -> None:
-    """Raise on legacy pack/grid placement kwargs passed to a flex child."""
+# Per-child keys a GRID CELL honors. `grow=` is deliberately ABSENT: Grid and
+# the page/pane containers filter their child options to GRID_KEYS, so a `grow=`
+# written on one of their children is silently dropped. `sticky`/`in_` are not
+# user-facing — `sticky` is a legacy key the guard below rejects, and the cell
+# derives it from `horizontal`/`vertical` instead.
+GRID_CHILD_KEYS = (GRID_KEYS | {"horizontal", "vertical"}) - {"sticky", "in_"}
+
+_ALIGN_ADVICE = (
+    "horizontal= takes left/center/right/stretch and vertical= takes "
+    "top/center/bottom/stretch (for example horizontal=\"stretch\")"
+)
+
+# The remedy depends on HOW the container places its children, and naming the
+# wrong one is the defect this message exists to fix (issue #426). A flex
+# container honors `grow=` on the child; a grid cell drops it, so recommending
+# it there would send the user to a kwarg that does nothing — the same silent
+# no-op #426 was filed about, just one step further along.
+FLEX_CHILD_ADVICE = (
+    "Use grow= to claim leftover space along the stacking axis, or "
+    "horizontal=/vertical= to align or stretch across it — " + _ALIGN_ADVICE
+)
+
+# Container-level options are named WITHOUT a trailing `=` on purpose: the `X=`
+# spelling is reserved for per-child remedies, which is what the regression test
+# checks must be real keys.
+GRID_CHILD_ADVICE = (
+    "Use horizontal=/vertical= to align or stretch the child inside its cell — "
+    + _ALIGN_ADVICE
+    + ". Leftover space is claimed by weighting the row or column on the "
+    "container (its columns/rows arguments), not by a kwarg on the child"
+)
+
+# The kind names the child's PLACEMENT, not its parent class: the dual-mode
+# containers (Card/GroupBox/Expander/AccordionSection) are one or the other
+# depending on their `layout=`, and the page/pane containers are grid cells
+# without a `Grid` anywhere in sight.
+ChildKind = Literal["flex child", "grid cell"]
+
+_CHILD_ADVICE: dict[str, str] = {
+    "flex child": FLEX_CHILD_ADVICE,
+    "grid cell": GRID_CHILD_ADVICE,
+}
+
+
+def _reject_legacy_child_kwargs(layout_kw: dict, where: str, kind: ChildKind) -> None:
+    """Raise on legacy pack/grid placement kwargs passed to a laid-out child.
+
+    Args:
+        layout_kw: the split-out layout kwargs to inspect.
+        where: the call site named in the message.
+        kind: how this container places the child — `'flex child'` or
+            `'grid cell'`. It selects the remedy, and the two differ: a grid
+            cell drops `grow=`, so recommending it there is the silent no-op
+            issue #426 exists to remove. Required rather than defaulted,
+            because a default hands the wrong advice to any caller who forgets
+            — which is how four call sites kept the defect through its own fix.
+    """
     bad = _LEGACY_CHILD_KEYS & layout_kw.keys()
     if bad:
         from bootstack.errors import BootstackError
 
+        # KeyError on an unknown kind is deliberate: a mistyped kind must fail
+        # loudly here rather than quietly pick a remedy for the other engine.
+        advice = _CHILD_ADVICE[kind]
         raise BootstackError(
             f"{where}: {', '.join(sorted(bad))} is not a valid layout option for "
-            f"a Row/Column/Grid child. Use grow= / align_self= (and justify_self= "
-            f"in a Grid) instead — see the layout guide."
+            f"a {kind}. {advice} — see the layout guide."
         )
 
 
@@ -376,7 +433,7 @@ def place_flex_child(
         child._placement = Placement("place", frame, options)
         return
 
-    _reject_legacy_child_kwargs(layout_kw, where)
+    _reject_legacy_child_kwargs(layout_kw, where, "flex child")
     _expand_margin(layout_kw)
     index = layout_kw.get("index")
     opts = _flex_child_opts(child, layout_kw)

bootstack/widgets/_impl/composites/selectbox.py

@@ -1,4 +1,4 @@
-from tkinter import Toplevel
+from tkinter import TclError, Toplevel
 
 from typing_extensions import Unpack
 
@@ -44,6 +44,7 @@ class SelectBox(Field):
             enable_search: bool = False,
             group_by: str = None,
             max_visible_items: int = None,
+            readonly: bool = False,
             **kwargs: Unpack[FieldOptions]
     ):
         """Args:
@@ -60,6 +61,12 @@ class SelectBox(Field):
             message: Optional helper/error message shown below the field.
             allow_custom_values: If True, the entry is editable so users can type
                 arbitrary values in addition to choosing from the list.
+            readonly: If True, the value is visible but cannot be changed — no
+                typing and no popup, from the dropdown button or the entry. It
+                suppresses `allow_custom_values`/`enable_search` rather than
+                discarding them, so clearing it restores whichever was asked
+                for. Distinct from `state='disabled'`, which also dims the
+                whole field and drops it out of the tab order.
             show_dropdown_button: If True (default), the dropdown button is shown. This option is
                 ignored if custom values are allowed.
             dropdown_button_icon: The icon to display on the dropdown button.
@@ -95,6 +102,14 @@ class SelectBox(Field):
             width: Width of the entry in characters.
             required: If True, field cannot be empty.
         """
+        # On select, readonly means the popup does not open and no typing, but allow_custom_values by itself
+        # without readonly just means standard combobox behavior.
+        #
+        # Every input the interaction state is derived from is set BEFORE
+        # `super().__init__()`, because Field's constructor calls
+        # `_sync_addon_state()`, which this class overrides to read them.
+        self._readonly = readonly
+        self._search_enabled = enable_search
         # Localization mode for option display (entry face + popup rows). None
         # defers to the app's localize_mode; False keeps the raw labels.
         self._localize = kwargs.pop('localize', None)
@@ -126,7 +141,6 @@ class SelectBox(Field):
         # Re-translate the displayed text + option maps on a live locale switch.
         self.winfo_toplevel().bind('<<LocaleChanged>>', self._on_locale_changed_refresh, add='+')
 
-        self._search_enabled = enable_search
         self._group_by = group_by
         self._max_visible_items = max_visible_items
         self._popup_open = False
@@ -137,24 +151,98 @@ class SelectBox(Field):
         self._item_labels = []
         self._group_headers = []
 
-        # Add dropdown button if needed
-        if allow_custom_values or show_dropdown_button:
-            self.insert_addon(
-                Button,
-                position="after",
-                name="dropdown",
-                icon=self._dropdown_button_icon,
-                icon_only=True,
-                command=self._on_dropdown_click
-            )
-
-        # Configure entry state based on search and custom value settings
-        if allow_custom_values or enable_search:
-            self.entry_widget.state(['!readonly'])
+        # A typeable entry is the only way the popup can lose an entrance: a
+        # click there has to place a text cursor rather than open the list, so
+        # the button becomes the sole way in. `show_dropdown_button=False` is
+        # honored only while the entry is NOT typeable.
+        #
+        # This decision is made ONCE, here. A later `configure()` that turns
+        # typing on does NOT insert a button the caller asked not to build.
+        if self._entry_is_typeable() or show_dropdown_button:
+            self._insert_dropdown_button()
+
+        # Bind click-to-open unconditionally and gate it inside the handler.
+        # Binding on the transition instead would mean unbinding on the way
+        # back, and a released tkinter binding name is reused immediately, so a
+        # deferred unbind can delete a different, live binding (cost a critical
+        # defect in #392).
+        self.entry_widget.bind('<Button-1>', self._on_entry_click, add='+')
+
+        self._apply_interaction_state()
+
+    # ----- Interaction state: typing, popup, dropdown button -----
+
+    def _entry_is_typeable(self) -> bool:
+        """Whether the user may type into the entry.
+
+        Read-only SUPPRESSES free typing rather than discarding it, so clearing
+        it restores whatever `allow_custom_values`/`enable_search` asked for
+        instead of falling back to a plain select.
+        """
+        if self._readonly:
+            return False
+        return bool(self._allow_custom_values or self._search_enabled)
+
+    def _popup_allowed(self) -> bool:
+        """Whether the option list may open, from either entrance."""
+        if self._readonly:
+            return False
+        return not self.entry_widget.instate(['disabled'])
+
+    def _insert_dropdown_button(self) -> None:
+        """Add the dropdown addon, marked read-only safe.
+
+        `active_when_readonly=True` stops `Field` dimming it for the ttk
+        `readonly` state, which on a select only means "no free typing" and is
+        the default. Dimming for a genuine read-only select is applied in
+        `_sync_addon_state` instead, off `_readonly`.
+        """
+        self.insert_addon(
+            Button,
+            position="after",
+            name="dropdown",
+            icon=self._dropdown_button_icon,
+            icon_only=True,
+            command=self._on_dropdown_click,
+            active_when_readonly=True,
+        )
+
+    def _apply_interaction_state(self) -> None:
+        """Recompute everything derived from readonly / custom values / search.
+
+        The ttk `readonly` state is an OUTPUT of this method, never storage.
+        It doubles as the widget's own "no free typing" flag, and writing it
+        from more than one place is exactly what let a caller's `read_only`
+        be silently overwritten (#453).
+        """
+        typeable = self._entry_is_typeable()
+        self.entry_widget.state(['!readonly'] if typeable else ['readonly'])
+
+        # Only a click that actually opens the list should advertise itself.
+        if typeable or not self._popup_allowed():
+            self.entry_widget.configure(cursor='')
         else:
-            # Set entry to readonly but keep dropdown button enabled
-            self.entry_widget.state(['readonly'])
-            self.after_idle(self._bind_readonly_selection_on_click)
+            self.entry_widget.configure(cursor='hand2')
+
+        self._sync_addon_state()
+
+    def _sync_addon_state(self, event: Any = None) -> None:
+        """Match the addons to the field state, then apply the read-only rule.
+
+        `Field` dims every addon while the entry is `readonly`, assuming an
+        addon mutates the value. Here `readonly` is also how "no free typing"
+        is expressed and the dropdown is the primary interaction, so it opts
+        out via `active_when_readonly` and is dimmed from here on the real
+        read-only flag instead.
+        """
+        super()._sync_addon_state(event)
+        button = self._addons.get('dropdown')
+        if button is None:
+            return
+        try:
+            button.configure(state='!disabled' if self._popup_allowed() else 'disabled')
+        except TclError:
+            pass
 
     # ----- Option normalization + value<->text mapping -----
 
@@ -332,19 +420,29 @@ class SelectBox(Field):
 
     def _on_dropdown_click(self):
         """Handle dropdown button click by focusing entry then showing popup."""
+        if not self._popup_allowed():
+            return
         self.entry_widget.focus_set()
         self._show_selection_options()
 
-    def _bind_readonly_selection_on_click(self):
-        """Bind entry click to show popup when in readonly mode."""
-        self.entry_widget.configure(cursor="hand2")
-        self.entry_widget.bind('<Button-1>', lambda _: self.after_idle(self._show_selection_options), add='+')
+    def _on_entry_click(self, _event: Any = None) -> None:
+        """Open the list when a click on the entry cannot mean anything else.
+
+        Bound for the widget's whole life and gated here, because a typeable
+        entry has to place a text cursor instead — and rebinding on every
+        transition risks deleting a recycled binding name (#392).
+        """
+        if self._entry_is_typeable() or not self._popup_allowed():
+            return
+        self.after_idle(self._show_selection_options)
 
     def _show_selection_options(self):
         """Create and display the popup list of selectable items."""
         if not self._records or self._popup_open:
             return
-        if self.entry_widget.instate(['disabled']):
+        # Both entrances gate on this too; it is repeated here so no future
+        # caller can reach the popup around them.
+        if not self._popup_allowed():
             return
 
         self._popup_open = True
@@ -954,10 +1052,7 @@ class SelectBox(Field):
             return self._allow_custom_values
         else:
             self._allow_custom_values = value
-            if value or self._search_enabled:
-                self.entry_widget.state(['!readonly'])
-            else:
-                self.readonly(True)
+            self._apply_interaction_state()
         return None
 
     @configure_delegate('enable_search')
@@ -967,12 +1062,36 @@ class SelectBox(Field):
             return self._search_enabled
         else:
             self._search_enabled = value
-            if value or self._allow_custom_values:
-                self.entry_widget.state(['!readonly'])
-            else:
-                self.readonly(True)
+            self._apply_interaction_state()
         return None
 
+    @configure_delegate('readonly')
+    def _delegate_readonly(self, value: bool = None):
+        """Get or set read-only: the value is visible but cannot be changed.
+
+        Distinct from a plain select, which is already untypeable but whose
+        list still opens, and from `disabled`, which additionally dims the
+        field and drops it out of the tab order.
+        """
+        if value is None:
+            return self._readonly
+        self._readonly = bool(value)
+        self._apply_interaction_state()
+        return None
+
+    @configure_delegate('state')
+    def _delegate_state(self, value=None):
+        """Apply the field state, then re-derive what read-only owns.
+
+        `Field` writes `readonly`/`normal` straight onto the entry, so
+        `state='normal'` — which is what clearing `disabled` sends — would
+        otherwise silently clear a read-only select as well.
+        """
+        result = super()._delegate_state(value)
+        if value is not None:
+            self._apply_interaction_state()
+        return result
+
     @configure_delegate('group_by')
     def _delegate_group_by(self, value=None):
         """Get or set the option field the popup clusters rows under.

bootstack/widgets/appshell.py

@@ -106,7 +106,7 @@ class Page:
 
     def guide_layout(self, child: Any, **layout_kw: Any) -> None:
         if self._layout == "grid":
-            _reject_legacy_child_kwargs(layout_kw, "AppShell page")
+            _reject_legacy_child_kwargs(layout_kw, "AppShell page", "grid cell")
             _expand_margin(layout_kw)
             options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
             h = layout_kw.get("horizontal") or self._horizontal_items

bootstack/widgets/card.py

@@ -144,7 +144,7 @@ class Card(PublicContainer):
 
     def _merge_layout_options(self, child: Any, layout_kw: dict) -> tuple[str, dict]:
         # Only reached for grid layout (column/row use the flex path above).
-        _reject_legacy_child_kwargs(layout_kw, "Card")
+        _reject_legacy_child_kwargs(layout_kw, "Card", "grid cell")
         options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
         h = layout_kw.get("horizontal") or self._horizontal_items
         v = layout_kw.get("vertical") or self._vertical_items

bootstack/widgets/expander.py

@@ -166,7 +166,7 @@ class Expander(PublicContainer):
 
     def guide_layout(self, child: PublicWidgetBase, **layout_kw: Any) -> None:
         if self._layout == "grid":
-            _reject_legacy_child_kwargs(layout_kw, "Expander")
+            _reject_legacy_child_kwargs(layout_kw, "Expander", "grid cell")
             _expand_margin(layout_kw)
             options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
             h = layout_kw.get("horizontal") or self._horizontal_items
@@ -284,7 +284,7 @@ class AccordionSection:
 
     def guide_layout(self, child: PublicWidgetBase, **layout_kw: Any) -> None:
         if self._layout == "grid":
-            _reject_legacy_child_kwargs(layout_kw, "AccordionSection")
+            _reject_legacy_child_kwargs(layout_kw, "AccordionSection", "grid cell")
             _expand_margin(layout_kw)
             options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
             h = layout_kw.get("horizontal") or self._horizontal_items

bootstack/widgets/grid.py

@@ -111,7 +111,7 @@ class Grid(PublicContainer):
         return "grid"
 
     def _merge_layout_options(self, child: Any, layout_kw: dict) -> tuple[str, dict]:
-        _reject_legacy_child_kwargs(layout_kw, "Grid")
+        _reject_legacy_child_kwargs(layout_kw, "Grid", "grid cell")
         options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
         # Derive the cell sticky from per-child horizontal/vertical, each falling
         # back to the container default for its axis.

bootstack/widgets/groupbox.py

@@ -136,7 +136,7 @@ class GroupBox(PublicContainer):
 
     def _merge_layout_options(self, child: Any, layout_kw: dict) -> tuple[str, dict]:
         # Only reached for grid layout (column/row use the flex path above).
-        _reject_legacy_child_kwargs(layout_kw, "GroupBox")
+        _reject_legacy_child_kwargs(layout_kw, "GroupBox", "grid cell")
         options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
         h = layout_kw.get("horizontal") or self._horizontal_items
         v = layout_kw.get("vertical") or self._vertical_items

bootstack/widgets/pagestack.py

@@ -96,7 +96,7 @@ class StackPage:
 
     def guide_layout(self, child: PublicWidgetBase, **layout_kw: Any) -> None:
         if self._layout == "grid":
-            _reject_legacy_child_kwargs(layout_kw, "StackPage")
+            _reject_legacy_child_kwargs(layout_kw, "StackPage", "grid cell")
             _expand_margin(layout_kw)
             options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
             h = layout_kw.get("horizontal") or self._horizontal_items

bootstack/widgets/select.py

@@ -59,8 +59,12 @@ class Select(PublicWidgetBase):
             before it scrolls (height is `max_visible_items * row_height`).
             Group headers and separators consume some of that budget, so the
             count is approximate. `None` (default) uses the built-in cap.
-        read_only: If `True`, value is visible but the popup cannot be
-            opened.
+        read_only: If `True`, the value is visible but cannot be changed —
+            neither the dropdown arrow nor a click in the field opens the
+            option list, and the arrow is dimmed to show it. Takes precedence
+            over `searchable` and `allow_custom_values` while set, and restores
+            them when cleared. Unlike `disabled`, the field keeps its normal
+            appearance and stays in the tab order. Defaults to `False`.
         disabled: If `True`, field is fully non-interactive and dimmed.
         width: Width in character units.
         accent: Accent token applied to the focus ring.
@@ -118,6 +122,7 @@ class Select(PublicWidgetBase):
             "allow_custom_values": allow_custom_values,
             "group_by":            group_by,
             "max_visible_items":   max_visible_items,
+            "readonly": read_only
         }
         if value is not None:
             internal_kwargs["value"] = value
@@ -131,8 +136,6 @@ class Select(PublicWidgetBase):
             internal_kwargs["required"] = True
         if disabled:
             internal_kwargs["state"] = "disabled"
-        elif read_only:
-            internal_kwargs["state"] = "readonly"
         if width is not None:
             internal_kwargs["width"] = width
         if accent is not None:
@@ -282,12 +285,22 @@ class Select(PublicWidgetBase):
 
     @property
     def read_only(self) -> bool:
-        """Whether the field is visible but the popup cannot be opened."""
-        return str(self._entry_widget().cget("state")) == "readonly"
+        """Whether the field is read-only — the value shows but cannot be changed.
+
+        An ordinary `Select` already refuses free typing, which is not the same
+        thing. A read-only one also keeps the option list shut, from both the
+        dropdown button and the field itself.
+        """
+        # Report the setting, never the state derived from it — reporting the
+        # derivation is what made every select claim to be read-only (#453).
+        # Read it with `cget`, never `configure(name)`: the delegating form of
+        # `configure` answers a query with a 5-tuple, which is unconditionally
+        # truthy and would silently restore that behavior.
+        return bool(self._internal.cget("readonly"))
 
     @read_only.setter
     def read_only(self, v: bool) -> None:
-        self._internal.configure(state="readonly" if v else "normal")
+        self._internal.configure(readonly=bool(v))
 
     @property
     def disabled(self) -> bool:

bootstack/widgets/splitview.py

@@ -92,7 +92,7 @@ class SplitPane:
 
     def guide_layout(self, child: PublicWidgetBase, **layout_kw: Any) -> None:
         if self._layout == "grid":
-            _reject_legacy_child_kwargs(layout_kw, "SplitPane")
+            _reject_legacy_child_kwargs(layout_kw, "SplitPane", "grid cell")
             _expand_margin(layout_kw)
             options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
             h = layout_kw.get("horizontal") or self._horizontal_items

bootstack/widgets/tabs.py

@@ -98,7 +98,7 @@ class TabPage:
 
     def guide_layout(self, child: PublicWidgetBase, **layout_kw: Any) -> None:
         if self._layout == "grid":
-            _reject_legacy_child_kwargs(layout_kw, "TabPage")
+            _reject_legacy_child_kwargs(layout_kw, "TabPage", "grid cell")
             _expand_margin(layout_kw)
             options = {k: v for k, v in layout_kw.items() if k in GRID_KEYS}
             h = layout_kw.get("horizontal") or self._horizontal_items

bootstack/widgets/timefield.py

@@ -52,8 +52,10 @@ class TimeField(ValueSignalMixin, FieldAddonMixin, PublicWidgetBase):
             way to bind a time field.
         required: If `True`, field cannot be left empty.
         disabled: If `True`, field is non-interactive.
-        read_only: If `True`, free-text entry is blocked; user must pick
-            from the dropdown.
+        read_only: If `True`, the time is visible but cannot be changed —
+            typing is blocked, and neither the clock button nor a click in the
+            field opens the time list. Unlike `disabled`, the field keeps its
+            normal appearance and stays in the tab order. Defaults to `False`.
         width: Width in character cells.
         accent: Accent color applied to the focus ring. Default `'primary'`.
         density: Widget density.
@@ -111,10 +113,14 @@ class TimeField(ValueSignalMixin, FieldAddonMixin, PublicWidgetBase):
             internal_kwargs["message"] = message
         if required:
             internal_kwargs["required"] = True
+        # Read-only rides its own option, not `state="readonly"` — the internal
+        # here is a select, where the ttk `readonly` state is an OUTPUT of the
+        # interaction state ("no free typing") and is re-derived at the end of
+        # construction, so a state write is overwritten before anyone sees it
+        # (#453). Same shape as the setter below and as `Select`.
+        internal_kwargs["readonly"] = read_only
         if disabled:
             internal_kwargs["state"] = "disabled"
-        elif read_only:
-            internal_kwargs["state"] = "readonly"
         if width is not None:
             internal_kwargs["width"] = width
         if accent is not None:
@@ -162,12 +168,22 @@ class TimeField(ValueSignalMixin, FieldAddonMixin, PublicWidgetBase):
 
     @property
     def read_only(self) -> bool:
-        """Whether the field is read-only (selectable but not editable)."""
-        return self._internal._entry.instate(("readonly",))
+        """Whether the field is read-only — the time shows but cannot be changed."""
+        # Report the setting, not the state derived from it. The two agree at
+        # rest, but the derivation is cleared and restored around a programmatic
+        # value write, so reading it answers `False` for a locked field from
+        # inside that window (#453). Same reason `Select.read_only` reads the
+        # setting; `cget`, never `configure(name)`, which answers a query with a
+        # truthy 5-tuple.
+        return bool(self._internal.cget("readonly"))
 
     @read_only.setter
     def read_only(self, v: bool) -> None:
-        self._internal.configure(state="readonly" if v else "normal")
+        # Route through the `readonly` option, not `state="readonly"`. The
+        # internal here is a select, where the ttk `readonly` state is an
+        # OUTPUT of the interaction state ("no free typing") and is re-derived
+        # on every change — so a state write is overwritten immediately (#453).
+        self._internal.configure(readonly=bool(v))
 
     # ----- Methods -----
 

{bootstack-0.3.0.dist-info → bootstack-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bootstack
-Version: 0.3.0
+Version: 0.3.2
 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.3.0.dist-info → bootstack-0.3.2.dist-info}/RECORD

@@ -181,13 +181,13 @@ bootstack/dev/_watcher.py,sha256=MEWnb3feq1KBXwHbN8tpcOYX6y6BIqtJULZAiVvylpc,353
 bootstack/dialogs/__init__.py,sha256=HKKmOPdXGdGyOw5lJiqxa1bhijDNwmiLl4jUWuyFEe4,33327
 bootstack/dialogs/_impl/__init__.py,sha256=uphIED7kUbHS71MyAcZAlCsdrs9DrGtet5X9Ry56nLU,1427
 bootstack/dialogs/_impl/colorchooser.py,sha256=umINO_pmbR6Q-vU3VTqGE1GqEypuL-d6Z7r1QO2R9dc,24412
-bootstack/dialogs/_impl/datedialog.py,sha256=L9aGW7bqqEwrhWgU8zxl4Gv_ZWXNZ9x1dO_KpuejHSk,18860
-bootstack/dialogs/_impl/dialog.py,sha256=ZoASFZag1FdYSrPFvrSwo6HHVScJLrWGTiCxJblhBKA,29914
+bootstack/dialogs/_impl/datedialog.py,sha256=akIxV_ss9gSdwH1go8pEZKvuwqcW0xpjX0fyIA-40cg,20275
+bootstack/dialogs/_impl/dialog.py,sha256=0SClHDSM0MeRS8qFgJW6gh3Nft27j0YQqM9w6w_VcGI,44742
 bootstack/dialogs/_impl/filterdialog.py,sha256=yEyO9Z1ywtRjDqtC9G_PJwn5mJlw4CnUmdrBM4e34B4,14850
 bootstack/dialogs/_impl/fontdialog.py,sha256=oDckLjdnqhutMq0wob23s1K_2eGBbVG5gH0l-Yaa_U4,13733
 bootstack/dialogs/_impl/formdialog.py,sha256=khQJnBNVxgBqzB_LVGWrFxNDMVSzo_ucjmxYSCP6BYM,31439
 bootstack/dialogs/_impl/message.py,sha256=7cSyay9-VEBdqhoDadh76jbQGB1LzFTXzqJn-lz_xIs,17605
-bootstack/dialogs/_impl/query.py,sha256=S2zW8ZYIxHAGtVRSKLEV7JNmJC119IeMQjsuCEP5tCg,22142
+bootstack/dialogs/_impl/query.py,sha256=TdKAaF45zJV8QrkQnsdGuXjaTwRccnsRGVj4XKP2gZs,22645
 bootstack/events/__init__.py,sha256=unaLsCDpj_-u_2DbEjDBpHARdoa1rQD9mTmJxkoInpY,2865
 bootstack/events/_event.py,sha256=RpcC5-U-VLOmsPninynIfzOOYvrCiahLNqg6yrdlwpg,4564
 bootstack/events/_payloads.py,sha256=sg594kqOp7C98gFYyyexwsQo5uvDBVUetZZi2sk15mo,15816
@@ -265,13 +265,13 @@ bootstack/validation/validation_result.py,sha256=x-hkUx2hhkuAecBT6oR9wgguPT6WFut
 bootstack/validation/validation_rules.py,sha256=1-Q1dKmIqqjcjbdhk9i8zTNiIqItixLiGY_0tnUN9-U,9324
 bootstack/widgets/__init__.py,sha256=d_UXVCoYCW7VIQNtKdABX1SbUaEQSSEKNL4SUEQ9XAY,3360
 bootstack/widgets/app.py,sha256=ohA-cpYIaUFggQulCdoN_x0gGvnWjAu04UhQj04BCAo,16579
-bootstack/widgets/appshell.py,sha256=TwTzDIlIos3Cri6XUhPCiYb8h6VyTlylBn9nZK1Fiwk,50759
+bootstack/widgets/appshell.py,sha256=XbG9ZQZYoli0cUl5pfONqm1ScOqzt9OrqMK8VTWYUNw,50772
 bootstack/widgets/avatar.py,sha256=4LTMm3S50PltRe-KF9M2sml0UEKo25KTdBjaqBC-Q0c,5383
 bootstack/widgets/boolean_controls.py,sha256=_Sa7r0yTR2zzMPmDIIag4LXTlIGECYcSA44myJTaWmw,19649
 bootstack/widgets/button.py,sha256=SAF-OrFPRpmT0KgFL8hy_jxQWpBvIGs6ICXreUbZTKY,10209
 bootstack/widgets/buttongroup.py,sha256=SpEuVl_Yv83LtLYy2lzQlTthhaW8h4Papg0Skj7EZ6o,9828
 bootstack/widgets/calendar.py,sha256=zkSCufG-s429qDr2ncb1qFe-MwYb2wLWgrlfvqdwaMQ,8096
-bootstack/widgets/card.py,sha256=8tfmuPKksZzxxq1LpSeaokz492lgXlFbWhxJ2NE8AFg,7058
+bootstack/widgets/card.py,sha256=wRrF64HurkT6QRUoqcX6Ath7IUlYXBLVRn1zCcZScAg,7071
 bootstack/widgets/carousel.py,sha256=Y_G1s-aavbV8bMgdEW_5ups4I5i4EF7WJg-7jvK9p8U,9453
 bootstack/widgets/chart.py,sha256=iPwugwEEmQO1IQMcI0uPO7CMveTafmrsivkuqKz5OOo,14110
 bootstack/widgets/codeeditor.py,sha256=rFbi-GEjRdupy8fSjtfTMGs1JHl_SDpLHgLF8H6hq5c,26361
@@ -279,17 +279,17 @@ bootstack/widgets/contextmenu.py,sha256=EnAGQQzEbOSbb9M-CK7lAzKFj81veOeR995an6kz
 bootstack/widgets/datatable.py,sha256=7r_q6k-9dxiE3_EO0QMwPfDG8pDJ3Ptp-Mqwt4lpOnY,28774
 bootstack/widgets/datefield.py,sha256=kgeqWw7AYrlJ3HpvzGotchD33QFU-9J5_kvXWxirpPM,15217
 bootstack/widgets/divider.py,sha256=eP7umEmuagvAqh49nYEO9koo117jQD-9-mK4uVD3QL8,2387
-bootstack/widgets/expander.py,sha256=UbwvkLDZNCFuzlFuAemWcEDmTN99uRTxMaGwrtuo0jc,22319
+bootstack/widgets/expander.py,sha256=l5pQRVQHs-G91wOlx0bGiTTKMlYb_8D82lYcf6RVLHA,22345
 bootstack/widgets/form.py,sha256=D8nN14nyAgSvpQDsqIGxZHBaXyVNzJhWSw83eINHj5w,7777
 bootstack/widgets/gallery.py,sha256=JAboTI4kB9PeVdONhY9-HHM4_e1VnvHiKjolKGIUFhA,10205
 bootstack/widgets/gauge.py,sha256=1ediRKxTSzid3doyzOX3ZN9xzjz4oq7nhyInKoqaZpI,6682
-bootstack/widgets/grid.py,sha256=Fa777RMCBWt7nhz_vkNz5vuWWTQNsF8cGLjqbY4Qs4M,5405
-bootstack/widgets/groupbox.py,sha256=XKrYqKoh4b0aeeKQ8qoxqWwdyzQCaZegJmtQfaZO56c,6915
+bootstack/widgets/grid.py,sha256=JiOdgL4YmCYI1MBs6UWN01EtTeVBFmTv7r-jHYX9Ld0,5418
+bootstack/widgets/groupbox.py,sha256=2Gbx7hVezkrNkcEuTy_Nuj5w-O9hnuyeKyaHhzF_m1g,6928
 bootstack/widgets/label.py,sha256=RnAz-jxCM3ib3QJrgafyPwvPzGGOsSFhlp8C2N9Fx54,9774
 bootstack/widgets/listview.py,sha256=xZkEYIMtbDSsJCs46MFdFtObDSnPos7mQJIc1gPFeL8,14788
 bootstack/widgets/menubutton.py,sha256=gmmZlUKpdyPatkkjS8kbS3XyYQoN9sLFFBOw5kEw_BA,16460
 bootstack/widgets/numberfield.py,sha256=69Fu-4lWvAWaKxOcoMs5RHtDu318QnAndq0zOvQ__8U,16127
-bootstack/widgets/pagestack.py,sha256=mK98IuExK-9xEcRP9OANn5_YLJgnR9RZndxuHLsXj2s,12525
+bootstack/widgets/pagestack.py,sha256=g8jKo7SR8hyGKGVpE98xHsAuQkOuZrGR3XldNUWS54o,12538
 bootstack/widgets/passwordfield.py,sha256=XZasSIc5e8TdK12tQGJ1CYRbrb2V7pHhhcWDpDCiyXQ,14034
 bootstack/widgets/pathfield.py,sha256=UDSkIb_yUyO9Tz5Gop2uOF0s0jItN5hca--C-5pbeOU,17225
 bootstack/widgets/picture.py,sha256=GIuJcMataK6OBqSQUSzR5wJEUurW3ekM4HXCMPHHEUQ,9381
@@ -298,7 +298,7 @@ bootstack/widgets/radio_variants.py,sha256=1se48gRKtVvs_Y21TfK18xetRwzF5WDWWY0zD
 bootstack/widgets/radiogroup.py,sha256=WZC0BR6v6IA94cbbxinwTFeVex_gssCVZOybTROhpVM,10069
 bootstack/widgets/scrollbar.py,sha256=ZZM7XdD0lRhlNBNr1TBz4Lun2IBHxVAPt00XdMJ3Rqc,2537
 bootstack/widgets/scrollview.py,sha256=ce6DAvEW0F5cGe1oWcsVFHG7bVvoJhI63QiF85v0tdk,8413
-bootstack/widgets/select.py,sha256=YET5D2-LQJtJw9gFNM2-ef-ZjKbYntANhS_MYFIiQAQ,13709
+bootstack/widgets/select.py,sha256=tUZjukhyRtEmzTUkrm7uu62CO8uc3FiroQsx8J3zgzM,14615
 bootstack/widgets/selectbutton.py,sha256=COSgcQjrts2il18bmMck4VsD5ZLRCClCjck9asI8Zmk,7491
 bootstack/widgets/sidebar_toggle.py,sha256=2yrAjdy3_U0pjkytmfZ1odE6AhNTGqroc3SWR0is0KY,5708
 bootstack/widgets/sizegrip.py,sha256=-nuJOuBzduNrUDsNWfaq0Ixt6zlGny0RYg-8J0yu8G4,1473
@@ -306,14 +306,14 @@ bootstack/widgets/slider.py,sha256=Llna3ph-uzZELFX4V6Rkq4mHkdeKv0lPUe7_Tk-hyv8,1
 bootstack/widgets/spinbox.py,sha256=pdkMF7LjQ5TGHvgCJv9I5_SmNf2_VP3MQ--UQFxf0Nw,5530
 bootstack/widgets/spinnerfield.py,sha256=2FPLbCEHEqedU0reZrG_tjKM_FkmiFpZu9f15VkH1ao,15269
 bootstack/widgets/splash.py,sha256=pdZgz6lEHzF-iZ9oGSlRcqzQOwJvUnSTDbn40Cx8ZNs,14352
-bootstack/widgets/splitview.py,sha256=OPzXaG7ZMEIwXtE4mr-iGpMkS6h-8x7lUl516Zcrau0,20074
+bootstack/widgets/splitview.py,sha256=uycXrhDLVdfwbD2mti1gGluvtJIzNKtCP3oGpwiEodM,20087
 bootstack/widgets/stacks.py,sha256=nCoGhLEaJ96yi9hrbze3q1StV_aGZuyxp_zW-hg6LM4,11778
 bootstack/widgets/statusbar.py,sha256=bMVZeLKkV-lNC10zrXOh8MjL9TeojO-dVISlcIyICCw,7931
-bootstack/widgets/tabs.py,sha256=mRzCb0NLLjMnNRET4_R0v7a3_ccL6IGRPIpYcRWpc8o,15551
+bootstack/widgets/tabs.py,sha256=al7F5vmCFpFXO-jj6DXE0hDreen9I6wef4Ns15ANux8,15564
 bootstack/widgets/textarea.py,sha256=Zi6HeJ4CDmEUVnJpRUDbUfbZM_keLt9EG_l8NluJHa0,16852
 bootstack/widgets/textfield.py,sha256=38rHx3xF6106Dpg72pCnghlgMuoS27KhJ8tAZa7sOTg,15113
 bootstack/widgets/theme_toggle.py,sha256=0m1MeMfN9-7aeAVboRiJ2wTNkmiKJ-pQ2WJ5rrqv-U4,3473
-bootstack/widgets/timefield.py,sha256=KoWaAugjK_wX2I_GdFlsJtpvWiXPY096mdCKJOREAio,12560
+bootstack/widgets/timefield.py,sha256=izIY6mrx9tHVexLSZOAfb14Y3O-8ETb58x-yylIPETU,13858
 bootstack/widgets/toast.py,sha256=6tn6lW_y001LnUTCQD-hjyN7DhVEd1peTJHXIztLeeE,12301
 bootstack/widgets/togglegroup.py,sha256=NVRDkKLLf8LLN35eUxY0taBtmfgjFZXZQwzG_mVry34,10631
 bootstack/widgets/toolbar.py,sha256=o_drKIyp3D91qIBoTbpuWVnAlb6lL6h3rPTizEX3E2o,14578
@@ -323,9 +323,9 @@ bootstack/widgets/types.py,sha256=_86PwJ20gim0hGnCdPYSn1YVrrsTfZhyQ1zWDwHqQTY,13
 bootstack/widgets/window.py,sha256=lwzYO6uAeXM_lSMXES911OsX8aVrJPKQHJu1u30bAIo,12921
 bootstack/widgets/_core/__init__.py,sha256=rJPvvI3eOV9M5cICBD2XPZFokThf_tQyTeZhLPaqukU,1106
 bootstack/widgets/_core/app_config.py,sha256=h_OaJ0jSif1eJeHWErpsXNyhtfCcmYQCcq0VriM48uk,9771
-bootstack/widgets/_core/base.py,sha256=5u57-fG0gdVNSqMwda6hfQoTay-72PbJoGGamapfpqs,27024
+bootstack/widgets/_core/base.py,sha256=G5xchiRbQI93zdpYYkMqSnfiSh_ZftCuQsr6aMdi0Tw,27038
 bootstack/widgets/_core/choices.py,sha256=IGm4NspPJQgnGOxfuXWsqs4nSk7HSkdH0P60Cd1gnjo,2369
-bootstack/widgets/_core/container.py,sha256=zrMadhoswXERiY4jjzeot2dnqpus-PKmG_vHESiuoqM,16051
+bootstack/widgets/_core/container.py,sha256=h40FyWl_kY6WCioMKUMc9FYjI7t0dCq4u-VlvKdHrXA,18893
 bootstack/widgets/_core/context.py,sha256=laL75HYr7kIx3KbZqtT_rO1wWRjV4pehNzWgcZUkw_I,764
 bootstack/widgets/_core/events.py,sha256=-Hlg3KiITXoei4QxlAmjw65jVXSnr3s81s9PWcdaaKo,3791
 bootstack/widgets/_core/field_mixin.py,sha256=pPdusObXGImu6hAkY6TxVCRoVoM0cbABy3FQIurhAqc,15164
@@ -371,7 +371,7 @@ bootstack/widgets/_impl/composites/radiogroup.py,sha256=CEYhCfBgH19Y7x-63nqKdycb
 bootstack/widgets/_impl/composites/scrolledtext.py,sha256=Dkp2ATIe-UADhvVDl6W6xEEwe-3AWkv2mESC5wP9Xik,15000
 bootstack/widgets/_impl/composites/scrolledtext.pyi,sha256=GceUarQJWlYKA2nly7mbIA3LJDxOJXO0QQyKEbbiQ3U,6475
 bootstack/widgets/_impl/composites/scrollview.py,sha256=zGN-xG0lIgB2O5Yz7j-LF4UeGR6-Fx-KjoplqMzZp78,32762
-bootstack/widgets/_impl/composites/selectbox.py,sha256=p33lKNiu-L7PbgYnjvs3nLOaxDgQrqnjfuvm_HkXO8g,50447
+bootstack/widgets/_impl/composites/selectbox.py,sha256=ncdXL1O4Bv_COuOQzytE6n8LDIT7Z31oR3FxZxIHuP8,55986
 bootstack/widgets/_impl/composites/spinnerentry.py,sha256=6CSvsastkc9j6CsloFsaDACSDrfrkoFda9BlYEjJwzQ,7006
 bootstack/widgets/_impl/composites/textentry.py,sha256=xH5NqG5bbMlv-OgaifIYkgUcNvXVSi4Q3VhFwqvCV50,2978
 bootstack/widgets/_impl/composites/timeentry.py,sha256=T5X93ueTDvUEemD5y96jt6_ApQHeMjWON6p-YW1T9lY,7503
@@ -467,10 +467,10 @@ bootstack/widgets/_impl/primitives/sizegrip.py,sha256=uwQRzOEHjNPXtUURhT6k2TNYdy
 bootstack/widgets/_impl/primitives/spinbox.py,sha256=5m0tZrqCw745nvIiBrJWnZ0q8fZ7bNEvopjROMbQolc,4526
 bootstack/widgets/_impl/primitives/switch.py,sha256=7dt43uE2P_WdkxZZsGtCFRAQ20nI2jx5VUqGSrWwEmA,2543
 bootstack/widgets/_impl/primitives/treeview.py,sha256=vnSowgzmtNEWst_i9ZgcacHjdvuheF9xmeTvTWE1bLg,2709
-bootstack-0.3.0.dist-info/licenses/LICENSE,sha256=CUeTPUOM8Qc0yuqneJUwuUmDBooET5UfsHjMrkdBeCg,1097
-bootstack-0.3.0.dist-info/licenses/NOTICE,sha256=c62TcygUKbXx1V3FEgziroDDry_NwmycqKEg_CRnYBU,1503
-bootstack-0.3.0.dist-info/METADATA,sha256=OWxwKlDIgf7qzuU1Ni7BCkzWflhlfHdhcxJe1Rxj2Gc,16107
-bootstack-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-bootstack-0.3.0.dist-info/entry_points.txt,sha256=phOlfRy3Th86IYlNhQiUrTLLLzxie1IG-kMas_5iMdA,49
-bootstack-0.3.0.dist-info/top_level.txt,sha256=IsKBAac2vRCegvRFSCzwcBr7TpHp4bLnLFgA75LOkXs,10
-bootstack-0.3.0.dist-info/RECORD,,
+bootstack-0.3.2.dist-info/licenses/LICENSE,sha256=CUeTPUOM8Qc0yuqneJUwuUmDBooET5UfsHjMrkdBeCg,1097
+bootstack-0.3.2.dist-info/licenses/NOTICE,sha256=c62TcygUKbXx1V3FEgziroDDry_NwmycqKEg_CRnYBU,1503
+bootstack-0.3.2.dist-info/METADATA,sha256=2LYdOq369ONQlATAYL6CwvKpd9l_nLHylhC8U298q3Q,16107
+bootstack-0.3.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bootstack-0.3.2.dist-info/entry_points.txt,sha256=phOlfRy3Th86IYlNhQiUrTLLLzxie1IG-kMas_5iMdA,49
+bootstack-0.3.2.dist-info/top_level.txt,sha256=IsKBAac2vRCegvRFSCzwcBr7TpHp4bLnLFgA75LOkXs,10
+bootstack-0.3.2.dist-info/RECORD,,