blockworx/tools/

select_tool.rs

use std::ops::ControlFlow;

use blockworx_geom::{Pos2, Vec2};

use crate::render::{LabelPass, RouteRenderMode, render_route};
use crate::theme::Style;
use crate::{
    shape::ShapeId,
    tools::{
        EditRoute, EditTextBox, MoveBlock, MoveBlockType, MoveLabel, MovePin, MoveTitle,
        MultiSelect, RenameBlockType, RenamePin, RenameRoute, RenameTitle, RetypePin,
        names::ToolName,
        rename_pin::Field,
        resize_block::ResizeBlock,
        select_pin::SelectPin,
        tool::{Action, Tool, ToolTrait},
    },
    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<Action> {
        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::tools::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)) => {
                        if let Some((wire, geometry)) =
                            data.auto_route(rid).zip(data.route_geometry(rid))
                        {
                            painter.set_cursor(Cursor::PointingHand);
                            render_route(
                                painter,
                                &wire,
                                geometry,
                                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(Action::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);
            }
            Some(Event::DragStarted { pos }) => {
                return Some(drag_to_move(data, pos, painter));
            }
            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<Action> {
    // Selecting a child block (or a port) surfaces its block-style selection.
    let select_shape = |shape| Some(Action::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(Action::SwitchTool(SelectPin::Selected { anchor }.into())),
        },
        // The label is left for the upcoming DoubleClicked rename.
        HitTarget::RouteLabel { .. } => None,
        HitTarget::Route(id) => Some(Action::SwitchTool(
            EditRoute::Selected { id, anchor: pos }.into(),
        )),
    }
}

/// 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>,
) -> Action {
    // 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 Action::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()
        }
        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(),
    };
    Action::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(crate) 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::canvas::Painter;
    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};

    /// 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),
        )
    }

    /// 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,
            lost_focus: false,
            enter_pressed: false,
            tab_pressed: false,
            escape_pressed: false,
            delete_pressed: false,
            shift: false,
        };
        let ctx = egui::Context::default();
        ctx.set_fonts(crate::canvas::build_fonts(
            blockworx_paint::FontChoice::default(),
        ));
        ctx.run_ui(egui::RawInput::default(), |_| {})
            .drop_without_applying_deltas();
        let mut editors = 0;
        ctx.run_ui(egui::RawInput::default(), |ui| {
            let theme = Theme::default();
            let mut painter = Painter::headless(ui.painter().clone(), theme.palette().clone());
            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 painter);
                        editor_at_pos(&drawing, pos, &style)
                    };
                    let Some(mut tool) = armed else { continue };
                    {
                        let mut style = Style::new(&theme, &mut painter);
                        let _ =
                            crate::tools::tool::frame(&mut tool, &mut drawing, &idle, &mut style);
                    }
                    let edit = painter
                        .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;
                }
            }
        })
        .drop_without_applying_deltas();
        // The sweep must actually have exercised the label variety above.
        assert!(editors > 60, "only {editors} editor points found");
    }
}