VectorCraft: An open-source, vector art tool written by scratch in pure Rust
//! File → Package…: where the package folder goes, its name, and what it collects (the linked
//! files, in a folder of their own or not, relinked or not; the fonts; the report). A document
//! never saved is saved first (Save As); unsaved changes are saved before packaging. The web
//! downloads the package as a zip.
//!
//! Fields: `folder` (the location), `name` (the package folder), `copyLinks`, `linksFolder`,
//! `relink`, `copyFonts`, `report`. OK runs `file.package` with them, then offers to show the
//! package folder (`file.showPackage`). On the desktop with Background Export on, the package is
//! collected and written on the background thread ([`crate::background`]) after the dialog closes.
use std::cell::Cell;
use std::rc::Rc;
use serde_json::{Value, json};
use vectorcraft_engine::EngineError;
use super::confirm::ask;
use super::{DialogSpec, form};
use crate::background::{self, Writer};
use crate::state::Dialog;
use crate::theme::Tokens;
use crate::{VectorcraftApp, io, widgets};
pub(super) const KIND: &str = "package";
const LABEL: f32 = 90.0;
/// The options: (field, label).
const OPTIONS: [(&str, &str); 5] = [
("copyLinks", "Copy Links"),
("linksFolder", "Collect Links in a Separate Folder"),
("relink", "Relink Linked Files to the Document"),
("copyFonts", "Copy Fonts Used in the Document"),
("report", "Create Report"),
];
pub(super) const SPEC: DialogSpec = DialogSpec {
heading: |_| tl!("Package").into(),
body,
confirm,
ok: Some("Package"),
min_width: 440.0,
max_width: Some(460.0),
..DialogSpec::FORM
};
/// Is there no file system to write a folder to (the web downloads a zip)?
fn downloads(app: &VectorcraftApp) -> bool {
app.services.download.is_some()
}
/// Open the dialog for the active document; one never saved is offered Save As first.
pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
let st = app.session.active().ok_or("no document")?;
let Some(path) = st.path.clone() else {
ask(
app,
tl!("Save the document first?"),
tl!("Package collects a saved document with its linked files and fonts."),
"file.saveAs",
json!({}),
);
return Ok(Value::Null);
};
let p = std::path::Path::new(&path);
let stem = p.file_stem().map_or_else(|| "Untitled".into(), |s| s.to_string_lossy().into_owned());
let folder = p.parent().map(|f| f.to_string_lossy().into_owned()).unwrap_or_default();
let mut fields = json!({ "folder": folder, "name": format!("{stem} Folder") });
for (k, _) in OPTIONS {
fields[k] = json!(true);
}
app.ui.dialog = Some(Dialog::new(KIND, fields));
Ok(Value::Null)
}
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let t = Tokens::get(ui.ctx());
if !downloads(app) {
widgets::label_row(ui, tl!("Location:"), LABEL, |ui| {
form::text(ui, d, "folder", 230.0);
if app.services.pick_folder.is_some() && ui.button(tl!("Choose…")).clicked() {
crate::picks::folder_field(app, d, "folder");
}
});
ui.add_space(4.0);
}
widgets::label_row(ui, tl!("Folder Name:"), LABEL, |ui| {
form::text(ui, d, "name", 230.0);
});
ui.add_space(10.0);
widgets::subheader(ui, tl!("Options"));
for (k, label) in OPTIONS {
// The link options apply only when the links are copied.
let enabled = !matches!(k, "linksFolder" | "relink") || d.bool("copyLinks");
let on = d.bool(k);
if widgets::check(ui, label, on, enabled) {
d.fields.insert(k.into(), json!(!on));
}
}
ui.add_space(6.0);
ui.label(egui::RichText::new(tl!("Fonts whose licence doesn't allow embedding are not copied.")).size(11.5).color(t.text_dim));
false
}
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
let mut params = Value::Object(d.fields.clone());
let web = downloads(app);
if web {
params["folder"] = Value::Null;
} else if d.str("folder").trim().is_empty() {
return Err("choose a location for the package".into());
}
// The package holds the document as saved.
if app.session.active().is_some_and(|st| st.is_dirty()) {
let r = io::save(app, vectorcraft_engine::cmd::fileio::SaveMode::Save, &json!({}), false)?;
// The save asks first (it would replace a file that loses what opening it left out).
if r.get("pending").is_some() {
return Ok(r);
}
}
// Background Export (Preferences › File Handling): the linked files and fonts are collected
// and the package is written from the document as it is now, while editing goes on. The jobs
// started before it (a save started above, an earlier package to the same folder) are written
// first: the worker runs its jobs in order, and a package made at once waits for them.
let enabled = app.session.prefs.background_export;
if !enabled {
background::wait_all(app);
}
let package = app.session.prepare_package(¶ms).map_err(|e| e.to_string()).inspect_err(|e| app.ui.status = e.clone())?;
let label = format!("Packaging {}", d.str("name"));
let later = Rc::new(Cell::new(false));
let in_background = later.clone();
let work = move |write: Writer| {
// A writer error that already names the file (an automation root's refusal) is kept as it is.
let mut write =
|path: &str, bytes: &[u8]| write(path, bytes).map_err(|e| EngineError::Other(if e.contains(path) { e } else { format!("{path}: {e}") }));
package.write(&mut write).map_err(|e| e.to_string())
};
let r = background::run(app, enabled, label, None, work, move |app, r| packaged(app, r, web, in_background.get()))?;
if r["background"] == true {
later.set(true);
app.ui.dialog = None;
}
Ok(r)
}
/// Report the package `r` (`file.package`'s reply): the status bar, the web's download, and the
/// offer to show the package folder. `later`: it was written in the background, after the dialog
/// closed, and a dialog open now is another one, which stays (the status bar names the folder).
fn packaged(app: &mut VectorcraftApp, r: Result<Value, String>, web: bool, later: bool) -> Result<Value, String> {
let r = r.inspect_err(|e| app.ui.status = e.clone())?;
if !later {
app.ui.dialog = None;
}
let n = r["files"].as_array().map_or(0, Vec::len);
let missing = r["missingLinks"].as_array().map_or(0, Vec::len);
// The fonts left out: their license doesn't allow it, or they aren't on this computer.
let fonts = r["skippedFonts"].as_array().into_iter().flatten().filter_map(|f| f["font"].as_str()).collect::<Vec<_>>().join(", ");
let shown_note = package_status_note(missing, &fonts);
let n = n as u64;
if web {
let (name, data) = (r["name"].as_str().unwrap_or("package.zip"), r["dataBase64"].as_str().unwrap_or_default());
let bytes = vectorcraft_format::base64_decode(data).ok_or("the package came back damaged")?;
io::write_named(app, None, name, &bytes)?;
app.status(package_status(n, None, &shown_note));
return Ok(r);
}
let folder = r["folder"].as_str().unwrap_or_default().to_string();
app.status(package_status(n, Some(&folder), &shown_note));
let detail = if shown_note.is_empty() {
crate::i18n::fmt(
&crate::i18n::tn(n, "{n} file in {folder}. Show the package folder?", "{n} files in {folder}. Show the package folder?"),
&[("folder", &folder)],
)
} else {
crate::i18n::fmt(
&crate::i18n::tn(n, "{n} file in {folder} {note}. Show the package folder?", "{n} files in {folder} {note}. Show the package folder?"),
&[("folder", &folder), ("note", &shown_note)],
)
};
if app.ui.dialog.is_none() {
ask(app, tl!("Package created"), &detail, "file.showPackage", json!({ "folder": folder }));
}
Ok(r)
}
/// The status bar's line for a package of `n` files written to `folder` (`None`: the web's
/// download), with `note` from [`package_status_note`] when it isn't empty. With a note and a
/// folder, the note comes before the folder and the folder ends the line. Each catalog also has
/// `@msgplural` rows for the English line, shown after a language switch; the folder takes the rest
/// of the line after `) in `, so a folder name with spaces or parentheses stays whole.
pub(super) fn package_status(n: u64, folder: Option<&str>, note: &str) -> String {
let (one, other) = match (folder.is_some(), note.is_empty()) {
(false, true) => ("Packaged {n} file", "Packaged {n} files"),
(false, false) => ("Packaged {n} file {note}", "Packaged {n} files {note}"),
(true, true) => ("Packaged {n} file in {folder}", "Packaged {n} files in {folder}"),
(true, false) => ("Packaged {n} file {note} in {folder}", "Packaged {n} files {note} in {folder}"),
};
crate::i18n::fmt(&crate::i18n::tn(n, one, other), &[("folder", folder.unwrap_or_default()), ("note", note)])
}
/// Parenthetical notes in a package status (`(2 linked files not found)` …),
/// joined with spaces and without a leading space (#3494).
pub(super) fn package_status_note(missing: usize, fonts: &str) -> String {
let mut parts = Vec::new();
if missing > 0 {
parts.push(format!("({})", crate::i18n::tn(missing as u64, "{n} linked file not found", "{n} linked files not found")));
}
if !fonts.is_empty() {
parts.push(format!("({})", crate::i18n::fmt(tl!("fonts not copied: {fonts}"), &[("fonts", fonts)])));
}
parts.join(" ")
}
/// `file.showPackage {folder}`: show a package folder in the file manager.
pub fn show_package(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
app.refuse_automation("file.showPackage")?;
let folder = p.get("folder").and_then(Value::as_str).ok_or("missing `folder`")?.to_string();
// A package is a folder: an executable, shortcut or app bundle would run, not be shown.
if !std::path::Path::new(&folder).is_dir() || folder.to_ascii_lowercase().ends_with(".app") {
return Err(format!("{folder} is not a package folder"));
}
io::open_in_app(app, &folder)?;
Ok(json!({ "folder": folder }))
}