Files
solidcraft/crates/ui-egui/src/dialogs_sheet.rs
T
3045d0787e Dialog curve picks keep their sketch (#4057) (#4081)
* Dialog curve picks keep their sketch (#3726)

* Format

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

* Format

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

* Adapt context-menu test to Sel::SketchCurve's sketch field

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

* Path Flange picks keep their sketch too

Path Flange (#4096) landed after this PR and still looked its path up in the newest sketch with those ids.

---------

Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 18:20:03 +00:00

1231 lines
60 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.
//! Sheet metal dialogs: Flange (base from profiles, edge flanges from picked edges, contour from
//! open sketch lines; the picks decide which), Hem, Unfold and Refold, Convert to Sheet Metal,
//! Sheet Metal Rules (the rule manager) and Create Flat Pattern (a flat view of the part with
//! its bend lines, the bend table and DXF export).
use crate::dialogs::put;
use crate::ui_kit::{choice_row, expr_row, hint_row};
use egui::{Align2, Color32, FontId, Pos2, Rect, RichText, Stroke, pos2, vec2};
use serde_json::{Map, Value, json};
use solidcraft_engine::Sel;
use solidcraft_engine::doc::expr::Kind as ValueKind;
use solidcraft_engine::doc::sheet::SheetRule;
use solidcraft_engine::doc::{FeatureKind, ProfileSel};
use solidcraft_engine::geom::{Vec2, Vec3};
use crate::SolveApp;
use crate::dialogs::{Dialog, Kind, edge_sel, face_sel, form_row, profile_indices};
use crate::selection::{AXES, BODIES, CURVES, EDGES, FACES, PLANAR_FACES, PROFILES, SelInput, SelectionExt as _, items, point_value as pt};
use crate::theme::Tokens;
const PERFORATION_PATTERNS: [&str; 2] = ["staggered", "square"];
const PERFORATION_LABELS: [&str; 2] = ["ui.perforate_staggered", "ui.perforate_square"];
const FOLD_POSITIONS: [&str; 4] = ["centerline", "start", "end", "mould"];
const FOLD_POSITION_LABELS: [&str; 4] = ["Centerline", "Start of Bend", "End of Bend", "Outside Mould Line"];
const FLANGE_TYPES: [&str; 3] = ["Base", "Edge", "Contour"];
const POSITIONS: [&str; 5] = ["inside", "outside", "middle", "material_outside", "tangent"];
const POSITION_LABELS: [&str; 5] = ["Inside", "Outside", "Middle", "Material Outside", "Tangent to Edge"];
/// Where an edge flange's height is measured from (`height_from`; the first is the default).
const HEIGHT_FROM: [&str; 3] = ["outer", "inner", "tangent"];
const HEIGHT_FROM_LABELS: [&str; 3] = ["Outer Sharp", "Inner Sharp", "Tangent"];
/// Rule fields the manager edits (parameter name, label).
const RULE_FIELDS: [(&str, &str); 8] = [
("thickness", "Thickness"),
("k_factor", "K Factor"),
("bend_radius", "Bend Radius"),
("relief_width", "Relief Width"),
("relief_depth", "Relief Depth"),
("corner_relief", "Corner Relief"),
("hem_gap", "Hem Gap"),
("gap", "Flange Gap"),
];
/// The corner relief shapes the manager offers (the rule's `corner_relief_shape`) and their labels.
const RELIEF_SHAPES: [&str; 4] = ["notch", "round", "rectangular", "tear"];
const RELIEF_SHAPE_LABELS: [&str; 4] = ["Notch", "Round", "Rectangular", "Tear"];
/// How the manager's rule reads bend angles in the DXF bend notes (the rule's `angle_display`)
/// and their labels.
const ANGLE_DISPLAYS: [&str; 2] = ["bend", "included"];
const ANGLE_DISPLAY_LABELS: [&str; 2] = ["Bend", "Included"];
/// The corner relief shapes an edge flange offers: the rule's (index 0, nothing of its own), then
/// the shapes of `RELIEF_SHAPES` in order.
/// Which way a further bend turns, against the bend before it.
const BEND_WAY_LABELS: [&str; 2] = ["Same way", "Other way"];
const FLANGE_RELIEF_LABELS: [&str; 5] = ["Rule", "Notch", "Round", "Rectangular", "Tear"];
crate::dialog_descriptor::dialog_descriptors! {
#[derive(Clone, Debug)]
pub enum Sm {
Perforate("sheet.perforate", "ui.perforate_title", [("Body (last if none)", BODIES | FACES, false)],
FeatureKind::SheetPerforate { diameter, pitch, margin, pattern, .. }) {
diameter: String = "3 mm".into() => diameter.to_string(),
pitch: String = "6 mm".into() => pitch.to_string(),
margin: String = String::new() => margin.as_deref().map(str::to_string).unwrap_or_default(),
pattern: usize = 0 => pattern.as_deref().and_then(|p| PERFORATION_PATTERNS.iter().position(|x| *x == p)).unwrap_or(0),
} => json!({"diameter": diameter, "pitch": pitch, "pattern": PERFORATION_PATTERNS.get(*pattern).copied().unwrap_or("staggered")});
Hem("sheet.hem", "HEM", [("Edges", EDGES, true)],
FeatureKind::SheetHem { length, gap, flip, .. }) {
length: String = "5 mm".into() => length.to_string(),
gap: String = String::new() => gap.as_deref().map(str::to_string).unwrap_or_default(),
flip: bool = false => *flip,
} => json!({"length": length, "flip": flip});
Fold("sheet.fold", "FOLD", [("Bend Line", AXES, false), ("Stationary Side", PLANAR_FACES, false)],
FeatureKind::SheetFold { angle, radius, position, flip, .. }) {
angle: String = "90 deg".into() => angle.to_string(),
radius: String = String::new() => radius.as_deref().map(str::to_string).unwrap_or_default(),
position: usize = 0 => FOLD_POSITIONS.iter().position(|x| x == position || (*x == "mould" && position == "mold")).unwrap_or(0),
flip: bool = false => *flip,
} => json!({"angle": angle, "position": FOLD_POSITIONS.get(*position).copied().unwrap_or("centerline"), "flip": flip});
Path("sheet.path_flange", "PATH FLANGE", [("Edge", EDGES, false), ("Path", CURVES, true)],
FeatureKind::SheetPath { radius, .. }) {
radius: String = String::new() => radius.as_deref().map(str::to_string).unwrap_or_default(),
} => json!({});
; custom {
/// Base, edge or contour flange (`ty` follows the picks: profiles, edges, sketch lines).
Flange {
ty: usize,
height: String,
angle: String,
radius: String,
position: usize,
/// Edge flanges: where the height is measured from (index into `HEIGHT_FROM`).
height_from: usize,
flip: bool,
distance: String,
reverse: bool,
rule: usize,
/// Edge flanges: the edges with an angle and/or a height of their own (the picked point,
/// angle, height; an empty text means the dialog's), from the rows per edge.
own: Vec<(Vec3, String, String)>,
/// Edge flanges: the corner relief shape of their own (index into `FLANGE_RELIEF_LABELS`;
/// 0 is the rule's) and its size (empty: the rule's).
relief: usize,
relief_size: String,
/// Edge flanges: further bends (angle, height, turns the other way), each a flange on
/// the far edge of the one before it (the command's `then`).
then: Vec<(String, String, bool)>,
},
Unfold {
refold: bool,
},
Convert {
rule: usize,
},
/// The rule manager: the rule shown (index into the rules, or past the end for a new one).
Rules {
pick: usize,
name: String,
values: Vec<String>,
/// The corner relief shape (index into `RELIEF_SHAPES`).
relief: usize,
/// How bend angles read (index into `ANGLE_DISPLAYS`).
angles: usize,
active: bool,
loaded: Option<usize>,
},
/// The flat pattern of the picked (or last) sheet body.
FlatPattern {
data: Option<Result<Value, String>>,
key: Option<(u64, Option<String>)>,
status: Option<String>,
},
}
}
}
impl Sm {
pub fn title(&self) -> &'static str {
match self {
Sm::Flange { .. } => "FLANGE",
Sm::Unfold { refold: false } => "UNFOLD",
Sm::Unfold { refold: true } => "REFOLD",
Sm::Convert { .. } => "CONVERT TO SHEET METAL",
Sm::Rules { .. } => "SHEET METAL RULES",
Sm::FlatPattern { .. } => "FLAT PATTERN",
_ => self.simple_metadata().map_or("", |(_, title)| title),
}
}
pub fn previews(&self) -> bool {
!matches!(self, Sm::FlatPattern { .. })
}
/// The value on the canvas (the flange's follows its picks).
pub fn primary(&mut self, inputs: &[SelInput]) -> Option<(&'static str, ValueKind, &mut String)> {
if let Sm::Flange { ty, .. } = self {
*ty = flange_type(inputs);
}
Some(match self {
Sm::Flange { ty: 1, height, .. } => ("Height", ValueKind::Length, height),
Sm::Flange { ty: 2, distance, .. } => ("Distance", ValueKind::Length, distance),
Sm::Hem { length, .. } => ("Length", ValueKind::Length, length),
Sm::Fold { angle, .. } => ("Angle", ValueKind::Angle, angle),
_ => return None,
})
}
}
fn new_flange(app: &SolveApp, ty: usize) -> Sm {
Sm::Flange {
ty,
height: crate::dialogs::length_default(&app.session, "10"),
angle: "90 deg".into(),
radius: String::new(),
position: 0,
height_from: 0,
flip: false,
distance: crate::dialogs::length_default(&app.session, "20"),
reverse: false,
rule: 0,
own: Vec::new(),
relief: 0,
relief_size: String::new(),
then: Vec::new(),
}
}
/// The dialog for a sheet metal command.
pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {
let (sm, inputs) = match id {
"sheet.flange" => (new_flange(app, 0), vec![SelInput::new("Profile / Edges", PROFILES | EDGES | CURVES, true)]),
"sheet.unfold" => (Sm::Unfold { refold: false }, vec![SelInput::new("Body (last if none)", BODIES, false)]),
"sheet.refold" => (Sm::Unfold { refold: true }, vec![SelInput::new("Body (last if none)", BODIES, false)]),
"sheet.convert" => {
(Sm::Convert { rule: 0 }, vec![SelInput::new("Fixed Face", PLANAR_FACES, false), SelInput::new("Bend Edges", EDGES, true)])
}
"sheet.manage_rules" => {
let active = app.session.doc.sheet.active.clone();
let rules = rule_list(app);
let pick = active.and_then(|a| rules.iter().position(|r| r.name == a)).unwrap_or(0);
(Sm::Rules { pick, name: String::new(), values: Vec::new(), relief: 0, angles: 0, active: true, loaded: None }, vec![])
}
"sheet.flat_pattern" => (Sm::FlatPattern { data: None, key: None, status: None }, vec![SelInput::new("Body (last if none)", BODIES, false)]),
_ => Sm::simple_start(id)?,
};
Some((crate::length_input::defaults(&app.session.doc, Kind::Sheet(sm)), inputs))
}
/// The design's rules (the default steel rule when it has none).
fn rule_list(app: &SolveApp) -> Vec<SheetRule> {
let r = &app.session.doc.sheet.rules;
if r.is_empty() { vec![SheetRule::steel()] } else { r.clone() }
}
/// "(active rule)" and the rule names, for a rule box.
fn rule_names(app: &SolveApp) -> Vec<String> {
std::iter::once("(active rule)".to_string()).chain(rule_list(app).into_iter().map(|r| r.name)).collect()
}
fn rule_combo(app: &SolveApp, ui: &mut egui::Ui, id: &str, rule: &mut usize) {
let names = rule_names(app);
let refs: Vec<&str> = names.iter().map(String::as_str).collect();
choice_row(ui, "Rule", id, rule, &refs);
}
/// The flange type the picks make: edges an edge flange, sketch lines a contour, else base.
fn flange_type(inputs: &[SelInput]) -> usize {
let items = inputs.first().map(|i| i.items.as_slice()).unwrap_or(&[]);
if items.iter().any(|x| matches!(x, Sel::Edge { .. })) {
1
} else if items.iter().any(|x| matches!(x, Sel::SketchCurve { .. })) {
2
} else {
0
}
}
/// The dialog's own rows (after the selection inputs); true when Enter was pressed in a value.
pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Sm, inputs: &mut [SelInput]) -> bool {
let t = Tokens::get();
let mut enter = false;
match k {
Sm::Flange { ty, height, angle, radius, position, height_from, flip, distance, reverse, rule, own, relief, relief_size, then } => {
*ty = flange_type(inputs);
form_row(ui, "Type", |ui| {
ui.label(FLANGE_TYPES.get(*ty).copied().unwrap_or(""));
});
match *ty {
1 => {
enter |= expr_row(ui, "Height", height);
enter |= expr_row(ui, "Angle", angle);
choice_row(ui, "Bend Position", "sm_pos", position, &POSITION_LABELS);
choice_row(ui, "Height From", "sm_height_from", height_from, &HEIGHT_FROM_LABELS);
// Further bends: each a flange on the far edge of the one before it.
form_row(ui, "Further Bends", |ui| {
let add = crate::ui_kit::button(ui, "Add bend", crate::ui_kit::Button::Normal)
.on_hover_text(crate::i18n::tr_label("Another bend on the far edge of the last flange"));
if add.clicked() && then.len() < 16 {
then.push(("45 deg".into(), "20 mm".into(), false));
}
});
let mut drop = None;
for (n, (a, h, other)) in then.iter_mut().enumerate() {
let bend = n + 2;
// The bend's heading: what it makes, and a bin to take it out.
form_row(ui, &format!("Bend {bend}"), |ui| {
if crate::ui_kit::bin_button(ui, crate::i18n::tr_label("Remove this bend")).clicked() {
drop = Some(n);
}
ui.label(format!("{} · {}", a.trim(), h.trim()));
});
enter |= expr_row(ui, &format!("Bend {bend} angle"), a);
enter |= expr_row(ui, &format!("Bend {bend} height"), h);
let mut way = usize::from(*other);
choice_row(ui, &format!("Bend {bend} turns"), &format!("sm_then_way_{n}"), &mut way, &BEND_WAY_LABELS);
*other = way == 1;
}
if let Some(n) = drop {
then.remove(n);
}
crate::ui_kit::section(ui, "flange_advanced", "Advanced", false, |ui| {
enter |= hint_row(ui, "Bend Radius", radius, crate::i18n::tr_label("from the rule"));
// The relief at the corners these flanges make: the rule's unless set here.
choice_row(ui, "Corner Relief Shape", "sm_flange_relief", relief, &FLANGE_RELIEF_LABELS);
enter |= hint_row(ui, "Corner Relief", relief_size, crate::i18n::tr_label("from the rule"));
// With several edges, a row for each: an angle and a height of its own, left
// empty for the values above (shown as the hints).
let points = edge_point_list(inputs);
if points.len() > 1 || own.iter().any(|o| !(o.1.trim().is_empty() && o.2.trim().is_empty())) {
form_row(ui, "Per Edge", |ui| {
ui.label(RichText::new(crate::i18n::tr_label("angle, height")).weak())
.on_hover_text("An edge's own angle and height. Empty: the values above.");
});
for (n, p) in points.iter().enumerate() {
let slot = own_slot(own, *p);
let Some((_, a, h)) = own.get_mut(slot) else { continue };
form_row(ui, &format!("Edge {}", n + 1), |ui| {
ui.horizontal(|ui| {
let w = ((ui.available_width() - ui.spacing().item_spacing.x) / 2.0).max(0.0);
for (text, hint, what, id) in
[(a, angle.as_str(), "angle", "sm_edge_angle"), (h, height.as_str(), "height", "sm_edge_height")]
{
ui.push_id((id, n), |ui| {
ui.allocate_ui_with_layout(
vec2(w, Tokens::get().control_height),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
enter |= crate::ui_kit::hint_field(ui, text, hint);
},
);
let at = ui.min_rect().center();
crate::scenario::publish_handle(&format!("dialog:Edge {} {what}", n + 1), at);
});
}
});
});
}
}
});
}
2 => {
enter |= expr_row(ui, "Distance", distance);
rule_combo(app, ui, "sm_rule", rule);
}
_ => rule_combo(app, ui, "sm_rule", rule),
}
if *ty == 2 {
crate::ui_kit::options(ui, "sheet_options", &mut [("Flip", flip), ("Other side", reverse)]);
} else {
crate::ui_kit::options(ui, "sheet_options", &mut [("Flip", flip)]);
}
}
Sm::Perforate { diameter, pitch, margin, pattern } => {
enter |= expr_row(ui, "ui.diameter", diameter);
enter |= expr_row(ui, "ui.perforate_pitch", pitch);
enter |= hint_row(ui, "Margin", margin, crate::i18n::tr_label("ui.perforate_margin_default"));
choice_row(ui, "Pattern", "sm_perforate_pattern", pattern, &PERFORATION_LABELS);
}
Sm::Hem { length, gap, flip } => {
form_row(ui, "Type", |ui| {
ui.label(crate::i18n::tr_label("Flat"));
});
enter |= expr_row(ui, "Length", length);
enter |= hint_row(ui, "ui.sheet_gap", gap, crate::i18n::tr_label("from the rule"));
crate::ui_kit::options(ui, "sheet_options", &mut [("Flip", flip)]);
}
Sm::Fold { angle, radius, position, flip } => {
choice_row(ui, "Bend Line Position", "sm_fold_pos", position, &FOLD_POSITION_LABELS);
enter |= expr_row(ui, "Angle", angle);
enter |= hint_row(ui, "Bend Radius", radius, crate::i18n::tr_label("from the rule"));
crate::ui_kit::options(ui, "sheet_options", &mut [("Flip", flip)]);
}
Sm::Path { radius } => {
path_chain(app, inputs);
// What the path makes: a flange per line, as long as the line (the sketch's lengths).
let lengths = path_lengths(app, inputs);
form_row(ui, "Flanges", |ui| {
ui.label(if lengths.is_empty() {
crate::i18n::tr_label("pick the path").to_string()
} else {
let each: Vec<String> = lengths.iter().map(|l| format!("{l:.1}")).collect();
format!("{} mm", each.join(" · "))
});
});
crate::ui_kit::caption(ui, "Flanges", crate::i18n::tr_label("set by the sketch's lines"));
enter |= hint_row(ui, "Bend Radius", radius, crate::i18n::tr_label("from the rule"));
}
Sm::Unfold { .. } => {}
Sm::Convert { rule } => rule_combo(app, ui, "sm_conv_rule", rule),
Sm::Rules { pick, name, values, relief, angles, active, loaded } => {
let rules = rule_list(app);
crate::rule_editor::rule_editor! {
ui, "sm_rules", rules, pick, name, active, loaded;
new_name: format!("Rule{}", rules.len() + 1),
load: {
// A new rule starts from the first rule.
let base = rules.get(*pick).cloned().unwrap_or_else(|| rules.first().cloned().unwrap_or_else(SheetRule::steel));
*values = vec![
crate::length_input::stored(&app.session.doc, &base.thickness),
base.k_factor.clone(),
crate::length_input::stored(&app.session.doc, &base.bend_radius),
crate::length_input::stored(&app.session.doc, &base.relief_width),
crate::length_input::stored(&app.session.doc, &base.relief_depth),
crate::length_input::stored(&app.session.doc, &base.corner_relief),
crate::length_input::stored(&app.session.doc, &base.hem_gap),
crate::length_input::stored(&app.session.doc, &base.gap),
];
*relief = RELIEF_SHAPES.iter().position(|s| s.eq_ignore_ascii_case(base.corner_relief_shape.trim())).unwrap_or(0);
*angles = ANGLE_DISPLAYS.iter().position(|d| d.eq_ignore_ascii_case(base.angle_display.trim())).unwrap_or(0);
*active = app.session.doc.sheet_rule(None).name == base.name || *pick >= rules.len();
},
fields: {
for ((key, label), v) in RULE_FIELDS.iter().zip(values.iter_mut()) {
if *key == "corner_relief" {
// The shape goes with its size, the row below.
choice_row(ui, "Corner Relief Shape", "sm_relief_shape", relief, &RELIEF_SHAPE_LABELS);
}
enter |= expr_row(ui, label, v);
}
choice_row(ui, "Angle Display", "sm_angle_display", angles, &ANGLE_DISPLAY_LABELS);
}
}
if *pick < rules.len()
&& !app.session.doc.sheet.rules.is_empty()
&& crate::ui_kit::button(ui, crate::i18n::tr_label("Delete rule"), crate::ui_kit::Button::Normal).clicked()
{
let n = rules.get(*pick).map(|r| r.name.clone()).unwrap_or_default();
match app.run("sheet.manage_rules", json!({"name": n, "delete": true})) {
Ok(_) => {
*pick = 0;
*loaded = None;
}
Err(e) => app.set_status(e, true),
}
}
}
Sm::FlatPattern { data, key, status } => {
let body = inputs.first().and_then(|i| i.items.first()).and_then(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None });
let want = (app.session.revision, body.clone());
if key.as_ref() != Some(&want) {
let mut p = json!({});
if let Some(b) = &body {
p["body"] = json!(b);
}
*data = Some(app.session.execute("sheet.flat_pattern", &p).map_err(|e| e.to_string()));
*key = Some(want);
}
match data {
Some(Ok(v)) => {
let size = &v["flat_size_mm"];
form_row(ui, "Body", |ui| {
ui.label(v["body"].as_str().unwrap_or(""));
});
form_row(ui, "Flat size", |ui| {
ui.label(format!(
"{} × {} × {}",
crate::prefs::show_mm(app, size[0].as_f64().unwrap_or(0.0), 1),
crate::prefs::show_mm(app, size[1].as_f64().unwrap_or(0.0), 1),
crate::prefs::show_mm(app, size[2].as_f64().unwrap_or(0.0), 1)
));
});
let bends = v["bends"].as_array().cloned().unwrap_or_default();
form_row(ui, "Bends", |ui| {
ui.label(format!("{}", bends.len()));
});
for b in bends.iter().take(50) {
let up = b["direction"] == "up";
let (up_col, down_col) = bend_colors();
form_row(ui, &format!(" Bend {}", b["bend"].as_u64().unwrap_or(0)), |ui| {
ui.label(
RichText::new(format!(
"{} {:.1}° R{}",
if up { "Up" } else { "Down" },
b["angle_deg"].as_f64().unwrap_or(0.0),
crate::prefs::show_mm(app, b["radius"].as_f64().unwrap_or(0.0), 1)
))
.color(if up { up_col } else { down_col }),
);
});
}
ui.vertical(|ui| {
if crate::ui_kit::button(ui, crate::i18n::tr_label("Export DXF…"), crate::ui_kit::Button::Normal).clicked() {
*status = Some(export_flat(app, v["body"].as_str().unwrap_or(""), "dxf"));
}
});
ui.vertical(|ui| {
if crate::ui_kit::button(ui, crate::i18n::tr_label("Export Bend Table…"), crate::ui_kit::Button::Normal).clicked() {
*status = Some(export_flat(app, v["body"].as_str().unwrap_or(""), "csv"));
}
});
if let Some(s) = status {
ui.vertical(|ui| {
ui.add(egui::Label::new(RichText::new(s.as_str()).color(t.text_dim)).wrap());
});
}
}
Some(Err(e)) => {
ui.vertical(|ui| {
ui.add(egui::Label::new(RichText::new(e.as_str()).color(t.error)).wrap());
});
}
None => {}
}
}
}
enter
}
fn export_flat(app: &mut SolveApp, body: &str, extension: &str) -> String {
let name = format!("{}-{body}.{extension}", app.session.doc.name);
let body = body.to_string();
let command = if extension == "csv" { "sheet.export_bend_table" } else { "sheet.export_dxf" };
app.pick_save(&name, &[extension], move |app, path| {
let message = if let Some(path) = path {
match app.run(command, json!({"body": body, "path": path})) {
Ok(_) => {
app.set_status(format!("Exported {path}"), false);
format!("Saved {path}")
}
Err(e) => e,
}
} else {
"Export cancelled".into()
};
if let Some(d) = app.dialog.as_mut()
&& let Kind::Sheet(Sm::FlatPattern { status, .. }) = &mut d.kind
{
*status = Some(message);
}
});
"Choose an export file…".into()
}
// ---- commands ----
fn rule_value(app: &SolveApp, rule: usize) -> Option<String> {
rule.checked_sub(1).and_then(|i| rule_list(app).get(i).map(|r| r.name.clone()))
}
/// A path flange's path is a chain: a line picked into Path brings every line joined to it end
/// to end, so one click takes the whole path.
fn path_chain(app: &SolveApp, inputs: &mut [SelInput]) {
let edge = inputs.first().and_then(|i| i.items.edge_points().first().copied());
let Some(input) = inputs.get_mut(1) else { return };
let st = app.session.world_state();
// The path is in the sketch its picks name (#3726).
let Some(ss) = crate::dialogs::picks_sketch(app, &input.items, None).and_then(|k| st.sketch(k)) else { return };
let mut ids: Vec<String> = Vec::new();
for id in input.items.curve_ids() {
let chain = match ss.sketch.curve_index(&id) {
Some(ci) => {
ss.sketch.chain(ci).into_iter().filter_map(|c| ss.sketch.curves.get(c)).filter(|c| !c.construction).map(|c| c.id.clone()).collect()
}
None => vec![id],
};
for id in chain {
if !ids.contains(&id) {
ids.push(id);
}
}
}
// In order along the path, so the flanges read from the edge out.
if let Ok(mut order) = ss.chain_order(&ids) {
// From the end nearer the picked edge.
let near = |id: Option<&String>| {
let segs = id.and_then(|id| ss.sketch.curve_index(id)).map(|ci| ss.sketch.segs(ci)).unwrap_or_default();
let ends = [segs.first().map(|s| s.start()), segs.last().map(|s| s.end())];
ends.into_iter().flatten().map(|p| edge.map_or(0.0, |e| ss.plane.to_world(p).dist(e))).fold(f64::INFINITY, f64::min)
};
if near(order.last()) < near(order.first()) {
order.reverse();
}
ids = order;
}
let chained: Vec<Sel> = ids.iter().map(|id| crate::selection::curve_pick(id, ss.feature, app.session.active_sketch)).collect();
if chained != input.items {
input.items = chained;
}
}
/// The lengths of the path's lines, in the order picked (mm).
fn path_lengths(app: &SolveApp, inputs: &[SelInput]) -> Vec<f64> {
let st = app.session.world_state();
let picks = items(inputs, 1);
let Some(ss) = crate::dialogs::picks_sketch(app, picks, None).and_then(|k| st.sketch(k)) else { return Vec::new() };
picks
.curve_ids()
.iter()
.filter_map(|id| {
let ci = ss.sketch.curve_index(id)?;
Some(ss.sketch.segs(ci).iter().map(|s| s.start().dist(s.end())).sum())
})
.collect()
}
fn edge_points(inputs: &[SelInput]) -> Vec<Value> {
items(inputs, 0).edge_points().into_iter().map(pt).collect()
}
/// The picked edges' points.
fn edge_point_list(inputs: &[SelInput]) -> Vec<Vec3> {
items(inputs, 0).edge_points()
}
/// Where the own angle and height of the edge picked at `p` are kept (an empty entry on first use).
fn own_slot(own: &mut Vec<(Vec3, String, String)>, p: Vec3) -> usize {
own.iter().position(|o| o.0.dist(p) < 1e-9).unwrap_or_else(|| {
own.push((p, String::new(), String::new()));
own.len() - 1
})
}
/// The edges for `sheet.flange`: a plain point, or `{point, angle?, height?}` for an edge with
/// an angle and/or a height of its own.
fn flange_edges(inputs: &[SelInput], own: &[(Vec3, String, String)]) -> Vec<Value> {
edge_point_list(inputs)
.into_iter()
.map(|p| {
let (a, h) = own.iter().find(|o| o.0.dist(p) < 1e-9).map(|o| (o.1.trim(), o.2.trim())).unwrap_or(("", ""));
if a.is_empty() && h.is_empty() {
return pt(p);
}
let mut e = json!({"point": pt(p)});
for (k, v) in [("angle", a), ("height", h)] {
if !v.is_empty() {
e[k] = json!(v);
}
}
e
})
.collect()
}
/// The commands the dialog's OK runs (`extra`: parameters kept from the feature being edited).
pub fn commands(app: &SolveApp, k: &Sm, inputs: &[SelInput], extra: &Map<String, Value>) -> Result<Vec<(String, Value)>, String> {
let s = &app.session;
let (cmd, mut p): (&str, Value) = match k {
Sm::Flange { height, angle, radius, position, height_from, flip, distance, reverse, rule, own, relief, relief_size, then, .. } => {
let mut p = match flange_type(inputs) {
1 => {
let mut p = json!({"type": "edge", "edges": flange_edges(inputs, own), "height": height, "angle": angle,
"position": POSITIONS.get(*position).copied().unwrap_or("inside")});
put(&mut p, &[("radius", radius)]);
if let Some(from) = HEIGHT_FROM.get(*height_from).filter(|_| *height_from > 0) {
p["height_from"] = json!(from);
}
if let Some(shape) = relief.checked_sub(1).and_then(|i| RELIEF_SHAPES.get(i)) {
p["corner_relief_shape"] = json!(shape);
}
put(&mut p, &[("corner_relief", relief_size)]);
if !then.is_empty() {
let mut bends = Vec::with_capacity(then.len());
for (n, (a, h, other)) in then.iter().enumerate() {
if h.trim().is_empty() {
return Err(format!("bend {} needs a height", n + 2));
}
let mut b = json!({"height": h});
put(&mut b, &[("angle", a)]);
// The bend's own side: the flange's, or the other one.
if *other {
b["flip"] = json!(!*flip);
}
bends.push(b);
}
p["then"] = json!(bends);
}
p
}
2 => {
let ids: Vec<String> = items(inputs, 0).curve_ids();
let st = s.world_state();
let sketch = items(inputs, 0)
.named_sketch()
.or_else(|| st.sketches.iter().rev().find(|ss| ids.iter().all(|id| ss.sketch.curve_index(id).is_some())).map(|ss| ss.feature))
.ok_or("pick lines of one sketch")?;
json!({"type": "contour", "sketch": sketch, "curves": ids, "distance": distance, "reverse": reverse})
}
_ => {
let ps: Vec<(u64, usize)> = items(inputs, 0).profiles();
let sketch = ps.first().map(|x| x.0).ok_or("select a profile, edges or sketch lines first")?;
let idx: Vec<usize> = ps.iter().filter(|x| x.0 == sketch).map(|x| x.1).collect();
json!({"type": "base", "sketch": sketch, "profiles": idx})
}
};
p["flip"] = json!(flip);
if let Some(r) = rule_value(app, *rule).filter(|_| p["type"] != "edge") {
p["rule"] = json!(r);
}
("sheet.flange", p)
}
Sm::Hem { gap, .. } => {
let edges = edge_points(inputs);
if edges.is_empty() {
return Err("select sheet edges first".into());
}
let mut p = json!({"edges": edges});
put(&mut p, &[("gap", gap)]);
("sheet.hem", p)
}
Sm::Fold { radius, .. } => {
let mut p = json!({});
match items(inputs, 0).first() {
Some(Sel::SketchCurve { id, sketch: named }) => {
let st = s.world_state();
let sketch = named
.or_else(|| st.sketches.iter().rev().find(|ss| ss.sketch.curve_index(id).is_some()).map(|ss| ss.feature))
.ok_or("the line's sketch is gone")?;
p["sketch"] = json!(sketch);
p["curve"] = json!(id);
}
// An edited fold made from two points keeps them (in `extra`).
_ if extra.contains_key("points") => {}
_ => return Err("select the bend line (a sketch line) first".into()),
}
put(&mut p, &[("radius", radius)]);
if let Some(Sel::Face { point, .. }) = items(inputs, 1).first() {
p["fixed"] = pt(*point);
}
("sheet.fold", p)
}
Sm::Path { radius } => {
let edge = edge_points(inputs).into_iter().next().ok_or("select the sheet edge first")?;
let picks = items(inputs, 1);
let curves = picks.curve_ids();
if curves.is_empty() {
return Err("select the path (sketch lines across the edge)".into());
}
let sketch = crate::dialogs::picks_sketch(app, picks, None).ok_or("the path's sketch is gone")?;
let mut p = json!({"edge": edge, "sketch": sketch, "curves": curves});
put(&mut p, &[("radius", radius)]);
("sheet.path_flange", p)
}
Sm::Perforate { margin, .. } => {
let mut p = json!({});
put(&mut p, &[("margin", margin)]);
match items(inputs, 0).first() {
Some(Sel::Body { name }) => p["body"] = json!(name),
Some(Sel::Face { body, .. }) => p["body"] = json!(body),
_ => {}
}
("sheet.perforate", p)
}
Sm::Unfold { refold } => {
let mut p = json!({});
if let Some(Sel::Body { name }) = items(inputs, 0).first() {
p["body"] = json!(name);
}
(if *refold { "sheet.refold" } else { "sheet.unfold" }, p)
}
Sm::Convert { rule } => {
let Some(Sel::Face { body, point, .. }) = items(inputs, 0).first() else {
return Err("select the fixed face first (a plate's large face)".into());
};
let mut p = json!({"body": body, "face": pt(*point)});
// The sharp edges of a solid or shelled body that become bends (a plate has none).
let bends: Vec<Value> = items(inputs, 1).edge_points().into_iter().map(pt).collect();
if !bends.is_empty() {
p["bends"] = json!(bends);
}
if let Some(r) = rule_value(app, *rule) {
p["rule"] = json!(r);
}
("sheet.convert", p)
}
Sm::Rules { pick, name, values, relief, angles, active, .. } => {
let rules = rule_list(app);
let fields = RULE_FIELDS.iter().map(|(key, _)| *key).zip(values);
let mut p = crate::rule_editor::params(rules.get(*pick).map(|r| r.name.as_str()), name, *active, fields)?;
p["corner_relief_shape"] = json!(RELIEF_SHAPES.get(*relief).copied().unwrap_or("notch"));
p["angle_display"] = json!(ANGLE_DISPLAYS.get(*angles).copied().unwrap_or("bend"));
("sheet.manage_rules", p)
}
Sm::FlatPattern { .. } => return Ok(Vec::new()),
};
k.fill_simple_params(&mut p);
if let Value::Object(m) = &mut p {
for (k, v) in extra {
m.entry(k.clone()).or_insert_with(|| v.clone());
}
}
Ok(vec![(cmd.to_string(), p)])
}
/// The dialog editing a sheet metal feature, filled from it.
pub fn for_feature(app: &SolveApp, kind: &FeatureKind) -> Option<(Kind, Vec<SelInput>, Map<String, Value>)> {
let s = &app.session;
let st = s.world_state();
let rule_index = |r: &Option<String>| r.as_ref().and_then(|n| rule_list(app).iter().position(|x| &x.name == n)).map_or(0, |i| i + 1);
let mut extra = Map::new();
let (k, items): (Sm, Vec<Sel>) = match kind {
FeatureKind::SheetBase { sketch, profiles, rule, flip } => {
let ps = st.sketch(sketch.0).map(|ss| profile_indices(ss, profiles)).unwrap_or_default();
let mut f = new_flange(app, 0);
if let Sm::Flange { flip: fl, rule: r, .. } = &mut f {
*fl = *flip;
*r = rule_index(rule);
}
(f, ps.into_iter().map(|index| Sel::Profile { sketch: sketch.0, index }).collect())
}
FeatureKind::SheetContour { sketch, curves, distance, rule, flip, reverse, .. } => {
let mut f = new_flange(app, 2);
if let Sm::Flange { flip: fl, rule: r, distance: d, reverse: rv, .. } = &mut f {
*fl = *flip;
*r = rule_index(rule);
*d = distance.to_string();
*rv = *reverse;
}
(f, curves.iter().map(|id| crate::selection::curve_pick(id, sketch.0, app.session.active_sketch)).collect())
}
FeatureKind::SheetFlange { edges, height, angle, radius, position, flip, body, corner_relief_shape, corner_relief, height_from } => {
if let Some(b) = body {
extra.insert("body".into(), json!(b));
}
// The edges, and the angle and height some have of their own (kept by the point the
// edge's selection carries).
let (mut picked, mut own) = (Vec::new(), Vec::new());
for e in edges {
let Some(sel) = edge_sel(s, e.point.0) else { continue };
if let (Sel::Edge { point, .. }, true) = (&sel, e.angle.is_some() || e.height.is_some()) {
own.push((
*point,
e.angle.as_deref().map(str::to_string).unwrap_or_default(),
e.height.as_deref().map(str::to_string).unwrap_or_default(),
));
}
picked.push(sel);
}
let f = Sm::Flange {
ty: 1,
height: height.to_string(),
angle: angle.to_string(),
radius: radius.as_deref().map(str::to_string).unwrap_or_default(),
position: POSITIONS.iter().position(|p| p == position).unwrap_or(0),
height_from: height_from
.as_deref()
.and_then(|name| HEIGHT_FROM.iter().position(|h| h.eq_ignore_ascii_case(name.trim())))
.unwrap_or(0),
flip: *flip,
distance: crate::dialogs::length_default(&app.session, "20"),
reverse: false,
rule: 0,
own,
relief: corner_relief_shape
.as_deref()
.and_then(|name| RELIEF_SHAPES.iter().position(|s| s.eq_ignore_ascii_case(name.trim())))
.map_or(0, |i| i + 1),
relief_size: corner_relief.as_deref().map(str::to_string).unwrap_or_default(),
then: Vec::new(),
};
(f, picked)
}
FeatureKind::SheetHem { edges, body, .. } => {
if let Some(b) = body {
extra.insert("body".into(), json!(b));
}
(Sm::simple_restore(kind)?, edges.iter().filter_map(|p| edge_sel(s, p.0)).collect())
}
FeatureKind::SheetFold { sketch, curve, a, b, fixed, body, .. } => {
if let Some(bd) = body {
extra.insert("body".into(), json!(bd));
}
let k = Sm::simple_restore(kind)?;
let (_, mut ins) = start(app, "sheet.fold")?;
match curve {
Some(c) => {
if let Some(i) = ins.first_mut() {
i.items = vec![match sketch {
Some(k) => crate::selection::curve_pick(c, k.0, app.session.active_sketch),
None => Sel::SketchCurve { id: c.clone(), sketch: None },
}];
}
}
// A fold given by two points keeps them.
None => {
extra.insert("points".into(), json!([pt(a.0), pt(b.0)]));
}
}
if let Some(i) = ins.get_mut(1) {
i.items = fixed.and_then(|f| face_sel(s, f.0)).into_iter().collect();
}
return Some((Kind::Sheet(k), ins, extra));
}
FeatureKind::SheetPath { edge, sketch, curves, body, .. } => {
if let Some(bd) = body {
extra.insert("body".into(), json!(bd));
}
let k = Sm::simple_restore(kind)?;
let (_, mut ins) = start(app, "sheet.path_flange")?;
if let Some(i) = ins.first_mut() {
i.items = edge_sel(s, edge.0).into_iter().collect();
}
if let Some(i) = ins.get_mut(1) {
i.items = curves.iter().map(|id| crate::selection::curve_pick(id, sketch.0, app.session.active_sketch)).collect();
}
return Some((Kind::Sheet(k), ins, extra));
}
FeatureKind::SheetPerforate { body, .. } => (Sm::simple_restore(kind)?, body.iter().map(|n| Sel::Body { name: n.to_string() }).collect()),
FeatureKind::SheetUnfold { body, refold } => {
(Sm::Unfold { refold: *refold }, body.iter().map(|n| Sel::Body { name: n.to_string() }).collect())
}
FeatureKind::SheetConvert { face, rule, bends, .. } => {
let (_, mut ins) = start(app, "sheet.convert")?;
if let Some(i) = ins.first_mut() {
i.items = face_sel(s, face.0).into_iter().collect();
}
if let Some(i) = ins.get_mut(1) {
i.items = bends.iter().filter_map(|p| edge_sel(s, p.0)).collect();
}
return Some((Kind::Sheet(Sm::Convert { rule: rule_index(rule) }), ins, extra));
}
_ => return None,
};
let id = match &k {
Sm::Flange { .. } => "sheet.flange",
Sm::Hem { .. } => "sheet.hem",
Sm::Perforate { .. } => "sheet.perforate",
Sm::Unfold { refold: false } => "sheet.unfold",
Sm::Unfold { .. } => "sheet.refold",
_ => "sheet.convert",
};
let (_, mut inputs) = start(app, id)?;
if let Some(i) = inputs.first_mut() {
i.items = items;
}
// Profiles stay a profile selection (`All` keeps them all).
if let (FeatureKind::SheetBase { profiles: ProfileSel::All, .. }, Some(i)) = (kind, inputs.first())
&& i.items.is_empty()
{
extra.insert("profiles".into(), json!("all"));
}
Some((Kind::Sheet(k), inputs, extra))
}
// ---- view ----
/// The direction an edge flange grows from its first edge: out of the sheet's larger
/// neighbouring face (flipped with Flip). A hem's handle runs along the hem instead
/// ([`hem_handle`]).
pub fn arrow(app: &SolveApp, d: &Dialog) -> Option<Vec3> {
let Kind::Sheet(k) = &d.kind else { return None };
let flip = match k {
Sm::Flange { ty: 1, flip, .. } => *flip,
Sm::Hem { .. } => return hem_handle(app, d).map(|(_, dir)| dir),
_ => return None,
};
let (n, _, _) = edge_frame(app, d)?;
Some(if flip { -n } else { n })
}
/// The sheet at the dialog's first picked edge: the unit normal of the larger neighbouring face
/// (out of the sheet), the unit normal of the other neighbour (the edge's end face, pointing away
/// from the sheet), and the sheet's thickness along the first.
fn edge_frame(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Vec3, f64)> {
let Sel::Edge { body, index, point } = d.inputs.first()?.items.first()? else { return None };
let st = app.session.world_state();
let m = st.body(body)?.mesh();
let faces = m.edge_faces.get(*index)?;
let area = |f: u32| -> f64 {
m.triangles
.iter()
.zip(&m.tri_face)
.filter(|(_, tf)| **tf == f)
.filter_map(|(t, _)| m.tri(t))
.map(|[a, b, c]| (b - a).cross(c - a).len() * 0.5)
.sum()
};
let normal = |f: u32| -> Option<Vec3> {
m.triangles
.iter()
.zip(&m.tri_face)
.filter(|(_, tf)| **tf == f)
.filter_map(|(t, _)| m.tri(t))
.min_by(|a, b| ((a[0] + a[1] + a[2]) / 3.0).dist(*point).total_cmp(&((b[0] + b[1] + b[2]) / 3.0).dist(*point)))
.and_then(|[a, b, c]| (b - a).cross(c - a).normalized())
};
let f = faces.iter().copied().max_by(|a, b| area(*a).total_cmp(&area(*b)))?;
let g = faces.iter().copied().find(|g| *g != f)?;
let (n, end) = (normal(f)?, normal(g)?);
// The end face spans the sheet's thickness along the normal.
let heights = m.triangles.iter().zip(&m.tri_face).filter(|(_, tf)| **tf == g).filter_map(|(t, _)| m.tri(t)).flatten().map(|v| v.dot(n));
let (lo, hi) = heights.fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), h| (lo.min(h), hi.max(h)));
let thickness = hi - lo;
(thickness.is_finite() && thickness > 0.0).then_some((n, end, thickness))
}
/// Where a hem's handle starts and where it points (#5828). Its Length is measured from the outer
/// face of the fold to the hem's tip, so the handle starts on the centre line of the hem layer at
/// that face and runs along the hem toward the tip: square to the picked edge, back over the sheet.
/// The layer lies on the far side of the sheet from the larger face unless flipped. The Gap is
/// taken from the dialog when it holds a number; otherwise the layer sits flat against the sheet.
pub fn hem_handle(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Vec3)> {
let Kind::Sheet(Sm::Hem { gap, flip, .. }) = &d.kind else { return None };
let Sel::Edge { point, .. } = d.inputs.first()?.items.first()? else { return None };
let (n, end, thickness) = edge_frame(app, d)?;
let gap = app.session.doc.eval(gap, ValueKind::Length).ok().filter(|g| g.is_finite() && *g >= 0.0).unwrap_or(0.0);
// The hem's side of the sheet, as a unit vector along the larger face's normal, and the
// distance of the layer's centre line from the face the edge lies on.
let (side, depth) = if *flip { (n, gap + thickness / 2.0) } else { (-n, thickness + gap + thickness / 2.0) };
let start = *point + end * (thickness + gap) + side * depth;
Some((start, -end))
}
/// Bend line colours: up and down (theme tokens, legible on either theme and in every colour
/// vision mode).
fn bend_colors() -> (Color32, Color32) {
let t = crate::theme::Tokens::get();
(t.bend_up, t.bend_down)
}
/// The flat pattern view: outline, cut-outs, perforations and bend lines (up and down in
/// their colours), fitted over the viewport. True when the dialog is a flat pattern.
pub fn overlay(app: &mut SolveApp, painter: &egui::Painter, rect: Rect, d: &Dialog) -> bool {
let Kind::Sheet(Sm::FlatPattern { data, .. }) = &d.kind else { return false };
let t = Tokens::get();
let (up_col, down_col) = bend_colors();
painter.rect_filled(rect, 0.0, t.panel);
let Some(Ok(v)) = data else {
painter.text(
rect.center(),
Align2::CENTER_CENTER,
"no sheet metal body",
FontId::proportional(crate::theme::Tokens::get().font_heading),
t.text_dim,
);
return true;
};
let read = |p: &Value| -> Option<(f64, f64)> { Some((p.get(0)?.as_f64()?, p.get(1)?.as_f64()?)) };
let loops: Vec<Vec<(f64, f64)>> =
v["outline"].as_array().into_iter().flatten().map(|l| l.as_array().into_iter().flatten().filter_map(read).collect()).collect();
let holes: Vec<Vec<(f64, f64)>> =
v["cutouts"].as_array().into_iter().flatten().map(|l| l.as_array().into_iter().flatten().filter_map(read).collect()).collect();
let mut lo = (f64::INFINITY, f64::INFINITY);
let mut hi = (f64::NEG_INFINITY, f64::NEG_INFINITY);
for p in loops.iter().flatten() {
lo = (lo.0.min(p.0), lo.1.min(p.1));
hi = (hi.0.max(p.0), hi.1.max(p.1));
}
if !(lo.0.is_finite() && hi.0 > lo.0 && hi.1 > lo.1) {
return true;
}
// Fit all retained islands to the exposed viewport. The command panel can grow
// to its width limit, so its actual edge, rather than a fixed reserve, bounds the view.
let panel_left = painter
.ctx()
.memory(|m| m.area_rect(egui::Id::new(("sc_dialog", "FLAT PATTERN"))))
.map(|panel| panel.left())
.unwrap_or(rect.right() - crate::frame::DIALOG_MAX_W);
let content = crate::shell::content_rect(app, rect);
let area = Rect::from_min_max(content.min + vec2(40.0, 60.0), pos2(panel_left.min(content.right()) - 20.0, content.bottom() - 60.0));
if area.width() <= 0.0 || area.height() <= 0.0 {
return true;
}
if !app.flat_view.fitted {
app.flat_view.fit(rect, area, lo, hi);
}
let cam = app.flat_view.cam;
let scale = f64::from(rect.height()) / (2.0 * cam.half_height());
let ox = f64::from(rect.center().x) - cam.target.x * scale;
let oy = f64::from(rect.center().y) + cam.target.y * scale;
let to = |p: (f64, f64)| -> Pos2 { pos2((ox + p.0 * scale) as f32, (oy - p.1 * scale) as f32) };
for l in &loops {
let pts: Vec<Pos2> = l.iter().map(|p| to(*p)).collect();
if pts.len() >= 3 {
painter.add(egui::Shape::closed_line(pts, Stroke::new(1.8, t.text)));
}
}
for h in &holes {
let pts: Vec<Pos2> = h.iter().map(|p| to(*p)).collect();
if pts.len() >= 2 {
painter.add(egui::Shape::closed_line(pts, Stroke::new(1.4, t.text)));
}
}
if let Some(body) = v["body"].as_str() {
app.flat_view.cache_perforations(&app.session, body);
let clip = rect.intersect(painter.clip_rect());
let pixels_per_point = painter.ctx().pixels_per_point();
for &(centre, radius) in &app.flat_view.perforations {
let radius = (radius * scale) as f32;
// Egui uses logical points; reject holes smaller than one physical pixel.
if !radius.is_finite() || radius * 2.0 * pixels_per_point < 1.0 {
continue;
}
let centre = to((centre.x, centre.y));
if centre.x.is_finite() && centre.y.is_finite() && clip.intersects(Rect::from_center_size(centre, vec2(radius * 2.0, radius * 2.0))) {
painter.circle_stroke(centre, radius, Stroke::new(1.4, t.text));
}
}
}
// A pocket retains material below (or above) the cut. Dashed contours and a depth
// annotation distinguish it from the solid through-cut boundaries.
let pockets: Vec<&Value> = v["pockets"].as_array().into_iter().flatten().collect();
let mut pocket_annotations: Vec<(Pos2, Vec<String>)> = Vec::new();
for pocket in &pockets {
let outer: Vec<(f64, f64)> = pocket["outline"].as_array().into_iter().flatten().filter_map(read).collect();
for contour in std::iter::once(&pocket["outline"]).chain(pocket["cutouts"].as_array().into_iter().flatten()) {
let mut pts: Vec<Pos2> = contour.as_array().into_iter().flatten().filter_map(read).map(to).collect();
if pts.len() >= 3 {
pts.push(pts[0]);
painter.extend(egui::Shape::dashed_line(&pts, Stroke::new(1.6, t.accent), 3.0, 3.0));
}
}
if !outer.is_empty() {
let bounds = outer.iter().map(|p| to(*p)).fold(Rect::NOTHING, |r, p| r.union(Rect::from_min_max(p, p)));
let anchor = bounds.center_top() - vec2(0.0, 6.0);
if let Some(label) = pocket_label(app, pocket) {
if let Some((_, labels)) = pocket_annotations.iter_mut().find(|(at, _)| at.distance(anchor) < 1.0) {
if !labels.contains(&label) {
labels.push(label);
}
} else {
pocket_annotations.push((anchor, vec![label]));
}
}
}
}
for (anchor, labels) in pocket_annotations {
painter.text(anchor, Align2::CENTER_BOTTOM, labels.join("\n"), FontId::proportional(crate::theme::Tokens::get().font_body), t.accent);
}
for b in v["bends"].as_array().into_iter().flatten() {
let (Some(a), Some(e)) = (read(&b["start"]), read(&b["end"])) else { continue };
let col = if b["direction"] == "up" { up_col } else { down_col };
painter.extend(egui::Shape::dashed_line(&[to(a), to(e)], Stroke::new(1.6, col), 8.0, 5.0));
}
// Legend.
let mut y = rect.top() + 14.0;
painter.text(
pos2(rect.left() + 14.0, y),
Align2::LEFT_TOP,
"FLAT PATTERN",
FontId::proportional(crate::theme::Tokens::get().font_button),
t.text,
);
for (label, col) in [("Bend up", up_col), ("Bend down", down_col)] {
y += 20.0;
painter.line_segment([pos2(rect.left() + 14.0, y + 7.0), pos2(rect.left() + 38.0, y + 7.0)], Stroke::new(2.0, col));
painter.text(pos2(rect.left() + 44.0, y), Align2::LEFT_TOP, label, FontId::proportional(crate::theme::Tokens::get().font_body), t.text_dim);
}
if !pockets.is_empty() {
y += 20.0;
painter.extend(egui::Shape::dashed_line(
&[pos2(rect.left() + 14.0, y + 7.0), pos2(rect.left() + 38.0, y + 7.0)],
Stroke::new(1.6, t.accent),
3.0,
3.0,
));
painter.text(
pos2(rect.left() + 44.0, y),
Align2::LEFT_TOP,
"Pocket boundary (material remains)",
FontId::proportional(crate::theme::Tokens::get().font_body),
t.text_dim,
);
}
true
}
/// The flat pattern's own 2D view: a top-down orthographic camera over the flat plane (x right,
/// y up, millimetres), so the shared navigation moves it like any other camera. The Design
/// camera is left alone while this has the viewport.
pub struct FlatView {
pub cam: solidcraft_engine::render::Camera,
/// The camera frames the pattern; cleared by Fit and Home, and whenever the dialog is closed.
pub fitted: bool,
/// Flat centres stay out of the command JSON and are reused while navigating.
perforation_key: Option<(std::sync::Weak<solidcraft_engine::doc::ModelState>, String)>,
perforations: Vec<(Vec2, f64)>,
}
impl Default for FlatView {
fn default() -> Self {
let mut cam = solidcraft_engine::render::Camera::default();
cam.set_view(solidcraft_engine::render::StandardView::Top);
cam.fov = 0.0;
cam.up = solidcraft_engine::render::UpAxis::Z;
FlatView { cam, fitted: false, perforation_key: None, perforations: Vec::new() }
}
}
impl FlatView {
fn cache_perforations(&mut self, session: &solidcraft_engine::Session, body: &str) {
let state = session.world_state();
let state_key = std::sync::Arc::downgrade(&state);
if self.perforation_key.as_ref().is_some_and(|(cached, name)| cached.ptr_eq(&state_key) && name == body) {
return;
}
self.perforation_key = Some((state_key, body.to_owned()));
self.perforations.clear();
let Some(sheet) = state.sheets.iter().find(|sheet| sheet.body == body) else { return };
// Bound overlay storage and drawing work, including designs with many fields.
const MAX_HOLES: usize = 1_000_000;
for field in &sheet.perforations {
if self.perforations.len() >= MAX_HOLES {
break;
}
if !field.diameter.is_finite() || field.diameter <= 0.0 {
continue;
}
let Ok(centres) = sheet.perforation_holes(field) else { continue };
let remaining = MAX_HOLES.saturating_sub(self.perforations.len());
self.perforations.extend(centres.into_iter().take(remaining).map(|centre| (centre, field.diameter / 2.0)));
}
}
/// Frame the pattern's bounds `lo..hi` in `area`, the part of `rect` the command panel leaves.
fn fit(&mut self, rect: Rect, area: Rect, lo: (f64, f64), hi: (f64, f64)) {
let scale = (f64::from(area.width()) / (hi.0 - lo.0)).min(f64::from(area.height()) / (hi.1 - lo.1));
self.cam.target.x = (lo.0 + hi.0) * 0.5 - f64::from(area.center().x - rect.center().x) / scale;
self.cam.target.y = (lo.1 + hi.1) * 0.5 + f64::from(area.center().y - rect.center().y) / scale;
self.cam.target.z = 0.0;
self.cam.distance = f64::from(rect.height()) / (2.0 * scale) / 0.4;
self.fitted = true;
}
}
/// The Create Flat Pattern dialog is open, so the viewport shows its 2D view.
pub(crate) fn flat_active(app: &SolveApp) -> bool {
matches!(app.dialog.as_ref().map(|d| &d.kind), Some(Kind::Sheet(Sm::FlatPattern { .. })))
}
/// Camera input for the flat pattern: the shared navigation without orbit, driving the flat view
/// instead of the Design camera. The result reports nothing under the pointer, so the model
/// beneath neither hovers, selects nor navigates.
pub(crate) fn navigate(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect, resp: &egui::Response) -> crate::navigation::CameraInput {
use crate::navigation::{NavCaps, handle};
let design = std::mem::replace(&mut app.cam, app.flat_view.cam);
let mut input = handle(app, ui, rect, resp, NavCaps { orbit: false, pick: false });
app.flat_view.cam = std::mem::replace(&mut app.cam, design);
app.viewport.mouse = None;
input.inside = false;
input.hover = None;
input
}
fn pocket_label(app: &SolveApp, pocket: &Value) -> Option<String> {
let depth = pocket["depth_mm"].as_f64()?;
if !depth.is_finite() || depth <= 0.0 {
return None;
}
let side = match pocket["side"].as_str()? {
"top" => "Top",
"bottom" => "Bottom",
"internal" => "Internal",
_ => return None,
};
Some(format!("{side} pocket: {} deep", crate::prefs::show_mm(app, depth, 1)))
}
#[cfg(test)]
#[path = "dialogs_sheet_tests.rs"]
mod tests;