//! Narrow-trait `Dropdown` (Phase 5p — first popover widget through `Paint::popover` /
 //! `draw_popover`, the 5o surface). Detached-label control: the adapter draws the label in
 //! the strip above the trigger, at `Layout::detached_label_inset`; the trigger's plate is the
 //! control alone.
 //!
 //! Parity notes (all legacy-faithful, verified against the pre-migration impl):
 //! - `parent_snapshot` is the data form of the legacy public, direct-write-only `parent`
 //!   pointer: legacy `set_parent` never wrote it (the WidgetHost default only touched the tree —
 //!   Ramp's dummy-ctx `set_parent` calls were silently discarded), so the Ramp popover clamp
 //!   and the fade-blend parent color activate only for callers that assign the field, exactly
 //!   as before — no production writer exists. The root plate-concentric corner walk it once
 //!   anchored is gone outright (replaced by the app-owned `corner_frame`, Phase 6s).
 //! - The row-rect hit expansion (`base.row_x/row_w`) is dropped, consistent with every other
 //!   migrated control: `Input::hit` tests the widget rect plus the open popover.
 //! - `Layout::intrinsic_measure_width` (new hook) preserves the `auto_width` measure behavior
 //!   (cce-system-interface sizes its page dropdown from `WidgetHost::measure`).
 
 use crate::colors;
 use crate::scene::layout::{Rect, Size};
 use crate::scene::paint::PaintCtx;
 use crate::widget::model::{Adapted, EventCtx, Input, Layout, Paint};
 use crate::widget::{
     WidgetHost, ElementState, Event, Key, MouseButton, NamedKey,
 };
 
 /// Read-data stand-in for the legacy direct-write `parent` pointer (6bd — no stored widget
 /// pointers): the popover clamp and bg fade-blend read the host's rect/kind/color ctx-less at
 /// paint time. Callers that want the Ramp clamp assign it directly, same activation model as
 /// the old field.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ParentSnapshot {
     pub rect: (f32, f32, f32, f32),
     pub is_ramp: bool,
     pub color: [f32; 4],
 }
 
 /// Monospace detection — the paint pass lays characters out on a fixed cell in a monospace font
 /// and on measured per-character advances otherwise, so the sizing pass must branch the same way.
 fn is_monospace_font(font_family: &str, font_size: f32) -> bool {
     let w_i10 = crate::widget::display::measure_text_width("iiiiiiiiii", font_family, font_size);
     let w_m10 = crate::widget::display::measure_text_width("mmmmmmmmmm", font_family, font_size);
     (w_i10 - w_m10).abs() < 5.0
 }
 
 /// The fixed per-character cell of a monospace font, taken as the slope between a 10- and a
 /// 20-`m` run so any constant side bearing in the measurement cancels out.
 fn monospace_cell_width(font_family: &str, font_size: f32) -> f32 {
     let w_m10 = crate::widget::display::measure_text_width("mmmmmmmmmm", font_family, font_size);
     let w_m20 = crate::widget::display::measure_text_width("mmmmmmmmmmmmmmmmmmmm", font_family, font_size);
     ((w_m20 - w_m10) / 10.0).max(1.0)
 }
 
 /// The side of a trigger's arrow, the `chevron-down` glyph: the size the
 /// "▼" it replaced drew at in the 10px face it was set in.
 pub(crate) const ARROW_SIDE: f32 = 8.0;
 /// The side of a list row's mark glyph, and the gap after it (see
 /// [`Dropdown::mark_column`]).
 const MARK_SIDE: f32 = 11.0;
 const MARK_GAP: f32 = 6.0;
 /// The arrow's colour: the grey the "▼" was drawn in (raw sRGB, as a text
 /// colour is).
 const ARROW_COLOR: [f32; 4] = [0x83 as f32 / 255.0, 0x83 as f32 / 255.0, 0x8a as f32 / 255.0, 1.0];
 
 /// Width of the ARROW SLOT, a trigger's right end in which its arrow is
 /// centred: `ARROW_SLOT` and a relief wall at this band height. A textpick
 /// picker (`ParametersBg`) is exactly this wide with its arrow in its middle,
 /// so its arrow lines up with every other trigger's in a column of rows.
 /// The wall is the lip a flush run's face rises out of at a field's seam.
 pub fn arrow_slot(band_h: f32) -> f32 {
     ARROW_SLOT + crate::layout::bevel_width().min(band_h * 0.2)
 }
 
 /// The arrow slot less its wall — a picker's face.
 pub const ARROW_SLOT: f32 = 24.0;
 
 /// The advance width `paint_text` will actually lay `text` out to.
 ///
 /// This is the single source of truth shared by the sizing pass (`content_width` /
 /// `display_width`) and the paint pass. It is deliberately NOT a plain `measure_text_width`: the
 /// paint pass advances on the monospace cell or on the M-dummy trick, and either can exceed the
 /// raw ink measure. Sizing a dropdown from the ink measure therefore left the trigger a few px too
 /// narrow and tripped its own right-edge fade — badly under a monospace UI font like the default
 /// Berkeley Mono. Keep this in step with `paint_text`.
 ///
 /// Shaped first ([`shaped_clusters`]), which is exactly where the glyphs land; the measured
 /// fallbacks below are for a process with no font system to shape through.
 fn text_advance(text: &str, font_family: &str, font_size: f32) -> f32 {
     let n = text.chars().count();
     if n == 0 {
         return 0.0;
     }
     if let Some(&(_, total)) = shaped_clusters(text, font_size).as_ref().and_then(|c| c.last()) {
         return total;
     }
     if is_monospace_font(font_family, font_size) {
         n as f32 * monospace_cell_width(font_family, font_size)
     } else {
         let w_dummy = crate::widget::display::measure_text_width("M", font_family, font_size);
         let measure_str = format!("{}M", text);
         (crate::widget::display::measure_text_width(&measure_str, font_family, font_size) - w_dummy).max(0.0)
     }
 }
 
 /// `text` shaped in the trigger's own font, as the renderer draws it: each cluster's start
 /// `(byte, x)` in logical px, ending on `(text.len(), total advance)` — `None` when there is no
 /// font system to shape through or the shape came back empty.
 ///
 /// The trigger draws its text a cluster at a time (so it can fade them one by one), and these
 /// are the offsets it places them at. Until 2026-09-30 they were measured instead — a prefix
 /// through `measure_text_width`, with every character then pushed at least a pixel past the
 /// previous one's MEASURED ink — and a lone narrow glyph measures wider than it advances, so
 /// "Create" drew as "Cr eat e".
 fn shaped_clusters(text: &str, font_size: f32) -> Option<Vec<(usize, f32)>> {
     let font = crate::layout::control_label_font_detached();
     let mut fs = crate::geometry_font_system().lock().ok()?;
     let clusters =
         crate::backend::text::shaped_cluster_offsets(&mut fs, text, font_size, Some(&font));
     (clusters.len() > 1 && clusters.last().is_some_and(|&(_, total)| total > 0.0)).then_some(clusters)
 }
 
 /// [`shaped_clusters`]' fallback, a character a piece: on the monospace cell, or at a
 /// measured prefix with each character kept a pixel clear of the last one's measured ink.
 fn measured_pieces(text: &str, font_family: &str, font_size: f32, total_advance: f32) -> Vec<(String, f32, f32)> {
     let chars: Vec<char> = text.chars().collect();
     let n = chars.len();
     if is_monospace_font(font_family, font_size) {
         let cell = monospace_cell_width(font_family, font_size);
         return chars.iter().enumerate().map(|(i, c)| (c.to_string(), i as f32 * cell, cell)).collect();
     }
     let w_dummy = crate::widget::display::measure_text_width("M", font_family, font_size);
     let mut offsets = Vec::with_capacity(n);
     let mut prefix = String::new();
     for (i, &c) in chars.iter().enumerate() {
         if i > 0 {
             prefix.push(chars[i - 1]);
         }
         let measured = if i == 0 {
             0.0
         } else {
             let w = crate::widget::display::measure_text_width(&format!("{prefix}M"), font_family, font_size);
             (w - w_dummy).max(0.0)
         };
         offsets.push((c, measured));
     }
     let mut out = Vec::with_capacity(n);
     let mut prev_end = 0.0f32;
     for i in 0..n {
         let (c, mut offset) = offsets[i];
         if i > 0 {
             offset = offset.max(prev_end + 1.0);
         }
         let next = if i + 1 < n { offsets[i + 1].1 } else { total_advance };
         out.push((c.to_string(), offset, next - offset));
         prev_end = offset + crate::widget::display::measure_text_width(&c.to_string(), font_family, font_size);
     }
     out
 }
 
 #[derive(Debug, Clone)]
 pub struct Dropdown {
     pub options: Vec<String>,
     pub selected: usize,
     pub open: bool,
     pub(crate) hovered_item: Option<usize>,
     just_changed: bool,
     /// Host read-data, written ONLY by direct assignment (the Ramp-clamp unit test; no
     /// production writer). Read by the Ramp popover clamp and the fade-blend parent color,
     /// like the legacy `parent` pointer it replaces.
     pub parent_snapshot: Option<ParentSnapshot>,
     /// Optional popover anchor override: the menu hangs off THIS rect instead
     /// of the trigger's — for triggers embedded in a larger control (the
     /// parameter pane's textpick picker button nested in its TextBox), where
     /// the menu should span the whole field, not the button sliver.
     pub popover_anchor: Option<Rect>,
     /// The arrow stands in the MIDDLE of the trigger instead of in the arrow
     /// slot at its right end — for a trigger that carries nothing else
     /// (the textpick picker), whose padding about the arrow should be even.
     pub center_arrow: bool,
     pub font_family: String,
     pub custom_display_text: Option<String>,
     pub open_upward: Option<bool>,
     pub auto_width: bool,
     /// Synced copy of the control label ([`Paint::sync_label`]) — drives the side/detached
     /// offsets the base label geometry imposes on the widget's own geometry.
     label: Option<String>,
     /// Own hover flag, maintained from `MouseEnter`/`MouseLeave` (the adapter's hover
     /// bookkeeping hit-tests through [`Input::hit`], which includes the open popover — matching
     /// the legacy `on_cursor_moved` + popover-aware `hit_test` pair).
     hovered: bool,
     /// App-owned concentric frame (Phase 6s): `(rect, radius, corners)` of the rounded plate
     /// the dropdown sits in. When set, the corner adjustment uses it INSTEAD of walking for a
     /// root plate container ancestor — the hook that keeps the adjustment after an app dissolves its
     /// root plate container (the walk finds nothing once the widget is parentless).
     corner_frame: Option<((f32, f32, f32, f32), f32, (bool, bool, bool, bool))>,
     /// The raised trigger plate's corner radii, top-left clockwise, in place
     /// of the configured radius on all four — a trigger that is one end of
     /// a wider field (a parameter pane's completion picker, square where it
     /// meets the text box, the field's own radius on the outside).
     radii: Option<(f32, f32, f32, f32)>,
     /// Raised style: the closed control's background is an SDF-lit `Bevel`
     /// plate (fill + rolled lit edge) instead of a flat fill + border stroke.
     raised: Option<bool>,
     /// Flat stance ([`crate::widget::PlateStance::Flat`]): the trigger's face
     /// alone, no groove, silhouette equal to its rect. Overrides `raised`.
     /// The concentric corner adjustment below does not apply — a flat fill
     /// carries one radius, and the adjustment exists to nest relief outlines.
     flat: bool,
     /// Per-widget override for the trigger plate's FACE, bypassing
     /// [`crate::scene::Material::control_face`] on the configured fill. The default
     /// forces the face opaque; an app that wants its controls made of the
     /// same frosted material as its panes passes the blur-behind sentinel (a
     /// negative alpha) here, which that helper would strip.
     face: Option<crate::scene::Material>,
     /// Keyboard focus (FocusIn / FocusOut): lights the trigger plate's rim.
     focused: bool,
     /// The open menu REPLACES the trigger instead of growing out of it: no
     /// trigger band (display text + arrow) in the open surface, the rows alone,
     /// with the menu's edge anchored where the trigger's was (its bottom for
     /// an upward menu, its top for a downward one) so the rows occupy the
     /// trigger's slot. The trigger itself stops painting once the revealed
     /// menu covers it. The settings app's page switcher: the current page
     /// already reads blue in the list, so the band repeated it.
     menu_replaces_trigger: bool,
     /// Expand/contract animation (the status-interface module-menu feel).
     /// WALL-CLOCK, not dt-stepped: progress runs from `anim_from` at
     /// `anim_start` toward 1 (or 0 while `closing`) over [`Self::ANIM_S`], read
     /// at draw time — so an app that never ticks its UiContext can never strand
     /// the popover mid-size; ticks only drive redraws and settle a landed
     /// close. `closing` keeps `open` (and the shrinking popover) alive while
     /// everything interactive gates on `!closing`.
     anim_from: f32,
     anim_start: Option<web_time::Instant>,
     closing: bool,
     /// Per-frame SNAPSHOT of the wall-clock progress, refreshed in `tick`
     /// (before each render) and on every routed event. All geometry readers —
     /// popover_rect at registration, draw_popover, the engine's occlusion
     /// clamp — use this one value, so the animated rect is stable within a
     /// frame: the clamp's exact-match overlay-text exemption compares text
     /// bounds against popover_rect evaluated later in the same pass, and a
     /// live clock read there would never match.
     anim_snap: f32,
 }
 
 impl Dropdown {
     /// The style in force: the per-widget override (`with_raised`) when set, else
     /// the DE's `control_relief`, read live so a runtime switch
     /// (`layout::set_control_relief`) restyles every control at once.
     fn raised(&self) -> bool {
         self.raised.unwrap_or_else(crate::layout::control_relief)
     }
 
     pub fn new(options: Vec<String>, selected: usize) -> Adapted<Dropdown> {
         Adapted::new(Dropdown {
             options,
             selected,
             open: false,
             hovered_item: None,
             just_changed: false,
             parent_snapshot: None,
             popover_anchor: None,
             center_arrow: false,
             font_family: "sans-serif".to_string(),
             custom_display_text: None,
             open_upward: None,
             auto_width: false,
             label: None,
             hovered: false,
             corner_frame: None,
             radii: None,
             raised: None,
             flat: false,
             face: None,
             focused: false,
             menu_replaces_trigger: false,
             anim_from: 0.0,
             anim_start: None,
             closing: false,
             anim_snap: 0.0,
         })
     }
 
     /// Whether the menu is open and taking input: open and not shrinking
     /// closed. `open` alone stays true through the closing animation, while
     /// the plate is still drawn but presses and keys are no longer its — a
     /// host that routes input to the dropdown ahead of what is under it asks
     /// this.
     pub fn is_expanded(&self) -> bool {
         self.open && !self.closing
     }
 
     /// Set (or clear) the app-owned concentric frame — see the `corner_frame` field docs.
     /// [`Self::radii`]: the raised trigger plate's corners, or `None` for
     /// the configured radius.
     pub fn set_radii(&mut self, radii: Option<(f32, f32, f32, f32)>) {
         self.radii = radii;
     }
 
     pub fn set_corner_frame(&mut self, frame: Option<((f32, f32, f32, f32), f32, (bool, bool, bool, bool))>) {
         self.corner_frame = frame;
     }
 
     pub fn take_change(&mut self) -> bool {
         let changed = self.just_changed;
         self.just_changed = false;
         changed
     }
 
     /// Horizontal inset added to a measured label to get a dropdown width the label fits inside
     /// without tripping `paint_text`'s right-edge fade: an 8px left pad plus the 28px right
     /// reservation (`right_limit = w - 28`, room for the 10px gap and the arrow) = 36px, plus a
     /// 2px cushion for the small gap between the ink-`measure_text_width` used here and the M-dummy
     /// advance the paint pass measures with. Shared by `content_width` (widest option) and
     /// `display_width` (collapsed display text) so the two can't drift.
     const LABEL_INSET: f32 = 38.0;
 
     /// The width the list keeps for MARKS: an option whose text begins with
     /// `context_menu::MARK_CHECK` ("✓ "), `MARK_ON` ("● ") or `MARK_OFF`
     /// ("○ ") is drawn with the check / circle / circle-outline glyph in a
     /// column at its left and its text after it — the context menu's
     /// convention, so a "View" menu-button can mark its switches as a menu
     /// does. When any option is marked every row keeps the column, so the
     /// labels line up; otherwise the list is as it was.
     fn mark_column(&self) -> f32 {
         let marked = self.options.iter().any(|o| crate::widget::context_menu::split_mark(o).0.is_some());
         if marked { MARK_SIDE + MARK_GAP } else { 0.0 }
     }
 
     pub fn content_width(&self) -> f32 {
         let font_setting = crate::layout::control_label_font_detached();
         let (font_family, font_size_opt) = crate::layout::parse_font_string(&font_setting);
         let font_size = font_size_opt.unwrap_or(12.0);
         let mut max_w = 0.0f32;
         let marks = self.mark_column();
         for opt in &self.options {
             let (_, label) = crate::widget::context_menu::split_mark(opt);
             let opt_w = marks + text_advance(label, &font_family, font_size) + Self::LABEL_INSET;
             if opt_w > max_w {
                 max_w = opt_w;
             }
         }
         max_w
     }
 
     /// The text shown on the collapsed trigger — the fixed `custom_display_text` (menu-button
     /// mode) if set, otherwise the selected option. Mirrors the selection logic in `paint_text`.
     fn display_text(&self) -> String {
         if let Some(ref custom_text) = self.custom_display_text {
             custom_text.clone()
         } else {
             let opt = self.options.get(self.selected).map(String::as_str).unwrap_or_default();
             crate::widget::context_menu::split_mark(opt).1.to_string()
         }
     }
 
     /// Trigger width sized to the collapsed display text rather than the widest option (via
     /// `content_width`). Used by menu-button dropdowns whose label is fixed, so "File"/"Edit" don't
     /// stretch to their longest menu entry. Shares `LABEL_INSET` so the label fits without fading.
     fn display_width(&self) -> f32 {
         let font_setting = crate::layout::control_label_font_detached();
         let (font_family, font_size_opt) = crate::layout::parse_font_string(&font_setting);
         let font_size = font_size_opt.unwrap_or(12.0);
         text_advance(&self.display_text(), &font_family, font_size) + Self::LABEL_INSET
     }
 
     /// The detached-label strip height above the content rect (zero unlabeled) —
     /// the adapter's `Widget::label_offset` over the synced label.
     fn label_top(&self) -> f32 {
         crate::widget::input::slider::detached_strip(&self.label)
     }
 
     /// Expansion/contraction duration — the status-interface module-menu pace.
     const ANIM_S: f32 = 0.14;
 
     /// LIVE animation progress in [0, 1], wall-clock from the last transition.
     /// 1 = fully open, 0 = fully contracted. Geometry never reads this
     /// directly — it reads the per-frame `anim_snap` (see the field docs).
     fn anim_progress_now(&self) -> f32 {
         let Some(start) = self.anim_start else {
             return if self.open && !self.closing { 1.0 } else { 0.0 };
         };
         // Animations off: a transition in flight has already landed.
         if !crate::motion::enabled() {
             return if self.closing { 0.0 } else { 1.0 };
         }
         let el = start.elapsed().as_secs_f32() / Self::ANIM_S;
         if self.closing {
             (self.anim_from - el).clamp(0.0, 1.0)
         } else {
             (self.anim_from + el).clamp(0.0, 1.0)
         }
     }
 
     fn begin_open(&mut self) {
         self.anim_from = self.anim_progress_now();
         self.anim_start = Some(web_time::Instant::now());
         self.open = true;
         self.closing = false;
         self.anim_snap = self.anim_progress_now();
     }
 
     fn begin_close(&mut self) {
         if !self.open || self.closing {
             return;
         }
         self.anim_from = self.anim_progress_now();
         self.anim_start = Some(web_time::Instant::now());
         self.closing = true;
         self.anim_snap = self.anim_progress_now();
     }
 
     /// Fold finished animations back into settled state and refresh the
     /// per-frame progress snapshot (draw paths are `&self`, so this runs from
     /// the mutation entry points: `tick` and `on_event`). Also heals an
     /// externally forced `open = false` (a direct field write skips the
     /// animation; reset so the next open still animates).
     fn settle_anim(&mut self) {
         if self.closing {
             if self.anim_progress_now() <= 0.0 {
                 self.closing = false;
                 self.open = false;
                 self.anim_start = None;
                 self.hovered_item = None;
             }
         } else if self.open {
             if self.anim_progress_now() >= 1.0 {
                 self.anim_start = None;
             }
         } else {
             self.anim_start = None;
         }
         self.anim_snap = self.anim_progress_now();
     }
 
     /// Land an in-flight open or close instantly (tests can't wait out the
     /// wall clock).
     #[cfg(test)]
     fn land_anim_for_test(&mut self) {
         self.anim_start = Some(web_time::Instant::now() - std::time::Duration::from_secs(1));
         self.settle_anim();
     }
 
     /// One option row's height — a fixed pitch, not the trigger's height.
     /// `popover_geom` sizes the box by it, `draw_popover` lays the labels out
     /// on it and `row_at` reads it back.
     const ROW_H: f32 = 24.0;
 
     fn popover_width(&self, content: Rect) -> f32 {
         content.width.max(self.content_width())
     }
 
     /// The relief wall the open plate eats out of its own OUTER edges. The
     /// menu's surface is carved exactly like the closed trigger's
     /// (`carve_inside` at `depth`, then a trough straddling the carved edge by
     /// ±depth/2), so the outermost `depth` of the box is valley rather than
     /// face. A row laid flush against that edge therefore has its bottom
     /// padding — and any descender sitting in it — painted over by the wall,
     /// which is what cut the last option of every menu in half. The flat path
     /// draws a 1px outline instead and costs a row only its outermost pixel.
     fn plate_inset(&self, trigger_h: f32) -> f32 {
         if self.raised() {
             crate::layout::bevel_width().min(trigger_h * 0.2)
         } else {
             1.0
         }
     }
 
     /// What [`Self::popover_geom`] reserves above and below the row strip:
     /// [`Self::plate_inset`] on whichever menu edges are OUTER edges of the
     /// open surface. A downward menu meets the trigger band along its top and
     /// owns only its bottom edge; an upward one is the other way round; a menu
     /// that replaces the trigger owns both.
     fn popover_pads(&self, content: Rect) -> (f32, f32) {
         let inset = self.plate_inset(content.height);
         let anchor = self.popover_anchor.unwrap_or(content);
         let base_y = anchor.y - self.label_top();
         let open_upward = self.open_upward.unwrap_or(base_y > 400.0);
         if self.menu_replaces_trigger {
             (inset, inset)
         } else if open_upward {
             (inset, 0.0)
         } else {
             (0.0, inset)
         }
     }
 
     /// Where the first option row sits: the menu box's top edge, past the
     /// relief wall when that edge is an outer one. Rows run from here at
     /// [`Self::ROW_H`] — the ONE origin the paint and the hit test share.
     fn rows_top(&self, content: Rect) -> f32 {
         let (_, ry, _, _) = self.popover_geom(content);
         ry + self.popover_pads(content).0
     }
 
     /// Which option lies at `py`, or None for the reserved wall at the menu's
     /// outer edge (and for anything past the last row).
     fn row_at(&self, content: Rect, py: f32) -> Option<usize> {
         let rel = py - self.rows_top(content);
         if rel < 0.0 {
             return None;
         }
         let idx = (rel / Self::ROW_H) as usize;
         (idx < self.options.len()).then_some(idx)
     }
 
     /// The ONE continuous surface drawn while open: the trigger band unioned
     /// with the revealed menu area — the status-interface treatment, where the
     /// module box literally grows into its menu instead of spawning a detached
     /// popover plate.
     fn unified_geom_drawn(&self, content: Rect) -> (f32, f32, f32, f32) {
         let (ax, ay, aw, ah) = self.popover_geom_drawn(content);
         if self.menu_replaces_trigger {
             // No band: the revealed menu IS the whole open surface.
             return (ax, ay, aw, ah);
         }
         let (tx, ty) = (content.x, content.y);
         let (tw, th) = (content.width, content.height);
         let x0 = tx.min(ax);
         let y0 = ty.min(ay);
         let x1 = (tx + tw).max(ax + aw);
         let y1 = (ty + th).max(ay + ah);
         (x0, y0, x1 - x0, y1 - y0)
     }
 
     /// The menu box revealed this frame: the full geometry with the height
     /// revealed — and the width grown out of the trigger — by the eased
     /// progress (cubic-out, the status-interface module-menu curve). Rows keep
     /// their final positions and slide into view under the traveling edge; an
     /// upward popover anchors its bottom edge to the trigger instead.
     ///
     /// The width grows out of the TRIGGER'S OWN SPAN, both edges travelling:
     /// a trigger nested in a wider field (a [`Self::popover_anchor`] — the
     /// textpick picker at the right end of its text box) opens as a plate the
     /// button's width under the button and widens out to the field. Growing
     /// from the anchor's left edge put a button-wide sliver under the text
     /// instead, and the union with the button spanned the whole field from
     /// the first frame. A trigger at its menu's left edge — every unanchored
     /// one — grows rightward exactly as it always did.
     fn popover_geom_drawn(&self, content: Rect) -> (f32, f32, f32, f32) {
         let (rx, ry, rw, rh) = self.popover_geom(content);
         let a = self.anim_snap;
         if a >= 1.0 {
             return (rx, ry, rw, rh);
         }
         let t = 1.0 - (1.0 - a) * (1.0 - a) * (1.0 - a);
         let base_y = content.y - self.label_top();
         let open_upward = self.open_upward.unwrap_or(base_y > 400.0);
         let (r0, r1) = (rx, rx + rw);
         let s0 = content.x.clamp(r0, r1);
         let s1 = (content.x + content.width).clamp(s0, r1);
         let x0 = s0 + (r0 - s0) * t;
         let x1 = s1 + (r1 - s1) * t;
         let ah = rh * t;
         let ay = if open_upward { ry + rh - ah } else { ry };
         (x0, ay, x1 - x0, ah)
     }
 
     /// Popover geometry against the laid-out content rect — the legacy `get_popover_geom`,
     /// with the base-rect reads rewritten in content-rect terms (`base.y + base.h` ⇒
     /// `content.y + content.height`, `base.y + label_offset` ⇒ `content.y`).
     ///
     /// The box is the row strip PLUS [`Self::popover_pads`] — it is a plate,
     /// and its outer edges are relief wall, not face. Rows start at
     /// [`Self::rows_top`], never at `ry`.
     pub fn popover_geom(&self, content: Rect) -> (f32, f32, f32, f32) {
         let (pad_top, pad_bottom) = self.popover_pads(content);
         let content = self.popover_anchor.unwrap_or(content);
         let rw = self.popover_width(content);
         let rh = self.options.len() as f32 * Self::ROW_H + pad_top + pad_bottom;
 
         let base_y = content.y - self.label_top();
         let open_upward = self.open_upward.unwrap_or(base_y > 400.0);
         let mut rx = content.x;
         let mut ry = if self.menu_replaces_trigger {
             // The menu takes the trigger's slot: flush with its bottom edge
             // (upward) or its top edge (downward) rather than stacked past it.
             if open_upward { content.y + content.height - rh } else { content.y }
         } else if open_upward {
             content.y - rh
         } else {
             content.y + content.height
         };
 
         let is_ramp = self.parent_snapshot.is_some_and(|s| s.is_ramp);
 
         if is_ramp {
             if let Some(snap) = self.parent_snapshot {
                 let (px, py, pw_parent, ph_parent) = snap.rect;
                 if pw_parent > 0.0 && ph_parent > 0.0 {
                     let dy_down = content.y + content.height;
                     let dy_up = content.y - rh;
 
                     if self.open_upward.is_none() {
                         if dy_down + rh > py + ph_parent && dy_up >= py {
                             ry = dy_up;
                         } else if dy_up < py && dy_down + rh <= py + ph_parent {
                             ry = dy_down;
                         }
                     }
 
                     // Clamp X to parent borders
                     if rx < px {
                         rx = px;
                     }
                     if rx + rw > px + pw_parent {
                         rx = px + pw_parent - rw;
                     }
 
                     // Clamp Y to parent borders
                     if ry < py {
                         ry = py;
                     }
                     if ry + rh > py + ph_parent {
                         ry = py + ph_parent - rh;
                     }
                 }
             }
         }
 
         (rx, ry, rw, rh)
     }
 
     fn border_color(&self) -> [f32; 4] {
         if self.open && !self.closing {
             [0.30, 0.50, 0.32, 1.0]
         } else if self.hovered {
             let bc = colors::dropdown_border_color();
             [(bc[0] + 0.15).min(1.0), (bc[1] + 0.15).min(1.0), (bc[2] + 0.15).min(1.0), bc[3]]
         } else {
             colors::dropdown_border_color()
         }
     }
 
     /// Emit the border + background geometry — the legacy `all_rounded_quads` body (rounded,
     /// with the root plate-concentric corner adjustment) or `extra_quads` (plain) depending on
     /// the configured radius, byte-for-byte on the same content rect.
     fn paint_background(&self, content: Rect, ctx: &mut PaintCtx) {
         let x = content.x;
         let w = content.width;
         let y = content.y;
         let visual_h = content.height;
 
         let raw_bg = colors::dropdown_background_color();
         let mut bg_color = raw_bg;
         bg_color[3] = 1.0; // Force opaque background to prevent subpixel blending artifacts
         let border_color = self.border_color();
 
         let radius = crate::layout::dropdown_corner_radius();
         // Raised style: one lit Bevel plate owns fill and edge (the concentric
         // corner_frame adjustment keeps the legacy path — it exists to nest
         // flat outlines, which a rolled edge replaces). A transparent
         // configured fill degrades to a Boss: edges only, plate as the face —
         // judged on the RAW alpha, before the opacity force above.
         if self.flat {
             let plate = crate::widget::ControlPlate::control(
                 Rect { x, y, width: w, height: visual_h },
                 radius,
                 crate::widget::PlateStance::Flat,
                 self.face.or_else(|| crate::scene::Material::control_face(raw_bg)),
             )
             .with_tint(self.focused.then(crate::widget::ControlPlate::focus_tint));
             ctx.control_plate(&plate);
             return;
         }
         if self.raised() {
             let depth = crate::layout::bevel_width().min(visual_h * 0.2);
             // Concentric corner_frame adjustment applies to the relief too: a
             // corner nested at equal gaps into the frame follows its curve.
             // The window corner is span-widened (corner_span_factor, diagonal
             // curvature = pr), so its parallel curve at inset g has diagonal
             // curvature pr - g — which as a NOMINAL widget-scale squircle
             // radius is factor * (pr - g). Exactly pr - g for circular
             // corners (factor 1).
             let mut r4 = [radius; 4];
             if let Some(((px, py, pw, ph), pr, (pr1, pr2, pr3, pr4))) = self.corner_frame {
                 let cf = crate::layout::corner_span_factor();
                 let g_left = x - px;
                 let g_top = y - py;
                 let g_right = (px + pw) - (x + w);
                 let g_bottom = (py + ph) - (y + visual_h);
                 if pr1 && (g_left - g_top).abs() < 1.0 && g_left >= 0.0 {
                     r4[0] = (pr - g_left).max(0.0) * cf;
                 }
                 if pr2 && (g_right - g_top).abs() < 1.0 && g_right >= 0.0 {
                     r4[1] = (pr - g_right).max(0.0) * cf;
                 }
                 if pr3 && (g_right - g_bottom).abs() < 1.0 && g_right >= 0.0 {
                     r4[2] = (pr - g_right).max(0.0) * cf;
                 }
                 if pr4 && (g_left - g_bottom).abs() < 1.0 && g_left >= 0.0 {
                     r4[3] = (pr - g_left).max(0.0) * cf;
                 }
             }
             if let Some((a, b, c, d)) = self.radii {
                 r4 = [a, b, c, d];
             }
             // The trigger is a flush control plate (groove ring down, beveled
             // lip back up, face level with the surface; a transparent raw
             // fill = edges only), its footprint the trigger's rect and its
             // silhouette the frame-adjusted radii.
             let plate = crate::widget::ControlPlate::control(
                 Rect { x, y, width: w, height: visual_h },
                 radius,
                 crate::widget::PlateStance::Flush,
                 self.face.or_else(|| crate::scene::Material::control_face(raw_bg)),
             )
             .with_radii((r4[0], r4[1], r4[2], r4[3]))
             .with_depth(depth)
             .with_tint(self.focused.then(crate::widget::ControlPlate::focus_tint));
             ctx.control_plate(&plate);
             return;
         }
         if radius <= 0.0 {
             ctx.quad(Rect { x, y, width: w, height: visual_h }, border_color);
             ctx.quad(
                 Rect { x: x + 1.0, y: y + 1.0, width: w - 2.0, height: visual_h - 2.0 },
                 bg_color,
             );
             return;
         }
 
         let inner_radius = (radius - 1.0).max(0.0);
         let mut adjusted = false;
         let mut outer_radii = [radius; 4];
         let mut inner_radii = [inner_radius; 4];
 
         // Only an explicit corner_frame adjusts concentric corners now — the legacy fallback
         // walked ancestors for a root plate, which no longer exists.
         let frame = self.corner_frame;
         if let Some(((px, py, pw, ph), pr, (pr1, pr2, pr3, pr4))) = frame {
             let g_left = x - px;
             let g_top = y - py;
             let g_right = (px + pw) - (x + w);
             let g_bottom = (py + ph) - (y + visual_h);
 
             if pr1 && (g_left - g_top).abs() < 1.0 && g_left >= 0.0 {
                 outer_radii[0] = (pr - g_left).max(0.0);
                 inner_radii[0] = (outer_radii[0] - 1.0).max(0.0);
                 adjusted = true;
             }
             if pr2 && (g_right - g_top).abs() < 1.0 && g_right >= 0.0 {
                 outer_radii[1] = (pr - g_right).max(0.0);
                 inner_radii[1] = (outer_radii[1] - 1.0).max(0.0);
                 adjusted = true;
             }
             if pr3 && (g_right - g_bottom).abs() < 1.0 && g_right >= 0.0 {
                 outer_radii[2] = (pr - g_right).max(0.0);
                 inner_radii[2] = (outer_radii[2] - 1.0).max(0.0);
                 adjusted = true;
             }
             if pr4 && (g_left - g_bottom).abs() < 1.0 && g_left >= 0.0 {
                 outer_radii[3] = (pr - g_left).max(0.0);
                 inner_radii[3] = (outer_radii[3] - 1.0).max(0.0);
                 adjusted = true;
             }
         }
 
         if adjusted {
             for (qx, qy, qw, qh, qr, qc, corners) in crate::layout::partition_concentric_corners(
                 x, y, w, visual_h, radius, outer_radii, border_color,
             ) {
                 ctx.rounded_rect(Rect { x: qx, y: qy, width: qw, height: qh }, qr, corners, qc);
             }
             for (qx, qy, qw, qh, qr, qc, corners) in crate::layout::partition_concentric_corners(
                 x + 1.0, y + 1.0, w - 2.0, visual_h - 2.0, inner_radius, inner_radii, bg_color,
             ) {
                 ctx.rounded_rect(Rect { x: qx, y: qy, width: qw, height: qh }, qr, corners, qc);
             }
         } else {
             let corners = (true, true, true, true);
             ctx.rounded_rect(Rect { x, y, width: w, height: visual_h }, radius, corners, border_color);
             ctx.rounded_rect(
                 Rect { x: x + 1.0, y: y + 1.0, width: w - 2.0, height: visual_h - 2.0 },
                 inner_radius,
                 corners,
                 bg_color,
             );
         }
     }
 
     /// Where the arrow is drawn on a trigger band: the `chevron-down` glyph,
     /// [`ARROW_SIDE`] square, centred in the arrow slot at the band's right
     /// end ([`arrow_slot`]), or in the whole band under `center_arrow`.
     /// Until 2026-10-02 it stood 18 px in from the right end, and the
     /// picker's centred arrow stood two pixels left of every other; until
     /// 2026-10-05 it was a "▼" in the control font.
     pub(crate) fn arrow_rect(&self, band: Rect) -> Rect {
         let slot = if self.center_arrow { band.width } else { arrow_slot(band.height).min(band.width) };
         Rect {
             x: band.x + band.width - 0.5 * (slot + ARROW_SIDE),
             y: band.y + 0.5 * (band.height - ARROW_SIDE),
             width: ARROW_SIDE,
             height: ARROW_SIDE,
         }
     }
 
     /// Emit the selected-text (per-character fade against the right edge) and the arrow glyph —
     /// the legacy `text_labels` body minus the control label (the adapter's base-label
     /// machinery draws that, with the +4px `detached_label_inset`).
     fn paint_text(&self, content: Rect, ctx: &mut PaintCtx) {
         let selected_text = if let Some(ref custom_text) = self.custom_display_text {
             custom_text.clone()
         } else {
             // A marked option (see `MARK_SIDE`) shows on the trigger without
             // its mark: the mark is the list's, not the value's.
             let opt = self.options.get(self.selected).map(String::as_str).unwrap_or_default();
             crate::widget::context_menu::split_mark(opt).1.to_string()
         };
 
         let (font_family, font_size) = crate::layout::control_label_font_detached_parsed();
         let x = content.x;
         let w = content.width;
         let start_x = x + 8.0;
         let right_limit = x + w - 28.0; // 10px margin before the arrow
         let fade_start_x = (right_limit - 24.0).max(start_x); // Fade out over the last 24px
         let text_y = crate::layout::center_text_y(content.y, content.height, font_size);
         let tc = colors::dropdown_text_color();
         let default_color = [
             (colors::linear_to_srgb(tc[0]) * 255.0).round() as u8,
             (colors::linear_to_srgb(tc[1]) * 255.0).round() as u8,
             (colors::linear_to_srgb(tc[2]) * 255.0).round() as u8,
         ];
         let bg_color = colors::dropdown_background_color();
         let mut parent_color = colors::page_color();
         if let Some(snap) = self.parent_snapshot {
             parent_color = snap.color;
         }
         let alpha = 1.0; // The dropdown background is drawn fully opaque
         let bg_rgb = [
             ((parent_color[0] * (1.0 - alpha) + bg_color[0] * alpha) * 255.0).round().clamp(0.0, 255.0) as u8,
             ((parent_color[1] * (1.0 - alpha) + bg_color[1] * alpha) * 255.0).round().clamp(0.0, 255.0) as u8,
             ((parent_color[2] * (1.0 - alpha) + bg_color[2] * alpha) * 255.0).round().clamp(0.0, 255.0) as u8,
         ];
 
         // The pieces the text is drawn in — `(text, offset, advance)` — each faded on its own.
         // Shaped when there is a font system (a cluster each, at the offset the shaper gives
         // it, which is where the whole string's glyphs would land); measured otherwise.
         let total_advance = text_advance(&selected_text, &font_family, font_size);
         let pieces: Vec<(String, f32, f32)> = match shaped_clusters(&selected_text, font_size) {
             Some(clusters) => clusters
                 .windows(2)
                 .map(|w| (selected_text[w[0].0..w[1].0].to_string(), w[0].1, w[1].1 - w[0].1))
                 .collect(),
             None => measured_pieces(&selected_text, &font_family, font_size, total_advance),
         };
 
         for (piece, offset, c_w) in pieces {
             let cur_x = start_x + offset;
 
             if cur_x >= right_limit {
                 break;
             }
 
             let char_mid_x = cur_x + c_w / 2.0;
             let mut skip_char = false;
             let text_end_x = start_x + total_advance;
             let color = if text_end_x > right_limit && char_mid_x > fade_start_x {
                 let factor = ((char_mid_x - fade_start_x) / (right_limit - fade_start_x)).clamp(0.0, 1.0);
                 if factor >= 0.9 {
                     skip_char = true;
                     default_color
                 } else {
                     [
                         (default_color[0] as f32 + (bg_rgb[0] as f32 - default_color[0] as f32) * factor).round() as u8,
                         (default_color[1] as f32 + (bg_rgb[1] as f32 - default_color[1] as f32) * factor).round() as u8,
                         (default_color[2] as f32 + (bg_rgb[2] as f32 - default_color[2] as f32) * factor).round() as u8,
                     ]
                 }
             } else {
                 default_color
             };
 
             if !skip_char && !piece.trim().is_empty() {
                 // The font named here and not left to the host: a dropdown
                 // painted as a stamp by another widget (the designer's
                 // palette paints its choice rows so) took that widget's
                 // font, and its menu then opened in this one. The whole
                 // configured string, as `widget_font` and `draw_popover`
                 // pass it — the runner reads its size too.
                 ctx.text_with(piece, cur_x, text_y, font_size, color, Some(crate::layout::control_label_font_detached()), None);
             }
         }
 
         // Only the chevron is bounded here. The trigger TEXT above fades
         // character by character toward `right_limit` and drops anything past
         // 90% — an overflow treatment of its own, which a hard clip would
         // fight rather than help.
         // The glyph is drawn at the configured font's size (the runner
         // reads it off the font string), so that is the size it is measured at.
         let _ = (&font_family, font_size);
         ctx.icon("chevron-down", self.arrow_rect(content), ARROW_COLOR);
     }
 
     /// Port of the legacy `keyboard_input` body.
     fn handle_key(&mut self, event: &crate::widget::KeyEvent) -> bool {
         if event.state != ElementState::Pressed {
             return false;
         }
         if !self.open || self.closing {
             if let Key::Named(NamedKey::Enter) | Key::Named(NamedKey::Space) = event.logical_key {
                 self.begin_open();
                 let mut start_idx = self.selected;
                 if start_idx < self.options.len() && self.options[start_idx] == "-" {
                     for i in 0..self.options.len() {
                         if self.options[i] != "-" {
                             start_idx = i;
                             break;
                         }
                     }
                 }
                 self.hovered_item = Some(start_idx);
                 return true;
             }
             return false;
         }
 
         match event.logical_key {
             Key::Named(NamedKey::ArrowDown) => {
                 let current = self.hovered_item.unwrap_or(self.selected);
                 let mut next = (current + 1) % self.options.len();
                 for _ in 0..self.options.len() {
                     if self.options[next] != "-" {
                         self.hovered_item = Some(next);
                         break;
                     }
                     next = (next + 1) % self.options.len();
                 }
                 true
             }
             Key::Named(NamedKey::ArrowUp) => {
                 let current = self.hovered_item.unwrap_or(self.selected);
                 let mut prev = if current == 0 { self.options.len() - 1 } else { current - 1 };
                 for _ in 0..self.options.len() {
                     if self.options[prev] != "-" {
                         self.hovered_item = Some(prev);
                         break;
                     }
                     prev = if prev == 0 { self.options.len() - 1 } else { prev - 1 };
                 }
                 true
             }
             Key::Named(NamedKey::Enter) | Key::Named(NamedKey::Space) => {
                 if std::env::var_os("CCE_DD_DEBUG").is_some() {
                     eprintln!("[dd] key-select hovered={:?} selected={}", self.hovered_item, self.selected);
                 }
                 if let Some(idx) = self.hovered_item {
                     if idx < self.options.len() && self.options[idx] != "-" {
                         if self.selected != idx || self.custom_display_text.is_some() {
                             self.selected = idx;
                             self.just_changed = true;
                         }
                         self.begin_close();
                     }
                 }
                 true
             }
             Key::Named(NamedKey::Escape) => {
                 self.begin_close();
                 true
             }
             _ => false,
         }
     }
 }
 
 impl Adapted<Dropdown> {
     /// Raised style: see the `raised` field.
     pub fn with_raised(mut self, raised: bool) -> Self {
         self.raised = Some(raised);
         self
     }
 
     /// Override the trigger plate's face — see the `face` field.
     pub fn with_face(mut self, face: crate::scene::Material) -> Self {
         self.face = Some(face);
         self
     }
 
     /// Draw the trigger with no relief at all — see
     /// [`crate::widget::PlateStance::Flat`]. Overrides `with_raised`.
     pub fn with_flat(mut self, flat: bool) -> Self {
         self.flat = flat;
         self
     }
 
     pub fn with_custom_display_text(mut self, text: &str) -> Self {
         self.custom_display_text = Some(text.to_string());
         self
     }
 
     pub fn with_font_family(mut self, font_family: &str) -> Self {
         self.font_family = font_family.to_string();
         self
     }
 
     pub fn with_open_upward(mut self, open_upward: bool) -> Self {
         self.open_upward = Some(open_upward);
         self
     }
 
     pub fn with_auto_width(mut self, auto_width: bool) -> Self {
         self.auto_width = auto_width;
         self
     }
 
     /// The open menu replaces the trigger: see the `menu_replaces_trigger` field.
     pub fn with_menu_replaces_trigger(mut self, replaces: bool) -> Self {
         self.menu_replaces_trigger = replaces;
         self
     }
 
     /// Popover geometry from the widget's laid-out rect — the legacy inherent
     /// `get_popover_geom` shape, for callers that hold the wrapper.
     pub fn get_popover_geom(&self) -> (f32, f32, f32, f32) {
         let (x, y, w, h) = WidgetHost::rect(self);
         let top = self.inner().label_top();
         self.inner().popover_geom(Rect { x, y: y + top, width: w, height: h - top })
     }
 }
 
 impl Layout for Dropdown {
 
     fn z_order(&self) -> i32 {
         if self.open {
             100
         } else {
             0
         }
     }
 
     /// Content size for the scene layout engine (Phase 2b). A normal dropdown is wide enough for
     /// the widest option (via `content_width`, which already includes the arrow/padding inset), so
     /// the control doesn't resize as the selection changes. A menu-button dropdown (fixed
     /// `custom_display_text`, e.g. a "File" menu) instead sizes to its display text — its label is
     /// fixed regardless of options, so fitting the widest entry would just stretch the trigger. The
     /// open popover still expands to the widest option via `popover_width`'s `.max(content_width())`.
     fn intrinsic_size(&self) -> Option<Size> {
         let width = if self.custom_display_text.is_some() {
             self.display_width()
         } else {
             self.content_width()
         };
         Some(Size::new(width, crate::layout::dropdown_height()))
     }
 
     fn intrinsic_measure_width(&self) -> bool {
         self.auto_width
     }
 }
 
 impl Paint for Dropdown {
     fn color(&self) -> [f32; 4] {
         [0.0, 0.0, 0.0, 0.0]
     }
 
     fn corner_style(&self, _rect: Rect) -> Option<(f32, (bool, bool, bool, bool))> {
         let r = crate::layout::dropdown_corner_radius();
         if r > 0.0 {
             Some((r, (true, true, true, true)))
         } else {
             Some((r, (false, false, false, false)))
         }
     }
 
     fn widget_font(&self) -> Option<String> {
         Some(crate::layout::control_label_font_detached())
     }
 
     fn sync_label(&mut self, label: &str) {
         self.label = Some(label.to_string());
     }
 
     fn paint(&self, rect: Rect, ctx: &mut PaintCtx) {
         if self.menu_replaces_trigger && self.open {
             // The trigger yields to the menu the moment the revealed rows
             // cover its band (and comes back as the contraction uncovers it);
             // the frosted menu plate is translucent, so a trigger left
             // painting beneath would show through blurred.
             let (_, ay, _, ah) = self.popover_geom_drawn(rect);
             if ay <= rect.y + 0.5 && ay + ah >= rect.y + rect.height - 0.5 {
                 return;
             }
         }
         self.paint_background(rect, ctx);
         self.paint_text(rect, ctx);
     }
 
     fn popover(&self, rect: Rect) -> Option<(f32, f32, f32, f32)> {
         if self.open {
             // The ANIMATED unified box (trigger band + revealed menu), not the
             // full menu geometry: hosts replay popover text with bounds derived
             // from this rect (and the dl-text occlusion clamp reads it), so
             // reporting the drawn surface keeps labels — the band's included —
             // clipped to the traveling edge everywhere without per-app changes.
             Some(self.unified_geom_drawn(rect))
         } else {
             None
         }
     }
 
     fn draw_popover(&self, rect: Rect, pc: &mut dyn crate::layout::RenderTarget) {
         if !self.open {
             return;
         }
 
         // ONE continuous surface in the status-interface manner: the trigger
         // band grows into the menu — no detached popover plate, no drop
         // shadows. The unified box spans the trigger and the revealed menu;
         // the trigger's display text is redrawn on top of its band. Rows sit
         // at their FINAL positions (from the full geometry) and slide into
         // view as the traveling edge reveals them, clipped to the menu area by
         // hand (RenderTarget carries no clip stack); text clips through its
         // bounds.
         let (rx, _ry, rw, _rh) = self.popover_geom(rect);
         // The row strip inside the box — past the relief wall on an outer edge.
         let rows_y = self.rows_top(rect);
         let (ax, ay, aw, ah) = self.popover_geom_drawn(rect);
         if aw <= 0.5 || ah <= 0.5 {
             // Nothing revealed yet — the plain trigger stands alone.
             return;
         }
         let clip = |x: f32, y: f32, w: f32, h: f32| -> Option<(f32, f32, f32, f32)> {
             let x0 = x.max(ax);
             let y0 = y.max(ay);
             let x1 = (x + w).min(ax + aw);
             let y1 = (y + h).min(ay + ah);
             if x1 > x0 && y1 > y0 { Some((x0, y0, x1 - x0, y1 - y0)) } else { None }
         };
 
         let theme = colors::active_theme();
         let (ux, uy, uw, uh) = self.unified_geom_drawn(rect);
 
         // The ACTUAL button surface, expanded: the raised trigger's flush
         // inset plate grown over the unified box (real relief prims on a
         // PaintCtx-backed target; collector hosts degrade to a rounded fill).
         // The trigger's configured fill is usually transparent — the window
         // plate IS its face — so the expansion substitutes the plate color,
         // FROSTED: the popover material (`Material::popover`), the same the
         // context menu wears (`ContextMenuState::paint`), so the menu shows
         // the content beneath it blurred and tinted rather than covering it.
         // Encoded here because the flat-path `RenderTarget` speaks colours.
         let radius = crate::layout::dropdown_corner_radius();
         let raw_bg = colors::dropdown_background_color();
         let face = {
             let base = if raw_bg[3] > 0.001 { raw_bg } else { crate::color::page_low_color() };
             crate::scene::Material::popover(base).fill(crate::scene::PlateRole::Nested)
         };
         if self.raised() {
             let depth = crate::layout::bevel_width().min(rect.height * 0.2);
             let (t, tr) = crate::layout::carve_inside(
                 crate::scene::layout::Rect { x: ux, y: uy, width: uw, height: uh },
                 (radius, radius, radius, radius),
                 depth,
             );
             pc.inset_plate(face, t.x, t.y, t.width, t.height, tr.0, depth);
         } else {
             pc.rect_with_radius(self.border_color(), ux, uy, uw, uh, radius);
             pc.rect_with_radius(face, ux + 1.0, uy + 1.0, uw - 2.0, uh - 2.0, (radius - 1.0).max(0.0));
         }
 
         // Trigger content redrawn over its band (the box covers the widget-pass
         // trigger paint) — display text left, arrow right, the paint_text palette.
         // A menu that replaces the trigger has no band to redraw on.
         if !self.menu_replaces_trigger {
             let (tx, ty) = (rect.x, rect.y);
             let th = rect.height;
             let band_bounds = Some([ux, uy, ux + uw, uy + uh]);
             let font = crate::layout::control_label_font_detached();
             let text_y = crate::layout::align_text_y(ty, th, 12.0, 0.0);
             pc.text_with_font_and_bounds(
                 &self.display_text(),
                 tx + 8.0,
                 text_y,
                 12.0,
                 [0.8, 0.8, 0.85, 1.0],
                 &font,
                 band_bounds,
             );
             pc.icon("chevron-down", self.arrow_rect(rect), ARROW_COLOR);
         }
 
         if let Some(h_idx) = self.hovered_item {
             let iy = rows_y + h_idx as f32 * Self::ROW_H;
             // 4. Vibrantly colored translucent selection highlight
             if let Some((cx, cy, cw, ch)) = clip(rx + 2.0, iy + 2.0, rw - 4.0, 20.0) {
                 pc.rect(theme.primary_accent, cx, cy, cw, ch);
             }
         }
 
         let marks = self.mark_column();
         for (idx, opt) in self.options.iter().enumerate() {
             let row_top = rows_y + idx as f32 * Self::ROW_H;
             let iy = crate::layout::align_text_y(row_top, Self::ROW_H, 12.0, 0.0);
 
             if opt == "-" {
                 if let Some((cx, cy, cw, ch)) = clip(rx + 8.0, row_top + 11.5, rw - 16.0, 1.0) {
                     pc.rect(theme.surface_border, cx, cy, cw, ch);
                 }
                 continue;
             }
 
             // Menu-button mode (custom_display_text) has no "current" option —
             // its rows are commands, so none reads as selected.
             let text_color = if self.hovered_item == Some(idx) {
                 [0xff, 0xff, 0xff]
             } else if self.selected == idx && self.custom_display_text.is_none() {
                 [0x3a, 0x9a, 0xff]
             } else {
                 [0xcc, 0xcc, 0xd4]
             };
 
             let color_f32 = [
                 text_color[0] as f32 / 255.0,
                 text_color[1] as f32 / 255.0,
                 text_color[2] as f32 / 255.0,
                 1.0,
             ];
 
             // Bounds = the unified popover rect EXACTLY (not the menu sub-box):
             // the dl-text occlusion clamp exempts only exact-match overlay
             // labels, and the unified box's traveling edge clips identically.
             let bounds = Some([ux, uy, ux + uw, uy + uh]);
             let font = crate::layout::control_label_font_detached();
             let (mark, label) = crate::widget::context_menu::split_mark(opt);
             if let Some(name) = mark {
                 let g = Rect { x: rx + 8.0, y: row_top + 0.5 * (Self::ROW_H - MARK_SIDE), width: MARK_SIDE, height: MARK_SIDE };
                 pc.push_clip_rect(ux, uy, uw, uh);
                 pc.icon(name, g, color_f32);
                 pc.pop_clip_rect();
             }
             pc.text_with_font_and_bounds(label, rx + 8.0 + marks, iy, 12.0, color_f32, &font, bounds);
         }
     }
 }
 
 impl Input for Dropdown {
     fn focus_role(&self) -> crate::widget::FocusRole {
         crate::widget::FocusRole::Plate
     }
     /// The legacy geometric test: the widget rect (edges inclusive), extended to the open
     /// popover. `rect` is the full base rect (label strip included), as legacy `hit_test` used.
     fn hit(&self, rect: Rect, x: f32, y: f32) -> bool {
         if rect.width <= 0.0 || rect.height <= 0.0 {
             return false;
         }
         let hit_trigger =
             x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
         if self.open && !self.closing {
             let top = self.label_top();
             let content = Rect { x: rect.x, y: rect.y + top, width: rect.width, height: rect.height - top };
             let (rx, ry, rw, rh) = self.popover_geom(content);
             let hit_popover = x >= rx && x <= rx + rw && y >= ry && y <= ry + rh;
             hit_trigger || hit_popover
         } else {
             hit_trigger
         }
     }
 
     fn opens_context_menu(&self) -> bool {
         true
     }
 
     /// Ungated presses (legacy `mouse_input` saw every press): an open dropdown must close on
     /// an outside click it would otherwise never learn about.
     fn gates_presses(&self) -> bool {
         false
     }
 
     /// Wall-clock animation bookkeeping: report "changed" while a transition is
     /// in flight (drives redraws where the app's UiContext gets ticked) and
     /// settle a landed close.
     fn tick(&mut self, _dt: f32, _rect: Rect) -> bool {
         let animating = self.anim_start.is_some();
         self.settle_anim();
         animating
     }
 
     fn on_event(&mut self, event: &Event, ectx: &mut EventCtx) -> bool {
         self.settle_anim();
         match event {
             Event::MouseButton {
                 button: MouseButton::Left,
                 state: ElementState::Released,
                 ..
             } => {
                 // While the menu is open (or shrinking closed), the paired
                 // release of any press this dropdown handled must not leak to
                 // widgets stacked beneath the popover: an unconsumed release
                 // falling through the host's dispatch landed on the button
                 // whose row the menu covers — in the designer's params pane,
                 // picking an "Open" entry fired the Save As button underneath
                 // and opened a save chooser on top of the load.
                 self.open || self.closing
             }
             Event::MouseButton {
                 button: MouseButton::Left,
                 state: ElementState::Pressed,
                 x: px,
                 y: py,
                 ..
             } => {
                 let content = ectx.rect;
                 let top = self.label_top();
                 let (bx, by, bw, bh) = (content.x, content.y - top, content.width, content.height + top);
                 let (rx, ry, rw, rh) = self.popover_geom(content);
 
                 let inside_trigger = *px >= bx && *px <= bx + bw && *py >= by && *py <= by + bh;
                 let inside_popover = self.open
                     && !self.closing
                     && *px >= rx && *px <= rx + rw && *py >= ry && *py <= ry + rh;
 
                 if std::env::var_os("CCE_DD_DEBUG").is_some() {
                     eprintln!(
                         "[dd] press ({px},{py}) rect=({:.0},{:.0},{:.0},{:.0}) popover=({rx:.0},{ry:.0},{rw:.0},{rh:.0}) open={} in_trig={inside_trigger} in_pop={inside_popover}",
                         content.x, content.y, content.width, content.height, self.open
                     );
                 }
                 if inside_popover {
                     if let Some(idx) = self.row_at(content, *py) {
                         if self.options[idx] == "-" {
                             return true;
                         }
                         if self.selected != idx || self.custom_display_text.is_some() {
                             self.selected = idx;
                             self.just_changed = true;
                         }
                     }
                     self.begin_close();
                     return true;
                 }
 
                 if inside_trigger {
                     if self.open && !self.closing {
                         self.begin_close();
                     } else {
                         self.begin_open();
                         // Animation frames arrive through the ctx tick loop.
                         if let Some(ui) = ectx.ui.as_deref_mut() {
                             ui.register_tick_receiver(ectx.id);
                         }
                         // Legacy `focus()` claimed only the global slot.
                         ectx.request_focus();
                     }
                     return true;
                 }
 
                 if self.open && !self.closing {
                     self.begin_close();
                     return true;
                 }
 
                 false
             }
             Event::PointerMove { x: px, y: py, .. } => {
                 // The popover-item half of the legacy `on_cursor_moved`; the trigger-hover half
                 // is the adapter's bookkeeping (MouseEnter/MouseLeave below).
                 let was_hovered_item = self.hovered_item;
                 self.hovered_item = None;
                 if self.open && !self.closing {
                     let (rx, ry, rw, rh) = self.popover_geom(ectx.rect);
                     if *px >= rx && *px <= rx + rw && *py >= ry && *py <= ry + rh {
                         if let Some(idx) = self.row_at(ectx.rect, *py) {
                             if self.options[idx] != "-" {
                                 self.hovered_item = Some(idx);
                             }
                         }
                     }
                 }
                 self.hovered_item != was_hovered_item
             }
             Event::MouseEnter => {
                 self.hovered = true;
                 true
             }
             Event::MouseLeave => {
                 self.hovered = false;
                 true
             }
             Event::KeyInput(key_event) => {
                 // A key event carries no position, so hosts that broadcast one to every
                 // widget root (cce-system-interface's `dispatch_page_event`) rely on each
                 // widget declining what is not addressed to it — TextBox gates on
                 // `editing`, Toggle has no key arm at all. A closed dropdown must gate on
                 // focus for the same reason: without this it opened on any Enter/Space
                 // that reached it, so the first dropdown in the host's dispatch order
                 // swallowed the Return meant for whatever actually held focus. (Settings'
                 // Browser page: Enter in the Homepage field opened the Page Color Scheme
                 // menu instead of committing the field. Its Power page: Enter on the
                 // focused Power Profile opened the last of the nine, GPU Power Limit.)
                 // An open dropdown always holds focus — the trigger press and `FocusIn`
                 // both claim it, and `FocusOut` closes it — so the `open` arm is reachable
                 // either way; it is spelled out so arrows and Escape stay live regardless.
                 if !self.open && !ectx.is_focused() {
                     return false;
                 }
                 let handled = self.handle_key(key_event);
                 if self.open {
                     if let Some(ui) = ectx.ui.as_deref_mut() {
                         ui.register_tick_receiver(ectx.id);
                     }
                 }
                 handled
             }
             Event::FocusIn => {
                 // Legacy `focus()` claimed the global focus slot on every direct call
                 // (test-interface focuses the ramp's preset dropdown this way).
                 self.focused = true;
                 ectx.request_focus();
                 false
             }
             Event::FocusOut => {
                 // Legacy `unfocus` closed the dropdown.
                 self.focused = false;
                 self.begin_close();
                 false
             }
             _ => false,
         }
     }
 
     fn take_click(&mut self) -> bool {
         self.take_change()
     }
 
     fn take_change(&mut self) -> bool {
         self.take_change()
     }
 
     fn value(&self) -> i32 {
         self.selected as i32
     }
 
     fn value_string(&self) -> Option<String> {
         self.options.get(self.selected).cloned()
     }
 
     fn set_value_string(&mut self, val: &str) -> bool {
         let val_trimmed = val.trim();
         for (idx, opt) in self.options.iter().enumerate() {
             if opt.eq_ignore_ascii_case(val_trimmed) {
                 if self.selected != idx {
                     self.selected = idx;
                     self.just_changed = true;
                     return true;
                 }
                 return false;
             }
         }
         if let Ok(idx) = val_trimmed.parse::<usize>() {
             if idx < self.options.len() {
                 if self.selected != idx {
                     self.selected = idx;
                     self.just_changed = true;
                     return true;
                 }
                 return false;
             }
         }
         false
     }
 }
 
 unsafe impl Send for Dropdown {}
 unsafe impl Sync for Dropdown {}
 
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::widget::LayoutConstraints;
 
     /// The trigger draws its text a cluster at a time, and each lands where the
     /// word shaped whole puts it — "Create" drew as "Cr eat e" while the offsets
     /// were measured a letter at a time.
     #[test]
     fn the_trigger_text_is_spaced_as_the_word_shapes() {
         let dd = Dropdown::new(vec!["Create".to_string()], 0);
         let mut pc = PaintCtx::new();
         dd.paint_text(Rect { x: 0.0, y: 0.0, width: 300.0, height: 24.0 }, &mut pc);
         let drawn: Vec<(String, f32)> = pc
             .finish()
             .items
             .into_iter()
             .filter_map(|item| match item.prim {
                 crate::scene::paint::Prim::Text { text, x, .. } => Some((text, x)),
                 _ => None,
             })
             .collect();
         assert_eq!(drawn.iter().map(|(t, _)| t.as_str()).collect::<String>(), "Create");
         let (_, size) = crate::layout::control_label_font_detached_parsed();
         let whole = shaped_clusters("Create", size).expect("the test process can shape");
         let x0 = drawn[0].1;
         for ((text, x), &(_, want)) in drawn.iter().zip(whole.iter()) {
             assert!((x - x0 - want).abs() < 0.01, "{text:?} drawn at {} where the word puts it at {want}", x - x0);
         }
     }
 
     #[test]
     fn test_dropdown_widget_interaction() {
         let mut dummy = crate::context::UiContext::new();
         let options = vec!["Option A".to_string(), "Option B".to_string(), "Option C".to_string()];
         let mut dd = Dropdown::new(options, 0);
         dd.set_rect(10.0, 10.0, 100.0, 24.0);
 
         // 1. Initial State
         assert!(!dd.open);
         assert_eq!(dd.selected, 0);
 
         // 2. Click trigger area opens dropdown
         let input_changed = dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 20.0, &mut dummy);
         assert!(input_changed);
         assert!(dd.open);
 
         // 3. Hovering options inside popover
         // Popover starts at y = 10 + 24 = 34. Options are of height 24 each.
         // Hover option B at y = 34 + 24 + 12 = 70.0
         let move_changed = dd.on_cursor_moved(50.0, 70.0, &mut dummy);
         assert!(move_changed);
         assert_eq!(dd.hovered_item, Some(1));
 
         assert!(dd.is_expanded(), "open and taking input");
         // 4. Click option B selects it and starts the animated close
         let select_changed = dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 70.0, &mut dummy);
         assert!(select_changed);
         assert!(dd.closing, "selection starts the animated contraction");
         assert!(dd.open && !dd.is_expanded(), "drawn while it shrinks, but no longer taking input");
         dd.land_anim_for_test();
         assert!(!dd.open);
         assert_eq!(dd.selected, 1);
         assert!(dd.take_change());
     }
 
     #[test]
     fn test_dropdown_context_menu_with_config() {
         let mut dummy = crate::context::UiContext::new();
         let options = vec!["Option A".to_string(), "Option B".to_string()];
         let mut dd = Dropdown::new(options, 0).with_config("path/to/config.json", "some_key");
         dd.set_rect(10.0, 10.0, 100.0, 24.0);
 
         assert!(!crate::widget::context_menu::is_visible());
 
         // Right click dropdown
         let handled = dd.mouse_input(MouseButton::Right, ElementState::Pressed, 50.0, 20.0, &mut dummy);
         assert!(handled);
 
         assert!(crate::widget::context_menu::is_visible());
         let menu_options = crate::widget::context_menu::options();
         assert!(menu_options.len() >= 3);
         assert_eq!(menu_options[1], "File: path/to/config.json");
         assert_eq!(menu_options[2], "Key: some_key");
 
         crate::widget::context_menu::hide();
         assert!(!crate::widget::context_menu::is_visible());
     }
 
     /// A closed dropdown takes Enter only when it is the focused widget.
     ///
     /// Hosts that broadcast a key event to every widget root (cce-system-interface's
     /// `dispatch_page_event`) depend on each widget declining what is not addressed to
     /// it — a key event carries no position to filter on. Without the focus gate the
     /// first dropdown in the host's dispatch order opened on *any* Enter that reached
     /// it, swallowing the Return meant for whatever actually held focus: settings'
     /// Browser page opened Page Color Scheme instead of committing the Homepage field,
     /// and its Power page opened the last of nine menus instead of the focused one.
     #[test]
     fn closed_dropdown_takes_enter_only_when_focused() {
         let mut dummy = crate::context::UiContext::new();
         let enter = crate::widget::KeyEvent {
             state: ElementState::Pressed,
             logical_key: Key::Named(NamedKey::Enter),
             text: None,
             repeat: false,
             ctrl: false,
             shift: false,
             alt: false,
         };
 
         let opts = vec!["Dark".to_string(), "Light".to_string()];
         let mut dd = Dropdown::new(opts.clone(), 0);
         dd.set_rect(10.0, 10.0, 100.0, 24.0);
 
         // Nothing focused: the Return belongs to someone else, so it is declined and
         // the menu stays shut.
         dummy.focused_widget = None;
         assert!(!dd.keyboard_input(&enter, &mut dummy));
         assert!(!dd.open);
 
         // Another widget focused: same — this is the settings-page case, where the
         // focused TextBox sits later in the reversed dispatch order.
         let other = Dropdown::new(opts, 0);
         dummy.focused_widget = Some(other.id());
         assert!(!dd.keyboard_input(&enter, &mut dummy));
         assert!(!dd.open);
 
         // Focused: Enter opens it, and arms the hover on the selection as before.
         dummy.focused_widget = Some(dd.id());
         assert!(dd.keyboard_input(&enter, &mut dummy));
         assert!(dd.open);
         assert_eq!(dd.hovered_item, Some(0));
 
         // Once open the gate is out of the way, so Escape still closes it even if the
         // focus moved on (`FocusOut` closes it too, but the key path must not depend
         // on that having run).
         dummy.focused_widget = None;
         let escape = crate::widget::KeyEvent {
             logical_key: Key::Named(NamedKey::Escape),
             ..enter.clone()
         };
         assert!(dd.keyboard_input(&escape, &mut dummy));
         assert!(dd.closing || !dd.open);
     }
 
     #[test]
     fn test_dropdown_separators() {
         let mut dummy = crate::context::UiContext::new();
         let options = vec![
             "Option A".to_string(),
             "-".to_string(),
             "Option B".to_string(),
         ];
         let mut dd = Dropdown::new(options, 0);
         dd.set_rect(10.0, 10.0, 100.0, 24.0);
 
         // Open dropdown
         dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 20.0, &mut dummy);
         assert!(dd.open);
 
         // Hover over separator at index 1 at y = 34 + 24 + 12 = 70.0
         dd.on_cursor_moved(50.0, 70.0, &mut dummy);
         assert_eq!(dd.hovered_item, None); // Separator should not be hovered
 
         // Click separator at index 1
         let clicked = dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 70.0, &mut dummy);
         assert!(clicked);
         assert!(dd.open); // Dropdown should remain open
         assert_eq!(dd.selected, 0); // Selection should not change
 
         // Hover over Option B at index 2 at y = 34 + 48 + 12 = 94.0
         dd.on_cursor_moved(50.0, 94.0, &mut dummy);
         assert_eq!(dd.hovered_item, Some(2));
 
         // Keyboard arrow up from index 2 should skip separator (index 1) and go to index 0
         let key_up = crate::widget::KeyEvent {
             state: ElementState::Pressed,
             logical_key: Key::Named(NamedKey::ArrowUp),
             text: None,
             repeat: false,
             ctrl: false,
             shift: false,
             alt: false,
         };
         dd.keyboard_input(&key_up, &mut dummy);
         assert_eq!(dd.hovered_item, Some(0));
     }
 
     #[test]
     fn test_dropdown_ramp_parent_constraints() {
         let mut ramp = crate::widget::Ramp::new();
         // Set the rect of parent Ramp
         ramp.set_rect(20.0, 20.0, 410.0, 260.0);
 
         let options = vec![
             "Option 1".to_string(),
             "Option 2".to_string(),
             "Option 3".to_string(),
             "Option 4".to_string(),
             "Option 5".to_string(),
             "Option 6".to_string(),
         ];
         let mut dd = Dropdown::new(options, 0).with_label("Preset");
         dd.set_rect(30.0, 125.0, 110.0, 20.0);
 
         // Link the dropdown to the Ramp's read-data (the legacy direct-write path)
         dd.parent_snapshot = Some(ParentSnapshot {
             rect: crate::widget::WidgetHost::rect(&ramp),
             is_ramp: true,
             color: crate::widget::WidgetHostExt::color(&ramp),
         });
 
         // Compute geometry
         let (rx, ry, rw, rh) = dd.get_popover_geom();
 
         // Validate coordinates stay inside the parent Ramp bounds: x in [20, 430], y in [20, 280]
         assert!(rx >= 20.0, "rx {} should be >= 20.0", rx);
         assert!(rx + rw <= 430.0, "rx + rw {} should be <= 430.0", rx + rw);
         assert!(ry >= 20.0, "ry {} should be >= 20.0", ry);
         assert!(ry + rh <= 280.0, "ry + rh {} should be <= 280.0", ry + rh);
     }
 
     #[test]
     fn test_dropdown_label_fade_out() {
         let options = vec!["This is a very long option name that will exceed the dropdown width".to_string()];
         let mut dd = Dropdown::new(options, 0);
         dd.set_rect(10.0, 10.0, 100.0, 24.0); // very narrow dropdown
 
         let labels = dd.own_text_labels();
         // Labels are individual characters of selected_text (the arrow is a glyph, not text).
         assert!(labels.len() > 2);
 
         // The last character label should be faded (i.e. not the default color)
         let last_char_idx = labels.len() - 1;
         let first_char = &labels[0];
         let last_char = &labels[last_char_idx];
 
         let tc = colors::dropdown_text_color();
         let expected_color = [
             (colors::linear_to_srgb(tc[0]) * 255.0).round() as u8,
             (colors::linear_to_srgb(tc[1]) * 255.0).round() as u8,
             (colors::linear_to_srgb(tc[2]) * 255.0).round() as u8,
         ];
         assert_eq!(first_char.color, expected_color);
         assert_ne!(last_char.color, expected_color); // color has shifted towards background
     }
 
     /// A list whose options carry the context menu's marks draws them as
     /// glyphs in a column at the left, the labels after it and lined up, and
     /// the trigger shows its value without the mark — the convention a
     /// "View" menu-button marks its switches by. Skipped without the icon set.
     #[test]
     fn a_marked_option_draws_its_glyph() {
         if !std::path::Path::new(&crate::icons_dir()).join("check.svg").is_file() {
             eprintln!("skipped: no icon set");
             return;
         }
         #[derive(Default)]
         struct Rec {
             icons: Vec<(String, f32)>,
             texts: Vec<(String, f32)>,
         }
         impl crate::layout::RenderTarget for Rec {
             fn rect(&mut self, _: [f32; 4], _: f32, _: f32, _: f32, _: f32) {}
             fn text(&mut self, t: &str, x: f32, _: f32, _: f32, _: [f32; 4]) {
                 self.texts.push((t.to_string(), x));
             }
             fn text_with_font_and_bounds(&mut self, t: &str, x: f32, _: f32, _: f32, _: [f32; 4], _: &str, _: Option<[f32; 4]>) {
                 self.texts.push((t.to_string(), x));
             }
             fn icon(&mut self, name: &str, r: Rect, _: [f32; 4]) {
                 self.icons.push((name.to_string(), r.x));
             }
         }
         let opts = vec!["✓ Show Grid".to_string(), "Control Panel".to_string(), "○ Opacity 50%".to_string()];
         let mut dd = Dropdown::new(opts, 0).with_custom_display_text("View");
         let rect = Rect { x: 10.0, y: 10.0, width: 200.0, height: 24.0 };
         {
             let d = dd.inner_mut();
             d.open = true;
             d.anim_snap = 1.0;
         }
         let mut rec = Rec::default();
         crate::widget::Paint::draw_popover(dd.inner(), rect, &mut rec);
         // The trigger band redrawn over the list keeps its arrow; the rest
         // are the rows' marks.
         rec.icons.retain(|(n, _)| n != "chevron-down");
         let names: Vec<&str> = rec.icons.iter().map(|(n, _)| n.as_str()).collect();
         assert_eq!(names, ["check", "circle-outline"]);
         let x_of = |t: &str| rec.texts.iter().find(|(s, _)| s == t).map(|(_, x)| *x).unwrap_or_else(|| panic!("{t:?} not drawn: {:?}", rec.texts));
         assert_eq!(x_of("Show Grid"), x_of("Control Panel"), "an unmarked row keeps the mark column");
         assert!(x_of("Show Grid") > rec.icons[0].1, "the label stands after its mark");
         assert!(rec.texts.iter().all(|(t, _)| !t.contains(['✓', '○', '●'])), "no mark drawn as text: {:?}", rec.texts);
         let plain = Dropdown::new(vec!["✓ On".to_string(), "Off".to_string()], 0);
         assert_eq!(plain.inner().display_text(), "On", "the trigger shows the value without its mark");
     }
 
     /// A trigger that carries nothing but its arrow (the textpick picker)
     /// stands it in its middle: its padding about the arrow is even.
     #[test]
     fn a_centred_arrow_stands_in_the_middle_of_its_trigger() {
         let arrow_x = |center: bool| {
             let mut dd = Dropdown::new(vec!["a".to_string()], 0).with_custom_display_text("");
             dd.inner_mut().center_arrow = center;
             dd.set_rect(10.0, 10.0, 30.0, 24.0);
             dd.inner().arrow_rect(Rect { x: 10.0, y: 10.0, width: 30.0, height: 24.0 }).x
         };
         let adv = super::ARROW_SIDE;
         let x = arrow_x(true);
         assert!((x + 0.5 * adv - 25.0).abs() < 1e-3, "centred on the trigger's middle: {x} + {adv}/2");
         let slot = super::arrow_slot(24.0);
         assert!((arrow_x(false) + 0.5 * adv - (40.0 - 0.5 * slot)).abs() < 1e-3, "an ordinary trigger centres it in the slot at its right end");
     }
 
     #[test]
     fn test_dropdown_auto_width() {
         let dummy = crate::context::UiContext::new();
         let options = vec!["Short".to_string(), "A much longer option name".to_string()];
         let mut dd = Dropdown::new(options, 0).with_auto_width(true);
         dd.set_rect(10.0, 10.0, 50.0, 24.0);
 
         let size = dd.measure(LayoutConstraints::new(0.0, 500.0, 24.0, 24.0), &dummy);
         assert!(size.width > 50.0, "Measured auto-width {} should be greater than original width 50.0", size.width);
 
         let dd_no_auto = Dropdown::new(vec!["Short".to_string(), "A much longer option name".to_string()], 0);
         let size_no_auto = dd_no_auto.measure(LayoutConstraints::new(0.0, 500.0, 24.0, 24.0), &dummy);
         assert_eq!(size_no_auto.width, 0.0);
     }
 
     #[test]
     fn intrinsic_size_fits_widest_option() {
         let wide = Dropdown::new(
             vec!["Short".to_string(), "A much longer option name".to_string()],
             0,
         );
         let size = Layout::intrinsic_size(wide.inner()).expect("dropdown reports intrinsic size");
         assert!(size.width >= wide.content_width(), "width fits the widest option");
         assert_eq!(size.height, crate::layout::dropdown_height());
 
         let narrow = Dropdown::new(vec!["Hi".to_string()], 0);
         assert!(
             size.width > Layout::intrinsic_size(narrow.inner()).unwrap().width,
             "more/longer options measure wider",
         );
     }
 
     #[test]
     fn menu_button_trigger_fits_display_text_not_widest_option() {
         // A menu-button dropdown (fixed custom display text) sizes its trigger to that text, so a
         // long menu entry (e.g. a recent-file path) no longer stretches the "File" button.
         let menu = Dropdown::new(
             vec![
                 "New".to_string(),
                 "/home/user/some/very/long/recent/project/path".to_string(),
             ],
             0,
         )
         .with_custom_display_text("File");
 
         let trigger = Layout::intrinsic_size(menu.inner()).expect("dropdown reports intrinsic size");
         assert!(
             trigger.width < menu.inner().content_width(),
             "menu-button trigger ({}) fits its display text, not the widest option ({})",
             trigger.width,
             menu.inner().content_width(),
         );
 
         // The open popover still expands to the widest option.
         let content = Rect { x: 0.0, y: 0.0, width: trigger.width, height: trigger.height };
         assert!(
             menu.inner().popover_geom(content).2 >= menu.inner().content_width(),
             "popover still fits the widest option",
         );
 
         // The trigger leaves the paint pass's full budget (8px left pad + 28px right/arrow
         // reservation) for the label, so the display text renders without tripping the right-edge
         // fade. This is the paint condition `start_x + total_advance > right_limit` restated:
         // `content.x + 8 + advance > content.x + width - 28`, i.e. it must hold that
         // `width >= advance + 36`. Measured via `text_advance` — the same function the paint pass
         // lays out with — so the guarantee holds in a monospace UI font too.
         let (font_family, font_size) = crate::layout::control_label_font_detached_parsed();
         let advance = text_advance("File", &font_family, font_size);
         assert!(
             trigger.width >= advance + 36.0,
             "trigger width ({}) leaves room for the laid-out label (advance {} + 36px budget), \
              so it doesn't fade",
             trigger.width,
             advance,
         );
     }
 
     /// Migration additions: popover routing through the adapter (`WidgetHost::popover_rect` /
     /// `render_popover`), outside-press close, and Escape via routed key events.
     #[test]
     fn popover_reaches_hosts_through_the_adapter() {
         let mut dummy = crate::context::UiContext::new();
         let options = vec!["A".to_string(), "B".to_string()];
         let mut dd = Dropdown::new(options, 0);
         dd.set_rect(10.0, 10.0, 100.0, 24.0);
 
         assert!(WidgetHost::popover_rect(&dd).is_none(), "closed dropdown registers no popover");
 
         dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 20.0, &mut dummy);
         assert!(dd.open);
         // popover_rect reports the ANIMATED box — land the expansion first.
         dd.land_anim_for_test();
         let (rx, ry, rw, rh) = WidgetHost::popover_rect(&dd).expect("open dropdown registers its popover");
         // The box is the band, the rows, and the relief wall the plate needs
         // along its one outer edge (the bottom, for a downward menu) — without
         // that reserve the trough painted over the last row's descenders.
         let wall = dd.plate_inset(24.0);
         assert!(wall > 0.0, "the default relief styling carves the open plate");
         assert_eq!((rx, ry), (10.0, 10.0), "the unified surface starts at the trigger band");
         assert!(
             rw >= 100.0 && rh == 24.0 + 2.0 * 24.0 + wall,
             "trigger band (24) + menu (2 * 24) + the bottom wall as one box",
         );
         assert_eq!(
             dd.rows_top(Rect { x: 10.0, y: 10.0, width: 100.0, height: 24.0 }),
             34.0,
             "a downward menu's rows still start flush under the band",
         );
         let trigger = Rect { x: 10.0, y: 10.0, width: 100.0, height: 24.0 };
         assert_eq!(dd.row_at(trigger, 34.0 + 47.9), Some(1), "the last row is whole");
         assert_eq!(dd.row_at(trigger, 34.0 + 48.1), None, "the wall below it picks nothing");
 
         // An outside press closes it (ungated presses — `gates_presses` is false).
         let closed = dd.mouse_input(MouseButton::Left, ElementState::Pressed, 500.0, 500.0, &mut dummy);
         assert!(closed);
         assert!(dd.closing, "outside press starts the animated contraction");
         dd.land_anim_for_test();
         assert!(!dd.open);
         assert!(!dd.take_change(), "outside close does not report a change");
     }
 
     /// `with_menu_replaces_trigger`: the open surface is the rows alone, sat
     /// in the trigger's slot — no band, and the trigger stops painting once
     /// the menu covers it.
     #[test]
     fn menu_replaces_trigger_drops_the_band() {
         let mut dummy = crate::context::UiContext::new();
         let options = vec!["A".to_string(), "B".to_string(), "C".to_string()];
         let mut dd = Dropdown::new(options, 1)
             .with_open_upward(true)
             .with_menu_replaces_trigger(true);
         dd.set_rect(10.0, 300.0, 100.0, 24.0);
 
         dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 310.0, &mut dummy);
         assert!(dd.open);
         dd.land_anim_for_test();
         let (rx, ry, rw, rh) = WidgetHost::popover_rect(&dd).expect("open dropdown registers its popover");
         // No band, so BOTH edges are outer ones and both carry the wall.
         let wall = dd.plate_inset(24.0);
         assert!(
             (rh - (3.0 * 24.0 + 2.0 * wall)).abs() < 0.01,
             "three rows and nothing else — no trigger band: {rh}",
         );
         assert_eq!((rx, ry + rh), (10.0, 324.0), "the menu's bottom edge sits on the trigger's bottom edge");
         assert_eq!(
             dd.rows_top(Rect { x: 10.0, y: 300.0, width: 100.0, height: 24.0 }),
             ry + wall,
             "the rows start inside the wall",
         );
         assert!(rw >= 100.0);
         assert_eq!(dd.get_popover_geom(), (rx, ry, rw, rh), "the drawn box is the full menu once landed");
 
         // The trigger's slot is now the bottom row: a press there picks it,
         // rather than toggling the trigger closed.
         dd.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 312.0, &mut dummy);
         assert_eq!(dd.selected, 2);
         assert!(dd.take_change());
         assert!(dd.closing);
         dd.land_anim_for_test();
         assert!(!dd.open);
 
         // The default keeps the band.
         let mut plain = Dropdown::new(vec!["A".to_string(), "B".to_string()], 0).with_open_upward(true);
         plain.set_rect(10.0, 300.0, 100.0, 24.0);
         plain.mouse_input(MouseButton::Left, ElementState::Pressed, 50.0, 310.0, &mut dummy);
         plain.land_anim_for_test();
         let (_, ry, _, rh) = WidgetHost::popover_rect(&plain).unwrap();
         // Upward: the menu's TOP is the outer edge, so the wall goes there and
         // the rows still end flush on the band.
         let wall = plain.plate_inset(24.0);
         assert_eq!(
             (ry, rh),
             (252.0 - wall, 24.0 + 2.0 * 24.0 + wall),
             "band (24) + two rows (48) + the top wall, stacked above the trigger",
         );
         assert_eq!(
             plain.rows_top(Rect { x: 10.0, y: 300.0, width: 100.0, height: 24.0 }),
             252.0,
             "the rows end flush on the band",
         );
     }
 
     /// A trigger nested at the right end of a wider field (the textpick
     /// picker, through `popover_anchor`) opens as a plate its own width,
     /// under itself, and widens out to the field — both edges travelling. An
     /// unanchored trigger still grows rightward from its own left edge.
     #[test]
     fn a_nested_trigger_grows_its_menu_out_of_its_own_span() {
         let trigger = Rect { x: 170.0, y: 10.0, width: 30.0, height: 24.0 };
         let field = Rect { x: 10.0, y: 10.0, width: 190.0, height: 24.0 };
         let mut dd = Dropdown::new(vec!["A".to_string(), "B".to_string()], 0).with_open_upward(false);
         dd.popover_anchor = Some(field);
 
         dd.anim_snap = 0.0;
         let (x, _, w, h) = dd.popover_geom_drawn(trigger);
         assert_eq!((x, w, h), (170.0, 30.0, 0.0), "it begins as the button");
         let (ux, _, uw, _) = dd.unified_geom_drawn(trigger);
         assert_eq!((ux, uw), (170.0, 30.0), "the open surface is the button alone at first");
 
         dd.anim_snap = 0.5;
         let (x, _, w, _) = dd.popover_geom_drawn(trigger);
         assert!(x > 10.0 && x < 170.0, "the left edge travels from the button toward the field's: {x}");
         assert_eq!(x + w, 200.0, "the right edge stays where the button's is");
 
         dd.anim_snap = 1.0;
         let (x, _, w, _) = dd.popover_geom_drawn(trigger);
         assert_eq!((x, w), (10.0, 190.0), "it lands spanning the field");
 
         let plain = {
             let mut d = Dropdown::new(vec!["A".to_string(), "B".to_string()], 0).with_open_upward(false);
             d.anim_snap = 0.5;
             d
         };
         let wide = Rect { x: 10.0, y: 10.0, width: 100.0, height: 24.0 };
         let (x, _, w, _) = plain.popover_geom_drawn(wide);
         assert_eq!(x, 10.0, "an unanchored menu keeps its left edge");
         assert!(w >= 100.0, "and grows rightward out of the trigger");
     }
 }