Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

28.0 KB
Raw Blame
//! Placing files off the UI thread (desktop): a file the user places (the Place dialog's OK, a file
//! dropped on the canvas, the OK of the PDF, DXF and text import options Place asks for) is read and
//! decoded on a thread that reads one file at a time while the status bar shows it, and is placed in
//! the document it was placed in once it is ready, as it would be at once: the same object, undo
//! step, selection and errors. The files the Place dialog loads the place cursor with are read, and
//! their thumbnails made, the same way, and so is the file each click or drag of the place cursor
//! places. A Paste the user gives decodes another app's bitmap on the same thread, and runs once it
//! is decoded ([`adopt_for_paste`]). Files are read and placed in the order they were started.
//! `file.place`, `file.place.queue` and `edit.paste*` from MCP and scripts run at once, and so does
//! every place and paste on wasm (no threads), with `VECTORCRAFT_SYNC_OPEN` set, and in unit tests
//! that do not set `off_the_ui_thread` ([`available`]).

use std::collections::HashMap;
use std::sync::mpsc::{Receiver, Sender, TryRecvError, channel};
use std::sync::{Arc, Mutex};

use serde_json::{Value, json};
use vectorcraft_engine::cmd::clipboard::{Clipboard, Flavour, ImageRead, read_image};
use vectorcraft_engine::cmd::place::{PlaceRead, QueueRead};
use vectorcraft_engine::file_access::ScopeHandle;

use crate::VectorcraftApp;

/// What was read: one file to place, the files to load the place cursor with, or a bitmap to paste.
enum Read {
    Place(Box<PlaceRead>),
    Queue(QueueRead),
    Paste(Box<Paste>),
}

/// A paste whose bitmap was decoded off the UI thread ([`adopt_for_paste`]).
struct Paste {
    /// The paste command and its params.
    id: String,
    params: Value,
    /// What it pastes (`None`: a bitmap the host converts couldn't be converted, or the paste
    /// waited behind another one without a bitmap of its own, and it takes the internal clipboard
    /// as it was when the paste started, as at once).
    pasted: Option<Pasted>,
    /// The view's center when the paste started, which the pasted objects are centered on.
    center: Option<[f64; 2]>,
    /// The objects selected when the paste started, which Paste in Front and Paste in Back paste
    /// next to (`None`: the paste follows an earlier one of its chain, and takes the selection
    /// that one left, [`Chain::left`]).
    selection: Option<Vec<vectorcraft_doc::NodeId>>,
    /// The number of its chain in [`Placing::chains`].
    chain: u64,
    /// Where new art went when the paste started, which is where the paste goes.
    insertion: Insertion,
    /// The latest Copy or Cut when the paste started ([`crate::sysclip::Publishing::latest`]).
    copied: u64,
    /// The internal clipboard when the paste started, which it pastes when [`Self::pasted`] is
    /// `None`.
    clipboard: Clipboard,
}

/// Where new art goes in the active document: the current layer, the isolated group or object, and
/// the drawing mode with the object Draw Inside draws into.
#[derive(Clone, PartialEq)]
struct Insertion {
    layer: Option<vectorcraft_doc::NodeId>,
    isolation: Option<vectorcraft_doc::NodeId>,
    draw_mode: vectorcraft_engine::DrawMode,
    draw_inside: Option<vectorcraft_doc::NodeId>,
}

impl Insertion {
    /// Where new art goes in `app`'s active document now.
    fn of(app: &VectorcraftApp) -> Option<Self> {
        let st = app.session.doc().ok()?;
        Some(Self { layer: st.active_layer, isolation: st.isolation, draw_mode: app.session.draw_mode, draw_inside: app.session.draw_inside })
    }

