blockworx_tools/

move_pin.rs

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

use crate::{
    edit::geometry::PinMove,
    grid::{PIN_PITCH, max_pin_slot},
    names::ToolName,
    shape::{PinLocation, ShapeId, pin::PinSide},
    state::RenderMode,
    tool::{PreviewPhase, ToolTrait, Transition, select_tool_for_anchor},
    widget::{DrawingPasses, drawing::Drawing},
};
use blockworx_doc::{geometry::PinSlot, id::PinId};

/// The slot the pin would snap to if released now. One definition, so the
/// preview, the guides, and the drop cannot disagree about where the drag
/// promised to land — `None` when no slot is free.
fn drop_candidate(data: &Drawing, anchor: PinId, side: PinSide, offset: f32) -> Option<u32> {
    data.pin_shape(anchor)
        .and_then(|id| data.shape(id))
        .and_then(|s| s.pin_drop_candidate(anchor, side, offset))
}

pub enum MovePin {
    Idle,
    Dragging {
        anchor: PinId,
        location: PinLocation,
        delta_pos: Vec2,
    },
}

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

    fn preview<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        _painter: &mut Style<'_, C>,
        phase: &PreviewPhase,
    ) {
        let MovePin::Dragging {
            anchor,
            location,
            delta_pos,
        } = self
        else {
            return;
        };
        // The release advances the drag like any other frame: it paints before
        // it commits, so the side it drops on has to be the side it draws.
        let pointer = match interaction.event {
            Some(Event::Dragging { pos, delta }) => {
                *delta_pos += delta;
                Some(pos)
            }
            Some(Event::DragStopped { pos }) => Some(pos),
            _ => None,
        };
        if let Some(pos) = pointer {
            let Some(rect) = data
                .pin_on_shape(*anchor)
                .map(|(shape, _)| shape.gui_rect())
            else {
                return;
            };
            // Saturate the dragged offset to the block's bounds so the pin
            // stays inside its containing rect: the lowest slot that keeps
            // two grid cells of bottom clearance is `max_pin_slot` (see its
            // docs), in offset pixels `max_pin_slot * PIN_PITCH`.
            let max_offset = max_pin_slot(rect.height()) as f32 * PIN_PITCH;
            delta_pos.y = delta_pos
                .y
                .clamp(-location.offset, max_offset - location.offset);
            location.side = if pos.x < rect.center().x {
                PinSide::West
            } else {
                PinSide::East
            };
        }
        // Re-route the connected routes live so they track the candidate.
        // Only a stub slides along an edge; a port body stays put, so its
        // routes are left on their committed geometry.
        let candidate = drop_candidate(data, *anchor, location.side, location.offset + delta_pos.y);
        if let (Some(offset), Some(ShapeId::Rect(_))) = (candidate, data.pin_shape(*anchor)) {
            data.preview_pin_drag(phase, *anchor, location.side, offset);
        }
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Transition> {
        match self {
            MovePin::Idle => {
                crate::widget::display::widget(data, interaction, painter);
                if let Some(Event::HoverAt(hover_pos)) = interaction.event {
                    if data.pin_text_at_pos(hover_pos, painter).is_some() {
                        painter.set_cursor(Cursor::PointingHand);
                    }
                } else if let Some(Event::DragStarted { pos }) = interaction.event
                    && let Some((anchor, location)) = data.pin_text_at_pos(pos, painter)
                {
                    *self = MovePin::Dragging {
                        anchor,
                        location,
                        delta_pos: Vec2::ZERO,
                    };
                }
            }
            MovePin::Dragging {
                anchor,
                location,
                delta_pos,
            } => {
                if let Some(Event::DragStopped { .. }) = interaction.event {
                    // The drop resolves its slot through the same candidate
                    // search the preview drew, so the pin lands where the drag
                    // promised (or nowhere, if no slot was free).
                    if let Some(offset) =
                        drop_candidate(data, *anchor, location.side, location.offset + delta_pos.y)
                    {
                        data.move_pin_snapped(
                            *anchor,
                            blockworx_doc::geometry::PinSlot {
                                side: location.side,
                                offset,
                            },
                        );
                    }
                    // Paint the committed state this frame. The tool switches
                    // away next frame, so without rendering here the frame goes
                    // blank and the pin flashes. Drop the stale approach corners
                    // on the moved pin's routes, then re-route first so they land
                    // in their final spot with a clean approach.
                    data.trim_anchor_approach(*anchor);
                    crate::widget::display::widget(data, interaction, painter);
                    // Stay on the moved pin so it remains the standing target for
                    // further edits (block pin → SelectPin, port → ResizeBlock).
                    return Some(Transition::SwitchTool(select_tool_for_anchor(
                        data, *anchor,
                    )));
                }
                let owner = data.pin_shape(*anchor);
                let candidate =
                    drop_candidate(data, *anchor, location.side, location.offset + delta_pos.y);
                let data: &Drawing = data;
                let anchor = *anchor;
                let side = location.side;
                let delta = delta_pos.y;
                let guides = candidate.map(|slot| {
                    crate::widget::alignment::pin_drag_guides(
                        data,
                        &[PinMove {
                            pin: anchor,
                            to: PinSlot { side, offset: slot },
                        }],
                        &[anchor],
                    )
                });
                DrawingPasses::new(data)
                    .shape_mode(move |id| {
                        if Some(id) == owner {
                            RenderMode::PinDragged {
                                pin: anchor,
                                delta,
                                side,
                                candidate,
                            }
                        } else {
                            RenderMode::Normal
                        }
                    })
                    // Draw every route; one touching the dragged pin shows only
                    // when the drop would be valid (then it tracks the candidate
                    // slot), otherwise it stays hidden until a valid slot is
                    // reached.
                    .routes(move |painter| {
                        let drawn: Vec<_> = data
                            .auto_routes()
                            .filter(|(_, wire)| {
                                let touching = wire.route.from == anchor || wire.route.to == anchor;
                                !touching || candidate.is_some()
                            })
                            .collect();
                        let ids: Vec<_> = drawn.iter().map(|&(id, _)| id).collect();
                        let hops = data.hops(&ids);
                        for (id, wire) in drawn {
                            let Some(course) = data.course(id, hops.of(id)) else {
                                continue;
                            };
                            render_route(
                                painter,
                                &wire,
                                course,
                                RouteRenderMode::Normal,
                                LabelPass::Draw,
                            );
                        }
                    })
                    .draw(painter);
                // Guides on top so they stay visible over the diagram.
                if let Some(guides) = &guides {
                    crate::widget::alignment::draw_guides(guides, painter);
                }
            }
        }
        None
    }
}