mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-21 20:28:51 +00:00
document-panels-w10: net change of 1 commits
- document-panels-w10: written from its sheet
This commit is contained in:
@@ -0,0 +1,827 @@
|
||||
//! The Layers panel's rename, isolation, reveal and thumbnail behaviour, driven through commands, the panel's events
|
||||
//! and one pass of `show`; nothing here reads painted text.
|
||||
|
||||
use serde_json::json;
|
||||
use vectorcraft_engine::{LayersReveal, Session};
|
||||
|
||||
use super::tests::{listed_ids, nested, rows_of, two_rects, undo_len};
|
||||
use super::*;
|
||||
|
||||
// PLAN: assumed `super::*` brings `RowId`, `DocLayers`, `LayerFilter`, `FilterObject`, `LayersEvent`, `LayerRowKey`,
|
||||
// `LayerSelect`, `LayerDrop`, `LayerMove`, `LayerPosition`, `LayerColumn`, `Mods`, `EditEvent`, `Mixed`,
|
||||
// `SelectionChange`, `CommandState` and `LayersFooterAction` into `layers` (document-panels-w7, document-panels-w8).
|
||||
|
||||
/// One pass of the panel in a 300 × 800 window, one second after the previous one.
|
||||
fn pass(app: &mut VectorcraftApp, ctx: &egui::Context) {
|
||||
let time = ctx.input(|i| i.time) + 1.0;
|
||||
let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(300.0, 800.0));
|
||||
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), time: Some(time), ..Default::default() }, |ui| show(app, ui));
|
||||
out.textures_delta.clear();
|
||||
}
|
||||
|
||||
/// The active document's pending reveal request.
|
||||
fn reveal_of(app: &VectorcraftApp) -> Option<LayersReveal> {
|
||||
app.session.active().and_then(|st| st.layers_reveal.clone())
|
||||
}
|
||||
|
||||
/// The panel options of the app.
|
||||
fn options(app: &mut VectorcraftApp) -> &mut PanelOptions {
|
||||
&mut app.ui.layers_ui.options // PLAN: assumed `LayersUi::options: PanelOptions` (document-panels-w7)
|
||||
}
|
||||
|
||||
fn is_open(app: &VectorcraftApp, id: NodeId) -> bool {
|
||||
app.session.active().is_some_and(|st| st.layers_open.contains(id))
|
||||
}
|
||||
|
||||
fn parent(app: &VectorcraftApp, id: NodeId) -> Option<NodeId> {
|
||||
app.session.active().and_then(|st| st.doc.parent_of(id))
|
||||
}
|
||||
|
||||
fn node_count(app: &VectorcraftApp) -> usize {
|
||||
let mut n = 0;
|
||||
if let Some(st) = app.session.active() {
|
||||
st.doc.walk(|_| n += 1);
|
||||
}
|
||||
n
|
||||
}
|
||||
|
||||
fn row(id: NodeId) -> RowId {
|
||||
RowId::Node(id)
|
||||
}
|
||||
|
||||
fn key(id: NodeId) -> LayerRowKey<RowId> {
|
||||
LayerRowKey::Layer(row(id))
|
||||
}
|
||||
|
||||
/// Applies a panel event as the panel's output stage does.
|
||||
fn apply(app: &mut VectorcraftApp, event: LayersEvent<RowId>) {
|
||||
rows::apply(app, event); // PLAN: assumed `rows::apply(app: &mut VectorcraftApp, event: LayersEvent<RowId>)`
|
||||
}
|
||||
|
||||
fn select_rows(app: &mut VectorcraftApp, ids: &[NodeId]) {
|
||||
let change = SelectionChange::Set(ids.iter().map(|id| row(*id)).collect());
|
||||
apply(app, LayersEvent::Select(LayerSelect::new(change, None)));
|
||||
}
|
||||
|
||||
fn mv(layers: &[NodeId], target: NodeId, position: LayerPosition, copy: bool) -> LayerMove<RowId> {
|
||||
LayerMove::new(layers.iter().map(|id| row(*id)).collect(), row(target), position, copy)
|
||||
}
|
||||
|
||||
fn doc_layers(app: &VectorcraftApp, opts: &PanelOptions) -> DocLayers {
|
||||
// PLAN: assumed `DocLayers::new(st: &DocState, opts: &PanelOptions, filter: &LayerFilter) -> DocLayers`
|
||||
DocLayers::new(app.session.active().expect("a document"), opts, &app.ui.layers_ui.filter)
|
||||
}
|
||||
|
||||
/// Whether the panel takes the drop `m`.
|
||||
fn accepts(app: &VectorcraftApp, m: &LayerMove<RowId>) -> bool {
|
||||
doc_layers(app, &PanelOptions::default()).accepts_drop(m) // PLAN: assumed `DocLayers::accepts_drop(&self, &LayerMove<RowId>) -> bool`
|
||||
}
|
||||
|
||||
fn drop_event(m: LayerMove<RowId>) -> LayersEvent<RowId> {
|
||||
let drop = LayerDrop::Layers(m);
|
||||
LayersEvent::Drop(EditEvent::set(Mixed::Same(drop.clone()), drop, "Move".into(), None))
|
||||
}
|
||||
|
||||
/// Every row the panel lists under the options `opts`, top down, depth first.
|
||||
fn listed_with(app: &VectorcraftApp, opts: &PanelOptions) -> Vec<NodeId> {
|
||||
fn walk(layers: &DocLayers, parent: Option<RowId>, out: &mut Vec<NodeId>) {
|
||||
// PLAN: assumed `DocLayers::children(&self, parent: Option<RowId>) -> Vec<RowId>`
|
||||
for child in layers.children(parent) {
|
||||
if let RowId::Node(id) = child {
|
||||
out.push(id);
|
||||
}
|
||||
walk(layers, Some(child), out);
|
||||
}
|
||||
}
|
||||
let mut out = vec![];
|
||||
walk(&doc_layers(app, opts), None, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// Whether the command's state in the panel menu is enabled.
|
||||
fn enabled(app: &VectorcraftApp, command: &str) -> bool {
|
||||
// PLAN: assumed `controls::menu_states(app: &VectorcraftApp) -> CommandStates`
|
||||
controls::menu_states(app).get(&command.into()).is_some_and(|s| s.is_enabled())
|
||||
}
|
||||
|
||||
/// Whether the panel menu titles Locate `title`.
|
||||
fn locate_titled(app: &VectorcraftApp, title: &str) -> bool {
|
||||
let states = controls::menu_states(app);
|
||||
states.get(&"layer.locate".into()).is_some_and(|s| *s == CommandState::new().enabled(s.is_enabled()).title(title))
|
||||
}
|
||||
|
||||
/// A menu command run as the panel menu runs it, on the rows it lists.
|
||||
fn menu_run(app: &mut VectorcraftApp, command: &str, params: serde_json::Value) -> Result<serde_json::Value, String> {
|
||||
controls::run(app, command, params) // PLAN: assumed `controls::run(app, command: &str, params: Value) -> Result<Value, String>`
|
||||
}
|
||||
|
||||
/// What a document's Layers thumbnail store holds and what it uploaded in the last frame: `(entries, uploads)`. It
|
||||
/// reads the store's statistics, which neither render nor queue a picture.
|
||||
fn stored(ctx: &egui::Context, uid: u64) -> (usize, usize) {
|
||||
// PLAN: assumed `thumbs::layer_thumbnails(&Context, u64)` returns the `Thumbnails` of that document
|
||||
let stats = thumbs::layer_thumbnails(ctx, uid).cache().statistics(ctx);
|
||||
(stats.entries, stats.uploads)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closing_a_document_releases_only_its_layer_thumbnails() {
|
||||
let (mut app, _, _) = two_rects();
|
||||
let ctx = egui::Context::default();
|
||||
app.ui_ctx = Some(ctx.clone());
|
||||
let first = app.session.active().unwrap().uid;
|
||||
pass(&mut app, &ctx);
|
||||
assert!(stored(&ctx, first).0 > 0, "the first document's rows render");
|
||||
|
||||
app.session.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
|
||||
app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
|
||||
let second = app.session.active().unwrap().uid;
|
||||
pass(&mut app, &ctx);
|
||||
assert!(stored(&ctx, second).0 > 0);
|
||||
|
||||
// The engine closes without the question the window asks; the whole frame drops the view of the closed document.
|
||||
app.session.execute("file.close", &json!({"index": 0})).unwrap();
|
||||
crate::tests::synthetic::key_frame(&mut app, &ctx, vec![]);
|
||||
assert!(app.session.documents().iter().all(|d| d.uid != first), "the first document closed");
|
||||
assert_eq!(stored(&ctx, first).0, 0, "the closed document's pictures are released");
|
||||
assert!(stored(&ctx, second).0 > 0, "the open document's pictures stay");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn row_thumbnails_wait_for_the_end_of_a_drag() {
|
||||
let (mut app, _, _) = two_rects();
|
||||
app.session.execute("select.all", &json!({})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
let uid = app.session.active().unwrap().uid;
|
||||
for _ in 0..4 {
|
||||
pass(&mut app, &ctx);
|
||||
}
|
||||
assert!(stored(&ctx, uid).0 > 0, "the rows' pictures render at once");
|
||||
app.session.begin_interaction("Move").unwrap();
|
||||
for i in 1..=10 {
|
||||
app.session.preview("object.transform", &json!({"matrix": [1, 0, 0, 1, i, 0]})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(stored(&ctx, uid).1, 0, "no picture is replaced while the drag lasts");
|
||||
}
|
||||
app.session.commit_interaction().unwrap();
|
||||
let mut uploads = 0;
|
||||
for _ in 0..4 {
|
||||
pass(&mut app, &ctx);
|
||||
uploads += stored(&ctx, uid).1;
|
||||
}
|
||||
assert!(uploads > 0, "the moved rows render after it");
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(stored(&ctx, uid).1, 0, "once");
|
||||
}
|
||||
|
||||
/// Rename (`ui.rename`) opens the name field on the selected object's row: the panel takes the request in one pass and
|
||||
/// the committed name is one undo step.
|
||||
#[test]
|
||||
fn rename_opens_the_name_field_of_the_selected_object() {
|
||||
let (mut app, _, [a, _]) = two_rects();
|
||||
let ctx = egui::Context::default();
|
||||
app.ui_ctx = Some(ctx.clone());
|
||||
let name = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node(a).unwrap().display_name();
|
||||
let before = name(&app);
|
||||
app.session.execute("select.set", &json!({"ids": [a.0]})).unwrap();
|
||||
let steps = undo_len(&app);
|
||||
let opened = app.run("ui.rename", json!({})).unwrap();
|
||||
assert_eq!(opened, json!({"id": a.0, "name": before}));
|
||||
assert_eq!(app.ui.layers_ui.rename, Some(row(a)), "the field is asked for on its row");
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Row(a)), "and the row is brought into view");
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(app.ui.layers_ui.rename, None, "the panel took the rename request");
|
||||
assert_eq!(reveal_of(&app), None, "and the reveal request");
|
||||
// PLAN: assumed `LayersEvent::rename(layer, text)`, the constructor of the non-exhaustive `Rename` event
|
||||
apply(&mut app, LayersEvent::rename(row(a), "Sun".into()));
|
||||
assert_eq!(name(&app), "Sun");
|
||||
assert_eq!(undo_len(&app), steps + 1, "one undo step");
|
||||
app.session.execute("edit.undo", &json!({})).unwrap();
|
||||
assert_eq!(name(&app), before);
|
||||
}
|
||||
|
||||
/// Without a selection Rename names the current layer; it refuses several objects and a row the panel doesn't list,
|
||||
/// and asks for no field then.
|
||||
#[test]
|
||||
fn rename_names_the_current_layer_and_refuses_several_or_hidden_rows() {
|
||||
let (mut app, layer, [a, b]) = two_rects();
|
||||
let ctx = egui::Context::default();
|
||||
app.ui_ctx = Some(ctx.clone());
|
||||
assert_eq!(app.run("ui.rename", json!({})).unwrap()["id"], json!(layer.0), "nothing selected: the current layer");
|
||||
app.ui.layers_ui.rename = None;
|
||||
app.session.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
|
||||
assert!(app.run("ui.rename", json!({})).is_err(), "two objects");
|
||||
assert_eq!(app.ui.layers_ui.rename, None);
|
||||
options(&mut app).layers_only = true;
|
||||
assert!(app.run("ui.rename", json!({"id": a.0})).is_err(), "Show Layers Only lists no object rows");
|
||||
assert_eq!(app.ui.layers_ui.rename, None);
|
||||
assert!(app.run("ui.rename", json!({"id": 999_999})).is_err(), "no such object");
|
||||
assert_eq!(app.ui.layers_ui.rename, None);
|
||||
assert_eq!(app.run("ui.rename", json!({"id": layer.0})).unwrap()["id"], json!(layer.0));
|
||||
assert_eq!(app.ui.layers_ui.rename, Some(row(layer)));
|
||||
}
|
||||
|
||||
/// In isolation mode the panel lists only the isolated sublayer, group or object, as the top row with the open rows
|
||||
/// inside it; the other layers and groups are listed again when it ends.
|
||||
#[test]
|
||||
fn isolation_lists_only_the_isolated_art_and_exit_lists_every_layer_again() {
|
||||
let (mut app, [layer, sub, g, b, a, c]) = nested();
|
||||
let run = |app: &mut VectorcraftApp, id: &str, p: serde_json::Value| app.session.execute(id, &p).unwrap();
|
||||
let top = NodeId(run(&mut app, "layer.new", json!({"top": true, "name": "Top"}))["id"].as_u64().unwrap());
|
||||
let all = vec![(top, 0), (layer, 0), (sub, 1), (g, 2), (b, 3), (a, 2), (c, 1)];
|
||||
assert_eq!(listed_ids(&app), all);
|
||||
run(&mut app, "object.isolate", json!({"id": g.0}));
|
||||
assert_eq!(listed_ids(&app), [(g, 0), (b, 1)], "the group and its art");
|
||||
run(&mut app, "object.exitIsolation", json!({}));
|
||||
assert_eq!(listed_ids(&app), all, "every layer again");
|
||||
run(&mut app, "object.isolate", json!({"id": sub.0}));
|
||||
assert_eq!(listed_ids(&app), [(sub, 0), (g, 1), (b, 2), (a, 1)], "the sublayer and its art");
|
||||
// Isolating an object inside lists that object alone.
|
||||
run(&mut app, "object.isolate", json!({"id": a.0}));
|
||||
assert_eq!(listed_ids(&app), [(a, 0)]);
|
||||
run(&mut app, "object.exitIsolation", json!({}));
|
||||
assert_eq!(listed_ids(&app), all);
|
||||
// A closed isolated group lists its own row alone, and an isolated object that is gone leaves every layer listed.
|
||||
run(&mut app, "object.isolate", json!({"id": g.0}));
|
||||
app.session.active_mut().unwrap().layers_open.set(g, false);
|
||||
assert_eq!(listed_ids(&app), [(g, 0)]);
|
||||
app.session.active_mut().unwrap().isolation = Some(NodeId(999_999));
|
||||
assert_eq!(listed_ids(&app), [(top, 0), (layer, 0), (sub, 1), (g, 2), (a, 2), (c, 1)]);
|
||||
}
|
||||
|
||||
/// Entering isolation mode opens the isolated row and leaving it lists every row again; a drop beside the isolated row
|
||||
/// or into the empty space under it moves nothing out of the isolated art.
|
||||
#[test]
|
||||
fn isolation_opens_the_isolated_row_and_keeps_drops_inside_it() {
|
||||
let (mut app, [layer, sub, g, _, a, _]) = nested();
|
||||
assert_eq!(listed_ids(&app).len(), 6);
|
||||
app.session.active_mut().unwrap().layers_open.set(sub, false);
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
assert!(is_open(&app, sub), "the sublayer's row opens as isolation starts");
|
||||
assert_eq!(listed_ids(&app).len(), 4, "Sub, g, b, a");
|
||||
// Rectangle a above the sublayer's row would leave the sublayer.
|
||||
let above = mv(&[a], sub, LayerPosition::Before, false);
|
||||
assert!(!accepts(&app, &above));
|
||||
apply(&mut app, drop_event(above));
|
||||
assert_eq!(parent(&app, a), Some(sub));
|
||||
// The sublayer under the last row (the empty space) stays in Layer 1.
|
||||
let under = mv(&[sub], a, LayerPosition::After, false);
|
||||
assert!(!accepts(&app, &under));
|
||||
apply(&mut app, drop_event(under));
|
||||
assert_eq!(parent(&app, sub), Some(layer));
|
||||
// Rectangle a onto the group's row: into it.
|
||||
let into = mv(&[a], g, LayerPosition::Into, false);
|
||||
assert!(accepts(&app, &into));
|
||||
apply(&mut app, drop_event(into));
|
||||
assert_eq!(parent(&app, a), Some(g));
|
||||
app.session.execute("object.exitIsolation", &json!({"all": true})).unwrap();
|
||||
assert_eq!(listed_ids(&app).len(), 6, "every row again");
|
||||
}
|
||||
|
||||
/// In isolation mode the rows outside the isolated art are no longer highlighted.
|
||||
#[test]
|
||||
fn isolation_drops_highlights_outside_the_isolated_art() {
|
||||
let (mut app, [_, sub, _, b, _, c]) = nested();
|
||||
let ctx = egui::Context::default();
|
||||
app.session.execute("layer.highlight", &json!({"ids": [c.0, b.0], "mode": "set"})).unwrap();
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(rows_of(&app), [b], "the rectangle on Layer 1, outside the sublayer, is let go");
|
||||
}
|
||||
|
||||
/// In isolation mode Rename and the rows opened around a located object stay inside the isolated row.
|
||||
#[test]
|
||||
fn isolation_keeps_rename_and_locate_to_the_rows_listed() {
|
||||
let (mut app, [layer, sub, g, b, _, c]) = nested();
|
||||
let ctx = egui::Context::default();
|
||||
app.ui_ctx = Some(ctx.clone());
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
let err = app.run("ui.rename", json!({"id": c.0})).unwrap_err();
|
||||
assert!(err.contains("the object is outside the isolated group"), "{err}");
|
||||
assert_eq!(app.run("ui.rename", json!({"id": b.0})).unwrap()["id"], json!(b.0));
|
||||
{
|
||||
let st = app.session.active().unwrap();
|
||||
// PLAN: assumed `listed_when_opened` keeps its argument order with `&LayerFilter` for the filter
|
||||
let listed = |id| listed_when_opened(&st.doc, st.isolation, &st.layers_open, &PanelOptions::default(), "", &LayerFilter::default(), id);
|
||||
assert_eq!([layer, sub, g, b, c].map(listed), [false, true, true, true, false]);
|
||||
}
|
||||
let st = app.session.active_mut().unwrap();
|
||||
st.layers_open.set(layer, false);
|
||||
st.layers_open.set(g, false);
|
||||
let doc = st.doc.clone();
|
||||
open_around(&mut app, &doc, &[c]);
|
||||
open_around(&mut app, &doc, &[b]);
|
||||
assert!(is_open(&app, g), "the group inside the sublayer opens");
|
||||
assert!(!is_open(&app, layer), "the layer around the sublayer stays closed");
|
||||
}
|
||||
|
||||
/// In isolation mode, with no row highlighted, Delete Selection and the trash do not delete the current layer when it is
|
||||
/// outside the isolated art, where the panel does not list it.
|
||||
#[test]
|
||||
fn isolation_keeps_delete_to_the_rows_listed() {
|
||||
let (mut app, [layer, sub, g, b, a, c]) = nested();
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
let st = app.session.active_mut().unwrap();
|
||||
st.layer_rows = vec![c];
|
||||
let current = st.current_layer().unwrap();
|
||||
assert!([layer, sub].contains(¤t), "the current layer holds the isolated group");
|
||||
let err = app.run("ui.layerDelete", json!({})).unwrap_err();
|
||||
assert!(err.contains("the object is outside the isolated group"), "{err}");
|
||||
let doc = &app.session.active().unwrap().doc;
|
||||
assert!([layer, sub, g, b, a, c].iter().all(|id| doc.node(*id).is_some()), "nothing was deleted");
|
||||
app.session.active_mut().unwrap().layer_rows = vec![b];
|
||||
app.run("ui.layerDelete", json!({})).unwrap();
|
||||
let doc = &app.session.active().unwrap().doc;
|
||||
assert!(doc.node(b).is_none(), "a highlighted row inside the isolated group is deleted");
|
||||
assert!(doc.node(a).is_some() && doc.node(c).is_some());
|
||||
}
|
||||
|
||||
/// In isolation mode New Layer and New Sublayer are off, and `ui.newLayer` is an error, while the layer they make would
|
||||
/// be outside the isolated art; a sublayer of an isolated sublayer is listed.
|
||||
#[test]
|
||||
fn isolation_keeps_new_layers_to_the_rows_listed() {
|
||||
let (mut app, [_, sub, g, ..]) = nested();
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
let st = app.session.active().unwrap();
|
||||
assert_eq!([(false, false), (true, false), (false, true)].map(|(s, t)| new_layer_unlisted(st, s, t)), [true; 3]);
|
||||
for p in [json!({}), json!({"sublayer": true})] {
|
||||
let err = app.run("ui.newLayer", p).unwrap_err();
|
||||
assert!(err.contains("exit isolation mode first"), "{err}");
|
||||
}
|
||||
assert!(!app.any_dialog_open());
|
||||
app.session.execute("object.exitIsolation", &json!({})).unwrap();
|
||||
app.session.execute("layer.setCurrent", &json!({"id": sub.0})).unwrap();
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
let st = app.session.active().unwrap();
|
||||
assert!(new_layer_unlisted(st, false, false), "a new layer would go beside the isolated sublayer");
|
||||
assert!(!new_layer_unlisted(st, true, false), "a new sublayer goes inside it");
|
||||
app.run("ui.newLayer", json!({"sublayer": true})).unwrap();
|
||||
assert!(app.any_dialog_open());
|
||||
// Exit Isolation Mode on the sublayer isolates its layer, beside which a new layer would go.
|
||||
app.session.execute("object.exitIsolation", &json!({})).unwrap();
|
||||
assert!(new_layer_unlisted(app.session.active().unwrap(), false, true));
|
||||
app.session.execute("object.exitIsolation", &json!({})).unwrap();
|
||||
assert!(!new_layer_unlisted(app.session.active().unwrap(), false, true));
|
||||
}
|
||||
|
||||
/// With Show Layers Only on, an isolated group or object is still listed as the top row, without the art inside it.
|
||||
#[test]
|
||||
fn isolation_with_show_layers_only_lists_the_isolated_group_or_object() {
|
||||
let (mut app, [_, sub, g, _, a, _]) = nested();
|
||||
let opts = PanelOptions { layers_only: true, ..Default::default() };
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
assert_eq!(listed_with(&app, &opts), [g], "the group's row, without its art");
|
||||
let st = app.session.active().unwrap();
|
||||
assert!(listed_when_opened(&st.doc, st.isolation, &st.layers_open, &opts, "", &LayerFilter::default(), g));
|
||||
app.session.execute("object.isolate", &json!({"id": a.0})).unwrap();
|
||||
assert_eq!(listed_with(&app, &opts), [a]);
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
assert_eq!(listed_with(&app, &opts), [sub], "a sublayer with no sublayers inside lists itself alone");
|
||||
}
|
||||
|
||||
/// In isolation mode the panel menu's Duplicate Selection copies only the rows the panel lists, Hide Others is off, and
|
||||
/// with a group isolated so is Locate Layer, whose layer row is not listed.
|
||||
#[test]
|
||||
fn isolation_keeps_the_panel_menu_to_the_rows_listed() {
|
||||
let (mut app, [layer, sub, g, b, _, c]) = nested();
|
||||
let top = NodeId(app.session.execute("layer.new", &json!({"top": true, "name": "Top"})).unwrap()["id"].as_u64().unwrap());
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
// A row left highlighted outside the sublayer before the panel shows again.
|
||||
app.session.active_mut().unwrap().layer_rows = vec![c, b];
|
||||
menu_run(&mut app, "layer.duplicate", json!({})).unwrap();
|
||||
let count = |app: &VectorcraftApp, id: NodeId| app.session.active().unwrap().doc.node(id).unwrap().children().unwrap().len();
|
||||
assert_eq!(count(&app, layer), 2, "rectangle c, outside the sublayer, is not copied");
|
||||
assert_eq!(count(&app, g), 2, "rectangle b is copied");
|
||||
assert!(!enabled(&app, "layer.hideOthers"), "Hide Others is off in isolation mode");
|
||||
assert!(app.session.active().unwrap().doc.node(top).unwrap().visible, "the layer outside the isolated art still shows");
|
||||
options(&mut app).layers_only = true;
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
|
||||
app.session.active_mut().unwrap().layer_rows = vec![];
|
||||
assert!(!enabled(&app, "layer.locate"), "the sublayer holding the group is not listed");
|
||||
let _ = menu_run(&mut app, "layer.locate", json!({"layersOnly": true})); // refused: the row is not listed
|
||||
assert!(rows_of(&app).is_empty(), "the sublayer holding the group is not highlighted");
|
||||
}
|
||||
|
||||
/// OK in Delete Selection's question deletes nothing when isolation mode started while it asked and a row it asked
|
||||
/// about is outside the isolated art, and rows given outside it, as rows dropped on the trash are, are not deleted
|
||||
/// either.
|
||||
#[test]
|
||||
fn isolation_keeps_a_confirmed_delete_to_the_rows_listed() {
|
||||
let (mut app, [_, sub, g, _, a, c]) = nested();
|
||||
let uid = app.session.active().unwrap().uid;
|
||||
app.session.active_mut().unwrap().layer_rows = vec![sub];
|
||||
assert!(app.run("ui.layerDelete", json!({})).unwrap().is_null(), "it asks first");
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
let ok = json!({"ids": [sub.0], "doc": uid, "confirmed": true});
|
||||
let err = app.run("ui.layerDelete", ok.clone()).unwrap_err();
|
||||
assert!(err.contains("the object is outside the isolated group"), "{err}");
|
||||
assert!(app.session.active().unwrap().doc.node(sub).is_some(), "nothing was deleted");
|
||||
let err = app.run("ui.layerDelete", json!({"ids": [c.0]})).unwrap_err();
|
||||
assert!(err.contains("the object is outside the isolated group"), "{err}");
|
||||
assert!(app.session.active().unwrap().doc.node(c).is_some(), "the rectangle outside the group stays");
|
||||
// OK with no rows given deletes the highlighted rows the panel lists, inside the sublayer.
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
app.session.active_mut().unwrap().layer_rows = vec![a, c];
|
||||
app.run("ui.layerDelete", json!({"doc": uid, "confirmed": true})).unwrap();
|
||||
let doc = &app.session.active().unwrap().doc;
|
||||
assert!(doc.node(a).is_none() && doc.node(c).is_some(), "only the row inside the sublayer is deleted");
|
||||
app.session.execute("object.exitIsolation", &json!({"all": true})).unwrap();
|
||||
app.run("ui.layerDelete", ok).unwrap();
|
||||
assert!(app.session.active().unwrap().doc.node(sub).is_none());
|
||||
}
|
||||
|
||||
/// A document put in isolation mode opens its isolated row at once, and showing the documents again opens nothing.
|
||||
#[test]
|
||||
fn isolation_opens_the_isolated_row_of_each_document() {
|
||||
let (mut app, [_, _, g, ..]) = nested();
|
||||
let ctx = egui::Context::default();
|
||||
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
app.session.execute("document.activate", &json!({"index": 0})).unwrap();
|
||||
app.session.active_mut().unwrap().layers_open.set(g, false);
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
assert!(is_open(&app, g), "the isolated group's row opens with the isolation");
|
||||
app.session.active_mut().unwrap().layers_open.set(g, false);
|
||||
app.session.execute("document.activate", &json!({"index": 1})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
app.session.execute("document.activate", &json!({"index": 0})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert!(!is_open(&app, g), "a row closed in isolation mode stays closed");
|
||||
}
|
||||
|
||||
/// In isolation mode an Alt-drag of the isolated row onto itself has no place to drop and copies nothing, and a guide
|
||||
/// dragged since before isolation mode began goes to no layer outside the isolated art.
|
||||
#[test]
|
||||
fn isolation_keeps_drops_on_the_isolated_row_inside_it() {
|
||||
let (mut app, [layer, sub, g, ..]) = nested();
|
||||
app.session.execute("guide.add", &json!({"vertical": true, "pos": 50, "layer": layer.0})).unwrap();
|
||||
let guide = app.session.active().unwrap().doc.ruler_guides()[0].id.unwrap();
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
let before = node_count(&app);
|
||||
let onto_itself = mv(&[sub], sub, LayerPosition::Into, true);
|
||||
assert!(!accepts(&app, &onto_itself));
|
||||
apply(&mut app, drop_event(onto_itself));
|
||||
assert_eq!(node_count(&app), before, "nothing was copied");
|
||||
app.session.execute("object.exitIsolation", &json!({"all": true})).unwrap();
|
||||
// PLAN: assumed a guide's row is `RowId::Node(its node id)`
|
||||
let guide_onto_group = mv(&[guide], g, LayerPosition::Into, false);
|
||||
assert!(accepts(&app, &guide_onto_group), "the guide would go to the sublayer holding it");
|
||||
app.session.execute("object.isolate", &json!({"id": g.0})).unwrap();
|
||||
assert!(!accepts(&app, &guide_onto_group), "not onto the isolated group's row, outside which its sublayer is");
|
||||
apply(&mut app, drop_event(guide_onto_group));
|
||||
assert_eq!(app.session.active().unwrap().doc.ruler_guides()[0].layer, Some(layer), "the guide stays on Layer 1");
|
||||
}
|
||||
|
||||
/// In isolation mode Alt-clicking or Ctrl/Cmd+Alt-clicking an eye, or Alt-clicking a lock, changes no layer outside the
|
||||
/// isolated art.
|
||||
#[test]
|
||||
fn isolation_keeps_alt_clicks_on_eyes_and_locks_inside_it() {
|
||||
let (mut app, [_, sub, ..]) = nested();
|
||||
let top = NodeId(app.session.execute("layer.new", &json!({"top": true, "name": "Top"})).unwrap()["id"].as_u64().unwrap());
|
||||
app.session.execute("object.isolate", &json!({"id": sub.0})).unwrap();
|
||||
let alt_cmd = Mods { cmd: true, alt: true, ..Mods::NONE };
|
||||
for (column, mods) in [(LayerColumn::Visibility, Mods::ALT), (LayerColumn::Visibility, alt_cmd), (LayerColumn::Lock, Mods::ALT)] {
|
||||
apply(&mut app, LayersEvent::cell_click(key(sub), column, mods));
|
||||
}
|
||||
let t = app.session.active().unwrap().doc.node(top).unwrap().clone();
|
||||
assert!(t.visible && !t.locked && !matches!(t.kind, NodeKind::Layer { preview: false, .. }), "the layer outside the isolated art is unchanged");
|
||||
}
|
||||
|
||||
/// With Show Layers Only on, Locate Object becomes Locate Layer in the panel menu and a row's menu, and the footer's
|
||||
/// Locate highlights the sublayer holding the selected art, opening the layer around it in the next pass. Off, it
|
||||
/// highlights the art's own row.
|
||||
#[test]
|
||||
fn with_show_layers_only_locate_object_becomes_locate_layer() {
|
||||
let (mut app, [layer, sub, _, b, _, _]) = nested();
|
||||
let ctx = egui::Context::default();
|
||||
app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
|
||||
assert!(locate_titled(&app, "Locate Object"));
|
||||
controls::footer(&mut app, LayersFooterAction::Locate); // PLAN: assumed `controls::footer(app, LayersFooterAction)` and its `Locate` variant
|
||||
assert_eq!(rows_of(&app), vec![b], "off: the art's own row");
|
||||
|
||||
options(&mut app).layers_only = true;
|
||||
assert!(locate_titled(&app, "Locate Layer"));
|
||||
app.session.active_mut().unwrap().layers_open.set(layer, false);
|
||||
pass(&mut app, &ctx);
|
||||
controls::footer(&mut app, LayersFooterAction::Locate);
|
||||
assert_eq!(rows_of(&app), vec![sub], "on: the sublayer holding the art");
|
||||
pass(&mut app, &ctx);
|
||||
assert!(is_open(&app, layer), "the layer around the sublayer opens");
|
||||
|
||||
// The row menu's Locate entry is the same command with the same parameters.
|
||||
app.session.active_mut().unwrap().layer_rows = vec![];
|
||||
menu_run(&mut app, "layer.locate", json!({"layersOnly": true})).unwrap();
|
||||
assert_eq!(rows_of(&app), vec![sub]);
|
||||
}
|
||||
|
||||
/// Locate Layer or Locate Object run again on the row it already highlighted reveals that row again, once per Locate.
|
||||
#[test]
|
||||
fn a_repeated_locate_reveals_the_row_it_already_highlighted() {
|
||||
let (mut app, [layer, sub, g, b, _, _]) = nested();
|
||||
let ctx = egui::Context::default();
|
||||
app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
|
||||
|
||||
options(&mut app).layers_only = true;
|
||||
app.session.execute("layer.locate", &json!({"layersOnly": true})).unwrap();
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Row(sub)));
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(rows_of(&app), vec![sub]);
|
||||
app.session.active_mut().unwrap().layers_open.set(layer, false);
|
||||
app.session.execute("layer.locate", &json!({"layersOnly": true})).unwrap();
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Row(sub)), "the highlighted row is asked for again");
|
||||
pass(&mut app, &ctx);
|
||||
assert!(is_open(&app, layer), "the layer around the sublayer opens again");
|
||||
app.session.active_mut().unwrap().layers_open.set(layer, false);
|
||||
pass(&mut app, &ctx);
|
||||
assert!(!is_open(&app, layer), "a pass without a Locate opens nothing");
|
||||
|
||||
options(&mut app).layers_only = false;
|
||||
app.session.execute("layer.locate", &json!({})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(rows_of(&app), vec![b]);
|
||||
for id in [sub, g] {
|
||||
app.session.active_mut().unwrap().layers_open.set(id, false);
|
||||
}
|
||||
app.session.execute("layer.locate", &json!({})).unwrap();
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Row(b)));
|
||||
pass(&mut app, &ctx);
|
||||
assert!(is_open(&app, layer) && is_open(&app, sub) && is_open(&app, g), "the layers and group around the object open again");
|
||||
assert_eq!(rows_of(&app), vec![b]);
|
||||
}
|
||||
|
||||
/// A layer of `n` groups of one path each, with only the layer open, as a document opens → (app, layer, the paths in
|
||||
/// stacking order, so the first is in the bottom row). The path in group `i` is named `Path {i}`.
|
||||
fn groups_of_one(n: usize) -> (VectorcraftApp, NodeId, Vec<NodeId>) {
|
||||
use vectorcraft_doc::Appearance;
|
||||
use vectorcraft_geom::{Rect, shapes};
|
||||
let mut d = Document::new(1000.0, 1000.0);
|
||||
let mut groups = vec![];
|
||||
let mut paths = vec![];
|
||||
for i in 0..n {
|
||||
let r = Rect::new(0.0, i as f64, 1.0, i as f64 + 1.0);
|
||||
let mut path = Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default());
|
||||
path.name = Some(format!("Path {i}"));
|
||||
paths.push(path.id);
|
||||
groups.push(Arc::new(Node::group(d.alloc_id(), vec![Arc::new(path)])));
|
||||
}
|
||||
*Arc::make_mut(&mut d.layers[0]).children_mut().unwrap() = groups;
|
||||
let layer = d.layers[0].id;
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
app.session.add_document(d, None);
|
||||
(app, layer, paths)
|
||||
}
|
||||
|
||||
/// Without Locate Selected Objects (the default), an object selected outside the panel leaves the open rows as they
|
||||
/// were; the request is taken and ignored. (The scroll offset is the framework panel's.)
|
||||
#[test]
|
||||
fn without_the_option_a_selection_leaves_the_rows_and_the_scroll_as_they_were() {
|
||||
let (mut app, layer, paths) = groups_of_one(500);
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
app.session.execute("select.set", &json!({"ids": [paths[0].0]})).unwrap();
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Selected(paths[0])));
|
||||
for _ in 0..2 {
|
||||
pass(&mut app, &ctx);
|
||||
}
|
||||
assert_eq!(reveal_of(&app), None, "the pass took the request");
|
||||
let group = parent(&app, paths[0]).unwrap();
|
||||
assert!(is_open(&app, layer) && !is_open(&app, group));
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, an object selected outside the panel is located as Locate Object locates it: the
|
||||
/// layer and the group around it open. The highlighted row stays as it was.
|
||||
#[test]
|
||||
fn with_the_option_a_selected_object_is_opened_and_scrolled_into_view() {
|
||||
let (mut app, layer, paths) = groups_of_one(500);
|
||||
options(&mut app).locate_selected = true;
|
||||
let ctx = egui::Context::default();
|
||||
let top = parent(&app, paths[499]).unwrap();
|
||||
app.session.execute("layer.highlight", &json!({"ids": [top.0]})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
expand(&mut app, &json!({"ids": [layer.0], "open": false})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 1, "only the layer's row");
|
||||
app.session.execute("select.set", &json!({"ids": [paths[0].0]})).unwrap();
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Selected(paths[0])));
|
||||
for _ in 0..4 {
|
||||
pass(&mut app, &ctx);
|
||||
}
|
||||
let group = parent(&app, paths[0]).unwrap();
|
||||
assert!(is_open(&app, layer) && is_open(&app, group), "the layer and the group open");
|
||||
assert_eq!(app.session.active().unwrap().highlighted_rows(), [top], "the highlighted row stays");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, the panel's own selecting locates nothing; an object then selected outside the
|
||||
/// panel is located, and the highlighted rows stay.
|
||||
#[test]
|
||||
fn with_the_option_the_panels_own_clicks_locate_nothing() {
|
||||
let (mut app, [layer, sub, g, b, _, c]) = nested();
|
||||
options(&mut app).locate_selected = true;
|
||||
expand(&mut app, &json!({"ids": [sub.0, g.0], "open": false})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "Layer 1, Sub (closed) and c");
|
||||
select_rows(&mut app, &[layer, sub, c]);
|
||||
assert_eq!(rows_of(&app), [layer, sub, c]);
|
||||
assert_eq!(reveal_of(&app), None, "a selection made in the panel asks for no reveal");
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "no row opens");
|
||||
app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 6, "b's sublayer and group open");
|
||||
assert_eq!(rows_of(&app), [layer, sub, c]);
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, a selection the panel menu changes is not located: Delete Selection deletes the
|
||||
/// highlighted object, and the object left selected stays in its closed sublayer and group.
|
||||
#[test]
|
||||
fn with_the_option_the_panel_menu_locates_nothing() {
|
||||
let (mut app, [_, sub, g, b, _, c]) = nested();
|
||||
options(&mut app).locate_selected = true;
|
||||
app.session.execute("select.set", &json!({"ids": [b.0, c.0]})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
expand(&mut app, &json!({"ids": [sub.0, g.0], "open": false})).unwrap();
|
||||
app.session.execute("layer.highlight", &json!({"ids": [c.0]})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "Layer 1, Sub (closed) and c");
|
||||
menu_run(&mut app, "ui.layerDelete", json!({})).unwrap();
|
||||
assert_eq!(app.session.active().unwrap().selection.objects, [b], "c is deleted and b stays selected");
|
||||
assert_eq!(reveal_of(&app), None);
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 2, "Sub stays closed");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, a saved selection recalled from the panel menu is not located.
|
||||
#[test]
|
||||
fn with_the_option_a_selection_recalled_from_the_panel_menu_is_not_located() {
|
||||
let (mut app, [_, sub, g, b, _, c]) = nested();
|
||||
options(&mut app).locate_selected = true;
|
||||
app.run("select.set", json!({"ids": [b.0]})).unwrap();
|
||||
app.run("select.save", json!({"name": "Kept"})).unwrap();
|
||||
app.run("select.set", json!({"ids": [c.0]})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
expand(&mut app, &json!({"ids": [sub.0, g.0], "open": false})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "Layer 1, Sub (closed) and c");
|
||||
menu_run(&mut app, "ui.layers.recall", json!({"name": "Kept"})).unwrap();
|
||||
assert_eq!(app.session.active().unwrap().selection.objects, [b], "the saved selection is recalled");
|
||||
assert_eq!(reveal_of(&app), None, "recalling clears the request");
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "Sub stays closed");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, the object selected in a document that becomes active is not located; an object
|
||||
/// selected after that is.
|
||||
#[test]
|
||||
fn with_the_option_a_document_becoming_active_locates_nothing() {
|
||||
let (mut app, [_, sub, g, b, a, _]) = nested();
|
||||
options(&mut app).locate_selected = true;
|
||||
app.session.execute("layer.highlight", &json!({"ids": []})).unwrap();
|
||||
app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
expand(&mut app, &json!({"ids": [sub.0, g.0], "open": false})).unwrap();
|
||||
app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
|
||||
app.session.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
app.session.execute("document.activate", &json!({"index": 0})).unwrap();
|
||||
assert_eq!(reveal_of(&app), None, "activating asks for no reveal");
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "b's sublayer and group stay closed");
|
||||
app.session.execute("select.set", &json!({"ids": [a.0]})).unwrap();
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Selected(a)));
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 5, "a's sublayer opens");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, the copies an Alt-drag selects are located once the drag ends, not while it lasts.
|
||||
#[test]
|
||||
fn with_the_option_a_selection_made_during_a_drag_is_located_when_it_ends() {
|
||||
let (mut app, [_, sub, g, b, ..]) = nested();
|
||||
options(&mut app).locate_selected = true;
|
||||
app.session.execute("select.set", &json!({"ids": [b.0]})).unwrap();
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
expand(&mut app, &json!({"ids": [sub.0, g.0], "open": false})).unwrap();
|
||||
pass(&mut app, &ctx);
|
||||
app.session.begin_interaction("Move").unwrap();
|
||||
for i in 1..=3 {
|
||||
app.session.preview("object.transform", &json!({"matrix": [1, 0, 0, 1, i * 10, 0], "copy": true})).unwrap();
|
||||
assert_eq!(reveal_of(&app), None, "a preview asks for nothing");
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 3, "nothing opens while the drag lasts");
|
||||
}
|
||||
app.session.commit_interaction().unwrap();
|
||||
let st = app.session.active().unwrap();
|
||||
let copy = st.selection.objects.last().copied().unwrap();
|
||||
assert!(copy != b && st.doc.parent_of(copy) == Some(g), "the copy is selected, in b's group");
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Selected(copy)));
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(listed_ids(&app).len(), 7, "Sub and the group open on the copy's row");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, art selected outside the panel in another layer is located as the art, not as its
|
||||
/// active layer. (The scroll offset is the framework panel's.)
|
||||
#[test]
|
||||
fn with_the_option_the_located_object_is_revealed_instead_of_its_active_layer() {
|
||||
let (mut app, layer, paths) = groups_of_one(500);
|
||||
options(&mut app).locate_selected = true;
|
||||
app.session.execute("layer.new", &json!({})).unwrap();
|
||||
assert_ne!(app.session.active().unwrap().current_layer(), Some(layer));
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
app.session.execute("select.set", &json!({"ids": [paths[0].0]})).unwrap();
|
||||
assert_eq!(app.session.active().unwrap().current_layer(), Some(layer), "the path's layer is the active one");
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Selected(paths[0])), "the art, not the layer");
|
||||
for _ in 0..4 {
|
||||
pass(&mut app, &ctx);
|
||||
}
|
||||
assert!(is_open(&app, parent(&app, paths[0]).unwrap()), "the group opens");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects and Show Layers Only on, art selected outside the panel has no row, so the request
|
||||
/// is for the layer that the selection makes the active one.
|
||||
#[test]
|
||||
fn with_the_option_and_show_layers_only_the_active_layer_is_revealed() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
options(&mut app).locate_selected = true;
|
||||
options(&mut app).layers_only = true;
|
||||
let run = |app: &mut VectorcraftApp, id: &str, p: serde_json::Value| app.session.execute(id, &p).unwrap();
|
||||
run(&mut app, "file.new", json!({"width": 100, "height": 100}));
|
||||
let rect = |app: &mut VectorcraftApp| run(app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 5, "height": 5}))["id"].as_u64().unwrap();
|
||||
let bottom = rect(&mut app);
|
||||
for _ in 0..59 {
|
||||
run(&mut app, "layer.new", json!({}));
|
||||
rect(&mut app);
|
||||
}
|
||||
run(&mut app, "select.none", json!({}));
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
let bottom_layer = app.session.active().unwrap().doc.layer_of(NodeId(bottom)).unwrap();
|
||||
run(&mut app, "select.set", json!({"ids": [bottom]}));
|
||||
// PLAN: the sheet row says `Current(layer)` here while writer note 3 says the session sets `Selected(object)` and
|
||||
// the panel falls back; the sheet row is asserted.
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Current(bottom_layer)));
|
||||
pass(&mut app, &ctx);
|
||||
assert_eq!(reveal_of(&app), None, "the pass took the request");
|
||||
}
|
||||
|
||||
/// With Locate Selected Objects on, art selected outside the panel that Show Layers Only or the filter leaves without a
|
||||
/// row opens nothing, so its group stays closed once the panel lists every row again. Art the filter keeps has its
|
||||
/// group opened.
|
||||
#[test]
|
||||
fn with_the_option_art_the_panel_does_not_list_opens_nothing() {
|
||||
let (mut app, _, paths) = groups_of_one(500);
|
||||
options(&mut app).locate_selected = true;
|
||||
let ctx = egui::Context::default();
|
||||
let open = |app: &VectorcraftApp, i: usize| is_open(app, parent(app, paths[i]).unwrap());
|
||||
let locate = |app: &mut VectorcraftApp, i: usize| {
|
||||
app.session.execute("select.set", &json!({"ids": [paths[i].0]})).unwrap();
|
||||
for _ in 0..4 {
|
||||
pass(app, &ctx);
|
||||
}
|
||||
};
|
||||
pass(&mut app, &ctx);
|
||||
options(&mut app).layers_only = true;
|
||||
locate(&mut app, 0);
|
||||
options(&mut app).layers_only = false;
|
||||
pass(&mut app, &ctx);
|
||||
assert!(!open(&app, 0), "Show Layers Only: the group stays closed");
|
||||
app.ui.layers_ui.filter = LayerFilter { objects: vec![FilterObject::Text], ..Default::default() };
|
||||
locate(&mut app, 1);
|
||||
assert!(!open(&app, 1), "a filter that leaves the path out: the group stays closed");
|
||||
app.ui.layers_ui.filter = LayerFilter { objects: vec![FilterObject::Paths], ..Default::default() };
|
||||
locate(&mut app, 2);
|
||||
assert!(open(&app, 2), "a filter that keeps the path: the group opens");
|
||||
}
|
||||
|
||||
/// Selecting art on the canvas makes its layer the active one and asks to reveal it, but not while a row is
|
||||
/// highlighted in the panel.
|
||||
#[test]
|
||||
fn a_canvas_selection_reveals_its_active_layer() {
|
||||
let mut app = VectorcraftApp::new(Session::new(), Default::default());
|
||||
let run = |app: &mut VectorcraftApp, id: &str, p: serde_json::Value| app.session.execute(id, &p).unwrap();
|
||||
run(&mut app, "file.new", json!({"width": 100, "height": 100}));
|
||||
let mut rects = vec![run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 5, "height": 5}))["id"].as_u64().unwrap()];
|
||||
for _ in 0..59 {
|
||||
run(&mut app, "layer.new", json!({}));
|
||||
rects.push(run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 5, "height": 5}))["id"].as_u64().unwrap());
|
||||
}
|
||||
run(&mut app, "select.none", json!({}));
|
||||
let ctx = egui::Context::default();
|
||||
pass(&mut app, &ctx);
|
||||
let doc = app.session.active().unwrap().doc.clone();
|
||||
let bottom_layer = doc.layer_of(NodeId(rects[0])).unwrap();
|
||||
let top_layer = doc.layer_of(NodeId(rects[59])).unwrap();
|
||||
run(&mut app, "select.set", json!({"ids": [rects[0]]}));
|
||||
assert_eq!(app.session.active().unwrap().current_layer(), Some(bottom_layer));
|
||||
assert_eq!(reveal_of(&app), Some(LayersReveal::Current(bottom_layer)), "no row is highlighted: the active layer");
|
||||
pass(&mut app, &ctx);
|
||||
// A row highlighted in the panel keeps the view when the active layer changes.
|
||||
run(&mut app, "layer.highlight", json!({"ids": [top_layer.0], "mode": "set"}));
|
||||
pass(&mut app, &ctx);
|
||||
run(&mut app, "select.set", json!({"ids": [rects[30]]}));
|
||||
assert_eq!(reveal_of(&app), None, "a highlighted row keeps the view");
|
||||
}
|
||||
Reference in New Issue
Block a user