mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-22 18:34:42 +01:00
Image Trace: preserve sampler gesture and target ownership
Keep consumed releases separate from fresh canvas presses, use click release positions, share the engine trace target selector, reject source misses before sampling, and return from the temporary tool without fresh activation.
This commit is contained in:
1 parent
f4f67ed66b
commit
2108617fa5
7 files changed
+435
-63
No files matched your search
@@ -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;
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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<NodeId> {
|
||||
target_image(s, "imageTrace.make", p).map(|(target, _)| target)
|
||||
}
|
||||
|
||||
fn target_image(s: &Session, c: &str, p: &Value) -> Result<(NodeId, Box<ImageObject>)> {
|
||||
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<Prepared> {
|
||||
let mut params = trace_params(s, c, p)?;
|
||||
@@ -619,25 +643,7 @@ fn prepare(s: &Session, c: &str, p: &Value) -> Result<Prepared> {
|
||||
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));
|
||||
}
|
||||
|
||||
+124
-14
@@ -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::<IgnoreSamplerClicks>(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<IgnoreSamplerRelease>,
|
||||
}
|
||||
|
||||
/// 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);
|
||||
|
||||
@@ -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<Pos2> {
|
||||
/// 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<Pos2> {
|
||||
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() }
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -171,28 +171,17 @@ thread_local! {
|
||||
static TARGET_LOOKUPS: std::cell::Cell<u32> = 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<NodeId> = 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).
|
||||
|
||||
@@ -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::<NodeId>::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);
|
||||
}
|
||||
Reference in new issue
Block a user