blockworx_editor/shape/

mod.rs

//! The geometry layer: where a shape's parts land on the canvas, how big
//! they are, and how they paint.
//!
//! Deliberately document-*agnostic*. Every type here is handed the entities
//! it draws — a block arrives with its pins, an image with its bytes, a text
//! box with its measured extent — so nothing in this module looks anything
//! up. The caller that knows the scope resolves those (see
//! [`Drawing`](crate::widget::drawing::Drawing)), which is also what keeps a
//! pin drawn as a boundary port and the same pin drawn as a stub on its
//! block from needing two data shapes.

use crate::theme::Style;
use blockworx_geom::{Pos2, Rect, Vec2};
use blockworx_paint::Renderer;

use blockworx_doc::{
    block_model::{Area, Asset, Pin, Text},
    geometry::GridSize,
    id::{AreaId, BlockId, ImageId, PinId, RouteId, TextId},
    values::LabelSide,
};

use crate::{shape::pin::PinSide, state::RenderMode};

pub mod area;
pub mod block;
pub mod image;
pub mod pin;
pub mod port;
pub mod text_box;

pub use block::BlockShape;
pub use image::Artwork;
pub use port::PortShape;
pub use text_box::TextShape;

/// Something the user can delete: a shape (child block or boundary port), a
/// route, a whole multi-selection of shapes, or a group of child-block pins.
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum Deletable {
    Shape(ShapeId),
    Route(RouteId),
    Shapes(Vec<ShapeId>),
    Pins(Vec<PinId>),
}

impl Deletable {
    /// The shapes this selection contains, or `None` for selections that aren't
    /// copyable as shapes — a bare route (its endpoints live outside the
    /// selection) or a group of pins (copied via `Action::CopyPins` instead).
    pub fn shapes(&self) -> Option<Vec<ShapeId>> {
        match self {
            Deletable::Shape(id) => Some(vec![*id]),
            Deletable::Shapes(ids) => Some(ids.clone()),
            Deletable::Route(_) | Deletable::Pins(_) => None,
        }
    }

    /// How many things this selection holds — the overlay's count prefix and
    /// the status chip's readout, answered once so the two corners of the
    /// frame cannot disagree about how much is selected.
    pub fn count(&self) -> usize {
        match self {
            Deletable::Shape(_) | Deletable::Route(_) => 1,
            Deletable::Shapes(ids) => ids.len(),
            Deletable::Pins(pins) => pins.len(),
        }
    }
}

/// A shape that carries an accent `role` the picker can target: a child block,
/// a boundary port, a route, a boundary area, or a text box.
#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum RoleTarget {
    Block(BlockId),
    Port(PinId),
    Route(RouteId),
    Area(AreaId),
    Text(TextId),
}

/// A unified ID that can refer to a child block (`BlockId`), a port-pin on the
/// current block (`PinId`), a free-floating text annotation (`TextId`), a
/// boundary area (`AreaId`), a free-floating background image
/// (`ImageId`), or a block's foreground icon (keyed by the owning `BlockId`).
#[derive(
    Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum ShapeId {
    Rect(BlockId),
    Port(PinId),
    Text(TextId),
    Area(AreaId),
    Image(ImageId),
    /// The icon owned by the block with this `BlockId` (at most one per block).
    Icon(BlockId),
}

impl ShapeId {
    /// The child block this id names, or `None` for every other kind —
    /// [`Self::Icon`] included, which names the block that *owns* the icon
    /// rather than the block itself.
    pub fn block(self) -> Option<BlockId> {
        match self {
            Self::Rect(id) => Some(id),
            Self::Port(_) | Self::Text(_) | Self::Area(_) | Self::Image(_) | Self::Icon(_) => None,
        }
    }

    pub fn is_block(self) -> bool {
        self.block().is_some()
    }

    /// Whether moving or resizing this shape can change routing. Only blocks
    /// (obstacles) and ports (route endpoints) take part in the routing graph;
    /// areas, text, and images are annotations, so manipulating them never
    /// needs a reroute — and they never block another shape's move either.
    pub fn affects_routing(self) -> bool {
        matches!(self, Self::Rect(_) | Self::Port(_))
    }

