856f865cf98d
actions_panel_menu.rs
//! The remaining panel commands compose with the same definitions, journal and ATN boundary.
use photocraft_engine::{
Session,
actions_cmds::{Action, ActionColor, ActionList, ActionStep},
actions_edit_cmds, atn_cmds,
jobs::Started,
};
use serde_json::json;
/// Tiny real document with one empty action keeps recording and background jobs observable.
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", json!({"width":40,"height":30})).unwrap();
s.actions.list.push(Action::new("A", vec![])).unwrap();
s
}
/// A painted stripe gives both the remove tool and blur a real input before recording starts.
fn stroke(s: &mut Session, color: &str) {
s.execute("paint.stroke", json!({"points":[[8,15],[32,15]],"size":3,"color":color})).unwrap();
}
/// Mode changes flush under the previous mode without altering painting or ordinary recording.
#[test]
fn tool_recording_is_opt_in_and_toggles_do_not_reclassify_pending_steps() {
let mut s = session();
s.execute("actions.record", json!({"action":"A"})).unwrap();
stroke(&mut s, "#ff0000");
s.execute("select.all", json!({})).unwrap();
let original = s.actions.clone();
assert!(s.execute("actions.allowToolRecording", json!({"enabled":"yes"})).is_err());
assert_eq!(s.actions, original, "invalid mode must not flush pending work");
s.execute("actions.allowToolRecording", json!({"enabled":true})).unwrap();
stroke(&mut s, "#00ff00");
s.execute("actions.allowToolRecording", json!({"enabled":false})).unwrap();
stroke(&mut s, "#0000ff");
s.execute("select.deselect", json!({})).unwrap();
s.execute("actions.stop", json!({})).unwrap();
assert_eq!(s.actions.list.actions()[0].steps.iter().map(|s| s.command.as_str()).collect::<Vec<_>>(), ["select.all", "paint.stroke", "select.deselect"]);
assert_eq!(s.actions.list.actions()[0].steps[1].params["color"], "#00ff00");
assert_eq!(s.journal.iter().filter(|s| s.0 == "paint.stroke").count(), 3, "all actual painting remains journaled");
assert_eq!(s.execute("actions.list", json!({})).unwrap()["toolRecording"], false);
}
/// A stroke started while off never joins a later enabled recording; ordinary jobs keep their owner.
#[test]
fn background_stroke_ownership_does_not_suppress_ordinary_filter_jobs() {
for command in ["paint.remove", "filter.blur.gaussianBlur"] {
let mut s = session();
stroke(&mut s, "#bb3300");
s.execute("actions.record", json!({"action":"A"})).unwrap();
let params = if command == "paint.remove" { json!({"points":[[20,15],[21,15]],"size":3}) } else { json!({"radius":1}) };
let Started::Job(job) = s.start(command, params).unwrap() else { panic!("expected the real background job: {command}") };
let changed = s.execute("actions.allowToolRecording", json!({"enabled":true}));
if command == "paint.remove" {
assert!(changed.is_err(), "the in-flight stroke retains the mode it started under");
assert!(!s.actions.record_tools);
} else {
changed.unwrap();
}
s.wait_job(job).unwrap();
if command == "paint.remove" {
s.execute("actions.allowToolRecording", json!({"enabled":true})).unwrap();
}
s.execute("actions.stop", json!({})).unwrap();
let ids = s.actions.list.actions()[0].steps.iter().map(|s| s.command.as_str()).collect::<Vec<_>>();
if command == "paint.remove" {
assert!(ids.is_empty());
} else {
assert_eq!(ids, [command]);
}
}
}
/// A Remove job started outside the current take neither blocks its toggle nor joins its steps.
#[test]
fn background_strokes_from_outside_the_current_take_do_not_block_the_toggle() {
for previous_take in [false, true] {
let mut s = session();
stroke(&mut s, "#bb3300");
if previous_take {
s.execute("actions.record", json!({"action":"A"})).unwrap();
s.execute("actions.allowToolRecording", json!({"enabled":true})).unwrap();
}
let Started::Job(job) = s.start("paint.remove", json!({"points":[[20,15],[21,15]],"size":3})).unwrap() else {
panic!("expected the real Remove job");
};
if previous_take {
s.execute("actions.stop", json!({})).unwrap();
s.execute("actions.allowToolRecording", json!({"enabled":false})).unwrap();
}
s.execute("actions.record", json!({"action":"A"})).unwrap();
assert_eq!(s.execute("actions.allowToolRecording", json!({"enabled":true})).unwrap()["enabled"], true);
s.wait_job(job).unwrap();
s.execute("actions.stop", json!({})).unwrap();
assert!(s.actions.list.actions()[0].steps.is_empty());
assert_eq!(s.journal.iter().filter(|step| step.0 == "paint.remove").count(), 1);
}
}
/// Interleaved membership and numeric calls expose incorrect folder placement or target rewriting.
#[test]
fn set_duplication_preserves_metadata_call_targets_and_empty_folder_order() {
let mut s = session();
s.actions.list = ActionList::new();
for (name, set) in [("A", "S"), ("Other", "T"), ("B", "S")] {
let mut a = Action::new(name, vec![ActionStep::new("actions.play", json!({"action":2}))]);
a.set = Some(set.into());
a.color = ActionColor::from_name("red");
a.disabled.insert(0);
a.dialogs.insert(0);
s.actions.list.push(a).unwrap();
}
s.prefs.edit(|p| {
p.shortcuts.insert("actions.play:A".into(), "F5".into());
});
let result = s.execute("actions.duplicate", json!({"set":"S"})).unwrap();
assert_eq!(result["set"], "S copy");
assert_eq!(actions_edit_cmds::set_names(&s), ["S", "T", "S copy"]);
// The copies go after the set's last action, so a call to an action before that point keeps its target.
assert_eq!(s.actions.list.actions().iter().map(|a| a.name.as_str()).collect::<Vec<_>>(), ["A", "Other", "B", "A copy", "B copy"]);
for a in s.actions.list.actions() {
assert_eq!(a.steps[0].params["action"], 2);
assert_eq!(a.color, ActionColor::from_name("red"));
assert!(a.disabled.contains(&0));
assert!(a.dialogs.contains(&0));
}
assert!(!s.prefs().shortcuts.contains_key("actions.play:A copy"));
let mut empty = Session::new();
for name in ["E", "F"] {
empty.execute("actions.newSet", json!({"name":name})).unwrap();
}
empty.execute("actions.duplicate", json!({"set":"E"})).unwrap();
assert_eq!(actions_edit_cmds::set_names(&empty), ["E", "E copy", "F"]);
let original = empty.actions.clone();
for params in [json!({"set":"Missing"}), json!({"set":"E","action":0}), json!({"set":false})] {
assert!(empty.execute("actions.duplicate", params).is_err());
assert_eq!(empty.actions, original);
}
}
/// Menu insertion keeps descriptor absence and kind; empty descriptors and ambiguous commands differ.
#[test]
fn inserted_menu_events_roundtrip_absent_settings_and_stateless_items_execute() {
assert!(!atn_cmds::menu_item_needs_settings("filter.noise.despeckle"));
assert!(atn_cmds::menu_item_needs_settings("filter.blur.gaussianBlur"));
for id in ["image.imageSize", "filter.blur.gaussianBlur", "filter.noise.despeckle"] {
for kind in ["name", "code"] {
let mut s = session();
s.execute("actions.insertMenuItem", json!({"action":"A","id":id,"eventKind":kind})).unwrap();
let bytes = atn_cmds::export("S", &[&s.actions.list.actions()[0]], &[], false).unwrap().0;
let raw = craft_psd::atn::parse(&bytes).unwrap();
assert!(raw.actions[0].items[0].descriptor.is_none());
let imported = atn_cmds::import(&bytes).unwrap();
let ActionStep { command: step, params } = &imported.actions[0].steps[0];
assert_eq!(step, atn_cmds::MENU_ITEM);
assert_eq!(params["id"], id);
assert_eq!(params["eventKind"], kind);
let (saved, skipped) = atn_cmds::export("S", &[&imported.actions[0]], &[], false).unwrap();
assert!(skipped.is_empty());
let saved = craft_psd::atn::parse(&saved).unwrap();
assert_eq!(saved.actions[0].items[0], raw.actions[0].items[0]);
let played = s.execute("actions.play", json!({"action":"A"})).unwrap();
assert_eq!(played.get("failed").is_none(), !atn_cmds::menu_item_needs_settings(id), "{id}: {played}");
}
}
let mut s = session();
let original = s.actions.clone();
for params in
[json!({"action":"A","id":"layer.setProps"}), json!({"action":"A","id":"file.open"}), json!({"action":"A","id":"image.imageSize","params":{"width":4}})]
{
assert!(s.execute("actions.insertMenuItem", params).is_err());
assert_eq!(s.actions, original);
}
let mut raw = craft_psd::atn::AtnFile::default();
raw.actions.push(craft_psd::atn::AtnAction {
items: vec![craft_psd::atn::AtnItem {
event: craft_psd::atn::AtnEvent::name("gaussianBlur"),
descriptor: Some(craft_psd::descriptor::Descriptor::new("null")),
..Default::default()
}],
..Default::default()
});
let loaded = atn_cmds::import(&craft_psd::atn::write(&raw).unwrap()).unwrap();
assert_eq!(loaded.actions[0].steps[0].command, "filter.blur.gaussianBlur");
}
/// A full curve is snapshotted independently of later source edits and replays as the work path.
#[test]
fn insert_path_captures_cubic_geometry_without_editing_the_document() {
let mut s = session();
let path = json!({"fillRule":"evenodd","inverted":true,"subpaths":[{"closed":false,"op":"combine","knots":[{"anchor":[1.5,2.25],"in":[-1.0,3.0],"out":[5.0,8.0],"smooth":true},{"anchor":[20.0,18.0],"in":[12.0,5.0],"out":[21.0,19.0]}]}]});
s.execute("path.set", json!({"name":"Curve","path":path})).unwrap();
let expected = s.execute("path.info", json!({"name":"Curve"})).unwrap()["path"].clone();
let revision = s.active().unwrap().revision;
assert!(s.execute("actions.insertPath", json!({"action":"A","name":"work"})).is_err());
assert!(s.actions.list.actions()[0].steps.is_empty());
s.execute("actions.insertPath", json!({"action":"A","name":"Curve"})).unwrap();
assert_eq!(s.active().unwrap().revision, revision);
assert_eq!(s.actions.list.actions()[0].steps[0].params["path"], expected);
s.execute("path.set", json!({"name":"Curve","path":{"subpaths":[]}})).unwrap();
let played = s.execute("actions.play", json!({"action":"A"})).unwrap();
assert!(played.get("failed").is_none(), "{played}");
assert_eq!(s.execute("path.info", json!({"name":"work"})).unwrap()["path"], expected);
assert!(atn_cmds::export("S", &[&s.actions.list.actions()[0]], &[], false).is_err(), "the measured ATN descriptor cannot represent inversion");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.