Files
chasse20 0ff72b0d46 Auto: Revert export additions and evaluate brush pickup by tile
Remove DDS encoding, its dependency, export options, tests and documentation. Revert the MaterialX export-dialog option and preview additions while retaining engine export support.

Evaluate material-brush and mask Clone/Smudge pickup on demand. Give mask preview and commit an explicit value image. Sample the document in solo mode and avoid redundant export cache invalidation.

Validate saved decal axes, stencil settings and smudge strength. Bound smart-mask reads, write masks atomically and reject external anchor references. Clear stale clone sources on cross-set selection. Reject moves into another set’s folder and use layer positions to detect no-op moves without cloning the project again.

Load saved materials on shelf click and route pinch gestures to viewport zoom. Add regression tests for the affected behaviors.
2026-11-18 05:20:25 +00:00

526 lines
24 KiB
Rust

//! Several selected layers, as in the reference app: Shift+click selects a range of rows,
//! Ctrl/Cmd+click adds or takes out one layer, and remove, duplicate, group, visibility and move
//! act on every selected layer in one undo step.
use serde_json::{Value, json};
use texturecraft_engine::core::{LayerId, LayerKind};
use texturecraft_engine::geom::primitives;
use texturecraft_engine::layer_selection::stack_rows;
use texturecraft_engine::{Session, execute};
fn session() -> Session {
Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 256).unwrap()
}
fn id(v: Value, key: &str) -> LayerId {
LayerId(v[key].as_u64().unwrap())
}
fn add(s: &mut Session, name: &str) -> LayerId {
id(execute(s, "layer.add.paint", &json!({ "name": name })).unwrap(), "layer")
}
/// Paint layers A (bottom) to D (top) on texture set 0, D selected.
fn four(s: &mut Session) -> [LayerId; 4] {
execute(s, "textureSet.select", &json!({"ts": 0})).unwrap();
[add(s, "A"), add(s, "B"), add(s, "C"), add(s, "D")]
}
/// The names of set 0's rows from the top (folder contents included).
fn rows(s: &Session) -> Vec<String> {
stack_rows(&s.doc.project, 0, false).iter().map(|id| s.doc.project.layer(*id).unwrap().name.clone()).collect()
}
fn names(s: &Session, ids: &[LayerId]) -> Vec<String> {
ids.iter().map(|id| s.doc.project.layer(*id).unwrap().name.clone()).collect()
}
fn selected(s: &Session) -> Vec<String> {
names(s, &s.selected_layers())
}
fn click(s: &mut Session, layer: LayerId, how: &str) {
let params = match how {
"shift" => json!({"layer": layer.0, "range": true}),
"ctrl" => json!({"layer": layer.0, "toggle": true}),
_ => json!({"layer": layer.0}),
};
execute(s, "layer.select", &params).unwrap();
}
#[test]
fn shift_click_selects_the_rows_from_the_last_clicked_layer() {
let mut s = session();
let [a, b, _, d] = four(&mut s);
click(&mut s, b, "plain");
click(&mut s, d, "shift");
assert_eq!(selected(&s), ["D", "C", "B"]);
assert_eq!(s.selected_layer(), Some(d), "the clicked layer is the active one");
// The range still starts at B, not at the active D
click(&mut s, a, "shift");
assert_eq!(selected(&s), ["B", "A"]);
assert_eq!(s.selected_layer(), Some(a));
assert_eq!(texturecraft_engine::inspect::session(&s)["selectedLayers"], json!([b.0, a.0]));
// A plain click selects one layer again
click(&mut s, d, "plain");
assert_eq!(selected(&s), ["D"]);
}
#[test]
fn ctrl_click_adds_and_takes_out_one_layer() {
let mut s = session();
let [a, _, c, _] = four(&mut s);
click(&mut s, a, "plain");
click(&mut s, c, "ctrl");
assert_eq!(selected(&s), ["C", "A"]);
assert_eq!(s.selected_layer(), Some(c));
click(&mut s, c, "ctrl");
assert_eq!(selected(&s), ["A"], "a second Ctrl+click takes the layer out");
assert_eq!(s.selected_layer(), Some(a), "the remaining layer becomes the active one");
click(&mut s, a, "ctrl");
assert!(selected(&s).is_empty(), "Ctrl+click on the only selected layer leaves an empty selection");
assert_eq!(s.selected_layer(), None);
// The next Shift+click has no anchor and starts over at the clicked layer
click(&mut s, c, "shift");
assert_eq!(selected(&s), ["C"]);
click(&mut s, a, "ctrl");
assert_eq!(selected(&s), ["C", "A"]);
}
#[test]
fn ctrl_click_on_another_selected_layer_keeps_the_active_one_and_the_range_start() {
let mut s = session();
let [a, b, c, d] = four(&mut s);
click(&mut s, b, "plain");
click(&mut s, d, "shift");
click(&mut s, c, "ctrl");
assert_eq!(selected(&s), ["D", "B"]);
assert_eq!(s.selected_layer(), Some(d), "D stays the active layer");
click(&mut s, a, "shift");
assert_eq!(selected(&s), ["B", "A"], "the range still starts at B");
}
#[test]
fn a_range_covers_the_shown_rows_only() {
let mut s = session();
let [a, b, c, d] = four(&mut s);
execute(&mut s, "layer.select", &json!({"layers": [b.0, c.0]})).unwrap();
let folder = id(execute(&mut s, "layer.group", &Value::Null).unwrap(), "layer");
assert_eq!(rows(&s)[..5], ["D", "Folder 1", "C", "B", "A"]);
click(&mut s, d, "plain");
click(&mut s, a, "shift");
assert_eq!(selected(&s), ["D", "Folder 1", "C", "B", "A"], "an open folder's layers are in the range");
if let LayerKind::Group { collapsed, .. } = &mut s.doc.project.layer_mut(folder).unwrap().kind {
*collapsed = true;
}
click(&mut s, d, "plain");
click(&mut s, a, "shift");
assert_eq!(selected(&s), ["D", "Folder 1", "A"], "a collapsed folder's layers are not");
}
#[test]
fn another_selected_layer_ends_the_multiple_selection() {
let mut s = session();
let [a, _, c, _] = four(&mut s);
click(&mut s, a, "plain");
click(&mut s, c, "ctrl");
add(&mut s, "E");
assert_eq!(selected(&s), ["E"], "a new layer is selected alone");
}
#[test]
fn delete_removes_every_selected_layer_in_one_undo_step() {
let mut s = session();
let [a, b, _, d] = four(&mut s);
execute(&mut s, "layer.select", &json!({"layers": [b.0, d.0]})).unwrap();
let depth = s.history_labels().len();
let r = execute(&mut s, "layer.remove", &Value::Null).unwrap();
assert_eq!(r["removed"], json!([d.0, b.0]));
assert_eq!(rows(&s)[..2], ["C", "A"]);
assert_eq!(selected(&s), ["A"], "the layer under the lowest removed one is selected");
assert_eq!(s.selected_layer(), Some(a));
assert_eq!(s.history_labels().len(), depth + 1, "one undo step");
s.undo().unwrap();
assert_eq!(rows(&s)[..4], ["D", "C", "B", "A"]);
}
#[test]
fn a_folder_and_its_own_layer_selected_remove_together() {
let mut s = session();
let [a, b, _, _] = four(&mut s);
let folder = id(execute(&mut s, "layer.group", &json!({"layer": b.0})).unwrap(), "layer");
execute(&mut s, "layer.select", &json!({"layers": [folder.0, b.0, a.0]})).unwrap();
execute(&mut s, "layer.remove", &Value::Null).unwrap();
assert_eq!(rows(&s)[..2], ["D", "C"]);
assert!(s.doc.project.layer(b).is_err() && s.doc.project.layer(a).is_err());
}
#[test]
fn duplicate_puts_the_copies_in_one_block_above_the_topmost_selected_layer() {
let mut s = session();
let [_, b, _, d] = four(&mut s);
execute(&mut s, "layer.select", &json!({"layers": [d.0, b.0], "layer": b.0})).unwrap();
execute(&mut s, "layer.duplicate", &Value::Null).unwrap();
assert_eq!(rows(&s)[..6], ["D copy", "B copy", "D", "C", "B", "A"], "the block sits directly above D, in stack order");
assert_eq!(selected(&s), ["D copy", "B copy"], "the copies are selected");
assert_eq!(names(&s, &[s.selected_layer().unwrap()]), ["B copy"], "the active layer's copy is the active one");
s.undo().unwrap();
assert_eq!(rows(&s)[..4], ["D", "C", "B", "A"]);
}
#[test]
fn duplicate_block_lands_at_the_topmost_layers_level_also_for_a_layer_from_a_folder() {
let mut s = session();
let [a, _, c, _] = four(&mut s);
let folder = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [a.0], "above": folder.0, "inside": true})).unwrap();
assert_eq!(rows(&s)[..5], ["Folder 1", "A", "D", "C", "B"]);
// The topmost selected row is A, inside the folder, so the block goes there
execute(&mut s, "layer.select", &json!({"layers": [c.0, a.0]})).unwrap();
execute(&mut s, "layer.duplicate", &Value::Null).unwrap();
assert_eq!(rows(&s)[..7], ["Folder 1", "A copy", "C copy", "A", "D", "C", "B"]);
assert_eq!(selected(&s), ["A copy", "C copy"], "the copies are the selection");
}
#[test]
fn duplicate_of_a_root_layer_and_a_folder_layer_with_the_root_one_higher() {
let mut s = session();
let [a, b, _, d] = four(&mut s);
let folder = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [a.0], "above": folder.0, "inside": true})).unwrap();
execute(&mut s, "layer.move", &json!({"layers": [folder.0], "above": b.0})).unwrap();
// Rows from the top: D, C, Folder 1 (A), B... select D (root, topmost) and A (in the folder)
assert_eq!(rows(&s)[..5], ["D", "C", "Folder 1", "A", "B"]);
execute(&mut s, "layer.select", &json!({"layers": [d.0, a.0]})).unwrap();
execute(&mut s, "layer.duplicate", &Value::Null).unwrap();
assert_eq!(rows(&s)[..4], ["D copy", "A copy", "D", "C"], "the block is at the root, above D");
}
#[test]
fn group_puts_the_selected_layers_into_one_folder_in_their_order() {
let mut s = session();
let [a, _, c, _] = four(&mut s);
execute(&mut s, "layer.select", &json!({"layers": [a.0, c.0]})).unwrap();
let folder = id(execute(&mut s, "layer.group", &Value::Null).unwrap(), "layer");
assert_eq!(rows(&s)[..5], ["D", "Folder 1", "C", "A", "B"], "the folder takes the top layer's place");
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [a, c], "bottom to top inside the folder");
assert_eq!(s.selected_layers(), [folder]);
s.undo().unwrap();
assert_eq!(rows(&s)[..4], ["D", "C", "B", "A"]);
}
#[test]
fn group_puts_the_folder_at_the_topmost_selected_layer_with_gaps_between() {
let mut s = session();
execute(&mut s, "textureSet.select", &json!({"ts": 0})).unwrap();
let [l1, l2, l3, l4, l5] = ["L1", "L2", "L3", "L4", "L5"].map(|n| add(&mut s, n));
execute(&mut s, "layer.select", &json!({"layers": [l2.0, l4.0]})).unwrap();
let folder = id(execute(&mut s, "layer.group", &Value::Null).unwrap(), "layer");
assert_eq!(rows(&s)[..6], ["L5", "Folder 1", "L4", "L2", "L3", "L1"], "the folder sits where L4 was, L3 stays below it");
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [l2, l4], "L2 stays below L4 inside");
let stack = &s.doc.project.texture_sets[0].stack;
assert_eq!(stack[stack.len() - 4..], [l1, l3, folder, l5], "L5 stays above the folder");
// Same result when the layers are picked in the other order
s.undo().unwrap();
execute(&mut s, "layer.select", &json!({"layers": [l4.0, l2.0]})).unwrap();
execute(&mut s, "layer.group", &Value::Null).unwrap();
assert_eq!(rows(&s)[..6], ["L5", "Folder 1", "L4", "L2", "L3", "L1"]);
}
#[test]
fn group_of_a_layer_inside_a_folder_and_one_outside_keeps_the_topmost_place() {
let mut s = session();
execute(&mut s, "textureSet.select", &json!({"ts": 0})).unwrap();
let [x, y, z] = ["X", "Y", "Z"].map(|n| add(&mut s, n));
let outer = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [y.0, z.0], "above": outer.0, "inside": true})).unwrap();
// Rows from the top: Folder 1 (Z, Y), X
assert_eq!(rows(&s)[..4], ["Folder 1", "Z", "Y", "X"]);
// The topmost selected layer Z is inside the folder: the new folder replaces it there
execute(&mut s, "layer.select", &json!({"layers": [z.0, x.0]})).unwrap();
let folder = id(execute(&mut s, "layer.group", &Value::Null).unwrap(), "layer");
assert_eq!(rows(&s)[..5], ["Folder 1", "Folder 2", "Z", "X", "Y"]);
assert_eq!(s.doc.project.layer(outer).unwrap().children(), [y, folder], "Z's place in the outer folder");
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [x, z], "X keeps its place below Z");
s.undo().unwrap();
assert_eq!(rows(&s)[..4], ["Folder 1", "Z", "Y", "X"]);
// X is outside and Y inside: Y is the topmost, so the folder appears inside the outer folder
execute(&mut s, "layer.select", &json!({"layers": [x.0, y.0]})).unwrap();
let folder = id(execute(&mut s, "layer.group", &Value::Null).unwrap(), "layer");
assert_eq!(rows(&s)[..5], ["Folder 1", "Z", "Folder 2", "Y", "X"]);
assert_eq!(s.doc.project.texture_sets[0].stack.last(), Some(&outer), "the outer folder stays on top");
assert_eq!(s.doc.project.layer(outer).unwrap().children(), [folder, z]);
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [x, y]);
}
#[test]
fn group_with_the_topmost_layer_at_the_root_takes_the_folder_layer_out_of_its_folder() {
let mut s = session();
execute(&mut s, "textureSet.select", &json!({"ts": 0})).unwrap();
let [_x, fa, fb] = ["X", "Fill A", "Fill B"].map(|n| add(&mut s, n));
let outer = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [fa.0, fb.0], "above": outer.0, "inside": true})).unwrap();
// Folder 1 (Fill B, Fill A) at the root above X; add Fill 3 above the folder
let f3 = add(&mut s, "Fill 3");
execute(&mut s, "layer.move", &json!({"layers": [f3.0], "above": outer.0})).unwrap();
assert_eq!(rows(&s)[..5], ["Fill 3", "Folder 1", "Fill B", "Fill A", "X"]);
execute(&mut s, "layer.select", &json!({"layers": [f3.0, fa.0]})).unwrap();
let folder = id(execute(&mut s, "layer.group", &Value::Null).unwrap(), "layer");
assert_eq!(rows(&s)[..6], ["Folder 2", "Fill 3", "Fill A", "Folder 1", "Fill B", "X"], "the new folder is at the root slot of Fill 3");
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [fa, f3], "stack order inside: the folder's own layer is lower");
assert_eq!(s.doc.project.layer(outer).unwrap().children(), [fb], "Fill A left its folder");
}
#[test]
fn shift_range_counts_the_folder_row_and_skips_the_layers_of_a_collapsed_folder() {
let mut s = session();
let [a, b, c, d] = four(&mut s);
let folder = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [b.0, c.0], "above": folder.0, "inside": true})).unwrap();
// Rows from the top: Folder 1 (C, B), D, A... move the folder between D and A
execute(&mut s, "layer.move", &json!({"layers": [folder.0], "above": a.0})).unwrap();
assert_eq!(rows(&s)[..5], ["D", "Folder 1", "C", "B", "A"]);
click(&mut s, d, "plain");
click(&mut s, a, "shift");
assert_eq!(selected(&s), ["D", "Folder 1", "C", "B", "A"], "an open folder: the row and its layers");
if let LayerKind::Group { collapsed, .. } = &mut s.doc.project.layer_mut(folder).unwrap().kind {
*collapsed = true;
}
click(&mut s, d, "plain");
click(&mut s, a, "shift");
assert_eq!(selected(&s), ["D", "Folder 1", "A"], "a collapsed folder: the row, not its layers");
}
#[test]
fn select_all_takes_the_folder_rows_and_the_layers_of_open_folders_only() {
let mut s = session();
let [a, b, c, d] = four(&mut s);
let folder = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [a.0, b.0], "above": folder.0, "inside": true})).unwrap();
click(&mut s, c, "plain");
let depth = s.history_labels().len();
// Open folder: the folder row and its layers
let r = execute(&mut s, "layer.select", &json!({"all": true})).unwrap();
let shown = stack_rows(&s.doc.project, 0, true);
assert_eq!(selected(&s)[..5], ["Folder 1", "B", "A", "D", "C"]);
assert_eq!(s.selected_layers(), shown, "every row of the set");
assert_eq!(r["layers"].as_array().unwrap().len(), shown.len());
assert_eq!(s.selected_layer(), Some(c), "the active layer stays");
assert_eq!(s.history_labels().len(), depth, "selecting is no undo step");
// Collapsed folder: the folder row, not its layers
if let LayerKind::Group { collapsed, .. } = &mut s.doc.project.layer_mut(folder).unwrap().kind {
*collapsed = true;
}
execute(&mut s, "layer.select", &json!({"layer": d.0})).unwrap();
execute(&mut s, "layer.select", &json!({"all": true})).unwrap();
assert_eq!(selected(&s)[..3], ["Folder 1", "D", "C"]);
assert!(!s.is_layer_selected(a) && !s.is_layer_selected(b), "the collapsed folder's layers stay unselected");
assert_eq!(s.selected_layer(), Some(d), "the active layer stays when it is picked again");
}
#[test]
fn the_visibility_of_one_layer_leaves_the_other_selected_layers_alone() {
let mut s = session();
let [a, _, c, _] = four(&mut s);
execute(&mut s, "layer.select", &json!({"layers": [a.0, c.0]})).unwrap();
execute(&mut s, "layer.visible", &json!({"layer": c.0})).unwrap();
assert!(!s.doc.project.layer(c).unwrap().visible && s.doc.project.layer(a).unwrap().visible, "only C is hidden");
assert_eq!(s.selected_layers().len(), 2, "the selection stays");
}
#[test]
fn visibility_of_several_layers_follows_the_layer_given_as_lead() {
let mut s = session();
let [a, b, c, _] = four(&mut s);
execute(&mut s, "layer.visible", &json!({"layer": a.0, "visible": false})).unwrap();
// The active layer is C (shown), but the eye of A (hidden) was clicked: all are shown
execute(&mut s, "layer.select", &json!({"layers": [a.0, b.0, c.0], "layer": c.0})).unwrap();
execute(&mut s, "layer.visible", &json!({"layers": [a.0, b.0, c.0], "layer": a.0})).unwrap();
let shown = |s: &Session| [a, b, c].map(|l| s.doc.project.layer(l).unwrap().visible);
assert_eq!(shown(&s), [true; 3], "A was hidden, so all are shown");
}
#[test]
fn visibility_toggles_every_selected_layer_the_way_of_the_active_one() {
let mut s = session();
let [a, b, c, _] = four(&mut s);
execute(&mut s, "layer.visible", &json!({"layer": a.0, "visible": false})).unwrap();
execute(&mut s, "layer.select", &json!({"layers": [a.0, b.0, c.0], "layer": c.0})).unwrap();
let depth = s.history_labels().len();
execute(&mut s, "layer.visible", &Value::Null).unwrap();
let shown = |s: &Session| [a, b, c].map(|l| s.doc.project.layer(l).unwrap().visible);
assert_eq!(shown(&s), [false; 3], "C was shown, so all are hidden");
assert_eq!(s.history_labels().len(), depth + 1, "one undo step");
execute(&mut s, "layer.visible", &json!({"layers": [a.0, b.0], "visible": true})).unwrap();
assert_eq!(shown(&s), [true, true, false]);
s.undo().unwrap();
s.undo().unwrap();
assert_eq!(shown(&s), [false, true, true]);
}
#[test]
fn selected_layers_move_together_keeping_their_order() {
let mut s = session();
let [a, b, c, d] = four(&mut s);
execute(&mut s, "layer.move", &json!({"layers": [a.0, c.0], "above": d.0})).unwrap();
assert_eq!(rows(&s)[..4], ["C", "A", "D", "B"]);
s.undo().unwrap();
assert_eq!(rows(&s)[..4], ["D", "C", "B", "A"]);
// Into a folder
let folder = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [d.0, b.0], "above": folder.0, "inside": true})).unwrap();
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [b, d]);
assert!(execute(&mut s, "layer.move", &json!({"layers": [a.0, c.0], "above": c.0})).is_err(), "not above one of themselves");
}
#[test]
fn selected_layers_moved_to_an_index_keep_their_order() {
for (pair, expected) in [("B", ["C", "D", "B", "A", "Layer 1"]), ("A", ["C", "D", "A", "B", "Layer 1"])] {
let mut s = session();
let [a, b, _, d] = four(&mut s);
let lower = if pair == "A" { a } else { b };
execute(&mut s, "layer.move", &json!({"layers": [d.0, lower.0], "index": 2})).unwrap();
assert_eq!(rows(&s)[..5], expected, "D and {pair} to index 2");
}
}
#[test]
fn extreme_move_deltas_clamp_to_the_stack_ends() {
let mut session = session();
let [_, layer, ..] = four(&mut session);
execute(&mut session, "layer.move", &json!({"layer": layer.0, "delta": i64::MAX})).unwrap();
assert_eq!(rows(&session)[0], "B", "a large positive delta moves to the top");
execute(&mut session, "layer.move", &json!({"layer": layer.0, "delta": i64::MIN})).unwrap();
assert_eq!(rows(&session).last().map(String::as_str), Some("B"), "a large negative delta moves to the bottom");
}
#[test]
fn layers_in_and_out_of_a_folder_dropped_below_the_stack_stay_together_at_its_bottom() {
let mut s = session();
let [_, b, _, d] = four(&mut s);
let folder = id(execute(&mut s, "layer.group", &json!({"layer": b.0})).unwrap(), "layer");
execute(&mut s, "layer.move", &json!({"layers": [d.0, b.0], "index": 0})).unwrap();
assert_eq!(s.doc.project.texture_sets[0].stack[..2], [b, d], "B at the bottom, D right above it");
assert!(s.doc.project.layer(folder).unwrap().children().is_empty(), "B left its folder");
}
#[test]
fn a_move_that_changes_nothing_is_not_an_undo_step() {
let mut s = session();
let [a, b, c, _] = four(&mut s);
let depth = s.history_labels().len();
execute(&mut s, "layer.move", &json!({"layer": b.0, "above": a.0})).unwrap();
execute(&mut s, "layer.move", &json!({"layers": [c.0, b.0], "above": a.0})).unwrap();
assert_eq!(s.history_labels().len(), depth, "B already sits above A, and C above B");
execute(&mut s, "layer.move", &json!({"layer": a.0, "above": c.0})).unwrap();
assert_eq!(s.history_labels().len(), depth + 1);
}
#[test]
fn an_explicit_layer_acts_on_that_layer_only_while_several_are_selected() {
let select = |s: &mut Session, b: LayerId, d: LayerId| execute(s, "layer.select", &json!({"layers": [b.0, d.0]})).unwrap();
let mut s = session();
let [_, b, _, d] = four(&mut s);
select(&mut s, b, d);
execute(&mut s, "layer.remove", &json!({"layer": b.0})).unwrap();
assert_eq!(rows(&s)[..3], ["D", "C", "A"], "remove");
let mut s = session();
let [_, b, _, d] = four(&mut s);
select(&mut s, b, d);
execute(&mut s, "layer.duplicate", &json!({"layer": b.0})).unwrap();
assert_eq!(rows(&s)[..5], ["D", "C", "B copy", "B", "A"], "duplicate");
let mut s = session();
let [_, b, _, d] = four(&mut s);
select(&mut s, b, d);
let folder = id(execute(&mut s, "layer.group", &json!({"layer": b.0})).unwrap(), "layer");
assert_eq!(s.doc.project.layer(folder).unwrap().children(), [b], "group");
let mut s = session();
let [_, b, _, d] = four(&mut s);
select(&mut s, b, d);
execute(&mut s, "layer.visible", &json!({"layer": b.0})).unwrap();
assert!(!s.doc.project.layer(b).unwrap().visible && s.doc.project.layer(d).unwrap().visible, "visible");
}
#[test]
fn undo_and_redo_end_the_multiple_selection() {
let mut s = session();
let [_, b, ..] = four(&mut s);
let e = add(&mut s, "E");
execute(&mut s, "layer.select", &json!({"layers": [b.0, e.0]})).unwrap();
s.undo().unwrap();
s.redo().unwrap();
assert_eq!(selected(&s), ["E"], "E is back alone, B is not picked again");
add(&mut s, "F");
assert_eq!(s.selected_layers().len(), 1);
assert!(!s.is_layer_selected(b));
}
#[test]
fn reselecting_an_earlier_active_layer_does_not_bring_back_its_multiple_selection() {
let mut s = session();
let [_, b, c, d] = four(&mut s);
click(&mut s, c, "plain");
let effect = execute(&mut s, "effect.add.filter", &json!({"target": "content", "filter": "invert"})).unwrap()["effect"].as_u64().unwrap();
execute(&mut s, "effect.copy", &json!({ "effect": effect })).unwrap();
execute(&mut s, "layer.select", &json!({"layers": [b.0, d.0], "layer": d.0})).unwrap();
add(&mut s, "E");
// Pasting the effect onto D selects D again, alone
execute(&mut s, "effect.paste", &json!({"layer": d.0})).unwrap();
assert_eq!(selected(&s), ["D"]);
}
#[test]
fn bad_layer_lists_are_errors() {
let mut s = session();
let [a, ..] = four(&mut s);
let other = id(execute(&mut s, "textureSet.select", &json!({"ts": 1})).and_then(|_| execute(&mut s, "layer.add.paint", &Value::Null)).unwrap(), "layer");
for command in ["layer.select", "layer.remove", "layer.duplicate", "layer.group", "layer.visible", "layer.move"] {
for layers in [json!("x"), json!([]), json!([u64::MAX]), json!([a.0, other.0]), json!([a.0, "x"])] {
assert!(execute(&mut s, command, &json!({"layers": layers, "above": null})).is_err(), "{command} {layers}");
}
}
assert!(execute(&mut s, "layer.select", &json!({"layers": [a.0], "layer": other.0})).is_err(), "the active layer must be listed");
}
#[test]
fn moving_layers_into_a_folder_in_another_set_preserves_the_document() {
let mut s = texturecraft_engine::sample_session(128, 64).unwrap();
let source = s.doc.project.texture_sets[0].stack[0];
execute(&mut s, "textureSet.select", &json!({"ts": 1})).unwrap();
let folder = id(execute(&mut s, "layer.add.group", &json!({})).unwrap(), "layer");
let before = s.doc.project.clone();
let history = s.history_labels();
for params in [json!({"layer": source.0, "above": folder.0, "inside": true}), json!({"layers": [source.0], "above": folder.0, "inside": true})] {
assert!(execute(&mut s, "layer.move", &params).is_err());
assert_eq!(s.doc.project, before);
assert_eq!(s.history_labels(), history);
}
}