diff --git a/crates/ui-egui/src/dim_view.rs b/crates/ui-egui/src/dim_view.rs index b55dd8c6a..812550993 100644 --- a/crates/ui-egui/src/dim_view.rs +++ b/crates/ui-egui/src/dim_view.rs @@ -58,6 +58,13 @@ struct Edit { /// dimension, and its text follows the pointer until a click pins it or Enter places it. live: Option, selection: Option, + /// The person took the value over: typed into it, pressed a key in it, inserted a completion + /// or a reference, or pressed into the field. Until then every frame starts with the whole + /// value selected, so the first key replaces it whatever else moved the caret (#11204). + owned: bool, + /// Where the box sat last frame: a press only takes the value over once the box stayed put + /// under it, so the click that placed or pinned the value does not. + shown: Option, /// The last dimension a click referenced, and when: the second click of a double-click on /// it must not insert its name again. picked: Option<(String, f64)>, @@ -168,6 +175,8 @@ pub fn begin_dimension(app: &mut SolveApp, entities: Vec, at: Vec2) -> R draft: Some(draft), live: None, selection: None, + owned: false, + shown: None, picked: None, sketch: None, driven: None, @@ -200,6 +209,8 @@ pub fn begin_live(app: &mut SolveApp, entities: Vec, pointer: Option bool { draft: None, live: None, selection: None, + owned: false, + shown: None, picked: None, sketch: Some(d.sketch), driven: None, @@ -528,6 +542,8 @@ fn open_editor(app: &mut SolveApp, id: Option) -> bool { draft: None, live: None, selection: None, + owned: false, + shown: None, picked: None, sketch: None, driven, @@ -864,6 +880,8 @@ pub fn edit_param(app: &SolveApp, param: &str) { draft: None, live: None, selection: None, + owned: false, + shown: None, picked: None, sketch: None, driven: None, @@ -913,6 +931,7 @@ fn insert_reference(ctx: &egui::Context, edit: &mut Edit, name: &str) { state.store(ctx, id); ctx.memory_mut(|m| m.request_focus(id)); edit.fresh = FRESH - 1; + edit.owned = true; if let Some(live) = edit.live.as_mut() { live.typed = true; } @@ -1000,7 +1019,26 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) { ui.set_max_width(popup_width); crate::ui_kit::text(ui, &crate::i18n::format("dialog.dimension_name", &[("name", &e.param)]), crate::ui_kit::Text::Inline) .on_hover_text(crate::i18n::tr("dialog.dimension_insert_hint")); + if !e.owned { + // The whole value is selected before the field reads its state, every frame + // until the person takes it over, so typing replaces it (#11204). Only on the + // first frame was not enough: a frame without the keyboard collapses the + // field's selection to its caret, and the first digit went in beside the value. + let n = e.expr.chars().count(); + let mut s = egui::text_edit::TextEditState::load(ui.ctx(), id).unwrap_or_default(); + s.cursor.set_char_range(Some(egui::text_selection::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n)))); + e.selection = s.cursor.char_range(); + s.store(ui.ctx(), id); + // A key this frame acts on the whole value (a digit replaces it, Home puts the + // caret before it); from then on the caret is the person's. + let focused = ui.memory(|m| m.has_focus(id)); + e.owned = focused && ui.input(|i| i.events.iter().any(|ev| matches!(ev, egui::Event::Key { pressed: true, .. }))); + } let r = crate::ui_kit::cell_editor(ui, id, &mut e.expr, "", false); + // A press into the field puts the caret where it landed; not the press that placed + // or pinned the value, which began before the box sat there. + let settled = e.shown == Some(anchor); + e.owned |= settled && r.hovered() && ui.input(|i| i.pointer.any_pressed()); crate::theme::TabAccent::number_focus(ui, &r); if r.has_focus() { e.selection = egui::TextEdit::load_state(ctx, id).and_then(|s| s.cursor.char_range()); @@ -1012,17 +1050,10 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) { if let Some(live) = e.live.as_mut() { live.typed |= r.changed() || completed; } + e.owned |= r.changed() || completed; if let Some(error) = e.draft.as_ref().and_then(|d| d.error.as_ref()) { crate::ui_kit::text(ui, error, crate::ui_kit::Text::Report("dimension_error", true)); } - if e.fresh == FRESH { - // The whole value is selected, so typing replaces it. - let n = e.expr.chars().count(); - let mut s = egui::text_edit::TextEditState::load(ui.ctx(), id).unwrap_or_default(); - s.cursor.set_char_range(Some(egui::text_selection::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n)))); - e.selection = s.cursor.char_range(); - s.store(ui.ctx(), id); - } let enter = ui.input(|i| i.key_pressed(egui::Key::Enter)); if r.lost_focus() && enter { done = Some(true); @@ -1042,6 +1073,7 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) { }); }); e.fresh = e.fresh.saturating_sub(1); + e.shown = Some(anchor); match done { Some(true) => { let result = if let Some(draft) = &e.draft { @@ -1060,7 +1092,8 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) { match result { Err(err) => { app.set_status(err, true); - EDIT.with(|x| *x.borrow_mut() = Some(Edit { fresh: FRESH, ..e })); + // The value is selected again, so typing replaces it. + EDIT.with(|x| *x.borrow_mut() = Some(Edit { fresh: FRESH, owned: false, ..e })); } Ok(reply) => { clear_picks(app); diff --git a/crates/ui-egui/src/dimension_create_ui_tests.rs b/crates/ui-egui/src/dimension_create_ui_tests.rs index f551f898a..986fff3b9 100644 --- a/crates/ui-egui/src/dimension_create_ui_tests.rs +++ b/crates/ui-egui/src/dimension_create_ui_tests.rs @@ -865,6 +865,101 @@ fn type_first_keeps_the_place_first_flow() { crate::dim_view::cancel(); } +/// Put the value field's caret at `at` with nothing selected, as the field itself does when it +/// misses the keyboard for a frame (a WebView2 showed the caret before the value, #11204). +fn caret_without_the_person(h: &Harness, at: usize) { + let id = egui::Id::new("sc_dim_edit"); + let mut state = egui::TextEdit::load_state(&h.ctx, id).unwrap_or_default(); + state.cursor.set_char_range(Some(egui::text::CCursorRange::one(egui::text::CCursor::new(at)))); + state.store(&h.ctx, id); +} + +/// A primary click at sketch point `at`, the button held down for `frames` frames. +fn held_click(h: &mut Harness, at: [f64; 2], frames: usize) { + h.step(&json!({"move":{"world":[at[0],at[1],0]}})).unwrap(); + let [x, y] = h.at(&json!({"world":[at[0],at[1],0]})).unwrap(); + let pos = egui::pos2(x as f32, y as f32); + let (button, modifiers) = (egui::PointerButton::Primary, egui::Modifiers::NONE); + h.app.synthetic.push(egui::Event::PointerButton { pos, button, pressed: true, modifiers }); + h.frames(frames); + h.app.synthetic.push(egui::Event::PointerButton { pos, button, pressed: false, modifiers }); + h.settle(); +} + +/// The value field's caret and selection end (characters). +fn caret(h: &Harness) -> Option<(usize, usize)> { + egui::TextEdit::load_state(&h.ctx, egui::Id::new("sc_dim_edit")) + .and_then(|s| s.cursor.char_range()) + .map(|r| (r.primary.index.0, r.secondary.index.0)) +} + +/// Until the person takes the proposed value over, the first digit they type replaces all of +/// it (#11204): however long the click that placed it was held, frames later, and whatever moved +/// the caret without them. Typed without Ctrl+A, as a person does. +#[test] +fn typed_digits_replace_the_proposed_value_whatever_moved_the_caret() { + for held in [1usize, 4, 12] { + let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]); + let dims = dimension_count(&h); + h.step(&json!({"click":{"world":[10,0,0]}})).unwrap(); + assert_live(&h); + // A click held `held` frames: what a person's 60 to 150 ms click is at 60 Hz and beyond. + held_click(&mut h, [10., -7.], held); + assert_eq!(crate::dim_view::live(), None, "held {held}: the text is pinned"); + h.frames(12); + caret_without_the_person(&h, 0); + h.frames(2); + assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::new("sc_dim_edit")), "held {held}"); + keys(&mut h, "400"); + assert_eq!(crate::dim_view::draft_preview().map(|d| d.0).as_deref(), Some("400"), "held {held}"); + h.step(&json!({"key":"Enter"})).unwrap(); + let new = added(&h, dims); + assert_eq!(new.len(), 1, "held {held}"); + assert!((new[0].kind.value().unwrap() - 400.).abs() < 1e-6, "held {held}: {:?}", new[0].kind); + crate::dim_view::cancel(); + } +} + +/// A caret the person put somewhere stays there: Home then 1 writes in front of the value, and a +/// click into the field types where it landed (#11204). +#[test] +fn a_caret_the_person_moved_stays_where_they_put_it() { + let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]); + let dims = dimension_count(&h); + h.step(&json!({"click":{"world":[10,0,0]}})).unwrap(); + assert_live(&h); + h.step(&json!({"click":{"world":[10,-7,0]}})).unwrap(); + h.frames(4); + h.step(&json!({"key":"Home"})).unwrap(); + h.frames(4); + assert_eq!(caret(&h), Some((0, 0)), "Home put the caret before the value"); + keys(&mut h, "1"); + h.frames(4); + assert_eq!(caret(&h), Some((1, 1)), "the caret stays after what was typed"); + assert_eq!(crate::dim_view::draft_preview().map(|d| d.0).as_deref(), Some("120 mm")); + h.step(&json!({"key":"Enter"})).unwrap(); + let new = added(&h, dims); + assert_eq!(new.len(), 1); + assert!((new[0].kind.value().unwrap() - 120.).abs() < 1e-6, "{:?}", new[0].kind); + crate::dim_view::cancel(); + + // A click into the field puts the caret where it landed: typing goes there. + let mut h = sketch_with(&[("sketch.line", json!({"points":[[0,0],[20,0]],"infer":false}))], [10., 0.]); + h.step(&json!({"click":{"world":[10,0,0]}})).unwrap(); + h.step(&json!({"click":{"world":[10,-7,0]}})).unwrap(); + h.frames(4); + let [x, y] = h.widget("20 mm").expect("the value field"); + h.step(&json!({"click":[x, y]})).unwrap(); + h.frames(4); + assert!(crate::dim_view::editing(), "a click into the field keeps the value open"); + let placed = caret(&h); + assert!(placed.is_some_and(|(a, b)| a == b), "the click placed a caret: {placed:?}"); + keys(&mut h, "4"); + let expr = crate::dim_view::draft_preview().map(|d| d.0).unwrap_or_default(); + assert!(expr.len() == "20 mm4".len() && expr.contains('4') && expr != "4", "typing went in at the click, not over the value: {expr:?}"); + crate::dim_view::cancel(); +} + /// Type-first, the text follows the pointer: moving it from inside the box the picks span (the /// distance between them) to above or beside it switches to the horizontal or vertical distance and /// back. Until something is typed the value follows the dimension, so the preview measures the