diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs index 359fc8761f..250110527c 100644 --- a/crates/engine/src/cmd.rs +++ b/crates/engine/src/cmd.rs @@ -903,7 +903,7 @@ pub use gradpresets::{GradientPreset, GradientPresetEntry}; pub use buildcmds::{TracePreset, TracePresetChange}; /// An Image Trace made off the UI thread, and what it traced (#3098). -pub use buildcmds::{TraceRun, Traced}; +pub use buildcmds::{TraceRun, Traced, image_trace_target}; /// The saved Image Trace presets' revision and latest changes ([`crate::Session`] keeps them). pub(crate) use buildcmds::TracePresetChanges; diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs index b739ca5f7e..905372fd06 100644 --- a/crates/engine/src/cmd/buildcmds.rs +++ b/crates/engine/src/cmd/buildcmds.rs @@ -42,7 +42,7 @@ pub(crate) use live_paint::{LivePaintMove, check_part_name, clear_part_name, iso use live_paint::{lp_expand, lp_fill, lp_gap_options, lp_info, lp_make, lp_merge, lp_release, lp_stroke_edge}; use shape_builder::{sb_merge, sb_regions}; pub(crate) use trace::TracePresetChanges; -pub use trace::{TracePreset, TracePresetChange, TraceRun, Traced}; +pub use trace::{TracePreset, TracePresetChange, TraceRun, Traced, image_trace_target}; use trace::{trace_expand, trace_make, trace_presets_delete, trace_presets_save, trace_release, trace_set_view}; /// Name of an Image Trace group. diff --git a/crates/engine/src/cmd/buildcmds/trace.rs b/crates/engine/src/cmd/buildcmds/trace.rs index 203fd62338..3ef8edc5c4 100644 --- a/crates/engine/src/cmd/buildcmds/trace.rs +++ b/crates/engine/src/cmd/buildcmds/trace.rs @@ -600,6 +600,30 @@ struct Prepared { library: Vec<([u8; 3], Paint)>, } +/// The object `imageTrace.make` would trace, without preparing settings or reading image bytes. +pub fn image_trace_target(s: &Session, p: &Value) -> Result { + target_image(s, "imageTrace.make", p).map(|(target, _)| target) +} + +fn target_image(s: &Session, c: &str, p: &Value) -> Result<(NodeId, Box)> { + let roots = root_ids(s, p)?; + let d = &s.doc()?.doc; + roots + .iter() + .find_map(|r| { + let n = d.node(*r)?; + match &n.kind { + NodeKind::Image(i) => Some((*r, i.clone())), + _ if is_trace_group(n) => match &n.children()?.first()?.kind { + NodeKind::Image(i) => Some((*r, i.clone())), + _ => None, + }, + _ => None, + } + }) + .ok_or_else(|| bad(c, "select an image (or an Image Trace group)")) +} + /// What command `c` with params `p` traces, and how, from the session: everything but the trace. fn prepare(s: &Session, c: &str, p: &Value) -> Result { let mut params = trace_params(s, c, p)?; @@ -619,25 +643,7 @@ fn prepare(s: &Session, c: &str, p: &Value) -> Result { None if is(tr::preset(named)) || is(tr::enhanced_preset(named)) => named.to_string(), None => "Custom".to_string(), }; - let roots = root_ids(s, p)?; - // The image (inside a trace group, or selected directly). - let (target, image) = { - let d = &s.doc()?.doc; - roots - .iter() - .find_map(|r| { - let n = d.node(*r)?; - match &n.kind { - NodeKind::Image(i) => Some((*r, i.clone())), - _ if is_trace_group(n) => match &n.children()?.first()?.kind { - NodeKind::Image(i) => Some((*r, i.clone())), - _ => None, - }, - _ => None, - } - }) - .ok_or_else(|| bad(c, "select an image (or an Image Trace group)"))? - }; + let (target, image) = target_image(s, c, p)?; if by_color && s.doc()?.doc.node(target).is_some_and(vectorcraft_render::effects::has_pathfinder) { return Err(bad(c, LIVE_PATHFINDER_BY_COLOR)); } diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index d1406d77d6..bfb89b5833 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -490,7 +490,6 @@ fn reset_ignore_sampler_clicks(ui: &Ui, id: egui::Id) { /// Reclassify only the two clicks whose raw history can still contain a consumed pick. /// Other widgets' clicks count too, as they do in egui; its pointer state stays untouched. fn ignore_sampler_clicks(ui: &Ui, id: egui::Id, consumed: bool) { - let (delay, distance) = ui.ctx().options(|o| (o.input_options.max_double_click_delay, o.input_options.max_click_dist)); let (clicked, primary, at, time) = ui.input(|i| { // A hover move after the release is not the position egui put in its click history. let at = i.events.iter().rev().find_map(|event| match event { @@ -508,6 +507,11 @@ fn ignore_sampler_clicks(ui: &Ui, id: egui::Id, consumed: bool) { return; } let Some(at) = at else { return }; + record_ignore_sampler_click(ui, id, at, time, primary); +} + +fn record_ignore_sampler_click(ui: &Ui, id: egui::Id, at: Pos2, time: f64, primary: bool) { + let (delay, distance) = ui.ctx().options(|o| (o.input_options.max_double_click_delay, o.input_options.max_click_dist)); ui.data_mut(|data| { let history_id = id.with("image-trace-clicks"); let Some(mut clicks) = data.remove_temp::(history_id) else { return }; @@ -551,20 +555,126 @@ fn clear_ignore_sampler_gesture(ui: &Ui, id: egui::Id) { }); } -fn begin_ignore_sampler_pointer(ui: &Ui, id: egui::Id, cancelled: bool) -> bool { - let (pressed, released, down) = ui.input(|i| (i.pointer.primary_pressed(), i.pointer.primary_released(), i.pointer.primary_down())); - if pressed { - // A fresh press replaces the complete sampler gesture if its release was not observed. - if ignore_sampler_owns_primary(ui, id) { - clear_ignore_sampler_gesture(ui, id); +#[derive(Clone, Copy)] +struct IgnoreSamplerRelease { + button: egui::PointerButton, + at: Pos2, + clicked: bool, +} + +#[derive(Default)] +struct IgnoreSamplerPointer { + owned: bool, + replaced: bool, + ordinary_pressed: bool, + consumed_release: bool, + releases: Vec, +} + +/// Attribute a fresh press after an owned release before egui's per-frame flags lose their order. +fn ignore_sampler_pointer_frame(ui: &Ui, id: egui::Id, cancelled: bool) -> IgnoreSamplerPointer { + let owned = ignore_sampler_owns_primary(ui, id); + if !owned && !cancelled { + return IgnoreSamplerPointer::default(); + } + let (distance, duration) = ui.ctx().options(|o| (o.input_options.max_click_dist, o.input_options.max_click_duration)); + ui.input(|i| { + let mut frame = IgnoreSamplerPointer { owned, ..Default::default() }; + let mut first_press_owned = cancelled; + let mut press = None; + let mut moved = false; + let mut primary_pressed = false; + for event in &i.events { + match event { + egui::Event::PointerMoved(at) => { + if let Some((_, origin)) = press { + moved |= Pos2::distance(origin, *at) > distance; + } + } + egui::Event::PointerButton { pos, button, pressed, .. } => { + if *pressed { + press = Some((*button, *pos)); + moved = false; + if *button == egui::PointerButton::Primary { + primary_pressed = true; + frame.replaced |= frame.owned; + // An observed old Up ends that cancelled sequence; without it, + // a fresh invalid press keeps the existing cancellation gate. + frame.owned = first_press_owned && !frame.consumed_release; + first_press_owned = false; + frame.ordinary_pressed |= !frame.owned; + } + } else { + // A fresh primary click needs its own Down, not an earlier owned click. + // Slop/origin are shared by buttons in egui; each press resets them, and + // a release clears its press time. In-frame presses have the same time. + let clicked = ignore_sampler_release_clicked(press, moved, primary_pressed, *button, duration); + ignore_sampler_release(&mut frame, *button, *pos, clicked); + if *button == egui::PointerButton::Primary { + primary_pressed = false; + } + press = None; + } + } + _ => {} + } } - if cancelled { - ui.data_mut(|data| data.insert_temp(ignore_sampler_primary_id(id), true)); + frame + }) +} + +fn ignore_sampler_release_clicked( + press: Option<(egui::PointerButton, Pos2)>, + moved: bool, + primary_pressed: bool, + button: egui::PointerButton, + duration: f64, +) -> bool { + let matched = if button == egui::PointerButton::Primary { primary_pressed } else { press.is_some_and(|(b, _)| b == button) }; + matched && !moved && (press.is_none() || !matches!(duration.partial_cmp(&0.0), Some(std::cmp::Ordering::Less))) +} + +fn ignore_sampler_release(frame: &mut IgnoreSamplerPointer, button: egui::PointerButton, at: Pos2, clicked: bool) { + if button == egui::PointerButton::Primary && frame.owned { + frame.consumed_release = true; + frame.releases.clear(); + } else if frame.consumed_release { + frame.releases.push(IgnoreSamplerRelease { button, at, clicked }); + } +} + +fn ignore_sampler_frame_clicks(ui: &Ui, id: egui::Id, frame: &IgnoreSamplerPointer, consumed: bool) { + if !frame.consumed_release || !frame.ordinary_pressed { + ignore_sampler_clicks(ui, id, consumed); + return; + } + // Consume the old sequence, then classify only subsequent ordinary releases. A new Down + // still reaches the tool when the last release belongs to the consumed sequence. + reset_ignore_sampler_clicks(ui, id); + ui.data_mut(|data| data.insert_temp(id.with("image-trace-click-count"), 0u8)); + let time = ui.input(|i| i.time); + for release in &frame.releases { + let primary = release.button == egui::PointerButton::Primary; + if release.clicked { + record_ignore_sampler_click(ui, id, release.at, time, primary); + } else if primary { + ui.data_mut(|data| data.insert_temp(id.with("image-trace-click-count"), 0u8)); } } - let consumed = ignore_sampler_owns_primary(ui, id) && (pressed || released || down); - ignore_sampler_clicks(ui, id, consumed); - consumed +} + +fn begin_ignore_sampler_pointer(ui: &Ui, id: egui::Id, cancelled: bool) -> (bool, bool) { + let frame = ignore_sampler_pointer_frame(ui, id, cancelled); + if frame.replaced { + // This also replaces an abandoned sampler Down whose release was not observed. + clear_ignore_sampler_gesture(ui, id); + } + if frame.owned { + ui.data_mut(|data| data.insert_temp(ignore_sampler_primary_id(id), true)); + } + let consumed = frame.owned && ui.input(|i| i.pointer.primary_pressed() || i.pointer.primary_released() || i.pointer.primary_down()); + ignore_sampler_frame_clicks(ui, id, &frame, consumed); + (consumed, frame.ordinary_pressed) } fn end_ignore_sampler_pointer(ui: &Ui, id: egui::Id) { @@ -589,8 +699,8 @@ fn observe_hidden_ignore_sampler_pointer(app: &VectorcraftApp, ui: &Ui, home_sho /// A sampler press keeps its release, even if its Down completes or its binding expires held. fn input_after_sampler_refresh(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect, cancelled: bool) { - let consumed = begin_ignore_sampler_pointer(ui, resp.id, cancelled); - if !consumed && (!cancelled || !ui.input(|i| i.pointer.any_pressed())) { + let (consumed, ordinary_pressed) = begin_ignore_sampler_pointer(ui, resp.id, cancelled); + if !consumed && (ordinary_pressed || !cancelled || !ui.input(|i| i.pointer.any_pressed())) { canvas_input(app, ui, resp, rect); } end_ignore_sampler_pointer(ui, resp.id); diff --git a/crates/ui-egui/src/canvas/input.rs b/crates/ui-egui/src/canvas/input.rs index 3aa3b48613..748ad07654 100644 --- a/crates/ui-egui/src/canvas/input.rs +++ b/crates/ui-egui/src/canvas/input.rs @@ -136,7 +136,7 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo drag_held(app, ui, &f, d, p); } else { // The drag ends where its button went up: the moves after the release in this frame are hover. - drag_released(app, ui, &f, d, release_pos(ui, button).unwrap_or(p)); + drag_released(app, ui, &f, d, release_pos(ui, button, false).unwrap_or(p)); } } else if let Some(p) = hover_tool // A press on an artboard's name starts no drag: the moves while it is held are not hover. @@ -189,14 +189,14 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo if !super::ignore_sampler_owns_primary(ui, resp.id) && super::primary_click_count(ui, resp) == 2 && !f.modal - && let Some(p) = at + && let Some(p) = release_pos(ui, egui::PointerButton::Primary, true).or(at) { double_click(app, ui, &f, p); } if !super::ignore_sampler_owns_primary(ui, resp.id) && super::primary_click_count(ui, resp) == 3 && !f.modal - && let Some(p) = at + && let Some(p) = release_pos(ui, egui::PointerButton::Primary, true).or(at) { triple_click(app, ui, &f, p); } @@ -638,13 +638,14 @@ fn triple_click(app: &mut VectorcraftApp, ui: &Ui, f: &Pointing, p: Pos2) { dispatch(app, &ev, view); } -/// Where `button` went up in this frame, if it did. -fn release_pos(ui: &Ui, button: egui::PointerButton) -> Option { +/// Where `button` went up: the first release ends a drag, the last classifies this frame's click. +fn release_pos(ui: &Ui, button: egui::PointerButton, last: bool) -> Option { ui.input(|i| { - i.events.iter().find_map(|e| match e { + let mut releases = i.events.iter().filter_map(|e| match e { egui::Event::PointerButton { pos, button: b, pressed: false, .. } if *b == button => Some(*pos), _ => None, - }) + }); + if last { releases.next_back() } else { releases.next() } }) } diff --git a/crates/ui-egui/src/panels/image_trace.rs b/crates/ui-egui/src/panels/image_trace.rs index 0303467c3c..b669f972b3 100644 --- a/crates/ui-egui/src/panels/image_trace.rs +++ b/crates/ui-egui/src/panels/image_trace.rs @@ -171,28 +171,17 @@ thread_local! { static TARGET_LOOKUPS: std::cell::Cell = const { std::cell::Cell::new(0) }; } -/// The object Trace acts on: the first selected image or Image Trace object in paint order, as -/// `imageTrace.make` takes it, else the first selected object. Only the selected images and Image -/// Trace objects are put in paint order. +/// The image or Image Trace object `imageTrace.make` takes from the selected roots, else the +/// first selected non-traceable object's metadata. Release and Expand keep their own selection scope. fn find_target(app: &VectorcraftApp) -> Target { let Some(st) = app.session.active() else { return Target::default() }; #[cfg(test)] TARGET_LOOKUPS.with(|n| n.set(n.get() + 1)); - let mut any_trace = false; - let traceable: Vec = st - .selection - .objects - .iter() - .copied() - .filter(|id| { - st.doc.node(*id).is_some_and(|n| { - let trace = is_trace(n); - any_trace |= trace; - trace || matches!(n.kind, NodeKind::Image(_)) - }) - }) - .collect(); - let node = st.doc.paint_order(traceable).into_iter().find_map(|id| st.doc.node(id)).or_else(|| first_node(app)); + let any_trace = st.selection.objects.iter().any(|id| st.doc.node(*id).is_some_and(is_trace)); + let node = vectorcraft_engine::cmd::image_trace_target(&app.session, &Value::Null) + .ok() + .and_then(|id| st.doc.node(id)) + .or_else(|| first_node(app).filter(|n| !is_trace(n) && !matches!(n.kind, NodeKind::Image(_)))); let Some(n) = node else { return Target { any_trace, ..Target::default() } }; Target { object: Some((st.uid, n.id)), @@ -388,6 +377,15 @@ fn sampled_ignore_color(app: &VectorcraftApp, s: &crate::state::TraceIgnoreSampl return None; } let pixel = image.xf.inverse() * point; + if !pixel.x.is_finite() + || !pixel.y.is_finite() + || pixel.x < 0.0 + || pixel.y < 0.0 + || pixel.x >= f64::from(image.width.max(1)) + || pixel.y >= f64::from(image.height.max(1)) + { + return None; + } let [r, g, b, alpha] = doc.images.get(&image.key)?.sample_object(pixel.x, pixel.y, (image.width, image.height), 1)?; (alpha != 0).then(|| format!("#{r:02x}{g:02x}{b:02x}")) } @@ -431,9 +429,9 @@ pub(crate) fn apply_ignore_color_sample(app: &mut VectorcraftApp, p: &Value) { } set_pstate(&ctx, "image-trace", st); ctx.request_repaint(); - // The old deferred SwitchTool ran after the panel accepted the color. Keep that order and - // fresh tool choice; a miss above has no switch request and remains armed. - app.select_tool(&s.back); + // Complete the temporary tool without treating its return as a fresh explicit tool choice. + // A miss above has no switch request and remains armed. + app.return_to_tool(&s.back); } /// The selected Image Trace object's View row (Control bar, Properties). diff --git a/crates/ui-egui/tests/image_trace_ignore_sampler.rs b/crates/ui-egui/tests/image_trace_ignore_sampler.rs index af8e9d6757..4496089271 100644 --- a/crates/ui-egui/tests/image_trace_ignore_sampler.rs +++ b/crates/ui-egui/tests/image_trace_ignore_sampler.rs @@ -1061,3 +1061,260 @@ fn review_followup_release_position_survives_a_later_hover_move() { assert!(ctx.input(|i| i.pointer.button_triple_clicked(PointerButton::Primary))); assert_eq!(app.session.active().unwrap().isolation, Some(group), "the fresh pair uses release positions, not subsequent hover positions"); } + +fn review_596866_button(at: Pos2, pressed: bool) -> Event { + Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() } +} + +fn review_596866_owned_release_then_press(coalesced: bool) { + let (mut app, ctx, point, group) = review_gesture_group_fixture(); + click_control(&mut app, &ctx, SAMPLE_TIP); + app.run("select.none", json!({})).unwrap(); + let at = review_gesture_screen(&app, &ctx, point); + let (start, step) = review_gesture_times(&ctx); + review_gesture_press(&mut app, &ctx, at, start); + assert_eq!(app.session.tool_id(), "selection"); + assert!(app.ui.trace_ignore_sampler.is_none()); + assert!(ctx.input(|i| i.pointer.primary_down())); + let document = app.session.active().unwrap().doc.clone(); + let paint = app.session.paint.clone(); + let history = (app.session.active().unwrap().history.undo.len(), app.session.active().unwrap().history.redo.len()); + if coalesced { + frame_at(&mut app, &ctx, start + step, vec![review_596866_button(at, false), review_596866_button(at, true)]); + assert!(ctx.input(|i| i.pointer.primary_released() && i.pointer.primary_pressed() && i.pointer.primary_down())); + } else { + review_gesture_release(&mut app, &ctx, at, start + step); + assert_eq!(app.session.active().unwrap().selection.objects, Vec::::new(), "CONTROL: the owned Up remains consumed"); + review_gesture_press(&mut app, &ctx, at, start + 3.0 * step); + } + let before_release = review_gesture_observation(&app, &ctx); + review_gesture_release(&mut app, &ctx, at, start + 4.0 * step); + let after_release = review_gesture_observation(&app, &ctx); + assert!(after_release.0 && !after_release.1, "the owned prefix and one fresh click form egui's raw Double"); + assert!( + before_release.2 == vec![group] && before_release.3.is_none() && after_release.2 == vec![group] && after_release.3.is_none(), + "coalesced={coalesced}: the first fresh click must select without isolation: before={before_release:?}, after={after_release:?}" + ); + assert_eq!(app.session.active().unwrap().doc, document); + assert_eq!(app.session.paint, paint); + assert_eq!((app.session.active().unwrap().history.undo.len(), app.session.active().unwrap().history.redo.len()), history); + if !coalesced { + review_gesture_press(&mut app, &ctx, at, start + 6.0 * step); + review_gesture_release(&mut app, &ctx, at, start + 7.0 * step); + assert_eq!(app.session.active().unwrap().isolation, Some(group), "CONTROL: the second fresh click still isolates"); + } +} + +#[test] +fn review_596866_owned_up_then_new_down_in_one_frame_keeps_the_next_click_single() { + review_596866_owned_release_then_press(false); + review_596866_owned_release_then_press(true); +} + +#[test] +fn review_596866_second_corrected_release_uses_its_release_position() { + let (mut control, control_ctx, control_point, control_group) = review_gesture_group_fixture(); + let control_at = review_gesture_screen(&control, &control_ctx, control_point); + review_gesture_ordinary_pair(&mut control, &control_ctx, control_at, control_at, control_group); + + let (mut app, ctx, point, group) = review_gesture_group_fixture(); + click_control(&mut app, &ctx, SAMPLE_TIP); + app.run("select.none", json!({})).unwrap(); + let at = review_gesture_screen(&app, &ctx, point); + let hover = review_gesture_screen(&app, &ctx, Point::new(340.0, 250.0)); + assert!(at.distance(hover) > ctx.options(|o| o.input_options.max_click_dist)); + let expected = review_gesture_state(&app); + let (start, step) = review_gesture_times(&ctx); + review_gesture_press(&mut app, &ctx, at, start); + review_gesture_release(&mut app, &ctx, at, start + step); + assert_eq!(review_gesture_state(&app), expected, "the stale prefix is consumed"); + review_gesture_press(&mut app, &ctx, at, start + 3.0 * step); + review_gesture_release(&mut app, &ctx, at, start + 4.0 * step); + assert_eq!(app.session.active().unwrap().selection.objects, vec![group]); + assert_eq!(app.session.active().unwrap().isolation, None, "the first fresh click is single"); + review_gesture_press(&mut app, &ctx, at, start + 6.0 * step); + frame_at(&mut app, &ctx, start + 7.0 * step, vec![review_596866_button(at, false), Event::PointerMoved(hover)]); + assert!(ctx.input(|i| i.pointer.button_triple_clicked(PointerButton::Primary))); + assert_eq!(ctx.input(|i| i.pointer.interact_pos()), Some(hover)); + assert_eq!( + app.session.active().unwrap().isolation, + Some(group), + "the corrected Double belongs to its release on the group, not the later blank hover" + ); +} + +fn review_596866_bound_point(app: &VectorcraftApp, target: NodeId) -> Point { + let state = app.session.active().unwrap(); + let node = state.doc.node(target).unwrap(); + let original = node.children().and_then(|children| children.first()).map_or(node, |child| child.as_ref()); + let NodeKind::Image(image) = &original.kind else { panic!("the retained binding has a source image") }; + image.xf * Point::new(f64::from(image.width) * 0.25, f64::from(image.height) * 0.5) +} + +fn review_596866_source_image(app: &VectorcraftApp, target: NodeId) -> NodeId { + let state = app.session.active().unwrap(); + let node = state.doc.node(target).unwrap(); + let original = node.children().and_then(|children| children.first()).map_or(node, |child| child.as_ref()); + assert!(matches!(original.kind, NodeKind::Image(_)), "the retained binding has an original source image"); + original.id +} + +fn review_596866_pick_binding(app: &mut VectorcraftApp, ctx: &egui::Context) -> NodeId { + click_control(app, ctx, SAMPLE_TIP); + let target = app.ui.trace_ignore_sampler.as_ref().unwrap().target; + let source = review_596866_source_image(app, target); + let point = review_596866_bound_point(app, target); + let at = review_gesture_screen(app, ctx, point); + let (start, step) = review_gesture_times(ctx); + review_gesture_press(app, ctx, at, start); + review_gesture_release(app, ctx, at, start + step); + settle(app, ctx); + assert!(app.ui.trace_ignore_sampler.is_none(), "an opaque original pixel completes the pick"); + source +} + +fn review_596866_ignore_color(app: &VectorcraftApp, source: NodeId) -> Value { + let doc = &app.session.active().unwrap().doc; + assert!(matches!(doc.node(source).unwrap().kind, NodeKind::Image(_)), "retrace retains the original source image identity"); + let trace = doc.node(doc.parent_of(source).unwrap()).unwrap(); + assert_eq!(trace.children().unwrap().first().unwrap().id, source, "the source remains the trace's first child"); + trace.extras().trace.as_ref().expect("the source's current parent is an Image Trace")["params"]["ignoreColor"].clone() +} + +fn review_596866_nested_trace_selection() -> (VectorcraftApp, egui::Context, NodeId, NodeId) { + let (mut app, ctx) = fixture(true, [37, 83, 149], true); + let first = selected(&app).id; + let parent = review_gesture_enclose_source(&mut app, first); + let bytes = { + let state = app.session.active().unwrap(); + let original = state.doc.node(first).unwrap().children().unwrap()[0].as_ref(); + let NodeKind::Image(image) = &original.kind else { panic!("the first trace retains its input") }; + state.doc.images[&image.key].bytes.clone() + }; + app.run( + "file.place", + json!({"name": "second-sampler-source.png", "dataBase64": vectorcraft_format::base64_encode(&bytes), "link": false, "at": [280, 150]}), + ) + .unwrap(); + app.run("imageTrace.make", json!({"preset": "Default", "params": {"mode": "blackAndWhite", "threshold": 127, "noise": 1, "ignoreWhite": false}})) + .unwrap(); + let second = selected(&app).id; + assert_ne!(first, second); + app.run("select.set", json!({"ids": [parent.0, first.0, second.0]})).unwrap(); + settle(&mut app, &ctx); + let state = app.session.active().unwrap(); + assert_eq!(state.selection.objects, vec![parent, first, second], "CONTROL: the public selection keeps the ordinary ancestor and nested trace"); + assert!(state.doc.node(parent).unwrap().extras().trace.is_none(), "the selected ancestor is not itself traceable"); + assert_eq!(state.doc.paint_order([first, second]), vec![first, second], "the nested trace precedes the top-level trace"); + (app, ctx, first, second) +} + +#[test] +fn review_596866_preview_retraces_the_retained_sampler_binding() { + let (mut control, control_ctx) = fixture(true, [37, 83, 149], true); + let control_source = review_596866_pick_binding(&mut control, &control_ctx); + assert_eq!(review_596866_ignore_color(&control, control_source), "#255395", "CONTROL: a single trace receives its sampled color"); + + let (mut app, ctx, first, second) = review_596866_nested_trace_selection(); + click_control(&mut app, &ctx, SAMPLE_TIP); + let bound = app.ui.trace_ignore_sampler.as_ref().unwrap().target; + assert!(bound == first || bound == second); + let other = if bound == first { second } else { first }; + let other_before = app.session.active().unwrap().doc.node(other).unwrap().clone(); + let bound_source = review_596866_source_image(&app, bound); + assert_ne!(review_596866_ignore_color(&app, bound_source), "#255395", "CONTROL: the sample must change the bound trace's stored color"); + let point = review_596866_bound_point(&app, bound); + let at = review_gesture_screen(&app, &ctx, point); + let (start, step) = review_gesture_times(&ctx); + review_gesture_press(&mut app, &ctx, at, start); + review_gesture_release(&mut app, &ctx, at, start + step); + settle(&mut app, &ctx); + let bound_color = review_596866_ignore_color(&app, bound_source); + let other_after = app.session.active().unwrap().doc.node(other).cloned(); + assert!( + bound_color == "#255395" && other_after.as_ref() == Some(&other_before), + "Preview must update only retained sampler target {bound:?}: bound_color={bound_color}, other_changed_or_missing={}", + other_after.as_ref() != Some(&other_before) + ); +} + +fn review_596866_grid_visible(app: &VectorcraftApp) -> bool { + vectorcraft_tools::distort::perspective::PerspectiveGrid::current(&app.session.active().unwrap().doc).visible +} + +fn review_596866_hidden_grid_fixture() -> (VectorcraftApp, egui::Context) { + let (mut app, ctx) = fixture(true, [37, 83, 149], false); + app.select_tool("perspectiveGrid"); + assert!(review_596866_grid_visible(&app), "CONTROL: a deliberate fresh tool choice shows the grid"); + app.run("perspective.grid.show", json!({"visible": false})).unwrap(); + settle(&mut app, &ctx); + assert_eq!(app.session.tool_id(), "perspectiveGrid"); + assert!(!review_596866_grid_visible(&app)); + (app, ctx) +} + +#[test] +fn review_596866_successful_pick_preserves_a_hidden_perspective_grid() { + let (mut control, _) = review_596866_hidden_grid_fixture(); + let revision = control.session.active().unwrap().revision; + control.select_tool("perspectiveGrid"); + assert!(review_596866_grid_visible(&control), "CONTROL: explicitly choosing the tool again still shows the grid"); + assert!(control.session.active().unwrap().revision > revision); + + let (mut app, ctx) = review_596866_hidden_grid_fixture(); + let expected = review_gesture_state(&app); + let source = review_596866_pick_binding(&mut app, &ctx); + assert_eq!(app.session.tool_id(), "perspectiveGrid"); + let observed = review_gesture_state(&app); + let visible = review_596866_grid_visible(&app); + click_control(&mut app, &ctx, "Trace"); + assert_eq!(review_596866_ignore_color(&app, source), "#255395", "CONTROL: the valid Preview-off pick really changed the panel draft"); + assert!(!visible, "returning from the temporary sampler must not show the hidden grid"); + assert_eq!(observed, expected, "the Preview-off pick must not change document, selection, revision, history or paint"); +} + +fn review_596866_coalesced_fresh_suffix(dragged: bool) { + let (mut app, ctx, point, group) = review_gesture_group_fixture(); + click_control(&mut app, &ctx, SAMPLE_TIP); + app.run("select.none", json!({})).unwrap(); + let at = review_gesture_screen(&app, &ctx, point); + let distance = ctx.options(|o| o.input_options.max_click_dist); + let away = at + vec2(distance + 8.0, 0.0); + assert!(away.distance(at) > distance && app.canvas_rect.unwrap().contains(away)); + let (start, step) = review_gesture_times(&ctx); + review_gesture_press(&mut app, &ctx, at, start); + assert_eq!(app.session.tool_id(), "selection"); + assert!(app.ui.trace_ignore_sampler.is_none() && ctx.input(|i| i.pointer.primary_down())); + let mut events = vec![review_596866_button(at, false), review_596866_button(at, true)]; + if dragged { + events.extend([Event::PointerMoved(away), Event::PointerMoved(at)]); + } + events.push(review_596866_button(at, false)); + frame_at(&mut app, &ctx, start + step, events); + assert!(ctx.input(|i| i.pointer.primary_pressed() && i.pointer.primary_released() && !i.pointer.primary_down())); + assert!(ctx.input(|i| i.pointer.button_clicked(PointerButton::Primary)), "the old owned release really contributed a raw click"); + assert_eq!(ctx.input(|i| i.pointer.button_double_clicked(PointerButton::Primary)), !dragged, "only the valid fresh suffix is a second raw click"); + assert_eq!(app.session.active().unwrap().selection.objects, vec![group], "the fresh Down still selects the group"); + assert_eq!(app.session.active().unwrap().isolation, None, "neither the first fresh click nor an out-and-back drag may isolate"); + // The ordinary tool receives its Up in the next empty frame; no document/history oracle + // forbids legitimate drag completion work. + frame_at(&mut app, &ctx, start + 2.0 * step, vec![]); + assert_eq!(app.session.active().unwrap().isolation, None); + review_gesture_press(&mut app, &ctx, at, start + 3.0 * step); + review_gesture_release(&mut app, &ctx, at, start + 4.0 * step); + if dragged { + assert!(ctx.input(|i| i.pointer.button_double_clicked(PointerButton::Primary))); + assert_eq!(app.session.active().unwrap().selection.objects, vec![group]); + assert_eq!(app.session.active().unwrap().isolation, None, "the invalid suffix must not advance ordinary click history"); + review_gesture_press(&mut app, &ctx, at, start + 6.0 * step); + review_gesture_release(&mut app, &ctx, at, start + 7.0 * step); + } + assert!(ctx.input(|i| i.pointer.button_triple_clicked(PointerButton::Primary))); + assert_eq!(app.session.active().unwrap().isolation, Some(group), "the second qualifying ordinary click still isolates: dragged={dragged}"); +} + +#[test] +fn review_596866_coalesced_fresh_release_qualifies_its_own_click() { + review_596866_coalesced_fresh_suffix(false); + review_596866_coalesced_fresh_suffix(true); +}