blockworx/widget/

movement.rs

//! Moving shapes: the per-kind moves, the collision rules that gate them, and
//! the group move that keeps a selection's relative layout — plus the waypoint
//! reconciliation each move owes the routes that touch it.

use ahash::HashSet;
use blockworx_geom::Vec2;

use blockworx_doc::{
    geometry::GridVec,
    id::{BlockId, PinId},
};

use crate::{
    edit::geometry::{self as edit_geometry, RouteEdit, RouteEnd, Shape},
    grid::{GRID_SIZE, artwork_rect, px_rect, snap_to_grid},
    shape::ShapeId,
    widget::drawing::Drawing,
};

impl Drawing<'_> {
    /// The `delta` a move of `shape` will actually apply, so a drag preview can
    /// match the commit. An icon is held inside the block it belongs to; every
    /// other shape moves by `delta` unchanged.
    pub fn constrain_move(&self, shape: ShapeId, delta: Vec2) -> Vec2 {
        match shape {
            ShapeId::Icon(rid) => match (self.icon(rid), self.block(rid)) {
                (Some(icon), Some(block)) => {
                    let box_now = artwork_rect(icon.rect);
                    let contained = crate::shape::block::contain_rect(
                        box_now.translate(delta),
                        px_rect(block.rect),
                    );
                    contained.min - box_now.min
                }
                _ => delta,
            },
            _ => delta,
        }
    }

    /// Move any shape (block, port, text box, area, image, or icon) by
    /// `delta`. Blocks and ports are collision-checked; annotations float
    /// freely, and an icon is held inside the block it belongs to.
    pub fn move_shape(&mut self, id: ShapeId, delta: Vec2) {
        self.author("move_shape", |indexed, sink| {
            edit_geometry::move_shape(indexed, Shape::from(id), delta, sink);
        });
    }

    /// The pins riding a set of moved shapes: a moved block carries its whole
    /// boundary, a moved port is one pin of its own — the classification the
    /// preview reconciles routes against. The commit runs the same rule from
    /// the emitter's side ([`edit_geometry::move_group`]).
    pub(super) fn riding_pins(
        &self,
        moved_blocks: &HashSet<BlockId>,
        moved_ports: &HashSet<PinId>,
    ) -> HashSet<PinId> {
        let mut pins: HashSet<PinId> = moved_ports.clone();
        for &block in moved_blocks {
            pins.extend(
                self.block_pins(crate::path::Scope::Block(block))
                    .into_iter()
                    .map(|(id, _)| id),
            );
        }
        pins
    }

    /// The wires this scope holds that end on `riding`, with the end that
    /// rode — the classification a move's waypoint reconciliation runs on.
    /// `None` for a wire with both ends riding (it keeps its shape) and for
    /// one with neither.
    fn straddling_routes(
        &self,
        riding: &HashSet<PinId>,
    ) -> Vec<(blockworx_doc::id::RouteId, Option<RouteEnd>)> {
        self.scope_route_ids()
            .into_iter()
            .filter_map(|id| {
                let route = self.route(id)?;
                let end = match (riding.contains(&route.from), riding.contains(&route.to)) {
                    (true, false) => Some(RouteEnd::From),
                    (false, true) => Some(RouteEnd::To),
                    (true, true) => None,
                    (false, false) => return None,
                };
                Some((id, end))
            })
            .collect()
    }

    /// Drop the stale approach waypoints on every route of this scope that
    /// straddles a move: exactly one endpoint anchored to a moved shape. The
    /// moved side's leading (or trailing) auto-corners are removed so the
    /// re-route regenerates a clean approach; routes fully inside or fully
    /// outside the move keep their waypoints. Commit-time only: the
    /// single-shape drop calls it directly, a group drag folds the same trim
    /// into [`edit_geometry::move_group`]'s own riders, and the live preview
    /// *computes* the identical set without applying it.
    pub fn trim_partial_route_approaches(&mut self, moved: &[ShapeId]) {
        let (moved_rects, moved_pins, _) = moved_set_and_delta(moved, Vec2::ZERO);
        let riding = self.riding_pins(&moved_rects, &moved_pins);
        self.trim_approaches(&riding);
    }

    /// Trim the approach waypoints of every route ending on `pin` (a single
    /// dragged pin or port), from that endpoint's side.
    pub fn trim_anchor_approach(&mut self, pin: PinId) {
        self.trim_approaches(&HashSet::from_iter([pin]));
    }

    fn trim_approaches(&mut self, riding: &HashSet<PinId>) {
        let straddling = self.straddling_routes(riding);
        for (id, end) in straddling {
            let Some(end) = end else { continue };
            let Some(route) = self.route(id) else {
                continue;
            };
            let trimmed = edit_geometry::trimmed_approach(&route.waypoints, end);
            self.author("trim_partial_route_approaches", |indexed, sink| {
                edit_geometry::commit_route_edit(
                    indexed.doc,
                    RouteEdit {
                        route: id,
                        waypoints: trimmed,
                        anchors: &[],
                    },
                    sink,
                );
            });
        }
    }

    /// Move several shapes rigidly by `delta`. Intra-group collisions are ignored
    /// (the group keeps its relative layout); the move is rejected wholesale if
    /// any moved shape would overlap a shape that is not part of `ids`. Each
    /// route the selection touches is reconciled in the same commit: one fully
    /// inside keeps its shape and shifts its corners rigidly, one that straddles
    /// the set drops its stale approach on the moved side.
    pub fn move_shapes(&mut self, ids: &[ShapeId], delta: Vec2) {
        let members: Vec<Shape> = ids.iter().copied().map(Shape::from).collect();
        self.author("move_shapes", |indexed, sink| {
            edit_geometry::move_group(indexed, &members, delta, sink);
        });
    }
}

