bootstack 0.1.0__py3-none-any.whl

bootstack/widgets/select.py

@@ -0,0 +1,302 @@
+from __future__ import annotations
+
+import tkinter
+from typing import overload, Any, Callable, Literal, TYPE_CHECKING
+
+from bootstack.widgets._impl.composites.selectbox import SelectBox as _InternalSelectBox
+from bootstack.widgets._core.base import PublicWidgetBase, adapt_handler
+from bootstack.widgets._core.events import resolve_event, register_widget_events
+from bootstack.widgets._core.options import record_to_dict
+from bootstack.events import ChangeEvent, Subscription
+from bootstack.streams import Stream
+from bootstack.widgets.textfield import _INNER_ENTRY_SEQUENCES
+from bootstack.widgets.types import AccentToken, Event, Option, OptionDict, WidgetDensity
+
+if TYPE_CHECKING:
+    from bootstack.signals import Signal
+
+_SELECT_EVENTS: dict[str, str] = {
+    "change": "<<Change>>",
+}
+
+
+class Select(PublicWidgetBase):
+    """A single-selection dropdown field.
+
+    The options list is the first positional argument. All options are
+    keyword-only.
+
+    Args:
+        options: Choices presented in the popup. Each item is a plain string,
+            a `(text, value)` tuple, or a `{'text': ..., 'value': ...}` dict —
+            so an option's displayed label can differ from its stored value.
+            A dict option may also carry `'icon'` (a glyph rendered beside the
+            row label) and `'disabled'` (when `True` the row is dimmed and
+            cannot be chosen); any other keys ride along as carried data on
+            `selection`. Defaults to an empty list.
+        value: Initially selected value (value-space — matches an option's
+            value, not its label).
+        signal: Reactive `Signal` two-way bound to the field's displayed text.
+            With decoupled options (text differs from value), bind to the value
+            via `on_change`/`value`; the signal carries the display text.
+        label: Label displayed above the field.
+        message: Hint or helper text displayed below the field.
+        required: If `True`, marks the field as required and prevents
+            empty submission.
+        searchable: If `True`, typing in the field filters the option
+            list. Defaults to `False`.
+        allow_custom_values: If `True`, users may type values not in
+            `options`. Defaults to `False`.
+        group_by: Name of an option field to cluster the popup rows under
+            non-selectable group headers (e.g. `'category'`). The field is read
+            from each option's flat record, so it may be any carried bag key (or
+            `'text'`/`'value'`). Groups appear in first-appearance order; an
+            option missing the field renders headerless. Grouping is
+            presentational only — `value`/`selection` are unaffected. `None`
+            (default) renders a flat list.
+        max_visible_items: Approximate number of option rows the popup shows
+            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.
+        disabled: If `True`, field is fully non-interactive and dimmed.
+        width: Width in character units.
+        accent: Accent token applied to the focus ring.
+        density: Padding density.
+        localize: Whether option labels (in the popup and the selected label
+            shown in the field) are translated through the catalog — `True`,
+            `False`, or `'auto'` (translate when a translation is registered,
+            otherwise show the literal). Defaults to the app's `localize_mode`.
+            Set `False` to keep proper nouns untranslated; override a single
+            option with its `localize` key. When searching is enabled, search
+            matches the displayed (translated) labels.
+        parent: Explicit parent widget. If omitted, the current
+            context-stack container is used.
+        **kwargs: Layout placement options applied by the parent container —
+            `fill`, `expand`, `anchor`, `margin`, `row`, `column`, `sticky`.
+            See :doc:`/tasks/layout`.
+    """
+
+    def __init__(
+        self,
+        options: list[Option] | None = None,
+        *,
+        value: Any = None,
+        signal: "Signal[str] | None" = None,
+        label: str | None = None,
+        message: str | None = None,
+        required: bool = False,
+        searchable: bool = False,
+        allow_custom_values: bool = False,
+        group_by: str | None = None,
+        max_visible_items: int | None = None,
+        read_only: bool = False,
+        disabled: bool = False,
+        width: int | None = None,
+        accent: AccentToken | str | None = None,
+        density: WidgetDensity | None = None,
+        localize: bool | Literal['auto'] | None = None,
+        parent: Any = None,
+        **kwargs: Any,
+    ) -> None:
+        self._parent = self._resolve_parent(parent)
+        layout_kw = self._split_layout_kwargs(kwargs)
+        tk_master = self._parent._child_master() if self._parent else None
+
+        internal_kwargs: dict[str, Any] = {
+            "items":               options or [],
+            "enable_search":       searchable,
+            "allow_custom_values": allow_custom_values,
+            "group_by":            group_by,
+            "max_visible_items":   max_visible_items,
+            # Public Select rejects an unknown value (unless custom values are
+            # allowed); internal/embedded SelectBoxes stay lenient.
+            "strict_value":        not allow_custom_values,
+        }
+        if value is not None:
+            internal_kwargs["value"] = value
+        if signal is not None:
+            internal_kwargs["textsignal"] = signal
+        if label is not None:
+            internal_kwargs["label"] = label
+        if message is not None:
+            internal_kwargs["message"] = message
+        if required:
+            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:
+            internal_kwargs["accent"] = accent
+        if density is not None:
+            internal_kwargs["density"] = density
+        if localize is not None:
+            internal_kwargs["localize"] = localize
+
+        self._internal = _InternalSelectBox(tk_master, **internal_kwargs)
+        self._attach_to_parent(layout_kw)
+
+    # ----- Event routing -----
+
+    def _entry_widget(self) -> tkinter.Misc:
+        return self._internal._entry
+
+    @overload
+    def on(self, event: str) -> Stream: ...
+    @overload
+    def on(self, event: str, handler: Callable[[Event], Any]) -> Subscription: ...
+    def on(self, event: str, handler: Callable[[Event], Any] | None = None) -> Stream | Subscription:
+        """Register a callback for an event by name.
+
+        A generic, string-keyed escape hatch — prefer the typed `on_*`
+        shorthands (e.g. `on_change`), which carry the precise payload type.
+        Called with no handler, returns a composable `Stream`; with a handler,
+        binds it and returns a `Subscription`.
+
+        Args:
+            event: Event name (for example `'change'` or `'focus'`).
+            handler: Called with the event payload. Omit to get a composable
+                :class:`~bootstack.streams.Stream` instead.
+
+        Returns:
+            A cancellable :class:`~bootstack.events.Subscription` when a handler
+            is given, otherwise a :class:`~bootstack.streams.Stream`.
+        """
+        sequence = resolve_event(self, str(event))
+        target = self._entry_widget() if sequence in _INNER_ENTRY_SEQUENCES else self._internal
+        if handler is None:
+            def _source(h):
+                t = self._entry_widget() if sequence in _INNER_ENTRY_SEQUENCES else self._internal
+                bid = t.bind(sequence, adapt_handler(h), add="+")
+                return Subscription(t, sequence, bid)
+            return Stream(self._internal, _source=_source)
+        bid = target.bind(sequence, adapt_handler(handler), add="+")
+        return Subscription(target, sequence, bid)
+
+    # ----- Properties -----
+
+    @property
+    def value(self) -> Any:
+        """The currently selected value, or `None` if unselected.
+
+        This is the option's *value* (value-space). For the displayed label, see
+        `text`.
+        """
+        return self._internal.value
+
+    @value.setter
+    def value(self, v: Any) -> None:
+        self._internal.value = v
+
+    @property
+    def text(self) -> str:
+        """The label currently shown in the field — the selected option's text.
+
+        Read-only; the complement of `value` (the selection's value). Assign to
+        `value` to change the selection.
+        """
+        return self._internal.text
+
+    @property
+    def selection(self) -> dict | None:
+        """The selected option as a full record dict — the data bag — or `None`.
+
+        `{'text': ..., 'value': ..., ...any extra keys}`, indexed by key like
+        any record. `None` when nothing is selected or the value is a custom
+        off-list one. Read-only.
+        """
+        return self._internal.selection
+
+    @property
+    def options(self) -> list[OptionDict]:
+        """The available options as normalized `{'text', 'value'}` records.
+
+        Assigning a new list rebuilds the popup. Accepts the same `Option`
+        forms as the constructor (strings, `(text, value)` tuples, or dicts).
+        """
+        return [record_to_dict(r) for r in self._internal.cget("items")]
+
+    @options.setter
+    def options(self, items: list[Option]) -> None:
+        self._internal.configure(items=list(items))
+
+    @property
+    def group_by(self) -> str | None:
+        """Name of the option field the popup clusters rows under, or `None`.
+
+        Assigning a field name groups the popup the next time it opens; assign
+        `None` to render a flat list. Grouping is presentational only — it does
+        not affect `value`, `selection`, or `options`.
+        """
+        return self._internal.cget("group_by")
+
+    @group_by.setter
+    def group_by(self, field: str | None) -> None:
+        self._internal.configure(group_by=field or "")
+
+    @property
+    def max_visible_items(self) -> int | None:
+        """Approximate option-row cap before the popup scrolls, or `None`.
+
+        Assigning takes effect the next time the popup opens; assign `None` to
+        restore the built-in cap. Height is `max_visible_items * row_height`,
+        so group headers and separators make the count approximate.
+        """
+        return self._internal.cget("max_visible_items")
+
+    @max_visible_items.setter
+    def max_visible_items(self, n: int | None) -> None:
+        self._internal.configure(max_visible_items=n or 0)
+
+    @property
+    def selected_index(self) -> int:
+        """Zero-based index of the selected option, or `-1` if none selected."""
+        return self._internal.selected_index
+
+    @selected_index.setter
+    def selected_index(self, v: int) -> None:
+        self._internal.selected_index = v
+
+    @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"
+
+    @read_only.setter
+    def read_only(self, v: bool) -> None:
+        self._internal.configure(state="readonly" if v else "normal")
+
+    @property
+    def disabled(self) -> bool:
+        """Whether the field is fully non-interactive."""
+        return str(self._entry_widget().cget("state")) == "disabled"
+
+    @disabled.setter
+    def disabled(self, v: bool) -> None:
+        self._internal.configure(state="disabled" if v else "normal")
+
+    # ----- Event shorthands -----
+
+    @overload
+    def on_change(self) -> Stream: ...
+    @overload
+    def on_change(self, handler: Callable[[ChangeEvent], Any]) -> Subscription: ...
+    def on_change(self, handler: Callable[[ChangeEvent], Any] | None = None) -> Stream | Subscription:
+        """Register a callback fired when the selection changes.
+
+        Args:
+            handler: Called with a :class:`~bootstack.events.ChangeEvent`. Omit
+                to get a composable :class:`~bootstack.streams.Stream` instead.
+
+        Returns:
+            A cancellable :class:`~bootstack.events.Subscription` when a
+            handler is given, otherwise a :class:`~bootstack.streams.Stream`.
+        """
+        return self.on("change", handler)
+
+
+register_widget_events(Select, _SELECT_EVENTS)

