From 30dfa32cf5eb84d3119d3d753dcd05befd5ae073 Mon Sep 17 00:00:00 2001 From: aiongg Date: Mon, 26 Oct 2026 18:17:30 +0000 Subject: [PATCH] refactor(ui-egui): move paint_mouse.rs tests to paint_mouse/tests.rs --- crates/ui-egui/src/paint_mouse.rs | 484 +----------------------- crates/ui-egui/src/paint_mouse/tests.rs | 481 +++++++++++++++++++++++ 2 files changed, 482 insertions(+), 483 deletions(-) create mode 100644 crates/ui-egui/src/paint_mouse/tests.rs diff --git a/crates/ui-egui/src/paint_mouse.rs b/crates/ui-egui/src/paint_mouse.rs index 33ff242b57..dc64d34312 100644 --- a/crates/ui-egui/src/paint_mouse.rs +++ b/crates/ui-egui/src/paint_mouse.rs @@ -236,486 +236,4 @@ pub fn show_picker(app: &mut PhotocraftApp, ctx: &egui::Context) { } #[cfg(test)] -mod tests { - use egui::{Modifiers, PointerButton, Pos2, vec2}; - use egui_kittest::Harness; - use serde_json::json; - - use super::*; - use crate::canvas::{ToolEvent, tool_event}; - - fn harness(prefs: Option<&str>) -> Harness<'static, PhotocraftApp> { - let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); - app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); - app.run("layer.new.layer", json!({})).unwrap(); - app.run("tools.setColors", json!({"foreground": "#0000ff"})).unwrap(); - app.run("tools.setBrush", json!({"brush": {"size": 20, "hardness": 1.0}})).unwrap(); - if let Some(v) = prefs { - app.run("prefs.set", json!({"path": "tools.rightClickWithPaintingTools", "value": v})).unwrap(); - } - app.ui.tool = Tool::Brush; - app.sync_views(); - let mut h = Harness::builder().with_size(vec2(1200.0, 800.0)).with_step_dt(1.0 / 60.0).build_ui_state( - |ui, app: &mut PhotocraftApp| { - let ctx = ui.ctx().clone(); - if !ctx.fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) { - return; - } - egui::CentralPanel::default().show(ui, |ui| crate::canvas::document_area(app, ui)); - }, - app, - ); - PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]); - h.run_steps(4); - h - } - - fn press(h: &mut Harness<'static, PhotocraftApp>, pos: Pos2, button: PointerButton, pressed: bool) { - h.event(egui::Event::PointerButton { pos, button, pressed, modifiers: Modifiers::NONE }); - h.run_steps(2); - } - - /// Drag across the canvas centre with `button`; returns the document points it covered. - fn drag(h: &mut Harness<'static, PhotocraftApp>, button: PointerButton) -> (Pos2, Pos2) { - let c = h.state().last_canvas_rect.center(); - let (a, b) = (c - vec2(80.0, 0.0), c + vec2(80.0, 0.0)); - h.event(egui::Event::PointerMoved(a)); - h.run_steps(1); - press(h, a, button, true); - for i in 1..=8 { - h.event(egui::Event::PointerMoved(a + (b - a) * (i as f32 / 8.0))); - h.run_steps(1); - } - press(h, b, button, false); - (a, b) - } - - fn alpha_at(h: &Harness<'static, PhotocraftApp>, screen: Pos2) -> f32 { - let app = h.state(); - let v = app.ui.views[0].clone(); - let r = app.last_canvas_rect; - let d = (screen - r.center()) / v.zoom; - let (x, y) = ((d.x + v.center[0]) as i32, (d.y + v.center[1]) as i32); - let st = app.session.active().unwrap(); - st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().rgba(x, y)[3] - } - - fn strokes(h: &Harness<'static, PhotocraftApp>) -> Vec { - h.state().session.journal.iter().filter(|(id, _)| id == "paint.stroke").map(|(_, p)| p.clone()).collect() - } - - #[test] - fn left_drag_paints() { - let mut h = harness(None); - let (a, b) = drag(&mut h, PointerButton::Primary); - assert_eq!(strokes(&h).len(), 1); - assert!(alpha_at(&h, a + (b - a) * 0.5) > 0.9); - } - - #[test] - fn shift_click_connects_to_the_previous_brush_stroke() { - use egui::{Event, Modifiers}; - - let mut h = harness(None); - let (_, end) = drag(&mut h, PointerButton::Primary); - let previous = h - .state() - .session - .journal - .iter() - .rev() - .find(|(id, _)| id == "paint.stroke") - .map(|(_, p)| p["points"].as_array().unwrap().last().unwrap().clone()) - .unwrap(); - let target = end + vec2(120.0, 80.0); - h.event(Event::PointerMoved(target)); - h.run_steps(1); - for pressed in [true, false] { - h.event(Event::PointerButton { pos: target, button: PointerButton::Primary, pressed, modifiers: Modifiers::SHIFT }); - h.run_steps(2); - } - - let strokes = strokes(&h); - assert_eq!(strokes.len(), 2, "a Shift-click commits one connected stroke"); - let points = strokes[1]["points"].as_array().unwrap(); - // The previous endpoint, then the clicked one. While the button is held, smoothing that is - // still catching up repeats the clicked point with later times. - assert_eq!(points[0][0], previous[0]); - assert_eq!(points[0][1], previous[1]); - let clicked = &points[1]; - assert!(points[1..].iter().all(|p| p[0] == clicked[0] && p[1] == clicked[1]), "{points:?}"); - assert!(alpha_at(&h, end + vec2(60.0, 40.0)) > 0.9, "the segment between the strokes is painted"); - } - - #[test] - fn right_click_opens_the_brush_picker_and_never_paints() { - let mut h = harness(None); - let undo = h.state().session.active().unwrap().history.past_len(); - let c = h.state().last_canvas_rect.center(); - h.event(egui::Event::PointerMoved(c)); - h.run_steps(1); - press(&mut h, c, PointerButton::Secondary, true); - press(&mut h, c, PointerButton::Secondary, false); - assert_eq!(h.state().ui.brush_picker, Some([c.x, c.y]), "opened at the pointer"); - assert!(strokes(&h).is_empty()); - // The picker shows over the canvas at the pointer, moved up just enough to stay on screen. - h.run_steps(2); - let shown = h.ctx.memory(|m| m.area_rect(egui::Id::unique("canvas-brush-picker"))).expect("picker shown"); - let screen = h.ctx.content_rect(); - assert!((shown.min.x - c.x).abs() < 1.0 && shown.min.y <= c.y + 1.0, "{shown:?}"); - assert!(screen.contains_rect(shown.shrink(0.5)) && shown.width() > 250.0 && shown.height() > 150.0, "{shown:?}"); - // It is the real preset library, not a fixed set of round tips (#258). - let names: Vec = h.state().session.tools.presets.iter().take(3).map(|p| p.name.clone()).collect(); - { - use egui_kittest::kittest::Queryable; - for n in &names { - assert!(h.query_by_label(n).is_some(), "{n} listed"); - } - } - // A right drag doesn't paint either. - drag(&mut h, PointerButton::Secondary); - assert!(strokes(&h).is_empty(), "right-drag never paints with the brush picker preference"); - assert_eq!(h.state().session.active().unwrap().history.past_len(), undo, "no edit"); - // Escape closes it. - h.state_mut().ui.brush_picker = Some([c.x, c.y]); - h.run_steps(1); - h.key_press(egui::Key::Escape); - h.run_steps(2); - assert_eq!(h.state().ui.brush_picker, None); - } - - #[test] - fn click_outside_closes_the_picker() { - let mut h = harness(None); - let c = h.state().last_canvas_rect.center(); - h.state_mut().ui.brush_picker = Some([c.x, c.y]); - h.run_steps(2); - let far = c - vec2(300.0, 200.0); - h.event(egui::Event::PointerMoved(far)); - press(&mut h, far, PointerButton::Primary, true); - press(&mut h, far, PointerButton::Primary, false); - assert_eq!(h.state().ui.brush_picker, None); - } - - /// #1031: the right-click picker picks brushes, not just the size. A click picks a preset and - /// keeps the picker open, a double-click picks one and closes it, and Enter applies a typed - /// size before it closes the picker. - #[test] - fn picker_click_picks_a_preset_and_double_click_closes_it() { - use egui_kittest::kittest::Queryable; - let mut h = harness(None); - let c = h.state().last_canvas_rect.center(); - h.event(egui::Event::PointerMoved(c)); - h.run_steps(1); - press(&mut h, c, PointerButton::Secondary, true); - press(&mut h, c, PointerButton::Secondary, false); - h.run_steps(2); - let names: Vec = h.state().session.tools.presets.iter().skip(1).take(2).map(|p| p.name.clone()).collect(); - let picks = |h: &Harness<'static, PhotocraftApp>, name: &str| { - h.state().session.journal.iter().filter(|(id, p)| id == "tools.setBrush" && *p == json!({ "preset": name })).count() - }; - h.get_by_label(&names[0]).click(); - h.run_steps(3); - assert_eq!(picks(&h, &names[0]), 1); - assert!(h.state().ui.brush_picker.is_some(), "a click keeps the picker open"); - let at = h.get_by_label(&names[1]).rect().center(); - h.event(egui::Event::PointerMoved(at)); - h.run_steps(1); - // Two clicks 2 frames apart; well after the first click, so not a triple click. - h.run_steps(40); - for pressed in [true, false, true, false] { - h.event(egui::Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }); - h.step(); - } - h.run_steps(2); - assert_eq!(picks(&h, &names[1]), 1, "picked once: the second click only closes"); - assert_eq!(h.state().ui.brush_picker, None, "a double-click closes the picker"); - assert!(strokes(&h).is_empty(), "nothing painted under the picker"); - // Enter applies the typed size, then closes the picker. - h.state_mut().ui.brush_picker = Some([c.x, c.y]); - h.run_steps(2); - h.get_all_by_role(egui::accesskit::Role::SpinButton).next().expect("the Size field").click(); - h.run_steps(1); - h.event(egui::Event::Text("30*2".into())); - h.run_steps(1); - h.key_press(egui::Key::Enter); - h.run_steps(2); - assert_eq!((h.state().session.tools.brush.size, h.state().ui.brush_picker), (60.0, None)); - } - - /// A sampled tip has no hardness: the picker shows only its size (Photoshop). - #[test] - fn picker_shows_hardness_only_for_round_tips() { - use egui_kittest::kittest::Queryable; - let mut h = harness(None); - let c = h.state().last_canvas_rect.center(); - h.state_mut().ui.brush_picker = Some([c.x, c.y]); - h.run_steps(2); - assert!(h.query_all_by_label("Hardness").next().is_some()); - let sampled = h.state().session.tools.presets.iter().find(|p| p.brush.tip != photocraft_engine::paint::TipShape::Round).map(|p| p.name.clone()); - h.state_mut().run("tools.setBrush", json!({ "preset": sampled.expect("a sampled preset") })).unwrap(); - h.run_steps(2); - assert!(h.query_all_by_label("Hardness").next().is_none()); - assert!(h.state().ui.brush_picker.is_some()); - } - - /// The gear menu's New Brush Preset… opens the New Brush Preset dialog (#4490), which saves - /// the preset under the typed name on OK. - #[test] - fn picker_gear_menu_saves_and_names_a_new_preset() { - use egui_kittest::kittest::Queryable; - let mut h = harness(None); - let c = h.state().last_canvas_rect.center(); - h.state_mut().ui.brush_picker = Some([c.x, c.y]); - h.run_steps(2); - h.get_by_label("Brush Preset Options").click(); - h.run_steps(2); - let before = h.state().session.tools.presets.len(); - h.get_by_label("New Brush Preset…").click(); - h.run_steps(3); - let dialog = h.state().ui.dialogs.iter().find(|d| crate::brush_preset_dialog::owns(&d.fields)).map(|d| d.id).expect("the dialog asks for a name"); - assert_eq!(h.state().session.tools.presets.len(), before, "nothing is saved before OK"); - assert!(h.state().ui.brush_picker.is_none(), "the dialog takes the picker's place"); - // This harness draws the canvas only: OK as automation does (the dialog's own tests type). - h.state_mut().ui.dialog_mut(dialog).unwrap().fields.insert("name".into(), json!("Inky")); - crate::dialogs::confirm(h.state_mut(), dialog).unwrap(); - h.run_steps(2); - assert!(h.state().session.tools.presets.iter().any(|p| p.name == "Inky"), "saved under the typed name"); - assert_eq!(h.state().session.tools.current_preset.as_deref(), Some("Inky")); - h.state_mut().ui.brush_picker = Some([c.x, c.y]); - h.run_steps(2); - // The gear's boxes pick the card parts; the last one on can't be turned off. - h.get_by_label("Brush Preset Options").click(); - h.run_steps(2); - h.get_by_label("Brush Tip").click(); - h.run_steps(2); - assert!(!h.state().ui.brush_picker_list.show_tip); - h.get_by_label("Brush Stroke").click(); - h.run_steps(2); - h.get_by_label("Brush Name").click(); - h.run_steps(2); - assert!(h.state().ui.brush_picker_list.show_name, "the last part on stays on"); - assert!(!h.state().ui.brush_picker_list.show_stroke && !h.state().ui.brush_picker_list.show_tip); - assert!(h.state().ui.brush_picker.is_some()); - // A rename left open goes with the picker. - h.state_mut().ui.brush_picker_list.renaming = - Some(crate::brush_panel::Renaming { group: false, name: "Inky".into(), folder: Vec::new(), text: String::new() }); - h.run_steps(2); - let far = c - vec2(300.0, 200.0); - h.event(egui::Event::PointerMoved(far)); - press(&mut h, far, PointerButton::Primary, true); - press(&mut h, far, PointerButton::Primary, false); - assert!(h.state().ui.brush_picker.is_none() && h.state().ui.brush_picker_list.renaming.is_none()); - } - - #[test] - fn right_drag_erases_with_the_erase_preference() { - let mut h = harness(Some("erase")); - let (a, b) = drag(&mut h, PointerButton::Primary); - let mid = a + (b - a) * 0.5; - assert!(alpha_at(&h, mid) > 0.9); - let undo = h.state().session.active().unwrap().history.past_len(); - drag(&mut h, PointerButton::Secondary); - let s = strokes(&h); - assert_eq!(s.len(), 2); - assert_eq!(s[1]["erase"], json!(true), "the right stroke erases"); - assert_eq!(alpha_at(&h, mid), 0.0, "erased to transparency"); - assert_eq!(h.state().session.active().unwrap().history.past_len(), undo + 1, "one undo step"); - assert_eq!(h.state().ui.brush_picker, None, "no picker in erase mode"); - // The next left stroke paints again. - drag(&mut h, PointerButton::Primary); - assert_eq!(strokes(&h)[2]["erase"], json!(false)); - assert!(alpha_at(&h, mid) > 0.9); - } - - #[test] - fn right_stroke_erases_with_pen_pressure_through_the_control_channel_path() { - let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); - app.run("file.new", json!({"width": 120, "height": 80})).unwrap(); - app.run("prefs.set", json!({"path": "tools.rightClickWithPaintingTools", "value": "erase"})).unwrap(); - app.ui.tool = Tool::Brush; - let m = Modifiers::NONE; - assert!(pointer_secondary(&mut app, &egui::Context::default(), true, egui::Modifiers::NONE, [0.0, 0.0])); - tool_event(&mut app, ToolEvent::Down { x: 10.0, y: 40.0, pressure: 0.4 }, m); - assert!(!app.secondary_erase, "armed for one stroke only"); - tool_event(&mut app, ToolEvent::Move { x: 100.0, y: 40.0, pressure: 0.8 }, m); - tool_event(&mut app, ToolEvent::Up { x: 100.0, y: 40.0 }, m); - let p = app.session.journal.iter().rev().find(|(id, _)| id == "paint.stroke").map(|(_, p)| p.clone()).unwrap(); - assert_eq!(p["erase"], json!(true)); - assert_eq!(p["points"][0], json!([10.0, 40.0, 0.4f32 as f64]), "pressure reaches the erasing stroke"); - // On the Background the erasing stroke paints the background colour (#76). - let st = app.session.active().unwrap(); - assert_eq!(st.doc.layers[0].surface().unwrap().rgba(50, 40), [1.0, 1.0, 1.0, 1.0]); - // With the default preference the right button opens the picker and nothing paints. - app.run("prefs.set", json!({"path": "tools.rightClickWithPaintingTools", "value": "brushPicker"})).unwrap(); - assert!(!pointer_secondary(&mut app, &egui::Context::default(), true, egui::Modifiers::NONE, [0.0, 0.0])); - assert!(app.ui.brush_picker.is_some() && !app.secondary_erase); - } - - #[test] - fn the_brush_is_a_per_tool_option_that_presets_keep() { - let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); - app.run("file.new", json!({"width": 64, "height": 64})).unwrap(); - let amount = |app: &PhotocraftApp| app.session.tools.brush.smoothing.amount; - app.ui.tool = Tool::Brush; - sync_tool_brush(&mut app); - assert_eq!(amount(&app), 0.1, "Photoshop's default"); - // Picking a preset (whose own smoothing is 0) keeps the tool's smoothing. - let preset = app.session.tools.presets.iter().find(|p| p.brush.smoothing.amount == 0.0).map(|p| p.name.clone()).unwrap(); - app.run("tools.setBrush", json!({"preset": preset})).unwrap(); - assert_eq!(amount(&app), 0.1); - // A user value (the options-bar field) survives a preset too, mode included. - app.session.tools.brush.smoothing.amount = 0.42; - app.session.tools.brush.smoothing.pulled_string = true; - app.run("tools.setBrush", json!({"preset": preset})).unwrap(); - assert_eq!((amount(&app), app.session.tools.brush.smoothing.pulled_string), (0.42, true)); - // The Eraser has its own (10 % at first); switching back restores the Brush's. - app.ui.tool = Tool::Eraser; - sync_tool_brush(&mut app); - assert_eq!(amount(&app), 0.1); - app.session.tools.brush.smoothing.amount = 0.0; - app.ui.tool = Tool::Brush; - sync_tool_brush(&mut app); - assert_eq!((amount(&app), app.session.tools.brush.smoothing.pulled_string), (0.42, true)); - // Other tools leave it alone; the Eraser kept its 0 %. - app.ui.tool = Tool::Move; - sync_tool_brush(&mut app); - assert_eq!(amount(&app), 0.42); - app.ui.tool = Tool::Eraser; - // A stroke picks up the tool's brush even without a frame in between. - tool_event(&mut app, ToolEvent::Down { x: 5.0, y: 5.0, pressure: 1.0 }, Modifiers::NONE); - assert_eq!(amount(&app), 0.0); - tool_event(&mut app, ToolEvent::Up { x: 30.0, y: 5.0 }, Modifiers::NONE); - } - - /// #218: Photoshop keeps a brush per painting tool, so the size, hardness, mode, opacity and - /// dynamics of one tool never leak into another's, and each tool gets its own back. - #[test] - fn each_tool_keeps_its_own_brush() { - let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); - app.run("file.new", json!({"width": 64, "height": 64})).unwrap(); - let brush = |app: &PhotocraftApp| app.session.tools.brush.clone(); - let size = |b: &BrushSettings| b.size; - let hardness = |b: &BrushSettings| b.hardness; - let opacity = |b: &BrushSettings| b.opacity; - let mode = |b: &BrushSettings| b.mode; - - app.ui.tool = Tool::Brush; - sync_tool_brush(&mut app); - app.run("tools.setBrush", json!({"brush": {"size": 40, "hardness": 0.2, "opacity": 0.7, "mode": "Multiply"}})).unwrap(); - assert_eq!(size(&brush(&app)), 40.0); - - // A tool seen for the first time starts from the brush the old tool left (Photoshop's - // 10 % smoothing), so nothing is lost by switching. - app.ui.tool = Tool::Eraser; - sync_tool_brush(&mut app); - assert_eq!(size(&brush(&app)), 40.0, "a new tool inherits the current brush"); - - // The Eraser edits its own size; the Brush keeps 40 px. - app.run("tools.setBrush", json!({"brush": {"size": 8, "hardness": 1.0}})).unwrap(); - app.ui.tool = Tool::Brush; - sync_tool_brush(&mut app); - assert_eq!(size(&brush(&app)), 40.0, "the Brush keeps its own size"); - assert_eq!(hardness(&brush(&app)), 0.2, "and its hardness"); - app.ui.tool = Tool::Eraser; - sync_tool_brush(&mut app); - assert_eq!(size(&brush(&app)), 8.0, "the Eraser keeps its own size"); - assert_eq!(hardness(&brush(&app)), 1.0, "and its hardness"); - - // Mode, opacity, flow and the dynamics sections are per tool too. - app.ui.tool = Tool::CloneStamp; - sync_tool_brush(&mut app); - assert_eq!(mode(&brush(&app)), photocraft_color::BlendMode::Normal, "a new tool starts in Normal, not the Brush's Multiply"); - app.run("tools.setBrush", json!({"brush": {"mode": "Screen", "opacity": 0.3}})).unwrap(); - app.ui.tool = Tool::Brush; - sync_tool_brush(&mut app); - assert_eq!((mode(&brush(&app)), opacity(&brush(&app))), (photocraft_color::BlendMode::Multiply, 0.7), "the Brush's own mode and opacity"); - app.ui.tool = Tool::CloneStamp; - sync_tool_brush(&mut app); - assert_eq!((mode(&brush(&app)), opacity(&brush(&app))), (photocraft_color::BlendMode::Screen, 0.3), "the Clone Stamp keeps its own"); - - // The colours, the erase flag and the seed belong to the session, so a swap keeps what is - // live now instead of restoring another tool's copy (a picked colour reaches every tool). - app.run("tools.setBrush", json!({"brush": {"color": [0.0, 1.0, 0.0, 1.0], "background": [1.0, 0.0, 1.0, 1.0], "erase": true, "seed": 42}})).unwrap(); - app.ui.tool = Tool::Brush; - sync_tool_brush(&mut app); - let b = brush(&app); - assert_eq!( - (b.color, b.background, b.erase, b.seed), - ([0.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0], true, 42), - "the session's own brush fields survive the swap" - ); - - // Tools with no brush of their own (the Move) leave the brush alone. - let before = brush(&app); - app.ui.tool = Tool::Move; - sync_tool_brush(&mut app); - assert_eq!(brush(&app), before); - } - - #[test] - fn eraser_tool_on_the_background_paints_the_background_colour() { - // #76: the Eraser on the Background (locked transparency) paints the background colour. - let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); - app.run("file.new", json!({"width": 120, "height": 80})).unwrap(); - app.run("tools.setColors", json!({"background": "#ff0000"})).unwrap(); - app.run("tools.setBrush", json!({"brush": {"size": 12, "hardness": 1.0}})).unwrap(); - app.ui.tool = Tool::Eraser; - let m = Modifiers::NONE; - tool_event(&mut app, ToolEvent::Down { x: 10.0, y: 40.0, pressure: 1.0 }, m); - tool_event(&mut app, ToolEvent::Move { x: 100.0, y: 40.0, pressure: 1.0 }, m); - tool_event(&mut app, ToolEvent::Up { x: 100.0, y: 40.0 }, m); - let st = app.session.active().unwrap(); - assert_eq!(st.doc.layers[0].name, "Background"); - assert_eq!(st.doc.layers[0].surface().unwrap().rgba(50, 40), [1.0, 0.0, 0.0, 1.0]); - assert_eq!(st.history.undo_label(), Some("Eraser")); - assert!(!app.ui.status_error, "{}", app.ui.status); - } - - /// Assert the one committed stroke contains a point at each queued screen position. - fn assert_committed_points(h: &Harness<'static, PhotocraftApp>, queued: &[Pos2]) { - let s = strokes(h); - assert_eq!(s.len(), 1); - let points = s[0]["points"].as_array().unwrap(); - let app = h.state(); - let v = app.ui.views[0].clone(); - let r = app.last_canvas_rect; - for p in queued { - let d = (*p - r.center()) / v.zoom; - let want = [d.x as f64 + v.center[0] as f64, d.y as f64 + v.center[1] as f64]; - assert!( - points.iter().any(|q| { - let q = q.as_array().unwrap(); - (q[0].as_f64().unwrap() - want[0]).abs() < 1.0 && (q[1].as_f64().unwrap() - want[1]).abs() < 1.0 - }), - "queued move {want:?} missing from {points:?}" - ); - } - } - - #[test] - fn one_frame_feeds_every_pointer_move_not_just_the_latest() { - // Fast strokes used to lose the moves between two frames: the canvas read only - // `interact_pointer_pos()` once per frame, so the stroke was a coarse polyline. Every - // `PointerMoved` egui-winit delivered in one frame must now reach the stroke. - let mut h = harness(None); - let c = h.state().last_canvas_rect.center(); - let a = c - vec2(90.0, 0.0); - h.event(egui::Event::PointerMoved(a)); - h.run_steps(1); - press(&mut h, a, PointerButton::Primary, true); - // Cross egui's drag threshold on its own frame. - h.event(egui::Event::PointerMoved(a + vec2(20.0, 0.0))); - h.run_steps(1); - // Several moves in ONE frame: `Harness::event` would make one frame per event, so push - // them straight into the next frame's input. All of them must reach the committed stroke. - let queued: Vec = (1..=6).map(|i| a + vec2(20.0 + i as f32 * 8.0, 0.0)).collect(); - for p in &queued { - h.input_mut().events.push(egui::Event::PointerMoved(*p)); - } - h.run_steps(1); - let end = *queued.last().unwrap(); - press(&mut h, end, PointerButton::Primary, false); - assert_committed_points(&h, &queued); - } -} +mod tests; diff --git a/crates/ui-egui/src/paint_mouse/tests.rs b/crates/ui-egui/src/paint_mouse/tests.rs new file mode 100644 index 0000000000..4b54a1ce98 --- /dev/null +++ b/crates/ui-egui/src/paint_mouse/tests.rs @@ -0,0 +1,481 @@ +use egui::{Modifiers, PointerButton, Pos2, vec2}; +use egui_kittest::Harness; +use serde_json::json; + +use super::*; +use crate::canvas::{ToolEvent, tool_event}; + +fn harness(prefs: Option<&str>) -> Harness<'static, PhotocraftApp> { + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + app.run("file.new", json!({"width": 400, "height": 300})).unwrap(); + app.run("layer.new.layer", json!({})).unwrap(); + app.run("tools.setColors", json!({"foreground": "#0000ff"})).unwrap(); + app.run("tools.setBrush", json!({"brush": {"size": 20, "hardness": 1.0}})).unwrap(); + if let Some(v) = prefs { + app.run("prefs.set", json!({"path": "tools.rightClickWithPaintingTools", "value": v})).unwrap(); + } + app.ui.tool = Tool::Brush; + app.sync_views(); + let mut h = Harness::builder().with_size(vec2(1200.0, 800.0)).with_step_dt(1.0 / 60.0).build_ui_state( + |ui, app: &mut PhotocraftApp| { + let ctx = ui.ctx().clone(); + if !ctx.fonts(|f| f.families().contains(&egui::FontFamily::Name("medium".into()))) { + return; + } + egui::CentralPanel::default().show(ui, |ui| crate::canvas::document_area(app, ui)); + }, + app, + ); + PhotocraftApp::setup_context(&h.ctx, crate::theme::ThemeKind::ALL[0]); + h.run_steps(4); + h +} + +fn press(h: &mut Harness<'static, PhotocraftApp>, pos: Pos2, button: PointerButton, pressed: bool) { + h.event(egui::Event::PointerButton { pos, button, pressed, modifiers: Modifiers::NONE }); + h.run_steps(2); +} + +/// Drag across the canvas centre with `button`; returns the document points it covered. +fn drag(h: &mut Harness<'static, PhotocraftApp>, button: PointerButton) -> (Pos2, Pos2) { + let c = h.state().last_canvas_rect.center(); + let (a, b) = (c - vec2(80.0, 0.0), c + vec2(80.0, 0.0)); + h.event(egui::Event::PointerMoved(a)); + h.run_steps(1); + press(h, a, button, true); + for i in 1..=8 { + h.event(egui::Event::PointerMoved(a + (b - a) * (i as f32 / 8.0))); + h.run_steps(1); + } + press(h, b, button, false); + (a, b) +} + +fn alpha_at(h: &Harness<'static, PhotocraftApp>, screen: Pos2) -> f32 { + let app = h.state(); + let v = app.ui.views[0].clone(); + let r = app.last_canvas_rect; + let d = (screen - r.center()) / v.zoom; + let (x, y) = ((d.x + v.center[0]) as i32, (d.y + v.center[1]) as i32); + let st = app.session.active().unwrap(); + st.doc.layer(st.active_layer.unwrap()).unwrap().surface().unwrap().rgba(x, y)[3] +} + +fn strokes(h: &Harness<'static, PhotocraftApp>) -> Vec { + h.state().session.journal.iter().filter(|(id, _)| id == "paint.stroke").map(|(_, p)| p.clone()).collect() +} + +#[test] +fn left_drag_paints() { + let mut h = harness(None); + let (a, b) = drag(&mut h, PointerButton::Primary); + assert_eq!(strokes(&h).len(), 1); + assert!(alpha_at(&h, a + (b - a) * 0.5) > 0.9); +} + +#[test] +fn shift_click_connects_to_the_previous_brush_stroke() { + use egui::{Event, Modifiers}; + + let mut h = harness(None); + let (_, end) = drag(&mut h, PointerButton::Primary); + let previous = h + .state() + .session + .journal + .iter() + .rev() + .find(|(id, _)| id == "paint.stroke") + .map(|(_, p)| p["points"].as_array().unwrap().last().unwrap().clone()) + .unwrap(); + let target = end + vec2(120.0, 80.0); + h.event(Event::PointerMoved(target)); + h.run_steps(1); + for pressed in [true, false] { + h.event(Event::PointerButton { pos: target, button: PointerButton::Primary, pressed, modifiers: Modifiers::SHIFT }); + h.run_steps(2); + } + + let strokes = strokes(&h); + assert_eq!(strokes.len(), 2, "a Shift-click commits one connected stroke"); + let points = strokes[1]["points"].as_array().unwrap(); + // The previous endpoint, then the clicked one. While the button is held, smoothing that is + // still catching up repeats the clicked point with later times. + assert_eq!(points[0][0], previous[0]); + assert_eq!(points[0][1], previous[1]); + let clicked = &points[1]; + assert!(points[1..].iter().all(|p| p[0] == clicked[0] && p[1] == clicked[1]), "{points:?}"); + assert!(alpha_at(&h, end + vec2(60.0, 40.0)) > 0.9, "the segment between the strokes is painted"); +} + +#[test] +fn right_click_opens_the_brush_picker_and_never_paints() { + let mut h = harness(None); + let undo = h.state().session.active().unwrap().history.past_len(); + let c = h.state().last_canvas_rect.center(); + h.event(egui::Event::PointerMoved(c)); + h.run_steps(1); + press(&mut h, c, PointerButton::Secondary, true); + press(&mut h, c, PointerButton::Secondary, false); + assert_eq!(h.state().ui.brush_picker, Some([c.x, c.y]), "opened at the pointer"); + assert!(strokes(&h).is_empty()); + // The picker shows over the canvas at the pointer, moved up just enough to stay on screen. + h.run_steps(2); + let shown = h.ctx.memory(|m| m.area_rect(egui::Id::unique("canvas-brush-picker"))).expect("picker shown"); + let screen = h.ctx.content_rect(); + assert!((shown.min.x - c.x).abs() < 1.0 && shown.min.y <= c.y + 1.0, "{shown:?}"); + assert!(screen.contains_rect(shown.shrink(0.5)) && shown.width() > 250.0 && shown.height() > 150.0, "{shown:?}"); + // It is the real preset library, not a fixed set of round tips (#258). + let names: Vec = h.state().session.tools.presets.iter().take(3).map(|p| p.name.clone()).collect(); + { + use egui_kittest::kittest::Queryable; + for n in &names { + assert!(h.query_by_label(n).is_some(), "{n} listed"); + } + } + // A right drag doesn't paint either. + drag(&mut h, PointerButton::Secondary); + assert!(strokes(&h).is_empty(), "right-drag never paints with the brush picker preference"); + assert_eq!(h.state().session.active().unwrap().history.past_len(), undo, "no edit"); + // Escape closes it. + h.state_mut().ui.brush_picker = Some([c.x, c.y]); + h.run_steps(1); + h.key_press(egui::Key::Escape); + h.run_steps(2); + assert_eq!(h.state().ui.brush_picker, None); +} + +#[test] +fn click_outside_closes_the_picker() { + let mut h = harness(None); + let c = h.state().last_canvas_rect.center(); + h.state_mut().ui.brush_picker = Some([c.x, c.y]); + h.run_steps(2); + let far = c - vec2(300.0, 200.0); + h.event(egui::Event::PointerMoved(far)); + press(&mut h, far, PointerButton::Primary, true); + press(&mut h, far, PointerButton::Primary, false); + assert_eq!(h.state().ui.brush_picker, None); +} + +/// #1031: the right-click picker picks brushes, not just the size. A click picks a preset and +/// keeps the picker open, a double-click picks one and closes it, and Enter applies a typed +/// size before it closes the picker. +#[test] +fn picker_click_picks_a_preset_and_double_click_closes_it() { + use egui_kittest::kittest::Queryable; + let mut h = harness(None); + let c = h.state().last_canvas_rect.center(); + h.event(egui::Event::PointerMoved(c)); + h.run_steps(1); + press(&mut h, c, PointerButton::Secondary, true); + press(&mut h, c, PointerButton::Secondary, false); + h.run_steps(2); + let names: Vec = h.state().session.tools.presets.iter().skip(1).take(2).map(|p| p.name.clone()).collect(); + let picks = |h: &Harness<'static, PhotocraftApp>, name: &str| { + h.state().session.journal.iter().filter(|(id, p)| id == "tools.setBrush" && *p == json!({ "preset": name })).count() + }; + h.get_by_label(&names[0]).click(); + h.run_steps(3); + assert_eq!(picks(&h, &names[0]), 1); + assert!(h.state().ui.brush_picker.is_some(), "a click keeps the picker open"); + let at = h.get_by_label(&names[1]).rect().center(); + h.event(egui::Event::PointerMoved(at)); + h.run_steps(1); + // Two clicks 2 frames apart; well after the first click, so not a triple click. + h.run_steps(40); + for pressed in [true, false, true, false] { + h.event(egui::Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }); + h.step(); + } + h.run_steps(2); + assert_eq!(picks(&h, &names[1]), 1, "picked once: the second click only closes"); + assert_eq!(h.state().ui.brush_picker, None, "a double-click closes the picker"); + assert!(strokes(&h).is_empty(), "nothing painted under the picker"); + // Enter applies the typed size, then closes the picker. + h.state_mut().ui.brush_picker = Some([c.x, c.y]); + h.run_steps(2); + h.get_all_by_role(egui::accesskit::Role::SpinButton).next().expect("the Size field").click(); + h.run_steps(1); + h.event(egui::Event::Text("30*2".into())); + h.run_steps(1); + h.key_press(egui::Key::Enter); + h.run_steps(2); + assert_eq!((h.state().session.tools.brush.size, h.state().ui.brush_picker), (60.0, None)); +} + +/// A sampled tip has no hardness: the picker shows only its size (Photoshop). +#[test] +fn picker_shows_hardness_only_for_round_tips() { + use egui_kittest::kittest::Queryable; + let mut h = harness(None); + let c = h.state().last_canvas_rect.center(); + h.state_mut().ui.brush_picker = Some([c.x, c.y]); + h.run_steps(2); + assert!(h.query_all_by_label("Hardness").next().is_some()); + let sampled = h.state().session.tools.presets.iter().find(|p| p.brush.tip != photocraft_engine::paint::TipShape::Round).map(|p| p.name.clone()); + h.state_mut().run("tools.setBrush", json!({ "preset": sampled.expect("a sampled preset") })).unwrap(); + h.run_steps(2); + assert!(h.query_all_by_label("Hardness").next().is_none()); + assert!(h.state().ui.brush_picker.is_some()); +} + +/// The gear menu's New Brush Preset… opens the New Brush Preset dialog (#4490), which saves +/// the preset under the typed name on OK. +#[test] +fn picker_gear_menu_saves_and_names_a_new_preset() { + use egui_kittest::kittest::Queryable; + let mut h = harness(None); + let c = h.state().last_canvas_rect.center(); + h.state_mut().ui.brush_picker = Some([c.x, c.y]); + h.run_steps(2); + h.get_by_label("Brush Preset Options").click(); + h.run_steps(2); + let before = h.state().session.tools.presets.len(); + h.get_by_label("New Brush Preset…").click(); + h.run_steps(3); + let dialog = h.state().ui.dialogs.iter().find(|d| crate::brush_preset_dialog::owns(&d.fields)).map(|d| d.id).expect("the dialog asks for a name"); + assert_eq!(h.state().session.tools.presets.len(), before, "nothing is saved before OK"); + assert!(h.state().ui.brush_picker.is_none(), "the dialog takes the picker's place"); + // This harness draws the canvas only: OK as automation does (the dialog's own tests type). + h.state_mut().ui.dialog_mut(dialog).unwrap().fields.insert("name".into(), json!("Inky")); + crate::dialogs::confirm(h.state_mut(), dialog).unwrap(); + h.run_steps(2); + assert!(h.state().session.tools.presets.iter().any(|p| p.name == "Inky"), "saved under the typed name"); + assert_eq!(h.state().session.tools.current_preset.as_deref(), Some("Inky")); + h.state_mut().ui.brush_picker = Some([c.x, c.y]); + h.run_steps(2); + // The gear's boxes pick the card parts; the last one on can't be turned off. + h.get_by_label("Brush Preset Options").click(); + h.run_steps(2); + h.get_by_label("Brush Tip").click(); + h.run_steps(2); + assert!(!h.state().ui.brush_picker_list.show_tip); + h.get_by_label("Brush Stroke").click(); + h.run_steps(2); + h.get_by_label("Brush Name").click(); + h.run_steps(2); + assert!(h.state().ui.brush_picker_list.show_name, "the last part on stays on"); + assert!(!h.state().ui.brush_picker_list.show_stroke && !h.state().ui.brush_picker_list.show_tip); + assert!(h.state().ui.brush_picker.is_some()); + // A rename left open goes with the picker. + h.state_mut().ui.brush_picker_list.renaming = + Some(crate::brush_panel::Renaming { group: false, name: "Inky".into(), folder: Vec::new(), text: String::new() }); + h.run_steps(2); + let far = c - vec2(300.0, 200.0); + h.event(egui::Event::PointerMoved(far)); + press(&mut h, far, PointerButton::Primary, true); + press(&mut h, far, PointerButton::Primary, false); + assert!(h.state().ui.brush_picker.is_none() && h.state().ui.brush_picker_list.renaming.is_none()); +} + +#[test] +fn right_drag_erases_with_the_erase_preference() { + let mut h = harness(Some("erase")); + let (a, b) = drag(&mut h, PointerButton::Primary); + let mid = a + (b - a) * 0.5; + assert!(alpha_at(&h, mid) > 0.9); + let undo = h.state().session.active().unwrap().history.past_len(); + drag(&mut h, PointerButton::Secondary); + let s = strokes(&h); + assert_eq!(s.len(), 2); + assert_eq!(s[1]["erase"], json!(true), "the right stroke erases"); + assert_eq!(alpha_at(&h, mid), 0.0, "erased to transparency"); + assert_eq!(h.state().session.active().unwrap().history.past_len(), undo + 1, "one undo step"); + assert_eq!(h.state().ui.brush_picker, None, "no picker in erase mode"); + // The next left stroke paints again. + drag(&mut h, PointerButton::Primary); + assert_eq!(strokes(&h)[2]["erase"], json!(false)); + assert!(alpha_at(&h, mid) > 0.9); +} + +#[test] +fn right_stroke_erases_with_pen_pressure_through_the_control_channel_path() { + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + app.run("file.new", json!({"width": 120, "height": 80})).unwrap(); + app.run("prefs.set", json!({"path": "tools.rightClickWithPaintingTools", "value": "erase"})).unwrap(); + app.ui.tool = Tool::Brush; + let m = Modifiers::NONE; + assert!(pointer_secondary(&mut app, &egui::Context::default(), true, egui::Modifiers::NONE, [0.0, 0.0])); + tool_event(&mut app, ToolEvent::Down { x: 10.0, y: 40.0, pressure: 0.4 }, m); + assert!(!app.secondary_erase, "armed for one stroke only"); + tool_event(&mut app, ToolEvent::Move { x: 100.0, y: 40.0, pressure: 0.8 }, m); + tool_event(&mut app, ToolEvent::Up { x: 100.0, y: 40.0 }, m); + let p = app.session.journal.iter().rev().find(|(id, _)| id == "paint.stroke").map(|(_, p)| p.clone()).unwrap(); + assert_eq!(p["erase"], json!(true)); + assert_eq!(p["points"][0], json!([10.0, 40.0, 0.4f32 as f64]), "pressure reaches the erasing stroke"); + // On the Background the erasing stroke paints the background colour (#76). + let st = app.session.active().unwrap(); + assert_eq!(st.doc.layers[0].surface().unwrap().rgba(50, 40), [1.0, 1.0, 1.0, 1.0]); + // With the default preference the right button opens the picker and nothing paints. + app.run("prefs.set", json!({"path": "tools.rightClickWithPaintingTools", "value": "brushPicker"})).unwrap(); + assert!(!pointer_secondary(&mut app, &egui::Context::default(), true, egui::Modifiers::NONE, [0.0, 0.0])); + assert!(app.ui.brush_picker.is_some() && !app.secondary_erase); +} + +#[test] +fn the_brush_is_a_per_tool_option_that_presets_keep() { + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + app.run("file.new", json!({"width": 64, "height": 64})).unwrap(); + let amount = |app: &PhotocraftApp| app.session.tools.brush.smoothing.amount; + app.ui.tool = Tool::Brush; + sync_tool_brush(&mut app); + assert_eq!(amount(&app), 0.1, "Photoshop's default"); + // Picking a preset (whose own smoothing is 0) keeps the tool's smoothing. + let preset = app.session.tools.presets.iter().find(|p| p.brush.smoothing.amount == 0.0).map(|p| p.name.clone()).unwrap(); + app.run("tools.setBrush", json!({"preset": preset})).unwrap(); + assert_eq!(amount(&app), 0.1); + // A user value (the options-bar field) survives a preset too, mode included. + app.session.tools.brush.smoothing.amount = 0.42; + app.session.tools.brush.smoothing.pulled_string = true; + app.run("tools.setBrush", json!({"preset": preset})).unwrap(); + assert_eq!((amount(&app), app.session.tools.brush.smoothing.pulled_string), (0.42, true)); + // The Eraser has its own (10 % at first); switching back restores the Brush's. + app.ui.tool = Tool::Eraser; + sync_tool_brush(&mut app); + assert_eq!(amount(&app), 0.1); + app.session.tools.brush.smoothing.amount = 0.0; + app.ui.tool = Tool::Brush; + sync_tool_brush(&mut app); + assert_eq!((amount(&app), app.session.tools.brush.smoothing.pulled_string), (0.42, true)); + // Other tools leave it alone; the Eraser kept its 0 %. + app.ui.tool = Tool::Move; + sync_tool_brush(&mut app); + assert_eq!(amount(&app), 0.42); + app.ui.tool = Tool::Eraser; + // A stroke picks up the tool's brush even without a frame in between. + tool_event(&mut app, ToolEvent::Down { x: 5.0, y: 5.0, pressure: 1.0 }, Modifiers::NONE); + assert_eq!(amount(&app), 0.0); + tool_event(&mut app, ToolEvent::Up { x: 30.0, y: 5.0 }, Modifiers::NONE); +} + +/// #218: Photoshop keeps a brush per painting tool, so the size, hardness, mode, opacity and +/// dynamics of one tool never leak into another's, and each tool gets its own back. +#[test] +fn each_tool_keeps_its_own_brush() { + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + app.run("file.new", json!({"width": 64, "height": 64})).unwrap(); + let brush = |app: &PhotocraftApp| app.session.tools.brush.clone(); + let size = |b: &BrushSettings| b.size; + let hardness = |b: &BrushSettings| b.hardness; + let opacity = |b: &BrushSettings| b.opacity; + let mode = |b: &BrushSettings| b.mode; + + app.ui.tool = Tool::Brush; + sync_tool_brush(&mut app); + app.run("tools.setBrush", json!({"brush": {"size": 40, "hardness": 0.2, "opacity": 0.7, "mode": "Multiply"}})).unwrap(); + assert_eq!(size(&brush(&app)), 40.0); + + // A tool seen for the first time starts from the brush the old tool left (Photoshop's + // 10 % smoothing), so nothing is lost by switching. + app.ui.tool = Tool::Eraser; + sync_tool_brush(&mut app); + assert_eq!(size(&brush(&app)), 40.0, "a new tool inherits the current brush"); + + // The Eraser edits its own size; the Brush keeps 40 px. + app.run("tools.setBrush", json!({"brush": {"size": 8, "hardness": 1.0}})).unwrap(); + app.ui.tool = Tool::Brush; + sync_tool_brush(&mut app); + assert_eq!(size(&brush(&app)), 40.0, "the Brush keeps its own size"); + assert_eq!(hardness(&brush(&app)), 0.2, "and its hardness"); + app.ui.tool = Tool::Eraser; + sync_tool_brush(&mut app); + assert_eq!(size(&brush(&app)), 8.0, "the Eraser keeps its own size"); + assert_eq!(hardness(&brush(&app)), 1.0, "and its hardness"); + + // Mode, opacity, flow and the dynamics sections are per tool too. + app.ui.tool = Tool::CloneStamp; + sync_tool_brush(&mut app); + assert_eq!(mode(&brush(&app)), photocraft_color::BlendMode::Normal, "a new tool starts in Normal, not the Brush's Multiply"); + app.run("tools.setBrush", json!({"brush": {"mode": "Screen", "opacity": 0.3}})).unwrap(); + app.ui.tool = Tool::Brush; + sync_tool_brush(&mut app); + assert_eq!((mode(&brush(&app)), opacity(&brush(&app))), (photocraft_color::BlendMode::Multiply, 0.7), "the Brush's own mode and opacity"); + app.ui.tool = Tool::CloneStamp; + sync_tool_brush(&mut app); + assert_eq!((mode(&brush(&app)), opacity(&brush(&app))), (photocraft_color::BlendMode::Screen, 0.3), "the Clone Stamp keeps its own"); + + // The colours, the erase flag and the seed belong to the session, so a swap keeps what is + // live now instead of restoring another tool's copy (a picked colour reaches every tool). + app.run("tools.setBrush", json!({"brush": {"color": [0.0, 1.0, 0.0, 1.0], "background": [1.0, 0.0, 1.0, 1.0], "erase": true, "seed": 42}})).unwrap(); + app.ui.tool = Tool::Brush; + sync_tool_brush(&mut app); + let b = brush(&app); + assert_eq!( + (b.color, b.background, b.erase, b.seed), + ([0.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0], true, 42), + "the session's own brush fields survive the swap" + ); + + // Tools with no brush of their own (the Move) leave the brush alone. + let before = brush(&app); + app.ui.tool = Tool::Move; + sync_tool_brush(&mut app); + assert_eq!(brush(&app), before); +} + +#[test] +fn eraser_tool_on_the_background_paints_the_background_colour() { + // #76: the Eraser on the Background (locked transparency) paints the background colour. + let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + app.run("file.new", json!({"width": 120, "height": 80})).unwrap(); + app.run("tools.setColors", json!({"background": "#ff0000"})).unwrap(); + app.run("tools.setBrush", json!({"brush": {"size": 12, "hardness": 1.0}})).unwrap(); + app.ui.tool = Tool::Eraser; + let m = Modifiers::NONE; + tool_event(&mut app, ToolEvent::Down { x: 10.0, y: 40.0, pressure: 1.0 }, m); + tool_event(&mut app, ToolEvent::Move { x: 100.0, y: 40.0, pressure: 1.0 }, m); + tool_event(&mut app, ToolEvent::Up { x: 100.0, y: 40.0 }, m); + let st = app.session.active().unwrap(); + assert_eq!(st.doc.layers[0].name, "Background"); + assert_eq!(st.doc.layers[0].surface().unwrap().rgba(50, 40), [1.0, 0.0, 0.0, 1.0]); + assert_eq!(st.history.undo_label(), Some("Eraser")); + assert!(!app.ui.status_error, "{}", app.ui.status); +} + +/// Assert the one committed stroke contains a point at each queued screen position. +fn assert_committed_points(h: &Harness<'static, PhotocraftApp>, queued: &[Pos2]) { + let s = strokes(h); + assert_eq!(s.len(), 1); + let points = s[0]["points"].as_array().unwrap(); + let app = h.state(); + let v = app.ui.views[0].clone(); + let r = app.last_canvas_rect; + for p in queued { + let d = (*p - r.center()) / v.zoom; + let want = [d.x as f64 + v.center[0] as f64, d.y as f64 + v.center[1] as f64]; + assert!( + points.iter().any(|q| { + let q = q.as_array().unwrap(); + (q[0].as_f64().unwrap() - want[0]).abs() < 1.0 && (q[1].as_f64().unwrap() - want[1]).abs() < 1.0 + }), + "queued move {want:?} missing from {points:?}" + ); + } +} + +#[test] +fn one_frame_feeds_every_pointer_move_not_just_the_latest() { + // Fast strokes used to lose the moves between two frames: the canvas read only + // `interact_pointer_pos()` once per frame, so the stroke was a coarse polyline. Every + // `PointerMoved` egui-winit delivered in one frame must now reach the stroke. + let mut h = harness(None); + let c = h.state().last_canvas_rect.center(); + let a = c - vec2(90.0, 0.0); + h.event(egui::Event::PointerMoved(a)); + h.run_steps(1); + press(&mut h, a, PointerButton::Primary, true); + // Cross egui's drag threshold on its own frame. + h.event(egui::Event::PointerMoved(a + vec2(20.0, 0.0))); + h.run_steps(1); + // Several moves in ONE frame: `Harness::event` would make one frame per event, so push + // them straight into the next frame's input. All of them must reach the committed stroke. + let queued: Vec = (1..=6).map(|i| a + vec2(20.0 + i as f32 * 8.0, 0.0)).collect(); + for p in &queued { + h.input_mut().events.push(egui::Event::PointerMoved(*p)); + } + h.run_steps(1); + let end = *queued.last().unwrap(); + press(&mut h, end, PointerButton::Primary, false); + assert_committed_points(&h, &queued); +}