2bc41aeb8602
run.rs
use super::bar::home_key;
use super::invoke::menu_dialog;
use super::slots::{recent_readable, recent_slot, saved_selection_name, saved_selection_slot, saved_view, saved_view_slot};
use super::state::{checked, selected_image};
use super::ui_commands::UI_COMMANDS;
use super::{Brightness, Face, SaveMode, Value, VectorcraftApp, io, json, next_zoom};
/// Canonical panel id for `window.panel`: a dock tab's or an icon panel's id or display label,
/// matched case-insensitively (`"Layers"`, `"swatches"`, `"Color Guide"`), or a library panel's id
/// as it is (`library:swatches:pastels`).
pub(crate) fn normalize_panel(input: &str) -> Option<&'static str> {
let name = input.trim();
crate::state::all_panels()
.find(|(id, label)| name.eq_ignore_ascii_case(id) || name.eq_ignore_ascii_case(label))
.map(|(id, _)| id)
.or_else(|| crate::panels::library_panel::intern(input))
}
/// An optional `{key?: bool}` param: none when it is omitted or null (the commands then toggle).
pub(crate) fn opt_bool(p: &Value, key: &str) -> Result<Option<bool>, String> {
match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(Value::Bool(b)) => Ok(Some(*b)),
Some(_) => Err(format!("`{key}` must be true or false")),
}
}
/// An optional `{key?: number}` param: none when it is omitted or null.
pub(crate) fn opt_number(p: &Value, key: &str) -> Result<Option<f64>, String> {
match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(v) => v.as_f64().map(Some).ok_or_else(|| format!("`{key}` must be a number")),
}
}
/// An optional `{key?: index}` param, a whole number of 0 or more: none when it is omitted or null.
pub(crate) fn opt_index(p: &Value, key: &str) -> Result<Option<usize>, String> {
match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(v) => v.as_u64().and_then(|i| usize::try_from(i).ok()).map(Some).ok_or_else(|| format!("`{key}` must be a whole number of 0 or more")),
}
}
/// An optional `{key?: [x, y]}` param: none when it is omitted or null.
fn opt_point(p: &Value, key: &str) -> Result<Option<vectorcraft_geom::Point>, String> {
match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(v) => match v.as_array().map(Vec::as_slice) {
Some([x, y]) => x.as_f64().zip(y.as_f64()).map(|(x, y)| Some(vectorcraft_geom::Point::new(x, y))),
_ => None,
}
.ok_or_else(|| format!("`{key}` must be [x, y] numbers")),
}
}
/// Handle a UI command. `None` = not a UI command (the engine handles it).
/// `params` has only keys the params description of engine command `id` names, or the parameter
/// error naming the one it doesn't (#1442). The UI's own commands aren't checked yet: their
/// descriptions haven't been audited against what they read.
/// `file.save` and `file.exportForScreens` take the params of the engine command they run.
pub fn check_params(session: &vectorcraft_engine::Session, id: &str, params: &Value) -> Result<(), String> {
let id = match id {
"file.save" => "document.save",
"file.exportForScreens" => "document.exportForScreens",
id => id,
};
if UI_COMMANDS.iter().any(|c| c.0 == id) {
return Ok(());
}
session.check_params(id, params).map_err(|e| e.to_string())
}
/// Runs `id` when the UI runs it itself: one of [`UI_COMMANDS`], or an engine command the UI
/// handles its own way (a Window menu panel item that toggles, …) → `None` to leave it to the
/// engine.
pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
// Window menu items and the named panel function keys toggle against the checked state;
// other commands that open panels show them.
let toggles = if id == "window.panel" { opt_bool(p, "toggle").and_then(|t| Ok((t, opt_bool(p, "toggleGroup")?))) } else { Ok((None, None)) };
let (toggle, toggle_group) = match toggles {
Ok(flags) => flags,
Err(e) => return Some(Err(e)),
};
if toggle == Some(true) && checked(app, id, p) == Some(true) {
let panel = p.get("panel").and_then(Value::as_str).and_then(normalize_panel).unwrap_or_default();
if app.ui.open_panel.as_deref() == Some(panel) {
app.ui.open_panel = None;
return Some(Ok(json!({"open": null})));
}
if toggle_group == Some(true) {
return Some(crate::panel_docking::hide_group(app, panel));
}
return Some(app.run("window.panel.close", json!({"panel": panel})));
}
if let Some(result) = crate::panel_docking::command(app, id, p) {
return Some(result);
}
if id == "app.language" {
let lang = p.get("lang").and_then(Value::as_str).unwrap_or("");
let value = if lang.eq_ignore_ascii_case("auto") {
"auto".to_string()
} else if let Some(l) = crate::i18n::Lang::from_code(lang) {
l.code().to_string()
} else {
let codes: Vec<&str> = std::iter::once("auto").chain(crate::i18n::Lang::all().map(|l| l.code())).collect();
return Some(Err(format!("lang must be one of {}", codes.join(", "))));
};
return Some(app.run("prefs.set", json!({"key": "interfaceLanguage", "value": value})).map(|_| json!(value)));
}
if let Some(r) = crate::panels::character::intercept_text_command(app, id) {
return Some(r);
}
if let Some(r) = crate::shortcut_editor::run_command(app, id, p)
.or_else(|| crate::workspaces::run_command(app, id, p))
.or_else(|| crate::edit_toolbar::command(app, id, p))
.or_else(|| crate::custom_toolbars::command(app, id, p))
.or_else(|| crate::panels::learn::command(app, id, p))
.or_else(|| crate::panels::discover::command(app, id, p))
.or_else(|| crate::panels::retype::command(app, id, p))
{
return Some(r);
}
run_ui_part1(app, id, p)
.or_else(|| run_ui_part2(app, id, p))
.or_else(|| run_ui_part3(app, id, p))
.or_else(|| run_ui_part4(app, id, p))
.or_else(|| run_ui_part5(app, id, p))
.or_else(|| run_ui_part6(app, id, p))
.or_else(|| run_ui_part7(app, id, p))
.or_else(|| run_ui_part8(app, id, p))
.or_else(|| run_ui_part9(app, id, p))
.or_else(|| run_ui_part10(app, id, p))
.or_else(|| run_ui_part11(app, id, p))
.or_else(|| run_ui_part12(app, id, p))
.or_else(|| run_ui_part13(app, id, p))
}
/// UI commands, part 1.
fn run_ui_part1(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"file.newDialog" => {
crate::dialogs::open_new_document(app);
Ok(Value::Null)
}
"file.newWithoutDialog" => crate::dialogs::new_document_without_dialog(app),
"app.home" => {
app.ui.home = Some(home_key(app));
Ok(Value::Null)
}
"file.open" => match s("path") {
Some(path) => match p.get("params").filter(|v| !v.is_null()) {
Some(params) => io::open_path_with(app, &path, params),
None => io::open_path(app, &path),
},
None => io::open_dialog(app).map(|_| Value::Null),
},
"file.openWith" => io::open_with(app, p),
// Saves write through the app (save panel, download); with no path known the panel and the
// format's options dialog ask first.
// A confined request sees the document's own file, and the folder a save suggests, only
// inside its read roots.
"file.save" | "file.saveAs" | "file.saveCopy" | "file.saveAsTemplate" => {
let mode = match id {
"file.save" => SaveMode::Save,
"file.saveAs" => SaveMode::SaveAs,
"file.saveCopy" => SaveMode::Copy,
_ => SaveMode::Template,
};
let saved = if mode == SaveMode::Save { io::save_current(app, p) } else { io::save(app, mode, p, true) };
saved.map(|mut r| {
vectorcraft_engine::cmd::fileio::leave_out_unreadable_save_paths(&mut r, p.get("path").and_then(Value::as_str));
r
})
}
// Without params the save panel picks the file, then its format's options dialog follows.
"document.exportSelection" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::export_selection(app),
"document.exportSelection" => {
io::save_command_output(app, id, "png", if p.is_object() { p.clone() } else { json!({}) }).map(|p| json!({"path": p}))
}
// Bytes sent by an agent go straight to the engine; a path or nothing opens it here.
"file.newFromTemplate" if p.get("dataBase64").is_none() => io::new_from_template(app, s("path")),
"file.revert" if opt_bool(p, "confirmed") != Ok(Some(true)) => opt_bool(p, "confirmed").and_then(|_| io::ask_revert(app)),
"file.reveal" => io::reveal(app),
"file.cancelExport" => Ok(io::cancel_exports(app)),
"file.exportInBackground" => Ok(io::hide_exports(app)),
"file.cancelSave" => Ok(io::cancel_saves(app)),
"file.saveInBackground" => Ok(io::hide_saves(app)),
"file.cancelOpen" => Ok(crate::opening::cancel_all(app)),
"file.openInBackground" => Ok(crate::opening::hide_all(app)),
"file.cancelPlace" => Ok(crate::placing::cancel_all(app)),
id if id.starts_with("file.openRecent") => match recent_slot(app, id).filter(|path| recent_readable(path)).cloned() {
Some(path) => io::open_reporting(app, &path),
None => Err("no such recent file".into()),
},
"type.findFont" => {
crate::find_font::open(app);
Ok(Value::Null)
}
_ => return None,
};
Some(r)
}
/// UI commands, part 2.
fn run_ui_part2(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let flag = |b: &mut bool| {
*b = !*b;
Ok(json!(*b))
};
let r = match id {
"ui.missingFontsDialog" => crate::dialogs::missing_fonts::open_command(app, s("folder")),
"ui.findFontsInFolder" => crate::dialogs::missing_fonts::find_in_folder_command(app, s("folder")),
"file.clearRecent" => {
app.ui.recent_files.clear();
Ok(Value::Null)
}
"file.recentFiles" => Ok(json!(io::recent_files(app).iter().filter(|path| recent_readable(path)).collect::<Vec<_>>())),
"file.place" => crate::place::run(app, p),
"file.place.queue" => crate::place::queue(app, p),
"file.export.svg" if p.as_object().is_none_or(|o| o.is_empty()) => {
crate::dialogs::svg_options::open(app, crate::dialogs::svg_options::Mode::Export, None);
Ok(Value::Null)
}
"file.export.svg" => io::export(app, Some("svg"), s("path"), p),
"file.export.svg.browser" => crate::dialogs::svg_options::browser_preview(app, p),
"file.exportForScreens" if p.as_object().is_none_or(|o| o.is_empty()) => {
crate::dialogs::open_export_for_screens(app);
Ok(Value::Null)
}
"file.exportForScreens" => io::export_for_screens(app, p.clone()),
"file.export.png" if s("path").is_none() => io::target_path(app, None, "png").and_then(|path| {
let f = vectorcraft_engine::cmd::fileio::format("png").ok_or("no PNG encoder")?;
let mut params = if p.is_object() { p.clone() } else { json!({}) };
params["format"] = json!("png");
params["path"] = json!(path);
// No artboard named: the artboard in use rather than the first (#5502), or each one the
// Artboard tool has selected, one file each.
let named = ["useArtboards", "rect"].iter().chain(vectorcraft_engine::cmd::fileio::ARTBOARD_PARAMS.iter()).any(|k| !params[*k].is_null());
let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
if !named && n > 0 {
match crate::panels::artboards::picked(app, n).as_slice() {
[i] => params["artboard"] = json!(i),
several => {
params["artboards"] = json!(several);
params["useArtboards"] = json!(true);
}
}
}
crate::dialogs::open_raster_options(app, f, params);
Ok(Value::Null)
}),
"file.export.png" => io::export(app, Some("png"), s("path"), p),
"file.documentSetup" => crate::dialogs::open_document_setup(app),
"edit.preferences" => {
crate::prefs_dialog::open(app, s("category").as_deref());
Ok(Value::Null)
}
// Edit → Color Settings… / Assign Profile… (no params): show the colour-management panel
// wherever it is, as Window › Separations Preview does (it isn't in an icon column, so a
// flyout for it never opened: #4542), scrolled to its Color Settings section, which a short
// window shows only after scrolling past the plates and Proof Setup (#6419).
"edit.colorSettings" | "edit.assignProfile" if p.as_object().is_none_or(|o| o.is_empty()) => {
crate::panel_docking::reveal_panel(app, "separations").and_then(|_| {
app.ui.color_settings_scroll = true;
app.session.execute(id, p).map_err(|e| e.to_string())
})
}
// Edit › Refresh Monitor Profile: the desktop app's next frame reads the display's profile.
"view.refreshMonitorProfile" => app.display_profile.request_read(app.session.prefs.monitor_profile_display).map(|()| {
if let Some(ctx) = &app.ui_ctx {
ctx.request_repaint();
}
json!({ "requested": true })
}),
// Outline or Preview is a setting of the active document's view.
"view.outline" => match app.view_mut() {
Some(v) => flag(&mut v.outline),
None => Err("no document".into()),
},
_ => return None,
};
Some(r)
}
/// UI commands, part 3.
fn run_ui_part3(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let flag = |b: &mut bool| {
*b = !*b;
Ok(json!(*b))
};
let r = match id {
"view.pixelPreview" => flag(&mut app.ui.view.pixel_preview),
"view.trimView" => flag(&mut app.ui.view.trim_view),
"view.cornerWidget" => flag(&mut app.ui.view.corner_widgets),
// Hide/Show Shape Widgets: `on` sets the state, and without it the state flips.
"view.shapeWidgets" => opt_bool(p, "on").map(|on| {
let v = &mut app.ui.view.shape_widgets;
*v = on.unwrap_or(!*v);
json!(*v)
}),
// New View: the engine stores the current zoom, centre and rotation under the given name.
"view.saved.new" if p.get("zoom").is_none() => {
let Some(v) = app.view().copied() else { return Some(Err("no document".into())) };
let mut params = if p.is_object() { p.clone() } else { json!({}) };
params["center"] = json!([v.center.x, v.center.y]);
params["zoom"] = json!(v.zoom);
params["rotation"] = json!(v.rotation);
app.session.execute(id, ¶ms).map_err(|e| e.to_string())
}
// A saved view: its zoom, centre and rotation, in the current window.
id if saved_view_slot(id).is_some() => {
let saved = saved_view(app, id).and_then(|sv| crate::state::View::saved(sv).map(|to| (sv.name.clone(), to)));
match (saved, app.view_mut()) {
(Some((name, to)), Some(v)) => {
(v.center, v.zoom, v.rotation) = (to.center, to.zoom, to.rotation);
Ok(json!({ "name": name }))
}
_ => Err("no such view".into()),
}
}
id if saved_selection_slot(id).is_some() => match saved_selection_name(app, id) {
Some(name) => app.run("select.recall", json!({ "name": name })),
None => Err("no such saved selection".into()),
},
"view.snapToPixel" => flag(&mut app.ui.view.snap_to_pixel),
"view.snapToGlyph" => flag(&mut app.ui.view.snap_to_glyph),
// The preference itself (General › Use Precise Cursors), so the command, the dialog and the saved
// preferences share one value.
"view.preciseCursors" => {
let on = !app.session.prefs.use_precise_cursors;
app.run("prefs.set", json!({"key": "usePreciseCursors", "value": on})).map(|_| {
crate::prefs_dialog::snapshot(app);
json!(on)
})
}
"view.textThreads" => flag(&mut app.ui.view.text_threads),
"type.hiddenCharacters" => flag(&mut app.ui.view.hidden_chars),
"edit.autoSpellCheck" => flag(&mut app.ui.view.auto_spell_check),
"type.bold" => crate::panels::character::toggle_face(app, Face::Bold),
"type.italic" => crate::panels::character::toggle_face(app, Face::Italic),
"type.highlightFontName" => crate::panels::character::highlight(app, crate::panels::character::Field::FontName),
"type.highlightFontSize" => crate::panels::character::highlight(app, crate::panels::character::Field::FontSize),
"type.highlightKerning" => crate::panels::character::highlight(app, crate::panels::character::Field::Kerning),
"type.highlightTracking" => crate::panels::character::highlight(app, crate::panels::character::Field::Tracking),
"type.underline" => crate::panels::character::toggle_underline(app),
"type.superscript" => crate::panels::character::toggle_position(app, "superscript"),
"type.subscript" => crate::panels::character::toggle_position(app, "subscript"),
"type.lineComposer" => crate::panels::paragraph::toggle_composer(app),
"type.hyphenate" => crate::panels::paragraph::toggle_hyphenate(app),
id if let Some((_, justify)) = crate::panels::paragraph::ALIGN_COMMANDS.iter().find(|c| c.0 == id) => {
crate::panels::paragraph::align(app, justify)
}
"type.applyBullets" => crate::panels::paragraph::apply_bullets(app, p),
"type.applyNumbers" => crate::panels::paragraph::apply_numbers(app, p),
"ui.bulletsAndNumbering" => crate::dialogs::bullets_numbering::open(app, p),
_ => return None,
};
Some(r)
}
/// UI commands, part 4.
fn run_ui_part4(app: &mut VectorcraftApp, id: &str, _p: &Value) -> Option<Result<Value, String>> {
let flag = |b: &mut bool| {
*b = !*b;
Ok(json!(*b))
};
let r = match id {
"type.convertListToText" => crate::panels::paragraph::convert_list_to_text(app),
id if let Some(b) = crate::panels::align::button(id) => crate::panels::align::run_button(app, b),
id if let Some(v) = crate::panels::align::align_to_command(id) => crate::panels::align::run_align_to(app, v),
"view.gradientAnnotator" => flag(&mut app.ui.view.gradient_annotator),
"view.livePaintGaps" => flag(&mut app.ui.view.live_paint_gaps),
"effect.last" => match app.last_effect.clone() {
Some((e, params)) => {
let label = vectorcraft_effects::effect_info(&e).map(|i| i.label.trim_end_matches('…').to_string()).unwrap_or_else(|| e.clone());
let mut fields = params.as_object().cloned().unwrap_or_default();
fields.insert("__effect".into(), json!(e));
fields.insert("__label".into(), json!(label));
fields.insert("preview".into(), json!(true));
app.ui.dialog = Some(crate::state::Dialog { kind: "effect".into(), fields });
Ok(Value::Null)
}
None => Err("no effect applied yet".into()),
},
id if id.starts_with("type.recentFont") => {
let n: usize = id["type.recentFont".len()..].parse().unwrap_or(0);
match n.checked_sub(1).and_then(|i| app.recent_fonts().get(i)).cloned() {
Some(font) => app.run("text.setStyle", json!({ "font": font })),
None => Err("no such recent font".into()),
}
}
"view.edges" => flag(&mut app.ui.view.edges),
"view.artboards" => flag(&mut app.ui.view.artboards),
"view.template" => flag(&mut app.ui.view.templates),
"view.rulers" => flag(&mut app.ui.view.rulers),
"view.videoRulers" => {
let v = &mut app.ui.view;
let show = !(v.video_rulers && v.rulers);
v.video_rulers = show;
v.rulers |= show;
Ok(json!(show))
}
"view.boundingBox" => flag(&mut app.ui.view.bounding_box),
"view.guides" => {
let r = flag(&mut app.ui.view.guides);
// Hidden ruler guides and guide paths cannot stay selected: their selection overlay
// would otherwise reveal geometry that Hide Guides just hid.
let hidden_selection = !app.ui.view.guides
&& app.session.active().is_some_and(|d| {
!d.selection.guides.is_empty()
|| d.selection
.objects
.iter()
.any(|id| matches!(d.doc.node(*id).map(|n| &n.kind), Some(vectorcraft_doc::NodeKind::Path { guide: true, .. })))
});
if hidden_selection {
// Deselecting a document that is open cannot fail.
let _ = app.run("select.none", json!({}));
}
r
}
"view.smartGuides" => flag(&mut app.ui.view.smart_guides),
"view.grid" => flag(&mut app.ui.view.grid),
"view.snapToGrid" => flag(&mut app.ui.view.snap_to_grid),
_ => return None,
};
Some(r)
}
/// UI commands, part 5.
fn run_ui_part5(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let flag = |b: &mut bool| {
*b = !*b;
Ok(json!(*b))
};
let r = match id {
"view.snapToPoint" => flag(&mut app.ui.view.snap_to_point),
"view.zoomIn" | "view.zoomOut" => {
let up = id == "view.zoomIn";
let print = app.session.prefs.display_print_size;
// Selection & Anchor Display › Zoom to Selection: the selection comes to the middle.
let focus = if app.session.prefs.zoom_to_selection { app.selection_box().map(|b| b.center()) } else { None };
match app.view_mut() {
Some(v) => {
v.zoom = next_zoom(v.zoom, up);
if let Some(c) = focus {
v.center = c;
}
Ok(json!({"zoom": crate::state::zoom_display_percent(v.zoom, print)}))
}
None => Err("no document".into()),
}
}
"view.setZoom" => {
let print = app.session.prefs.display_print_size;
let (zoom, center) = match opt_number(p, "zoom").and_then(|z| Ok((z, opt_point(p, "center")?))) {
Ok(given) => given,
Err(e) => return Some(Err(e)),
};
let z = crate::state::zoom_from_display_percent(zoom.unwrap_or(100.0), print);
match app.view_mut() {
Some(v) => {
v.zoom = z.clamp(0.0313, 640.0);
v.fitted = true;
if let Some(c) = center {
v.center = c;
}
Ok(Value::Null)
}
None => Err("no document".into()),
}
}
"view.fitArtboard" | "view.fitAll" | "view.actualSize" => {
crate::canvas::fit(app, id);
Ok(Value::Null)
}
"view.goToArtboard" => go_to_artboard(app, p),
"view.statusBarShow" => crate::chrome::set_status_bar_show(app, p),
// The navigator's four buttons as commands of their own, so Edit › Keyboard Shortcuts lists
// them (view.goToArtboard needs an index, so a key alone can't run it).
"view.firstArtboard" => go_to_artboard(app, &json!({ "index": "first" })),
"view.previousArtboard" => go_to_artboard(app, &json!({ "index": "previous" })),
"view.nextArtboard" => go_to_artboard(app, &json!({ "index": "next" })),
"view.lastArtboard" => go_to_artboard(app, &json!({ "index": "last" })),
"view.presentation" => {
app.ui.screen_mode = if app.ui.screen_mode == 3 { 0 } else { 3 };
Ok(json!(app.ui.screen_mode))
}
"view.screenMode" => {
let mode = match opt_index(p, "mode") {
Ok(mode) => mode,
Err(e) => return Some(Err(e)),
};
app.ui.screen_mode = match mode {
Some(m) => m.min(3) as u8,
// F cycles the three screen modes. Without a mode, the command also goes from
// Presentation Mode (not in the cycle) back to Normal.
None if app.ui.screen_mode >= 2 => 0,
None => app.ui.screen_mode + 1,
};
Ok(json!(app.ui.screen_mode))
}
// View › Rotate View and the status bar's angle menu: the view turns about the center of the
// canvas to the angle, normalized as a Rotate View drag normalizes it.
"view.rotate" => {
let key = "angle";
let Some(angle) = p.get(key).and_then(Value::as_f64).filter(|a| a.is_finite()) else {
return Some(Err(format!("`{key}` must be a number")));
};
match app.view_mut() {
Some(v) => {
v.rotation = vectorcraft_geom::normalize_deg(angle);
Ok(json!({ "angle": v.rotation }))
}
None => Err("no document".into()),
}
}
// View › Rotate View to Selection: the view turns about the center of the canvas to the angle
// of the selection's bounding box, so the box is square to the window.
"view.rotateToSelection" => {
let Some(st) = app.session.active() else { return Some(Err("no document".into())) };
if st.selection.objects.is_empty() {
return Some(Err("nothing selected".into()));
}
let angle = vectorcraft_geom::normalize_deg(st.doc.bbox_angle(&st.selection.objects));
match app.view_mut() {
Some(v) => {
v.rotation = angle;
Ok(json!({ "angle": angle }))
}
None => Err("no document".into()),
}
}
"view.rotateReset" => {
if let Some(v) = app.view_mut() {
v.rotation = 0.0;
}
Ok(Value::Null)
}
"window.control" => flag(&mut app.ui.control_bar),
"window.helpBar" => flag(&mut app.ui.help_bar),
// The Control bar's panel menu and gripper: the edge of the window the bar docks to, or
// floating over the window at the position it last floated at.
"window.control.dock" => {
let key = "edge";
let edges = crate::chrome::CONTROL_BAR_EDGES;
match edges.iter().position(|e| s(key).as_deref() == Some(*e)) {
Some(i) => {
app.ui.control_bar_floating = i == 2;
if i < 2 {
app.ui.control_bar_bottom = i == 1;
}
Ok(json!({ key: edges[i] }))
}
None => Err(format!("`{key}` must be one of {}", edges.join(", "))),
}
}
// The Control bar's panel menu: a group of the bar's options on or off.
"window.control.options" => {
let groups = crate::chrome::CONTROL_BAR_GROUPS;
match (groups.iter().find(|g| s("group").as_deref() == Some(**g)), opt_bool(p, "visible")) {
(None, _) => Err(format!("`group` must be one of {}", groups.join(", "))),
(_, Err(e)) => Err(e),
(Some(&group), Ok(visible)) => {
let hidden = &mut app.ui.control_bar_hidden_groups;
let visible = visible.unwrap_or_else(|| hidden.contains(group));
if visible {
hidden.remove(group);
} else {
hidden.insert(group.to_string());
}
Ok(json!({ "group": group, "visible": visible }))
}
}
}
"window.toolbar" => flag(&mut app.ui.toolbar),
"window.toolbarCompact" => opt_bool(p, "on").map(|on| {
let on = on.unwrap_or(!app.ui.toolbar_compact);
app.ui.toolbar_compact = on;
json!(on)
}),
"window.toolbarColumns" => {
let toolbar = match crate::custom_toolbars::target(&app.ui, p) {
Ok(t) => t,
Err(e) => return Some(Err(e)),
};
let double = match toolbar.as_deref().and_then(|name| crate::custom_toolbars::find_mut(&mut app.ui, name)) {
Some(b) => &mut b.double,
None => &mut app.ui.toolbar_double,
};
opt_bool(p, "double").map(|on| {
let on = on.unwrap_or(!*double);
*double = on;
json!(on)
})
}
"window.toolbarAdvanced" => flag(&mut app.ui.toolbar_advanced),
"window.toolsBesideCanvas" => opt_bool(p, "on").map(|on| {
let on = on.unwrap_or(!app.ui.tools_beside_canvas);
app.ui.tools_beside_canvas = on;
json!(on)
}),
"imageTrace.preview" => opt_bool(p, "on").map(|on| {
let on = on.unwrap_or(!app.ui.image_trace_preview);
app.ui.image_trace_preview = on;
json!(on)
}),
"window.floatTools" => {
let floating = match opt_bool(p, "floating") {
Ok(on) => on,
Err(e) => return Some(Err(e)),
};
let Some(tool) = s("tool") else { return Some(Err("tool (a tool id) is required".into())) };
let toolbar = match crate::custom_toolbars::target(&app.ui, p) {
Ok(t) => t,
Err(e) => return Some(Err(e)),
};
crate::toolbar::float_group(app, &tool, floating, toolbar.as_deref()).map(Value::Bool)
}
_ => return None,
};
Some(r)
}
/// UI commands, part 6.
fn run_ui_part6(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let flag = |b: &mut bool| {
*b = !*b;
Ok(json!(*b))
};
let r = match id {
"window.taskBar" => flag(&mut app.ui.task_bar),
"window.pathfinder.compoundShapes" => flag(&mut app.ui.shape_modes_compound),
"window.taskBar.pin" => {
let place = &mut app.ui.task_bar_place;
opt_bool(p, "pinned").map(|pinned| {
let pinned = pinned.unwrap_or(!place.pinned);
// Pinning holds the bar where it shows; unpinning lets it follow the selection from
// there (the bar turns its pinned spot into an offset when it is next drawn).
if pinned && !place.pinned {
place.pin_at = place.shown_at;
}
place.pinned = pinned;
json!(pinned)
})
}
"window.taskBar.reset" => {
app.ui.task_bar_place = Default::default();
Ok(Value::Null)
}
"window.dock" => {
let ui = &mut app.ui;
// The bars the last Tab hid show again, unless the toolbar or the Control bar was shown
// another way since then (Window › Tools, Window › Control). Panels shown with Shift+Tab
// in between stay shown. Switching workspaces clears the record (`workspaces::apply`).
// A shown toolbar made with New Toolbar counts as a bar Tab hides, so a record with none
// of the three bars is of the toolbars made with New Toolbar alone.
let custom = ui.custom_toolbars.iter().any(|b| b.shown);
let hid = ui.tab_hid.take().filter(|_| !ui.toolbar && !ui.control_bar);
let on = if let Some(h) = hid {
ui.dock |= h.dock;
ui.toolbar = h.toolbar;
ui.control_bar = h.control_bar;
true
} else if ui.dock || ui.toolbar || ui.control_bar || custom {
ui.tab_hid = Some(crate::state::TabHid { dock: ui.dock, toolbar: ui.toolbar, control_bar: ui.control_bar });
ui.dock = false;
ui.toolbar = false;
ui.control_bar = false;
ui.open_panel = None;
false
} else {
ui.dock = true;
ui.toolbar = true;
ui.control_bar = true;
true
};
Ok(json!(on))
}
"window.panels" => {
let on = !app.ui.dock;
app.ui.dock = on;
if !on {
app.ui.open_panel = None;
}
Ok(json!(on))
}
"window.brightness" => match s("brightness").as_deref().and_then(Brightness::parse) {
Some(b) => {
app.ui.brightness = b;
app.session.prefs.ui_brightness = b.id().into();
app.canvas.key = None;
Ok(json!(b.id()))
}
None => Err("brightness must be dark|mediumDark|mediumLight|light".into()),
},
"window.newWindow" => crate::doc_windows::new_window(app),
"window.arrange.cascade" => crate::doc_windows::cascade(app),
"window.arrange.tile" => crate::canvas::tile(app, p),
"window.arrange.floatInWindow" => crate::doc_windows::float_in_window(app, p),
"window.arrange.floatAllInWindows" => crate::doc_windows::float_all(app),
"window.arrange.consolidateAllWindows" if p.get("index").is_some_and(|i| !i.is_null()) => crate::doc_windows::dock(app, p),
"window.arrange.consolidateAllWindows" => crate::canvas::consolidate(app),
"window.nextDocument" => crate::chrome::step_document(app, true),
"window.previousDocument" => crate::chrome::step_document(app, false),
"tool.select" => match s("tool") {
Some(t) if vectorcraft_tools::tool_info(&t).is_some() => app.try_select_tool(&t).map(|()| json!({"tool": app.session.tool_id()})),
Some(t) => Err(format!("unknown tool `{t}`")),
None => Err("missing `tool`".into()),
},
"tool.selectLastSelection" => {
let id = app.session.last_selection_tool();
let switched = if app.session.tool_id() == id { Ok(()) } else { app.try_select_tool(id) };
switched.map(|()| json!({"tool": app.session.tool_id()}))
}
"tool.switchSelectionTools" => {
let tool = if app.session.tool_id() == "selection" { "directSelection" } else { "selection" };
app.try_select_tool(tool).map(|()| json!({"tool": app.session.tool_id()}))
}
crate::touch::TOGGLE_MODE => crate::touch::toggle_mode(app),
crate::addons::pathtools::corner::COMMAND => crate::addons::pathtools::corner::open(app),
crate::addons::pathtools::shared_edge::COMMAND => crate::addons::pathtools::shared_edge::open(app),
crate::addons::arrange::ZOOM => crate::addons::arrange::zoom(app),
crate::addons::select::link_status::COMMAND => crate::addons::select::link_status::run(app, p),
crate::addons::document::SAVE_COPY => crate::addons::document::save_copy(app, p),
crate::addons::document::EXPORT_ALL => crate::addons::document::export_all(app, p),
crate::addons::document::BATCH_TRACE => crate::addons::document::batch_trace(app, p),
"tool.setOption" => app.session.set_tool_option_cmd(p),
"effect.dialog" => crate::dialogs::open_effect_dialog(app, p),
"ui.recolorDialog" => crate::dialogs::recolor::open(app, p),
"ui.cropImage" if !selected_image(app, |_| true) => Err("select an image".into()),
"ui.cropImage" => app.try_select_tool(vectorcraft_tools::cropimage::ID).map(|()| json!({"tool": app.session.tool_id()})),
// Create Object Mosaic… has a dialog of its own, opened on the selected image.
"ui.paramDialog" if s("command").as_deref() == Some(crate::dialogs::object_mosaic::COMMAND) => {
crate::dialogs::object_mosaic::open(app, p.get("params").unwrap_or(&Value::Null))
}
"ui.paramDialog" => {
let cmd = s("command").unwrap_or_default();
let mut fields = p.get("params").and_then(Value::as_object).cloned().unwrap_or_default();
// Find and Replace has a dialog of its own, which stays open from match to match.
if cmd == crate::dialogs::find_replace::COMMAND {
return Some(crate::dialogs::find_replace::open(app, &fields));
}
fields.insert("__command".into(), json!(cmd));
fields.insert("__label".into(), json!(s("label").unwrap_or(cmd.clone())));
app.ui.dialog = Some(crate::state::Dialog { kind: "command".into(), fields });
Ok(Value::Null)
}
"effect.applyLast" => match app.last_effect.clone() {
Some((e, params)) => app.run("effect.apply", json!({"effect": e, "params": params})),
None => Err("no effect applied yet".into()),
},
"pathfinder.repeat" => crate::panels::pathfinder::repeat(app),
"file.export.pdf" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::open_save_pdf(app, &json!({})),
"file.export.pdf" => io::export_pdf(app, p.clone()),
_ => return None,
};
Some(r)
}
/// UI commands, part 7.
fn run_ui_part7(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"help.about" => {
app.ui.about = true;
Ok(Value::Null)
}
"help.checkForUpdates" => crate::updates_ui::check(app),
"help.safeMode" => crate::dialogs::safe_mode::open(app),
"help.copyTroubleshootingInfo" => crate::troubleshooting::copy(app),
"help.commandPalette" => {
app.ui.palette_open = !app.ui.palette_open;
app.ui.palette_query.clear();
Ok(Value::Null)
}
// Closing asks Save / Don't Save / Cancel for modified documents first (`unsaved`).
// Without an `index`, the current window closes: one of several views of a document closes
// without closing the document (Window › New Window).
"file.close" => match opt_index(p, "index") {
Err(e) => Err(e),
Ok(Some(i)) => crate::unsaved::close(app, i),
Ok(None) => {
app.session.active_index()?;
crate::doc_windows::close_current(app)
}
},
"file.closeAll" => crate::unsaved::close_all(app, "closeAll"),
"app.quit" => crate::unsaved::close_all(app, "quit"),
"ui.swatchOptions" => match s("name") {
Some(name) => crate::dialogs::swatch_options::open(app, &name),
None => Err("missing `name`".into()),
},
"ui.newSwatch" => {
let on = |k: &str| opt_bool(p, k).map(|on| on.unwrap_or(false));
on("spot")
.and_then(|spot| Ok((spot, on("global")?)))
.and_then(|(spot, global)| crate::dialogs::new_swatch::open(app, spot, global, s("group").as_deref()))
}
"ui.newColorGroup" => {
let names = p.get("swatches").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
crate::dialogs::new_color_group::open(app, names.unwrap_or_default())
}
"ui.colorGroupOptions" => crate::dialogs::color_group_options::open(app, p),
"ui.colorPicker" => crate::dialogs::open_color_picker(app, p),
"ui.sampleScreenColor" => crate::screen_color::start(app, p),
"ui.graphicStyleOptions" => crate::dialogs::graphic_style_options::open(app, s("name").as_deref()),
"ui.charStyleOptions" => match s("name") {
Some(name) => crate::dialogs::char_style_options::open(app, &name),
None => Err("missing `name`".into()),
},
"ui.charStyleOptions.resetPanel" => crate::dialogs::char_style_options::reset_panel(app),
"ui.paraStyleOptions" => match s("name") {
Some(name) => crate::dialogs::para_style_options::open(app, &name),
None => Err("missing `name`".into()),
},
"ui.paraStyleOptions.resetPanel" => crate::dialogs::para_style_options::reset_panel(app),
"ui.newCharStyle" => crate::panels::text_styles::open_new(app, crate::panels::text_styles::Kind::Char),
"ui.newParaStyle" => crate::panels::text_styles::open_new(app, crate::panels::text_styles::Kind::Para),
"ui.symbolOptions" => {
let name = s("name");
let edit = match opt_bool(p, "edit") {
Ok(edit) => edit.unwrap_or(false),
Err(e) => return Some(Err(e)),
};
let keep_art = match opt_bool(p, "keepArt") {
Ok(keep) => keep.unwrap_or(false),
Err(e) => return Some(Err(e)),
};
if edit || name.is_some() {
if keep_art {
return Some(Err("`keepArt` applies only to a new symbol".into()));
}
crate::dialogs::symbol_options::open_edit(app, name.as_deref())
} else {
crate::dialogs::symbol_options::open(app, keep_art)
}
}
"ui.newBrush" => crate::dialogs::new_brush::open(app, p.get("ids").cloned()),
"ui.brushOptions" => crate::dialogs::brush_options::open(app, s("name").as_deref()),
"ui.brushObjectOptions" => crate::dialogs::brush_options::open_object(app),
"tool.options" => crate::toolbar::open_options(app, &s("tool").unwrap_or_default()),
_ => return None,
};
Some(r)
}
/// UI commands, part 8.
fn run_ui_part8(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"ui.colorGuideOptions" => {
crate::dialogs::color_guide_options::open(app);
Ok(Value::Null)
}
"ui.colorBalanceDialog" => {
crate::dialogs::color_balance::open(app);
Ok(Value::Null)
}
"ui.saturateDialog" => {
crate::dialogs::saturate::open(app);
Ok(Value::Null)
}
"ui.indexedColorDialog" => {
crate::dialogs::indexed_color::open(app);
Ok(Value::Null)
}
"window.swatchLibrary" => crate::panels::swatches::open_library(app, p),
"window.swatchLibrary.other" => crate::panels::swatches::other_library(app, s("path")),
"ui.saveSwatchLibrary" => {
let names = p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
crate::dialogs::save_swatch_library::open(app, names.unwrap_or_default())
}
id if id.starts_with(crate::panels::swatches::USER_SLOT) => match crate::panels::swatches::user_library(app, id) {
Some(l) => crate::panels::swatches::open_library(app, &json!({ "library": l.id })),
None => Err("no such user library".into()),
},
"ui.mergeGraphicStyles" => {
let names = p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
crate::dialogs::graphic_style_options::open_merge(app, names.unwrap_or_default())
}
"ui.tileEdgeColor" => crate::dialogs::tile_edge_color::open(app),
"ui.layerOptions" => crate::dialogs::layer_options::open(app, p),
"ui.layerDelete" => crate::panels::layers::delete(app, p),
"ui.rename" => crate::panels::layers::rename(app, p),
"ui.newLayer" => crate::dialogs::layer_options::open_new(app, p),
"ui.newArtboard" => crate::dialogs::artboard_options::open_new(app),
"artboard.selectAll" => crate::panels::artboards::select_all_command(app),
"ui.layersPanelOptions" => crate::dialogs::layers_panel_options::open(app),
"ui.navigatorPanelOptions" => crate::panels::navigator::set_options(app, p),
"ui.attributesPanelOptions" => crate::panels::attributes::set_options(app, p),
"ui.layersExpand" => crate::panels::layers::expand(app, p),
"ui.layersFilter" => crate::panels::layers::set_filter(app, p),
"ui.panelView" => crate::panels::set_view(app, p),
"ui.flattenTransparencyDialog" => {
crate::dialogs::flatten::open(app);
Ok(Value::Null)
}
_ => return None,
};
Some(r)
}
/// UI commands, part 9.
fn run_ui_part9(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"ui.flattenerPresetsDialog" => {
crate::dialogs::flattener_presets::open(app, s("selected").as_deref());
Ok(Value::Null)
}
"ui.imageTracePresetDialog" => crate::dialogs::trace_presets::open(app, p),
"ui.flattenerPreview" => crate::panels::flattener_preview::command(app, p),
"ui.foldPreview" => crate::addons::packaging::preview::command(app, p),
"ui.copyScriptConsole" => crate::panels::script_console::copy(app, p),
"window.graphicStyleLibrary" => crate::panels::graphic_styles::open_library(app, p),
"ui.libraryPanel" => crate::panels::library_panel::command(app, p),
"ui.libraryPanel.locate" => crate::panels::library_panel::locate(app, p),
"window.graphicStyleLibrary.other" => crate::panels::graphic_styles::other_library(app, s("path")),
"ui.saveGraphicStyleLibrary" => {
let names = p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
crate::dialogs::save_style_library::open(app, names.unwrap_or_default())
}
"ui.loadCharStyles" => crate::panels::text_styles::load(app, "charStyle.load", s("path")),
"ui.loadParaStyles" => crate::panels::text_styles::load(app, "paraStyle.load", s("path")),
"ui.loadAllStyles" => crate::panels::text_styles::load(app, "textStyle.loadAll", s("path")),
id if id.starts_with(crate::panels::graphic_styles::USER_SLOT) => match crate::panels::graphic_styles::user_library(app, id) {
Some(l) => crate::panels::graphic_styles::open_library(app, &json!({ "library": l.id })),
None => Err("no such user library".into()),
},
"window.symbolLibrary" => crate::panels::symbols::open_library(app, p),
"window.symbolLibrary.other" => crate::panels::symbols::other_library(app, s("path")),
"ui.saveSymbolLibrary" => {
let names = p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
crate::dialogs::save_symbol_library::open(app, names.unwrap_or_default())
}
id if id.starts_with(crate::panels::symbols::USER_SLOT) => match crate::panels::symbols::user_library(app, id) {
Some(l) => crate::panels::symbols::open_library(app, &json!({ "library": l.id })),
None => Err("no such user library".into()),
},
"window.brushLibrary" => crate::panels::brushes::open_library(app, p),
"window.brushLibrary.other" => crate::panels::brushes::other_library(app, s("path")),
"ui.saveBrushLibrary" => {
let names = p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
crate::dialogs::save_brush_library::open(app, names.unwrap_or_default())
}
id if id.starts_with(crate::panels::brushes::USER_SLOT) => match crate::panels::brushes::user_library(app, id) {
Some(l) => crate::panels::brushes::open_library(app, &json!({ "library": l.id })),
None => Err("no such user library".into()),
},
_ => return None,
};
Some(r)
}
/// UI commands, part 10.
fn run_ui_part10(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"ui.expandDialog" => match opt_bool(p, "immediate") {
Ok(Some(true)) => crate::dialogs::expand::expand_now(app),
Ok(_) => crate::dialogs::expand::open(app),
Err(e) => Err(e),
},
"ui.simplifyAuto" => crate::dialogs::simplify_slider::auto(app),
"ui.simplifyMoreOptions" => crate::dialogs::simplify_slider::more_options(app),
"ui.smoothAuto" => crate::dialogs::smooth_slider::auto(app),
"ui.recolorUndo" => crate::dialogs::recolor::step(app, true),
"ui.recolorRedo" => crate::dialogs::recolor::step(app, false),
"ui.dialogReset" => crate::dialogs::reset(app),
"attributes.openUrl" => crate::panels::attributes::open_url(app, p),
"ui.javascriptFilesDialog" => crate::panels::svg_interactivity::files_dialog(app, p),
"ui.svgFilterDialog" => crate::dialogs::svg_filter::open(app, p),
"ui.importSvgFilter" => crate::dialogs::svg_filter::import_file(app),
"ui.spotColors" => crate::dialogs::spot_colors::open(app),
"ui.menuDialog" => {
// As from the menu ([`invoke`]), the edit the tool computes on another thread first.
let r = app.session.finish_tool_edit();
crate::canvas::apply_requests(app, r);
match s("command").as_deref() {
Some(c) if crate::dialogs::envelope::opens(c) => crate::dialogs::envelope::open(app, c),
c => match c.and_then(|c| menu_dialog(app, c)) {
Some((kind, fields)) => {
app.ui.dialog = Some(crate::state::Dialog::new(kind, fields));
Ok(Value::Null)
}
None => Err("`command` must be a command whose menu item opens a dialog (see ui.menuDialog)".into()),
},
}
}
"ui.widthPointEdit" => crate::dialogs::width_point::open(app, p),
"ui.corners" => crate::dialogs::corners::open(app, p),
"ui.hyphenation" => crate::dialogs::hyphenation::open(app),
"ui.justification" => crate::dialogs::justification::open(app),
"ui.tateChuYokoSettings" => crate::dialogs::tate_chu_yoko::open(app),
"ui.warichuSettings" => crate::dialogs::warichu::open(app),
"ui.colorGuideLimit" => crate::panels::color_guide::set_limit(app, p),
"ui.colorPanel" => crate::panels::color::command(app, p),
"ui.colorRgbPercent" => crate::panels::color::rgb_percent_command(app, p),
"ui.colorWheel" => crate::panels::color_wheel::command(app, p),
"ui.savePdfDialog" => crate::dialogs::open_save_pdf(app, p),
crate::dialogs::SAVE_PDF_SUMMARY => crate::dialogs::save_pdf_summary(app, p),
"file.exportAs" if s("path").is_none() => {
crate::dialogs::open_export_as(app, s("format").as_deref(), p);
Ok(Value::Null)
}
"file.exportAs" => io::export(app, s("format").as_deref(), s("path"), p),
_ => return None,
};
Some(r)
}
/// UI commands, part 11.
fn run_ui_part11(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"ui.fileInfoDialog" => crate::dialogs::file_info::open(app),
"ui.rasterEffectsSettingsDialog" => crate::dialogs::raster_effects::open(app),
"ui.effectGalleryDialog" => crate::dialogs::effect_gallery::open(app, p),
"ui.pdfPresetsDialog" => {
crate::dialogs::pdf_presets::open(app, s("selected").as_deref());
Ok(Value::Null)
}
"ui.pdfPresetDialog" => crate::dialogs::open_pdf_preset(app, p),
// Save for Office Documents…: its dialog; with options, pick the file (or write `path`).
"document.exportForOffice" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::office_export::open(app),
"document.exportForOffice" => io::save_command_output(app, id, "png", p.clone()).map(|path| json!({ "path": path })),
"ui.dxfOptionsDialog" if app.session.active().is_none() => Err("no document".into()),
"ui.dxfOptionsDialog" => {
crate::dialogs::dxf_options::open(app, p);
Ok(Value::Null)
}
"links.editOriginal" => crate::panels::links::open_file(app, p, false),
"links.reveal" => crate::panels::links::open_file(app, p, true),
"links.copyInfo" => crate::panels::links::copy_info(app, p),
"ui.placementOptionsDialog" => crate::dialogs::placement_options::open(app, p),
"ui.relinkDialog" => crate::dialogs::relink::open(app, p),
"ui.findLinksInFolder" => {
crate::dialogs::find_links::find_in_folder_command(app, s("folder"), p.get("ids").and_then(Value::as_array).cloned())
}
"ui.packageDialog" => crate::dialogs::package::open(app),
crate::panels::actions::RENAME_ACTION => crate::panels::actions::rename_action(app, p),
crate::panels::actions::INCLUDE_STEPS => crate::panels::actions::include_steps(app, p),
crate::panels::actions::NEW_ACTION => crate::panels::actions::new_action(app, p),
crate::panels::actions::ACTION_OPTIONS => crate::panels::actions::action_options(app, p),
crate::panels::actions::PLAY_ACTION => crate::panels::actions::play_action(app, p),
crate::panels::actions::PLAY_AT => crate::panels::actions::play_at(app, p),
crate::panels::actions::BUTTON_MODE => crate::panels::actions::button_mode(app, p),
crate::panels::actions::PLAYBACK_OPTIONS => crate::panels::actions::playback_options(app, p),
crate::panels::actions::START_RECORDING => crate::panels::actions::record(app, p),
crate::panels::actions::STOP_RECORDING => crate::panels::actions::stop(app, p),
crate::panels::actions::INSERT_STOP => crate::panels::actions::insert_stop(app, p),
crate::panels::actions::INSERT_MENU_ITEM => crate::panels::actions::insert_menu_item(app, p),
crate::panels::actions::INSERT_SELECT_PATH => crate::panels::actions::insert_select_path(app, p),
crate::panels::actions::INSERT_SELECT_OBJECT => crate::panels::actions::insert_select_object(app, p),
crate::panels::actions::CONTINUE_PLAYBACK => crate::panels::actions::continue_playback(app, p),
crate::panels::actions::DELETE_STEP => crate::panels::actions::delete_step(app, p),
crate::panels::actions::MOVE_STEP => crate::panels::actions::move_step(app, p),
"ui.batchDialog" => {
let index = |k: &str| opt_index(p, k).map(|i| i.unwrap_or(0));
index("set").and_then(|set| Ok((set, index("action")?))).and_then(|(set, action)| crate::dialogs::action_batch::open(app, set, action))
}
crate::panels::actions::SAVE_SET => crate::panels::actions::save_set(app, p),
crate::panels::actions::LOAD_SET => crate::panels::actions::load_set(app, p),
crate::panels::actions::REPLACE_SET => crate::panels::actions::replace_set(app, p),
crate::panels::actions::DELETE_SETS => crate::panels::actions::delete_sets(app, p),
crate::panels::actions::DUPLICATE => crate::panels::actions::duplicate(app, p),
crate::panels::actions::RESET => crate::panels::actions::reset(app, p),
crate::panels::actions::CLEAR => crate::panels::actions::clear(app, p),
"ui.shortcutImportDialog" => crate::dialogs::shortcut_import::command(app, p),
_ => return None,
};
Some(r)
}
/// UI commands, part 12.
fn run_ui_part12(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"file.showPackage" => crate::dialogs::package::show_package(app, p),
"docInfo.save" => crate::panels::doc_info::save_report(app, p),
// Slice Options… and Divide Slices…: their dialogs, on the selected slices.
"object.slice.options" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::slices::open_options(app),
"object.slice.divide" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::slices::open_divide(app),
"ui.epsOptionsDialog" if app.session.active().is_none() => Err("no document".into()),
"ui.epsOptionsDialog" => {
crate::dialogs::eps_options::open(app, p);
Ok(Value::Null)
}
"ui.hpglOptionsDialog" if app.session.active().is_none() => Err("no document".into()),
"ui.hpglOptionsDialog" => {
crate::dialogs::hpgl_options::open(app, p);
Ok(Value::Null)
}
// Save for Web: its dialog; with settings, write the files.
"file.saveForWeb" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::save_for_web::open(app),
"file.saveForWeb" => crate::dialogs::save_for_web::save(app, p.clone()),
"file.saveForWeb.browser" => crate::dialogs::save_for_web::browser_preview(app, p),
// File → Export Selection…: the selection becomes one asset (`multiple: true`: one per
// object), shown checked on Export for Screens' Assets tab.
"file.exportSelection" => {
let multiple = match opt_bool(p, "multiple") {
Ok(multiple) => multiple.unwrap_or(false),
Err(e) => return Some(Err(e)),
};
app.run("assets.add", json!({ "multiple": multiple })).map(|r| {
let ids: Vec<u64> = r["assets"].as_array().into_iter().flatten().filter_map(Value::as_u64).collect();
crate::dialogs::open_export_for_screens_assets(app, Some(&ids));
json!({ "assets": ids })
})
}
"css.copy" => crate::panels::css_properties::copy(app, p),
"css.exportFile" => crate::panels::css_properties::export_file(app, p),
// File → Print…: its dialog; with params, print (or save the job as a PDF) without it.
"file.print" if p.as_object().is_none_or(|o| o.is_empty()) => crate::dialogs::print::open(app),
"file.print" => crate::print::run(app, p),
"print.printers" => Ok(crate::print::printers(app)),
"print.printerSetup" => {
let printer = s("printer").filter(|n| !n.is_empty());
match app.services.print.as_mut() {
Some(service) => service.setup(printer.as_deref()).map(|_| Value::Null),
None => Err("printing isn't available here".into()),
}
}
_ => return None,
};
Some(r)
}
/// UI commands, part 13.
fn run_ui_part13(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
let r = match id {
"ui.printPresetsDialog" => {
crate::dialogs::print_presets::open(app, s("selected").as_deref());
Ok(Value::Null)
}
"ui.printPresetDialog" => crate::dialogs::print::open_preset(app, p),
"plugin.dialog" => crate::dialogs::plugin::open(app, p),
"ui.installPlugin" => io::install_plugin(app, p),
"plugin.cancelRuns" => Ok(crate::plugin_runs::cancel_all(app)),
"plugin.hideRuns" => Ok(crate::plugin_runs::hide_all(app)),
"imageTrace.cancelRuns" => Ok(crate::trace_runs::cancel_all(app)),
"imageTrace.hideRuns" => Ok(crate::trace_runs::hide_all(app)),
"ui.checkScript" => crate::dialogs::script_check::command(app, p),
"ui.runScript" => crate::dialogs::script_run::command(app, p),
crate::scripts_menu::COMMAND => crate::scripts_menu::run(app, p),
"ui.perspectiveGridDialog" => crate::dialogs::perspective_grid::open(app),
"ui.perspectivePresetsDialog" => {
crate::dialogs::perspective_presets::open(app, s("selected").as_deref());
Ok(Value::Null)
}
"ui.savePerspectivePreset" => crate::dialogs::perspective_grid::open_save(app),
id if id.starts_with(crate::dialogs::perspective_presets::SLOT) => match crate::dialogs::perspective_presets::slot_preset(app, id) {
Some(name) => app.run("perspective.grid.preset", json!({ "name": name })),
None => Err("no such perspective grid preset".into()),
},
"ui.blendOptions" => crate::dialogs::blend_options::open(app),
"ui.livePaintGapOptions" => crate::dialogs::live_paint_gaps::open(app),
"ui.perspectivePlane" => crate::dialogs::perspective_plane::open(app, p),
crate::dialogs::check_spelling::COMMAND => crate::dialogs::check_spelling::open(app),
_ => return None,
};
Some(r)
}
/// `view.goToArtboard`: make artboard `index` (a number, or first / previous / next / last from
/// the current one) active, synchronizing the Artboard tool when in use, and fit it in the window.
fn go_to_artboard(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
let n = app.session.active().map(|d| d.doc.artboards.len()).ok_or("no document open")?;
let last = n.checked_sub(1).ok_or("the document has no artboards")?;
let current = app.view().map_or(0, |v| v.artboard).min(last);
let to = match p.get("index") {
Some(Value::String(s)) => match s.as_str() {
"first" => 0,
"previous" => current.saturating_sub(1),
"next" => current + 1,
"last" => last,
other => return Err(format!("index must be a number or first, previous, next or last, not `{other}`")),
},
Some(v) => v.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or("index must be a number or first, previous, next or last")?,
None => return Err("missing index".into()),
}
.min(last);
crate::panels::artboards::select(app, to);
crate::canvas::fit(app, "view.fitArtboard");
Ok(json!({ "index": to }))
}
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.