blockworx/shell/

tool_cluster.rs

//! The tool cluster: the left edge, vertically centred, holding the creators
//! and nothing else — "a tool creates or places something. Everything after
//! that happens by selecting the result and acting on it".
//!
//! Select sits at the top with air under it, then the authoring tools, and a
//! rule stands between the two groups: hairlines are forbidden as
//! *incidental* decoration, and this one is categorical — what selects and
//! what creates are two kinds.
//!
//! Each cell is its icon alone, the mockup's own treatment — the word lives
//! in the tooltip with the digit: *"the icon should describe the function,
//! and the tooltip can carry the words"*. Tapping the armed tool returns to
//! Select, so the cluster is its own way out.
//!
//! Under the lens the whole cluster dims and goes inert — one of three
//! redundant signals, with the viewing pill and the drained canvas.
//!

use blockworx_store::doc::Viewing;

use crate::{
    shell::glass::{self, Live},
    tools::{
        commands::{Act, CommandId, CommandSet},
        names::{BAND_TOOLS, BandTool, ToolName},
    },
};

/// Everything [`tool_cluster`] renders against.
#[derive(Clone, Copy)]
pub struct ToolCluster {
    /// The cell shown armed (see
    /// [`displayed_tool`](crate::tools::names::displayed_tool)).
    pub selected: ToolName,
    /// What the canvas is showing. A past rev has no tool to arm.
    pub viewing: Viewing,
}

/// What one cluster frame reports: what a click fired, where a cell
/// carried off the cluster was dropped, and — for the tests that click the
/// real column — each cell's screen rect.
pub struct ToolClusterFrame {
    pub action: Option<Act>,
    pub drag_out: Option<DragOut>,
    #[cfg(test)]
    pub tool_rects: Vec<(ToolName, egui::Rect)>,
}

/// A cell pressed and dragged off the cluster, released at `at` (screen
/// space). The cluster reports where the drop landed and says nothing about
/// what it means — the canvas transform and the chrome's own boxes are the
/// app's, and a drop on the glass has to come to nothing.
#[derive(Clone, Copy, Debug)]
pub struct DragOut {
    pub tool: ToolName,
    pub at: egui::Pos2,
}

/// Draw the cluster in its berth.
pub fn tool_cluster(
    chrome: &mut super::Chrome,
    commands: &mut CommandSet,
    cluster: ToolCluster,
) -> ToolClusterFrame {
    chrome.piece(glass::Berth::ToolCluster, |ui| {
        column(ui, commands, cluster)
    })
}

/// The cells themselves, top to bottom. Split from [`tool_cluster`] so a
/// caller with its own berth can draw the same column.
fn column(ui: &mut egui::Ui, commands: &mut CommandSet, cluster: ToolCluster) -> ToolClusterFrame {
    let ToolCluster { selected, viewing } = cluster;
    let lens = matches!(viewing, Viewing::Past(_));
    let mut clicked: Option<CommandId> = None;
    let mut drag_out = None;
    let mut rects = Vec::new();
    // Under the lens the cluster dims and goes inert, rather than each cell
    // forming its own opinion about a document that cannot be written.
    ui.add_enabled_ui(!lens, |ui| {
        if lens {
            ui.multiply_opacity(UNDER_THE_LENS);
        }
        ui.vertical(|ui| {
            ui.spacing_mut().item_spacing.y = CELL_GAP;
            for (place, band) in BAND_TOOLS.iter().enumerate() {
                // The mockup's `.toolsep`, between groups: what selects, what
                // builds blocks, and what annotates the sheet. Hairlines are
                // forbidden as *incidental* rules; these are structure.
                if place > 0 && BAND_TOOLS[place - 1].group != band.group {
                    glass::separator(ui, glass::Run::Column);
                }
                // The registry's own answer, so a cell and the command it
                // fires cannot disagree: a locked block withholds Add Port,
                // and a read-only session withholds every authoring tool.
                let id = crate::tools::commands::band_command(band.tool);
                let armed = Armed::of(selected, band.tool);
                let response = cell(ui, band, armed, Live::from(commands.contains(id)))
                    .on_hover_text(hover(ui.ctx(), band.tool, id))
                    .on_disabled_hover_text(hover(ui.ctx(), band.tool, id));
                rects.push((band.tool, response.rect));
                // The cell's second gesture: carried off the cluster and
                // dropped on the canvas, which stamps rather than arms
                // (`crate::tools::stamp`). egui tells the two apart by how
                // far the pointer travelled, so a cell answers both.
                if response.dragged() {
                    carried(ui.ctx(), band.tool);
                }
                if response.drag_stopped()
                    && let Some(at) = response.interact_pointer_pos()
                {
                    drag_out = Some(DragOut {
                        tool: band.tool,
                        at,
                    });
                }
                if response.clicked() {
                    // Tapping the armed tool puts it down. Select armed is
                    // already down, so it stays where it is.
                    clicked = Some(match armed {
                        Armed::Yes => CommandId::Arm(ToolName::Select),
                        Armed::No => id,
                    });
                }
            }
        });
    });
    ToolClusterFrame {
        action: clicked.and_then(|id| commands.take(id)),
        drag_out,
        #[cfg(test)]
        tool_rects: rects,
    }
}

