//! The widget roster: the app's top-level widgets in fixed, statically typed slots.
 //!
 //! The designer does not build a dynamic widget tree — every top-level pane, bar and
 //! plate lives in a named field of [`WidgetSlots`], and the `*_IDX` constants address
 //! those same fields positionally for the genuinely index-driven paths (draw order,
 //! focus cycling, broadcast loops). The whole roster is declared once, in the
 //! `widget_roster!` invocation below — one line per slot, from which the constants,
 //! the struct fields and every index→field dispatch are generated. The typed accessors
 //! that assert each slot's concrete type are hand-written, below the macro.
 
 use cce_ui::context::UiContext;
 use cce_ui::widget::{
     Adapted, Breadcrumb, Graph, MenuBar, ParametersBg, Splitter, Spreadsheet,
     StatusBar, WidgetHost, WidgetId,
 };
 
 use crate::playbar::Playbar;
 use crate::viewport_3d::Viewport3D;
 
 /// Declares the whole roster from one line per slot: `INDEX_CONST: field: WidgetType`.
 ///
 /// Declaration order *is* slot order: the `*_IDX` constants are numbered from it and
 /// `WIDGET_COUNT` falls out of the length. The single list below generates the
 /// constants, the `WidgetSlots` fields, and all four index→field dispatch matches, so
 /// adding or reordering a pane is one line instead of six hand-kept edits whose only
 /// backstop was a runtime panic.
 macro_rules! widget_roster {
     ($($idx:ident : $field:ident : $ty:ty),+ $(,)?) => {
         widget_roster!(@number 0usize; $($idx)+);
 
         /// The roster, concretely typed (Phase 6bb): every slot's type is statically known — the
         /// old `Vec<Box<dyn WidgetHost>>` erased that and pinned `WidgetHost`'s full surface through the
         /// broadcast loops. The widgets live in the `UiContext`; the roster holds their handles
         /// (`docs/rfc-owning-registry.md` in cce-ui). The `*_IDX` constants keep addressing the same slots through
         /// `get_dyn`/`get_dyn_mut` for the genuinely index-driven paths (draw order, focus cycling,
         /// broadcast loops); everything else reaches the concrete field.
         pub struct WidgetSlots {
             $(pub $field: cce_ui::widget::Handle<Adapted<$ty>>,)+
         }
 
         impl WidgetSlots {
             // Per-slot drag queries (the ControlPanel endgame took `draggable`/`is_dragging`
             // off `WidgetHost`): the roster routes an index to the concrete slot's inherent
             // `Adapted` read, like the other value drains.
             pub fn draggable(&self, ui: &UiContext, idx: usize) -> bool {
                 match idx {
                     $($idx => ui[self.$field].draggable(),)+
                     _ => slot_out_of_range(idx),
                 }
             }
 
             pub fn is_dragging(&self, ui: &UiContext, idx: usize) -> bool {
                 match idx {
                     $($idx => ui[self.$field].is_dragging(),)+
                     _ => slot_out_of_range(idx),
                 }
             }
 
             /// The slot's widget id: what focus, popovers and dispatch are keyed by.
             pub fn id(&self, idx: usize) -> WidgetId {
                 match idx {
                     $($idx => self.$field.id(),)+
                     _ => slot_out_of_range(idx),
                 }
             }
 
             /// The slot's widget, which the context owns.
             pub fn get_dyn<'a>(&self, ui: &'a UiContext, idx: usize) -> &'a (dyn WidgetHost + 'static) {
                 match idx {
                     $($idx => &ui[self.$field],)+
                     _ => slot_out_of_range(idx),
                 }
             }
 
             pub fn get_dyn_mut<'a>(&self, ui: &'a mut UiContext, idx: usize) -> &'a mut (dyn WidgetHost + 'static) {
                 match idx {
                     $($idx => &mut ui[self.$field],)+
                     _ => slot_out_of_range(idx),
                 }
             }
         }
     };
 
     // Number the constants in declaration order; what is left over at the end is the count.
     (@number $n:expr;) => {
         pub const WIDGET_COUNT: usize = $n;
     };
     (@number $n:expr; $head:ident $($rest:ident)*) => {
         pub const $head: usize = $n;
         widget_roster!(@number $n + 1; $($rest)*);
     };
 }
 
 /// Every dispatch match needs a `_` arm — the compiler cannot see that the constant
 /// patterns cover `0..WIDGET_COUNT` — and `!` fits all four return types.
 #[cold]
 #[inline(never)]
 fn slot_out_of_range(idx: usize) -> ! {
     panic!("widget slot index out of range: {idx}")
 }
 
 widget_roster! {
     HEADER_IDX:              header:              MenuBar,
     CONTENT_IDX:             content:             Graph,
     SPLITTER1_IDX:           splitter1:           Splitter,
     VIEWPORT_IDX:            viewport:            Viewport3D,
     SPLITTER2_IDX:           splitter2:           Splitter,
     PARAM_IDX:               param:               ParametersBg,
     CANVAS_IDX:              canvas:              Canvas,
     LEFT_MENUBAR_IDX:        left_menubar:        MenuBar,
     RIGHT_MENUBAR_IDX:       right_menubar:       MenuBar,
     PARAM_MENUBAR_IDX:       param_menubar:       MenuBar,
     STATUS_IDX:              status:              StatusBar,
     BREADCRUMB_IDX:          breadcrumb:          Breadcrumb,
     SPREADSHEET_IDX:         spreadsheet:         Spreadsheet,
     SPREADSHEET_MENUBAR_IDX: spreadsheet_menubar: MenuBar,
     NETWORK_PANEL_IDX:       network_panel:       PassivePlate,
     PLAYBAR_IDX:             playbar:             Playbar,
     // (The second network editor's three slots — plate, graph, breadcrumb —
     // stood here until 2026-10-07, when the editor was removed.)
     // The Alt+D dialog: plate, query line and the one list of commands and
     // settings, its controls painted from the toolkit's own stamps. (A second
     // ParametersBg slot for a Settings half sat after it until 2026-09-24.)
     DIALOG_IDX:              dialog:              crate::dialog::Dialog,
 }
 
 impl WidgetSlots {
     /// Roster index of the slot at `target_addr` (a thin widget address — the comparison
     /// never dereferences; callers pass `ptr as *const ()`).
     pub fn find_index(&self, ui: &UiContext, id: cce_ui::widget::WidgetId) -> Option<usize> {
         (0..WIDGET_COUNT).position(|i| self.get_dyn(ui, i).base().id() == id)
     }
 
     // Roster accessors on CONCRETE types (Phase 6aw, controller decision option 2): each
     // index's type is known statically, so the capability traits are reached by downcast +
     // Deref instead of WidgetHost's deleted as_*_controller discovery hooks. Signatures keep
     // returning the narrow trait objects so the ~40 call sites stay unchanged. The dynamic
     // `idx` of menu()/menu_mut() only ever receives the five menubar indexes.
     pub fn viewport<'a>(&self, ui: &'a UiContext) -> &'a Viewport3D {
         ui[self.viewport]
             .as_any()
             .downcast_ref::<Viewport3D>()
             .expect("VIEWPORT_IDX must be a Viewport3D")
     }
 
     pub fn viewport_mut<'a>(&self, ui: &'a mut UiContext) -> &'a mut Viewport3D {
         ui[self.viewport]
             .as_any_mut()
             .downcast_mut::<Viewport3D>()
             .expect("VIEWPORT_IDX must be a Viewport3D")
     }
 
     /// The menu-capable roster entries are exactly the `Adapted<MenuBar>` bars (Phase 6aw
     /// concrete typing); `None` for everything else.
     pub fn menubar_at<'a>(&self, ui: &'a UiContext, idx: usize) -> Option<&'a MenuBar> {
         // Adapted::as_any exposes the INNER widget, so the downcast targets MenuBar itself.
         self.get_dyn(ui, idx).as_any().downcast_ref::<MenuBar>()
     }
 
     pub fn menu<'a>(&self, ui: &'a UiContext, idx: usize) -> &'a dyn cce_ui::widget::MenuController {
         self.get_dyn(ui, idx).as_any().downcast_ref::<MenuBar>().expect("not a MenuBar")
     }
 
     pub fn menu_mut<'a>(&self, ui: &'a mut UiContext, idx: usize) -> &'a mut dyn cce_ui::widget::MenuController {
         self.get_dyn_mut(ui, idx).as_any_mut().downcast_mut::<MenuBar>().expect("not a MenuBar")
     }
 
     pub fn graph<'a>(&self, ui: &'a UiContext) -> &'a dyn cce_ui::widget::GraphController {
         ui[self.content].as_any().downcast_ref::<Graph>().expect("CONTENT_IDX must be a Graph")
     }
 
     pub fn graph_mut<'a>(&self, ui: &'a mut UiContext) -> &'a mut dyn cce_ui::widget::GraphController {
         ui[self.content].as_any_mut().downcast_mut::<Graph>().expect("CONTENT_IDX must be a Graph")
     }
 
     pub fn param<'a>(&self, ui: &'a UiContext) -> &'a dyn cce_ui::widget::ParamController {
         ui[self.param].as_any().downcast_ref::<ParametersBg>().expect("PARAM_IDX must be a ParametersBg")
     }
 
     pub fn param_mut<'a>(&self, ui: &'a mut UiContext) -> &'a mut dyn cce_ui::widget::ParamController {
         ui[self.param].as_any_mut().downcast_mut::<ParametersBg>().expect("PARAM_IDX must be a ParametersBg")
     }
 
     /// The pane as its concrete type, for what `ParamController` does not
     /// carry — the code row's error line.
     pub fn param_bg_mut<'a>(&self, ui: &'a mut UiContext) -> &'a mut ParametersBg {
         ui[self.param].as_any_mut().downcast_mut::<ParametersBg>().expect("PARAM_IDX must be a ParametersBg")
     }
 
     /// The spreadsheet as itself, for what its controller trait does not
     /// carry — the scrollbars the render arm straddles around the plate.
     pub fn spreadsheet<'a>(&self, ui: &'a UiContext) -> &'a Spreadsheet {
         ui[self.spreadsheet].as_any().downcast_ref::<Spreadsheet>().expect("SPREADSHEET_IDX must be a Spreadsheet")
     }
 
     pub fn spreadsheet_mut<'a>(&self, ui: &'a mut UiContext) -> &'a mut dyn cce_ui::widget::SpreadsheetController {
         ui[self.spreadsheet].as_any_mut().downcast_mut::<Spreadsheet>().expect("SPREADSHEET_IDX must be a Spreadsheet")
     }
 
     pub fn path_mut<'a>(&self, ui: &'a mut UiContext) -> &'a mut dyn cce_ui::widget::PathController {
         ui[self.breadcrumb].as_any_mut().downcast_mut::<Breadcrumb>().expect("BREADCRUMB_IDX must be a Breadcrumb")
     }
 }
 
 
 /// Dissolved cce-ui `Plate` (Phase 6as): a passive panel wearing the parameter
 /// plate's fill — same tint, opacity, and blur-behind marker (`param_plate_fill`),
 /// so the network plate's bevel rolls exactly like the params plate's and tracks a
 /// live retint/opacity/blur toggle. NOT scaled by the network fade (it was until
 /// 2026-09-20): the graph's grid cells are this plate showing through, so the
 /// plate has to be the pane material verbatim or the network pane reads as a
 /// different colour from every other pane. The fade applies to what is drawn
 /// over it — grid lines, wires, text. No children, no events.
 pub struct PassivePlate {
     /// Circular hit shape while the network pane is round (the legacy Plate marker).
     curved_circle: Option<(f32, f32, f32)>,
 }
 
 impl PassivePlate {
     pub fn new() -> cce_ui::widget::Adapted<PassivePlate> {
         cce_ui::widget::Adapted::new(Self {
             curved_circle: None,
         })
     }
 
     pub fn set_curved_circle(&mut self, circle: Option<(f32, f32, f32)>) {
         self.curved_circle = circle;
     }
 }
 
 impl cce_ui::widget::Layout for PassivePlate {}
 
 impl cce_ui::widget::Paint for PassivePlate {
     /// Nothing: the plate's fill AND border are drawn by `append_widget_plate` (or, in
     /// circular mode, the circle+arc branch) in the designer's hand-ordered paint walk.
     /// The default `paint` would emit a plain square-cornered quad of the whole rect,
     /// which the walk then re-drew through `extra_quads` ON TOP of the rounded plate —
     /// square corners over the rounded ones.
     fn paint(&self, _rect: cce_ui::scene::layout::Rect, _ctx: &mut cce_ui::scene::paint::PaintCtx) {}
 
     fn color(&self) -> [f32; 4] {
         // `param_plate_fill` folds in the plate opacity and the blur marker.
         cce_ui::colors::param_plate_fill()
     }
 
     fn corner_style(&self, _rect: cce_ui::scene::layout::Rect) -> Option<(f32, (bool, bool, bool, bool))> {
         let r = cce_ui::layout::plate_corner_radius();
         let on = r > 0.0;
         Some((r, (on, on, on, on)))
     }
 
     fn solid_border(&self) -> Option<([f32; 4], f32)> {
         if let Some(bc) = cce_ui::colors::plate_border_color() {
             Some((bc, cce_ui::colors::plate_border_thickness()))
         } else {
             None
         }
     }
 }
 
 impl cce_ui::widget::Input for PassivePlate {
     fn hit(&self, rect: cce_ui::scene::layout::Rect, x: f32, y: f32) -> bool {
         if let Some((cx, cy, r)) = self.curved_circle {
             let dx = x - cx;
             let dy = y - cy;
             return dx * dx + dy * dy <= r * r;
         }
         // Exclusive right/bottom edges, like the legacy Plate hit test.
         x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height
     }
 }
 
 
 /// App-owned copy of the dissolved cce-ui `Canvas` (Phase 6ay part 2): the transparent
 /// hit-through pane behind the network area. Verbatim; dies with the machinery retype.
 pub struct Canvas;
 
 impl Canvas {
     pub fn new() -> cce_ui::widget::Adapted<Canvas> { cce_ui::widget::Adapted::new(Canvas) }
 }
 
 impl cce_ui::widget::Layout for Canvas {}
 
 impl cce_ui::widget::Paint for Canvas {
     fn color(&self) -> [f32; 4] { [0.0, 0.0, 0.0, 0.0] }
 }
 
 impl cce_ui::widget::Input for Canvas {
     // Hit-through: the pane never claims the pointer (the graph decides its own hits).
     fn hit(&self, _rect: cce_ui::scene::layout::Rect, _x: f32, _y: f32) -> bool { false }
 }