blockworx/derived/

mod.rs

//! Derived state: everything computed *from* the document that the
//! editor needs *beside* it — solver geometry, measurement caches,
//! propagated accents. Never authored, never undone, never persisted:
//! the document is authored state only, and this is where the rest
//! lives (editor-swap playbook, step 7).
//!
//! Owned by the app for the life of a document — rebuilt wholesale on
//! load/undo/restore, incrementally by the passes that used to write
//! the document — and threaded through
//! [`Drawing`](crate::widget::drawing::Drawing) like the spatial index,
//! mutably, because the solver passes that fill it run inside `Drawing`
//! methods.

pub mod route;

pub use route::{Crossing, LocAndDirection, RouteGeometry};

use ahash::HashMap;

use crate::document::model::Generation;
use crate::document::{Document, GridSize, LineAnchor};
use crate::store::{PinId, RectId, RouteId, TextId};

#[derive(Default)]
pub struct Derived {
    pub pin_accents: PinAccents,
    pub text_extents: TextExtents,
    /// Solved geometry per owning block, then per route. A missing entry is a
    /// route that has not been materialized — nothing to draw or hit-test yet.
    pub routes: ScopedRoutes,
}

/// Route geometry keyed by the owning block first. The outer key is
/// load-bearing, not organizational: `RouteId`s are minted per block map, so
/// two scopes' routes share ids, and a flat map would let each materialized
/// scope overwrite the last one's geometry — the same hazard [`PinAccents`]
/// documents for `PinId`.
#[derive(Default)]
pub struct ScopedRoutes {
    map: HashMap<RectId, HashMap<RouteId, RouteGeometry>>,
}

impl ScopedRoutes {
    /// The geometry of `block`'s routes, if any were materialized.
    pub fn scope(&self, block: RectId) -> Option<&HashMap<RouteId, RouteGeometry>> {
        self.map.get(&block)
    }

    /// The geometry map of `block`'s routes, created empty on first touch.
    pub fn scope_mut(&mut self, block: RectId) -> &mut HashMap<RouteId, RouteGeometry> {
        self.map.entry(block).or_default()
    }

    /// One route's solved geometry within its owning block.
    pub fn get(&self, block: RectId, route: RouteId) -> Option<&RouteGeometry> {
        self.scope(block)?.get(&route)
    }

    /// Drop a deleted block's geometry wholesale. Also guards id reuse: the
    /// flat map re-mints a deleted `RectId`, and the new block must not
    /// inherit the dead one's scope.
    pub fn remove_scope(&mut self, block: RectId) {
        self.map.remove(&block);
    }
}

impl Derived {
    /// Bring the accent propagation up to date with `document`. Gated on
    /// the generation stamp, so the once-per-borrow call sites stay
    /// cheap.
    pub fn refresh_accents(&mut self, document: &Document) {
        if self.pin_accents.generation == Some(document.generation()) {
            return;
        }
        self.pin_accents.recompute(document);
    }
}

/// Route-role propagation onto pin stubs: a wire's accent colors the
/// pins it lands on. Derived fresh from the routes — the last route at
/// a level to touch an anchor wins, including a plain (`None`) role —
/// where the document used to store the propagation and let it go
/// stale. Keys carry the owning block because a `PinId` is unique per
/// block, not per document.
#[derive(Default)]
pub struct PinAccents {
    generation: Option<Generation>,
    /// A child block's pin, as colored by its parent level's routes.
    pin: HashMap<(RectId, PinId), Option<u8>>,
    /// A port's own pin, as colored by the port's level's routes.
    port_pin: HashMap<(RectId, PinId), Option<u8>>,
}

impl PinAccents {
    /// The stub accent of `pin` drawn as part of child block `block`.
    pub fn pin(&self, block: RectId, pin: PinId) -> Option<u8> {
        self.pin.get(&(block, pin)).copied().flatten()
    }

    /// The stub accent of `pin` drawn as part of a port on `level`.
    pub fn port_pin(&self, level: RectId, pin: PinId) -> Option<u8> {
        self.port_pin.get(&(level, pin)).copied().flatten()
    }

    fn recompute(&mut self, document: &Document) {
        self.pin.clear();
        self.port_pin.clear();
        for (&level, block) in document.blocks.iter() {
            for (_, route) in &block.routes {
                for anchor in [route.start(), route.finish()] {
                    match anchor {
                        LineAnchor::Pin { block, pin } => {
                            self.pin.insert((block, pin), route.role());
                        }
                        LineAnchor::Port(pin) => {
                            self.port_pin.insert((level, pin), route.role());
                        }
                    }
                }
            }
        }
        self.generation = Some(document.generation());
    }
}

/// Galley-measured text-box extents, keyed by the text they were
/// measured for: an entry is consulted only while the box still holds
/// that text, so the cache can never serve a stale rect — undo, load,
/// or restore leave it self-invalidated and readers fall back to the
/// character-count estimate until the box is next edited.
#[derive(Default)]
pub struct TextExtents {
    map: HashMap<TextId, (String, GridSize)>,
}

impl TextExtents {
    pub fn set(&mut self, id: TextId, text: String, size: GridSize) {
        self.map.insert(id, (text, size));
    }

    /// The measured extent, if it was measured for exactly `current_text`.
    pub fn valid_for(&self, id: TextId, current_text: &str) -> Option<GridSize> {
        self.map
            .get(&id)
            .filter(|(text, _)| text == current_text)
            .map(|&(_, size)| size)
    }
}

/// The accent lookup for one shape's pins, resolved by a caller that
/// knows the shape's id: a block's pins read the child-pin view, a
/// port's pin reads the port view at its own level.
#[derive(Clone, Copy)]
pub struct ShapeAccents<'a> {
    owner: RectId,
    accents: &'a PinAccents,
}

impl<'a> ShapeAccents<'a> {
    pub fn new(owner: RectId, accents: &'a PinAccents) -> Self {
        Self { owner, accents }
    }

    pub fn pin(&self, pin: PinId) -> Option<u8> {
        self.accents.pin(self.owner, pin)
    }

    pub fn port_pin(&self, pin: PinId) -> Option<u8> {
        self.accents.port_pin(self.owner, pin)
    }
}