/// The drag-out's preview: the cell's own icon riding under the pointer, so
/// the gesture reads as carrying the tool onto the canvas rather than as a
/// press that missed. Ghosted, in its own layer over everything, and
/// uninteractable — it must not become the thing the drop lands on.
fn carried(ctx: &egui::Context, tool: ToolName) {
    let Some(at) = ctx.pointer_latest_pos() else {
        return;
    };
    egui::Area::new(egui::Id::new("tool_carried"))
        .order(egui::Order::Tooltip)
        .fixed_pos(at - egui::Vec2::splat(glass::TOOL_ICON / 2.0))
        .interactable(false)
        .movable(false)
        .constrain(false)
        .fade_in(false)
        .show(ctx, |ui| {
            ui.multiply_opacity(CARRIED);
            let icon = glass::image(ui, tool_icon(tool), glass::TOOL_ICON);
            ui.add(icon);
        });
}

/// How much of itself the carried icon keeps: enough to follow, not enough
/// to be mistaken for something already placed.
const CARRIED: f32 = 0.6;

/// How much of itself the cluster keeps while a past rev is on the canvas —
/// the mockup's `opacity:.35`, dim enough to read as unavailable at a glance.
const UNDER_THE_LENS: f32 = 0.35;

/// The air between cells — the mockup's `.tools{gap:2px}`. What sets Select
/// apart is the rule above the creators, not a wider gap.
const CELL_GAP: f32 = 2.0;

/// Whether this cell's tool is the one the canvas is holding.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Armed {
    Yes,
    No,
}

impl Armed {
    fn of(selected: ToolName, tool: ToolName) -> Self {
        if selected == tool {
            Armed::Yes
        } else {
            Armed::No
        }
    }
}

/// One cell: the icon alone, centred; the tooltip carries the words.
fn cell(ui: &mut egui::Ui, band: &BandTool, armed: Armed, live: Live) -> egui::Response {
    ui.add_enabled_ui(live == Live::Yes, |ui| {
        let (rect, response) = ui.allocate_exact_size(glass::TOOL, egui::Sense::click_and_drag());
        if !ui.is_rect_visible(rect) {
            return response;
        }
        let visuals = ui
            .style()
            .interact_selectable(&response, armed == Armed::Yes);
        let held = glass::Pressed::from(response.is_pointer_button_down_on());
        // The mockup's press: the plate ducks under the finger and springs
        // back past its own size on release, arriving under the armed cell's
        // blue. Only the plate moves — the cell keeps its box, so nothing
        // below it in the column shifts while a press is in flight.
        let scale = glass::press_scale(ui.ctx(), response.id, held);
        // Unframed until pointed at or armed: seven boxed icons down the
        // cluster read as a wall.
        if armed == Armed::Yes || response.hovered() || held == glass::Pressed::Yes {
            let plate = egui::Rect::from_center_size(rect.center(), rect.size() * scale);
            ui.painter().rect(
                plate.expand(visuals.expansion),
                f32::from(glass::TOOL_RADIUS) * scale,
                visuals.weak_bg_fill,
                visuals.bg_stroke,
                egui::StrokeKind::Inside,
            );
        }
        glass::image(ui, tool_icon(band.tool), glass::TOOL_ICON).paint_at(
            ui,
            egui::Rect::from_center_size(rect.center(), egui::Vec2::splat(glass::TOOL_ICON)),
        );
        response
    })
    .inner
}

