blockworx/widget/

document_ext.rs

//! Widget-layer geometry and structural extensions for [`Document`]. These work
//! in world (egui) coordinates and resolve shape geometry through [`BaseShape`],
//! so they live here rather than on the pure-data `Document` in `document`.

use egui::{Pos2, Rect};

use crate::document::{
    Block, Document, GridRect, GridSize, LineAnchor, TOP_BLOCK_DEFAULT_HEIGHT,
    TOP_BLOCK_DEFAULT_RECT, TOP_BLOCK_DEFAULT_WIDTH,
};
use crate::grid::{GridRectExt, snap_block_height_cells};
use crate::shape::BaseShape;
use crate::shape::port::PORT_PIN_ID;
use crate::store::{IdMapExt, RectId};

/// World-space geometry over a [`Document`], plus the one structural edit that
/// needs that geometry ([`wrap_top_in_new_parent`](DocumentExt::wrap_top_in_new_parent)).
pub trait DocumentExt {
    /// World-space bounding box enclosing block `id`'s interior shapes: its child
    /// block rects, its own boundary pins (drawn as ports), its text
    /// annotations, and its boundary comments. `None` when the block has no
    /// interior shapes.
    fn content_bounds(&self, id: RectId) -> Option<Rect>;

    /// Resolve a [`LineAnchor`] (interpreted in the context of the current block
    /// `current_id`) to its world position. `Port` reads the current block's own
    /// pin; `Pin { block, .. }` reads a globally-identified child block.
    fn anchor_pos(&self, current_id: RectId, anchor: LineAnchor) -> Option<Pos2>;

    /// Add a level above the whole document: mint a fresh parent block whose sole
    /// child is the current top, size the old top to its child-boundary rect so
    /// it reads as a child, and point [`Document::top_id`] at the new parent. Used
    /// by "Go Up" at the document root. The demoted block keeps all its own
    /// ids/pins/children/routes (ids are document-global, so nothing is remapped).
    fn wrap_top_in_new_parent(&mut self);
}

impl DocumentExt for Document {
    fn content_bounds(&self, id: RectId) -> Option<Rect> {
        let block = self.blocks.get(&id)?;
        self.child_blocks(id)
            .map(|(_, b)| b.inner.to_rect())
            .chain(block.pins.values().map(|p| p.rect.to_rect()))
            .chain(block.texts.values().map(|t| t.gui_rect()))
            .chain(block.comments.values().map(|c| c.inner.to_rect()))
            .reduce(egui::Rect::union)
    }

    fn anchor_pos(&self, current_id: RectId, anchor: LineAnchor) -> Option<Pos2> {
        match anchor {
            LineAnchor::Port(pid) => {
                let cur = self.blocks.get(&current_id)?;
                let p = cur.pins.get(&pid)?;
                p.anchor_point_with_rect(p.rect.to_rect(), PORT_PIN_ID)
            }
            LineAnchor::Pin { block, pin } => {
                let b = self.blocks.get(&block)?;
                b.anchor_point_with_rect(b.inner.to_rect(), pin)
            }
        }
    }

    fn wrap_top_in_new_parent(&mut self) {
        let old_top = self.top_id;
        let boundary = child_boundary_rect(self, old_top);
        if let Some(b) = self.blocks.get_mut(&old_top) {
            b.inner = boundary;
        }
        // The new parent must not reuse the default "top" name: the old root keeps
        // it, so two levels named "top" would make the nav breadcrumb ambiguous.
        let name = next_top_name(self);
        let mut parent = Block::default();
        parent.decorations.title.name = name;
        let new_id = self.blocks.insert_value(parent);
        if let Some(parent) = self.blocks.get_mut(&new_id) {
            parent.children.insert(old_top);
        }
        self.top_id = new_id;
    }
}

