blockworx_editor/render/

layout.rs

//! Pure position/alignment helpers shared by the drawing primitives and by the
//! hit-testing in `widget`. No drawing happens here — each function maps an
//! element's geometry to a label anchor (and its [`Align2`]).

use blockworx_doc::values::LabelSide;
use blockworx_geom::{Align, Align2, Pos2, Rect, pos2, vec2};

use crate::{
    grid::{GRID_SIZE, PORT_TEXT_SIZE, TAG_SHIM, pin_offset_y},
    shape::{
        ShapeLabel,
        pin::{Pin, PinSide, slot},
    },
};

/// Vertical gap, in world units, between a pin/port's stub line and the
/// baseline-center of the `tag` label drawn above it.
const PIN_TAG_RISE: f32 = PORT_TEXT_SIZE * 0.7;

pub fn port_text_center(bbox: Rect, side: PinSide) -> Pos2 {
    let y = bbox.center().y - GRID_SIZE / 2.0;
    match side {
        PinSide::East => pos2(bbox.center().x - GRID_SIZE / 2.0, y),
        PinSide::West => pos2(bbox.center().x + GRID_SIZE / 2.0, y),
    }
}

pub fn pin_text_location(bbox: Rect, pin: &Pin, side: PinSide, offset: f32) -> (Pos2, Align2) {
    let y_coord = pin_offset_y(bbox.top(), slot(pin).offset) + offset;
    match side {
        PinSide::East => (
            pos2(bbox.right() - GRID_SIZE / 2.0, y_coord),
            Align2::RIGHT_CENTER,
        ),
        PinSide::West => (
            pos2(bbox.left() + GRID_SIZE / 2.0, y_coord),
            Align2::LEFT_CENTER,
        ),
    }
}

/// Position and alignment for the `tag` label, which sits above the stub line
/// hugging the shape edge: right-justified on the West side, left-justified on
/// the East side (opposite to how `name` is justified). `left`/`right` are the
/// shape's edge x-coordinates (the inner end of the stub); `line_y` is the
/// stub's y.
pub fn pin_tag_location(left: f32, right: f32, side: PinSide, line_y: f32) -> (Pos2, Align2) {
    let y = line_y - PIN_TAG_RISE;
    match side {
        PinSide::East => (pos2(right + TAG_SHIM, y), Align2::LEFT_CENTER),
        PinSide::West => (pos2(left - TAG_SHIM, y), Align2::RIGHT_CENTER),
    }
}

fn title_anchor(bbox: Rect, side: LabelSide, offset: f32) -> (Pos2, Align2) {
    match side {
        LabelSide::Bottom => (bbox.center_bottom() + vec2(offset, 0.0), Align2::CENTER_TOP),
        LabelSide::Top => (bbox.center_top() + vec2(offset, 0.0), Align2::CENTER_BOTTOM),
        LabelSide::Center => (bbox.center() + vec2(offset, 0.0), Align2::CENTER_CENTER),
    }
}

pub fn block_title_position(bbox: Rect, title: &ShapeLabel<'_>) -> (Pos2, Align2) {
    title_anchor(bbox, title.side, title.offset)
}

/// Like [`block_title_position`], but clamps the horizontal offset so a title of
/// width `text_width` stays within the block (pinning flush when wider). Used at
/// draw time so a later resize can't leave a stale offset drawing outside the block.
pub fn clamped_block_title_position(
    bbox: Rect,
    title: &ShapeLabel<'_>,
    text_width: f32,
) -> (Pos2, Align2) {
    let offset = clamp_label_offset(bbox, text_width, title.offset, Align::Center);
    title_anchor(bbox, title.side, offset)
}

/// Clamp a block label's horizontal `offset` so its text of width `text_width`
/// stays within the block's horizontal extent, given the label's horizontal
/// anchor — [`Align::Center`] for the title, [`Align::Min`] (left) for the
/// type, [`Align::Max`] (right) for the tag. When the text is wider
/// than the block the label is pinned flush to its anchored edge.
pub fn clamp_label_offset(bbox: Rect, text_width: f32, offset: f32, h_align: Align) -> f32 {
    let slack = (bbox.width() - text_width).max(0.0);
    let (lo, hi) = match h_align {
        Align::Min => (0.0, slack),
        Align::Center => (-slack / 2.0, slack / 2.0),
        Align::Max => (-slack, 0.0),
    };
    offset.clamp(lo, hi)
}