    /// Whether this shape is artwork: a free-floating image or a block icon.
    /// Artwork moves and resizes in free pixels — magnetically snapped to
    /// alignment guides and to its intrinsic aspect ratio — instead of on the
    /// grid pitch every other shape follows.
    pub fn is_artwork(self) -> bool {
        matches!(self, Self::Image(_) | Self::Icon(_))
    }
}

#[derive(Copy, Clone, Debug)]
pub struct PinLocation {
    pub side: PinSide,
    pub offset: f32,
}

impl From<(PinSide, f32)> for PinLocation {
    fn from(value: (PinSide, f32)) -> Self {
        PinLocation {
            side: value.0,
            offset: value.1,
        }
    }
}

/// A [`blockworx_doc::block_model::Label`] namespace resolved for drawing:
/// its four registers read out,
/// with the offset converted from the document's fixed-point to the world
/// pixels every anchor formula works in
/// ([`shape_label`](crate::edit::lower::shape_label) is the one conversion).
/// Borrowed and `Copy`, so a drag preview builds its shifted twin with a
/// struct update instead of cloning the name.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct ShapeLabel<'a> {
    pub name: &'a str,
    pub hidden: bool,
    pub side: LabelSide,
    pub offset: f32,
}

/// `BaseShape` is what every shape can answer without knowing the document:
/// where it sits, what its labels are, where its pins hang, and how it
/// paints. Writes are not here — they are commits, emitted by
/// [`crate::edit`] against the document the gesture read.
pub trait BaseShape {
    fn title(&self) -> Option<ShapeLabel<'_>> {
        None
    }
    fn type_label(&self) -> Option<ShapeLabel<'_>> {
        None
    }
    fn gui_rect(&self) -> Rect;
    fn constrain_resize_delta(&self, delta: Vec2) -> Vec2 {
        delta
    }
    fn pin(&self, id: PinId) -> Option<&Pin> {
        let _ = id;
        None
    }
    fn anchor_point_with_rect(&self, rect: Rect, id: PinId) -> Option<Pos2> {
        let _ = (rect, id);
        None
    }
    fn pin_position(&self, location: PinLocation) -> Option<Pos2> {
        let _ = location;
        None
    }
    /// The slot a dragged pin would snap to (its grid offset), or `None` if no
    /// free slot is available. Read-only: the drop's own write is
    /// [`crate::edit::geometry::move_pin`], and both resolve the same slot so
    /// the preview lands where the commit will.
    fn pin_drop_candidate(&self, pin_id: PinId, side: PinSide, raw_offset_px: f32) -> Option<u32> {
        let _ = (pin_id, side, raw_offset_px);
        None
    }
    fn pin_text_rect<R: Renderer>(&self, id: PinId, painter: &Style<'_, R>) -> Option<Rect> {
        let _ = (id, painter);
        None
    }
    /// Bounding box of a pin's `type` label (the smaller second line below the
    /// name), for hit-testing a double-click on the type. `None` for shapes
    /// without such a pin.
    fn pin_type_rect<R: Renderer>(&self, id: PinId, painter: &Style<'_, R>) -> Option<Rect> {
        let _ = (id, painter);
        None
    }
    /// Bounding box of a pin's `tag` label (drawn above the stub line), sized for
    /// an explicit `text`. `None` if the shape has no such pin. Callers pass the
    /// "+tag" placeholder for an empty tag so the prompt stays a hit/edit target.
    fn tag_text_rect_for<R: Renderer>(
        &self,
        id: PinId,
        text: &str,
        painter: &Style<'_, R>,
    ) -> Option<Rect> {
        let _ = (id, text, painter);
        None
    }
    /// Clickable hit region around a pin's stub (the red line).
    fn pin_stub_rect(&self, id: PinId) -> Option<Rect> {
        let _ = id;
        None
    }
    /// Render this shape. A block draws its own `tag` label from its
    /// decorations, so no external id is needed.
    fn render_ng<R: Renderer>(&self, mode: RenderMode, painter: &mut Style<'_, R>) {
        let _ = (mode, painter);
    }
    fn new_pin_locations(&self) -> Vec<PinLocation> {
        Vec::new()
    }
    fn title_anchor(&self) -> Option<Pos2> {
        None
    }
    fn type_anchor(&self) -> Option<Pos2> {
        None
    }
    fn resizable(&self) -> bool {
        false
    }
}

