//! Narrow, single-concern widget traits + an adapter into the legacy `WidgetHost` tree — Phase 5 of
 //! the core rebuild (see `docs/rfc-core-rebuild.md` §3.5 and §5).
 //!
 //! Phase 5 replaces the ~123-method [`WidgetHost`] god-trait with small traits, one per concern. A
 //! *non-breaking supertrait carve-out* of `WidgetHost` is not possible in Rust, for two reasons found
 //! by experiment:
 //!
 //! 1. The structural methods the layout/paint passes need (`rect`, `children`, `set_rect`, …) are
 //!    overridden in dozens of widgets across cce-ui **and** the app crates. Moving them off
 //!    `WidgetHost` breaks every override; merely *declaring* them on a supertrait breaks every call
 //!    site too, because a supertrait method is always in scope on the subtrait — `elem.children()`
 //!    on a `&dyn WidgetHost` becomes ambiguous.
 //! 2. Trait-object coercion does not offer a way around it: a blanket "view" impl
 //!    `impl<T: WidgetHost> Paint for T` does **not** let `&dyn WidgetHost` coerce to `&dyn Paint`
 //!    (that coercion only exists for real supertraits).
 //!
 //! So we take the RFC's recommended **adapter** path. The traits here — [`Layout`] and [`Paint`] —
 //! are *independent* of `WidgetHost` (no super/sub relationship). A widget written against them is
 //! placed into the existing `*mut dyn WidgetHost` tree by wrapping it in [`Adapted`], whose `WidgetHost`
 //! impl forwards each legacy method to the matching narrow-trait method and supplies the
 //! [`Widget`] base that `WidgetHost`'s rect/id/dirty machinery reads. Existing `impl WidgetHost` widgets
 //! are untouched; new or migrated widgets implement only the concern traits they need; both kinds
 //! coexist in one tree. When the last widget is migrated, `WidgetHost` and this adapter are deleted.
 //!
 //! This commit lands the two concerns the scene passes already consume: [`Layout`] drives
 //! [`crate::scene::bridge`] and [`Paint`] drives [`crate::scene::painter`]. The input/event
 //! concern follows in its own commit.
 
 use crate::scene::layout::{Rect, Size};
 use crate::scene::paint::{PaintCtx, Prim};
 use crate::widget::{WidgetHost, Event, TextLabel, UiContext, Widget, WidgetId, WidgetHostExt};
 
 /// Layout inputs for the scene layout engine — the RFC's `Widget` concern, named `Layout` here to
 /// avoid the existing [`Widget`] base struct.
 pub trait Layout {
     /// Intrinsic content size of a leaf (e.g. measured text), consumed by the adapter's
     /// `measure` (gated on [`Layout::intrinsic_measure_width`]).
     fn intrinsic_size(&self) -> Option<Size> {
         None
     }
 
     /// Whether this widget's base label IS its content — the text a `Button` face, a
     /// `Checkbox` row or a `Label` draws itself — rather than a control label, which
     /// the adapter draws detached above the content (the one convention for every
     /// labeled control: `layout::control_label_strip` tall, at
     /// [`detached_label_inset`](Layout::detached_label_inset)). Inline-label widgets
     /// carry no label strip and get no content-rect inset.
     fn inline_label(&self) -> bool {
         false
     }
 
     /// Horizontal inset of the detached base label: [`crate::layout::DETACHED_LABEL_INSET`]
     /// for every control, so a column of labels is one line and the carve-out tabs
     /// (which hug the label at this inset) sit under their labels.
     fn detached_label_inset(&self) -> f32 {
         crate::layout::DETACHED_LABEL_INSET
     }
 
     /// Whether `WidgetHost::measure` should prefer [`intrinsic_size`](Layout::intrinsic_size)'s
     /// width over the current rect width (Dropdown's `auto_width` measure override — hosts size
     /// it from `measure`, e.g. cce-system-interface' page dropdown). Default: keep the legacy
     /// `WidgetHost::measure` width (the current rect's).
     fn intrinsic_measure_width(&self) -> bool {
         false
     }
 
     /// Whether the adapter's hit test substitutes the base row rect (`row_x`/`row_w`, pushed in
     /// by row-layout hosts via `set_row_rect`) — the legacy
     /// `WidgetHost::hit_test` default geometry. Migrated controls so far dropped it (accepted
     /// drift); TextBox restores it (cce-files' save-name box relies on row hits). Default: off,
     /// keeping the other migrated widgets exactly as they shipped.
     fn hit_row_rect(&self) -> bool {
         false
     }
 
     /// Adjust a row-rect assignment before it lands on the base (`WidgetHost::set_row_rect` —
     /// TextBox clamps the row width to its `width`/`max_width`). Default: identity.
     fn adjust_row_rect(&self, x: f32, w: f32) -> (f32, f32) {
         (x, w)
     }
 
     /// The final base rect landed from a `set_rect`, visible or not — unlike
     /// [`arrange_children`](Layout::arrange_children), which the adapter gates on visibility.
     /// TextBox caches it (its cursor/scroll math reads the laid-out rect between events) and
     /// re-clamps its scroll, the legacy `set_rect` side effect. Default: ignore.
     fn rect_assigned(&mut self, _rect: Rect) {}
 
     /// Adjust a rect assignment before it lands on the base (Switcher clamps to its parent).
     /// Default: identity.
     fn adjust_rect(&self, requested: Rect) -> Rect {
         requested
     }
 
     /// Position children after a `set_rect`. Called only while the widget is visible. There
     /// is no context here: a child the context holds (`widget::Embedded`) is placed in
     /// [`register_embedded_children`](Layout::register_embedded_children) from the rect
     /// kept here.
     fn arrange_children(&mut self, _rect: Rect) {}
 
     /// Legacy `WidgetHost::z_index` (host render ordering; MenuBar's dropdowns layer at 100+).
     fn z_order(&self) -> i32 {
         0
     }
 
     /// Republish value-embedded legacy children into the ctx registry (Paginator's ButtonStrip
     /// and Pages). Legacy value-owning containers re-registered their children on EVERY `tick` and
     /// `layout` because the children's addresses move with the owning struct (host struct moves,
     /// `Vec` reallocation) — and the registration is load-bearing: the spatial grid is rebuilt
     /// from registered widgets, and it is the registered ButtonStrip (whose
     /// `blocks_root_plate_drag` is true) that makes the sidebar block root plate drags. The
     /// adapter calls this from `WidgetHost::tick` and `WidgetHost::layout`, mirroring the legacy
     /// cadence. `host_id` is the adapter's id, for `link_ids`. Default: nothing embedded.
     fn register_embedded_children(&mut self, _host_id: WidgetId, _ctx: &mut UiContext) {}
 
     /// Give back the children `register_embedded_children` put into `ctx`
     /// (`Embedded::detach`), so a widget removed from its context leaves with them. Called by
     /// `UiContext::remove`. Default: nothing embedded.
     fn release_embedded_children(&mut self, _ctx: &mut UiContext) {}
 }
 
 /// The paint concern — a widget's fill color, its own (non-recursive) geometry emission, and
 /// whether it clips its children. Mirrors `WidgetHost::color` / `paint_self` / `clips_children`, but
 /// [`paint`](Paint::paint) receives the laid-out `rect` as a parameter (the RFC shape) rather than
 /// reading a stored rect, so a narrow widget carries no base of its own.
 pub trait Paint {
     /// This widget's fill color (RGBA).
     fn color(&self) -> [f32; 4];
 
     /// Emit this node's OWN primitives (non-recursive) into `ctx`, given its final `rect`. The
     /// default paints a plain background from [`color`](Paint::color) — the common leaf case.
     /// Recursion into children and clipping are the paint walk's job ([`crate::scene::painter`]),
     /// not this method's.
     fn paint(&self, rect: Rect, ctx: &mut PaintCtx) {
         let color = self.color();
         if color[3].abs() > 0.001 {
             ctx.quad(rect, color);
         }
     }
 
     /// [`paint`](Paint::paint) with the live [`UiContext`] — what `paint_self` actually calls.
     /// The default forwards to `paint`, so ordinary widgets implement only that. Override this
     /// for composites whose own geometry aggregates hover/coverage-dependent child chrome that
     /// needs the context (ParametersBg): child-holding widgets that never entered the arena tree
     /// have no other way to reach it from the paint path.
     fn paint_ui(&self, _ui: &UiContext, rect: Rect, ctx: &mut PaintCtx) {
         self.paint(rect, ctx);
     }
 
     /// Whether the paint walk clips this widget's children to its `rect` (scroll/root plate
     /// containers). Default: no.
     fn clips_children(&self) -> bool {
         false
     }
 
     /// Corner rounding `(radius, per-corner flags)` of the widget's background, given its
     /// laid-out rect (MenuBar's corners depend on where it sits against its parent's edges).
     /// What a host drawing the widget's PLATE reads — `WidgetHostExt::corner_radii`, the
     /// designer's `append_widget_plate`, the flat-host bridge; the widget's own geometry is
     /// whatever [`paint`](Paint::paint) emits. Default: sharp corners.
     fn corner_style(&self, _rect: Rect) -> Option<(f32, (bool, bool, bool, bool))> {
         None
     }
 
     /// This widget's OWN popover (dropdown) rect, if one is open — hosts float it above
     /// z-ordered siblings (`register_popover` + `render_popovers`). Containers combine this
     /// with their children's popovers in the adapter. Default: none.
     fn popover(&self, _rect: Rect) -> Option<(f32, f32, f32, f32)> {
         None
     }
 
     /// Draw this widget's own popover (legacy `WidgetHost::render_popover`).
     fn draw_popover(&self, _rect: Rect, _pc: &mut dyn crate::layout::RenderTarget) {}
 
     /// Solid border `(color, thickness)` of the widget's background quad. **Transitional**, like
     /// [`corner_style`](Paint::corner_style): `render_widget` gives a widget's background quad a
     /// border+inset treatment when this is `Some` — `Toggle`'s square mode depends on it.
     fn solid_border(&self) -> Option<([f32; 4], f32)> {
         None
     }
 
     /// Font for this widget's text on legacy text paths (`render_widget` reads
     /// `WidgetHost::widget_font`). **Transitional.**
     fn widget_font(&self) -> Option<String> {
         None
     }
 
     /// Font for the widget's OWN prim-derived text on the scene paint walk (Phase 6). Defaults
     /// to [`widget_font`](Paint::widget_font) — one font for everything the widget draws, which
     /// is the legacy tuple-pipeline convention. A widget whose content text deliberately
     /// differs from its control font (TextBox with a customized `font_family`/`font_size`)
     /// overrides this; the detached base label always renders in `widget_font`. Only the paint
     /// walk consults it — the legacy `text_labels_with_font_and_bounds` getters keep serving
     /// `widget_font` so unmigrated apps stay byte-identical.
     fn text_font(&self) -> Option<String> {
         self.widget_font()
     }
 
     /// Shaping attributes (italic / weight) for the same content text
     /// [`text_font`](Paint::text_font) names — a TextBox showing a specific
     /// face of its family (the font picker's preview of a Bold or Thin cut).
     /// The detached base label never takes them.
     fn text_attrs(&self) -> crate::scene::paint::TextAttrs {
         crate::scene::paint::TextAttrs::default()
     }
 
     /// Receive the control label set on the wrapper via [`Adapted::with_label`] (and legacy
     /// `Control::set_label` paths). Widgets that paint their label themselves (inline-label
     /// widgets) store it here; the default discards it, leaving label drawing to the adapter's
     /// base-label machinery.
     fn sync_label(&mut self, _label: &str) {}
 
     /// Clip rect `[x1, y1, x2, y2]` for this widget's text on the legacy bounded-text paths
     /// (`text_labels_with_bounds` / `text_labels_with_font_and_bounds`). `None` (default) keeps
     /// the legacy behavior: unbounded, except inside a scroll ancestor. Graph clips its node
     /// names to its own rect.
     fn text_bounds(&self, _rect: Rect) -> Option<[f32; 4]> {
         None
     }
 
     /// Per-frame text shaping against the app's `FontSystem` (legacy `WidgetHost::prepare_text`
     /// overrides). TextBox measures its glyph advances here — load-bearing for cursor↔pixel
     /// mapping, not just a render cache. Receives the laid-out content rect. Default: nothing
     /// to shape.
     fn prepare_text(&mut self, _fs: &mut cosmic_text::FontSystem, _rect: Rect) {}
 
     /// Whether [`paint`](Paint::paint) emits the widget's ENTIRE subtree, so the paint walk
     /// must not also descend into its (ctx-linked) children — the legacy
     /// `WidgetHost::renders_own_subtree` contract. TreeList: its field widgets stay ctx-linked
     /// for event propagation, but their pixels come from `paint`'s own child pass (which
     /// gates the add-key popover box on the popover actually being open).
     fn paints_own_subtree(&self) -> bool {
         false
     }
 
 
     /// Whether the widget wears the shared focus highlight: the primary tint over its row
     /// span while it holds focus, drawn by the adapter over its background. Only the TextBox
     /// opts in (the focused editor's teal wash in the data editor). Default: none.
     fn legacy_focus_highlight(&self) -> bool {
         false
     }
 
     /// Whether this widget serves
     /// [`legacy_labels_with_font_and_bounds`](Paint::legacy_labels_with_font_and_bounds) —
     /// the text sibling of the dual-geometry escape hatch. The adapter's standard text bridge
     /// gives every own label ONE font ([`widget_font`](Paint::widget_font)) and ONE clip rect
     /// ([`text_bounds`](Paint::text_bounds)); a widget whose legacy
     /// `text_labels_with_font_and_bounds` override assigns them PER LABEL (ParametersBg clips
     /// each label to its viewport but its code editor's to the code box, in monospace) serves
     /// that view verbatim instead. Transitional — dies when `Prim::Text` carries font+bounds.
     fn serves_legacy_labels(&self) -> bool {
         false
     }
 
     /// The per-label font+bounds text view for legacy `text_labels_with_font_and_bounds`
     /// readers. Served as a FULL replacement: the adapter adds no child aggregation on top, so
     /// a container's implementation must include its children (as the legacy overrides did —
     /// hence the ctx, which the child recursion needs).
     fn legacy_labels_with_font_and_bounds(&self, _rect: Rect, _ctx: &UiContext) -> Vec<(TextLabel, Option<String>, Option<[f32; 4]>)> {
         Vec::new()
     }
 
 }
 
 /// What an event handler may reach beyond its own state — the RFC §3.5 `EventCtx`, grown as
 /// migrated widgets need capabilities: the laid-out content rect, the widget's id (scroll-gesture
 /// gating keys on it), focus acquisition, and — transitionally — the raw [`UiContext`] for the
 /// legacy shared state some widgets consult (`scroll_gesture_new`, …). `ui` is `None` when the
 /// event was synthesized outside a routed path (the `FocusIn`/`FocusOut` from direct
 /// `focus()`/`unfocus()` calls).
 pub struct EventCtx<'a> {
     /// The widget's content rect (detached-label region excluded).
     pub rect: Rect,
     /// This widget's tree id.
     pub id: WidgetId,
     /// The routing context, when routed. **Transitional** — narrow widgets should only touch the
     /// legacy shared fields (scroll gesture state) until those get typed helpers here.
     pub ui: Option<&'a mut UiContext>,
     /// Where [`open_context_menu`](EventCtx::open_context_menu) asked for the menu: the
     /// adapter opens it once the widget has handled the event, handing itself over.
     menu_at: Option<(f32, f32)>,
 }
 
 impl<'a> EventCtx<'a> {
     pub(crate) fn new(rect: Rect, id: WidgetId, ui: Option<&'a mut UiContext>) -> Self {
         EventCtx { rect, id, ui, menu_at: None }
     }
 
     /// Open the context menu a widget asked for while it handled the event, on `host` (the
     /// widget's adapter, done handling it).
     pub(crate) fn open_requested_menu(self, host: &dyn WidgetHost) {
         if let (Some((px, py)), Some(ui)) = (self.menu_at, self.ui) {
             ui.handle_right_click(host, px, py);
         }
     }
 }
 
 impl EventCtx<'_> {
     /// Make this widget the window's focus (`UiContext::focused_widget`). Recorded, not
     /// dispatched: the widget is handling an event now and has its focus already; the
     /// widget that held focus before is told (`unfocus`). Without a context (inside
     /// `focus()` / `unfocus()`, whose caller is the context) there is nothing to record.
     pub fn request_focus(&mut self) {
         let id = self.id;
         if let Some(ui) = self.ui.as_deref_mut() {
             ui.claim_focus(id);
         }
     }
 
     /// Drop this widget's hold on the window's focus, if it has it (MenuBar releases focus
     /// when its dropdowns close).
     pub fn release_focus(&mut self) {
         let id = self.id;
         if let Some(ui) = self.ui.as_deref_mut() {
             if ui.focused_widget == Some(id) {
                 ui.focused_widget = None;
             }
         }
     }
 
     /// Whether this widget holds the window's focus.
     pub fn is_focused(&self) -> bool {
         self.ui.as_deref().is_some_and(|ui| ui.focused_widget == Some(self.id))
     }
 
     /// Open the shared context menu on this widget (legacy `ctx.handle_right_click(self, …)`),
     /// for widgets that must do work *before* the menu opens — Breadcrumb records which segment
     /// was right-clicked first, so the menu header can show that segment's path.
     /// [`Input::opens_context_menu`] can't express that: the adapter's gate runs instead of
     /// `on_event`, not after it. The menu opens when the widget has handled the event (the
     /// adapter hands itself to the context then). No-op outside a routed path.
     pub fn open_context_menu(&mut self, px: f32, py: f32) {
         if self.ui.is_some() {
             self.menu_at = Some((px, py));
         }
     }
 }
 
 /// The input concern — hit-testing and event handling against the laid-out rect. Mirrors the
 /// legacy `WidgetHost::hit_test` / `handle_event` pair, but with the RFC's centralizations: the
 /// default hit is plain rect containment (no per-widget address hacks), and pointer-positioned
 /// events are hit-gated by the adapter *before* they reach [`on_event`](Input::on_event), so a
 /// narrow widget never re-implements the "am I actually under the cursor?" boilerplate that every
 /// legacy `mouse_input` override carries.
 /// A widget's part in keyboard navigation — see [`Input::focus_role`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FocusRole {
     /// Not a stop: the traversal skips it.
     None,
     /// A plate — a thing you press. Enter / Space act on it while focused.
     Plate,
     /// A well — a thing you enter. It opens for typing when focused.
     Well,
 }
 
 pub trait Input {
     /// Whether the point `(x, y)` hits this widget, given its laid-out `rect`. Override for
     /// non-rectangular hit shapes. Default: containment (edges inclusive, matching the legacy
     /// `hit_test`).
     fn hit(&self, rect: Rect, x: f32, y: f32) -> bool {
         x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height
     }
 
     /// React to `event`. Return `true` to consume it (the router marks the widget dirty and
     /// stops propagation). `MouseButton` *presses* and `MouseWheel` arrive only when
     /// [`hit`](Input::hit) passed; *releases* arrive ungated (press-tracking widgets commit or
     /// cancel from anywhere); `MouseEnter` / `MouseLeave` are synthesized by the hover machinery.
     /// Default: ignore everything.
     fn on_event(&mut self, _event: &Event, _ectx: &mut EventCtx) -> bool {
         false
     }
 
     /// Whether pressing on this widget blocks dragging the movable root plate under it. Passive
     /// display widgets (separators, status dots) return `false` so drags pass through them.
     /// Default: `true`, matching the legacy `WidgetHost` default.
     fn blocks_root_plate_drag(&self) -> bool {
         true
     }
 
     /// Whether a right-click on this widget opens the shared config context menu (the adapter
     /// then routes it to `UiContext::handle_right_click`, which `on_event` can't reach — it has
     /// no ctx by design). Default: no.
     fn opens_context_menu(&self) -> bool {
         false
     }
 
     /// What this widget is to keyboard navigation — see "Plates, wells and
     /// seams" in `CLAUDE.md`. A [`FocusRole::Plate`] is a thing you press
     /// (Enter / Space act on it while focused); a [`FocusRole::Well`] opens
     /// for typing when focused. Both are stops for `UiContext::focus_step`.
     /// Default: [`FocusRole::None`] — skipped by the traversal. A widget that
     /// declares a role must handle `FocusIn` / `FocusOut`.
     fn focus_role(&self) -> FocusRole {
         FocusRole::None
     }
 
     /// Whether, focused, this widget takes Tab itself, so the toolkit's Tab walk
     /// (`Application::plate_navigation`) passes it the key instead of moving focus: a
     /// multi-line text box that is editing types it. The group chord (`focus_next_group`,
     /// Ctrl+Tab by default) still leaves it. Default false: Tab leaves a widget.
     fn keeps_tab(&self) -> bool {
         false
     }
 
     /// Whether the adapter hit-gates `MouseButton` presses before `on_event` (the leaf
     /// centralization). Event-proxying containers return `false`: legacy container
     /// `mouse_input` overrides saw every press — Switcher unfocuses its active child when a
     /// press lands outside it, which a gated `on_event` would never learn about.
     fn gates_presses(&self) -> bool {
         true
     }
 
     // --- The legacy polling/value-binding surface (`take_click`, `take_change`,
     // `get_value_string`/`set_value_string`, `value`) apps read widget state through. Kept on
     // `Input` to avoid a fourth trait bound; replaced by typed messages when RFC §3.5's EventCtx
     // lands. All default to the inert legacy defaults.
 
     /// Consume the "was clicked since last asked" flag.
     fn take_click(&mut self) -> bool {
         false
     }
 
     /// Consume the "value changed since last asked" flag.
     fn take_change(&mut self) -> bool {
         false
     }
 
     /// The widget's value serialized for the config system.
     fn value_string(&self) -> Option<String> {
         None
     }
 
     /// What this widget is to assistive technology, when the toolkit's guess from its type
     /// and [`focus_role`](Input::focus_role) is not it (`crate::a11y::role_for`). Default
     /// `None`: the guess stands.
     fn a11y_role(&self) -> Option<accesskit::Role> {
         None
     }
 
     /// The range an assistive tool may set this widget's value in, as `(min, max, step)` in
     /// the units [`value_string`](Input::value_string) reads in — a slider's or spin
     /// button's. Default `None`: the value is not a number a reader can set.
     fn a11y_range(&self) -> Option<(f64, f64, f64)> {
         None
     }
 
     /// The parts of this widget a screen reader should see as nodes of their own, under the
     /// widget's node: a radio group's radio buttons. `rect` is the widget's content rect.
     /// Default none.
     fn a11y_items(&self, _rect: Rect) -> Vec<crate::a11y::A11yItem> {
         Vec::new()
     }
 
     /// An assistive tool clicked item `idx` of [`a11y_items`](Input::a11y_items): do what a
     /// press on it does, reported as a change. Returns whether anything changed.
     fn a11y_select_item(&mut self, _idx: usize) -> bool {
         false
     }
 
     /// The text a reader reads and edits, when this widget is a text field: what it shows,
     /// its caret and selection (`crate::a11y::A11yText`). The tree publishes it as text runs,
     /// which is what gives the field AT-SPI's Text and EditableText interfaces. Default
     /// `None`: not a text field (its [`value_string`](Input::value_string) is its value).
     fn a11y_text(&self) -> Option<crate::a11y::A11yText> {
         None
     }
 
     /// Replace the field's text with what an assistive tool asked for (AT-SPI's
     /// `SetTextContents`), as the user replacing it would — undoable, the caret at its end —
     /// and mark it changed, so the host's `take_change` reports it. Returns whether it
     /// changed. Default: not settable.
     fn a11y_set_text(&mut self, _text: &str) -> bool {
         false
     }
 
     /// Set the value an assistive tool asked for (AT-SPI's `SetCurrentValue`), clamped to
     /// [`a11y_range`](Input::a11y_range), and mark it changed as a typed value would be, so
     /// the host's `take_change` reports it. Returns whether it changed. Default: not
     /// settable.
     fn a11y_set_value(&mut self, _value: f64) -> bool {
         false
     }
 
     /// Set the widget's value from a config string. Returns whether it parsed and changed.
     fn set_value_string(&mut self, _val: &str) -> bool {
         false
     }
 
     /// The widget's value as an integer (legacy `WidgetHost::value`).
     fn value(&self) -> i32 {
         0
     }
 
     // --- Clipboard/selection surface (the context menu's Cut/Copy/Paste/Select-All actions
     // call these on their target WidgetHost). The defaults replicate the `WidgetHost` defaults
     // byte-for-byte (whole-value copy through the value-string pair), so widgets migrated
     // before these hooks existed keep their exact behavior; TextBox overrides with real
     // selection-aware implementations.
 
     fn context_action(&mut self, action: crate::widget::ContextAction) -> bool {
         match action {
             crate::widget::ContextAction::Cut => {
                 if let Some(val) = self.value_string() {
                     crate::widget::clipboard::copy_to_clipboard(&val);
                     self.set_value_string("")
                 } else {
                     false
                 }
             }
             crate::widget::ContextAction::Copy => {
                 if let Some(val) = self.value_string() {
                     crate::widget::clipboard::copy_to_clipboard(&val);
                     true
                 } else {
                     false
                 }
             }
             crate::widget::ContextAction::Paste => {
                 if let Some(text) = crate::widget::clipboard::read_from_clipboard() {
                     self.set_value_string(&text)
                 } else {
                     false
                 }
             }
             _ => false,
         }
     }
 
     /// Whether direct `focus()`/`unfocus()` calls flip the base `focused` flag. Legacy widgets
     /// differ: most set it in their `focus` overrides, but TextBox never did — its detached
     /// label must not color as focused. Default: flip it (what every widget migrated so far
     /// has shipped with).
     fn tracks_base_focus(&self) -> bool {
         true
     }
 
     /// Selection state pushed in by list/row hosts (legacy `WidgetHost::set_selected`).
     fn set_selected(&mut self, _selected: bool) {}
 
     // --- Drag surface: legacy hosts (designer, control_panel, parameters_bg, graph, audio…)
     // drive drags by calling these directly on the widget, not through events.
 
     /// Whether a press on this widget starts a host-driven drag. Receives the laid-out rect:
     /// scroll widgets (Spreadsheet) are draggable only while their content overflows it.
     fn draggable(&self, _rect: Rect) -> bool {
         false
     }
     fn is_dragging(&self) -> bool {
         false
     }
     fn drag_begin(&mut self, _px: f32, _py: f32, _rect: Rect) {}
     /// Returns whether the drag changed the widget's value (drives redraw).
     fn drag_update(&mut self, _px: f32, _py: f32, _rect: Rect) -> bool {
         false
     }
     /// For self-moving widgets (Panel, Splitter): the new origin this drag step wants, or `None`
     /// if unmoved. The adapter applies it to the base rect (the model cannot reach it).
     fn drag_reposition(&mut self, _px: f32, _py: f32, _rect: Rect) -> Option<(f32, f32)> {
         None
     }
     fn drag_end(&mut self) {}
     /// Movement bounds pushed in by hosts (reached via the inherent `Adapted::set_drag_bounds`).
     fn set_drag_bounds(&mut self, _bx: f32, _by: f32, _bw: f32, _bh: f32) {}
 
     // --- Tick surface: hosts broadcast `WidgetHost::tick(dt)` every frame (the designer's render
     // loop) to advance time-based widget state — inertial scroll velocity, here. Transitional:
     // §3.6 `Animated<T>` + arena-driven frame requests replace hand-ticked state.
 
     /// Advance time-based state by `dt` seconds against the laid-out rect. Return whether
     /// anything observable changed (drives redraw).
     fn tick(&mut self, _dt: f32, _rect: Rect) -> bool {
         false
     }
 
     /// Context-carrying tick for legacy stateful containers whose per-frame work needs the
     /// routing context — TreeList commits its inline rename editor, re-targets focus, and
     /// drains its search box on tick. Runs right after [`tick`](Input::tick) with a routed
     /// [`EventCtx`] (ui + the adapter's id/pointer). Transitional, like the capability hooks.
     fn tick_ctx(&mut self, _dt: f32, _ectx: &mut EventCtx) -> bool {
         false
     }
 
     /// Whether this widget wants `tick` calls from tick-gating hosts (legacy
     /// `WidgetHost::wants_tick`; the designer ticks unconditionally and ignores this).
     fn wants_tick(&self) -> bool {
         false
     }
 
     /// Whether this widget consumes scroll gestures (legacy `WidgetHost::is_scrollable`, read by
     /// the router's scroll-gesture gating).
     fn scrollable(&self) -> bool {
         false
     }
 
     // --- Controller capabilities (transitional, like the polling surface above). The legacy
     // tree reaches a widget's typed API through the `WidgetHost::as_*_controller` downcast pairs;
     // `WidgetHost` is implemented exactly once (for `Adapted<W>`), so a migrated controller widget
     // re-exposes its controller impl through these hooks instead — `Some(self)` when `W`
     // implements the trait. Dies with `WidgetHost`: the end state reaches a controller through the
     // concrete `Adapted<W>` (or a `&dyn XController` held directly), per RFC §3.5.
 
 
     /// Keyboard modifier state pushed in by hosts before dispatch (legacy
     /// `WidgetHost::set_modifiers`).
     fn set_modifiers(&mut self, _ctrl: bool, _shift: bool, _alt: bool) {}
 
     /// The widget's visibility flag changed through `WidgetHost::set_visible` (the adapter owns
     /// the flag) — legacy hideable widgets used the setter for side effects (MenuBar closes
     /// its dropdowns and invalidates layout).
     fn visibility_changed(&mut self, _visible: bool) {}
 
     /// The widget's `WidgetHost::focused` answer, given the base flag — MenuBar reports focused
     /// while any of its dropdowns is open, beyond the flag itself. Default: the flag.
     fn is_focused(&self, base_focused: bool) -> bool {
         base_focused
     }
 
 }
 
 /// Wraps a narrow-trait widget `W` so it lives in the legacy `*mut dyn WidgetHost` tree. Carries the
 /// [`Widget`] base that `WidgetHost`'s rect / id / dirty machinery needs, and forwards the concern
 /// methods to `W`. See the module docs for why this bridge exists rather than a supertrait split.
 ///
 /// The bounds live on the struct (not just the `WidgetHost` impl) so `Drop` can clear the global
 /// focus / context-menu references through `&dyn WidgetHost` — the same guard legacy widgets with
 /// `Drop` impls (e.g. the old `Checkbox`) carried.
 #[derive(Debug, Clone)]
 pub struct Adapted<W: Layout + Paint + Input + 'static> {
     base: Widget,
     /// The [`Widget`] base carries no visibility, and the legacy `WidgetHost` defaults are a no-op
     /// `set_visible` + always-true `visible()` — every hideable legacy widget stores its own
     /// flag. The adapter owns it once for all migrated widgets: hosts toggle panes through
     /// `WidgetHost::set_visible` (the designer), and the hit-test/render bridges gate on it.
     visible: bool,
     inner: W,
 }
 
 impl<W: Layout + Paint + Input + 'static> Drop for Adapted<W> {
     fn drop(&mut self) {
         crate::widget::clear_widget_references(self);
     }
 }
 
 /// Plain-data widgets constructed via `Default` (PreviewState in cce-files) keep their
 /// construction sites when the wrapper lands.
 impl<W: Layout + Paint + Input + Default + 'static> Default for Adapted<W> {
     fn default() -> Self {
         Adapted::new(W::default())
     }
 }
 
 impl<W: Layout + Paint + Input + 'static> Adapted<W> {
     /// Wrap `inner` with a fresh [`Widget`] base.
     pub fn new(inner: W) -> Self {
         Adapted { base: Widget::new(), visible: true, inner }
     }
 
     /// The wrapped widget.
     pub fn inner(&self) -> &W {
         &self.inner
     }
 
     /// The wrapped widget, mutably.
     pub fn inner_mut(&mut self) -> &mut W {
         &mut self.inner
     }
 
     /// This widget's tree id (assigned lazily), for registering it in a [`UiContext`].
     pub fn id(&self) -> WidgetId {
         self.base.id()
     }
 
     /// Attach a control label. Mirrors the `with_label` builders legacy control widgets carry,
     /// so construction sites keep their shape when a widget migrates. The label is stored on the
     /// base (legacy machinery: label offsets, context-menu titles) *and* pushed into the widget
     /// via [`Paint::sync_label`] for widgets that paint it themselves.
     pub fn with_label(mut self, label: &str) -> Self {
         self.base.label = Some(label.to_string());
         self.inner.sync_label(label);
         self
     }
 
     /// Bind this widget to a config file/key (right-click context-menu editing). Mirrors the
     /// legacy `with_config` builders.
     pub fn with_config(mut self, file: &str, key: &str) -> Self {
         self.base.config_file = Some(file.to_string());
         self.base.config_key = Some(key.to_string());
         self
     }
 
     /// Update the control label, keeping the base copy (legacy machinery) and the widget's own
     /// copy ([`Paint::sync_label`]) in step. Inherent so it shadows `Control::set_label` — which
     /// writes only the base and would leave a self-painting label stale — at every call site,
     /// regardless of which traits are in scope.
     pub fn set_label(&mut self, label: &str) {
         self.base.label = Some(label.to_string());
         self.inner.sync_label(label);
     }
 
     /// Take the control label off again: the base copy goes to `None`, so
     /// the adapter reserves no label strip, and the widget's own copy is
     /// synced empty — which the self-painting widgets' strip rule
     /// (`slider::detached_strip`) reads as no label. What a host needs when
     /// it moves a label from the control to a column of its own
     /// (`ParametersBg` re-flowing a narrow pane).
     pub fn clear_label(&mut self) {
         self.base.label = None;
         self.inner.sync_label("");
     }
 
     /// Name the widget to a screen reader without drawing a label
     /// ([`Widget::accessible_name`]); `None` falls back to the label.
     pub fn set_accessible_name(&mut self, name: Option<&str>) {
         self.base.accessible_name = name.map(str::to_string);
     }
 
     // --- The value/polling drains (off `WidgetHost` in the 6bd value shrink): apps read
     // widget state through these concrete methods; each forwards to the narrow `Input`
     // hook. The last dyn readers went concrete-slot instead (TI roster, cloud JsonControl,
     // designer pane-focus sync).
 
     /// Drain the one-shot click flag (Button-class widgets).
     pub fn take_click(&mut self) -> bool {
         Input::take_click(&mut self.inner)
     }
 
     /// Drain the one-shot value-changed flag.
     pub fn take_change(&mut self) -> bool {
         Input::take_change(&mut self.inner)
     }
 
     /// The widget's value serialized to a string (config writes, context-menu Copy).
     pub fn get_value_string(&self) -> Option<String> {
         Input::value_string(&self.inner)
     }
 
     /// Parse and apply a value string; returns whether the value changed.
     pub fn set_value_string(&mut self, val: &str) -> bool {
         Input::set_value_string(&mut self.inner, val)
     }
 
     /// The widget's value as an integer.
     pub fn value(&self) -> i32 {
         Input::value(&self.inner)
     }
 
     /// Selection state pushed in by list/row hosts.
     pub fn set_selected(&mut self, selected: bool) {
         Input::set_selected(&mut self.inner, selected)
     }
 
     /// Text-content mutation: keep the base copy and the widget's own copy
     /// ([`Paint::sync_label`]) in step, like `set_label`.
     pub fn set_text(&mut self, text: &str) {
         self.base.label = Some(text.to_string());
         Paint::sync_label(&mut self.inner, text);
     }
 
 }
 
 impl<W: Layout + Paint + Input + 'static> Adapted<W> {
     /// Whether a press here may start a drag (off `WidgetHost` — the ControlPanel
     /// endgame; forwards to the narrow `Input` hook with the laid-out content rect).
     pub fn draggable(&self) -> bool {
         Input::draggable(&self.inner, self.content_rect())
     }
 
     /// Whether the widget's own drag is live (off `WidgetHost` with `draggable`).
     pub fn is_dragging(&self) -> bool {
         Input::is_dragging(&self.inner)
     }
 
     /// Movement bounds pushed in by hosts (off the `WidgetHost` trait since 6bd — the one
     /// production caller is concrete: designer's network panel).
     pub fn set_drag_bounds(&mut self, bx: f32, by: f32, bw: f32, bh: f32) {
         Input::set_drag_bounds(&mut self.inner, bx, by, bw, bh)
     }
 
     /// Unlink all tree children (off `WidgetHost` in 6bd batch 2 — every caller is a concrete
     /// `Adapted` field).
     pub fn clear_children(&mut self, ctx: &mut UiContext) {
         ctx.clear_children_ids(self.base.id());
     }
 
     // --- The direct-dispatch entry points, inherent since the 6bd collapse. In-crate
     // composites forward to their CONCRETE embedded children through these; dyn callers
     // and the router go through `handle_event`, which these forward to (the two paths
     // are identical by construction — including Drag*, which handle_event maps onto the
     // Input drag hooks).
 
     pub fn mouse_input(&mut self, button: crate::widget::MouseButton, state: crate::widget::ElementState, px: f32, py: f32, ctx: &mut UiContext) -> bool {
         self.handle_event(
             &Event::MouseButton { button, state, x: px, y: py, local_x: px, local_y: py },
             ctx,
         )
     }
     pub fn mouse_wheel(&mut self, delta: &crate::widget::MouseScrollDelta, px: f32, py: f32, ctx: &mut UiContext) -> bool {
         self.handle_event(
             &Event::MouseWheel { delta: *delta, x: px, y: py, local_x: px, local_y: py },
             ctx,
         )
     }
 
     /// [`Self::mouse_wheel`] WITHOUT the adapter's rect hit-gate: straight to the
     /// widget's `Input::on_event`. For hosts that already zone-gated the wheel
     /// themselves against a capture region LARGER than the widget rect — the
     /// band slider's shape-conforming halo extends past the row rect, and the
     /// rect gate would clip exactly the fringe the halo exists to catch
     /// (`ParametersBg`'s slider forwarding). The widget's own on_event still
     /// applies its fine-grained zone test.
     /// Offer `event` to the widget's `on_event`, routed (with the context), and open the
     /// context menu it asked for, if any, once it is done.
     fn offer(&mut self, event: &Event, ctx: &mut UiContext) -> bool {
         let mut ectx = EventCtx::new(self.content_rect(), self.base.id(), Some(ctx));
         let consumed = Input::on_event(&mut self.inner, event, &mut ectx);
         ectx.open_requested_menu(&*self);
         consumed
     }
 
     pub fn mouse_wheel_ungated(
         &mut self,
         delta: &crate::widget::MouseScrollDelta,
         px: f32,
         py: f32,
         ctx: &mut UiContext,
     ) -> bool {
         self.offer(&Event::MouseWheel { delta: *delta, x: px, y: py, local_x: px, local_y: py }, ctx)
     }
     pub fn keyboard_input(&mut self, event: &crate::widget::KeyEvent, ctx: &mut UiContext) -> bool {
         self.handle_event(&Event::KeyInput(event.clone()), ctx)
     }
     pub fn drag_begin(&mut self, px: f32, py: f32) {
         let rect = self.content_rect();
         Input::drag_begin(&mut self.inner, px, py, rect)
     }
     pub fn drag_update(&mut self, px: f32, py: f32) -> bool {
         let rect = self.content_rect();
         if let Some((nx, ny)) = Input::drag_reposition(&mut self.inner, px, py, rect) {
             self.base.x = nx;
             self.base.y = ny;
             return true;
         }
         Input::drag_update(&mut self.inner, px, py, rect)
     }
     pub fn drag_end(&mut self) {
         Input::drag_end(&mut self.inner)
     }
 
     /// The deleted trait default: coverage-gated hover dispatch (an open popover covering
     /// the point clears the hover instead of recomputing it).
     pub fn cursor_moved(&mut self, px: f32, py: f32, ctx: &mut UiContext) -> bool {
         ctx.set_cursor_pos(px, py);
         if ctx.is_coordinate_covered(self.base.id(), px, py) {
             let was = self.base.hovered;
             if was {
                 self.base.hovered = false;
                 self.handle_event(&Event::MouseLeave, ctx);
             }
             return was;
         }
         self.on_cursor_moved(px, py, ctx)
     }
 
     /// Ungated pointer moves (no popover-coverage check): offer the raw move to the widget,
     /// then fall back to the base hover bookkeeping, mirroring `handle_event`'s `PointerMove`
     /// arm. Not routed *through* `handle_event`, because the routed path reaches this method
     /// too (via `cursor_moved`) and would recurse; on that path `on_event` sees the same
     /// unconsumed move twice, which is fine — a hover recompute is idempotent (anything
     /// that changed on the first call consumed it there).
     pub fn on_cursor_moved(&mut self, px: f32, py: f32, ctx: &mut UiContext) -> bool {
         let event = Event::PointerMove { x: px, y: py, local_x: px, local_y: py };
         if self.offer(&event, ctx) {
             return true;
         }
         let was = self.base.hovered;
         let is_hit = self.hit_test(px, py, ctx);
         self.base.hovered = is_hit;
         if was != is_hit {
             let transition = if is_hit { Event::MouseEnter } else { Event::MouseLeave };
             self.handle_event(&transition, ctx);
             true
         } else {
             false
         }
     }
 
     /// Link this widget under `parent`, or unlink it from its parent (`None`).
     pub fn set_parent(&mut self, parent: Option<WidgetId>, ctx: &mut UiContext) {
         ctx.tree.set_parent(self.base.id(), parent);
     }
 
     /// The model's intrinsic content size (off the `WidgetHost` trait since 6bd — the concrete
     /// callers are fonts'/graph's hand-laid button/dropdown sizing).
     pub fn intrinsic_size(&self) -> Option<Size> {
         Layout::intrinsic_size(&self.inner)
     }
 
 
 
 
     /// This widget's OWN text (prim-derived + detached base label), before any child
     /// aggregation — the shared source for the three text getters.
     pub(crate) fn own_text_labels(&self) -> Vec<TextLabel> {
         if !self.visible() {
             return Vec::new();
         }
         let mut out: Vec<TextLabel> = self
             .painted_prims()
             .into_iter()
             .filter_map(|prim| match prim {
                 Prim::Text { text, x, y, font_size, color, .. } => {
                     Some(TextLabel { text, x, y, font_size, color })
                 }
                 _ => None,
             })
             .collect();
         if !Layout::inline_label(&self.inner) {
             out.extend(self.base_label_fallback());
         }
         out
     }
 
     /// This widget's GLYPHS — the image prims its [`Paint::paint`] emits, a
     /// dropdown's arrow or a spinbox's −/+ — as `(image, rect, alpha)`, for a
     /// container that paints its children's chrome itself and collects their
     /// text through [`own_text_labels`](Self::own_text_labels) (the
     /// parameters pane). Until 2026-10-05 those symbols were text and rode
     /// the labels; as glyphs nothing carried them, and the pane drew its
     /// controls without their arrows.
     pub(crate) fn own_glyphs(&self) -> Vec<(u32, Rect, f32)> {
         if !self.visible() {
             return Vec::new();
         }
         self.painted_prims()
             .into_iter()
             .filter_map(|prim| match prim {
                 Prim::Image { image, rect, alpha } => Some((image, rect, alpha)),
                 _ => None,
             })
             .collect()
     }
 
     /// The paint walk's own-labels bridge: prim-derived text in the widget's content font
     /// ([`Paint::text_font`]), plus the detached base label in the configured detached-label
     /// font. Fed the Text prims `paint_self` already holds from its own pass — running
     /// `Paint::paint` a second time just to get them back doubled every leaf's paint cost.
     fn own_labels_from_painted(
         &self,
         _ctx: &UiContext,
         painted: Vec<TextLabel>,
         prim_font: Option<String>,
     ) -> Vec<(TextLabel, Option<String>, Option<[f32; 4]>)> {
         // The detached label is the adapter's, not the widget's: one font for every
         // control's label — `style.control.label.font_detached`, whose size
         // `base_label_fallback` already takes — whatever font the widget's own content
         // uses (a TreeList's rows, a Breadcrumb's segments) or does not declare. A
         // widget with no `widget_font` used to fall back to the engine's sans default
         // here, so half the gallery's labels were in a different face.
         //
         // `text_bounds` clips the widget's content text only. The detached label sits
         // in the strip above the content, so a widget clipping its content to its own
         // rect (Graph) clipped its label away, and one clipping to the inside of its
         // relief (TextBox's well floor) could not do so at all while the label shared
         // the clip — TextBox widened it to the whole block, and its text ran over its
         // wall. (The legacy scroll-ancestor clamp ended here too: always a no-op since
         // Phase 6av — ScrollBox, the last scroll ancestor type, never appeared as a
         // tree parent.)
         let base_font = Some(crate::layout::control_label_font_detached());
         let bounds = Paint::text_bounds(&self.inner, self.content_rect());
         let mut out: Vec<(TextLabel, Option<String>, Option<[f32; 4]>)> = Vec::new();
         if self.visible() {
             out.extend(painted.into_iter().map(|l| (l, prim_font.clone(), bounds)));
             if !Layout::inline_label(&self.inner) {
                 out.extend(self.base_label_fallback().into_iter().map(|l| (l, base_font.clone(), None)));
             }
         }
         out
     }
 
     /// The base-label text of a *detached*-label widget — a replica of the legacy default
     /// `WidgetHost::text_labels` body (which an overriding impl can no longer call).
     fn base_label_fallback(&self) -> Vec<TextLabel> {
         let b = &self.base;
         if let Some(ref label) = b.label {
             let (_, font_size) = crate::layout::control_label_font_detached_parsed();
             let color = crate::colors::control_label_color_detached_for_state(b.hovered, b.focused);
             let inset = Layout::detached_label_inset(&self.inner);
             return vec![TextLabel { text: label.clone(), x: b.x + inset, y: b.y, font_size, color }];
         }
         Vec::new()
     }
 }
 
 /// Auto-deref to the wrapped widget, so call sites keep using a migrated widget's own state and
 /// methods directly (`dot.status`, `dot.set_status(..)`) without knowing about the wrapper.
 /// (By-value builders can't flow through `Deref` — those get mirrored per-widget, like
 /// `with_label` here or `UsageBar::with_colors`.)
 impl<W: Layout + Paint + Input + 'static> std::ops::Deref for Adapted<W> {
     type Target = W;
     fn deref(&self) -> &W {
         &self.inner
     }
 }
 
 impl<W: Layout + Paint + Input + 'static> std::ops::DerefMut for Adapted<W> {
     fn deref_mut(&mut self) -> &mut W {
         &mut self.inner
     }
 }
 
 impl<W: Layout + Paint + Input + 'static> WidgetHost for Adapted<W> {
     fn layout_model(&self) -> &dyn Layout {
         &self.inner
     }
     fn paint_model(&self) -> &dyn Paint {
         &self.inner
     }
     fn input_model(&self) -> &dyn Input {
         &self.inner
     }
     fn input_model_mut(&mut self) -> &mut dyn Input {
         &mut self.inner
     }
     fn base(&self) -> &Widget {
         &self.base
     }
     fn base_mut(&mut self) -> &mut Widget {
         &mut self.base
     }
     // `as_any` exposes the *inner* widget: legacy code downcasts by concrete widget type
     // (`json_layout`'s `downcast_mut::<Checkbox>()`), and the adapter must be transparent to it.
     fn as_any(&self) -> &dyn std::any::Any {
         &self.inner
     }
     fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
         &mut self.inner
     }
     fn set_visible(&mut self, visible: bool) {
         if self.visible != visible {
             self.visible = visible;
             Input::visibility_changed(&mut self.inner, visible);
         }
     }
     fn visible(&self) -> bool {
         self.visible
     }
 
     fn focused(&self, _ctx: &UiContext) -> bool {
         Input::is_focused(&self.inner, self.base.focused)
     }
 
 
     fn layout(&mut self, origin: crate::widget::Point, constraints: crate::widget::LayoutConstraints, ctx: &mut UiContext) {
         // The WidgetHost default (measure + set_rect), plus recursive child layout for visible
         // containers — the ctx-carrying half of the arrangement the model can't do in
         // `arrange_children`.
         // `origin` is the CONTENT box's top-left and `measure` its height; the detached
         // label hangs in the strip above, so the block `set_rect` takes starts `strip`
         // higher and is `strip` taller.
         let size = self.measure(constraints, ctx);
         let strip = self.label_strip();
         self.set_rect(origin.x, origin.y - strip, size.width, size.height + strip);
         let host_id = self.base.id();
         Layout::register_embedded_children(&mut self.inner, host_id, ctx);
     }
 
     fn prepare_text(&mut self, fs: &mut cosmic_text::FontSystem) {
         if self.visible() {
             let rect = self.content_rect();
             Paint::prepare_text(&mut self.inner, fs, rect);
         }
     }
 
     fn popover_rect(&self) -> Option<(f32, f32, f32, f32)> {
         if !self.visible() {
             return None;
         }
         Paint::popover(&self.inner, self.content_rect())
     }
 
     fn render_popover(&self, pc: &mut dyn crate::layout::RenderTarget) {
         if !self.visible() {
             return;
         }
         Paint::draw_popover(&self.inner, self.content_rect(), pc);
     }
 
     // --- Legacy structural conventions the adapter owns on the widget's behalf ---
 
     /// The assigned rect is the widget's whole block: the detached label strip (if any)
     /// at its top, the content below (`content_rect`). One convention for every
     /// control — a caller sizing a labeled widget by hand adds `label_strip` to the
     /// content height; `layout` does that for it.
     fn set_rect(&mut self, x: f32, y: f32, w: f32, h: f32) {
         let r = Layout::adjust_rect(&self.inner, Rect { x, y, width: w, height: h });
         self.base.x = r.x;
         self.base.y = r.y;
         self.base.w = r.width;
         self.base.h = r.height;
         // Ungated rect notification (TextBox re-clamps scroll on every assignment, hidden or
         // not — the legacy `set_rect` side effect).
         let landed = Rect { x: self.base.x, y: self.base.y, width: self.base.w, height: self.base.h };
         Layout::rect_assigned(&mut self.inner, landed);
         // Containers position their children from the assigned rect (legacy `set_rect`
         // overrides); hidden containers skip it, like the legacy impls.
         if self.visible {
             let content = self.content_rect();
             Layout::arrange_children(&mut self.inner, content);
         }
     }
 
 
     fn label_strip(&self) -> f32 {
         if Layout::inline_label(&self.inner) { 0.0 } else { self.base.label_offset() }
     }
 
     /// The detached label's box, as `base_label_fallback` places the text: at the
     /// label inset on the strip above the content, measured in the detached-label font.
     fn detached_label_rect(&self) -> Option<Rect> {
         if Layout::inline_label(&self.inner) {
             return None;
         }
         let label = self.base.label.as_deref()?;
         let (fam, size) = crate::layout::control_label_font_detached_parsed();
         let width = crate::widget::display::measure_text_width(label, &fam, size);
         Some(Rect { x: self.base.x + Layout::detached_label_inset(&self.inner), y: self.base.y, width, height: self.label_strip() })
     }
 
     /// The `WidgetHost::measure` default, except the width consults the intrinsic size when the
     /// widget opts in ([`Layout::intrinsic_measure_width`] — Dropdown's `auto_width`).
     fn measure(&self, constraints: crate::widget::LayoutConstraints, _ctx: &UiContext) -> crate::widget::Size {
         let (_, _, w, h) = self.rect();
         let pref_w = if Layout::intrinsic_measure_width(&self.inner) {
             Layout::intrinsic_size(&self.inner).map_or(w, |s| s.width)
         } else {
             w
         };
         // Content height: the intrinsic one, else the landed rect less its label strip.
         let pref_h = self.preferred_height().unwrap_or(h - self.label_strip());
         crate::widget::Size {
             width: pref_w.clamp(constraints.min_width, constraints.max_width),
             height: pref_h.clamp(constraints.min_height, constraints.max_height),
         }
     }
 
 
     /// Report the *inner* type's name, not `Adapted<W>`: runtime type-name matching (e.g.
     /// `layout.rs`' span-full widget list) must keep seeing the widget it knows.
     fn type_name(&self) -> &'static str {
         std::any::type_name::<W>().split("::").last().unwrap_or("Widget")
     }
 
     // --- Paint concern -> `Paint` ---
 
 
 
 
 
 
     fn a11y_items(&self) -> Vec<crate::a11y::A11yItem> {
         Input::a11y_items(&self.inner, self.content_rect())
     }
 
 
     fn paint_self(&self, ui: &UiContext, ctx: &mut PaintCtx) {
         let mut tmp = PaintCtx::new();
         Paint::paint_ui(&self.inner, ui, self.content_rect(), &mut tmp);
         // Subtree painters (paints_own_subtree) author their COMPLETE text in paint() —
         // per-child fonts and clip bounds included — so their Text prims pass through
         // verbatim and the single-font own-labels re-derivation below is skipped
         // (re-deriving would flatten a composite's mixed child fonts to widget_font).
         let subtree = Paint::paints_own_subtree(&self.inner);
         // The Text prims the own-labels bridge below re-derives labels from. Only
         // ParametersBg and Group override `paint_ui`, and neither reaches that
         // bridge, so this pass's text is exactly what `Paint::paint` would emit.
         let mut painted_text: Vec<TextLabel> = Vec::new();
         for item in tmp.finish().items {
             // Re-emitting through ctx re-records clip state, so restore the
             // circular clip the widget authored the prim under (Ramp's
             // foam-cell fills) — it would otherwise be dropped here.
             let clip_circle = item.clip_circle;
             if let Some(c) = clip_circle {
                 ctx.push_clip_circle(c);
             }
             // `replay` emits every prim but Text and hands Text back — the two
             // callers disagree about it. A subtree painter authored its own text
             // (per-child fonts and clips) so that passes through verbatim;
             // otherwise it is dropped in favour of the own-labels bridge below.
             if let Some(Prim::Text { text, x, y, font_size, color, font, bounds, .. }) =
                 ctx.replay(item.prim)
             {
                 if subtree {
                     ctx.text_with(text, x, y, font_size, color, font, bounds);
                 } else {
                     painted_text.push(TextLabel { text, x, y, font_size, color });
                 }
             }
             if clip_circle.is_some() {
                 ctx.pop_clip_circle();
             }
         }
         // The focus highlight a widget opts into (the TextBox): the primary tint over the
         // row span while focused, over the background. (The hover tint never drew here.)
         if Paint::legacy_focus_highlight(&self.inner) && ui.is_focused_id(self.base.id()) {
             let b = &self.base;
             let (hx, hw) = if b.row_w > 0.0 { (b.row_x, b.row_w) } else { (b.x, b.w) };
             ctx.quad(Rect { x: hx, y: b.y, width: hw, height: b.h }, crate::colors::highlight_primary_color());
         }
         // Own text with per-label font+bounds: the hatch view verbatim for hatched widgets
         // (caveat: its contract includes raw container children — those few widgets keep the
         // hatch until their hosts adopt the walk), else the standard own-labels bridge (prim
         // text + the detached base label, one font, text_bounds or the scroll-ancestor clip).
         if subtree {
             // The detached label is the adapter's, not the widget's: a subtree painter
             // authors its own text but knows nothing of the label strip above its
             // content (TreeList, Spreadsheet, Ramp), so the bridge's base-label half
             // still runs for it — in the detached-label font, like every control's.
             // Skipping it left a labelled tree's strip reserved but blank.
             if self.visible() && !Layout::inline_label(&self.inner) {
                 let font = Some(crate::layout::control_label_font_detached());
                 for tl in self.base_label_fallback() {
                     ctx.text_with(tl.text, tl.x, tl.y, tl.font_size, tl.color, font.clone(), None);
                 }
             }
             return;
         }
         // `own_labels_from_painted` lists the content labels first (all of them
         // while visible), then the base label: the first `content` take the
         // widget's `text_attrs`.
         let (labels, content) = if Paint::serves_legacy_labels(&self.inner) {
             (Paint::legacy_labels_with_font_and_bounds(&self.inner, self.content_rect(), ui), 0)
         } else {
             let content = if self.visible() { painted_text.len() } else { 0 };
             (self.own_labels_from_painted(ui, painted_text, Paint::text_font(&self.inner)), content)
         };
         let attrs = Paint::text_attrs(&self.inner);
         for (i, (tl, font, bounds)) in labels.into_iter().enumerate() {
             let attrs = if i < content { attrs } else { crate::scene::paint::TextAttrs::default() };
             ctx.text_attrs(tl.text, tl.x, tl.y, tl.font_size, tl.color, font, bounds, attrs);
         }
     }
 
     // The legacy per-widget text getters are deleted from `WidgetHost`: this adapter's text
     // reaches the frame through `paint_self` above (prim-derived own labels + the
     // detached base label), and composites that need a concrete Adapted child's labels
     // call `own_labels_with_font_and_bounds` directly (pub(crate)).
 
 
 
 
 
 
 
     // --- Input concern -> `Input` ---
     /// Row-rect assignment (row-layout hosts): apply the widget's clamp
     /// ([`Layout::adjust_row_rect`] — TextBox's `width`/`max_width`), then the base write the
     /// `WidgetHost` default does.
     fn set_row_rect(&mut self, x: f32, w: f32) {
         let (rx, rw) = Layout::adjust_row_rect(&self.inner, x, w);
         self.base.row_x = rx;
         self.base.row_w = rw;
     }
     fn attach_embedded(&mut self, ctx: &mut UiContext) {
         let host_id = self.base.id();
         Layout::register_embedded_children(&mut self.inner, host_id, ctx);
     }
 
     fn release_embedded(&mut self, ctx: &mut UiContext) {
         Layout::release_embedded_children(&mut self.inner, ctx);
     }
 
     fn tick(&mut self, dt: f32, ctx: &mut UiContext) -> bool {
         // A composite places the children the context holds from the rect it kept: every
         // tick, as on every layout.
         let host_id = self.base.id();
         Layout::register_embedded_children(&mut self.inner, host_id, ctx);
         let rect = self.content_rect();
         let mut changed = Input::tick(&mut self.inner, dt, rect);
         let mut ectx = EventCtx::new(rect, host_id, Some(ctx));
         changed |= Input::tick_ctx(&mut self.inner, dt, &mut ectx);
         ectx.open_requested_menu(&*self);
         changed
     }
     /// Focus set/cleared directly (hosts call `w.focus()`/`w.unfocus()`): keep the base flag
     /// (unless the widget opts out — [`Input::tracks_base_focus`], TextBox's legacy `focus`
     /// never set it) and tell the widget via the same `FocusIn`/`FocusOut` events the router
     /// would send.
     fn focus(&mut self) {
         if Input::tracks_base_focus(&self.inner) {
             self.base.focused = true;
         }
         let mut ectx = EventCtx::new(self.content_rect(), self.base.id(), None);
         Input::on_event(&mut self.inner, &Event::FocusIn, &mut ectx);
     }
     fn unfocus(&mut self) {
         if Input::tracks_base_focus(&self.inner) {
             self.base.focused = false;
         }
         let mut ectx = EventCtx::new(self.content_rect(), self.base.id(), None);
         Input::on_event(&mut self.inner, &Event::FocusOut, &mut ectx);
     }
 
     fn hit_test(&self, px: f32, py: f32, ctx: &UiContext) -> bool {
         // Hidden widgets are not hittable. Legacy widgets with a visibility toggle (Spreadsheet)
         // carry this gate themselves — and need it: hosts broadcast wheel/press dispatch to
         // every widget (the designer) and rely on hidden ones rejecting the hit.
         if !self.visible() {
             return false;
         }
         // Preserve the legacy occlusion check (a covering layer swallows the hit), then delegate
         // the geometric test to the narrow trait instead of the row/label-offset machinery.
         if ctx.is_coordinate_covered(self.base.id(), px, py) {
             return false;
         }
         let (x, y, w, h) = self.rect();
         // Row-hit opt-in ([`Layout::hit_row_rect`]): replicate the legacy `hit_test` default's
         // geometry — substitute the host-pushed row span — before
         // the narrow test. The width<=0 reject also comes from that default.
         if Layout::hit_row_rect(&self.inner) {
             if w <= 0.0 || h <= 0.0 {
                 return false;
             }
             let (hx, hw) = if self.base.row_w > 0.0 { (self.base.row_x, self.base.row_w) } else { (x, w) };
             return Input::hit(&self.inner, Rect { x: hx, y, width: hw, height: h }, px, py);
         }
         Input::hit(&self.inner, Rect { x, y, width: w, height: h }, px, py)
     }
 
     fn handle_event(&mut self, event: &Event, ctx: &mut UiContext) -> bool {
         let rect = self.content_rect();
         match event {
             // A hit right-press on a context-menu widget routes to the shared config menu,
             // which reads the widget itself, so the adapter owns it.
             Event::MouseButton {
                 button: crate::widget::MouseButton::Right,
                 state: crate::widget::ElementState::Pressed,
                 x: px,
                 y: py,
                 ..
             } if Input::opens_context_menu(&self.inner) => {
                 if self.hit_test(*px, *py, ctx) {
                     ctx.handle_right_click(&*self, *px, *py);
                     return true;
                 }
                 false
             }
             // Hit-gate PRESSES and wheel once, here, so narrow widgets never carry the
             // per-widget "check hit_test first" boilerplate legacy `mouse_input` overrides do.
             // RELEASES are deliberately NOT gated: a press-tracking widget (Button) must see the
             // release wherever the cursor ended up, to commit or cancel — exactly what legacy
             // `mouse_input` overrides did by receiving every release. Event-proxying containers
             // opt out of the press gate (`Input::gates_presses`): legacy container overrides
             // saw every press (Switcher unfocuses its child on an outside press).
             Event::MouseButton { state: crate::widget::ElementState::Pressed, x: px, y: py, .. }
                 if !Input::gates_presses(&self.inner) =>
             {
                 let _ = (px, py);
                 self.offer(event, ctx)
             }
             Event::MouseButton { state: crate::widget::ElementState::Pressed, x: px, y: py, .. }
             | Event::MouseWheel { x: px, y: py, .. } => {
                 self.hit_test(*px, *py, ctx) && self.offer(event, ctx)
             }
             Event::MouseButton { state: crate::widget::ElementState::Released, .. } => {
                 self.offer(event, ctx)
             }
             // Offer the raw move to the widget; if unconsumed, run the legacy hover bookkeeping
             // (base.hovered + MouseEnter/MouseLeave synthesis, which re-enters this method and
             // reaches `on_event` through the arm below).
             Event::PointerMove { x: px, y: py, .. } => {
                 if self.offer(event, ctx) {
                     return true;
                 }
                 let (px, py) = (*px, *py);
                 self.cursor_moved(px, py, ctx)
             }
             // The router's drag lifecycle (recorded drag target → DragStart/DragUpdate/
             // DragEnd) maps to the Input drag hooks, exactly like the direct
             // `WidgetHost::drag_*` entry points below — `on_event` is offered first, but no
             // widget consumes Drag* there today; without these arms the events fell into the
             // on_event default and every ROUTED drag was silently dead (the reason each app
             // historically kept its own held-drag index and called drag_update directly).
             Event::DragStart { start_x, start_y } => {
                 if self.offer(event, ctx) {
                     return true;
                 }
                 Input::drag_begin(&mut self.inner, *start_x, *start_y, rect);
                 true
             }
             Event::DragUpdate { x, y, .. } => {
                 if self.offer(event, ctx) {
                     return true;
                 }
                 if let Some((nx, ny)) = Input::drag_reposition(&mut self.inner, *x, *y, rect) {
                     self.base.x = nx;
                     self.base.y = ny;
                     return true;
                 }
                 Input::drag_update(&mut self.inner, *x, *y, rect)
             }
             Event::DragEnd => {
                 if self.offer(event, ctx) {
                     return true;
                 }
                 Input::drag_end(&mut self.inner);
                 true
             }
             // A widget hidden while still holding focus (the designer keys into
             // `focused_widget`; hiding a pane doesn't unfocus it) must not consume keys —
             // formerly the `keyboard_input` entry point's gate, now on the one funnel
             // (which also closes the routed path's missing-gate hole).
             Event::KeyInput(_) if !self.visible() => false,
             // Everything else (KeyInput, Tick, Enter/Leave, Focus*) forwards directly —
             // the legacy default dispatch would route these to leaf handlers Adapted never
             // overrides, so there is no behavior to fall back to.
             _ => self.offer(event, ctx),
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
     /// A subtree painter's own text passes through verbatim, and the adapter still
     /// draws the detached label above its content — the widget cannot, it does not
     /// know about the label.
     #[test]
     fn a_subtree_painters_detached_label_is_drawn() {
         use crate::scene::paint::PaintCtx;
         use crate::widget::{TreeList, WidgetHost};
         let ui = crate::context::UiContext::new();
         let mut tree = TreeList::new().with_label("TreeList");
         let strip = tree.label_strip();
         assert!(strip > 0.0);
         tree.set_rect(0.0, 0.0, 300.0, 200.0 + strip);
         let mut pc = PaintCtx::new();
         WidgetHost::paint_self(&tree, &ui, &mut pc);
         let texts: Vec<(String, f32)> = pc
             .finish()
             .items
             .into_iter()
             .filter_map(|it| match it.prim {
                 crate::scene::paint::Prim::Text { text, y, .. } => Some((text, y)),
                 _ => None,
             })
             .collect();
         let label = texts.iter().find(|(t, _)| t == "TreeList").expect("the detached label is drawn");
         assert_eq!(label.1, 0.0, "on the strip above the content");
         assert!(texts.iter().any(|(t, _)| t == "Key"), "the tree's own header text still passes through");
     }
 
     use super::*;
     use crate::widget::PathController;
     use crate::scene::layout::{Rect, Size};
     use crate::scene::paint::Prim;
     use crate::scene::painter::paint_tree;
     use crate::widget::UiContext;
 
     /// A leaf that only knows the two narrow concerns — no `WidgetHost` in sight: it reports an
     /// intrinsic size ([`Layout`]) and a color ([`Paint`]).
     struct Dot {
         color: [f32; 4],
         size: Size,
     }
     impl Layout for Dot {
         fn intrinsic_size(&self) -> Option<Size> {
             Some(self.size)
         }
     }
     impl Paint for Dot {
         fn color(&self) -> [f32; 4] {
             self.color
         }
     }
     impl Input for Dot {}
 
     /// A narrow container: it drives a column layout ([`Layout`]) and paints nothing.
     struct Col;
     impl Layout for Col {}
     impl Paint for Col {
         fn color(&self) -> [f32; 4] {
             [0.0, 0.0, 0.0, 0.0]
         }
     }
     impl Input for Col {}
 
     fn rect_of(w: &dyn WidgetHost) -> Rect {
         let (x, y, w, h) = w.rect();
         Rect { x, y, width: w, height: h }
     }
 
     /// One rhythm for labeled controls: the preferred height is the CONTENT height
     /// for every kind (ProgressBar, Slider, Spinbox, Dropdown), and `layout` places that
     /// content at the origin with the label strip hanging above it — so a strategy
     /// placing content boxes lines mixed controls up by content, neither squashes a
     /// track to the label's leftovers nor lets a label spill into the gap below.
     #[test]
     fn labeled_controls_land_their_content_at_the_origin_with_the_label_above() {
         use crate::widget::{Dropdown, LayoutConstraints, Point, ProgressBar, Slider, Spinbox};
         let mut ctx = UiContext::new();
         let mut slider = Slider::new().with_label("Gain");
         let mut spinbox = Spinbox::new(1, 0, 9, 1).with_label("Count");
         let mut dropdown = Dropdown::new(vec!["a".into()], 0).with_label("Pick");
         let mut bar = ProgressBar::new(0.5).with_label("Load");
         let strip = slider.base.label_offset();
         assert!(strip > 0.0, "a detached label has a strip above the content");
 
         for (name, w, content) in [
             ("slider", &mut slider as &mut dyn WidgetHost, crate::layout::slider_height()),
             ("spinbox", &mut spinbox, crate::layout::spinbox_height()),
             ("dropdown", &mut dropdown, crate::layout::dropdown_height()),
             ("progress bar", &mut bar, crate::layout::progressbar_height()),
         ] {
             let pref = w.preferred_height().expect(name);
             assert!((pref - content).abs() < 0.01, "{name}: preferred {pref} is the content height {content}");
             assert!((w.label_strip() - strip).abs() < 0.01, "{name}: one label strip");
             w.layout(Point { x: 0.0, y: 100.0 }, LayoutConstraints::new(100.0, 100.0, pref, pref), &mut ctx);
             let (_, top, _, landed) = w.rect();
             assert!((top - (100.0 - strip)).abs() < 0.01, "{name}: the label hangs above the origin (top {top})");
             assert!((landed - (content + strip)).abs() < 0.01, "{name}: occupied {landed} = content + strip");
             let painted = landed - w.label_strip();
             assert!((painted - content).abs() < 0.01, "{name}: content {painted}, wanted {content}");
         }
     }
 
     #[test]
     fn narrow_widget_lays_out_and_paints_through_the_adapter() {
         // A pure narrow-trait widget tree (Col + two Dots), wrapped in `Adapted`, is laid out by
         // the existing bridge and painted by the existing painter — proving a widget that never
         // touches `WidgetHost` participates in both live passes.
         let mut ctx = UiContext::new();
         let root = ctx.insert(Adapted::new(Col));
         let a = ctx.insert(Adapted::new(Dot { color: [1.0, 0.0, 0.0, 1.0], size: Size::new(10.0, 10.0) }));
         let b = ctx.insert(Adapted::new(Dot { color: [0.0, 1.0, 0.0, 1.0], size: Size::new(10.0, 20.0) }));
         ctx.link_ids(root.id(), a.id());
         ctx.link_ids(root.id(), b.id());
 
         // Layout by hand (the Phase-2b bridge is gone; apps drive the solver directly) —
         // the same column-of-two placement the bridge used to compute.
         ctx[root].set_rect(0.0, 0.0, 100.0, 100.0);
         ctx[a].set_rect(0.0, 0.0, 10.0, 10.0);
         ctx[b].set_rect(0.0, 14.0, 10.0, 20.0);
         assert_eq!(rect_of(&ctx[a]), Rect { x: 0.0, y: 0.0, width: 10.0, height: 10.0 });
         assert_eq!(rect_of(&ctx[b]), Rect { x: 0.0, y: 14.0, width: 10.0, height: 20.0 });
 
         // Paint: each Dot's `Paint::paint` default emits one quad at its laid-out rect, in colour.
         let list = paint_tree(&ctx, &ctx[root]);
         let quads: Vec<_> = list
             .items
             .iter()
             .filter_map(|it| match it.prim {
                 Prim::Quad { rect, color } => Some((rect, color)),
                 _ => None,
             })
             .collect();
         assert!(
             quads.iter().any(|(r, c)| *r == Rect { x: 0.0, y: 0.0, width: 10.0, height: 10.0 } && c[0] == 1.0),
             "red Dot painted at its laid-out rect: {quads:?}",
         );
         assert!(
             quads.iter().any(|(r, c)| *r == Rect { x: 0.0, y: 14.0, width: 10.0, height: 20.0 } && c[1] == 1.0),
             "green Dot painted at its laid-out rect: {quads:?}",
         );
     }
 
     /// A narrow interactive widget: counts left-clicks and records hover transitions — all
     /// through [`Input::on_event`], never touching `WidgetHost`.
     struct Clicker {
         clicks: u32,
         entered: u32,
         left: u32,
     }
     impl Layout for Clicker {}
     impl Paint for Clicker {
         fn color(&self) -> [f32; 4] {
             [0.5, 0.5, 0.5, 1.0]
         }
     }
     impl Input for Clicker {
         fn on_event(&mut self, event: &Event, _ectx: &mut EventCtx) -> bool {
             use crate::widget::{ElementState, MouseButton};
             match event {
                 Event::MouseButton { button: MouseButton::Left, state: ElementState::Pressed, .. } => {
                     self.clicks += 1;
                     true
                 }
                 Event::MouseEnter => {
                     self.entered += 1;
                     false
                 }
                 Event::MouseLeave => {
                     self.left += 1;
                     false
                 }
                 _ => false,
             }
         }
     }
 
     #[test]
     fn narrow_widget_receives_routed_events_through_the_adapter() {
         use crate::widget::{ElementState, MouseButton};
         let mut ctx = UiContext::new();
         let w = ctx.insert(Adapted::new(Clicker { clicks: 0, entered: 0, left: 0 }));
         let id = w.id();
         ctx[w].set_rect(10.0, 10.0, 40.0, 20.0);
 
         let click_at = |x: f32, y: f32| Event::MouseButton {
             button: MouseButton::Left,
             state: ElementState::Pressed,
             x,
             y,
             local_x: x,
             local_y: y,
         };
 
         // A click inside the rect is hit-gated in, consumed, and counted.
         assert!(ctx.propagate_event(&click_at(20.0, 15.0), id), "in-rect click is consumed");
         // A click outside never reaches on_event (the adapter's hit gate rejects it).
         assert!(!ctx.propagate_event(&click_at(200.0, 200.0), id), "out-of-rect click passes through");
         assert_eq!(ctx[w].inner().clicks, 1, "only the in-rect click was counted");
 
         // Hover: moving inside synthesizes MouseEnter (via the legacy bookkeeping the adapter
         // preserves) and sets the base hover flag; moving away synthesizes MouseLeave.
         ctx.propagate_event(&Event::PointerMove { x: 20.0, y: 15.0, local_x: 20.0, local_y: 15.0 }, id);
         assert_eq!(ctx[w].inner().entered, 1, "MouseEnter reached on_event");
         assert!(ctx[w].base().hovered, "base hover flag set through the adapter");
         ctx.propagate_event(&Event::PointerMove { x: 200.0, y: 200.0, local_x: 200.0, local_y: 200.0 }, id);
         assert_eq!(ctx[w].inner().left, 1, "MouseLeave reached on_event");
         assert!(!ctx[w].base().hovered, "base hover flag cleared");
     }
 
     /// A narrow widget that is also a controller: the controller trait is reached through the
     /// concrete `Adapted<W>` by deref (Phase 6aw -- the `WidgetHost::as_*_controller` discovery
     /// hooks are deleted).
     struct Crumbs {
         segs: Vec<String>,
         clicked: Option<usize>,
     }
     impl Layout for Crumbs {}
     impl Paint for Crumbs {
         fn color(&self) -> [f32; 4] {
             [0.0; 4]
         }
     }
     impl Input for Crumbs {
     }
     impl PathController for Crumbs {
         fn set_path(&mut self, segments: &[String]) {
             self.segs = segments.to_vec();
         }
         fn path_click(&mut self) -> Option<usize> {
             self.clicked.take()
         }
     }
 
     #[test]
     fn controller_capability_reached_through_the_concrete_adapter() {
         let mut w = Box::new(Adapted::new(Crumbs { segs: Vec::new(), clicked: Some(2) }));
 
         // The controller trait is reached by deref through the concrete Adapted<W>...
         PathController::set_path(&mut **w, &["home".to_string(), "user".to_string()]);
         assert_eq!(PathController::path_click(&mut **w), Some(2));
 
         // ...and lands on the same state the concrete widget sees.
         assert_eq!(w.inner().segs, vec!["home".to_string(), "user".to_string()]);
         assert_eq!(w.inner().clicked, None, "path_click drained through the deref");
     }
     /// Phase 6: the paint walk's text prims carry the widget's font and clip rect (what the
     /// display-list text path renders), not the bare `Paint::paint` text.
     #[test]
     fn paint_walk_text_carries_font_and_bounds() {
         struct Tag;
         impl Layout for Tag {}
         impl Paint for Tag {
             fn color(&self) -> [f32; 4] {
                 [0.0; 4]
             }
             fn paint(&self, rect: Rect, ctx: &mut PaintCtx) {
                 ctx.text("hi", rect.x + 2.0, rect.y + 2.0, 12.0, [1, 2, 3]);
             }
             fn widget_font(&self) -> Option<String> {
                 Some("Mono:12".into())
             }
             fn text_bounds(&self, rect: Rect) -> Option<[f32; 4]> {
                 Some([rect.x, rect.y, rect.x + rect.width, rect.y + rect.height])
             }
         }
         impl Input for Tag {}
 
         let mut ctx = UiContext::new();
         let w = ctx.insert(Adapted::new(Tag));
         ctx[w].set_rect(10.0, 20.0, 100.0, 30.0);
 
         let list = paint_tree(&ctx, &ctx[w]);
         let texts: Vec<_> = list
             .items
             .iter()
             .filter_map(|it| match &it.prim {
                 Prim::Text { text, font, bounds, .. } => Some((text.clone(), font.clone(), *bounds)),
                 _ => None,
             })
             .collect();
         assert_eq!(texts.len(), 1, "one text prim, no plain duplicate");
         assert_eq!(texts[0].0, "hi");
         assert_eq!(texts[0].1.as_deref(), Some("Mono:12"), "widget_font attached");
         assert_eq!(texts[0].2, Some([10.0, 20.0, 110.0, 50.0]), "text_bounds attached");
     }
 
     /// `text_bounds` clips the content text only: the detached label sits in the
     /// strip above the content rect, so the content's clip would cut it away.
     #[test]
     fn text_bounds_leave_the_detached_label_unclipped() {
         struct Tag;
         impl Layout for Tag {}
         impl Paint for Tag {
             fn color(&self) -> [f32; 4] {
                 [0.0; 4]
             }
             fn paint(&self, rect: Rect, ctx: &mut PaintCtx) {
                 ctx.text("hi", rect.x + 2.0, rect.y + 2.0, 12.0, [1, 2, 3]);
             }
             fn text_bounds(&self, rect: Rect) -> Option<[f32; 4]> {
                 Some([rect.x, rect.y, rect.x + rect.width, rect.y + rect.height])
             }
         }
         impl Input for Tag {}
 
         let mut ctx = UiContext::new();
         let w = ctx.insert(Adapted::new(Tag).with_label("Name"));
         ctx[w].set_rect(10.0, 20.0, 100.0, 60.0);
 
         let list = paint_tree(&ctx, &ctx[w]);
         let bounds_of = |want: &str| {
             list.items.iter().find_map(|it| match &it.prim {
                 Prim::Text { text, bounds, .. } if text == want => Some(*bounds),
                 _ => None,
             })
         };
         assert!(matches!(bounds_of("hi"), Some(Some(_))), "content text is clipped");
         assert_eq!(bounds_of("Name"), Some(None), "the label is not");
     }
 
 }