d84914ef1e5a
layer_multi_select.rs
//! 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", ¶ms).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", ¶ms).is_err());
assert_eq!(s.doc.project, before);
assert_eq!(s.history_labels(), history);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.