blockworx_tools/

multi_select.rs

use crate::theme::Style;
use blockworx_geom::{Pos2, Rect, Vec2, WorldPx};
use blockworx_paint::{Canvas, Event, Interaction};

use crate::edit::geometry::Moving;
use crate::edit::naming::Authoring;
use crate::{
    MultiPinSelect, SelectTool,
    grid::{GROUP_SELECTION_PAD, snap_offset},
    names::ToolName,
    resize_block::ResizeBlock,
    shape::ShapeId,
    state::RenderMode,
    theme::Role,
    tool::{Action, Deletable, PreviewPhase, ToolTrait, Transition},
    widget::{DrawingPasses, drawing::Drawing},
};
use blockworx_geom::grid::px_rect;

/// Multi-selection of shapes (blocks and/or ports), entered by drawing a marquee
/// while the `Select` tool is active. Only two operations are supported on the
/// group: move it rigidly, or delete it (via the Delete button overlay).
pub enum MultiSelect {
    /// Rubber-band in progress; nothing is committed yet. `base` is the existing
    /// selection a shift-marquee extends — empty for a fresh marquee.
    Marquee {
        start: Pos2,
        current: Pos2,
        base: Vec<ShapeId>,
    },
    /// A committed multi-selection (idle).
    Selected { shapes: Vec<ShapeId> },
    /// The whole group is being dragged rigidly.
    Moving {
        shapes: Vec<ShapeId>,
        delta_pos: Vec2,
    },
}

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

    fn selection(&self) -> Option<Deletable> {
        match self {
            MultiSelect::Selected { shapes } => Some(Deletable::Shapes(shapes.clone())),
            _ => None,
        }
    }

    fn preview<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        _painter: &mut Style<'_, C>,
        phase: &PreviewPhase,
    ) {
        let MultiSelect::Moving { shapes, delta_pos } = self else {
            return;
        };
        if let Some(Event::Dragging { delta, .. }) = interaction.event {
            *delta_pos += delta;
        }
        // Suppose each member at its previewed position. Snap the offset to the
        // grid so it matches the geometry the on-drop commit produces (no
        // release flash), exactly like `MoveBlock`.
        let offset = snap_offset(*delta_pos);
        let drags: Vec<(ShapeId, Vec2)> = shapes.iter().map(|&id| (id, offset)).collect();
        data.preview_drag(phase, &drags);
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Transition> {
        self.render(data, interaction, painter);
        match self {
            MultiSelect::Marquee {
                start,
                current,
                base,
            } => {
                if let Some(Event::Dragging { pos, .. }) = interaction.event {
                    *current = pos;
                } else if let Some(Event::DragStopped { .. }) = interaction.event {
                    // Every shape — including top-layer areas — fully enclosed
                    // by the marquee.
                    let marquee = Rect::from_two_pos(*start, *current);
                    let enclosed: Vec<ShapeId> = data
                        .shape_candidates(marquee)
                        .into_iter()
                        .chain(data.areas())
                        .filter(|(_, s)| marquee.contains_rect(s.gui_rect()))
                        .map(|(id, _)| id)
                        .collect();
                    if enclosed.is_empty() && base.is_empty() {
                        // No whole object enclosed: fall back to a pin-only
                        // selection if the marquee covered any child-block pins.
                        let pins = data.pins_in_rect(marquee);
                        if !pins.is_empty() {
                            return Some(Transition::SwitchTool(
                                MultiPinSelect::Selected { pins }.into(),
                            ));
                        }
                        return Some(Transition::SwitchTool(SelectTool.into()));
                    }
                    // Union the marquee's catch with the shift-extended base.
                    let mut shapes = std::mem::take(base);
                    for id in enclosed {
                        if !shapes.contains(&id) {
                            shapes.push(id);
                        }
                    }
                    if let [shape] = shapes[..] {
                        // Exactly one shape behaves like a single click: hand off to
                        // the single-selection tool so it gets the full overlay.
                        return Some(Transition::SwitchTool(
                            ResizeBlock::Selected { shape }.into(),
                        ));
                    }
                    *self = MultiSelect::Selected { shapes };
                }
            }
            MultiSelect::Selected { shapes } => {
                if interaction.delete_pressed {
                    return Some(Action::Delete(Deletable::Shapes(shapes.clone())).into());
                }
                if let Some(Event::DragStarted { pos }) = interaction.event {
                    if interaction.shift {
                        // Shift-drag extends the group with a new marquee.
                        return Some(Transition::SwitchTool(
                            MultiSelect::Marquee {
                                start: pos,
                                current: pos,
                                base: shapes.clone(),
                            }
                            .into(),
                        ));
                    } else if data.authoring() == Authoring::Offered
                        && data
                            .shape_at_pos(pos)
                            .is_some_and(|hit| shapes.contains(&hit))
                    {
                        // Grabbing a member drags the whole group.
                        let shapes = std::mem::take(shapes);
                        *self = MultiSelect::Moving {
                            shapes,
                            delta_pos: Vec2::ZERO,
                        };
                    } else {
                        // Dragging another object moves it directly; empty canvas
                        // re-marquees (the fallback inside `drag_to_move`).
                        return Some(crate::select_tool::drag_to_move(
                            data,
                            pos,
                            painter,
                            crate::select_tool::IconGrab::NotArmed,
                        ));
                    }
                } else if let Some(Event::Clicked { pos }) = interaction.event {
                    if interaction.shift {
                        // Shift-click toggles a shape in/out of the group; clicking
                        // elsewhere with shift keeps the current selection.
                        if let Some(hit) = data.shape_at_pos(pos) {
                            return Some(Transition::SwitchTool(
                                crate::select_tool::extend_with_shape(shapes, hit),
                            ));
                        }
                        return None;
                    }
                    // Clicking another object selects it directly; empty canvas
                    // clears the group selection.
                    return Some(
                        crate::select_tool::click_to_select(data, pos, painter).unwrap_or_default(),
                    );
                }
            }
            MultiSelect::Moving { .. } => {
                if let Some(Event::DragStopped { .. }) = interaction.event {
                    let MultiSelect::Moving { shapes, delta_pos } = self else {
                        unreachable!()
                    };
                    let shapes = std::mem::take(shapes);
                    data.move_shapes(&shapes, *delta_pos);
                    // Keep the group selected after the move.
                    *self = MultiSelect::Selected { shapes };
                }
            }
        }
        None
    }
}