bootstack/widgets/selectbutton.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import overload, Any, Callable, Literal, TYPE_CHECKING
+
+from bootstack.widgets._impl.primitives.optionmenu import OptionMenu as _InternalOptionMenu
+from bootstack.widgets._core.base import PublicWidgetBase
+from bootstack.widgets._core.events import register_widget_events
+from bootstack.widgets._core.icon_image_props import IconProperty
+from bootstack.widgets._core.options import record_to_dict
+from bootstack.events import ChangeEvent, Subscription
+from bootstack.streams import Stream
+from bootstack.widgets.types import AccentToken, Event, Option, OptionDict, WidgetDensity, ButtonVariant, IconSpec
+
+if TYPE_CHECKING:
+    from bootstack.signals import Signal
+
+_SELECTBUTTON_EVENTS: dict[str, str] = {
+    "change": "<<Change>>",
+}
+
+
+class SelectButton(IconProperty, PublicWidgetBase):
+    """A button that opens a dropdown value list — a button-styled alternative to `Select`.
+
+    Clicking the button opens a popup list of options. The selected value is
+    displayed on the button face. Unlike `Select`, there is no text field —
+    the button is the only interaction point.
+
+    Args:
+        options: Choices shown in the popup. Each item is a plain string, a
+            `(text, value)` tuple, or a `{'text': ..., 'value': ...}` dict — so
+            an option's displayed label can differ from its stored value, e.g.
+            `["Light", "Dark"]` or `[("Light theme", "light")]`. A dict option
+            may also carry `'icon'` (a glyph rendered beside the menu label) and
+            `'disabled'` (when `True` the item is dimmed and cannot be chosen);
+            any other keys ride along as carried data on `selection`.
+        value: Initially selected value (value-space — matches an option's
+            value, not its label). Must match one of the options.
+        signal: Reactive `Signal[str]` controlling the selected value. When
+            provided, `value=` is ignored — seed the Signal directly.
+        disabled: If `True`, the button is non-interactive and dimmed.
+            Defaults to `False`.
+        accent: Accent token applied to the button.
+        variant: Button style variant. Default `'solid'`.
+        density: Padding density.
+        icon: Bootstrap Icons name shown on the button beside the value.
+        localize: Whether option labels (and the selected label on the button
+            face) are translated through the catalog — `True`, `False`, or
+            `'auto'` (translate when a translation is registered, otherwise show
+            the literal). Defaults to the app's `localize_mode`. Set `False` to
+            keep proper nouns untranslated; override a single option with its
+            `localize` key.
+        parent: Explicit parent widget. If omitted, the current
+            context-stack container is used.
+        **kwargs: Layout placement options applied by the parent container —
+            `fill`, `expand`, `anchor`, `margin`, `row`, `column`, `sticky`.
+            See :doc:`/tasks/layout`.
+    """
+
+    def __init__(
+        self,
+        options: list[Option] | None = None,
+        *,
+        value: Any = None,
+        signal: "Signal[str] | None" = None,
+        disabled: bool = False,
+        accent: AccentToken | str | None = None,
+        variant: ButtonVariant = "default",
+        density: WidgetDensity | None = None,
+        icon: str | IconSpec | None = None,
+        localize: bool | Literal['auto'] | None = None,
+        parent: Any = None,
+        **kwargs: Any,
+    ) -> None:
+        self._parent = self._resolve_parent(parent)
+        layout_kw = self._split_layout_kwargs(kwargs)
+        tk_master = self._parent._child_master() if self._parent else None
+
+        internal_kwargs: dict[str, Any] = {
+            "options": options or [],
+        }
+        if value is not None:
+            internal_kwargs["value"] = value
+        if signal is not None:
+            internal_kwargs["textsignal"] = signal
+        if disabled:
+            internal_kwargs["state"] = "disabled"
+        if accent is not None:
+            internal_kwargs["accent"] = accent
+        if variant is not None:
+            internal_kwargs["variant"] = variant
+        if density is not None:
+            internal_kwargs["density"] = density
+        if icon is not None:
+            internal_kwargs["icon"] = icon
+        if localize is not None:
+            internal_kwargs["localize"] = localize
+
+        self._internal = _InternalOptionMenu(tk_master, **internal_kwargs)
+        self._attach_to_parent(layout_kw)
+
+    # ----- Properties -----
+
+    @property
+    def value(self) -> Any:
+        """The currently selected value, or `None` if unselected.
+
+        This is the option's *value* (value-space). For the displayed label, see
+        `text`.
+        """
+        return self._internal.get()
+
+    @value.setter
+    def value(self, v: Any) -> None:
+        self._internal.set(v)
+
+    @property
+    def text(self) -> str:
+        """The label currently shown on the button — the selected option's text.
+
+        Read-only; the complement of `value`. Assign to `value` to change the
+        selection.
+        """
+        return self._internal.text
+
+    @property
+    def selection(self) -> dict | None:
+        """The selected option as a full record dict — the data bag — or `None`.
+
+        `{'text': ..., 'value': ..., ...any extra keys}`, indexed by key like
+        any record. Read-only.
+        """
+        return self._internal.selection
+
+    @property
+    def options(self) -> list[OptionDict]:
+        """The available options as normalized `{'text', 'value'}` records.
+
+        Assigning a new list rebuilds the dropdown. Accepts the same `Option`
+        forms as the constructor (strings, `(text, value)` tuples, or dicts).
+        """
+        return [record_to_dict(r) for r in self._internal.cget("options")]
+
+    @options.setter
+    def options(self, items: list[Option]) -> None:
+        self._internal.configure(options=list(items))
+
+    @property
+    def signal(self) -> "Signal[str] | None":
+        """The reactive `Signal` linked to this button, or `None`."""
+        return getattr(self._internal, 'textsignal', None)
+
+    @property
+    def disabled(self) -> bool:
+        """Whether the button is non-interactive."""
+        return str(self._internal.cget("state")) == "disabled"
+
+    @disabled.setter
+    def disabled(self, v: bool) -> None:
+        self._internal.configure(state="disabled" if v else "normal")
+
+    # ----- Event shorthands -----
+
+    @overload
+    def on_change(self) -> Stream: ...
+    @overload
+    def on_change(self, handler: Callable[[ChangeEvent], Any]) -> Subscription: ...
+    def on_change(self, handler: Callable[[ChangeEvent], Any] | None = None) -> Stream | Subscription:
+        """Register a callback fired whenever the selected value changes.
+
+        Args:
+            handler: Called with a :class:`~bootstack.events.ChangeEvent`. Omit
+                to get a composable :class:`~bootstack.streams.Stream` instead.
+
+        Returns:
+            A cancellable :class:`~bootstack.events.Subscription` when a
+            handler is given, otherwise a :class:`~bootstack.streams.Stream`.
+        """
+        return self.on("change", handler)
+
+
+register_widget_events(SelectButton, _SELECTBUTTON_EVENTS)

