LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Merge slideshow-overlays into slideshow-titles (origin/main: title-screen RenderResult gains main's gpu_fallback field; tracker summary refreshed)
Jason Baldwin41c9cd3817e5
diff --cc crates/engine/src/slide_title.rsindex 79ac3489c,000000000..5885463b1mode 100644,000000..100644--- a/crates/engine/src/slide_title.rs+++ b/crates/engine/src/slide_title.rs@@@ -1,526 -1,0 +1,527 @@@+//! Slideshow title screens (Lightroom Classic's Slideshow ▸ Titles panel): an intro shown before+//! the first slide and an ending shown after the last one, each switched on on its own, with a+//! background colour and, centred on it, the identity plate (the one of the Overlays panel: its+//! text or image) or a line of text, at a scale. [`TitleSettings`] is a library preference+//! (`prefs.json`), edited with the `slideshow.titles` command; [`TitleCompose`] draws one screen.+//!+//! **One composer:** a title screen is a slide with no photo: `lightcraft_slideshow::compose`+//! fills it with the title's colour, then the overlay code ([`crate::slide_overlay`]) draws the+//! plate or text with the shared text renderer ([`crate::text`]). Playback, the Settings preview+//! and `slideshow.preview {title}` all go through [`TitleCompose::compose`], so they draw the same+//! pixels.+//!+//! **Timing** is in [`crate::slideshow::Playback`]: each screen stays up for its own duration+//! (default: the slide duration) and fades in and out with the playback fade.+//!+//! **Resolution independence:** the scale is the height of the plate (or of a text line) as a+//! fraction of the slide's shorter side; text wider than the slide is scaled down to fit.+//!+//! **Never crash:** settings are validated by [`TitleSettings::merged`] and clamped by+//! [`TitleSettings::sanitized`]; an unreadable plate image draws the colour alone (and+//! `slideshow.titles` reports it).++use std::sync::Arc;++use lightcraft_raster::Rgba8;+use lightcraft_slideshow::{Layout, Rect, SlideSettings, hex, parse_color};+use serde::{Deserialize, Serialize};+use serde_json::{Map, Value, json};++use crate::export::Anchor;+use crate::slide_overlay::{IdentityPlate, OverlaySettings, PLATE_SIZE_MAX, Placement, RelativeTo, SIZE_MIN, SlideOverlays, TEXT_MAX_CHARS};+pub use crate::slideshow::Title;++/// Widest a title's plate or text may be (fraction of the slide's width): wider is scaled down.+pub const FIT_WIDTH: f64 = 0.9;++/// What a title screen shows on its colour.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub enum TitleContent {+ /// The colour alone.+ None,+ /// The identity plate of the Overlays panel (its text or image).+ #[default]+ IdentityPlate,+ /// This screen's own text.+ Text,+}++impl TitleContent {+ pub const ALL: [TitleContent; 3] = [TitleContent::None, TitleContent::IdentityPlate, TitleContent::Text];++ pub fn id(self) -> &'static str {+ match self {+ TitleContent::None => "none",+ TitleContent::IdentityPlate => "identityPlate",+ TitleContent::Text => "text",+ }+ }++ fn parse(s: &str) -> Option<TitleContent> {+ TitleContent::ALL.into_iter().find(|c| c.id().eq_ignore_ascii_case(s.trim()))+ }+}++/// One title screen.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase")]+pub struct TitleScreen {+ pub enabled: bool,+ /// The screen's background colour.+ pub color: [u8; 3],+ pub content: TitleContent,+ /// The text drawn with [`TitleContent::Text`].+ pub text: String,+ /// Draw the plate or text in [`Self::text_color`] (off: in the identity plate's colour).+ /// An image plate keeps its own colours.+ pub override_color: bool,+ pub text_color: [u8; 3],+ /// Height of the plate (or of a text line), fraction of the slide's shorter side.+ pub scale: f64,+ /// Seconds the screen stays up (`None`: the slide duration).+ pub duration: Option<f64>,+}++impl TitleScreen {+ fn new(text: &str) -> Self {+ TitleScreen {+ enabled: false,+ color: [0, 0, 0],+ content: TitleContent::IdentityPlate,+ text: text.into(),+ override_color: false,+ text_color: [255, 255, 255],+ scale: 0.1,+ duration: None,+ }+ }+}++/// The intro and ending screens.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase")]+pub struct TitleSettings {+ pub intro: TitleScreen,+ pub ending: TitleScreen,+}++impl Default for TitleSettings {+ fn default() -> Self {+ TitleSettings { intro: TitleScreen::new("Welcome"), ending: TitleScreen::new("The End") }+ }+}++impl Default for TitleScreen {+ fn default() -> Self {+ TitleScreen::new("")+ }+}++fn cut(s: &mut String) {+ if let Some((i, _)) = s.char_indices().nth(TEXT_MAX_CHARS) {+ s.truncate(i);+ }+}++const SCREEN_KEYS: &str = "enabled, color, content, text, overrideColor, textColor, scale, duration";++impl TitleScreen {+ fn sanitized(mut self) -> Self {+ cut(&mut self.text);+ self.scale = if self.scale.is_finite() { self.scale.clamp(SIZE_MIN, PLATE_SIZE_MAX) } else { 0.1 };+ self.duration = self.duration.filter(|d| d.is_finite()).map(|d| d.clamp(crate::slideshow::SLIDE_MIN, crate::slideshow::SLIDE_MAX));+ self+ }++ pub 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("content".into(), json!(self.content.id()));+ o.insert("text".into(), json!(self.text));+ o.insert("overrideColor".into(), json!(self.override_color));+ o.insert("textColor".into(), json!(hex(self.text_color)));+ o.insert("scale".into(), json!(self.scale));+ o.insert("duration".into(), json!(self.duration));+ Value::Object(o)+ }++ fn merge(&mut self, ctx: &str, v: &Value) -> Result<(), String> {+ let obj = v.as_object().ok_or_else(|| format!("`{ctx}` must be an object, not {v}"))?;+ let num = |k: &str, v: &Value| match v.as_f64() {+ Some(x) if x.is_finite() => Ok(x),+ _ => Err(format!("`{ctx}.{k}` must be a finite number, not {v}")),+ };+ let boolean = |k: &str, v: &Value| v.as_bool().ok_or_else(|| format!("`{ctx}.{k}` must be true or false, not {v}"));+ let colour = |k: &str, v: &Value| parse_color(v).ok_or_else(|| format!("`{ctx}.{k}` must be \"#rrggbb\" or [r, g, b] (0–255), not {v}"));+ for (k, v) in obj {+ match k.as_str() {+ "enabled" => self.enabled = boolean(k, v)?,+ "color" => self.color = colour(k, v)?,+ "content" => {+ self.content = v+ .as_str()+ .and_then(TitleContent::parse)+ .ok_or_else(|| format!("`{ctx}.content` must be \"none\", \"identityPlate\" or \"text\", not {v}"))?+ }+ "text" => {+ let mut s = v.as_str().ok_or_else(|| format!("`{ctx}.text` must be text, not {v}"))?.to_string();+ cut(&mut s);+ self.text = s;+ }+ "overrideColor" => self.override_color = boolean(k, v)?,+ "textColor" => self.text_color = colour(k, v)?,+ "scale" => self.scale = num(k, v)?,+ "duration" => {+ self.duration = match v {+ Value::Null => None,+ _ => Some(num(k, v).map_err(|_| format!("`{ctx}.duration` must be seconds or null (the slide duration), not {v}"))?),+ }+ }+ _ => return Err(format!("unknown key `{ctx}.{k}` ({SCREEN_KEYS})")),+ }+ }+ Ok(())+ }+}++impl TitleSettings {+ pub fn screen(&self, t: Title) -> &TitleScreen {+ match t {+ Title::Intro => &self.intro,+ Title::Ending => &self.ending,+ }+ }++ /// Every value in range (non-finite numbers take the defaults).+ pub fn sanitized(mut self) -> Self {+ self.intro = self.intro.sanitized();+ self.ending = self.ending.sanitized();+ self+ }++ pub fn to_json(&self) -> Value {+ json!({"intro": self.intro.to_json(), "ending": self.ending.to_json()})+ }++ /// These settings with the keys `p` names changed, validated and clamped; a wrong type or an+ /// unknown key is an error and nothing changes.+ 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() {+ "intro" => s.intro.merge(k, v)?,+ "ending" => s.ending.merge(k, v)?,+ _ => return Err(format!("unknown setting `{k}` (intro, ending)")),+ }+ }+ Ok(s.sanitized())+ }++ /// How long each screen that is on stays up, given the slide duration (for+ /// [`crate::slideshow::Playback::with_titles`]): (intro, ending).+ pub fn durations(&self, slide: f64) -> (Option<f64>, Option<f64>) {+ let d = |s: &TitleScreen| s.enabled.then(|| s.duration.unwrap_or(slide));+ (d(&self.intro), d(&self.ending))+ }++ /// Problems worth telling the user about: a screen showing an identity plate image that+ /// can't be read, or one with nothing to show.+ pub fn warnings(&self, overlays: &OverlaySettings) -> Vec<String> {+ let mut out = Vec::new();+ let plate = &overlays.identity_plate;+ for t in Title::ALL {+ let s = self.screen(t);+ if !s.enabled {+ continue;+ }+ match s.content {+ TitleContent::IdentityPlate if !plate.image.trim().is_empty() && crate::export::watermark_logo(plate.image.trim()).is_none() => {+ out.push(format!("{} screen: identity plate image {} can't be read; only the colour shows", t.id(), plate.image.trim()))+ }+ TitleContent::IdentityPlate if plate.image.trim().is_empty() && plate.text.trim().is_empty() => {+ out.push(format!("{} screen: the identity plate has no text or image; only the colour shows", t.id()))+ }+ TitleContent::Text if s.text.trim().is_empty() => out.push(format!("{} screen: no text; only the colour shows", t.id())),+ _ => {}+ }+ }+ out+ }+}++/// How to draw one title screen at a size: its colour and its plate or text, resolved from the+/// library's settings (no session needed, so it runs on a render worker).+#[derive(Clone, Debug)]+pub struct TitleCompose {+ pub title: Title,+ /// The screen as a slide: its colour as the backdrop, nothing else.+ pub settings: SlideSettings,+ /// The plate or text, as a centred identity plate (`None`: the colour alone).+ pub overlays: Option<Arc<SlideOverlays>>,+ pub width: usize,+ pub height: usize,+}++impl TitleCompose {+ /// Screen `title` of `titles` at `width × height` (a bigger one is drawn at the composer's+ /// [`lightcraft_slideshow::MAX_SIDE`]),+ /// with `overlays`' identity plate when the screen shows it.+ pub fn new(titles: &TitleSettings, overlays: &OverlaySettings, title: Title, width: usize, height: usize) -> Self {+ let s = titles.screen(title).clone().sanitized();+ let settings = SlideSettings { backdrop_color: s.color, ..SlideSettings::default() }.sanitized();+ let plate = &overlays.identity_plate;+ let centre = Placement { anchor: Anchor::Center, offset_x: 0.0, offset_y: 0.0, relative_to: RelativeTo::Slide };+ let colour = |own: [u8; 3]| if s.override_color { s.text_color } else { own };+ let shown = match s.content {+ TitleContent::None => None,+ TitleContent::IdentityPlate => Some(IdentityPlate {+ enabled: true,+ text: plate.text.clone(),+ image: plate.image.clone(),+ size: s.scale,+ color: colour(plate.color),+ opacity: plate.opacity,+ place: centre,+ behind: false,+ }),+ TitleContent::Text => Some(IdentityPlate {+ enabled: true,+ text: s.text.clone(),+ image: String::new(),+ size: s.scale,+ color: colour(plate.color),+ opacity: 1.0,+ place: centre,+ behind: false,+ }),+ };+ let mut compose = TitleCompose { title, settings, overlays: None, width, height };+ if let Some(p) = shown.filter(|p| !p.text.trim().is_empty() || !p.image.trim().is_empty()) {+ let resolved =+ |p: IdentityPlate| Arc::new(SlideOverlays::resolve(&OverlaySettings { identity_plate: p, ..OverlaySettings::default() }, None));+ compose.overlays = Some(resolved(p.clone()));+ // a long text (or a wide logo) at a large scale: shrink it to fit the slide's width+ if let Some(b) = compose.plate_box() {+ let max = FIT_WIDTH * compose.layout().slide.width();+ if b.width() > max && b.width() > 0.0 {+ let size = (p.size * max / b.width()).max(SIZE_MIN);+ compose.overlays = Some(resolved(IdentityPlate { size, ..p }));+ }+ }+ }+ compose+ }++ fn layout(&self) -> Layout {+ lightcraft_slideshow::layout(&self.settings, 1.0, self.width, self.height)+ }++ /// Where the plate or text is on the screen (`None`: nothing is drawn but the colour).+ pub fn plate_box(&self) -> Option<Rect> {+ let o = self.overlays.as_ref()?;+ o.boxes(&self.layout()).into_iter().next().map(|(_, r)| r)+ }++ /// What makes the screen's pixels differ (for render keys).+ pub fn key(&self) -> u64 {+ use std::hash::{Hash, Hasher};+ let mut h = std::collections::hash_map::DefaultHasher::new();+ "title".hash(&mut h);+ self.title.hash(&mut h);+ self.settings.pixel_key().hash(&mut h);+ self.overlays.as_ref().map(|o| o.key()).hash(&mut h);+ (self.width, self.height).hash(&mut h);+ h.finish()+ }++ /// The screen's pixels.+ pub fn compose(&self) -> Rgba8 {+ let empty = Rgba8::new(0, 0);+ let (mut img, l) = lightcraft_slideshow::compose_with(&empty, None, &self.settings, self.width, self.height, &mut |_, _| {});+ if let Some(o) = &self.overlays {+ o.draw_front(&mut img, &l);+ }+ img+ }++ /// [`Self::compose`] as a render result (for a frontend's render queue): request `request_id`,+ /// under this screen's key. Title screens show no photo (`photo` is 0).+ pub fn result(&self, request_id: u64) -> crate::media::RenderResult {+ let image = self.compose();+ let histogram = lightcraft_raster::Histogram::of_srgb8(&image);+ crate::media::RenderResult {+ request_id,+ source_key: None,+ photo: lightcraft_catalog::PhotoId(0),+ level: crate::media::SourceLevel::Preview,+ key: self.key(),+ rendered: Ok(lightcraft_pipeline::Rendered { image, histogram, deep: None }),+ loaded: None,+ quick: None,+ display: None,++ gpu_fallback: None,+ }+ }+}++impl crate::Session {+ /// Title screen `title` at `width × height` with the library's titles and identity plate.+ pub fn title_compose(&self, title: Title, width: usize, height: usize) -> Arc<TitleCompose> {+ Arc::new(TitleCompose::new(&self.slide_titles, &self.slide_overlays, title, width, height))+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn at(img: &Rgba8, x: usize, y: usize) -> [u8; 3] {+ let p = img.get(x, y);+ [p[0], p[1], p[2]]+ }++ /// The bounding box of the pixels that differ from `bg` (x0, y0, x1, y1).+ fn ink(img: &Rgba8, bg: [u8; 3]) -> Option<(usize, usize, usize, usize)> {+ let mut b: Option<(usize, usize, usize, usize)> = None;+ for y in 0..img.height {+ for x in 0..img.width {+ let c = at(img, x, y);+ if c.iter().zip(bg).any(|(a, b)| a.abs_diff(b) > 40) {+ b = Some(match b {+ None => (x, y, x + 1, y + 1),+ Some((x0, y0, x1, y1)) => (x0.min(x), y0.min(y), x1.max(x + 1), y1.max(y + 1)),+ });+ }+ }+ }+ b+ }++ fn text_titles(scale: f64) -> TitleSettings {+ TitleSettings::default()+ .merged(&json!({"intro": {"enabled": true, "color": "#203040", "content": "text", "text": "Holiday", "overrideColor": true, "textColor": "#ffcc00", "scale": scale}}))+ .unwrap()+ }++ #[test]+ fn a_text_title_is_centred_in_its_colours_and_scales_with_the_slide() {+ let o = OverlaySettings::default();+ let t = text_titles(0.2);+ let mut boxes = Vec::new();+ for (w, h) in [(400, 250), (800, 500)] {+ let c = TitleCompose::new(&t, &o, Title::Intro, w, h);+ let img = c.compose();+ assert_eq!((img.width, img.height), (w, h));+ assert_eq!(at(&img, 2, 2), [0x20, 0x30, 0x40], "the title's colour");+ let (x0, y0, x1, y1) = ink(&img, [0x20, 0x30, 0x40]).expect("the text is drawn");+ // centred (glyph ink sits inside the line box, so allow some slack vertically)+ let (cx, cy) = ((x0 + x1) as f64 / 2.0, (y0 + y1) as f64 / 2.0);+ assert!((cx - w as f64 / 2.0).abs() < w as f64 * 0.03, "centred across: {cx} of {w}");+ assert!((cy - h as f64 / 2.0).abs() < h as f64 * 0.06, "centred down: {cy} of {h}");+ let mid = at(&img, (x0..x1).find(|x| at(&img, *x, (y0 + y1) / 2) != [0x20, 0x30, 0x40]).unwrap_or(x0), (y0 + y1) / 2);+ assert!(mid[0] > 150 && mid[2] < 120, "drawn in the text colour: {mid:?}");+ boxes.push(((x1 - x0) as f64 / w as f64, (y1 - y0) as f64 / h as f64));+ let b = c.plate_box().unwrap();+ assert!((b.height() - 0.2 * h as f64).abs() < 2.0, "the scale is the line height: {b:?}");+ }+ let ((w1, h1), (w2, h2)) = (boxes[0], boxes[1]);+ assert!((w1 - w2).abs() < 0.02 && (h1 - h2).abs() < 0.02, "proportional at two sizes: {boxes:?}");+ // a bigger scale draws bigger text+ let big = ink(&TitleCompose::new(&text_titles(0.3), &o, Title::Intro, 800, 500).compose(), [0x20, 0x30, 0x40]).unwrap();+ assert!((big.2 - big.0) as f64 / 800.0 > w2 * 1.3);+ }++ #[test]+ fn the_identity_plate_shows_in_its_own_colour_unless_overridden() {+ let o = OverlaySettings::default()+ .merged(&json!({"identityPlate": {"text": "Studio", "color": "#00ff00", "opacity": 1, "anchor": "topLeft"}}))+ .unwrap();+ assert!(!o.identity_plate.enabled, "the overlay plate itself may be off");+ let t = TitleSettings::default().merged(&json!({"ending": {"enabled": true, "color": "#000000", "scale": 0.15}})).unwrap();+ let img = TitleCompose::new(&t, &o, Title::Ending, 600, 400).compose();+ let (x0, y0, x1, y1) = ink(&img, [0, 0, 0]).expect("the plate is drawn");+ assert!(x0 > 100 && x1 < 500 && y0 > 120 && y1 < 280, "centred, not at the overlay's anchor: {:?}", (x0, y0, x1, y1));+ let greens = (y0..y1).flat_map(|y| (x0..x1).map(move |x| (x, y))).filter(|&(x, y)| {+ let c = at(&img, x, y);+ c[1] > 200 && c[0] < 60+ });+ assert!(greens.count() > 100, "in the plate's colour");+ let over = t.merged(&json!({"ending": {"overrideColor": true, "textColor": "#ff0000"}})).unwrap();+ let img = TitleCompose::new(&over, &o, Title::Ending, 600, 400).compose();+ let reds = img.data.iter().filter(|p| p[0] > 200 && p[1] < 60).count();+ assert!(reds > 100, "overridden");+ // the colour alone+ let none = t.merged(&json!({"ending": {"content": "none", "color": "#123456"}})).unwrap();+ let c = TitleCompose::new(&none, &o, Title::Ending, 64, 40);+ assert!(c.plate_box().is_none());+ assert!(c.compose().data.iter().all(|p| p[..3] == [0x12, 0x34, 0x56]));+ }++ #[test]+ fn a_missing_plate_image_draws_the_colour_and_is_reported() {+ let o = OverlaySettings::default().merged(&json!({"identityPlate": {"image": "/no/such/logo.png"}})).unwrap();+ let t = TitleSettings::default().merged(&json!({"intro": {"enabled": true, "color": "#336699"}})).unwrap();+ let c = TitleCompose::new(&t, &o, Title::Intro, 120, 80);+ assert!(c.compose().data.iter().all(|p| p[..3] == [0x33, 0x66, 0x99]));+ let w = t.warnings(&o);+ assert!(w.iter().any(|w| w.contains("intro") && w.contains("can't be read")), "{w:?}");+ let t = t.merged(&json!({"intro": {"content": "text", "text": " "}})).unwrap();+ assert!(t.warnings(&o).iter().any(|w| w.contains("no text")));+ }++ #[test]+ fn long_text_is_scaled_down_to_fit_the_width() {+ let t = TitleSettings::default()+ .merged(&json!({"intro": {"enabled": true, "content": "text", "text": "A very long title that would never fit across", "scale": 0.5}}))+ .unwrap();+ let c = TitleCompose::new(&t, &OverlaySettings::default(), Title::Intro, 800, 450);+ let b = c.plate_box().unwrap();+ assert!(b.width() <= 800.0 * FIT_WIDTH + 2.0 && b.x0 >= 0.0, "{b:?}");+ }++ #[test]+ fn settings_are_validated_clamped_and_round_trip() {+ let d = TitleSettings::default();+ assert!(!d.intro.enabled && !d.ending.enabled, "off by default");+ assert_eq!(d.durations(4.0), (None, None));+ for bad in [+ json!({"intro": {"enabled": 1}}),+ json!({"intro": {"color": "#12"}}),+ json!({"ending": {"content": "video"}}),+ json!({"ending": {"scale": "big"}}),+ json!({"ending": {"duration": "long"}}),+ json!({"intro": {"sparkle": true}}),+ json!({"intro": []}),+ json!({"credits": {}}),+ json!({"INTRO": {}}),+ json!([1]),+ ] {+ assert!(d.merged(&bad).is_err(), "{bad}");+ }+ let s = d+ .merged(&json!({"intro": {"enabled": true, "scale": 9, "duration": 1e9}, "ending": {"enabled": true, "scale": -1, "duration": 0}}))+ .unwrap();+ assert_eq!((s.intro.scale, s.ending.scale), (PLATE_SIZE_MAX, SIZE_MIN));+ assert_eq!((s.intro.duration, s.ending.duration), (Some(crate::slideshow::SLIDE_MAX), Some(crate::slideshow::SLIDE_MIN)));+ assert_eq!(s.durations(4.0), (Some(crate::slideshow::SLIDE_MAX), Some(crate::slideshow::SLIDE_MIN)));+ let s = s.merged(&json!({"intro": {"duration": null}})).unwrap();+ assert_eq!(s.durations(4.0).0, Some(4.0), "null: the slide duration");+ assert_eq!(d.merged(&s.to_json()).unwrap(), s, "the JSON form reads back");+ let back: TitleSettings = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();+ assert_eq!(back, s);+ let partial: TitleSettings = serde_json::from_str(r#"{"ending": {"enabled": true}}"#).unwrap();+ assert!(partial.ending.enabled && !partial.intro.enabled);+ // NaN / ∞ from a hand-edited file+ let s = TitleSettings { intro: TitleScreen { scale: f64::NAN, duration: Some(f64::INFINITY), ..d.intro.clone() }, ..d.clone() }.sanitized();+ assert_eq!((s.intro.scale, s.intro.duration), (0.1, None));+ // any size composes+ for (w, h) in [(0, 0), (1, 100_000), (usize::MAX, 3)] {+ let c = TitleCompose::new(&text_titles(0.5), &OverlaySettings::default(), Title::Intro, w, h);+ let img = c.compose();+ assert!(img.width >= 1 && img.height >= 1 && img.width <= lightcraft_slideshow::MAX_SIDE);+ }+ }+}diff --cc docs/control-protocol.mdindex efe960c43,d5dcb94f1..89abc10da--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@@ -79,10 -79,17 +79,18 @@@ filmstrip is visible| `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.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 |+| `engine.execute {command: "slideshow.titles"}` | `{intro?: screen, ending?: screen}`, a screen being `{enabled?, color?, content?: "none"\|"identityPlate"\|"text", text?, overrideColor?, textColor?, scale?, duration?: seconds\|null}` | The intro and ending screens, saved with the library: a background colour and, centred, the Overlays identity plate or the screen's own text, in the plate's colour or `textColor` when `overrideColor` is on, `scale` = its height as a fraction of the slide's shorter side; `duration` null = the slide duration. The intro plays once before the first photo, the ending after the last when repeat is off. Replies with the settings and `warnings` |+| `engine.execute {command: "slideshow.preview"}` | `{id?, title?, width?, height?, path?}` | One slide composed with the layout and overlays, as the slideshow plays it (with `title: "intro"\|"ending"`, that title screen instead → `{title, enabled, width, height, plate}`): 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 |+ White balance (`develop.set` with `wb.temp` / `wb.tint`, `develop.wb`, `develop.wbPick`) is in Kelvin and tint on+ raws with colour matrices — in the file (DNG) or measured for the camera model (`lightcraft_raw::spectral`; issue+ #730) — where As Shot reads the file's as-shot white; rendered files and raws without matrices use a relative scale+ whose 6500 K / 0 is the as-shot look (the Edit panel shows it as −100..+100). The stored `wb` of such a Kelvin raw+ says `"scale": "kelvin"`; a partial settings JSON given to `develop.merge` or a preset whose `wb` sets `temp` / `tint`+ **without** `scale` keeps the relative meaning it always had (6500 = as shot) on every raw, so agents that mean+ Kelvin on a Kelvin raw pass `"scale": "kelvin"` or use `develop.set` / `develop.wb`.+Image navigation is also available directly as the UI command `view.navigate`, with`{zoom?: "fit" | "fill" | {"percent": number}, pan?: [x, y]}`. Percentage zoom accepts fractionalvalues greater than 0 and at most 800; pan is the normalized image centre, with coordinates from 0 to 1.diff --cc docs/whats-new.mdindex 83d5a7ff1,cefb53ffc..f67841250--- a/docs/whats-new.md+++ b/docs/whats-new.md@@@ -1,19 -1,37 +1,49 @@@# What's new in LightCraft- ## 2026-10-10+ ## 2026-10-11++ ### Open Library knows a Lightroom catalog+ - Choosing a Lightroom Classic catalog folder in File → Open Library… (or one of its `Previews.lrdata` /+ `.lrcat-data` folders, or the `.lrcat`) no longer makes an empty LightCraft library inside it (issue #891). The+ library open now stays, and LightCraft says "This is a Lightroom catalog, not a LightCraft library" and offers+ **Import Lightroom Catalog…** with that catalog, or Cancel. `lightcraft-cli --library` refuses those folders too.++ ### Canon EOS R5 Mark II+ - Canon EOS R5 Mark II C-RAW files that opened as "preview only" (more than half of them, depending on the+ scene) now develop from their sensor data with every editing tool, like the camera's other raws. Photos+ imported earlier switch over with Photo ▸ Reload from Disk.++ ### Switching libraries+ - File ▸ New Library… asks for a name, then where to put it, and opens the new library (issue #902).+ - File ▸ Open Recent Library lists the last 8 libraries; ones that are gone (moved, drive disconnected) are greyed+ out. Clear Recent Libraries empties the list.+ - The open library's name shows under My Photos at the top of the left panel and in the window title.+ - `lightcraft-cli --library` given a library's own file (`catalog.snap`) opens its folder instead of failing with+ "File exists".+ - Agents use `app.newLibrary {path, name}`, `app.recentLibraries` and `app.clearRecentLibraries`.++ ### Edit in PhotoCraft+ - Right-click a photo ▸ Edit In ▸ Edit in PhotoCraft (or Photo ▸ Edit In, ⇧⌘E) renders a copy with your edits, stacks it+ with the original and opens it in PhotoCraft. LightCraft finds PhotoCraft where its installer put it (Windows,+ macOS, Linux packages, AppImage, Flatpak), and says so if it isn't installed, before making a copy.+ - The copy is a 16-bit PSD by default, which PhotoCraft saves straight back to with File ▸ Save; when you come back to+ LightCraft the copy shows what you saved.+ - Settings ▸ General ▸ External Editing: the format (PSD or TIFF), colour space and bit depth for PhotoCraft and for+ the other editor (Edit in Other Editor, now ⌥⌘E), and where PhotoCraft is if you use a portable copy.+ - Export can write PSD too (flat, 8- or 16-bit).+### Slideshow intro and ending screens+- A slideshow can now open with an intro screen and close with an ending screen, like Lightroom Classic's Titles+ panel. Each is switched on on its own and has a background colour and, centred on it, your identity plate (the one+ set under Overlays: its text or image) or a line of text of its own, in the plate's colour or one you pick, at a+ scale. Each stays up for its own duration (by default the slide duration) and fades in and out like a slide.+- The intro plays once before the first photo; the ending after the last photo when Repeat is off (while repeating+ the show runs until you stop it, so the ending doesn't come up). Random order never moves them, ←/→ step across them,+ and the control bar says Intro or End while one is up (the photo count only counts photos).+- Set them in Settings ▸ Slideshow ▸ Titles; the preview there switches between the photo's slide, the intro and the+ ending. They are saved with the library. Agents use `slideshow.titles`, and `slideshow.preview {title: "intro"}`+ renders a screen as a PNG.+### Slideshow overlays- Slides can now carry Lightroom Classic's Slideshow overlays: an identity plate (a line of text in a colour, or animage file such as a PNG logo with transparency, at a size and opacity, optionally drawn behind the photo), the