    /// Make it where new art goes in `app`'s active document → where new art went before.
    fn set(self, app: &mut VectorcraftApp) -> Option<Self> {
        let st = app.session.doc_mut().ok()?;
        let (layer, isolation) = (std::mem::replace(&mut st.active_layer, self.layer), std::mem::replace(&mut st.isolation, self.isolation));
        let draw_mode = std::mem::replace(&mut app.session.draw_mode, self.draw_mode);
        let draw_inside = std::mem::replace(&mut app.session.draw_inside, self.draw_inside);
        Some(Self { layer, isolation, draw_mode, draw_inside })
    }

    /// Put back each part of `self` (where new art went before [`Self::set`] set `started`) that
    /// differs from `started`, what the user changed meanwhile; a part the paste itself changed
    /// stays as the paste left it.
    fn restore_changed(self, started: &Self, app: &mut VectorcraftApp) {
        if let Ok(st) = app.session.doc_mut() {
            if self.layer != started.layer {
                st.active_layer = self.layer;
            }
            if self.isolation != started.isolation {
                st.isolation = self.isolation;
            }
        }
        if self.draw_mode != started.draw_mode {
            app.session.draw_mode = self.draw_mode;
        }
        if self.draw_inside != started.draw_inside {
            app.session.draw_inside = self.draw_inside;
        }
    }
}

/// Pastes decoded off the UI thread that follow each other in one document: each was given while the
/// one before waited, with the selection and the insertion context that one started with or, once
/// it ran, left.
struct Chain {
    /// The selection and the insertion context a paste given now must have to join the chain.
    context: (Vec<vectorcraft_doc::NodeId>, Insertion),
    /// The selection the chain's latest paste left, which the next one takes.
    left: Option<Vec<vectorcraft_doc::NodeId>>,
    /// How many of its pastes wait.
    waiting: usize,
}

