blockworx/widget/

clipboard.rs

//! Copy, cut, and paste, as the drawing surface sees them.
//!
//! The payload model itself lives in [`crate::edit::clipboard`] — a value
//! snapshot of the copied closure with the gesture that made it, versioned
//! as `Clipboard::V2` and carried over the OS clipboard as JSON. This module is the [`Drawing`] side: which
//! selection a gesture copied, where a paste lands, and the emitter call each
//! turns into. Nothing here decides *what* a copy contains — that is the
//! delete closure's own walk, shared so a cut and a delete cascade agree.

use blockworx_doc::{
    block_model::Label,
    commit::Commit,
    document::{DocIndex, Document},
    geometry::GridVec,
    id::{BlockId, PinId},
    opcode::{Crud, OpCodes},
};
use blockworx_geom::Pos2;
use blockworx_store::doc::DocumentNonce;

use crate::grid::grid_point;
use crate::{
    edit::{
        clipboard::{Clipboard, Paste, PasteTarget, PinPaste, Snapshot},
        delete::Target,
        geometry::Shape,
    },
    shape::ShapeId,
    widget::drawing::Drawing,
};

/// The whole-cell diagonal a targetless paste lands at, so a duplicate never
/// hides the original it was copied from.
const UNTARGETED_OFFSET: GridVec = GridVec::new(2, 2);

/// Whether `text` is one of our clipboard payloads rather than plain text to
/// insert into a focused editor — a copied selection, or a whole exported
/// document (D19).
pub fn is_object_clipboard(text: &str) -> bool {
    Clipboard::from_json(text).is_some() || crate::import::from_clipboard(text).is_some()
}

/// The entity a copied shape names. An icon has none: it is a value on its
/// block, and travels with it.
fn copy_target(id: ShapeId) -> Option<Target> {
    Some(match id {
        ShapeId::Rect(id) => Target::Block(id),
        ShapeId::Port(id) => Target::Pin(id),
        ShapeId::Text(id) => Target::Text(id),
        ShapeId::Area(id) => Target::Area(id),
        ShapeId::Image(id) => Target::Image(id),
        ShapeId::Icon(_) => return None,
    })
}

/// What the tools name a pasted root.
fn pasted_shape(shape: Shape) -> ShapeId {
    match shape {
        Shape::Block(id) => ShapeId::Rect(id),
        Shape::Port(id) => ShapeId::Port(id),
        Shape::Text(id) => ShapeId::Text(id),
        Shape::Area(id) => ShapeId::Area(id),
        Shape::Image(id) => ShapeId::Image(id),
        Shape::Icon(id) => ShapeId::Icon(id),
    }
}

impl Drawing<'_> {
    /// The value snapshot of `shapes` — each with the subtree it owns, the
    /// wires landing on any of their pins, and those wires' labels. `None`
    /// when the selection holds nothing copyable.
    pub fn copy_selection(&self, shapes: &[ShapeId]) -> Option<Clipboard> {
        let targets: Vec<Target> = shapes.iter().filter_map(|&id| copy_target(id)).collect();
        let clip = crate::edit::clipboard::copy(&self.indexed(), &targets);
        (!clip.snapshot().is_empty()).then_some(clip)
    }

    /// The value snapshot of a pin selection — the payload a paste slots onto
    /// another block's boundary.
    pub fn copy_pins(&self, pins: &[PinId]) -> Option<Clipboard> {
        let targets: Vec<Target> = pins.iter().copied().map(Target::Pin).collect();
        let clip = crate::edit::clipboard::copy(&self.indexed(), &targets);
        (!clip.snapshot().pins.is_empty()).then(|| clip.into_pins())
    }

    /// Copy `shapes`, then delete them — one commit, so the cut and the
    /// cascade it implies undo together. What the delete declines the copy
    /// declines too, which is what makes the paste that follows a *move*.
    ///
    /// `from` is the session document the cut is coming out of: the paste
    /// that completes it keeps its ids only where it lands back there.
    pub fn cut_selection(&mut self, shapes: &[ShapeId], from: DocumentNonce) -> Option<Clipboard> {
        let targets: Vec<Target> = shapes.iter().filter_map(|&id| copy_target(id)).collect();
        let mut clip = None;
        self.author("cut_selection", |indexed, sink| {
            clip = Some(crate::edit::clipboard::cut(indexed, &targets, from, sink));
        });
        clip.filter(|clip| !clip.snapshot().is_empty())
    }

    /// Copy a pin selection, then delete it — the pin half of a cut.
    pub fn cut_pins(&mut self, pins: &[PinId], from: DocumentNonce) -> Option<Clipboard> {
        let targets: Vec<Target> = pins.iter().copied().map(Target::Pin).collect();
        let mut clip = None;
        self.author("cut_pins", |indexed, sink| {
            clip = Some(crate::edit::clipboard::cut(indexed, &targets, from, sink));
        });
        clip.filter(|clip| !clip.snapshot().pins.is_empty())
            .map(Clipboard::into_pins)
    }

    /// Insert `clip` into this scope, returning the roots so the caller can
    /// select them. A payload this document's own cut made, none of whose
    /// sources it still holds, is the cut this paste completes and moves in
    /// place; anything else duplicates.
    ///
    /// `into` is the session document being pasted into — a paste into any
    /// other document mints, however free the ids look.
    ///
    /// `target_top_left` lands the group's own top-left corner there; with no
    /// target the group is offset diagonally so it does not hide its source.
    pub fn paste_snapshot(
        &mut self,
        clip: &Clipboard,
        into: DocumentNonce,
        target_top_left: Option<Pos2>,
    ) -> Vec<ShapeId> {
        let snapshot = clip.snapshot();
        let offset = match (target_top_left, snapshot.origin()) {
            (Some(target), Some(origin)) => {
                let target = grid_point(target);
                GridVec::new(target.x - origin.x, target.y - origin.y)
            }
            _ => UNTARGETED_OFFSET,
        };
        let scope = self.current_scope();
        let mut ids = self.ids();
        let mut roots = Vec::new();
        self.author("paste", |indexed, sink| {
            roots = crate::edit::clipboard::paste(
                indexed,
                Paste {
                    clip,
                    into,
                    target: PasteTarget { scope, offset },
                },
                &mut ids,
                sink,
            );
        });
        roots.into_iter().map(pasted_shape).collect()
    }

    /// Paste copied pins onto `owner`'s boundary, each at the next free slot,
    /// growing the block until they fit. A frozen interface takes none.
    pub fn paste_pins(&mut self, snapshot: &Snapshot, owner: crate::path::Scope) -> Vec<PinId> {
        let mut ids = self.ids();
        let mut pasted = Vec::new();
        self.author("paste_pins", |indexed, sink| {
            pasted = crate::edit::clipboard::paste_pins(
                indexed,
                PinPaste {
                    pins: &snapshot.pins,
                    owner,
                },
                &mut ids,
                sink,
            );
        });
        pasted
    }
}

