blockworx/tools/

resize_block.rs

use std::ops::ControlFlow;

use blockworx_geom::{Pos2, Rect, Vec2};

use crate::theme::{Role, Style};
use crate::{
    edit::naming::Authoring,
    grid::{GRID_SIZE, HIT_RADIUS, PIN_PITCH, PORT_RADIUS, artwork_rect},
    shape::{
        BlockShape, PinLocation, ShapeId, ShapeRef,
        block::{
            ASPECT_SNAP_RADIUS, ResizeSnap, clamp_resize_within, fixed_corner,
            icon_rect_after_resize, resize_corner, resize_rect, snap_resize_aspect,
            snap_resized_block,
        },
        pin::{PinSide, slot},
    },
    state::{RenderMode, ResizeMode},
    tools::{
        RouteTool,
        multi_select::MultiSelect,
        names::ToolName,
        new_pin::{
            HINT_ROUTE_THRESHOLD, NEW_PIN_ANIM_TIME, NEW_PIN_INACTIVE_SCALE, active_new_pin_target,
            draw_plus, draw_route_hint, new_pin_targets, route_hint_phase, target_anim_key,
        },
        rename_pin::{Field, RenamePin},
        select_pin::SelectPin,
        tool::{Action, Deletable, Supposing, ToolTrait},
    },
    widget::{DrawingPasses, drawing::Drawing, hit_target::HitTarget},
};
use blockworx_doc::id::BlockId;
use blockworx_paint::{Canvas, Event, Interaction};

#[derive(Default)]
pub enum ResizeBlock {
    #[default]
    Idle,
    Selected {
        shape: ShapeId,
    },
    ResizeRect {
        shape: ShapeId,
        mode: ResizeMode,
        delta_pos: Vec2,
        /// Smallest size (px) the shape may shrink to, computed when the resize
        /// begins so every existing pin — and any icon — stays inside it.
        min_size: Vec2,
    },
}

/// Smallest width a block may be resized to: 4 grid cells. Ports, images, and
/// icons are exempt (they may be narrower) — see [`min_resize_size`].
const MIN_BLOCK_WIDTH: f32 = GRID_SIZE * 4.0;

/// Minimum width a resize may shrink `shape` to: [`MIN_BLOCK_WIDTH`] for a child
/// block, `0.0` for any other shape (which may be freely narrow).
fn min_block_width(shape: ShapeId) -> f32 {
    if shape.is_block() {
        MIN_BLOCK_WIDTH
    } else {
        0.0
    }
}

/// The size floor a resize of `shape` must respect: its own minimum (see
/// [`min_block_width`] and [`min_block_height`]) grown to hold its icon, since a
/// block never shrinks smaller than the artwork it carries. The icon's extent is
/// raised to the lattice the drop snaps to, or the snap would round back through
/// it.
fn min_resize_size(data: &Drawing, shape: ShapeId, shape_ref: &ShapeRef<'_>) -> Vec2 {
    let own = Vec2::new(min_block_width(shape), min_block_height(shape, shape_ref));
    // `ShapeId::Icon` names its owning block, so ask only for a block's icon.
    let icon = match shape {
        ShapeId::Rect(rid) => data.icon(rid).map(|icon| artwork_rect(icon.rect)),
        _ => None,
    };
    match icon {
        Some(icon) => Vec2::new(
            own.x.max(crate::grid::ceil_to_grid(icon.width())),
            own.y.max(crate::grid::ceil_block_height(icon.height())),
        ),
        None => own,
    }
}

/// Minimum height a resize may shrink `shape` to. For a child block this is a
/// valid block height: at least `PIN_PITCH` (a single pin slot), and tall enough
/// to hold its pins. The pins can slide up into the top margin as the block
/// shrinks (the resize emitter rides them up, see
/// [`crate::edit::geometry::resize`]), so the pin floor is set by their
/// *span* — the slots between the highest and lowest pin — giving
/// `PIN_PITCH * (span + 1)`. Non-blocks keep the bare pin floor (`0.0` when they
/// have none).
fn min_block_height(shape: ShapeId, block: &ShapeRef<'_>) -> f32 {
    let mut bounds: Option<(u32, u32)> = None;
    block.with_pins(|_, pin| {
        let offset = slot(pin).offset;
        bounds = Some(bounds.map_or((offset, offset), |(lo, hi)| {
            (lo.min(offset), hi.max(offset))
        }));
    });
    let pin_floor = match bounds {
        Some((lo, hi)) => PIN_PITCH * ((hi - lo) as f32 + 1.0),
        None => 0.0,
    };
    if shape.is_block() {
        pin_floor.max(PIN_PITCH)
    } else {
        pin_floor
    }
}

