mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-18 16:04:57 +00:00
feat(engine): replay target-only ATN menu events
This commit is contained in:
1 parent
b4c7656c49
commit
71b98c8134
4 files changed
+380
-12
No files matched your search
@@ -17,7 +17,7 @@ use super::steps_layer::{
|
||||
};
|
||||
use super::steps_make::{locking_from, locking_to, make_from, make_to, set_from, set_to};
|
||||
use super::tables::{NOISE, OFFSET_FILL, SMART_BLUR_MODE, SMART_BLUR_QUALITY, TRIM};
|
||||
use super::{AtnEvent, D, Descriptor, STOP_MESSAGE, Value, json};
|
||||
use super::{AtnEvent, D, Descriptor, Map, STOP_MESSAGE, Value, json};
|
||||
|
||||
/// An event: code (empty when Photoshop only has a string name), string name, the panel
|
||||
/// label, the command ids it exports (the first is the one simple events import to), and the
|
||||
@@ -175,20 +175,57 @@ fn clipping_to(_: &str, p: &Value) -> Option<Descriptor> {
|
||||
Some(desc("null").with("null", layer_ref(p)?))
|
||||
}
|
||||
|
||||
// Target matching follows #10628's Link Layers adapter. Recorded Link and Unlink
|
||||
// need explicit state: replaying the UI toggle can perform the opposite operation.
|
||||
fn link_from(d: &Descriptor, linked: bool) -> Mapped {
|
||||
// The reference permits normalizing the top-level descriptor class to null.
|
||||
if d.items == desc("null").with("null", target_ref("Lyr ")).items {
|
||||
step("layer.linkLayers", json!({"linked": linked}))
|
||||
} else {
|
||||
Mapped::Unsupported { harmless: false }
|
||||
// Adapter-only transport bit: the reference permits either no target key or the
|
||||
// current-layer target. Save must retain that distinction; native behavior is identical.
|
||||
const NO_TARGET: &str = "_atnNoTarget";
|
||||
|
||||
fn target_params(d: &Descriptor) -> Option<Map<String, Value>> {
|
||||
let mut p = Map::new();
|
||||
if d.items.is_empty() {
|
||||
p.insert(NO_TARGET.into(), Value::Bool(true));
|
||||
} else if d.items != desc("null").with("null", target_ref("Lyr ")).items {
|
||||
return None;
|
||||
}
|
||||
Some(p)
|
||||
}
|
||||
|
||||
fn target_descriptor(p: &Value) -> Option<Descriptor> {
|
||||
match p.get(NO_TARGET) {
|
||||
None => Some(desc("null").with("null", target_ref("Lyr "))),
|
||||
Some(Value::Bool(true)) => Some(desc("null")),
|
||||
Some(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
// Native-parameter allowlist adapted from #10628; refuse unrepresented options on export.
|
||||
fn params(p: &Value, allowed: &[&str]) -> bool {
|
||||
p.as_object().is_some_and(|p| p.keys().all(|key| allowed.contains(&key.as_str())))
|
||||
}
|
||||
|
||||
fn target_only_from(d: &Descriptor, id: &str) -> Mapped {
|
||||
target_params(d).map_or(Mapped::Unsupported { harmless: false }, |p| step(id, Value::Object(p)))
|
||||
}
|
||||
|
||||
fn target_only_to(_: &str, p: &Value) -> Option<Descriptor> {
|
||||
if !params(p, &[NO_TARGET]) {
|
||||
return None;
|
||||
}
|
||||
target_descriptor(p)
|
||||
}
|
||||
|
||||
// Recorded Link and Unlink need explicit state: replaying the UI toggle can
|
||||
// perform the opposite operation. Target matching follows #10628's adapter.
|
||||
fn link_from(d: &Descriptor, linked: bool) -> Mapped {
|
||||
let Some(mut p) = target_params(d) else { return Mapped::Unsupported { harmless: false } };
|
||||
p.insert("linked".into(), Value::Bool(linked));
|
||||
step("layer.linkLayers", Value::Object(p))
|
||||
}
|
||||
|
||||
fn link_to(p: &Value, linked: bool) -> Option<Descriptor> {
|
||||
let p = p.as_object()?;
|
||||
(p.len() == 1 && p.get("linked") == Some(&Value::Bool(linked))).then(|| desc("null").with("null", target_ref("Lyr ")))
|
||||
if !params(p, &["linked", NO_TARGET]) || p.get("linked") != Some(&Value::Bool(linked)) {
|
||||
return None;
|
||||
}
|
||||
target_descriptor(p)
|
||||
}
|
||||
|
||||
fn smart_path_from(d: &Descriptor, id: &str) -> Mapped {
|
||||
@@ -230,6 +267,12 @@ macro_rules! clipping_event {
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! target_event {
|
||||
($name:literal, $label:literal, $id:literal) => {
|
||||
Event { code: "", name: $name, label: $label, ids: &[$id], from: |d| target_only_from(d, $id), to: target_only_to }
|
||||
};
|
||||
}
|
||||
|
||||
/// Every Photoshop event PhotoCraft maps. The order matters only for the panel label.
|
||||
pub(super) const EVENTS: &[Event] = &[
|
||||
// Filters.
|
||||
@@ -401,6 +444,15 @@ pub(super) const EVENTS: &[Event] = &[
|
||||
},
|
||||
Event { code: "Dplc", name: "duplicate", label: "Duplicate", ids: &["layer.duplicate", "image.duplicate"], from: duplicate_from, to: duplicate_to },
|
||||
// Layers.
|
||||
target_event!("reverse", "Reverse", "layer.arrange.reverse"),
|
||||
target_event!("selectLinkedLayers", "Select Linked Layers", "layer.selectLinkedLayers"),
|
||||
target_event!("disableLayerStyle", "Clear Layer Style", "layer.layerStyle.clear"),
|
||||
target_event!("rasterizeAll", "Rasterize All Layers", "layer.rasterize.allLayers"),
|
||||
target_event!("addBlankVideoLayer", "New Blank Video Layer", "layer.videoLayers.newBlankVideoLayer"),
|
||||
target_event!("isolateLayers", "Isolate Layers", "select.isolateLayers"),
|
||||
target_event!("textLoadDefaultTypeStyles", "Load Default Type Styles", "type.loadDefaultTypeStyles"),
|
||||
target_event!("textSaveDefaultTypeStyles", "Save Default Type Styles", "type.saveDefaultTypeStyles"),
|
||||
target_event!("recordMeasurements", "Record Measurements", "image.analysis.recordMeasurements"),
|
||||
Event { code: "", name: "linkSelectedLayers", label: "Link Layers", ids: &["layer.linkLayers"], from: |d| link_from(d, true), to: |_, p| link_to(p, true) },
|
||||
Event {
|
||||
code: "",
|
||||
@@ -529,6 +581,10 @@ pub(super) const EVENTS: &[Event] = &[
|
||||
ev!("", "newPlacedLayer", "Convert to Smart Object", "layer.smartObjects.convertToSmartObject", &[]),
|
||||
ev!("", "placedLayerEditContents", "Edit Contents", "layer.smartObjects.editContents", &[]),
|
||||
ev!("", "updatePlacedLayer", "Update Smart Objects", "layer.smartObjects.updateModifiedContent", &[]),
|
||||
target_event!("placedLayerMakeCopy", "New Smart Object via Copy", "layer.smartObjects.newSmartObjectViaCopy"),
|
||||
target_event!("placedLayerConvertToLayers", "Convert to Layers", "layer.smartObjects.convertToLayers"),
|
||||
target_event!("placedLayerConvertToEmbedded", "Convert to Embedded", "layer.smartObjects.convertToEmbedded"),
|
||||
target_event!("placedLayerUpdateAllModified", "Update All Modified Content", "layer.smartObjects.updateAllModifiedContent"),
|
||||
Event {
|
||||
code: "",
|
||||
name: "placedLayerExportContents",
|
||||
|
||||
@@ -550,6 +550,18 @@ fn every_mapped_command_exports_and_imports_back() {
|
||||
("layer.groupLayers", json!({})),
|
||||
("layer.linkLayers", json!({"linked": true})),
|
||||
("layer.linkLayers", json!({"linked": false})),
|
||||
("layer.linkLayers", json!({"linked": true, "_atnNoTarget": true})),
|
||||
("layer.linkLayers", json!({"linked": false, "_atnNoTarget": true})),
|
||||
("layer.arrange.reverse", json!({})),
|
||||
("layer.arrange.reverse", json!({"_atnNoTarget": true})),
|
||||
("layer.selectLinkedLayers", json!({})),
|
||||
("layer.layerStyle.clear", json!({})),
|
||||
("layer.rasterize.allLayers", json!({})),
|
||||
("layer.videoLayers.newBlankVideoLayer", json!({})),
|
||||
("select.isolateLayers", json!({})),
|
||||
("type.loadDefaultTypeStyles", json!({})),
|
||||
("type.saveDefaultTypeStyles", json!({})),
|
||||
("image.analysis.recordMeasurements", json!({})),
|
||||
("layer.new.layerViaCopy", json!({})),
|
||||
("layer.newFillLayer.solidColor", json!({"color": "#336699"})),
|
||||
("layer.newAdjustmentLayer.hueSaturation", json!({})),
|
||||
@@ -621,6 +633,10 @@ fn every_mapped_command_exports_and_imports_back() {
|
||||
("layer.smartObjects.convertToSmartObject", json!({})),
|
||||
("layer.smartObjects.editContents", json!({})),
|
||||
("layer.smartObjects.updateModifiedContent", json!({})),
|
||||
("layer.smartObjects.newSmartObjectViaCopy", json!({})),
|
||||
("layer.smartObjects.convertToLayers", json!({})),
|
||||
("layer.smartObjects.convertToEmbedded", json!({})),
|
||||
("layer.smartObjects.updateAllModifiedContent", json!({})),
|
||||
("layer.smartObjects.exportContents", json!({"path": "/tmp/contents.png"})),
|
||||
("layer.smartObjects.convertToLinked", json!({"path": "/tmp/linked.png"})),
|
||||
("layer.smartObjects.relinkToFile", json!({"path": "/tmp/relinked.png"})),
|
||||
|
||||
@@ -170,7 +170,7 @@ fn atn_link_events_keep_descriptors_and_replay_the_requested_operation() {
|
||||
fn unsupported_link_descriptors_are_kept_and_ambiguous_exports_are_refused() {
|
||||
for event in ["linkSelectedLayers", "unlinkSelectedLayers"] {
|
||||
for descriptor in [
|
||||
Descriptor::new("null"),
|
||||
Descriptor::new("null").with("null", D::Reference(vec![])),
|
||||
Descriptor::new("null").with("null", D::Integer(1)),
|
||||
Descriptor::new("null").with("null", target_class("Dcmn")),
|
||||
Descriptor::new("null").with("null", target()).with("extra", D::Boolean(true)),
|
||||
@@ -191,6 +191,274 @@ fn unsupported_link_descriptors_are_kept_and_ambiguous_exports_are_refused() {
|
||||
}
|
||||
}
|
||||
|
||||
const TARGET_EVENTS: &[(&str, &str)] = &[
|
||||
("reverse", "layer.arrange.reverse"),
|
||||
("selectLinkedLayers", "layer.selectLinkedLayers"),
|
||||
("disableLayerStyle", "layer.layerStyle.clear"),
|
||||
("placedLayerMakeCopy", "layer.smartObjects.newSmartObjectViaCopy"),
|
||||
("placedLayerConvertToLayers", "layer.smartObjects.convertToLayers"),
|
||||
("placedLayerConvertToEmbedded", "layer.smartObjects.convertToEmbedded"),
|
||||
("placedLayerUpdateAllModified", "layer.smartObjects.updateAllModifiedContent"),
|
||||
("rasterizeAll", "layer.rasterize.allLayers"),
|
||||
("addBlankVideoLayer", "layer.videoLayers.newBlankVideoLayer"),
|
||||
("isolateLayers", "select.isolateLayers"),
|
||||
("textLoadDefaultTypeStyles", "type.loadDefaultTypeStyles"),
|
||||
("textSaveDefaultTypeStyles", "type.saveDefaultTypeStyles"),
|
||||
("recordMeasurements", "image.analysis.recordMeasurements"),
|
||||
];
|
||||
|
||||
fn targeted(event: &str, explicit: bool) -> Descriptor {
|
||||
let d = Descriptor::new(event);
|
||||
if explicit { d.with("null", target()) } else { d }
|
||||
}
|
||||
|
||||
fn load_targeted(s: &mut Session, event: &str, id: &str, explicit: bool) {
|
||||
assert_eq!(load(s, &file(event, targeted(event, explicit)))["unsupported"], json!([]), "{event}");
|
||||
let p = if explicit { json!({}) } else { json!({"_atnNoTarget": true}) };
|
||||
assert_eq!(s.actions.list[0].steps, [(id.into(), p)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn target_events_keep_empty_and_explicit_target_descriptors_distinct() {
|
||||
for &(event, id) in TARGET_EVENTS {
|
||||
for explicit in [false, true] {
|
||||
let mut s = Session::new();
|
||||
load_targeted(&mut s, event, id, explicit);
|
||||
let saved = s.execute("actions.save", json!({"set": "Links"})).unwrap();
|
||||
let bytes = photocraft_engine::paint::tile::b64_decode(saved["data"].as_str().unwrap()).unwrap();
|
||||
let item = &atn::parse(&bytes).unwrap().actions[0].items[0];
|
||||
assert_eq!(item.event, AtnEvent::name(event));
|
||||
assert_eq!(item.descriptor, Some(targeted("null", explicit)), "{event}");
|
||||
assert_eq!(load(&mut s, &bytes)["unsupported"], json!([]));
|
||||
}
|
||||
}
|
||||
// Reference lines197–199 permits writing an empty descriptor for an absent one.
|
||||
let mut f = atn::parse(&file("reverse", Descriptor::new("null"))).unwrap();
|
||||
f.actions[0].items[0].descriptor = None;
|
||||
let mut s = Session::new();
|
||||
assert_eq!(load(&mut s, &atn::write(&f).unwrap())["unsupported"], json!([]));
|
||||
let saved = s.execute("actions.save", json!({"set": "Links"})).unwrap();
|
||||
let bytes = photocraft_engine::paint::tile::b64_decode(saved["data"].as_str().unwrap()).unwrap();
|
||||
assert_eq!(atn::parse(&bytes).unwrap().actions[0].items[0].descriptor, Some(Descriptor::new("null")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bare_link_events_keep_their_operation_and_empty_keys() {
|
||||
for (event, linked) in [("linkSelectedLayers", true), ("unlinkSelectedLayers", false)] {
|
||||
let initial = if linked { None } else { Some(77) };
|
||||
let mut s = fixture(&[initial, initial], &[0, 1]);
|
||||
assert_eq!(load(&mut s, &file(event, Descriptor::new(event)))["unsupported"], json!([]));
|
||||
assert_eq!(s.actions.list[0].steps[0].1, json!({"linked": linked, "_atnNoTarget": true}));
|
||||
let saved = s.execute("actions.save", json!({"set": "Links"})).unwrap();
|
||||
let bytes = photocraft_engine::paint::tile::b64_decode(saved["data"].as_str().unwrap()).unwrap();
|
||||
assert_eq!(atn::parse(&bytes).unwrap().actions[0].items[0].descriptor, Some(Descriptor::new("null")));
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
play(&mut s);
|
||||
assert_ne!(s.active().unwrap().doc, before);
|
||||
let after = s.active().unwrap().doc.clone();
|
||||
assert!(groups(&s).iter().all(|group| group.is_some() == linked));
|
||||
assert_eq!(groups(&s)[0], groups(&s)[1]);
|
||||
play(&mut s);
|
||||
assert_eq!(s.active().unwrap().doc, after);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn target_events_keep_unknown_targets_and_refuse_native_options() {
|
||||
for &(event, id) in TARGET_EVENTS {
|
||||
for descriptor in [
|
||||
Descriptor::new(event).with("null", D::Integer(1)),
|
||||
Descriptor::new(event).with("null", target_class("Dcmn")),
|
||||
targeted(event, true).with("null", target()),
|
||||
targeted(event, true).with("extra", D::Boolean(true)),
|
||||
] {
|
||||
let mut s = Session::new();
|
||||
assert_eq!(load(&mut s, &file(event, descriptor.clone()))["unsupported"].as_array().unwrap().len(), 1);
|
||||
let saved = s.execute("actions.save", json!({"set": "Links"})).unwrap();
|
||||
let bytes = photocraft_engine::paint::tile::b64_decode(saved["data"].as_str().unwrap()).unwrap();
|
||||
assert_eq!(atn::parse(&bytes).unwrap().actions[0].items[0].descriptor, Some(descriptor));
|
||||
}
|
||||
for p in [json!({"layer": 1}), json!({"on": true}), json!({"_atnNoTarget": false}), json!({"_atnNoTarget": "true"})] {
|
||||
let action = Action::new("A", vec![(id.into(), p)]);
|
||||
assert!(atn_cmds::export("Links", &[&action], &[], false).is_err(), "{event}");
|
||||
}
|
||||
}
|
||||
for linked in [false, true] {
|
||||
let action = Action::new("A", vec![("layer.linkLayers".into(), json!({"linked": linked, "_atnNoTarget": false}))]);
|
||||
assert!(atn_cmds::export("Links", &[&action], &[], false).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reverse_linked_selection_and_clear_style_events_do_their_edits() {
|
||||
for explicit in [false, true] {
|
||||
let mut s = fixture(&[None, None, None], &[0, 1, 2]);
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
let ids: Vec<_> = before.layers.iter().map(|layer| layer.id).rev().collect();
|
||||
load_targeted(&mut s, "reverse", "layer.arrange.reverse", explicit);
|
||||
play(&mut s);
|
||||
assert_eq!(s.active().unwrap().doc.layers.iter().map(|layer| layer.id).collect::<Vec<_>>(), ids);
|
||||
assert!(s.undo());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
|
||||
let mut s = fixture(&[Some(77), Some(77), None], &[0]);
|
||||
let ids: Vec<_> = s.active().unwrap().doc.layers[..2].iter().map(|layer| layer.id).collect();
|
||||
load_targeted(&mut s, "selectLinkedLayers", "layer.selectLinkedLayers", explicit);
|
||||
play(&mut s);
|
||||
assert_eq!(s.active().unwrap().selected_layers(), ids);
|
||||
|
||||
let mut s = fixture(&[None], &[0]);
|
||||
s.execute("layer.layerStyle.colorOverlay", json!({"color": "#ff0000"})).unwrap();
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
assert_eq!(before.layers[0].effects.items.len(), 1);
|
||||
load_targeted(&mut s, "disableLayerStyle", "layer.layerStyle.clear", explicit);
|
||||
play(&mut s);
|
||||
assert!(s.active().unwrap().doc.layers[0].effects.items.is_empty());
|
||||
assert!(s.undo());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
}
|
||||
}
|
||||
|
||||
fn smart_target_scene(event: &str, bytes: &[u8], replacement: &[u8], path: &str) -> Session {
|
||||
let mut s = smart_fixture(bytes);
|
||||
if matches!(event, "placedLayerConvertToEmbedded" | "placedLayerUpdateAllModified") {
|
||||
s.execute("layer.smartObjects.convertToLinked", json!({"path": path})).unwrap();
|
||||
}
|
||||
if event == "placedLayerUpdateAllModified" {
|
||||
std::fs::write(path, replacement).unwrap();
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
fn assert_smart_target_edit(event: &str, s: &Session, original_id: photocraft_doc::SmartContentsId, pixels: &[[f32; 4]], bytes: &[u8]) {
|
||||
match event {
|
||||
"placedLayerMakeCopy" => {
|
||||
assert_ne!(active_smart(s).contents_id, original_id);
|
||||
assert_eq!(s.active().unwrap().doc.walk().iter().filter(|(_, _, layer)| matches!(layer.content, LayerContent::Smart(_))).count(), 2);
|
||||
}
|
||||
"placedLayerConvertToLayers" => assert!(s.active().unwrap().doc.walk().iter().all(|(_, _, layer)| !matches!(layer.content, LayerContent::Smart(_)))),
|
||||
"placedLayerConvertToEmbedded" => assert!(matches!(&active_smart(s).source, SmartSource::Embedded { bytes: actual, .. } if actual.as_slice() == bytes)),
|
||||
"placedLayerUpdateAllModified" => assert!(photocraft_compose::flatten(&s.active().unwrap().doc).px.iter().all(|px| *px == [1.0, 0.0, 0.0, 1.0])),
|
||||
_ => unreachable!(),
|
||||
}
|
||||
if event != "placedLayerUpdateAllModified" {
|
||||
assert_eq!(photocraft_compose::flatten(&s.active().unwrap().doc).px, pixels);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn smart_target_events_copy_unpack_embed_and_refresh_real_contents() {
|
||||
let original = png("#0000ff");
|
||||
let replacement = png("#ff0000");
|
||||
for &(event, id) in &TARGET_EVENTS[3..7] {
|
||||
for explicit in [false, true] {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("linked.png");
|
||||
let mut s = smart_target_scene(event, &original, &replacement, path.to_str().unwrap());
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
let pixels = photocraft_compose::flatten(&before).px;
|
||||
let contents_id = active_smart(&s).contents_id;
|
||||
load_targeted(&mut s, event, id, explicit);
|
||||
play(&mut s);
|
||||
assert_smart_target_edit(event, &s, contents_id, &pixels, &original);
|
||||
assert!(s.undo());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rasterize_all_event_visits_nested_and_top_level_smart_layers() {
|
||||
for explicit in [false, true] {
|
||||
let mut s = smart_fixture(&png("#0000ff"));
|
||||
let first = s.active().unwrap().active_layer.unwrap();
|
||||
s.execute("layer.smartObjects.newSmartObjectViaCopy", json!({})).unwrap();
|
||||
let doc = Arc::make_mut(&mut s.active_mut().unwrap().doc);
|
||||
let nested = doc.remove(first).unwrap();
|
||||
doc.layers.push(Layer::group("Nested", vec![nested]));
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
let pixels = photocraft_compose::flatten(&before).px;
|
||||
load_targeted(&mut s, "rasterizeAll", "layer.rasterize.allLayers", explicit);
|
||||
play(&mut s);
|
||||
assert!(s.active().unwrap().doc.walk().iter().all(|(_, _, layer)| !matches!(layer.content, LayerContent::Smart(_))));
|
||||
assert_eq!(photocraft_compose::flatten(&s.active().unwrap().doc).px, pixels);
|
||||
assert!(s.undo());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn video_and_isolate_events_use_current_document_state() {
|
||||
for explicit in [false, true] {
|
||||
let mut s = fixture(&[None], &[0]);
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
load_targeted(&mut s, "addBlankVideoLayer", "layer.videoLayers.newBlankVideoLayer", explicit);
|
||||
play(&mut s);
|
||||
let st = s.active().unwrap();
|
||||
let video = st.doc.layer(st.active_layer.unwrap()).unwrap().video.as_ref().unwrap();
|
||||
assert_eq!(video.frames.len(), 1);
|
||||
assert_eq!(video.fps, 30.0);
|
||||
assert!(video.frames[0].content_bounds().is_empty());
|
||||
assert!(s.undo());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
|
||||
let mut s = fixture(&[None, None, None], &[0, 2]);
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
let ids = s.active().unwrap().selected_layers();
|
||||
let history = s.active().unwrap().history.past_len();
|
||||
load_targeted(&mut s, "isolateLayers", "select.isolateLayers", explicit);
|
||||
play(&mut s);
|
||||
assert_eq!(s.active().unwrap().isolated_layers, ids);
|
||||
play(&mut s);
|
||||
assert!(s.active().unwrap().isolated_layers.is_empty());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
assert_eq!(s.active().unwrap().history.past_len(), history);
|
||||
}
|
||||
}
|
||||
|
||||
fn active_text(s: &Session) -> &photocraft_doc::TextLayer {
|
||||
let st = s.active().unwrap();
|
||||
let LayerContent::Text(text) = &st.doc.layer(st.active_layer.unwrap()).unwrap().content else { panic!("expected Type") };
|
||||
text
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn type_default_events_save_then_restore_changed_styles() {
|
||||
for explicit in [false, true] {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", json!({"width": 32, "height": 32})).unwrap();
|
||||
s.execute("type.create", json!({"text": "Hi", "size": 14})).unwrap();
|
||||
assert!(s.type_defaults.is_none());
|
||||
load_targeted(&mut s, "textSaveDefaultTypeStyles", "type.saveDefaultTypeStyles", explicit);
|
||||
play(&mut s);
|
||||
assert_eq!(s.type_defaults.as_ref().unwrap().0.size_pt, 14.0);
|
||||
s.execute("type.setStyle", json!({"size": 28})).unwrap();
|
||||
assert_eq!(active_text(&s).char_runs()[0].style.size_pt, 28.0);
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
load_targeted(&mut s, "textLoadDefaultTypeStyles", "type.loadDefaultTypeStyles", explicit);
|
||||
play(&mut s);
|
||||
assert_eq!(active_text(&s).char_runs()[0].style.size_pt, 14.0);
|
||||
assert!(s.undo());
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measurement_event_records_actual_selected_area() {
|
||||
for explicit in [false, true] {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", json!({"width": 4, "height": 4, "background": "white"})).unwrap();
|
||||
s.execute("select.rect", json!({"x": 0, "y": 0, "width": 2, "height": 2})).unwrap();
|
||||
let before = s.active().unwrap().doc.clone();
|
||||
load_targeted(&mut s, "recordMeasurements", "image.analysis.recordMeasurements", explicit);
|
||||
play(&mut s);
|
||||
assert_eq!(s.analysis.log.len(), 1);
|
||||
assert_eq!(s.analysis.log[0].values["source"], "Selection");
|
||||
assert_eq!(s.analysis.log[0].values["area"].as_f64(), Some(4.0));
|
||||
assert_eq!(s.active().unwrap().doc, before);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn link_descriptor_headers_normalize_without_changing_meaningful_keys() {
|
||||
for event in ["linkSelectedLayers", "unlinkSelectedLayers"] {
|
||||
|
||||
+28
@@ -16,6 +16,34 @@ saved as either Photoshop event. Explicit layer lists and extra parameters also
|
||||
cannot be saved as these events. Unsupported targets or extra descriptor keys
|
||||
are kept as Photoshop steps for lossless saving, rather than partially replayed.
|
||||
|
||||
## Other events without settings
|
||||
|
||||
| Photoshop event | PhotoCraft command |
|
||||
| --- | --- |
|
||||
| `reverse` | `layer.arrange.reverse` |
|
||||
| `selectLinkedLayers` | `layer.selectLinkedLayers` |
|
||||
| `disableLayerStyle` | `layer.layerStyle.clear` |
|
||||
| `placedLayerMakeCopy` | `layer.smartObjects.newSmartObjectViaCopy` |
|
||||
| `placedLayerConvertToLayers` | `layer.smartObjects.convertToLayers` |
|
||||
| `placedLayerConvertToEmbedded` | `layer.smartObjects.convertToEmbedded` |
|
||||
| `placedLayerUpdateAllModified` | `layer.smartObjects.updateAllModifiedContent` |
|
||||
| `rasterizeAll` | `layer.rasterize.allLayers` |
|
||||
| `addBlankVideoLayer` | `layer.videoLayers.newBlankVideoLayer` |
|
||||
| `isolateLayers` | `select.isolateLayers` |
|
||||
| `textLoadDefaultTypeStyles` | `type.loadDefaultTypeStyles` |
|
||||
| `textSaveDefaultTypeStyles` | `type.saveDefaultTypeStyles` |
|
||||
| `recordMeasurements` | `image.analysis.recordMeasurements` |
|
||||
|
||||
These events and Link/Unlink accept either an empty descriptor or an explicit
|
||||
current-layer target. Save retains which form was imported. Other targets or
|
||||
extra settings stay complete Photoshop steps; native options with no recorded
|
||||
representation are refused on export.
|
||||
|
||||
Playback uses each native command's normal preconditions and current state.
|
||||
Isolate Layers toggles the panel view. Type defaults are saved in the current
|
||||
session. Record Measurements uses the current selection/ruler/count and data
|
||||
point configuration.
|
||||
|
||||
## Smart Object file operations
|
||||
|
||||
| Photoshop event | Meaningful descriptor keys | PhotoCraft command |
|
||||
|
||||
Reference in new issue
Block a user