Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

LRC-PRINT-LAYOUT: the print layout model (paper, margins, grid, package cells, packer, snapping)

Atmik Shetty4f1ed6df6526
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 3bc6c431e..21fc30e46 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -56,6 +56,7 @@ pub mod originals;
pub mod preset_import;
pub mod preset_luminar;
pub mod presets;
+pub mod print;
pub mod proof;
pub mod rename;
pub mod segment;
diff --git a/crates/engine/src/print/layout.rs b/crates/engine/src/print/layout.rs
new file mode 100644
index 000000000..8a9e1a027
--- /dev/null
+++ b/crates/engine/src/print/layout.rs
@@ -0,0 +1,1300 @@
+//! The Print module's page layout model: paper, margins, layout styles and cells.
+//!
+//! Pure data and geometry, no rendering. Every length is in **inches** in page space: the origin
+//! is the top-left corner of the page *as printed* (after orientation), x grows right and y down.
+//! Rulers show other units ([`Unit`]) but convert at the edge; the model never stores them.
+//!
+//! Four layout styles ([`Style`]):
+//! * `singleImage`: one photo fills the printable area of each page;
+//! * `contactSheet`: a grid of identical cells ([`GridSpec`]), the photos paginated over pages;
+//! * `picturePackage`: one photo at several cell sizes, packed onto pages by [`Layout::auto_layout`];
+//! * `customPackage`: free placement of cells (overlap allowed, [`Stack`] order), each with its own photo.
+//!
+//! Package cells live in [`Layout::cells`] in stacking order (later = on top). Everything that
+//! arrives from outside (commands, saved templates) passes through [`Layout::validate`]; all
+//! setters reject NaN, infinite, negative and oversized numbers instead of storing them.
+use serde::{Deserialize, Serialize};
+
+/// Largest page edge accepted, inches.
+pub const MAX_PAGE_IN: f64 = 60.0;
+/// Smallest page edge accepted, inches.
+pub const MIN_PAGE_IN: f64 = 1.0;
+/// Smallest cell edge accepted, inches.
+pub const MIN_CELL_IN: f64 = 0.1;
+/// Package layouts hold at most this many cells.
+pub const MAX_CELLS: usize = 200;
+/// Package layouts span at most this many pages.
+pub const MAX_PAGES: u32 = 50;
+/// Largest margin accepted, inches.
+pub const MAX_MARGIN_IN: f64 = 10.0;
+/// The printable area must stay at least this wide and tall, inches.
+pub const MIN_PRINTABLE_IN: f64 = 0.5;
+/// Largest grid dimension of a contact sheet.
+pub const MAX_GRID: usize = 20;
+/// Geometry tolerance, inches (far below one printed pixel at any supported resolution).
+pub const EPS: f64 = 1e-6;
+
+/// Paper sizes by name: portrait width and height in millimetres (ISO) or inches (US/photo).
+const PAPER: &[(&str, f64, f64)] = &[
+ ("a3", 297.0 / 25.4, 420.0 / 25.4),
+ ("a4", 210.0 / 25.4, 297.0 / 25.4),
+ ("a5", 148.0 / 25.4, 210.0 / 25.4),
+ ("letter", 8.5, 11.0),
+ ("legal", 8.5, 14.0),
+ ("tabloid", 11.0, 17.0),
+ ("4x6", 4.0, 6.0),
+ ("5x7", 5.0, 7.0),
+ ("8x10", 8.0, 10.0),
+ ("13x19", 13.0, 19.0),
+];
+
+/// Names accepted by [`PageSetup::paper`] (besides `custom`).
+pub fn paper_names() -> impl Iterator<Item = &'static str> {
+ PAPER.iter().map(|p| p.0)
+}
+
+/// Portrait size in inches of a named paper (case-insensitive), `None` for unknown names and `custom`.
+pub fn paper_size(name: &str) -> Option<(f64, f64)> {
+ let name = name.to_ascii_lowercase();
+ PAPER.iter().find(|p| p.0 == name).map(|p| (p.1, p.2))
+}
+
+/// An axis-aligned rectangle in inches.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Rect {
+ pub x: f64,
+ pub y: f64,
+ pub w: f64,
+ pub h: f64,
+}
+
+impl Rect {
+ pub const fn new(x: f64, y: f64, w: f64, h: f64) -> Self {
+ Self { x, y, w, h }
+ }
+ pub fn right(&self) -> f64 {
+ self.x + self.w
+ }
+ pub fn bottom(&self) -> f64 {
+ self.y + self.h
+ }
+ pub fn area(&self) -> f64 {
+ self.w * self.h
+ }
+ pub fn is_finite(&self) -> bool {
+ self.x.is_finite() && self.y.is_finite() && self.w.is_finite() && self.h.is_finite()
+ }
+ /// Whether the interiors overlap by more than [`EPS`] on both axes (touching edges do not count).
+ pub fn overlaps(&self, o: &Rect) -> bool {
+ self.x < o.right() - EPS && o.x < self.right() - EPS && self.y < o.bottom() - EPS && o.y < self.bottom() - EPS
+ }
+ /// Whether `o` lies entirely inside `self`, within [`EPS`].
+ pub fn contains(&self, o: &Rect) -> bool {
+ o.x >= self.x - EPS && o.y >= self.y - EPS && o.right() <= self.right() + EPS && o.bottom() <= self.bottom() + EPS
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Orientation {
+ #[default]
+ Portrait,
+ Landscape,
+}
+
+/// Ruler and dimension units.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Unit {
+ #[default]
+ #[serde(rename = "in")]
+ Inches,
+ #[serde(rename = "cm")]
+ Centimeters,
+ #[serde(rename = "mm")]
+ Millimeters,
+ #[serde(rename = "pt")]
+ Points,
+}
+
+impl Unit {
+ pub fn per_inch(self) -> f64 {
+ match self {
+ Unit::Inches => 1.0,
+ Unit::Centimeters => 2.54,
+ Unit::Millimeters => 25.4,
+ Unit::Points => 72.0,
+ }
+ }
+ pub fn from_inches(self, inches: f64) -> f64 {
+ inches * self.per_inch()
+ }
+ pub fn to_inches(self, value: f64) -> f64 {
+ value / self.per_inch()
+ }
+ pub fn label(self) -> &'static str {
+ match self {
+ Unit::Inches => "in",
+ Unit::Centimeters => "cm",
+ Unit::Millimeters => "mm",
+ Unit::Points => "pt",
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Margins {
+ pub top: f64,
+ pub right: f64,
+ pub bottom: f64,
+ pub left: f64,
+}
+
+impl Default for Margins {
+ fn default() -> Self {
+ Self::uniform(0.25)
+ }
+}
+
+impl Margins {
+ pub const fn uniform(v: f64) -> Self {
+ Self { top: v, right: v, bottom: v, left: v }
+ }
+}
+
+/// Paper, orientation and margins (Lightroom's Page Setup + the Page margins).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
+pub struct PageSetup {
+ /// A name from [`paper_names`] or `custom`.
+ pub paper: String,
+ /// Portrait size of a `custom` paper, inches.
+ pub custom_width: f64,
+ pub custom_height: f64,
+ pub orientation: Orientation,
+ pub margins: Margins,
+}
+
+impl Default for PageSetup {
+ fn default() -> Self {
+ Self { paper: "letter".into(), custom_width: 8.5, custom_height: 11.0, orientation: Orientation::Portrait, margins: Margins::default() }
+ }
+}
+
+fn check(v: f64, what: &str, min: f64, max: f64) -> Result<f64, String> {
+ if v.is_finite() && v >= min && v <= max { Ok(v) } else { Err(format!("{what} must be a number from {min} to {max}")) }
+}
+
+impl PageSetup {
+ /// Page width and height in inches after orientation.
+ pub fn size(&self) -> Result<(f64, f64), String> {
+ let (w, h) = if self.paper.eq_ignore_ascii_case("custom") {
+ (
+ check(self.custom_width, "custom width", MIN_PAGE_IN, MAX_PAGE_IN)?,
+ check(self.custom_height, "custom height", MIN_PAGE_IN, MAX_PAGE_IN)?,
+ )
+ } else {
+ paper_size(&self.paper)
+ .ok_or_else(|| format!("unknown paper `{}` (one of {} or custom)", self.paper, paper_names().collect::<Vec<_>>().join(", ")))?
+ };
+ Ok(match self.orientation {
+ Orientation::Portrait => (w, h),
+ Orientation::Landscape => (h, w),
+ })
+ }
+
+ /// The area inside the margins.
+ pub fn printable(&self) -> Result<Rect, String> {
+ let (w, h) = self.size()?;
+ let m = &self.margins;
+ let (t, r, b, l) = (
+ check(m.top, "top margin", 0.0, MAX_MARGIN_IN)?,
+ check(m.right, "right margin", 0.0, MAX_MARGIN_IN)?,
+ check(m.bottom, "bottom margin", 0.0, MAX_MARGIN_IN)?,
+ check(m.left, "left margin", 0.0, MAX_MARGIN_IN)?,
+ );
+ let (pw, ph) = (w - l - r, h - t - b);
+ if pw < MIN_PRINTABLE_IN || ph < MIN_PRINTABLE_IN {
+ return Err(format!("margins leave less than {MIN_PRINTABLE_IN} in of printable area"));
+ }
+ Ok(Rect::new(l, t, pw, ph))
+ }
+
+ /// The page size in PDF points (1/72 in).
+ pub fn size_points(&self) -> Result<(f64, f64), String> {
+ let (w, h) = self.size()?;
+ Ok((w * 72.0, h * 72.0))
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Style {
+ #[default]
+ SingleImage,
+ ContactSheet,
+ PicturePackage,
+ CustomPackage,
+}
+
+impl Style {
+ /// Styles whose cells are listed in [`Layout::cells`].
+ pub fn is_package(self) -> bool {
+ matches!(self, Style::PicturePackage | Style::CustomPackage)
+ }
+}
+
+/// The contact-sheet grid. `singleImage` ignores it (one cell per page, no spacing).
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
+pub struct GridSpec {
+ pub columns: usize,
+ pub rows: usize,
+ /// Gap between columns / rows, inches.
+ pub spacing_x: f64,
+ pub spacing_y: f64,
+ /// Make the cells square (the grid is centred in the printable area).
+ pub keep_square: bool,
+}
+
+impl Default for GridSpec {
+ fn default() -> Self {
+ Self { columns: 3, rows: 4, spacing_x: 0.1, spacing_y: 0.1, keep_square: false }
+ }
+}
+
+/// One cell of a package layout.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
+pub struct Cell {
+ pub id: u32,
+ /// Zero-based page the cell is on.
+ pub page: u32,
+ pub rect: Rect,
+ /// The photo printed in the cell (Custom Package); `None` uses the job's first photo.
+ /// Not part of a saved template.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub photo: Option<u64>,
+}
+
+/// Where a cell goes in the stacking order of its page.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Stack {
+ ToBack,
+ Backward,
+ Forward,
+ ToFront,
+}
+
+/// How dragged cells snap.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Snap {
+ Off,
+ /// To the edges of the other cells and of the printable area.
+ #[default]
+ Cells,
+ /// To multiples of [`Guides::grid_size`] from the printable area's corner.
+ Grid,
+}
+
+/// Rulers, grid and guides (Lightroom's Guides panel).
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
+pub struct Guides {
+ pub show_rulers: bool,
+ pub units: Unit,
+ pub snap: Snap,
+ /// Grid pitch, inches.
+ pub grid_size: f64,
+ pub show_margins: bool,
+ pub show_bleed: bool,
+ pub show_page_grid: bool,
+ pub show_cells: bool,
+ pub show_dimensions: bool,
+}
+
+impl Default for Guides {
+ fn default() -> Self {
+ Self {
+ show_rulers: true,
+ units: Unit::Inches,
+ snap: Snap::Cells,
+ grid_size: 0.25,
+ show_margins: true,
+ show_bleed: false,
+ show_page_grid: false,
+ show_cells: true,
+ show_dimensions: false,
+ }
+ }
+}
+
+impl Guides {
+ pub fn validate(&self) -> Result<(), String> {
+ check(self.grid_size, "grid size", 0.05, 10.0).map(|_| ())
+ }
+}
+
+/// The page layout: setup, style and cells. See the module docs for the units and style rules.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]
+pub struct Layout {
+ pub style: Style,
+ pub page: PageSetup,
+ pub grid: GridSpec,
+ /// Gap kept between cells by [`Layout::auto_layout`] and new cells, inches.
+ pub spacing: f64,
+ /// Pages of a package layout (at least 1 and past every cell).
+ pub pages: u32,
+ /// Package cells in stacking order, back to front.
+ pub cells: Vec<Cell>,
+ next_id: u32,
+}
+
+impl Default for Layout {
+ fn default() -> Self {
+ Self {
+ style: Style::SingleImage,
+ page: PageSetup::default(),
+ grid: GridSpec::default(),
+ spacing: 0.1,
+ pages: 1,
+ cells: Vec::new(),
+ next_id: 1,
+ }
+ }
+}
+
+/// Free space on one page as a set of maximal rectangles (the MaxRects scheme).
+struct Free(Vec<Rect>);
+
+impl Free {
+ fn new(area: Rect) -> Self {
+ Self(vec![area])
+ }
+
+ /// Removes `used` from the free space.
+ fn occupy(&mut self, used: &Rect) {
+ let mut next = Vec::with_capacity(self.0.len() + 4);
+ for f in &self.0 {
+ if !f.overlaps(used) {
+ next.push(*f);
+ continue;
+ }
+ if used.x > f.x + EPS {
+ next.push(Rect::new(f.x, f.y, used.x - f.x, f.h));
+ }
+ if used.right() < f.right() - EPS {
+ next.push(Rect::new(used.right(), f.y, f.right() - used.right(), f.h));
+ }
+ if used.y > f.y + EPS {
+ next.push(Rect::new(f.x, f.y, f.w, used.y - f.y));
+ }
+ if used.bottom() < f.bottom() - EPS {
+ next.push(Rect::new(f.x, used.bottom(), f.w, f.bottom() - used.bottom()));
+ }
+ }
+ // Drop rectangles contained in another (the first of two equal ones survives).
+ let mut keep: Vec<Rect> = Vec::with_capacity(next.len());
+ for (i, r) in next.iter().enumerate() {
+ let dominated = next.iter().enumerate().any(|(j, o)| i != j && o.contains(r) && (!r.contains(o) || j < i));
+ if !dominated {
+ keep.push(*r);
+ }
+ }
+ self.0 = keep;
+ }
+
+ /// The best spot for a `w` x `h` block: least leftover on the short side, then the long side,
+ /// then top-most and left-most. The block is turned a quarter (when `rotate`) only if it fits
+ /// nowhere as given, so cells keep their shape whenever they can. Returns the spot and
+ /// whether the block was turned.
+ fn best_fit(&self, w: f64, h: f64, rotate: bool) -> Option<(Rect, bool)> {
+ self.fit_block(w, h)
+ .map(|r| (r, false))
+ .or_else(|| if rotate && (w - h).abs() >= EPS { self.fit_block(h, w).map(|r| (r, true)) } else { None })
+ }
+
+ fn fit_block(&self, bw: f64, bh: f64) -> Option<Rect> {
+ let mut best: Option<((f64, f64, f64, f64), Rect)> = None;
+ let eq = |a: f64, b: f64| (a - b).abs() < EPS;
+ for f in &self.0 {
+ if bw > f.w + EPS || bh > f.h + EPS {
+ continue;
+ }
+ let (dw, dh) = (f.w - bw, f.h - bh);
+ let key = (dw.min(dh), dw.max(dh), f.y, f.x);
+ let better = best.as_ref().is_none_or(|(k, _)| {
+ if !eq(k.0, key.0) {
+ return key.0 < k.0;
+ }
+ if !eq(k.1, key.1) {
+ return key.1 < k.1;
+ }
+ if !eq(k.2, key.2) {
+ return key.2 < k.2;
+ }
+ key.3 < k.3 - EPS
+ });
+ if better {
+ best = Some((key, Rect::new(f.x, f.y, bw, bh)));
+ }
+ }
+ best.map(|(_, r)| r)
+ }
+}
+
+/// Where each block of [`pack`] went: page index, rectangle in page space and whether it was turned.
+pub type Placement = (u32, Rect, bool);
+
+/// Packs blocks (width, height) onto pages of `area`, keeping `spacing` between them.
+///
+/// Deterministic: blocks are placed largest first (area, then longer side, then input order) with
+/// the MaxRects best-short-side-fit rule, filling earlier pages before opening a new one. Blocks
+/// may be turned a quarter when `rotate`. Fails when a block cannot fit an empty page or the
+/// result would need more than [`MAX_PAGES`] pages. The result is in input order.
+pub fn pack(sizes: &[(f64, f64)], area: Rect, spacing: f64, rotate: bool) -> Result<Vec<Placement>, String> {
+ if !area.is_finite() || area.w <= 0.0 || area.h <= 0.0 {
+ return Err("no printable area to pack into".into());
+ }
+ let spacing = check(spacing, "spacing", 0.0, MAX_PAGE_IN)?;
+ if sizes.len() > MAX_CELLS {
+ return Err(format!("at most {MAX_CELLS} cells"));
+ }
+ for (w, h) in sizes {
+ check(*w, "cell width", MIN_CELL_IN, MAX_PAGE_IN)?;
+ check(*h, "cell height", MIN_CELL_IN, MAX_PAGE_IN)?;
+ }
+ // Each block carries `spacing` on its right and bottom; the area grows by the same so a block
+ // flush with the margin still fits.
+ let padded = Rect::new(area.x, area.y, area.w + spacing, area.h + spacing);
+ let mut order: Vec<usize> = (0..sizes.len()).collect();
+ order.sort_by(|&a, &b| {
+ let (sa, sb) = (sizes.get(a).copied().unwrap_or_default(), sizes.get(b).copied().unwrap_or_default());
+ (sb.0 * sb.1).total_cmp(&(sa.0 * sa.1)).then((sb.0.max(sb.1)).total_cmp(&sa.0.max(sa.1))).then(a.cmp(&b))
+ });
+ let mut pages: Vec<Free> = Vec::new();
+ let mut out: Vec<Option<Placement>> = vec![None; sizes.len()];
+ for i in order {
+ let (w, h) = sizes.get(i).copied().unwrap_or_default();
+ let (bw, bh) = (w + spacing, h + spacing);
+ let mut placed = None;
+ for (p, free) in pages.iter().enumerate() {
+ if let Some(hit) = free.best_fit(bw, bh, rotate) {
+ placed = Some((p, hit));
+ break;
+ }
+ }
+ let (p, (spot, turned)) = match placed {
+ Some(v) => v,
+ None => {
+ if pages.len() as u32 >= MAX_PAGES {
+ return Err(format!("the cells need more than {MAX_PAGES} pages"));
+ }
+ let fresh = Free::new(padded);
+ let hit = fresh.best_fit(bw, bh, rotate).ok_or_else(|| format!("a {w:.2} x {h:.2} in cell does not fit the printable area"))?;
+ pages.push(fresh);
+ (pages.len() - 1, hit)
+ }
+ };
+ if let Some(free) = pages.get_mut(p) {
+ free.occupy(&spot);
+ }
+ let (cw, ch) = if turned { (h, w) } else { (w, h) };
+ if let Some(slot) = out.get_mut(i) {
+ *slot = Some((p as u32, Rect::new(spot.x, spot.y, cw, ch), turned));
+ }
+ }
+ out.into_iter().map(|p| p.ok_or_else(|| "internal packing error".to_string())).collect()
+}
+
+/// Snaps a span (`start`, `len`) along one axis so its start or end lands on the nearest candidate
+/// within `threshold`; unchanged when none is close.
+fn snap_span(start: f64, len: f64, candidates: &[f64], threshold: f64) -> f64 {
+ let mut best: Option<(f64, f64)> = None;
+ for &c in candidates {
+ for shift in [c - start, c - (start + len)] {
+ if shift.abs() <= threshold && best.is_none_or(|(d, _)| shift.abs() < d) {
+ best = Some((shift.abs(), shift));
+ }
+ }
+ }
+ start + best.map_or(0.0, |b| b.1)
+}
+
+/// Snaps one coordinate (a dragged edge) to the nearest candidate within `threshold`.
+fn snap_edge(v: f64, candidates: &[f64], threshold: f64) -> f64 {
+ candidates.iter().copied().filter(|c| (c - v).abs() <= threshold).min_by(|a, b| (a - v).abs().total_cmp(&(b - v).abs())).unwrap_or(v)
+}
+
+impl Layout {
+ /// Page size in inches after orientation.
+ pub fn page_size(&self) -> Result<(f64, f64), String> {
+ self.page.size()
+ }
+
+ /// The printable area (inside the margins).
+ pub fn printable(&self) -> Result<Rect, String> {
+ self.page.printable()
+ }
+
+ /// Checks every number and cross-reference; also repairs `next_id` so ids stay unique.
+ /// Run on anything that did not come from the setters (commands, templates).
+ pub fn validate(&mut self) -> Result<(), String> {
+ let area = self.page.printable()?;
+ check(self.spacing, "spacing", 0.0, 10.0)?;
+ if !(1..=MAX_GRID).contains(&self.grid.columns) || !(1..=MAX_GRID).contains(&self.grid.rows) {
+ return Err(format!("columns and rows must be 1 to {MAX_GRID}"));
+ }
+ check(self.grid.spacing_x, "column spacing", 0.0, 10.0)?;
+ check(self.grid.spacing_y, "row spacing", 0.0, 10.0)?;
+ for r in self.grid_rects_for(area)? {
+ if r.w < MIN_CELL_IN || r.h < MIN_CELL_IN {
+ return Err("the grid leaves cells smaller than 0.1 in".into());
+ }
+ }
+ if self.cells.len() > MAX_CELLS {
+ return Err(format!("at most {MAX_CELLS} cells"));
+ }
+ if !(1..=MAX_PAGES).contains(&self.pages) {
+ return Err(format!("pages must be 1 to {MAX_PAGES}"));
+ }
+ let mut seen = std::collections::BTreeSet::new();
+ for c in &self.cells {
+ if !seen.insert(c.id) {
+ return Err(format!("duplicate cell id {}", c.id));
+ }
+ if c.page >= self.pages {
+ return Err(format!("cell {} is on page {} but the layout has {} pages", c.id, c.page + 1, self.pages));
+ }
+ self.check_rect(&c.rect, area)?;
+ }
+ self.next_id = self.next_id.max(self.cells.iter().map(|c| c.id).max().unwrap_or(0).saturating_add(1)).max(1);
+ Ok(())
+ }
+
+ fn check_rect(&self, r: &Rect, area: Rect) -> Result<(), String> {
+ if !r.is_finite() || r.w < MIN_CELL_IN - EPS || r.h < MIN_CELL_IN - EPS {
+ return Err(format!("cells must be at least {MIN_CELL_IN} in wide and tall"));
+ }
+ if !area.contains(r) {
+ return Err("a cell lies outside the printable area".into());
+ }
+ Ok(())
+ }
+
+ /// The cells of one grid page in reading order (`singleImage`: one cell filling the area).
+ pub fn grid_rects(&self) -> Result<Vec<Rect>, String> {
+ self.grid_rects_for(self.page.printable()?)
+ }
+
+ fn grid_rects_for(&self, area: Rect) -> Result<Vec<Rect>, String> {
+ if self.style == Style::SingleImage {
+ return Ok(vec![area]);
+ }
+ let g = &self.grid;
+ let (cols, rows) = (g.columns.clamp(1, MAX_GRID), g.rows.clamp(1, MAX_GRID));
+ let gaps_x = g.spacing_x * (cols - 1) as f64;
+ let gaps_y = g.spacing_y * (rows - 1) as f64;
+ let mut cw = (area.w - gaps_x) / cols as f64;
+ let mut ch = (area.h - gaps_y) / rows as f64;
+ if !(cw > 0.0 && ch > 0.0) {
+ return Err("the grid spacing leaves no room for cells".into());
+ }
+ let (mut ox, mut oy) = (area.x, area.y);
+ if g.keep_square {
+ let side = cw.min(ch);
+ ox += (cw - side) * cols as f64 / 2.0;
+ oy += (ch - side) * rows as f64 / 2.0;
+ cw = side;
+ ch = side;
+ }
+ let mut out = Vec::with_capacity(cols * rows);
+ for r in 0..rows {
+ for c in 0..cols {
+ out.push(Rect::new(ox + c as f64 * (cw + g.spacing_x), oy + r as f64 * (ch + g.spacing_y), cw, ch));
+ }
+ }
+ Ok(out)
+ }
+
+ /// Cells per page of a grid style; 1 for the package styles.
+ pub fn cells_per_page(&self) -> usize {
+ match self.style {
+ Style::SingleImage => 1,
+ Style::ContactSheet => self.grid.columns.clamp(1, MAX_GRID) * self.grid.rows.clamp(1, MAX_GRID),
+ Style::PicturePackage | Style::CustomPackage => 1,
+ }
+ }
+
+ /// Pages a print of `photos` photos needs: the photos over the grid for the grid styles, the
+ /// layout's own pages for the packages.
+ pub fn page_count(&self, photos: usize) -> usize {
+ match self.style {
+ Style::SingleImage | Style::ContactSheet => photos.max(1).div_ceil(self.cells_per_page()),
+ Style::PicturePackage | Style::CustomPackage => self.pages.max(1) as usize,
+ }
+ }
+
+ pub fn cell(&self, id: u32) -> Option<&Cell> {
+ self.cells.iter().find(|c| c.id == id)
+ }
+
+ fn index(&self, id: u32) -> Result<usize, String> {
+ self.cells.iter().position(|c| c.id == id).ok_or_else(|| format!("no cell {id}"))
+ }
+
+ /// Cells of one page, back to front.
+ pub fn cells_on_page(&self, page: u32) -> impl Iterator<Item = &Cell> {
+ self.cells.iter().filter(move |c| c.page == page)
+ }
+
+ /// Sets the layout style. Entering a package style from a grid style keeps existing cells.
+ pub fn set_style(&mut self, style: Style) {
+ self.style = style;
+ }
+
+ fn require_package(&self) -> Result<(), String> {
+ if self.style.is_package() { Ok(()) } else { Err("cells exist only in the Picture Package and Custom Package styles".into()) }
+ }
+
+ /// Adds a `w` x `h` in cell at the first free spot of the earliest page with room (a new page
+ /// when none has), and returns its id. A cell too large for the printable area is refused.
+ pub fn add_cell(&mut self, w: f64, h: f64) -> Result<u32, String> {
+ self.require_package()?;
+ let area = self.printable()?;
+ check(w, "cell width", MIN_CELL_IN, MAX_PAGE_IN)?;
+ check(h, "cell height", MIN_CELL_IN, MAX_PAGE_IN)?;
+ if self.cells.len() >= MAX_CELLS {
+ return Err(format!("at most {MAX_CELLS} cells"));
+ }
+ if w > area.w + EPS || h > area.h + EPS {
+ return Err(format!("a {w:.2} x {h:.2} in cell is larger than the printable area ({:.2} x {:.2} in)", area.w, area.h));
+ }
+ let padded = Rect::new(area.x, area.y, area.w + self.spacing, area.h + self.spacing);
+ let spot = (0..self.pages).find_map(|p| {
+ let mut free = Free::new(padded);
+ for c in self.cells_on_page(p) {
+ free.occupy(&Rect::new(c.rect.x, c.rect.y, c.rect.w + self.spacing, c.rect.h + self.spacing));
+ }
+ free.best_fit(w + self.spacing, h + self.spacing, false).map(|(r, _)| (p, r))
+ });
+ let (page, at) = match spot {
+ Some(v) => v,
+ None => {
+ if self.pages >= MAX_PAGES {
+ return Err(format!("a layout holds at most {MAX_PAGES} pages"));
+ }
+ self.pages += 1;
+ (self.pages - 1, Rect::new(area.x, area.y, w, h))
+ }
+ };
+ let id = self.take_id();
+ self.cells.push(Cell { id, page, rect: Rect::new(at.x, at.y, w, h), photo: None });
+ Ok(id)
+ }
+
+ fn take_id(&mut self) -> u32 {
+ let id = self.next_id.max(1);
+ self.next_id = id.saturating_add(1);
+ id
+ }
+
+ /// Moves a cell so its top-left corner is at (`x`, `y`), kept inside the printable area.
+ pub fn move_cell(&mut self, id: u32, x: f64, y: f64) -> Result<Rect, String> {
+ self.require_package()?;
+ let area = self.printable()?;
+ if !x.is_finite() || !y.is_finite() {
+ return Err("position must be finite".into());
+ }
+ let i = self.index(id)?;
+ let cell = self.cells.get_mut(i).ok_or("no such cell")?;
+ let r = &mut cell.rect;
+ r.x = x.clamp(area.x, (area.right() - r.w).max(area.x));
+ r.y = y.clamp(area.y, (area.bottom() - r.h).max(area.y));
+ Ok(*r)
+ }
+
+ /// Gives a cell a new rectangle (position and size), clamped into the printable area.
+ pub fn resize_cell(&mut self, id: u32, rect: Rect) -> Result<Rect, String> {
+ self.require_package()?;
+ let area = self.printable()?;
+ if !rect.is_finite() {
+ return Err("rectangle must be finite".into());
+ }
+ let w = check(rect.w, "cell width", MIN_CELL_IN, MAX_PAGE_IN)?.min(area.w);
+ let h = check(rect.h, "cell height", MIN_CELL_IN, MAX_PAGE_IN)?.min(area.h);
+ let i = self.index(id)?;
+ let cell = self.cells.get_mut(i).ok_or("no such cell")?;
+ cell.rect = Rect::new(rect.x.clamp(area.x, (area.right() - w).max(area.x)), rect.y.clamp(area.y, (area.bottom() - h).max(area.y)), w, h);
+ Ok(cell.rect)
+ }
+
+ pub fn delete_cell(&mut self, id: u32) -> Result<(), String> {
+ let i = self.index(id)?;
+ self.cells.remove(i);
+ Ok(())
+ }
+
+ /// Removes every cell and extra page (Lightroom's Clear Layout).
+ pub fn clear(&mut self) {
+ self.cells.clear();
+ self.pages = 1;
+ }
+
+ /// Appends an empty page to a package layout and returns its zero-based index.
+ pub fn new_page(&mut self) -> Result<u32, String> {
+ self.require_package()?;
+ if self.pages >= MAX_PAGES {
+ return Err(format!("a layout holds at most {MAX_PAGES} pages"));
+ }
+ self.pages += 1;
+ Ok(self.pages - 1)
+ }
+
+ /// Moves a cell to another page, keeping its rectangle (clamped inside the printable area).
+ pub fn set_cell_page(&mut self, id: u32, page: u32) -> Result<(), String> {
+ self.require_package()?;
+ if page >= self.pages {
+ return Err(format!("the layout has {} pages", self.pages));
+ }
+ let i = self.index(id)?;
+ if let Some(c) = self.cells.get_mut(i) {
+ c.page = page;
+ }
+ Ok(())
+ }
+
+ /// Assigns (or with `None` clears) the photo printed in a cell.
+ pub fn set_cell_photo(&mut self, id: u32, photo: Option<u64>) -> Result<(), String> {
+ let i = self.index(id)?;
+ if let Some(c) = self.cells.get_mut(i) {
+ c.photo = photo;
+ }
+ Ok(())
+ }
+
+ /// Changes a cell's place in the stacking order of its page (Send to Back, Backward, Forward,
+ /// Bring to Front). Cells on other pages are not moved past.
+ pub fn restack(&mut self, id: u32, how: Stack) -> Result<(), String> {
+ let i = self.index(id)?;
+ let page = self.cells.get(i).map(|c| c.page).ok_or("no such cell")?;
+ let same: Vec<usize> = self.cells.iter().enumerate().filter(|(_, c)| c.page == page).map(|(k, _)| k).collect();
+ let pos = same.iter().position(|&k| k == i).ok_or("no such cell")?;
+ let target = match how {
+ Stack::ToBack => 0,
+ Stack::Backward => pos.saturating_sub(1),
+ Stack::Forward => (pos + 1).min(same.len().saturating_sub(1)),
+ Stack::ToFront => same.len().saturating_sub(1),
+ };
+ if target == pos {
+ return Ok(());
+ }
+ let cell = self.cells.remove(i);
+ // Index in the shortened vector where the target neighbour now sits.
+ let at = same.get(target).map(|&k| if k > i { k - 1 } else { k }).ok_or("no such cell")?;
+ let at = if target > pos { at + 1 } else { at };
+ self.cells.insert(at.min(self.cells.len()), cell);
+ Ok(())
+ }
+
+ /// Re-packs every cell of the package onto as few pages as possible (Auto Layout). Cells keep
+ /// their sizes (a cell may be turned a quarter to fit) and their stacking order; their
+ /// photos are untouched. Fails, changing nothing, when a cell cannot fit the printable area.
+ pub fn auto_layout(&mut self) -> Result<(), String> {
+ self.require_package()?;
+ let area = self.printable()?;
+ let sizes: Vec<(f64, f64)> = self.cells.iter().map(|c| (c.rect.w, c.rect.h)).collect();
+ let placed = pack(&sizes, area, self.spacing, true)?;
+ let mut pages = 1;
+ for (c, (page, rect, _)) in self.cells.iter_mut().zip(placed) {
+ c.page = page;
+ c.rect = rect;
+ pages = pages.max(page + 1);
+ }
+ self.pages = pages;
+ Ok(())
+ }
+
+ /// Whether two cells on the same page overlap.
+ pub fn has_overlaps(&self) -> bool {
+ self.cells.iter().enumerate().any(|(i, a)| self.cells.iter().skip(i + 1).any(|b| a.page == b.page && a.rect.overlaps(&b.rect)))
+ }
+
+ /// Snap candidates along each axis for cell `skip` on `page`: edges of other cells and of the
+ /// printable area, or grid lines.
+ fn candidates(&self, page: u32, skip: Option<u32>, snap: Snap, grid: f64) -> Result<(Vec<f64>, Vec<f64>), String> {
+ let area = self.printable()?;
+ let (mut xs, mut ys) = (Vec::new(), Vec::new());
+ match snap {
+ Snap::Off => {}
+ Snap::Cells => {
+ xs.extend([area.x, area.right()]);
+ ys.extend([area.y, area.bottom()]);
+ for c in self.cells_on_page(page).filter(|c| Some(c.id) != skip) {
+ xs.extend([c.rect.x, c.rect.right()]);
+ ys.extend([c.rect.y, c.rect.bottom()]);
+ }
+ }
+ Snap::Grid => {
+ let grid = check(grid, "grid size", 0.05, 10.0)?;
+ let n = |len: f64| (len / grid).floor().min(4000.0) as usize;
+ xs.extend((0..=n(area.w)).map(|k| area.x + k as f64 * grid));
+ ys.extend((0..=n(area.h)).map(|k| area.y + k as f64 * grid));
+ xs.push(area.right());
+ ys.push(area.bottom());
+ }
+ }
+ Ok((xs, ys))
+ }
+
+ /// Snaps a cell being dragged: `rect` keeps its size, and its left or right edge (likewise top
+ /// or bottom) lands on a candidate within `threshold` inches.
+ pub fn snap_move(&self, id: u32, rect: Rect, snap: Snap, grid: f64, threshold: f64) -> Result<Rect, String> {
+ if !rect.is_finite() || !threshold.is_finite() {
+ return Err("rectangle must be finite".into());
+ }
+ let page = self.cell(id).map(|c| c.page).ok_or_else(|| format!("no cell {id}"))?;
+ let (xs, ys) = self.candidates(page, Some(id), snap, grid)?;
+ let area = self.printable()?;
+ let x = snap_span(rect.x, rect.w, &xs, threshold.max(0.0));
+ let y = snap_span(rect.y, rect.h, &ys, threshold.max(0.0));
+ Ok(Rect::new(x.clamp(area.x, (area.right() - rect.w).max(area.x)), y.clamp(area.y, (area.bottom() - rect.h).max(area.y)), rect.w, rect.h))
+ }
+
+ /// Snaps a cell being resized by its bottom-right corner: the right and bottom edges land on
+ /// candidates within `threshold`, the top-left corner stays.
+ pub fn snap_resize(&self, id: u32, rect: Rect, snap: Snap, grid: f64, threshold: f64) -> Result<Rect, String> {
+ if !rect.is_finite() || !threshold.is_finite() {
+ return Err("rectangle must be finite".into());
+ }
+ let page = self.cell(id).map(|c| c.page).ok_or_else(|| format!("no cell {id}"))?;
+ let (xs, ys) = self.candidates(page, Some(id), snap, grid)?;
+ let right = snap_edge(rect.right(), &xs, threshold.max(0.0));
+ let bottom = snap_edge(rect.bottom(), &ys, threshold.max(0.0));
+ Ok(Rect::new(rect.x, rect.y, (right - rect.x).max(MIN_CELL_IN), (bottom - rect.y).max(MIN_CELL_IN)))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn package() -> Layout {
+ Layout { style: Style::PicturePackage, ..Default::default() }
+ }
+
+ fn assert_clean(l: &Layout) {
+ let area = l.printable().unwrap();
+ for c in &l.cells {
+ assert!(area.contains(&c.rect), "{c:?} outside {area:?}");
+ assert!(c.page < l.pages);
+ }
+ assert!(!l.has_overlaps(), "{:#?}", l.cells);
+ }
+
+ #[test]
+ fn papers_and_orientation() {
+ let mut p = PageSetup::default();
+ assert_eq!(p.size().unwrap(), (8.5, 11.0));
+ p.orientation = Orientation::Landscape;
+ assert_eq!(p.size().unwrap(), (11.0, 8.5));
+ assert_eq!(p.size_points().unwrap(), (792.0, 612.0));
+ p.paper = "A4".into();
+ let (w, h) = p.size().unwrap();
+ assert!((w - 11.693).abs() < 1e-3 && (h - 8.268).abs() < 1e-3);
+ for n in paper_names() {
+ p.paper = n.into();
+ assert!(p.printable().is_ok(), "{n}");
+ }
+ p.paper = "custom".into();
+ p.custom_width = 20.0;
+ p.custom_height = 30.0;
+ assert_eq!(p.size().unwrap(), (30.0, 20.0));
+ p.paper = "poster".into();
+ assert!(p.size().is_err());
+ }
+
+ #[test]
+ fn hostile_numbers_are_rejected() {
+ for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1.0, 1e9] {
+ let p = PageSetup { paper: "custom".into(), custom_width: bad, ..Default::default() };
+ assert!(p.size().is_err(), "{bad}");
+ let p = PageSetup { margins: Margins { left: bad, ..Margins::default() }, ..Default::default() };
+ assert!(p.printable().is_err(), "{bad}");
+ let mut l = package();
+ assert!(l.add_cell(bad, 2.0).is_err(), "{bad}");
+ assert!(l.add_cell(2.0, bad).is_err());
+ let id = l.add_cell(2.0, 2.0).unwrap();
+ assert!(bad.is_finite() || l.move_cell(id, bad, 0.0).is_err());
+ assert!(l.resize_cell(id, Rect::new(0.0, 0.0, bad, 1.0)).is_err());
+ assert!(bad.is_finite() || l.snap_move(id, Rect::new(bad, 0.0, 1.0, 1.0), Snap::Cells, 0.25, 0.1).is_err());
+ let mut g = Layout { spacing: bad, ..package() };
+ assert!(g.validate().is_err());
+ assert!(pack(&[(1.0, 1.0)], l.printable().unwrap(), bad, true).is_err());
+ assert!(pack(&[(bad, 1.0)], l.printable().unwrap(), 0.0, true).is_err());
+ }
+ // Margins that leave nothing.
+ let p = PageSetup { margins: Margins::uniform(4.5), ..Default::default() };
+ assert!(p.printable().is_err());
+ let mut l = Layout { grid: GridSpec { columns: 0, ..Default::default() }, ..Default::default() };
+ assert!(l.validate().is_err());
+ l.grid.columns = 21;
+ assert!(l.validate().is_err());
+ }
+
+ #[test]
+ fn units_convert() {
+ for u in [Unit::Inches, Unit::Centimeters, Unit::Millimeters, Unit::Points] {
+ assert!((u.to_inches(u.from_inches(3.5)) - 3.5).abs() < 1e-12);
+ }
+ assert!((Unit::Millimeters.from_inches(1.0) - 25.4).abs() < 1e-12);
+ assert_eq!(Unit::Points.from_inches(2.0), 144.0);
+ assert_eq!(serde_json::to_string(&Unit::Centimeters).unwrap(), "\"cm\"");
+ }
+
+ #[test]
+ fn contact_grid_fills_the_printable_area() {
+ let l = Layout {
+ style: Style::ContactSheet,
+ grid: GridSpec { columns: 3, rows: 4, spacing_x: 0.2, spacing_y: 0.1, keep_square: false },
+ ..Default::default()
+ };
+ let area = l.printable().unwrap();
+ let cells = l.grid_rects().unwrap();
+ assert_eq!(cells.len(), 12);
+ let first = cells.first().unwrap();
+ let last = cells.last().unwrap();
+ assert!((first.x - area.x).abs() < 1e-9 && (first.y - area.y).abs() < 1e-9);
+ assert!((last.right() - area.right()).abs() < 1e-9 && (last.bottom() - area.bottom()).abs() < 1e-9);
+ for (i, a) in cells.iter().enumerate() {
+ assert!((a.w - first.w).abs() < 1e-12 && (a.h - first.h).abs() < 1e-12);
+ for b in cells.iter().skip(i + 1) {
+ assert!(!a.overlaps(b));
+ }
+ }
+ // Square cells are centred.
+ let sq = Layout { grid: GridSpec { keep_square: true, ..l.grid }, ..l.clone() };
+ let cells = sq.grid_rects().unwrap();
+ assert!(cells.iter().all(|c| (c.w - c.h).abs() < 1e-12));
+ let (lo, hi) = (cells.iter().map(|c| c.x).fold(f64::MAX, f64::min), cells.iter().map(|c| c.right()).fold(f64::MIN, f64::max));
+ assert!(((lo - area.x) - (area.right() - hi)).abs() < 1e-9);
+ // Single image ignores the grid.
+ let one = Layout { style: Style::SingleImage, ..l };
+ assert_eq!(one.grid_rects().unwrap(), vec![area]);
+ }
+
+ #[test]
+ fn page_counts() {
+ let mut l = Layout { style: Style::ContactSheet, grid: GridSpec { columns: 2, rows: 2, ..Default::default() }, ..Default::default() };
+ assert_eq!(l.page_count(0), 1);
+ assert_eq!(l.page_count(4), 1);
+ assert_eq!(l.page_count(5), 2);
+ l.style = Style::SingleImage;
+ assert_eq!(l.page_count(3), 3);
+ l.style = Style::PicturePackage;
+ l.pages = 4;
+ assert_eq!(l.page_count(99), 4);
+ }
+
+ #[test]
+ fn packer_is_deterministic_and_clean() {
+ let area = Layout::default().printable().unwrap();
+ let sizes: Vec<(f64, f64)> =
+ [(4.0, 6.0), (5.0, 7.0), (2.5, 3.5), (2.5, 3.5), (3.5, 5.0), (8.0, 10.0), (4.0, 6.0), (2.0, 2.0), (1.0, 1.5), (5.0, 7.0), (4.0, 6.0)]
+ .to_vec();
+ let a = pack(&sizes, area, 0.1, true).unwrap();
+ assert_eq!(a, pack(&sizes, area, 0.1, true).unwrap());
+ assert_eq!(a.len(), sizes.len());
+ for (i, (p, r, turned)) in a.iter().enumerate() {
+ assert!(area.contains(r), "{r:?}");
+ let (w, h) = sizes[i];
+ let expect = if *turned { (h, w) } else { (w, h) };
+ assert!((r.w - expect.0).abs() < 1e-9 && (r.h - expect.1).abs() < 1e-9);
+ for (j, (q, s, _)) in a.iter().enumerate().skip(i + 1) {
+ if p == q {
+ // The spacing is kept between neighbours.
+ let grown = Rect::new(r.x, r.y, r.w + 0.1 - 2e-6, r.h + 0.1 - 2e-6);
+ assert!(!grown.overlaps(s), "{i} and {j}: {r:?} {s:?}");
+ }
+ }
+ }
+ // The input order does not hide a block that needs a page of its own.
+ assert!(a.iter().map(|p| p.0).max().unwrap() >= 1);
+ }
+
+ #[test]
+ fn packer_rotates_only_when_needed_and_refuses_oversize() {
+ let area = Rect::new(0.25, 0.25, 8.0, 10.5);
+ // 10 x 5 only fits a portrait page turned.
+ let r = pack(&[(10.0, 5.0)], area, 0.0, true).unwrap();
+ assert!(r[0].2 && (r[0].1.w - 5.0).abs() < 1e-9 && (r[0].1.h - 10.0).abs() < 1e-9);
+ assert!(pack(&[(10.0, 5.0)], area, 0.0, false).is_err());
+ let r = pack(&[(4.0, 6.0)], area, 0.0, true).unwrap();
+ assert!(!r[0].2, "a block that fits as given is not turned");
+ assert!(pack(&[(9.0, 11.0)], area, 0.0, true).is_err());
+ // A block that exactly fills the area fits despite the spacing.
+ assert!(pack(&[(8.0, 10.5)], area, 0.2, true).is_ok());
+ assert!(pack(&vec![(1.0, 1.0); MAX_CELLS + 1], area, 0.0, true).is_err());
+ // More pages than allowed.
+ assert!(pack(&vec![(8.0, 10.5); 51], area, 0.0, true).is_err());
+ assert_eq!(pack(&vec![(8.0, 10.5); 50], area, 0.0, true).unwrap().iter().map(|p| p.0).max(), Some(49));
+ }
+
+ #[test]
+ fn packing_is_dense() {
+ // Four 4x5.25 cells tile a letter page's 8 x 10.5 area exactly.
+ let area = Rect::new(0.25, 0.25, 8.0, 10.5);
+ let r = pack(&[(4.0, 5.25); 4], area, 0.0, false).unwrap();
+ assert!(r.iter().all(|p| p.0 == 0));
+ // Eight 4x6 photos fit two pages (four per page with the rotation trick is impossible: 4x6 x2 per column).
+ let r = pack(&[(4.0, 6.0); 4], area, 0.0, true).unwrap();
+ assert_eq!(r.iter().map(|p| p.0).max(), Some(1));
+ }
+
+ #[test]
+ fn add_cell_fills_gaps_then_opens_pages() {
+ let mut l = package();
+ let a = l.add_cell(3.9, 6.0).unwrap();
+ let b = l.add_cell(3.9, 6.0).unwrap();
+ assert_eq!(l.cell(a).unwrap().rect.x, 0.25);
+ assert_ne!(l.cell(a).unwrap().rect, l.cell(b).unwrap().rect);
+ assert_clean(&l);
+ // Keep adding until a second page appears.
+ for _ in 0..6 {
+ l.add_cell(3.9, 6.0).unwrap();
+ }
+ assert!(l.pages >= 2);
+ assert_clean(&l);
+ assert_eq!(l.cells.len(), 8);
+ assert!(l.add_cell(9.0, 9.0).is_err(), "wider than the printable area");
+ let mut grid = Layout::default();
+ assert!(grid.add_cell(1.0, 1.0).is_err());
+ }
+
+ #[test]
+ fn cell_cap() {
+ let mut l = package();
+ for _ in 0..MAX_CELLS {
+ if l.add_cell(0.5, 0.5).is_err() {
+ break;
+ }
+ }
+ assert!(l.cells.len() <= MAX_CELLS);
+ let n = l.cells.len();
+ if n == MAX_CELLS {
+ assert!(l.add_cell(0.5, 0.5).is_err());
+ }
+ }
+
+ #[test]
+ fn move_and_resize_stay_inside() {
+ let mut l = package();
+ let id = l.add_cell(2.0, 3.0).unwrap();
+ let r = l.move_cell(id, 100.0, -5.0).unwrap();
+ let area = l.printable().unwrap();
+ assert!((r.right() - area.right()).abs() < 1e-9 && (r.y - area.y).abs() < 1e-9);
+ let r = l.resize_cell(id, Rect::new(7.0, 9.0, 50.0, 50.0)).unwrap();
+ assert!(area.contains(&r));
+ assert!(l.resize_cell(id, Rect::new(0.0, 0.0, 0.0, 1.0)).is_err());
+ assert!(l.move_cell(77, 0.0, 0.0).is_err());
+ l.delete_cell(id).unwrap();
+ assert!(l.delete_cell(id).is_err());
+ }
+
+ #[test]
+ fn stacking_order() {
+ let mut l = Layout { style: Style::CustomPackage, ..Default::default() };
+ let ids: Vec<u32> = (0..4).map(|_| l.add_cell(1.0, 1.0).unwrap()).collect();
+ let order = |l: &Layout| l.cells.iter().map(|c| c.id).collect::<Vec<_>>();
+ assert_eq!(order(&l), ids);
+ l.restack(ids[0], Stack::ToFront).unwrap();
+ assert_eq!(order(&l), vec![ids[1], ids[2], ids[3], ids[0]]);
+ l.restack(ids[0], Stack::Backward).unwrap();
+ assert_eq!(order(&l), vec![ids[1], ids[2], ids[0], ids[3]]);
+ l.restack(ids[0], Stack::Forward).unwrap();
+ assert_eq!(order(&l), vec![ids[1], ids[2], ids[3], ids[0]]);
+ l.restack(ids[0], Stack::Forward).unwrap();
+ assert_eq!(order(&l), vec![ids[1], ids[2], ids[3], ids[0]]);
+ l.restack(ids[0], Stack::ToBack).unwrap();
+ assert_eq!(order(&l), ids);
+ l.restack(ids[0], Stack::Backward).unwrap();
+ assert_eq!(order(&l), ids);
+ assert!(l.restack(99, Stack::ToBack).is_err());
+ }
+
+ #[test]
+ fn stacking_ignores_other_pages() {
+ let mut l = Layout { style: Style::CustomPackage, pages: 2, ..Default::default() };
+ let a = l.add_cell(1.0, 1.0).unwrap();
+ let b = l.add_cell(1.0, 1.0).unwrap();
+ let c = l.add_cell(1.0, 1.0).unwrap();
+ l.set_cell_page(b, 1).unwrap();
+ l.restack(a, Stack::ToFront).unwrap();
+ // `a` goes past `c` (same page) and not necessarily past `b`.
+ let pos = |id| l.cells.iter().position(|x| x.id == id).unwrap();
+ assert!(pos(a) > pos(c));
+ }
+
+ #[test]
+ fn overlap_is_allowed_by_move_and_reported() {
+ let mut l = Layout { style: Style::CustomPackage, ..Default::default() };
+ let a = l.add_cell(3.0, 3.0).unwrap();
+ let b = l.add_cell(3.0, 3.0).unwrap();
+ assert!(!l.has_overlaps());
+ let r = l.cell(a).unwrap().rect;
+ l.move_cell(b, r.x + 1.0, r.y + 1.0).unwrap();
+ assert!(l.has_overlaps());
+ // Touching edges are not an overlap.
+ l.move_cell(b, r.right(), r.y).unwrap();
+ assert!(!l.has_overlaps());
+ }
+
+ #[test]
+ fn auto_layout_repacks_cleanly_and_keeps_photos() {
+ let mut l = package();
+ for (w, h) in [(4.0, 6.0), (5.0, 7.0), (2.5, 3.5), (8.0, 10.0), (4.0, 6.0), (3.5, 5.0)] {
+ l.add_cell(w, h).unwrap();
+ }
+ let first = l.cells[0].id;
+ l.set_cell_photo(first, Some(42)).unwrap();
+ // Scramble positions to overlap, then auto layout.
+ for c in &mut l.cells {
+ c.rect.x = 0.25;
+ c.rect.y = 0.25;
+ c.page = 0;
+ }
+ l.pages = 1;
+ assert!(l.has_overlaps());
+ l.auto_layout().unwrap();
+ assert_clean(&l);
+ assert_eq!(l.cell(first).unwrap().photo, Some(42));
+ assert_eq!(l.cells.len(), 6);
+ let again = l.clone();
+ let mut l2 = again.clone();
+ l2.auto_layout().unwrap();
+ l.auto_layout().unwrap();
+ assert_eq!(l, l2);
+ }
+
+ #[test]
+ fn auto_layout_failure_changes_nothing() {
+ let mut l = package();
+ l.add_cell(2.0, 2.0).unwrap();
+ l.cells.push(Cell { id: 50, page: 0, rect: Rect::new(0.25, 0.25, 40.0, 40.0), photo: None });
+ let before = l.clone();
+ assert!(l.auto_layout().is_err());
+ assert_eq!(l, before);
+ }
+
+ #[test]
+ fn clear_and_new_page() {
+ let mut l = package();
+ l.add_cell(2.0, 2.0).unwrap();
+ assert_eq!(l.new_page().unwrap(), 1);
+ assert_eq!(l.pages, 2);
+ l.clear();
+ assert_eq!((l.cells.len(), l.pages), (0, 1));
+ for _ in 1..MAX_PAGES {
+ l.new_page().unwrap();
+ }
+ assert!(l.new_page().is_err());
+ let mut g = Layout::default();
+ assert!(g.new_page().is_err());
+ }
+
+ #[test]
+ fn validate_catches_bad_cells() {
+ let mut l = package();
+ l.add_cell(2.0, 2.0).unwrap();
+ let ok = l.clone();
+ let mut bad = ok.clone();
+ bad.cells[0].rect.w = f64::NAN;
+ assert!(bad.validate().is_err());
+ let mut bad = ok.clone();
+ bad.cells[0].page = 3;
+ assert!(bad.validate().is_err());
+ let mut bad = ok.clone();
+ bad.cells[0].rect.x = 50.0;
+ assert!(bad.validate().is_err());
+ let mut bad = ok.clone();
+ bad.cells.push(bad.cells[0].clone());
+ assert!(bad.validate().is_err());
+ let mut bad = ok.clone();
+ bad.pages = 0;
+ assert!(bad.validate().is_err());
+ let mut bad = ok.clone();
+ bad.next_id = 0;
+ bad.validate().unwrap();
+ assert!(bad.next_id > bad.cells[0].id);
+ assert!(serde_json::from_str::<Layout>(r#"{"surprise":1}"#).is_err());
+ let mut round: Layout = serde_json::from_str(&serde_json::to_string(&ok).unwrap()).unwrap();
+ round.validate().unwrap();
+ assert_eq!(round, ok);
+ }
+
+ #[test]
+ fn snapping_to_cells_grid_and_margins() {
+ let mut l = Layout { style: Style::CustomPackage, spacing: 0.0, ..Default::default() };
+ let a = l.add_cell(3.0, 3.0).unwrap();
+ let b = l.add_cell(2.0, 2.0).unwrap();
+ let ra = l.cell(a).unwrap().rect;
+ // Left edge of b near the right edge of a.
+ let m = l.snap_move(b, Rect::new(ra.right() + 0.04, 5.0, 2.0, 2.0), Snap::Cells, 0.25, 0.1).unwrap();
+ assert!((m.x - ra.right()).abs() < 1e-9);
+ assert_eq!(m.y, 5.0);
+ // Too far: untouched.
+ let m = l.snap_move(b, Rect::new(ra.right() + 0.5, 5.0, 2.0, 2.0), Snap::Cells, 0.25, 0.1).unwrap();
+ assert!((m.x - (ra.right() + 0.5)).abs() < 1e-9);
+ // Right edge snaps to the printable margin.
+ let area = l.printable().unwrap();
+ let m = l.snap_move(b, Rect::new(area.right() - 2.0 - 0.03, 5.0, 2.0, 2.0), Snap::Cells, 0.25, 0.1).unwrap();
+ assert!((m.right() - area.right()).abs() < 1e-9);
+ // Off leaves everything.
+ let m = l.snap_move(b, Rect::new(ra.right() + 0.04, 5.0, 2.0, 2.0), Snap::Off, 0.25, 0.1).unwrap();
+ assert!((m.x - (ra.right() + 0.04)).abs() < 1e-9);
+ // Grid snapping lands on multiples from the printable corner.
+ let m = l.snap_move(b, Rect::new(1.37, 2.62, 2.0, 2.0), Snap::Grid, 0.5, 0.2).unwrap();
+ assert!(((m.x - area.x) / 0.5).fract().abs() < 1e-9 || (((m.x - area.x) / 0.5).fract() - 1.0).abs() < 1e-9);
+ // Resize snaps the dragged corner only.
+ let r = l.snap_resize(b, Rect::new(5.0, 5.0, 2.1, 1.9), Snap::Grid, 0.5, 0.2).unwrap();
+ assert_eq!((r.x, r.y), (5.0, 5.0));
+ assert!(((r.right() - area.x) / 0.5 - ((r.right() - area.x) / 0.5).round()).abs() < 1e-9);
+ // Never below the minimum size.
+ let r = l.snap_resize(b, Rect::new(5.0, 5.0, 0.0, 0.0), Snap::Grid, 0.5, 0.2).unwrap();
+ assert!(r.w >= MIN_CELL_IN && r.h >= MIN_CELL_IN);
+ assert!(l.snap_move(99, Rect::new(0.0, 0.0, 1.0, 1.0), Snap::Cells, 0.25, 0.1).is_err());
+ assert!(l.snap_move(b, Rect::new(0.0, 0.0, 1.0, 1.0), Snap::Grid, 0.0, 0.1).is_err());
+ assert!(l.snap_move(b, Rect::new(0.0, 0.0, 1.0, 1.0), Snap::Grid, f64::NAN, 0.1).is_err());
+ }
+
+ #[test]
+ fn cell_aspect_survives_auto_layout() {
+ let mut l = package();
+ let id = l.add_cell(2.5, 3.5).unwrap();
+ l.auto_layout().unwrap();
+ let r = l.cell(id).unwrap().rect;
+ assert!((r.w / r.h - 2.5 / 3.5).abs() < 1e-9 || (r.h / r.w - 2.5 / 3.5).abs() < 1e-9);
+ }
+
+ #[test]
+ fn guides_validate() {
+ assert!(Guides::default().validate().is_ok());
+ for bad in [f64::NAN, 0.0, -1.0, 1e9] {
+ assert!(Guides { grid_size: bad, ..Default::default() }.validate().is_err());
+ }
+ }
+
+ #[test]
+ fn rect_helpers() {
+ let a = Rect::new(0.0, 0.0, 2.0, 2.0);
+ assert!(a.overlaps(&Rect::new(1.0, 1.0, 2.0, 2.0)));
+ assert!(!a.overlaps(&Rect::new(2.0, 0.0, 1.0, 1.0)));
+ assert!(a.contains(&Rect::new(0.5, 0.5, 1.0, 1.0)));
+ assert!(!a.contains(&Rect::new(1.5, 0.5, 1.0, 1.0)));
+ assert_eq!(a.area(), 4.0);
+ }
+}
diff --git a/crates/engine/src/print/mod.rs b/crates/engine/src/print/mod.rs
new file mode 100644
index 000000000..d309dbd6f
--- /dev/null
+++ b/crates/engine/src/print/mod.rs
@@ -0,0 +1,4 @@
+//! The Print module: page layout, composition of pages and PDF output.
+//!
+//! [`layout`] is the pure page model (paper, margins, cells); the rest of the module renders it.
+pub mod layout;
diff --git a/docs/gaps.md b/docs/gaps.md
index 7c4f56223..724758c8a 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
# Gaps: where LightCraft falls short of Lightroom
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-11 · **Change:** minor (CR3 entry names the EOS R7 C-RAW fix and the refused CRX variants; CI and Windows / Linux entries note the 0.6.0 riscv64 build; camera colour: tone curve from black-and-white camera JPEGs; Compare and Reference get sharp zoom windows; gap 4 shrinks; gap 14: the HDR switch is read from crs XMP; gaps 2 and 10: EOS R5 Mark II CR3 verified) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-12 · **Change:** minor (gap 15: print layout model; CR3 entry names the EOS R7 C-RAW fix and the refused CRX variants; CI and Windows / Linux entries note the 0.6.0 riscv64 build; camera colour: tone curve from black-and-white camera JPEGs; Compare and Reference get sharp zoom windows; gap 4 shrinks; gap 14: the HDR switch is read from crs XMP; gaps 2 and 10: EOS R5 Mark II CR3 verified) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
Every known shortfall, one entry each, ranked by user impact (how many Lightroom users hit it, and
how hard it blocks them), then by effort. **Agents pick work from the top** (the first entry nobody is
@@ -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: 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 |
| 2026-10-11 | minor | Reviewed against main after 0.6.0: CR3 entry names the CRX variants `crx.rs` still refuses and the R7 / R6 Mark II C-RAW state (decoding, not verified, so the measured numbers don't move); CI and Windows / Linux entries note the riscv64 release build (#844); R7 fix added to Closed recently. Panel docking (UI.9, #869) closes no listed gap |
| 2026-10-11 | minor | Camera colour entry: raws with a black-and-white camera JPEG take its tone curve (#577); gap not closed |
| 2026-10-11 | minor | Gap 4: Compare and Reference views get zoom windows per pane (1:1 was a 2,560 px render magnified); overlays and soft proofing remain, 8–15 h → 4–8 h |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 77ae26e4c..ee965a945 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-11 · **Change:** minor (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-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
The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what we
have and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good
@@ -749,9 +749,9 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-
| LRC-SS-EXPORT | Slideshow export | P2 | ⬜ | | |
| LRC-PRINT-LAYOUTSTYLE | Print layout styles | P2 | 🟡 | `cmd:dialog.contactSheet`, `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs` | paginated contact sheets; single-image/custom package layouts missing |
| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | ⬜ | | |
-| LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:export.contactSheet`, `crates/ui-egui/src/panels/dialogs.rs` | A4/Letter, portrait/landscape, 1–8 columns and 1–10 rows; fixed margins and spacing |
+| LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:export.contactSheet`, `crates/ui-egui/src/panels/dialogs.rs`, `crates/engine/src/print/layout.rs` | A4/Letter, portrait/landscape, 1–8 columns and 1–10 rows; fixed margins and spacing. The new layout model (ten paper sizes + custom, orientation, margins, grid with spacing and square cells, package cells with Auto Layout packing) is in the engine but not yet reachable from a command or the UI |
| LRC-PRINT-GUIDES | Print guides | P2 | ⬜ | | |
-| LRC-PRINT-CELLS | Picture-package cells | P2 | ⬜ | | |
+| LRC-PRINT-CELLS | Picture-package cells | P2 | ⬜ | `crates/engine/src/print/layout.rs` | cell model, deterministic packer, stacking order and snapping exist in the engine; no command or UI yet |
| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs` | optional filename captions; no page backgrounds/identity plates |
| 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 | ⬜ | | |
@@ -787,6 +787,7 @@ Latin stays upright. Advanced Japanese composition remains open. Regression cove
| Date | Change | Summary |
|---|---|---|
+| 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 |
| 2026-10-11 | minor | KEY-SLIDER-TYPE: honor immediate Return/Escape and keep typed keys in the value editor; add regression references |
| 2026-10-11 | minor | LR-PROF-CAMERACOLOR: raws with a black-and-white camera JPEG take its tone curve (issue #577) |
| 2026-10-11 | minor | LR-VIEW-ZOOM and LR-VIEW-COMPARE: Compare and Reference are sharp at 1:1 (zoom windows per pane, two originals kept decoded while they are open); statuses unchanged |