//! The plate menu: what can be done to a pane's PLATE — collapse and
 //! detach — as rows of that pane's right-click menu.
 //!
 //! Until 2026-10-01 these rows were a menu of their own, opened by a small
 //! circular trigger on the top-right of every plate (and that trigger, dragged,
 //! moved the pane to another dock). The trigger is gone: where the plate's
 //! pane has a context menu of its own (the network editor's, the
 //! playbar's) the rows are a PAGE of it, its **Plate** row turning the menu
 //! into them (since 2026-10-06; they were appended inline until then), and
 //! they make up the whole menu where it has none (the params pane off a
 //! row, the spreadsheet, and a collapsed or detached plate's stub). Moving
 //! a pane to another dock was a row too (`Move To …`) until the docks went,
 //! 2026-10-07.
 //!
 //! [`State::plate_menu_rows`] is the one list; [`State::open_plate_menu_at`]
 //! shows it alone and [`State::open_plate_page`] as another menu's page,
 //! dispatching a pick through [`State::run_plate_menu_action`].
 
 use crate::app::State;
 use crate::slots::{
     NETWORK_PANEL_IDX, PARAM_IDX, PLAYBAR_IDX, SPREADSHEET_IDX, WIDGET_COUNT,
 };
 use cce_ui::widget::plate_dock::{self, PlateDockAction, PlateDockState};
 
 /// The plates that carry a plate menu. The viewport is deliberately absent:
 /// its "plate" is the window-spanning lip, not a pane.
 pub const PLATE_SLOTS: [usize; 4] = [NETWORK_PANEL_IDX, PARAM_IDX, SPREADSHEET_IDX, PLAYBAR_IDX];
 
 /// What the plate menu can do to its plate.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PlateMenuAction {
     /// Shrink the plate to its title stub (or restore it).
     Collapse,
     Expand,
     /// Move the pane out into its own window.
     Detach,
     /// Take a detached pane back, closing the window that held it.
     Reattach,
     /// A "-" row: engraved, inert — keeps the action list aligned with the
     /// option rows so a click on the line dispatches nothing.
     Separator,
 }
 
 /// The pane's display name — the stub's label, and what the menu is "about".
 pub fn plate_title(idx: usize) -> &'static str {
     match idx {
         NETWORK_PANEL_IDX => "Network",
         PARAM_IDX => "Parameters",
         SPREADSHEET_IDX => "Spreadsheet",
         PLAYBAR_IDX => "Playbar",
         _ => "Pane",
     }
 }
 
 
 impl State {
     /// The plate whose rect holds (px, py), topmost first — the plate a
     /// right press there is about.
     pub fn plate_at(&self, px: f32, py: f32) -> Option<usize> {
         PLATE_SLOTS.iter().rev().copied().find(|&idx| {
             let w = self.slots.get_dyn(&self.ui_context, idx);
             if !w.visible() {
                 return false;
             }
             // The network spans the window and has no plate: it is not the
             // plate under anything.
             if idx == NETWORK_PANEL_IDX && !self.pane_is_stubbed(idx) {
                 return false;
             }
             // The params HUD is under every plate and, without its own,
             // only its rows: it is the plate there only where it claims.
             if idx == PARAM_IDX && !self.pane_is_stubbed(idx) {
                 return self.params_claims(px, py);
             }
             let (x, y, ww, h) = w.rect();
             ww > 0.0 && h > 0.0 && px >= x && px < x + ww && py >= y && py < y + h
         })
     }
 
     /// The rows of `idx`'s plate menu, labels and actions in step. Contextual:
     /// a collapsed plate offers Expand instead of Collapse, Detach appears only
     /// where a detached window exists for that pane, and a detached pane's
     /// stub offers Reattach alone.
     pub fn plate_menu_rows(&self, idx: usize) -> (Vec<String>, Vec<PlateMenuAction>) {
         // The standard rows come from the toolkit protocol (Reattach-only for
         // a detached pane's stub, Collapse/Expand, Detach when allowed); the
         // designer appends its app rows after.
         let state = PlateDockState {
             collapsed: self.collapsed_panes[idx],
             detached: self.pane_is_detached(idx),
         };
         let mut options: Vec<String> = Vec::new();
         let mut actions: Vec<PlateMenuAction> = Vec::new();
         for (label, action) in plate_dock::standard_menu(state, self.plate_can_detach(idx)) {
             // Neither the HUD nor the network collapses: neither is a plate
             // with a stub to shrink to, and hiding one is its Show … Pane.
             if (idx == PARAM_IDX || idx == NETWORK_PANEL_IDX)
                 && matches!(action, PlateDockAction::Collapse | PlateDockAction::Expand)
             {
                 continue;
             }
             options.push(label);
             actions.push(match action {
                 PlateDockAction::Collapse => PlateMenuAction::Collapse,
                 PlateDockAction::Expand => PlateMenuAction::Expand,
                 PlateDockAction::Detach => PlateMenuAction::Detach,
                 PlateDockAction::Reattach => PlateMenuAction::Reattach,
             });
         }
         // The window actions are the whole menu: the spreadsheet's Full
         // Width / Between Panes rows and every docked plate's Move To rows
         // went with the docks, 2026-10-07.
         (options, actions)
     }
 
     /// Show `idx`'s plate menu alone, at the pointer — a pane with no
     /// context menu of its own, or a stub.
     pub fn open_plate_menu(&mut self, idx: usize) {
         self.open_plate_menu_at(idx, None);
     }
 
     /// Show `idx`'s plate menu alone: at the pointer, or with its top-left
     /// at `at` in place of a page it is turned back to from.
     pub fn open_plate_menu_at(&mut self, idx: usize, at: Option<(f32, f32)>) {
         let (options, actions) = self.plate_menu_rows(idx);
         if options.is_empty() {
             return;
         }
         let target = self.slots.get_dyn(&self.ui_context, idx).base().id();
         self.put_up_menu(at, None, options, 0, target);
         self.plate_menu_slot = Some(idx);
         self.plate_menu_actions = actions;
         self.plate_page_from = None;
     }
 
     /// `idx`'s plate rows as a PAGE of another menu — the playbar's Plate
     /// row turned into them — at `at`, under a back band to `from`.
     pub fn open_plate_page(&mut self, idx: usize, at: (f32, f32), from: crate::menu_page::MenuOrigin) {
         let (options, actions) = self.plate_menu_rows(idx);
         if options.is_empty() {
             return;
         }
         let target = self.slots.get_dyn(&self.ui_context, idx).base().id();
         self.put_up_menu(Some(at), Some(from), options, 0, target);
         self.plate_menu_slot = Some(idx);
         self.plate_menu_actions = actions;
         self.plate_page_from = Some(from);
     }
 
     pub fn plate_menu_open(&self) -> bool {
         cce_ui::widget::context_menu::is_visible() && self.plate_menu_slot.is_some()
     }
 
     pub fn close_plate_menu(&mut self) {
         cce_ui::widget::context_menu::hide();
         self.plate_menu_slot = None;
         self.plate_menu_actions.clear();
         self.plate_page_from = None;
     }
 
     /// Route a left press while the plate menu is open — same contract as
     /// `handle_node_menu_click`.
     pub fn handle_plate_menu_click(&mut self) -> bool {
         if !self.plate_menu_open() {
             return false;
         }
         if cce_ui::widget::context_menu::hit_test(self.cursor_x, self.cursor_y) {
             let row = cce_ui::widget::context_menu::row_at(self.cursor_x, self.cursor_y);
             let picked = self.plate_menu_slot.zip(row.and_then(|r| self.plate_menu_actions.get(r).copied()));
             self.close_plate_menu();
             if let Some((idx, action)) = picked {
                 self.run_plate_menu_action(idx, action);
             }
             return true;
         }
         self.close_plate_menu();
         false
     }
 
     /// Run a plate row for `idx`.
     pub fn run_plate_menu_action(&mut self, idx: usize, action: PlateMenuAction) {
         match action {
             PlateMenuAction::Collapse => self.set_pane_collapsed(idx, true),
             PlateMenuAction::Expand => self.set_pane_collapsed(idx, false),
             PlateMenuAction::Detach => self.detach_plate(idx),
             PlateMenuAction::Reattach => self.reattach_plate(idx),
             PlateMenuAction::Separator => {}
         }
     }
 
     pub fn set_pane_collapsed(&mut self, idx: usize, collapsed: bool) {
         // The params HUD and the network never collapse (see
         // `plate_menu_rows`).
         let collapsed = collapsed && idx != PARAM_IDX && idx != NETWORK_PANEL_IDX;
         if !PLATE_SLOTS.contains(&idx) || self.collapsed_panes[idx] == collapsed {
             return;
         }
         self.collapsed_panes[idx] = collapsed;
         self.rebuild_positions();
         self.apply_layout();
     }
 }
 
 impl State {
     /// Whether `idx` has somewhere to detach TO. Today only the network pane
     /// has a detached-window mode (`--detached-network`); the others gain one
     /// as that path is generalized, and until then they simply do not offer
     /// the item rather than offering one that does nothing.
     pub fn plate_can_detach(&self, idx: usize) -> bool {
         // A detached window never offers to detach its own pane again, and a
         // pane already handed out cannot be handed out twice.
         if self.is_detached_network || self.detached_pane.is_some() {
             return false;
         }
         match idx {
             NETWORK_PANEL_IDX => !self.detached_circular_network,
             other => pane_detach_flag(other).is_some() && !self.detached_panes[other],
         }
     }
 
     fn detach_plate(&mut self, idx: usize) {
         if idx == NETWORK_PANEL_IDX {
             self.execute_action(crate::shortcut::Action::DetachCircularWindow);
             return;
         }
         let Some(flag) = pane_detach_flag(idx) else { return };
 
         // The detached window reads the pane out of the shared project file and
         // then syncs through it, exactly as the network window does — so it has
         // to be on disk BEFORE the child starts.
         let shared = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("default_project.json");
         if let Err(e) = self.save_to_file(&shared) {
             eprintln!("Failed to save shared project before detaching: {e:?}");
             return;
         }
 
         match std::env::current_exe() {
             Ok(exe) => match std::process::Command::new(exe).arg(flag).spawn() {
                 Ok(child) => {
                     self.detached_children.insert(idx, child);
                     self.detached_panes[idx] = true;
                     self.rebuild_positions();
                     self.apply_layout();
                 }
                 // Leave the pane in place if the child never started, rather
                 // than hiding it into a window that does not exist.
                 Err(e) => eprintln!("Failed to spawn detached {}: {e:?}", plate_title(idx)),
             },
             Err(e) => eprintln!("Cannot locate own executable to detach: {e:?}"),
         }
     }
 }
 
 /// Height of a collapsed plate: its title stub (toolkit-owned since 7c).
 pub use cce_ui::widget::plate_dock::STUB_H;
 
 impl State {
     /// Rewrite the collapsed plates' rects down to their stubs.
     ///
     /// A post-pass over `positions[..]` rather than a branch in each layout
     /// arm: `rebuild_positions` lays panes out three different ways (floating,
     /// circular network, detached window) and collapse means the same thing in
     /// all of them — keep the plate's origin and width, take its height down to
     /// the stub. In the floating layout, which is what the main window uses,
     /// that reclaims the space outright: the panes float over a full-bleed
     /// viewport, so nothing has to reflow around them.
     ///
     /// The panes whose body is a SEPARATE slot (the network plate owns the
     /// graph and the breadcrumb) also hide those, since a stub has no room for
     /// them and they would otherwise keep painting over the viewport.
     pub(crate) fn apply_collapsed_panes(&mut self) {
         for idx in PLATE_SLOTS {
             if !self.collapsed_panes[idx] {
                 continue;
             }
             self.stub_slot(idx);
         }
     }
 
     /// Whether `idx` is currently drawn as a stub — the render pass asks before
     /// painting a pane's body, and the title text only appears here.
     pub fn pane_is_collapsed(&self, idx: usize) -> bool {
         PLATE_SLOTS.contains(&idx) && self.collapsed_panes[idx]
     }
 }
 
 /// The CLI flag that runs this pane as its own window, e.g. `--detached-params`.
 /// The network keeps `--detached-network`, handled separately: its detached
 /// window is circular, not merely detached.
 pub fn pane_detach_flag(idx: usize) -> Option<&'static str> {
     match idx {
         PARAM_IDX => Some("--detached-params"),
         SPREADSHEET_IDX => Some("--detached-spreadsheet"),
         PLAYBAR_IDX => Some("--detached-playbar"),
         _ => None,
     }
 }
 
 /// The stable external name of a plate pane — the identity used by the MCP
 /// pane tools and by pane state persisted in project files.
 pub fn pane_name_from_slot(idx: usize) -> Option<&'static str> {
     match idx {
         NETWORK_PANEL_IDX => Some("network"),
         PARAM_IDX => Some("parameters"),
         SPREADSHEET_IDX => Some("spreadsheet"),
         PLAYBAR_IDX => Some("playbar"),
         _ => None,
     }
 }
 
 /// The inverse of [`pane_name_from_slot`], accepting the "params" shorthand.
 pub fn pane_slot_from_name(name: &str) -> Option<usize> {
     match name.to_ascii_lowercase().as_str() {
         "network" => Some(NETWORK_PANEL_IDX),
         "parameters" | "params" => Some(PARAM_IDX),
         "spreadsheet" => Some(SPREADSHEET_IDX),
         "playbar" => Some(PLAYBAR_IDX),
         _ => None,
     }
 }
 
 /// The pane an argv entry asks for, if any — the inverse of [`pane_detach_flag`].
 pub fn pane_from_detach_flag(arg: &str) -> Option<usize> {
     PLATE_SLOTS
         .iter()
         .copied()
         .find(|&idx| pane_detach_flag(idx) == Some(arg))
 }
 
 /// The detached window's `app_id`, which the compositor keys window rules off.
 pub fn pane_app_id(idx: usize) -> &'static str {
     match idx {
         PARAM_IDX => "cce-designer-params",
         SPREADSHEET_IDX => "cce-designer-spreadsheet",
         PLAYBAR_IDX => "cce-designer-playbar",
         _ => "cce-designer",
     }
 }
 
 /// Inset of a detached pane inside its own window, so the plate keeps a visible
 /// edge of its own instead of fusing with the window border.
 pub const DETACHED_MARGIN: f32 = 8.0;
 
 impl State {
     /// Resolve the detached-window arrangement, both sides of it.
     ///
     /// A post-pass for the same reason `apply_collapsed_panes` is one: detaching
     /// means one thing regardless of which of the three layout branches just
     /// ran. In the CHILD process the detached pane claims the whole window and
     /// every other slot goes dark; in the PARENT the panes it has handed out
     /// stop being laid out, so the space they held is released.
     pub(crate) fn apply_detached_panes(&mut self) {
         if let Some(idx) = self.detached_pane {
             for i in 0..WIDGET_COUNT {
                 if i == idx {
                     continue;
                 }
                 self.positions[i] = (0.0, 0.0, 0.0, 0.0);
                 self.slots.get_dyn_mut(&mut self.ui_context, i).set_visible(false);
             }
             let m = DETACHED_MARGIN;
             self.positions[idx] = (
                 m,
                 m,
                 (self.width - 2.0 * m).max(0.0),
                 (self.height - 2.0 * m).max(0.0),
             );
             self.slots.get_dyn_mut(&mut self.ui_context, idx).set_visible(true);
             return;
         }
 
         // The parent keeps a STUB for each pane it handed out rather than
         // dropping it: the stub carries the corner control, which is the only
         // way back. Hiding the pane outright left no way to reattach it.
         for idx in PLATE_SLOTS {
             if self.detached_panes[idx] {
                 self.stub_slot(idx);
             }
         }
     }
 
     /// Shrink one slot to its title stub, taking any separate body slots with it.
     /// Shared by collapse and by the parent side of a detach.
     fn stub_slot(&mut self, idx: usize) {
         let (x, y, w, h) = self.positions[idx];
         if w <= 0.0 || h <= 0.0 {
             // Already laid out as hidden — there is no stub to make.
             return;
         }
         self.positions[idx] = (x, y, w, STUB_H.min(h));
         if idx == NETWORK_PANEL_IDX {
             for child in [crate::slots::CONTENT_IDX, crate::slots::BREADCRUMB_IDX] {
                 self.positions[child] = (0.0, 0.0, 0.0, 0.0);
                 self.slots.get_dyn_mut(&mut self.ui_context, child).set_visible(false);
             }
         }
     }
 }
 
 impl State {
     /// Is this pane currently living in a detached window? The network's flag
     /// is separate because its detached window is the circular one.
     pub fn pane_is_detached(&self, idx: usize) -> bool {
         if idx == NETWORK_PANEL_IDX {
             return self.detached_circular_network;
         }
         PLATE_SLOTS.contains(&idx) && self.detached_panes[idx]
     }
 
     /// Is this pane drawn as a stub rather than in full — collapsed, or left
     /// behind by a detach?
     pub fn pane_is_stubbed(&self, idx: usize) -> bool {
         self.pane_is_detached(idx) || self.pane_is_collapsed(idx)
     }
 
     /// The label a stubbed pane shows, or `None` when the pane is drawn in full.
     /// Collapsed and detached both stub, and they must not look alike: one is
     /// one click from expanding, the other is somewhere else entirely.
     pub fn pane_stub_label(&self, idx: usize) -> Option<String> {
         if self.pane_is_detached(idx) {
             Some(format!("{} — detached", plate_title(idx)))
         } else if self.pane_is_collapsed(idx) {
             Some(plate_title(idx).to_string())
         } else {
             None
         }
     }
 
     /// Detach or reattach a pane — the corner menu's two window actions, also
     /// the MCP surface's, so pane placement is scriptable like collapse is.
     pub fn set_pane_detached(&mut self, idx: usize, detached: bool) {
         if detached {
             if self.plate_can_detach(idx) {
                 self.detach_plate(idx);
             }
         } else {
             self.reattach_plate(idx);
         }
     }
 
     /// Take a detached pane back and close the window that held it.
     pub fn reattach_plate(&mut self, idx: usize) {
         if !self.pane_is_detached(idx) {
             return;
         }
         self.close_detached_child(idx);
 
         if idx == NETWORK_PANEL_IDX {
             // Toggling the action back off is the network's own reattach — it
             // clears the flag and re-lays out without spawning anything.
             self.execute_action(crate::shortcut::Action::DetachCircularWindow);
             return;
         }
 
         self.detached_panes[idx] = false;
         self.rebuild_positions();
         self.apply_layout();
     }
 
     /// Close the detached child and reap it. Best-effort: a child the user
     /// already closed is simply gone, and reattaching must work anyway.
     fn close_detached_child(&mut self, idx: usize) {
         if let Some(mut child) = self.detached_children.remove(&idx) {
             let _ = child.kill();
             // Reap it, or the process table keeps a zombie for the rest of the
             // session — the same trap the liveness probe fell into.
             let _ = child.wait();
         }
     }
 
     /// Notice detached children the user closed themselves and take their panes
     /// back, so a closed window does not strand its pane as a dead stub. Called
     /// from the frame tick.
     ///
     /// `try_wait`, NOT `kill(pid, 0)`: the child is ours and unreaped, so once
     /// it exits it is a zombie — still present in the process table, so the
     /// signal probe reports it alive forever and the pane is never reclaimed.
     pub(crate) fn poll_detached_children(&mut self) -> bool {
         let mut reclaimed = false;
         for idx in PLATE_SLOTS {
             if !self.pane_is_detached(idx) {
                 continue;
             }
             let exited = match self.detached_children.get_mut(&idx) {
                 // `Ok(None)` is the only "still running" answer; an Err handle
                 // is no more useful than an exited one.
                 Some(child) => !matches!(child.try_wait(), Ok(None)),
                 None => continue,
             };
             if !exited {
                 continue;
             }
             self.detached_children.remove(&idx);
             if idx == NETWORK_PANEL_IDX {
                 self.detached_circular_network = false;
                 let val = false;
                 self.menu_mut(crate::slots::LEFT_MENUBAR_IDX).set_item_checked(2, 3, val);
                 self.menu_mut(crate::slots::HEADER_IDX).set_item_checked(2, 3, val);
             } else {
                 self.detached_panes[idx] = false;
             }
             reclaimed = true;
         }
         if reclaimed {
             self.rebuild_positions();
             self.apply_layout();
         }
         reclaimed
     }
 }