Skip to content

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

Thread: suggest cylinder size and expose metric diameter and pitch (#1759)

Colin Faulkinghamda65b4fc8c36
diff --git a/ROADMAP.md b/ROADMAP.md
index 1033266f7b..c394976286 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -80,6 +80,11 @@ completed drawings publish atomically. The browser still exports synchronously.
## Interactive modelling
+- Thread resolves a suggested metric size when a cylindrical face is picked. Diameter and
+ pitch selectors expose the existing metric designation parameter; custom designations stay
+ editable, and Automatic size returns to the face's suggestion. Cosmetic/modelled and
+ full/partial-length options remain available. This does not add tolerance classes or
+ left-hand threads.
- New Body extrusion and face-offset previews show completed intermediate geometry while a
drag continues, then catch up to the exact final value. Changes to the selected geometry,
operation or feature still discard obsolete results. Distance arrows and their value boxes
diff --git a/assets/locales/en.json b/assets/locales/en.json
index b0a05d490c..5c5c9f474b 100644
--- a/assets/locales/en.json
+++ b/assets/locales/en.json
@@ -783,6 +783,10 @@
"sketch_text.path_hint": "A curve of the sketch the text follows: click here, then the curve",
"sketch_text.use_font_file": "Use the font file {path}",
"the parts library is not available": "the parts library is not available",
+ "thread.automatic_size": "Automatic size",
+ "thread.designation": "Designation",
+ "thread.iso_metric": "ISO metric",
+ "thread.select_size": "Select size",
"timeline.group": "New Feature Folder",
"timeline.move_many": "Move Timeline Items",
"timeline.move_to_group": "Move Features to Folder",
diff --git a/assets/locales/ja.json b/assets/locales/ja.json
index 9e8c692d6c..f5a41eaa12 100644
--- a/assets/locales/ja.json
+++ b/assets/locales/ja.json
@@ -783,6 +783,10 @@
"sketch_text.path_hint": "文字が沿うスケッチの曲線: ここをクリックしてから曲線をクリック",
"sketch_text.use_font_file": "フォント ファイル {path} を使用",
"the parts library is not available": "パーツライブラリは利用できません",
+ "thread.automatic_size": "サイズを自動選択",
+ "thread.designation": "ねじの呼び",
+ "thread.iso_metric": "ISOメートルねじ",
+ "thread.select_size": "サイズを選択",
"timeline.group": "フィーチャーフォルダを新規作成",
"timeline.move_many": "タイムライン項目を移動",
"timeline.move_to_group": "フィーチャーをフォルダへ移動",
diff --git a/assets/locales/zh.json b/assets/locales/zh.json
index 34e1af5af7..dbea5f178e 100644
--- a/assets/locales/zh.json
+++ b/assets/locales/zh.json
@@ -783,6 +783,10 @@
"sketch_text.path_hint": "文字所跟随的草图曲线:先单击此处,再选择曲线",
"sketch_text.use_font_file": "使用字体文件 {path}",
"the parts library is not available": "零件库不可用",
+ "thread.automatic_size": "自动尺寸",
+ "thread.designation": "螺纹标记",
+ "thread.iso_metric": "ISO 公制",
+ "thread.select_size": "选择尺寸",
"timeline.group": "新建特征文件夹",
"timeline.move_many": "移动时间线项目",
"timeline.move_to_group": "将特征移至文件夹",
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index aaf39d76a1..a9c4f566b1 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -209,6 +209,12 @@ const ISO_COARSE: [(f64, f64); 22] = [
(56.0, 5.5),
];
+/// Nominal diameters and coarse pitches (mm) used for automatic ISO metric thread sizing.
+/// Other diameter/pitch pairs can be supplied as explicit designations.
+pub fn metric_thread_sizes() -> &'static [(f64, f64)] {
+ &ISO_COARSE
+}
+
/// "M8" or "M8x1" → (nominal diameter, pitch).
pub fn parse_metric_thread(s: &str) -> Option<(f64, f64)> {
let t = s.trim().to_ascii_uppercase();
@@ -221,7 +227,7 @@ pub fn parse_metric_thread(s: &str) -> Option<(f64, f64)> {
Some(p) => p,
None => ISO_COARSE.iter().find(|(n, _)| (n - d).abs() < 1e-9)?.1,
};
- (d > 0.0 && pitch > 0.0 && pitch < d).then_some((d, pitch))
+ (d.is_finite() && pitch.is_finite() && d > 0.0 && pitch > 0.0 && pitch < d).then_some((d, pitch))
}
/// The metric thread a cylinder of this diameter takes: a shaft is the major diameter, a hole
@@ -241,6 +247,12 @@ fn format_thread(d: f64, p: f64) -> String {
if coarse { format!("M{}", num(d)) } else { format!("M{}x{}", num(d), num(p)) }
}
+/// The automatic ISO metric designation for a cylindrical face, using the same fit check as
+/// a thread feature without an explicit size. This query does not change the model.
+pub fn suggested_thread(st: &ModelState, p: Vec3) -> Result<String> {
+ thread_on(st, 0, p, None, None).map(|t| t.designation)
+}
+
/// A cosmetic thread on the cylindrical face at `p`.
fn thread_on(st: &ModelState, feature: u64, p: Vec3, designation: Option<&str>, length: Option<f64>) -> Result<ThreadInfo> {
let (body, cyl) = st
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index ae00b365d5..285b7d3f95 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -58,9 +58,9 @@ pub use assembly::{
pub use document::*;
pub use eval::{
EdgeRef, FeatureResult, Model, ModelBody, ModelState, PlacedBodies, RevolveExtent, SolvedSketch, ThreadInfo, curve_pick_error, edge_names_for,
- edge_refs, face_point_names, face_point_state, hole_direction_at, import_body_names, object_height, parse_metric_thread, pattern_matrices,
- revolve_extent, revolve_extent_with_convention, select_profiles, sketch_hole_direction, sketch_line_plane, state_in_frame, state_in_frame_at,
- through_all_distance, world_state, world_state_reusing,
+ edge_refs, face_point_names, face_point_state, hole_direction_at, import_body_names, metric_thread_sizes, object_height, parse_metric_thread,
+ pattern_matrices, revolve_extent, revolve_extent_with_convention, select_profiles, sketch_hole_direction, sketch_line_plane, state_in_frame,
+ state_in_frame_at, suggested_thread, through_all_distance, world_state, world_state_reusing,
};
pub use expr::Expr;
pub use names::{BodyName, FeatureName, SketchId};
diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs
index bbd35caeeb..025b2c35b9 100644
--- a/crates/engine/src/cmd/features.rs
+++ b/crates/engine/src/cmd/features.rs
@@ -79,7 +79,7 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("solid.thread", "Thread", thread)
.at("SOLID", "CREATE")
.icon("thread")
- .params("face: [x,y,z] on a cylindrical face; designation?: ISO metric (\"M8\", \"M8x1\"; default: the size that fits); length?: expr (default: the whole face). Cosmetic: the model is unchanged, model.threads lists it"),
+ .params("face: [x,y,z] on a cylindrical face; designation?: ISO metric (\"M8\", \"M8x1\"; default: the size that fits); length?: expr (default: the whole face); modeled?: bool (default false). Cosmetic: the model is unchanged, model.threads lists it. Modeled: cuts the thread profile into the body"),
CommandSpec::new("solid.shell", "Shell", shell)
.at("SOLID", "MODIFY")
.icon("shell")
diff --git a/crates/engine/src/thread_tests.rs b/crates/engine/src/thread_tests.rs
index 906fcb62f8..3b725197ba 100644
--- a/crates/engine/src/thread_tests.rs
+++ b/crates/engine/src/thread_tests.rs
@@ -22,6 +22,18 @@ fn volume(s: &mut Session, b: &str) -> f64 {
const SIZES: [(f64, f64); 9] = [(3.0, 0.5), (4.0, 0.7), (5.0, 0.8), (6.0, 1.0), (8.0, 1.25), (10.0, 1.5), (12.0, 1.75), (16.0, 2.0), (20.0, 2.5)];
+#[test]
+fn non_finite_thread_designations_are_refused_without_changing_the_design() {
+ let mut s = Session::default();
+ run(&mut s, "solid.cylinder", json!({"radius":4,"height":10}));
+ let saved = s.doc.to_json();
+ for designation in ["Minfx1", "M8xinf", "MNaNx1", "M8xNaN", "M1e999x1"] {
+ let result = s.execute("solid.thread", &json!({"face":[4,0,2],"designation":designation}));
+ assert!(result.is_err(), "{designation}: {result:?}");
+ assert_eq!(s.doc.to_json(), saved);
+ }
+}
+
/// ∫ 2π r · width(r) dr over [a, b]: the volume one turn of the groove takes out (a screw
/// motion of a section in an axial plane sweeps 2π∫r dA per turn).
fn per_turn(a: f64, b: f64, width: impl Fn(f64) -> f64) -> f64 {
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index d790e71247..139e10a464 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -137,6 +137,11 @@ pub enum Kind {
Thread {
designation: String,
length: String,
+ /// The last automatic size; a different value is a manual override. Keep automatic
+ /// features automatic when applying, even though their resolved size is visible.
+ suggested: Option<String>,
+ /// The picks used for the suggestion, so an unchanged dialog does no geometry work.
+ of: Vec<Sel>,
},
/// A rib (one wall along open curves) or a web (a wall per curve).
Rib {
@@ -529,9 +534,10 @@ impl Dialog {
),
"solid.scale" => Dialog::new(Kind::Scale { factor: "2".into() }, vec![SelInput::new("Bodies", BODIES, true)]),
"solid.offset_face" => Dialog::new(Kind::OffsetFaces { distance: "2 mm".into() }, vec![SelInput::new("Faces", PLANAR_FACES, true)]),
- "solid.thread" => {
- Dialog::new(Kind::Thread { designation: String::new(), length: String::new() }, vec![SelInput::new("Cylindrical face", FACES, false)])
- }
+ "solid.thread" => Dialog::new(
+ Kind::Thread { designation: String::new(), length: String::new(), suggested: None, of: Vec::new() },
+ vec![SelInput::new("Cylindrical face", FACES, false)],
+ ),
"material.assign" => Dialog::new(Kind::Material { index: 1 }, vec![SelInput::new("Bodies", BODIES, true)]),
"inspect.section" => {
Dialog::new(Kind::Section { offset: "0 mm".into(), flip: false }, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)])
@@ -700,10 +706,30 @@ impl Dialog {
{
inp.items = default_profiles(s);
}
+ d.sync_thread(s);
d.advance();
Some(d)
}
+ /// Resolve a newly selected face without replacing an authored size or changing the
+ /// document. Clearing the face also clears a suggestion that no longer applies.
+ fn sync_thread(&mut self, s: &Session) {
+ let Kind::Thread { designation, suggested, of, .. } = &mut self.kind else { return };
+ if !designation.trim().is_empty() && suggested.as_deref() != Some(designation.as_str()) {
+ return;
+ }
+ let picks = self.inputs.first().map(|i| i.items.as_slice()).unwrap_or_default();
+ if picks == of.as_slice() {
+ return;
+ }
+ *of = picks.to_vec();
+ *suggested = picks.first().and_then(|sel| match sel {
+ Sel::Face { point, .. } => solidcraft_engine::doc::suggested_thread(&s.world_state(), *point).ok(),
+ _ => None,
+ });
+ *designation = suggested.clone().unwrap_or_default();
+ }
+
pub fn rename(feature: u64, name: &str) -> Dialog {
Dialog::new(Kind::Rename { feature, name: name.to_string() }, vec![])
}
@@ -946,6 +972,7 @@ impl Dialog {
self.advance();
}
self.error = None;
+ self.sync_thread(s);
}
/// Box selection result: replace (or add to) the active input.
@@ -976,6 +1003,7 @@ impl Dialog {
inp.items.push(x);
}
}
+ self.sync_thread(s);
}
}
@@ -1712,6 +1740,7 @@ fn input_rows_range(d: &mut Dialog, ui: &mut egui::Ui, s: &Session, range: std::
}
d.active = i;
}
+ d.sync_thread(s);
}
/// Each live reference sits with the independent values it drives.
@@ -2110,6 +2139,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
return;
}
auto_operation(app, &mut d);
+ d.sync_thread(&app.session);
update_measure(app, &mut d);
update_fill_cells(app, &mut d);
// A refused OK's error is about the inputs it ran with (#641). Once a value (in the dialog,
@@ -2750,22 +2780,23 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
enter |= field(ui, distance);
ui.end_row();
}
- Kind::Thread { designation, length } => {
- // Fusion's order: Modeled, Full Length, then the size; a length only when not
- // full.
+ Kind::Thread { designation, length, suggested, of } => {
row_label(ui, "Modeled");
extra_check(ui, &mut d.extra, "modeled");
ui.end_row();
row_label(ui, "Full Length");
let mut full = length.trim().is_empty();
- if ui.checkbox(&mut full, "").changed() {
+ let response = ui.checkbox(&mut full, "");
+ publish_row(&response);
+ if response.changed() {
*length = if full { String::new() } else { "10 mm".into() };
}
ui.end_row();
- row_label(ui, "Size");
- let r = ui.add(egui::TextEdit::singleline(designation).hint_text(tr("fits the face, e.g. M8")));
- enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
- ui.end_row();
+ let (submitted, reset) = crate::dialogs_thread::rows(ui, designation, suggested);
+ enter |= submitted;
+ if reset {
+ of.clear();
+ }
if !full {
row_label(ui, "Length");
enter |= field(ui, length);
@@ -4030,10 +4061,10 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
need(0, "planar faces")?;
("solid.offset_face", json!({"faces": face_points(0), "distance": distance}))
}
- Kind::Thread { designation, length } => {
+ Kind::Thread { designation, length, suggested, .. } => {
need(0, "a cylindrical face")?;
let mut p = json!({"face": face_points(0).into_iter().next().unwrap_or(Value::Null)});
- if !designation.trim().is_empty() {
+ if !designation.trim().is_empty() && suggested.as_deref() != Some(designation.as_str()) {
p["designation"] = json!(designation.trim());
}
if !length.trim().is_empty() {
@@ -5058,10 +5089,13 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
d.kind = Kind::Thread {
designation: designation.clone().unwrap_or_default(),
length: length.as_deref().map(str::to_string).unwrap_or_default(),
+ suggested: None,
+ of: Vec::new(),
};
if let Some(inp) = d.inputs.first_mut() {
inp.items = face_sel(s, face.0).into_iter().collect();
}
+ d.sync_thread(s);
d
}
FeatureKind::BoundingSolid { bodies, margin } => {
diff --git a/crates/ui-egui/src/dialogs_thread.rs b/crates/ui-egui/src/dialogs_thread.rs
new file mode 100644
index 0000000000..b9d0cdf1dc
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_thread.rs
@@ -0,0 +1,95 @@
+//! Metric thread choices use the document's sizing table and the existing designation
+//! parameter. Browsing choices does not edit the model or freeze an automatic feature.
+
+use solidcraft_engine::doc::{metric_thread_sizes, parse_metric_thread};
+
+use crate::dialogs::{check, combo, row_label};
+use crate::i18n::tr;
+
+/// Common pitch presets, not an exhaustive catalogue of standard diameter/pitch pairs.
+/// The coarse and current pitches are included separately; custom pairs remain editable.
+const PITCHES: &[f64] = &[0.2, 0.25, 0.35, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0, 4.0];
+
+/// Returns (Enter pressed, automatic sizing requested).
+pub(crate) fn rows(ui: &mut egui::Ui, designation: &mut String, suggested: &mut Option<String>) -> (bool, bool) {
+ row_label(ui, "Profile");
+ ui.label(tr("ISO metric"));
+ ui.end_row();
+
+ row_label(ui, "Automatic size");
+ let before = designation.trim().is_empty() || suggested.as_deref() == Some(designation.as_str());
+ let mut automatic = before;
+ ui.add_enabled_ui(!designation.trim().is_empty(), |ui| check(ui, &mut automatic));
+ let reset = automatic && !before;
+ if automatic != before {
+ *suggested = None;
+ if automatic {
+ designation.clear();
+ }
+ }
+ ui.end_row();
+
+ let current = parse_metric_thread(designation);
+ let mut diameters: Vec<f64> = metric_thread_sizes().iter().map(|(d, _)| *d).collect();
+ if let Some((d, _)) = current
+ && !diameters.contains(&d)
+ {
+ diameters.push(d);
+ diameters.sort_by(f64::total_cmp);
+ }
+ row_label(ui, "Size");
+ let labels: Vec<String> = diameters.iter().map(|d| format!("{d} mm")).collect();
+ let mut selected = current.and_then(|(d, _)| diameters.iter().position(|n| *n == d)).unwrap_or(diameters.len());
+ let before = selected;
+ let mut labels: Vec<&str> = labels.iter().map(String::as_str).collect();
+ if current.is_none() {
+ labels.push("Select size");
+ }
+ combo(ui, "thread_diameter", &labels, &mut selected);
+ // A new diameter starts with its coarse pitch. The current custom diameter, if any,
+ // is already selected and retains its explicit pitch.
+ if selected != before
+ && let Some(d) = diameters.get(selected)
+ && let Some((_, coarse)) = metric_thread_sizes().iter().find(|(n, _)| n == d)
+ {
+ *designation = format!("M{d}x{coarse}");
+ *suggested = None;
+ }
+ ui.end_row();
+
+ let current = parse_metric_thread(designation);
+ row_label(ui, "Pitch");
+ ui.add_enabled_ui(current.is_some(), |ui| {
+ let mut pitches = Vec::new();
+ if let Some((d, p)) = current {
+ let coarse = metric_thread_sizes().iter().find(|(n, _)| *n == d).map(|(_, p)| *p);
+ pitches.extend(PITCHES.iter().copied().filter(|p| *p < d && *p <= coarse.unwrap_or(d)));
+ pitches.extend(coarse);
+ pitches.push(p);
+ }
+ pitches.sort_by(|a, b| b.total_cmp(a));
+ pitches.dedup();
+ let labels: Vec<String> = pitches.iter().map(|p| format!("{p} mm")).collect();
+ let labels: Vec<&str> = labels.iter().map(String::as_str).collect();
+ let mut selected = current.and_then(|(_, p)| pitches.iter().position(|n| *n == p)).unwrap_or(0);
+ let before = selected;
+ combo(ui, "thread_pitch", &labels, &mut selected);
+ if selected != before
+ && let (Some((d, _)), Some(p)) = (current, pitches.get(selected))
+ {
+ *designation = format!("M{d}x{p}");
+ *suggested = None;
+ }
+ });
+ ui.end_row();
+
+ row_label(ui, "Designation");
+ let response = ui.add(egui::TextEdit::singleline(designation).hint_text(tr("fits the face, e.g. M8")));
+ crate::scenario::publish_handle("dialog:thread_size", response.rect.center());
+ if response.changed() {
+ *suggested = None;
+ }
+ let enter = response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
+ ui.end_row();
+ (enter, reset)
+}
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 1d8738b762..a5e76ed5ce 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -36,6 +36,7 @@ pub mod dialogs_save_mesh;
pub mod dialogs_sheet;
pub mod dialogs_surface;
pub mod dialogs_sweep;
+mod dialogs_thread;
pub mod dialogs_view_dxf;
pub mod dim_view;
#[cfg(test)]
diff --git a/crates/ui-egui/src/preselect_tests.rs b/crates/ui-egui/src/preselect_tests.rs
index f9433aecd7..7df2a87927 100644
--- a/crates/ui-egui/src/preselect_tests.rs
+++ b/crates/ui-egui/src/preselect_tests.rs
@@ -905,6 +905,235 @@ fn variable_fillet_mid_radii_round_trip() {
assert_eq!(p["params"]["mid"], json!([]), "{p}");
}
+/// Use an actual mesh point, as a viewport pick does; analytic cylinder points need not lie
+/// on the display mesh's facets.
+fn thread_face(app: &SolveApp, body: &str) -> Sel {
+ let state = app.session.world_state();
+ let body_state = state.body(body).unwrap();
+ let index = solidcraft_engine::doc::naming::face_spots(body_state)
+ .into_iter()
+ .enumerate()
+ .find_map(|(index, spot)| {
+ spot.filter(|spot| matches!(spot.surface, Some(solidcraft_engine::kernel::FaceSurface::Cylinder { .. }))).map(|_| index)
+ })
+ .unwrap();
+ let mesh = body_state.mesh();
+ let point = mesh
+ .triangles
+ .iter()
+ .zip(&mesh.tri_face)
+ .find_map(|(triangle, face)| {
+ if *face as usize != index {
+ return None;
+ }
+ mesh.tri(triangle).map(|[a, b, c]| (a + b + c) / 3.0)
+ })
+ .unwrap();
+ Sel::Face { body: body.into(), index, point }
+}
+
+#[test]
+fn thread_size_suggestion_matches_the_feature_for_shafts_and_holes() {
+ for (diameter, internal, expected) in [(8.0, false, "M8"), (20.0, false, "M20"), (5.0, true, "M6")] {
+ let mut app = app_with(json!([]));
+ if internal {
+ app.run("solid.box", json!({"corner":[-10,-10,0],"length":20,"width":20,"height":10})).unwrap();
+ }
+ app.run("solid.cylinder", json!({"radius":diameter / 2.0,"height":10,"body_name":"Cylinder"})).unwrap();
+ if internal {
+ app.run("solid.combine", json!({"target":"Body1","tools":["Cylinder"],"operation":"cut"})).unwrap();
+ }
+ let pick = thread_face(&app, if internal { "Body1" } else { "Cylinder" });
+ let saved = app.session.doc.to_json();
+ let d = start(&mut app, vec![pick], "solid.thread");
+ assert!(matches!(&d.kind, Kind::Thread { designation, .. } if designation == expected), "{:?}", d.kind);
+ assert_eq!(app.session.doc.to_json(), saved, "suggesting a size is read-only");
+ let (command, params) = apply_commands(&app, &d).unwrap().remove(0);
+ assert!(params.get("designation").is_none(), "an automatic size stays automatic");
+ let result = app.session.execute(&command, &params).unwrap();
+ assert_eq!(result["thread"]["designation"], expected);
+ assert_eq!(result["thread"]["internal"], internal);
+ }
+}
+
+#[test]
+fn thread_size_suggestion_follows_picks_without_overwriting_manual_sizes() {
+ let mut app = app_with(json!([
+ {"command":"solid.cylinder","params":{"radius":4,"height":10}},
+ {"command":"solid.cylinder","params":{"base":[30,0,0],"radius":10,"height":10}},
+ {"command":"solid.cylinder","params":{"base":[200,0,0],"radius":50,"height":10}}
+ ]));
+ let small = thread_face(&app, "Body1");
+ let large = thread_face(&app, "Body2");
+ let unsupported = thread_face(&app, "Body3");
+ let planar = crate::dialogs::face_sel(&app.session, Vec3::new(0.0, 0.0, 10.0)).unwrap();
+ let mut d = start(&mut app, vec![], "solid.thread");
+ for (pick, expected) in [
+ (small.clone(), "M8"),
+ (large.clone(), "M20"),
+ (large.clone(), "M20"),
+ (small.clone(), "M8"),
+ (unsupported, ""),
+ (small.clone(), "M8"),
+ (planar, ""),
+ ] {
+ d.pick(&app.session, pick);
+ assert!(matches!(&d.kind, Kind::Thread { designation, .. } if designation == expected), "{:?}", d.kind);
+ }
+ d.take_box(&app.session, vec![], false);
+ assert!(matches!(&d.kind, Kind::Thread { designation, .. } if designation.is_empty()));
+ d.take_box(&app.session, vec![small], false);
+ assert!(matches!(&d.kind, Kind::Thread { designation, .. } if designation == "M8"));
+ if let Kind::Thread { designation, .. } = &mut d.kind {
+ *designation = "M8x1".into();
+ }
+ d.pick(&app.session, large);
+ assert!(matches!(&d.kind, Kind::Thread { designation, .. } if designation == "M8x1"));
+ assert_eq!(apply_commands(&app, &d).unwrap()[0].1["designation"], "M8x1");
+}
+
+#[test]
+fn thread_size_suggestion_reopens_without_changing_saved_thread_parameters() {
+ for designation in [None, Some("M8"), Some("M8x1")] {
+ let mut h = crate::scenario::Harness::new();
+ h.app.run("solid.cylinder", json!({"radius":4,"height":10})).unwrap();
+ let Sel::Face { point, .. } = thread_face(&h.app, "Body1") else { panic!("a face") };
+ let mut params = json!({"face":point});
+ if let Some(size) = designation {
+ params["designation"] = json!(size);
+ }
+ let id = h.app.run("solid.thread", params).unwrap()["feature"].as_u64().unwrap();
+ let before = h.app.session.doc.feature(id).unwrap().kind.clone();
+ h.app.edit_feature(id);
+ h.frames(2);
+ let d = h.app.dialog.as_ref().unwrap();
+ assert!(matches!(&d.kind, Kind::Thread { designation: size, .. } if size == designation.unwrap_or("M8")), "{d:?}");
+ let (command, params) = apply_commands(&h.app, d).unwrap().remove(0);
+ h.app.session.execute(&command, &params).unwrap();
+ assert_eq!(h.app.session.doc.feature(id).unwrap().kind, before);
+ }
+}
+
+#[test]
+fn thread_size_suggestion_can_be_cleared_and_edited_in_the_dialog() {
+ let mut h = crate::scenario::Harness::new();
+ h.app.run("solid.cylinder", json!({"radius":4,"height":10})).unwrap();
+ let pick = thread_face(&h.app, "Body1");
+ h.app.session.selection = vec![pick.clone()];
+ h.step(&json!({"start":"solid.thread"})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:clear:Cylindrical face"}})).unwrap();
+ assert!(matches!(&h.app.dialog.as_ref().unwrap().kind, Kind::Thread { designation, .. } if designation.is_empty()));
+ h.app.dialog.as_mut().unwrap().pick(&h.app.session, pick.clone());
+ h.frames(2);
+ h.step(&json!({"click":{"handle":"dialog:thread_size"}})).unwrap();
+ h.step(&json!({"key":"A","cmd":true})).unwrap();
+ // Even deliberately typing the same size turns it into an explicit override.
+ h.step(&json!({"text":"M8"})).unwrap();
+ let d = h.app.dialog.as_ref().unwrap();
+ assert_eq!(apply_commands(&h.app, d).unwrap()[0].1["designation"], "M8");
+ h.step(&json!({"click":{"handle":"dialog:clear:Cylindrical face"}})).unwrap();
+ h.app.dialog.as_mut().unwrap().pick(&h.app.session, pick);
+ h.frames(2);
+ assert_eq!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["designation"], "M8");
+}
+
+#[test]
+fn thread_choices_apply_a_fine_pitch_and_partial_modelled_thread() {
+ let mut h = crate::scenario::Harness::new();
+ h.app.run("solid.cylinder", json!({"radius":4,"height":10})).unwrap();
+ h.app.session.selection = vec![thread_face(&h.app, "Body1")];
+ h.step(&json!({"start":"solid.thread"})).unwrap();
+ let saved = h.app.session.doc.to_json();
+ for handle in ["dialog:Pitch", "dialog:Pitch:1 mm", "dialog:Full Length", "dialog:Length"] {
+ h.step(&json!({"click":{"handle":handle}})).unwrap();
+ }
+ h.step(&json!({"key":"A","cmd":true})).unwrap();
+ h.step(&json!({"text":"4 mm"})).unwrap();
+ h.step(&json!({"click":{"handle":"dialog:Modeled"}})).unwrap();
+ let (command, params) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
+ assert_eq!(params["designation"], "M8x1");
+ assert_eq!(params["length"], "4 mm");
+ assert_eq!(params["modeled"], true);
+ assert_eq!(h.app.session.doc.to_json(), saved, "changing options only previews");
+ let before = h.app.session.world_state().body("Body1").unwrap().mesh().measure().volume;
+ let result = h.app.session.execute(&command, &params).unwrap();
+ let state = h.app.session.world_state();
+ let after = state.body("Body1").unwrap().mesh().measure().volume;
+ assert!(before - after > 1.0, "the selected fine pitch must cut the shaft");
+ let id = result["feature"].as_u64().unwrap();
+ let kind = &h.app.session.doc.feature(id).unwrap().kind;
+ assert!(matches!(kind, solidcraft_engine::doc::FeatureKind::Thread { designation: Some(d), length: Some(l), modeled: true, .. }
+ if d == "M8x1" && l == "4 mm"));
+}
+
+#[test]
+fn thread_choices_reset_to_the_face_and_can_freeze_the_same_size() {
+ let mut h = crate::scenario::Harness::new();
+ h.app.run("solid.cylinder", json!({"radius":4,"height":10})).unwrap();
+ h.app.session.selection = vec![thread_face(&h.app, "Body1")];
+ h.step(&json!({"start":"solid.thread"})).unwrap();
+ for handle in ["dialog:Size", "dialog:Size:6 mm", "dialog:Pitch", "dialog:Pitch:0.75 mm"] {
+ h.step(&json!({"click":{"handle":handle}})).unwrap();
+ }
+ let d = h.app.dialog.as_ref().unwrap();
+ assert_eq!(apply_commands(&h.app, d).unwrap()[0].1["designation"], "M6x0.75");
+ h.step(&json!({"click":{"handle":"dialog:Automatic size"}})).unwrap();
+ h.frames(2);
+ let d = h.app.dialog.as_ref().unwrap();
+ assert!(matches!(&d.kind, Kind::Thread { designation, .. } if designation == "M8"));
+ assert!(apply_commands(&h.app, d).unwrap()[0].1.get("designation").is_none());
+ h.step(&json!({"click":{"handle":"dialog:Automatic size"}})).unwrap();
+ assert_eq!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["designation"], "M8");
+}
+
+#[test]
+fn thread_choices_preserve_custom_saved_pairs_and_offer_large_fine_pitches() {
+ for (diameter, designation) in [(7.3, "M7.3x0.6"), (56.0, "M56")] {
+ let mut h = crate::scenario::Harness::new();
+ h.app.run("solid.cylinder", json!({"radius":diameter / 2.0,"height":10})).unwrap();
+ let Sel::Face { point, .. } = thread_face(&h.app, "Body1") else { panic!("a face") };
+ let id = h.app.run("solid.thread", json!({"face":point,"designation":designation})).unwrap()["feature"].as_u64().unwrap();
+ h.app.edit_feature(id);
+ h.frames(2);
+ assert!(h.widget(&format!("{diameter} mm")).is_some());
+ assert!(h.widget(if diameter == 56.0 { "5.5 mm" } else { "0.6 mm" }).is_some());
+ let (_, params) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
+ assert_eq!(params["params"]["designation"], designation);
+ if diameter == 56.0 {
+ for handle in ["dialog:Pitch", "dialog:Pitch:2 mm"] {
+ h.step(&json!({"click":{"handle":handle}})).unwrap();
+ }
+ let (command, params) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
+ assert_eq!(params["params"]["designation"], "M56x2");
+ h.app.session.execute(&command, &params).unwrap();
+ let mut reopened = solidcraft_engine::doc::Document::from_json(&h.app.session.doc.to_json()).unwrap();
+ // This test submits the edit command directly; finish the editor's rollback
+ // before checking the complete saved design.
+ reopened.marker = None;
+ let session = Session::new(reopened);
+ assert_eq!(session.world_state().threads[0].designation, "M56x2");
+ }
+ }
+}
+
+#[test]
+fn thread_choices_can_start_without_a_face_and_recover_from_invalid_text() {
+ let mut h = crate::scenario::Harness::new();
+ h.step(&json!({"start":"solid.thread"})).unwrap();
+ for handle in ["dialog:Size", "dialog:Size:8 mm", "dialog:thread_size"] {
+ h.step(&json!({"click":{"handle":handle}})).unwrap();
+ }
+ h.step(&json!({"key":"A","cmd":true})).unwrap();
+ h.step(&json!({"text":"Munknown"})).unwrap();
+ h.frames(2);
+ assert!(matches!(&h.app.dialog.as_ref().unwrap().kind, Kind::Thread { designation, .. } if designation == "Munknown"));
+ for handle in ["dialog:Size", "dialog:Size:8 mm"] {
+ h.step(&json!({"click":{"handle":handle}})).unwrap();
+ }
+ assert!(matches!(&h.app.dialog.as_ref().unwrap().kind, Kind::Thread { designation, .. } if designation == "M8x1.25"));
+ assert!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).is_err(), "a face is still required");
+}
+
#[test]
fn newer_options_reach_their_commands() {
let mut app = boxed();