diff --git a/crates/engine/src/cmd/atn_cmds/steps_doc.rs b/crates/engine/src/cmd/atn_cmds/steps_doc.rs index 4a4202a26a..d4778d16c3 100644 --- a/crates/engine/src/cmd/atn_cmds/steps_doc.rs +++ b/crates/engine/src/cmd/atn_cmds/steps_doc.rs @@ -427,7 +427,12 @@ pub(super) fn image_size_to(_: &str, p: &Value) -> Option { if let Some(i) = jstr(p, "resample").filter(|r| *r != "none") { d = d.with("Intr", enm("Intp", lookup_back(INTERPOLATION, i)?)); } - Some(d.with("scaleStyles", D::Boolean(jbool(p, "scaleStyles").unwrap_or(true)))) + // A recorded step without the key keeps style sizes, so only scaling needs the key: an + // Image Size step recorded without it saves back unchanged. + if jbool(p, "scaleStyles").unwrap_or(true) { + d = d.with("scaleStyles", D::Boolean(true)); + } + Some(d) } pub(super) fn crop_from(d: &Descriptor) -> Mapped { @@ -486,19 +491,28 @@ pub(super) fn stop_to(_: &str, p: &Value) -> Option { pub(super) fn paste_from(d: &Descriptor) -> Mapped { // As is a class, not text or an enum; unknown forms must not fall back to raster paste. if let Some(value) = d.get("As ") { + // `Pxel` is what an ordinary Paste and Paste in Place record; it keeps the ordinary route + // (layer recreation, mask and channel targets, in place). Only a vector form is explicit. let mode = match value { - D::Class(value) if value.class_id.is("Pxel") => "pixels", - D::Class(value) if value.class_id.is("Path") => "path", - D::Class(value) if value.class_id.is("shapeClass") => "shape", + D::Class(value) if value.class_id.is("Pxel") => None, + D::Class(value) if value.class_id.is("Path") => Some("path"), + D::Class(value) if value.class_id.is("shapeClass") => Some("shape"), _ => return Mapped::Unsupported { harmless: false }, }; - if !matches!(d.get("inPlace"), None | Some(D::Boolean(false))) || d.get("null").is_some() { + let in_place = match d.get("inPlace") { + None => false, + Some(D::Boolean(value)) => *value, + Some(_) => return Mapped::Unsupported { harmless: false }, + }; + if (in_place && mode.is_some()) || d.get("null").is_some() { return Mapped::Unsupported { harmless: false }; } if d.get("AntA").is_some_and(|v| !matches!(v, D::Enumerated { type_id, value } if type_id.is("Annt") && value.is("Anno"))) { return Mapped::Unsupported { harmless: false }; } - return step("edit.paste", json!({"as": mode})); + if let Some(mode) = mode { + return step("edit.paste", json!({"as": mode})); + } } none(if get_bool(d, "inPlace") == Some(true) { "edit.pasteSpecial.pasteInPlace" } else { "edit.paste" }) } @@ -574,8 +588,9 @@ pub(super) fn profile_from(d: &Descriptor, id: &str) -> Mapped { let Some(profile) = name.as_deref().and_then(|n| lookup(PROFILES, n)) else { return Mapped::Unsupported { harmless: false } }; let mut p = json!({"profile": profile}); if id == "edit.convertToProfile" { - // All mapped PROFILES are RGB. Other radio values need their own target mapping. - if !matches!(d.get("sdwM"), None | Some(D::Integer(2))) { + // All mapped PROFILES are RGB; the reference application records -1 for these RGB + // targets. Other values need their own target mapping. + if !matches!(d.get("sdwM"), None | Some(D::Integer(-1))) { return Mapped::Unsupported { harmless: false }; } for (key, param) in [("Dthr", "dither"), ("Fltt", "flatten"), ("rasterizePlaced", "rasterizePlaced")] { @@ -597,7 +612,7 @@ pub(super) fn profile_from(d: &Descriptor, id: &str) -> Mapped { step(id, p) } -/// Export effective native flags explicitly, deriving the RGB radio value from the mapped target. +/// Export effective native flags explicitly, with the `sdwM` value recorded for RGB targets. pub(super) fn profile_to(id: &str, p: &Value) -> Option { let name = lookup_back(PROFILES, jstr(p, "profile")?)?; let mut d = desc("null").with("null", target_ref("Dcmn")); @@ -609,7 +624,7 @@ pub(super) fn profile_to(id: &str, p: &Value) -> Option { .with("T ", text(name)) .with("Inte", enm("Inte", lookup_back(INTENT, jstr(p, "intent").unwrap_or("relative"))?)) .with("MpBl", D::Boolean(jbool(p, "bpc").unwrap_or(true))) - .with("sdwM", D::Integer(2)); + .with("sdwM", D::Integer(-1)); for (key, param) in [("Dthr", "dither"), ("Fltt", "flatten"), ("rasterizePlaced", "rasterizePlaced")] { let value = match p.get(param) { None | Some(Value::Null) => false, diff --git a/crates/engine/src/cmd/color_cmds/profile_dither.rs b/crates/engine/src/cmd/color_cmds/profile_dither.rs index eff335a10b..8f99f49dbe 100644 --- a/crates/engine/src/cmd/color_cmds/profile_dither.rs +++ b/crates/engine/src/cmd/color_cmds/profile_dither.rs @@ -1,6 +1,10 @@ //! Opt-in 8-bit profile quantization. The ordinary CMS buffer paths stay unchanged. +use std::sync::Arc; + use photocraft_geom::{Rect, TILE_SIZE, TileCoord}; +use photocraft_raster::Tile; +use rayon::prelude::*; use super::{ ColorMode, Document, EngineError, Intent, PixelFormat, Profile, Result, SampleType, Surface, Transform, cms_err, convert_color, convert_document, @@ -50,12 +54,29 @@ fn tile_origin(c: TileCoord) -> Result<(i32, i32)> { Ok((x as i32, y as i32)) } +/// A transparent default stays transparent: its converted default already stands for the absent +/// tiles, and dither noise under alpha 0 is invisible, so only stored tiles are dithered. +fn sparse(s: &Surface) -> bool { + let sf = s.format(); + sf.alpha && s.default_pixel().get(sf.mode.color_channels()).is_some_and(|a| *a == 0.0) +} + +/// The tiles the dithered output stores: every in-canvas tile (unless the surface is sparse) +/// plus every stored tile. +fn dither_tiles(s: &Surface, bounds: Rect) -> Vec { + if sparse(s) { + return s.tiles().map(|(c, _)| *c).collect(); + } + let outside = s.tiles().map(|(c, _)| *c).filter(|c| !in_canvas_tiles(*c, bounds)); + bounds.tiles().chain(outside).collect() +} + /// Price every additional output tile before allocating any; distant tiles add no bounding box. fn output_bytes(s: &Surface, to: PixelFormat, bounds: Rect) -> Result { - let mut count = u128::from(bounds.tile_count()); + let mut count = if sparse(s) { 0 } else { u128::from(bounds.tile_count()) }; for (c, _) in s.tiles() { tile_origin(*c)?; - if !in_canvas_tiles(*c, bounds) { + if sparse(s) || !in_canvas_tiles(*c, bounds) { count = count.checked_add(1).ok_or_else(|| bad("dither output size overflowed"))?; } } @@ -78,46 +99,53 @@ fn quantize(value: f32, threshold: f64) -> u8 { } /// Stream the finite canvas and stored deviations, retaining the undithered infinite default. +/// Tiles are independent (the noise depends on pixel coordinates only) and run in parallel. fn surface(s: &Surface, to: PixelFormat, t: &Transform, bounds: Rect) -> Result { - let (ss, ds) = (s.channels(), to.channels()); - let (ni, no) = (t.inputs(), t.outputs()); + let ds = to.channels(); let mut converted_default = [0.0; 16]; - t.convert_f32(&s.default_pixel(), ss, &mut converted_default[..ds], ds, true); + t.convert_f32(&s.default_pixel(), s.channels(), &mut converted_default[..ds], ds, true); let mut out = Surface::with_default(to, &converted_default[..ds]); + let tiles = dither_tiles(s, bounds).par_iter().map(|c| dither_tile(s, &out, t, bounds, *c).map(|tile| (*c, Arc::new(tile)))).collect::>>()?; + out.put_tiles(tiles); + out.prune(); + Ok(out) +} + +/// One output tile of [`surface`], starting from the converted default of `out`. +fn dither_tile(s: &Surface, out: &Surface, t: &Transform, bounds: Rect, c: TileCoord) -> Result { + let (ss, ds) = (s.channels(), out.channels()); + let (ni, no) = (t.inputs(), t.outputs()); let default = s.default_bytes(); - let outside = s.tiles().map(|(c, _)| *c).filter(|c| !in_canvas_tiles(*c, bounds)); - for c in bounds.tiles().chain(outside) { - let (x0, y0) = tile_origin(c)?; - let source = s.tile(c).map(|tile| tile.bytes()); - let dest = out.try_tile_mut(c).map_err(|e| EngineError::Other(format!("could not allocate dither output: {e}")))?; - for (index, dp) in dest.bytes_mut().chunks_exact_mut(ds).enumerate() { - let x = x0 + (index % TILE_SIZE as usize) as i32; - let y = y0 + (index / TILE_SIZE as usize) as i32; - let sp = match source { - Some(bytes) => bytes.get(index * ss..index * ss + ss).ok_or_else(|| bad("a stored tile has invalid sample storage"))?, - None => default, - }; - // A redundant default tile outside the canvas must match the implicit plane. - if !bounds.contains(x, y) && sp == default { - continue; - } - let mut input = [0.0; 16]; - let mut output = [0.0; 16]; - for (d, s) in input.iter_mut().zip(sp).take(ni) { - *d = f32::from(*s) / 255.0; - } - t.eval_fast(&input[..ni], &mut output[..no]); - // The hash can return 1.0; recenter its 65536 bins strictly inside (0, 1). - let threshold = (f64::from(photocraft_color::dither_noise(x, y)) * 65535.0 + 0.5) / 65536.0; - for (d, value) in dp.iter_mut().zip(output).take(no) { - *d = quantize(value, threshold); - } - for (d, s) in dp.iter_mut().skip(no).zip(sp.iter().skip(ni)) { - *d = *s; - } + let (x0, y0) = tile_origin(c)?; + let source = s.tile(c).map(|tile| tile.bytes()); + let mut dest = out.try_default_tile().map_err(|e| EngineError::Other(format!("could not allocate dither output: {e}")))?; + for (index, dp) in dest.bytes_mut().chunks_exact_mut(ds).enumerate() { + let x = x0 + (index % TILE_SIZE as usize) as i32; + let y = y0 + (index / TILE_SIZE as usize) as i32; + let sp = match source { + Some(bytes) => bytes.get(index * ss..index * ss + ss).ok_or_else(|| bad("a stored tile has invalid sample storage"))?, + None => default, + }; + // A redundant default tile outside the canvas must match the implicit plane. + if !bounds.contains(x, y) && sp == default { + continue; + } + let mut input = [0.0; 16]; + let mut output = [0.0; 16]; + for (d, s) in input.iter_mut().zip(sp).take(ni) { + *d = f32::from(*s) / 255.0; + } + t.eval_fast(&input[..ni], &mut output[..no]); + // The hash can return 1.0; recenter its 65536 bins strictly inside (0, 1). + let threshold = (f64::from(photocraft_color::dither_noise(x, y)) * 65535.0 + 0.5) / 65536.0; + for (d, value) in dp.iter_mut().zip(output).take(no) { + *d = quantize(value, threshold); + } + for (d, s) in dp.iter_mut().skip(no).zip(sp.iter().skip(ni)) { + *d = *s; } } - Ok(out) + Ok(dest) } /// Preserve ordinary conversion outside opt-in U8, admitting the whole dither edit first. diff --git a/crates/engine/tests/convert_profile_atn.rs b/crates/engine/tests/convert_profile_atn.rs index bf539408c0..465a77b350 100644 --- a/crates/engine/tests/convert_profile_atn.rs +++ b/crates/engine/tests/convert_profile_atn.rs @@ -119,7 +119,7 @@ fn rendered(s: &Session) -> Vec<[f32; 4]> { #[test] fn recorded_rgb_flags_survive_save_reimport_and_public_playback() { for values in [[true, true, true], [true, false, true], [true, false, false], [false, false, false]] { - let mut d = descriptor().with("sdwM", D::Integer(2)); + let mut d = descriptor().with("sdwM", D::Integer(-1)); let mut params = json!({"profile": "srgb", "intent": "relative", "bpc": false}); for ((key, param), value) in FLAGS.into_iter().zip(values) { d = d.with(key, D::Boolean(value)); @@ -149,7 +149,7 @@ fn recorded_rgb_flags_survive_save_reimport_and_public_playback() { let saved = save(&mut replay); let parsed = atn::parse(&saved).unwrap(); let saved_d = parsed.actions[0].items[0].descriptor.as_ref().unwrap(); - assert_eq!(saved_d.get("sdwM"), Some(&D::Integer(2))); + assert_eq!(saved_d.get("sdwM"), Some(&D::Integer(-1))); for ((key, _), value) in FLAGS.into_iter().zip(values) { assert_eq!(saved_d.get(key), Some(&D::Boolean(value))); } @@ -205,7 +205,7 @@ fn defaults_are_explicit_false_and_assign_profile_is_unchanged() { for (key, _) in FLAGS { assert_eq!(d.get(key), Some(&D::Boolean(false))); } - assert_eq!(d.get("sdwM"), Some(&D::Integer(2))); + assert_eq!(d.get("sdwM"), Some(&D::Integer(-1))); } let assign = Action::new("Assign", vec![("edit.assignProfile".into(), json!({"profile": "srgb"}))]); let (bytes, skipped) = atn_cmds::export("Profile", &[&assign], &[], false).unwrap(); @@ -222,12 +222,12 @@ fn defaults_are_explicit_false_and_assign_profile_is_unchanged() { #[test] fn unsupported_values_are_preserved_and_invalid_native_values_refuse_export() { let mut descriptors = Vec::new(); - for value in [D::Integer(3), D::Integer(4), D::Integer(-1), D::Integer(999), D::Boolean(true), D::Double(2.0)] { + for value in [D::Integer(3), D::Integer(4), D::Integer(2), D::Integer(999), D::Boolean(true), D::Double(2.0)] { descriptors.push(descriptor().with("sdwM", value)); } for (key, _) in FLAGS { for value in [D::Integer(1), D::Text(UnicodeString::new_nul("true"))] { - descriptors.push(descriptor().with("sdwM", D::Integer(2)).with(key, value)); + descriptors.push(descriptor().with("sdwM", D::Integer(-1)).with(key, value)); } } for d in descriptors { @@ -251,3 +251,36 @@ fn unsupported_values_are_preserved_and_invalid_native_values_refuse_export() { let action = Action::new("Invalid radio null", vec![("edit.convertToProfile".into(), json!({"profile": "srgb", "sdwM": null}))]); assert!(atn_cmds::export("Profile", &[&action], &[], false).is_err()); } + +/// A step recorded by the reference application (`sdwM` -1, dither on) maps and saves back as recorded. +#[test] +fn reference_recorded_convert_to_profile_maps() { + let d = Descriptor::new("null") + .with( + "null", + D::Reference(vec![photocraft_psd::descriptor::ReferenceItem::Enumerated { + class: photocraft_psd::descriptor::Class { name: UnicodeString::new_nul(""), class_id: Id::new("Dcmn") }, + type_id: Id::new("Ordn"), + value: Id::new("Trgt"), + }]), + ) + .with("T ", D::Text(UnicodeString::new_nul("ProPhoto RGB"))) + .with("Inte", D::Enumerated { type_id: Id::new("Inte"), value: Id::new("AClr") }) + .with("Dthr", D::Boolean(true)) + .with("Fltt", D::Boolean(false)) + .with("rasterizePlaced", D::Boolean(false)) + .with("sdwM", D::Integer(-1)); + let mut s = fixture(); + assert_eq!(load(&mut s, &recorded(d))["unsupported"], json!([])); + assert_eq!( + s.actions.list[0].steps, + vec![( + "edit.convertToProfile".into(), + json!({"profile": "prophoto-compat", "intent": "absolute", "dither": true, "flatten": false, "rasterizePlaced": false}) + )] + ); + let saved = atn::parse(&save(&mut s)).unwrap(); + let saved = saved.actions[0].items[0].descriptor.as_ref().unwrap(); + assert_eq!(saved.get("sdwM"), Some(&D::Integer(-1))); + assert_eq!(saved.get("Dthr"), Some(&D::Boolean(true))); +} diff --git a/crates/engine/tests/convert_profile_dither.rs b/crates/engine/tests/convert_profile_dither.rs index 54cc62a31f..73b0441c23 100644 --- a/crates/engine/tests/convert_profile_dither.rs +++ b/crates/engine/tests/convert_profile_dither.rs @@ -209,3 +209,21 @@ fn refusals_are_early_and_atomic() { assert!(state.history.can_redo()); } } + +/// Absent tiles of a transparent layer stay absent: only the stored tile is dithered. +#[test] +fn transparent_layers_stay_sparse() { + let p = json!({"profile": "display-p3", "dither": true}); + let stored = |size: Size| { + let mut surface = Surface::with_default(PixelFormat::RGBA8, &[0.0; 4]); + let tile = surface.solid_tile(&GRAY); + surface.put_tiles([(TileCoord::new(1, 1), tile)]); + document(size, surface, SampleType::U8) + }; + let large = converted(stored(Size::new(1024, 1024)), p.clone()); + assert_eq!(pixels(&large).tile_count(), 1, "a transparent layer must not become dense"); + let small = converted(stored(Size::new(512, 512)), p); + let tile = |doc: &Document| pixels(doc).tile(TileCoord::new(1, 1)).unwrap().bytes().to_vec(); + assert_eq!(tile(&large), tile(&small), "the stored tile is dithered as before"); + assert_eq!(pixels(&large).pixel(700, 700)[3], 0.0); +} diff --git a/crates/engine/tests/image_size_scale_styles_atn.rs b/crates/engine/tests/image_size_scale_styles_atn.rs index a177202a98..e6a5028458 100644 --- a/crates/engine/tests/image_size_scale_styles_atn.rs +++ b/crates/engine/tests/image_size_scale_styles_atn.rs @@ -5,7 +5,7 @@ use photocraft_doc::{Effect, Effects, FxCommon, FxPaint, LayerId, StrokeFx, Stro use photocraft_engine::{Session, actions_cmds::Action, atn_cmds}; use photocraft_psd::{ atn::{self, AtnAction, AtnEvent, AtnFile, AtnItem}, - descriptor::{Descriptor, UnicodeString, Value as D}, + descriptor::{Descriptor, Id, UnicodeString, Value as D}, }; use serde_json::{Value, json}; @@ -83,7 +83,8 @@ fn imported_style_scaling_survives_saved_bytes_and_playback() { assert_eq!(s.actions.list[0].steps, vec![("image.imageSize".into(), json!({"percent": 50, "scaleStyles": scale}))]); let saved = save(&mut s); let parsed = atn::parse(&saved).unwrap(); - assert_eq!(parsed.actions[0].items[0].descriptor.as_ref().unwrap().get("scaleStyles"), Some(&D::Boolean(scale))); + // Only scaling needs the key: without it the step keeps style sizes. + assert_eq!(parsed.actions[0].items[0].descriptor.as_ref().unwrap().get("scaleStyles"), scale.then_some(&D::Boolean(true))); let imported = atn_cmds::import(&saved).unwrap(); assert!(imported.unsupported.is_empty()); assert_eq!(imported.actions[0].steps, s.actions.list[0].steps); @@ -109,7 +110,7 @@ fn native_default_is_written_explicitly_and_keeps_its_behavior() { let (bytes, skipped) = atn_cmds::export("Styles", &[&action], &[], false).unwrap(); assert!(skipped.is_empty()); let parsed = atn::parse(&bytes).unwrap(); - assert_eq!(parsed.actions[0].items[0].descriptor.as_ref().unwrap().get("scaleStyles"), Some(&D::Boolean(scale)), "{params}"); + assert_eq!(parsed.actions[0].items[0].descriptor.as_ref().unwrap().get("scaleStyles"), scale.then_some(&D::Boolean(true)), "{params}"); let (mut direct, direct_id) = fixture(); direct.execute("image.imageSize", params).unwrap(); assert_size_and_style(&direct, direct_id, scale); @@ -150,3 +151,21 @@ fn malformed_or_empty_steps_are_kept_without_becoming_resizes() { } } } + +/// A recorded Image Size step without `scaleStyles` (Fit Image records none) saves back identically. +#[test] +fn step_without_scale_styles_saves_back_identically() { + for event in ["ImgS", "imageSize"] { + let fit = Descriptor::new("null") + .with("Wdth", D::UnitFloat { unit: *b"#Pxl", value: 100.0 }) + .with("Hght", D::UnitFloat { unit: *b"#Pxl", value: 78.0 }) + .with("Rslt", D::UnitFloat { unit: *b"#Rsl", value: 72.0 }) + .with("Intr", D::Enumerated { type_id: Id::new("Intp"), value: Id::new("Bcbc") }); + let source = recorded(event, Some(fit)); + let original = atn::parse(&source).unwrap(); + let mut s = Session::new(); + assert_eq!(load(&mut s, &source)["unsupported"], json!([])); + let saved = atn::parse(&save(&mut s)).unwrap(); + assert_eq!(saved.actions[0].items[0].descriptor, original.actions[0].items[0].descriptor); + } +} diff --git a/crates/engine/tests/vector_paste_options.rs b/crates/engine/tests/vector_paste_options.rs index 8f22954bbf..b9548f15db 100644 --- a/crates/engine/tests/vector_paste_options.rs +++ b/crates/engine/tests/vector_paste_options.rs @@ -279,10 +279,14 @@ fn atn_classes_roundtrip_and_play_real_modes() { for (class_id, mode) in [("Pxel", "pixels"), ("Path", "path"), ("shapeClass", "shape")] { let mut s = scene(8); assert_eq!(load(&mut s, &recorded(descriptor(class_id)))["unsupported"], json!([])); - assert_eq!(s.actions.list[0].steps, vec![("edit.paste".into(), json!({"as":mode}))]); + // `As Pxel` is what an ordinary Paste records: it keeps the ordinary route. + let params = if mode == "pixels" { json!({}) } else { json!({"as":mode}) }; + assert_eq!(s.actions.list[0].steps, vec![("edit.paste".into(), params)]); let saved = save(&mut s); let file = atn::parse(&saved).unwrap(); - assert_eq!(file.actions[0].items[0].descriptor.as_ref().unwrap().get("As "), descriptor(class_id).get("As ")); + if mode != "pixels" { + assert_eq!(file.actions[0].items[0].descriptor.as_ref().unwrap().get("As "), descriptor(class_id).get("As ")); + } let imported = atn_cmds::import(&saved).unwrap(); assert_eq!(imported.actions[0].steps, s.actions.list[0].steps); s.actions.list = imported.actions; @@ -333,3 +337,35 @@ fn atn_unknown_forms_are_kept_and_legacy_omission_stays_legacy() { assert!(atn_cmds::export("Vector", &[&action], &[], false).is_err()); } } + +fn recorded_pixels_paste(in_place: bool) -> Descriptor { + let d = Descriptor::new("null").with("AntA", D::Enumerated { type_id: Id::new("Annt"), value: Id::new("Anno") }); + let d = if in_place { d.with("inPlace", D::Boolean(true)) } else { d }; + d.with("As ", descriptor("Pxel").get("As ").unwrap().clone()) +} + +/// A recorded ordinary Paste (`AntA Anno`, `As Pxel`) keeps whole-layer recreation of a copied layer. +#[test] +fn recorded_pixels_paste_keeps_the_ordinary_route() { + let mut s = Session::new(); + s.execute("file.new", json!({"width": 20, "height": 16, "background": "transparent"})).unwrap(); + s.clipboard = Some(Clip::from_svg(SVG).unwrap()); + s.execute("edit.paste", json!({"as":"shape"})).unwrap(); + s.execute("edit.copy", json!({})).unwrap(); + assert_eq!(load(&mut s, &recorded(recorded_pixels_paste(false)))["unsupported"], json!([])); + assert_eq!(s.actions.list[0].steps, vec![("edit.paste".into(), json!({}))]); + let layers = s.active().unwrap().doc.layers.len(); + let result = s.execute("actions.play", json!({"action":"Paste"})).unwrap(); + assert_eq!(result["ran"], 1); + assert!(result.get("failed").is_none(), "{result}"); + assert!(s.active().unwrap().doc.layers.len() > layers); + assert!(matches!(output(&s).content, LayerContent::Shape(_)), "a copied shape layer pastes as a shape layer"); +} + +/// A recorded Paste in Place (`inPlace true`, `AntA Anno`, `As Pxel`) plays as Paste in Place. +#[test] +fn recorded_pixels_paste_in_place_maps() { + let mut s = Session::new(); + assert_eq!(load(&mut s, &recorded(recorded_pixels_paste(true)))["unsupported"], json!([])); + assert_eq!(s.actions.list[0].steps, vec![("edit.pasteSpecial.pasteInPlace".into(), json!({}))]); +} diff --git a/docs/atn.md b/docs/atn.md index d48214cc2f..6a93e21a08 100644 --- a/docs/atn.md +++ b/docs/atn.md @@ -145,14 +145,15 @@ the reference application. - Image Size preserves `scaleStyles`. Native calls default to true; an absent ATN flag means false. Crop and resolution-only resizing retain their existing behavior. - Convert to Profile preserves `Dthr`, `Fltt` and `rasterizePlaced`, defaulting to false. - Supported RGB destinations use `sdwM: 2`; other model codes and malformed flags remain kept - steps. Absolute intent writes `AClr`, with `AbsC` still accepted on import. + `sdwM` is written as the reference application records it (-1); other values and malformed + flags remain kept steps. Absolute intent writes `AClr`, with `AbsC` still accepted on import. - Content-Aware Fill preserves colour, quarter-turn rotation, scale and mirror adaptation. Existing native defaults remain unchanged. - Paste Layer Style preserves `allowPasteFXOnLayerSet`. False skips selected groups without applying their styles to children; a selection with no eligible targets fails without editing. -- Paste preserves `As ` as pixels, path or shape using the original bounded SVG source. - Unsupported geometry fails instead of silently rasterizing. Omission retains ordinary Paste. +- Paste preserves `As ` path or shape using the original bounded SVG source. Unsupported + geometry fails instead of silently rasterizing. `As Pxel` plays as an ordinary Paste (or Paste + in Place), as does omission. Generated fixtures verify these native options and their load/save/playback behavior. Matching Photoshop conversion-order, SVG rasterization and placement comparisons were not available.