/// Clamp the y-component of a resize `delta` so the block cannot shrink below
/// `min_height`. Which edge moves (and therefore the sign of the constraint)
/// depends on the resize `mode`.
fn clamp_to_min_height(mode: ResizeMode, orig: Rect, min_height: f32, mut delta: Vec2) -> Vec2 {
    // Prevent shrinking below `min_height`, but never force a shape to grow: a
    // fixed-height shape (a port) reports a min_height from its boundary slot
    // that exceeds its own height, and clamping up to it would balloon the
    // resize preview.
    let min_height = min_height.min(orig.height());
    match mode {
        // Top edge moves down as delta.y grows; height = orig.height() - delta.y.
        ResizeMode::LeftTop | ResizeMode::RightTop => {
            delta.y = delta.y.min(orig.height() - min_height);
        }
        // Bottom edge moves up as delta.y shrinks; height = orig.height() + delta.y.
        ResizeMode::LeftBottom | ResizeMode::RightBottom => {
            delta.y = delta.y.max(min_height - orig.height());
        }
    }
    delta
}

/// Clamp the x-component of a resize `delta` so the block cannot shrink below
/// `min_width`. Which edge moves (and therefore the sign of the constraint)
/// depends on the resize `mode`.
fn clamp_to_min_width(mode: ResizeMode, orig: Rect, min_width: f32, mut delta: Vec2) -> Vec2 {
    let min_width = min_width.min(orig.width());
    match mode {
        // Left edge moves right as delta.x grows; width = orig.width() - delta.x.
        ResizeMode::LeftTop | ResizeMode::LeftBottom => {
            delta.x = delta.x.min(orig.width() - min_width);
        }
        // Right edge moves as delta.x; width = orig.width() + delta.x.
        ResizeMode::RightTop | ResizeMode::RightBottom => {
            delta.x = delta.x.max(min_width - orig.width());
        }
    }
    delta
}

/// The icon a resized block carries, and the offset to preview it at: exactly
/// where the drop puts it (see [`icon_rect_after_resize`]), so the icon tracks
/// the block through the drag instead of jumping into place on release.
fn icon_preview(
    data: &Drawing,
    shape: ShapeId,
    bbox: Rect,
    preview: Rect,
) -> Option<(ShapeId, Vec2)> {
    let ShapeId::Rect(rid) = shape else {
        return None;
    };
    let icon = artwork_rect(data.icon(rid)?.rect);
    let moved = icon_rect_after_resize(icon, bbox, preview);
    Some((ShapeId::Icon(rid), moved.min - icon.min))
}

/// The intrinsic aspect ratio (`w/h`) of an image or icon shape, or `None` for
/// other shapes or an image the painter can't resolve. Drives the aspect-lock
/// resize snap.
fn intrinsic_aspect<C: Canvas>(
    data: &Drawing,
    shape: ShapeId,
    painter: &Style<'_, C>,
) -> Option<f32> {
    let ShapeRef::Image(artwork) = data.shape(shape)? else {
        return None;
    };
    let size = painter.image_intrinsic_size(artwork.asset?)?;
    (size.y > 0.0).then(|| size.x / size.y)
}

/// The resize delta a `shape`+`mode` commits to for the accumulated `raw_delta`,
/// computed from immutable reads only (so it can run before a mutable apply, as
/// `DragStopped` needs). The pipeline: `constrain_resize_delta → clamp_to_min_height
/// → clamp_to_min_width → contain-icon`, and for a free image/icon `→ aspect snap → contain → edge
/// magnetism → contain`. Both the drag preview and the drop apply this, so they
/// agree. An icon is re-contained after every snap, so containment always wins.
struct Resize {
    shape: ShapeId,
    mode: ResizeMode,
    /// The shape's rect at drag start.
    bbox: Rect,
    /// Accumulated pointer delta since drag start.
    raw_delta: Vec2,
    /// The floor from [`min_resize_size`], captured at drag start.
    min_size: Vec2,
}