/// The lowest `top_{n}` (n ≥ 1) not already used as a block title, so each new
/// wrapped parent gets a distinct, stable name.
fn next_top_name(doc: &Document) -> String {
    // One more candidate than there are blocks, so at least one is always free;
    // the fallback keeps the search total instead of unwrapping.
    let last = doc.blocks.len() + 1;
    (1..=last)
        .map(|n| format!("top_{n}"))
        .find(|candidate| {
            !doc.blocks
                .values()
                .any(|b| b.decorations.title.name == *candidate)
        })
        .unwrap_or_else(|| format!("top_{}", last + 1))
}

/// The rect block `id` shows as once it is demoted to a child: the rect it
/// already has, made tall enough that every boundary pin fits inside. Its size
/// is *not* derived from what it contains — a block as large as the whole
/// drawing is unwieldy, and this one keeps whatever size the user gave it.
fn child_boundary_rect(doc: &Document, id: RectId) -> GridRect {
    let Some(block) = doc.blocks.get(&id) else {
        return TOP_BLOCK_DEFAULT_RECT;
    };
    let max_off = block.pins.values().map(|p| p.offset).max().unwrap_or(0);
    let min_h = 2 * (max_off + 2); // one slot of margin below the lowest pin
    let own = block.inner;
    // Documents written before top blocks were born with a size carry `w=0 h=0`,
    // which would demote to an invisible child.
    let width = if own.size.w == 0 {
        TOP_BLOCK_DEFAULT_WIDTH
    } else {
        own.size.w
    };
    let height = if own.size.h == 0 {
        TOP_BLOCK_DEFAULT_HEIGHT
    } else {
        own.size.h
    };
    GridRect::new(
        own.min,
        GridSize::new(width, snap_block_height_cells(height.max(min_h))),
    )
}

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

    #[test]
    fn repeated_wraps_give_each_new_parent_a_distinct_name() {
        let mut doc = Document::default(); // top is named "top"
        doc.wrap_top_in_new_parent();
        let first = doc
            .blocks
            .get(&doc.top_id)
            .unwrap()
            .decorations
            .title
            .name
            .clone();
        doc.wrap_top_in_new_parent();
        let second = doc
            .blocks
            .get(&doc.top_id)
            .unwrap()
            .decorations
            .title
            .name
            .clone();
        assert_eq!(first, "top_1");
        assert_eq!(second, "top_2");
        assert_ne!(first, second);
    }

    /// Going up over a drawing must not blow the demoted root up to the size of
    /// its contents: it keeps its own (default) width, small enough to resize.
    #[test]
    fn a_demoted_root_keeps_its_own_width_not_its_contents() {
        let mut doc = Document::default();
        let old_top = doc.top_id;
        doc.add_child(
            old_top,
            Block {
                inner: GridRect::new(GridPos::new(4, 4), GridSize::new(40, 10)),
                ..Block::default()
            },
        );
        // Precondition: the contents really are wider than the top block, so
        // content-derived sizing would be a visible difference.
        let content = doc.content_bounds(old_top).expect("the child block");
        let content_cells = GridRect::from_rect_snapped(content).size.w;
        assert!(content_cells > TOP_BLOCK_DEFAULT_WIDTH);

        doc.wrap_top_in_new_parent();

        let demoted = doc.block(old_top).expect("the demoted root");
        assert_eq!(demoted.inner.size.w, TOP_BLOCK_DEFAULT_WIDTH);
        let new_top = doc.block(doc.top_id).expect("the new parent");
        assert_eq!(new_top.inner.size.w, TOP_BLOCK_DEFAULT_WIDTH);
    }

    /// A `w=0 h=0` top (written before top blocks were born with a size) demotes
    /// to a visible child rather than an invisible sliver.
    #[test]
    fn a_degenerate_top_demotes_to_the_default_size() {
        let mut doc = Document::default();
        let old_top = doc.top_id;
        doc.block_mut(old_top).unwrap().inner = GridRect::default();
        assert_eq!(doc.block(old_top).unwrap().inner.size.w, 0);

        doc.wrap_top_in_new_parent();

        let demoted = doc.block(old_top).expect("the demoted root");
        assert_eq!(demoted.inner.size, TOP_BLOCK_DEFAULT_RECT.size);
    }
}