/// A whole document as a clipboard payload: everything its **root scope**
/// holds, with the block `top` sits under titled `title` (D19). Import and
/// the clipboard paste of an exported document both go through here, so "the
/// document appears in the active scope" is an ordinary paste — fresh ids,
/// one gesture, undoable — rather than a second merge path.
///
/// The root scope, not `top`'s subtree: `top` names the level the editor
/// opens on, which is not always the outermost block — a document wrapped
/// before `top` was re-pointed, or one holding a block drawn beside its
/// sheet, keeps live blocks outside it, and following `top` would leave them
/// behind without saying so.
///
/// The file is seeded onto an empty document as the commit that creates
/// it, so an import refuses exactly what the fold refuses.
pub fn block_from_document(parsed: &Document, title: &str) -> Option<Clipboard> {
    let mut ops = parsed.creating_commit("Imported a diagram")?.ops().to_vec();
    retitle_outermost(
        &mut ops,
        outermost_ancestor(parsed, parsed.title_block().top),
        title,
    );
    let doc = Document::default()
        .try_apply(&Commit::new("Imported a diagram".into(), ops))
        .ok()?;
    let mut index = DocIndex::of(&doc);
    let indexed = index.view(&doc);
    let clip = crate::edit::clipboard::copy(&indexed, &root_contents(&indexed));
    (!clip.snapshot().is_empty()).then_some(clip)
}

/// Everything the document root holds, as copy targets. Its own boundary
/// ports are not among them: they name a boundary the insert has no host
/// for, so they are reported rather than silently slotted onto whatever
/// block the paste lands in.
fn root_contents(indexed: &blockworx_doc::document::IndexedDocument<'_>) -> Vec<Target> {
    let Some(root) = indexed.index.scope(BlockId::NULL) else {
        return Vec::new();
    };
    if !root.pins.is_empty() {
        tracing::warn!(
            "{} boundary port(s) of the inserted diagram have no boundary to join",
            root.pins.len(),
        );
    }
    root.children
        .iter()
        .map(|&id| Target::Block(id))
        .chain(root.texts.iter().map(|&id| Target::Text(id)))
        .chain(root.areas.iter().map(|&id| Target::Area(id)))
        .chain(root.images.iter().map(|&id| Target::Image(id)))
        .collect()
}

/// Name the block a reader ends up holding — the outermost ancestor of the
/// document's `top` — after the document itself. A fresh label rather than
/// an edit of the one there: a top block whose title was hidden — which a
/// sheet's usually is — would otherwise arrive as an anonymous rectangle.
fn retitle_outermost(ops: &mut [OpCodes], outermost: BlockId, title: &str) {
    for op in ops {
        if let OpCodes::Block(id, Crud::Create(block)) = op
            && *id == outermost
        {
            block.title = Label {
                name: title.to_owned(),
                ..Label::default()
            };
        }
    }
}

/// The outermost block `id` sits under. Bounded by the block count so a
/// file naming a parent cycle — which the fold refuses later — terminates.
fn outermost_ancestor(parsed: &Document, id: BlockId) -> BlockId {
    let mut current = id;
    for _ in 0..parsed.blocks().count() {
        match parsed.block(&current).map(|block| block.parent) {
            Some(parent) if parent != BlockId::NULL => current = parent,
            _ => break,
        }
    }
    current
}