impl Resize {
    fn final_delta<C: Canvas>(&self, data: &Drawing, painter: &Style<'_, C>) -> Vec2 {
        let Self {
            shape,
            mode,
            bbox,
            raw_delta,
            min_size,
        } = *self;
        let icon_bounds = match shape {
            ShapeId::Icon(rid) => data.shape(ShapeId::Rect(rid)).map(|b| b.gui_rect()),
            _ => None,
        };
        let contain = |d: Vec2| match icon_bounds {
            Some(bounds) => clamp_resize_within(bbox, mode, d, bounds),
            None => d,
        };
        let mut delta = data
            .shape(shape)
            .map_or(raw_delta, |s| s.constrain_resize_delta(raw_delta));
        delta = clamp_to_min_height(mode, bbox, min_size.y, delta);
        delta = clamp_to_min_width(mode, bbox, min_size.x, delta);
        delta = contain(delta);
        if shape.is_artwork() {
            // Snap to the image's intrinsic aspect ratio when close, so the user can
            // deliberately hit an undistorted resize.
            if let Some(aspect) = intrinsic_aspect(data, shape, painter) {
                let resized = resize_rect(&bbox, mode, delta);
                if let Some(snapped) =
                    snap_resize_aspect(bbox, mode, resized, aspect, ASPECT_SNAP_RADIUS)
                {
                    delta = contain(resize_corner(&snapped, mode) - resize_corner(&bbox, mode));
                }
            }
            // Then snap the dragged edge to a nearby static edge, so a free image/icon
            // lines up like a move does.
            let corner = resize_corner(&resize_rect(&bbox, mode, delta), mode);
            let snapped = crate::widget::alignment::snap_resize_corner(data, shape, corner);
            if snapped != corner {
                delta = contain(snapped - resize_corner(&bbox, mode));
            }
        }
        delta
    }
}

// ── New-pin targets ──────────────────────────────────────────────────────────
//
// While a block is selected, every free pin slot is offered as a small blue dot
// one grid cell outside the block edge — where the pin's connection point will
// land. The dot nearest the cursor (within `NEW_PIN_ACTIVATION_RANGE`) animates
// into a blue ring that grows out to `PORT_RADIUS`. Pressing on that ring inverts
// the marker (a filled disk) for as long as the button is held; releasing inside
// the ring adds the pin, releasing outside cancels. The marker geometry and the
// animation primitives live in [`crate::tools::new_pin`], shared with the route
// tool.

/// The world-space pointer: real on the live canvas, the demo's synthetic
/// pointer in a scripted session (see
/// [`Animator::pointer_world`](blockworx_paint::Animator::pointer_world)).
fn pointer_world<C: Canvas>(painter: &Style<'_, C>) -> Option<Pos2> {
    painter.pointer_world()
}

/// The new-pin marker `pos` lands on: the block's active target, within the
/// widest grab its neighbours leave it (R34) — wider than the ring draws at,
/// like every other target on the canvas.
pub(crate) fn new_pin_target_at(
    data: &Drawing,
    rid: BlockId,
    pos: Pos2,
) -> Option<(PinLocation, Pos2)> {
    let targets = new_pin_targets(&data.block_shape(rid)?);
    let idx = active_new_pin_target(&targets, pos)?;
    let (loc, center) = targets[idx];
    (pos.distance(center) < crate::tools::new_pin::new_pin_grab().get()).then_some((loc, center))
}

/// Draw the new-pin markers for the selected block `rid`. The marker nearest
/// `hover` grows a blue ring out to `PORT_RADIUS`; the marker `held` down is
/// drawn inverted as a filled disk and locks out hover activation.
fn draw_new_pin_targets<C: Canvas>(
    block: &BlockShape<'_>,
    rid: BlockId,
    hover: Option<Pos2>,
    held: Option<Pos2>,
    painter: &mut Style<'_, C>,
) {
    let targets = new_pin_targets(block);
    let pressed = held;
    let active = if pressed.is_some() {
        None
    } else {
        hover.and_then(|p| active_new_pin_target(&targets, p))
    };
    for (i, (loc, center)) in targets.iter().enumerate() {
        if Some(*center) == pressed {
            // Inverted "pressed" button: a filled blue disk with a light `+`.
            painter.circle_filled(*center, PORT_RADIUS, Role::NewPinPreviewFill);
            draw_plus(*center, PORT_RADIUS, Role::NewPinPreviewStroke, painter);
            // While held, an animated hint teaches that dragging out starts a route.
            let phase = route_hint_phase(painter.now());
            draw_route_hint(*center, loc.side, phase, painter);
            painter.request_repaint();
            continue;
        }
        let goal = if active == Some(i) { 1.0 } else { 0.0 };
        let t = painter.animate(target_anim_key(rid, *loc), goal, NEW_PIN_ANIM_TIME);
        // The resting dot fades out as the ring grows in, so it reads as the dot
        // expanding into the ring.
        if t < 1.0 {
            painter.with_opacity(1.0 - t, |p| {
                p.circle_filled(
                    *center,
                    PORT_RADIUS * NEW_PIN_INACTIVE_SCALE,
                    Role::NewPinPreviewFill,
                );
            });
        }
        if t > 0.0 {
            // A blue ring grows from the dot's radius out to `PORT_RADIUS`.
            let radius =
                PORT_RADIUS * (NEW_PIN_INACTIVE_SCALE + (1.0 - NEW_PIN_INACTIVE_SCALE) * t);
            painter.circle(
                *center,
                radius,
                Role::Transparent,
                (2.0, Role::NewPinPreviewFill),
            );
            painter.with_opacity(t, |p| {
                draw_plus(*center, PORT_RADIUS, Role::NewPinPreviewFill, p);
            });
        }
    }
}