bootstack/widgets/sidebar_toggle.py

@@ -0,0 +1,130 @@
+"""SidebarToggle — a hamburger button that collapses/expands an AppShell sidebar.
+
+This is not a standalone, place-anywhere widget like `ThemeToggle`: a sidebar
+toggle only means anything in the context of one shell's sidebar. It is built by
+`Toolbar.add_sidebar_toggle()` / `StatusBar.add_sidebar_toggle()`, which wire it
+to the owning `AppShell`; it is not exported at the `bootstack` top level.
+"""
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from bootstack.widgets.button import Button
+from bootstack.widgets.types import AccentToken, ButtonVariant, WidgetDensity
+
+
+class SidebarToggle(Button):
+    """A hamburger button that collapses and expands an AppShell's sidebar.
+
+    Clicking it toggles the shell's sidebar. With `collapse='compact'` (the
+    default — the desktop convention) it shrinks the sidebar to an icon rail when
+    that sidebar can show icons (a static `page_nav`), and falls back to fully
+    hiding it when it can't (a data-bound `list_nav`/`tree_nav`). With
+    `collapse='hidden'` it always toggles between hidden and expanded. Its icon
+    can reflect the current state — `expand_icon` is shown while the sidebar is
+    collapsed (clicking expands it) and `collapse_icon` while it is expanded
+    (clicking collapses it); each falls back to `icon` when not given.
+
+    Args:
+        shell: The `AppShell` whose sidebar this controls.
+        collapse: What "collapse" means — `'compact'` (shrink to the icon rail
+            where possible, else hide; the default) or `'hidden'` (always fully
+            hide).
+        icon: Base icon, used for both states unless a state-specific icon is
+            given. Defaults by mode — `'layout-sidebar'` (a panel glyph) for
+            `collapse='compact'`, `'list'` (a hamburger) for `collapse='hidden'`.
+        expand_icon: Icon shown while the sidebar is collapsed (the affordance to
+            expand it). Falls back to `icon`.
+        collapse_icon: Icon shown while the sidebar is expanded (the affordance to
+            collapse it). Falls back to `icon`.
+        variant: Button style variant. Default `'ghost'`.
+        density: Padding density — `'default'` or `'compact'`.
+        accent: Accent token applied to the icon. Defaults to the foreground.
+        parent: Explicit parent widget. If omitted, the current context-stack
+            container is used.
+        **kwargs: Layout placement options applied by the parent container.
+    """
+
+    def __init__(
+        self,
+        *,
+        shell: Any,
+        collapse: Literal["compact", "hidden"] = "compact",
+        icon: str | None = None,
+        expand_icon: str | None = None,
+        collapse_icon: str | None = None,
+        variant: ButtonVariant = "ghost",
+        density: WidgetDensity = "default",
+        accent: AccentToken | str | None = None,
+        parent: Any = None,
+        **kwargs: Any,
+    ) -> None:
+        self._shell = shell
+        self._collapse = collapse
+        # Default glyph follows the collapse mode: a panel for the icon rail, a
+        # hamburger for full hide.
+        if icon is None:
+            icon = "layout-sidebar" if collapse == "compact" else "list"
+        self._base_icon = icon
+        self._expand_icon = expand_icon
+        self._collapse_icon = collapse_icon
+        super().__init__(
+            on_click=self._toggle,
+            icon=self._state_icon(),
+            variant=variant,
+            density=density,
+            accent=accent,
+            parent=parent,
+            **kwargs,
+        )
+
+        # Keep the icon matching the live sidebar state — toggling here or
+        # elsewhere (Ctrl-B, another control) refreshes it. Setting the icon never
+        # fires a click, so there is no cycle.
+        self._subs = [
+            shell.on_sidebar_toggle(self._sync_icon),
+            shell.on_sidebar_mode_change(self._sync_icon),
+        ]
+        self.on_destroy(self._cleanup_sidebar_toggle)
+
+    def _is_expanded(self) -> bool:
+        return self._shell.sidebar_mode == "expanded"
+
+    def _state_icon(self) -> str:
+        if self._is_expanded():
+            return self._collapse_icon or self._base_icon
+        return self._expand_icon or self._base_icon
+
+    def _toggle(self) -> None:
+        if self._collapse == "hidden":
+            # Always fully hide (VS Code-style focus collapse).
+            self._shell.toggle_sidebar()
+            return
+        # "compact": collapse as far as is useful — to the icon rail when the
+        # active sidebar can show icons, otherwise hide it (a data list can't
+        # compact). Mirrors the shell's own Ctrl-B behavior.
+        if self._can_compact():
+            mode = self._shell.sidebar_mode
+            self._shell.sidebar_mode = "expanded" if mode == "compact" else "compact"
+        else:
+            self._shell.toggle_sidebar()
+
+    def _can_compact(self) -> bool:
+        """Whether the active sidebar can shrink to icons (vs. only hide)."""
+        try:
+            return bool(self._shell._internal._can_compact_active())
+        except Exception:
+            return False
+
+    def _sync_icon(self, _event: Any = None) -> None:
+        self.icon = self._state_icon()
+
+    def _cleanup_sidebar_toggle(self, _event: Any = None) -> None:
+        for sub in self._subs:
+            try:
+                sub.cancel()
+            except Exception:
+                pass
+
+
+__all__ = ["SidebarToggle"]