/// The tool's name, with every chord bound to it — its own digit beside the
/// chord the editor already had. The cell prints one word; the tooltip prints
/// the whole name.
fn hover(ctx: &egui::Context, tool: ToolName, id: CommandId) -> String {
    let chords: Vec<String> = crate::tools::commands::chords(id)
        .map(|chord| crate::keys::spelled(ctx, *chord))
        .collect();
    if chords.is_empty() {
        tool.to_string()
    } else {
        format!("{tool} ({})", chords.join(", "))
    }
}

/// The cluster icon for a base tool. Only [`BAND_TOOLS`] reach this; any other
/// `ToolName` falls back to the select cursor.
fn tool_icon(tool: ToolName) -> egui::ImageSource<'static> {
    match tool {
        ToolName::NewBlock => NEW_BLOCK_ICON,
        ToolName::NewArea => AREA_ICON,
        ToolName::AddPin => ADD_PIN_ICON,
        ToolName::AddPort => ADD_PORT_ICON,
        ToolName::NewImage => IMAGE_ICON,
        ToolName::AddText => ADD_TEXT_ICON,
        ToolName::Route => ROUTE_ICON,
        _ => SELECT_ICON,
    }
}

const IMAGE_ICON: egui::ImageSource<'static> = egui::include_image!("../../icons/icon-image.svg");
const SELECT_ICON: egui::ImageSource<'static> = egui::include_image!("../../icons/icon-select.svg");
const NEW_BLOCK_ICON: egui::ImageSource<'static> =
    egui::include_image!("../../icons/icon-new-block.svg");
const AREA_ICON: egui::ImageSource<'static> = egui::include_image!("../../icons/icon-area.svg");
const ADD_PIN_ICON: egui::ImageSource<'static> =
    egui::include_image!("../../icons/icon-add-pin.svg");
const ADD_PORT_ICON: egui::ImageSource<'static> =
    egui::include_image!("../../icons/icon-add-port.svg");
const ADD_TEXT_ICON: egui::ImageSource<'static> =
    egui::include_image!("../../icons/icon-add-text.svg");
const ROUTE_ICON: egui::ImageSource<'static> = egui::include_image!("../../icons/icon-route.svg");

#[cfg(test)]
mod tests {
    use super::*;
    use crate::canvas::convert::{IntoEgui as _, IntoGeom as _};
    use crate::edit::naming::InterfaceLock;
    use crate::panels::painted::Chrome;
    use crate::shell::tests::screen;
    use crate::tools::commands::{CommandContext, History, band_command};
    use crate::tools::tool::Action;
    use crate::widget::test_fixtures::Scene;
    use blockworx_geom::Pos2;
    use blockworx_store::doc::Writability;

    /// Every tool the cluster draws binds to its own digit, and the
    /// digits run 1..n in the order the cluster lays them out.
    #[test]
    fn every_tool_binds_to_its_place_in_the_column() {
        use blockworx_paint::{Key, Modifiers};
        const DIGITS: [Key; 8] = [
            Key::Num1,
            Key::Num2,
            Key::Num3,
            Key::Num4,
            Key::Num5,
            Key::Num6,
            Key::Num7,
            Key::Num8,
        ];
        assert!(
            BAND_TOOLS.len() <= DIGITS.len(),
            "the cluster outgrew §5's digit row",
        );
        for (place, band) in BAND_TOOLS.iter().enumerate() {
            let tool = band.tool;
            let digits: Vec<Key> = crate::tools::commands::chords(band_command(tool))
                .filter(|chord| chord.modifiers == Modifiers::None)
                .map(|chord| chord.key)
                .collect();
            assert_eq!(
                digits,
                vec![DIGITS[place]],
                "{tool:?} sits {} in the cluster but binds {digits:?}",
                place + 1,
            );
        }
    }

    /// The session the cluster is a view of.
    struct Session {
        writability: Writability,
        viewing: Viewing,
        selected: ToolName,
        scene: Scene,
        rects: Vec<(ToolName, egui::Rect)>,
        fired: Vec<Act>,
        dropped: Vec<DragOut>,
    }

    impl Session {
        fn new(writability: Writability) -> Self {
            Session {
                writability,
                viewing: Viewing::Head,
                selected: ToolName::Select,
                scene: Scene::new(Vec::new()),
                rects: Vec::new(),
                fired: Vec::new(),
                dropped: Vec::new(),
            }
        }

