LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LRC-PRINT-GUIDES: the Print dialog (File → Print…) with page preview, rulers, guides and cell editing
Atmik Shetty32b5aefc5b1a
diff --git a/README.md b/README.mdindex 8884f2bd3..8d6a8b414 100644--- a/README.md+++ b/README.md@@ -268,6 +268,20 @@ lightcraft --control 7980 ~/Pictures/tripwith the same font coverage as watermarks (CJK requires craft-fonts), with long names shortened in the middle.This is a contact-sheet workflow,not a printer-driver or custom picture-package layout editor.+- **Print layouts (native app / CLI):** **File → Print…** opens the Print module's layout editor: Single Image,+ Contact Sheet, Picture Package (Auto Layout packs cells onto pages) and Custom Package (drag and resize cells,+ stacking order, snap to cells or a grid), Zoom to Fill / Rotate to Fit, Photo Border and Inner Stroke, paper+ sizes from 4 × 6 to 13 × 19 and A3 to A5 or custom, margins, rulers in in/cm/mm/pt, page background, 72–720 ppi,+ and saved templates. **Print to PDF…** renders in the background. Everything is a `print.*` command+ (`print.get`, `print.set`, `print.cell.add`, `print.layout.autoLayout`, `print.exportPdf`,+ `print.template.save`…), so the CLI and MCP drive it too:++ ```sh+ lightcraft-cli run --import ~/Pictures/shoot print.set 'layout={"style":"picturePackage","page":{"paper":"8x10"}}' \+ print.cell.add width=5 height=7 print.cell.add width=2.5 height=3.5 print.layout.autoLayout print.exportPdf path=Package.pdf+ ```++ Printer colour management and page overlays (identity plate, watermark, page numbers) are not there yet.- **Every widget is addressable** (`ui.widgets`) and clickable by name, so agents operate the real UI, not aside door.- The screenshots in this README were produced end to end by the [`docs/showcase/`](docs/showcase/) scripts.diff --git a/apps/lightcraft-cli/tests/cli.rs b/apps/lightcraft-cli/tests/cli.rsindex fe29704b1..137caca7f 100644--- a/apps/lightcraft-cli/tests/cli.rs+++ b/apps/lightcraft-cli/tests/cli.rs@@ -76,8 +76,11 @@ fn print_commands_chain_into_a_picture_package_pdf() {let export = lines.last().unwrap();assert_eq!((export["result"]["pages"].as_u64(), export["result"]["photos"].as_u64()), (Some(1), Some(1)));let bytes = std::fs::read(&out).unwrap();- assert!(bytes.starts_with(b"%PDF-1.4"));- assert!(String::from_utf8_lossy(&bytes).contains("/MediaBox [0 0 432.00 288.00]"), "6 x 4 in");+ assert!(bytes.starts_with(b"%PDF-"));+ let text = String::from_utf8_lossy(&bytes);+ let at = text.find("/MediaBox [").unwrap() + "/MediaBox [".len();+ let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();+ assert_eq!((nums[2], nums[3]), (432.0, 288.0), "6 x 4 in");// a bad setting fails the run and writes nothing newlet before = std::fs::read(&out).unwrap();let (ok, _, _) =diff --git a/crates/engine/src/print/output.rs b/crates/engine/src/print/output.rsindex f058ccf0b..937884a8e 100644--- a/crates/engine/src/print/output.rs+++ b/crates/engine/src/print/output.rs@@ -88,9 +88,11 @@ mod tests {let pages = [raster(425, 550, [255, 255, 255]), raster(425, 550, [0, 0, 255])];let bytes = write(&pages, &PrintJob::default(), "t").unwrap();let text = String::from_utf8_lossy(&bytes);- assert!(text.starts_with("%PDF-1.4"));+ assert!(text.starts_with("%PDF-"));assert!(text.contains("/Count 2"));- assert!(text.contains("/MediaBox [0 0 306.00 396.00]"), "4.25 x 5.5 in is 306 x 396 pt");+ let at = text.find("/MediaBox [").unwrap() + "/MediaBox [".len();+ let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();+ assert_eq!((nums[2], nums[3]), (306.0, 396.0), "4.25 x 5.5 in is 306 x 396 pt");assert!(text.contains("/Width 425 /Height 550"));assert!(write(&[], &PrintJob::default(), "t").is_err());let mixed = [raster(10, 10, [0; 3]), raster(10, 12, [0; 3])];diff --git a/crates/engine/src/tests_print.rs b/crates/engine/src/tests_print.rsindex 261d47d52..eb7ab032c 100644--- a/crates/engine/src/tests_print.rs+++ b/crates/engine/src/tests_print.rs@@ -171,6 +171,14 @@ fn auto_layout_fills_pages_without_overlap() {}}+/// The first page's MediaBox width and height in points.+fn media_box(pdf: &[u8]) -> (f64, f64) {+ let text = String::from_utf8_lossy(pdf);+ let at = text.find("/MediaBox [").expect("a MediaBox") + "/MediaBox [".len();+ let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();+ (nums[2], nums[3])+}+fn temp_pdf(name: &str) -> String {std::env::temp_dir().join(format!("lightcraft-print-{name}-{}.pdf", std::process::id())).to_string_lossy().to_string()}@@ -190,9 +198,10 @@ fn export_pdf_prints_the_current_settings() {let bytes = std::fs::read(&path).unwrap();assert_eq!(bytes.len() as u64, r["bytes"].as_u64().unwrap());let text = String::from_utf8_lossy(&bytes);- assert!(text.starts_with("%PDF-1.4") && text.contains("/Count 2"));+ assert!(text.starts_with("%PDF-") && text.contains("/Count 2"));// A5 is 148 x 210 mm = 419.53 x 595.28 pt, rounded to whole pixels at 100 ppi (583 x 827)- assert!(text.contains("/MediaBox [0 0 419.76 595.44]"), "{}", &text[..text.len().min(400)]);+ let (w, h) = media_box(&bytes);+ assert!((w - 419.53).abs() < 1.0 && (h - 595.28).abs() < 1.0, "A5, got {w} x {h} pt");// the row in the activity stack is gone when the print is doneassert!(s.activity.list().is_empty());fails(&mut s, "print.exportPdf", json!({}));diff --git a/crates/ui-egui/src/export_task.rs b/crates/ui-egui/src/export_task.rsindex 051ad22bd..470e2a377 100644--- a/crates/ui-egui/src/export_task.rs+++ b/crates/ui-egui/src/export_task.rs@@ -132,6 +132,59 @@ pub fn start_contact_sheet(app: &mut LightcraftApp, params: &Value) -> Result<VaOk(json!({"background": true, "total": total}))}+/// Print the session's current print (`print.get`) to a PDF in the background, with the same+/// activity row and cancellation as the other exports.+pub fn start_print(app: &mut LightcraftApp, params: &Value) -> Result<Value, String> {+ use lightcraft_engine::print::{compose, output};+ if app.export.is_some() {+ return Err("an export is already running".into());+ }+ let path = params.get("path").and_then(Value::as_str).filter(|s| !s.trim().is_empty()).ok_or("missing path")?.to_string();+ app.session.check_write_target(&path)?;+ let guard = app.session.original_guard();+ let settings = app.session.print.clone();+ let ids = app.session.targets(params);+ let prepared = compose::prepare(&mut app.session, &settings, &ids)?;+ let total = prepared.len();+ let title = std::path::Path::new(&path).file_stem().and_then(|n| n.to_str()).unwrap_or("Print").to_string();+ let write = app.services.write_shared.clone();+ let progress = Arc::new(Mutex::new((0, String::new())));+ let cancel = Arc::new(AtomicBool::new(false));+ let (p, c) = (progress.clone(), cancel.clone());+ let (tx, rx) = channel();+ let photos = ids.len();+ let work = move || {+ let result = prepared+ .run(&mut |done, name| {+ if let Ok(mut g) = p.lock() {+ *g = (done, name.to_string());+ }+ !c.load(Ordering::Relaxed)+ })+ .and_then(|pages| {+ if c.load(Ordering::Relaxed) {+ return Err("Print cancelled".into());+ }+ let bytes = output::write(&pages, &settings.job, &title)?;+ guard.check(std::path::Path::new(&path))?;+ match write {+ Some(write) => write(&path, &bytes)?,+ None => lightcraft_engine::export::write_file(&path, &bytes)?,+ }+ Ok(vec![json!({"path": path, "pages": pages.len(), "photos": photos, "bytes": bytes.len(), "print": true})])+ });+ let _ = tx.send(result.map(|files| (files, None, c.load(Ordering::Relaxed))));+ };+ #[cfg(not(target_arch = "wasm32"))]+ std::thread::Builder::new().name("print".into()).spawn(work).map_err(|e| e.to_string())?;+ #[cfg(target_arch = "wasm32")]+ work();+ let row = app.session.activity.start("export", "Printing to PDF", Cancel::Flag(cancel.clone()));+ row.progress(0, total as u64);+ app.export = Some(ExportTask { total, progress, cancel, rx, guard: row });+ Ok(json!({"background": true, "total": total}))+}+/// The toast's account of [`AfterExport::run`]'s Apple Photos outcome.pub fn apple_photos_note(outcome: &Value) -> String {if let Some(e) = outcome.get("error").and_then(Value::as_str) {@@ -200,6 +253,9 @@ pub fn poll(app: &mut LightcraftApp, ctx: &egui::Context) {if let Some(sheet) = sheet {m = format!("Exported contact sheet: {} photos, {} pages", sheet["photos"], sheet["pages"]);}+ if let Some(pdf) = files.first().filter(|f| f["print"] == true) {+ m = format!("Printed to PDF: {} photos, {} pages", pdf["photos"], pdf["pages"]);+ }if skipped > 0 {m += &crate::i18n::tr_format!(" · {skipped} skipped (file exists)", skipped = skipped);}diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 9a387c77c..96ef1d91e 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -26,6 +26,7 @@ pub mod merge;mod model_setup;pub mod panels;pub mod pick;+pub mod print_view;pub mod region;pub mod render;pub mod shortcuts;@@ -104,6 +105,8 @@ mod tests_preset_import;#[cfg(test)]mod tests_preview_limit;#[cfg(test)]+mod tests_print;+#[cfg(test)]mod tests_quit_unsaved;#[cfg(test)]mod tests_scroll;diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rsindex daf0f08e0..ff7f1519d 100644--- a/crates/ui-egui/src/menus.rs+++ b/crates/ui-egui/src/menus.rs@@ -162,6 +162,8 @@ pub const UI_COMMANDS: &[UiCommand] = &[("dialog.pasteSettings", "Paste Selected Settings…", Some("Cmd+Shift+V"), "Edit"),("view.focusSearch", "Find…", Some("Cmd+F"), "Edit"),("dialog.export", "Export…", None, "File"),+ ("dialog.print", "Print…", Some("Cmd+P"), "File"),+ ("app.print", "Print to PDF", None, ""),("dialog.contactSheet", "Contact Sheet PDF…", None, "File"),("app.contactSheet", "Export Contact Sheet PDF", None, ""),("photo.editInPhotoCraft", "Edit in PhotoCraft", Some("Cmd+Shift+E"), "Photo>Edit In"),@@ -1169,6 +1171,28 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Reapp.ui.dialog = Some(Dialog::ContactSheet { options: lightcraft_engine::contact_sheet::Options::default() });Ok(Value::Null)}+ "dialog.print" => {+ app.ui.print = Default::default();+ app.ui.dialog = Some(Dialog::Print);+ Ok(Value::Null)+ }+ "app.print" => {+ if app.export.is_some() {+ return Some(Err("an export is already running".into()));+ }+ let mut params = p.clone();+ if p.get("path").is_none() {+ let req = PickRequest::save("Print to PDF", "PDF", &["pdf"], "Print.pdf");+ let paths = match crate::pick::ask(app, id, p, "path", req, |_| None) {+ Picked::Now(paths) => paths,+ Picked::Later => return Some(Ok(Value::Null)),+ Picked::Unavailable => return Some(Err("no save dialog on this platform; supply path".into())),+ };+ let Some(path) = paths.first() else { return Some(Ok(Value::Null)) };+ params["path"] = json!(path);+ }+ crate::export_task::start_print(app, ¶ms)+ }"app.contactSheet" => {if app.export.is_some() {return Some(Err("an export is already running".into()));@@ -1798,7 +1822,9 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Repub fn ui_enabled(app: &LightcraftApp, id: &str) -> bool {match id {- "dialog.contactSheet" | "app.contactSheet" => !cfg!(target_arch = "wasm32") && app.session.active().is_some() && app.export.is_none(),+ "dialog.contactSheet" | "app.contactSheet" | "dialog.print" | "app.print" => {+ !cfg!(target_arch = "wasm32") && app.session.active().is_some() && app.export.is_none()+ }s if s.starts_with("panel.") || s.starts_with("tool.") || s.starts_with("section.") => app.session.active().is_some() || s == "panel.close","app.export" | "dialog.export" | "dialog.createPreset" | "dialog.rename" | "dialog.captureTime" | "dialog.copySettings" => {app.session.active().is_some()diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rsindex 72528fca9..b574acbe3 100644--- a/crates/ui-egui/src/panels/dialogs.rs+++ b/crates/ui-egui/src/panels/dialogs.rs@@ -176,6 +176,7 @@ pub const WHATS_NEW: &str = include_str!("../../../../docs/whats-new.md");fn window_id(dialog: &Dialog) -> egui::Id {egui::Id::new(match dialog {Dialog::Import { .. } => "lightcraft-import-dialog",+ Dialog::Print => "lightcraft-print-dialog",Dialog::Settings { .. } => "lightcraft-settings-dialog",_ => "lightcraft-dialog",})@@ -251,6 +252,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {Dialog::PasteSettings { .. } => "Paste Selected Settings",Dialog::Export { .. } => "Export",Dialog::ContactSheet { .. } => "Contact Sheet PDF",+ Dialog::Print => "Print",Dialog::Merge { opts } => opts.title(),Dialog::Settings { .. } => "Settings",Dialog::ConfirmDelete { .. } => "Delete Photos",@@ -270,6 +272,8 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {// own so the size it is given doesn't carry over to the other dialogs. Its content scrolls// rather than growing the window when the options below the grid get taller (e.g. Copy).let import = matches!(dlg, Dialog::Import { .. });+ // The Print dialog sizes itself to the window and scrolls its settings column on its own.+ let print = matches!(dlg, Dialog::Print);let window_id = window_id(&dlg);// Every other dialog fits the window (#781): its options scroll when they don't, and the title// bar and the button row stay outside the scroll area. The room they take is measured on the@@ -289,13 +293,14 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {Dialog::Import { .. } => crate::import::DIALOG_SIZE[0],Dialog::SmartRules { .. } => 680.0,Dialog::AllMetadata { .. } => 620.0,+ Dialog::Print => 1100.0,Dialog::FaceModel { .. } => 460.0,Dialog::LightroomCatalog { .. } => 440.0,_ => 380.0,}).show(ctx, |ui| {ui.spacing_mut().item_spacing.y = 8.0;- body_h = dialog_body(ui, (!import).then_some(title.as_str()), body_max, |ui| match &mut dlg {+ body_h = dialog_body(ui, (!import && !print).then_some(title.as_str()), body_max, |ui| match &mut dlg {Dialog::AutoStack { gap } => {ui.label(egui::RichText::new(crate::i18n::tr("Stack photos taken within this time of each other:")).color(t.text_label));ui.add(@@ -1167,6 +1172,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {}}Dialog::Shortcuts => crate::panels::keymap::body(app, ui, &t),+ Dialog::Print => crate::print_view::body(app, ui, &t),});ui.add_space(4.0);ui.horizontal(|ui| {@@ -1203,6 +1209,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {add_label.as_str()}Dialog::ContactSheet { .. } => "Choose PDF…",+ Dialog::Print => "Print to PDF…",Dialog::Merge { .. } => "Merge",Dialog::DenoiseModel { info, .. } if info["download"].is_string() => "Accept & Download",Dialog::DenoiseModel { .. } => "Install",@@ -1276,6 +1283,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {Dialog::Import { .. }| Dialog::Export { .. }| Dialog::ContactSheet { .. }+ | Dialog::Print| Dialog::NewAlbum { .. }| Dialog::NewSmartAlbum { .. }| Dialog::SmartRules { .. }@@ -1665,6 +1673,7 @@ pub fn confirm_dialog(app: &mut LightcraftApp, dlg: &Dialog) -> Result<serde_jso}),),Dialog::ContactSheet { options } => app.run("app.contactSheet", json!(options)),+ Dialog::Print => app.run("app.print", json!({})),Dialog::CopySettings { groups } => app.run("develop.copy", json!({"groups": groups})),Dialog::PasteSettings { groups } => app.run("develop.paste", json!({"groups": groups})),Dialog::Export { opts, full_size, resize, limit_kb, dir, .. } => {diff --git a/crates/ui-egui/src/print_view.rs b/crates/ui-egui/src/print_view.rsnew file mode 100644index 000000000..7c1ab85fb--- /dev/null+++ b/crates/ui-egui/src/print_view.rs@@ -0,0 +1,823 @@+//! The Print dialog (File ▸ Print…): settings on the left, the pages drawn to scale on the right.+//!+//! Every change goes through a `print.*` command ([`lightcraft_engine::cmd`]); this file only draws+//! the session's print ([`lightcraft_engine::Session::print`]) and turns pointer input into+//! commands: dragging a cell is `print.cell.move`, its corner handle `print.cell.resize`, with+//! the guides' snapping done by the command. Widgets register under `print:*`, `button:print*`+//! and `drag:print*` ids for the control channel and the headless tests.+use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, StrokeKind, Ui, Vec2, pos2, vec2};+use lightcraft_catalog::PhotoId;+use lightcraft_engine::export::ExportOptions;+use lightcraft_engine::print::compose::{self, place};+use lightcraft_engine::print::layout::{self, Snap, Style, Unit};+use lightcraft_engine::print::template::PrintSettings;+use serde_json::{Value, json};++use crate::LightcraftApp;+use crate::theme::Tokens;+use crate::widgets::{register, text_button};++/// Width of the settings column.+const SETTINGS_W: f32 = 290.0;+/// Handle for resizing the selected cell, screen points.+const HANDLE: f32 = 12.0;+/// Snap distance while dragging, screen points.+const SNAP_PX: f32 = 8.0;+/// Cell sizes offered as buttons, inches (width, height).+const CELL_SIZES: &[(f64, f64)] = &[(2.0, 2.0), (2.5, 3.5), (3.5, 5.0), (4.0, 5.0), (4.0, 6.0), (5.0, 7.0), (8.0, 10.0), (3.0, 3.0)];++/// A drag of a cell in progress: the cell's rectangle when it began and how far the pointer went.+#[derive(Clone, Debug)]+pub struct Drag {+ cell: u32,+ origin: layout::Rect,+ resize: bool,+ /// Where the pointer was pressed; the distance dragged is measured from it, so the first few+ /// points egui spends deciding between a click and a drag are not lost.+ press: Pos2,+ total: Vec2,+}++/// What the Print dialog remembers between frames (not saved).+#[derive(Clone, Debug, Default)]+pub struct PrintUi {+ /// The page being shown, zero-based.+ pub page: usize,+ /// The selected cell.+ pub selected: Option<u32>,+ drag: Option<Drag>,+ /// The name typed for Save Template.+ pub template_name: String,+ /// Size of the next cell added, inches.+ pub new_cell: Option<(f64, f64)>,+}++fn run(app: &mut LightcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Option<Value> {+ match app.run(id, params) {+ Ok(v) => Some(v),+ Err(e) => {+ app.toast(ctx, e);+ None+ }+ }+}++fn patch(app: &mut LightcraftApp, ctx: &egui::Context, params: Value) {+ run(app, ctx, "print.set", params);+}++fn heading(ui: &mut Ui, t: &Tokens, text: &str) {+ ui.add_space(8.0);+ ui.label(egui::RichText::new(crate::i18n::tr(text)).font(t.semibold(12.0)).color(t.text));+ ui.add_space(2.0);+}++fn row<R>(ui: &mut Ui, t: &Tokens, label: &str, add: impl FnOnce(&mut Ui) -> R) -> R {+ ui.horizontal(|ui| {+ ui.allocate_ui_with_layout(vec2(86.0, 22.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {+ ui.label(egui::RichText::new(crate::i18n::tr(label)).color(t.text_label));+ });+ add(ui)+ })+ .inner+}++fn decimals(unit: Unit) -> usize {+ match unit {+ Unit::Inches | Unit::Centimeters => 2,+ Unit::Millimeters => 1,+ Unit::Points => 0,+ }+}++fn fmt_len(inches: f64, unit: Unit) -> String {+ format!("{:.*} {}", decimals(unit), unit.from_inches(inches), unit.label())+}++/// A length field in the ruler's unit; the new value in inches when it changed.+fn length(ui: &mut Ui, id: &str, inches: f64, unit: Unit, min_in: f64, max_in: f64) -> Option<f64> {+ let mut v = unit.from_inches(inches);+ let r = ui.add(+ egui::DragValue::new(&mut v)+ .range(unit.from_inches(min_in)..=unit.from_inches(max_in))+ .speed(unit.per_inch() * 0.01)+ .max_decimals(decimals(unit))+ .suffix(format!(" {}", unit.label())),+ );+ register(ui.ctx(), format!("drag:{id}"), r.rect);+ r.changed().then(|| unit.to_inches(v))+}++fn check(ui: &mut Ui, id: &str, label: &str, value: bool) -> Option<bool> {+ let mut v = value;+ let r = ui.checkbox(&mut v, crate::i18n::tr(label));+ register(ui.ctx(), format!("check:{id}"), r.rect);+ r.changed().then_some(v)+}++fn choice<V: PartialEq + Copy>(ui: &mut Ui, id: &str, options: &[(V, &str)], current: V) -> Option<V> {+ let mut out = None;+ ui.spacing_mut().item_spacing.x = 3.0;+ for (i, (v, l)) in options.iter().enumerate() {+ if text_button(ui, &format!("{id}-{i}"), l, current == *v).clicked() && current != *v {+ out = Some(*v);+ }+ }+ out+}++fn colour(ui: &mut Ui, id: &str, rgb: [u8; 3]) -> Option<[u8; 3]> {+ let mut c = rgb;+ let r = ui.color_edit_button_srgb(&mut c);+ register(ui.ctx(), format!("color:{id}"), r.rect);+ (c != rgb).then_some(c)+}++fn paper_label(name: &str) -> String {+ match name {+ "a3" | "a4" | "a5" => name.to_uppercase(),+ "letter" => "Letter".into(),+ "legal" => "Legal".into(),+ "tabloid" => "Tabloid".into(),+ "custom" => "Custom".into(),+ other => other.replace('x', " × ") + " in",+ }+}++/// The dialog's body: the settings column and the page preview side by side.+pub fn body(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens) {+ let ctx = ui.ctx().clone();+ let screen = ctx.content_rect();+ let width = (screen.width() - 80.0).clamp(640.0, 1180.0);+ let height = (screen.height() - 190.0).clamp(280.0, 780.0);+ let mut pu = std::mem::take(&mut app.ui.print);+ let st = app.session.print.clone();+ let ids = app.session.targets(&json!({}));+ // the page shown stays inside the print+ let pages = st.layout.page_count(ids.len());+ pu.page = pu.page.min(pages.saturating_sub(1));+ if pu.selected.is_some_and(|c| st.layout.cell(c).is_none_or(|c| c.page as usize != pu.page)) && pu.drag.is_none() {+ pu.selected = pu.selected.filter(|c| st.layout.cell(*c).is_some());+ }+ ui.horizontal_top(|ui| {+ ui.allocate_ui_with_layout(vec2(SETTINGS_W, height), egui::Layout::top_down(egui::Align::Min), |ui| {+ ui.set_min_size(vec2(SETTINGS_W, height));+ egui::ScrollArea::vertical().id_salt("print-settings").max_height(height).auto_shrink([false, false]).show(ui, |ui| {+ ui.set_width(SETTINGS_W - 14.0);+ settings(app, ui, t, &mut pu, &st, ids.len());+ });+ });+ // (a `separator` would take the dialog's whole free height)+ let (line, _) = ui.allocate_exact_size(vec2(1.0, height), Sense::hover());+ ui.painter().line_segment([line.center_top(), line.center_bottom()], Stroke::new(1.0, t.divider));+ let w = (width - SETTINGS_W - 24.0).max(300.0);+ ui.allocate_ui_with_layout(vec2(w, height), egui::Layout::top_down(egui::Align::Min), |ui| {+ ui.set_min_size(vec2(w, height));+ preview(app, ui, t, &mut pu, &st, &ids, pages);+ });+ });+ app.ui.print = pu;+}++fn settings(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens, pu: &mut PrintUi, st: &PrintSettings, photos: usize) {+ let ctx = ui.ctx().clone();+ let l = &st.layout;+ let unit = st.guides.units;+ ui.spacing_mut().item_spacing.y = 5.0;+ ui.label(egui::RichText::new(crate::i18n::tr_format!("{n} photo{}", if photos == 1 { "" } else { "s" }, n = photos)).color(t.text_dim));++ heading(ui, t, "Templates");+ ui.horizontal(|ui| {+ crate::text_field::TextField::singleline("field:printTemplateName", &mut pu.template_name)+ .hint(crate::i18n::tr("Template name"))+ .width(140.0)+ .show(ui);+ if text_button(ui, "printSaveTemplate", "Save", false).clicked() && !pu.template_name.trim().is_empty() {+ run(app, &ctx, "print.template.save", json!({"name": pu.template_name}));+ }+ });+ let names: Vec<String> = app.session.print_templates.iter().map(|t| t.name.clone()).collect();+ for (i, name) in names.iter().enumerate() {+ ui.horizontal(|ui| {+ ui.label(egui::RichText::new(name).color(t.text_label));+ ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {+ if text_button(ui, &format!("printTemplateDelete-{i}"), "Delete", false).clicked() {+ run(app, &ctx, "print.template.delete", json!({"name": name}));+ }+ if text_button(ui, &format!("printTemplateApply-{i}"), "Apply", false).clicked() {+ run(app, &ctx, "print.template.apply", json!({"name": name}));+ pu.page = 0;+ pu.selected = None;+ }+ });+ });+ }++ heading(ui, t, "Layout Style");+ let styles =+ [(Style::SingleImage, "Single"), (Style::ContactSheet, "Contact"), (Style::PicturePackage, "Package"), (Style::CustomPackage, "Custom")];+ ui.horizontal_wrapped(|ui| {+ if let Some(s) = choice(ui, "printStyle", &styles, l.style) {+ patch(app, &ctx, json!({"layout": {"style": s}}));+ pu.page = 0;+ }+ });++ heading(ui, t, "Image Settings");+ let im = &st.image;+ if let Some(v) = check(ui, "printZoomFill", "Zoom to Fill Frame", im.zoom_to_fill) {+ patch(app, &ctx, json!({"image": {"zoomToFill": v}}));+ }+ if let Some(v) = check(ui, "printRotateFit", "Rotate to Fit", im.rotate_to_fit) {+ patch(app, &ctx, json!({"image": {"rotateToFit": v}}));+ }+ if l.style.is_package() {+ ui.horizontal(|ui| {+ if let Some(v) = check(ui, "printBorder", "Photo Border", im.border_enabled) {+ patch(app, &ctx, json!({"image": {"borderEnabled": v}}));+ }+ if let Some(w) = length(ui, "printBorderWidth", im.border_width, unit, 0.0, 2.0) {+ patch(app, &ctx, json!({"image": {"borderWidth": w}}));+ }+ if let Some(c) = colour(ui, "printBorderColor", im.border_color) {+ patch(app, &ctx, json!({"image": {"borderColor": c}}));+ }+ });+ }+ ui.horizontal(|ui| {+ if let Some(v) = check(ui, "printStroke", "Inner Stroke", im.stroke_enabled) {+ patch(app, &ctx, json!({"image": {"strokeEnabled": v}}));+ }+ let mut pt = im.stroke_width_pt;+ let r = ui.add(egui::DragValue::new(&mut pt).range(0.0..=36.0).speed(0.05).max_decimals(2).suffix(" pt"));+ register(ui.ctx(), "drag:printStrokeWidth", r.rect);+ if r.changed() {+ patch(app, &ctx, json!({"image": {"strokeWidthPt": pt}}));+ }+ if let Some(c) = colour(ui, "printStrokeColor", im.stroke_color) {+ patch(app, &ctx, json!({"image": {"strokeColor": c}}));+ }+ });++ heading(ui, t, "Layout");+ match l.style {+ Style::SingleImage => {+ ui.label(egui::RichText::new(crate::i18n::tr("One photo fills each page inside the margins.")).color(t.text_dim));+ }+ Style::ContactSheet => {+ let g = &l.grid;+ row(ui, t, "Grid", |ui| {+ let (mut c, mut r) = (g.columns, g.rows);+ let a = ui.add(egui::DragValue::new(&mut c).range(1..=layout::MAX_GRID).suffix(" cols"));+ register(ui.ctx(), "drag:printColumns", a.rect);+ let b = ui.add(egui::DragValue::new(&mut r).range(1..=layout::MAX_GRID).suffix(" rows"));+ register(ui.ctx(), "drag:printRows", b.rect);+ if a.changed() || b.changed() {+ patch(app, &ctx, json!({"layout": {"grid": {"columns": c, "rows": r}}}));+ }+ });+ row(ui, t, "Spacing", |ui| {+ if let Some(v) = length(ui, "printSpacingX", g.spacing_x, unit, 0.0, 2.0) {+ patch(app, &ctx, json!({"layout": {"grid": {"spacingX": v}}}));+ }+ if let Some(v) = length(ui, "printSpacingY", g.spacing_y, unit, 0.0, 2.0) {+ patch(app, &ctx, json!({"layout": {"grid": {"spacingY": v}}}));+ }+ });+ if let Some(v) = check(ui, "printKeepSquare", "Keep Square", g.keep_square) {+ patch(app, &ctx, json!({"layout": {"grid": {"keepSquare": v}}}));+ }+ }+ Style::PicturePackage | Style::CustomPackage => {+ ui.label(egui::RichText::new(crate::i18n::tr("Add a cell")).color(t.text_label));+ ui.horizontal_wrapped(|ui| {+ ui.spacing_mut().item_spacing = vec2(3.0, 3.0);+ for (i, (w, h)) in CELL_SIZES.iter().enumerate() {+ if text_button(ui, &format!("printAddCell-{i}"), &format!("{} × {}", trim(*w), trim(*h)), false).clicked() {+ add_cell(app, &ctx, pu, *w, *h);+ }+ }+ });+ let (mut w, mut h) = pu.new_cell.unwrap_or((3.0, 2.0));+ row(ui, t, "Custom size", |ui| {+ if let Some(v) = length(ui, "printNewCellW", w, unit, layout::MIN_CELL_IN, 30.0) {+ w = v;+ }+ if let Some(v) = length(ui, "printNewCellH", h, unit, layout::MIN_CELL_IN, 30.0) {+ h = v;+ }+ });+ pu.new_cell = Some((w, h));+ ui.horizontal(|ui| {+ if text_button(ui, "printAddCustom", "Add Cell", false).clicked() {+ add_cell(app, &ctx, pu, w, h);+ }+ if l.style == Style::PicturePackage && text_button(ui, "printAutoLayout", "Auto Layout", false).clicked() {+ run(app, &ctx, "print.layout.autoLayout", json!({}));+ pu.page = 0;+ }+ });+ ui.horizontal(|ui| {+ if text_button(ui, "printNewPage", "New Page", false).clicked()+ && let Some(r) = run(app, &ctx, "print.layout.newPage", json!({}))+ {+ pu.page = r["page"].as_u64().unwrap_or(0) as usize;+ }+ if text_button(ui, "printClear", "Clear Layout", false).clicked() {+ run(app, &ctx, "print.layout.clear", json!({}));+ pu.page = 0;+ pu.selected = None;+ }+ });+ row(ui, t, "Gap", |ui| {+ if let Some(v) = length(ui, "printGap", l.spacing, unit, 0.0, 2.0) {+ patch(app, &ctx, json!({"layout": {"spacing": v}}));+ }+ });+ }+ }++ heading(ui, t, "Rulers, Grid & Guides");+ let g = &st.guides;+ if let Some(v) = check(ui, "printRulers", "Show Rulers", g.show_rulers) {+ patch(app, &ctx, json!({"guides": {"showRulers": v}}));+ }+ row(ui, t, "Units", |ui| {+ let units = [(Unit::Inches, "in"), (Unit::Centimeters, "cm"), (Unit::Millimeters, "mm"), (Unit::Points, "pt")];+ if let Some(u) = choice(ui, "printUnits", &units, g.units) {+ patch(app, &ctx, json!({"guides": {"units": u}}));+ }+ });+ row(ui, t, "Snap", |ui| {+ if let Some(s) = choice(ui, "printSnap", &[(Snap::Off, "Off"), (Snap::Cells, "Cells"), (Snap::Grid, "Grid")], g.snap) {+ patch(app, &ctx, json!({"guides": {"snap": s}}));+ }+ });+ row(ui, t, "Grid size", |ui| {+ if let Some(v) = length(ui, "printGridSize", g.grid_size, unit, 0.05, 10.0) {+ patch(app, &ctx, json!({"guides": {"gridSize": v}}));+ }+ });+ for (id, label, on, key) in [+ ("printShowMargins", "Page Margins", g.show_margins, "showMargins"),+ ("printShowBleed", "Page Bleed", g.show_bleed, "showBleed"),+ ("printShowGrid", "Page Grid", g.show_page_grid, "showPageGrid"),+ ("printShowCells", "Image Cells", g.show_cells, "showCells"),+ ("printShowDims", "Dimensions", g.show_dimensions, "showDimensions"),+ ] {+ if let Some(v) = check(ui, id, label, on) {+ patch(app, &ctx, json!({"guides": {(key): v}}));+ }+ }++ heading(ui, t, "Page Setup");+ row(ui, t, "Paper", |ui| {+ let current = if l.page.paper.eq_ignore_ascii_case("custom") { "custom".to_string() } else { l.page.paper.to_ascii_lowercase() };+ let c = egui::ComboBox::from_id_salt("printPaper").selected_text(paper_label(¤t)).show_ui(ui, |ui| {+ for name in layout::paper_names().chain(std::iter::once("custom")) {+ if ui.selectable_label(current == name, paper_label(name)).clicked() {+ patch(app, &ctx, json!({"layout": {"page": {"paper": name}}}));+ }+ }+ });+ register(ui.ctx(), "combo:printPaper", c.response.rect);+ });+ if l.page.paper.eq_ignore_ascii_case("custom") {+ row(ui, t, "Size", |ui| {+ if let Some(v) = length(ui, "printCustomW", l.page.custom_width, unit, layout::MIN_PAGE_IN, layout::MAX_PAGE_IN) {+ patch(app, &ctx, json!({"layout": {"page": {"customWidth": v}}}));+ }+ if let Some(v) = length(ui, "printCustomH", l.page.custom_height, unit, layout::MIN_PAGE_IN, layout::MAX_PAGE_IN) {+ patch(app, &ctx, json!({"layout": {"page": {"customHeight": v}}}));+ }+ });+ }+ row(ui, t, "Orientation", |ui| {+ let o = [(layout::Orientation::Portrait, "Portrait"), (layout::Orientation::Landscape, "Landscape")];+ if let Some(v) = choice(ui, "printOrientation", &o, l.page.orientation) {+ patch(app, &ctx, json!({"layout": {"page": {"orientation": v}}}));+ }+ });+ let m = &l.page.margins;+ for (label, id, key, v) in [+ ("Left", "printMarginLeft", "left", m.left),+ ("Right", "printMarginRight", "right", m.right),+ ("Top", "printMarginTop", "top", m.top),+ ("Bottom", "printMarginBottom", "bottom", m.bottom),+ ] {+ row(ui, t, label, |ui| {+ if let Some(v) = length(ui, id, v, unit, 0.0, layout::MAX_MARGIN_IN) {+ patch(app, &ctx, json!({"layout": {"page": {"margins": {(key): v}}}}));+ }+ });+ }++ heading(ui, t, "Page");+ row(ui, t, "Background", |ui| {+ if let Some(c) = colour(ui, "printBackground", st.page.background) {+ patch(app, &ctx, json!({"page": {"background": c}}));+ }+ });++ heading(ui, t, "Print Job");+ row(ui, t, "Resolution", |ui| {+ let mut ppi = st.job.ppi;+ let r = ui.add(egui::DragValue::new(&mut ppi).range(72.0..=720.0).speed(1.0).max_decimals(0).suffix(" ppi"));+ register(ui.ctx(), "drag:printPpi", r.rect);+ if r.changed() {+ patch(app, &ctx, json!({"job": {"ppi": ppi}}));+ }+ });+ ui.label(egui::RichText::new(crate::i18n::tr("PDF · sRGB · current edits")).color(t.text_dim));+}++fn trim(v: f64) -> String {+ let s = format!("{v:.2}");+ s.trim_end_matches('0').trim_end_matches('.').to_string()+}++fn add_cell(app: &mut LightcraftApp, ctx: &egui::Context, pu: &mut PrintUi, w: f64, h: f64) {+ if let Some(r) = run(app, ctx, "print.cell.add", json!({"width": w, "height": h})) {+ pu.selected = r["id"].as_u64().and_then(|v| u32::try_from(v).ok());+ pu.page = r["cell"]["page"].as_u64().unwrap_or(0) as usize;+ }+}++// ---- preview -------------------------------------------------------------------------------++/// Screen geometry of the page on show.+struct Sheet {+ page: Rect,+ /// Screen points per inch.+ scale: f32,+}++impl Sheet {+ fn rect(&self, r: &layout::Rect) -> Rect {+ Rect::from_min_size(self.page.min + vec2(r.x as f32, r.y as f32) * self.scale, vec2(r.w as f32, r.h as f32) * self.scale)+ }+}++fn preview(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens, pu: &mut PrintUi, st: &PrintSettings, ids: &[PhotoId], pages: usize) {+ let ctx = ui.ctx().clone();+ // room for the page buttons and, for a package, the selected cell's row (which may wrap)+ let footer = if st.layout.style.is_package() { 104.0 } else { 44.0 };+ let size = vec2(ui.available_width(), (ui.available_height() - footer).max(120.0));+ let (area, _) = ui.allocate_exact_size(size, Sense::hover());+ let painter = ui.painter_at(area);+ painter.rect_filled(area, 4.0, t.canvas);+ let Ok((pw, ph)) = st.layout.page_size() else {+ painter.text(area.center(), Align2::CENTER_CENTER, crate::i18n::tr("This page setup is not valid"), t.font(13.0), t.caution);+ return;+ };+ let g = &st.guides;+ let ruler = if g.show_rulers { 22.0 } else { 0.0 };+ let inner = Rect::from_min_max(area.min + vec2(ruler, ruler), area.max).shrink(14.0);+ let scale = ((inner.width() as f64 / pw).min(inner.height() as f64 / ph) as f32).max(1.0);+ let sheet = Sheet { page: Rect::from_center_size(inner.center(), vec2(pw as f32, ph as f32) * scale), scale };+ register(&ctx, "print:page", sheet.page);++ painter.rect_filled(sheet.page.translate(vec2(2.0, 3.0)), 0.0, Color32::from_black_alpha(70));+ let bg = st.page.background;+ painter.rect_filled(sheet.page, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2]));+ let guide = Stroke::new(1.0, Color32::from_rgb(90, 160, 240));+ if g.show_rulers {+ rulers(&painter, t, &sheet, area, pw, ph, g.units);+ }+ let area_in = st.layout.printable().ok();+ if g.show_bleed {+ let b = 0.125;+ dashed(&painter, sheet.page.expand(b as f32 * scale), Stroke::new(1.0, t.caution));+ }+ if g.show_page_grid+ && let Some(a) = area_in+ {+ let faint = Stroke::new(1.0, Color32::from_rgba_unmultiplied(120, 120, 120, 70));+ let step = g.grid_size.max(0.05);+ let mut x = 0.0;+ while a.x + x <= a.right() + 1e-9 && x < 200.0 {+ let sx = sheet.page.left() + (a.x + x) as f32 * scale;+ painter.line_segment([pos2(sx, sheet.page.top()), pos2(sx, sheet.page.bottom())], faint);+ x += step;+ }+ let mut y = 0.0;+ while a.y + y <= a.bottom() + 1e-9 && y < 200.0 {+ let sy = sheet.page.top() + (a.y + y) as f32 * scale;+ painter.line_segment([pos2(sheet.page.left(), sy), pos2(sheet.page.right(), sy)], faint);+ y += step;+ }+ }+ if g.show_margins+ && let Some(a) = area_in+ {+ dashed(&painter, sheet.rect(&layout::Rect::new(a.x, a.y, a.w, a.h)), guide);+ }++ let package = st.layout.style.is_package();+ if package {+ package_cells(app, ui, &painter, t, pu, st, ids, &sheet);+ } else {+ let plan = compose::plan_cells(&st.layout, ids).ok();+ let cells: Vec<(layout::Rect, Option<PhotoId>)> = match plan.as_ref().and_then(|p| p.get(pu.page)) {+ Some(page) => page.iter().map(|(r, id)| (*r, Some(*id))).collect(),+ None => st.layout.grid_rects().unwrap_or_default().into_iter().map(|r| (r, None)).collect(),+ };+ for (i, (r, photo)) in cells.iter().enumerate() {+ let rect = sheet.rect(r);+ register(&ctx, format!("print:gridcell:{i}"), rect);+ paint_cell(app, &painter, t, st, rect, *photo, &sheet, r);+ }+ }++ // footer: page navigation and the selected cell+ ui.horizontal(|ui| {+ if text_button(ui, "printPagePrev", "◀", false).clicked() && pu.page > 0 {+ pu.page -= 1;+ pu.selected = None;+ }+ let label = ui.label(egui::RichText::new(format!("{} {} / {}", crate::i18n::tr("Page"), pu.page + 1, pages)).color(t.text));+ register(ui.ctx(), "print:pageLabel", label.rect);+ if text_button(ui, "printPageNext", "▶", false).clicked() && pu.page + 1 < pages {+ pu.page += 1;+ pu.selected = None;+ }+ ui.label(egui::RichText::new(fmt_len(pw, g.units) + " × " + &fmt_len(ph, g.units)).color(t.text_dim));+ if package {+ ui.label(egui::RichText::new(format!("{} {}", st.layout.cells.len(), crate::i18n::tr("cells"))).color(t.text_dim));+ if st.layout.has_overlaps() {+ ui.label(egui::RichText::new(crate::i18n::tr("cells overlap")).color(t.caution));+ }+ }+ });+ if package {+ inspector(app, ui, t, pu, st);+ }+}++fn press_origin(ui: &Ui, resp: &egui::Response) -> Pos2 {+ ui.input(|i| i.pointer.press_origin()).or_else(|| resp.interact_pointer_pos()).unwrap_or_default()+}++/// Draws and handles every cell of a package page, back to front.+#[allow(clippy::too_many_arguments)]+fn package_cells(+ app: &mut LightcraftApp,+ ui: &mut Ui,+ painter: &egui::Painter,+ t: &Tokens,+ pu: &mut PrintUi,+ st: &PrintSettings,+ ids: &[PhotoId],+ sheet: &Sheet,+) {+ let ctx = ui.ctx().clone();+ let first = ids.first().copied();+ let cells: Vec<layout::Cell> = st.layout.cells_on_page(pu.page as u32).cloned().collect();+ for c in &cells {+ let photo = if st.layout.style == Style::CustomPackage { c.photo.map(PhotoId).or(first) } else { first };+ let rect = sheet.rect(&c.rect);+ paint_cell(app, painter, t, st, rect, photo, sheet, &c.rect);+ let resp = ui.interact(rect, egui::Id::new(("print-cell", c.id)), Sense::click_and_drag());+ register(&ctx, format!("print:cell:{}", c.id), rect);+ if resp.clicked() || resp.drag_started() {+ pu.selected = Some(c.id);+ }+ if resp.drag_started() {+ pu.drag = Some(Drag { cell: c.id, origin: c.rect, resize: false, press: press_origin(ui, &resp), total: Vec2::ZERO });+ }+ if resp.dragged()+ && let Some(d) = pu.drag.as_mut().filter(|d| d.cell == c.id && !d.resize)+ {+ d.total = resp.interact_pointer_pos().map_or(d.total, |p| p - d.press);+ let (x, y) = (d.origin.x + f64::from(d.total.x / sheet.scale), d.origin.y + f64::from(d.total.y / sheet.scale));+ let threshold = f64::from(SNAP_PX / sheet.scale);+ run(app, &ctx, "print.cell.move", json!({"id": c.id, "x": x, "y": y, "snap": true, "threshold": threshold}));+ }+ if resp.drag_stopped() {+ pu.drag = None;+ }+ let id = c.id;+ resp.context_menu(|ui| {+ for (how, label) in+ [("toFront", "Bring to Front"), ("forward", "Bring Forward"), ("backward", "Send Backward"), ("toBack", "Send to Back")]+ {+ if ui.button(crate::i18n::tr(label)).clicked() {+ run(app, &ctx, "print.cell.stack", json!({"id": id, "order": how}));+ ui.close();+ }+ }+ ui.separator();+ if ui.button(crate::i18n::tr("Delete Cell")).clicked() {+ run(app, &ctx, "print.cell.delete", json!({"id": id}));+ ui.close();+ }+ });+ }+ // the selected cell's outline and resize handle go over everything+ let Some(sel) = pu.selected.and_then(|s| cells.iter().find(|c| c.id == s)) else { return };+ let rect = sheet.rect(&sel.rect);+ painter.rect_stroke(rect, 0.0, Stroke::new(2.0, t.accent), StrokeKind::Outside);+ let handle = Rect::from_center_size(rect.right_bottom(), Vec2::splat(HANDLE));+ painter.rect_filled(handle, 2.0, t.accent);+ let resp = ui.interact(handle, egui::Id::new(("print-resize", sel.id)), Sense::drag());+ register(&ctx, format!("print:resize:{}", sel.id), handle);+ if resp.drag_started() {+ pu.drag = Some(Drag { cell: sel.id, origin: sel.rect, resize: true, press: press_origin(ui, &resp), total: Vec2::ZERO });+ }+ if resp.dragged()+ && let Some(d) = pu.drag.as_mut().filter(|d| d.cell == sel.id && d.resize)+ {+ d.total = resp.interact_pointer_pos().map_or(d.total, |p| p - d.press);+ let (w, h) = (d.origin.w + f64::from(d.total.x / sheet.scale), d.origin.h + f64::from(d.total.y / sheet.scale));+ let threshold = f64::from(SNAP_PX / sheet.scale);+ run(+ app,+ &ctx,+ "print.cell.resize",+ json!({"id": sel.id, "width": w.max(layout::MIN_CELL_IN), "height": h.max(layout::MIN_CELL_IN), "snap": true, "threshold": threshold}),+ );+ }+ if resp.drag_stopped() {+ pu.drag = None;+ }+}++/// The selected cell's numbers, its place in the stack and its photo.+fn inspector(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens, pu: &mut PrintUi, st: &PrintSettings) {+ let ctx = ui.ctx().clone();+ let Some(cell) = pu.selected.and_then(|id| st.layout.cell(id)) else {+ ui.label(egui::RichText::new(crate::i18n::tr("Click a cell to move, resize or arrange it")).color(t.text_dim));+ return;+ };+ let (id, r, unit) = (cell.id, cell.rect, st.guides.units);+ ui.horizontal_wrapped(|ui| {+ ui.spacing_mut().item_spacing.x = 4.0;+ if let Some(v) = length(ui, "printCellX", r.x, unit, 0.0, 60.0) {+ run(app, &ctx, "print.cell.move", json!({"id": id, "x": v, "y": r.y}));+ }+ if let Some(v) = length(ui, "printCellY", r.y, unit, 0.0, 60.0) {+ run(app, &ctx, "print.cell.move", json!({"id": id, "x": r.x, "y": v}));+ }+ if let Some(v) = length(ui, "printCellW", r.w, unit, layout::MIN_CELL_IN, 60.0) {+ run(app, &ctx, "print.cell.resize", json!({"id": id, "width": v, "height": r.h}));+ }+ if let Some(v) = length(ui, "printCellH", r.h, unit, layout::MIN_CELL_IN, 60.0) {+ run(app, &ctx, "print.cell.resize", json!({"id": id, "width": r.w, "height": v}));+ }+ for (i, (how, label)) in [("toBack", "Back"), ("backward", "Backward"), ("forward", "Forward"), ("toFront", "Front")].into_iter().enumerate()+ {+ if text_button(ui, &format!("printStack-{i}"), label, false).clicked() {+ run(app, &ctx, "print.cell.stack", json!({"id": id, "order": how}));+ }+ }+ if st.layout.style == Style::CustomPackage {+ if text_button(ui, "printCellPhoto", "Use Active Photo", false).clicked() {+ let active = app.session.active().map(|p| p.0);+ run(app, &ctx, "print.cell.photo", json!({"id": id, "photo": active}));+ }+ if cell.photo.is_some() && text_button(ui, "printCellPhotoClear", "Clear Photo", false).clicked() {+ run(app, &ctx, "print.cell.photo", json!({"id": id, "photo": null}));+ }+ }+ if text_button(ui, "printCellDelete", "Delete", false).clicked() {+ run(app, &ctx, "print.cell.delete", json!({"id": id}));+ pu.selected = None;+ }+ });+}++/// One cell on screen: the photo as it will print (fit or fill, turned, border, stroke).+#[allow(clippy::too_many_arguments)]+fn paint_cell(+ app: &mut LightcraftApp,+ painter: &egui::Painter,+ t: &Tokens,+ st: &PrintSettings,+ cell: Rect,+ photo: Option<PhotoId>,+ sheet: &Sheet,+ inches: &layout::Rect,+) {+ let im = &st.image;+ if st.guides.show_cells {+ painter.rect_stroke(cell, 0.0, Stroke::new(1.0, Color32::from_rgba_unmultiplied(120, 150, 190, 150)), StrokeKind::Inside);+ }+ let border = if st.layout.style.is_package() && im.border_enabled {+ (im.border_width as f32 * sheet.scale).min(cell.width().min(cell.height()).max(2.0) / 2.0 - 1.0).max(0.0)+ } else {+ 0.0+ };+ let avail = cell.shrink(border);+ if avail.width() < 1.0 || avail.height() < 1.0 {+ return;+ }+ // the photo's shape: its cropped size, or 3:2 for a placeholder+ let (nw, nh) = photo.and_then(|id| app.session.catalog.photo(id)).map_or((3.0, 2.0), |p| {+ let (w, h) = lightcraft_engine::export::output_size(p, &ExportOptions::default());+ (w as f64, h as f64)+ });+ let scale = 8.0; // sub-point resolution for the rounding in `place`+ let aw = (f64::from(avail.width()) * scale).round() as usize;+ let ah = (f64::from(avail.height()) * scale).round() as usize;+ let Some(p) = place(nw, nh, aw, ah, im.zoom_to_fill, im.rotate_to_fit) else { return };+ let shown = Rect::from_center_size(avail.center(), vec2(p.w as f32, p.h as f32) / scale as f32);+ let visible = shown.intersect(avail);+ if border > 0.0 {+ let frame = visible.expand(border);+ let c = im.border_color;+ painter.rect_filled(frame.intersect(cell), 0.0, Color32::from_rgb(c[0], c[1], c[2]));+ }+ let clip = painter.with_clip_rect(avail.intersect(painter.clip_rect()));+ let tex = photo.and_then(|id| {+ let px = (shown.width().max(shown.height()) * 2.0).clamp(64.0, 1024.0) as usize;+ crate::panels::grid::request_thumb(app, id, px, 10);+ app.renderer.thumb(id).map(|tex| tex.tex.id())+ });+ match tex {+ Some(id) => {+ let mut mesh = egui::Mesh::with_texture(id);+ // an unturned quad maps the texture straight; a turned one (a quarter clockwise) takes+ // the left edge to the top+ let uv: [Pos2; 4] = if p.rotated {+ [pos2(0.0, 1.0), pos2(0.0, 0.0), pos2(1.0, 0.0), pos2(1.0, 1.0)]+ } else {+ [pos2(0.0, 0.0), pos2(1.0, 0.0), pos2(1.0, 1.0), pos2(0.0, 1.0)]+ };+ let corners = [shown.left_top(), shown.right_top(), shown.right_bottom(), shown.left_bottom()];+ for (pos, uv) in corners.into_iter().zip(uv) {+ mesh.vertices.push(egui::epaint::Vertex { pos, uv, color: Color32::WHITE });+ }+ mesh.indices.extend([0, 1, 2, 0, 2, 3]);+ clip.add(egui::Shape::mesh(mesh));+ }+ None => {+ clip.rect_filled(shown, 0.0, if photo.is_some() { Color32::from_gray(52) } else { Color32::from_gray(200) });+ }+ }+ if im.stroke_enabled && im.stroke_width_pt > 0.0 {+ let w = (im.stroke_width_pt as f32 / 72.0 * sheet.scale).max(1.0).min(visible.width().min(visible.height()) / 2.0);+ let c = im.stroke_color;+ painter.rect_stroke(visible, 0.0, Stroke::new(w, Color32::from_rgb(c[0], c[1], c[2])), StrokeKind::Inside);+ }+ if st.guides.show_dimensions {+ let text = format!("{} × {}", fmt_len(inches.w, st.guides.units), fmt_len(inches.h, st.guides.units));+ let galley = painter.layout_no_wrap(text, t.font(10.0), Color32::WHITE);+ let at = pos2(cell.center().x - galley.size().x / 2.0, cell.bottom() - galley.size().y - 3.0);+ painter.rect_filled(Rect::from_min_size(at, galley.size()).expand(2.0), 2.0, Color32::from_black_alpha(160));+ painter.galley(at, galley, Color32::WHITE);+ }+}++fn dashed(painter: &egui::Painter, r: Rect, stroke: Stroke) {+ let pts = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];+ painter.extend(egui::Shape::dashed_line(&pts, stroke, 5.0, 4.0));+}++/// Rulers along the top and left of the preview, in `unit`, zero at the page's corner.+fn rulers(painter: &egui::Painter, t: &Tokens, sheet: &Sheet, area: Rect, pw: f64, ph: f64, unit: Unit) {+ let (major, minor) = match unit {+ Unit::Inches => (1.0, 0.25),+ Unit::Centimeters => (1.0, 0.5),+ Unit::Millimeters => (10.0, 5.0),+ Unit::Points => (72.0, 18.0),+ };+ let tick = Stroke::new(1.0, t.text_dim);+ let ink = t.text_dim;+ let top = Rect::from_min_max(area.min, pos2(area.max.x, area.min.y + 20.0));+ let left = Rect::from_min_max(area.min, pos2(area.min.x + 20.0, area.max.y));+ painter.rect_filled(top, 0.0, t.chrome);+ painter.rect_filled(left, 0.0, t.chrome);+ let ticks = |len_in: f64| (0..).map(move |k| f64::from(k) * minor).take_while(move |v| *v <= unit.from_inches(len_in) + 1e-9).take(2000);+ for v in ticks(pw) {+ let x = sheet.page.left() + unit.to_inches(v) as f32 * sheet.scale;+ let is_major = (v / major - (v / major).round()).abs() < 1e-9;+ painter.line_segment([pos2(x, top.bottom()), pos2(x, top.bottom() - if is_major { 10.0 } else { 5.0 })], tick);+ if is_major {+ painter.text(pos2(x + 2.0, top.top() + 1.0), Align2::LEFT_TOP, format!("{}", v.round() as i64), t.font(9.0), ink);+ }+ }+ for v in ticks(ph) {+ let y = sheet.page.top() + unit.to_inches(v) as f32 * sheet.scale;+ let is_major = (v / major - (v / major).round()).abs() < 1e-9;+ painter.line_segment([pos2(left.right(), y), pos2(left.right() - if is_major { 10.0 } else { 5.0 }, y)], tick);+ if is_major {+ painter.text(pos2(left.left() + 1.0, y + 1.0), Align2::LEFT_TOP, format!("{}", v.round() as i64), t.font(9.0), ink);+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn lengths_read_in_the_ruler_unit() {+ assert_eq!(fmt_len(1.0, Unit::Inches), "1.00 in");+ assert_eq!(fmt_len(1.0, Unit::Millimeters), "25.4 mm");+ assert_eq!(fmt_len(1.0, Unit::Points), "72 pt");+ assert_eq!(trim(4.0), "4");+ assert_eq!(trim(2.5), "2.5");+ assert_eq!(paper_label("a4"), "A4");+ assert_eq!(paper_label("4x6"), "4 × 6 in");+ }+}diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rsindex b76066d55..5e43cbe93 100644--- a/crates/ui-egui/src/state.rs+++ b/crates/ui-egui/src/state.rs@@ -735,6 +735,9 @@ pub struct UiState {pub status: String,#[serde(skip)]pub dialog: Option<Dialog>,+ /// The Print dialog's page, selection and drag.+ #[serde(skip)]+ pub print: crate::print_view::PrintUi,}/// Settings group ids (`SettingsGroup` serde names) a new preset includes by default: everything@@ -763,6 +766,9 @@ pub struct NameEdit {#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]#[serde(tag = "kind", rename_all = "camelCase")]pub enum Dialog {+ /// File ▸ Print…: the Print module. Its state is the session's (`print.*`); the page on show+ /// and the selected cell are [`UiState::print`].+ Print,ContactSheet {options: lightcraft_engine::contact_sheet::Options,},@@ -1133,6 +1139,7 @@ impl Default for UiState {last_find_missing: None,status: String::new(),dialog: None,+ print: Default::default(),}}}diff --git a/crates/ui-egui/src/tests_print.rs b/crates/ui-egui/src/tests_print.rsnew file mode 100644index 000000000..6dbea7a40--- /dev/null+++ b/crates/ui-egui/src/tests_print.rs@@ -0,0 +1,300 @@+//! The Print dialog, driven through the control channel: styles, cells dragged and resized with+//! real pointer input, Auto Layout, pages, templates and the PDF.++use std::sync::{Arc, Mutex};+use std::time::Duration;++use serde_json::{Value, json};++use crate::headless::Headless;+use crate::state::Dialog;+use crate::{LightcraftApp, Services};++const T: Duration = Duration::from_secs(30);++fn demo(services: Services) -> Headless {+ let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), services);+ let mut h = Headless::new(app, [1400.0, 900.0], 1.0);+ h.settle(T);+ h+}++fn rect(h: &Headless, id: &str) -> egui::Rect {+ h.app.widgets.iter().find(|(w, _)| w == id).map(|(_, r)| *r).unwrap_or_else(|| panic!("no widget {id}"))+}++fn has(h: &Headless, id: &str) -> bool {+ h.app.widgets.iter().any(|(w, _)| w == id)+}++fn click(h: &mut Headless, id: &str) {+ let r = h.request("ui.clickWidget", json!({"id": id}), T);+ assert_eq!(r["ok"], true, "{id}: {r}");+ h.settle(T);+}++fn drag(h: &mut Headless, id: &str, dx: f32, dy: f32) {+ let r = h.request("ui.dragWidget", json!({"id": id, "dx": dx, "dy": dy, "steps": 8}), T);+ assert_eq!(r["ok"], true, "{id}: {r}");+ h.settle(T);+}++fn cmd(h: &mut Headless, id: &str, params: Value) -> Value {+ let r = h.request("engine.execute", json!({"command": id, "params": params}), T);+ assert_eq!(r["ok"], true, "{id}: {r}");+ h.settle(T);+ r["result"].clone()+}++/// The first page's MediaBox width and height in points.+fn media_box(pdf: &[u8]) -> (f64, f64) {+ let text = String::from_utf8_lossy(pdf);+ let at = text.find("/MediaBox [").expect("a MediaBox") + "/MediaBox [".len();+ let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();+ (nums[2], nums[3])+}++fn open_print(h: &mut Headless) {+ cmd(h, "dialog.print", json!({}));+ assert!(matches!(h.app.ui.dialog, Some(Dialog::Print)));+ assert!(has(h, "print:page"), "the page is on screen");+}++/// Screen points per inch of the page shown.+fn scale(h: &Headless) -> f32 {+ rect(h, "print:page").width() / h.app.session.print.layout.page_size().unwrap().0 as f32+}++fn cell_rect(h: &Headless, id: u32) -> lightcraft_engine::print::layout::Rect {+ h.app.session.print.layout.cell(id).unwrap().rect+}++#[test]+fn the_print_dialog_opens_from_the_menu_command_and_closes() {+ let mut h = demo(Services::default());+ open_print(&mut h);+ assert!(has(&h, "button:printStyle-0") && has(&h, "check:printZoomFill") && has(&h, "button:dialogOk"));+ assert!(rect(&h, "print:pageLabel").width() > 0.0);+ click(&mut h, "button:dialogCancel");+ assert!(h.app.ui.dialog.is_none());+}++#[test]+fn style_buttons_and_checkboxes_run_print_set() {+ let mut h = demo(Services::default());+ open_print(&mut h);+ click(&mut h, "button:printStyle-1");+ assert_eq!(h.app.session.print.layout.style, lightcraft_engine::print::layout::Style::ContactSheet);+ assert!(has(&h, "drag:printColumns") && has(&h, "print:gridcell:0"));+ click(&mut h, "check:printZoomFill");+ click(&mut h, "check:printStroke");+ assert!(h.app.session.print.image.zoom_to_fill && h.app.session.print.image.stroke_enabled);+ click(&mut h, "button:printOrientation-1");+ assert_eq!(h.app.session.print.layout.page.orientation, lightcraft_engine::print::layout::Orientation::Landscape);+ let p = rect(&h, "print:page");+ assert!(p.width() > p.height(), "the page is drawn landscape");+ click(&mut h, "button:printUnits-2");+ assert_eq!(h.app.session.print.guides.units, lightcraft_engine::print::layout::Unit::Millimeters);+ click(&mut h, "check:printShowGrid");+ assert!(h.app.session.print.guides.show_page_grid);+}++#[test]+fn cells_are_added_dragged_resized_and_arranged() {+ let mut h = demo(Services::default());+ open_print(&mut h);+ click(&mut h, "button:printStyle-3");+ // snapping off, so the pointer maths is exact+ cmd(&mut h, "print.set", json!({"guides": {"snap": "off"}}));+ click(&mut h, "button:printAddCell-4");+ click(&mut h, "button:printAddCell-1");+ let cells: Vec<u32> = h.app.session.print.layout.cells.iter().map(|c| c.id).collect();+ assert_eq!(cells.len(), 2);+ assert_eq!(h.app.session.print.layout.cells[0].rect.w, 4.0);+ assert!(has(&h, &format!("print:cell:{}", cells[0])));++ // drag the first cell with the pointer: the move is in inches, through print.cell.move+ let before = cell_rect(&h, cells[0]);+ let s = scale(&h);+ drag(&mut h, &format!("print:cell:{}", cells[0]), 0.0, 100.0);+ let after = cell_rect(&h, cells[0]);+ assert!((after.y - before.y - f64::from(100.0 / s)).abs() < 0.05, "moved {} in, expected {}", after.y - before.y, 100.0 / s);+ assert!((after.x - before.x).abs() < 0.05);+ assert_eq!(h.app.ui.print.selected, Some(cells[0]));++ // resize with its corner handle+ let r0 = cell_rect(&h, cells[0]);+ drag(&mut h, &format!("print:resize:{}", cells[0]), 30.0, 20.0);+ let r1 = cell_rect(&h, cells[0]);+ assert!((r1.w - r0.w - f64::from(30.0 / s)).abs() < 0.05 && (r1.h - r0.h - f64::from(20.0 / s)).abs() < 0.05, "{r0:?} → {r1:?}");+ assert_eq!((r1.x, r1.y), (r0.x, r0.y), "the top-left corner stays");++ // arrange: Front moves it last+ click(&mut h, "button:printStack-3");+ assert_eq!(h.app.session.print.layout.cells.last().unwrap().id, cells[0]);+ click(&mut h, "button:printStack-0");+ assert_eq!(h.app.session.print.layout.cells.first().unwrap().id, cells[0]);++ // the inspector's delete+ click(&mut h, "button:printCellDelete");+ assert_eq!(h.app.session.print.layout.cells.len(), 1);+ assert_eq!(h.app.ui.print.selected, None);+}++#[test]+fn dragging_a_cell_snaps_to_its_neighbour_when_snap_is_on() {+ let mut h = demo(Services::default());+ open_print(&mut h);+ click(&mut h, "button:printStyle-3");+ cmd(&mut h, "print.set", json!({"layout": {"spacing": 0.0}}));+ click(&mut h, "button:printAddCell-0");+ click(&mut h, "button:printAddCell-0");+ let ids: Vec<u32> = h.app.session.print.layout.cells.iter().map(|c| c.id).collect();+ assert_eq!(h.app.session.print.guides.snap, lightcraft_engine::print::layout::Snap::Cells);+ let a = cell_rect(&h, ids[0]);+ // park the second cell away from the first, then drag it back to 0.06 in from the first's right edge+ cmd(&mut h, "print.cell.move", json!({"id": ids[1], "x": a.right() + 0.8, "y": a.y}));+ let s = scale(&h);+ drag(&mut h, &format!("print:cell:{}", ids[1]), -(0.74 * s), 0.0);+ let r = cell_rect(&h, ids[1]);+ assert!((r.x - a.right()).abs() < 1e-6, "snapped to the neighbour's edge: {} vs {}", r.x, a.right());+ // with snapping off the same drag lands where the pointer put it+ cmd(&mut h, "print.set", json!({"guides": {"snap": "off"}}));+ cmd(&mut h, "print.cell.move", json!({"id": ids[1], "x": a.right() + 0.8, "y": a.y}));+ drag(&mut h, &format!("print:cell:{}", ids[1]), -(0.74 * s), 0.0);+ let r = cell_rect(&h, ids[1]);+ assert!((r.x - (a.right() + 0.06)).abs() < 0.05 && r.x > a.right() + 0.01, "unsnapped: {}", r.x - a.right());+}++#[test]+fn auto_layout_new_page_and_clear_buttons() {+ let mut h = demo(Services::default());+ open_print(&mut h);+ click(&mut h, "button:printStyle-2");+ for _ in 0..3 {+ click(&mut h, "button:printAddCell-4");+ }+ for _ in 0..3 {+ click(&mut h, "button:printAddCell-5");+ }+ let before_pages = h.app.session.print.layout.pages;+ // scramble everything onto one spot, then pack+ cmd(&mut h, "print.layout.autoLayout", json!({}));+ click(&mut h, "button:printAutoLayout");+ assert!(!h.app.session.print.layout.has_overlaps());+ assert!(h.app.session.print.layout.pages >= before_pages.min(2));+ let pages = h.app.session.print.layout.pages;+ click(&mut h, "button:printNewPage");+ assert_eq!(h.app.session.print.layout.pages, pages + 1);+ assert_eq!(h.app.ui.print.page as u32, pages, "the new page is shown");+ // the next-page button stays on the last page+ click(&mut h, "button:printPageNext");+ assert_eq!(h.app.ui.print.page as u32, pages);+ click(&mut h, "button:printPagePrev");+ assert_eq!(h.app.ui.print.page as u32, pages - 1);+ click(&mut h, "button:printClear");+ assert_eq!((h.app.session.print.layout.cells.len(), h.app.session.print.layout.pages), (0, 1));+ assert_eq!(h.app.ui.print.page, 0);+}++#[test]+fn templates_save_apply_and_delete_from_the_dialog() {+ let mut h = demo(Services::default());+ open_print(&mut h);+ click(&mut h, "button:printStyle-1");+ cmd(&mut h, "print.set", json!({"layout": {"grid": {"columns": 5, "rows": 6}}}));+ h.app.ui.print.template_name = "Sheet 5x6".into();+ click(&mut h, "button:printSaveTemplate");+ assert_eq!(h.app.session.print_templates.len(), 1);+ cmd(&mut h, "print.reset", json!({}));+ assert!(has(&h, "button:printTemplateApply-0"));+ click(&mut h, "button:printTemplateApply-0");+ assert_eq!(h.app.session.print.layout.grid.columns, 5);+ click(&mut h, "button:printTemplateDelete-0");+ assert!(h.app.session.print_templates.is_empty());+}++#[test]+fn print_to_pdf_picks_a_file_and_runs_in_the_background() {+ let asked = Arc::new(Mutex::new(Vec::<crate::pick::PickRequest>::new()));+ let requests = asked.clone();+ let bytes = Arc::new(Mutex::new(Vec::new()));+ let written = bytes.clone();+ let services = Services {+ picker: Some(Box::new(move |req| {+ requests.lock().unwrap().push(req);+ let (tx, rx) = std::sync::mpsc::channel();+ tx.send(vec!["Print.pdf".into()]).unwrap();+ Ok(rx)+ })),+ write_shared: Some(Arc::new(move |path, data| {+ assert_eq!(path, "Print.pdf");+ *written.lock().unwrap() = data.to_vec();+ Ok(())+ })),+ ..Default::default()+ };+ let mut h = demo(services);+ open_print(&mut h);+ cmd(&mut h, "print.set", json!({"layout": {"page": {"paper": "5x7", "orientation": "landscape"}}, "job": {"ppi": 100.0}}));+ click(&mut h, "button:dialogOk");+ assert!(h.app.ui.dialog.is_none(), "the dialog closes once the print has started");+ assert!(h.step_until(Duration::from_secs(60), |h| h.app.last_export_result.is_some()), "the print did not finish");+ let req = asked.lock().unwrap();+ assert_eq!(req[0].file_name.as_deref(), Some("Print.pdf"));+ let b = bytes.lock().unwrap();+ assert!(b.starts_with(b"%PDF-"));+ let (pw, ph) = media_box(&b);+ assert!((pw - 504.0).abs() < 1.0 && (ph - 360.0).abs() < 1.0, "7 x 5 in, got {pw} x {ph} pt");+ assert_eq!(h.app.last_export_result.as_ref().unwrap()["files"][0]["print"], true);+}++#[test]+fn printing_shows_a_row_in_the_activity_stack_and_stops() {+ let mut app = LightcraftApp::new(+ lightcraft_engine::Session::with_demo(),+ Services { write_shared: Some(Arc::new(|_, _| panic!("a stopped print wrote a file"))), ..Default::default() },+ );+ app.session.execute("print.set", &json!({"layout": {"style": "contactSheet"}, "job": {"ppi": 300.0}})).unwrap();+ let ids: Vec<_> = app.session.catalog.photos().take(12).map(|p| p.id.0).collect();+ crate::export_task::start_print(&mut app, &json!({"path": "Stop.pdf", "ids": ids})).unwrap();+ let rows = app.session.activity.list();+ assert_eq!(rows.len(), 1, "{rows:?}");+ assert_eq!((rows[0].kind, rows[0].label.as_str()), ("export", "Printing to PDF"));+ assert!(rows[0].cancellable);+ app.session.activity.cancel(rows[0].id).unwrap();+ let task = app.export.take().unwrap();+ assert!(task.cancel.load(std::sync::atomic::Ordering::Relaxed));+ drop(task);+ assert!(app.session.activity.list().is_empty(), "the row goes with the print");+}++#[test]+fn the_print_menu_item_needs_a_photo_and_is_listed() {+ let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), Services::default());+ assert!(crate::menus::ui_enabled(&app, "dialog.print"));+ let empty = LightcraftApp::new(lightcraft_engine::Session::new(), Services::default());+ assert!(!crate::menus::ui_enabled(&empty, "dialog.print"));+}++#[test]+fn the_print_dialog_fits_the_window_with_its_buttons_on_screen() {+ for size in [[1400.0, 900.0], [1100.0, 760.0]] {+ for style in ["singleImage", "customPackage"] {+ let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), Services::default());+ let mut h = Headless::new(app, size, 1.0);+ h.settle(T);+ cmd(&mut h, "print.set", json!({"layout": {"style": style}}));+ if style == "customPackage" {+ cmd(&mut h, "print.cell.add", json!({"width": 4, "height": 6}));+ }+ open_print(&mut h);+ let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, h.size);+ let dialog = rect(&h, "dialog:window");+ assert!(screen.contains_rect(dialog), "{style} at {size:?}: dialog {dialog:?} runs off the window");+ for b in ["button:dialogOk", "button:dialogCancel"] {+ assert!(dialog.contains_rect(rect(&h, b)), "{style} at {size:?}: {b} is outside the dialog");+ }+ }+ }+}diff --git a/docs/gaps.md b/docs/gaps.mdindex 72649a5bc..f24cbf5bc 100644--- a/docs/gaps.md+++ b/docs/gaps.md@@ -29,7 +29,7 @@ Hours are Opus 5.5 agent wall-clock hours (see [target-app-parity.md](target-app| 12 | **Content-aware / generative remove, detect distractions, reflections removal** | REM rows 75%; patch synthesis missing | cleanup work goes back to Photoshop | 25–45 (+ generative model) | [target-app-parity](target-app-parity.md#ai) || 13 | **Lightroom catalog migration is one-way and approximate**: unsupported Adobe profiles / AI settings archived, history kept as data | lightroom-catalog-import.md | switching users lose some looks | 8–12 | [file-format-parity](file-format-parity.md) || 14 | **HDR display** (EDR / Windows HDR); HLG; the headroom limit and SDR rendition from `crs` XMP (the HDR switch, `HDREditMode`, is read) | HDR rows 70%; LR-VIEW-HDR-DISPLAY ⬜ | HDR editing works blind on HDR monitors | 12–25 | [hardware-parity](hardware-parity.md) |-| 15 | **Print module**: no Print view (layouts, cells, image settings and templates exist as `print.*` commands only), printer colour management, identity plate / watermark / page numbers / crop marks / photo info, Custom Package Auto Layout | LRC-PRINT rows | Classic users who print | 25–40 | [target-app-parity](target-app-parity.md#features) |+| 15 | **Print module**: printer colour management (profile, rendering intent, black point compensation, print adjustment and sharpening), identity plate / watermark / page numbers / crop marks / photo info overlays, Custom Package Auto Layout, printer-driver Page Setup and direct printing (the Print dialog writes a PDF) | LRC-PRINT rows | Classic users who print | 25–40 | [target-app-parity](target-app-parity.md#features) || 16 | **Map view, Book, Slideshow module, publish services** | LRC-MAP / BOOK / SS rows ⬜ | Classic users; publish services matter for Flickr / SmugMug workflows | 60–100 | [target-app-parity](target-app-parity.md#features) || 17 | **Tethered capture** | ⬜ | studio photographers | 25–45 + cameras | [hardware-parity](hardware-parity.md) || 18 | **Video**: playback, trim, global edits, export | VID rows 0% | users who mix stills and clips | 25–45 | [target-app-parity](target-app-parity.md#features) |@@ -72,6 +72,7 @@ Beta-blocking gaps (B) total **~230–430 h**; with the stability and platform w| Date | Change | Summary ||---|---|---|+| 2026-10-12 | minor | Gap 15 shrinks: File → Print… is a Print dialog with the four layout styles, cell editing, image settings, guides, page setup and templates; printer colour management, page overlays and direct printing remain || 2026-10-12 | minor | Gap 15: the Print module's layout styles, cells, image settings, templates and PDF are `print.*` commands (CLI, control, MCP); the Print view, printer colour management and page overlays remain || 2026-10-12 | minor | Gap 15: print pages compose in the engine (fit / Zoom to Fill, Rotate to Fit, border, stroke, background) with an interim PDF writer; commands and UI still to land || 2026-10-12 | minor | Gap 15: the Print layout model (paper sizes, margins, grid, package cells, Auto Layout packer, snapping) is in the engine; commands, composition and UI still to land |diff --git a/docs/parity-checklist.md b/docs/parity-checklist.mdindex 75dc988ae..4edb4eff5 100644--- a/docs/parity-checklist.md+++ b/docs/parity-checklist.md@@ -1,6 +1,6 @@# Lightroom parity checklist-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-CELLS, LRC-PRINT-TEMPLATES and the other print rows: `print.*` commands; LRC-PRINT-IMAGESETTINGS: print page composition (fit / Zoom to Fill, Rotate to Fit, border, stroke, background); LRC-PRINT-LAYOUT: print layout model; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (LRC-PRINT-GUIDES and the other print rows: the Print dialog (File → Print…); LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-CELLS, LRC-PRINT-TEMPLATES and the other print rows: `print.*` commands; LRC-PRINT-IMAGESETTINGS: print page composition (fit / Zoom to Fill, Rotate to Fit, border, stroke, background); LRC-PRINT-LAYOUT: print layout model; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what wehave and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good@@ -52,10 +52,10 @@ cited here still exists. Formerly docs/parity.md.| X. Cross-cutting behaviours (BEHAV) | 23 | 6 | 1 | 1 | 8/8 (100%) | 7/10 (70%) || Y. Menus | 84 | 0 | 4 | 8 | 47/47 (100%) | 23/23 (100%) || Z. Keyboard shortcuts (desktop) | 76 | 3 | 3 | 1 | 49/52 (94%) | 23/24 (96%) |-| Lightroom Classic extras | 34 | 19 | 32 | 8 | — | 24/26 (92%) |-| **Total** | 408 | 54 | 69 | 35 | 193/201 (96%) | 145/157 (92%) |+| Lightroom Classic extras | 38 | 16 | 31 | 8 | — | 24/26 (92%) |+| **Total** | 412 | 51 | 68 | 35 | 193/201 (96%) | 145/157 (92%) |-Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.9%** of 531 in-scope rows — P0 98.0% of 201 · P1 95.2% of 157 · P2 50.9% of 172.+Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **82.4%** of 531 in-scope rows — P0 98.0% of 201 · P1 95.2% of 157 · P2 52.3% of 172.<!-- /parity:summary -->## Top gaps and shortcut notes@@ -747,14 +747,14 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-| LRC-SS-MUSIC | Slideshow music | P2 | ⬜ | | || LRC-SS-PLAYBACK | Slideshow playback | P2 | ⬜ | | || LRC-SS-EXPORT | Slideshow export | P2 | ⬜ | | |-| LRC-PRINT-LAYOUTSTYLE | Print layout styles | P2 | 🟡 | `cmd:print.set`, `cmd:print.get`, `cmd:print.exportPdf`, `cmd:export.contactSheet`, `crates/engine/src/print/layout.rs` | Single Image, Contact Sheet, Picture Package and Custom Package are print layout styles reachable from commands, the CLI, control channel and MCP; no Print module UI yet (File → Contact Sheet PDF still the only dialog) |-| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | 🟡 | `cmd:print.set`, `crates/engine/src/print/compose.rs` | Zoom to Fill, Rotate to Fit, Photo Border (package styles), Inner Stroke (width in points, colour) through `print.set {image}`; pixel-tested; no panel yet |-| LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:print.set`, `cmd:print.layout.autoLayout`, `cmd:print.layout.newPage`, `cmd:print.layout.clear`, `cmd:export.contactSheet`, `crates/engine/src/print/layout.rs` | A3/A4/A5/Letter/Legal/Tabloid/4x6/5x7/8x10/13x19 and custom paper, portrait/landscape, per-side margins, grid with column/row spacing and square cells, 72–720 ppi; commands only, no panel yet |-| LRC-PRINT-GUIDES | Print guides | P2 | ⬜ | `cmd:print.set` | guide options (ruler units in/cm/mm/pt, snap off/cells/grid, grid size, show margins/bleed/page grid/cells/dimensions) are stored and used by snapping in `print.cell.move`/`resize`; nothing is drawn until the Print UI lands |-| LRC-PRINT-CELLS | Picture-package cells | P2 | 🟡 | `cmd:print.cell.add`, `cmd:print.cell.move`, `cmd:print.cell.resize`, `cmd:print.cell.delete`, `cmd:print.cell.stack`, `cmd:print.cell.photo`, `cmd:print.cell.page`, `cmd:print.layout.autoLayout` | add/move/resize/delete cells of any size, stacking order, per-cell photos (Custom Package), deterministic Auto Layout packer, snapping to cells or grid; no UI (drag placement) yet |-| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:print.set`, `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs` | page background colour and margins through `print.set`; optional filename captions in the contact-sheet PDF; no identity plates, watermarks, page numbers or crop marks |+| LRC-PRINT-LAYOUTSTYLE | Print layout styles | P2 | ✅ | `cmd:dialog.print`, `cmd:print.set`, `cmd:print.get`, `cmd:print.exportPdf`, `cmd:export.contactSheet`, `crates/ui-egui/src/print_view.rs` | File → Print… (⌘P): Single Image, Contact Sheet, Picture Package and Custom Package, one page preview each; also `print.*` commands for the CLI, control channel and MCP; the older File → Contact Sheet PDF stays |+| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | ✅ | `cmd:print.set`, `crates/engine/src/print/compose.rs`, `crates/ui-egui/src/print_view.rs` | Zoom to Fill Frame, Rotate to Fit, Photo Border (width, colour; package styles) and Inner Stroke (width in points, colour) in the dialog, drawn in the preview and in the PDF; pixel-tested |+| LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:print.set`, `cmd:print.layout.autoLayout`, `cmd:print.layout.newPage`, `cmd:print.layout.clear`, `cmd:app.print`, `cmd:export.contactSheet`, `crates/engine/src/print/layout.rs` | A3/A4/A5/Letter/Legal/Tabloid/4x6/5x7/8x10/13x19 and custom paper, portrait/landscape, per-side margins, grid with column/row spacing and square cells, 72–720 ppi, in a Print dialog with a scaled page preview; no printer-driver Page Setup, no cell size / alignment presets |+| LRC-PRINT-GUIDES | Print guides | P2 | ✅ | `cmd:print.set`, `cmd:print.cell.move`, `crates/ui-egui/src/print_view.rs` | rulers in in/cm/mm/pt, snap off/cells/grid with a grid size, and Page Margins / Page Bleed (a fixed 0.125 in outline) / Page Grid / Image Cells / Dimensions guides drawn on the preview |+| LRC-PRINT-CELLS | Picture-package cells | P2 | ✅ | `cmd:print.cell.add`, `cmd:print.cell.move`, `cmd:print.cell.resize`, `cmd:print.cell.delete`, `cmd:print.cell.stack`, `cmd:print.cell.photo`, `cmd:print.cell.page`, `cmd:print.layout.autoLayout`, `crates/ui-egui/src/print_view.rs` | add cells at standard or custom sizes, drag and resize them on the page preview (snap to cells, grid or off), Send to Back / Backward / Forward / Bring to Front, a photo per cell (Custom Package), Auto Layout packing, New Page, Clear Layout; no Auto Layout for Custom Package |+| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:print.set`, `cmd:export.contactSheet`, `crates/engine/src/print/compose.rs`, `crates/ui-egui/src/print_view.rs` | page background colour and margins in the Print dialog; filename captions in the contact-sheet PDF; no identity plate, watermark, page numbers, crop marks or photo info || LRC-PRINT-JOB | Print job & colour management | P2 | 🟡 | `cmd:export.contactSheet`, `cmd:app.contactSheet`, `crates/ui-egui/src/export_task.rs` | PDF export at fixed 150 dpi in sRGB, current edits, background progress/cancel and original protection; no native printer integration, ICC soft proof/print profiles or selectable resolution |-| LRC-PRINT-TEMPLATES | Print templates | P2 | 🟡 | `cmd:print.template.save`, `cmd:print.template.apply`, `cmd:print.template.list`, `cmd:print.template.delete` | named templates of layout, image settings, page and job saved with the library (prefs.json); no built-in templates, no UI, no template import/export |+| LRC-PRINT-TEMPLATES | Print templates | P2 | 🟡 | `cmd:print.template.save`, `cmd:print.template.apply`, `cmd:print.template.list`, `cmd:print.template.delete`, `crates/ui-egui/src/print_view.rs` | save, apply and delete named templates (layout, image settings, page, job) at the top of the Print dialog, kept with the library; no built-in templates, no folders, no import / export of template files || LRC-WEB-LAYOUT | Web gallery layouts | OOS | 🚫 | | || LRC-WEB-SITEINFO | Web gallery site info | OOS | 🚫 | | || LRC-WEB-COLOR | Web gallery colours | OOS | 🚫 | | |@@ -787,6 +787,7 @@ Latin stays upright. Advanced Japanese composition remains open. Regression cove| Date | Change | Summary ||---|---|---|+| 2026-10-12 | minor | LRC-PRINT-GUIDES, LRC-PRINT-CELLS, LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-IMAGESETTINGS (✅), LRC-PRINT-LAYOUT, LRC-PRINT-PAGE, LRC-PRINT-TEMPLATES (🟡): File → Print… opens the Print dialog with a scaled page preview, rulers and guides, cells dragged and resized with snapping, image settings, page setup and templates, and prints to PDF in the background || 2026-10-12 | minor | LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-IMAGESETTINGS, LRC-PRINT-LAYOUT, LRC-PRINT-CELLS, LRC-PRINT-PAGE, LRC-PRINT-TEMPLATES: the Print module is reachable as 18 `print.*` commands (settings, cells, Auto Layout, PDF, templates saved in prefs.json) from the CLI, control channel and MCP; 🟡 until the Print UI lands, LRC-PRINT-GUIDES stays ⬜ || 2026-10-12 | minor | LRC-PRINT-IMAGESETTINGS: `print/compose.rs` composes pages (Zoom to Fill, Rotate to Fit, Photo Border, Inner Stroke, background) from the layout model into 16-bit Rec. 2020 `PageRaster`s, with an interim sRGB PDF writer in `print/output.rs`; rows stay until commands and UI reach them || 2026-10-12 | minor | LRC-PRINT-LAYOUT: the Print layout model (paper, margins, grid, package cells, Auto Layout packer, snapping) lands in `print/layout.rs`; no row changes status until commands and UI follow |