LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LR-MASK-EFFECTS: manage, group and fully import local adjustment presets (engine)
OneSlips0f40a2d2f590
diff --git a/crates/engine/src/cmd/mask_effect_files.rs b/crates/engine/src/cmd/mask_effect_files.rsnew file mode 100644index 000000000..e1e099bc8--- /dev/null+++ b/crates/engine/src/cmd/mask_effect_files.rs@@ -0,0 +1,681 @@+//! Mask effect preset files: Lightroom Classic local adjustment presets (`.lrtemplate`, Lua,+//! `type = "LocalizedAdjustmentPreset"`), Camera Raw local correction presets (`.xmp` with+//! `crs:Local*` fields, from its `LocalCorrections` folder), our `.lceffect` JSON, and `.zip`+//! bundles of these. Folders, and Lightroom users' "divider" presets (`10 ----- DETAIL ----- 10`,+//! empty presets that head a numbered section of the menu), become groups.+//!+//! Read from the files' public structure and black-box observation; settings we have no slider+//! for are reported and kept with the effect (an export carries them).++use lightcraft_develop::LocalAdjustments;+use serde_json::{Map, Value, json};++use super::mask_effects::{MaskEffect, upsert};+use super::{bad, str_param};+use crate::preset_import::{Lua, group_from_dir, parse_lua, read_zip};+use crate::{Result, Session};++/// File extension of exported effect presets (JSON).+pub const EFFECT_EXT: &str = "lceffect";+/// `format` tag of an exported effect-preset file.+const FILE_FORMAT: &str = "lightcraft.maskEffects";+/// The Lua `type` of a Lightroom local adjustment preset.+const LR_LOCAL_TYPE: &str = "LocalizedAdjustmentPreset";+/// Larger files aren't presets (or bundles of them).+const MAX_FILE: u64 = 64 << 20;+/// How deep nested Lua tables are kept as JSON.+const MAX_DEPTH: usize = 16;++/// An effect read from a file, with the settings it couldn't keep and where it came from.+#[derive(Clone, Debug)]+pub struct Found {+ pub effect: MaskEffect,+ pub unmapped: Vec<String>,+ pub file: String,+ /// Effects of one folder (or folder inside a bundle) share this key: divider presets group+ /// the effects next to them.+ pub dir: String,+ /// The group the folder gives (when the file names none).+ pub dir_group: Option<String>,+ /// The file named its group (`.lceffect`, `crs:Group`): kept.+ pub has_group: bool,+}++/// A readable name for a Lightroom local setting we can't carry over.+fn setting_label(key: &str) -> String {+ let k = key.trim_start_matches("Local");+ let lower = k.to_ascii_lowercase();+ match lower.as_str() {+ "grain" => "Grain".into(),+ "toningluminance" => "Color luminance".into(),+ "pointcolors" => "Point Color".into(),+ "refinesaturation" => "Refine Saturation".into(),+ "curverefinesaturation" => "Refine Saturation".into(),+ "maincurve" | "redcurve" | "greencurve" | "bluecurve" => "Curve".into(),+ _ => k.to_string(),+ }+}++/// A Lua value as JSON (tables nested at most [`MAX_DEPTH`] deep).+fn lua_json(v: &Lua, depth: usize) -> Value {+ match v {+ Lua::Nil => Value::Null,+ Lua::Bool(b) => json!(b),+ Lua::Num(n) => serde_json::Number::from_f64(*n).map(Value::Number).unwrap_or(Value::Null),+ Lua::Str(s) => json!(s),+ Lua::Table(..) if depth >= MAX_DEPTH => Value::Null,+ Lua::Table(items, fields) if fields.is_empty() => Value::Array(items.iter().map(|x| lua_json(x, depth + 1)).collect()),+ Lua::Table(_, fields) => Value::Object(fields.iter().map(|(k, x)| (k.clone(), lua_json(x, depth + 1))).collect()),+ }+}++/// Does a setting value do anything (a non-zero number, a non-empty table, …)?+fn meaningful(v: &Value) -> bool {+ match v {+ Value::Null => false,+ Value::Bool(b) => *b,+ Value::Number(n) => n.as_f64().is_some_and(|x| x.abs() > 1e-9),+ Value::String(s) => !s.is_empty(),+ Value::Array(a) => !a.is_empty(),+ Value::Object(o) => !o.is_empty(),+ }+}++/// Is `text` a Lightroom local adjustment preset (`.lrtemplate`)?+pub fn is_lr_local_template(text: &str) -> bool {+ parse_lua(text.trim_start_matches('\u{feff}'))+ .ok()+ .and_then(|root| root.get("type").and_then(Lua::str).map(|t| t == LR_LOCAL_TYPE))+ .unwrap_or(false)+}++/// `$$$/Path/Key=Default` (a localisable string) → `Default`.+fn delocalize(t: &str) -> &str {+ t.strip_prefix("$$$/").and_then(|r| r.split_once('=')).map_or(t, |(_, d)| d)+}++/// A Lightroom local adjustment preset → an effect named after its title (else `stem`), and the+/// settings we have no equivalent for (e.g. `Grain`, `Point Color`), which the effect keeps in+/// `extra`.+pub fn parse_lr_local_template(text: &str, stem: &str) -> std::result::Result<(MaskEffect, Vec<String>), String> {+ let root = parse_lua(text.trim_start_matches('\u{feff}'))?;+ if root.get("type").and_then(Lua::str) != Some(LR_LOCAL_TYPE) {+ return Err("not a local adjustment preset".into());+ }+ let Some(Lua::Table(_, fields)) = root.get("value") else { return Err("no adjustments in this local preset".into()) };+ // `exposure2012` → `LocalExposure2012`: the template's keys are the XMP `Local*` names, lower camel case+ let crs = |k: &str| {+ let mut c = k.chars();+ c.next().map(|f| format!("Local{}{}", f.to_ascii_uppercase(), c.as_str())).unwrap_or_default()+ };+ let num = |k: &str| fields.iter().find(|(f, _)| crs(f) == k).and_then(|(_, v)| if let Lua::Num(n) = v { Some(*n) } else { None });+ let values = crate::crs_masks::local_values(num);+ let mut extra = Map::new();+ for (k, v) in fields {+ if crate::crs_masks::is_local_field(&crs(k)) {+ continue;+ }+ let j = lua_json(v, 0);+ if meaningful(&j) {+ extra.insert(k.clone(), j);+ }+ }+ let title = root.get("title").or_else(|| root.get("internalName")).and_then(Lua::str).map(str::trim).filter(|t| !t.is_empty());+ let name = title.map(|t| delocalize(t).trim().to_string()).filter(|t| !t.is_empty()).unwrap_or_else(|| stem.to_string());+ build(name, values, extra)+}++fn build(name: String, values: Map<String, Value>, extra: Map<String, Value>) -> std::result::Result<(MaskEffect, Vec<String>), String> {+ let adjust: LocalAdjustments = serde_json::from_value(Value::Object(values)).map_err(|e| format!("unreadable local preset: {e}"))?;+ let mut unmapped: Vec<String> = extra.keys().map(|k| setting_label(k)).collect();+ unmapped.sort();+ unmapped.dedup();+ let effect = MaskEffect { name, adjust, extra, ..Default::default() }.normalized();+ Ok((effect, unmapped))+}++/// The local slider fields of a Camera Raw local correction preset: its top-level `crs:Local*`+/// properties, or (a preset typed `Local` without them) its first correction's.+fn xmp_local_fields(d: &lightcraft_meta::XmpData) -> Option<Map<String, Value>> {+ let mut out = Map::new();+ for (k, v) in &d.properties {+ if let Some(name) = k.strip_prefix("crs:").filter(|n| n.starts_with("Local") && !n.contains('/'))+ && let Some(x) = v.first()+ {+ out.insert(name.to_string(), json!(x.trim()));+ }+ }+ if !out.is_empty() {+ return Some(out);+ }+ let typed_local = d.properties.get("crs:PresetType").and_then(|v| v.first()).is_some_and(|t| t.trim().eq_ignore_ascii_case("local"));+ if !typed_local {+ return None;+ }+ let correction = crate::crs_masks::CONTAINERS.iter().find_map(|c| d.values.get(*c).and_then(|l| l.items().first()))?;+ let lightcraft_meta::XmpValue::Struct(m) = correction else { return None };+ for (k, v) in m {+ if let Some(name) = k.strip_prefix("crs:").filter(|n| n.starts_with("Local"))+ && let Some(x) = v.text()+ {+ out.insert(name.to_string(), json!(x));+ }+ }+ Some(out)+}++/// Is `text` a Camera Raw local correction preset (XMP)?+pub fn is_local_xmp(text: &str) -> bool {+ lightcraft_meta::parse_xmp(text.trim_start_matches('\u{feff}')).ok().and_then(|d| xmp_local_fields(&d)).is_some()+}++/// A Camera Raw local correction preset (XMP) → an effect named after `crs:Name` (else `stem`),+/// in `crs:Group` if it names one.+pub fn parse_local_xmp(text: &str, stem: &str) -> std::result::Result<(MaskEffect, Vec<String>), String> {+ let d = lightcraft_meta::parse_xmp(text.trim_start_matches('\u{feff}')).map_err(|e| e.to_string())?;+ let fields = xmp_local_fields(&d).ok_or("not a local correction preset (no crs:Local… settings)")?;+ let num = |v: &Value| v.as_str().map(|s| s.strip_prefix('+').unwrap_or(s)).and_then(|s| s.parse::<f64>().ok()).filter(|x| x.is_finite());+ let values = crate::crs_masks::local_values(|k| fields.get(k).and_then(num));+ let mut extra = Map::new();+ for (k, v) in &fields {+ if crate::crs_masks::is_local_field(k) {+ continue;+ }+ let v = num(v).map_or_else(|| v.clone(), |x| json!(x));+ if meaningful(&v) {+ extra.insert(k.clone(), v);+ }+ }+ let first = |k: &str| d.properties.get(k).and_then(|v| v.first()).map(|s| s.trim().to_string()).filter(|s| !s.is_empty());+ let name = first("crs:Name").unwrap_or_else(|| stem.to_string());+ let (mut e, unmapped) = build(name, values, extra)?;+ e.group = first("crs:Group").unwrap_or_default();+ Ok((e, unmapped))+}++/// Effects in an `.lceffect` file: `{format, version, effects: [...]}`, a bare array, or one effect.+pub fn parse_file(bytes: &[u8]) -> std::result::Result<Vec<MaskEffect>, String> {+ let v: Value = serde_json::from_slice(bytes).map_err(|e| format!("not an effect preset file: {e}"))?;+ let items = match v {+ Value::Object(mut o) if o.contains_key("effects") => o.remove("effects").unwrap_or_default(),+ v @ Value::Array(_) => v,+ v @ Value::Object(_) => Value::Array(vec![v]),+ _ => return Err("not an effect preset file".into()),+ };+ let list: Vec<MaskEffect> = serde_json::from_value(items).map_err(|e| format!("not an effect preset file: {e}"))?;+ let list: Vec<MaskEffect> = list.into_iter().filter(|e| !e.name.trim().is_empty()).map(MaskEffect::normalized).collect();+ if list.is_empty() {+ return Err("no effect presets in the file".into());+ }+ Ok(list)+}++fn ext_of(name: &str) -> String {+ std::path::Path::new(name).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default()+}++fn stem_of(name: &str) -> String {+ std::path::Path::new(name).file_stem().map(|s| s.to_string_lossy().to_string()).filter(|s| !s.is_empty()).unwrap_or_else(|| "Effect".into())+}++type Parsed = std::result::Result<Vec<(MaskEffect, Vec<String>)>, String>;++/// The effects in file `name` (`bytes`) if it is a local preset (`.lrtemplate` of the local type,+/// a local correction `.xmp`, an `.lceffect`); `None` for any other file (a develop preset…).+pub fn parse_bytes(name: &str, bytes: &[u8]) -> Option<Parsed> {+ let stem = stem_of(name);+ match ext_of(name).as_str() {+ "lrtemplate" => {+ let text = String::from_utf8_lossy(bytes);+ is_lr_local_template(&text).then(|| parse_lr_local_template(&text, &stem).map(|e| vec![e]))+ }+ "xmp" => {+ let text = String::from_utf8_lossy(bytes);+ is_local_xmp(&text).then(|| parse_local_xmp(&text, &stem).map(|e| vec![e]))+ }+ EFFECT_EXT => Some(parse_file(bytes).map(|v| v.into_iter().map(|e| (e, Vec::new())).collect())),+ _ => None,+ }+}++/// The group effects in folder `dir` (relative to the imported folder) go to.+pub fn group_for_dir(dir: &str) -> Option<String> {+ effect_group_from_dir(dir)+}++/// Folder names that only say "local presets" (`Local Adjustment Presets`, `LocalCorrections`…)+/// give no group.+fn effect_group_from_dir(dir: &str) -> Option<String> {+ const FILLER: &[&str] = &[+ "local",+ "adjustment",+ "adjustments",+ "localcorrections",+ "corrections",+ "correction",+ "brush",+ "brushes",+ "mask",+ "masks",+ "effect",+ "effects",+ ];+ let generic = |part: &str| {+ let lower = part.to_ascii_lowercase();+ let words: Vec<&str> = lower.split(|c: char| !c.is_alphanumeric()).filter(|w| !w.is_empty()).collect();+ words.iter().any(|w| FILLER.contains(w))+ && words.iter().all(|w| FILLER.contains(w) || matches!(*w, "presets" | "preset" | "lightroom" | "camera" | "raw" | "classic"))+ };+ let kept: Vec<&str> = dir.split(['/', '\\']).filter(|p| !p.is_empty() && !generic(p)).collect();+ group_from_dir(&kept.join("/"))+}++/// Effects found in `bytes` of file `file` (a `.zip` is opened: the local presets inside).+/// `dir_group`: the group the file's folder gives. Errors are `(file, message)`.+pub fn found_in(file: &str, bytes: &[u8], dir_group: Option<String>, out: &mut Vec<Found>, failed: &mut Vec<(String, String)>) -> bool {+ let dir = std::path::Path::new(file).parent().map(|d| d.to_string_lossy().to_string()).unwrap_or_default();+ if ext_of(file) == "zip" {+ let Ok(entries) = read_zip(bytes) else { return false };+ let zip_group = effect_group_from_dir(&stem_of(file)).or(dir_group);+ let mut any = false;+ for (inner, data) in entries {+ let inner_dir = inner.rsplit_once('/').map(|(d, _)| d.to_string()).unwrap_or_default();+ let group = effect_group_from_dir(&inner_dir).or_else(|| zip_group.clone());+ let label = format!("{file}/{inner}");+ match parse_bytes(&inner, &data) {+ Some(Ok(list)) => {+ any = true;+ push(out, list, &label, format!("{file}/{inner_dir}"), group, &inner);+ }+ Some(Err(e)) => {+ any = true;+ failed.push((label, e));+ }+ None => {}+ }+ }+ return any;+ }+ match parse_bytes(file, bytes) {+ Some(Ok(list)) => {+ push(out, list, file, dir, dir_group, file);+ true+ }+ Some(Err(e)) => {+ failed.push((file.to_string(), e));+ true+ }+ None => false,+ }+}++fn push(out: &mut Vec<Found>, list: Vec<(MaskEffect, Vec<String>)>, file: &str, dir: String, dir_group: Option<String>, name: &str) {+ let named = ext_of(name) == EFFECT_EXT;+ for (effect, unmapped) in list {+ let has_group = named || !effect.group.is_empty();+ out.push(Found { effect, unmapped, file: file.to_string(), dir: dir.clone(), dir_group: dir_group.clone(), has_group });+ }+}++/// The number a preset name starts with (`24a-Eye` → 24).+fn leading_number(name: &str) -> Option<u64> {+ let digits: String = name.trim().chars().take_while(char::is_ascii_digit).take(18).collect();+ digits.parse().ok()+}++/// The section title of a divider preset — an effect that sets nothing, named like+/// `10 ----- DETAIL ENHANCERS ----- 10` (a run of at least three `-`, `=`, `_`, `*`, `#`, `~`, `—`).+pub fn divider_title(e: &MaskEffect) -> Option<String> {+ if !e.is_empty() {+ return None;+ }+ let marks = ['-', '=', '_', '*', '#', '~', '—', '–', '•', '.'];+ let chars: Vec<char> = e.name.chars().collect();+ let has_run = chars.windows(3).any(|w| marks.contains(&w[0]) && w[0] == w[1] && w[1] == w[2]);+ if !has_run {+ return None;+ }+ let title: String = e.name.chars().map(|c| if marks.contains(&c) { ' ' } else { c }).collect();+ let title = title.trim().trim_start_matches(|c: char| c.is_ascii_digit() || c.is_whitespace());+ let title = title.trim_end_matches(|c: char| c.is_ascii_digit() || c.is_whitespace());+ let title = title.split_whitespace().collect::<Vec<_>>().join(" ");+ if !title.chars().any(char::is_alphanumeric) {+ return None;+ }+ // "DETAIL ENHANCERS" → "Detail Enhancers"+ let shouting = title.chars().any(char::is_alphabetic) && !title.chars().any(char::is_lowercase);+ Some(if shouting {+ title+ .split(' ')+ .map(|w| {+ let mut c = w.chars();+ c.next().map(|f| f.to_uppercase().chain(c.flat_map(char::to_lowercase)).collect::<String>()).unwrap_or_default()+ })+ .collect::<Vec<_>>()+ .join(" ")+ } else {+ title+ })+}++/// Give `found` their groups; returns the divider presets (which become groups, not effects) as+/// `(found, group)`. A numbered effect goes to the divider with the largest number not above its+/// own (`12 Sky` under `10 --- DETAIL --- 10`); others to their folder's group.+pub fn assign_groups(found: Vec<Found>, group: Option<&str>) -> (Vec<Found>, Vec<(Found, String)>) {+ let (dividers, mut effects): (Vec<(Found, Option<String>)>, Vec<(Found, Option<String>)>) =+ found.into_iter().map(|f| (divider_title(&f.effect).filter(|_| !f.has_group), f)).map(|(t, f)| (f, t)).partition(|(_, t)| t.is_some());+ let dividers: Vec<(Found, String)> = dividers.into_iter().filter_map(|(f, t)| t.map(|t| (f, t))).collect();+ for (f, _) in &mut effects {+ if let Some(g) = group {+ f.effect.group = g.to_string();+ continue;+ }+ if f.has_group {+ continue;+ }+ let section = leading_number(&f.effect.name).and_then(|n| {+ dividers+ .iter()+ .filter(|(d, _)| d.dir == f.dir)+ .filter_map(|(d, t)| leading_number(&d.effect.name).filter(|m| *m <= n).map(|m| (m, t)))+ .max_by_key(|(m, _)| *m)+ .map(|(_, t)| t.clone())+ });+ f.effect.group = section.or_else(|| f.dir_group.clone()).unwrap_or_default();+ }+ (effects.into_iter().map(|(f, _)| f).collect(), dividers)+}++/// Add the found effects (grouped; same-named ones replaced; effects left from an earlier import+/// of a divider dropped) and save → the report rows `(imported, dividers)`.+pub fn add_found(s: &mut Session, found: Vec<Found>, group: Option<&str>, dry: bool) -> Result<(Vec<Value>, Vec<Value>)> {+ let (effects, dividers) = assign_groups(found, group);+ let rows: Vec<Value> =+ effects.iter().map(|f| json!({"name": f.effect.name, "group": f.effect.group, "file": f.file, "unmapped": f.unmapped})).collect();+ let div_rows: Vec<Value> = dividers.iter().map(|(f, g)| json!({"name": f.effect.name, "group": g, "file": f.file})).collect();+ if dry || (effects.is_empty() && dividers.is_empty()) {+ return Ok((rows, div_rows));+ }+ s.mask_effects.retain(|e| !(e.is_empty() && dividers.iter().any(|(d, _)| d.effect.name.eq_ignore_ascii_case(&e.name))));+ for f in effects {+ upsert(s, f.effect);+ }+ s.save_prefs()?;+ Ok((rows, div_rows))+}++/// The files under `paths` an effect import reads (folders walked, at most 8 levels), each with+/// the group its folder gives and whether it was named (not found in a folder).+fn effect_files(paths: &[String]) -> Vec<(String, Option<String>, bool)> {+ fn walk(dir: &std::path::Path, base: &std::path::Path, depth: usize, out: &mut Vec<(String, Option<String>, bool)>) {+ let Ok(rd) = std::fs::read_dir(dir) else { return };+ let mut entries: Vec<_> = rd.flatten().map(|e| e.path()).collect();+ entries.sort();+ for p in entries {+ if p.is_dir() {+ if depth < 8 {+ walk(&p, base, depth + 1, out);+ }+ } else if p.extension().is_some_and(|e| ["lrtemplate", EFFECT_EXT, "xmp", "zip"].iter().any(|x| e.eq_ignore_ascii_case(x))) {+ let rel = p.parent().and_then(|d| d.strip_prefix(base).ok()).map(|d| d.to_string_lossy().to_string());+ out.push((p.to_string_lossy().to_string(), rel.and_then(|d| effect_group_from_dir(&d)), false));+ }+ }+ }+ let mut out = Vec::new();+ for x in paths {+ let p = std::path::Path::new(x);+ if p.is_dir() {+ walk(p, p.parent().unwrap_or(std::path::Path::new("")), 0, &mut out);+ } else {+ out.push((x.clone(), None, true));+ }+ }+ out+}++/// Read a file of at most [`MAX_FILE`] bytes.+pub fn read_capped(path: &str) -> std::result::Result<Vec<u8>, String> {+ let len = std::fs::metadata(path).map_err(|e| e.to_string())?.len();+ if len > MAX_FILE {+ return Err(format!("too large for a preset file ({} MB)", len >> 20));+ }+ std::fs::read(path).map_err(|e| e.to_string())+}++pub fn import_effects(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.importEffects";+ let mut paths: Vec<String> =+ p.get("paths").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect()).unwrap_or_default();+ if let Some(x) = str_param(p, "path") {+ paths.push(x.to_string());+ }+ if paths.is_empty() {+ return Err(bad(C, "missing `path` / `paths`"));+ }+ let group = str_param(p, "group").map(str::trim).filter(|g| !g.is_empty());+ let dry = p.get("dryRun").and_then(Value::as_bool).unwrap_or(false);+ let (mut found, mut failed) = (Vec::new(), Vec::new());+ for (f, dir_group, named) in effect_files(&paths) {+ match read_capped(&f) {+ Ok(bytes) => {+ if !found_in(&f, &bytes, dir_group, &mut found, &mut failed) && named {+ failed.push((f, "not a local adjustment preset".into()));+ }+ }+ Err(e) => failed.push((f, e)),+ }+ }+ let (imported, dividers) = add_found(s, found, group, dry)?;+ Ok(json!({"imported": imported, "dividers": dividers, "failed": failed.into_iter().map(|(f, e)| json!([f, e])).collect::<Vec<_>>()}))+}++pub fn export_effects(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.exportEffects";+ let path = str_param(p, "path").filter(|x| !x.trim().is_empty()).ok_or_else(|| bad(C, "missing `path`"))?;+ let mut path = std::path::PathBuf::from(path);+ if path.extension().is_none() {+ path.set_extension(EFFECT_EXT);+ }+ let names: Option<Vec<String>> =+ p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());+ let group = str_param(p, "group").map(str::trim);+ let chosen: Vec<&MaskEffect> = s+ .mask_effects+ .iter()+ .filter(|e| names.as_ref().is_none_or(|n| n.iter().any(|x| x.eq_ignore_ascii_case(&e.name))))+ .filter(|e| group.is_none_or(|g| g.eq_ignore_ascii_case(&e.group)))+ .collect();+ if chosen.is_empty() {+ return Err(bad(C, "no effect presets to export"));+ }+ if let Some(dir) = path.parent().filter(|d| !d.as_os_str().is_empty()) {+ std::fs::create_dir_all(dir).map_err(|e| crate::EngineError::Other(format!("{}: {e}", dir.display())))?;+ }+ let text = serde_json::to_string_pretty(&json!({"format": FILE_FORMAT, "version": 2, "effects": chosen}))+ .map_err(|e| crate::EngineError::Other(e.to_string()))?;+ std::fs::write(&path, text).map_err(|e| crate::EngineError::Other(format!("{}: {e}", path.display())))?;+ Ok(json!({"path": path.display().to_string(), "count": chosen.len()}))+}++#[cfg(test)]+mod tests {+ use super::*;++ // A synthetic template in the shape Lightroom writes (our own values).+ const TEMPLATE: &str = r#"s = {+ id = "00000000-0000-0000-0000-000000000001",+ internalName = "Soft Glow",+ title = "Soft Glow",+ type = "LocalizedAdjustmentPreset",+ value = {+ clarity = 0.5,+ clarity2012 = -0.25,+ exposure = 0,+ exposure2012 = 0.125,+ grain = 0.25,+ highlights2012 = -0.5,+ luminanceNoise = 0.1,+ refineSaturation = 0,+ temperature = 0.2,+ texture = -0.3,+ toningHue = 240,+ toningLuminance = 0.1,+ toningSaturation = 0,+ pointColors = {+ {+ HueRange = { LowerFull = 0.3, LowerNone = 0, UpperFull = 0.6, UpperNone = 1, },+ HueShift = -0.05,+ RangeAmount = 0.5,+ SrcHue = 0.8,+ },+ },+ },+ version = 0,+}"#;++ #[test]+ fn reads_a_lightroom_local_template() {+ assert!(is_lr_local_template(TEMPLATE));+ let (e, unmapped) = parse_lr_local_template(TEMPLATE, "file").unwrap();+ assert_eq!(e.name, "Soft Glow");+ assert!((e.adjust.exposure - 0.5).abs() < 1e-9, "exposure2012 is a quarter of the stops");+ assert!((e.adjust.clarity + 25.0).abs() < 1e-9, "the 2012 field wins over the old one");+ assert!((e.adjust.highlights + 50.0).abs() < 1e-9);+ assert!((e.adjust.temp - 20.0).abs() < 1e-9);+ assert!((e.adjust.texture + 30.0).abs() < 1e-9);+ assert!((e.adjust.noise - 10.0).abs() < 1e-9);+ assert!((e.adjust.amount - 100.0).abs() < 1e-9);+ assert_eq!(unmapped, vec!["Color luminance".to_string(), "Grain".into(), "Point Color".into()]);+ assert_eq!(e.extra.get("grain"), Some(&json!(0.25)), "kept for export");+ assert_eq!(e.extra["pointColors"][0]["HueRange"]["UpperFull"], json!(0.6));+ assert!(!e.extra.contains_key("refineSaturation"), "zero settings aren't kept");+ }++ #[test]+ fn develop_templates_are_not_local_ones() {+ let develop = r#"s = { title = "X", type = "Develop", value = { settings = { Exposure2012 = 1 } } }"#;+ assert!(!is_lr_local_template(develop));+ assert!(parse_lr_local_template(develop, "x").is_err());+ assert!(parse_bytes("x.lrtemplate", develop.as_bytes()).is_none(), "left to the develop preset import");+ }++ #[test]+ fn malformed_files_are_errors_not_panics() {+ for bad in [+ "garbage {",+ "",+ "s = {",+ r#"s = { type = "LocalizedAdjustmentPreset", value = 3 }"#,+ r#"s = { type = "LocalizedAdjustmentPreset" }"#,+ r#"s = { type = "LocalizedAdjustmentPreset", value = { exposure2012 = "x", grain = {{{{}}}} } }"#,+ "s = { type = \"LocalizedAdjustmentPreset\", value = { exposure2012 = 1e400, contrast2012 = -1e400 } }",+ "\u{feff}s = { type = \"LocalizedAdjustmentPreset\", title = \"\", value = {} }",+ ] {+ let _ = parse_lr_local_template(bad, "x");+ let _ = parse_bytes("x.lrtemplate", bad.as_bytes());+ }+ // deeply nested tables+ let deep = format!("s = {{ type = \"LocalizedAdjustmentPreset\", value = {{ pointColors = {}1{} }} }}", "{".repeat(200), "}".repeat(200));+ let _ = parse_lr_local_template(&deep, "x");+ let (e, _) = parse_lr_local_template("s = { type = \"LocalizedAdjustmentPreset\", value = { exposure2012 = 9 } }", "Stem").unwrap();+ assert_eq!((e.name.as_str(), e.adjust.exposure), ("Stem", 4.0), "values clamp, the file name names it");+ for bad in ["", "<x:xmpmeta", "<x:xmpmeta></x:xmpmeta>", "\u{0}\u{1}"] {+ assert!(parse_bytes("x.xmp", bad.as_bytes()).is_none_or(|r| r.is_err()));+ }+ for bad in ["", "3", "[]", "{\"effects\": 3}", "[{\"name\": 4}]", "{\"effects\": [{\"name\": \" \"}]}"] {+ assert!(parse_file(bad.as_bytes()).is_err(), "{bad}");+ }+ assert!(!found_in("x.zip", b"PK\x05\x06garbage", None, &mut Vec::new(), &mut Vec::new()));+ }++ /// A Camera Raw local correction preset (our own values).+ const ACR: &str = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">+<rdf:Description rdf:about="" xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/"+ crs:PresetType="Local" crs:LocalExposure2012="+0.25" crs:LocalShadows2012="0.4" crs:LocalGrain="0.2" crs:LocalTexture="0">+ <crs:Name><rdf:Alt><rdf:li xml:lang="x-default">Lift Shadows</rdf:li></rdf:Alt></crs:Name>+ <crs:Group><rdf:Alt><rdf:li xml:lang="x-default">Faces</rdf:li></rdf:Alt></crs:Group>+</rdf:Description></rdf:RDF></x:xmpmeta>"#;++ #[test]+ fn reads_a_camera_raw_local_preset() {+ assert!(is_local_xmp(ACR));+ let (e, unmapped) = parse_local_xmp(ACR, "file").unwrap();+ assert_eq!((e.name.as_str(), e.group.as_str()), ("Lift Shadows", "Faces"));+ assert_eq!((e.adjust.exposure, e.adjust.shadows), (1.0, 40.0));+ assert_eq!(unmapped, vec!["Grain".to_string()]);+ // a develop preset is not one+ let develop = ACR+ .replace(+ "crs:LocalExposure2012=\"+0.25\" crs:LocalShadows2012=\"0.4\" crs:LocalGrain=\"0.2\" crs:LocalTexture=\"0\"",+ "crs:Exposure2012=\"1\"",+ )+ .replace("PresetType=\"Local\"", "PresetType=\"Normal\"");+ assert!(!is_local_xmp(&develop));+ // a preset typed Local that keeps its sliders in a correction+ let nested = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">+<rdf:Description rdf:about="" xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:PresetType="Local">+ <crs:MaskGroupBasedCorrections><rdf:Seq><rdf:li><rdf:Description crs:What="Correction" crs:LocalClarity2012="-0.5"/></rdf:li></rdf:Seq></crs:MaskGroupBasedCorrections>+</rdf:Description></rdf:RDF></x:xmpmeta>"#;+ let (e, _) = parse_local_xmp(nested, "Soft").unwrap();+ assert_eq!((e.name.as_str(), e.adjust.clarity), ("Soft", -50.0));+ }++ fn found(name: &str, exposure: f64, dir: &str) -> Found {+ Found {+ effect: MaskEffect { name: name.into(), adjust: LocalAdjustments { exposure, ..Default::default() }, ..Default::default() },+ unmapped: Vec::new(),+ file: format!("{dir}/{name}.lrtemplate"),+ dir: dir.into(),+ dir_group: None,+ has_group: false,+ }+ }++ #[test]+ fn dividers_become_groups() {+ let e = |n: &str| MaskEffect { name: n.into(), ..Default::default() };+ assert_eq!(divider_title(&e("10 ----- DETAIL ENHANCERS ----- 10")).as_deref(), Some("Detail Enhancers"));+ assert_eq!(divider_title(&e("50--------MISC-----50")).as_deref(), Some("Misc"));+ assert_eq!(divider_title(&e("=== Portraits ===")).as_deref(), Some("Portraits"));+ assert_eq!(divider_title(&e("11_General_-_All_Purpose")), None, "no run of marks");+ assert_eq!(divider_title(&e("-----")), None, "no title");+ let busy = MaskEffect { adjust: LocalAdjustments { exposure: 1.0, ..Default::default() }, ..e("20 --- X --- 20") };+ assert_eq!(divider_title(&busy), None, "a divider sets nothing");++ let list = vec![+ found("01 Burn", -1.0, "a"),+ found("10 ----- DETAIL ENHANCERS ----- 10", 0.0, "a"),+ found("12 Sky", 0.5, "a"),+ found("20 ----- RETOUCHING ----- 20", 0.0, "a"),+ found("24a-Eye-Cleaner", 0.1, "a"),+ found("99 Late", 0.1, "a"),+ found("Burn (Darken)", -0.5, "a"),+ Found { dir_group: Some("Other".into()), ..found("15 Elsewhere", 0.2, "b") },+ ];+ let (effects, dividers) = assign_groups(list.clone(), None);+ let groups: Vec<(&str, &str)> = effects.iter().map(|f| (f.effect.name.as_str(), f.effect.group.as_str())).collect();+ assert_eq!(+ groups,+ vec![+ ("01 Burn", ""),+ ("12 Sky", "Detail Enhancers"),+ ("24a-Eye-Cleaner", "Retouching"),+ ("99 Late", "Retouching"),+ ("Burn (Darken)", ""),+ ("15 Elsewhere", "Other"),+ ]+ );+ assert_eq!(dividers.len(), 2);+ let (effects, _) = assign_groups(list, Some("Mine"));+ assert!(effects.iter().all(|f| f.effect.group == "Mine"));+ }++ #[test]+ fn folder_names_that_only_say_local_presets_give_no_group() {+ assert_eq!(effect_group_from_dir("Local Adjustment Presets"), None);+ assert_eq!(effect_group_from_dir("LocalCorrections"), None);+ assert_eq!(effect_group_from_dir("Local Adjustment Presets/Portrait Brushes"), Some("Portrait Brushes".into()));+ assert_eq!(effect_group_from_dir("Skin Kit"), Some("Skin Kit".into()));+ }+}diff --git a/crates/engine/src/cmd/mask_effects.rs b/crates/engine/src/cmd/mask_effects.rsindex 64b9fcac5..387909a6d 100644--- a/crates/engine/src/cmd/mask_effects.rs+++ b/crates/engine/src/cmd/mask_effects.rs@@ -1,75 +1,317 @@//! Mask effect presets: named sets of local adjustment sliders picked from the Masking panel's//! Effect menu (Lightroom's local adjustment / brush presets), saved with the library preferences.-//! Imported from Lightroom `.lrtemplate` local presets (`type = "LocalizedAdjustmentPreset"`)-//! and our own `.lceffect` JSON files.+//! Grouped (folders in the menu), favourites, partial presets (only some sliders, with or without+//! Amount) and optional brush settings. Files: [`super::mask_effect_files`].-use lightcraft_develop::LocalAdjustments;+use std::cmp::Ordering;++use lightcraft_catalog::PhotoId;+use lightcraft_develop::{DevelopSettings, LocalAdjustments, Mask};use serde::{Deserialize, Serialize};-use serde_json::{Value, json};+use serde_json::{Map, Value, json};+use super::mask_effect_files as files;use super::{CommandSpec, always, bad, cmd, has_active, str_param};-use crate::preset_import::{Lua, parse_lua};use crate::{Result, Session};-/// File extension of exported effect presets (JSON).-pub const EFFECT_EXT: &str = "lceffect";-/// `format` tag of an exported effect-preset file.-const FILE_FORMAT: &str = "lightcraft.maskEffects";-/// The Lua `type` of a Lightroom local adjustment preset.-const LR_LOCAL_TYPE: &str = "LocalizedAdjustmentPreset";+/// The local sliders an effect can set (`LocalAdjustments` field names; Amount aside).+pub const FIELDS: &[&str] = &[+ "temp",+ "tint",+ "exposure",+ "contrast",+ "highlights",+ "shadows",+ "whites",+ "blacks",+ "texture",+ "clarity",+ "dehaze",+ "hue",+ "saturation",+ "sharpness",+ "noise",+ "moire",+ "defringe",+ "color_hue",+ "color_sat",+];++/// Brush settings an effect can carry (Lightroom keeps these per brush, not in presets).+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default)]+pub struct BrushSettings {+ /// Radius as a fraction of the image's long edge.+ pub size: f64,+ /// 0..100.+ pub feather: f64,+ pub flow: f64,+ pub density: f64,+ pub auto_mask: bool,+}++impl Default for BrushSettings {+ fn default() -> Self {+ Self { size: 0.04, feather: 50.0, flow: 100.0, density: 100.0, auto_mask: false }+ }+}++impl BrushSettings {+ fn clamped(self) -> Self {+ let c = |v: f64, lo: f64, hi: f64, d: f64| if v.is_finite() { v.clamp(lo, hi) } else { d };+ let d = Self::default();+ Self {+ size: c(self.size, 0.002, 0.5, d.size),+ feather: c(self.feather, 0.0, 100.0, d.feather),+ flow: c(self.flow, 1.0, 100.0, d.flow),+ density: c(self.density, 1.0, 100.0, d.density),+ auto_mask: self.auto_mask,+ }+ }+}-/// A named set of local adjustment sliders. Applying one sets every slider of the mask (those the-/// preset doesn't name go to 0); the mask's Amount stays.-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+/// A named set of local adjustment sliders. Applying one sets the sliders it names (all of them+/// when `fields` is empty, as Lightroom's presets do: those it doesn't change go to 0); the mask's+/// Amount stays unless `with_amount`.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]#[serde(default)]pub struct MaskEffect {pub name: String,pub adjust: LocalAdjustments,+ /// The Effect menu folder ("" = none).+ #[serde(skip_serializing_if = "String::is_empty")]+ pub group: String,+ #[serde(skip_serializing_if = "std::ops::Not::not")]+ pub favorite: bool,+ /// The sliders this effect sets ([`FIELDS`] names); empty = all of them.+ #[serde(skip_serializing_if = "Vec::is_empty")]+ pub fields: Vec<String>,+ /// Applying sets the mask's Amount to `adjust.amount` too.+ #[serde(skip_serializing_if = "std::ops::Not::not")]+ pub with_amount: bool,+ /// Brush settings the brush takes when the effect is applied.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub brush: Option<BrushSettings>,+ /// Settings of an imported preset that we have no slider for (Lightroom key → value), kept so+ /// an export carries them.+ #[serde(skip_serializing_if = "Map::is_empty")]+ pub extra: Map<String, Value>,+}++impl Default for MaskEffect {+ fn default() -> Self {+ Self {+ name: String::new(),+ adjust: LocalAdjustments::default(),+ group: String::new(),+ favorite: false,+ fields: Vec::new(),+ with_amount: false,+ brush: None,+ extra: Map::new(),+ }+ }+}++/// Field `k` of `a` (0 for an unknown name).+pub fn get(a: &LocalAdjustments, k: &str) -> f64 {+ serde_json::to_value(a).ok().and_then(|v| v.get(k).and_then(Value::as_f64)).unwrap_or(0.0)+}++/// `a` with field `k` set to `v` (unchanged for an unknown name).+pub fn set(a: &LocalAdjustments, k: &str, v: f64) -> LocalAdjustments {+ let Ok(Value::Object(mut o)) = serde_json::to_value(a) else { return *a };+ if !o.contains_key(k) || !v.is_finite() {+ return *a;+ }+ o.insert(k.into(), json!(v));+ serde_json::from_value(Value::Object(o)).unwrap_or(*a)+}++/// The sliders of `a` away from 0 (the colour's hue only with its saturation).+pub fn changed_fields(a: &LocalAdjustments) -> Vec<String> {+ let mut out: Vec<String> = FIELDS.iter().filter(|k| get(a, k).abs() > 1e-9 && **k != "color_hue").map(|k| k.to_string()).collect();+ if a.color_sat.abs() > 1e-9 {+ out.push("color_hue".into());+ }+ out}impl MaskEffect {- /// `a` with this preset's sliders and `a`'s Amount.+ /// The sliders this effect sets.+ pub fn field_list(&self) -> Vec<&str> {+ if self.fields.is_empty() { FIELDS.to_vec() } else { FIELDS.iter().copied().filter(|k| self.fields.iter().any(|f| f == k)).collect() }+ }+ /// `a` with this preset's sliders (and Amount, if it carries it).pub fn apply(&self, a: &LocalAdjustments) -> LocalAdjustments {- LocalAdjustments { amount: a.amount, ..self.adjust }+ let mut out = if self.fields.is_empty() {+ LocalAdjustments { amount: a.amount, ..self.adjust }+ } else {+ self.field_list().iter().fold(*a, |acc, k| set(&acc, k, get(&self.adjust, k)))+ };+ if self.with_amount {+ out.amount = self.adjust.amount;+ }+ out}- /// Does `a` carry exactly this preset's sliders (Amount aside)?+ /// Does `a` carry exactly this preset's sliders? A tint's hue doesn't count without its+ /// saturation (it does nothing then).pub fn matches(&self, a: &LocalAdjustments) -> bool {- let strip = |a: &LocalAdjustments| LocalAdjustments { amount: 100.0, ..*a };- let (x, y) = (serde_json::to_value(strip(&self.adjust)).unwrap_or_default(), serde_json::to_value(strip(a)).unwrap_or_default());- match (x.as_object(), y.as_object()) {- (Some(x), Some(y)) => x.iter().all(|(k, v)| {- let (p, q) = (v.as_f64().unwrap_or(0.0), y.get(k).and_then(Value::as_f64).unwrap_or(0.0));- (p - q).abs() < 1e-6- }),- _ => false,+ let fields = self.field_list();+ let colorless = |x: &LocalAdjustments| x.color_sat.abs() < 1e-9;+ let same = |k: &str| (get(&self.adjust, k) - get(a, k)).abs() < 1e-6;+ fields.iter().all(|k| *k == "color_hue" && colorless(&self.adjust) && colorless(a) || same(k))+ && (!self.with_amount || (self.adjust.amount - a.amount).abs() < 1e-6)+ }+ /// Does the effect set nothing (all its sliders at 0, nothing kept from an import)?+ pub fn is_empty(&self) -> bool {+ self.extra.is_empty() && changed_fields(&self.adjust).iter().all(|k| !self.field_list().contains(&k.as_str()))+ }+ /// The same effect with its values in range and its field list normalised.+ pub fn normalized(mut self) -> Self {+ self.name = self.name.trim().to_string();+ self.group = self.group.trim().to_string();+ let amount = if self.with_amount { self.adjust.amount } else { 100.0 };+ self.adjust = super::masks::clamp_local(LocalAdjustments { amount, ..self.adjust });+ self.fields.retain(|f| FIELDS.contains(&f.as_str()));+ if self.fields.iter().any(|f| f == "color_sat") && !self.fields.iter().any(|f| f == "color_hue") {+ self.fields.push("color_hue".into());+ }+ self.fields.sort_by_key(|f| FIELDS.iter().position(|k| k == f));+ self.fields.dedup();+ if self.fields.len() == FIELDS.len() {+ self.fields.clear();}+ self.brush = self.brush.map(BrushSettings::clamped);+ self}}-/// Name of the effect the mask adjustments `a` match, if any.+/// Compare names the way people number their presets: digit runs as numbers ("2 …" before+/// "10 …"), letters ignoring case.+pub fn natural_cmp(a: &str, b: &str) -> Ordering {+ fn chunks(s: &str) -> Vec<(bool, String)> {+ let mut out: Vec<(bool, String)> = Vec::new();+ for c in s.chars() {+ let d = c.is_ascii_digit();+ match out.last_mut() {+ Some((kind, text)) if *kind == d => text.push(c),+ _ => out.push((d, c.to_string())),+ }+ }+ out+ }+ let (x, y) = (chunks(a), chunks(b));+ for (p, q) in x.iter().zip(y.iter()) {+ let o = match (p, q) {+ ((true, m), (true, n)) => {+ let (m, n) = (m.trim_start_matches('0'), n.trim_start_matches('0'));+ m.len().cmp(&n.len()).then_with(|| m.cmp(n))+ }+ ((_, m), (_, n)) => m.to_lowercase().cmp(&n.to_lowercase()),+ };+ if o != Ordering::Equal {+ return o;+ }+ }+ x.len().cmp(&y.len()).then_with(|| a.cmp(b))+}++/// The Effect menu's order: groups in the order they first appear (ungrouped first), each with+/// its effects (indices into `effects`) sorted by name.+pub fn menu_order(effects: &[MaskEffect]) -> Vec<(String, Vec<usize>)> {+ let mut groups: Vec<(String, Vec<usize>)> = Vec::new();+ if effects.iter().any(|e| e.group.is_empty()) {+ groups.push((String::new(), Vec::new()));+ }+ for (i, e) in effects.iter().enumerate() {+ match groups.iter_mut().find(|(g, _)| g.eq_ignore_ascii_case(&e.group)) {+ Some((_, v)) => v.push(i),+ None => groups.push((e.group.clone(), vec![i])),+ }+ }+ for (_, v) in &mut groups {+ v.sort_by(|a, b| match (effects.get(*a), effects.get(*b)) {+ (Some(x), Some(y)) => natural_cmp(&x.name, &y.name),+ _ => Ordering::Equal,+ });+ }+ groups+}++/// Name of the effect the mask adjustments `a` match, if any (full presets before partial ones).pub fn matching_effect(s: &Session, a: &LocalAdjustments) -> Option<String> {- s.mask_effects.iter().find(|e| e.matches(a)).map(|e| e.name.clone())+ let full = s.mask_effects.iter().filter(|e| e.fields.is_empty()).find(|e| e.matches(a));+ full.or_else(|| s.mask_effects.iter().find(|e| e.matches(a))).map(|e| e.name.clone())+}++fn position(s: &Session, name: &str) -> Option<usize> {+ s.mask_effects.iter().position(|x| x.name.eq_ignore_ascii_case(name.trim()))}-/// Add or replace (same name, ignoring case) an effect.-fn upsert(s: &mut Session, e: MaskEffect) {- match s.mask_effects.iter_mut().find(|x| x.name.eq_ignore_ascii_case(&e.name)) {- Some(x) => *x = e,+/// Add or replace (same name, ignoring case) an effect; a replaced one keeps its star.+pub(crate) fn upsert(s: &mut Session, e: MaskEffect) {+ match position(s, &e.name).and_then(|i| s.mask_effects.get_mut(i)) {+ Some(x) => {+ let favorite = x.favorite || e.favorite;+ *x = MaskEffect { favorite, ..e };+ }None => s.mask_effects.push(e),}}fn name_param(p: &Value, c: &str) -> Result<String> {- str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).map(str::to_string).ok_or_else(|| bad(c, "missing `name`"))+ name_of(p, "name", c)+}++fn name_of(p: &Value, key: &str, c: &str) -> Result<String> {+ str_param(p, key).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string).ok_or_else(|| bad(c, format!("missing `{key}`")))+}++fn strings(p: &Value, key: &str) -> Option<Vec<String>> {+ p.get(key).and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect())+}++/// The names a command acts on: `names: [...]` or `name`.+fn names_param(p: &Value, c: &str) -> Result<Vec<String>> {+ match strings(p, "names").filter(|v| !v.is_empty()) {+ Some(v) => Ok(v),+ None => name_param(p, c).map(|n| vec![n]),+ }+}++fn effect_index(s: &Session, name: &str, c: &str) -> Result<usize> {+ position(s, name).ok_or_else(|| bad(c, format!("no effect `{name}`")))}/// The selected mask's adjustments on the active photo.-fn selected_adjust(s: &Session, p: &Value, c: &str) -> Result<(u32, LocalAdjustments)> {+fn selected_mask(s: &Session, p: &Value, c: &str) -> Result<Mask> {let id = s.active().ok_or_else(|| bad(c, "no active photo"))?;- let mid = p.get("id").and_then(Value::as_u64).map(|v| v as u32).or(s.active_mask).ok_or_else(|| bad(c, "no mask selected (give `id`)"))?;+ let mid = p+ .get("id")+ .and_then(Value::as_u64)+ .and_then(|v| u32::try_from(v).ok())+ .or(s.active_mask)+ .ok_or_else(|| bad(c, "no mask selected (give `id`)"))?;let d = s.develop_of(id).unwrap_or_default();- let m = d.masks.iter().find(|m| m.id == mid).ok_or_else(|| bad(c, format!("no mask {mid}")))?;- Ok((mid, m.adjust))+ d.masks.iter().find(|m| m.id == mid).cloned().ok_or_else(|| bad(c, format!("no mask {mid}")))+}++/// The kind of a mask's first component (`brush`, `linear`, `radial`, `subject`…): the tool the+/// effect is remembered for.+pub fn mask_tool(m: &Mask) -> Option<String> {+ m.components.first().and_then(|c| serde_json::to_value(&c.shape).ok()).and_then(|v| v.get("kind").and_then(Value::as_str).map(str::to_string))+}++/// The adjustments a new mask made with `tool` starts with: the effect last applied to a mask of+/// that kind (Lightroom carries the chosen effect over to the next mask), else all at 0.+pub fn new_mask_adjust(s: &Session, tool: &str) -> LocalAdjustments {+ s.mask_tool_effects+ .get(tool)+ .and_then(|name| position(s, name))+ .and_then(|i| s.mask_effects.get(i))+ .map(|e| super::masks::clamp_local(e.apply(&LocalAdjustments::default())))+ .unwrap_or_default()}fn list(s: &Session) -> Value {@@ -78,194 +320,274 @@ fn list(s: &Session) -> Value {.and_then(|id| s.develop_of(id)).and_then(|d| s.active_mask.and_then(|mid| d.masks.iter().find(|m| m.id == mid).map(|m| m.adjust))).and_then(|a| matching_effect(s, &a));- json!({"effects": s.mask_effects, "current": current})+ let groups: Vec<Value> = menu_order(&s.mask_effects)+ .into_iter()+ .map(|(g, ix)| json!({"name": g, "effects": ix.iter().filter_map(|i| s.mask_effects.get(*i)).map(|e| e.name.clone()).collect::<Vec<_>>()}))+ .collect();+ json!({"effects": s.mask_effects, "groups": groups, "current": current, "toolEffects": s.mask_tool_effects})+}++/// Masks on `d` named like one of `names` (ignoring case).+fn masks_named(d: &DevelopSettings, names: &[String]) -> Vec<u32> {+ d.masks.iter().filter(|m| names.iter().any(|n| n.eq_ignore_ascii_case(&m.name))).map(|m| m.id).collect()}fn apply_effect(s: &mut Session, p: &Value) -> Result<Value> {const C: &str = "mask.applyEffect";let name = name_param(p, C)?;- let effect = s.mask_effects.iter().find(|x| x.name.eq_ignore_ascii_case(&name)).cloned().ok_or_else(|| bad(C, format!("no effect `{name}`")))?;- let (mid, _) = selected_adjust(s, p, C)?;+ let effect = s.mask_effects.get(effect_index(s, &name, C)?).cloned().ok_or_else(|| bad(C, format!("no effect `{name}`")))?;let id = s.active().ok_or_else(|| bad(C, "no active photo"))?;- let mut d = (*s.develop_of(id).unwrap_or_default()).clone();- let m = d.masks.iter_mut().find(|m| m.id == mid).ok_or_else(|| bad(C, format!("no mask {mid}")))?;- m.adjust = super::masks::clamp_local(effect.apply(&m.adjust));- s.set_develop(id, d, &format!("Mask Effect: {}", effect.name))?;- Ok(json!({"name": effect.name, "mask": mid}))+ let d = s.develop_of(id).unwrap_or_default();+ // the masks: `ids`, `all`, else `id` or the selected one+ let ids: Vec<u32> = if p.get("all").and_then(Value::as_bool).unwrap_or(false) {+ d.masks.iter().map(|m| m.id).collect()+ } else if let Some(a) = p.get("ids").and_then(Value::as_array) {+ a.iter().filter_map(Value::as_u64).filter_map(|v| u32::try_from(v).ok()).collect()+ } else {+ vec![selected_mask(s, p, C)?.id]+ };+ if ids.is_empty() {+ return Err(bad(C, "no masks to apply the effect to"));+ }+ if let Some(missing) = ids.iter().find(|m| !d.masks.iter().any(|x| x.id == **m)) {+ return Err(bad(C, format!("no mask {missing}")));+ }+ let set_masks = |d: &DevelopSettings, ids: &[u32]| {+ let mut d = d.clone();+ for m in d.masks.iter_mut().filter(|m| ids.contains(&m.id)) {+ m.adjust = super::masks::clamp_local(effect.apply(&m.adjust));+ }+ d+ };+ let label = format!("Mask Effect: {}", effect.name);+ // with `photos: "selected"`, the other selected photos' masks of the same names too+ let others: Vec<(PhotoId, DevelopSettings)> = if str_param(p, "photos") == Some("selected") {+ let names: Vec<String> = d.masks.iter().filter(|m| ids.contains(&m.id)).map(|m| m.name.clone()).collect();+ s.selection+ .ids+ .iter()+ .filter(|x| **x != id)+ .filter_map(|x| s.develop_of(*x).map(|o| (*x, o)))+ .filter_map(|(x, o)| {+ let found = masks_named(&o, &names);+ (!found.is_empty()).then(|| (x, set_masks(&o, &found)))+ })+ .collect()+ } else {+ Vec::new()+ };+ let mine = set_masks(&d, &ids);+ let photos = 1 + others.len();+ if others.is_empty() {+ s.set_develop(id, mine, &label)?;+ } else {+ // one undo step for every photo+ let mut ops: Vec<_> = s.develop_op(id, mine, &label).into_iter().collect();+ ops.extend(others.into_iter().filter_map(|(x, o)| s.develop_op(x, o, &label)));+ s.commit(&label, lightcraft_catalog::Op::Batch { ops })?;+ }+ // the next mask made with this tool starts with the effect+ if p.get("remember").and_then(Value::as_bool).unwrap_or(true) {+ for m in d.masks.iter().filter(|m| ids.contains(&m.id)) {+ if let Some(tool) = mask_tool(m) {+ s.mask_tool_effects.insert(tool, effect.name.clone());+ }+ }+ s.save_prefs()?;+ }+ Ok(json!({"name": effect.name, "masks": ids, "photos": photos, "brush": effect.brush}))+}++/// The fields a save keeps: `fields: [..]` | `"changed"` | `"all"` (default).+fn fields_param(p: &Value, a: &LocalAdjustments, c: &str) -> Result<Vec<String>> {+ match p.get("fields") {+ None | Some(Value::Null) => Ok(Vec::new()),+ Some(Value::String(x)) if x == "all" => Ok(Vec::new()),+ Some(Value::String(x)) if x == "changed" => {+ let f = changed_fields(a);+ if f.is_empty() { Err(bad(c, "the mask changes no slider; nothing to save")) } else { Ok(f) }+ }+ Some(Value::Array(v)) => {+ let f: Vec<String> = v.iter().filter_map(Value::as_str).filter(|k| FIELDS.contains(k)).map(str::to_string).collect();+ if f.is_empty() { Err(bad(c, format!("`fields` names no slider (one of {})", FIELDS.join(", ")))) } else { Ok(f) }+ }+ Some(_) => Err(bad(c, "`fields` is \"all\", \"changed\" or a list of slider names")),+ }+}++fn brush_param(p: &Value, c: &str) -> Result<Option<BrushSettings>> {+ match p.get("brush") {+ None | Some(Value::Null) | Some(Value::Bool(false)) => Ok(None),+ Some(v) => serde_json::from_value::<BrushSettings>(v.clone()).map(|b| Some(b.clamped())).map_err(|e| bad(c, format!("`brush`: {e}"))),+ }}fn save_effect(s: &mut Session, p: &Value) -> Result<Value> {const C: &str = "mask.saveEffect";let name = name_param(p, C)?;- let (_, adjust) = selected_adjust(s, p, C)?;- upsert(s, MaskEffect { name, adjust: LocalAdjustments { amount: 100.0, ..adjust } });+ let adjust = selected_mask(s, p, C)?.adjust;+ let group = str_param(p, "group").map(|g| g.trim().to_string()).unwrap_or_default();+ let e = MaskEffect {+ name,+ adjust,+ group,+ fields: fields_param(p, &adjust, C)?,+ with_amount: p.get("amount").and_then(Value::as_bool).unwrap_or(false),+ brush: brush_param(p, C)?,+ ..Default::default()+ };+ upsert(s, e.normalized());s.save_prefs()?;Ok(list(s))}-fn delete_effect(s: &mut Session, p: &Value) -> Result<Value> {- const C: &str = "mask.deleteEffect";+/// Overwrite an effect's sliders with the selected mask's (keeping which sliders and whether+/// Amount it carries, its group and star).+fn update_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.updateEffect";let name = name_param(p, C)?;- let n = s.mask_effects.len();- s.mask_effects.retain(|x| !x.name.eq_ignore_ascii_case(&name));- if n == s.mask_effects.len() {- return Err(bad(C, format!("no effect `{name}`")));+ let i = effect_index(s, &name, C)?;+ let adjust = selected_mask(s, p, C)?.adjust;+ let brush = brush_param(p, C)?;+ let e = s.mask_effects.get_mut(i).ok_or_else(|| bad(C, format!("no effect `{name}`")))?;+ let mut next = MaskEffect { adjust, extra: Map::new(), ..e.clone() };+ if let Some(f) = p.get("fields").filter(|v| !v.is_null()) {+ next.fields = fields_param(&json!({"fields": f}), &adjust, C)?;+ }+ if let Some(a) = p.get("amount").and_then(Value::as_bool) {+ next.with_amount = a;}+ if brush.is_some() {+ next.brush = brush;+ }+ *e = next.normalized();s.save_prefs()?;Ok(list(s))}-/// Is `text` a Lightroom local adjustment preset (`.lrtemplate`)?-pub fn is_lr_local_template(text: &str) -> bool {- parse_lua(text.trim_start_matches('\u{feff}'))- .ok()- .and_then(|root| root.get("type").and_then(Lua::str).map(|t| t == LR_LOCAL_TYPE))- .unwrap_or(false)+fn rename_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.renameEffect";+ let name = name_param(p, C)?;+ let to = name_of(p, "to", C)?;+ let i = effect_index(s, &name, C)?;+ if position(s, &to).is_some_and(|j| j != i) {+ return Err(bad(C, format!("an effect named `{to}` exists already")));+ }+ if let Some(e) = s.mask_effects.get_mut(i) {+ e.name = to.clone();+ }+ for v in s.mask_tool_effects.values_mut() {+ if v.eq_ignore_ascii_case(&name) {+ *v = to.clone();+ }+ }+ s.save_prefs()?;+ Ok(list(s))}-/// A Lightroom local adjustment preset → an effect named after its title (else `stem`), and the-/// non-zero sliders we have no equivalent for (e.g. `toningLuminance`, `grain`).-pub fn parse_lr_local_template(text: &str, stem: &str) -> std::result::Result<(MaskEffect, Vec<String>), String> {- let root = parse_lua(text.trim_start_matches('\u{feff}'))?;- if root.get("type").and_then(Lua::str) != Some(LR_LOCAL_TYPE) {- return Err("not a local adjustment preset".into());- }- let Some(Lua::Table(_, fields)) = root.get("value") else { return Err("no adjustments in this local preset".into()) };- // `exposure2012` → `LocalExposure2012`: the template's keys are the XMP `Local*` names, lower camel case- let crs = |k: &str| {- let mut c = k.chars();- c.next().map(|f| format!("Local{}{}", f.to_ascii_uppercase(), c.as_str())).unwrap_or_default()- };- let num = |k: &str| fields.iter().find(|(f, _)| crs(f) == k).and_then(|(_, v)| if let Lua::Num(n) = v { Some(*n) } else { None });- let values = crate::crs_masks::local_values(num);- let unmapped: Vec<String> = fields- .iter()- .filter(|(k, v)| matches!(v, Lua::Num(n) if n.abs() > 1e-9) && !crate::crs_masks::is_local_field(&crs(k)))- // a colour tint's hue without saturation does nothing- .filter(|(k, _)| k != "toningHue")- .map(|(k, _)| k.clone())- .collect();- let adjust: LocalAdjustments = serde_json::from_value(Value::Object(values)).map_err(|e| format!("unreadable local preset: {e}"))?;- let title = root.get("title").or_else(|| root.get("internalName")).and_then(Lua::str).map(str::trim).filter(|t| !t.is_empty());- let name =- title.map(|t| t.strip_prefix("$$$/").and_then(|r| r.split_once('=')).map_or(t, |(_, d)| d).to_string()).unwrap_or_else(|| stem.to_string());- Ok((MaskEffect { name, adjust: super::masks::clamp_local(LocalAdjustments { amount: 100.0, ..adjust }) }, unmapped))-}--/// Effects in an `.lceffect` file: `{format, version, effects: [...]}`, a bare array, or one effect.-pub fn parse_file(bytes: &[u8]) -> std::result::Result<Vec<MaskEffect>, String> {- let v: Value = serde_json::from_slice(bytes).map_err(|e| format!("not an effect preset file: {e}"))?;- let items = match &v {- Value::Object(o) if o.contains_key("effects") => o["effects"].clone(),- Value::Array(_) => v.clone(),- Value::Object(_) => Value::Array(vec![v.clone()]),- _ => return Err("not an effect preset file".into()),+/// A name like `base` that no effect has: `base`, `base 2`, `base 3`…+fn free_name(s: &Session, base: &str) -> String {+ (1..10_000)+ .map(|n| if n == 1 { base.to_string() } else { format!("{base} {n}") })+ .find(|n| position(s, n).is_none())+ .unwrap_or_else(|| base.into())+}++fn duplicate_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.duplicateEffect";+ let name = name_param(p, C)?;+ let e = s.mask_effects.get(effect_index(s, &name, C)?).cloned().ok_or_else(|| bad(C, format!("no effect `{name}`")))?;+ let to = match str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()) {+ Some(t) if position(s, t).is_some() => return Err(bad(C, format!("an effect named `{t}` exists already"))),+ Some(t) => t.to_string(),+ None => free_name(s, &format!("{} copy", e.name)),};- let list: Vec<MaskEffect> = serde_json::from_value(items).map_err(|e| format!("not an effect preset file: {e}"))?;- let list: Vec<MaskEffect> = list- .into_iter()- .filter(|e| !e.name.trim().is_empty())- .map(|e| MaskEffect { name: e.name.trim().to_string(), adjust: super::masks::clamp_local(LocalAdjustments { amount: 100.0, ..e.adjust }) })- .collect();- if list.is_empty() {- return Err("no effect presets in the file".into());- }- Ok(list)+ s.mask_effects.push(MaskEffect { name: to.clone(), favorite: false, ..e });+ s.save_prefs()?;+ let mut out = list(s);+ out["name"] = json!(to);+ Ok(out)}-/// Effects in file `path` (`.lrtemplate` or `.lceffect`) with the sliders each one couldn't keep.-pub fn read_file(path: &str) -> std::result::Result<Vec<(MaskEffect, Vec<String>)>, String> {- let bytes = std::fs::read(path).map_err(|e| e.to_string())?;- let p = std::path::Path::new(path);- let stem = p.file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_else(|| "Effect".into());- match p.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).as_deref() {- Some("lrtemplate") => parse_lr_local_template(&String::from_utf8_lossy(&bytes), &stem).map(|e| vec![e]),- _ => parse_file(&bytes).map(|v| v.into_iter().map(|e| (e, Vec::new())).collect()),+fn delete_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.deleteEffect";+ let names = names_param(p, C)?;+ if let Some(missing) = names.iter().find(|n| position(s, n).is_none()) {+ return Err(bad(C, format!("no effect `{missing}`")));}+ s.mask_effects.retain(|x| !names.iter().any(|n| n.eq_ignore_ascii_case(&x.name)));+ s.mask_tool_effects.retain(|_, v| !names.iter().any(|n| n.eq_ignore_ascii_case(v)));+ s.save_prefs()?;+ Ok(list(s))}-/// Add `effects` (same-named ones replaced) and save → the import report rows.-pub fn add_effects(s: &mut Session, effects: Vec<(MaskEffect, Vec<String>, String)>) -> Result<Vec<Value>> {- let rows: Vec<Value> = effects.iter().map(|(e, unmapped, file)| json!({"name": e.name, "file": file, "unmapped": unmapped})).collect();- let any = !effects.is_empty();- for (e, _, _) in effects {- upsert(s, e);- }- if any {- s.save_prefs()?;+fn favorite_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.favoriteEffect";+ let names = names_param(p, C)?;+ let mut idx = Vec::new();+ for n in &names {+ idx.push(effect_index(s, n, C)?);}- Ok(rows)-}--/// The files under `paths` (folders walked, at most 8 levels) an effect import reads.-fn effect_files(paths: &[String]) -> Vec<String> {- fn walk(dir: &std::path::Path, depth: usize, out: &mut Vec<String>) {- let Ok(rd) = std::fs::read_dir(dir) else { return };- let mut entries: Vec<_> = rd.flatten().map(|e| e.path()).collect();- entries.sort();- for p in entries {- if p.is_dir() {- if depth < 8 {- walk(&p, depth + 1, out);- }- } else if p.extension().is_some_and(|e| e.eq_ignore_ascii_case("lrtemplate") || e.eq_ignore_ascii_case(EFFECT_EXT)) {- out.push(p.to_string_lossy().to_string());- }+ let want = p.get("favorite").and_then(Value::as_bool);+ for i in idx {+ if let Some(e) = s.mask_effects.get_mut(i) {+ e.favorite = want.unwrap_or(!e.favorite);}}- let mut out = Vec::new();- for x in paths {- let p = std::path::Path::new(x);- if p.is_dir() {- walk(p, 0, &mut out);- } else {- out.push(x.clone());- }- }- out+ s.save_prefs()?;+ Ok(list(s))}-fn import_effects(s: &mut Session, p: &Value) -> Result<Value> {- const C: &str = "mask.importEffects";- let mut paths: Vec<String> =- p.get("paths").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect()).unwrap_or_default();- if let Some(x) = str_param(p, "path") {- paths.push(x.to_string());- }- if paths.is_empty() {- return Err(bad(C, "missing `path` / `paths`"));+fn set_group(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.setEffectGroup";+ let names = names_param(p, C)?;+ let group = str_param(p, "group").map(|g| g.trim().to_string()).ok_or_else(|| bad(C, "missing `group` (\"\" = none)"))?;+ let mut idx = Vec::new();+ for n in &names {+ idx.push(effect_index(s, n, C)?);}- let (mut ok, mut failed) = (Vec::new(), Vec::new());- for f in effect_files(&paths) {- match read_file(&f) {- Ok(list) => ok.extend(list.into_iter().map(|(e, u)| (e, u, f.clone()))),- Err(e) => failed.push(json!([f, e])),+ // an existing group's spelling wins+ let group = s.mask_effects.iter().map(|e| &e.group).find(|g| g.eq_ignore_ascii_case(&group)).cloned().unwrap_or(group);+ for i in idx {+ if let Some(e) = s.mask_effects.get_mut(i) {+ e.group = group.clone();}}- let imported = add_effects(s, ok)?;- Ok(json!({"imported": imported, "failed": failed}))+ s.save_prefs()?;+ Ok(list(s))}-fn export_effects(s: &mut Session, p: &Value) -> Result<Value> {- const C: &str = "mask.exportEffects";- let path = str_param(p, "path").filter(|x| !x.trim().is_empty()).ok_or_else(|| bad(C, "missing `path`"))?;- let mut path = std::path::PathBuf::from(path);- if path.extension().is_none() {- path.set_extension(EFFECT_EXT);+fn rename_group(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.renameEffectGroup";+ let group = name_of(p, "group", C)?;+ let to = str_param(p, "to").map(|g| g.trim().to_string()).ok_or_else(|| bad(C, "missing `to` (\"\" = ungroup)"))?;+ let mut n = 0;+ for e in s.mask_effects.iter_mut().filter(|e| e.group.eq_ignore_ascii_case(&group)) {+ e.group = to.clone();+ n += 1;}- let names: Option<Vec<String>> =- p.get("names").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());- let chosen: Vec<&MaskEffect> =- s.mask_effects.iter().filter(|e| names.as_ref().is_none_or(|n| n.iter().any(|x| x.eq_ignore_ascii_case(&e.name)))).collect();- if chosen.is_empty() {- return Err(bad(C, "no effect presets to export"));+ if n == 0 {+ return Err(bad(C, format!("no group `{group}`")));}- if let Some(dir) = path.parent().filter(|d| !d.as_os_str().is_empty()) {- std::fs::create_dir_all(dir).map_err(|e| crate::EngineError::Other(format!("{}: {e}", dir.display())))?;+ s.save_prefs()?;+ Ok(list(s))+}++fn tool_effect(s: &mut Session, p: &Value) -> Result<Value> {+ const C: &str = "mask.toolEffect";+ let tool = name_of(p, "tool", C)?;+ match str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()) {+ Some(n) => {+ let i = effect_index(s, n, C)?;+ let name = s.mask_effects.get(i).map(|e| e.name.clone()).unwrap_or_default();+ s.mask_tool_effects.insert(tool, name);+ }+ None => {+ s.mask_tool_effects.remove(&tool);+ }}- let text = serde_json::to_string_pretty(&json!({"format": FILE_FORMAT, "version": 1, "effects": chosen})).unwrap_or_default();- std::fs::write(&path, text).map_err(|e| crate::EngineError::Other(format!("{}: {e}", path.display())))?;- Ok(json!({"path": path.display().to_string(), "count": chosen.len()}))+ s.save_prefs()?;+ Ok(json!({"toolEffects": s.mask_tool_effects}))}pub fn specs() -> Vec<CommandSpec> {@@ -275,7 +597,7 @@ pub fn specs() -> Vec<CommandSpec> {"Mask Effect Presets",[],None,- "{} → {effects: [{name, adjust: {exposure, contrast, …}}], current: name of the effect the selected mask's sliders match, or null}",+ "{} → {effects: [{name, adjust, group?, favorite?, fields?, with_amount?, brush?, extra?}], groups: [{name, effects: [name]}] (menu order), current: the effect the selected mask matches or null, toolEffects: {tool: effect a new mask of that kind starts with}}",always,|s, _| Ok(list(s))),@@ -284,7 +606,7 @@ pub fn specs() -> Vec<CommandSpec> {"Apply Mask Effect",[],None,- "{name, id?} — sets every slider of the selected mask (or mask `id`) from the effect preset; Amount stays",+ "{name, id? | ids?: [maskId] | all?: bool, photos?: \"selected\" (also the masks of the same names on the other selected photos, one undo step), remember?: bool (true: new masks of this kind start with it)} — sets the effect's sliders (all, or the ones it keeps; Amount only if it carries it) → {name, masks, photos, brush}",has_active,apply_effect),@@ -293,28 +615,67 @@ pub fn specs() -> Vec<CommandSpec> {"Save Mask Effect",[],None,- "{name, id?} — the selected mask's sliders as an effect preset (replaces one of that name), saved with the library",+ "{name, id?, group?, fields?: \"all\" (default) | \"changed\" | [slider], amount?: bool (carry Amount), brush?: {size, feather, flow, density, auto_mask}} — the selected mask's sliders as an effect preset (replaces one of that name), saved with the library",has_active,save_effect),- cmd!("mask.deleteEffect", "Delete Mask Effect", [], None, "{name} — removes an effect preset", always, delete_effect),+ cmd!(+ "mask.updateEffect",+ "Update Mask Effect",+ [],+ None,+ "{name, id?, fields?, amount?, brush?} — overwrite the effect with the selected mask's sliders (keeps its group, star and which sliders it carries unless given)",+ has_active,+ update_effect+ ),+ cmd!("mask.renameEffect", "Rename Mask Effect", [], None, "{name, to}", always, rename_effect),+ cmd!(+ "mask.duplicateEffect",+ "Duplicate Mask Effect",+ [],+ None,+ "{name, to?} (default \"<name> copy\") → list + {name}",+ always,+ duplicate_effect+ ),+ cmd!("mask.deleteEffect", "Delete Mask Effect", [], None, "{name | names: [name]} — removes effect presets", always, delete_effect),+ cmd!("mask.favoriteEffect", "Favorite Mask Effect", [], None, "{name | names, favorite?: bool (default: toggle)}", always, favorite_effect),+ cmd!("mask.setEffectGroup", "Move Mask Effect to Group", [], None, "{name | names, group: name (\"\" = none)}", always, set_group),+ cmd!(+ "mask.renameEffectGroup",+ "Rename Mask Effect Group",+ [],+ None,+ "{group, to} (\"\" ungroups; an existing name merges)",+ always,+ rename_group+ ),+ cmd!(+ "mask.toolEffect",+ "Set Effect for New Masks",+ [],+ None,+ "{tool: brush|linear|radial|subject|…, name?} — the effect new masks of that kind start with (no name: none)",+ always,+ tool_effect+ ),cmd!("mask.importEffects","Import Mask Effects",[],None,- "{path | paths: [file or folder]} — Lightroom local adjustment presets (.lrtemplate) and .lceffect files; same-named effects are replaced → {imported: [{name, file, unmapped}], failed: [[file, error]]}",+ "{path | paths: [file or folder], group?, dryRun?} — Lightroom Classic local adjustment presets (.lrtemplate), Camera Raw local correction presets (.xmp), .lceffect files and .zip bundles of these; folders and Lightroom's divider presets (\"10 ----- DETAIL ----- 10\") become groups; same-named effects are replaced → {imported: [{name, group, file, unmapped}], dividers: [{name, group, file}], failed: [[file, error]]}",always,- import_effects+ files::import_effects),cmd!("mask.exportEffects","Export Mask Effects",[],None,- "{path, names?: [name] (default: all)} — writes an .lceffect JSON file → {path, count}",+ "{path, names?: [name], group?: name (default: all)} — writes an .lceffect JSON file (groups, stars and kept Lightroom settings included) → {path, count}",always,- export_effects+ files::export_effects),]}@@ -323,57 +684,73 @@ pub fn specs() -> Vec<CommandSpec> {mod tests {use super::*;- // A synthetic template in the shape Lightroom writes (our own values).- const TEMPLATE: &str = r#"s = {- id = "00000000-0000-0000-0000-000000000001",- internalName = "Soft Glow",- title = "Soft Glow",- type = "LocalizedAdjustmentPreset",- value = {- clarity = 0.5,- clarity2012 = -0.25,- exposure = 0,- exposure2012 = 0.125,- highlights2012 = -0.5,- temperature = 0.2,- texture = -0.3,- toningHue = 240,- toningLuminance = 0.1,- toningSaturation = 0,- },- version = 0,-}"#;+ #[test]+ fn apply_keeps_amount_and_matches_ignore_it() {+ let e = MaskEffect { name: "E".into(), adjust: LocalAdjustments { exposure: 1.0, ..Default::default() }, ..Default::default() };+ let current = LocalAdjustments { shadows: 40.0, amount: 60.0, ..Default::default() };+ let out = e.apply(¤t);+ assert_eq!((out.exposure, out.shadows, out.amount), (1.0, 0.0, 60.0));+ assert!(e.matches(&out));+ assert!(!e.matches(¤t));+ }#[test]- fn reads_a_lightroom_local_template() {- assert!(is_lr_local_template(TEMPLATE));- let (e, unmapped) = parse_lr_local_template(TEMPLATE, "file").unwrap();- assert_eq!(e.name, "Soft Glow");- assert!((e.adjust.exposure - 0.5).abs() < 1e-9, "exposure2012 is a quarter of the stops");- assert!((e.adjust.clarity + 25.0).abs() < 1e-9, "the 2012 field wins over the old one");- assert!((e.adjust.highlights + 50.0).abs() < 1e-9);- assert!((e.adjust.temp - 20.0).abs() < 1e-9);- assert!((e.adjust.texture + 30.0).abs() < 1e-9);- assert!((e.adjust.amount - 100.0).abs() < 1e-9);- assert_eq!(unmapped, vec!["toningLuminance".to_string()]);+ fn partial_effects_leave_other_sliders_and_can_carry_amount() {+ let e = MaskEffect {+ name: "Lift".into(),+ adjust: LocalAdjustments { shadows: 30.0, clarity: 99.0, amount: 70.0, ..Default::default() },+ fields: vec!["shadows".into()],+ with_amount: true,+ ..Default::default()+ };+ let current = LocalAdjustments { exposure: 0.5, clarity: 10.0, ..Default::default() };+ let out = e.apply(¤t);+ assert_eq!((out.exposure, out.shadows, out.clarity, out.amount), (0.5, 30.0, 10.0, 70.0));+ assert!(e.matches(&out));+ assert!(!e.matches(&LocalAdjustments { amount: 100.0, ..out }), "Amount counts when carried");}#[test]- fn develop_templates_are_not_local_ones() {- let develop = r#"s = { title = "X", type = "Develop", value = { settings = { Exposure2012 = 1 } } }"#;- assert!(!is_lr_local_template(develop));- assert!(parse_lr_local_template(develop, "x").is_err());- assert!(parse_lr_local_template("garbage {", "x").is_err());- assert!(parse_lr_local_template(r#"s = { type = "LocalizedAdjustmentPreset", value = 3 }"#, "x").is_err());+ fn hue_without_saturation_still_matches() {+ let e = MaskEffect {+ name: "E".into(),+ adjust: LocalAdjustments { color_hue: 240.0, exposure: 0.25, ..Default::default() },+ ..Default::default()+ };+ assert!(e.matches(&LocalAdjustments { exposure: 0.25, ..Default::default() }));+ assert!(!e.matches(&LocalAdjustments { exposure: 0.25, color_sat: 10.0, ..Default::default() }));}#[test]- fn apply_keeps_amount_and_matches_ignore_it() {- let e = MaskEffect { name: "E".into(), adjust: LocalAdjustments { exposure: 1.0, ..Default::default() } };- let current = LocalAdjustments { shadows: 40.0, amount: 60.0, ..Default::default() };- let out = e.apply(¤t);- assert_eq!((out.exposure, out.shadows, out.amount), (1.0, 0.0, 60.0));- assert!(e.matches(&out));- assert!(!e.matches(¤t));+ fn natural_order_and_groups() {+ let mut v = vec!["10 b", "2 a", "Burn", "01 x", "1 y"];+ v.sort_by(|a, b| natural_cmp(a, b));+ assert_eq!(v, vec!["01 x", "1 y", "2 a", "10 b", "Burn"]);+ let e = |n: &str, g: &str| MaskEffect { name: n.into(), group: g.into(), ..Default::default() };+ let list = vec![e("12 b", "Detail"), e("3 a", ""), e("11 a", "detail"), e("20 r", "Retouch"), e("Burn", "")];+ let order = menu_order(&list);+ let names: Vec<(String, Vec<&str>)> = order.iter().map(|(g, ix)| (g.clone(), ix.iter().map(|i| list[*i].name.as_str()).collect())).collect();+ assert_eq!(+ names,+ vec![("".to_string(), vec!["3 a", "Burn"]), ("Detail".to_string(), vec!["11 a", "12 b"]), ("Retouch".to_string(), vec!["20 r"]),]+ );+ }++ #[test]+ fn normalized_clamps_and_tidies_fields() {+ let e = MaskEffect {+ name: " X ".into(),+ adjust: LocalAdjustments { exposure: 99.0, amount: 150.0, ..Default::default() },+ fields: vec!["color_sat".into(), "bogus".into(), "exposure".into()],+ brush: Some(BrushSettings { size: f64::NAN, flow: 0.0, ..Default::default() }),+ ..Default::default()+ }+ .normalized();+ assert_eq!(e.name, "X");+ assert_eq!(e.adjust.exposure, 4.0);+ assert_eq!(e.adjust.amount, 100.0, "Amount isn't carried");+ assert_eq!(e.fields, vec!["exposure", "color_hue", "color_sat"]);+ let b = e.brush.unwrap();+ assert_eq!((b.size, b.flow), (0.04, 1.0));}}diff --git a/crates/engine/src/cmd/masks.rs b/crates/engine/src/cmd/masks.rsindex d05f80abb..7b4548734 100644--- a/crates/engine/src/cmd/masks.rs+++ b/crates/engine/src/cmd/masks.rs@@ -171,11 +171,14 @@ pub fn specs() -> Vec<CommandSpec> {return Ok(json!({"pending": true}));}let next = s.active().and_then(|id| s.develop_of(id)).map(|d| d.next_mask_id()).unwrap_or(1);+ // the effect last applied to a mask of this kind+ let adjust = super::mask_effects::new_mask_adjust(s, &kind);let out = masks_edit(s, "mask.add", "Add Mask", |masks, active| {masks.push(Mask {id: next,name: name.unwrap_or_else(|| format!("Mask {next}")),components: vec![MaskComponent { name: None, op: MaskOp::Add, invert: false, shape }],+ adjust,..Default::default()});*active = Some(next);@@ -245,11 +248,12 @@ pub fn specs() -> Vec<CommandSpec> {};let next = s.active().and_then(|id| s.develop_of(id)).map(|d| d.next_mask_id()).unwrap_or(1);let want = p.get("id").and_then(Value::as_u64).map(|v| v as u32).or(s.active_mask);+ let adjust = super::mask_effects::new_mask_adjust(s, "brush");masks_edit(s, "mask.brushStroke", "Brush", |masks, active| {let i = match want.and_then(|m| masks.iter().position(|x| x.id == m)) {Some(i) => i,None => {- masks.push(Mask { id: next, name: format!("Mask {next}"), ..Default::default() });+ masks.push(Mask { id: next, name: format!("Mask {next}"), adjust, ..Default::default() });*active = Some(next);masks.len() - 1}diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex 36b242741..2f27dc17c 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -24,6 +24,7 @@ pub mod keywords;pub mod library;pub mod lut_profiles;pub mod manage;+pub mod mask_effect_files;pub mod mask_effects;mod masks;mod merge;diff --git a/crates/engine/src/cmd/preset_files.rs b/crates/engine/src/cmd/preset_files.rsindex ec31130d4..5da980657 100644--- a/crates/engine/src/cmd/preset_files.rs+++ b/crates/engine/src/cmd/preset_files.rs@@ -2,6 +2,7 @@use serde_json::{Value, json};+use super::mask_effect_files as mef;use super::{CommandSpec, always, bad, cmd, str_param};use crate::preset_import::{group_from_dir, read_presets};use crate::presets::{LCPRESET_EXT, expand_preset_paths, to_lcpreset};@@ -18,28 +19,38 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {let mut imported = Vec::new();let mut failed = Vec::new();let mut skipped = 0usize;- // Lightroom local adjustment (brush) presets become mask effects+ // local adjustment (brush) presets — Lightroom's .lrtemplate, Camera Raw's local .xmp, our+ // .lceffect, also inside zips — become mask effectslet mut effects = Vec::new();+ let mut effect_failed = Vec::new();for top in &paths {let from_dir = std::path::Path::new(top).is_dir();for f in expand_preset_paths(std::slice::from_ref(top)) {- if f.to_ascii_lowercase().ends_with(".lrtemplate") {- let text = std::fs::read(&f).map(|b| String::from_utf8_lossy(&b).to_string()).unwrap_or_default();- if super::mask_effects::is_lr_local_template(&text) {- let stem = std::path::Path::new(&f).file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default();- match super::mask_effects::parse_lr_local_template(&text, &stem) {- Ok((e, unmapped)) => effects.push((e, unmapped, f.clone())),- Err(e) => failed.push(json!([f, e])),- }- continue;- }- }// presets in a folder go to a group named after it (unless the file names its own)// the path from the imported folder (inclusive) to the file's folderlet base = std::path::Path::new(top).parent().unwrap_or(std::path::Path::new(""));let rel = std::path::Path::new(&f).parent().and_then(|d| d.strip_prefix(base).ok()).map(|d| d.to_string_lossy().to_string());- let dir_group = rel.filter(|_| from_dir).and_then(|d| group_from_dir(&d));- let parsed = std::fs::read(&f).map_err(|e| e.to_string()).and_then(|b| read_presets(&f, &b, dir_group));+ let rel = rel.filter(|_| from_dir);+ let bytes = match mef::read_capped(&f) {+ Ok(b) => b,+ Err(e) => {+ failed.push(json!([f, e]));+ continue;+ }+ };+ let lower = f.to_ascii_lowercase();+ let maybe_local = [".lrtemplate", ".xmp", ".zip", ".lceffect"].iter().any(|x| lower.ends_with(x));+ let before = effects.len() + effect_failed.len();+ let local = maybe_local && mef::found_in(&f, &bytes, rel.as_deref().and_then(mef::group_for_dir), &mut effects, &mut effect_failed);+ // a zip may hold develop presets as well+ if local && !lower.ends_with(".zip") {+ continue;+ }+ let dir_group = rel.and_then(|d| group_from_dir(&d));+ let parsed = read_presets(&f, &bytes, dir_group);+ if local && parsed.is_err() && effects.len() + effect_failed.len() > before {+ continue;+ }match parsed {Ok(list) => {for mut it in list {@@ -58,12 +69,9 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {}}}- let effects = if dry {- effects.iter().map(|(e, unmapped, file)| json!({"name": e.name, "file": file, "unmapped": unmapped})).collect()- } else {- super::mask_effects::add_effects(s, effects)?- };- Ok(json!({"imported": imported, "skipped": skipped, "failed": failed, "effects": effects}))+ failed.extend(effect_failed.into_iter().map(|(f, e)| json!([f, e])));+ let (effects, dividers) = mef::add_found(s, effects, group.as_deref(), dry)?;+ Ok(json!({"imported": imported, "skipped": skipped, "failed": failed, "effects": effects, "effectDividers": dividers}))}fn export(s: &mut Session, p: &Value) -> Result<Value> {@@ -101,7 +109,7 @@ pub fn specs() -> Vec<CommandSpec> {"Import Presets",[],None,- "{paths: [file or folder], group?, dryRun?} — .lcpreset, XMP presets, .lrtemplate, photos carrying edits (DNG/JPEG/TIFF \"DNG presets\"), Luminar looks (.lmp, .mplumpack collections) and .zip bundles of these; folders give their name as group; crs: fields mapped per docs/xmp-interop.md; Lightroom local adjustment presets (.lrtemplate) become mask effects (`mask.effects`) → {imported: [{id,name,group,file,unmapped}], skipped, failed, effects: [{name,file,unmapped}]}",+ "{paths: [file or folder], group?, dryRun?} — .lcpreset, XMP presets, .lrtemplate, photos carrying edits (DNG/JPEG/TIFF \"DNG presets\"), Luminar looks (.lmp, .mplumpack collections) and .zip bundles of these; folders give their name as group; crs: fields mapped per docs/xmp-interop.md; local adjustment presets (Lightroom .lrtemplate, Camera Raw local .xmp, .lceffect) become mask effects (`mask.effects`; divider presets become their groups) → {imported: [{id,name,group,file,unmapped}], skipped, failed, effects: [{name,group,file,unmapped}], effectDividers: [{name,group,file}]}",always,import),diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex b8114eaf2..b88156d9e 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -259,6 +259,9 @@ pub struct Session {pub curve_presets: Vec<cmd::curves::CurvePreset>,/// Mask effect presets (the Masking panel's Effect menu).pub mask_effects: Vec<cmd::mask_effects::MaskEffect>,+ /// The effect a new mask of each kind (`brush`, `linear`…) starts with: the one last applied+ /// to a mask of that kind.+ pub mask_tool_effects: std::collections::BTreeMap<String, String>,/// Saved colour-label name sets.pub label_sets: Vec<cmd::manage::LabelSet>,/// Look-alike signatures by content key (Find Similar).@@ -376,6 +379,7 @@ impl Session {filter_presets: Vec::new(),curve_presets: Vec::new(),mask_effects: Vec::new(),+ mask_tool_effects: Default::default(),label_sets: Vec::new(),signatures: Default::default(),lut_profiles: Vec::new(),@@ -1014,6 +1018,8 @@ mod tests_library;#[cfg(test)]mod tests_lightroom_folder;#[cfg(test)]+mod tests_mask_effects;+#[cfg(test)]mod tests_merge;#[cfg(test)]mod tests_organize;diff --git a/crates/engine/src/library.rs b/crates/engine/src/library.rsindex 36a7378f6..5d6af424f 100644--- a/crates/engine/src/library.rs+++ b/crates/engine/src/library.rs@@ -169,6 +169,8 @@ struct PrefsFile {curve_presets: Vec<crate::cmd::curves::CurvePreset>,/// Mask effect presets.mask_effects: Vec<crate::cmd::mask_effects::MaskEffect>,+ /// The effect new masks of each kind start with.+ mask_tool_effects: std::collections::BTreeMap<String, String>,/// Colour-label name sets.label_sets: Vec<crate::cmd::manage::LabelSet>,/// Imported LUT profiles.@@ -399,6 +401,7 @@ impl Session {self.filter_presets = prefs.filter_presets;self.curve_presets = prefs.curve_presets;self.mask_effects = prefs.mask_effects;+ self.mask_tool_effects = prefs.mask_tool_effects;self.label_sets = prefs.label_sets;self.lut_profiles = prefs.lut_profiles;crate::cmd::lut_profiles::register_all(self);@@ -635,6 +638,7 @@ impl Session {filter_presets: self.filter_presets.clone(),curve_presets: self.curve_presets.clone(),mask_effects: self.mask_effects.clone(),+ mask_tool_effects: self.mask_tool_effects.clone(),label_sets: self.label_sets.clone(),lut_profiles: self.lut_profiles.clone(),keyword_sets: self.keyword_sets.clone(),diff --git a/crates/engine/src/presets.rs b/crates/engine/src/presets.rsindex 8c36aa742..a1958286d 100644--- a/crates/engine/src/presets.rs+++ b/crates/engine/src/presets.rs@@ -88,7 +88,7 @@ pub fn parse_preset_file(name: &str, bytes: &[u8]) -> Result<Vec<Preset>, Stringpub fn expand_preset_paths(paths: &[String]) -> Vec<String> {let preset_file = |p: &Path| {let ext = p.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();- ext == LCPRESET_EXT || ["xmp", "lrtemplate", "zip", "lmp", "mplumpack"].contains(&ext.as_str())+ ext == LCPRESET_EXT || ["xmp", "lrtemplate", "zip", "lmp", "mplumpack", crate::cmd::mask_effect_files::EFFECT_EXT].contains(&ext.as_str())};let mut out = Vec::new();for p in paths {diff --git a/crates/engine/src/tests_mask_effects.rs b/crates/engine/src/tests_mask_effects.rsnew file mode 100644index 000000000..18572449d--- /dev/null+++ b/crates/engine/src/tests_mask_effects.rs@@ -0,0 +1,293 @@+//! Mask effect presets end to end: managing them (rename, update, duplicate, delete, stars,+//! groups), applying (several masks, other photos, new masks remembering the effect), saving+//! some sliders, and importing Lightroom / Camera Raw local presets from folders and zips.++use std::path::PathBuf;++use serde_json::{Value, json};++use crate::Session;++fn temp_dir(tag: &str) -> PathBuf {+ let d = std::env::temp_dir().join(format!("lc-effects-{tag}-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&d);+ std::fs::create_dir_all(&d).unwrap();+ d+}++/// A Lightroom local preset (synthetic values) in the Lua shape Lightroom writes.+fn lr_local(title: &str, value: &str) -> String {+ format!(+ "s = {{\n\tid = \"0\",\n\tinternalName = \"{title}\",\n\ttitle = \"{title}\",\n\ttype = \"LocalizedAdjustmentPreset\",\n\tvalue = {{\n{value}\n\t}},\n\tversion = 0,\n}}"+ )+}++const ZERO: &str = "\t\texposure2012 = 0,\n\t\ttoningHue = 240,\n\t\ttoningSaturation = 0,";++fn names(v: &Value) -> Vec<String> {+ v["effects"].as_array().unwrap().iter().map(|e| e["name"].as_str().unwrap().to_string()).collect()+}++fn mask_adjust(s: &Session, id: u32) -> lightcraft_develop::LocalAdjustments {+ s.develop_of(s.active().unwrap()).unwrap().masks.iter().find(|m| m.id == id).unwrap().adjust+}++fn with_effect(s: &mut Session, name: &str, values: Value) {+ s.execute("mask.add", &json!({"kind": "radial"})).unwrap();+ s.execute("mask.adjust", &json!({"values": values})).unwrap();+ s.execute("mask.saveEffect", &json!({"name": name})).unwrap();+ s.execute("mask.delete", &json!({})).unwrap();+}++#[test]+fn managing_effects() {+ let mut s = Session::with_demo();+ with_effect(&mut s, "Lift", json!({"shadows": 30}));+ with_effect(&mut s, "Dark", json!({"exposure": -1}));+ // rename (not onto another one's name)+ assert!(s.execute("mask.renameEffect", &json!({"name": "lift", "to": "dark"})).is_err());+ assert!(s.execute("mask.renameEffect", &json!({"name": "nope", "to": "x"})).is_err());+ let v = s.execute("mask.renameEffect", &json!({"name": "lift", "to": "Lift Shadows"})).unwrap();+ assert_eq!(names(&v), ["Lift Shadows", "Dark"]);+ // duplicate: "<name> copy", then "<name> copy 2"+ let v = s.execute("mask.duplicateEffect", &json!({"name": "Dark"})).unwrap();+ assert_eq!(v["name"], "Dark copy");+ let v = s.execute("mask.duplicateEffect", &json!({"name": "Dark"})).unwrap();+ assert_eq!(v["name"], "Dark copy 2");+ assert!(s.execute("mask.duplicateEffect", &json!({"name": "Dark", "to": "dark copy"})).is_err());+ // stars and groups+ s.execute("mask.favoriteEffect", &json!({"name": "Dark copy"})).unwrap();+ assert!(s.mask_effects[2].favorite);+ s.execute("mask.favoriteEffect", &json!({"name": "Dark copy"})).unwrap();+ assert!(!s.mask_effects[2].favorite, "toggles");+ s.execute("mask.setEffectGroup", &json!({"names": ["Dark", "Dark copy"], "group": "Burn"})).unwrap();+ s.execute("mask.setEffectGroup", &json!({"name": "Dark copy 2", "group": "burn"})).unwrap();+ assert_eq!(s.mask_effects[3].group, "Burn", "an existing group's spelling wins");+ let v = s.execute("mask.effects", &json!({})).unwrap();+ assert_eq!(v["groups"], json!([{"name": "", "effects": ["Lift Shadows"]}, {"name": "Burn", "effects": ["Dark", "Dark copy", "Dark copy 2"]}]));+ s.execute("mask.renameEffectGroup", &json!({"group": "BURN", "to": "Darken"})).unwrap();+ assert!(s.mask_effects.iter().skip(1).all(|e| e.group == "Darken"));+ assert!(s.execute("mask.renameEffectGroup", &json!({"group": "Burn", "to": "x"})).is_err());+ // update with the selected mask's sliders+ s.execute("mask.add", &json!({"kind": "linear"})).unwrap();+ s.execute("mask.adjust", &json!({"values": {"exposure": -2, "clarity": 10}})).unwrap();+ s.execute("mask.updateEffect", &json!({"name": "Dark"})).unwrap();+ let dark = &s.mask_effects[1];+ assert_eq!((dark.adjust.exposure, dark.adjust.clarity, dark.group.as_str()), (-2.0, 10.0, "Darken"));+ // delete several (the menu asks first)+ s.execute("mask.deleteEffect", &json!({"names": ["Dark copy", "Dark copy 2"]})).unwrap();+ assert!(s.execute("mask.deleteEffect", &json!({"names": ["Dark", "gone"]})).is_err(), "nothing deleted when one is missing");+ assert_eq!(s.mask_effects.len(), 2);+ for bad in [json!({}), json!({"name": ""}), json!({"name": 3}), json!({"names": [1, 2]})] {+ assert!(s.execute("mask.deleteEffect", &bad).is_err(), "{bad}");+ assert!(s.execute("mask.favoriteEffect", &bad).is_err());+ }+}++#[test]+fn saving_some_sliders_and_amount() {+ let mut s = Session::with_demo();+ s.execute("mask.add", &json!({"kind": "brush"})).unwrap();+ s.execute("mask.adjust", &json!({"values": {"shadows": 25, "texture": -10, "amount": 60}})).unwrap();+ s.execute("mask.saveEffect", &json!({"name": "Only", "fields": "changed", "amount": true, "brush": {"size": 0.1, "flow": 40}})).unwrap();+ let e = &s.mask_effects[0];+ assert_eq!(e.fields, ["shadows", "texture"]);+ assert!(e.with_amount);+ assert_eq!(e.brush.map(|b| (b.size, b.flow)), Some((0.1, 40.0)));+ s.execute("mask.saveEffect", &json!({"name": "Pick", "fields": ["exposure", "bogus"]})).unwrap();+ assert_eq!(s.mask_effects[1].fields, ["exposure"]);+ for bad in [+ json!({"name": "x", "fields": []}),+ json!({"name": "x", "fields": 3}),+ json!({"name": "x", "fields": "some"}),+ json!({"name": "x", "brush": 7}),+ ] {+ assert!(s.execute("mask.saveEffect", &bad).is_err(), "{bad}");+ }+ // applying a partial effect leaves the other sliders and sets Amount; it brings its brush+ s.execute("mask.adjust", &json!({"values": {"shadows": 0, "texture": 0, "clarity": 50, "amount": 100}})).unwrap();+ let mid = s.active_mask.unwrap();+ let r = s.execute("mask.applyEffect", &json!({"name": "only"})).unwrap();+ assert_eq!(r["brush"]["flow"], 40.0);+ let a = mask_adjust(&s, mid);+ assert_eq!((a.shadows, a.texture, a.clarity, a.amount), (25.0, -10.0, 50.0, 60.0));+ // a mask that changes nothing has nothing to save as "changed"+ s.execute("mask.add", &json!({"kind": "radial"})).unwrap();+ assert!(s.execute("mask.saveEffect", &json!({"name": "Empty", "fields": "changed"})).is_err());+}++#[test]+fn applying_to_several_masks_and_photos_is_one_undo_step() {+ let mut s = Session::with_demo();+ with_effect(&mut s, "Bright", json!({"exposure": 1}));+ let ids: Vec<u64> = s.catalog.photos().take(2).map(|p| p.id.0).collect();+ s.execute("library.select", &json!({"ids": ids, "active": ids[0]})).unwrap();+ for _ in 0..2 {+ s.execute("mask.add", &json!({"kind": "radial", "name": "Face"})).unwrap();+ }+ s.execute("mask.add", &json!({"kind": "linear", "name": "Sky"})).unwrap();+ let all: Vec<u32> = s.develop_of(s.active().unwrap()).unwrap().masks.iter().map(|m| m.id).collect();+ let face = all[all.len() - 3];+ s.execute("mask.applyEffect", &json!({"name": "Bright", "ids": [face, all[all.len() - 2]], "remember": false})).unwrap();+ assert_eq!(mask_adjust(&s, face).exposure, 1.0);+ assert_eq!(mask_adjust(&s, *all.last().unwrap()).exposure, 0.0, "only the masks named");+ assert!(s.execute("mask.applyEffect", &json!({"name": "Bright", "ids": [999]})).is_err());+ assert!(s.execute("mask.applyEffect", &json!({"name": "Bright", "ids": []})).is_err());+ s.execute("mask.applyEffect", &json!({"name": "Bright", "all": true, "remember": false})).unwrap();+ assert_eq!(mask_adjust(&s, *all.last().unwrap()).exposure, 1.0);+ // the other selected photo's "Face" mask gets the effect too, in the same undo step+ s.execute("library.select", &json!({"ids": ids, "active": ids[1]})).unwrap();+ s.execute("mask.add", &json!({"kind": "radial", "name": "face"})).unwrap();+ s.execute("mask.add", &json!({"kind": "radial", "name": "Other"})).unwrap();+ s.execute("library.select", &json!({"ids": ids, "active": ids[0]})).unwrap();+ with_effect(&mut s, "Warm", json!({"temp": 20}));+ let r = s.execute("mask.applyEffect", &json!({"name": "Warm", "id": face, "photos": "selected", "remember": false})).unwrap();+ assert_eq!(r["photos"], 2);+ let other = s.develop_of(lightcraft_catalog::PhotoId(ids[1])).unwrap();+ assert_eq!(other.masks.iter().map(|m| m.adjust.temp).collect::<Vec<_>>(), [20.0, 0.0]);+ s.execute("edit.undo", &json!({})).unwrap();+ let other = s.develop_of(lightcraft_catalog::PhotoId(ids[1])).unwrap();+ assert_eq!(other.masks[0].adjust.temp, 0.0, "undone on every photo");+ assert_eq!(mask_adjust(&s, face).temp, 0.0);+}++#[test]+fn new_masks_start_with_the_last_effect_of_their_tool() {+ let mut s = Session::with_demo();+ with_effect(&mut s, "Dodge", json!({"exposure": 0.5}));+ with_effect(&mut s, "Grad", json!({"highlights": -40}));+ s.execute("mask.add", &json!({"kind": "brush"})).unwrap();+ s.execute("mask.applyEffect", &json!({"name": "Dodge"})).unwrap();+ s.execute("mask.add", &json!({"kind": "linear"})).unwrap();+ s.execute("mask.applyEffect", &json!({"name": "Grad"})).unwrap();+ assert_eq!(s.execute("mask.effects", &json!({})).unwrap()["toolEffects"], json!({"brush": "Dodge", "linear": "Grad"}));+ // a new brush mask (painted with no mask selected) starts as Dodge, a new gradient as Grad+ s.execute("mask.select", &json!({"id": null})).unwrap();+ s.execute("mask.brushStroke", &json!({"points": [[0.2, 0.2], [0.3, 0.3]]})).unwrap();+ assert_eq!(mask_adjust(&s, s.active_mask.unwrap()).exposure, 0.5);+ s.execute("mask.add", &json!({"kind": "linear"})).unwrap();+ assert_eq!(mask_adjust(&s, s.active_mask.unwrap()).highlights, -40.0);+ s.execute("mask.add", &json!({"kind": "radial"})).unwrap();+ assert_eq!(mask_adjust(&s, s.active_mask.unwrap()).exposure, 0.0, "radial has none");+ // set / clear explicitly; renaming and deleting the effect follow+ s.execute("mask.toolEffect", &json!({"tool": "radial", "name": "dodge"})).unwrap();+ assert!(s.execute("mask.toolEffect", &json!({"tool": "radial", "name": "nope"})).is_err());+ s.execute("mask.renameEffect", &json!({"name": "Dodge", "to": "Dodge 2"})).unwrap();+ assert_eq!(s.mask_tool_effects.get("brush").map(String::as_str), Some("Dodge 2"));+ s.execute("mask.deleteEffect", &json!({"name": "Dodge 2"})).unwrap();+ assert!(!s.mask_tool_effects.contains_key("brush") && !s.mask_tool_effects.contains_key("radial"));+ s.execute("mask.toolEffect", &json!({"tool": "linear"})).unwrap();+ assert!(s.mask_tool_effects.is_empty());+}++#[test]+fn lightroom_folder_import_groups_by_dividers_and_round_trips() {+ let lib = temp_dir("folder");+ let src = lib.join("Local Adjustment Presets");+ std::fs::create_dir_all(src.join("Kit")).unwrap();+ let files: [(&str, String); 7] = [+ ("01 Burn.lrtemplate", lr_local("01 Burn", "\t\texposure2012 = -0.25,")),+ ("10 ----- DETAIL ----- 10.lrtemplate", lr_local("10 ----- DETAIL ----- 10", ZERO)),+ ("12 Sky.lrtemplate", lr_local("12 Sky | Cloud", "\t\thighlights2012 = -1,\n\t\tgrain = 0.06,")),+ ("20 ----- RETOUCHING ----- 20.lrtemplate", lr_local("20 ----- RETOUCHING ----- 20", ZERO)),+ ("21 Skin.lrtemplate", lr_local("21 Skin", "\t\tclarity2012 = -1,\n\t\tsharpness = -0.25,")),+ ("Kit/Glow.lrtemplate", lr_local("Glow", "\t\tdehaze = -0.2,")),+ ("Look.lrtemplate", "s = { title = \"Look\", type = \"Develop\", value = { settings = { Exposure2012 = 0.5 } } }".to_string()),+ ];+ for (f, text) in &files {+ std::fs::write(src.join(f), text).unwrap();+ }+ std::fs::write(src.join("broken.lrtemplate"), "s = { type = \"LocalizedAdjustmentPreset\", value = 5 }").unwrap();+ {+ let mut s = Session::new().with_fs();+ s.open_library(&lib, true).unwrap();+ // an earlier import that kept the dividers as effects+ s.mask_effects.push(crate::cmd::mask_effects::MaskEffect { name: "10 ----- DETAIL ----- 10".into(), ..Default::default() });+ let r = s.execute("preset.import", &json!({"paths": [src.to_string_lossy()]})).unwrap();+ assert_eq!(r["imported"].as_array().unwrap().len(), 1, "the develop template stays a develop preset");+ assert_eq!(r["effectDividers"].as_array().unwrap().len(), 2);+ assert_eq!(r["failed"].as_array().unwrap().len(), 1, "{r}");+ let groups: Vec<(String, String)> = s.mask_effects.iter().map(|e| (e.name.clone(), e.group.clone())).collect();+ assert_eq!(+ groups,+ [+ ("01 Burn".to_string(), "".to_string()),+ ("12 Sky | Cloud".into(), "Detail".into()),+ ("21 Skin".into(), "Retouching".into()),+ ("Glow".into(), "Kit".into()),+ ],+ "the old divider effect is gone; folders and dividers give groups"+ );+ let sky = &r["effects"].as_array().unwrap().iter().find(|e| e["name"] == "12 Sky | Cloud").unwrap()["unmapped"];+ assert_eq!(sky, &json!(["Grain"]));+ // the effects' own import: a dry run changes nothing+ let r = s.execute("mask.importEffects", &json!({"path": src.to_string_lossy(), "dryRun": true, "group": "X"})).unwrap();+ assert_eq!(r["imported"].as_array().unwrap().len(), 4);+ assert!(s.mask_effects.iter().all(|e| e.group != "X"));+ // export one group, everything; re-import keeps groups, stars and the kept grain+ s.execute("mask.favoriteEffect", &json!({"name": "21 Skin"})).unwrap();+ let out = lib.join("backup.lceffect");+ let r = s.execute("mask.exportEffects", &json!({"path": out.to_string_lossy(), "group": "retouching"})).unwrap();+ assert_eq!(r["count"], 1);+ assert!(s.execute("mask.exportEffects", &json!({"path": out.to_string_lossy(), "group": "none"})).is_err());+ s.execute("mask.exportEffects", &json!({"path": out.to_string_lossy()})).unwrap();+ let before = s.mask_effects.clone();+ s.execute("mask.deleteEffect", &json!({"names": before.iter().map(|e| e.name.clone()).collect::<Vec<_>>()})).unwrap();+ // through the general import too (File ▸ Import Profiles & Presets…, drag & drop)+ let r = s.execute("preset.import", &json!({"paths": [out.to_string_lossy()]})).unwrap();+ assert_eq!(r["effects"].as_array().unwrap().len(), 4);+ assert_eq!(s.mask_effects, before, "round trip");+ assert_eq!(s.mask_effects[1].extra.get("grain"), Some(&json!(0.06)));+ s.close_library().unwrap();+ }+ let mut s = Session::new().with_fs();+ s.open_library(&lib, false).unwrap();+ assert_eq!(s.mask_effects.len(), 4, "persisted");+ assert!(s.mask_effects[2].favorite);+ let _ = std::fs::remove_dir_all(&lib);+}++#[test]+fn zips_and_camera_raw_xmp_presets_import() {+ let lib = temp_dir("zip");+ let xmp = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">+<rdf:Description rdf:about="" xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:PresetType="Local" crs:LocalSaturation="-0.5">+ <crs:Name><rdf:Alt><rdf:li xml:lang="x-default">Mute</rdf:li></rdf:Alt></crs:Name>+</rdf:Description></rdf:RDF></x:xmpmeta>"#;+ let develop_xmp = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">+<rdf:Description rdf:about="" xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:Exposure2012="0.5" crs:Name="Bright"/></rdf:RDF></x:xmpmeta>"#;+ let brush = lr_local("Brush A", "\t\tshadows2012 = 0.5,");+ let zip = crate::preset_import::tests::zip(+ &[("Skin Kit/Brush A.lrtemplate", brush.as_bytes()), ("Skin Kit/Mute.xmp", xmp.as_bytes()), ("Looks/Bright.xmp", develop_xmp.as_bytes())],+ true,+ );+ let path = lib.join("bundle.zip");+ std::fs::write(&path, zip).unwrap();+ let mut s = Session::with_demo();+ let r = s.execute("preset.import", &json!({"paths": [path.to_string_lossy()]})).unwrap();+ assert_eq!(r["imported"].as_array().unwrap().len(), 1, "the develop XMP: {r}");+ assert_eq!(r["effects"].as_array().unwrap().len(), 2);+ let got: Vec<(String, String)> = s.mask_effects.iter().map(|e| (e.name.clone(), e.group.clone())).collect();+ assert_eq!(got, [("Brush A".to_string(), "Skin Kit".to_string()), ("Mute".into(), "Skin Kit".into())]);+ assert_eq!(s.mask_effects[1].adjust.saturation, -50.0);+ // the effects' own import reads the zip and a lone XMP; a develop XMP named on its own fails+ let mut s = Session::with_demo();+ let lone = lib.join("Mute.xmp");+ std::fs::write(&lone, xmp).unwrap();+ let dev = lib.join("Bright.xmp");+ std::fs::write(&dev, develop_xmp).unwrap();+ let r = s.execute("mask.importEffects", &json!({"paths": [path.to_string_lossy(), lone.to_string_lossy(), dev.to_string_lossy()]})).unwrap();+ assert_eq!(r["imported"].as_array().unwrap().len(), 3);+ assert_eq!(r["failed"].as_array().unwrap().len(), 1);+ assert_eq!(s.mask_effects.len(), 2, "same names replaced");+ // unreadable things are errors, never panics+ std::fs::write(lib.join("junk.zip"), b"PK\x03\x04\xff\xff").unwrap();+ std::fs::write(lib.join("junk.lceffect"), b"{\"effects\": [{\"name\": \"x\", \"adjust\": {\"exposure\": \"high\"}}]}").unwrap();+ for f in ["junk.zip", "junk.lceffect", "missing.lrtemplate"] {+ let r = s.execute("mask.importEffects", &json!({"path": lib.join(f).to_string_lossy()})).unwrap();+ assert_eq!(r["failed"].as_array().unwrap().len(), 1, "{f}: {r}");+ let _ = s.execute("preset.import", &json!({"paths": [lib.join(f).to_string_lossy()]}));+ }+ assert!(s.execute("mask.importEffects", &json!({})).is_err());+ let _ = std::fs::remove_dir_all(&lib);+}diff --git a/crates/engine/src/tests_prefs.rs b/crates/engine/src/tests_prefs.rsindex 494b17ede..30f39a708 100644--- a/crates/engine/src/tests_prefs.rs+++ b/crates/engine/src/tests_prefs.rs@@ -285,7 +285,7 @@ fn mask_effects_import_apply_save_export_and_persist() {let r = s.execute("preset.import", &json!({"paths": [src.to_string_lossy()]})).unwrap();assert_eq!(r["imported"].as_array().unwrap().len(), 1, "the develop template stays a develop preset");assert_eq!(r["effects"][0]["name"], "Brighten");- assert_eq!(r["effects"][0]["unmapped"], json!(["grain"]));+ assert_eq!(r["effects"][0]["unmapped"], json!(["Grain"]));assert_eq!(s.mask_effects.len(), 1);// apply to a mask: every slider set, Amount kepts.execute("mask.add", &json!({"kind": "radial"})).unwrap();diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 9a387c77c..5df4b66bd 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -1385,7 +1385,7 @@ pub fn is_model_file(path: &str) -> bool {/// Files dropped on the window that are presets rather than photos.pub fn is_preset_file(path: &str) -> bool {let ext = std::path::Path::new(path).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();- ["lcpreset", "lrtemplate", "xmp", "zip", "cube", "lmp", "mplumpack"].contains(&ext.as_str())+ ["lcpreset", "lrtemplate", "xmp", "zip", "cube", "lmp", "mplumpack", "lceffect"].contains(&ext.as_str())}/// Splits dropped files into presets and everything else. An `.xmp` dropped next to a photo with the samediff --git a/crates/ui-egui/src/pick.rs b/crates/ui-egui/src/pick.rsindex 1032a5cd9..7ee3853ed 100644--- a/crates/ui-egui/src/pick.rs+++ b/crates/ui-egui/src/pick.rs@@ -58,7 +58,7 @@ impl PickRequest {}/// What File ▸ Import Profiles & Presets… opens.-pub const PRESET_EXTENSIONS: &[&str] = &["lcpreset", "xmp", "lrtemplate", "zip", "dng", "lmp", "mplumpack", "cube"];+pub const PRESET_EXTENSIONS: &[&str] = &["lcpreset", "xmp", "lrtemplate", "zip", "dng", "lmp", "mplumpack", "cube", "lceffect"];/// What Import Point Curve Presets… opens.pub const CURVE_PRESET_EXTENSIONS: &[&str] = &["lccurve", "json"];