        fn frame(&mut self, ui: &mut egui::Ui) {
            let armed: crate::tools::tool::Tool = crate::tools::SelectTool.into();
            let mut commands = {
                let drawing = self.scene.drawing();
                CommandSet::available(&CommandContext {
                    tool: &armed,
                    data: &drawing,
                    history: History::empty(),
                    current_lock: InterfaceLock::Unlocked,
                    writability: self.writability,
                    saving: blockworx_store::doc::Saving::Withheld,
                    viewing: self.viewing,
                })
            };
            let mut chrome = crate::shell::Chrome::over(ui.ctx(), ui.max_rect());
            let frame = tool_cluster(
                &mut chrome,
                &mut commands,
                ToolCluster {
                    selected: self.selected,
                    viewing: self.viewing,
                },
            );
            self.rects = frame.tool_rects;
            if let Some(act) = frame.action {
                self.fired.push(act);
            }
            if let Some(carried) = frame.drag_out {
                self.dropped.push(carried);
            }
        }
    }

    /// Click the cluster's `tool` cell and report which tool that armed, laid
    /// out and hit-tested for real. `None` is a cell that dispatched nothing.
    fn click_the_tool(session: &mut Session, tool: ToolName) -> Option<ToolName> {
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let at = session
            .rects
            .iter()
            .find_map(|&(name, rect)| (name == tool).then_some(rect))
            .expect("every tool reports its rect, live or dead");
        assert!(at.is_positive(), "the {tool:?} cell never laid out");
        let before = session.fired.len();
        chrome.click_at(at.center().geom(), |ui| session.frame(ui));
        match session.fired.get(before) {
            None => None,
            Some(Act::Edit(Action::Arm(armed))) => Some(*armed),
            Some(other) => panic!(
                "the {tool:?} cell dispatched {}",
                crate::tools::commands::act_name(other),
            ),
        }
    }

    /// The cells run down the left edge, not across: a horizontal cluster
    /// would be the band this replaced.
    #[test]
    fn the_cells_are_stacked_in_a_column() {
        let mut session = Session::new(Writability::Writable);
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let rects = &session.rects;
        assert_eq!(rects.len(), BAND_TOOLS.len(), "a tool never laid out");
        for pair in rects.windows(2) {
            let (above, below) = (pair[0].1, pair[1].1);
            assert!(
                below.top() > above.top(),
                "{:?} is beside {:?}, not under it",
                pair[1].0,
                pair[0].0,
            );
            assert_eq!(
                below.left(),
                above.left(),
                "the column is not aligned at {:?}",
                pair[1].0,
            );
        }
        assert_eq!(
            rects[0].0,
            ToolName::Select,
            "Select is not at the top of the cluster (§5)",
        );
    }

    /// The groups are set apart by the mockup's own rule: Select from the
    /// block tools, the block tools from the sheet tools. A rule is a thing
    /// drawn, so the test asks the geometry: the run at every boundary is
    /// wider than the run between two tools of one group, and what fills the
    /// one under Select is painted rather than empty.
    #[test]
    fn a_rule_stands_between_the_groups() {
        let mut session = Session::new(Writability::Writable);
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let group_of = |tool: ToolName| {
            BAND_TOOLS
                .iter()
                .find(|band| band.tool == tool)
                .map(|band| band.group)
        };
        let gaps: Vec<(bool, f32)> = session
            .rects
            .windows(2)
            .map(|pair| {
                let boundary = group_of(pair[0].0) != group_of(pair[1].0);
                (boundary, pair[1].1.top() - pair[0].1.bottom())
            })
            .collect();
        let (boundaries, within): (Vec<_>, Vec<_>) = gaps.iter().partition(|(at, _)| *at);
        assert_eq!(
            boundaries.len(),
            2,
            "precondition: three groups on the band: {gaps:?}",
        );
        let narrowest = boundaries
            .iter()
            .map(|(_, gap)| *gap)
            .fold(f32::INFINITY, f32::min);
        assert!(
            within.iter().all(|(_, gap)| narrowest > *gap),
            "a group boundary carries no rule: {gaps:?}",
        );
        let under_select = &gaps[0].1;
        let column = crate::shell::berth_rect(chrome.ctx(), glass::Berth::ToolCluster)
            .expect("the cluster never laid out");
        let select = session.rects[0].1;
        assert!(
            *under_select >= 1.0 + 2.0 * glass::separator_air(),
            "the run under Select is too narrow to hold a rule and its air: \
             {under_select}",
        );
        assert!(
            column.width() > 0.0,
            "precondition: the cluster laid out around {select:?}",
        );
    }

