blockworx_tools/

select_tool.rs

use std::ops::ControlFlow;

use blockworx_doc::id::BlockId;
use blockworx_geom::{Pos2, Vec2};

use crate::render::{LabelPass, RouteRenderMode, render_route};
use crate::theme::Style;
use crate::{
    EditRoute, EditTextBox, MoveBlock, MoveBlockType, MoveLabel, MovePin, MoveTitle, MultiSelect,
    RenameBlockType, RenamePin, RenameRoute, RenameTitle, RetypePin,
    names::ToolName,
    rename_pin::Field,
    resize_block::ResizeBlock,
    select_pin::SelectPin,
    shape::ShapeId,
    tool::{Action, Tool, ToolTrait, Transition},
    widget::{
        drawing::Drawing,
        hit_target::{HitTarget, PinPart},
    },
};
use blockworx_paint::{Canvas, Cursor, Event, Interaction, Renderer};
pub struct SelectTool;

impl ToolTrait for SelectTool {
    fn name(&self) -> ToolName {
        ToolName::Select
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Transition> {
        crate::widget::display::widget(data, interaction, painter);
        // Hovering a pin grows a route-start target; pressing/dragging it hands off
        // to the route tool. Owns the interaction when the cursor is on a target.
        if let ControlFlow::Break(action) = crate::route_start::widget(data, interaction, painter) {
            return action;
        }
        painter.set_cursor(Cursor::Default);
        match interaction.event {
            Some(Event::HoverAt(pos)) => {
                let _span = tracing::info_span!("hit_test_hover").entered();
                // Anything a click or double-click acts on in place gets the
                // pointing finger, without changing tools.
                match data.resolve_at_pos(pos, painter) {
                    Some(
                        HitTarget::Title(_)
                        | HitTarget::BlockType(_)
                        | HitTarget::Pin { .. }
                        | HitTarget::RouteLabel { .. },
                    ) => painter.set_cursor(Cursor::PointingHand),
                    Some(HitTarget::Route(rid)) => {
                        let hops = data.hops_of(rid);
                        if let Some((wire, course)) =
                            data.auto_route(rid).zip(data.course(rid, &hops))
                        {
                            painter.set_cursor(Cursor::PointingHand);
                            render_route(
                                painter,
                                &wire,
                                course,
                                RouteRenderMode::Highlighted,
                                LabelPass::Draw,
                            );
                        }
                    }
                    Some(HitTarget::Port(_) | HitTarget::Shape(_)) | None => {}
                }
            }
            Some(Event::DoubleClicked { pos }) => {
                if let Some(tool) = editor_at_pos(data, pos, painter) {
                    return Some(Transition::SwitchTool(tool));
                }
                // A double-click on an editor target that simply isn't editable
                // right now (e.g. a locked block's type) is consumed, not a zoom —
                // only a double-click on truly empty canvas fits the view.
                if editor_target_at_pos(data, pos, painter) {
                    return None;
                }
                return Some(Action::ResetView.into());
            }
            Some(Event::DragStarted { pos }) => {
                return Some(drag_to_move(data, pos, painter, IconGrab::NotArmed));
            }
            Some(Event::Clicked { pos }) => {
                let _span = tracing::info_span!("hit_test_click").entered();
                // A click selects whatever is under it (route / pin / shape), or
                // nothing for empty canvas or a route label (the label is left for
                // the upcoming DoubleClicked rename).
                return click_to_select(data, pos, painter);
            }
            _ => {}
        }

        None
    }
}

/// The text editor a double-click at `pos` should open, if it landed on an
/// editable label: a title, block tag, pin name/type/tag, route label, or a text
/// box. Shared by every selecting tool so a double-click always opens the right
/// editor regardless of what is currently selected — including committing one
/// in-place edit and handing straight off to another thing double-clicked.
pub(crate) fn editor_at_pos(
    data: &Drawing,
    pos: Pos2,
    painter: &Style<'_, impl Renderer>,
) -> Option<Tool> {
    if data.authoring().is_withheld() {
        return None;
    }
    match data.resolve_at_pos(pos, painter)? {
        HitTarget::Title(shape) => RenameTitle::new_with_shape(data, shape).map(Into::into),
        HitTarget::BlockType(rect) => RenameBlockType::new_with_rect(data, rect).map(Into::into),
        HitTarget::Pin { anchor, part, .. } => match part {
            PinPart::Name => RenamePin::new_with_anchor(data, anchor, Field::Name).map(Into::into),
            PinPart::Type => RetypePin::new_with_anchor(data, anchor).map(Into::into),
            PinPart::Tag => RenamePin::new_with_anchor(data, anchor, Field::Tag).map(Into::into),
            PinPart::Stub => None,
        },
        HitTarget::RouteLabel { route, label } => {
            RenameRoute::new_with_route_and_label(data, route, label, painter).map(Into::into)
        }
        HitTarget::Shape(ShapeId::Text(tid)) => EditTextBox::new_for(data, tid).map(Into::into),
        HitTarget::Port(_) | HitTarget::Route(_) | HitTarget::Shape(_) => None,
    }
}

/// Whether `pos` lands on any in-place-editor target — an editable label or a
/// text box — *regardless* of whether that target is currently editable. Used to
/// tell an uneditable target (e.g. a locked block's type) from empty canvas so a
/// double-click on it is consumed rather than treated as a fit-to-view.
fn editor_target_at_pos<C: Canvas>(data: &Drawing, pos: Pos2, painter: &Style<'_, C>) -> bool {
    matches!(
        data.resolve_at_pos(pos, painter),
        Some(
            HitTarget::Title(_)
                | HitTarget::BlockType(_)
                | HitTarget::Pin {
                    part: PinPart::Name | PinPart::Type | PinPart::Tag,
                    ..
                }
                | HitTarget::RouteLabel { .. }
                | HitTarget::Shape(ShapeId::Text(_))
        )
    )
}

/// Resolve a left-click at `pos` to the tool that selects whatever is under it: a
/// route, a child-block pin, or a shape (block / port / area / image / text).
/// Returns `None` when nothing selectable is there — empty canvas, or a route
/// label (left for the double-click rename). Shared by every selecting tool so a
/// click always lands on the clicked object, even when something else is already
/// selected.
pub(crate) fn click_to_select(
    data: &Drawing,
    pos: Pos2,
    painter: &Style<'_, impl Renderer>,
) -> Option<Transition> {
    // Selecting a child block (or a port) surfaces its block-style selection.
    let select_shape = |shape| {
        Some(Transition::SwitchTool(
            ResizeBlock::Selected { shape }.into(),
        ))
    };
    match data.resolve_at_pos(pos, painter)? {
        HitTarget::Title(shape) | HitTarget::Shape(shape) => select_shape(shape),
        HitTarget::BlockType(rect) => select_shape(ShapeId::Rect(rect)),
        HitTarget::Port(port) => select_shape(ShapeId::Port(port)),
        // Clicking anywhere on a child-block pin selects just that pin; a port's
        // own labels keep the port's block-style selection.
        HitTarget::Pin { anchor, .. } => match data.pin_shape(anchor) {
            Some(port @ ShapeId::Port(_)) => select_shape(port),
            _ => Some(Transition::SwitchTool(
                SelectPin::Selected { anchor }.into(),
            )),
        },
        // The label is left for the upcoming DoubleClicked rename.
        HitTarget::RouteLabel { .. } => None,
        HitTarget::Route(id) => Some(Transition::SwitchTool(
            EditRoute::Selected { id, anchor: pos }.into(),
        )),
    }
}

/// Whether a block's icon is the thing currently selected — the one state in
/// which a drag on it takes the icon rather than the block under it.
///
/// An icon is large, centred, and sits on the very face you press to move a
/// block, while moving it is rare and moving the block constant: a drag on an
/// unarmed icon is almost always a drag meant for the block. Clicking an icon
/// arms it — that is what raises its resize handles — so the gesture that asks
/// for the icon is the one already in the app.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(crate) enum IconGrab {
    /// Nothing is selected, or something that is not an icon is.
    NotArmed,
    Armed(BlockId),
}