impl MultiSelect {
    fn render<C: Canvas>(
        &self,
        data: &Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) {
        match self {
            MultiSelect::Marquee {
                start,
                current,
                base,
            } => {
                crate::widget::display::widget(data, interaction, painter);
                // Keep the already-selected shapes framed while a shift-marquee
                // extends them, so the user sees what's being added to.
                if !base.is_empty() {
                    draw_selection_bounds(data, base, Vec2::ZERO, painter);
                }
                let marquee = Rect::from_two_pos(*start, *current);
                painter.rect(
                    marquee,
                    WorldPx::ZERO,
                    Role::MarqueeFill,
                    (1.0, Role::SelectionFrame),
                );
            }
            MultiSelect::Selected { shapes } => {
                crate::widget::display::widget(data, interaction, painter);
                draw_selection_bounds(data, shapes, Vec2::ZERO, painter);
            }
            MultiSelect::Moving { shapes, delta_pos } => {
                // Each moving block's icon travels with it, so preview it moving
                // alongside the group.
                let icons: Vec<ShapeId> = shapes
                    .iter()
                    .filter_map(|s| s.block().map(ShapeId::Icon))
                    .collect();
                let delta = *delta_pos;
                let mut dragged_ids: Vec<ShapeId> = shapes.clone();
                dragged_ids.extend(icons.iter().copied());
                let offset = snap_offset(*delta_pos);
                let guides =
                    crate::widget::alignment::shape_drag_guides(data, &dragged_ids, offset);
                DrawingPasses::new(data)
                    .shape_mode(move |id| {
                        if shapes.contains(&id) || icons.contains(&id) {
                            RenderMode::Moving { delta }
                        } else {
                            RenderMode::Normal
                        }
                    })
                    .draw(painter);
                // Keep the group frame visible, moved with the (grid-snapped) drag.
                draw_selection_bounds(data, shapes, offset, painter);
                // A destination the emitter would refuse says so while the
                // drag is still in the hand — and only the overlaps the move
                // *creates*, the group rule exempting one the selection
                // arrived with.
                for overlap in data.conflicts(shapes, delta, Moving::AsAGroup) {
                    crate::render::draw_refused_conflict(px_rect(overlap), painter);
                }
                // Guides on top so a center guide through the aligned shapes shows.
                crate::widget::alignment::draw_guides(&guides, painter);
            }
        }
    }
}

/// Draw one frame around the union of `shapes` (offset by `offset` for a move
/// preview). No resize handles — those belong only to a single selection.
fn draw_selection_bounds<C: Canvas>(
    data: &Drawing,
    shapes: &[ShapeId],
    offset: Vec2,
    painter: &mut Style<'_, C>,
) {
    let bounds = crate::selection_bounds::shapes_bounds(data, shapes);
    if let Some(bounds) = bounds {
        // Inflate the frame so it sits clear of the shapes' own edges.
        crate::render::draw_box_outline(
            bounds.translate(offset).expand(GROUP_SELECTION_PAD),
            Role::Transparent,
            (1.0, Role::SelectionFrameOutline),
            painter,
        );
    }
}