b45255bb6fe2
clipboard.rs
use serde_json::Value;
use super::{FigApp, dev_mode_refuses, json, trn};
use crate::i18n::trf;
/// Run a menu item: some open dialogs or use platform services, the rest go to the engine.
/// Paste: the system clipboard wins when it holds something newer than our own copy (layers copied
/// from another design app, an image, SVG or text from another app); otherwise our copied layers.
/// `event_text` is the text the platform handed over with the paste event (the browser has no
/// other way to read it; the desktop's clipboard bridge has already read it). `at`: the page
/// point to paste at (Paste here); `None` pastes in the middle of the view.
/// In Dev Mode only a comment's link pastes (it opens the thread); everything else would edit.
pub fn paste(app: &mut FigApp, event_text: Option<&str>, at: Option<(f64, f64)>) {
// A gesture injected through the control channel pastes only our own copied layers: it must not
// read (and so expose) the user's system clipboard.
if app.control_synthetic {
// Synthetic input is user-like: Dev Mode refuses the paste here too, and only the engine's
// own copied layers are pasted (the system clipboard is never read).
if !(at.is_none() && crate::property_rows::paste(app)) && !dev_mode_refuses(app, "edit.paste") {
app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
}
return;
}
// Only HTML that holds readable design data takes this path; other HTML pastes as before.
if let Some(html) = app.services.clipboard_get_html().filter(|h| figcraft_engine::cmd::edit::design_clipboard_buffer(h).is_some()) {
if dev_mode_refuses(app, "edit.paste") {
return;
}
let mut params = json!({"html": html});
if let Some((x, y)) = at {
params["x"] = json!(x);
params["y"] = json!(y);
}
// A paste the user made: what was left out shows in the import report.
if let Some(r) = app.run_user("edit.pasteDesignLayers", params) {
// The pasted layers are now our copy: text another app puts on the clipboard later is newer.
app.ui.last_copy = Some(app.services.clipboard_get_text().unwrap_or_default());
app.ui.last_copy_generation = app.session.clipboard.layers_generation;
let missing: Vec<&str> = r["missingImages"].as_array().map(|a| a.iter().filter_map(Value::as_str).collect()).unwrap_or_default();
let left_out = r["warnings"].as_array().map_or(0, Vec::len);
if !missing.is_empty() {
// Name the layers: an image the clipboard didn't carry is easy to miss among them.
app.toast(trf("Pasted design layers; the clipboard didn't carry the images of: {layers}", &[("layers", &missing.join(", "))]));
} else if left_out > 0 {
app.toast(trn("Pasted design layers; {n} kinds of content were left out", left_out, &[]));
}
}
return;
}
// The text the platform handed over with the paste event is the system clipboard's text: the
// browser delivers it, and the desktop's async clipboard bridge read it while the window
// thread was free to serve the transfer. Never re-read the clipboard synchronously for it —
// on the desktop that read blocks the window thread for the read timeout, and when this app
// itself owns the clipboard (a self-paste) its own source can only be served by that very
// thread, so the read waits the full timeout and the window freezes for seconds (#2021).
// A paste the platform didn't hand text over (a chord, an image, the menu) reads it, as before.
let sys_text =
if let Some(t) = event_text { (!t.is_empty()).then(|| t.to_string()) } else { app.services.clipboard_get_text().filter(|t| !t.is_empty()) };
// The text matching `last_copy` means the system clipboard still holds what we mirrored only
// while the engine clipboard is the one we mirrored. A control-channel copy changes the engine
// clipboard without writing the system clipboard, so its generation no longer matches and the
// user's own text is pasted instead of the programmatic selection.
let ours = sys_text.is_some() && sys_text == app.ui.last_copy && app.ui.last_copy_generation == app.session.clipboard.layers_generation;
let (cx, cy) = at.or_else(|| app.session.ds().ok().map(|d| (d.view.cx, d.view.cy))).unwrap_or((0.0, 0.0));
if !ours {
if let Some((png, w, h)) = clipboard_png(app) {
if dev_mode_refuses(app, "edit.paste") {
return;
}
use base64::Engine as _;
let b64 = base64::engine::general_purpose::STANDARD.encode(png);
// One selected layer that can have fills takes the image as its top fill.
if let [target] = app.session.selection()[..]
&& at.is_none()
&& app.session.doc().ok().and_then(|d| d.node(target)).is_some_and(|n| figcraft_engine::cmd::create::accepts_image_fill(&n.kind))
{
app.run("image.place", json!({"data": b64, "target": target}));
return;
}
// Centred in the view; Paste here puts its top-left at the point, as it does layers.
let (x, y) = if at.is_some() { (cx, cy) } else { ((cx - w / 2.0).round(), (cy - h / 2.0).round()) };
app.run("file.import", json!({"data": b64, "name": "Pasted image.png", "x": x, "y": y}));
return;
}
// Not ours: any other text is newer (another app's text, SVG, a comment link) and wins.
// Our own marker for copied layers without a text/SVG mirror is never a text paste; when
// the engine copy moved on it falls through to `edit.paste` (the only layers we still have).
if let Some(text) = sys_text.filter(|t| !is_clipboard_marker(t)) {
return paste_text(app, &text, (cx, cy), at.is_none());
}
}
// Nothing newer from another app: a fill, stroke or effect copied from its row, when that was
// the last copy, else our copied layers.
if at.is_none() && crate::property_rows::paste(app) {
return;
}
if !dev_mode_refuses(app, "edit.paste") {
app.run("edit.paste", at.map_or(json!({}), |(x, y)| json!({"x": x, "y": y})));
}
}
/// The marker FigCraft puts on the system clipboard for copied layers with no text/SVG mirror.
fn is_clipboard_marker(text: &str) -> bool {
text.starts_with("figcraft://clipboard/")
}
/// Paste text from another app at `(cx, cy)` (`center`: centred there): a comment's link opens its
/// thread, SVG imports, spreadsheet cells on a board make a table, anything else becomes a text
/// layer.
fn paste_text(app: &mut FigApp, text: &str, (cx, cy): (f64, f64), center: bool) {
let board = app.session.doc().is_ok_and(figcraft_engine::board::is_board);
if text.trim().starts_with("figcraft://comment/") {
app.run("comment.open", json!({"link": text.trim()}));
} else if dev_mode_refuses(app, "edit.paste") {
// Dev Mode: the note says why nothing was pasted.
} else if let Some((cells, more)) = board.then(|| figcraft_engine::board_table::spreadsheet_cells(text)).flatten() {
// Centred in the view, or (Paste here) its top-left at the point.
let mut params = json!({"cells": cells});
if !center {
(params["x"], params["y"]) = (json!(cx), json!(cy));
}
if app.run("board.table", params).is_some() && more {
let (rows, columns) = (figcraft_engine::board_table::MAX_ROWS, figcraft_engine::board_table::MAX_COLUMNS);
app.toast(trf(
"A table takes at most {rows} rows and {columns} columns: the rest wasn't pasted",
&[("rows", &rows.to_string()), ("columns", &columns.to_string())],
));
}
} else if figcraft_engine::looks_like_svg(text) {
use base64::Engine as _;
let b64 = base64::engine::general_purpose::STANDARD.encode(text.as_bytes());
app.run_user("file.import", json!({"data": b64, "name": "Pasted SVG.svg", "x": cx, "y": cy, "center": center}));
} else {
app.run("text.create", json!({"text": text, "x": cx, "y": cy}));
}
}
/// The system clipboard's image as PNG bytes, with its size.
fn clipboard_png(app: &mut FigApp) -> Option<(Vec<u8>, f64, f64)> {
let clipboard_png = app.services.clipboard_get_png().filter(|png| png.len() <= crate::MAX_CLIPBOARD_PNG_BYTES);
let (png, (w, h)) = match clipboard_png.and_then(with_pixel_size) {
Some(readable) => readable,
None => with_pixel_size(encoded_clipboard_image(app)?)?,
};
let density = figcraft_format::pixel_density(&png);
let (w, h) = figcraft_format::placed_size(w, h, density, figcraft_engine::cmd::create::PLACED_IMAGE_MAX_SIDE);
Some((png, w, h))
}
const MAX_PASTED_IMAGE_PIXELS: u64 = 100_000_000;
fn with_pixel_size(png: Vec<u8>) -> Option<(Vec<u8>, (u32, u32))> {
use image::ImageDecoder as _;
let decoder = image::ImageReader::new(std::io::Cursor::new(&png)).with_guessed_format().ok()?.into_decoder().ok()?;
let (w, h) = decoder.dimensions();
if w == 0 || h == 0 || u64::from(w) * u64::from(h) > MAX_PASTED_IMAGE_PIXELS {
return None;
}
image::DynamicImage::from_decoder(decoder).ok()?;
Some((png, (w, h)))
}
fn encoded_clipboard_image(app: &mut FigApp) -> Option<Vec<u8>> {
let (w, h, rgba) = app.services.clipboard_get_image()?;
let img = image::RgbaImage::from_raw(w, h, rgba)?;
let mut out = std::io::Cursor::new(Vec::new());
img.write_to(&mut out, image::ImageFormat::Png).ok()?;
Some(out.into_inner())
}
/// The text of a selection made only of text layers, one layer per line (None for any other
/// selection, or when there is no text).
pub(super) fn text_layers_text(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
let texts: Option<Vec<&str>> = ids.iter().map(|i| doc.node(*i).and_then(|n| n.kind.text()).map(|t| t.characters.as_str())).collect();
texts.map(|t| t.join("\n")).filter(|t| !t.is_empty())
}
/// The layers as SVG text for other apps (None when the export fails).
pub(super) fn figcraft_svg_export(doc: &figcraft_doc::Document, ids: &[figcraft_doc::NodeId]) -> Option<String> {
let bytes = figcraft_engine::cmd::file::export_bytes(doc, ids, figcraft_doc::ExportFormat::Svg, 1.0).ok()?;
String::from_utf8(bytes).ok()
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.