/// A borrowed reference to any shape, bundled with whatever the geometry
/// layer needs beside the entity itself: a block's pins, a port's own id, a
/// text box's measured extent, artwork's bytes. Because this is a concrete
/// enum (not a trait object), methods with generic parameters (e.g.
/// `with_pins`) work naturally — dispatch is via `match`, not a vtable.
pub enum ShapeRef<'a> {
    Block(BlockShape<'a>),
    Port(PortShape<'a>),
    Text(TextShape<'a>),
    Area(&'a Area),
    Image(Artwork<'a>),
}

impl<'a> ShapeRef<'a> {
    /// A free-floating text annotation with the extent it was last measured
    /// at, or `None` to fall back on the character-count estimate.
    pub fn text(text: &'a Text, extent: Option<GridSize>) -> Self {
        Self::Text(TextShape { text, extent })
    }

    /// A placed image or a block icon: the box it fills and the bytes behind
    /// its content hash, which the caller resolved from the document's asset
    /// table.
    pub fn artwork(rect: Rect, asset: Option<&'a Asset>) -> Self {
        Self::Image(Artwork { rect, asset })
    }

    pub fn gui_rect(&self) -> Rect {
        match self {
            Self::Block(b) => b.gui_rect(),
            Self::Port(p) => p.gui_rect(),
            Self::Text(t) => t.gui_rect(),
            Self::Area(c) => c.gui_rect(),
            Self::Image(s) => s.gui_rect(),
        }
    }
    /// `accents` is the derived pin-accent lookup, resolved by the caller
    /// (who knows the shape's scope); only ports consume it here — a block's
    /// pins draw in the deferred [`Self::render_pins_ng`] pass.
    pub fn render_ng<R: Renderer>(
        &self,
        accents: crate::presentation::ShapeAccents<'_>,
        mode: RenderMode,
        painter: &mut Style<'_, R>,
    ) {
        match self {
            Self::Block(b) => b.render_ng(mode, painter),
            Self::Port(p) => p.render_ng(accents, mode, painter),
            Self::Text(t) => t.render_ng(mode, painter),
            Self::Area(c) => c.render_ng(mode, painter),
            Self::Image(s) => s.render_ng(mode, painter),
        }
    }
    /// Draw only a block's deferred pin layer (see [`crate::widget::DrawingPasses`]).
    /// Only blocks have pins to layer over their icon; every other shape draws
    /// nothing.
    pub fn render_pins_ng<R: Renderer>(
        &self,
        accents: crate::presentation::ShapeAccents<'_>,
        mode: RenderMode,
        painter: &mut Style<'_, R>,
    ) {
        match self {
            Self::Block(b) => b.render_pins_ng(accents, mode, painter),
            Self::Port(_) | Self::Text(_) | Self::Area(_) | Self::Image(_) => {}
        }
    }
    pub fn with_pins(&self, mut f: impl FnMut(PinId, &'a Pin)) {
        match self {
            Self::Block(b) => b.pins.iter().for_each(|&(id, pin)| f(id, pin)),
            Self::Port(p) => f(p.id, p.pin),
            // Text boxes, areas, and images have no pins, so `f` is never called.
            Self::Text(_) | Self::Area(_) | Self::Image(_) => {}
        }
    }
    pub fn pin(&self, id: PinId) -> Option<&Pin> {
        match self {
            Self::Block(b) => b.pin(id),
            Self::Port(p) => p.pin(id),
            Self::Text(t) => t.pin(id),
            Self::Area(c) => c.pin(id),
            Self::Image(s) => s.pin(id),
        }
    }
    pub fn pin_text_rect<R: Renderer>(&self, id: PinId, painter: &Style<'_, R>) -> Option<Rect> {
        match self {
            Self::Block(b) => b.pin_text_rect(id, painter),
            Self::Port(p) => p.pin_text_rect(id, painter),
            Self::Text(t) => t.pin_text_rect(id, painter),
            Self::Area(c) => c.pin_text_rect(id, painter),
            Self::Image(s) => s.pin_text_rect(id, painter),
        }
    }
    pub fn pin_type_rect<R: Renderer>(&self, id: PinId, painter: &Style<'_, R>) -> Option<Rect> {
        match self {
            Self::Block(b) => b.pin_type_rect(id, painter),
            Self::Port(p) => p.pin_type_rect(id, painter),
            Self::Text(t) => t.pin_type_rect(id, painter),
            Self::Area(c) => c.pin_type_rect(id, painter),
            Self::Image(s) => s.pin_type_rect(id, painter),
        }
    }
    pub fn tag_text_rect_for<R: Renderer>(
        &self,
        id: PinId,
        text: &str,
        painter: &Style<'_, R>,
    ) -> Option<Rect> {
        match self {
            Self::Block(b) => b.tag_text_rect_for(id, text, painter),
            Self::Port(p) => p.tag_text_rect_for(id, text, painter),
            Self::Text(t) => t.tag_text_rect_for(id, text, painter),
            Self::Area(c) => c.tag_text_rect_for(id, text, painter),
            Self::Image(s) => s.tag_text_rect_for(id, text, painter),
        }
    }
    pub fn pin_stub_rect(&self, id: PinId) -> Option<Rect> {
        match self {
            Self::Block(b) => b.pin_stub_rect(id),
            Self::Port(p) => p.pin_stub_rect(id),
            Self::Text(t) => t.pin_stub_rect(id),
            Self::Area(c) => c.pin_stub_rect(id),
            Self::Image(s) => s.pin_stub_rect(id),
        }
    }
    pub fn anchor_point_with_rect(&self, rect: Rect, id: PinId) -> Option<Pos2> {
        match self {
            Self::Block(b) => b.anchor_point_with_rect(rect, id),
            Self::Port(p) => p.anchor_point_with_rect(rect, id),
            Self::Text(t) => t.anchor_point_with_rect(rect, id),
            Self::Area(c) => c.anchor_point_with_rect(rect, id),
            Self::Image(s) => s.anchor_point_with_rect(rect, id),
        }
    }
    pub fn pin_drop_candidate(
        &self,
        pin_id: PinId,
        side: PinSide,
        raw_offset_px: f32,
    ) -> Option<u32> {
        match self {
            Self::Block(b) => b.pin_drop_candidate(pin_id, side, raw_offset_px),
            Self::Port(p) => p.pin_drop_candidate(pin_id, side, raw_offset_px),
            Self::Text(t) => t.pin_drop_candidate(pin_id, side, raw_offset_px),
            Self::Area(c) => c.pin_drop_candidate(pin_id, side, raw_offset_px),
            Self::Image(s) => s.pin_drop_candidate(pin_id, side, raw_offset_px),
        }
    }
    pub fn title(&self) -> Option<ShapeLabel<'_>> {
        match self {
            Self::Block(b) => b.title(),
            Self::Port(p) => p.title(),
            Self::Text(t) => t.title(),
            Self::Area(c) => c.title(),
            Self::Image(s) => s.title(),
        }
    }
    pub fn type_label(&self) -> Option<ShapeLabel<'_>> {
        match self {
            Self::Block(b) => b.type_label(),
            Self::Port(p) => p.type_label(),
            Self::Text(t) => t.type_label(),
            Self::Area(c) => c.type_label(),
            Self::Image(s) => s.type_label(),
        }
    }
    pub fn title_anchor(&self) -> Option<Pos2> {
        match self {
            Self::Block(b) => b.title_anchor(),
            Self::Port(p) => p.title_anchor(),
            Self::Text(t) => t.title_anchor(),
            Self::Area(c) => c.title_anchor(),
            Self::Image(s) => s.title_anchor(),
        }
    }
    pub fn resizable(&self) -> bool {
        match self {
            Self::Block(b) => b.resizable(),
            Self::Port(p) => p.resizable(),
            Self::Text(t) => t.resizable(),
            Self::Area(c) => c.resizable(),
            Self::Image(s) => s.resizable(),
        }
    }
    pub fn constrain_resize_delta(&self, delta: Vec2) -> Vec2 {
        match self {
            Self::Block(b) => b.constrain_resize_delta(delta),
            Self::Port(p) => p.constrain_resize_delta(delta),
            Self::Text(t) => t.constrain_resize_delta(delta),
            Self::Area(c) => c.constrain_resize_delta(delta),
            Self::Image(s) => s.constrain_resize_delta(delta),
        }
    }
}