Files
vectorcraft/crates/ui-egui/src/dialogs/javascript_files.rs
T
dotCooCoo f5de590dee SVG Interactivity: replies name JavaScript files outside the read roots by file name
With automation read roots in force, svgInteractivity.info and the files
reply of addFile and removeFile returned every linked JavaScript file as
stored, including paths outside the roots. They now name such a file by
its file name alone, as document.json does; a file inside the roots and
a URL are named as they are, and the document keeps every path.

removeFile also unlinks a file outside the roots by that file name. When
the name fits more than one linked file, it returns an error that names
no stored path and unlinks nothing. addFile still treats only the same
text as already linked.

In a frame a request drives, the JavaScript Files dialog lists such a
file by its file name while its selection keeps the file as linked, and
ui.inspect gives the selected file the same way. The person's frames
show full paths.
2026-11-13 09:32:19 -08:00

236 lines
11 KiB
Rust

//! JavaScript Files (the SVG Interactivity panel's Link JavaScript Files…): the JavaScript files
//! the active document links, in a list. Add links the path or URL in File or URL
//! (`svgInteractivity.addFile`; Choose… puts a picked file's `file:///` URL there where the host
//! has an open dialog), and Remove unlinks the file selected in the list
//! (`svgInteractivity.removeFile`). SVG export writes a `<script xlink:href>` element for each
//! linked file. Add and Remove act at once. The dialog has only Close.
//!
//! Fields: `file` (the path or URL to link), `selected` (a linked file).
//!
//! In a frame automation drives with read roots in force, the list names a file outside them by
//! its file name alone, as `svgInteractivity.info` does; `selected` keeps the file as linked.
use serde_json::{Value, json};
use vectorcraft_engine::cmd::links::shown_script;
use super::DialogSpec;
use crate::picks::PickRequest;
use crate::state::Dialog;
use crate::{FilePick, VectorcraftApp, widgets};
/// The dialog kind of JavaScript Files.
pub const KIND: &str = "javascriptFiles";
pub(super) const SPEC: DialogSpec = DialogSpec {
heading: |_| tl!("JavaScript Files").into(),
body,
confirm: |app, _| {
app.ui.dialog = None;
Ok(Value::Null)
},
ok: None,
min_width: 420.0,
..DialogSpec::FORM
};
/// Open JavaScript Files for the active document.
pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
if app.session.active().is_none() {
return Err("no document open".into());
}
app.ui.dialog = Some(Dialog::new(KIND, json!({ "file": "", "selected": "" })));
Ok(Value::Null)
}
/// The extension of JavaScript files.
const JS_EXTS: &[&str] = &["js"];
/// The open dialog for a JavaScript file.
fn pick() -> FilePick {
FilePick { filters: vec![FilePick::filter("JavaScript", JS_EXTS)], ..Default::default() }
}
/// Choose…: the file picked in the open dialog into File or URL, as a `file:///` URL
/// ([`crate::io::file_url`]).
fn choose(app: &mut VectorcraftApp, d: &mut Dialog) -> Result<(), String> {
if let Some(path) = crate::picks::open(app, &pick()) {
d.fields.insert("file".into(), json!(crate::io::file_url(&path)));
}
Ok(())
}
/// What a button asked for, done once the dialog is drawn.
enum Action {
Select(String),
Choose,
Add,
Remove,
}
/// The active document's linked files, each as it is linked and as the list shows it
/// ([`shown_script`]).
fn listed(app: &VectorcraftApp) -> Vec<(String, String)> {
app.session.active().map_or_else(Vec::new, |st| st.doc.svg_scripts.iter().map(|f| (f.clone(), shown_script(st, f).into_owned())).collect())
}
/// The row of `files` ([`listed`]) that `selected` names: the one row linked or shown as it. A
/// click selects a file as it is linked; a request may also give it as the list shows it. A name
/// that fits several rows selects none, as `svgInteractivity.removeFile` refuses it.
fn selected_row(files: &[(String, String)], selected: &str) -> Option<usize> {
let mut rows = files.iter().enumerate().filter(|(_, (linked, shown))| linked == selected || shown == selected);
match (rows.next(), rows.next()) {
(Some((i, _)), None) => Some(i),
_ => None,
}
}
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let files = listed(app);
let selected = d.str("selected");
let row = selected_row(&files, &selected);
let mut act = None;
widgets::list_box(ui, |ui| {
egui::ScrollArea::vertical().id_salt("javascript-files").min_scrolled_height(140.0).max_height(140.0).show(ui, |ui| {
ui.set_width(ui.available_width());
ui.set_min_height(140.0);
// Paths and URLs are data: shown as they are.
for (i, (linked, shown)) in files.iter().enumerate() {
if ui.selectable_label(row == Some(i), shown.as_str()).clicked() {
act = Some(Action::Select(linked.clone()));
}
}
});
});
ui.add_space(8.0);
widgets::label_row(ui, tl!("File or URL:"), 84.0, |ui| {
if let Some(v) = widgets::exact_text_field(ui, "javascript-file", &d.str("file"), 240.0) {
d.fields.insert("file".into(), json!(v));
}
if crate::picks::can(app, &PickRequest::Open(pick())) && widgets::flat_button(ui, tl!("Choose…"), 64.0).clicked() {
act = Some(Action::Choose);
}
});
ui.add_space(6.0);
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 4.0;
if ui.add_enabled_ui(!d.str("file").trim().is_empty(), |ui| widgets::flat_button(ui, tl!("Add"), 64.0)).inner.clicked() {
act = Some(Action::Add);
}
if ui.add_enabled_ui(row.is_some(), |ui| widgets::flat_button(ui, tl!("Remove"), 64.0)).inner.clicked() {
act = Some(Action::Remove);
}
});
let r = match act {
None => Ok(()),
Some(Action::Select(f)) => {
d.fields.insert("selected".into(), json!(f));
Ok(())
}
// The open dialog, shown off the UI thread, fills the dialog as it is then.
Some(Action::Choose) => crate::picks::in_dialog(app, d, choose),
Some(Action::Add) => {
let file = d.str("file").trim().to_string();
app.run("svgInteractivity.addFile", json!({ "file": file })).map(|_| {
d.fields.insert("selected".into(), json!(file));
d.fields.insert("file".into(), json!(""));
})
}
Some(Action::Remove) => app.run("svgInteractivity.removeFile", json!({ "file": selected })).map(|_| {
d.fields.insert("selected".into(), json!(""));
}),
};
if let Err(e) = r {
app.status(e);
}
false
}
#[cfg(test)]
mod tests {
use super::*;
use vectorcraft_engine::Session;
/// One headless frame of the dialog's body: the texts drawn.
fn frame(app: &mut VectorcraftApp, d: &mut Dialog) -> Vec<String> {
fn texts(s: &egui::Shape, out: &mut Vec<String>) {
match s {
egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
_ => {}
}
}
let ctx = egui::Context::default();
let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
body(app, ui, d);
});
out.textures_delta.clear();
let mut v = vec![];
out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
v
}
#[test]
fn opens_on_the_documents_linked_files() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
assert!(open(&mut app).is_err(), "no document");
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
app.session.execute("svgInteractivity.addFile", &json!({"file": "scripts/menu.js"})).unwrap();
crate::menus::invoke(&mut app, "ui.javascriptFilesDialog", json!({}));
assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(KIND));
let mut d = app.ui.dialog.clone().unwrap();
// (Only paths are checked: tests running alongside change the language labels are drawn in.)
let texts = frame(&mut app, &mut d);
assert!(texts.iter().any(|t| t == "scripts/menu.js"), "{texts:?}");
d.fields.insert("file".into(), json!("https://example.com/b.js"));
let texts = frame(&mut app, &mut d);
assert!(texts.iter().any(|t| t == "https://example.com/b.js"), "the field shows `file`: {texts:?}");
}
/// In a frame drawn with read roots in force, the list names a linked file outside them by its
/// file name alone, and that name unlinks it; the person sees the whole path.
#[test]
fn automation_javascript_files_dialog_hides_outside_root_paths() {
let base = std::env::temp_dir().join(format!("vc-js-dialog-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
std::fs::create_dir_all(base.join("in")).unwrap();
let outside = base.join("outside").join("menu.js").to_string_lossy().into_owned();
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
app.session.execute("svgInteractivity.addFile", &json!({ "file": outside })).unwrap();
let mut d = Dialog::new(KIND, json!({ "file": "", "selected": "" }));
let texts = frame(&mut app, &mut d);
assert!(texts.contains(&outside), "{texts:?}");
let roots = vectorcraft_engine::file_access::AutomationRoots::new(&[&base.join("in")], &[]).unwrap();
let texts = vectorcraft_engine::file_access::confine(roots.as_ref(), || frame(&mut app, &mut d));
assert!(texts.iter().any(|t| t == "menu.js") && !texts.iter().any(|t| t.contains("vc-js-dialog")), "{texts:?}");
// A row keeps the file as linked, so a click selects it by its whole path, which stays
// selected in the person's list; a name a request gives selects it too.
let rows = vectorcraft_engine::file_access::confine(roots.as_ref(), || listed(&app));
assert_eq!(rows, [(outside.clone(), "menu.js".to_string())]);
assert_eq!((selected_row(&rows, &outside), selected_row(&rows, "menu.js")), (Some(0), Some(0)));
// A name two rows show selects neither.
let twins = [rows[0].clone(), ("/elsewhere/menu.js".to_string(), "menu.js".to_string())];
assert_eq!((selected_row(&twins, "menu.js"), selected_row(&twins, "/elsewhere/menu.js")), (None, Some(1)));
assert_eq!(listed(&app), [(outside.clone(), outside.clone())], "the person's");
// Remove sends the selected name.
let removed = vectorcraft_engine::file_access::confine(roots.as_ref(), || app.run("svgInteractivity.removeFile", json!({"file": "menu.js"})));
assert!(removed.is_ok(), "{removed:?}");
assert!(app.session.active().is_some_and(|st| st.doc.svg_scripts.is_empty()));
let _ = std::fs::remove_dir_all(base);
}
/// Choose… puts the picked file in File or URL as a `file:///` URL, with no `\` and with
/// spaces percent-encoded.
#[test]
fn choose_puts_the_picked_file_in_as_a_file_url() {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let picked = std::env::temp_dir().join("my menu.js").to_string_lossy().into_owned();
app.services.pick_open = Some(Box::new(move |_: &FilePick| Some(picked.clone())));
let mut d = Dialog::new(KIND, json!({ "file": "", "selected": "" }));
choose(&mut app, &mut d).unwrap();
let file = d.str("file");
assert!(file.starts_with("file:///") && file.ends_with("/my%20menu.js") && !file.contains('\\'), "{file}");
}
}