/// What a paste whose bitmap was decoded off the UI thread pastes.
enum Pasted {
    /// The bitmap's type and the image read from it.
    Image(&'static str, Result<ImageRead, String>),
    /// Another flavour: the text that names the picture, when the picture couldn't be made.
    Flavour(Flavour),
}

/// Files being read for Place.
pub struct Pending {
    /// The file's name ("photo.tif"; the names joined with ", " for the place cursor's files).
    pub(crate) name: String,
    /// What the status bar shows ("Placing photo.tif").
    pub label: String,
    /// The document they are placed in ([`vectorcraft_engine::DocState::uid`]).
    doc: u64,
    /// Whether the file was dropped on the canvas (its messages say so, as
    /// [`crate::place::drop_files`]'s do).
    dropped: bool,
    /// Whether it is a paste's bitmap ([`adopt_for_paste`]) rather than a file.
    paste: bool,
    /// The number of the paste's chain ([`Placing::chains`]).
    chain: Option<u64>,
    done: Receiver<Result<Read, String>>,
}

/// A read waiting for the thread that reads the files.
type Job = Box<dyn FnOnce() + Send>;

/// The files being read for Place, in the order they were started.
#[derive(Default)]
pub struct Placing {
    pub pending: Vec<Pending>,
    /// A deferred paste awaiting its own Swatch Conflict dialog.
    swatch_paste: Option<PendingSwatch>,
    /// Set by unit tests whose app reads the files the user places off the UI thread.
    pub(crate) off_the_ui_thread: bool,
    /// Set while [`crate::menus::invoke`] runs a Paste the user gave.
    pub(crate) for_user: bool,
    /// Set while a paste whose bitmap was converted off the UI thread runs: it takes the internal
    /// clipboard as it is.
    adopted: bool,
    /// The chains of pastes decoded off the UI thread that have pastes waiting, by number.
    chains: HashMap<u64, Chain>,
    /// For each document, the number of its latest chain, which a paste given there may join.
    latest_chain: HashMap<u64, u64>,
    /// The number the next chain takes.
    next_chain: u64,
    /// The thread that reads the files, one at a time in the order they were started: started with
    /// the first read, it ends when the app does.
    reader: Option<Sender<Job>>,
    /// Unit tests: how many reads run now, and the most that ran at once.
    #[cfg(test)]
    pub(crate) reading: std::sync::Arc<[std::sync::atomic::AtomicUsize; 2]>,
}

struct PendingSwatch {
    clipboard: Clipboard,
    insertion: Insertion,
    selection: Vec<vectorcraft_doc::NodeId>,
    doc: u64,
    chain: u64,
}

/// Does `app` read a file the user places off the UI thread? Where documents open off it
/// ([`crate::opening::available`]), and in the unit tests that set `off_the_ui_thread`.
pub fn available(app: &VectorcraftApp) -> bool {
    app.placing.off_the_ui_thread || crate::opening::available()
}

/// `file.place` with `p` for the active document, its file read and decoded off the UI thread
/// ([`vectorcraft_engine::Session::prepare_place`], [`vectorcraft_engine::cmd::place::PlaceJob::read`])
/// → `{background: true, status}`; `dropped` when it was dropped on the canvas. The params are
/// checked here first, so a bad one is an error at once. When no thread could start, the file is
/// placed at once → `file.place`'s reply.
pub fn start(app: &mut VectorcraftApp, p: &Value, dropped: bool) -> Result<Value, String> {
    let job = app.session.prepare_place(p).map_err(|e| e.to_string())?;
    let name = job.name();
    let started = spawn(app, name.clone(), name, dropped, move || job.read().map(|r| Read::Place(Box::new(r))).map_err(|e| e.to_string()))?;
    started.map_or_else(
        || {
            let r = app.session.execute("file.place", p).map_err(|e| e.to_string());
            app.sync_views();
            r
        },
        Ok,
    )
}

/// `file.place.queue` with `p` for the active document, its files read and their thumbnails made off
/// the UI thread → `{background: true, status}`; the place cursor is loaded once they are ready. When no thread could start, the cursor is loaded at once → `file.place.queue`'s reply.
pub fn start_queue(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
    let job = app.session.prepare_place_queue(p).map_err(|e| e.to_string())?;
    let names = job.names().join(", ");
    let started = spawn(app, names.clone(), names, false, move || job.read().map(Read::Queue).map_err(|e| e.to_string()))?;
    match started {
        Some(r) => Ok(r),
        None => {
            let r = app.session.execute("file.place.queue", p).map_err(|e| e.to_string());
            app.sync_views();
            let r = r?;
            crate::place::show_thumbnails(app, &r);
            Ok(r)
        }
    }
}

/// Before paste command `id` with `p`: what another app put on the system clipboard replaces the
/// internal clipboard ([`VectorcraftApp::adopt_system_clipboard`]) → `None`, and the paste runs at
/// once. For a Paste the user gives ([`crate::menus::invoke`]) where placed files are read off the
/// UI thread ([`available`]), the bitmap's bytes are copied off the system clipboard at once and
/// decoded on the thread that reads placed files, after the files started before it →
/// `{background: true, status}`: a bitmap the host converts to PNG is converted there
/// ([`crate::SystemClipboard::read_deferred`]), and the bitmap is read as `clipboard.importImage`
/// reads it ([`read_image`]). The paste runs once it is decoded, in the document it was given in,
/// as it would at once ([`poll`]). A Paste the user gives while such a paste waits waits behind it,
/// also when it has no bitmap to read. When no thread could start, the bitmap is read at once.
pub fn adopt_for_paste(app: &mut VectorcraftApp, id: &str, p: &Value) -> Result<Option<Value>, String> {
    if std::mem::take(&mut app.placing.adopted) {
        app.clipboard_image_request = None;
        return Ok(None);
    }
    if !(app.placing.for_user && available(app)) {
        return app.adopt_system_clipboard().map(|()| None);
    }
    let center = app.view().map(|v| [v.center.x, v.center.y]);
    let make = app.adopt_system_clipboard_or_defer(true)?;
    // A paste that takes the internal clipboard as it is (what another app put there was loaded
    // at once, or nothing was) runs at once, unless a paste whose bitmap is read waits: then it
    // waits behind that one, with the internal clipboard as it is now.
    if make.is_none() && !app.placing.pending.iter().any(|p| p.paste) {
        return Ok(None);
    }
    let copied = app.clipboard_publishing.latest();
    let (doc, objects) = app.session.doc().map(|st| (st.uid, st.selection.objects.clone())).map_err(|e| e.to_string())?;
    let insertion = Insertion::of(app).ok_or("no document")?;
    // A paste given while one of the document's latest chain waits, with the selection and the
    // insertion context that chain expects, joins it: it goes next to what the paste before it
    // leaves selected, as at once. Otherwise it starts a chain.
    let context = (objects, insertion.clone());
    let joins =
        app.placing.latest_chain.get(&doc).copied().filter(|c| app.placing.chains.get(c).is_some_and(|ch| ch.waiting > 0 && ch.context == context));
    let (chain, selection) = match joins {
        Some(chain) => (chain, None),
        None => (app.placing.next_chain, Some(context.0.clone())),
    };
    let clipboard = app.session.clipboard.clone();
    let (id, params) = (id.to_string(), p.clone());
    // The work stays here when no thread could start.
    let slot = Arc::new(Mutex::new(make));
    let work = slot.clone();
    let started = spawn_labeled(app, "clipboard".into(), "Pasting".into(), false, Some(chain), move || {
        let make = work.lock().ok().and_then(|mut m| m.take());
        let pasted = make.and_then(|m| m()).map(|f| {
            if crate::sysclip::imports_as_image(f.mime) {
                Pasted::Image(f.mime, read_image(&f.data).map_err(|e| e.to_string()))
            } else {
                Pasted::Flavour(f)
            }
        });
        Ok(Read::Paste(Box::new(Paste { id, params, pasted, center, selection, chain, insertion, copied, clipboard })))
    })?;
    if started.is_some() {
        if joins.is_none() {
            app.placing.next_chain += 1;
            app.placing.chains.insert(chain, Chain { context, left: None, waiting: 0 });
            app.placing.latest_chain.insert(doc, chain);
        }
        if let Some(ch) = app.placing.chains.get_mut(&chain) {
            ch.waiting += 1;
        }
        return Ok(started);
    }
    match slot.lock().ok().and_then(|mut m| m.take()).and_then(|m| m()) {
        Some(f) => app.adopt_flavour(&f, center).map(|()| None),
        None => Ok(None),
    }
}

/// Run `read` for the active document on the thread that reads the files, after the reads started
/// before it (so a batch of large pictures is decoded one at a time, as at once) →
/// `{background: true, status}`, or `None` when that thread could not start.
fn spawn(
    app: &mut VectorcraftApp,
    name: String,
    shown: String,
    dropped: bool,
    read: impl FnOnce() -> Result<Read, String> + Send + 'static,
) -> Result<Option<Value>, String> {
    spawn_labeled(app, name, format!("Placing {shown}"), dropped, None, read)
}

/// [`spawn`] with the status bar's `label`; `chain` for a paste's bitmap, its chain's number.
fn spawn_labeled(
    app: &mut VectorcraftApp,
    name: String,
    label: String,
    dropped: bool,
    chain: Option<u64>,
    read: impl FnOnce() -> Result<Read, String> + Send + 'static,
) -> Result<Option<Value>, String> {
    let doc = app.session.doc().map_err(|e| e.to_string())?.uid;
    let (tx, done) = channel();
    // The automation roots in force here are in force there.
    let scope = ScopeHandle::capture();
    #[cfg(test)]
    let reading = app.placing.reading.clone();
    let job: Job = Box::new(move || {
        #[cfg(test)]
        {
            let now = reading[0].fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1;
            reading[1].fetch_max(now, std::sync::atomic::Ordering::SeqCst);
        }
        let r = scope
            .run(|| vectorcraft_engine::guard::catch_panic(read))
            .unwrap_or_else(|msg| Err(format!("internal error: {msg} (please report this bug)")));
        #[cfg(test)]
        reading[0].fetch_sub(1, std::sync::atomic::Ordering::SeqCst);
        // The app may have quit meanwhile: nothing to hand it to.
        let _ = tx.send(r);
    });
    // A reader that has ended gives the job back.
    let job = match &app.placing.reader {
        Some(reader) => reader.send(job).err().map(|e| e.0),
        None => Some(job),
    };
    if let Some(job) = job {
        let (reader, jobs) = channel::<Job>();
        let started = std::thread::Builder::new().name("vectorcraft-place".into()).spawn(move || {
            for job in jobs {
                job();
            }
        });
        if started.is_err() {
            return Ok(None);
        }
        let _ = reader.send(job);
        app.placing.reader = Some(reader);
    }
    app.placing.pending.push(Pending { name, label: label.clone(), doc, dropped, paste: chain.is_some(), chain, done });
    let status = format!("{label}…");
    app.status(status.clone());
    Ok(Some(json!({ "background": true, "status": status })))
}

/// Place the files that are ready (each frame), in the order they were started: a file read
/// sooner than one started before it waits for that one. Not while a dialog is open, an
/// interaction is open, or a tool is busy with a drag of its own (the place cursor's) while the
/// pointer button is held, as [`crate::opening::poll`]: a placed file's document becomes the
/// active one and the dialog's OK acts on the active document; a drag in another document is
/// canceled when the active document changes, and a drag or preview in the same one previews from
/// the document as it was before it began, without the placed art. A tool that is busy while the
/// button is not held is waiting between its clicks (the Dimension tool after its first point):
/// the file is placed unless the tool has a preview open (the Flare tool after its center drag).
pub fn poll(app: &mut VectorcraftApp) {
    settle_swatch_paste(app);
    while app.ui.dialog.is_none()
        && !app.session.in_interaction()
        && !(app.session.tool_busy() && app.session.pointer_held())
        && let Some(p) = app.placing.pending.first()
    {
        let r = match p.done.try_recv() {
            Ok(r) => r,
            Err(TryRecvError::Empty) => return,
            Err(TryRecvError::Disconnected) => Err("the file stopped being read (please report this bug)".to_string()),
        };
        let p = app.placing.pending.remove(0);
        // The status bar no longer says it is placing.
        if app.ui.status == format!("{}…", p.label) {
            app.ui.status.clear();
        }
        finish(app, &p, r);
        if let Some(chain) = p.chain
            && !app.placing.swatch_paste.as_ref().is_some_and(|waiting| waiting.chain == chain)
        {
            finish_chain(app, chain);
        }
    }
}

/// Place files read off the UI thread in their document, which becomes the active one again, as
/// [`crate::place::run`] and [`crate::place::queue`] place files read at once; an error shows in
/// the status bar as it does then.
fn finish(app: &mut VectorcraftApp, p: &Pending, r: Result<Read, String>) {
    let Some(i) = app.session.documents().iter().position(|st| st.uid == p.doc) else {
        let name = &p.name;
        if p.paste {
            app.status("Couldn't paste: the document it was pasted in was closed");
        } else if p.dropped {
            app.status(format!("Couldn't place {name}: the document it was dropped on was closed"));
        } else {
            app.status(format!("Couldn't place {name}: the document it was placed in was closed"));
        }
        return;
    };
    if p.paste {
        let error = match &r {
            Ok(Read::Paste(paste)) => match &paste.pasted {
                Some(Pasted::Image(_, Err(e))) => Some(e.as_str()),
                _ => None,
            },
            Err(e) => Some(e.as_str()),
            _ => None,
        };
        if let Some(e) = error {
            if let Some(ch) = p.chain.and_then(|chain| app.placing.chains.get_mut(&chain))
                && ch.left.is_none()
            {
                let selection = match &r {
                    Ok(Read::Paste(paste)) => paste.selection.clone(),
                    _ => None,
                };
                ch.left = Some(selection.unwrap_or_else(|| ch.context.0.clone()));
            }
            app.status(format!("Couldn't paste from the clipboard: {e}"));
            return;
        }
    }
    app.session.set_active(i);
    let r = match r {
        Ok(Read::Place(read)) => app.session.place_read(*read).map(|_| ()).map_err(|e| e.to_string()),
        Ok(Read::Queue(read)) => app.session.place_queue_read(read).map(|r| crate::place::show_thumbnails(app, &r)).map_err(|e| e.to_string()),
        Ok(Read::Paste(paste)) => return finish_paste(app, *paste),
        Err(e) => Err(e),
    };
    app.sync_views();
    let name = &p.name;
    match r {
        Err(e) if p.dropped => app.status(format!("Couldn't place {name}: {e}")),
        Err(e) => app.status(e),
        Ok(()) => {}
    }
}

/// Run a paste whose bitmap was decoded off the UI thread, in its document, which is the active one:
/// the image replaces the internal clipboard, the objects selected when the paste started are
/// selected again, and the paste command runs as it runs at once ([`VectorcraftApp::run`]), into
/// the layer that was current when it started, with its errors in the status bar. A Copy or Cut
/// made since the paste started keeps the internal clipboard it made.
fn finish_paste(app: &mut VectorcraftApp, paste: Paste) {
    let kept = (app.clipboard_publishing.latest() != paste.copied).then(|| app.session.clipboard.clone());
    let adopted = match paste.pasted {
        Some(Pasted::Image(mime, read)) => app.adopt_image_read(mime, paste.center, read),
        Some(Pasted::Flavour(f)) => app.adopt_flavour(&f, paste.center),
        None => {
            app.session.clipboard = paste.clipboard;
            Ok(())
        }
    };
    let chain = paste.chain;
    let selection = paste.selection.or_else(|| app.placing.chains.get_mut(&chain).and_then(|ch| ch.left.take()));
    let mut deferred = false;
    let left = match adopted {
        Err(e) => {
            app.status(e);
            selection
        }
        Ok(()) => {
            // Where new art goes now, before a selection changes the current layer.
            let current = Insertion::of(app);
            // The objects selected when the paste started (or that the paste it follows left) are
            // selected again (those that are left), as `Session::place_read` selects the object
            // Replace swaps.
            let now = app.session.doc().map(|st| st.selection.objects.clone()).unwrap_or_default();
            if let Some(selection) = selection.filter(|s| *s != now) {
                let left: Vec<u64> =
                    selection.iter().filter(|id| app.session.doc().is_ok_and(|st| st.doc.node(**id).is_some())).map(|id| id.0).collect();
                let _ = app.session.execute("select.set", &json!({ "ids": left }));
            }
            // The paste goes where new art went when it started (the current layer, the isolated
            // group, the object Draw Inside draws into), and what the user changed meanwhile is
            // kept.
            paste.insertion.clone().set(app);
            let requested_selection = app.session.doc().map(|st| st.selection.objects.clone()).unwrap_or_default();
            app.placing.adopted = true;
            // `run` shows an error in the status bar.
            let _ = app.run(&paste.id, paste.params);
            // Also when the paste did not reach the clipboard (the Type tool took it).
            app.placing.adopted = false;
            if let Some(d) = app.ui.dialog.as_mut().filter(|d| d.kind == crate::dialogs::swatch_conflict::KIND) {
                d.fields.insert("__deferredPaste".into(), json!(chain));
                if let Ok(st) = app.session.doc() {
                    app.placing.swatch_paste = Some(PendingSwatch {
                        clipboard: app.session.clipboard.clone(),
                        insertion: paste.insertion.clone(),
                        selection: requested_selection,
                        doc: st.uid,
                        chain,
                    });
                    deferred = true;
                }
            }
            if let Some(current) = current {
                current.restore_changed(&paste.insertion, app);
            }
            app.session.doc().ok().map(|st| st.selection.objects.clone())
        }
    };
    // The chain's next paste takes the selection this one left, and a paste given with it and the
    // insertion context joins the chain while a paste of it waits ([`poll`] drops the chain).
    let context = app.session.doc().ok().map(|st| st.selection.objects.clone()).zip(Insertion::of(app));
    if !deferred && let Some(ch) = app.placing.chains.get_mut(&chain) {
        ch.left = left;
        if let Some(context) = context {
            ch.context = context;
        }
    }
    if let Some(kept) = kept {
        app.session.clipboard = kept;
    }
}

fn finish_chain(app: &mut VectorcraftApp, chain: u64) {
    if let Some(ch) = app.placing.chains.get_mut(&chain) {
        ch.waiting = ch.waiting.saturating_sub(1);
        if ch.waiting == 0 {
            app.placing.chains.remove(&chain);
            app.placing.latest_chain.retain(|_, c| *c != chain);
        }
    }
}

/// Release a deferred paste when its Swatch Conflict dialog is canceled or replaced.
pub(crate) fn cancel_swatch_paste(app: &mut VectorcraftApp) {
    if let Some(waiting) = app.placing.swatch_paste.take() {
        if let Some(ch) = app.placing.chains.get_mut(&waiting.chain) {
            ch.left = Some(waiting.selection);
        }
        finish_chain(app, waiting.chain);
    }
}

/// Release a deferred paste once its dialog is no longer the active dialog.
pub(crate) fn settle_swatch_paste(app: &mut VectorcraftApp) {
    let active = app.placing.swatch_paste.as_ref().is_some_and(|waiting| {
        app.ui.dialog.as_ref().is_some_and(|d| {
            d.kind == crate::dialogs::swatch_conflict::KIND && d.fields.get("__deferredPaste").and_then(Value::as_u64) == Some(waiting.chain)
        })
    });
    if app.placing.swatch_paste.is_some() && !active {
        cancel_swatch_paste(app);
    }
}

/// Run the command confirmed by the deferred paste's Swatch Conflict dialog.
pub(crate) fn confirm_swatch_paste(app: &mut VectorcraftApp, id: &str, params: Value, token: Option<u64>) -> Result<Value, String> {
    if !app.placing.swatch_paste.as_ref().is_some_and(|waiting| Some(waiting.chain) == token) {
        if token.is_some() || app.placing.swatch_paste.is_some() {
            cancel_swatch_paste(app);
            return Err("the deferred paste is no longer available".into());
        }
        return app.run(id, params);
    }
    let Some(waiting) = app.placing.swatch_paste.take() else { return app.run(id, params) };
    let Some(index) = app.session.documents().iter().position(|st| st.uid == waiting.doc) else {
        finish_chain(app, waiting.chain);
        return Err("Couldn't paste: the document it was pasted in was closed".into());
    };
    app.session.set_active(index);
    app.sync_views();
    let current = std::mem::replace(&mut app.session.clipboard, waiting.clipboard);
    let changed = Insertion::of(app);
    let now = app.session.doc().map(|st| st.selection.objects.clone()).unwrap_or_default();
    let selected: Vec<u64> =
        waiting.selection.iter().filter(|id| app.session.doc().is_ok_and(|st| st.doc.node(**id).is_some())).map(|id| id.0).collect();
    if selected != now.iter().map(|id| id.0).collect::<Vec<_>>() {
        let _ = app.session.execute("select.set", &json!({"ids": selected}));
    }
    let insertion = waiting.insertion.clone();
    insertion.clone().set(app);
    app.placing.adopted = true;
    let result = app.run(id, params);
    app.placing.adopted = false;
    if let Some(changed) = changed {
        changed.restore_changed(&insertion, app);
    }
    app.session.clipboard = current;
    let left = if result.is_ok() { app.session.doc().ok().map(|st| st.selection.objects.clone()) } else { Some(waiting.selection) };
    let context = app.session.doc().ok().map(|st| st.selection.objects.clone()).zip(Insertion::of(app));
    if let Some(ch) = app.placing.chains.get_mut(&waiting.chain) {
        ch.left = left;
        if let Some(context) = context {
            ch.context = context;
        }
    }
    finish_chain(app, waiting.chain);
    result
}

#[cfg(test)]
mod tests;