SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch dimensions: enter the value in a small window with step arrows (#7246) (#7251)
Lars Jansen7bd66b7c06a2
diff --git a/assets/locales/pending/sketch-dimension-window.json b/assets/locales/pending/sketch-dimension-window.jsonnew file mode 100644index 0000000000..1daf8e5ae0--- /dev/null+++ b/assets/locales/pending/sketch-dimension-window.json@@ -0,0 +1,110 @@+{+ "en": {+ "dialog.dimension_step_down": "Down by {step}",+ "dialog.dimension_step_expression": "Only a number steps; an expression stays as typed",+ "dialog.dimension_step_up": "Up by {step}",+ "prefs.dimension_step_angle": "What the window's arrows, Up/Down and the wheel add to an angle",+ "prefs.dimension_step_length": "What the window's arrows, Up/Down and the wheel add to a length",+ "prefs.dimension_steps": "Window steps",+ "prefs.dimension_values": "Dimension values",+ "prefs.dimension_values_note": "Where you type a dimension's value. A window has arrows that step it; the Dimension tool places the text first.",+ "prefs.dimension_values_view": "In the view",+ "prefs.dimension_values_window": "In a window"+ },+ "ja": {+ "dialog.dimension_step_down": "{step} 減らす",+ "dialog.dimension_step_expression": "増減できるのは数値だけです。式はそのまま残ります",+ "dialog.dimension_step_up": "{step} 増やす",+ "prefs.dimension_step_angle": "ウィンドウの矢印、上下キー、ホイールで角度に加える量",+ "prefs.dimension_step_length": "ウィンドウの矢印、上下キー、ホイールで長さに加える量",+ "prefs.dimension_steps": "ウィンドウの増減量",+ "prefs.dimension_values": "寸法値の入力",+ "prefs.dimension_values_note": "寸法値を入力する場所です。ウィンドウでは矢印で値を増減でき、寸法ツールは先に文字を配置します。",+ "prefs.dimension_values_view": "ビュー内",+ "prefs.dimension_values_window": "ウィンドウ"+ },+ "zh": {+ "dialog.dimension_step_down": "减少 {step}",+ "dialog.dimension_step_expression": "只有数字可以增减;表达式保持不变",+ "dialog.dimension_step_up": "增加 {step}",+ "prefs.dimension_step_angle": "窗口的箭头、上下方向键和滚轮给角度增减的量",+ "prefs.dimension_step_length": "窗口的箭头、上下方向键和滚轮给长度增减的量",+ "prefs.dimension_steps": "窗口步长",+ "prefs.dimension_values": "尺寸值",+ "prefs.dimension_values_note": "输入尺寸值的位置。窗口带有可增减数值的箭头;尺寸工具会先放置文字。",+ "prefs.dimension_values_view": "在视图中",+ "prefs.dimension_values_window": "在窗口中"+ },+ "de": {+ "dialog.dimension_step_down": "Um {step} verringern",+ "dialog.dimension_step_expression": "Nur eine Zahl lässt sich schrittweise ändern; ein Ausdruck bleibt, wie er eingegeben ist",+ "dialog.dimension_step_up": "Um {step} erhöhen",+ "prefs.dimension_step_angle": "Was die Pfeile des Fensters, Auf/Ab und das Mausrad zu einem Winkel addieren",+ "prefs.dimension_step_length": "Was die Pfeile des Fensters, Auf/Ab und das Mausrad zu einer Länge addieren",+ "prefs.dimension_steps": "Schritte im Fenster",+ "prefs.dimension_values": "Bemaßungswerte",+ "prefs.dimension_values_note": "Wo der Wert einer Bemaßung eingegeben wird. Ein Fenster hat Pfeile, die ihn schrittweise ändern; das Bemaßungswerkzeug platziert zuerst den Text.",+ "prefs.dimension_values_view": "In der Ansicht",+ "prefs.dimension_values_window": "In einem Fenster"+ },+ "ko": {+ "dialog.dimension_step_down": "{step} 줄이기",+ "dialog.dimension_step_expression": "숫자만 증감할 수 있으며 수식은 입력한 그대로 유지됩니다",+ "dialog.dimension_step_up": "{step} 늘리기",+ "prefs.dimension_step_angle": "창의 화살표, 위/아래 키와 휠이 각도에 더하는 값",+ "prefs.dimension_step_length": "창의 화살표, 위/아래 키와 휠이 길이에 더하는 값",+ "prefs.dimension_steps": "창의 증감 단위",+ "prefs.dimension_values": "치수 값",+ "prefs.dimension_values_note": "치수 값을 입력하는 위치입니다. 창에는 값을 증감하는 화살표가 있으며, 치수 도구는 텍스트를 먼저 배치합니다.",+ "prefs.dimension_values_view": "뷰에서",+ "prefs.dimension_values_window": "창에서"+ },+ "nl": {+ "dialog.dimension_step_down": "{step} omlaag",+ "dialog.dimension_step_expression": "Alleen een getal verspringt; een uitdrukking blijft zoals ingevoerd",+ "dialog.dimension_step_up": "{step} omhoog",+ "prefs.dimension_step_angle": "Wat de pijlen van het venster, Omhoog/Omlaag en het wieltje bij een hoek optellen",+ "prefs.dimension_step_length": "Wat de pijlen van het venster, Omhoog/Omlaag en het wieltje bij een lengte optellen",+ "prefs.dimension_steps": "Stappen in het venster",+ "prefs.dimension_values": "Maatwaarden",+ "prefs.dimension_values_note": "Waar de waarde van een maat wordt ingevoerd. Een venster heeft pijlen die de waarde laten verspringen; het maatgereedschap plaatst eerst de tekst.",+ "prefs.dimension_values_view": "In de weergave",+ "prefs.dimension_values_window": "In een venster"+ },+ "ar": {+ "dialog.dimension_step_down": "إنقاص بمقدار {step}",+ "dialog.dimension_step_expression": "يتغير الرقم فقط بالخطوات؛ يبقى التعبير كما كُتب",+ "dialog.dimension_step_up": "زيادة بمقدار {step}",+ "prefs.dimension_step_angle": "ما تضيفه أسهم النافذة وأعلى/أسفل والعجلة إلى الزاوية",+ "prefs.dimension_step_length": "ما تضيفه أسهم النافذة وأعلى/أسفل والعجلة إلى الطول",+ "prefs.dimension_steps": "خطوات النافذة",+ "prefs.dimension_values": "قيم الأبعاد",+ "prefs.dimension_values_note": "مكان كتابة قيمة البعد. للنافذة أسهم تغيّرها بخطوات؛ تضع أداة البعد النص أولًا.",+ "prefs.dimension_values_view": "في العرض",+ "prefs.dimension_values_window": "في نافذة"+ },+ "he": {+ "dialog.dimension_step_down": "הפחתה ב־{step}",+ "dialog.dimension_step_expression": "רק מספר משתנה בצעדים; ביטוי נשאר כפי שנכתב",+ "dialog.dimension_step_up": "הוספה של {step}",+ "prefs.dimension_step_angle": "מה שהחצים בחלון, למעלה/למטה והגלגלת מוסיפים לזווית",+ "prefs.dimension_step_length": "מה שהחצים בחלון, למעלה/למטה והגלגלת מוסיפים לאורך",+ "prefs.dimension_steps": "צעדי החלון",+ "prefs.dimension_values": "ערכי מידות",+ "prefs.dimension_values_note": "היכן מקלידים את ערך המידה. לחלון יש חצים שמשנים אותו בצעדים; כלי המידה מציב קודם את הטקסט.",+ "prefs.dimension_values_view": "בתצוגה",+ "prefs.dimension_values_window": "בחלון"+ },+ "vi": {+ "dialog.dimension_step_down": "Giảm {step}",+ "dialog.dimension_step_expression": "Chỉ số mới thay đổi theo bước; biểu thức giữ nguyên như đã nhập",+ "dialog.dimension_step_up": "Tăng {step}",+ "prefs.dimension_step_angle": "Lượng mà mũi tên của cửa sổ, Lên/Xuống và con lăn cộng vào một góc",+ "prefs.dimension_step_length": "Lượng mà mũi tên của cửa sổ, Lên/Xuống và con lăn cộng vào một độ dài",+ "prefs.dimension_steps": "Bước của cửa sổ",+ "prefs.dimension_values": "Giá trị kích thước",+ "prefs.dimension_values_note": "Nơi bạn nhập giá trị kích thước. Cửa sổ có mũi tên để thay đổi theo bước; công cụ Kích thước đặt văn bản trước.",+ "prefs.dimension_values_view": "Trong khung nhìn",+ "prefs.dimension_values_window": "Trong một cửa sổ"+ }+}diff --git a/crates/ui-egui/src/dim_view.rs b/crates/ui-egui/src/dim_view.rsindex 381145289a..ecb6727bbc 100644--- a/crates/ui-egui/src/dim_view.rs+++ b/crates/ui-egui/src/dim_view.rs@@ -31,6 +31,8 @@ use crate::SolveApp;use crate::theme::Tokens;use crate::viewport::Proj;+pub(crate) mod window;+/// A dimension as drawn this frame (screen space), for hit testing.#[derive(Clone, Debug)]struct Drawn {@@ -153,6 +155,7 @@ fn shown_error(id: &str, e: &str) -> String {pub fn cancel() {EDIT.with(|edit| *edit.borrow_mut() = None);PLACEMENT.with(|preview| *preview.borrow_mut() = None);+ window::forget();}/// Infer the measured value through the same command as scripts, without creating a real@@ -192,6 +195,11 @@ pub fn begin_dimension(app: &mut SolveApp, entities: Vec<String>, at: Vec2) -> R/// it. Midpoint pairs and dimensions that would only be driven keep the place-first flow:/// the pointer chooses the orientation, and a click places the text before entering a value.pub fn begin_live(app: &mut SolveApp, entities: Vec<String>, pointer: Option<Pos2>) -> Result<bool, String> {+ // The value window opens on placed text (`window`): a window following the pointer could+ // not be reached.+ if window::on(app) {+ return Ok(false);+ }// A midpoint pair chooses its orientation and text position before entering a value.// This also permits switching freely between driving and reference spans.let midpoint_pair = entities.len() == 2 && entities.iter().all(|id| id.starts_with("mid:"));@@ -844,6 +852,7 @@ pub fn show(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, proj: &P}}DRAWN.with(|d| *d.borrow_mut() = drawn);+ window::paint(app, painter, proj);edit_box(app, ui.ctx());}@@ -1005,6 +1014,10 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) {}return;};+ if window::on(app) {+ let (done, escaped) = window::show(app, ctx, &mut e, at);+ return settle(app, e, done, escaped);+ }let id = egui::Id::new("sc_dim_edit");let mut done: Option<bool> = None;let mut escaped = false;@@ -1074,8 +1087,14 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) {});});});- e.fresh = e.fresh.saturating_sub(1);e.shown = Some(anchor);+ settle(app, e, done, escaped);+}++/// Apply or drop the edit as the box or the window answered (`done`: Some(true) applies, Some(false)+/// drops it, and `escaped` the Dimension tool's picks with it), or keep it open.+fn settle(app: &mut SolveApp, mut e: Edit, done: Option<bool>, escaped: bool) {+ e.fresh = e.fresh.saturating_sub(1);match done {Some(true) => {let result = if let Some(draft) = &e.draft {diff --git a/crates/ui-egui/src/dim_view/window.rs b/crates/ui-egui/src/dim_view/window.rsnew file mode 100644index 0000000000..00d68744cb--- /dev/null+++ b/crates/ui-egui/src/dim_view/window.rs@@ -0,0 +1,345 @@+//! The dimension value window (Preferences › Sketch › Dimension values: In a window, #7246).+//! Placing a dimension with the Dimension tool, or double-clicking one, opens a small window at+//! its text, kept inside the view, instead of the box on the dimension:+//! - the value field, which takes what the box takes (numbers, units, expressions, parameter+//! names, `w = 20`; a click on another dimension inserts its name);+//! - arrows that step a plain number by the step preferences: a length by `dimension_step_mm`,+//! written in the unit the value is written in (none: the design's), an angle by+//! `dimension_step_deg`. Up/Down and the mouse wheel over the field step it too (Shift: ten+//! steps, Alt: a tenth, as in the other value fields). An expression is left as typed;+//! - a check (OK, also Enter) and a cross (Cancel, also Esc).+//!+//! While it is open the sketch shows the value: what it moves is drawn in the preview colour, and+//! why OK would refuse it shows under the field. Nothing reaches the design until OK, which+//! applies through the box's own path (`edit_box`), so undo, driven dimensions and refusals are+//! the same as there. Cancel drops this edit only: a new dimension is not added, and the+//! Dimension tool stays on for the next one. A click elsewhere drops it as well, as it does the+//! box.+//!+//! With the window the Dimension tool places a new dimension's text first (`begin_live` keeps the+//! place-first flow), and the window opens on the placed text: a window following the pointer+//! could never be reached.++use super::*;+use crate::prefs::{DIMENSION_STEP_DEG, DIMENSION_STEP_MM, DimensionInput};+use solidcraft_engine::doc::expr::{Kind, unit_info};++/// The window's area.+const AREA: &str = "sc_dim_window";++/// The window is on (Preferences › Sketch).+pub(super) fn on(app: &SolveApp) -> bool {+ app.preferences.dimension_input == DimensionInput::Window+}++/// What a step adds to a length (millimetres) and to an angle (degrees). A saved value outside+/// what Preferences accepts (a hand edit) steps by the default.+fn steps(app: &SolveApp) -> (f64, f64) {+ let or_default = |value: f64, accepted: std::ops::RangeInclusive<f64>| if accepted.contains(&value) { value } else { 1.0 };+ (or_default(app.preferences.dimension_step_mm, DIMENSION_STEP_MM), or_default(app.preferences.dimension_step_deg, DIMENSION_STEP_DEG))+}++/// Whether a dimension's value is a length or an angle, from its parameter's unit.+fn kind(doc: &solidcraft_engine::doc::Document, param: &str) -> Kind {+ doc.param(param).and_then(|p| unit_info(&p.unit)).map_or(Kind::Length, |(kind, _)| kind)+}++/// `text` moved by `steps` steps (negative: down) of `step_mm` (a length) or `step_deg` (an+/// angle). A plain number keeps the unit it is written in (none: `design_unit` for a length,+/// degrees for an angle) and its decimal mark, gaining the decimal places the step needs in that+/// unit. `None` for anything else: an expression is left as typed.+pub(crate) fn stepped(text: &str, steps: f64, kind: Kind, design_unit: &str, step_mm: f64, step_deg: f64) -> Option<String> {+ crate::value_step::shifted(text, |written| {+ let unit = match written {+ "" if kind == Kind::Angle => "deg",+ "" => design_unit,+ "\"" | "″" => "in",+ "'" | "′" => "ft",+ unit => unit,+ };+ let (unit_kind, per_unit) = unit_info(unit)?;+ let step = match (kind, unit_kind) {+ (Kind::Length, Kind::Length) => step_mm,+ (Kind::Angle, Kind::Angle) => step_deg.to_radians(),+ _ => return None,+ };+ let amount = step / per_unit * steps;+ (amount.is_finite() && per_unit > 0.0).then(|| (amount, places(amount)))+ })+}++/// The fewest decimal places, at most six, that write `amount` as it is.+fn places(amount: f64) -> usize {+ let a = amount.abs();+ (0..6)+ .find(|p| {+ let scale = 10f64.powi(*p);+ ((a * scale).round() / scale - a).abs() <= a * 1e-9+ })+ .map_or(6, |p| p as usize)+}++/// What OK would make of an existing dimension's typed value, worked out once per text: the+/// sketch it gives, or the refusal OK would show. It runs OK's own command on a scratch copy of+/// the session, so nothing reaches the design.+struct Existing {+ doc: Arc<solidcraft_engine::doc::Document>,+ param: String,+ expr: String,+ sketch: Option<Arc<solidcraft_engine::doc::SolvedSketch>>,+ error: Option<String>,+}++thread_local! {+ static EXISTING: RefCell<Option<Existing>> = const { RefCell::new(None) };+ /// Where the open window sits, for which parameter, and the frame it was last drawn in. It+ /// stays where it opened while it is open, so its arrows stay under the pointer while the+ /// stepped value moves the dimension's text.+ static ANCHOR: RefCell<Option<(String, u64, Pos2)>> = const { RefCell::new(None) };+}++/// Whether the open window is under `p`: the wheel there steps its value, so the camera under it+/// does not zoom (navigation asks).+pub(crate) fn covers(ctx: &egui::Context, p: Pos2) -> bool {+ super::editing() && ctx.memory(|m| m.area_rect(egui::Id::new(AREA))).is_some_and(|r| r.contains(p))+}++/// Forget the worked-out value (the edit closed).+pub(super) fn forget() {+ EXISTING.with(|e| *e.borrow_mut() = None);+}++fn existing(app: &SolveApp, param: &str, expr: &str) -> (Option<Arc<solidcraft_engine::doc::SolvedSketch>>, Option<String>) {+ EXISTING.with(|cell| {+ let mut cell = cell.borrow_mut();+ let current = cell.as_ref().is_some_and(|x| Arc::ptr_eq(&x.doc, &app.session.doc) && x.param == param && x.expr == expr);+ if !current {+ let expression = crate::length_input::expression(&app.session.doc, expr, kind(&app.session.doc, param));+ let mut scratch = app.session.scratch();+ let (sketch, error) = match scratch.execute("parameters.change", &json!({"name": param, "expression": expression})) {+ Ok(_) => {+ (app.session.active_sketch.and_then(|id| scratch.world_state().ok()?.sketches.iter().find(|s| s.feature == id).cloned()), None)+ }+ Err(e) => (None, Some(shown_error("parameters.change", &e.to_string()))),+ };+ *cell = Some(Existing { doc: app.session.doc.clone(), param: param.to_string(), expr: expr.to_string(), sketch, error });+ }+ cell.as_ref().map(|x| (x.sketch.clone(), x.error.clone())).unwrap_or_default()+ })+}++/// Draw what the open window's value moves in the sketch, in the preview colour, over the sketch+/// as it is. A value OK would refuse shows nothing.+pub(super) fn paint(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {+ if !on(app) {+ return;+ }+ let Some((param, expr, draft)) = EDIT.with(|edit| {+ let edit = edit.borrow();+ let e = edit.as_ref()?;+ let draft = e.draft.as_ref().map(|d| (d.sketch, d.preview.clone(), d.error.is_some()));+ Some((e.param.clone(), e.expr.clone(), draft))+ }) else {+ return;+ };+ let Some(sketch) = app.session.active_sketch else { return };+ let after = match draft {+ Some((id, preview, false)) => preview.sketches.iter().find(|s| s.feature == id).cloned(),+ Some((_, _, true)) => None,+ None => existing(app, ¶m, &expr).0,+ };+ let state = app.session.world_state().ok();+ let changes = after.and_then(|after| crate::preview::sketch_changes(state.as_ref().and_then(|state| state.sketch(sketch)), &after));+ let mut budget = solidcraft_engine::render::SamplingBudget::new(32_768, 65_536);+ let curves = changes.map_or(0, |changes| crate::preview::paint_sketch(&changes, painter, proj, &mut budget));+ crate::scenario::publish_count("dimwin:preview_curves", curves as f64);+}++/// Where the window goes: where it already is while it stays open, else under the dimension's+/// text `at` (over it where the view has no room below); always inside the view's free area.+/// `size` is the window's as drawn last frame.+fn place(app: &SolveApp, ctx: &egui::Context, param: &str, at: Pos2, size: egui::Vec2) -> Pos2 {+ let frame = ctx.cumulative_frame_nr();+ let view = app.viewport.layout.as_ref().map(|layout| layout.drawable).filter(|r| r.is_finite() && r.is_positive());+ ANCHOR.with(|anchor| {+ let mut anchor = anchor.borrow_mut();+ let open = anchor.as_ref().filter(|(open, drawn, _)| open == param && drawn.saturating_add(1) >= frame).map(|x| x.2);+ let mut pos = open.unwrap_or_else(|| {+ let gap = Tokens::get().space_12;+ let below = Pos2::new(at.x - size.x * 0.5, at.y + gap);+ if view.is_some_and(|rect| below.y + size.y > rect.bottom()) { Pos2::new(below.x, at.y - gap - size.y) } else { below }+ });+ if let Some(rect) = view {+ pos.x = pos.x.clamp(rect.left(), (rect.right() - size.x).max(rect.left()));+ pos.y = pos.y.clamp(rect.top(), (rect.bottom() - size.y).max(rect.top()));+ }+ *anchor = Some((param.to_string(), frame, pos));+ pos+ })+}++/// The check or the cross in `rect`, its icon in colour as the view's own OK and Cancel draw it+/// (`view_confirm`): hover, the pointing hand, its tooltip, and its handle `key` for scenarios and+/// the control channel. True when clicked.+fn button(ui: &mut egui::Ui, rect: Rect, key: &str, tip: &str, icon: &str) -> bool {+ let t = Tokens::get();+ let response = ui.interact(rect, ui.id().with(key), egui::Sense::click());+ if response.hovered() {+ ui.painter().rect_filled(rect, t.control_radius, t.hover);+ ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);+ }+ crate::icons::paint_icon(ui.painter(), rect.shrink(t.space_4), icon, 1.0);+ response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, tip));+ crate::scenario::publish_target(key, rect);+ response.on_hover_text(tip).clicked()+}++/// Draw the window for the open edit `e` at its dimension's text `at` (screen) and answer it:+/// `Some(true)` applies it (the check, Enter), `Some(false)` drops it; the second value says+/// whether a new dimension's picks go too (the cross, Esc), as Esc in the box does.+pub(super) fn show(app: &mut SolveApp, ctx: &egui::Context, e: &mut Edit, at: Pos2) -> (Option<bool>, bool) {+ let t = Tokens::get();+ let id = egui::Id::new("sc_dim_edit");+ let area = egui::Id::new(AREA);+ let (kind, error) = match &e.draft {+ Some(draft) => (kind(&draft.preview_doc, &e.param), draft.error.clone()),+ None => (kind(&app.session.doc, &e.param), existing(app, &e.param, &e.expr).1),+ };+ let (step_mm, step_deg) = steps(app);+ let unit = crate::length_input::unit(&app.session.doc).to_string();+ let step = |text: &str, steps: f64| stepped(text, steps, kind, &unit, step_mm, step_deg);+ let step_text = if kind == Kind::Angle {+ format!("{:.*}°", usize::from(app.preferences.angle_decimals), step_deg)+ } else {+ crate::prefs::format_length(step_mm, &app.session.doc.units, app.preferences.length_decimals)+ };+ let last = ctx.memory(|m| m.area_rect(area));+ let width = t.space_24 * 8.0;+ let guess = egui::vec2(width + t.space_6 * 2.0, t.control_height * 2.0 + t.space_6 * 3.0);+ let anchor = place(app, ctx, &e.param, at, last.map_or(guess, |r| r.size()));+ // A click on the window (an arrow) takes the keyboard from its field, as any click away does;+ // the field takes it back instead of closing.+ let on_window = ctx.input(|i| i.pointer.any_click() && i.pointer.interact_pos().is_some_and(|p| last.is_some_and(|r| r.contains(p))));+ let mut answer: Option<bool> = None;+ let mut escaped = false;+ let mut by = 0.0;+ Container::new(ctx, Surface::Canvas).area(area).fixed_pos(anchor).order(egui::Order::Foreground).show(ctx, |ui| {+ Container::popup_frame(ui.style()).fill(t.dialog_body).inner_margin(t.space_6).show(ui, |ui| {+ crate::ui_kit::scope(ui, |ui| {+ ui.set_width(width);+ // The parameter's name, then the check and the cross.+ let (title, _) = ui.allocate_exact_size(egui::vec2(width, t.control_height), egui::Sense::hover());+ let name = crate::i18n::format("dialog.dimension_name", &[("name", &e.param)]);+ ui.scope_builder(egui::UiBuilder::new().max_rect(title).layout(egui::Layout::left_to_right(egui::Align::Center)), |ui| {+ crate::ui_kit::text(ui, &name, crate::ui_kit::Text::Inline).on_hover_text(crate::i18n::tr("dialog.dimension_insert_hint"));+ });+ let side = t.control_height;+ let cancel = Rect::from_min_size(egui::pos2(title.right() - side, title.top()), egui::vec2(side, side));+ let ok = cancel.translate(egui::vec2(-(side + t.space_2), 0.0));+ if button(ui, ok, "dimwin:ok", crate::i18n::tr("ui.heading_ok"), "finish") {+ answer = Some(true);+ }+ if button(ui, cancel, "dimwin:cancel", crate::i18n::tr("ui.cancel"), "close") {+ answer = Some(false);+ escaped = true;+ }+ // The value, with its arrows at its right (the kit's own up and down arrows).+ let (row, _) = ui.allocate_exact_size(egui::vec2(width, t.control_height), egui::Sense::hover());+ let arrows = 2.0 * (t.form_close_size - t.space_4) + t.space_2;+ let (r, up, down) = ui+ .scope_builder(egui::UiBuilder::new().max_rect(row).layout(egui::Layout::left_to_right(egui::Align::Center)), |ui| {+ ui.spacing_mut().item_spacing.x = t.space_2;+ let field = egui::vec2((row.width() - arrows - t.space_2).max(t.space_24), t.control_height);+ let r = ui.allocate_ui(field, |ui| crate::ui_kit::cell_editor(ui, id, &mut e.expr, "", false)).inner;+ crate::scenario::publish_target("dimwin:value", r.rect);+ if r.has_focus() {+ e.selection = egui::TextEdit::load_state(ctx, id).and_then(|s| s.cursor.char_range());+ }+ if crate::expression_complete::complete(ui, &r, &mut e.expr) {+ e.selection = egui::TextEdit::load_state(ctx, id).and_then(|s| s.cursor.char_range());+ }+ let can_step = step(&e.expr, 1.0).is_some();+ let tip = |id: &str| {+ if can_step {+ crate::i18n::format(id, &[("step", &step_text)])+ } else {+ crate::i18n::tr("dialog.dimension_step_expression").to_string()+ }+ };+ let up = crate::ui_kit::compact_button(ui, crate::ui_kit::MOVE_UP, &tip("dialog.dimension_step_up"), can_step, false);+ crate::scenario::publish_target("dimwin:up", up.rect);+ let down = crate::ui_kit::compact_button(ui, crate::ui_kit::MOVE_DOWN, &tip("dialog.dimension_step_down"), can_step, false);+ crate::scenario::publish_target("dimwin:down", down.rect);+ (r, up.clicked(), down.clicked())+ })+ .inner;+ if up {+ by += 1.0;+ }+ if down {+ by -= 1.0;+ }+ // Up/Down in the field and the wheel over it or its arrows step too.+ if r.has_focus() {+ by += ui.input(crate::value_step::key_tenths) as f64 / 10.0;+ }+ let wheel = id.with("dimwin_wheel");+ if ui.rect_contains_pointer(row) {+ by += crate::value_step::wheel_tenths(ui, wheel) as f64 / 10.0;+ crate::navigation::claim_wheel(ui.ctx());+ } else {+ ui.data_mut(|d| d.remove::<f32>(wheel));+ }+ if let Some(error) = &error {+ crate::ui_kit::text(ui, error, crate::ui_kit::Text::Report("dimension_error", true));+ }+ if e.fresh == FRESH {+ select_all(ctx, id, e);+ }+ let enter = ui.input(|i| i.key_pressed(egui::Key::Enter));+ let field = if r.lost_focus() && enter {+ Some(true)+ } else if e.fresh > 0 || on_window || by != 0.0 {+ if !r.has_focus() {+ r.request_focus();+ }+ None+ } else if r.lost_focus() {+ Some(false)+ } else {+ None+ };+ answer = answer.or(field);+ if ui.input(|i| i.key_pressed(egui::Key::Escape)) {+ answer = Some(false);+ escaped = true;+ }+ });+ });+ });+ if let Some(rect) = ctx.memory(|m| m.area_rect(area)) {+ crate::scenario::publish_rect("dimwin", rect);+ }+ if by != 0.0+ && answer.is_none()+ && let Some(stepped) = step(&e.expr, by)+ {+ e.expr = stepped;+ // The whole new value is selected, so typing replaces it.+ select_all(ctx, id, e);+ ctx.request_repaint();+ }+ if answer.is_some() {+ forget();+ }+ (answer, escaped)+}++/// Select the whole value in the field, so typing replaces it.+fn select_all(ctx: &egui::Context, id: egui::Id, e: &mut Edit) {+ let n = e.expr.chars().count();+ let mut state = egui::TextEdit::load_state(ctx, id).unwrap_or_default();+ state.cursor.set_char_range(Some(egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n))));+ e.selection = state.cursor.char_range();+ state.store(ctx, id);+}diff --git a/crates/ui-egui/src/dimension_create_ui_tests.rs b/crates/ui-egui/src/dimension_create_ui_tests.rsindex 986fff3b90..7693c18a13 100644--- a/crates/ui-egui/src/dimension_create_ui_tests.rs+++ b/crates/ui-egui/src/dimension_create_ui_tests.rs@@ -192,6 +192,215 @@ fn dimension_tool_click_respects_the_selection_filter() {crate::dim_view::cancel();}+/// A line from the origin to `end` with Preferences › Sketch › Dimension values set to In a+/// window (#7246).+fn windowed(end: [f64; 2]) -> Harness {+ let mut h = line(end);+ h.call("ui.prefs", json!({"dimension_input": "window"}));+ h+}++/// The value the open new dimension's window holds.+fn draft_value() -> String {+ crate::dim_view::draft_preview().map(|(expr, _, _)| expr).unwrap_or_default()+}++/// In a window, the Dimension tool places the text first and the window opens on it. Its arrows,+/// Up/Down and the wheel over the field step the value while the sketch previews it, nothing+/// reaches the design before the check, the check adds the dimension in one undo step, and the+/// tool stays on for the next dimension.+#[test]+fn a_new_dimension_in_the_window_steps_previews_and_applies_once() {+ let mut h = windowed([20., 0.]);+ let original = h.app.session.doc.to_json();+ let undo = h.app.session.undo.len();+ h.step(&json!({"start":"sketch.dimension"})).unwrap();+ h.step(&json!({"click":{"world":[10,0,0]}})).unwrap();+ assert_eq!(crate::dim_view::live(), None, "no value follows the pointer before the text is placed");+ assert!(!crate::dim_view::editing());+ h.step(&json!({"click":{"world":[10,6,0]}})).unwrap();+ h.frames(3);+ assert!(crate::dim_view::editing(), "placing the text opens the window");+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::new("sc_dim_edit")), "its field takes the keyboard");+ let window = crate::scenario::rect_of("dimwin").expect("the window is shown");+ let drawable = h.app.viewport.layout.as_ref().unwrap().drawable;+ assert!(drawable.contains_rect(window), "the window {window:?} stays in the view {drawable:?}");+ assert_eq!(draft_value(), "20 mm");+ let arrow = crate::scenario::handle_at("dimwin:up");+ for _ in 0..3 {+ h.step(&json!({"click":{"handle":"dimwin:up"}})).unwrap();+ }+ h.frames(2);+ assert_eq!(crate::scenario::handle_at("dimwin:up"), arrow, "the window stays put while the value moves the text");+ let (value, dimension, _) = crate::dim_view::draft_preview().unwrap();+ assert_eq!(value, "23 mm");+ assert!((dimension.kind.value().unwrap() - 23.).abs() < 1e-6, "the sketch previews the stepped value");+ assert!(crate::scenario::count_of("dimwin:preview_curves").unwrap_or(0.0) > 0.0, "what the value moves is drawn");+ assert_eq!(h.app.session.doc.to_json(), original, "nothing reaches the design before OK");+ assert_eq!(h.app.session.undo.len(), undo);+ assert_eq!(h.ctx.memory(|m| m.focused()), Some(egui::Id::new("sc_dim_edit")), "the arrows leave the keyboard with the field");+ // The wheel over the field steps it instead of zooming the view.+ let cam = h.app.cam;+ let field = crate::scenario::rect_of("dimwin:value").unwrap();+ h.call("ui.scroll", json!({"x": field.center().x, "y": field.center().y, "delta": -40.0}));+ h.frames(2);+ assert_eq!(draft_value(), "22 mm");+ assert_eq!(h.app.cam, cam, "the view did not zoom");+ h.step(&json!({"key":"ArrowUp"})).unwrap();+ h.frames(2);+ assert_eq!(draft_value(), "23 mm");+ h.step(&json!({"click":{"handle":"dimwin:ok"}})).unwrap();+ h.frames(2);+ assert!(!crate::dim_view::editing(), "{}", h.call("ui.inspect", json!({})));+ assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");+ let state = h.app.session.world_state().unwrap();+ let sk = &state.sketch(h.app.session.active_sketch.unwrap()).unwrap().sketch;+ let dimension = sk.constraints.iter().find(|c| c.param.is_some()).expect("the dimension was added");+ assert!((dimension.kind.value().unwrap() - 23.).abs() < 1e-6);+ assert_eq!(h.app.tool.as_ref().map(|t| (t.cmd, t.picks.len())), Some(("sketch.dimension", 0)), "the tool stays on for the next one");+ crate::dim_view::cancel();+}++/// The cross and Esc drop only the dimension in the window: nothing is added and the Dimension+/// tool stays on. Esc with no window open then puts the tool down, as before.+#[test]+fn the_window_cross_and_escape_drop_only_this_dimension() {+ let mut h = windowed([20., 0.]);+ let original = h.app.session.doc.to_json();+ let undo = h.app.session.undo.len();+ place(&mut h, &[[10., 0.]], [10., 6.]);+ h.step(&json!({"click":{"handle":"dimwin:up"}})).unwrap();+ h.step(&json!({"click":{"handle":"dimwin:cancel"}})).unwrap();+ h.frames(2);+ assert!(!crate::dim_view::editing());+ assert_eq!(h.app.session.doc.to_json(), original);+ assert_eq!(h.app.session.undo.len(), undo);+ assert_eq!(h.app.tool.as_ref().map(|t| (t.cmd, t.picks.len())), Some(("sketch.dimension", 0)));+ place(&mut h, &[[10., 0.]], [10., 6.]);+ h.step(&json!({"key":"Escape"})).unwrap();+ assert!(!crate::dim_view::editing());+ assert_eq!(h.app.session.doc.to_json(), original);+ assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.dimension"), "Esc in the window leaves the tool on");+ h.frames(40);+ h.step(&json!({"key":"Escape"})).unwrap();+ assert!(h.app.tool.is_none(), "Esc with no window open ends the tool");+ crate::dim_view::cancel();+}++/// Double-clicking an existing dimension opens the window too. Typing and stepping preview the+/// sketch without touching the design, a value OK would refuse says why under the field, an+/// expression is left as typed by the arrows, and Enter applies the value in one undo step.+#[test]+fn double_clicking_a_dimension_opens_the_window_with_a_live_preview() {+ let mut h = windowed([20., 0.]);+ h.app.run("parameters.add", json!({"name":"width","expression":"30 mm"})).unwrap();+ h.app.run("sketch.dimension", json!({"entities":["l1"],"value":20,"text_at":[10,8]})).unwrap();+ h.settle();+ let before = h.app.session.doc.to_json();+ let undo = h.app.session.undo.len();+ h.frames(40);+ h.step(&json!({"click":{"dimension":"d1"},"double":true})).unwrap();+ h.frames(3);+ assert!(crate::dim_view::editing() && crate::scenario::rect_of("dimwin").is_some(), "the window opens on the dimension");+ type_value(&mut h, "26");+ h.frames(2);+ assert!(crate::scenario::count_of("dimwin:preview_curves").unwrap_or(0.0) > 0.0, "the sketch previews 26");+ h.step(&json!({"key":"ArrowUp"})).unwrap();+ h.frames(2);+ assert!(h.widget("27").is_some(), "Up stepped the value: {}", h.call("ui.inspect", json!({})));+ assert_eq!(h.app.session.doc.to_json(), before, "nothing reaches the design before OK");+ type_value(&mut h, "no_such_name");+ h.frames(2);+ assert!(crate::scenario::rect_of("dialog:report:dimension_error").is_some(), "the refusal shows under the field");+ assert_eq!(crate::scenario::count_of("dimwin:preview_curves"), Some(0.0), "a refused value previews nothing");+ type_value(&mut h, "width - 4");+ h.step(&json!({"click":{"handle":"dimwin:up"}})).unwrap();+ h.frames(2);+ assert!(h.widget("width - 4").is_some(), "an expression is left as typed");+ type_value(&mut h, "27");+ h.step(&json!({"key":"Enter"})).unwrap();+ h.frames(2);+ assert!(!crate::dim_view::editing());+ assert!((h.app.session.doc.eval("d1", solidcraft_engine::doc::expr::Kind::Length).unwrap() - 27.).abs() < 1e-6);+ assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");+ crate::dim_view::cancel();+}++/// The arrows keep the unit and decimal mark a value is written in: a length steps by the length+/// step converted to that unit (a bare number is in the design's unit), an angle by the angle+/// step, and anything but a plain number is left alone.+#[test]+fn window_steps_keep_the_written_unit_and_decimal_mark() {+ use crate::dim_view::window::stepped;+ use solidcraft_engine::doc::expr::Kind::{Angle, Length};+ assert_eq!(stepped("20 mm", 1.0, Length, "mm", 1.0, 1.0).as_deref(), Some("21 mm"));+ assert_eq!(stepped("20", -1.0, Length, "mm", 0.5, 1.0).as_deref(), Some("19.5"));+ assert_eq!(stepped("1 in", 1.0, Length, "mm", 2.54, 1.0).as_deref(), Some("1.1 in"));+ assert_eq!(stepped("1", 1.0, Length, "in", 2.54, 1.0).as_deref(), Some("1.1"), "a bare length is in the design's unit");+ assert_eq!(stepped("3\"", 10.0, Length, "mm", 2.54, 1.0).as_deref(), Some("4\""));+ assert_eq!(stepped("2,5 cm", 1.0, Length, "mm", 1.0, 1.0).as_deref(), Some("2,6 cm"));+ assert_eq!(stepped("45 deg", -1.0, Angle, "mm", 1.0, 5.0).as_deref(), Some("40 deg"));+ assert_eq!(stepped("45", 0.1, Angle, "in", 1.0, 1.0).as_deref(), Some("45.1"), "a bare angle is in degrees");+ assert_eq!(stepped("width / 2", 1.0, Length, "mm", 1.0, 1.0), None);+ assert_eq!(stepped("20 deg", 1.0, Length, "mm", 1.0, 1.0), None, "a length does not step an angle");+}++/// Dimension values default to In the view with steps of 1 mm and 1°; the choice and the steps+/// save, out-of-range steps and unknown choices are refused, and the Sketch page's Restore+/// Defaults and Cancel treat them as the page's own.+#[test]+fn the_dimension_window_preferences_default_save_and_reset() {+ use crate::prefs::{DimensionInput, Prefs, control};+ let d = Prefs::default();+ assert_eq!((d.dimension_input, d.dimension_step_mm, d.dimension_step_deg), (DimensionInput::View, 1.0, 1.0));+ let old: Prefs = serde_json::from_value(json!({})).unwrap();+ assert_eq!(old.dimension_input, DimensionInput::View, "saved preferences without it keep the box");+ let read = crate::prefs::lenient(&json!({"dimension_input": "sideways", "dimension_step_mm": 2.0}));+ assert_eq!((read.dimension_input, read.dimension_step_mm), (DimensionInput::View, 2.0), "an unknown choice costs only itself");+ let mut app = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());+ for refused in [+ json!({"dimension_input": "sideways"}),+ json!({"dimension_step_mm": 0.0}),+ json!({"dimension_step_mm": 5000.0}),+ json!({"dimension_step_deg": 0.0}),+ json!({"dimension_step_deg": 200.0}),+ ] {+ assert!(control(&mut app, &refused).is_err(), "{refused}");+ }+ assert_eq!(app.preferences, Prefs::default(), "a refusal changes nothing");+ control(&mut app, &json!({"open": "Sketch", "dimension_input": "window", "dimension_step_mm": 0.5, "dimension_step_deg": 15.0})).unwrap();+ control(&mut app, &json!({"button": "apply"})).unwrap();+ let mut other = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());+ other.load_prefs(&app.prefs());+ assert_eq!(+ (other.preferences.dimension_input, other.preferences.dimension_step_mm, other.preferences.dimension_step_deg),+ (DimensionInput::Window, 0.5, 15.0)+ );+ control(&mut app, &json!({"button": "defaults"})).unwrap();+ assert_eq!(+ (app.preferences.dimension_input, app.preferences.dimension_step_mm, app.preferences.dimension_step_deg),+ (DimensionInput::View, 1.0, 1.0)+ );+ control(&mut app, &json!({"button": "cancel"})).unwrap();+ assert_eq!(+ (app.preferences.dimension_input, app.preferences.dimension_step_mm, app.preferences.dimension_step_deg),+ (DimensionInput::Window, 0.5, 15.0)+ );+}++/// The Sketch page's Dimension values switch is a real control.+#[test]+fn the_sketch_page_switches_dimension_values_to_a_window() {+ let mut h = Harness::new();+ h.call("ui.prefs", json!({"open": "Sketch"}));+ h.frames(4);+ let handle = format!("dialog:{}:{}", crate::i18n::tr("prefs.dimension_values"), crate::i18n::tr("prefs.dimension_values_window"));+ crate::prefs::reveal_preference(&mut h, &handle);+ h.step(&json!({"click":{"handle": handle}})).unwrap();+ h.frames(2);+ assert_eq!(h.app.preferences.dimension_input, crate::prefs::DimensionInput::Window);+}+#[test]fn dimension_parameters_use_typing_and_ctrl_space_completion() {for (prefix, expected) in [("wid", "width"), ("", "width"), ("d", "d1")] {diff --git a/crates/ui-egui/src/navigation.rs b/crates/ui-egui/src/navigation.rsindex 6456b8fb75..76cc3eab22 100644--- a/crates/ui-egui/src/navigation.rs+++ b/crates/ui-egui/src/navigation.rs@@ -582,6 +582,7 @@ pub(crate) fn handle(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect, resp: &elet wheel_inside = inside|| (ui.is_enabled()&& !crate::value_step::enabled(ui.ctx())+ && !hover.is_some_and(|p| crate::dim_view::window::covers(ui.ctx(), p))&& hover.is_some_and(|p| {rect.contains(p)&& !axes.contains(p)diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex f81cc07553..0966e4b68d 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -676,6 +676,21 @@ impl OriginPlaneNames {}}+/// Where a sketch dimension's value is typed (Preferences › Sketch, "Dimension values", #7246).+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum DimensionInput {+ /// In a box on the dimension (also what a value this version doesn't know reads as).+ #[default]+ View,+ /// In a small window at the dimension, with arrows that step the value (`dim_view::window`).+ Window,+}++/// The lengths (millimetres) and angles (degrees) the dimension window's arrows may step by.+pub const DIMENSION_STEP_MM: std::ops::RangeInclusive<f64> = 0.001..=1000.0;+pub const DIMENSION_STEP_DEG: std::ops::RangeInclusive<f64> = 0.001..=180.0;+/// What an orbit turns around (Preferences: "Orbit around").#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]@@ -1567,6 +1582,13 @@ preference_settings! {line_hover_tangent_arc: bool = false, PAGE_SKETCH;/// Include hidden geometry and a small pointer neighbourhood in Select Other.select_other_hidden: bool = true, PAGE_SKETCH;+ /// Where a dimension's value is typed: in a box on the dimension (the default), or in a small+ /// window at it whose arrows step the value (#7246, `dim_view::window`).+ dimension_input: DimensionInput = DimensionInput::View, PAGE_SKETCH;+ /// What the dimension window's arrows, Up/Down and the wheel add to a length (millimetres,+ /// converted to the unit the value is written in) and to an angle (degrees).+ dimension_step_mm: f64 = 1.0, PAGE_SKETCH, accept(DIMENSION_STEP_MM);+ dimension_step_deg: f64 = 1.0, PAGE_SKETCH, accept(DIMENSION_STEP_DEG);/// When true: Shift+click adds without removing; Primary toggles./// When false (default): Shift and Primary both toggle.selection_shift_add_only: bool = false, PAGE_SKETCH;@@ -3983,6 +4005,11 @@ fn prepare_preferences({return Err("`stand_up_unknown` must be ask, note or off".into());}+ if let Some(v) = p.get("dimension_input")+ && !matches!(v.as_str(), Some("view" | "window"))+ {+ return Err("`dimension_input` must be view or window".into());+ }let mut new: Prefs = serde_json::from_value(cur).map_err(|e| e.to_string())?;migrate_gruvbox(&mut new);if let Some(update) = p.get("theme_options") {@@ -4076,6 +4103,9 @@ fn prepare_preferences(if !accepted::perspective_fov(&new) {return Err("`perspective_fov` must be 15°…90° in radians (0.2618…1.5708)".into());}+ if !accepted::dimension_step_mm(&new) || !accepted::dimension_step_deg(&new) {+ return Err("`dimension_step_mm` must be 0.001…1000 and `dimension_step_deg` 0.001…180".into());+ }if solidcraft_engine::doc::display_quality::DisplayQuality::parse(&new.display_quality).is_none() {return Err("`display_quality` must be coarse, normal, fine or ultra".into());}diff --git a/crates/ui-egui/src/prefs/sketch.rs b/crates/ui-egui/src/prefs/sketch.rsindex ede212693c..d8e88e0f3a 100644--- a/crates/ui-egui/src/prefs/sketch.rs+++ b/crates/ui-egui/src/prefs/sketch.rs@@ -172,6 +172,7 @@ fn drawing(app: &mut SolveApp, ui: &mut egui::Ui) {);});});+ dimension_values(app, ui, t.space_24 * 8.0 + t.space_8);});}@@ -480,3 +481,35 @@ fn targets(key: &str, response: &egui::Response) {};crate::scenario::publish_target(&format!("dialog:{legacy}"), response.rect);}++/// Where a dimension's value is typed, and what the window's arrows step lengths and angles by+/// (#7246). The steps only matter in the window, so they wait for it.+fn dimension_values(app: &mut SolveApp, ui: &mut egui::Ui, label_width: f32) {+ let label = app.tr("prefs.dimension_values").to_string();+ ui_kit::settings_block_hint(ui, &label, app.tr("prefs.dimension_values_note"), label_width, |ui| {+ let options = [app.tr("prefs.dimension_values_view"), app.tr("prefs.dimension_values_window")];+ let mut selected = usize::from(app.preferences.dimension_input == DimensionInput::Window);+ if ui_kit::settings_segments(ui, &label, &mut selected, &options) {+ app.preferences.dimension_input = if selected == 1 { DimensionInput::Window } else { DimensionInput::View };+ }+ });+ let window = app.preferences.dimension_input == DimensionInput::Window;+ let units = app.session.doc.units.clone();+ let decimals = app.preferences.length_decimals;+ ui_kit::settings_block(ui, app.tr("prefs.dimension_steps"), label_width, |ui| {+ ui.add_enabled_ui(window, |ui| {+ ui.horizontal(|ui| {+ let t = Tokens::get();+ ui_kit::settings_control_width(ui, t.form_label_width, |ui| {+ let p = &mut app.preferences;+ ui_kit::bounded_length_field(ui, &mut p.dimension_step_mm, &units, decimals, DIMENSION_STEP_MM, 0.1)+ .on_hover_text(crate::i18n::tr("prefs.dimension_step_length"));+ });+ ui_kit::settings_control_width(ui, t.form_label_width, |ui| {+ ui_kit::number_field(ui, &mut app.preferences.dimension_step_deg, DIMENSION_STEP_DEG, 0.1, "°")+ .on_hover_text(crate::i18n::tr("prefs.dimension_step_angle"));+ });+ });+ });+ });+}diff --git a/crates/ui-egui/src/preview.rs b/crates/ui-egui/src/preview.rsindex 6ee7f0078e..cc5889fd57 100644--- a/crates/ui-egui/src/preview.rs+++ b/crates/ui-egui/src/preview.rs@@ -774,38 +774,7 @@ pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {replaced.push(b.name.clone());}}- let sketches = after- .sketches- .iter()- .filter_map(|sketch| {- let old = before.sketch(sketch.feature);- let old_curves =- old.into_iter().flat_map(|s| s.sketch.curves.iter().map(|c| (c.id.as_str(), c))).collect::<std::collections::HashMap<_, _>>();- let old_points =- old.into_iter().flat_map(|s| s.sketch.points.iter().map(|p| (p.id.as_str(), p.pos))).collect::<std::collections::HashMap<_, _>>();- let indices = sketch- .sketch- .curves- .iter()- .enumerate()- .filter_map(|(index, curve)| {- let unchanged = old_curves.get(curve.id.as_str()).is_some_and(|previous| {- previous.kind == curve.kind- && curve.kind.point_ids().iter().all(|i| old.and_then(|s| s.sketch.point(*i)) == sketch.sketch.point(*i))- });- if unchanged { None } else { Some(index) }- })- .collect::<Vec<_>>();- let points = sketch- .sketch- .points- .iter()- .enumerate()- .filter_map(|(i, p)| if old_points.get(p.id.as_str()) == Some(&p.pos) { None } else { Some(i) })- .collect::<Vec<_>>();- if indices.is_empty() && points.is_empty() { None } else { Some(SketchPreview { sketch: sketch.clone(), curves: indices, points }) }- })- .collect();+ let sketches = after.sketches.iter().filter_map(|sketch| sketch_changes(before.sketch(sketch.feature), sketch)).collect();Built { scene: sc, sketches, replaced, error: None, bounds: Aabb3::EMPTY, applied: None, tapered: Vec::new(), stopped: None }}@@ -821,6 +790,37 @@ fn on_surface(index: &SurfaceIndex, [a, b, c]: [Vec3; 3]) -> bool {/// bounded, so a modeled thread's thousands of faces still cost little.const FACE_SAMPLES: usize = 24;+/// What of `sketch` differs from `old`, the same sketch before a change: the curves whose shape+/// or points moved and the points that moved (`None`: nothing did).+pub(crate) fn sketch_changes(+ old: Option<&solidcraft_engine::doc::SolvedSketch>,+ sketch: &std::sync::Arc<solidcraft_engine::doc::SolvedSketch>,+) -> Option<SketchPreview> {+ let old_curves = old.into_iter().flat_map(|s| s.sketch.curves.iter().map(|c| (c.id.as_str(), c))).collect::<std::collections::HashMap<_, _>>();+ let old_points =+ old.into_iter().flat_map(|s| s.sketch.points.iter().map(|p| (p.id.as_str(), p.pos))).collect::<std::collections::HashMap<_, _>>();+ let indices = sketch+ .sketch+ .curves+ .iter()+ .enumerate()+ .filter_map(|(index, curve)| {+ let unchanged = old_curves.get(curve.id.as_str()).is_some_and(|previous| {+ previous.kind == curve.kind && curve.kind.point_ids().iter().all(|i| old.and_then(|s| s.sketch.point(*i)) == sketch.sketch.point(*i))+ });+ if unchanged { None } else { Some(index) }+ })+ .collect::<Vec<_>>();+ let points = sketch+ .sketch+ .points+ .iter()+ .enumerate()+ .filter_map(|(i, p)| if old_points.get(p.id.as_str()) == Some(&p.pos) { None } else { Some(i) })+ .collect::<Vec<_>>();+ if indices.is_empty() && points.is_empty() { None } else { Some(SketchPreview { sketch: sketch.clone(), curves: indices, points }) }+}+/// Which of the `nf` faces of `m` are new surface, i.e. not on the old mesh? Each is decided by/// a vote of points on it (triangle centroids spread over the face). One pass over `m`'s/// triangles gathers the centroids, and the old mesh is indexed once, so the cost stays@@ -962,22 +962,30 @@ pub fn paint_sketches(app: &SolveApp, painter: &egui::Painter, proj: &crate::vie{return;}- let stroke = egui::Stroke::new(2.5, Tokens::get().preview_sketch);let mut budget = solidcraft_engine::render::SamplingBudget::new(32_768, 65_536);- let mut curves = 0;- for preview in &app.preview.sketches {- let sketch = &preview.sketch;- for index in &preview.curves {- crate::tools::paint_curve(&sketch.sketch, *index, &sketch.plane, painter, proj, stroke, &mut budget);- curves += 1;- }- for index in &preview.points {- if let Some(point) = sketch.sketch.point(*index).and_then(|p| proj.to_screen(sketch.plane.to_world(p))) {- painter.circle_filled(point, 3.0, stroke.color);- }+ let curves: usize = app.preview.sketches.iter().map(|preview| paint_sketch(preview, painter, proj, &mut budget)).sum();+ crate::scenario::publish_count("sketch_preview_curves", curves as f64);+}++/// Draw what a change moves in a sketch, its curves and points, in the preview colour; returns+/// how many curves it drew.+pub(crate) fn paint_sketch(+ preview: &SketchPreview,+ painter: &egui::Painter,+ proj: &crate::viewport::Proj,+ budget: &mut solidcraft_engine::render::SamplingBudget,+) -> usize {+ let stroke = egui::Stroke::new(2.5, Tokens::get().preview_sketch);+ let sketch = &preview.sketch;+ for index in &preview.curves {+ crate::tools::paint_curve(&sketch.sketch, *index, &sketch.plane, painter, proj, stroke, budget);+ }+ for index in &preview.points {+ if let Some(point) = sketch.sketch.point(*index).and_then(|p| proj.to_screen(sketch.plane.to_world(p))) {+ painter.circle_filled(point, 3.0, stroke.color);}}- crate::scenario::publish_count("sketch_preview_curves", curves as f64);+ preview.curves.len()}#[cfg(test)]diff --git a/crates/ui-egui/src/value_step.rs b/crates/ui-egui/src/value_step.rsindex a8a0cbfb24..b8022ab5cc 100644--- a/crates/ui-egui/src/value_step.rs+++ b/crates/ui-egui/src/value_step.rs@@ -80,7 +80,7 @@ fn tenths_for(m: Modifiers) -> Option<i64> {}/// This frame's Up/Down presses, key repeats included, in signed tenths.-fn key_tenths(i: &egui::InputState) -> i64 {+pub(crate) fn key_tenths(i: &egui::InputState) -> i64 {i.events.iter().filter_map(|e| match e {@@ -94,7 +94,7 @@ fn key_tenths(i: &egui::InputState) -> i64 {/// This frame's wheel notches over the field in signed tenths. Scrolling up steps up. A mouse/// wheel reports lines (a notch each); a trackpad reports points, which add up across frames in/// `key` until they make a notch (a line's worth, `line_scroll_speed`).-fn wheel_tenths(ui: &egui::Ui, key: egui::Id) -> i64 {+pub(crate) fn wheel_tenths(ui: &egui::Ui, key: egui::Id) -> i64 {let speed = ui.ctx().options(|o| o.input_options.line_scroll_speed).max(1.0);let mut pending = ui.data(|d| d.get_temp::<f32>(key)).unwrap_or(0.0);let mut out = 0i64;@@ -167,7 +167,22 @@ fn plain(text: &str) -> Option<Plain> {fn stepped(text: &str, tenths: i64) -> Option<String> {let p = plain(text)?;let places = if tenths % 10 == 0 { p.places } else { p.places.max(1) };- let v = p.value + tenths as f64 / 10.0;+ rewritten(text, &p, p.value + tenths as f64 / 10.0, places)+}++/// `text` with its plain number moved by what `by` answers for the unit it is written in (the+/// text after the number, empty for none): an amount and the decimal places it needs, written+/// with at least the places the number had (`dim_view::window` steps by a length or an angle+/// this way). `None` when `text` is not a plain number or `by` has no answer.+pub(crate) fn shifted(text: &str, by: impl FnOnce(&str) -> Option<(f64, usize)>) -> Option<String> {+ let p = plain(text)?;+ let (amount, places) = by(text.get(p.end..)?.trim())?;+ rewritten(text, &p, p.value + amount, places.max(p.places))+}++/// `text` with its plain number `p` replaced by `v` written with `places` decimals, in the decimal+/// mark it had.+fn rewritten(text: &str, p: &Plain, v: f64, places: usize) -> Option<String> {if !v.is_finite() {return None;}diff --git a/crates/ui-egui/tests/scenarios/sketch_dimension_window.json b/crates/ui-egui/tests/scenarios/sketch_dimension_window.jsonnew file mode 100644index 0000000000..3114639af8--- /dev/null+++ b/crates/ui-egui/tests/scenarios/sketch_dimension_window.json@@ -0,0 +1,21 @@+[+ {"note": "#7246: with Preferences › Sketch › Dimension values set to In a window, the Dimension tool places the text first and a small window opens on it. Its arrows step the value, the check applies it in one step, and the tool stays on for the next dimension."},+ {"call": "ui.prefs", "params": {"dimension_input": "window"}},+ {"call": "engine.execute", "params": {"command": "sketch.create", "params": {"plane": "XY"}}},+ {"call": "engine.execute", "params": {"command": "sketch.line", "params": {"points": [[0, 0], [30, 0]], "ids": ["l1"]}}},+ {"call": "ui.view", "params": {"view": "top"}},+ {"call": "ui.view", "params": {"view": "fit"}},+ {"start": "sketch.dimension"},+ {"click": {"sketch": [15, 0]}},+ {"click": {"sketch": [15, 6]}},+ {"frames": 5},+ {"expect": {"shown_handles": ["dimwin:value", "dimwin:up", "dimwin:down", "dimwin:ok", "dimwin:cancel"]}},+ {"click": {"handle": "dimwin:up"}},+ {"click": {"handle": "dimwin:up"}},+ {"click": {"handle": "dimwin:ok"}},+ {"frames": 3},+ {"expect": {"errors": 0}},+ {"expect": {"hidden_handles": ["dimwin:value"]}},+ {"expect": {"tool": "sketch.dimension"}},+ {"expect": {"query": {"command": "sketch.inspect", "path": ["curves", 0, "end_at", 0], "value": 32}}}+]diff --git a/docs/book/src/guide/sketching.md b/docs/book/src/guide/sketching.mdindex 8fed36e2d0..a9cec30da3 100644--- a/docs/book/src/guide/sketching.md+++ b/docs/book/src/guide/sketching.md@@ -368,6 +368,16 @@ nothing picked yet, click it once: its value box opens with the value selected,and the tool stays on for the next dimension. The dimension's text always takes the click; itslines take it only away from sketch points and curves, which still start a new dimension.+To type values in a small window instead, set **Preferences › Sketch › Dimension values** to+**In a window**. The Dimension tool then places the text first: click what you want to+measure, then where the text goes, and the window opens there (double-clicking a dimension+opens it too). Its field takes the same numbers, units, expressions and parameter names as the+box, and the sketch shows the value as you type. The arrows beside the field, Up and Down, and+the mouse wheel over the field step a number by **Window steps** (1 mm and 1° unless you change+them; Shift steps ten times as far, Alt a tenth), keeping the unit it is written in. The check+(or Enter) applies the value as one undo step and the tool stays on for the next dimension; the+cross (or Esc) drops this dimension only, and Esc with no window open puts the tool down.+To have shapes dimensioned as you draw them, turn on **Dimension new shapes** in Preferences ›Sketch (it is off by default). Each line, rectangle, circle, arc, slot, polygon or ellipse you drawthen gets all its dimensions at the sizes you drew: a line its length and angle, a rectangle itsdiff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 4949c5b317..9e5e35304d 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -702,6 +702,9 @@ One setting per line, sorted by name. A change that adds a setting adds its own- `default_units`- `dialog_buttons` (`bottom` (default), `top`: a feature dialog's OK, Cancel and Apply sit in its title row instead of under its inputs, #6708; the buttons keep their handles, and `dialog:close` is then Cancel's; the Sketch panel's Finish Sketch row moves above its options, #9860)- `dialog_place` (`edge` (default) or `left_column`: command dialogs open in the left column in place of the browser and the History, #6707)+- `dimension_input` (`view` (default): a sketch dimension's value is typed in a box on the dimension; `window`: placing a dimension with the Dimension tool, or double-clicking one, opens a small window at it with the value field (handle `dimwin:value`), arrows that step the value (`dimwin:up`, `dimwin:down`), a check (`dimwin:ok`, also Enter) and a cross (`dimwin:cancel`, also Esc), #7246)+- `dimension_step_deg` (default 1, 0.001…180: what the dimension window's arrows, Up/Down and the wheel over its field add to an angle, in degrees)+- `dimension_step_mm` (default 1, 0.001…1000: what the window's arrows, Up/Down and the wheel over its field add to a length, in millimetres, written in the unit the value is written in)- `extrude_auto_to_object` (default true: in the Extrude dialog, with a profile picked, a face, vertex or parallel plane picked off its plane switches the extent to To Object, unless the Profiles box was clicked into; it applies to Extrude dialogs opened afterwards)- `frame_rate_details` (default false: with the frame rate, a frame-time graph of the frames drawn with the triangles over it, a frame-time histogram and what the GPU drew; clicking the readout switches it)- `graphics_adapter` (exact card name, or empty for Automatic; applies after restart; `WGPU_ADAPTER_NAME` takes precedence)