diff --git a/crates/ui-egui/src/placing.rs b/crates/ui-egui/src/placing.rs index ca380f7ca8..c43ad596b4 100644 --- a/crates/ui-egui/src/placing.rs +++ b/crates/ui-egui/src/placing.rs @@ -21,10 +21,11 @@ use vectorcraft_engine::file_access::ScopeHandle; use crate::VectorcraftApp; -/// What was read: one file to place, the files to load the place cursor with (and whether they ask -/// for their import options when placed), or a bitmap to paste. +/// What was read: one file to place (and where new art went when it was placed), the files to load +/// the place cursor with (and whether they ask for their import options when placed), or a bitmap +/// to paste. enum Read { - Place(Box), + Place(Box, Insertion), Queue(QueueRead, bool), Paste(Box), } @@ -56,7 +57,8 @@ struct Paste { } /// Where new art goes in the active document: the current layer, the isolated group or object, and -/// the drawing mode with the object Draw Inside draws into. +/// the drawing mode with the object Draw Inside draws into. A paste and a placed file read off the +/// UI thread keep the one from when they were given. #[derive(Clone, PartialEq)] struct Insertion { layer: Option, @@ -81,9 +83,34 @@ impl Insertion { Some(Self { layer, isolation, draw_mode, draw_inside }) } + /// Whether new art can still go where `self` says in `app`'s active document: the isolated group + /// or object when it names one, else the object Draw Inside draws into when it names one and + /// `draws_inside` (a paste draws inside it, a placed file does not), else its layer, which must + /// still be a layer, is still there, shown and unlocked. A paste or a placed file whose layer or + /// group was deleted, hidden or locked meanwhile goes where new art goes now. + fn usable(&self, app: &VectorcraftApp, draws_inside: bool) -> bool { + app.session.doc().is_ok_and(|st| { + let inside = self.draw_inside.filter(|_| draws_inside && self.draw_mode == vectorcraft_engine::DrawMode::Inside); + match (self.isolation, inside, self.layer) { + (Some(target), ..) | (None, Some(target), _) => st.doc.is_editable(target), + (None, None, Some(l)) => st.doc.node(l).is_some_and(|n| n.is_layer()) && st.doc.is_editable(l), + (None, None, None) => true, + } + }) + } + + /// `self` when new art can still go there ([`Self::usable`]), else `now`: where new art went + /// before the paste or the place selected anything again. + fn or_now(self, now: Option<&Self>, app: &VectorcraftApp, draws_inside: bool) -> Self { + match now { + Some(now) if !self.usable(app, draws_inside) => now.clone(), + _ => self, + } + } + /// Put back each part of `self` (where new art went before [`Self::set`] set `started`) that - /// differs from `started`, what the user changed meanwhile; a part the paste itself changed - /// stays as the paste left it. + /// differs from `started`, what the user changed meanwhile; a part the paste or the place + /// itself changed stays as it left it. fn restore_changed(self, started: &Self, app: &mut VectorcraftApp) { if let Ok(st) = app.session.doc_mut() { if self.layer != started.layer { @@ -224,7 +251,9 @@ pub fn start(app: &mut VectorcraftApp, p: &Value, dropped: bool) -> Result) { } app.session.set_active(i); let r = match r { - Ok(Read::Place(read)) => app.session.place_read(*read).map(|_| ()).map_err(|e| e.to_string()), + Ok(Read::Place(read, insertion)) => { + // The file goes where new art went when it was placed (the current layer, the isolated + // group), as a paste does, and what the user changed meanwhile is kept. Where new art + // goes now is taken before Replace selects the object it swaps again. + let current = Insertion::of(app); + let insertion = insertion.or_now(current.as_ref(), app, false); + insertion.clone().set(app); + let r = app.session.place_read(*read).map(|_| ()).map_err(|e| e.to_string()); + if let Some(current) = current { + current.restore_changed(&insertion, app); + } + r + } Ok(Read::Queue(read, asks)) => { app.session.place_queue_read(read).map(|r| crate::place::show_thumbnails(app, &r, asks)).map_err(|e| e.to_string()) } @@ -540,7 +581,8 @@ fn finish_paste(app: &mut VectorcraftApp, paste: Paste) { // The paste goes where new art went when it started (the current layer, the isolated // group, the object Draw Inside draws into), and what the user changed meanwhile is // kept. - paste.insertion.clone().set(app); + let insertion = paste.insertion.or_now(current.as_ref(), app, pastes_inside(&paste.id)); + insertion.clone().set(app); let requested_selection = app.session.doc().map(|st| st.selection.objects.clone()).unwrap_or_default(); app.placing.adopted = true; // `run` shows an error in the status bar. @@ -552,7 +594,7 @@ fn finish_paste(app: &mut VectorcraftApp, paste: Paste) { if let Ok(st) = app.session.doc() { app.placing.swatch_paste = Some(PendingSwatch { clipboard: app.session.clipboard.clone(), - insertion: paste.insertion.clone(), + insertion: insertion.clone(), selection: requested_selection, doc: st.uid, reverts: st.reverts, @@ -562,7 +604,7 @@ fn finish_paste(app: &mut VectorcraftApp, paste: Paste) { } } if let Some(current) = current { - current.restore_changed(&paste.insertion, app); + current.restore_changed(&insertion, app); } app.session.doc().ok().map(|st| st.selection.objects.clone()) } @@ -613,6 +655,12 @@ pub(crate) fn settle_swatch_paste(app: &mut VectorcraftApp) { } } +/// Does the paste command `id` paste inside the object Draw Inside draws into? Paste in Front and +/// Paste in Back keep their own places. +fn pastes_inside(id: &str) -> bool { + !matches!(id, "edit.pasteInFront" | "edit.pasteInBack") +} + /// Run the command confirmed by the deferred paste's Swatch Conflict dialog. pub(crate) fn confirm_swatch_paste(app: &mut VectorcraftApp, id: &str, params: Value, token: Option) -> Result { if !app.placing.swatch_paste.as_ref().is_some_and(|waiting| Some(waiting.chain) == token) { @@ -643,7 +691,7 @@ pub(crate) fn confirm_swatch_paste(app: &mut VectorcraftApp, id: &str, params: V if selected != now.iter().map(|id| id.0).collect::>() { let _ = app.session.execute("select.set", &json!({"ids": selected})); } - let insertion = waiting.insertion.clone(); + let insertion = waiting.insertion.clone().or_now(changed.as_ref(), app, pastes_inside(id)); insertion.clone().set(app); app.placing.adopted = true; let result = app.run(id, params); diff --git a/crates/ui-egui/src/placing/tests.rs b/crates/ui-egui/src/placing/tests.rs index 9043bac0ea..af411f3430 100644 --- a/crates/ui-egui/src/placing/tests.rs +++ b/crates/ui-egui/src/placing/tests.rs @@ -661,6 +661,134 @@ fn a_deferred_swatch_paste_uses_its_original_layer() { assert_eq!(st.current_layer(), Some(second)); } +/// A bitmap pasted from another app while a group is isolated goes into that group when the +/// isolation ends and the current layer, which does not hold the group, is locked while the bitmap +/// is decoded. +#[test] +fn a_bitmap_pasted_into_an_isolated_group_stays_there_when_another_layer_is_locked() { + let (mut app, _) = pasting_app(true, Some(Flavour { mime: PNG, data: picture(Png, 60, 40) }), None, true); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let squares: Vec = + (0..2).map(|i| app.run("shape.rectangle", json!({"x": 10 + 30 * i, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone()).collect(); + app.run("select.set", json!({"ids": squares})).unwrap(); + let group = NodeId(app.run("object.group", json!({})).unwrap()["id"].as_u64().unwrap()); + app.run("select.none", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + app.run("object.isolate", json!({"id": group.0})).unwrap(); + app.session.doc_mut().unwrap().active_layer = Some(first); + crate::menus::invoke(&mut app, "edit.paste", json!({})); + app.run("object.exitIsolation", json!({})).unwrap(); + app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + assert_eq!(st.selection.objects.first().and_then(|i| st.doc.parent_of(*i)), Some(group), "pasted into the group isolated at the paste"); + assert_eq!(st.isolation, None, "the isolation ended meanwhile stays ended"); +} + +/// A bitmap pasted from another app whose layer is locked while it is decoded goes into the layer +/// current then, also when the objects selected at the paste, which it selects again, are in +/// another layer. +#[test] +fn a_bitmap_whose_layer_is_locked_meanwhile_is_not_pasted_next_to_the_selection() { + let (mut app, _) = pasting_app(true, Some(Flavour { mime: PNG, data: picture(Png, 60, 40) }), None, true); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let selected = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone(); + let second = app.session.doc().unwrap().current_layer().unwrap(); + app.run("layer.new", json!({})).unwrap(); + let third = app.session.doc().unwrap().current_layer().unwrap(); + app.run("select.set", json!({"ids": [selected]})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + assert_eq!(app.session.doc().unwrap().selection.objects.len(), 1); + crate::menus::invoke(&mut app, "edit.paste", json!({})); + app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(); + app.run("layer.setCurrent", json!({"id": third.0})).unwrap(); + app.run("select.none", json!({})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + let pasted = st.selection.objects.first().and_then(|i| st.doc.layer_containing(*i)); + assert_eq!(pasted, Some(third), "pasted into the current layer, not {second:?}"); +} + +/// In Draw Inside, a bitmap decoded off the UI thread is pasted inside the object Draw Inside draws +/// into, in another layer, when the layer current at the paste is locked meanwhile. +#[test] +fn a_bitmap_pasted_in_draw_inside_stays_inside_when_its_layer_is_locked() { + let (mut app, _) = pasting_app(true, Some(Flavour { mime: PNG, data: picture(Png, 60, 40) }), None, true); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let path = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 200, "height": 200})).unwrap()["id"].clone(); + app.run("layer.new", json!({})).unwrap(); + let third = app.session.doc().unwrap().current_layer().unwrap(); + app.run("select.set", json!({"ids": [path]})).unwrap(); + app.run("view.drawMode", json!({"mode": "inside"})).unwrap(); + app.run("select.none", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + crate::menus::invoke(&mut app, "edit.paste", json!({})); + app.run("view.drawMode", json!({"mode": "normal"})).unwrap(); + app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(); + app.run("layer.setCurrent", json!({"id": third.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + let group = st.selection.objects.first().and_then(|i| st.doc.parent_of(*i)); + assert!( + group.is_some_and(|g| st.doc.node(g).is_some_and(|n| n.children().is_some_and(|c| c.iter().any(|n| n.id.0 == path.as_u64().unwrap())))), + "pasted inside the path" + ); +} + +/// Paste in Front does not paste inside the object Draw Inside draws into: a bitmap decoded off the +/// UI thread goes into the layer current at the paste when that object is locked meanwhile. +#[test] +fn a_bitmap_pasted_in_front_in_draw_inside_keeps_its_layer() { + let (mut app, _) = pasting_app(true, Some(Flavour { mime: PNG, data: picture(Png, 60, 40) }), None, true); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let second = app.session.doc().unwrap().current_layer().unwrap(); + let path = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 200, "height": 200})).unwrap()["id"].clone(); + app.run("layer.new", json!({})).unwrap(); + let third = app.session.doc().unwrap().current_layer().unwrap(); + app.run("select.set", json!({"ids": [path]})).unwrap(); + app.run("view.drawMode", json!({"mode": "inside"})).unwrap(); + app.run("select.none", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + crate::menus::invoke(&mut app, "edit.pasteInFront", json!({})); + app.run("layer.setProps", json!({"ids": [second.0], "locked": true})).unwrap(); + app.run("layer.setCurrent", json!({"id": third.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + assert_eq!(st.selection.objects.first().and_then(|i| st.doc.layer_containing(*i)), Some(first), "pasted into the layer current at the paste"); +} + +/// A paste waiting for its Swatch Conflict dialog whose layer is locked before the dialog's OK +/// goes into the layer current at the OK, not into the topmost layer. +#[test] +fn a_deferred_swatch_paste_whose_layer_is_locked_meanwhile_uses_the_current_layer() { + let (mut app, _) = pasting_app(true, None, None, true); + app.run("swatch.new", json!({"name": "Brand", "color": "#ff0000", "global": true})).unwrap(); + let source = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone(); + app.run("paint.setFill", json!({"ids": [source], "swatch": "Brand"})).unwrap(); + app.run("edit.copy", json!({})).unwrap(); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("swatch.new", json!({"name": "Brand", "color": "#0000ff", "global": true})).unwrap(); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let second = app.session.doc().unwrap().current_layer().unwrap(); + app.run("layer.new", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + app.run("select.none", json!({})).unwrap(); + crate::menus::invoke(&mut app, "edit.paste", json!({})); + placed(&mut app); + assert_eq!(app.ui.dialog.as_ref().unwrap().kind, crate::dialogs::swatch_conflict::KIND); + app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + app.ui.dialog.as_mut().unwrap().fields.insert("choice".into(), json!("add")); + crate::dialogs::confirm(&mut app).unwrap(); + let st = app.session.doc().unwrap(); + assert_eq!(st.selection.objects.first().and_then(|i| st.doc.layer_containing(*i)), Some(second)); +} + #[test] fn a_queued_paste_stacks_after_a_deferred_swatch_confirmation() { for id in ["edit.pasteInFront", "edit.pasteInBack"] { @@ -970,6 +1098,166 @@ fn a_bitmap_read_off_the_ui_thread_is_pasted_into_its_layer() { assert_eq!(st.current_layer(), Some(second), "the layer of the object selected meanwhile stays current"); } +/// An app placing off the UI thread with three layers, the bottom one current → the app, a TIFF +/// file to place and the layers from the bottom up. +fn three_layers(test: &str) -> (VectorcraftApp, String, [NodeId; 3]) { + let mut app = app(true); + let path = saved(test, "a.tif", &picture(Tiff, 60, 40)); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let second = app.session.doc().unwrap().current_layer().unwrap(); + app.run("layer.new", json!({})).unwrap(); + let third = app.session.doc().unwrap().current_layer().unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + (app, path, [first, second, third]) +} + +/// A file read off the UI thread after the Place dialog's OK is placed into the layer that was +/// current at the OK, and a layer made current while it is read stays current. +#[test] +fn a_file_read_off_the_ui_thread_is_placed_into_its_layer() { + let (mut app, a, [first, second, _]) = three_layers("into-its-layer"); + app.run("file.place", json!({"paths": [a]})).unwrap(); + assert_eq!(crate::dialogs::confirm(&mut app).unwrap()["background"], true); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + assert_eq!(st.doc.layer_containing(st.selection.objects[0]), Some(first), "placed into the layer current at the OK"); + assert_eq!(st.current_layer(), Some(second), "the layer made current meanwhile stays current"); +} + +/// A file dropped on the canvas goes into the layer current at the drop, not into a group in +/// another layer isolated while the file is read, and the group stays isolated. +#[test] +fn a_dropped_file_is_placed_into_the_layer_current_at_the_drop() { + let (mut app, a, [first, second, _]) = three_layers("drop-into-its-layer"); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + let squares: Vec = + (0..2).map(|i| app.run("shape.rectangle", json!({"x": 10 + 30 * i, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone()).collect(); + app.run("select.set", json!({"ids": squares})).unwrap(); + let group = NodeId(app.run("object.group", json!({})).unwrap()["id"].as_u64().unwrap()); + app.run("select.none", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + let doc = app.session.doc().unwrap().uid; + let drop = DropTarget::Place(DropAt { doc, reverts: 0, at: vectorcraft_geom::Point::new(200.0, 150.0), embed: false }); + crate::place::drop_files(&mut app, vec![(drop, ("a.tif".into(), Some(a), vec![]))]); + app.run("object.isolate", json!({"id": group.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + assert_eq!(st.doc.parent_of(st.selection.objects[0]), Some(first), "placed into the layer current at the drop"); + assert_eq!(st.isolation, Some(group), "the group stays isolated"); +} + +/// An object selected in another layer while a placed file is read makes that layer current, and +/// it stays current after the file is placed into the layer current at the OK. +#[test] +fn a_file_placed_while_an_object_in_another_layer_is_selected_keeps_its_layer() { + let (mut app, a, [first, second, _]) = three_layers("select-meanwhile"); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + let square = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + app.run("select.none", json!({})).unwrap(); + app.run("file.place", json!({"paths": [a]})).unwrap(); + crate::dialogs::confirm(&mut app).unwrap(); + app.run("select.set", json!({"ids": [square]})).unwrap(); + assert_eq!(app.session.doc().unwrap().current_layer(), Some(second)); + placed(&mut app); + let st = app.session.doc().unwrap(); + assert_eq!(st.doc.layer_containing(st.selection.objects[0]), Some(first), "placed into the layer current at the OK"); + assert_eq!(st.current_layer(), Some(second), "the layer of the object selected meanwhile stays current"); +} + +/// Replace swaps the object selected at the OK in its own layer, and a layer made current while the +/// file is read stays current after Replace selects that object again. +#[test] +fn a_replace_read_off_the_ui_thread_keeps_the_layer_made_current_meanwhile() { + let (mut app, a, [first, second, _]) = three_layers("replace-meanwhile"); + app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap(); + crate::place::run_for_user(&mut app, &json!({"path": a, "replace": true})).unwrap(); + app.run("select.none", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + let image = st.selection.objects[0]; + assert!(matches!(st.doc.node(image).map(|n| &n.kind), Some(vectorcraft_doc::NodeKind::Image(_))), "{}", app.ui.status); + assert_eq!(st.doc.layer_containing(image), Some(first), "the image takes the replaced object's place"); + assert_eq!(st.current_layer(), Some(second), "the layer made current meanwhile stays current"); +} + +/// A file whose layer is deleted or locked while it is read goes where new art goes now: into the +/// layer current then, not into the topmost layer. +#[test] +fn a_file_whose_layer_is_deleted_or_locked_meanwhile_goes_into_the_current_layer() { + let mut found = vec![]; + let mut wanted = vec![]; + for change in ["delete", "lock", "hide"] { + let (mut app, a, [first, second, _]) = three_layers(&format!("layer-{change}")); + app.run("file.place", json!({"paths": [a]})).unwrap(); + crate::dialogs::confirm(&mut app).unwrap(); + match change { + "delete" => app.run("layer.delete", json!({"ids": [first.0]})).unwrap(), + "lock" => app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(), + _ => app.run("layer.setProps", json!({"ids": [first.0], "visible": false})).unwrap(), + }; + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + let image = st.selection.objects.first().copied(); + found.push((change, image.and_then(|i| st.doc.layer_containing(i)), st.current_layer())); + wanted.push((change, Some(second), Some(second))); + } + assert_eq!(found, wanted, "placed into the current layer, which stays current"); +} + +/// Place does not draw inside an object: with Draw Inside on for an object in another layer, a file +/// whose layer is locked while it is read goes into the layer current then. +#[test] +fn a_file_placed_with_draw_inside_on_follows_its_layer() { + let (mut app, a, [first, second, _]) = three_layers("draw-inside"); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + let inside = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 200, "height": 200})).unwrap()["id"].clone(); + app.run("select.set", json!({"ids": [inside]})).unwrap(); + app.run("view.drawMode", json!({"mode": "inside"})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + app.run("select.none", json!({})).unwrap(); + assert_eq!(app.session.draw_inside.map(|t| t.0), inside.as_u64()); + app.run("file.place", json!({"paths": [a]})).unwrap(); + crate::dialogs::confirm(&mut app).unwrap(); + app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(); + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + assert_eq!(st.selection.objects.first().and_then(|i| st.doc.layer_containing(*i)), Some(second), "placed into the current layer"); +} + +/// A bitmap pasted from another app whose layer is deleted, locked or hidden while it is decoded +/// goes into the layer current then, not into the topmost layer. +#[test] +fn a_bitmap_whose_layer_is_deleted_or_locked_meanwhile_is_pasted_into_the_current_layer() { + let mut found = vec![]; + let mut wanted = vec![]; + for change in ["delete", "lock", "hide"] { + let (mut app, _) = pasting_app(true, Some(Flavour { mime: PNG, data: picture(Png, 60, 40) }), None, true); + let first = app.session.doc().unwrap().doc.layers[0].id; + app.run("layer.new", json!({})).unwrap(); + let second = app.session.doc().unwrap().current_layer().unwrap(); + app.run("layer.new", json!({})).unwrap(); + app.run("layer.setCurrent", json!({"id": first.0})).unwrap(); + crate::menus::invoke(&mut app, "edit.paste", json!({})); + match change { + "delete" => app.run("layer.delete", json!({"ids": [first.0]})).unwrap(), + "lock" => app.run("layer.setProps", json!({"ids": [first.0], "locked": true})).unwrap(), + _ => app.run("layer.setProps", json!({"ids": [first.0], "visible": false})).unwrap(), + }; + app.run("layer.setCurrent", json!({"id": second.0})).unwrap(); + placed(&mut app); + let st = app.session.doc().unwrap(); + found.push((change, st.selection.objects.first().and_then(|i| st.doc.layer_containing(*i)))); + wanted.push((change, Some(second))); + } + assert_eq!(found, wanted, "pasted into the current layer"); +} + /// The Place dialog's OK with one file, with several (the place cursor and its thumbnails), a /// drop on the canvas and [`crate::io::place_bytes`] read their files off the UI thread; /// `file.place` and `file.place.queue` from MCP and scripts read them at once, with the replies