/// Resolve a drag started at `pos` to the tool that moves/edits whatever is under
/// it: a title, block tag, port, child-block pin, route label, route edge, or a
/// shape body — falling back to a marquee on empty canvas. Always returns an
/// action. Shared by every selecting tool so a drag begins on the grabbed object
/// immediately, even when something else is already selected.
pub(crate) fn drag_to_move<C: Canvas>(
    data: &mut Drawing,
    pos: Pos2,
    painter: &Style<'_, C>,
    icon: IconGrab,
) -> Transition {
    // Every drag-to-edit in the app resolves here, so a read-only session
    // refuses them all in one place — and keeps the marquee, which selects.
    if data.authoring().is_withheld() {
        return Transition::SwitchTool(
            MultiSelect::Marquee {
                start: pos,
                current: pos,
                base: Vec::new(),
            }
            .into(),
        );
    }
    // Dragging a body moves it immediately; MoveBlock selects it on drag stop.
    let move_shape = |shape| {
        MoveBlock::Dragging {
            shape,
            delta_pos: Vec2::ZERO,
        }
        .into()
    };
    let tool: Tool = match data.resolve_at_pos(pos, painter) {
        Some(HitTarget::Title(shape)) => MoveTitle::Dragging {
            shape,
            delta_pos: Vec2::ZERO,
        }
        .into(),
        Some(HitTarget::BlockType(rect)) => MoveBlockType {
            rect,
            delta_pos: Vec2::ZERO,
        }
        .into(),
        Some(HitTarget::Port(port)) => move_shape(ShapeId::Port(port)),
        Some(HitTarget::Pin {
            anchor, location, ..
        }) => match data.pin_shape(anchor) {
            // A port's own labels stand for the port: dragging them moves it,
            // since a port's pin has no edge to slide along.
            Some(port @ ShapeId::Port(_)) => move_shape(port),
            _ => MovePin::Dragging {
                anchor,
                location,
                delta_pos: Vec2::ZERO,
            }
            .into(),
        },
        Some(HitTarget::RouteLabel { route, label }) => {
            match MoveLabel::drag_from(data, route, label) {
                Some(dragging) => dragging.into(),
                None => EditRoute::Selected {
                    id: route,
                    anchor: pos,
                }
                .into(),
            }
        }
        Some(HitTarget::Route(id)) => {
            // Dragging a route edge edits it straight away, skipping the
            // click-to-select step; if the grab isn't on a draggable part it falls
            // back to selecting the route.
            EditRoute::drag_from(data, id, pos)
                .unwrap_or(EditRoute::Selected { id, anchor: pos })
                .into()
        }
        // An icon nobody armed hands the drag to the block it sits on: the
        // press was meant for the block nine times in ten, and the icon is
        // still one click away from taking it.
        Some(HitTarget::Shape(ShapeId::Icon(rid))) if icon != IconGrab::Armed(rid) => {
            move_shape(ShapeId::Rect(rid))
        }
        Some(HitTarget::Shape(shape)) => move_shape(shape),
        // Empty canvas: begin a marquee multi-selection.
        None => MultiSelect::Marquee {
            start: pos,
            current: pos,
            base: Vec::new(),
        }
        .into(),
    };
    Transition::SwitchTool(tool)
}

