Sketch dimensions: enter the value in a small window with step arrows (#7246) (#7251)

* claim: #7246

* feat(sketch): enter a dimension's value in a small window with step arrows (#7246)

* Dimension window: fit the layer split, and keep the wheel off the camera over the window

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
authored and GitHub committed 2026-11-04 05:12:31 +00:00
1 parent 86db05e538
commit 7bd66b7c06
12 files changed
+853 -49

No files matched your search

@@ -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ổ"
}
}
+20 -1
View File
@@ -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 {
+345
View File
@@ -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, &param, &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);
}
@@ -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")] {
+1
View File
@@ -582,6 +582,7 @@ pub(crate) fn handle(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect, resp: &e
let 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)
+30
View File
@@ -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());
}
+33
View File
@@ -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"));
});
});
});
});
}
+53 -45
View File
@@ -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)]
+18 -3
View File
@@ -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;
}
@@ -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}}}
]
+10
View File
@@ -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; its
lines 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 draw
then gets all its dimensions at the sizes you drew: a line its length and angle, a rectangle its
+3
View File
@@ -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)