feat(engine): replay target-only ATN menu events

This commit is contained in:
yoriswind committed 2026-11-01 13:36:08 -08:00
1 parent b4c7656c49
commit 71b98c8134
4 files changed
+380 -12

No files matched your search

+67 -11
View File
@@ -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",
+16
View File
@@ -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"})),
+269 -1
View File
@@ -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
View File
@@ -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 |