/// Shared derivation used by both the group-drag COMMIT (`move_shapes`) and its
/// live PREVIEW ([`Drawing::suppose_drag`]): the moved block/port id
/// sets plus the grid-cell delta. `delta` is the raw (unsnapped) move vector;
/// both paths pass the identical `delta`, so the returned `grid_delta` — and
/// therefore the waypoint offset — is byte-identical between preview and commit
/// (no release snap).
pub(super) fn moved_set_and_delta(
    ids: &[ShapeId],
    delta: Vec2,
) -> (HashSet<BlockId>, HashSet<PinId>, GridVec) {
    let moved_rects: HashSet<BlockId> = ids
        .iter()
        .filter_map(|id| match id {
            ShapeId::Rect(rid) => Some(*rid),
            _ => None,
        })
        .collect();
    let moved_pins: HashSet<PinId> = ids
        .iter()
        .filter_map(|id| match id {
            ShapeId::Port(pid) => Some(*pid),
            _ => None,
        })
        .collect();
    let snapped = snap_to_grid(delta.to_pos2()).to_vec2();
    let grid_delta = GridVec::new(
        (snapped.x / GRID_SIZE).round() as i32,
        (snapped.y / GRID_SIZE).round() as i32,
    );
    (moved_rects, moved_pins, grid_delta)
}

#[cfg(test)]
mod tests {
    use blockworx_doc::{
        fixtures::{block_id, image_id, route_id},
        geometry::GridPoint,
        id::BlockId,
        values::PinSide,
    };
    use blockworx_geom::{Pos2, Rect, pos2, vec2};

    use crate::{
        grid::{GRID_SIZE, artwork_rect},
        path::Scope,
        shape::ShapeId,
        widget::{
            drawing::Drawing,
            test_fixtures::{self as fx, Scene, two_blocks_with_a_routed_waypoint},
        },
    };

    fn corners(drawing: &Drawing<'_>, rid: blockworx_doc::id::RouteId) -> Vec<GridPoint> {
        drawing
            .auto_route(rid)
            .expect("the route is in this scope")
            .route
            .waypoints
            .iter()
            .map(|wp| wp.pos)
            .collect()
    }

    fn icon_min(scene: &mut Scene, id: BlockId) -> Pos2 {
        artwork_rect(
            scene
                .drawing()
                .icon(id)
                .expect("the block carries an icon")
                .rect,
        )
        .min
    }

    fn image_rect(scene: &mut Scene, id: blockworx_doc::id::ImageId) -> Rect {
        artwork_rect(
            scene
                .drawing()
                .image(id)
                .expect("the image is in this scope")
                .rect,
        )
    }

    fn image_min(scene: &mut Scene, id: blockworx_doc::id::ImageId) -> Pos2 {
        image_rect(scene, id).min
    }

    fn block_rect(drawing: &Drawing<'_>, id: BlockId) -> Rect {
        drawing
            .shape(ShapeId::Rect(id))
            .expect("the block is in this scope")
            .gui_rect()
    }

