blockworx/tools/

block_edit.rs

//! The block-edit tab cycle.
//!
//! When any of a child block's text fields is being edited, Tab walks through the
//! whole block in a stable order — name, type, then each pin's name, type, and
//! tag — and Esc cancels back to the selected block. This module owns the ordered
//! set of fields and the step/build helpers; the rename tools call into it. A
//! locked block's type isn't editable, so Tab skips it (see `edit_cycle`).

use crate::{
    shape::{
        ShapeId,
        pin::{PinSide, slot},
    },
    tools::{
        RenameBlockType, RenamePin, RenameTitle, RetypePin,
        rename_pin::Field,
        tool::{Action, Tool},
    },
    widget::drawing::Drawing,
};
use blockworx_doc::{
    geometry::PinSlot,
    id::{BlockId, PinId},
};

/// One editable text field of a block.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum EditTarget {
    Name,
    Type,
    PinName(PinId),
    PinType(PinId),
    PinTag(PinId),
}

/// The block's editable fields in tab order: name, type, then each pin — all West
/// (left) pins top-to-bottom, then all East (right) pins. Each pin's three fields
/// run left-to-right across the pin: a West pin's tag sits outboard to the left of
/// its labels (tag → name → type), an East pin's tag outboard to the right (name →
/// tag → type). The subtitle (type) comes last either way. The block's own type
/// field is dropped on a locked block, which can't edit it, so Tab steps straight
/// from name to the first pin.
pub fn edit_cycle(data: &Drawing<'_>, block: BlockId) -> Vec<EditTarget> {
    let id = ShapeId::Rect(block);
    let Some(shape) = data.shape(id) else {
        return Vec::new();
    };
    let mut pins: Vec<(PinId, PinSlot)> = Vec::new();
    shape.with_pins(|pin_id, pin| pins.push((pin_id, slot(pin))));
    pins.sort_by_key(|(_, slot)| (slot.side != PinSide::West, slot.offset));
    let mut targets = vec![EditTarget::Name];
    if !data.shape_owner_locked(id) {
        targets.push(EditTarget::Type);
    }
    for (pin_id, slot) in pins {
        let (name, tag, ty) = (
            EditTarget::PinName(pin_id),
            EditTarget::PinTag(pin_id),
            EditTarget::PinType(pin_id),
        );
        match slot.side {
            PinSide::West => targets.extend([tag, name, ty]),
            PinSide::East => targets.extend([name, tag, ty]),
        }
    }
    targets
}

/// The field after `current` in `block`'s cycle, wrapping around to the start.
pub fn next_target(data: &Drawing<'_>, block: BlockId, current: EditTarget) -> Option<EditTarget> {
    let cycle = edit_cycle(data, block);
    let idx = cycle.iter().position(|t| *t == current)?;
    Some(cycle[(idx + 1) % cycle.len()])
}

/// Build the editor tool for `target` on child block `block`.
pub fn tool_for_target(data: &Drawing, block: BlockId, target: EditTarget) -> Option<Tool> {
    match target {
        EditTarget::Name => RenameTitle::new_with_shape(data, ShapeId::Rect(block)).map(Into::into),
        EditTarget::Type => RenameBlockType::new_with_rect(data, block).map(Into::into),
        EditTarget::PinName(p) => RenamePin::new_with_anchor(data, p, Field::Name).map(Into::into),
        EditTarget::PinType(p) => RetypePin::new_with_anchor(data, p).map(Into::into),
        EditTarget::PinTag(p) => RenamePin::new_with_anchor(data, p, Field::Tag).map(Into::into),
    }
}

/// Switch to editing the field after `current` in child block `block`'s cycle.
pub fn advance(data: &Drawing, block: BlockId, current: EditTarget) -> Option<Action> {
    let next = next_target(data, block, current)?;
    tool_for_target(data, block, next).map(Action::SwitchTool)
}

#[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, pin_id},
        opcode::OpCodes,
    };
    use blockworx_geom::{Rect, pos2};

    fn block_120x300(n: u32) -> OpCodes {
        fx::block_in(
            n,
            Scope::Root,
            Rect::from_min_max(pos2(0.0, 0.0), pos2(120.0, 300.0)),
        )
    }

    #[test]
    fn cycle_is_name_type_then_west_pins_then_east_with_side_aware_field_order() {
        let block = block_id(1);
        // Added out of visual order to exercise the (side, offset) sort.
        let (e_top, w_bot, w_top, e_bot) = (pin_id(2), pin_id(3), pin_id(4), pin_id(5));
        let mut scene = Scene::new(vec![
            block_120x300(1),
            fx::pin(2, 1, PinSide::East, 0),
            fx::pin(3, 1, PinSide::West, 1),
            fx::pin(4, 1, PinSide::West, 0),
            fx::pin(5, 1, PinSide::East, 1),
        ]);
        let data = scene.drawing();

        let mut expected = vec![EditTarget::Name, EditTarget::Type];
        // West pins (top-down): tag, name, type.
        for p in [w_top, w_bot] {
            expected.extend([
                EditTarget::PinTag(p),
                EditTarget::PinName(p),
                EditTarget::PinType(p),
            ]);
        }
        // East pins (top-down): name, tag, type.
        for p in [e_top, e_bot] {
            expected.extend([
                EditTarget::PinName(p),
                EditTarget::PinTag(p),
                EditTarget::PinType(p),
            ]);
        }
        assert_eq!(edit_cycle(&data, block), expected);
    }

    #[test]
    fn next_target_wraps_from_last_pin_field_back_to_name() {
        let (block, p) = (block_id(1), pin_id(2));
        let mut scene = Scene::new(vec![block_120x300(1), fx::pin(2, 1, PinSide::West, 0)]);
        let data = scene.drawing();
        // Block field order is name → type, then the pins.
        assert_eq!(
            next_target(&data, block, EditTarget::Name),
            Some(EditTarget::Type)
        );
        // West pin field order is tag → name → type.
        assert_eq!(
            next_target(&data, block, EditTarget::Type),
            Some(EditTarget::PinTag(p))
        );
        assert_eq!(
            next_target(&data, block, EditTarget::PinTag(p)),
            Some(EditTarget::PinName(p))
        );
        // The pin's type is the final field, so it wraps back to the block name.
        assert_eq!(
            next_target(&data, block, EditTarget::PinType(p)),
            Some(EditTarget::Name)
        );
    }

    #[test]
    fn locked_block_drops_type_from_the_cycle() {
        let block = block_id(1);
        let mut scene = Scene::new(vec![block_120x300(1), fx::locked(1)]);
        {
            let data = scene.drawing();
            // The block's own type is frozen on a locked block: it's absent from the
            // cycle, which (with no pins) is just the name.
            assert!(!edit_cycle(&data, block).contains(&EditTarget::Type));
            assert_eq!(edit_cycle(&data, block), vec![EditTarget::Name]);
        }
        // Unlocking restores the type step after the name.
        scene.apply(vec![fx::unlocked(1)]);
        let data = scene.drawing();
        assert_eq!(
            next_target(&data, block, EditTarget::Name),
            Some(EditTarget::Type)
        );
    }
}