VectorCraft: An open-source, vector art tool written by scratch in pure Rust
//! Links panel: every image in the document, linked files with their status (missing, modified)
//! and embedded images, as rows with a thumbnail, name, page and status. Clicking a row selects
//! its image, Ctrl/Cmd-click adds or removes it, and Shift-click selects the images of the rows
//! from the last row clicked without Shift to it (with Ctrl/Cmd, adds them); the buttons Relink,
//! Go To, Update and Edit Original act on the selected rows; Link Info shows the details of the
//! first. The flyout adds Relink to Folder, Find in Folder (Find Linked Files:
//! `ui.findLinksInFolder`), Embed / Unembed, Placement Options, Show filters, Sort, thumbnail size
//! and Show in Folder.
//!
//! Everything runs through the `links.*` commands (`links.editOriginal` and `links.reveal` are UI
//! commands: they hand the file to the system).
use egui::{Sense, Ui, vec2};
use serde_json::{Value, json};
use vectorcraft_doc::NodeId;
use super::{pstate, set_pstate};
use crate::theme::{self, Tokens};
use crate::widgets::{self, menu_item};
use crate::{VectorcraftApp, icons};
pub const ID: &str = "links";
/// Seconds between two looks at the linked files (they change outside the app).
const RECHECK: f64 = 2.0;
const SHOW: [(&str, &str); 4] = [("all", "Show All"), ("missing", "Show Missing"), ("modified", "Show Modified"), ("embedded", "Show Embedded")];
const SORT: [(&str, &str); 3] = [("name", "Sort by Name"), ("kind", "Sort by Kind"), ("status", "Sort by Status")];
const THUMBS: [(f32, &str); 4] = [(0.0, "No Thumbnails"), (18.0, "Small Thumbnails"), (28.0, "Medium Thumbnails"), (44.0, "Large Thumbnails")];
/// The panel's options (flyout).
#[derive(Clone)]
struct Options {
show: &'static str,
sort: Option<&'static str>,
/// Thumbnail side (pt); 0 hides them.
thumb: f32,
/// The Link Info section is open.
info: bool,
}
impl Default for Options {
fn default() -> Self {
Self { show: "all", sort: None, thumb: 28.0, info: true }
}
}
/// `links.list` and the first selected image's `links.info`, with what they were fetched for.
#[derive(Clone, Default)]
struct Cache {
/// (document uid, revision, show, sort).
key: Option<(u64, u64, &'static str, Option<&'static str>)>,
at: f64,
list: Value,
info: Option<(u64, Value)>,
}
fn options(ctx: &egui::Context) -> Options {
pstate(ctx, "links-options")
}
fn set_options(ctx: &egui::Context, f: impl FnOnce(&mut Options)) {
let mut o = options(ctx);
f(&mut o);
set_pstate(ctx, "links-options", o);
}
/// The rows to show (cached per document revision, the files looked at again every [`RECHECK`]
/// seconds) and the Link Info of the first selected image when the section is open.
fn cached(app: &mut VectorcraftApp, ctx: &egui::Context, o: &Options) -> Option<Cache> {
let st = app.session.active()?;
let key = Some((st.uid, st.revision, o.show, o.sort));
let first = selected_images(app).first().copied();
let now = ctx.input(|i| i.time);
let mut c: Cache = pstate(ctx, "links-cache");
let stale = c.key != key || now - c.at > RECHECK;
if stale {
c.list = app.session.execute("links.list", &json!({ "show": o.show, "sort": o.sort })).ok()?;
(c.key, c.at) = (key, now);
}
let want = first.filter(|_| o.info);
if stale || c.info.as_ref().map(|(id, _)| *id) != want {
c.info = want.and_then(|id| Some((id, app.session.execute("links.info", &json!({ "id": id })).ok()?)));
}
set_pstate(ctx, "links-cache", c.clone());
// Files change on disk without a frame of ours: look again later.
ctx.request_repaint_after(std::time::Duration::from_secs_f64(RECHECK));
Some(c)
}
/// The ids of the selected image objects and placed documents.
fn selected_images(app: &VectorcraftApp) -> Vec<u64> {
let Some(st) = app.session.active() else { return vec![] };
let image = |id: &NodeId| {
st.doc.node(*id).is_some_and(|n| matches!(n.kind, vectorcraft_doc::NodeKind::Image(_) | vectorcraft_doc::NodeKind::PlacedDocument(_)))
};
st.selection.objects.iter().filter(|id| image(id)).map(|id| id.0).collect()
}
/// The rows of `list` whose image is selected.
fn selected_rows<'a>(list: &'a Value, selected: &[u64]) -> Vec<&'a Value> {
list["links"].as_array().into_iter().flatten().filter(|r| r["id"].as_u64().is_some_and(|id| selected.contains(&id))).collect()
}
/// The ids of `rows` that `keep` accepts.
fn ids(rows: &[&Value], keep: impl Fn(&Value) -> bool) -> Vec<u64> {
rows.iter().filter(|r| keep(r)).filter_map(|r| r["id"].as_u64()).collect()
}
fn status_is(r: &Value, status: &str) -> bool {
r["status"].as_str() == Some(status)
}
fn report(app: &mut VectorcraftApp, r: Result<Value, String>, done: impl FnOnce(&Value) -> String) {
let msg = match r {
Ok(v) => done(&v),
Err(e) => e,
};
app.status(msg);
}
/// The status bar's line for `n` relinked images.
pub(crate) fn relinked_status(n: usize) -> String {
crate::i18n::msg_n(n as u64, "Relinked {n} image", "Relinked {n} images", &[])
}
/// The status bar's line for `n` images read again from their updated files.
pub(crate) fn updated_status(n: usize) -> String {
crate::i18n::msg_n(n as u64, "Updated {n} image", "Updated {n} images", &[])
}
/// Relink images `ids` to a picked file.
pub(crate) fn relink(app: &mut VectorcraftApp, ids: Vec<u64>) {
crate::picks::button(app, move |app| relink_picked(app, ids.clone()));
}
fn relink_picked(app: &mut VectorcraftApp, ids: Vec<u64>) {
let pick = crate::FilePick { filters: crate::FilePick::filters(vectorcraft_engine::cmd::fileio::place_filters()), ..Default::default() };
let Some(path) = crate::picks::open(app, &pick) else { return };
let r = app.run("links.relink", json!({ "ids": ids, "path": path }));
report(app, r, |v| relinked_status(v["relinked"].as_array().map_or(0, Vec::len)));
}
/// Replace images `ids` with a picked file (Control bar, Properties): it keeps its own aspect
/// ratio, fitted inside the old bounds (Placement Options: Fit), whatever their Placement Options
/// say.
pub(crate) fn replace(app: &mut VectorcraftApp, ids: Vec<u64>) {
crate::picks::button(app, move |app| {
let pick = crate::FilePick { filters: crate::FilePick::filters(vectorcraft_engine::cmd::fileio::place_filters()), ..Default::default() };
let Some(path) = crate::picks::open(app, &pick) else { return };
let r = app.run("links.relink", json!({ "ids": ids.clone(), "path": path, "preserve": "fit" }));
report(app, r, |v| crate::i18n::msg_n(v["relinked"].as_array().map_or(0, Vec::len) as u64, "Replaced {n} image", "Replaced {n} images", &[]));
});
}
/// Relink images `ids` (none: every missing one) to the files of their names in a picked folder.
fn relink_to_folder(app: &mut VectorcraftApp, ids: Vec<u64>) {
crate::picks::button(app, move |app| relink_to_picked_folder(app, ids.clone()));
}
fn relink_to_picked_folder(app: &mut VectorcraftApp, ids: Vec<u64>) {
let Some(folder) = crate::picks::folder(app) else { return };
let ids = Some(ids).filter(|i| !i.is_empty());
let r = app.run("links.relink", json!({ "ids": ids, "folder": folder }));
report(app, r, |v| {
let missed: Vec<&str> = v["notFound"].as_array().into_iter().flatten().filter_map(Value::as_str).collect();
let n = v["relinked"].as_array().map_or(0, Vec::len);
if missed.is_empty() {
relinked_status(n)
} else {
let (one, other) = ("Relinked {n} image; not in that folder: {names}", "Relinked {n} images; not in that folder: {names}");
crate::i18n::msg_n(n as u64, one, other, &[("names", &missed.join(", "))])
}
});
}
/// Select image `id` and scroll it into view.
pub(crate) fn go_to(app: &mut VectorcraftApp, id: u64) {
let Ok(r) = app.run("links.goTo", json!({ "id": id })) else { return };
let b: Vec<f64> = r["bounds"].as_array().into_iter().flatten().filter_map(Value::as_f64).collect();
if let (&[x0, y0, x1, y1], Some(v)) = (&b[..], app.view_mut()) {
v.center = vectorcraft_geom::Point::new((x0 + x1) / 2.0, (y0 + y1) / 2.0);
v.fitted = true;
}
}
/// Write embedded image `id` to a picked file (the web downloads it) and link it there.
pub(crate) fn unembed(app: &mut VectorcraftApp, id: u64, name: &str) {
if app.services.download.is_some() {
if let Ok(v) = app.session.execute("links.unembed", &json!({ "id": id }))
&& let (Some(name), Some(bytes)) = (v["name"].as_str(), v["dataBase64"].as_str().and_then(vectorcraft_format::base64_decode))
{
// A download that can't start is said like any file that can't be written.
let _ = crate::io::write_reporting(app, name, &bytes);
}
return;
}
let name = name.to_string();
crate::picks::button(app, move |app| {
let Some(path) = crate::picks::save(app, &crate::FilePick::named(&name)) else { return };
let r = app.run("links.unembed", json!({ "id": id, "path": path }));
report(app, r, |v| format!("Unembedded to {}", v["path"].as_str().unwrap_or_default()));
});
}
/// The UI commands `links.editOriginal` (open the linked file in its app) and `links.reveal`
/// (show it in its folder) for image `id` (default: the selected linked image) → `{path}`.
pub(crate) fn open_file(app: &mut VectorcraftApp, p: &Value, reveal: bool) -> Result<Value, String> {
let id = p.get("id").and_then(Value::as_u64).or_else(|| {
let list = app.session.execute("links.list", &json!({})).ok()?;
let sel = selected_images(app);
ids(&selected_rows(&list, &sel), |r| r["linked"] == true).first().copied()
});
let info = app.session.execute("links.info", &json!({ "id": id })).map_err(|e| e.to_string())?;
let path = info["path"].as_str().ok_or("select a linked image: an embedded one has no file")?.to_string();
if info["status"] == "missing" {
return Err(format!("{path} can't be found: relink it first"));
}
// A placed document's file opens here, in a new tab: saving it updates this document.
if !reveal && info["document"] == true {
let opened = app.run("document.open", json!({ "path": path }))?;
// Its missing fonts are asked about as for a document opened with File › Open.
crate::dialogs::missing_fonts::after_open(app, &opened);
crate::dialogs::settle(app);
return Ok(json!({ "path": path }));
}
if reveal {
crate::io::reveal_path(app, &path)?;
} else {
app.refuse_automation("links.editOriginal")?;
openable_original(&path)?;
crate::io::open_original(app, &path)?;
}
Ok(json!({ "path": path }))
}
/// Whether Edit Original may hand `path` to the system's default app: a regular file (after
/// following links) whose name, and the name it links to, have the extension of a format
/// VectorCraft reads. Anything else (a folder or app bundle, a script, a shortcut) is refused.
pub(crate) fn openable_original(path: &str) -> Result<(), String> {
let readable = |p: &std::path::Path| {
let ext = p.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();
use vectorcraft_engine::cmd::fileio::{FORMATS, read_extensions};
!ext.is_empty() && FORMATS.iter().any(|f| f.read && read_extensions(f).contains(&ext.as_str()))
};
let name = std::path::Path::new(path).file_name().map_or_else(|| path.to_string(), |n| n.to_string_lossy().into_owned());
let real = std::fs::canonicalize(path).map_err(|e| format!("can't open “{name}”: {e}"))?;
if !real.is_file() {
return Err(format!("“{name}” is not a file"));
}
if !readable(std::path::Path::new(path)) || !readable(&real) {
return Err(format!("Edit Original opens image and document files only; “{name}” is not one"));
}
Ok(())
}
/// A status badge: missing (red, ?), modified (amber, !), embedded (the image icon).
fn badge(ui: &Ui, r: egui::Rect, status: &str) {
let t = Tokens::get(ui.ctx());
let c = r.center();
let p = ui.painter();
let font = theme::semibold(10.0);
match status {
"missing" => {
p.circle_filled(c, 6.5, t.error);
p.text(c, egui::Align2::CENTER_CENTER, "?", font, egui::Color32::WHITE);
}
"modified" => {
let pts = vec![c + vec2(0.0, -7.0), c + vec2(7.0, 6.0), c + vec2(-7.0, 6.0)];
p.add(egui::Shape::convex_polygon(pts, t.warning, egui::Stroke::NONE));
p.text(c + vec2(0.0, 1.5), egui::Align2::CENTER_CENTER, "!", font, egui::Color32::BLACK);
}
"embedded" => icons::paint(ui, "image", egui::Rect::from_center_size(c, vec2(13.0, 13.0)), t.text_dim),
_ => {}
}
}
fn status_tip(r: &Value) -> String {
let path = r["found"].as_str().or(r["path"].as_str()).unwrap_or_default();
let tip = match r["status"].as_str().unwrap_or_default() {
"missing" => crate::i18n::fmt(tl!("Missing: {path}"), &[("path", path)]),
"modified" => crate::i18n::fmt(tl!("Modified since it was read: {path}"), &[("path", path)]),
"embedded" => tl!("Embedded").into(),
_ => path.to_string(),
};
// An image shown at reduced size or too large to draw (`links.list`'s note).
match r["note"].as_str() {
Some(note) => format!("{tip}\n{}", crate::i18n::msg(note)),
None => tip,
}
}
/// A click on the row of image `id` among the shown `rows`: plain selects the image alone,
/// Ctrl/Cmd adds or removes it, and Shift selects the images of the rows from the last row clicked
/// without Shift in this document to it, or with Ctrl/Cmd adds them to the selection. A
/// Shift-click while that row is not shown, or after the last click was in another document, acts
/// as a click without Shift.
fn click(app: &mut VectorcraftApp, ctx: &egui::Context, rows: &[Value], id: u64, m: egui::Modifiers) {
let Some(uid) = app.session.active().map(|st| st.uid) else { return };
let anchor: Option<(u64, u64)> = pstate(ctx, "links-anchor");
let at = |id: u64| rows.iter().position(|r| r["id"].as_u64() == Some(id));
if m.shift
&& let Some((_, a)) = anchor.filter(|(doc, _)| *doc == uid)
&& let (Some(i), Some(j)) = (at(a), at(id))
{
let range: Vec<u64> = rows.get(i.min(j)..=i.max(j)).unwrap_or_default().iter().filter_map(|r| r["id"].as_u64()).collect();
app.run(if m.command { "select.add" } else { "select.set" }, json!({ "ids": range })).ok();
return;
}
set_pstate(ctx, "links-anchor", Some((uid, id)));
if m.command {
app.run("select.toggle", json!({ "id": id })).ok();
} else {
app.run("select.set", json!({ "ids": [id] })).ok();
}
}
pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
let t = Tokens::get(ui.ctx());
let o = options(ui.ctx());
let Some(cache) = cached(app, ui.ctx(), &o) else {
widgets::dim_label(ui, tl!("No document"));
return;
};
let Some(st) = app.session.active() else { return };
let doc = st.doc.clone();
let thumbs = super::layers::ThumbSource::of(app, st, &doc);
let selected = selected_images(app);
let rows: &[Value] = cache.list["links"].as_array().map_or(&[], Vec::as_slice);
let mut clicked: Option<(u64, egui::Modifiers, bool)> = None;
widgets::list_box(ui, |ui| {
ui.set_min_height(110.0);
ui.set_width(ui.available_width());
if rows.is_empty() {
let detail = if o.show == "all" {
tl!("File › Place… brings in an image, linked or embedded.")
} else {
tl!("Nothing matches the Show filter.")
};
super::empty_state(ui, "link", tl!("No images"), detail);
return;
}
egui::ScrollArea::vertical().max_height(260.0).auto_shrink([false, true]).show(ui, |ui| {
let h = o.thumb.max(16.0) + 6.0;
for r in rows {
let Some(id) = r["id"].as_u64() else { continue };
let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), h), Sense::click());
if !ui.is_rect_visible(rect) {
continue;
}
if selected.contains(&id) {
ui.painter().rect_filled(rect, 0.0, t.row_selected);
} else if resp.hovered() {
ui.painter().rect_filled(rect, 0.0, t.hover);
}
let mut x = rect.left() + 6.0;
if o.thumb > 0.0 {
let tr = egui::Rect::from_min_size(egui::pos2(x, rect.center().y - o.thumb / 2.0), vec2(o.thumb, o.thumb));
ui.painter().rect_filled(tr, 0.0, egui::Color32::WHITE);
if let Some(n) = super::layers::node_arc(&doc, NodeId(id)) {
super::layers::real_thumb(ui, &thumbs, &n, tr);
}
ui.painter().rect_stroke(tr, 0.0, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
x = tr.right() + 6.0;
}
let right = rect.right() - 22.0;
badge(
ui,
egui::Rect::from_center_size(egui::pos2(right + 10.0, rect.center().y), vec2(16.0, 16.0)),
r["status"].as_str().unwrap_or_default(),
);
let mut text_right = right - 4.0;
if let Some(page) = r["page"].as_u64() {
let g = ui.painter().layout_no_wrap(format!("{page}"), egui::FontId::proportional(11.5), t.text_dim);
text_right -= g.size().x;
ui.painter().galley(egui::pos2(text_right, rect.center().y - g.size().y / 2.0), g, t.text_dim);
text_right -= 6.0;
}
let name = r["name"].as_str().unwrap_or_default();
let clip = egui::Rect::from_min_max(egui::pos2(x, rect.top()), egui::pos2(text_right.max(x), rect.bottom()));
ui.painter().with_clip_rect(clip).text(
egui::pos2(x, rect.center().y),
egui::Align2::LEFT_CENTER,
name,
egui::FontId::proportional(12.5),
t.text,
);
let resp = resp.on_hover_text(status_tip(r));
if resp.double_clicked() {
clicked = Some((id, egui::Modifiers::NONE, true));
} else if resp.clicked() {
clicked = Some((id, ui.input(|i| i.modifiers), false));
}
}
});
});
match clicked {
Some((id, _, true)) => go_to(app, id),
Some((id, m, false)) => click(app, ui.ctx(), rows, id, m),
None => {}
}
if o.info {
let units = app.session.general_unit();
link_info(ui, cache.info.as_ref().map(|(_, i)| i), units);
}
let sel = selected_rows(&cache.list, &selected);
let modified = ids(&sel, |r| status_is(r, "modified") || r["preview"] == true && !status_is(r, "missing"));
let can_edit = sel.iter().any(|r| r["linked"] == true && !status_is(r, "missing"));
let linked = ids(&sel, |r| r["linked"] == true);
widgets::bottom_bar(ui, |ui| {
let info = !o.info;
if widgets::icon_button(ui, if o.info { "chevron-down" } else { "chevron-right" }, tl!("Show Link Info"), false, 24.0).clicked() {
set_options(ui.ctx(), |o| o.info = info);
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if widgets::icon_button_enabled(ui, "pencil", tl!("Edit Original"), false, can_edit, 24.0).clicked() {
crate::menus::invoke(app, "links.editOriginal", json!({}));
}
if widgets::icon_button_enabled(ui, "rotate-cw", tl!("Update Link"), false, !modified.is_empty(), 24.0).clicked() {
let r = app.run("links.update", json!({ "ids": modified }));
report(app, r, |v| updated_status(v["updated"].as_array().map_or(0, Vec::len)));
}
if widgets::icon_button_enabled(ui, "zoom-in", tl!("Go To Link"), false, sel.len() == 1, 24.0).clicked()
&& let Some(id) = sel.first().and_then(|r| r["id"].as_u64())
{
go_to(app, id);
}
if widgets::icon_button_enabled(ui, "link", tl!("Relink…"), false, !sel.is_empty() && can_pick(app), 24.0).clicked() {
relink(app, ids(&sel, |_| true));
}
if widgets::icon_button_enabled(ui, "link-2-off", tl!("Break Link"), false, !linked.is_empty(), 24.0).clicked() {
break_link(app, linked.clone());
}
});
});
}
/// Break Link (`links.embed`) of `ids`: images keep their files' pixels, placed documents become
/// editable copies of their art.
fn break_link(app: &mut VectorcraftApp, ids: Vec<u64>) {
let r = app.run("links.embed", json!({ "ids": ids }));
report(app, r, |v| {
let missing = v["missing"].as_array().map_or(0, Vec::len);
let n = v["embedded"].as_array().map_or(0, Vec::len);
if missing == 0 {
crate::i18n::msg_n(n as u64, "Broke {n} link", "Broke {n} links", &[])
} else {
crate::i18n::msg_n(
n as u64,
"Broke {n} link; {missing} can't be read: relink or update them first",
"Broke {n} links; {missing} can't be read: relink or update them first",
&[("missing", &missing.to_string())],
)
}
});
}
/// Pick-a-file actions need a file dialog (the desktop app).
fn can_pick(app: &VectorcraftApp) -> bool {
app.services.pick_open.is_some()
}
/// Bytes as B, KB or MB.
fn size_label(bytes: u64) -> String {
match bytes {
b if b < 1024 => format!("{b} B"),
b if b < 1024 * 1024 => format!("{:.1} KB", b as f64 / 1024.0),
b => format!("{:.1} MB", b as f64 / (1024.0 * 1024.0)),
}
}
/// Milliseconds since the Unix epoch as a UTC date and time.
pub(crate) fn date_label(ms: u64) -> String {
let [y, mo, d, h, mi, _] = vectorcraft_doc::metadata::civil(i64::try_from(ms / 1000).unwrap_or(i64::MAX));
format!("{y:04}-{mo:02}-{d:02} {h:02}:{mi:02} UTC")
}
/// The Link Info section: the details of `info` (`links.info`), or a hint.
fn link_info(ui: &mut Ui, info: Option<&Value>, units: vectorcraft_doc::Unit) {
widgets::divider(ui);
let Some(i) = info else {
widgets::dim_label(ui, tl!("Select an image to see its Link Info."));
return;
};
let pair = |k: &str| {
let n: Vec<f64> = i[k].as_array().into_iter().flatten().filter_map(Value::as_f64).collect();
match n[..] {
[x, y] if (x - y).abs() < 0.05 => format!("{x:.0}"),
[x, y] => format!("{x:.0} × {y:.0}"),
_ => String::new(),
}
};
let row = super::doc_info::row;
row(ui, tl!("Name"), i["fileName"].as_str().or(i["name"].as_str()).unwrap_or_default().into());
row(ui, tl!("Format"), i["format"].as_str().unwrap_or_default().into());
row(ui, tl!("Color Space"), i["colorMode"].as_str().unwrap_or_default().into());
if let Some(l) = i["location"].as_str() {
row(ui, tl!("Location"), l.into());
}
// A placed document has no resolution: its rows are left out.
for (label, k) in [(tl!("PPI"), "ppi"), (tl!("Effective PPI"), "effectivePpi")] {
if i.get(k).is_some() {
row(ui, label, pair(k));
}
}
// Pixels, or a placed document's artboard size.
let dims = match (i["pixelWidth"].as_u64(), i["pageWidth"].as_f64(), i["pageHeight"].as_f64()) {
(Some(w), _, _) => format!("{w} × {} px", i["pixelHeight"].as_u64().unwrap_or(0)),
(None, Some(w), Some(h)) => format!("{} × {}", units.format(w), units.format(h)),
_ => String::new(),
};
row(ui, tl!("Dimensions"), dims);
let scale: Vec<f64> = i["scale"].as_array().into_iter().flatten().filter_map(Value::as_f64).collect();
if let [x, y] = scale[..] {
row(ui, tl!("Scale"), format!("H: {x:.1}% V: {y:.1}%"));
}
row(ui, tl!("Rotation"), format!("{:.1}°", i["rotation"].as_f64().unwrap_or(0.0)));
if let Some(b) = i["fileSize"].as_u64() {
row(ui, tl!("Size"), size_label(b));
}
for (k, label) in [("created", tl!("Created")), ("modified", tl!("Modified"))] {
if let Some(ms) = i[k].as_u64() {
row(ui, label, date_label(ms));
}
}
if let Some(p) = i["page"].as_u64() {
row(ui, tl!("Page"), p.to_string());
}
let status = match i["status"].as_str().unwrap_or_default() {
"ok" => tl!("Linked"),
"missing" => tl!("Missing"),
"modified" => tl!("Modified"),
_ => tl!("Embedded"),
};
row(ui, tl!("Status"), status.into());
}
pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
let o = options(ui.ctx());
// The rows the panel shows (the menu opens from it).
let list = pstate::<Cache>(ui.ctx(), "links-cache").list;
let selected = selected_images(app);
let sel = selected_rows(&list, &selected);
let linked = ids(&sel, |r| r["linked"] == true);
let embedded: Vec<&Value> = sel.iter().copied().filter(|r| status_is(r, "embedded")).collect();
let any = !sel.is_empty();
let missing_any = list["missing"].as_u64().unwrap_or(0) > 0;
if menu_item(ui, tl!("Relink…"), any && can_pick(app), false) {
relink(app, ids(&sel, |_| true));
}
if menu_item(ui, tl!("Relink to Folder…"), (any || missing_any) && app.services.pick_folder.is_some(), false) {
relink_to_folder(app, ids(&sel, |_| true));
}
if menu_item(ui, tl!("Find in Folder…"), (!linked.is_empty() || missing_any) && app.services.pick_folder.is_some(), false) {
crate::menus::invoke(app, "ui.findLinksInFolder", json!({ "ids": linked }));
}
if menu_item(ui, tl!("Go To Link"), sel.len() == 1, false)
&& let Some(id) = sel.first().and_then(|r| r["id"].as_u64())
{
go_to(app, id);
}
if menu_item(ui, tl!("Update Link"), sel.iter().any(|r| status_is(r, "modified")), false) {
let r = app.run("links.update", json!({ "ids": ids(&sel, |r| status_is(r, "modified")) }));
report(app, r, |v| updated_status(v["updated"].as_array().map_or(0, Vec::len)));
}
if menu_item(ui, tl!("Edit Original"), sel.iter().any(|r| r["linked"] == true && !status_is(r, "missing")), false) {
crate::menus::invoke(app, "links.editOriginal", json!({}));
}
ui.separator();
if menu_item(ui, tl!("Embed Image(s)"), !linked.is_empty(), false) {
let r = app.run("links.embed", json!({ "ids": linked }));
report(app, r, |v| {
let missing = v["missing"].as_array().map_or(0, Vec::len);
let n = v["embedded"].as_array().map_or(0, Vec::len);
if missing == 0 {
crate::i18n::msg_n(n as u64, "Embedded {n} image", "Embedded {n} images", &[])
} else {
crate::i18n::msg_n(
n as u64,
"Embedded {n} image; {missing} missing: relink them first",
"Embedded {n} images; {missing} missing: relink them first",
&[("missing", &missing.to_string())],
)
}
});
}
if menu_item(ui, tl!("Unembed…"), embedded.len() == 1, false)
&& let Some(r) = embedded.first()
&& let Some(id) = r["id"].as_u64()
{
let name = r["name"].as_str().unwrap_or("Image").to_string();
unembed(app, id, &name);
}
if menu_item(ui, tl!("Placement Options…"), any, false) {
crate::menus::invoke(app, "ui.placementOptionsDialog", json!({ "ids": ids(&sel, |_| true) }));
}
if menu_item(ui, tl!("Show in Folder"), sel.iter().any(|r| r["linked"] == true && !status_is(r, "missing")), false) {
crate::menus::invoke(app, "links.reveal", json!({}));
}
ui.separator();
for (id, label) in SHOW {
if menu_item(ui, tl!(label), true, o.show == id) {
set_options(ui.ctx(), |o| o.show = id);
}
}
ui.separator();
for (id, label) in SORT {
if menu_item(ui, tl!(label), true, o.sort == Some(id)) {
set_options(ui.ctx(), |o| o.sort = if o.sort == Some(id) { None } else { Some(id) });
}
}
ui.separator();
for (px, label) in THUMBS {
if menu_item(ui, tl!(label), true, o.thumb == px) {
set_options(ui.ctx(), |o| o.thumb = px);
}
}
if menu_item(ui, tl!("Show Link Info"), true, o.info) {
set_options(ui.ctx(), |o| o.info = !o.info);
}
}