Skip to content

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

LRC-SS-OVERLAYS: slideshow overlays: identity plate, rating stars, text with tokens, watermark

Jason Baldwin12dc533396fd
diff --git a/crates/engine/src/cmd/slideshow.rs b/crates/engine/src/cmd/slideshow.rs
index 17bd861f1..1ac391055 100644
--- a/crates/engine/src/cmd/slideshow.rs
+++ b/crates/engine/src/cmd/slideshow.rs
@@ -2,8 +2,9 @@
//! random order, repeat, preparing previews in advance). `slideshow.layout`: how a slide looks
//! (Layout, Options and Backdrop: margins, aspect preview, zoom to fill, stroke, shadow, backdrop
//! colour, colour wash, background image). Both are library preferences, saved in the library's
-//! `prefs.json`; the app's slideshow (View ▸ Slideshow) plays with them. `slideshow.preview`
-//! composes one slide as a PNG.
+//! `prefs.json`; the app's slideshow (View ▸ Slideshow) plays with them. `slideshow.overlays`:
+//! the identity plate, rating stars, text overlays with tokens and the watermark drawn on every
+//! slide (also a library preference). `slideshow.preview` composes one slide as a PNG.
use lightcraft_catalog::PhotoId;
use serde_json::{Value, json};
@@ -38,6 +39,20 @@ fn layout(s: &mut Session, p: &Value) -> Result<Value> {
Ok(s.slide_layout.to_json())
}
+fn overlays(s: &mut Session, p: &Value) -> Result<Value> {
+ let changes = p.as_object().is_some_and(|o| !o.is_empty());
+ if changes {
+ let next = s.slide_overlays.merged(p).map_err(|e| bad("slideshow.overlays", e))?;
+ if next != s.slide_overlays {
+ s.slide_overlays = next;
+ s.save_prefs()?;
+ }
+ }
+ let mut out = s.slide_overlays.to_json();
+ out["warnings"] = json!(s.slide_overlays.warnings());
+ Ok(out)
+}
+
/// A slide size from the request: both sides given, one (the other from the aspect preview), or
/// neither (1280 wide). Each side 16–[`PREVIEW_MAX`].
fn preview_size(s: &Session, p: &Value) -> Result<(usize, usize)> {
@@ -89,6 +104,9 @@ fn preview(s: &mut Session, p: &Value) -> Result<Value> {
"cell": rect(l.cell),
"photo": rect(l.visible),
});
+ let photo = s.catalog.photo(id).cloned();
+ let o = crate::slide_overlay::SlideOverlays::resolve(&s.slide_overlays, photo.as_deref());
+ out["overlays"] = o.boxes(&l).into_iter().map(|(k, r)| json!({"kind": k.id(), "box": rect(r)})).collect();
match path {
Some(path) => {
crate::export::write_file(path, &png).map_err(crate::EngineError::Other)?;
@@ -135,12 +153,21 @@ pub fn specs() -> Vec<CommandSpec> {
always,
layout
),
+ cmd!(
+ "slideshow.overlays",
+ "Slideshow Overlay Settings",
+ [],
+ None,
+ "{identityPlate?: {enabled?, text?, image?: PNG/JPEG file (drawn instead of the text; \"\" = the text), size?: height as a fraction of the slide's shorter side (0.005–0.5), color?: \"#rrggbb\"|[r,g,b], opacity?: 0–1, …placement, behind?: bool (render behind the photo)}, ratingStars?: {enabled?, color?, size?: a star's height (0.005–0.15), …placement}, texts?: [text overlay] (replaces the list, at most 16; each entry merged onto the one at its index), addText?: text overlay ({} = the default \"{file}\"), removeText?: index, showWatermark?: bool, watermark?: text | the export watermark object {text, vertical, size, opacity, anchor, inset, color, shadow, image, imageWidth} (merged; sizes relative to the photo)} where a text overlay is {text?: template with tokens ({file}, {name}, {title}, {caption}, {date} (YYYY-MM-DD) / {date:%d.%m.%Y}, {exposure}, {shutter}, {aperture}, {focal}, {iso}, {camera}, {lens}, {rating}, {creator}, {copyright}, {folder}, {ext}; unknown tags show as typed), size?: line height (0.005–0.3), color?, opacity?, …placement, shadow?: bool, shadowOpacity?: 0–1, shadowOffset?, shadowRadius?: 0–0.05 (fractions of the shorter side), shadowAngle?: degrees counter-clockwise from the right} and the placement keys are anchor?: topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight, offsetX?, offsetY?: fractions of the slide's shorter side (x right, y down; −1–1), relativeTo?: \"slide\"|\"photo\" (the overlay is kept on the slide) — omitted keys keep their value, {} reads them; out-of-range numbers are clamped, wrong types refused; saved with the library; slideshow playback and slideshow.preview draw them → the settings and warnings (an unreadable identity plate image, unknown tokens)",
+ always,
+ overlays
+ ),
cmd!(
query "slideshow.preview",
"Slideshow Slide Preview",
[],
None,
- "{id?: photo (default: the active one), width?, height?: pixels (16–4096; one given: the other from the aspect preview; neither: 1280 wide), path?: write the PNG here} — the photo's slide composed with the slideshow layout → {id, width, height, cell: [x0,y0,x1,y1], photo: [x0,y0,x1,y1] (the visible photo, slide pixels), path | png (base64 PNG)}",
+ "{id?: photo (default: the active one), width?, height?: pixels (16–4096; one given: the other from the aspect preview; neither: 1280 wide), path?: write the PNG here} — the photo's slide composed with the slideshow layout and overlays → {id, width, height, cell: [x0,y0,x1,y1], photo: [x0,y0,x1,y1] (the visible photo, slide pixels), overlays: [{kind: identityPlate|ratingStars|textN|watermark, box: [x0,y0,x1,y1]}], path | png (base64 PNG)}",
always,
preview
),
diff --git a/crates/engine/src/export.rs b/crates/engine/src/export.rs
index 6a9e9147c..4cd4dd50d 100644
--- a/crates/engine/src/export.rs
+++ b/crates/engine/src/export.rs
@@ -242,58 +242,8 @@ impl Default for Watermark {
}
}
-/// Inter SemiBold (OFL, see assets/ATTRIBUTION.md).
-static WATERMARK_FONT: &[u8] = include_bytes!("../../../assets/fonts/Inter-SemiBold.ttf");
-
-/// The watermark faces: Inter first, then the craft-fonts CJK faces (Mincho first, the watermark's
-/// serif look; then any other CJK face — a watermark has no UI language, so every CJK script is
-/// offered). Without craft-fonts that is Inter alone, and CJK characters draw as Inter's
-/// missing-glyph box.
-fn watermark_fonts(craft: &'static [crate::fonts::CraftFont]) -> Vec<ab_glyph::FontRef<'static>> {
- let mut cjk: Vec<_> = crate::fonts::cjk(craft).collect();
- cjk.sort_by_key(|f| !f.is_mincho());
- std::iter::once(WATERMARK_FONT)
- .chain(cjk.into_iter().map(|f| f.bytes))
- .filter_map(|bytes| ab_glyph::FontRef::try_from_slice(bytes).ok())
- .collect()
-}
-
-/// Shape a whole grapheme in one cell. CJK uses vertical origins and forms; Latin stays upright.
-/// Unlike Unicode presentation-form characters, GSUB works with BIZ UD fonts too.
-fn watermark_cell_glyphs(
- font: &ab_glyph::FontRef<'_>,
- data: &harfrust::ShaperData,
- text: &str,
- vertical: bool,
- px: f32,
- left: f32,
- top: f32,
-) -> Option<Vec<ab_glyph::Glyph>> {
- use ab_glyph::{Font, ScaleFont};
- let face = harfrust::FontRef::new(font.font_data()).ok()?;
- let mut buf = harfrust::UnicodeBuffer::new();
- buf.push_str(text);
- buf.set_direction(if vertical { harfrust::Direction::TopToBottom } else { harfrust::Direction::LeftToRight });
- buf.guess_segment_properties();
- let shaped = data.shaper(&face).build().shape(buf, harfrust::ShapeOptions::new());
- if shaped.glyph_infos().is_empty() {
- return None;
- }
- let sf = font.as_scaled(px);
- let (sx, sy) = (sf.h_scale_factor(), sf.v_scale_factor());
- let advance_x = shaped.glyph_positions().iter().map(|p| p.x_advance as f32 * sx).sum::<f32>();
- let advance_y = shaped.glyph_positions().iter().map(|p| -(p.y_advance as f32) * sy).sum::<f32>();
- let (mut x, mut y) = if vertical { (left + px / 2.0, top + (px - advance_y) / 2.0) } else { (left + (px - advance_x) / 2.0, top + sf.ascent()) };
- let mut glyphs = Vec::new();
- for (info, pos) in shaped.glyph_infos().iter().zip(shaped.glyph_positions()) {
- let gid = u16::try_from(info.glyph_id).ok().filter(|g| *g != 0)?;
- let pen = ab_glyph::point(x + pos.x_offset as f32 * sx, y - pos.y_offset as f32 * sy);
- glyphs.push(ab_glyph::GlyphId(gid).with_scale_and_position(px, pen));
- x += pos.x_advance as f32 * sx;
- y -= pos.y_advance as f32 * sy;
- }
- Some(glyphs)
-}
+#[cfg(test)]
+use crate::text::{TEXT_FONT as WATERMARK_FONT, cell_glyphs as watermark_cell_glyphs, faces as watermark_fonts};
/// Draw `wm` onto `img` (straight alpha blending of the encoded values).
pub fn draw_watermark(img: &mut Rgba8, wm: &Watermark) {
@@ -306,6 +256,23 @@ pub fn draw_watermark(img: &mut Rgba8, wm: &Watermark) {
});
}
+/// Draw `wm` into the `w × h` area of `img` whose top-left corner is (`x0`, `y0`), sized and
+/// anchored as on an image of that size (a slideshow slide's photo). The area is clipped to `img`.
+pub fn draw_watermark_in(img: &mut Rgba8, wm: &Watermark, x0: usize, y0: usize, w: usize, h: usize) {
+ let (width, height) = (img.width, img.height);
+ watermark_coverage(w, h, wm, crate::fonts::CRAFT_FONTS, |x, y, k, col| {
+ let (px, py) = (x0.saturating_add(x), y0.saturating_add(y));
+ if px >= width || py >= height {
+ return;
+ }
+ if let Some(p) = img.data.get_mut(py * width + px) {
+ for c in 0..3 {
+ p[c] = (p[c] as f32 + (col[c] as f32 - p[c] as f32) * k).round() as u8;
+ }
+ }
+ });
+}
+
/// Draw `wm` onto a high-bit-depth image (`wm.color` is in the image's space, 8-bit encoded; float
/// images are linear and blend in linear light).
pub fn draw_watermark_deep(img: &mut DeepImage, wm: &Watermark) {
@@ -338,7 +305,6 @@ fn watermark_coverage(
craft: &'static [crate::fonts::CraftFont],
mut blend_px: impl FnMut(usize, usize, f32, [u8; 3]),
) {
- use ab_glyph::{Font, PxScale, ScaleFont, point};
if !wm.image.trim().is_empty() {
logo_coverage(width, height, wm, blend_px);
return;
@@ -347,97 +313,10 @@ fn watermark_coverage(
if text.is_empty() || width == 0 || height == 0 {
return;
}
- let fonts = watermark_fonts(craft);
- let Some(latin) = fonts.first() else { return };
- let vertical_data: Vec<_> = if wm.vertical {
- fonts.iter().map(|font| harfrust::FontRef::new(font.font_data()).ok().map(|face| harfrust::ShaperData::new(&face))).collect()
- } else {
- Vec::new()
- };
let short = width.min(height) as f32;
let px = (wm.size.clamp(0.005, 0.5) * short).max(6.0);
- let mut glyphs = Vec::new();
- let mut x = 0.0f32;
- let mut y = 0.0f32;
- let mut tw = 0.0f32;
- let mut prev = None;
- let columns = text.split('\n').count();
- let mut column = 0usize;
- use unicode_segmentation::UnicodeSegmentation;
- // Horizontal watermarks retain scalar layout and kerning; only vertical cells use graphemes.
- let cells: Box<dyn Iterator<Item = &str>> =
- if wm.vertical { Box::new(text.graphemes(true)) } else { Box::new(text.char_indices().filter_map(|(i, c)| text.get(i..i + c.len_utf8()))) };
- for cell in cells {
- let Some(original) = cell.chars().next() else { continue };
- if cell == "\n" || (wm.vertical && cell == "\r\n") {
- if wm.vertical {
- column = column.saturating_add(1);
- tw = tw.max(y);
- y = 0.0;
- } else {
- tw = tw.max(x);
- x = 0.0;
- y += px;
- }
- prev = None;
- continue;
- }
- let cjk = matches!(original as u32, 0x3000..=0x30FF | 0x3400..=0x9FFF | 0xFF01..=0xFF60);
- if wm.vertical && (cjk || cell.chars().count() > 1) {
- let left = columns.saturating_sub(column.saturating_add(1)) as f32 * px;
- let shaped = fonts.iter().zip(&vertical_data).enumerate().find_map(|(face, (font, data))| {
- let data = data.as_ref()?;
- let cluster = watermark_cell_glyphs(font, data, cell, cjk, px, left, y)?;
- let substituted = cluster.len() != 1 || cluster.first().is_some_and(|g| g.id != font.glyph_id(original));
- if cjk && !substituted && matches!(original, '、' | '。' | 'ー' | '(' | ')' | '「' | '」' | '『' | '』' | '【' | '】') {
- return None;
- }
- Some((face, cluster))
- });
- if let Some((face, cluster)) = shaped {
- glyphs.extend(cluster.into_iter().map(|g| (face, g, None)));
- y += px;
- continue;
- }
- }
- let vertical_form = match original {
- '、' => '︑',
- '。' => '︒',
- '(' => '︵',
- ')' => '︶',
- '「' => '﹁',
- '」' => '﹂',
- '『' => '﹃',
- '』' => '﹄',
- '【' => '︻',
- '】' => '︼',
- '…' => '︙',
- other => other,
- };
- let has = |font: &ab_glyph::FontRef<'_>, c: char| font.glyph_id(c).0 != 0;
- let ch = if wm.vertical && fonts.iter().skip(1).any(|f| has(f, vertical_form)) { vertical_form } else { original };
- // The first face with the glyph; Inter (its missing-glyph box) when none has it.
- let face = fonts.iter().position(|f| has(f, ch)).unwrap_or(0);
- let sf = fonts.get(face).unwrap_or(latin).as_scaled(PxScale::from(px));
- let id = sf.glyph_id(ch);
- if wm.vertical {
- let left = columns.saturating_sub(column.saturating_add(1)) as f32 * px;
- let pen = point(left + (px - sf.h_advance(id)) / 2.0, y + sf.ascent());
- let rotation = matches!(original, 'ー' | '—' | '–').then_some((left + px / 2.0, y + px / 2.0));
- glyphs.push((face, id.with_scale_and_position(px, pen), rotation));
- y += px;
- } else {
- if let Some((previous_face, previous)) = prev
- && previous_face == face
- {
- x += sf.kern(previous, id);
- }
- glyphs.push((face, id.with_scale_and_position(px, point(x, y + sf.ascent())), None));
- x += sf.h_advance(id);
- prev = Some((face, id));
- }
- }
- let (tw, th) = if wm.vertical { (columns as f32 * px, tw.max(y)) } else { (tw.max(x), y + px) };
+ let Some(layout) = crate::text::TextLayout::new(text, px, wm.vertical, craft) else { return };
+ let (tw, th) = (layout.width, layout.height);
let inset = wm.inset.clamp(0.0, 0.4) * short;
let (w, h) = (width as f32, height as f32);
use Anchor::*;
@@ -452,33 +331,20 @@ fn watermark_coverage(
BottomLeft | Bottom | BottomRight => h - inset - th,
};
let alpha = wm.opacity.clamp(0.0, 1.0);
- let mut blend = |gx: i32, gy: i32, cov: f32, col: [u8; 3], a: f32| {
- if gx < 0 || gy < 0 || gx >= width as i32 || gy >= height as i32 {
- return;
- }
- blend_px(gx as usize, gy as usize, (cov * a).clamp(0.0, 1.0), col);
- };
let passes: &[(f32, [u8; 3], f32)] =
if wm.shadow { &[((px * 0.05).max(1.0), [0, 0, 0], 0.45), (0.0, wm.color, 1.0)] } else { &[(0.0, wm.color, 1.0)] };
for &(off, col, a) in passes {
- for (face, g, rotation) in &glyphs {
- if let Some(o) = fonts.get(*face).and_then(|font| font.outline_glyph(g.clone())) {
- let b = o.px_bounds();
- o.draw(|gx, gy, cov| {
- let (sx, sy) = (b.min.x + gx as f32, b.min.y + gy as f32);
- let (sx, sy) = match rotation {
- Some((cx, cy)) => (cx - (sy - cy), cy + (sx - cx)),
- None => (sx, sy),
- };
- blend((ox + off + sx) as i32, (oy + off + sy) as i32, cov, col, a * alpha);
- });
+ layout.draw_in(ox + off, oy + off, width as f32, height as f32, |gx, gy, cov| {
+ if gx < 0 || gy < 0 || gx >= width as i32 || gy >= height as i32 {
+ return;
}
- }
+ blend_px(gx as usize, gy as usize, (cov * a * alpha).clamp(0.0, 1.0), col);
+ });
}
}
/// A watermark graphic, decoded once per file (and again when the file changes).
-fn watermark_logo(path: &str) -> Option<std::sync::Arc<Rgba8>> {
+pub(crate) fn watermark_logo(path: &str) -> Option<std::sync::Arc<Rgba8>> {
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
static CACHE: Mutex<Option<HashMap<String, (std::time::SystemTime, Arc<Rgba8>)>>> = Mutex::new(None);
@@ -833,7 +699,7 @@ impl ExportOptions {
}
/// A `watermark` value: text, or an object of [`WATERMARK_PARAMS`] (issue #183).
- fn validate_watermark(cmd: &str, v: &serde_json::Value) -> crate::Result<()> {
+ pub(crate) fn validate_watermark(cmd: &str, v: &serde_json::Value) -> crate::Result<()> {
use serde_json::Value;
let bad = |msg: String| crate::cmd::bad(cmd, msg);
let obj = match v {
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 9d1bd5db8..fab21a5d9 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -56,9 +56,11 @@ pub mod rename;
pub mod segment;
pub mod sidecar;
pub mod slide;
+pub mod slide_overlay;
pub mod slideshow;
pub mod smart;
pub mod sync;
+pub mod text;
mod view;
pub mod walk;
@@ -278,6 +280,8 @@ pub struct Session {
/// Slideshow slide layout: Layout, Options and Backdrop (`slideshow.layout`; persisted in
/// prefs.json).
pub slide_layout: slide::SlideSettings,
+ /// Slideshow overlays (identity plate, rating stars, text overlays, watermark).
+ pub slide_overlays: slide_overlay::OverlaySettings,
/// The background image the slides last rendered (shared by slide jobs: rendered once).
pub slide_backdrop: std::sync::Arc<slide::BackdropCache>,
/// Where smart previews are kept when not in the library folder (persisted in prefs.json).
@@ -364,6 +368,7 @@ impl Session {
cache_mb: 0,
slideshow: slideshow::PlaybackSettings::default(),
slide_layout: slide::SlideSettings::default(),
+ slide_overlays: slide_overlay::OverlaySettings::default(),
slide_backdrop: Default::default(),
smart_previews_dir: None,
forget_local_days: lightcraft_catalog::DEFAULT_FORGET_DAYS,
diff --git a/crates/engine/src/library.rs b/crates/engine/src/library.rs
index 4f5695a0f..6c7bafaef 100644
--- a/crates/engine/src/library.rs
+++ b/crates/engine/src/library.rs
@@ -162,6 +162,8 @@ struct PrefsFile {
slideshow: crate::slideshow::PlaybackSettings,
/// Slideshow slide layout (margins, options, backdrop).
slide_layout: crate::slide::SlideSettings,
+ /// Slideshow overlays.
+ slide_overlays: crate::slide_overlay::OverlaySettings,
}
fn presets_json(s: &Session) -> String {
@@ -346,6 +348,7 @@ impl Session {
self.cache_mb = prefs.cache_mb;
self.slideshow = prefs.slideshow.sanitized();
self.slide_layout = prefs.slide_layout.sanitized();
+ self.slide_overlays = prefs.slide_overlays.sanitized();
self.forget_local_days = prefs.forget_local_days.unwrap_or(lightcraft_catalog::DEFAULT_FORGET_DAYS);
self.smart_previews_dir = prefs.smart_previews_dir.filter(|_| on_disk).map(PathBuf::from);
if let Some(d) = &self.smart_previews_dir {
@@ -584,6 +587,7 @@ impl Session {
forget_local_days: Some(self.forget_local_days),
slideshow: self.slideshow.clone(),
slide_layout: self.slide_layout.clone(),
+ slide_overlays: self.slide_overlays.clone(),
})
.unwrap_or_default();
let Some(lib) = self.library.as_mut() else { return Ok(()) };
diff --git a/crates/engine/src/rename.rs b/crates/engine/src/rename.rs
index 259d51fcd..31a2696e0 100644
--- a/crates/engine/src/rename.rs
+++ b/crates/engine/src/rename.rs
@@ -245,6 +245,19 @@ pub fn expand(template: &str, p: &Photo, seq: usize) -> String {
/// The template's tokens replaced for `p` (no extension added, nothing sanitized). A bare `{seq}`
/// is zero-padded to `seq_width` digits.
pub fn expand_tokens(template: &str, p: &Photo, seq: usize, seq_width: usize) -> String {
+ expand_tokens_with(template, p, seq, seq_width, &|_, _, _| None)
+}
+
+/// [`expand_tokens`] with more tokens: `extra(name, arg, tag)` (the name lower-cased, the text
+/// after `:`, the whole tag without braces) answers a token first; `None` leaves it to the rename
+/// tokens (and an unknown one stays as typed). Slideshow text overlays add their tokens this way.
+pub fn expand_tokens_with(
+ template: &str,
+ p: &Photo,
+ seq: usize,
+ seq_width: usize,
+ extra: &dyn Fn(&str, Option<&str>, &str) -> Option<String>,
+) -> String {
let (stem, ext) = split_ext(&p.file_name);
let mut out = String::new();
let mut rest = template;
@@ -257,31 +270,35 @@ pub fn expand_tokens(template: &str, p: &Photo, seq: usize, seq_width: usize) ->
};
let tok = &rest[i + 1..i + j];
let (name, arg) = tok.split_once(':').map(|(a, b)| (a, Some(b))).unwrap_or((tok, None));
- let v = match name.trim().to_ascii_lowercase().as_str() {
- "name" | "filename" => stem.to_string(),
- "num" => {
- let digits = stem.chars().rev().take_while(char::is_ascii_digit).count();
- stem[stem.len() - digits..].to_string()
- }
- "seq" | "n" => {
- let w: usize = arg.and_then(|a| a.parse().ok()).unwrap_or(seq_width).min(9);
- format!("{seq:0w$}")
- }
- "date" => format_date(p.date(), arg.unwrap_or("%Y%m%d")),
- "folder" => match &p.source {
- Source::File { path } => {
- Path::new(path).parent().and_then(Path::file_name).map(|f| f.to_string_lossy().to_string()).unwrap_or_default()
+ let lower = name.trim().to_ascii_lowercase();
+ let v = match extra(&lower, arg, tok) {
+ Some(v) => v,
+ None => match lower.as_str() {
+ "name" | "filename" => stem.to_string(),
+ "num" => {
+ let digits = stem.chars().rev().take_while(char::is_ascii_digit).count();
+ stem[stem.len() - digits..].to_string()
+ }
+ "seq" | "n" => {
+ let w: usize = arg.and_then(|a| a.parse().ok()).unwrap_or(seq_width).min(9);
+ format!("{seq:0w$}")
}
- Source::Demo { .. } => String::new(),
+ "date" => format_date(p.date(), arg.unwrap_or("%Y%m%d")),
+ "folder" => match &p.source {
+ Source::File { path } => {
+ Path::new(path).parent().and_then(Path::file_name).map(|f| f.to_string_lossy().to_string()).unwrap_or_default()
+ }
+ Source::Demo { .. } => String::new(),
+ },
+ "camera" => p.meta.camera.clone(),
+ "lens" => p.meta.lens.clone(),
+ "iso" => p.meta.iso.map(|v| v.to_string()).unwrap_or_default(),
+ "rating" => p.rating.to_string(),
+ "title" => p.meta.title.clone(),
+ "creator" => p.meta.creator.clone(),
+ "ext" => ext.to_string(),
+ _ => format!("{{{tok}}}"),
},
- "camera" => p.meta.camera.clone(),
- "lens" => p.meta.lens.clone(),
- "iso" => p.meta.iso.map(|v| v.to_string()).unwrap_or_default(),
- "rating" => p.rating.to_string(),
- "title" => p.meta.title.clone(),
- "creator" => p.meta.creator.clone(),
- "ext" => ext.to_string(),
- _ => format!("{{{tok}}}"),
};
out.push_str(&v);
rest = &rest[i + j + 1..];
diff --git a/crates/engine/src/slide.rs b/crates/engine/src/slide.rs
index cd487d7d8..ab252cf6d 100644
--- a/crates/engine/src/slide.rs
+++ b/crates/engine/src/slide.rs
@@ -1,6 +1,7 @@
//! Slideshow slides in the engine: the library's slide layout ([`SlideSettings`], Lightroom
-//! Classic's Layout, Options and Backdrop panels; the `slideshow.layout` command) and render jobs
-//! that compose a photo into its slide ([`SlideCompose`], [`crate::media::RenderJob::with_slide`]).
+//! Classic's Layout, Options and Backdrop panels; the `slideshow.layout` command), its overlays
+//! ([`crate::slide_overlay`], `slideshow.overlays`) and render jobs that compose a photo into its
+//! slide ([`SlideCompose`], [`crate::media::RenderJob::with_slide`]).
//!
//! The composer itself is `lightcraft-slideshow` (no UI, no catalog): playback, the Settings
//! preview and `slideshow.preview` all compose through it, so they draw the same pixels.
@@ -50,6 +51,8 @@ pub struct SlideCompose {
pub width: usize,
pub height: usize,
pub backdrop: Option<Backdrop>,
+ /// The overlays resolved for the slide's photo (`None`: none draw).
+ pub overlays: Option<Arc<crate::slide_overlay::SlideOverlays>>,
}
impl SlideCompose {
@@ -59,12 +62,19 @@ impl SlideCompose {
^ (self.width as u64).wrapping_mul(0x9e37_79b9_7f4a_7c15)
^ (self.height as u64).wrapping_mul(0xc2b2_ae3d_27d4_eb4f)
^ self.backdrop.as_ref().map_or(0, |b| b.job.key.rotate_left(29))
+ ^ self.overlays.as_ref().map_or(0, |o| o.key().rotate_left(43))
}
/// The slide showing `photo` (rendered at [`lightcraft_slideshow::photo_size`], or any size).
pub fn compose(&self, photo: &Rgba8) -> Rgba8 {
let bg = self.backdrop.as_ref().and_then(Backdrop::image);
- lightcraft_slideshow::compose(photo, bg.as_deref(), &self.settings, self.width, self.height)
+ let Some(o) = &self.overlays else {
+ return lightcraft_slideshow::compose(photo, bg.as_deref(), &self.settings, self.width, self.height);
+ };
+ let (mut img, l) =
+ lightcraft_slideshow::compose_with(photo, bg.as_deref(), &self.settings, self.width, self.height, &mut |img, l| o.draw_behind(img, l));
+ o.draw_front(&mut img, &l);
+ img
}
}
@@ -83,9 +93,16 @@ impl crate::Session {
Some(if a.is_finite() && a > 0.0 { a } else { 1.5 })
}
+ /// Does a slide show nothing but the photo fitted on black (the plain layout and no
+ /// overlays)? Playback then shows the photo's own render.
+ pub fn slides_plain(&self) -> bool {
+ self.slide_layout.is_plain() && !self.slide_overlays.any()
+ }
+
/// The composition of `settings` at `width × height`, with its background image's render job
- /// (the photo `settings.background_image` names, when it is in the catalog).
- pub fn slide_compose(&mut self, settings: &SlideSettings, width: usize, height: usize) -> Arc<SlideCompose> {
+ /// (the photo `settings.background_image` names, when it is in the catalog) and the library's
+ /// overlays resolved for `photo`.
+ pub fn slide_compose(&mut self, settings: &SlideSettings, width: usize, height: usize, photo: Option<PhotoId>) -> Arc<SlideCompose> {
let settings = settings.clone().sanitized();
let backdrop = settings.background_image.filter(|_| settings.background_opacity > 0.0).and_then(|bid| {
let id = PhotoId(bid);
@@ -96,7 +113,11 @@ impl crate::Session {
let job = self.render_job(id, w, h, false, true)?;
Some(Backdrop { photo: id, job: Box::new(job), cache: self.slide_backdrop.clone() })
});
- Arc::new(SlideCompose { settings, width, height, backdrop })
+ let overlays = self.slide_overlays.any().then(|| {
+ let p = photo.and_then(|id| self.catalog.photo(id));
+ Arc::new(crate::slide_overlay::SlideOverlays::resolve(&self.slide_overlays, p.map(|p| &**p)))
+ });
+ Arc::new(SlideCompose { settings, width, height, backdrop, overlays })
}
/// A render job whose result is photo `id`'s slide at `width × height` with the library's
@@ -126,7 +147,7 @@ impl crate::Session {
(w, h) = (((w as f64 * k).round() as usize).max(1), ((h as f64 * k).round() as usize).max(1));
}
let job = if view { self.loupe_job(id, w.max(8), h.max(8), true)? } else { self.render_job(id, w.max(8), h.max(8), false, true)? };
- let compose = self.slide_compose(settings, width, height);
+ let compose = self.slide_compose(settings, width, height, Some(id));
Some(job.with_slide(compose))
}
diff --git a/crates/engine/src/slide_overlay.rs b/crates/engine/src/slide_overlay.rs
new file mode 100644
index 000000000..8dc450c8b
--- /dev/null
+++ b/crates/engine/src/slide_overlay.rs
@@ -0,0 +1,1322 @@
+//! Slideshow overlays (Lightroom Classic's Slideshow ▸ Overlays panel): the identity plate (text
+//! or an image file), the photo's rating as stars, text overlays with tokens (file name, title,
+//! caption, capture date, exposure, camera, lens, rating…) and the export watermark.
+//! [`OverlaySettings`] is a library preference (`prefs.json`), edited with the
+//! `slideshow.overlays` command; [`SlideOverlays`] is those settings resolved for one photo (its
+//! texts expanded, its rating) and drawn onto the composed slide.
+//!
+//! **Where the drawing lives:** text needs the fonts (Inter plus the craft-fonts CJK fallbacks,
+//! [`crate::text`]) and tokens need the catalog's photo, both in the engine, so overlays are a
+//! second pass in the engine over `lightcraft_slideshow::compose_with`'s slide (its `behind` hook
+//! draws an identity plate set to "render behind image" before the photo). The composer stays a
+//! layout-and-pixels crate with no fonts and no catalog.
+//!
+//! **Resolution independence:** sizes and offsets are fractions of the slide's shorter side (also
+//! for overlays anchored to the photo), so a slide at any size has the same proportions. An
+//! overlay is placed at one of nine anchors of the slide or of the photo, moved by its offset
+//! (x right, y down) and kept on the slide.
+//!
+//! **Never crash:** settings are validated by [`OverlaySettings::merged`] and clamped by
+//! [`OverlaySettings::sanitized`]; text is cut at [`TEXT_MAX_CHARS`]; an unreadable identity
+//! plate image draws nothing (and `slideshow.overlays` reports it); unknown tokens stay as typed
+//! (as in rename and export file names) and are reported.
+
+use std::sync::Arc;
+
+use lightcraft_catalog::Photo;
+use lightcraft_raster::{Image, Plane, Rgba8};
+use lightcraft_slideshow::{Layout, Rect, hex, parse_color};
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value, json};
+
+use crate::export::{Anchor, Watermark};
+
+/// Smallest text, plate and star size (fraction of the slide's shorter side).
+pub const SIZE_MIN: f64 = 0.005;
+/// Largest text line height.
+pub const TEXT_SIZE_MAX: f64 = 0.3;
+/// Largest identity plate height.
+pub const PLATE_SIZE_MAX: f64 = 0.5;
+/// Largest star.
+pub const STAR_SIZE_MAX: f64 = 0.15;
+/// Largest offset either way (fraction of the shorter side).
+pub const OFFSET_MAX: f64 = 1.0;
+/// Longest shadow offset and radius (fractions of the shorter side).
+pub const SHADOW_OFFSET_MAX: f64 = 0.05;
+pub const SHADOW_RADIUS_MAX: f64 = 0.05;
+/// Most text overlays.
+pub const MAX_TEXTS: usize = 16;
+/// Longest overlay text or template (characters; longer is cut).
+pub const TEXT_MAX_CHARS: usize = 1000;
+
+/// What an overlay is anchored to.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum RelativeTo {
+ #[default]
+ Slide,
+ /// The visible photo.
+ Photo,
+}
+
+impl RelativeTo {
+ fn id(self) -> &'static str {
+ match self {
+ RelativeTo::Slide => "slide",
+ RelativeTo::Photo => "photo",
+ }
+ }
+}
+
+/// The nine anchors, in reading order (for pickers and tests).
+pub const ANCHORS: [Anchor; 9] = [
+ Anchor::TopLeft,
+ Anchor::Top,
+ Anchor::TopRight,
+ Anchor::Left,
+ Anchor::Center,
+ Anchor::Right,
+ Anchor::BottomLeft,
+ Anchor::Bottom,
+ Anchor::BottomRight,
+];
+
+/// An anchor's id (`topLeft`…).
+pub fn anchor_id(a: Anchor) -> &'static str {
+ match a {
+ Anchor::TopLeft => "topLeft",
+ Anchor::Top => "top",
+ Anchor::TopRight => "topRight",
+ Anchor::Left => "left",
+ Anchor::Center => "center",
+ Anchor::Right => "right",
+ Anchor::BottomLeft => "bottomLeft",
+ Anchor::Bottom => "bottom",
+ Anchor::BottomRight => "bottomRight",
+ }
+}
+
+/// Where an overlay goes: an anchor of the slide or the photo, and an offset from it.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Placement {
+ pub anchor: Anchor,
+ /// Fractions of the slide's shorter side, x to the right, y down.
+ pub offset_x: f64,
+ pub offset_y: f64,
+ pub relative_to: RelativeTo,
+}
+
+impl Default for Placement {
+ fn default() -> Self {
+ Placement { anchor: Anchor::BottomRight, offset_x: -0.03, offset_y: -0.03, relative_to: RelativeTo::Slide }
+ }
+}
+
+impl Placement {
+ fn sanitized(mut self) -> Self {
+ self.offset_x = clamp_or(self.offset_x, -OFFSET_MAX, OFFSET_MAX, 0.0);
+ self.offset_y = clamp_or(self.offset_y, -OFFSET_MAX, OFFSET_MAX, 0.0);
+ self
+ }
+
+ fn json(&self, o: &mut Map<String, Value>) {
+ o.insert("anchor".into(), json!(anchor_id(self.anchor)));
+ o.insert("offsetX".into(), json!(self.offset_x));
+ o.insert("offsetY".into(), json!(self.offset_y));
+ o.insert("relativeTo".into(), json!(self.relative_to.id()));
+ }
+
+ /// Apply a placement key; `false` when `k` isn't one.
+ fn merge(&mut self, ctx: &str, k: &str, v: &Value) -> Result<bool, String> {
+ match k {
+ "anchor" => {
+ self.anchor = serde_json::from_value(v.clone()).map_err(|_| {
+ format!("`{ctx}.anchor` must be one of topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight, not {v}")
+ })?
+ }
+ "offsetX" => self.offset_x = number(ctx, k, v)?,
+ "offsetY" => self.offset_y = number(ctx, k, v)?,
+ "relativeTo" => {
+ self.relative_to = match v.as_str() {
+ Some("slide") => RelativeTo::Slide,
+ Some("photo") => RelativeTo::Photo,
+ _ => return Err(format!("`{ctx}.relativeTo` must be \"slide\" or \"photo\", not {v}")),
+ }
+ }
+ _ => return Ok(false),
+ }
+ Ok(true)
+ }
+
+ /// The box of a `w × h` overlay on the slide `l`: at the anchor of the slide or the visible
+ /// photo, moved by the offset, then kept on the slide (when it fits).
+ pub fn place(&self, l: &Layout, w: f64, h: f64) -> Rect {
+ let c = match self.relative_to {
+ RelativeTo::Slide => l.slide,
+ RelativeTo::Photo => l.visible,
+ };
+ let short = l.slide.width().min(l.slide.height());
+ use Anchor::*;
+ let x = match self.anchor {
+ TopLeft | Left | BottomLeft => c.x0,
+ Top | Center | Bottom => (c.x0 + c.x1 - w) / 2.0,
+ TopRight | Right | BottomRight => c.x1 - w,
+ } + self.offset_x * short;
+ let y = match self.anchor {
+ TopLeft | Top | TopRight => c.y0,
+ Left | Center | Right => (c.y0 + c.y1 - h) / 2.0,
+ BottomLeft | Bottom | BottomRight => c.y1 - h,
+ } + self.offset_y * short;
+ let s = l.slide;
+ let fit = |v: f64, lo: f64, hi: f64, len: f64| if v.is_finite() { v.min(hi - len).max(lo) } else { lo };
+ let (x, y) = (fit(x, s.x0, s.x1, w), fit(y, s.y0, s.y1, h));
+ Rect { x0: x, y0: y, x1: x + w, y1: y + h }
+ }
+}
+
+/// A soft drop shadow under text.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct TextShadow {
+ pub on: bool,
+ pub opacity: f64,
+ /// Fraction of the slide's shorter side.
+ pub offset: f64,
+ /// Blur radius, fraction of the slide's shorter side.
+ pub radius: f64,
+ /// Degrees counter-clockwise from the right (−45 = down right).
+ pub angle: f64,
+}
+
+impl Default for TextShadow {
+ fn default() -> Self {
+ TextShadow { on: false, opacity: 0.6, offset: 0.004, radius: 0.004, angle: -45.0 }
+ }
+}
+
+/// The identity plate: a line of text, or an image file (PNG / JPEG…, its transparency kept).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct IdentityPlate {
+ pub enabled: bool,
+ pub text: String,
+ /// An image file drawn instead of the text (empty = the text).
+ pub image: String,
+ /// Height: the text's line height or the image's height, fraction of the shorter side.
+ pub size: f64,
+ pub color: [u8; 3],
+ pub opacity: f64,
+ pub place: Placement,
+ /// Draw it before the photo, so the photo covers it where they meet.
+ pub behind: bool,
+}
+
+impl Default for IdentityPlate {
+ fn default() -> Self {
+ IdentityPlate {
+ enabled: false,
+ text: "LightCraft".into(),
+ image: String::new(),
+ size: 0.05,
+ color: [255, 255, 255],
+ opacity: 0.8,
+ place: Placement { anchor: Anchor::TopLeft, offset_x: 0.03, offset_y: 0.03, relative_to: RelativeTo::Slide },
+ behind: false,
+ }
+ }
+}
+
+/// The photo's star rating, drawn as stars.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct RatingStars {
+ pub enabled: bool,
+ pub color: [u8; 3],
+ /// A star's height, fraction of the shorter side.
+ pub size: f64,
+ pub place: Placement,
+}
+
+impl Default for RatingStars {
+ fn default() -> Self {
+ RatingStars {
+ enabled: false,
+ color: [235, 235, 235],
+ size: 0.03,
+ place: Placement { anchor: Anchor::TopRight, offset_x: -0.015, offset_y: 0.015, relative_to: RelativeTo::Photo },
+ }
+ }
+}
+
+/// A text overlay: a template with tokens (`{title}`, `{caption}`, `{exposure}`…; see [`TOKENS`]).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct TextOverlay {
+ pub text: String,
+ /// Line height, fraction of the shorter side.
+ pub size: f64,
+ pub color: [u8; 3],
+ pub opacity: f64,
+ pub place: Placement,
+ pub shadow: TextShadow,
+}
+
+impl Default for TextOverlay {
+ fn default() -> Self {
+ TextOverlay {
+ text: "{file}".into(),
+ size: 0.03,
+ color: [255, 255, 255],
+ opacity: 0.9,
+ place: Placement { anchor: Anchor::Bottom, offset_x: 0.0, offset_y: -0.02, relative_to: RelativeTo::Slide },
+ shadow: TextShadow::default(),
+ }
+ }
+}
+
+/// Every overlay of a slide.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct OverlaySettings {
+ pub identity_plate: IdentityPlate,
+ pub rating_stars: RatingStars,
+ pub texts: Vec<TextOverlay>,
+ /// Draw [`Self::watermark`] on the photo.
+ pub show_watermark: bool,
+ /// The export watermark's settings (sizes relative to the photo, as in export).
+ pub watermark: Watermark,
+}
+
+/// Tokens text overlays add to the rename tokens ([`crate::rename::TOKENS`]): tag, meaning.
+pub const TOKENS: &[(&str, &str)] = &[
+ ("{file}", "File name with its extension"),
+ ("{caption}", "Caption metadata"),
+ ("{copyright}", "Copyright metadata"),
+ ("{exposure}", "Shutter speed and aperture (1/250 s at f/8)"),
+ ("{shutter}", "Shutter speed"),
+ ("{aperture}", "Aperture (f/8)"),
+ ("{focal}", "Focal length (50 mm)"),
+ ("{date}", "Capture date as YYYY-MM-DD (or {date:%d.%m.%Y} …)"),
+];
+
+fn clamp_or(v: f64, lo: f64, hi: f64, fallback: f64) -> f64 {
+ if v.is_finite() { v.clamp(lo, hi) } else { fallback }
+}
+
+fn wrap_angle(a: f64, fallback: f64) -> f64 {
+ if !a.is_finite() {
+ return fallback;
+ }
+ let w = (a + 180.0).rem_euclid(360.0) - 180.0;
+ if w <= -180.0 { 180.0 } else { w }
+}
+
+/// `s` cut at [`TEXT_MAX_CHARS`] characters.
+fn cut(s: &mut String) {
+ if let Some((i, _)) = s.char_indices().nth(TEXT_MAX_CHARS) {
+ s.truncate(i);
+ }
+}
+
+fn number(ctx: &str, k: &str, v: &Value) -> Result<f64, String> {
+ match v.as_f64() {
+ Some(x) if x.is_finite() => Ok(x),
+ _ => Err(format!("`{ctx}.{k}` must be a finite number, not {v}")),
+ }
+}
+
+fn boolean(ctx: &str, k: &str, v: &Value) -> Result<bool, String> {
+ v.as_bool().ok_or_else(|| format!("`{ctx}.{k}` must be true or false, not {v}"))
+}
+
+fn string(ctx: &str, k: &str, v: &Value) -> Result<String, String> {
+ let mut s = v.as_str().ok_or_else(|| format!("`{ctx}.{k}` must be text, not {v}"))?.to_string();
+ cut(&mut s);
+ Ok(s)
+}
+
+fn colour(ctx: &str, k: &str, v: &Value) -> Result<[u8; 3], String> {
+ parse_color(v).ok_or_else(|| format!("`{ctx}.{k}` must be \"#rrggbb\" or [r, g, b] (0–255), not {v}"))
+}
+
+fn object<'a>(ctx: &str, v: &'a Value) -> Result<&'a Map<String, Value>, String> {
+ v.as_object().ok_or_else(|| format!("`{ctx}` must be an object, not {v}"))
+}
+
+fn unknown(ctx: &str, k: &str, keys: &str) -> String {
+ format!("unknown key `{ctx}.{k}` ({keys})")
+}
+
+impl IdentityPlate {
+ fn sanitized(mut self) -> Self {
+ let d = IdentityPlate::default();
+ cut(&mut self.text);
+ cut(&mut self.image);
+ self.size = clamp_or(self.size, SIZE_MIN, PLATE_SIZE_MAX, d.size);
+ self.opacity = clamp_or(self.opacity, 0.0, 1.0, d.opacity);
+ self.place = self.place.sanitized();
+ self
+ }
+
+ fn to_json(&self) -> Value {
+ let mut o = Map::new();
+ o.insert("enabled".into(), json!(self.enabled));
+ o.insert("text".into(), json!(self.text));
+ o.insert("image".into(), json!(self.image));
+ o.insert("size".into(), json!(self.size));
+ o.insert("color".into(), json!(hex(self.color)));
+ o.insert("opacity".into(), json!(self.opacity));
+ self.place.json(&mut o);
+ o.insert("behind".into(), json!(self.behind));
+ Value::Object(o)
+ }
+
+ fn merge(&mut self, v: &Value) -> Result<(), String> {
+ const C: &str = "identityPlate";
+ for (k, v) in object(C, v)? {
+ if self.place.merge(C, k, v)? {
+ continue;
+ }
+ match k.as_str() {
+ "enabled" => self.enabled = boolean(C, k, v)?,
+ "text" => self.text = string(C, k, v)?,
+ "image" => self.image = string(C, k, v)?.trim().to_string(),
+ "size" => self.size = number(C, k, v)?,
+ "color" => self.color = colour(C, k, v)?,
+ "opacity" => self.opacity = number(C, k, v)?,
+ "behind" => self.behind = boolean(C, k, v)?,
+ _ => return Err(unknown(C, k, "enabled, text, image, size, color, opacity, anchor, offsetX, offsetY, relativeTo, behind")),
+ }
+ }
+ Ok(())
+ }
+}
+
+impl RatingStars {
+ fn sanitized(mut self) -> Self {
+ self.size = clamp_or(self.size, SIZE_MIN, STAR_SIZE_MAX, RatingStars::default().size);
+ self.place = self.place.sanitized();
+ self
+ }
+
+ fn to_json(&self) -> Value {
+ let mut o = Map::new();
+ o.insert("enabled".into(), json!(self.enabled));
+ o.insert("color".into(), json!(hex(self.color)));
+ o.insert("size".into(), json!(self.size));
+ self.place.json(&mut o);
+ Value::Object(o)
+ }
+
+ fn merge(&mut self, v: &Value) -> Result<(), String> {
+ const C: &str = "ratingStars";
+ for (k, v) in object(C, v)? {
+ if self.place.merge(C, k, v)? {
+ continue;
+ }
+ match k.as_str() {
+ "enabled" => self.enabled = boolean(C, k, v)?,
+ "color" => self.color = colour(C, k, v)?,
+ "size" => self.size = number(C, k, v)?,
+ _ => return Err(unknown(C, k, "enabled, color, size, anchor, offsetX, offsetY, relativeTo")),
+ }
+ }
+ Ok(())
+ }
+}
+
+impl TextOverlay {
+ fn sanitized(mut self) -> Self {
+ let d = TextOverlay::default();
+ cut(&mut self.text);
+ self.size = clamp_or(self.size, SIZE_MIN, TEXT_SIZE_MAX, d.size);
+ self.opacity = clamp_or(self.opacity, 0.0, 1.0, d.opacity);
+ self.place = self.place.sanitized();
+ let ds = TextShadow::default();
+ let sh = &mut self.shadow;
+ sh.opacity = clamp_or(sh.opacity, 0.0, 1.0, ds.opacity);
+ sh.offset = clamp_or(sh.offset, 0.0, SHADOW_OFFSET_MAX, ds.offset);
+ sh.radius = clamp_or(sh.radius, 0.0, SHADOW_RADIUS_MAX, ds.radius);
+ sh.angle = wrap_angle(sh.angle, ds.angle);
+ self
+ }
+
+ fn to_json(&self) -> Value {
+ let mut o = Map::new();
+ o.insert("text".into(), json!(self.text));
+ o.insert("size".into(), json!(self.size));
+ o.insert("color".into(), json!(hex(self.color)));
+ o.insert("opacity".into(), json!(self.opacity));
+ self.place.json(&mut o);
+ o.insert("shadow".into(), json!(self.shadow.on));
+ o.insert("shadowOpacity".into(), json!(self.shadow.opacity));
+ o.insert("shadowOffset".into(), json!(self.shadow.offset));
+ o.insert("shadowRadius".into(), json!(self.shadow.radius));
+ o.insert("shadowAngle".into(), json!(self.shadow.angle));
+ Value::Object(o)
+ }
+
+ fn merge(&mut self, ctx: &str, v: &Value) -> Result<(), String> {
+ for (k, v) in object(ctx, v)? {
+ if self.place.merge(ctx, k, v)? {
+ continue;
+ }
+ match k.as_str() {
+ "text" => self.text = string(ctx, k, v)?,
+ "size" => self.size = number(ctx, k, v)?,
+ "color" => self.color = colour(ctx, k, v)?,
+ "opacity" => self.opacity = number(ctx, k, v)?,
+ "shadow" => self.shadow.on = boolean(ctx, k, v)?,
+ "shadowOpacity" => self.shadow.opacity = number(ctx, k, v)?,
+ "shadowOffset" => self.shadow.offset = number(ctx, k, v)?,
+ "shadowRadius" => self.shadow.radius = number(ctx, k, v)?,
+ "shadowAngle" => self.shadow.angle = number(ctx, k, v)?,
+ _ => {
+ return Err(unknown(
+ ctx,
+ k,
+ "text, size, color, opacity, anchor, offsetX, offsetY, relativeTo, shadow, shadowOpacity, shadowOffset, shadowRadius, shadowAngle",
+ ));
+ }
+ }
+ }
+ Ok(())
+ }
+}
+
+/// The keys [`OverlaySettings::merged`] takes.
+const KEYS: &str = "identityPlate, ratingStars, texts, addText, removeText, showWatermark, watermark";
+
+impl OverlaySettings {
+ /// Every value in range (non-finite numbers take the defaults), at most [`MAX_TEXTS`] texts.
+ pub fn sanitized(mut self) -> Self {
+ self.identity_plate = self.identity_plate.sanitized();
+ self.rating_stars = self.rating_stars.sanitized();
+ self.texts.truncate(MAX_TEXTS);
+ self.texts = self.texts.into_iter().map(TextOverlay::sanitized).collect();
+ let d = Watermark::default();
+ let w = &mut self.watermark;
+ let f = |v: f32, lo: f32, hi: f32, fb: f32| if v.is_finite() { v.clamp(lo, hi) } else { fb };
+ w.size = f(w.size, 0.005, 0.5, d.size);
+ w.opacity = f(w.opacity, 0.0, 1.0, d.opacity);
+ w.inset = f(w.inset, 0.0, 0.4, d.inset);
+ w.image_width = f(w.image_width, 0.01, 1.0, d.image_width);
+ cut(&mut w.text);
+ w.target = None;
+ self
+ }
+
+ /// Does any overlay draw (on some photo)?
+ pub fn any(&self) -> bool {
+ let p = &self.identity_plate;
+ (p.enabled && p.opacity > 0.0 && (!p.text.trim().is_empty() || !p.image.trim().is_empty()))
+ || self.rating_stars.enabled
+ || self.texts.iter().any(|t| t.opacity > 0.0 && !t.text.trim().is_empty())
+ || (self.show_watermark && (!self.watermark.text.trim().is_empty() || !self.watermark.image.trim().is_empty()))
+ }
+
+ pub fn to_json(&self) -> Value {
+ let wm = serde_json::to_value(&self.watermark).unwrap_or(Value::Null);
+ json!({
+ "identityPlate": self.identity_plate.to_json(),
+ "ratingStars": self.rating_stars.to_json(),
+ "texts": self.texts.iter().map(TextOverlay::to_json).collect::<Vec<_>>(),
+ "showWatermark": self.show_watermark,
+ "watermark": wm,
+ })
+ }
+
+ /// These settings with the keys `p` names changed, validated and clamped; a wrong type or an
+ /// unknown key is an error and nothing changes. `texts` replaces the list (each entry merged
+ /// onto the one at its index, or a new default text); `addText` appends one (an object, `{}`
+ /// for the default); `removeText` removes the one at an index; `watermark` takes the export
+ /// watermark's keys (or text alone) merged onto the current one.
+ pub fn merged(&self, p: &Value) -> Result<Self, String> {
+ let Some(obj) = p.as_object() else { return Err("parameters must be an object".into()) };
+ let mut s = self.clone();
+ for (k, v) in obj {
+ match k.as_str() {
+ "identityPlate" => s.identity_plate.merge(v)?,
+ "ratingStars" => s.rating_stars.merge(v)?,
+ "texts" => {
+ let list = v.as_array().ok_or_else(|| format!("`texts` must be a list of text overlays, not {v}"))?;
+ if list.len() > MAX_TEXTS {
+ return Err(format!("at most {MAX_TEXTS} text overlays, not {}", list.len()));
+ }
+ let mut next = Vec::with_capacity(list.len());
+ for (i, item) in list.iter().enumerate() {
+ let mut t = s.texts.get(i).cloned().unwrap_or_default();
+ t.merge(&format!("texts[{i}]"), item)?;
+ next.push(t);
+ }
+ s.texts = next;
+ }
+ "addText" => {
+ if s.texts.len() >= MAX_TEXTS {
+ return Err(format!("at most {MAX_TEXTS} text overlays"));
+ }
+ let mut t = TextOverlay::default();
+ t.merge("addText", v)?;
+ s.texts.push(t);
+ }
+ "removeText" => {
+ let i = v.as_u64().ok_or_else(|| format!("`removeText` must be the index of a text overlay, not {v}"))?;
+ let i = usize::try_from(i).ok().filter(|i| *i < s.texts.len()).ok_or_else(|| format!("no text overlay {i}"))?;
+ s.texts.remove(i);
+ }
+ "showWatermark" => s.show_watermark = boolean("", k, v).map_err(|_| format!("`showWatermark` must be true or false, not {v}"))?,
+ "watermark" => {
+ crate::export::ExportOptions::validate_watermark("slideshow.overlays", v).map_err(|e| e.to_string())?;
+ s.watermark = match v {
+ Value::String(t) => Watermark { text: t.clone(), ..s.watermark.clone() },
+ _ => {
+ let mut cur = serde_json::to_value(&s.watermark).map_err(|e| e.to_string())?;
+ if let (Some(c), Some(o)) = (cur.as_object_mut(), v.as_object()) {
+ for (k, v) in o.iter().filter(|(_, v)| !v.is_null()) {
+ c.insert(k.clone(), v.clone());
+ }
+ }
+ serde_json::from_value(cur).map_err(|e| format!("`watermark`: {e}"))?
+ }
+ };
+ }
+ other => return Err(format!("unknown setting `{other}` ({KEYS})")),
+ }
+ }
+ Ok(s.sanitized())
+ }
+
+ /// A hash of the settings (for render keys). Stable within a run.
+ pub fn pixel_key(&self) -> u64 {
+ use std::hash::{Hash, Hasher};
+ let mut h = std::collections::hash_map::DefaultHasher::new();
+ self.clone().sanitized().to_json().to_string().hash(&mut h);
+ h.finish()
+ }
+
+ /// Problems worth telling the user about: an identity plate image that can't be read, tags in
+ /// text overlays that aren't tokens (they show as typed).
+ pub fn warnings(&self) -> Vec<String> {
+ let mut out = Vec::new();
+ let p = &self.identity_plate;
+ if p.enabled && !p.image.trim().is_empty() && crate::export::watermark_logo(p.image.trim()).is_none() {
+ out.push(format!("identity plate image {} can't be read; nothing is drawn", p.image.trim()));
+ }
+ for (i, t) in self.texts.iter().enumerate() {
+ for tag in unknown_tokens(&t.text) {
+ out.push(format!("text overlay {}: {tag} isn't a token and shows as typed", i + 1));
+ }
+ }
+ out
+ }
+}
+
+/// An exposure as "1/250 s at f/8" (either part alone when the other is unknown).
+fn exposure(p: &Photo) -> String {
+ let parts: Vec<String> = [shutter(p), aperture(p)].into_iter().filter(|s| !s.is_empty()).collect();
+ parts.join(" at ")
+}
+
+fn shutter(p: &Photo) -> String {
+ let s = p.meta.shutter.trim();
+ if s.is_empty() || s.ends_with('s') || s.ends_with('"') { s.to_string() } else { format!("{s} s") }
+}
+
+fn aperture(p: &Photo) -> String {
+ p.meta.aperture.filter(|a| a.is_finite() && *a > 0.0).map(|a| format!("f/{a:.1}").replace(".0", "")).unwrap_or_default()
+}
+
+/// The overlay tokens beyond the rename ones; `{seq}` has no meaning on a slide and stays as typed.
+fn overlay_token(p: &Photo, name: &str, arg: Option<&str>, tag: &str) -> Option<String> {
+ Some(match name {
+ "file" => p.file_name.clone(),
+ "caption" => p.meta.caption.clone(),
+ "copyright" => p.meta.copyright.clone(),
+ "exposure" => exposure(p),
+ "shutter" => shutter(p),
+ "aperture" => aperture(p),
+ "focal" => p.meta.focal_mm.filter(|f| f.is_finite() && *f > 0.0).map(|f| format!("{f:.0} mm")).unwrap_or_default(),
+ "date" if arg.is_none() => crate::rename::expand_tokens("{date:%Y-%m-%d}", p, 1, 1),
+ "seq" | "n" => format!("{{{tag}}}"),
+ _ => return None,
+ })
+}
+
+/// `template`'s tokens replaced for `p`: the rename tokens ([`crate::rename::expand_tokens`]) and
+/// [`TOKENS`]. Unknown tags stay as typed.
+pub fn expand(template: &str, p: &Photo) -> String {
+ crate::rename::expand_tokens_with(template, p, 1, 1, &|name, arg, tag| overlay_token(p, name, arg, tag))
+}
+
+/// The `{…}` tags in `template` that aren't tokens.
+pub fn unknown_tokens(template: &str) -> Vec<String> {
+ let p = crate::rename::sample_photo();
+ let mut out = Vec::new();
+ let mut rest = template;
+ while let Some(i) = rest.find('{') {
+ let Some(after) = rest.get(i..) else { break };
+ let Some(j) = after.find('}') else { break };
+ let Some(tag) = after.get(..j + 1) else { break };
+ if expand(tag, &p) == tag && !out.iter().any(|t| t == tag) {
+ out.push(tag.to_string());
+ }
+ rest = after.get(j + 1..).unwrap_or("");
+ }
+ out
+}
+
+/// What an overlay box is, for [`SlideOverlays::boxes`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+ IdentityPlate,
+ RatingStars,
+ /// The text overlay at this index.
+ Text(usize),
+ Watermark,
+}
+
+impl Kind {
+ pub fn id(&self) -> String {
+ match self {
+ Kind::IdentityPlate => "identityPlate".into(),
+ Kind::RatingStars => "ratingStars".into(),
+ Kind::Text(i) => format!("text{i}"),
+ Kind::Watermark => "watermark".into(),
+ }
+ }
+}
+
+/// The overlays of one photo's slide: the settings, its texts expanded, its rating.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SlideOverlays {
+ pub settings: OverlaySettings,
+ /// One per text overlay, tokens replaced.
+ pub texts: Vec<String>,
+ pub rating: u8,
+}
+
+/// Gap between stars, as a share of a star's size.
+const STAR_GAP: f64 = 0.2;
+
+impl SlideOverlays {
+ /// `settings` resolved for `photo` (`None`: no photo, so no tokens and no rating).
+ pub fn resolve(settings: &OverlaySettings, photo: Option<&Photo>) -> SlideOverlays {
+ let settings = settings.clone().sanitized();
+ let texts = settings.texts.iter().map(|t| photo.map(|p| expand(&t.text, p)).unwrap_or_else(|| t.text.clone())).collect();
+ SlideOverlays { settings, texts, rating: photo.map_or(0, |p| p.rating.min(5)) }
+ }
+
+ /// What makes the drawn overlays differ (for render keys).
+ pub fn key(&self) -> u64 {
+ use std::hash::{Hash, Hasher};
+ let mut h = std::collections::hash_map::DefaultHasher::new();
+ self.settings.pixel_key().hash(&mut h);
+ self.texts.hash(&mut h);
+ self.rating.hash(&mut h);
+ h.finish()
+ }
+
+ fn short(l: &Layout) -> f64 {
+ l.slide.width().min(l.slide.height()).max(1.0)
+ }
+
+ /// The identity plate's text layout, or its image scaled to its size.
+ fn plate(&self, l: &Layout) -> Option<PlateContent> {
+ let p = &self.settings.identity_plate;
+ if !p.enabled || p.opacity <= 0.0 {
+ return None;
+ }
+ let short = Self::short(l);
+ let px = (p.size * short).max(1.0);
+ if !p.image.trim().is_empty() {
+ let img = crate::export::watermark_logo(p.image.trim())?;
+ if img.width == 0 || img.height == 0 {
+ return None;
+ }
+ let h = px.round().clamp(1.0, l.slide.height().max(1.0));
+ let w = (h * img.width as f64 / img.height as f64).round().clamp(1.0, l.slide.width().max(1.0));
+ return Some(PlateContent::Image(img, w as usize, h as usize));
+ }
+ let text = p.text.trim();
+ crate::text::TextLayout::new(text, px as f32, false, crate::fonts::CRAFT_FONTS).map(PlateContent::Text)
+ }
+
+ fn text_layout(&self, i: usize, l: &Layout) -> Option<crate::text::TextLayout> {
+ let t = self.settings.texts.get(i)?;
+ let text = self.texts.get(i)?.trim();
+ if t.opacity <= 0.0 {
+ return None;
+ }
+ crate::text::TextLayout::new(text, (t.size * Self::short(l)).max(1.0) as f32, false, crate::fonts::CRAFT_FONTS)
+ }
+
+ fn stars_size(&self, l: &Layout) -> Option<(usize, f64)> {
+ let r = &self.settings.rating_stars;
+ let n = usize::from(self.rating.min(5));
+ (r.enabled && n > 0).then(|| (n, (r.size * Self::short(l)).max(2.0)))
+ }
+
+ /// Where each overlay goes on the slide `l` (the ones that draw something).
+ pub fn boxes(&self, l: &Layout) -> Vec<(Kind, Rect)> {
+ let mut out = Vec::new();
+ let s = &self.settings;
+ if let Some(c) = self.plate(l) {
+ let (w, h) = c.size();
+ out.push((Kind::IdentityPlate, s.identity_plate.place.place(l, w, h)));
+ }
+ if let Some((n, size)) = self.stars_size(l) {
+ let w = n as f64 * size + (n as f64 - 1.0) * size * STAR_GAP;
+ out.push((Kind::RatingStars, s.rating_stars.place.place(l, w, size)));
+ }
+ for (i, t) in s.texts.iter().enumerate() {
+ if let Some(tl) = self.text_layout(i, l) {
+ out.push((Kind::Text(i), t.place.place(l, tl.width as f64, tl.height as f64)));
+ }
+ }
+ if s.show_watermark && (!s.watermark.text.trim().is_empty() || !s.watermark.image.trim().is_empty()) {
+ out.push((Kind::Watermark, l.visible));
+ }
+ out
+ }
+
+ /// Draw the overlays drawn behind the photo (an identity plate with "render behind image").
+ pub fn draw_behind(&self, img: &mut Rgba8, l: &Layout) {
+ if self.settings.identity_plate.behind {
+ self.draw_plate(img, l);
+ }
+ }
+
+ /// Draw the overlays over the composed slide: the watermark on the photo, then the identity
+ /// plate (unless it is behind), the rating stars and the text overlays.
+ pub fn draw_front(&self, img: &mut Rgba8, l: &Layout) {
+ let s = &self.settings;
+ if s.show_watermark {
+ let (x0, y0, x1, y1) = pixels(&l.visible, img.width, img.height);
+ if x1 > x0 && y1 > y0 {
+ crate::export::draw_watermark_in(img, &s.watermark, x0, y0, x1 - x0, y1 - y0);
+ }
+ }
+ if !s.identity_plate.behind {
+ self.draw_plate(img, l);
+ }
+ if let Some((n, size)) = self.stars_size(l) {
+ let w = n as f64 * size + (n as f64 - 1.0) * size * STAR_GAP;
+ let b = s.rating_stars.place.place(l, w, size);
+ for i in 0..n {
+ let x = b.x0 + i as f64 * size * (1.0 + STAR_GAP);
+ star(img, x, b.y0, size, s.rating_stars.color);
+ }
+ }
+ for (i, t) in s.texts.iter().enumerate() {
+ let Some(tl) = self.text_layout(i, l) else { continue };
+ let b = t.place.place(l, tl.width as f64, tl.height as f64);
+ let short = Self::short(l);
+ if t.shadow.on && t.shadow.opacity > 0.0 {
+ let (d, a) = (t.shadow.offset * short, t.shadow.angle.to_radians());
+ let (dx, dy) = (d * a.cos(), -d * a.sin());
+ shadow(img, &tl, b.x0 + dx, b.y0 + dy, t.shadow.radius * short / 2.0, (t.shadow.opacity * t.opacity) as f32);
+ }
+ draw_text(img, &tl, b.x0, b.y0, t.color, t.opacity as f32);
+ }
+ }
+
+ fn draw_plate(&self, img: &mut Rgba8, l: &Layout) {
+ let p = &self.settings.identity_plate;
+ let Some(c) = self.plate(l) else { return };
+ let (w, h) = c.size();
+ let b = p.place.place(l, w, h);
+ match c {
+ PlateContent::Text(tl) => draw_text(img, &tl, b.x0, b.y0, p.color, p.opacity as f32),
+ PlateContent::Image(src, w, h) => {
+ if let Some(scaled) = scaled_graphic(p.image.trim(), &src, w, h) {
+ draw_graphic(img, &scaled, b.x0.round() as i64, b.y0.round() as i64, p.opacity as f32);
+ }
+ }
+ }
+ }
+}
+
+enum PlateContent {
+ Text(crate::text::TextLayout),
+ Image(Arc<Rgba8>, usize, usize),
+}
+
+impl PlateContent {
+ fn size(&self) -> (f64, f64) {
+ match self {
+ PlateContent::Text(t) => (t.width as f64, t.height as f64),
+ PlateContent::Image(_, w, h) => (*w as f64, *h as f64),
+ }
+ }
+}
+
+/// Whole pixel bounds of `r` clipped to `w × h`.
+fn pixels(r: &Rect, w: usize, h: usize) -> (usize, usize, usize, usize) {
+ let c = |v: f64, max: usize| if v.is_finite() { v.round().clamp(0.0, max as f64) as usize } else { 0 };
+ let (x0, y0) = (c(r.x0, w), c(r.y0, h));
+ (x0, y0, c(r.x1, w).max(x0), c(r.y1, h).max(y0))
+}
+
+/// Blend `c` into pixel (`x`, `y`) at `k` (0–1); outside the image does nothing.
+fn blend(img: &mut Rgba8, x: i64, y: i64, k: f32, c: [u8; 3]) {
+ if x < 0 || y < 0 || k <= 0.0 {
+ return;
+ }
+ let (x, y) = (x as usize, y as usize);
+ if x >= img.width || y >= img.height {
+ return;
+ }
+ let w = img.width;
+ if let Some(p) = img.data.get_mut(y * w + x) {
+ let k = k.min(1.0);
+ for i in 0..3 {
+ p[i] = (p[i] as f32 + (c[i] as f32 - p[i] as f32) * k).round().clamp(0.0, 255.0) as u8;
+ }
+ }
+}
+
+fn draw_text(img: &mut Rgba8, tl: &crate::text::TextLayout, x: f64, y: f64, c: [u8; 3], opacity: f32) {
+ let (w, h) = (img.width as f32, img.height as f32);
+ tl.draw_in(x as f32, y as f32, w, h, |gx, gy, cov| blend(img, i64::from(gx), i64::from(gy), cov * opacity, c));
+}
+
+/// A soft black shadow of the text at (`x`, `y`): its coverage blurred by `sigma` pixels. Only
+/// the part that can reach the image is rasterised.
+fn shadow(img: &mut Rgba8, tl: &crate::text::TextLayout, x: f64, y: f64, sigma: f64, opacity: f32) {
+ let pad = (sigma * 3.0).ceil().clamp(0.0, 512.0);
+ let (iw, ih) = (img.width as f64, img.height as f64);
+ let mx0 = (x - pad).floor().max(-pad);
+ let my0 = (y - pad).floor().max(-pad);
+ let mx1 = (x + tl.width as f64 + pad).ceil().min(iw + pad);
+ let my1 = (y + tl.height as f64 + pad).ceil().min(ih + pad);
+ if !(mx1 > mx0 && my1 > my0) || !mx0.is_finite() || !my0.is_finite() {
+ return;
+ }
+ let (w, h) = ((mx1 - mx0) as usize, (my1 - my0) as usize);
+ let mut mask = Plane::new(w, h);
+ tl.draw_in((x - mx0) as f32, (y - my0) as f32, w as f32, h as f32, |gx, gy, cov| {
+ if gx >= 0
+ && gy >= 0
+ && (gx as usize) < w
+ && (gy as usize) < h
+ && let Some(m) = mask.data.get_mut(gy as usize * w + gx as usize)
+ {
+ *m = (*m + cov).min(1.0);
+ }
+ });
+ let mask = if sigma > 0.3 { lightcraft_raster::blur::gaussian(&mask, sigma as f32) } else { mask };
+ let (ox, oy) = (mx0 as i64, my0 as i64);
+ for (i, k) in mask.data.iter().enumerate() {
+ if *k > 1e-3 {
+ blend(img, ox + (i % w) as i64, oy + (i / w) as i64, k * opacity, [0, 0, 0]);
+ }
+ }
+}
+
+/// The identity plate image scaled to its size, premultiplied: (file, its decoded image, w, h) →
+/// pixels, so the slides of a slideshow don't each scale a large logo again.
+type ScaledCache = std::sync::Mutex<Option<(String, usize, usize, usize, Arc<Image<[f32; 4]>>)>>;
+static SCALED: ScaledCache = std::sync::Mutex::new(None);
+
+/// `src` (decoded from `path`) scaled to `w × h` (premultiplied, so transparent edges stay clean).
+fn scaled_graphic(path: &str, src: &Arc<Rgba8>, w: usize, h: usize) -> Option<Arc<Image<[f32; 4]>>> {
+ if src.width == 0 || src.height == 0 || w == 0 || h == 0 || src.data.len() != src.width * src.height {
+ return None;
+ }
+ let id = Arc::as_ptr(src) as usize;
+ let mut cache = SCALED.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+ if let Some((p, i, cw, ch, img)) = cache.as_ref()
+ && (p.as_str(), *i, *cw, *ch) == (path, id, w, h)
+ {
+ return Some(img.clone());
+ }
+ let pre: Image<[f32; 4]> = Image::from_fn(src.width, src.height, |x, y| {
+ let p = src.get(x, y);
+ let a = p[3] as f32 / 255.0;
+ [p[0] as f32 * a, p[1] as f32 * a, p[2] as f32 * a, a]
+ });
+ let scaled = Arc::new(lightcraft_raster::resample::resize(&pre, w, h, lightcraft_raster::resample::Filter::Mitchell));
+ *cache = Some((path.to_string(), id, w, h, scaled.clone()));
+ Some(scaled)
+}
+
+/// The scaled graphic at (`x`, `y`), blended with its alpha × `opacity`.
+fn draw_graphic(img: &mut Rgba8, scaled: &Image<[f32; 4]>, x: i64, y: i64, opacity: f32) {
+ for yy in 0..scaled.height {
+ for xx in 0..scaled.width {
+ let [r, g, b, a] = scaled.get(xx, yy);
+ let a = a.clamp(0.0, 1.0);
+ if a <= 1e-4 {
+ continue;
+ }
+ let c = [r, g, b].map(|v| (v / a).round().clamp(0.0, 255.0) as u8);
+ blend(img, x + xx as i64, y + yy as i64, a * opacity, c);
+ }
+ }
+}
+
+/// The ten points of a five-pointed star in a `size` box at (`x`, `y`), point up.
+fn star_points(x: f64, y: f64, size: f64) -> [(f64, f64); 10] {
+ let r = size / 2.0;
+ // the star's height is r (1 + cos 36°); centre it vertically in the box
+ let cy = y + size / 2.0 + r * (1.0 - (36f64).to_radians().cos()) / 2.0;
+ let cx = x + size / 2.0;
+ let inner = r * 0.382;
+ let mut pts = [(0.0, 0.0); 10];
+ for (i, p) in pts.iter_mut().enumerate() {
+ let a = (90.0 + 36.0 * i as f64).to_radians();
+ let rr = if i % 2 == 0 { r } else { inner };
+ *p = (cx + rr * a.cos(), cy - rr * a.sin());
+ }
+ pts
+}
+
+/// A filled star: even-odd scanlines, four a pixel row, with exact horizontal coverage.
+fn star(img: &mut Rgba8, x: f64, y: f64, size: f64, c: [u8; 3]) {
+ if !(x.is_finite() && y.is_finite() && size.is_finite() && size > 0.0) {
+ return;
+ }
+ let pts = star_points(x, y, size);
+ let (x0, y0) = (x.floor() as i64, y.floor() as i64);
+ let n = size.ceil() as usize + 2;
+ let mut row = vec![0f32; n];
+ let mut xs: Vec<f64> = Vec::with_capacity(pts.len());
+ for py in y0..y0 + n as i64 {
+ row.fill(0.0);
+ for s in 0..4 {
+ let sy = py as f64 + (s as f64 + 0.5) / 4.0;
+ xs.clear();
+ for (i, &(xi, yi)) in pts.iter().enumerate() {
+ let Some(&(xj, yj)) = pts.get((i + pts.len() - 1) % pts.len()) else { continue };
+ if (yi > sy) != (yj > sy) {
+ xs.push((xj - xi) * (sy - yi) / (yj - yi) + xi);
+ }
+ }
+ xs.sort_by(f64::total_cmp);
+ for &[a, b] in xs.as_chunks::<2>().0 {
+ let (a, b) = (a - x0 as f64, b - x0 as f64);
+ let first = a.floor().max(0.0) as usize;
+ let last = (b.ceil().max(0.0) as usize).min(n);
+ for (i, v) in row.iter_mut().enumerate().take(last).skip(first) {
+ let cover = (b.min(i as f64 + 1.0) - a.max(i as f64)).max(0.0);
+ *v += cover as f32 / 4.0;
+ }
+ }
+ }
+ for (i, k) in row.iter().enumerate() {
+ if *k > 0.0 {
+ blend(img, x0 + i as i64, py, k.min(1.0), c);
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn layout(w: usize, h: usize) -> Layout {
+ lightcraft_slideshow::layout(&lightcraft_slideshow::SlideSettings::default().merged(&json!({"margins": 0.1})).unwrap(), 1.5, w, h)
+ }
+
+ fn photo() -> Photo {
+ let mut p = crate::rename::sample_photo();
+ p.rating = 3;
+ p.meta.caption = "Morning fog".into();
+ p.meta.shutter = "1/250".into();
+ p.meta.aperture = Some(8.0);
+ p.meta.focal_mm = Some(50.0);
+ p
+ }
+
+ #[test]
+ fn tokens_expand_like_the_rename_tokens_plus_slide_ones() {
+ let p = photo();
+ assert_eq!(expand("{caption}", &p), "Morning fog");
+ assert_eq!(expand("{exposure}", &p), "1/250 s at f/8");
+ assert_eq!(expand("{focal} · ISO {iso}", &p), format!("50 mm · ISO {}", p.meta.iso.unwrap_or_default()));
+ assert_eq!(expand("{file}", &p), p.file_name);
+ assert_eq!(expand("{name}", &p), crate::rename::expand_tokens("{name}", &p, 1, 1), "rename tokens work");
+ assert_eq!(expand("{date}", &p), crate::rename::expand_tokens("{date:%Y-%m-%d}", &p, 1, 1));
+ assert_eq!(expand("{rating}", &p), "3");
+ // unknown and slide-less tags show as typed, and are reported
+ assert_eq!(expand("{sparkle} {seq} {", &p), "{sparkle} {seq} {");
+ assert_eq!(unknown_tokens("{title} {sparkle} {seq} {é}"), vec!["{sparkle}", "{seq}", "{é}"]);
+ // a photo without metadata: empty values, no panic
+ let mut bare = p.clone();
+ bare.meta = Default::default();
+ assert_eq!(expand("[{exposure}|{camera}|{caption}|{focal}]", &bare), "[|||]");
+ }
+
+ #[test]
+ fn nine_anchors_place_inside_the_slide_with_their_offsets() {
+ let l = layout(1000, 600);
+ let short = 600.0;
+ for anchor in ANCHORS {
+ for relative_to in [RelativeTo::Slide, RelativeTo::Photo] {
+ let at = |ox: f64, oy: f64| Placement { anchor, offset_x: ox, offset_y: oy, relative_to }.place(&l, 100.0, 40.0);
+ let b = at(0.0, 0.0);
+ assert!(b.x0 >= 0.0 && b.y0 >= 0.0 && b.x1 <= 1000.0 && b.y1 <= 600.0, "{anchor:?} {relative_to:?}: {b:?}");
+ assert_eq!((b.width(), b.height()), (100.0, 40.0));
+ let c = if relative_to == RelativeTo::Slide { l.slide } else { l.visible };
+ let (cx, cy) = ((b.x0 + b.x1) / 2.0, (b.y0 + b.y1) / 2.0);
+ let id = anchor_id(anchor);
+ let want_x = if id.ends_with("eft") {
+ c.x0 + 50.0
+ } else if id.ends_with("ight") {
+ c.x1 - 50.0
+ } else {
+ (c.x0 + c.x1) / 2.0
+ };
+ let want_y = if id.starts_with("top") {
+ c.y0 + 20.0
+ } else if id.starts_with("bottom") {
+ c.y1 - 20.0
+ } else {
+ (c.y0 + c.y1) / 2.0
+ };
+ assert!((cx - want_x).abs() < 1e-9 && (cy - want_y).abs() < 1e-9, "{id} {relative_to:?}: {b:?}");
+ // an inward offset moves it by that share of the shorter side
+ let (sx, sy) = (if id.ends_with("ight") { -0.02 } else { 0.02 }, if id.starts_with("bottom") { -0.03 } else { 0.03 });
+ let m = at(sx, sy);
+ assert!((m.x0 - b.x0 - sx * short).abs() < 1e-9 && (m.y0 - b.y0 - sy * short).abs() < 1e-9, "{id}: {m:?}");
+ }
+ }
+ // pushed off the slide: kept on it
+ let b = Placement { anchor: Anchor::BottomRight, offset_x: 0.5, offset_y: 0.5, relative_to: RelativeTo::Slide }.place(&l, 100.0, 40.0);
+ assert_eq!((b.x1, b.y1), (1000.0, 600.0));
+ }
+
+ fn blank(w: usize, h: usize) -> Rgba8 {
+ Image::filled(w, h, [0, 0, 0, 255])
+ }
+
+ fn lit(img: &Rgba8, r: &Rect, min: u8) -> usize {
+ let (x0, y0, x1, y1) = pixels(r, img.width, img.height);
+ (y0..y1).flat_map(|y| (x0..x1).map(move |x| (x, y))).filter(|&(x, y)| img.get(x, y)[1] >= min).count()
+ }
+
+ #[test]
+ fn rating_stars_count_matches_the_rating() {
+ let l = layout(800, 500);
+ let s = OverlaySettings::default().merged(&json!({"ratingStars": {"enabled": true, "color": "#00ff00", "size": 0.05}})).unwrap();
+ let mut p = photo();
+ let mut widths = Vec::new();
+ for rating in 0..=5u8 {
+ p.rating = rating;
+ let o = SlideOverlays::resolve(&s, Some(&p));
+ let boxes = o.boxes(&l);
+ let mut img = blank(800, 500);
+ o.draw_front(&mut img, &l);
+ let Some((_, b)) = boxes.iter().find(|(k, _)| *k == Kind::RatingStars) else {
+ assert_eq!(rating, 0, "no stars only for an unrated photo");
+ assert_eq!(lit(&img, &l.slide, 1), 0);
+ continue;
+ };
+ widths.push(b.width());
+ // count the stars: separate runs of lit columns along the box's middle row
+ let y = ((b.y0 + b.y1) / 2.0) as usize;
+ let mut runs = 0;
+ let mut was = false;
+ for x in 0..800 {
+ let on = img.get(x, y)[1] > 128;
+ runs += usize::from(on && !was);
+ was = on;
+ }
+ assert_eq!(runs, usize::from(rating), "{rating} stars");
+ }
+ assert!(widths.windows(2).all(|w| w[1] > w[0]));
+ }
+
+ #[test]
+ fn text_with_a_shadow_draws_the_shadow_at_its_angle() {
+ let l = layout(800, 500);
+ let s = OverlaySettings::default()
+ .merged(
+ &json!({"texts": [{"text": "Shadow", "size": 0.08, "color": "#ffffff", "opacity": 1, "anchor": "center", "offsetX": 0, "offsetY": 0,
+ "shadow": true, "shadowOpacity": 1, "shadowOffset": 0.02, "shadowRadius": 0, "shadowAngle": -90}]}),
+ )
+ .unwrap();
+ let o = SlideOverlays::resolve(&s, Some(&photo()));
+ let b = o.boxes(&l)[0].1;
+ let mut grey = Image::filled(800, 500, [128, 128, 128, 255]);
+ o.draw_front(&mut grey, &l);
+ // straight down by 10 px: dark pixels below the text box's glyphs, none above
+ let dark = |r: Rect| {
+ let (x0, y0, x1, y1) = pixels(&r, 800, 500);
+ (y0..y1).flat_map(|y| (x0..x1).map(move |x| (x, y))).filter(|&(x, y)| grey.get(x, y)[0] < 40).count()
+ };
+ assert!(dark(Rect { y0: b.y1 - 2.0, y1: b.y1 + 10.0, ..b }) > 20, "the shadow falls below");
+ assert_eq!(dark(Rect { y0: b.y0 - 12.0, y1: b.y0, ..b }), 0, "none above");
+ // without the shadow: no dark pixels at all
+ let off = s.merged(&json!({"texts": [{"shadow": false}]})).unwrap();
+ let mut grey2 = Image::filled(800, 500, [128, 128, 128, 255]);
+ SlideOverlays::resolve(&off, Some(&photo())).draw_front(&mut grey2, &l);
+ assert!(grey2.data.iter().all(|p| p[0] >= 128));
+ }
+
+ #[test]
+ fn identity_plate_image_draws_at_its_opacity_and_a_missing_one_is_reported() {
+ let dir = std::env::temp_dir().join(format!("lc-plate-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let path = dir.join("plate.png");
+ let red = Image::filled(40, 20, [255u8, 0, 0, 255]);
+ let png = lightcraft_codecs::encode_png(&lightcraft_codecs::EncodeImage::rgba8(&red), &lightcraft_codecs::EncodeMeta::default()).unwrap();
+ std::fs::write(&path, png).unwrap();
+ let l = layout(800, 500);
+ let s = OverlaySettings::default()
+ .merged(&json!({"identityPlate": {"enabled": true, "image": path.to_string_lossy(), "size": 0.1, "opacity": 0.5, "anchor": "topLeft", "offsetX": 0, "offsetY": 0}}))
+ .unwrap();
+ assert!(s.warnings().is_empty());
+ let o = SlideOverlays::resolve(&s, None);
+ let b = o.boxes(&l)[0].1;
+ assert_eq!((b.x0, b.y0, b.width(), b.height()), (0.0, 0.0, 100.0, 50.0), "50 px high (10 % of 500), its aspect kept");
+ let mut img = blank(800, 500);
+ o.draw_front(&mut img, &l);
+ let p = img.get(50, 25);
+ assert!((p[0] as i32 - 128).abs() <= 2 && p[1] == 0, "half-opaque red over black: {p:?}");
+ assert_eq!(img.get(150, 25)[0], 0, "only inside its box");
+ // behind the image: the photo covers it
+ let behind = s.merged(&json!({"identityPlate": {"behind": true, "anchor": "center"}})).unwrap();
+ let photo_img = Image::filled(30, 20, [0u8, 0, 255, 255]);
+ let ob = SlideOverlays::resolve(&behind, None);
+ let (img, l2) =
+ lightcraft_slideshow::compose_with(&photo_img, None, &lightcraft_slideshow::SlideSettings::default(), 800, 500, &mut |i, l| {
+ ob.draw_behind(i, l)
+ });
+ let _ = l2;
+ assert_eq!(img.get(400, 250), [0, 0, 255, 255], "the photo is on top");
+ // a missing file: reported, nothing drawn, no panic
+ let gone = s.merged(&json!({"identityPlate": {"image": dir.join("nope.png").to_string_lossy()}})).unwrap();
+ assert_eq!(gone.warnings().len(), 1);
+ let mut img = blank(800, 500);
+ SlideOverlays::resolve(&gone, None).draw_front(&mut img, &l);
+ assert!(img.data.iter().all(|p| p[0] == 0));
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn overlays_are_resolution_independent() {
+ let s = OverlaySettings::default()
+ .merged(&json!({
+ "identityPlate": {"enabled": true, "text": "Studio", "size": 0.06},
+ "ratingStars": {"enabled": true, "size": 0.04},
+ "texts": [{"text": "{caption}", "size": 0.04, "anchor": "bottomLeft", "offsetX": 0.02, "offsetY": -0.02, "relativeTo": "photo"}],
+ }))
+ .unwrap();
+ let o = SlideOverlays::resolve(&s, Some(&photo()));
+ let (a, b) = (o.boxes(&layout(800, 500)), o.boxes(&layout(1600, 1000)));
+ assert_eq!(a.len(), 3);
+ for ((ka, ra), (kb, rb)) in a.iter().zip(&b) {
+ assert_eq!(ka, kb);
+ for (va, vb) in [(ra.x0, rb.x0), (ra.y0, rb.y0), (ra.x1, rb.x1), (ra.y1, rb.y1)] {
+ assert!((va * 2.0 - vb).abs() <= 4.0, "{ka:?}: {ra:?} vs {rb:?}");
+ }
+ }
+ }
+
+ #[test]
+ fn hostile_settings_are_refused_or_clamped_and_never_panic() {
+ let d = OverlaySettings::default();
+ for bad in [
+ json!({"identityPlate": {"size": "big"}}),
+ json!({"identityPlate": {"anchor": "middle"}}),
+ json!({"identityPlate": 3}),
+ json!({"ratingStars": {"color": "#zzzzzz"}}),
+ json!({"texts": {"text": "a"}}),
+ json!({"texts": [{"relativeTo": "page"}]}),
+ json!({"texts": [{"sparkle": 1}]}),
+ json!({"texts": vec![json!({}); MAX_TEXTS + 1]}),
+ json!({"removeText": 0}),
+ json!({"removeText": -1}),
+ json!({"watermark": {"size": 9}}),
+ json!({"watermark": 5}),
+ json!({"showWatermark": "yes"}),
+ json!({"glitter": true}),
+ json!([1]),
+ ] {
+ assert!(d.merged(&bad).is_err(), "{bad}");
+ }
+ let s = d
+ .merged(&json!({"identityPlate": {"size": 1e300, "opacity": -3, "offsetX": -1e9}, "ratingStars": {"size": 0}, "addText": {"size": -1, "shadowAngle": 900, "shadowRadius": 7}}))
+ .unwrap();
+ assert_eq!((s.identity_plate.size, s.identity_plate.opacity, s.identity_plate.place.offset_x), (PLATE_SIZE_MAX, 0.0, -OFFSET_MAX));
+ assert_eq!(s.rating_stars.size, SIZE_MIN);
+ assert_eq!((s.texts[0].size, s.texts[0].shadow.angle, s.texts[0].shadow.radius), (SIZE_MIN, 180.0, SHADOW_RADIUS_MAX));
+ assert!(d.merged(&json!({"removeText": 0})).is_err());
+ assert!(s.merged(&json!({"removeText": 0})).unwrap().texts.is_empty());
+ // round trips (command JSON and prefs.json)
+ assert_eq!(d.merged(&s.to_json()).unwrap(), s);
+ let back: OverlaySettings = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+ assert_eq!(back, s);
+ // NaN / ∞ from a hand-edited prefs file
+ let mut wild = s.clone();
+ wild.identity_plate.size = f64::NAN;
+ wild.texts[0].place.offset_y = f64::INFINITY;
+ wild.watermark.size = f32::NAN;
+ let w = wild.sanitized();
+ assert_eq!(
+ (w.identity_plate.size, w.texts[0].place.offset_y, w.watermark.size),
+ (IdentityPlate::default().size, 0.0, Watermark::default().size)
+ );
+ // drawing hostile text at every size: empty, huge, CJK, RTL, control characters
+ let huge = "W".repeat(50_000);
+ for text in ["", " ", "\n\n", huge.as_str(), "日本語のテキスト", "שלום עולם", "مرحبا", "a\u{0}b\u{7}c\r\n", "{caption}{"]
+ {
+ let s = d
+ .merged(&json!({"identityPlate": {"enabled": true, "text": text, "size": PLATE_SIZE_MAX}, "ratingStars": {"enabled": true}, "addText": {"text": text, "size": TEXT_SIZE_MAX, "shadow": true, "shadowRadius": SHADOW_RADIUS_MAX}, "showWatermark": true, "watermark": text}))
+ .unwrap();
+ assert!(s.identity_plate.text.chars().count() <= TEXT_MAX_CHARS);
+ let mut bare = photo();
+ bare.meta = Default::default();
+ for (w, h) in [(1, 1), (17, 9), (320, 200)] {
+ let l = lightcraft_slideshow::layout(&lightcraft_slideshow::SlideSettings::default(), f64::NAN, w, h);
+ let o = SlideOverlays::resolve(&s, Some(&bare));
+ let mut img = blank(l.slide.width() as usize, l.slide.height() as usize);
+ o.draw_behind(&mut img, &l);
+ o.draw_front(&mut img, &l);
+ for (_, b) in o.boxes(&l) {
+ assert!(b.x0.is_finite() && b.y1.is_finite());
+ }
+ }
+ }
+ }
+
+ /// Huge text and stars on a big slide cost what shows: glyphs off the slide aren't rasterised.
+ #[test]
+ fn huge_overlays_on_a_big_slide_stay_cheap() {
+ let long = "Wide ".repeat(400);
+ let s = OverlaySettings::default()
+ .merged(&json!({
+ "ratingStars": {"enabled": true, "size": STAR_SIZE_MAX},
+ "addText": {"text": long, "size": TEXT_SIZE_MAX, "shadow": true, "shadowRadius": SHADOW_RADIUS_MAX, "anchor": "topLeft", "offsetX": 0, "offsetY": 0},
+ }))
+ .unwrap();
+ let mut p = photo();
+ p.rating = 5;
+ let l = lightcraft_slideshow::layout(&lightcraft_slideshow::SlideSettings::default(), 1.5, 4000, 2500);
+ let mut img = blank(4000, 2500);
+ let t = std::time::Instant::now();
+ SlideOverlays::resolve(&s, Some(&p)).draw_front(&mut img, &l);
+ assert!(t.elapsed().as_secs_f64() < 20.0, "{:?}", t.elapsed());
+ assert!(img.get(100, 300)[0] > 0, "the text's start shows");
+ }
+
+ /// CJK text draws with the craft-fonts faces (skips without them).
+ #[test]
+ fn cjk_text_uses_the_craft_fonts() {
+ if crate::fonts::cjk(crate::fonts::CRAFT_FONTS).next().is_none() {
+ eprintln!("skipped: built without craft-fonts (CRAFT_FONTS_DIR)");
+ return;
+ }
+ let cjk = crate::text::TextLayout::new("日本語", 40.0, false, crate::fonts::CRAFT_FONTS).unwrap();
+ let tofu = crate::text::TextLayout::new("日本語", 40.0, false, &[]).unwrap();
+ let count = |t: &crate::text::TextLayout| {
+ let mut n = 0usize;
+ t.draw(0.0, 0.0, |_, _, c| n += usize::from(c > 0.5));
+ n
+ };
+ assert_ne!(count(&cjk), count(&tofu), "real glyphs, not missing-glyph boxes");
+ }
+}
diff --git a/crates/engine/src/tests_slide.rs b/crates/engine/src/tests_slide.rs
index 84a8b5274..3e41f16ee 100644
--- a/crates/engine/src/tests_slide.rs
+++ b/crates/engine/src/tests_slide.rs
@@ -137,3 +137,93 @@ fn a_background_image_and_the_slide_key() {
let img = s.slide_now(&gone, photos[0], 320, 200).unwrap();
assert_eq!(img.get(3, 3), [255, 0, 0, 255]);
}
+
+#[test]
+fn slide_overlays_are_validated_and_persist_with_the_library() {
+ let lib = temp_dir("overlays");
+ {
+ let mut s = Session::new().with_fs();
+ s.open_library(&lib, false).unwrap();
+ let r = s.execute("slideshow.overlays", &json!({})).unwrap();
+ assert_eq!(r["identityPlate"]["enabled"], false, "defaults: {r}");
+ assert_eq!(r["texts"], json!([]));
+ assert!(s.slides_plain());
+ let r = s
+ .execute(
+ "slideshow.overlays",
+ &json!({"identityPlate": {"enabled": true, "text": "Studio Nord"}, "ratingStars": {"enabled": true}, "addText": {"text": "{caption} {bogus}"}, "showWatermark": true, "watermark": "© Ann"}),
+ )
+ .unwrap();
+ assert_eq!(r["texts"].as_array().map(Vec::len), Some(1));
+ assert_eq!(r["watermark"]["text"], "© Ann");
+ assert_eq!(r["warnings"].as_array().map(Vec::len), Some(1), "the unknown token is reported: {r}");
+ assert!(!s.slides_plain(), "overlays make playback compose its slides");
+ // a bad value changes nothing (the good keys beside it included)
+ for bad in
+ [json!({"identityPlate": {"size": "big"}, "showWatermark": false}), json!({"texts": [{"anchor": "nowhere"}]}), json!({"removeText": 5})]
+ {
+ assert!(s.execute("slideshow.overlays", &bad).is_err(), "{bad}");
+ }
+ assert!(s.slide_overlays.show_watermark);
+ drop(s);
+ }
+ let mut s = Session::new().with_fs();
+ s.open_library(&lib, false).unwrap();
+ let r = s.execute("slideshow.overlays", &json!({})).unwrap();
+ assert_eq!((r["identityPlate"]["text"].as_str(), r["texts"][0]["text"].as_str()), (Some("Studio Nord"), Some("{caption} {bogus}")));
+ // the layout beside it is untouched by an overlay change
+ let before = s.slide_layout.clone();
+ s.execute("slideshow.overlays", &json!({"removeText": 0})).unwrap();
+ assert_eq!(s.slide_layout, before);
+ drop(s);
+ // hand-edited values out of range are clamped when the library opens
+ std::fs::write(lib.join("prefs.json"), r#"{"slideOverlays": {"identityPlate": {"size": 1e9, "opacity": -2}, "texts": [{"size": 1e300}]}}"#)
+ .unwrap();
+ let mut s = Session::new().with_fs();
+ s.open_library(&lib, false).unwrap();
+ assert_eq!((s.slide_overlays.identity_plate.size, s.slide_overlays.identity_plate.opacity), (crate::slide_overlay::PLATE_SIZE_MAX, 0.0));
+ assert_eq!(s.slide_overlays.texts[0].size, crate::slide_overlay::TEXT_SIZE_MAX);
+ drop(s);
+ let _ = std::fs::remove_dir_all(&lib);
+}
+
+#[test]
+fn slide_preview_draws_the_overlays() {
+ let mut s = Session::with_demo();
+ let photos = s.visible_cloned();
+ s.execute("library.select", &json!({"ids": [photos[0].0]})).unwrap();
+ s.execute("photo.rate", &json!({"rating": 4, "ids": [photos[0].0]})).unwrap();
+ s.execute("slideshow.layout", &json!({"margins": 0.2, "backdropColor": "#000000"})).unwrap();
+ let before = s.slide_job(photos[0], 320, 200, None).unwrap().key;
+ let plain = s.slide_now(&s.slide_layout.clone(), photos[0], 640, 400).unwrap();
+ s.execute(
+ "slideshow.overlays",
+ &json!({
+ "identityPlate": {"enabled": true, "text": "LC", "size": 0.1, "color": "#00ff00", "opacity": 1, "anchor": "topLeft", "offsetX": 0.01, "offsetY": 0.01},
+ "ratingStars": {"enabled": true, "color": "#ffff00", "size": 0.05, "anchor": "bottomRight", "offsetX": -0.01, "offsetY": -0.01, "relativeTo": "slide"},
+ "addText": {"text": "{file}", "size": 0.05, "color": "#ffffff", "opacity": 1, "anchor": "bottom", "offsetX": 0, "offsetY": -0.01},
+ }),
+ )
+ .unwrap();
+ assert_ne!(s.slide_job(photos[0], 320, 200, None).unwrap().key, before, "overlays change the slide's render key");
+ let r = s.execute("slideshow.preview", &json!({"width": 640, "height": 400})).unwrap();
+ let kinds: Vec<&str> = r["overlays"].as_array().unwrap().iter().filter_map(|o| o["kind"].as_str()).collect();
+ assert_eq!(kinds, ["identityPlate", "ratingStars", "text0"]);
+ let img = s.slide_now(&s.slide_layout.clone(), photos[0], 640, 400).unwrap();
+ let count = |img: &lightcraft_raster::Rgba8, b: &serde_json::Value, want: fn([u8; 4]) -> bool| {
+ let v: Vec<usize> = (0..4).map(|i| b[i].as_f64().unwrap() as usize).collect();
+ (v[1]..v[3]).flat_map(|y| (v[0]..v[2]).map(move |x| (x, y))).filter(|&(x, y)| want(img.get(x, y))).count()
+ };
+ for (i, (kind, want)) in [
+ ("identityPlate", (|p: [u8; 4]| p[1] > 200 && p[0] < 60) as fn([u8; 4]) -> bool),
+ ("ratingStars", |p| p[0] > 200 && p[1] > 200 && p[2] < 60),
+ ("text0", |p| p[0] > 200 && p[1] > 200 && p[2] > 200),
+ ]
+ .into_iter()
+ .enumerate()
+ {
+ let b = &r["overlays"][i]["box"];
+ assert!(count(&img, b, want) > 10, "{kind} is drawn in its box {b}");
+ assert_eq!(count(&plain, b, want), 0, "{kind}: not there without overlays");
+ }
+}
diff --git a/crates/engine/src/text.rs b/crates/engine/src/text.rs
new file mode 100644
index 000000000..4c22789b1
--- /dev/null
+++ b/crates/engine/src/text.rs
@@ -0,0 +1,207 @@
+//! Text drawing in pure Rust, shared by the export watermark and the slideshow overlays: Inter
+//! SemiBold (bundled) first, then the craft-fonts CJK faces as fallbacks ([`faces`]); glyph outlines
+//! from `ab_glyph`, vertical CJK cells shaped with `harfrust`. [`TextLayout`] lays a string out
+//! once (lines split at `\n`, kerning within a face) and reports its size, so callers can anchor
+//! it before drawing; drawing hands out per-pixel coverage, and the caller blends.
+//!
+//! RTL scripts are laid out in logical order without bidi reordering, and scripts no face covers
+//! draw as Inter's missing-glyph box: wrong-looking, never a crash.
+
+use ab_glyph::{Font, FontRef, Glyph, PxScale, ScaleFont, point};
+
+/// Inter SemiBold (OFL, see assets/ATTRIBUTION.md).
+pub static TEXT_FONT: &[u8] = include_bytes!("../../../assets/fonts/Inter-SemiBold.ttf");
+
+/// Most characters one layout draws (longer text is cut there), so hostile text stays cheap.
+pub const MAX_CHARS: usize = 4000;
+
+/// The text faces: Inter first, then the craft-fonts CJK faces (Mincho first, the watermark's
+/// serif look; then any other CJK face — drawn text has no UI language, so every CJK script is
+/// offered). Without craft-fonts that is Inter alone, and CJK characters draw as Inter's
+/// missing-glyph box.
+pub fn faces(craft: &'static [crate::fonts::CraftFont]) -> Vec<FontRef<'static>> {
+ let mut cjk: Vec<_> = crate::fonts::cjk(craft).collect();
+ cjk.sort_by_key(|f| !f.is_mincho());
+ std::iter::once(TEXT_FONT).chain(cjk.into_iter().map(|f| f.bytes)).filter_map(|bytes| FontRef::try_from_slice(bytes).ok()).collect()
+}
+
+/// Shape a whole grapheme in one cell. CJK uses vertical origins and forms; Latin stays upright.
+/// Unlike Unicode presentation-form characters, GSUB works with BIZ UD fonts too.
+pub fn cell_glyphs(font: &FontRef<'_>, data: &harfrust::ShaperData, text: &str, vertical: bool, px: f32, left: f32, top: f32) -> Option<Vec<Glyph>> {
+ let face = harfrust::FontRef::new(font.font_data()).ok()?;
+ let mut buf = harfrust::UnicodeBuffer::new();
+ buf.push_str(text);
+ buf.set_direction(if vertical { harfrust::Direction::TopToBottom } else { harfrust::Direction::LeftToRight });
+ buf.guess_segment_properties();
+ let shaped = data.shaper(&face).build().shape(buf, harfrust::ShapeOptions::new());
+ if shaped.glyph_infos().is_empty() {
+ return None;
+ }
+ let sf = font.as_scaled(px);
+ let (sx, sy) = (sf.h_scale_factor(), sf.v_scale_factor());
+ let advance_x = shaped.glyph_positions().iter().map(|p| p.x_advance as f32 * sx).sum::<f32>();
+ let advance_y = shaped.glyph_positions().iter().map(|p| -(p.y_advance as f32) * sy).sum::<f32>();
+ let (mut x, mut y) = if vertical { (left + px / 2.0, top + (px - advance_y) / 2.0) } else { (left + (px - advance_x) / 2.0, top + sf.ascent()) };
+ let mut glyphs = Vec::new();
+ for (info, pos) in shaped.glyph_infos().iter().zip(shaped.glyph_positions()) {
+ let gid = u16::try_from(info.glyph_id).ok().filter(|g| *g != 0)?;
+ let pen = point(x + pos.x_offset as f32 * sx, y - pos.y_offset as f32 * sy);
+ glyphs.push(ab_glyph::GlyphId(gid).with_scale_and_position(px, pen));
+ x += pos.x_advance as f32 * sx;
+ y -= pos.y_advance as f32 * sy;
+ }
+ Some(glyphs)
+}
+
+/// A string laid out at one size: its glyphs relative to the box's top-left corner and the box's
+/// size in pixels (lines are `px` apart; vertical text: columns `px` wide, right to left).
+pub struct TextLayout {
+ fonts: Vec<FontRef<'static>>,
+ /// (face, glyph, rotation centre for glyphs turned 90° in vertical text).
+ glyphs: Vec<(usize, Glyph, Option<(f32, f32)>)>,
+ pub width: f32,
+ pub height: f32,
+}
+
+impl TextLayout {
+ /// `text` (cut at [`MAX_CHARS`]) at `px` pixels a line; `None` when there is nothing to draw
+ /// (empty text, a non-finite or non-positive size).
+ pub fn new(text: &str, px: f32, vertical: bool, craft: &'static [crate::fonts::CraftFont]) -> Option<TextLayout> {
+ use unicode_segmentation::UnicodeSegmentation;
+ if text.is_empty() || !px.is_finite() || px <= 0.0 {
+ return None;
+ }
+ let text = match text.char_indices().nth(MAX_CHARS) {
+ Some((i, _)) => text.get(..i).unwrap_or(text),
+ None => text,
+ };
+ let fonts = faces(craft);
+ let latin = fonts.first()?.clone();
+ let vertical_data: Vec<_> = if vertical {
+ fonts.iter().map(|font| harfrust::FontRef::new(font.font_data()).ok().map(|face| harfrust::ShaperData::new(&face))).collect()
+ } else {
+ Vec::new()
+ };
+ let mut glyphs = Vec::new();
+ let mut x = 0.0f32;
+ let mut y = 0.0f32;
+ let mut tw = 0.0f32;
+ let mut prev = None;
+ let columns = text.split('\n').count();
+ let mut column = 0usize;
+ // Horizontal text keeps scalar layout and kerning; only vertical cells use graphemes.
+ let cells: Box<dyn Iterator<Item = &str>> =
+ if vertical { Box::new(text.graphemes(true)) } else { Box::new(text.char_indices().filter_map(|(i, c)| text.get(i..i + c.len_utf8()))) };
+ for cell in cells {
+ let Some(original) = cell.chars().next() else { continue };
+ if cell == "\n" || (vertical && cell == "\r\n") {
+ if vertical {
+ column = column.saturating_add(1);
+ tw = tw.max(y);
+ y = 0.0;
+ } else {
+ tw = tw.max(x);
+ x = 0.0;
+ y += px;
+ }
+ prev = None;
+ continue;
+ }
+ if original.is_control() {
+ continue;
+ }
+ let cjk = matches!(original as u32, 0x3000..=0x30FF | 0x3400..=0x9FFF | 0xFF01..=0xFF60);
+ if vertical && (cjk || cell.chars().count() > 1) {
+ let left = columns.saturating_sub(column.saturating_add(1)) as f32 * px;
+ let shaped = fonts.iter().zip(&vertical_data).enumerate().find_map(|(face, (font, data))| {
+ let data = data.as_ref()?;
+ let cluster = cell_glyphs(font, data, cell, cjk, px, left, y)?;
+ let substituted = cluster.len() != 1 || cluster.first().is_some_and(|g| g.id != font.glyph_id(original));
+ if cjk && !substituted && matches!(original, '、' | '。' | 'ー' | '(' | ')' | '「' | '」' | '『' | '』' | '【' | '】')
+ {
+ return None;
+ }
+ Some((face, cluster))
+ });
+ if let Some((face, cluster)) = shaped {
+ glyphs.extend(cluster.into_iter().map(|g| (face, g, None)));
+ y += px;
+ continue;
+ }
+ }
+ let vertical_form = match original {
+ '、' => '︑',
+ '。' => '︒',
+ '(' => '︵',
+ ')' => '︶',
+ '「' => '﹁',
+ '」' => '﹂',
+ '『' => '﹃',
+ '』' => '﹄',
+ '【' => '︻',
+ '】' => '︼',
+ '…' => '︙',
+ other => other,
+ };
+ let has = |font: &FontRef<'_>, c: char| font.glyph_id(c).0 != 0;
+ let ch = if vertical && fonts.iter().skip(1).any(|f| has(f, vertical_form)) { vertical_form } else { original };
+ // The first face with the glyph; Inter (its missing-glyph box) when none has it.
+ let face = fonts.iter().position(|f| has(f, ch)).unwrap_or(0);
+ let sf = fonts.get(face).unwrap_or(&latin).as_scaled(PxScale::from(px));
+ let id = sf.glyph_id(ch);
+ if vertical {
+ let left = columns.saturating_sub(column.saturating_add(1)) as f32 * px;
+ let pen = point(left + (px - sf.h_advance(id)) / 2.0, y + sf.ascent());
+ let rotation = matches!(original, 'ー' | '—' | '–').then_some((left + px / 2.0, y + px / 2.0));
+ glyphs.push((face, id.with_scale_and_position(px, pen), rotation));
+ y += px;
+ } else {
+ if let Some((previous_face, previous)) = prev
+ && previous_face == face
+ {
+ x += sf.kern(previous, id);
+ }
+ glyphs.push((face, id.with_scale_and_position(px, point(x, y + sf.ascent())), None));
+ x += sf.h_advance(id);
+ prev = Some((face, id));
+ }
+ }
+ let (width, height) = if vertical { (columns as f32 * px, tw.max(y)) } else { (tw.max(x), y + px) };
+ Some(TextLayout { fonts, glyphs, width, height })
+ }
+
+ /// Call `f(x, y, coverage)` for every pixel the text covers with its top-left corner at
+ /// (`ox`, `oy`); coordinates may be negative or past the image (the caller clips).
+ pub fn draw(&self, ox: f32, oy: f32, f: impl FnMut(i32, i32, f32)) {
+ self.draw_in(ox, oy, f32::INFINITY, f32::INFINITY, f);
+ }
+
+ /// [`Self::draw`], skipping the glyphs that fall wholly outside `0..clip_w × 0..clip_h`
+ /// (so huge text costs what shows, not what is laid out).
+ pub fn draw_in(&self, ox: f32, oy: f32, clip_w: f32, clip_h: f32, mut f: impl FnMut(i32, i32, f32)) {
+ for (face, g, rotation) in &self.glyphs {
+ if rotation.is_none() {
+ // a glyph lies within one line height below its pen's top and an em or so after it
+ let (px, py) = (ox + g.position.x, oy + g.position.y);
+ let em = g.scale.y.max(g.scale.x);
+ if px + 2.0 * em < 0.0 || px - em > clip_w || py + em < 0.0 || py - 2.0 * em > clip_h {
+ continue;
+ }
+ }
+ if let Some(o) = self.fonts.get(*face).and_then(|font| font.outline_glyph(g.clone())) {
+ let b = o.px_bounds();
+ if rotation.is_none() && (ox + b.max.x < 0.0 || ox + b.min.x > clip_w || oy + b.max.y < 0.0 || oy + b.min.y > clip_h) {
+ continue;
+ }
+ o.draw(|gx, gy, cov| {
+ let (sx, sy) = (b.min.x + gx as f32, b.min.y + gy as f32);
+ let (sx, sy) = match rotation {
+ Some((cx, cy)) => (cx - (sy - cy), cy + (sx - cx)),
+ None => (sx, sy),
+ };
+ f((ox + sx) as i32, (oy + sy) as i32, cov);
+ });
+ }
+ }
+ }
+}
diff --git a/crates/slideshow/src/compose.rs b/crates/slideshow/src/compose.rs
index 998e591c9..61ce91f3f 100644
--- a/crates/slideshow/src/compose.rs
+++ b/crates/slideshow/src/compose.rs
@@ -204,6 +204,20 @@ fn blurred_step(n: usize, a: f64, b: f64, sigma: f64) -> Vec<f32> {
/// backdrop image (any size; it fills the slide) composed with `s` at `out_w × out_h` pixels
/// (limited to [`MAX_SIDE`] a side, at least 1 × 1). An empty `photo` draws the backdrop alone.
pub fn compose(photo: &Rgba8, backdrop_image: Option<&Rgba8>, s: &SlideSettings, out_w: usize, out_h: usize) -> Rgba8 {
+ compose_with(photo, backdrop_image, s, out_w, out_h, &mut |_, _| {}).0
+}
+
+/// [`compose`], calling `behind(slide, layout)` once the backdrop is drawn and before the shadow,
+/// the stroke and the photo (so it draws behind the photo: a slideshow identity plate with
+/// "render behind image"), and returning the layout it drew with (for overlays drawn on top).
+pub fn compose_with(
+ photo: &Rgba8,
+ backdrop_image: Option<&Rgba8>,
+ s: &SlideSettings,
+ out_w: usize,
+ out_h: usize,
+ behind: &mut dyn FnMut(&mut Rgba8, &Layout),
+) -> (Rgba8, Layout) {
let s = s.clone().sanitized();
let (w, h) = slide_size(out_w, out_h);
let has_photo = photo.width > 0 && photo.height > 0 && photo.data.len() == photo.width * photo.height;
@@ -237,6 +251,7 @@ pub fn compose(photo: &Rgba8, backdrop_image: Option<&Rgba8>, s: &SlideSettings,
}
});
}
+ behind(&mut out, &l);
// cast shadow: a blurred rectangle (separable: the product of two blurred steps)
if let Some((r, sigma)) = l.shadow {
let op = s.shadow_opacity as f32;
@@ -261,7 +276,7 @@ pub fn compose(photo: &Rgba8, backdrop_image: Option<&Rgba8>, s: &SlideSettings,
if has_photo {
draw_image(&mut out, photo, &l.photo, &l.cell, 1.0);
}
- out
+ (out, l)
}
#[cfg(test)]
@@ -459,6 +474,19 @@ mod tests {
}
}
+ #[test]
+ fn behind_draws_under_the_photo_and_the_layout_comes_back() {
+ let s = with(json!({"margins": 0.2}));
+ let mut seen = None;
+ let (img, l) = compose_with(&solid(10, 10, GREEN), None, &s, 200, 100, &mut |out, l| {
+ seen = Some(*l);
+ out.data.fill([255, 0, 0, 255]);
+ });
+ assert_eq!(seen, Some(l), "the hook gets the layout the slide is drawn with");
+ assert_eq!(px(&img, 2, 2), RED, "the hook's paint stays on the backdrop");
+ assert_eq!(px(&img, 100, 50), GREEN, "and the photo covers it");
+ }
+
#[test]
fn hostile_input_never_panics() {
let wild = SlideSettings {
diff --git a/crates/slideshow/src/lib.rs b/crates/slideshow/src/lib.rs
index 4d61716a5..5827491d9 100644
--- a/crates/slideshow/src/lib.rs
+++ b/crates/slideshow/src/lib.rs
@@ -19,5 +19,5 @@
mod compose;
mod settings;
-pub use compose::{Layout, Rect, compose, layout, photo_size};
+pub use compose::{Layout, Rect, compose, compose_with, layout, photo_size};
pub use settings::{Aspect, MARGIN_MAX, MAX_SIDE, SHADOW_OFFSET_MAX, SHADOW_RADIUS_MAX, STROKE_MAX, SlideSettings, hex, parse_color};
diff --git a/crates/ui-egui/locales/de.json b/crates/ui-egui/locales/de.json
index fa4855fe3..d37a5e23a 100644
--- a/crates/ui-egui/locales/de.json
+++ b/crates/ui-egui/locales/de.json
@@ -2057,5 +2057,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "Wählen Sie ein Foto aus und schalten Sie dies ein, um die Folie hinter jedem Foto damit zu füllen.",
"Reset layout": "Layout zurücksetzen",
"Select a photo to preview its slide": "Wählen Sie ein Foto, um seine Folie in der Vorschau zu sehen",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "Das ausgewählte Foto als Folie. Die Wiedergabe füllt den Bildschirm; die Seitenverhältnis-Vorschau ändert nur diese Vorschau."
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "Das ausgewählte Foto als Folie. Die Wiedergabe füllt den Bildschirm; die Seitenverhältnis-Vorschau ändert nur diese Vorschau.",
+ "Overlays": "Überlagerungen",
+ "Identity plate": "Erkennungstafel",
+ "Your name or studio": "Ihr Name oder Studio",
+ "Anchored to": "Verankert an",
+ "Slide": "Folie",
+ "Render behind image": "Hinter dem Bild rendern",
+ "Rating stars": "Sternebewertung",
+ "Text overlays": "Textüberlagerungen",
+ "Add text overlay": "Textüberlagerung hinzufügen",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "Token: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Anderer Text erscheint wie eingegeben.",
+ "Use export watermark": "Export-Wasserzeichen verwenden",
+ "The export watermark, drawn on the photo and sized relative to it.": "Das Export-Wasserzeichen, auf das Foto gezeichnet und relativ zu ihm skaliert."
}
diff --git a/crates/ui-egui/locales/es.json b/crates/ui-egui/locales/es.json
index 4ab5578fe..3f592a18e 100644
--- a/crates/ui-egui/locales/es.json
+++ b/crates/ui-egui/locales/es.json
@@ -1902,5 +1902,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "Selecciona una foto y activa esta opción para llenar con ella el fondo detrás de cada foto.",
"Reset layout": "Restablecer diseño",
"Select a photo to preview its slide": "Selecciona una foto para previsualizar su diapositiva",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "La foto seleccionada como diapositiva. La reproducción llena la pantalla; la vista previa de proporción solo cambia esta vista previa."
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "La foto seleccionada como diapositiva. La reproducción llena la pantalla; la vista previa de proporción solo cambia esta vista previa.",
+ "Overlays": "Superposiciones",
+ "Identity plate": "Placa de identidad",
+ "Your name or studio": "Tu nombre o estudio",
+ "Anchored to": "Anclado a",
+ "Slide": "Diapositiva",
+ "Render behind image": "Representar detrás de la imagen",
+ "Rating stars": "Estrellas de valoración",
+ "Text overlays": "Superposiciones de texto",
+ "Add text overlay": "Añadir superposición de texto",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. El resto del texto se muestra tal cual.",
+ "Use export watermark": "Usar la marca de agua de exportación",
+ "The export watermark, drawn on the photo and sized relative to it.": "La marca de agua de exportación, dibujada sobre la foto y escalada respecto a ella."
}
diff --git a/crates/ui-egui/locales/fr.json b/crates/ui-egui/locales/fr.json
index e456530b5..5f1a0d596 100644
--- a/crates/ui-egui/locales/fr.json
+++ b/crates/ui-egui/locales/fr.json
@@ -1902,5 +1902,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "Sélectionnez une photo, puis activez cette option pour en remplir le fond derrière chaque photo.",
"Reset layout": "Réinitialiser la disposition",
"Select a photo to preview its slide": "Sélectionnez une photo pour prévisualiser sa diapositive",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "La photo sélectionnée en diapositive. La lecture remplit l’écran ; l’aperçu des proportions ne change que cet aperçu."
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "La photo sélectionnée en diapositive. La lecture remplit l’écran ; l’aperçu des proportions ne change que cet aperçu.",
+ "Overlays": "Incrustations",
+ "Identity plate": "Plaque d'identification",
+ "Your name or studio": "Votre nom ou studio",
+ "Anchored to": "Ancré à",
+ "Slide": "Diapositive",
+ "Render behind image": "Afficher derrière l'image",
+ "Rating stars": "Étoiles de notation",
+ "Text overlays": "Incrustations de texte",
+ "Add text overlay": "Ajouter une incrustation de texte",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "Jetons : {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Le reste du texte s'affiche tel quel.",
+ "Use export watermark": "Utiliser le filigrane d'exportation",
+ "The export watermark, drawn on the photo and sized relative to it.": "Le filigrane d'exportation, dessiné sur la photo et dimensionné par rapport à elle."
}
diff --git a/crates/ui-egui/locales/ja.json b/crates/ui-egui/locales/ja.json
index a8da442e4..74ef29b77 100644
--- a/crates/ui-egui/locales/ja.json
+++ b/crates/ui-egui/locales/ja.json
@@ -1904,5 +1904,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "写真を選択してからこれをオンにすると、各写真の背後をその写真で埋めます。",
"Reset layout": "レイアウトをリセット",
"Select a photo to preview its slide": "写真を選択するとスライドをプレビューできます",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "選択した写真をスライドとして表示します。再生では画面全体に表示され、縦横比プレビューはこのプレビューだけを変更します。"
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "選択した写真をスライドとして表示します。再生では画面全体に表示され、縦横比プレビューはこのプレビューだけを変更します。",
+ "Overlays": "オーバーレイ",
+ "Identity plate": "ID プレート",
+ "Your name or studio": "あなたの名前またはスタジオ名",
+ "Anchored to": "基準",
+ "Slide": "スライド",
+ "Render behind image": "画像の背後に表示",
+ "Rating stars": "レーティングの星",
+ "Text overlays": "テキストオーバーレイ",
+ "Add text overlay": "テキストオーバーレイを追加",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "トークン: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}。その他の文字は入力どおりに表示されます。",
+ "Use export watermark": "書き出しの透かしを使用",
+ "The export watermark, drawn on the photo and sized relative to it.": "書き出しの透かし。写真の上に、写真に対する比率で描かれます。"
}
diff --git a/crates/ui-egui/locales/pt-br.json b/crates/ui-egui/locales/pt-br.json
index e811a1be1..4653d1055 100644
--- a/crates/ui-egui/locales/pt-br.json
+++ b/crates/ui-egui/locales/pt-br.json
@@ -1902,5 +1902,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "Selecione uma foto e ative esta opção para preencher com ela o fundo atrás de cada foto.",
"Reset layout": "Redefinir layout",
"Select a photo to preview its slide": "Selecione uma foto para visualizar o slide dela",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "A foto selecionada como slide. A reprodução preenche a tela; a visualização da proporção muda só esta visualização."
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "A foto selecionada como slide. A reprodução preenche a tela; a visualização da proporção muda só esta visualização.",
+ "Overlays": "Sobreposições",
+ "Identity plate": "Placa de identidade",
+ "Your name or studio": "Seu nome ou estúdio",
+ "Anchored to": "Ancorado em",
+ "Slide": "Slide",
+ "Render behind image": "Renderizar atrás da imagem",
+ "Rating stars": "Estrelas de classificação",
+ "Text overlays": "Sobreposições de texto",
+ "Add text overlay": "Adicionar sobreposição de texto",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. O restante do texto aparece como digitado.",
+ "Use export watermark": "Usar a marca d'água de exportação",
+ "The export watermark, drawn on the photo and sized relative to it.": "A marca d'água de exportação, desenhada sobre a foto e dimensionada em relação a ela."
}
diff --git a/crates/ui-egui/locales/ru.json b/crates/ui-egui/locales/ru.json
index 2685f8609..44cd11cb7 100644
--- a/crates/ui-egui/locales/ru.json
+++ b/crates/ui-egui/locales/ru.json
@@ -1616,5 +1616,18 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "Выберите фото и включите этот параметр, чтобы заполнить им фон за каждым фото.",
"Reset layout": "Сбросить макет",
"Select a photo to preview its slide": "Выберите фото, чтобы увидеть его слайд",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "Выбранное фото в виде слайда. При воспроизведении слайд заполняет экран; предпросмотр пропорций меняет только этот предпросмотр."
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "Выбранное фото в виде слайда. При воспроизведении слайд заполняет экран; предпросмотр пропорций меняет только этот предпросмотр.",
+ "Overlays": "Наложения",
+ "Identity plate": "Фирменная табличка",
+ "Your name or studio": "Ваше имя или студия",
+ "Anchored to": "Привязка к",
+ "Slide": "Слайд",
+ "Render behind image": "Рисовать за изображением",
+ "Rating stars": "Звёзды рейтинга",
+ "Text overlays": "Текстовые наложения",
+ "Add text overlay": "Добавить текстовое наложение",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "Токены: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Остальной текст выводится как написан.",
+ "Use export watermark": "Использовать водяной знак экспорта",
+ "The export watermark, drawn on the photo and sized relative to it.": "Водяной знак экспорта, рисуется на фото и масштабируется относительно него.",
+ "© Your Name": "© Ваше имя"
}
diff --git a/crates/ui-egui/locales/uk.json b/crates/ui-egui/locales/uk.json
index e3ddc10ae..a279f5c3c 100644
--- a/crates/ui-egui/locales/uk.json
+++ b/crates/ui-egui/locales/uk.json
@@ -2096,5 +2096,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "Виберіть фото й увімкніть цей параметр, щоб заповнити ним тло за кожним фото.",
"Reset layout": "Скинути макет",
"Select a photo to preview its slide": "Виберіть фото, щоб переглянути його слайд",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "Вибране фото як слайд. Під час відтворення слайд заповнює екран; попередній перегляд пропорцій змінює лише цей перегляд."
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "Вибране фото як слайд. Під час відтворення слайд заповнює екран; попередній перегляд пропорцій змінює лише цей перегляд.",
+ "Overlays": "Накладання",
+ "Identity plate": "Фірмова табличка",
+ "Your name or studio": "Ваше ім'я або студія",
+ "Anchored to": "Прив'язка до",
+ "Slide": "Слайд",
+ "Render behind image": "Малювати за зображенням",
+ "Rating stars": "Зірки рейтингу",
+ "Text overlays": "Текстові накладання",
+ "Add text overlay": "Додати текстове накладання",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "Токени: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Решта тексту виводиться як написано.",
+ "Use export watermark": "Використати водяний знак експорту",
+ "The export watermark, drawn on the photo and sized relative to it.": "Водяний знак експорту, малюється на фото й масштабується відносно нього."
}
diff --git a/crates/ui-egui/locales/zh-hans.json b/crates/ui-egui/locales/zh-hans.json
index 065494810..cb3b27456 100644
--- a/crates/ui-egui/locales/zh-hans.json
+++ b/crates/ui-egui/locales/zh-hans.json
@@ -1902,5 +1902,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "选择一张照片,然后打开此项,用它填充每张照片后面的幻灯片背景。",
"Reset layout": "重置布局",
"Select a photo to preview its slide": "选择一张照片以预览其幻灯片",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "将所选照片显示为幻灯片。播放时会填满屏幕;长宽比预览只改变此预览。"
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "将所选照片显示为幻灯片。播放时会填满屏幕;长宽比预览只改变此预览。",
+ "Overlays": "叠加",
+ "Identity plate": "身份标识",
+ "Your name or studio": "你的名字或工作室",
+ "Anchored to": "锚定到",
+ "Slide": "幻灯片",
+ "Render behind image": "在图像后面渲染",
+ "Rating stars": "评级星标",
+ "Text overlays": "文本叠加",
+ "Add text overlay": "添加文本叠加",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "标记:{file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}。其他文字按原样显示。",
+ "Use export watermark": "使用导出水印",
+ "The export watermark, drawn on the photo and sized relative to it.": "导出水印,绘制在照片上,大小相对于照片。"
}
diff --git a/crates/ui-egui/locales/zh-hant.json b/crates/ui-egui/locales/zh-hant.json
index 27802e68e..e0ba2692e 100644
--- a/crates/ui-egui/locales/zh-hant.json
+++ b/crates/ui-egui/locales/zh-hant.json
@@ -1902,5 +1902,17 @@
"Select a photo, then turn this on to fill the slide behind every photo with it.": "選取一張照片,然後開啟此項,以它填滿每張照片後方的投影片背景。",
"Reset layout": "重設版面",
"Select a photo to preview its slide": "選取一張照片以預覽其投影片",
- "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "將所選照片顯示為投影片。播放時會填滿螢幕;長寬比預覽只會改變此預覽。"
+ "The selected photo as a slide. Playback fills the screen; the aspect preview only changes this preview.": "將所選照片顯示為投影片。播放時會填滿螢幕;長寬比預覽只會改變此預覽。",
+ "Overlays": "疊加",
+ "Identity plate": "身分標識",
+ "Your name or studio": "你的名字或工作室",
+ "Anchored to": "錨定到",
+ "Slide": "幻燈片",
+ "Render behind image": "在影像後方繪製",
+ "Rating stars": "評等星號",
+ "Text overlays": "文字疊加",
+ "Add text overlay": "新增文字疊加",
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.": "標記:{file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}。其他文字按原樣顯示。",
+ "Use export watermark": "使用匯出浮水印",
+ "The export watermark, drawn on the photo and sized relative to it.": "匯出浮水印,繪製在照片上,大小相對於照片。"
}
diff --git a/crates/ui-egui/src/panels/mod.rs b/crates/ui-egui/src/panels/mod.rs
index 3d40f9cc1..4acd6dedc 100644
--- a/crates/ui-egui/src/panels/mod.rs
+++ b/crates/ui-egui/src/panels/mod.rs
@@ -28,6 +28,7 @@ pub mod rules_editor;
pub mod second;
pub mod settings;
pub mod slide_layout;
+pub mod slide_overlays;
pub mod slideshow;
pub mod strip;
pub mod topbar;
diff --git a/crates/ui-egui/src/panels/settings.rs b/crates/ui-egui/src/panels/settings.rs
index 2be60a4a5..8a7d9e8d8 100644
--- a/crates/ui-egui/src/panels/settings.rs
+++ b/crates/ui-egui/src/panels/settings.rs
@@ -657,6 +657,8 @@ fn slideshow_tab(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens) {
playback_section(app, ui, t);
ui.add_space(6.0);
super::slide_layout::sections(app, ui, t);
+ ui.add_space(6.0);
+ super::slide_overlays::sections(app, ui, t);
});
});
ui.add_space(12.0);
diff --git a/crates/ui-egui/src/panels/slide_layout.rs b/crates/ui-egui/src/panels/slide_layout.rs
index c0e03844c..2f5ef0883 100644
--- a/crates/ui-egui/src/panels/slide_layout.rs
+++ b/crates/ui-egui/src/panels/slide_layout.rs
@@ -1,5 +1,6 @@
//! Settings ▸ Slideshow: the slide's Layout, Options and Backdrop sections (Lightroom Classic's
-//! Slideshow panels of the same names) and a small live preview of the composed slide.
+//! Slideshow panels of the same names) and a small live preview of the composed slide (with the
+//! overlays of [`super::slide_overlays`]).
//!
//! Every control goes through `slideshow.layout` (validated there, saved with the library).
//! Sliders change the layout in memory while dragged (the preview follows) and save it when let
@@ -177,7 +178,16 @@ pub fn preview(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens) {
};
let ppp = ui.ctx().pixels_per_point();
let (pw, ph) = (((PREVIEW_W * ppp).round() as usize).max(16), ((h * ppp).round() as usize).max(16));
- let key = s.pixel_key() ^ id.0.rotate_left(17) ^ ((pw as u64) << 32 | ph as u64);
+ // the overlays and what they show of the photo (its rating, its metadata) change it too
+ let shown = app.session.catalog.photo(id).filter(|_| app.session.slide_overlays.any()).map_or(0, |p| {
+ use std::hash::{Hash, Hasher};
+ let mut h = std::collections::hash_map::DefaultHasher::new();
+ p.rating.hash(&mut h);
+ serde_json::to_string(&p.meta).unwrap_or_default().hash(&mut h);
+ h.finish()
+ });
+ let overlays = if app.session.slide_overlays.any() { app.session.slide_overlays.pixel_key() ^ shown.rotate_left(5) } else { 0 };
+ let key = s.pixel_key() ^ id.0.rotate_left(17) ^ ((pw as u64) << 32 | ph as u64) ^ overlays.rotate_left(29);
let now = ui.input(|i| i.time);
let mem = egui::Id::new("settingsSlideshowPreviewKey");
let (last, since) = ui.ctx().data(|d| d.get_temp::<(u64, f64)>(mem)).unwrap_or((0, f64::NEG_INFINITY));
diff --git a/crates/ui-egui/src/panels/slide_overlays.rs b/crates/ui-egui/src/panels/slide_overlays.rs
new file mode 100644
index 000000000..3824eeb0d
--- /dev/null
+++ b/crates/ui-egui/src/panels/slide_overlays.rs
@@ -0,0 +1,265 @@
+//! Settings ▸ Slideshow ▸ Overlays (Lightroom Classic's Slideshow Overlays panel): the identity
+//! plate (text or an image file), rating stars, text overlays with tokens and the watermark.
+//!
+//! Every control goes through `slideshow.overlays` (validated there, saved with the library), like
+//! the Layout sections beside it ([`super::slide_layout`]); the live preview next to them shows the
+//! overlays on the active photo's slide. Sliders change the settings in memory while dragged and
+//! save them when let go; text fields save when the edit ends (Return or leaving the field).
+
+use egui::RichText;
+use lightcraft_engine::export::Anchor;
+use lightcraft_engine::slide_overlay::{
+ ANCHORS, OFFSET_MAX, OverlaySettings, PLATE_SIZE_MAX, Placement, RelativeTo, SHADOW_OFFSET_MAX, SHADOW_RADIUS_MAX, STAR_SIZE_MAX, TEXT_SIZE_MAX,
+};
+use serde_json::{Value, json};
+
+use super::settings::{check, choices, heading, hint, row};
+use crate::LightcraftApp;
+use crate::text_field::TextField;
+use crate::theme::Tokens;
+use crate::widgets::register;
+
+#[derive(Clone, Copy)]
+enum Unit {
+ /// A fraction shown as a percentage (of the slide's shorter side, or an opacity).
+ Percent,
+ Degrees,
+}
+
+fn set(app: &mut LightcraftApp, p: Value) {
+ let _ = app.run("slideshow.overlays", p);
+}
+
+/// A slider (`slider:{id}`) over `lo..=hi`; `wrap(value)` makes the `slideshow.overlays` request.
+fn slider(app: &mut LightcraftApp, ui: &mut egui::Ui, id: &str, value: f64, lo: f64, hi: f64, unit: Unit, wrap: &dyn Fn(f64) -> Value) {
+ let (k, suffix) = match unit {
+ Unit::Percent => (100.0, " %"),
+ Unit::Degrees => (1.0, "°"),
+ };
+ let mut v = value * k;
+ let r = ui.add(egui::Slider::new(&mut v, lo * k..=hi * k).suffix(suffix).max_decimals(1));
+ register(ui.ctx(), format!("slider:{id}"), r.rect);
+ let p = wrap(v / k);
+ if r.changed()
+ && let Ok(next) = app.session.slide_overlays.merged(&p)
+ {
+ app.session.slide_overlays = next;
+ }
+ if r.drag_stopped() || (r.changed() && !r.dragged()) {
+ set(app, p);
+ }
+}
+
+/// A colour button (`button:{id}`).
+fn colour(app: &mut LightcraftApp, ui: &mut egui::Ui, id: &str, value: [u8; 3], wrap: &dyn Fn([u8; 3]) -> Value) {
+ let mut c = value;
+ let r = egui::color_picker::color_edit_button_srgb(ui, &mut c);
+ register(ui.ctx(), format!("button:{id}"), r.rect);
+ if r.changed() {
+ set(app, wrap(c));
+ }
+}
+
+/// A checkbox (`check:settings.{id}`); true when it is on.
+fn toggle(app: &mut LightcraftApp, ui: &mut egui::Ui, id: &str, value: bool, label: &str, wrap: &dyn Fn(bool) -> Value) -> bool {
+ let mut v = value;
+ if check(ui, &format!("settings.{id}"), &mut v, label) {
+ set(app, wrap(v));
+ }
+ v
+}
+
+/// A one-line text field (`field:{id}`), saved when the edit ends.
+fn text(app: &mut LightcraftApp, ui: &mut egui::Ui, id: &str, value: &str, hint: &str, wrap: &dyn Fn(&str) -> Value) {
+ let mem = egui::Id::new(("slideshow-overlay-field", id));
+ let mut s: String = ui.data(|d| d.get_temp(mem)).unwrap_or_else(|| value.to_string());
+ let widget = format!("field:{id}");
+ let r = TextField::singleline(&widget, &mut s).hint(crate::i18n::tr(hint)).width(ui.available_width().clamp(80.0, 260.0)).show(ui);
+ if r.editing {
+ ui.data_mut(|d| d.insert_temp(mem, s.clone()));
+ } else {
+ ui.data_mut(|d| d.remove::<String>(mem));
+ }
+ if r.committed() && s != value {
+ set(app, wrap(&s));
+ }
+}
+
+/// The nine anchors as a 3 × 3 grid of buttons (`button:{id}-{0..8}`); true when one is picked.
+fn anchor_grid(ui: &mut egui::Ui, id: &str, value: &mut Anchor) -> bool {
+ const GLYPHS: [&str; 9] = ["↖", "↑", "↗", "←", "•", "→", "↙", "↓", "↘"];
+ let mut changed = false;
+ ui.vertical(|ui| {
+ ui.spacing_mut().item_spacing = egui::vec2(2.0, 2.0);
+ for r in 0..3 {
+ ui.horizontal(|ui| {
+ for c in 0..3 {
+ let i = r * 3 + c;
+ let (Some(a), Some(g)) = (ANCHORS.get(i), GLYPHS.get(i)) else { continue };
+ if crate::widgets::text_button(ui, &format!("{id}-{i}"), g, *value == *a).clicked() && *value != *a {
+ *value = *a;
+ changed = true;
+ }
+ }
+ });
+ }
+ });
+ changed
+}
+
+/// Anchor, offsets and what the overlay is anchored to; `wrap` turns placement keys into the request.
+fn placement(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens, id: &str, p: &Placement, photo_too: bool, wrap: &dyn Fn(Value) -> Value) {
+ row(ui, t, "Position", |ui| {
+ let mut a = p.anchor;
+ if anchor_grid(ui, &format!("{id}Anchor"), &mut a) {
+ set(app, wrap(json!({"anchor": lightcraft_engine::slide_overlay::anchor_id(a)})));
+ }
+ });
+ if photo_too {
+ row(ui, t, "Anchored to", |ui| {
+ let mut r = p.relative_to;
+ if choices(ui, &format!("{id}RelativeTo"), &[(RelativeTo::Slide, "Slide"), (RelativeTo::Photo, "Photo")], &mut r) {
+ let v = if r == RelativeTo::Photo { "photo" } else { "slide" };
+ set(app, wrap(json!({"relativeTo": v})));
+ }
+ });
+ }
+ row(ui, t, "Offset X", |ui| {
+ slider(app, ui, &format!("{id}OffsetX"), p.offset_x, -OFFSET_MAX / 2.0, OFFSET_MAX / 2.0, Unit::Percent, &|v| wrap(json!({"offsetX": v})))
+ });
+ row(ui, t, "Offset Y", |ui| {
+ slider(app, ui, &format!("{id}OffsetY"), p.offset_y, -OFFSET_MAX / 2.0, OFFSET_MAX / 2.0, Unit::Percent, &|v| wrap(json!({"offsetY": v})))
+ });
+}
+
+/// The request changing text overlay `i` of `n` by `change` (the others kept).
+fn text_change(i: usize, n: usize, change: Value) -> Value {
+ let list: Vec<Value> = (0..n).map(|k| if k == i { change.clone() } else { json!({}) }).collect();
+ json!({ "texts": list })
+}
+
+/// The Overlays sections.
+pub fn sections(app: &mut LightcraftApp, ui: &mut egui::Ui, t: &Tokens) {
+ let s: OverlaySettings = app.session.slide_overlays.clone();
+ heading(ui, t, "Overlays");
+
+ // identity plate
+ let p = s.identity_plate.clone();
+ let plate = |v: Value| json!({ "identityPlate": v });
+ if toggle(app, ui, "slideshowPlate", p.enabled, "Identity plate", &|v| plate(json!({"enabled": v}))) {
+ let mem = egui::Id::new("slideshow-plate-graphic");
+ let mut graphic = !p.image.is_empty() || ui.data(|d| d.get_temp::<bool>(mem)).unwrap_or(false);
+ let before = graphic;
+ row(ui, t, "Style", |ui| choices(ui, "slideshowPlateStyle", &[(false, "Text"), (true, "Image")], &mut graphic));
+ if graphic != before {
+ ui.data_mut(|d| d.insert_temp(mem, graphic));
+ if !graphic && !p.image.is_empty() {
+ set(app, plate(json!({"image": ""})));
+ }
+ }
+ if graphic {
+ row(ui, t, "Image", |ui| {
+ if app.services.pick_files.is_some()
+ && crate::widgets::text_button(ui, "slideshowPlateChoose", "Choose…", false).clicked()
+ && let Some(f) = app.services.pick_files.as_mut().and_then(|pick| pick().into_iter().next())
+ {
+ set(app, plate(json!({"image": f})));
+ }
+ text(app, ui, "slideshowPlateImage", &p.image, "logo.png", &|v| plate(json!({"image": v})));
+ });
+ } else {
+ row(ui, t, "Text", |ui| text(app, ui, "slideshowPlateText", &p.text, "Your name or studio", &|v| plate(json!({"text": v}))));
+ row(ui, t, "Colour", |ui| colour(app, ui, "slideshowPlateColor", p.color, &|c| plate(json!({"color": c}))));
+ }
+ row(ui, t, "Size", |ui| slider(app, ui, "slideshowPlateSize", p.size, 0.01, PLATE_SIZE_MAX, Unit::Percent, &|v| plate(json!({"size": v}))));
+ row(ui, t, "Opacity", |ui| slider(app, ui, "slideshowPlateOpacity", p.opacity, 0.0, 1.0, Unit::Percent, &|v| plate(json!({"opacity": v}))));
+ placement(app, ui, t, "slideshowPlate", &p.place, true, &plate);
+ toggle(app, ui, "slideshowPlateBehind", p.behind, "Render behind image", &|v| plate(json!({"behind": v})));
+ }
+
+ // rating stars
+ ui.add_space(4.0);
+ let r = s.rating_stars.clone();
+ let stars = |v: Value| json!({ "ratingStars": v });
+ if toggle(app, ui, "slideshowStars", r.enabled, "Rating stars", &|v| stars(json!({"enabled": v}))) {
+ row(ui, t, "Colour", |ui| colour(app, ui, "slideshowStarsColor", r.color, &|c| stars(json!({"color": c}))));
+ row(ui, t, "Size", |ui| slider(app, ui, "slideshowStarsSize", r.size, 0.01, STAR_SIZE_MAX, Unit::Percent, &|v| stars(json!({"size": v}))));
+ placement(app, ui, t, "slideshowStars", &r.place, true, &stars);
+ }
+
+ // text overlays
+ ui.add_space(6.0);
+ ui.label(RichText::new(crate::i18n::tr("Text overlays")).font(t.semibold(11.5)).color(t.text));
+ let n = s.texts.len();
+ for (i, o) in s.texts.iter().enumerate() {
+ let id = format!("slideshowText{i}");
+ let wrap = |v: Value| text_change(i, n, v);
+ ui.add_space(2.0);
+ row(ui, t, &format!("{} {}", crate::i18n::tr("Text"), i + 1), |ui| {
+ text(app, ui, &id, &o.text, "{title} · {exposure}", &|v| wrap(json!({"text": v})));
+ if crate::widgets::text_button(ui, &format!("{id}Remove"), "Remove", false).clicked() {
+ set(app, json!({"removeText": i}));
+ }
+ });
+ if app.session.slide_overlays.texts.len() != n {
+ return; // removed: the indices moved; drawn again next frame
+ }
+ row(ui, t, "Size", |ui| {
+ slider(app, ui, &format!("{id}Size"), o.size, 0.01, TEXT_SIZE_MAX / 2.0, Unit::Percent, &|v| wrap(json!({"size": v})))
+ });
+ row(ui, t, "Colour", |ui| colour(app, ui, &format!("{id}Color"), o.color, &|c| wrap(json!({"color": c}))));
+ row(ui, t, "Opacity", |ui| slider(app, ui, &format!("{id}Opacity"), o.opacity, 0.0, 1.0, Unit::Percent, &|v| wrap(json!({"opacity": v}))));
+ placement(app, ui, t, &id, &o.place, true, &wrap);
+ let sh = o.shadow;
+ if toggle(app, ui, &format!("{id}Shadow"), sh.on, "Shadow", &|v| wrap(json!({"shadow": v}))) {
+ row(ui, t, "Opacity", |ui| {
+ slider(app, ui, &format!("{id}ShadowOpacity"), sh.opacity, 0.0, 1.0, Unit::Percent, &|v| wrap(json!({"shadowOpacity": v})))
+ });
+ row(ui, t, "Offset", |ui| {
+ slider(app, ui, &format!("{id}ShadowOffset"), sh.offset, 0.0, SHADOW_OFFSET_MAX, Unit::Percent, &|v| wrap(json!({"shadowOffset": v})))
+ });
+ row(ui, t, "Radius", |ui| {
+ slider(app, ui, &format!("{id}ShadowRadius"), sh.radius, 0.0, SHADOW_RADIUS_MAX, Unit::Percent, &|v| wrap(json!({"shadowRadius": v})))
+ });
+ row(ui, t, "Angle", |ui| {
+ slider(app, ui, &format!("{id}ShadowAngle"), sh.angle, -180.0, 180.0, Unit::Degrees, &|v| wrap(json!({"shadowAngle": v})))
+ });
+ }
+ }
+ if n < lightcraft_engine::slide_overlay::MAX_TEXTS && crate::widgets::text_button(ui, "slideshowAddText", "Add text overlay", false).clicked() {
+ set(app, json!({"addText": {}}));
+ }
+ hint(
+ ui,
+ t,
+ "Tokens: {file}, {name}, {title}, {caption}, {date}, {exposure}, {iso}, {focal}, {camera}, {lens}, {rating}, {creator}, {copyright}. Other text shows as typed.",
+ );
+
+ // watermark
+ ui.add_space(4.0);
+ let w = s.watermark.clone();
+ let wm = |v: Value| json!({ "watermark": v });
+ if toggle(app, ui, "slideshowWatermark", s.show_watermark, "Watermark", &|v| json!({"showWatermark": v})) {
+ row(ui, t, "Text", |ui| text(app, ui, "slideshowWatermarkText", &w.text, "© Your Name", &|v| wm(json!({"text": v}))));
+ row(ui, t, "Size", |ui| slider(app, ui, "slideshowWatermarkSize", w.size as f64, 0.01, 0.15, Unit::Percent, &|v| wm(json!({"size": v}))));
+ row(ui, t, "Opacity", |ui| {
+ slider(app, ui, "slideshowWatermarkOpacity", w.opacity as f64, 0.05, 1.0, Unit::Percent, &|v| wm(json!({"opacity": v})))
+ });
+ row(ui, t, "Position", |ui| {
+ let mut a = w.anchor;
+ if anchor_grid(ui, "slideshowWatermarkAnchor", &mut a) {
+ set(app, wm(json!({"anchor": lightcraft_engine::slide_overlay::anchor_id(a)})));
+ }
+ });
+ let export_wm = app.session.last_export.as_ref().and_then(|e| e.get("watermark")).filter(|v| v.is_object() || v.is_string()).cloned();
+ if let Some(e) = export_wm
+ && crate::widgets::text_button(ui, "slideshowUseExportWatermark", "Use export watermark", false).clicked()
+ {
+ set(app, wm(e));
+ }
+ hint(ui, t, "The export watermark, drawn on the photo and sized relative to it.");
+ }
+ for warning in app.session.slide_overlays.warnings() {
+ ui.label(RichText::new(warning).size(11.0).color(t.caution));
+ }
+}
diff --git a/crates/ui-egui/src/panels/slideshow.rs b/crates/ui-egui/src/panels/slideshow.rs
index 13b8f0c5a..42a514d5f 100644
--- a/crates/ui-egui/src/panels/slideshow.rs
+++ b/crates/ui-egui/src/panels/slideshow.rs
@@ -182,7 +182,7 @@ fn slide_job(app: &mut LightcraftApp, id: PhotoId, area: Rect, ppp: f32, texture
let photo = app.session.catalog.photo(id)?.clone();
let frame = Frame::with_lens(photo.width.max(1) as usize, photo.height.max(1) as usize, &photo.develop, true, photo.embedded_lens.as_ref());
let native = super::detail::output_px(&frame);
- if !app.session.slide_layout.is_plain() {
+ if !app.session.slides_plain() {
let (w, h) = slide_px(area, ppp, texture_side);
let edge = app.ui.settings.loupe_edge(w.max(h) as f32, native[0].max(native[1]), texture_side);
return app.session.slide_job(id, w, h, Some(edge));
diff --git a/crates/ui-egui/src/tests_slideshow.rs b/crates/ui-egui/src/tests_slideshow.rs
index 36558267b..b7f26c768 100644
--- a/crates/ui-egui/src/tests_slideshow.rs
+++ b/crates/ui-egui/src/tests_slideshow.rs
@@ -344,3 +344,86 @@ fn settings_shows_the_slide_layout_and_a_live_preview() {
assert!(c[1] > 200 && c[0] < 60, "the green backdrop in the preview margin: {c:?}");
h.settle(SETTLE);
}
+
+#[test]
+fn overlays_show_during_playback() {
+ let mut h = grid();
+ assert!(h.app.session.slides_plain());
+ // the default layout with an identity plate: playback composes the slide to draw it
+ run(
+ &mut h,
+ "slideshow.overlays",
+ json!({"identityPlate": {"enabled": true, "text": "LC", "size": 0.12, "color": "#00ff00", "opacity": 1, "anchor": "topLeft", "offsetX": 0.02, "offsetY": 0.02}}),
+ );
+ assert!(!h.app.session.slides_plain());
+ run(&mut h, "view.slideshow", json!({"interval": 60, "fadeDuration": 0}));
+ let current = play(&h).current();
+ assert!(h.step_until(SETTLE, |h| has_slide(h, current)), "the slide is composed and ready");
+ h.step();
+ assert_eq!(h.app.renderer.textures.get(&Slot::Slide(current)).unwrap().size, [1000, 700]);
+ let img = h.paint();
+ // the plate's box: 14 px in from the top-left corner, 84 px high
+ let green = (14..98).flat_map(|y| (14..120).map(move |x| (x, y))).filter(|&(x, y)| {
+ let c = painted(&img, x, y);
+ c[1] > 200 && c[0] < 80 && c[2] < 80
+ });
+ assert!(green.count() > 200, "the identity plate is on the slide");
+ h.settle(SETTLE);
+}
+
+#[test]
+fn settings_shows_the_overlays_and_the_preview_follows_them() {
+ let mut h = grid();
+ let first = h.app.session.visible_cloned()[0];
+ run(&mut h, "library.select", json!({"ids": [first.0]}));
+ run(&mut h, "view.slideshowOptions", json!({}));
+ assert!(h.step_until(SETTLE, |h| h.app.renderer.textures.get(&Slot::SlidePreview).is_some_and(|t| t.photo == first)));
+ let has = |h: &Headless, w: &str| h.app.widgets.iter().any(|(id, _)| id == w);
+ // scroll down to the Overlays section
+ let r = h.request("ui.hoverWidget", json!({"id": "check:settings.slideshowRandom"}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ for _ in 0..4 {
+ let r = h.request("ui.scroll", json!({"dy": -800}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ for _ in 0..10 {
+ h.step();
+ }
+ }
+ for w in ["check:settings.slideshowPlate", "check:settings.slideshowStars", "button:slideshowAddText", "check:settings.slideshowWatermark"] {
+ assert!(has(&h, w), "{w}");
+ }
+ let r = h.request("ui.clickWidget", json!({"id": "button:slideshowAddText"}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ h.step();
+ assert_eq!(h.app.session.slide_overlays.texts.len(), 1);
+ h.step();
+ assert!(has(&h, "field:slideshowText0"), "the text overlay's template field");
+ // its rows are below the fold: scroll on down
+ for _ in 0..4 {
+ let r = h.request("ui.scroll", json!({"dy": -800}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ for _ in 0..10 {
+ h.step();
+ }
+ }
+ assert!(has(&h, "button:slideshowText0Anchor-4"), "its anchor grid");
+ let r = h.request("ui.clickWidget", json!({"id": "button:slideshowText0Anchor-0"}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ h.step();
+ assert_eq!(h.app.session.slide_overlays.texts[0].place.anchor, lightcraft_engine::export::Anchor::TopLeft, "picked in the grid");
+ // removed from its row the text overlay from its row
+ let r = h.request("ui.clickWidget", json!({"id": "button:slideshowText0Remove"}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ h.step();
+ assert!(h.app.session.slide_overlays.texts.is_empty());
+ h.step();
+ let r = h.request("ui.clickWidget", json!({"id": "check:settings.slideshowPlate"}), T);
+ assert_eq!(r["ok"], true, "{r}");
+ h.step();
+ assert!(h.app.session.slide_overlays.identity_plate.enabled);
+ // the preview is rendered again with the overlays
+ let before = h.app.renderer.textures.get(&Slot::SlidePreview).map(|t| t.key);
+ run(&mut h, "slideshow.overlays", json!({"identityPlate": {"text": "Studio", "color": "#ff00ff"}}));
+ assert!(h.step_until(SETTLE, |h| h.app.renderer.textures.get(&Slot::SlidePreview).map(|t| t.key) != before));
+ h.settle(SETTLE);
+}
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index 2d0f88ab1..2a4525d3e 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -50,7 +50,8 @@ mode ([mcp.md](mcp.md)) is a thin layer over this channel. Implementation:
| `engine.execute {command: "activity.cancel"}` | `{id}` or `{all: true}` | Asks the task (or every cancellable one) to stop at its next file or photo → `{cancelled: n}`; an unknown id (it may have just finished) or a task that can't be cancelled is an error |
| `ui.render` | `{id?, size?, path?}` | Render a photo (PNG to `path`), `{width, height}` |
| `engine.execute {command: "slideshow.layout"}` | `{margins?, marginLeft?, …, zoomToFill?, strokeBorder?, castShadow?, backdropColor?, colorWash?, backgroundImage?, …}` (see `engine.commands`) | The slideshow's slide layout (Layout, Options, Backdrop), saved with the library; omitted keys keep their value, `{}` reads it; out-of-range numbers are clamped, a wrong type or unknown key is refused and nothing changes |
-| `engine.execute {command: "slideshow.preview"}` | `{id?, width?, height?, path?}` | One slide composed with the layout, as the slideshow plays it: a PNG written to `path`, or returned base64 in `png` without one; `{id, width, height, cell, photo}` (`cell` and `photo` are `[x0, y0, x1, y1]` in slide pixels). Sides 16–4096; one side given takes the other from the aspect preview |
+| `engine.execute {command: "slideshow.overlays"}` | `{identityPlate?: {enabled?, text?, image?, size?, color?, opacity?, anchor?, offsetX?, offsetY?, relativeTo?, behind?}, ratingStars?: {enabled?, color?, size?, anchor?, …}, texts?: [{text?, size?, color?, opacity?, anchor?, offsetX?, offsetY?, relativeTo?, shadow?, shadowOpacity?, shadowOffset?, shadowRadius?, shadowAngle?}], addText?, removeText?, showWatermark?, watermark?}` (see `engine.commands`) | The overlays drawn on every slide, saved with the library: sizes and offsets are fractions of the slide's shorter side, anchors `topLeft`…`bottomRight` of the `slide` or the `photo`; text overlays expand tokens (`{caption}`, `{exposure}`, `{date}`, the file-naming tokens…; unknown tags show as typed); `watermark` takes the export watermark's keys. Replies with the settings and `warnings` |
+| `engine.execute {command: "slideshow.preview"}` | `{id?, width?, height?, path?}` | One slide composed with the layout and overlays, as the slideshow plays it: a PNG written to `path`, or returned base64 in `png` without one; `{id, width, height, cell, photo, overlays}` (`cell` and `photo` are `[x0, y0, x1, y1]` in slide pixels; `overlays` lists `{kind, box}` for each drawn overlay). Sides 16–4096; one side given takes the other from the aspect preview |
| `app.quit` | — | Close the app |
Image navigation is also available directly as the UI command `view.navigate`, with
diff --git a/docs/mcp.md b/docs/mcp.md
index 845d054fd..1631eab88 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -200,7 +200,10 @@ Slideshow slides, for example: `cmd_slideshow_layout` reads or changes the slide
zoom to fill, stroke border, cast shadow, backdrop colour, colour wash, background image; saved with
the library) and `cmd_slideshow_preview {id?, width?, height?, path?}` composes one slide with it —
written as a PNG to `path`, or returned as base64 PNG in `png` — so an agent can look at a layout
-before playing it. `cmd_slideshow_playback` sets the timing and fades.
+before playing it. `cmd_slideshow_playback` sets the timing and fades. `cmd_slideshow_overlays` sets the
+overlays drawn on every slide (identity plate text or image, rating stars, text overlays with tokens such as
+`{caption}` or `{exposure}`, the export watermark); its reply lists `warnings` (an unreadable plate image, tags that
+aren't tokens), and `cmd_slideshow_preview` returns each overlay's box.
## Resources
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 6995f6f16..1cc7972fd 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -52,10 +52,10 @@ cited here still exists. Formerly docs/parity.md.
| X. Cross-cutting behaviours (BEHAV) | 18 | 6 | 1 | 1 | 8/8 (100%) | 6/9 (67%) |
| Y. Menus | 82 | 0 | 4 | 8 | 47/47 (100%) | 23/23 (100%) |
| Z. Keyboard shortcuts (desktop) | 75 | 3 | 3 | 1 | 49/52 (94%) | 23/24 (96%) |
-| Lightroom Classic extras | 35 | 17 | 31 | 9 | — | 23/25 (92%) |
-| **Total** | 399 | 51 | 69 | 36 | 192/200 (96%) | 143/155 (92%) |
+| Lightroom Classic extras | 35 | 18 | 30 | 9 | — | 23/25 (92%) |
+| **Total** | 399 | 52 | 68 | 36 | 192/200 (96%) | 143/155 (92%) |
-Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.8%** of 519 in-scope rows — P0 98.0% of 200 · P1 95.2% of 155 · P2 49.1% of 163.
+Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.9%** of 519 in-scope rows — P0 98.0% of 200 · P1 95.2% of 155 · P2 49.4% of 163.
<!-- /parity:summary -->
## Top gaps and shortcut notes
@@ -730,11 +730,11 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-
| LRC-SS-TEMPLATES | Slideshow templates | P2 | ⬜ | | |
| LRC-SS-OPTIONS | Slideshow options | P2 | ✅ | `cmd:slideshow.layout`, `cmd:slideshow.preview`, `path:crates/slideshow/src/compose.rs` | Zoom to Fill Frame (the photo covers its image cell, cropped to it; off: fits inside), Stroke Border (colour, width as a share of the slide's shorter side, drawn around the photo), Cast Shadow (opacity, offset, radius, angle; a blurred offset rectangle under the photo and its stroke). Composed by `lightcraft-slideshow` (CPU, no UI) for playback, the Settings ▸ Slideshow preview and `slideshow.preview`; edited in Settings ▸ Slideshow until the Slideshow module view exists |
| LRC-SS-LAYOUT | Slideshow layout | P2 | 🟡 | `cmd:slideshow.layout`, `cmd:slideshow.preview`, `path:crates/ui-egui/src/panels/slide_layout.rs` | Margins left / right / top / bottom (linked or each on its own; shares of the slide's shorter side, so any screen or output size looks the same), Show Guides, Aspect Preview (Screen, 16:9, 4:3). Missing: the Slideshow module's slide editor — guides are drawn only in the Settings ▸ Slideshow preview and can't be dragged to set the margins; the aspect preview applies to that preview and `slideshow.preview` (playback always fills the screen, as in Classic) |
-| LRC-SS-OVERLAYS | Slideshow overlays | P2 | ⬜ | | |
+| LRC-SS-OVERLAYS | Slideshow overlays | P2 | 🟡 | `cmd:slideshow.overlays`, `cmd:slideshow.preview`, `path:crates/engine/src/slide_overlay.rs`, `path:crates/ui-egui/src/panels/slide_overlays.rs` | Identity plate (text with size / colour / opacity, or a PNG / JPEG file with its transparency; render behind image), rating stars (our own vector stars, colour, size), text overlays (up to 16) with tokens (`{file}`, `{caption}`, `{title}`, `{date}`, `{exposure}`, `{shutter}`, `{aperture}`, `{focal}`, `{iso}`, `{camera}`, `{lens}`, `{rating}`, `{copyright}` and the other rename tokens; unknown tags show as typed and are reported), size / colour / opacity and a drop shadow (opacity, offset, radius, angle); each at one of nine anchors of the slide or the photo plus an offset, kept on the slide; the export watermark on the photo. Sizes relative to the slide; drawn by the engine over the composed slide (Inter + craft-fonts CJK, the export watermark's text renderer) for playback, the Settings ▸ Slideshow preview and `slideshow.preview`. Missing: dragging overlays on the slide in a Slideshow module editor, font family / style choice (Inter SemiBold only), the Identity Plate Editor's styled multi-run text, right-to-left reordering (Arabic / Hebrew draw in logical order, and without glyphs in Inter) |
| LRC-SS-BACKDROP | Slideshow backdrop | P2 | ✅ | `cmd:slideshow.layout`, `path:crates/slideshow/src/compose.rs` | Background colour, Color Wash (a gradient from a second colour, full at the side its angle points to, at an opacity), Background Image (a library photo filling the slide at an opacity: "Use selected photo" in Settings ▸ Slideshow, `backgroundImage` in `slideshow.layout`; rendered once and shared by the slides). In the web build the composition runs on the main thread when a worker's render comes back |
| LRC-SS-TITLES | Slideshow titles | P2 | ⬜ | | |
| LRC-SS-MUSIC | Slideshow music | P2 | ⬜ | | |
-| LRC-SS-PLAYBACK | Slideshow playback | P2 | 🟡 | `cmd:slideshow.playback`, `cmd:view.slideshowOptions`, `cmd:slideshow.togglePause`, `cmd:slideshow.next`, `cmd:slideshow.previous`, `cmd:slideshow.end` | Playback settings (library preference, `slideshow.playback`; Settings ▸ Slideshow, View ▸ Slideshow Options…): slide duration 0.5–120 s, fade 0–10 s (≤ slide; 0 = cut) as a crossfade or through a colour, random order (seeded shuffle, every photo once per pass, a new order each pass), repeat (off: ends after the last slide), prepare previews in advance (the next 2 slides render off the UI thread; a transition never starts before its slide is rendered — the current one is held). Space / ←/→ (cut) / Esc and a control bar (previous, play/pause, next, n / N, end) that shows on pointer movement. Missing: the Slideshow module view and its "preview in the view" (phase 2 of the module plan), music and sync to music (LRC-SS-MUSIC), pan & zoom, manual-advance mode, choosing the screen to play on, overlays and titles on the slides (LRC-SS-OVERLAYS, LRC-SS-TITLES). Slides are composed with the layout, options and backdrop (LRC-SS-LAYOUT / OPTIONS / BACKDROP) |
+| LRC-SS-PLAYBACK | Slideshow playback | P2 | 🟡 | `cmd:slideshow.playback`, `cmd:view.slideshowOptions`, `cmd:slideshow.togglePause`, `cmd:slideshow.next`, `cmd:slideshow.previous`, `cmd:slideshow.end` | Playback settings (library preference, `slideshow.playback`; Settings ▸ Slideshow, View ▸ Slideshow Options…): slide duration 0.5–120 s, fade 0–10 s (≤ slide; 0 = cut) as a crossfade or through a colour, random order (seeded shuffle, every photo once per pass, a new order each pass), repeat (off: ends after the last slide), prepare previews in advance (the next 2 slides render off the UI thread; a transition never starts before its slide is rendered — the current one is held). Space / ←/→ (cut) / Esc and a control bar (previous, play/pause, next, n / N, end) that shows on pointer movement. Missing: the Slideshow module view and its "preview in the view" (phase 2 of the module plan), music and sync to music (LRC-SS-MUSIC), pan & zoom, manual-advance mode, choosing the screen to play on, titles on the slides (LRC-SS-TITLES). Slides are composed with the layout, options and backdrop (LRC-SS-LAYOUT / OPTIONS / BACKDROP) and carry the overlays (LRC-SS-OVERLAYS) |
| 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 | ⬜ | | |
diff --git a/docs/whats-new.md b/docs/whats-new.md
index a59175377..6f14bced6 100644
--- a/docs/whats-new.md
+++ b/docs/whats-new.md
@@ -2,6 +2,19 @@
## 2026-10-10
+### Slideshow overlays
+- Slides can now carry Lightroom Classic's Slideshow overlays: an identity plate (a line of text in a colour, or an
+ image file such as a PNG logo with transparency, at a size and opacity, optionally drawn behind the photo), the
+ photo's rating as stars, and any number of text overlays (up to 16) built from tokens: `{caption}`, `{title}`,
+ `{file}`, `{date}`, `{exposure}` ("1/250 s at f/8"), `{iso}`, `{focal}`, `{camera}`, `{lens}`, `{rating}` and the
+ other file-naming tokens, with a size, colour, opacity and an optional soft shadow (opacity, offset, radius, angle).
+ Each sits at one of nine anchors of the slide or of the photo, moved by an offset, and never leaves the slide.
+- The export watermark can be drawn on every slide's photo too ("Use export watermark" takes the one you last
+ exported with).
+- Set them in Settings ▸ Slideshow ▸ Overlays; the slide preview there and View ▸ Slideshow show them. Sizes are a
+ share of the slide, so slides look the same on any screen. They are saved with the library. Agents use
+ `slideshow.overlays`; `slideshow.preview` now also returns where each overlay landed.
+
### Slideshow layout, options and backdrop
- Slides can now be laid out like Lightroom Classic's Slideshow Layout, Options and Backdrop panels: margins (all four
linked, or each on its own), Zoom to Fill Frame (crop the photo to fill its cell), a stroke border (colour, width),