    /// Three tall blocks in a row, each wire crossing a slot so it has to bend:
    /// A→B lives wholly inside the {A, B} selection, B→C straddles it. Both
    /// wires start from the corners the solver itself lays down, so a claim
    /// about what a move does to them is a claim about a settled shape.
    fn settled_row() -> Scene {
        let tall = |n, x: f32| {
            fx::block_in(
                n,
                Scope::Root,
                Rect::from_min_max(pos2(x, 0.0), pos2(x + 40.0, 120.0)),
            )
        };
        let mut scene = Scene::new(vec![
            tall(1, 0.0),
            tall(2, 300.0),
            tall(3, 600.0),
            fx::pin(4, 1, PinSide::East, 0),
            fx::pin(5, 2, PinSide::West, 1),
            fx::pin(6, 2, PinSide::East, 0),
            fx::pin(9, 3, PinSide::West, 1),
            // A throwaway corner apiece: the settling rip-up has something to
            // clear, so the gesture authors an op and its rider promotes the
            // solved corners back onto the wires.
            fx::route(7, Scope::Root, 4, 5, &[(10, 4)]),
            fx::route(8, Scope::Root, 6, 9, &[(30, 4)]),
        ]);
        fx::materialize(&mut scene);
        scene.commit(|drawing| {
            drawing.reroute(route_id(7));
            drawing.reroute(route_id(8));
        });
        scene
    }

    fn shifted(corners: &[GridPoint], dy: i32) -> Vec<GridPoint> {
        corners
            .iter()
            .map(|p| GridPoint {
                x: p.x,
                y: p.y + dy,
            })
            .collect()
    }

    #[test]
    fn move_shapes_moves_fully_selected_route_waypoints() {
        // Moving BOTH endpoints of a route drags its corners rigidly along by
        // the same grid delta, so the wire keeps its shape.
        let mut scene = settled_row();
        let before = corners(&scene.drawing(), route_id(7));
        assert!(!before.is_empty(), "the settled wire has a shape to carry");

        scene.commit(|drawing| {
            drawing.move_shapes(
                &[ShapeId::Rect(block_id(1)), ShapeId::Rect(block_id(2))],
                vec2(0.0, 4.0 * GRID_SIZE),
            );
        });

        assert_eq!(
            corners(&scene.drawing(), route_id(7)),
            shifted(&before, 4),
            "every corner shifted by the (0, 4) grid delta the blocks moved"
        );
    }

    #[test]
    fn move_shapes_group_translates_internal_routes_and_trims_boundary_ones() {
        // One drag of the group {A, B} treats its two wires differently in the
        // same commit: A→B is wholly inside and travels rigidly, while B→C
        // leaves the selection and re-approaches C from B’s new position
        // instead of being dragged into the shape it used to have.
        let (a, b) = (block_id(1), block_id(2));
        let (internal_id, boundary_id) = (route_id(7), route_id(8));
        let mut scene = settled_row();
        let internal_before = corners(&scene.drawing(), internal_id);
        let boundary_before = corners(&scene.drawing(), boundary_id);
        assert!(!internal_before.is_empty() && !boundary_before.is_empty());

        scene.commit(|drawing| {
            drawing.move_shapes(
                &[ShapeId::Rect(a), ShapeId::Rect(b)],
                vec2(0.0, 4.0 * GRID_SIZE),
            );
        });

        let drawing = scene.drawing();
        assert_eq!(
            corners(&drawing, internal_id),
            shifted(&internal_before, 4),
            "the fully-selected route travelled rigidly with its endpoints"
        );
        assert_ne!(
            corners(&drawing, boundary_id),
            shifted(&boundary_before, 4),
            "the straddling route re-approached instead of translating"
        );
    }

    #[test]
    fn move_shapes_trims_a_partially_selected_route_approach() {
        // Moving only ONE endpoint of a route drops the stale approach corners on
        // the moved side: the route straddles the selection boundary, so keeping
        // the old waypoint would pin the wire to the block's former position and
        // route it back through the corner it left behind. Block A is the moved
        // start endpoint and the lone (unlocked) waypoint is its approach corner,
        // so the trim removes it, leaving the route to auto-route clean.
        let mut scene = two_blocks_with_a_routed_waypoint();

        scene.commit(|drawing| {
            drawing.move_shapes(&[ShapeId::Rect(block_id(1))], vec2(GRID_SIZE, 0.0));
        });

        let after = corners(&scene.drawing(), route_id(5));
        assert!(
            after.is_empty(),
            "the stale approach waypoint was trimmed; got {after:?}"
        );
    }

