blockworx_tools/

resize_block.rs

use std::ops::ControlFlow;

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

use crate::theme::{Role, Style};
use crate::{
    edit::naming::Authoring,
    grid::{GRID_SIZE, PIN_PITCH, artwork_rect},
    multi_select::MultiSelect,
    names::ToolName,
    new_pin::{add_pin, draw_markers, marker_at, offered_markers},
    render::text_box::BoxWidth,
    select_pin::SelectPin,
    shape::{
        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::slot,
    },
    state::{RenderMode, ResizeMode},
    tool::{Action, Deletable, PreviewPhase, ToolTrait, Transition},
    widget::{DrawingPasses, drawing::Drawing, hit_target::HitTarget},
};
use blockworx_paint::{Canvas, Event, Interaction, Renderer};

#[derive(Default)]
pub enum ResizeBlock {
    #[default]
    Idle,
    Selected {
        shape: ShapeId,
    },
    ResizeRect {
        shape: ShapeId,
        mode: ResizeMode,
        delta_pos: Vec2,
        bounds: ResizeBounds,
    },
}

/// The sizes a resize stays between, taken when it begins.
#[derive(Clone, Copy, Debug)]
pub struct ResizeBounds {
    /// Smallest size (px): every existing pin — and any icon — stays inside it.
    min: Vec2,
    /// A text box's widest box; unbounded for every other shape.
    widest: WorldPx,
}

/// Smallest width a block or a text box may be resized to: 4 grid cells. Ports,
/// areas, 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 or a text box, `0.0` for any other shape (which may be freely narrow).
fn min_block_width(shape: ShapeId) -> f32 {
    if shape.is_block() || matches!(shape, ShapeId::Text(_)) {
        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,
    }
}

/// What a resize of `shape` stays between: [`min_resize_size`], and for a text
/// box the widest box its column cap allows.
fn resize_bounds(
    data: &Drawing,
    shape: ShapeId,
    shape_ref: &ShapeRef<'_>,
    painter: &Style<'_, impl Renderer>,
) -> ResizeBounds {
    ResizeBounds {
        min: min_resize_size(data, shape, shape_ref),
        widest: match shape {
            ShapeId::Text(_) => BoxWidth::widest(painter),
            _ => WorldPx::UNBOUNDED,
        },
    }
}

/// 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
}

/// Clamp the x-component of a resize `delta` so the shape cannot grow wider than
/// `widest`, never forcing a shape already wider to shrink.
fn clamp_to_widest(mode: ResizeMode, orig: Rect, widest: WorldPx, mut delta: Vec2) -> Vec2 {
    let widest = widest.get().max(orig.width());
    match mode {
        ResizeMode::LeftTop | ResizeMode::LeftBottom => {
            delta.x = delta.x.max(orig.width() - widest);
        }
        ResizeMode::RightTop | ResizeMode::RightBottom => {
            delta.x = delta.x.min(widest - 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 → clamp_to_widest → 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 bounds from [`resize_bounds`], captured at drag start.
    bounds: ResizeBounds,
}

impl Resize {
    fn final_delta<C: Canvas>(&self, data: &Drawing, painter: &Style<'_, C>) -> Vec2 {
        let Self {
            shape,
            mode,
            bbox,
            raw_delta,
            bounds,
        } = *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, bounds.min.y, delta);
        delta = clamp_to_min_width(mode, bbox, bounds.min.x, delta);
        delta = clamp_to_widest(mode, bbox, bounds.widest, 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
    }
}

/// The corner handle `pos` grabs on `shape`'s selection rect, if any. Handles
/// only exist on resizable shapes.
fn resize_mode_at(shape: &ShapeRef<'_>, pos: Pos2) -> Option<ResizeMode> {
    if !shape.resizable() {
        return None;
    }
    crate::render::resize_handle_at(shape.gui_rect(), pos)
}

/// 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 preview<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
        phase: &PreviewPhase,
    ) {
        let ResizeBlock::ResizeRect {
            shape,
            mode,
            delta_pos,
            bounds,
        } = self
        else {
            return;
        };
        let Some(bbox) = data.shape(*shape).map(|s| s.gui_rect()) else {
            return;
        };
        let (shape, mode, bounds) = (*shape, *mode, *bounds);
        if let Some(Event::Dragging { delta, .. }) = interaction.event {
            *delta_pos = Resize {
                shape,
                mode,
                bbox,
                raw_delta: *delta_pos + delta,
                bounds,
            }
            .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.preview_resize(phase, &[(shape, predicted)]);
    }

    fn widget<C: Canvas>(
        &mut self,
        data: &mut Drawing,
        interaction: &Interaction,
        painter: &mut Style<'_, C>,
    ) -> Option<Transition> {
        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)).into());
                }
                // 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::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::select_tool::editor_at_pos(data, pos, painter) {
                        return Some(Transition::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(Transition::SwitchTool(
                        SelectPin::Selected { anchor }.into(),
                    ));
                }
                // The selected block's new-pin markers: a click on one adds
                // the pin and opens its name, and a press held on one owns the
                // gesture, so a drag from it does nothing. Handled before the
                // empty-canvas deselect below, since the markers sit off the
                // block body.
                if let ShapeId::Rect(rid) = shape {
                    let markers = offered_markers(data, [rid]);
                    if let Some(Event::Clicked { pos }) = interaction.event
                        && let Some(marker) = marker_at(&markers, pos)
                    {
                        if let Some(added) = add_pin(data, marker) {
                            return Some(added);
                        }
                        *self = ResizeBlock::Selected { shape };
                        return None;
                    }
                    if let Some(press) = interaction.press
                        && marker_at(&markers, press.origin).is_some()
                    {
                        *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(Transition::SwitchTool(
                                crate::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::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(Transition::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)?,
                            resize_bounds(data, shape, &block, painter),
                        ))
                    });
                    if let Some((mode, bounds)) = grab {
                        *self = ResizeBlock::ResizeRect {
                            shape,
                            mode,
                            delta_pos: Vec2::ZERO,
                            bounds,
                        };
                        return None;
                    }
                    // This is the one selection that can be an icon, and an
                    // armed icon is the one state a drag on it takes the
                    // icon rather than the block under it.
                    let icon = match shape {
                        ShapeId::Icon(rid) => crate::select_tool::IconGrab::Armed(rid),
                        _ => crate::select_tool::IconGrab::NotArmed,
                    };
                    return Some(crate::select_tool::drag_to_move(data, pos, painter, icon));
                }
            }
            ResizeBlock::ResizeRect {
                shape,
                mode,
                delta_pos,
                bounds,
            } => {
                // 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,
                            bounds,
                        }
                        .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);
                if let ShapeId::Rect(rid) = selected_id {
                    draw_markers(&offered_markers(data, [rid]), interaction, 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::theme::Theme;

        {
            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 measured = blockworx_text::measure::Measured::new(
                blockworx_paint::FontChoice::default(),
                theme.palette().clone(),
            );
            let mut canvas = measured.canvas(blockworx_text::measure::Scripted::default());
            let style = Style::new(&theme, &mut canvas);
            let bounds =
                resize_bounds(&data, shape, &data.shape(shape).expect("the block"), &style);
            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,
                    bounds,
                }
                .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:?}"
                );
            }
        }
    }
}