bootstack/widgets/sizegrip.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bootstack.widgets._impl.primitives.sizegrip import SizeGrip as _InternalSizeGrip
+from bootstack.widgets._core.base import PublicWidgetBase
+from bootstack.widgets.types import AccentToken
+
+
+class SizeGrip(PublicWidgetBase):
+    """A resize handle placed in the corner of a window or panel.
+
+    Typically anchored to the bottom-right corner so users can drag to resize
+    the parent window.
+
+    Args:
+        accent: Accent token for styling.
+        parent: Override the context-stack parent.
+        **kwargs: Layout placement options applied by the parent container —
+            `fill`, `expand`, `anchor`, `margin`, `row`, `column`, `sticky`.
+            See :doc:`/tasks/layout`.
+    """
+
+    def __init__(
+        self,
+        *,
+        accent: AccentToken | str | None = None,
+        parent: Any = None,
+        **kwargs: Any,
+    ) -> None:
+        self._parent = self._resolve_parent(parent)
+        layout_kw = self._split_layout_kwargs(kwargs)
+
+        tk_master = self._parent._child_master() if self._parent else None
+
+        internal_kwargs: dict[str, Any] = {}
+        if accent is not None:
+            internal_kwargs["accent"] = accent
+        # **kwargs is layout-only (split out above) — not forwarded to the internal.
+
+        self._internal = _InternalSizeGrip(tk_master, **internal_kwargs)
+        self._attach_to_parent(layout_kw)