/// The corner handle `pos` grabs on `shape`'s selection rect, if any. Handles
/// only exist on resizable shapes; a text box carries none.
fn resize_mode_at(shape: &crate::shape::ShapeRef<'_>, pos: Pos2) -> Option<ResizeMode> {
    if !shape.resizable() {
        return None;
    }
    let rect = shape.gui_rect();
    [
        (rect.left_top(), ResizeMode::LeftTop),
        (rect.right_top(), ResizeMode::RightTop),
        (rect.left_bottom(), ResizeMode::LeftBottom),
        (rect.right_bottom(), ResizeMode::RightBottom),
    ]
    .into_iter()
    .find_map(|(corner, mode)| (pos.distance(corner) < HIT_RADIUS.get()).then_some(mode))
}

/// Only blocks hold their height to the 4-cell pitch; ports, areas, images
/// and text boxes just snap to the grid.
fn resize_snap(shape: ShapeId) -> ResizeSnap {
    if shape.is_block() {
        ResizeSnap::BlockPitch
    } else {
        ResizeSnap::GridOnly
    }
}

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

    fn selection(&self) -> Option<Deletable> {
        match self {
            ResizeBlock::Selected { shape } => Some(Deletable::Shape(*shape)),
            _ => None,
        }
    }

    fn suppose<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
        phase: &Supposing,
    ) {
        let ResizeBlock::ResizeRect {
            shape,
            mode,
            delta_pos,
            min_size,
        } = self
        else {
            return;
        };
        let Some(bbox) = data.shape(*shape).map(|s| s.gui_rect()) else {
            return;
        };
        let (shape, mode, min_size) = (*shape, *mode, *min_size);
        if let Some(Event::Dragging { delta, .. }) = interaction.event {
            *delta_pos = Resize {
                shape,
                mode,
                bbox,
                raw_delta: *delta_pos + delta,
                min_size,
            }
            .final_delta(data, painter);
        }
        // Suppose the previewed (grid-snapped) resized rect, which is what the
        // drop commits.
        let predicted = snap_resized_block(
            resize_rect(&bbox, mode, *delta_pos),
            mode,
            resize_snap(shape),
        );
        data.suppose_resize(phase, &[(shape, predicted)]);
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Action> {
        self.render(data, interaction, painter);
        let state = std::mem::take(self);
        match state {
            ResizeBlock::Idle => {
                if let Some(Event::Clicked { pos }) = interaction.event
                    && let Some(shape) = data.shape_at_pos(pos)
                {
                    *self = ResizeBlock::Selected { shape };
                    return None;
                }
            }
            ResizeBlock::Selected { shape } => {
                if interaction.delete_pressed {
                    return Some(Action::Delete(Deletable::Shape(shape)));
                }
                // Hovering an existing pin grows a route-start target; pressing or
                // dragging it hands off to the route tool, exactly as in the Select
                // tool. Checked before the pin-stub and new-pin handling so a press
                // on the target starts a route rather than drilling into the pin.
                if let ControlFlow::Break(action) =
                    crate::tools::route_start::widget(data, interaction, painter)
                {
                    *self = ResizeBlock::Selected { shape };
                    return action;
                }
                if let Some(Event::DoubleClicked { pos }) = interaction.event {
                    // App will switch tools in response, so leaving `*self` as the
                    // taken-default Idle is fine here. The shared resolver opens the
                    // editor for whatever editable label was hit — a title or tag
                    // drawn over the block body takes precedence over the body, and
                    // any pin / route label / text box is handled too. A bare block
                    // body is entered via the "Expand" overlay button, not here, so
                    // a miss falls through to the click/drag handling below.
                    if let Some(tool) = crate::tools::select_tool::editor_at_pos(data, pos, painter)
                    {
                        return Some(Action::SwitchTool(tool));
                    }
                }
                // Clicking a pin on the selected block drills into per-pin
                // selection.
                if let Some(Event::Clicked { pos }) = interaction.event
                    && let Some(HitTarget::Pin { anchor, .. }) = data.resolve_at_pos(pos, painter)
                    && matches!(data.pin_shape(anchor), Some(ShapeId::Rect(_)))
                {
                    return Some(Action::SwitchTool(SelectPin::Selected { anchor }.into()));
                }
                // New-pin markers, with two commit modes: a click on a marker's
                // ring (press released in place — a click is decided at
                // release) adds the pin and drops into editing its name; a held
                // press pulled firmly outward adds the pin and hands the same
                // gesture to the routing tool. A sloppy release classifies as a
                // drag, not a click, so it commits nothing. Handled before the
                // empty-canvas deselect below, since the markers sit off the
                // block body.
                if let ShapeId::Rect(rid) = shape
                    // The markers this answers are drawn under the same
                    // condition (see `render`), so a press near a slot the
                    // user cannot see never adds a pin.
                    && data.authoring_of(shape) == Authoring::Offered
                {
                    if let Some(Event::Clicked { pos }) = interaction.event
                        && let Some((loc, _)) = new_pin_target_at(data, rid, pos)
                    {
                        if let Some(pin) = data.add_named_pin(rid, loc) {
                            return Some(RenamePin::action(data, pin, Field::Name));
                        }
                        *self = ResizeBlock::Selected { shape };
                        return None;
                    }
                    if let Some(press) = interaction.press
                        && let Some((loc, center)) = new_pin_target_at(data, rid, press.origin)
                    {
                        // Held: the marker stays inverted (drawn by `render`) and
                        // owns the interaction. A firm pull outward (the pin's
                        // direction, past the hint's threshold) starts a route —
                        // decided from actual displacement, not the host's drag
                        // classification, so a jittery hold keeps cycling.
                        if let Some(p) = pointer_world(painter) {
                            let outward = match loc.side {
                                PinSide::East => 1.0,
                                PinSide::West => -1.0,
                            };
                            if (p.x - center.x) * outward > HINT_ROUTE_THRESHOLD.get()
                                && let Some(pin) = data.add_named_pin(rid, loc)
                            {
                                return Some(Action::SwitchTool(
                                    RouteTool::routing_from_new_pin(pin, p).into(),
                                ));
                            }
                        }
                        *self = ResizeBlock::Selected { shape };
                        return None;
                    }
                }
                if let Some(Event::Clicked { pos }) = interaction.event {
                    if interaction.shift {
                        // Shift-click toggles another shape into a multi-selection;
                        // shift-clicking elsewhere keeps the current selection.
                        if let Some(hit) = data.shape_at_pos(pos) {
                            return Some(Action::SwitchTool(
                                crate::tools::select_tool::extend_with_shape(&[shape], hit),
                            ));
                        }
                        return None;
                    }
                    // Clicking the already-selected shape keeps it selected;
                    // clicking any other object (shape / route / pin) selects that
                    // directly, and empty canvas deselects.
                    if data.shape_at_pos(pos) != Some(shape) {
                        return Some(
                            crate::tools::select_tool::click_to_select(data, pos, painter)
                                .unwrap_or_default(),
                        );
                    }
                }
                // Shift-drag starts a marquee that extends the current selection.
                if interaction.shift
                    && let Some(Event::DragStarted { pos }) = interaction.event
                {
                    return Some(Action::SwitchTool(
                        MultiSelect::Marquee {
                            start: pos,
                            current: pos,
                            base: vec![shape],
                        }
                        .into(),
                    ));
                }
                if let Some(Event::DragStarted { pos }) = interaction.event {
                    // A grab on one of the selection's corner handles resizes;
                    // anything else moves whatever the drag landed on. A
                    // read-only session takes neither: `drag_to_move` answers
                    // with a marquee.
                    let editing = data.authoring() == Authoring::Offered;
                    let grab = data.shape(shape).filter(|_| editing).and_then(|block| {
                        Some((
                            resize_mode_at(&block, pos)?,
                            min_resize_size(data, shape, &block),
                        ))
                    });
                    if let Some((mode, min_size)) = grab {
                        *self = ResizeBlock::ResizeRect {
                            shape,
                            mode,
                            delta_pos: Vec2::ZERO,
                            min_size,
                        };
                        return None;
                    }
                    return Some(crate::tools::select_tool::drag_to_move(data, pos, painter));
                }
            }
            ResizeBlock::ResizeRect {
                shape,
                mode,
                delta_pos,
                min_size,
            } => {
                // A shape deleted under a live drag leaves nothing to resize, so
                // the tool drops out on the taken default.
                if matches!(interaction.event, Some(Event::Dragging { .. }))
                    && data.shape(shape).is_none()
                {
                    return None;
                }
                if let Some(Event::DragStopped { .. }) = interaction.event {
                    // Compute the committed rect from immutable reads (the shared
                    // pipeline queries the block, aspect, and other shapes), then
                    // apply it with one mutable borrow.
                    let free = shape.is_artwork();
                    if let Some(bbox) = data.shape(shape).map(|s| s.gui_rect()) {
                        let delta = Resize {
                            shape,
                            mode,
                            bbox,
                            raw_delta: delta_pos,
                            min_size,
                        }
                        .final_delta(data, painter);
                        let resized = resize_rect(&bbox, mode, delta);
                        let predicted = if free {
                            resized
                        } else {
                            snap_resized_block(resized, mode, resize_snap(shape))
                        };
                        data.apply_resize(shape, predicted);
                    }
                    *self = ResizeBlock::Selected { shape };
                    return None;
                }
            }
        }
        *self = state;
        None
    }
}

