mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 01:18:43 +00:00
Wire physical Actions placement through existing commands
Resolve current folder selectors before capture effects; retain new-draft placement through Save; publish validated definition fields and intended shortcut maps only. Preserve logical set-only behavior, checked physical no-ops and runtime snapshot comparisons. Route Classic and Modern creation, assignment, duplicate and owned delete by occurrence with revision/origin revalidation. Keep known numeric Play/Conditional calls stable through insertion and reorder. Prepare four engine and three panel adapter controls in existing suites. Source-only: compiler, formatting and tests unrun; public PR unchanged.
This commit is contained in:
1 parent
4515b5fc59
commit
169ceb32dc
13 files changed
+545
-144
No files matched your search
@@ -548,6 +548,11 @@ fn get(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
/// Start capture into the selected or newly created definition while refusing incompatible playback state.
|
||||
fn record(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let destination = library::RowBinding::requested(&s.actions, p, library::placement::SelectorUse::NewAction).map_err(|error| bad("actions.record", error))?;
|
||||
if p.get("action").is_some() && (p.get("set").is_some() || p.get("name").is_some()) {
|
||||
return Err(bad("actions.record", "record an existing action without replacement name/set fields"));
|
||||
}
|
||||
if destination.is_some() { library::placement::idle(s, "actions.record")?; }
|
||||
not_playing(s, "actions.record")?;
|
||||
if s.actions.recording_active() {
|
||||
return Err(bad("actions.record", "already recording; stop first"));
|
||||
@@ -578,9 +583,18 @@ fn record(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Some(Value::String(n)) if !n.trim().is_empty() => Some(n.trim().to_string()),
|
||||
Some(_) => return Err(bad("actions.record", "\"set\" must be a set name or null")),
|
||||
};
|
||||
s.actions.list.push(Action { set, ..Action::new(name, Vec::new()) });
|
||||
s.actions.touch();
|
||||
s.actions.list.len() - 1
|
||||
let value = Action { set, ..Action::new(name, Vec::new()) };
|
||||
if let Some(destination) = destination {
|
||||
let prepared = library::placement::prepare(&s.actions, &s.prefs().shortcuts, &s.prefs().alternate_shortcuts,
|
||||
library::placement::Edit::Insert { destination, action:value }).map_err(|error| bad("actions.record", error))?;
|
||||
let index = prepared.result["index"].as_u64().and_then(|value| usize::try_from(value).ok()).ok_or_else(|| bad("actions.record", "missing prepared action index"))?;
|
||||
prepared.publish(s);
|
||||
index
|
||||
} else {
|
||||
s.actions.list.push(value);
|
||||
s.actions.touch();
|
||||
s.actions.list.len() - 1
|
||||
}
|
||||
};
|
||||
s.actions.recording = Some((s.journal.len(), idx));
|
||||
s.actions.take = s.actions.take.wrapping_add(1);
|
||||
@@ -906,6 +920,15 @@ fn move_item(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let moved = s.actions.list.remove(idx);
|
||||
let result = json!({"action": moved.name, "index": to});
|
||||
s.actions.list.insert(to, moved);
|
||||
// A direct list reorder follows the same known numeric call surface as physical moves.
|
||||
let count = s.actions.list.len();
|
||||
for (id, params) in s.actions.list.iter_mut().flat_map(|action| &mut action.steps) {
|
||||
for &key in call_keys(id) {
|
||||
let Some(old) = params.get(key).and_then(num).and_then(|value| usize::try_from(value).ok()).filter(|&old| old < count) else { continue };
|
||||
let new = moved_index(old, idx, to);
|
||||
if new != old { params[key] = json!(new); }
|
||||
}
|
||||
}
|
||||
if let Some((_, recording)) = s.actions.recording.as_mut() {
|
||||
*recording = moved_index(*recording, idx, to);
|
||||
}
|
||||
@@ -929,6 +952,13 @@ pub fn moved_index(index: usize, from: usize, to: usize) -> usize {
|
||||
|
||||
/// Delete the selected set, action or step with the appropriate playback and recording guards.
|
||||
fn delete(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let physical = library::RowBinding::requested(&s.actions, p, library::placement::SelectorUse::Folder).map_err(|error| bad("actions.delete", error))?;
|
||||
if let Some(source) = physical {
|
||||
library::placement::idle(s, "actions.delete")?;
|
||||
let prepared = library::placement::prepare(&s.actions, &s.prefs().shortcuts, &s.prefs().alternate_shortcuts,
|
||||
library::placement::Edit::Delete { source }).map_err(|error| bad("actions.delete", error))?;
|
||||
return Ok(prepared.publish(s));
|
||||
}
|
||||
not_playing(s, "actions.delete")?;
|
||||
if p.get("set").is_some() {
|
||||
if p.get("action").is_some() || p.get("step").is_some() {
|
||||
@@ -1226,7 +1256,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
label: "Record Action",
|
||||
menu: &[],
|
||||
shortcut: None,
|
||||
params: r##"{"name":str? (new action, default "Action N"),"set":name? (the set it goes in, as New Action records into the selected set)} or {"action":name|index} (append) → {action, index}"##,
|
||||
params: r##"{"name":str? (new action, default "Action N"),"set":name?,"setSlot":current physical slot? (new action destination; exact optional caption)} or {"action":name|index} (append) → {action, index}"##,
|
||||
enabled: always,
|
||||
run: record,
|
||||
journal: false,
|
||||
@@ -1256,7 +1286,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
label: "Delete Action",
|
||||
menu: &[],
|
||||
shortcut: None,
|
||||
params: r##"{"action":name|index, "step":index?} or {"set":name} → {deleted:name} or {action,deletedStep,steps} or {deletedSet,deleted:[name…]}. Step is 0-based, including pending recorded steps. Deleting a folder also deletes its contents, including an empty folder. Whole-action/folder deletion requires recording to be stopped. Calls to survivors keep their target; calls to deleted actions become invalid."##,
|
||||
params: r##"{"action":name|index, "step":index?} or {"set":name?,"setSlot":current physical slot?} → {deleted:name} or {action,deletedStep,steps} or {deletedSet,deleted:[name…]}. Step is 0-based, including pending recorded steps. Deleting a folder also deletes its contents, including an empty folder. Whole-action/folder deletion requires recording to be stopped. Calls to survivors keep their target; calls to deleted actions become invalid."##,
|
||||
enabled: always,
|
||||
run: delete,
|
||||
journal: false,
|
||||
|
||||
@@ -88,13 +88,13 @@ pub(super) fn preview_value(s: &Session, id: u64) -> Result<Action> {
|
||||
|
||||
/// Require both this draft identity and its unchanged staged value before an owned preview resumes.
|
||||
pub(super) fn preview_matches(s: &Session, id: u64, snapshot: &Action) -> bool {
|
||||
s.actions.editor.as_ref().is_some_and(|draft| draft.id == id && &draft.value == snapshot)
|
||||
s.actions.editor.as_ref().is_some_and(|draft| draft.id == id && &draft.value == snapshot && super::library::same_placement(&draft.value, snapshot))
|
||||
}
|
||||
|
||||
/// Structured inspection serializes the complete Action, not a metadata whitelist.
|
||||
fn view(draft: &Draft, value: &Action) -> Value {
|
||||
json!({"draft":draft.id, "action":value, "shortcut":draft.shortcut,
|
||||
"dirty": value != &draft.opening || draft.shortcut != draft.opening_shortcut,
|
||||
"dirty": value != &draft.opening || !super::library::same_placement(value, &draft.opening) || draft.shortcut != draft.opening_shortcut,
|
||||
"recording":draft.recording.is_some(), "source":draft.source, "libraryRevision":draft.library_revision})
|
||||
}
|
||||
|
||||
@@ -133,7 +133,8 @@ fn new_value(s: &Session, p: &Value) -> Result<Action> {
|
||||
|
||||
/// Open one complete action clone, without changing the library, shortcuts or preset store.
|
||||
fn open(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
fields(p, &["action", "name", "set"], OPEN)?;
|
||||
fields(p, &["action", "name", "set", "setSlot"], OPEN)?;
|
||||
let destination = super::library::RowBinding::requested(&s.actions, p, super::library::placement::SelectorUse::NewAction).map_err(|error| bad(OPEN, error))?;
|
||||
not_playing(s, OPEN)?;
|
||||
if s.actions.editor.is_some() || s.actions.recording_active() {
|
||||
return Err(bad(OPEN, "close the open editor or stop recording first"));
|
||||
@@ -142,10 +143,11 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if source.is_some() && (p.get("name").is_some() || p.get("set").is_some()) {
|
||||
return Err(bad(OPEN, "open an existing action without replacement name/set fields"));
|
||||
}
|
||||
let value = match source {
|
||||
let mut value = match source {
|
||||
Some(index) => s.actions.list.get(index).cloned().ok_or_else(|| bad(OPEN, "no such action"))?,
|
||||
None => new_value(s, p)?,
|
||||
};
|
||||
if let Some(destination) = destination { destination.apply(&mut value); }
|
||||
let id = s.actions.take.checked_add(1).ok_or_else(|| bad(OPEN, "recording identities exhausted"))?;
|
||||
let shortcut = s.prefs().shortcuts.get(&format!("{}{}", super::PLAY_SHORTCUT_PREFIX, value.name)).cloned().unwrap_or_default();
|
||||
let draft = Draft {
|
||||
@@ -407,7 +409,8 @@ fn stop(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
/// Reject external library/shortcut edits before preparing any definition publication.
|
||||
fn unchanged(s: &Session, draft: &Draft) -> Result<()> {
|
||||
let source_changed = draft.source.is_some_and(|index| s.actions.list.get(index) != Some(&draft.opening));
|
||||
let source_changed = draft.source.is_some_and(|index| s.actions.list.get(index).is_none_or(|value|
|
||||
value != &draft.opening || !super::library::same_placement(value, &draft.opening)));
|
||||
if s.actions.rev != draft.library_revision
|
||||
|| source_changed
|
||||
|| action_keys(&s.prefs().shortcuts) != draft.keys
|
||||
@@ -488,7 +491,8 @@ fn save(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
unchanged(s, draft)?;
|
||||
let mut value = visible(s, draft)?;
|
||||
if value == draft.opening && draft.shortcut == draft.opening_shortcut {
|
||||
if let Some(destination) = &value.library_row { destination.slot(&s.actions).map_err(|error| bad(SAVE, error))?; }
|
||||
if value == draft.opening && super::library::same_placement(&value, &draft.opening) && draft.shortcut == draft.opening_shortcut {
|
||||
// Save closes this capture even when it has no completed steps. The committed
|
||||
// library, shortcut maps and their revisions still remain exactly unchanged.
|
||||
let mut next = draft.clone();
|
||||
@@ -513,47 +517,43 @@ fn save(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
.chain(draft.source.is_none().then_some(&value)),
|
||||
)
|
||||
.map_err(|error| bad(SAVE, error))?;
|
||||
let (keys, alternates) = bindings(s, draft, &value);
|
||||
let target = draft.source.unwrap_or(s.actions.list.len());
|
||||
let changed = draft.source.is_none() || value != draft.opening || !changes.is_empty();
|
||||
let prefs_changed = keys != s.prefs().shortcuts || alternates != s.prefs().alternate_shortcuts;
|
||||
let (mut keys, mut alternates) = bindings(s, draft, &value);
|
||||
let changed = draft.source.is_none() || value != draft.opening || !super::library::same_placement(&value, &draft.opening) || !changes.is_empty();
|
||||
let mut proposed = super::library::definition_copy(&s.actions);
|
||||
// Renamed callers and the edited action remain one preflighted transaction.
|
||||
for (action, step, params) in changes {
|
||||
if let Some((_, old)) = proposed.list.get_mut(action).and_then(|action| action.steps.get_mut(step)) { *old = params; }
|
||||
}
|
||||
let target;
|
||||
if draft.source.is_none() && value.library_row.is_some() {
|
||||
let destination = value.library_row.clone().ok_or_else(|| bad(SAVE, "missing draft destination"))?;
|
||||
let prepared = super::library::placement::prepare(&proposed, &keys, &alternates,
|
||||
super::library::placement::Edit::Insert { destination, action:value }).map_err(|error| bad(SAVE, error))?;
|
||||
target = prepared.result["index"].as_u64().and_then(|index| usize::try_from(index).ok()).ok_or_else(|| bad(SAVE, "missing prepared action index"))?;
|
||||
proposed = prepared.definition;
|
||||
keys = prepared.shortcuts;
|
||||
alternates = prepared.alternates;
|
||||
} else {
|
||||
target = draft.source.unwrap_or(proposed.list.len());
|
||||
if target == proposed.list.len() {
|
||||
proposed.list.try_reserve(1).map_err(|_| bad(SAVE, "not enough memory for the action"))?;
|
||||
proposed.list.push(value);
|
||||
} else if let Some(old) = proposed.list.get_mut(target) { *old = value; }
|
||||
super::library::check_definition(&proposed, &keys).map_err(|error| bad(SAVE, error))?;
|
||||
}
|
||||
// The prepared insertion may remap this value's numeric calls; acknowledge that exact value.
|
||||
let published = proposed.list.get(target).cloned().ok_or_else(|| bad(SAVE, "missing prepared definition"))?;
|
||||
let mut next = draft.clone();
|
||||
next.value = value.clone();
|
||||
next.opening = value.clone();
|
||||
next.value = published.clone();
|
||||
next.opening = published.clone();
|
||||
next.source = Some(target);
|
||||
next.library_revision = if changed { s.actions.rev.saturating_add(1) } else { s.actions.rev };
|
||||
next.opening_shortcut = next.shortcut.clone();
|
||||
next.keys = action_keys(&keys);
|
||||
next.alternates = action_keys(&alternates);
|
||||
next.recording = None;
|
||||
let response = view(&next, &value);
|
||||
let mut proposed = super::library::definition_copy(&s.actions);
|
||||
if target == proposed.list.len() {
|
||||
proposed.list.try_reserve(1).map_err(|_| bad(SAVE, "not enough memory for the action"))?;
|
||||
}
|
||||
// Include renamed callers in the same encoded candidate as the edited action.
|
||||
for (action, step, params) in changes {
|
||||
if let Some((_, old)) = proposed.list.get_mut(action).and_then(|action| action.steps.get_mut(step)) {
|
||||
*old = params;
|
||||
}
|
||||
}
|
||||
if target == proposed.list.len() {
|
||||
proposed.list.push(value);
|
||||
} else if let Some(old) = proposed.list.get_mut(target) {
|
||||
*old = value;
|
||||
}
|
||||
super::library::check_definition(&proposed, &keys).map_err(|error| bad(SAVE, error))?;
|
||||
// Encoding succeeded. Publish definitions without replacing the live capture/owner state.
|
||||
s.actions.list = proposed.list;
|
||||
if changed {
|
||||
s.actions.touch();
|
||||
}
|
||||
if prefs_changed {
|
||||
s.edit_prefs(|prefs| {
|
||||
prefs.shortcuts = keys;
|
||||
prefs.alternate_shortcuts = alternates;
|
||||
});
|
||||
}
|
||||
let response = view(&next, &published);
|
||||
super::library::placement::publish(s, proposed, keys, alternates, changed);
|
||||
s.actions.editor = Some(next);
|
||||
Ok(response)
|
||||
}
|
||||
@@ -578,7 +578,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
command(
|
||||
OPEN,
|
||||
"Open Action Draft",
|
||||
r#"{"action":name|index?} or {"name":str?,"set":str?} → draft view. One unpublished complete Action; untouched New Save is a no-op."#,
|
||||
r#"{"action":name|index?} or {"name":str?,"set":str?,"setSlot":current physical slot?} → draft view. One unpublished complete Action; untouched New Save is a no-op."#,
|
||||
open,
|
||||
),
|
||||
command(
|
||||
|
||||
@@ -10,7 +10,7 @@ use super::{Action, ActionState, color_to_atn};
|
||||
use crate::atn_cmds::{self, sidecar};
|
||||
|
||||
pub(crate) mod placement;
|
||||
pub use placement::RowBinding;
|
||||
pub use placement::{RowBinding, same_placement};
|
||||
|
||||
type Result<T> = std::result::Result<T, String>;
|
||||
const MAX_BYTES: usize = crate::preset_store::MAX_ACTIONS_BYTES as usize;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! Isolated checked physical-placement prototype. No public command adapter is installed here.
|
||||
//! Checked physical placement used by existing Actions command adapters.
|
||||
//! Prepared candidates own definitions/maps only; callers must retain their normal lifetime gates.
|
||||
use std::{collections::{BTreeMap, HashMap, HashSet}, sync::Arc};
|
||||
use super::{Action, ActionState, RowOrigin, Result, atn_cmds, sidecar};
|
||||
@@ -55,13 +55,62 @@ impl RowBinding {
|
||||
Ok(slot)
|
||||
}
|
||||
|
||||
fn apply(&self, action: &mut Action) {
|
||||
pub(crate) fn apply(&self, action: &mut Action) {
|
||||
action.set = Some(self.name.clone());
|
||||
action.library_row = Some(self.clone());
|
||||
sidecar::place_metadata(action, self.carrier.clone());
|
||||
}
|
||||
}
|
||||
|
||||
impl RowBinding {
|
||||
/// Placement-only no-op detection uses the current checked context, not Action::PartialEq.
|
||||
pub(crate) fn contains(&self, state: &ActionState, action: &Action) -> Result<bool> {
|
||||
self.slot(state)?;
|
||||
let raw = state.library.row_index(&state.sets).source(action)?;
|
||||
Ok(atn_cmds::logical_set_name(action.set.as_deref()) == self.name
|
||||
&& raw.as_ref().map(RowOrigin::key) == self.row.as_ref().map(RowOrigin::key))
|
||||
}
|
||||
}
|
||||
|
||||
/// Runtime snapshot comparison only; ordinary Action equality retains its reload contract.
|
||||
pub fn same_placement(left: &Action, right: &Action) -> bool {
|
||||
let row = |action: &Action| action.library_row.as_ref().map(|binding| binding.row.as_ref().map(RowOrigin::key))
|
||||
.unwrap_or_else(|| action.library_origin.as_ref().map(|origin| origin.row.key()));
|
||||
if atn_cmds::logical_set_name(left.set.as_deref()) != atn_cmds::logical_set_name(right.set.as_deref()) || row(left) != row(right) { return false; }
|
||||
match (&left.library_row, &right.library_row) {
|
||||
(Some(left), Some(right)) => left.carrier == right.carrier,
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
/// Publish a fully validated candidate without replacing capture, editor, Owner or counters.
|
||||
pub(crate) fn publish(s: &mut crate::Session, definition: ActionState, shortcuts: Keys, alternates: Alternates, changed: bool) {
|
||||
s.actions.list = definition.list;
|
||||
s.actions.sets = definition.sets;
|
||||
s.actions.library = definition.library;
|
||||
s.actions.atn_set_rows = definition.atn_set_rows;
|
||||
if shortcuts != s.prefs().shortcuts || alternates != s.prefs().alternate_shortcuts {
|
||||
s.edit_prefs(|prefs| { prefs.shortcuts = shortcuts; prefs.alternate_shortcuts = alternates; });
|
||||
}
|
||||
if changed { s.actions.touch(); }
|
||||
}
|
||||
|
||||
impl Prepared {
|
||||
pub(crate) fn publish(self, s: &mut crate::Session) -> Value {
|
||||
publish(s, self.definition, self.shortcuts, self.alternates, true);
|
||||
self.result
|
||||
}
|
||||
}
|
||||
|
||||
/// Moving indices while a capture/job owns them must fail before any recording flush.
|
||||
pub(crate) fn idle(s: &crate::Session, command: &str) -> crate::Result<()> {
|
||||
super::super::not_playing(s, command)?;
|
||||
if s.actions.recording_active() || s.has_recording_job() {
|
||||
return Err(super::super::bad(command, "finish recording and its pending step before editing a physical folder"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// All readers use the same checked destination and current row-local carrier.
|
||||
/// Temporary indexes preserve linear validation even when many actions share a caption.
|
||||
pub(crate) fn validate(state: &ActionState) -> Result<()> {
|
||||
@@ -229,9 +278,10 @@ pub(crate) fn prepare(state: &ActionState, shortcuts: &Keys, alternates: &Altern
|
||||
value
|
||||
}).collect();
|
||||
let count = copied.len();
|
||||
let copied_names: Vec<_> = copied.iter().map(|action| action.name.clone()).collect();
|
||||
definition.list.splice(at..at, copied);
|
||||
crate::actions_edit_cmds::shift_action_calls(&mut definition.list, at, count);
|
||||
json!({"index":at,"set":name,"slot":destination_slot,"actions":count})
|
||||
json!({"index":at,"set":name,"slot":destination_slot,"actions":copied_names})
|
||||
}
|
||||
Edit::Delete { source } => {
|
||||
let slot = source.slot(state)?;
|
||||
|
||||
@@ -22,7 +22,7 @@ pub struct Owner {
|
||||
|
||||
/// Restore a Classic recorder only to one unchanged definition, allowing reorder but rejecting ambiguity.
|
||||
fn classic_index(s: &Session, action: &Action) -> Option<usize> {
|
||||
let mut matches = s.actions.list.iter().enumerate().filter(|(_, candidate)| *candidate == action).map(|(index, _)| index);
|
||||
let mut matches = s.actions.list.iter().enumerate().filter(|(_, candidate)| *candidate == action && super::library::same_placement(candidate, action)).map(|(index, _)| index);
|
||||
let index = matches.next()?;
|
||||
matches.next().is_none().then_some(index)
|
||||
}
|
||||
|
||||
@@ -171,7 +171,7 @@ pub(crate) fn shift_action_calls(actions: &mut [Action], at: usize, count: usize
|
||||
fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "actions.duplicate";
|
||||
not_playing(s, cmd)?;
|
||||
if p.get("set").is_some() {
|
||||
if p.get("set").is_some() || p.get("setSlot").is_some() {
|
||||
return duplicate_set(s, p);
|
||||
}
|
||||
let idx = resolve(&s.actions.list, p, cmd)?;
|
||||
@@ -219,6 +219,16 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
/// Copy a folder below its source, using the existing first-appearance order and empty-set model.
|
||||
fn duplicate_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "actions.duplicate";
|
||||
use crate::actions_cmds::library::{RowBinding, placement};
|
||||
let physical = RowBinding::requested(&s.actions, p, placement::SelectorUse::Folder).map_err(|error| bad(cmd, error))?;
|
||||
if let Some(source) = physical {
|
||||
placement::idle(s, cmd)?;
|
||||
let mut names = crate::atn_cmds::UniqueNames::new(set_names(s));
|
||||
let name = names.claim(&format!("{} copy", source.name));
|
||||
let prepared = placement::prepare(&s.actions, &s.prefs().shortcuts, &s.prefs().alternate_shortcuts,
|
||||
placement::Edit::Duplicate { source, name }).map_err(|error| bad(cmd, error))?;
|
||||
return Ok(prepared.publish(s));
|
||||
}
|
||||
if p.get("action").is_some() || p.get("step").is_some() {
|
||||
return Err(bad(cmd, "select either a set or an action/step"));
|
||||
}
|
||||
@@ -243,6 +253,7 @@ fn duplicate_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
.map(|mut a| {
|
||||
a.name = names.claim(&format!("{} copy", a.name));
|
||||
a.set = Some(name.clone());
|
||||
if let Some(binding) = &mut a.library_row { binding.name = name.clone(); }
|
||||
a
|
||||
})
|
||||
.collect();
|
||||
@@ -327,6 +338,19 @@ fn dialog(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
fn assign_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "actions.assignSet";
|
||||
use crate::actions_cmds::library::{RowBinding, placement};
|
||||
let physical = RowBinding::requested(&s.actions, p, placement::SelectorUse::Assign).map_err(|error| bad(cmd, error))?;
|
||||
if let Some(destination) = physical {
|
||||
placement::idle(s, cmd)?;
|
||||
let index = resolve(&s.actions.list, p, cmd)?;
|
||||
if destination.contains(&s.actions, &s.actions.list[index]).map_err(|error| bad(cmd, error))? {
|
||||
return Ok(json!({"action":s.actions.list[index].name,"set":destination.name,"index":index,"slot":destination.slot(&s.actions).map_err(|error| bad(cmd, error))?}));
|
||||
}
|
||||
let mut prepared = placement::prepare(&s.actions, &s.prefs().shortcuts, &s.prefs().alternate_shortcuts,
|
||||
placement::Edit::Assign { destination, action:index }).map_err(|error| bad(cmd, error))?;
|
||||
prepared.result["action"] = json!(s.actions.list[index].name);
|
||||
return Ok(prepared.publish(s));
|
||||
}
|
||||
not_playing(s, cmd)?;
|
||||
let idx = resolve(&s.actions.list, p, cmd)?;
|
||||
let set = match p.get("set") {
|
||||
@@ -337,6 +361,7 @@ fn assign_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
};
|
||||
crate::atn_cmds::sidecar::assign_set_metadata(&mut s.actions, idx, set.as_deref());
|
||||
let action = &mut s.actions.list[idx];
|
||||
if crate::atn_cmds::logical_set_name(action.set.as_deref()) != crate::atn_cmds::logical_set_name(set.as_deref()) { action.library_row = None; }
|
||||
action.set = set;
|
||||
let result = json!({"action": action.name, "set": action.set});
|
||||
s.actions.touch();
|
||||
@@ -576,7 +601,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
label: "Duplicate Action",
|
||||
menu: &[],
|
||||
shortcut: None,
|
||||
params: r##"{"action":name|index, "step":index?} or {"set":name} → {action,index,steps} or {set,actions,index}. Copies a step, action or entire folder below its source, retaining settings and flags. Whole-action/folder copies require recording to be stopped; original function keys stay with their original actions."##,
|
||||
params: r##"{"action":name|index, "step":index?} or {"set":name?,"setSlot":current physical slot?} → {action,index,steps} or {set,actions,index}. Copies a step, action or entire folder below its source, retaining settings and flags. Whole-action/folder copies require recording to be stopped; original function keys stay with their original actions."##,
|
||||
enabled: always,
|
||||
run: duplicate,
|
||||
journal: false,
|
||||
@@ -616,7 +641,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
label: "Move to Set",
|
||||
menu: &[],
|
||||
shortcut: None,
|
||||
params: r##"{"action":name|index, "set":name|null} → {action, set}. The set folder the Actions panel shows the action under (what Load Actions fills and Save Actions writes); null takes it out of any set."##,
|
||||
params: r##"{"action":name|index, "set":name|null?, "setSlot":current physical slot?} → {action, set, index?, slot?}. The set folder the Actions panel shows the action under (what Load Actions fills and Save Actions writes); null takes it out of any set."##,
|
||||
enabled: always,
|
||||
run: assign_set,
|
||||
journal: false,
|
||||
|
||||
@@ -169,6 +169,8 @@ fn import_actions(s: &mut Session, p: &Value, whole: bool) -> Result<Value> {
|
||||
/// Encode the selected action or library while retaining its physical source and metadata.
|
||||
pub(super) fn save(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "actions.save";
|
||||
let physical = crate::actions_cmds::library::RowBinding::requested(&s.actions, p,
|
||||
crate::actions_cmds::library::placement::SelectorUse::Folder).map_err(|error| bad(cmd, error))?;
|
||||
crate::actions_cmds::flush_recording(s)?;
|
||||
let skip = match p.get("skipUnsupported") {
|
||||
None | Some(Value::Null) => false,
|
||||
@@ -183,14 +185,7 @@ pub(super) fn save(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Some(Value::String(n)) if !n.trim().is_empty() => Some(n.trim().to_string()),
|
||||
Some(_) => return Err(bad(cmd, "`set` must be a non-empty string")),
|
||||
};
|
||||
let physical_slot = match p.get("setSlot") {
|
||||
None | Some(Value::Null) => None,
|
||||
Some(value) => Some(value.as_u64().and_then(|slot| usize::try_from(slot).ok())
|
||||
.filter(|slot| s.actions.sets.get(*slot).is_some()).ok_or_else(|| bad(cmd, "`setSlot` is not a current physical folder slot"))?),
|
||||
};
|
||||
if physical_slot.is_some() && p.get("action").is_some() {
|
||||
return Err(bad(cmd, "select either a physical folder or an action"));
|
||||
}
|
||||
let physical_slot = physical.as_ref().map(|binding| binding.slot(&s.actions)).transpose().map_err(|error| bad(cmd, error))?;
|
||||
let mut groups = if let Some(slot) = physical_slot {
|
||||
let name = s.actions.sets.get(slot).ok_or_else(|| bad(cmd, "the action folder no longer exists"))?;
|
||||
if set_param.as_ref().is_some_and(|selected| selected != name) { return Err(bad(cmd, "the physical folder name changed")); }
|
||||
|
||||
@@ -262,3 +262,132 @@ fn tool_recording_opt_in_has_the_same_journal_policy_in_both_recorders() {
|
||||
assert_eq!(s.journal.iter().filter(|(id, _)| id == "paint.stroke").count(), 3);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn physical_session() -> Session {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", json!({"width":8,"height":6})).unwrap();
|
||||
for _ in 0..2 { s.execute("actions.reset", json!({"mode":"append","confirm":true})).unwrap(); }
|
||||
s
|
||||
}
|
||||
fn physical_counts(s: &Session) -> Vec<usize> {
|
||||
actions_edit_cmds::set_occurrences(s).unwrap().iter().map(|row| row.actions.len()).collect()
|
||||
}
|
||||
|
||||
/// Registered recorder/new-draft adapters retain the chosen physical occurrence through Save.
|
||||
#[test]
|
||||
fn physical_record_and_new_draft_save_keep_destinations_and_runtime_counters() {
|
||||
let mut s = physical_session();
|
||||
s.actions.playback_nonce = 73;
|
||||
s.actions.playback_steps = 19;
|
||||
let recorded = s.execute("actions.record", json!({"name":"Earlier recorder","setSlot":0,"set":actions_edit_cmds::DEFAULT_SET_NAME})).unwrap();
|
||||
assert_eq!(recorded["index"],2);
|
||||
s.execute("image.adjustments.invert",json!({})).unwrap();
|
||||
s.execute("actions.stop",json!({})).unwrap();
|
||||
assert_eq!(physical_counts(&s),[3,2]);
|
||||
let id = s.execute("actions.editor.open",json!({"name":"Second draft","setSlot":1})).unwrap()["draft"].as_u64().unwrap();
|
||||
let take = s.actions.take;
|
||||
s.execute("actions.editor.update",json!({"draft":id,"description":"Published only by Save"})).unwrap();
|
||||
let saved = s.execute("actions.editor.save",json!({"draft":id})).unwrap();
|
||||
assert_eq!(saved["source"],5);
|
||||
assert_eq!(saved["dirty"],false);
|
||||
assert_eq!(physical_counts(&s),[3,3]);
|
||||
assert_eq!(s.actions.take,take);
|
||||
assert_eq!((s.actions.playback_nonce,s.actions.playback_steps),(73,19));
|
||||
let revision = s.actions.rev;
|
||||
s.execute("actions.editor.save",json!({"draft":id})).unwrap();
|
||||
assert_eq!(s.actions.rev,revision,"unchanged Save is still a no-op");
|
||||
s.execute("actions.editor.discard",json!({"draft":id})).unwrap();
|
||||
let before = s.actions.list.len();
|
||||
let id = s.execute("actions.editor.open",json!({"name":"Untouched new draft","setSlot":0})).unwrap()["draft"].as_u64().unwrap();
|
||||
s.execute("actions.editor.save",json!({"draft":id})).unwrap();
|
||||
assert_eq!(s.actions.list.len(),before,"unchanged New Save keeps C's no-publication contract");
|
||||
}
|
||||
|
||||
/// A placement-only move changes revision despite logical equality; occurrence deletion owns both maps.
|
||||
#[test]
|
||||
fn physical_assign_duplicate_delete_preserve_namesakes_and_both_binding_maps() {
|
||||
let mut s = physical_session();
|
||||
let index = s.execute("actions.record",json!({"name":"Move me","setSlot":1})).unwrap()["index"].as_u64().unwrap() as usize;
|
||||
s.execute("select.all",json!({})).unwrap();
|
||||
s.execute("actions.stop",json!({})).unwrap();
|
||||
s.prefs.edit(|prefs| {
|
||||
prefs.shortcuts.insert("actions.play:Move me".into(),"F4".into());
|
||||
prefs.alternate_shortcuts.insert("actions.play:Move me".into(),vec!["F5".into()]);
|
||||
prefs.shortcuts.insert("actions.play:Invert Colors".into(),"F6".into());
|
||||
});
|
||||
let old = s.actions.list[index].clone();
|
||||
let revision = s.actions.rev;
|
||||
let moved = s.execute("actions.assignSet",json!({"action":index,"setSlot":0})).unwrap();
|
||||
let moved_index = moved["index"].as_u64().unwrap() as usize;
|
||||
assert_eq!(s.actions.list[moved_index],old,"ordinary logical equality remains unchanged");
|
||||
assert!(!photocraft_engine::actions_cmds::library::same_placement(&s.actions.list[moved_index],&old));
|
||||
assert!(s.actions.rev > revision);
|
||||
assert_eq!(physical_counts(&s),[3,2]);
|
||||
let revision = s.actions.rev;
|
||||
s.execute("actions.assignSet",json!({"action":moved_index,"setSlot":0})).unwrap();
|
||||
assert_eq!(s.actions.rev,revision,"same actual occurrence is a no-op");
|
||||
let document = s.active().unwrap().doc.clone();
|
||||
let take = s.actions.take;
|
||||
let copied = s.execute("actions.duplicate",json!({"setSlot":1})).unwrap();
|
||||
assert_eq!(copied["actions"].as_array().unwrap().len(),2);
|
||||
assert_eq!(physical_counts(&s),[3,2,2]);
|
||||
s.execute("actions.delete",json!({"setSlot":0})).unwrap();
|
||||
assert_eq!(physical_counts(&s),[2,2]);
|
||||
assert!(!s.prefs().shortcuts.contains_key("actions.play:Move me"));
|
||||
assert!(!s.prefs().alternate_shortcuts.contains_key("actions.play:Move me"));
|
||||
assert!(s.prefs().shortcuts.contains_key("actions.play:Invert Colors"),"the other namesake still owns this name");
|
||||
assert!(std::sync::Arc::ptr_eq(&document,&s.active().unwrap().doc));
|
||||
assert_eq!(s.actions.take,take);
|
||||
// Set-only remains a logical group operation, including actions carrying explicit placement.
|
||||
s.execute("actions.duplicate",json!({"set":copied["set"]})).unwrap();
|
||||
}
|
||||
|
||||
/// Invalid selectors and stale Saves never flush or consume the active Classic/draft capture.
|
||||
#[test]
|
||||
fn physical_adapter_refusals_preserve_capture_and_stale_draft() {
|
||||
let mut s = physical_session();
|
||||
s.execute("actions.record",json!({"action":0})).unwrap();
|
||||
s.execute("select.all",json!({})).unwrap();
|
||||
let cursor = s.actions.recording;
|
||||
let take = s.actions.take;
|
||||
let definitions = s.actions.list.clone();
|
||||
for params in [json!({"setSlot":99}),json!({"setSlot":null}),json!({"setSlot":0,"set":null}),json!({"setSlot":0,"action":0})] {
|
||||
assert!(s.execute("actions.record",params.clone()).is_err());
|
||||
assert!(s.execute("actions.editor.open",params.clone()).is_err());
|
||||
assert!(s.execute("actions.save",params).is_err());
|
||||
assert_eq!(s.actions.recording,cursor);
|
||||
assert_eq!(s.actions.take,take);
|
||||
assert_eq!(s.actions.list,definitions);
|
||||
}
|
||||
assert!(s.execute("actions.assignSet",json!({"action":0,"setSlot":1})).is_err());
|
||||
assert!(s.execute("actions.delete",json!({"setSlot":1})).is_err());
|
||||
s.execute("actions.stop",json!({})).unwrap();
|
||||
let id = s.execute("actions.editor.open",json!({"name":"Held destination","setSlot":1})).unwrap()["draft"].as_u64().unwrap();
|
||||
s.execute("actions.editor.update",json!({"draft":id,"description":"Still unpublished"})).unwrap();
|
||||
let draft = s.actions.editor.clone();
|
||||
let take = s.actions.take;
|
||||
s.execute("actions.newSet",json!({"name":"External change"})).unwrap();
|
||||
let definitions = s.actions.list.clone();
|
||||
assert!(s.execute("actions.editor.save",json!({"draft":id})).is_err());
|
||||
assert_eq!(s.actions.editor,draft);
|
||||
assert_eq!(s.actions.take,take);
|
||||
assert_eq!(s.actions.list,definitions);
|
||||
}
|
||||
|
||||
/// Direct list reorder follows numeric Conditional branches as well as Play.
|
||||
#[test]
|
||||
fn list_reorder_remaps_both_call_forms_without_traversing_foreign_json() {
|
||||
let mut s = physical_session();
|
||||
let foreign = json!({"actions":[{"steps":[["actions.play",{"action":0}]]}]});
|
||||
s.actions.list[1].steps.extend([
|
||||
("actions.play".into(),json!({"action":0})),
|
||||
("actions.conditional".into(),json!({"if":"always","then":0,"else":1})),
|
||||
("file.automate.batch".into(),foreign.clone()),
|
||||
]);
|
||||
s.execute("actions.move",json!({"action":0,"to":1})).unwrap();
|
||||
let steps = &s.actions.list[0].steps;
|
||||
assert_eq!(steps[1].1,json!({"action":1}));
|
||||
assert_eq!(steps[2].1,json!({"if":"always","then":1,"else":0}));
|
||||
assert_eq!(steps[3].1,foreign);
|
||||
}
|
||||
@@ -149,6 +149,14 @@ impl FolderSelection {
|
||||
if matches.next().is_some() { return Err("the selected Actions folder is ambiguous".into()); }
|
||||
row.slot.ok_or_else(|| "the selected Actions folder has no physical slot".into())
|
||||
}
|
||||
|
||||
fn checked_params(&self, app: &PhotocraftApp, revision: u64) -> Result<Value, String> {
|
||||
if self.slot.is_some() { return Ok(json!({"set":self.name,"setSlot":self.checked_slot(app, revision)?})); }
|
||||
if app.session.actions.rev != revision { return Err("the selected Actions folder changed".into()); }
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
if rows.iter().filter(|row| self.matches(row)).count() != 1 { return Err("the selected Actions folder changed or is ambiguous".into()); }
|
||||
Ok(json!({"set":self.name}))
|
||||
}
|
||||
}
|
||||
|
||||
fn selected_occurrence(app: &PhotocraftApp) -> Option<photocraft_engine::actions_edit_cmds::SetOccurrence> {
|
||||
@@ -728,6 +736,21 @@ fn new_action_set(app: &PhotocraftApp) -> Option<String> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve the actual selected occurrence before opening a recorder or a delayed new draft.
|
||||
fn new_action_params(app: &PhotocraftApp) -> Result<Value, String> {
|
||||
let revision = app.session.actions.rev;
|
||||
if app.ui.actions.selected.is_none() && let Some(key) = &app.ui.actions.selected_folder {
|
||||
return key.checked_params(app, revision);
|
||||
}
|
||||
if let Some(index) = app.ui.actions.selected.filter(|&index| index < app.session.actions.list.len()) {
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
if let Some(row) = rows.iter().find(|row| row.actions.contains(&index)) {
|
||||
if row.slot.is_some() { return FolderSelection::from_row(row).checked_params(app, revision); }
|
||||
}
|
||||
}
|
||||
Ok(new_action_set(app).map_or(json!({}), |set| json!({"set":set})))
|
||||
}
|
||||
|
||||
fn begin_recording(app: &mut PhotocraftApp, append: bool) {
|
||||
if app.session.actions.recording_active() {
|
||||
return;
|
||||
@@ -736,19 +759,29 @@ fn begin_recording(app: &mut PhotocraftApp, append: bool) {
|
||||
// new action like New Action does, in the selected set.
|
||||
let params = match app.ui.actions.selected {
|
||||
Some(i) if append => json!({"action": i}),
|
||||
_ => new_action_set(app).map_or(json!({}), |set| json!({"set": set})),
|
||||
_ => match new_action_params(app) {
|
||||
Ok(params) => params,
|
||||
Err(error) => { app.ui.status = error; app.ui.status_error = true; return; }
|
||||
},
|
||||
};
|
||||
let old_count = app.session.actions.list.len();
|
||||
let Ok(v) = app.run("actions.record", params) else { return };
|
||||
let Some(i) = v.get("index").and_then(Value::as_u64).and_then(|n| usize::try_from(n).ok()) else { return };
|
||||
app.ui.actions.select(i, None);
|
||||
if app.ui.actions.expanded.len() <= i {
|
||||
app.ui.actions.expanded.resize(i + 1, false);
|
||||
if app.session.actions.list.len() > old_count {
|
||||
app.ui.actions.expanded.resize(old_count, false);
|
||||
app.ui.actions.expanded.insert(i, true);
|
||||
} else {
|
||||
app.ui.actions.expanded.resize(app.session.actions.list.len(), false);
|
||||
if let Some(expanded) = app.ui.actions.expanded.get_mut(i) { *expanded = true; }
|
||||
}
|
||||
app.ui.actions.expanded[i] = true;
|
||||
// Its set too, in case its folder is collapsed.
|
||||
if let Some(action) = app.session.actions.list.get(i) {
|
||||
let set = photocraft_engine::atn_cmds::logical_set_name(action.set.as_deref());
|
||||
app.ui.actions.collapsed_sets.retain(|c| c != set);
|
||||
// Reveal only the actual recording folder, retaining independent namesake disclosure.
|
||||
if let Ok(rows) = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session) {
|
||||
if let Some(row) = rows.iter().find(|row| row.actions.contains(&i)) {
|
||||
let key = FolderSelection::from_row(row);
|
||||
app.ui.actions.collapsed_folders.retain(|old| old != &key);
|
||||
if row.origin.is_none() { app.ui.actions.collapsed_sets.retain(|name| name != &row.name); }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1649,7 +1682,7 @@ fn classic_panel_menu(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
if ui.add_enabled(can_delete || (!recording && selected_set(app).is_some()), egui::Button::new(tl!("Duplicate"))).clicked() {
|
||||
act = Some("duplicate");
|
||||
}
|
||||
if ui.add_enabled(can_delete, egui::Button::new(tl!("Delete"))).clicked() {
|
||||
if ui.add_enabled(can_delete || (!recording && selected_set(app).is_some()), egui::Button::new(tl!("Delete"))).clicked() {
|
||||
act = Some("delete");
|
||||
}
|
||||
if ui.add_enabled(any, egui::Button::new(tl!("Play"))).clicked() {
|
||||
@@ -1720,10 +1753,7 @@ fn classic_panel_menu(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
v.unwrap_or(Value::Null)
|
||||
})
|
||||
}
|
||||
"delete" => {
|
||||
delete_selection(app);
|
||||
Ok(Value::Null)
|
||||
}
|
||||
"delete" => request_delete(app),
|
||||
"duplicate" => duplicate_selection(app),
|
||||
"recordAgain" => record_again::open(app),
|
||||
"toolRecording" => app.run("actions.allowToolRecording", json!({"enabled": !app.session.actions.record_tools})),
|
||||
@@ -1752,6 +1782,8 @@ fn classic_panel_menu(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
struct DragRow {
|
||||
action: usize,
|
||||
step: Option<usize>,
|
||||
revision: u64,
|
||||
origin: Option<(usize, usize)>,
|
||||
}
|
||||
|
||||
/// Drops use an insertion line, converted to the final index expected by actions.move.
|
||||
@@ -1772,6 +1804,45 @@ fn drag_row(ui: &egui::Ui, response: &egui::Response, row: DragRow, t: &Tokens)
|
||||
}
|
||||
|
||||
fn move_row(app: &mut PhotocraftApp, source: DragRow, to: usize) {
|
||||
let checked = (|| -> Result<Option<(Value, usize)>, String> {
|
||||
if source.revision != app.session.actions.rev { return Err("The dragged action changed; drag it again".into()); }
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
let source_row = rows.iter().find(|row| row.actions.contains(&source.action)).ok_or("The dragged action no longer exists")?;
|
||||
if source_row.origin != source.origin { return Err("The dragged action folder changed".into()); }
|
||||
if source.step.is_some() { return Ok(None); }
|
||||
if to >= app.session.actions.list.len() { return Err("The drop position changed".into()); }
|
||||
let mut order: Vec<_> = (0..app.session.actions.list.len()).filter(|&index| index != source.action).collect();
|
||||
order.insert(to, source.action);
|
||||
let neighbour = to.checked_sub(1).and_then(|index| order.get(index)).or_else(|| order.get(to + 1));
|
||||
let Some(target) = neighbour.and_then(|index| rows.iter().find(|row| row.actions.contains(index))) else { return Ok(None) };
|
||||
let key = FolderSelection::from_row(target);
|
||||
if !key.matches(source_row) && (source_row.origin.is_some() || target.origin.is_some()) {
|
||||
let mut params = key.checked_params(app, source.revision)?;
|
||||
if params.get("setSlot").is_none() { return Err("The target folder has no physical slot".into()); }
|
||||
params["action"] = json!(source.action);
|
||||
return Ok(Some((params, source.action)));
|
||||
}
|
||||
Ok(None)
|
||||
})();
|
||||
match checked {
|
||||
Err(error) => { app.ui.status = error; app.ui.status_error = true; return; }
|
||||
Ok(Some((params, from))) => {
|
||||
match app.run("actions.assignSet", params) {
|
||||
Ok(result) => {
|
||||
if let Some(index) = result.get("index").and_then(Value::as_u64).and_then(|index| usize::try_from(index).ok()) {
|
||||
app.ui.actions.expanded.resize(app.session.actions.list.len(), false);
|
||||
if from < app.ui.actions.expanded.len() && index < app.ui.actions.expanded.len() {
|
||||
let expanded = app.ui.actions.expanded.remove(from); app.ui.actions.expanded.insert(index, expanded);
|
||||
}
|
||||
app.ui.actions.select(index, None);
|
||||
}
|
||||
}
|
||||
Err(error) => { app.ui.status = error; app.ui.status_error = true; }
|
||||
}
|
||||
return;
|
||||
}
|
||||
Ok(None) => {}
|
||||
}
|
||||
let mut params = json!({"action": source.action, "to": to});
|
||||
if let Some(step) = source.step {
|
||||
params["step"] = json!(step);
|
||||
@@ -1802,11 +1873,20 @@ fn move_row(app: &mut PhotocraftApp, source: DragRow, to: usize) {
|
||||
/// Keep the selection and disclosure rows on the new copy after the engine edits the list.
|
||||
fn duplicate_selection(app: &mut PhotocraftApp) -> Result<Value, String> {
|
||||
if let Some(set) = selected_set(app).map(str::to_string) {
|
||||
let params = match &app.ui.actions.selected_folder {
|
||||
Some(key) => key.checked_params(app, app.session.actions.rev)?,
|
||||
None => json!({"set":set}),
|
||||
};
|
||||
let old_len = app.session.actions.list.len();
|
||||
let result = app.run("actions.duplicate", json!({"set":set}))?;
|
||||
let result = app.run("actions.duplicate", params)?;
|
||||
app.ui.actions.selected = None;
|
||||
app.ui.actions.selected_step = None;
|
||||
app.ui.actions.selected_set = result.get("set").and_then(Value::as_str).map(str::to_string);
|
||||
app.ui.actions.selected_folder = None;
|
||||
if let Some(slot) = result.get("slot").and_then(Value::as_u64).and_then(|slot| usize::try_from(slot).ok()) {
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
if let Some(row) = rows.iter().find(|row| row.slot == Some(slot)) { app.ui.actions.select_folder(FolderSelection::from_row(row)); }
|
||||
}
|
||||
let index = result.get("index").and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok()).unwrap_or(old_len);
|
||||
let count = app.session.actions.list.len().saturating_sub(old_len);
|
||||
app.ui.actions.expanded.resize(old_len, false);
|
||||
@@ -1840,6 +1920,20 @@ fn duplicate_selection(app: &mut PhotocraftApp) -> Result<Value, String> {
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn request_delete(app: &mut PhotocraftApp) -> Result<Value, String> {
|
||||
if app.ui.actions.selected.is_some() { delete_selection(app); return Ok(Value::Null); }
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
let key = if let Some(key) = &app.ui.actions.selected_folder { key.clone() } else {
|
||||
let name = selected_set(app).ok_or("Select an action folder first")?;
|
||||
let mut matches = rows.iter().filter(|row| row.name == name);
|
||||
let row = matches.next().ok_or("The selected folder no longer exists")?;
|
||||
if matches.next().is_some() { return Err("The selected folder is ambiguous".into()); }
|
||||
FolderSelection::from_row(row)
|
||||
};
|
||||
key.checked_params(app, app.session.actions.rev)?;
|
||||
modern::ask_delete(app, None, Some(key))
|
||||
}
|
||||
|
||||
fn delete_selection(app: &mut PhotocraftApp) {
|
||||
let Some(action) = app.ui.actions.selected else { return };
|
||||
let step = app.ui.actions.selected_step;
|
||||
@@ -2165,7 +2259,7 @@ fn classic_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
} else if resp.hovered() {
|
||||
ui.painter().rect_filled(rect, 0.0, t.hover.gamma_multiply(0.5));
|
||||
}
|
||||
if let Some(change) = drag_row(ui, &resp, DragRow { action: i, step: None }, &t) {
|
||||
if let Some(change) = drag_row(ui, &resp, DragRow { action: i, step: None, revision:app.session.actions.rev, origin:folder.and_then(|folder| folder.origin) }, &t) {
|
||||
moved = Some(change);
|
||||
}
|
||||
let expanded = app.ui.actions.expanded.get(i).copied().unwrap_or(false) && !button_mode;
|
||||
@@ -2234,7 +2328,7 @@ fn classic_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
}
|
||||
}
|
||||
if expanded {
|
||||
let context = StepRowsContext { action: i, x0, steps, disabled, dialogs, reveal, tokens: &t };
|
||||
let context = StepRowsContext { action: i, x0, steps, disabled, dialogs, reveal, tokens: &t, origin:folder.and_then(|folder| folder.origin) };
|
||||
let events = draw_step_rows(app, ui, &context);
|
||||
moved = moved.or(events.moved);
|
||||
toggled = toggled.or(events.toggled);
|
||||
@@ -2298,13 +2392,11 @@ fn classic_panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
if crate::icons::button(ui, "plus", 24.0, false, tl!("Create new action")).clicked() && !recording_now {
|
||||
begin_recording(app, false);
|
||||
}
|
||||
let can_delete = app.ui.actions.selected.is_some() && (!recording_now || app.ui.actions.selected_step.is_some());
|
||||
let can_delete = (app.ui.actions.selected.is_some() && (!recording_now || app.ui.actions.selected_step.is_some())) || (!recording_now && selected_set(app).is_some());
|
||||
ui.add_enabled_ui(can_delete, |ui| {
|
||||
let response = crate::icons::button(ui, "trash", 24.0, false, tl!("Delete"));
|
||||
response.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, can_delete, tl!("Delete")));
|
||||
if response.clicked() {
|
||||
delete_selection(app);
|
||||
}
|
||||
if response.clicked() && let Err(error) = request_delete(app) { app.ui.status = error; app.ui.status_error = true; }
|
||||
});
|
||||
let mode_label = if app.ui.actions.button_mode { tl!("Button Mode On") } else { tl!("Button Mode") };
|
||||
let mode_button = ui.add_enabled(!recording_now, egui::Button::new(mode_label).small()).on_hover_text(tl!("Button Mode"));
|
||||
@@ -2354,6 +2446,7 @@ struct StepRowsContext<'a> {
|
||||
dialogs: &'a std::collections::BTreeSet<usize>,
|
||||
reveal: Option<(usize, usize)>,
|
||||
tokens: &'a Tokens,
|
||||
origin: Option<(usize, usize)>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
@@ -2372,7 +2465,7 @@ fn draw_step_rows(app: &mut PhotocraftApp, ui: &mut egui::Ui, context: &StepRows
|
||||
}
|
||||
let label = step_label(id, params);
|
||||
draw_step_label(app, ui, rect, &response, step, &label, context);
|
||||
events.moved = drag_row(ui, &response, DragRow { action: context.action, step: Some(step) }, context.tokens).or(events.moved);
|
||||
events.moved = drag_row(ui, &response, DragRow { action: context.action, step: Some(step), revision:app.session.actions.rev, origin:context.origin }, context.tokens).or(events.moved);
|
||||
let (check, dialog) = draw_step_controls(ui, rect, step, &label, context);
|
||||
if check.clicked() {
|
||||
events.toggled = Some((context.action, step));
|
||||
|
||||
@@ -39,7 +39,7 @@ struct Progress {
|
||||
|
||||
enum Delete {
|
||||
Action(Box<Action>),
|
||||
Group(String, Vec<Action>, u64),
|
||||
Group(super::FolderSelection, Vec<Action>, u64),
|
||||
}
|
||||
|
||||
/// Include backend drafts and suspended playback so layout/navigation guards cannot bypass hidden owners.
|
||||
@@ -300,6 +300,7 @@ fn export(app: &mut PhotocraftApp) -> Result<Value, String> {
|
||||
struct DragAction {
|
||||
index: usize,
|
||||
source: Action,
|
||||
revision: u64,
|
||||
}
|
||||
|
||||
enum Operation {
|
||||
@@ -308,12 +309,13 @@ enum Operation {
|
||||
Play(Vec<usize>),
|
||||
Duplicate(Value),
|
||||
DeleteAction(usize),
|
||||
DeleteGroup(String),
|
||||
Assign(Box<DragAction>, String),
|
||||
DuplicateGroup(super::FolderSelection, u64),
|
||||
DeleteGroup(super::FolderSelection, u64),
|
||||
Assign(Box<DragAction>, super::FolderSelection),
|
||||
NewGroup,
|
||||
}
|
||||
|
||||
fn context(ui: &mut egui::Ui, action: Option<usize>, group: Option<&str>, play: Vec<usize>, group_mutable: bool) -> Option<Operation> {
|
||||
fn context(ui: &mut egui::Ui, action: Option<usize>, group: Option<&super::FolderSelection>, play: Vec<usize>, revision: u64) -> Option<Operation> {
|
||||
let mut operation = None;
|
||||
if ui.add_enabled(action.is_some(), egui::Button::new(tl!("Edit Action"))).clicked() {
|
||||
operation = action.map(Operation::Edit);
|
||||
@@ -325,16 +327,16 @@ fn context(ui: &mut egui::Ui, action: Option<usize>, group: Option<&str>, play:
|
||||
ui.add_enabled(false, egui::Button::new(tl!(label)));
|
||||
}
|
||||
let duplicate = if group.is_some() { tl!("Duplicate group") } else { tl!("Duplicate action") };
|
||||
if ui.add_enabled(group_mutable, egui::Button::new(duplicate)).clicked() {
|
||||
operation = Some(Operation::Duplicate(match group {
|
||||
Some(group) => json!({"set":group}),
|
||||
None => json!({"action":action}),
|
||||
}));
|
||||
if ui.button(duplicate).clicked() {
|
||||
operation = Some(match group {
|
||||
Some(group) => Operation::DuplicateGroup(group.clone(), revision),
|
||||
None => Operation::Duplicate(json!({"action":action})),
|
||||
});
|
||||
}
|
||||
let delete = if group.is_some() { tl!("Delete group") } else { tl!("Delete action") };
|
||||
if ui.add_enabled(group_mutable, egui::Button::new(delete)).clicked() {
|
||||
if ui.button(delete).clicked() {
|
||||
operation = match group {
|
||||
Some(group) => Some(Operation::DeleteGroup(group.into())),
|
||||
Some(group) => Some(Operation::DeleteGroup(group.clone(), revision)),
|
||||
None => action.map(Operation::DeleteAction),
|
||||
};
|
||||
}
|
||||
@@ -369,7 +371,7 @@ fn action_row(app: &mut PhotocraftApp, ui: &mut egui::Ui, index: usize, action:
|
||||
operation = Some(Operation::Play(vec![index]));
|
||||
}
|
||||
if tile.drag_started() {
|
||||
tile.dnd_set_drag_payload(DragAction { index, source: action.clone() });
|
||||
tile.dnd_set_drag_payload(DragAction { index, source: action.clone(), revision:app.session.actions.rev });
|
||||
}
|
||||
let name = ui
|
||||
.add_sized(vec2((ui.available_width() - 60.0).max(20.0), size), egui::Button::new(&action.name).frame(false).sense(Sense::click_and_drag()))
|
||||
@@ -379,18 +381,18 @@ fn action_row(app: &mut PhotocraftApp, ui: &mut egui::Ui, index: usize, action:
|
||||
operation = Some(Operation::Play(vec![index]));
|
||||
}
|
||||
if name.drag_started() {
|
||||
name.dnd_set_drag_payload(DragAction { index, source: action.clone() });
|
||||
name.dnd_set_drag_payload(DragAction { index, source: action.clone(), revision:app.session.actions.rev });
|
||||
}
|
||||
if (hovered || app.ui.actions.selected == Some(index)) && icons::button(ui, "settings", 24.0, false, tl!("Edit action")).clicked() {
|
||||
operation = Some(Operation::Edit(index));
|
||||
}
|
||||
let menu = icons::button(ui, "ellipsis", 24.0, false, tl!("Actions"));
|
||||
egui::Popup::menu(&menu).show(|ui| {
|
||||
operation = context(ui, Some(index), None, vec![index], true).or(operation.take());
|
||||
operation = context(ui, Some(index), None, vec![index], app.session.actions.rev).or(operation.take());
|
||||
});
|
||||
});
|
||||
row.response.context_menu(|ui| {
|
||||
operation = context(ui, Some(index), None, vec![index], true).or(operation.take());
|
||||
operation = context(ui, Some(index), None, vec![index], app.session.actions.rev).or(operation.take());
|
||||
});
|
||||
operation
|
||||
}
|
||||
@@ -462,8 +464,6 @@ pub(super) fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
ranks.get(folder.name.as_str()).copied().unwrap_or(usize::MAX),
|
||||
));
|
||||
}
|
||||
let mut occurrences = std::collections::HashMap::new();
|
||||
for folder in &folders { *occurrences.entry(folder.name.as_str()).or_insert(0usize) += 1; }
|
||||
app.ui.actions.collapsed_folders.retain(|key| folders.iter().any(|row| key.matches(row)));
|
||||
if app.ui.actions.selected_folder.as_ref().is_some_and(|key| !folders.iter().any(|row| key.matches(row))) {
|
||||
app.ui.actions.selected_folder = None;
|
||||
@@ -488,9 +488,6 @@ pub(super) fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
}
|
||||
let key = super::FolderSelection::from_row(folder);
|
||||
let collapsed = app.ui.actions.folder_collapsed(&key);
|
||||
// The existing group mutation commands accept a logical caption. Until the
|
||||
// serialized slot-selector extension lands, they cannot mutate one namesake.
|
||||
let group_mutable = occurrences.get(group.as_str()) == Some(&1);
|
||||
ui.push_id(("modern-physical-folder", key.origin, key.slot, group), |ui| {
|
||||
let header = ui.horizontal(|ui| {
|
||||
if icons::button(ui, if collapsed { "chevron-right" } else { "chevron-down" }, 20.0, false, group).clicked() {
|
||||
@@ -502,14 +499,14 @@ pub(super) fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
}
|
||||
let menu = icons::button(ui, "ellipsis", 24.0, false, tl!("Actions"));
|
||||
egui::Popup::menu(&menu).show(|ui| {
|
||||
operation = context(ui, None, Some(group), members.clone(), group_mutable).or(operation.take());
|
||||
operation = context(ui, None, Some(&key), members.clone(), app.session.actions.rev).or(operation.take());
|
||||
});
|
||||
});
|
||||
if group_mutable && let Some(drag) = header.response.dnd_release_payload::<DragAction>() {
|
||||
operation = Some(Operation::Assign(Box::new((*drag).clone()), group.clone()));
|
||||
if let Some(drag) = header.response.dnd_release_payload::<DragAction>() {
|
||||
operation = Some(Operation::Assign(Box::new((*drag).clone()), key.clone()));
|
||||
}
|
||||
header.response.context_menu(|ui| {
|
||||
operation = context(ui, None, Some(group), members.clone(), group_mutable).or(operation.take());
|
||||
operation = context(ui, None, Some(&key), members.clone(), app.session.actions.rev).or(operation.take());
|
||||
});
|
||||
if !collapsed || !query.is_empty() {
|
||||
for &index in members {
|
||||
@@ -530,20 +527,24 @@ pub(super) fn panel(app: &mut PhotocraftApp, ui: &mut egui::Ui) {
|
||||
});
|
||||
if let Some(operation) = operation {
|
||||
let result = match operation {
|
||||
Operation::New => {
|
||||
let set = app.ui.actions.selected_set.clone();
|
||||
open(app, json!({"set":set}))
|
||||
}
|
||||
Operation::New => super::new_action_params(app).and_then(|params| open(app, params)),
|
||||
Operation::Edit(index) => open(app, json!({"action":index})),
|
||||
Operation::Play(indices) => start_library(app, &indices),
|
||||
Operation::Duplicate(params) => app.run("actions.duplicate", params),
|
||||
Operation::DeleteAction(index) => ask_delete(app, Some(index), None),
|
||||
Operation::DeleteGroup(group) => ask_delete(app, None, Some(group)),
|
||||
Operation::DuplicateGroup(group, revision) => group.checked_params(app, revision).and_then(|params| app.run("actions.duplicate", params)),
|
||||
Operation::DeleteGroup(group, revision) => group.checked_params(app, revision).and_then(|_| ask_delete(app, None, Some(group))),
|
||||
Operation::Assign(drag, group) => {
|
||||
if app.session.actions.list.get(drag.index) != Some(&drag.source) {
|
||||
if app.session.actions.rev != drag.revision || app.session.actions.list.get(drag.index).is_none_or(|value|
|
||||
value != &drag.source || !actions_cmds::library::same_placement(value, &drag.source)) {
|
||||
Err(tl!("The dragged action changed; drag it again").into())
|
||||
} else {
|
||||
app.run("actions.assignSet", json!({"action":drag.index,"set":group}))
|
||||
group.checked_params(app, drag.revision).and_then(|mut params| {
|
||||
params["action"] = json!(drag.index);
|
||||
app.run("actions.assignSet", params).inspect(|result| {
|
||||
if let Some(index) = result.get("index").and_then(Value::as_u64).and_then(|index| usize::try_from(index).ok()) { app.ui.actions.select(index, None); }
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
Operation::NewGroup => new_group(app),
|
||||
@@ -729,7 +730,7 @@ fn tick_with_quantum(app: &mut PhotocraftApp, ctx: &egui::Context, quantum: usiz
|
||||
}
|
||||
ctx.request_repaint();
|
||||
} else {
|
||||
let indices: Option<Vec<_>> = task.then.iter().map(|action| app.session.actions.list.iter().position(|current| current == action)).collect();
|
||||
let indices: Option<Vec<_>> = task.then.iter().map(|action| app.session.actions.list.iter().position(|current| current == action && actions_cmds::library::same_placement(current, action))).collect();
|
||||
let result = indices.ok_or("A group action changed during playback".to_string()).and_then(|indices| start_library(app, &indices));
|
||||
if result.is_err() {
|
||||
app.actions_runtime.progress = None;
|
||||
@@ -832,7 +833,7 @@ pub(crate) fn owns_delete(fields: &serde_json::Map<String, Value>) -> bool {
|
||||
}
|
||||
|
||||
/// Capture the selected definition or group revision and authorization gate before opening its delete question.
|
||||
fn ask_delete(app: &mut PhotocraftApp, index: Option<usize>, group: Option<String>) -> Result<Value, String> {
|
||||
pub(super) fn ask_delete(app: &mut PhotocraftApp, index: Option<usize>, group: Option<super::FolderSelection>) -> Result<Value, String> {
|
||||
if app.actions_runtime.delete.is_some() {
|
||||
return Err("Answer the open delete question first".into());
|
||||
}
|
||||
@@ -841,19 +842,13 @@ fn ask_delete(app: &mut PhotocraftApp, index: Option<usize>, group: Option<Strin
|
||||
}
|
||||
let (target, message) = match group {
|
||||
Some(group) => {
|
||||
if !photocraft_engine::actions_edit_cmds::set_names(&app.session).contains(&group) {
|
||||
return Err("The selected group no longer exists".into());
|
||||
}
|
||||
let members = app
|
||||
.session
|
||||
.actions
|
||||
.list
|
||||
.iter()
|
||||
.filter(|action| photocraft_engine::atn_cmds::logical_set_name(action.set.as_deref()) == group)
|
||||
.cloned()
|
||||
.collect();
|
||||
let message = crate::i18n::fmt(tl!("Delete the group \"{name}\"?"), &[("name", &group)]);
|
||||
(Delete::Group(group, members, app.session.actions.rev), message)
|
||||
let revision = app.session.actions.rev;
|
||||
group.checked_params(app, revision)?;
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
let row = rows.iter().find(|row| group.matches(row)).ok_or("The selected group no longer exists")?;
|
||||
let members = row.actions.iter().filter_map(|&index| app.session.actions.list.get(index).cloned()).collect();
|
||||
let message = crate::i18n::fmt(tl!("Delete the group \"{name}\"?"), &[("name", &group.name)]);
|
||||
(Delete::Group(group, members, revision), message)
|
||||
}
|
||||
None => {
|
||||
let action = index.and_then(|index| app.session.actions.list.get(index)).cloned().ok_or("The selected action no longer exists")?;
|
||||
@@ -887,28 +882,27 @@ pub(crate) fn delete_confirm(app: &mut PhotocraftApp, fields: &serde_json::Map<S
|
||||
if fields.get(DELETE).and_then(Value::as_u64) != Some(id) {
|
||||
return Err("The delete question has changed".into());
|
||||
}
|
||||
let mut removed = Vec::new();
|
||||
let params = match target {
|
||||
Delete::Action(action) => {
|
||||
let mut matches = app.session.actions.list.iter().enumerate().filter(|(_, current)| *current == action.as_ref()).map(|(index, _)| index);
|
||||
let mut matches = app.session.actions.list.iter().enumerate().filter(|(_, current)| *current == action.as_ref() && actions_cmds::library::same_placement(current, &action)).map(|(index, _)| index);
|
||||
let index = matches.next().ok_or("The selected action changed; select it again")?;
|
||||
if matches.next().is_some() {
|
||||
return Err("The selected action is ambiguous".into());
|
||||
}
|
||||
removed.push(index);
|
||||
json!({"action":index})
|
||||
}
|
||||
Delete::Group(group, members, revision) => {
|
||||
let current: Vec<_> = app
|
||||
.session
|
||||
.actions
|
||||
.list
|
||||
.iter()
|
||||
.filter(|action| photocraft_engine::atn_cmds::logical_set_name(action.set.as_deref()) == group)
|
||||
.cloned()
|
||||
.collect();
|
||||
if app.session.actions.rev != revision || current != members || !photocraft_engine::actions_edit_cmds::set_names(&app.session).contains(&group) {
|
||||
let params = group.checked_params(app, revision)?;
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session)?;
|
||||
let row = rows.iter().find(|row| group.matches(row)).ok_or("The selected group changed; select it again")?;
|
||||
removed = row.actions.clone();
|
||||
let current: Vec<_> = row.actions.iter().filter_map(|&index| app.session.actions.list.get(index)).collect();
|
||||
if current.len() != members.len() || current.iter().zip(&members).any(|(current, old)| *current != old || !actions_cmds::library::same_placement(current, old)) {
|
||||
return Err("The selected group changed; select it again".into());
|
||||
}
|
||||
json!({"set":group})
|
||||
params
|
||||
}
|
||||
};
|
||||
let saved = app.session.authorize;
|
||||
@@ -916,9 +910,13 @@ pub(crate) fn delete_confirm(app: &mut PhotocraftApp, fields: &serde_json::Map<S
|
||||
let result = app.run("actions.delete", params);
|
||||
app.session.authorize = saved;
|
||||
if result.is_ok() {
|
||||
for &index in removed.iter().rev() {
|
||||
if index < app.ui.actions.expanded.len() { app.ui.actions.expanded.remove(index); }
|
||||
}
|
||||
app.ui.actions.selected = None;
|
||||
app.ui.actions.selected_step = None;
|
||||
app.ui.actions.selected_set = None;
|
||||
app.ui.actions.selected_folder = None;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
@@ -236,7 +236,9 @@ fn delete_confirmation_is_one_use_and_rejects_a_changed_target() {
|
||||
fn empty_group_delete_question_rejects_a_changed_library_revision() {
|
||||
let mut app = app();
|
||||
app.run("actions.newSet", json!({"name":"Empty"})).unwrap();
|
||||
let id = ask_delete(&mut app, None, Some("Empty".into())).unwrap()["dialog"].as_u64().unwrap();
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
let empty = super::super::FolderSelection::from_row(rows.iter().find(|row| row.name == "Empty").unwrap());
|
||||
let id = ask_delete(&mut app, None, Some(empty)).unwrap()["dialog"].as_u64().unwrap();
|
||||
app.run("actions.newSet", json!({"name":"Later"})).unwrap();
|
||||
assert!(crate::dialogs::confirm(&mut app, id).is_err());
|
||||
assert!(photocraft_engine::actions_edit_cmds::set_names(&app.session).contains(&"Empty".to_string()));
|
||||
@@ -506,3 +508,28 @@ fn canonical_ungrouped_category_keeps_classic_loose_rows_flat_and_order_stable()
|
||||
h.run_steps(3);
|
||||
assert!(h.query_all_by_label(photocraft_engine::atn_cmds::UNGROUPED_SET).any(|node| node.rect().width() > 24.0));
|
||||
}
|
||||
|
||||
|
||||
/// The real Modern New entry point retains its selected occurrence through backend Save/delete.
|
||||
#[test]
|
||||
fn modern_new_draft_and_delete_question_keep_selected_namesake() {
|
||||
let mut app = app();
|
||||
for _ in 0..2 { app.session.execute("actions.reset",json!({"mode":"append","confirm":true})).unwrap(); }
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
app.ui.actions.select_folder(super::super::FolderSelection::from_row(&rows[1]));
|
||||
let mut h = harness(app);
|
||||
h.get_by_label("Create new action").click();
|
||||
h.run_steps(3);
|
||||
let id = h.state().session.actions.editor.as_ref().unwrap().id();
|
||||
h.state_mut().run("actions.editor.update",json!({"draft":id,"description":"Modern selected row"})).unwrap();
|
||||
h.state_mut().run("actions.editor.save",json!({"draft":id})).unwrap();
|
||||
h.state_mut().run("actions.editor.discard",json!({"draft":id})).unwrap();
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&h.state().session).unwrap();
|
||||
assert_eq!(rows.iter().map(|row| row.actions.len()).collect::<Vec<_>>(),[2,3]);
|
||||
let target = super::super::FolderSelection::from_row(&rows[1]);
|
||||
let dialog = ask_delete(h.state_mut(),None,Some(target)).unwrap()["dialog"].as_u64().unwrap();
|
||||
crate::dialogs::confirm(h.state_mut(),dialog).unwrap();
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&h.state().session).unwrap();
|
||||
assert_eq!(rows.len(),1);
|
||||
assert_eq!(rows[0].actions.len(),2);
|
||||
}
|
||||
@@ -1784,13 +1784,16 @@ fn moving_an_action_next_to_another_set_joins_it() {
|
||||
app.session.actions.list.push(b);
|
||||
app.session.actions.list.push(Action::new("C", vec![]));
|
||||
// C dropped below B: it joins B's set, "Two".
|
||||
move_row(&mut app, DragRow { action: 2, step: None }, 2);
|
||||
let drag = DragRow { action: 2, step: None, revision:app.session.actions.rev, origin:None };
|
||||
move_row(&mut app, drag, 2);
|
||||
assert_eq!(app.session.actions.list[2].set.as_deref(), Some("Two"));
|
||||
// B dropped to the top, above A: the row below decides when there is none above.
|
||||
move_row(&mut app, DragRow { action: 1, step: None }, 0);
|
||||
let drag = DragRow { action: 1, step: None, revision:app.session.actions.rev, origin:None };
|
||||
move_row(&mut app, drag, 0);
|
||||
assert_eq!((app.session.actions.list[0].name.as_str(), app.session.actions.list[0].set.as_deref()), ("B", Some("One")));
|
||||
// C dropped between A (One) and nothing: the row above wins.
|
||||
move_row(&mut app, DragRow { action: 2, step: None }, 2);
|
||||
let drag = DragRow { action: 2, step: None, revision:app.session.actions.rev, origin:None };
|
||||
move_row(&mut app, drag, 2);
|
||||
assert_eq!((app.session.actions.list[2].name.as_str(), app.session.actions.list[2].set.as_deref()), ("C", Some("One")));
|
||||
}
|
||||
|
||||
@@ -3056,3 +3059,44 @@ fn bulk_load_contents_budget_does_not_limit_native_paths() {
|
||||
assert!(!app.ui.status_error, "{}", app.ui.status);
|
||||
assert_eq!(app.session.actions.list[0].name, "From disk");
|
||||
}
|
||||
|
||||
|
||||
/// Classic recorder, Duplicate and Delete dispatch the selected occurrence's current slot.
|
||||
#[test]
|
||||
fn classic_physical_folder_adapters_keep_new_record_copy_and_delete_local() {
|
||||
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
|
||||
app.background_jobs = false;
|
||||
app.run("file.new",json!({"width":8,"height":8})).unwrap();
|
||||
for _ in 0..2 { app.session.execute("actions.reset",json!({"mode":"append","confirm":true})).unwrap(); }
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
app.ui.actions.collapsed_folders = rows.iter().map(FolderSelection::from_row).collect();
|
||||
app.ui.actions.select_folder(FolderSelection::from_row(&rows[1]));
|
||||
begin_recording(&mut app,false);
|
||||
assert_eq!(app.ui.actions.collapsed_folders.len(),1,"recording reveals only its actual folder");
|
||||
app.run("actions.stop",json!({})).unwrap();
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
assert_eq!(rows.iter().map(|row| row.actions.len()).collect::<Vec<_>>(),[2,3]);
|
||||
app.ui.actions.select_folder(FolderSelection::from_row(&rows[0]));
|
||||
duplicate_selection(&mut app).unwrap();
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
assert_eq!(rows.iter().map(|row| row.actions.len()).collect::<Vec<_>>(),[2,2,3]);
|
||||
let dialog = request_delete(&mut app).unwrap()["dialog"].as_u64().unwrap();
|
||||
crate::dialogs::confirm(&mut app,dialog).unwrap();
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
assert_eq!(rows.iter().map(|row| row.actions.len()).collect::<Vec<_>>(),[2,3]);
|
||||
assert_eq!(rows[0].name,rows[1].name,"the two original namesakes remain");
|
||||
}
|
||||
|
||||
/// A delayed Classic drag refuses a same-caption replacement before any move or assignment.
|
||||
#[test]
|
||||
fn classic_physical_drag_refuses_changed_revision_without_partial_reorder() {
|
||||
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default());
|
||||
for _ in 0..2 { app.session.execute("actions.reset",json!({"mode":"append","confirm":true})).unwrap(); }
|
||||
let rows = photocraft_engine::actions_edit_cmds::set_occurrences(&app.session).unwrap();
|
||||
let drag = DragRow { action:2,step:None,revision:app.session.actions.rev,origin:rows[1].origin };
|
||||
app.session.execute("actions.reset",json!({"mode":"replace","confirm":true})).unwrap();
|
||||
let definitions = app.session.actions.list.clone();
|
||||
move_row(&mut app,drag,0);
|
||||
assert!(app.ui.status_error);
|
||||
assert_eq!(app.session.actions.list,definitions);
|
||||
}
|
||||
@@ -674,6 +674,16 @@ matches an existing folder. The warning's OK replaces the library; Append adds t
|
||||
Edit > Undo Reset Actions restores only the latest unchanged Reset's definitions and both
|
||||
shortcut maps, independently of document History and active recording/playback state.
|
||||
|
||||
The existing record, new-draft Open, Assign Set, Duplicate, Delete and Save commands accept
|
||||
`setSlot` to select one current physical folder; an optional `set` must match its exact current
|
||||
caption. A bare slot is current-state selection, not a stable identifier. The panel retains
|
||||
revision and row origin across delayed operations. Set-only calls keep logical caption-wide
|
||||
behavior. Physical creation and assignment use contiguous blocks and preserve numeric Play
|
||||
and Conditional targets; unrepresentable order or a changed first-name target is refused
|
||||
before publication. Destination placement does not replace raw action/event provenance or
|
||||
change logical `Action` equality. New-draft Save retains its opening destination and publishes
|
||||
only validated definitions and intended shortcut maps.
|
||||
|
||||
`actions.insertPath` snapshots the exact selected work, layer or saved path as a native
|
||||
`path.set` work-path step, retaining cubic controls, operations, fill rule and inversion.
|
||||
The measured Photoshop `set`/`WrPt` descriptor mapping represents non-inverted, even-odd-fill
|
||||
|
||||
Reference in new issue
Block a user