Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch dimension: typing replaces the proposed value (#11204) (#11214)

kaltenbrunnermarkus160ee037cce9
diff --git a/crates/ui-egui/src/dim_view.rs b/crates/ui-egui/src/dim_view.rs
index b55dd8c6a8..8125509934 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<Live>,
selection: Option<egui::text::CCursorRange>,
+ /// 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<Pos2>,
/// 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<String>, 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<String>, pointer: Option<Pos
draft: Some(draft),
live,
selection: None,
+ owned: false,
+ shown: None,
picked: None,
sketch: None,
driven: None,
@@ -243,6 +254,7 @@ fn move_text(app: &SolveApp, e: &mut Edit, at: Vec2) {
if expr != e.expr {
// Keep the new value selected, so typing still replaces it.
e.fresh = FRESH;
+ e.owned = false;
}
(e.param, e.expr, *draft) = (param, expr, redone);
return;
@@ -429,6 +441,8 @@ pub fn model_double_click(app: &mut SolveApp, pos: Pos2) -> 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<String>) -> 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 f551f898a1..986fff3b90 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