impl ResizeBlock {
    fn render<C: Canvas>(
        &self,
        data: &Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) {
        match self {
            ResizeBlock::Idle => {
                crate::widget::display::widget(data, interaction, painter);
            }
            ResizeBlock::Selected { shape: selected_id } => {
                let selected_id = *selected_id;
                crate::widget::display::render_selected(data, selected_id, painter);
                // A selected block offers its free pin slots as animated
                // markers — unless nothing may be added to it, which a locked
                // interface and a read-only session both mean.
                if let ShapeId::Rect(rid) = selected_id
                    && data.authoring_of(selected_id) == Authoring::Offered
                    && let Some(block) = data.block_shape(rid)
                {
                    let hover = match interaction.event {
                        Some(Event::HoverAt(p)) => Some(p),
                        _ => None,
                    };
                    let held = interaction
                        .press
                        .and_then(|press| new_pin_target_at(data, rid, press.origin))
                        .map(|(_, center)| center);
                    draw_new_pin_targets(&block, rid, hover, held, painter);
                }
            }
            ResizeBlock::ResizeRect {
                shape: selected_id,
                mode,
                delta_pos,
                ..
            } => {
                let selected_id = *selected_id;
                let mode = *mode;
                let delta_pos = *delta_pos;
                let resizing = RenderMode::Resizing {
                    mode,
                    delta: delta_pos,
                };
                let bbox = data.shape(selected_id).map(|s| s.gui_rect());
                // The rect the drop would commit: grid-snapped for a block, free
                // for an image/icon.
                let preview = bbox.map(|bbox| {
                    let resized = resize_rect(&bbox, mode, delta_pos);
                    if selected_id.is_block() {
                        snap_resized_block(resized, mode, ResizeSnap::BlockPitch)
                    } else {
                        resized
                    }
                });
                // Alignment guides for the resized shape at its previewed rect.
                let guides = preview
                    .map(|preview| {
                        crate::widget::alignment::resize_guides(data, selected_id, preview)
                    })
                    .unwrap_or_default();
                // A resized block's icon rides along with it.
                let (icon_id, icon_delta) = match bbox
                    .zip(preview)
                    .and_then(|(bbox, preview)| icon_preview(data, selected_id, bbox, preview))
                {
                    Some((id, delta)) => (Some(id), delta),
                    None => (None, Vec2::ZERO),
                };
                // For an image/icon snapped to its intrinsic aspect, the aspect
                // diagonal, shown only while actually on-aspect.
                let aspect_guide = intrinsic_aspect(data, selected_id, painter)
                    .zip(bbox)
                    .and_then(|(aspect, bbox)| {
                        let resized = resize_rect(&bbox, mode, delta_pos);
                        ((resized.width() / resized.height() - aspect).abs() < 1e-2).then_some([
                            fixed_corner(&resized, mode),
                            resize_corner(&resized, mode),
                        ])
                    });
                DrawingPasses::new(data)
                    .shape_mode(move |id| {
                        if id == selected_id {
                            resizing
                        } else if Some(id) == icon_id {
                            RenderMode::Moving { delta: icon_delta }
                        } else {
                            RenderMode::Normal
                        }
                    })
                    // Guides on top so they stay visible over the diagram.
                    .overlay(move |painter| {
                        crate::widget::alignment::draw_guides(&guides, painter);
                        if let Some(seg) = aspect_guide {
                            painter.line_segment(seg, (1.0, Role::AlignmentGuide));
                        }
                    })
                    .draw(painter);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::path::Scope;
    use crate::widget::test_fixtures::{self as fx, Scene};
    use blockworx_doc::{fixtures::block_id, id::BlockId};
    use blockworx_geom::pos2;

    /// A 20×16-cell block carrying artwork over its middle — the scene both
    /// icon-containment claims are made against.
    fn block_with_an_icon(n: u32) -> Scene {
        let block = Rect::from_min_max(pos2(0.0, 0.0), pos2(20.0 * GRID_SIZE, 16.0 * GRID_SIZE));
        let side = block.width().min(block.height()) * 0.6;
        Scene::new(vec![
            fx::block_in(n, Scope::Root, block),
            fx::asset().1,
            fx::icon(n, Rect::from_center_size(block.center(), Vec2::splat(side))),
        ])
    }

    // A fixed-height shape (a port) reports a min_height larger than its own
    // height. The clamp must not force the resize preview to grow to it.
    #[test]
    fn clamp_to_min_height_never_forces_a_fixed_height_shape_to_grow() {
        let port = Rect::from_min_max(pos2(0.0, 0.0), pos2(60.0, 30.0));
        let oversized_min = 210.0; // e.g. PIN_PITCH * (slot 5 + 2)
        for mode in [
            ResizeMode::LeftTop,
            ResizeMode::RightTop,
            ResizeMode::LeftBottom,
            ResizeMode::RightBottom,
        ] {
            // A width-only drag (y already locked to 0) stays at 0.
            let clamped = clamp_to_min_height(mode, port, oversized_min, Vec2::new(20.0, 0.0));
            assert_eq!(clamped.y, 0.0, "{mode:?} ballooned the height");
        }
    }

    #[test]
    fn clamp_to_min_height_still_blocks_shrinking_a_block_below_its_pins() {
        let block = Rect::from_min_max(pos2(0.0, 0.0), pos2(300.0, 300.0));
        let min_height = 200.0;
        // Dragging the bottom edge up far enough to cross min_height is clamped.
        let clamped = clamp_to_min_height(
            ResizeMode::RightBottom,
            block,
            min_height,
            Vec2::new(0.0, -250.0),
        );
        assert_eq!(clamped.y, min_height - block.height());
    }

    #[test]
    fn min_block_width_gates_on_rect() {
        assert_eq!(
            min_block_width(ShapeId::Rect(BlockId::NULL)),
            MIN_BLOCK_WIDTH
        );
        assert_eq!(
            min_block_width(ShapeId::Area(blockworx_doc::id::AreaId::NULL)),
            0.0
        );
    }

    #[test]
    fn clamp_to_min_width_blocks_shrinking_a_block_below_min_width_from_the_right() {
        let block = Rect::from_min_max(pos2(0.0, 0.0), pos2(300.0, 300.0));
        // Dragging the right edge left far enough to cross the min width is clamped.
        let clamped = clamp_to_min_width(
            ResizeMode::RightBottom,
            block,
            MIN_BLOCK_WIDTH,
            Vec2::new(-250.0, 0.0),
        );
        assert_eq!(clamped.x, MIN_BLOCK_WIDTH - block.width());
    }

    #[test]
    fn clamp_to_min_width_blocks_shrinking_a_block_below_min_width_from_the_left() {
        let block = Rect::from_min_max(pos2(0.0, 0.0), pos2(300.0, 300.0));
        // Dragging the left edge right far enough to cross the min width is clamped.
        let clamped = clamp_to_min_width(
            ResizeMode::LeftTop,
            block,
            MIN_BLOCK_WIDTH,
            Vec2::new(250.0, 0.0),
        );
        assert_eq!(clamped.x, block.width() - MIN_BLOCK_WIDTH);
    }

    // A shape whose min_width exceeds its own width must not be forced to grow.
    #[test]
    fn clamp_to_min_width_never_forces_a_fixed_width_shape_to_grow() {
        let narrow = Rect::from_min_max(pos2(0.0, 0.0), pos2(30.0, 60.0));
        let oversized_min = MIN_BLOCK_WIDTH; // wider than the shape itself
        for mode in [
            ResizeMode::LeftTop,
            ResizeMode::RightTop,
            ResizeMode::LeftBottom,
            ResizeMode::RightBottom,
        ] {
            // A height-only drag (x already locked to 0) stays at 0.
            let clamped = clamp_to_min_width(mode, narrow, oversized_min, Vec2::new(0.0, 20.0));
            assert_eq!(clamped.x, 0.0, "{mode:?} ballooned the width");
        }
    }

    /// The icon is previewed at the offset the drop commits, so it tracks the
    /// block instead of jumping into place on release.
    #[test]
    fn a_resized_blocks_icon_previews_at_the_offset_the_drop_commits() {
        let rid = block_id(1);
        let mut scene = block_with_an_icon(1);
        let shape = ShapeId::Rect(rid);
        // Drag the top-left corner inward by whole cells, so the snap is exact.
        let mode = ResizeMode::LeftTop;

        let (before, preview, delta) = {
            let data = scene.drawing();
            let before = artwork_rect(data.icon(rid).expect("the icon").rect);
            let bbox = data.shape(shape).expect("the block").gui_rect();
            let preview = snap_resized_block(
                resize_rect(&bbox, mode, Vec2::new(4.0 * GRID_SIZE, 3.0 * GRID_SIZE)),
                mode,
                ResizeSnap::BlockPitch,
            );
            let (icon_id, delta) =
                icon_preview(&data, shape, bbox, preview).expect("the block's icon");
            assert_eq!(icon_id, ShapeId::Icon(rid));
            (before, preview, delta)
        };
        // Precondition: this resize really carries the icon, so agreement is a claim.
        assert_ne!(delta, Vec2::ZERO);

        scene.commit(|data| data.apply_resize(shape, preview));

        let committed = artwork_rect(scene.drawing().icon(rid).expect("the icon").rect);
        assert_eq!(committed.min - before.min, delta);
    }

    /// A block with an icon never shrinks smaller than the artwork it carries:
    /// drag every corner as far inward as it goes and the committed rect still
    /// holds the icon.
    #[test]
    fn a_block_never_resizes_smaller_than_its_icon() {
        use crate::canvas::Painter;
        use crate::theme::Theme;

        let ctx = egui::Context::default();
        ctx.run_ui(egui::RawInput::default(), |ui| {
            let rid = block_id(1);
            let mut scene = block_with_an_icon(1);
            let data = scene.drawing();
            let shape = ShapeId::Rect(rid);
            let icon = artwork_rect(data.icon(rid).expect("the icon").rect);
            let bbox = data.shape(shape).expect("the block").gui_rect();
            // Precondition: the icon is smaller than the block, so a shrink has
            // somewhere to go before it hits the icon.
            assert!(bbox.contains_rect(icon) && icon.width() < bbox.width());

            let theme = Theme::default();
            let mut painter = Painter::headless(ui.painter().clone(), theme.palette().clone());
            let style = Style::new(&theme, &mut painter);
            let min_size = min_resize_size(&data, shape, &data.shape(shape).expect("the block"));
            for mode in [
                ResizeMode::LeftTop,
                ResizeMode::RightTop,
                ResizeMode::LeftBottom,
                ResizeMode::RightBottom,
            ] {
                // Drag the corner clear across the block and past the far side.
                let inward = match mode {
                    ResizeMode::LeftTop => Vec2::new(bbox.width(), bbox.height()),
                    ResizeMode::RightTop => Vec2::new(-bbox.width(), bbox.height()),
                    ResizeMode::LeftBottom => Vec2::new(bbox.width(), -bbox.height()),
                    ResizeMode::RightBottom => Vec2::new(-bbox.width(), -bbox.height()),
                };
                let delta = Resize {
                    shape,
                    mode,
                    bbox,
                    raw_delta: inward,
                    min_size,
                }
                .final_delta(&data, &style);
                let committed = snap_resized_block(
                    resize_rect(&bbox, mode, delta),
                    mode,
                    ResizeSnap::BlockPitch,
                );
                assert!(
                    committed.width() >= icon.width() && committed.height() >= icon.height(),
                    "{mode:?} shrank {committed:?} below the icon {icon:?}"
                );
            }
        })
        .drop_without_applying_deltas();
    }
}