2bc41aeb8602
print.rs
//! File → Print: the Print dialog. The print preset (and Save Preset…) and the printer (and
//! Setup…) on top, then the sections General,
//! Marks and Bleed, Output, Graphics, Color Management, Advanced and Summary, with a preview of the
//! printed page under the section list: the arrows step through the pages, dragging the art moves
//! its placement on the paper.
//!
//! The fields are the print settings (`print.setup`'s; sections are objects such as `marks`) plus
//! `printer` (a name from `print.printers`, "" the system's default), `toFile` (save the job as a
//! PDF instead) and UI-only `__` keys, so agents fill the dialog with `ui.dialog.set`. Print (OK)
//! keeps the settings with the document (`print.setup`) and prints them (`file.print`); Done
//! (`discard: true`, then confirm) only keeps them. The preview, the inks and the Summary come
//! from `print.preview`: the dialog lays nothing out itself.
//!
//! `preset` names the print preset whose settings were loaded last: setting it (the list, or
//! `ui.dialog.set`) loads that preset's settings. Save Preset… names the settings as a preset
//! (`print.presets.save`). The same dialog edits a preset (kind `printPreset`, from Edit → Print
//! Presets): a `name` instead of the preset and printer, and OK saves the preset.
use std::sync::{Arc, LazyLock};
use serde_json::{Value, json};
use vectorcraft_color::cms::Intent;
use vectorcraft_geom::Rect as DRect;
use vectorcraft_pdf::{
Choice, Emulsion, FontDownload, Media, Orientation, Origin, OutputMode, PrintArtboards, PrintImage, PrintLayers, PrintOverprints, PrintScaling,
PrintSettings,
};
use super::save_pdf::{TOP_LABEL_WIDTH, choice, current_section, flag, get, heading, length, note, number, pick, row, row_with, set, text};
use super::{DialogSpec, form};
use crate::state::Dialog;
use crate::theme::{self, Tokens};
use crate::{VectorcraftApp, widgets};
use vectorcraft_engine::cmd::printpresets::DEFAULT_PRESET;
pub(super) const KIND: &str = "print";
pub(super) const SPEC: DialogSpec =
DialogSpec { heading: |_| tl!("Print").into(), body, confirm, ok: Some("Print"), discard: Some("Done"), ..DialogSpec::FORM };
/// The dialog kind of the preset editor (New / Edit in Edit → Print Presets).
pub(super) const PRESET_KIND: &str = "printPreset";
pub(super) const PRESET_SPEC: DialogSpec = DialogSpec {
heading: |d| if d.str(EDITING).is_empty() { tl!("New Print Preset") } else { tl!("Edit Print Preset") }.into(),
body,
confirm: confirm_preset,
ok: Some("Save Preset"),
..DialogSpec::FORM
};
/// The preset editor's field holding the name of the saved preset it edits (empty: a new one).
const EDITING: &str = "__editing";
/// The field holding the name typed for Save Preset… (present while that row shows).
const SAVE_AS: &str = "__savePresetAs";
/// The preset whose settings were loaded last (`preset` loads its settings when it differs).
const LOADED: &str = "__loaded";
pub(super) const SECTIONS: [&str; 7] = ["General", "Marks and Bleed", "Output", "Graphics", "Color Management", "Advanced", "Summary"];
/// The default print settings as JSON: what a field an agent left out reads as.
static DEFAULTS: LazyLock<Value> = LazyLock::new(|| serde_json::to_value(PrintSettings::default()).unwrap_or_default());
/// The defaults of the settings a dialog of `kind` edits, when it is a Print dialog.
pub(super) fn defaults(kind: &str) -> Option<&'static Value> {
(kind == KIND || kind == PRESET_KIND).then(|| &*DEFAULTS)
}
/// Set when the Print Tiling tool placed the pages (`tileOrigin`): the placement is ignored.
const PLACED: &str = "tileOrigin.placed";
/// The link between Scale W and H.
const SCALE_LINKED: &str = "scale.linked";
/// Scale W and H as [`link_scale`] last left them, to tell which one changed since.
const SCALE_SEEN: &str = "__scaleSeen";
/// The fields that aren't print settings.
const NOT_SETTINGS: [&str; 5] = ["printer", "toFile", "discard", "preset", "name"];
/// The Printer list's entries besides the system's printers.
const DEFAULT_PRINTER: &str = "Default Printer";
const PDF_FILE: &str = "PDF File";
/// The preview's size in the section column.
const PREVIEW: egui::Vec2 = egui::vec2(super::save_pdf::LIST_WIDTH - 12.0, 168.0);
/// Open the Print dialog on the document's print settings and the system's default printer.
pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
let st = app.session.active().ok_or("no document")?;
// The settings saved with the document, every field filled in (defaults if never set up).
let saved: PrintSettings = st.doc.print_setup.clone().and_then(|v| serde_json::from_value(v).ok()).unwrap_or_default();
let mut fields = fields_of(&saved)?;
let printers = crate::print::printers(app);
let list = printers["printers"].as_array().map(Vec::as_slice).unwrap_or_default();
let default = list.iter().find(|p| p["default"] == true).or(list.first()).and_then(|p| p["name"].as_str()).unwrap_or_default();
fields.insert("printer".into(), json!(default));
fields.insert("toFile".into(), json!(!printers["service"].as_bool().unwrap_or(false)));
fields.insert("__printers".into(), printers);
app.ui.print_direct_pdf = false;
fields.insert("__section".into(), json!(SECTIONS[0]));
fields.insert("__sheet".into(), json!(0));
// The saved preset these settings are, if any (else [Default], shown as [Custom] if they differ).
let preset = app.session.prefs.print_presets.iter().find(|p| p.settings == saved).map_or(DEFAULT_PRESET, |p| p.name.as_str());
fields.insert("preset".into(), json!(preset));
fields.insert(LOADED.into(), json!(preset));
see_scale(&mut fields);
app.ui.dialog = Some(Dialog { kind: KIND.into(), fields });
Ok(Value::Null)
}
/// The settings as dialog fields.
fn fields_of(set: &PrintSettings) -> Result<serde_json::Map<String, Value>, String> {
match serde_json::to_value(set).map_err(|e| e.to_string())? {
Value::Object(fields) => Ok(fields),
_ => Err("print settings are not an object".into()),
}
}
/// Load the settings of the preset `preset` names once it changed (the list, or `ui.dialog.set`).
fn sync_preset(app: &VectorcraftApp, d: &mut Dialog) -> Result<(), String> {
let name = d.str("preset");
if d.kind != KIND || name == d.str(LOADED) {
return Ok(());
}
d.fields.insert(LOADED.into(), json!(name));
let set = app.session.print_preset_settings(&name).ok_or_else(|| format!("no print preset named `{name}`"))?;
d.fields.extend(fields_of(&set)?);
see_scale(&mut d.fields);
Ok(())
}
/// Save Preset…: save the settings under the typed name and pick that preset.
fn save_preset(app: &mut VectorcraftApp, d: &mut Dialog) -> Result<Value, String> {
let r = app.run("print.presets.save", json!({ "name": d.str(SAVE_AS), "preset": DEFAULT_PRESET, "settings": settings(d) }))?;
d.fields.remove(SAVE_AS);
d.fields.insert("preset".into(), r["name"].clone());
d.fields.insert(LOADED.into(), r["name"].clone());
Ok(r)
}
/// Open the preset editor on the saved preset `name`, or on a new preset starting from `preset`
/// (default: [Default]).
pub fn open_preset(app: &mut VectorcraftApp, params: &Value) -> Result<Value, String> {
let s = |k: &str| params.get(k).and_then(Value::as_str);
let (base, name, editing) = match s("name") {
Some(name) => {
let p = app.session.prefs.print_presets.iter().find(|p| p.name.eq_ignore_ascii_case(name.trim()));
let p = p.ok_or_else(|| format!("no saved print preset named `{name}` ({DEFAULT_PRESET} is protected: start a new one from it)"))?;
(p.name.clone(), p.name.clone(), p.name.clone())
}
None => (s("preset").unwrap_or(DEFAULT_PRESET).to_string(), app.session.new_print_preset_name(), String::new()),
};
let set = app.session.print_preset_settings(&base).ok_or_else(|| format!("no print preset named `{base}`"))?;
let mut fields = fields_of(&set)?;
fields.insert("name".into(), json!(name));
fields.insert(EDITING.into(), json!(editing));
fields.insert("__section".into(), json!(SECTIONS[0]));
fields.insert("__sheet".into(), json!(0));
see_scale(&mut fields);
app.ui.dialog = Some(Dialog { kind: PRESET_KIND.into(), fields });
Ok(Value::Null)
}
/// Save Preset (the preset editor's OK): `print.presets.save`, then back to Edit → Print Presets on
/// it. A new preset may not take the name of another one.
fn confirm_preset(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
let mut d = d.clone();
link_scale(&mut d);
let d = &d;
let (name, editing) = (d.str("name"), d.str(EDITING));
let p = if editing.is_empty() {
if app.session.print_preset_settings(&name).is_some() {
return Err(format!("a preset named `{}` exists", name.trim()));
}
json!({ "name": name, "preset": DEFAULT_PRESET, "settings": settings(d) })
} else {
json!({ "name": editing, "newName": name, "settings": settings(d) })
};
let r = app.run("print.presets.save", p)?;
super::print_presets::open(app, r["name"].as_str());
Ok(r)
}
/// The print settings the dialog stands for (`print.setup`'s `settings`).
pub(super) fn settings(d: &Dialog) -> Value {
let mut p = form::params(d);
if let Some(o) = p.as_object_mut() {
for k in NOT_SETTINGS {
o.remove(k);
}
}
p
}
/// Print, or Done (`discard`): keep the settings with the document (one undo step when they
/// changed), then print them; settings that can't print keep the dialog open, unchanged. While
/// Save Preset… asks for a name, it saves the preset instead.
fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
let mut d = d.clone();
// Done's flag holds for this press only: the dialog may stay open.
let done = d.fields.remove("discard").is_some_and(|v| v == true);
let synced = sync_preset(app, &mut d);
link_scale(&mut d);
app.ui.dialog = Some(d.clone());
synced?;
// While Save Preset… asks for a name, OK (and Enter) saves the preset instead.
if d.fields.contains_key(SAVE_AS) {
let r = save_preset(app, &mut d);
app.ui.dialog = Some(d);
return r;
}
let settings = settings(&d);
let p = json!({ "settings": settings });
// Laid out first, so a bad range or overlap is refused before anything is kept.
app.session.execute("print.preview", &p).map_err(|e| e.to_string())?;
app.run("print.setup", p)?;
if done {
app.ui.dialog = None;
return Ok(json!({ "settings": settings }));
}
let direct_pdf = app.ui.print_direct_pdf;
let r = crate::print::run(
app,
&json!({
"settings": settings,
"printer": d.str("printer"),
"toFile": d.bool("toFile"),
"directPdf": direct_pdf,
}),
)?;
app.ui.dialog = None;
Ok(r)
}
// ---------- the dialog ----------
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
let t = Tokens::get(ui.ctx());
if let Err(e) = sync_preset(app, d) {
app.status(e);
}
link_scale(d);
if d.kind == PRESET_KIND {
row_with(ui, tl!("Preset name:"), TOP_LABEL_WIDTH, |ui| {
form::text_edit(ui, d, "name", 288.0);
});
} else {
preset_rows(app, ui, d);
printer_row(app, ui, d);
}
ui.add_space(10.0);
let section = current_section(d, &SECTIONS);
let preview = preview_of(app, ui.ctx(), &settings(d));
ui.horizontal_top(|ui| {
super::save_pdf::section_frame(ui, |ui| {
super::save_pdf::section_list(ui, d, &SECTIONS, section);
ui.add_space(10.0);
page_preview(app, ui, d, &preview);
});
ui.add_space(14.0);
ui.vertical(|ui| {
ui.set_width(500.0);
ui.label(egui::RichText::new(tl!(section)).font(theme::semibold(14.0)).color(t.text_strong));
let list_h = super::modal::list_height(ui, 360.0);
egui::ScrollArea::vertical().id_salt(("print", section)).max_height(list_h).auto_shrink([false, false]).show(ui, |ui| match section {
"Marks and Bleed" => super::save_pdf::marks_and_bleeds(app, ui, d),
"Output" => output(ui, d, &preview),
"Graphics" => graphics(ui, d),
"Color Management" => color(ui, d),
"Advanced" => advanced(app, ui, d),
"Summary" => summary(ui, d, &preview, app.session.active().is_some()),
_ => general(app, ui, d),
});
});
});
false
}
/// The Print Preset row ([Default], the saved presets; [Custom] once the settings differ from the
/// preset's) with Save Preset…, and while Save Preset… asks for a name, the row taking it.
fn preset_rows(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
const CUSTOM: &str = "[Custom]";
let name = d.str("preset");
let current = serde_json::from_value::<PrintSettings>(settings(d)).ok();
let same = current.is_some() && current == app.session.print_preset_settings(&name);
let names: Vec<&str> = std::iter::once(DEFAULT_PRESET).chain(app.session.prefs.print_presets.iter().map(|p| p.name.as_str())).collect();
let mut picked = None;
let asking = d.fields.contains_key(SAVE_AS);
let mut ask = false;
row_with(ui, tl!("Print Preset:"), TOP_LABEL_WIDTH, |ui| {
// [Default] is ours (translated); the saved presets are names.
let current = if same { name.as_str() } else { tl!(CUSTOM) };
picked = super::mixed_dropdown(ui, "print-preset", current, &names, 300.0, |k| k == 0).and_then(|i| names.get(i)).map(|n| n.to_string());
let save = ui.add_enabled_ui(!asking, |ui| widgets::flat_button(ui, tl!("Save Preset…"), 96.0)).inner;
ask = save.on_hover_text(tl!("Save these settings as a print preset")).clicked();
});
if let Some(n) = picked {
// Picking the preset shown again brings its settings back.
d.fields.insert(LOADED.into(), json!(""));
d.fields.insert("preset".into(), json!(n));
if let Err(e) = sync_preset(app, d) {
app.status(e);
}
}
if ask {
d.fields.insert(SAVE_AS.into(), json!(app.session.new_print_preset_name()));
}
if d.fields.contains_key(SAVE_AS) {
row_with(ui, tl!("Save as preset:"), TOP_LABEL_WIDTH, |ui| {
form::text_edit(ui, d, SAVE_AS, 200.0);
if widgets::flat_button(ui, tl!("Save"), 52.0).clicked()
&& let Err(e) = save_preset(app, d)
{
app.status(e);
}
if widgets::flat_button(ui, tl!("Cancel"), 60.0).clicked() {
d.fields.remove(SAVE_AS);
}
});
}
}
/// What the Printer list offers.
enum Destination {
Printer(String),
/// The system's default printer (the web: the browser's print dialog).
Default,
File,
}
/// The Printer row: the system's printers (or its default one), PDF File; Setup….
fn printer_row(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
let printers = d.fields.get("__printers");
let names: Vec<String> = printers
.and_then(|p| p["printers"].as_array())
.map(|a| a.iter().filter_map(|p| p["name"].as_str().map(str::to_string)).collect())
.unwrap_or_default();
let service = printers.and_then(|p| p["service"].as_bool()).unwrap_or(false);
let setup = printers.and_then(|p| p["setup"].as_bool()).unwrap_or(false);
let mut entries: Vec<Destination> = names.iter().cloned().map(Destination::Printer).collect();
if service && names.is_empty() {
entries.push(Destination::Default);
}
entries.push(Destination::File);
// The system's printers by their names; the default printer and PDF File are ours.
let options: Vec<&str> = entries
.iter()
.map(|e| match e {
Destination::Printer(name) => name.as_str(),
Destination::Default => tl!(DEFAULT_PRINTER),
Destination::File => tl!(PDF_FILE),
})
.collect();
let printer = d.str("printer");
let current = if d.bool("toFile") {
tl!(PDF_FILE)
} else if printer.is_empty() {
tl!(DEFAULT_PRINTER)
} else {
printer.as_str()
};
row_with(ui, tl!("Printer:"), TOP_LABEL_WIDTH, |ui| {
match widgets::dropdown_names(ui, "print-printer", current, &options, 300.0).and_then(|i| entries.get(i)) {
Some(Destination::Printer(name)) => {
d.fields.insert("printer".into(), json!(name));
d.fields.insert("toFile".into(), json!(false));
}
Some(Destination::Default) => {
d.fields.insert("printer".into(), json!(""));
d.fields.insert("toFile".into(), json!(false));
}
Some(Destination::File) => {
d.fields.insert("toFile".into(), json!(true));
}
None => {}
}
let to_file = d.bool("toFile");
let tip = if setup { tl!("The system's settings of this printer") } else { tl!("No printer settings to open here") };
if ui.add_enabled_ui(setup && !to_file, |ui| widgets::flat_button(ui, tl!("Setup…"), 72.0)).inner.on_hover_text(tip).clicked()
&& let Err(e) = app.run("print.printerSetup", json!({ "printer": d.str("printer") }))
{
app.status(e);
}
});
if service && cfg!(windows) {
let to_file = d.bool("toFile");
ui.add_enabled(!to_file, egui::Checkbox::new(&mut app.ui.print_direct_pdf, "Send PDF directly (bypass driver)"));
note(ui, "Writes the print-ready PDF to the printer's TCP/IP RAW port, for PCL-only drivers that change the custom page size.");
}
}
/// `print.preview` of `settings` (an error when they can't print), cached until they or the
/// document change.
fn preview_of(app: &mut VectorcraftApp, ctx: &egui::Context, settings: &Value) -> Arc<Result<Value, String>> {
let doc = app.session.active().map_or((0, 0), |s| (s.uid, s.revision));
let stamp = egui::Id::unique((settings.to_string(), doc));
let key = egui::Id::unique("print-preview");
if let Some((s, v)) = ctx.data(|m| m.get_temp::<(egui::Id, Arc<Result<Value, String>>)>(key))
&& s == stamp
{
return v;
}
let v = Arc::new(app.session.execute("print.preview", &json!({ "settings": settings })).map_err(|e| e.to_string()));
ctx.data_mut(|m| m.insert_temp(key, (stamp, v.clone())));
v
}
/// A `[x0, y0, x1, y1]` array as a rectangle.
fn rect_of(v: &Value) -> Option<DRect> {
let n = |i: usize| v.get(i).and_then(Value::as_f64);
Some(DRect::new(n(0)?, n(1)?, n(2)?, n(3)?))
}
/// The page `__sheet` shows (clamped to the pages there are) and how many there are.
fn current_sheet<'a>(d: &Dialog, pv: &'a Value) -> Option<(usize, usize, &'a Value)> {
let sheets = pv["sheets"].as_array()?;
let i = (d.f64("__sheet", 0.0).max(0.0) as usize).min(sheets.len().checked_sub(1)?);
Some((i, sheets.len(), sheets.get(i)?))
}
/// The preview: the page with its imageable area (dashed) and the art as it prints; ◀ ▶ step
/// through the pages; dragging the art moves the placement (not when tiling).
fn page_preview(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog, pv: &Result<Value, String>) {
let t = Tokens::get(ui.ctx());
let (rect, resp) = ui.allocate_exact_size(PREVIEW, egui::Sense::drag());
ui.painter().rect_filled(rect, 3.0, t.pasteboard);
let sheet = pv.as_ref().ok().and_then(|v| current_sheet(d, v));
let Some((index, count, sheet)) = sheet else {
let text = match pv {
_ if app.session.active().is_none() => tl!("Open a document to preview its pages"),
Ok(_) => tl!("Nothing to print"),
Err(_) => tl!("Can't print these settings: see the Summary"),
};
let font = egui::FontId::proportional(11.0);
let galley = ui.painter().layout(text.into(), font, t.text_dim, rect.width() - 16.0);
ui.painter().galley(rect.center() - galley.size() / 2.0, galley, t.text_dim);
return;
};
let size = egui::vec2(sheet["width"].as_f64().unwrap_or(0.0) as f32, sheet["height"].as_f64().unwrap_or(0.0) as f32);
let fit = ((rect.width() - 16.0) / size.x).min((rect.height() - 16.0) / size.y);
if !(fit.is_finite() && fit > 0.0) {
return;
}
let page = egui::Rect::from_center_size(rect.center(), size * fit);
let to_screen = |x: f64, y: f64| page.min + egui::vec2(x as f32, y as f32) * fit;
let painter = ui.painter();
painter.rect_filled(page.translate(egui::vec2(2.0, 2.0)), 0.0, egui::Color32::from_black_alpha(60));
painter.rect_filled(page, 0.0, egui::Color32::WHITE);
// Dragging moves the art (and its trim box) on the paper; the placement changes on release.
let tiling = choice::<PrintScaling>(d, "scaling").is_some_and(PrintScaling::tiles);
let drag_id = egui::Id::unique("print-preview-drag");
let mut offset = ui.ctx().data(|m| m.get_temp::<egui::Vec2>(drag_id)).unwrap_or_default();
if !tiling && resp.dragged() {
offset += resp.drag_delta();
ui.ctx().data_mut(|m| m.insert_temp(drag_id, offset));
}
let coeffs: Vec<f64> = sheet["transform"].as_array().map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
let clip = ui.painter().with_clip_rect(page);
// With copies per sheet, `copies` holds each copy's artboard on the page, and `moves` holds
// each copy's move on screen from the first.
let copies: Vec<DRect> = sheet["copies"].as_array().map(|a| a.iter().filter_map(rect_of).collect()).unwrap_or_default();
let moves: Vec<egui::Vec2> = match copies.first() {
Some(first) => copies.iter().map(|r| egui::vec2((r.x0 - first.x0) as f32, (r.y0 - first.y0) as f32) * fit).collect(),
None => vec![egui::Vec2::ZERO],
};
if let ([a, b, c, dd, e, f], Some(area)) = (coeffs.as_slice(), rect_of(&sheet["area"])) {
let px = (f64::from(page.width().max(page.height()) * ui.ctx().pixels_per_point())).min(1024.0);
let layers = choice::<PrintLayers>(d, "printLayers").unwrap_or(PrintLayers::VisiblePrintable);
if let Some(tex) = art_texture(app, ui.ctx(), layers, area, px) {
let at = |x: f64, y: f64| to_screen(a * x + c * y + e, b * x + dd * y + f) + offset;
let mut mesh = egui::Mesh::with_texture(tex.id());
for m in &moves {
let first = mesh.vertices.len() as u32;
for (p, uv) in [
((area.x0, area.y0), (0.0, 0.0)),
((area.x1, area.y0), (1.0, 0.0)),
((area.x1, area.y1), (1.0, 1.0)),
((area.x0, area.y1), (0.0, 1.0)),
] {
mesh.vertices.push(egui::epaint::Vertex { pos: at(p.0, p.1) + *m, uv: egui::pos2(uv.0, uv.1), color: egui::Color32::WHITE });
}
mesh.add_triangle(first, first + 1, first + 2);
mesh.add_triangle(first, first + 2, first + 3);
}
clip.add(mesh);
}
}
if resp.drag_stopped() && offset != egui::Vec2::ZERO {
move_placement(d, sheet, (f64::from(offset.x / fit), f64::from(offset.y / fit)));
}
if !resp.dragged() {
ui.ctx().data_mut(|m| m.remove::<egui::Vec2>(drag_id));
}
// The imageable area inside the device's margin, and the artboard's edge.
let margin = get(d, "margin").as_f64().unwrap_or(0.0) as f32 * fit;
if margin > 0.5 {
let r = page.shrink(margin);
let stroke = egui::Stroke::new(1.0, t.text_dim);
let corners = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];
clip.extend(egui::Shape::dashed_line(&corners, stroke, 3.0, 2.0));
}
// The preview strokes each copy's artboard edge, or the trim box without copies per sheet.
let trims = if copies.is_empty() { rect_of(&sheet["trim"]).into_iter().collect() } else { copies };
for trim in trims {
let r = egui::Rect::from_min_max(to_screen(trim.x0, trim.y0), to_screen(trim.x1, trim.y1)).translate(offset);
clip.rect_stroke(r, 0.0, egui::Stroke::new(1.0, t.accent), egui::StrokeKind::Middle);
}
let resp = if tiling { resp } else { resp.on_hover_cursor(egui::CursorIcon::Grab) };
resp.on_hover_text(if tiling { tl!("The page as it prints") } else { tl!("Drag the art to move it on the paper") });
// ◀ n of N ▶, then what the page is.
ui.horizontal(|ui| {
ui.spacing_mut().item_spacing.x = 2.0;
if widgets::icon_button_enabled(ui, "chevron-left", tl!("Previous page"), false, index > 0, 20.0).clicked() {
d.fields.insert("__sheet".into(), json!(index - 1));
}
let text = crate::i18n::fmt(tl!("{page} of {count}"), &[("page", &(index + 1).to_string()), ("count", &count.to_string())]);
ui.add_sized([PREVIEW.x - 44.0, 20.0], egui::Label::new(egui::RichText::new(text).size(11.5).color(t.text)));
if widgets::icon_button_enabled(ui, "chevron-right", tl!("Next page"), false, index + 1 < count, 20.0).clicked() {
d.fields.insert("__sheet".into(), json!(index + 1));
}
});
let mut what = vec![];
match sheet["artboard"].as_u64() {
Some(a) => what.push(crate::i18n::fmt(tl!("Artboard {number}"), &[("number", &(a + 1).to_string())])),
None => what.push(tl!("All the art").into()),
}
if let Some(tile) = sheet["tile"].as_u64() {
what.push(crate::i18n::fmt(tl!("tile {number}"), &[("number", &tile.to_string())]));
}
if let Some(ink) = sheet["ink"].as_str() {
what.push(ink.to_string());
}
let unit = app.session.general_unit();
let scale = sheet["scale"].as_array().map(|s| s.iter().filter_map(Value::as_f64).collect::<Vec<_>>()).unwrap_or_default();
let scale = match scale.as_slice() {
[w, h] if (w - h).abs() < 1e-6 => format!("{}%", round2(*w)),
[w, h] => format!("{}% × {}%", round2(*w), round2(*h)),
_ => String::new(),
};
let paper = format!("{} × {}", unit.number(f64::from(size.x)), unit.format(f64::from(size.y)));
for line in [what.join(" · "), format!("{paper} · {scale}")] {
ui.label(egui::RichText::new(line).size(11.0).color(t.text_dim));
}
}
/// Move the placement so the art of `sheet` moves `(dx, dy)` points on the page: the move turned
/// back onto the paper (the page may be turned or mirrored), at the art's scale.
pub(super) fn move_placement(d: &mut Dialog, sheet: &Value, (dx, dy): (f64, f64)) {
let n = |k: &str, i: usize| sheet[k].get(i).and_then(Value::as_f64);
let (Some(a), Some(b), Some(c), Some(e)) = (n("transform", 0), n("transform", 1), n("transform", 2), n("transform", 3)) else { return };
let (Some(sx), Some(sy)) = (n("scale", 0), n("scale", 1)) else { return };
let (sx, sy) = (sx / 100.0, sy / 100.0);
if !(sx > 0.0 && sy > 0.0) {
return;
}
// The transform's linear part is the page's turn times the scale, and the turn's inverse is
// its transpose: the columns over the scale.
let (px, py) = ((a * dx + b * dy) / sx, (c * dx + e * dy) / sy);
if get(d, PLACED).as_bool() == Some(true) {
// Pages the Print Tiling tool placed: their corner moves the other way over the art.
let x = get(d, "tileOrigin.x").as_f64().unwrap_or(0.0) - px / sx;
let y = get(d, "tileOrigin.y").as_f64().unwrap_or(0.0) - py / sy;
set(d, "tileOrigin.x", json!(round2(x)));
set(d, "tileOrigin.y", json!(round2(y)));
return;
}
let x = get(d, "placement.x").as_f64().unwrap_or(0.0) + px;
let y = get(d, "placement.y").as_f64().unwrap_or(0.0) + py;
set(d, "placement.x", json!(round2(x)));
set(d, "placement.y", json!(round2(y)));
}
fn round2(v: f64) -> f64 {
(v * 100.0).round() / 100.0
}
/// The art of `area` as it prints (only the layers that print), `px` pixels on its longest side;
/// cached until the document, the layers or the size change.
fn art_texture(app: &mut VectorcraftApp, ctx: &egui::Context, layers: PrintLayers, area: DRect, px: f64) -> Option<egui::TextureHandle> {
let st = app.session.active()?;
let bits = [area.x0, area.y0, area.x1, area.y1].map(f64::to_bits);
let stamp = egui::Id::unique((st.uid, st.revision, layers, bits, px.round() as u32));
let key = egui::Id::unique("print-preview-art");
if let Some((s, tex)) = ctx.data(|m| m.get_temp::<(egui::Id, egui::TextureHandle)>(key))
&& s == stamp
{
return Some(tex);
}
// The artboards' background colors print behind the art.
let mut doc = st.doc.with_artboard_fills(0..st.doc.artboards.len()).unwrap_or_else(|| (*st.doc).clone());
vectorcraft_pdf::keep_layers(&mut doc.layers, layers);
let tex = widgets::region_texture(ctx, &mut app.canvas.renderer, "print-preview-art", &doc, area, px);
ctx.data_mut(|m| m.insert_temp(key, (stamp, tex.clone())));
Some(tex)
}
// ---------- sections ----------
/// A whole number at `path` within `range`.
fn whole(ui: &mut egui::Ui, d: &mut Dialog, path: &str, range: std::ops::RangeInclusive<f64>, enabled: bool) {
let v = get(d, path).as_f64().unwrap_or(*range.start());
ui.add_enabled_ui(enabled, |ui| {
if let Some(x) = widgets::range_field(ui, path, v, range, "", 0, 56.0) {
set(d, path, json!(x as u64));
}
});
}
/// A Scale percentage at `path`, 1–1000 %: the value typed, once one was.
fn percent(ui: &mut egui::Ui, d: &mut Dialog, path: &str, enabled: bool) -> Option<f64> {
let v = get(d, path).as_f64().unwrap_or(100.0);
let typed = ui.add_enabled_ui(enabled, |ui| widgets::range_field(ui, path, v, 1.0..=1000.0, "%", 3, 64.0)).inner;
if let Some(x) = typed {
set(d, path, json!(x));
}
typed
}
/// The link after Scale W and H: on, either field sets both, and turning it on sets H to W. With
/// the keyboard on it, Space or Enter toggles it unless it is dimmed.
fn scale_link(ui: &mut egui::Ui, d: &mut Dialog, linked: bool) {
const NAME: &str = "Constrain Width and Height Proportions";
let size = crate::panels::transform::CONSTRAIN_LINK_SIZE;
let (_, at) = ui.allocate_exact_size(egui::Vec2::splat(size), egui::Sense::click());
let enabled = ui.is_enabled();
let keyed = enabled
&& at.has_focus()
&& ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Space) | i.consume_key(egui::Modifiers::NONE, egui::Key::Enter));
let resp = widgets::paint_icon_button(ui, at, if linked { "link" } else { "link-2-off" }, NAME, linked);
// Off is a state too: screen readers hear the link as off, not as a plain button.
resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, enabled, linked, tl!(NAME)));
if resp.clicked() || keyed {
set(d, SCALE_LINKED, json!(!linked));
link_scale(d);
}
}
/// While the Scale link is on, keep H equal to W: the field that changed since the last call (a
/// field typed in, or `ui.dialog.set`) gives its value to the other, and when neither changed H
/// takes W, as turning the link on does. As `print.setup` reads a `scale`: one set with W and H
/// apart and without a `linked` key turns the link off, one that leaves out W, H or `linked` (or
/// gives `null`) keeps it as it was, and one that changes both W and H apart while linked is left
/// as it is (and stays changed on later calls), for confirming to refuse.
fn link_scale(d: &mut Dialog) {
let seen = d.fields.get(SCALE_SEEN).cloned().unwrap_or_default();
if let Some(Value::Object(s)) = d.fields.get_mut("scale") {
let num = |s: &serde_json::Map<String, Value>, k: &str| s.get(k).and_then(Value::as_f64);
let stated = |s: &serde_json::Map<String, Value>, k: &str| s.get(k).is_some_and(|v| !v.is_null());
if s.get("linked").is_none() && num(s, "width").zip(num(s, "height")).is_some_and(|(w, h)| w != h) {
s.insert("linked".into(), json!(false));
}
for (i, k) in ["width", "height", "linked"].into_iter().enumerate() {
if !stated(s, k) && !seen[i].is_null() {
s.insert(k.into(), seen[i].clone());
}
}
}
let (w, h) = (get(d, "scale.width").clone(), get(d, "scale.height").clone());
if get(d, SCALE_LINKED).as_bool() == Some(true) && w.as_f64() != h.as_f64() {
let (w_kept, h_kept) = (seen[0].as_f64() == w.as_f64(), seen[1].as_f64() == h.as_f64());
if (w_kept && !h_kept) || w.as_f64().is_none() {
set(d, "scale.width", h);
} else if h_kept || seen.is_null() {
set(d, "scale.height", w);
} else {
return;
}
}
see_scale(&mut d.fields);
}
/// Remember Scale W, H and the link as the fields hold them, for [`link_scale`].
fn see_scale(fields: &mut serde_json::Map<String, Value>) {
let s = fields.get("scale").cloned().unwrap_or_default();
fields.insert(SCALE_SEEN.into(), json!([s["width"], s["height"], s["linked"]]));
}
fn general(app: &VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
let unit = app.session.general_unit();
row(ui, tl!("Copies:"), |ui| {
whole(ui, d, "copies", 1.0..=f64::from(vectorcraft_pdf::MAX_COPIES), true);
ui.add_space(12.0);
let copies = get(d, "copies").as_u64().unwrap_or(1);
flag(ui, d, "collate", tl!("Collate"), copies > 1);
flag(ui, d, "reverse", tl!("Reverse Order"), true);
});
heading(ui, tl!("Artboards"));
let artboards = choice::<PrintArtboards>(d, "artboards").unwrap_or(PrintArtboards::All);
ui.horizontal(|ui| {
for (a, label) in [(PrintArtboards::All, tl!("All")), (PrintArtboards::Range, tl!("Range:"))] {
if widgets::radio(ui, label, artboards == a, true) {
set(d, "artboards", json!(a.id()));
}
}
let mut range = get(d, "range").as_str().unwrap_or_default().to_string();
let edit = egui::TextEdit::singleline(&mut range).align(egui::Align2::LEFT_CENTER).desired_width(140.0).hint_text("1-3, 5");
if ui.add_enabled(artboards == PrintArtboards::Range, edit).changed() {
set(d, "range", json!(range));
}
});
if widgets::radio(ui, tl!("Ignore Artboards (all the art as one page)"), artboards == PrintArtboards::Ignore, true) {
set(d, "artboards", json!(PrintArtboards::Ignore.id()));
}
flag(ui, d, "skipBlank", tl!("Skip Blank Artboards"), artboards != PrintArtboards::Ignore);
heading(ui, tl!("Media"));
row(ui, tl!("Size:"), |ui| {
pick::<Media>(ui, d, "media", 160.0, |_| true);
});
// A paper size shows its size; Custom takes one.
let media = choice::<Media>(d, "media").unwrap_or_default();
row(ui, tl!("Width:"), |ui| match media.size() {
Some((w, h)) => {
ui.add_enabled_ui(false, |ui| widgets::num_field(ui, "print-media-w", Some(w), unit, 80.0));
ui.label(tl!("Height:"));
ui.add_enabled_ui(false, |ui| widgets::num_field(ui, "print-media-h", Some(h), unit, 80.0));
}
None => {
length(ui, d, "width", unit, true);
ui.label(tl!("Height:"));
length(ui, d, "height", unit, true);
}
});
heading(ui, tl!("Orientation"));
flag(ui, d, "autoRotate", tl!("Auto-Rotate (turn the paper to each artboard)"), true);
let auto = get(d, "autoRotate").as_bool() == Some(true);
row(ui, tl!("Orientation:"), |ui| {
ui.add_enabled_ui(!auto, |ui| pick::<Orientation>(ui, d, "orientation", 160.0, |_| true));
});
flag(ui, d, "transverse", tl!("Transverse (the page a quarter turn on the paper)"), true);
heading(ui, tl!("Options"));
row(ui, tl!("Print Layers:"), |ui| {
pick::<PrintLayers>(ui, d, "printLayers", 220.0, |_| true);
});
let scaling = choice::<PrintScaling>(d, "scaling").unwrap_or(PrintScaling::None);
let tiles = scaling.tiles();
let placed = get(d, PLACED).as_bool() == Some(true);
row(ui, tl!("Placement:"), |ui| {
ui.add_enabled_ui(!tiles && !placed, |ui| {
let origin = choice::<Origin>(d, "placement.origin").unwrap_or_default();
let current = Origin::ALL.iter().position(|o| *o == origin).unwrap_or(4);
if let Some(o) = widgets::reference_point_named(ui, current, tl!("Placement:")).and_then(|i| Origin::ALL.get(i)) {
set(d, "placement.origin", json!(o.id()));
}
ui.label("X:");
length(ui, d, "placement.x", unit, true);
ui.label("Y:");
length(ui, d, "placement.y", unit, true);
});
});
if placed {
row(ui, "", |ui| {
note(ui, tl!("The Print Tiling tool placed the pages."));
if widgets::flat_button(ui, tl!("Reset"), 56.0).on_hover_text(tl!("Place the pages with the placement again")).clicked() {
set(d, PLACED, json!(false));
}
});
}
row(ui, tl!("Scaling:"), |ui| {
pick::<PrintScaling>(ui, d, "scaling", 180.0, |_| true);
});
row(ui, tl!("Scale:"), |ui| {
let on = scaling == PrintScaling::Custom || tiles;
let linked = get(d, SCALE_LINKED).as_bool() == Some(true);
ui.label(tl!("W:"));
let w = percent(ui, d, "scale.width", on);
if let Some(w) = w.filter(|_| linked) {
set(d, "scale.height", json!(w));
}
ui.label(tl!("H:"));
let h = percent(ui, d, "scale.height", on);
if let Some(h) = h.filter(|_| linked) {
set(d, "scale.width", json!(h));
}
// A typed W or H is what the next `ui.dialog.set` changes from.
if w.is_some() || h.is_some() {
see_scale(&mut d.fields);
}
ui.add_enabled_ui(on, |ui| scale_link(ui, d, linked));
});
row(ui, tl!("Overlap:"), |ui| length(ui, d, "overlap", unit, tiles));
row(ui, tl!("Tile Range:"), |ui| text(ui, d, "tileRange", tiles));
if tiles {
note(ui, tl!("Tiles are numbered across, then down; leave the range empty for every tile."));
}
flag(ui, d, "copiesPerSheet", tl!("Copies per Sheet (as many as fit, in a grid)"), !tiles);
let per_sheet = get(d, "copiesPerSheet").as_bool() == Some(true);
row(ui, tl!("Gutter:"), |ui| length(ui, d, "gutter", unit, !tiles && per_sheet));
}
fn output(ui: &mut egui::Ui, d: &mut Dialog, pv: &Result<Value, String>) {
row(ui, tl!("Mode:"), |ui| {
pick::<OutputMode>(ui, d, "output.mode", 160.0, |_| true);
});
row(ui, tl!("Emulsion:"), |ui| {
pick::<Emulsion>(ui, d, "output.emulsion", 160.0, |_| true);
});
row(ui, tl!("Image:"), |ui| {
pick::<PrintImage>(ui, d, "output.image", 160.0, |_| true);
});
let separations = choice::<OutputMode>(d, "output.mode") == Some(OutputMode::Separations);
flag(ui, d, "output.spotsToProcess", tl!("Convert All Spot Colors to Process"), separations);
flag(ui, d, "output.overprintBlack", tl!("Overprint Black"), separations);
heading(ui, tl!("Document Ink Options"));
// Every ink of the document, the spot inks printing as process (no plate) included.
let inks = pv.as_ref().ok().and_then(|v| v["documentInks"].as_array()).map(Vec::as_slice).unwrap_or_default();
if !separations || inks.is_empty() {
note(ui, tl!("Separations list the document's inks here: one page per ink that prints."));
return;
}
let all_spots = get(d, "output.spotsToProcess").as_bool() == Some(true);
let t = Tokens::get(ui.ctx());
egui::Grid::new("print-inks").num_columns(4).spacing([12.0, 4.0]).show(ui, |ui| {
for h in [tl!("Print"), tl!("Ink"), tl!("Frequency"), tl!("Angle")] {
ui.label(egui::RichText::new(h).size(11.5).color(t.text_dim));
}
ui.end_row();
for ink in inks {
let name = ink["name"].as_str().unwrap_or_default();
// A spot ink printing as process has no plate: its plate options wait, dimmed, for it
// to print as a spot ink again.
let process = ink["convertToProcess"] == true;
let on = ink["print"].as_bool().unwrap_or(true);
if widgets::check_box(ui, name, on, !process) {
set_ink(d, name, "print", json!(!on));
}
ui.horizontal(|ui| {
if ink["spot"] == true {
if ink_kind_button(ui, name, process, !all_spots) {
set_ink(d, name, "convertToProcess", json!(!process));
}
} else {
ui.add_space(INK_KIND);
}
let spot = if ink["spot"] == true { format!(" ({})", tl!("spot")) } else { String::new() };
ui.label(egui::RichText::new(format!("{name}{spot}")).color(t.text));
});
for (k, suffix) in [("frequency", " lpi"), ("angle", "°")] {
let v = ink[k].as_f64().unwrap_or(0.0);
let heading = if k == "frequency" { tl!("Frequency") } else { tl!("Angle") };
let field_name = format!("{heading} {name}");
let typed =
ui.add_enabled_ui(!process, |ui| widgets::plain_field_named(ui, ("print-ink", name, k), Some(&field_name), v, suffix, 2, 72.0));
if let Some(x) = typed.inner {
set_ink(d, name, k, json!(x));
}
}
ui.end_row();
}
});
note(ui, tl!("Frequencies and angles are the output device's to apply."));
}
/// The size of the spot or process icon before a spot ink's name.
const INK_KIND: f32 = 18.0;
/// The icon before spot ink `name`'s name: a spot icon while it prints as a spot ink, the four
/// process inks while it prints as process (`process`). A click switches it; dimmed (`enabled`
/// off) while Convert All Spot Colors to Process converts every spot ink. Whether it was clicked.
fn ink_kind_button(ui: &mut egui::Ui, name: &str, process: bool, enabled: bool) -> bool {
let label = if process {
crate::i18n::fmt(tl!("Keep {name} as spot"), &[("name", name)])
} else {
crate::i18n::fmt(tl!("Convert {name} to process"), &[("name", name)])
};
let sense = if enabled { egui::Sense::click() } else { egui::Sense::hover() };
let (rect, resp) = ui.allocate_exact_size(egui::Vec2::splat(INK_KIND), sense);
let t = Tokens::get(ui.ctx());
if enabled && resp.hovered() {
ui.painter().rect_filled(rect, 3.0, t.hover);
}
let icon = rect.shrink(4.0);
if process {
let q = icon.size() / 2.0;
for (i, c) in crate::panels::swatches::CMYK_INKS.into_iter().enumerate() {
let c = if enabled { c } else { c.gamma_multiply(0.4) };
let at = icon.min + egui::vec2((i % 2) as f32 * q.x, (i / 2) as f32 * q.y);
ui.painter().rect_filled(egui::Rect::from_min_size(at, q), 0.0, c);
}
} else {
let color = if enabled { t.icon } else { t.text_disabled };
ui.painter().circle_stroke(icon.center(), icon.width() / 2.0, egui::Stroke::new(1.0, color));
ui.painter().circle_filled(icon.center(), icon.width() / 5.0, color);
}
resp.widget_info(|| widgets::icon_button_info(enabled, false, &label));
let resp = resp.on_hover_text(label);
enabled && resp.clicked()
}
/// Set option `key` of ink `name` in `output.inks` (the ink gets its own entry the first time).
fn set_ink(d: &mut Dialog, name: &str, key: &str, value: Value) {
let mut inks = get(d, "output.inks").as_array().cloned().unwrap_or_default();
match inks.iter_mut().find(|i| i["name"] == name) {
Some(ink) => ink[key] = value,
None => {
let mut ink = json!({ "name": name, "print": true });
ink[key] = value;
inks.push(ink);
}
}
set(d, "output.inks", Value::Array(inks));
}
fn graphics(ui: &mut egui::Ui, d: &mut Dialog) {
heading(ui, tl!("Paths"));
flag(ui, d, "graphics.autoFlatness", tl!("Automatic flatness"), true);
let auto = get(d, "graphics.autoFlatness").as_bool() == Some(true);
row(ui, tl!("Flatness:"), |ui| {
number(ui, d, "graphics.flatness", "", !auto);
ui.label(egui::RichText::new(tl!("0.2 (quality) to 100 (speed)")).size(11.5).color(Tokens::get(ui.ctx()).text_dim));
});
heading(ui, tl!("Fonts"));
row(ui, tl!("Download:"), |ui| {
pick::<FontDownload>(ui, d, "graphics.fonts", 160.0, |_| true);
});
}
fn color(ui: &mut egui::Ui, d: &mut Dialog) {
let profiles = vectorcraft_color::cms::profiles();
let names: Vec<&str> = std::iter::once(SAME_AS_SOURCE).chain(profiles.iter().map(|p| p.name.as_str())).collect();
row(ui, tl!("Printer profile:"), |ui| super::save_pdf::profile_pick(ui, d, "color.profile", &names, 1, true));
note(ui, tl!("Composite colours are converted to it; separations separate with it when it is a CMYK profile."));
row(ui, tl!("Rendering intent:"), |ui| {
let current = serde_json::from_value::<Intent>(get(d, "color.intent").clone()).unwrap_or_default();
let labels: Vec<&str> = Intent::ALL.iter().map(Intent::label).collect();
if let Some(i) = widgets::dropdown(ui, "color.intent", current.label(), &labels, 200.0).and_then(|i| Intent::ALL.get(i)) {
set(d, "color.intent", serde_json::to_value(i).unwrap_or_default());
}
});
note(ui, tl!("How colours outside the press's gamut are separated."));
flag(ui, d, "color.preserveNumbers", tl!("Preserve CMYK Numbers"), true);
note(ui, tl!("CMYK colours print with their own values; off, they go through the colour settings too."));
}
fn advanced(app: &VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
heading(ui, tl!("Printer"));
row(ui, tl!("Unprintable margin:"), |ui| length(ui, d, "margin", app.session.general_unit(), true));
note(ui, tl!("The edge of the paper the printer can't reach: the art goes inside it, and the preview shows it dashed."));
let composite = choice::<OutputMode>(d, "output.mode") != Some(OutputMode::Separations);
flag(ui, d, "advanced.printAsBitmap", tl!("Print as Bitmap"), composite);
note(ui, tl!("Each page prints as one image, at the document's raster effects resolution."));
heading(ui, tl!("Overprint and Transparency Flattener Options"));
row(ui, tl!("Overprints:"), |ui| {
ui.add_enabled_ui(composite, |ui| pick::<PrintOverprints>(ui, d, "advanced.overprints", 160.0, |_| true));
});
let presets = app.session.flattener_presets();
let names: Vec<&str> = std::iter::once(KEEP_TRANSPARENCY).chain(presets.iter().map(|p| p.name.as_str())).collect();
// None and the built-in presets are ours; the saved presets are names.
let builtins = names.len().saturating_sub(app.session.prefs.flattener_presets.len());
row(ui, tl!("Preset:"), |ui| super::save_pdf::profile_pick(ui, d, "advanced.flattenerPreset", &names, builtins, true));
note(
ui,
tl!(
"Simulate prints overprints as Overprint Preview shows them; separations always keep them. A preset flattens transparency before printing (PostScript files always flatten it)."
),
);
}
/// The Printer Profile entry for no conversion.
const SAME_AS_SOURCE: &str = "Same As Source";
/// The flattener Preset entry for transparency printed as it is.
const KEEP_TRANSPARENCY: &str = "None (keep transparency)";
/// The section an option is set in, and whether its first key is the section's own object
/// (`output.mode` → Output › Mode).
pub(super) fn section_of(option: &str) -> (usize, bool) {
match option.split('.').next().unwrap_or_default() {
"marks" | "bleed" => (1, false),
"output" => (2, true),
"graphics" => (3, true),
"color" => (4, true),
"margin" => (5, false),
"advanced" => (5, true),
_ => (0, false),
}
}
/// `output.mode` → "Output › Mode", `placement.x` → "General › Placement › X".
pub(super) fn option_label(option: &str) -> String {
let (section, own) = section_of(option);
let keys = option.split('.').skip(usize::from(own)).map(|k| form::humanize(k).trim_end_matches(':').to_string());
std::iter::once(SECTIONS.get(section).copied().unwrap_or_default().to_string()).chain(keys).collect::<Vec<_>>().join(" › ")
}
/// Changed options (`{option, value}`) with their choices as the dialog names them
/// (`tileFull` → "Tile Full Pages").
pub(super) fn labelled(changed: &mut [Value]) {
fn label<T: Choice>(id: &str) -> Option<&'static str> {
T::IDS.iter().position(|i| *i == id).and_then(|i| T::LABELS.get(i)).copied()
}
for c in changed {
let Some(id) = c["value"].as_str() else { continue };
let named = match c["option"].as_str().unwrap_or_default() {
"artboards" => label::<PrintArtboards>(id),
"media" => label::<Media>(id),
"orientation" => label::<Orientation>(id),
"printLayers" => label::<PrintLayers>(id),
"placement.origin" => label::<Origin>(id),
"scaling" => label::<PrintScaling>(id),
"marks.kind" => label::<vectorcraft_pdf::MarkKind>(id),
"output.mode" => label::<OutputMode>(id),
"output.emulsion" => label::<Emulsion>(id),
"output.image" => label::<PrintImage>(id),
"graphics.fonts" => label::<FontDownload>(id),
"advanced.overprints" => label::<PrintOverprints>(id),
"color.intent" => serde_json::from_value::<Intent>(c["value"].clone()).ok().map(|i| i.label()),
_ => None,
};
if let Some(l) = named {
c["value"] = json!(l);
}
}
}
fn summary(ui: &mut egui::Ui, d: &mut Dialog, pv: &Result<Value, String>, has_doc: bool) {
let t = Tokens::get(ui.ctx());
match pv {
Ok(v) => {
heading(ui, tl!("Pages"));
let per_copy = v["sheets"].as_array().map_or(0, Vec::len);
ui.label(
egui::RichText::new(crate::i18n::fmt(
tl!("{pages} in all, {count} per copy"),
&[("pages", &v["pages"].to_string()), ("count", &per_copy.to_string())],
))
.color(t.text),
);
}
// A preset edited without a document has no pages to count.
Err(_) if !has_doc => {}
Err(e) => {
heading(ui, tl!("Error"));
ui.label(egui::RichText::new(super::save_pdf::warning_line(crate::i18n::current(), e)).color(t.text));
}
}
heading(ui, tl!("Options"));
let mut changed = vec![];
vectorcraft_engine::cmd::fileio::pdf::changed("", &settings(d), &DEFAULTS, &mut changed);
changed.sort_by_key(|c| section_of(c["option"].as_str().unwrap_or_default()).0);
labelled(&mut changed);
if changed.is_empty() {
note(ui, tl!("Every option is at its default."));
}
super::save_pdf::option_rows(ui, &changed, option_label);
if let Ok(v) = pv {
heading(ui, tl!("Warnings"));
super::save_pdf::warning_rows(ui, v["warnings"].as_array().map(Vec::as_slice).unwrap_or_default());
}
}
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.