6ef13b2cc8a6
printing.rs
//! Localized print-page wording around the shared, backend-independent controls.
use craft_ui::printing::Labels;
pub use craft_ui::printing::{Discover, Duplex, Feedback, Printer, Settings, State};
/// Native submission adds WordCraft's PDF-page collation setting and spooler options to the shared spooler settings.
pub type Submit = Box<dyn Fn(Vec<u8>, Settings, bool, Vec<(String, String)>) -> std::sync::mpsc::Receiver<Result<String, String>>>;
/// Metadata for the app-owned commands. Inspecting it never discovers printers or submits.
pub fn commands(app: &crate::WordApp) -> Vec<serde_json::Value> {
use serde_json::json;
let enabled = if app.services.print_native.is_some() { app.printing.ready() } else { app.services.print.is_some() };
let submit_params = "pagesPerSheet?: 1|2|4|6|9|16|booklet|bookletReverse; range?: all|current|selection|custom; pages?: string (1-3,5); parity?: all|odd|even; copies?: integer 1..999; collate?: bool; orientation?: auto|portrait|landscape; paper?: none|Letter|Legal|A4|… (Layout › Size names: Scale to paper size, every page scaled onto that paper and centred; the document is unchanged). Native uses the selected printer, duplex and grayscale from ui.printSettings; omitted copies/collation use current settings. Browser printing opens its dialog. Submits only when explicitly executed.";
vec![
json!({"id":"ui.printSettings", "label":"Print settings", "location":"File › Print", "shortcut":null,
"params":"printer?: discovered name; copies?: integer 1..999; duplex?: printerDefault|off|longEdge|shortEdge|null; grayscale?: bool; refresh?: bool. Empty params inspect printer/copies/duplex/grayscale, printers, busy/discovering/ready and status/detail. Updates are atomic; refresh discovers only on native hosts. Never submits or opens a dialog.",
"enabled":true}),
json!({"id":"ui.printSubmit", "label":"Submit print job", "location":"File › Print", "shortcut":null, "params":submit_params, "enabled":enabled}),
json!({"id":"ui.print", "label":"Print (alias of ui.printSubmit)", "location":"File › Print", "shortcut":null, "params":submit_params, "enabled":enabled}),
json!({"id":"ui.printCancel", "label":"Cancel printing", "location":"File › Print", "shortcut":null,
"params":"none. Stops the job being submitted if it hasn't started reaching the spooler (it may wait on a sleeping printer's driver); returns cancelled: true when nothing will be sent, false when the job was already being sent (cancel it from the system's print queue).",
"enabled": app.services.cancel_print.is_some() && app.printing.busy()}),
]
}
/// Builds translated print labels, draws the shared print-settings panel, and shows the current
/// feedback message (unless `hide_message`: this window has already said it).
pub fn show(state: &mut State, ui: &mut egui::Ui, discover: &Discover, hide_message: bool, translate: impl Fn(&str) -> String) {
let labels = Labels {
printer: &translate("Printer"),
select_printer: &translate("Select a printer"),
refresh: &translate("Refresh printers"),
copies: &translate("Copies"),
duplex: &translate("Two-sided printing"),
printer_default: &translate("Printer default"),
one_sided: &translate("One-sided"),
long_edge: &translate("Two-sided: long edge"),
short_edge: &translate("Two-sided: short edge"),
grayscale: &translate("Grayscale"),
};
state.show(ui, egui::Id::unique("wordcraft_print_settings"), discover, &labels);
if let Some(message) = state.message.as_ref().filter(|_| !hide_message) {
ui.label(feedback(message, translate));
}
}
/// Read print settings/status, or validate an explicit update before changing anything.
/// `refresh: true` starts discovery only; this command never submits a job or opens a dialog.
pub fn settings(state: &mut State, params: &serde_json::Value, discover: Option<&Discover>) -> Result<serde_json::Value, String> {
use serde_json::{Value, json};
let object = params.as_object().ok_or("print settings must be an object")?;
if object.keys().any(|key| !["printer", "copies", "duplex", "grayscale", "refresh"].contains(&key.as_str())) {
return Err("unknown print setting; use printer, copies, duplex, grayscale or refresh".into());
}
if state.busy() && !object.is_empty() {
return Err("wait for the active print submission before changing settings".into());
}
let mut next = state.settings.clone();
if let Some(value) = object.get("printer") {
let printer = value.as_str().ok_or("printer must be a name from the discovered list")?;
if !state.printers.iter().any(|available| available.name == printer) {
return Err("printer must be a name from the discovered list".into());
}
next.printer = printer.to_owned();
}
if let Some(value) = object.get("copies") {
let copies = value.as_u64().filter(|copies| (1..=999).contains(copies)).ok_or("copies must be an integer from 1 to 999")?;
next.copies = copies as u32;
}
if let Some(value) = object.get("duplex") {
next.duplex = match value.as_str() {
Some("printerDefault") => None,
Some("off") => Some(Duplex::Off),
Some("longEdge") => Some(Duplex::LongEdge),
Some("shortEdge") => Some(Duplex::ShortEdge),
None if value.is_null() => None,
_ => return Err("duplex must be printerDefault, off, longEdge or shortEdge".into()),
};
}
if let Some(value) = object.get("grayscale") {
next.grayscale = value.as_bool().ok_or("grayscale must be a boolean")?;
}
let refresh = object.get("refresh").map(|value| value.as_bool().ok_or("refresh must be a boolean")).transpose()?.unwrap_or(false);
if refresh {
let discover = discover.ok_or("native printer discovery is unavailable here")?;
if !state.refresh(discover) {
return Err("printer discovery or submission is already active".into());
}
}
state.settings = next;
let (status, detail) = match state.message.as_ref() {
None => ("idle", ""),
Some(Feedback::FindingPrinters) => ("findingPrinters", ""),
Some(Feedback::NoPrinters) => ("noPrinters", ""),
Some(Feedback::DiscoveryFailed) => ("discoveryFailed", ""),
Some(Feedback::Submitting) => ("submitting", ""),
Some(Feedback::Submitted(receipt)) => ("submitted", receipt.as_str()),
Some(Feedback::Failed(error)) => ("failed", error.as_str()),
Some(Feedback::WorkerStopped) => ("workerStopped", ""),
};
Ok(json!({
"printer": state.settings.printer, "copies": state.settings.copies,
"duplex": match state.settings.duplex { None => "printerDefault", Some(Duplex::Off) => "off", Some(Duplex::LongEdge) => "longEdge", Some(Duplex::ShortEdge) => "shortEdge" },
"grayscale": state.settings.grayscale,
"printers": state.printers.iter().map(|printer| json!({"name": printer.name, "default": printer.default})).collect::<Vec<Value>>(),
"busy": state.busy(), "discovering": state.discovering(), "ready": state.ready(), "status": status, "detail": detail,
}))
}
const SPOOLED: &str = "Print job submitted: spooled {count} sheet(s)";
/// The sheet count of the Windows backend's English receipt `spooled N sheet(s)`.
fn spooled_sheets(receipt: &str) -> Option<usize> {
receipt.trim().strip_prefix("spooled ")?.strip_suffix(" sheet(s)")?.parse().ok()
}
pub fn feedback(message: &Feedback, translate: impl Fn(&str) -> String) -> String {
match message {
Feedback::FindingPrinters => translate("Finding printers…"),
Feedback::NoPrinters => translate("No printers found. Configure a system printer or export a PDF."),
Feedback::DiscoveryFailed => translate("Printer discovery failed."),
Feedback::Submitting => translate("Submitting print job…"),
Feedback::Submitted(receipt) if receipt.trim().is_empty() => translate("Print job submitted."),
Feedback::Submitted(receipt) if spooled_sheets(receipt).is_some_and(|_| translate(SPOOLED) != SPOOLED) => {
let count = spooled_sheets(receipt).unwrap_or_default();
translate(SPOOLED).replace("{count}", &count.to_string())
}
Feedback::Submitted(receipt) => translate("Print job submitted: {receipt}").replace("{receipt}", receipt),
Feedback::Failed(error) => translate("Print failed: {error}").replace("{error}", error),
Feedback::WorkerStopped => translate("Print failed: the printing worker stopped."),
}
}
/// `ui.printCancel`: stop the job being submitted before it reaches the spooler. A job can wait
/// a long time on a sleeping network printer's driver (#5710) with the print settings locked;
/// once cancelled it is never sent, so the panel is free again at once: printer list and
/// settings kept, the printers listed again.
pub fn cancel(app: &mut crate::WordApp) -> Result<serde_json::Value, String> {
if !app.printing.busy() {
return Err("no print job is being submitted".into());
}
let cancel = app.services.cancel_print.as_ref().ok_or("cancelling a print job isn't available here")?;
if !cancel() {
app.status(tl!("Cancellation could not be confirmed here. The printer driver may still be processing the job. If it appears in the system's print queue, cancel it there."));
return Ok(serde_json::json!({"cancelled": false}));
}
// The shared state keeps the job's receiver private: a fresh one drops it (the worker's
// answer, if it ever comes, goes nowhere) and keeps the user's settings.
let old = std::mem::take(&mut app.printing);
app.printing.settings = old.settings;
app.printing.printers = old.printers;
app.status(tl!("Printing cancelled. Nothing was sent to the printer."));
Ok(serde_json::json!({"cancelled": true}))
}
/// The IPP/PWG 5101.1 media name of a Layout › Size paper (the spooler's `media` option).
pub fn pwg_media(paper: &str) -> Option<&'static str> {
Some(match paper {
"Letter" => "na_letter_8.5x11in",
"Legal" => "na_legal_8.5x14in",
"Executive" => "na_executive_7.25x10.5in",
"A3" => "iso_a3_297x420mm",
"A4" => "iso_a4_210x297mm",
"A5" => "iso_a5_148x210mm",
"B4 (JIS)" => "jis_b4_257x364mm",
"B5 (JIS)" => "jis_b5_182x257mm",
"Tabloid" => "na_ledger_11x17in",
"Statement" => "na_invoice_5.5x8.5in",
"Envelope #10" => "na_number-10_4.125x9.5in",
"Envelope DL" => "iso_dl_110x220mm",
_ => return None,
})
}
/// Build the upstream page-range/markup PDF and hand it to the chosen host print flow.
pub fn submit(app: &mut crate::WordApp, params: &serde_json::Value) -> Result<serde_json::Value, String> {
use serde_json::json;
if app.services.print.is_none() && app.services.print_native.is_none() {
return Err("printing to the system print dialog isn't available here; export a PDF instead".into());
}
let native = app.services.print_native.is_some();
if native && !app.printing.ready() {
return Err("Select an available printer in File > Print before submitting.".into());
}
let mut pdf_params = params.clone();
let mut settings = app.printing.settings.clone();
let collate = params.get("collate").map(|value| value.as_bool().ok_or("collate must be a boolean")).transpose()?.unwrap_or(app.ui.print.collate);
if native {
let object = pdf_params.as_object_mut().ok_or("print settings must be an object")?;
if let Some(copies) = object.get("copies") {
settings.copies = copies.as_u64().filter(|copies| (1..=999).contains(copies)).ok_or("copies must be an integer from 1 to 999")? as u32;
}
// Copies/collation belong to the spooler. Baking them into the PDF would multiply
// the copies twice, and duplex could put the end of one copy behind the next.
object.insert("copies".into(), json!(1));
}
if app.ui.update_fields_before_print
&& let Err(error) = app.session.run("references.updateFields", &json!({"all": true}))
{
log::warn!("updating fields before printing: {error}");
}
let colour = if app.ui.print_backgrounds { None } else { app.session.doc.settings.page_color.take() };
let picture = if app.ui.print_backgrounds { None } else { app.session.doc.settings.page_picture.take() };
let pdf = app.session.print_job_pdf(&pdf_params).map_err(|error| error.to_string());
if colour.is_some() {
app.session.doc.settings.page_color = colour;
}
if picture.is_some() {
app.session.doc.settings.page_picture = picture;
}
let result = pdf.and_then(|(bytes, plan)| {
if native && plan.chosen.checked_mul(settings.copies as usize).is_none_or(|pages| pages > wordcraft_engine::print::MAX_PRINT_PAGES) {
return Err("the selected pages and copies exceed the print-job page limit".into());
}
let len = bytes.len();
if let Some(submit) = &app.services.print_native {
let mut print_options = Vec::new();
let orientation = params.get("orientation").and_then(|v| v.as_str()).unwrap_or(&app.ui.print.orientation);
let mode = wordcraft_engine::print::imposition(params).map_err(|e| e.to_string())?;
let is_landscape = if mode != wordcraft_engine::print::Imposition::Single {
let markup = wordcraft_engine::cmd::file::export_options(&app.session, &pdf_params).markup;
let lay = app.session.export_layout_with(markup);
wordcraft_engine::print::sheets(params, &lay, app.session.current_pages(&lay))
.map_err(|e| e.to_string())?
.first()
.is_some_and(|s| s.width > s.height)
} else if orientation == "landscape" {
true
} else if orientation == "portrait" {
false
} else {
let lay = app.session.export_layout();
lay.pages.first().is_some_and(|p| p.w > p.h)
};
// Scale to paper size: ask the printer for that paper too, so it takes it from the right tray.
if let Some(media) = wordcraft_engine::print::paper(params).ok().flatten().and_then(|(name, _, _)| pwg_media(name)) {
print_options.push(("media".into(), media.into()));
}
if is_landscape {
print_options.push(("orientation-requested".into(), "4".into()));
print_options.push(("landscape".into(), "true".into()));
} else {
print_options.push(("orientation-requested".into(), "3".into()));
}
app.printing.begin(submit(bytes, settings, collate, print_options)).map_err(|_| "A print job is already being submitted.".to_owned())?;
app.print_feedback_seen = None;
app.print_gen = app.print_gen.wrapping_add(1);
} else if let Some(print) = &app.services.print {
print(&bytes)?;
}
Ok(len)
});
match result {
Ok(len) => {
app.status(if native { tl!("Submitting print job…") } else { tl!("Opening print dialog…") });
Ok(json!({"printing": true, "bytes": len, "pending": native}))
}
Err(error) => {
log::error!("print failed: {error}");
let msg = crate::i18n::fmt(tl!("Print failed: {error}"), &[("error", &error)]);
app.status(msg.clone());
Err(msg)
}
}
}
#[cfg(test)]
mod tests {
/// Every Layout › Size paper has a printer media name (#2108) the spooler accepts as a keyword.
#[test]
fn every_paper_size_has_a_media_name() {
for (name, _, _) in wordcraft_geom::PAPER_SIZES {
let media = super::pwg_media(name).unwrap_or_else(|| panic!("{name} has no media name"));
assert!(media.len() <= 64 && media.bytes().all(|b| b.is_ascii_graphic() && !matches!(b, b'/' | b':' | b'=' | b'"')), "{media}");
}
assert_eq!(super::pwg_media("Quarto"), None);
}
}
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.