    /// Item 2, the other half: *"The dividing line under the select tool is
    /// not centered."* It is inset from both shoulders (the mockup's
    /// `.toolsep{margin:5px 12px}`), and an inset taken off one side only is
    /// a rule that hangs left of the column it divides.
    #[test]
    fn the_rule_under_select_is_centred_on_the_column_it_divides() {
        let mut session = Session::new(Writability::Writable);
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let select = session.rects[0].1;
        let next = session.rects[1].1;
        assert!(
            next.top() > select.bottom(),
            "precondition: there is a run between Select and the creators",
        );
        let rule = chrome
            .fills()
            .iter()
            .find(|(drawn, _)| {
                drawn.height() <= 2.0
                    && drawn.top() >= select.bottom()
                    && drawn.bottom() <= next.top()
            })
            .map(|(drawn, _)| *drawn)
            .expect("nothing is painted in the run under Select");
        assert!(
            (rule.center().x - select.center().x).abs() < 0.5,
            "the rule is off centre: {rule:?} under a cell centred at {}",
            select.center().x,
        );
        assert!(
            rule.width() < select.width(),
            "the rule runs shoulder to shoulder: {rule:?}",
        );
    }

    /// A cell is its icon alone — the cluster paints no text of any
    /// kind, and the words live in the tooltips (proved for the hover text
    /// below).
    #[test]
    fn the_cluster_paints_no_words() {
        let mut session = Session::new(Writability::Writable);
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let column = crate::shell::berth_rect(chrome.ctx(), glass::Berth::ToolCluster)
            .expect("the cluster never laid out");
        for text in chrome.texts() {
            for rect in chrome.rects(text) {
                assert!(
                    !column.intersects(rect.egui()),
                    "the cluster painted {text:?}; the tooltip carries the words (R24)",
                );
            }
        }
        for (tool, cell) in &session.rects {
            assert_eq!(cell.size(), glass::TOOL, "{tool:?} is not cell-sized");
        }
    }

    /// The digit is shown where the user looks for it, beside the chord the
    /// tool already had.
    #[test]
    fn a_tools_hover_names_both_its_digit_and_its_chord() {
        let ctx = egui::Context::default();
        // `format_shortcut` reads the font set, which a context only has once
        // it has run a frame.
        let mut out = ctx.clone().run_ui(egui::RawInput::default(), |_| {});
        out.textures_delta.clear();
        let said = hover(&ctx, ToolName::NewBlock, CommandId::Arm(ToolName::NewBlock));
        assert!(said.contains("New Block"), "{said}");
        assert!(said.contains('2'), "the digit is missing: {said}");
        assert!(said.contains('B'), "the existing chord is gone: {said}");
    }

    /// Tapping the armed tool puts it down, so the cluster is its own way
    /// back to Select without reaching for Escape.
    #[test]
    fn tapping_the_armed_tool_returns_to_select() {
        let mut session = Session::new(Writability::Writable);
        session.selected = ToolName::NewBlock;
        assert_eq!(
            click_the_tool(&mut session, ToolName::NewBlock),
            Some(ToolName::Select),
            "tapping the armed tool re-armed it instead of putting it down",
        );
    }

    /// Drag a cell off the cluster and release it at `to`, reporting the
    /// drop the cluster made of it.
    fn drag_the_tool_out(session: &mut Session, tool: ToolName, to: egui::Pos2) -> Option<DragOut> {
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let at = session
            .rects
            .iter()
            .find_map(|&(name, rect)| (name == tool).then_some(rect))
            .expect("every tool reports its rect, live or dead");
        let before = session.dropped.len();
        chrome.drag_between(at.center().geom(), to.geom(), |ui| session.frame(ui));
        session.dropped.get(before).copied()
    }

    /// A cell answers two gestures, and the drag is the one that does
    /// not arm. The cluster reports where the drop landed and nothing else
    /// — what it means is the app's to say.
    #[test]
    fn carrying_a_cell_off_the_cluster_reports_the_drop_and_arms_nothing() {
        let mut session = Session::new(Writability::Writable);
        let onto = egui::pos2(600.0, 350.0);
        let dropped = drag_the_tool_out(&mut session, ToolName::NewBlock, onto)
            .expect("the cluster reported no drop");
        assert_eq!(dropped.tool, ToolName::NewBlock);
        assert_eq!(dropped.at, onto, "the drop point is where the release was");
        assert!(
            session.fired.is_empty(),
            "the drag-out also armed something: {} actions",
            session.fired.len(),
        );
    }

