* claim: #10316 * Insert Part: ASME/ANSI inch hex cap screws, hex nuts and SAE/USS washers (#10316) Part of #10316. New standard-part families, tabled in inches as the standards give them and built in millimetres: hex cap screw (ASME B18.2.1) and hex nut (ASME B18.2.2), 1/4 to 1 in UNC and UNF from the thread catalogue, and plain washers SAE and USS (ANSI B18.22.1 Type A). Cap screws take the standard inch lengths, 1/2 to 8 in, defaulting to the first at or above 2.5 d. Lengths read as fractional inches in Insert Part, Change Part Size, part names and part numbers. Insert Part gains a Unit system list (Metric, Inch) above Type; it opens on Metric. parts.library reports each family's system. Inch parts get no cosmetic thread: solid.thread takes only metric designations (#9571), and the old path would have made a wrong metric mark. 9/16 waits for the thread catalogue; split lock washers and carriage bolts follow in later PRs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,83 @@
|
||||
{
|
||||
"en": {
|
||||
"parts.family.hex_cap_screw_inch": "Hex cap screw (inch)",
|
||||
"parts.family.hex_nut_inch": "Hex nut (inch)",
|
||||
"parts.family.washer_sae": "Plain washer, SAE (narrow)",
|
||||
"parts.family.washer_uss": "Plain washer, USS (wide)",
|
||||
"parts.system": "Unit system",
|
||||
"parts.system.inch": "Inch",
|
||||
"parts.system.metric": "Metric"
|
||||
},
|
||||
"ar": {
|
||||
"parts.family.hex_cap_screw_inch": "برغي سداسي الرأس (بوصة)",
|
||||
"parts.family.hex_nut_inch": "صامولة سداسية (بوصة)",
|
||||
"parts.family.washer_sae": "حلقة مسطحة، SAE (ضيقة)",
|
||||
"parts.family.washer_uss": "حلقة مسطحة، USS (عريضة)",
|
||||
"parts.system": "نظام الوحدات",
|
||||
"parts.system.inch": "بوصة",
|
||||
"parts.system.metric": "متري"
|
||||
},
|
||||
"he": {
|
||||
"parts.family.hex_cap_screw_inch": "בורג ראש משושה (אינץ')",
|
||||
"parts.family.hex_nut_inch": "אום משושה (אינץ')",
|
||||
"parts.family.washer_sae": "דסקית שטוחה, SAE (צרה)",
|
||||
"parts.family.washer_uss": "דסקית שטוחה, USS (רחבה)",
|
||||
"parts.system": "מערכת יחידות",
|
||||
"parts.system.inch": "אינץ'",
|
||||
"parts.system.metric": "מטרי"
|
||||
},
|
||||
"ja": {
|
||||
"parts.family.hex_cap_screw_inch": "六角ボルト(インチ)",
|
||||
"parts.family.hex_nut_inch": "六角ナット(インチ)",
|
||||
"parts.family.washer_sae": "平座金、SAE(小形)",
|
||||
"parts.family.washer_uss": "平座金、USS(大形)",
|
||||
"parts.system": "単位系",
|
||||
"parts.system.inch": "インチ",
|
||||
"parts.system.metric": "メートル"
|
||||
},
|
||||
"vi": {
|
||||
"parts.family.hex_cap_screw_inch": "Bu lông đầu lục giác (inch)",
|
||||
"parts.family.hex_nut_inch": "Đai ốc lục giác (inch)",
|
||||
"parts.family.washer_sae": "Vòng đệm phẳng, SAE (hẹp)",
|
||||
"parts.family.washer_uss": "Vòng đệm phẳng, USS (rộng)",
|
||||
"parts.system": "Hệ đơn vị",
|
||||
"parts.system.inch": "Inch",
|
||||
"parts.system.metric": "Hệ mét"
|
||||
},
|
||||
"zh": {
|
||||
"parts.family.hex_cap_screw_inch": "六角头螺栓(英制)",
|
||||
"parts.family.hex_nut_inch": "六角螺母(英制)",
|
||||
"parts.family.washer_sae": "平垫圈,SAE(窄型)",
|
||||
"parts.family.washer_uss": "平垫圈,USS(宽型)",
|
||||
"parts.system": "单位制",
|
||||
"parts.system.inch": "英制",
|
||||
"parts.system.metric": "公制"
|
||||
},
|
||||
"de": {
|
||||
"parts.family.hex_cap_screw_inch": "Sechskantschraube (Zoll)",
|
||||
"parts.family.hex_nut_inch": "Sechskantmutter (Zoll)",
|
||||
"parts.family.washer_sae": "Unterlegscheibe, SAE (schmal)",
|
||||
"parts.family.washer_uss": "Unterlegscheibe, USS (breit)",
|
||||
"parts.system": "Maßsystem",
|
||||
"parts.system.inch": "Zoll",
|
||||
"parts.system.metric": "Metrisch"
|
||||
},
|
||||
"es": {
|
||||
"parts.family.hex_cap_screw_inch": "Tornillo de cabeza hexagonal (pulgadas)",
|
||||
"parts.family.hex_nut_inch": "Tuerca hexagonal (pulgadas)",
|
||||
"parts.family.washer_sae": "Arandela plana, SAE (estrecha)",
|
||||
"parts.family.washer_uss": "Arandela plana, USS (ancha)",
|
||||
"parts.system": "Sistema de unidades",
|
||||
"parts.system.inch": "Pulgadas",
|
||||
"parts.system.metric": "Métrico"
|
||||
},
|
||||
"fr": {
|
||||
"parts.family.hex_cap_screw_inch": "Vis à tête hexagonale (pouces)",
|
||||
"parts.family.hex_nut_inch": "Écrou hexagonal (pouces)",
|
||||
"parts.family.washer_sae": "Rondelle plate, SAE (étroite)",
|
||||
"parts.family.washer_uss": "Rondelle plate, USS (large)",
|
||||
"parts.system": "Système d'unités",
|
||||
"parts.system.inch": "Pouces",
|
||||
"parts.system.metric": "Métrique"
|
||||
}
|
||||
}
|
||||
@@ -47,6 +47,7 @@ pub(crate) use features::{EdgeRefForm, PLANE_FORMS, axis_dir_form, axis_line_obj
|
||||
pub use features::{auto_operation, extrude_reach, shown_scope};
|
||||
pub use file::open_steps::OpenSteps;
|
||||
pub use join_pieces::{Addition, addition};
|
||||
pub use parts::part_length_label;
|
||||
pub use sketch::dimension_roles;
|
||||
pub(crate) use sketch::face::face_pick_form;
|
||||
pub use sketch_construction::{
|
||||
|
||||
+303
-26
@@ -1,5 +1,6 @@
|
||||
//! Standard parts: ISO metric fasteners, dowel pins and ball bearings, generated in code from
|
||||
//! the dimensions in the public standards tables (no vendor geometry). Each part is inserted as
|
||||
//! Standard parts: ISO metric and ASME/ANSI inch fasteners, dowel pins and ball bearings,
|
||||
//! generated in code from the dimensions in the public standards tables (no vendor geometry).
|
||||
//! Inch parts are tabled in inches and built in millimetres like the rest. Each part is inserted as
|
||||
//! its own component, built by ordinary features (so it stays parametric and editable), with a
|
||||
//! cosmetic thread where it has one; at a hole it gets a rigid joint that puts its axis on the
|
||||
//! hole's and seats it on the face. Inserted at several holes it is still one component, placed
|
||||
@@ -16,20 +17,24 @@ use crate::params::{bad, num, str_, vec3};
|
||||
use crate::{EngineError, Result, Session};
|
||||
|
||||
pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("parts.library", "Standard Parts", library).icon("library")
|
||||
CommandSpec::new("parts.library", "Standard Parts", library)
|
||||
.icon("library")
|
||||
.noundo()
|
||||
.params("family? → families (name, standard, sizes, lengths) and, with family, each size's dimensions (mm)"),
|
||||
CommandSpec::new("parts.fastener", "Insert Fastener", insert_atomic).at("SOLID", "INSERT").icon("fastener").params(
|
||||
"the Insert Part dialog's command (same as parts.insert): family, size, length?, at?|point?+direction?, name?",
|
||||
),
|
||||
.params("family? → families (name, standard, system: metric|inch, sizes, lengths) and, with family, each size's dimensions (mm)"),
|
||||
CommandSpec::new("parts.fastener", "Insert Fastener", insert_atomic)
|
||||
.at("SOLID", "INSERT")
|
||||
.icon("fastener")
|
||||
.params("the Insert Part dialog's command (same as parts.insert): family, size, length?, at?|point?+direction?, name?"),
|
||||
CommandSpec::new("parts.insert", "Insert Part", insert_atomic).icon("fastener").params(
|
||||
"family (socket_head_cap_screw | button_head_cap_screw | hex_bolt | hex_nut | washer | set_screw | dowel_pin | bearing); size (\"M6\", or \"608\" for bearings); \
|
||||
length? (mm; screws, bolts, set screws, pins; default a standard length near 2.5 d); \
|
||||
"family (socket_head_cap_screw | button_head_cap_screw | hex_bolt | hex_nut | washer | set_screw | dowel_pin | bearing | \
|
||||
hex_cap_screw_inch | hex_nut_inch | washer_sae | washer_uss); size (\"M6\", \"608\" for bearings, \"1/2-13 UNC\" for inch screws and nuts, \
|
||||
\"1/2\" for inch washers); length? (mm, inch parts too; screws, bolts, set screws, pins; default a standard length near 2.5 d); \
|
||||
at?: [x,y,z] on a hole's rim or wall (the part seats on the hole's face with a rigid joint), or a list of them (one component, \
|
||||
placed and seated once per hole) | point?: [x,y,z] with direction?: [x,y,z] (no joint); name? → component, occurrence, joint?, \
|
||||
and with at: occurrences, joints (one per hole, in pick order)",
|
||||
),
|
||||
CommandSpec::new("parts.resize", "Change Part Size", resize_atomic).icon("scale")
|
||||
CommandSpec::new("parts.resize", "Change Part Size", resize_atomic)
|
||||
.icon("scale")
|
||||
.params("component: id|name of an inserted part; size?; length? — rebuilds it (joints keep it seated)"),
|
||||
];
|
||||
|
||||
@@ -43,6 +48,10 @@ const FAMILIES: &[(&str, &str, &str)] = &[
|
||||
("set_screw", "Hex socket set screw, flat point", "ISO 4026"),
|
||||
("dowel_pin", "Parallel pin (dowel)", "ISO 8734"),
|
||||
("bearing", "Deep groove ball bearing (envelope)", "ISO 15 (6000/6200/600 series)"),
|
||||
("hex_cap_screw_inch", "Hex cap screw (inch)", "ASME B18.2.1"),
|
||||
("hex_nut_inch", "Hex nut (inch)", "ASME B18.2.2"),
|
||||
("washer_sae", "Plain washer, SAE (narrow)", "ANSI B18.22.1 Type A"),
|
||||
("washer_uss", "Plain washer, USS (wide)", "ANSI B18.22.1 Type A"),
|
||||
];
|
||||
|
||||
/// ISO metric coarse: (size, d, pitch).
|
||||
@@ -190,6 +199,127 @@ const BEARINGS: [(&str, f64, f64, f64); 13] = [
|
||||
const LENGTHS: [f64; 22] =
|
||||
[4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 16.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 80.0, 90.0, 100.0, 120.0];
|
||||
|
||||
/// Millimetres per inch.
|
||||
const INCH: f64 = 25.4;
|
||||
|
||||
/// ASME B18.2.1 hex cap screw, in inches: (nominal size, width across flats F, head height H).
|
||||
/// 9/16 is left out until the thread catalogue has its UNC and UNF threads.
|
||||
const INCH_HEX_CAP: [(&str, f64, f64); 9] = [
|
||||
("1/4", 0.4375, 0.156),
|
||||
("5/16", 0.5, 0.203),
|
||||
("3/8", 0.5625, 0.234),
|
||||
("7/16", 0.625, 0.281),
|
||||
("1/2", 0.75, 0.312),
|
||||
("5/8", 0.9375, 0.391),
|
||||
("3/4", 1.125, 0.469),
|
||||
("7/8", 1.3125, 0.547),
|
||||
("1", 1.5, 0.609),
|
||||
];
|
||||
|
||||
/// ASME B18.2.2 hex nut, in inches: (nominal size, width across flats F, thickness H).
|
||||
const INCH_HEX_NUT: [(&str, f64, f64); 9] = [
|
||||
("1/4", 0.4375, 0.219),
|
||||
("5/16", 0.5, 0.266),
|
||||
("3/8", 0.5625, 0.328),
|
||||
("7/16", 0.6875, 0.375),
|
||||
("1/2", 0.75, 0.438),
|
||||
("5/8", 0.9375, 0.547),
|
||||
("3/4", 1.125, 0.641),
|
||||
("7/8", 1.3125, 0.75),
|
||||
("1", 1.5, 0.859),
|
||||
];
|
||||
|
||||
/// ANSI B18.22.1 Type A plain washers, in inches: (nominal size, inside diameter, outside
|
||||
/// diameter, thickness). SAE is the standard's narrow (N) series, USS its wide (W) one.
|
||||
const WASHER_SAE: [(&str, f64, f64, f64); 9] = [
|
||||
("1/4", 0.281, 0.625, 0.065),
|
||||
("5/16", 0.344, 0.688, 0.065),
|
||||
("3/8", 0.406, 0.812, 0.065),
|
||||
("7/16", 0.469, 0.922, 0.065),
|
||||
("1/2", 0.531, 1.062, 0.095),
|
||||
("5/8", 0.656, 1.312, 0.095),
|
||||
("3/4", 0.812, 1.469, 0.134),
|
||||
("7/8", 0.938, 1.75, 0.134),
|
||||
("1", 1.062, 2.0, 0.134),
|
||||
];
|
||||
const WASHER_USS: [(&str, f64, f64, f64); 9] = [
|
||||
("1/4", 0.312, 0.734, 0.065),
|
||||
("5/16", 0.375, 0.875, 0.083),
|
||||
("3/8", 0.438, 1.0, 0.083),
|
||||
("7/16", 0.5, 1.25, 0.083),
|
||||
("1/2", 0.562, 1.375, 0.109),
|
||||
("5/8", 0.688, 1.75, 0.134),
|
||||
("3/4", 0.812, 2.0, 0.148),
|
||||
("7/8", 0.938, 2.25, 0.165),
|
||||
("1", 1.062, 2.5, 0.165),
|
||||
];
|
||||
|
||||
/// Standard lengths for inch cap screws (inches).
|
||||
const INCH_LENGTHS: [f64; 19] = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 7.0, 8.0];
|
||||
|
||||
fn inch_lengths() -> Vec<f64> {
|
||||
INCH_LENGTHS.iter().map(|l| l * INCH).collect()
|
||||
}
|
||||
|
||||
/// The first standard length at or above 2.5 d. Both sides are inches turned into mm, so the
|
||||
/// comparison allows for rounding: a 1/2 screw's 2.5 d is exactly 1-1/4.
|
||||
fn default_inch_length(d: f64) -> f64 {
|
||||
inch_lengths().into_iter().find(|l| *l >= 2.5 * d - 1e-9).unwrap_or(8.0 * INCH)
|
||||
}
|
||||
|
||||
fn is_inch(family: &str) -> bool {
|
||||
matches!(family, "hex_cap_screw_inch" | "hex_nut_inch" | "washer_sae" | "washer_uss")
|
||||
}
|
||||
|
||||
/// A unified inch thread from the catalogue (`1/2-13 UNC`): its nominal size (`1/2`), and its
|
||||
/// major diameter and pitch (mm).
|
||||
fn unified(size: &str) -> Option<(String, f64, f64)> {
|
||||
use solidcraft_doc::TappedThreadFamily::{Unc, Unf};
|
||||
let t = solidcraft_doc::parse_tapped_thread(size).filter(|t| matches!(t.family, Unc | Unf))?;
|
||||
let nominal = t.designation.split('-').next()?.to_string();
|
||||
Some((nominal, t.major_diameter, t.pitch))
|
||||
}
|
||||
|
||||
/// The catalogue's threads for a nominal inch size, UNC before UNF.
|
||||
fn unified_sizes(nominal: &str) -> Vec<solidcraft_doc::TappedThread> {
|
||||
use solidcraft_doc::TappedThreadFamily::{Unc, Unf};
|
||||
[Unc, Unf].into_iter().flat_map(solidcraft_doc::tapped_thread_sizes).filter(|t| t.designation.split('-').next() == Some(nominal)).collect()
|
||||
}
|
||||
|
||||
/// A length (mm) in fractional inches to the nearest 1/64 (`1-1/2`), or none off that grid.
|
||||
fn inch_fraction(mm: f64) -> Option<String> {
|
||||
let n = mm / INCH * 64.0;
|
||||
let r = n.round();
|
||||
if !r.is_finite() || r <= 0.0 || r > 1e6 || (n - r).abs() > 1e-6 {
|
||||
return None;
|
||||
}
|
||||
let r = r as u64;
|
||||
let (whole, mut num, mut den) = (r / 64, r % 64, 64);
|
||||
while num > 0 && num % 2 == 0 {
|
||||
num /= 2;
|
||||
den /= 2;
|
||||
}
|
||||
Some(match (whole, num) {
|
||||
(w, 0) => w.to_string(),
|
||||
(0, n) => format!("{n}/{den}"),
|
||||
(w, n) => format!("{w}-{n}/{den}"),
|
||||
})
|
||||
}
|
||||
|
||||
/// How a part's length (mm) is shown where its family has a unit of its own: `1-1/2 in` for an
|
||||
/// inch family, none for a metric one (shown in the design's units).
|
||||
pub fn part_length_label(family: &str, mm: f64) -> Option<String> {
|
||||
is_inch(family).then(|| inch_fraction(mm)).flatten().map(|f| format!("{f} in"))
|
||||
}
|
||||
|
||||
/// A part's size with its length, as names and part numbers write it: `M6x20`, `1/2-13 UNC x 2`.
|
||||
fn size_with_length(family: &str, size: &str, len: f64) -> String {
|
||||
match is_inch(family).then(|| inch_fraction(len)).flatten() {
|
||||
Some(l) => format!("{size} x {l}"),
|
||||
None => format!("{size}x{len}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn metric(size: &str) -> Option<(f64, f64)> {
|
||||
METRIC.iter().find(|(s, _, _)| s.eq_ignore_ascii_case(size)).map(|(_, d, p)| (*d, *p))
|
||||
}
|
||||
@@ -202,9 +332,11 @@ fn default_length(d: f64) -> f64 {
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
enum Shape {
|
||||
/// A head (round, domed or hex), a shank down −z, an optional hex socket in the head's top.
|
||||
Screw { d: f64, pitch: f64, len: f64, head: Head, socket: Option<(f64, f64)> },
|
||||
/// `pitch` is that of a metric cosmetic thread; inch parts have none, as `solid.thread` takes
|
||||
/// only metric designations (#9571).
|
||||
Screw { d: f64, pitch: Option<f64>, len: f64, head: Head, socket: Option<(f64, f64)> },
|
||||
/// A hex prism with a through hole (nut), z 0…m.
|
||||
Nut { d: f64, pitch: f64, s: f64, m: f64 },
|
||||
Nut { d: f64, pitch: Option<f64>, s: f64, m: f64 },
|
||||
/// A ring (washer, bearing envelope), z 0…h.
|
||||
Ring { d_in: f64, d_out: f64, h: f64 },
|
||||
/// A cylinder down −z with a socket in its top (set screw), or plain (pin).
|
||||
@@ -237,22 +369,43 @@ fn shape(family: &str, size: &str, length: Option<f64>) -> std::result::Result<S
|
||||
"socket_head_cap_screw" => {
|
||||
let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;
|
||||
let (_, dk, k, s, t) = SHCS.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4762"))?;
|
||||
Shape::Screw { d, pitch, len: len(d), head: Head::Round { dk, k }, socket: Some((s, t)) }
|
||||
Shape::Screw { d, pitch: Some(pitch), len: len(d), head: Head::Round { dk, k }, socket: Some((s, t)) }
|
||||
}
|
||||
"button_head_cap_screw" => {
|
||||
let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;
|
||||
let (_, dk, k, s, t) = BHCS.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 7380-1"))?;
|
||||
Shape::Screw { d, pitch, len: len(d), head: Head::Dome { dk, k, flat: BUTTON_FLAT * s }, socket: Some((s, t)) }
|
||||
Shape::Screw { d, pitch: Some(pitch), len: len(d), head: Head::Dome { dk, k, flat: BUTTON_FLAT * s }, socket: Some((s, t)) }
|
||||
}
|
||||
"hex_bolt" => {
|
||||
let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;
|
||||
let (_, s, k) = HEX_BOLT.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4014"))?;
|
||||
Shape::Screw { d, pitch, len: len(d), head: Head::Hex { s, k }, socket: None }
|
||||
Shape::Screw { d, pitch: Some(pitch), len: len(d), head: Head::Hex { s, k }, socket: None }
|
||||
}
|
||||
"hex_nut" => {
|
||||
let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;
|
||||
let (_, s, m) = HEX_NUT.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4032"))?;
|
||||
Shape::Nut { d, pitch, s, m }
|
||||
Shape::Nut { d, pitch: Some(pitch), s, m }
|
||||
}
|
||||
"hex_cap_screw_inch" => {
|
||||
let (nominal, d, _) = unified(size).ok_or_else(|| need("UNC/UNF"))?;
|
||||
let (_, f, h) = INCH_HEX_CAP.iter().find(|r| r.0 == nominal).copied().ok_or_else(|| need("ASME B18.2.1"))?;
|
||||
Shape::Screw {
|
||||
d,
|
||||
pitch: None,
|
||||
len: length.unwrap_or_else(|| default_inch_length(d)),
|
||||
head: Head::Hex { s: f * INCH, k: h * INCH },
|
||||
socket: None,
|
||||
}
|
||||
}
|
||||
"hex_nut_inch" => {
|
||||
let (nominal, d, _) = unified(size).ok_or_else(|| need("UNC/UNF"))?;
|
||||
let (_, f, h) = INCH_HEX_NUT.iter().find(|r| r.0 == nominal).copied().ok_or_else(|| need("ASME B18.2.2"))?;
|
||||
Shape::Nut { d, pitch: None, s: f * INCH, m: h * INCH }
|
||||
}
|
||||
"washer_sae" | "washer_uss" => {
|
||||
let table = if family == "washer_sae" { &WASHER_SAE } else { &WASHER_USS };
|
||||
let (_, d1, d2, h) = table.iter().find(|r| r.0 == size.trim()).copied().ok_or_else(|| need("ANSI B18.22.1"))?;
|
||||
Shape::Ring { d_in: d1 * INCH, d_out: d2 * INCH, h: h * INCH }
|
||||
}
|
||||
"washer" => {
|
||||
let (_, d1, d2, h) = WASHER.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 7089"))?;
|
||||
@@ -390,12 +543,16 @@ fn build(s: &mut Session, sh: &Shape) -> Result<()> {
|
||||
if let Some((af, t)) = socket {
|
||||
hex(s, af, k, k - t, "cut")?;
|
||||
}
|
||||
thread(s, d, pitch, Vec3::new(d / 2.0, 0.0, -len / 2.0));
|
||||
if let Some(p) = pitch {
|
||||
thread(s, d, p, Vec3::new(d / 2.0, 0.0, -len / 2.0));
|
||||
}
|
||||
}
|
||||
Shape::Nut { d, pitch, s: af, m } => {
|
||||
hex(s, af, 0.0, m, "new")?;
|
||||
cyl(s, d, -1.0, m + 1.0, "cut")?;
|
||||
thread(s, d, pitch, Vec3::new(d / 2.0, 0.0, m / 2.0));
|
||||
if let Some(p) = pitch {
|
||||
thread(s, d, p, Vec3::new(d / 2.0, 0.0, m / 2.0));
|
||||
}
|
||||
}
|
||||
Shape::Ring { d_in, d_out, h } => {
|
||||
revolve(s, &[(d_in / 2.0, 0.0), (d_out / 2.0, 0.0), (d_out / 2.0, h), (d_in / 2.0, h)], "new")?;
|
||||
@@ -424,11 +581,26 @@ fn library(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
"set_screw" => SET_SCREW.iter().map(|r| json!({"size": r.0, "d": metric(r.0).map(|m| m.0), "pitch": metric(r.0).map(|m| m.1), "socket": r.1, "socket_depth": r.2})).collect(),
|
||||
"dowel_pin" => DOWEL.iter().map(|d| json!({"size": format!("{d}"), "d": d})).collect(),
|
||||
"bearing" => BEARINGS.iter().map(|r| json!({"size": r.0, "bore": r.1, "outer": r.2, "width": r.3})).collect(),
|
||||
"hex_cap_screw_inch" => INCH_HEX_CAP
|
||||
.iter()
|
||||
.flat_map(|r| unified_sizes(r.0).into_iter().map(move |t| json!({"size": t.designation, "d": t.major_diameter, "pitch": t.pitch, "across_flats": r.1 * INCH, "head_height": r.2 * INCH})))
|
||||
.collect(),
|
||||
"hex_nut_inch" => INCH_HEX_NUT
|
||||
.iter()
|
||||
.flat_map(|r| unified_sizes(r.0).into_iter().map(move |t| json!({"size": t.designation, "d": t.major_diameter, "pitch": t.pitch, "across_flats": r.1 * INCH, "height": r.2 * INCH})))
|
||||
.collect(),
|
||||
"washer_sae" | "washer_uss" => {
|
||||
let table = if id == "washer_sae" { &WASHER_SAE } else { &WASHER_USS };
|
||||
table.iter().map(|r| json!({"size": r.0, "inner": r.1 * INCH, "outer": r.2 * INCH, "thickness": r.3 * INCH})).collect()
|
||||
}
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let (_, name, standard) = FAMILIES.iter().find(|f| f.0 == id).copied().unwrap_or(("", "", ""));
|
||||
let lengths =
|
||||
matches!(id, "socket_head_cap_screw" | "button_head_cap_screw" | "hex_bolt" | "set_screw" | "dowel_pin").then_some(LENGTHS.to_vec());
|
||||
let lengths = match id {
|
||||
"socket_head_cap_screw" | "button_head_cap_screw" | "hex_bolt" | "set_screw" | "dowel_pin" => Some(LENGTHS.to_vec()),
|
||||
"hex_cap_screw_inch" => Some(inch_lengths()),
|
||||
_ => None,
|
||||
};
|
||||
if lengths.is_some() {
|
||||
for row in &mut sizes {
|
||||
let Some(size) = row.get("size").and_then(Value::as_str).map(str::to_string) else { continue };
|
||||
@@ -438,7 +610,8 @@ fn library(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
}
|
||||
json!({"family": id, "name": name, "standard": standard, "sizes": sizes, "lengths": lengths})
|
||||
let system = if is_inch(id) { "inch" } else { "metric" };
|
||||
json!({"family": id, "name": name, "standard": standard, "system": system, "sizes": sizes, "lengths": lengths})
|
||||
};
|
||||
match str_(p, "family") {
|
||||
Some(f) if FAMILIES.iter().any(|x| x.0 == f) => Ok(fam(f)),
|
||||
@@ -449,16 +622,17 @@ fn library(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
fn part_name(family: &str, size: &str, sh: &Shape) -> String {
|
||||
match sh {
|
||||
Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{} {size}x{len}", label(family)),
|
||||
Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{} {}", label(family), size_with_length(family, size, *len)),
|
||||
_ => format!("{} {size}", label(family)),
|
||||
}
|
||||
}
|
||||
|
||||
/// A standard part's part number and description: its standard and size (`ISO 4762 M6x20`), or
|
||||
/// a bearing's designation, and the family's name with the size.
|
||||
/// A standard part's part number and description: its standard and size (`ISO 4762 M6x20`,
|
||||
/// `ASME B18.2.1 1/2-13 UNC x 2`, an inch washer with its series: `ANSI B18.22.1 1/2 N`), or a
|
||||
/// bearing's designation, and the family's name with the size.
|
||||
fn identity(family: &str, size: &str, sh: &Shape) -> (String, String) {
|
||||
let size = match sh {
|
||||
Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{size}x{len}"),
|
||||
Shape::Screw { len, .. } | Shape::Rod { len, .. } => size_with_length(family, size, *len),
|
||||
_ => size.to_string(),
|
||||
};
|
||||
let standard = match family {
|
||||
@@ -469,10 +643,18 @@ fn identity(family: &str, size: &str, sh: &Shape) -> (String, String) {
|
||||
"washer" => "ISO 7089",
|
||||
"set_screw" => "ISO 4026",
|
||||
"dowel_pin" => "ISO 8734",
|
||||
"hex_cap_screw_inch" => "ASME B18.2.1",
|
||||
"hex_nut_inch" => "ASME B18.2.2",
|
||||
"washer_sae" | "washer_uss" => "ANSI B18.22.1",
|
||||
_ => "",
|
||||
};
|
||||
let series = match family {
|
||||
"washer_sae" => " N",
|
||||
"washer_uss" => " W",
|
||||
_ => "",
|
||||
};
|
||||
let name = FAMILIES.iter().find(|f| f.0 == family).map_or("Part", |f| f.1);
|
||||
let part_number = if standard.is_empty() { size.clone() } else { format!("{standard} {size}") };
|
||||
let part_number = if standard.is_empty() { size.clone() } else { format!("{standard} {size}{series}") };
|
||||
(part_number, format!("{name} {size}"))
|
||||
}
|
||||
|
||||
@@ -503,6 +685,10 @@ fn label(family: &str) -> &'static str {
|
||||
"washer" => "Washer",
|
||||
"set_screw" => "Set Screw",
|
||||
"dowel_pin" => "Dowel Pin",
|
||||
"hex_cap_screw_inch" => "Hex Cap Screw",
|
||||
"hex_nut_inch" => "Hex Nut",
|
||||
"washer_sae" => "SAE Washer",
|
||||
"washer_uss" => "USS Washer",
|
||||
_ => "Bearing",
|
||||
}
|
||||
}
|
||||
@@ -777,6 +963,93 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// #10316: ASME/ANSI inch hex cap screws, hex nuts and SAE/USS washers, tabled in inches and
|
||||
/// built in millimetres, with sizes from the UNC/UNF thread catalogue and fractional-inch names.
|
||||
#[test]
|
||||
fn inch_parts_follow_the_asme_and_ansi_tables() {
|
||||
const IN: f64 = 25.4;
|
||||
let across_corners = |af: f64| af / (std::f64::consts::PI / 6.0).cos();
|
||||
let part_number = |s: &Session, out: &Value| {
|
||||
let comp = out["component"].as_u64().unwrap_or(0);
|
||||
s.doc.components.iter().find(|c| c.id == comp).and_then(|c| c.metadata.text(solidcraft_doc::metadata::PART_NUMBER)).map(str::to_string)
|
||||
};
|
||||
// Every nominal size 1/4 to 1 but 9/16, coarse and fine.
|
||||
let l = run(&mut Session::default(), "parts.library", json!({"family": "hex_cap_screw_inch"}));
|
||||
let sizes: Vec<&str> = l["sizes"].as_array().map(|a| a.iter().filter_map(|x| x["size"].as_str()).collect()).unwrap_or_default();
|
||||
assert_eq!(sizes.len(), 18, "{sizes:?}");
|
||||
assert_eq!(sizes[..2], ["1/4-20 UNC", "1/4-28 UNF"]);
|
||||
assert_eq!(sizes[16..], ["1-8 UNC", "1-12 UNF"]);
|
||||
assert_eq!((l["standard"].as_str(), l["system"].as_str()), (Some("ASME B18.2.1"), Some("inch")));
|
||||
let all = run(&mut Session::default(), "parts.library", json!({}));
|
||||
let inch: Vec<&str> = all["families"]
|
||||
.as_array()
|
||||
.map(|a| a.iter().filter(|f| f["system"] == "inch").filter_map(|f| f["family"].as_str()).collect())
|
||||
.unwrap_or_default();
|
||||
assert_eq!(inch, ["hex_cap_screw_inch", "hex_nut_inch", "washer_sae", "washer_uss"]);
|
||||
let lengths: Vec<f64> = l["lengths"].as_array().map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
|
||||
assert_eq!((lengths.first().copied(), lengths.last().copied(), lengths.len()), (Some(0.5 * IN), Some(8.0 * IN), 19));
|
||||
// A 1/2-13 x 2 cap screw: 3/4 across flats, head 0.312 high, shank 2 in long, no thread mark.
|
||||
let mut s = Session::default();
|
||||
let out = run(&mut s, "parts.insert", json!({"family": "hex_cap_screw_inch", "size": "1/2-13 UNC", "length": 2.0 * IN}));
|
||||
assert_eq!(out["name"], "Hex Cap Screw 1/2-13 UNC x 2");
|
||||
assert_eq!(part_number(&s, &out).as_deref(), Some("ASME B18.2.1 1/2-13 UNC x 2"));
|
||||
let (lo, hi) = bbox(&s, "Hex Cap Screw 1/2-13 UNC x 2");
|
||||
let w = (hi.x - lo.x).max(hi.y - lo.y);
|
||||
assert!((w - across_corners(0.75 * IN)).abs() < 1e-6 && (lo.z + 2.0 * IN).abs() < 1e-6 && (hi.z - 0.312 * IN).abs() < 1e-6, "{lo:?} {hi:?}");
|
||||
assert!(s.model.state().threads.is_empty(), "solid.thread takes only metric designations (#9571)");
|
||||
// Its default length is the first standard length at or above 2.5 d: 1-1/4 for a 1/2.
|
||||
let mut d = Session::default();
|
||||
assert_eq!(
|
||||
run(&mut d, "parts.insert", json!({"family": "hex_cap_screw_inch", "size": "1/2-20 UNF"}))["name"],
|
||||
"Hex Cap Screw 1/2-20 UNF x 1-1/4"
|
||||
);
|
||||
// A 1/2-13 nut: 3/4 across flats, 0.438 thick, with the 1/2 in hole through it.
|
||||
let mut n = Session::default();
|
||||
let out = run(&mut n, "parts.insert", json!({"family": "hex_nut_inch", "size": "1/2-13 UNC"}));
|
||||
assert_eq!(part_number(&n, &out).as_deref(), Some("ASME B18.2.2 1/2-13 UNC"));
|
||||
let (lo, hi) = bbox(&n, "Hex Nut 1/2-13 UNC");
|
||||
let (w, h) = ((hi.x - lo.x).max(hi.y - lo.y), hi.z - lo.z);
|
||||
assert!((w - across_corners(0.75 * IN)).abs() < 1e-6 && (h - 0.438 * IN).abs() < 1e-6, "{w} {h}");
|
||||
// 1/2 washers: SAE 1.062 x 0.095, USS 1.375 x 0.109, the series in the part number.
|
||||
for (family, label, od, t, number) in [
|
||||
("washer_sae", "SAE Washer 1/2", 1.062, 0.095, "ANSI B18.22.1 1/2 N"),
|
||||
("washer_uss", "USS Washer 1/2", 1.375, 0.109, "ANSI B18.22.1 1/2 W"),
|
||||
] {
|
||||
let mut w = Session::default();
|
||||
let out = run(&mut w, "parts.insert", json!({"family": family, "size": "1/2"}));
|
||||
assert_eq!(part_number(&w, &out).as_deref(), Some(number));
|
||||
let (lo, hi) = bbox(&w, label);
|
||||
assert!((hi.x - lo.x - od * IN).abs() < 1e-6 && (hi.z - lo.z - t * IN).abs() < 1e-6, "{family}: {lo:?} {hi:?}");
|
||||
}
|
||||
// Resizing keeps it inch, and sizes the tables don't have are refused.
|
||||
let r = run(&mut s, "parts.resize", json!({"component": "Hex Cap Screw 1/2-13 UNC x 2", "size": "3/8-16 UNC", "length": 1.0 * IN}));
|
||||
assert_eq!(r["name"], "Hex Cap Screw 3/8-16 UNC x 1");
|
||||
for (family, size) in [
|
||||
("hex_cap_screw_inch", "9/16-12 UNC"),
|
||||
("hex_cap_screw_inch", "#10-24 UNC"),
|
||||
("hex_cap_screw_inch", "M12"),
|
||||
("hex_cap_screw_inch", "1/2-20 UNC"),
|
||||
("hex_nut_inch", "1/2"),
|
||||
("washer_sae", "9/16"),
|
||||
("washer_uss", "1/2-13 UNC"),
|
||||
] {
|
||||
assert!(Session::default().execute("parts.insert", &json!({"family": family, "size": size})).is_err(), "{family} {size}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inch_lengths_read_as_fractions() {
|
||||
assert_eq!(super::part_length_label("hex_cap_screw_inch", 1.5 * 25.4).as_deref(), Some("1-1/2 in"));
|
||||
assert_eq!(super::part_length_label("hex_cap_screw_inch", 0.75 * 25.4).as_deref(), Some("3/4 in"));
|
||||
assert_eq!(super::part_length_label("hex_cap_screw_inch", 8.0 * 25.4).as_deref(), Some("8 in"));
|
||||
// Off the 1/64 grid, or a metric family: shown as millimetres in the design's units.
|
||||
assert_eq!(super::part_length_label("hex_cap_screw_inch", 20.0), None);
|
||||
assert_eq!(super::part_length_label("socket_head_cap_screw", 25.4), None);
|
||||
for bad in [f64::NAN, f64::INFINITY, -25.4, 0.0, 1e300] {
|
||||
assert_eq!(super::part_length_label("hex_cap_screw_inch", bad), None, "{bad}");
|
||||
}
|
||||
}
|
||||
|
||||
/// #7692: a button head cap screw (ISO 7380-1) takes the same parameters as a socket head
|
||||
/// cap screw, with a domed crown in place of the cylindrical head.
|
||||
#[test]
|
||||
@@ -955,6 +1228,10 @@ mod tests {
|
||||
("set_screw", "M6", "M8"),
|
||||
("dowel_pin", "6", "8"),
|
||||
("bearing", "608", "6200"),
|
||||
("hex_cap_screw_inch", "1/2-13 UNC", "5/8-11 UNC"),
|
||||
("hex_nut_inch", "1/2-13 UNC", "5/8-18 UNF"),
|
||||
("washer_sae", "1/2", "5/8"),
|
||||
("washer_uss", "1/2", "5/8"),
|
||||
] {
|
||||
let mut s = Session::default();
|
||||
let part = run(&mut s, "parts.insert", json!({"family": family, "size": size}));
|
||||
|
||||
@@ -18,12 +18,16 @@ pub(crate) fn configuration(app: &SolveApp, component: u64) -> Option<String> {
|
||||
if size.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(configuration_name(size, part.length))
|
||||
Some(configuration_name(&part.family, size, part.length))
|
||||
}
|
||||
|
||||
fn configuration_name(size: &str, length: Option<f64>) -> String {
|
||||
/// An inch family's length is in fractional inches (`1/2-13 UNC×2 in`), a metric one's in mm.
|
||||
fn configuration_name(family: &str, size: &str, length: Option<f64>) -> String {
|
||||
match length.filter(|length| length.is_finite() && *length > 0.0) {
|
||||
Some(length) => format!("{size}×{length}"),
|
||||
Some(length) => match solidcraft_engine::cmd::part_length_label(family, length) {
|
||||
Some(label) => format!("{size}×{label}"),
|
||||
None => format!("{size}×{length}"),
|
||||
},
|
||||
None => size.to_owned(),
|
||||
}
|
||||
}
|
||||
@@ -183,14 +187,14 @@ pub fn rows(app: &SolveApp, ui: &mut egui::Ui, k: &mut Resize) -> bool {
|
||||
choice_row(ui, "Size", "part_resize_size", &mut k.size, &sizes);
|
||||
if let Some(lengths) = k.lengths() {
|
||||
let mut index = k.length.and_then(|l| lengths.iter().position(|x| *x == l)).unwrap_or(0);
|
||||
let labels: Vec<String> = lengths.iter().map(|l| crate::prefs::show_mm(app, *l, 1)).collect();
|
||||
let labels: Vec<String> = lengths.iter().map(|l| crate::dialogs_parts::length_label(app, &k.family.id, *l)).collect();
|
||||
let labels: Vec<&str> = labels.iter().map(String::as_str).collect();
|
||||
choice_row(ui, "Length", "part_resize_length", &mut index, &labels);
|
||||
k.length = lengths.get(index).copied();
|
||||
}
|
||||
if let Some((size, _)) = k.family.sizes.get(k.size) {
|
||||
row(ui, "Configuration", |ui| {
|
||||
ui.label(configuration_name(size, k.length));
|
||||
ui.label(configuration_name(&k.family.id, size, k.length));
|
||||
});
|
||||
}
|
||||
crate::ui_kit::text(ui, crate::i18n::tr("ui.part_size_shared"), crate::ui_kit::Text::Hint("part_size_shared"));
|
||||
@@ -479,6 +483,10 @@ mod tests {
|
||||
("set_screw", "M5", Some(10.0)),
|
||||
("dowel_pin", "6", Some(20.0)),
|
||||
("bearing", "608", None),
|
||||
("hex_cap_screw_inch", "1/2-13 UNC", Some(2.0 * 25.4)),
|
||||
("hex_nut_inch", "1/2-13 UNC", None),
|
||||
("washer_sae", "1/2", None),
|
||||
("washer_uss", "1/2", None),
|
||||
] {
|
||||
let (app, id) = part(family, size, length);
|
||||
let k = Resize::new(&app, id).unwrap();
|
||||
@@ -541,6 +549,23 @@ mod tests {
|
||||
assert_eq!(commands[0].1["length"], 20.5);
|
||||
}
|
||||
|
||||
/// #10316: an inch part's lengths are fractional inches in a millimetre design too, and the
|
||||
/// command still takes millimetres.
|
||||
#[test]
|
||||
fn part_size_shows_an_inch_part_in_fractional_inches() {
|
||||
let (app, id) = part("hex_cap_screw_inch", "1/2-13 UNC", Some(1.5 * 25.4));
|
||||
assert_eq!(configuration(&app, id).as_deref(), Some("1/2-13 UNC×1-1/2 in"));
|
||||
let mut h = crate::scenario::Harness::new();
|
||||
h.app = app;
|
||||
h.app.home.open = false;
|
||||
menu(&mut h.app, Target::Component { id });
|
||||
h.frames(3);
|
||||
assert!(h.widget_near("1-1/2 in", "Length").is_some());
|
||||
change(&mut h.app, "5/8-11 UNC", Some(2.0 * 25.4));
|
||||
let commands = crate::dialogs::apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap();
|
||||
assert_eq!((commands[0].1["size"].as_str(), commands[0].1["length"].as_f64()), (Some("5/8-11 UNC"), Some(50.8)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn part_size_real_widgets_change_size_length_and_confirm_once() {
|
||||
let (app, id) = part("socket_head_cap_screw", "M5", Some(20.5));
|
||||
|
||||
@@ -20,6 +20,8 @@ pub struct Family {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub standard: String,
|
||||
/// `metric` or `inch`: the Unit system list shows the families of one at a time.
|
||||
pub system: String,
|
||||
/// Size names and their table rows.
|
||||
pub sizes: Vec<(String, Value)>,
|
||||
pub lengths: Option<Vec<f64>>,
|
||||
@@ -43,6 +45,7 @@ pub fn families(v: &Value) -> Vec<Family> {
|
||||
Some(Family {
|
||||
name: f.get("name").and_then(Value::as_str).unwrap_or(&id).to_string(),
|
||||
standard: f.get("standard").and_then(Value::as_str).unwrap_or("").to_string(),
|
||||
system: f.get("system").and_then(Value::as_str).unwrap_or("metric").to_string(),
|
||||
sizes,
|
||||
lengths: f.get("lengths").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_f64).collect()),
|
||||
id,
|
||||
@@ -61,6 +64,9 @@ pub(crate) fn family_name(f: &Family) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// The Unit system list: each system's id in the library and its label.
|
||||
const SYSTEMS: [(&str, &str); 2] = [("metric", "Metric"), ("inch", "Inch")];
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Pt {
|
||||
pub family: usize,
|
||||
@@ -120,6 +126,12 @@ pub fn insert_params(lib: &[Family], k: &Pt, holes: &[Sel]) -> Result<Value, Str
|
||||
Ok(p)
|
||||
}
|
||||
|
||||
/// A length (mm) of a part of the family: in fractional inches for an inch family, in the
|
||||
/// design's units otherwise.
|
||||
pub(crate) fn length_label(app: &SolveApp, family: &str, mm: f64) -> String {
|
||||
solidcraft_engine::cmd::part_length_label(family, mm).unwrap_or_else(|| crate::prefs::show_mm(app, mm, 1))
|
||||
}
|
||||
|
||||
/// Where the Length list opens for a size: the index of the length an insert of it gets when
|
||||
/// none is asked for, which `parts.library` reports beside the size's table values. The list
|
||||
/// carries no item of its own for it, so a size whose default is missing opens on the first.
|
||||
@@ -162,12 +174,34 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Pt, inputs: &[SelInpu
|
||||
});
|
||||
return false;
|
||||
}
|
||||
let names: Vec<String> =
|
||||
lib.iter().map(|f| if f.standard.is_empty() { family_name(f) } else { format!("{} ({})", family_name(f), f.standard) }).collect();
|
||||
// The Unit system list picks metric or inch; Type lists that system's families. The system
|
||||
// shown is the chosen family's, so a new system moves the choice to its first family.
|
||||
let current = lib.get(k.family).map_or("metric", |f| f.system.as_str());
|
||||
let mut system = SYSTEMS.iter().position(|s| s.0 == current).unwrap_or(0);
|
||||
let was_system = system;
|
||||
choice_row(ui, "Unit system", "pt_system", &mut system, &SYSTEMS.map(|s| s.1));
|
||||
let system_id = SYSTEMS.get(system).map_or("metric", |s| s.0);
|
||||
if system != was_system
|
||||
&& let Some(first) = lib.iter().position(|f| f.system == system_id)
|
||||
{
|
||||
k.family = first;
|
||||
k.size = 0;
|
||||
k.length = None;
|
||||
}
|
||||
let shown: Vec<usize> = (0..lib.len()).filter(|i| lib.get(*i).is_some_and(|f| f.system == system_id)).collect();
|
||||
let names: Vec<String> = shown
|
||||
.iter()
|
||||
.filter_map(|i| lib.get(*i))
|
||||
.map(|f| if f.standard.is_empty() { family_name(f) } else { format!("{} ({})", family_name(f), f.standard) })
|
||||
.collect();
|
||||
let refs: Vec<&str> = names.iter().map(String::as_str).collect();
|
||||
let before = k.family;
|
||||
choice_row(ui, "Type", "pt_family", &mut k.family, &refs);
|
||||
if k.family != before {
|
||||
let mut pick = shown.iter().position(|i| *i == k.family).unwrap_or(0);
|
||||
let before = pick;
|
||||
choice_row(ui, "Type", "pt_family", &mut pick, &refs);
|
||||
if pick != before
|
||||
&& let Some(i) = shown.get(pick)
|
||||
{
|
||||
k.family = *i;
|
||||
k.size = 0;
|
||||
k.length = None;
|
||||
}
|
||||
@@ -180,7 +214,7 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Pt, inputs: &[SelInpu
|
||||
k.length = None;
|
||||
}
|
||||
if let Some(ls) = &f.lengths {
|
||||
let labels: Vec<String> = ls.iter().map(|l| crate::prefs::show_mm(app, *l, 1)).collect();
|
||||
let labels: Vec<String> = ls.iter().map(|l| length_label(app, &f.id, *l)).collect();
|
||||
let refs: Vec<&str> = labels.iter().map(String::as_str).collect();
|
||||
let mut i = k.length.unwrap_or_else(|| default_length(f, k.size, ls));
|
||||
form_row(ui, "Length", |ui| {
|
||||
@@ -302,7 +336,8 @@ mod tests {
|
||||
for f in &l {
|
||||
assert_ne!(family_name(f), f.name, "{}", f.id);
|
||||
}
|
||||
let unknown = Family { id: "spring".into(), name: "Spring".into(), standard: String::new(), sizes: vec![], lengths: None };
|
||||
let unknown =
|
||||
Family { id: "spring".into(), name: "Spring".into(), standard: String::new(), system: "metric".into(), sizes: vec![], lengths: None };
|
||||
assert_eq!(family_name(&unknown), "Spring");
|
||||
}
|
||||
|
||||
@@ -339,6 +374,38 @@ mod tests {
|
||||
assert!(insert_params(&[], &k, &[]).is_err());
|
||||
}
|
||||
|
||||
/// #10316: the Unit system list above Type picks metric or inch, and Type then lists that
|
||||
/// system's families only.
|
||||
#[test]
|
||||
fn the_system_list_picks_the_families_type_shows() {
|
||||
let chosen = |h: &crate::scenario::Harness| {
|
||||
let Kind::Part(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("not Insert Part") };
|
||||
commands(&h.app, k, &[]).unwrap()[0].1.clone()
|
||||
};
|
||||
let mut h = crate::scenario::Harness::new();
|
||||
h.app.home.open = false;
|
||||
h.app.start("parts.insert");
|
||||
h.frames(3);
|
||||
assert!(h.widget_near("Metric", "Unit system").is_some());
|
||||
assert_eq!(chosen(&h)["family"], "socket_head_cap_screw");
|
||||
h.step(&json!({"click":{"handle":"dialog:Unit system"}})).unwrap();
|
||||
h.step(&json!({"click":{"handle":"dialog:Unit system:Inch"}})).unwrap();
|
||||
h.frames(2);
|
||||
assert_eq!((chosen(&h)["family"].as_str(), chosen(&h)["size"].as_str()), (Some("hex_cap_screw_inch"), Some("1/4-20 UNC")));
|
||||
// Type now lists the inch families and no metric one.
|
||||
h.step(&json!({"click":{"handle":"dialog:Type"}})).unwrap();
|
||||
assert!(crate::scenario::handle_at("dialog:Type:Plain washer, USS (wide) (ANSI B18.22.1 Type A)").is_some());
|
||||
assert!(crate::scenario::handle_at("dialog:Type:Hex nut (ISO 4032)").is_none());
|
||||
h.step(&json!({"click":{"handle":"dialog:Type:Hex nut (inch) (ASME B18.2.2)"}})).unwrap();
|
||||
h.frames(2);
|
||||
assert_eq!(chosen(&h)["family"], "hex_nut_inch");
|
||||
// Back to metric: the first metric family again.
|
||||
h.step(&json!({"click":{"handle":"dialog:Unit system"}})).unwrap();
|
||||
h.step(&json!({"click":{"handle":"dialog:Unit system:Metric"}})).unwrap();
|
||||
h.frames(2);
|
||||
assert_eq!(chosen(&h)["family"], "socket_head_cap_screw");
|
||||
}
|
||||
|
||||
/// Every dimension the library gives for a size is labelled in words, in each family.
|
||||
#[test]
|
||||
fn every_library_dimension_has_a_label_in_words() {
|
||||
|
||||
Reference in New Issue
Block a user