Files
solidcraft/crates/ui-egui/src/dialogs_thread.rs
T
JIJINBEIandClaude Opus 5.5 16f3b939b3 Update egui/eframe to 0.37 (#9933)
* Update egui/eframe to 0.37 (WIP)

egui, eframe and egui-wgpu 0.36 -> 0.37. SolidCraft's egui-wgpu patch is
rebased onto 0.37.0; the vendored accesskit_macos is dropped (0.27.2 has
the #7535 fix).

Not finished: 36 solidcraft-ui-egui lib tests fail, and the full lib run
crashes with SIGSEGV when tests run in parallel.

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

* Tests: clear texture deltas that egui 0.37 refuses to drop

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

* Drop non-finite pointer input before egui; keep test time monotonic

egui 0.37 debug-asserts on NaN wheel deltas, on time moving backwards in the
pointer history, and on add_space inside a Grid.

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

* Hold a click that follows typing in the same frame until the next frame

egui 0.37 drops a field's focus on a click elsewhere when the field first
reads its style, before it reads the frame's typing, so text typed in the
frame of a click was lost.

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

* Name a document tab's close button "Close tab"

egui 0.37 names an unnamed widget after its tooltip, so the tab's × became a
second control named Close beside a dialog's. The space mouse guard test now
clicks where each button was: by name it found nothing behind the guard.

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

* Turn on egui's default_fonts: 0.37 no longer does

The built-in Hack is the UI's symbol fallback (#2955). The app got it through
eframe, but solidcraft-ui-egui on its own (its tests) did not.

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

* Text menu: act on the selection the menu click took the focus from

egui 0.37 drops a field's focus on a click elsewhere before the field draws,
and an unfocused field loses its selection, so Copy, Cut and Paste from the
right-click menu saw no selection.

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

* Placement field: keep its native height under egui 0.37's interact floor

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

* Tests: pin the theme's 2/3 point radii; measure Japanese ribbon labels with a Japanese face

egui 0.37 rounds widgets 4 points by default, which the theme deliberately
does not follow. The ribbon test measured Japanese with missing glyphs, whose
width changed in 0.37; with BIZ UDPGothic, 駆動 wraps after its particle like
変換 does.

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

* Tests: click the render inspector's Perspective checkbox by position

egui 0.37 orders the accessibility tree differently, so the name found the
stage's Perspective segment first.

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

* Translate "Close tab" for the complete catalogs

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

* Point the focus workarounds at emilk/egui#8763

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

* Cargo.lock: update only what egui 0.37 needs

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

* Web: Id::new -> Id::unique for the wasm-only windows

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

* Command search: keep its hint centred under egui 0.37's interact floor

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

* egui 0.37 renames in code main added since the branch

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

* egui 0.37 renames in code main added since the last rebase

Id::new to Id::unique, ui.id() to ui.scope_id(), WidgetType to Role, the
wheel events' source, and the button stroke read from the widget visuals.

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

* Review: disclosures report expanded, late screenshots drained, chat width reset on both sides

A disclosure's node says whether it is open as expanded, as egui's own
collapsing header does. The screenshot channel is drained every frame, so a
shot whose request was cancelled is dropped. Resetting the chat panel's width
forgets both sides' state, as before 0.37, and the request stays with its
window when tabs switch. Tests main added since the last rebase clear their
texture deltas.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 10:31:50 +00:00

1241 lines
56 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The thread dialog: form, size, hand, starts, extent, runouts, tip and the modelled option of
//! `solid.thread`. Choices only build the command's parameters: the command checks the geometry
//! and its error text is what the dialog shows. Browsing choices does not edit the model or
//! freeze an automatic feature. Sizes, designations and the face's size come from the document's
//! thread forms ([`ThreadForm`]).
use serde_json::{Value, json};
use solidcraft_engine::doc::thread_forms::{SteepFlank, ThreadForm, ThreadHand, ThreadTip};
use solidcraft_engine::doc::{
Document, Expr, FeatureKind, TappedThreadFamily, ThreadLimit, ThreadRunout, metric_thread_sizes, parse_metric_thread, parse_tapped_thread,
tapped_thread_sizes,
};
use solidcraft_engine::{Sel, Session};
use crate::dialogs::{Dialog, Kind, combo, edge_sel, face_sel, form_row, object_point, plane_sel, put, set_object_accepting};
use crate::i18n::tr;
use crate::selection::{Accept, EDGES, FACES, PLANES, SelInput};
use crate::ui_kit::{choice_row, expr_row, hint_row, text_row};
/// Common metric pitch presets besides the coarse one, not an exhaustive catalogue of standard
/// diameter/pitch pairs; the current pitch is included separately, custom pairs remain editable.
const METRIC_PITCHES: &[f64] = &[0.2, 0.25, 0.35, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0, 4.0];
/// Generated metric designations omit only the shared catalogue's coarse pitch.
/// Authored designation text is never rewritten just by displaying a dialog.
pub(crate) fn designation(diameter: f64, pitch: f64) -> String {
let coarse = metric_thread_sizes().iter().any(|(d, p)| (d - diameter).abs() < 1e-9 && (p - pitch).abs() < 1e-9);
if coarse { format!("M{diameter}") } else { format!("M{diameter}x{pitch}") }
}
/// Unsaved numeric inputs for a custom metric designation. The document still stores only
/// the existing designation; an invalid draft must not apply its last valid value.
#[derive(Clone, Debug, PartialEq)]
pub struct HoleThreadDraft {
source: String,
diameter: String,
pitch: String,
pub(crate) error: Option<String>,
}
impl HoleThreadDraft {
fn new(source: &str) -> Self {
let (diameter, pitch) = match parse_metric_thread(source) {
Some((d, p)) => (format!("{d} mm"), format!("{p} mm")),
None => (String::new(), String::new()),
};
Self { source: source.into(), diameter, pitch, error: None }
}
fn update(&mut self, doc: &Document, authored: &mut String) {
let candidate = || -> Result<String, String> {
let d = doc.eval(&self.diameter, solidcraft_engine::doc::expr::Kind::Length).map_err(|e| format!("nominal diameter: {e}"))?;
let p = doc.eval(&self.pitch, solidcraft_engine::doc::expr::Kind::Length).map_err(|e| format!("pitch: {e}"))?;
let text = designation(d, p);
parse_metric_thread(&text).ok_or("use a positive nominal diameter and a pitch smaller than it")?;
Ok(text)
};
match candidate() {
Ok(text) => {
*authored = text;
self.source = authored.clone();
self.error = None;
}
Err(error) => self.error = Some(error),
}
}
}
/// Tapped holes use a shared, finite catalogue; the engine derives the physical drill.
/// Custom remains a dialog mode even when its current values match a catalogue size.
pub(crate) fn hole_rows(
ui: &mut egui::Ui,
doc: &Document,
designation: &mut String,
custom: &mut Option<HoleThreadDraft>,
drill: &mut Option<String>,
) -> bool {
let before = designation.clone();
let designation_id = ui.make_persistent_id("hole_thread_designation");
let families = [
TappedThreadFamily::Metric,
TappedThreadFamily::Unc,
TappedThreadFamily::Unf,
TappedThreadFamily::G,
TappedThreadFamily::Rp,
TappedThreadFamily::Rc,
TappedThreadFamily::Npt,
];
let family = parse_tapped_thread(designation).map(|s| s.family).unwrap_or(TappedThreadFamily::Metric);
let mut profile = families.iter().position(|f| *f == family).unwrap_or(0);
let before_profile = profile;
form_row(ui, "Profile", |ui| combo(ui, "hole_thread_profile", &["ISO metric", "UNC", "UNF", "G / BSPP", "Rp", "Rc", "NPT"], &mut profile));
let family = families.get(profile).copied().unwrap_or(TappedThreadFamily::Metric);
let sizes = tapped_thread_sizes(family);
if family != TappedThreadFamily::Metric {
*custom = None;
}
if profile != before_profile
&& let Some(size) = sizes.first()
{
*designation = size.designation.clone();
*custom = None;
}
let current = parse_tapped_thread(designation);
let catalogue = current.as_ref().and_then(|s| sizes.iter().position(|p| p.designation == s.designation));
if family == TappedThreadFamily::Metric
&& (custom.as_ref().is_some_and(|draft| draft.source != *designation) || (custom.is_none() && catalogue.is_none()))
{
*custom = Some(HoleThreadDraft::new(designation));
}
form_row(ui, "Size", |ui| {
let mut selected = if custom.is_some() { sizes.len() } else { catalogue.unwrap_or(sizes.len()) };
let before = selected;
let mut labels: Vec<String> = sizes.iter().map(|s| s.designation.clone()).collect();
if family == TappedThreadFamily::Metric {
labels.push("Custom".to_string());
}
let labels: Vec<&str> = labels.iter().map(String::as_str).collect();
let catalogue_id = match family {
TappedThreadFamily::Metric => "hole_thread_catalogue_metric",
TappedThreadFamily::Unc => "hole_thread_catalogue_unc",
TappedThreadFamily::Unf => "hole_thread_catalogue_unf",
TappedThreadFamily::G => "hole_thread_catalogue_g",
TappedThreadFamily::Rp => "hole_thread_catalogue_rp",
TappedThreadFamily::Rc => "hole_thread_catalogue_rc",
TappedThreadFamily::Npt => "hole_thread_catalogue_npt",
};
combo(ui, catalogue_id, &labels, &mut selected);
if selected != before {
if let Some(size) = sizes.get(selected) {
*designation = size.designation.clone();
*custom = None;
} else {
*custom = Some(HoleThreadDraft::new(designation));
}
}
});
if matches!(family, TappedThreadFamily::G | TappedThreadFamily::Rp | TappedThreadFamily::Rc | TappedThreadFamily::Npt) {
form_row(ui, "Thread diameter", |ui| {
if let Some(size) = parse_tapped_thread(designation) {
ui.label(format!("{:.3} mm, {}°", size.major_diameter, size.profile_degrees()));
}
});
form_row(ui, "Pitch", |ui| {
if let Some(size) = parse_tapped_thread(designation) {
ui.label(format!("{:.4} mm ({} TPI)", size.pitch, (25.4 / size.pitch).round()));
}
});
}
let mut enter = false;
if let Some(draft) = custom {
let (diameter_enter, diameter_changed) = text_row(ui, "Nominal diameter", &mut draft.diameter, "");
let (pitch_enter, pitch_changed) = text_row(ui, "Pitch", &mut draft.pitch, "");
if diameter_changed || pitch_changed {
draft.update(doc, designation);
}
enter |= diameter_enter || pitch_enter;
}
let response = form_row(ui, "Designation", |ui| crate::ui_kit::cell_editor(ui, designation_id, designation, "M5, M5x0.5, 1/4-20 UNC", false));
if response.changed() && custom.is_some() {
*custom = Some(HoleThreadDraft::new(designation));
}
// The drill: the tap maker's for the size, or one the user types, from the thread's minor
// diameter to 5% over the tap maker's. A new size goes back to its own drill.
if *designation != before {
*drill = None;
}
let mut drill_enter = false;
form_row(ui, "Tap drill diameter", |ui| {
match parse_tapped_thread(designation).filter(|_| custom.as_ref().is_none_or(|draft| draft.error.is_none())) {
Some(size) => {
let default = format!("{} mm", size.tap_drill);
let (lo, hi) = size.drill_range();
let mm = |v: f64| format!("{:.3}", v);
let args = [("drill", mm(size.tap_drill)), ("minor", mm(size.minor_diameter())), ("low", mm(lo)), ("high", mm(hi))];
let args: Vec<(&str, &str)> = args.iter().map(|(k, v)| (*k, v.as_str())).collect();
let id = match (size.taper_drill().is_some(), size.drill_is_tabulated()) {
(true, _) => "thread.drill_range_taper",
(false, true) => "thread.drill_range",
(false, false) => "thread.drill_range_custom",
};
let tip = crate::i18n::format(id, &args);
let mut text = drill.clone().unwrap_or_else(|| default.clone());
let (submitted, changed) = crate::ui_kit::text_field_tip(ui, &mut text, &default, &tip);
if changed {
*drill = (text.trim() != default && !text.trim().is_empty()).then_some(text);
}
drill_enter = submitted;
}
None => {
ui.label(tr("thread.select_size"));
}
}
});
enter || drill_enter || (response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)))
}
/// The forms offered. The square thread is left out: no standard defines it, and the command
/// refuses it ([`ThreadForm::refused`]).
const FORMS: &[(&str, ThreadForm)] = &[
("ISO metric", ThreadForm::Metric),
("Trapezoidal (ISO 2904)", ThreadForm::Trapezoidal),
("Acme (ASME B1.5)", ThreadForm::Acme),
("Buttress (DIN 513)", ThreadForm::Buttress),
("Buttress (ASME B1.9)", ThreadForm::ButtressAsme),
("thread.form_bspp", ThreadForm::Bspp),
("thread.form_rp", ThreadForm::Rp),
("thread.form_bspt", ThreadForm::Bspt),
("thread.form_npt", ThreadForm::Npt),
];
const HANDS: &[(&str, ThreadHand)] = &[("Right", ThreadHand::Right), ("Left", ThreadHand::Left), ("Both", ThreadHand::Both)];
/// A tapped hole's and a pipe thread's hands: one groove, so never both.
const HOLE_HANDS: &[(&str, ThreadHand)] = &[("Right", ThreadHand::Right), ("Left", ThreadHand::Left)];
const STARTS: &[(&str, u32)] = &[("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5), ("6", 6), ("7", 7), ("8", 8)];
const FULL: usize = 0;
const LENGTH: usize = 1;
const UP_TO_EXTENT: usize = 2;
const EXTENTS: &[(&str, &str)] = &[("Full", "full"), ("Length", "length"), ("Up to", "up_to")];
/// The thread's start, its free end: run off it plain, or chamfered (ISO 4753).
const STARTS_AT: &[&str] = &["None", "Chamfer"];
/// The thread's inner end: a square stop (the groove ends in its own profile) or a fade
/// (ISO 3508's runout).
const ENDS_AT: &[&str] = &["thread.end_square", "ui.fade"];
const FLANKS: &[(&str, SteepFlank)] = &[("End", SteepFlank::End), ("Start", SteepFlank::Start)];
/// The pick of the end the thread is measured from (`from`).
const START_END: &str = "Start end (optional)";
/// The face or plane an Up To extent runs to (`up_to`).
const UP_TO: &str = "Up to";
const UP_TO_ACCEPT: Accept = FACES | PLANES;
/// The selection inputs of a new thread dialog.
pub(crate) fn inputs() -> Vec<SelInput> {
vec![SelInput::new("Cylindrical face", FACES, false)]
}
/// The inner end: square or a fade, the fade's typed length (empty: ISO 3508's runout, the
/// standard 2.5 P unless the thread was saved with the short 1.25 P).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Ease {
pub fade: bool,
pub length: String,
pub short: bool,
}
impl Ease {
pub(crate) fn of(r: &Option<ThreadRunout>) -> Ease {
match r {
None => Ease::default(),
Some(ThreadRunout::Standard) => Ease { fade: true, ..Ease::default() },
Some(ThreadRunout::Short) => Ease { fade: true, short: true, ..Ease::default() },
Some(ThreadRunout::Length { length }) => Ease { fade: true, length: expr(length), short: false },
}
}
/// The command's `ease_out`, none for a square end.
pub(crate) fn param(&self) -> Option<Value> {
let typed = self.length.trim();
self.fade.then(|| match (typed.is_empty(), self.short) {
(false, _) => json!(typed),
(true, true) => json!("short"),
(true, false) => json!("standard"),
})
}
}
fn expr(e: &Expr) -> String {
e.to_string()
}
/// The thread options beyond the size and length.
#[derive(Clone, Debug, PartialEq)]
pub struct Options {
pub form: ThreadForm,
pub hand: ThreadHand,
pub starts: u32,
/// An index into the extents (full, length, up to).
pub extent: usize,
pub ease_out: Ease,
pub tip: ThreadTip,
pub chamfer_angle: String,
pub chamfer_depth: String,
pub steep_flank: SteepFlank,
}
impl Default for Options {
fn default() -> Options {
Options {
form: ThreadForm::Metric,
hand: ThreadHand::default(),
starts: 1,
extent: FULL,
ease_out: Ease::default(),
tip: ThreadTip::default(),
chamfer_angle: String::new(),
chamfer_depth: String::new(),
steep_flank: SteepFlank::default(),
}
}
}
impl Options {
/// Does the thread start at one end of the face (a length or an Up To extent, a runout or a
/// tip)? Then the end to start from can be picked.
pub fn starts_at_an_end(&self) -> bool {
self.extent != FULL || self.ease_out.fade || self.tip != ThreadTip::None
}
}
fn is_buttress(form: ThreadForm) -> bool {
matches!(form, ThreadForm::Buttress | ThreadForm::ButtressAsme)
}
/// Sizes in inches are listed by designation, and their pitch is part of it (threads per inch):
/// the inch forms and the pipe threads, whose nominal sizes are pipe sizes.
fn inch(form: ThreadForm) -> bool {
matches!(form, ThreadForm::Acme | ThreadForm::ButtressAsme) || is_pipe(form)
}
/// A pipe thread: one start, turning one way.
fn is_pipe(form: ThreadForm) -> bool {
!form.pipe_sizes().is_empty()
}
fn same(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-9
}
/// The diameter and pitch (mm) a designation of this form names.
fn parse(form: ThreadForm, designation: &str) -> Option<(f64, f64)> {
form.parse(designation, 1).ok().map(|t| (t.major, t.pitch))
}
fn designation_of(form: ThreadForm, d: f64, p: f64) -> String {
form.format(d, p, p)
}
/// The pitches the Pitch choice offers for diameter `d` (largest first), with the current one.
fn pitches(form: ThreadForm, d: f64, current: f64) -> Vec<f64> {
let standard = form.sizes().into_iter().find(|(n, _)| same(*n, d)).map(|(_, p)| p);
let mut pitches = Vec::new();
if form == ThreadForm::Metric {
pitches.extend(METRIC_PITCHES.iter().copied().filter(|p| *p < d && *p <= standard.unwrap_or(d)));
}
pitches.extend(standard);
pitches.push(current);
pitches.sort_by(|a, b| b.total_cmp(a));
pitches.dedup_by(|a, b| same(*a, *b));
pitches
}
/// A typical designation of the form, for the field's hint.
fn example(form: ThreadForm) -> String {
let sizes = form.sizes();
match sizes.iter().min_by(|a, b| (a.0 - 20.0).abs().total_cmp(&(b.0 - 20.0).abs())) {
Some((d, p)) => designation_of(form, *d, *p),
// ASME B1.9 has no size table: 2.5 in, 8 threads per inch.
None => designation_of(form, 2.5 * 25.4, 25.4 / 8.0),
}
}
/// A new form keeps a manual size's diameter when the form lists it (with the form's standard
/// pitch); any other size goes back to the size that fits the face. True when the size went
/// back to automatic.
fn change_form(designation: &mut String, suggested: &mut Option<String>, from: ThreadForm, to: ThreadForm) -> bool {
let automatic = designation.trim().is_empty() || suggested.as_deref() == Some(designation.as_str());
let kept = (!automatic)
.then(|| parse(from, designation))
.flatten()
.and_then(|(d, _)| to.sizes().into_iter().find(|(n, _)| same(*n, d)))
.map(|(d, p)| designation_of(to, d, p));
*suggested = None;
match kept {
Some(kept) => {
*designation = kept;
false
}
None => {
designation.clear();
true
}
}
}
/// A choice row over typed values.
/// The hole dialog's Hand row for a tapped hole, the same choice the thread dialog offers.
pub(crate) fn hole_hand_row(ui: &mut egui::Ui, hand: &mut ThreadHand) {
pick(ui, "Hand", "hole_hand", hand, HOLE_HANDS);
}
fn pick<T: Copy + PartialEq>(ui: &mut egui::Ui, label: &str, id: &str, value: &mut T, choices: &[(&str, T)]) {
let labels: Vec<&str> = choices.iter().map(|c| c.0).collect();
let mut index = choices.iter().position(|c| c.1 == *value).unwrap_or(0);
choice_row(ui, label, id, &mut index, &labels);
if let Some(c) = choices.get(index) {
*value = c.1;
}
}
/// The thread's rows. Returns (Enter pressed, automatic sizing requested). The picks are the
/// caller's: [`sync_inputs`] adds or removes them by the options.
pub(crate) fn rows(
ui: &mut egui::Ui,
designation: &mut String,
suggested: &mut Option<String>,
length: &mut String,
o: &mut Options,
modeled: &mut bool,
) -> (bool, bool) {
let mut enter = false;
let mut reset = false;
let mut form = o.form;
pick(ui, "Form", "thread_form", &mut form, FORMS);
if form != o.form {
reset |= change_form(designation, suggested, o.form, form);
o.form = form;
}
let f = o.form;
let before = designation.trim().is_empty() || suggested.as_deref() == Some(designation.as_str());
let mut automatic = before;
crate::ui_kit::section(ui, "thread_options", "Options", true, |ui| {
crate::ui_kit::checkbox_grid(ui, &mut [("Modeled", modeled)], 2);
ui.add_enabled_ui(!designation.trim().is_empty(), |ui| crate::ui_kit::checkbox_grid(ui, &mut [("Automatic size", &mut automatic)], 2));
});
reset |= automatic && !before;
if automatic != before {
*suggested = None;
if automatic {
designation.clear();
}
}
if !f.sizes().is_empty() {
size_rows(ui, f, designation, suggested);
}
let hint = crate::i18n::format("thread.fits_the_face", &[("example", &example(f))]);
let (submitted, changed) = text_row(ui, "Designation", designation, &hint);
enter |= submitted;
if let Some(at) = crate::scenario::handle_at("dialog:Designation") {
crate::scenario::publish_handle("dialog:thread_size", at);
}
if changed {
*suggested = None;
}
if is_pipe(f) {
// A pipe thread has one start and turns one way.
o.starts = 1;
if o.hand == ThreadHand::Both {
o.hand = ThreadHand::Right;
}
pick(ui, "Hand", "thread_hand", &mut o.hand, HOLE_HANDS);
} else {
pick(ui, "Hand", "thread_hand", &mut o.hand, HANDS);
pick(ui, "Starts", "thread_starts", &mut o.starts, STARTS);
}
if is_buttress(f) {
pick(ui, "Steep Flank", "thread_flank", &mut o.steep_flank, FLANKS);
}
let extents: Vec<&str> = EXTENTS.iter().map(|x| x.0).collect();
let extent = o.extent;
choice_row(ui, "Extent", "thread_extent", &mut o.extent, &extents);
if o.extent == LENGTH {
if extent != LENGTH && length.trim().is_empty() {
*length = "10 mm".into();
}
enter |= expr_row(ui, "Length", length);
}
crate::ui_kit::section(ui, "thread_ends", "Ends", true, |ui| {
// The start, a free end: plain or chamfered. A thread saved chamfered at both ends
// keeps that.
let mut chamfered = usize::from(o.tip != ThreadTip::None);
choice_row(ui, "Start", "thread_start", &mut chamfered, STARTS_AT);
o.tip = match (chamfered, o.tip) {
(0, _) => ThreadTip::None,
(_, ThreadTip::None) => ThreadTip::Start,
(_, kept) => kept,
};
if o.tip != ThreadTip::None {
enter |= hint_row(ui, "Chamfer Angle", &mut o.chamfer_angle, tr("ui.iso_4753"));
// ISO 4753's depth is for ISO metric threads; the other forms give theirs.
let depth = if f == ThreadForm::Metric { "ui.iso_4753" } else { "thread.chamfer_depth_needed" };
enter |= hint_row(ui, "Chamfer Depth", &mut o.chamfer_depth, tr(depth));
}
enter |= end_rows(ui, &mut o.ease_out);
});
(enter, reset)
}
/// The inner end of a modelled thread (a thread's, or a tapped hole's towards its bottom):
/// square, or a fade over its length.
pub(crate) fn end_rows(ui: &mut egui::Ui, ease: &mut Ease) -> bool {
let mut fade = usize::from(ease.fade);
choice_row(ui, "End", "thread_end", &mut fade, ENDS_AT);
ease.fade = fade == 1;
if !ease.fade {
return false;
}
let hint = if ease.short { tr("thread.fade_short") } else { tr("thread.fade_standard") };
hint_row(ui, "Fade Length", &mut ease.length, hint)
}
/// The Size choice of a form with a size table, and the Pitch choice of the metric ones (an
/// inch designation names its threads per inch).
fn size_rows(ui: &mut egui::Ui, f: ThreadForm, designation: &mut String, suggested: &mut Option<String>) {
let table = f.sizes();
let current = parse(f, designation);
// ISO 7-1 writes the internal taper thread Rc: a size picked for a hole the dialog sized Rc
// stays Rc.
let internal = f == ThreadForm::Bspt && ThreadForm::pipe_internal(designation);
let designation_of = |f: ThreadForm, d: f64, p: f64| {
let name = designation_of(f, d, p);
if internal { name.replacen("R ", "Rc ", 1) } else { name }
};
let mut diameters: Vec<f64> = table.iter().map(|(d, _)| *d).collect();
if let Some((d, _)) = current
&& !diameters.iter().any(|n| same(*n, d))
{
diameters.push(d);
diameters.sort_by(f64::total_cmp);
}
form_row(ui, "Size", |ui| {
let labels: Vec<String> = diameters
.iter()
.map(|d| match table.iter().find(|(n, _)| same(*n, *d)) {
Some((n, p)) if inch(f) => designation_of(f, *n, *p),
_ if inch(f) => designation.trim().to_string(),
_ => format!("{d} mm"),
})
.collect();
let mut selected = current.and_then(|(d, _)| diameters.iter().position(|n| same(*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 standard 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((_, p)) = table.iter().find(|(n, _)| same(*n, *d))
{
*designation = designation_of(f, *d, *p);
*suggested = None;
}
});
if inch(f) {
return;
}
let current = parse(f, designation);
form_row(ui, "Pitch", |ui| {
ui.add_enabled_ui(current.is_some(), |ui| {
let pitches = current.map(|(d, p)| pitches(f, d, p)).unwrap_or_default();
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| same(*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 = designation_of(f, d, *p);
*suggested = None;
}
});
});
}
/// Add the picks the options use, and take away the others: the end to start from (optional,
/// so it does not take the next click), and the Up To place (which does).
pub(crate) fn sync_inputs(inputs: &mut Vec<SelInput>, active: &mut usize, o: &Options) {
let was = *active;
set_object_accepting(inputs, active, START_END, EDGES, o.starts_at_an_end());
*active = was.min(inputs.len().saturating_sub(1));
set_object_accepting(inputs, active, UP_TO, UP_TO_ACCEPT, o.extent == UP_TO_EXTENT);
}
/// Put the options into the command's parameters. Defaults are left out, so a thread without
/// them means what it always did.
pub(crate) fn put_params(p: &mut Value, length: &str, o: &Options, inputs: &[SelInput]) {
if o.form != ThreadForm::Metric {
p["form"] = json!(o.form.name());
}
if o.hand != ThreadHand::default() {
p["hand"] = json!(o.hand);
}
if o.starts != 1 {
p["starts"] = json!(o.starts);
}
match o.extent {
LENGTH => {
p["extent"] = json!(EXTENTS[LENGTH].1);
put(p, &[("length", length)]);
}
UP_TO_EXTENT => {
p["extent"] = json!(EXTENTS[UP_TO_EXTENT].1);
if let Some(to) = up_to(inputs) {
p["up_to"] = to;
}
}
_ => {}
}
if let Some(from) = object_point(inputs, START_END) {
p["from"] = from;
}
if let Some(e) = o.ease_out.param() {
p["ease_out"] = e;
}
if o.tip != ThreadTip::None {
p["tip"] = json!(o.tip);
put(p, &[("chamfer_angle", o.chamfer_angle.as_str()), ("chamfer_depth", o.chamfer_depth.as_str())]);
}
if is_buttress(o.form) && o.steep_flank != SteepFlank::default() {
p["steep_flank"] = json!(o.steep_flank);
}
}
/// The picked Up To place: a plane's name, or a point on a face.
fn up_to(inputs: &[SelInput]) -> Option<Value> {
match inputs.iter().find(|i| i.label == UP_TO)?.items.first()? {
Sel::Plane { name } => Some(json!(name)),
_ => object_point(inputs, UP_TO),
}
}
/// The face's size in the dialog's form, for an automatic size.
pub(crate) fn suggested(s: &Session, picks: &[Sel], o: &Options) -> Option<String> {
picks.first().and_then(|sel| match sel {
Sel::Face { point, .. } => solidcraft_engine::doc::suggested_thread_in(&crate::open_meshing::session_world(s), *point, o.form).ok(),
_ => None,
})
}
/// A saved thread's dialog: every option as saved, with its picks.
pub(crate) fn reopen(d: &mut Dialog, s: &Session, kind: &FeatureKind) {
let FeatureKind::Thread {
face,
designation,
length,
modeled,
from,
up_to,
form,
hand,
starts,
ease_out,
tip,
chamfer_angle,
chamfer_depth,
steep_flank,
// Kept by the edit itself (`timeline.redefine`), not a dialog option.
old_auto_size: _,
} = kind
else {
return;
};
if *modeled {
d.extra.insert("modeled".into(), json!(true));
}
let options = Options {
form: *form,
hand: *hand,
starts: *starts,
extent: if length.is_some() {
LENGTH
} else if up_to.is_some() {
UP_TO_EXTENT
} else {
FULL
},
ease_out: Ease::of(ease_out),
tip: *tip,
chamfer_angle: chamfer_angle.as_ref().map(expr).unwrap_or_default(),
chamfer_depth: chamfer_depth.as_ref().map(expr).unwrap_or_default(),
steep_flank: *steep_flank,
};
if let Some(inp) = d.inputs.first_mut() {
inp.items = face_sel(s, face.0).into_iter().collect();
}
sync_inputs(&mut d.inputs, &mut d.active, &options);
// A place no pick finds again (the model changed) is still the place saved.
let place = |sel: Option<Sel>, p| sel.unwrap_or(Sel::Vertex { body: String::new(), point: p });
let set = |d: &mut Dialog, label: &str, sel: Sel| {
if let Some(inp) = d.inputs.iter_mut().find(|i| i.label == label) {
inp.items = vec![sel];
}
};
if let Some(from) = from {
set(d, START_END, place(edge_sel(s, from.0), from.0));
}
match up_to {
Some(ThreadLimit::Face(at)) => set(d, UP_TO, place(face_sel(s, at.0), at.0)),
Some(ThreadLimit::Plane(plane)) => {
if let Some(sel) = plane_sel(s, plane) {
set(d, UP_TO, sel);
}
}
None => {}
}
d.active = 0;
d.kind = Kind::Thread {
designation: designation.clone().unwrap_or_default(),
length: length.as_ref().map(expr).unwrap_or_default(),
suggested: None,
of: Vec::new(),
options,
};
}
#[cfg(test)]
#[path = "dialogs_thread_tests.rs"]
mod tests;
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod contribution_tests {
use super::*;
use crate::{
Services, SolveApp,
dialogs::{Dialog, Kind, apply_commands},
};
use serde_json::json;
use solidcore_record::Vec3;
use solidcraft_engine::{Sel, Session};
fn hole() -> (SolveApp, Dialog) {
let mut app = SolveApp::new(Session::default(), Services::default());
app.run("solid.box", json!({"length":20,"width":20,"height":10,"body_name":"Plate"})).unwrap();
app.session.selection = vec![Sel::Face { body: "Plate".into(), index: 5, point: Vec3::new(10.0, 10.0, 10.0) }];
let d = Dialog::for_command(&app, "solid.hole").unwrap();
(app, d)
}
fn custom_hole_widget() -> crate::scenario::Harness {
let (app, dialog) = hole();
let mut h = crate::scenario::Harness::new();
h.app = app;
h.app.dialog = Some(dialog);
h.frames(3);
h.step(&json!({"click":{"handle":"dialog:Hole Tap Type"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Hole Tap Type:Tapped"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Size"}})).unwrap();
let at = crate::scenario::handle_at("dialog:Size:M5").unwrap();
h.call("ui.scroll", json!({"x":at.x,"y":at.y,"delta":-2000}));
h.frames(20);
h.step(&json!({"widget":"Custom"})).unwrap();
h.frames(3);
h
}
fn replace_field(h: &mut crate::scenario::Harness, field: &str, value: &str) {
h.step(&json!({"click":{"handle":format!("dialog:{field}")}})).unwrap();
h.step(&json!({"key":"A","cmd":true})).unwrap();
h.step(&json!({"text":value})).unwrap();
h.frames(2);
}
#[test]
fn custom_tapped_size_keeps_its_choice_and_exposes_nominal_diameter() {
let h = custom_hole_widget();
assert!(h.widget("Custom").is_some(), "Custom must remain the selected size after the popup closes");
assert!(crate::scenario::handle_at("dialog:Nominal diameter").is_some(), "a custom tapped hole needs an editable nominal diameter");
let card = crate::scenario::rect_of("dialog:card").unwrap();
for label in ["Profile", "Size", "Nominal diameter", "Pitch", "Designation", "Tap drill diameter"] {
let row = crate::scenario::rect_of(&format!("dialog:row:{label}")).unwrap();
let control = crate::scenario::rect_of(&format!("dialog:control:{label}")).unwrap();
assert_eq!(row.height(), crate::theme::Tokens::get().control_height, "{label}");
assert!(card.contains_rect(row) && row.contains_rect(control), "{label}: {row:?} {control:?} outside {card:?}");
}
}
#[test]
fn custom_nominal_diameter_and_pitch_change_the_real_hole_and_reopen() {
let mut h = custom_hole_widget();
replace_field(&mut h, "Nominal diameter", "8.5 mm");
replace_field(&mut h, "Pitch", "1 mm");
let commands = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap();
assert_eq!(commands[0].1["thread"], "M8.5x1");
assert!(commands[0].1.get("diameter").is_none(), "the nominal size must reach the engine through the thread designation");
h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();
h.frames(3);
assert!(h.app.dialog.is_none());
let faces = h.app.run("model.faces", json!({"body":"Plate"})).unwrap();
assert!(
faces["faces"].as_array().unwrap().iter().any(|face| { face["cylinder"]["radius"].as_f64().is_some_and(|r| (r - 3.75).abs() < 1e-9) }),
"the physical tap drill must be 8.5 - 1 = 7.5 mm"
);
let saved = h.app.session.doc.to_json();
let reopened = Session::new(Document::from_json(&saved).unwrap());
let world = crate::open_meshing::session_world(&reopened);
assert_eq!(world.threads.len(), 1);
assert_eq!(world.threads[0].designation, "M8.5x1");
assert!((world.threads[0].pitch - 1.).abs() < 1e-9);
}
#[test]
fn an_invalid_custom_pitch_blocks_the_old_valid_size_and_cancel_keeps_the_model() {
let mut h = custom_hole_widget();
let before = h.app.session.doc.to_json();
let history = (h.app.session.undo.len(), h.app.session.redo.len());
replace_field(&mut h, "Pitch", "5 mm");
assert!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).is_err());
assert_eq!(crate::scenario::count_of("dialog:ok:enabled"), Some(0.0));
h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();
assert!(h.app.dialog.is_some(), "an invalid custom draft must keep the dialog open");
assert_eq!(h.app.session.doc.to_json(), before);
assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
h.step(&json!({"key":"Escape"})).unwrap();
assert!(h.app.dialog.is_none());
assert_eq!(h.app.session.doc.to_json(), before);
assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
}
/// A tapped hole offers what a thread does: Modeled, and then its inner end, square or a
/// fade, towards the bottom. OK cuts it; editing the hole brings them back.
#[test]
fn a_tapped_hole_is_modelled_with_the_threads_end() {
let (app, dialog) = hole();
let mut h = crate::scenario::Harness::new();
h.app = app;
h.app.dialog = Some(dialog);
h.frames(3);
for handle in ["dialog:Hole Tap Type", "dialog:Hole Tap Type:Tapped"] {
h.step(&json!({"click":{"handle":handle}})).unwrap();
}
h.frames(2);
assert!(crate::scenario::rect_of("dialog:row:End").is_none(), "a listed thread has no end to finish");
h.step(&json!({"click":{"handle":"dialog:Modeled"}})).unwrap();
h.frames(2);
for handle in ["dialog:End", "dialog:End:ui.fade"] {
h.step(&json!({"click":{"handle":handle}})).unwrap();
}
h.frames(2);
let (cmd, p) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
assert_eq!((&p["modeled"], &p["ease_out"]), (&json!(true), &json!("standard")), "{p}");
let id = h.app.run(&cmd, p.clone()).unwrap()["feature"].as_u64().unwrap();
h.app.dialog = None;
h.app.edit_feature(id);
h.frames(2);
let (_, again) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
let again = if again.get("params").is_some() { again["params"].clone() } else { again };
assert_eq!((&again["modeled"], &again["ease_out"]), (&json!(true), &json!("standard")), "{again}");
}
/// A tapped hole's drill: the tap maker's for the size (M8: 6.8 mm), or a typed one from the
/// thread's minor diameter to 5% over it; outside that the command names the range. A new
/// size takes its own drill again, and a saved hole drilled otherwise (an older design's
/// d - P) reopens with its drill.
#[test]
fn a_tapped_holes_drill_is_the_tap_makers_or_one_within_its_range() {
let (app, dialog) = hole();
let mut h = crate::scenario::Harness::new();
h.app = app;
h.app.dialog = Some(dialog);
h.frames(3);
for handle in ["dialog:Hole Tap Type", "dialog:Hole Tap Type:Tapped"] {
h.step(&json!({"click":{"handle":handle}})).unwrap();
}
let set = |h: &mut crate::scenario::Harness, field: &str, text: &str| {
h.step(&json!({"click":{"handle":format!("dialog:{field}")}})).unwrap();
h.step(&json!({"key":"A","cmd":true})).unwrap();
h.step(&json!({"text":text})).unwrap();
h.frames(2);
};
set(&mut h, "Designation", "M8");
let params = |h: &crate::scenario::Harness| apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0).1;
assert!(params(&h).get("diameter").is_none(), "the tap maker's drill is the command's own");
set(&mut h, "Tap drill diameter", "7 mm");
assert_eq!(params(&h)["diameter"], json!("7 mm"));
let (cmd, p) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
let id = h.app.run(&cmd, p.clone()).unwrap()["feature"].as_u64().unwrap();
set(&mut h, "Tap drill diameter", "7.5 mm");
let (cmd, p) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
let e = h.app.session.execute(&cmd, &p).unwrap_err().to_string();
assert!(e.contains("from 6.647 to 7.14 mm") && e.contains("too little of the thread"), "{e}");
set(&mut h, "Designation", "M10");
assert!(params(&h).get("diameter").is_none(), "a new size takes its own drill");
// An older design's M8 hole, drilled 6.75 mm (d - P), keeps that drill when edited.
let solidcraft_engine::doc::FeatureKind::Hole { diameter, .. } = &mut h.app.session.doc_mut().feature_mut(id).unwrap().kind else {
panic!("not Hole")
};
*diameter = "6.75 mm".into();
h.app.dialog = None;
h.app.edit_feature(id);
h.frames(2);
let (_, again) = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap().remove(0);
let again = if again.get("params").is_some() { again["params"].clone() } else { again };
assert_eq!(again["diameter"], json!("6.75 mm"), "{again}");
}
#[test]
fn manual_designation_keeps_keyboard_focus_when_custom_fields_appear() {
let (app, dialog) = hole();
let mut h = crate::scenario::Harness::new();
h.app = app;
h.app.dialog = Some(dialog);
h.frames(3);
h.step(&json!({"click":{"handle":"dialog:Hole Tap Type"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Hole Tap Type:Tapped"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Designation"}})).unwrap();
h.step(&json!({"key":"A","cmd":true})).unwrap();
for text in ["M", "8", "x", "1"] {
h.step(&json!({"text":text})).unwrap();
h.frames(2);
}
assert_eq!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["thread"], "M8x1");
assert!(crate::scenario::handle_at("dialog:Nominal diameter").is_some());
}
#[test]
fn custom_lengths_use_explicit_units_and_invalid_drafts_never_apply_stale_values() {
let (mut app, mut dialog) = hole();
app.run("document.units", json!({"units":"in"})).unwrap();
let Kind::Hole { opts, .. } = &mut dialog.kind else { panic!("not a hole") };
opts.tapped = true;
opts.all = true;
let mut draft = HoleThreadDraft::new(&opts.thread);
draft.diameter = "0.25 in".into();
draft.pitch = "0.05 in".into();
draft.update(&app.session.doc, &mut opts.thread);
assert!(draft.error.is_none());
let (d, p) = parse_metric_thread(&opts.thread).unwrap();
assert!((d - 6.35).abs() < 1e-9 && (p - 1.27).abs() < 1e-9);
opts.custom_thread = Some(draft);
let commands = apply_commands(&app, &dialog).unwrap();
app.run(&commands[0].0, commands[0].1.clone()).unwrap();
let Kind::Hole { opts, .. } = &mut dialog.kind else { panic!("not a hole") };
for invalid in ["", "0", "-1 mm", "unknown_size", "NaN"] {
let draft = opts.custom_thread.as_mut().unwrap();
draft.diameter = invalid.into();
draft.update(&app.session.doc, &mut opts.thread);
assert!(draft.error.is_some(), "{invalid}");
}
assert!(apply_commands(&app, &dialog).is_err());
}
#[test]
fn contribution_tapped_holes_derive_the_drill_from_the_catalogue() {
for (designation, expected) in [("M5", 4.2), ("M6x1", 5.0), ("M5x0.5", 4.5)] {
let (mut app, mut d) = hole();
if let Kind::Hole { diameter, opts, .. } = &mut d.kind {
*diameter = "17 mm".into();
opts.tapped = true;
opts.all = true;
opts.thread = designation.into();
}
assert!(d.primary().is_none(), "no independent diameter editor for a tapped hole");
let commands = apply_commands(&app, &d).unwrap();
let (id, p) = &commands[0];
assert!(p.get("diameter").is_none());
assert_eq!(p["thread"], designation);
let out = app.run(id, p.clone()).unwrap();
let f = app.session.doc.feature(out["feature"].as_u64().unwrap()).unwrap();
let solidcraft_engine::doc::FeatureKind::Hole { diameter, .. } = &f.kind else { panic!("not a Hole") };
let drill = app.session.doc.eval(diameter, solidcraft_engine::doc::expr::Kind::Length).unwrap();
assert!((drill - expected).abs() < 1e-9, "{designation}: {drill}");
}
}
#[test]
fn contribution_invalid_tapped_holes_are_refused_and_plain_holes_keep_diameter() {
let (app, mut d) = hole();
assert!(d.primary().is_some());
assert!(apply_commands(&app, &d).unwrap()[0].1.get("diameter").is_some());
for designation in ["", "M0", "M5x5", "M5xNaN", "not a thread"] {
if let Kind::Hole { opts, .. } = &mut d.kind {
opts.tapped = true;
opts.thread = designation.into();
}
assert!(apply_commands(&app, &d).is_err(), "{designation}");
}
}
#[test]
fn contribution_thread_catalogue_is_parseable_and_rendering_keeps_custom_designations() {
for (d, p) in metric_thread_sizes() {
assert_eq!(parse_metric_thread(&format!("M{d}")), Some((*d, *p)));
assert_eq!(parse_metric_thread(&format!("M{d}x{p}")), Some((*d, *p)));
}
let ctx = egui::Context::default();
for original in ["M5", "M5x0.5", "M33x1", "1/4-20 UNC", "#10-32 UNF", "invalid"] {
let mut designation = original.to_string();
let mut custom = None;
let doc = Document::default();
ctx.run_ui(Default::default(), |ui| {
egui::Grid::new("hole_catalogue").show(ui, |ui| {
hole_rows(ui, &doc, &mut designation, &mut custom, &mut None);
});
})
.textures_delta
.clear();
assert_eq!(designation, original);
}
}
#[test]
fn expanded_catalogue_profiles_select_unified_sizes_and_keep_metric_custom_mode() {
let mut h = custom_hole_widget();
h.step(&json!({"click":{"handle":"dialog:Profile"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Profile:UNC"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Size"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Size:1/4-20 UNC"}})).unwrap();
h.frames(3);
assert_eq!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["thread"], "1/4-20 UNC");
assert!(crate::scenario::handle_at("dialog:Nominal diameter").is_none());
assert!(h.widget("5.1054 mm").is_some());
h.step(&json!({"click":{"handle":"dialog:Profile"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Profile:UNF"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Size"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Size:#10-32 UNF"}})).unwrap();
h.frames(3);
assert_eq!(apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap()[0].1["thread"], "#10-32 UNF");
h.step(&json!({"click":{"handle":"dialog:Profile"}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Profile:ISO metric"}})).unwrap();
if let Some(Dialog { kind: Kind::Hole { opts, .. }, .. }) = h.app.dialog.as_mut() {
opts.thread = "M8x1".into();
}
h.frames(3);
assert!(h.widget("M8x1").is_some());
assert!(crate::scenario::handle_at("dialog:Nominal diameter").is_none());
// Choosing Custom is persistent even at a now-catalogued fine pitch.
if let Some(Dialog { kind: Kind::Hole { opts, .. }, .. }) = h.app.dialog.as_mut() {
opts.custom_thread = Some(HoleThreadDraft::new(&opts.thread));
}
h.frames(3);
assert!(h.widget("Custom").is_some());
assert!(crate::scenario::handle_at("dialog:Nominal diameter").is_some());
}
#[test]
fn expanded_catalogue_drills_real_cylinders_and_reopens_without_resizing() {
for (name, major, pitch, drill) in [
("1/4-20 UNC", 6.35, 1.27, 5.1054),
("#10-32 UNF", 4.826, 25.4 / 32.0, 4.0386),
("M8", 8.0, 1.25, 6.8),
("M8x1", 8.0, 1.0, 7.0),
("M8.5x1", 8.5, 1.0, 7.5),
] {
let (mut app, _) = hole();
let out = app.run("solid.hole", json!({"position":[10,10,10], "thread":name})).unwrap();
let id = out["feature"].as_u64().unwrap();
let saved = app.session.doc.to_json();
let reopened = Session::new(Document::from_json(&saved).unwrap());
let world = crate::open_meshing::session_world(&reopened);
let t = &world.threads[0];
assert_eq!(t.designation, name);
assert!((t.major_diameter - major).abs() < 1e-9 && (t.pitch - pitch).abs() < 1e-9);
let body = &world.bodies[0].body;
assert!(body.validity().is_empty());
let face = solidcraft_engine::kernel::cylinder_face_at(body, Vec3::new(10.0 + drill / 2.0, 10.0, 5.0)).unwrap();
assert!(face.internal && (2.0 * face.radius - drill).abs() < 1e-8);
let actual = body.mesh(&solidcraft_engine::kernel::MeshTolerance::chord(0.001)).unwrap().measure().volume;
let expected = 4000.0 - std::f64::consts::PI * (drill / 2.0).powi(2) * 10.0;
assert!((actual - expected).abs() < 0.5, "{name}: {actual} versus {expected}");
// A saved explicit drill remains authoritative, including a legacy metric bore.
let mut doc = Document::from_json(&saved).unwrap();
let solidcraft_engine::doc::FeatureKind::Hole { diameter, .. } = &mut doc.feature_mut(id).unwrap().kind else { panic!("not Hole") };
*diameter = format!("{} mm", drill + 0.05).as_str().into();
let reopened = Session::new(Document::from_json(&doc.to_json()).unwrap());
let world = crate::open_meshing::session_world(&reopened);
let face = solidcraft_engine::kernel::cylinder_face_at(&world.bodies[0].body, Vec3::new(10.0 + (drill + 0.05) / 2.0, 10.0, 5.0)).unwrap();
assert!((2.0 * face.radius - drill - 0.05).abs() < 1e-8);
}
}
#[test]
fn expanded_catalogue_rejects_external_taper_holes_and_nonmetric_thread_features() {
let (mut app, _) = hole();
let before = app.session.doc.to_json();
for name in ["R1/4", "1/4-20 UNF"] {
assert!(app.run("solid.hole", json!({"position":[10,10,10],"thread":name})).is_err());
assert_eq!(app.session.doc.to_json(), before);
}
app.run("solid.hole", json!({"position":[10,10,10],"thread":"M8"})).unwrap();
let before = app.session.doc.to_json();
for designation in ["1/4-20 UNC", "G 1/4", "Rp 1/4"] {
for modeled in [false, true] {
assert!(app.run("solid.thread", json!({"face":[13.4,10,5],"designation":designation,"modeled":modeled})).is_err());
assert_eq!(app.session.doc.to_json(), before);
}
}
assert_eq!(app.session.doc.to_json(), before);
let out = app.run("solid.thread", json!({"face":[13.4,10,5],"designation":"M8"})).unwrap();
let solidcraft_engine::doc::FeatureKind::Thread { designation, modeled, .. } =
&mut app.session.doc_mut().feature_mut(out["feature"].as_u64().unwrap()).unwrap().kind
else {
panic!("not Thread")
};
*designation = Some("1/4-20 UNC".into());
*modeled = true;
let reopened = Session::new(Document::from_json(&app.session.doc.to_json()).unwrap());
// The thread is metric (the M8 it was made as): a unified designation is not one of its.
let error = reopened.model.results.last().unwrap().error.clone().unwrap();
assert!(error.contains("unknown metric thread `1/4-20 UNC`"), "{error}");
}
#[test]
fn expanded_catalogue_public_plate_evidence_uses_only_headless_model_rendering() {
let Some(dir) = std::env::var_os("SOLIDCRAFT_CATALOGUE_EVIDENCE") else { return };
crate::gpu::install_cpu_picture_renderer();
let mut h = crate::scenario::Harness::new();
h.app.run("solid.box", json!({"length":50,"width":25,"height":6,"body_name":"ThreadPlate"})).unwrap();
for (x, name) in [(10, "M8x1"), (25, "1/4-20 UNC"), (40, "#10-32 UNF")] {
h.app.run("solid.hole", json!({"position":[x,12.5,6],"thread":name})).unwrap();
}
h.call("ui.view", json!({"view":"iso"}));
let path = std::path::Path::new(&dir).join("catalogue-plate.png");
let out = h.call("ui.render", json!({"path":path,"width":1000,"height":700,"grid":false,"axes":false}));
assert_eq!(out["ok"], true, "{out}");
std::fs::write(std::path::Path::new(&dir).join("catalogue-plate.solidcraft"), h.app.session.doc.to_json()).unwrap();
}
#[test]
fn contribution_metric_designation_omits_only_the_catalogue_coarse_pitch() {
for &(d, p) in metric_thread_sizes() {
assert_eq!(designation(d, p), format!("M{d}"));
assert_eq!(parse_metric_thread(&designation(d, p)), Some((d, p)));
assert_eq!(parse_metric_thread(&designation(d, p / 2.)), Some((d, p / 2.)));
assert!(designation(d, p / 2.).contains('x'));
}
assert_eq!(designation(8., 1.25), "M8");
assert_eq!(designation(8., 1.), "M8x1");
assert_eq!(designation(5., 0.5), "M5x0.5");
assert_eq!(designation(33., 1.), "M33x1");
assert_eq!(designation(8., 1.25 + 1e-12), "M8");
assert!(designation(8., 1.25 + 1e-6).contains('x'));
}
#[test]
fn contribution_metric_designation_rendering_preserves_authored_legacy_and_custom_text() {
// The tapped hole's rows; the thread dialog's own tests cover its designations.
let context = egui::Context::default();
crate::fonts::setup_bundled_fonts(&context);
for original in ["M8x1.25", "M8x1", "M33x1", "M5×0.5", " m8x1.25 ", "invalid"] {
let mut hole = original.to_string();
let mut custom = None;
let doc = Document::default();
context
.run_ui(Default::default(), |ui| {
egui::Grid::new("authored_hole").show(ui, |ui| {
hole_rows(ui, &doc, &mut hole, &mut custom, &mut None);
});
})
.textures_delta
.clear();
assert_eq!(hole, original);
}
}
#[test]
fn contribution_metric_designation_keeps_domain_pitch_drill_units_and_reopen() {
for (diameter, pitch, drill) in [(8., 1.25, 6.8), (8., 1., 7.), (5., 0.5, 4.5)] {
let (mut app, mut dialog) = hole();
app.run("document.units", json!({"units":"in"})).unwrap();
if let Kind::Hole { opts, .. } = &mut dialog.kind {
opts.tapped = true;
opts.all = true;
opts.thread = designation(diameter, pitch);
}
let commands = apply_commands(&app, &dialog).unwrap();
let result = app.run(&commands[0].0, commands[0].1.clone()).unwrap();
let feature = app.session.doc.feature(result["feature"].as_u64().unwrap()).unwrap();
let solidcraft_engine::doc::FeatureKind::Hole { diameter, .. } = &feature.kind else { panic!("not a hole") };
assert!((app.session.doc.eval(diameter, solidcraft_engine::doc::expr::Kind::Length).unwrap() - drill).abs() < 1e-9);
let saved = app.session.doc.to_json();
let reopened = Session::new(solidcraft_engine::doc::Document::from_json(&saved).unwrap());
let state = crate::open_meshing::session_world(&reopened);
assert_eq!(state.threads.len(), 1);
assert!((state.threads[0].pitch - pitch).abs() < 1e-9);
}
}
#[test]
fn parallel_pipe_profiles_switch_and_cancel_without_changing_the_document() {
let mut h = custom_hole_widget();
let before = h.app.session.doc.to_json();
for (profile, name, drill) in [("G / BSPP", "G 1/4", "11.75 mm"), ("Rp", "Rp 1/4", "11.4 mm")] {
h.step(&json!({"click":{"handle":"dialog:Profile"}})).unwrap();
h.step(&json!({"click":{"handle":format!("dialog:Profile:{profile}")}})).unwrap();
h.step(&json!({"click":{"handle":"dialog:Size"}})).unwrap();
h.step(&json!({"click":{"handle":format!("dialog:Size:{name}")}})).unwrap();
h.frames(3);
let command = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap();
assert_eq!(command[0].1["thread"], name);
assert!(command[0].1.get("diameter").is_none());
assert!(h.widget(drill).is_some());
assert!(crate::scenario::handle_at("dialog:Nominal diameter").is_none());
}
h.step(&json!({"key":"Escape"})).unwrap();
assert!(h.app.dialog.is_none());
assert_eq!(h.app.session.doc.to_json(), before);
}
#[test]
fn parallel_pipe_holes_have_the_tabulated_cylinders_depth_and_saved_designations() {
use solidcraft_engine::doc::{TappedThreadFamily, tapped_thread_sizes};
for family in [TappedThreadFamily::G, TappedThreadFamily::Rp] {
for size in tapped_thread_sizes(family) {
let mut app = SolveApp::new(Session::default(), Services::default());
app.run("solid.box", json!({"length":80,"width":80,"height":15,"body_name":"Plate"})).unwrap();
let result = app.run("solid.hole", json!({"position":[40,40,15],"thread":size.designation,"depth":10})).unwrap();
let saved = app.session.doc.to_json();
let reopened = Session::new(Document::from_json(&saved).unwrap());
let state = crate::open_meshing::session_world(&reopened);
assert_eq!(state.threads.len(), 1);
let t = &state.threads[0];
assert_eq!(t.designation, size.designation);
assert!((t.major_diameter - size.major_diameter).abs() < 1e-9 && (t.pitch - size.pitch).abs() < 1e-9);
assert!((t.end - t.start - 10.0).abs() < 1e-6);
let body = &state.bodies[0].body;
assert!(body.validity().is_empty());
for z in [6.0, 10.0, 14.0] {
let c = solidcraft_engine::kernel::cylinder_face_at(body, Vec3::new(40.0 + size.tap_drill / 2.0, 40.0, z)).unwrap();
assert!(c.internal && (2.0 * c.radius - size.tap_drill).abs() < 1e-8);
}
let actual = body.mesh(&solidcraft_engine::kernel::MeshTolerance::chord(0.001)).unwrap().measure().volume;
let removed = std::f64::consts::PI * (size.tap_drill / 2.0).powi(2) * 10.0;
assert!((actual - (96000.0 - removed)).abs() / removed < 0.002, "{}: {actual}", size.designation);
assert_eq!(reopened.doc.to_json(), saved);
if size.designation.ends_with(" 1/4") {
let mut doc = Document::from_json(&saved).unwrap();
let solidcraft_engine::doc::FeatureKind::Hole { diameter, .. } =
&mut doc.feature_mut(result["feature"].as_u64().unwrap()).unwrap().kind
else {
panic!("not Hole")
};
*diameter = format!("{} mm", size.tap_drill + 0.03).as_str().into();
let reopened = Session::new(Document::from_json(&doc.to_json()).unwrap());
let state = crate::open_meshing::session_world(&reopened);
let c = solidcraft_engine::kernel::cylinder_face_at(
&state.bodies[0].body,
Vec3::new(40.0 + (size.tap_drill + 0.03) / 2.0, 40.0, 10.0),
)
.unwrap();
assert!((2.0 * c.radius - size.tap_drill - 0.03).abs() < 1e-8);
}
}
}
}
}