blockworx_tools/

move_block.rs

use crate::theme::Style;
use blockworx_geom::Vec2;
use blockworx_paint::{Canvas, Cursor, Event, Interaction};

use crate::{
    edit::geometry::Moving,
    grid::snap_offset,
    names::ToolName,
    resize_block::ResizeBlock,
    shape::ShapeId,
    state::RenderMode,
    tool::{PreviewPhase, ToolTrait, Transition},
    widget::{DrawingPasses, drawing::Drawing},
};
use blockworx_geom::grid::px_rect;

pub enum MoveBlock {
    Idle,
    Dragging { shape: ShapeId, delta_pos: Vec2 },
}

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

    fn preview<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        _painter: &mut Style<'_, C>,
        phase: &PreviewPhase,
    ) {
        let MoveBlock::Dragging { shape, delta_pos } = self else {
            return;
        };
        if let Some(Event::Dragging { delta, .. }) = interaction.event {
            *delta_pos += delta;
        }
        // Suppose the block at its previewed position so the frame draws — and
        // routes — against it. Snap the offset to the grid so this matches the
        // geometry the on-drop commit produces (no release flash).
        data.preview_drag(phase, &[(*shape, snap_offset(*delta_pos))]);
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Transition> {
        self.render(data, interaction, painter);
        match self {
            MoveBlock::Idle => {
                if let Some(Event::HoverAt(hover_pos)) = interaction.event
                    && data.shape_at_pos(hover_pos).is_some()
                {
                    painter.set_cursor(Cursor::Move);
                }
                if let Some(Event::DragStarted { pos }) = interaction.event
                    && let Some(shape) = data.shape_at_pos(pos)
                {
                    *self = MoveBlock::Dragging {
                        shape,
                        delta_pos: Vec2::ZERO,
                    };
                }
            }
            MoveBlock::Dragging { .. } => {
                if let Some(Event::DragStopped { .. }) = interaction.event {
                    let MoveBlock::Dragging { shape, delta_pos } = self else {
                        unreachable!()
                    };
                    // Free shapes (images/icons) snap magnetically to alignment,
                    // then an icon is contained to its block — both must match the
                    // preview so there's no release flash.
                    let magnetic = if shape.is_artwork() {
                        crate::widget::alignment::snap_drag_offset(data, &[*shape], *delta_pos)
                    } else {
                        *delta_pos
                    };
                    let commit = data.constrain_move(*shape, magnetic);
                    data.move_shape(*shape, commit);
                    if shape.affects_routing() {
                        // Drop the stale approach corners the drag left on routes
                        // ending at the moved shape; the gesture's solve rider
                        // rebuilds a clean approach in the same commit.
                        data.trim_partial_route_approaches(&[*shape]);
                    }
                    // Keep the just-moved shape selected.
                    return Some(Transition::SwitchTool(
                        ResizeBlock::Selected { shape: *shape }.into(),
                    ));
                }
            }
        }
        None
    }
}

impl MoveBlock {
    fn render<C: Canvas>(
        &self,
        data: &Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) {
        match self {
            MoveBlock::Idle => {
                crate::widget::display::widget(data, interaction, painter);
            }
            MoveBlock::Dragging {
                shape: dragging_id,
                delta_pos,
            } => {
                // The dragged block's icon travels with it, so preview it moving
                // alongside the block (they commit together in `move_block`).
                let icon_id = dragging_id.block().map(ShapeId::Icon);
                let raw = *delta_pos;
                let dragging_id = *dragging_id;
                let mut dragged_ids = vec![dragging_id];
                dragged_ids.extend(icon_id);
                // Free shapes (images/icons) snap magnetically to alignment so the
                // guide lands; blocks/others preview at the raw delta and their
                // guides use the grid-snapped offset (they snap on commit).
                let is_free = dragging_id.is_artwork();
                let magnetic = if is_free {
                    crate::widget::alignment::snap_drag_offset(data, &dragged_ids, raw)
                } else {
                    raw
                };
                // Contain an icon to its block live, so the preview matches the
                // clamped commit instead of leaving the rect and snapping back.
                let delta = data.constrain_move(dragging_id, magnetic);
                let guide_offset = if is_free { delta } else { snap_offset(raw) };
                let guides =
                    crate::widget::alignment::shape_drag_guides(data, &dragged_ids, guide_offset);
                // A block previews at the grid-snapped position (it snaps on
                // commit), so its icon must follow at that same snapped delta —
                // not the raw `delta` — or the icon drifts off the block.
                let icon_delta = snap_offset(raw);
                DrawingPasses::new(data)
                    .shape_mode(move |id| {
                        if id == dragging_id {
                            RenderMode::Moving { delta }
                        } else if Some(id) == icon_id {
                            RenderMode::Moving { delta: icon_delta }
                        } else {
                            RenderMode::Normal
                        }
                    })
                    .draw(painter);
                // A destination the emitter would refuse says so while the
                // drag is still in the hand, rather than undoing itself in
                // silence on release.
                // The cells it would have to share are what is marked — one
                // drag can conflict with several shapes, and an outline
                // round the mover could not say which.
                for overlap in data.conflicts(&[dragging_id], delta, Moving::Alone) {
                    crate::render::draw_refused_conflict(px_rect(overlap), painter);
                }
                // Guides are drawn on top so a center guide (which runs through the
                // opaque shapes it aligns) stays visible.
                crate::widget::alignment::draw_guides(&guides, painter);
            }
        }
    }
}