    /// The registry gates the drag the way it gates the click: a cell drawn
    /// dead cannot be carried out either.
    #[test]
    fn a_dead_cell_cannot_be_carried_out() {
        let onto = egui::pos2(600.0, 350.0);
        assert!(
            drag_the_tool_out(
                &mut Session::new(Writability::Writable),
                ToolName::NewBlock,
                onto,
            )
            .is_some(),
            // Without this the refusal below could be a mis-aimed drag.
            "a writable cluster reported no drop",
        );
        assert!(
            drag_the_tool_out(
                &mut Session::new(Writability::ReadOnly),
                ToolName::NewBlock,
                onto,
            )
            .is_none(),
            "a read-only cluster let New Block be carried out",
        );
    }

    /// The add-pin tool has a cell of its own, and the cell arms it.
    #[test]
    fn the_cluster_carries_the_add_pin_tool() {
        assert_eq!(
            click_the_tool(&mut Session::new(Writability::Writable), ToolName::AddPin),
            Some(ToolName::AddPin),
        );
    }

    /// A cell that is not armed arms its own tool, which is the other half of
    /// the rule above.
    #[test]
    fn tapping_an_idle_tool_arms_it() {
        let mut session = Session::new(Writability::Writable);
        assert_eq!(
            click_the_tool(&mut session, ToolName::NewBlock),
            Some(ToolName::NewBlock),
            "an idle cell did not arm its own tool",
        );
    }

    /// A read-only session's cluster still shows every tool — it keeps its
    /// shape — but the creators are dead, and the neutral Select is not.
    #[test]
    fn a_read_only_cluster_arms_select_but_no_creator() {
        assert_eq!(
            click_the_tool(&mut Session::new(Writability::Writable), ToolName::NewBlock),
            Some(ToolName::NewBlock),
            // Without this the refusal below could be a mis-aimed click.
            "a writable cluster refused New Block",
        );
        assert!(
            click_the_tool(&mut Session::new(Writability::ReadOnly), ToolName::NewBlock).is_none(),
            "a read-only cluster armed the New Block tool",
        );
        assert_eq!(
            click_the_tool(&mut Session::new(Writability::ReadOnly), ToolName::Select),
            Some(ToolName::Select),
            "a read-only cluster refused Select, which authors nothing",
        );
    }

    /// Under the lens the whole cluster goes inert — Select included,
    /// because there is no selection to make in a document nobody is
    /// editing.
    #[test]
    fn the_lens_makes_the_whole_cluster_inert() {
        let mut session = Session::new(Writability::Writable);
        session.viewing = Viewing::Past(blockworx_doc::fixtures::rev(2));
        for tool in [ToolName::Select, ToolName::NewBlock] {
            assert!(
                click_the_tool(&mut session, tool).is_none(),
                "{tool:?} answered a click under the lens",
            );
        }
    }

    /// The cluster creates and nothing else: a navigation verb here would
    /// be a second home for what the path pill already carries.
    #[test]
    fn the_cluster_carries_no_navigation() {
        let mut session = Session::new(Writability::Writable);
        let mut chrome = Chrome::new(screen().geom());
        chrome.settle(|ui| session.frame(ui));
        let column = crate::shell::berth_rect(chrome.ctx(), glass::Berth::ToolCluster)
            .expect("the cluster never laid out");
        let mut y = column.top();
        while y <= column.bottom() {
            chrome.click_at(Pos2::new(column.center().x, y), |ui| session.frame(ui));
            y += 6.0;
        }
        assert!(
            session
                .fired
                .iter()
                .any(|a| matches!(a, Act::Edit(Action::Arm(_)))),
            "precondition: the scan reaches the cluster's own cells",
        );
        assert!(
            !session.fired.iter().any(|a| matches!(
                a,
                Act::Edit(Action::GoUp | Action::GoToPath(_) | Action::ExpandBlock(_))
            )),
            "a navigation verb is in the tool cluster: {} verbs",
            session.fired.len(),
        );
    }
}