    #[test]
    fn move_shapes_moves_an_image_freely() {
        let sid = image_id(1);
        let mut scene = Scene::new(vec![
            fx::asset().1,
            fx::image(
                1,
                Scope::Root,
                Rect::from_min_max(pos2(0.0, 0.0), pos2(40.0, 40.0)),
            ),
        ]);
        let before = image_min(&mut scene, sid);

        let delta = vec2(GRID_SIZE, 2.0 * GRID_SIZE);
        scene.commit(|drawing| drawing.move_shapes(&[ShapeId::Image(sid)], delta));

        assert_eq!(
            image_min(&mut scene, sid),
            before + delta,
            "the image moves freely (no grid snap)"
        );
    }

    #[test]
    fn a_background_image_does_not_move_with_a_block() {
        // Background images are independent shapes: one sitting inside a block
        // stays put when the block moves (unlike the old "stuck image" behavior).
        let (a, inside) = (block_id(1), image_id(2));
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0), // (0,0)..(40,40)
            fx::asset().1,
            fx::image(
                2,
                Scope::Root,
                Rect::from_min_max(pos2(15.0, 15.0), pos2(25.0, 25.0)),
            ),
        ]);
        let before = image_min(&mut scene, inside);
        let block_before = block_rect(&scene.drawing(), a);

        scene.commit(|drawing| drawing.move_shape(ShapeId::Rect(a), vec2(4.0 * GRID_SIZE, 0.0)));

        // Precondition: the block really moved, so the image standing still is
        // a statement about the image and not about a refused gesture.
        assert_ne!(block_rect(&scene.drawing(), a), block_before);
        assert_eq!(
            image_min(&mut scene, inside),
            before,
            "a background image is not dragged by a moving block"
        );
    }

    #[test]
    fn an_icon_moves_with_its_block() {
        // An icon is a property of its block, so moving the block moves the icon.
        let a = block_id(1);
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0), // (0,0)..(40,40)
            fx::asset().1,
            fx::icon(1, Rect::from_min_max(pos2(8.0, 8.0), pos2(32.0, 32.0))),
        ]);
        let before = icon_min(&mut scene, a);

        scene.commit(|drawing| drawing.move_shape(ShapeId::Rect(a), vec2(4.0 * GRID_SIZE, 0.0)));

        assert_eq!(
            icon_min(&mut scene, a),
            before + vec2(4.0 * GRID_SIZE, 0.0),
            "the icon travels with its block"
        );
    }

    #[test]
    fn move_icon_is_clamped_inside_its_block() {
        let a = block_id(1);
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0), // (0,0)..(40,40)
            fx::asset().1,
            fx::icon(1, Rect::from_min_max(pos2(8.0, 8.0), pos2(32.0, 32.0))),
        ]);
        let before = icon_min(&mut scene, a);
        // Shove the icon far past the block's bottom-right corner.
        scene.commit(|drawing| drawing.move_shape(ShapeId::Icon(a), vec2(1000.0, 1000.0)));

        let drawing = scene.drawing();
        let icon = artwork_rect(drawing.icon(a).unwrap().rect);
        // Precondition: the shove moved the icon at all, so containment is the
        // clamp speaking rather than a move that never happened.
        assert_ne!(icon.min, before);
        assert!(
            block_rect(&drawing, a).contains_rect(icon),
            "the icon stays within its block"
        );
    }

    #[test]
    fn an_icon_co_selected_with_its_block_is_not_moved_twice() {
        // An icon follows its block. If both are in one move (e.g. shift-clicking
        // the icon onto its selected block), `move_shapes` must move the icon
        // once, not once via the block and again on its own.
        let a = block_id(1);
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0), // (0,0)..(40,40)
            fx::asset().1,
            fx::icon(1, Rect::from_min_max(pos2(8.0, 8.0), pos2(32.0, 32.0))),
        ]);
        let before = icon_min(&mut scene, a);

        scene.commit(|drawing| {
            drawing.move_shapes(
                &[ShapeId::Rect(a), ShapeId::Icon(a)],
                vec2(4.0 * GRID_SIZE, 0.0),
            );
        });

        assert_eq!(
            icon_min(&mut scene, a),
            before + vec2(4.0 * GRID_SIZE, 0.0),
            "the icon shifts by one block-move, not two"
        );
    }

    #[test]
    fn an_image_never_blocks_a_block_move() {
        // Images float like text boxes: an image sitting where a block wants to
        // move must not veto the move.
        let a = block_id(1);
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0), // (0,0)..(40,40)
            fx::asset().1,
            // An image covering the block's destination one cell to the right.
            fx::image(
                2,
                Scope::Root,
                Rect::from_min_max(pos2(40.0, 0.0), pos2(80.0, 40.0)),
            ),
        ]);
        let before = block_rect(&scene.drawing(), a);
        // Precondition: the image really does cover where the block is headed.
        assert!(
            image_rect(&mut scene, image_id(2))
                .intersects(before.translate(vec2(2.0 * GRID_SIZE, 0.0)))
        );

        scene.commit(|drawing| drawing.move_shape(ShapeId::Rect(a), vec2(2.0 * GRID_SIZE, 0.0)));

        assert_ne!(
            block_rect(&scene.drawing(), a),
            before,
            "the block moved despite the overlapping image"
        );
    }

    #[test]
    fn an_already_overlapping_group_can_be_moved() {
        // CP3/CP5 regression: a pasted copy overlaps its sources. Because it
        // already overlaps a non-member, a nudge that doesn't create a *new*
        // collision must still be allowed.
        let (copy_a, copy_b) = (block_id(3), block_id(4));
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),
            fx::block(2, 120.0),
            fx::block(3, 30.0),  // a copy sitting atop block 1
            fx::block(4, 150.0), // a copy sitting atop block 2
        ]);
        let pasted = [ShapeId::Rect(copy_a), ShapeId::Rect(copy_b)];
        let before: Vec<Rect> = {
            let drawing = scene.drawing();
            pasted
                .iter()
                .map(|&id| drawing.shape(id).unwrap().gui_rect())
                .collect()
        };
        // Precondition: the pasted copies start out overlapping their sources,
        // which is what makes "no NEW collision" the rule under test.
        assert!(before[0].intersects(block_rect(&scene.drawing(), block_id(1))));

        scene.commit(|drawing| drawing.move_shapes(&pasted, vec2(GRID_SIZE, 0.0)));

        let drawing = scene.drawing();
        for (&id, b) in pasted.iter().zip(before) {
            assert_eq!(
                drawing.shape(id).unwrap().gui_rect(),
                b.translate(vec2(GRID_SIZE, 0.0)),
                "each pasted block shifts one grid cell; the move is not a no-op"
            );
        }
    }

    #[test]
    fn move_shapes_still_blocks_a_move_into_a_clear_neighbor() {
        // Guard preservation: A and B don't overlap; a delta that would drive the
        // member A onto the clear non-member B must still be rejected wholesale.
        let a = block_id(1);
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),   // (0,0)..(40,40)
            fx::block(2, 120.0), // clear, well to the right
        ]);
        let before = block_rect(&scene.drawing(), a);
        // Precondition: A is clear of B now, and its destination is not.
        assert!(!before.intersects(block_rect(&scene.drawing(), block_id(2))));
        assert!(
            before
                .translate(vec2(120.0, 0.0))
                .intersects(block_rect(&scene.drawing(), block_id(2)))
        );

        // Slide A right so its destination lands on top of B.
        scene.commit(|drawing| drawing.move_shapes(&[ShapeId::Rect(a)], vec2(120.0, 0.0)));

        assert_eq!(
            block_rect(&scene.drawing(), a),
            before,
            "the move into a clear neighbor is rejected"
        );
    }

    #[test]
    fn move_shapes_allows_a_nudge_that_does_not_worsen_overlap() {
        // A member that already overlaps a non-member may be nudged, as long as
        // the move creates no collision that wasn't already present.
        let a = block_id(1);
        let mut scene = Scene::new(vec![
            fx::block(1, 0.0),  // member,     (0,0)..(40,40)
            fx::block(2, 10.0), // non-member, (10,0)..(50,40) — overlaps A
        ]);
        let before = block_rect(&scene.drawing(), a);
        // Precondition: the member already overlaps the non-member.
        assert!(before.intersects(block_rect(&scene.drawing(), block_id(2))));

        scene.commit(|drawing| drawing.move_shapes(&[ShapeId::Rect(a)], vec2(GRID_SIZE, 0.0)));

        assert_eq!(
            block_rect(&scene.drawing(), a),
            before.translate(vec2(GRID_SIZE, 0.0)),
            "an already-overlapping member is still allowed to move"
        );
    }
}