/// The [`LabelSide`] a block label snaps to when its anchor is dragged to `y`:
/// the top third of the block is Top, the bottom third Bottom, the middle Center.
/// Shared by the live drag preview and the drag-commit so both agree.
pub fn label_side_for_y(bbox: Rect, y: f32) -> LabelSide {
    let third = bbox.height() / 3.0;
    if y < bbox.top() + third {
        LabelSide::Top
    } else if y > bbox.top() + 2.0 * third {
        LabelSide::Bottom
    } else {
        LabelSide::Center
    }
}

/// Placement of a block's type label. Mirrors [`block_title_position`] but is
/// **left-anchored** to the block's left edge, so the default (`offset == 0`,
/// `side == Top`) sits in the upper-left corner with the text baseline on the
/// top edge and the left edge flush with the block's.
fn type_anchor(bbox: Rect, side: LabelSide, offset: f32) -> (Pos2, Align2) {
    match side {
        LabelSide::Top => (bbox.left_top() + vec2(offset, 0.0), Align2::LEFT_BOTTOM),
        LabelSide::Center => (bbox.left_center() + vec2(offset, 0.0), Align2::LEFT_CENTER),
        LabelSide::Bottom => (bbox.left_bottom() + vec2(offset, 0.0), Align2::LEFT_TOP),
    }
}

pub fn block_type_position(bbox: Rect, type_label: &ShapeLabel<'_>) -> (Pos2, Align2) {
    type_anchor(bbox, type_label.side, type_label.offset)
}

