Lasse Lian
6df69e9def
Thin Extrude builds walls of a set thickness along sketch curves, open chains and closed loops, with the wall centred, inside, outside or on both sides at two thicknesses. Saved under format 20 (thin on an Extrude); an extrude without thin saves as before. Closes #721.
4831 lines
222 KiB
Rust
4831 lines
222 KiB
Rust
//! Command dialogs (shown at the right of the viewport). A dialog collects values and selection
|
||
//! inputs (geometry picked in the viewport, never typed), then runs its command; it never
|
||
//! changes the design itself. Things selected before the command starts become its input.
|
||
|
||
use std::hash::{Hash, Hasher};
|
||
|
||
use egui::{Color32, RichText, Stroke, vec2};
|
||
use serde_json::{Value, json};
|
||
use solidcraft_engine::Sel;
|
||
use solidcraft_engine::Session;
|
||
use solidcraft_engine::doc::expr::Kind as ValueKind;
|
||
use solidcraft_engine::doc::{AxisRef, Direction, FeatureKind, FilletStyle, HoleKind, Operation, PatternKind, PlaneRef, ProfileSel, ThinSide};
|
||
use solidcraft_engine::geom::{Aabb3, Vec3};
|
||
|
||
use crate::SolveApp;
|
||
use crate::selection::{self, AXES, Accept, BODIES, CURVES, EDGES, FACES, PLANAR_FACES, PLANES, PROFILES, SelInput};
|
||
use crate::theme::Tokens;
|
||
use crate::viewport::Hit;
|
||
|
||
pub(crate) const OPS: [&str; 4] = ["new", "join", "cut", "intersect"];
|
||
pub(crate) const OP_LABELS: [&str; 4] = ["New Body", "Join", "Cut", "Intersect"];
|
||
const DIRS: [&str; 4] = ["positive", "negative", "symmetric", "positive"];
|
||
/// The "Two sides" direction (a second distance the other way).
|
||
pub const TWO_SIDES: usize = 3;
|
||
/// Thin Extrude wall locations, as `solid.extrude` names them, and their labels.
|
||
const WALL_SIDES: [&str; 4] = ["center", "inside", "outside", "two_sides"];
|
||
const WALL_LABELS: [&str; 4] = ["Center", "Inside", "Outside", "Two Sides"];
|
||
/// What an extrude's first input picks: profiles or planar faces, or curves too when thin.
|
||
const EXTRUDE_ACCEPT: Accept = PROFILES | PLANAR_FACES;
|
||
const THIN_ACCEPT: Accept = PROFILES | CURVES;
|
||
const HOLE_TYPES: [&str; 3] = ["simple", "counterbore", "countersink"];
|
||
const HOLE_LABELS: [&str; 3] = ["Simple", "Counterbore", "Countersink"];
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub enum Kind {
|
||
/// Pick a plane or planar face; the sketch starts on it at once.
|
||
Sketch,
|
||
Extrude {
|
||
distance: String,
|
||
direction: usize,
|
||
operation: usize,
|
||
/// Into a body: cut; additions: join when a solid exists, otherwise new.
|
||
/// until the user picks one.
|
||
auto_op: bool,
|
||
/// The other side's distance (two sides).
|
||
distance2: String,
|
||
/// Taper angle (empty or zero: none).
|
||
taper: String,
|
||
/// An explicitly authored zero taper is still a model parameter.
|
||
taper_present: bool,
|
||
/// Optional distance beyond the selected end object.
|
||
to_offset: String,
|
||
/// Start offset from the profile plane (empty: start on the profile plane).
|
||
start: String,
|
||
/// Extent type All (through everything) instead of a distance.
|
||
all: bool,
|
||
/// Thin Extrude: a wall along the picked curves (or profiles' outlines).
|
||
thin: bool,
|
||
/// The wall thickness (inside, with Two Sides).
|
||
wall: String,
|
||
/// Wall location: an index into [`WALL_SIDES`].
|
||
wall_side: usize,
|
||
/// The thickness outside, with Two Sides.
|
||
wall2: String,
|
||
},
|
||
Revolve {
|
||
angle: String,
|
||
operation: usize,
|
||
/// An arbitrary stored line until the user deliberately picks a replacement.
|
||
axis: Option<Value>,
|
||
},
|
||
Fillet {
|
||
radius: String,
|
||
chamfer: bool,
|
||
chain: bool,
|
||
/// Chamfer type: 0 equal distance, 1 two distances, 2 distance and angle; with the
|
||
/// second distance, the angle and which face the first distance is on.
|
||
ctype: usize,
|
||
distance2: String,
|
||
angle: String,
|
||
flip: bool,
|
||
},
|
||
Shell {
|
||
thickness: String,
|
||
},
|
||
Draft {
|
||
angle: String,
|
||
},
|
||
Mirror,
|
||
/// Rectangular pattern of bodies: along one direction, optionally a second.
|
||
PatternRect {
|
||
count: String,
|
||
spacing: String,
|
||
count2: String,
|
||
spacing2: String,
|
||
},
|
||
/// Circular pattern of bodies around an axis.
|
||
PatternCirc {
|
||
count: String,
|
||
angle: String,
|
||
},
|
||
/// Loft through profiles of different sketches, in pick order.
|
||
Loft {
|
||
operation: usize,
|
||
},
|
||
/// Sweep a profile along a path of sketch curves.
|
||
Sweep {
|
||
operation: usize,
|
||
},
|
||
/// A construction plane offset from a plane.
|
||
OffsetPlane {
|
||
offset: String,
|
||
},
|
||
/// A construction plane through an axis at an angle to a plane.
|
||
AnglePlane {
|
||
angle: String,
|
||
},
|
||
/// A plane perpendicular to one selected path at a fractional distance.
|
||
PathPlane {
|
||
t: String,
|
||
sketch: Option<u64>,
|
||
},
|
||
/// Split a body by a plane.
|
||
Split,
|
||
/// Scale bodies uniformly.
|
||
Scale {
|
||
factor: String,
|
||
},
|
||
/// Move planar faces along their normals.
|
||
OffsetFaces {
|
||
distance: String,
|
||
},
|
||
/// A cosmetic thread on a cylindrical face.
|
||
Thread {
|
||
designation: String,
|
||
length: String,
|
||
},
|
||
/// A rib (one wall along open curves) or a web (a wall per curve).
|
||
Rib {
|
||
web: bool,
|
||
thickness: String,
|
||
depth: String,
|
||
flip: bool,
|
||
},
|
||
/// Raise or sink profiles of a sketch on a face.
|
||
Emboss {
|
||
depth: String,
|
||
deboss: bool,
|
||
},
|
||
/// Move planar faces onto a target plane or face.
|
||
ReplaceFace,
|
||
/// Boundary Fill: the cells the tool bodies make (a point inside, a description, filled
|
||
/// or not), found again when the tools change.
|
||
BoundaryFill {
|
||
operation: usize,
|
||
cells: Vec<(Vec3, String, bool)>,
|
||
of: Vec<Sel>,
|
||
},
|
||
/// Move bodies so a face or point meets another.
|
||
Align {
|
||
flip: bool,
|
||
},
|
||
/// Remove bodies from here on in the timeline.
|
||
Remove,
|
||
/// Pattern bodies along a path of sketch curves.
|
||
PathPattern {
|
||
count: String,
|
||
spacing: String,
|
||
},
|
||
/// A pipe (round, optionally hollow) along sketch curves.
|
||
Pipe {
|
||
diameter: String,
|
||
wall: String,
|
||
},
|
||
/// A stock block around bodies.
|
||
Stock {
|
||
margin: String,
|
||
},
|
||
/// Physical material (and with it the appearance) of bodies.
|
||
Material {
|
||
index: usize,
|
||
},
|
||
/// Section Analysis: cut the view by a plane, moved along its normal.
|
||
Section {
|
||
offset: String,
|
||
flip: bool,
|
||
},
|
||
/// Measure one or two picked items (vertices, edges, faces): the result of the last
|
||
/// measurement and the items it was for.
|
||
Measure {
|
||
result: Option<Value>,
|
||
of: Vec<Sel>,
|
||
},
|
||
/// Move bodies by a distance along X, Y and Z.
|
||
/// Move/Copy (see `dialogs_move`): the move type, X/Y/Z distances (Point to Position: the
|
||
/// target), X/Y/Z angles (Free Move) and the angle (Rotate).
|
||
Move {
|
||
mode: usize,
|
||
x: String,
|
||
y: String,
|
||
z: String,
|
||
rx: String,
|
||
ry: String,
|
||
rz: String,
|
||
angle: String,
|
||
},
|
||
Hole {
|
||
diameter: String,
|
||
depth: String,
|
||
kind: usize,
|
||
cb_diameter: String,
|
||
cb_depth: String,
|
||
cs_diameter: String,
|
||
cs_angle: String,
|
||
opts: HoleOpts,
|
||
},
|
||
Primitive {
|
||
cmd: &'static str,
|
||
fields: Vec<(&'static str, String)>,
|
||
operation: usize,
|
||
/// Where it goes: a picked point on a face or vertex, with the face's normal when the
|
||
/// face is planar. `None` keeps the command's own placement (the origin, or the edited
|
||
/// feature's).
|
||
at: Option<(Vec3, Option<Vec3>)>,
|
||
},
|
||
Combine {
|
||
operation: usize,
|
||
keep_tools: bool,
|
||
},
|
||
Params {
|
||
new_name: String,
|
||
new_expr: String,
|
||
},
|
||
EditParam {
|
||
name: String,
|
||
expr: String,
|
||
},
|
||
Rename {
|
||
feature: u64,
|
||
name: String,
|
||
},
|
||
/// Delete a feature that others depend on.
|
||
ConfirmDelete {
|
||
features: Vec<u64>,
|
||
with: Vec<String>,
|
||
fail: Vec<String>,
|
||
},
|
||
/// Joints and components (`dialogs_assembly`).
|
||
Assembly(crate::dialogs_assembly::Asm),
|
||
/// Sheet metal (`dialogs_sheet`).
|
||
Sheet(crate::dialogs_sheet::Sm),
|
||
/// Surface tools and Split Face (`dialogs_surface`).
|
||
Surface(crate::dialogs_surface::Surf),
|
||
/// Plastic features (`dialogs_plastic`).
|
||
Plastic(crate::dialogs_plastic::Pl),
|
||
/// Appearance (`dialogs_appearance`).
|
||
Appearance(crate::dialogs_appearance::Ap),
|
||
/// Contact sets, motion studies, exploded views, configurations (`dialogs_motion`).
|
||
Motion(crate::dialogs_motion::Mo),
|
||
/// Insert Part from the standard parts library (`dialogs_parts`).
|
||
Part(crate::dialogs_parts::Pt),
|
||
/// Edit Text: a sketch text's content and placement (`sketch_text`).
|
||
Text(Box<crate::sketch_text::Tx>),
|
||
TextMove(crate::sketch_text_move::TextMove),
|
||
/// Sketch-space modify tools: scale and offset, and later fillet, chamfer, the patterns,
|
||
/// mirror and move (`sketch_modify_ui`).
|
||
SketchModify(crate::sketch_modify_ui::Mod),
|
||
}
|
||
|
||
/// The Single hole placement's input: places on planar faces. A pick on or near a sketch point
|
||
/// that lies on the face (a circle's centre) is taken at that point, as Multiple picks it.
|
||
/// Holes go on any face (flat or curved; the engine drills against the face's normal there).
|
||
const HOLE_FACES: Accept = PLANAR_FACES | FACES | selection::POINTS;
|
||
|
||
/// The rest of the Hole dialog: placement, extents, tap type and drill point.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct HoleOpts {
|
||
/// Placement at several sketch points instead of one face point.
|
||
pub multiple: bool,
|
||
/// Extents: through all instead of a distance.
|
||
pub all: bool,
|
||
/// Drill point: an angled tip instead of a flat bottom.
|
||
pub angled: bool,
|
||
pub tip_angle: String,
|
||
/// Tap type: tapped (a cosmetic thread) instead of simple.
|
||
pub tapped: bool,
|
||
pub thread: String,
|
||
}
|
||
|
||
impl Default for HoleOpts {
|
||
fn default() -> Self {
|
||
HoleOpts { multiple: false, all: false, angled: true, tip_angle: "118 deg".into(), tapped: false, thread: "M5".into() }
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub struct Dialog {
|
||
pub kind: Kind,
|
||
/// Selection inputs, in order; clicks in the viewport go to the active one.
|
||
pub inputs: Vec<SelInput>,
|
||
pub active: usize,
|
||
pub error: Option<String>,
|
||
/// Editing an existing feature (its id, and the timeline marker to restore afterwards).
|
||
pub editing: Option<(u64, Option<usize>)>,
|
||
/// A user pick or clear makes the profile selector explicit, even if all are reselected.
|
||
pub profile_selection_changed: bool,
|
||
/// Give the on-canvas value box the keyboard (and select its text) on the next frame.
|
||
pub focus: bool,
|
||
/// Folded to its header (the "−" glyph).
|
||
pub collapsed: bool,
|
||
/// Parameters the dialog doesn't show but the command needs (kept when editing).
|
||
pub extra: serde_json::Map<String, Value>,
|
||
/// What the inputs were when OK was refused: `error` stays only while they still are.
|
||
pub refused: Option<Refused>,
|
||
/// Create Sketch opened by a sketch tool's shortcut: that tool starts once the sketch is open.
|
||
pub then_start: Option<&'static str>,
|
||
}
|
||
|
||
/// The commands a dialog's inputs make (or why they make none), its picks, and the design's
|
||
/// revision (a parameter the commands name can change without changing them).
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct Refused {
|
||
commands: Result<Vec<(String, Value)>, String>,
|
||
picks: Vec<SelInput>,
|
||
revision: u64,
|
||
}
|
||
|
||
impl Refused {
|
||
fn now(app: &SolveApp, d: &Dialog) -> Refused {
|
||
Refused { commands: apply_commands(app, d), picks: d.inputs.clone(), revision: app.session.revision }
|
||
}
|
||
}
|
||
|
||
/// Can a selection go into an input that accepts `a`? (Planar-ness is checked when picking.)
|
||
fn fits(a: Accept, s: &Sel) -> bool {
|
||
match s {
|
||
Sel::Profile { .. } => a & PROFILES != 0,
|
||
Sel::Edge { .. } => a & EDGES != 0,
|
||
Sel::Face { .. } => a & (FACES | PLANAR_FACES) != 0,
|
||
Sel::Body { .. } => a & BODIES != 0,
|
||
Sel::Plane { .. } => a & PLANES != 0,
|
||
Sel::Axis { .. } => a & AXES != 0,
|
||
Sel::SketchCurve { .. } => a & (AXES | CURVES) != 0,
|
||
Sel::Vertex { .. } => a & selection::VERTICES != 0,
|
||
Sel::Feature { .. } => a & selection::FEATURES != 0,
|
||
// Sketch points go into a sketch command's own inputs (Entities, a base point), so a
|
||
// box selection and a pre-selection reach them the way a click already does.
|
||
Sel::SketchPoint { .. } => a & (selection::POINTS | selection::SKETCH_POINTS) != 0,
|
||
Sel::SketchConstraint { .. } | Sel::Occurrence { .. } | Sel::ExternalSketchCurve { .. } | Sel::ExternalSketchPoint { .. } => false,
|
||
}
|
||
}
|
||
|
||
impl Dialog {
|
||
/// Show why OK (or starting the sketch) was refused, for as long as the inputs stay as they are.
|
||
fn refuse(&mut self, app: &SolveApp, error: String) {
|
||
self.refused = Some(Refused::now(app, self));
|
||
self.error = Some(error);
|
||
}
|
||
|
||
pub(crate) fn new(kind: Kind, inputs: Vec<SelInput>) -> Dialog {
|
||
Dialog {
|
||
kind,
|
||
inputs,
|
||
active: 0,
|
||
error: None,
|
||
editing: None,
|
||
profile_selection_changed: false,
|
||
focus: true,
|
||
collapsed: false,
|
||
extra: serde_json::Map::new(),
|
||
refused: None,
|
||
then_start: None,
|
||
}
|
||
}
|
||
|
||
pub fn for_command(app: &SolveApp, id: &str) -> Option<Dialog> {
|
||
let s = &app.session;
|
||
let has_bodies = !s.world_state().bodies.is_empty();
|
||
let mut d = match id {
|
||
"sketch.create" => Dialog::new(Kind::Sketch, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)]),
|
||
"solid.extrude" => Dialog::new(
|
||
Kind::Extrude {
|
||
distance: "10 mm".into(),
|
||
direction: 0,
|
||
operation: usize::from(has_bodies),
|
||
auto_op: true,
|
||
distance2: "10 mm".into(),
|
||
taper: "0 deg".into(),
|
||
taper_present: false,
|
||
to_offset: String::new(),
|
||
start: String::new(),
|
||
all: false,
|
||
thin: false,
|
||
wall: "2 mm".into(),
|
||
wall_side: 0,
|
||
wall2: "1 mm".into(),
|
||
},
|
||
vec![SelInput::new("Profiles", EXTRUDE_ACCEPT, true)],
|
||
),
|
||
"solid.revolve" => Dialog::new(
|
||
Kind::Revolve { angle: "360 deg".into(), operation: 0, axis: None },
|
||
vec![SelInput::new("Profile", PROFILES, true), SelInput::new("Axis", AXES, false)],
|
||
),
|
||
"solid.fillet" => Dialog::new(fillet_kind("2 mm", false), vec![SelInput::new("Edges", EDGES | FACES, true)]),
|
||
"solid.chamfer" => Dialog::new(fillet_kind("1 mm", true), vec![SelInput::new("Edges", EDGES | FACES, true)]),
|
||
"solid.shell" => {
|
||
let mut d = Dialog::new(Kind::Shell { thickness: "2 mm".into() }, vec![SelInput::new("Faces/Body", FACES, true)]);
|
||
// Fusion opens faces joined smoothly to the picked ones too.
|
||
d.extra.insert("tangent_chain".into(), json!(true));
|
||
d
|
||
}
|
||
"solid.draft" => Dialog::new(
|
||
Kind::Draft { angle: "5 deg".into() },
|
||
vec![SelInput::new("Faces", FACES, true), SelInput::new("Neutral plane", PLANES | PLANAR_FACES, false)],
|
||
),
|
||
"solid.mirror" => {
|
||
Dialog::new(Kind::Mirror, vec![SelInput::new("Objects", BODIES, true), SelInput::new("Mirror Plane", PLANES | PLANAR_FACES, false)])
|
||
}
|
||
"solid.rib" | "solid.web" => Dialog::new(
|
||
Kind::Rib { web: id == "solid.web", thickness: "2 mm".into(), depth: String::new(), flip: false },
|
||
vec![SelInput::new("Curves", CURVES, true)],
|
||
),
|
||
"solid.emboss" => Dialog::new(
|
||
Kind::Emboss { depth: "1 mm".into(), deboss: false },
|
||
vec![SelInput::new("Profiles", PROFILES, true), SelInput::new("Target Face (optional)", FACES, false)],
|
||
),
|
||
"solid.replace_face" => Dialog::new(
|
||
Kind::ReplaceFace,
|
||
vec![SelInput::new("Faces", PLANAR_FACES, true), SelInput::new("Target", PLANES | PLANAR_FACES, false)],
|
||
),
|
||
"solid.boundary_fill" => {
|
||
Dialog::new(Kind::BoundaryFill { operation: 0, cells: Vec::new(), of: Vec::new() }, vec![SelInput::new("Tools", BODIES, true)])
|
||
}
|
||
"solid.align" => Dialog::new(
|
||
Kind::Align { flip: false },
|
||
vec![
|
||
SelInput::new("Bodies", BODIES, true),
|
||
SelInput::new("From", FACES | EDGES | selection::VERTICES, false),
|
||
SelInput::new("To", FACES | EDGES | selection::VERTICES, false),
|
||
],
|
||
),
|
||
"solid.remove" => Dialog::new(Kind::Remove, vec![SelInput::new("Bodies", BODIES, true)]),
|
||
"solid.pattern.path" => Dialog::new(
|
||
Kind::PathPattern { count: "4".into(), spacing: "20 mm".into() },
|
||
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Path", CURVES, true)],
|
||
),
|
||
"solid.pipe" => Dialog::new(Kind::Pipe { diameter: "5 mm".into(), wall: String::new() }, vec![SelInput::new("Path", CURVES, true)]),
|
||
"solid.bounding_solid" => Dialog::new(Kind::Stock { margin: "2 mm".into() }, vec![SelInput::new("Bodies (all if none)", BODIES, true)]),
|
||
"construct.plane.offset" => {
|
||
Dialog::new(Kind::OffsetPlane { offset: "10 mm".into() }, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)])
|
||
}
|
||
"construct.plane.along_path" => {
|
||
Dialog::new(Kind::PathPlane { t: "0.5".into(), sketch: None }, vec![SelInput::new("Path", CURVES | EDGES, false)])
|
||
}
|
||
"construct.plane.at_angle" => Dialog::new(
|
||
Kind::AnglePlane { angle: "45 deg".into() },
|
||
vec![SelInput::new("Plane", PLANES, false), SelInput::new("Axis", AXES, false)],
|
||
),
|
||
"solid.split_body" => {
|
||
Dialog::new(Kind::Split, vec![SelInput::new("Body to split", BODIES, false), SelInput::new("Splitting tool", PLANES | FACES, false)])
|
||
}
|
||
"solid.scale" => Dialog::new(Kind::Scale { factor: "2".into() }, vec![SelInput::new("Bodies", BODIES, true)]),
|
||
"solid.offset_face" => Dialog::new(Kind::OffsetFaces { distance: "2 mm".into() }, vec![SelInput::new("Faces", PLANAR_FACES, true)]),
|
||
"solid.thread" => {
|
||
Dialog::new(Kind::Thread { designation: String::new(), length: String::new() }, vec![SelInput::new("Cylindrical face", FACES, false)])
|
||
}
|
||
"material.assign" => Dialog::new(Kind::Material { index: 1 }, vec![SelInput::new("Bodies", BODIES, true)]),
|
||
"inspect.section" => {
|
||
Dialog::new(Kind::Section { offset: "0 mm".into(), flip: false }, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)])
|
||
}
|
||
"inspect.measure" => {
|
||
Dialog::new(Kind::Measure { result: None, of: Vec::new() }, vec![SelInput::new("Items", FACES | EDGES | selection::VERTICES, true)])
|
||
}
|
||
"solid.pattern.rectangular" => Dialog::new(
|
||
Kind::PatternRect { count: "3".into(), spacing: "20 mm".into(), count2: "1".into(), spacing2: "20 mm".into() },
|
||
vec![
|
||
SelInput::new("Objects", BODIES, true),
|
||
SelInput::new("Direction", AXES | EDGES, false),
|
||
SelInput::new("Direction 2", AXES | EDGES, false),
|
||
],
|
||
),
|
||
"solid.pattern.circular" => Dialog::new(
|
||
Kind::PatternCirc { count: "6".into(), angle: "360 deg".into() },
|
||
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Axis", AXES, false)],
|
||
),
|
||
"solid.loft" => Dialog::new(Kind::Loft { operation: usize::from(has_bodies) }, vec![SelInput::new("Profiles", PROFILES, true)]),
|
||
"solid.sweep" => Dialog::new(
|
||
Kind::Sweep { operation: usize::from(has_bodies) },
|
||
vec![SelInput::new("Profile", PROFILES, true), SelInput::new("Path", CURVES, true)],
|
||
),
|
||
"solid.move" => Dialog::new(crate::dialogs_move::kind(0), crate::dialogs_move::inputs(0)),
|
||
"solid.hole" => Dialog::new(hole_defaults(), vec![SelInput::new("Face", HOLE_FACES, true)]),
|
||
"solid.box" => Dialog::new(
|
||
Kind::Primitive {
|
||
cmd: "solid.box",
|
||
fields: vec![("length", length_default(s, "20")), ("width", length_default(s, "20")), ("height", length_default(s, "20"))],
|
||
operation: 0,
|
||
at: None,
|
||
},
|
||
vec![],
|
||
),
|
||
"solid.cylinder" => Dialog::new(
|
||
Kind::Primitive {
|
||
cmd: "solid.cylinder",
|
||
fields: vec![("diameter", length_default(s, "20")), ("height", length_default(s, "20"))],
|
||
operation: 0,
|
||
at: None,
|
||
},
|
||
vec![],
|
||
),
|
||
"solid.sphere" => Dialog::new(
|
||
Kind::Primitive { cmd: "solid.sphere", fields: vec![("diameter", length_default(s, "20"))], operation: 0, at: None },
|
||
vec![],
|
||
),
|
||
"solid.torus" => Dialog::new(
|
||
Kind::Primitive {
|
||
cmd: "solid.torus",
|
||
fields: vec![("major", length_default(s, "20")), ("minor", length_default(s, "5"))],
|
||
operation: 0,
|
||
at: None,
|
||
},
|
||
vec![],
|
||
),
|
||
"solid.coil" => Dialog::new(
|
||
Kind::Primitive {
|
||
cmd: "solid.coil",
|
||
fields: vec![
|
||
("diameter", length_default(s, "40")),
|
||
("revolutions", "4".into()),
|
||
("pitch", length_default(s, "8")),
|
||
("section_size", length_default(s, "3")),
|
||
],
|
||
operation: 0,
|
||
at: None,
|
||
},
|
||
vec![],
|
||
),
|
||
"solid.combine" => Dialog::new(
|
||
Kind::Combine { operation: 1, keep_tools: false },
|
||
vec![SelInput::new("Target Body", BODIES, false), SelInput::new("Tool Bodies", BODIES, true)],
|
||
),
|
||
"parameters.change" => Dialog::new(Kind::Params { new_name: String::new(), new_expr: String::new() }, vec![]),
|
||
_ => {
|
||
let (kind, inputs) = crate::dialogs_assembly::start(app, id)
|
||
.or_else(|| crate::dialogs_sheet::start(app, id))
|
||
.or_else(|| crate::dialogs_surface::start(app, id))
|
||
.or_else(|| crate::dialogs_plastic::start(app, id))
|
||
.or_else(|| crate::dialogs_appearance::start(app, id))
|
||
.or_else(|| crate::dialogs_motion::start(app, id))
|
||
.or_else(|| crate::dialogs_parts::start(app, id))
|
||
.or_else(|| crate::sketch_text::start(app, id))
|
||
.or_else(|| crate::sketch_text_move::start(app, id))
|
||
.or_else(|| crate::sketch_modify_ui::start(app, id))?;
|
||
Dialog::new(kind, inputs)
|
||
}
|
||
};
|
||
// Patterns of features picked in the timeline: the objects are features.
|
||
if is_pattern(&d.kind)
|
||
&& s.selection.iter().any(|x| matches!(x, Sel::Feature { .. }))
|
||
&& let Some(inp) = d.inputs.first_mut()
|
||
{
|
||
inp.accept = selection::FEATURES;
|
||
inp.label = objects_label(inp.accept);
|
||
}
|
||
// Pre-selection: what is selected now becomes the input (first input that takes it); a
|
||
// face or edge stands for its body where bodies are wanted. (Edit Text's selection is the
|
||
// text it edits, not its path.)
|
||
let preselection: &[Sel] = if matches!(d.kind, Kind::Text(_)) { &[] } else { &s.selection };
|
||
for sel in preselection {
|
||
let as_body = match sel {
|
||
Sel::Face { body, .. } | Sel::Edge { body, .. } | Sel::Vertex { body, .. } => Some(Sel::Body { name: body.clone() }),
|
||
_ => None,
|
||
};
|
||
if let Some(b) = as_body
|
||
&& let Some(inp) = d.inputs.iter_mut().find(|i| i.accept == BODIES && (i.multi || i.items.is_empty()))
|
||
{
|
||
if !inp.items.contains(&b) {
|
||
inp.items.push(b);
|
||
}
|
||
continue;
|
||
}
|
||
// Planar-only inputs take planar faces only.
|
||
let planar_ok = match sel {
|
||
Sel::Face { body, index, .. } => planar_face(s, body, *index).is_some(),
|
||
_ => true,
|
||
};
|
||
let takes = |i: &SelInput| {
|
||
fits(i.accept, sel) && (i.multi || i.items.is_empty()) && (planar_ok || i.accept & FACES != 0 || !matches!(sel, Sel::Face { .. }))
|
||
};
|
||
if let Some(inp) = d.inputs.iter_mut().find(|i| takes(i)) {
|
||
// Fillets and chamfers take an edge with its tangent chain, as a pick does.
|
||
let picked = match (&d.kind, sel) {
|
||
(Kind::Fillet { chain: true, .. }, Sel::Edge { body, index, .. }) => s
|
||
.model
|
||
.state()
|
||
.body(body)
|
||
.map(|b| {
|
||
let m = b.mesh();
|
||
m.tangent_chain(*index, 2f64.to_radians())
|
||
.into_iter()
|
||
.filter_map(|i| m.edges.get(i).map(|e| Sel::Edge { body: body.clone(), index: i, point: polyline_mid(e) }))
|
||
.collect::<Vec<_>>()
|
||
})
|
||
.unwrap_or_else(|| vec![sel.clone()]),
|
||
(Kind::Measure { .. }, _) => vec![crate::viewport::measurement_selection(s, sel)],
|
||
_ if inp.multi => crate::viewport::grouped_selection(s, sel),
|
||
_ => vec![sel.clone()],
|
||
};
|
||
for x in picked {
|
||
if !inp.items.iter().any(|y| selection::same_item(y, &x)) {
|
||
inp.items.push(x);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// A primitive goes where a face or vertex is picked, standing on a planar face.
|
||
if let Kind::Primitive { at, .. } = &mut d.kind {
|
||
*at = s.selection.iter().find_map(|sel| match sel {
|
||
Sel::Face { body, index, point } => Some((*point, planar_face(s, body, *index).map(|(_, n)| n))),
|
||
Sel::Vertex { point, .. } => Some((*point, None)),
|
||
_ => None,
|
||
});
|
||
}
|
||
// With nothing pre-selected, a single profile in the sketch being used is taken (#684:
|
||
// not one a feature already builds from).
|
||
if matches!(d.kind, Kind::Extrude { .. } | Kind::Revolve { .. })
|
||
&& let Some(inp) = d.inputs.first_mut()
|
||
&& inp.items.is_empty()
|
||
{
|
||
inp.items = default_profiles(s);
|
||
}
|
||
d.advance();
|
||
Some(d)
|
||
}
|
||
|
||
pub fn rename(feature: u64, name: &str) -> Dialog {
|
||
Dialog::new(Kind::Rename { feature, name: name.to_string() }, vec![])
|
||
}
|
||
|
||
pub fn confirm_delete(feature: u64, with: Vec<String>, fail: Vec<String>) -> Dialog {
|
||
Dialog::confirm_delete_many(vec![feature], with, fail)
|
||
}
|
||
|
||
pub fn confirm_delete_many(features: Vec<u64>, with: Vec<String>, fail: Vec<String>) -> Dialog {
|
||
Dialog::new(Kind::ConfirmDelete { features, with, fail }, vec![])
|
||
}
|
||
|
||
pub fn edit_param(s: &Session, name: &str) -> Dialog {
|
||
Dialog::new(Kind::EditParam { name: name.into(), expr: s.doc.param(name).map(|p| p.expr.clone()).unwrap_or_default() }, vec![])
|
||
}
|
||
|
||
/// Make the first single input still empty (after the filled ones) active.
|
||
fn advance(&mut self) {
|
||
if let Some(i) = self.inputs.iter().position(|i| i.items.is_empty()) {
|
||
self.active = i;
|
||
} else {
|
||
self.active = self.active.min(self.inputs.len().saturating_sub(1));
|
||
}
|
||
}
|
||
|
||
/// Does this dialog make a feature that can be previewed live?
|
||
pub fn previews(&self) -> bool {
|
||
match &self.kind {
|
||
Kind::Assembly(k) => return k.previews(),
|
||
Kind::Sheet(k) => return k.previews(),
|
||
Kind::Surface(_) => return true,
|
||
Kind::SketchModify(k) => return k.previews(),
|
||
Kind::Plastic(k) => return k.previews(),
|
||
Kind::Part(_) => return true,
|
||
_ => {}
|
||
}
|
||
matches!(
|
||
self.kind,
|
||
Kind::Extrude { .. }
|
||
| Kind::Revolve { .. }
|
||
| Kind::Fillet { .. }
|
||
| Kind::Shell { .. }
|
||
| Kind::Draft { .. }
|
||
| Kind::Mirror
|
||
| Kind::Split
|
||
| Kind::Rib { .. }
|
||
| Kind::Emboss { .. }
|
||
| Kind::ReplaceFace
|
||
| Kind::Align { .. }
|
||
| Kind::Remove
|
||
| Kind::PathPattern { .. }
|
||
| Kind::Pipe { .. }
|
||
| Kind::Stock { .. }
|
||
| Kind::Scale { .. }
|
||
| Kind::OffsetFaces { .. }
|
||
| Kind::PatternRect { .. }
|
||
| Kind::PatternCirc { .. }
|
||
| Kind::Loft { .. }
|
||
| Kind::Sweep { .. }
|
||
| Kind::PathPlane { .. }
|
||
| Kind::Move { .. }
|
||
| Kind::Hole { .. }
|
||
| Kind::Primitive { .. }
|
||
| Kind::Combine { .. }
|
||
| Kind::BoundaryFill { .. }
|
||
)
|
||
}
|
||
|
||
/// The main value (shown on the canvas too): label, kind and the expression.
|
||
pub fn primary(&mut self) -> Option<(&'static str, ValueKind, &mut String)> {
|
||
Some(match &mut self.kind {
|
||
Kind::Extrude { to_offset, .. } if to_object_on(&self.inputs) => ("To Offset", ValueKind::Length, to_offset),
|
||
Kind::Extrude { distance, .. } => ("Distance", ValueKind::Length, distance),
|
||
Kind::Revolve { angle, .. } => ("Angle", ValueKind::Angle, angle),
|
||
Kind::Fillet { radius, chamfer, .. } => {
|
||
let label = if *chamfer {
|
||
"Distance"
|
||
} else if matches!(self.extra.get("type").and_then(Value::as_str), Some("curvature" | "g2")) {
|
||
"Equivalent Radius"
|
||
} else {
|
||
"Radius"
|
||
};
|
||
(label, ValueKind::Length, radius)
|
||
}
|
||
Kind::Shell { thickness } => ("Thickness", ValueKind::Length, thickness),
|
||
Kind::Draft { angle } => ("Angle", ValueKind::Angle, angle),
|
||
Kind::Hole { diameter, .. } => ("Diameter", ValueKind::Length, diameter),
|
||
// A move's main value follows its type: a distance along X for the ones that
|
||
// translate, the angle for Rotate. Point to Point is two picks with nothing to type.
|
||
Kind::Move { mode, x, angle, .. } => match *mode {
|
||
crate::dialogs_move::ROTATE => ("Angle", ValueKind::Angle, angle),
|
||
crate::dialogs_move::POINT_TO_POINT => return None,
|
||
_ => ("X", ValueKind::Length, x),
|
||
},
|
||
Kind::PatternRect { spacing, .. } => ("Spacing", ValueKind::Length, spacing),
|
||
Kind::PatternCirc { angle, .. } => ("Angle", ValueKind::Angle, angle),
|
||
Kind::Section { offset, .. } => ("Distance", ValueKind::Length, offset),
|
||
Kind::OffsetPlane { offset } => ("Distance", ValueKind::Length, offset),
|
||
Kind::PathPlane { t, .. } => ("Position (0 to 1)", ValueKind::Unitless, t),
|
||
Kind::Rib { thickness, .. } => ("Thickness", ValueKind::Length, thickness),
|
||
Kind::Emboss { depth, .. } => ("Depth", ValueKind::Length, depth),
|
||
Kind::PathPattern { spacing, .. } => ("Spacing", ValueKind::Length, spacing),
|
||
Kind::Pipe { diameter, .. } => ("Diameter", ValueKind::Length, diameter),
|
||
Kind::Stock { margin } => ("Margin", ValueKind::Length, margin),
|
||
Kind::AnglePlane { angle } => ("Angle", ValueKind::Angle, angle),
|
||
Kind::Scale { factor } => ("Scale", ValueKind::Unitless, factor),
|
||
Kind::OffsetFaces { distance } => ("Distance", ValueKind::Length, distance),
|
||
Kind::Sheet(k) => return k.primary(&self.inputs),
|
||
Kind::Surface(k) => return k.primary(),
|
||
Kind::Plastic(k) => return k.primary(),
|
||
Kind::SketchModify(k) => return k.primary(),
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
/// Dialogs holding a table get the wide limit.
|
||
pub fn is_wide(&self) -> bool {
|
||
matches!(self.kind, Kind::Params { .. }) || matches!(&self.kind, Kind::Motion(k) if k.wide())
|
||
}
|
||
|
||
pub fn wants_picks(&self) -> bool {
|
||
!self.inputs.is_empty()
|
||
}
|
||
|
||
pub fn active_input(&self) -> Option<&SelInput> {
|
||
self.inputs.get(self.active)
|
||
}
|
||
|
||
/// Everything the inputs hold (for highlighting).
|
||
pub fn items(&self) -> Vec<Sel> {
|
||
self.inputs.iter().flat_map(|i| i.items.iter().cloned()).collect()
|
||
}
|
||
|
||
pub fn highlight_key(&self) -> u64 {
|
||
let mut h = std::collections::hash_map::DefaultHasher::new();
|
||
serde_json::to_string(&self.items()).unwrap_or_default().hash(&mut h);
|
||
self.active.hash(&mut h);
|
||
h.finish()
|
||
}
|
||
|
||
/// The selection a hit would add to the active input.
|
||
pub fn candidate(&self, s: &Session, h: &Hit) -> Option<Sel> {
|
||
self.candidate_on(s, h, None)
|
||
}
|
||
|
||
/// The face under the cursor (the nearest face the pick ray meets, first among `hits`), looked
|
||
/// up once for all the sketch points among `hits` when the active input snaps face places to
|
||
/// them (the Single hole's); `None` otherwise.
|
||
pub(crate) fn face_snap(&self, s: &Session, hits: &[Hit]) -> Option<FaceSnap> {
|
||
if !self.active_input().is_some_and(|i| snaps_to_points(i.accept)) {
|
||
return None;
|
||
}
|
||
let Some(Hit::Face { body, index, .. }) = hits.iter().find(|h| matches!(h, Hit::Face { .. })) else { return None };
|
||
let st = s.world_state();
|
||
let near: Vec<Vec3> = hits
|
||
.iter()
|
||
.filter_map(|h| match h {
|
||
Hit::SketchPoint { sketch, at, .. } => st.sketch(*sketch).map(|ss| ss.plane.to_world(*at)),
|
||
_ => None,
|
||
})
|
||
.collect();
|
||
if near.is_empty() {
|
||
return None;
|
||
}
|
||
Some(FaceSnap::new(s, body, *index, &near))
|
||
}
|
||
|
||
/// The selection a hit would add to the active input, given the face under the cursor
|
||
/// ([`Dialog::face_snap`] of the same hits). A face place picked on or near a sketch point that
|
||
/// lies on that face (a circle's centre) is taken at the point, as a points input picks it.
|
||
pub(crate) fn candidate_on(&self, s: &Session, h: &Hit, snap: Option<&FaceSnap>) -> Option<Sel> {
|
||
if matches!(self.kind, Kind::SketchModify(_)) {
|
||
return crate::sketch_modify_ui::candidate(self, s, h);
|
||
}
|
||
let inp = self.active_input()?;
|
||
// Features are also picked on the canvas: a face stands for the feature that made it.
|
||
if inp.accept == selection::FEATURES {
|
||
return match h {
|
||
Hit::Face { body, index, point } => feature_of_face(s, body, *index, *point).map(|id| Sel::Feature { id }),
|
||
_ => None,
|
||
};
|
||
}
|
||
if snaps_to_points(inp.accept)
|
||
&& let Hit::SketchPoint { sketch, at, .. } = h
|
||
{
|
||
let snap = snap?;
|
||
return snap.place_at(s.world_state().sketch(*sketch)?.plane.to_world(*at));
|
||
}
|
||
// The snap looked the face under the cursor up already, planar or not.
|
||
inp.accepts(h, |body, face| snap.and_then(|f| f.planar(body, face)).unwrap_or_else(|| planar_face(s, body, face).is_some()))
|
||
}
|
||
|
||
/// A pick in the viewport (already accepted by the active input).
|
||
pub fn pick(&mut self, s: &Session, sel: Sel) {
|
||
if let Kind::PathPlane { sketch, .. } = &mut self.kind {
|
||
*sketch = None;
|
||
self.extra.remove("path");
|
||
}
|
||
if self.active == 0 && matches!(self.kind, Kind::Extrude { .. } | Kind::Revolve { .. } | Kind::Emboss { .. }) {
|
||
self.profile_selection_changed = true;
|
||
}
|
||
let measure = matches!(self.kind, Kind::Measure { .. });
|
||
let sel = if measure { crate::viewport::measurement_selection(s, &sel) } else { sel };
|
||
let chain = matches!(self.kind, Kind::Fillet { chain: true, .. });
|
||
let mut picked =
|
||
if !measure && self.active_input().is_some_and(|i| i.multi) { crate::viewport::picked_selection(s, &sel) } else { vec![sel.clone()] };
|
||
// Tangent chain: an edge brings the edges that continue it smoothly.
|
||
if chain
|
||
&& let Sel::Edge { body, index, .. } = &sel
|
||
&& let Some(b) = s.world_state().body(body)
|
||
{
|
||
let m = b.mesh();
|
||
picked = m
|
||
.tangent_chain(*index, 2f64.to_radians())
|
||
.into_iter()
|
||
.filter_map(|i| m.edges.get(i).map(|e| Sel::Edge { body: body.clone(), index: i, point: polyline_mid(e) }))
|
||
.collect();
|
||
}
|
||
// Extrude and revolve take profiles of one sketch.
|
||
if let Sel::Profile { sketch, .. } = &sel
|
||
&& !matches!(self.kind, Kind::Loft { .. })
|
||
&& let Some(inp) = self.inputs.get_mut(self.active)
|
||
{
|
||
inp.items.retain(|x| !matches!(x, Sel::Profile { sketch: s2, .. } if s2 != sketch));
|
||
}
|
||
let Some(inp) = self.inputs.get_mut(self.active) else { return };
|
||
inp.toggle(picked);
|
||
self.focus = true;
|
||
// A measurement is between two items: a third pick starts over from the last one.
|
||
if matches!(self.kind, Kind::Measure { .. }) && inp.items.len() > 2 {
|
||
let keep = inp.items.split_off(inp.items.len() - 1);
|
||
inp.items = keep;
|
||
}
|
||
if !inp.multi && !inp.items.is_empty() && self.active + 1 < self.inputs.len() {
|
||
self.advance();
|
||
}
|
||
self.error = None;
|
||
}
|
||
|
||
/// Box selection result: replace (or add to) the active input.
|
||
pub fn take_box(&mut self, s: &Session, sels: Vec<Sel>, add: bool) {
|
||
if let Kind::PathPlane { sketch, .. } = &mut self.kind {
|
||
*sketch = None;
|
||
self.extra.remove("path");
|
||
}
|
||
if self.active == 0 && matches!(self.kind, Kind::Extrude { .. } | Kind::Revolve { .. } | Kind::Emboss { .. }) {
|
||
self.profile_selection_changed = true;
|
||
}
|
||
let measure = matches!(self.kind, Kind::Measure { .. });
|
||
let Some(inp) = self.inputs.get_mut(self.active) else { return };
|
||
if !add {
|
||
inp.items.clear();
|
||
}
|
||
for x in sels {
|
||
let x = if measure { crate::viewport::measurement_selection(s, &x) } else { x };
|
||
if !fits(inp.accept, &x) {
|
||
continue;
|
||
}
|
||
if !inp.multi {
|
||
inp.items.clear();
|
||
inp.items.push(x);
|
||
break;
|
||
}
|
||
if !inp.items.iter().any(|y| selection::same_item(y, &x)) {
|
||
inp.items.push(x);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Profiles of the sketch a feature would use, when there is just one: the active sketch's, else
|
||
/// the last sketch's while no feature builds from it yet. A used profile (a cube's sketch on its
|
||
/// bottom face) is only taken when it is picked.
|
||
fn default_profiles(s: &Session) -> Vec<Sel> {
|
||
let st = s.world_state();
|
||
let sid = s.active_sketch.or_else(|| {
|
||
s.doc.features.iter().rev().find(|f| matches!(f.kind, FeatureKind::Sketch { .. })).map(|f| f.id).filter(|&id| !profiles_used(s, id))
|
||
});
|
||
match sid.and_then(|id| st.sketch(id).map(|ss| (id, ss.profiles.len()))) {
|
||
Some((id, 1)) => vec![Sel::Profile { sketch: id, index: 0 }],
|
||
_ => Vec::new(),
|
||
}
|
||
}
|
||
|
||
/// Does an input take face places that snap to sketch points on the face (the Single hole's)?
|
||
pub(crate) fn snaps_to_points(accept: Accept) -> bool {
|
||
accept & selection::POINTS != 0 && accept & PLANAR_FACES != 0
|
||
}
|
||
|
||
/// Which of a sketch's points a face place snaps to (the Single hole's): the points of geometry
|
||
/// the sketch shows. Not generated offset nodes or a text outline's points, which are never drawn or picked on their own
|
||
/// (as `view::sketch_point_visible` has it), nor projected points while the sketch hides
|
||
/// projected geometry (Show Projected off), whose curves aren't picked either. Hidden sketches
|
||
/// offer no points at all. Show Points doesn't count: it only hides the markers of the sketch
|
||
/// being edited, and a finished sketch's circle centres are snapped to without markers.
|
||
pub(crate) struct SnapPoints<'a> {
|
||
/// Show Projected is off: no linked point is taken.
|
||
hide_linked: bool,
|
||
shown: solidcraft_engine::view::SketchPointVisibility<'a>,
|
||
}
|
||
|
||
impl<'a> SnapPoints<'a> {
|
||
pub(crate) fn of(sk: &'a solidcraft_engine::sketch::Sketch) -> Self {
|
||
Self { hide_linked: sk.view.hide_projected, shown: solidcraft_engine::view::SketchPointVisibility::new(sk) }
|
||
}
|
||
|
||
/// Does a face place snap to point `p` of the sketch?
|
||
pub(crate) fn takes(&self, p: &solidcraft_engine::sketch::SPoint) -> bool {
|
||
self.shown.takes(p) && !(self.hide_linked && p.link.is_some())
|
||
}
|
||
}
|
||
|
||
/// How near a sketch point must be to a face to lie on it: a micrometre, wherever the part is (a
|
||
/// planar face's triangles lie in its plane), by the true distance ([`triangle_dist`]).
|
||
const ON_FACE: f64 = 1e-3;
|
||
|
||
/// The distance from `p` to the triangle `abc`, exactly: from its plane when `p` is over it,
|
||
/// otherwise from its nearest side. (`preview::point_triangle_dist` takes a point just past a
|
||
/// side for one over the triangle, with an absolute tolerance that is wide for a sliver.)
|
||
fn triangle_dist(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> f64 {
|
||
let sides = [(a, b), (b, c), (c, a)];
|
||
let to_sides = || sides.iter().map(|(u, v)| p.dist_to_segment(*u, *v)).fold(f64::INFINITY, f64::min);
|
||
// However small the triangle: only one without area (or not finite) has no plane.
|
||
let n = (b - a).cross(c - a);
|
||
let len = n.len();
|
||
if !(len > 0.0 && len.is_finite()) {
|
||
return to_sides();
|
||
}
|
||
let unit = n / len;
|
||
let h = (p - a).dot(unit);
|
||
let q = p - unit * h;
|
||
if sides.iter().all(|(u, v)| (*v - *u).cross(q - *u).dot(unit) >= 0.0) { h.abs() } else { to_sides() }
|
||
}
|
||
|
||
/// The most point-in-triangle tests one pick makes for the snap. Points past it aren't snapped
|
||
/// to (the face as picked still is), so no sketch, however dense, can stall the viewport.
|
||
const SNAP_BUDGET: usize = 1 << 18;
|
||
|
||
#[cfg(test)]
|
||
thread_local! {
|
||
/// A smaller [`SNAP_BUDGET`] for a test that runs it out.
|
||
static TEST_BUDGET: std::cell::Cell<Option<usize>> = const { std::cell::Cell::new(None) };
|
||
}
|
||
|
||
/// Run the snap with a budget of `n` tests per pick on this thread (`None`: [`SNAP_BUDGET`]).
|
||
#[cfg(test)]
|
||
pub(crate) fn set_snap_budget(n: Option<usize>) {
|
||
TEST_BUDGET.with(|b| b.set(n));
|
||
}
|
||
|
||
fn snap_budget() -> usize {
|
||
#[cfg(test)]
|
||
if let Some(n) = TEST_BUDGET.with(std::cell::Cell::get) {
|
||
return n;
|
||
}
|
||
SNAP_BUDGET
|
||
}
|
||
|
||
/// The face under the cursor, looked up once for all the sketch points one pick offers a face
|
||
/// place to (the Single hole's snap): whether it is planar, its plane, and those of its
|
||
/// triangles near the points on that plane, with their bounding boxes. A dense sketch over a
|
||
/// finely tessellated part costs one planarity lookup and one pass over the body's triangles per
|
||
/// pick; then a point off the plane is turned down at once, and a point on it is tested against
|
||
/// the face's triangles near the cursor, within [`SNAP_BUDGET`] tests in all.
|
||
pub(crate) struct FaceSnap {
|
||
body: String,
|
||
face: usize,
|
||
/// A point of the plane, its unit normal, and how far a point on the face may be from it
|
||
/// (the triangles' own distance plus [`ON_FACE`]); `None` when the face isn't planar.
|
||
plane: Option<(Vec3, Vec3, f64)>,
|
||
tris: Vec<([Vec3; 3], Aabb3)>,
|
||
/// Point-in-triangle tests left for this pick.
|
||
budget: std::cell::Cell<usize>,
|
||
}
|
||
|
||
impl FaceSnap {
|
||
/// Face `face` of `body`, for sketch points at `near` (in the world).
|
||
fn new(s: &Session, body: &str, face: usize, near: &[Vec3]) -> FaceSnap {
|
||
let mut snap = FaceSnap { body: body.to_string(), face, plane: None, tris: Vec::new(), budget: std::cell::Cell::new(snap_budget()) };
|
||
let st = s.world_state();
|
||
let (Some((origin, normal)), Some(b)) = (planar_face(s, body, face), st.body(body)) else { return snap };
|
||
let m = b.mesh();
|
||
#[cfg(test)]
|
||
SNAP_WORK.with(|w| w.set((w.get().0, w.get().1 + m.triangles.len())));
|
||
let tris: Vec<[Vec3; 3]> = m.triangles.iter().zip(&m.tri_face).filter(|(_, f)| **f as usize == face).filter_map(|(t, _)| m.tri(t)).collect();
|
||
// Anything within ON_FACE of a triangle is within this of the plane.
|
||
let stray = tris.iter().flatten().map(|v| (*v - origin).dot(normal).abs()).fold(0.0, f64::max);
|
||
let plane = (origin, normal, stray + ON_FACE);
|
||
let mut region = Aabb3::EMPTY;
|
||
for p in near.iter().filter(|p| near_plane(plane, **p)) {
|
||
region.add(*p);
|
||
}
|
||
snap.tris = tris
|
||
.into_iter()
|
||
.map(|t| {
|
||
let mut b = Aabb3::EMPTY;
|
||
t.iter().for_each(|v| b.add(*v));
|
||
(t, b)
|
||
})
|
||
.filter(|(_, b)| boxes_meet(b, ®ion, ON_FACE))
|
||
.collect();
|
||
snap.plane = Some(plane);
|
||
snap
|
||
}
|
||
|
||
/// Is face `face` of `body` planar, when it is this snap's face?
|
||
fn planar(&self, body: &str, face: usize) -> Option<bool> {
|
||
(self.face == face && self.body == body).then_some(self.plane.is_some())
|
||
}
|
||
|
||
/// The face place at `p` (one of the points the snap was made for), when `p` lies on the face.
|
||
fn place_at(&self, p: Vec3) -> Option<Sel> {
|
||
let plane = self.plane?;
|
||
if !(p.is_finite() && near_plane(plane, p)) {
|
||
return None;
|
||
}
|
||
let at = Aabb3 { min: p, max: p };
|
||
for ([a, b, c], bb) in &self.tris {
|
||
let left = self.budget.get();
|
||
if left == 0 {
|
||
return None;
|
||
}
|
||
self.budget.set(left - 1);
|
||
#[cfg(test)]
|
||
SNAP_WORK.with(|w| w.set((w.get().0, w.get().1 + 1)));
|
||
if boxes_meet(bb, &at, ON_FACE) && triangle_dist(p, *a, *b, *c) < ON_FACE {
|
||
return Some(Sel::Face { body: self.body.clone(), index: self.face, point: p });
|
||
}
|
||
}
|
||
None
|
||
}
|
||
}
|
||
|
||
/// Is `p` within reach of the plane (a point of it, unit normal, reach)?
|
||
fn near_plane((origin, normal, reach): (Vec3, Vec3, f64), p: Vec3) -> bool {
|
||
(p - origin).dot(normal).abs() <= reach
|
||
}
|
||
|
||
/// Do boxes `a` and `b` meet once `b` is grown by `pad` on every side?
|
||
fn boxes_meet(a: &Aabb3, b: &Aabb3, pad: f64) -> bool {
|
||
a.min.x <= b.max.x + pad
|
||
&& b.min.x - pad <= a.max.x
|
||
&& a.min.y <= b.max.y + pad
|
||
&& b.min.y - pad <= a.max.y
|
||
&& a.min.z <= b.max.z + pad
|
||
&& b.min.z - pad <= a.max.z
|
||
}
|
||
|
||
#[cfg(test)]
|
||
thread_local! {
|
||
/// Planar face lookups (each tessellates the body) and triangles the snap looked at, on this
|
||
/// thread: tests bound the work of a pick with them.
|
||
static SNAP_WORK: std::cell::Cell<(usize, usize)> = const { std::cell::Cell::new((0, 0)) };
|
||
}
|
||
|
||
/// (planar face lookups, triangles the snap looked at) on this thread since the last call.
|
||
#[cfg(test)]
|
||
pub(crate) fn take_snap_work() -> (usize, usize) {
|
||
SNAP_WORK.with(|w| w.replace((0, 0)))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod face_snap_tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn a_point_more_than_a_micrometre_off_a_sliver_is_off_the_face() {
|
||
// A triangle with half-micrometre legs. Points 2 µm below its lower side and 1.6 µm past
|
||
// its long side get past `preview::point_triangle_dist`'s inside test (an absolute
|
||
// tolerance); the snap goes by the true distance and turns them down. Points on a side,
|
||
// or half a micrometre beyond one, are on the face.
|
||
let (a, b, c) = (Vec3::ZERO, Vec3::new(5e-4, 0.0, 0.0), Vec3::new(0.0, 5e-4, 0.0));
|
||
let out = Vec3::new(1.0, 1.0, 0.0) * std::f64::consts::FRAC_1_SQRT_2;
|
||
let mid = Vec3::new(2.5e-4, 2.5e-4, 0.0);
|
||
let off = [Vec3::new(2.5e-4, -2e-3, 0.0), Vec3::new(1.4e-3, 1.4e-3, 0.0)];
|
||
let on = [mid, mid + out * 5e-4, Vec3::new(1e-4, -5e-4, 0.0), Vec3::new(1e-4, 1e-4, 5e-4)];
|
||
let mut bb = Aabb3::EMPTY;
|
||
[a, b, c].into_iter().for_each(|v| bb.add(v));
|
||
let snap = FaceSnap {
|
||
body: "Body1".into(),
|
||
face: 0,
|
||
plane: Some((Vec3::ZERO, Vec3::Z, ON_FACE)),
|
||
tris: vec![([a, b, c], bb)],
|
||
budget: std::cell::Cell::new(SNAP_BUDGET),
|
||
};
|
||
for p in off {
|
||
assert!(crate::preview::point_triangle_dist(p, a, b, c) < ON_FACE, "the inside test alone takes {p:?}");
|
||
assert!(triangle_dist(p, a, b, c) > 1.5e-3, "{p:?}");
|
||
assert_eq!(snap.place_at(p), None, "{p:?}");
|
||
}
|
||
for p in on {
|
||
assert_eq!(snap.place_at(p), Some(Sel::Face { body: "Body1".into(), index: 0, point: p }), "{p:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn the_distance_to_a_tiny_triangle_is_from_its_plane_over_it() {
|
||
// Legs of 20 nm: the triangle still has a plane, and a point just under a micrometre
|
||
// above it is that far from it (not from its nearest side), so it is on the face. A
|
||
// triangle without area is measured from its sides; nothing here panics on non-finite input.
|
||
let (a, b, c) = (Vec3::ZERO, Vec3::new(2e-5, 0.0, 0.0), Vec3::new(0.0, 2e-5, 0.0));
|
||
let p = Vec3::new(5e-6, 5e-6, 0.99999e-3);
|
||
assert!((triangle_dist(p, a, b, c) - 0.99999e-3).abs() < 1e-12, "{}", triangle_dist(p, a, b, c));
|
||
assert!((triangle_dist(Vec3::new(0.0, 3.0, 4.0), a, b, b) - 5.0).abs() < 1e-9, "a triangle without area");
|
||
let far = |d: f64| d.is_nan() || d >= ON_FACE;
|
||
assert!(far(triangle_dist(Vec3::new(f64::NAN, 0.0, 0.0), a, b, c)), "a point that isn't finite is never near");
|
||
assert!(far(triangle_dist(p, a, b, Vec3::new(f64::INFINITY, 0.0, 0.0))), "nor is a triangle that isn't finite");
|
||
}
|
||
}
|
||
|
||
/// Does a feature build from this sketch's profiles (extrude, revolve, sweep, loft, emboss…)?
|
||
fn profiles_used(s: &Session, sketch: u64) -> bool {
|
||
s.doc.features.iter().any(|f| f.kind.profile_sels().iter().any(|(id, _)| *id == sketch))
|
||
}
|
||
|
||
/// The plane of a planar body face: (point on it, unit normal).
|
||
pub fn planar_face(s: &Session, body: &str, face: usize) -> Option<(Vec3, Vec3)> {
|
||
#[cfg(test)]
|
||
SNAP_WORK.with(|w| w.set((w.get().0 + 1, w.get().1)));
|
||
let st = s.world_state();
|
||
let b = st.body(body)?;
|
||
let tol = (b.body.size() * 1e-3).max(1e-3);
|
||
let f = b.body.faces(tol).ok()?.into_iter().find(|f| f.index == face)?;
|
||
Some((f.centroid, f.plane_normal?))
|
||
}
|
||
|
||
fn polyline_mid(pts: &[Vec3]) -> Vec3 {
|
||
let len: f64 = pts.windows(2).map(|w| w[0].dist(w[1])).sum();
|
||
let mut acc = 0.0;
|
||
for w in pts.windows(2) {
|
||
let l = w[0].dist(w[1]);
|
||
if acc + l >= len * 0.5 && l > 0.0 {
|
||
return w[0].lerp(w[1], (len * 0.5 - acc) / l);
|
||
}
|
||
acc += l;
|
||
}
|
||
pts.first().copied().unwrap_or_default()
|
||
}
|
||
|
||
fn pt(v: Vec3) -> Value {
|
||
json!([v.x, v.y, v.z])
|
||
}
|
||
|
||
/// A plane input as a command parameter: an origin/construction plane name or a face plane.
|
||
fn plane_value(s: &Session, sel: Option<&Sel>) -> Option<Value> {
|
||
match sel? {
|
||
Sel::Plane { name } => Some(json!(name)),
|
||
Sel::Face { body, index, point } => {
|
||
let (_, n) = planar_face(s, body, *index)?;
|
||
Some(json!({"origin": pt(*point), "normal": pt(n)}))
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// A value field; true when Enter was pressed in it.
|
||
pub(crate) fn field(ui: &mut egui::Ui, s: &mut String) -> bool {
|
||
let r = ui.text_edit_singleline(s);
|
||
publish_row(&r);
|
||
crate::params_dialog::complete(ui, &r, s);
|
||
r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter))
|
||
}
|
||
|
||
/// A checkbox row. Its row handle (`dialog:<row label>`) lets a scenario click it by the label
|
||
/// beside it, the way `field` already publishes one for a value field.
|
||
pub(crate) fn check(ui: &mut egui::Ui, on: &mut bool) {
|
||
let r = ui.checkbox(on, "");
|
||
publish_row(&r);
|
||
}
|
||
|
||
pub(crate) fn combo(ui: &mut egui::Ui, id: &str, labels: &[&str], sel: &mut usize) {
|
||
let row = ROW.with(|r| r.borrow().clone());
|
||
let selected = labels.get(*sel).copied().map(tr).unwrap_or("");
|
||
let r = egui::ComboBox::from_id_salt(id).selected_text(selected).width(FIELD_W).show_ui(ui, |ui| {
|
||
for (i, l) in labels.iter().enumerate() {
|
||
let item = ui.selectable_value(sel, i, tr(l));
|
||
crate::scenario::publish_handle(&format!("dialog:{row}:{l}"), item.rect.center());
|
||
}
|
||
});
|
||
publish_row(&r.response);
|
||
}
|
||
|
||
/// A mode choice as a row of icon buttons rather than a drop-down: every mode is on screen at
|
||
/// once, each drawn as the shape it makes, with its name as the tooltip. `labels` and `icons`
|
||
/// run in step; a mode with no icon gets the fallback square. Publishes the handles a combo
|
||
/// does, `dialog:<row label>:<label>` per mode and `dialog:<row label>` for the row.
|
||
pub(crate) fn icon_choice(ui: &mut egui::Ui, labels: &[&str], icons: &[&str], sel: &mut usize) {
|
||
let t = Tokens::get();
|
||
let row = ROW.with(|r| r.borrow().clone());
|
||
let mut at = None;
|
||
ui.horizontal(|ui| {
|
||
for (i, label) in labels.iter().enumerate() {
|
||
let on = *sel == i;
|
||
let (r, resp) = ui.allocate_exact_size(vec2(28.0, 24.0), egui::Sense::click());
|
||
if on {
|
||
ui.painter().rect_filled(r, 4.0, t.accent);
|
||
} else if resp.hovered() {
|
||
ui.painter().rect_filled(r, 4.0, t.hover);
|
||
}
|
||
let ink = if on { Color32::WHITE } else { t.icon };
|
||
crate::icons::paint(ui.painter(), r.shrink(3.0), icons.get(i).copied().unwrap_or(""), ink, t.icon_fill, ink);
|
||
crate::scenario::publish_handle(&format!("dialog:{row}:{label}"), r.center());
|
||
if on {
|
||
at = Some(r.center());
|
||
}
|
||
if resp.on_hover_text(tr(label)).clicked() {
|
||
*sel = i;
|
||
}
|
||
}
|
||
});
|
||
if let Some(p) = at {
|
||
crate::scenario::publish_handle(&format!("dialog:{row}"), p);
|
||
}
|
||
}
|
||
|
||
thread_local! {
|
||
/// The label of the dialog row being laid out (its widgets publish `dialog:<label>` handles).
|
||
static ROW: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };
|
||
}
|
||
|
||
fn tr(text: &str) -> &str {
|
||
crate::i18n::tr_label(text)
|
||
}
|
||
|
||
/// A dialog row's widget, for scenarios and demos: the handle `dialog:<row label>`.
|
||
fn publish_row(r: &egui::Response) {
|
||
ROW.with(|row| crate::scenario::publish_handle(&format!("dialog:{}", row.borrow()), r.rect.center()));
|
||
}
|
||
|
||
fn title(k: &Kind) -> &'static str {
|
||
match k {
|
||
Kind::Sketch => "CREATE SKETCH",
|
||
Kind::Extrude { .. } => "EXTRUDE",
|
||
Kind::Revolve { .. } => "REVOLVE",
|
||
Kind::Fillet { chamfer: false, .. } => "FILLET",
|
||
Kind::Fillet { chamfer: true, .. } => "CHAMFER",
|
||
Kind::Shell { .. } => "SHELL",
|
||
Kind::Draft { .. } => "DRAFT",
|
||
Kind::Mirror => "MIRROR",
|
||
Kind::Measure { .. } => "MEASURE",
|
||
Kind::Material { .. } => "PHYSICAL MATERIAL",
|
||
Kind::OffsetPlane { .. } => "OFFSET PLANE",
|
||
Kind::PathPlane { .. } => "PLANE ALONG PATH",
|
||
Kind::Rib { web: false, .. } => "RIB",
|
||
Kind::Rib { web: true, .. } => "WEB",
|
||
Kind::Emboss { .. } => "EMBOSS",
|
||
Kind::ReplaceFace => "REPLACE FACE",
|
||
Kind::Align { .. } => "ALIGN",
|
||
Kind::BoundaryFill { .. } => "BOUNDARY FILL",
|
||
Kind::Remove => "REMOVE",
|
||
Kind::PathPattern { .. } => "PATTERN ON PATH",
|
||
Kind::Pipe { .. } => "PIPE",
|
||
Kind::Stock { .. } => "STOCK",
|
||
Kind::AnglePlane { .. } => "PLANE AT ANGLE",
|
||
Kind::Split => "SPLIT BODY",
|
||
Kind::Scale { .. } => "SCALE",
|
||
Kind::OffsetFaces { .. } => "OFFSET FACE",
|
||
Kind::Thread { .. } => "THREAD",
|
||
Kind::Section { .. } => "SECTION ANALYSIS",
|
||
Kind::PatternRect { .. } => "RECTANGULAR PATTERN",
|
||
Kind::PatternCirc { .. } => "CIRCULAR PATTERN",
|
||
Kind::Loft { .. } => "LOFT",
|
||
Kind::Sweep { .. } => "SWEEP",
|
||
Kind::Move { .. } => "MOVE",
|
||
Kind::Hole { .. } => "HOLE",
|
||
Kind::Primitive { cmd, .. } => match *cmd {
|
||
"solid.box" => "BOX",
|
||
"solid.cylinder" => "CYLINDER",
|
||
"solid.sphere" => "SPHERE",
|
||
"solid.coil" => "COIL",
|
||
_ => "TORUS",
|
||
},
|
||
Kind::Combine { .. } => "COMBINE",
|
||
Kind::Params { .. } => "PARAMETERS",
|
||
Kind::EditParam { .. } => "EDIT DIMENSION",
|
||
Kind::Rename { .. } => "RENAME",
|
||
Kind::ConfirmDelete { .. } => "DELETE FEATURE",
|
||
Kind::Assembly(k) => k.title(),
|
||
Kind::Sheet(k) => k.title(),
|
||
Kind::Surface(k) => k.title(),
|
||
Kind::Plastic(k) => k.title(),
|
||
Kind::Appearance(_) => "APPEARANCE",
|
||
Kind::Motion(k) => k.title(),
|
||
Kind::Part(_) => "INSERT PART",
|
||
Kind::Text(_) => "EDIT TEXT",
|
||
Kind::TextMove(_) => "MOVE/COPY TEXT",
|
||
Kind::SketchModify(k) => k.title(),
|
||
}
|
||
}
|
||
|
||
fn hint(inp: &SelInput) -> &'static str {
|
||
let a = inp.accept;
|
||
if a & PROFILES != 0 {
|
||
"click profiles in the view"
|
||
} else if a & EDGES != 0 {
|
||
"click edges or faces"
|
||
} else if a & PLANES != 0 {
|
||
"click a plane or planar face"
|
||
} else if a & AXES != 0 {
|
||
"click an axis or sketch line"
|
||
} else if a & CURVES != 0 {
|
||
"click sketch curves"
|
||
} else if a & (selection::POINTS | selection::SKETCH_POINTS) != 0 {
|
||
"click sketch points"
|
||
} else if a & BODIES != 0 {
|
||
"click bodies"
|
||
} else {
|
||
"click faces"
|
||
}
|
||
}
|
||
|
||
/// Width of the label column; longer labels are cut with "…".
|
||
const LABEL_W: f32 = 92.0;
|
||
/// The label column grows to fit its labels up to this, then long labels wrap.
|
||
const LABEL_MAX_W: f32 = 150.0;
|
||
|
||
/// A row label in the dialog's label column (the grid sizes the column to its widest label).
|
||
pub(crate) fn row_label(ui: &mut egui::Ui, text: &str) {
|
||
ROW.with(|r| *r.borrow_mut() = text.to_string());
|
||
let display_text = tr(text);
|
||
let full = egui::WidgetText::from(display_text).into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, egui::TextStyle::Body).size().x;
|
||
let w = full.clamp(LABEL_W, LABEL_MAX_W);
|
||
ui.allocate_ui_with_layout(vec2(w, 22.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
|
||
ui.set_width(w);
|
||
ui.add(egui::Label::new(display_text).wrap());
|
||
});
|
||
}
|
||
|
||
thread_local! {
|
||
/// Faces already traced to their feature, by (revision, body, face).
|
||
static FACE_FEATURE: std::cell::RefCell<(u64, std::collections::HashMap<(String, usize), Option<u64>>)> = Default::default();
|
||
}
|
||
|
||
/// The feature that made a face: the latest feature before which the face's point lay on no
|
||
/// face of the model.
|
||
fn feature_of_face(s: &Session, body: &str, index: usize, p: Vec3) -> Option<u64> {
|
||
let key = (body.to_string(), index);
|
||
if let Some(hit) = FACE_FEATURE.with(|c| {
|
||
let c = c.borrow();
|
||
if c.0 == s.revision { c.1.get(&key).copied() } else { None }
|
||
}) {
|
||
return hit;
|
||
}
|
||
let on_model = |st: &solidcraft_engine::doc::ModelState| {
|
||
st.bodies.iter().any(|b| {
|
||
let m = b.mesh();
|
||
let bb = m.bounds();
|
||
let tol = 1e-4 * (1.0 + bb.diagonal());
|
||
p.x >= bb.min.x - tol
|
||
&& p.y >= bb.min.y - tol
|
||
&& p.z >= bb.min.z - tol
|
||
&& p.x <= bb.max.x + tol
|
||
&& p.y <= bb.max.y + tol
|
||
&& p.z <= bb.max.z + tol
|
||
&& m.triangles.iter().filter_map(|t| m.tri(t)).any(|t| point_tri_dist(p, t) < tol)
|
||
})
|
||
};
|
||
let found = s
|
||
.doc
|
||
.features
|
||
.iter()
|
||
.rev()
|
||
.filter(|f| !matches!(f.kind, FeatureKind::Sketch { .. }) && s.model.result(f.id).is_some_and(|r| r.error.is_none()))
|
||
.find(|f| !on_model(&s.model.state_before(f.id)))
|
||
.map(|f| f.id);
|
||
FACE_FEATURE.with(|c| {
|
||
let mut c = c.borrow_mut();
|
||
if c.0 != s.revision {
|
||
*c = (s.revision, std::collections::HashMap::new());
|
||
}
|
||
c.1.insert(key, found);
|
||
});
|
||
found
|
||
}
|
||
|
||
/// Distance from a point to a triangle.
|
||
pub(crate) fn point_tri_dist(p: Vec3, [a, b, c]: [Vec3; 3]) -> f64 {
|
||
let n = (b - a).cross(c - a);
|
||
let nn = n.dot(n);
|
||
if nn > 1e-24 {
|
||
let q = p - n * ((p - a).dot(n) / nn);
|
||
let inside = [(a, b), (b, c), (c, a)].iter().all(|(u, v)| (*v - *u).cross(q - *u).dot(n) >= 0.0);
|
||
if inside {
|
||
return (p - q).len();
|
||
}
|
||
}
|
||
p.dist_to_segment(a, b).min(p.dist_to_segment(b, c)).min(p.dist_to_segment(c, a))
|
||
}
|
||
|
||
/// The pattern objects' label: features are picked in the timeline.
|
||
fn objects_label(accept: Accept) -> &'static str {
|
||
if accept == selection::FEATURES { "Features" } else { "Objects" }
|
||
}
|
||
|
||
fn is_pattern(k: &Kind) -> bool {
|
||
matches!(k, Kind::PatternRect { .. } | Kind::PatternCirc { .. } | Kind::PathPattern { .. } | Kind::Mirror)
|
||
}
|
||
|
||
/// The Object Type row of a pattern: bodies (picked in the view) or features (picked in the
|
||
/// timeline, e.g. a hole).
|
||
fn object_type_row(d: &mut Dialog, ui: &mut egui::Ui) {
|
||
let Some(inp) = d.inputs.first_mut() else { return };
|
||
row_label(ui, "Object Type");
|
||
let cur = usize::from(inp.accept == selection::FEATURES);
|
||
let mut ty = cur;
|
||
combo(ui, "pat_obj", &["Bodies", "Features"], &mut ty);
|
||
ui.end_row();
|
||
if ty != cur {
|
||
inp.accept = if ty == 1 { selection::FEATURES } else { BODIES };
|
||
inp.label = objects_label(inp.accept);
|
||
inp.items.clear();
|
||
d.active = 0;
|
||
}
|
||
}
|
||
|
||
/// Rows above the selection inputs: the pattern type and object type, the Hole placement (one
|
||
/// face point, or sketch points).
|
||
fn placement_row(d: &mut Dialog, ui: &mut egui::Ui) {
|
||
if matches!(d.kind, Kind::Mirror) {
|
||
object_type_row(d, ui);
|
||
return;
|
||
}
|
||
if matches!(d.kind, Kind::Move { .. }) {
|
||
crate::dialogs_move::type_row(d, ui);
|
||
return;
|
||
}
|
||
let current = match d.kind {
|
||
Kind::PatternRect { .. } => Some(0),
|
||
Kind::PatternCirc { .. } => Some(1),
|
||
Kind::PathPattern { .. } => Some(2),
|
||
_ => None,
|
||
};
|
||
if let Some(cur) = current {
|
||
row_label(ui, "Type");
|
||
let mut ty = cur;
|
||
combo(ui, "pat_type", &["Rectangular", "Circular", "Path"], &mut ty);
|
||
ui.end_row();
|
||
if ty != cur {
|
||
// Same objects, the new pattern's other inputs.
|
||
let objects = d.inputs.first().map(|i| i.items.clone()).unwrap_or_default();
|
||
let (kind, mut inputs) = match ty {
|
||
0 => (
|
||
Kind::PatternRect { count: "3".into(), spacing: "20 mm".into(), count2: "1".into(), spacing2: "20 mm".into() },
|
||
vec![
|
||
SelInput::new("Objects", BODIES, true),
|
||
SelInput::new("Direction", AXES | EDGES, false),
|
||
SelInput::new("Direction 2", AXES | EDGES, false),
|
||
],
|
||
),
|
||
1 => (
|
||
Kind::PatternCirc { count: "6".into(), angle: "360 deg".into() },
|
||
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Axis", AXES, false)],
|
||
),
|
||
_ => (
|
||
Kind::PathPattern { count: "4".into(), spacing: "20 mm".into() },
|
||
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Path", CURVES, true)],
|
||
),
|
||
};
|
||
let accept = d.inputs.first().map(|i| i.accept).unwrap_or(BODIES);
|
||
if let Some(i) = inputs.first_mut() {
|
||
i.items = objects;
|
||
i.accept = accept;
|
||
i.label = objects_label(accept);
|
||
}
|
||
d.kind = kind;
|
||
d.inputs = inputs;
|
||
d.extra.clear();
|
||
d.advance();
|
||
}
|
||
object_type_row(d, ui);
|
||
return;
|
||
}
|
||
let Kind::Hole { opts, .. } = &mut d.kind else { return };
|
||
row_label(ui, "Placement");
|
||
let mut m = usize::from(opts.multiple);
|
||
combo(ui, "hole_place", &["Single", "Multiple"], &mut m);
|
||
ui.end_row();
|
||
if (m == 1) != opts.multiple {
|
||
opts.multiple = m == 1;
|
||
d.inputs = vec![if opts.multiple { SelInput::new("Points", selection::POINTS, true) } else { SelInput::new("Face", HOLE_FACES, true) }];
|
||
d.active = 0;
|
||
d.extra.remove("direction");
|
||
}
|
||
}
|
||
|
||
fn selection_label(s: &Session, item: &Sel) -> String {
|
||
match item {
|
||
Sel::SketchCurve { id } => id.clone(),
|
||
Sel::SketchPoint { id } => crate::sketch_modify_ui::point_id(s, item).unwrap_or(id).to_string(),
|
||
Sel::Plane { name } | Sel::Axis { name } | Sel::Body { name } => name.clone(),
|
||
Sel::Face { body, index, .. } => format!("{body} · face {index}"),
|
||
Sel::Edge { body, index, .. } => format!("{body} · edge {index}"),
|
||
Sel::Feature { id } => s.doc.feature(*id).map(|f| f.name.clone()).unwrap_or_else(|| format!("Feature {id}")),
|
||
Sel::Vertex { body, point } if body.is_empty() => {
|
||
let state = s.world_state();
|
||
let p = s.active_sketch.and_then(|id| state.sketch(id)).map(|sk| sk.plane.to_local(*point)).unwrap_or_default();
|
||
format!("({:.2}, {:.2}) mm", p.x, p.y)
|
||
}
|
||
_ => format!("{item:?}"),
|
||
}
|
||
}
|
||
|
||
/// Selection input rows: label, "N selected" (or a hint) and a clear button; clicking a row
|
||
/// makes it the active input.
|
||
fn input_rows(d: &mut Dialog, ui: &mut egui::Ui, s: &Session) {
|
||
// Edit Text shows its Path input among its own rows.
|
||
if matches!(d.kind, Kind::Text(_)) {
|
||
return;
|
||
}
|
||
let t = Tokens::get();
|
||
let mut clear: Option<usize> = None;
|
||
let mut activate: Option<usize> = None;
|
||
for (i, inp) in d.inputs.iter().enumerate() {
|
||
row_label(ui, inp.label);
|
||
ui.horizontal(|ui| {
|
||
let active = i == d.active;
|
||
// A chip: "↖ Select" (outlined) while empty, "N selected" (filled) once picked.
|
||
let custom_axis = i == 1 && inp.items.is_empty() && matches!(d.kind, Kind::Revolve { axis: Some(_), .. });
|
||
let filled = !inp.items.is_empty() || custom_axis;
|
||
let text = if filled {
|
||
RichText::new(if custom_axis {
|
||
crate::i18n::tr("dialog.custom_axis").into()
|
||
} else if !inp.multi {
|
||
inp.items.first().map(|item| selection_label(s, item)).unwrap_or_default()
|
||
} else {
|
||
crate::i18n::format("dialog.selected_count", &[("count", &inp.items.len().to_string())])
|
||
})
|
||
.color(Color32::WHITE)
|
||
} else {
|
||
RichText::new(crate::i18n::tr("dialog.select")).color(t.text)
|
||
};
|
||
let stroke = if active { Stroke::new(1.5, t.accent) } else { Stroke::new(1.0, t.dialog_border.gamma_multiply(1.6)) };
|
||
// Not in the Tab order: Tab moves between values.
|
||
let b = egui::Button::new(text)
|
||
.wrap_mode(egui::TextWrapMode::Wrap)
|
||
.fill(if filled { t.chip } else { Color32::TRANSPARENT })
|
||
.stroke(stroke)
|
||
.min_size(vec2(0.0, 22.0))
|
||
.sense(egui::Sense::CLICK);
|
||
let chip = ui.add(b);
|
||
publish_row(&chip);
|
||
let tooltip = if custom_axis {
|
||
if let Kind::Revolve { axis: Some(axis), .. } = &d.kind {
|
||
format!(
|
||
"Custom axis\nOrigin: {}\nDirection: {}\nClick to select a replacement axis",
|
||
axis.get("origin").map(ToString::to_string).unwrap_or_default(),
|
||
axis.get("dir").map(ToString::to_string).unwrap_or_default()
|
||
)
|
||
} else {
|
||
hint(inp).to_string()
|
||
}
|
||
} else {
|
||
format!("{} (click to pick into this input)", hint(inp))
|
||
};
|
||
if chip.on_hover_text(tooltip).clicked() {
|
||
activate = Some(i);
|
||
}
|
||
if !inp.items.is_empty() {
|
||
let button = ui.small_button("×").on_hover_text(tr("Clear the selection"));
|
||
crate::scenario::publish_handle(&format!("dialog:clear:{}", inp.label), button.rect.center());
|
||
if button.clicked() {
|
||
clear = Some(i);
|
||
}
|
||
}
|
||
});
|
||
ui.end_row();
|
||
}
|
||
if let Some(i) = activate {
|
||
d.active = i;
|
||
}
|
||
if let Some(i) = clear
|
||
&& let Some(inp) = d.inputs.get_mut(i)
|
||
{
|
||
inp.items.clear();
|
||
if i == 0 {
|
||
d.profile_selection_changed = true;
|
||
}
|
||
d.active = i;
|
||
}
|
||
}
|
||
|
||
/// Width limits of a docked dialog: shrink-wrapped to its content within these.
|
||
use crate::frame::{DIALOG_MAX_W, DIALOG_MIN_W, DIALOG_WIDE_MAX_W};
|
||
/// Width of value fields and choice boxes in a dialog.
|
||
const FIELD_W: f32 = 124.0;
|
||
|
||
/// Find the Boundary Fill cells again when the tool bodies changed (keeping the choices of
|
||
/// cells that are still there).
|
||
fn update_fill_cells(app: &SolveApp, d: &mut Dialog) {
|
||
let tools: Vec<Sel> = sels(d, 0).to_vec();
|
||
let Kind::BoundaryFill { cells, of, .. } = &mut d.kind else { return };
|
||
if *of == tools {
|
||
return;
|
||
}
|
||
let names: Vec<String> = tools.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None }).collect();
|
||
// Editing: the tools as they were before this feature (it may have removed them).
|
||
let st = match d.editing {
|
||
Some((id, _)) => app.session.model.state_before(id),
|
||
None => app.session.world_state(),
|
||
};
|
||
let found = fill_cells(&st, &names);
|
||
let kept: Vec<String> = cells.iter().filter(|c| c.2).map(|c| c.1.clone()).collect();
|
||
*cells = found.into_iter().map(|(p, label)| (p, label.clone(), kept.is_empty() || kept.contains(&label))).collect();
|
||
*of = tools;
|
||
}
|
||
|
||
/// The cells a set of tool bodies makes: each region inside some of them and outside the rest,
|
||
/// as a point inside it and which tools hold it. Found by sampling a grid over the tools.
|
||
pub(crate) fn fill_cells(st: &solidcraft_engine::doc::ModelState, tools: &[String]) -> Vec<(Vec3, String)> {
|
||
let bodies: Vec<_> = tools.iter().filter_map(|n| st.body(n).map(|b| (n.clone(), b.mesh()))).take(16).collect();
|
||
if bodies.is_empty() {
|
||
return Vec::new();
|
||
}
|
||
let indexes: Vec<_> = bodies.iter().map(|(_, m)| m.inside_index()).collect();
|
||
let bb = bodies.iter().fold(solidcraft_engine::geom::Aabb3::EMPTY, |b, (_, m)| b.union(&m.bounds()));
|
||
let n = 20;
|
||
let at = |i: usize, lo: f64, hi: f64| lo + (hi - lo) * (i as f64 + 0.5) / n as f64;
|
||
// Signature (which tools hold the point) → the points with it.
|
||
let mut groups: Vec<(u32, Vec<Vec3>)> = Vec::new();
|
||
for i in 0..n {
|
||
for j in 0..n {
|
||
for k in 0..n {
|
||
let p = Vec3::new(at(i, bb.min.x, bb.max.x), at(j, bb.min.y, bb.max.y), at(k, bb.min.z, bb.max.z));
|
||
let sig = indexes.iter().enumerate().fold(0u32, |acc, (t, ix)| if ix.contains(p) { acc | (1 << t) } else { acc });
|
||
if sig == 0 {
|
||
continue;
|
||
}
|
||
match groups.iter_mut().find(|(g, _)| *g == sig) {
|
||
Some((_, v)) => v.push(p),
|
||
None => groups.push((sig, vec![p])),
|
||
}
|
||
}
|
||
}
|
||
}
|
||
groups.sort_by_key(|(sig, _)| *sig);
|
||
groups
|
||
.into_iter()
|
||
.filter_map(|(sig, pts)| {
|
||
let c = pts.iter().fold(Vec3::ZERO, |a, p| a + *p) * (1.0 / pts.len() as f64);
|
||
// The sample nearest the middle (the middle itself may be outside a curved cell).
|
||
let rep = pts.iter().min_by(|a, b| a.dist(c).total_cmp(&b.dist(c))).copied()?;
|
||
let inside: Vec<&str> = bodies.iter().enumerate().filter(|(t, _)| sig & (1 << t) != 0).map(|(_, (name, _))| name.as_str()).collect();
|
||
Some((rep, format!("Inside {}", inside.join(", "))))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// Measure again when the picked items changed.
|
||
fn update_measure(app: &SolveApp, d: &mut Dialog) {
|
||
let items: Vec<Sel> = sels(d, 0).to_vec();
|
||
if let Kind::Measure { result, of } = &mut d.kind
|
||
&& *of != items
|
||
{
|
||
*result = if items.is_empty() { None } else { Some(app.session.measure_items(&items)) };
|
||
*of = items;
|
||
}
|
||
}
|
||
|
||
fn fmt_mm(app: &SolveApp, v: &Value) -> String {
|
||
v.as_f64().map(|x| crate::prefs::show_mm(app, x, 1)).unwrap_or_default()
|
||
}
|
||
|
||
/// The measurement in the dialog.
|
||
fn measure_rows(app: &SolveApp, ui: &mut egui::Ui, r: Option<&Value>) {
|
||
let t = Tokens::get();
|
||
let Some(r) = r else {
|
||
ui.label("");
|
||
ui.label(RichText::new(tr("pick one or two vertices, edges or faces")).color(t.text_dim));
|
||
ui.end_row();
|
||
return;
|
||
};
|
||
if let Some(e) = r.get("error").and_then(Value::as_str) {
|
||
ui.label("");
|
||
ui.label(RichText::new(e).color(t.error));
|
||
ui.end_row();
|
||
return;
|
||
}
|
||
for (i, it) in r["items"].as_array().into_iter().flatten().enumerate() {
|
||
let what = match it["type"].as_str() {
|
||
Some("edge") => format!("Length {}", fmt_mm(app, &it["length_mm"])),
|
||
Some("face") => format!("Area {}", crate::prefs::show_mm(app, it["area_mm2"].as_f64().unwrap_or(0.0), 2)),
|
||
Some("vertex") => {
|
||
let p = &it["position"];
|
||
format!("At {}, {}, {}", fmt_mm(app, &p[0]), fmt_mm(app, &p[1]), fmt_mm(app, &p[2]))
|
||
}
|
||
_ => String::new(),
|
||
};
|
||
ui.label(format!("Item {}", i + 1));
|
||
ui.label(what);
|
||
ui.end_row();
|
||
}
|
||
if r.get("distance_mm").is_some() {
|
||
ui.label(RichText::new(tr("Distance")).strong());
|
||
ui.label(RichText::new(fmt_mm(app, &r["distance_mm"])).strong());
|
||
ui.end_row();
|
||
let d = &r["delta"];
|
||
for (k, l) in ["ΔX", "ΔY", "ΔZ"].iter().enumerate() {
|
||
ui.label(*l);
|
||
ui.label(crate::prefs::show_mm(app, d[k].as_f64().unwrap_or(0.0).abs(), 1));
|
||
ui.end_row();
|
||
}
|
||
}
|
||
if let Some(a) = r["angle_deg"].as_f64() {
|
||
ui.label(RichText::new(tr("Angle")).strong());
|
||
ui.label(RichText::new(format!("{a:.3}°")).strong());
|
||
ui.end_row();
|
||
}
|
||
}
|
||
|
||
/// Keep an automatic extrude operation in step with the geometry.
|
||
fn auto_operation(app: &SolveApp, d: &mut Dialog) {
|
||
if !matches!(d.kind, Kind::Extrude { auto_op: true, .. }) {
|
||
return;
|
||
}
|
||
let Some(op) =
|
||
dialog_commands(app, d).ok().and_then(|c| c.into_iter().next()).and_then(|(_, p)| solidcraft_engine::auto_operation(&app.session, &p))
|
||
else {
|
||
return;
|
||
};
|
||
if let Kind::Extrude { operation, .. } = &mut d.kind
|
||
&& let Some(i) = OPS.iter().position(|o| *o == op)
|
||
{
|
||
*operation = i;
|
||
}
|
||
}
|
||
|
||
/// Show the active dialog (if any), docked flush to an edge of the viewport just below the axis
|
||
/// view, sized to its content. The right edge is its place, except while a sketch is open: the
|
||
/// Sketch Palette keeps the right there, and the dialog takes the left so both stay on screen.
|
||
pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
|
||
app.viewport.dialog_rect = None;
|
||
let Some(mut d) = app.dialog.take() else { return };
|
||
// Edit Text lasts as long as its text: other design changes leave it open.
|
||
if let Kind::Text(k) = &mut d.kind
|
||
&& !crate::sketch_text::refresh(app, k)
|
||
{
|
||
return;
|
||
}
|
||
crate::sketch_text::sync_path(&mut d);
|
||
let _language = crate::i18n::scope(&app.preferences.language);
|
||
if let Kind::TextMove(k) = &d.kind
|
||
&& !crate::sketch_text_move::valid(app, k)
|
||
{
|
||
return;
|
||
}
|
||
auto_operation(app, &mut d);
|
||
update_measure(app, &mut d);
|
||
update_fill_cells(app, &mut d);
|
||
// A refused OK's error is about the inputs it ran with (#641). Once a value (in the dialog,
|
||
// or on the canvas, which the viewport applied earlier this frame), a pick or the design (a
|
||
// parameter the inputs use) changes, it gives way to what the inputs make now: their own
|
||
// error, or nothing and the live preview. `built`: whether they make commands, for OK below.
|
||
let mut built = None;
|
||
if d.error.is_some()
|
||
&& let Some(was) = &d.refused
|
||
{
|
||
let now = Refused::now(app, &d);
|
||
built = Some(now.commands.is_ok());
|
||
if now != *was {
|
||
d.error = now.commands.as_ref().err().cloned();
|
||
d.refused = d.error.is_some().then_some(now);
|
||
}
|
||
}
|
||
// Physical materials: the library's, then the design's own (material.create).
|
||
let material_names = app.session.doc.material_names();
|
||
let t = Tokens::get();
|
||
let vp = app.viewport.rect.unwrap_or_else(|| ctx.content_rect());
|
||
let top = (vp.top() + crate::viewport::AXIS_VIEW_CLEARANCE).min((vp.bottom() - 360.0).max(vp.top()));
|
||
// The Sketch Palette owns the right edge for as long as a sketch is being edited. A dialog
|
||
// started there docks at the left instead, so neither panel hides the other.
|
||
let side = if crate::sketch_palette::editing(app) && crate::sketch_palette::fits_beside_a_dialog(app, ctx) {
|
||
crate::frame::Side::Left
|
||
} else {
|
||
crate::frame::Side::Right
|
||
};
|
||
let anchor = egui::pos2(side.anchor_x(vp), top);
|
||
let mut keep = true;
|
||
let mut ok = false;
|
||
let mut applied = false;
|
||
let mut cancel = false;
|
||
let mut enter = false;
|
||
let wide = d.is_wide();
|
||
let raw_title = title(&d.kind);
|
||
let heading = if d.editing.is_some() { crate::i18n::format("dialog.edit_title", &[("title", tr(raw_title))]) } else { tr(raw_title).to_string() };
|
||
let frame = crate::frame::dock_frame(ctx, side);
|
||
// The area includes the border as well as the inner margins; reserve all of it so a
|
||
// horizontally scrolling table cannot push a wide dialog two pixels past its limit.
|
||
let horizontal_frame = frame.inner_margin.leftf() + frame.inner_margin.rightf() + 2.0 * frame.stroke.width;
|
||
// OK is offered once the inputs make a feature.
|
||
let has_ok = !matches!(d.kind, Kind::Sketch | Kind::Params { .. } | Kind::Measure { .. });
|
||
let valid = !has_ok || !d.previews() || (built.unwrap_or_else(|| apply_commands(app, &d).is_ok()) && app.preview.error.is_none());
|
||
let width = if wide { crate::frame::Width::Wide } else { crate::frame::Width::Normal };
|
||
let wkey = egui::Id::new(("sc_dialog_w", wide));
|
||
let response = crate::frame::docked_on(
|
||
RichText::new(heading.clone()).strong().size(13.0),
|
||
egui::Id::new(("sc_dialog", title(&d.kind))),
|
||
anchor,
|
||
vp.bottom() - anchor.y - 8.0,
|
||
width,
|
||
side,
|
||
)
|
||
.frame(frame)
|
||
.open(&mut keep)
|
||
.show(ctx, |ui| {
|
||
ui.spacing_mut().text_edit_width = FIELD_W;
|
||
// Long texts (errors, notes) wrap instead of widening the dialog.
|
||
ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Wrap);
|
||
let margin = horizontal_frame;
|
||
let min_w = if wide { 480.0 } else { DIALOG_MIN_W } - margin;
|
||
ui.set_min_width(min_w);
|
||
ui.set_max_width(if wide { DIALOG_WIDE_MAX_W } else { DIALOG_MAX_W } - margin);
|
||
// Rows that end at the right edge line up with last frame's content width.
|
||
let total = crate::frame::content_width(ui, wkey, min_w);
|
||
// Header: "−" folds the dialog, the command name, "»" at the right, on the title band.
|
||
crate::frame::heading(ui, crate::frame::Level::Title, total, |ui| {
|
||
let total = total - 2.0 * crate::frame::HEADING_MARGIN;
|
||
let fold = if d.collapsed { "+" } else { "−" };
|
||
if ui
|
||
.add(egui::Button::new(RichText::new(fold).size(14.0)).frame(false))
|
||
.on_hover_text(if d.collapsed { "Expand" } else { "Collapse" })
|
||
.clicked()
|
||
{
|
||
d.collapsed = !d.collapsed;
|
||
}
|
||
ui.label(RichText::new(heading.as_str()).strong().size(12.5));
|
||
let chevron_width = ui.spacing().interact_size.x;
|
||
crate::frame::right_aligned(ui, total, chevron_width, |ui| {
|
||
let chevron = if d.collapsed { "«" } else { "»" };
|
||
if ui
|
||
.add(egui::Button::new(RichText::new(chevron).color(t.text_dim)).frame(false).min_size(vec2(chevron_width, 0.0)))
|
||
.on_hover_text(if d.collapsed { "Expand" } else { "Collapse" })
|
||
.clicked()
|
||
{
|
||
d.collapsed = !d.collapsed;
|
||
}
|
||
});
|
||
});
|
||
if d.collapsed {
|
||
return;
|
||
}
|
||
ui.add_space(2.0);
|
||
// A sizing pass initially offers almost no height to an auto-sized window.
|
||
// Give only the fields a viewport-derived scroll budget; header and actions
|
||
// stay visible, while short forms still shrink to their natural height.
|
||
let vertical_frame = frame.inner_margin.topf() + frame.inner_margin.bottomf() + 2.0 * frame.stroke.width;
|
||
let footer_height = ui.spacing().interact_size.y.max(24.0) + 6.0 + ui.spacing().item_spacing.y;
|
||
let fields_height = (vp.bottom() - anchor.y - 8.0 - vertical_frame - ui.min_rect().height() - footer_height).max(1.0);
|
||
egui::ScrollArea::vertical().id_salt("feature_fields").min_scrolled_height(fields_height).max_height(fields_height).show(ui, |ui| {
|
||
// Configuration tables own their column widths and scrolling; the two-column form
|
||
// grid would squeeze their row names and action buttons into a label-sized cell.
|
||
if let Kind::Motion(k @ crate::dialogs_motion::Mo::Configurations { .. }) = &mut d.kind {
|
||
enter |= crate::dialogs_motion::rows(app, ui, k, &mut d.inputs);
|
||
}
|
||
egui::Grid::new("sc_dialog_grid").num_columns(2).spacing(vec2(10.0, 8.0)).show(ui, |ui| {
|
||
if matches!(&d.kind, Kind::Motion(crate::dialogs_motion::Mo::Configurations { .. })) {
|
||
return;
|
||
}
|
||
placement_row(&mut d, ui);
|
||
if matches!(&d.kind, Kind::SketchModify(k) if k.previews())
|
||
|| matches!(d.kind, Kind::Mirror | Kind::PatternRect { .. } | Kind::PatternCirc { .. } | Kind::PathPattern { .. })
|
||
{
|
||
row_label(ui, "dialog.step");
|
||
let label = d.active_input().map(|input| tr(input.label)).unwrap_or_else(|| tr("Objects"));
|
||
ui.label(crate::i18n::format(
|
||
"dialog.selection_step",
|
||
&[("step", &(d.active + 1).to_string()), ("total", &d.inputs.len().to_string()), ("input", label)],
|
||
));
|
||
ui.end_row();
|
||
row_label(ui, "");
|
||
ui.label(tr("dialog.selection_guidance"));
|
||
ui.end_row();
|
||
}
|
||
input_rows(&mut d, ui, &app.session);
|
||
match &mut d.kind {
|
||
Kind::Sketch => {
|
||
if d.error.is_some()
|
||
&& let Some(selection @ Sel::Face { .. }) = d.inputs.first().and_then(|i| i.items.first())
|
||
{
|
||
row_label(ui, "Attachment");
|
||
ui.label(tr("This face cannot provide a durable attachment. Choose another face or explicitly use a fixed plane."));
|
||
ui.end_row();
|
||
row_label(ui, "");
|
||
if ui.button(tr("Use fixed plane")).clicked()
|
||
&& let Some(mut plane) = crate::sketch_attachment_ui::face_plane(app, selection)
|
||
{
|
||
plane["fixed"] = json!(true);
|
||
match app.run("sketch.create", json!({"plane":plane})) {
|
||
Ok(_) => {
|
||
app.pre_sketch_cam = Some(app.cam);
|
||
look_at_sketch(app);
|
||
cancel = true;
|
||
}
|
||
Err(error) => d.refuse(app, error),
|
||
}
|
||
}
|
||
ui.end_row();
|
||
}
|
||
}
|
||
Kind::Extrude {
|
||
distance,
|
||
direction,
|
||
operation,
|
||
auto_op,
|
||
distance2,
|
||
taper,
|
||
taper_present,
|
||
to_offset,
|
||
start,
|
||
all,
|
||
thin,
|
||
wall,
|
||
wall_side,
|
||
wall2,
|
||
} => {
|
||
row_label(ui, "Thin");
|
||
if ui.checkbox(thin, tr("Thin Extrude")).changed() {
|
||
set_thin(&mut d.inputs, *thin);
|
||
}
|
||
ui.end_row();
|
||
if *thin {
|
||
row_label(ui, "Wall Location");
|
||
combo(ui, "ex_wall", &WALL_LABELS, wall_side);
|
||
ui.end_row();
|
||
row_label(ui, "Wall Thickness");
|
||
enter |= field(ui, wall);
|
||
ui.end_row();
|
||
if *wall_side == 3 {
|
||
row_label(ui, "Thickness Outside");
|
||
enter |= field(ui, wall2);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
row_label(ui, "Start");
|
||
let old = if object_on(&d.inputs, FROM_OBJECT) { 2 } else { usize::from(!start.is_empty()) };
|
||
let mut st = old;
|
||
combo(ui, "ex_start", &["Profile Plane", "Offset", "From Object"], &mut st);
|
||
if st != old {
|
||
set_object(&mut d.inputs, &mut d.active, FROM_OBJECT, st == 2);
|
||
if st == 1 && start.is_empty() {
|
||
*start = "5 mm".into();
|
||
}
|
||
if st == 0 {
|
||
start.clear();
|
||
}
|
||
}
|
||
ui.end_row();
|
||
if st != 0 {
|
||
row_label(ui, "Offset");
|
||
enter |= field(ui, start);
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Direction");
|
||
// One Side, Two Sides, Symmetric (a flip is a negative distance).
|
||
let order = [0usize, TWO_SIDES, 2];
|
||
let mut pos = order.iter().position(|o| o == direction).unwrap_or(0);
|
||
combo(ui, "ex_dir", &["One Side", "Two Sides", "Symmetric"], &mut pos);
|
||
if pos != order.iter().position(|o| o == direction).unwrap_or(0) {
|
||
*direction = order.get(pos).copied().unwrap_or(0);
|
||
}
|
||
ui.end_row();
|
||
if *direction < 2 {
|
||
row_label(ui, "Reverse");
|
||
let mut reverse = *direction == 1;
|
||
if ui.checkbox(&mut reverse, tr("Reverse Direction")).changed() {
|
||
*direction = usize::from(reverse);
|
||
}
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Extent Type");
|
||
let cur = if to_object_on(&d.inputs) { 1 } else { usize::from(*all) * 2 };
|
||
let mut ext = cur;
|
||
combo(ui, "ex_ext", &["Distance", "To Object", "All"], &mut ext);
|
||
*all = ext == 2;
|
||
set_to_object(&mut d.inputs, &mut d.active, ext == 1);
|
||
ui.end_row();
|
||
if ext == 0 {
|
||
row_label(ui, "Distance");
|
||
enter |= field(ui, distance);
|
||
ui.end_row();
|
||
if *direction == TWO_SIDES {
|
||
row_label(ui, "Distance 2");
|
||
enter |= field(ui, distance2);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
if ext == 1 {
|
||
row_label(ui, "To Offset");
|
||
enter |= field(ui, to_offset);
|
||
ui.end_row();
|
||
}
|
||
if *direction < 2 {
|
||
row_label(ui, "Taper Angle");
|
||
let before = taper.clone();
|
||
enter |= field(ui, taper);
|
||
if *taper != before {
|
||
*taper_present = !taper.trim().is_empty();
|
||
}
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Operation");
|
||
let before = *operation;
|
||
combo(ui, "ex_op", &OP_LABELS, operation);
|
||
// A choice made by hand sticks.
|
||
if *operation != before {
|
||
*auto_op = false;
|
||
}
|
||
ui.end_row();
|
||
}
|
||
Kind::Revolve { angle, operation, .. } => {
|
||
row_label(ui, "Type");
|
||
let cur = usize::from(to_object_on(&d.inputs));
|
||
let mut ty = cur;
|
||
combo(ui, "rv_type", &["Angle", "To Object"], &mut ty);
|
||
set_to_object(&mut d.inputs, &mut d.active, ty == 1);
|
||
ui.end_row();
|
||
if ty == 0 {
|
||
// One Side, Two Sides (a second angle), Symmetric (the angle split).
|
||
row_label(ui, "Direction");
|
||
let cur = if d.extra.contains_key("angle2") {
|
||
1
|
||
} else if d.extra.get("direction").is_some() {
|
||
2
|
||
} else {
|
||
0
|
||
};
|
||
let mut dir = cur;
|
||
combo(ui, "rv_dir", &["One Side", "Two Sides", "Symmetric"], &mut dir);
|
||
if dir != cur {
|
||
d.extra.remove("angle2");
|
||
d.extra.remove("direction");
|
||
match dir {
|
||
1 => {
|
||
d.extra.insert("angle2".into(), json!("90 deg"));
|
||
}
|
||
2 => {
|
||
d.extra.insert("direction".into(), json!("symmetric"));
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
ui.end_row();
|
||
row_label(ui, "Angle");
|
||
enter |= field(ui, angle);
|
||
ui.end_row();
|
||
if dir == 1 {
|
||
row_label(ui, "Angle 2");
|
||
enter |= extra_field(ui, &mut d.extra, "angle2", "90 deg");
|
||
ui.end_row();
|
||
}
|
||
}
|
||
row_label(ui, "Operation");
|
||
combo(ui, "rv_op", &OP_LABELS, operation);
|
||
ui.end_row();
|
||
}
|
||
Kind::Fillet { radius, chamfer, chain, ctype, distance2, angle, flip } => {
|
||
if *chamfer {
|
||
row_label(ui, "Chamfer Type");
|
||
combo(ui, "ch_type", &CHAMFER_TYPES, ctype);
|
||
ui.end_row();
|
||
}
|
||
let mut rtype = 0;
|
||
if !*chamfer {
|
||
row_label(ui, "Radius Type");
|
||
rtype = extra_choice(
|
||
ui,
|
||
&mut d.extra,
|
||
"fi_type",
|
||
"type",
|
||
&[
|
||
("Constant", "constant"),
|
||
("Chord Length", "chord"),
|
||
("Variable", "variable"),
|
||
("Spline", "spline"),
|
||
("Curvature (G2)", "curvature"),
|
||
],
|
||
);
|
||
ui.end_row();
|
||
}
|
||
row_label(
|
||
ui,
|
||
if !*chamfer {
|
||
match rtype {
|
||
1 => "Chord Length",
|
||
2 | 3 => "Start Radius",
|
||
4 => "Equivalent Radius",
|
||
_ => "Radius",
|
||
}
|
||
} else if *ctype == 0 {
|
||
"Distance"
|
||
} else {
|
||
"Distance 1"
|
||
},
|
||
);
|
||
enter |= field(ui, radius);
|
||
ui.end_row();
|
||
// A constant radius too large for the edges: refused, reduced to the
|
||
// largest that fits (the preview shows what was used), or tapered along
|
||
// the edges to the room there.
|
||
if !*chamfer && rtype == 0 {
|
||
row_label(ui, "Radius Fit");
|
||
let fit = extra_choice(
|
||
ui,
|
||
&mut d.extra,
|
||
"fi_fit",
|
||
"fit",
|
||
&[("Exact", "exact"), ("Reduce to Fit", "reduce"), ("Taper to Fit", "taper")],
|
||
);
|
||
ui.end_row();
|
||
if fit == 1
|
||
&& let Some((lo, hi)) = app.preview.applied
|
||
{
|
||
// A range where edges apart from each other fit different radii.
|
||
row_label(ui, "Applied Radius");
|
||
let shown = if hi > lo {
|
||
format!("{} – {}", crate::prefs::show_mm_bare(app, lo), crate::prefs::show_mm(app, hi, 1))
|
||
} else {
|
||
crate::prefs::show_mm(app, lo, 1)
|
||
};
|
||
ui.label(RichText::new(shown).color(t.warning));
|
||
ui.end_row();
|
||
}
|
||
} else if !*chamfer {
|
||
d.extra.remove("fit");
|
||
}
|
||
if *chamfer && *ctype == 1 {
|
||
row_label(ui, "Distance 2");
|
||
enter |= field(ui, distance2);
|
||
ui.end_row();
|
||
}
|
||
if *chamfer && *ctype == 2 {
|
||
row_label(ui, "Angle");
|
||
enter |= field(ui, angle);
|
||
ui.end_row();
|
||
}
|
||
if *chamfer && *ctype > 0 {
|
||
row_label(ui, "Flip");
|
||
ui.checkbox(flip, "");
|
||
ui.end_row();
|
||
}
|
||
if !*chamfer && rtype == 2 {
|
||
row_label(ui, "End Radius");
|
||
enter |= extra_field(ui, &mut d.extra, "radius2", "1 mm");
|
||
ui.end_row();
|
||
// Which end of the first edge takes the start radius.
|
||
row_label(ui, "Swap Ends");
|
||
extra_check(ui, &mut d.extra, "swap_ends");
|
||
ui.end_row();
|
||
// Radii between the ends: position along the edge (from the start end)
|
||
// and radius.
|
||
let mut mids = mid_points(&d.extra);
|
||
let mut remove = None;
|
||
for (k, (t, r)) in mids.iter_mut().enumerate() {
|
||
row_label(ui, "Mid Radius");
|
||
ui.horizontal(|ui| {
|
||
ui.add(egui::DragValue::new(t).speed(0.01).range(0.01..=0.99).fixed_decimals(2))
|
||
.on_hover_text(tr("Position along the edge, 0 at the start end, 1 at the other"));
|
||
enter |= field(ui, r);
|
||
if ui.small_button("×").on_hover_text(tr("Remove this point")).clicked() {
|
||
remove = Some(k);
|
||
}
|
||
});
|
||
ui.end_row();
|
||
}
|
||
if let Some(k) = remove {
|
||
mids.remove(k);
|
||
}
|
||
row_label(ui, "");
|
||
if ui.button(tr("Add Mid Radius")).clicked() && mids.len() < 20 {
|
||
let t = if mids.is_empty() { 0.5 } else { (mids.iter().map(|m| m.0).fold(0.0, f64::max) + 1.0) * 0.5 };
|
||
mids.push((t.min(0.99), radius.clone()));
|
||
}
|
||
ui.end_row();
|
||
d.extra.insert("mid".into(), json!(mids.iter().map(|(t, r)| json!([t, r])).collect::<Vec<_>>()));
|
||
if !mids.is_empty() {
|
||
row_label(ui, "Smooth");
|
||
extra_check(ui, &mut d.extra, "smooth");
|
||
ui.end_row();
|
||
}
|
||
}
|
||
if !*chamfer && rtype == 3 {
|
||
// The radius along the edge as a B-spline: its control radii from the
|
||
// start end, also dragged by their handles on the edge.
|
||
row_label(ui, "Swap Ends");
|
||
extra_check(ui, &mut d.extra, "swap_ends");
|
||
ui.end_row();
|
||
let mut radii = spline_radii(&mut d.extra, radius);
|
||
let n = radii.len();
|
||
for (k, r) in radii.iter_mut().enumerate() {
|
||
row_label(ui, if k + 1 == n { "End Radius" } else { "Control Radius" });
|
||
enter |= field(ui, r);
|
||
ui.end_row();
|
||
}
|
||
d.extra.insert("radii".into(), json!(radii));
|
||
}
|
||
row_label(ui, "Tangent Chain");
|
||
ui.checkbox(chain, "");
|
||
ui.end_row();
|
||
}
|
||
Kind::Shell { thickness } => {
|
||
row_label(ui, "Tangent Chain");
|
||
extra_check(ui, &mut d.extra, "tangent_chain");
|
||
ui.end_row();
|
||
let dir = d.extra.get("direction").and_then(Value::as_str).unwrap_or("inside").to_string();
|
||
row_label(
|
||
ui,
|
||
match dir.as_str() {
|
||
"outside" => "Outside Thickness",
|
||
"both" => "Thickness",
|
||
_ => "Inside Thickness",
|
||
},
|
||
);
|
||
enter |= field(ui, thickness);
|
||
ui.end_row();
|
||
row_label(ui, "Direction");
|
||
extra_choice(ui, &mut d.extra, "sh_dir", "direction", &[("Inside", "inside"), ("Outside", "outside"), ("Both", "both")]);
|
||
ui.end_row();
|
||
}
|
||
Kind::Draft { angle } => {
|
||
row_label(ui, "Angle");
|
||
enter |= field(ui, angle);
|
||
ui.end_row();
|
||
}
|
||
Kind::Mirror => {
|
||
row_label(ui, "Operation");
|
||
let mut op = usize::from(d.extra.get("combine").and_then(Value::as_bool).unwrap_or(false));
|
||
combo(ui, "mi_op", &["New Body", "Join"], &mut op);
|
||
d.extra.insert("combine".into(), json!(op == 1));
|
||
ui.end_row();
|
||
}
|
||
Kind::Measure { result, .. } => measure_rows(app, ui, result.as_ref()),
|
||
Kind::OffsetPlane { offset } => {
|
||
row_label(ui, "Distance");
|
||
enter |= field(ui, offset);
|
||
ui.end_row();
|
||
}
|
||
Kind::AnglePlane { angle } => {
|
||
row_label(ui, "Angle");
|
||
enter |= field(ui, angle);
|
||
ui.end_row();
|
||
}
|
||
Kind::PathPlane { t, .. } => {
|
||
row_label(ui, "Position (0 to 1)");
|
||
enter |= field(ui, t);
|
||
ui.end_row();
|
||
}
|
||
Kind::Split | Kind::ReplaceFace | Kind::Remove => {}
|
||
Kind::Rib { thickness, depth, flip, .. } => {
|
||
row_label(ui, "Thickness");
|
||
enter |= field(ui, thickness);
|
||
ui.end_row();
|
||
row_label(ui, "Depth");
|
||
let r = ui.add(egui::TextEdit::singleline(depth).hint_text(tr("to the next face")));
|
||
crate::params_dialog::complete(ui, &r, depth);
|
||
enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
|
||
ui.end_row();
|
||
row_label(ui, "Flip");
|
||
ui.checkbox(flip, "");
|
||
ui.end_row();
|
||
}
|
||
Kind::Emboss { depth, deboss } => {
|
||
row_label(ui, "Depth");
|
||
enter |= field(ui, depth);
|
||
ui.end_row();
|
||
row_label(ui, "Type");
|
||
let mut i = usize::from(*deboss);
|
||
combo(ui, "emb_mode", &["Emboss", "Deboss"], &mut i);
|
||
*deboss = i == 1;
|
||
ui.end_row();
|
||
ui.label("");
|
||
ui.add(
|
||
egui::Label::new(
|
||
"Orthogonal line profiles tangent to one supported cylinder wrap automatically. Pick a wall to choose a target.",
|
||
)
|
||
.wrap(),
|
||
);
|
||
ui.end_row();
|
||
}
|
||
Kind::Align { flip } => {
|
||
// Where on the picked face or edge to snap: as picked (a face turns to meet
|
||
// the other, an edge at its middle), its centre, or a round one's centre.
|
||
for (label, key) in [("From Snap", "from_snap"), ("To Snap", "to_snap")] {
|
||
row_label(ui, label);
|
||
extra_choice(ui, &mut d.extra, key, key, &[("As Picked", "picked"), ("Centre", "center"), ("Circle Centre", "circle")]);
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Flip");
|
||
ui.checkbox(flip, "");
|
||
ui.end_row();
|
||
}
|
||
Kind::BoundaryFill { operation, cells, .. } => {
|
||
row_label(ui, "Cells");
|
||
if cells.is_empty() {
|
||
ui.label(RichText::new(tr("Pick the tool bodies")).color(Tokens::get().text_dim));
|
||
}
|
||
ui.end_row();
|
||
for (i, (_, label, on)) in cells.iter_mut().enumerate() {
|
||
row_label(ui, &format!("Cell {}", i + 1));
|
||
ui.checkbox(on, label.as_str());
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Operation");
|
||
combo(ui, "bf_op", &OP_LABELS, operation);
|
||
ui.end_row();
|
||
row_label(ui, "Remove Tools");
|
||
extra_check(ui, &mut d.extra, "remove_tools");
|
||
ui.end_row();
|
||
}
|
||
Kind::PathPattern { count, spacing } => {
|
||
for (l, v) in [("Quantity", count), ("Spacing", spacing)] {
|
||
row_label(ui, l);
|
||
enter |= field(ui, v);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
Kind::Pipe { diameter, wall } => {
|
||
row_label(ui, "Diameter");
|
||
enter |= field(ui, diameter);
|
||
ui.end_row();
|
||
row_label(ui, "Wall");
|
||
let r = ui.add(egui::TextEdit::singleline(wall).hint_text("solid"));
|
||
crate::params_dialog::complete(ui, &r, wall);
|
||
enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
|
||
ui.end_row();
|
||
}
|
||
Kind::Stock { margin } => {
|
||
row_label(ui, "Margin");
|
||
enter |= field(ui, margin);
|
||
ui.end_row();
|
||
}
|
||
Kind::Scale { factor } => {
|
||
row_label(ui, "Scale factor");
|
||
enter |= field(ui, factor);
|
||
ui.end_row();
|
||
}
|
||
Kind::OffsetFaces { distance } => {
|
||
row_label(ui, "Distance");
|
||
enter |= field(ui, distance);
|
||
ui.end_row();
|
||
}
|
||
Kind::Thread { designation, length } => {
|
||
// Fusion's order: Modeled, Full Length, then the size; a length only when not
|
||
// full.
|
||
row_label(ui, "Modeled");
|
||
extra_check(ui, &mut d.extra, "modeled");
|
||
ui.end_row();
|
||
row_label(ui, "Full Length");
|
||
let mut full = length.trim().is_empty();
|
||
if ui.checkbox(&mut full, "").changed() {
|
||
*length = if full { String::new() } else { "10 mm".into() };
|
||
}
|
||
ui.end_row();
|
||
row_label(ui, "Size");
|
||
let r = ui.add(egui::TextEdit::singleline(designation).hint_text(tr("fits the face, e.g. M8")));
|
||
enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
|
||
ui.end_row();
|
||
if !full {
|
||
row_label(ui, "Length");
|
||
enter |= field(ui, length);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
Kind::Material { index } => {
|
||
let names: Vec<&str> = material_names.iter().map(String::as_str).collect();
|
||
row_label(ui, "Material");
|
||
combo(ui, "mat", &names, index);
|
||
ui.end_row();
|
||
}
|
||
Kind::Section { offset, flip } => {
|
||
row_label(ui, "Distance");
|
||
enter |= field(ui, offset);
|
||
ui.end_row();
|
||
row_label(ui, "Flip");
|
||
ui.checkbox(flip, "");
|
||
ui.end_row();
|
||
}
|
||
Kind::PatternRect { count, spacing, count2, spacing2 } => {
|
||
for (l, v) in [("Quantity", count), ("Spacing", spacing), ("Quantity 2", count2), ("Spacing 2", spacing2)] {
|
||
row_label(ui, l);
|
||
enter |= field(ui, v);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
Kind::PatternCirc { count, angle } => {
|
||
for (l, v) in [("Quantity", count), ("Total angle", angle)] {
|
||
row_label(ui, l);
|
||
enter |= field(ui, v);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
Kind::Loft { operation } => {
|
||
row_label(ui, "Operation");
|
||
combo(ui, "lf_op", &OP_LABELS, operation);
|
||
ui.end_row();
|
||
}
|
||
Kind::Sweep { operation } => {
|
||
row_label(ui, "Operation");
|
||
combo(ui, "sw_op", &OP_LABELS, operation);
|
||
ui.end_row();
|
||
}
|
||
k @ Kind::Move { .. } => {
|
||
enter |= crate::dialogs_move::rows(ui, k);
|
||
row_label(ui, "Create Copy");
|
||
extra_check(ui, &mut d.extra, "copy");
|
||
ui.end_row();
|
||
}
|
||
Kind::Hole { diameter, depth, kind, cb_diameter, cb_depth, cs_diameter, cs_angle, opts } => {
|
||
row_label(ui, "Extents");
|
||
let cur = if to_object_on(&d.inputs) { 1 } else { usize::from(opts.all) * 2 };
|
||
let mut ext = cur;
|
||
combo(ui, "hole_ext", &["Distance", "To Object", "All"], &mut ext);
|
||
opts.all = ext == 2;
|
||
set_to_object(&mut d.inputs, &mut d.active, ext == 1);
|
||
ui.end_row();
|
||
if opts.multiple {
|
||
// Every point of the picked points' sketches (standalone points and
|
||
// circle centres), not just the picked ones.
|
||
row_label(ui, "All Sketch Points");
|
||
extra_check(ui, &mut d.extra, "all_points");
|
||
ui.end_row();
|
||
// The holes go into the part the sketch touches; Flip drills the
|
||
// other way.
|
||
row_label(ui, "Flip");
|
||
extra_check(ui, &mut d.extra, "flip");
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Hole Type");
|
||
combo(ui, "hole_kind", &HOLE_LABELS, kind);
|
||
ui.end_row();
|
||
row_label(ui, "Hole Tap Type");
|
||
let mut tap = usize::from(opts.tapped);
|
||
combo(ui, "hole_tap", &["Simple", "Tapped"], &mut tap);
|
||
opts.tapped = tap == 1;
|
||
ui.end_row();
|
||
if opts.tapped {
|
||
row_label(ui, "Size");
|
||
let r = ui.add(egui::TextEdit::singleline(&mut opts.thread).hint_text("M5"));
|
||
enter |= r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
|
||
ui.end_row();
|
||
}
|
||
if *kind == 0 {
|
||
row_label(ui, "Drill Point");
|
||
let mut tip = usize::from(opts.angled);
|
||
combo(ui, "hole_tip", &["Flat", "Angle"], &mut tip);
|
||
opts.angled = tip == 1;
|
||
ui.end_row();
|
||
}
|
||
if !opts.all {
|
||
row_label(ui, "Depth");
|
||
enter |= field(ui, depth);
|
||
ui.end_row();
|
||
}
|
||
if *kind == 0 && opts.angled {
|
||
row_label(ui, "Tip Angle");
|
||
enter |= field(ui, &mut opts.tip_angle);
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Diameter");
|
||
enter |= field(ui, diameter);
|
||
ui.end_row();
|
||
if *kind == 1 {
|
||
row_label(ui, "Counterbore Ø");
|
||
enter |= field(ui, cb_diameter);
|
||
ui.end_row();
|
||
row_label(ui, "Counterbore depth");
|
||
enter |= field(ui, cb_depth);
|
||
ui.end_row();
|
||
}
|
||
if *kind == 2 {
|
||
row_label(ui, "Countersink Ø");
|
||
enter |= field(ui, cs_diameter);
|
||
ui.end_row();
|
||
row_label(ui, "Countersink angle");
|
||
enter |= field(ui, cs_angle);
|
||
ui.end_row();
|
||
}
|
||
}
|
||
Kind::Primitive { fields, operation, at, .. } => {
|
||
for (k, v) in fields.iter_mut() {
|
||
row_label(ui, k);
|
||
enter |= field(ui, v);
|
||
ui.end_row();
|
||
}
|
||
if let Some((p, _)) = *at {
|
||
row_label(ui, "Position");
|
||
ui.horizontal(|ui| {
|
||
ui.label(format!("{:.2}, {:.2}, {:.2}", p.x, p.y, p.z));
|
||
if ui.small_button("×").on_hover_text(tr("Place at the origin instead")).clicked() {
|
||
*at = None;
|
||
}
|
||
});
|
||
ui.end_row();
|
||
}
|
||
row_label(ui, "Operation");
|
||
combo(ui, "pr_op", &OP_LABELS, operation);
|
||
ui.end_row();
|
||
}
|
||
Kind::Combine { operation, keep_tools } => {
|
||
row_label(ui, "Operation");
|
||
let mut op = operation.saturating_sub(1);
|
||
combo(ui, "cb_op", &OP_LABELS[1..], &mut op);
|
||
*operation = op + 1;
|
||
ui.end_row();
|
||
row_label(ui, "New Component");
|
||
extra_check(ui, &mut d.extra, "new_component");
|
||
ui.end_row();
|
||
row_label(ui, "Keep Tools");
|
||
ui.checkbox(keep_tools, "");
|
||
ui.end_row();
|
||
}
|
||
Kind::Params { new_name, new_expr } => params_table(app, ui, new_name, new_expr),
|
||
Kind::EditParam { name, expr } => {
|
||
ui.label(name.as_str());
|
||
let r = ui.text_edit_singleline(expr);
|
||
crate::params_dialog::complete(ui, &r, expr);
|
||
if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
|
||
ok = true;
|
||
}
|
||
r.request_focus();
|
||
ui.end_row();
|
||
}
|
||
Kind::Rename { name, .. } => {
|
||
row_label(ui, "Name");
|
||
let r = ui.text_edit_singleline(name);
|
||
if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
|
||
ok = true;
|
||
}
|
||
r.request_focus();
|
||
ui.end_row();
|
||
}
|
||
Kind::Assembly(k) => enter |= crate::dialogs_assembly::rows(app, ui, k, &mut d.inputs, &mut d.active),
|
||
Kind::Sheet(k) => enter |= crate::dialogs_sheet::rows(app, ui, k, &mut d.inputs),
|
||
Kind::Surface(k) => enter |= crate::dialogs_surface::rows(ui, k),
|
||
Kind::SketchModify(k) => enter |= crate::sketch_modify_ui::rows(ui, k),
|
||
Kind::Plastic(k) => enter |= crate::dialogs_plastic::rows(app, ui, k, &d.inputs),
|
||
Kind::Appearance(k) => enter |= crate::dialogs_appearance::rows(app, ui, k, &mut d.inputs),
|
||
Kind::Motion(k) => enter |= crate::dialogs_motion::rows(app, ui, k, &mut d.inputs),
|
||
Kind::Part(k) => enter |= crate::dialogs_parts::rows(app, ui, k, &d.inputs),
|
||
Kind::Text(k) => enter |= crate::sketch_text::rows(ui, k, &mut d.inputs, &mut d.active),
|
||
Kind::TextMove(k) => enter |= crate::sketch_text_move::rows(ui, k),
|
||
Kind::ConfirmDelete { with, fail, .. } => {
|
||
if !with.is_empty() {
|
||
row_label(ui, "Also deletes");
|
||
ui.label(with.join(", "));
|
||
ui.end_row();
|
||
}
|
||
if !fail.is_empty() {
|
||
row_label(ui, "Will fail");
|
||
ui.label(RichText::new(fail.join(", ")).color(t.warning));
|
||
ui.end_row();
|
||
}
|
||
}
|
||
}
|
||
if matches!(d.kind, Kind::SketchModify(_))
|
||
&& d.previews()
|
||
&& let Err(error) = apply_commands(app, &d)
|
||
{
|
||
d.refuse(app, error);
|
||
}
|
||
if let Some(e) = d.error.as_ref().or(app.preview.error.as_ref()).cloned() {
|
||
row_label(ui, "");
|
||
ui.vertical(|ui| {
|
||
ui.add(egui::Label::new(RichText::new(e.as_str()).color(t.error)).wrap());
|
||
let response = ui.button("Create Issue…");
|
||
crate::scenario::publish_handle("dialog:create_issue", response.rect.center());
|
||
if response.clicked() {
|
||
crate::issue_report::begin(app, ctx, Some(&d), Some(&e));
|
||
}
|
||
});
|
||
ui.end_row();
|
||
}
|
||
});
|
||
});
|
||
ui.add_space(6.0);
|
||
// Footer: an info glyph at the left, OK and Cancel at the right.
|
||
ui.horizontal(|ui| {
|
||
let (r, resp) = ui.allocate_exact_size(vec2(16.0, 16.0), egui::Sense::hover());
|
||
ui.painter().circle_stroke(r.center(), 7.0, Stroke::new(1.2, t.text_dim));
|
||
ui.painter().text(r.center(), egui::Align2::CENTER_CENTER, "i", egui::FontId::proportional(11.0), t.text_dim);
|
||
resp.on_hover_text(heading.as_str());
|
||
// The spinner's place is always taken: a widget that comes and goes would shift
|
||
// the automatic ids of OK and Cancel, and a click pressed in one frame and
|
||
// released in the next would be lost (an animating preview toggles it often).
|
||
let (sr, sresp) = ui.allocate_exact_size(vec2(14.0, 14.0), egui::Sense::hover());
|
||
if app.preview.busy {
|
||
egui::Spinner::new().size(14.0).paint_at(ui, sr);
|
||
sresp.on_hover_text(tr("Updating the preview"));
|
||
}
|
||
let raw_label = if matches!(d.kind, Kind::ConfirmDelete { .. }) { "Delete" } else { "OK" };
|
||
let label = tr(raw_label);
|
||
let raw_close = if matches!(d.kind, Kind::Params { .. } | Kind::Measure { .. }) { "Close" } else { "Cancel" };
|
||
let close = tr(raw_close);
|
||
let button_width = |text: &str| {
|
||
let galley = egui::WidgetText::from(text).into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, egui::TextStyle::Button);
|
||
(galley.size().x + 2.0 * ui.spacing().button_padding.x).max(64.0)
|
||
};
|
||
let (ok_width, close_width) = (button_width(label), button_width(close));
|
||
let buttons = close_width + if has_ok { ok_width + ui.spacing().item_spacing.x } else { 0.0 };
|
||
crate::frame::right_aligned(ui, total, buttons, |ui| {
|
||
if has_ok {
|
||
let b = egui::Button::new(RichText::new(label).color(if valid { Color32::WHITE } else { t.text_dim }))
|
||
.fill(if valid { t.accent } else { Color32::TRANSPARENT })
|
||
.wrap_mode(egui::TextWrapMode::Extend)
|
||
.min_size(vec2(ok_width, 24.0));
|
||
let r = ui.add_enabled(valid, b);
|
||
crate::scenario::publish_handle(&format!("dialog:{raw_label}"), r.rect.center());
|
||
if r.clicked() {
|
||
ok = true;
|
||
}
|
||
}
|
||
if ui.add(egui::Button::new(close).wrap_mode(egui::TextWrapMode::Extend).min_size(vec2(close_width, 24.0))).clicked() {
|
||
cancel = true;
|
||
}
|
||
});
|
||
});
|
||
crate::frame::remember_width(ui, wkey);
|
||
});
|
||
app.viewport.dialog_rect = response.map(|r| r.response.rect);
|
||
if let Some(r) = app.viewport.dialog_rect {
|
||
crate::scenario::publish_rect("dialog:outer", r);
|
||
}
|
||
// Keyboard: Enter applies (from a value field, or with nothing focused), Esc cancels.
|
||
let (enter_free, esc) = ctx.input(|i| (i.key_pressed(egui::Key::Enter), i.key_pressed(egui::Key::Escape)));
|
||
let nothing_focused = ctx.memory(|m| m.focused().is_none());
|
||
let canvas_enter = enter_free && ctx.memory(|m| m.had_focus_last_frame(egui::Id::new("sc_canvas_value")));
|
||
// Tables (configurations, a study's keys) take Enter for their cells.
|
||
let enter_applies = !matches!(d.kind, Kind::Sketch | Kind::Params { .. } | Kind::Measure { .. } | Kind::ConfirmDelete { .. })
|
||
&& !matches!(&d.kind, Kind::Motion(k) if k.wide());
|
||
let report_active = app.issue_report.draft.is_some();
|
||
if !report_active && enter_applies && (enter || canvas_enter || (enter_free && nothing_focused)) {
|
||
ok = true;
|
||
}
|
||
if !report_active && esc && !app.esc_handled {
|
||
app.esc_handled = true;
|
||
cancel = true;
|
||
}
|
||
// A plane picked for a new sketch starts it right away.
|
||
let mut then_start = None;
|
||
if matches!(d.kind, Kind::Sketch)
|
||
&& d.error.is_none()
|
||
&& let Some(sel) = d.inputs.first().and_then(|i| i.items.first()).cloned()
|
||
{
|
||
match start_sketch(app, &sel) {
|
||
Ok(()) => {
|
||
cancel = true;
|
||
then_start = d.then_start;
|
||
}
|
||
Err(error) => d.refuse(app, error),
|
||
}
|
||
}
|
||
if ok {
|
||
// Edit Text applies its own way: its live changes and OK are one undo step.
|
||
let run = match &mut d.kind {
|
||
Kind::Text(k) => crate::sketch_text::apply(app, k),
|
||
_ => run_dialog(app, &d),
|
||
};
|
||
match run {
|
||
Ok(()) => {
|
||
cancel = true;
|
||
applied = true;
|
||
}
|
||
Err(e) => d.refuse(app, e),
|
||
}
|
||
}
|
||
if !keep || cancel {
|
||
crate::dialogs_motion::closed(app, &mut d, applied);
|
||
if let Kind::Text(k) = &mut d.kind {
|
||
crate::sketch_text::closed(app, k, applied);
|
||
}
|
||
}
|
||
// The edited text's outlines are new curves: the old selection would name stale ids.
|
||
if applied && matches!(d.kind, Kind::Text(_) | Kind::TextMove(_)) {
|
||
let _ = app.session.execute("select.clear", &json!({}));
|
||
}
|
||
if keep && !cancel {
|
||
// The canvas follows Edit Text's fields.
|
||
if let Kind::Text(k) = &mut d.kind {
|
||
crate::sketch_text::preview(app, k);
|
||
}
|
||
app.dialog = Some(d);
|
||
} else if let Some((_, marker)) = d.editing {
|
||
// Editing done: put the timeline marker back where it was.
|
||
let _ = roll_marker(app, marker);
|
||
}
|
||
// The shortcut that asked for this sketch starts its tool in it.
|
||
if let Some(id) = then_start {
|
||
app.start(id);
|
||
}
|
||
}
|
||
|
||
/// Close the dialog without applying it (Esc, Cancel). An edit puts the timeline marker back.
|
||
pub fn cancel(app: &mut SolveApp) {
|
||
if let Some(mut d) = app.dialog.take() {
|
||
crate::dialogs_motion::closed(app, &mut d, false);
|
||
if let Kind::Text(k) = &mut d.kind {
|
||
crate::sketch_text::closed(app, k, false);
|
||
}
|
||
app.dialog = Some(d);
|
||
}
|
||
if let Some(d) = app.dialog.take()
|
||
&& let Some((_, marker)) = d.editing
|
||
{
|
||
let _ = roll_marker(app, marker);
|
||
}
|
||
}
|
||
|
||
/// Temporary rollback used by an editor is view state. Preserve both history stacks,
|
||
/// including redo and a history already at the undo limit.
|
||
pub(crate) fn roll_marker(app: &mut SolveApp, marker: Option<usize>) -> Result<(), String> {
|
||
let undo = std::mem::take(&mut app.session.undo);
|
||
let redo = std::mem::take(&mut app.session.redo);
|
||
let selection = std::mem::take(&mut app.session.selection);
|
||
let result = app.run("timeline.roll_to", marker.map(|m| json!({"position":m})).unwrap_or_else(|| json!({})));
|
||
app.session.undo = undo;
|
||
app.session.redo = redo;
|
||
app.session.selection = selection;
|
||
result.map(|_| ())
|
||
}
|
||
|
||
/// The pick input an extent of To Object adds (a face, vertex or point to go to).
|
||
const TO_OBJECT: &str = "To Object";
|
||
const FROM_OBJECT: &str = "From Object";
|
||
|
||
fn object_on(inputs: &[SelInput], label: &str) -> bool {
|
||
inputs.iter().any(|i| i.label == label)
|
||
}
|
||
|
||
fn to_object_on(inputs: &[SelInput]) -> bool {
|
||
inputs.iter().any(|i| i.label == TO_OBJECT)
|
||
}
|
||
|
||
/// Add or remove the To Object input; the active input moves to it when it is added.
|
||
fn set_to_object(inputs: &mut Vec<SelInput>, active: &mut usize, on: bool) {
|
||
set_object(inputs, active, TO_OBJECT, on);
|
||
}
|
||
|
||
fn set_object(inputs: &mut Vec<SelInput>, active: &mut usize, label: &'static str, on: bool) {
|
||
if on && !object_on(inputs, label) {
|
||
inputs.push(SelInput::new(label, FACES | selection::VERTICES, false));
|
||
*active = inputs.len() - 1;
|
||
} else if !on && object_on(inputs, label) {
|
||
inputs.retain(|i| i.label != label);
|
||
*active = (*active).min(inputs.len().saturating_sub(1));
|
||
}
|
||
}
|
||
|
||
/// The picked To Object place.
|
||
fn to_object_point(inputs: &[SelInput]) -> Option<Value> {
|
||
object_point(inputs, TO_OBJECT)
|
||
}
|
||
|
||
pub(crate) fn object_point(inputs: &[SelInput], label: &str) -> Option<Value> {
|
||
inputs.iter().find(|i| i.label == label)?.items.first().and_then(|x| match x {
|
||
Sel::Face { point, .. } | Sel::Vertex { point, .. } | Sel::Edge { point, .. } => Some(pt(*point)),
|
||
_ => None,
|
||
})
|
||
}
|
||
|
||
/// A To Object input filled from a stored place (editing).
|
||
fn with_to_object(d: &mut Dialog, s: &Session, to: Option<Vec3>) {
|
||
with_object(d, s, TO_OBJECT, to);
|
||
}
|
||
|
||
fn with_object(d: &mut Dialog, s: &Session, label: &'static str, to: Option<Vec3>) {
|
||
if let Some(p) = to {
|
||
set_object(&mut d.inputs, &mut d.active, label, true);
|
||
if let Some(inp) = d.inputs.iter_mut().find(|i| i.label == label) {
|
||
inp.items = vec![face_sel(s, p).unwrap_or(Sel::Vertex { body: String::new(), point: p })];
|
||
}
|
||
}
|
||
}
|
||
|
||
/// A choice row stored in the dialog's extra parameters as `key: value` (the first choice, the
|
||
/// command's default, is stored as no key at all).
|
||
fn extra_choice(ui: &mut egui::Ui, extra: &mut serde_json::Map<String, Value>, id: &str, key: &str, choices: &[(&str, &str)]) -> usize {
|
||
let cur = extra.get(key).and_then(Value::as_str).and_then(|v| choices.iter().position(|(_, x)| *x == v)).unwrap_or(0);
|
||
let mut i = cur;
|
||
let labels: Vec<&str> = choices.iter().map(|(l, _)| *l).collect();
|
||
combo(ui, id, &labels, &mut i);
|
||
if i != cur {
|
||
match choices.get(i) {
|
||
Some((_, v)) if i > 0 => {
|
||
extra.insert(key.into(), json!(v));
|
||
}
|
||
_ => {
|
||
extra.remove(key);
|
||
}
|
||
}
|
||
}
|
||
i
|
||
}
|
||
|
||
/// A checkbox stored in the dialog's extra parameters.
|
||
fn extra_check(ui: &mut egui::Ui, extra: &mut serde_json::Map<String, Value>, key: &str) {
|
||
let mut on = extra.get(key).and_then(Value::as_bool).unwrap_or(false);
|
||
let r = ui.checkbox(&mut on, "");
|
||
if r.changed() {
|
||
extra.insert(key.into(), json!(on));
|
||
}
|
||
// The box carries no text of its own, so a scenario reaches it by its row handle.
|
||
publish_row(&r);
|
||
}
|
||
|
||
/// A value field stored in the dialog's extra parameters (`default` until edited).
|
||
fn extra_field(ui: &mut egui::Ui, extra: &mut serde_json::Map<String, Value>, key: &str, default: &str) -> bool {
|
||
let mut v = extra.get(key).and_then(Value::as_str).unwrap_or(default).to_string();
|
||
let enter = field(ui, &mut v);
|
||
extra.insert(key.into(), json!(v));
|
||
enter
|
||
}
|
||
|
||
/// A spline fillet's control radii after the start radius, as expressions. A dialog without a
|
||
/// spline yet gets a cubic one of two spans, all its control radii `radius`.
|
||
pub(crate) fn spline_radii(extra: &mut serde_json::Map<String, Value>, radius: &str) -> Vec<String> {
|
||
let radii: Vec<String> = extra
|
||
.get("radii")
|
||
.and_then(Value::as_array)
|
||
.into_iter()
|
||
.flatten()
|
||
.filter_map(|r| match r {
|
||
Value::String(x) => Some(x.clone()),
|
||
Value::Number(n) => Some(n.to_string()),
|
||
_ => None,
|
||
})
|
||
.collect();
|
||
let knots = extra.get("knots").and_then(Value::as_array).map_or(0, Vec::len);
|
||
// All control radii (the start radius and these) plus the degree (1…3) plus one.
|
||
if !radii.is_empty() && (radii.len() + 3..=radii.len() + 5).contains(&knots) {
|
||
return radii;
|
||
}
|
||
extra.insert("knots".into(), json!([0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0]));
|
||
vec![radius.to_string(); 4]
|
||
}
|
||
|
||
/// A variable fillet's middle radii as (position, radius expression).
|
||
fn mid_points(extra: &serde_json::Map<String, Value>) -> Vec<(f64, String)> {
|
||
extra
|
||
.get("mid")
|
||
.and_then(Value::as_array)
|
||
.into_iter()
|
||
.flatten()
|
||
.filter_map(|m| {
|
||
let t = m.get(0)?.as_f64()?;
|
||
let r = match m.get(1)? {
|
||
Value::String(x) => x.clone(),
|
||
Value::Number(n) => n.to_string(),
|
||
_ => return None,
|
||
};
|
||
Some((t, r))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
pub(crate) const CHAMFER_TYPES: [&str; 3] = ["Equal Distance", "Two Distances", "Distance and Angle"];
|
||
|
||
/// A new Fillet or Chamfer dialog's values.
|
||
fn fillet_kind(size: &str, chamfer: bool) -> Kind {
|
||
Kind::Fillet { radius: size.into(), chamfer, chain: true, ctype: 0, distance2: size.into(), angle: "45 deg".into(), flip: false }
|
||
}
|
||
|
||
/// A length field's first text: `number` in the design's units, with the unit written out so the
|
||
/// field shows it as the other dialogs show theirs ("20 mm", "20 in"). OK makes the size the bare
|
||
/// number would.
|
||
fn length_default(s: &Session, number: &str) -> String {
|
||
match s.doc.with_design_unit(number, ValueKind::Length) {
|
||
e if e != number => e,
|
||
// A millimetre design (or one whose units are not a length): bare numbers are mm.
|
||
_ => format!("{} mm", number.trim()),
|
||
}
|
||
}
|
||
|
||
/// A feature's length as its edit field shows it. A bare number is kept in millimetres: where the
|
||
/// design reads bare numbers in another unit, the field says "mm" (as the configuration table
|
||
/// does), so OK keeps the size. Anything else shows as stored.
|
||
fn stored_length(s: &Session, e: &str) -> String {
|
||
if s.doc.with_design_unit(e, ValueKind::Length) == e { e.to_string() } else { format!("{} mm", e.trim()) }
|
||
}
|
||
|
||
fn hole_defaults() -> Kind {
|
||
Kind::Hole {
|
||
diameter: "5 mm".into(),
|
||
depth: "10 mm".into(),
|
||
kind: 0,
|
||
cb_diameter: "9 mm".into(),
|
||
cb_depth: "3 mm".into(),
|
||
cs_diameter: "10 mm".into(),
|
||
cs_angle: "90 deg".into(),
|
||
opts: HoleOpts::default(),
|
||
}
|
||
}
|
||
|
||
fn params_table(app: &mut SolveApp, ui: &mut egui::Ui, new_name: &mut String, new_expr: &mut String) {
|
||
let t = Tokens::get();
|
||
ui.label(RichText::new(tr("Name")).strong());
|
||
ui.label(RichText::new(tr("Expression · value")).strong());
|
||
ui.end_row();
|
||
let (vals, errs) = app.session.doc.param_values();
|
||
let params = app.session.doc.params.clone();
|
||
for p in params {
|
||
ui.label(if p.model { RichText::new(&p.name).color(t.text_dim) } else { RichText::new(&p.name) });
|
||
ui.horizontal(|ui| {
|
||
let id = egui::Id::new(("pexpr", &p.name));
|
||
let mut e = ui.data(|dd| dd.get_temp::<String>(id)).unwrap_or_else(|| p.expr.clone());
|
||
let r = ui.add(egui::TextEdit::singleline(&mut e).desired_width(160.0));
|
||
let refused_id = egui::Id::new(("prefused", &p.name));
|
||
if r.changed() {
|
||
// Typing again clears the reason a previous change was refused.
|
||
ui.data_mut(|dd| {
|
||
dd.insert_temp(id, e.clone());
|
||
dd.remove::<String>(refused_id);
|
||
});
|
||
}
|
||
if r.lost_focus() && e != p.expr {
|
||
match change_param(app, &p.name, &e) {
|
||
Ok(()) => ui.data_mut(|dd| {
|
||
dd.remove::<String>(id);
|
||
dd.remove::<String>(refused_id);
|
||
}),
|
||
// Refused (it would leave a sketch unsolved, say): the typed expression
|
||
// stays in the field with the reason beside it, nothing silently reverts.
|
||
Err(why) => ui.data_mut(|dd| {
|
||
dd.insert_temp(refused_id, why);
|
||
}),
|
||
}
|
||
}
|
||
let refused = ui.data(|dd| dd.get_temp::<String>(refused_id));
|
||
let v = vals.get(&p.name).map(|v| if p.unit == "deg" { format!("{:.3}°", v.v.to_degrees()) } else { format!("{:.4} {}", v.v, p.unit) });
|
||
match (v, errs.get(&p.name).or(refused.as_ref())) {
|
||
(_, Some(e)) => ui.label(RichText::new(e).color(t.error)),
|
||
(Some(v), None) => ui.label(RichText::new(v).color(t.text_dim)),
|
||
_ => ui.label(""),
|
||
};
|
||
});
|
||
ui.end_row();
|
||
}
|
||
ui.add(egui::TextEdit::singleline(new_name).hint_text(tr("new name")).desired_width(110.0));
|
||
ui.horizontal(|ui| {
|
||
ui.add(egui::TextEdit::singleline(new_expr).hint_text(tr("expression, e.g. 25 mm")).desired_width(160.0));
|
||
if ui.button(tr("Add")).clicked()
|
||
&& !new_name.is_empty()
|
||
&& app.run("parameters.change", json!({"name": new_name, "expression": new_expr})).is_ok()
|
||
{
|
||
new_name.clear();
|
||
new_expr.clear();
|
||
}
|
||
});
|
||
ui.end_row();
|
||
}
|
||
|
||
/// Set a parameter's expression from the parameters table: `Err` with the message to show
|
||
/// beside the field when the change is refused (the document keeps its values).
|
||
pub(crate) fn change_param(app: &mut SolveApp, name: &str, expression: &str) -> Result<(), String> {
|
||
app.run("parameters.change", json!({"name": name, "expression": expression}))
|
||
.map(|_| ())
|
||
.map_err(|e| crate::friendly_error("parameters.change", &e))
|
||
}
|
||
|
||
/// Start a sketch on a picked plane or planar face and turn the view to face it.
|
||
pub fn start_sketch(app: &mut SolveApp, sel: &Sel) -> Result<(), String> {
|
||
let plane = match sel {
|
||
Sel::Plane { name } => json!(name),
|
||
Sel::Face { .. } => crate::sketch_attachment_ui::face_plane(app, sel).ok_or("Selected face placement no longer exists")?,
|
||
_ => return Err("Select an origin plane, construction plane or planar body face".into()),
|
||
};
|
||
let before = app.cam;
|
||
app.run("sketch.create", json!({ "plane": plane })).map_err(|error| crate::friendly_error("sketch.create", &error))?;
|
||
app.pre_sketch_cam = Some(before);
|
||
look_at_sketch(app);
|
||
// On a face: look at the picked point, not the plane's origin (a corner of the face),
|
||
// which left the face filling the view off-centre like a big square.
|
||
if let Sel::Face { point, .. } = sel
|
||
&& let Some(mut to) = app.cam_anim.as_ref().map(|a| a.to)
|
||
{
|
||
to.target = *point;
|
||
app.animate_to(to);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Animate the camera to look straight at the active sketch plane.
|
||
pub fn look_at_sketch(app: &mut SolveApp) {
|
||
let st = app.session.world_state();
|
||
if let Some(ss) = app.session.active_sketch.and_then(|id| st.sketch(id)) {
|
||
let mut to = app.cam.looking_from(ss.plane.normal());
|
||
// Keep the sketch's own x axis to the right when looking straight down or up.
|
||
if ss.plane.normal().z.abs() > 0.999 {
|
||
let x = ss.plane.x;
|
||
to.yaw = if ss.plane.normal().z > 0.0 { (-x.y).atan2(x.x) } else { x.y.atan2(x.x) };
|
||
}
|
||
to.target = ss.plane.origin;
|
||
app.animate_to(to);
|
||
}
|
||
}
|
||
|
||
fn sels(d: &Dialog, i: usize) -> &[Sel] {
|
||
d.inputs.get(i).map(|x| x.items.as_slice()).unwrap_or(&[])
|
||
}
|
||
|
||
fn run_dialog(app: &mut SolveApp, d: &Dialog) -> Result<(), String> {
|
||
let commands = apply_commands(app, d)?;
|
||
// The live preview may be computing these very commands: OK takes its result.
|
||
crate::preview::settle(app, &commands);
|
||
if let Some((_, marker)) = d.editing {
|
||
// Record the actual pre-edit timeline state in the command's undo snapshot.
|
||
roll_marker(app, marker)?;
|
||
}
|
||
for (cmd, params) in commands {
|
||
if let Err(error) = app.run(&cmd, params) {
|
||
if let Some((id, _)) = d.editing {
|
||
let position = app.session.doc.feature_index(id);
|
||
let _ = roll_marker(app, position);
|
||
}
|
||
return Err(error);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Placement used to edit a definition in the selected authoring occurrence.
|
||
pub(crate) fn feature_frame(s: &Session, component: u64) -> solidcraft_engine::doc::Mat {
|
||
if component == s.active_component { s.active_component_frame() } else { s.placed_document().component_transform(component) }
|
||
}
|
||
|
||
/// The feature dialog's current operation name for a reviewed issue draft.
|
||
pub(crate) fn report_title(d: &Dialog) -> String {
|
||
title(&d.kind).to_string()
|
||
}
|
||
|
||
/// The commands OK runs (an edit rebuilds its feature in place); the live preview runs the same.
|
||
pub fn apply_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, String> {
|
||
let cmds = dialog_commands(app, d)?;
|
||
if let Some((id, _)) = d.editing {
|
||
let (cmd, mut params) = cmds.into_iter().next().ok_or("nothing to apply")?;
|
||
if let Some(feature) = app.session.doc.feature(id) {
|
||
let original_all = match &feature.kind {
|
||
FeatureKind::Extrude { sketch, profiles: ProfileSel::All, thin: None, .. }
|
||
| FeatureKind::Revolve { sketch, profiles: ProfileSel::All, .. }
|
||
| FeatureKind::Emboss { sketch, profiles: ProfileSel::All, .. } => Some(*sketch),
|
||
_ => None,
|
||
};
|
||
if let Some(sketch) = original_all
|
||
&& !d.profile_selection_changed
|
||
&& let Some(ss) = app.session.world_state().sketch(sketch)
|
||
{
|
||
let mut selected: Vec<usize> = sels(d, 0)
|
||
.iter()
|
||
.filter_map(|item| match item {
|
||
Sel::Profile { sketch: id, index } if *id == sketch => Some(*index),
|
||
_ => None,
|
||
})
|
||
.collect();
|
||
selected.sort_unstable();
|
||
selected.dedup();
|
||
if selected == (0..ss.profiles.len()).collect::<Vec<_>>() && sels(d, 0).len() == selected.len() {
|
||
params["profiles"] = json!("all");
|
||
}
|
||
}
|
||
}
|
||
return Ok(vec![("timeline.redefine".into(), json!({"feature": id, "command": cmd, "params": params}))]);
|
||
}
|
||
Ok(cmds)
|
||
}
|
||
|
||
/// The commands the live preview runs: OK's, with a joint's motion while it animates.
|
||
pub fn preview_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, String> {
|
||
let mut cmds = apply_commands(app, d)?;
|
||
if let Kind::Assembly(k) = &d.kind {
|
||
crate::dialogs_assembly::animate(app, k, &mut cmds);
|
||
}
|
||
Ok(cmds)
|
||
}
|
||
|
||
/// A wrapped Emboss edit keeps its profile guide in the saved author occurrence.
|
||
/// An invalid saved context must not draw the guide at a different occurrence.
|
||
pub(crate) fn emboss_profile_plane(app: &SolveApp, sketch: u64) -> Result<Option<solidcraft_engine::geom::Plane>, String> {
|
||
let Some(dialog) = app.dialog.as_ref().filter(|d| matches!(d.kind, Kind::Emboss { .. })) else { return Ok(None) };
|
||
let Some((feature, _)) = dialog.editing else { return Ok(None) };
|
||
let Some(feature) = app.session.doc.feature(feature) else { return Err("the edited feature is missing".into()) };
|
||
let FeatureKind::Emboss { sketch: source, face: Some(face), .. } = &feature.kind else { return Ok(None) };
|
||
if *source != sketch {
|
||
return Ok(None);
|
||
}
|
||
let model = app.session.model.state();
|
||
let sketch = model.sketch(sketch).ok_or("the Emboss sketch is missing")?;
|
||
let body = model.body(&face.body).ok_or("the Emboss target body is missing")?;
|
||
let owner = app.session.doc.feature(sketch.feature).map(|feature| feature.component).unwrap_or(0);
|
||
let plane = sketch.plane;
|
||
let frame = face.sketch_frame(&app.session.doc, feature.component, owner, body).map_err(|error| error.to_string())?;
|
||
solidcraft_engine::geom::Plane::new(
|
||
solidcraft_engine::doc::apply_point(&frame, plane.origin),
|
||
solidcraft_engine::doc::apply_vector(&frame, plane.x),
|
||
solidcraft_engine::doc::apply_vector(&frame, plane.y),
|
||
)
|
||
.map(Some)
|
||
.ok_or_else(|| "the Emboss author frame is degenerate".into())
|
||
}
|
||
|
||
/// The commands (id, parameters) a dialog's OK runs.
|
||
fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, String> {
|
||
let s = &app.session;
|
||
let need = |i: usize, what: &str| -> Result<(), String> { if sels(d, i).is_empty() { Err(format!("select {what} first")) } else { Ok(()) } };
|
||
let profiles = || -> (Value, Value) {
|
||
let ps: Vec<(u64, usize)> =
|
||
sels(d, 0).iter().filter_map(|x| if let Sel::Profile { sketch, index } = x { Some((*sketch, *index)) } else { None }).collect();
|
||
(ps.first().map(|x| json!(x.0)).unwrap_or(Value::Null), json!(ps.iter().map(|x| x.1).collect::<Vec<_>>()))
|
||
};
|
||
let body_names =
|
||
|i: usize| -> Vec<String> { sels(d, i).iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None }).collect() };
|
||
let face_points = |i: usize| -> Vec<Value> {
|
||
sels(d, i).iter().filter_map(|x| if let Sel::Face { point, .. } = x { Some(pt(*point)) } else { None }).collect()
|
||
};
|
||
let (cmd, params): (&str, Value) = match &d.kind {
|
||
Kind::Extrude {
|
||
distance,
|
||
direction,
|
||
operation,
|
||
distance2,
|
||
taper,
|
||
taper_present,
|
||
to_offset,
|
||
start,
|
||
all,
|
||
thin,
|
||
wall,
|
||
wall_side,
|
||
wall2,
|
||
..
|
||
} => {
|
||
need(0, if *thin { "curves or profiles" } else { "profiles or a planar face" })?;
|
||
let mut common = json!({"distance": distance, "direction": DIRS.get(*direction).copied().unwrap_or("positive"), "operation": OPS.get(*operation).copied().unwrap_or("new")});
|
||
let tapered = s.doc.eval(taper, ValueKind::Angle).map(|v| v.abs() > 1e-12).unwrap_or(!taper.trim().is_empty());
|
||
if *direction == TWO_SIDES {
|
||
common["distance2"] = json!(distance2);
|
||
} else if *direction < 2 && (*taper_present || tapered) {
|
||
common["taper"] = json!(taper);
|
||
}
|
||
if !start.trim().is_empty() {
|
||
common["start_offset"] = json!(start);
|
||
}
|
||
if *all {
|
||
common["through_all"] = json!(true);
|
||
}
|
||
if to_object_on(&d.inputs) {
|
||
common["to"] = to_object_point(&d.inputs).ok_or("select the object to extrude to")?;
|
||
if !to_offset.trim().is_empty() {
|
||
common["to_offset"] = json!(to_offset);
|
||
}
|
||
}
|
||
if object_on(&d.inputs, FROM_OBJECT) {
|
||
common["from"] = object_point(&d.inputs, FROM_OBJECT).ok_or("select the object to extrude from")?;
|
||
}
|
||
let with = |extra: Value| -> Value {
|
||
let mut p = common.clone();
|
||
if let (Value::Object(m), Value::Object(e)) = (&mut p, extra) {
|
||
m.extend(e);
|
||
for (k, v) in &d.extra {
|
||
m.entry(k.clone()).or_insert_with(|| v.clone());
|
||
}
|
||
}
|
||
p
|
||
};
|
||
if *thin {
|
||
// The picked curves, and the outlines (outer and holes) of picked profiles.
|
||
let st = s.world_state();
|
||
let mut curves = curve_ids(d, 0);
|
||
let mut sketch = None;
|
||
for x in sels(d, 0) {
|
||
if let Sel::Profile { sketch: id, index } = x
|
||
&& let Some(p) = st.sketch(*id).and_then(|ss| ss.profiles.get(*index))
|
||
{
|
||
sketch = Some(*id);
|
||
curves.extend(p.curve_ids());
|
||
}
|
||
}
|
||
let mut seen = std::collections::BTreeSet::new();
|
||
curves.retain(|c| seen.insert(c.clone()));
|
||
// A picked profile's sketch, or the edited extrude's, when it has every curve.
|
||
let edited = d.editing.and_then(|(id, _)| s.doc.feature(id)).and_then(|f| match f.kind {
|
||
FeatureKind::Extrude { sketch, .. } => Some(sketch),
|
||
_ => None,
|
||
});
|
||
let has_all = |id: u64| curves.iter().all(|c| st.sketch(id).is_some_and(|ss| ss.sketch.curve_index(c).is_some()));
|
||
let sketch = match sketch.or(edited) {
|
||
Some(id) if has_all(id) => id,
|
||
_ => curves_sketch(app, &curves, None).ok_or("the curves must be in one sketch")?,
|
||
};
|
||
let mut wall_params = json!({"sketch": sketch, "thin": true, "curves": curves, "thickness": wall, "side": WALL_SIDES.get(*wall_side).copied().unwrap_or("center")});
|
||
if *wall_side == 3 {
|
||
wall_params["thickness2"] = json!(wall2);
|
||
}
|
||
return Ok(vec![("solid.extrude".to_string(), with(wall_params))]);
|
||
}
|
||
let mut out = Vec::new();
|
||
let (sketch, idx) = profiles();
|
||
if !sketch.is_null() {
|
||
out.push(("solid.extrude".to_string(), with(json!({"sketch": sketch, "profiles": idx}))));
|
||
}
|
||
// Each planar body face extrudes on its own.
|
||
for p in face_points(0) {
|
||
out.push(("solid.extrude".to_string(), with(json!({ "face": p }))));
|
||
}
|
||
return Ok(out);
|
||
}
|
||
Kind::Revolve { angle, operation, axis: stored_axis } => {
|
||
need(0, "profiles")?;
|
||
let axis = match sels(d, 1).first() {
|
||
Some(Sel::Axis { name }) => json!(name),
|
||
Some(Sel::SketchCurve { id }) => json!(id),
|
||
_ => stored_axis.clone().ok_or("select an axis")?,
|
||
};
|
||
let (sketch, idx) = profiles();
|
||
let mut p =
|
||
json!({"sketch": sketch, "profiles": idx, "axis": axis, "angle": angle, "operation": OPS.get(*operation).copied().unwrap_or("new")});
|
||
if to_object_on(&d.inputs) {
|
||
p["to"] = to_object_point(&d.inputs).ok_or("select the object to turn to")?;
|
||
}
|
||
("solid.revolve", p)
|
||
}
|
||
Kind::Fillet { radius, chamfer, ctype, distance2, angle, flip, .. } => {
|
||
need(0, "edges")?;
|
||
// Faces stand for all their edges.
|
||
let st = s.world_state();
|
||
let mut pts: Vec<Vec3> = Vec::new();
|
||
for x in sels(d, 0) {
|
||
match x {
|
||
Sel::Edge { point, .. } => pts.push(*point),
|
||
Sel::Face { body, index, .. } => {
|
||
if let Some(b) = st.body(body) {
|
||
let m = b.mesh();
|
||
for e in m.face_edges(u32::try_from(*index).unwrap_or(u32::MAX)) {
|
||
if !m.seams.get(e).copied().unwrap_or(false)
|
||
&& let Some(p) = m.edges.get(e)
|
||
{
|
||
pts.push(polyline_mid(p));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
let mut uniq: Vec<Vec3> = Vec::new();
|
||
for p in pts {
|
||
if !uniq.iter().any(|q| q.dist(p) < 1e-9) {
|
||
uniq.push(p);
|
||
}
|
||
}
|
||
let edges: Vec<Value> = uniq.into_iter().map(pt).collect();
|
||
if *chamfer {
|
||
let mut p = json!({"edges": edges, "distance": radius});
|
||
match *ctype {
|
||
1 => p["distance2"] = json!(distance2),
|
||
2 => p["angle"] = json!(angle),
|
||
_ => {}
|
||
}
|
||
if *ctype > 0 && *flip {
|
||
p["flip"] = json!(true);
|
||
}
|
||
("solid.chamfer", p)
|
||
} else {
|
||
let mut p = json!({"edges": edges, "radius": radius});
|
||
let style = d.extra.get("type").and_then(Value::as_str);
|
||
if matches!(style, Some("variable" | "spline")) {
|
||
// The start radius goes at one end of the first edge (Swap Ends: the other).
|
||
let ends = sels(d, 0).iter().find_map(|x| match x {
|
||
Sel::Edge { body, index, .. } => {
|
||
st.body(body).and_then(|b| b.mesh().edges.get(*index).and_then(|e| Some((*e.first()?, *e.last()?))))
|
||
}
|
||
_ => None,
|
||
});
|
||
let swap = d.extra.get("swap_ends").and_then(Value::as_bool).unwrap_or(false);
|
||
if let Some((a, b)) = ends {
|
||
p["start"] = pt(if swap { b } else { a });
|
||
}
|
||
let mids = mid_points(&d.extra);
|
||
if style == Some("variable") && !mids.is_empty() {
|
||
p["mid"] = json!(mids.iter().map(|(t, r)| json!([t, r])).collect::<Vec<_>>());
|
||
if d.extra.get("smooth").and_then(Value::as_bool).unwrap_or(false) {
|
||
p["smooth"] = json!(true);
|
||
}
|
||
}
|
||
}
|
||
("solid.fillet", p)
|
||
}
|
||
}
|
||
Kind::Shell { thickness } => {
|
||
need(0, "faces to remove")?;
|
||
("solid.shell", json!({"faces": face_points(0), "thickness": thickness}))
|
||
}
|
||
Kind::Draft { angle } => {
|
||
need(0, "faces")?;
|
||
need(1, "the neutral plane")?;
|
||
let neutral = plane_value(s, sels(d, 1).first()).ok_or("the neutral plane must be a plane or a planar face")?;
|
||
("solid.draft", json!({"faces": face_points(0), "angle": angle, "neutral": neutral}))
|
||
}
|
||
Kind::Mirror => {
|
||
need(0, "objects")?;
|
||
need(1, "the mirror plane")?;
|
||
let plane = plane_value(s, sels(d, 1).first()).ok_or("the mirror plane must be a plane or a planar face")?;
|
||
let mut p = json!({"plane": plane});
|
||
pattern_objects(s, sels(d, 0), &mut p);
|
||
("solid.mirror", p)
|
||
}
|
||
Kind::PatternRect { count, spacing, count2, spacing2 } => {
|
||
need(0, "objects")?;
|
||
let kept = d.extra.get("dir1").and_then(|v| serde_json::from_value::<[f64; 3]>(v.clone()).ok()).map(|a| Vec3::new(a[0], a[1], a[2]));
|
||
let d1 = match (sels(d, 1).first(), kept) {
|
||
(Some(x), _) => axis_of(app, x).ok_or("the direction must be an axis, a sketch line or a straight edge")?.1,
|
||
(None, Some(k)) => k,
|
||
(None, None) => return Err("select a direction (an axis, a sketch line or a straight edge) first".into()),
|
||
};
|
||
let mut p = json!({"dir1": pt(d1), "count1": count, "spacing1": spacing});
|
||
pattern_objects(s, sels(d, 0), &mut p);
|
||
if let Some((_, d2)) = sels(d, 2).first().and_then(|x| axis_of(app, x)) {
|
||
p["dir2"] = pt(d2);
|
||
p["count2"] = json!(count2);
|
||
p["spacing2"] = json!(spacing2);
|
||
}
|
||
("solid.pattern.rectangular", p)
|
||
}
|
||
Kind::PatternCirc { count, angle } => {
|
||
need(0, "objects")?;
|
||
let axis = match sels(d, 1).first() {
|
||
None if d.extra.contains_key("axis") => d.extra.get("axis").cloned().unwrap_or(Value::Null),
|
||
Some(Sel::Axis { name }) => json!(name),
|
||
Some(x) => {
|
||
let (o, dir) = axis_of(app, x).ok_or("the axis must be an origin axis or a sketch line")?;
|
||
json!({"origin": pt(o), "dir": pt(dir)})
|
||
}
|
||
None => return Err("select an axis".into()),
|
||
};
|
||
let mut p = json!({"axis": axis, "count": count, "angle": angle});
|
||
pattern_objects(s, sels(d, 0), &mut p);
|
||
("solid.pattern.circular", p)
|
||
}
|
||
Kind::Loft { operation } => {
|
||
need(0, "profiles of two or more sketches")?;
|
||
// One section per sketch, in the order the sketches were first picked.
|
||
let mut sections: Vec<(u64, Vec<usize>)> = Vec::new();
|
||
for x in sels(d, 0) {
|
||
if let Sel::Profile { sketch, index } = x {
|
||
match sections.iter_mut().find(|(sk, _)| sk == sketch) {
|
||
Some((_, v)) => v.push(*index),
|
||
None => sections.push((*sketch, vec![*index])),
|
||
}
|
||
}
|
||
}
|
||
if sections.len() < 2 {
|
||
return Err("pick profiles in two or more sketches".into());
|
||
}
|
||
let sections: Vec<Value> = sections.into_iter().map(|(sk, v)| json!({"sketch": sk, "profiles": v})).collect();
|
||
("solid.loft", json!({"sections": sections, "operation": OPS.get(*operation).copied().unwrap_or("new")}))
|
||
}
|
||
Kind::Sweep { operation } => {
|
||
need(0, "a profile")?;
|
||
need(1, "the path")?;
|
||
let (sketch, idx) = profiles();
|
||
let path: Vec<String> = sels(d, 1).iter().filter_map(|x| if let Sel::SketchCurve { id } = x { Some(id.clone()) } else { None }).collect();
|
||
let path_sketch = curves_sketch(app, &path, sketch.as_u64()).ok_or("the path curves must be in one sketch")?;
|
||
(
|
||
"solid.sweep",
|
||
json!({"sketch": sketch, "profiles": idx, "path_sketch": path_sketch, "path": path, "operation": OPS.get(*operation).copied().unwrap_or("new")}),
|
||
)
|
||
}
|
||
Kind::OffsetPlane { offset } => {
|
||
need(0, "a plane")?;
|
||
let base = match sels(d, 0).first() {
|
||
Some(Sel::Plane { name }) => json!(name),
|
||
Some(face @ Sel::Face { .. }) => {
|
||
crate::sketch_attachment_ui::face_plane(app, face).ok_or("the picked face is no longer in the model")?
|
||
}
|
||
_ => return Err("pick an origin or construction plane, or a planar face".into()),
|
||
};
|
||
("construct.plane.offset", json!({"base": base, "offset": offset}))
|
||
}
|
||
Kind::PathPlane { t, sketch } => {
|
||
need(0, "a path")?;
|
||
let path = match sels(d, 0).first() {
|
||
Some(Sel::SketchCurve { id }) => {
|
||
let st = app.session.world_state();
|
||
let matches: Vec<u64> = st
|
||
.sketches
|
||
.iter()
|
||
.filter(|ss| ss.sketch.curve_index(id).is_some() || ss.sketch.wire_index(id).is_some())
|
||
.map(|ss| ss.feature)
|
||
.collect();
|
||
let source = match sketch {
|
||
Some(source) if matches.contains(source) => *source,
|
||
None if matches.len() == 1 => *matches.first().ok_or("pick a path")?,
|
||
_ => return Err("pick the path in the viewport to identify its source sketch".into()),
|
||
};
|
||
json!({"sketch": source, "curve": id})
|
||
}
|
||
Some(Sel::Edge { point, .. }) => d.extra.get("path").cloned().unwrap_or_else(|| json!({"edge": pt(*point)})),
|
||
_ => return Err("pick a sketch curve or model edge".into()),
|
||
};
|
||
("construct.plane.along_path", json!({"path": path, "t": t}))
|
||
}
|
||
Kind::AnglePlane { angle } => {
|
||
need(0, "a plane")?;
|
||
let base = match sels(d, 0).first() {
|
||
Some(Sel::Plane { name }) => name.clone(),
|
||
_ => return Err("pick an origin or construction plane".into()),
|
||
};
|
||
let axis = match sels(d, 1).first() {
|
||
Some(Sel::Axis { name }) => json!(name),
|
||
Some(x) => {
|
||
let (o, dir) = axis_of(app, x).ok_or("the axis must be an origin axis or a sketch line")?;
|
||
json!({"origin": pt(o), "dir": pt(dir)})
|
||
}
|
||
None => d.extra.get("axis").cloned().ok_or("pick an axis")?,
|
||
};
|
||
("construct.plane.at_angle", json!({"base": base, "axis": axis, "angle": angle}))
|
||
}
|
||
Kind::Rib { web, thickness, depth, flip } => {
|
||
need(0, "open sketch curves")?;
|
||
let curves = curve_ids(d, 0);
|
||
let sketch = curves_sketch(app, &curves, None).ok_or("the curves must be in one sketch")?;
|
||
let mut p = json!({"sketch": sketch, "curves": curves, "thickness": thickness, "flip": flip});
|
||
if !depth.trim().is_empty() {
|
||
p["depth"] = json!(depth);
|
||
}
|
||
(if *web { "solid.web" } else { "solid.rib" }, p)
|
||
}
|
||
Kind::Emboss { depth, deboss } => {
|
||
need(0, "profiles")?;
|
||
let (sketch, idx) = profiles();
|
||
let mut p = json!({"sketch": sketch, "profiles": idx, "depth": depth, "mode": if *deboss { "deboss" } else { "emboss" }});
|
||
if let Some(Sel::Face { body, point, .. }) = sels(d, 1).first() {
|
||
p["face"] = pt(*point);
|
||
p["targets"] = json!([body]);
|
||
}
|
||
("solid.emboss", p)
|
||
}
|
||
Kind::ReplaceFace => {
|
||
need(0, "faces to move")?;
|
||
need(1, "the target")?;
|
||
let mut p = json!({"faces": face_points(0)});
|
||
match sels(d, 1).first() {
|
||
Some(Sel::Plane { name }) => p["target"] = json!(name),
|
||
Some(Sel::Face { point, .. }) => p["target_face"] = pt(*point),
|
||
_ => return Err("pick a plane or planar face".into()),
|
||
}
|
||
("solid.replace_face", p)
|
||
}
|
||
Kind::Align { flip } => {
|
||
need(0, "bodies")?;
|
||
need(1, "what to move from")?;
|
||
need(2, "where to move it to")?;
|
||
let mut p = json!({"bodies": body_names(0), "flip": flip});
|
||
for (i, key) in [(1, "from"), (2, "to")] {
|
||
let snap = d.extra.get(&format!("{key}_snap")).and_then(Value::as_str).unwrap_or("picked");
|
||
match (sels(d, i).first(), snap) {
|
||
(Some(Sel::Face { point, .. }), "center") => p[key] = json!({"snap": "face_center", "at": pt(*point)}),
|
||
(Some(Sel::Face { point, .. } | Sel::Edge { point, .. }), "circle") => {
|
||
p[key] = json!({"snap": "circle_center", "at": pt(*point)})
|
||
}
|
||
(Some(Sel::Face { point, .. }), _) => p[format!("{key}_face")] = pt(*point),
|
||
(Some(Sel::Edge { point, .. }), _) => p[key] = json!({"snap": "edge_mid", "at": pt(*point)}),
|
||
(Some(Sel::Vertex { point, .. }), _) => p[key] = pt(*point),
|
||
_ => return Err("pick faces, edges or vertices".into()),
|
||
}
|
||
}
|
||
("solid.align", p)
|
||
}
|
||
Kind::Remove => {
|
||
need(0, "bodies")?;
|
||
("solid.remove", json!({"bodies": body_names(0)}))
|
||
}
|
||
Kind::PathPattern { count, spacing } => {
|
||
need(0, "objects")?;
|
||
need(1, "the path")?;
|
||
let path = curve_ids(d, 1);
|
||
let sketch = curves_sketch(app, &path, None).ok_or("the path curves must be in one sketch")?;
|
||
let mut p = json!({"path_sketch": sketch, "path": path, "count": count, "spacing": spacing});
|
||
pattern_objects(s, sels(d, 0), &mut p);
|
||
("solid.pattern.path", p)
|
||
}
|
||
Kind::Pipe { diameter, wall } => {
|
||
need(0, "the path")?;
|
||
let path = curve_ids(d, 0);
|
||
let sketch = curves_sketch(app, &path, None).ok_or("the path curves must be in one sketch")?;
|
||
let mut p = json!({"path_sketch": sketch, "path": path, "diameter": diameter});
|
||
if !wall.trim().is_empty() {
|
||
p["wall"] = json!(wall);
|
||
}
|
||
("solid.pipe", p)
|
||
}
|
||
Kind::Stock { margin } => {
|
||
let mut p = json!({"margin": margin});
|
||
if !sels(d, 0).is_empty() {
|
||
p["bodies"] = json!(body_names(0));
|
||
}
|
||
("solid.bounding_solid", p)
|
||
}
|
||
Kind::Split => {
|
||
need(0, "the body to split")?;
|
||
need(1, "the splitting plane")?;
|
||
let body = body_names(0).into_iter().next().unwrap_or_default();
|
||
// A plane, a planar face's plane, or any other face (its surface extended).
|
||
let p = match sels(d, 1).first() {
|
||
Some(Sel::Plane { name }) => json!({"body": body, "plane": name}),
|
||
Some(Sel::Face { body: b, index, point }) => match planar_face(s, b, *index) {
|
||
Some((_, n)) => json!({"body": body, "plane": {"origin": pt(*point), "normal": pt(n)}}),
|
||
None => json!({"body": body, "tool": {"body": b, "point": pt(*point)}}),
|
||
},
|
||
_ => return Err("pick a plane or a face".into()),
|
||
};
|
||
("solid.split_body", p)
|
||
}
|
||
Kind::Scale { factor } => {
|
||
need(0, "bodies")?;
|
||
("solid.scale", json!({"bodies": body_names(0), "factor": factor}))
|
||
}
|
||
Kind::OffsetFaces { distance } => {
|
||
need(0, "planar faces")?;
|
||
("solid.offset_face", json!({"faces": face_points(0), "distance": distance}))
|
||
}
|
||
Kind::Thread { designation, length } => {
|
||
need(0, "a cylindrical face")?;
|
||
let mut p = json!({"face": face_points(0).into_iter().next().unwrap_or(Value::Null)});
|
||
if !designation.trim().is_empty() {
|
||
p["designation"] = json!(designation.trim());
|
||
}
|
||
if !length.trim().is_empty() {
|
||
p["length"] = json!(length);
|
||
}
|
||
("solid.thread", p)
|
||
}
|
||
Kind::Material { index } => {
|
||
need(0, "bodies")?;
|
||
let name = s.doc.material_names().get(*index).cloned().unwrap_or_else(|| "Default".into());
|
||
("material.assign", json!({"bodies": body_names(0), "material": name}))
|
||
}
|
||
Kind::Section { offset, flip } => {
|
||
need(0, "a plane or planar face")?;
|
||
let plane = match sels(d, 0).first() {
|
||
Some(Sel::Plane { name }) if matches!(name.as_str(), "XY" | "XZ" | "YZ") => json!(name),
|
||
Some(Sel::Face { body, index, point }) => {
|
||
let (_, n) = planar_face(s, body, *index).ok_or("the face must be planar")?;
|
||
json!({"origin": pt(*point), "normal": pt(n)})
|
||
}
|
||
Some(Sel::Plane { name }) => {
|
||
let pl = solidcraft_engine::view::construction_planes(s)
|
||
.into_iter()
|
||
.find(|(_, n, _)| n == name)
|
||
.map(|(_, _, pl)| pl)
|
||
.ok_or("unknown plane")?;
|
||
json!({"origin": pt(pl.origin), "normal": pt(pl.normal())})
|
||
}
|
||
_ => return Err("pick a plane or a planar face".into()),
|
||
};
|
||
("inspect.section", json!({"plane": plane, "offset": offset, "flip": flip}))
|
||
}
|
||
Kind::Move { .. } => return Ok(vec![("solid.move".into(), crate::dialogs_move::params(app, d)?)]),
|
||
Kind::Hole { diameter, depth, kind, cb_diameter, cb_depth, cs_diameter, cs_angle, opts } => {
|
||
need(0, if opts.multiple { "sketch points" } else { "a face position" })?;
|
||
let ty = match *kind {
|
||
0 if opts.angled => "drilled",
|
||
k => HOLE_TYPES.get(k).copied().unwrap_or("simple"),
|
||
};
|
||
// One hole per picked face position, or one Hole feature per sketch for sketch points.
|
||
let mut places: Vec<Value> = Vec::new();
|
||
if opts.multiple {
|
||
let mut by_sketch: Vec<(u64, Vec<String>)> = Vec::new();
|
||
for x in sels(d, 0) {
|
||
if let Sel::SketchPoint { id } = x
|
||
&& let Some((sk, pid)) = id.split_once(':')
|
||
&& let Ok(sk) = sk.parse::<u64>()
|
||
{
|
||
match by_sketch.iter_mut().find(|(s, _)| *s == sk) {
|
||
Some((_, v)) => v.push(pid.to_string()),
|
||
None => by_sketch.push((sk, vec![pid.to_string()])),
|
||
}
|
||
}
|
||
}
|
||
let all_points = d.extra.get("all_points").and_then(Value::as_bool).unwrap_or(false);
|
||
let flip = d.extra.get("flip").and_then(Value::as_bool).unwrap_or(false);
|
||
places.extend(
|
||
by_sketch
|
||
.into_iter()
|
||
.map(|(sk, ids)| if all_points { json!({ "sketch": sk }) } else { json!({"sketch": sk, "points": ids}) })
|
||
.map(|mut place| {
|
||
if flip {
|
||
place["flip"] = json!(true);
|
||
}
|
||
place
|
||
}),
|
||
);
|
||
} else {
|
||
// One hole per pick: a curved surface split at its seam is picked whole (both
|
||
// halves, the clicked one first), but the hole goes where it was clicked only.
|
||
let mut taken: Vec<Sel> = Vec::new();
|
||
for x in sels(d, 0) {
|
||
if !matches!(x, Sel::Face { .. }) || taken.iter().any(|t| same_face(t, x)) {
|
||
continue;
|
||
}
|
||
taken.extend(crate::viewport::grouped_selection(s, x));
|
||
places.extend(face_point(x).map(|p| json!({ "position": p })));
|
||
}
|
||
}
|
||
let mut out = Vec::new();
|
||
for place in places {
|
||
let mut params = place;
|
||
params["diameter"] = json!(diameter);
|
||
params["type"] = json!(ty);
|
||
if to_object_on(&d.inputs) {
|
||
params["to"] = to_object_point(&d.inputs).ok_or("select the object to drill to")?;
|
||
} else if !opts.all {
|
||
params["depth"] = json!(depth);
|
||
}
|
||
if ty == "drilled" {
|
||
params["tip_angle"] = json!(opts.tip_angle);
|
||
}
|
||
if opts.tapped && !opts.thread.trim().is_empty() {
|
||
params["thread"] = json!(opts.thread.trim());
|
||
}
|
||
match *kind {
|
||
1 => {
|
||
params["cb_diameter"] = json!(cb_diameter);
|
||
params["cb_depth"] = json!(cb_depth);
|
||
}
|
||
2 => {
|
||
params["cs_diameter"] = json!(cs_diameter);
|
||
params["cs_angle"] = json!(cs_angle);
|
||
}
|
||
_ => {}
|
||
}
|
||
out.push(("solid.hole".to_string(), params));
|
||
}
|
||
return Ok(out);
|
||
}
|
||
Kind::Primitive { cmd, fields, operation, at } => {
|
||
let mut p = serde_json::Map::new();
|
||
for (k, v) in fields {
|
||
p.insert((*k).into(), json!(v));
|
||
}
|
||
if let Some((point, normal)) = *at {
|
||
match *cmd {
|
||
"solid.box" => {
|
||
p.insert("corner".into(), box_corner(s, fields, point, normal));
|
||
}
|
||
"solid.cylinder" | "solid.coil" => {
|
||
p.insert("base".into(), pt(point));
|
||
if let Some(n) = normal {
|
||
p.insert("axis".into(), pt(n));
|
||
}
|
||
}
|
||
_ => {
|
||
p.insert("center".into(), pt(point));
|
||
}
|
||
}
|
||
}
|
||
p.insert("operation".into(), json!(OPS.get(*operation).copied().unwrap_or("new")));
|
||
(cmd, Value::Object(p))
|
||
}
|
||
Kind::BoundaryFill { operation, cells, .. } => {
|
||
need(0, "the tool bodies")?;
|
||
let picked: Vec<Value> = cells.iter().filter(|c| c.2).map(|c| pt(c.0)).collect();
|
||
if picked.is_empty() {
|
||
return Err("tick the cells to fill".into());
|
||
}
|
||
("solid.boundary_fill", json!({"tools": body_names(0), "cells": picked, "operation": OPS.get(*operation).copied().unwrap_or("new")}))
|
||
}
|
||
Kind::Combine { operation, keep_tools } => {
|
||
need(0, "the target body")?;
|
||
need(1, "tool bodies")?;
|
||
let target = body_names(0).into_iter().next().unwrap_or_default();
|
||
let tools: Vec<String> = body_names(1).into_iter().filter(|n| *n != target).collect();
|
||
(
|
||
"solid.combine",
|
||
json!({"target": target, "tools": tools, "operation": OPS.get(*operation).copied().unwrap_or("join"), "keep_tools": keep_tools}),
|
||
)
|
||
}
|
||
Kind::EditParam { name, expr } => ("parameters.change", json!({"name": name, "expression": expr})),
|
||
Kind::Rename { feature, name } => ("timeline.rename", json!({"feature": feature, "name": name})),
|
||
Kind::ConfirmDelete { features, .. } => ("timeline.delete", json!({ "features": features })),
|
||
Kind::Sketch | Kind::Params { .. } | Kind::Measure { .. } => return Ok(Vec::new()),
|
||
Kind::Assembly(k) => return crate::dialogs_assembly::commands(app, k, &d.inputs),
|
||
Kind::Sheet(k) => return crate::dialogs_sheet::commands(app, k, &d.inputs, &d.extra),
|
||
Kind::Surface(k) => return crate::dialogs_surface::commands(app, k, &d.inputs, &d.extra),
|
||
Kind::SketchModify(k) => return crate::sketch_modify_ui::commands(app, k, &d.inputs, &d.extra),
|
||
Kind::Plastic(k) => return crate::dialogs_plastic::commands(app, k, &d.inputs, &d.extra),
|
||
Kind::Appearance(k) => return Ok(crate::dialogs_appearance::commands(k, &d.inputs)),
|
||
Kind::Motion(k) => return crate::dialogs_motion::commands(app, k, &d.inputs),
|
||
Kind::Part(k) => return crate::dialogs_parts::commands(app, k, &d.inputs),
|
||
Kind::Text(k) => return crate::sketch_text::commands(app, k),
|
||
Kind::TextMove(k) => return crate::sketch_text_move::commands(app, k),
|
||
};
|
||
let mut params = params;
|
||
if let Value::Object(m) = &mut params {
|
||
for (k, v) in &d.extra {
|
||
m.entry(k.clone()).or_insert_with(|| v.clone());
|
||
}
|
||
}
|
||
Ok(vec![(cmd.to_string(), params)])
|
||
}
|
||
|
||
/// The corner of a box placed at `p`: standing on a face whose normal is along an axis (centred
|
||
/// on `p` across the face), otherwise centred on `p`. Sizes that are expressions stay
|
||
/// expressions, so the box keeps standing on the face when they change.
|
||
fn box_corner(s: &Session, fields: &[(&'static str, String)], p: Vec3, normal: Option<Vec3>) -> Value {
|
||
let size = |k: &str| fields.iter().find(|f| f.0 == k).map(|f| s.doc.with_design_unit(&f.1, ValueKind::Length)).unwrap_or_default();
|
||
let along = |axis: Vec3| normal.map(|n| n.dot(axis)).filter(|d| d.abs() > 1.0 - 1e-9);
|
||
let coord = |c: f64, size: String, axis: Vec3| {
|
||
// How much of the size lies behind `p`: none (or all) along the face normal, half across it.
|
||
let back = match along(axis) {
|
||
Some(d) if d > 0.0 => return json!(c),
|
||
Some(_) => 1.0,
|
||
None => 0.5,
|
||
};
|
||
// A plain length ("20 mm", "2 in"; a bare number has the design's unit by now) gives a
|
||
// plain number (mm).
|
||
let plain = solidcraft_engine::doc::expr::is_literal(&size)
|
||
.then(|| solidcraft_engine::doc::Document::eval_in(&Default::default(), &size, ValueKind::Length).ok())
|
||
.flatten();
|
||
match plain.filter(|v| v.is_finite()) {
|
||
Some(v) => json!(c - back * v),
|
||
None if back < 1.0 => json!(format!("{c} mm - ({size}) / 2")),
|
||
None => json!(format!("{c} mm - ({size})")),
|
||
}
|
||
};
|
||
json!([coord(p.x, size("length"), Vec3::X), coord(p.y, size("width"), Vec3::Y), coord(p.z, size("height"), Vec3::Z)])
|
||
}
|
||
|
||
/// Switch an extrude's first input between profiles and faces, and (thin) profiles and curves;
|
||
/// picks the other kind doesn't take are dropped.
|
||
fn set_thin(inputs: &mut [SelInput], thin: bool) {
|
||
if let Some(input) = inputs.first_mut() {
|
||
input.accept = if thin { THIN_ACCEPT } else { EXTRUDE_ACCEPT };
|
||
input.label = if thin { "Profiles/Curves" } else { "Profiles" };
|
||
input.items.retain(|x| match x {
|
||
Sel::Profile { .. } => true,
|
||
Sel::SketchCurve { .. } => thin,
|
||
Sel::Face { .. } => !thin,
|
||
_ => false,
|
||
});
|
||
}
|
||
}
|
||
|
||
/// Sketch curve ids picked in an input.
|
||
fn curve_ids(d: &Dialog, i: usize) -> Vec<String> {
|
||
sels(d, i).iter().filter_map(|x| if let Sel::SketchCurve { id } = x { Some(id.clone()) } else { None }).collect()
|
||
}
|
||
|
||
/// The features that made these bodies (what patterns and mirrors copy).
|
||
/// The features a pattern repeats: picked features as they are, picked bodies by the features
|
||
/// that made them.
|
||
/// What a pattern or mirror copies: picked features are replayed; picked bodies are copied as
|
||
/// they are now, with every feature that shaped them (a fillet after the extrude included).
|
||
fn pattern_objects(s: &Session, objects: &[Sel], p: &mut Value) {
|
||
if objects.iter().any(|x| matches!(x, Sel::Feature { .. })) {
|
||
p["features"] = json!(pattern_features(s, objects));
|
||
} else {
|
||
let bodies: Vec<&str> = objects.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.as_str()) } else { None }).collect();
|
||
p["bodies"] = json!(bodies);
|
||
}
|
||
}
|
||
|
||
fn pattern_features(s: &Session, objects: &[Sel]) -> Vec<String> {
|
||
let mut out: Vec<String> = Vec::new();
|
||
let bodies: Vec<String> = objects.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.clone()) } else { None }).collect();
|
||
for x in objects {
|
||
if let Sel::Feature { id } = x
|
||
&& let Some(f) = s.doc.feature(*id)
|
||
&& !out.contains(&f.name)
|
||
{
|
||
out.push(f.name.clone());
|
||
}
|
||
}
|
||
for f in source_features(s, &bodies) {
|
||
if !out.contains(&f) {
|
||
out.push(f);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
fn source_features(s: &Session, bodies: &[String]) -> Vec<String> {
|
||
let st = s.world_state();
|
||
let mut features: Vec<String> = Vec::new();
|
||
for n in bodies {
|
||
if let Some(f) = st.body(n).and_then(|b| s.doc.feature(b.feature)).map(|f| f.name.clone())
|
||
&& !features.contains(&f)
|
||
{
|
||
features.push(f);
|
||
}
|
||
}
|
||
features
|
||
}
|
||
|
||
/// The sketch holding all these curve ids (the active sketch first, never `not`).
|
||
pub(crate) fn curves_sketch(app: &SolveApp, ids: &[String], not: Option<u64>) -> Option<u64> {
|
||
let st = app.session.world_state();
|
||
let has =
|
||
|sid: u64| st.sketch(sid).is_some_and(|ss| ids.iter().all(|id| ss.sketch.curve_index(id).is_some() || ss.sketch.wire_index(id).is_some()));
|
||
if let Some(a) = app.session.active_sketch
|
||
&& Some(a) != not
|
||
&& has(a)
|
||
{
|
||
return Some(a);
|
||
}
|
||
st.sketches.iter().rev().map(|ss| ss.feature).find(|sid| Some(*sid) != not && has(*sid))
|
||
}
|
||
|
||
/// An axis selection as a line: a point on it and its unit direction (origin axes, or a straight
|
||
/// sketch line).
|
||
pub fn axis_of(app: &SolveApp, sel: &Sel) -> Option<(Vec3, Vec3)> {
|
||
match sel {
|
||
Sel::Axis { name } => match name.as_str() {
|
||
"X" => Some((Vec3::ZERO, Vec3::X)),
|
||
"Y" => Some((Vec3::ZERO, Vec3::Y)),
|
||
"Z" => Some((Vec3::ZERO, Vec3::Z)),
|
||
// A construction axis.
|
||
n => solidcraft_engine::view::construction_axes(&app.session).into_iter().find(|(_, an, _, _)| an == n).map(|(_, _, o, d)| (o, d)),
|
||
},
|
||
Sel::SketchCurve { id } => {
|
||
let st = app.session.world_state();
|
||
let sid = curves_sketch(app, std::slice::from_ref(id), None)?;
|
||
let ss = st.sketch(sid)?;
|
||
let c = ss.sketch.curves.get(ss.sketch.curve_index(id)?)?;
|
||
let solidcraft_engine::sketch::CurveKind::Line { a, b } = c.kind else { return None };
|
||
let (pa, pb) = (ss.plane.to_world(ss.sketch.point(a)?), ss.plane.to_world(ss.sketch.point(b)?));
|
||
Some((pa, (pb - pa).normalized()?))
|
||
}
|
||
// A straight model edge, along it.
|
||
Sel::Edge { body, index, .. } => {
|
||
let b = app.session.world_state().body(body).cloned()?;
|
||
let m = b.mesh();
|
||
let e = m.edges.get(*index)?;
|
||
let (a, z) = (*e.first()?, *e.last()?);
|
||
let dir = (z - a).normalized()?;
|
||
let tol = 1e-6 * a.dist(z).max(1.0);
|
||
if !e.iter().all(|p| (*p - a).cross(dir).len() < tol) {
|
||
return None;
|
||
}
|
||
// An edge along an origin axis points the way the axis does (as picking the axis).
|
||
let axis = [Vec3::X, Vec3::Y, Vec3::Z].into_iter().find(|x| dir.dot(*x).abs() > 1.0 - 1e-9);
|
||
Some((a, axis.unwrap_or(dir)))
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// Which profiles of a sketch a profile selection means.
|
||
pub(crate) fn profile_indices(ss: &solidcraft_engine::doc::SolvedSketch, sel: &ProfileSel) -> Vec<usize> {
|
||
let ps = &ss.profiles;
|
||
match sel {
|
||
ProfileSel::All => (0..ps.len()).collect(),
|
||
ProfileSel::Indices { indices } => indices.iter().copied().filter(|i| *i < ps.len()).collect(),
|
||
ProfileSel::OffsetBoundaries { .. } | ProfileSel::WholeBoundaries { .. } => {
|
||
solidcraft_engine::doc::profile_selection_indices(ss, sel).unwrap_or_default()
|
||
}
|
||
ProfileSel::Curves { loops } => loops
|
||
.iter()
|
||
.filter_map(|l| {
|
||
solidcraft_engine::doc::profile_selection_indices(ss, &ProfileSel::Curves { loops: vec![l.clone()] }).ok()?.first().copied()
|
||
})
|
||
.collect(),
|
||
ProfileSel::Points { points } => points.iter().filter_map(|q| solidcraft_engine::doc::sketch::profile_at_point(ps, *q)).collect(),
|
||
}
|
||
}
|
||
|
||
thread_local! {
|
||
/// A dialog is being filled from a feature: its points are in component frames.
|
||
static REFILL: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
|
||
}
|
||
|
||
/// While filling a dialog from a feature (dropped at the end).
|
||
struct Refill;
|
||
|
||
impl Refill {
|
||
fn start() -> Refill {
|
||
REFILL.with(|r| r.set(true));
|
||
Refill
|
||
}
|
||
}
|
||
|
||
impl Drop for Refill {
|
||
fn drop(&mut self) {
|
||
REFILL.with(|r| r.set(false));
|
||
}
|
||
}
|
||
|
||
/// A point stored in a feature, as it shows on world body `body`: features keep their picks in
|
||
/// the frame of the body they were on, so each body's placement takes the point to the world
|
||
/// (a moved component, a pasted instance). Other points are the world already.
|
||
fn stored_on(frames: &Option<Vec<(String, solidcraft_engine::doc::Mat)>>, body: &str, p: Vec3) -> Vec3 {
|
||
frames.as_ref().and_then(|f| f.iter().find(|(n, _)| n == body)).map(|(_, m)| solidcraft_engine::doc::apply_point(m, p)).unwrap_or(p)
|
||
}
|
||
|
||
/// Body placements while filling a dialog from a feature (when anything is placed).
|
||
fn stored_frames(s: &Session) -> Option<Vec<(String, solidcraft_engine::doc::Mat)>> {
|
||
if !REFILL.with(std::cell::Cell::get) || !solidcraft_engine::frames::placed(s) {
|
||
return None;
|
||
}
|
||
let st = s.model.state();
|
||
Some(s.doc.body_frames(&st).into_iter().map(|(w, _, _, m)| (w, m)).collect())
|
||
}
|
||
|
||
/// The edge of a visible body through (or nearest) a point.
|
||
pub(crate) fn edge_sel(s: &Session, p0: Vec3) -> Option<Sel> {
|
||
let st = s.world_state();
|
||
let frames = stored_frames(s);
|
||
let mut best: Option<(f64, Sel)> = None;
|
||
for b in &st.bodies {
|
||
let p = stored_on(&frames, &b.name, p0);
|
||
let m = b.mesh();
|
||
for (i, e) in m.edges.iter().enumerate() {
|
||
let d = e.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min);
|
||
if best.as_ref().is_none_or(|(bd, _)| d < *bd) {
|
||
best = Some((d, Sel::Edge { body: b.name.clone(), index: i, point: p }));
|
||
}
|
||
}
|
||
}
|
||
best.map(|x| x.1)
|
||
}
|
||
|
||
/// The body face containing a point (nearest triangle).
|
||
pub(crate) fn face_sel(s: &Session, p0: Vec3) -> Option<Sel> {
|
||
let st = s.world_state();
|
||
let frames = stored_frames(s);
|
||
let mut best: Option<(f64, Sel)> = None;
|
||
for b in &st.bodies {
|
||
let p = stored_on(&frames, &b.name, p0);
|
||
let m = b.mesh();
|
||
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
|
||
let Some([a, bb, c]) = m.tri(t) else { continue };
|
||
let d = crate::preview::point_triangle_dist(p, a, bb, c);
|
||
if best.as_ref().is_none_or(|(bd, _)| d < *bd) {
|
||
best = Some((d, Sel::Face { body: b.name.clone(), index: *f as usize, point: p }));
|
||
}
|
||
}
|
||
}
|
||
best.filter(|(d, _)| *d < 1e-3 + 1e-6 * p0.len()).map(|x| x.1)
|
||
}
|
||
|
||
fn emboss_face_sel(s: &Session, component: u64, face: &solidcraft_engine::doc::EmbossFace, persistent: &str) -> Option<Sel> {
|
||
let source = s.model.state();
|
||
let body = source.body(&face.body)?;
|
||
let index = solidcraft_engine::doc::naming::face_names(body).iter().position(|name| name == persistent)?;
|
||
let owner = s.doc.model_body_component(body);
|
||
let world_name = s.doc.world_body_name(&source, &face.body, owner, &face.path);
|
||
let author = solidcraft_engine::doc::EmbossFace::component_frame(&s.doc, component, &face.author_path).ok()?;
|
||
let point = solidcraft_engine::doc::apply_point(&author, face.at);
|
||
s.world_state().body(&world_name)?;
|
||
Some(Sel::Face { body: world_name, index, point })
|
||
}
|
||
|
||
pub(crate) fn plane_sel(s: &Session, pl: &PlaneRef) -> Option<Sel> {
|
||
match pl {
|
||
PlaneRef::Origin { name } | PlaneRef::Construction { name } => Some(Sel::Plane { name: name.clone() }),
|
||
PlaneRef::Custom { plane } | PlaneRef::Face { plane, .. } => face_sel(s, plane.origin),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
pub(crate) fn op_index(o: &Operation) -> usize {
|
||
match o {
|
||
Operation::NewBody => 0,
|
||
Operation::Join => 1,
|
||
Operation::Cut => 2,
|
||
Operation::Intersect => 3,
|
||
}
|
||
}
|
||
|
||
/// The origin axis a unit direction runs along (either way), if any.
|
||
fn world_axis(d: Vec3) -> Option<String> {
|
||
[("X", Vec3::X), ("Y", Vec3::Y), ("Z", Vec3::Z)]
|
||
.into_iter()
|
||
.find(|(_, a)| d.cross(*a).len() < 1e-9 && d.dot(*a) > 0.0)
|
||
.map(|(n, _)| n.to_string())
|
||
}
|
||
|
||
fn pt3(v: Vec3) -> Value {
|
||
json!([v.x, v.y, v.z])
|
||
}
|
||
|
||
/// A point of expressions: numbers as numbers, expressions as strings.
|
||
fn pt_expr(p: &solidcraft_engine::doc::PointExpr) -> Value {
|
||
Value::Array(p.iter().map(|e| e.parse::<f64>().ok().filter(|x| x.is_finite()).map_or_else(|| json!(e), |x| json!(x))).collect())
|
||
}
|
||
|
||
/// A dialog that edits an existing feature, filled from it. The timeline is rolled back to just
|
||
/// before the feature, so its references show on the geometry they refer to.
|
||
pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dialog> {
|
||
let _refill = Refill::start();
|
||
let s = &app.session;
|
||
let f = s.doc.feature(id)?.clone();
|
||
let st = s.world_state();
|
||
let start = |cmd: &str| Dialog::for_command(app, cmd);
|
||
let mut d = match &f.kind {
|
||
FeatureKind::Extrude { sketch, profiles, extent, operation, targets, thin } => {
|
||
let mut d = start("solid.extrude")?;
|
||
d.kind = Kind::Extrude {
|
||
distance: extent.distance.clone(),
|
||
direction: match (extent.direction, &extent.distance2) {
|
||
(_, Some(_)) => TWO_SIDES,
|
||
(Direction::Positive, None) => 0,
|
||
(Direction::Negative, None) => 1,
|
||
(Direction::Symmetric, None) => 2,
|
||
},
|
||
operation: op_index(operation),
|
||
auto_op: false,
|
||
distance2: extent.distance2.clone().unwrap_or_else(|| "10 mm".into()),
|
||
taper: extent.taper.clone().unwrap_or_else(|| "0 deg".into()),
|
||
taper_present: extent.taper.is_some(),
|
||
to_offset: extent.to_offset.clone().unwrap_or_default(),
|
||
start: extent.start_offset.clone().unwrap_or_default(),
|
||
all: extent.through_all,
|
||
thin: thin.is_some(),
|
||
wall: thin.as_ref().map_or_else(|| "2 mm".into(), |t| t.thickness.clone()),
|
||
wall_side: thin.as_ref().map_or(0, |t| WALL_SIDES.iter().position(|w| ThinSide::parse(w) == Some(t.side)).unwrap_or(0)),
|
||
wall2: thin.as_ref().and_then(|t| t.thickness2.clone()).unwrap_or_else(|| "1 mm".into()),
|
||
};
|
||
// Extent references belong to the extrude's authoring frame, including free
|
||
// points. They are not body-local picks (a reference may be on another body).
|
||
let frame = feature_frame(s, f.component);
|
||
for (label, point) in [(TO_OBJECT, extent.to), (FROM_OBJECT, extent.from)] {
|
||
if let Some(point) = point {
|
||
set_object(&mut d.inputs, &mut d.active, label, true);
|
||
if let Some(input) = d.inputs.iter_mut().find(|i| i.label == label) {
|
||
input.items = vec![Sel::Vertex { body: String::new(), point: solidcraft_engine::doc::apply_point(&frame, point) }];
|
||
}
|
||
}
|
||
}
|
||
if let Some(thin) = thin {
|
||
set_thin(&mut d.inputs, true);
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = thin.curves.iter().map(|id| Sel::SketchCurve { id: id.clone() }).collect();
|
||
}
|
||
} else {
|
||
let items = st.sketch(*sketch).map(|ss| profile_indices(ss, profiles)).unwrap_or_default();
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = items.into_iter().map(|index| Sel::Profile { sketch: *sketch, index }).collect();
|
||
}
|
||
}
|
||
if !targets.is_empty() {
|
||
d.extra.insert("targets".into(), json!(targets));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Revolve { sketch, profiles, axis, angle, operation, targets, angle2, symmetric, convention, to } => {
|
||
let mut d = start("solid.revolve")?;
|
||
let frame = feature_frame(s, f.component);
|
||
let stored_axis = match axis {
|
||
AxisRef::Line { origin, dir } => Some(json!({
|
||
"origin": pt(solidcraft_engine::doc::apply_point(&frame, *origin)),
|
||
"dir": pt(solidcraft_engine::doc::apply_vector(&frame, *dir))
|
||
})),
|
||
_ => None,
|
||
};
|
||
d.kind = Kind::Revolve { angle: angle.clone(), operation: op_index(operation), axis: stored_axis };
|
||
d.extra.insert("convention".into(), json!(convention));
|
||
if let Some(a2) = angle2 {
|
||
d.extra.insert("angle2".into(), json!(a2));
|
||
}
|
||
if *symmetric {
|
||
d.extra.insert("direction".into(), json!("symmetric"));
|
||
}
|
||
if let Some(point) = to {
|
||
set_to_object(&mut d.inputs, &mut d.active, true);
|
||
if let Some(input) = d.inputs.iter_mut().find(|i| i.label == TO_OBJECT) {
|
||
input.items = vec![Sel::Vertex { body: String::new(), point: solidcraft_engine::doc::apply_point(&frame, *point) }];
|
||
}
|
||
}
|
||
let items = st.sketch(*sketch).map(|ss| profile_indices(ss, profiles)).unwrap_or_default();
|
||
if let Some(inp) = d.inputs.get_mut(0) {
|
||
inp.items = items.into_iter().map(|index| Sel::Profile { sketch: *sketch, index }).collect();
|
||
}
|
||
let ax = match axis {
|
||
AxisRef::World { axis } => Some(Sel::Axis { name: axis.to_ascii_uppercase() }),
|
||
AxisRef::SketchAxis { axis } => Some(Sel::Axis { name: axis.to_ascii_lowercase() }),
|
||
AxisRef::SketchLine { curve } => Some(Sel::SketchCurve { id: curve.clone() }),
|
||
_ => None,
|
||
};
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = ax.into_iter().collect();
|
||
}
|
||
if !targets.is_empty() {
|
||
d.extra.insert("targets".into(), json!(targets));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Fillet { edges, radius, .. } | FeatureKind::Chamfer { edges, distance: radius, .. } => {
|
||
let chamfer = matches!(f.kind, FeatureKind::Chamfer { .. });
|
||
let mut d = start(if chamfer { "solid.chamfer" } else { "solid.fillet" })?;
|
||
d.kind = fillet_kind(radius, chamfer);
|
||
if let Kind::Fillet { chain, ctype, distance2, angle, flip, .. } = &mut d.kind {
|
||
*chain = false;
|
||
// An unequal chamfer: two distances, or a distance and an angle.
|
||
if let FeatureKind::Chamfer { distance2: d2, angle: a, flip: f, .. } = &f.kind {
|
||
if let Some(v) = d2 {
|
||
*ctype = 1;
|
||
*distance2 = v.clone();
|
||
} else if let Some(v) = a {
|
||
*ctype = 2;
|
||
*angle = v.clone();
|
||
}
|
||
*flip = *f;
|
||
}
|
||
}
|
||
// A fillet that reduces or tapers a radius too large for its edges.
|
||
if let FeatureKind::Fillet { fit, .. } = &f.kind {
|
||
use solidcraft_engine::doc::FilletFit;
|
||
let mode = match fit {
|
||
FilletFit::Exact => None,
|
||
FilletFit::Reduce => Some("reduce"),
|
||
FilletFit::Taper => Some("taper"),
|
||
};
|
||
if let Some(mode) = mode {
|
||
d.extra.insert("fit".into(), json!(mode));
|
||
}
|
||
}
|
||
// A chord-length or variable fillet.
|
||
if let FeatureKind::Fillet { style, .. } = &f.kind {
|
||
match style {
|
||
FilletStyle::Constant => {}
|
||
FilletStyle::Curvature => {
|
||
d.extra.insert("type".into(), json!("curvature"));
|
||
}
|
||
FilletStyle::Chord => {
|
||
d.extra.insert("type".into(), json!("chord"));
|
||
}
|
||
FilletStyle::Variable { start, .. } | FilletStyle::Spline { start, .. } => {
|
||
match style {
|
||
FilletStyle::Variable { radius2, mid, smooth, .. } => {
|
||
d.extra.insert("type".into(), json!("variable"));
|
||
d.extra.insert("radius2".into(), json!(radius2));
|
||
d.extra.insert("mid".into(), json!(mid.iter().map(|(t, r)| json!([t, r])).collect::<Vec<_>>()));
|
||
d.extra.insert("smooth".into(), json!(smooth));
|
||
}
|
||
FilletStyle::Spline { knots, radii, .. } => {
|
||
d.extra.insert("type".into(), json!("spline"));
|
||
d.extra.insert("knots".into(), json!(knots));
|
||
d.extra.insert("radii".into(), json!(radii));
|
||
}
|
||
FilletStyle::Constant | FilletStyle::Chord | FilletStyle::Curvature => {}
|
||
}
|
||
// The start was the first edge's last point: ends swapped.
|
||
let first_end = edges.first().and_then(|p| edge_sel(s, *p)).and_then(|x| match x {
|
||
Sel::Edge { body, index, .. } => {
|
||
s.world_state().body(&body).and_then(|b| b.mesh().edges.get(index).and_then(|e| e.last().copied()))
|
||
}
|
||
_ => None,
|
||
});
|
||
let swapped = first_end.is_some_and(|e| e.dist(*start) < 1e-6);
|
||
d.extra.insert("swap_ends".into(), json!(swapped));
|
||
}
|
||
}
|
||
}
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = edges.iter().filter_map(|p| edge_sel(s, *p)).collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Shell { faces, thickness, direction, tangent_chain, .. } => {
|
||
let mut d = start("solid.shell")?;
|
||
d.kind = Kind::Shell { thickness: thickness.clone() };
|
||
d.extra.insert("tangent_chain".into(), json!(tangent_chain));
|
||
if !direction.is_empty() && direction != "inside" {
|
||
d.extra.insert("direction".into(), json!(direction));
|
||
}
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = faces.iter().filter_map(|p| face_sel(s, *p)).collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Draft { faces, angle, neutral, pull, .. } => {
|
||
let mut d = start("solid.draft")?;
|
||
d.kind = Kind::Draft { angle: angle.clone() };
|
||
if let Some(inp) = d.inputs.get_mut(0) {
|
||
inp.items = faces.iter().filter_map(|p| face_sel(s, *p)).collect();
|
||
}
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = plane_sel(s, neutral).into_iter().collect();
|
||
}
|
||
d.extra.insert("pull".into(), pt3(*pull));
|
||
d
|
||
}
|
||
FeatureKind::Hole { position, direction, diameter, depth, hole, points, thread, to } => {
|
||
let mut d = start("solid.hole")?;
|
||
let mut k = hole_defaults();
|
||
if let Kind::Hole { diameter: dia, depth: dep, kind, cb_diameter, cb_depth, cs_diameter, cs_angle, opts } = &mut k {
|
||
*dia = diameter.clone();
|
||
opts.all = depth.is_none();
|
||
opts.angled = matches!(hole, HoleKind::Drilled { .. });
|
||
opts.multiple = points.is_some();
|
||
if let Some(th) = thread {
|
||
opts.tapped = true;
|
||
opts.thread = th.clone();
|
||
}
|
||
if let Some(dd) = depth {
|
||
*dep = dd.clone();
|
||
}
|
||
match hole {
|
||
HoleKind::Counterbore { cb_diameter: a, cb_depth: b } => {
|
||
*kind = 1;
|
||
*cb_diameter = a.clone();
|
||
*cb_depth = b.clone();
|
||
}
|
||
HoleKind::Countersink { cs_diameter: a, cs_angle: b } => {
|
||
*kind = 2;
|
||
*cs_diameter = a.clone();
|
||
*cs_angle = b.clone();
|
||
}
|
||
HoleKind::Drilled { tip_angle } => {
|
||
opts.tip_angle = tip_angle.clone();
|
||
}
|
||
HoleKind::Simple => {}
|
||
}
|
||
}
|
||
d.kind = k;
|
||
match points {
|
||
Some(sp) => {
|
||
d.inputs = vec![SelInput::new("Points", selection::POINTS, true)];
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = sp.ids.iter().map(|id| Sel::SketchPoint { id: format!("{}:{id}", sp.sketch) }).collect();
|
||
}
|
||
if sp.flip {
|
||
d.extra.insert("flip".into(), json!(true));
|
||
}
|
||
}
|
||
None => {
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = vec![face_sel(s, *position).unwrap_or(Sel::Face { body: String::new(), index: 0, point: *position })];
|
||
}
|
||
d.extra.insert("direction".into(), pt3(*direction));
|
||
}
|
||
}
|
||
if to.is_some() {
|
||
if let Kind::Hole { opts, .. } = &mut d.kind {
|
||
opts.all = false;
|
||
}
|
||
with_to_object(&mut d, s, *to);
|
||
}
|
||
// A hole at every point of a sketch.
|
||
if points.as_ref().is_some_and(|sp| sp.ids.is_empty()) {
|
||
d.extra.insert("all_points".into(), json!(true));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Box { corner, length, width, height, operation } => {
|
||
let mut d = start("solid.box")?;
|
||
d.kind = Kind::Primitive {
|
||
cmd: "solid.box",
|
||
fields: vec![("length", stored_length(s, length)), ("width", stored_length(s, width)), ("height", stored_length(s, height))],
|
||
operation: op_index(operation),
|
||
at: None,
|
||
};
|
||
d.extra.insert("corner".into(), pt_expr(corner));
|
||
d
|
||
}
|
||
FeatureKind::Cylinder { base, axis, radius, height, operation } => {
|
||
let mut d = start("solid.cylinder")?;
|
||
d.kind = Kind::Primitive {
|
||
cmd: "solid.cylinder",
|
||
fields: vec![("radius", stored_length(s, radius)), ("height", stored_length(s, height))],
|
||
operation: op_index(operation),
|
||
at: None,
|
||
};
|
||
d.extra.insert("base".into(), pt_expr(base));
|
||
d.extra.insert("axis".into(), pt3(*axis));
|
||
d
|
||
}
|
||
FeatureKind::Sphere { center, radius, operation } => {
|
||
let mut d = start("solid.sphere")?;
|
||
d.kind =
|
||
Kind::Primitive { cmd: "solid.sphere", fields: vec![("radius", stored_length(s, radius))], operation: op_index(operation), at: None };
|
||
d.extra.insert("center".into(), pt_expr(center));
|
||
d
|
||
}
|
||
FeatureKind::Torus { center, major, minor, operation } => {
|
||
let mut d = start("solid.torus")?;
|
||
d.kind = Kind::Primitive {
|
||
cmd: "solid.torus",
|
||
fields: vec![("major", stored_length(s, major)), ("minor", stored_length(s, minor))],
|
||
operation: op_index(operation),
|
||
at: None,
|
||
};
|
||
d.extra.insert("center".into(), pt_expr(center));
|
||
d
|
||
}
|
||
FeatureKind::BoundaryFill { tools, cells, operation, remove_tools } => {
|
||
let mut d = start("solid.boundary_fill")?;
|
||
// The cells again, ticked where a stored cell point lies in the same cell.
|
||
let before = s.model.state_before(f.id);
|
||
let found = fill_cells(&before, tools);
|
||
let filled: Vec<String> =
|
||
cells.iter().filter_map(|c| found.iter().min_by(|a, b| a.0.dist(*c).total_cmp(&b.0.dist(*c))).map(|x| x.1.clone())).collect();
|
||
let items: Vec<Sel> = tools.iter().map(|n| Sel::Body { name: n.clone() }).collect();
|
||
d.kind = Kind::BoundaryFill {
|
||
operation: op_index(operation),
|
||
cells: found.into_iter().map(|(p, l)| (p, l.clone(), filled.contains(&l))).collect(),
|
||
of: items.clone(),
|
||
};
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = items;
|
||
}
|
||
if *remove_tools {
|
||
d.extra.insert("remove_tools".into(), json!(true));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Combine { target, tools, operation, keep_tools } => {
|
||
let mut d = start("solid.combine")?;
|
||
d.kind = Kind::Combine { operation: op_index(operation).max(1), keep_tools: *keep_tools };
|
||
if let Some(inp) = d.inputs.get_mut(0) {
|
||
inp.items = vec![Sel::Body { name: target.clone() }];
|
||
}
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = tools.iter().map(|n| Sel::Body { name: n.clone() }).collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Mirror { features, plane, bodies, .. } => {
|
||
let mut d = start("solid.mirror")?;
|
||
let ids: Vec<u64> = features.iter().filter_map(|n| s.doc.find_feature(n).map(|f| f.id)).collect();
|
||
// Features that made no body of their own (a hole) were picked as features.
|
||
let as_features = ids.iter().any(|id| !st.bodies.iter().any(|b| b.feature == *id));
|
||
if let Some(inp) = d.inputs.get_mut(0) {
|
||
if !bodies.is_empty() {
|
||
inp.items = bodies.iter().map(|name| Sel::Body { name: name.clone() }).collect();
|
||
} else if as_features {
|
||
inp.accept = selection::FEATURES;
|
||
inp.label = objects_label(inp.accept);
|
||
inp.items = ids.iter().map(|id| Sel::Feature { id: *id }).collect();
|
||
} else {
|
||
inp.items = st.bodies.iter().filter(|b| ids.contains(&b.feature)).map(|b| Sel::Body { name: b.name.clone() }).collect();
|
||
}
|
||
}
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = plane_sel(s, plane).into_iter().collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Pattern { features, pattern, bodies: copied } => {
|
||
let ids: Vec<u64> = features.iter().filter_map(|n| s.doc.find_feature(n).map(|f| f.id)).collect();
|
||
let bodies: Vec<Sel> = if copied.is_empty() {
|
||
st.bodies.iter().filter(|b| ids.contains(&b.feature)).map(|b| Sel::Body { name: b.name.clone() }).collect()
|
||
} else {
|
||
copied.iter().map(|name| Sel::Body { name: name.clone() }).collect()
|
||
};
|
||
let mut d = match pattern {
|
||
PatternKind::Rectangular { dir1, count1, spacing1, dir2, count2, spacing2 } => {
|
||
let mut d = start("solid.pattern.rectangular")?;
|
||
d.kind = Kind::PatternRect {
|
||
count: count1.clone(),
|
||
spacing: spacing1.clone(),
|
||
count2: count2.clone().unwrap_or_else(|| "1".into()),
|
||
spacing2: spacing2.clone().unwrap_or_else(|| "20 mm".into()),
|
||
};
|
||
// Directions along the origin axes show as those axes; others are kept as is.
|
||
for (i, (key, dir)) in [("dir1", Some(*dir1)), ("dir2", *dir2)].into_iter().enumerate() {
|
||
let Some(dir) = dir else { continue };
|
||
match world_axis(dir) {
|
||
Some(name) => {
|
||
if let Some(inp) = d.inputs.get_mut(i + 1) {
|
||
inp.items = vec![Sel::Axis { name }];
|
||
}
|
||
}
|
||
None => {
|
||
d.extra.insert(key.into(), pt3(dir));
|
||
}
|
||
}
|
||
}
|
||
d
|
||
}
|
||
PatternKind::Circular { origin, axis, count, angle } => {
|
||
let mut d = start("solid.pattern.circular")?;
|
||
d.kind = Kind::PatternCirc { count: count.clone(), angle: angle.clone() };
|
||
match world_axis(*axis).filter(|_| origin.len() < 1e-9) {
|
||
Some(name) => {
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = vec![Sel::Axis { name }];
|
||
}
|
||
}
|
||
None => {
|
||
d.extra.insert("axis".into(), json!({"origin": pt3(*origin), "dir": pt3(*axis)}));
|
||
}
|
||
}
|
||
d
|
||
}
|
||
// No dialog for a path pattern yet: edit it with timeline.redefine.
|
||
PatternKind::Path { .. } => return None,
|
||
};
|
||
// Features that made no body of their own (a hole, a fillet) were picked as features.
|
||
let as_features = copied.is_empty() && ids.iter().any(|id| !st.bodies.iter().any(|b| b.feature == *id));
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
if as_features {
|
||
inp.accept = selection::FEATURES;
|
||
inp.label = objects_label(inp.accept);
|
||
inp.items = ids.iter().map(|id| Sel::Feature { id: *id }).collect();
|
||
} else {
|
||
inp.items = bodies;
|
||
}
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Loft { sections, operation, targets } => {
|
||
let mut d = start("solid.loft")?;
|
||
d.kind = Kind::Loft { operation: op_index(operation) };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = sections
|
||
.iter()
|
||
.flat_map(|sec| {
|
||
let idx = st.sketch(sec.sketch).map(|ss| profile_indices(ss, &sec.profiles)).unwrap_or_default();
|
||
idx.into_iter().map(move |index| Sel::Profile { sketch: sec.sketch, index })
|
||
})
|
||
.collect();
|
||
}
|
||
if !targets.is_empty() {
|
||
d.extra.insert("targets".into(), json!(targets));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Sweep { sketch, profiles, path, operation, targets, .. } => {
|
||
let mut d = start("solid.sweep")?;
|
||
d.kind = Kind::Sweep { operation: op_index(operation) };
|
||
let items = st.sketch(*sketch).map(|ss| profile_indices(ss, profiles)).unwrap_or_default();
|
||
if let Some(inp) = d.inputs.get_mut(0) {
|
||
inp.items = items.into_iter().map(|index| Sel::Profile { sketch: *sketch, index }).collect();
|
||
}
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = path.iter().map(|id| Sel::SketchCurve { id: id.clone() }).collect();
|
||
}
|
||
if !targets.is_empty() {
|
||
d.extra.insert("targets".into(), json!(targets));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::ConstructionPlane { plane: PlaneRef::Offset { base, distance } } => {
|
||
let mut d = start("construct.plane.offset")?;
|
||
d.kind = Kind::OffsetPlane { offset: distance.clone() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = plane_sel(s, base).into_iter().collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::ConstructionPlane { plane: PlaneRef::AlongPath { path, t } } => {
|
||
let mut d = start("construct.plane.along_path")?;
|
||
let (item, sketch) = match path.as_ref() {
|
||
solidcraft_engine::doc::construct::GeoRef::SketchCurve { sketch, curve } => (Sel::SketchCurve { id: curve.clone() }, Some(*sketch)),
|
||
solidcraft_engine::doc::construct::GeoRef::Edge { at, name } => {
|
||
// Preserve the saved named reference until a replacement is picked.
|
||
d.extra.insert("path".into(), json!({"type":"edge","at":pt3(*at),"name":name}));
|
||
(Sel::Edge { body: String::new(), index: 0, point: *at }, None)
|
||
}
|
||
_ => return None,
|
||
};
|
||
d.kind = Kind::PathPlane { t: t.clone(), sketch };
|
||
if let Some(input) = d.inputs.first_mut() {
|
||
input.items = vec![item];
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::ConstructionPlane { plane: PlaneRef::AtAngle { base, axis_origin, axis_dir, angle } } => {
|
||
let mut d = start("construct.plane.at_angle")?;
|
||
d.kind = Kind::AnglePlane { angle: angle.clone() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = plane_sel(s, base).into_iter().collect();
|
||
}
|
||
match world_axis(*axis_dir).filter(|_| axis_origin.len() < 1e-9) {
|
||
Some(name) => {
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = vec![Sel::Axis { name }];
|
||
}
|
||
}
|
||
None => {
|
||
d.extra.insert("axis".into(), json!({"origin": pt3(*axis_origin), "dir": pt3(*axis_dir)}));
|
||
}
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Split { body, plane, tool } => {
|
||
let mut d = start("solid.split_body")?;
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = vec![Sel::Body { name: body.clone() }];
|
||
}
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = match tool {
|
||
Some(t) => face_sel(s, t.point).into_iter().collect(),
|
||
None => plane_sel(s, plane).into_iter().collect(),
|
||
};
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Scale { bodies, origin, factor, factors } => {
|
||
let mut d = start("solid.scale")?;
|
||
d.kind = Kind::Scale { factor: factor.clone() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = bodies.iter().map(|n| Sel::Body { name: n.clone() }).collect();
|
||
}
|
||
d.extra.insert("origin".into(), pt3(*origin));
|
||
if let Some(f) = factors {
|
||
d.extra.insert("factors".into(), json!(f));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::OffsetFace { faces, distance, body } => {
|
||
let mut d = start("solid.offset_face")?;
|
||
d.kind = Kind::OffsetFaces { distance: distance.clone() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = faces.iter().filter_map(|p| face_sel(s, *p)).collect();
|
||
}
|
||
if let Some(b) = body {
|
||
d.extra.insert("body".into(), json!(b));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Thread { face, designation, length, modeled } => {
|
||
let mut d = start("solid.thread")?;
|
||
if *modeled {
|
||
d.extra.insert("modeled".into(), json!(true));
|
||
}
|
||
d.kind = Kind::Thread { designation: designation.clone().unwrap_or_default(), length: length.clone().unwrap_or_default() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = face_sel(s, *face).into_iter().collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::BoundingSolid { bodies, margin } => {
|
||
let mut d = start("solid.bounding_solid")?;
|
||
d.kind = Kind::Stock { margin: margin.clone() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = bodies.iter().map(|n| Sel::Body { name: n.clone() }).collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Pipe { path, diameter, wall, operation, targets, .. } => {
|
||
let mut d = start("solid.pipe")?;
|
||
d.kind = Kind::Pipe { diameter: diameter.clone(), wall: wall.clone().unwrap_or_default() };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = path.iter().map(|id| Sel::SketchCurve { id: id.clone() }).collect();
|
||
}
|
||
d.extra.insert("operation".into(), json!(OPS.get(op_index(operation)).copied().unwrap_or("new")));
|
||
if !targets.is_empty() {
|
||
d.extra.insert("targets".into(), json!(targets));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Emboss { sketch, profiles, depth, deboss, targets, face } => {
|
||
let mut d = start("solid.emboss")?;
|
||
d.kind = Kind::Emboss { depth: depth.clone(), deboss: *deboss };
|
||
let items = st.sketch(*sketch).map(|ss| profile_indices(ss, profiles)).unwrap_or_default();
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = items.into_iter().map(|index| Sel::Profile { sketch: *sketch, index }).collect();
|
||
}
|
||
if !targets.is_empty() {
|
||
d.extra.insert("targets".into(), json!(targets));
|
||
}
|
||
if let Some(face) = face
|
||
&& let Some(input) = d.inputs.get_mut(1)
|
||
{
|
||
input.items = vec![emboss_face_sel(s, f.component, face, f.face_names.first()?)?];
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Rib { curves, thickness, depth, flip, web, .. } => {
|
||
let mut d = start(if *web { "solid.web" } else { "solid.rib" })?;
|
||
d.kind = Kind::Rib { web: *web, thickness: thickness.clone(), depth: depth.clone().unwrap_or_default(), flip: *flip };
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = curves.iter().map(|id| Sel::SketchCurve { id: id.clone() }).collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::ReplaceFace { faces, target, body } => {
|
||
let mut d = start("solid.replace_face")?;
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = faces.iter().filter_map(|p| face_sel(s, *p)).collect();
|
||
}
|
||
if let Some(inp) = d.inputs.get_mut(1) {
|
||
inp.items = plane_sel(s, target).into_iter().collect();
|
||
}
|
||
if let Some(b) = body {
|
||
d.extra.insert("body".into(), json!(b));
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Remove { bodies } => {
|
||
let mut d = start("solid.remove")?;
|
||
if let Some(inp) = d.inputs.first_mut() {
|
||
inp.items = bodies.iter().map(|n| Sel::Body { name: n.clone() }).collect();
|
||
}
|
||
d
|
||
}
|
||
FeatureKind::Move { bodies, translate, rotate_axis, angle, copy } => {
|
||
let mut d = start("solid.move")?;
|
||
crate::dialogs_move::for_feature(&mut d, bodies, translate, *rotate_axis, angle.as_ref(), *copy);
|
||
d
|
||
}
|
||
other => {
|
||
let (kind, inputs, extra) = crate::dialogs_sheet::for_feature(app, other)
|
||
.or_else(|| crate::dialogs_plastic::for_feature(app, other))
|
||
.or_else(|| crate::dialogs_surface::for_feature(app, other, &feature_frame(s, f.component)))?;
|
||
let mut d = Dialog::new(kind, inputs);
|
||
d.extra = extra;
|
||
d
|
||
}
|
||
};
|
||
d.editing = Some((id, marker));
|
||
d.active = 0;
|
||
d.error = None;
|
||
Some(d)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod param_refusal_tests {
|
||
use super::*;
|
||
use solidcraft_engine::Session;
|
||
|
||
#[test]
|
||
fn a_refused_parameter_change_shows_why() {
|
||
// A triangle whose sides are parameters: a side longer than the other two together
|
||
// has no solution, so the change is refused and the table shows the reason.
|
||
let mut s = Session::default();
|
||
s.execute("sketch.create", &json!({"plane": "XY", "name": "Tri"})).unwrap();
|
||
s.execute("sketch.line", &json!({"points": [[0, 0], [40, 0], [20, 30]], "closed": true})).unwrap();
|
||
for l in ["l1", "l2", "l3"] {
|
||
s.execute("sketch.dimension", &json!({"entities": [l]})).unwrap();
|
||
}
|
||
s.execute("sketch.finish", &json!({})).unwrap();
|
||
let name = s.doc.params.iter().find(|p| p.model).map(|p| p.name.clone()).unwrap();
|
||
let before = s.doc.param(&name).map(|p| p.expr.clone());
|
||
let mut app = SolveApp::new(s, Default::default());
|
||
let why = change_param(&mut app, &name, "500 mm").unwrap_err();
|
||
assert!(why.contains("Tri") && why.contains("conflict"), "{why}");
|
||
assert_eq!(app.session.doc.param(&name).map(|p| p.expr.clone()), before);
|
||
assert!(app.status.as_ref().is_some_and(|(m, _, error)| *error && m.contains("Tri")), "{:?}", app.status);
|
||
assert!(change_param(&mut app, &name, "41 mm").is_ok());
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod refused_ok_tests {
|
||
//! A refused OK's error lasts only as long as the inputs it was about (#641).
|
||
|
||
use super::*;
|
||
use crate::scenario::Harness;
|
||
|
||
fn steps(h: &mut Harness, steps: &[Value]) {
|
||
for s in steps {
|
||
h.step(s).unwrap();
|
||
}
|
||
}
|
||
|
||
/// A box, and a hole dialog with a position picked on its top.
|
||
fn hole_dialog() -> Harness {
|
||
let mut h = Harness::new();
|
||
steps(
|
||
&mut h,
|
||
&[
|
||
json!({"call": "engine.execute", "params": {"command": "solid.box", "params": {"length": 50, "width": 30, "height": 20}}}),
|
||
json!({"call": "ui.view", "params": {"view": "iso"}}),
|
||
json!({"start": "solid.hole"}),
|
||
json!({"click": {"world": [25, 15, 20]}}),
|
||
],
|
||
);
|
||
h
|
||
}
|
||
|
||
fn set_depth(h: &mut Harness, depth: &str) {
|
||
steps(h, &[json!({"click": {"handle": "dialog:Depth"}}), json!({"key": "A", "cmd": true}), json!({"text": depth})]);
|
||
}
|
||
|
||
/// What the dialog shows in red once the live preview has finished: its own error, else the
|
||
/// preview's.
|
||
fn shown(h: &mut Harness) -> Option<String> {
|
||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
|
||
while h.app.preview.busy {
|
||
assert!(std::time::Instant::now() < deadline, "the preview did not finish");
|
||
h.frames(1);
|
||
}
|
||
h.app.dialog.as_ref().and_then(|d| d.error.clone()).or_else(|| h.app.preview.error.clone())
|
||
}
|
||
|
||
fn refused(h: &mut Harness) {
|
||
set_depth(h, "-5");
|
||
steps(h, &[json!({"key": "Enter"})]);
|
||
assert_eq!(h.app.dialog.as_ref().and_then(|d| d.error.as_deref()), Some("hole depth must be positive"));
|
||
}
|
||
|
||
#[test]
|
||
fn the_error_stays_while_the_inputs_do() {
|
||
let mut h = hole_dialog();
|
||
refused(&mut h);
|
||
h.frames(10);
|
||
assert_eq!(shown(&mut h).as_deref(), Some("hole depth must be positive"));
|
||
}
|
||
|
||
#[test]
|
||
fn a_value_fixed_in_the_dialog_clears_it() {
|
||
let mut h = hole_dialog();
|
||
refused(&mut h);
|
||
set_depth(&mut h, "5");
|
||
h.frames(2);
|
||
assert_eq!(shown(&mut h), None);
|
||
}
|
||
|
||
/// The canvas value box and the arrows change the dialog before `show` runs in a frame.
|
||
#[test]
|
||
fn a_value_fixed_outside_the_dialog_clears_it() {
|
||
let mut h = hole_dialog();
|
||
refused(&mut h);
|
||
if let Some(Kind::Hole { depth, .. }) = h.app.dialog.as_mut().map(|d| &mut d.kind) {
|
||
*depth = "5 mm".into();
|
||
}
|
||
h.frames(2);
|
||
assert_eq!(shown(&mut h), None);
|
||
}
|
||
|
||
#[test]
|
||
fn a_refusal_for_a_missing_pick_clears_once_it_is_picked() {
|
||
let mut h = Harness::new();
|
||
steps(
|
||
&mut h,
|
||
&[
|
||
json!({"call": "engine.execute", "params": {"command": "solid.box", "params": {"length": 50, "width": 30, "height": 20}}}),
|
||
json!({"call": "ui.view", "params": {"view": "iso"}}),
|
||
json!({"start": "solid.hole"}),
|
||
json!({"key": "Enter"}),
|
||
],
|
||
);
|
||
let error = h.app.dialog.as_ref().and_then(|d| d.error.clone());
|
||
assert!(error.as_deref().is_some_and(|e| e.contains("first")), "{error:?}");
|
||
steps(&mut h, &[json!({"click": {"world": [25, 15, 20]}})]);
|
||
h.frames(2);
|
||
assert_eq!(shown(&mut h), None);
|
||
}
|
||
|
||
/// A parameter the depth names changes the design, not the dialog's commands.
|
||
#[test]
|
||
fn a_parameter_the_inputs_use_clears_it() {
|
||
let mut h = hole_dialog();
|
||
let add = json!({"command": "parameters.add", "params": {"name": "dep", "expression": "-5 mm"}});
|
||
steps(&mut h, &[json!({"call": "engine.execute", "params": add})]);
|
||
set_depth(&mut h, "dep");
|
||
steps(&mut h, &[json!({"key": "Enter"})]);
|
||
assert!(h.app.dialog.as_ref().and_then(|d| d.error.as_deref()).is_some_and(|e| e.contains("depth")));
|
||
let change = json!({"command": "parameters.change", "params": {"name": "dep", "expression": "5 mm"}});
|
||
steps(&mut h, &[json!({"call": "engine.execute", "params": change})]);
|
||
h.frames(2);
|
||
assert_eq!(shown(&mut h), None);
|
||
}
|
||
|
||
/// Picks changed some other way than a click (a box selection, a cleared chip) are seen too,
|
||
/// and the dialog then says what the inputs lack now.
|
||
#[test]
|
||
fn a_pick_changed_outside_the_dialog_shows_what_is_missing_now() {
|
||
let mut h = hole_dialog();
|
||
refused(&mut h);
|
||
if let Some(input) = h.app.dialog.as_mut().and_then(|d| d.inputs.first_mut()) {
|
||
input.items.clear();
|
||
}
|
||
h.frames(2);
|
||
let error = h.app.dialog.as_ref().and_then(|d| d.error.clone());
|
||
assert!(error.as_deref().is_some_and(|e| e.contains("first")), "{error:?}");
|
||
}
|
||
|
||
/// Editing an existing hole: the refusal clears, and OK then edits that hole.
|
||
#[test]
|
||
fn editing_a_hole_clears_it_and_keeps_the_feature() {
|
||
let mut h = Harness::new();
|
||
let hole = json!({"command": "solid.hole", "params": {"position": [25, 15, 20], "diameter": "5 mm", "depth": "10 mm", "name": "Bore"}});
|
||
steps(
|
||
&mut h,
|
||
&[
|
||
json!({"call": "engine.execute", "params": {"command": "solid.box", "params": {"length": 50, "width": 30, "height": 20}}}),
|
||
json!({"call": "engine.execute", "params": hole}),
|
||
json!({"call": "ui.view", "params": {"view": "iso"}}),
|
||
json!({"call": "ui.editFeature", "params": {"feature": "Bore"}}),
|
||
],
|
||
);
|
||
let features = h.app.session.doc.features.len();
|
||
refused(&mut h);
|
||
assert!(h.app.dialog.as_ref().is_some_and(|d| d.editing.is_some()));
|
||
set_depth(&mut h, "5");
|
||
h.frames(2);
|
||
assert_eq!(shown(&mut h), None);
|
||
steps(&mut h, &[json!({"key": "Enter"})]);
|
||
assert!(h.app.dialog.is_none());
|
||
assert_eq!(h.app.session.doc.features.len(), features);
|
||
let bore = h.app.session.execute("timeline.inspect", &json!({"feature": "Bore"})).unwrap();
|
||
assert!(bore.to_string().contains("\"depth\":\"5\""), "{bore}");
|
||
}
|
||
}
|
||
|
||
/// Whether two picks are the same face of the same body (wherever on it they were made).
|
||
fn same_face(a: &Sel, b: &Sel) -> bool {
|
||
matches!((a, b), (Sel::Face { body: ba, index: ia, .. }, Sel::Face { body: bb, index: ib, .. }) if ba == bb && ia == ib)
|
||
}
|
||
|
||
/// Where a face was picked.
|
||
fn face_point(x: &Sel) -> Option<Value> {
|
||
if let Sel::Face { point, .. } = x { Some(pt(*point)) } else { None }
|
||
}
|