diff --git a/.cargo/config.toml b/.cargo/config.toml
index de96c3e4a..876a223e7 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -22,6 +22,7 @@ rustflags = [
[target.x86_64-pc-windows-gnu]
rustflags = [
"-Clink-arg=-Wl,--stack,16777216",
+ "-Clink-arg=-Wl,--exclude-all-symbols",
]
[target.x86_64-pc-windows-msvc]
diff --git a/Cargo.lock b/Cargo.lock
index 49635a72c..76a3880ef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -83,7 +83,7 @@ checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
[[package]]
name = "acadrust"
version = "0.5.5"
-source = "git+https://github.com/HakanSeven12/cadcodec.git?rev=4d7b359b0571f9b6e0f85a62a21c67508722b83e#4d7b359b0571f9b6e0f85a62a21c67508722b83e"
+source = "git+https://github.com/HakanSeven12/cadcodec.git?rev=568a12c#568a12cb97c24e14b1cc488085b3f81cf89b94d9"
dependencies = [
"ahash 0.8.12",
"anyhow",
@@ -919,7 +919,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
[[package]]
name = "cadkernel"
version = "0.1.0"
-source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=50f020377c01fcebb5f31844b9900f046b05192f#50f020377c01fcebb5f31844b9900f046b05192f"
+source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=dcf0840#dcf0840d2e62afdde35cf38c0a3aa914ff305eed"
dependencies = [
"acadrust",
"cavalier_contours",
@@ -930,7 +930,7 @@ dependencies = [
[[package]]
name = "cadkernel-constraints"
version = "0.1.0"
-source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=50f020377c01fcebb5f31844b9900f046b05192f#50f020377c01fcebb5f31844b9900f046b05192f"
+source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=dcf0840#dcf0840d2e62afdde35cf38c0a3aa914ff305eed"
dependencies = [
"nalgebra",
]
@@ -4601,6 +4601,7 @@ dependencies = [
"base64",
"flate2",
"getrandom 0.3.4",
+ "image",
"lopdf",
"serde",
"serde_derive",
diff --git a/Cargo.toml b/Cargo.toml
index 1467496a5..ed9e2120a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,9 +32,9 @@ glam = { version = "0.33", features = ["bytemuck"] }
rfd = "0.17"
clap = { version = "4", features = ["derive", "string"] }
env_logger = "0.11"
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "4d7b359b0571f9b6e0f85a62a21c67508722b83e", features = ["serde"] }
-cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "50f020377c01fcebb5f31844b9900f046b05192f", features = ["acis", "offset"] }
-cadkernel-constraints = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "50f020377c01fcebb5f31844b9900f046b05192f" }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "568a12c", features = ["serde"] }
+cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "dcf0840", features = ["acis", "offset"] }
+cadkernel-constraints = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "dcf0840" }
dwg-thumbnailer = { path = "crates/dwg-thumbnailer" }
flate2 = "1"
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "bmp", "tiff"] }
@@ -60,7 +60,7 @@ fluent-syntax = "0.12"
naga = { version = "27", features = ["wgsl-in"] }
[target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.61", features = ["Win32_UI_Shell", "Win32_UI_WindowsAndMessaging", "Win32_System_Com", "Win32_System_Registry", "Win32_Storage_FileSystem", "Win32_Foundation"] }
+windows-sys = { version = "0.61", features = ["Win32_UI_Shell", "Win32_UI_WindowsAndMessaging", "Win32_System_Com", "Win32_System_Registry", "Win32_Storage_FileSystem", "Win32_Foundation", "Win32_Graphics_Printing"] }
[target.'cfg(target_os = "linux")'.dependencies]
ashpd = { version = "0.13.13", default-features = false, features = ["async-io", "wayland"] }
@@ -85,7 +85,7 @@ meshopt = "0.6.2"
i18n-embed = { version = "0.16", features = ["desktop-requester"] }
rayon = "1"
open = "5"
-printpdf = { version = "0.9.1", default-features = false }
+printpdf = { version = "0.9.1", default-features = false, features = ["images"] }
ureq = { version = "3", default-features = false, features = ["rustls", "platform-verifier", "win-system-proxy"] }
[target.'cfg(target_arch = "wasm32")'.dependencies]
diff --git a/assets/icons/align_bottom.svg b/assets/icons/align_bottom.svg
new file mode 100644
index 000000000..ca7fa2bea
--- /dev/null
+++ b/assets/icons/align_bottom.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/align_hcenter.svg b/assets/icons/align_hcenter.svg
new file mode 100644
index 000000000..7ea838f62
--- /dev/null
+++ b/assets/icons/align_hcenter.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/align_left.svg b/assets/icons/align_left.svg
new file mode 100644
index 000000000..aedbf0ec9
--- /dev/null
+++ b/assets/icons/align_left.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/align_right.svg b/assets/icons/align_right.svg
new file mode 100644
index 000000000..35f934aa0
--- /dev/null
+++ b/assets/icons/align_right.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/align_top.svg b/assets/icons/align_top.svg
new file mode 100644
index 000000000..99efe0452
--- /dev/null
+++ b/assets/icons/align_top.svg
@@ -0,0 +1,4 @@
+
diff --git a/assets/icons/align_vcenter.svg b/assets/icons/align_vcenter.svg
new file mode 100644
index 000000000..4740c61fc
--- /dev/null
+++ b/assets/icons/align_vcenter.svg
@@ -0,0 +1,4 @@
+
diff --git a/benches/performance_benchmarks.rs b/benches/performance_benchmarks.rs
index edde1bb36..4ae2dcf9c 100644
--- a/benches/performance_benchmarks.rs
+++ b/benches/performance_benchmarks.rs
@@ -48,16 +48,20 @@ use acadrust::{CadDocument, DxfReader, DxfWriter, EntityType};
use glam::{DVec3, Mat4, Vec3};
use iced::{Color, Point, Rectangle};
+use OpenCADStudio::scene::parametric_constraints::{
+ ConstraintKind, ParametricRef, ParametricScope,
+};
use OpenCADStudio::scene::pick::hit_test::{box_hit, click_hit};
use OpenCADStudio::scene::pick::interaction_index::InteractionIndex;
use OpenCADStudio::scene::pick::selection_state::SelectionState;
use OpenCADStudio::scene::pipeline::wire_arena::partition_wires;
-use OpenCADStudio::scene::sketch_constraints::{ConstraintKind, SketchRef, SketchScope};
use OpenCADStudio::scene::view::camera::Camera;
use OpenCADStudio::scene::{ChangeKind, Scene};
use OpenCADStudio::snap::Snapper;
use OpenCADStudio::ui::icons::{self, CHECK};
-use OpenCADStudio::ui::overlay::{grid_segments, GridCanvasState, GridKey, GridParams, GridStyle, should_reuse};
+use OpenCADStudio::ui::overlay::{
+ grid_segments, should_reuse, GridCanvasState, GridKey, GridParams, GridStyle,
+};
use OpenCADStudio::ui::properties::LinetypeItem;
use OpenCADStudio::ui::ribbon::{LayerInfo, Ribbon};
@@ -109,8 +113,8 @@ impl Default for BenchmarkRunner {
impl BenchmarkRunner {
pub fn new() -> Self {
let args: Vec = env::args().collect();
- let quick_mode = args.iter().any(|a| a == "--quick" || a == "-q")
- || env::var("CAD_BENCH_QUICK").is_ok();
+ let quick_mode =
+ args.iter().any(|a| a == "--quick" || a == "-q") || env::var("CAD_BENCH_QUICK").is_ok();
let filter = args
.windows(2)
@@ -220,22 +224,37 @@ impl BenchmarkRunner {
/// Print summary table to stdout and persist JSON report.
pub fn finish(&self) {
- let baseline_map: HashMap = if let Some(ref path) = self.baseline_path {
- if let Ok(content) = std::fs::read_to_string(path) {
- if let Ok(report) = serde_json::from_str::(&content) {
- println!("\nLoaded baseline from '{}' ({} metrics)", path.display(), report.metrics.len());
- report.metrics.into_iter().map(|m| (m.name.clone(), m)).collect()
+ let baseline_map: HashMap =
+ if let Some(ref path) = self.baseline_path {
+ if let Ok(content) = std::fs::read_to_string(path) {
+ if let Ok(report) = serde_json::from_str::(&content) {
+ println!(
+ "\nLoaded baseline from '{}' ({} metrics)",
+ path.display(),
+ report.metrics.len()
+ );
+ report
+ .metrics
+ .into_iter()
+ .map(|m| (m.name.clone(), m))
+ .collect()
+ } else {
+ eprintln!(
+ "Warning: Failed to parse baseline JSON at '{}'",
+ path.display()
+ );
+ HashMap::new()
+ }
} else {
- eprintln!("Warning: Failed to parse baseline JSON at '{}'", path.display());
+ eprintln!(
+ "Warning: Could not read baseline file at '{}'",
+ path.display()
+ );
HashMap::new()
}
} else {
- eprintln!("Warning: Could not read baseline file at '{}'", path.display());
HashMap::new()
- }
- } else {
- HashMap::new()
- };
+ };
println!("\n========================================================================================================================");
println!(" OPENCADSTUDIO PERFORMANCE BENCHMARK REPORT ");
@@ -301,7 +320,11 @@ impl BenchmarkRunner {
timestamp: chrono_now(),
os: env::consts::OS.to_string(),
arch: env::consts::ARCH.to_string(),
- profile: if cfg!(debug_assertions) { "debug".to_string() } else { "release".to_string() },
+ profile: if cfg!(debug_assertions) {
+ "debug".to_string()
+ } else {
+ "release".to_string()
+ },
is_quick_mode: self.quick_mode,
metrics: self.results.clone(),
};
@@ -311,9 +334,16 @@ impl BenchmarkRunner {
let _ = std::fs::create_dir_all(parent);
}
if let Err(e) = std::fs::write(&self.output_path, json) {
- eprintln!("Error saving metrics to '{}': {}", self.output_path.display(), e);
+ eprintln!(
+ "Error saving metrics to '{}': {}",
+ self.output_path.display(),
+ e
+ );
} else {
- println!("Saved complete performance metrics JSON to: {}\n", self.output_path.display());
+ println!(
+ "Saved complete performance metrics JSON to: {}\n",
+ self.output_path.display()
+ );
}
}
}
@@ -381,9 +411,27 @@ fn bench_scene_entity_ingestion(runner: &mut BenchmarkRunner) {
let y = (i / 50) as f64 * 50.0 + 6000.0;
let mut pl = LwPolyline::new();
pl.vertices = vec![
- LwVertex { location: Vector2::new(x, y), bulge: 0.0, start_width: 0.0, end_width: 0.0, vertex_id: 0 },
- LwVertex { location: Vector2::new(x + 20.0, y), bulge: 0.5, start_width: 0.0, end_width: 0.0, vertex_id: 1 },
- LwVertex { location: Vector2::new(x + 20.0, y + 20.0), bulge: 0.0, start_width: 0.0, end_width: 0.0, vertex_id: 2 },
+ LwVertex {
+ location: Vector2::new(x, y),
+ bulge: 0.0,
+ start_width: 0.0,
+ end_width: 0.0,
+ vertex_id: 0,
+ },
+ LwVertex {
+ location: Vector2::new(x + 20.0, y),
+ bulge: 0.5,
+ start_width: 0.0,
+ end_width: 0.0,
+ vertex_id: 1,
+ },
+ LwVertex {
+ location: Vector2::new(x + 20.0, y + 20.0),
+ bulge: 0.0,
+ start_width: 0.0,
+ end_width: 0.0,
+ vertex_id: 2,
+ },
];
scene.add_entity(EntityType::LwPolyline(pl));
}
@@ -462,8 +510,20 @@ fn bench_analytical_tessellation_zoom(runner: &mut BenchmarkRunner) {
let mut pline = LwPolyline::new();
pline.is_closed = true;
pline.vertices = vec![
- LwVertex { location: Vector2::new(x, y), bulge: 1.0, start_width: 0.0, end_width: 0.0, vertex_id: 0 },
- LwVertex { location: Vector2::new(x + 30.0, y), bulge: 1.0, start_width: 0.0, end_width: 0.0, vertex_id: 1 },
+ LwVertex {
+ location: Vector2::new(x, y),
+ bulge: 1.0,
+ start_width: 0.0,
+ end_width: 0.0,
+ vertex_id: 0,
+ },
+ LwVertex {
+ location: Vector2::new(x + 30.0, y),
+ bulge: 1.0,
+ start_width: 0.0,
+ end_width: 0.0,
+ vertex_id: 1,
+ },
];
scene.add_entity(EntityType::LwPolyline(pline));
}
@@ -610,7 +670,12 @@ fn bench_hit_test_picking(runner: &mut BenchmarkRunner) {
let view_rot = Mat4::IDENTITY;
let eye = DVec3::new(1000.0, 1000.0, 2000.0);
- let bounds = Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 1080.0 };
+ let bounds = Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: 1920.0,
+ height: 1080.0,
+ };
let n_queries = if runner.quick_mode { 200 } else { 1_000 };
let mut click_samples = Vec::with_capacity(5);
@@ -620,7 +685,15 @@ fn bench_hit_test_picking(runner: &mut BenchmarkRunner) {
for q in 0..n_queries {
let cx = ((q * 37) % 1920) as f32;
let cy = ((q * 53) % 1080) as f32;
- let hit = click_hit(Point::new(cx, cy), wires.as_slice(), view_rot, eye, bounds, false, 8.0);
+ let hit = click_hit(
+ Point::new(cx, cy),
+ wires.as_slice(),
+ view_rot,
+ eye,
+ bounds,
+ false,
+ 8.0,
+ );
black_box(hit);
}
let per_query_us = (t0.elapsed().as_secs_f64() * 1_000_000.0) / (n_queries as f64);
@@ -716,7 +789,12 @@ fn bench_osnap_evaluation(runner: &mut BenchmarkRunner) {
let view_rot = Mat4::IDENTITY;
let eye = DVec3::new(500.0, 500.0, 1000.0);
- let bounds = Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 1080.0 };
+ let bounds = Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: 1920.0,
+ height: 1080.0,
+ };
let grid_origin = Vec3::ZERO;
let grid_axes = (Vec3::X, Vec3::Y, Vec3::Z);
@@ -729,10 +807,7 @@ fn bench_osnap_evaluation(runner: &mut BenchmarkRunner) {
let wx = (q as f64 * 7.3) % 2500.0;
let wy = (q as f64 * 11.7) % 2500.0;
let cursor_world = DVec3::new(wx, wy, 0.0);
- let cursor_screen = Point::new(
- ((q * 23) % 1920) as f32,
- ((q * 31) % 1080) as f32,
- );
+ let cursor_screen = Point::new(((q * 23) % 1920) as f32, ((q * 31) % 1080) as f32);
let hit = snapper.snap(
cursor_world,
@@ -798,11 +873,23 @@ fn bench_geometric_constraint_solving(runner: &mut BenchmarkRunner) {
lines.push((h1, h2, h3));
}
- let cs = scene.sketch_constraint_set_mut(SketchScope::ModelSpace);
+ let cs = scene.parametric_constraint_set_mut(ParametricScope::ModelSpace);
for &(h1, h2, h3) in &lines {
- cs.add(ConstraintKind::Perpendicular, vec![SketchRef::whole(h1), SketchRef::whole(h2)], None);
- cs.add(ConstraintKind::Perpendicular, vec![SketchRef::whole(h2), SketchRef::whole(h3)], None);
- cs.add(ConstraintKind::Parallel, vec![SketchRef::whole(h1), SketchRef::whole(h3)], None);
+ cs.add(
+ ConstraintKind::Perpendicular,
+ vec![ParametricRef::whole(h1), ParametricRef::whole(h2)],
+ None,
+ );
+ cs.add(
+ ConstraintKind::Perpendicular,
+ vec![ParametricRef::whole(h2), ParametricRef::whole(h3)],
+ None,
+ );
+ cs.add(
+ ConstraintKind::Parallel,
+ vec![ParametricRef::whole(h1), ParametricRef::whole(h3)],
+ None,
+ );
}
let target = lines[run_idx % lines.len()].0;
@@ -858,7 +945,9 @@ fn bench_dxf_io_throughput(runner: &mut BenchmarkRunner) {
for _ in 0..runs {
let t0 = Instant::now();
- let bytes = DxfWriter::new(&doc).write_to_vec().expect("DXF write succeeds");
+ let bytes = DxfWriter::new(&doc)
+ .write_to_vec()
+ .expect("DXF write succeeds");
write_samples.push(t0.elapsed().as_secs_f64() * 1000.0);
dxf_bytes = bytes;
}
@@ -1095,8 +1184,12 @@ fn bench_ui_grid_geometry(runner: &mut BenchmarkRunner) {
// ── 1. Uncached grid geometry generation ──
if runner.should_run("ui_grid_geometry_uncached") {
for _ in 0..10 {
- let _ = black_box(grid_segments(view_rot1, eye1, bounds1, step1, origin1, axes1, limits1));
- let _ = black_box(grid_segments(view_rot2, eye2, bounds2, step2, origin2, axes2, limits2));
+ let _ = black_box(grid_segments(
+ view_rot1, eye1, bounds1, step1, origin1, axes1, limits1,
+ ));
+ let _ = black_box(grid_segments(
+ view_rot2, eye2, bounds2, step2, origin2, axes2, limits2,
+ ));
}
let n = if runner.quick_mode { 20 } else { 100 };
@@ -1172,7 +1265,11 @@ fn bench_ui_grid_geometry(runner: &mut BenchmarkRunner) {
let t0 = Instant::now();
let mut hit_count = 0u32;
for _ in 0..n {
- let key = GridKey::from_grids(black_box(&grids), black_box(canvas_bounds), GridStyle::default());
+ let key = GridKey::from_grids(
+ black_box(&grids),
+ black_box(canvas_bounds),
+ GridStyle::default(),
+ );
if should_reuse(state.key.borrow().as_ref(), &key) {
hit_count += 1;
}
diff --git a/crates/ocs_plugin_api/Cargo.toml b/crates/ocs_plugin_api/Cargo.toml
index aea33085c..fb55f5254 100644
--- a/crates/ocs_plugin_api/Cargo.toml
+++ b/crates/ocs_plugin_api/Cargo.toml
@@ -14,7 +14,7 @@ serde = { version = "1", features = ["derive"] }
# Pulled in only by the `host` feature, which adds the `acadrust`-typed
# `HostApi` runtime surface. The default crate stays dependency-free so engine
# crates and external tooling can depend on the manifest/ribbon contract cheaply.
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "4d7b359b0571f9b6e0f85a62a21c67508722b83e", optional = true, features = ["serde"] }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "568a12c", optional = true, features = ["serde"] }
# Runtime IPC and serialization (host feature only).
interprocess = { version = "2", optional = true }
@@ -38,7 +38,7 @@ serde_json = "1"
serde = { version = "1", features = ["derive"] }
cargo-lock = "11"
# acadrust is scanned at build time to generate the embedded type registry.
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "4d7b359b0571f9b6e0f85a62a21c67508722b83e", features = ["serde"] }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "568a12c", features = ["serde"] }
[dev-dependencies]
serde_json = "1"
diff --git a/crates/ocs_web_worker/Cargo.toml b/crates/ocs_web_worker/Cargo.toml
index 809c2090a..9aa9b8bfc 100644
--- a/crates/ocs_web_worker/Cargo.toml
+++ b/crates/ocs_web_worker/Cargo.toml
@@ -8,7 +8,7 @@ publish = false
crate-type = ["cdylib"]
[dependencies]
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "4d7b359b0571f9b6e0f85a62a21c67508722b83e", features = ["serde"] }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "568a12c", features = ["serde"] }
bincode = "1.3"
serde = { version = "1", features = ["derive"] }
console_error_panic_hook = "0.1"
diff --git a/crates/plugin-template-api2/Cargo.toml b/crates/plugin-template-api2/Cargo.toml
index 290103605..d9a7576f1 100644
--- a/crates/plugin-template-api2/Cargo.toml
+++ b/crates/plugin-template-api2/Cargo.toml
@@ -10,4 +10,4 @@ crate-type = ["cdylib"]
[dependencies]
ocs_plugin_api = { path = "../ocs_plugin_api", features = ["host"] }
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "4d7b359b0571f9b6e0f85a62a21c67508722b83e", features = ["serde"] }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "568a12c", features = ["serde"] }
diff --git a/docs/plugin-template-v2/Cargo.toml b/docs/plugin-template-v2/Cargo.toml
index f46779ba5..23a662f1f 100644
--- a/docs/plugin-template-v2/Cargo.toml
+++ b/docs/plugin-template-v2/Cargo.toml
@@ -12,4 +12,4 @@ crate-type = ["cdylib"]
[dependencies]
ocs_plugin_api = { path = "../../crates/ocs_plugin_api", features = ["host"] }
-acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "4d7b359b0571f9b6e0f85a62a21c67508722b83e" }
+acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "568a12c" }
diff --git a/packaging/build_macos_signed.sh b/packaging/build_macos_signed.sh
index bbed9a20c..97ef76563 100755
--- a/packaging/build_macos_signed.sh
+++ b/packaging/build_macos_signed.sh
@@ -112,13 +112,23 @@ codesign --verify --strict --verbose=2 "$APP"
echo "==> dmg"
DMG="$DIST/OpenCADStudio-v$VERSION-macos-arm64.dmg"
rm -f "$DMG"
+
+# Stage the app next to the install-location shortcut (#769).
+STAGING="$DIST/dmg-staging"
+rm -rf "$STAGING"
+mkdir -p "$STAGING"
+cp -R "$APP" "$STAGING/"
+ln -s /Applications "$STAGING/Applications"
+
for i in 1 2 3 4 5; do
- if hdiutil create -volname "Open CAD Studio" -srcfolder "$APP" -ov -format UDZO "$DMG"; then
+ if hdiutil create -volname "Open CAD Studio" -srcfolder "$STAGING" -ov -format UDZO "$DMG"; then
break
fi
+ rm -f "$DMG"
echo "hdiutil failed (attempt $i), retrying..." >&2
sleep 3
done
+rm -rf "$STAGING"
[ -f "$DMG" ] || { echo "hdiutil failed permanently" >&2; exit 1; }
if [ -n "${NOTARY_PROFILE:-}" ] && [ "$DEVELOPER_ID" != "-" ]; then
diff --git a/src/app/automation.rs b/src/app/automation.rs
index a862a29cf..8012361d7 100644
--- a/src/app/automation.rs
+++ b/src/app/automation.rs
@@ -18,7 +18,7 @@
use std::io::{BufRead, Write};
use std::path::PathBuf;
-use serde_json::{Value, json};
+use serde_json::{json, Value};
use super::OpenCADStudio;
@@ -317,8 +317,10 @@ impl OpenCADStudio {
let i = self.active_tab;
self.tabs[i].scene.clear();
self.tabs[i].scene.document = doc;
- self.tabs[i].scene.load_sketch_constraints_from_document();
self.tabs[i].scene.load_named_parameters_from_document();
+ self.tabs[i]
+ .scene
+ .load_parametric_constraints_from_document();
self.tabs[i].scene.material_base_dir = path_buf.parent().map(PathBuf::from);
crate::app::style_ops::ensure_standard_styles(
&mut self.tabs[i].scene.document,
@@ -1399,7 +1401,8 @@ mod tests {
let mut app = OpenCADStudio::new_for_test();
let stale = acadrust::Handle::from(9999);
app.tabs[app.active_tab].scene.solid_models.insert(
- stale, cadkernel::brep::make::cuboid([0.0; 3], [1.0; 3]).unwrap(),
+ stale,
+ cadkernel::brep::make::cuboid([0.0; 3], [1.0; 3]).unwrap(),
);
let path = std::env::temp_dir().join(format!(
"ocs_automation_finalize_test_{}.dxf",
@@ -1415,7 +1418,8 @@ mod tests {
let mut corrupt = acadrust::entities::Circle::new();
corrupt.center = acadrust::types::Vector3::new(1.0, 1.0, 0.0);
corrupt.radius = 0.0; // io::is_entity_corrupt rejects a zero-radius circle
- doc.add_entity(acadrust::EntityType::Circle(corrupt)).unwrap();
+ doc.add_entity(acadrust::EntityType::Circle(corrupt))
+ .unwrap();
let bytes = crate::io::save_to_bytes(&doc, "dxf", doc.version)
.expect("save a document containing a corrupt entity");
std::fs::write(&path, bytes).unwrap();
@@ -1423,19 +1427,29 @@ mod tests {
let p = path.to_string_lossy().replace('\\', "\\\\");
let result = app.automation_op(&format!(r#"{{"op":"open","path":"{p}"}}"#));
assert_eq!(result["ok"], true, "{}", result["error"]);
- assert_eq!(result["total"], 1, "the corrupt circle must not survive the open");
- assert_eq!(result["purged"], 1, "the purge count must be reported, matching the UI open path's diagnostics");
+ assert_eq!(
+ result["total"], 1,
+ "the corrupt circle must not survive the open"
+ );
+ assert_eq!(
+ result["purged"], 1,
+ "the purge count must be reported, matching the UI open path's diagnostics"
+ );
let i = app.active_tab;
assert!(!app.tabs[i].scene.solid_models.contains_key(&stale));
- assert_eq!(app.tabs[i].scene.material_base_dir.as_deref(), path.parent());
+ assert_eq!(
+ app.tabs[i].scene.material_base_dir.as_deref(),
+ path.parent()
+ );
assert!(
app.tabs[i].scene.document.source_path.is_some(),
"automation open must run the same finalization as a path-based open, which sets source_path (load_bytes alone never does)"
);
app.tabs[i].scene.solid_models.insert(
- stale, cadkernel::brep::make::cuboid([0.0; 3], [1.0; 3]).unwrap(),
+ stale,
+ cadkernel::brep::make::cuboid([0.0; 3], [1.0; 3]).unwrap(),
);
assert_eq!(app.automation_op(r#"{"op":"new"}"#)["ok"], true);
assert!(app.tabs[i].scene.solid_models.is_empty());
@@ -1523,26 +1537,41 @@ mod tests {
// Start LINE
let _ = app.update(Message::CommandInput("LINE".to_string()));
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("LINE")
+ );
// Type M2P
let _ = app.update(Message::CommandInput("M2P".to_string()));
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("MTP")
+ );
assert!(app.tabs[0].suspended_cmd.is_some());
- assert_eq!(app.tabs[0].suspended_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+ assert_eq!(
+ app.tabs[0].suspended_cmd.as_ref().map(|c| c.name()),
+ Some("LINE")
+ );
// Point 1: 0,0
let _ = app.update(Message::CommandInput("0,0".to_string()));
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("MTP")
+ );
// Point 2: 10,20
let _ = app.update(Message::CommandInput("10,20".to_string()));
let _ = app.update(Message::CommandSubmit);
// MTP should have finished and restored LINE, with midpoint (5, 10, 0)
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("LINE")
+ );
assert!(app.tabs[0].suspended_cmd.is_none());
assert_eq!(app.last_point, Some(glam::DVec3::new(5.0, 10.0, 0.0)));
@@ -1561,7 +1590,10 @@ mod tests {
let _ = app.update(Message::CommandSubmit);
let _ = app.update(Message::SnapOverrideMtp);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("MTP")
+ );
assert_eq!(
app.tabs[0].suspended_cmd.as_ref().map(|c| c.name()),
Some("LINE")
@@ -1577,17 +1609,26 @@ mod tests {
// Start LINE
let _ = app.update(Message::CommandInput("LINE".to_string()));
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("LINE")
+ );
// Type MTP
let _ = app.update(Message::CommandInput("MTP".to_string()));
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("MTP")
+ );
// Escape during MTP
let _ = app.update(Message::CommandEscape);
// Parent LINE must be restored, not cancelled!
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("LINE")
+ );
assert!(app.tabs[0].suspended_cmd.is_none());
// Escape again cancels LINE
@@ -1605,7 +1646,10 @@ mod tests {
// Start LINE
let _ = app.update(Message::CommandInput("LINE".to_string()));
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("LINE")
+ );
// Simulate typing 'm', '2', 'p' character by character
let _ = app.update(Message::CommandAppendChar("m".to_string()));
@@ -1620,6 +1664,20 @@ mod tests {
// Submit triggers MTP
let _ = app.update(Message::CommandSubmit);
- assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+ assert_eq!(
+ app.tabs[0].active_cmd.as_ref().map(|c| c.name()),
+ Some("MTP")
+ );
+ }
+
+ #[test]
+ fn test_open_color_dropdown() {
+ use crate::app::Message;
+ let mut app = OpenCADStudio::new_for_test();
+ app.automation_op(r#"{"op":"new"}"#);
+ let wid = app.main_window.unwrap_or_else(iced::window::Id::unique);
+ let _ = app.view(wid);
+ let _ = app.update(Message::ToggleRibbonDropdown("PROP_COLOR".to_string()));
+ let _ = app.view(wid);
}
}
diff --git a/src/app/command_driver.rs b/src/app/command_driver.rs
index 35259107d..d8f355ed9 100644
--- a/src/app/command_driver.rs
+++ b/src/app/command_driver.rs
@@ -8,9 +8,10 @@ impl OpenCADStudio {
let Some(layer) = self.tabs[i].scene.locked_layer_name(handle) else {
return false;
};
- self.command_line.push_info(crate::tf!(
- "Object is on locked layer \"{layer}\" — unlock the layer to edit it."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("Object is on locked layer \"{layer}\" — unlock the layer to edit it.")
+ .as_ref(),
+ );
true
}
@@ -42,19 +43,13 @@ impl OpenCADStudio {
let endpoint = |entity: &acadrust::EntityType| {
let last_grip = match entity {
acadrust::EntityType::Line(line) => {
- return Some(glam::DVec3::new(
- line.end.x,
- line.end.y,
- line.end.z,
- ));
+ return Some(glam::DVec3::new(line.end.x, line.end.y, line.end.z));
}
acadrust::EntityType::Arc(_) => Some(2),
acadrust::EntityType::LwPolyline(polyline) => {
polyline.vertices.len().checked_sub(1)
}
- acadrust::EntityType::Polyline(polyline) => {
- polyline.vertices.len().checked_sub(1)
- }
+ acadrust::EntityType::Polyline(polyline) => polyline.vertices.len().checked_sub(1),
acadrust::EntityType::Polyline2D(polyline) => {
polyline.vertices.len().checked_sub(1)
}
@@ -216,9 +211,7 @@ impl OpenCADStudio {
.solid_history_operation(handle)
.cloned()
.is_some_and(|operation| {
- self.tabs[i]
- .scene
- .rebuild_solid_history(handle, operation)
+ self.tabs[i].scene.rebuild_solid_history(handle, operation)
});
if !restored {
self.tabs[i].scene.reseed_derived_caches(handle);
@@ -271,8 +264,10 @@ impl OpenCADStudio {
if self.tabs[i].active_cmd.is_some() {
tasks.push(self.apply_cmd_result(CmdResult::CancelForSpaceChange));
} else if message_pending {
- self.command_line
- .push_info(crate::t!("Command cancelled because the active drawing space changed.").as_ref());
+ self.command_line.push_info(
+ crate::t!("Command cancelled because the active drawing space changed.")
+ .as_ref(),
+ );
}
cancellation_reported = true;
}
@@ -285,8 +280,9 @@ impl OpenCADStudio {
self.mtext_cancel();
}
if !cancellation_reported && (grip_cancelled || suspended_cancelled || editor_cancelled) {
- self.command_line
- .push_info(crate::t!("Command cancelled because the active drawing space changed.").as_ref());
+ self.command_line.push_info(
+ crate::t!("Command cancelled because the active drawing space changed.").as_ref(),
+ );
}
self.command_line.input.clear();
@@ -310,7 +306,8 @@ impl OpenCADStudio {
.is_some_and(|command| command.name() != "LIMITS")
&& self.tabs[i].scene.drawing_limit_check_enabled();
if checks_limits && !self.tabs[i].scene.point_inside_drawing_limits(point) {
- self.command_line.push_error(crate::t!("Outside limits.").as_ref());
+ self.command_line
+ .push_error(crate::t!("Outside limits.").as_ref());
return false;
}
true
@@ -318,15 +315,24 @@ impl OpenCADStudio {
/// Refresh screen-space feature picking immediately before point dispatch.
pub(super) fn refresh_command_point_pick_context(&mut self, i: usize) {
- if self.tabs[i].active_cmd.as_ref()
+ if self.tabs[i]
+ .active_cmd
+ .as_ref()
.is_some_and(|command| command.wants_point_pick_context())
{
let scene = &self.tabs[i].scene;
let size = scene.selection.borrow().vp_size;
let edit = scene.viewport_edit_frame(size);
- let tile = edit.as_ref().map(|(_, rect)| *rect)
+ let tile = edit
+ .as_ref()
+ .map(|(_, rect)| *rect)
.unwrap_or_else(|| scene.active_model_tile_bounds(size.0, size.1));
- let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: tile.width, height: tile.height };
+ let bounds = iced::Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: tile.width,
+ height: tile.height,
+ };
let context = if bounds.width > 0.0 && bounds.height > 0.0 {
let (view, eye) = if let Some((camera, _)) = edit {
(camera.view_proj_rte(bounds), camera.eye())
@@ -334,9 +340,15 @@ impl OpenCADStudio {
let camera = scene.camera.borrow();
(camera.view_proj_rte(bounds), camera.eye())
};
- Some(crate::command::PointPickContext { view, eye, bounds,
- aperture_px: crate::ui::overlay::pick_box_aperture_px(self.pick_box) })
- } else { None };
+ Some(crate::command::PointPickContext {
+ view,
+ eye,
+ bounds,
+ aperture_px: crate::ui::overlay::pick_box_aperture_px(self.pick_box),
+ })
+ } else {
+ None
+ };
if let Some(command) = self.tabs[i].active_cmd.as_mut() {
command.set_point_pick_context(context);
}
@@ -415,7 +427,9 @@ impl OpenCADStudio {
if let Some(command) = self.tabs[i].active_cmd.as_mut() {
command.set_entity_pick_direction(direction);
}
- if self.tabs[i].active_cmd.as_ref()
+ if self.tabs[i]
+ .active_cmd
+ .as_ref()
.is_some_and(|command| command.inject_before_entity_pick())
{
if let Some(entity) = self.tabs[i].scene.document.get_entity(*handle).cloned() {
@@ -426,7 +440,9 @@ impl OpenCADStudio {
}
}
if let StepInput::SelectionComplete(handles) = &input {
- let exclude_locked = self.tabs[i].active_cmd.as_ref()
+ let exclude_locked = self.tabs[i]
+ .active_cmd
+ .as_ref()
.is_some_and(|command| command.selection_entities_exclude_locked());
let entities = {
let scene = &self.tabs[i].scene;
@@ -453,7 +469,9 @@ impl OpenCADStudio {
command.inject_selection_entities(entities);
}
}
- if matches!(&input, StepInput::Point(_)) { self.refresh_command_point_pick_context(i); }
+ if matches!(&input, StepInput::Point(_)) {
+ self.refresh_command_point_pick_context(i);
+ }
let ctrl = self.ctrl_down;
let shift = self.shift_down;
let result: Option = {
@@ -620,11 +638,14 @@ impl OpenCADStudio {
_ => return None,
};
if add.is_empty() {
- self.command_line.push_info(crate::t!(match kw.as_str() {
- "P" | "PREVIOUS" => "No previous selection set.",
- "ALL" => "Nothing to select.",
- _ => "No last object.",
- }).as_ref());
+ self.command_line.push_info(
+ crate::t!(match kw.as_str() {
+ "P" | "PREVIOUS" => "No previous selection set.",
+ "ALL" => "Nothing to select.",
+ _ => "No last object.",
+ })
+ .as_ref(),
+ );
return Some(Task::none());
}
let count = add.len();
@@ -799,8 +820,7 @@ impl OpenCADStudio {
let tab = &mut self.tabs[self.active_tab];
let changed = tab.scene.document.header.sketch_type != sketch_type
|| (tab.scene.document.header.sketch_increment - increment).abs() > f64::EPSILON
- || (tab.scene.document.header.sketch_tolerance - tolerance).abs()
- > f64::EPSILON;
+ || (tab.scene.document.header.sketch_tolerance - tolerance).abs() > f64::EPSILON;
if changed {
crate::io::set_sketch_settings(
&mut tab.scene.document,
@@ -955,28 +975,64 @@ impl OpenCADStudio {
TableCellEditStart::Started
}
- /// Removes and re-solves the first conflicting constraint in the active scope.
- pub(super) fn resolve_one_sketch_conflict(&mut self) {
+ fn remove_parametric_constraint(
+ &mut self,
+ id: crate::scene::parametric_constraints::ConstraintId,
+ label: &'static str,
+ ) -> bool {
let i = self.active_tab;
- let scope = self.tabs[i].current_sketch_scope();
- let Some(set) = self.tabs[i].scene.sketch_constraint_set(scope) else { return };
- let Some(&(id, _kind)) = set.conflicts.first() else { return };
- let Some(constraint) = set.get(id) else { return };
+ let scope = self.tabs[i].current_parametric_scope();
+ let Some(set) = self.tabs[i].scene.parametric_constraint_set(scope) else {
+ return false;
+ };
+ let Some(constraint) = set.get(id) else {
+ return false;
+ };
let touched: Vec = constraint.refs.iter().map(|r| r.entity).collect();
- let label = "Remove conflicting constraint";
-
let constraints_before = set.clone();
let pending = self.begin_undo(i, label, touched.len(), true);
self.tabs[i]
.scene
- .record_undo_sketch_constraints_before(scope, constraints_before);
- self.tabs[i].scene.sketch_constraint_set_mut(scope).remove(id);
- let changes: Vec<(Handle, crate::scene::ChangeKind)> =
- touched.into_iter().map(|h| (h, crate::scene::ChangeKind::Modified)).collect();
+ .record_undo_parametric_constraints_before(scope, constraints_before);
+ self.tabs[i]
+ .scene
+ .parametric_constraint_set_mut(scope)
+ .remove(id);
+ if self.tabs[i].scene.selected_constraint == Some(id) {
+ self.tabs[i].scene.selected_constraint = None;
+ }
+ let changes: Vec<(Handle, crate::scene::ChangeKind)> = touched
+ .into_iter()
+ .map(|h| (h, crate::scene::ChangeKind::Modified))
+ .collect();
self.tabs[i].scene.bump_entities(&changes);
if let Some(pd) = pending {
self.commit_undo_delta(i, pd);
}
+ self.refresh_properties();
+ true
+ }
+
+ /// Removes and re-solves the first conflicting constraint in the active scope.
+ pub(super) fn resolve_one_parametric_conflict(&mut self) {
+ let i = self.active_tab;
+ let scope = self.tabs[i].current_parametric_scope();
+ let Some(id) = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .and_then(|set| set.conflicts.first().map(|(id, _)| *id))
+ else {
+ return;
+ };
+ self.remove_parametric_constraint(id, "Remove conflicting constraint");
+ }
+
+ /// Removes one user-selected constraint from the active standard graph scope.
+ pub(super) fn delete_parametric_constraint(
+ &mut self,
+ id: crate::scene::parametric_constraints::ConstraintId,
+ ) {
+ self.remove_parametric_constraint(id, "Delete constraint");
}
/// Rebuilds the active tab's `Scene::named_parameters` from the
@@ -987,7 +1043,9 @@ impl OpenCADStudio {
// one arbitrarily (`ParameterTable::set` would just let the last
// one silently win) -- refuse every row sharing that name up front,
// same as `named_parameters::preview`'s live check.
- let duplicates = crate::ui::window::named_parameters::duplicate_name_rows(&self.named_parameter_editor_rows);
+ let duplicates = crate::ui::window::named_parameters::duplicate_name_rows(
+ &self.named_parameter_editor_rows,
+ );
let mut table = crate::scene::named_parameters::ParameterTable::new();
let mut failed = 0usize;
for (idx, row) in self.named_parameter_editor_rows.iter().enumerate() {
@@ -996,12 +1054,19 @@ impl OpenCADStudio {
continue;
}
if let Err(e) = table.set(name, row.formula.trim()) {
- self.command_line.push_error(crate::tf!("Parameter '{}': {}", name, e).as_ref());
+ self.command_line
+ .push_error(crate::tf!("Parameter '{}': {}", name, e).as_ref());
failed += 1;
}
}
if !duplicates.is_empty() {
- self.command_line.push_error(crate::tf!("{} row(s) skipped: duplicate parameter name.", duplicates.len()).as_ref());
+ self.command_line.push_error(
+ crate::tf!(
+ "{} row(s) skipped: duplicate parameter name.",
+ duplicates.len()
+ )
+ .as_ref(),
+ );
failed += duplicates.len();
}
let param_count = table.len();
@@ -1013,10 +1078,16 @@ impl OpenCADStudio {
// incremental" philosophy).
let touched: Vec = self.tabs[i]
.scene
- .sketch_constraints
+ .parametric_constraints
.iter()
.flat_map(|set| set.constraints.iter())
- .filter(|c| c.enabled && matches!(c.driving_param, Some(crate::scene::named_parameters::DrivingValue::Named(_))))
+ .filter(|c| {
+ c.enabled
+ && matches!(
+ c.driving_param,
+ Some(crate::scene::named_parameters::DrivingValue::Named(_))
+ )
+ })
.flat_map(|c| c.refs.iter().map(|r| r.entity))
.collect();
@@ -1025,15 +1096,20 @@ impl OpenCADStudio {
self.tabs[i].scene.named_parameters = table;
self.tabs[i].dirty = true;
if !touched.is_empty() {
- let changes: Vec<(Handle, crate::scene::ChangeKind)> =
- touched.into_iter().map(|h| (h, crate::scene::ChangeKind::Modified)).collect();
+ let changes: Vec<(Handle, crate::scene::ChangeKind)> = touched
+ .into_iter()
+ .map(|h| (h, crate::scene::ChangeKind::Modified))
+ .collect();
self.tabs[i].scene.bump_entities(&changes);
+ } else {
+ self.tabs[i].scene.sync_native_parametric_graph();
}
if let Some(pd) = pending {
self.commit_undo_delta(i, pd);
}
if failed == 0 {
- self.command_line.push_info(crate::tf!("{} parameter(s) applied.", param_count).as_ref());
+ self.command_line
+ .push_info(crate::tf!("{} parameter(s) applied.", param_count).as_ref());
}
}
@@ -1046,7 +1122,7 @@ impl OpenCADStudio {
fn resolve_named_parameter_edit(&mut self, i: usize, name: &str) {
let touched: Vec = self.tabs[i]
.scene
- .sketch_constraints
+ .parametric_constraints
.iter()
.flat_map(|set| set.constraints.iter())
.filter(|c| {
@@ -1057,10 +1133,13 @@ impl OpenCADStudio {
.collect();
self.tabs[i].dirty = true;
if touched.is_empty() {
+ self.tabs[i].scene.sync_native_parametric_graph();
return;
}
- let changes: Vec<(Handle, crate::scene::ChangeKind)> =
- touched.into_iter().map(|h| (h, crate::scene::ChangeKind::Modified)).collect();
+ let changes: Vec<(Handle, crate::scene::ChangeKind)> = touched
+ .into_iter()
+ .map(|h| (h, crate::scene::ChangeKind::Modified))
+ .collect();
self.tabs[i].scene.bump_entities(&changes);
}
@@ -1089,7 +1168,13 @@ impl OpenCADStudio {
return Task::none();
};
let typed = typed.trim().to_string();
- let Some(current) = self.tabs[i].scene.named_parameters().iter().nth(index).cloned() else {
+ let Some(current) = self.tabs[i]
+ .scene
+ .named_parameters()
+ .iter()
+ .nth(index)
+ .cloned()
+ else {
self.refresh_properties();
return Task::none();
};
@@ -1104,7 +1189,8 @@ impl OpenCADStudio {
return Task::none();
}
ParamField::Name if self.tabs[i].scene.named_parameters().contains(&typed) => {
- self.command_line.push_error(crate::tf!("Parameter '{}' already exists.", typed).as_ref());
+ self.command_line
+ .push_error(crate::tf!("Parameter '{}' already exists.", typed).as_ref());
self.refresh_properties();
return Task::none();
}
@@ -1115,13 +1201,27 @@ impl OpenCADStudio {
self.tabs[i].scene.record_undo_named_parameters_before();
let (result, resolve_name) = match field {
- ParamField::Formula =>
- (self.tabs[i].scene.named_parameters_mut().set(¤t.name, &typed), current.name.clone()),
+ ParamField::Formula => (
+ self.tabs[i]
+ .scene
+ .named_parameters_mut()
+ .set(¤t.name, &typed),
+ current.name.clone(),
+ ),
ParamField::Name => {
- self.tabs[i].scene.named_parameters_mut().remove(¤t.name);
- let outcome = self.tabs[i].scene.named_parameters_mut().set(&typed, ¤t.source);
+ self.tabs[i]
+ .scene
+ .named_parameters_mut()
+ .remove(¤t.name);
+ let outcome = self.tabs[i]
+ .scene
+ .named_parameters_mut()
+ .set(&typed, ¤t.source);
if outcome.is_err() {
- let _ = self.tabs[i].scene.named_parameters_mut().set(¤t.name, ¤t.source);
+ let _ = self.tabs[i]
+ .scene
+ .named_parameters_mut()
+ .set(¤t.name, ¤t.source);
}
(outcome, typed.clone())
}
@@ -1129,7 +1229,8 @@ impl OpenCADStudio {
if let Err(e) = result {
self.tabs[i].scene.take_undo_recording();
- self.command_line.push_error(crate::tf!("Parameter '{}': {}", current.name, e).as_ref());
+ self.command_line
+ .push_error(crate::tf!("Parameter '{}': {}", current.name, e).as_ref());
self.refresh_properties();
return Task::none();
}
@@ -1137,7 +1238,7 @@ impl OpenCADStudio {
if field == ParamField::Name {
let affected: Vec = self.tabs[i]
.scene
- .sketch_constraints
+ .parametric_constraints
.iter()
.enumerate()
.filter_map(|(index, set)| {
@@ -1150,11 +1251,17 @@ impl OpenCADStudio {
})
.collect();
for set_index in affected {
- let scope = self.tabs[i].scene.sketch_constraints[set_index].scope;
- let before = self.tabs[i].scene.sketch_constraints[set_index].clone();
- self.tabs[i].scene.record_undo_sketch_constraints_before(scope, before);
- for constraint in &mut self.tabs[i].scene.sketch_constraints[set_index].constraints {
- if let Some(crate::scene::named_parameters::DrivingValue::Named(name)) = &mut constraint.driving_param {
+ let scope = self.tabs[i].scene.parametric_constraints[set_index].scope;
+ let before = self.tabs[i].scene.parametric_constraints[set_index].clone();
+ self.tabs[i]
+ .scene
+ .record_undo_parametric_constraints_before(scope, before);
+ for constraint in
+ &mut self.tabs[i].scene.parametric_constraints[set_index].constraints
+ {
+ if let Some(crate::scene::named_parameters::DrivingValue::Named(name)) =
+ &mut constraint.driving_param
+ {
if name == ¤t.name {
*name = typed.clone();
}
@@ -1177,7 +1284,13 @@ impl OpenCADStudio {
/// special-case handling here.
pub(super) fn on_prop_param_delete(&mut self, index: usize) -> Task {
let i = self.active_tab;
- let Some(name) = self.tabs[i].scene.named_parameters().iter().nth(index).map(|p| p.name.clone()) else {
+ let Some(name) = self.tabs[i]
+ .scene
+ .named_parameters()
+ .iter()
+ .nth(index)
+ .map(|p| p.name.clone())
+ else {
return Task::none();
};
let pending = self.begin_undo(i, "Delete named parameter", 0, true);
@@ -1215,6 +1328,7 @@ impl OpenCADStudio {
let pending = self.begin_undo(i, "Add named parameter", 0, true);
self.tabs[i].scene.record_undo_named_parameters_before();
let _ = self.tabs[i].scene.named_parameters_mut().set(&name, "1");
+ self.tabs[i].scene.sync_native_parametric_graph();
self.tabs[i].dirty = true;
if let Some(pd) = pending {
self.commit_undo_delta(i, pd);
@@ -1243,25 +1357,47 @@ impl OpenCADStudio {
handle: Handle,
mut entities: Vec,
) -> Vec {
- let same_type = entities.len() == 1 && self.tabs[tab].scene.document.get_entity(handle)
- .is_some_and(|original| std::mem::discriminant(original) == std::mem::discriminant(&entities[0]));
+ let same_type = entities.len() == 1
+ && self.tabs[tab]
+ .scene
+ .document
+ .get_entity(handle)
+ .is_some_and(|original| {
+ std::mem::discriminant(original) == std::mem::discriminant(&entities[0])
+ });
let handles = if same_type {
let mut entity = entities.pop().expect("one replacement");
entity.common_mut().handle = handle;
// Scene::update_entity also retains the live owning block and
// refreshes dependent render caches without erase notifications.
- if self.tabs[tab].scene.update_entity(entity) { vec![handle] } else { Vec::new() }
+ if self.tabs[tab].scene.update_entity(entity) {
+ vec![handle]
+ } else {
+ Vec::new()
+ }
} else {
- let owner = self.tabs[tab].scene.document.get_entity(handle).map(|entity| entity.common().owner_handle);
+ let owner = self.tabs[tab]
+ .scene
+ .document
+ .get_entity(handle)
+ .map(|entity| entity.common().owner_handle);
self.tabs[tab].scene.erase_entities(&[handle]);
- entities.into_iter().map(|mut entity| {
- entity.common_mut().handle = Handle::NULL;
- if let Some(owner) = owner { entity.common_mut().owner_handle = owner; }
- self.tabs[tab].scene.add_entity(entity)
- }).collect()
+ entities
+ .into_iter()
+ .map(|mut entity| {
+ entity.common_mut().handle = Handle::NULL;
+ if let Some(owner) = owner {
+ entity.common_mut().owner_handle = owner;
+ }
+ self.tabs[tab].scene.add_entity(entity)
+ })
+ .collect()
};
for &updated in &handles {
- if matches!(self.tabs[tab].scene.document.get_entity(updated), Some(acadrust::EntityType::Dimension(_))) {
+ if matches!(
+ self.tabs[tab].scene.document.get_entity(updated),
+ Some(acadrust::EntityType::Dimension(_))
+ ) {
self.tabs[tab].scene.invalidate_dim_block_recorded(updated);
}
}
@@ -1279,8 +1415,7 @@ impl OpenCADStudio {
if !matches!(
&op,
PeditOp::Multiple(_, _) | PeditOp::JoinSelection(_, _, _)
- )
- && self.reject_locked_edit(tab, handle)
+ ) && self.reject_locked_edit(tab, handle)
{
return Task::none();
}
@@ -1300,7 +1435,10 @@ impl OpenCADStudio {
.map(|entity| (*handle, entity))
})
.collect::>();
- let connector_distance = crate::modules::draw::modify::pedit::selection_connector_distance(&available, *fuzz);
+ let connector_distance =
+ crate::modules::draw::modify::pedit::selection_connector_distance(
+ &available, *fuzz,
+ );
let mut changes = Vec::new();
while !available.is_empty() {
let (source_handle, source) = available.remove(0);
@@ -1352,8 +1490,11 @@ impl OpenCADStudio {
.map(|replacement| (*handle, replacement, true))
} else {
let mut replacement = original.clone();
- apply_pedit(&mut replacement, operation)
- .then_some((*handle, replacement, false))
+ apply_pedit(&mut replacement, operation).then_some((
+ *handle,
+ replacement,
+ false,
+ ))
}
})
.collect();
@@ -1435,14 +1576,12 @@ impl OpenCADStudio {
.and_then(convert_to_polyline);
match converted {
Some(polyline) => {
- return self.apply_cmd_result(CmdResult::ReplaceEntity(
- handle,
- vec![polyline],
- ));
+ return self
+ .apply_cmd_result(CmdResult::ReplaceEntity(handle, vec![polyline]));
}
- None => self.command_line.push_error(
- crate::t!("PEDIT: cannot convert this entity.").as_ref(),
- ),
+ None => self
+ .command_line
+ .push_error(crate::t!("PEDIT: cannot convert this entity.").as_ref()),
}
}
_ => {
@@ -1477,27 +1616,132 @@ impl OpenCADStudio {
}
}
}
- if let Some(prompt) = self.tabs[tab].active_cmd.as_ref().map(|command| command.prompt()) {
+ if let Some(prompt) = self.tabs[tab]
+ .active_cmd
+ .as_ref()
+ .map(|command| command.prompt())
+ {
self.command_line.push_info(&prompt);
}
Task::none()
}
+ fn apply_continuous_constraints(&mut self, i: usize, new_handles: &[acadrust::Handle]) {
+ let supported_creation = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .is_some_and(|command| {
+ matches!(
+ command.name(),
+ "LINE"
+ | "PLINE"
+ | "POLYLINE"
+ | "RECTANG"
+ | "RECTANGLE"
+ | "POLYGON"
+ | "CIRCLE"
+ | "ARC"
+ )
+ });
+ if supported_creation {
+ self.apply_inferred_constraints(i, new_handles);
+ }
+ }
+
+ pub(in crate::app) fn apply_inferred_constraints(
+ &mut self,
+ i: usize,
+ changed_handles: &[acadrust::Handle],
+ ) {
+ if !self.constraint_infer || changed_handles.is_empty() {
+ return;
+ }
+ let scope = self.tabs[i].current_parametric_scope();
+ let owner = scope.owner_handle(&self.tabs[i].scene.document);
+ let candidates = self.tabs[i]
+ .scene
+ .document
+ .block_records
+ .iter()
+ .find(|record| record.handle == owner)
+ .map(|record| record.entity_handles.clone())
+ .unwrap_or_default();
+ let inferred = self.tabs[i].scene.inferred_parametric_constraints(
+ scope,
+ &candidates,
+ &self.auto_constrain_settings,
+ );
+ let inferred: Vec<_> = inferred
+ .into_iter()
+ .filter(|(_, refs)| {
+ refs.iter()
+ .any(|reference| changed_handles.contains(&reference.entity))
+ })
+ .collect();
+ if inferred.is_empty() {
+ return;
+ }
+ let before = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .cloned()
+ .unwrap_or_else(|| {
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(scope)
+ });
+ self.tabs[i]
+ .scene
+ .record_undo_parametric_constraints_before(scope, before);
+ let mut touched = Vec::new();
+ for (kind, refs) in inferred {
+ touched.extend(refs.iter().map(|reference| reference.entity));
+ self.tabs[i]
+ .scene
+ .parametric_constraint_set_mut(scope)
+ .add(kind, refs, None);
+ }
+ touched.sort_unstable_by_key(|handle| handle.value());
+ touched.dedup();
+ let changes: Vec<_> = touched
+ .into_iter()
+ .map(|handle| (handle, crate::scene::ChangeKind::Modified))
+ .collect();
+ self.tabs[i].scene.bump_entities_with_parametric_policy(
+ &changes,
+ &[],
+ self.constraint_solve_mode,
+ );
+ }
+
fn apply_cmd_result_inner(&mut self, result: CmdResult) -> Task {
let i = self.active_tab;
- if let Some(bind) = self.tabs[i].active_cmd.as_ref().and_then(|command| command.nested_copy_bind_setting()) {
+ if let Some(bind) = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .and_then(|command| command.nested_copy_bind_setting())
+ {
if self.ncopy_bind != bind {
self.ncopy_bind = bind;
self.persist_settings_if_changed();
}
}
- let preserve_commit_style = self.tabs[i].active_cmd.as_ref()
+ let preserve_commit_style = self.tabs[i]
+ .active_cmd
+ .as_ref()
.is_some_and(|command| command.preserve_commit_style());
let preserve_commit_layer = self.tabs[i]
- .active_cmd
- .as_ref()
- .is_some_and(|command| command.preserve_commit_layer());
+ .active_cmd
+ .as_ref()
+ .is_some_and(|command| command.preserve_commit_layer());
match result {
+ CmdResult::OpenAutoConstrainSettings => {
+ self.auto_constrain_saved = Some(self.auto_constrain_settings.clone());
+ self.auto_constrain_selected_row = 0;
+ self.auto_constrain_distance_input =
+ format!("{}", self.auto_constrain_settings.distance_tolerance);
+ self.auto_constrain_angle_input =
+ format!("{}", self.auto_constrain_settings.angle_tolerance_deg);
+ self.active_modal = Some(super::ModalKind::AutoConstrainSettings);
+ }
CmdResult::NeedPoint => {
// ATTEDIT finished its entity pick: hand the chosen block off to
// the attribute editor dialog and end the command (open_attribute
@@ -1605,6 +1849,9 @@ impl OpenCADStudio {
.attach_dimension_association(handle, sources);
}
}
+ if let Some(handle) = committed {
+ self.apply_continuous_constraints(i, &[handle]);
+ }
self.tabs[i].dirty = true;
let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
if let Some(p) = prompt {
@@ -1627,28 +1874,36 @@ impl OpenCADStudio {
return Task::none();
}
let label = self.history_label_from_active_cmd(i, "ENTITY");
- let symbol_names = self.tabs[i].active_cmd.as_ref()
- .and_then(|command| command.nested_copy_symbol_names()).cloned();
- let delta_safe = symbol_names.is_none() && entities
- .iter()
- .all(|entity| self.delta_add_safe(i, entity));
+ let symbol_names = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .and_then(|command| command.nested_copy_symbol_names())
+ .cloned();
+ let delta_safe = symbol_names.is_none()
+ && entities.iter().all(|entity| self.delta_add_safe(i, entity));
let pending = self.begin_undo(i, label, entities.len(), delta_safe);
if let Some(names) = symbol_names {
- let retained = self.tabs[i].scene.document.localize_nested_copy_symbols(&mut entities, &names);
+ let retained = self.tabs[i]
+ .scene
+ .document
+ .localize_nested_copy_symbols(&mut entities, &names);
if retained > 0 {
self.command_line.push_info(&format!("{} copied object(s) retain imported style references whose dependencies cannot be localized.", retained));
}
self.refresh_layer_panel();
}
+ let mut committed = Vec::new();
for entity in entities {
- if preserve_commit_style {
- let _ = self.commit_entity_handle_preserve_style(entity);
+ let handle = if preserve_commit_style {
+ self.commit_entity_handle_preserve_style(entity)
} else if preserve_commit_layer {
- let _ = self.commit_entity_handle_preserve_layer(entity);
+ self.commit_entity_handle_preserve_layer(entity)
} else {
- self.commit_entity(entity);
- }
+ self.commit_entity_handle(entity)
+ };
+ committed.extend(handle);
}
+ self.apply_continuous_constraints(i, &committed);
self.tabs[i].dirty = true;
self.tabs[i].scene.clear_preview_wire();
let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
@@ -1661,28 +1916,36 @@ impl OpenCADStudio {
}
CmdResult::CommitEntitiesAndExit(mut entities) => {
let label = self.history_label_from_active_cmd(i, "ENTITY");
- let symbol_names = self.tabs[i].active_cmd.as_ref()
- .and_then(|command| command.nested_copy_symbol_names()).cloned();
- let delta_safe = symbol_names.is_none() && entities
- .iter()
- .all(|entity| self.delta_add_safe(i, entity));
+ let symbol_names = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .and_then(|command| command.nested_copy_symbol_names())
+ .cloned();
+ let delta_safe = symbol_names.is_none()
+ && entities.iter().all(|entity| self.delta_add_safe(i, entity));
let pending = self.begin_undo(i, label, entities.len(), delta_safe);
if let Some(names) = symbol_names {
- let retained = self.tabs[i].scene.document.localize_nested_copy_symbols(&mut entities, &names);
+ let retained = self.tabs[i]
+ .scene
+ .document
+ .localize_nested_copy_symbols(&mut entities, &names);
if retained > 0 {
self.command_line.push_info(&format!("{} copied object(s) retain imported style references whose dependencies cannot be localized.", retained));
}
self.refresh_layer_panel();
}
+ let mut committed = Vec::new();
for entity in entities {
- if preserve_commit_style {
- let _ = self.commit_entity_handle_preserve_style(entity);
+ let handle = if preserve_commit_style {
+ self.commit_entity_handle_preserve_style(entity)
} else if preserve_commit_layer {
- let _ = self.commit_entity_handle_preserve_layer(entity);
+ self.commit_entity_handle_preserve_layer(entity)
} else {
- self.commit_entity(entity);
- }
+ self.commit_entity_handle(entity)
+ };
+ committed.extend(handle);
}
+ self.apply_continuous_constraints(i, &committed);
self.tabs[i].dirty = true;
self.tabs[i].scene.clear_preview_wire();
self.tabs[i].active_cmd = None;
@@ -1710,9 +1973,7 @@ impl OpenCADStudio {
});
let label = self.history_label_from_active_cmd(i, "MVIEW");
let pending = self.begin_undo(i, label, 1, true);
- let handle = self.commit_entity_handle(
- acadrust::EntityType::Viewport(viewport),
- );
+ let handle = self.commit_entity_handle(acadrust::EntityType::Viewport(viewport));
if let (Some(handle), Some(saved)) = (handle, saved_view) {
if let Some(acadrust::EntityType::Viewport(viewport)) =
self.tabs[i].scene.document.get_entity_mut(handle)
@@ -1743,36 +2004,27 @@ impl OpenCADStudio {
} => {
if boundary.is_none() {
let scene = &self.tabs[i].scene;
- let valid = scene
- .entity_belongs_to_current_layout(boundary_handle)
+ let valid = scene.entity_belongs_to_current_layout(boundary_handle)
&& scene
- .document
- .get_entity(boundary_handle)
- .is_some_and(|entity| {
- match entity {
+ .document
+ .get_entity(boundary_handle)
+ .is_some_and(|entity| match entity {
acadrust::EntityType::Circle(_) => true,
acadrust::EntityType::Ellipse(ellipse) => ellipse.is_full(),
- acadrust::EntityType::LwPolyline(polyline) => {
- polyline.is_closed
- }
- acadrust::EntityType::Polyline(polyline) => {
- polyline.is_closed()
- }
- acadrust::EntityType::Polyline2D(polyline) => {
- polyline.is_closed()
- }
- acadrust::EntityType::Polyline3D(polyline) => {
- polyline.flags.closed
- }
+ acadrust::EntityType::LwPolyline(polyline) => polyline.is_closed,
+ acadrust::EntityType::Polyline(polyline) => polyline.is_closed(),
+ acadrust::EntityType::Polyline2D(polyline) => polyline.is_closed(),
+ acadrust::EntityType::Polyline3D(polyline) => polyline.flags.closed,
_ => false,
- }
- });
+ });
if !valid {
self.command_line.push_error(
crate::t!("MVIEW Object: select a closed paper-space circle, ellipse, or polyline.").as_ref(),
);
- if let Some(prompt) =
- self.tabs[i].active_cmd.as_ref().map(|command| command.prompt())
+ if let Some(prompt) = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .map(|command| command.prompt())
{
self.command_line.push_info(&prompt);
}
@@ -1805,9 +2057,7 @@ impl OpenCADStudio {
}
None => boundary_handle,
};
- let polygon = self.tabs[i]
- .scene
- .clip_boundary_polygon(clip_handle, 0.0);
+ let polygon = self.tabs[i].scene.clip_boundary_polygon(clip_handle, 0.0);
let bounds: Option<(f64, f64, f64, f64)> =
polygon.iter().fold(None, |bounds, point| {
if !point[0].is_finite() || !point[1].is_finite() {
@@ -1829,8 +2079,9 @@ impl OpenCADStudio {
})
});
let Some((min_x, min_y, max_x, max_y)) = bounds else {
- self.command_line
- .push_error(crate::t!("MVIEW: the clipping boundary has no usable area.").as_ref());
+ self.command_line.push_error(
+ crate::t!("MVIEW: the clipping boundary has no usable area.").as_ref(),
+ );
self.tabs[i].active_cmd = None;
if let Some(pending) = pending {
self.commit_undo_delta(i, pending);
@@ -1838,8 +2089,9 @@ impl OpenCADStudio {
return Task::none();
};
if max_x - min_x < 1e-6 || max_y - min_y < 1e-6 {
- self.command_line
- .push_error(crate::t!("MVIEW: the clipping boundary has no usable area.").as_ref());
+ self.command_line.push_error(
+ crate::t!("MVIEW: the clipping boundary has no usable area.").as_ref(),
+ );
self.tabs[i].active_cmd = None;
if let Some(pending) = pending {
self.commit_undo_delta(i, pending);
@@ -1857,9 +2109,8 @@ impl OpenCADStudio {
viewport.height = max_y - min_y;
viewport.id = 2;
viewport.clip_boundary_handle = clip_handle;
- let viewport_handle = self.commit_entity_handle(
- acadrust::EntityType::Viewport(viewport),
- );
+ let viewport_handle =
+ self.commit_entity_handle(acadrust::EntityType::Viewport(viewport));
if let Some(viewport_handle) = viewport_handle {
if !created_boundary {
let before = self.tabs[i]
@@ -1868,12 +2119,9 @@ impl OpenCADStudio {
.get_entity(clip_handle)
.cloned()
.map(std::sync::Arc::new);
- self.tabs[i]
- .scene
- .record_undo_before(clip_handle, before);
+ self.tabs[i].scene.record_undo_before(clip_handle, before);
}
- if let Some(boundary) =
- self.tabs[i].scene.document.get_entity_mut(clip_handle)
+ if let Some(boundary) = self.tabs[i].scene.document.get_entity_mut(clip_handle)
{
let common = boundary.common_mut();
common.invisible = true;
@@ -1881,10 +2129,9 @@ impl OpenCADStudio {
common.reactors.push(viewport_handle);
}
}
- self.tabs[i].scene.bump_entities(&[(
- clip_handle,
- crate::scene::ChangeKind::Modified,
- )]);
+ self.tabs[i]
+ .scene
+ .bump_entities(&[(clip_handle, crate::scene::ChangeKind::Modified)]);
}
self.tabs[i].dirty = true;
self.tabs[i].scene.clear_preview_wire();
@@ -1905,9 +2152,7 @@ impl OpenCADStudio {
.entity_belongs_to_active_space(handle)
.then(|| scene.document.get_entity(handle))
.flatten()
- .and_then(
- crate::modules::draw::draw::wipeout::wipeout_from_polyline,
- )
+ .and_then(crate::modules::draw::draw::wipeout::wipeout_from_polyline)
};
if let Some(wipeout) = wipeout {
if erase_source {
@@ -1921,17 +2166,17 @@ impl OpenCADStudio {
self.command_line.push_error(
crate::t!("WIPEOUT Polyline: select a straight, closed, planar 2D polyline with at least 3 non-intersecting vertices.").as_ref(),
);
- let command =
- crate::modules::draw::draw::wipeout::WipeoutCommand::new_polyline();
- self.command_line.push_info(
- &crate::command::CadCommand::prompt(&command),
- );
+ let command = crate::modules::draw::draw::wipeout::WipeoutCommand::new_polyline();
+ self.command_line
+ .push_info(&crate::command::CadCommand::prompt(&command));
self.tabs[i].active_cmd = Some(Box::new(command));
}
CmdResult::MviewSwitchLayout(layout) => {
let task = self.on_layout_switch_preserving_command(layout);
- if let Some(prompt) =
- self.tabs[i].active_cmd.as_ref().map(|command| command.prompt())
+ if let Some(prompt) = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .map(|command| command.prompt())
{
self.command_line.push_info(&prompt);
}
@@ -1950,12 +2195,20 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = None;
return Task::none();
}
+ if matches!(&transform, crate::command::EntityTransform::Translate(_)) {
+ let scope = self.tabs[i].current_parametric_scope();
+ handles = self.tabs[i]
+ .scene
+ .parametric_connected_handles(scope, &handles);
+ handles.retain(|handle| !self.tabs[i].scene.is_layer_locked(*handle));
+ }
let label = self.history_label_from_active_cmd(i, "MOVE");
- // A move/rotate/scale/mirror mutates only the selected entities
- // (and their baked dimension sub-entities) through
- // transform_entities — always delta-safe.
+ // A translation carries its complete connected constraint
+ // component so each member keeps its own dimensions. Other
+ // transforms retain their selected-object behavior.
let pending = self.begin_undo(i, label, handles.len(), true);
self.tabs[i].scene.transform_entities(&handles, &transform);
+ self.apply_inferred_constraints(i, &handles);
self.tabs[i].dirty = true;
self.tabs[i].scene.clear_preview_wire();
self.tabs[i].active_cmd = None;
@@ -1994,10 +2247,8 @@ impl OpenCADStudio {
}
CmdResult::CopyToClipboard { handles, base } => {
let count = self.copy_entities_to_clipboard(i, &handles, base);
- self.command_line.push_info(crate::tf!(
- "{} object(s) copied to clipboard.",
- count
- ).as_ref());
+ self.command_line
+ .push_info(crate::tf!("{} object(s) copied to clipboard.", count).as_ref());
let prompt = self.tabs[i]
.active_cmd
.as_ref()
@@ -2076,6 +2327,9 @@ impl OpenCADStudio {
.attach_dimension_association(handle, sources);
}
}
+ if let Some(handle) = committed {
+ self.apply_continuous_constraints(i, &[handle]);
+ }
self.tabs[i].dirty = true;
self.tabs[i].scene.clear_preview_wire();
self.tabs[i].active_cmd = None;
@@ -2095,16 +2349,10 @@ impl OpenCADStudio {
continue_command,
} => {
let label = self.history_label_from_active_cmd(i, "DIMENSION");
- let association_mode = self.tabs[i]
- .scene
- .document
- .header
- .dimension_associativity;
+ let association_mode = self.tabs[i].scene.document.header.dimension_associativity;
let single_source_dimension = matches!(
&entity,
- acadrust::EntityType::Dimension(
- acadrust::entities::Dimension::Ordinate(_)
- )
+ acadrust::EntityType::Dimension(acadrust::entities::Dimension::Ordinate(_))
);
// A dimension placed on the sheet but measuring model geometry
// through a viewport carries the compensation as a negative
@@ -2168,9 +2416,7 @@ impl OpenCADStudio {
&entity,
&self.tabs[i].scene.document,
);
- let delta_safe = pieces
- .iter()
- .all(|piece| self.delta_add_safe(i, piece));
+ let delta_safe = pieces.iter().all(|piece| self.delta_add_safe(i, piece));
let pending = self.begin_undo(i, label, pieces.len(), delta_safe);
for piece in pieces {
self.tabs[i].scene.add_entity(piece);
@@ -2209,9 +2455,10 @@ impl OpenCADStudio {
}));
}
crate::command::DimensionAssociationInput::Explicit(sources) => {
- self.tabs[i]
- .scene
- .attach_dimension_association_sources(handle, sources.clone());
+ self.tabs[i].scene.attach_dimension_association_sources(
+ handle,
+ sources.clone(),
+ );
changes.extend(sources.into_iter().flatten().map(|source| {
(source.handle, crate::scene::ChangeKind::Modified)
}));
@@ -2231,11 +2478,7 @@ impl OpenCADStudio {
self.commit_undo_delta(i, pd);
}
if continue_command {
- if let Some(prompt) = self.tabs[i]
- .active_cmd
- .as_ref()
- .map(|cmd| cmd.prompt())
- {
+ if let Some(prompt) = self.tabs[i].active_cmd.as_ref().map(|cmd| cmd.prompt()) {
self.command_line.push_info(&prompt);
}
} else {
@@ -2244,11 +2487,7 @@ impl OpenCADStudio {
}
}
CmdResult::CommitDimensionsAndExit(dimensions) => {
- let association_mode = self.tabs[i]
- .scene
- .document
- .header
- .dimension_associativity;
+ let association_mode = self.tabs[i].scene.document.header.dimension_associativity;
let mut made = 0;
let pending = if association_mode == 0 {
let mut pieces = Vec::new();
@@ -2291,9 +2530,7 @@ impl OpenCADStudio {
}
pieces.extend(exploded);
}
- let delta_safe = pieces
- .iter()
- .all(|piece| self.delta_add_safe(i, piece));
+ let delta_safe = pieces.iter().all(|piece| self.delta_add_safe(i, piece));
let pending = self.begin_undo(i, "QDIM", pieces.len(), delta_safe);
for piece in pieces {
self.tabs[i].scene.add_entity(piece);
@@ -2342,9 +2579,12 @@ impl OpenCADStudio {
.scene
.attach_dimension_association_sources(handle, sources.clone());
let mut changes = vec![(handle, crate::scene::ChangeKind::Modified)];
- changes.extend(sources.into_iter().flatten().map(|source| {
- (source.handle, crate::scene::ChangeKind::Modified)
- }));
+ changes.extend(
+ sources
+ .into_iter()
+ .flatten()
+ .map(|source| (source.handle, crate::scene::ChangeKind::Modified)),
+ );
changes.sort_by_key(|(handle, _)| handle.value());
changes.dedup_by_key(|(handle, _)| handle.value());
self.tabs[i].scene.bump_entities(&changes);
@@ -2367,7 +2607,10 @@ impl OpenCADStudio {
CmdResult::SetQuickDimensionSnapPriority(priority) => {
self.quick_dimension_snap_priority = priority.min(1);
self.persist_settings_if_changed();
- let prompt = self.tabs[i].active_cmd.as_ref().map(|command| command.prompt());
+ let prompt = self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .map(|command| command.prompt());
if let Some(prompt) = prompt {
self.command_line.push_info(&prompt);
}
@@ -2388,9 +2631,8 @@ impl OpenCADStudio {
self.push_undo_snapshot(i, "MLEADERALIGN");
if apply_mleader_align(&mut self.tabs[i].scene, &handles, from, to) {
self.tabs[i].dirty = true;
- self.command_line.push_output(
- crate::t!("MLEADERALIGN Leaders aligned.").as_ref(),
- );
+ self.command_line
+ .push_output(crate::t!("MLEADERALIGN Leaders aligned.").as_ref());
}
}
self.tabs[i].scene.clear_preview_wire();
@@ -2404,9 +2646,8 @@ impl OpenCADStudio {
self.push_undo_snapshot(i, "MLEADERCOLLECT");
if apply_mleader_collect(&mut self.tabs[i].scene, &compatible, point) {
self.tabs[i].dirty = true;
- self.command_line.push_output(
- crate::t!("MLEADERCOLLECT Leaders collected.").as_ref(),
- );
+ self.command_line
+ .push_output(crate::t!("MLEADERCOLLECT Leaders collected.").as_ref());
}
}
self.tabs[i].scene.clear_preview_wire();
@@ -2422,15 +2663,10 @@ impl OpenCADStudio {
} => {
let label = self.history_label_from_active_cmd(i, "SOLID");
let erase_source = erase_source.filter(|handle| {
- self.delete_objects != 0
- && !self.tabs[i].scene.is_layer_locked(*handle)
+ self.delete_objects != 0 && !self.tabs[i].scene.is_layer_locked(*handle)
});
- let pending = self.begin_undo(
- i,
- label,
- 1 + usize::from(erase_source.is_some()),
- true,
- );
+ let pending =
+ self.begin_undo(i, label, 1 + usize::from(erase_source.is_some()), true);
let handle = self.add_solid_model(entity, *solid, history);
if !handle.is_null() {
if let Some(source) = erase_source {
@@ -2489,9 +2725,7 @@ impl OpenCADStudio {
open_editor,
} => {
let label = self.history_label_from_active_cmd(i, "ENTITY");
- let delta_safe = entities
- .iter()
- .all(|entity| self.delta_add_safe(i, entity));
+ let delta_safe = entities.iter().all(|entity| self.delta_add_safe(i, entity));
let pending = self.begin_undo(i, label, entities.len(), delta_safe);
let mut edit_handle = None;
let mut leader_handle = None;
@@ -2521,14 +2755,11 @@ impl OpenCADStudio {
// The LEADER may already have received its annotation context while
// annotation_handle was still NULL. Refresh it now that the MTEXT link
// is known so the context represents the finished leader.
+ self.tabs[i].scene.sync_displayed_annotation_context(lh);
+
self.tabs[i]
.scene
- .sync_displayed_annotation_context(lh);
-
- self.tabs[i].scene.bump_entities(&[(
- lh,
- crate::scene::ChangeKind::Modified,
- )]);
+ .bump_entities(&[(lh, crate::scene::ChangeKind::Modified)]);
}
}
self.tabs[i].dirty = true;
@@ -2561,15 +2792,12 @@ impl OpenCADStudio {
let ucs = self.tabs[i].ucs_xform();
let world_to_block = ucs.to_ucs_transform_at(base);
let block_to_world = ucs.to_wcs_transform_at(base);
- match self.tabs[i]
- .scene
- .create_block_from_entities(
- &handles,
- &name,
- &world_to_block,
- &block_to_world,
- )
- {
+ match self.tabs[i].scene.create_block_from_entities(
+ &handles,
+ &name,
+ &world_to_block,
+ &block_to_world,
+ ) {
Ok(insert_handle) => {
self.tabs[i].dirty = true;
self.tabs[i].scene.deselect_all();
@@ -2619,11 +2847,10 @@ impl OpenCADStudio {
let label = self.history_label_from_active_cmd(i, "HATCH");
let pending = self.begin_undo(i, label, 1, true);
let layer = self.tabs[i].active_layer.clone();
- let new_handle = self.tabs[i].scene.add_hatch(
- hatch,
- Some(&layer),
- Some((color, transparency)),
- );
+ let new_handle =
+ self.tabs[i]
+ .scene
+ .add_hatch(hatch, Some(&layer), Some((color, transparency)));
if !new_handle.is_null() {
self.tabs[i].scene.select_entity(new_handle, true);
}
@@ -2661,10 +2888,9 @@ impl OpenCADStudio {
}
hatch.boundary_sources = Some(std::sync::Arc::new(sources));
let layer = self.tabs[i].active_layer.clone();
- let new_handle =
- self.tabs[i]
- .scene
- .add_hatch(hatch, Some(&layer), entity_style);
+ let new_handle = self.tabs[i]
+ .scene
+ .add_hatch(hatch, Some(&layer), entity_style);
if !new_handle.is_null() {
self.tabs[i].scene.select_entity(new_handle, true);
}
@@ -2686,11 +2912,10 @@ impl OpenCADStudio {
let pending = self.begin_undo(i, label, hatches.len(), true);
let layer = self.tabs[i].active_layer.clone();
for hatch in hatches {
- let new_handle = self.tabs[i].scene.add_hatch(
- hatch,
- Some(&layer),
- entity_style.clone(),
- );
+ let new_handle =
+ self.tabs[i]
+ .scene
+ .add_hatch(hatch, Some(&layer), entity_style.clone());
if !new_handle.is_null() {
self.tabs[i].scene.select_entity(new_handle, true);
}
@@ -2749,7 +2974,7 @@ impl OpenCADStudio {
.is_some_and(|c| c.name() == "SS_CATCHMENT");
self.push_undo_snapshot(i, label);
for (handle, entities) in replacements {
- self.replace_command_entity(i,handle,entities);
+ self.replace_command_entity(i, handle, entities);
}
for entity in additions {
self.tabs[i].scene.add_entity(entity);
@@ -2775,7 +3000,7 @@ impl OpenCADStudio {
let label = self.history_label_from_active_cmd(i, "TRIM");
self.push_undo_snapshot(i, label);
for (handle, entities) in replacements {
- let new_handles = self.replace_command_entity(i,handle,entities);
+ let new_handles = self.replace_command_entity(i, handle, entities);
if let Some(command) = self.tabs[i].active_cmd.as_mut() {
command.on_entity_replaced(handle, &new_handles);
}
@@ -2819,36 +3044,50 @@ impl OpenCADStudio {
self.tabs[i].snap_result = None;
self.refresh_properties();
}
- CmdResult::AddSketchConstraint { kind, refs, driving_param, label } => {
- if let Err(message) = self.tabs[i]
- .scene
- .validate_sketch_constraint(kind, &refs, driving_param.as_ref())
- {
+ CmdResult::AddParametricConstraint {
+ kind,
+ refs,
+ driving_param,
+ label,
+ } => {
+ if let Err(message) = self.tabs[i].scene.validate_parametric_constraint(
+ kind,
+ &refs,
+ driving_param.as_ref(),
+ ) {
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
self.command_line.push_error(message);
return Task::none();
}
- let scope = self.tabs[i].current_sketch_scope();
- let constraints_before = self
- .tabs[i]
+ let scope = self.tabs[i].current_parametric_scope();
+ let constraints_before = self.tabs[i]
.scene
- .sketch_constraint_set(scope)
+ .parametric_constraint_set(scope)
.cloned()
.unwrap_or_else(|| {
- crate::scene::sketch_constraints::SketchConstraintSet::new(scope)
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(scope)
});
let touched: Vec = refs.iter().map(|r| r.entity).collect();
let pending = self.begin_undo(i, label, touched.len(), true);
self.tabs[i]
.scene
- .record_undo_sketch_constraints_before(scope, constraints_before);
- self.tabs[i].scene.sketch_constraint_set_mut(scope).add(kind, refs, driving_param);
+ .record_undo_parametric_constraints_before(scope, constraints_before);
+ let retain_size = self.constraint_solve_mode && driving_param.is_none();
+ self.tabs[i].scene.parametric_constraint_set_mut(scope).add(
+ kind,
+ refs,
+ driving_param,
+ );
let changes: Vec<(Handle, crate::scene::ChangeKind)> = touched
.into_iter()
.map(|h| (h, crate::scene::ChangeKind::Modified))
.collect();
- self.tabs[i].scene.bump_entities(&changes);
+ self.tabs[i].scene.bump_entities_with_parametric_policy(
+ &changes,
+ &[],
+ retain_size,
+ );
self.tabs[i].dirty = true;
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
@@ -2858,48 +3097,197 @@ impl OpenCADStudio {
self.commit_undo_delta(i, pd);
}
}
- CmdResult::AddCoincidentConstraint { point_a, point_b, label } => {
- let scope = self.tabs[i].current_sketch_scope();
+ CmdResult::AddCoincidentConstraint {
+ first,
+ second,
+ multiple,
+ label,
+ } => {
+ let scope = self.tabs[i].current_parametric_scope();
let to_world = |p: glam::DVec3| acadrust::types::Vector3::new(p.x, p.y, p.z);
- let resolved_a =
- crate::scene::sketch_constraints::nearest_sketch_point(&self.tabs[i].scene.document, scope, to_world(point_a), None);
- let resolved_b = resolved_a.and_then(|ref_a| {
- crate::scene::sketch_constraints::nearest_sketch_point(&self.tabs[i].scene.document, scope, to_world(point_b), None)
- .filter(|ref_b| *ref_b != ref_a)
- });
- match (resolved_a, resolved_b) {
- (Some(ref_a), Some(ref_b)) => {
- return self.apply_cmd_result(CmdResult::AddSketchConstraint {
- kind: crate::scene::sketch_constraints::ConstraintKind::Coincident,
- refs: vec![ref_a, ref_b],
- driving_param: None,
- label,
- });
+ let resolve = |pick: crate::command::CoincidentPick,
+ exclude: Option| {
+ if pick.whole_curve {
+ pick.handle.and_then(|handle| {
+ crate::scene::parametric_constraints::parametric_curve_ref_for_pick(
+ &self.tabs[i].scene.document,
+ scope,
+ handle,
+ to_world(pick.point),
+ )
+ })
+ } else if let Some(handle) = pick.handle {
+ crate::scene::parametric_constraints::nearest_parametric_point_on_entity(
+ &self.tabs[i].scene.document,
+ scope,
+ handle,
+ to_world(pick.point),
+ )
+ } else {
+ crate::scene::parametric_constraints::nearest_parametric_point(
+ &self.tabs[i].scene.document,
+ scope,
+ to_world(pick.point),
+ exclude,
+ )
}
+ };
+ let resolved_first = resolve(first, None);
+ let resolved_second = resolved_first
+ .and_then(|reference| resolve(second, Some(reference.entity)));
+ let (Some(first_ref), Some(second_ref)) = (resolved_first, resolved_second) else {
+ self.command_line.push_error(
+ "Coincident: select a supported endpoint, center, midpoint, vertex, or curve.",
+ );
+ return Task::none();
+ };
+ let (kind, refs) = match (first.whole_curve, second.whole_curve) {
+ (false, false) if first_ref != second_ref => (
+ crate::scene::parametric_constraints::ConstraintKind::Coincident,
+ vec![first_ref, second_ref],
+ ),
+ (true, false) => (
+ crate::scene::parametric_constraints::ConstraintKind::PointOnCurve,
+ vec![second_ref, first_ref],
+ ),
+ (false, true) => (
+ crate::scene::parametric_constraints::ConstraintKind::PointOnCurve,
+ vec![first_ref, second_ref],
+ ),
_ => {
- self.command_line.push_error(
- "Coincident: pick didn't land on a point (endpoint, center, or vertex) — enable an Endpoint/Center object snap and try again.",
- );
- self.tabs[i].active_cmd = None;
- self.tabs[i].snap_result = None;
+ self.command_line
+ .push_error("Coincident: select one point and one curve, or two points.");
+ return Task::none();
}
+ };
+ if let Err(error) = self.tabs[i]
+ .scene
+ .validate_parametric_constraint(kind, &refs, None)
+ {
+ self.command_line.push_error(error);
+ return Task::none();
+ }
+ let touched: Vec<_> = refs.iter().map(|reference| reference.entity).collect();
+ let constraints_before = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .cloned()
+ .unwrap_or_else(|| {
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(scope)
+ });
+ let pending = self.begin_undo(i, label, touched.len(), true);
+ self.tabs[i]
+ .scene
+ .record_undo_parametric_constraints_before(scope, constraints_before);
+ self.tabs[i]
+ .scene
+ .parametric_constraint_set_mut(scope)
+ .add(kind, refs, None);
+ let changes: Vec<_> = touched
+ .iter()
+ .copied()
+ .map(|handle| (handle, crate::scene::ChangeKind::Modified))
+ .collect();
+ self.tabs[i].scene.bump_entities_with_parametric_policy(
+ &changes,
+ &[first_ref],
+ self.constraint_solve_mode,
+ );
+ self.tabs[i].dirty = true;
+ self.tabs[i].snap_result = None;
+ if !multiple {
+ self.tabs[i].active_cmd = None;
+ }
+ self.command_line.push_output("Coincident constraint applied.");
+ if multiple {
+ if let Some(prompt) = self.tabs[i].active_cmd.as_ref().map(|cmd| cmd.prompt()) {
+ self.command_line.push_info(&prompt);
+ }
+ self.command_line.set_step_options(
+ self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .map(|cmd| cmd.options())
+ .unwrap_or_default(),
+ );
+ }
+ self.refresh_properties();
+ if let Some(pd) = pending {
+ self.commit_undo_delta(i, pd);
}
}
- CmdResult::AddPointOnEntityConstraint { point, target, kind, label } => {
- let scope = self.tabs[i].current_sketch_scope();
+ CmdResult::AddAutoCoincidentConstraints { handles } => {
+ use crate::scene::parametric_constraints::ConstraintKind;
+ let scope = self.tabs[i].current_parametric_scope();
+ let inferred = self.tabs[i]
+ .scene
+ .inferred_coincident_constraints(scope, &handles);
+ let count = inferred.len();
+ if count > 0 {
+ let constraints_before = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .cloned()
+ .unwrap_or_else(|| {
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(
+ scope,
+ )
+ });
+ let pending = self.begin_undo(i, "Coincident auto constrain", handles.len(), true);
+ self.tabs[i]
+ .scene
+ .record_undo_parametric_constraints_before(scope, constraints_before);
+ for refs in inferred {
+ self.tabs[i]
+ .scene
+ .parametric_constraint_set_mut(scope)
+ .add(ConstraintKind::Coincident, refs, None);
+ }
+ let changes: Vec<_> = handles
+ .iter()
+ .copied()
+ .map(|handle| (handle, crate::scene::ChangeKind::Modified))
+ .collect();
+ self.tabs[i].scene.bump_entities(&changes);
+ self.tabs[i].dirty = true;
+ self.refresh_properties();
+ if let Some(pd) = pending {
+ self.commit_undo_delta(i, pd);
+ }
+ }
+ self.tabs[i].active_cmd = None;
+ self.tabs[i].snap_result = None;
+ self.command_line
+ .push_output(format!("{} coincident constraint(s) applied.", count).as_str());
+ }
+ CmdResult::AddPointOnEntityConstraint {
+ point,
+ target,
+ kind,
+ label,
+ } => {
+ let scope = self.tabs[i].current_parametric_scope();
let to_world = |p: glam::DVec3| acadrust::types::Vector3::new(p.x, p.y, p.z);
- let resolved = crate::scene::sketch_constraints::nearest_sketch_point(&self.tabs[i].scene.document, scope, to_world(point), Some(target));
+ let resolved = crate::scene::parametric_constraints::nearest_parametric_point(
+ &self.tabs[i].scene.document,
+ scope,
+ to_world(point),
+ Some(target),
+ );
match resolved {
Some(point_ref) => {
- use crate::scene::sketch_constraints::{ConstraintKind, SketchRef};
+ use crate::scene::parametric_constraints::{ConstraintKind, ParametricRef};
// `CenterPoint` addresses its whole-entity side via
// the center marker (same solve as Coincident /
// Concentric — `ConstraintKind::CenterPoint`'s own
// doc comment); `Midpoint`/`PointOnCurve` address it
// as a whole entity.
- let target_ref =
- if kind == ConstraintKind::CenterPoint { SketchRef::center(target) } else { SketchRef::whole(target) };
- return self.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let target_ref = if kind == ConstraintKind::CenterPoint {
+ ParametricRef::center(target)
+ } else {
+ ParametricRef::whole(target)
+ };
+ return self.apply_cmd_result(CmdResult::AddParametricConstraint {
kind,
refs: vec![point_ref, target_ref],
driving_param: None,
@@ -2916,20 +3304,24 @@ impl OpenCADStudio {
}
}
CmdResult::AddEqualDistanceConstraint { points, label } => {
- let scope = self.tabs[i].current_sketch_scope();
+ let scope = self.tabs[i].current_parametric_scope();
let to_world = |p: glam::DVec3| acadrust::types::Vector3::new(p.x, p.y, p.z);
let mut refs = Vec::with_capacity(4);
for p in points {
- let Some(r) = crate::scene::sketch_constraints::nearest_sketch_point(&self.tabs[i].scene.document, scope, to_world(p), None)
- else {
+ let Some(r) = crate::scene::parametric_constraints::nearest_parametric_point(
+ &self.tabs[i].scene.document,
+ scope,
+ to_world(p),
+ None,
+ ) else {
refs.clear();
break;
};
refs.push(r);
}
if refs.len() == 4 {
- return self.apply_cmd_result(CmdResult::AddSketchConstraint {
- kind: crate::scene::sketch_constraints::ConstraintKind::EqualDistance,
+ return self.apply_cmd_result(CmdResult::AddParametricConstraint {
+ kind: crate::scene::parametric_constraints::ConstraintKind::EqualDistance,
refs,
driving_param: None,
label,
@@ -2941,19 +3333,27 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
}
- CmdResult::ReassociateCenterMark { target, source, point } => {
+ CmdResult::ReassociateCenterMark {
+ target,
+ source,
+ point,
+ } => {
if self.reject_locked_edit(i, target) {
return Task::none();
}
self.push_undo_snapshot(i, "CENTERREASSOCIATE");
- if self.tabs[i].scene.reassociate_center_mark(target, source, point) {
+ if self.tabs[i]
+ .scene
+ .reassociate_center_mark(target, source, point)
+ {
self.tabs[i].dirty = true;
self.command_line.push_output(
crate::t!("CENTERREASSOCIATE: center mark associated.").as_ref(),
);
} else {
self.command_line.push_error(
- crate::t!("CENTERREASSOCIATE: the selected source is not circular.").as_ref(),
+ crate::t!("CENTERREASSOCIATE: the selected source is not circular.")
+ .as_ref(),
);
}
self.tabs[i].active_cmd = None;
@@ -3089,12 +3489,23 @@ impl OpenCADStudio {
self.tabs[i].scene.invalidate_dim_block_recorded(nh);
}
}
- let pedit_entities = if self.tabs[i].active_cmd.as_ref().is_some_and(|command| command.name() == "PEDIT") {
- new_handles.iter().filter_map(|new| self.tabs[i].scene.document.get_entity(*new).cloned()).collect::>()
- } else { Vec::new() };
+ let pedit_entities = if self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .is_some_and(|command| command.name() == "PEDIT")
+ {
+ new_handles
+ .iter()
+ .filter_map(|new| self.tabs[i].scene.document.get_entity(*new).cloned())
+ .collect::>()
+ } else {
+ Vec::new()
+ };
if let Some(cmd) = &mut self.tabs[i].active_cmd {
cmd.on_entity_replaced(handle, &new_handles);
- for entity in pedit_entities { cmd.inject_picked_entity(entity); }
+ for entity in pedit_entities {
+ cmd.inject_picked_entity(entity);
+ }
}
self.tabs[i].dirty = true;
let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
@@ -3211,11 +3622,15 @@ impl OpenCADStudio {
// snapshot — the create already pushed one, so the whole object
// reverts as a unit.
if let Some(old) = self.tabs[i].scene.document.get_entity_mut(handle) {
- let old_handle = old.as_entity().handle();
- let layer = old.as_entity().layer().to_string();
+ // The initial live commit assigns the handle, owning block,
+ // current layer and common display properties. Geometry
+ // refreshes must retain all of that identity; replacing only
+ // the handle and layer reset owner_handle to NULL and made
+ // the completed entity unavailable to scoped operations such
+ // as parametric constraints.
+ let common = old.common().clone();
let mut new = entity;
- new.as_entity_mut().set_handle(old_handle);
- new.as_entity_mut().set_layer(layer);
+ *new.common_mut() = common;
*old = new;
self.tabs[i]
.scene
@@ -3288,11 +3703,14 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
self.restore_pre_cmd_tangent();
- self.command_line.push_info(crate::t!(if space_changed {
- "Command cancelled because the active drawing space changed."
- } else {
- "Command cancelled."
- }).as_ref());
+ self.command_line.push_info(
+ crate::t!(if space_changed {
+ "Command cancelled because the active drawing space changed."
+ } else {
+ "Command cancelled."
+ })
+ .as_ref(),
+ );
}
}
CmdResult::SelectByPath {
@@ -3400,7 +3818,9 @@ impl OpenCADStudio {
.objects
.get(&style_handle)
.and_then(|object| match object {
- acadrust::objects::ObjectType::TableStyle(style) => Some(style),
+ acadrust::objects::ObjectType::TableStyle(style) => {
+ Some(style)
+ }
_ => None,
})
});
@@ -3418,15 +3838,13 @@ impl OpenCADStudio {
match self.begin_table_cell_edit(i, handle, point) {
TableCellEditStart::Started => {}
TableCellEditStart::LockedCell => {
- self.command_line.push_error(
- crate::t!("The cell is content locked.").as_ref(),
- );
+ self.command_line
+ .push_error(crate::t!("The cell is content locked.").as_ref());
let _ = self.dispatch_command("TABLEDIT");
}
TableCellEditStart::NoCell => {
- self.command_line.push_error(
- crate::t!("No editable table cell picked.").as_ref(),
- );
+ self.command_line
+ .push_error(crate::t!("No editable table cell picked.").as_ref());
let _ = self.dispatch_command("TABLEDIT");
}
}
@@ -3463,7 +3881,8 @@ impl OpenCADStudio {
.push_info(crate::tf!("Layer matched to \"{layer}\".").as_ref());
self.sync_ribbon_layers();
} else {
- self.command_line.push_error(crate::t!("Source object not found.").as_ref());
+ self.command_line
+ .push_error(crate::t!("Source object not found.").as_ref());
}
}
CmdResult::MatchProperties { mut dest, src } => {
@@ -3600,15 +4019,17 @@ impl OpenCADStudio {
.map(|handle| (handle, crate::scene::ChangeKind::Modified))
.collect();
self.tabs[i].scene.bump_entities(&changes);
- self.command_line
- .push_info(crate::tf!("Properties matched to {} object(s).", dest.len()).as_ref());
+ self.command_line.push_info(
+ crate::tf!("Properties matched to {} object(s).", dest.len()).as_ref(),
+ );
// Clear the consumed target selection and keep prompting.
self.tabs[i].scene.deselect_all();
if let Some(cmd) = &self.tabs[i].active_cmd {
self.command_line.push_info(&cmd.prompt());
}
} else {
- self.command_line.push_error(crate::t!("Source object not found.").as_ref());
+ self.command_line
+ .push_error(crate::t!("Source object not found.").as_ref());
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
self.tabs[i].scene.clear_preview_wire();
@@ -3619,7 +4040,8 @@ impl OpenCADStudio {
self.tabs[i].snap_result = None;
self.tabs[i].scene.clear_preview_wire();
if self.clipboard.is_empty() {
- self.command_line.push_error(crate::t!("Clipboard is empty.").as_ref());
+ self.command_line
+ .push_error(crate::t!("Clipboard is empty.").as_ref());
} else {
let delta = base_pt - self.clipboard_base;
let translate = crate::command::EntityTransform::Translate(delta);
@@ -3751,14 +4173,16 @@ impl OpenCADStudio {
self.push_undo_snapshot(i, "VPLAYER");
self.tabs[i].dirty = true;
if frozen_count > 0 {
- self.command_line.push_info(crate::tf!(
- "VPLAYER: {frozen_count} layer(s) frozen in viewport."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("VPLAYER: {frozen_count} layer(s) frozen in viewport.")
+ .as_ref(),
+ );
}
if thawed_count > 0 {
- self.command_line.push_info(crate::tf!(
- "VPLAYER: {thawed_count} layer(s) thawed in viewport."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("VPLAYER: {thawed_count} layer(s) thawed in viewport.")
+ .as_ref(),
+ );
}
// Sync layer panel so VP freeze columns update immediately.
let doc_layers = self.tabs[i].scene.document.layers.clone();
@@ -3783,7 +4207,8 @@ impl OpenCADStudio {
self.tabs[i]
.scene
.zoom_to_window(p1.as_vec3(), p2.as_vec3());
- self.command_line.push_output(crate::t!("Zoom Window").as_ref());
+ self.command_line
+ .push_output(crate::t!("Zoom Window").as_ref());
}
CmdResult::Measurement(msg) => {
self.tabs[i].active_cmd = None;
@@ -3889,7 +4314,8 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
self.restore_pre_cmd_tangent();
- self.command_line.push_output(crate::t!("ALIGN: applied.").as_ref());
+ self.command_line
+ .push_output(crate::t!("ALIGN: applied.").as_ref());
self.refresh_properties();
if let Some(pd) = pending {
self.commit_undo_delta(i, pd);
@@ -3917,7 +4343,8 @@ impl OpenCADStudio {
self.tabs[i].scene.erase_entities(&[handle]);
self.tabs[i].scene.add_entity(new_entity);
self.tabs[i].dirty = true;
- self.command_line.push_output(crate::t!("LENGTHEN: applied.").as_ref());
+ self.command_line
+ .push_output(crate::t!("LENGTHEN: applied.").as_ref());
self.refresh_properties();
}
None => {
@@ -3950,8 +4377,9 @@ impl OpenCADStudio {
self.command_line
.push_output(crate::tf!("DIVIDE: {count} marker(s) placed.").as_ref());
} else {
- self.command_line
- .push_error(crate::t!("DIVIDE: entity type not supported or N < 2.").as_ref());
+ self.command_line.push_error(
+ crate::t!("DIVIDE: entity type not supported or N < 2.").as_ref(),
+ );
}
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
@@ -3993,24 +4421,53 @@ impl OpenCADStudio {
}
CmdResult::PeditOp { handle, op } => return self.apply_pedit_result(i, handle, op),
CmdResult::JoinToSource { source, handles } => {
- if self.reject_locked_edit(i, source) { return Task::none(); }
- let joined = self.tabs[i].scene.document.get_entity(source).and_then(|entity| {
- let candidates: Vec<_> = handles.iter().filter(|handle| **handle != source && !self.tabs[i].scene.is_layer_locked(**handle))
- .filter_map(|handle| self.tabs[i].scene.document.get_entity(*handle).map(|entity| (*handle,entity))).collect();
- crate::modules::draw::modify::join::join_to_source(entity,&candidates)
- });
+ if self.reject_locked_edit(i, source) {
+ return Task::none();
+ }
+ let joined = self.tabs[i]
+ .scene
+ .document
+ .get_entity(source)
+ .and_then(|entity| {
+ let candidates: Vec<_> = handles
+ .iter()
+ .filter(|handle| {
+ **handle != source && !self.tabs[i].scene.is_layer_locked(**handle)
+ })
+ .filter_map(|handle| {
+ self.tabs[i]
+ .scene
+ .document
+ .get_entity(*handle)
+ .map(|entity| (*handle, entity))
+ })
+ .collect();
+ crate::modules::draw::modify::join::join_to_source(entity, &candidates)
+ });
if let Some((replacement, consumed)) = joined {
- self.push_undo_snapshot(i,"JOIN");
- if let Some(entity) = self.tabs[i].scene.document.get_entity_mut(source) { *entity = replacement; }
+ self.push_undo_snapshot(i, "JOIN");
+ if let Some(entity) = self.tabs[i].scene.document.get_entity_mut(source) {
+ *entity = replacement;
+ }
self.tabs[i].scene.erase_entities(&consumed);
self.tabs[i].scene.refresh_fill_model(source);
- self.tabs[i].scene.bump_entities(&[(source,crate::scene::ChangeKind::Modified)]);
+ self.tabs[i]
+ .scene
+ .bump_entities(&[(source, crate::scene::ChangeKind::Modified)]);
self.tabs[i].dirty = true;
- self.command_line.push_output(&format!("JOIN: {} objects joined to source.",consumed.len()));
+ self.command_line.push_output(&format!(
+ "JOIN: {} objects joined to source.",
+ consumed.len()
+ ));
self.refresh_properties();
- } else { self.command_line.push_info("JOIN: no compatible objects joined to source."); }
- self.tabs[i].active_cmd = None; self.tabs[i].snap_result = None;
- self.tabs[i].scene.clear_preview_wire(); self.restore_pre_cmd_tangent();
+ } else {
+ self.command_line
+ .push_info("JOIN: no compatible objects joined to source.");
+ }
+ self.tabs[i].active_cmd = None;
+ self.tabs[i].snap_result = None;
+ self.tabs[i].scene.clear_preview_wire();
+ self.restore_pre_cmd_tangent();
}
CmdResult::JoinEntities(handles) => {
if let Some(handle) = handles
@@ -4040,9 +4497,10 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
self.restore_pre_cmd_tangent();
- self.command_line.push_output(crate::tf!(
- "JOIN: {count_in} object(s) joined into {count_out}."
- ).as_ref());
+ self.command_line.push_output(
+ crate::tf!("JOIN: {count_in} object(s) joined into {count_out}.")
+ .as_ref(),
+ );
self.refresh_properties();
}
None => {
@@ -4068,12 +4526,14 @@ impl OpenCADStudio {
.and_then(|e| break_entity(e, p1, p2));
match replacement {
Some(frags) => {
- let unchanged = frags.len() == 1 && self.tabs[i].scene.document.get_entity(handle)
- .is_some_and(|original| {
- let mut fragment = frags[0].clone();
- fragment.common_mut().handle = handle;
- &fragment == original
- });
+ let unchanged = frags.len() == 1
+ && self.tabs[i].scene.document.get_entity(handle).is_some_and(
+ |original| {
+ let mut fragment = frags[0].clone();
+ fragment.common_mut().handle = handle;
+ &fragment == original
+ },
+ );
if unchanged {
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
@@ -4085,7 +4545,10 @@ impl OpenCADStudio {
let label = self.history_label_from_active_cmd(i, "BREAK");
self.push_undo_snapshot(i, label);
let count = frags.len();
- let owner = self.tabs[i].scene.document.get_entity(handle)
+ let owner = self.tabs[i]
+ .scene
+ .document
+ .get_entity(handle)
.map(|entity| entity.common().owner_handle);
let mut fragments = frags.into_iter();
if let Some(mut first) = fragments.next() {
@@ -4093,7 +4556,9 @@ impl OpenCADStudio {
self.tabs[i].scene.update_entity(first);
for mut fragment in fragments {
fragment.common_mut().handle = Handle::NULL;
- if let Some(owner) = owner { fragment.common_mut().owner_handle = owner; }
+ if let Some(owner) = owner {
+ fragment.common_mut().owner_handle = owner;
+ }
self.tabs[i].scene.add_entity(fragment);
}
} else {
@@ -4127,8 +4592,9 @@ impl OpenCADStudio {
let x1 = p1.x.max(p2.x);
let y1 = p1.y.max(p2.y);
self.plot_window = Some((x0, y0, x1, y1));
- self.command_line
- .push_output(crate::tf!("Plot window: {x0:.2},{y0:.2} to {x1:.2},{y1:.2}").as_ref());
+ self.command_line.push_output(
+ crate::tf!("Plot window: {x0:.2},{y0:.2} to {x1:.2},{y1:.2}").as_ref(),
+ );
// Pick window closed the plot dialog so the viewport could
// receive the two clicks — bring the dialog back with the
// window now active.
@@ -4145,9 +4611,9 @@ impl OpenCADStudio {
let x2 = p1.x.max(p2.x);
let y2 = p1.y.max(p2.y);
self.plot_window = Some((x1, y1, x2, y2));
- self.command_line.push_output(crate::tf!(
- "Plot window: {x1:.2},{y1:.2} to {x2:.2},{y2:.2}"
- ).as_ref());
+ self.command_line.push_output(
+ crate::tf!("Plot window: {x1:.2},{y1:.2} to {x2:.2},{y2:.2}").as_ref(),
+ );
self.plot_dialog.area = "Window".to_string();
self.active_modal = Some(super::ModalKind::Plot);
}
@@ -4176,10 +4642,7 @@ impl OpenCADStudio {
handles.extend(
scene
.interaction_handles_in_world_aabb([
- win_min.x,
- win_min.y,
- win_max.x,
- win_max.y,
+ win_min.x, win_min.y, win_max.x, win_max.y,
])
.into_iter()
.filter(|&handle| !scene.is_layer_locked(handle)),
@@ -4191,9 +4654,8 @@ impl OpenCADStudio {
handles.dedup();
if handles.is_empty() {
- self.command_line.push_output(
- crate::t!("STRETCH: nothing crosses the window.").as_ref(),
- );
+ self.command_line
+ .push_output(crate::t!("STRETCH: nothing crosses the window.").as_ref());
} else {
// Visual feedback must only highlight entities that actually have a
// stretchable point inside one of the crossing windows. `handles` can
@@ -4276,11 +4738,7 @@ impl OpenCADStudio {
let wires = self.tabs[i].scene.wire_models_for(&handles);
- let cmd = StretchCommand::with_windows(
- handles,
- wires,
- windows,
- );
+ let cmd = StretchCommand::with_windows(handles, wires, windows);
self.command_line.push_info(&CadCommand::prompt(&cmd));
self.tabs[i].active_cmd = Some(Box::new(cmd));
@@ -4304,15 +4762,13 @@ impl OpenCADStudio {
let pending = self.begin_undo(i, "STRETCH", handles.len(), !structural);
let mut count = 0usize;
let mut changed_handles = Vec::new();
+ let mut driven_refs = Vec::new();
// Helper: is DXF point (x, y) inside the world-space window?
// Drawing plane is world XY (= DXF XY).
let in_win = |x: f64, y: f64| -> bool {
windows.iter().any(|(win_min, win_max)| {
- x >= win_min.x
- && x <= win_max.x
- && y >= win_min.y
- && y <= win_max.y
+ x >= win_min.x && x <= win_max.x && y >= win_min.y && y <= win_max.y
})
};
@@ -4325,6 +4781,54 @@ impl OpenCADStudio {
let mut stretched_dims: Vec = Vec::new();
for handle in &handles {
let before = self.tabs[i].scene.document.get_entity_arc(*handle);
+ if let Some(entity) = before.as_deref() {
+ use crate::scene::parametric_constraints::ParametricRef;
+ match entity {
+ acadrust::EntityType::Line(line) => {
+ if in_win(line.start.x, line.start.y) {
+ driven_refs.push(ParametricRef::point(*handle, 0));
+ }
+ if in_win(line.end.x, line.end.y) {
+ driven_refs.push(ParametricRef::point(*handle, 1));
+ }
+ }
+ acadrust::EntityType::LwPolyline(polyline) => {
+ if let Some(world) =
+ crate::entities::curve::lwpolyline_world_xy(polyline)
+ {
+ for (index, vertex) in world.vertices.iter().enumerate() {
+ if in_win(vertex.location.x, vertex.location.y) {
+ driven_refs.push(ParametricRef::point(
+ *handle,
+ index as i32,
+ ));
+ }
+ }
+ }
+ }
+ acadrust::EntityType::Polyline2D(polyline) => {
+ for (index, vertex) in polyline.vertices.iter().enumerate() {
+ if in_win(vertex.location.x, vertex.location.y) {
+ driven_refs.push(ParametricRef::point(
+ *handle,
+ index as i32,
+ ));
+ }
+ }
+ }
+ acadrust::EntityType::Circle(circle)
+ if in_win(circle.center.x, circle.center.y) =>
+ {
+ driven_refs.push(ParametricRef::center(*handle));
+ }
+ acadrust::EntityType::Arc(arc)
+ if in_win(arc.center.x, arc.center.y) =>
+ {
+ driven_refs.push(ParametricRef::center(*handle));
+ }
+ _ => {}
+ }
+ }
let Some(entity) = self.tabs[i].scene.document.get_entity_mut(*handle) else {
continue;
};
@@ -4347,8 +4851,7 @@ impl OpenCADStudio {
}
}
acadrust::EntityType::LwPolyline(p) => {
- let Some(mut world) =
- crate::entities::curve::lwpolyline_world_xy(p)
+ let Some(mut world) = crate::entities::curve::lwpolyline_world_xy(p)
else {
continue;
};
@@ -4431,12 +4934,7 @@ impl OpenCADStudio {
}
acadrust::EntityType::Viewport(vp) => {
stretched = windows.iter().any(|(win_min, win_max)| {
- crate::entities::viewport::stretch(
- vp,
- *win_min,
- *win_max,
- delta,
- )
+ crate::entities::viewport::stretch(vp, *win_min, *win_max, delta)
});
}
acadrust::EntityType::Dimension(dim) => {
@@ -4553,7 +5051,12 @@ impl OpenCADStudio {
.iter()
.map(|&handle| (handle, crate::scene::ChangeKind::Modified))
.collect();
- self.tabs[i].scene.bump_entities(&changes);
+ self.tabs[i].scene.bump_entities_with_parametric_policy(
+ &changes,
+ &driven_refs,
+ self.constraint_solve_mode && !driven_refs.is_empty(),
+ );
+ self.apply_inferred_constraints(i, &changed_handles);
}
self.tabs[i].dirty = true;
self.tabs[i].active_cmd = None;
@@ -4585,9 +5088,7 @@ impl OpenCADStudio {
return Task::none();
}
use crate::command::{ExtrudeExtent, ExtrudeMode};
- use crate::modules::insert::solid3d_cmds::{
- empty_extruded_surface, empty_solid3d,
- };
+ use crate::modules::insert::solid3d_cmds::{empty_extruded_surface, empty_solid3d};
use crate::scene::model::sweep_model;
let path = match extent {
ExtrudeExtent::Path(handle) => self.tabs[i]
@@ -4609,7 +5110,8 @@ impl OpenCADStudio {
let mut consumed = Vec::new();
let mut failed = 0usize;
for handle in &handles {
- let Some(entity) = self.tabs[i].scene.document.get_entity(*handle).cloned() else {
+ let Some(entity) = self.tabs[i].scene.document.get_entity(*handle).cloned()
+ else {
failed += 1;
continue;
};
@@ -4639,20 +5141,16 @@ impl OpenCADStudio {
(false, Some((_, path)), _) => {
sweep_model::extruded_along_path(&entity, path, taper_angle)
}
- (false, None, Some(direction)) => {
- sweep_model::extruded_direction(
- &entity,
- direction.to_array(),
- taper_angle,
- )
- }
- (true, None, Some(direction)) => {
- sweep_model::extruded_surface(
- &entity,
- direction.to_array(),
- taper_angle,
- )
- }
+ (false, None, Some(direction)) => sweep_model::extruded_direction(
+ &entity,
+ direction.to_array(),
+ taper_angle,
+ ),
+ (true, None, Some(direction)) => sweep_model::extruded_surface(
+ &entity,
+ direction.to_array(),
+ taper_angle,
+ ),
(true, Some(_), _) => path_direction.and_then(|direction| {
sweep_model::extruded_surface(
&entity,
@@ -4667,9 +5165,7 @@ impl OpenCADStudio {
continue;
};
let created = if creates_surface {
- let direction = direction
- .or(path_direction)
- .unwrap_or(glam::DVec3::ZERO);
+ let direction = direction.or(path_direction).unwrap_or(glam::DVec3::ZERO);
let history = path
.is_none()
.then(|| {
@@ -4701,28 +5197,28 @@ impl OpenCADStudio {
None => self.add_surface_model(surface, body),
}
} else {
- let direction = direction.unwrap_or(glam::DVec3::ZERO);
- let history = path
- .as_ref()
- .and_then(|(_, path)| {
- sweep_model::sweep_history(
- &entity,
- path,
- taper_angle,
- profile.plane.origin,
- )
- })
- .or_else(|| {
- sweep_model::extrusion_history(
- &entity,
- None,
- direction.to_array(),
- taper_angle,
- profile.plane.origin,
- )
- })
+ let direction = direction.unwrap_or(glam::DVec3::ZERO);
+ let history = path
+ .as_ref()
+ .and_then(|(_, path)| {
+ sweep_model::sweep_history(
+ &entity,
+ path,
+ taper_angle,
+ profile.plane.origin,
+ )
+ })
+ .or_else(|| {
+ sweep_model::extrusion_history(
+ &entity,
+ None,
+ direction.to_array(),
+ taper_angle,
+ profile.plane.origin,
+ )
+ })
.unwrap_or_else(|| crate::scene::model::solid_history::brep_op(&body));
- self.add_solid_model(empty_solid3d(), body, history)
+ self.add_solid_model(empty_solid3d(), body, history)
};
if created.is_null() {
failed += 1;
@@ -4780,9 +5276,8 @@ impl OpenCADStudio {
return Task::none();
}
if !distance.is_finite() {
- self.command_line.push_error(
- crate::t!("Requires numeric distance or two points.").as_ref(),
- );
+ self.command_line
+ .push_error(crate::t!("Requires numeric distance or two points.").as_ref());
return Task::none();
}
if distance.abs() <= f64::EPSILON {
@@ -4801,13 +5296,12 @@ impl OpenCADStudio {
failed += 1;
continue;
};
- let kernel_distance = if surface.kind
- == acadrust::entities::SurfaceKind::Revolved
- {
- -distance
- } else {
- distance
- };
+ let kernel_distance =
+ if surface.kind == acadrust::entities::SurfaceKind::Revolved {
+ -distance
+ } else {
+ distance
+ };
let body = self.tabs[i]
.scene
.solid_models
@@ -4864,10 +5358,19 @@ impl OpenCADStudio {
self.refresh_properties();
}
- CmdResult::PresspullPick { handle, point, offset, multiple: _ } => {
+ CmdResult::PresspullPick {
+ handle,
+ point,
+ offset,
+ multiple: _,
+ } => {
self.presspull_pick(handle, point, offset);
}
- CmdResult::PresspullApply { targets, distance, color: _ } => {
+ CmdResult::PresspullApply {
+ targets,
+ distance,
+ color: _,
+ } => {
self.presspull_apply(targets, distance);
}
@@ -4890,9 +5393,7 @@ impl OpenCADStudio {
}
let delete_sources = self.delete_objects != 0;
use crate::command::ExtrudeMode;
- use crate::modules::insert::solid3d_cmds::{
- empty_revolved_surface, empty_solid3d,
- };
+ use crate::modules::insert::solid3d_cmds::{empty_revolved_surface, empty_solid3d};
use crate::scene::model::sweep_model;
let from = axis_start.to_array();
let to = axis_end.to_array();
@@ -4941,27 +5442,21 @@ impl OpenCADStudio {
body,
)
} else {
- let result = sweep_model::revolve_history(
- &entity,
- from,
- to,
- angle,
- start_angle,
- )
- .and_then(|history| {
- cadkernel::acis::rebuild_body(&history)
- .ok()
- .map(|solid| (solid, history))
- })
- .or_else(|| {
- sweep_model::revolved(&entity, from, to, angle, start_angle).map(
- |solid| {
- let history =
- crate::scene::model::solid_history::brep_op(&solid);
- (solid, history)
- },
- )
- });
+ let result =
+ sweep_model::revolve_history(&entity, from, to, angle, start_angle)
+ .and_then(|history| {
+ cadkernel::acis::rebuild_body(&history)
+ .ok()
+ .map(|solid| (solid, history))
+ })
+ .or_else(|| {
+ sweep_model::revolved(&entity, from, to, angle, start_angle)
+ .map(|solid| {
+ let history =
+ crate::scene::model::solid_history::brep_op(&solid);
+ (solid, history)
+ })
+ });
let Some((solid, history)) = result else {
failed += 1;
continue;
@@ -5038,7 +5533,10 @@ impl OpenCADStudio {
failed += 1;
}
}
- let selection = profiles.iter().map(|(_, entity)| entity.clone()).collect::>();
+ let selection = profiles
+ .iter()
+ .map(|(_, entity)| entity.clone())
+ .collect::>();
let options = sweep_model::sweep_selection_options(&selection, options);
let pending = if profiles.is_empty() {
None
@@ -5051,20 +5549,21 @@ impl OpenCADStudio {
let result = path.as_ref().zip(options).and_then(|(path, options)| {
let record = sweep_model::sweep_record(&profile, path, options)?;
let (_, _, closed) = cadkernel::acis::sweep_profile_geometry(
- record.sweep_entity.as_ref()?, record.sweep_entity_transform,
- ).ok()?;
+ record.sweep_entity.as_ref()?,
+ record.sweep_entity_transform,
+ )
+ .ok()?;
let surface = mode == ExtrudeMode::Surface || !closed;
- let body = cadkernel::acis::rebuild_sweep_with_mode(&record, surface).ok()?;
+ let body =
+ cadkernel::acis::rebuild_sweep_with_mode(&record, surface).ok()?;
Some((body, record, surface))
});
let Some((body, record, surface)) = result else {
failed += 1;
continue;
};
- let deletes_path = crate::app::delobj_deletes_auxiliary(
- delete_objects,
- surface,
- );
+ let deletes_path =
+ crate::app::delobj_deletes_auxiliary(delete_objects, surface);
if deletes_path && self.tabs[i].scene.is_layer_locked(path_handle) {
failed += 1;
continue;
@@ -5073,7 +5572,8 @@ impl OpenCADStudio {
self.add_surface_model(sweep_model::swept_surface_entity(&record), body)
} else {
self.add_solid_model(
- empty_solid3d(), body,
+ empty_solid3d(),
+ body,
acadrust::objects::SolidHistoryOperation::Sweep(record),
)
};
@@ -5103,7 +5603,9 @@ impl OpenCADStudio {
created = created_handles.len(), failed = failed
).as_ref());
} else {
- self.command_line.push_error(crate::t!("SWEEP: could not sweep the profile along the path.").as_ref());
+ self.command_line.push_error(
+ crate::t!("SWEEP: could not sweep the profile along the path.").as_ref(),
+ );
}
if let Some(pending) = pending {
self.commit_undo_delta(i, pending);
@@ -5116,39 +5618,69 @@ impl OpenCADStudio {
}
// ── LOFT ──────────────────────────────────────────────────────
- CmdResult::LoftEntities { sections, guides, path, mode, options, color: _ } => {
+ CmdResult::LoftEntities {
+ sections,
+ guides,
+ path,
+ mode,
+ options,
+ color: _,
+ } => {
use crate::command::LoftSectionSelection;
use crate::modules::insert::solid3d_cmds::empty_solid3d;
use crate::scene::model::loft_command_model;
- let mut sources = sections.iter().flat_map(|section| match section {
- LoftSectionSelection::Entity(handle) => vec![*handle],
- LoftSectionSelection::Join(handles) => handles.clone(),
- LoftSectionSelection::Point(_) => Vec::new(),
- }).collect::>();
+ let mut sources = sections
+ .iter()
+ .flat_map(|section| match section {
+ LoftSectionSelection::Entity(handle) => vec![*handle],
+ LoftSectionSelection::Join(handles) => handles.clone(),
+ LoftSectionSelection::Point(_) => Vec::new(),
+ })
+ .collect::>();
sources.sort_unstable_by_key(|handle| handle.value());
sources.dedup();
let delete_objects = self.delete_objects;
let delete_sections = delete_objects != 0;
let section_locked = delete_sections
- && sources.iter().any(|handle| self.tabs[i].scene.is_layer_locked(*handle));
- let available = sources.iter().chain(guides.iter()).copied().chain(path)
- .filter_map(|handle| self.tabs[i].scene.document.get_entity(handle)
- .cloned().map(|entity| (handle, entity))).collect::>();
+ && sources
+ .iter()
+ .any(|handle| self.tabs[i].scene.is_layer_locked(*handle));
+ let available = sources
+ .iter()
+ .chain(guides.iter())
+ .copied()
+ .chain(path)
+ .filter_map(|handle| {
+ self.tabs[i]
+ .scene
+ .document
+ .get_entity(handle)
+ .cloned()
+ .map(|entity| (handle, entity))
+ })
+ .collect::>();
let result = if section_locked {
Err("LOFT: a source is on a locked layer; disable source deletion or unlock it.".to_string())
} else {
loft_command_model::record(§ions, &guides, path, &available, mode, options)
- .and_then(|record| cadkernel::acis::rebuild_loft_with_options(&record).map(|body| (body, record)))
+ .and_then(|record| {
+ cadkernel::acis::rebuild_loft_with_options(&record)
+ .map(|body| (body, record))
+ })
};
match result {
Ok((body, record)) => {
- let surface = record.parameters.as_ref().is_some_and(|settings| settings.surface);
- let delete_auxiliary = crate::app::delobj_deletes_auxiliary(
- delete_objects,
- surface,
- );
+ let surface = record
+ .parameters
+ .as_ref()
+ .is_some_and(|settings| settings.surface);
+ let delete_auxiliary =
+ crate::app::delobj_deletes_auxiliary(delete_objects, surface);
if delete_auxiliary
- && guides.iter().copied().chain(path)
+ && guides
+ .iter()
+ .copied()
+ .chain(path)
.any(|handle| self.tabs[i].scene.is_layer_locked(handle))
{
self.command_line.push_error(
@@ -5159,15 +5691,23 @@ impl OpenCADStudio {
let dirty_before = self.tabs[i].dirty;
let pending = self.begin_undo(i, "LOFT", 1, true);
let created = if surface {
- let handle = self.add_surface_model(loft_command_model::surface_entity(&record), body);
+ let handle = self.add_surface_model(
+ loft_command_model::surface_entity(&record),
+ body,
+ );
if !handle.is_null() {
- self.tabs[i].scene.create_solid_history(handle,
- acadrust::objects::SolidHistoryOperation::Loft(record));
+ self.tabs[i].scene.create_solid_history(
+ handle,
+ acadrust::objects::SolidHistoryOperation::Loft(record),
+ );
}
handle
} else {
- self.add_solid_model(empty_solid3d(), body,
- acadrust::objects::SolidHistoryOperation::Loft(record))
+ self.add_solid_model(
+ empty_solid3d(),
+ body,
+ acadrust::objects::SolidHistoryOperation::Loft(record),
+ )
};
if created.is_null() {
// The creation helper already removed its provisional
@@ -5194,10 +5734,14 @@ impl OpenCADStudio {
self.tabs[i].dirty = true;
let message = if surface {
crate::t!("LOFT: surface created.")
- } else { crate::t!("LOFT: solid created.") };
+ } else {
+ crate::t!("LOFT: solid created.")
+ };
self.command_line.push_output(message.as_ref());
}
- if let Some(pending) = pending { self.commit_undo_delta(i, pending); }
+ if let Some(pending) = pending {
+ self.commit_undo_delta(i, pending);
+ }
}
Err(error) => {
self.command_line.push_error(&error);
@@ -5219,14 +5763,8 @@ impl OpenCADStudio {
other_value,
fillet,
} => {
- let task = self.solid_edge_blend(
- handle,
- &edges,
- base_face,
- value,
- other_value,
- fillet,
- );
+ let task =
+ self.solid_edge_blend(handle, &edges, base_face, value, other_value, fillet);
self.tabs[i].active_cmd = None;
self.tabs[i].snap_result = None;
self.tabs[i].scene.clear_preview_wire();
@@ -5304,39 +5842,63 @@ impl OpenCADStudio {
.push_error(crate::t!("HATCHEDIT: hatch entity not found.").as_ref());
} else {
use crate::command::{CadCommand, HatchEditOperation};
- if matches!(&operation,HatchEditOperation::BeginAssociate) {
- let associative=matches!(self.tabs[i].scene.document.get_entity(handle),Some(acadrust::EntityType::Hatch(h)) if h.is_associative);
+ if matches!(&operation, HatchEditOperation::BeginAssociate) {
+ let associative = matches!(self.tabs[i].scene.document.get_entity(handle),Some(acadrust::EntityType::Hatch(h)) if h.is_associative);
if associative {
- self.command_line.push_info("HATCHEDIT: hatch is already associative.");
- self.tabs[i].active_cmd=None;
- }else{
- let plane=match self.tabs[i].scene.document.get_entity(handle) {
- Some(acadrust::EntityType::Hatch(h))=>{
- let storage=crate::entities::curve::ocs_plane(h.normal,h.elevation);
- crate::command::WorkingPlane::new(glam::DVec3::from_array(storage.origin),glam::DVec3::from_array(storage.x_axis),glam::DVec3::from_array(storage.y_axis))
- },
- _=>self.tabs[i].ucs_xform().working_plane(),
+ self.command_line
+ .push_info("HATCHEDIT: hatch is already associative.");
+ self.tabs[i].active_cmd = None;
+ } else {
+ let plane = match self.tabs[i].scene.document.get_entity(handle) {
+ Some(acadrust::EntityType::Hatch(h)) => {
+ let storage =
+ crate::entities::curve::ocs_plane(h.normal, h.elevation);
+ crate::command::WorkingPlane::new(
+ glam::DVec3::from_array(storage.origin),
+ glam::DVec3::from_array(storage.x_axis),
+ glam::DVec3::from_array(storage.y_axis),
+ )
+ }
+ _ => self.tabs[i].ucs_xform().working_plane(),
};
- let mut sources=self.tabs[i].scene.boundary_sources_on_plane(plane,1e-6);
+ let mut sources =
+ self.tabs[i].scene.boundary_sources_on_plane(plane, 1e-6);
sources.remove(&handle);
let command=crate::modules::draw::draw::hatchedit::HatcheditCommand::for_association(handle,name,scale,angle,plane,sources);
self.tabs[i].scene.deselect_all();
self.command_line.push_info(&command.prompt());
- self.tabs[i].active_cmd=Some(Box::new(command));
+ self.tabs[i].active_cmd = Some(Box::new(command));
}
return Task::none();
}
- if let HatchEditOperation::DrawOrderBoundary{above}=&operation {
- let references:Vec<_>=match self.tabs[i].scene.document.get_entity(handle) {
- Some(acadrust::EntityType::Hatch(h))=>h.paths.iter().flat_map(|p|p.boundary_handles.iter())
- .filter(|h|self.tabs[i].scene.document.get_entity(**h).is_some()).map(|h|format!("{:X}",h.value())).collect(),
- _=>Vec::new(),
- };
- self.tabs[i].active_cmd=None;
- if references.is_empty(){self.command_line.push_info("HATCHEDIT: no associated boundary objects.");return Task::none();}
- self.tabs[i].scene.deselect_all();self.tabs[i].scene.select_entity(handle,false);
- let command=format!("DRAWORDER {} {}",if *above{"ABOVE"}else{"UNDER"},references.join(" "));
- return self.dispatch_view(&command,i).unwrap_or_else(Task::none);
+ if let HatchEditOperation::DrawOrderBoundary { above } = &operation {
+ let references: Vec<_> =
+ match self.tabs[i].scene.document.get_entity(handle) {
+ Some(acadrust::EntityType::Hatch(h)) => h
+ .paths
+ .iter()
+ .flat_map(|p| p.boundary_handles.iter())
+ .filter(|h| {
+ self.tabs[i].scene.document.get_entity(**h).is_some()
+ })
+ .map(|h| format!("{:X}", h.value()))
+ .collect(),
+ _ => Vec::new(),
+ };
+ self.tabs[i].active_cmd = None;
+ if references.is_empty() {
+ self.command_line
+ .push_info("HATCHEDIT: no associated boundary objects.");
+ return Task::none();
+ }
+ self.tabs[i].scene.deselect_all();
+ self.tabs[i].scene.select_entity(handle, false);
+ let command = format!(
+ "DRAWORDER {} {}",
+ if *above { "ABOVE" } else { "UNDER" },
+ references.join(" ")
+ );
+ return self.dispatch_view(&command, i).unwrap_or_else(Task::none);
}
if matches!(
&operation,
@@ -5354,20 +5916,43 @@ impl OpenCADStudio {
}
self.push_undo_snapshot(i, "HATCHEDIT");
match operation {
- HatchEditOperation::Appearance { color, layer, transparency } => {
- let layer=layer.map(|name|if name=="."{self.tabs[i].active_layer.clone()}else{name});
- if layer.as_ref().is_some_and(|name|self.tabs[i].scene.document.layers.get(name).is_none()) {
+ HatchEditOperation::Appearance {
+ color,
+ layer,
+ transparency,
+ } => {
+ let layer = layer.map(|name| {
+ if name == "." {
+ self.tabs[i].active_layer.clone()
+ } else {
+ name
+ }
+ });
+ if layer.as_ref().is_some_and(|name| {
+ self.tabs[i].scene.document.layers.get(name).is_none()
+ }) {
self.discard_last_undo_entry(i);
self.command_line.push_error("HATCHEDIT: layer not found.");
return Task::none();
}
- if let Some(entity)=self.tabs[i].scene.document.get_entity_mut(handle) {
- let common=entity.common_mut();
- if let Some(value)=color {common.color=value;common.color_name=None;common.color_book_handle=None;}
- if let Some(value)=layer {common.layer=value;}
- if let Some(value)=transparency {common.transparency=value;}
+ if let Some(entity) = self.tabs[i].scene.document.get_entity_mut(handle)
+ {
+ let common = entity.common_mut();
+ if let Some(value) = color {
+ common.color = value;
+ common.color_name = None;
+ common.color_book_handle = None;
+ }
+ if let Some(value) = layer {
+ common.layer = value;
+ }
+ if let Some(value) = transparency {
+ common.transparency = value;
+ }
}
- self.tabs[i].scene.bump_entities(&[(handle,crate::scene::ChangeKind::Modified)]);
+ self.tabs[i]
+ .scene
+ .bump_entities(&[(handle, crate::scene::ChangeKind::Modified)]);
self.refresh_properties();
}
HatchEditOperation::Update {
@@ -5381,7 +5966,8 @@ impl OpenCADStudio {
if let Some((x, y)) = origin {
if !self.tabs[i].scene.document.set_hatch_origin([x, y]) {
self.discard_last_undo_entry(i);
- self.command_line.push_error("HATCHEDIT: cannot store default origin.");
+ self.command_line
+ .push_error("HATCHEDIT: cannot store default origin.");
return Task::none();
}
}
@@ -5393,7 +5979,10 @@ impl OpenCADStudio {
if let Some(entry) =
crate::scene::model::hatch_patterns::find(&name)
{
- let mut pattern = crate::scene::model::hatch_patterns::build_dxf_pattern(entry);
+ let mut pattern =
+ crate::scene::model::hatch_patterns::build_dxf_pattern(
+ entry,
+ );
crate::entities::hatch::scale_pattern_geometry(
&mut pattern,
scale.max(1.0e-6) as f64,
@@ -5403,7 +5992,11 @@ impl OpenCADStudio {
(angle as f64).to_radians(),
);
let origin = hatch.pattern_origin();
- crate::entities::hatch::translate_pattern_geometry(&mut pattern, origin.x, origin.y);
+ crate::entities::hatch::translate_pattern_geometry(
+ &mut pattern,
+ origin.x,
+ origin.y,
+ );
hatch.pattern = pattern;
hatch.is_solid = matches!(
entry.gpu,
@@ -5457,10 +6050,9 @@ impl OpenCADStudio {
}
}
}
- self.tabs[i].scene.bump_entities(&[(
- handle,
- crate::scene::ChangeKind::Modified,
- )]);
+ self.tabs[i]
+ .scene
+ .bump_entities(&[(handle, crate::scene::ChangeKind::Modified)]);
}
HatchEditOperation::AddBoundaries(handles) => {
self.tabs[i]
@@ -5473,12 +6065,25 @@ impl OpenCADStudio {
.edit_hatch_boundary_handles(handle, &handles, false);
}
HatchEditOperation::AssociatePaths(paths) => {
- if paths.is_empty()||paths.iter().any(|path|path.boundary_handles.is_empty()||path.boundary_handles.iter().any(|source|self.tabs[i].scene.document.get_entity(*source).is_none())) {
+ if paths.is_empty()
+ || paths.iter().any(|path| {
+ path.boundary_handles.is_empty()
+ || path.boundary_handles.iter().any(|source| {
+ self.tabs[i]
+ .scene
+ .document
+ .get_entity(*source)
+ .is_none()
+ })
+ })
+ {
self.discard_last_undo_entry(i);
- self.command_line.push_error("HATCHEDIT: associated boundary is no longer available.");
+ self.command_line.push_error(
+ "HATCHEDIT: associated boundary is no longer available.",
+ );
return Task::none();
}
- self.tabs[i].scene.replace_hatch_association(handle,paths);
+ self.tabs[i].scene.replace_hatch_association(handle, paths);
}
HatchEditOperation::RecreateBoundary { associate, region } => {
let source = self.tabs[i].scene.document.get_entity(handle).cloned();
@@ -5493,33 +6098,79 @@ impl OpenCADStudio {
glam::DVec3::from_array(storage.y_axis),
);
let (entities, path_groups) = if region {
- let loops = source.paths.iter().map(|path| {
- path.edges.iter().map(crate::entities::hatch::edge_curve).collect::>>()
- }).collect::>>();
- let Some(loops) = loops.filter(|loops| !loops.is_empty() && loops.iter().all(|ring| !ring.is_empty())) else {
+ let loops = source
+ .paths
+ .iter()
+ .map(|path| {
+ path.edges
+ .iter()
+ .map(crate::entities::hatch::edge_curve)
+ .collect::>>()
+ })
+ .collect::>>();
+ let Some(loops) = loops.filter(|loops| {
+ !loops.is_empty()
+ && loops.iter().all(|ring| !ring.is_empty())
+ }) else {
self.discard_last_undo_entry(i);
- self.command_line.push_error("HATCHEDIT: boundary cannot form a region.");
+ self.command_line.push_error(
+ "HATCHEDIT: boundary cannot form a region.",
+ );
return Task::none();
};
- let contained = loops.iter().enumerate().map(|(inner, ring)| {
- let seed = ring[0].point_at(0.0);
- loops.iter().enumerate().map(|(outer, boundary)| {
- inner != outer && cadkernel::geom2d::contains(boundary, seed, cadkernel::geom2d::Tolerance::new(1e-6))
- }).collect::>()
- }).collect::>();
- let depths = contained.iter().map(|row| row.iter().filter(|inside| **inside).count()).collect::>();
- let groups = depths.iter().enumerate().filter(|(_, depth)| **depth % 2 == 0).map(|(outer, depth)| {
- let mut indices = vec![outer];
- indices.extend((0..loops.len()).filter(|inner| depths[*inner] == *depth + 1 && contained[*inner][outer]));
- indices
- }).collect::>();
- let entities = groups.iter().map(|indices| {
- let profiles = indices.iter().map(|index| loops[*index].clone()).collect::>();
- crate::scene::model::presspull_model::region_from_loops(&profiles, plane)
- }).collect::>>();
+ let contained = loops
+ .iter()
+ .enumerate()
+ .map(|(inner, ring)| {
+ let seed = ring[0].point_at(0.0);
+ loops
+ .iter()
+ .enumerate()
+ .map(|(outer, boundary)| {
+ inner != outer
+ && cadkernel::geom2d::contains(
+ boundary,
+ seed,
+ cadkernel::geom2d::Tolerance::new(1e-6),
+ )
+ })
+ .collect::>()
+ })
+ .collect::>();
+ let depths = contained
+ .iter()
+ .map(|row| row.iter().filter(|inside| **inside).count())
+ .collect::>();
+ let groups = depths
+ .iter()
+ .enumerate()
+ .filter(|(_, depth)| **depth % 2 == 0)
+ .map(|(outer, depth)| {
+ let mut indices = vec![outer];
+ indices.extend((0..loops.len()).filter(|inner| {
+ depths[*inner] == *depth + 1
+ && contained[*inner][outer]
+ }));
+ indices
+ })
+ .collect::>();
+ let entities = groups
+ .iter()
+ .map(|indices| {
+ let profiles = indices
+ .iter()
+ .map(|index| loops[*index].clone())
+ .collect::>();
+ crate::scene::model::presspull_model::region_from_loops(
+ &profiles, plane,
+ )
+ })
+ .collect::>>();
let Some(entities) = entities else {
self.discard_last_undo_entry(i);
- self.command_line.push_error("HATCHEDIT: boundary cannot form a region.");
+ self.command_line.push_error(
+ "HATCHEDIT: boundary cannot form a region.",
+ );
return Task::none();
};
(entities, groups)
@@ -5540,30 +6191,39 @@ impl OpenCADStudio {
);
return Task::none();
}
- let groups = (0..entities.len()).map(|index| vec![index]).collect();
+ let groups =
+ (0..entities.len()).map(|index| vec![index]).collect();
(entities, groups)
};
let mut path_handles = vec![None; source.paths.len()];
for (entity, paths) in entities.into_iter().zip(path_groups) {
if let Some(boundary) = self.commit_entity_handle(entity) {
- for path in paths { if let Some(slot) = path_handles.get_mut(path) { *slot = Some(boundary); } }
- }
- }
- if associate { if let Some(acadrust::EntityType::Hatch(hatch)) =
- self.tabs[i].scene.document.get_entity_mut(handle)
- {
- for (path, boundary) in hatch.paths.iter_mut().zip(path_handles.iter().copied()) {
- if let Some(boundary) = boundary {
- path.boundary_handles = vec![boundary];
- path.flags.set_external(true);
+ for path in paths {
+ if let Some(slot) = path_handles.get_mut(path) {
+ *slot = Some(boundary);
+ }
}
}
- hatch.is_associative = path_handles.iter().all(Option::is_some);
- } }
- self.tabs[i].scene.bump_entities(&[(
- handle,
- crate::scene::ChangeKind::Modified,
- )]);
+ }
+ if associate {
+ if let Some(acadrust::EntityType::Hatch(hatch)) =
+ self.tabs[i].scene.document.get_entity_mut(handle)
+ {
+ for (path, boundary) in
+ hatch.paths.iter_mut().zip(path_handles.iter().copied())
+ {
+ if let Some(boundary) = boundary {
+ path.boundary_handles = vec![boundary];
+ path.flags.set_external(true);
+ }
+ }
+ hatch.is_associative =
+ path_handles.iter().all(Option::is_some);
+ }
+ }
+ self.tabs[i]
+ .scene
+ .bump_entities(&[(handle, crate::scene::ChangeKind::Modified)]);
}
}
HatchEditOperation::Separate => {
@@ -5589,7 +6249,7 @@ impl OpenCADStudio {
}
HatchEditOperation::DrawOrderFront
| HatchEditOperation::DrawOrderBack
- | HatchEditOperation::DrawOrderBoundary {..}
+ | HatchEditOperation::DrawOrderBoundary { .. }
| HatchEditOperation::BeginAssociate => unreachable!(),
}
self.tabs[i].dirty = true;
@@ -5689,10 +6349,17 @@ impl OpenCADStudio {
let active = self.tabs[i].active_cmd.take();
self.undo_active_tab();
self.tabs[i].active_cmd = active;
- if self.tabs[i].active_cmd.as_ref().is_some_and(|command| command.name() == "PEDIT") {
- let entities: Vec<_> = self.tabs[i].scene.document.entities().cloned().collect();
+ if self.tabs[i]
+ .active_cmd
+ .as_ref()
+ .is_some_and(|command| command.name() == "PEDIT")
+ {
+ let entities: Vec<_> =
+ self.tabs[i].scene.document.entities().cloned().collect();
if let Some(command) = self.tabs[i].active_cmd.as_mut() {
- for entity in entities { command.inject_picked_entity(entity); }
+ for entity in entities {
+ command.inject_picked_entity(entity);
+ }
}
}
let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
@@ -5721,8 +6388,9 @@ impl OpenCADStudio {
)
});
if handles.is_empty() {
- self.command_line
- .push_error(crate::t!("DIMEDIT: no editable dimensions were selected.").as_ref());
+ self.command_line.push_error(
+ crate::t!("DIMEDIT: no editable dimensions were selected.").as_ref(),
+ );
} else {
self.push_undo_snapshot(i, "DIMEDIT");
for handle in &handles {
@@ -5818,7 +6486,8 @@ impl OpenCADStudio {
}
if updated {
self.tabs[i].dirty = true;
- self.command_line.push_output(crate::t!("DDEDIT: text updated.").as_ref());
+ self.command_line
+ .push_output(crate::t!("DDEDIT: text updated.").as_ref());
} else {
self.discard_last_undo_entry(i);
self.command_line
@@ -5863,11 +6532,7 @@ impl OpenCADStudio {
/// this drawing doesn't already have. Each recreated record gets a fresh
/// handle from the target document so it can't collide with an existing
/// one. No-op for same-document pastes (the records already exist). (#129)
- pub(super) fn merge_dependencies(
- &mut self,
- i: usize,
- deps: &crate::app::ClipboardDeps,
- ) {
+ pub(super) fn merge_dependencies(&mut self, i: usize, deps: &crate::app::ClipboardDeps) {
use acadrust::TableEntry;
if deps.is_empty() {
return;
@@ -5992,7 +6657,7 @@ impl OpenCADStudio {
_ => glam::DVec3::ZERO,
};
self.merge_clipboard_ext_objects(i, &by_index, annotation_delta);
- // Source handles stored in the clipboard map one-to-one to the freshly
+ // Source handles stored in the clipboard map one-to-one to the freshly
// pasted handles. Use that map to reconnect LEADER -> copied annotation.
let mut handle_map = rustc_hash::FxHashMap::default();
@@ -6042,7 +6707,9 @@ impl OpenCADStudio {
self.tabs[i].scene.recreate_groups(groups, &handle_map);
}
// Constraints wholly within the pasted selection follow it.
- self.tabs[i].scene.duplicate_sketch_constraints_for(&handle_map);
+ self.tabs[i]
+ .scene
+ .duplicate_parametric_constraints_for(&handle_map);
// Incremental: `add_entity` already tessellated every pasted top-level
// solid, and existing document solids are still cached — so only newly
// introduced block-definition solids need building. The full rebuild
@@ -6342,16 +7009,10 @@ fn wire_segments(
for model in models {
for run in model.points.split(|point| !point[0].is_finite()) {
for pair in run.windows(2) {
- let first = glam::DVec3::new(
- pair[0][0] as f64,
- pair[0][1] as f64,
- pair[0][2] as f64,
- );
- let second = glam::DVec3::new(
- pair[1][0] as f64,
- pair[1][1] as f64,
- pair[1][2] as f64,
- );
+ let first =
+ glam::DVec3::new(pair[0][0] as f64, pair[0][1] as f64, pair[0][2] as f64);
+ let second =
+ glam::DVec3::new(pair[1][0] as f64, pair[1][1] as f64, pair[1][2] as f64);
if first.is_finite()
&& second.is_finite()
&& first.distance_squared(second) > 1.0e-18
@@ -6373,7 +7034,10 @@ fn segment_intersection_xy(
[second.0.to_array(), second.1.to_array()],
0.25,
)?;
- Some((glam::DVec3::from_array(gap[0]), glam::DVec3::from_array(gap[1])))
+ Some((
+ glam::DVec3::from_array(gap[0]),
+ glam::DVec3::from_array(gap[1]),
+ ))
}
fn break_object_handle(document: &acadrust::CadDocument, dimension: Handle) -> Option {
@@ -6395,7 +7059,10 @@ fn remove_dimension_break_data(document: &mut acadrust::CadDocument, dimension:
.filter_map(|(handle, object)| match object {
acadrust::objects::ObjectType::DataObject(object) => match &object.data {
acadrust::objects::DataObjectData::BreakData(data)
- if data.dimension_reference == dimension => Some(*handle),
+ if data.dimension_reference == dimension =>
+ {
+ Some(*handle)
+ }
_ => None,
},
_ => None,
@@ -6475,9 +7142,7 @@ fn write_dimension_break_data(
document
.objects
.insert(object_handle, ObjectType::DataObject(object));
- if let Some(ObjectType::Dictionary(dictionary)) =
- document.objects.get_mut(&dictionary_handle)
- {
+ if let Some(ObjectType::Dictionary(dictionary)) = document.objects.get_mut(&dictionary_handle) {
dictionary
.entries
.retain(|(name, _)| !name.eq_ignore_ascii_case("ACAD_BREAKDATA"));
@@ -6535,8 +7200,11 @@ fn apply_dimbreak(
.filter(|handle| remove_dimension_break_data(&mut scene.document, *handle))
.collect();
return DimBreakResult {
- message: crate::tf!("DIMBREAK: removed breaks from {} dimension(s).", changed.len())
- .into_owned(),
+ message: crate::tf!(
+ "DIMBREAK: removed breaks from {} dimension(s).",
+ changed.len()
+ )
+ .into_owned(),
changed,
};
}
@@ -6604,11 +7272,14 @@ fn apply_dimbreak(
}
}
let start = references.len() as i32;
- references.extend(intersections.into_iter().enumerate().map(
- |(index, points)| {
- break_reference(start + index as i32, 1, points.0, points.1)
- },
- ));
+ references.extend(
+ intersections
+ .into_iter()
+ .enumerate()
+ .map(|(index, points)| {
+ break_reference(start + index as i32, 1, points.0, points.1)
+ }),
+ );
}
DimensionBreakOperation::Remove => {}
}
@@ -6645,16 +7316,28 @@ fn apply_dimspace(
use acadrust::entities::Dimension;
let (axis, normal, definition, auto_spacing) = match scene.document.get_entity(base_h) {
Some(acadrust::EntityType::Dimension(dimension @ Dimension::Linear(d))) => {
- let spacing = dimension_auto_spacing(&scene.document, dimension, scene.creation_annotation_multiplier());
+ let spacing = dimension_auto_spacing(
+ &scene.document,
+ dimension,
+ scene.creation_annotation_multiplier(),
+ );
(
[d.rotation.cos(), d.rotation.sin(), 0.0],
[d.base.normal.x, d.base.normal.y, d.base.normal.z],
- [d.definition_point.x, d.definition_point.y, d.definition_point.z],
+ [
+ d.definition_point.x,
+ d.definition_point.y,
+ d.definition_point.z,
+ ],
spacing,
)
}
Some(acadrust::EntityType::Dimension(dimension @ Dimension::Aligned(d))) => {
- let spacing = dimension_auto_spacing(&scene.document, dimension, scene.creation_annotation_multiplier());
+ let spacing = dimension_auto_spacing(
+ &scene.document,
+ dimension,
+ scene.creation_annotation_multiplier(),
+ );
(
[
d.second_point.x - d.first_point.x,
@@ -6662,7 +7345,11 @@ fn apply_dimspace(
d.second_point.z - d.first_point.z,
],
[d.base.normal.x, d.base.normal.y, d.base.normal.z],
- [d.definition_point.x, d.definition_point.y, d.definition_point.z],
+ [
+ d.definition_point.x,
+ d.definition_point.y,
+ d.definition_point.z,
+ ],
spacing,
)
}
@@ -6679,11 +7366,8 @@ fn apply_dimspace(
let mut changed = false;
if let Some(acadrust::EntityType::Dimension(dim)) = scene.document.get_entity_mut(h) {
let slide = |p: &mut acadrust::types::Vector3| {
- let point = cadkernel::space::move_to_dimension_spacing(
- [p.x, p.y, p.z],
- frame,
- target,
- );
+ let point =
+ cadkernel::space::move_to_dimension_spacing([p.x, p.y, p.z], frame, target);
*p = acadrust::types::Vector3::new(point[0], point[1], point[2]);
};
match dim {
@@ -6721,8 +7405,14 @@ fn dimension_auto_spacing(
let style = document
.dim_styles
.iter()
- .find(|style| style.name.eq_ignore_ascii_case(&dimension.base().style_name))
- .map(|style| crate::entities::dimension::resolved_dimension_style(style, dimension, document));
+ .find(|style| {
+ style
+ .name
+ .eq_ignore_ascii_case(&dimension.base().style_name)
+ })
+ .map(|style| {
+ crate::entities::dimension::resolved_dimension_style(style, dimension, document)
+ });
style
.map(|style| {
let scale = if style.dimscale > 1.0e-9 {
@@ -6752,9 +7442,7 @@ fn apply_mleader_align(
});
let mut changed = Vec::new();
for &handle in handles {
- if let Some(acadrust::EntityType::MultiLeader(ml)) =
- scene.document.get_entity_mut(handle)
- {
+ if let Some(acadrust::EntityType::MultiLeader(ml)) = scene.document.get_entity_mut(handle) {
let old = ml.context.content_base_point;
let projected = closest_point(&line, [old.x, old.y]).point;
let new_x = projected[0];
@@ -6791,9 +7479,7 @@ fn compatible_mleader_collect_handles(
if scene.is_layer_locked(*handle) {
return None;
}
- let acadrust::EntityType::MultiLeader(leader) =
- scene.document.get_entity(*handle)?
- else {
+ let acadrust::EntityType::MultiLeader(leader) = scene.document.get_entity(*handle)? else {
return None;
};
(leader.content_type == acadrust::entities::LeaderContentType::Block)
@@ -6831,8 +7517,7 @@ fn apply_mleader_collect(
}
let px = point.x;
let py = point.y;
- let Some(acadrust::EntityType::MultiLeader(base)) =
- scene.document.get_entity(handles[0])
+ let Some(acadrust::EntityType::MultiLeader(base)) = scene.document.get_entity(handles[0])
else {
return false;
};
@@ -7321,44 +8006,104 @@ mod command_replacement_tests {
let mut app = OpenCADStudio::new_for_test();
let _ = app.automation_op(r#"{"op":"new"}"#);
let tab = app.active_tab;
- let handle = app.tabs[tab].scene.add_entity(acadrust::EntityType::Line(
- Line::from_points(Vector3::ZERO, Vector3::new(1.0, 0.0, 0.0)),
- ));
- let owner = app.tabs[tab].scene.document.get_entity(handle).unwrap().common().owner_handle;
+ let handle = app.tabs[tab]
+ .scene
+ .add_entity(acadrust::EntityType::Line(Line::from_points(
+ Vector3::ZERO,
+ Vector3::new(1.0, 0.0, 0.0),
+ )));
+ let owner = app.tabs[tab]
+ .scene
+ .document
+ .get_entity(handle)
+ .unwrap()
+ .common()
+ .owner_handle;
- let kept = app.replace_command_entity(tab, handle, vec![acadrust::EntityType::Line(
- Line::from_points(Vector3::ZERO, Vector3::new(3.0, 0.0, 0.0)),
- )]);
+ let kept = app.replace_command_entity(
+ tab,
+ handle,
+ vec![acadrust::EntityType::Line(Line::from_points(
+ Vector3::ZERO,
+ Vector3::new(3.0, 0.0, 0.0),
+ ))],
+ );
assert_eq!(kept, vec![handle]);
let edited = app.tabs[tab].scene.document.get_entity(handle).unwrap();
assert_eq!(edited.common().owner_handle, owner);
assert!(matches!(edited, acadrust::EntityType::Line(line) if line.end.x == 3.0));
- let allocated = app.replace_command_entity(tab, handle,
- vec![acadrust::EntityType::Circle(Circle::from_coords(0.0, 0.0, 0.0, 2.0))]);
+ let allocated = app.replace_command_entity(
+ tab,
+ handle,
+ vec![acadrust::EntityType::Circle(Circle::from_coords(
+ 0.0, 0.0, 0.0, 2.0,
+ ))],
+ );
assert_eq!(allocated.len(), 1);
assert_ne!(allocated[0], handle);
assert!(app.tabs[tab].scene.document.get_entity(handle).is_none());
}
+
+ #[test]
+ fn live_geometry_updates_keep_document_identity_and_display_properties() {
+ let mut app = OpenCADStudio::new_for_test();
+ let _ = app.automation_op(r#"{"op":"new"}"#);
+ let tab = app.active_tab;
+ let handle = app.tabs[tab]
+ .scene
+ .add_entity(acadrust::EntityType::Line(Line::from_points(
+ Vector3::ZERO,
+ Vector3::new(1.0, 0.0, 0.0),
+ )));
+ let expected = {
+ let entity = app.tabs[tab].scene.document.get_entity_mut(handle).unwrap();
+ entity.common_mut().layer = "LIVE".to_string();
+ entity.common_mut().invisible = true;
+ entity.common_mut().linetype_scale = 2.5;
+ entity.common().clone()
+ };
+
+ let _ = app.apply_cmd_result(CmdResult::UpdateLiveEntity {
+ handle,
+ entity: acadrust::EntityType::Line(Line::from_points(
+ Vector3::ZERO,
+ Vector3::new(4.0, 0.0, 0.0),
+ )),
+ finish: false,
+ });
+
+ let updated = app.tabs[tab].scene.document.get_entity(handle).unwrap();
+ assert_eq!(updated.common().handle, expected.handle);
+ assert_eq!(updated.common().owner_handle, expected.owner_handle);
+ assert_eq!(updated.common().layer, expected.layer);
+ assert_eq!(updated.common().invisible, expected.invisible);
+ assert_eq!(updated.common().linetype_scale, expected.linetype_scale);
+ assert!(matches!(updated, acadrust::EntityType::Line(line) if line.end.x == 4.0));
+ }
}
#[cfg(test)]
-mod sketch_constraint_undo_tests {
+mod parametric_constraint_undo_tests {
use super::*;
- use crate::scene::sketch_constraints::{ConstraintKind, SketchRef, SketchScope};
+ use crate::scene::parametric_constraints::{ConstraintKind, ParametricRef, ParametricScope};
fn add_line(app: &mut OpenCADStudio, x1: f64, y1: f64, x2: f64, y2: f64) -> Handle {
app.tabs[app.active_tab]
.scene
- .add_entity(acadrust::EntityType::Line(acadrust::entities::Line::from_points(
- acadrust::types::Vector3::new(x1, y1, 0.0),
- acadrust::types::Vector3::new(x2, y2, 0.0),
- )))
+ .add_entity(acadrust::EntityType::Line(
+ acadrust::entities::Line::from_points(
+ acadrust::types::Vector3::new(x1, y1, 0.0),
+ acadrust::types::Vector3::new(x2, y2, 0.0),
+ ),
+ ))
}
fn line_angle_deg(app: &OpenCADStudio, handle: Handle) -> f64 {
match app.tabs[app.active_tab].scene.document.get_entity(handle) {
- Some(acadrust::EntityType::Line(l)) => (l.end.y - l.start.y).atan2(l.end.x - l.start.x).to_degrees(),
+ Some(acadrust::EntityType::Line(l)) => (l.end.y - l.start.y)
+ .atan2(l.end.x - l.start.x)
+ .to_degrees(),
other => panic!("expected a Line, got {other:?}"),
}
}
@@ -7372,15 +8117,23 @@ mod sketch_constraint_undo_tests {
let original_angle = line_angle_deg(&app, line);
assert!((original_angle - 16.699244).abs() < 1e-3);
- let _ = app.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Horizontal,
- refs: vec![SketchRef::whole(line)],
+ refs: vec![ParametricRef::whole(line)],
driving_param: None,
label: "Horizontal constraint",
});
- assert!(line_angle_deg(&app, line).abs() < 1e-6, "constraint should have leveled the line");
+ assert!(
+ line_angle_deg(&app, line).abs() < 1e-6,
+ "constraint should have leveled the line"
+ );
assert_eq!(
- app.tabs[app.active_tab].scene.sketch_constraint_set(SketchScope::ModelSpace).unwrap().constraints.len(),
+ app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap()
+ .constraints
+ .len(),
1
);
@@ -7388,7 +8141,7 @@ mod sketch_constraint_undo_tests {
assert_eq!(
app.tabs[app.active_tab]
.scene
- .sketch_constraint_set(SketchScope::ModelSpace)
+ .parametric_constraint_set(ParametricScope::ModelSpace)
.map(|s| s.constraints.len())
.unwrap_or(0),
0,
@@ -7400,15 +8153,23 @@ mod sketch_constraint_undo_tests {
);
app.redo_steps(1);
- assert!(line_angle_deg(&app, line).abs() < 1e-6, "redo should re-level the line");
+ assert!(
+ line_angle_deg(&app, line).abs() < 1e-6,
+ "redo should re-level the line"
+ );
assert_eq!(
- app.tabs[app.active_tab].scene.sketch_constraint_set(SketchScope::ModelSpace).unwrap().constraints.len(),
+ app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap()
+ .constraints
+ .len(),
1,
"redo should restore the constraint record"
);
}
- /// Drawing commands must not create sketch constraints implicitly.
+ /// Drawing commands must not create parametric constraints implicitly.
#[test]
fn drawing_a_line_onto_an_existing_endpoint_does_not_add_a_constraint() {
let mut app = OpenCADStudio::new_for_test();
@@ -7419,13 +8180,15 @@ mod sketch_constraint_undo_tests {
acadrust::types::Vector3::new(5.0, 0.0, 0.0), // exactly on `existing`'s end point
acadrust::types::Vector3::new(10.0, 0.0, 0.0),
));
- app.tabs[app.active_tab].active_cmd = Some(Box::new(crate::modules::draw::draw::line::LineCommand::new()));
+ app.tabs[app.active_tab].active_cmd = Some(Box::new(
+ crate::modules::draw::draw::line::LineCommand::new(),
+ ));
let _ = app.apply_cmd_result(CmdResult::CommitEntity(new_line));
assert_eq!(
app.tabs[app.active_tab]
.scene
- .sketch_constraint_set(SketchScope::ModelSpace)
+ .parametric_constraint_set(ParametricScope::ModelSpace)
.map(|s| s.constraints.len())
.unwrap_or(0),
0,
@@ -7435,36 +8198,99 @@ mod sketch_constraint_undo_tests {
/// Conflict resolution removes one flagged constraint and is undoable.
#[test]
- fn resolve_one_sketch_conflict_removes_a_flagged_constraint_and_is_undoable() {
+ fn resolve_one_parametric_conflict_removes_a_flagged_constraint_and_is_undoable() {
let mut app = OpenCADStudio::new_for_test();
let _ = app.automation_op(r#"{"op":"new"}"#);
let line = add_line(&mut app, 0.0, 0.0, 10.0, 3.0);
- let _ = app.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Horizontal,
- refs: vec![SketchRef::whole(line)],
+ refs: vec![ParametricRef::whole(line)],
driving_param: None,
label: "Horizontal constraint",
});
- let _ = app.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Horizontal,
- refs: vec![SketchRef::whole(line)],
+ refs: vec![ParametricRef::whole(line)],
driving_param: None,
label: "Horizontal constraint",
}); // exact duplicate — flagged redundant once bumped
- app.tabs[app.active_tab].scene.bump_entities(&[(line, crate::scene::ChangeKind::Modified)]);
+ app.tabs[app.active_tab]
+ .scene
+ .bump_entities(&[(line, crate::scene::ChangeKind::Modified)]);
- let set = app.tabs[app.active_tab].scene.sketch_constraint_set(SketchScope::ModelSpace).unwrap();
+ let set = app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap();
assert_eq!(set.constraints.len(), 2);
- assert_eq!(set.conflicts.len(), 1, "the duplicate should have been flagged");
+ assert_eq!(
+ set.conflicts.len(),
+ 1,
+ "the duplicate should have been flagged"
+ );
- app.resolve_one_sketch_conflict();
- let set = app.tabs[app.active_tab].scene.sketch_constraint_set(SketchScope::ModelSpace).unwrap();
- assert_eq!(set.constraints.len(), 1, "one of the two duplicates should have been removed");
+ app.resolve_one_parametric_conflict();
+ let set = app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap();
+ assert_eq!(
+ set.constraints.len(),
+ 1,
+ "one of the two duplicates should have been removed"
+ );
app.undo_steps(1);
- let set = app.tabs[app.active_tab].scene.sketch_constraint_set(SketchScope::ModelSpace).unwrap();
- assert_eq!(set.constraints.len(), 2, "undo should restore the removed constraint");
+ let set = app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap();
+ assert_eq!(
+ set.constraints.len(),
+ 2,
+ "undo should restore the removed constraint"
+ );
+ }
+
+ #[test]
+ fn deleting_one_parametric_constraint_is_undoable() {
+ let mut app = OpenCADStudio::new_for_test();
+ let _ = app.automation_op(r#"{"op":"new"}"#);
+ let line = add_line(&mut app, 0.0, 0.0, 10.0, 3.0);
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
+ kind: ConstraintKind::Horizontal,
+ refs: vec![ParametricRef::whole(line)],
+ driving_param: None,
+ label: "Horizontal constraint",
+ });
+ let id = app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap()
+ .constraints[0]
+ .id;
+ app.tabs[app.active_tab].scene.selected_constraint = Some(id);
+
+ app.delete_parametric_constraint(id);
+ assert!(app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap()
+ .constraints
+ .is_empty());
+ assert_eq!(app.tabs[app.active_tab].scene.selected_constraint, None);
+
+ app.undo_steps(1);
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .unwrap()
+ .constraints
+ .len(),
+ 1
+ );
}
/// `named_parameters_design.md` stage 4: applying the PARAMETERS editor's
@@ -7480,24 +8306,38 @@ mod sketch_constraint_undo_tests {
// The constraint is added *before* the parameter exists -- allowed,
// same as `ParameterTable::set`'s own forward-reference tolerance;
// it just doesn't resolve to anything until the parameter is defined.
- let _ = app.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Distance,
- refs: vec![SketchRef::point(line, 0), SketchRef::point(line, 1)],
- driving_param: Some(crate::scene::named_parameters::DrivingValue::Named("target_len".to_string())),
+ refs: vec![ParametricRef::point(line, 0), ParametricRef::point(line, 1)],
+ driving_param: Some(crate::scene::named_parameters::DrivingValue::Named(
+ "target_len".to_string(),
+ )),
label: "Distance constraint",
});
app.named_parameter_editor_rows =
- vec![crate::ui::window::named_parameters::ParamEditorRow { name: "target_len".to_string(), formula: "8".to_string() }];
+ vec![crate::ui::window::named_parameters::ParamEditorRow {
+ name: "target_len".to_string(),
+ formula: "8".to_string(),
+ }];
app.apply_named_parameter_editor_rows();
- assert_eq!(app.tabs[app.active_tab].scene.named_parameters().resolve("target_len"), Ok(8.0));
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .resolve("target_len"),
+ Ok(8.0)
+ );
let (start, end) = match app.tabs[app.active_tab].scene.document.get_entity(line) {
Some(acadrust::EntityType::Line(l)) => (l.start, l.end),
other => panic!("expected a Line, got {other:?}"),
};
let len = ((end.x - start.x).powi(2) + (end.y - start.y).powi(2)).sqrt();
- assert!((len - 8.0).abs() < 1e-6, "length should track the applied parameter, got {len}");
+ assert!(
+ (len - 8.0).abs() < 1e-6,
+ "length should track the applied parameter, got {len}"
+ );
// Redefining the parameter and re-applying should ripple again.
app.named_parameter_editor_rows[0].formula = "3".to_string();
@@ -7507,10 +8347,19 @@ mod sketch_constraint_undo_tests {
other => panic!("expected a Line, got {other:?}"),
};
let len = ((end.x - start.x).powi(2) + (end.y - start.y).powi(2)).sqrt();
- assert!((len - 3.0).abs() < 1e-6, "length should track the redefined parameter, got {len}");
+ assert!(
+ (len - 3.0).abs() < 1e-6,
+ "length should track the redefined parameter, got {len}"
+ );
app.undo_steps(1);
- assert_eq!(app.tabs[app.active_tab].scene.named_parameters().resolve("target_len"), Ok(8.0));
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .resolve("target_len"),
+ Ok(8.0)
+ );
let length_after_undo = match app.tabs[app.active_tab].scene.document.get_entity(line) {
Some(acadrust::EntityType::Line(line)) => line.length(),
other => panic!("expected a Line, got {other:?}"),
@@ -7518,7 +8367,47 @@ mod sketch_constraint_undo_tests {
assert!((length_after_undo - 8.0).abs() < 1e-6);
app.redo_steps(1);
- assert_eq!(app.tabs[app.active_tab].scene.named_parameters().resolve("target_len"), Ok(3.0));
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .resolve("target_len"),
+ Ok(3.0)
+ );
+ }
+
+ /// The no-selection page must expose the active drawing's named parameters.
+ #[test]
+ fn no_selection_properties_exposes_named_parameters() {
+ let mut app = OpenCADStudio::new_for_test();
+ let _ = app.automation_op(r#"{"op":"new"}"#);
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters_mut()
+ .set("width", "12")
+ .unwrap();
+
+ app.refresh_properties();
+
+ assert!(app.tabs[app.active_tab]
+ .properties
+ .sections
+ .iter()
+ .flat_map(|section| §ion.props)
+ .any(|property| matches!(
+ &property.value,
+ crate::scene::model::object::PropValue::ParamRow { name, .. }
+ if name == "width"
+ )));
+ assert!(app.tabs[app.active_tab]
+ .properties
+ .sections
+ .iter()
+ .flat_map(|section| §ion.props)
+ .any(|property| matches!(
+ property.value,
+ crate::scene::model::object::PropValue::ParamsVisibilityToggle(_)
+ )));
}
/// End-to-end through the actual `Message` handlers a Properties-panel
@@ -7534,41 +8423,89 @@ mod sketch_constraint_undo_tests {
let mut app = OpenCADStudio::new_for_test();
let _ = app.automation_op(r#"{"op":"new"}"#);
let line = add_line(&mut app, 0.0, 0.0, 10.0, 0.0);
- let _ = app.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Distance,
- refs: vec![SketchRef::point(line, 0), SketchRef::point(line, 1)],
- driving_param: Some(crate::scene::named_parameters::DrivingValue::Named("len".to_string())),
+ refs: vec![ParametricRef::point(line, 0), ParametricRef::point(line, 1)],
+ driving_param: Some(crate::scene::named_parameters::DrivingValue::Named(
+ "len".to_string(),
+ )),
label: "Distance constraint",
});
// Add: the first row is auto-named "param1".
let _ = app.update(Message::PropParamAddNew);
- assert!(app.tabs[app.active_tab].scene.named_parameters().contains("param1"));
- let index = app.tabs[app.active_tab].scene.named_parameters().iter().position(|p| p.name == "param1").unwrap();
+ assert!(app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("param1"));
+ let index = app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .iter()
+ .position(|p| p.name == "param1")
+ .unwrap();
// Rename param1 -> len (commit-on-submit, not per keystroke: input
// alone must not touch the table yet).
- let _ = app.update(Message::PropParamInput { index, field: ParamField::Name, value: "len".to_string() });
- assert!(app.tabs[app.active_tab].scene.named_parameters().contains("param1"), "typing alone must not commit");
- let _ = app.update(Message::PropParamCommit { index, field: ParamField::Name });
- assert!(!app.tabs[app.active_tab].scene.named_parameters().contains("param1"));
- assert!(app.tabs[app.active_tab].scene.named_parameters().contains("len"));
+ let _ = app.update(Message::PropParamInput {
+ index,
+ field: ParamField::Name,
+ value: "len".to_string(),
+ });
+ assert!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("param1"),
+ "typing alone must not commit"
+ );
+ let _ = app.update(Message::PropParamCommit {
+ index,
+ field: ParamField::Name,
+ });
+ assert!(!app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("param1"));
+ assert!(app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("len"));
// Redefine its formula to 8 and confirm the Distance constraint
// (already referencing "len" by name, defined before this) re-solves.
- let _ = app.update(Message::PropParamInput { index, field: ParamField::Formula, value: "8".to_string() });
- let _ = app.update(Message::PropParamCommit { index, field: ParamField::Formula });
- assert_eq!(app.tabs[app.active_tab].scene.named_parameters().resolve("len"), Ok(8.0));
+ let _ = app.update(Message::PropParamInput {
+ index,
+ field: ParamField::Formula,
+ value: "8".to_string(),
+ });
+ let _ = app.update(Message::PropParamCommit {
+ index,
+ field: ParamField::Formula,
+ });
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .resolve("len"),
+ Ok(8.0)
+ );
let (start, end) = match app.tabs[app.active_tab].scene.document.get_entity(line) {
Some(acadrust::EntityType::Line(l)) => (l.start, l.end),
other => panic!("expected a Line, got {other:?}"),
};
let len = ((end.x - start.x).powi(2) + (end.y - start.y).powi(2)).sqrt();
- assert!((len - 8.0).abs() < 1e-6, "length should track the redefined parameter, got {len}");
+ assert!(
+ (len - 8.0).abs() < 1e-6,
+ "length should track the redefined parameter, got {len}"
+ );
// Delete: the row is gone from the table.
let _ = app.update(Message::PropParamDelete(index));
- assert!(!app.tabs[app.active_tab].scene.named_parameters().contains("len"));
+ assert!(!app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("len"));
}
/// A Constraints-section row click selects every entity the constraint
@@ -7580,18 +8517,24 @@ mod sketch_constraint_undo_tests {
let a = add_line(&mut app, 0.0, 0.0, 10.0, 0.0);
let b = add_line(&mut app, 0.0, 5.0, 10.0, 5.0);
let unrelated = add_line(&mut app, 20.0, 20.0, 30.0, 20.0);
- let _ = app.apply_cmd_result(CmdResult::AddSketchConstraint {
+ let _ = app.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Parallel,
- refs: vec![SketchRef::whole(a), SketchRef::whole(b)],
+ refs: vec![ParametricRef::whole(a), ParametricRef::whole(b)],
driving_param: None,
label: "Parallel constraint",
});
- app.tabs[app.active_tab].scene.select_entity(unrelated, true);
+ app.tabs[app.active_tab]
+ .scene
+ .select_entity(unrelated, true);
let _ = app.update(Message::PropConstraintLinkClick(vec![a, b]));
- let selected: std::collections::HashSet =
- app.tabs[app.active_tab].scene.selected_entities().into_iter().map(|(h, _)| h).collect();
+ let selected: std::collections::HashSet = app.tabs[app.active_tab]
+ .scene
+ .selected_entities()
+ .into_iter()
+ .map(|(h, _)| h)
+ .collect();
assert_eq!(selected, std::collections::HashSet::from([a, b]));
}
@@ -7606,15 +8549,36 @@ mod sketch_constraint_undo_tests {
let _ = app.automation_op(r#"{"op":"new"}"#);
app.named_parameter_editor_rows = vec![
- crate::ui::window::named_parameters::ParamEditorRow { name: "good".to_string(), formula: "10".to_string() },
- crate::ui::window::named_parameters::ParamEditorRow { name: "bad".to_string(), formula: "1 +".to_string() },
+ crate::ui::window::named_parameters::ParamEditorRow {
+ name: "good".to_string(),
+ formula: "10".to_string(),
+ },
+ crate::ui::window::named_parameters::ParamEditorRow {
+ name: "bad".to_string(),
+ formula: "1 +".to_string(),
+ },
];
app.apply_named_parameter_editor_rows();
- assert_eq!(app.tabs[app.active_tab].scene.named_parameters().resolve("good"), Ok(10.0));
- assert!(!app.tabs[app.active_tab].scene.named_parameters().contains("bad"), "a malformed row must not be added");
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .resolve("good"),
+ Ok(10.0)
+ );
assert!(
- app.command_line.history.iter().any(|e| e.kind == crate::ui::command_line::EntryKind::Error),
+ !app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("bad"),
+ "a malformed row must not be added"
+ );
+ assert!(
+ app.command_line
+ .history
+ .iter()
+ .any(|e| e.kind == crate::ui::command_line::EntryKind::Error),
"a malformed row must be reported as an error, not silently dropped"
);
}
@@ -7628,15 +8592,40 @@ mod sketch_constraint_undo_tests {
let _ = app.automation_op(r#"{"op":"new"}"#);
app.named_parameter_editor_rows = vec![
- crate::ui::window::named_parameters::ParamEditorRow { name: "x".to_string(), formula: "1".to_string() },
- crate::ui::window::named_parameters::ParamEditorRow { name: "x".to_string(), formula: "2".to_string() },
- crate::ui::window::named_parameters::ParamEditorRow { name: "y".to_string(), formula: "3".to_string() },
+ crate::ui::window::named_parameters::ParamEditorRow {
+ name: "x".to_string(),
+ formula: "1".to_string(),
+ },
+ crate::ui::window::named_parameters::ParamEditorRow {
+ name: "x".to_string(),
+ formula: "2".to_string(),
+ },
+ crate::ui::window::named_parameters::ParamEditorRow {
+ name: "y".to_string(),
+ formula: "3".to_string(),
+ },
];
app.apply_named_parameter_editor_rows();
- assert!(!app.tabs[app.active_tab].scene.named_parameters().contains("x"), "a duplicated name must not be added at all");
- assert_eq!(app.tabs[app.active_tab].scene.named_parameters().resolve("y"), Ok(3.0));
- assert!(app.command_line.history.iter().any(|e| e.kind == crate::ui::command_line::EntryKind::Error));
+ assert!(
+ !app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .contains("x"),
+ "a duplicated name must not be added at all"
+ );
+ assert_eq!(
+ app.tabs[app.active_tab]
+ .scene
+ .named_parameters()
+ .resolve("y"),
+ Ok(3.0)
+ );
+ assert!(app
+ .command_line
+ .history
+ .iter()
+ .any(|e| e.kind == crate::ui::command_line::EntryKind::Error));
}
/// Two endpoint picks resolve to a Coincident constraint.
@@ -7648,17 +8637,47 @@ mod sketch_constraint_undo_tests {
let b = add_line(&mut app, 20.0, 0.0, 20.0, 5.0); // deliberately far from `a`, so the two picks are unambiguous
let _ = app.apply_cmd_result(CmdResult::AddCoincidentConstraint {
- point_a: glam::DVec3::new(5.0, 0.0, 0.0), // a's end
- point_b: glam::DVec3::new(20.0, 0.0, 0.0), // b's start
+ first: crate::command::CoincidentPick {
+ handle: Some(a),
+ point: glam::DVec3::new(5.0, 0.0, 0.0),
+ whole_curve: false,
+ },
+ second: crate::command::CoincidentPick {
+ handle: Some(b),
+ point: glam::DVec3::new(20.0, 0.0, 0.0),
+ whole_curve: false,
+ },
+ multiple: false,
label: "Coincident constraint",
});
- let set = app.tabs[app.active_tab].scene.sketch_constraint_set(SketchScope::ModelSpace).expect("a constraint set should exist");
+ let set = app.tabs[app.active_tab]
+ .scene
+ .parametric_constraint_set(ParametricScope::ModelSpace)
+ .expect("a constraint set should exist");
assert_eq!(set.constraints.len(), 1);
let c = &set.constraints[0];
assert_eq!(c.kind, ConstraintKind::Coincident);
let entities: Vec = c.refs.iter().map(|r| r.entity).collect();
- assert!(entities.contains(&a) && entities.contains(&b), "the constraint should reference both lines");
+ assert!(
+ entities.contains(&a) && entities.contains(&b),
+ "the constraint should reference both lines"
+ );
+ let Some(acadrust::EntityType::Line(first)) =
+ app.tabs[app.active_tab].scene.document.get_entity(a)
+ else {
+ panic!("expected first line");
+ };
+ let Some(acadrust::EntityType::Line(second)) =
+ app.tabs[app.active_tab].scene.document.get_entity(b)
+ else {
+ panic!("expected second line");
+ };
+ assert!(
+ (first.end - acadrust::types::Vector3::new(5.0, 0.0, 0.0)).length() < 1.0e-7
+ );
+ assert!((second.start - first.end).length() < 1.0e-7);
+ assert!((second.length() - 5.0).abs() < 1.0e-7);
}
/// A pick that doesn't land near any real point (no object snap match)
@@ -7671,15 +8690,24 @@ mod sketch_constraint_undo_tests {
let _a = add_line(&mut app, 0.0, 0.0, 5.0, 0.0);
let _ = app.apply_cmd_result(CmdResult::AddCoincidentConstraint {
- point_a: glam::DVec3::new(5.0, 0.0, 0.0), // a's end — a real point
- point_b: glam::DVec3::new(500.0, 500.0, 0.0), // nowhere near anything
+ first: crate::command::CoincidentPick {
+ handle: Some(_a),
+ point: glam::DVec3::new(5.0, 0.0, 0.0),
+ whole_curve: false,
+ },
+ second: crate::command::CoincidentPick {
+ handle: None,
+ point: glam::DVec3::new(500.0, 500.0, 0.0),
+ whole_curve: false,
+ },
+ multiple: false,
label: "Coincident constraint",
});
assert_eq!(
app.tabs[app.active_tab]
.scene
- .sketch_constraint_set(SketchScope::ModelSpace)
+ .parametric_constraint_set(ParametricScope::ModelSpace)
.map(|s| s.constraints.len())
.unwrap_or(0),
0,
@@ -7702,12 +8730,13 @@ mod delobj_tests {
let profile = app.tabs[i]
.scene
.add_entity(acadrust::EntityType::Circle(circle));
- let path = app.tabs[i].scene.add_entity(acadrust::EntityType::Line(
- acadrust::Line::from_points(
- Vector3::new(0.0, 0.0, 0.0),
- Vector3::new(0.0, 0.0, 5.0),
- ),
- ));
+ let path =
+ app.tabs[i]
+ .scene
+ .add_entity(acadrust::EntityType::Line(acadrust::Line::from_points(
+ Vector3::new(0.0, 0.0, 0.0),
+ Vector3::new(0.0, 0.0, 5.0),
+ )));
app.delete_objects = value;
let _ = app.apply_cmd_result(CmdResult::SweepEntities {
@@ -7718,14 +8747,18 @@ mod delobj_tests {
color: [1.0; 4],
});
- let created = app.tabs[i].scene.document.entities().any(|entity| match mode {
- crate::command::ExtrudeMode::Solid => {
- matches!(entity, acadrust::EntityType::Solid3D(_))
- }
- crate::command::ExtrudeMode::Surface => {
- matches!(entity, acadrust::EntityType::Surface(_))
- }
- });
+ let created = app.tabs[i]
+ .scene
+ .document
+ .entities()
+ .any(|entity| match mode {
+ crate::command::ExtrudeMode::Solid => {
+ matches!(entity, acadrust::EntityType::Solid3D(_))
+ }
+ crate::command::ExtrudeMode::Surface => {
+ matches!(entity, acadrust::EntityType::Surface(_))
+ }
+ });
assert!(created, "SWEEP must produce the requested result");
(
app.tabs[i].scene.document.get_entity(profile).is_some(),
@@ -7764,41 +8797,93 @@ mod thicken_tests {
fn thicken_preserves_sources_and_round_trips_results_with_one_undo() {
let mut app = OpenCADStudio::new_for_test();
app.automation_op(r#"{"op":"new"}"#);
- let body = cadkernel::brep::planar_region(Plane::XY, &[
- vec![Curve::Circle(Circle { centre: [0.0; 2], radius: 3.0 })],
- ]).unwrap();
- let source = app.add_surface_model(acadrust::EntityType::Surface(Surface::new(SurfaceKind::Plane)), body);
+ let body = cadkernel::brep::planar_region(
+ Plane::XY,
+ &[vec![Curve::Circle(Circle {
+ centre: [0.0; 2],
+ radius: 3.0,
+ })]],
+ )
+ .unwrap();
+ let source = app.add_surface_model(
+ acadrust::EntityType::Surface(Surface::new(SurfaceKind::Plane)),
+ body,
+ );
assert!(!source.is_null());
let i = app.active_tab;
- let invalid = app.tabs[i].scene.add_entity(acadrust::EntityType::Surface(Surface::new(SurfaceKind::Generic)));
- let original = serde_json::to_value(app.tabs[i].scene.document.get_entity(source).unwrap()).unwrap();
+ let invalid = app.tabs[i]
+ .scene
+ .add_entity(acadrust::EntityType::Surface(Surface::new(
+ SurfaceKind::Generic,
+ )));
+ let original =
+ serde_json::to_value(app.tabs[i].scene.document.get_entity(source).unwrap()).unwrap();
let before = app.tabs[i].history.undo_stack.len();
- let _ = app.apply_cmd_result(CmdResult::ThickenEntities { handles: vec![source], distance: 0.0 });
+ let _ = app.apply_cmd_result(CmdResult::ThickenEntities {
+ handles: vec![source],
+ distance: 0.0,
+ });
assert_eq!(app.tabs[i].history.undo_stack.len(), before);
- let _ = app.apply_cmd_result(CmdResult::ThickenEntities { handles: vec![invalid, source], distance: 2.0 });
+ let _ = app.apply_cmd_result(CmdResult::ThickenEntities {
+ handles: vec![invalid, source],
+ distance: 2.0,
+ });
assert_eq!(app.tabs[i].history.undo_stack.len(), before + 1);
- let result = app.tabs[i].scene.document.entities().find_map(|entity| {
- matches!(entity, acadrust::EntityType::Solid3D(_)).then_some(entity.common().handle)
- }).unwrap();
- assert!(app.tabs[i].scene.document.solid_history_operation(result).is_some());
- assert_eq!(serde_json::to_value(app.tabs[i].scene.document.get_entity(source).unwrap()).unwrap(), original);
- let expected = cadkernel::brep::analytic_mass_properties(&app.tabs[i].scene.solid_models[&result]).unwrap().volume;
- let bytes = crate::io::save_to_bytes(&app.tabs[i].scene.document, "dwg", app.tabs[i].scene.document.version).unwrap();
+ let result = app.tabs[i]
+ .scene
+ .document
+ .entities()
+ .find_map(|entity| {
+ matches!(entity, acadrust::EntityType::Solid3D(_)).then_some(entity.common().handle)
+ })
+ .unwrap();
+ assert!(app.tabs[i]
+ .scene
+ .document
+ .solid_history_operation(result)
+ .is_some());
+ assert_eq!(
+ serde_json::to_value(app.tabs[i].scene.document.get_entity(source).unwrap()).unwrap(),
+ original
+ );
+ let expected =
+ cadkernel::brep::analytic_mass_properties(&app.tabs[i].scene.solid_models[&result])
+ .unwrap()
+ .volume;
+ let bytes = crate::io::save_to_bytes(
+ &app.tabs[i].scene.document,
+ "dwg",
+ app.tabs[i].scene.document.version,
+ )
+ .unwrap();
let document = crate::io::load_bytes("thicken.dwg", bytes).unwrap();
let mut restored = crate::scene::Scene::new();
restored.document = document;
restored.restore_solid_models(&[result]);
- let actual = cadkernel::brep::analytic_mass_properties(&restored.solid_models[&result]).unwrap().volume;
+ let actual = cadkernel::brep::analytic_mass_properties(&restored.solid_models[&result])
+ .unwrap()
+ .volume;
assert!((expected - actual).abs() < 1e-8);
app.undo_active_tab();
assert!(app.tabs[i].scene.document.get_entity(result).is_none());
- assert!(app.tabs[i].scene.document.solid_history_operation(result).is_none());
+ assert!(app.tabs[i]
+ .scene
+ .document
+ .solid_history_operation(result)
+ .is_none());
assert!(app.tabs[i].scene.document.get_entity(source).is_some());
assert!(app.tabs[i].scene.document.get_entity(invalid).is_some());
app.redo_active_tab();
assert!(app.tabs[i].scene.document.get_entity(result).is_some());
- assert!(app.tabs[i].scene.document.solid_history_operation(result).is_some());
- assert_eq!(serde_json::to_value(app.tabs[i].scene.document.get_entity(source).unwrap()).unwrap(), original);
+ assert!(app.tabs[i]
+ .scene
+ .document
+ .solid_history_operation(result)
+ .is_some());
+ assert_eq!(
+ serde_json::to_value(app.tabs[i].scene.document.get_entity(source).unwrap()).unwrap(),
+ original
+ );
}
#[test]
@@ -7812,12 +8897,9 @@ mod thicken_tests {
Parameterization::Chord,
)
.unwrap();
- let body = cadkernel::brep::extrude_surface(
- Plane::XY,
- &[Curve::Nurbs(profile)],
- [0.0, 0.0, 2.0],
- )
- .unwrap();
+ let body =
+ cadkernel::brep::extrude_surface(Plane::XY, &[Curve::Nurbs(profile)], [0.0, 0.0, 2.0])
+ .unwrap();
let source = app.add_surface_model(
acadrust::EntityType::Surface(Surface::new(SurfaceKind::Generic)),
body,
@@ -7834,8 +8916,7 @@ mod thicken_tests {
.document
.entities()
.filter_map(|entity| {
- matches!(entity, acadrust::EntityType::Solid3D(_))
- .then_some(entity.common().handle)
+ matches!(entity, acadrust::EntityType::Solid3D(_)).then_some(entity.common().handle)
})
.collect::>();
assert_eq!(solids.len(), 1);
diff --git a/src/app/commands/draw.rs b/src/app/commands/draw.rs
index dc59babfa..d021b1d6b 100644
--- a/src/app/commands/draw.rs
+++ b/src/app/commands/draw.rs
@@ -29,12 +29,7 @@ impl OpenCADStudio {
_ => None,
})
.collect();
- let cmd_obj = MlineCommand::with_styles(
- styles,
- style_name,
- scale,
- justification,
- );
+ let cmd_obj = MlineCommand::with_styles(styles, style_name, scale, justification);
self.command_line.push_info(&cmd_obj.prompt());
self.tabs[i].active_cmd = Some(Box::new(cmd_obj));
}
@@ -133,25 +128,29 @@ impl OpenCADStudio {
if rest.is_empty() {
// List attributes.
if ins.attributes.is_empty() {
- self.command_line.push_output(crate::tf!(
- " Insert {:x}: no attributes.",
- sh.value()
- ).as_ref());
+ self.command_line.push_output(
+ crate::tf!(" Insert {:x}: no attributes.", sh.value())
+ .as_ref(),
+ );
} else {
for attr in &ins.attributes {
- self.command_line.push_output(crate::tf!(
- " [{tag}] = {val}",
- tag = attr.tag,
- val = attr.get_value()
- ).as_ref());
+ self.command_line.push_output(
+ crate::tf!(
+ " [{tag}] = {val}",
+ tag = attr.tag,
+ val = attr.get_value()
+ )
+ .as_ref(),
+ );
}
}
}
}
}
if !found_any {
- self.command_line
- .push_error(crate::t!("ATTEDIT: no Insert entities in selection.").as_ref());
+ self.command_line.push_error(
+ crate::t!("ATTEDIT: no Insert entities in selection.").as_ref(),
+ );
}
// If tag + value supplied, mutate attributes.
if parts.len() == 2 && !parts[0].is_empty() {
@@ -179,13 +178,17 @@ impl OpenCADStudio {
}
if changed > 0 {
self.tabs[i].dirty = true;
- self.command_line.push_output(crate::tf!(
+ self.command_line.push_output(
+ crate::tf!(
"ATTEDIT: updated {changed} attribute(s) [{tag_up}] = {new_val}."
- ).as_ref());
+ )
+ .as_ref(),
+ );
} else {
- self.command_line.push_error(crate::tf!(
- "ATTEDIT: tag '{tag_up}' not found in selection."
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!("ATTEDIT: tag '{tag_up}' not found in selection.")
+ .as_ref(),
+ );
}
}
}
@@ -243,9 +246,10 @@ impl OpenCADStudio {
}
}
self.tabs[i].dirty = true;
- self.command_line.push_output(crate::tf!(
- "ATTDISP {sub}: {count} attribute definition(s) updated."
- ).as_ref());
+ self.command_line.push_output(
+ crate::tf!("ATTDISP {sub}: {count} attribute definition(s) updated.")
+ .as_ref(),
+ );
}
_ => {
self.command_line
@@ -388,8 +392,10 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
None => {
- self.command_line
- .push_info(crate::t!("ARC Continue No previous line or arc to continue.").as_ref());
+ self.command_line.push_info(
+ crate::t!("ARC Continue No previous line or arc to continue.")
+ .as_ref(),
+ );
}
}
}
@@ -528,16 +534,26 @@ impl OpenCADStudio {
if count > 0 {
self.tabs[i].dirty = true;
}
- self.command_line
- .push_output(&crate::tf!("CENTERRESET: {count} center object(s) updated."));
+ self.command_line.push_output(&crate::tf!(
+ "CENTERRESET: {count} center object(s) updated."
+ ));
}
"CENTERREASSOCIATE" => {
let handles = self.tabs[i].scene.selected_handles_in_order();
- let mark_targets: Vec<_> = handles.iter().copied().filter(|handle| {
- let Some(acadrust::EntityType::Line(line)) = self.tabs[i].scene.document.get_entity(*handle) else { return false; };
- acadrust::entities::CenterMarkAssociation::read(&line.common.extended_data).is_some()
- }).collect();
+ let mark_targets: Vec<_> = handles
+ .iter()
+ .copied()
+ .filter(|handle| {
+ let Some(acadrust::EntityType::Line(line)) =
+ self.tabs[i].scene.document.get_entity(*handle)
+ else {
+ return false;
+ };
+ acadrust::entities::CenterMarkAssociation::read(&line.common.extended_data)
+ .is_some()
+ })
+ .collect();
if mark_targets.len() == 1 && handles.len() == 1 {
use crate::modules::draw::draw::dimcenter::CenterMarkReassociateCommand;
let new_cmd = CenterMarkReassociateCommand::new(mark_targets[0]);
@@ -546,25 +562,35 @@ impl OpenCADStudio {
return Some(self.finish_dispatch(cmd));
}
self.push_undo_snapshot(i, "CENTERREASSOCIATE");
- let count = self.tabs[i].scene.set_centerline_association(&handles, true)
- + self.tabs[i].scene.set_center_mark_association(&handles, true);
+ let count = self.tabs[i]
+ .scene
+ .set_centerline_association(&handles, true)
+ + self.tabs[i]
+ .scene
+ .set_center_mark_association(&handles, true);
if count > 0 {
self.tabs[i].dirty = true;
}
- self.command_line
- .push_output(&crate::tf!("CENTERREASSOCIATE: {count} center object(s) associated."));
+ self.command_line.push_output(&crate::tf!(
+ "CENTERREASSOCIATE: {count} center object(s) associated."
+ ));
}
"CENTERDISASSOCIATE" => {
let handles = self.tabs[i].scene.selected_handles_in_order();
self.push_undo_snapshot(i, "CENTERDISASSOCIATE");
- let count = self.tabs[i].scene.set_centerline_association(&handles, false)
- + self.tabs[i].scene.set_center_mark_association(&handles, false);
+ let count = self.tabs[i]
+ .scene
+ .set_centerline_association(&handles, false)
+ + self.tabs[i]
+ .scene
+ .set_center_mark_association(&handles, false);
if count > 0 {
self.tabs[i].dirty = true;
}
- self.command_line
- .push_output(&crate::tf!("CENTERDISASSOCIATE: {count} center object(s) detached."));
+ self.command_line.push_output(&crate::tf!(
+ "CENTERDISASSOCIATE: {count} center object(s) detached."
+ ));
}
"DIMCENTER" => {
@@ -602,15 +628,20 @@ impl OpenCADStudio {
self.command_line.push_info(&selection.prompt());
self.tabs[i].active_cmd = Some(Box::new(selection));
} else {
- let replacements = self.tabs[i].scene.selected_entities().into_iter()
+ let replacements = self.tabs[i]
+ .scene
+ .selected_entities()
+ .into_iter()
.filter(|(handle, _)| !self.tabs[i].scene.is_layer_locked(*handle))
- .filter_map(|(handle, entity)| ReverseCommand::reversed(entity)
- .map(|reversed| (handle, vec![reversed])))
+ .filter_map(|(handle, entity)| {
+ ReverseCommand::reversed(entity)
+ .map(|reversed| (handle, vec![reversed]))
+ })
.collect::>();
if !replacements.is_empty() {
- return Some(self.apply_cmd_result(crate::command::CmdResult::ReplaceMany(
- replacements, Vec::new(),
- )));
+ return Some(self.apply_cmd_result(
+ crate::command::CmdResult::ReplaceMany(replacements, Vec::new()),
+ ));
}
}
}
@@ -766,9 +797,7 @@ impl OpenCADStudio {
glam::DVec3::from_array(storage.x_axis),
glam::DVec3::from_array(storage.y_axis),
);
- let boundary_sources = self.tabs[i]
- .scene
- .boundary_sources_on_plane(plane, 1.0e-6);
+ let boundary_sources = self.tabs[i].scene.boundary_sources_on_plane(plane, 1.0e-6);
let outlines = crate::scene::boundary_faces(&boundary_sources, 1.0e-6);
let selected = self.tabs[i]
.scene
@@ -776,20 +805,14 @@ impl OpenCADStudio {
.into_iter()
.map(|(handle, _)| handle)
.collect::>();
- let inherited = selected
- .iter()
- .find_map(|handle| {
- let model = self.tabs[i].scene.hatches.get(handle)?.clone();
- let common = self.tabs[i].scene.document.get_entity(*handle)?.common();
- Some((model, common.color.clone(), common.transparency))
- });
- let new_cmd = HatchCommand::new(
- outlines,
- boundary_sources,
- selected,
- inherited,
- plane,
- ).with_origin(self.tabs[i].scene.document.hatch_origin());
+ let inherited = selected.iter().find_map(|handle| {
+ let model = self.tabs[i].scene.hatches.get(handle)?.clone();
+ let common = self.tabs[i].scene.document.get_entity(*handle)?.common();
+ Some((model, common.color.clone(), common.transparency))
+ });
+ let new_cmd =
+ HatchCommand::new(outlines, boundary_sources, selected, inherited, plane)
+ .with_origin(self.tabs[i].scene.document.hatch_origin());
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
self.refresh_area_preview(i);
@@ -804,11 +827,11 @@ impl OpenCADStudio {
if let Some(model) = self.tabs[i].scene.hatches.get(&h).cloned() {
let entity = self.tabs[i].scene.document.get_entity(h);
let annotative = entity.is_some_and(|entity| {
- crate::scene::annotative::is_annotative(
- &self.tabs[i].scene.document,
- entity,
- )
- });
+ crate::scene::annotative::is_annotative(
+ &self.tabs[i].scene.document,
+ entity,
+ )
+ });
let (scale, angle) = match entity {
Some(acadrust::EntityType::Hatch(hatch)) => (
hatch.pattern_scale as f32,
@@ -822,15 +845,28 @@ impl OpenCADStudio {
scale,
angle,
annotative,
- ).with_appearance(entity,self.tabs[i].scene.document.header.current_entity_color,self.tabs[i].scene.document.current_entity_transparency()).with_origin(self.tabs[i].scene.document.hatch_origin());
+ )
+ .with_appearance(
+ entity,
+ self.tabs[i].scene.document.header.current_entity_color,
+ self.tabs[i].scene.document.current_entity_transparency(),
+ )
+ .with_origin(self.tabs[i].scene.document.hatch_origin());
self.command_line.push_info(&cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(cmd));
} else {
- self.command_line
- .push_error(crate::t!("HATCHEDIT: selected entity is not a hatch.").as_ref());
+ self.command_line.push_error(
+ crate::t!("HATCHEDIT: selected entity is not a hatch.").as_ref(),
+ );
}
} else {
- let cmd = HatcheditCommand::new().with_appearance(None,self.tabs[i].scene.document.header.current_entity_color,self.tabs[i].scene.document.current_entity_transparency()).with_origin(self.tabs[i].scene.document.hatch_origin());
+ let cmd = HatcheditCommand::new()
+ .with_appearance(
+ None,
+ self.tabs[i].scene.document.header.current_entity_color,
+ self.tabs[i].scene.document.current_entity_transparency(),
+ )
+ .with_origin(self.tabs[i].scene.document.hatch_origin());
self.command_line.push_info(&cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(cmd));
}
@@ -854,9 +890,7 @@ impl OpenCADStudio {
} else {
crate::command::WorkingPlane::default()
};
- let sources = self.tabs[i]
- .scene
- .boundary_sources_on_plane(plane, 1.0e-6);
+ let sources = self.tabs[i].scene.boundary_sources_on_plane(plane, 1.0e-6);
let selected = self.tabs[i]
.scene
.selected_entities()
@@ -895,7 +929,8 @@ impl OpenCADStudio {
SplineCommand::control_vertices()
} else {
SplineCommand::new()
- }.with_document(&self.tabs[i].scene.document);
+ }
+ .with_document(&self.tabs[i].scene.document);
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
@@ -935,8 +970,7 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = Some(Box::new(cmd));
} else {
use crate::modules::draw::modify::mirror::MirrorCommand;
- let (wires, text_ghosts) =
- self.tabs[i].scene.mirror_preview_parts(&handles);
+ let (wires, text_ghosts) = self.tabs[i].scene.mirror_preview_parts(&handles);
let mirror_text = self.tabs[i].scene.document.header.mirror_text;
let new_cmd = MirrorCommand::new(handles, wires, text_ghosts, mirror_text);
self.command_line.push_info(&new_cmd.prompt());
@@ -986,10 +1020,10 @@ impl OpenCADStudio {
self.command_line.push_info(&sel.prompt());
self.tabs[i].active_cmd = Some(Box::new(sel));
} else {
- let scope = self.tabs[i].current_sketch_scope();
+ let scope = self.tabs[i].current_parametric_scope();
let dimensional = cmd.starts_with("DC");
let visible = !matches!(cmd, "GCHIDE" | "DCHIDE");
- let count = self.tabs[i].scene.set_sketch_constraint_visibility(
+ let count = self.tabs[i].scene.set_parametric_constraint_visibility(
scope,
Some(&handles),
dimensional,
@@ -1002,19 +1036,19 @@ impl OpenCADStudio {
}
"GCRESET" => {
- let scope = self.tabs[i].current_sketch_scope();
+ let scope = self.tabs[i].current_parametric_scope();
let count = self.tabs[i]
.scene
- .set_sketch_constraint_visibility(scope, None, false, true);
+ .set_parametric_constraint_visibility(scope, None, false, true);
self.command_line
.push_output(format!("{} constraint indicator(s) reset.", count).as_str());
}
"GCSHOWALL" | "GCHIDEALL" | "DCSHOWALL" | "DCHIDEALL" => {
- let scope = self.tabs[i].current_sketch_scope();
+ let scope = self.tabs[i].current_parametric_scope();
let dimensional = cmd.starts_with("DC");
let visible = matches!(cmd, "GCSHOWALL" | "DCSHOWALL");
- let count = self.tabs[i].scene.set_sketch_constraint_visibility(
+ let count = self.tabs[i].scene.set_parametric_constraint_visibility(
scope,
None,
dimensional,
@@ -1032,11 +1066,8 @@ impl OpenCADStudio {
self.command_line.push_info(&sel.prompt());
self.tabs[i].active_cmd = Some(Box::new(sel));
} else {
- let scope = self.tabs[i].current_sketch_scope();
- let Some(before) = self.tabs[i]
- .scene
- .sketch_constraint_set(scope)
- .cloned()
+ let scope = self.tabs[i].current_parametric_scope();
+ let Some(before) = self.tabs[i].scene.parametric_constraint_set(scope).cloned()
else {
self.command_line.push_output("No constraints found.");
return None;
@@ -1061,8 +1092,8 @@ impl OpenCADStudio {
let pending = self.begin_undo(i, "Delete constraints", handles.len(), true);
self.tabs[i]
.scene
- .record_undo_sketch_constraints_before(scope, before);
- let set = self.tabs[i].scene.sketch_constraint_set_mut(scope);
+ .record_undo_parametric_constraints_before(scope, before);
+ let set = self.tabs[i].scene.parametric_constraint_set_mut(scope);
for id in &ids {
set.remove(*id);
}
@@ -1082,53 +1113,86 @@ impl OpenCADStudio {
}
}
+ "CONSTRAINTSETTINGS" => {
+ self.auto_constrain_saved = Some(self.auto_constrain_settings.clone());
+ self.auto_constrain_selected_row = 0;
+ self.auto_constrain_distance_input =
+ format!("{}", self.auto_constrain_settings.distance_tolerance);
+ self.auto_constrain_angle_input =
+ format!("{}", self.auto_constrain_settings.angle_tolerance_deg);
+ self.active_modal = Some(crate::app::ModalKind::AutoConstrainSettings);
+ }
+
"AUTOCONSTRAIN" => {
let handles = self.tabs[i].scene.selected_handles_in_order();
if handles.is_empty() {
use crate::modules::draw::select::SelectObjectsCommand;
- let sel = SelectObjectsCommand::new(cmd);
+ let sel = SelectObjectsCommand::auto_constrain(cmd);
self.command_line.push_info(&sel.prompt());
self.tabs[i].active_cmd = Some(Box::new(sel));
} else {
- let scope = self.tabs[i].current_sketch_scope();
+ let scope = self.tabs[i].current_parametric_scope();
let inferred = self.tabs[i]
.scene
- .inferred_sketch_constraints(scope, &handles);
+ .inferred_parametric_constraints(
+ scope,
+ &handles,
+ &self.auto_constrain_settings,
+ );
if inferred.is_empty() {
- self.command_line
- .push_output("No supported geometric relations were found.");
- return None;
- }
- let before = self.tabs[i]
- .scene
- .sketch_constraint_set(scope)
- .cloned()
- .unwrap_or_else(|| {
- crate::scene::sketch_constraints::SketchConstraintSet::new(scope)
- });
- let pending = self.begin_undo(i, "Auto constrain", handles.len(), true);
- self.tabs[i]
- .scene
- .record_undo_sketch_constraints_before(scope, before);
- let count = inferred.len();
- for (kind, refs) in inferred {
+ self.command_line.push_output(
+ format!(
+ "0 constraint(s) applied to {} object(s).",
+ handles.len()
+ )
+ .as_str(),
+ );
+ self.tabs[i].scene.deselect_all();
+ self.refresh_selected_grips();
+ } else {
+ let before = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .cloned()
+ .unwrap_or_else(|| {
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(
+ scope,
+ )
+ });
+ let pending = self.begin_undo(i, "Auto constrain", handles.len(), true);
self.tabs[i]
.scene
- .sketch_constraint_set_mut(scope)
- .add(kind, refs, None);
- }
- let changes: Vec<_> = handles
- .iter()
- .copied()
- .map(|handle| (handle, crate::scene::ChangeKind::Modified))
- .collect();
- self.tabs[i].scene.bump_entities(&changes);
- self.tabs[i].dirty = true;
- self.refresh_properties();
- self.command_line
- .push_output(format!("{} constraint(s) applied.", count).as_str());
- if let Some(pd) = pending {
- self.commit_undo_delta(i, pd);
+ .record_undo_parametric_constraints_before(scope, before);
+ let count = inferred.len();
+ for (kind, refs) in inferred {
+ self.tabs[i]
+ .scene
+ .parametric_constraint_set_mut(scope)
+ .add(kind, refs, None);
+ }
+ let changes: Vec<_> = handles
+ .iter()
+ .copied()
+ .map(|handle| (handle, crate::scene::ChangeKind::Modified))
+ .collect();
+ self.tabs[i].scene.bump_entities_with_parametric_policy(
+ &changes,
+ &[],
+ self.constraint_solve_mode,
+ );
+ self.tabs[i].dirty = true;
+ self.refresh_properties();
+ self.command_line.push_output(
+ format!(
+ "{} constraint(s) applied to {} object(s).",
+ count,
+ handles.len()
+ )
+ .as_str(),
+ );
+ if let Some(pd) = pending {
+ self.commit_undo_delta(i, pd);
+ }
}
}
}
@@ -1142,14 +1206,13 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = Some(Box::new(sel));
} else {
let Some(refs) = self.tabs[i].scene.smooth_constraint_refs(&handles) else {
- self.command_line.push_output(
- "Select one open spline and one open target curve.",
- );
+ self.command_line
+ .push_output("Select one open spline and one open target curve.");
return None;
};
use crate::command::CmdResult;
- use crate::scene::sketch_constraints::ConstraintKind;
- return Some(self.apply_cmd_result(CmdResult::AddSketchConstraint {
+ use crate::scene::parametric_constraints::ConstraintKind;
+ return Some(self.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Smooth,
refs,
driving_param: None,
@@ -1166,7 +1229,7 @@ impl OpenCADStudio {
self.command_line.push_info(&sel.prompt());
self.tabs[i].active_cmd = Some(Box::new(sel));
} else {
- let scope = self.tabs[i].current_sketch_scope();
+ let scope = self.tabs[i].current_parametric_scope();
let conversions: Vec<_> = handles
.iter()
.copied()
@@ -1179,23 +1242,24 @@ impl OpenCADStudio {
)?;
self.tabs[i]
.scene
- .validate_sketch_constraint(kind, &refs, Some(&value))
+ .validate_parametric_constraint(kind, &refs, Some(&value))
.ok()?;
Some((handle, kind, refs, value))
})
.collect();
if conversions.is_empty() {
- self.command_line.push_output(
- "No supported associative dimensions were selected.",
- );
+ self.command_line
+ .push_output("No supported associative dimensions were selected.");
return None;
}
let before = self.tabs[i]
.scene
- .sketch_constraint_set(scope)
+ .parametric_constraint_set(scope)
.cloned()
.unwrap_or_else(|| {
- crate::scene::sketch_constraints::SketchConstraintSet::new(scope)
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(
+ scope,
+ )
});
let mut touched: Vec<_> = conversions
.iter()
@@ -1215,12 +1279,13 @@ impl OpenCADStudio {
);
self.tabs[i]
.scene
- .record_undo_sketch_constraints_before(scope, before);
+ .record_undo_parametric_constraints_before(scope, before);
for (_, kind, refs, value) in conversions {
- self.tabs[i]
- .scene
- .sketch_constraint_set_mut(scope)
- .add(kind, refs, Some(value));
+ self.tabs[i].scene.parametric_constraint_set_mut(scope).add(
+ kind,
+ refs,
+ Some(value),
+ );
}
self.tabs[i].scene.erase_entities(&dimensions);
let changes: Vec<_> = touched
@@ -1251,28 +1316,35 @@ impl OpenCADStudio {
.push_output("Select exactly one entity, then run this constraint again.");
} else {
use crate::command::CmdResult;
- use crate::scene::sketch_constraints::{ConstraintKind, SketchRef};
+ use crate::scene::parametric_constraints::{ConstraintKind, ParametricRef};
let (kind, label) = match cmd {
"HCONSTRAINT" => (ConstraintKind::Horizontal, "Horizontal constraint"),
"VCONSTRAINT" => (ConstraintKind::Vertical, "Vertical constraint"),
_ => (ConstraintKind::Fixed, "Fixed constraint"),
};
- return Some(self.apply_cmd_result(CmdResult::AddSketchConstraint {
+ return Some(self.apply_cmd_result(CmdResult::AddParametricConstraint {
kind,
- refs: vec![SketchRef::whole(handles[0])],
+ refs: vec![ParametricRef::whole(handles[0])],
driving_param: None,
label,
}));
}
}
- "CCONSTRAINT" => {
+ "CCONSTRAINT" | "GCCOINCIDENT" => {
use crate::modules::parametric::CoincidentConstraintCommand;
let new_cmd = CoincidentConstraintCommand::new();
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
+ "GEOMCONSTRAINT" => {
+ use crate::modules::parametric::GeomConstraintCommand;
+ let new_cmd = GeomConstraintCommand::new();
+ self.command_line.push_info(&new_cmd.prompt());
+ self.tabs[i].active_cmd = Some(Box::new(new_cmd));
+ }
+
"EDCONSTRAINT" => {
use crate::modules::parametric::EqualDistanceConstraintCommand;
let new_cmd = EqualDistanceConstraintCommand::new();
@@ -1280,7 +1352,8 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
- "PCONSTRAINT" | "QCONSTRAINT" | "ECONSTRAINT" | "TCONSTRAINT" | "LCONSTRAINT" | "NRCONSTRAINT" => {
+ "PCONSTRAINT" | "QCONSTRAINT" | "ECONSTRAINT" | "TCONSTRAINT" | "LCONSTRAINT"
+ | "NRCONSTRAINT" => {
let handles = self.tabs[i].scene.selected_handles_in_order();
if handles.is_empty() {
use crate::modules::draw::select::SelectObjectsCommand;
@@ -1293,18 +1366,23 @@ impl OpenCADStudio {
);
} else {
use crate::command::CmdResult;
- use crate::scene::sketch_constraints::{ConstraintKind, SketchRef};
+ use crate::scene::parametric_constraints::{ConstraintKind, ParametricRef};
let (kind, label) = match cmd {
"PCONSTRAINT" => (ConstraintKind::Parallel, "Parallel constraint"),
- "QCONSTRAINT" => (ConstraintKind::Perpendicular, "Perpendicular constraint"),
+ "QCONSTRAINT" => {
+ (ConstraintKind::Perpendicular, "Perpendicular constraint")
+ }
"TCONSTRAINT" => (ConstraintKind::Tangent, "Tangent constraint"),
"LCONSTRAINT" => (ConstraintKind::Colinear, "Colinear constraint"),
"NRCONSTRAINT" => (ConstraintKind::Normal, "Normal constraint"),
_ => (ConstraintKind::Equal, "Equal constraint"),
};
- return Some(self.apply_cmd_result(CmdResult::AddSketchConstraint {
+ return Some(self.apply_cmd_result(CmdResult::AddParametricConstraint {
kind,
- refs: vec![SketchRef::whole(handles[0]), SketchRef::whole(handles[1])],
+ refs: vec![
+ ParametricRef::whole(handles[0]),
+ ParametricRef::whole(handles[1]),
+ ],
driving_param: None,
label,
}));
@@ -1319,13 +1397,18 @@ impl OpenCADStudio {
self.command_line.push_info(&sel.prompt());
self.tabs[i].active_cmd = Some(Box::new(sel));
} else if handles.len() != 2 {
- self.command_line.push_output("Select exactly two circles/arcs, then run this constraint again.");
+ self.command_line.push_output(
+ "Select exactly two circles/arcs, then run this constraint again.",
+ );
} else {
use crate::command::CmdResult;
- use crate::scene::sketch_constraints::{ConstraintKind, SketchRef};
- return Some(self.apply_cmd_result(CmdResult::AddSketchConstraint {
+ use crate::scene::parametric_constraints::{ConstraintKind, ParametricRef};
+ return Some(self.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Concentric,
- refs: vec![SketchRef::center(handles[0]), SketchRef::center(handles[1])],
+ refs: vec![
+ ParametricRef::center(handles[0]),
+ ParametricRef::center(handles[1]),
+ ],
driving_param: None,
label: "Concentric constraint",
}));
@@ -1345,10 +1428,14 @@ impl OpenCADStudio {
);
} else {
use crate::command::CmdResult;
- use crate::scene::sketch_constraints::{ConstraintKind, SketchRef};
- return Some(self.apply_cmd_result(CmdResult::AddSketchConstraint {
+ use crate::scene::parametric_constraints::{ConstraintKind, ParametricRef};
+ return Some(self.apply_cmd_result(CmdResult::AddParametricConstraint {
kind: ConstraintKind::Symmetric,
- refs: vec![SketchRef::center(handles[0]), SketchRef::center(handles[1]), SketchRef::whole(handles[2])],
+ refs: vec![
+ ParametricRef::center(handles[0]),
+ ParametricRef::center(handles[1]),
+ ParametricRef::whole(handles[2]),
+ ],
driving_param: None,
label: "Symmetric constraint",
}));
@@ -1368,13 +1455,26 @@ impl OpenCADStudio {
);
} else {
use crate::modules::parametric::PointOnEntityConstraintCommand;
- use crate::scene::sketch_constraints::ConstraintKind;
+ use crate::scene::parametric_constraints::ConstraintKind;
let (name, kind, label) = match cmd {
- "CPCONSTRAINT" => ("CPCONSTRAINT", ConstraintKind::CenterPoint, "Center point constraint"),
- "MPCONSTRAINT" => ("MPCONSTRAINT", ConstraintKind::Midpoint, "Midpoint constraint"),
- _ => ("OCCONSTRAINT", ConstraintKind::PointOnCurve, "Point on curve constraint"),
+ "CPCONSTRAINT" => (
+ "CPCONSTRAINT",
+ ConstraintKind::CenterPoint,
+ "Center point constraint",
+ ),
+ "MPCONSTRAINT" => (
+ "MPCONSTRAINT",
+ ConstraintKind::Midpoint,
+ "Midpoint constraint",
+ ),
+ _ => (
+ "OCCONSTRAINT",
+ ConstraintKind::PointOnCurve,
+ "Point on curve constraint",
+ ),
};
- let new_cmd = PointOnEntityConstraintCommand::new(name, kind, handles[0], label);
+ let new_cmd =
+ PointOnEntityConstraintCommand::new(name, kind, handles[0], label);
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
@@ -1389,8 +1489,9 @@ impl OpenCADStudio {
self.command_line.push_info(&sel.prompt());
self.tabs[i].active_cmd = Some(Box::new(sel));
} else if handles.len() != 1 {
- self.command_line
- .push_output("Select exactly one line or circle, then run this constraint again.");
+ self.command_line.push_output(
+ "Select exactly one line or circle, then run this constraint again.",
+ );
} else {
use crate::modules::parametric::{DistanceConstraintCommand, DistanceMode};
let (command_name, mode) = match cmd {
@@ -1412,7 +1513,9 @@ impl OpenCADStudio {
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
- None => self.command_line.push_output("Select a line or a circle for a distance constraint."),
+ None => self
+ .command_line
+ .push_output("Select a line or a circle for a distance constraint."),
}
}
}
@@ -1445,7 +1548,9 @@ impl OpenCADStudio {
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
- None => self.command_line.push_output("Select two lines for an angle constraint."),
+ None => self
+ .command_line
+ .push_output("Select two lines for an angle constraint."),
}
}
}
@@ -1457,8 +1562,7 @@ impl OpenCADStudio {
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
- "BOX" | "WEDGE" | "CONE" | "SPHERE" | "PYRAMID" | "PYR"
- | "TORUS" => {
+ "BOX" | "WEDGE" | "CONE" | "SPHERE" | "PYRAMID" | "PYR" | "TORUS" => {
use crate::modules::model::primitive_cmd::PrimitiveCommand;
let new_cmd = PrimitiveCommand::new(cmd);
self.command_line.push_info(&new_cmd.prompt());
@@ -1625,54 +1729,69 @@ impl OpenCADStudio {
continue;
};
let mut region = Region::new();
- region.point_of_reference = Vector3::new(
- plane.origin[0],
- plane.origin[1],
- plane.origin[2],
- );
+ region.point_of_reference =
+ Vector3::new(plane.origin[0], plane.origin[1], plane.origin[2]);
region.common.layer = self.tabs[i].active_layer.clone();
regions.push((region, body));
sources.push(*handle);
}
}
// Open inputs must share one geometric plane, independently of the UCS.
- let open_curves: Vec<_> = self.tabs[i].scene.selected_entities().iter()
+ let open_curves: Vec<_> = self.tabs[i]
+ .scene
+ .selected_entities()
+ .iter()
.filter(|(handle, _)| !sources.contains(handle))
.filter_map(|(_, entity)| crate::entities::curve::entity_curve(entity))
.collect();
let open_plane = cadkernel::space::common_curve_plane(&open_curves, 1.0e-6);
let open_plane_rejected = !open_curves.is_empty() && open_plane.is_none();
if let Some(plane) = open_plane {
- let working_plane = crate::command::WorkingPlane::new(
- glam::DVec3::from_array(plane.origin),
- glam::DVec3::from_array(plane.x_axis),
- glam::DVec3::from_array(plane.y_axis),
- );
- let selected_handles: rustc_hash::FxHashSet<_> = self.tabs[i].scene
- .selected_entities().iter().map(|(handle, _)| *handle).collect();
- let mut boundary_sources = self.tabs[i].scene
- .boundary_sources_on_plane(working_plane, 1.0e-6);
- boundary_sources.retain(|handle, _| {
- selected_handles.contains(handle) && !sources.contains(handle)
- });
- for ring in crate::scene::boundary_faces(&boundary_sources, 1.0e-6) {
- let paths = crate::scene::exact_hatch_paths(
- std::slice::from_ref(&ring), &[true], &boundary_sources, 1.0e-6,
+ let working_plane = crate::command::WorkingPlane::new(
+ glam::DVec3::from_array(plane.origin),
+ glam::DVec3::from_array(plane.x_axis),
+ glam::DVec3::from_array(plane.y_axis),
);
- let Some(path) = paths.first() else { continue; };
- let Some(curves) = path.edges.iter()
- .map(crate::entities::hatch::edge_curve).collect::>>()
- else { continue; };
- let Some(body) = cadkernel::brep::planar_region(plane, &[curves])
- else { continue; };
- let mut region = Region::new();
- region.point_of_reference = Vector3::new(
- plane.origin[0], plane.origin[1], plane.origin[2],
- );
- region.common.layer = self.tabs[i].active_layer.clone();
- regions.push((region, body));
- sources.extend(crate::scene::ring_source_handles(&ring, &boundary_sources));
- }
+ let selected_handles: rustc_hash::FxHashSet<_> = self.tabs[i]
+ .scene
+ .selected_entities()
+ .iter()
+ .map(|(handle, _)| *handle)
+ .collect();
+ let mut boundary_sources = self.tabs[i]
+ .scene
+ .boundary_sources_on_plane(working_plane, 1.0e-6);
+ boundary_sources.retain(|handle, _| {
+ selected_handles.contains(handle) && !sources.contains(handle)
+ });
+ for ring in crate::scene::boundary_faces(&boundary_sources, 1.0e-6) {
+ let paths = crate::scene::exact_hatch_paths(
+ std::slice::from_ref(&ring),
+ &[true],
+ &boundary_sources,
+ 1.0e-6,
+ );
+ let Some(path) = paths.first() else {
+ continue;
+ };
+ let Some(curves) = path
+ .edges
+ .iter()
+ .map(crate::entities::hatch::edge_curve)
+ .collect::>>()
+ else {
+ continue;
+ };
+ let Some(body) = cadkernel::brep::planar_region(plane, &[curves]) else {
+ continue;
+ };
+ let mut region = Region::new();
+ region.point_of_reference =
+ Vector3::new(plane.origin[0], plane.origin[1], plane.origin[2]);
+ region.common.layer = self.tabs[i].active_layer.clone();
+ regions.push((region, body));
+ sources.extend(crate::scene::ring_source_handles(&ring, &boundary_sources));
+ }
} else if open_plane_rejected {
self.command_line.push_error(
"REGION: open objects must form coplanar, noncollinear boundaries.",
@@ -1720,8 +1839,10 @@ impl OpenCADStudio {
let sides = nums.get(2).map(|s| *s as usize).unwrap_or(4);
return Some(self.solid_pyramid(nums[0], nums[1], sides));
}
- self.command_line
- .push_info(crate::t!("Usage: PYRAMID [sides] (default 4 sides)").as_ref());
+ self.command_line.push_info(
+ crate::t!("Usage: PYRAMID [sides] (default 4 sides)")
+ .as_ref(),
+ );
}
// SECTION [X|Y|Z] — draw the cross-section outline of the solid.
@@ -1756,7 +1877,10 @@ impl OpenCADStudio {
match parts.get(val_idx).and_then(|s| s.parse::().ok()) {
Some(v) => return Some(self.solid_section(axis, v)),
None => self.command_line.push_info(
- crate::t!("Usage: SECTION [X|Y|Z] (cross-sections the selected solid)").as_ref(),
+ crate::t!(
+ "Usage: SECTION [X|Y|Z] (cross-sections the selected solid)"
+ )
+ .as_ref(),
),
}
}
@@ -1909,7 +2033,8 @@ impl OpenCADStudio {
match angle {
Some(a) => return Some(self.solid_rotate3d(axis, a)),
None => self.command_line.push_info(
- crate::t!("Usage: 3DROTATE [X|Y|Z] (rotates the selected solid)").as_ref(),
+ crate::t!("Usage: 3DROTATE [X|Y|Z] (rotates the selected solid)")
+ .as_ref(),
),
}
}
@@ -1951,11 +2076,12 @@ impl OpenCADStudio {
}
})
});
- let (centre, radius) = bounds.map_or((glam::DVec3::ZERO, 10.0), |(min, max)| {
- let min = glam::DVec3::from_array(min);
- let max = glam::DVec3::from_array(max);
- ((min + max) * 0.5, (max - min).length().max(2.0) * 0.65)
- });
+ let (centre, radius) =
+ bounds.map_or((glam::DVec3::ZERO, 10.0), |(min, max)| {
+ let min = glam::DVec3::from_array(min);
+ let max = glam::DVec3::from_array(max);
+ ((min + max) * 0.5, (max - min).length().max(2.0) * 0.65)
+ });
(targets, centre, radius, scene.active_gaze_dir().as_dvec3())
};
let c = SliceCommand::new(targets, view_normal, centre, radius);
@@ -1990,7 +2116,10 @@ impl OpenCADStudio {
return Some(self.slice_selected(plane, Some(side)));
}
None => self.command_line.push_info(
- crate::t!("Usage: SLICE [X|Y|Z] [TOP|BOTTOM] (cuts the selected solid)").as_ref(),
+ crate::t!(
+ "Usage: SLICE [X|Y|Z] [TOP|BOTTOM] (cuts the selected solid)"
+ )
+ .as_ref(),
),
}
}
@@ -2006,8 +2135,7 @@ impl OpenCADStudio {
let styles = scene.document.text_styles.iter().cloned().collect();
(defaults, styles, annotation_multiplier)
};
- let new_cmd =
- TextCommand::with_defaults(defaults, styles, annotation_multiplier);
+ let new_cmd = TextCommand::with_defaults(defaults, styles, annotation_multiplier);
self.command_line.push_info(&new_cmd.prompt());
self.tabs[i].active_cmd = Some(Box::new(new_cmd));
}
@@ -2092,9 +2220,15 @@ mod region_tests {
app.automation_op(r#"{"op":"run","cmd":"CIRCLE 5,5 3"}"#);
app.automation_op(r#"{"op":"run","cmd":"LINE 0,0 10,10"}"#);
let i = app.active_tab;
- let sources: Vec<_> = app.tabs[i].scene.document.entities()
+ let sources: Vec<_> = app.tabs[i]
+ .scene
+ .document
+ .entities()
.map(|entity| {
- (entity.common().handle, matches!(entity, acadrust::EntityType::Circle(_)))
+ (
+ entity.common().handle,
+ matches!(entity, acadrust::EntityType::Circle(_)),
+ )
})
.collect();
assert_eq!(sources.len(), 2);
@@ -2110,7 +2244,10 @@ mod region_tests {
!delete_sources || !is_circle,
);
}
- let region_count = app.tabs[i].scene.document.entities()
+ let region_count = app.tabs[i]
+ .scene
+ .document
+ .entities()
.filter(|entity| matches!(entity, acadrust::EntityType::Region(_)))
.count();
assert_eq!(region_count, 1);
diff --git a/src/app/commands/inquiry.rs b/src/app/commands/inquiry.rs
index aa9c088a7..161a6c28c 100644
--- a/src/app/commands/inquiry.rs
+++ b/src/app/commands/inquiry.rs
@@ -1,6 +1,82 @@
use super::*;
impl OpenCADStudio {
+ /// Align every selected object or complete group by one edge or center.
+ fn align_selected_bounds(&mut self, i: usize, command: &str) {
+ use crate::command::EntityTransform;
+ use cadkernel::space::BoundsAlignment;
+ use glam::DVec3;
+
+ let (alignment, label) = match command {
+ "ALIGNLEFT" => (BoundsAlignment::Left, "Align Left"),
+ "ALIGNHCENTER" => (BoundsAlignment::HorizontalCenter, "Align Horizontal Centers"),
+ "ALIGNRIGHT" => (BoundsAlignment::Right, "Align Right"),
+ "ALIGNTOP" => (BoundsAlignment::Top, "Align Top"),
+ "ALIGNVCENTER" => (BoundsAlignment::VerticalCenter, "Align Vertical Centers"),
+ "ALIGNBOTTOM" => (BoundsAlignment::Bottom, "Align Bottom"),
+ _ => return,
+ };
+
+ let handles: Vec<_> = self.tabs[i]
+ .scene
+ .selected_handles_in_order()
+ .into_iter()
+ .filter(|handle| !self.tabs[i].scene.is_layer_locked(*handle))
+ .collect();
+ if handles.len() < 2 {
+ self.command_line
+ .push_info(crate::t!("Select objects").as_ref());
+ return;
+ }
+
+ let bounds: Vec<_> = self.tabs[i]
+ .scene
+ .selected_object_units(&handles)
+ .into_iter()
+ .filter_map(|unit| {
+ let mut min_x = f64::INFINITY;
+ let mut min_y = f64::INFINITY;
+ let mut max_x = f64::NEG_INFINITY;
+ let mut max_y = f64::NEG_INFINITY;
+ for handle in &unit {
+ let entity = self.tabs[i].scene.document.get_entity(*handle)?;
+ let bb = entity.as_entity().bounding_box();
+ min_x = min_x.min(bb.min.x);
+ min_y = min_y.min(bb.min.y);
+ max_x = max_x.max(bb.max.x);
+ max_y = max_y.max(bb.max.y);
+ }
+ let bounds = [min_x, min_y, max_x, max_y];
+ bounds
+ .iter()
+ .all(|value| value.is_finite())
+ .then_some((unit, bounds))
+ })
+ .collect();
+ if bounds.len() < 2 {
+ return;
+ }
+
+ let extents: Vec<_> = bounds.iter().map(|(_, bounds)| *bounds).collect();
+ let offsets = cadkernel::space::align_aabbs_2d(&extents, alignment)
+ .expect("validated at least two finite bounds");
+ let pending = self.begin_undo(i, label, handles.len(), true);
+ for ((unit, _), [dx, dy]) in bounds.iter().zip(offsets) {
+ self.tabs[i].scene.transform_entities(
+ unit,
+ &EntityTransform::Translate(DVec3::new(dx, dy, 0.0)),
+ );
+ }
+ self.tabs[i].dirty = true;
+ self.refresh_properties();
+ if let Some(pending) = pending {
+ self.commit_undo_delta(i, pending);
+ }
+ self.command_line.push_output(
+ crate::tf!("{command}: aligned {} object(s).", bounds.len()).as_ref(),
+ );
+ }
+
pub(super) fn dispatch_inquiry(&mut self, cmd: &str, i: usize) -> Option> {
match cmd {
"3DORBIT" => {
@@ -980,6 +1056,11 @@ impl OpenCADStudio {
self.tabs[i].active_cmd = Some(Box::new(cmd));
}
+ "ALIGNLEFT" | "ALIGNHCENTER" | "ALIGNRIGHT" | "ALIGNTOP" | "ALIGNVCENTER"
+ | "ALIGNBOTTOM" => {
+ self.align_selected_bounds(i, cmd);
+ }
+
"LENGTHEN" => {
use crate::modules::draw::modify::lengthen::LengthenCommand;
let cmd = LengthenCommand::new();
@@ -2211,3 +2292,97 @@ mod flatten_tests {
);
}
}
+
+#[cfg(test)]
+mod align_selected_bounds_tests {
+ use super::*;
+ use acadrust::entities::{EntityType, Line};
+ use acadrust::types::Vector3;
+
+ fn add_line(app: &mut OpenCADStudio, x1: f64, y1: f64, x2: f64, y2: f64) -> acadrust::Handle {
+ app.tabs[app.active_tab]
+ .scene
+ .add_entity(EntityType::Line(Line::from_points(
+ Vector3::new(x1, y1, 0.0),
+ Vector3::new(x2, y2, 0.0),
+ )))
+ }
+
+ fn line_start_x(app: &OpenCADStudio, handle: acadrust::Handle) -> f64 {
+ match app.tabs[app.active_tab].scene.document.get_entity(handle) {
+ Some(EntityType::Line(l)) => l.start.x.min(l.end.x),
+ other => panic!("expected a Line, got {other:?}"),
+ }
+ }
+
+ fn line_max_y(app: &OpenCADStudio, handle: acadrust::Handle) -> f64 {
+ match app.tabs[app.active_tab].scene.document.get_entity(handle) {
+ Some(EntityType::Line(l)) => l.start.y.max(l.end.y),
+ other => panic!("expected a Line, got {other:?}"),
+ }
+ }
+
+ /// A single selected object has no "other object" to align to — refuse
+ /// with an informational message rather than silently moving nothing
+ /// (or panicking on the empty-bounds case).
+ #[test]
+ fn refuses_with_fewer_than_two_selected_objects() {
+ let mut app = OpenCADStudio::new_for_test();
+ let _ = app.automation_op(r#"{"op":"new"}"#);
+ let a = add_line(&mut app, 0.0, 0.0, 2.0, 1.0);
+ app.tabs[app.active_tab].scene.select_entities(&[a]);
+ let i = app.active_tab;
+
+ app.dispatch_inquiry("ALIGNLEFT", i);
+ assert_eq!(line_start_x(&app, a), 0.0, "the lone object must not move");
+ }
+
+ /// ALIGNLEFT moves every selected object's left edge to the leftmost
+ /// edge already present in the selection; ALIGNTOP does the same for
+ /// the topmost edge. Both are undoable as one step.
+ #[test]
+ fn aligns_left_and_top_edges_and_is_undoable() {
+ let mut app = OpenCADStudio::new_for_test();
+ let _ = app.automation_op(r#"{"op":"new"}"#);
+ let left = add_line(&mut app, 0.0, 0.0, 1.0, 1.0); // leftmost & topmost already
+ let right = add_line(&mut app, 5.0, -3.0, 8.0, -2.0); // further right and lower
+ app.tabs[app.active_tab].scene.select_entities(&[left, right]);
+ let i = app.active_tab;
+
+ app.dispatch_inquiry("ALIGNLEFT", i);
+ assert_eq!(line_start_x(&app, left), 0.0, "the already-leftmost object must not move");
+ assert_eq!(line_start_x(&app, right), 0.0, "the other object's left edge should meet it");
+
+ app.dispatch_inquiry("ALIGNTOP", i);
+ assert_eq!(line_max_y(&app, left), 1.0, "the already-topmost object must not move");
+ assert_eq!(line_max_y(&app, right), 1.0, "the other object's top edge should meet it");
+
+ app.undo_steps(1); // undo ALIGNTOP
+ assert_eq!(line_max_y(&app, right), -2.0, "undo should restore the pre-ALIGNTOP position");
+ app.undo_steps(1); // undo ALIGNLEFT
+ assert_eq!(line_start_x(&app, right), 5.0, "undo should restore the original geometry");
+ }
+
+ /// A complete, fully-selected group (`Scene::selected_object_units`)
+ /// moves as one rigid unit instead of each member line sliding to meet
+ /// the *other* members of its own group.
+ #[test]
+ fn a_complete_group_aligns_as_one_rigid_unit() {
+ let mut app = OpenCADStudio::new_for_test();
+ let _ = app.automation_op(r#"{"op":"new"}"#);
+ let a = add_line(&mut app, 5.0, 0.0, 6.0, 1.0);
+ let b = add_line(&mut app, 7.0, 0.0, 8.0, 1.0);
+ let other = add_line(&mut app, 0.0, 0.0, 1.0, 1.0);
+ app.tabs[app.active_tab].scene.create_group("pair".to_string(), vec![a, b]);
+ app.tabs[app.active_tab].scene.select_entities(&[a, b, other]);
+ let i = app.active_tab;
+
+ app.dispatch_inquiry("ALIGNLEFT", i);
+ // The group's own left edge (a's, at x=5) moves to meet `other`'s
+ // left edge (x=0): a shifts by -5, and b — sharing the same
+ // transform — must shift by exactly the same amount, not collapse
+ // onto `a`.
+ assert_eq!(line_start_x(&app, a), 0.0);
+ assert_eq!(line_start_x(&app, b), 2.0, "b must keep its offset from a, not collapse onto it");
+ }
+}
diff --git a/src/app/commands/styleprops.rs b/src/app/commands/styleprops.rs
index 9fed425e9..751d2e5d2 100644
--- a/src/app/commands/styleprops.rs
+++ b/src/app/commands/styleprops.rs
@@ -1046,6 +1046,9 @@ impl OpenCADStudio {
| "GRIPHOT"
| "GRIPHOVER"
| "GRIPOBJLIMIT"
+ | "CONSTRAINTSOLVEMODE"
+ | "CONSTRAINTINFER"
+ | "CONSTRAINTBARDISPLAY"
) =>
{
return self.dispatch_styleprops(&format!("SETVAR {cmd}"), i);
@@ -1068,7 +1071,7 @@ impl OpenCADStudio {
let value = it.next().map(|s| s.trim().to_string());
if name.is_empty() || name == "?" {
self.command_line.push_info(
- crate::t!("SETVAR: CETRANSPARENCY LTSCALE CELTSCALE PDMODE PDSIZE TEXTSIZE ORTHOMODE FILLMODE MIRRTEXT FRAME IMAGEFRAME PDFFRAME WIPEOUTFRAME XCLIPFRAME POINTCLOUDCLIPFRAME ZOOMWHEEL ZOOMFACTOR CURSORSIZE PICKBOX CURSORTYPE SNAPANG TEXTFILL CLIPROMPTLINES COMMANDLINEFADETIME ATTREQ ATTDIA DIMASSOC DIMCONTINUEMODE ANGBASE ANGDIR SKETCHINC SKPOLY SKTOLERANCE DONUTID DONUTOD CENTEREXE CENTERLAYER CENTERLTYPE CENTERLTSCALE CENTERLTYPEFILE CENTERCROSSSIZE CENTERCROSSGAP CENTERMARKEXE COLORTHEME SELECTIONAREA SELECTIONAREAOPACITY SELECTIONEFFECT SELECTIONEFFECTCOLOR WINDOWSAREACOLOR CROSSINGAREACOLOR SELECTIONPREVIEW GRIPSIZE GRIPCOLOR GRIPHOT GRIPHOVER GRIPOBJLIMIT | CLAYER CELTYPE TEXTSTYLE (read-only)").as_ref(),
+ crate::t!("SETVAR: CETRANSPARENCY LTSCALE CELTSCALE PDMODE PDSIZE TEXTSIZE ORTHOMODE FILLMODE MIRRTEXT FRAME IMAGEFRAME PDFFRAME WIPEOUTFRAME XCLIPFRAME POINTCLOUDCLIPFRAME ZOOMWHEEL ZOOMFACTOR CURSORSIZE PICKBOX CURSORTYPE SNAPANG TEXTFILL CLIPROMPTLINES COMMANDLINEFADETIME ATTREQ ATTDIA DIMASSOC DIMCONTINUEMODE CONSTRAINTSOLVEMODE CONSTRAINTINFER CONSTRAINTBARDISPLAY ANGBASE ANGDIR SKETCHINC SKPOLY SKTOLERANCE DONUTID DONUTOD CENTEREXE CENTERLAYER CENTERLTYPE CENTERLTSCALE CENTERLTYPEFILE CENTERCROSSSIZE CENTERCROSSGAP CENTERMARKEXE COLORTHEME SELECTIONAREA SELECTIONAREAOPACITY SELECTIONEFFECT SELECTIONEFFECTCOLOR WINDOWSAREACOLOR CROSSINGAREACOLOR SELECTIONPREVIEW GRIPSIZE GRIPCOLOR GRIPHOT GRIPHOVER GRIPOBJLIMIT | CLAYER CELTYPE TEXTSTYLE (read-only)").as_ref(),
);
} else {
if name == "CETRANSPARENCY" {
@@ -1262,6 +1265,50 @@ impl OpenCADStudio {
}
return Some(self.finish_dispatch(cmd));
}
+ if matches!(
+ name.as_str(),
+ "CONSTRAINTSOLVEMODE" | "CONSTRAINTINFER" | "CONSTRAINTBARDISPLAY"
+ ) {
+ let current = match name.as_str() {
+ "CONSTRAINTSOLVEMODE" => i16::from(self.constraint_solve_mode),
+ "CONSTRAINTINFER" => i16::from(self.constraint_infer),
+ "CONSTRAINTBARDISPLAY" => self.constraint_bar_display,
+ _ => unreachable!(),
+ };
+ let maximum = if name == "CONSTRAINTBARDISPLAY" { 3 } else { 1 };
+ if let Some(value) = &value {
+ match value
+ .parse::()
+ .ok()
+ .filter(|value| (0..=maximum).contains(value))
+ {
+ Some(mode) => {
+ match name.as_str() {
+ "CONSTRAINTSOLVEMODE" => {
+ self.constraint_solve_mode = mode != 0
+ }
+ "CONSTRAINTINFER" => self.constraint_infer = mode != 0,
+ "CONSTRAINTBARDISPLAY" => {
+ self.constraint_bar_display = mode
+ }
+ _ => unreachable!(),
+ }
+ self.persist_settings_if_changed();
+ self.command_line
+ .push_output(&crate::tf!("{name} = {mode}"));
+ }
+ None => self.command_line.push_error(&crate::tf!(
+ "{name}: expected an integer from 0 to {maximum}."
+ )),
+ }
+ } else {
+ self.command_line.push_output(crate::tf!(
+ "Enter new value for {name} <{current}>:"
+ ).as_ref());
+ self.pending_setvar = Some(name.clone());
+ }
+ return Some(self.finish_dispatch(cmd));
+ }
if matches!(name.as_str(), "DONUTID" | "DONUTOD") {
let current = if name == "DONUTID" {
crate::modules::draw::defaults::get_donut_inner_diameter()
diff --git a/src/app/control/transport.rs b/src/app/control/transport.rs
index aa29f10ba..adce0eeb7 100644
--- a/src/app/control/transport.rs
+++ b/src/app/control/transport.rs
@@ -52,6 +52,7 @@ fn listen(sender: mpsc::Sender) -> std::io::Result<()> {
}
let mut file = options.open(&path)?;
write!(file, "{descriptor}")?;
+ drop(file);
let clients = Arc::new(AtomicUsize::new(0));
for stream in listener.incoming().flatten() {
if clients.fetch_add(1, Ordering::SeqCst) >= 8 {
diff --git a/src/app/document.rs b/src/app/document.rs
index 6bdcd7329..50d4cfc4b 100644
--- a/src/app/document.rs
+++ b/src/app/document.rs
@@ -6,11 +6,11 @@ use crate::scene::pick::grip::GripEdit;
use crate::scene::GripDef;
use crate::scene::{ObjectIsolationState, Scene};
use crate::snap::SnapResult;
+use crate::t;
use crate::ui::{LayerPanel, PropertiesPanel};
use acadrust::tables::{normalize_name, Ucs};
use acadrust::{CadDocument, EntityType, Handle};
use iced;
-use crate::t;
use std::any::Any;
use std::collections::HashMap;
use std::path::PathBuf;
@@ -240,14 +240,18 @@ impl DocumentTab {
.and_then(|index| self.block_edits.get_mut(index))
}
- /// The [`crate::scene::sketch_constraints::SketchScope`] a new persistent
+ /// The [`crate::scene::parametric_constraints::ParametricScope`] a new persistent
/// constraint should attach to right now — whatever's actually being
/// edited: the open block definition if a BEDIT session is active, model
/// space otherwise.
- pub(super) fn current_sketch_scope(&self) -> crate::scene::sketch_constraints::SketchScope {
+ pub(super) fn current_parametric_scope(
+ &self,
+ ) -> crate::scene::parametric_constraints::ParametricScope {
match self.active_block_edit_session() {
- Some(session) => crate::scene::sketch_constraints::SketchScope::Block(session.br_handle),
- None => crate::scene::sketch_constraints::SketchScope::ModelSpace,
+ Some(session) => {
+ crate::scene::parametric_constraints::ParametricScope::Block(session.br_handle)
+ }
+ None => crate::scene::parametric_constraints::ParametricScope::ModelSpace,
}
}
@@ -291,8 +295,7 @@ impl DocumentTab {
u.origin = h.model_space_ucs_origin;
u.x_axis = h.model_space_ucs_x_axis;
u.y_axis = h.model_space_ucs_y_axis;
- if h.model_space_ucs_name.is_empty()
- && super::helpers::UcsXform::from_ucs(&u).is_identity()
+ if h.model_space_ucs_name.is_empty() && super::helpers::UcsXform::from_ucs(&u).is_identity()
{
None
} else {
@@ -475,31 +478,30 @@ impl DocumentTab {
}
}
} else {
- let (origin, x_axis, y_axis, elevation, ortho, named, base) =
- match &self.active_ucs {
- Some(ucs) => (
- ucs.origin,
- ucs.x_axis,
- ucs.y_axis,
- ucs.elevation,
- ucs.ortho_type,
- if ucs.named_ucs_handle.is_valid() {
- ucs.named_ucs_handle
- } else {
- ucs.handle
- },
- ucs.base_ucs_handle,
- ),
- None => (
- Vector3::ZERO,
- Vector3::UNIT_X,
- Vector3::UNIT_Y,
- 0.0,
- 0,
- Handle::NULL,
- Handle::NULL,
- ),
- };
+ let (origin, x_axis, y_axis, elevation, ortho, named, base) = match &self.active_ucs {
+ Some(ucs) => (
+ ucs.origin,
+ ucs.x_axis,
+ ucs.y_axis,
+ ucs.elevation,
+ ucs.ortho_type,
+ if ucs.named_ucs_handle.is_valid() {
+ ucs.named_ucs_handle
+ } else {
+ ucs.handle
+ },
+ ucs.base_ucs_handle,
+ ),
+ None => (
+ Vector3::ZERO,
+ Vector3::UNIT_X,
+ Vector3::UNIT_Y,
+ 0.0,
+ 0,
+ Handle::NULL,
+ Handle::NULL,
+ ),
+ };
for object in self.scene.document.objects.values_mut() {
let acadrust::objects::ObjectType::Layout(layout) = object else {
continue;
@@ -656,7 +658,7 @@ impl DocumentTab {
#[derive(Clone)]
pub(super) enum HistorySnapshot {
// Boxed: `DeltaSnapshot` grew past the other variants once
- // `sketch_constraints` (ERASE-undo fix) was added, and every undo/redo
+ // `parametric_constraints` (ERASE-undo fix) was added, and every undo/redo
// stack slot costs as much as this enum's largest variant regardless of
// which one it actually holds.
Delta(Box),
@@ -687,41 +689,33 @@ impl HistorySnapshot {
)
.saturating_add(d.selected_before.len().saturating_mul(16))
.saturating_add(d.selected_after.len().saturating_mul(16))
+ .saturating_add(d.active_layer.as_ref().map_or(0, |(before, after)| {
+ before.len().saturating_add(after.len())
+ }))
.saturating_add(
- d.active_layer
- .as_ref()
- .map_or(0, |(before, after)| before.len().saturating_add(after.len())),
- )
- .saturating_add(
- d.sketch_constraints
+ d.parametric_constraints
.iter()
- .map(|entry| entry.before.constraints.len().saturating_add(entry.after.constraints.len()))
+ .map(|entry| {
+ entry
+ .before
+ .constraints
+ .len()
+ .saturating_add(entry.after.constraints.len())
+ })
.sum::()
.saturating_mul(96),
)
- .saturating_add(
- d.named_parameters
- .as_ref()
- .map_or(0, |(before, after)| before.len().saturating_add(after.len()).saturating_mul(128)),
- )
+ .saturating_add(d.named_parameters.as_ref().map_or(0, |(before, after)| {
+ before.len().saturating_add(after.len()).saturating_mul(128)
+ }))
.saturating_add(d.label.len()),
HistorySnapshot::ObjectVisibility(v) => v
.before
.hidden
.len()
- .saturating_add(
- v.before
- .keep
- .as_ref()
- .map_or(0, rustc_hash::FxHashSet::len),
- )
+ .saturating_add(v.before.keep.as_ref().map_or(0, rustc_hash::FxHashSet::len))
.saturating_add(v.after.hidden.len())
- .saturating_add(
- v.after
- .keep
- .as_ref()
- .map_or(0, rustc_hash::FxHashSet::len),
- )
+ .saturating_add(v.after.keep.as_ref().map_or(0, rustc_hash::FxHashSet::len))
.saturating_add(v.selected_before.len())
.saturating_add(v.selected_after.len())
.saturating_mul(16)
@@ -760,12 +754,12 @@ pub(super) struct DeltaSnapshot {
/// Opposite non-entity document state. `apply_delta_state` swaps this with
/// the live structure, so the same allocation shuttles between undo/redo.
pub(super) structure: Option,
- /// Sketch-constraint scopes this same command changed alongside its
+ /// Parametric-constraint scopes this same command changed alongside its
/// entities (e.g. ERASE removing a constraint set's touched constraints)
- /// — `sketch_constraints` lives on `Scene`, not in `document`/
+ /// — `parametric_constraints` lives on `Scene`, not in `document`/
/// `document.objects`, so it needs its own channel here rather than
/// riding along with `entities`/`structure`. Almost always empty.
- pub(super) sketch_constraints: Vec,
+ pub(super) parametric_constraints: Vec,
/// Drawing-wide parameter table changed by this transaction.
pub(super) named_parameters: Option<(
crate::scene::named_parameters::ParameterTable,
@@ -831,13 +825,13 @@ pub(super) struct ObjectEntryDelta {
pub(super) after: Option,
}
-/// One sketch-constraint scope's before/after image within an entity delta.
+/// One parametric-constraint scope's before/after image within an entity delta.
/// This keeps constraint cleanup atomic with edits such as entity erasure.
#[derive(Clone)]
-pub(super) struct SketchConstraintsEntryDelta {
- pub(super) scope: crate::scene::sketch_constraints::SketchScope,
- pub(super) before: crate::scene::sketch_constraints::SketchConstraintSet,
- pub(super) after: crate::scene::sketch_constraints::SketchConstraintSet,
+pub(super) struct ParametricConstraintsEntryDelta {
+ pub(super) scope: crate::scene::parametric_constraints::ParametricScope,
+ pub(super) before: crate::scene::parametric_constraints::ParametricConstraintSet,
+ pub(super) after: crate::scene::parametric_constraints::ParametricConstraintSet,
}
#[derive(Default)]
diff --git a/src/app/history.rs b/src/app/history.rs
index a43d387e0..421c495d0 100644
--- a/src/app/history.rs
+++ b/src/app/history.rs
@@ -1,7 +1,8 @@
use super::{
document::{
DeltaSnapshot, HistorySnapshot, ObjectEntryDelta, ObjectVisibilitySnapshot,
- PendingHistorySnapshot, SketchConstraintsEntryDelta, StructureSnapshot, TableEntryDelta,
+ ParametricConstraintsEntryDelta, PendingHistorySnapshot, StructureSnapshot,
+ TableEntryDelta,
},
OpenCADStudio,
};
@@ -167,8 +168,7 @@ impl OpenCADStudio {
) {
self.finish_pending_history(i);
let after = self.tabs[i].scene.object_isolation.clone();
- let selected_after: Vec =
- self.tabs[i].scene.selected.iter().copied().collect();
+ let selected_after: Vec = self.tabs[i].scene.selected.iter().copied().collect();
if before == after && selected_before == selected_after {
return;
}
@@ -225,7 +225,7 @@ impl OpenCADStudio {
dirty_after: true,
active_layer: None,
structure: (!objects.is_empty()).then_some(StructureSnapshot::Objects(objects)),
- sketch_constraints: Vec::new(),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: label.into(),
};
@@ -233,9 +233,7 @@ impl OpenCADStudio {
}
pub(super) fn defer_live_entity_history_after(&mut self, i: usize, handle: Handle) {
- let Some(HistorySnapshot::Delta(delta)) =
- self.tabs[i].history.undo_stack.last_mut()
- else {
+ let Some(HistorySnapshot::Delta(delta)) = self.tabs[i].history.undo_stack.last_mut() else {
return;
};
if let Some((_, _, after)) = delta
@@ -254,9 +252,7 @@ impl OpenCADStudio {
let selected_after = self.tabs[i].scene.selected.iter().copied().collect();
let current_layout_after = self.tabs[i].scene.current_layout.clone();
let dirty_after = self.tabs[i].dirty;
- let Some(HistorySnapshot::Delta(delta)) =
- self.tabs[i].history.undo_stack.last_mut()
- else {
+ let Some(HistorySnapshot::Delta(delta)) = self.tabs[i].history.undo_stack.last_mut() else {
return;
};
let Some((_, _, entry_after)) = delta
@@ -335,8 +331,9 @@ impl OpenCADStudio {
dirty_after,
active_layer: (pending.active_layer != active_layer_after)
.then_some((pending.active_layer, active_layer_after)),
- structure: structure_changed.then_some(StructureSnapshot::Full(pending.structure_before)),
- sketch_constraints: Vec::new(),
+ structure: structure_changed
+ .then_some(StructureSnapshot::Full(pending.structure_before)),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: pending.label,
};
@@ -445,7 +442,7 @@ impl OpenCADStudio {
dirty_after: self.tabs[i].dirty,
active_layer: None,
structure: Some(StructureSnapshot::Layers(entries)),
- sketch_constraints: Vec::new(),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: pending.label,
};
@@ -502,7 +499,7 @@ impl OpenCADStudio {
dirty_after: self.tabs[i].dirty,
active_layer: None,
structure: Some(StructureSnapshot::TextStyles(entries)),
- sketch_constraints: Vec::new(),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: pending.label,
};
@@ -559,7 +556,7 @@ impl OpenCADStudio {
dirty_after: self.tabs[i].dirty,
active_layer: None,
structure: Some(StructureSnapshot::DimStyles(entries)),
- sketch_constraints: Vec::new(),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: pending.label,
};
@@ -624,7 +621,7 @@ impl OpenCADStudio {
dirty_after: self.tabs[i].dirty,
active_layer: None,
structure: Some(StructureSnapshot::Objects(entries)),
- sketch_constraints: Vec::new(),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: pending.label,
};
@@ -659,7 +656,7 @@ impl OpenCADStudio {
dim_names,
object_handles,
}),
- sketch_constraints: Vec::new(),
+ parametric_constraints: Vec::new(),
named_parameters: None,
label: "STYLE".to_string(),
};
@@ -741,15 +738,16 @@ impl OpenCADStudio {
pending.label
);
}
- let (entity_before, object_before, sketch_constraints_before, named_parameters_before) =
+ let (entity_before, object_before, parametric_constraints_before, named_parameters_before) =
rec.into_recorded_images();
- let entities: Vec<(Handle, Option>, Option>)> = entity_before
- .into_iter()
- .map(|(h, before)| {
- let after = self.tabs[i].scene.document.get_entity_arc(h);
- (h, before, after)
- })
- .collect();
+ let entities: Vec<(Handle, Option>, Option>)> =
+ entity_before
+ .into_iter()
+ .map(|(h, before)| {
+ let after = self.tabs[i].scene.document.get_entity_arc(h);
+ (h, before, after)
+ })
+ .collect();
let objects: Vec = object_before
.into_iter()
.filter_map(|(handle, before)| {
@@ -761,21 +759,28 @@ impl OpenCADStudio {
})
})
.collect();
- let sketch_constraints: Vec = sketch_constraints_before
- .into_iter()
- .filter_map(|(scope, before)| {
- let after = self.tabs[i]
- .scene
- .sketch_constraint_set(scope)
- .cloned()
- .unwrap_or_else(|| crate::scene::sketch_constraints::SketchConstraintSet::new(scope));
- (before.constraints != after.constraints).then_some(SketchConstraintsEntryDelta {
- scope,
- before,
- after,
+ let parametric_constraints: Vec =
+ parametric_constraints_before
+ .into_iter()
+ .filter_map(|(scope, before)| {
+ let after = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .cloned()
+ .unwrap_or_else(|| {
+ crate::scene::parametric_constraints::ParametricConstraintSet::new(
+ scope,
+ )
+ });
+ (before.constraints != after.constraints).then_some(
+ ParametricConstraintsEntryDelta {
+ scope,
+ before,
+ after,
+ },
+ )
})
- })
- .collect();
+ .collect();
let named_parameters = named_parameters_before.and_then(|before| {
let after = self.tabs[i].scene.named_parameters().clone();
(before != after).then_some((before, after))
@@ -815,7 +820,7 @@ impl OpenCADStudio {
dirty_after,
active_layer: None,
structure,
- sketch_constraints,
+ parametric_constraints,
named_parameters,
label: pending.label,
};
@@ -839,9 +844,10 @@ impl OpenCADStudio {
if let Some(structure) = d.structure.as_mut() {
match structure {
StructureSnapshot::Full(stored) => {
- let inverse = self.tabs[i].scene.document.swap_structure(
- std::mem::replace(stored, acadrust::CadDocument::new()),
- );
+ let inverse = self.tabs[i]
+ .scene
+ .document
+ .swap_structure(std::mem::replace(stored, acadrust::CadDocument::new()));
*stored = inverse;
self.tabs[i].scene.invalidate_dependency_index();
}
@@ -945,9 +951,9 @@ impl OpenCADStudio {
}
let changes = self.tabs[i].scene.apply_entity_delta(&d.entities, undo);
let scene = &mut self.tabs[i].scene;
- for entry in &d.sketch_constraints {
+ for entry in &d.parametric_constraints {
let value = if undo { &entry.before } else { &entry.after };
- *scene.sketch_constraint_set_mut(entry.scope) = value.clone();
+ *scene.parametric_constraint_set_mut(entry.scope) = value.clone();
}
if let Some((before, after)) = &d.named_parameters {
scene.named_parameters = if undo { before } else { after }.clone();
@@ -1070,6 +1076,7 @@ impl OpenCADStudio {
}
}
}
+ scene.sync_native_parametric_graph();
scene.clear_preview_wire();
}
// UCS state is cached separately from its persisted header/viewport
@@ -1104,7 +1111,8 @@ impl OpenCADStudio {
let available = self.tabs[i].history.undo_stack.len();
let steps = steps.min(available);
if steps == 0 {
- self.command_line.push_info(crate::t!("Nothing to undo.").as_ref());
+ self.command_line
+ .push_info(crate::t!("Nothing to undo.").as_ref());
return;
}
@@ -1127,14 +1135,15 @@ impl OpenCADStudio {
structure,
StructureSnapshot::Full(_) | StructureSnapshot::Layers(_)
)
- }) || d.active_layer.is_some() || d.entities.iter().any(|(_, before, after)| {
- before
- .as_deref()
- .is_some_and(|entity| matches!(entity, EntityType::Viewport(_)))
- || after
+ }) || d.active_layer.is_some()
+ || d.entities.iter().any(|(_, before, after)| {
+ before
.as_deref()
.is_some_and(|entity| matches!(entity, EntityType::Viewport(_)))
- });
+ || after
+ .as_deref()
+ .is_some_and(|entity| matches!(entity, EntityType::Viewport(_)))
+ });
had_full |= d.structure.as_ref().is_some_and(StructureSnapshot::is_full);
changes.extend(self.apply_delta_state(i, &mut d, true));
self.tabs[i]
@@ -1162,7 +1171,8 @@ impl OpenCADStudio {
let available = self.tabs[i].history.redo_stack.len();
let steps = steps.min(available);
if steps == 0 {
- self.command_line.push_info(crate::t!("Nothing to redo.").as_ref());
+ self.command_line
+ .push_info(crate::t!("Nothing to redo.").as_ref());
return;
}
@@ -1182,14 +1192,15 @@ impl OpenCADStudio {
structure,
StructureSnapshot::Full(_) | StructureSnapshot::Layers(_)
)
- }) || d.active_layer.is_some() || d.entities.iter().any(|(_, before, after)| {
- before
- .as_deref()
- .is_some_and(|entity| matches!(entity, EntityType::Viewport(_)))
- || after
+ }) || d.active_layer.is_some()
+ || d.entities.iter().any(|(_, before, after)| {
+ before
.as_deref()
.is_some_and(|entity| matches!(entity, EntityType::Viewport(_)))
- });
+ || after
+ .as_deref()
+ .is_some_and(|entity| matches!(entity, EntityType::Viewport(_)))
+ });
had_full |= d.structure.as_ref().is_some_and(StructureSnapshot::is_full);
changes.extend(self.apply_delta_state(i, &mut d, false));
self.tabs[i]
diff --git a/src/app/mod.rs b/src/app/mod.rs
index c68bdfa0d..9a5b4ebb8 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -7,6 +7,7 @@ pub(crate) fn automation_action_names() -> &'static [&'static str] {
pub(crate) mod config;
#[cfg(not(target_arch = "wasm32"))]
pub use automation::{export_headless, serve};
+mod annotation_data;
mod command_driver;
pub(crate) mod commands;
pub(crate) mod dim_viewport;
@@ -31,7 +32,6 @@ mod startup;
mod style_ops;
mod text_inline;
mod tolerance_dialog;
-mod annotation_data;
mod update;
mod view;
mod visibility;
@@ -261,12 +261,12 @@ pub(crate) enum FindMatchKey {
}
use crate::snap::Snapper;
use crate::ui::{CommandLine, Ribbon, StatusBar};
-use acadrust::CadDocument;
use acadrust::types::{Color as AcadColor, LineWeight};
+use acadrust::CadDocument;
use iced::time::Instant;
use iced::window;
-use iced::{Point, Task, Theme, mouse};
+use iced::{mouse, Point, Task, Theme};
use std::sync::Arc;
pub(super) const POLY_START_DELAY_MS: u128 = 150;
@@ -553,14 +553,18 @@ pub(super) struct OpenCADStudio {
/// When true (default), the app registers itself as a .dwg/.dxf/.bak file
/// handler on each launch. Toggle with the FILEASSOC command.
pub file_assoc_enabled: bool,
- /// When true, saving creates native constraint objects alongside the
- /// application's own persistence record. Existing native objects remain
- /// synchronized regardless of this setting.
- pub write_dwg_native_constraints: bool,
- /// When true (default), a sketch constraint's viewport pill shows its
+ /// When true (default), a parametric constraint's viewport pill shows its
/// glyph plus a driven value or named-parameter name. When false, every
/// pill shows only the glyph.
pub show_constraint_values: bool,
+ pub auto_constrain_settings: settings::AutoConstrainSettings,
+ auto_constrain_saved: Option,
+ auto_constrain_selected_row: usize,
+ auto_constrain_distance_input: String,
+ auto_constrain_angle_input: String,
+ pub constraint_solve_mode: bool,
+ pub constraint_infer: bool,
+ pub constraint_bar_display: i16,
/// Minutes between autosaves to a `.sv$` recovery file (SAVETIME command);
/// 0 disables autosave.
pub savetime_min: i32,
@@ -1746,6 +1750,7 @@ pub enum ModalKind {
DrawingUnits,
GeometricTolerance,
DraftingSettings,
+ AutoConstrainSettings,
LayerStateEditor,
Plot,
PrintAll,
@@ -2138,8 +2143,6 @@ pub enum Message {
/// Register or unregister as the .dwg/.dxf handler, from Options. Same
/// setting the FILEASSOC command carries.
FileAssocChanged(bool),
- /// Toggle writing native constraint objects on save.
- WriteDwgNativeConstraintsChanged(bool),
/// Toggle showing driven values/named-parameter names on constraint
/// pills, from Options. See `show_constraint_values`'s doc comment.
ShowConstraintValuesChanged(bool),
@@ -2567,9 +2570,9 @@ pub enum Message {
/// Cycle the coordinate readout mode ($COORDS): static → live → polar.
CycleCoordsMode,
/// Removes one flagged redundant or conflicting constraint from the
- /// current sketch scope.
+ /// current parametric scope.
/// No-op if the scope currently has no flagged conflict.
- ResolveOneSketchConflict,
+ ResolveOneParametricConflict,
/// Toggle the status-bar customization menu open/closed.
ToggleStatusBarMenu,
/// Close the status-bar customization menu.
@@ -2666,6 +2669,20 @@ pub enum Message {
DraftingSettingsClose,
DraftingSettingsCloseDiscard,
DraftingSettingsCloseKeep,
+ AutoConstrainSelectRow(usize),
+ AutoConstrainToggleKind(settings::AutoConstraintKind),
+ AutoConstrainMoveUp,
+ AutoConstrainMoveDown,
+ AutoConstrainSelectAll,
+ AutoConstrainClearAll,
+ AutoConstrainReset,
+ AutoConstrainToggleTangentPoint,
+ AutoConstrainTogglePerpendicularIntersection,
+ AutoConstrainDistanceChanged(String),
+ AutoConstrainAngleChanged(String),
+ AutoConstrainApply,
+ AutoConstrainOk,
+ AutoConstrainCancel,
/// Toggle a ribbon dropdown open/closed.
ToggleRibbonDropdown(String),
/// Toggle a collapsed ribbon panel's flyout open/closed (by panel title).
@@ -2928,6 +2945,8 @@ pub enum Message {
/// A Constraints-section row was clicked: select every entity in the
/// list (replacing the current selection) in the viewport.
PropConstraintLinkClick(Vec),
+ /// Remove one parametric constraint selected from Properties or the viewport.
+ PropConstraintDelete(crate::scene::parametric_constraints::ConstraintId),
// ── About window ────────────────────────────────────────────────────
AboutOpen,
// ── Graphics warning ────────────────────────────────────────────────
@@ -3656,8 +3675,15 @@ impl OpenCADStudio {
dimension_continue_mode: 1,
backup_on_save: true,
file_assoc_enabled: true,
- write_dwg_native_constraints: false,
show_constraint_values: true,
+ auto_constrain_settings: settings::AutoConstrainSettings::default(),
+ auto_constrain_saved: None,
+ auto_constrain_selected_row: 0,
+ auto_constrain_distance_input: "0.05".to_string(),
+ auto_constrain_angle_input: "1".to_string(),
+ constraint_solve_mode: true,
+ constraint_infer: false,
+ constraint_bar_display: 3,
savetime_min: 10,
default_bg_color: None,
default_paper_bg_color: None,
diff --git a/src/app/properties.rs b/src/app/properties.rs
index 7096e7b03..a942c5ca6 100644
--- a/src/app/properties.rs
+++ b/src/app/properties.rs
@@ -1,10 +1,10 @@
use super::helpers::{entity_type_key, entity_type_label, title_case_word};
use super::{OpenCADStudio, VARIES_LABEL};
use crate::io::linetypes;
-use crate::scene::view::dispatch;
use crate::scene::model::object::PropValue;
-use crate::ui;
+use crate::scene::view::dispatch;
use crate::t;
+use crate::ui;
use acadrust::types::{Transform, Vector3};
use acadrust::{Entity, EntityType, Handle};
@@ -37,9 +37,7 @@ impl OpenCADStudio {
// building the panel, and syncing the ribbon.
let t_all = crate::perf::enabled().then(iced::time::Instant::now);
let i = self.active_tab;
- if !crate::entities::object_data::cache_is_prepared(
- &self.tabs[i].scene.object_data_cache,
- ) {
+ if !crate::entities::object_data::cache_is_prepared(&self.tabs[i].scene.object_data_cache) {
self.tabs[i].scene.object_data_cache =
crate::entities::object_data::build_cache(&self.tabs[i].scene.document);
}
@@ -153,7 +151,9 @@ impl OpenCADStudio {
}
_ => None,
});
- vertex_count.map_or(prop_vertex, |count| prop_vertex.min(count.saturating_sub(1)))
+ vertex_count.map_or(prop_vertex, |count| {
+ prop_vertex.min(count.saturating_sub(1))
+ })
} else {
prop_vertex
};
@@ -202,9 +202,7 @@ impl OpenCADStudio {
} else if !header.current_linetype_handle.is_null() {
doc.line_types
.iter()
- .find(|line_type| {
- line_type.handle == header.current_linetype_handle
- })
+ .find(|line_type| line_type.handle == header.current_linetype_handle)
.map(|line_type| line_type.name.clone())
.unwrap_or_else(|| "ByLayer".to_string())
} else {
@@ -308,7 +306,10 @@ impl OpenCADStudio {
PropSection {
title: t!("General").into_owned(),
props: vec![
- read_only(t!("AC Version").as_ref(), doc.version.as_str().to_string()),
+ read_only(
+ t!("AC Version").as_ref(),
+ doc.version.as_str().to_string(),
+ ),
Property {
label: t!("Color").into_owned(),
field: "color",
@@ -341,11 +342,20 @@ impl OpenCADStudio {
label: t!("Transparency").into_owned(),
field: "transparency",
value: PropValue::EditChoice {
- value: crate::scene::creation_style::current_transparency_label(self.tabs[i].scene.document.current_entity_transparency()),
+ value:
+ crate::scene::creation_style::current_transparency_label(
+ self.tabs[i]
+ .scene
+ .document
+ .current_entity_transparency(),
+ ),
options: vec!["ByLayer".to_string(), "ByBlock".to_string()],
},
},
- read_only(t!("Thickness").as_ref(), format_length(header.thickness)),
+ read_only(
+ t!("Thickness").as_ref(),
+ format_length(header.thickness),
+ ),
],
},
PropSection {
@@ -440,7 +450,8 @@ impl OpenCADStudio {
label: t!("UCS icon On").into_owned(),
field: "view_ucs_icon_on",
value: PropValue::Choice {
- selected: if ucs_icon_on { "Yes" } else { "No" }.to_string(),
+ selected: if ucs_icon_on { "Yes" } else { "No" }
+ .to_string(),
options: vec!["Yes".to_string(), "No".to_string()],
},
},
@@ -448,7 +459,8 @@ impl OpenCADStudio {
label: t!("UCS icon at origin").into_owned(),
field: "view_ucs_icon_at_origin",
value: PropValue::Choice {
- selected: if ucs_icon_at_origin { "Yes" } else { "No" }.to_string(),
+ selected: if ucs_icon_at_origin { "Yes" } else { "No" }
+ .to_string(),
options: vec!["Yes".to_string(), "No".to_string()],
},
},
@@ -456,7 +468,8 @@ impl OpenCADStudio {
label: t!("UCS per viewport").into_owned(),
field: "view_ucs_per_viewport",
value: PropValue::Choice {
- selected: if ucs_per_viewport { "Yes" } else { "No" }.to_string(),
+ selected: if ucs_per_viewport { "Yes" } else { "No" }
+ .to_string(),
options: vec!["Yes".to_string(), "No".to_string()],
},
},
@@ -471,6 +484,41 @@ impl OpenCADStudio {
},
],
},
+ PropSection {
+ title: t!("Parameters").into_owned(),
+ props: {
+ let mut props = vec![Property {
+ label: String::new(),
+ field: "show_constraint_values",
+ value: PropValue::ParamsVisibilityToggle(
+ self.show_constraint_values,
+ ),
+ }];
+ props.extend(scene
+ .named_parameters()
+ .iter()
+ .enumerate()
+ .map(|(index, parameter)| Property {
+ label: String::new(),
+ field: "named_parameter",
+ value: PropValue::ParamRow {
+ index,
+ name: parameter.name.clone(),
+ formula: parameter.source.clone(),
+ resolved: scene
+ .named_parameters()
+ .resolve(¶meter.name)
+ .map_err(|error| error.to_string()),
+ },
+ }));
+ props.push(Property {
+ label: String::new(),
+ field: "named_parameter_add",
+ value: PropValue::ParamAddRow,
+ });
+ props
+ },
+ },
];
ui::PropertiesPanel {
title: t!("No selection").into_owned(),
@@ -478,7 +526,9 @@ impl OpenCADStudio {
.iter()
.flat_map(|section| section.props.iter())
.filter_map(|prop| match &prop.value {
- crate::scene::model::object::PropValue::Choice { options, .. } => Some((
+ crate::scene::model::object::PropValue::Choice {
+ options, ..
+ } => Some((
prop.field.to_string(),
iced::widget::combo_box::State::new(
options
@@ -493,9 +543,7 @@ impl OpenCADStudio {
.collect(),
sections,
layer_combo: iced::widget::combo_box::State::new(layer_names.clone()),
- linetype_combo: iced::widget::combo_box::State::new(
- linetype_items.clone(),
- ),
+ linetype_combo: iced::widget::combo_box::State::new(linetype_items.clone()),
lineweight_combo: iced::widget::combo_box::State::new(
ui::properties::lw_options(),
),
@@ -515,7 +563,8 @@ impl OpenCADStudio {
} else {
crate::command::WorkingPlane::default()
};
- let display_entity = dispatch::entity_in_working_plane(contextual.as_ref(), plane);
+ let display_entity =
+ dispatch::entity_in_working_plane(contextual.as_ref(), plane);
let entity = &display_entity;
let group_names = self.tabs[i].scene.group_names_for_entity(handle);
let compact_solid =
@@ -528,12 +577,10 @@ impl OpenCADStudio {
if compact_solid {
retain_compact_solid_sections(&mut sections);
}
- sections.extend(
- crate::scene::model::solid_history::primitive_properties(
- &self.tabs[i].scene.document,
- handle,
- ),
- );
+ sections.extend(crate::scene::model::solid_history::primitive_properties(
+ &self.tabs[i].scene.document,
+ handle,
+ ));
// Turn the Material row into an editable picker: the source
// options (ByLayer / ByBlock) plus every named material the
@@ -606,10 +653,11 @@ impl OpenCADStudio {
if let Some(row) =
section.props.iter_mut().find(|row| row.field == "color")
{
- row.value = crate::scene::model::object::PropValue::NamedColorChoice {
- color,
- name: color_name.clone(),
- };
+ row.value =
+ crate::scene::model::object::PropValue::NamedColorChoice {
+ color,
+ name: color_name.clone(),
+ };
}
}
use crate::entities::common::ro_prop;
@@ -788,7 +836,12 @@ impl OpenCADStudio {
metrics
.principal_directions
.chunks_exact(3)
- .map(|axis| format!("({:.6}, {:.6}, {:.6})", axis[0], axis[1], axis[2]))
+ .map(|axis| {
+ format!(
+ "({:.6}, {:.6}, {:.6})",
+ axis[0], axis[1], axis[2]
+ )
+ })
.collect::>()
.join(", "),
),
@@ -829,12 +882,21 @@ impl OpenCADStudio {
}
if !compact_solid {
- sections.extend(crate::entities::object_data::sections(
+ let mut object_sections = crate::entities::object_data::sections(
&self.tabs[i].scene.document,
&self.tabs[i].scene.object_data_cache,
handle,
entity,
- ));
+ );
+ let scope = self.tabs[i].current_parametric_scope();
+ let constrained = self.tabs[i]
+ .scene
+ .parametric_constraint_set(scope)
+ .is_some_and(|set| set.constraints_touching(handle).next().is_some());
+ if constrained {
+ object_sections.retain(|section| section.title != "Associative Data");
+ }
+ sections.extend(object_sections);
}
{
@@ -870,11 +932,9 @@ impl OpenCADStudio {
if let acadrust::EntityType::Insert(ins) = entity {
let eq = (ins.x_scale() - ins.y_scale()).abs() < 1e-12
&& (ins.x_scale() - ins.z_scale()).abs() < 1e-12;
- let uniform =
- eq && !self.props_asym_scale.contains(&handle.value());
+ let uniform = eq && !self.props_asym_scale.contains(&handle.value());
for section in sections.iter_mut() {
- let Some(xi) =
- section.props.iter().position(|p| p.field == "x_scale")
+ let Some(xi) = section.props.iter().position(|p| p.field == "x_scale")
else {
continue;
};
@@ -930,12 +990,14 @@ impl OpenCADStudio {
_ => common
.plotstyle_handle
.and_then(|ph| {
- crate::scene::annotative::as_dict(doc, dict_h).and_then(|dict| {
- dict.entries
- .iter()
- .find(|(_, h)| *h == ph)
- .map(|(n, _)| n.clone())
- })
+ crate::scene::annotative::as_dict(doc, dict_h).and_then(
+ |dict| {
+ dict.entries
+ .iter()
+ .find(|(_, h)| *h == ph)
+ .map(|(n, _)| n.clone())
+ },
+ )
})
.unwrap_or_else(|| "ByLayer".to_string()),
};
@@ -1025,19 +1087,28 @@ impl OpenCADStudio {
let cur_tstyle = ml
.text_style_handle
.and_then(|h| {
- doc.text_styles.iter().find(|s| s.handle == h).map(|s| s.name.clone())
+ doc.text_styles
+ .iter()
+ .find(|s| s.handle == h)
+ .map(|s| s.name.clone())
})
.unwrap_or_else(|| "Standard".to_string());
let cur_arrow = ml
.arrowhead_handle
.and_then(|h| {
- doc.block_records.iter().find(|b| b.handle == h).map(|b| b.name.clone())
+ doc.block_records
+ .iter()
+ .find(|b| b.handle == h)
+ .map(|b| b.name.clone())
})
.unwrap_or_else(|| "Closed filled".to_string());
let cur_ltype = ml
.line_type_handle
.and_then(|h| {
- doc.line_types.iter().find(|l| l.handle == h).map(|l| l.name.clone())
+ doc.line_types
+ .iter()
+ .find(|l| l.handle == h)
+ .map(|l| l.name.clone())
})
.unwrap_or_else(|| "ByBlock".to_string());
let cur_block = ml
@@ -1231,7 +1302,9 @@ impl OpenCADStudio {
.find(|property| property.field == "style_name")
{
let current = match &prop.value {
- crate::scene::model::object::PropValue::PlainText(s) => s.clone(),
+ crate::scene::model::object::PropValue::PlainText(s) => {
+ s.clone()
+ }
_ => String::new(),
};
prop.value = crate::scene::model::object::PropValue::Choice {
@@ -1262,7 +1335,9 @@ impl OpenCADStudio {
use crate::entities::dim_override as dov;
use crate::scene::model::object::PropValue;
let dim_c = dov::color(&d.base().common.extended_data, dov::DIMCLRD)
- .unwrap_or_else(|| acadrust::types::Color::from_index(style.dimclrd));
+ .unwrap_or_else(|| {
+ acadrust::types::Color::from_index(style.dimclrd)
+ });
set_row_value(
&mut sections,
"dim_line_color",
@@ -1276,11 +1351,7 @@ impl OpenCADStudio {
.unwrap_or_else(|| {
acadrust::types::Color::from_index(inherited)
});
- set_row_value(
- &mut sections,
- field,
- PropValue::ColorChoice(color),
- );
+ set_row_value(&mut sections, field, PropValue::ColorChoice(color));
}
}
}
@@ -1311,9 +1382,7 @@ impl OpenCADStudio {
// insert of it follows). Anonymous (*) and
// xref(-dependent) blocks keep the read-only row.
let regular = |br: &acadrust::tables::BlockRecord| {
- !br.is_anonymous()
- && !br.flags.is_xref
- && !br.name.contains('|')
+ !br.is_anonymous() && !br.flags.is_xref && !br.name.contains('|')
};
let editable = doc
.block_records
@@ -1327,9 +1396,7 @@ impl OpenCADStudio {
.filter(|br| regular(br))
.map(|br| br.name.clone())
.collect();
- options.sort_by(|a, b| {
- a.to_lowercase().cmp(&b.to_lowercase())
- });
+ options.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));
set_row_value(
&mut sections,
"block",
@@ -1379,9 +1446,9 @@ impl OpenCADStudio {
.find(|p| p.field == "dimension_style")
{
let cur = match &p.value {
- crate::scene::model::object::PropValue::PlainText(s) => {
- s.clone()
- }
+ crate::scene::model::object::PropValue::PlainText(
+ s,
+ ) => s.clone(),
_ => ld.dimension_style.clone(),
};
p.value = crate::scene::model::object::PropValue::Choice {
@@ -1456,8 +1523,9 @@ impl OpenCADStudio {
);
// A per-object color override wins over the style.
- let dim_c = dov::color(xd, dov::DIMCLRD)
- .unwrap_or_else(|| acadrust::types::Color::from_index(ds.dimclrd));
+ let dim_c = dov::color(xd, dov::DIMCLRD).unwrap_or_else(|| {
+ acadrust::types::Color::from_index(ds.dimclrd)
+ });
set_row_value(
&mut sections,
"dim_line_color",
@@ -1494,9 +1562,8 @@ impl OpenCADStudio {
acadrust::EntityType::Tolerance(tol) => {
use crate::entities::dim_override as dov;
let style = crate::entities::tolerance::resolve_dim_style(tol, doc);
- let style_name = style
- .map(|entry| entry.name.clone())
- .unwrap_or_else(|| {
+ let style_name =
+ style.map(|entry| entry.name.clone()).unwrap_or_else(|| {
if tol.dimension_style_name.trim().is_empty() {
"Standard".to_string()
} else {
@@ -1524,24 +1591,18 @@ impl OpenCADStudio {
},
);
- let text_style_name = dov::handle(
- &tol.common.extended_data,
- dov::DIMTXSTY,
- )
- .and_then(|handle| {
- doc.text_styles
- .iter()
- .find(|entry| entry.handle == handle)
- })
- .map(|entry| entry.name.clone())
- .or_else(|| style.map(|entry| entry.dimtxsty.clone()))
- .unwrap_or_else(|| "Standard".to_string());
+ let text_style_name =
+ dov::handle(&tol.common.extended_data, dov::DIMTXSTY)
+ .and_then(|handle| {
+ doc.text_styles.iter().find(|entry| entry.handle == handle)
+ })
+ .map(|entry| entry.name.clone())
+ .or_else(|| style.map(|entry| entry.dimtxsty.clone()))
+ .unwrap_or_else(|| "Standard".to_string());
let text_height_editable = doc
.text_styles
.iter()
- .find(|entry| {
- entry.name.eq_ignore_ascii_case(&text_style_name)
- })
+ .find(|entry| entry.name.eq_ignore_ascii_case(&text_style_name))
.is_none_or(|entry| !entry.has_fixed_height());
let mut names = text_style_names.clone();
if !names
@@ -1559,12 +1620,9 @@ impl OpenCADStudio {
},
);
- let height = dov::real(
- &tol.common.extended_data,
- dov::DIMTXT,
- )
- .or_else(|| style.map(|entry| entry.dimtxt))
- .unwrap_or(tol.text_height);
+ let height = dov::real(&tol.common.extended_data, dov::DIMTXT)
+ .or_else(|| style.map(|entry| entry.dimtxt))
+ .unwrap_or(tol.text_height);
set_row_value(
&mut sections,
"tol_text_height",
@@ -1588,9 +1646,9 @@ impl OpenCADStudio {
set_row_value(
&mut sections,
"text_height",
- PropValue::ReadOnly(
- crate::entities::common::format_length(ml.text_height),
- ),
+ PropValue::ReadOnly(crate::entities::common::format_length(
+ ml.text_height,
+ )),
);
}
if let Some(sh) = ml.style_handle {
@@ -1645,15 +1703,16 @@ impl OpenCADStudio {
.table_style_handle
.and_then(|handle| doc.objects.get(&handle))
.and_then(|object| match object {
- acadrust::objects::ObjectType::TableStyle(style) => {
- Some(style)
- }
+ acadrust::objects::ObjectType::TableStyle(style) => Some(style),
_ => None,
});
let selected = selected_style
.map(|style| style.name.clone())
.unwrap_or_else(|| "Standard".to_string());
- if !names.iter().any(|name| name.eq_ignore_ascii_case(&selected)) {
+ if !names
+ .iter()
+ .any(|name| name.eq_ignore_ascii_case(&selected))
+ {
names.insert(0, selected.clone());
}
set_row_value(
@@ -1675,10 +1734,8 @@ impl OpenCADStudio {
table,
selected_style,
);
- let flow_up = crate::entities::table::resolved_flow_up(
- table,
- selected_style,
- );
+ let flow_up =
+ crate::entities::table::resolved_flow_up(table, selected_style);
let (horizontal_margin, vertical_margin) =
crate::entities::table::resolved_table_margins(
table,
@@ -1713,9 +1770,7 @@ impl OpenCADStudio {
let columns = table.column_count();
if columns > 0 {
let cell_index = prop_vertex.min(
- table.row_count()
- .saturating_mul(columns)
- .saturating_sub(1),
+ table.row_count().saturating_mul(columns).saturating_sub(1),
);
let row_index = cell_index / columns;
let column_index = cell_index % columns;
@@ -1796,14 +1851,13 @@ impl OpenCADStudio {
"tbl_cell_text_height",
crate::entities::common::format_length(text_height),
);
- let content_color = local(
- CellStylePropertyFlags::CONTENT_COLOR,
- )
- .map(|style| style.content_color)
- .or_else(|| {
- document_row_style.map(|style| style.text_color)
- })
- .unwrap_or(acadrust::types::Color::ByBlock);
+ let content_color =
+ local(CellStylePropertyFlags::CONTENT_COLOR)
+ .map(|style| style.content_color)
+ .or_else(|| {
+ document_row_style.map(|style| style.text_color)
+ })
+ .unwrap_or(acadrust::types::Color::ByBlock);
update_row_color(
&mut sections,
"tbl_cell_content_color",
@@ -1828,8 +1882,7 @@ impl OpenCADStudio {
background_style
.map(|style| style.fill_enabled)
.or_else(|| {
- document_row_style
- .map(|style| style.fill_enabled)
+ document_row_style.map(|style| style.fill_enabled)
})
.unwrap_or(false),
);
@@ -1840,23 +1893,18 @@ impl OpenCADStudio {
.map(|style| style.format_string.clone())
})
.unwrap_or_default();
- update_row_text(
- &mut sections,
- "tbl_cell_format",
- format,
- );
+ update_row_text(&mut sections, "tbl_cell_format", format);
let data_type = cell
.contents
.first()
.map(|content| content.value.value_type)
.filter(|kind| *kind != CellValueType::Unknown)
.or_else(|| {
- local(CellStylePropertyFlags::DATA_TYPE)
- .map(|style| {
- CellValueType::from(
- style.value_data_type.max(0) as u32,
- )
- })
+ local(CellStylePropertyFlags::DATA_TYPE).map(|style| {
+ CellValueType::from(
+ style.value_data_type.max(0) as u32
+ )
+ })
})
.or_else(|| {
document_row_style.map(|style| {
@@ -1927,9 +1975,7 @@ impl OpenCADStudio {
]
.into_iter()
.flatten()
- .find(|style| {
- style.applied_border_edges.contains(edge)
- });
+ .find(|style| style.applied_border_edges.contains(edge));
if let Some(style) = local_style {
return if edge == CellEdgeFlags::TOP {
!style.top_border.invisible
@@ -2006,12 +2052,10 @@ impl OpenCADStudio {
|| match entity {
acadrust::EntityType::Dimension(
acadrust::entities::Dimension::Arc(dimension),
- ) => {
- crate::scene::annotative::dim_style_is_annotative(
- doc,
- &dimension.base.style_name,
- )
- }
+ ) => crate::scene::annotative::dim_style_is_annotative(
+ doc,
+ &dimension.base.style_name,
+ ),
acadrust::EntityType::Tolerance(_) => {
crate::scene::annotative::annotation_style_is_annotative(
doc, entity,
@@ -2087,10 +2131,11 @@ impl OpenCADStudio {
}
}
if is_anno {
- let memberships = crate::scene::annotative::object_scale_memberships(
- doc,
- entity.common().handle,
- );
+ let memberships =
+ crate::scene::annotative::object_scale_memberships(
+ doc,
+ entity.common().handle,
+ );
let assigned_scales = if memberships.is_empty() {
doc.header.current_annotation_scale.clone()
} else {
@@ -2189,53 +2234,6 @@ impl OpenCADStudio {
if compact_solid {
retain_compact_solid_sections(&mut sections);
}
- // Persistent sketch-constraint list for this entity —
- // the Properties-panel analogue of the viewport's
- // constraint glyph pills: one row per constraint
- // touching `handle`, clickable to select every entity
- // it relates (PropConstraintLinkClick). Omitted
- // entirely when the entity has none — an unconstrained
- // entity (the common case) shouldn't gain empty
- // bookkeeping.
- {
- let scope = self.tabs[i].current_sketch_scope();
- let scene = &self.tabs[i].scene;
- if let Some(set) = scene.sketch_constraint_set(scope) {
- let props: Vec = set
- .constraints_touching(handle)
- .map(|c| {
- let conflicting = set.conflicts.iter().any(|(id, _)| *id == c.id);
- let value_suffix = match &c.driving_param {
- Some(crate::scene::named_parameters::DrivingValue::Literal(v)) => {
- format!(" = {v:.2}")
- }
- Some(crate::scene::named_parameters::DrivingValue::Named(name)) => {
- match scene.named_parameters().resolve(name) {
- Ok(v) => format!(" = {name} ({v:.2})"),
- Err(_) => format!(" = {name} (?)"),
- }
- }
- None => String::new(),
- };
- let label = format!("{} {:?}{}", c.kind.glyph_symbol(), c.kind, value_suffix);
- let mut handles: Vec = c.refs.iter().map(|r| r.entity).collect();
- handles.sort_by_key(|h| h.value());
- handles.dedup();
- crate::scene::model::object::Property {
- label,
- field: "sketch_constraint",
- value: crate::scene::model::object::PropValue::EntityLink { handles, conflicting },
- }
- })
- .collect();
- if !props.is_empty() {
- sections.push(crate::scene::model::object::PropSection {
- title: t!("Constraints").into_owned(),
- props,
- });
- }
- }
- }
let title = match entity {
acadrust::EntityType::Insert(ins) => {
let is_xref = self.tabs[i]
@@ -2270,7 +2268,9 @@ impl OpenCADStudio {
.iter()
.flat_map(|section| section.props.iter())
.filter_map(|prop| match &prop.value {
- crate::scene::model::object::PropValue::Choice { options, .. } => Some((
+ crate::scene::model::object::PropValue::Choice {
+ options, ..
+ } => Some((
prop.field.to_string(),
iced::widget::combo_box::State::new(
options
@@ -2335,20 +2335,19 @@ impl OpenCADStudio {
} else {
crate::command::WorkingPlane::default()
};
- let local_entities: Vec<(Handle, std::borrow::Cow<'_, EntityType>)> =
- filtered
- .iter()
- .map(|(handle, entity)| {
- let local = if plane.is_identity() {
- std::borrow::Cow::Borrowed(*entity)
- } else {
- std::borrow::Cow::Owned(
- dispatch::entity_in_working_plane(entity, plane),
- )
- };
- (*handle, local)
- })
- .collect();
+ let local_entities: Vec<(Handle, std::borrow::Cow<'_, EntityType>)> = filtered
+ .iter()
+ .map(|(handle, entity)| {
+ let local = if plane.is_identity() {
+ std::borrow::Cow::Borrowed(*entity)
+ } else {
+ std::borrow::Cow::Owned(dispatch::entity_in_working_plane(
+ entity, plane,
+ ))
+ };
+ (*handle, local)
+ })
+ .collect();
let local_refs: Vec<(Handle, &EntityType)> = local_entities
.iter()
.map(|(handle, entity)| (*handle, entity.as_ref()))
@@ -2381,7 +2380,10 @@ filter={:.1} local={:.1} aggregate={:.1} entities={}",
}
sections.extend(aggregate_solid_history_sections(
&self.tabs[i].scene.document,
- &local_refs.iter().map(|(handle, _)| *handle).collect::>(),
+ &local_refs
+ .iter()
+ .map(|(handle, _)| *handle)
+ .collect::>(),
));
if compact_solids {
retain_compact_solid_sections(&mut sections);
@@ -2391,7 +2393,9 @@ filter={:.1} local={:.1} aggregate={:.1} entities={}",
.iter()
.flat_map(|section| section.props.iter())
.filter_map(|prop| match &prop.value {
- crate::scene::model::object::PropValue::Choice { options, .. } => Some((
+ crate::scene::model::object::PropValue::Choice {
+ options, ..
+ } => Some((
prop.field.to_string(),
iced::widget::combo_box::State::new(
options
@@ -2458,8 +2462,7 @@ filter={:.1} local={:.1} aggregate={:.1} entities={}",
make_sections_read_only(&mut panel.sections);
// Rows demoted to read-only no longer back an editable field;
// drop them from the id→key map so focus can't map onto them.
- panel.field_key_by_id =
- crate::ui::properties::build_field_key_map(&panel.sections);
+ panel.field_key_by_id = crate::ui::properties::build_field_key_map(&panel.sections);
panel.edit_buf.clear();
panel.active_field = None;
panel.color_picker_open = false;
@@ -2624,17 +2627,13 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
let is_paper = self.tabs[i].scene.current_layout != "Model";
// Paper-space entity coordinates are NOT offset by world_offset (same rule
// as wire tessellation in wires_for_block). Only subtract in model space.
- let wo = if is_paper {
- [0.0f64; 3]
- } else {
- [0.0_f64; 3]
- };
+ let wo = if is_paper { [0.0f64; 3] } else { [0.0_f64; 3] };
let (new_handle, new_grips, new_grip_handles) = {
let annotation_scale_handle = self.tabs[i].scene.displayed_annotation_scale_handle();
let selected = self.tabs[i].scene.selected_entities();
let single_handle = (selected.len() == 1
&& !self.tabs[i].scene.is_layer_locked(selected[0].0))
- .then(|| selected[0].0);
+ .then(|| selected[0].0);
let mut grips = Vec::new();
let mut handles = Vec::new();
// Avoid rebuilding every entity's grip markers above the configured
@@ -2729,9 +2728,7 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
.copied()
.zip(self.tabs[i].selected_grips.iter().map(|grip| grip.id))
.collect();
- self.tabs[i]
- .hot_grips
- .retain(|key| available.contains(key));
+ self.tabs[i].hot_grips.retain(|key| available.contains(key));
// Append the dynamic-block visibility (lookup) grip, if the lone
// selection is a visibility-parametric block reference.
self.refresh_visibility_grip(wo);
@@ -2756,6 +2753,25 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
}
pub(super) fn invalidate_property_targets(&mut self, i: usize, handles: &[Handle]) {
+ self.invalidate_property_targets_with_driven(i, handles, &[]);
+ }
+
+ pub(super) fn invalidate_property_targets_with_driven(
+ &mut self,
+ i: usize,
+ handles: &[Handle],
+ driven_refs: &[crate::scene::parametric_constraints::ParametricRef],
+ ) {
+ self.invalidate_property_targets_with_originals(i, handles, driven_refs, &[]);
+ }
+
+ pub(super) fn invalidate_property_targets_with_originals(
+ &mut self,
+ i: usize,
+ handles: &[Handle],
+ driven_refs: &[crate::scene::parametric_constraints::ParametricRef],
+ retained_originals: &[(Handle, acadrust::EntityType)],
+ ) {
let mut context_object_changed = false;
for &handle in handles {
// A dimension is drawn from the block holding its picture, and that
@@ -2768,9 +2784,7 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
) {
self.tabs[i].scene.invalidate_dim_block_recorded(handle);
}
- context_object_changed |= self.tabs[i]
- .scene
- .sync_displayed_annotation_context(handle);
+ context_object_changed |= self.tabs[i].scene.sync_displayed_annotation_context(handle);
// Hatch / SOLID fills render from prebuilt cached models; rebuild
// them or pattern edits (scale, background, …) stay invisible
// (#415).
@@ -2787,7 +2801,14 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
.iter()
.map(|&handle| (handle, crate::scene::ChangeKind::Modified))
.collect();
- self.tabs[i].scene.bump_entities(&changes);
+ self.tabs[i]
+ .scene
+ .bump_entities_with_parametric_originals(
+ &changes,
+ driven_refs,
+ self.constraint_solve_mode && !driven_refs.is_empty(),
+ retained_originals,
+ );
}
/// Apply a single-property edit to every handle in `handles`, recording the
@@ -2826,10 +2847,7 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
/// Like [`commit_entity`] but returns the handle the new entity was given
/// (or `None` if it could not be added). Lets callers follow up — e.g.
/// open the in-place text editor on a freshly created MultiLeader.
- pub(super) fn commit_entity_handle(
- &mut self,
- entity: acadrust::EntityType,
- ) -> Option {
+ pub(super) fn commit_entity_handle(&mut self, entity: acadrust::EntityType) -> Option {
self.commit_entity_handle_with_policies(entity, false, false, false)
}
@@ -2893,9 +2911,7 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
const PREFIX: &str = "__OPENCAD_LINK_PENDING__";
if let Some(path) = table.name.strip_prefix(PREFIX).map(str::to_string) {
use acadrust::entities::table::CellStateFlags;
- use acadrust::objects::{
- ClassObject, ClassObjectData, DataLink, ObjectType,
- };
+ use acadrust::objects::{ClassObject, ClassObjectData, DataLink, ObjectType};
let document = &mut self.tabs[i].scene.document;
let link_handle = document.allocate_handle();
let mut object = ClassObject::new(ClassObjectData::DataLink(DataLink {
@@ -2997,7 +3013,11 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
// CELTSCALE (header.current_entity_linetype_scale): new entities
// pick up the document's saved per-entity linetype scale. The user
// can override per entity later via the properties panel.
- let celtscale = self.tabs[i].scene.document.header.current_entity_linetype_scale;
+ let celtscale = self.tabs[i]
+ .scene
+ .document
+ .header
+ .current_entity_linetype_scale;
if (celtscale - 1.0).abs() > 1e-9 && celtscale.abs() > 1e-9 {
entity.common_mut().linetype_scale = celtscale;
}
@@ -3019,12 +3039,12 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
// Smart centre objects carry their own drawing-level creation style.
// Apply it after the generic ribbon style so ordinary LINE entities
// keep the existing path while centre lines honour their settings.
- let center_line = acadrust::entities::CenterLineAssociation::read(
- &entity.common().extended_data,
- ).is_some();
- let center_mark = acadrust::entities::CenterMarkAssociation::read(
- &entity.common().extended_data,
- ).is_some();
+ let center_line =
+ acadrust::entities::CenterLineAssociation::read(&entity.common().extended_data)
+ .is_some();
+ let center_mark =
+ acadrust::entities::CenterMarkAssociation::read(&entity.common().extended_data)
+ .is_some();
if center_line || center_mark {
let settings = self.tabs[i].scene.centerline_settings();
if !settings.layer.eq_ignore_ascii_case("Current") {
@@ -3039,12 +3059,7 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
} else {
acadrust::entities::CENTERLINE_XDATA_APPLICATION
};
- if !self.tabs[i]
- .scene
- .document
- .app_ids
- .contains(application)
- {
+ if !self.tabs[i].scene.document.app_ids.contains(application) {
let mut app = acadrust::tables::AppId::new(application);
app.handle = self.tabs[i].scene.document.allocate_handle();
let _ = self.tabs[i].scene.document.app_ids.add(app);
@@ -3052,12 +3067,10 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
}
let text_style_annotative = match &entity {
- acadrust::EntityType::Text(text) => {
- crate::scene::annotative::text_style_is_annotative(
- &self.tabs[i].scene.document,
- &text.style,
- )
- }
+ acadrust::EntityType::Text(text) => crate::scene::annotative::text_style_is_annotative(
+ &self.tabs[i].scene.document,
+ &text.style,
+ ),
acadrust::EntityType::MText(text) => {
crate::scene::annotative::text_style_is_annotative(
&self.tabs[i].scene.document,
@@ -3090,13 +3103,12 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
_ => {}
}
}
- let needs_annotation_context = crate::scene::annotative::is_annotative(
- &self.tabs[i].scene.document,
- &entity,
- ) || crate::scene::annotative::annotation_style_is_annotative(
- &self.tabs[i].scene.document,
- &entity,
- );
+ let needs_annotation_context =
+ crate::scene::annotative::is_annotative(&self.tabs[i].scene.document, &entity)
+ || crate::scene::annotative::annotation_style_is_annotative(
+ &self.tabs[i].scene.document,
+ &entity,
+ );
let new_handle = if matches!(&entity, acadrust::EntityType::Viewport(_))
&& self.tabs[i].scene.current_layout != "Model"
@@ -3181,9 +3193,7 @@ handles={handles_ms:.1} panel={:.1} ribbon={ribbon_ms:.1} tail={:.1} selected={}
}
}
-fn make_sections_read_only(
- sections: &mut [crate::scene::model::object::PropSection],
-) {
+fn make_sections_read_only(sections: &mut [crate::scene::model::object::PropSection]) {
use crate::scene::model::object::PropValue;
for property in sections
@@ -3208,15 +3218,13 @@ fn make_sections_read_only(
acadrust::types::Color::Rgb { r, g, b } => format!("{r},{g},{b}"),
},
PropValue::NamedColorChoice { name, .. } => name.clone(),
- PropValue::ColorVaries
- | PropValue::LwVaries
- | PropValue::FieldLwVaries { .. } => VARIES_LABEL.to_string(),
+ PropValue::ColorVaries | PropValue::LwVaries | PropValue::FieldLwVaries { .. } => {
+ VARIES_LABEL.to_string()
+ }
PropValue::LwChoice(lineweight)
| PropValue::FieldLwChoice {
value: lineweight, ..
- } => {
- ui::properties::LwItem(*lineweight).to_string()
- }
+ } => ui::properties::LwItem(*lineweight).to_string(),
PropValue::BoolToggle { value, .. } => {
if *value { t!("Yes") } else { t!("No") }.into_owned()
}
@@ -3231,6 +3239,9 @@ fn make_sections_read_only(
PropValue::EntityLink { handles, .. } => format!("{} entity link(s)", handles.len()),
PropValue::ParamRow { name, formula, .. } => format!("{name} = {formula}"),
PropValue::ParamAddRow => String::new(),
+ PropValue::ParamsVisibilityToggle(value) => {
+ if *value { t!("On") } else { t!("Off") }.into_owned()
+ }
};
property.field = "locked_read_only";
property.value = PropValue::ReadOnly(text);
@@ -3312,9 +3323,9 @@ fn aggregate_solid_history_sections(
document: &acadrust::CadDocument,
handles: &[Handle],
) -> Vec {
- let mut sections = handles.iter().map(|handle| {
- crate::scene::model::solid_history::primitive_properties(document, *handle)
- });
+ let mut sections = handles
+ .iter()
+ .map(|handle| crate::scene::model::solid_history::primitive_properties(document, *handle));
let Some(mut merged) = sections.next() else {
return Vec::new();
};
@@ -3330,9 +3341,7 @@ fn aggregate_solid_history_sections(
merged
}
-fn retain_compact_solid_sections(
- sections: &mut Vec,
-) {
+fn retain_compact_solid_sections(sections: &mut Vec) {
sections.iter_mut().for_each(|section| {
let internal_surface_section = section
.props
@@ -3419,12 +3428,10 @@ fn merge_prop_value(
(
PropValue::FieldLwChoice { field, .. },
PropValue::FieldLwChoice {
- field: other_field,
- ..
+ field: other_field, ..
},
) if field == other_field => PropValue::FieldLwVaries { field },
- (PropValue::FieldLwVaries { field }, _)
- | (_, PropValue::FieldLwVaries { field }) => {
+ (PropValue::FieldLwVaries { field }, _) | (_, PropValue::FieldLwVaries { field }) => {
PropValue::FieldLwVaries { field }
}
(PropValue::LinetypeChoice(_), PropValue::LinetypeChoice(_)) => {
@@ -3504,11 +3511,7 @@ fn merge_prop_value(
/// Set the first property row matching `field` (across all sections) to a
/// read-only `value`. No-op when the field is absent. Used to fill the
/// doc-dependent placeholder rows the entity builders leave empty.
-fn set_row(
- sections: &mut [crate::scene::model::object::PropSection],
- field: &str,
- value: String,
-) {
+fn set_row(sections: &mut [crate::scene::model::object::PropSection], field: &str, value: String) {
for section in sections.iter_mut() {
if let Some(row) = section.props.iter_mut().find(|p| p.field == field) {
row.value = crate::scene::model::object::PropValue::ReadOnly(value);
@@ -3539,7 +3542,11 @@ fn update_row_text(
) {
use crate::scene::model::object::PropValue;
for section in sections.iter_mut() {
- let Some(row) = section.props.iter_mut().find(|property| property.field == field) else {
+ let Some(row) = section
+ .props
+ .iter_mut()
+ .find(|property| property.field == field)
+ else {
continue;
};
match &mut row.value {
@@ -3561,7 +3568,11 @@ fn update_row_toggle(
) {
use crate::scene::model::object::PropValue;
for section in sections.iter_mut() {
- let Some(row) = section.props.iter_mut().find(|property| property.field == field) else {
+ let Some(row) = section
+ .props
+ .iter_mut()
+ .find(|property| property.field == field)
+ else {
continue;
};
match &mut row.value {
@@ -3592,14 +3603,16 @@ fn update_row_color(
acadrust::types::Color::Rgb { r, g, b } => format!("{r},{g},{b}"),
};
for section in sections.iter_mut() {
- let Some(row) = section.props.iter_mut().find(|property| property.field == field) else {
+ let Some(row) = section
+ .props
+ .iter_mut()
+ .find(|property| property.field == field)
+ else {
continue;
};
match &mut row.value {
PropValue::ColorChoice(current) => *current = color,
- PropValue::NamedColorChoice { .. } => {
- row.value = PropValue::ColorChoice(color)
- }
+ PropValue::NamedColorChoice { .. } => row.value = PropValue::ColorChoice(color),
PropValue::ReadOnly(current) => *current = label,
PropValue::ReadOnlyWithTooltip { value: current, .. } => *current = label,
_ => {}
@@ -3795,30 +3808,30 @@ fn format_unit_factor(factor: f64) -> String {
/// Convert INSUNITS (DXF group 70) to millimetres.
fn insunits_to_mm(code: i16) -> Option {
Some(match code {
- 1 => 25.4, // Inches
- 2 => 304.8, // Feet
- 3 => 1_609_344.0, // Miles
- 4 => 1.0, // Millimeters
- 5 => 10.0, // Centimeters
- 6 => 1_000.0, // Meters
- 7 => 1_000_000.0, // Kilometers
- 8 => 0.000_025_4, // Microinches
- 9 => 0.025_4, // Mils
- 10 => 914.4, // Yards
- 11 => 1.0e-7, // Angstroms
- 12 => 1.0e-6, // Nanometers
- 13 => 0.001, // Microns
- 14 => 100.0, // Decimeters
- 15 => 10_000.0, // Decameters
- 16 => 100_000.0, // Hectometers
- 17 => 1.0e12, // Gigameters
- 18 => 1.495_978_707e14, // Astronomical Units
- 19 => 9.460_730_472_580_8e18, // Light Years
+ 1 => 25.4, // Inches
+ 2 => 304.8, // Feet
+ 3 => 1_609_344.0, // Miles
+ 4 => 1.0, // Millimeters
+ 5 => 10.0, // Centimeters
+ 6 => 1_000.0, // Meters
+ 7 => 1_000_000.0, // Kilometers
+ 8 => 0.000_025_4, // Microinches
+ 9 => 0.025_4, // Mils
+ 10 => 914.4, // Yards
+ 11 => 1.0e-7, // Angstroms
+ 12 => 1.0e-6, // Nanometers
+ 13 => 0.001, // Microns
+ 14 => 100.0, // Decimeters
+ 15 => 10_000.0, // Decameters
+ 16 => 100_000.0, // Hectometers
+ 17 => 1.0e12, // Gigameters
+ 18 => 1.495_978_707e14, // Astronomical Units
+ 19 => 9.460_730_472_580_8e18, // Light Years
20 => 3.085_677_581_491_367_3e19, // Parsecs
- 21 => 1_200_000.0 / 3_937.0, // US Survey Feet
- 22 => 100_000.0 / 3_937.0, // US Survey Inches
- 23 => 3_600_000.0 / 3_937.0, // US Survey Yards
- 24 => 6_336_000_000.0 / 3_937.0, // US Survey Miles
+ 21 => 1_200_000.0 / 3_937.0, // US Survey Feet
+ 22 => 100_000.0 / 3_937.0, // US Survey Inches
+ 23 => 3_600_000.0 / 3_937.0, // US Survey Yards
+ 24 => 6_336_000_000.0 / 3_937.0, // US Survey Miles
_ => return None,
})
}
@@ -3842,9 +3855,7 @@ fn apply_insert_unit_scale(ins: &mut acadrust::entities::Insert, ratio: f64) ->
#[cfg(test)]
mod insert_unit_scale_tests {
- use super::{
- apply_insert_unit_scale, format_unit_factor, insert_unit_scale, insunits_to_mm,
- };
+ use super::{apply_insert_unit_scale, format_unit_factor, insert_unit_scale, insunits_to_mm};
use acadrust::entities::{AttributeEntity, Insert};
use acadrust::types::Vector3;
@@ -3909,10 +3920,7 @@ mod insert_unit_scale_tests {
fn astronomical_units_use_precise_si_values() {
assert_eq!(insunits_to_mm(18), Some(1.495_978_707e14));
assert_eq!(insunits_to_mm(19), Some(9.460_730_472_580_8e18));
- assert_eq!(
- insunits_to_mm(20),
- Some(3.085_677_581_491_367_3e19)
- );
+ assert_eq!(insunits_to_mm(20), Some(3.085_677_581_491_367_3e19));
assert_ne!(format_unit_factor(1.0e-7), "0.0000");
}
@@ -4004,11 +4012,7 @@ mod apply_property_op_tests {
app.tabs[i].dirty = false;
app.apply_property_op(i, "CHPROP", &[h1, h2], |app2, h| {
count2.set(count2.get() + 1);
- if let Some(e) = app2.tabs[app2.active_tab]
- .scene
- .document
- .get_entity_mut(h)
- {
+ if let Some(e) = app2.tabs[app2.active_tab].scene.document.get_entity_mut(h) {
e.common_mut().color = Color::Index(7);
}
});
@@ -4038,19 +4042,22 @@ mod apply_property_op_tests {
app.tabs[i].dirty = false;
app.apply_property_op(i, "CHPROP", &[h1, missing], |app2, h| {
count2.set(count2.get() + 1);
- if let Some(e) = app2.tabs[app2.active_tab]
- .scene
- .document
- .get_entity_mut(h)
- {
+ if let Some(e) = app2.tabs[app2.active_tab].scene.document.get_entity_mut(h) {
e.common_mut().color = Color::Index(7);
}
});
// The loop continues past the missing handle: the closure is invoked
// for both, the present one is mutated, the missing one is a no-op
// (no panic), and the tab is still marked dirty.
- assert_eq!(count.get(), 2, "closure still called for the missing handle");
- assert!(app.tabs[i].dirty, "tab marked dirty even with a missing handle");
+ assert_eq!(
+ count.get(),
+ 2,
+ "closure still called for the missing handle"
+ );
+ assert!(
+ app.tabs[i].dirty,
+ "tab marked dirty even with a missing handle"
+ );
let e = app.tabs[i]
.scene
.document
@@ -4111,32 +4118,68 @@ mod chprop_integration_tests {
let _ = app.update(Message::PropColorChanged(Color::Index(5)));
assert_eq!(
- app.tabs[i].scene.document.get_entity(h1).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h1)
+ .unwrap()
+ .common()
+ .color,
Color::Index(5)
);
assert_eq!(
- app.tabs[i].scene.document.get_entity(h2).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h2)
+ .unwrap()
+ .common()
+ .color,
Color::Index(5)
);
assert!(app.tabs[i].dirty, "helper must set the dirty bit");
app.undo_active_tab();
assert_eq!(
- app.tabs[i].scene.document.get_entity(h1).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h1)
+ .unwrap()
+ .common()
+ .color,
original
);
assert_eq!(
- app.tabs[i].scene.document.get_entity(h2).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h2)
+ .unwrap()
+ .common()
+ .color,
original
);
app.redo_active_tab();
assert_eq!(
- app.tabs[i].scene.document.get_entity(h1).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h1)
+ .unwrap()
+ .common()
+ .color,
Color::Index(5)
);
assert_eq!(
- app.tabs[i].scene.document.get_entity(h2).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h2)
+ .unwrap()
+ .common()
+ .color,
Color::Index(5)
);
}
@@ -4164,14 +4207,26 @@ mod chprop_integration_tests {
let _ = app.automation_op(r#"{"op":"select","type":"Line"}"#);
let _ = app.automation_op(r#"{"op":"run","cmd":"CHPROP COLOR 3"}"#);
assert_ne!(
- app.tabs[i].scene.document.get_entity(h).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h)
+ .unwrap()
+ .common()
+ .color,
original,
"CHPROP COLOR 3 must have changed the line's colour"
);
app.undo_active_tab();
assert_eq!(
- app.tabs[i].scene.document.get_entity(h).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h)
+ .unwrap()
+ .common()
+ .color,
original,
"undo must restore the pre-CHPROP colour"
);
@@ -4215,7 +4270,13 @@ mod chprop_integration_tests {
let _ = app.update(Message::PropColorChanged(Color::Index(9)));
assert_ne!(
- app.tabs[i].scene.document.get_entity(h).unwrap().common().color,
+ app.tabs[i]
+ .scene
+ .document
+ .get_entity(h)
+ .unwrap()
+ .common()
+ .color,
Color::Index(9),
"a locked-layer entity must not be mutated by PropColorChanged"
);
@@ -4257,12 +4318,12 @@ mod grip_limit_tests {
let handles: Vec<_> = (0..n)
.map(|k| {
let x = k as f64;
- app.tabs[i].scene.add_entity(EntityType::Line(
- Line::from_points(
+ app.tabs[i]
+ .scene
+ .add_entity(EntityType::Line(Line::from_points(
Vector3::new(x, 0.0, 0.0),
Vector3::new(x + 1.0, 1.0, 0.0),
- ),
- ))
+ )))
})
.collect();
for handle in handles {
@@ -4273,11 +4334,17 @@ mod grip_limit_tests {
};
assert!(
- select_n(crate::app::settings::DEFAULT_GRIP_OBJECT_LIMIT as usize, None) > 0,
+ select_n(
+ crate::app::settings::DEFAULT_GRIP_OBJECT_LIMIT as usize,
+ None
+ ) > 0,
"a selection at the limit must still show its grips",
);
assert_eq!(
- select_n(crate::app::settings::DEFAULT_GRIP_OBJECT_LIMIT as usize + 1, None),
+ select_n(
+ crate::app::settings::DEFAULT_GRIP_OBJECT_LIMIT as usize + 1,
+ None
+ ),
0,
"one past the limit must show none at all",
);
@@ -4347,10 +4414,12 @@ mod grip_limit_tests {
let handles: Vec<_> = (0..over)
.map(|k| {
let x = k as f64;
- app.tabs[i].scene.add_entity(EntityType::Line(Line::from_points(
- Vector3::new(x, 0.0, 0.0),
- Vector3::new(x + 1.0, 1.0, 0.0),
- )))
+ app.tabs[i]
+ .scene
+ .add_entity(EntityType::Line(Line::from_points(
+ Vector3::new(x, 0.0, 0.0),
+ Vector3::new(x + 1.0, 1.0, 0.0),
+ )))
})
.collect();
for handle in handles {
diff --git a/src/app/settings.rs b/src/app/settings.rs
index 09f01584a..9c2757542 100644
--- a/src/app/settings.rs
+++ b/src/app/settings.rs
@@ -11,6 +11,108 @@
use crate::snap::SnapType;
use serde::{Deserialize, Serialize};
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum AutoConstraintKind {
+ Coincident,
+ Collinear,
+ Parallel,
+ Perpendicular,
+ Tangent,
+ Concentric,
+ Horizontal,
+ Vertical,
+ Equal,
+}
+
+impl AutoConstraintKind {
+ pub const ALL: [Self; 9] = [
+ Self::Coincident,
+ Self::Collinear,
+ Self::Parallel,
+ Self::Perpendicular,
+ Self::Tangent,
+ Self::Concentric,
+ Self::Horizontal,
+ Self::Vertical,
+ Self::Equal,
+ ];
+
+ pub const fn label(self) -> &'static str {
+ match self {
+ Self::Coincident => "Coincident",
+ Self::Collinear => "Collinear",
+ Self::Parallel => "Parallel",
+ Self::Perpendicular => "Perpendicular",
+ Self::Tangent => "Tangent",
+ Self::Concentric => "Concentric",
+ Self::Horizontal => "Horizontal",
+ Self::Vertical => "Vertical",
+ Self::Equal => "Equal",
+ }
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AutoConstrainSettings {
+ pub priority: Vec,
+ pub enabled: Vec,
+ pub tangent_must_share_point: bool,
+ pub perpendicular_must_intersect: bool,
+ pub distance_tolerance: f64,
+ pub angle_tolerance_deg: f64,
+}
+
+impl Default for AutoConstrainSettings {
+ fn default() -> Self {
+ Self {
+ priority: AutoConstraintKind::ALL.to_vec(),
+ // Keep Equal available without creating redundant relations
+ // between equal-length segments by default.
+ enabled: AutoConstraintKind::ALL
+ .into_iter()
+ .filter(|kind| *kind != AutoConstraintKind::Equal)
+ .collect(),
+ tangent_must_share_point: true,
+ perpendicular_must_intersect: true,
+ distance_tolerance: 0.05,
+ angle_tolerance_deg: 1.0,
+ }
+ }
+}
+
+impl AutoConstrainSettings {
+ pub fn sanitize(&mut self) {
+ let mut priority = Vec::with_capacity(AutoConstraintKind::ALL.len());
+ for kind in self
+ .priority
+ .iter()
+ .copied()
+ .chain(AutoConstraintKind::ALL)
+ {
+ if !priority.contains(&kind) {
+ priority.push(kind);
+ }
+ }
+ self.priority = priority;
+ self.enabled
+ .retain(|kind| AutoConstraintKind::ALL.contains(kind));
+ self.enabled.sort_by_key(|kind| {
+ self.priority
+ .iter()
+ .position(|candidate| candidate == kind)
+ .unwrap_or(usize::MAX)
+ });
+ self.enabled.dedup();
+ if !self.distance_tolerance.is_finite() || self.distance_tolerance < 0.0 {
+ self.distance_tolerance = 0.05;
+ }
+ if !self.angle_tolerance_deg.is_finite() || self.angle_tolerance_deg < 0.0 {
+ self.angle_tolerance_deg = 1.0;
+ }
+ }
+}
+
/// Cursor shown over the drawing viewport.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum CursorType {
@@ -283,16 +385,25 @@ pub struct UserSettings {
/// When true (default), the app (re)registers itself as a .dwg/.dxf/.bak
/// handler on every launch. Toggle with the FILEASSOC command.
pub file_assoc_enabled: bool,
- /// When true, saving also writes sketch constraints as native drawing
- /// objects alongside the application's own persistence record.
- #[serde(default)]
- pub write_dwg_native_constraints: bool,
/// When true (default), a sketch constraint's viewport pill shows its
/// glyph plus a driven value or named-parameter name. When false, every
/// pill shows just the bare glyph, so the value/name text doesn't cover
/// canvas detail on a dense sketch.
#[serde(default = "default_show_constraint_values")]
pub show_constraint_values: bool,
+ /// Inference types, priority, intersection rules, and tolerances used by
+ /// the Auto Constrain command.
+ #[serde(default)]
+ pub auto_constrain: AutoConstrainSettings,
+ /// Keep existing geometry size while solving after a constraint edit.
+ #[serde(default = "default_constraint_solve_mode")]
+ pub constraint_solve_mode: bool,
+ /// Apply eligible geometric constraints while creating geometry.
+ #[serde(default)]
+ pub constraint_infer: bool,
+ /// Constraint bar display bit mask: 1 after applying, 2 on selection.
+ #[serde(default = "default_constraint_bar_display")]
+ pub constraint_bar_display: i16,
/// Minutes between autosaves to a `.sv$` recovery file (SAVETIME command).
/// 0 disables autosave.
pub savetime_min: i32,
@@ -363,6 +474,14 @@ fn default_show_constraint_values() -> bool {
true
}
+fn default_constraint_solve_mode() -> bool {
+ true
+}
+
+fn default_constraint_bar_display() -> i16 {
+ 3
+}
+
fn deserialize_clipromptlines<'de, D>(de: D) -> Result
where
D: serde::Deserializer<'de>,
@@ -418,8 +537,11 @@ impl Default for UserSettings {
textfill: true,
backup_on_save: true,
file_assoc_enabled: true,
- write_dwg_native_constraints: false,
show_constraint_values: true,
+ auto_constrain: AutoConstrainSettings::default(),
+ constraint_solve_mode: true,
+ constraint_infer: false,
+ constraint_bar_display: 3,
savetime_min: 10,
default_save_format: crate::io::DEFAULT_SAVE_FORMAT.to_string(),
pick_add: true,
diff --git a/src/app/update/command.rs b/src/app/update/command.rs
index 4dd845b72..8a3c081c4 100644
--- a/src/app/update/command.rs
+++ b/src/app/update/command.rs
@@ -1999,10 +1999,11 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task {
}
pub(super) fn on_ribbon_color_changed(&mut self, color: AcadColor) -> Task {
- let i = self.active_tab;
- self.ribbon.prop_color_palette_open = false;
- self.ribbon.close_dropdown();
- let handles = self.property_target_handles(i);
+ let i = self.active_tab;
+ self.ribbon.prop_color_palette_open = false;
+ self.ribbon.close_dropdown();
+ self.note_recent_color(color);
+ let handles = self.property_target_handles(i);
if handles.is_empty() {
if self.has_property_selection(i) {
return Task::none();
@@ -3247,6 +3248,29 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task {
self.tabs[i].properties.active_field = None;
let handles = self.property_target_handles(i);
if !handles.is_empty() {
+ let driven_marker = match field {
+ "start_x" | "start_y" | "start_z" => Some(0),
+ "end_x" | "end_y" | "end_z" => Some(1),
+ "center_x" | "center_y" | "center_z" => Some(-3),
+ _ => None,
+ };
+ let retained_originals: Vec<_> = if self.constraint_solve_mode
+ && driven_marker.is_some()
+ {
+ handles
+ .iter()
+ .filter_map(|handle| {
+ self.tabs[i]
+ .scene
+ .document
+ .get_entity(*handle)
+ .cloned()
+ .map(|entity| (*handle, entity))
+ })
+ .collect()
+ } else {
+ Vec::new()
+ };
let evaluates_expression = self.tabs[i]
.properties
.sections
@@ -3563,7 +3587,22 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task {
}
}
}
- self.invalidate_property_targets(i, &handles);
+ let driven_refs: Vec<_> = driven_marker
+ .into_iter()
+ .flat_map(|marker| {
+ handles.iter().copied().map(move |handle| {
+ crate::scene::parametric_constraints::ParametricRef::point(
+ handle, marker,
+ )
+ })
+ })
+ .collect();
+ self.invalidate_property_targets_with_originals(
+ i,
+ &handles,
+ &driven_refs,
+ &retained_originals,
+ );
self.tabs[i].dirty = true;
self.refresh_properties();
}
diff --git a/src/app/update/file.rs b/src/app/update/file.rs
index 1bad3d3ce..8f7ca88f2 100644
--- a/src/app/update/file.rs
+++ b/src/app/update/file.rs
@@ -4,13 +4,12 @@
use super::util::*;
use super::{format_size, VIEWCUBE_HIT_SIZE};
use crate::app::helpers::{
- parse_coord, polar_constrain_near, ucs_rotate_vec, ucs_to_wcs, ucs_z_axis,
- CoordKind,
+ parse_coord, polar_constrain_near, ucs_rotate_vec, ucs_to_wcs, ucs_z_axis, CoordKind,
};
use crate::app::{Message, OpenCADStudio, POLY_START_DELAY_MS};
use crate::modules::ModuleEvent;
-use crate::scene::pick::grip::{find_hit_grip, find_hit_grip_paper, find_hit_grip_rte, GripEdit};
use crate::scene::model::object::GripApply;
+use crate::scene::pick::grip::{find_hit_grip, find_hit_grip_paper, find_hit_grip_rte, GripEdit};
use crate::scene::{
self, hover_id, CubeRegion, Scene, VIEWCUBE_DRAW_PX, VIEWCUBE_PAD, VIEWCUBE_PX,
};
@@ -59,9 +58,7 @@ fn plot_dialog_scale_factor(d: &crate::ui::window::plot::PlotDialogState) -> f64
fn scale_name_for_factor(scales: &[(String, f64)], factor: f64) -> Option {
scales
.iter()
- .find(|(_, candidate)| {
- (*candidate - factor).abs() <= 1e-6 * factor.abs().max(1.0)
- })
+ .find(|(_, candidate)| (*candidate - factor).abs() <= 1e-6 * factor.abs().max(1.0))
.map(|(name, _)| name.clone())
}
@@ -83,42 +80,13 @@ fn plot_render_mode_override(
#[cfg(not(target_arch = "wasm32"))]
fn native_paths_match(left: &std::path::Path, right: &std::path::Path) -> bool {
- match (
- std::fs::canonicalize(left),
- std::fs::canonicalize(right),
- ) {
+ match (std::fs::canonicalize(left), std::fs::canonicalize(right)) {
(Ok(left), Ok(right)) => left == right,
_ => left == right,
}
}
-type LayoutPlotParams = (
- std::sync::Arc>,
- Vec,
- Vec,
- crate::io::pdf_export::PlotGroupSplits,
- f64,
- f64,
- f64,
- f64,
- i32,
- f32,
- Option<(f32, f32, f32, f32)>,
-);
-
-type ClippedPlotParams = (
- Vec,
- Vec,
- Vec,
- crate::io::pdf_export::PlotGroupSplits,
- f64,
- f64,
- f64,
- f64,
- i32,
- f32,
- Option<(f32, f32, f32, f32)>,
-);
+use crate::io::pdf_export::{PdfPageInput, PlotContent};
fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f64) {
use crate::io::paper_sizes::{sheet_mm, Orientation, PaperSize};
@@ -149,11 +117,8 @@ fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f
}
}
-fn plot_content_extents(
- wires: &[crate::io::pdf_export::PlotWire],
- hatches: &[crate::scene::model::hatch_model::HatchModel],
- wipeouts: &[crate::scene::model::hatch_model::HatchModel],
-) -> Option<(f64, f64, f64, f64)> {
+fn plot_content_extents(content: &PlotContent) -> Option<(f64, f64, f64, f64)> {
+ let PlotContent { wires, hatches, wipeouts, images, .. } = content;
let mut bounds = (
f64::INFINITY,
f64::INFINITY,
@@ -168,14 +133,40 @@ fn plot_content_extents(
bounds.3 = bounds.3.max(y);
}
};
- for wire in wires {
+ for wire in wires.iter().filter(|wire| wire.name != "paper_printable_area") {
let [x0, y0, x1, y1] = wire.aabb;
include(x0 as f64, y0 as f64);
include(x1 as f64, y1 as f64);
}
for hatch in wipeouts.iter().chain(hatches.iter()) {
for &[x, y] in hatch.boundary.iter() {
- include(hatch.world_origin[0] + x as f64, hatch.world_origin[1] + y as f64);
+ include(
+ hatch.world_origin[0] + x as f64,
+ hatch.world_origin[1] + y as f64,
+ );
+ }
+ }
+ for plot in images {
+ let mut image_bounds = [f64::INFINITY, f64::INFINITY,
+ f64::NEG_INFINITY, f64::NEG_INFINITY];
+ for vertex in &plot.image.verts {
+ for axis in 0..2 {
+ let value = vertex.pos[axis] as f64 + vertex.pos_low[axis] as f64;
+ image_bounds[axis] = image_bounds[axis].min(value);
+ image_bounds[axis + 2] = image_bounds[axis + 2].max(value);
+ }
+ }
+ for clip in &plot.clips {
+ for axis in 0..2 {
+ let min = clip.iter().map(|p| p[axis]).fold(f64::INFINITY, f64::min);
+ let max = clip.iter().map(|p| p[axis]).fold(f64::NEG_INFINITY, f64::max);
+ image_bounds[axis] = image_bounds[axis].max(min);
+ image_bounds[axis + 2] = image_bounds[axis + 2].min(max);
+ }
+ }
+ if image_bounds[0] < image_bounds[2] && image_bounds[1] < image_bounds[3] {
+ include(image_bounds[0], image_bounds[1]);
+ include(image_bounds[2], image_bounds[3]);
}
}
(bounds.0.is_finite()
@@ -191,12 +182,7 @@ fn plot_scene_content(
scene: &crate::scene::Scene,
paper_space_last: bool,
render_mode_override: Option,
-) -> (
- std::sync::Arc>,
- Vec,
- Vec,
- crate::io::pdf_export::PlotGroupSplits,
-) {
+) -> PlotContent {
let (mut paper_wires, mut model_wires) = scene.plot_wire_groups(render_mode_override);
let plot_viewport_borders = scene
.effective_plot_settings()
@@ -230,20 +216,23 @@ fn plot_scene_content(
let model_wires = with_depth(model_wires);
let paper_hatches = scene.paper_plot_hatches().as_ref().clone();
let paper_wipeouts = scene.paper_plot_wipeouts().as_ref().clone();
+ let paper_images = scene.paper_plot_images();
if scene.current_layout == "Model" {
let splits = crate::io::pdf_export::PlotGroupSplits {
wires: paper_wires.len(),
hatches: paper_hatches.len(),
wipeouts: paper_wipeouts.len(),
+ images: paper_images.len(),
+ };
+ return PlotContent {
+ wires: std::sync::Arc::new(paper_wires),
+ hatches: paper_hatches,
+ wipeouts: paper_wipeouts,
+ images: paper_images,
+ group_splits: splits,
};
- return (
- std::sync::Arc::new(paper_wires),
- paper_hatches,
- paper_wipeouts,
- splits,
- );
}
- let (mut model_pattern_wires, model_hatches, model_wipeouts) =
+ let (mut model_pattern_wires, model_hatches, model_wipeouts, model_images) =
scene.viewport_plot_fills();
model_pattern_wires.retain(|(wire, _)| wire.plot_visible);
let model_pattern_wires = model_pattern_wires
@@ -251,36 +240,42 @@ fn plot_scene_content(
.map(|(wire, draw_depth)| crate::io::pdf_export::PlotWire { wire, draw_depth })
.collect::>();
- let (wires, hatches, wipeouts, splits) = if paper_space_last {
+ let (wires, hatches, wipeouts, images, splits) = if paper_space_last {
let splits = crate::io::pdf_export::PlotGroupSplits {
wires: model_wires.len() + model_pattern_wires.len(),
hatches: model_hatches.len(),
wipeouts: model_wipeouts.len(),
+ images: model_images.len(),
};
let mut wires = model_wires;
let mut hatches = model_hatches;
let mut wipeouts = model_wipeouts;
+ let mut images = model_images;
wires.extend(model_pattern_wires);
wires.extend(paper_wires);
hatches.extend(paper_hatches);
wipeouts.extend(paper_wipeouts);
- (wires, hatches, wipeouts, splits)
+ images.extend(paper_images);
+ (wires, hatches, wipeouts, images, splits)
} else {
let splits = crate::io::pdf_export::PlotGroupSplits {
wires: paper_wires.len(),
hatches: paper_hatches.len(),
wipeouts: paper_wipeouts.len(),
+ images: paper_images.len(),
};
let mut wires = paper_wires;
let mut hatches = paper_hatches;
let mut wipeouts = paper_wipeouts;
+ let mut images = paper_images;
wires.extend(model_wires);
wires.extend(model_pattern_wires);
hatches.extend(model_hatches);
wipeouts.extend(model_wipeouts);
- (wires, hatches, wipeouts, splits)
+ images.extend(model_images);
+ (wires, hatches, wipeouts, images, splits)
};
- (std::sync::Arc::new(wires), hatches, wipeouts, splits)
+ PlotContent { wires: std::sync::Arc::new(wires), hatches, wipeouts, images, group_splits: splits }
}
impl OpenCADStudio {
@@ -304,9 +299,7 @@ impl OpenCADStudio {
for (h, needs_acis, needs_wires) in targets {
let body = scene.solid_models.get(&h);
let sat = needs_acis
- .then(|| {
- body.and_then(crate::scene::convert::acis_export::solid_to_sat)
- })
+ .then(|| body.and_then(crate::scene::convert::acis_export::solid_to_sat))
.flatten();
let wires = needs_wires.then(|| {
if let Some(body) = body {
@@ -434,8 +427,11 @@ impl OpenCADStudio {
textfill: crate::scene::text::sdf_atlas::textfill(),
backup_on_save: self.backup_on_save,
file_assoc_enabled: self.file_assoc_enabled,
- write_dwg_native_constraints: self.write_dwg_native_constraints,
show_constraint_values: self.show_constraint_values,
+ auto_constrain: self.auto_constrain_settings.clone(),
+ constraint_solve_mode: self.constraint_solve_mode,
+ constraint_infer: self.constraint_infer,
+ constraint_bar_display: self.constraint_bar_display,
savetime_min: self.savetime_min,
default_save_format: self.default_save_format.clone(),
pick_add: self.pick_add,
@@ -516,8 +512,16 @@ impl OpenCADStudio {
crate::scene::text::sdf_atlas::set_textfill(s.textfill);
self.backup_on_save = s.backup_on_save;
self.file_assoc_enabled = s.file_assoc_enabled;
- self.write_dwg_native_constraints = s.write_dwg_native_constraints;
self.show_constraint_values = s.show_constraint_values;
+ self.auto_constrain_settings = s.auto_constrain.clone();
+ self.auto_constrain_settings.sanitize();
+ self.auto_constrain_distance_input =
+ format!("{}", self.auto_constrain_settings.distance_tolerance);
+ self.auto_constrain_angle_input =
+ format!("{}", self.auto_constrain_settings.angle_tolerance_deg);
+ self.constraint_solve_mode = s.constraint_solve_mode;
+ self.constraint_infer = s.constraint_infer;
+ self.constraint_bar_display = s.constraint_bar_display.clamp(0, 3);
self.savetime_min = s.savetime_min;
self.default_save_format =
crate::io::canonical_save_format(&s.default_save_format).to_string();
@@ -532,9 +536,8 @@ impl OpenCADStudio {
.set_cliprompt_lines(self.cliprompt_lines.clamp(0, 50) as u8);
self.commandline_fade_ms =
crate::app::settings::clamp_commandline_fade_ms(s.commandline_fade_ms);
- self.command_line.set_commandline_fade_ms(
- self.commandline_fade_ms.clamp(0, 60000) as u32,
- );
+ self.command_line
+ .set_commandline_fade_ms(self.commandline_fade_ms.clamp(0, 60000) as u32);
// Block usage: clone but cap to sane sizes (MRU 20, freq map 200)
self.block_mru = s.block_mru.iter().take(20).cloned().collect();
self.block_freq = s
@@ -620,7 +623,11 @@ impl OpenCADStudio {
(n, f, m)
})
.collect();
- scored.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.2.cmp(&b.2)).then_with(|| a.0.cmp(b.0)));
+ scored.sort_by(|a, b| {
+ b.1.cmp(&a.1)
+ .then_with(|| a.2.cmp(&b.2))
+ .then_with(|| a.0.cmp(b.0))
+ });
scored.into_iter().map(|(n, _, _)| n.clone()).collect()
}
@@ -717,8 +724,7 @@ impl OpenCADStudio {
/// Rebuild the ribbon's tab list from the registry, dropping the tabs of any
/// disabled plugins. Call after `disabled_plugins` changes.
pub(in crate::app) fn rebuild_ribbon_modules(&mut self) {
- let modules =
- crate::plugin::ribbon_modules_enabled(&self.disabled_plugins);
+ let modules = crate::plugin::ribbon_modules_enabled(&self.disabled_plugins);
self.ribbon.set_modules(modules);
// Refresh the command-line autocomplete pool so a newly enabled plugin's
// commands become typeable (and a disabled one's drop out). This runs on
@@ -880,10 +886,10 @@ impl OpenCADStudio {
.iter()
.map(std::path::PathBuf::from)
.collect();
- self.recent_limit = cfg
- .recent
- .limit
- .clamp(crate::app::recent::RECENT_MIN, crate::app::recent::RECENT_MAX);
+ self.recent_limit = cfg.recent.limit.clamp(
+ crate::app::recent::RECENT_MIN,
+ crate::app::recent::RECENT_MAX,
+ );
self.recent_files.truncate(self.recent_limit);
self.recent_limit_input = self.recent_limit.to_string();
// Thumbnails are decoded by a background task queued at boot
@@ -951,7 +957,8 @@ impl OpenCADStudio {
tab.scene.recolor_meshes();
tab.scene.bump_geometry();
}
- tab.scene.request_refresh(crate::scene::ViewportRefreshScope::All);
+ tab.scene
+ .request_refresh(crate::scene::ViewportRefreshScope::All);
}
}
@@ -962,39 +969,39 @@ impl OpenCADStudio {
self.persist_settings_if_changed();
}
-pub(super) fn on_open_file(&mut self) -> Task {
- // Native: pick a path, then load on a worker thread. Web: the
- // browser hands back bytes, so pick + parse in one step and feed
- // the shared `FileOpened` handler directly.
- #[cfg(not(target_arch = "wasm32"))]
- {
- Task::perform(crate::io::pick_open_path(), Message::OpenPathPicked)
- }
- #[cfg(target_arch = "wasm32")]
- {
- // `FileOpened` only installs the result when an open is in
- // progress, so mark one. The browser picker + parse happen
- // inside `pick_and_load_web`; the real name is unknown until
- // then, so show a generic label meanwhile.
+ pub(super) fn on_open_file(&mut self) -> Task {
+ // Native: pick a path, then load on a worker thread. Web: the
+ // browser hands back bytes, so pick + parse in one step and feed
+ // the shared `FileOpened` handler directly.
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ Task::perform(crate::io::pick_open_path(), Message::OpenPathPicked)
+ }
+ #[cfg(target_arch = "wasm32")]
+ {
+ // `FileOpened` only installs the result when an open is in
+ // progress, so mark one. The browser picker + parse happen
+ // inside `pick_and_load_web`; the real name is unknown until
+ // then, so show a generic label meanwhile.
let state = std::sync::Arc::new(crate::io::OpenProgressState::new(
crate::app::OPEN_PHASE_READING,
));
- let open_id = self.next_open_id();
- self.opening = Some(crate::app::OpenProgress {
- id: open_id,
- name: "Opening…".into(),
- source_path: None,
- size_bytes: 0,
- state: state.clone(),
- started: Instant::now(),
- recovery_error: None,
- recovery_read_stats: None,
- recovery_bytes: None,
- });
- Task::perform(crate::io::pick_and_load_web(state), move |outcome| {
- Message::WebFileOpened(open_id, outcome)
- })
- }
+ let open_id = self.next_open_id();
+ self.opening = Some(crate::app::OpenProgress {
+ id: open_id,
+ name: "Opening…".into(),
+ source_path: None,
+ size_bytes: 0,
+ state: state.clone(),
+ started: Instant::now(),
+ recovery_error: None,
+ recovery_read_stats: None,
+ recovery_bytes: None,
+ });
+ Task::perform(crate::io::pick_and_load_web(state), move |outcome| {
+ Message::WebFileOpened(open_id, outcome)
+ })
+ }
}
pub(in crate::app) fn next_open_id(&mut self) -> u64 {
@@ -1032,10 +1039,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
/// Read through this session's lease when it covers `path`.
#[cfg(not(target_arch = "wasm32"))]
- pub(in crate::app) fn read_drawing(
- &self,
- path: &std::path::Path,
- ) -> std::io::Result> {
+ pub(in crate::app) fn read_drawing(&self, path: &std::path::Path) -> std::io::Result> {
use std::io::{Read, Seek, SeekFrom};
let lease = self
@@ -1073,8 +1077,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
path: &std::path::Path,
loaded_fingerprint: Option,
) {
- let current_fingerprint =
- crate::io::edit_lock::FileFingerprint::capture(path).ok();
+ let current_fingerprint = crate::io::edit_lock::FileFingerprint::capture(path).ok();
if loaded_fingerprint
.as_ref()
.zip(current_fingerprint.as_ref())
@@ -1087,14 +1090,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
.as_ref(),
);
}
- self.tabs[i].disk_fingerprint =
- loaded_fingerprint.or(current_fingerprint);
+ self.tabs[i].disk_fingerprint = loaded_fingerprint.or(current_fingerprint);
match crate::io::edit_lock::EditLease::acquire(path) {
Ok(lease) => {
if let Some(warning) = lease.platform_warning() {
- self.command_line.push_info(crate::tf!(
- "Edit lease active; {warning}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!(
+ "Edit lease active; {warning}. External-change checks remain active."
+ )
+ .as_ref(),
+ );
}
self.tabs[i].edit_lease = Some(lease);
self.tabs[i].edit_lock_conflict = false;
@@ -1102,16 +1107,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
Err(crate::io::edit_lock::EditLeaseError::Locked(error)) => {
self.tabs[i].edit_lease = None;
self.tabs[i].edit_lock_conflict = true;
- self.command_line.push_error_once(crate::tf!(
- "Opened read-only against other editors: {error}"
- ).as_ref());
+ self.command_line.push_error_once(
+ crate::tf!("Opened read-only against other editors: {error}").as_ref(),
+ );
}
Err(crate::io::edit_lock::EditLeaseError::Unavailable(error)) => {
self.tabs[i].edit_lease = None;
self.tabs[i].edit_lock_conflict = false;
- self.command_line.push_info(crate::tf!(
- "{error}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{error}. External-change checks remain active.").as_ref(),
+ );
}
}
}
@@ -1143,27 +1148,29 @@ pub(super) fn on_open_file(&mut self) -> Task {
Some(Ok(warning)) => {
self.tabs[i].edit_lock_conflict = false;
if let Some(warning) = warning {
- self.command_line.push_info(crate::tf!(
- "{warning}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{warning}. External-change checks remain active.").as_ref(),
+ );
}
}
Some(Err(crate::io::edit_lock::EditLeaseError::Locked(error))) => {
self.tabs[i].edit_lock_conflict = true;
- self.command_line.push_error_once(crate::tf!(
- "Saved, but the refreshed drawing is locked by another editor: {error}"
- ).as_ref());
+ self.command_line.push_error_once(
+ crate::tf!(
+ "Saved, but the refreshed drawing is locked by another editor: {error}"
+ )
+ .as_ref(),
+ );
}
Some(Err(crate::io::edit_lock::EditLeaseError::Unavailable(error))) => {
self.tabs[i].edit_lock_conflict = false;
- self.command_line.push_info(crate::tf!(
- "{error}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{error}. External-change checks remain active.").as_ref(),
+ );
}
None => self.install_native_edit_guard(i, path, None),
}
- self.tabs[i].disk_fingerprint =
- crate::io::edit_lock::FileFingerprint::capture(path).ok();
+ self.tabs[i].disk_fingerprint = crate::io::edit_lock::FileFingerprint::capture(path).ok();
}
#[cfg(not(target_arch = "wasm32"))]
@@ -1201,9 +1208,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
return Err(crate::io::SaveFailure::file_in_use(error));
}
Err(crate::io::edit_lock::EditLeaseError::Unavailable(error)) => {
- self.command_line.push_info(crate::tf!(
- "{error}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{error}. External-change checks remain active.").as_ref(),
+ );
None
}
}
@@ -1239,12 +1246,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
if set_current_path {
self.tabs[i].current_path = Some(path.clone());
}
- self.refresh_native_edit_guard_after_save(
- i,
- &path,
- path_changed,
- destination_lease,
- );
+ self.refresh_native_edit_guard_after_save(i, &path, path_changed, destination_lease);
self.tabs[i].dirty = false;
if set_current_path {
self.tabs[i].recovery_save_as_required = false;
@@ -1254,20 +1256,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
#[cfg(not(target_arch = "wasm32"))]
- fn retry_native_edit_guard(
- &mut self,
- i: usize,
- path: &std::path::Path,
- ) -> Result<(), String> {
+ fn retry_native_edit_guard(&mut self, i: usize, path: &std::path::Path) -> Result<(), String> {
if let Some(lease) = self.tabs[i].edit_lease.as_mut() {
match lease.refresh_drawing_lock(path) {
Ok(()) => {
let warning = lease.platform_warning().map(str::to_owned);
self.tabs[i].edit_lock_conflict = false;
if let Some(warning) = warning {
- self.command_line.push_info(crate::tf!(
- "{warning}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{warning}. External-change checks remain active.").as_ref(),
+ );
}
return Ok(());
}
@@ -1276,9 +1274,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
Err(crate::io::edit_lock::EditLeaseError::Unavailable(error)) => {
self.tabs[i].edit_lock_conflict = false;
- self.command_line.push_info(crate::tf!(
- "{error}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{error}. External-change checks remain active.").as_ref(),
+ );
return Ok(());
}
}
@@ -1290,75 +1288,84 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.tabs[i].edit_lease = Some(lease);
self.tabs[i].edit_lock_conflict = false;
if let Some(warning) = warning {
- self.command_line.push_info(crate::tf!(
- "{warning}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{warning}. External-change checks remain active.").as_ref(),
+ );
}
Ok(())
}
Err(crate::io::edit_lock::EditLeaseError::Locked(error)) => Err(error),
Err(crate::io::edit_lock::EditLeaseError::Unavailable(error)) => {
self.tabs[i].edit_lock_conflict = false;
- self.command_line.push_info(crate::tf!(
- "{error}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{error}. External-change checks remain active.").as_ref(),
+ );
Ok(())
}
}
}
- pub(super) fn on_file_opened(&mut self, name: String, path: std::path::PathBuf, doc: acadrust::CadDocument,
+ pub(super) fn on_file_opened(
+ &mut self,
+ name: String,
+ path: std::path::PathBuf,
+ doc: acadrust::CadDocument,
mut caches: crate::scene::DerivedCaches,
) -> Task {
- // If the user clicked Cancel while the parser was running, the
- // overlay state was cleared and we silently drop the result.
- if self.opening.is_none() {
- return Task::none();
- }
- let open_started = self.opening.as_ref().map(|p| p.started);
- let size_bytes = self
- .opening
- .as_ref()
- .map(|progress| progress.size_bytes)
- .unwrap_or(0);
- let timings = caches.timings;
- let entity_count = doc.entities().count();
- let parser_errors_recovered = caches.read_stats.as_ref().is_some_and(|stats| {
- stats.recovered()
- || stats.skipped_source_records > 0
- || !stats.stream_completed
- }) || doc.notifications.iter().any(|item| {
- item.notification_type == acadrust::notification::NotificationType::Error
- });
- let reference_recovered = caches
- .xrefs
- .iter()
- .any(|item| item.status == crate::io::xref::XrefStatus::Recovered);
- let reference_failed = caches
- .xrefs
- .iter()
- .any(|item| item.status == crate::io::xref::XrefStatus::Failed);
- let document_repaired = parser_errors_recovered
- || reference_recovered
- || caches.corrupt_dropped > 0
- || caches.xref_dropped > 0;
- let recovery_needed = document_repaired || reference_failed;
- let total_ms = open_started
- .map(|started| started.elapsed().as_millis() as u32)
- .unwrap_or(0);
- self.command_line
- .push_output(crate::tf!("Opened \"{name}\" — {entity_count} entities").as_ref());
- if caches.corrupt_dropped > 0 {
- self.command_line.push_error(crate::tf!(
- "Warning: {} corrupt entities dropped (parser junk — bad normals / counts)",
- caches.corrupt_dropped
- ).as_ref());
- }
+ // If the user clicked Cancel while the parser was running, the
+ // overlay state was cleared and we silently drop the result.
+ if self.opening.is_none() {
+ return Task::none();
+ }
+ let open_started = self.opening.as_ref().map(|p| p.started);
+ let size_bytes = self
+ .opening
+ .as_ref()
+ .map(|progress| progress.size_bytes)
+ .unwrap_or(0);
+ let timings = caches.timings;
+ let entity_count = doc.entities().count();
+ let parser_errors_recovered = caches.read_stats.as_ref().is_some_and(|stats| {
+ stats.recovered() || stats.skipped_source_records > 0 || !stats.stream_completed
+ }) || doc
+ .notifications
+ .iter()
+ .any(|item| item.notification_type == acadrust::notification::NotificationType::Error);
+ let reference_recovered = caches
+ .xrefs
+ .iter()
+ .any(|item| item.status == crate::io::xref::XrefStatus::Recovered);
+ let reference_failed = caches
+ .xrefs
+ .iter()
+ .any(|item| item.status == crate::io::xref::XrefStatus::Failed);
+ let document_repaired = parser_errors_recovered
+ || reference_recovered
+ || caches.corrupt_dropped > 0
+ || caches.xref_dropped > 0;
+ let recovery_needed = document_repaired || reference_failed;
+ let total_ms = open_started
+ .map(|started| started.elapsed().as_millis() as u32)
+ .unwrap_or(0);
+ self.command_line
+ .push_output(crate::tf!("Opened \"{name}\" — {entity_count} entities").as_ref());
+ if caches.corrupt_dropped > 0 {
+ self.command_line.push_error(
+ crate::tf!(
+ "Warning: {} corrupt entities dropped (parser junk — bad normals / counts)",
+ caches.corrupt_dropped
+ )
+ .as_ref(),
+ );
+ }
if caches.xref_dropped > 0 {
- self.command_line.push_error(crate::tf!(
- "Warning: {} corrupt xref entities dropped",
- caches.xref_dropped
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!(
+ "Warning: {} corrupt xref entities dropped",
+ caches.xref_dropped
+ )
+ .as_ref(),
+ );
}
for info in &caches.xrefs {
match info.status {
@@ -1367,342 +1374,345 @@ pub(super) fn on_open_file(&mut self) -> Task {
.push_output(crate::tf!("XREF Loaded \"{}\"", info.name).as_ref());
}
crate::io::xref::XrefStatus::Recovered => {
- self.command_line.push_error(crate::tf!(
- "XREF Recovered with warnings: \"{}\"",
- info.name
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!("XREF Recovered with warnings: \"{}\"", info.name).as_ref(),
+ );
}
crate::io::xref::XrefStatus::NotFound => {
- self.command_line.push_error(crate::tf!(
- "XREF Not found: \"{}\" ({})",
- info.name, info.path
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!("XREF Not found: \"{}\" ({})", info.name, info.path).as_ref(),
+ );
}
crate::io::xref::XrefStatus::Failed => {
- self.command_line.push_error(crate::tf!(
- "XREF Recovery failed: \"{}\" ({})",
- info.name, info.path
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!("XREF Recovery failed: \"{}\" ({})", info.name, info.path)
+ .as_ref(),
+ );
}
crate::io::xref::XrefStatus::Unloaded => {
- self.command_line
- .push_info(crate::tf!("XREF Unloaded (skipped): \"{}\"", info.name).as_ref());
+ self.command_line.push_info(
+ crate::tf!("XREF Unloaded (skipped): \"{}\"", info.name).as_ref(),
+ );
}
}
}
- #[cfg(not(target_arch = "wasm32"))]
- let thumbs_task = self.push_recent(path.clone());
- #[cfg(target_arch = "wasm32")]
- let thumbs_task = Task::none();
+ #[cfg(not(target_arch = "wasm32"))]
+ let thumbs_task = self.push_recent(path.clone());
+ #[cfg(target_arch = "wasm32")]
+ let thumbs_task = Task::none();
- let current_is_empty = {
- let t = &self.tabs[self.active_tab];
- !t.is_start
- && t.current_path.is_none()
- && !t.dirty
- && self.tabs[self.active_tab].scene.document.entities().count() == 0
- };
- let i = if current_is_empty {
- self.active_tab
- } else {
- self.tab_counter += 1;
- let new_tab = crate::app::document::DocumentTab::new_drawing(self.tab_counter);
- self.tabs.push(new_tab);
- let idx = self.tabs.len() - 1;
- self.active_tab = idx;
- self.apply_display_defaults(idx);
- idx
- };
+ let current_is_empty = {
+ let t = &self.tabs[self.active_tab];
+ !t.is_start
+ && t.current_path.is_none()
+ && !t.dirty
+ && self.tabs[self.active_tab].scene.document.entities().count() == 0
+ };
+ let i = if current_is_empty {
+ self.active_tab
+ } else {
+ self.tab_counter += 1;
+ let new_tab = crate::app::document::DocumentTab::new_drawing(self.tab_counter);
+ self.tabs.push(new_tab);
+ let idx = self.tabs.len() - 1;
+ self.active_tab = idx;
+ self.apply_display_defaults(idx);
+ idx
+ };
- let mut recovery_report = recovery_needed.then(|| {
- crate::io::recovery::RecoveryReport::recovered(
- self.tabs[i].id,
- &path,
- size_bytes,
- caches.source_sha256.clone(),
- caches.read_stats.clone(),
- entity_count.saturating_add(caches.corrupt_dropped),
- caches.corrupt_dropped,
- caches.xref_dropped,
- &caches.xrefs,
- &doc.notifications,
- document_repaired,
- timings,
- total_ms,
- )
- });
- if let Some(report) = recovery_report.as_mut() {
- report.persist();
- }
+ let mut recovery_report = recovery_needed.then(|| {
+ crate::io::recovery::RecoveryReport::recovered(
+ self.tabs[i].id,
+ &path,
+ size_bytes,
+ caches.source_sha256.clone(),
+ caches.read_stats.clone(),
+ entity_count.saturating_add(caches.corrupt_dropped),
+ caches.corrupt_dropped,
+ caches.xref_dropped,
+ &caches.xrefs,
+ &doc.notifications,
+ document_repaired,
+ timings,
+ total_ms,
+ )
+ });
+ if let Some(report) = recovery_report.as_mut() {
+ report.persist();
+ }
- #[cfg(not(target_arch = "wasm32"))]
- let opened_fingerprint = self
- .opening
- .as_ref()
- .and_then(|opening| opening.fingerprint.clone());
- self.tabs[i].current_path = Some(path.clone());
- #[cfg(not(target_arch = "wasm32"))]
- self.install_native_edit_guard(i, &path, opened_fingerprint);
- self.tabs[i].scene.material_base_dir =
- path.parent().map(std::path::Path::to_path_buf);
- self.tabs[i].scene.document = doc;
- // Load persisted constraints after installing the document.
- self.tabs[i].scene.load_sketch_constraints_from_document();
- // named_parameters_design.md stage 2: same load-time hook,
- // for the document-wide parameter table.
- self.tabs[i].scene.load_named_parameters_from_document();
- self.tabs[i].active_layer = self.tabs[i]
- .scene
- .document
- .header
- .current_layer_name
- .clone();
- // A file saved without the built-in Standard styles (foreign
- // or damaged) gets them re-seeded so nothing dangles (#366).
- crate::app::style_ops::ensure_standard_styles(
- &mut self.tabs[i].scene.document,
- );
- // Follow the file's saved current UCS from the moment it opens.
- self.tabs[i].adopt_active_ucs_from_header();
- // Adopt the drawing's own Ortho ($ORTHOMODE) and running OSNAP
- // ($OSMODE) so each file keeps its own state.
- self.adopt_header_sysvars(i);
- // Route shared CJK ideographs to the language matching this
- // drawing's code page (web per-language font split). Drop the
- // glyph cache if it changed so Han re-resolves to the new
- // language's font; geometry is (re)built below regardless. (#141)
- if crate::scene::text::web_font::set_cjk_lang_from_codepage(
- &self.tabs[i].scene.document.header.code_page,
- ) {
- crate::scene::text::ttf_glyph::clear_fallback_cache();
- }
- // Current model-space annotation scale comes from the drawing's
- // CANNOSCALEVALUE (paper/drawing factor). Convert its inverse into
- // drawing units as well: metric annotation sizes are paper millimetres
- // and imperial annotation sizes are paper inches.
- // Current model-space annotation scale comes from the drawing's
- // CANNOSCALEVALUE (paper/drawing factor). Convert its paper unit into
- // the drawing's INSUNITS as well, so e.g. a metre drawing uses
- // 0.001 model units for 1 mm of paper at 1:1.
- let cannoscale_value = self.tabs[i].scene.document.header.annotation_scale_value;
- let unit_factor = self.tabs[i].scene.annotation_scale_unit_factor();
+ #[cfg(not(target_arch = "wasm32"))]
+ let opened_fingerprint = self
+ .opening
+ .as_ref()
+ .and_then(|opening| opening.fingerprint.clone());
+ self.tabs[i].current_path = Some(path.clone());
+ #[cfg(not(target_arch = "wasm32"))]
+ self.install_native_edit_guard(i, &path, opened_fingerprint);
+ self.tabs[i].scene.material_base_dir = path.parent().map(std::path::Path::to_path_buf);
+ self.tabs[i].scene.document = doc;
+ // Load parameters first so imported dimensional constraints
+ // can resolve their named driving values.
+ self.tabs[i].scene.load_named_parameters_from_document();
+ self.tabs[i]
+ .scene
+ .load_parametric_constraints_from_document();
+ self.tabs[i].active_layer = self.tabs[i]
+ .scene
+ .document
+ .header
+ .current_layer_name
+ .clone();
+ // A file saved without the built-in Standard styles (foreign
+ // or damaged) gets them re-seeded so nothing dangles (#366).
+ crate::app::style_ops::ensure_standard_styles(&mut self.tabs[i].scene.document);
+ // Follow the file's saved current UCS from the moment it opens.
+ self.tabs[i].adopt_active_ucs_from_header();
+ // Adopt the drawing's own Ortho ($ORTHOMODE) and running OSNAP
+ // ($OSMODE) so each file keeps its own state.
+ self.adopt_header_sysvars(i);
+ // Route shared CJK ideographs to the language matching this
+ // drawing's code page (web per-language font split). Drop the
+ // glyph cache if it changed so Han re-resolves to the new
+ // language's font; geometry is (re)built below regardless. (#141)
+ if crate::scene::text::web_font::set_cjk_lang_from_codepage(
+ &self.tabs[i].scene.document.header.code_page,
+ ) {
+ crate::scene::text::ttf_glyph::clear_fallback_cache();
+ }
+ // Current model-space annotation scale comes from the drawing's
+ // CANNOSCALEVALUE (paper/drawing factor). Convert its inverse into
+ // drawing units as well: metric annotation sizes are paper millimetres
+ // and imperial annotation sizes are paper inches.
+ // Current model-space annotation scale comes from the drawing's
+ // CANNOSCALEVALUE (paper/drawing factor). Convert its paper unit into
+ // the drawing's INSUNITS as well, so e.g. a metre drawing uses
+ // 0.001 model units for 1 mm of paper at 1:1.
+ let cannoscale_value = self.tabs[i].scene.document.header.annotation_scale_value;
+ let unit_factor = self.tabs[i].scene.annotation_scale_unit_factor();
- self.tabs[i].scene.annotation_scale = if cannoscale_value > 1e-9 {
- ((1.0 / cannoscale_value) / unit_factor) as f32
- } else {
- (1.0 / unit_factor) as f32
- };
+ self.tabs[i].scene.annotation_scale = if cannoscale_value > 1e-9 {
+ ((1.0 / cannoscale_value) / unit_factor) as f32
+ } else {
+ (1.0 / unit_factor) as f32
+ };
- // Open-time breakdown so regressions are visible immediately.
- // `total` is wall time from the Open click to here (post-xref,
- // pre-first-frame); the phase figures are the background-thread
- // parse/purge/cache spans plus the UI-thread xref resolve.
- self.command_line.push_info(crate::tf!(
- " parse {}ms · purge {}ms · caches {}ms · xref {}ms · total {}ms",
- timings.parse_ms, timings.purge_ms, timings.caches_ms, timings.xref_ms, total_ms
- ).as_ref());
+ // Open-time breakdown so regressions are visible immediately.
+ // `total` is wall time from the Open click to here (post-xref,
+ // pre-first-frame); the phase figures are the background-thread
+ // parse/purge/cache spans plus the UI-thread xref resolve.
+ self.command_line.push_info(
+ crate::tf!(
+ " parse {}ms · purge {}ms · caches {}ms · xref {}ms · total {}ms",
+ timings.parse_ms,
+ timings.purge_ms,
+ timings.caches_ms,
+ timings.xref_ms,
+ total_ms
+ )
+ .as_ref(),
+ );
- // Caches were built on the background thread inside open_path().
- self.tabs[i].scene.local_extent_max = caches.local_extent_max;
- self.tabs[i].scene.local_center = caches.local_center;
- self.tabs[i].scene.hatches = caches.hatches;
- self.tabs[i].scene.images = caches.images;
- self.tabs[i].scene.meshes = caches.meshes;
- self.tabs[i].scene.block_meshes = caches.block_meshes;
- self.tabs[i].scene.object_data_cache = caches.object_data;
+ // Caches were built on the background thread inside open_path().
+ self.tabs[i].scene.local_extent_max = caches.local_extent_max;
+ self.tabs[i].scene.local_center = caches.local_center;
+ self.tabs[i].scene.hatches = caches.hatches;
+ self.tabs[i].scene.images = caches.images;
+ self.tabs[i].scene.meshes = caches.meshes;
+ self.tabs[i].scene.block_meshes = caches.block_meshes;
+ self.tabs[i].scene.object_data_cache = caches.object_data;
let prepared_geometry = caches.prepared_geometry.take();
- // Invalidate the wire cache so the new document is tessellated.
- self.tabs[i].scene.bump_geometry();
- if let Some(prepared) = prepared_geometry {
- self.tabs[i].scene.install_prepared_open_geometry(prepared);
- }
- // Pay for the interaction index here, not on the first hover.
- self.tabs[i].scene.warm_interaction_caches();
- self.tabs[i]
- .scene
- .replace_selection(rustc_hash::FxHashSet::default());
- self.tabs[i].scene.preview_wires = vec![];
- // Reopen in whichever space the file was saved in — the CTAB
- // tab name when recorded, else the $TILEMODE model/paper flag —
- // instead of always landing in Model.
- {
- let names = self.tabs[i].scene.layout_names();
- let saved = crate::io::saved_active_layout(&self.tabs[i].scene.document)
- .and_then(|n| {
- names.iter().find(|x| x.eq_ignore_ascii_case(&n)).cloned()
- });
- self.tabs[i].scene.current_layout = match saved {
- Some(n) => n,
- None if self.tabs[i].scene.document.header.show_model_space => {
- "Model".to_string()
- }
- // Paper was active but no CTAB — fall back to the first
- // paper layout (names[0] is always "Model").
- None => names
- .into_iter()
- .nth(1)
- .unwrap_or_else(|| "Model".to_string()),
- };
- self.tabs[i].scene.load_current_layout_state();
- self.tabs[i].refresh_active_ucs();
- }
- // Object isolation is session-only. A newly opened drawing must
- // not inherit the previous tab's filter, and persisted entity
- // visibility remains independent (not an isolation session).
- self.tabs[i].scene.reset_transient_visibility();
- crate::io::linetypes::populate_document(&mut self.tabs[i].scene.document);
- self.tabs[i].properties = PropertiesPanel::empty();
- // Seed the current table / multileader style from the file's
- // header so the ✓ marks the right one (text/dim/mline come from
- // the document header directly). DXF provides these via
- // $CTABLESTYLE / $CMLEADERSTYLE; DWG leaves them at "Standard".
- self.ribbon.active_table_style = self.tabs[i]
- .scene
- .document
- .header
- .current_table_style_name
- .clone();
- self.tabs[i].active_mleader_style = self.tabs[i]
- .scene
- .document
- .header
- .current_mleader_style_name
- .clone();
- let doc_layers = self.tabs[i].scene.document.layers.clone();
- let vp_info = self.tabs[i].scene.viewport_list();
- self.tabs[i]
- .layers
- .sync_with_viewports(&doc_layers, vp_info);
- self.sync_ribbon_layers();
- // Load the Annotate-ribbon style dropdowns (text / dimension /
- // multileader / table) from the opened document instead of
- // leaving them on the hard-coded "Standard" default.
- self.sync_ribbon_styles();
- // Reset the Home-ribbon Color / Linetype / Lineweight chips
- // to the newly opened document's CECOLOR / CELTYPE / CELWEIGHT
- // defaults (or to ByLayer when the file leaves them empty).
- // Without this they stick to whatever the prior tab had
- // selected — see #21.
- self.sync_ribbon_from_selection();
- self.tabs[i].scene.restore_saved_camera();
- // Grid/snap are per-drawing view settings — adopt the opened
- // file's active viewport state rather than a global preference.
- self.adopt_view_display(i);
- self.sync_render_mode_to_active_tile(i);
- self.tabs[i].last_synced_camera_gen = self.tabs[i].scene.camera_generation;
- self.tabs[i].dirty = document_repaired;
- self.tabs[i].recovery_save_as_required = document_repaired;
- self.tabs[i].history = crate::app::document::HistoryState::default();
- self.refresh_properties();
- #[cfg(not(target_arch = "wasm32"))]
- let interaction_task = {
- let wires = self.tabs[i].scene.hit_test_wires();
- let screen_height = self.tabs[i].scene.selection.borrow().vp_size.1;
- self.prepare_interaction_index_task(i, wires, screen_height)
- .unwrap_or_else(Task::none)
- };
- #[cfg(target_arch = "wasm32")]
- let interaction_task = Task::none();
+ // Invalidate the wire cache so the new document is tessellated.
+ self.tabs[i].scene.bump_geometry();
+ if let Some(prepared) = prepared_geometry {
+ self.tabs[i].scene.install_prepared_open_geometry(prepared);
+ }
+ // Pay for the interaction index here, not on the first hover.
+ self.tabs[i].scene.warm_interaction_caches();
+ self.tabs[i]
+ .scene
+ .replace_selection(rustc_hash::FxHashSet::default());
+ self.tabs[i].scene.preview_wires = vec![];
+ // Reopen in whichever space the file was saved in — the CTAB
+ // tab name when recorded, else the $TILEMODE model/paper flag —
+ // instead of always landing in Model.
+ {
+ let names = self.tabs[i].scene.layout_names();
+ let saved = crate::io::saved_active_layout(&self.tabs[i].scene.document)
+ .and_then(|n| names.iter().find(|x| x.eq_ignore_ascii_case(&n)).cloned());
+ self.tabs[i].scene.current_layout = match saved {
+ Some(n) => n,
+ None if self.tabs[i].scene.document.header.show_model_space => "Model".to_string(),
+ // Paper was active but no CTAB — fall back to the first
+ // paper layout (names[0] is always "Model").
+ None => names
+ .into_iter()
+ .nth(1)
+ .unwrap_or_else(|| "Model".to_string()),
+ };
+ self.tabs[i].scene.load_current_layout_state();
+ self.tabs[i].refresh_active_ucs();
+ }
+ // Object isolation is session-only. A newly opened drawing must
+ // not inherit the previous tab's filter, and persisted entity
+ // visibility remains independent (not an isolation session).
+ self.tabs[i].scene.reset_transient_visibility();
+ crate::io::linetypes::populate_document(&mut self.tabs[i].scene.document);
+ self.tabs[i].properties = PropertiesPanel::empty();
+ // Seed the current table / multileader style from the file's
+ // header so the ✓ marks the right one (text/dim/mline come from
+ // the document header directly). DXF provides these via
+ // $CTABLESTYLE / $CMLEADERSTYLE; DWG leaves them at "Standard".
+ self.ribbon.active_table_style = self.tabs[i]
+ .scene
+ .document
+ .header
+ .current_table_style_name
+ .clone();
+ self.tabs[i].active_mleader_style = self.tabs[i]
+ .scene
+ .document
+ .header
+ .current_mleader_style_name
+ .clone();
+ let doc_layers = self.tabs[i].scene.document.layers.clone();
+ let vp_info = self.tabs[i].scene.viewport_list();
+ self.tabs[i]
+ .layers
+ .sync_with_viewports(&doc_layers, vp_info);
+ self.sync_ribbon_layers();
+ // Load the Annotate-ribbon style dropdowns (text / dimension /
+ // multileader / table) from the opened document instead of
+ // leaving them on the hard-coded "Standard" default.
+ self.sync_ribbon_styles();
+ // Reset the Home-ribbon Color / Linetype / Lineweight chips
+ // to the newly opened document's CECOLOR / CELTYPE / CELWEIGHT
+ // defaults (or to ByLayer when the file leaves them empty).
+ // Without this they stick to whatever the prior tab had
+ // selected — see #21.
+ self.sync_ribbon_from_selection();
+ self.tabs[i].scene.restore_saved_camera();
+ // Grid/snap are per-drawing view settings — adopt the opened
+ // file's active viewport state rather than a global preference.
+ self.adopt_view_display(i);
+ self.sync_render_mode_to_active_tile(i);
+ self.tabs[i].last_synced_camera_gen = self.tabs[i].scene.camera_generation;
+ self.tabs[i].dirty = document_repaired;
+ self.tabs[i].recovery_save_as_required = document_repaired;
+ self.tabs[i].history = crate::app::document::HistoryState::default();
+ self.refresh_properties();
+ #[cfg(not(target_arch = "wasm32"))]
+ let interaction_task = {
+ let wires = self.tabs[i].scene.hit_test_wires();
+ let screen_height = self.tabs[i].scene.selection.borrow().vp_size.1;
+ self.prepare_interaction_index_task(i, wires, screen_height)
+ .unwrap_or_else(Task::none)
+ };
+ #[cfg(target_arch = "wasm32")]
+ let interaction_task = Task::none();
if let Some(opening) = &self.opening {
opening
.state
.set(crate::app::OPEN_PHASE_FINALIZING, 10000, 1, 1);
}
self.opening.take();
- let pending_open_task = if let Some(report) = recovery_report {
- self.recovery_report = Some(report);
- self.active_modal = Some(crate::app::ModalKind::Recovery);
- Task::none()
- } else {
- self.drain_pending_open()
- };
- Task::batch([thumbs_task, pending_open_task, interaction_task])
+ let pending_open_task = if let Some(report) = recovery_report {
+ self.recovery_report = Some(report);
+ self.active_modal = Some(crate::app::ModalKind::Recovery);
+ Task::none()
+ } else {
+ self.drain_pending_open()
+ };
+ Task::batch([thumbs_task, pending_open_task, interaction_task])
}
- pub(super) fn on_wblock_save_result_some(&mut self, block_name: String, path: std::path::PathBuf,
+ pub(super) fn on_wblock_save_result_some(
+ &mut self,
+ block_name: String,
+ path: std::path::PathBuf,
) -> Task {
- let i = self.active_tab;
- let document = self.tabs[i].scene.document.clone();
- let handles: Vec<_> = self.tabs[i].scene.selected.iter().copied().collect();
+ let i = self.active_tab;
+ let document = self.tabs[i].scene.document.clone();
+ let handles: Vec<_> = self.tabs[i].scene.selected.iter().copied().collect();
let worker_name = block_name.clone();
let worker_path = path.clone();
background_task(
move || {
let document = if worker_name == "*" {
- crate::modules::insert::wblock::extract_entities_to_doc(
- &document,
- &handles,
- )
+ crate::modules::insert::wblock::extract_entities_to_doc(&document, &handles)
} else {
- crate::modules::insert::wblock::extract_block_to_doc(
- &document,
- &worker_name)
+ crate::modules::insert::wblock::extract_block_to_doc(&document, &worker_name)
}
- .map_err(|e| e.to_string())?; crate::io::save(&document, &worker_path).map_err(|e| e.to_string())
- },
- move |result| Message::WblockWriteFinished(block_name, path, result),)
+ .map_err(|e| e.to_string())?;
+ crate::io::save(&document, &worker_path).map_err(|e| e.to_string())
+ },
+ move |result| Message::WblockWriteFinished(block_name, path, result),
+ )
}
pub(super) fn on_stl_export_path_some(&mut self, path: std::path::PathBuf) -> Task {
- // Re-build STL bytes (we can't easily pass them through the message).
- let i = self.active_tab;
- // STL gets the highest-resolution LOD (slot 0) so the
- // exported geometry isn't downgraded by the view-dependent
- // mesh LOD ladder used for rendering.
- let meshes: Vec = self.tabs[i]
- .scene
- .meshes
- .values()
- .filter_map(|s| s.lods.first().cloned())
- .collect();
- let worker_path = path.clone();
+ // Re-build STL bytes (we can't easily pass them through the message).
+ let i = self.active_tab;
+ // STL gets the highest-resolution LOD (slot 0) so the
+ // exported geometry isn't downgraded by the view-dependent
+ // mesh LOD ladder used for rendering.
+ let meshes: Vec = self.tabs[i]
+ .scene
+ .meshes
+ .values()
+ .filter_map(|s| s.lods.first().cloned())
+ .collect();
+ let worker_path = path.clone();
background_task(
move || {
let mesh_refs: Vec<_> = meshes.iter().collect();
let bytes = crate::io::stl::build_stl(&mesh_refs)
.ok_or_else(|| "no mesh data to export".to_string())?;
std::fs::write(&worker_path, bytes).map_err(|e| e.to_string())
- },
- move |result| Message::StlExportFinished(path, result),)
+ },
+ move |result| Message::StlExportFinished(path, result),
+ )
}
pub(super) fn on_step_export_path_some(&mut self, path: std::path::PathBuf) -> Task {
- let i = self.active_tab;
- // Export uses LOD 0 (full resolution); see StlExportPath above.
- let meshes: Vec = self.tabs[i]
- .scene
- .meshes
- .values()
- .filter_map(|s| s.lods.first().cloned())
- .collect();
- let worker_path = path.clone();
+ let i = self.active_tab;
+ // Export uses LOD 0 (full resolution); see StlExportPath above.
+ let meshes: Vec = self.tabs[i]
+ .scene
+ .meshes
+ .values()
+ .filter_map(|s| s.lods.first().cloned())
+ .collect();
+ let worker_path = path.clone();
background_task(
move || {
let mesh_refs: Vec<_> = meshes.iter().collect();
let text = crate::io::step::build_step(&mesh_refs)
.ok_or_else(|| "no mesh data to export".to_string())?;
std::fs::write(&worker_path, text.as_bytes()).map_err(|e| e.to_string())
- },
- move |result| Message::StepExportFinished(path, result),)
+ },
+ move |result| Message::StepExportFinished(path, result),
+ )
}
pub(super) fn on_obj_import_path_some(&mut self, path: std::path::PathBuf) -> Task {
- let tab_id = self.tabs[self.active_tab].id;
+ let tab_id = self.tabs[self.active_tab].id;
let worker_path = path.clone();
background_task(
move || {
- let src = std::fs::read_to_string(&worker_path).map_err(|e| e.to_string())?; crate::io::obj::parse_obj(&src, [0.7, 0.7, 0.85, 1.0])
- .ok_or_else(|| "no usable geometry in file".to_string())
+ let src = std::fs::read_to_string(&worker_path).map_err(|e| e.to_string())?;
+ crate::io::obj::parse_obj(&src, [0.7, 0.7, 0.85, 1.0])
+ .ok_or_else(|| "no usable geometry in file".to_string())
},
- move |result| Message::ObjImportFinished(tab_id, path, result),)
+ move |result| Message::ObjImportFinished(tab_id, path, result),
+ )
}
fn sync_view_state_for_save(&mut self, i: usize) {
self.sync_vport_display(i);
if self.tabs[i].active_block_edit.is_none() {
self.tabs[i].scene.sync_camera_to_document();
- self.tabs[i].last_synced_camera_gen =
- self.tabs[i].scene.camera_generation;
+ self.tabs[i].last_synced_camera_gen = self.tabs[i].scene.camera_generation;
}
}
@@ -1711,16 +1721,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.sync_view_state_for_save(i);
sync_annotation_scale_header(&mut self.tabs[i].scene);
self.stamp_header_sysvars(i);
- self.tabs[i].scene.document.header.user_real1 =
- self.tabs[i].scene.annotation_scale as f64;
+ self.tabs[i].scene.document.header.user_real1 = self.tabs[i].scene.annotation_scale as f64;
self.sync_solid_models_for_save(i);
- // Materialize constraints immediately before serialization.
- self.tabs[i].scene.materialize_sketch_constraints_for_save();
- // named_parameters_design.md stage 2: same save-time hook, for the
- // document-wide parameter table.
- self.tabs[i].scene.materialize_named_parameters_for_save();
- // Keep the optional native constraint graph synchronized on save.
- self.tabs[i].scene.materialize_dwg_native_constraints_for_save(self.write_dwg_native_constraints);
+ self.tabs[i].scene.sync_native_parametric_graph();
}
#[cfg(not(target_arch = "wasm32"))]
@@ -1837,11 +1840,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
let mut recent_task = Task::none();
- let saved = match crate::io::save_to_bytes(
- &self.tabs[i].scene.document,
- &ext,
- version,
- ) {
+ let saved = match crate::io::save_to_bytes(&self.tabs[i].scene.document, &ext, version) {
Ok(bytes) => {
crate::sys::download_bytes(&filename, &bytes);
let cache_name = std::path::Path::new(&filename)
@@ -1929,13 +1928,11 @@ pub(super) fn on_open_file(&mut self) -> Task {
&& self.tabs[i].recovery_save_as_required
&& destination_is_current
{
- self.command_line.push_error_once(
- crate::tr!("recovery", "save-new-file-required").as_ref(),
- );
+ self.command_line
+ .push_error_once(crate::tr!("recovery", "save-new-file-required").as_ref());
self.restore_failed_save_continuation(continuation, i);
self.active_tab = i;
- self.save_dialog_for_unsaved =
- continuation != crate::app::SaveContinuation::None;
+ self.save_dialog_for_unsaved = continuation != crate::app::SaveContinuation::None;
if capture_ready {
self.thumbnail_capture_clean = false;
}
@@ -1946,12 +1943,15 @@ pub(super) fn on_open_file(&mut self) -> Task {
&& self.tabs[i].edit_lock_conflict
{
let error = "Drawing edit lock is held by another editor.".to_string();
- self.command_line.push_error_once(crate::tf!(
- "Unable to save \"{}\": {error}",
- path.file_name()
- .map(|name| name.to_string_lossy().into_owned())
- .unwrap_or_else(|| path.display().to_string())
- ).as_ref());
+ self.command_line.push_error_once(
+ crate::tf!(
+ "Unable to save \"{}\": {error}",
+ path.file_name()
+ .map(|name| name.to_string_lossy().into_owned())
+ .unwrap_or_else(|| path.display().to_string())
+ )
+ .as_ref(),
+ );
self.pending_save_failure = Some(crate::app::PendingSaveFailure {
tab_id,
path,
@@ -1973,22 +1973,18 @@ pub(super) fn on_open_file(&mut self) -> Task {
&& i == self.active_tab
&& !self.thumbnail_capture_clean
&& self.main_window.is_some()
- && crate::ui::wrap_bar::dropdown_bounds(
- crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID,
- )
- .is_some()
+ && crate::ui::wrap_bar::dropdown_bounds(crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID)
+ .is_some()
{
- self.pending_native_thumbnail_save = Some(
- crate::app::PendingNativeThumbnailSave {
- tab_id,
- path,
- version,
- purpose,
- continuation,
- set_current_path,
- check_external_change,
- },
- );
+ self.pending_native_thumbnail_save = Some(crate::app::PendingNativeThumbnailSave {
+ tab_id,
+ path,
+ version,
+ purpose,
+ continuation,
+ set_current_path,
+ check_external_change,
+ });
self.thumbnail_capture_clean = true;
return Task::none();
}
@@ -1999,12 +1995,15 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.pending_save_leases.insert(tab_id, lease);
}
Err(crate::io::edit_lock::EditLeaseError::Locked(error)) => {
- self.command_line.push_error_once(crate::tf!(
- "Unable to save \"{}\": {error}",
- path.file_name()
- .map(|name| name.to_string_lossy().into_owned())
- .unwrap_or_else(|| path.display().to_string())
- ).as_ref());
+ self.command_line.push_error_once(
+ crate::tf!(
+ "Unable to save \"{}\": {error}",
+ path.file_name()
+ .map(|name| name.to_string_lossy().into_owned())
+ .unwrap_or_else(|| path.display().to_string())
+ )
+ .as_ref(),
+ );
self.pending_save_failure = Some(crate::app::PendingSaveFailure {
tab_id,
path,
@@ -2022,9 +2021,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
return Task::none();
}
Err(crate::io::edit_lock::EditLeaseError::Unavailable(error)) => {
- self.command_line.push_info(crate::tf!(
- "{error}. External-change checks remain active."
- ).as_ref());
+ self.command_line.push_info(
+ crate::tf!("{error}. External-change checks remain active.").as_ref(),
+ );
}
}
}
@@ -2035,9 +2034,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
let thumbnail = (purpose != crate::app::SavePurpose::Autosave && i == self.active_tab)
.then_some(version >= acadrust::DxfVersion::AC1027);
let capture_bounds = thumbnail.and_then(|_| {
- crate::ui::wrap_bar::dropdown_bounds(
- crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID,
- )
+ crate::ui::wrap_bar::dropdown_bounds(crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID)
});
let clone_started = iced::time::Instant::now();
let snapshot = self.tabs[i].scene.document.clone();
@@ -2057,8 +2054,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
let previous_autosave =
(purpose != crate::app::SavePurpose::Autosave).then(|| self.autosave_target(i));
let backup = purpose != crate::app::SavePurpose::Autosave && self.backup_on_save;
- let verification = if check_external_change
- && purpose != crate::app::SavePurpose::Autosave
+ let verification = if check_external_change && purpose != crate::app::SavePurpose::Autosave
{
let expected = if set_current_path {
None
@@ -2072,11 +2068,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
expected,
)
} else if destination_is_current {
- Self::native_save_verification(
- &path,
- self.tabs[i].edit_lease.as_mut(),
- expected,
- )
+ Self::native_save_verification(&path, self.tabs[i].edit_lease.as_mut(), expected)
} else {
Self::native_save_verification(&path, None, expected)
}
@@ -2133,7 +2125,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
verify_reader,
path,
previous_autosave,
- ) = work.take().expect("save capture produced more than one result");
+ ) = work
+ .take()
+ .expect("save capture produced more than one result");
Task::perform(
async move {
let (result, refreshed_preview) = std::thread::spawn(move || {
@@ -2192,12 +2186,14 @@ pub(super) fn on_open_file(&mut self) -> Task {
)
};
match capture_window {
- Some(window) => iced::window::screenshot(window).map(Some).then(move |screenshot| {
- Task::batch([
- Task::done(Message::ThumbnailCaptureFinished),
- run_save(screenshot),
- ])
- }),
+ Some(window) => iced::window::screenshot(window)
+ .map(Some)
+ .then(move |screenshot| {
+ Task::batch([
+ Task::done(Message::ThumbnailCaptureFinished),
+ run_save(screenshot),
+ ])
+ }),
None => {
self.thumbnail_capture_clean = false;
run_save(None)
@@ -2206,12 +2202,8 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
#[cfg(not(target_arch = "wasm32"))]
- pub(super) fn on_save_finished(
- &mut self,
- outcome: crate::app::SaveOutcome,
- ) -> Task {
- let latest = self.active_save_jobs.get(&outcome.tab_id).copied()
- == Some(outcome.job_id);
+ pub(super) fn on_save_finished(&mut self, outcome: crate::app::SaveOutcome) -> Task {
+ let latest = self.active_save_jobs.get(&outcome.tab_id).copied() == Some(outcome.job_id);
if latest {
self.active_save_jobs.remove(&outcome.tab_id);
}
@@ -2231,17 +2223,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
if let Err(error) = &outcome.result {
- if error.externally_modified
- && outcome.purpose != crate::app::SavePurpose::Autosave
- {
+ if error.externally_modified && outcome.purpose != crate::app::SavePurpose::Autosave {
let file_name = outcome
.path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| outcome.path.display().to_string());
- self.command_line.push_error_once(crate::tf!(
- "Save stopped: \"{file_name}\" changed outside Open CAD Studio."
- ).as_ref());
+ self.command_line.push_error_once(
+ crate::tf!("Save stopped: \"{file_name}\" changed outside Open CAD Studio.")
+ .as_ref(),
+ );
self.pending_external_change = Some(crate::app::PendingExternalChange {
tab_id: outcome.tab_id,
path: outcome.path.clone(),
@@ -2260,9 +2251,12 @@ pub(super) fn on_open_file(&mut self) -> Task {
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| outcome.path.display().to_string());
- self.command_line.push_error_once(crate::tf!(
- "Unable to save \"{file_name}\": file is in use by another application."
- ).as_ref());
+ self.command_line.push_error_once(
+ crate::tf!(
+ "Unable to save \"{file_name}\": file is in use by another application."
+ )
+ .as_ref(),
+ );
self.pending_save_failure = Some(crate::app::PendingSaveFailure {
tab_id: outcome.tab_id,
path: outcome.path.clone(),
@@ -2310,16 +2304,15 @@ pub(super) fn on_open_file(&mut self) -> Task {
let mut tasks = Vec::new();
match outcome.purpose {
crate::app::SavePurpose::Autosave => {
- self.command_line.push_output(crate::t!("Autosaved 1 drawing").as_ref());
+ self.command_line
+ .push_output(crate::t!("Autosaved 1 drawing").as_ref());
}
crate::app::SavePurpose::Manual | crate::app::SavePurpose::SaveAs => {
let path_changed = outcome.set_current_path
&& self.tabs[i]
.current_path
.as_deref()
- .is_none_or(|current| {
- !native_paths_match(current, &outcome.path)
- });
+ .is_none_or(|current| !native_paths_match(current, &outcome.path));
self.command_line
.push_output(crate::tf!("Saved: {}", outcome.path.display()).as_ref());
if let Some(previous) = outcome.previous_autosave {
@@ -2385,9 +2378,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
) {
self.pending_close = match continuation {
crate::app::SaveContinuation::None => None,
- crate::app::SaveContinuation::CloseTab => {
- Some(crate::app::PendingClose::Tab(tab_idx))
- }
+ crate::app::SaveContinuation::CloseTab => Some(crate::app::PendingClose::Tab(tab_idx)),
crate::app::SaveContinuation::Quit => Some(crate::app::PendingClose::Quit),
};
}
@@ -2442,8 +2433,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.close_active_modal();
self.restore_failed_save_continuation(failure.continuation, i);
self.active_tab = i;
- self.save_dialog_for_unsaved =
- failure.continuation != crate::app::SaveContinuation::None;
+ self.save_dialog_for_unsaved = failure.continuation != crate::app::SaveContinuation::None;
self.open_save_dialog_window(i)
}
@@ -2485,8 +2475,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.close_active_modal();
self.restore_failed_save_continuation(conflict.continuation, i);
self.active_tab = i;
- self.save_dialog_for_unsaved =
- conflict.continuation != crate::app::SaveContinuation::None;
+ self.save_dialog_for_unsaved = conflict.continuation != crate::app::SaveContinuation::None;
self.open_save_dialog_window(i)
}
@@ -2522,40 +2511,41 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
pub(super) fn on_save_file(&mut self) -> Task {
- if self.read_only {
- self.command_line
- .push_error(crate::t!("Read-only session (--read-only): saving is disabled.").as_ref());
- return Task::none();
- }
- let i = self.active_tab;
- // Web serializes immediately below. Native preparation happens
- // once after the destination/version is known.
- #[cfg(target_arch = "wasm32")]
- {
- self.sync_view_state_for_save(i);
- self.stamp_header_sysvars(i);
- }
- // Native: save straight to the known path. Web has no path
- // (downloads instead), so always go through the Save dialog.
- #[cfg(not(target_arch = "wasm32"))]
- if !self.tabs[i].recovery_save_as_required {
- if let Some(path) = self.tabs[i].current_path.clone() {
- // A direct Save preserves the document's current version.
- let ver = self.tabs[i].scene.document.version;
- self.prepare_native_save(i);
- return self.queue_native_save(
- i,
- path,
- ver,
- crate::app::SavePurpose::Manual,
- crate::app::SaveContinuation::None,
- false,
- true,
- );
- }
- }
- self.save_dialog_for_unsaved = false;
- self.save_with_default_format(i)
+ if self.read_only {
+ self.command_line.push_error(
+ crate::t!("Read-only session (--read-only): saving is disabled.").as_ref(),
+ );
+ return Task::none();
+ }
+ let i = self.active_tab;
+ // Web serializes immediately below. Native preparation happens
+ // once after the destination/version is known.
+ #[cfg(target_arch = "wasm32")]
+ {
+ self.sync_view_state_for_save(i);
+ self.stamp_header_sysvars(i);
+ }
+ // Native: save straight to the known path. Web has no path
+ // (downloads instead), so always go through the Save dialog.
+ #[cfg(not(target_arch = "wasm32"))]
+ if !self.tabs[i].recovery_save_as_required {
+ if let Some(path) = self.tabs[i].current_path.clone() {
+ // A direct Save preserves the document's current version.
+ let ver = self.tabs[i].scene.document.version;
+ self.prepare_native_save(i);
+ return self.queue_native_save(
+ i,
+ path,
+ ver,
+ crate::app::SavePurpose::Manual,
+ crate::app::SaveContinuation::None,
+ false,
+ true,
+ );
+ }
+ }
+ self.save_dialog_for_unsaved = false;
+ self.save_with_default_format(i)
}
/// Save without the version picker: use the configured default and go straight to
@@ -2566,10 +2556,8 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.active_tab = tab_idx;
self.save_dialog_format = if self.tabs[tab_idx].recovery_save_as_required {
let document = &self.tabs[tab_idx].scene.document;
- let is_dxf = crate::io::source_is_dxf(
- self.tabs[tab_idx].current_path.as_deref(),
- document,
- );
+ let is_dxf =
+ crate::io::source_is_dxf(self.tabs[tab_idx].current_path.as_deref(), document);
let version = if is_dxf {
document.version
} else {
@@ -2599,110 +2587,104 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
pub(super) fn on_save_dialog_confirm(&mut self) -> Task {
- let (ext, version) = crate::io::parse_save_format(&self.save_dialog_format);
- // Warn before a lossy Save-As that would drop unsupported
- // (AEC / application) objects kept only as verbatim
- // source-version bytes — let the user keep them by saving in the
- // source version, or proceed and drop them.
- if !self.aec_drop_acknowledged {
- let is_dxf = ext.eq_ignore_ascii_case("dxf");
- let n = crate::io::dropped_on_save_count(
- &self.tabs[self.active_tab].scene.document,
- version,
- is_dxf,
- );
- if n > 0 {
- self.aec_drop_count = n;
- self.active_modal = Some(crate::app::ModalKind::AecDropWarning);
- return Task::none();
- }
- }
- // The user need not type an extension: append the selected
- // format's one when the entered name carries none.
- let name = self.save_dialog_filename.trim();
- let filename = if name.is_empty() {
- format!("drawing.{ext}")
- } else if std::path::Path::new(name).extension().is_none() {
- format!("{name}.{ext}")
- } else {
- name.to_string()
- };
- self.save_dialog_filename = filename.clone();
- let i = self.active_tab;
+ let (ext, version) = crate::io::parse_save_format(&self.save_dialog_format);
+ // Warn before a lossy Save-As that would drop unsupported
+ // (AEC / application) objects kept only as verbatim
+ // source-version bytes — let the user keep them by saving in the
+ // source version, or proceed and drop them.
+ if !self.aec_drop_acknowledged {
+ let is_dxf = ext.eq_ignore_ascii_case("dxf");
+ let n = crate::io::dropped_on_save_count(
+ &self.tabs[self.active_tab].scene.document,
+ version,
+ is_dxf,
+ );
+ if n > 0 {
+ self.aec_drop_count = n;
+ self.active_modal = Some(crate::app::ModalKind::AecDropWarning);
+ return Task::none();
+ }
+ }
+ // The user need not type an extension: append the selected
+ // format's one when the entered name carries none.
+ let name = self.save_dialog_filename.trim();
+ let filename = if name.is_empty() {
+ format!("drawing.{ext}")
+ } else if std::path::Path::new(name).extension().is_none() {
+ format!("{name}.{ext}")
+ } else {
+ name.to_string()
+ };
+ self.save_dialog_filename = filename.clone();
+ let i = self.active_tab;
- // Native: hand the destination choice to the OS save dialog —
- // it provides folder browsing and overwrite confirmation. The
- // chosen version rides in `save_dialog_format` and the write
- // happens in `on_save_dialog_path_picked` once a path returns.
- #[cfg(not(target_arch = "wasm32"))]
- {
- let seed_dir = self.tabs[i]
- .current_path
- .as_ref()
- .and_then(|p| p.parent().map(|d| d.to_path_buf()));
- let default_name = filename;
- let (filter_label, filter_ext): (&str, &str) =
- if ext.eq_ignore_ascii_case("dxf") {
- ("DXF Files", "dxf")
- } else {
- ("DWG Files", "dwg")
- };
- let close = self.close_save_dialog_window();
- let pick = Task::perform(
- async move {
- let mut dlg = crate::sys::file_dialog()
- .set_title(crate::t!("Save Drawing As").as_ref())
- .set_file_name(default_name)
- .add_filter(filter_label, &[filter_ext]);
- if let Some(dir) = seed_dir {
- dlg = dlg.set_directory(dir);
- }
- dlg.save_file().await.map(|h| crate::sys::handle_path(&h))
- },
- Message::SaveDialogPathPicked,
- );
- Task::batch([close, pick])
- }
- // Web: no filesystem — serialize and hand the browser a download.
- #[cfg(target_arch = "wasm32")]
- {
- let close = self.close_save_dialog_window();
- self.sync_view_state_for_save(i);
- sync_annotation_scale_header(&mut self.tabs[i].scene);
- self.stamp_header_sysvars(i);
- self.sync_solid_models_for_save(i);
- self.tabs[i].scene.materialize_sketch_constraints_for_save();
- self.tabs[i].scene.materialize_named_parameters_for_save();
- self.tabs[i].scene.materialize_dwg_native_constraints_for_save(self.write_dwg_native_constraints);
- let tab_id = self.tabs[i].id;
- let bounds = crate::ui::wrap_bar::dropdown_bounds(
- crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID,
- );
- let Some(bounds) = bounds else {
- return Task::batch([
- close,
- Task::done(Message::WebSaveScreenshot {
- tab_id,
- filename,
- ext: ext.to_string(),
- version,
- bounds: None,
- screenshot: None,
- }),
- ]);
- };
- self.pending_web_thumbnail_save = Some(
- crate::app::PendingWebThumbnailSave {
- tab_id,
- filename,
- ext: ext.to_string(),
- version,
- bounds,
- },
- );
- self.thumbnail_capture_clean = true;
- close
- }
+ // Native: hand the destination choice to the OS save dialog —
+ // it provides folder browsing and overwrite confirmation. The
+ // chosen version rides in `save_dialog_format` and the write
+ // happens in `on_save_dialog_path_picked` once a path returns.
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ let seed_dir = self.tabs[i]
+ .current_path
+ .as_ref()
+ .and_then(|p| p.parent().map(|d| d.to_path_buf()));
+ let default_name = filename;
+ let (filter_label, filter_ext): (&str, &str) = if ext.eq_ignore_ascii_case("dxf") {
+ ("DXF Files", "dxf")
+ } else {
+ ("DWG Files", "dwg")
+ };
+ let close = self.close_save_dialog_window();
+ let pick = Task::perform(
+ async move {
+ let mut dlg = crate::sys::file_dialog()
+ .set_title(crate::t!("Save Drawing As").as_ref())
+ .set_file_name(default_name)
+ .add_filter(filter_label, &[filter_ext]);
+ if let Some(dir) = seed_dir {
+ dlg = dlg.set_directory(dir);
+ }
+ dlg.save_file().await.map(|h| crate::sys::handle_path(&h))
+ },
+ Message::SaveDialogPathPicked,
+ );
+ Task::batch([close, pick])
+ }
+ // Web: no filesystem — serialize and hand the browser a download.
+ #[cfg(target_arch = "wasm32")]
+ {
+ let close = self.close_save_dialog_window();
+ self.sync_view_state_for_save(i);
+ sync_annotation_scale_header(&mut self.tabs[i].scene);
+ self.stamp_header_sysvars(i);
+ self.sync_solid_models_for_save(i);
+ self.tabs[i].scene.sync_native_parametric_graph();
+ let tab_id = self.tabs[i].id;
+ let bounds =
+ crate::ui::wrap_bar::dropdown_bounds(crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID);
+ let Some(bounds) = bounds else {
+ return Task::batch([
+ close,
+ Task::done(Message::WebSaveScreenshot {
+ tab_id,
+ filename,
+ ext: ext.to_string(),
+ version,
+ bounds: None,
+ screenshot: None,
+ }),
+ ]);
+ };
+ self.pending_web_thumbnail_save = Some(crate::app::PendingWebThumbnailSave {
+ tab_id,
+ filename,
+ ext: ext.to_string(),
+ version,
+ bounds,
+ });
+ self.thumbnail_capture_clean = true;
+ close
+ }
}
/// Native: a destination path came back from the OS save dialog — write the
@@ -2791,10 +2773,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
.chars()
.map(|c| if c.is_alphanumeric() { c } else { '_' })
.collect();
- std::env::temp_dir().join(format!(
- "OpenCADStudio_{safe}_{}.sv$",
- self.tabs[i].id
- ))
+ std::env::temp_dir().join(format!("OpenCADStudio_{safe}_{}.sv$", self.tabs[i].id))
}
}
}
@@ -2807,9 +2786,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
pub(super) fn on_autosave(&mut self) -> Task {
let mut tasks = Vec::new();
for i in 0..self.tabs.len() {
- if !self.tabs[i].dirty
- || self.active_save_jobs.contains_key(&self.tabs[i].id)
- {
+ if !self.tabs[i].dirty || self.active_save_jobs.contains_key(&self.tabs[i].id) {
continue;
}
self.prepare_native_save(i);
@@ -2889,10 +2866,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
area if area.starts_with("View: ") => PlotType::View,
_ => PlotType::Layout,
};
- ps.plot_view_name = plot_area
- .strip_prefix("View: ")
- .unwrap_or("")
- .to_string();
+ ps.plot_view_name = plot_area.strip_prefix("View: ").unwrap_or("").to_string();
if plot_area == "Window" {
if let Some((x0, y0, x1, y1)) = plot_window {
ps.set_plot_window(x0, y0, x1, y1);
@@ -2962,10 +2936,13 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.tabs[i].dirty = true;
self.tabs[i].scene.bump_geometry_no_blocks();
- self.command_line.push_info(crate::tf!(
- "Page setup: {w:.1}×{h:.1} mm area={plot_area} \
+ self.command_line.push_info(
+ crate::tf!(
+ "Page setup: {w:.1}×{h:.1} mm area={plot_area} \
center={center} rot={rotation}°"
- ).as_ref());
+ )
+ .as_ref(),
+ );
}
}
@@ -2986,32 +2963,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.load_plotsettings_into_dialog(&settings);
}
}
- let Some((wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip)) =
- self.direct_plot_params()
+ let Some(page) = self.direct_plot_page()
else {
- self.command_line
- .push_error(crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref());
+ self.command_line.push_error(
+ crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref(),
+ );
return Task::none();
};
- let plot_style = self.dialog_plot_style(&self.plot_dialog);
- let render_options = Self::pdf_plot_options(&self.plot_dialog, group_splits);
let worker_path = path.clone();
let work = move || {
- crate::io::pdf_export::export_pdf(
- &wires,
- &hatches,
- &wipeouts,
- page_w,
- page_h,
- ox,
- oy,
- rotation,
- scale,
- clip,
- &worker_path,
- plot_style.as_ref(),
- render_options,
- )
+ crate::io::pdf_export::export_pdf(&page, &worker_path)
.map(|_| crate::tf!("Exported: {}", worker_path.display()).into_owned())
.map_err(|e| crate::tf!("Export failed: {e}").into_owned())
};
@@ -3029,48 +2990,32 @@ pub(super) fn on_open_file(&mut self) -> Task {
"Extents" => self.extents_plot_job(),
_ => self.window_plot_job(),
};
- let Some((wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip)) =
- job
+ let Some(page) = job
else {
self.command_line
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
return Task::none();
};
- let plot_style = self.dialog_plot_style(&self.plot_dialog);
- let render_options = Self::pdf_plot_options(&self.plot_dialog, group_splits);
let worker_path = path.clone();
self.close_active_modal();
let work = move || {
- crate::io::pdf_export::export_pdf(
- &wires,
- &hatches,
- &wipeouts,
- page_w,
- page_h,
- ox,
- oy,
- rotation,
- scale,
- clip,
- &worker_path,
- plot_style.as_ref(),
- render_options,
- )
- .map(|_| {crate::tf!(
- "Plotted window to {}",
+ crate::io::pdf_export::export_pdf(&page, &worker_path)
+ .map(|_| {
+ crate::tf!(
+ "Plotted window to {}",
worker_path
- .file_name().unwrap_or_default().to_string_lossy()
- ).into_owned()
- }).map_err(|e| crate::tf!("Plot failed: {e}").into_owned())
+ .file_name()
+ .unwrap_or_default()
+ .to_string_lossy()
+ )
+ .into_owned()
+ })
+ .map_err(|e| crate::tf!("Plot failed: {e}").into_owned())
};
self.run_plot_work(self.plot_dialog.background, false, work)
}
- pub(super) fn report_plot_result(
- &mut self,
- result: Result,
- reopen_plot: bool,
- ) {
+ pub(super) fn report_plot_result(&mut self, result: Result, reopen_plot: bool) {
match result {
Ok(message) => self.command_line.push_info(&message),
Err(error) => self.command_line.push_error(&error),
@@ -3147,19 +3092,19 @@ pub(super) fn on_open_file(&mut self) -> Task {
.document
.header
.paper_space_linetype_scaling;
- let original_plimcheck = self.tabs[i]
- .scene
- .document
- .header
- .paper_space_limit_check;
+ let original_plimcheck = self.tabs[i].scene.document.header.paper_space_limit_check;
let original_dialog = self.plot_dialog.clone();
let original_style = self.active_plot_style.clone();
let original_window = self.plot_window;
let original_setup = self.plot_setup_template.clone();
let original_camera = self.tabs[i].scene.camera.borrow().clone();
let original_camera_generation = self.tabs[i].scene.camera_generation;
- let override_dialog = self.print_all_settings_override.then(|| original_dialog.clone());
- let override_style = self.print_all_settings_override.then(|| original_style.clone());
+ let override_dialog = self
+ .print_all_settings_override
+ .then(|| original_dialog.clone());
+ let override_style = self
+ .print_all_settings_override
+ .then(|| original_style.clone());
let result = (|| {
let mut pages = Vec::with_capacity(selected.len());
for name in selected {
@@ -3190,10 +3135,10 @@ pub(super) fn on_open_file(&mut self) -> Task {
return Err(crate::tf!(
"Layout '{name}' plot style table '{}' is not loaded.",
dialog.style_name
- ).into_owned());
+ )
+ .into_owned());
}
- let plot_style = self.dialog_plot_style(&dialog);
- let params = match dialog.area.as_str() {
+ let area_page = match dialog.area.as_str() {
"Display" => self.display_plot_job(),
"Extents" => self.extents_plot_job(),
"Limits" => self.limits_plot_job(),
@@ -3203,62 +3148,14 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
_ => None,
};
- let (
- wires,
- hatches,
- wipeouts,
- group_splits,
- paper_w,
- paper_h,
- offset_x,
- offset_y,
- rotation_deg,
- scale,
- clip,
- ) = if dialog.area == "Layout" {
- self.layout_plot_params_for("Layout")
+ let page = if dialog.area == "Layout" {
+ self.layout_plot_page_for("Layout")
} else {
- let (
- wires,
- hatches,
- wipeouts,
- group_splits,
- paper_w,
- paper_h,
- offset_x,
- offset_y,
- rotation_deg,
- scale,
- clip,
- ) = params.ok_or_else(|| crate::tf!("Layout '{name}' plot area is empty.").into_owned())?;
- (
- std::sync::Arc::new(wires),
- hatches,
- wipeouts,
- group_splits,
- paper_w,
- paper_h,
- offset_x,
- offset_y,
- rotation_deg,
- scale,
- clip,
- )
+ area_page.ok_or_else(|| {
+ crate::tf!("Layout '{name}' plot area is empty.").into_owned()
+ })?
};
- pages.push(crate::io::pdf_export::PdfPageInput {
- wires,
- hatches,
- wipeouts,
- paper_w,
- paper_h,
- offset_x,
- offset_y,
- rotation_deg,
- scale,
- clip,
- options: Self::pdf_plot_options(&dialog, group_splits),
- plot_style,
- });
+ pages.push(page);
}
Ok(pages)
})();
@@ -3269,11 +3166,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
.document
.header
.paper_space_linetype_scaling = original_psltscale;
- self.tabs[i]
- .scene
- .document
- .header
- .paper_space_limit_check = original_plimcheck;
+ self.tabs[i].scene.document.header.paper_space_limit_check = original_plimcheck;
self.plot_dialog = original_dialog;
self.active_plot_style = original_style;
self.plot_window = original_window;
@@ -3283,19 +3176,12 @@ pub(super) fn on_open_file(&mut self) -> Task {
result
}
- pub(super) fn on_print_all_pdf_path_some(
- &mut self,
- path: std::path::PathBuf,
- ) -> Task {
+ pub(super) fn on_print_all_pdf_path_some(&mut self, path: std::path::PathBuf) -> Task {
let dialog = self.plot_dialog.clone();
- if self.print_all_settings_override
- && dialog.style_missing
- && dialog.apply_plot_styles
- {
- self.command_line.push_error(crate::tf!(
- "Plot style table '{}' is not loaded.",
- dialog.style_name
- ).as_ref());
+ if self.print_all_settings_override && dialog.style_missing && dialog.apply_plot_styles {
+ self.command_line.push_error(
+ crate::tf!("Plot style table '{}' is not loaded.", dialog.style_name).as_ref(),
+ );
return Task::none();
}
let pages = match self.print_all_pages() {
@@ -3309,13 +3195,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.save_config();
self.close_active_modal();
let work = move || {
- crate::io::pdf_export::export_pdf_pages(
- &pages,
- &worker_path,
- None,
- )
- .map(|_| crate::tf!("Exported {} layouts to {}", pages.len(), worker_path.display()).into_owned())
- .map_err(|error| crate::tf!("Export failed: {error}").into_owned())
+ crate::io::pdf_export::export_pdf_pages(&pages, &worker_path, None)
+ .map(|_| {
+ crate::tf!(
+ "Exported {} layouts to {}",
+ pages.len(),
+ worker_path.display()
+ )
+ .into_owned()
+ })
+ .map_err(|error| crate::tf!("Export failed: {error}").into_owned())
};
self.run_print_all_work(dialog.background, work)
}
@@ -3323,22 +3212,18 @@ pub(super) fn on_open_file(&mut self) -> Task {
pub(super) fn on_print_all_print(&mut self) -> Task {
#[cfg(target_arch = "wasm32")]
{
- self.command_line.push_error(
- crate::t!("Printing is not available in the web version.").as_ref(),
- );
+ self.command_line
+ .push_error(crate::t!("Printing is not available in the web version.").as_ref());
Task::none()
}
#[cfg(not(target_arch = "wasm32"))]
{
let dialog = self.plot_dialog.clone();
- if self.print_all_settings_override
- && dialog.style_missing
- && dialog.apply_plot_styles
+ if self.print_all_settings_override && dialog.style_missing && dialog.apply_plot_styles
{
- self.command_line.push_error(crate::tf!(
- "Plot style table '{}' is not loaded.",
- dialog.style_name
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!("Plot style table '{}' is not loaded.", dialog.style_name).as_ref(),
+ );
return Task::none();
}
let pages = match self.print_all_pages() {
@@ -3348,24 +3233,22 @@ pub(super) fn on_open_file(&mut self) -> Task {
return Task::none();
}
};
- let options = self.plot_print_options(&dialog, Default::default());
+ let options = self.plot_print_options(&dialog);
let temp_path = crate::io::print_to_printer::temp_pdf_path("print_all");
self.save_config();
self.close_active_modal();
- self.command_line.push_info(
- crate::t!("Sending selected layouts to the system printer…").as_ref(),
- );
+ self.command_line
+ .push_info(crate::t!("Sending selected layouts to the system printer…").as_ref());
let work = move || {
- crate::io::pdf_export::export_pdf_pages(
- &pages,
- &temp_path,
- None,
- )
- .and_then(|_| {
- crate::io::print_to_printer::print_existing_pdf(&temp_path, &options)
- })
- .map(|printer| crate::tf!("Sent {} layouts to printer: {printer}", pages.len()).into_owned())
- .map_err(|error| crate::tf!("Print failed: {error}").into_owned())
+ crate::io::pdf_export::export_pdf_pages(&pages, &temp_path, None)
+ .and_then(|_| {
+ crate::io::print_to_printer::print_existing_pdf(&temp_path, &options)
+ })
+ .map(|printer| {
+ crate::tf!("Sent {} layouts to printer: {printer}", pages.len())
+ .into_owned()
+ })
+ .map_err(|error| crate::tf!("Print failed: {error}").into_owned())
};
self.run_print_all_work(true, work)
}
@@ -3382,12 +3265,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
}
- fn run_plot_work(
- &mut self,
- background: bool,
- reopen_plot: bool,
- work: F,
- ) -> Task
+ fn run_plot_work(&mut self, background: bool, reopen_plot: bool, work: F) -> Task
where
F: FnOnce() -> Result + Send + 'static,
{
@@ -3402,42 +3280,31 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
}
- /// Build the render inputs and page geometry for a full-layout plot: wires
- /// plus hatch / wipeout fills, the effective (rotation-swapped) sheet size,
- /// draw-origin offset, rotation, unit scale, and optional clip. Shared by
- /// PDF export, preview, and printer output so all three render identically.
- pub(super) fn layout_plot_params(&self) -> LayoutPlotParams {
- self.layout_plot_params_for(&self.plot_dialog.area)
+ /// Assemble a layout page for PDF export, preview, or printing.
+ pub(super) fn layout_plot_page(&self) -> PdfPageInput {
+ self.layout_plot_page_for(&self.plot_dialog.area)
}
- fn layout_plot_params_for(&self, plot_area: &str) -> LayoutPlotParams {
+ fn layout_plot_page_for(&self, plot_area: &str) -> PdfPageInput {
let i = self.active_tab;
let scene = &self.tabs[i].scene;
let paper_space = scene.current_layout != "Model";
let selected_sheet = plot_dialog_sheet_mm(&self.plot_dialog);
- let (source_wires, hatches, wipeouts, mut group_splits) =
- plot_scene_content(
- scene,
- self.plot_dialog.paperspace_last,
- plot_render_mode_override(&self.plot_dialog),
- );
+ let mut content = plot_scene_content(
+ scene,
+ self.plot_dialog.paperspace_last,
+ plot_render_mode_override(&self.plot_dialog),
+ );
// The printable-area rectangle is an on-screen guide, not drawing
// content. It used to leak into every paper-space PDF/preview/print.
- let wires = if paper_space {
- group_splits.wires = source_wires[..group_splits.wires.min(source_wires.len())]
+ if paper_space {
+ content.group_splits.wires = content.wires[..content.group_splits.wires.min(content.wires.len())]
.iter()
.filter(|wire| wire.name != "paper_printable_area")
.count();
- std::sync::Arc::new(
- source_wires
- .iter()
- .filter(|wire| wire.name != "paper_printable_area")
- .cloned()
- .collect(),
- )
- } else {
- source_wires
- };
+ std::sync::Arc::make_mut(&mut content.wires)
+ .retain(|wire| wire.name != "paper_printable_area");
+ }
if let Some(((x0, y0), (x1, y1))) = scene.paper_limits() {
// Paper geometry is stored in layout units; PDF pages use mm.
// Scale both geometry and offsets by the same unit conversion.
@@ -3457,21 +3324,12 @@ pub(super) fn on_open_file(&mut self) -> Task {
// Only the explicit upside-down choice rotates layout content here.
let rotation = dialog_rotation;
let centered = self.plot_dialog.center;
- let origin_x = self
- .plot_dialog
- .offset_x
- .parse::()
- .unwrap_or(0.0);
- let origin_y = self
- .plot_dialog
- .offset_y
- .parse::()
- .unwrap_or(0.0);
+ let origin_x = self.plot_dialog.offset_x.parse::().unwrap_or(0.0);
+ let origin_y = self.plot_dialog.offset_y.parse::().unwrap_or(0.0);
let (scale, offset_x, offset_y) = if plot_extents {
let (min_x, min_y, max_x, max_y) =
- plot_content_extents(&wires, &hatches, &wipeouts)
- .unwrap_or((x0, y0, x1, y1));
+ plot_content_extents(&content).unwrap_or((x0, y0, x1, y1));
let content_w = (max_x - min_x).max(1e-9);
let content_h = (max_y - min_y).max(1e-9);
let scale = if self.plot_dialog.fit_to_paper {
@@ -3492,11 +3350,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
} else {
origin_y
};
- (
- scale,
- target_x / scale - min_x,
- target_y / scale - min_y,
- )
+ (scale, target_x / scale - min_x, target_y / scale - min_y)
} else if plot_layout {
// Map the complete paper-space sheet to the physical paper
// selected in the dialog. Layout bounds can be stored in mm,
@@ -3511,11 +3365,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
.max(1e-9);
let target_x = (selected_sheet.0 - bounds_w * scale) * 0.5;
let target_y = (selected_sheet.1 - bounds_h * scale) * 0.5;
- (
- scale,
- target_x / scale - x0,
- target_y / scale - y0,
- )
+ (scale, target_x / scale - x0, target_y / scale - y0)
} else {
// Legacy direct callers still get dialog positioning. Normal
// Display/Window paths use `area_plot_job` instead.
@@ -3545,30 +3395,31 @@ pub(super) fn on_open_file(&mut self) -> Task {
// ink is restricted to the device's printable rectangle. Extents
// has its own fitted area and must not inherit this paper clip.
let clip = if plot_layout {
- scene.printable_area_limits().map(|((px0, py0), (px1, py1))| {
- (
- (px0 + offset_x) as f32,
- (py0 + offset_y) as f32,
- (px1 - px0) as f32,
- (py1 - py0) as f32,
- )
- })
+ scene
+ .printable_area_limits()
+ .map(|((px0, py0), (px1, py1))| {
+ (
+ (px0 + offset_x) as f32,
+ (py0 + offset_y) as f32,
+ (px1 - px0) as f32,
+ (py1 - py0) as f32,
+ )
+ })
} else {
None
};
- return (
- wires,
- hatches,
- wipeouts,
- group_splits,
- page_w,
- page_h,
+ return PdfPageInput {
+ content,
+ paper_w: page_w,
+ paper_h: page_h,
offset_x,
offset_y,
- rotation,
- scale as f32,
+ rotation_deg: rotation,
+ scale: scale as f32,
clip,
- );
+ options: Self::pdf_plot_options(&self.plot_dialog),
+ plot_style: self.dialog_plot_style(&self.plot_dialog),
+ };
}
// Model space keeps its established extents + 5% margin behaviour.
@@ -3588,65 +3439,52 @@ pub(super) fn on_open_file(&mut self) -> Task {
} else {
(297.0, 210.0, 0.0, 0.0)
};
- (
- wires,
- hatches,
- wipeouts,
- group_splits,
- page_w,
- page_h,
+ PdfPageInput {
+ content,
+ paper_w: page_w,
+ paper_h: page_h,
offset_x,
offset_y,
- 0,
- 1.0,
- None,
- )
+ rotation_deg: 0,
+ scale: 1.0,
+ clip: None,
+ options: Self::pdf_plot_options(&self.plot_dialog),
+ plot_style: self.dialog_plot_style(&self.plot_dialog),
+ }
}
/// Build direct PDF/printer output using the physical layout sheet in
/// paper space and the selected ISO sheet/scale around Model extents.
- fn direct_plot_params(&self) -> Option {
+ fn direct_plot_page(&self) -> Option {
if self.tabs[self.active_tab].scene.current_layout != "Model" {
- return Some(self.layout_plot_params_for("Layout"));
+ return Some(self.layout_plot_page_for("Layout"));
}
- let (wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip) =
- self.extents_plot_job()?;
- if wires.is_empty() && hatches.is_empty() && wipeouts.is_empty() {
+ let page = self.extents_plot_job()?;
+ let content = &page.content;
+ if content.wires.is_empty() && content.hatches.is_empty()
+ && content.wipeouts.is_empty() && content.images.is_empty()
+ {
return None;
}
- Some((
- std::sync::Arc::new(wires),
- hatches,
- wipeouts,
- group_splits,
- page_w,
- page_h,
- ox,
- oy,
- rotation,
- scale,
- clip,
- ))
+ Some(page)
}
pub(super) fn on_print_to_printer(&mut self) -> Task {
- let Some((wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip)) =
- self.direct_plot_params()
+ let Some(page) = self.direct_plot_page()
else {
- self.command_line
- .push_error(crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref());
+ self.command_line.push_error(
+ crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref(),
+ );
return Task::none();
};
- let plot_style = self.dialog_plot_style(&self.plot_dialog);
- let options = self.plot_print_options(&self.plot_dialog, group_splits);
- self.command_line.push_info(crate::t!("Sending to system printer…").as_ref());
+ let options = self.plot_print_options(&self.plot_dialog);
+ self.command_line
+ .push_info(crate::t!("Sending to system printer…").as_ref());
background_task(
move || {
iced::futures::executor::block_on(
- crate::io::print_to_printer::print_wires_with(
- wires, hatches, wipeouts, page_w, page_h, ox, oy, rotation, scale, clip,
- plot_style, options,
- ))
+ crate::io::print_to_printer::print_wires_with(page, options),
+ )
},
Message::PrintResult,
)
@@ -3883,7 +3721,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
match crate::io::print_to_printer::open_printer_properties(
self.plot_dialog.printer.as_deref(),
) {
- Ok(()) => self.command_line.push_info(crate::t!("Opened printer properties.").as_ref()),
+ Ok(()) => self
+ .command_line
+ .push_info(crate::t!("Opened printer properties.").as_ref()),
Err(error) => self.command_line.push_error(&error),
}
Task::none()
@@ -3919,11 +3759,8 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.plot_dialog.offset_x = "0.0".into();
self.plot_dialog.offset_y = "0.0".into();
self.plot_dialog.fit_to_paper = false;
- self.plot_dialog.scale = scale_name_for_factor(
- &self.plot_dialog.scales,
- 1.0,
- )
- .unwrap_or_else(|| "1:1".into());
+ self.plot_dialog.scale = scale_name_for_factor(&self.plot_dialog.scales, 1.0)
+ .unwrap_or_else(|| "1:1".into());
}
self.plot_dialog.area = s;
Task::none()
@@ -3966,9 +3803,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
}
PlotFlag::Center if d.area != "Layout" => d.center = !d.center,
- PlotFlag::ScaleLw if !d.fit_to_paper => {
- d.scale_lw = !d.scale_lw
- }
+ PlotFlag::ScaleLw if !d.fit_to_paper => d.scale_lw = !d.scale_lw,
PlotFlag::PlotStyles if !d.style_name.is_empty() => {
d.apply_plot_styles = !d.apply_plot_styles
}
@@ -4044,9 +3879,10 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
Task::none()
}
- M::SetCurrent => {
+ M::SetCurrent => {
self.apply_dialog_to_layout();
- self.command_line.push_info(crate::t!("Page setup applied to the layout.").as_ref());
+ self.command_line
+ .push_info(crate::t!("Page setup applied to the layout.").as_ref());
Task::none()
}
M::NewSetup => {
@@ -4129,7 +3965,9 @@ pub(super) fn on_open_file(&mut self) -> Task {
if !name.is_empty() {
if self.plot_dialog.name_rename {
let old = self.plot_dialog.selected_setup.clone();
- self.tabs[self.active_tab].scene.page_setup_rename(&old, &name);
+ self.tabs[self.active_tab]
+ .scene
+ .page_setup_rename(&old, &name);
} else {
let ps = self.dialog_to_plotsettings();
self.tabs[self.active_tab].scene.page_setup_save(&name, ps);
@@ -4150,10 +3988,13 @@ pub(super) fn on_open_file(&mut self) -> Task {
M::Preview => self.on_plot_dlg_commit(true),
M::Commit if self.print_all_options => {
if self.plot_dialog.style_missing && self.plot_dialog.apply_plot_styles {
- self.command_line.push_error(crate::tf!(
- "Plot style table '{}' is not loaded.",
- self.plot_dialog.style_name
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!(
+ "Plot style table '{}' is not loaded.",
+ self.plot_dialog.style_name
+ )
+ .as_ref(),
+ );
return Task::none();
}
self.plot_dialog.paper_space = true;
@@ -4202,7 +4043,11 @@ pub(super) fn on_open_file(&mut self) -> Task {
d.orientation = "Landscape".into();
d.paper_width_mm = 297.0;
d.paper_height_mm = 210.0;
- d.area = if is_model { "Window".into() } else { "Layout".into() };
+ d.area = if is_model {
+ "Window".into()
+ } else {
+ "Layout".into()
+ };
d.center = true;
d.offset_x = "0.0".into();
d.offset_y = "0.0".into();
@@ -4217,8 +4062,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.plot_dialog.copy_settings_from(&prev);
}
} else if is_layout_entry(name) {
- if let Some(ps) = self
- .tabs[self.active_tab]
+ if let Some(ps) = self.tabs[self.active_tab]
.scene
.plot_settings_for(layout_entry_name(name))
{
@@ -4270,11 +4114,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
area if area.starts_with("View: ") => PlotType::View,
_ => PlotType::Extents,
};
- ps.plot_view_name = d
- .area
- .strip_prefix("View: ")
- .unwrap_or("")
- .to_string();
+ ps.plot_view_name = d.area.strip_prefix("View: ").unwrap_or("").to_string();
if d.area == "Window" {
if let Some((x0, y0, x1, y1)) = self.plot_window {
ps.set_plot_window(x0, y0, x1, y1);
@@ -4340,9 +4180,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
/// Load a `PlotSettings` into the dialog editor fields.
fn load_plotsettings_into_dialog(&mut self, ps: &acadrust::objects::PlotSettings) {
- use acadrust::objects::{
- PlotType, ShadePlotMode, ShadePlotResolutionLevel,
- };
+ use acadrust::objects::{PlotType, ShadePlotMode, ShadePlotResolutionLevel};
self.plot_setup_template = Some(ps.clone());
if matches!(ps.plot_type, PlotType::Window) && !ps.plot_window.is_empty() {
self.plot_window = Some((
@@ -4354,17 +4192,20 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
if !ps.current_style_sheet.is_empty()
&& self
- .active_plot_style
- .as_ref()
- .is_none_or(|table| !table.name.eq_ignore_ascii_case(&ps.current_style_sheet))
+ .active_plot_style
+ .as_ref()
+ .is_none_or(|table| !table.name.eq_ignore_ascii_case(&ps.current_style_sheet))
{
- if let Ok(table) = crate::io::plot_style::PlotStyleTable::load_named(
- &ps.current_style_sheet,
- ) {
+ if let Ok(table) =
+ crate::io::plot_style::PlotStyleTable::load_named(&ps.current_style_sheet)
+ {
self.active_plot_style = Some(table);
}
}
- let active_style_name = self.active_plot_style.as_ref().map(|table| table.name.clone());
+ let active_style_name = self
+ .active_plot_style
+ .as_ref()
+ .map(|table| table.name.clone());
let style_name = if ps.current_style_sheet.is_empty() {
String::new()
} else if active_style_name
@@ -4383,8 +4224,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
if !matches!(
paper.as_str(),
"A4" | "A3" | "A2" | "A1" | "A0" | "Letter" | "Legal" | "Tabloid"
- )
- && !ps.paper_size.is_empty()
+ ) && !ps.paper_size.is_empty()
{
paper = ps.paper_size.clone();
}
@@ -4508,25 +4348,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
let rotation: i16 = if d.upside_down { 180 } else { 0 };
let off_x = d.offset_x.parse::().unwrap_or(0.0);
let off_y = d.offset_y.parse::().unwrap_or(0.0);
- self.apply_plot_page_settings(
- sheet_w,
- sheet_h,
- &d.area,
- d.center,
- off_x,
- off_y,
- rotation,
- );
+ self.apply_plot_page_settings(sheet_w, sheet_h, &d.area, d.center, off_x, off_y, rotation);
}
/// Open a preview PDF, export a PDF, or send the job to the chosen printer.
fn on_plot_dlg_commit(&mut self, preview: bool) -> Task {
let d = self.plot_dialog.clone();
if d.style_missing && d.apply_plot_styles {
- self.command_line.push_error(crate::tf!(
- "Plot style table '{}' is not loaded.",
- d.style_name
- ).as_ref());
+ self.command_line.push_error(
+ crate::tf!("Plot style table '{}' is not loaded.", d.style_name).as_ref(),
+ );
return Task::none();
}
// Remember the user's print preferences across sessions.
@@ -4537,7 +4368,6 @@ pub(super) fn on_open_file(&mut self) -> Task {
self.active_modal = None;
self.reset_modal_geometry();
- let plot_style = self.dialog_plot_style(&d);
// Extents, Window and Display use one plot path in both spaces. Only
// Paper-space Layout is special: it uses the physical sheet bounds.
if d.area != "Layout" {
@@ -4551,19 +4381,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
}
_ => None,
};
- let Some((
- w_wires,
- w_hatches,
- w_wipeouts,
- wgroup_splits,
- sw,
- sh,
- wox,
- woy,
- wrotation,
- wscale,
- wclip,
- )) = job
+ let Some(page) = job
else {
self.command_line
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
@@ -4574,14 +4392,11 @@ pub(super) fn on_open_file(&mut self) -> Task {
// whatever the output target is.
if preview {
let tmp = crate::io::print_to_printer::temp_pdf_path("preview");
- let render_options = Self::pdf_plot_options(&d, wgroup_splits);
let work = move || {
- crate::io::pdf_export::export_pdf(
- &w_wires, &w_hatches, &w_wipeouts, sw, sh, wox, woy, wrotation, wscale, wclip, &tmp,
- plot_style.as_ref(),
- render_options,
- ).and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
- .map(|_| crate::t!("Opened plot preview.").into_owned()).map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
+ crate::io::pdf_export::export_pdf(&page, &tmp)
+ .and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
+ .map(|_| crate::t!("Opened plot preview.").into_owned())
+ .map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
};
return self.run_plot_work(d.background, true, work);
}
@@ -4590,43 +4405,27 @@ pub(super) fn on_open_file(&mut self) -> Task {
return Task::done(Message::PlotWindowExport);
}
let tmp = crate::io::print_to_printer::temp_pdf_path("print");
- let render_options = Self::pdf_plot_options(&d, wgroup_splits);
- let opts = self.plot_print_options(&d, wgroup_splits);
+ let opts = self.plot_print_options(&d);
let work = move || {
- crate::io::pdf_export::export_pdf(
- &w_wires, &w_hatches, &w_wipeouts, sw, sh, wox, woy, wrotation, wscale, wclip, &tmp,
- plot_style.as_ref(),
- render_options,
- ).and_then(|_| crate::io::print_to_printer::print_existing_pdf(&tmp, &opts))
+ crate::io::pdf_export::export_pdf(&page, &tmp)
+ .and_then(|_| {
+ crate::io::print_to_printer::print_existing_pdf(&tmp, &opts)
+ })
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
.map_err(|e| crate::tf!("Print failed: {e}").into_owned())
};
return self.run_plot_work(true, false, work);
}
- let (wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip) =
- self.layout_plot_params();
+ let page = self.layout_plot_page();
if preview {
let tmp = crate::io::print_to_printer::temp_pdf_path("preview");
- let render_options = Self::pdf_plot_options(&d, group_splits);
let work = move || {
- crate::io::pdf_export::export_pdf(
- &wires,
- &hatches,
- &wipeouts,
- page_w,
- page_h,
- ox,
- oy,
- rotation,
- scale,
- clip,
- &tmp,
- plot_style.as_ref(),
- render_options,
- ).and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
- .map(|_| crate::t!("Opened plot preview.").into_owned()).map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
+ crate::io::pdf_export::export_pdf(&page, &tmp)
+ .and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
+ .map(|_| crate::t!("Opened plot preview.").into_owned())
+ .map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
};
return self.run_plot_work(d.background, true, work);
}
@@ -4636,14 +4435,13 @@ pub(super) fn on_open_file(&mut self) -> Task {
return Task::done(Message::PlotExport);
}
- let opts = self.plot_print_options(&d, group_splits);
- self.command_line.push_info(crate::t!("Sending to system printer…").as_ref());
+ let opts = self.plot_print_options(&d);
+ self.command_line
+ .push_info(crate::t!("Sending to system printer…").as_ref());
let work = move || {
- iced::futures::executor::block_on(
- crate::io::print_to_printer::print_wires_with(
- wires, hatches, wipeouts, page_w, page_h, ox, oy, rotation, scale, clip,
- plot_style, opts,
- ))
+ iced::futures::executor::block_on(crate::io::print_to_printer::print_wires_with(
+ page, opts,
+ ))
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
.map_err(|error| crate::tf!("Print failed: {error}").into_owned())
};
@@ -4655,19 +4453,16 @@ pub(super) fn on_open_file(&mut self) -> Task {
fn plot_print_options(
&self,
d: &crate::ui::window::plot::PlotDialogState,
- group_splits: crate::io::pdf_export::PlotGroupSplits,
) -> crate::io::print_to_printer::PrintOptions {
crate::io::print_to_printer::PrintOptions {
printer: d.printer.clone(),
copies: d.copies.trim().parse::().unwrap_or(1).max(1),
quality: Some(d.quality.clone()),
- render: Self::pdf_plot_options(d, group_splits),
}
}
fn pdf_plot_options(
d: &crate::ui::window::plot::PlotDialogState,
- group_splits: crate::io::pdf_export::PlotGroupSplits,
) -> crate::io::pdf_export::PdfPlotOptions {
crate::io::pdf_export::PdfPlotOptions {
object_lineweights: d.lineweights,
@@ -4675,7 +4470,6 @@ pub(super) fn on_open_file(&mut self) -> Task {
transparency: d.transparency,
stamp: d.stamp,
merge_lines: d.merge_lines,
- group_splits,
}
}
@@ -4692,22 +4486,20 @@ pub(super) fn on_open_file(&mut self) -> Task {
.cloned()
}
- fn window_plot_job(&self) -> Option {
+ fn window_plot_job(&self) -> Option {
self.area_plot_job(self.plot_window?)
}
- fn display_plot_job(&self) -> Option {
+ fn display_plot_job(&self) -> Option {
self.area_plot_job(self.display_plot_window()?)
}
- fn limits_plot_job(&self) -> Option {
- let (min, max) = self.tabs[self.active_tab]
- .scene
- .current_drawing_limits()?;
+ fn limits_plot_job(&self) -> Option {
+ let (min, max) = self.tabs[self.active_tab].scene.current_drawing_limits()?;
self.area_plot_job((min.x, min.y, max.x, max.y))
}
- fn named_view_plot_job(&self, name: &str) -> Option {
+ fn named_view_plot_job(&self, name: &str) -> Option {
let view = self.tabs[self.active_tab]
.scene
.document
@@ -4715,7 +4507,8 @@ pub(super) fn on_open_file(&mut self) -> Task {
.iter()
.find(|view| {
view.name.eq_ignore_ascii_case(name)
- && view.paper_space == (self.tabs[self.active_tab].scene.current_layout != "Model")
+ && view.paper_space
+ == (self.tabs[self.active_tab].scene.current_layout != "Model")
})?;
let half_w = view.width.abs() * 0.5;
let half_h = view.height.abs() * 0.5;
@@ -4728,32 +4521,18 @@ pub(super) fn on_open_file(&mut self) -> Task {
))
}
- fn extents_plot_job(&self) -> Option {
+ fn extents_plot_job(&self) -> Option {
let scene = &self.tabs[self.active_tab].scene;
if scene.current_layout == "Model" {
let (min, max) = scene.model_space_extents()?;
- return self.area_plot_job((
- min.x as f64,
- min.y as f64,
- max.x as f64,
- max.y as f64,
- ));
+ return self.area_plot_job((min.x as f64, min.y as f64, max.x as f64, max.y as f64));
}
- let (wires, hatches, wipeouts, _) =
- plot_scene_content(
- scene,
- self.plot_dialog.paperspace_last,
- plot_render_mode_override(&self.plot_dialog),
- );
- let extents = plot_content_extents(
- &wires
- .iter()
- .filter(|wire| wire.name != "paper_printable_area")
- .cloned()
- .collect::>(),
- &hatches,
- &wipeouts,
- )?;
+ let content = plot_scene_content(
+ scene,
+ self.plot_dialog.paperspace_last,
+ plot_render_mode_override(&self.plot_dialog),
+ );
+ let extents = plot_content_extents(&content)?;
self.area_plot_job(extents)
}
@@ -4793,12 +4572,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
iced::Point::new(bounds.width, bounds.height),
iced::Point::new(0.0, bounds.height),
] {
- let world = camera.unproject_on_plane(
- point,
- bounds,
- glam::Vec3::Z,
- glam::DVec3::ZERO,
- );
+ let world = camera.unproject_on_plane(point, bounds, glam::Vec3::Z, glam::DVec3::ZERO);
x0 = x0.min(world.x);
y0 = y0.min(world.y);
x1 = x1.max(world.x);
@@ -4815,7 +4589,7 @@ pub(super) fn on_open_file(&mut self) -> Task {
/// Render a selected rectangle through one shared Model/Paper path. The
/// window may lie partly or wholly outside a paper sheet.
- fn area_plot_job(&self, window: (f64, f64, f64, f64)) -> Option {
+ fn area_plot_job(&self, window: (f64, f64, f64, f64)) -> Option {
use crate::io::paper_sizes::{window_to_sheet, PlotScale};
let i = self.active_tab;
let (x0, y0, x1, y1) = window;
@@ -4854,24 +4628,22 @@ pub(super) fn on_open_file(&mut self) -> Task {
};
let scene = &self.tabs[i].scene;
let (wx0, wy0, wx1, wy1) = (x0 as f32, y0 as f32, x1 as f32, y1 as f32);
- let (all_wires, hatches, wipeouts, mut group_splits) =
- plot_scene_content(
- scene,
- self.plot_dialog.paperspace_last,
- plot_render_mode_override(&self.plot_dialog),
- );
- let first_wire_count = all_wires[..group_splits.wires.min(all_wires.len())]
+ let mut content = plot_scene_content(
+ scene,
+ self.plot_dialog.paperspace_last,
+ plot_render_mode_override(&self.plot_dialog),
+ );
+ let in_window = |wire: &crate::io::pdf_export::PlotWire| {
+ wire.name != "paper_printable_area"
+ && wire.aabb[0] <= wx1 && wire.aabb[2] >= wx0
+ && wire.aabb[1] <= wy1 && wire.aabb[3] >= wy0
+ };
+ content.group_splits.wires = content.wires
+ [..content.group_splits.wires.min(content.wires.len())]
.iter()
- .filter(|w| w.name != "paper_printable_area")
- .filter(|w| w.aabb[0] <= wx1 && w.aabb[2] >= wx0 && w.aabb[1] <= wy1 && w.aabb[3] >= wy0)
+ .filter(|wire| in_window(wire))
.count();
- let wires: Vec<_> = all_wires
- .iter()
- .filter(|w| w.name != "paper_printable_area")
- .filter(|w| w.aabb[0] <= wx1 && w.aabb[2] >= wx0 && w.aabb[1] <= wy1 && w.aabb[3] >= wy0)
- .cloned()
- .collect();
- group_splits.wires = first_wire_count;
+ std::sync::Arc::make_mut(&mut content.wires).retain(in_window);
let offset_x = (target_x / scale) - x0;
let offset_y = (target_y / scale) - y0;
let clip = Some((
@@ -4885,95 +4657,96 @@ pub(super) fn on_open_file(&mut self) -> Task {
90 | 270 => (sheet_h, sheet_w),
_ => (sheet_w, sheet_h),
};
- Some((
- wires,
- hatches,
- wipeouts,
- group_splits,
- page_w,
- page_h,
+ Some(PdfPageInput {
+ content,
+ paper_w: page_w,
+ paper_h: page_h,
offset_x,
offset_y,
- rotation,
- scale as f32,
+ rotation_deg: rotation,
+ scale: scale as f32,
clip,
- ))
+ options: Self::pdf_plot_options(&self.plot_dialog),
+ plot_style: self.dialog_plot_style(&self.plot_dialog),
+ })
}
pub(super) fn on_plot_style_panel_apply(&mut self) -> Task {
- let aci = self.plotstyle_panel_aci as usize;
- if let Some(table) = self.active_plot_style.as_mut() {
- if let Some(entry) = table.aci_entries.get_mut(aci) {
- // Parse color.
- let color_str = self.ps_color_buf.trim();
- if color_str.is_empty() {
- entry.color = None;
- } else if color_str.starts_with('#') && color_str.len() == 7 {
- let r = u8::from_str_radix(&color_str[1..3], 16).unwrap_or(0);
- let g = u8::from_str_radix(&color_str[3..5], 16).unwrap_or(0);
- let b = u8::from_str_radix(&color_str[5..7], 16).unwrap_or(0);
- entry.color = Some([r, g, b]);
- }
- if let Ok(lw) = self.ps_lineweight_buf.trim().parse::() {
- entry.lineweight = lw;
- }
- if let Ok(sc) = self.ps_screening_buf.trim().parse::() {
- entry.screening = sc.min(100);
- }
-
- }
- } else {
- // No table loaded: create an identity table and apply.
- let mut table = crate::io::plot_style::PlotStyleTable::identity("Custom.ctb");
- if let Some(entry) = table.aci_entries.get_mut(aci) {
- let color_str = self.ps_color_buf.trim();
- if color_str.starts_with('#') && color_str.len() == 7 {
- let r = u8::from_str_radix(&color_str[1..3], 16).unwrap_or(0);
- let g = u8::from_str_radix(&color_str[3..5], 16).unwrap_or(0);
- let b = u8::from_str_radix(&color_str[5..7], 16).unwrap_or(0);
- entry.color = Some([r, g, b]);
- }
- if let Ok(lw) = self.ps_lineweight_buf.trim().parse::() {
- entry.lineweight = lw;
- }
- if let Ok(sc) = self.ps_screening_buf.trim().parse::() {
- entry.screening = sc.min(100);
- }
- }
- self.active_plot_style = Some(table);
- self.command_line
- .push_output(crate::tf!("Created new CTB table, ACI {aci} updated.").as_ref());
+ let aci = self.plotstyle_panel_aci as usize;
+ if let Some(table) = self.active_plot_style.as_mut() {
+ if let Some(entry) = table.aci_entries.get_mut(aci) {
+ // Parse color.
+ let color_str = self.ps_color_buf.trim();
+ if color_str.is_empty() {
+ entry.color = None;
+ } else if color_str.starts_with('#') && color_str.len() == 7 {
+ let r = u8::from_str_radix(&color_str[1..3], 16).unwrap_or(0);
+ let g = u8::from_str_radix(&color_str[3..5], 16).unwrap_or(0);
+ let b = u8::from_str_radix(&color_str[5..7], 16).unwrap_or(0);
+ entry.color = Some([r, g, b]);
}
- Task::none()
+ if let Ok(lw) = self.ps_lineweight_buf.trim().parse::() {
+ entry.lineweight = lw;
+ }
+ if let Ok(sc) = self.ps_screening_buf.trim().parse::