/// Like [`block_type_position`], but clamps the horizontal offset so a type label
/// of width `text_width` stays within the block (pinning flush when wider). Used
/// at draw time so a later resize can't leave a stale offset drawing outside.
pub fn clamped_block_type_position(
    bbox: Rect,
    type_label: &ShapeLabel<'_>,
    text_width: f32,
) -> (Pos2, Align2) {
    let offset = clamp_label_offset(bbox, text_width, type_label.offset, Align::Min);
    type_anchor(bbox, type_label.side, offset)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn clamp_label_offset_keeps_each_anchor_within_the_block_width() {
        let bbox = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 40.0));
        // 40-wide label, 60 of slack. Center: ±30 around center.
        assert_eq!(clamp_label_offset(bbox, 40.0, 100.0, Align::Center), 30.0);
        assert_eq!(clamp_label_offset(bbox, 40.0, -100.0, Align::Center), -30.0);
        assert_eq!(clamp_label_offset(bbox, 40.0, 20.0, Align::Center), 20.0);
        // Left-anchored (type): flush-left at 0, slides right up to the full slack.
        assert_eq!(clamp_label_offset(bbox, 40.0, -100.0, Align::Min), 0.0);
        assert_eq!(clamp_label_offset(bbox, 40.0, 100.0, Align::Min), 60.0);
        // Right-anchored (tag): flush-right at 0, slides left down to -slack.
        assert_eq!(clamp_label_offset(bbox, 40.0, 100.0, Align::Max), 0.0);
        assert_eq!(clamp_label_offset(bbox, 40.0, -100.0, Align::Max), -60.0);
        // A label wider than the block can only sit flush to its anchor.
        assert_eq!(clamp_label_offset(bbox, 140.0, 50.0, Align::Center), 0.0);
        assert_eq!(clamp_label_offset(bbox, 140.0, 50.0, Align::Min), 0.0);
    }

    #[test]
    fn block_type_position_sits_at_the_upper_left_by_default() {
        let bbox = Rect::from_min_max(pos2(10.0, 20.0), pos2(110.0, 60.0));
        // The default type label: empty, top-side, no offset.
        let (pos, align) = block_type_position(bbox, &ShapeLabel::default());
        // Default type label is Top side, offset 0 → left-bottom anchored on the
        // block's top-left corner (text baseline on the top edge, left-flush).
        assert_eq!(pos, bbox.left_top());
        assert_eq!(align, Align2::LEFT_BOTTOM);
    }

    #[test]
    fn bottom_side_labels_hang_below_the_edge_growing_downward() {
        // A Bottom label mirrors the Top one: anchored on the block's bottom edge
        // with a TOP vertical align, so its text grows down and away from the rect
        // instead of back up over the bottom edge.
        let bbox = Rect::from_min_max(pos2(10.0, 20.0), pos2(110.0, 60.0));
        let bottom = |side| ShapeLabel {
            side,
            ..Default::default()
        };

        let (pos, align) = block_title_position(bbox, &bottom(LabelSide::Bottom));
        assert_eq!(pos, bbox.center_bottom());
        assert_eq!(align, Align2::CENTER_TOP);

        let (pos, align) = block_type_position(bbox, &bottom(LabelSide::Bottom));
        assert_eq!(pos, bbox.left_bottom());
        assert_eq!(align, Align2::LEFT_TOP);
    }

    fn label(side: LabelSide, offset: f32) -> ShapeLabel<'static> {
        ShapeLabel {
            side,
            offset,
            ..Default::default()
        }
    }

    /// A centered title anchored at `x` has its text spanning `±text_width/2`.
    fn centered_span(x: f32, text_width: f32) -> (f32, f32) {
        (x - text_width / 2.0, x + text_width / 2.0)
    }

    /// A left-anchored type label anchored at `x` has its text spanning `[x, x+w]`.
    fn left_span(x: f32, text_width: f32) -> (f32, f32) {
        (x, x + text_width)
    }

    #[test]
    fn resizing_narrower_reclamps_a_title_slid_to_the_wide_edge_back_inside() {
        let text_width = 40.0;
        let wide = Rect::from_min_max(pos2(0.0, 0.0), pos2(200.0, 40.0));
        let narrow = Rect::from_min_max(pos2(0.0, 0.0), pos2(80.0, 40.0));

        // Slide the title flush to the wide block's right edge, then persist that
        // raw offset and re-clamp it against the narrow block.
        let wide_offset = clamp_label_offset(wide, text_width, 1_000.0, Align::Center);
        let title = label(LabelSide::Center, wide_offset);

        let (raw_pos, _) = block_title_position(narrow, &title);
        let (clamped_pos, _) = clamped_block_title_position(narrow, &title, text_width);
        assert!(
            clamped_pos.x < raw_pos.x,
            "re-clamp must move the title strictly inward",
        );

        let (lo, hi) = centered_span(clamped_pos.x, text_width);
        assert!(lo >= narrow.left() && hi <= narrow.right());
    }

    #[test]
    fn resizing_narrower_reclamps_a_type_slid_to_the_wide_edge_back_inside() {
        let text_width = 40.0;
        let wide = Rect::from_min_max(pos2(0.0, 0.0), pos2(200.0, 40.0));
        let narrow = Rect::from_min_max(pos2(0.0, 0.0), pos2(80.0, 40.0));

        let wide_offset = clamp_label_offset(wide, text_width, 1_000.0, Align::Min);
        let type_label = label(LabelSide::Top, wide_offset);

        let (raw_pos, _) = block_type_position(narrow, &type_label);
        let (clamped_pos, _) = clamped_block_type_position(narrow, &type_label, text_width);
        assert!(
            clamped_pos.x < raw_pos.x,
            "re-clamp must move the type label strictly inward",
        );

        let (lo, hi) = left_span(clamped_pos.x, text_width);
        assert!(lo >= narrow.left() && hi <= narrow.right());
    }

    #[test]
    fn a_label_wider_than_the_block_pins_flush_for_every_side_and_anchor() {
        let narrow = Rect::from_min_max(pos2(10.0, 0.0), pos2(60.0, 40.0));
        let text_width = 200.0; // Wider than the 50-wide block.

        for side in [LabelSide::Top, LabelSide::Center, LabelSide::Bottom] {
            // A wide title pins flush to the horizontal center regardless of offset.
            let title = label(side, 500.0);
            let (pos, _) = clamped_block_title_position(narrow, &title, text_width);
            assert_eq!(pos.x, narrow.center().x);

            // A wide type label pins flush to the left edge regardless of offset.
            let type_label = label(side, 500.0);
            let (pos, _) = clamped_block_type_position(narrow, &type_label, text_width);
            assert_eq!(pos.x, narrow.left());
        }
    }
}