/// Toggle `shape` into the shape selection `base` (shift-click): add it if absent,
/// remove it if present. Resolves to the right tool for the resulting size —
/// nothing → select tool, one → block-style single selection, many → multi-select.
pub fn extend_with_shape(base: &[ShapeId], shape: ShapeId) -> Tool {
    let mut shapes: Vec<ShapeId> = base.to_vec();
    if let Some(i) = shapes.iter().position(|&s| s == shape) {
        shapes.remove(i);
    } else {
        shapes.push(shape);
    }
    match shapes.as_slice() {
        [] => SelectTool.into(),
        [only] => ResizeBlock::Selected { shape: *only }.into(),
        _ => MultiSelect::Selected { shapes }.into(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::path::Scope;
    use crate::{
        grid::GRID_SIZE,
        shape::pin::PinSide,
        theme::Theme,
        widget::test_fixtures::{self as fx, Scene},
    };
    use blockworx_doc::fixtures::block_id;
    use blockworx_geom::{Rect, pos2};
    use blockworx_text::measure::{Measured, Scripted};

    /// A world-space rect given in whole grid cells.
    fn cells(min: (f32, f32), max: (f32, f32)) -> Rect {
        Rect::from_min_max(
            pos2(min.0 * GRID_SIZE, min.1 * GRID_SIZE),
            pos2(max.0 * GRID_SIZE, max.1 * GRID_SIZE),
        )
    }

    /// An icon covers the face you press to move its block, and moving the
    /// icon is rare. So a drag on one hands the block the gesture — unless
    /// the icon is itself the selection, which is the state its resize
    /// handles are already raised in.
    #[test]
    fn an_icon_takes_a_drag_only_while_it_is_the_selection() {
        let inside = cells((10.0, 10.0), (18.0, 16.0));
        let scene = || {
            Scene::new(vec![
                fx::block_in(4, Scope::Root, cells((6.0, 6.0), (22.0, 20.0))),
                fx::titled(4, "core"),
                fx::icon(4, inside),
            ])
        };
        let on_the_icon = inside.center();
        let icon = ShapeId::Icon(block_id(4));

        let hit = crate::headless::Canvas::new(scene())
            .probe(|drawing, style| drawing.resolve_at_pos(on_the_icon, style));
        assert!(
            matches!(hit, Some(HitTarget::Shape(ShapeId::Icon(_)))),
            "precondition: the point hits the icon, so the gate is the only thing \
             that decides what the drag takes: {hit:?}",
        );

        let dragged = |armed: IconGrab| {
            crate::headless::Canvas::new(scene()).probe_mut(|drawing, style| {
                match drag_to_move(drawing, on_the_icon, style, armed) {
                    Transition::SwitchTool(Tool::MoveBlock(MoveBlock::Dragging {
                        shape, ..
                    })) => Some(shape),
                    _ => None,
                }
            })
        };

        assert_eq!(
            dragged(IconGrab::NotArmed),
            Some(ShapeId::Rect(block_id(4))),
            "an unarmed icon must hand the drag to the block it sits on",
        );
        assert_eq!(
            dragged(IconGrab::Armed(block_id(4))),
            Some(icon),
            "the icon is the selection, so the drag is the one that was asked for",
        );
        assert_eq!(
            dragged(IconGrab::Armed(block_id(1))),
            Some(ShapeId::Rect(block_id(4))),
            "another block's icon being armed is not this one being armed",
        );
    }

    /// Every point where a double-click opens an in-place editor must open it
    /// *over that point*: the editor tools are armed through the real
    /// `editor_at_pos` path and run for one frame, and the `EditText` they
    /// publish has to cover the clicked spot. This is the net for the
    /// port-rename class of bug — an editor placed by different math than the
    /// label that was hit — swept across every label kind in one scene:
    /// block titles and types (including a clamped stale-offset title), pin
    /// names/types/tags on both sides, boundary ports, an area, and a text
    /// box.
    #[test]
    fn every_editor_opens_over_the_label_it_was_summoned_from() {
        // Block 1 is the level being drawn, so its own pins are the boundary
        // ports; the note's measured extent stays unset, as after a load.
        let mut scene = Scene::new(vec![
            fx::block_in(1, Scope::Root, cells((0.0, 0.0), (34.0, 30.0))),
            fx::pin_at(
                2,
                Scope::Block(block_id(1)),
                "po",
                fx::slot(PinSide::East, 2),
                cells((2.0, 2.0), (7.0, 4.0)),
            ),
            fx::pin_at(
                3,
                Scope::Block(block_id(1)),
                "pi",
                fx::slot(PinSide::West, 1),
                cells((2.0, 5.0), (7.0, 7.0)),
            ),
            // A roomy child block with labelled pins on both sides.
            fx::block_in(
                4,
                Scope::Block(block_id(1)),
                cells((8.0, 8.0), (22.0, 20.0)),
            ),
            fx::titled(4, "core"),
            fx::typed(4, "Widget"),
            fx::pin_at(
                5,
                Scope::Block(block_id(4)),
                "out",
                fx::slot(PinSide::East, 1),
                Rect::ZERO,
            ),
            fx::pin_typed(5, "u8"),
            fx::pin_tagged(5, "t1"),
            fx::pin_tag_shown(5),
            fx::pin_at(
                6,
                Scope::Block(block_id(4)),
                "in",
                fx::slot(PinSide::West, 2),
                Rect::ZERO,
            ),
            fx::pin_typed(6, "u8"),
            fx::pin_tagged(6, "t2"),
            fx::pin_tag_shown(6),
            // The clamp case: a narrow block whose wide title carries a stale
            // offset, drawn (and hit) clamped back over the block.
            fx::block_in(
                7,
                Scope::Block(block_id(1)),
                cells((26.0, 8.0), (30.0, 14.0)),
            ),
            fx::titled(7, "a rather long title"),
            fx::title_offset(7, 400.0),
            fx::area(
                8,
                Scope::Block(block_id(1)),
                cells((2.0, 24.0), (14.0, 28.0)),
            ),
            fx::text(
                9,
                Scope::Block(block_id(1)),
                "note",
                pos2(24.0 * GRID_SIZE, 24.0 * GRID_SIZE),
            ),
        ])
        .inside(block_id(1));

        let idle = Interaction {
            event: None,
            press: None,
            text: None,
            escape_pressed: false,
            delete_pressed: false,
            shift: false,
        };
        let theme = Theme::default();
        let measured = Measured::new(
            blockworx_paint::FontChoice::default(),
            theme.palette().clone(),
        );
        let mut canvas = measured.canvas(Scripted::default());
        let mut editors = 0;
        let mut drawing = scene.drawing();
        // Half-cell sweep over the scene.
        for i in 0..=68 {
            for j in 0..=60 {
                let pos = pos2(i as f32 * GRID_SIZE * 0.5, j as f32 * GRID_SIZE * 0.5);
                let armed = {
                    let style = Style::new(&theme, &mut canvas);
                    editor_at_pos(&drawing, pos, &style)
                };
                let Some(mut tool) = armed else { continue };
                {
                    let mut style = Style::new(&theme, &mut canvas);
                    let _ = crate::tool::frame(&mut tool, &mut drawing, &idle, &mut style);
                }
                let edit = canvas
                    .take_edit_text()
                    .unwrap_or_else(|| panic!("editor armed at {pos:?} published no EditText"));
                assert!(
                    edit.position.expand(GRID_SIZE).contains(pos),
                    "editor at {:?} opened away from the {:?} that summoned it",
                    edit.position,
                    pos
                );
                editors += 1;
            }
        }
        // The sweep must actually have exercised the label variety above.
        assert!(editors > 60, "only {editors} editor points found");
    }
}