mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-19 20:30:42 -06:00
Compare commits
77
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
60233f87ff | ||
|
|
4831f26ca6 | ||
|
|
a770fa5a5e | ||
|
|
b23d172885 | ||
|
|
11d66cc3cd | ||
|
|
83a2b4c373 | ||
|
|
2ed5614e46 | ||
|
|
ad5ac32662 | ||
|
|
92b718f912 | ||
|
|
766af02ec4 | ||
|
|
d9d6c78a28 | ||
|
|
0ebb256d33 | ||
|
|
730907b9b8 | ||
|
|
f1b76fab54 | ||
|
|
65ed2fb7f0 | ||
|
|
16341b665f | ||
|
|
259d892a33 | ||
|
|
2ccf5874b0 | ||
|
|
ed0fbce27c | ||
|
|
e1b86d5743 | ||
|
|
cb36b573c3 | ||
|
|
32dfdef71c | ||
|
|
29e17181bf | ||
|
|
b21747b30b | ||
|
|
b3d11070e4 | ||
|
|
155fd45d61 | ||
|
|
0bc69feed0 | ||
|
|
13f4d09b6d | ||
|
|
7b525189c0 | ||
|
|
13de76e5b2 | ||
|
|
afe77dc0d4 | ||
|
|
a009f7d022 | ||
|
|
682034d737 | ||
|
|
5b170664aa | ||
|
|
ca6c100342 | ||
|
|
072ec4500a | ||
|
|
58a13b5a64 | ||
|
|
a5a5550165 | ||
|
|
281f86d602 | ||
|
|
caaa0e37f7 | ||
|
|
c07b6a2ff7 | ||
|
|
e347afbc63 | ||
|
|
39011d2552 | ||
|
|
d8d5041d75 | ||
|
|
c13976c657 | ||
|
|
3c135760b5 | ||
|
|
e1d3520c9e | ||
|
|
7ffabe0fc0 | ||
|
|
4f57426bad | ||
|
|
feedca47dc | ||
|
|
2fa8997548 | ||
|
|
38933e7f91 | ||
|
|
9397db72e6 | ||
|
|
f0c1b4ff29 | ||
|
|
e65132c77a | ||
|
|
4415f4e5dc | ||
|
|
28428b0cc3 | ||
|
|
7983a25e38 | ||
|
|
0b9f1ed74a | ||
|
|
7f590216eb | ||
|
|
df1e333229 | ||
|
|
23d5918a62 | ||
|
|
43896056e2 | ||
|
|
853ca574bd | ||
|
|
744e99cafd | ||
|
|
98a05c66f9 | ||
|
|
3e0de6246f | ||
|
|
9f71170368 | ||
|
|
4abc2dee5b | ||
|
|
4ca8136379 | ||
|
|
372be8db01 | ||
|
|
3c0c5b1f61 | ||
|
|
f67e5ccd38 | ||
|
|
800b0319ac | ||
|
|
9e022cf31c | ||
|
|
3e42b346ff | ||
|
|
afcb6aa743 |
@@ -114,3 +114,7 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr
|
||||
- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
|
||||
- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
|
||||
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
|
||||
|
||||
## Shared libraries
|
||||
|
||||
Before adding or changing file-format, codec, protocol, or reusable UI code, check `storytold/craft-libs` and its open PRs first; reuse or extend the shared library rather than duplicating it locally, keep app-specific policy and model mapping in the app, and preserve behavior, security/resource limits, attribution, and regression coverage during cutovers.
|
||||
|
||||
Generated
+169
-8
@@ -299,6 +299,9 @@ name = "arrayvec"
|
||||
version = "0.7.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
|
||||
dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "as-raw-xcb-connection"
|
||||
@@ -668,6 +671,7 @@ dependencies = [
|
||||
"serde_json",
|
||||
"sys-locale",
|
||||
"thiserror 2.0.21",
|
||||
"uds_windows",
|
||||
"windows",
|
||||
"winit",
|
||||
"winresource",
|
||||
@@ -746,6 +750,7 @@ version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-geom",
|
||||
"craft-dxf",
|
||||
"craft-font-catalog",
|
||||
"craft-shx",
|
||||
"encoding_rs",
|
||||
"harfrust 0.14.0",
|
||||
@@ -773,11 +778,11 @@ dependencies = [
|
||||
"cadcraft-render",
|
||||
"craft-dwg",
|
||||
"craft-dxf",
|
||||
"craft-image-codecs",
|
||||
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"craft-pdf",
|
||||
"craft-svg",
|
||||
"image",
|
||||
"miniz_oxide 0.9.1",
|
||||
"quick-xml 0.42.0",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
@@ -810,7 +815,7 @@ dependencies = [
|
||||
"cadcraft-doc",
|
||||
"cadcraft-fonts",
|
||||
"cadcraft-geom",
|
||||
"craft-image-codecs",
|
||||
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"lyon_tessellation",
|
||||
"rayon",
|
||||
"serde_json",
|
||||
@@ -829,6 +834,7 @@ dependencies = [
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"chrono",
|
||||
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"craft-ui",
|
||||
"craft-update",
|
||||
"craft-window",
|
||||
@@ -1205,6 +1211,16 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-font-catalog"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c07e38090879ffa994f893df9956c6d5b96c049c#c07e38090879ffa994f893df9956c6d5b96c049c"
|
||||
dependencies = [
|
||||
"skrifa 0.47.0",
|
||||
"thiserror 2.0.21",
|
||||
"windows-registry",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-fonts-build"
|
||||
version = "0.1.0"
|
||||
@@ -1238,8 +1254,33 @@ name = "craft-image-codecs"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
|
||||
dependencies = [
|
||||
"craft-jpeg",
|
||||
"craft-metadata",
|
||||
"craft-jpeg 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"craft-metadata 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"crc32fast",
|
||||
"exr",
|
||||
"flate2",
|
||||
"half",
|
||||
"hayro-jpeg2000",
|
||||
"image",
|
||||
"image-webp",
|
||||
"jpeg-encoder",
|
||||
"png",
|
||||
"rayon",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
"tiff",
|
||||
"zune-core",
|
||||
"zune-jpeg",
|
||||
"zune-jpegxl",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-image-codecs"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
|
||||
dependencies = [
|
||||
"craft-jpeg 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
|
||||
"craft-metadata 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
|
||||
"crc32fast",
|
||||
"exr",
|
||||
"flate2",
|
||||
@@ -1266,6 +1307,14 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-jpeg"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
|
||||
dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-jsonrpc"
|
||||
version = "0.1.0"
|
||||
@@ -1290,7 +1339,19 @@ source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a
|
||||
dependencies = [
|
||||
"brotli-decompressor",
|
||||
"chrono",
|
||||
"craft-tiff",
|
||||
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"quick-xml 0.41.0",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-metadata"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
|
||||
dependencies = [
|
||||
"brotli-decompressor",
|
||||
"chrono",
|
||||
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
|
||||
"quick-xml 0.41.0",
|
||||
"serde",
|
||||
]
|
||||
@@ -1318,7 +1379,23 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-shx"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=3c5007339754def577b3c5274f523d96384a35c4#3c5007339754def577b3c5274f523d96384a35c4"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=2f2d1d84e3a36b3f93e81507aeff3f0da97a7162#2f2d1d84e3a36b3f93e81507aeff3f0da97a7162"
|
||||
|
||||
[[package]]
|
||||
name = "craft-svg"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
|
||||
dependencies = [
|
||||
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
|
||||
"craft-xml",
|
||||
"flate2",
|
||||
"kurbo",
|
||||
"quick-xml 0.41.0",
|
||||
"roxmltree",
|
||||
"thiserror 2.0.21",
|
||||
"vectorcraft-geom",
|
||||
"vectorcraft-pathops",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-tiff"
|
||||
@@ -1329,6 +1406,15 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-tiff"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-ui"
|
||||
version = "0.1.0"
|
||||
@@ -1353,7 +1439,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-update"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"dunce",
|
||||
@@ -1408,6 +1494,16 @@ dependencies = [
|
||||
"wayland-client",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-xml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
|
||||
dependencies = [
|
||||
"quick-xml 0.41.0",
|
||||
"serde",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crc32fast"
|
||||
version = "1.5.3"
|
||||
@@ -2956,6 +3052,7 @@ dependencies = [
|
||||
"arrayvec",
|
||||
"euclid",
|
||||
"polycool",
|
||||
"serde",
|
||||
"smallvec",
|
||||
]
|
||||
|
||||
@@ -3011,6 +3108,19 @@ version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4"
|
||||
|
||||
[[package]]
|
||||
name = "linesweeper"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a25df1b0c5432893f41bba817150e323703ee5f6d974f3a6808ac7fd7f046d18"
|
||||
dependencies = [
|
||||
"arrayvec",
|
||||
"kurbo",
|
||||
"polycool",
|
||||
"rustc-hash 2.1.3",
|
||||
"smallvec",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "linux-raw-sys"
|
||||
version = "0.4.15"
|
||||
@@ -4172,6 +4282,17 @@ dependencies = [
|
||||
"once_cell",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "read-fonts"
|
||||
version = "0.44.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d5a0cf4bb6cbce4c29756270d189a5e400ac05e91192161d83a0bcb6e68492e8"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"font-types 0.12.7",
|
||||
"once_cell",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "read-fonts"
|
||||
version = "0.45.1"
|
||||
@@ -4279,6 +4400,15 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "roxmltree"
|
||||
version = "0.21.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9da7f59328b09405b181fee1018925fad50f157afb43c0c0f5c522c256dd5907"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rstar"
|
||||
version = "0.13.0"
|
||||
@@ -4636,6 +4766,16 @@ dependencies = [
|
||||
"read-fonts 0.41.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "skrifa"
|
||||
version = "0.47.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "526e654b303ff4ad73a5a40b25de2b3ce3d039c5e3b6da5f89ae6e57004cb40f"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"read-fonts 0.44.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "skrifa"
|
||||
version = "0.48.0"
|
||||
@@ -5282,6 +5422,27 @@ dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "vectorcraft-geom"
|
||||
version = "0.18.0"
|
||||
source = "git+https://github.com/storytold/vectorcraft.git?rev=6b3a6b8788ebcb420d69449199cbdf323888d27e#6b3a6b8788ebcb420d69449199cbdf323888d27e"
|
||||
dependencies = [
|
||||
"kurbo",
|
||||
"serde",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "vectorcraft-pathops"
|
||||
version = "0.18.0"
|
||||
source = "git+https://github.com/storytold/vectorcraft.git?rev=6b3a6b8788ebcb420d69449199cbdf323888d27e#6b3a6b8788ebcb420d69449199cbdf323888d27e"
|
||||
dependencies = [
|
||||
"kurbo",
|
||||
"linesweeper",
|
||||
"thiserror 2.0.21",
|
||||
"vectorcraft-geom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "vello_common"
|
||||
version = "0.2.0"
|
||||
|
||||
+6
-2
@@ -16,7 +16,7 @@ cadcraft-geom = { path = "crates/geom" }
|
||||
# DXF tags: the shared reader and writer (moved from crates/dxf; craft-libs#791).
|
||||
craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "9ed120e6b1bd5116a4649c578d1272d60cf932b9" }
|
||||
craft-dwg = { git = "https://github.com/storytold/craft-libs", rev = "7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf" }
|
||||
craft-shx = { git = "https://github.com/storytold/craft-libs", rev = "3c5007339754def577b3c5274f523d96384a35c4" }
|
||||
craft-shx = { git = "https://github.com/storytold/craft-libs", rev = "2f2d1d84e3a36b3f93e81507aeff3f0da97a7162" }
|
||||
craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "ae5020c1ed922cf7976a3a5545f05b07f466be12" }
|
||||
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "0325b2d73676d736e94097dbcef01219cf25c7db" }
|
||||
cadcraft-color = { path = "crates/color" }
|
||||
@@ -30,11 +30,15 @@ cadcraft-ui-egui = { path = "crates/ui-egui" }
|
||||
cadcraft-mcp = { path = "crates/mcp" }
|
||||
craft-mcp = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
|
||||
craft-jsonrpc = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
|
||||
# SVG/SVGZ import and export geometry (craft-libs#778).
|
||||
craft-svg = { git = "https://github.com/storytold/craft-libs", rev = "c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52" }
|
||||
# Which paths stored in a drawing (xrefs, data links) may be opened.
|
||||
craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
|
||||
# PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
|
||||
# craft-pdf's patched backends to the same revision (Cargo ignores dependency-local patches).
|
||||
craft-pdf = { version = "=0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", default-features = false }
|
||||
# TrueType embedding-permission classification for plotted fonts (craft-libs#778).
|
||||
craft-font-catalog = { git = "https://github.com/storytold/craft-libs", rev = "c07e38090879ffa994f893df9956c6d5b96c049c", default-features = false }
|
||||
clap = { version = "4", features = ["derive", "env"] }
|
||||
clap_complete = "4.6.11"
|
||||
clap_mangen = { version = "0.3.3", features = ["env"] }
|
||||
@@ -77,7 +81,7 @@ egui-wgpu = "0.37"
|
||||
# Monotonic time on native and web (performance.now on wasm).
|
||||
web-time = "1.1"
|
||||
# craft-update: app-specific pretend versions apply to startup and manual checks.
|
||||
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] }
|
||||
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", features = ["egui"] }
|
||||
rfd = "0.17"
|
||||
arboard = { version = "3.6", default-features = false }
|
||||
|
||||
|
||||
+50
-21
@@ -1,21 +1,23 @@
|
||||
# CADCraft roadmap
|
||||
|
||||
**Stage: pre-alpha** · next: alpha, ~2 points (38% → 40% ready for real work) and ~125–190 Opus 5.5 hours away (the four failing core workflows of the [alpha gate](docs/roadmap.md#alpha-gate))
|
||||
**Stage: pre-alpha** · next: alpha, when the six rows of the [alpha gate](docs/roadmap.md#alpha-gate) pass (five fail today; the gate was revised on 2026-11-19 and its hours are not re-estimated yet)
|
||||
|
||||
> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-10-24 · **Change:** minor (re-audit against main 41d9b5e95: language table, CI gate, open-PR count; previously: progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027
|
||||
> **Last reviewed:** 2026-11-19 · **Last updated:** 2026-11-19 · **Change:** major (alpha gate revised from user reports: six rows, Windows first; Upcoming re-ranked into three priority tiers; previously minor: re-audit against main 41d9b5e95) · **Target:** Autodesk AutoCAD 2027
|
||||
|
||||
CADCraft targets full parity with AutoCAD (2D drafting first, then annotation, layouts and
|
||||
plotting, DWG, parametrics and 3D), plus what AutoCAD doesn't have: agent control over MCP, a
|
||||
scriptable CLI, a web build, Linux and FreeBSD builds, and a free licence.
|
||||
|
||||
**Why pre-alpha:** four of AutoCAD's five core workflows fail the [alpha gate](docs/roadmap.md#alpha-gate).
|
||||
Precise drafting still has approximate ellipse and spline intersections and a few stubbed prompt options
|
||||
(object snap tracking, TRIM/EXTEND/OFFSET options and typed snap overrides have landed); dynamic blocks can't be
|
||||
authored and xrefs can't be edited in place (the Block Editor, REFEDIT, dynamic block editing and XCLIP have landed);
|
||||
plots go only to PDF, PNG and SVG files (plot styles and the Plot dialog have landed); and a DWG saved by
|
||||
CADCraft drops what acadrust doesn't model and has never been checked in
|
||||
AutoCAD. Dimensioning passes. Ready for real work (≈ 38%) is also under the ~40% alpha bar. Beta
|
||||
is ≈ 600–930 h away.
|
||||
**Why pre-alpha:** five of the six rows of the [alpha gate](docs/roadmap.md#alpha-gate) fail. The gate
|
||||
was revised on 2026-11-19 from what people report: about 525 of the issues open or closed in the
|
||||
last 30 days come from people describing their own drawings, hardware or workflow, and the ones that
|
||||
name a platform name Windows most (135; Linux 57, macOS 36, web 14). They report an app that
|
||||
doesn't start on older graphics hardware, large or foreign DWG files that are refused, freeze or open
|
||||
wrong, clicks lost while the mouse moves, layouts in the wrong units, and a menu bar or panels that
|
||||
can't be brought back. Drafting, dimensioning and annotating a sheet nearly passes. Dynamic-block
|
||||
authoring, editing an xref in place and exact ellipse and spline geometry had almost no reports behind
|
||||
them and moved to the beta checklist. Ready for real work (≈ 38%, not re-scored since 2026-10-10) is
|
||||
also under the ~40% alpha bar. Beta is ≈ 600–930 h away.
|
||||
|
||||
## Headline numbers
|
||||
|
||||
@@ -25,7 +27,7 @@ is ≈ 600–930 h away.
|
||||
| Ready for real work | **≈ 38%** | estimated ([target-app-parity.md](docs/target-app-parity.md)) |
|
||||
| Mainstream practitioner (2D drafter) | **≈ 28%** (lower than the full number: file exchange, stability and interaction discounts multiply) | estimated ([target-app-parity.md](docs/target-app-parity.md#mainstream-practitioner)) |
|
||||
| Essentials user | **≈ 46%** | estimated ([target-app-parity.md](docs/target-app-parity.md#essentials-user)) |
|
||||
| Remaining to alpha | **≈ 125–190 h** (the gate rows) | estimated |
|
||||
| Remaining to alpha | **≈ 125–190 h** (estimated 2026-10-10 for the previous gate; not re-estimated for the revised one) | estimated |
|
||||
| Remaining to beta | **≈ 600–930 h** (≈ 150–250 h elapsed with 4–6 agents) | estimated |
|
||||
| Remaining to full parity | **≈ 1,300–2,100 h** (≈ 330–550 h elapsed) | estimated |
|
||||
|
||||
@@ -105,17 +107,43 @@ Other languages shipped: Ukrainian (1,357 rows, the reference catalog, #36), Cze
|
||||
|
||||
## Upcoming
|
||||
|
||||
Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md).
|
||||
Ranked in three tiers; a higher tier goes first whenever it has work. Within a tier, a fix that is
|
||||
already written and waiting in a pull request lands before new work starts, whoever wrote it. Detail
|
||||
and the beta checklist are in [docs/roadmap.md](docs/roadmap.md).
|
||||
|
||||
1. Gate and land: CI runs `cargo xtask ci` on every PR since #1987 (fmt on main is fixed); land the 450 open PRs (2026-10-24) (15–25 h).
|
||||
2. Stop losing data on save (DXF done, #528; native MULTILEADER, #459, and the save version, #421, done; through DWG, acadrust still drops some content) (30–45 h).
|
||||
3. Real-file DWG/DXF corpus and a black-box check in AutoCAD (10–15 h + owner).
|
||||
4. ~~Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
|
||||
editable dynamic input.~~ Done (#379, #441, #60, #519; `snap/tracking.rs`, `pointmod.rs`, `dyninput.rs`).
|
||||
5. ~~Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER.~~ Done (#397, #408, #547); the stubs left are in gaps F1.
|
||||
6. ~~Autosave, recovery, AUDIT, RECOVER.~~ Done on the desktop (#406, #416); the web build has no autosave (gaps F4).
|
||||
7. Exact ellipse/spline geometry and correct polyline offsets (30–50 h).
|
||||
8. Xrefs, block editor, groups, then dynamic blocks (80–120 h): xrefs (#525), groups (#417), the Block Editor (#824, #833, #885), REFEDIT (#818), XCLIP and XCLIPFRAME (#2354) and dynamic block references (#838–#883) landed; left: dynamic-block authoring, editing an xref in place.
|
||||
**1. Urgent: security fixes, leaks, crashes and lost work.**
|
||||
- The open findings of the security audit (#1919–#1935): check each against the input limits that
|
||||
landed on 2026-11-11, close what is fixed and fix the rest. A crafted handle that makes new entities
|
||||
overwrite existing ones (#1921) is fixed by #1276.
|
||||
- Hostile-input fixes waiting in pull requests (#2820, #2821, #2765).
|
||||
- Crashes and hangs with a reproduction: the web build on a large DXF (#1603), a DWG with 3D content
|
||||
(#2174), startup on older graphics hardware (#1724, #1631, #3222).
|
||||
|
||||
**2. Parity with AutoCAD: the alpha gate rows, then the beta checklist (apart from its items named under tier 3).**
|
||||
- It starts on common hardware (#1596, then an automatic fallback renderer).
|
||||
- It opens the DWG and DXF files people already have: large files (#3102, #2633, #1088), layouts and
|
||||
paper units (#1672, #2836), and a corpus of real files run in CI.
|
||||
- Saving loses nothing and other CAD programs open the result (#2904, #1687, #3234, #2632).
|
||||
- Input feels like AutoCAD for Windows: clicks while the mouse moves (#1001, #2092), right-click and
|
||||
Space as Enter (#1387), double-click to edit text (#842).
|
||||
- The prompt options that still say "not available yet", and TRIM/EXTEND depth.
|
||||
- Layouts print at scale on a system printer, and the menu bar and panels can always be restored
|
||||
(#3216, #1240).
|
||||
- 714 pull requests are open (2026-11-19). About 230 are mergeable, pass CI and are small; they are
|
||||
reviewed and landed in this order, the longest-waiting authors first within a row.
|
||||
|
||||
**3. Lower priority: affects fewer people and nothing breaks without it.**
|
||||
- Dynamic-block authoring, editing an xref in place, exact ellipse and spline geometry, correct
|
||||
polyline offsets.
|
||||
- Prompt options that need 3D (DVIEW's camera options, -RENAME Material); 3D itself comes after 1.0,
|
||||
but a file with 3D content must open safely (tier 1).
|
||||
- Menu breadth against AutoCAD for Mac as a headline number.
|
||||
|
||||
Done since the last ranking: precision input (#379, #441, #60, #519), prompt options in TRIM/EXTEND,
|
||||
OFFSET, ROTATE, PLINE, SPLINE, MTEXT and MLEADER (#397, #408, #547), autosave, recovery, AUDIT and
|
||||
RECOVER on the desktop (#406, #416), xrefs (#525), groups (#417), the Block Editor (#824, #833, #885),
|
||||
REFEDIT (#818), XCLIP (#2354), dynamic block references (#838–#883), and the Dimension Style Manager
|
||||
(#1460).
|
||||
|
||||
## Progress log
|
||||
|
||||
@@ -138,6 +166,7 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-11-19 | major | Alpha gate revised from user reports (six rows, Windows first; block authoring, xref editing in place and exact curve geometry moved to beta); Upcoming re-ranked into three tiers: urgent (security, leaks, crashes, lost work), parity, lower priority; percentages and hours not re-scored |
|
||||
| 2026-10-24 | minor | Re-audit against main 41d9b5e95: language table, CI gate and open-PR count re-checked against main 41d9b5e95 |
|
||||
| 2026-10-21 | trivial | Progress log: proxy objects keep their class through a save (#1812) |
|
||||
| 2026-10-14 | minor | Progress log: HATCHEDIT boundary add/remove |
|
||||
|
||||
@@ -54,6 +54,8 @@ fn install_io() {
|
||||
groups: cadcraft_io::entity_groups,
|
||||
entity: cadcraft_io::entity_from_groups,
|
||||
});
|
||||
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
|
||||
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
|
||||
}
|
||||
|
||||
/// `path` as text, for the engine and io calls that take a file name as a string.
|
||||
|
||||
@@ -128,6 +128,8 @@ mod web {
|
||||
groups: cadcraft_io::entity_groups,
|
||||
entity: cadcraft_io::entity_from_groups,
|
||||
});
|
||||
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
|
||||
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
|
||||
let Some(canvas) = app_canvas() else {
|
||||
log::error!("missing <canvas id=\"{CANVAS_ID}\">");
|
||||
return;
|
||||
|
||||
@@ -67,6 +67,9 @@ hidapi = { version = "2.6.7", default-features = false, features = ["windows-nat
|
||||
# View ▸ Accessibility ▸ Animation Effects ▸ Use System Setting: Windows' Animation effects
|
||||
# setting (system_animations.rs). Already in Cargo.lock through wgpu's DirectX 12 backend.
|
||||
windows = { version = "0.62", features = ["UI_ViewManagement"] }
|
||||
# One CADCraft per sign-in: later launches hand their files over an AF_UNIX socket
|
||||
# (single_instance.rs). Already in Cargo.lock through zbus.
|
||||
uds_windows = "1.2.1"
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
hidapi = { version = "2.6.7", default-features = false, features = ["linux-native-basic-udev"] }
|
||||
|
||||
@@ -24,6 +24,9 @@ pub(crate) struct LaunchArgs {
|
||||
/// Open with the sample drawing
|
||||
#[arg(long)]
|
||||
pub(crate) sample: bool,
|
||||
/// Open the files in a new window, even if CADCraft is already running (Windows)
|
||||
#[arg(long)]
|
||||
pub(crate) new_window: bool,
|
||||
}
|
||||
|
||||
/// The command line. An empty or blank variable counts as unset.
|
||||
@@ -81,7 +84,10 @@ mod tests {
|
||||
assert_eq!((parsed.control, parsed.sample), (Some(50494), true));
|
||||
assert_eq!(parsed.files, [PathBuf::from("a.dxf"), PathBuf::from("b.dwg")]);
|
||||
let parsed = parse_args(&[]).unwrap();
|
||||
assert_eq!((parsed.control, parsed.sample, parsed.files.len()), (None, false, 0));
|
||||
assert_eq!((parsed.control, parsed.sample, parsed.new_window, parsed.files.len()), (None, false, false, 0));
|
||||
let parsed = parse_args(&["--new-window", "a.dwg"]).unwrap();
|
||||
assert!(parsed.new_window);
|
||||
assert_eq!(parsed.files, [PathBuf::from("a.dwg")]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! CADCraft desktop app.
|
||||
//!
|
||||
//! Usage: `cadcraft [--control <port>] [--sample] [files…]` (`cadcraft --help` lists the rest; see [`launch_args`])
|
||||
//! Usage: `cadcraft [--control <port>] [--sample] [--new-window] [files…]` (`cadcraft --help` lists the rest; see [`launch_args`])
|
||||
//!
|
||||
//! `--control <port>` (or `CADCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server:
|
||||
//! `{"id":1,"method":"cmdline.input","params":{"text":"circle 0,0 5"}}` → `{"id":1,"ok":true,…}`.
|
||||
@@ -25,6 +25,7 @@ mod logging;
|
||||
mod native_menu;
|
||||
#[cfg(target_os = "macos")]
|
||||
mod sheet;
|
||||
mod single_instance;
|
||||
mod spacemouse;
|
||||
mod system_animations;
|
||||
mod workspace;
|
||||
@@ -42,6 +43,8 @@ struct App {
|
||||
system_animations: system_animations::SystemAnimations,
|
||||
workspace: workspace::Workspace,
|
||||
workspace_error: Option<String>,
|
||||
/// The first CADCraft of this sign-in: files that later launches hand over (Windows).
|
||||
single_instance: Option<single_instance::Server>,
|
||||
#[cfg(target_os = "macos")]
|
||||
native_menu: Option<native_menu::NativeMenu>,
|
||||
/// `CADCRAFT_NO_NATIVE_MENU`: the menus stay inside the window.
|
||||
@@ -87,6 +90,17 @@ impl eframe::App for App {
|
||||
/// eframe logic callback: syncs the OS animation setting and runs `CadApp::logic`; when the pass index is 0 (the first pass or a hidden tick) it also installs/polls the macOS native menu, polls the spacemouse and persists the workspace; a quit request closes the viewport.
|
||||
fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
||||
self.cad.system_animations = self.system_animations.current();
|
||||
// Files another launch handed over open as tabs here, and the window comes forward.
|
||||
if let Some(server) = &self.single_instance {
|
||||
let paths = server.take_paths();
|
||||
if !paths.is_empty() {
|
||||
ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(false));
|
||||
ctx.send_viewport_cmd(egui::ViewportCommand::Focus);
|
||||
for p in &paths {
|
||||
self.cad.open_path(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Consume control/open/screenshot queues and time-based autosave, including hidden ticks.
|
||||
self.cad.guarded_logic(ctx);
|
||||
// Host frame work runs here, once per frame, and so also on a hidden logic-only tick (which
|
||||
@@ -157,6 +171,8 @@ pub fn install_io() {
|
||||
groups: cadcraft_io::entity_groups,
|
||||
entity: cadcraft_io::entity_from_groups,
|
||||
});
|
||||
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
|
||||
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
|
||||
}
|
||||
|
||||
fn services() -> Services {
|
||||
@@ -308,6 +324,14 @@ fn main() -> eframe::Result {
|
||||
}
|
||||
}
|
||||
}
|
||||
// A launch that only names files hands them to the CADCraft already running and exits.
|
||||
let handed = single_instance::absolute(&files);
|
||||
let may_hand_off = handed.is_some() && !launch.new_window && !files.is_empty() && control_port.is_none() && !sample;
|
||||
let instance = match single_instance::claim(handed.as_deref().unwrap_or_default(), may_hand_off) {
|
||||
single_instance::Claim::HandedOff => return Ok(()),
|
||||
single_instance::Claim::Primary(server) => Some(server),
|
||||
single_instance::Claim::Alone => None,
|
||||
};
|
||||
install_io();
|
||||
cadcraft_engine::settings_dir::set(vars.config_dir.clone());
|
||||
if let Some(dir) = &vars.config_dir {
|
||||
@@ -428,6 +452,10 @@ fn main() -> eframe::Result {
|
||||
let metric = app.session.settings.measureinit;
|
||||
app.session.new_drawing(metric);
|
||||
}
|
||||
if let Some(server) = &instance {
|
||||
let ctx = cc.egui_ctx.clone();
|
||||
server.set_wake(move || ctx.request_repaint());
|
||||
}
|
||||
let ctx = cc.egui_ctx.clone();
|
||||
let desktop_theme = desktop_theme::DesktopTheme::start(move || ctx.request_repaint());
|
||||
let ctx = cc.egui_ctx.clone();
|
||||
@@ -439,6 +467,7 @@ fn main() -> eframe::Result {
|
||||
spacemouse: spacemouse::SpaceMouse::start(cc.egui_ctx.clone()),
|
||||
workspace,
|
||||
workspace_error,
|
||||
single_instance: instance,
|
||||
#[cfg(target_os = "macos")]
|
||||
native_menu: None,
|
||||
#[cfg(target_os = "macos")]
|
||||
|
||||
@@ -0,0 +1,393 @@
|
||||
//! One CADCraft per Windows sign-in: a launch that only names files hands them to the CADCraft
|
||||
//! that is already running, where they open as tabs, and exits.
|
||||
//!
|
||||
//! Outlook attachments, Explorer double-clicks and Open With all start `cadcraft.exe "<file>"`, so
|
||||
//! without single instance, every file got its own process and window. The first CADCraft listens on a Unix
|
||||
//! domain socket (Windows 10 1803 and later) in `%LOCALAPPDATA%\CADCraft`. The socket is named after the
|
||||
//! Windows session (`instance-Console.sock`), so two sign-ins of the same user never open files in each
|
||||
//! other's windows. The exchange is one line each way, a JSON request naming absolute paths and `ok`,
|
||||
//! and the running app opens the paths exactly as File ▸ Open would. `--new-window` opens a window
|
||||
//! of its own, and so does a launch with anything besides files (`--control`, `--sample`).
|
||||
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, Mutex, PoisonError};
|
||||
#[cfg(windows)]
|
||||
use std::time::Duration;
|
||||
|
||||
/// Longest request read: one line of JSON, far longer than any real list of paths.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
const MAX_REQUEST: u64 = 1 << 20;
|
||||
|
||||
/// How long either side waits for the other before giving up.
|
||||
#[cfg(windows)]
|
||||
const TIMEOUT: Duration = Duration::from_secs(5);
|
||||
|
||||
/// What this launch should do.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
pub enum Claim {
|
||||
/// The running CADCraft took the files: exit without a window.
|
||||
HandedOff,
|
||||
/// This is the first CADCraft: open a window and accept later launches' files.
|
||||
Primary(Server),
|
||||
/// Open a window of its own and accept nothing.
|
||||
Alone,
|
||||
}
|
||||
|
||||
/// Files that later launches handed over, and how to wake the UI for them.
|
||||
#[derive(Default)]
|
||||
struct Inbox {
|
||||
paths: Vec<PathBuf>,
|
||||
wake: Option<Box<dyn Fn() + Send>>,
|
||||
}
|
||||
|
||||
/// The first CADCraft's end of the socket. A background thread accepts launches until the
|
||||
/// process exits; the UI picks their files up through [`Server::take_paths`].
|
||||
#[derive(Clone)]
|
||||
pub struct Server {
|
||||
inbox: Arc<Mutex<Inbox>>,
|
||||
}
|
||||
|
||||
impl Server {
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
fn new() -> Self {
|
||||
Self { inbox: Arc::default() }
|
||||
}
|
||||
|
||||
/// Queue files from another launch and wake the UI.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
fn deliver(&self, paths: Vec<String>) {
|
||||
let mut inbox = self.inbox.lock().unwrap_or_else(PoisonError::into_inner);
|
||||
inbox.paths.extend(paths.into_iter().map(PathBuf::from));
|
||||
if let Some(wake) = &inbox.wake {
|
||||
wake();
|
||||
}
|
||||
}
|
||||
|
||||
/// Register a callback to wake the UI when new files arrive.
|
||||
pub fn set_wake(&self, wake: impl Fn() + Send + 'static) {
|
||||
self.inbox.lock().unwrap_or_else(PoisonError::into_inner).wake = Some(Box::new(wake));
|
||||
}
|
||||
|
||||
/// Take any queued paths delivered to this server.
|
||||
pub fn take_paths(&self) -> Vec<PathBuf> {
|
||||
std::mem::take(&mut self.inbox.lock().unwrap_or_else(PoisonError::into_inner).paths)
|
||||
}
|
||||
}
|
||||
|
||||
/// The request a launch sends: `{"open":[…]}` and a newline.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
pub fn request(paths: &[String]) -> String {
|
||||
let mut line = serde_json::json!({ "open": paths }).to_string();
|
||||
line.push('\n');
|
||||
line
|
||||
}
|
||||
|
||||
/// The paths a request names, or `None` when it isn't a request.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
pub fn parse_request(line: &str) -> Option<Vec<String>> {
|
||||
let value: serde_json::Value = serde_json::from_str(line.trim_end()).ok()?;
|
||||
let open = value.get("open")?.as_array()?;
|
||||
let paths = open.iter().map(|p| p.as_str().filter(|s| !s.is_empty()).map(str::to_string)).collect::<Option<Vec<String>>>()?;
|
||||
(!paths.is_empty()).then_some(paths)
|
||||
}
|
||||
|
||||
/// File arguments made absolute against this launch's working folder, as the request names them.
|
||||
/// `None` when one isn't valid Unicode: JSON can't carry it unchanged, so that launch opens its
|
||||
/// own window.
|
||||
pub fn absolute(paths: &[PathBuf]) -> Option<Vec<String>> {
|
||||
paths.iter().map(|p| std::path::absolute(p).unwrap_or_else(|_| p.clone()).into_os_string().into_string().ok()).collect()
|
||||
}
|
||||
|
||||
/// Decide what this launch does. `files` are absolute ([`absolute`]); `may_hand_off` is false
|
||||
/// when the launch asked for anything besides opening files, so it gets its own window.
|
||||
pub fn claim(files: &[String], may_hand_off: bool) -> Claim {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
match socket_path() {
|
||||
Some(path) => claim_at(&path, files, may_hand_off),
|
||||
None => Claim::Alone,
|
||||
}
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
let _ = (files, may_hand_off);
|
||||
Claim::Alone
|
||||
}
|
||||
}
|
||||
|
||||
/// The socket in `%LOCALAPPDATA%\CADCraft`.
|
||||
#[cfg(windows)]
|
||||
fn socket_path() -> Option<std::path::PathBuf> {
|
||||
let name = socket_name(std::env::var("SESSIONNAME").ok().as_deref());
|
||||
std::env::var_os("LOCALAPPDATA").filter(|v| !v.is_empty()).map(|d| std::path::PathBuf::from(d).join("CADCraft").join(name))
|
||||
}
|
||||
|
||||
/// The socket's file name for a Windows session (`SESSIONNAME`: `Console`, `RDP-Tcp#3`…): a 64-bit
|
||||
/// FNV-1a hash of the whole name, so two sessions of one user practically never share a socket
|
||||
/// (`RDP-Tcp#3` and `RDP-Tcp3` stay apart; a user has a handful of sessions, not billions), and the
|
||||
/// name has a fixed, short length. A Windows socket path holds at most 107
|
||||
/// bytes including `%LOCALAPPDATA%\CADCraft\`, so the name must not grow with the session's.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
fn socket_name(session: Option<&str>) -> String {
|
||||
let hash = session.unwrap_or_default().bytes().fold(0xcbf2_9ce4_8422_2325_u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3));
|
||||
format!("{hash:016x}.sock")
|
||||
}
|
||||
|
||||
/// Held while a launch finds out whether it is the first, so launches that start together take turns.
|
||||
#[cfg(windows)]
|
||||
fn election(socket: &std::path::Path) -> Option<std::fs::File> {
|
||||
if let Some(dir) = socket.parent() {
|
||||
let _ = std::fs::create_dir_all(dir);
|
||||
}
|
||||
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).open(socket.with_extension("lock")).ok()?;
|
||||
let deadline = std::time::Instant::now() + TIMEOUT;
|
||||
loop {
|
||||
match file.try_lock() {
|
||||
Ok(()) => return Some(file),
|
||||
Err(std::fs::TryLockError::WouldBlock) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
|
||||
Err(e) => {
|
||||
log::info!("single instance: no election lock ({e})");
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// [`claim`] with the socket at `path`.
|
||||
#[cfg(windows)]
|
||||
fn claim_at(path: &std::path::Path, files: &[String], may_hand_off: bool) -> Claim {
|
||||
use uds_windows::{UnixListener, UnixStream};
|
||||
let _election = election(path);
|
||||
for _ in 0..3 {
|
||||
match UnixStream::connect(path) {
|
||||
Ok(stream) => {
|
||||
if !may_hand_off {
|
||||
return Claim::Alone;
|
||||
}
|
||||
return match hand_off(&stream, files) {
|
||||
Ok(()) => Claim::HandedOff,
|
||||
Err(e) => {
|
||||
log::warn!("couldn't hand the files to the running CADCraft ({e}); opening a new window");
|
||||
Claim::Alone
|
||||
}
|
||||
};
|
||||
}
|
||||
// Only a refused or missing socket is stale: any other failure may come from a
|
||||
// listener that is alive, whose socket must not be taken over.
|
||||
Err(e) if !matches!(e.kind(), std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::NotFound) => {
|
||||
log::warn!("single instance off: can't reach {} ({e})", path.display());
|
||||
return Claim::Alone;
|
||||
}
|
||||
Err(_) => match std::fs::remove_file(path) {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
continue;
|
||||
}
|
||||
Err(e) => {
|
||||
log::warn!("single instance off: can't clear {} ({e})", path.display());
|
||||
return Claim::Alone;
|
||||
}
|
||||
},
|
||||
}
|
||||
if let Some(dir) = path.parent() {
|
||||
let _ = std::fs::create_dir_all(dir);
|
||||
}
|
||||
match UnixListener::bind(path) {
|
||||
Ok(listener) => return serve(listener),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::AddrInUse => continue,
|
||||
Err(e) => {
|
||||
log::warn!("single instance off: can't listen at {} ({e})", path.display());
|
||||
return Claim::Alone;
|
||||
}
|
||||
}
|
||||
}
|
||||
Claim::Alone
|
||||
}
|
||||
|
||||
/// Send `files` over `stream` and wait for the running app's `ok`.
|
||||
#[cfg(windows)]
|
||||
fn hand_off(stream: &uds_windows::UnixStream, files: &[String]) -> std::io::Result<()> {
|
||||
use std::io::{BufRead, Read, Write};
|
||||
stream.set_read_timeout(Some(TIMEOUT))?;
|
||||
stream.set_write_timeout(Some(TIMEOUT))?;
|
||||
let mut writer = stream;
|
||||
writer.write_all(request(files).as_bytes())?;
|
||||
let mut reply = String::new();
|
||||
std::io::BufReader::new(stream.take(16)).read_line(&mut reply)?;
|
||||
if reply == "ok\n" { Ok(()) } else { Err(std::io::Error::other("the running CADCraft didn't confirm")) }
|
||||
}
|
||||
|
||||
/// Accept launches on a background thread for as long as the process runs.
|
||||
#[cfg(windows)]
|
||||
fn serve(listener: uds_windows::UnixListener) -> Claim {
|
||||
let server = Server::new();
|
||||
let inbox = Server { inbox: Arc::clone(&server.inbox) };
|
||||
let started = std::thread::Builder::new().name("single-instance".into()).spawn(move || {
|
||||
for stream in listener.incoming() {
|
||||
let result = stream.and_then(|s| receive(&s, &inbox));
|
||||
if let Err(e) = result {
|
||||
log::warn!("single instance: a launch's request failed ({e})");
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
}
|
||||
});
|
||||
match started {
|
||||
Ok(_) => Claim::Primary(server),
|
||||
Err(e) => {
|
||||
log::warn!("single instance off: no listener thread ({e})");
|
||||
Claim::Alone
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Read one launch's request, queue its files and confirm.
|
||||
#[cfg(windows)]
|
||||
fn receive(stream: &uds_windows::UnixStream, server: &Server) -> std::io::Result<()> {
|
||||
use std::io::{BufRead, Read, Write};
|
||||
stream.set_read_timeout(Some(TIMEOUT))?;
|
||||
stream.set_write_timeout(Some(TIMEOUT))?;
|
||||
let mut line = String::new();
|
||||
std::io::BufReader::new(stream.take(MAX_REQUEST)).read_line(&mut line)?;
|
||||
if line.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let paths = parse_request(&line)
|
||||
.filter(|paths| paths.iter().all(|p| std::path::Path::new(p).is_absolute()))
|
||||
.ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidData, "not an open request of absolute paths"))?;
|
||||
server.deliver(paths);
|
||||
let mut writer = stream;
|
||||
writer.write_all(b"ok\n")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_request_names_its_paths_and_parses_back() {
|
||||
let paths = vec![r"C:\Plans\Ground floor.dwg".to_string(), "C:\\Plans\\Schnitt ä.dxf".to_string()];
|
||||
let line = request(&paths);
|
||||
assert!(line.ends_with('\n') && !line.trim_end().contains('\n'), "{line:?}");
|
||||
assert_eq!(parse_request(&line), Some(paths));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn anything_else_is_not_a_request() {
|
||||
for line in ["", "ok\n", "{}", r#"{"open":[]}"#, r#"{"open":[""]}"#, r#"{"open":["a",1]}"#, r#"{"open":"a"}"#, "[\"a\"]"] {
|
||||
assert_eq!(parse_request(line), None, "{line:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_socket_is_named_after_the_session() {
|
||||
let names = [None, Some(""), Some("Console"), Some("RDP-Tcp#3"), Some("RDP-Tcp3"), Some(r"..\x")];
|
||||
let sockets: Vec<String> = names.iter().map(|n| socket_name(*n)).collect();
|
||||
// No session name is the same as an empty one; every other name gets its own socket.
|
||||
assert_eq!(sockets[0], sockets[1]);
|
||||
let distinct: std::collections::HashSet<&String> = sockets[1..].iter().collect();
|
||||
assert_eq!(distinct.len(), names.len() - 1, "{sockets:?}");
|
||||
// Short, fixed and safe as a file name, whatever the session is called.
|
||||
let long = socket_name(Some(&"\u{10ffff}".repeat(32)));
|
||||
for s in sockets.iter().chain([&long]) {
|
||||
assert_eq!(s.len(), 21, "{s}");
|
||||
assert!(s.strip_suffix(".sock").is_some_and(|h| h.bytes().all(|b| b.is_ascii_hexdigit())), "{s}");
|
||||
}
|
||||
// Names that differ only past the 32nd character stay apart.
|
||||
let long = "S".repeat(40);
|
||||
assert_ne!(socket_name(Some(&long)), socket_name(Some(&long[..39])));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn files_are_made_absolute() {
|
||||
let files = absolute(&[PathBuf::from("a.dwg")]).unwrap();
|
||||
assert_eq!(files.len(), 1);
|
||||
assert!(std::path::Path::new(&files[0]).is_absolute() && files[0].ends_with("a.dwg"), "{files:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delivered_files_wait_for_the_ui_and_wake_it() {
|
||||
let server = Server::new();
|
||||
let woken = Arc::new(Mutex::new(0));
|
||||
let count = Arc::clone(&woken);
|
||||
server.set_wake(move || *count.lock().unwrap() += 1);
|
||||
server.deliver(vec!["a.dwg".into()]);
|
||||
server.deliver(vec!["b.dxf".into()]);
|
||||
assert_eq!(*woken.lock().unwrap(), 2);
|
||||
assert_eq!(server.take_paths(), [PathBuf::from("a.dwg"), PathBuf::from("b.dxf")]);
|
||||
assert!(server.take_paths().is_empty());
|
||||
}
|
||||
|
||||
/// Removes a test's folder when the test ends, best effort: the listener thread keeps its socket
|
||||
/// open until the process exits.
|
||||
#[cfg(windows)]
|
||||
struct Cleanup(PathBuf);
|
||||
|
||||
#[cfg(windows)]
|
||||
impl Drop for Cleanup {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// A fresh folder for one test, and its socket path.
|
||||
#[cfg(windows)]
|
||||
fn socket_dir(test: &str) -> (Cleanup, PathBuf) {
|
||||
let dir = std::env::temp_dir().join(format!("cadcraft-single-instance-{}-{test}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let path = dir.join("instance-test.sock");
|
||||
(Cleanup(dir), path)
|
||||
}
|
||||
|
||||
/// The whole exchange over a real socket: a stale socket file is taken over, a later launch
|
||||
/// hands its files to that listener, one that asked for its own window gets it, and a request
|
||||
/// naming a relative path is refused.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_later_launch_hands_its_files_to_the_first() {
|
||||
let (dir, path) = socket_dir("handoff");
|
||||
drop(uds_windows::UnixListener::bind(&path).unwrap());
|
||||
assert!(path.exists(), "the stale socket file stays behind");
|
||||
|
||||
let Claim::Primary(server) = claim_at(&path, &[], false) else { panic!("the stale socket wasn't taken over") };
|
||||
let files = vec![dir.0.join("a.dwg").to_string_lossy().into_owned()];
|
||||
// The listener queues the files before it confirms, so they are there once this returns.
|
||||
assert!(matches!(claim_at(&path, &files, true), Claim::HandedOff));
|
||||
assert_eq!(server.take_paths(), [PathBuf::from(&files[0])]);
|
||||
assert!(matches!(claim_at(&path, &files, false), Claim::Alone));
|
||||
assert!(server.take_paths().is_empty());
|
||||
// Not confirmed, so that launch opens its own window and nothing is queued.
|
||||
assert!(matches!(claim_at(&path, &["a.dwg".to_string()], true), Claim::Alone));
|
||||
assert!(server.take_paths().is_empty());
|
||||
}
|
||||
|
||||
/// Launches that start together take turns: one opens the window, the others hand it their files.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn launches_at_once_open_one_window() {
|
||||
const LAUNCHES: usize = 6;
|
||||
let (dir, path) = socket_dir("together");
|
||||
let start = Arc::new(std::sync::Barrier::new(LAUNCHES));
|
||||
let launches: Vec<_> = (0..LAUNCHES)
|
||||
.map(|i| {
|
||||
let (path, start) = (path.clone(), Arc::clone(&start));
|
||||
let file = dir.0.join(format!("{i}.dwg")).to_string_lossy().into_owned();
|
||||
std::thread::spawn(move || {
|
||||
start.wait();
|
||||
(file.clone(), claim_at(&path, &[file], true))
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let results: Vec<(String, Claim)> = launches.into_iter().map(|t| t.join().unwrap()).collect();
|
||||
let servers: Vec<&Server> = results.iter().filter_map(|(_, c)| if let Claim::Primary(s) = c { Some(s) } else { None }).collect();
|
||||
assert_eq!(servers.len(), 1, "one window");
|
||||
let mut handed: Vec<PathBuf> = results.iter().filter(|(_, c)| matches!(c, Claim::HandedOff)).map(|(f, _)| PathBuf::from(f)).collect();
|
||||
assert_eq!(handed.len(), LAUNCHES - 1, "the rest handed their files over");
|
||||
let mut received = servers[0].take_paths();
|
||||
handed.sort();
|
||||
received.sort();
|
||||
assert_eq!(received, handed);
|
||||
}
|
||||
}
|
||||
@@ -106,6 +106,10 @@ sync_github_name = true
|
||||
[people.GULERTOLGA]
|
||||
sync_github_name = true
|
||||
|
||||
[people.Obtrusive8276]
|
||||
display_name = "Nicopicks"
|
||||
sync_github_name = false
|
||||
|
||||
[people.Tyler-Chiriboga]
|
||||
real_name = "Tyler Chiriboga"
|
||||
sync_github_name = true
|
||||
@@ -121,3 +125,6 @@ real_name = "Helen Kwok"
|
||||
|
||||
[people.V1dalTheAbidal]
|
||||
sync_github_name = true
|
||||
|
||||
[people.tyrel]
|
||||
real_name = "Tyrel Haveman"
|
||||
|
||||
+13
-2
@@ -172,8 +172,8 @@ fn build_palette() -> [Rgb; 256] {
|
||||
Rgb(0, 0, 255),
|
||||
Rgb(255, 0, 255),
|
||||
Rgb(255, 255, 255),
|
||||
Rgb(65, 65, 65),
|
||||
Rgb(128, 128, 128),
|
||||
Rgb(192, 192, 192),
|
||||
];
|
||||
for (slot, colour) in palette.iter_mut().zip(base) {
|
||||
*slot = colour;
|
||||
@@ -193,7 +193,7 @@ fn build_palette() -> [Rgb; 256] {
|
||||
*slot = Rgb(channel(red), channel(green), channel(blue));
|
||||
}
|
||||
}
|
||||
let greys = [51u8, 91, 132, 173, 214, 255];
|
||||
let greys = [51u8, 80, 105, 130, 190, 255];
|
||||
for (offset, shade) in greys.iter().enumerate() {
|
||||
if let Some(slot) = palette.get_mut(250 + offset) {
|
||||
*slot = Rgb(*shade, *shade, *shade);
|
||||
@@ -302,6 +302,17 @@ mod tests {
|
||||
assert_eq!(aci_rgb(255), Rgb(255, 255, 255));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn palette_fixed_greys() {
|
||||
assert_eq!(aci_rgb(8), Rgb(65, 65, 65));
|
||||
assert_eq!(aci_rgb(9), Rgb(128, 128, 128));
|
||||
for (i, g) in [(250u8, 51u8), (251, 80), (252, 105), (253, 130), (254, 190)] {
|
||||
assert_eq!(aci_rgb(i), Rgb(g, g, g));
|
||||
}
|
||||
assert_eq!(nearest_aci(Rgb(65, 65, 65)), 8);
|
||||
assert_eq!(nearest_aci(Rgb(128, 128, 128)), 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aci_roundtrip_and_parse() {
|
||||
assert_eq!(Color::from_aci(256), Color::ByLayer);
|
||||
|
||||
@@ -72,6 +72,10 @@ pub struct Foreign {
|
||||
/// proxy objects or entities: a proxy's class number (group 91) is 500 plus its class's place
|
||||
/// here, and saving renumbers it to the written CLASSES (#1812).
|
||||
pub class_order: Vec<String>,
|
||||
/// The roles of every file handle of an object CADCraft writes itself (table records, tables,
|
||||
/// blocks, the named object dictionary and its entries), so that AutoLISP names those objects
|
||||
/// as the file did (`handent`). Saving gives them new handles; not part of [`Foreign::is_empty`].
|
||||
pub handles: BTreeMap<Handle, ForeignKey>,
|
||||
/// The file's data store section (ACDSDATA, AutoCAD 2013 and later), as read: its groups
|
||||
/// after the section name. It holds the ACIS geometry of 3D solids, regions, bodies and
|
||||
/// surfaces, which from 2013 on those entities don't carry themselves: each `ACDSRECORD`
|
||||
|
||||
+13
-3
@@ -209,12 +209,22 @@ impl Drawing {
|
||||
}
|
||||
}
|
||||
|
||||
/// Allocate a fresh handle.
|
||||
/// Allocate a fresh handle. It skips the handles the drawing's file gave the objects CADCraft
|
||||
/// writes itself ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a
|
||||
/// file CADCraft wrote numbers them above its `$HANDSEED` (#495).
|
||||
pub fn new_handle(&mut self) -> Handle {
|
||||
let h = Handle(self.handseed);
|
||||
self.handseed = self.handseed.saturating_add(1);
|
||||
let h = self.next_handle();
|
||||
self.handseed = h.0.saturating_add(1);
|
||||
h
|
||||
}
|
||||
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it.
|
||||
pub fn next_handle(&self) -> Handle {
|
||||
let mut h = self.handseed;
|
||||
while self.foreign.handles.contains_key(&Handle(h)) && h < u64::MAX {
|
||||
h = h.saturating_add(1);
|
||||
}
|
||||
Handle(h)
|
||||
}
|
||||
/// Make sure future handles don't collide with `h` (after loading a file).
|
||||
pub fn bump_handseed(&mut self, h: Handle) {
|
||||
if h.0 >= self.handseed {
|
||||
|
||||
@@ -476,6 +476,7 @@ impl DimStyle {
|
||||
match field {
|
||||
"textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
|
||||
"scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
|
||||
"decimals" | "altDecimals" | "tolDecimals" => x.is_some_and(|x| !(0.0..=8.0).contains(&x)),
|
||||
"fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
|
||||
"textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
|
||||
"dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
|
||||
|
||||
@@ -715,6 +715,17 @@ fn space_names_its_tab() {
|
||||
assert_eq!(p.tab_name(), "Sheet A");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_handles_skip_the_files_object_handles() {
|
||||
let mut d = Drawing::new_metric();
|
||||
let next = d.handseed;
|
||||
let f = std::sync::Arc::make_mut(&mut d.foreign);
|
||||
f.handles.insert(Handle(next), ("LAYER".into(), "0".into()));
|
||||
f.handles.insert(Handle(next + 1), ("NOD".into(), String::new()));
|
||||
assert_eq!(d.new_handle(), Handle(next + 2));
|
||||
assert_eq!(d.new_handle(), Handle(next + 3));
|
||||
}
|
||||
|
||||
/// Several spellings of one DIM field apply once, the last in the map's order, and none is rejected.
|
||||
#[test]
|
||||
fn dim_style_spellings_of_one_field_apply_once() {
|
||||
|
||||
@@ -8,6 +8,8 @@ mod audit;
|
||||
pub(crate) mod blocks;
|
||||
pub mod clipboard;
|
||||
pub mod constraints;
|
||||
mod dimstyle_cli;
|
||||
mod dimstyles;
|
||||
mod draw;
|
||||
mod draw2;
|
||||
mod draworder;
|
||||
@@ -34,6 +36,8 @@ mod overkill;
|
||||
mod pline_opts;
|
||||
pub mod plotters;
|
||||
mod props;
|
||||
pub use blocks::library::{clear_library_cache, list_library, read_library_file};
|
||||
pub use dimstyle_cli::usable_dim_style_name;
|
||||
pub use draw2::breakline::BreaklineOptions;
|
||||
pub use props::MatchProps;
|
||||
pub(crate) use props::UNIT_RANGES;
|
||||
@@ -186,6 +190,8 @@ pub fn command_specs() -> &'static [CommandSpec] {
|
||||
v.extend(draw::specs());
|
||||
v.extend(draw2::specs());
|
||||
v.extend(annotate::specs());
|
||||
v.extend(dimstyles::specs());
|
||||
v.extend(dimstyle_cli::specs());
|
||||
v.extend(mleader_edit::specs());
|
||||
v.extend(annoscale::specs());
|
||||
v.extend(hatch::specs());
|
||||
|
||||
+129
-11
@@ -44,13 +44,17 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
.alias(&["i", "-insert", "ddinsert"])
|
||||
.params("{name (\"*NAME\": exploded), file?: DXF/DWG path (defines or redefines block `name`, default the file name, from its model space; base point $INSBASE), at: [x,y], scale?: number | [x, y], rotation? (degrees), basePoint?: [x,y] (block coordinates), attribs?: {TAG: value}, explode?: bool}")
|
||||
.interactive(|_| Ok(Box::new(InsertM::default()))),
|
||||
CommandSpec::new("blockspalette", "Blocks Palette", run_blockspalette)
|
||||
.params("{references?: bool (default true; counting reads every object)} → {blocks: [{name, description, references?}], truncated} (the app opens the Blocks palette instead)")
|
||||
.enabled(has_doc)
|
||||
.noundo(),
|
||||
CommandSpec::new("minsert", "Multiple Insert", run_minsert)
|
||||
.params("{name, file?: DXF/DWG path (as INSERT), at: [x,y], scale?: number | [x, y], rotation? (degrees), basePoint?: [x,y], attribs?: {TAG: value}, rows?: 1..32767 (default 1), columns?: 1..32767 (default 1), rowSpacing?, columnSpacing? (along the reference's own axes, not scaled with it)}")
|
||||
.interactive(|_| Ok(Box::new(InsertM { minsert: true, ..InsertM::default() }))),
|
||||
CommandSpec::new("attdef", "Define Attributes...", run_attdef)
|
||||
.menu(&["Draw", "Block", "Define Attributes..."])
|
||||
.alias(&["att", "-attdef"])
|
||||
.params("{tag, prompt?, default?, at, height?, invisible?}")
|
||||
.params("{tag, prompt?, default?, at, height?, invisible?, justify?: L|C|R|M|TL|TC|TR|ML|MC|MR|BL|BC|BR, style? (default the current text style)}")
|
||||
.interactive(|_| Ok(Box::new(attdef::AttdefM::default()))),
|
||||
attedit::attedit_spec(),
|
||||
attedit::dash_attedit_spec(),
|
||||
@@ -92,6 +96,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
.into_iter()
|
||||
.chain(attribs::attdisp_menu_specs())
|
||||
.chain(xref::specs())
|
||||
.chain(library::specs())
|
||||
.chain(refedit::specs())
|
||||
.chain(xclip::specs())
|
||||
.chain(bedit::specs())
|
||||
@@ -113,6 +118,15 @@ fn referenced_block(e: &Entity) -> Option<String> {
|
||||
}
|
||||
}
|
||||
|
||||
/// The attributes an object carries: a block reference's, or those of a multileader's block content.
|
||||
pub(crate) fn object_attribs(e: &Entity) -> &[Attrib] {
|
||||
match &e.kind {
|
||||
EntityKind::Insert(i) => &i.attribs,
|
||||
EntityKind::MLeader(m) => m.block.as_ref().map_or(&[][..], |b| b.attribs.as_slice()),
|
||||
_ => &[],
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether any of `ents` refers to block `name`, directly or through nested block references,
|
||||
/// dimension blocks and multileader block content.
|
||||
pub(crate) fn references_block(d: &cadcraft_doc::Drawing, ents: &[Entity], name: &str) -> bool {
|
||||
@@ -346,6 +360,40 @@ fn run_block(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "block": name, "insert": r.map(|h| h.hex()) }))
|
||||
}
|
||||
|
||||
/// BLOCKSPALETTE as a JSON call: the drawing's own blocks (no anonymous, layout or xref blocks)
|
||||
/// with their descriptions and how many objects draw each (block references, dimensions and
|
||||
/// multileader block content). The app opens the palette instead.
|
||||
fn run_blockspalette(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let d = s.doc()?;
|
||||
let counting = bool_or(p, "references", true);
|
||||
let mut counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
|
||||
if counting {
|
||||
let mut count = |store: &cadcraft_doc::EntityStore| {
|
||||
for e in store.iter() {
|
||||
if let Some(block) = referenced_block(e) {
|
||||
let n = counts.entry(block.to_ascii_lowercase()).or_insert(0);
|
||||
*n = n.saturating_add(1);
|
||||
}
|
||||
}
|
||||
};
|
||||
count(&d.model);
|
||||
d.layouts.iter().for_each(|l| count(&l.entities));
|
||||
d.blocks.values().for_each(|b| count(&b.entities));
|
||||
}
|
||||
let (blocks, truncated) = library::library_blocks(d);
|
||||
let list: Vec<Value> = blocks
|
||||
.iter()
|
||||
.map(|b| {
|
||||
let mut block = json!({ "name": b.name, "description": b.description });
|
||||
if counting {
|
||||
block["references"] = json!(counts.get(&b.name.to_ascii_lowercase()).copied().unwrap_or(0));
|
||||
}
|
||||
block
|
||||
})
|
||||
.collect();
|
||||
Ok(json!({ "blocks": list, "truncated": truncated }))
|
||||
}
|
||||
|
||||
fn run_insert(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
insert_json(s, p, "insert", Grid::ONE)
|
||||
}
|
||||
@@ -400,21 +448,79 @@ fn insert_json(s: &mut Session, p: &Value, cmd: &str, grid: Grid) -> Result<Valu
|
||||
Ok(attedit::with_unknown_tags(s, h, &vals, json!({ "handle": h.hex() })))
|
||||
}
|
||||
|
||||
fn attdef_kind(s: &Session, tag: &str, prompt: &str, default: &str, at: Vec2, height: f64, invisible: bool) -> EntityKind {
|
||||
let style = s.doc().map(|d| d.header.str("TEXTSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into());
|
||||
/// The current text style (TEXTSTYLE).
|
||||
fn current_text_style(s: &Session) -> String {
|
||||
s.doc().map(|d| d.header.str("TEXTSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into())
|
||||
}
|
||||
|
||||
/// A text style's name as the table spells it, with the width factor and oblique angle an
|
||||
/// attribute definition takes from it (the renderer uses the entity's own values). `None` when
|
||||
/// the drawing has no such style.
|
||||
fn style_values(s: &Session, name: &str) -> Result<Option<(String, f64, f64)>> {
|
||||
Ok(s.doc()?.text_style(name).map(|t| (t.name.clone(), t.width_factor, t.oblique)))
|
||||
}
|
||||
|
||||
/// The current text style (TEXTSTYLE) with its width factor and oblique angle.
|
||||
fn current_style_values(s: &Session) -> (String, f64, f64) {
|
||||
let name = current_text_style(s);
|
||||
style_values(s, &name).ok().flatten().unwrap_or((name, 1.0, 0.0))
|
||||
}
|
||||
|
||||
/// A justification code as `-ATTDEF` takes it, typed or in `justify`. Align and Fit run between
|
||||
/// two baseline points; `attdef` has one, so it can't express them.
|
||||
fn attdef_justify(code: &str) -> Result<(HAlign, VAlign)> {
|
||||
let j = super::draw::justify(code.trim()).ok_or_else(|| bad("attdef", "unknown justification"))?;
|
||||
if matches!(j.0, HAlign::Aligned | HAlign::Fit) {
|
||||
return Err(bad("attdef", "Align and Fit need two points, which attdef doesn't take yet; use L, C, R, M or TL … BR"));
|
||||
}
|
||||
Ok(j)
|
||||
}
|
||||
|
||||
/// The named text style with its width factor and oblique angle, or the error both the JSON form
|
||||
/// and the typed `Style` option give for a style the drawing doesn't have.
|
||||
fn resolve_style(s: &Session, name: &str) -> Result<(String, f64, f64)> {
|
||||
style_values(s, name)?.ok_or_else(|| bad("attdef", format!("no text style \"{name}\"")))
|
||||
}
|
||||
|
||||
/// An optional string parameter: absent or null is `None`, a string is `Some`, anything else is
|
||||
/// an error rather than being ignored.
|
||||
fn opt_str_param<'a>(cmd: &str, p: &'a Value, key: &str) -> Result<Option<&'a str>> {
|
||||
match p.get(key) {
|
||||
None | Some(Value::Null) => Ok(None),
|
||||
Some(Value::String(v)) => Ok(Some(v)),
|
||||
Some(v) => Err(bad(cmd, format!("`{key}` must be a string, got {v}"))),
|
||||
}
|
||||
}
|
||||
|
||||
/// An attribute definition at `at` with justification `j` (as TEXT: any but Left keeps `at` as
|
||||
/// its alignment point) in text style `style`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn attdef_kind(
|
||||
tag: &str,
|
||||
prompt: &str,
|
||||
default: &str,
|
||||
at: Vec2,
|
||||
height: f64,
|
||||
invisible: bool,
|
||||
j: (HAlign, VAlign),
|
||||
style: (String, f64, f64),
|
||||
) -> EntityKind {
|
||||
let (halign, valign) = j;
|
||||
let (style, width_factor, oblique) = style;
|
||||
let left = halign == HAlign::Left && valign == VAlign::Baseline;
|
||||
EntityKind::AttDef(Attrib {
|
||||
tag: tag.to_ascii_uppercase(),
|
||||
text: Text {
|
||||
insert: v3(at),
|
||||
align_pt: None,
|
||||
align_pt: if left { None } else { Some(v3(at)) },
|
||||
height,
|
||||
value: default.into(),
|
||||
rotation: 0.0,
|
||||
width_factor: 1.0,
|
||||
oblique: 0.0,
|
||||
width_factor,
|
||||
oblique,
|
||||
style,
|
||||
halign: HAlign::Left,
|
||||
valign: VAlign::Baseline,
|
||||
halign,
|
||||
valign,
|
||||
},
|
||||
invisible,
|
||||
constant: false,
|
||||
@@ -432,7 +538,14 @@ fn run_attdef(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
let at = point_req("attdef", p, "at")?;
|
||||
let h = f64_or(p, "height", s.doc()?.header.f64("TEXTSIZE", 0.2));
|
||||
let k = attdef_kind(s, tag, str_param(p, "prompt").unwrap_or(tag), str_param(p, "default").unwrap_or(""), at, h, bool_or(p, "invisible", false));
|
||||
// Justification and text style as TEXT and MTEXT take them (#1658).
|
||||
let j = attdef_justify(opt_str_param("attdef", p, "justify")?.unwrap_or("L"))?;
|
||||
let style = match opt_str_param("attdef", p, "style")? {
|
||||
Some(n) => resolve_style(s, n)?,
|
||||
None => current_style_values(s),
|
||||
};
|
||||
let (prompt, default) = (str_param(p, "prompt").unwrap_or(tag), str_param(p, "default").unwrap_or(""));
|
||||
let k = attdef_kind(tag, prompt, default, at, h, bool_or(p, "invisible", false), j, style);
|
||||
Ok(json!({ "handle": s.add_entity(k)?.hex() }))
|
||||
}
|
||||
|
||||
@@ -601,6 +714,7 @@ impl BlockM {
|
||||
}
|
||||
|
||||
mod insert_file;
|
||||
pub(crate) mod library;
|
||||
pub(crate) mod xref;
|
||||
|
||||
/// Where the command-line INSERT is in its prompt sequence.
|
||||
@@ -705,6 +819,9 @@ impl InsertM {
|
||||
if self.explode {
|
||||
insert_file::explode_insert(s, h)?;
|
||||
}
|
||||
// Written here, not when the name is given: a cancelled INSERT leaves the drawing as
|
||||
// it was, so it takes no undo step that would undo nothing visible.
|
||||
s.doc_mut()?.header.set_str("INSNAME", &n);
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
Ok(Step::Continue)
|
||||
@@ -760,13 +877,14 @@ impl InsertM {
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
s.doc_mut()?.header.set_str("INSNAME", &b.name);
|
||||
self.name = Some(b.name.clone());
|
||||
self.stage = InsStage::Point;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Define the block from a file, then choose it; a file that can't be read is reported.
|
||||
/// Define the block from a file, then choose it; a file that can't be read is reported. The
|
||||
/// definition comes before the insertion point and stays when INSERT is then cancelled, as in
|
||||
/// AutoCAD 2027.
|
||||
fn choose_file(&mut self, s: &mut Session, f: &insert_file::FileRef) -> Result<()> {
|
||||
match f.define(s) {
|
||||
Ok(name) => self.choose(s, &name),
|
||||
|
||||
@@ -103,6 +103,7 @@ impl AttdefM {
|
||||
fn finish(&mut self, s: &mut Session, rotation: f64) -> Result<Step> {
|
||||
let (h, v) = self.justify;
|
||||
let left = h == HAlign::Left && v == VAlign::Baseline;
|
||||
let (style, width_factor, oblique) = super::resolve_style(s, &self.style)?;
|
||||
s.add_entity(EntityKind::AttDef(Attrib {
|
||||
tag: self.tag.to_uppercase(),
|
||||
text: Text {
|
||||
@@ -111,9 +112,9 @@ impl AttdefM {
|
||||
height: self.height,
|
||||
value: std::mem::take(&mut self.value),
|
||||
rotation,
|
||||
width_factor: 1.0,
|
||||
oblique: 0.0,
|
||||
style: self.style.clone(),
|
||||
width_factor,
|
||||
oblique,
|
||||
style,
|
||||
halign: h,
|
||||
valign: v,
|
||||
},
|
||||
@@ -156,7 +157,7 @@ impl Interactive for AttdefM {
|
||||
Prompt::new(self.point_prompt(), Accept::POINT).kw(&["Justify", "Style"])
|
||||
}
|
||||
Ask::Point => Prompt::new(self.point_prompt(), Accept::POINT),
|
||||
Ask::Justify => Prompt::new("Enter an option", Accept::TEXT).kw(&JUSTIFY),
|
||||
Ask::Justify => crate::cmd::draw::justify_prompt(false),
|
||||
Ask::Style => Prompt::new("Enter style name", Accept::TEXT).kw(&["?"]).default(self.style.clone()),
|
||||
Ask::Height => {
|
||||
let th = s.doc().map(|d| d.header.f64("TEXTSIZE", 0.2)).unwrap_or(0.2);
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
//! (names this drawing already has keep this drawing's definitions). The file is read through the
|
||||
//! host's io hooks like OPEN, so the engine stays I/O-agnostic.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::sync::Arc;
|
||||
|
||||
use cadcraft_doc::{Block, Drawing, Entity, EntityKind, Handle};
|
||||
@@ -14,7 +14,8 @@ use serde_json::{Value, json};
|
||||
|
||||
use super::super::file::io;
|
||||
use super::super::modify::explode_kind;
|
||||
use super::{references_block, valid_block_name};
|
||||
use super::purge::{Kind, candidates, is_arrow_override, override_arrows, override_name, scan_reads_everything};
|
||||
use super::{referenced_block, references_block, valid_block_name};
|
||||
use crate::cmd::{bad, str_param};
|
||||
use crate::{EngineError, Result, Session};
|
||||
|
||||
@@ -37,7 +38,7 @@ impl FileRef {
|
||||
/// Read the file and (re)define its block. Returns the block's name.
|
||||
pub fn define(&self, s: &mut Session) -> Result<String> {
|
||||
let src = read_drawing(&self.path)?;
|
||||
define_from(s, &src, &self.name)
|
||||
define_from(s, &src, &self.name, false)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -45,6 +46,11 @@ impl FileRef {
|
||||
/// path (it has a folder separator or a .dwg/.dxf extension) that isn't the name of a block.
|
||||
pub(super) fn file_ref(s: &Session, t: &str) -> Option<FileRef> {
|
||||
let t = t.trim();
|
||||
// A block of this drawing is that block, whatever its name looks like: a name read from a file
|
||||
// must not pass for `name=path` and make INSERT read another file (CWE-74).
|
||||
if s.doc().is_ok_and(|d| d.block(t).is_some()) {
|
||||
return None;
|
||||
}
|
||||
if let Some((name, path)) = t.split_once('=') {
|
||||
let name = name.trim();
|
||||
let path = if path.trim().is_empty() { name } else { path.trim() };
|
||||
@@ -52,7 +58,7 @@ pub(super) fn file_ref(s: &Session, t: &str) -> Option<FileRef> {
|
||||
}
|
||||
let lower = t.to_ascii_lowercase();
|
||||
let pathlike = t.contains(['/', '\\']) || lower.ends_with(".dwg") || lower.ends_with(".dxf");
|
||||
if !pathlike || s.doc().is_ok_and(|d| d.block(t).is_some()) {
|
||||
if !pathlike {
|
||||
return None;
|
||||
}
|
||||
Some(FileRef { name: stem(t), path: t.to_string(), explicit: false })
|
||||
@@ -68,7 +74,7 @@ pub(super) fn stem(path: &str) -> String {
|
||||
}
|
||||
|
||||
/// Read a drawing file through the io hooks; a path without extension tries .dwg, then .dxf.
|
||||
fn read_drawing(path: &str) -> Result<Drawing> {
|
||||
pub(super) fn read_drawing(path: &str) -> Result<Drawing> {
|
||||
let hooks = io().ok_or_else(|| bad("insert", "file formats are not available in this build"))?;
|
||||
let has_ext = stem(path) != path.rsplit(['/', '\\']).next().unwrap_or(path);
|
||||
let candidates = if has_ext { vec![path.to_string()] } else { vec![path.to_string(), format!("{path}.dwg"), format!("{path}.dxf")] };
|
||||
@@ -93,18 +99,29 @@ fn read_file(_path: &str) -> Result<Vec<u8>> {
|
||||
}
|
||||
|
||||
/// (Re)define block `name` from `src`'s model space with base point `$INSBASE`, adding the
|
||||
/// layers, linetypes, styles and blocks of `src` this drawing doesn't have. Nothing changes when
|
||||
/// the definition fails (an invalid name, or a block that would contain itself).
|
||||
fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
|
||||
/// layers, linetypes, styles and blocks of `src` this drawing doesn't have. With `only_needed`
|
||||
/// the layers, linetypes and styles that nothing uses are left out again, as when a block is
|
||||
/// taken from a library drawing: only what the block needs comes along. Nothing changes when the
|
||||
/// definition fails (an invalid name, or a block that would contain itself).
|
||||
pub(super) fn define_from(s: &mut Session, src: &Drawing, name: &str, only_needed: bool) -> Result<String> {
|
||||
if !valid_block_name(name) {
|
||||
return Err(bad("insert", format!("\"{name}\" is not a valid block name")));
|
||||
}
|
||||
let mut d = s.doc()?.clone();
|
||||
let before = TableNames::of(&d);
|
||||
// Redefining keeps the existing definition's name (block names are case-insensitive).
|
||||
let name = d.blocks.keys().find(|k| k.eq_ignore_ascii_case(name)).cloned().unwrap_or_else(|| name.to_string());
|
||||
let own_dim_styles = names_of(&d, Kind::Dimstyles);
|
||||
merge_tables(&mut d, src);
|
||||
let renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
|
||||
for (from, to) in &renames {
|
||||
let mut renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
|
||||
if only_needed {
|
||||
// The other blocks of the file are not copied at all.
|
||||
let need = needed_blocks(src);
|
||||
renames.retain(|from, _| need.contains(&from.to_ascii_uppercase()));
|
||||
}
|
||||
let renames = Renames::new(renames);
|
||||
rename_style_arrows(&mut d, &own_dim_styles, &renames);
|
||||
for (from, to) in &renames.exact {
|
||||
let Some(b) = src.blocks.get(from) else { continue };
|
||||
let mut nb = (**b).clone();
|
||||
nb.name = to.clone();
|
||||
@@ -130,10 +147,129 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
|
||||
b.entities.push(e);
|
||||
}
|
||||
d.blocks.insert(name.clone(), Arc::new(b));
|
||||
if only_needed {
|
||||
drop_unused_new(&mut d, &before, &name);
|
||||
}
|
||||
*s.doc_mut()? = d;
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
/// The tables a drawing merge adds to, in an order where removing the unused entries of one
|
||||
/// frees the next (blocks free layers, layers free linetypes, dimension styles free text styles).
|
||||
const MERGED: [Kind; 8] =
|
||||
[Kind::Blocks, Kind::Dimstyles, Kind::MleaderStyles, Kind::MlineStyles, Kind::TableStyles, Kind::Layers, Kind::Linetypes, Kind::TextStyles];
|
||||
|
||||
/// The names (lower case) in one of those tables.
|
||||
fn names_of(d: &Drawing, kind: Kind) -> BTreeSet<String> {
|
||||
let lower = |it: &mut dyn Iterator<Item = &String>| it.map(|n| n.to_ascii_lowercase()).collect::<BTreeSet<String>>();
|
||||
match kind {
|
||||
Kind::Blocks => lower(&mut d.blocks.keys()),
|
||||
Kind::Dimstyles => lower(&mut d.dim_styles.iter().map(|t| &t.name)),
|
||||
Kind::MleaderStyles => lower(&mut d.mleader_styles.iter().map(|t| &t.name)),
|
||||
Kind::MlineStyles => lower(&mut d.mline_styles.iter().map(|t| &t.name)),
|
||||
Kind::TableStyles => lower(&mut d.table_styles.iter().map(|t| &t.name)),
|
||||
Kind::Layers => lower(&mut d.layers.iter().map(|t| &t.name)),
|
||||
Kind::Linetypes => lower(&mut d.linetypes.iter().map(|t| &t.name)),
|
||||
Kind::TextStyles => lower(&mut d.text_styles.iter().map(|t| &t.name)),
|
||||
_ => BTreeSet::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The names in the merged tables, by kind.
|
||||
struct TableNames(Vec<(Kind, BTreeSet<String>)>);
|
||||
|
||||
impl TableNames {
|
||||
fn of(d: &Drawing) -> Self {
|
||||
TableNames(MERGED.iter().map(|k| (*k, names_of(d, *k))).collect())
|
||||
}
|
||||
}
|
||||
|
||||
/// Upper-case names of the blocks `roots` and every block they need, through nested references,
|
||||
/// dimension blocks, multileader block content and dimension arrowheads.
|
||||
fn reachable(d: &Drawing, roots: Vec<String>) -> BTreeSet<String> {
|
||||
let mut seen = BTreeSet::new();
|
||||
let mut todo = roots;
|
||||
// Each block is walked once, so this ends, cycles included.
|
||||
while let Some(n) = todo.pop() {
|
||||
if !seen.insert(n.to_ascii_uppercase()) {
|
||||
continue;
|
||||
}
|
||||
let Some(b) = d.block(&n) else { continue };
|
||||
for e in b.entities.iter() {
|
||||
todo.extend(referenced_block(e));
|
||||
if let EntityKind::Dimension(dm) = &e.kind {
|
||||
todo.extend(override_arrows(dm));
|
||||
}
|
||||
}
|
||||
}
|
||||
seen
|
||||
}
|
||||
|
||||
/// Upper-case names of the blocks the model space of `src` needs: the ones it refers to, what
|
||||
/// those need, and the arrowheads of its dimension styles.
|
||||
fn needed_blocks(src: &Drawing) -> BTreeSet<String> {
|
||||
let mut roots: Vec<String> = Vec::new();
|
||||
for e in src.model.iter() {
|
||||
roots.extend(referenced_block(e));
|
||||
if let EntityKind::Dimension(dm) = &e.kind {
|
||||
roots.extend(override_arrows(dm));
|
||||
}
|
||||
}
|
||||
for st in &src.dim_styles {
|
||||
let arrows = [&st.arrow_block, &st.arrow_block1, &st.arrow_block2, &st.leader_arrow_block];
|
||||
roots.extend(arrows.into_iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()));
|
||||
}
|
||||
reachable(src, roots)
|
||||
}
|
||||
|
||||
/// Remove the blocks, layers, linetypes and styles that were not in the drawing `before` and that
|
||||
/// nothing uses (PURGE's scan), in an order where removing one frees the next. `keep` is the
|
||||
/// block just defined: nothing refers to it yet, so it and the blocks it needs stay. Nothing goes
|
||||
/// from a drawing too big for that scan: an unused entry stays, but a used one would be lost.
|
||||
fn drop_unused_new(d: &mut Drawing, before: &TableNames, keep: &str) {
|
||||
if !scan_reads_everything(d) {
|
||||
return;
|
||||
}
|
||||
// Removing a dimension style frees its arrowhead block, which an earlier table already
|
||||
// scanned: scan again until a pass removes nothing (a chain is never longer than the tables).
|
||||
for _ in 0..MERGED.len() {
|
||||
if !drop_unused_pass(d, before, keep) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One scan of the merged tables; `true` when it removed something.
|
||||
fn drop_unused_pass(d: &mut Drawing, before: &TableNames, keep: &str) -> bool {
|
||||
let mut removed = false;
|
||||
for (kind, old) in &before.0 {
|
||||
// Nothing was added to this table: nothing to scan for.
|
||||
if names_of(d, *kind).is_subset(old) {
|
||||
continue;
|
||||
}
|
||||
let keep_blocks = if matches!(kind, Kind::Blocks) { reachable(d, vec![keep.to_string()]) } else { BTreeSet::new() };
|
||||
let fresh: BTreeSet<String> = candidates(d, *kind)
|
||||
.into_iter()
|
||||
.filter(|n| !old.contains(&n.to_ascii_lowercase()) && !keep_blocks.contains(&n.to_ascii_uppercase()))
|
||||
.map(|n| n.to_ascii_lowercase())
|
||||
.collect();
|
||||
let gone = |name: &str| fresh.contains(&name.to_ascii_lowercase());
|
||||
removed |= !fresh.is_empty();
|
||||
match kind {
|
||||
Kind::Blocks => d.blocks.retain(|k, _| !gone(k)),
|
||||
Kind::Dimstyles => d.dim_styles.retain(|t| !gone(&t.name)),
|
||||
Kind::MleaderStyles => d.mleader_styles.retain(|t| !gone(&t.name)),
|
||||
Kind::MlineStyles => d.mline_styles.retain(|t| !gone(&t.name)),
|
||||
Kind::TableStyles => d.table_styles.retain(|t| !gone(&t.name)),
|
||||
Kind::Layers => d.layers.retain(|t| !gone(&t.name)),
|
||||
Kind::Linetypes => d.linetypes.retain(|t| !gone(&t.name)),
|
||||
Kind::TextStyles => d.text_styles.retain(|t| !gone(&t.name)),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
removed
|
||||
}
|
||||
|
||||
/// Add the source's layers, linetypes and styles that this drawing doesn't have (a name that
|
||||
/// exists keeps this drawing's definition).
|
||||
fn merge_tables(d: &mut Drawing, src: &Drawing) {
|
||||
@@ -147,9 +283,42 @@ fn merge_tables(d: &mut Drawing, src: &Drawing) {
|
||||
merge(&mut d.mline_styles, &src.mline_styles, |t| &t.name);
|
||||
}
|
||||
|
||||
/// The names the copied source blocks take, found as `Drawing::block` finds a block: a reference
|
||||
/// may spell a name differently from its definition.
|
||||
struct Renames {
|
||||
exact: BTreeMap<String, String>,
|
||||
upper: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Renames {
|
||||
fn new(exact: BTreeMap<String, String>) -> Self {
|
||||
let mut upper = BTreeMap::new();
|
||||
for (from, to) in &exact {
|
||||
upper.entry(from.to_ascii_uppercase()).or_insert_with(|| to.clone());
|
||||
}
|
||||
Renames { exact, upper }
|
||||
}
|
||||
|
||||
fn get(&self, name: &str) -> Option<&String> {
|
||||
self.exact.get(name).or_else(|| self.upper.get(&name.to_ascii_uppercase()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Point the dimension styles the source brought at their renamed arrowhead blocks. The styles
|
||||
/// this drawing already had (`own`) name this drawing's blocks.
|
||||
fn rename_style_arrows(d: &mut Drawing, own: &BTreeSet<String>, renames: &Renames) {
|
||||
for st in d.dim_styles.iter_mut().filter(|t| !own.contains(&t.name.to_ascii_lowercase())) {
|
||||
for arrow in [&mut st.arrow_block, &mut st.arrow_block1, &mut st.arrow_block2, &mut st.leader_arrow_block] {
|
||||
if let Some(n) = renames.get(arrow.trim()) {
|
||||
arrow.clone_from(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A copy of a source entity for this drawing: a fresh handle, block references renamed, and
|
||||
/// links to other source objects (associative dimension points) dropped.
|
||||
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
|
||||
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &Renames) -> Entity {
|
||||
let mut e = e.clone();
|
||||
let old = e.handle;
|
||||
e.handle = d.new_handle();
|
||||
@@ -174,6 +343,23 @@ fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String,
|
||||
if let Some(n) = dm.block.as_ref().and_then(|b| renames.get(b)) {
|
||||
dm.block = Some(n.clone());
|
||||
}
|
||||
for (key, value) in dm.overrides.iter_mut() {
|
||||
// Only a block that was renamed changes the value: a number naming a block that
|
||||
// kept its name stays as it was given.
|
||||
if is_arrow_override(key)
|
||||
&& let Some(b) = override_name(value)
|
||||
&& let Some(n) = renames.get(&b).filter(|n| **n != b)
|
||||
{
|
||||
*value = json!(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
EntityKind::MLeader(m) => {
|
||||
if let Some(b) = &mut m.block
|
||||
&& let Some(n) = renames.get(&b.block)
|
||||
{
|
||||
b.block = n.clone();
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@@ -234,6 +420,78 @@ mod tests {
|
||||
assert!(file_ref(&s, "BOLT").is_none());
|
||||
}
|
||||
|
||||
/// A block holding very many references still reaches every block it needs.
|
||||
#[test]
|
||||
fn a_block_of_many_references_keeps_all_it_needs() {
|
||||
let reference = |handle: u64, block: &str| {
|
||||
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": block, "insert": [0, 0, 0] })).unwrap();
|
||||
Entity::new(Handle(handle), EntityKind::Insert(insert))
|
||||
};
|
||||
let mut big = Block::new("Big");
|
||||
big.entities.push(reference(0x100, "Deep"));
|
||||
for i in 0..100_001 {
|
||||
big.entities.push(reference(0x200 + i, "Leaf"));
|
||||
}
|
||||
let mut d = Drawing::default();
|
||||
d.blocks.insert("Big".into(), Arc::new(big));
|
||||
d.blocks.insert("Deep".into(), Arc::new(Block::new("Deep")));
|
||||
d.blocks.insert("Leaf".into(), Arc::new(Block::new("Leaf")));
|
||||
assert!(reachable(&d, vec!["Big".into()]).contains("DEEP"));
|
||||
}
|
||||
|
||||
/// A drawing with very many references does not lose the arrowhead of a merged dimension
|
||||
/// style: the arrowheads are the last thing PURGE's walk looks at.
|
||||
#[test]
|
||||
fn many_references_keep_a_merged_arrowhead() {
|
||||
let mut d = Drawing::new_metric();
|
||||
d.blocks.insert("Leaf".into(), Arc::new(Block::new("Leaf")));
|
||||
for i in 0..100_001 {
|
||||
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": "Leaf", "insert": [0, 0, 0] })).unwrap();
|
||||
d.model.push(Entity::new(Handle(0x200 + i), EntityKind::Insert(insert)));
|
||||
}
|
||||
let before = TableNames::of(&d);
|
||||
d.blocks.insert("Tip".into(), Arc::new(Block::new("Tip")));
|
||||
d.dim_styles.push(cadcraft_doc::DimStyle { name: "Late".into(), arrow_block: "Tip".into(), ..Default::default() });
|
||||
d.header.set_str("DIMSTYLE", "Late");
|
||||
d.blocks.insert("Merged".into(), Arc::new(Block::new("Merged")));
|
||||
drop_unused_new(&mut d, &before, "Merged");
|
||||
assert!(d.block("Tip").is_some());
|
||||
}
|
||||
|
||||
/// Past the purge scan's limit nothing is called unused: a merged block's dimension style and
|
||||
/// layer stay even when the scan never reaches its objects.
|
||||
#[test]
|
||||
fn a_drawing_too_big_for_the_scan_keeps_what_was_merged() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
|
||||
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
|
||||
dim.common.layer = "Late".into();
|
||||
if let EntityKind::Dimension(dm) = &mut dim.kind {
|
||||
dm.style = "Late".into();
|
||||
}
|
||||
// One definition under many names: millions of objects for the scan, thousands in memory.
|
||||
let mut filler = Block::new("Filler");
|
||||
for i in 0..10_000 {
|
||||
filler.entities.push(Entity::new(Handle(0x1000 + i), dim.kind.clone()));
|
||||
}
|
||||
let filler = Arc::new(filler);
|
||||
let mut d = Drawing::new_metric();
|
||||
for i in 0..501 {
|
||||
d.blocks.insert(format!("F{i:03}"), filler.clone());
|
||||
}
|
||||
let before = TableNames::of(&d);
|
||||
assert!(!scan_reads_everything(&d));
|
||||
d.layers.push(cadcraft_doc::Layer { name: "Late".into(), ..Default::default() });
|
||||
d.dim_styles.push(cadcraft_doc::DimStyle { name: "Late".into(), ..Default::default() });
|
||||
// Sorted after every filler, so past the limit.
|
||||
let mut merged = Block::new("Z");
|
||||
merged.entities.push(dim);
|
||||
d.blocks.insert("Z".into(), Arc::new(merged));
|
||||
drop_unused_new(&mut d, &before, "Z");
|
||||
assert!(d.layers.iter().any(|l| l.name == "Late"));
|
||||
assert!(d.dim_styles.iter().any(|t| t.name == "Late"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inserted_file_brings_its_mline_styles() {
|
||||
let mut src = Drawing::default();
|
||||
@@ -246,4 +504,211 @@ mod tests {
|
||||
merge_tables(&mut d, &src);
|
||||
assert_eq!(d.mline_styles.len(), before);
|
||||
}
|
||||
|
||||
/// A block reference, for the fixtures below.
|
||||
fn reference(handle: u64, block: &str) -> Entity {
|
||||
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": block, "insert": [0, 0, 0] })).unwrap();
|
||||
Entity::new(Handle(handle), EntityKind::Insert(insert))
|
||||
}
|
||||
|
||||
/// An anonymous block `*U1` that its description tells apart.
|
||||
fn anonymous(description: &str) -> Arc<Block> {
|
||||
let mut b = Block::new("*U1");
|
||||
b.description = description.into();
|
||||
Arc::new(b)
|
||||
}
|
||||
|
||||
/// Takes `model`, whose `*U1` is the file's, into a drawing with a `*U1` of its own, and says
|
||||
/// which of the two the one object of block "Part" refers to.
|
||||
fn colliding_block_after_import(model: Entity) -> String {
|
||||
let mut src = Drawing::new_metric();
|
||||
src.blocks.insert("*U1".into(), anonymous("from the file"));
|
||||
src.model.push(model);
|
||||
let mut s = Session::new();
|
||||
s.doc_mut().unwrap().blocks.insert("*U1".into(), anonymous("from the drawing"));
|
||||
define_from(&mut s, &src, "Part", true).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
let part = d.block("Part").unwrap();
|
||||
let to = part.entities.iter().next().and_then(|e| referenced_block(e)).unwrap();
|
||||
d.block(&to).unwrap().description.clone()
|
||||
}
|
||||
|
||||
/// Block names are case-insensitive, so `*u1` is the file's `*U1` and takes its new name.
|
||||
#[test]
|
||||
fn a_renamed_block_is_found_whatever_the_case_of_the_reference() {
|
||||
assert_eq!(colliding_block_after_import(reference(0x500, "*u1")), "from the file");
|
||||
}
|
||||
|
||||
/// The block content of a multileader takes the new name like any other reference.
|
||||
#[test]
|
||||
fn a_multileader_follows_its_renamed_block() {
|
||||
let EntityKind::Insert(content) = reference(0x500, "*U1").kind else { return };
|
||||
let mut m: cadcraft_doc::MLeader =
|
||||
serde_json::from_value(json!({ "leaders": [], "landing": [0, 0, 0], "dogleg": 0.0, "text": null })).unwrap();
|
||||
m.block = Some(content);
|
||||
assert_eq!(colliding_block_after_import(Entity::new(Handle(0x501), EntityKind::MLeader(m))), "from the file");
|
||||
}
|
||||
|
||||
/// An arrowhead override given as a number names its block: the block comes along, and the
|
||||
/// override is left as given when the block keeps its name.
|
||||
#[test]
|
||||
fn a_numeric_arrowhead_override_brings_its_block() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
|
||||
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
|
||||
if let EntityKind::Dimension(dm) = &mut dim.kind {
|
||||
dm.overrides.insert("DIMBLK1".into(), json!(45));
|
||||
}
|
||||
let mut src = Drawing::new_metric();
|
||||
src.blocks.insert("45".into(), Arc::new(Block::new("45")));
|
||||
src.model.push(dim);
|
||||
let mut t = Session::new();
|
||||
define_from(&mut t, &src, "Part", true).unwrap();
|
||||
let d = t.doc().unwrap();
|
||||
assert!(d.block("45").is_some());
|
||||
let e = d.block("Part").unwrap().entities.iter().next().unwrap().clone();
|
||||
let EntityKind::Dimension(dm) = &e.kind else { panic!("not a dimension") };
|
||||
assert_eq!(dm.overrides["DIMBLK1"], json!(45));
|
||||
}
|
||||
|
||||
/// Arrowheads are references too: a dimension style that came along and a dimension's override
|
||||
/// follow the renamed block, and a style this drawing already had keeps its own.
|
||||
#[test]
|
||||
fn arrowheads_follow_a_renamed_block() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
|
||||
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
|
||||
if let EntityKind::Dimension(dm) = &mut dim.kind {
|
||||
dm.style = "Came".into();
|
||||
dm.overrides.insert("DIMBLK1".into(), json!("*U1"));
|
||||
}
|
||||
let style = |name: &str| cadcraft_doc::DimStyle { name: name.into(), arrow_block: "*U1".into(), ..Default::default() };
|
||||
let mut src = Drawing::new_metric();
|
||||
src.blocks.insert("*U1".into(), anonymous("from the file"));
|
||||
src.dim_styles.extend([style("Came"), style("Own")]);
|
||||
src.model.push(dim);
|
||||
let mut t = Session::new();
|
||||
let d = t.doc_mut().unwrap();
|
||||
d.blocks.insert("*U1".into(), anonymous("from the drawing"));
|
||||
d.dim_styles.push(style("Own"));
|
||||
define_from(&mut t, &src, "Part", true).unwrap();
|
||||
|
||||
let d = t.doc().unwrap();
|
||||
let of = |name: &str| d.block(name).unwrap().description.clone();
|
||||
let arrow = |name: &str| d.dim_styles.iter().find(|st| st.name == name).unwrap().arrow_block.clone();
|
||||
assert_eq!(of(&arrow("Came")), "from the file");
|
||||
assert_eq!(of(&arrow("Own")), "from the drawing");
|
||||
let e = d.block("Part").unwrap().entities.iter().next().unwrap().clone();
|
||||
let EntityKind::Dimension(dm) = &e.kind else { return };
|
||||
assert_eq!(of(dm.overrides["DIMBLK1"].as_str().unwrap()), "from the file");
|
||||
}
|
||||
|
||||
/// What the objects of an imported block name comes along, directly or through another table:
|
||||
/// a leader's dimension style, a dimension's text style override, the text style in a linetype,
|
||||
/// an attribute's layer and multiline text style, here on a block reference and on a
|
||||
/// multileader's block content. What nothing names stays out.
|
||||
#[test]
|
||||
fn an_import_keeps_every_style_and_layer_its_objects_name() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
|
||||
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
|
||||
if let EntityKind::Dimension(dm) = &mut dim.kind {
|
||||
dm.overrides.insert("DIMTXSTY".into(), json!("InOverride"));
|
||||
}
|
||||
let attrib = |style: &str, layer: &str| {
|
||||
let mut a: cadcraft_doc::Attrib = serde_json::from_value(json!({
|
||||
"tag": "A",
|
||||
"text": { "insert": [0, 0, 0], "height": 1.0, "value": "1" },
|
||||
"multiline": { "mtext": { "insert": [0, 0, 0], "height": 1.0, "contents": "1", "style": style }, "readAs": "1" },
|
||||
}))
|
||||
.unwrap();
|
||||
a.props.layer = Some(layer.into());
|
||||
a
|
||||
};
|
||||
let mut placed = reference(0x500, "Inner");
|
||||
if let EntityKind::Insert(i) = &mut placed.kind {
|
||||
i.attribs.push(attrib("InAttribute", "OnAttribute"));
|
||||
}
|
||||
let EntityKind::Insert(mut content) = reference(0x501, "Inner").kind else { return };
|
||||
content.attribs.push(attrib("InContent", "OnContent"));
|
||||
let mut multileader: cadcraft_doc::MLeader =
|
||||
serde_json::from_value(json!({ "leaders": [], "landing": [0, 0, 0], "dogleg": 0.0, "text": null })).unwrap();
|
||||
multileader.block = Some(content);
|
||||
let leader: cadcraft_doc::Leader = serde_json::from_value(json!({ "vertices": [], "style": "ForLeader" })).unwrap();
|
||||
let line = cadcraft_doc::Line { a: cadcraft_geom::Vec3::ZERO, b: cadcraft_geom::Vec3::new(1.0, 0.0, 0.0) };
|
||||
let mut line = Entity::new(Handle(0x502), EntityKind::Line(line));
|
||||
line.common.linetype = "WithText".into();
|
||||
|
||||
let mut src = Drawing::new_metric();
|
||||
src.blocks.insert("Inner".into(), Arc::new(Block::new("Inner")));
|
||||
for name in ["InOverride", "InAttribute", "InContent", "InLinetype", "Spare"] {
|
||||
let mut t = src.text_styles[0].clone();
|
||||
t.name = name.into();
|
||||
src.text_styles.push(t);
|
||||
}
|
||||
for name in ["OnAttribute", "OnContent", "Unused"] {
|
||||
src.layers.push(cadcraft_doc::Layer { name: name.into(), ..Default::default() });
|
||||
}
|
||||
let dash = cadcraft_doc::DashElement { style: Some("InLinetype".into()), ..cadcraft_doc::DashElement::dash(1.0) };
|
||||
src.linetypes.push(cadcraft_doc::Linetype { name: "WithText".into(), description: String::new(), pattern: vec![dash] });
|
||||
src.dim_styles.push(cadcraft_doc::DimStyle { name: "ForLeader".into(), ..Default::default() });
|
||||
src.model.push(dim);
|
||||
src.model.push(placed);
|
||||
src.model.push(Entity::new(Handle(0x503), EntityKind::MLeader(multileader)));
|
||||
src.model.push(Entity::new(Handle(0x504), EntityKind::Leader(leader)));
|
||||
src.model.push(line);
|
||||
let mut t = Session::new();
|
||||
define_from(&mut t, &src, "Part", true).unwrap();
|
||||
|
||||
let d = t.doc().unwrap();
|
||||
let styles: Vec<&str> = d.text_styles.iter().map(|t| t.name.as_str()).collect();
|
||||
for name in ["InOverride", "InAttribute", "InContent", "InLinetype"] {
|
||||
assert!(styles.contains(&name), "{name}: {styles:?}");
|
||||
}
|
||||
assert!(!styles.contains(&"Spare"), "{styles:?}");
|
||||
let layers: Vec<&str> = d.layers.iter().map(|l| l.name.as_str()).collect();
|
||||
assert!(layers.contains(&"OnAttribute") && layers.contains(&"OnContent"), "{layers:?}");
|
||||
assert!(!layers.contains(&"Unused"), "{layers:?}");
|
||||
assert!(d.dim_styles.iter().any(|st| st.name == "ForLeader"));
|
||||
}
|
||||
|
||||
/// The text style of a table style's cell style is in use.
|
||||
#[test]
|
||||
fn a_table_style_keeps_its_cell_styles_text_style() {
|
||||
let mut d = Drawing::new_metric();
|
||||
let mut t = d.text_styles[0].clone();
|
||||
t.name = "InCell".into();
|
||||
d.text_styles.push(t);
|
||||
let mut cell = cadcraft_doc::TableStyle::default().cell_style("Data");
|
||||
cell.text_style = "InCell".into();
|
||||
d.table_styles[0].cell_styles.push(cell);
|
||||
assert!(!candidates(&d, Kind::TextStyles).iter().any(|n| n == "InCell"));
|
||||
}
|
||||
|
||||
/// A linetype of the file stays when a dimension style that came along names it, and stays out
|
||||
/// when only a style that did not come along does.
|
||||
#[test]
|
||||
fn a_linetype_follows_the_dimension_style_that_names_it() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
|
||||
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
|
||||
if let EntityKind::Dimension(dm) = &mut dim.kind {
|
||||
dm.style = "Used".into();
|
||||
}
|
||||
let mut src = Drawing::new_metric();
|
||||
for name in ["Kept", "Left"] {
|
||||
let mut lt = src.linetypes[0].clone();
|
||||
lt.name = name.into();
|
||||
src.linetypes.push(lt);
|
||||
}
|
||||
src.dim_styles.push(cadcraft_doc::DimStyle { name: "Used".into(), dim_linetype: "Kept".into(), ..Default::default() });
|
||||
src.dim_styles.push(cadcraft_doc::DimStyle { name: "Spare".into(), ext_linetype1: "Left".into(), ..Default::default() });
|
||||
src.model.push(dim);
|
||||
let mut t = Session::new();
|
||||
define_from(&mut t, &src, "Part", true).unwrap();
|
||||
let d = t.doc().unwrap();
|
||||
assert!(d.linetypes.iter().any(|l| l.name == "Kept"));
|
||||
assert!(!d.dim_styles.iter().any(|st| st.name == "Spare"));
|
||||
assert!(!d.linetypes.iter().any(|l| l.name == "Left"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,378 @@
|
||||
//! Block libraries for the Blocks palette: a folder of drawings or a single drawing file whose
|
||||
//! blocks can be placed in the current drawing.
|
||||
//!
|
||||
//! BLOCKLIBRARY lists what a library holds, BLOCKLIBRARIES keeps the list of libraries the user
|
||||
//! added (in the settings folder; in memory where there is none), and BLOCKLIBIMPORT defines a
|
||||
//! library block in the current drawing so that INSERT can place it. Files are read through the
|
||||
//! host's io hooks like OPEN, so the engine stays I/O-agnostic.
|
||||
|
||||
use std::path::Path;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::SystemTime;
|
||||
|
||||
use cadcraft_doc::Drawing;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::insert_file::{define_from, read_drawing, stem};
|
||||
use super::valid_block_name;
|
||||
use crate::cmd::{CommandSpec, always, bad, has_doc, str_param};
|
||||
use crate::{Result, Session};
|
||||
|
||||
/// Most drawings one folder library lists.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const MAX_FILES: usize = 2000;
|
||||
/// Most directory entries looked at in a folder library.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const MAX_SCANNED: usize = 100_000;
|
||||
/// Most blocks a palette listing holds: the rest of a hostile file's table is left out.
|
||||
const MAX_LISTED: usize = 10_000;
|
||||
/// Most libraries the list keeps.
|
||||
const MAX_LIBRARIES: usize = 64;
|
||||
/// The longest library path kept.
|
||||
const MAX_PATH_BYTES: usize = 4096;
|
||||
/// The file in the settings folder that keeps the library list, and its largest size.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const LIST_FILE: &str = "block-libraries.json";
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const MAX_LIST_BYTES: usize = 256 << 10;
|
||||
|
||||
/// How many parsed library drawings stay in memory.
|
||||
const CACHE_MAX: usize = 4;
|
||||
|
||||
/// A library drawing already read, and the file's size and time then.
|
||||
struct Cached {
|
||||
path: String,
|
||||
stamp: (u64, Option<SystemTime>),
|
||||
drawing: Arc<Drawing>,
|
||||
}
|
||||
|
||||
static CACHE: Mutex<Vec<Cached>> = Mutex::new(Vec::new());
|
||||
|
||||
/// Forget the library drawings read so far: the next read parses each file again, even one whose
|
||||
/// size and time did not change (Refresh in the palette).
|
||||
pub fn clear_library_cache() {
|
||||
if let Ok(mut cache) = CACHE.lock() {
|
||||
cache.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// The file's size and modification time; `None` where it cannot be told (nothing is kept then).
|
||||
fn stamp(path: &str) -> Option<(u64, Option<SystemTime>)> {
|
||||
if cfg!(target_arch = "wasm32") {
|
||||
return None;
|
||||
}
|
||||
std::fs::metadata(path).ok().filter(std::fs::Metadata::is_file).map(|m| (m.len(), m.modified().ok()))
|
||||
}
|
||||
|
||||
/// A library drawing, read once and kept while the file is as it was: placing a block must not
|
||||
/// parse the whole file again.
|
||||
fn cached_drawing(path: &str) -> Result<Arc<Drawing>> {
|
||||
// The reader sniffs the bytes, so a DXF named `part.bin` would load: the contract is DWG/DXF by name.
|
||||
if !is_drawing(Path::new(path)) {
|
||||
return Err(bad("blocklibrary", format!("{path}: expected a DWG or DXF file")));
|
||||
}
|
||||
let now = stamp(path);
|
||||
if let Some(now) = now
|
||||
&& let Ok(cache) = CACHE.lock()
|
||||
&& let Some(hit) = cache.iter().find(|c| c.path == path && c.stamp == now)
|
||||
{
|
||||
return Ok(hit.drawing.clone());
|
||||
}
|
||||
// The palette reads previews outside a command, so a parser panic stops here too.
|
||||
let read = std::panic::catch_unwind(|| read_drawing(path));
|
||||
let drawing = Arc::new(read.unwrap_or_else(|p| Err(bad("blocklibrary", format!("{path}: {}", crate::guard::message(p.as_ref())))))?);
|
||||
if let Some(now) = now
|
||||
&& let Ok(mut cache) = CACHE.lock()
|
||||
{
|
||||
cache.retain(|c| c.path != path);
|
||||
cache.push(Cached { path: path.to_string(), stamp: now, drawing: drawing.clone() });
|
||||
while cache.len() > CACHE_MAX {
|
||||
cache.remove(0);
|
||||
}
|
||||
}
|
||||
Ok(drawing)
|
||||
}
|
||||
|
||||
/// The list where no settings folder keeps it, and the copy read from it.
|
||||
static MEMORY: Mutex<Vec<String>> = Mutex::new(Vec::new());
|
||||
/// The last write of the list failed: the copy in memory is newer than the file.
|
||||
static UNSAVED: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
/// The commands the Blocks palette uses: BLOCKLIBRARY, BLOCKLIBIMPORT and BLOCKLIBRARIES.
|
||||
pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("blocklibrary", "Block Library", run_library)
|
||||
.params("{path: a folder of DWG/DXF files, or one such file} → {kind: \"folder\", path, files: [{name, file}], truncated} | {kind: \"file\", path, blocks: [{name, description}], truncated}")
|
||||
.enabled(always)
|
||||
.noundo(),
|
||||
CommandSpec::new("blocklibraries", "Block Libraries", run_libraries)
|
||||
.params("{op?: \"list\" (default)|\"add\"|\"remove\", path? (add, remove)} → {libraries: [path], path? (add: the entry as kept)}")
|
||||
.enabled(always)
|
||||
.noundo(),
|
||||
CommandSpec::new("blocklibimport", "Import Library Block", run_import)
|
||||
.params("{path: DWG/DXF file, block?: the block to take from it (default: the whole drawing), name?: the block to define (default: `block`, else the file name; never one the drawing already has)} → {name}")
|
||||
.enabled(has_doc),
|
||||
]
|
||||
}
|
||||
|
||||
/// A drawing file by its extension.
|
||||
fn is_drawing(p: &Path) -> bool {
|
||||
p.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("dwg") || e.eq_ignore_ascii_case("dxf"))
|
||||
}
|
||||
|
||||
/// The drawings in a folder, by name: `(block name, full path)`, and whether some were left out.
|
||||
fn folder_files(dir: &Path) -> Result<(Vec<(String, String)>, bool)> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
let rd = std::fs::read_dir(dir).map_err(|e| bad("blocklibrary", format!("{}: {e}", dir.display())))?;
|
||||
let entries: Vec<PathBuf> = rd.filter_map(|e| e.ok()).map(|e| e.path()).take(MAX_SCANNED.saturating_add(1)).collect();
|
||||
let mut truncated = entries.len() > MAX_SCANNED;
|
||||
let mut out: Vec<(String, String)> = entries
|
||||
.iter()
|
||||
.take(MAX_SCANNED)
|
||||
.filter(|p| is_drawing(p) && p.is_file())
|
||||
.filter_map(|p| p.to_str().map(|s| (stem(s), s.to_string())))
|
||||
.collect();
|
||||
out.sort_by_key(|(n, _)| n.to_ascii_lowercase());
|
||||
truncated |= out.len() > MAX_FILES;
|
||||
out.truncate(MAX_FILES);
|
||||
Ok((out, truncated))
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
{
|
||||
let _ = dir;
|
||||
Err(bad("blocklibrary", "paths are not available on the web"))
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether two library paths name the same place: letter case counts except where the file
|
||||
/// system ignores it (Windows, and macOS by default).
|
||||
fn same_path(a: &str, b: &str) -> bool {
|
||||
if cfg!(any(windows, target_os = "macos")) { a.eq_ignore_ascii_case(b) } else { a == b }
|
||||
}
|
||||
|
||||
/// Whether `path` is a folder.
|
||||
fn is_folder(path: &str) -> bool {
|
||||
!cfg!(target_arch = "wasm32") && Path::new(path).is_dir()
|
||||
}
|
||||
|
||||
/// The first `MAX_LISTED` named blocks of a library drawing by name (no generated or layout
|
||||
/// blocks, no xrefs), and whether there were more. The names are made lower case once, and only
|
||||
/// the blocks that are kept are sorted.
|
||||
pub(crate) fn library_blocks(d: &Drawing) -> (Vec<&std::sync::Arc<cadcraft_doc::Block>>, bool) {
|
||||
let mut keyed: Vec<(String, &std::sync::Arc<cadcraft_doc::Block>)> = d
|
||||
.blocks
|
||||
.values()
|
||||
.filter(|b| !b.anonymous && b.xref_path.is_none() && !b.name.starts_with('*') && !b.name.contains('|'))
|
||||
.map(|b| (b.name.to_ascii_lowercase(), b))
|
||||
.collect();
|
||||
let truncated = keyed.len() > MAX_LISTED;
|
||||
if truncated {
|
||||
keyed.select_nth_unstable_by(MAX_LISTED, |a, b| a.0.cmp(&b.0));
|
||||
keyed.truncate(MAX_LISTED);
|
||||
}
|
||||
keyed.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
(keyed.into_iter().map(|(_, b)| b).collect(), truncated)
|
||||
}
|
||||
|
||||
/// Read a library file (for the palette's previews too), kept until the file changes.
|
||||
pub fn read_library_file(path: &str) -> Result<Arc<Drawing>> {
|
||||
cached_drawing(path)
|
||||
}
|
||||
|
||||
/// What BLOCKLIBRARY answers for `path`. It needs no session, so the palette reads big drawings
|
||||
/// and slow folders on a worker thread.
|
||||
pub fn list_library(path: &str) -> Result<Value> {
|
||||
if is_folder(path) {
|
||||
let (files, truncated) = folder_files(Path::new(path))?;
|
||||
let list: Vec<Value> = files.iter().map(|(name, file)| json!({ "name": name, "file": file })).collect();
|
||||
return Ok(json!({ "kind": "folder", "path": path, "files": list, "truncated": truncated }));
|
||||
}
|
||||
let d = cached_drawing(path)?;
|
||||
let (blocks, truncated) = library_blocks(&d);
|
||||
let list: Vec<Value> = blocks.iter().map(|b| json!({ "name": b.name, "description": b.description })).collect();
|
||||
Ok(json!({ "kind": "file", "path": path, "blocks": list, "truncated": truncated }))
|
||||
}
|
||||
|
||||
/// BLOCKLIBRARY: list a folder's drawings or a drawing's blocks.
|
||||
fn run_library(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = str_param(p, "path").map(str::trim).filter(|s| !s.is_empty()).ok_or_else(|| bad("blocklibrary", "`path` is required"))?;
|
||||
list_library(path)
|
||||
}
|
||||
|
||||
/// BLOCKLIBIMPORT: define a library block (or a whole drawing) in the current drawing, under a
|
||||
/// name it does not have yet.
|
||||
fn run_import(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = str_param(p, "path").map(str::trim).filter(|s| !s.is_empty()).ok_or_else(|| bad("blocklibimport", "`path` is required"))?;
|
||||
let block = str_param(p, "block").map(str::trim).filter(|s| !s.is_empty());
|
||||
// A whole drawing is named after its file; a block of it after itself.
|
||||
let name = str_param(p, "name")
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_string)
|
||||
.unwrap_or_else(|| block.map_or_else(|| stem(path), str::to_string));
|
||||
if !valid_block_name(&name) {
|
||||
return Err(bad("blocklibimport", format!("\"{name}\" is not a valid block name")));
|
||||
}
|
||||
// A block the drawing already has is never replaced, as in the palette: its references
|
||||
// would change with it.
|
||||
if s.doc()?.block(&name).is_some() {
|
||||
return Err(bad("blocklibimport", format!("block \"{name}\" is already in the drawing")));
|
||||
}
|
||||
let mut src = (*cached_drawing(path)?).clone();
|
||||
let mut picked = None;
|
||||
if let Some(block) = block {
|
||||
let b = src.block(block).cloned().ok_or_else(|| bad("blocklibimport", format!("{path} has no block \"{block}\"")))?;
|
||||
// The block is a drawing of its own: its objects as model space and its base point as
|
||||
// $INSBASE, with the file's other blocks around it.
|
||||
src.model = b.entities.clone();
|
||||
src.header.set("INSBASE", cadcraft_doc::HVal::Point(b.base));
|
||||
picked = Some(b);
|
||||
}
|
||||
// Only the layers, linetypes and styles the block needs come along, not the whole file's.
|
||||
let name = define_from(s, &src, &name, true)?;
|
||||
// The definition is a new one: what the block says about itself still comes along.
|
||||
if let Some(from) = picked
|
||||
&& let Some(b) = s.doc_mut()?.blocks.get_mut(&name)
|
||||
{
|
||||
let b = Arc::make_mut(b);
|
||||
b.annotative = from.annotative;
|
||||
b.description.clone_from(&from.description);
|
||||
b.units = from.units;
|
||||
b.explodable = from.explodable;
|
||||
}
|
||||
Ok(json!({ "name": name }))
|
||||
}
|
||||
|
||||
/// Where the library list is kept.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn list_path() -> Option<PathBuf> {
|
||||
crate::settings_dir::current().map(|d| d.join(LIST_FILE))
|
||||
}
|
||||
|
||||
/// A path the list can hold: short enough, with no control characters.
|
||||
fn acceptable(path: &str) -> bool {
|
||||
!path.is_empty() && path.len() <= MAX_PATH_BYTES && !path.chars().any(char::is_control)
|
||||
}
|
||||
|
||||
/// The list in the settings folder. The file is hand-editable, so what it holds is checked here.
|
||||
/// `Ok(None)`: no settings folder or no file yet. `Err`: a file that is there but unreadable.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn read_list() -> std::result::Result<Option<Vec<String>>, String> {
|
||||
let Some(path) = list_path() else { return Ok(None) };
|
||||
if !path.exists() {
|
||||
return Ok(None);
|
||||
}
|
||||
let bytes = crate::capped_read::read_capped(&path, MAX_LIST_BYTES).map_err(|e| format!("{}: {e}", path.display()))?;
|
||||
let list: Vec<String> = serde_json::from_slice(&bytes).map_err(|e| format!("{}: {e}", path.display()))?;
|
||||
Ok(Some(list.into_iter().filter(|p| acceptable(p)).take(MAX_LIBRARIES).collect()))
|
||||
}
|
||||
|
||||
/// On the web there is no settings folder: the list lives in memory only.
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn read_list() -> std::result::Result<Option<Vec<String>>, String> {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// The list, and why the file could not be read when it exists but is unreadable. Such a file is
|
||||
/// never written over: `run_libraries` refuses to change the list while it stays unreadable.
|
||||
fn load_list() -> (Vec<String>, Option<String>) {
|
||||
let memory = || MEMORY.lock().map(|m| m.clone()).unwrap_or_default();
|
||||
if UNSAVED.load(Ordering::Relaxed) {
|
||||
return (memory(), None);
|
||||
}
|
||||
match read_list() {
|
||||
Ok(Some(list)) => (list, None),
|
||||
Ok(None) => (memory(), None),
|
||||
Err(why) => (memory(), Some(why)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Write the list to `path`, its folder made if needed. `false` when it could not be written.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn write_list(path: &Path, list: &[String]) -> bool {
|
||||
let Ok(bytes) = serde_json::to_vec_pretty(list) else { return false };
|
||||
if let Some(dir) = path.parent() {
|
||||
let _ = std::fs::create_dir_all(dir);
|
||||
}
|
||||
crate::atomic_write::write_atomic(path, &bytes).is_ok()
|
||||
}
|
||||
|
||||
/// Keep the list in memory and write it to the settings folder.
|
||||
fn save_list(list: &[String]) {
|
||||
if let Ok(mut m) = MEMORY.lock() {
|
||||
*m = list.to_vec();
|
||||
}
|
||||
// A list that cannot be written is still kept for this session.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(p) = list_path() {
|
||||
UNSAVED.store(!write_list(&p, list), Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
/// BLOCKLIBRARIES: list, add to or remove from the libraries.
|
||||
fn run_libraries(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let (mut list, unreadable) = load_list();
|
||||
let op = str_param(p, "op").unwrap_or("list");
|
||||
if let (Some(why), "add" | "remove") = (&unreadable, op) {
|
||||
return Err(bad("blocklibraries", format!("the library list cannot be read, so it is left as it is ({why})")));
|
||||
}
|
||||
let path = str_param(p, "path").map(str::trim).filter(|s| !s.is_empty());
|
||||
match op {
|
||||
"list" => {}
|
||||
"add" => {
|
||||
let path = path.ok_or_else(|| bad("blocklibraries", "`path` is required"))?;
|
||||
let drawing = is_drawing(Path::new(path)) && Path::new(path).is_file();
|
||||
if !acceptable(path) || !(is_folder(path) || drawing) {
|
||||
return Err(bad("blocklibraries", "a library is a folder or a DWG/DXF file"));
|
||||
}
|
||||
let stored = match list.iter().find(|l| same_path(l, path)) {
|
||||
Some(l) => l.clone(),
|
||||
None => {
|
||||
if list.len() >= MAX_LIBRARIES {
|
||||
return Err(bad("blocklibraries", format!("at most {MAX_LIBRARIES} libraries")));
|
||||
}
|
||||
list.push(path.to_string());
|
||||
path.to_string()
|
||||
}
|
||||
};
|
||||
save_list(&list);
|
||||
return Ok(json!({ "libraries": list, "path": stored }));
|
||||
}
|
||||
"remove" => {
|
||||
let path = path.ok_or_else(|| bad("blocklibraries", "`path` is required"))?;
|
||||
list.retain(|l| !same_path(l, path));
|
||||
save_list(&list);
|
||||
}
|
||||
other => return Err(bad("blocklibraries", format!("unknown op \"{other}\""))),
|
||||
}
|
||||
Ok(json!({ "libraries": list }))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A list that could not be written stays the list of this session, whatever the file says.
|
||||
#[test]
|
||||
fn a_failed_write_keeps_the_list_in_memory() {
|
||||
let dir = std::env::temp_dir().join(format!("cadcraft-library-list-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let blocker = dir.join("a-file");
|
||||
std::fs::write(&blocker, b"x").unwrap();
|
||||
let list = vec!["C:/kept".to_string()];
|
||||
// A folder that is a file: neither the folder nor the list can be made.
|
||||
assert!(!write_list(&blocker.join("block-libraries.json"), &list));
|
||||
assert!(write_list(&dir.join("block-libraries.json"), &list));
|
||||
|
||||
*MEMORY.lock().unwrap() = list.clone();
|
||||
UNSAVED.store(true, Ordering::Relaxed);
|
||||
assert_eq!(load_list().0, list);
|
||||
UNSAVED.store(false, Ordering::Relaxed);
|
||||
MEMORY.lock().unwrap().clear();
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -114,17 +114,40 @@ fn json_key(kind: Kind) -> &'static str {
|
||||
}
|
||||
}
|
||||
|
||||
/// Most objects PURGE's scan reads, as the scan of used layers does.
|
||||
const MAX_SCAN: usize = 5_000_000;
|
||||
|
||||
fn all_entities(d: &Drawing) -> impl Iterator<Item = &std::sync::Arc<cadcraft_doc::Entity>> {
|
||||
d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).chain(d.blocks.values().flat_map(|b| b.entities.iter()))
|
||||
}
|
||||
|
||||
fn entities(d: &Drawing) -> impl Iterator<Item = &std::sync::Arc<cadcraft_doc::Entity>> {
|
||||
d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).chain(d.blocks.values().flat_map(|b| b.entities.iter())).take(5_000_000)
|
||||
all_entities(d).take(MAX_SCAN)
|
||||
}
|
||||
|
||||
/// Whether the scan reads the whole drawing: past its limit, what is in use can look unused.
|
||||
pub(in crate::cmd) fn scan_reads_everything(d: &Drawing) -> bool {
|
||||
all_entities(d).nth(MAX_SCAN).is_none()
|
||||
}
|
||||
|
||||
/// Whether a dimension override sets an arrowhead block.
|
||||
pub(in crate::cmd) fn is_arrow_override(key: &str) -> bool {
|
||||
cadcraft_doc::DimStyle::field_name(key).is_some_and(|f| f.starts_with("arrowBlock") || f == "leaderArrowBlock")
|
||||
}
|
||||
|
||||
/// The name a dimension override gives a style, linetype or arrowhead block. A number names one
|
||||
/// too: DIMOVERRIDE keeps it as given, and the dimension is drawn with it as text.
|
||||
pub(in crate::cmd) fn override_name(v: &Value) -> Option<String> {
|
||||
match v {
|
||||
Value::String(n) => Some(n.trim().to_string()),
|
||||
Value::Number(n) => Some(n.to_string()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The arrowhead block names a dimension's overrides set.
|
||||
pub(in crate::cmd) fn override_arrows(dm: &cadcraft_doc::Dimension) -> impl Iterator<Item = String> + '_ {
|
||||
dm.overrides
|
||||
.iter()
|
||||
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k).is_some_and(|f| f.starts_with("arrowBlock") || f == "leaderArrowBlock"))
|
||||
.filter_map(|(_, v)| v.as_str().map(|n| n.trim().to_string()))
|
||||
.filter(|n| !n.is_empty())
|
||||
dm.overrides.iter().filter(|(k, _)| is_arrow_override(k)).filter_map(|(_, v)| override_name(v)).filter(|n| !n.is_empty())
|
||||
}
|
||||
|
||||
/// Upper-case names of blocks reachable from model space, the layouts and dimensions, and the
|
||||
@@ -151,10 +174,9 @@ pub(in crate::cmd) fn used_blocks(d: &Drawing) -> HashSet<String> {
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let mut guard = 0;
|
||||
// Each block is walked once, so this ends, cycles included.
|
||||
while let Some(n) = frontier.pop() {
|
||||
guard += 1;
|
||||
if guard > 100_000 || !used.insert(n.to_ascii_uppercase()) {
|
||||
if !used.insert(n.to_ascii_uppercase()) {
|
||||
continue;
|
||||
}
|
||||
if let Some(b) = d.block(&n) {
|
||||
@@ -178,6 +200,33 @@ fn is(name: &str, list: &[&str]) -> bool {
|
||||
list.iter().any(|n| n.eq_ignore_ascii_case(name))
|
||||
}
|
||||
|
||||
/// The linetypes an object names besides its own: its attributes' overrides, its dimension
|
||||
/// overrides, and the copy of its style a multiline keeps.
|
||||
fn linetypes_inside(e: &cadcraft_doc::Entity) -> Vec<String> {
|
||||
let mut out: Vec<String> = super::object_attribs(e).iter().filter_map(|a| a.props.linetype.clone()).collect();
|
||||
match &e.kind {
|
||||
EntityKind::Dimension(dm) => out.extend(
|
||||
dm.overrides
|
||||
.iter()
|
||||
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k).is_some_and(|f| matches!(f, "dimLinetype" | "extLinetype1" | "extLinetype2")))
|
||||
.filter_map(|(_, v)| override_name(v)),
|
||||
),
|
||||
EntityKind::MLine(m) => out.extend(m.def.elements.iter().map(|e| e.linetype.clone())),
|
||||
_ => {}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The linetypes named by objects, layers, dimension styles and multiline styles.
|
||||
fn linetypes_in_use(d: &Drawing) -> impl Iterator<Item = String> + '_ {
|
||||
let objects = entities(d).map(|e| e.common.linetype.clone());
|
||||
let inside = entities(d).flat_map(|e| linetypes_inside(e));
|
||||
let layers = d.layers.iter().map(|l| l.linetype.clone());
|
||||
let dims = d.dim_styles.iter().flat_map(|t| [t.dim_linetype.clone(), t.ext_linetype1.clone(), t.ext_linetype2.clone()]);
|
||||
let mlines = d.mline_styles.iter().flat_map(|t| t.elements.iter().map(|e| e.linetype.clone()));
|
||||
objects.chain(inside).chain(layers).chain(dims).chain(mlines)
|
||||
}
|
||||
|
||||
/// Names of the unused objects of a named kind, in table order. This is PURGE's scan; `USAGE`
|
||||
/// reads it too, without purging anything.
|
||||
pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
|
||||
@@ -197,21 +246,7 @@ pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
|
||||
.collect()
|
||||
}
|
||||
Kind::Linetypes => {
|
||||
// Objects and layers use linetypes, and so do dimension styles and a dimension's own
|
||||
// overrides (DIMLTYPE, DIMLTEX1, DIMLTEX2), and multiline styles' elements.
|
||||
let styles = d.dim_styles.iter().flat_map(|s| [s.dim_linetype.clone(), s.ext_linetype1.clone(), s.ext_linetype2.clone()]);
|
||||
let overrides = entities(d).filter_map(|e| if let EntityKind::Dimension(dm) = &e.kind { Some(dm) } else { None }).flat_map(|dm| {
|
||||
["dimLinetype", "extLinetype1", "extLinetype2"].into_iter().filter_map(|k| dm.overrides.get(k)?.as_str().map(str::to_string))
|
||||
});
|
||||
let mlines = d.mline_styles.iter().flat_map(|s| s.elements.iter().map(|el| el.linetype.clone()));
|
||||
let used = lower(
|
||||
&mut entities(d)
|
||||
.map(|e| e.common.linetype.clone())
|
||||
.chain(d.layers.iter().map(|l| l.linetype.clone()))
|
||||
.chain(styles)
|
||||
.chain(overrides)
|
||||
.chain(mlines),
|
||||
);
|
||||
let used = lower(&mut linetypes_in_use(d));
|
||||
let cur = d.header.str("CELTYPE", "ByLayer");
|
||||
d.linetypes
|
||||
.iter()
|
||||
|
||||
@@ -0,0 +1,509 @@
|
||||
//! -DIMSTYLE, dimension styles at the command line (scripts, the keyboard): save the current
|
||||
//! settings as a style (annotative or not), make a style current, list the current settings or
|
||||
//! a style's or a dimension's, compare a style with the current one, give the current settings
|
||||
//! to dimensions, list the styles. Also `dimstyle.overrides`, which sets the current style's
|
||||
//! overrides (what the Dimension Style Manager's Override edits), in one undo step.
|
||||
|
||||
use cadcraft_doc::{DimStyle, Drawing, EntityKind, Handle};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::machines::{SelOutcome, SelectPhase};
|
||||
use super::{CommandSpec, bad, bool_or, curves, str_param, targets};
|
||||
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
const CMD: &str = "-dimstyle";
|
||||
|
||||
fn other(m: impl Into<String>) -> EngineError {
|
||||
EngineError::Other(m.into())
|
||||
}
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("-dimstyle", "Dimension Style", run)
|
||||
.params(
|
||||
"{option: save | annotative | restore | status | variables | apply | list, name?, handle?, handles?, replace?: bool, pattern?} \
|
||||
→ save (annotative: an annotative style): the current settings (style and its overrides) as style `name`, made current \
|
||||
(`replace` redefines one); restore: style `name` (or dimension `handle`'s style) made current; status: {variables} of the \
|
||||
current settings; variables: {variables} of style `name` or dimension `handle`; apply: the current settings given to \
|
||||
`handles` (default: the selection); list: {styles} matching `pattern` (*, ? and #)",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(DashDimStyle::default()))),
|
||||
CommandSpec::new("dimstyle.overrides", "Dimension Style Overrides", run_overrides).params(
|
||||
"{<style fields or DIM* variables: values>, clear?: bool} → {overrides} (the current style's overrides, which new \
|
||||
dimensions take; `clear` drops them all first)",
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
/// What new dimensions are drawn with: the current style with its overrides.
|
||||
fn current_settings(d: &Drawing) -> DimStyle {
|
||||
let name = d.header.str("DIMSTYLE", "Standard");
|
||||
let mut st = d.dim_style(&name).cloned().unwrap_or_default().with_overrides(&d.dim_overrides());
|
||||
st.name = name;
|
||||
st
|
||||
}
|
||||
|
||||
/// A style's variables (DIM* name → value) as `dimstyle.list` reports them.
|
||||
fn variables(st: &DimStyle) -> serde_json::Map<String, Value> {
|
||||
let v = serde_json::to_value(st).unwrap_or(Value::Null);
|
||||
cadcraft_doc::DIMVARS.iter().filter_map(|(var, field)| v.get(*field).map(|x| ((*var).to_string(), x.clone()))).collect()
|
||||
}
|
||||
|
||||
/// A variable's value as the command line shows it.
|
||||
fn shown(v: &Value) -> String {
|
||||
if v.is_object()
|
||||
&& let Ok(c) = serde_json::from_value::<cadcraft_color::Color>(v.clone())
|
||||
{
|
||||
return c.name();
|
||||
}
|
||||
match v {
|
||||
Value::String(s) if s.is_empty() => "\"\"".into(),
|
||||
Value::String(s) => s.clone(),
|
||||
Value::Bool(b) => (if *b { "On" } else { "Off" }).into(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// One line per variable: name, value and what it is.
|
||||
fn listing(vars: &serde_json::Map<String, Value>) -> Vec<String> {
|
||||
cadcraft_doc::DIMVARS
|
||||
.iter()
|
||||
.filter_map(|(var, field)| {
|
||||
let v = vars.get(*var)?;
|
||||
let label = crate::properties::dim_prop(field).map_or(*field, |p| p.label);
|
||||
Some(format!("{var:<10} {:<20} {label}", shown(v)))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The variables of `b` that differ from `a`'s: (name, a's value, b's value).
|
||||
fn differences(a: &DimStyle, b: &DimStyle) -> Vec<(String, Value, Value)> {
|
||||
let (va, vb) = (variables(a), variables(b));
|
||||
cadcraft_doc::DIMVARS
|
||||
.iter()
|
||||
.filter_map(|(var, _)| {
|
||||
let (x, y) = (va.get(*var)?, vb.get(*var)?);
|
||||
(x != y).then(|| ((*var).to_string(), x.clone(), y.clone()))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `name` against a pattern with `*` (any run), `?` (any character) and `#` (a digit), ignoring
|
||||
/// case: QSELECT's matcher, which takes time in proportion to the lengths (a pattern that backs
|
||||
/// up at every `*` can't hang the command).
|
||||
fn matches(pattern: &str, name: &str) -> bool {
|
||||
let p = pattern.trim();
|
||||
p.is_empty() || super::qselect::wildcard(p, name)
|
||||
}
|
||||
|
||||
fn styles_matching(d: &Drawing, pattern: &str) -> Vec<String> {
|
||||
d.dim_styles.iter().filter(|s| matches(pattern, &s.name)).map(|s| s.name.clone()).collect()
|
||||
}
|
||||
|
||||
/// A usable dimension style name, trimmed: for -DIMSTYLE and `dimstyle.saveas` alike. No `~`,
|
||||
/// which Restore reads as "compare with".
|
||||
pub(super) fn check_name(name: &str) -> Result<String> {
|
||||
let name = name.trim();
|
||||
if !usable_dim_style_name(name) {
|
||||
return Err(bad(CMD, "bad style name"));
|
||||
}
|
||||
Ok(name.to_string())
|
||||
}
|
||||
|
||||
/// Whether `name` (trimmed) is one a new dimension style can have: what -DIMSTYLE,
|
||||
/// `dimstyle.saveas`, `dimstyle` and `dimstyle.rename` take, for dialogs to check before OK.
|
||||
pub fn usable_dim_style_name(name: &str) -> bool {
|
||||
let name = name.trim();
|
||||
!(name.is_empty() || name.len() > 255 || name.contains(['<', '>', '/', '\\', '"', ':', ';', '?', '*', '|', ',', '=', '`', '~']))
|
||||
}
|
||||
|
||||
/// Save the current settings as style `name` and make it current.
|
||||
fn save(s: &mut Session, name: &str, annotative: Option<bool>, replace: bool) -> Result<Value> {
|
||||
let name = check_name(name)?;
|
||||
// Refused before the drawing is touched: a failed call leaves no (empty) undo step.
|
||||
if !replace && s.doc()?.dim_style(&name).is_some() {
|
||||
return Err(bad(CMD, format!("a dimension style `{name}` already exists")));
|
||||
}
|
||||
let d = s.doc_mut()?;
|
||||
let mut st = current_settings(d);
|
||||
if let Some(a) = annotative {
|
||||
st.annotative = a;
|
||||
}
|
||||
let name = match d.dim_styles.iter_mut().find(|x| x.name.eq_ignore_ascii_case(&name)) {
|
||||
Some(existing) if replace => {
|
||||
let kept = existing.name.clone();
|
||||
*existing = DimStyle { name: kept.clone(), ..st };
|
||||
kept
|
||||
}
|
||||
Some(_) => return Err(bad(CMD, format!("a dimension style `{name}` already exists"))),
|
||||
None => {
|
||||
d.dim_styles.push(DimStyle { name: name.clone(), ..st });
|
||||
name
|
||||
}
|
||||
};
|
||||
d.header.set_str("DIMSTYLE", &name);
|
||||
d.sync_dim_vars();
|
||||
// A redefined style redraws the dimensions that use it.
|
||||
super::props::regen_dims(d, |dm| dm.style.eq_ignore_ascii_case(&name))?;
|
||||
Ok(json!({ "style": name }))
|
||||
}
|
||||
|
||||
/// Make style `name` current (its overrides go).
|
||||
fn restore(s: &mut Session, name: &str) -> Result<Value> {
|
||||
let n = s.doc()?.dim_style(name).map(|t| t.name.clone()).ok_or_else(|| bad(CMD, format!("no dimension style `{name}`")))?;
|
||||
let d = s.doc_mut()?;
|
||||
d.header.set_str("DIMSTYLE", &n);
|
||||
d.sync_dim_vars();
|
||||
Ok(json!({ "current": n }))
|
||||
}
|
||||
|
||||
/// Give dimensions the current settings: the current style and its overrides.
|
||||
fn apply(s: &mut Session, hs: &[Handle]) -> Result<Value> {
|
||||
// The dimensions among them, found before the drawing is touched: none leaves no undo step.
|
||||
let d = s.doc()?;
|
||||
let dims: Vec<Handle> = hs.iter().copied().filter(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Dimension(_)))).collect();
|
||||
if dims.is_empty() {
|
||||
return Ok(json!({ "changed": 0 }));
|
||||
}
|
||||
let d = s.doc_mut()?;
|
||||
let style = d.header.str("DIMSTYLE", "Standard");
|
||||
let overrides = d.dim_overrides();
|
||||
let mut n = 0;
|
||||
for h in dims {
|
||||
d.modify_entity(h, |e| {
|
||||
if let EntityKind::Dimension(dm) = &mut e.kind {
|
||||
dm.style.clone_from(&style);
|
||||
dm.overrides.clone_from(&overrides);
|
||||
dm.block = None;
|
||||
n += 1;
|
||||
}
|
||||
})?;
|
||||
}
|
||||
Ok(json!({ "changed": n }))
|
||||
}
|
||||
|
||||
/// The style and effective settings of dimension `h`.
|
||||
fn dimension_settings(s: &Session, h: Handle) -> Result<DimStyle> {
|
||||
let d = s.doc()?;
|
||||
match d.entity(h).map(|e| &e.kind) {
|
||||
Some(EntityKind::Dimension(dm)) => Ok(d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides)),
|
||||
_ => Err(bad(CMD, "not a dimension")),
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_param(p: &Value) -> Option<Handle> {
|
||||
p.get("handle").and_then(|v| v.as_str().and_then(Handle::parse_hex).or_else(|| v.as_u64().map(Handle)))
|
||||
}
|
||||
|
||||
fn run(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let option = str_param(p, "option").unwrap_or("restore").trim().to_ascii_lowercase();
|
||||
match option.as_str() {
|
||||
"save" | "annotative" => {
|
||||
let name = str_param(p, "name").ok_or_else(|| bad(CMD, "`name` is required"))?.to_string();
|
||||
let anno = if option == "annotative" { Some(true) } else { p.get("annotative").and_then(Value::as_bool) };
|
||||
save(s, &name, anno, bool_or(p, "replace", false))
|
||||
}
|
||||
"restore" => match handle_param(p) {
|
||||
Some(h) => {
|
||||
let name = dimension_settings(s, h)?.name;
|
||||
restore(s, &name)
|
||||
}
|
||||
None => restore(s, str_param(p, "name").ok_or_else(|| bad(CMD, "`name` or `handle` is required"))?),
|
||||
},
|
||||
"status" => Ok(json!({ "variables": variables(¤t_settings(s.doc()?)) })),
|
||||
"variables" => {
|
||||
let st = match handle_param(p) {
|
||||
Some(h) => dimension_settings(s, h)?,
|
||||
None => {
|
||||
let name = str_param(p, "name").ok_or_else(|| bad(CMD, "`name` or `handle` is required"))?;
|
||||
s.doc()?.dim_style(name).cloned().ok_or_else(|| bad(CMD, format!("no dimension style `{name}`")))?
|
||||
}
|
||||
};
|
||||
Ok(json!({ "style": st.name, "variables": variables(&st) }))
|
||||
}
|
||||
"apply" => {
|
||||
let hs = targets(s, p)?;
|
||||
apply(s, &hs)
|
||||
}
|
||||
"list" | "?" => Ok(json!({ "styles": styles_matching(s.doc()?, str_param(p, "pattern").unwrap_or("*")) })),
|
||||
_ => Err(bad(CMD, "`option` is save, annotative, restore, status, variables, apply or list")),
|
||||
}
|
||||
}
|
||||
|
||||
/// `dimstyle.overrides`: set the current style's overrides (the header DIM* variables).
|
||||
fn run_overrides(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let clear = bool_or(p, "clear", false);
|
||||
let mut given = serde_json::Map::new();
|
||||
for (k, v) in p.as_object().into_iter().flatten() {
|
||||
if k == "clear" {
|
||||
continue;
|
||||
}
|
||||
let field = DimStyle::field_name(k)
|
||||
.filter(|f| !matches!(*f, "name" | "annotative"))
|
||||
.ok_or_else(|| bad("dimstyle.overrides", format!("`{k}` is not a dimension variable")))?;
|
||||
given.insert(field.to_string(), v.clone());
|
||||
}
|
||||
// Checked first (against the style alone when its overrides go), so nothing changes when
|
||||
// one value is unusable: a command's error doesn't undo what it did.
|
||||
let d = s.doc()?;
|
||||
let mut base = current_settings(d);
|
||||
if clear {
|
||||
base = d.dim_style(&base.name).cloned().unwrap_or_default();
|
||||
}
|
||||
let rejected = base.apply_fields(&given);
|
||||
if !rejected.is_empty() {
|
||||
return Err(bad("dimstyle.overrides", format!("unusable values for {}", rejected.join(", "))));
|
||||
}
|
||||
// The values as the style took them (a lineweight named ByLayer is -1, ...): what the
|
||||
// header variables hold, so writing them can't fail halfway.
|
||||
let taken = serde_json::to_value(&base).unwrap_or(Value::Null);
|
||||
if clear {
|
||||
s.doc_mut()?.sync_dim_vars();
|
||||
}
|
||||
for (field, v) in &given {
|
||||
let Some((var, _)) = cadcraft_doc::DIMVARS.iter().find(|(_, f)| f == field) else { continue };
|
||||
let v = taken.get(field.as_str()).unwrap_or(v);
|
||||
// Colors are stored as color numbers in the header.
|
||||
let v = match serde_json::from_value::<cadcraft_color::Color>(v.clone()).ok().or_else(|| v.as_str().and_then(cadcraft_color::Color::parse)) {
|
||||
Some(c) if field.ends_with("Color") => json!(c.to_aci()),
|
||||
_ => v.clone(),
|
||||
};
|
||||
crate::sysvars::set(s, var, &v)?;
|
||||
}
|
||||
Ok(json!({ "overrides": s.doc()?.dim_overrides() }))
|
||||
}
|
||||
|
||||
/// What -DIMSTYLE asks next.
|
||||
#[derive(Clone, Default)]
|
||||
enum Ask {
|
||||
#[default]
|
||||
Option,
|
||||
Annotative,
|
||||
SaveName {
|
||||
annotative: Option<bool>,
|
||||
},
|
||||
Redefine {
|
||||
name: String,
|
||||
annotative: Option<bool>,
|
||||
},
|
||||
RestoreName,
|
||||
RestorePick,
|
||||
VariablesName,
|
||||
VariablesPick,
|
||||
Apply,
|
||||
ListPattern,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct DashDimStyle {
|
||||
ask: Ask,
|
||||
sel: SelectPhase,
|
||||
}
|
||||
|
||||
impl DashDimStyle {
|
||||
fn list(&self, s: &mut Session, pattern: &str) -> Result<()> {
|
||||
let names = styles_matching(s.doc()?, pattern);
|
||||
s.echo(format!("Named dimension styles: {}", if names.is_empty() { "none".into() } else { names.join(", ") }));
|
||||
Ok(())
|
||||
}
|
||||
fn show_variables(&self, s: &mut Session, st: &DimStyle) {
|
||||
s.echo(format!("Dimension style: {}", st.name));
|
||||
for line in listing(&variables(st)) {
|
||||
s.echo(line);
|
||||
}
|
||||
}
|
||||
fn answer(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
let ask = std::mem::take(&mut self.ask);
|
||||
let text = match &i {
|
||||
Input::Text(t) | Input::Keyword(t) => Some(t.trim().to_string()),
|
||||
_ => None,
|
||||
};
|
||||
match ask {
|
||||
Ask::Option => {
|
||||
let k = text.unwrap_or_else(|| "Restore".into());
|
||||
self.ask = match k.to_ascii_lowercase().as_str() {
|
||||
"annotative" | "an" => Ask::Annotative,
|
||||
"save" | "s" => Ask::SaveName { annotative: None },
|
||||
"restore" | "r" | "" => Ask::RestoreName,
|
||||
"status" | "st" => {
|
||||
let st = current_settings(s.doc()?);
|
||||
self.show_variables(s, &st);
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
"variables" | "v" => Ask::VariablesName,
|
||||
"apply" | "a" => Ask::Apply,
|
||||
"?" => Ask::ListPattern,
|
||||
_ => return Err(other("Enter one of the options.")),
|
||||
};
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Ask::Annotative => {
|
||||
let yes = !matches!(text.as_deref().map(str::to_ascii_lowercase).as_deref(), Some("no" | "n"));
|
||||
self.ask = Ask::SaveName { annotative: Some(yes) };
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Ask::SaveName { annotative } => match text.as_deref() {
|
||||
None | Some("") => Ok(Step::Done),
|
||||
Some("?") => {
|
||||
self.list(s, "*")?;
|
||||
self.ask = Ask::SaveName { annotative };
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Some(name) => {
|
||||
let name = match check_name(name) {
|
||||
Ok(n) => n,
|
||||
Err(e) => {
|
||||
self.ask = Ask::SaveName { annotative };
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
if s.doc()?.dim_style(&name).is_some() {
|
||||
self.ask = Ask::Redefine { name, annotative };
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
save(s, &name, annotative, false)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
},
|
||||
Ask::Redefine { name, annotative } => {
|
||||
if matches!(text.as_deref().map(str::to_ascii_lowercase).as_deref(), Some("yes" | "y")) {
|
||||
save(s, &name, annotative, true)?;
|
||||
Ok(Step::Done)
|
||||
} else {
|
||||
self.ask = Ask::SaveName { annotative };
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
}
|
||||
Ask::RestoreName => match text.as_deref() {
|
||||
None | Some("") => {
|
||||
self.ask = Ask::RestorePick;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Some("?") => {
|
||||
self.list(s, "*")?;
|
||||
self.ask = Ask::RestoreName;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
// ~name: how style `name` differs from the current settings.
|
||||
Some(t) if t.starts_with('~') => {
|
||||
let d = s.doc()?;
|
||||
let other_style = d.dim_style(t.trim_start_matches('~').trim()).cloned().ok_or_else(|| other("No such dimension style."))?;
|
||||
let current = current_settings(d);
|
||||
let diff = differences(¤t, &other_style);
|
||||
s.echo(format!("Differences between {} and current settings:", other_style.name));
|
||||
if diff.is_empty() {
|
||||
s.echo("None".to_string());
|
||||
}
|
||||
for (var, cur, theirs) in diff {
|
||||
s.echo(format!("{var:<10} {:<20} {}", shown(&theirs), shown(&cur)));
|
||||
}
|
||||
self.ask = Ask::RestoreName;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Some(name) => {
|
||||
if let Err(e) = restore(s, name) {
|
||||
self.ask = Ask::RestoreName;
|
||||
return Err(e);
|
||||
}
|
||||
Ok(Step::Done)
|
||||
}
|
||||
},
|
||||
Ask::RestorePick | Ask::VariablesPick => {
|
||||
let restoring = matches!(ask, Ask::RestorePick);
|
||||
let Input::Point(p) = i else {
|
||||
if matches!(i, Input::Enter) {
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
// Anything else asks for the dimension again.
|
||||
self.ask = ask;
|
||||
return Ok(Step::Continue);
|
||||
};
|
||||
let picked = curves::pick_at(s, p).and_then(|h| dimension_settings(s, h).ok());
|
||||
let Some(st) = picked else {
|
||||
self.ask = if restoring { Ask::RestorePick } else { Ask::VariablesPick };
|
||||
return Err(other("Select a dimension."));
|
||||
};
|
||||
if restoring {
|
||||
restore(s, &st.name)?;
|
||||
} else {
|
||||
self.show_variables(s, &st);
|
||||
}
|
||||
Ok(Step::Done)
|
||||
}
|
||||
Ask::VariablesName => match text.as_deref() {
|
||||
None | Some("") => {
|
||||
self.ask = Ask::VariablesPick;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Some("?") => {
|
||||
self.list(s, "*")?;
|
||||
self.ask = Ask::VariablesName;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Some(name) => {
|
||||
let Some(st) = s.doc()?.dim_style(name).cloned() else {
|
||||
self.ask = Ask::VariablesName;
|
||||
return Err(other("No such dimension style."));
|
||||
};
|
||||
self.show_variables(s, &st);
|
||||
Ok(Step::Done)
|
||||
}
|
||||
},
|
||||
Ask::Apply => match self.sel.feed(s, &i)? {
|
||||
SelOutcome::More => {
|
||||
self.ask = Ask::Apply;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
SelOutcome::Empty => Ok(Step::Done),
|
||||
SelOutcome::Done(hs) => {
|
||||
let r = apply(s, &hs)?;
|
||||
s.echo(format!("{} dimension(s) take the current settings.", r["changed"]));
|
||||
s.set_selection(Vec::new());
|
||||
Ok(Step::Done)
|
||||
}
|
||||
},
|
||||
Ask::ListPattern => {
|
||||
self.list(s, text.as_deref().filter(|t| !t.is_empty()).unwrap_or("*"))?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Interactive for DashDimStyle {
|
||||
fn name(&self) -> &'static str {
|
||||
"-DIMSTYLE"
|
||||
}
|
||||
fn begin(&mut self, s: &mut Session) -> Result<Step> {
|
||||
let d = s.doc()?;
|
||||
let current = d.header.str("DIMSTYLE", "Standard");
|
||||
let annotative = d.dim_style(¤t).is_some_and(|st| st.annotative);
|
||||
let overridden = if d.dim_overrides().is_empty() { "" } else { " (with overrides)" };
|
||||
s.echo(format!("Current dimension style: {current}{overridden} Annotative: {}", if annotative { "Yes" } else { "No" }));
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
match &self.ask {
|
||||
Ask::Option => Prompt::new("Enter a dimension style option", curves::KW)
|
||||
.kw(&["ANnotative", "Save", "Restore", "STatus", "Variables", "Apply", "?"])
|
||||
.default("Restore"),
|
||||
Ask::Annotative => Prompt::new("Create annotative dimension style", curves::KW).kw(&["Yes", "No"]).default("Yes"),
|
||||
Ask::SaveName { .. } => Prompt::new("Enter name for new dimension style or [?]", Accept::TEXT).kw(&["?"]),
|
||||
Ask::Redefine { .. } => Prompt::new("That name is already in use, redefine it?", curves::KW).kw(&["Yes", "No"]).default("No"),
|
||||
Ask::RestoreName => Prompt::new("Enter a dimension style name, [?] or <select dimension>", Accept::TEXT).kw(&["?"]),
|
||||
Ask::RestorePick | Ask::VariablesPick => Prompt::new("Select dimension", Accept::POINT),
|
||||
Ask::VariablesName => Prompt::new("Enter a dimension style name, [?] or <select dimensions>", Accept::TEXT).kw(&["?"]),
|
||||
Ask::Apply => self.sel.prompt(),
|
||||
Ask::ListPattern => Prompt::new("Enter dimension style(s) to list", Accept::TEXT).default("*"),
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
// A refused answer asks the same question again.
|
||||
let asked = self.ask.clone();
|
||||
let r = self.answer(s, i);
|
||||
if r.is_err() {
|
||||
self.ask = asked;
|
||||
}
|
||||
r
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
//! Dimension style commands of the dimension shortcut menu: Remove Style Overrides (DIMOVERRIDE
|
||||
//! Clear for the selected dimensions) and Save as New Style (a style made of a dimension's
|
||||
//! settings, its overrides included, which the dimension then uses).
|
||||
|
||||
use cadcraft_doc::{DimStyle, EntityKind, Handle};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::machines::SelectRun;
|
||||
use super::{CommandSpec, bad, curves, str_param, targets};
|
||||
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
fn other(m: impl Into<String>) -> EngineError {
|
||||
EngineError::Other(m.into())
|
||||
}
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("dimoverride.clear", "Remove Style Overrides", run_clear)
|
||||
.params("{handles?} (dimensions; they draw with their style's settings again) → {changed}")
|
||||
.interactive(|_| Ok(Box::new(SelectRun::new("dimoverride.clear", "DIMOVERRIDE")))),
|
||||
CommandSpec::new("dimstyle.saveas", "Save as New Style...", run_save_as)
|
||||
.params(
|
||||
"{handle? (default: the first selected dimension), name} → {style, handle} (a new dimension style with the dimension's \
|
||||
settings, overrides included; the dimension takes it and its overrides are cleared; the current style is unchanged)",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(SaveAsM::default()))),
|
||||
]
|
||||
}
|
||||
|
||||
fn run_clear(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let hs: Vec<String> = targets(s, p)?.iter().map(|h| h.hex()).collect();
|
||||
super::props::dim_override(s, &json!({ "handles": hs, "clear": true }))
|
||||
}
|
||||
|
||||
fn is_dim(s: &Session, h: Handle) -> bool {
|
||||
s.doc().ok().and_then(|d| d.entity(h)).is_some_and(|e| matches!(e.kind, EntityKind::Dimension(_)))
|
||||
}
|
||||
|
||||
/// A usable new dimension style name (as -DIMSTYLE takes one).
|
||||
fn new_name(s: &Session, name: &str) -> Result<String> {
|
||||
let name = super::dimstyle_cli::check_name(name).map_err(|_| bad("dimstyle.saveas", "bad style name"))?;
|
||||
if s.doc()?.dim_style(&name).is_some() {
|
||||
return Err(bad("dimstyle.saveas", format!("a dimension style `{name}` already exists")));
|
||||
}
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
/// Make style `name` from dimension `h`'s settings and give it to the dimension.
|
||||
fn save_as(s: &mut Session, h: Handle, name: &str) -> Result<Value> {
|
||||
let name = new_name(s, name)?;
|
||||
let d = s.doc_mut()?;
|
||||
let Some(EntityKind::Dimension(dm)) = d.entity(h).map(|e| e.kind.clone()) else { return Err(bad("dimstyle.saveas", "not a dimension")) };
|
||||
let st = d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides);
|
||||
d.dim_styles.push(DimStyle { name: name.clone(), ..st });
|
||||
d.modify_entity(h, |e| {
|
||||
if let EntityKind::Dimension(dm) = &mut e.kind {
|
||||
dm.style.clone_from(&name);
|
||||
dm.overrides.clear();
|
||||
dm.block = None;
|
||||
}
|
||||
})?;
|
||||
Ok(json!({ "style": name, "handle": h.hex() }))
|
||||
}
|
||||
|
||||
fn run_save_as(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = str_param(p, "name").ok_or_else(|| bad("dimstyle.saveas", "`name` is required"))?.to_string();
|
||||
let hs = targets(s, p)?;
|
||||
let h = hs.into_iter().find(|h| is_dim(s, *h)).ok_or_else(|| bad("dimstyle.saveas", "select a dimension"))?;
|
||||
save_as(s, h, &name)
|
||||
}
|
||||
|
||||
/// Save as New Style: the selected dimension (or one picked), then the new style's name.
|
||||
#[derive(Default)]
|
||||
struct SaveAsM {
|
||||
dim: Option<Handle>,
|
||||
}
|
||||
|
||||
impl Interactive for SaveAsM {
|
||||
fn name(&self) -> &'static str {
|
||||
"DIMSTYLE"
|
||||
}
|
||||
fn begin(&mut self, s: &mut Session) -> Result<Step> {
|
||||
self.dim = s.selection().into_iter().find(|h| is_dim(s, *h));
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
match self.dim {
|
||||
None => Prompt::new("Select a dimension", Accept::POINT),
|
||||
Some(_) => Prompt::new("Enter name of new dimension style", Accept::TEXT),
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
match (self.dim, i) {
|
||||
(None, Input::Point(p)) => {
|
||||
let h = curves::pick_at(s, p).filter(|h| is_dim(s, *h)).ok_or_else(|| other("Select a dimension."))?;
|
||||
self.dim = Some(h);
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Some(h), Input::Text(t) | Input::Keyword(t)) => {
|
||||
let r = save_as(s, h, &t)?;
|
||||
s.echo(format!("Dimension style {} created from the dimension.", r["style"].as_str().unwrap_or_default()));
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(_, Input::Enter) => Ok(Step::Done),
|
||||
_ => Ok(Step::Continue),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -33,8 +33,9 @@ use point::{DonutM, PointM, RayM, run_donut, run_point, run_ray};
|
||||
use polygon::{PolygonM, run_polygon};
|
||||
use solid::{SolidM, run_solid};
|
||||
use spline::{SplineM, run_spline};
|
||||
pub(crate) use text::justify;
|
||||
|
||||
use text::{MTextM, TextM, run_mtext, run_text};
|
||||
pub(crate) use text::{justify, justify_prompt};
|
||||
|
||||
/// Every draw command's spec: JSON parameters, menu path, aliases and the interactive prompt
|
||||
/// machine each command starts.
|
||||
|
||||
@@ -25,6 +25,16 @@ pub(crate) fn justify(j: &str) -> Option<(HAlign, VAlign)> {
|
||||
})
|
||||
}
|
||||
|
||||
/// The justification options TEXT offers, in prompt order.
|
||||
const JUSTIFY_OPTIONS: [&str; 15] = ["Left", "Center", "Right", "Align", "Middle", "Fit", "TL", "TC", "TR", "ML", "MC", "MR", "BL", "BC", "BR"];
|
||||
|
||||
/// The prompt for a justification option. Align and Fit run between two baseline points, so a
|
||||
/// command that takes one point (`-ATTDEF`) passes `two_points: false` and doesn't list them.
|
||||
pub(crate) fn justify_prompt(two_points: bool) -> Prompt {
|
||||
let options: Vec<&str> = JUSTIFY_OPTIONS.into_iter().filter(|o| two_points || !matches!(*o, "Align" | "Fit")).collect();
|
||||
Prompt::new("Enter an option", Accept::TEXT).kw(&options)
|
||||
}
|
||||
|
||||
pub(crate) fn make_text(s: &Session, at: Vec2, value: &str, height: f64, rotation: f64, j: (HAlign, VAlign)) -> EntityKind {
|
||||
let style = s.doc().map(|d| d.header.str("TEXTSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into());
|
||||
let (h, v) = j;
|
||||
@@ -119,8 +129,7 @@ impl Interactive for TextM {
|
||||
fn prompt(&self, s: &Session) -> Prompt {
|
||||
let th = s.doc().map(|d| d.header.f64("TEXTSIZE", 0.2)).unwrap_or(0.2);
|
||||
if self.asking_justify {
|
||||
return Prompt::new("Enter an option", Accept::TEXT)
|
||||
.kw(&["Left", "Center", "Right", "Align", "Middle", "Fit", "TL", "TC", "TR", "ML", "MC", "MR", "BL", "BC", "BR"]);
|
||||
return justify_prompt(true);
|
||||
}
|
||||
match (self.at, self.height, self.rotation) {
|
||||
(None, _, _) => Prompt::new("Specify start point of text", Accept::POINT).kw(&["Justify", "Style"]),
|
||||
|
||||
@@ -363,7 +363,7 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let (a, b) = (screen(Vec2::new(min.x, max.y)), screen(Vec2::new(max.x, min.y)));
|
||||
cadcraft_render::raster::blank_outside_pixels(&mut pm, a, b);
|
||||
}
|
||||
let png = pm.encode_png().map_err(|_| bad("preview", "rendering the preview failed"))?;
|
||||
let png = cadcraft_render::raster::encode_png(&pm).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
|
||||
let layout = space.tab_name();
|
||||
Ok(json!({ "data": base64_encode(&png), "width": w, "height": h, "layout": layout, "paper": page.paper, "landscape": page.landscape }))
|
||||
}
|
||||
|
||||
@@ -67,6 +67,22 @@ pub fn entity_codec() -> Option<&'static EntityCodec> {
|
||||
CODEC.get()
|
||||
}
|
||||
|
||||
/// The drawing's non-graphic records as written (tables, BLOCK records, objects): each one's
|
||||
/// type, groups after the type and role (see [`cadcraft_doc::foreign::ForeignKey`]). AutoLISP's
|
||||
/// `namedobjdict`, `tblobjname` and `handent` of non-graphic objects read them (installed by the
|
||||
/// app with the DXF writer, a lower layer; kept apart from [`EntityCodec`] so hosts that only
|
||||
/// need entities don't have to provide it).
|
||||
pub type ObjectRecords = fn(&Drawing) -> Vec<(String, Vec<craft_dxf::Tag>, Option<cadcraft_doc::foreign::ForeignKey>)>;
|
||||
|
||||
static OBJECT_RECORDS: OnceLock<ObjectRecords> = OnceLock::new();
|
||||
|
||||
pub fn set_object_records(f: ObjectRecords) {
|
||||
let _ = OBJECT_RECORDS.set(f);
|
||||
}
|
||||
pub fn object_records() -> Option<ObjectRecords> {
|
||||
OBJECT_RECORDS.get().copied()
|
||||
}
|
||||
|
||||
/// COMPARE (drawing comparison).
|
||||
pub mod compare;
|
||||
|
||||
@@ -408,6 +424,7 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
s.cancel();
|
||||
s.docs.remove(i);
|
||||
s.lisp_forget_closed();
|
||||
if i < s.active {
|
||||
// An earlier drawing went away: the active one shifted down by one.
|
||||
s.active -= 1;
|
||||
@@ -423,6 +440,7 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
fn run_closeall(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
s.cancel();
|
||||
s.docs.clear();
|
||||
s.lisp_forget_closed();
|
||||
s.active = 0;
|
||||
s.bump_doc_epoch();
|
||||
ok()
|
||||
|
||||
@@ -1,8 +1,9 @@
|
||||
//! HATCH, GRADIENT, BOUNDARY, REGION: boundaries from pick points or selected closed objects.
|
||||
|
||||
mod patfile;
|
||||
pub(super) use edit::{set_pattern, takes_pattern};
|
||||
pub(super) use patfile::run_patterns;
|
||||
pub use patfile::{PatternChoice, pattern_choices};
|
||||
pub(super) use patfile::{lines_for, run_patterns};
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{Drawing, Entity, EntityKind, Gradient, Handle, Hatch, HatchLoop, Space, entity_bounds};
|
||||
@@ -10,6 +11,7 @@ use cadcraft_geom::{Bounds2, PolyVertex, Polyline, Vec2, point_in_polygon};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::helpers::lwpoly;
|
||||
use super::machines::SelectRun;
|
||||
use super::{CommandSpec, bad, bool_or, f64_or, point_param, points_param, size_param, str_param, targets};
|
||||
|
||||
use crate::{Accept, EngineError, Input, Interactive, Picker, Prompt, Result, Session, Step};
|
||||
@@ -27,7 +29,12 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("hatch", "Hatch...", run_hatch).menu(&["Draw", "Hatch..."]).alias(&["h", "bh", "-hatch"]).params("{points?: [[x,y]] (internal points) and/or handles?: [hex] (closed objects), pattern?: \"ANSI31\" (built in, or defined by patternFile | patternText), patternFile?: path to a .pat file | patternText?: its contents (loads the patterns it defines), scale?, angle? (degrees), associative? (HPASSOC), separate? (HPSEPARATE: a hatch per point/object), origin?: [x,y] (HPORIGIN) | originMode?: \"current\"|\"bottomLeft\"|\"bottomRight\"|\"topLeft\"|\"topRight\"|\"center\" (HPORIGINMODE), style?: \"normal\"|\"outer\"|\"ignore\" (HPISLANDDETECTION)} — gaps up to HPGAPTOL close").interactive(|s| Ok(Box::new(HatchM::new(s, false)))),
|
||||
CommandSpec::new("gradient", "Gradient...", run_gradient).menu(&["Draw", "Gradient..."]).alias(&["gd"]).params("{points? and/or handles?, name?: \"LINEAR\"|\"CYLINDER\"|\"CURVED\"|\"SPHERICAL\"|\"HEMISPHERICAL\" or INV… (colours swapped), color1?, color2?, angle? (degrees), centered? (default true)}").interactive(|s| Ok(Box::new(HatchM::new(s, true)))),
|
||||
CommandSpec::new("boundary", "Boundary...", run_boundary).menu(&["Draw", "Boundary..."]).alias(&["bo", "bpoly"]).params("{points: [[x,y]]}").interactive(|_| Ok(Box::new(BoundaryM { region: false }))),
|
||||
CommandSpec::new("region", "Region", run_region).menu(&["Draw", "Region"]).alias(&["reg"]).params("{handles?}"),
|
||||
CommandSpec::new("region", "Region", run_region)
|
||||
.menu(&["Draw", "Region"])
|
||||
.alias(&["reg"])
|
||||
.params("{handles?}")
|
||||
// Typed with nothing selected it asks for objects, as in AutoCAD, rather than converting none.
|
||||
.interactive(|_| Ok(Box::new(SelectRun::new("region", "REGION")))),
|
||||
CommandSpec::new("hatchedit", "Hatch Edit", edit::run_hatchedit).menu(&["Modify", "Object", "Hatch..."]).alias(&["he", "-hatchedit"]).params("{handles?, pattern?, scale?, angle?, gradient?: {name?, color1?, color2?, angle? (degrees), centered?} (makes or changes a gradient fill; `pattern` turns it back), associative?: bool (false unlinks; true links each loop to a closed object of the same shape, or to `boundary` objects), boundary?: [hex], addPoints?: [[x,y]], addBoundary?: [hex], removeLoops?: [zero-based index] (geometry edits require one hatch), style?, origin? | originMode?, separate?: true, recreate?: \"polyline\"|\"region\", associate?: bool (link to the recreated boundary)}").interactive(|s| Ok(Box::new(edit::HatchEditM::new(s)))),
|
||||
CommandSpec::new("hatchpick", "Hatch Pick", pick::run_hatchpick)
|
||||
.params("{points?: [[x,y]] (internal points), handles?: [hex] (closed objects)} (typed: Points, Objects, oRigin or Hatch, then the picks): the Hatch and Gradient dialog's picks, kept in the session; changes nothing")
|
||||
|
||||
@@ -143,21 +143,8 @@ fn separate(s: &mut Session, handle: Handle) -> Result<Vec<Handle>> {
|
||||
|
||||
/// Pattern, scale and angle (degrees) from the parameters.
|
||||
fn properties(h: &mut Hatch, p: &Value) {
|
||||
if let Some(v) = str_param(p, "pattern").map(str::trim).filter(|v| !v.is_empty()) {
|
||||
h.pattern = v.to_ascii_uppercase();
|
||||
h.solid = h.pattern == "SOLID";
|
||||
// A named pattern, SOLID included, replaces the gradient fill; the renderer draws the
|
||||
// gradient first when it is set.
|
||||
h.gradient = None;
|
||||
if !h.solid {
|
||||
// A library pattern is drawn from the library; a loaded .pat pattern brings its lines;
|
||||
// any other name is the hatch's own and keeps its definition.
|
||||
if cadcraft_doc::library::pattern(&h.pattern).is_some() {
|
||||
h.pattern_lines.clear();
|
||||
} else if let Some(user) = super::patfile::user_pattern(&h.pattern) {
|
||||
h.pattern_lines = user.lines;
|
||||
}
|
||||
}
|
||||
if let Some(v) = str_param(p, "pattern") {
|
||||
set_pattern(h, v);
|
||||
}
|
||||
if let Some(x) = p.get("scale").and_then(Value::as_f64).filter(|x| x.is_finite() && *x > 0.0) {
|
||||
h.scale = x;
|
||||
@@ -167,6 +154,43 @@ fn properties(h: &mut Hatch, p: &Value) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the pattern called `up` (upper case) is defined: SOLID, one CADCraft defines, or a
|
||||
/// loaded .pat pattern.
|
||||
fn defined_pattern(up: &str) -> bool {
|
||||
up == "SOLID" || cadcraft_doc::library::pattern(up).is_some() || super::patfile::user_pattern(up).is_some()
|
||||
}
|
||||
|
||||
/// Whether `h` can take the pattern called `name`: a defined one, or the hatch's own (a pattern
|
||||
/// read from a file keeps its definition).
|
||||
pub(crate) fn takes_pattern(h: &Hatch, name: &str) -> bool {
|
||||
let up = name.trim().to_ascii_uppercase();
|
||||
defined_pattern(&up) || h.pattern.eq_ignore_ascii_case(&up)
|
||||
}
|
||||
|
||||
/// Give `h` the pattern called `name` (HATCHEDIT's and Properties' pattern edit); false, and
|
||||
/// nothing changes, for a blank name or one the hatch can't take ([`takes_pattern`]).
|
||||
pub(crate) fn set_pattern(h: &mut Hatch, name: &str) -> bool {
|
||||
let name = name.trim();
|
||||
if name.is_empty() || !takes_pattern(h, name) {
|
||||
return false;
|
||||
}
|
||||
h.pattern = name.to_ascii_uppercase();
|
||||
h.solid = h.pattern == "SOLID";
|
||||
// A named pattern, SOLID included, replaces the gradient fill; the renderer draws the
|
||||
// gradient first when it is set.
|
||||
h.gradient = None;
|
||||
if !h.solid {
|
||||
// A library pattern is drawn from the library; a loaded .pat pattern brings its lines;
|
||||
// any other name is the hatch's own and keeps its definition.
|
||||
if cadcraft_doc::library::pattern(&h.pattern).is_some() {
|
||||
h.pattern_lines.clear();
|
||||
} else if let Some(user) = super::patfile::user_pattern(&h.pattern) {
|
||||
h.pattern_lines = user.lines;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// HATCHEDIT's `gradient`: the fields to change, all checked before any hatch is touched.
|
||||
struct GradientEdit {
|
||||
name: Option<&'static str>,
|
||||
@@ -389,9 +413,7 @@ pub(super) fn run_hatchedit(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
// Like the prompt: a pattern must be one CADCraft defines, SOLID, or the hatches' own (a
|
||||
// pattern read from a file keeps its definition).
|
||||
if let Some(up) = str_param(p, "pattern").map(|v| v.trim().to_ascii_uppercase()).filter(|v| !v.is_empty())
|
||||
&& up != "SOLID"
|
||||
&& cadcraft_doc::library::pattern(&up).is_none()
|
||||
&& super::patfile::user_pattern(&up).is_none()
|
||||
&& !defined_pattern(&up)
|
||||
{
|
||||
let d = s.doc()?;
|
||||
let own = hs.iter().all(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Hatch(x)) if x.pattern == up));
|
||||
|
||||
@@ -106,6 +106,10 @@ pub fn used_layers(d: &cadcraft_doc::Drawing) -> std::collections::HashSet<Strin
|
||||
if !set.contains(&e.common.layer.to_ascii_lowercase()) {
|
||||
set.insert(e.common.layer.to_ascii_lowercase());
|
||||
}
|
||||
// An attribute can sit on a layer of its own.
|
||||
for layer in super::blocks::object_attribs(e).iter().filter_map(|a| a.props.layer.as_ref()) {
|
||||
set.insert(layer.to_ascii_lowercase());
|
||||
}
|
||||
}
|
||||
set
|
||||
}
|
||||
|
||||
+107
-374
@@ -6,22 +6,31 @@ mod chprop;
|
||||
mod dash_units;
|
||||
mod matchprop;
|
||||
mod rename;
|
||||
mod set;
|
||||
|
||||
pub use matchprop::MatchProps;
|
||||
use set::run_set;
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{EntityKind, Handle, Lineweight, Transparency};
|
||||
use cadcraft_geom::Vec3;
|
||||
use cadcraft_doc::{EntityKind, Lineweight, Transparency};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, point_value, str_param, targets};
|
||||
use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, str_param, targets};
|
||||
|
||||
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("properties", "Properties", run_get).menu(&["Modify", "Properties"]).alias(&["pr", "props", "ch"]).params("{handles?} → properties of the selection").noundo(),
|
||||
CommandSpec::new("properties.set", "Set Properties", run_set).params("{handles?, layer?, color?, linetype?, lineweight?, ltscale?, thickness?, transparency?: \"ByLayer\" | \"ByBlock\" | 0..90, visible?, <geometry fields: radius, center, start, end, text, height, rotation…>; dimensions: textOverride, dimStyle, textHeight, arrowSize, dimScale, precision (per-dimension overrides)} → {changed, locked, message?}: objects on locked layers (and, during REFEDIT, outside the working set) are left out, and `message` says how many"),
|
||||
CommandSpec::new("properties.set", "Set Properties", run_set).params(
|
||||
"{handles?, layer?, color?, linetype?, lineweight?, ltscale?, thickness?, transparency?: \"ByLayer\" | \"ByBlock\" | 0..90, visible?, annotative?, \
|
||||
<geometry fields: radius, center, start, end, text, height, rotation…>, text: style?, justify?, oblique?, positionX/Y/Z?, alignmentX/Y?, \
|
||||
mtext: style?, justify?, lineSpacing?, lineSpacingDistance?, lineSpacingStyle?: atLeast | exactly, positionX/Y/Z?, \
|
||||
dimension: dimStyle?, textOverride?, textRotation?, textPositionX/Y?, prefix?, suffix?, altPrefix?, altSuffix?, dimScale?, precision?, \
|
||||
<dimension style variables (field or DIM* name, e.g. textHeight / DIMTXT) set as overrides of each dimension>, clearOverrides?, clear?: [variable]} \
|
||||
→ {changed, locked, message?, ignored: keys no selected object took} (the keys are those of `properties.describe` rows): objects on locked layers \
|
||||
(and, during REFEDIT, outside the working set) are left out, and `message` says how many",
|
||||
),
|
||||
CommandSpec::new("chprop", "Change Properties", run_set)
|
||||
.params("as properties.set, leaving out objects on locked layers (and, during REFEDIT, outside the working set) → {changed, locked, message?} (the command line asks Color, LAyer, LType, ltScale, LWeight, Thickness and TRansparency in turn)")
|
||||
.interactive(|_| Ok(Box::new(chprop::ChpropM::new()))),
|
||||
@@ -29,6 +38,13 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
.alias(&["-ch"])
|
||||
.params("{handles?, point?: [x, y], elevation?} → {changed, ignored, differingZ, detachedHatches, locked}: the point moves the nearer end of each line to it (level or plumb with the other end under ORTHOMODE) and, when it is the one object, passes a circle through it or places a text, attribute definition or block reference at it (`ignored` otherwise); `elevation` sets the z of objects whose points share one (`differingZ` otherwise); objects on locked layers are left out (the command line asks Specify change point or [Properties], then about each circle, text, attribute definition and block reference in turn)")
|
||||
.interactive(|_| Ok(Box::new(change::ChangeM::new()))),
|
||||
CommandSpec::new("properties.describe", "Describe Properties", run_describe)
|
||||
.params(
|
||||
"{handles?, type?: one of the `types` names, to describe only those objects} → {types: [{type, count}], filter?, count, \
|
||||
groups: [{name, rows: [{key, label, kind, value, varies, display, editable, note?, overridden?, options?: [{value, label}], quick?}]}]} \
|
||||
(each row's `key` is the `properties.set` key that changes it; text, mtext and dimensions have their own groups)",
|
||||
)
|
||||
.noundo(),
|
||||
CommandSpec::new("matchprop", "Match Properties", matchprop::run_matchprop)
|
||||
.menu(&["Modify", "Match Properties"])
|
||||
.alias(&["ma", "painter"])
|
||||
@@ -172,10 +188,13 @@ fn parse_color(v: &Value) -> Option<Color> {
|
||||
|
||||
/// A transparency as JSON, in the form `properties.set` takes: "ByLayer", "ByBlock" or a percentage.
|
||||
pub(super) fn transparency_value(t: Transparency) -> Value {
|
||||
match t {
|
||||
Transparency::Percent(p) => json!(p),
|
||||
other => json!(other.name()),
|
||||
}
|
||||
crate::properties::transparency_value(t)
|
||||
}
|
||||
|
||||
fn run_describe(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let hs = targets(s, p)?;
|
||||
let d = s.doc()?;
|
||||
Ok(serde_json::to_value(crate::properties::describe(d, &hs, str_param(p, "type"))).unwrap_or(Value::Null))
|
||||
}
|
||||
|
||||
/// "ByLayer", "ByBlock" or a percentage 0..=90 (a number, or a string such as "50" or "50%").
|
||||
@@ -189,369 +208,6 @@ fn parse_transparency(v: &Value) -> Option<Transparency> {
|
||||
(pct.is_finite() && (0.0..=90.0).contains(&pct)).then(|| Transparency::Percent(pct.round() as u8))
|
||||
}
|
||||
|
||||
fn set_xy(p: &mut Vec3, v: &Value) {
|
||||
if let Some(q) = point_value(v) {
|
||||
p.x = q.x;
|
||||
p.y = q.y;
|
||||
}
|
||||
}
|
||||
|
||||
/// The objects `properties.set` leaves alone, as CHPROP, MATCHPROP and MOVE do: those on locked
|
||||
/// layers and, while a reference is edited in place, those outside the working set.
|
||||
#[derive(Default)]
|
||||
struct LeftOut {
|
||||
locked: usize,
|
||||
outside: usize,
|
||||
}
|
||||
|
||||
impl LeftOut {
|
||||
/// `hs` without the objects that can't be edited, each object once, and how many those were. A
|
||||
/// handle that names no object is an error, before anything changes.
|
||||
fn split(s: &Session, hs: Vec<Handle>) -> Result<(Vec<Handle>, LeftOut)> {
|
||||
let d = s.doc()?;
|
||||
// The working set, once: `RefEdit::is_working` searches a list.
|
||||
let working: Option<std::collections::HashSet<Handle>> = d.refedit.as_ref().map(|r| r.items.iter().map(|i| i.copy).collect());
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
let mut out = LeftOut::default();
|
||||
let mut free = Vec::new();
|
||||
for h in hs {
|
||||
let Some(e) = d.entity(h) else {
|
||||
return Err(cadcraft_doc::DocError::NoEntity(h).into());
|
||||
};
|
||||
if !seen.insert(h) {
|
||||
continue;
|
||||
}
|
||||
if working.as_ref().is_some_and(|w| !w.contains(&h)) {
|
||||
out.outside += 1;
|
||||
} else if d.layer(&e.common.layer).is_some_and(|l| l.locked) {
|
||||
out.locked += 1;
|
||||
} else {
|
||||
free.push(h);
|
||||
}
|
||||
}
|
||||
Ok((free, out))
|
||||
}
|
||||
|
||||
/// `{changed, locked}`, and a message saying how many were left out when any were.
|
||||
fn result(&self, changed: usize) -> Value {
|
||||
let mut notes = Vec::new();
|
||||
match self.locked {
|
||||
0 => {}
|
||||
1 => notes.push("1 object was on a locked layer.".to_string()),
|
||||
n => notes.push(format!("{n} objects were on a locked layer.")),
|
||||
}
|
||||
match self.outside {
|
||||
0 => {}
|
||||
1 => notes.push("1 object was not in the working set.".to_string()),
|
||||
n => notes.push(format!("{n} objects were not in the working set.")),
|
||||
}
|
||||
if changed == 0 && !notes.is_empty() {
|
||||
notes.push("Nothing was changed.".to_string());
|
||||
}
|
||||
let mut r = json!({ "changed": changed, "locked": self.locked + self.outside });
|
||||
if !notes.is_empty()
|
||||
&& let Some(o) = r.as_object_mut()
|
||||
{
|
||||
o.insert("message".into(), json!(notes.join(" ")));
|
||||
}
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let hs = targets(s, p)?;
|
||||
if hs.is_empty() {
|
||||
return Err(bad("properties.set", "nothing selected"));
|
||||
}
|
||||
let (hs, left_out) = LeftOut::split(s, hs)?;
|
||||
let color = p.get("color").map(|c| parse_color(c).ok_or_else(|| bad("properties.set", "bad colour"))).transpose()?;
|
||||
let transparency = p
|
||||
.get("transparency")
|
||||
.map(|v| parse_transparency(v).ok_or_else(|| bad("properties.set", "transparency must be ByLayer, ByBlock or a percentage from 0 to 90")))
|
||||
.transpose()?;
|
||||
let thickness = p
|
||||
.get("thickness")
|
||||
.map(|v| v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("properties.set", "thickness must be a finite number")))
|
||||
.transpose()?;
|
||||
let lw = p.get("lineweight").map(|v| super::layer::parse_lw(v).ok_or_else(|| bad("properties.set", "bad lineweight"))).transpose()?;
|
||||
let d = s.doc()?;
|
||||
// An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
|
||||
let linetype = str_param(p, "linetype")
|
||||
.map(|n| {
|
||||
if n.eq_ignore_ascii_case("ByLayer") || n.eq_ignore_ascii_case("ByBlock") {
|
||||
Ok(n.to_string())
|
||||
} else {
|
||||
d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))
|
||||
}
|
||||
})
|
||||
.transpose()?;
|
||||
let dim_style = str_param(p, "dimStyle")
|
||||
.map(|n| d.dim_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("dimension style `{n}` not found"))))
|
||||
.transpose()?;
|
||||
let dim_over = dim_overrides(p)?;
|
||||
if hs.is_empty() {
|
||||
// Every object was left out: the drawing stays as it was, with no undo step.
|
||||
return Ok(left_out.result(0));
|
||||
}
|
||||
let d = s.doc_mut()?;
|
||||
if let Some(l) = str_param(p, "layer") {
|
||||
d.ensure_layer(l);
|
||||
}
|
||||
let anno_scale = d.current_anno_scale();
|
||||
let common = CommonEntityProperties { anno_scale: &anno_scale, color, linetype: linetype.as_deref(), lineweight: lw, transparency, thickness };
|
||||
for h in &hs {
|
||||
d.modify_entity(*h, |e| {
|
||||
set_common_properties(e, p, &common);
|
||||
apply_kind_properties(e, p, dim_style.as_ref(), &dim_over);
|
||||
})?;
|
||||
}
|
||||
Ok(left_out.result(hs.len()))
|
||||
}
|
||||
|
||||
fn apply_kind_properties(
|
||||
entity: &mut cadcraft_doc::Entity,
|
||||
params: &Value,
|
||||
dim_style: Option<&String>,
|
||||
dim_overrides: &serde_json::Map<String, Value>,
|
||||
) {
|
||||
let num = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
|
||||
match &mut entity.kind {
|
||||
EntityKind::Line(l) => {
|
||||
if let Some(v) = params.get("start") {
|
||||
set_xy(&mut l.a, v);
|
||||
}
|
||||
if let Some(v) = params.get("end") {
|
||||
set_xy(&mut l.b, v);
|
||||
}
|
||||
// Length / angle keep the start point and move the end point.
|
||||
let (a, b) = (l.a.xy(), l.b.xy());
|
||||
let len = num("length").filter(|x| *x > 0.0 && *x < 1e15).unwrap_or_else(|| a.dist(b));
|
||||
let ang = num("angle").map(f64::to_radians).unwrap_or_else(|| a.angle_to(b));
|
||||
if num("length").is_some() || num("angle").is_some() {
|
||||
let e = cadcraft_geom::Vec2::polar(a, len, ang);
|
||||
if e.is_finite() {
|
||||
l.b.x = e.x;
|
||||
l.b.y = e.y;
|
||||
}
|
||||
}
|
||||
}
|
||||
EntityKind::Circle(c) => {
|
||||
if let Some(v) = params.get("center") {
|
||||
set_xy(&mut c.center, v);
|
||||
}
|
||||
if let Some(r) = num("radius").filter(|r| *r > 0.0) {
|
||||
c.radius = r;
|
||||
}
|
||||
if let Some(dm) = num("diameter").filter(|r| *r > 0.0) {
|
||||
c.radius = dm / 2.0;
|
||||
}
|
||||
if let Some(cf) = num("circumference").filter(|x| *x > 0.0) {
|
||||
c.radius = cf / cadcraft_geom::TAU;
|
||||
}
|
||||
if let Some(a) = num("area").filter(|x| *x > 0.0) {
|
||||
c.radius = (a / cadcraft_geom::PI).sqrt();
|
||||
}
|
||||
}
|
||||
EntityKind::Arc(a) => {
|
||||
if let Some(v) = params.get("center") {
|
||||
set_xy(&mut a.center, v);
|
||||
}
|
||||
if let Some(r) = num("radius").filter(|r| *r > 0.0) {
|
||||
a.radius = r;
|
||||
}
|
||||
if let Some(x) = num("startAngle") {
|
||||
a.start = cadcraft_geom::norm_angle(x.to_radians());
|
||||
}
|
||||
if let Some(x) = num("endAngle") {
|
||||
a.end = cadcraft_geom::norm_angle(x.to_radians());
|
||||
}
|
||||
}
|
||||
EntityKind::Text(t) => {
|
||||
if let Some(v) = str_param(params, "text") {
|
||||
t.value = v.to_string();
|
||||
}
|
||||
if let Some(x) = num("height").filter(|x| *x > 0.0) {
|
||||
t.height = x;
|
||||
}
|
||||
if let Some(x) = num("rotation") {
|
||||
t.rotation = x.to_radians();
|
||||
}
|
||||
if let Some(x) = num("widthFactor").filter(|x| *x > 0.0) {
|
||||
t.width_factor = x;
|
||||
}
|
||||
// The position is the point the text is placed by: moving it moves the text.
|
||||
if let Some(to) = params.get("position").and_then(point_value) {
|
||||
let d = to - t.justify_point();
|
||||
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
|
||||
q.x += d.x;
|
||||
q.y += d.y;
|
||||
}
|
||||
}
|
||||
}
|
||||
EntityKind::MText(t) => {
|
||||
if let Some(v) = str_param(params, "text") {
|
||||
t.contents = v.replace('\n', "\\P");
|
||||
}
|
||||
if let Some(x) = num("height").filter(|x| *x > 0.0) {
|
||||
t.height = x;
|
||||
}
|
||||
if let Some(x) = num("width").filter(|x| *x >= 0.0) {
|
||||
t.width = x;
|
||||
}
|
||||
if let Some(x) = num("rotation") {
|
||||
t.rotation = x.to_radians();
|
||||
}
|
||||
}
|
||||
// A multileader's text: its contents (#1081) and height.
|
||||
EntityKind::MLeader(m) => {
|
||||
if let Some(t) = &mut m.text {
|
||||
if let Some(v) = str_param(params, "text") {
|
||||
t.contents = v.replace('\n', "\\P");
|
||||
}
|
||||
if let Some(x) = num("height").filter(|x| *x > 0.0) {
|
||||
t.height = x;
|
||||
}
|
||||
}
|
||||
}
|
||||
EntityKind::LwPolyline(pl) => {
|
||||
if let Some(x) = num("width").filter(|x| *x >= 0.0) {
|
||||
pl.const_width = x;
|
||||
}
|
||||
if let Some(c) = params.get("closed").and_then(Value::as_bool) {
|
||||
pl.closed = c;
|
||||
}
|
||||
}
|
||||
EntityKind::Insert(insert) => set_insert_properties(insert, params),
|
||||
EntityKind::Dimension(dimension) => set_dimension_properties(dimension, params, dim_style, dim_overrides),
|
||||
EntityKind::Hatch(hatch) => set_hatch_properties(hatch, params),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn set_insert_properties(insert: &mut cadcraft_doc::Insert, params: &Value) {
|
||||
let number = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
|
||||
|
||||
if let Some(x) = number("rotation") {
|
||||
let turn = x.to_radians() - insert.rotation;
|
||||
insert.rotation = x.to_radians();
|
||||
// The attached text turns with the reference, around its insertion point (as ROTATE does).
|
||||
let base = insert.insert.xy();
|
||||
for a in &mut insert.attribs {
|
||||
let t = &mut a.text;
|
||||
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
|
||||
let r = q.xy().rotate_about(base, turn);
|
||||
q.x = r.x;
|
||||
q.y = r.y;
|
||||
}
|
||||
t.rotation = cadcraft_geom::norm_angle(t.rotation + turn);
|
||||
if let Some(ml) = &mut a.multiline {
|
||||
let r = ml.mtext.insert.xy().rotate_about(base, turn);
|
||||
ml.mtext.insert.x = r.x;
|
||||
ml.mtext.insert.y = r.y;
|
||||
ml.mtext.rotation = cadcraft_geom::norm_angle(ml.mtext.rotation + turn);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(x) = number("scale").filter(|x| *x != 0.0) {
|
||||
// A new positive scale carries the attached attribute text with it, like SCALE about the insertion point.
|
||||
if x > 0.0 && insert.scale.x > 0.0 {
|
||||
let m = cadcraft_geom::Mat3::scale_about(insert.insert.xy(), x / insert.scale.x);
|
||||
for a in &mut insert.attribs {
|
||||
let mut k = EntityKind::Text(a.text.clone());
|
||||
k.transform(&m);
|
||||
if let EntityKind::Text(t) = k {
|
||||
a.text = t;
|
||||
}
|
||||
a.transform_multiline(&m);
|
||||
}
|
||||
}
|
||||
insert.scale = Vec3::new(x, x, x);
|
||||
}
|
||||
}
|
||||
|
||||
fn set_dimension_properties(
|
||||
dimension: &mut cadcraft_doc::Dimension,
|
||||
params: &Value,
|
||||
style: Option<&String>,
|
||||
overrides: &serde_json::Map<String, Value>,
|
||||
) {
|
||||
if let Some(v) = str_param(params, "textOverride") {
|
||||
dimension.text = v.to_string();
|
||||
dimension.block = None;
|
||||
}
|
||||
if let Some(st) = style {
|
||||
dimension.style.clone_from(st);
|
||||
dimension.block = None;
|
||||
}
|
||||
if !overrides.is_empty() {
|
||||
dimension.overrides.extend(overrides.clone());
|
||||
dimension.block = None;
|
||||
}
|
||||
}
|
||||
|
||||
fn set_hatch_properties(hatch: &mut cadcraft_doc::Hatch, params: &Value) {
|
||||
let number = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
|
||||
|
||||
if let Some(v) = str_param(params, "pattern") {
|
||||
if !hatch.pattern.eq_ignore_ascii_case(v) {
|
||||
hatch.pattern_lines = super::hatch::lines_for(v);
|
||||
}
|
||||
hatch.pattern = v.to_ascii_uppercase();
|
||||
// The old pattern's definition lines no longer apply.
|
||||
hatch.pattern_lines.clear();
|
||||
hatch.solid = hatch.pattern == "SOLID";
|
||||
if !hatch.solid {
|
||||
// A named pattern replaces the gradient fill; the renderer draws the gradient first when it is set.
|
||||
hatch.gradient = None;
|
||||
}
|
||||
}
|
||||
if let Some(x) = number("scale").filter(|x| *x > 0.0) {
|
||||
hatch.scale = x;
|
||||
}
|
||||
if let Some(x) = number("angle") {
|
||||
hatch.angle = x.to_radians();
|
||||
}
|
||||
}
|
||||
|
||||
struct CommonEntityProperties<'a> {
|
||||
anno_scale: &'a cadcraft_doc::AnnoScale,
|
||||
color: Option<Color>,
|
||||
linetype: Option<&'a str>,
|
||||
lineweight: Option<Lineweight>,
|
||||
transparency: Option<Transparency>,
|
||||
thickness: Option<f64>,
|
||||
}
|
||||
|
||||
fn set_common_properties(entity: &mut cadcraft_doc::Entity, params: &Value, common: &CommonEntityProperties<'_>) {
|
||||
if let Some(annotative) = params.get("annotative").and_then(Value::as_bool) {
|
||||
cadcraft_doc::set_annotative(entity, annotative, common.anno_scale);
|
||||
}
|
||||
if let Some(layer) = str_param(params, "layer") {
|
||||
entity.common.layer = layer.to_string();
|
||||
}
|
||||
if let Some(color) = common.color {
|
||||
entity.common.color = color;
|
||||
}
|
||||
if let Some(linetype) = common.linetype {
|
||||
entity.common.linetype = linetype.to_string();
|
||||
}
|
||||
if let Some(lineweight) = common.lineweight {
|
||||
entity.common.lineweight = lineweight;
|
||||
}
|
||||
if let Some(scale) = params.get("ltscale").and_then(Value::as_f64).filter(|scale| *scale > 0.0) {
|
||||
entity.common.ltscale = scale;
|
||||
}
|
||||
if let Some(transparency) = common.transparency {
|
||||
entity.common.transparency = transparency;
|
||||
}
|
||||
if let Some(thickness) = common.thickness {
|
||||
entity.common.thickness = thickness;
|
||||
}
|
||||
if let Some(visible) = params.get("visible").and_then(Value::as_bool) {
|
||||
entity.common.visible = visible;
|
||||
}
|
||||
}
|
||||
|
||||
fn run_color(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let c = p.get("color").and_then(parse_color).ok_or_else(|| bad("color", "`color` is required"))?;
|
||||
set_current_color(s.doc_mut()?, c);
|
||||
@@ -791,6 +447,8 @@ fn run_style(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
return Err(bad("style", "bad style name"));
|
||||
}
|
||||
let d = s.doc_mut()?;
|
||||
// As it was (none for a new style), so dimensions are redrawn only when it changes.
|
||||
let before = d.text_style(&name).cloned();
|
||||
let idx = match d.text_styles.iter().position(|t| t.name.eq_ignore_ascii_case(&name)) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
@@ -826,6 +484,13 @@ fn run_style(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
}
|
||||
// Dimensions whose text uses the style drop the geometry they were read with when it
|
||||
// changed: their text changes with it. Only making it current keeps that geometry.
|
||||
if before.as_ref() != d.text_styles.get(idx) {
|
||||
let text_style_of: std::collections::HashMap<String, String> =
|
||||
d.dim_styles.iter().map(|st| (st.name.to_ascii_lowercase(), st.text_style.clone())).collect();
|
||||
regen_dims(d, |dm| dim_text_style(dm, &text_style_of).eq_ignore_ascii_case(&name))?;
|
||||
}
|
||||
if bool_or(p, "current", true) {
|
||||
d.header.set_str("TEXTSTYLE", &name);
|
||||
}
|
||||
@@ -854,12 +519,19 @@ pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
|
||||
let stores = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).chain(d.blocks.values().map(|b| &b.entities));
|
||||
for st in stores {
|
||||
for e in st.iter() {
|
||||
out.extend(super::blocks::object_attribs(e).iter().flat_map(attrib_text_styles));
|
||||
match &e.kind {
|
||||
EntityKind::Text(t) => out.push(t.style.clone()),
|
||||
EntityKind::MText(t) => out.push(t.style.clone()),
|
||||
EntityKind::AttDef(a) => out.push(a.text.style.clone()),
|
||||
EntityKind::Insert(i) => out.extend(i.attribs.iter().map(|a| a.text.style.clone())),
|
||||
EntityKind::AttDef(a) => out.extend(attrib_text_styles(a)),
|
||||
EntityKind::MLeader(m) => out.extend(m.text.iter().map(|t| t.style.clone())),
|
||||
// A dimension's own text style (a DIMTXSTY override), which a rename follows too.
|
||||
EntityKind::Dimension(dm) => out.extend(
|
||||
dm.overrides
|
||||
.iter()
|
||||
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k) == Some("textStyle"))
|
||||
.filter_map(|(_, v)| super::blocks::purge::override_name(v)),
|
||||
),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
@@ -867,6 +539,11 @@ pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
|
||||
out
|
||||
}
|
||||
|
||||
/// The text styles of an attribute or attribute definition, its multiline text included.
|
||||
fn attrib_text_styles(a: &cadcraft_doc::Attrib) -> impl Iterator<Item = String> + '_ {
|
||||
std::iter::once(a.text.style.clone()).chain(a.multiline.iter().map(|m| m.mtext.style.clone()))
|
||||
}
|
||||
|
||||
fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let from = str_param(p, "from").ok_or_else(|| bad("style.rename", "`from` is required"))?.to_string();
|
||||
let to = str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("style.rename", "`to` is required"))?.to_string();
|
||||
@@ -896,6 +573,7 @@ fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
EntityKind::AttDef(a) => a.text.style.eq_ignore_ascii_case(&from),
|
||||
EntityKind::Insert(i) => i.attribs.iter().any(|a| a.text.style.eq_ignore_ascii_case(&from)),
|
||||
EntityKind::MLeader(m) => m.text.iter().any(|t| t.style.eq_ignore_ascii_case(&from)),
|
||||
EntityKind::Dimension(dm) => dm.overrides.iter().any(|(k, v)| is_text_style_override(k, v, &from)),
|
||||
_ => false,
|
||||
};
|
||||
let repoint = |k: &mut EntityKind| match k {
|
||||
@@ -904,6 +582,8 @@ fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
EntityKind::AttDef(a) => fix(&mut a.text.style),
|
||||
EntityKind::Insert(i) => i.attribs.iter_mut().for_each(|a| fix(&mut a.text.style)),
|
||||
EntityKind::MLeader(m) => m.text.iter_mut().for_each(|t| fix(&mut t.style)),
|
||||
// A dimension's own text style (a DIMTXSTY override).
|
||||
EntityKind::Dimension(dm) => dm.overrides.iter_mut().filter(|(k, v)| is_text_style_override(k, v, &from)).for_each(|(_, v)| *v = json!(to)),
|
||||
_ => {}
|
||||
};
|
||||
let mut hs: Vec<cadcraft_doc::Handle> = d.model.iter().filter(|e| uses(&e.kind)).map(|e| e.handle).collect();
|
||||
@@ -953,7 +633,14 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if name.is_empty() || name.len() > 255 {
|
||||
return Err(bad("dimstyle", "bad style name"));
|
||||
}
|
||||
// A new style's name is one -DIMSTYLE takes (no `~`, which its Restore reads as compare, or
|
||||
// wildcards); a style read from a file keeps the name it has.
|
||||
if s.doc()?.dim_style(&name).is_none() {
|
||||
super::dimstyle_cli::check_name(&name).map_err(|_| bad("dimstyle", "bad style name"))?;
|
||||
}
|
||||
let d = s.doc_mut()?;
|
||||
// As it was (none for a new style), so dimensions are redrawn only when it changes.
|
||||
let before = d.dim_style(&name).cloned();
|
||||
let base = d.dim_style(&d.header.str("DIMSTYLE", "Standard")).cloned().unwrap_or_default();
|
||||
let idx = match d.dim_styles.iter().position(|t| t.name.eq_ignore_ascii_case(&name)) {
|
||||
Some(i) => i,
|
||||
@@ -968,6 +655,12 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
src.iter().filter(|(k, _)| !matches!(k.as_str(), "name" | "current")).map(|(k, v)| (k.clone(), v.clone())).collect();
|
||||
rejected = st.apply_fields(&fields);
|
||||
}
|
||||
// Dimensions with the style drop the geometry they were read with when it changed, so they
|
||||
// show the edit (as AutoCAD updates every dimension that uses a style; their overrides still
|
||||
// win). Only making it current keeps that geometry.
|
||||
if before.as_ref() != d.dim_styles.get(idx) {
|
||||
regen_dims(d, |dm| dm.style.eq_ignore_ascii_case(&name))?;
|
||||
}
|
||||
if bool_or(p, "current", true) {
|
||||
d.header.set_str("DIMSTYLE", &name);
|
||||
}
|
||||
@@ -979,7 +672,8 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if !rejected.is_empty()
|
||||
&& let Some(o) = out.as_object_mut()
|
||||
{
|
||||
o.insert("ignored".into(), json!(rejected));
|
||||
o.insert("ignored".into(), json!(rejected.clone()));
|
||||
o.insert("message".into(), json!(format!("Ignored invalid value for: {}", rejected.join(", "))));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
@@ -1010,6 +704,44 @@ fn run_dimstyle_current(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(dimstyles_json(d))
|
||||
}
|
||||
|
||||
/// Dimensions (in model space, layouts and block definitions) that `uses` matches drop the
|
||||
/// geometry block they were read with, so they are drawn and saved from their style again.
|
||||
pub(super) fn regen_dims(d: &mut cadcraft_doc::Drawing, uses: impl Fn(&cadcraft_doc::Dimension) -> bool) -> Result<()> {
|
||||
let stale = |e: &cadcraft_doc::Entity| matches!(&e.kind, EntityKind::Dimension(dm) if dm.block.is_some() && uses(dm));
|
||||
let regen = |e: &mut cadcraft_doc::Entity| {
|
||||
if let EntityKind::Dimension(dm) = &mut e.kind {
|
||||
dm.block = None;
|
||||
}
|
||||
};
|
||||
let mut hs: Vec<cadcraft_doc::Handle> = d.model.iter().filter(|e| stale(e)).map(|e| e.handle).collect();
|
||||
hs.extend(d.layouts.iter().flat_map(|l| l.entities.iter().filter(|e| stale(e)).map(|e| e.handle)));
|
||||
for h in hs {
|
||||
d.modify_entity(h, regen)?;
|
||||
}
|
||||
for block in d.blocks.values_mut() {
|
||||
let hs: Vec<cadcraft_doc::Handle> = block.entities.iter().filter(|e| stale(e)).map(|e| e.handle).collect();
|
||||
if !hs.is_empty() {
|
||||
let b = std::sync::Arc::make_mut(block);
|
||||
for h in hs {
|
||||
b.entities.modify(h, regen);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The text style a dimension's text is drawn with: its DIMTXSTY override, else its style's
|
||||
/// (`text_style_of`: lower-case dimension style name → text style).
|
||||
fn dim_text_style(dm: &cadcraft_doc::Dimension, text_style_of: &std::collections::HashMap<String, String>) -> String {
|
||||
let own = dm.overrides.iter().find(|(k, _)| cadcraft_doc::DimStyle::field_name(k) == Some("textStyle")).and_then(|(_, v)| v.as_str());
|
||||
own.map(str::to_string).or_else(|| text_style_of.get(&dm.style.to_ascii_lowercase()).cloned()).unwrap_or_else(|| "Standard".into())
|
||||
}
|
||||
|
||||
/// Whether a dimension override `k: v` names text style `style`.
|
||||
fn is_text_style_override(k: &str, v: &Value, style: &str) -> bool {
|
||||
cadcraft_doc::DimStyle::field_name(k) == Some("textStyle") && v.as_str().is_some_and(|n| n.eq_ignore_ascii_case(style))
|
||||
}
|
||||
|
||||
fn dims_using(d: &cadcraft_doc::Drawing, name: &str) -> Vec<(cadcraft_doc::Space, cadcraft_doc::Handle)> {
|
||||
let mut out = Vec::new();
|
||||
for space in std::iter::once(cadcraft_doc::Space::Model).chain(d.layouts.iter().map(|l| cadcraft_doc::Space::Paper(l.name.clone()))) {
|
||||
@@ -1052,6 +784,7 @@ fn block_dims_using(d: &cadcraft_doc::Drawing, name: &str) -> Vec<(String, cadcr
|
||||
fn run_dimstyle_rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let from = str_param(p, "from").ok_or_else(|| bad("dimstyle.rename", "`from` is required"))?.to_string();
|
||||
let to = str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("dimstyle.rename", "`to` is required"))?.to_string();
|
||||
let to = super::dimstyle_cli::check_name(&to).map_err(|_| bad("dimstyle.rename", "bad style name"))?;
|
||||
let d = s.doc_mut()?;
|
||||
if from.eq_ignore_ascii_case("Standard") {
|
||||
return Err(bad("dimstyle.rename", "the Standard style cannot be renamed"));
|
||||
|
||||
@@ -0,0 +1,781 @@
|
||||
//! `properties.set`: change properties of the selected objects, the way the Properties palette
|
||||
//! edits them. Keys that no selected object takes come back in `ignored`.
|
||||
|
||||
use std::collections::{BTreeSet, HashMap};
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{
|
||||
AnnoScale, Arc, Circle, DimStyle, Dimension, Drawing, Entity, EntityKind, HAlign, Handle, Hatch, Insert, Line, Lineweight, MText, Text,
|
||||
Transparency, VAlign,
|
||||
};
|
||||
use cadcraft_geom::{Vec2, Vec3};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::{parse_color, parse_transparency};
|
||||
use crate::cmd::{bad, point_value, str_param, targets};
|
||||
use crate::properties::{LINE_PITCH, is_dim_linetype, join_post, split_post};
|
||||
use crate::{Result, Session};
|
||||
|
||||
fn set_xy(p: &mut Vec3, v: &Value) {
|
||||
if let Some(q) = point_value(v) {
|
||||
p.x = q.x;
|
||||
p.y = q.y;
|
||||
}
|
||||
}
|
||||
|
||||
/// Keys `properties.set` handles itself; the rest that name a dimension style variable (a field
|
||||
/// such as `textHeight` or a DIM* name such as `DIMTXT`) set per-dimension overrides.
|
||||
const SET_KEYS: &[&str] = &[
|
||||
"handles",
|
||||
"handle",
|
||||
"layer",
|
||||
"color",
|
||||
"linetype",
|
||||
"lineweight",
|
||||
"ltscale",
|
||||
"thickness",
|
||||
"transparency",
|
||||
"visible",
|
||||
"annotative",
|
||||
"dimStyle",
|
||||
"textOverride",
|
||||
"textRotation",
|
||||
"textPositionX",
|
||||
"textPositionY",
|
||||
"clearOverrides",
|
||||
"clear",
|
||||
"prefix",
|
||||
"suffix",
|
||||
"altPrefix",
|
||||
"altSuffix",
|
||||
// An insert's or hatch's scale; a dimension's overall scale is `dimScale` (or DIMSCALE).
|
||||
"scale",
|
||||
];
|
||||
|
||||
/// The dimension style variables of a call, checked once: canonical field names with their
|
||||
/// values, and the keys they were given as. Unusable values are left out (and so `ignored`).
|
||||
struct DimVars {
|
||||
fields: Vec<(&'static str, Value)>,
|
||||
keys: Vec<String>,
|
||||
}
|
||||
|
||||
impl DimVars {
|
||||
fn new(d: &Drawing, p: &Value) -> Result<Self> {
|
||||
// Text height, arrow size, overall scale (`dimScale`) and precision are refused, not
|
||||
// ignored, when unusable, and the last two have names of their own (#1473).
|
||||
let checked = super::dim_overrides(p)?;
|
||||
let mut given = serde_json::Map::new();
|
||||
for (k, v) in p.as_object().into_iter().flatten() {
|
||||
if SET_KEYS.contains(&k.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let Some(field) = DimStyle::field_name(k).filter(|f| !matches!(*f, "name" | "annotative")) else { continue };
|
||||
let v = match (field, v.as_str()) {
|
||||
// A text style or linetype that doesn't exist would fall back without a word.
|
||||
("textStyle", Some(n)) => {
|
||||
json!(d.text_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("text style `{n}` not found")))?)
|
||||
}
|
||||
(f, Some(n)) if is_dim_linetype(f) => {
|
||||
if n.is_empty() || n.eq_ignore_ascii_case("ByBlock") {
|
||||
json!("")
|
||||
} else {
|
||||
json!(d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))?)
|
||||
}
|
||||
}
|
||||
// Closed filled is `""` among the arrowheads, but an empty per-end arrowhead draws
|
||||
// DIMBLK's: chosen for one end, it's named.
|
||||
("arrowBlock1" | "arrowBlock2", Some("")) => json!("_CLOSEDFILLED"),
|
||||
_ => v.clone(),
|
||||
};
|
||||
given.insert(k.clone(), v);
|
||||
}
|
||||
let rejected = DimStyle::default().apply_fields(&given);
|
||||
let mut out = DimVars { fields: Vec::new(), keys: Vec::new() };
|
||||
for (k, v) in given {
|
||||
if rejected.contains(&k) {
|
||||
continue;
|
||||
}
|
||||
if let Some(f) = DimStyle::field_name(&k) {
|
||||
out.fields.push((f, v));
|
||||
out.keys.push(k);
|
||||
}
|
||||
}
|
||||
for (key, field) in [("dimScale", "scale"), ("precision", "decimals")] {
|
||||
if let Some(v) = checked.get(field) {
|
||||
out.fields.push((field, v.clone()));
|
||||
out.keys.push(key.to_string());
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
}
|
||||
|
||||
/// What some edits need to know about objects before they change.
|
||||
#[derive(Default)]
|
||||
struct Prepared {
|
||||
/// TEXT made aligned or fit: where its baseline ends (its width along its rotation).
|
||||
ends: HashMap<Handle, Vec2>,
|
||||
/// Dimensions: where their text is drawn now.
|
||||
text_pos: HashMap<Handle, Vec2>,
|
||||
/// The DIMPOST and DIMAPOST templates of each dimension style (by lowercase name), when a
|
||||
/// prefix or suffix is edited: a dimension's are worked out after its other edits.
|
||||
posts: Option<HashMap<String, (String, String)>>,
|
||||
}
|
||||
|
||||
impl Prepared {
|
||||
fn new(d: &Drawing, p: &Value, hs: &[Handle]) -> Self {
|
||||
let mut out = Prepared::default();
|
||||
let two_points = str_param(p, "justify").and_then(crate::cmd::draw::justify).is_some_and(|(h, _)| matches!(h, HAlign::Aligned | HAlign::Fit));
|
||||
let moves_text = p.get("textPositionX").is_some() || p.get("textPositionY").is_some();
|
||||
let posts = ["prefix", "suffix", "altPrefix", "altSuffix"].iter().any(|k| p.get(*k).is_some());
|
||||
if !(two_points || moves_text || posts) {
|
||||
return out;
|
||||
}
|
||||
for h in hs {
|
||||
let Some(e) = d.entity(*h) else { continue };
|
||||
match &e.kind {
|
||||
EntityKind::Text(t) if two_points => {
|
||||
// The text as this call leaves it: its contents, style, height, width factor
|
||||
// and rotation, where the call sets them too.
|
||||
let num = |k: &str| p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite());
|
||||
let style = str_param(p, "style").and_then(|n| d.text_style(n)).map_or(t.style.as_str(), |s| s.name.as_str());
|
||||
let value = str_param(p, "text").unwrap_or(&t.value);
|
||||
let height = num("height").filter(|x| *x > 0.0).unwrap_or(t.height);
|
||||
let width_factor = num("widthFactor").filter(|x| *x > 0.0).unwrap_or(t.width_factor);
|
||||
let rotation = num("rotation").map_or(t.rotation, f64::to_radians);
|
||||
let font = cadcraft_fonts::TextFont::resolve(&d.text_style(style).cloned().unwrap_or_default().font);
|
||||
let w = cadcraft_fonts::text_width(&font, value, height, width_factor);
|
||||
let w = if w.is_finite() && w > 1e-9 { w } else { height.max(1e-9) };
|
||||
out.ends.insert(*h, Vec2::polar(t.justify_point(), w, rotation));
|
||||
}
|
||||
EntityKind::Dimension(dm) if moves_text => {
|
||||
out.text_pos.insert(*h, cadcraft_render::dimension_in(d, dm).text_pos);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if posts {
|
||||
out.posts = Some(d.dim_styles.iter().map(|st| (st.name.to_ascii_lowercase(), (st.post.clone(), st.alt_post.clone()))).collect());
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// Give TEXT a justification. It keeps the point it is placed by, so the text moves (as
|
||||
/// AutoCAD's Properties Justify does); aligned and fit text then ends at `end`.
|
||||
fn set_justify(t: &mut Text, h: HAlign, v: VAlign, end: Option<Vec2>) {
|
||||
let at = t.justify_point();
|
||||
let z = t.insert.z;
|
||||
let was_two_points = matches!(t.halign, HAlign::Aligned | HAlign::Fit) && t.align_pt.is_some();
|
||||
let two_points = matches!(h, HAlign::Aligned | HAlign::Fit);
|
||||
t.halign = h;
|
||||
t.valign = if two_points { VAlign::Baseline } else { v };
|
||||
if two_points {
|
||||
// Between aligned and fit the two points stay.
|
||||
if !was_two_points {
|
||||
t.insert = at.to3(z);
|
||||
t.align_pt = Some(end.unwrap_or_else(|| Vec2::polar(at, t.height.max(1e-9), t.rotation)).to3(z));
|
||||
}
|
||||
} else if (h, v) == (HAlign::Left, VAlign::Baseline) {
|
||||
t.insert = at.to3(z);
|
||||
t.align_pt = None;
|
||||
} else {
|
||||
t.insert = at.to3(z);
|
||||
t.align_pt = Some(at.to3(z));
|
||||
}
|
||||
}
|
||||
|
||||
/// Move TEXT by `d` (both of its points).
|
||||
fn shift(t: &mut Text, d: Vec2) {
|
||||
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
|
||||
q.x += d.x;
|
||||
q.y += d.y;
|
||||
}
|
||||
}
|
||||
|
||||
/// Set a per-dimension override, replacing the same variable under another spelling (a DIM*
|
||||
/// name read from a file).
|
||||
fn set_override(dm: &mut cadcraft_doc::Dimension, field: &'static str, v: Value) {
|
||||
dm.overrides.retain(|k, _| DimStyle::field_name(k) != Some(field));
|
||||
dm.overrides.insert(field.to_string(), v);
|
||||
}
|
||||
|
||||
/// A `properties.set` call, checked before any object changes: the values every object takes,
|
||||
/// and what the edits need to know beforehand.
|
||||
struct Call<'a> {
|
||||
p: &'a Value,
|
||||
color: Option<Color>,
|
||||
transparency: Option<Transparency>,
|
||||
thickness: Option<f64>,
|
||||
lineweight: Option<Lineweight>,
|
||||
linetype: Option<String>,
|
||||
dim_style: Option<String>,
|
||||
text_style: Option<String>,
|
||||
dim_vars: DimVars,
|
||||
prep: Prepared,
|
||||
anno_scale: AnnoScale,
|
||||
}
|
||||
|
||||
/// The keys some object took.
|
||||
type Used<'c> = BTreeSet<&'c str>;
|
||||
|
||||
impl Call<'_> {
|
||||
/// A finite number under `k`.
|
||||
fn num(&self, k: &str) -> Option<f64> {
|
||||
self.p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite())
|
||||
}
|
||||
}
|
||||
|
||||
/// The objects `properties.set` leaves alone, as CHPROP, MATCHPROP and MOVE do: those on locked
|
||||
/// layers and, while a reference is edited in place, those outside the working set.
|
||||
#[derive(Default)]
|
||||
struct LeftOut {
|
||||
locked: usize,
|
||||
outside: usize,
|
||||
}
|
||||
|
||||
impl LeftOut {
|
||||
/// `hs` without the objects that can't be edited, each object once, and how many those were. A
|
||||
/// handle that names no object is an error, before anything changes.
|
||||
fn split(s: &Session, hs: Vec<Handle>) -> Result<(Vec<Handle>, LeftOut)> {
|
||||
let d = s.doc()?;
|
||||
// The working set, once: `RefEdit::is_working` searches a list.
|
||||
let working: Option<std::collections::HashSet<Handle>> = d.refedit.as_ref().map(|r| r.items.iter().map(|i| i.copy).collect());
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
let mut out = LeftOut::default();
|
||||
let mut free = Vec::new();
|
||||
for h in hs {
|
||||
let Some(e) = d.entity(h) else {
|
||||
return Err(cadcraft_doc::DocError::NoEntity(h).into());
|
||||
};
|
||||
if !seen.insert(h) {
|
||||
continue;
|
||||
}
|
||||
if working.as_ref().is_some_and(|w| !w.contains(&h)) {
|
||||
out.outside += 1;
|
||||
} else if d.layer(&e.common.layer).is_some_and(|l| l.locked) {
|
||||
out.locked += 1;
|
||||
} else {
|
||||
free.push(h);
|
||||
}
|
||||
}
|
||||
Ok((free, out))
|
||||
}
|
||||
|
||||
/// `{changed, locked, ignored}`, and a message saying how many were left out when any were.
|
||||
fn result(&self, changed: usize, ignored: &[&str]) -> Value {
|
||||
let mut notes = Vec::new();
|
||||
match self.locked {
|
||||
0 => {}
|
||||
1 => notes.push("1 object was on a locked layer.".to_string()),
|
||||
n => notes.push(format!("{n} objects were on a locked layer.")),
|
||||
}
|
||||
match self.outside {
|
||||
0 => {}
|
||||
1 => notes.push("1 object was not in the working set.".to_string()),
|
||||
n => notes.push(format!("{n} objects were not in the working set.")),
|
||||
}
|
||||
if changed == 0 && !notes.is_empty() {
|
||||
notes.push("Nothing was changed.".to_string());
|
||||
}
|
||||
let mut r = json!({ "changed": changed, "locked": self.locked + self.outside, "ignored": ignored });
|
||||
if !notes.is_empty()
|
||||
&& let Some(o) = r.as_object_mut()
|
||||
{
|
||||
o.insert("message".into(), json!(notes.join(" ")));
|
||||
}
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let hs = targets(s, p)?;
|
||||
if hs.is_empty() {
|
||||
return Err(bad("properties.set", "nothing selected"));
|
||||
}
|
||||
let (hs, left_out) = LeftOut::split(s, hs)?;
|
||||
let color = p.get("color").map(|c| parse_color(c).ok_or_else(|| bad("properties.set", "bad colour"))).transpose()?;
|
||||
let transparency = p
|
||||
.get("transparency")
|
||||
.map(|v| parse_transparency(v).ok_or_else(|| bad("properties.set", "transparency must be ByLayer, ByBlock or a percentage from 0 to 90")))
|
||||
.transpose()?;
|
||||
let thickness = p
|
||||
.get("thickness")
|
||||
.map(|v| v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("properties.set", "thickness must be a finite number")))
|
||||
.transpose()?;
|
||||
let lineweight =
|
||||
p.get("lineweight").map(|v| crate::cmd::layer::parse_lw(v).ok_or_else(|| bad("properties.set", "bad lineweight"))).transpose()?;
|
||||
// Every check reads the drawing first: a refused call leaves no empty undo step.
|
||||
let d = s.doc()?;
|
||||
// An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
|
||||
let linetype = str_param(p, "linetype")
|
||||
.map(|n| {
|
||||
if n.eq_ignore_ascii_case("ByLayer") || n.eq_ignore_ascii_case("ByBlock") {
|
||||
Ok(n.to_string())
|
||||
} else {
|
||||
d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))
|
||||
}
|
||||
})
|
||||
.transpose()?;
|
||||
let dim_style = str_param(p, "dimStyle")
|
||||
.map(|n| d.dim_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("dimension style `{n}` not found"))))
|
||||
.transpose()?;
|
||||
let text_style = str_param(p, "style")
|
||||
.map(|n| d.text_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("text style `{n}` not found"))))
|
||||
.transpose()?;
|
||||
let dim_vars = DimVars::new(d, p)?;
|
||||
// A pattern must be one each hatch can take, as HATCHEDIT refuses others.
|
||||
if let Some(v) = str_param(p, "pattern").filter(|v| !v.trim().is_empty())
|
||||
&& hs.iter().any(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Hatch(x)) if !crate::cmd::hatch::takes_pattern(x, v)))
|
||||
{
|
||||
return Err(bad("properties.set", format!("unknown pattern {}", v.trim().to_ascii_uppercase())));
|
||||
}
|
||||
if hs.is_empty() {
|
||||
// Every object was left out: the drawing stays as it was, with no undo step.
|
||||
return Ok(left_out.result(0, &[]));
|
||||
}
|
||||
let prep = Prepared::new(d, p, &hs);
|
||||
let anno_scale = d.current_anno_scale();
|
||||
let c = Call { p, color, transparency, thickness, lineweight, linetype, dim_style, text_style, dim_vars, prep, anno_scale };
|
||||
// A failed call changes nothing (a command's error doesn't undo what it did), so the drawing
|
||||
// is taken for writing, and the layer made, only after every check.
|
||||
let d = s.doc_mut()?;
|
||||
if let Some(l) = str_param(p, "layer") {
|
||||
d.ensure_layer(l);
|
||||
}
|
||||
let mut used = Used::new();
|
||||
for h in &hs {
|
||||
let h = *h;
|
||||
d.modify_entity(h, |e| {
|
||||
common(e, &c, &mut used);
|
||||
match &mut e.kind {
|
||||
EntityKind::Line(l) => line(l, &c, &mut used),
|
||||
EntityKind::Circle(ci) => circle(ci, &c, &mut used),
|
||||
EntityKind::Arc(a) => arc(a, &c, &mut used),
|
||||
EntityKind::Text(t) => {
|
||||
text(t, &c, h, &mut used);
|
||||
text_position(t, &c, &mut used);
|
||||
}
|
||||
EntityKind::MText(t) => mtext(t, &c, &mut used),
|
||||
EntityKind::MLeader(m) => mleader(m, &c, &mut used),
|
||||
EntityKind::LwPolyline(pl) => {
|
||||
if let Some(x) = c.num("width").filter(|x| *x >= 0.0) {
|
||||
pl.const_width = x;
|
||||
used.insert("width");
|
||||
}
|
||||
if let Some(closed) = p.get("closed").and_then(Value::as_bool) {
|
||||
pl.closed = closed;
|
||||
used.insert("closed");
|
||||
}
|
||||
}
|
||||
EntityKind::Insert(i) => insert(i, &c, &mut used),
|
||||
EntityKind::Dimension(dm) => dimension(dm, &c, h, &mut used),
|
||||
EntityKind::Hatch(ha) => hatch(ha, &c, &mut used),
|
||||
_ => {}
|
||||
}
|
||||
})?;
|
||||
}
|
||||
let ignored: Vec<&str> = p
|
||||
.as_object()
|
||||
.map(|o| o.keys().map(String::as_str).filter(|k| !matches!(*k, "handles" | "handle") && !used.contains(k)).collect())
|
||||
.unwrap_or_default();
|
||||
Ok(left_out.result(hs.len(), &ignored))
|
||||
}
|
||||
|
||||
/// A multileader's text: its contents (#1081) and height.
|
||||
fn mleader<'c>(m: &mut cadcraft_doc::MLeader, c: &'c Call<'_>, used: &mut Used<'c>) {
|
||||
let Some(t) = &mut m.text else { return };
|
||||
if let Some(v) = str_param(c.p, "text") {
|
||||
t.contents = v.replace('\n', "\\P");
|
||||
used.insert("text");
|
||||
}
|
||||
if let Some(x) = c.num("height").filter(|x| *x > 0.0) {
|
||||
t.height = x;
|
||||
used.insert("height");
|
||||
}
|
||||
}
|
||||
|
||||
/// The properties every object has: annotative, layer, color, linetype, lineweight, linetype
|
||||
/// scale, transparency, thickness and visibility.
|
||||
fn common<'c>(e: &mut Entity, c: &'c Call<'_>, used: &mut Used<'c>) {
|
||||
let p = c.p;
|
||||
// Annotative: Yes supports the current annotation scale; No drops every scale.
|
||||
if let Some(a) = p.get("annotative").and_then(Value::as_bool)
|
||||
&& cadcraft_doc::can_be_annotative(&e.kind)
|
||||
{
|
||||
cadcraft_doc::set_annotative(e, a, &c.anno_scale);
|
||||
if let EntityKind::Dimension(dm) = &mut e.kind {
|
||||
dm.block = None;
|
||||
}
|
||||
used.insert("annotative");
|
||||
}
|
||||
if let Some(l) = str_param(p, "layer") {
|
||||
e.common.layer = l.to_string();
|
||||
used.insert("layer");
|
||||
}
|
||||
if let Some(color) = c.color {
|
||||
e.common.color = color;
|
||||
used.insert("color");
|
||||
}
|
||||
if let Some(lt) = &c.linetype {
|
||||
e.common.linetype.clone_from(lt);
|
||||
used.insert("linetype");
|
||||
}
|
||||
if let Some(w) = c.lineweight {
|
||||
e.common.lineweight = w;
|
||||
used.insert("lineweight");
|
||||
}
|
||||
if let Some(x) = p.get("ltscale").and_then(Value::as_f64).filter(|x| *x > 0.0 && x.is_finite()) {
|
||||
e.common.ltscale = x;
|
||||
used.insert("ltscale");
|
||||
}
|
||||
if let Some(t) = c.transparency {
|
||||
e.common.transparency = t;
|
||||
used.insert("transparency");
|
||||
}
|
||||
if let Some(th) = c.thickness {
|
||||
e.common.thickness = th;
|
||||
used.insert("thickness");
|
||||
}
|
||||
if let Some(v) = p.get("visible").and_then(Value::as_bool) {
|
||||
e.common.visible = v;
|
||||
used.insert("visible");
|
||||
}
|
||||
}
|
||||
|
||||
fn line(l: &mut Line, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
if let Some(v) = c.p.get("start") {
|
||||
set_xy(&mut l.a, v);
|
||||
used.insert("start");
|
||||
}
|
||||
if let Some(v) = c.p.get("end") {
|
||||
set_xy(&mut l.b, v);
|
||||
used.insert("end");
|
||||
}
|
||||
// Length / angle keep the start point and move the end point.
|
||||
let (a, b) = (l.a.xy(), l.b.xy());
|
||||
let length = c.num("length").filter(|x| *x > 0.0 && *x < 1e15);
|
||||
let len = length.unwrap_or_else(|| a.dist(b));
|
||||
let ang = c.num("angle").map(f64::to_radians).unwrap_or_else(|| a.angle_to(b));
|
||||
if length.is_some() || c.num("angle").is_some() {
|
||||
let e = Vec2::polar(a, len, ang);
|
||||
if e.is_finite() {
|
||||
l.b.x = e.x;
|
||||
l.b.y = e.y;
|
||||
if length.is_some() {
|
||||
used.insert("length");
|
||||
}
|
||||
if c.num("angle").is_some() {
|
||||
used.insert("angle");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn circle(ci: &mut Circle, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
if let Some(v) = c.p.get("center") {
|
||||
set_xy(&mut ci.center, v);
|
||||
used.insert("center");
|
||||
}
|
||||
if let Some(r) = c.num("radius").filter(|r| *r > 0.0) {
|
||||
ci.radius = r;
|
||||
used.insert("radius");
|
||||
}
|
||||
if let Some(dm) = c.num("diameter").filter(|r| *r > 0.0) {
|
||||
ci.radius = dm / 2.0;
|
||||
used.insert("diameter");
|
||||
}
|
||||
if let Some(cf) = c.num("circumference").filter(|x| *x > 0.0) {
|
||||
ci.radius = cf / cadcraft_geom::TAU;
|
||||
used.insert("circumference");
|
||||
}
|
||||
if let Some(a) = c.num("area").filter(|x| *x > 0.0) {
|
||||
ci.radius = (a / cadcraft_geom::PI).sqrt();
|
||||
used.insert("area");
|
||||
}
|
||||
}
|
||||
|
||||
fn arc(a: &mut Arc, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
if let Some(v) = c.p.get("center") {
|
||||
set_xy(&mut a.center, v);
|
||||
used.insert("center");
|
||||
}
|
||||
if let Some(r) = c.num("radius").filter(|r| *r > 0.0) {
|
||||
a.radius = r;
|
||||
used.insert("radius");
|
||||
}
|
||||
if let Some(x) = c.num("startAngle") {
|
||||
a.start = cadcraft_geom::norm_angle(x.to_radians());
|
||||
used.insert("startAngle");
|
||||
}
|
||||
if let Some(x) = c.num("endAngle") {
|
||||
a.end = cadcraft_geom::norm_angle(x.to_radians());
|
||||
used.insert("endAngle");
|
||||
}
|
||||
}
|
||||
|
||||
/// TEXT's contents, style, size, angles and justification.
|
||||
fn text(t: &mut Text, c: &Call<'_>, h: Handle, used: &mut Used<'_>) {
|
||||
let p = c.p;
|
||||
if let Some(v) = str_param(p, "text") {
|
||||
t.value = v.to_string();
|
||||
used.insert("text");
|
||||
}
|
||||
if let Some(st) = &c.text_style {
|
||||
t.style.clone_from(st);
|
||||
used.insert("style");
|
||||
}
|
||||
if let Some(x) = c.num("height").filter(|x| *x > 0.0) {
|
||||
t.height = x;
|
||||
used.insert("height");
|
||||
}
|
||||
if let Some(x) = c.num("rotation") {
|
||||
t.rotation = x.to_radians();
|
||||
// Aligned and fit text run along their baseline's two ends: it turns too.
|
||||
if matches!(t.halign, HAlign::Aligned | HAlign::Fit)
|
||||
&& let Some(end) = t.align_pt
|
||||
{
|
||||
let e = Vec2::polar(t.insert.xy(), t.insert.xy().dist(end.xy()), t.rotation);
|
||||
t.align_pt = Some(Vec3::new(e.x, e.y, end.z));
|
||||
}
|
||||
used.insert("rotation");
|
||||
}
|
||||
if let Some(x) = c.num("widthFactor").filter(|x| *x > 0.0) {
|
||||
t.width_factor = x;
|
||||
used.insert("widthFactor");
|
||||
}
|
||||
if let Some(x) = c.num("oblique").filter(|x| x.abs() <= 85.0) {
|
||||
t.oblique = x.to_radians();
|
||||
used.insert("oblique");
|
||||
}
|
||||
if let Some((ha, va)) = str_param(p, "justify").and_then(crate::cmd::draw::justify) {
|
||||
set_justify(t, ha, va, c.prep.ends.get(&h).copied());
|
||||
used.insert("justify");
|
||||
}
|
||||
}
|
||||
|
||||
/// Where TEXT is: its position (the point it's placed by), and an aligned or fit text's second
|
||||
/// point.
|
||||
fn text_position(t: &mut Text, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
// The position is the point the text is placed by: moving it moves the text.
|
||||
if let Some(to) = c.p.get("position").and_then(point_value) {
|
||||
shift(t, to - t.justify_point());
|
||||
used.insert("position");
|
||||
}
|
||||
let (x, y) = (c.num("positionX"), c.num("positionY"));
|
||||
if x.is_some() || y.is_some() {
|
||||
let at = t.justify_point();
|
||||
shift(t, Vec2::new(x.unwrap_or(at.x), y.unwrap_or(at.y)) - at);
|
||||
used.extend(["positionX", "positionY"].into_iter().filter(|k| c.num(k).is_some()));
|
||||
}
|
||||
if let Some(z) = c.num("positionZ") {
|
||||
t.insert.z = z;
|
||||
if let Some(a) = &mut t.align_pt {
|
||||
a.z = z;
|
||||
}
|
||||
used.insert("positionZ");
|
||||
}
|
||||
// Aligned and fit text: the second point alone (the text refits between them).
|
||||
if matches!(t.halign, HAlign::Aligned | HAlign::Fit)
|
||||
&& let Some(a) = &mut t.align_pt
|
||||
{
|
||||
if let Some(x) = c.num("alignmentX") {
|
||||
a.x = x;
|
||||
used.insert("alignmentX");
|
||||
}
|
||||
if let Some(y) = c.num("alignmentY") {
|
||||
a.y = y;
|
||||
used.insert("alignmentY");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mtext(t: &mut MText, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
let p = c.p;
|
||||
if let Some(v) = str_param(p, "text") {
|
||||
t.contents = v.replace('\n', "\\P");
|
||||
used.insert("text");
|
||||
}
|
||||
if let Some(st) = &c.text_style {
|
||||
t.style.clone_from(st);
|
||||
used.insert("style");
|
||||
}
|
||||
if let Some(x) = c.num("height").filter(|x| *x > 0.0) {
|
||||
t.height = x;
|
||||
used.insert("height");
|
||||
}
|
||||
if let Some(x) = c.num("width").filter(|x| *x >= 0.0) {
|
||||
t.width = x;
|
||||
used.insert("width");
|
||||
}
|
||||
if let Some(x) = c.num("rotation") {
|
||||
t.rotation = x.to_radians();
|
||||
used.insert("rotation");
|
||||
}
|
||||
// The attachment point stays where it is; the text moves around it.
|
||||
if let Some(n) = str_param(p, "justify").and_then(crate::cmd::mtext_opts::attach_code) {
|
||||
t.attach = n;
|
||||
used.insert("justify");
|
||||
}
|
||||
mtext_spacing(t, c, used);
|
||||
if let Some(to) = p.get("position").and_then(point_value) {
|
||||
t.insert.x = to.x;
|
||||
t.insert.y = to.y;
|
||||
used.insert("position");
|
||||
}
|
||||
for (k, slot) in [("positionX", &mut t.insert.x), ("positionY", &mut t.insert.y), ("positionZ", &mut t.insert.z)] {
|
||||
if let Some(v) = c.num(k) {
|
||||
*slot = v;
|
||||
used.insert(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// MTEXT's line spacing: a factor, a distance, or its style.
|
||||
fn mtext_spacing(t: &mut MText, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
// MTEXT's Line spacing option takes factors from 0.25 to 4.
|
||||
let factor = |f: f64| f.is_finite() && (0.25 - 1e-9..=4.0 + 1e-9).contains(&f);
|
||||
if let Some(x) = c.num("lineSpacing").filter(|x| factor(*x)) {
|
||||
t.line_spacing = x;
|
||||
used.insert("lineSpacing");
|
||||
}
|
||||
if let Some(f) = c.num("lineSpacingDistance").map(|x| x / (t.height * LINE_PITCH)).filter(|f| factor(*f)) {
|
||||
t.line_spacing = f;
|
||||
used.insert("lineSpacingDistance");
|
||||
}
|
||||
// "atLeast", "At least", "exactly"…
|
||||
let spacing = str_param(c.p, "lineSpacingStyle").map(|v| v.chars().filter(char::is_ascii_alphabetic).collect::<String>().to_ascii_lowercase());
|
||||
if let Some(exact) = match spacing.as_deref() {
|
||||
Some("atleast") => Some(false),
|
||||
Some("exactly") => Some(true),
|
||||
_ => None,
|
||||
} {
|
||||
t.line_spacing_exact = exact;
|
||||
used.insert("lineSpacingStyle");
|
||||
}
|
||||
}
|
||||
|
||||
fn insert(i: &mut Insert, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
if let Some(x) = c.num("rotation") {
|
||||
let turn = x.to_radians() - i.rotation;
|
||||
i.rotation = x.to_radians();
|
||||
// The attached text turns with the reference, around its insertion point (as ROTATE does).
|
||||
let base = i.insert.xy();
|
||||
for a in &mut i.attribs {
|
||||
let t = &mut a.text;
|
||||
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
|
||||
let r = q.xy().rotate_about(base, turn);
|
||||
q.x = r.x;
|
||||
q.y = r.y;
|
||||
}
|
||||
t.rotation = cadcraft_geom::norm_angle(t.rotation + turn);
|
||||
if let Some(ml) = &mut a.multiline {
|
||||
let r = ml.mtext.insert.xy().rotate_about(base, turn);
|
||||
ml.mtext.insert.x = r.x;
|
||||
ml.mtext.insert.y = r.y;
|
||||
ml.mtext.rotation = cadcraft_geom::norm_angle(ml.mtext.rotation + turn);
|
||||
}
|
||||
}
|
||||
used.insert("rotation");
|
||||
}
|
||||
if let Some(x) = c.num("scale").filter(|x| *x != 0.0) {
|
||||
// A new positive scale carries the attached attribute text with it, like SCALE about the insertion point.
|
||||
if x > 0.0 && i.scale.x > 0.0 {
|
||||
let m = cadcraft_geom::Mat3::scale_about(i.insert.xy(), x / i.scale.x);
|
||||
for a in &mut i.attribs {
|
||||
let mut k = EntityKind::Text(a.text.clone());
|
||||
k.transform(&m);
|
||||
if let EntityKind::Text(t) = k {
|
||||
a.text = t;
|
||||
}
|
||||
a.transform_multiline(&m);
|
||||
}
|
||||
}
|
||||
i.scale = Vec3::new(x, x, x);
|
||||
used.insert("scale");
|
||||
}
|
||||
}
|
||||
|
||||
fn dimension<'c>(dm: &mut Dimension, c: &'c Call<'_>, h: Handle, used: &mut Used<'c>) {
|
||||
let p = c.p;
|
||||
let before = dm.clone();
|
||||
if let Some(v) = str_param(p, "textOverride") {
|
||||
dm.text = v.to_string();
|
||||
used.insert("textOverride");
|
||||
}
|
||||
if let Some(st) = &c.dim_style {
|
||||
dm.style.clone_from(st);
|
||||
used.insert("dimStyle");
|
||||
}
|
||||
// Overrides: clear first, then set (as DIMOVERRIDE does).
|
||||
if p.get("clearOverrides").and_then(Value::as_bool) == Some(true) {
|
||||
dm.overrides.clear();
|
||||
used.insert("clearOverrides");
|
||||
}
|
||||
if let Some(names) = p.get("clear").and_then(Value::as_array) {
|
||||
// Prefix and suffix rows reset DIMPOST (DIMAPOST), the variable they're halves of.
|
||||
let field = |n: &str| match n {
|
||||
"prefix" | "suffix" => Some("post"),
|
||||
"altPrefix" | "altSuffix" => Some("altPost"),
|
||||
n => DimStyle::field_name(n),
|
||||
};
|
||||
for f in names.iter().filter_map(Value::as_str).filter_map(field) {
|
||||
dm.overrides.retain(|k, _| DimStyle::field_name(k) != Some(f));
|
||||
}
|
||||
used.insert("clear");
|
||||
}
|
||||
for (f, v) in &c.dim_vars.fields {
|
||||
set_override(dm, f, v.clone());
|
||||
}
|
||||
used.extend(c.dim_vars.keys.iter().map(String::as_str));
|
||||
if let Some(x) = c.num("textRotation") {
|
||||
dm.text_rotation = x.to_radians();
|
||||
used.insert("textRotation");
|
||||
}
|
||||
let (x, y) = (c.num("textPositionX"), c.num("textPositionY"));
|
||||
if x.is_some() || y.is_some() {
|
||||
let at = c.prep.text_pos.get(&h).copied().unwrap_or_else(|| dm.text_mid.xy());
|
||||
dm.text_mid.x = x.unwrap_or(at.x);
|
||||
dm.text_mid.y = y.unwrap_or(at.y);
|
||||
dm.user_text_pos = true;
|
||||
used.extend(["textPositionX", "textPositionY"].into_iter().filter(|k| c.num(k).is_some()));
|
||||
}
|
||||
dimension_posts(dm, c, used);
|
||||
// The geometry block read from a file no longer matches: draw and save it anew.
|
||||
if *dm != before {
|
||||
dm.block = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// A dimension's prefix and suffix edits, which go into the DIMPOST and DIMAPOST templates it
|
||||
/// draws with after the call's other edits (its style, cleared and new overrides).
|
||||
fn dimension_posts(dm: &mut Dimension, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
let Some(styles) = &c.prep.posts else { return };
|
||||
let (post, alt) = styles.get(&dm.style.to_ascii_lowercase()).cloned().unwrap_or_default();
|
||||
let st = DimStyle { post, alt_post: alt, ..DimStyle::default() }.with_overrides(&dm.overrides);
|
||||
for (field, template, keys) in [("post", &st.post, ["prefix", "suffix"]), ("altPost", &st.alt_post, ["altPrefix", "altSuffix"])] {
|
||||
let (pre, suf) = (str_param(c.p, keys[0]), str_param(c.p, keys[1]));
|
||||
if pre.is_some() || suf.is_some() {
|
||||
let (pre0, suf0) = split_post(template);
|
||||
set_override(dm, field, json!(join_post(pre.unwrap_or(&pre0), suf.unwrap_or(&suf0))));
|
||||
used.extend(keys.into_iter().filter(|k| str_param(c.p, k).is_some()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn hatch(ha: &mut Hatch, c: &Call<'_>, used: &mut Used<'_>) {
|
||||
// HATCHEDIT's pattern edit (a blank name changes nothing, so it's ignored).
|
||||
if let Some(v) = str_param(c.p, "pattern")
|
||||
&& crate::cmd::hatch::set_pattern(ha, v)
|
||||
{
|
||||
used.insert("pattern");
|
||||
}
|
||||
if let Some(x) = c.num("scale").filter(|x| *x > 0.0) {
|
||||
ha.scale = x;
|
||||
used.insert("scale");
|
||||
}
|
||||
if let Some(x) = c.num("angle") {
|
||||
ha.angle = x.to_radians();
|
||||
used.insert("angle");
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,7 @@ pub mod lisp;
|
||||
pub mod mtext_edit;
|
||||
pub mod pointmod;
|
||||
pub mod prompt;
|
||||
pub mod properties;
|
||||
mod recent;
|
||||
pub mod render_look;
|
||||
pub mod sample;
|
||||
@@ -85,6 +86,11 @@ pub struct Session {
|
||||
pub doc_epoch: u64,
|
||||
pub settings: Settings,
|
||||
pub running: Option<Running>,
|
||||
/// How many commands were started, nested transparent ones left out.
|
||||
pub commands_started: u64,
|
||||
/// The last command that ended by itself, not cancelled: its number in `commands_started`, and
|
||||
/// whether it took new handles (it added to the drawing, and nothing took that back).
|
||||
pub last_finished: Option<(u64, bool)>,
|
||||
/// A script is running ([`Session::script`]); a SCRIPT command inside it is refused.
|
||||
in_script: bool,
|
||||
/// The command suspended while a transparent command (`'ZOOM`, `'PAN`…) prompts inside it;
|
||||
@@ -176,6 +182,8 @@ impl Session {
|
||||
doc_epoch: 0,
|
||||
settings: Settings::default(),
|
||||
running: None,
|
||||
commands_started: 0,
|
||||
last_finished: None,
|
||||
in_script: false,
|
||||
suspended: None,
|
||||
log: Vec::new(),
|
||||
|
||||
@@ -5,10 +5,14 @@
|
||||
//! (`getpoint`, `pause`) and carry on later, so the interface keeps drawing while a routine
|
||||
//! waits. Each drawing has its own symbols, as in AutoCAD. A run is one undo step.
|
||||
|
||||
/// A block-definition entity and its successor in the block, by handle.
|
||||
pub type BlockSlots = HashMap<Handle, (Arc<cadcraft_doc::Entity>, Option<Handle>)>;
|
||||
|
||||
pub mod builtins;
|
||||
mod drawing;
|
||||
pub mod eval;
|
||||
pub mod input;
|
||||
mod objects;
|
||||
pub mod read;
|
||||
mod startup;
|
||||
pub mod value;
|
||||
@@ -54,13 +58,20 @@ pub struct Env {
|
||||
pub next_file: u32,
|
||||
/// Entities `entdel` deleted (it brings them back when called again), with their space.
|
||||
pub deleted: HashMap<Handle, (cadcraft_doc::Space, Arc<cadcraft_doc::Entity>)>,
|
||||
/// Every entity's handle in creation order, for the drawing it was taken from (`entnext`).
|
||||
pub order: Option<(usize, Arc<Vec<Handle>>)>,
|
||||
/// Every entity's handle in creation order (`entlast`, `entnext`), with clones of the spaces
|
||||
/// it was taken from (model space, then each layout): it is reused only while the drawing's
|
||||
/// spaces still share every chunk with them ([`cadcraft_doc::EntityStore::same_as`]).
|
||||
pub order: Option<(Vec<cadcraft_doc::EntityStore>, Arc<Vec<Handle>>)>,
|
||||
/// Each block-definition entity with its successor in its block (None for the last), for the drawing
|
||||
/// it was taken from: `entnext`'s indexed lookup, which also tells whether a handle is a block's.
|
||||
pub block_next: Option<(usize, Arc<BlockSlots>)>,
|
||||
/// `tblnext`'s place in each table.
|
||||
pub tblnext: HashMap<String, usize>,
|
||||
/// A block definition `entmake` has begun (a BLOCK list) and not yet ended (ENDBLK): the
|
||||
/// entities made meanwhile go into it, numbered when it ends.
|
||||
pub pending_block: Option<(cadcraft_doc::Block, Vec<cadcraft_doc::Entity>)>,
|
||||
/// Entity names of non-graphic objects (dictionaries, table records, layouts).
|
||||
pub(crate) objects: objects::Names,
|
||||
/// The command history's length after LISP last printed a line: when something else wrote since
|
||||
/// (a prompt, a command's echo), a leading newline only ends that line.
|
||||
pub printed_at: Option<usize>,
|
||||
@@ -77,8 +88,10 @@ impl Default for Env {
|
||||
next_file: 1,
|
||||
deleted: HashMap::new(),
|
||||
order: None,
|
||||
block_next: None,
|
||||
tblnext: HashMap::new(),
|
||||
pending_block: None,
|
||||
objects: objects::Names::default(),
|
||||
printed_at: None,
|
||||
};
|
||||
builtins::install(&mut e);
|
||||
@@ -207,8 +220,19 @@ impl Session {
|
||||
self.lisp.envs.remove(&uid).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Put a drawing's environment back, unless the drawing was closed meanwhile (a routine
|
||||
/// cancelled by CLOSE ends after its drawing went away).
|
||||
fn lisp_env_put(&mut self, uid: u64, env: Env) {
|
||||
self.lisp.envs.insert(uid, env);
|
||||
if uid == 0 || self.docs.iter().any(|d| d.uid == uid) {
|
||||
self.lisp.envs.insert(uid, env);
|
||||
}
|
||||
}
|
||||
|
||||
/// Drop the environments of drawings no longer open: one holds clones of its drawing's
|
||||
/// entity stores ([`Env::order`]), which would otherwise outlive the drawing.
|
||||
pub(crate) fn lisp_forget_closed(&mut self) {
|
||||
let docs = &self.docs;
|
||||
self.lisp.envs.retain(|uid, _| *uid == 0 || docs.iter().any(|d| d.uid == *uid));
|
||||
}
|
||||
|
||||
/// A routine is running (possibly waiting for input).
|
||||
@@ -451,7 +475,7 @@ impl Session {
|
||||
let steps = std::mem::take(&mut self.lisp.steps);
|
||||
let mut env = self.lisp.envs.remove(&run.uid).unwrap_or_default();
|
||||
self.lisp_flush(&mut env, true);
|
||||
self.lisp.envs.insert(run.uid, env);
|
||||
self.lisp_env_put(run.uid, env);
|
||||
if let (Ok(v), true) = (&result, run.print) {
|
||||
let text = value::to_text(v, true);
|
||||
if !builtins::is_null_symbol(v) {
|
||||
|
||||
@@ -234,3 +234,40 @@ fn a_definition_that_isnt_added_leaves_no_layer() {
|
||||
assert_eq!(ok(&mut s, ENDBLK), "\"EB\"");
|
||||
assert!(has(&s, "PARTS"), "the block's layer exists once it is added");
|
||||
}
|
||||
|
||||
/// entnext walks entmade block entities in order through the cached successor index, and a
|
||||
/// redefinition (same drawing, same block name) is not served from the stale index.
|
||||
#[test]
|
||||
fn entnext_walks_entmade_blocks_and_sees_a_redefinition() {
|
||||
let mut s = session();
|
||||
let walk = r#"(progn (setq e (cdr (assoc -2 (tblsearch "BLOCK" "EB"))) types nil)
|
||||
(while e (setq types (cons (cdr (assoc 0 (entget e))) types) e (entnext e)))
|
||||
(reverse types))"#;
|
||||
for code in [BLOCK_EB, LINE, CIRCLE, ENDBLK] {
|
||||
ok(&mut s, code);
|
||||
}
|
||||
assert_eq!(ok(&mut s, walk), "(\"LINE\" \"CIRCLE\")");
|
||||
assert_eq!(ok(&mut s, walk), "(\"LINE\" \"CIRCLE\")", "second walk from the cache");
|
||||
for code in [BLOCK_EB, CIRCLE, LINE, LINE, ENDBLK] {
|
||||
ok(&mut s, code);
|
||||
}
|
||||
assert_eq!(ok(&mut s, walk), "(\"CIRCLE\" \"LINE\" \"LINE\")");
|
||||
}
|
||||
|
||||
/// entget and handent reach every entity of an entmade block through the cached index, and a
|
||||
/// redefinition shows the new entities, not the old ones.
|
||||
#[test]
|
||||
fn entget_and_handent_reach_every_block_entity_also_after_a_redefinition() {
|
||||
let mut s = session();
|
||||
let walk = r#"(progn (setq e (cdr (assoc -2 (tblsearch "BLOCK" "EB"))) r nil)
|
||||
(while e (setq r (cons (list (cdr (assoc 0 (entget e))) (equal (handent (cdr (assoc 5 (entget e)))) e)) r) e (entnext e)))
|
||||
(reverse r))"#;
|
||||
for code in [BLOCK_EB, LINE, CIRCLE, LINE, ENDBLK] {
|
||||
ok(&mut s, code);
|
||||
}
|
||||
assert_eq!(ok(&mut s, walk), "((\"LINE\" T) (\"CIRCLE\" T) (\"LINE\" T))");
|
||||
for code in [BLOCK_EB, CIRCLE, ENDBLK] {
|
||||
ok(&mut s, code);
|
||||
}
|
||||
assert_eq!(ok(&mut s, walk), "((\"CIRCLE\" T))");
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@ use std::sync::Arc;
|
||||
|
||||
use super::eval::{Ctx, Flow, Special};
|
||||
use super::value::{Builtin, BuiltinKind, Sym, Value, charge_bytes, check_string_len, eq, equal, real_text, to_text};
|
||||
use super::{Env, LispError, drawing, input, read};
|
||||
use super::{Env, LispError, drawing, input, objects, read};
|
||||
|
||||
macro_rules! cxrs {
|
||||
($($name:ident $path:literal),*) => {
|
||||
@@ -262,6 +262,10 @@ static BUILTINS: &[Builtin] = &[
|
||||
ctx!("SSGETFIRST", drawing::ssgetfirst),
|
||||
ctx!("TBLSEARCH", drawing::tblsearch),
|
||||
ctx!("TBLNEXT", drawing::tblnext),
|
||||
ctx!("TBLOBJNAME", objects::tblobjname),
|
||||
ctx!("NAMEDOBJDICT", objects::namedobjdict),
|
||||
ctx!("DICTSEARCH", objects::dictsearch),
|
||||
ctx!("DICTNEXT", objects::dictnext),
|
||||
ctx!("RTOS", drawing::rtos),
|
||||
ctx!("ANGTOS", drawing::angtos),
|
||||
ctx!("DISTOF", drawing::distof),
|
||||
|
||||
@@ -126,9 +126,11 @@ fn write_text_file(path: &str, text: &str, append: bool) {
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn write_text_file(_path: &str, _text: &str, _append: bool) {}
|
||||
|
||||
/// A file or a folder: routines test whether a module is installed with `(findfile "module/.")`.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn file_exists(path: &str) -> bool {
|
||||
std::path::Path::new(path).is_file()
|
||||
let p = std::path::Path::new(path);
|
||||
p.is_file() || p.is_dir()
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
//! Drawing access from LISP: `command`, system variables, entity lists (`entget`, `entmake`,
|
||||
//! `entmod`, `entdel`, `entlast`, `entnext`, `handent`), selection sets (`ssget` and friends),
|
||||
//! `entmod`, `entdel`, `entlast`, `entnext`, `handent`; non-graphic objects are in
|
||||
//! [`super::objects`]), selection sets (`ssget` and friends),
|
||||
//! symbol tables (`tblsearch`, `tblnext`) and unit conversions (`rtos`, `angtos`, `distof`,
|
||||
//! `angtof`).
|
||||
//!
|
||||
@@ -7,19 +8,21 @@
|
||||
//! [`crate::cmd::file::entity_codec`]), so what `entget` shows is what a DXF file holds, except
|
||||
//! for angles, which are radians in a list and degrees in a file.
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use cadcraft_doc::{Entity, Handle, Space};
|
||||
use cadcraft_geom::Vec2;
|
||||
use craft_dxf::Tag;
|
||||
|
||||
use super::LispError;
|
||||
use super::builtins::args_err;
|
||||
use super::eval::{Ctx, Flow, Need};
|
||||
use super::value::{PickSet, Value, to_text};
|
||||
use super::{BlockSlots, LispError};
|
||||
use crate::{Input, Session};
|
||||
|
||||
fn arity(a: &[Value], min: usize, max: usize) -> Result<(), LispError> {
|
||||
pub(super) fn arity(a: &[Value], min: usize, max: usize) -> Result<(), LispError> {
|
||||
if a.len() < min {
|
||||
return Err(args_err(true));
|
||||
}
|
||||
@@ -29,14 +32,14 @@ fn arity(a: &[Value], min: usize, max: usize) -> Result<(), LispError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn ename(v: &Value) -> Result<Handle, LispError> {
|
||||
pub(super) fn ename(v: &Value) -> Result<Handle, LispError> {
|
||||
match v {
|
||||
Value::Ename(h) => Ok(*h),
|
||||
other => Err(LispError::bad_arg("lentityp", other)),
|
||||
}
|
||||
}
|
||||
|
||||
fn string(v: &Value) -> Result<String, LispError> {
|
||||
pub(super) fn string(v: &Value) -> Result<String, LispError> {
|
||||
match v {
|
||||
Value::Str(s) => Ok(s.to_string()),
|
||||
other => Err(LispError::bad_arg("stringp", other)),
|
||||
@@ -271,7 +274,7 @@ fn tag_value(t: &Tag) -> Value {
|
||||
}
|
||||
|
||||
/// DXF groups as an association list: points combined into lists `(10 x y z)`.
|
||||
fn groups_to_list(tags: &[Tag]) -> Vec<Value> {
|
||||
pub(super) fn groups_to_list(tags: &[Tag]) -> Vec<Value> {
|
||||
let mut out = Vec::new();
|
||||
let mut i = 0;
|
||||
while let Some(t) = tags.get(i) {
|
||||
@@ -356,8 +359,16 @@ fn space_of(d: &cadcraft_doc::Drawing, h: Handle) -> Option<Space> {
|
||||
pub fn entget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 1, 2)?;
|
||||
let h = ename(&a[0])?;
|
||||
let drawn = ctx.s.doc().is_ok_and(|d| d.entity(h).is_some());
|
||||
let from_block = if drawn { None } else { block_entity(ctx, h) };
|
||||
let Ok(d) = ctx.s.doc() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
let Some(e) = d.entity(h) else { return Ok(Flow::Value(Value::Nil)) };
|
||||
// An entity of a block definition (#1700) has no layout.
|
||||
let (e, in_block) = match (d.entity(h), &from_block) {
|
||||
(Some(e), _) => (e, false),
|
||||
(None, Some(e)) => (e, true),
|
||||
// Not an entity: a table record, layout or dictionary (#1659, #1661).
|
||||
(None, None) => return Ok(Flow::Value(super::objects::entget(ctx, h))),
|
||||
};
|
||||
let (kind, mut tags) = (codec()?.groups)(d, e);
|
||||
convert_angles(&kind, &mut tags, f64::to_radians);
|
||||
let layout = match space_of(d, h) {
|
||||
@@ -365,7 +376,7 @@ pub fn entget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
_ => "Model".into(),
|
||||
};
|
||||
let mut items = vec![Value::cons(Value::Int(-1), Value::Ename(h)), Value::cons(Value::Int(0), Value::str(&kind))];
|
||||
let mut placed_layout = false;
|
||||
let mut placed_layout = in_block;
|
||||
for v in groups_to_list(&tags) {
|
||||
// The layout name follows the AcDbEntity marker, as AutoCAD lists it.
|
||||
let after_marker = !placed_layout && v.car().as_number() == Some(100.0) && matches!(v.cdr(), Value::Str(ref s) if &**s == "AcDbEntity");
|
||||
@@ -493,6 +504,7 @@ fn end_block(ctx: &mut Ctx<'_>) -> Value {
|
||||
}
|
||||
let name = b.name.clone();
|
||||
d.blocks.insert(name.clone(), Arc::new(b));
|
||||
ctx.env.block_next = None;
|
||||
ctx.s.touch();
|
||||
Value::str(&name)
|
||||
}
|
||||
@@ -504,7 +516,7 @@ pub fn entmod(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
return Err(LispError::bad_arg("lentityp", &Value::Nil));
|
||||
};
|
||||
let Some(old) = ctx.s.doc().ok().and_then(|d| d.entity(h)).cloned() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
let (kind_name, common, kind) = match entity_from_list(ctx, list) {
|
||||
let (kind_name, common, mut kind) = match entity_from_list(ctx, list) {
|
||||
Ok(x) => x,
|
||||
Err(_) => return Ok(Flow::Value(Value::Nil)),
|
||||
};
|
||||
@@ -512,6 +524,13 @@ pub fn entmod(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
if !kind_name.eq_ignore_ascii_case(old.kind.dxf_name()) {
|
||||
return Ok(Flow::Value(Value::Nil));
|
||||
}
|
||||
// A block reference's attributes are entities of their own in AutoCAD, which entmod of the
|
||||
// INSERT leaves alone; its list doesn't hold them, so they are kept from the reference.
|
||||
if let (cadcraft_doc::EntityKind::Insert(new), cadcraft_doc::EntityKind::Insert(was)) = (&mut kind, &old.kind)
|
||||
&& new.attribs.is_empty()
|
||||
{
|
||||
new.attribs = was.attribs.clone();
|
||||
}
|
||||
let Ok(d) = ctx.s.doc_mut() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
d.ensure_layer(&common.layer);
|
||||
let ok = d
|
||||
@@ -557,24 +576,76 @@ pub fn entdel(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `b` holds the same handles as `a`, in the same chunks and order. A chunk `b` still shares
|
||||
/// with `a` (which is held, so its chunks stay alive) is the same; only a chunk an edit copied is
|
||||
/// compared handle by handle.
|
||||
fn same_handles(a: &cadcraft_doc::EntityStore, b: &cadcraft_doc::EntityStore) -> bool {
|
||||
if a.len() != b.len() {
|
||||
return false;
|
||||
}
|
||||
let (mut x, mut y) = (a.chunk_slices(), b.chunk_slices());
|
||||
loop {
|
||||
match (x.next(), y.next()) {
|
||||
(None, None) => return true,
|
||||
(Some((ka, sa)), Some((kb, sb))) => {
|
||||
if ka != kb && (sa.len() != sb.len() || sa.iter().zip(sb).any(|(p, q)| p.handle != q.handle)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
_ => return false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Every entity's handle in creation order (model space and layouts), cached per drawing.
|
||||
///
|
||||
/// The cache is keyed by content identity, as the spatial index is: it holds clones of the
|
||||
/// spaces it was taken from, so any edit (`entmake`, `entmod`, `entdel`, a command, undo) copies
|
||||
/// the chunk it touches and the cache no longer matches. The drawing's address is no key: an
|
||||
/// edit in place keeps it, and a new drawing can be given the address of a dropped one.
|
||||
fn handles_in_order(ctx: &mut Ctx<'_>) -> Arc<Vec<Handle>> {
|
||||
let Ok(d) = ctx.s.doc() else { return Arc::default() };
|
||||
let spaces = || std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities));
|
||||
if let Some((stores, v)) = &mut ctx.env.order
|
||||
&& stores.len() == 1 + d.layouts.len()
|
||||
&& stores.iter().zip(spaces()).all(|(a, b)| same_handles(a, b))
|
||||
{
|
||||
// An edit that left every handle in place (a property `entmod`) keeps the order: hold
|
||||
// the spaces as they are now, so the next call finds their chunks shared again.
|
||||
if !stores.iter().zip(spaces()).all(|(a, b)| a.same_as(b)) {
|
||||
*stores = spaces().cloned().collect();
|
||||
}
|
||||
return v.clone();
|
||||
}
|
||||
let mut v: Vec<Handle> = spaces().flat_map(|s| s.iter().map(|e| e.handle)).collect();
|
||||
v.sort_unstable();
|
||||
let v = Arc::new(v);
|
||||
ctx.env.order = Some((spaces().cloned().collect(), v.clone()));
|
||||
v
|
||||
}
|
||||
|
||||
/// Every block-definition entity with its successor within its block, cached per drawing like
|
||||
/// [`handles_in_order`]: one pass over the blocks, then `entnext`, `entget` and `handent` on a
|
||||
/// block's entity are hash lookups instead of scans of the block (and of every block, to find
|
||||
/// which holds the entity).
|
||||
fn block_slots(ctx: &mut Ctx<'_>) -> Arc<BlockSlots> {
|
||||
let Ok(st) = ctx.s.state() else { return Arc::default() };
|
||||
let key = Arc::as_ptr(&st.doc) as usize;
|
||||
if let Some((k, v)) = &ctx.env.order
|
||||
if let Some((k, v)) = &ctx.env.block_next
|
||||
&& *k == key
|
||||
{
|
||||
return v.clone();
|
||||
}
|
||||
let d = &st.doc;
|
||||
let mut v: Vec<Handle> = d.model.handles();
|
||||
for l in &d.layouts {
|
||||
v.extend(l.entities.handles());
|
||||
let mut m = HashMap::new();
|
||||
for b in st.doc.blocks.values() {
|
||||
let mut it = b.entities.iter().peekable();
|
||||
while let Some(e) = it.next() {
|
||||
m.insert(e.handle, (e.clone(), it.peek().map(|n| n.handle)));
|
||||
}
|
||||
}
|
||||
v.sort_unstable();
|
||||
let v = Arc::new(v);
|
||||
ctx.env.order = Some((key, v.clone()));
|
||||
v
|
||||
let m = Arc::new(m);
|
||||
ctx.env.block_next = Some((key, m.clone()));
|
||||
m
|
||||
}
|
||||
|
||||
pub fn entlast(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
@@ -584,6 +655,15 @@ pub fn entlast(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
|
||||
pub fn entnext(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 0, 1)?;
|
||||
// From an entity of a block definition: the next one in that block, nil after the last (#1700).
|
||||
if let Some(v) = a.first().filter(|v| !v.is_nil()) {
|
||||
let h = ename(v)?;
|
||||
if ctx.s.doc().is_ok_and(|d| d.entity(h).is_none())
|
||||
&& let Some((_, next)) = block_slots(ctx).get(&h)
|
||||
{
|
||||
return Ok(Flow::Value(next.map(Value::Ename).unwrap_or_default()));
|
||||
}
|
||||
}
|
||||
let order = handles_in_order(ctx);
|
||||
let next = match a.first() {
|
||||
None | Some(Value::Nil) => order.first().copied(),
|
||||
@@ -599,8 +679,14 @@ pub fn entnext(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
pub fn handent(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 1, 1)?;
|
||||
let s = string(&a[0])?;
|
||||
let h = Handle::parse_hex(&s).filter(|h| ctx.s.doc().is_ok_and(|d| d.entity(*h).is_some()));
|
||||
Ok(Flow::Value(h.map(Value::Ename).unwrap_or_default()))
|
||||
let Some(h) = Handle::parse_hex(&s) else { return Ok(Flow::Value(Value::Nil)) };
|
||||
let found = ctx.s.doc().is_ok_and(|d| d.entity(h).is_some()) || block_entity(ctx, h).is_some() || super::objects::exists(ctx, h);
|
||||
Ok(Flow::Value(if found { Value::Ename(h) } else { Value::Nil }))
|
||||
}
|
||||
|
||||
/// Entity `h` of a block definition (#1700), by the cached index.
|
||||
fn block_entity(ctx: &mut Ctx<'_>, h: Handle) -> Option<Arc<Entity>> {
|
||||
block_slots(ctx).get(&h).map(|(e, _)| e.clone())
|
||||
}
|
||||
|
||||
// ---------------- selection sets ----------------
|
||||
@@ -992,12 +1078,17 @@ fn table_records(d: &cadcraft_doc::Drawing, table: &str) -> Vec<Value> {
|
||||
.blocks
|
||||
.values()
|
||||
.map(|b| {
|
||||
Value::list(vec![
|
||||
let mut items = vec![
|
||||
pair(0, Value::str("BLOCK")),
|
||||
pair(2, Value::str(&b.name)),
|
||||
pair(70, Value::Int(0)),
|
||||
Value::list(vec![Value::Int(10), Value::Real(b.base.x), Value::Real(b.base.y), Value::Real(b.base.z)]),
|
||||
])
|
||||
];
|
||||
// Its first entity (-2): entnext walks the rest of the definition (#1700).
|
||||
if let Some(first) = b.entities.iter().next() {
|
||||
items.push(pair(-2, Value::Ename(first.handle)));
|
||||
}
|
||||
Value::list(items)
|
||||
})
|
||||
.collect(),
|
||||
"DIMSTYLE" => d
|
||||
|
||||
@@ -0,0 +1,281 @@
|
||||
//! Non-graphic objects from LISP: the named object dictionary and its dictionaries, table records
|
||||
//! and layouts (`namedobjdict`, `dictsearch`, `dictnext`, `tblobjname`, and `handent` and
|
||||
//! `entget` of such an object).
|
||||
//!
|
||||
//! CADCraft writes these objects from its own model and gives them handles only in a file, so
|
||||
//! they are read from the drawing's records as a DXF file of it holds them
|
||||
//! ([`crate::cmd::file::EntityCodec::objects`]). Each object gets an entity name that stays the
|
||||
//! same for the drawing's session: the handle the drawing's file gave it, when the drawing was
|
||||
//! read from a file that had it, otherwise a name above any file's handles. An object is known by
|
||||
//! its role (a layer's name, a dictionary key, a layout's name), so its name follows it across
|
||||
//! edits; one without a role (an object of a deeper dictionary) is known by its handle in the
|
||||
//! written records, so its name holds only until the drawing changes (then it names nothing). Lists of these objects are
|
||||
//! read-only: `entmod` and `entmake` don't take them.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::{Arc, Weak};
|
||||
|
||||
use cadcraft_doc::foreign::ForeignKey;
|
||||
use cadcraft_doc::{Drawing, Handle};
|
||||
use craft_dxf::Tag;
|
||||
|
||||
use super::LispError;
|
||||
use super::drawing::{arity, ename, groups_to_list, string};
|
||||
use super::eval::{Ctx, Flow};
|
||||
use super::value::Value;
|
||||
|
||||
/// The first entity name given to an object its drawing's file didn't name.
|
||||
const OWN_NAMES: u64 = 0x7F00_0000_0000_0000;
|
||||
/// The kind of a key for an object without a role: its written handle is the name.
|
||||
const BY_HANDLE: &str = "@";
|
||||
|
||||
/// The entity names given to non-graphic objects, and what they are read from.
|
||||
#[derive(Default)]
|
||||
pub struct Names {
|
||||
by_key: HashMap<ForeignKey, Handle>,
|
||||
by_name: HashMap<Handle, ForeignKey>,
|
||||
next: u64,
|
||||
/// The written records of the drawing they were taken from (held weakly, so its address
|
||||
/// can't be reused for another drawing while the records are kept).
|
||||
records: Option<(Weak<Drawing>, Arc<Records>)>,
|
||||
/// `dictnext`'s place in each dictionary.
|
||||
dictnext: HashMap<Handle, usize>,
|
||||
}
|
||||
|
||||
/// A drawing's non-graphic records as written.
|
||||
struct Records {
|
||||
list: Vec<(String, Vec<Tag>, Option<ForeignKey>)>,
|
||||
/// Written handle → index in `list`.
|
||||
by_handle: HashMap<String, usize>,
|
||||
/// Role → written handle.
|
||||
by_role: HashMap<ForeignKey, String>,
|
||||
}
|
||||
|
||||
impl Records {
|
||||
fn key(&self, written: &str) -> Option<ForeignKey> {
|
||||
let i = *self.by_handle.get(written)?;
|
||||
let (_, _, role) = self.list.get(i)?;
|
||||
Some(role.clone().unwrap_or_else(|| (BY_HANDLE.into(), written.to_string())))
|
||||
}
|
||||
|
||||
fn written(&self, key: &ForeignKey) -> Option<&str> {
|
||||
if key.0 == BY_HANDLE {
|
||||
return self.by_handle.get_key_value(&key.1).map(|(h, _)| h.as_str());
|
||||
}
|
||||
self.by_role.get(key).map(String::as_str)
|
||||
}
|
||||
|
||||
fn record(&self, written: &str) -> Option<&(String, Vec<Tag>, Option<ForeignKey>)> {
|
||||
self.list.get(*self.by_handle.get(written)?)
|
||||
}
|
||||
}
|
||||
|
||||
/// A record's own handle: group 5, or 105 for a DIMSTYLE (before any xdata).
|
||||
fn own_handle(tags: &[Tag]) -> Option<&Tag> {
|
||||
tags.iter().take_while(|t| t.code < 1000).find(|t| matches!(t.code, 5 | 105))
|
||||
}
|
||||
|
||||
/// A handle as the records spell it (upper-case hex without leading zeros).
|
||||
fn norm(hex: &str) -> Option<String> {
|
||||
Handle::parse_hex(hex.trim()).map(Handle::hex)
|
||||
}
|
||||
|
||||
fn records(names: &mut Names, d: &Arc<Drawing>) -> Option<Arc<Records>> {
|
||||
if let Some((w, r)) = &names.records
|
||||
&& std::ptr::eq(w.as_ptr(), Arc::as_ptr(d))
|
||||
{
|
||||
return Some(r.clone());
|
||||
}
|
||||
let list = crate::cmd::file::object_records()?(d);
|
||||
let mut by_handle = HashMap::new();
|
||||
let mut by_role = HashMap::new();
|
||||
for (i, (_, tags, role)) in list.iter().enumerate() {
|
||||
let Some(h) = own_handle(tags).and_then(|t| norm(&t.str())) else { continue };
|
||||
if let Some(role) = role {
|
||||
by_role.entry(role.clone()).or_insert_with(|| h.clone());
|
||||
}
|
||||
by_handle.entry(h).or_insert(i);
|
||||
}
|
||||
let r = Arc::new(Records { list, by_handle, by_role });
|
||||
// Written handles change with the drawing: names given by them no longer hold.
|
||||
names.by_key.retain(|k, _| k.0 != BY_HANDLE);
|
||||
names.by_name.retain(|_, k| k.0 != BY_HANDLE);
|
||||
names.records = Some((Arc::downgrade(d), r.clone()));
|
||||
Some(r)
|
||||
}
|
||||
|
||||
/// The entity name of the object with `key`, given out now if it has none yet.
|
||||
fn name_of(names: &mut Names, d: &Drawing, key: &ForeignKey) -> Option<Handle> {
|
||||
if let Some(h) = names.by_key.get(key) {
|
||||
return Some(*h);
|
||||
}
|
||||
let free = |names: &Names, h: Handle| d.entity(h).is_none() && !names.by_name.contains_key(&h);
|
||||
let file = (key.0 != BY_HANDLE).then(|| d.foreign.handles.iter().find(|(_, k)| *k == key).map(|(h, _)| *h)).flatten();
|
||||
let h = match file.filter(|h| free(names, *h)) {
|
||||
Some(h) => h,
|
||||
None => {
|
||||
// A name of its own, past any that is taken (a hostile file can use this range too).
|
||||
let mut found = None;
|
||||
for _ in 0..1024 {
|
||||
let h = Handle(OWN_NAMES.checked_add(names.next)?);
|
||||
names.next = names.next.checked_add(1)?;
|
||||
if free(names, h) && !d.foreign.handles.contains_key(&h) {
|
||||
found = Some(h);
|
||||
break;
|
||||
}
|
||||
}
|
||||
found?
|
||||
}
|
||||
};
|
||||
names.by_key.insert(key.clone(), h);
|
||||
names.by_name.insert(h, key.clone());
|
||||
Some(h)
|
||||
}
|
||||
|
||||
/// What an entity name of a non-graphic object stands for.
|
||||
fn key_of(names: &Names, d: &Drawing, h: Handle) -> Option<ForeignKey> {
|
||||
names.by_name.get(&h).cloned().or_else(|| d.foreign.handles.get(&h).cloned())
|
||||
}
|
||||
|
||||
/// Groups that hold a handle (DXF Reference, group code value types): soft and hard pointers and
|
||||
/// owners, arbitrary object handles and plot style handles.
|
||||
fn pointer_group(code: i32) -> bool {
|
||||
matches!(code, 320..=369 | 390..=399 | 480..=481)
|
||||
}
|
||||
|
||||
/// The object `written` as an entity list: `(-1 . name)`, its type and its groups, with its
|
||||
/// handle (group 5, a DIMSTYLE's 105) as its name's and pointers as entity names.
|
||||
fn object_list(names: &mut Names, d: &Drawing, recs: &Records, name: Handle, written: &str) -> Value {
|
||||
let Some((kind, tags, _)) = recs.record(written) else { return Value::Nil };
|
||||
let mut items = vec![Value::cons(Value::Int(-1), Value::Ename(name)), Value::cons(Value::Int(0), Value::str(kind))];
|
||||
for v in groups_to_list(tags) {
|
||||
let code = v.car().as_number().map(|c| c as i32);
|
||||
let text = match v.cdr() {
|
||||
Value::Str(s) => Some(s.to_string()),
|
||||
_ => None,
|
||||
};
|
||||
match (code, text) {
|
||||
(Some(c @ (5 | 105)), Some(_)) => items.push(Value::cons(Value::Int(c), Value::str(&name.hex()))),
|
||||
(Some(c), Some(t)) if pointer_group(c) => {
|
||||
let Some(h) = norm(&t).filter(|h| h != "0") else { continue };
|
||||
let target = Handle::parse_hex(&h).filter(|e| d.entity(*e).is_some());
|
||||
let target = target.or_else(|| recs.key(&h).and_then(|k| name_of(names, d, &k)));
|
||||
items.push(match target {
|
||||
Some(e) => Value::cons(Value::Int(c), Value::Ename(e)),
|
||||
None => v,
|
||||
});
|
||||
}
|
||||
_ => items.push(v),
|
||||
}
|
||||
}
|
||||
Value::list(items)
|
||||
}
|
||||
|
||||
/// The written handle of the non-graphic object named `h`, if it still exists.
|
||||
fn written_of(names: &Names, d: &Drawing, recs: &Records, h: Handle) -> Option<String> {
|
||||
let key = key_of(names, d, h)?;
|
||||
recs.written(&key).map(str::to_string)
|
||||
}
|
||||
|
||||
/// `entget` of a non-graphic object: nil when `h` names none.
|
||||
pub fn entget(ctx: &mut Ctx<'_>, h: Handle) -> Value {
|
||||
let Ok(st) = ctx.s.state() else { return Value::Nil };
|
||||
let names = &mut ctx.env.objects;
|
||||
let Some(recs) = records(names, &st.doc) else { return Value::Nil };
|
||||
let Some(w) = written_of(names, &st.doc, &recs, h) else { return Value::Nil };
|
||||
object_list(names, &st.doc, &recs, h, &w)
|
||||
}
|
||||
|
||||
/// `handent` of a non-graphic object: whether `h` names one that exists.
|
||||
pub fn exists(ctx: &mut Ctx<'_>, h: Handle) -> bool {
|
||||
let Ok(st) = ctx.s.state() else { return false };
|
||||
let names = &mut ctx.env.objects;
|
||||
let Some(recs) = records(names, &st.doc) else { return false };
|
||||
written_of(names, &st.doc, &recs, h).is_some()
|
||||
}
|
||||
|
||||
/// `(namedobjdict)`: the named object dictionary's entity name.
|
||||
pub fn namedobjdict(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 0, 0)?;
|
||||
let Ok(st) = ctx.s.state() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
let names = &mut ctx.env.objects;
|
||||
let key: ForeignKey = ("NOD".into(), String::new());
|
||||
let found = records(names, &st.doc).filter(|r| r.written(&key).is_some()).and_then(|_| name_of(names, &st.doc, &key));
|
||||
Ok(Flow::Value(found.map(Value::Ename).unwrap_or_default()))
|
||||
}
|
||||
|
||||
/// `(tblobjname table name)`: the entity name of a symbol table record (of the BLOCK entity for
|
||||
/// the BLOCK table), nil when there is none.
|
||||
pub fn tblobjname(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 2, 2)?;
|
||||
let table = string(&a[0])?.trim().to_ascii_uppercase();
|
||||
// As the roles spell names (upper case in ASCII only).
|
||||
let name = string(&a[1])?.trim().to_ascii_uppercase();
|
||||
let Ok(st) = ctx.s.state() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
let names = &mut ctx.env.objects;
|
||||
let key: ForeignKey = (table, name);
|
||||
let found = records(names, &st.doc).filter(|r| r.written(&key).is_some()).and_then(|_| name_of(names, &st.doc, &key));
|
||||
Ok(Flow::Value(found.map(Value::Ename).unwrap_or_default()))
|
||||
}
|
||||
|
||||
/// A dictionary's entries: (key, written handle of the entry), in order.
|
||||
fn entries(kind: &str, tags: &[Tag]) -> Vec<(String, String)> {
|
||||
if !matches!(kind, "DICTIONARY" | "ACDBDICTIONARYWDFLT") {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
let mut key: Option<String> = None;
|
||||
for t in tags {
|
||||
match t.code {
|
||||
3 => key = Some(t.str()),
|
||||
350 | 360 => {
|
||||
if let (Some(k), Some(h)) = (key.take(), norm(&t.str())) {
|
||||
out.push((k, h));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The entity list of entry `i` of the dictionary named `dict`, and the number of entries.
|
||||
fn entry(ctx: &mut Ctx<'_>, dict: Handle, pick: impl Fn(&[(String, String)]) -> Option<usize>) -> (Value, Option<usize>) {
|
||||
let Ok(st) = ctx.s.state() else { return (Value::Nil, None) };
|
||||
let names = &mut ctx.env.objects;
|
||||
let Some(recs) = records(names, &st.doc) else { return (Value::Nil, None) };
|
||||
let Some(w) = written_of(names, &st.doc, &recs, dict) else { return (Value::Nil, None) };
|
||||
let Some((kind, tags, _)) = recs.record(&w) else { return (Value::Nil, None) };
|
||||
let list = entries(kind, tags);
|
||||
let Some(i) = pick(&list) else { return (Value::Nil, None) };
|
||||
let Some((_, eh)) = list.get(i) else { return (Value::Nil, None) };
|
||||
let Some(name) = recs.key(eh).and_then(|k| name_of(names, &st.doc, &k)) else { return (Value::Nil, Some(i)) };
|
||||
(object_list(names, &st.doc, &recs, name, eh), Some(i))
|
||||
}
|
||||
|
||||
/// `(dictsearch dict key [setnext])`: the entity list of the entry `key` (any case) of a
|
||||
/// dictionary, nil when it has none; with `setnext`, `dictnext` goes on after it.
|
||||
pub fn dictsearch(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 2, 3)?;
|
||||
let dict = ename(&a[0])?;
|
||||
let key = string(&a[1])?;
|
||||
let (v, i) = entry(ctx, dict, |list| list.iter().position(|(k, _)| k.eq_ignore_ascii_case(&key)));
|
||||
if let Some(i) = i
|
||||
&& a.get(2).is_some_and(|v| !v.is_nil())
|
||||
{
|
||||
ctx.env.objects.dictnext.insert(dict, i.saturating_add(1));
|
||||
}
|
||||
Ok(Flow::Value(v))
|
||||
}
|
||||
|
||||
/// `(dictnext dict [rewind])`: the entity list of a dictionary's next entry (its first with
|
||||
/// `rewind`, or on the first call), nil after the last.
|
||||
pub fn dictnext(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 1, 2)?;
|
||||
let dict = ename(&a[0])?;
|
||||
let rewind = a.get(1).is_some_and(|v| !v.is_nil());
|
||||
let at = if rewind { 0 } else { ctx.env.objects.dictnext.get(&dict).copied().unwrap_or(0) };
|
||||
let (v, _) = entry(ctx, dict, |list| (at < list.len()).then_some(at));
|
||||
ctx.env.objects.dictnext.insert(dict, at.saturating_add(1));
|
||||
Ok(Flow::Value(v))
|
||||
}
|
||||
@@ -2,10 +2,12 @@
|
||||
|
||||
use super::value::{Value, to_text};
|
||||
use crate::Session;
|
||||
use crate::cmd::file::{EntityCodec, set_entity_codec};
|
||||
use crate::cmd::file::{EntityCodec, set_entity_codec, set_object_records};
|
||||
|
||||
pub(super) fn session() -> Session {
|
||||
set_entity_codec(EntityCodec { groups: cadcraft_io::entity_groups, entity: cadcraft_io::entity_from_groups });
|
||||
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
|
||||
set_object_records(cadcraft_io::object_records);
|
||||
Session::new()
|
||||
}
|
||||
|
||||
@@ -404,6 +406,147 @@ fn entity_lists_round_trip() {
|
||||
assert_eq!(ok(&mut s, "(handent \"ZZZZZZ\")"), "nil");
|
||||
}
|
||||
|
||||
/// entlast, entnext and (ssget "L") see what the routine itself just made, changed or deleted:
|
||||
/// the order they share isn't kept past an edit, even one that leaves the drawing where it was.
|
||||
#[test]
|
||||
fn entlast_follows_edits_within_one_routine() {
|
||||
let mut s = session();
|
||||
assert_eq!(
|
||||
ok(
|
||||
&mut s,
|
||||
"(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0))) (setq a (entlast))
|
||||
(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 2.0 0.0 0.0))) (setq b (entlast))
|
||||
(list (eq a b) (cdr (assoc 11 (entget b))) (eq (entnext a) b) (eq (ssname (ssget \"L\") 0) b))"
|
||||
),
|
||||
"(nil (2.0 0.0 0.0) T T)"
|
||||
);
|
||||
// Deleting the last makes the one before it last; entdel brings it back last again.
|
||||
assert_eq!(ok(&mut s, "(entdel b) (setq c (entlast)) (entdel b) (list (eq c a) (eq (entlast) b))"), "(T T)");
|
||||
// A command, an entmod and entlast, over and over in one routine: each entlast is the line
|
||||
// just drawn.
|
||||
assert_eq!(
|
||||
ok(
|
||||
&mut s,
|
||||
"(setq seen nil i 0)
|
||||
(repeat 40
|
||||
(command \"_.LINE\" (list i 10) (list i 20) \"\")
|
||||
(setq e (entlast) d (entget e))
|
||||
(entmod (subst (cons 8 \"MOVED\") (assoc 8 d) d))
|
||||
(if (and (not (member e seen)) (equal (cdr (assoc 10 (entget (entlast)))) (list (float i) 10.0 0.0) 1e-9))
|
||||
(setq seen (cons e seen)))
|
||||
(setq i (1+ i)))
|
||||
(list (length seen) (cdr (assoc 8 (entget (entlast)))))"
|
||||
),
|
||||
"(40 \"MOVED\")"
|
||||
);
|
||||
// The same across routines, with an undo between them.
|
||||
for i in 0..10 {
|
||||
ok(&mut s, &format!("(entmake '((0 . \"CIRCLE\") (10 {i}.0 50.0 0.0) (40 . 1.0)))"));
|
||||
assert_eq!(ok(&mut s, "(cadr (assoc 10 (entget (entlast))))"), format!("{i}.0"));
|
||||
s.undo().unwrap();
|
||||
ok(&mut s, &format!("(entmake '((0 . \"CIRCLE\") (10 {i}.0 60.0 0.0) (40 . 1.0)))"));
|
||||
assert_eq!(ok(&mut s, "(caddr (assoc 10 (entget (entlast))))"), "60.0");
|
||||
}
|
||||
}
|
||||
|
||||
/// entmod of a block reference keeps its attributes and their values: they aren't in its list
|
||||
/// (in AutoCAD they are entities of their own, which entmod of the INSERT leaves alone).
|
||||
#[test]
|
||||
fn entmod_of_a_block_reference_keeps_its_attributes() {
|
||||
let mut s = session();
|
||||
ok(
|
||||
&mut s,
|
||||
"(entmake '((0 . \"BLOCK\") (2 . \"TAGGED\") (70 . 0) (10 0.0 0.0 0.0)))
|
||||
(entmake '((0 . \"CIRCLE\") (10 0.0 0.0 0.0) (40 . 1.0)))
|
||||
(entmake '((0 . \"ATTDEF\") (10 0.0 2.0 0.0) (40 . 1.0) (1 . \"\") (3 . \"Name\") (2 . \"PSTN\") (70 . 0)))
|
||||
(entmake '((0 . \"ENDBLK\")))",
|
||||
);
|
||||
s.execute("insert", &serde_json::json!({"name": "TAGGED", "at": [10, 10], "attribs": {"PSTN": "ARK1"}})).unwrap();
|
||||
let insert = |s: &Session| {
|
||||
s.doc()
|
||||
.unwrap()
|
||||
.model
|
||||
.iter()
|
||||
.find_map(|e| match &e.kind {
|
||||
cadcraft_doc::EntityKind::Insert(i) => {
|
||||
Some((e.common.layer.clone(), i.attribs.iter().map(|a| (a.tag.clone(), a.text.value.clone())).collect::<Vec<_>>()))
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.unwrap()
|
||||
};
|
||||
let want = vec![("PSTN".to_string(), "ARK1".to_string())];
|
||||
assert_eq!(insert(&s).1, want);
|
||||
ok(&mut s, "(setq d (entget (entlast))) (entmod (subst (cons 8 \"UGO\") (assoc 8 d) d))");
|
||||
assert_eq!(insert(&s), ("UGO".to_string(), want.clone()));
|
||||
// A new rotation keeps them too.
|
||||
ok(&mut s, "(setq d (entget (entlast))) (entmod (subst (cons 50 (/ pi 2)) (assoc 50 d) d))");
|
||||
let rotation = s
|
||||
.doc()
|
||||
.unwrap()
|
||||
.model
|
||||
.iter()
|
||||
.find_map(|e| match &e.kind {
|
||||
cadcraft_doc::EntityKind::Insert(i) => Some(i.rotation),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
assert!((rotation - std::f64::consts::FRAC_PI_2).abs() < 1e-9, "the entmod took: {rotation}");
|
||||
assert_eq!(insert(&s).1, want);
|
||||
}
|
||||
|
||||
/// An edit that leaves every handle where it was (a layer change) keeps entlast's cached order;
|
||||
/// one that adds an entity rebuilds it.
|
||||
#[test]
|
||||
fn entlast_keeps_its_order_across_property_edits() {
|
||||
let mut s = session();
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0))) (entlast)");
|
||||
let uid = s.state().unwrap().uid;
|
||||
// The cached order itself is held, so a rebuilt one can't take its address.
|
||||
let order = |s: &Session| s.lisp.envs[&uid].order.as_ref().unwrap().1.clone();
|
||||
let before = order(&s);
|
||||
assert_eq!(
|
||||
ok(&mut s, "(setq d (entget (entlast))) (entmod (subst (cons 8 \"MOVED\") (assoc 8 d) d)) (cdr (assoc 8 (entget (entlast))))"),
|
||||
"\"MOVED\""
|
||||
);
|
||||
assert!(std::sync::Arc::ptr_eq(&order(&s), &before), "a layer change keeps the order");
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 2.0 0.0 0.0))) (entlast)");
|
||||
assert!(!std::sync::Arc::ptr_eq(&order(&s), &before), "a new entity rebuilds it");
|
||||
}
|
||||
|
||||
/// Closing a drawing drops its LISP environment, and with it the entity stores its cached
|
||||
/// order holds.
|
||||
#[test]
|
||||
fn closing_a_drawing_drops_its_environment() {
|
||||
let mut s = session();
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0))) (entlast)");
|
||||
let uid = s.state().unwrap().uid;
|
||||
assert!(s.lisp.envs.get(&uid).is_some_and(|e| e.order.is_some()));
|
||||
s.execute("close", &serde_json::json!({})).unwrap();
|
||||
assert!(!s.lisp.envs.contains_key(&uid));
|
||||
}
|
||||
|
||||
/// HANDSEED is the next handle the drawing gives out, in hex, and moves as objects are made.
|
||||
#[test]
|
||||
fn handseed_follows_new_objects() {
|
||||
let mut s = session();
|
||||
let seed = |s: &Session| format!("\"{:X}\"", s.doc().unwrap().next_handle().0);
|
||||
let before = ok(&mut s, "(getvar \"HANDSEED\")");
|
||||
assert_eq!(before, seed(&s));
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0)))");
|
||||
let after = ok(&mut s, "(getvar \"HANDSEED\")");
|
||||
assert_eq!(after, seed(&s));
|
||||
assert_ne!(after, before);
|
||||
assert!(eval(&mut s, "(setvar \"HANDSEED\" \"FFFFFF\")").is_err(), "read-only");
|
||||
// A handle the file's own objects hold is skipped, as allocation skips it.
|
||||
let d = s.doc_mut().unwrap();
|
||||
let held = d.handseed;
|
||||
std::sync::Arc::make_mut(&mut d.foreign).handles.insert(cadcraft_doc::Handle(held), ("NOD".into(), String::new()));
|
||||
assert_eq!(ok(&mut s, "(getvar \"HANDSEED\")"), format!("\"{:X}\"", held + 1));
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0)))");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 5 (entget (entlast))))"), format!("\"{:X}\"", held + 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn entity_lists_hold_angles_in_radians() {
|
||||
let mut s = session();
|
||||
@@ -1048,6 +1191,253 @@ fn a_panic_inside_a_routine_ends_it_with_an_error() {
|
||||
assert_eq!(ok(&mut s, "(+ 1 2)"), "3");
|
||||
}
|
||||
|
||||
/// The handle (group 5, a DIMSTYLE's 105) of the `kind` record named `name` (group 2, or 1 for a
|
||||
/// LAYOUT; any for "") in DXF text.
|
||||
fn dxf_handle(dxf: &str, kind: &str, name: &str) -> String {
|
||||
let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
|
||||
let pairs: Vec<(&str, &str)> = lines.chunks(2).filter_map(|c| Some((*c.first()?, *c.get(1)?))).collect();
|
||||
let mut i = 0;
|
||||
while i < pairs.len() {
|
||||
if pairs[i] == ("0", kind) {
|
||||
let rec: Vec<(&str, &str)> = pairs[i + 1..].iter().take_while(|p| p.0 != "0").copied().collect();
|
||||
let named = name.is_empty() || rec.iter().any(|p| (p.0 == "2" || (kind == "LAYOUT" && p.0 == "1")) && p.1 == name);
|
||||
if named {
|
||||
return rec.iter().find(|p| p.0 == "5" || p.0 == "105").unwrap().1.to_string();
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
panic!("no {kind} {name}")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn namedobjdict_and_dictsearch_reach_the_layouts() {
|
||||
let mut s = session();
|
||||
assert!(ok(&mut s, "(namedobjdict)").starts_with("<Entity name: "));
|
||||
assert_eq!(ok(&mut s, "(eq (namedobjdict) (namedobjdict))"), "T");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (namedobjdict))))"), "\"DICTIONARY\"");
|
||||
// Keys in any case; the entry's own list, owned by the dictionary it is in.
|
||||
ok(&mut s, "(setq layouts (dictsearch (namedobjdict) \"acad_layout\"))");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 layouts))"), "\"DICTIONARY\"");
|
||||
assert_eq!(ok(&mut s, "(eq (cdr (assoc 330 layouts)) (namedobjdict))"), "T");
|
||||
ok(&mut s, "(setq l1 (dictsearch (cdr (assoc -1 layouts)) \"Layout1\"))");
|
||||
assert_eq!(ok(&mut s, "(list (cdr (assoc 0 l1)) (cdr (assoc 1 (member '(100 . \"AcDbLayout\") l1))))"), "(\"LAYOUT\" \"Layout1\")");
|
||||
// The plot settings are there to read; the layout's block record is an entity name.
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 2 l1))"), "\"none_device\"");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (cdr (assoc 330 (reverse l1))))))"), "\"BLOCK_RECORD\"");
|
||||
// The name in group 5 leads back to the object.
|
||||
assert_eq!(ok(&mut s, "(eq (handent (cdr (assoc 5 l1))) (cdr (assoc -1 l1)))"), "T");
|
||||
assert_eq!(ok(&mut s, "(dictsearch (namedobjdict) \"NO_SUCH_KEY\")"), "nil");
|
||||
// A layer is not a dictionary: nothing to search.
|
||||
assert_eq!(ok(&mut s, "(dictsearch (tblobjname \"LAYER\" \"0\") \"ACAD_LAYOUT\")"), "nil");
|
||||
assert!(eval(&mut s, "(dictsearch \"ACAD_LAYOUT\" \"x\")").unwrap_err().contains("lentityp"));
|
||||
assert!(eval(&mut s, "(namedobjdict 1)").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dictnext_walks_a_dictionary() {
|
||||
let mut s = session();
|
||||
ok(&mut s, "(setq d (cdr (assoc -1 (dictsearch (namedobjdict) \"ACAD_LAYOUT\"))))");
|
||||
let names = "(progn (setq out nil e (dictnext d T)) (while e (setq out (cons (cdr (assoc 1 (member '(100 . \"AcDbLayout\") e))) out) e (dictnext d))) (reverse out))";
|
||||
assert_eq!(ok(&mut s, names), "(\"Model\" \"Layout1\" \"Layout2\")");
|
||||
// Past the end it stays nil until rewound.
|
||||
assert_eq!(ok(&mut s, "(dictnext d)"), "nil");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 (dictnext d T)))"), "\"LAYOUT\"");
|
||||
// dictsearch with setnext: dictnext goes on after the entry found.
|
||||
ok(&mut s, "(dictsearch d \"Model\" T)");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 1 (member '(100 . \"AcDbLayout\") (dictnext d))))"), "\"Layout1\"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tblobjname_names_table_records() {
|
||||
let mut s = session();
|
||||
ok(&mut s, "(setq l (tblobjname \"layer\" \"0\"))");
|
||||
assert_eq!(ok(&mut s, "(list (cdr (assoc 0 (entget l))) (cdr (assoc 2 (entget l))))"), "(\"LAYER\" \"0\")");
|
||||
// Its owner is the LAYER table.
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 2 (entget (cdr (assoc 330 (entget l))))))"), "\"LAYER\"");
|
||||
// The BLOCK table gives the block's BLOCK entity.
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (tblobjname \"BLOCK\" \"*Model_Space\"))))"), "\"BLOCK\"");
|
||||
assert_eq!(ok(&mut s, "(tblobjname \"LAYER\" \"NO_SUCH_LAYER\")"), "nil");
|
||||
// Names outside ASCII: found in the case they have, ASCII letters in any case.
|
||||
s.execute("layer.new", &serde_json::json!({"name": "ébauche"})).unwrap();
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 2 (entget (tblobjname \"LAYER\" \"éBAUCHE\"))))"), "\"ébauche\"");
|
||||
assert_eq!(ok(&mut s, "(tblobjname \"NO_SUCH_TABLE\" \"0\")"), "nil");
|
||||
// A DIMSTYLE has its handle in group 105.
|
||||
ok(&mut s, "(setq ds (tblobjname \"DIMSTYLE\" (cdr (assoc 2 (tblnext \"DIMSTYLE\" T)))))");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget ds)))"), "\"DIMSTYLE\"");
|
||||
assert_eq!(ok(&mut s, "(eq ds (handent (cdr (assoc 105 (entget ds)))))"), "T");
|
||||
assert!(eval(&mut s, "(tblobjname \"LAYER\")").is_err());
|
||||
// The name holds while the drawing changes.
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 10.0 0.0 0.0)))");
|
||||
assert_eq!(ok(&mut s, "(eq l (tblobjname \"LAYER\" \"0\"))"), "T");
|
||||
assert_eq!(ok(&mut s, "(eq l (handent (cdr (assoc 5 (entget l)))))"), "T");
|
||||
}
|
||||
|
||||
/// #1661: the handles of a layer and a layout in a file lead to them once the file is open.
|
||||
#[test]
|
||||
fn handent_names_a_files_layer_and_layout() {
|
||||
let mut s = session();
|
||||
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 10.0 0.0 0.0)))");
|
||||
let bytes = cadcraft_io::write(s.doc().unwrap(), "h.dxf").unwrap();
|
||||
let dxf = String::from_utf8(bytes.clone()).unwrap();
|
||||
let (layer, layout) = (dxf_handle(&dxf, "LAYER", "0"), dxf_handle(&dxf, "LAYOUT", "Layout1"));
|
||||
let line = dxf_handle(&dxf, "LINE", "");
|
||||
let dimstyle = dxf_handle(&dxf, "DIMSTYLE", "Standard");
|
||||
let mut s = session();
|
||||
s.open_drawing(cadcraft_io::read(&bytes, "h.dxf").unwrap(), "h.dxf", None);
|
||||
assert_eq!(ok(&mut s, &format!("(cdr (assoc 0 (entget (handent \"{line}\"))))")), "\"LINE\"");
|
||||
assert_eq!(ok(&mut s, &format!("(cdr (assoc 2 (entget (handent \"{layer}\"))))")), "\"0\"");
|
||||
assert_eq!(ok(&mut s, &format!("(eq (handent \"{layer}\") (tblobjname \"LAYER\" \"0\"))")), "T");
|
||||
assert_eq!(ok(&mut s, &format!("(cdr (assoc 0 (entget (handent \"{layout}\"))))")), "\"LAYOUT\"");
|
||||
assert_eq!(ok(&mut s, &format!("(cdr (assoc 5 (entget (handent \"{layout}\"))))")), format!("\"{layout}\""));
|
||||
// A DIMSTYLE's handle is in group 105, in the file and in its list.
|
||||
assert_eq!(ok(&mut s, &format!("(cdr (assoc 0 (entget (handent \"{dimstyle}\"))))")), "\"DIMSTYLE\"");
|
||||
assert_eq!(ok(&mut s, &format!("(cdr (assoc 105 (entget (handent \"{dimstyle}\"))))")), format!("\"{dimstyle}\""));
|
||||
assert_eq!(ok(&mut s, &format!("(eq (handent \"{dimstyle}\") (tblobjname \"DIMSTYLE\" \"Standard\"))")), "T");
|
||||
assert_eq!(ok(&mut s, "(handent \"FFFFF\")"), "nil");
|
||||
assert_eq!(ok(&mut s, "(handent \"not hex\")"), "nil");
|
||||
}
|
||||
|
||||
/// A drawing with a dictionary two levels below the named object dictionary (kept from its file):
|
||||
/// NOD › MY_DICT › INNER › LEAF (an XRECORD).
|
||||
fn nested_dictionary_file() -> Vec<u8> {
|
||||
let s = session();
|
||||
let bytes = cadcraft_io::write(s.doc().unwrap(), "n.dxf").unwrap();
|
||||
let text = String::from_utf8(bytes).unwrap();
|
||||
let lines: Vec<&str> = text.lines().collect();
|
||||
let mut pairs: Vec<(String, String)> = lines.chunks(2).map(|c| (c[0].trim().to_string(), c[1].to_string())).collect();
|
||||
let objects = pairs.iter().position(|p| p.0 == "2" && p.1 == "OBJECTS").unwrap();
|
||||
let nod = objects + pairs[objects..].iter().position(|p| p.0 == "0" && p.1 == "DICTIONARY").unwrap();
|
||||
let nod_handle = pairs[nod + 1].1.clone();
|
||||
let after = nod + pairs[nod..].iter().position(|p| p.0 == "281").unwrap() + 1;
|
||||
pairs.splice(after..after, [("3".into(), "MY_DICT".into()), ("350".into(), "AAA1".into())]);
|
||||
let end = objects + pairs[objects..].iter().position(|p| p.0 == "0" && p.1 == "ENDSEC").unwrap();
|
||||
let p = |c: &str, v: &str| (c.to_string(), v.to_string());
|
||||
let added = vec![
|
||||
p("0", "DICTIONARY"),
|
||||
p("5", "AAA1"),
|
||||
p("330", &nod_handle),
|
||||
p("100", "AcDbDictionary"),
|
||||
p("281", "1"),
|
||||
p("3", "INNER"),
|
||||
p("350", "AAA2"),
|
||||
p("0", "DICTIONARY"),
|
||||
p("5", "AAA2"),
|
||||
p("330", "AAA1"),
|
||||
p("100", "AcDbDictionary"),
|
||||
p("281", "1"),
|
||||
p("3", "LEAF"),
|
||||
p("350", "AAA3"),
|
||||
p("0", "XRECORD"),
|
||||
p("5", "AAA3"),
|
||||
p("330", "AAA2"),
|
||||
p("100", "AcDbXrecord"),
|
||||
p("280", "1"),
|
||||
p("1", "hello"),
|
||||
];
|
||||
pairs.splice(end..end, added);
|
||||
pairs.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect::<String>().into_bytes()
|
||||
}
|
||||
|
||||
/// An object found below a dictionary entry has no role: once the drawing changes, its old name
|
||||
/// finds nothing rather than whatever now has its written handle.
|
||||
#[test]
|
||||
fn a_deeper_objects_name_lapses_when_the_drawing_changes() {
|
||||
let mut s = session();
|
||||
s.open_drawing(cadcraft_io::read(&nested_dictionary_file(), "n.dxf").unwrap(), "n.dxf", None);
|
||||
ok(&mut s, "(setq inner (cdr (assoc -1 (dictsearch (cdr (assoc -1 (dictsearch (namedobjdict) \"MY_DICT\"))) \"INNER\"))))");
|
||||
ok(&mut s, "(setq leaf (cdr (assoc -1 (dictsearch inner \"LEAF\"))))");
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 1 (entget leaf)))"), "\"hello\"");
|
||||
// Unchanged drawing: the same name.
|
||||
assert_eq!(ok(&mut s, "(eq leaf (cdr (assoc -1 (dictsearch inner \"LEAF\"))))"), "T");
|
||||
s.execute("layer.new", &serde_json::json!({"name": "Walls"})).unwrap();
|
||||
assert_eq!(ok(&mut s, "(entget leaf)"), "nil");
|
||||
// Looked up again, it is there (under a new name); the entry with a role kept its name.
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 1 (dictsearch inner \"LEAF\")))"), "\"hello\"");
|
||||
}
|
||||
|
||||
// ---------------- entities of block definitions (#1700) ----------------
|
||||
|
||||
/// A drawing with one linear dimension measuring 100 whose `*D1` block, as stored in the file,
|
||||
/// says 99.5 (a stale block: the defpoints moved, the block wasn't rebuilt).
|
||||
fn stale_dimension() -> Session {
|
||||
let mut s = session();
|
||||
s.execute("dimlinear", &serde_json::json!({"p1": [0, 0], "p2": [100, 0], "at": [50, -20], "rotation": 0})).unwrap();
|
||||
let dxf = cadcraft_io::write_dxf(s.doc().unwrap());
|
||||
// The *D1 block's MTEXT says 100 (100.0000 here); make the file say 99.5.
|
||||
let lines: Vec<&str> = dxf.lines().collect();
|
||||
let (mut kind, mut block, mut out, mut changed) = (String::new(), String::new(), Vec::new(), 0);
|
||||
for (i, l) in lines.iter().enumerate() {
|
||||
let code = if i % 2 == 0 { l.trim() } else { "" };
|
||||
let value = lines.get(i + 1).map(|v| v.trim()).unwrap_or("");
|
||||
if code == "0" {
|
||||
kind = value.to_string();
|
||||
}
|
||||
if code == "2" && kind == "BLOCK" {
|
||||
block = value.to_string();
|
||||
}
|
||||
if i % 2 == 1 && kind == "MTEXT" && block == "*D1" && lines.get(i - 1).map(|c| c.trim()) == Some("1") && l.trim().starts_with("100") {
|
||||
out.push("99.5".to_string());
|
||||
changed += 1;
|
||||
continue;
|
||||
}
|
||||
out.push(l.to_string());
|
||||
}
|
||||
assert_eq!(changed, 1, "the fixture found the *D1 text");
|
||||
let mut s = session();
|
||||
s.open_drawing(cadcraft_io::read_dxf(out.join("\n").as_bytes()).unwrap(), "stale", None);
|
||||
s
|
||||
}
|
||||
|
||||
/// The issue's use: a routine reads the text a dimension's block stores and compares it with the
|
||||
/// measurement, so it finds the stale block.
|
||||
#[test]
|
||||
fn a_routine_reads_the_text_a_dimension_block_stores() {
|
||||
let mut s = stale_dimension();
|
||||
let code = r#"(progn
|
||||
(defun dtext (dim / e txt)
|
||||
(setq e (cdr (assoc -2 (tblsearch "BLOCK" (cdr (assoc 2 (entget dim)))))))
|
||||
(while e
|
||||
(if (= (cdr (assoc 0 (entget e))) "MTEXT") (setq txt (cdr (assoc 1 (entget e)))))
|
||||
(setq e (entnext e)))
|
||||
txt)
|
||||
(setq dim (entlast))
|
||||
(list (dtext dim) (cdr (assoc 42 (entget dim)))))"#;
|
||||
assert_eq!(ok(&mut s, code), "(\"99.5\" 100.0)");
|
||||
}
|
||||
|
||||
/// tblsearch names a block's first entity (-2); entnext walks the definition in order and ends
|
||||
/// with nil; entget lists each one (without a layout); handent finds them by handle.
|
||||
#[test]
|
||||
fn entnext_and_entget_walk_a_block_definition() {
|
||||
let mut s = session();
|
||||
let l = s.execute("line", &serde_json::json!({"points": [[0, 0], [10, 0]]})).unwrap()["handles"][0].as_str().unwrap().to_string();
|
||||
let c = s.execute("circle", &serde_json::json!({"center": [5, 5], "radius": 2})).unwrap()["handle"].as_str().unwrap().to_string();
|
||||
s.execute("block", &serde_json::json!({"name": "B", "base": [0, 0], "handles": [l, c], "keep": "delete"})).unwrap();
|
||||
s.execute("line", &serde_json::json!({"points": [[50, 0], [60, 0]]})).unwrap();
|
||||
let walk = r#"(progn (setq e (cdr (assoc -2 (tblsearch "BLOCK" "B"))) types nil)
|
||||
(while e (setq types (cons (cdr (assoc 0 (entget e))) types) e (entnext e)))
|
||||
(reverse types))"#;
|
||||
assert_eq!(ok(&mut s, walk), "(\"LINE\" \"CIRCLE\")", "the block's own entities, not the drawing's");
|
||||
let first = "(cdr (assoc -2 (tblsearch \"BLOCK\" \"B\")))";
|
||||
assert_eq!(ok(&mut s, &format!("(assoc 410 (entget {first}))")), "nil", "no layout");
|
||||
assert_eq!(ok(&mut s, &format!("(equal (handent (cdr (assoc 5 (entget {first})))) {first})")), "T");
|
||||
// The drawing's own entities walk as before.
|
||||
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (entnext))))"), "\"LINE\"");
|
||||
assert_eq!(ok(&mut s, "(entnext (entlast))"), "nil");
|
||||
// Editing a block's entity through entmod or entdel isn't offered: nil, nothing changes.
|
||||
assert_eq!(ok(&mut s, &format!("(entdel {first})")), "nil");
|
||||
assert_eq!(ok(&mut s, &format!("(entmod (entget {first}))")), "nil");
|
||||
assert_eq!(s.doc().unwrap().block("B").unwrap().entities.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_empty_block_has_no_first_entity() {
|
||||
let mut s = session();
|
||||
s.doc_mut().unwrap().blocks.insert("EMPTY".into(), std::sync::Arc::new(cadcraft_doc::Block::new("EMPTY")));
|
||||
assert_eq!(ok(&mut s, "(assoc -2 (tblsearch \"BLOCK\" \"EMPTY\"))"), "nil");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn angtof_reads_the_string_in_the_given_units() {
|
||||
let mut s = Session::new();
|
||||
|
||||
@@ -0,0 +1,806 @@
|
||||
//! What the Properties palette shows for a selection: groups of rows, each with the
|
||||
//! `properties.set` key that changes it, the value the objects share (or *VARIES*), how the
|
||||
//! value reads in the drawing's units, and whether it can be edited. `properties.describe`
|
||||
//! returns the same description, so the palette, Quick Properties and agents read one list.
|
||||
//!
|
||||
//! Text, MText and Dimension have their own groups; other objects have the General group only
|
||||
//! (the palette draws their rows itself). Dimension rows are the dimension style variables,
|
||||
//! valued as the dimension draws them (its style with its overrides); setting one stores a
|
||||
//! per-dimension override, as AutoCAD's Properties palette does (DIMOVERRIDE).
|
||||
|
||||
use std::collections::HashSet;
|
||||
|
||||
use cadcraft_doc::{DimKind, DimStyle, Dimension, Drawing, Entity, EntityKind, HAlign, Handle, Lineweight, MText, Text, Transparency, VAlign};
|
||||
use serde::Serialize;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::units;
|
||||
|
||||
/// What a row shows when the described objects don't share a value.
|
||||
pub const VARIES: &str = "*VARIES*";
|
||||
|
||||
/// MTEXT line pitch per unit of text height at line spacing factor 1 (the layout's 5/3 in
|
||||
/// `cadcraft_fonts`): Line space distance = factor × text height × `LINE_PITCH`.
|
||||
pub const LINE_PITCH: f64 = 5.0 / 3.0;
|
||||
|
||||
/// Above this many dimensions, their measurement and text position aren't worked out (each
|
||||
/// needs the dimension's geometry); the rows show *VARIES*.
|
||||
const GEOMETRY_CAP: usize = 256;
|
||||
|
||||
/// The Properties of a selection.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||||
pub struct Description {
|
||||
/// The object types selected and how many of each, in the order first selected.
|
||||
pub types: Vec<TypeCount>,
|
||||
/// The type the description is limited to; `None`: every selected object.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub filter: Option<&'static str>,
|
||||
/// How many objects the rows describe.
|
||||
pub count: usize,
|
||||
pub groups: Vec<Group>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
||||
pub struct TypeCount {
|
||||
#[serde(rename = "type")]
|
||||
pub name: &'static str,
|
||||
pub count: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||||
pub struct Group {
|
||||
pub name: &'static str,
|
||||
pub rows: Vec<Row>,
|
||||
}
|
||||
|
||||
/// One property of the described objects.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Row {
|
||||
/// The `properties.set` key that changes it.
|
||||
pub key: &'static str,
|
||||
pub label: &'static str,
|
||||
pub kind: Kind,
|
||||
/// The value every described object has; `null` when they differ.
|
||||
pub value: Value,
|
||||
pub varies: bool,
|
||||
/// The value as shown: lengths in the drawing's units (LUNITS/LUPREC), angles in its angle
|
||||
/// units (AUNITS/AUPREC), choices by their label; *VARIES* when the objects differ.
|
||||
pub display: String,
|
||||
pub editable: bool,
|
||||
/// Why the row can't be edited, or what decides its value.
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub note: Option<String>,
|
||||
/// Dimension rows: a described dimension overrides its style here.
|
||||
#[serde(skip_serializing_if = "is_false")]
|
||||
pub overridden: bool,
|
||||
/// The values a choice or style row can take.
|
||||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||||
pub options: Vec<Choice>,
|
||||
/// One of the rows Quick Properties shows.
|
||||
#[serde(skip_serializing_if = "is_false")]
|
||||
pub quick: bool,
|
||||
}
|
||||
|
||||
fn is_false(b: &bool) -> bool {
|
||||
!*b
|
||||
}
|
||||
|
||||
impl Row {
|
||||
fn quick(mut self) -> Self {
|
||||
self.quick = true;
|
||||
self
|
||||
}
|
||||
fn read_only(mut self) -> Self {
|
||||
self.editable = false;
|
||||
self
|
||||
}
|
||||
fn overridden_if(mut self, overridden: bool) -> Self {
|
||||
self.overridden = overridden;
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||||
pub struct Choice {
|
||||
pub value: Value,
|
||||
pub label: String,
|
||||
}
|
||||
|
||||
impl Choice {
|
||||
fn new(value: Value, label: impl Into<String>) -> Self {
|
||||
Choice { value, label: label.into() }
|
||||
}
|
||||
}
|
||||
|
||||
/// How a row's value is entered and shown.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum Kind {
|
||||
/// One line of text.
|
||||
Text,
|
||||
/// MTEXT contents, inline formatting codes included.
|
||||
Contents,
|
||||
/// A plain number (factors, scales).
|
||||
Number,
|
||||
/// A length in drawing units.
|
||||
Distance,
|
||||
/// An angle in degrees.
|
||||
Angle,
|
||||
/// A direction (a text's rotation): `value` is in degrees counterclockwise from +X, as
|
||||
/// `properties.set` takes it; `display` shows it as the drawing measures directions, from
|
||||
/// ANGBASE in the ANGDIR sense (#1275).
|
||||
Direction,
|
||||
Bool,
|
||||
/// One of `options`.
|
||||
Choice,
|
||||
Color,
|
||||
Layer,
|
||||
Linetype,
|
||||
Lineweight,
|
||||
Transparency,
|
||||
TextStyle,
|
||||
DimStyle,
|
||||
}
|
||||
|
||||
/// A transparency as `properties.set` takes it: "ByLayer", "ByBlock" or a percentage.
|
||||
pub fn transparency_value(t: Transparency) -> Value {
|
||||
match t {
|
||||
Transparency::Percent(p) => json!(p),
|
||||
other => json!(other.name()),
|
||||
}
|
||||
}
|
||||
|
||||
/// The Properties of the objects `handles` (model space and layouts), limited to the objects
|
||||
/// of type `filter` (a name from [`Description::types`]) when it names one. Handles that don't
|
||||
/// name an object are left out.
|
||||
pub fn describe(d: &Drawing, handles: &[Handle], filter: Option<&str>) -> Description {
|
||||
let mut seen = HashSet::new();
|
||||
let all: Vec<&Entity> = handles.iter().filter(|h| seen.insert(**h)).filter_map(|h| d.entity(*h).map(|e| &**e)).collect();
|
||||
let mut types: Vec<TypeCount> = Vec::new();
|
||||
for e in &all {
|
||||
let name = e.kind.type_name();
|
||||
match types.iter_mut().find(|t| t.name == name) {
|
||||
Some(t) => t.count += 1,
|
||||
None => types.push(TypeCount { name, count: 1 }),
|
||||
}
|
||||
}
|
||||
let filter = filter.and_then(|f| types.iter().find(|t| t.name.eq_ignore_ascii_case(f.trim())).map(|t| t.name));
|
||||
let ents: Vec<&Entity> = all.into_iter().filter(|e| filter.is_none_or(|f| e.kind.type_name() == f)).collect();
|
||||
let c = Ctx::new(d);
|
||||
let mut groups = Vec::new();
|
||||
if !ents.is_empty() {
|
||||
groups.push(general(&c, &ents));
|
||||
let texts: Vec<&Text> = ents.iter().filter_map(|e| if let EntityKind::Text(t) = &e.kind { Some(t) } else { None }).collect();
|
||||
let mtexts: Vec<&MText> = ents.iter().filter_map(|e| if let EntityKind::MText(t) = &e.kind { Some(t) } else { None }).collect();
|
||||
let dims: Vec<&Dimension> = ents.iter().filter_map(|e| if let EntityKind::Dimension(t) = &e.kind { Some(t) } else { None }).collect();
|
||||
// Type groups only when every described object is of that type (AutoCAD shows the
|
||||
// common properties of a mixed selection).
|
||||
if texts.len() == ents.len() {
|
||||
groups.extend(text_groups(&c, &ents, &texts));
|
||||
} else if mtexts.len() == ents.len() {
|
||||
groups.extend(mtext_groups(&c, &ents, &mtexts));
|
||||
} else if dims.len() == ents.len() {
|
||||
groups.extend(dimension_groups(&c, &ents, &dims));
|
||||
}
|
||||
}
|
||||
Description { types, filter, count: ents.len(), groups }
|
||||
}
|
||||
|
||||
/// Unit settings and the drawing, for formatting rows.
|
||||
struct Ctx<'a> {
|
||||
d: &'a Drawing,
|
||||
lunits: i64,
|
||||
luprec: i64,
|
||||
aunits: i64,
|
||||
auprec: i64,
|
||||
angles: units::AngleSettings,
|
||||
}
|
||||
|
||||
impl<'a> Ctx<'a> {
|
||||
fn new(d: &'a Drawing) -> Self {
|
||||
let h = &d.header;
|
||||
Ctx {
|
||||
d,
|
||||
lunits: h.i64("LUNITS", 2),
|
||||
luprec: h.i64("LUPREC", 4),
|
||||
aunits: h.i64("AUNITS", 0),
|
||||
auprec: h.i64("AUPREC", 0),
|
||||
angles: units::AngleSettings::from_header(h),
|
||||
}
|
||||
}
|
||||
|
||||
fn distance(&self, v: f64) -> String {
|
||||
units::format_distance(v, self.lunits, self.luprec)
|
||||
}
|
||||
|
||||
/// `deg` in the drawing's angle units.
|
||||
fn angle(&self, deg: f64) -> String {
|
||||
units::format_angle(deg.to_radians(), self.aunits, self.auprec)
|
||||
}
|
||||
|
||||
fn show(&self, kind: Kind, v: &Value, options: &[Choice]) -> String {
|
||||
match kind {
|
||||
Kind::Distance => v.as_f64().map(|x| self.distance(x)).unwrap_or_default(),
|
||||
Kind::Number => v.as_f64().map(|x| format!("{x:.4}")).unwrap_or_default(),
|
||||
Kind::Angle => v.as_f64().map(|x| self.angle(x)).unwrap_or_default(),
|
||||
Kind::Direction => v.as_f64().map(|x| self.angle(self.angles.shown(x.to_radians()).to_degrees())).unwrap_or_default(),
|
||||
Kind::Bool => (if v.as_bool() == Some(true) { "Yes" } else { "No" }).to_string(),
|
||||
Kind::Choice => options.iter().find(|o| o.value == *v).map(|o| o.label.clone()).unwrap_or_else(|| plain(v)),
|
||||
_ => plain(v),
|
||||
}
|
||||
}
|
||||
|
||||
/// A row valued by `values` (one per described object).
|
||||
fn row(&self, key: &'static str, label: &'static str, kind: Kind, values: impl IntoIterator<Item = Value>) -> Row {
|
||||
self.choice(key, label, kind, Vec::new(), values)
|
||||
}
|
||||
|
||||
/// A row with options (a choice, or a style picked from the drawing's styles).
|
||||
fn choice(&self, key: &'static str, label: &'static str, kind: Kind, options: Vec<Choice>, values: impl IntoIterator<Item = Value>) -> Row {
|
||||
let mut it = values.into_iter();
|
||||
let first = it.next().unwrap_or(Value::Null);
|
||||
let varies = it.any(|v| !same(&v, &first));
|
||||
let (value, display) = if varies { (Value::Null, VARIES.to_string()) } else { (first.clone(), self.show(kind, &first, &options)) };
|
||||
Row { key, label, kind, value, varies, display, editable: true, note: None, overridden: false, options, quick: false }
|
||||
}
|
||||
|
||||
fn text_styles(&self) -> Vec<Choice> {
|
||||
self.d.text_styles.iter().map(|t| Choice::new(json!(t.name), t.name.clone())).collect()
|
||||
}
|
||||
|
||||
fn dim_styles(&self) -> Vec<Choice> {
|
||||
self.d.dim_styles.iter().map(|t| Choice::new(json!(t.name), t.name.clone())).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// A value as plain text: strings as they are, numbers and booleans as JSON writes them.
|
||||
fn plain(v: &Value) -> String {
|
||||
match v {
|
||||
Value::String(s) => s.clone(),
|
||||
Value::Null => String::new(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn general(c: &Ctx, ents: &[&Entity]) -> Group {
|
||||
let rows = vec![
|
||||
c.row("color", "Color", Kind::Color, ents.iter().map(|e| json!(e.common.color.name()))),
|
||||
c.row("layer", "Layer", Kind::Layer, ents.iter().map(|e| json!(e.common.layer))).quick(),
|
||||
c.row("linetype", "Linetype", Kind::Linetype, ents.iter().map(|e| json!(e.common.linetype))),
|
||||
c.row("ltscale", "Linetype scale", Kind::Number, ents.iter().map(|e| json!(e.common.ltscale))),
|
||||
c.row("lineweight", "Lineweight", Kind::Lineweight, ents.iter().map(|e| json!(e.common.lineweight.name()))),
|
||||
c.row("transparency", "Transparency", Kind::Transparency, ents.iter().map(|e| transparency_value(e.common.transparency))),
|
||||
];
|
||||
Group { name: "General", rows }
|
||||
}
|
||||
|
||||
fn annotative(c: &Ctx, ents: &[&Entity]) -> Row {
|
||||
c.row("annotative", "Annotative", Kind::Bool, ents.iter().map(|e| json!(cadcraft_doc::is_annotative(e)))).quick()
|
||||
}
|
||||
|
||||
/// TEXT justifications as `properties.set` takes them, with their labels.
|
||||
pub const TEXT_JUSTIFY: &[(&str, &str)] = &[
|
||||
("Left", "Left"),
|
||||
("Center", "Center"),
|
||||
("Right", "Right"),
|
||||
("Align", "Align"),
|
||||
("Middle", "Middle"),
|
||||
("Fit", "Fit"),
|
||||
("TL", "Top left"),
|
||||
("TC", "Top center"),
|
||||
("TR", "Top right"),
|
||||
("ML", "Middle left"),
|
||||
("MC", "Middle center"),
|
||||
("MR", "Middle right"),
|
||||
("BL", "Bottom left"),
|
||||
("BC", "Bottom center"),
|
||||
("BR", "Bottom right"),
|
||||
];
|
||||
|
||||
/// MTEXT attachments 1–9 as `properties.set` takes them, with their labels.
|
||||
pub const MTEXT_JUSTIFY: &[(&str, &str)] = &[
|
||||
("TL", "Top left"),
|
||||
("TC", "Top center"),
|
||||
("TR", "Top right"),
|
||||
("ML", "Middle left"),
|
||||
("MC", "Middle center"),
|
||||
("MR", "Middle right"),
|
||||
("BL", "Bottom left"),
|
||||
("BC", "Bottom center"),
|
||||
("BR", "Bottom right"),
|
||||
];
|
||||
|
||||
fn options(list: &[(&str, &str)]) -> Vec<Choice> {
|
||||
list.iter().map(|(v, l)| Choice::new(json!(v), *l)).collect()
|
||||
}
|
||||
|
||||
/// The justification code of a TEXT (one of [`TEXT_JUSTIFY`]).
|
||||
pub fn text_justify(t: &Text) -> &'static str {
|
||||
match (t.halign, t.valign) {
|
||||
(HAlign::Aligned, _) => "Align",
|
||||
(HAlign::Fit, _) => "Fit",
|
||||
(HAlign::Middle, _) => "Middle",
|
||||
(HAlign::Left, VAlign::Baseline) => "Left",
|
||||
(HAlign::Center, VAlign::Baseline) => "Center",
|
||||
(HAlign::Right, VAlign::Baseline) => "Right",
|
||||
(HAlign::Left, VAlign::Top) => "TL",
|
||||
(HAlign::Center, VAlign::Top) => "TC",
|
||||
(HAlign::Right, VAlign::Top) => "TR",
|
||||
(HAlign::Left, VAlign::Middle) => "ML",
|
||||
(HAlign::Center, VAlign::Middle) => "MC",
|
||||
(HAlign::Right, VAlign::Middle) => "MR",
|
||||
(HAlign::Left, VAlign::Bottom) => "BL",
|
||||
(HAlign::Center, VAlign::Bottom) => "BC",
|
||||
(HAlign::Right, VAlign::Bottom) => "BR",
|
||||
}
|
||||
}
|
||||
|
||||
/// The justification code of an MTEXT attachment (1–9; anything else reads as top left).
|
||||
pub fn mtext_justify(attach: u8) -> &'static str {
|
||||
MTEXT_JUSTIFY.get(usize::from(attach.max(1)) - 1).map_or("TL", |(code, _)| *code)
|
||||
}
|
||||
|
||||
fn text_groups(c: &Ctx, ents: &[&Entity], texts: &[&Text]) -> Vec<Group> {
|
||||
let mut text = vec![
|
||||
c.row("text", "Contents", Kind::Text, texts.iter().map(|t| json!(t.value))).quick(),
|
||||
c.choice("style", "Style", Kind::TextStyle, c.text_styles(), texts.iter().map(|t| json!(t.style))).quick(),
|
||||
annotative(c, ents),
|
||||
c.choice("justify", "Justification", Kind::Choice, options(TEXT_JUSTIFY), texts.iter().map(|t| json!(text_justify(t)))).quick(),
|
||||
c.row("height", "Height", Kind::Distance, texts.iter().map(|t| json!(t.height))).quick(),
|
||||
c.row("rotation", "Rotation", Kind::Direction, texts.iter().map(|t| json!(t.rotation.to_degrees()))).quick(),
|
||||
c.row("widthFactor", "Width factor", Kind::Number, texts.iter().map(|t| json!(t.width_factor))),
|
||||
c.row("oblique", "Obliquing", Kind::Angle, texts.iter().map(|t| json!(t.oblique.to_degrees()))),
|
||||
];
|
||||
// Aligned and fit text sit between two points: the second is the text alignment point.
|
||||
let second: Option<Vec<cadcraft_geom::Vec3>> =
|
||||
texts.iter().map(|t| if matches!(t.halign, HAlign::Aligned | HAlign::Fit) { t.align_pt } else { None }).collect();
|
||||
if let Some(pts) = second {
|
||||
text.push(c.row("alignmentX", "Text alignment X", Kind::Distance, pts.iter().map(|p| json!(p.x))));
|
||||
text.push(c.row("alignmentY", "Text alignment Y", Kind::Distance, pts.iter().map(|p| json!(p.y))));
|
||||
}
|
||||
// The position is the point the text is placed by (see `Text::justify_point`).
|
||||
let geometry = vec![
|
||||
c.row("positionX", "Position X", Kind::Distance, texts.iter().map(|t| json!(t.justify_point().x))),
|
||||
c.row("positionY", "Position Y", Kind::Distance, texts.iter().map(|t| json!(t.justify_point().y))),
|
||||
c.row("positionZ", "Position Z", Kind::Distance, texts.iter().map(|t| json!(t.insert.z))),
|
||||
];
|
||||
vec![Group { name: "Text", rows: text }, Group { name: "Geometry", rows: geometry }]
|
||||
}
|
||||
|
||||
fn mtext_groups(c: &Ctx, ents: &[&Entity], mts: &[&MText]) -> Vec<Group> {
|
||||
let spacing = vec![Choice::new(json!("atLeast"), "At least"), Choice::new(json!("exactly"), "Exactly")];
|
||||
let columns = |t: &MText| match &t.columns {
|
||||
None => "None".to_string(),
|
||||
Some(col) => match col.kind {
|
||||
cadcraft_doc::MTextColumnType::Static => format!("Static ({})", col.count.max(1)),
|
||||
cadcraft_doc::MTextColumnType::Dynamic => "Dynamic".to_string(),
|
||||
},
|
||||
};
|
||||
let text = vec![
|
||||
c.row("text", "Contents", Kind::Contents, mts.iter().map(|t| json!(t.contents))).quick(),
|
||||
c.choice("style", "Style", Kind::TextStyle, c.text_styles(), mts.iter().map(|t| json!(t.style))).quick(),
|
||||
annotative(c, ents),
|
||||
c.choice("justify", "Justification", Kind::Choice, options(MTEXT_JUSTIFY), mts.iter().map(|t| json!(mtext_justify(t.attach)))).quick(),
|
||||
c.row("height", "Text height", Kind::Distance, mts.iter().map(|t| json!(t.height))).quick(),
|
||||
c.row("rotation", "Rotation", Kind::Direction, mts.iter().map(|t| json!(t.rotation.to_degrees()))).quick(),
|
||||
c.row("lineSpacing", "Line space factor", Kind::Number, mts.iter().map(|t| json!(t.line_spacing))),
|
||||
c.row("lineSpacingDistance", "Line space distance", Kind::Distance, mts.iter().map(|t| json!(t.line_spacing * t.height * LINE_PITCH))),
|
||||
c.choice(
|
||||
"lineSpacingStyle",
|
||||
"Line space style",
|
||||
Kind::Choice,
|
||||
spacing,
|
||||
mts.iter().map(|t| json!(if t.line_spacing_exact { "exactly" } else { "atLeast" })),
|
||||
),
|
||||
c.row("width", "Defined width", Kind::Distance, mts.iter().map(|t| json!(t.width))),
|
||||
c.row("columns", "Columns", Kind::Text, mts.iter().map(|t| json!(columns(t)))).read_only(),
|
||||
];
|
||||
let geometry = vec![
|
||||
c.row("positionX", "Position X", Kind::Distance, mts.iter().map(|t| json!(t.insert.x))),
|
||||
c.row("positionY", "Position Y", Kind::Distance, mts.iter().map(|t| json!(t.insert.y))),
|
||||
c.row("positionZ", "Position Z", Kind::Distance, mts.iter().map(|t| json!(t.insert.z))),
|
||||
];
|
||||
vec![Group { name: "Text", rows: text }, Group { name: "Geometry", rows: geometry }]
|
||||
}
|
||||
|
||||
/// How a dimension style variable is entered.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum DimPropKind {
|
||||
Distance,
|
||||
Number,
|
||||
/// Degrees.
|
||||
Angle,
|
||||
Bool,
|
||||
/// Numbers with labels.
|
||||
Choice(&'static [(i64, &'static str)]),
|
||||
/// Decimal places 0–8.
|
||||
Precision,
|
||||
Color,
|
||||
TextStyle,
|
||||
/// A linetype name; "" (and "ByBlock") is ByBlock.
|
||||
Linetype,
|
||||
/// Hundredths of a millimetre, or -1 ByLayer, -2 ByBlock, -3 Default.
|
||||
Lineweight,
|
||||
/// An arrowhead name ("" is closed filled).
|
||||
Arrow,
|
||||
/// The decimal separator.
|
||||
Separator,
|
||||
}
|
||||
|
||||
/// A dimension style variable as a Properties row.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct DimProp {
|
||||
/// The [`DimStyle`] field (camelCase), which is also the `properties.set` key.
|
||||
pub field: &'static str,
|
||||
pub group: &'static str,
|
||||
pub label: &'static str,
|
||||
pub kind: DimPropKind,
|
||||
/// Shown in the Properties palette (the rest belong to the style dialog only).
|
||||
pub palette: bool,
|
||||
}
|
||||
|
||||
const fn prop(field: &'static str, group: &'static str, label: &'static str, kind: DimPropKind) -> DimProp {
|
||||
DimProp { field, group, label, kind, palette: true }
|
||||
}
|
||||
|
||||
const fn style_only(field: &'static str, group: &'static str, label: &'static str, kind: DimPropKind) -> DimProp {
|
||||
DimProp { field, group, label, kind, palette: false }
|
||||
}
|
||||
|
||||
/// The groups dimension rows come in, in order (after Misc).
|
||||
pub const DIM_GROUPS: &[&str] = &["Lines & Arrows", "Text", "Fit", "Primary Units", "Alternate Units", "Tolerances"];
|
||||
|
||||
const TEXT_POS_HOR: &[(i64, &str)] = &[(0, "Centered"), (1, "At Ext Line 1"), (2, "At Ext Line 2"), (3, "Over Ext Line 1"), (4, "Over Ext Line 2")];
|
||||
const TEXT_POS_VERT: &[(i64, &str)] = &[(0, "Centered"), (1, "Above"), (2, "Outside"), (3, "JIS"), (4, "Below")];
|
||||
const FIT: &[(i64, &str)] = &[(0, "Text and arrows"), (1, "Arrows"), (2, "Text"), (3, "Best fit")];
|
||||
const TEXT_MOVE: &[(i64, &str)] = &[(0, "Keep dim line with text"), (1, "Move text, add leader"), (2, "Move text, no leader")];
|
||||
const LINEAR_UNITS: &[(i64, &str)] =
|
||||
&[(1, "Scientific"), (2, "Decimal"), (3, "Engineering"), (4, "Architectural"), (5, "Fractional"), (6, "Windows desktop")];
|
||||
const ALT_UNITS: &[(i64, &str)] = &[
|
||||
(1, "Scientific"),
|
||||
(2, "Decimal"),
|
||||
(3, "Engineering"),
|
||||
(4, "Architectural stacked"),
|
||||
(5, "Fractional stacked"),
|
||||
(6, "Architectural"),
|
||||
(7, "Fractional"),
|
||||
(8, "Windows desktop"),
|
||||
];
|
||||
const ANGLE_FORMAT: &[(i64, &str)] = &[(0, "Decimal degrees"), (1, "Degrees Minutes Seconds"), (2, "Gradians"), (3, "Radians")];
|
||||
const FRACTION_FORMAT: &[(i64, &str)] = &[(0, "Horizontal stacking"), (1, "Diagonal stacking"), (2, "Not stacked")];
|
||||
const TOL_POS: &[(i64, &str)] = &[(0, "Bottom"), (1, "Middle"), (2, "Top")];
|
||||
const ARC_SYMBOL: &[(i64, &str)] = &[(0, "Before text"), (1, "Above text"), (2, "None")];
|
||||
|
||||
/// Every modeled dimension style variable as a row, grouped as AutoCAD's Properties palette
|
||||
/// groups dimension properties. The rows not shown in the palette are style settings only.
|
||||
pub const DIM_PROPS: &[DimProp] = &[
|
||||
// Lines & Arrows
|
||||
prop("arrowBlock1", "Lines & Arrows", "Arrow 1", DimPropKind::Arrow),
|
||||
prop("arrowBlock2", "Lines & Arrows", "Arrow 2", DimPropKind::Arrow),
|
||||
style_only("arrowBlock", "Lines & Arrows", "Arrowheads", DimPropKind::Arrow),
|
||||
prop("arrowSize", "Lines & Arrows", "Arrow size", DimPropKind::Distance),
|
||||
prop("tickSize", "Lines & Arrows", "Tick size", DimPropKind::Distance),
|
||||
prop("dimLineColor", "Lines & Arrows", "Dim line color", DimPropKind::Color),
|
||||
prop("dimLinetype", "Lines & Arrows", "Dim line linetype", DimPropKind::Linetype),
|
||||
prop("dimLineweight", "Lines & Arrows", "Dim line lineweight", DimPropKind::Lineweight),
|
||||
prop("dimLineExtend", "Lines & Arrows", "Dim line ext", DimPropKind::Distance),
|
||||
prop("suppressDim1", "Lines & Arrows", "Hide dim line 1", DimPropKind::Bool),
|
||||
prop("suppressDim2", "Lines & Arrows", "Hide dim line 2", DimPropKind::Bool),
|
||||
prop("extLineColor", "Lines & Arrows", "Ext line color", DimPropKind::Color),
|
||||
prop("extLinetype1", "Lines & Arrows", "Ext line 1 linetype", DimPropKind::Linetype),
|
||||
prop("extLinetype2", "Lines & Arrows", "Ext line 2 linetype", DimPropKind::Linetype),
|
||||
prop("extLineweight", "Lines & Arrows", "Ext line lineweight", DimPropKind::Lineweight),
|
||||
prop("extExtend", "Lines & Arrows", "Ext line ext", DimPropKind::Distance),
|
||||
prop("extOffset", "Lines & Arrows", "Ext line offset", DimPropKind::Distance),
|
||||
prop("fixedExt", "Lines & Arrows", "Ext line fixed", DimPropKind::Bool),
|
||||
prop("fixedExtLength", "Lines & Arrows", "Ext line length", DimPropKind::Distance),
|
||||
prop("suppressExt1", "Lines & Arrows", "Hide ext line 1", DimPropKind::Bool),
|
||||
prop("suppressExt2", "Lines & Arrows", "Hide ext line 2", DimPropKind::Bool),
|
||||
prop("centerMark", "Lines & Arrows", "Center mark size", DimPropKind::Distance),
|
||||
prop("jogAngle", "Lines & Arrows", "Jog angle", DimPropKind::Angle),
|
||||
prop("arcSymbol", "Lines & Arrows", "Arc length symbol", DimPropKind::Choice(ARC_SYMBOL)),
|
||||
style_only("leaderArrowBlock", "Lines & Arrows", "Leader arrow", DimPropKind::Arrow),
|
||||
style_only("baselineSpacing", "Lines & Arrows", "Baseline spacing", DimPropKind::Distance),
|
||||
// Text
|
||||
prop("textColor", "Text", "Text color", DimPropKind::Color),
|
||||
prop("textHeight", "Text", "Text height", DimPropKind::Distance),
|
||||
prop("textGap", "Text", "Text offset", DimPropKind::Distance),
|
||||
prop("textOutsideHorizontal", "Text", "Text outside align", DimPropKind::Bool),
|
||||
prop("textJust", "Text", "Text pos hor", DimPropKind::Choice(TEXT_POS_HOR)),
|
||||
prop("textAbove", "Text", "Text pos vert", DimPropKind::Choice(TEXT_POS_VERT)),
|
||||
prop("textStyle", "Text", "Text style", DimPropKind::TextStyle),
|
||||
prop("textInsideHorizontal", "Text", "Text inside align", DimPropKind::Bool),
|
||||
style_only("textVerticalPos", "Text", "Text vertical position", DimPropKind::Number),
|
||||
// Fit
|
||||
prop("forceLineInside", "Fit", "Dim line forced", DimPropKind::Bool),
|
||||
prop("suppressOutsideArrows", "Fit", "Suppress arrows", DimPropKind::Bool),
|
||||
prop("scale", "Fit", "Dim scale overall", DimPropKind::Number),
|
||||
prop("fit", "Fit", "Fit", DimPropKind::Choice(FIT)),
|
||||
prop("textInside", "Fit", "Text inside", DimPropKind::Bool),
|
||||
prop("textMove", "Fit", "Text movement", DimPropKind::Choice(TEXT_MOVE)),
|
||||
// Primary Units
|
||||
prop("decimalSeparator", "Primary Units", "Decimal separator", DimPropKind::Separator),
|
||||
prop("round", "Primary Units", "Dim roundoff", DimPropKind::Distance),
|
||||
prop("linearFactor", "Primary Units", "Dim scale linear", DimPropKind::Number),
|
||||
prop("linearUnit", "Primary Units", "Dim units", DimPropKind::Choice(LINEAR_UNITS)),
|
||||
prop("decimals", "Primary Units", "Precision", DimPropKind::Precision),
|
||||
prop("fractionFormat", "Primary Units", "Fraction format", DimPropKind::Choice(FRACTION_FORMAT)),
|
||||
prop("angularUnit", "Primary Units", "Angle format", DimPropKind::Choice(ANGLE_FORMAT)),
|
||||
prop("angularDecimals", "Primary Units", "Angle precision", DimPropKind::Precision),
|
||||
style_only("post", "Primary Units", "Prefix and suffix", DimPropKind::Number),
|
||||
style_only("zeroSuppression", "Primary Units", "Zero suppression", DimPropKind::Number),
|
||||
style_only("angularZeroSuppression", "Primary Units", "Angular zero suppression", DimPropKind::Number),
|
||||
// Alternate Units
|
||||
prop("alt", "Alternate Units", "Alt enabled", DimPropKind::Bool),
|
||||
prop("altUnit", "Alternate Units", "Alt format", DimPropKind::Choice(ALT_UNITS)),
|
||||
prop("altDecimals", "Alternate Units", "Alt precision", DimPropKind::Precision),
|
||||
prop("altFactor", "Alternate Units", "Alt scale factor", DimPropKind::Number),
|
||||
prop("altRound", "Alternate Units", "Alt round", DimPropKind::Number),
|
||||
style_only("altPost", "Alternate Units", "Alt prefix and suffix", DimPropKind::Number),
|
||||
style_only("altZeroSuppression", "Alternate Units", "Alt zero suppression", DimPropKind::Number),
|
||||
// Tolerances
|
||||
prop("tolerance", "Tolerances", "Tolerances", DimPropKind::Bool),
|
||||
prop("limits", "Tolerances", "Limits", DimPropKind::Bool),
|
||||
prop("tolPlus", "Tolerances", "Upper tolerance", DimPropKind::Number),
|
||||
prop("tolMinus", "Tolerances", "Lower tolerance", DimPropKind::Number),
|
||||
prop("tolDecimals", "Tolerances", "Tolerance precision", DimPropKind::Precision),
|
||||
prop("tolScale", "Tolerances", "Tolerance height", DimPropKind::Number),
|
||||
prop("tolJust", "Tolerances", "Tolerance pos vert", DimPropKind::Choice(TOL_POS)),
|
||||
style_only("tolZeroSuppression", "Tolerances", "Tolerance zero suppression", DimPropKind::Number),
|
||||
];
|
||||
|
||||
/// The arrowheads drawn in code, by the DIMBLK name stored for them and their label.
|
||||
pub const ARROWHEADS: &[(&str, &str)] = &[
|
||||
("", "Closed filled"),
|
||||
("_CLOSEDBLANK", "Closed blank"),
|
||||
("_CLOSED", "Closed"),
|
||||
("_DOT", "Dot"),
|
||||
("_ARCHTICK", "Architectural tick"),
|
||||
("_OBLIQUE", "Oblique"),
|
||||
("_OPEN", "Open arrow"),
|
||||
("_ORIGIN", "Origin indicator"),
|
||||
("_ORIGIN2", "Origin indicator 2"),
|
||||
("_OPEN90", "Right angle"),
|
||||
("_OPEN30", "Open 30"),
|
||||
("_DOTSMALL", "Dot small"),
|
||||
("_DOTBLANK", "Dot blank"),
|
||||
("_SMALL", "Small"),
|
||||
("_BOXBLANK", "Box blank"),
|
||||
("_BOXFILLED", "Box filled"),
|
||||
("_DATUMBLANK", "Datum triangle"),
|
||||
("_DATUMFILLED", "Datum triangle filled"),
|
||||
("_INTEGRAL", "Integral"),
|
||||
("_NONE", "None"),
|
||||
];
|
||||
|
||||
/// The row for dimension style field `field`, if it has one.
|
||||
pub fn dim_prop(field: &str) -> Option<&'static DimProp> {
|
||||
DIM_PROPS.iter().find(|p| p.field.eq_ignore_ascii_case(field))
|
||||
}
|
||||
|
||||
/// The dimension style fields whose value is a linetype name ("" is ByBlock).
|
||||
pub fn is_dim_linetype(field: &str) -> bool {
|
||||
matches!(field, "dimLinetype" | "extLinetype1" | "extLinetype2")
|
||||
}
|
||||
|
||||
impl DimPropKind {
|
||||
/// The values a choice kind can take, with their labels (none for the other kinds; text
|
||||
/// styles are the drawing's).
|
||||
pub fn options(self) -> Vec<Choice> {
|
||||
match self {
|
||||
DimPropKind::Choice(list) => list.iter().map(|(v, l)| Choice::new(json!(v), *l)).collect(),
|
||||
DimPropKind::Precision => {
|
||||
(0..=8u8).map(|n| Choice::new(json!(n), if n == 0 { "0".into() } else { format!("0.{}", "0".repeat(usize::from(n))) })).collect()
|
||||
}
|
||||
DimPropKind::Lineweight => {
|
||||
let mut o = vec![Choice::new(json!(-2), "ByBlock"), Choice::new(json!(-1), "ByLayer"), Choice::new(json!(-3), "Default")];
|
||||
o.extend(Lineweight::STANDARD.iter().map(|w| Choice::new(json!(w), Lineweight::Mm100(*w).name())));
|
||||
o
|
||||
}
|
||||
DimPropKind::Arrow => ARROWHEADS.iter().map(|(v, l)| Choice::new(json!(v), *l)).collect(),
|
||||
DimPropKind::Separator => [(".", "Period"), (",", "Comma"), (" ", "Space")].iter().map(|(v, l)| Choice::new(json!(v), *l)).collect(),
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn row_kind(self, c: &Ctx) -> (Kind, Vec<Choice>) {
|
||||
match self {
|
||||
DimPropKind::Distance => (Kind::Distance, Vec::new()),
|
||||
DimPropKind::Number => (Kind::Number, Vec::new()),
|
||||
DimPropKind::Angle => (Kind::Angle, Vec::new()),
|
||||
DimPropKind::Bool => (Kind::Bool, Vec::new()),
|
||||
DimPropKind::Color => (Kind::Color, Vec::new()),
|
||||
DimPropKind::TextStyle => (Kind::TextStyle, c.text_styles()),
|
||||
DimPropKind::Linetype => (Kind::Linetype, Vec::new()),
|
||||
DimPropKind::Choice(_) | DimPropKind::Precision | DimPropKind::Lineweight | DimPropKind::Arrow | DimPropKind::Separator => {
|
||||
(Kind::Choice, self.options())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `name` normalized as the renderer reads arrowhead names ("_DOT", "dot" and "Dot" alike).
|
||||
fn arrow_key(name: &str) -> String {
|
||||
name.trim().trim_start_matches('_').chars().filter(char::is_ascii_alphanumeric).collect::<String>().to_ascii_lowercase()
|
||||
}
|
||||
|
||||
/// A dimension style field's value as the row shows and `properties.set` takes it: a color's
|
||||
/// name, ByBlock for an empty linetype, and the arrowhead an empty per-end arrowhead draws.
|
||||
pub fn dim_value(p: &DimProp, st: &Value) -> Value {
|
||||
let v = st.get(p.field).cloned().unwrap_or(Value::Null);
|
||||
match p.kind {
|
||||
DimPropKind::Color => serde_json::from_value::<cadcraft_color::Color>(v).map(|c| json!(c.name())).unwrap_or(Value::Null),
|
||||
DimPropKind::Linetype => match v.as_str() {
|
||||
Some("") | None => json!("ByBlock"),
|
||||
Some(_) => v,
|
||||
},
|
||||
DimPropKind::Arrow => {
|
||||
// Per-end arrowheads left empty use DIMBLK (an empty leader arrowhead is closed filled).
|
||||
let name = v.as_str().filter(|s| !s.is_empty() || !matches!(p.field, "arrowBlock1" | "arrowBlock2")).map(str::to_string);
|
||||
let name = name.unwrap_or_else(|| st.get("arrowBlock").and_then(Value::as_str).unwrap_or_default().to_string());
|
||||
// A drawn arrowhead reads as its standard name; a block of the user's stays as it is.
|
||||
match ARROWHEADS.iter().find(|(n, _)| arrow_key(n) == arrow_key(&name) || (n.is_empty() && arrow_key(&name) == "closedfilled")) {
|
||||
Some((n, _)) => json!(n),
|
||||
None => json!(name),
|
||||
}
|
||||
}
|
||||
_ => v,
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether dimension `dm` overrides style field `field`.
|
||||
fn overrides(dm: &Dimension, field: &str) -> bool {
|
||||
dm.overrides.keys().any(|k| DimStyle::field_name(k) == Some(field))
|
||||
}
|
||||
|
||||
/// The prefix and suffix of a DIMPOST/DIMAPOST template: around `<>`, or the whole template
|
||||
/// as a suffix when it has no `<>` (as the renderer reads it).
|
||||
pub fn split_post(template: &str) -> (String, String) {
|
||||
match template.split_once("<>") {
|
||||
Some((pre, post)) => (pre.to_string(), post.to_string()),
|
||||
None => (String::new(), template.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
/// A DIMPOST/DIMAPOST template from a prefix and a suffix.
|
||||
pub fn join_post(prefix: &str, suffix: &str) -> String {
|
||||
if prefix.is_empty() { suffix.to_string() } else { format!("{prefix}<>{suffix}") }
|
||||
}
|
||||
|
||||
/// The measurement as the dimension writes it (its own units and precision).
|
||||
fn measurement_text(dm: &Dimension, st: &DimStyle, meas: f64) -> String {
|
||||
match dm.kind {
|
||||
// As the renderer writes angles: DIMAUNIT, DIMADEC, and DIMAZIN's leading and trailing zeros.
|
||||
DimKind::Angular | DimKind::Angular3P => {
|
||||
cadcraft_render::units::format_angle(meas, st.angular_unit, st.angular_decimals, (st.angular_zero_suppression & 3) * 4)
|
||||
}
|
||||
_ => cadcraft_render::format_linear_value(meas, st),
|
||||
}
|
||||
}
|
||||
|
||||
fn dimension_groups(c: &Ctx, ents: &[&Entity], dims: &[&Dimension]) -> Vec<Group> {
|
||||
let styles: Vec<DimStyle> = dims.iter().map(|dm| c.d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides)).collect();
|
||||
let values: Vec<Value> = styles.iter().map(|st| serde_json::to_value(st).unwrap_or(Value::Null)).collect();
|
||||
// Measurement and text position need each dimension's geometry.
|
||||
let geometry: Option<Vec<cadcraft_render::DimGeometry>> =
|
||||
(dims.len() <= GEOMETRY_CAP).then(|| dims.iter().map(|dm| cadcraft_render::dimension_in(c.d, dm)).collect());
|
||||
let mut groups = vec![Group {
|
||||
name: "Misc",
|
||||
rows: vec![
|
||||
c.choice("dimStyle", "Dim style", Kind::DimStyle, c.dim_styles(), dims.iter().map(|dm| json!(dm.style))).quick(),
|
||||
annotative(c, ents),
|
||||
],
|
||||
}];
|
||||
for &name in DIM_GROUPS {
|
||||
let mut rows: Vec<Row> = Vec::new();
|
||||
for p in DIM_PROPS.iter().filter(|p| p.group == name && p.palette) {
|
||||
let (kind, options) = p.kind.row_kind(c);
|
||||
let mut r = c.choice(p.field, p.label, kind, options, values.iter().map(|v| dim_value(p, v)));
|
||||
r.overridden = dims.iter().any(|dm| overrides(dm, p.field));
|
||||
if p.field == "textHeight" {
|
||||
fixed_height(c, &mut r, &styles);
|
||||
}
|
||||
rows.push(r);
|
||||
}
|
||||
match name {
|
||||
"Text" => {
|
||||
let (xs, ys): (Vec<Value>, Vec<Value>) = match &geometry {
|
||||
Some(g) => g.iter().map(|g| (json!(g.text_pos.x), json!(g.text_pos.y))).unzip(),
|
||||
None => (vec![Value::Null, json!(VARIES)], vec![Value::Null, json!(VARIES)]),
|
||||
};
|
||||
rows.push(c.row("textPositionX", "Text position X", Kind::Distance, xs));
|
||||
rows.push(c.row("textPositionY", "Text position Y", Kind::Distance, ys));
|
||||
rows.push(c.row("textRotation", "Text rotation", Kind::Angle, dims.iter().map(|dm| json!(dm.text_rotation.to_degrees()))));
|
||||
let measured: Vec<(Value, String)> = match &geometry {
|
||||
Some(g) => g
|
||||
.iter()
|
||||
.zip(dims)
|
||||
.zip(&styles)
|
||||
.map(|((g, dm), st)| {
|
||||
let angular = matches!(dm.kind, DimKind::Angular | DimKind::Angular3P);
|
||||
(json!(if angular { g.measurement.to_degrees() } else { g.measurement }), measurement_text(dm, st, g.measurement))
|
||||
})
|
||||
.collect(),
|
||||
None => vec![(Value::Null, String::new()), (json!(VARIES), String::new())],
|
||||
};
|
||||
// A length, or an angle in degrees, shown as the dimension writes it.
|
||||
let mut m = c.row("measurement", "Measurement", Kind::Number, measured.iter().map(|(v, _)| v.clone())).read_only().quick();
|
||||
let shown = measured.first().map(|(_, s)| s.clone()).unwrap_or_default();
|
||||
// Equal measurements written differently (units, precision) vary too.
|
||||
if measured.iter().any(|(_, s)| *s != shown) {
|
||||
(m.value, m.varies, m.display) = (Value::Null, true, VARIES.to_string());
|
||||
} else if !m.varies {
|
||||
m.display = shown;
|
||||
}
|
||||
rows.push(m);
|
||||
rows.push(c.row("textOverride", "Text override", Kind::Text, dims.iter().map(|dm| json!(dm.text))).quick());
|
||||
}
|
||||
"Primary Units" => {
|
||||
let (pre, suf): (Vec<Value>, Vec<Value>) = styles.iter().map(|st| split_post(&st.post)).map(|(p, s)| (json!(p), json!(s))).unzip();
|
||||
let at = rows.iter().position(|r| r.key == "round").unwrap_or(rows.len());
|
||||
// Prefix and suffix are DIMPOST's two halves: overridden with it, and reset with it.
|
||||
let posted = dims.iter().any(|dm| overrides(dm, "post"));
|
||||
rows.insert(at, c.row("prefix", "Dim prefix", Kind::Text, pre).overridden_if(posted));
|
||||
let at = rows.iter().position(|r| r.key == "linearUnit").unwrap_or(rows.len());
|
||||
rows.insert(at, c.row("suffix", "Dim suffix", Kind::Text, suf).overridden_if(posted));
|
||||
}
|
||||
"Alternate Units" => {
|
||||
let (pre, suf): (Vec<Value>, Vec<Value>) =
|
||||
styles.iter().map(|st| split_post(&st.alt_post)).map(|(p, s)| (json!(p), json!(s))).unzip();
|
||||
let posted = dims.iter().any(|dm| overrides(dm, "altPost"));
|
||||
rows.push(c.row("altPrefix", "Alt prefix", Kind::Text, pre).overridden_if(posted));
|
||||
rows.push(c.row("altSuffix", "Alt suffix", Kind::Text, suf).overridden_if(posted));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
groups.push(Group { name, rows });
|
||||
}
|
||||
groups
|
||||
}
|
||||
|
||||
/// Equal values, numbers to 12 significant digits, as the palette compares them: float noise
|
||||
/// (7 and 7.0000000000001, or 1.2e-16 next to zero) is no difference, while values the display
|
||||
/// rounds alike (7 and 7.000001) still differ.
|
||||
fn same(a: &Value, b: &Value) -> bool {
|
||||
fn tag(v: f64) -> String {
|
||||
let v = if v.abs() < 1e-12 { 0.0 } else { v };
|
||||
format!("{:.11e}", v + 0.0)
|
||||
}
|
||||
match (a, b) {
|
||||
(Value::Number(x), Value::Number(y)) => match (x.as_f64(), y.as_f64()) {
|
||||
(Some(x), Some(y)) => tag(x) == tag(y),
|
||||
_ => x == y,
|
||||
},
|
||||
_ => a == b,
|
||||
}
|
||||
}
|
||||
|
||||
/// A fixed-height text style decides the dimension text height whatever DIMTXT says (as in
|
||||
/// AutoCAD); the row says so instead of taking edits that change nothing.
|
||||
fn fixed_height(c: &Ctx, r: &mut Row, styles: &[DimStyle]) {
|
||||
let fixed: Vec<Option<(&str, f64)>> = styles
|
||||
.iter()
|
||||
.map(|st| c.d.text_style(&st.text_style).filter(|ts| ts.height > 0.0 && ts.height.is_finite()).map(|ts| (ts.name.as_str(), ts.height)))
|
||||
.collect();
|
||||
let Some(&Some((name, h))) = fixed.iter().find(|f| f.is_some()) else { return };
|
||||
if fixed.iter().all(|f| *f == Some((name, h))) {
|
||||
r.value = json!(h);
|
||||
r.varies = false;
|
||||
r.display = c.distance(h);
|
||||
r.editable = false;
|
||||
r.note =
|
||||
Some(format!("Set by text style \"{name}\", which has a fixed height. Give the style a height of 0 to use the dimension text height."));
|
||||
} else {
|
||||
// Each dimension's text is its style's fixed height or its own DIMTXT.
|
||||
let heights: Vec<f64> = fixed.iter().zip(styles).map(|(f, st)| f.map_or(st.text_height, |(_, h)| h)).collect();
|
||||
let first = heights.first().copied().unwrap_or_default();
|
||||
if heights.iter().all(|h| *h == first) {
|
||||
(r.value, r.varies, r.display) = (json!(first), false, c.distance(first));
|
||||
} else {
|
||||
(r.value, r.varies, r.display) = (Value::Null, true, VARIES.to_string());
|
||||
}
|
||||
r.editable = fixed.iter().any(Option::is_none);
|
||||
r.note = Some("Some of these dimensions take their text height from a fixed-height text style.".into());
|
||||
}
|
||||
}
|
||||
@@ -61,6 +61,7 @@ impl Session {
|
||||
Ok(r) => r,
|
||||
Err(_) => {
|
||||
self.docs.truncate(n);
|
||||
self.lisp_forget_closed();
|
||||
self.active = self.active.min(self.docs.len().saturating_sub(1));
|
||||
self.bump_doc_epoch();
|
||||
Err(EngineError::Internal("open".into(), "panic".into()))
|
||||
|
||||
@@ -63,6 +63,7 @@ impl Session {
|
||||
let Some(spec) = find_command(&id) else {
|
||||
// A command defined in LISP: (defun c:NAME …).
|
||||
if !transparent && let Some(f) = self.lisp_command(&lower) {
|
||||
self.commands_started = self.commands_started.wrapping_add(1);
|
||||
if self.running.is_some() {
|
||||
self.cancel();
|
||||
}
|
||||
@@ -96,8 +97,11 @@ impl Session {
|
||||
self.echo(format!("Command: {}", spec.id.to_ascii_uppercase()));
|
||||
return self.input(Input::Keyword("Undo".into()));
|
||||
}
|
||||
if !nested && self.running.is_some() {
|
||||
self.cancel();
|
||||
if !nested {
|
||||
self.commands_started = self.commands_started.wrapping_add(1);
|
||||
if self.running.is_some() {
|
||||
self.cancel();
|
||||
}
|
||||
}
|
||||
(spec.enabled)(self).map_err(|m| EngineError::Disabled(spec.id.into(), m))?;
|
||||
if let Some(why) = cmd::blocks::bedit::refused_in_editor(self, spec.id) {
|
||||
@@ -378,7 +382,14 @@ impl Session {
|
||||
Ok(())
|
||||
}
|
||||
Ok(Step::Done) => {
|
||||
let seed = run.before.handseed;
|
||||
self.finish(run, false);
|
||||
let added = self.doc().is_ok_and(|d| d.handseed != seed);
|
||||
// A transparent command ending inside another (`'ZOOM` in an INSERT) is not that
|
||||
// command ending: it shares its number.
|
||||
if self.suspended.is_none() {
|
||||
self.last_finished = Some((self.commands_started, added));
|
||||
}
|
||||
self.resume_suspended();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -166,6 +166,10 @@ pub fn get(s: &Session, name: &str) -> Option<Value> {
|
||||
"CMDNAMES" => json!(s.running.as_ref().map(|r| r.id.to_ascii_uppercase()).unwrap_or_default()),
|
||||
"DWGNAME" => json!(s.state().map(|d| d.title.clone()).unwrap_or_default()),
|
||||
"DBMOD" => json!(s.state().map(|d| i32::from(d.is_dirty())).unwrap_or(0)),
|
||||
// The next handle the drawing gives out, in hex as `$HANDSEED` (the header keeps the
|
||||
// value the file was read with, which new objects don't move): past the handles the
|
||||
// file's own objects hold, as allocation skips them.
|
||||
"HANDSEED" => json!(format!("{:X}", s.doc().ok()?.next_handle().0)),
|
||||
// The drawing's folder with a trailing separator ("" while it has no file); DWGTITLED is 1 once it has one.
|
||||
"DWGPREFIX" => json!(s.state().ok().and_then(|d| d.path.as_deref()).map(dwg_prefix).unwrap_or_default()),
|
||||
"DWGTITLED" => json!(s.state().map(|d| i32::from(d.path.is_some())).unwrap_or(0)),
|
||||
@@ -254,6 +258,7 @@ const READ_ONLY: &[&str] = &[
|
||||
"TILEMODE",
|
||||
"PLATFORM",
|
||||
"DBMOD",
|
||||
"HANDSEED",
|
||||
"BLOCKEDITOR",
|
||||
"CTAB",
|
||||
"LASTPOINT",
|
||||
|
||||
@@ -0,0 +1,254 @@
|
||||
//! #1658: `attdef` takes a justification and a text style, as `text` and `mtext` do, so a
|
||||
//! title-block attribute can be built centred or right-aligned in its style without an `entmod`.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::{Attrib, EntityKind, HAlign, Handle, VAlign};
|
||||
use cadcraft_engine::geom::Vec3;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
fn h(v: &Value) -> Handle {
|
||||
v["handle"].as_str().and_then(Handle::parse_hex).unwrap()
|
||||
}
|
||||
|
||||
fn attdef(s: &Session, h: Handle) -> Attrib {
|
||||
match &s.doc().unwrap().entity(h).unwrap().kind {
|
||||
EntityKind::AttDef(a) => a.clone(),
|
||||
k => panic!("{k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs `attdef` with `p` and returns the definition it made.
|
||||
fn add(s: &mut Session, p: Value) -> Attrib {
|
||||
let made = h(&s.execute("attdef", &p).unwrap());
|
||||
attdef(s, made)
|
||||
}
|
||||
|
||||
/// The issue's drawing: a text style ROMANS beside the current Standard.
|
||||
fn session() -> Session {
|
||||
let mut s = Session::new();
|
||||
s.execute("style", &json!({"name": "ROMANS", "font": "romans.shx"})).unwrap();
|
||||
s.execute("style.current", &json!({"name": "Standard"})).unwrap();
|
||||
s
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn justify_and_style_are_applied() {
|
||||
let mut s = session();
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [10, 10], "height": 2.5, "justify": "MC", "style": "ROMANS"}));
|
||||
assert_eq!((a.text.halign, a.text.valign), (HAlign::Center, VAlign::Middle));
|
||||
assert_eq!(a.text.style, "ROMANS");
|
||||
assert_eq!(a.text.align_pt, Some(Vec3::new(10.0, 10.0, 0.0)), "justified text is placed by its alignment point");
|
||||
// Every code `text` takes, and the style name in any case (kept as the table spells it).
|
||||
for (j, want) in [
|
||||
("BR", (HAlign::Right, VAlign::Bottom)),
|
||||
("tl", (HAlign::Left, VAlign::Top)),
|
||||
("C", (HAlign::Center, VAlign::Baseline)),
|
||||
("M", (HAlign::Middle, VAlign::Baseline)),
|
||||
] {
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [0, 0], "justify": j, "style": "romans"}));
|
||||
assert_eq!((a.text.halign, a.text.valign), want, "{j}");
|
||||
assert_eq!(a.text.style, "ROMANS");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_them_nothing_changes() {
|
||||
let mut s = session();
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [10, 10]}));
|
||||
assert_eq!((a.text.halign, a.text.valign, a.text.align_pt), (HAlign::Left, VAlign::Baseline, None));
|
||||
assert_eq!(a.text.style, "Standard", "the current text style");
|
||||
// With another current style, that one: not always Standard.
|
||||
s.execute("style.current", &json!({"name": "ROMANS"})).unwrap();
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [10, 10]}));
|
||||
assert_eq!(a.text.style, "ROMANS", "the current text style");
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [10, 10], "justify": "L"}));
|
||||
assert_eq!((a.text.halign, a.text.valign, a.text.align_pt), (HAlign::Left, VAlign::Baseline, None));
|
||||
assert_eq!(a.text.style, "ROMANS", "the current text style");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_bad_justification_or_style_is_refused() {
|
||||
let mut s = session();
|
||||
let n = s.doc().unwrap().model.len();
|
||||
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "justify": "XX"})).is_err());
|
||||
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "style": "NOPE"})).is_err());
|
||||
// Align and Fit need a second baseline point, which attdef has no way to take.
|
||||
for j in ["A", "ALIGN", "F", "fit"] {
|
||||
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "justify": j})).is_err(), "{j}");
|
||||
}
|
||||
assert_eq!(s.doc().unwrap().model.len(), n, "nothing added");
|
||||
}
|
||||
|
||||
/// The issue's use: a block built from the definition gives its attributes the same placement,
|
||||
/// and a save and reopen keeps them.
|
||||
#[test]
|
||||
fn a_block_and_a_saved_file_keep_them() {
|
||||
let mut s = session();
|
||||
let ad =
|
||||
h(&s.execute("attdef", &json!({"tag": "TITLE", "default": "x", "at": [50, 10], "height": 2.5, "justify": "MC", "style": "ROMANS"})).unwrap());
|
||||
let l = s.execute("line", &json!({"points": [[0, 0], [100, 0]]})).unwrap()["handles"][0].as_str().and_then(Handle::parse_hex).unwrap();
|
||||
s.execute("block", &json!({"name": "TB", "base": [0, 0], "handles": [ad.hex(), l.hex()], "keep": "delete"})).unwrap();
|
||||
let ins = h(&s.execute("insert", &json!({"name": "TB", "at": [0, 0], "attribs": {"TITLE": "PLAN"}})).unwrap());
|
||||
let EntityKind::Insert(i) = &s.doc().unwrap().entity(ins).unwrap().kind else { panic!() };
|
||||
let att = i.attribs.first().unwrap();
|
||||
assert_eq!(
|
||||
(att.text.halign, att.text.valign, att.text.style.as_str(), att.text.value.as_str()),
|
||||
(HAlign::Center, VAlign::Middle, "ROMANS", "PLAN")
|
||||
);
|
||||
let read = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
|
||||
let def =
|
||||
read.block("TB").unwrap().entities.iter().find_map(|e| if let EntityKind::AttDef(a) = &e.kind { Some(a.clone()) } else { None }).unwrap();
|
||||
assert_eq!((def.text.halign, def.text.valign, def.text.style.as_str()), (HAlign::Center, VAlign::Middle, "ROMANS"), "reopened definition");
|
||||
let att = read.model.iter().find_map(|e| if let EntityKind::Insert(i) = &e.kind { i.attribs.first().cloned() } else { None }).unwrap();
|
||||
assert_eq!((att.text.halign, att.text.valign, att.text.style.as_str()), (HAlign::Center, VAlign::Middle, "ROMANS"), "reopened attribute");
|
||||
}
|
||||
|
||||
/// A `justify` or `style` that is present but not a string is an error, not a silent default (#1720).
|
||||
#[test]
|
||||
fn a_non_string_justify_or_style_is_refused() {
|
||||
let mut s = session();
|
||||
let n = s.doc().unwrap().model.len();
|
||||
for (key, bad) in [("justify", json!(1)), ("justify", json!(true)), ("style", json!(2)), ("style", json!(["ROMANS"]))] {
|
||||
let mut p = json!({"tag": "T", "at": [0, 0]});
|
||||
p[key] = bad.clone();
|
||||
let err = s.execute("attdef", &p).unwrap_err().to_string();
|
||||
assert!(err.contains(key) && err.contains("string"), "{key} = {bad}: {err}");
|
||||
}
|
||||
// Null means absent.
|
||||
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "justify": null, "style": null})).is_ok());
|
||||
assert_eq!(s.doc().unwrap().model.len(), n + 1, "only the null one was added");
|
||||
}
|
||||
|
||||
/// The definition takes its text style's width factor and oblique angle (#1720).
|
||||
#[test]
|
||||
fn the_definition_takes_the_styles_width_factor_and_oblique() {
|
||||
let mut s = session();
|
||||
s.execute("style", &json!({"name": "SLANT", "font": "romans.shx", "widthFactor": 0.7, "oblique": 15, "current": false})).unwrap();
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [0, 0], "style": "SLANT"}));
|
||||
assert!((a.text.width_factor - 0.7).abs() < 1e-12, "width factor {}", a.text.width_factor);
|
||||
assert!((a.text.oblique - 15f64.to_radians()).abs() < 1e-12, "oblique {}", a.text.oblique);
|
||||
// The current style, when none is named.
|
||||
s.execute("style.current", &json!({"name": "SLANT"})).unwrap();
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [0, 0]}));
|
||||
assert!((a.text.width_factor - 0.7).abs() < 1e-12 && (a.text.oblique - 15f64.to_radians()).abs() < 1e-12);
|
||||
// A plain style keeps 1 and 0.
|
||||
let a = add(&mut s, json!({"tag": "T", "at": [0, 0], "style": "Standard"}));
|
||||
assert_eq!((a.text.width_factor, a.text.oblique), (1.0, 0.0));
|
||||
}
|
||||
|
||||
/// `-ATTDEF` typed at the command line: accept modes, tag, prompt and default, then the point prompt.
|
||||
fn typed_to_start_point(s: &mut Session) {
|
||||
s.cmdline("-attdef").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
for line in ["TAG", "Prompt", "Default"] {
|
||||
s.cmdline(line).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
fn last_attdef(s: &Session) -> Attrib {
|
||||
let e = s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::AttDef(_))).last().unwrap();
|
||||
attdef(s, e.handle)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_start_point_prompt_offers_justify_and_style() {
|
||||
let mut s = session();
|
||||
typed_to_start_point(&mut s);
|
||||
assert!(s.prompt_text().contains("Specify start point of text or [Justify/Style]"), "{}", s.prompt_text());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_justify_then_a_point_justifies_the_definition() {
|
||||
let mut s = session();
|
||||
typed_to_start_point(&mut s);
|
||||
s.cmdline("J").unwrap();
|
||||
assert!(s.prompt_text().contains("Enter an option"), "{}", s.prompt_text());
|
||||
s.cmdline("MC").unwrap();
|
||||
assert!(s.prompt_text().contains("Specify middle point of text"), "{}", s.prompt_text());
|
||||
s.cmdline("10,10").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
assert!(s.running.is_none(), "{}", s.prompt_text());
|
||||
let a = last_attdef(&s);
|
||||
assert_eq!((a.text.halign, a.text.valign), (HAlign::Center, VAlign::Middle));
|
||||
assert_eq!(a.text.align_pt, Some(Vec3::new(10.0, 10.0, 0.0)), "stored as the JSON form does");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_justify_refuses_align_fit_and_unknown_codes_and_asks_again() {
|
||||
let mut s = session();
|
||||
typed_to_start_point(&mut s);
|
||||
s.cmdline("J").unwrap();
|
||||
for bad in ["A", "Fit", "XX"] {
|
||||
s.cmdline(bad).unwrap();
|
||||
assert!(s.log.iter().any(|l| l.contains("Invalid option") || l.contains("Align and Fit")), "{bad}: {:?}", s.log);
|
||||
s.log.clear();
|
||||
assert!(s.prompt_text().contains("Enter an option"), "{bad}: {}", s.prompt_text());
|
||||
}
|
||||
s.cmdline("TR").unwrap();
|
||||
s.cmdline("0,0").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
let a = last_attdef(&s);
|
||||
assert_eq!((a.text.halign, a.text.valign), (HAlign::Right, VAlign::Top));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_style_then_a_point_takes_the_styles_values() {
|
||||
let mut s = session();
|
||||
s.execute("style", &json!({"name": "SLANT", "font": "romans.shx", "widthFactor": 0.7, "oblique": 15, "current": false})).unwrap();
|
||||
typed_to_start_point(&mut s);
|
||||
s.cmdline("S").unwrap();
|
||||
assert!(s.prompt_text().contains("Enter style name"), "{}", s.prompt_text());
|
||||
s.cmdline("slant").unwrap();
|
||||
s.cmdline("0,0").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
let a = last_attdef(&s);
|
||||
assert_eq!(a.text.style, "SLANT");
|
||||
assert!((a.text.width_factor - 0.7).abs() < 1e-12 && (a.text.oblique - 15f64.to_radians()).abs() < 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_style_that_does_not_exist_asks_again() {
|
||||
let mut s = session();
|
||||
typed_to_start_point(&mut s);
|
||||
s.cmdline("S").unwrap();
|
||||
s.cmdline("NOPE").unwrap();
|
||||
assert!(s.log.iter().any(|l| l.contains("Cannot find text style \"NOPE\"")), "{:?}", s.log);
|
||||
assert!(s.prompt_text().contains("Enter style name"), "{}", s.prompt_text());
|
||||
s.cmdline("ROMANS").unwrap();
|
||||
s.cmdline("0,0").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
assert_eq!(last_attdef(&s).text.style, "ROMANS");
|
||||
}
|
||||
|
||||
/// The keywords a command's Justify prompt offers, from `[A/B/...]` in its prompt text.
|
||||
fn justify_options(s: &Session) -> Vec<String> {
|
||||
let p = s.prompt_text();
|
||||
let inner = p.split_once('[').and_then(|(_, r)| r.split_once(']')).map(|(i, _)| i).unwrap_or("");
|
||||
inner.split('/').map(str::to_string).collect()
|
||||
}
|
||||
|
||||
/// `-ATTDEF`'s Justify prompt doesn't list Align and Fit, which it would only refuse (they run
|
||||
/// between two points), while TEXT's still offers every option (#1720).
|
||||
#[test]
|
||||
fn attdef_justify_prompt_leaves_out_align_and_fit_but_text_keeps_them() {
|
||||
let mut s = session();
|
||||
typed_to_start_point(&mut s);
|
||||
s.cmdline("J").unwrap();
|
||||
let opts = justify_options(&s);
|
||||
assert!(opts.iter().any(|o| o == "Left") && opts.iter().any(|o| o == "MC"), "{opts:?}");
|
||||
assert!(!opts.iter().any(|o| o == "Align" || o == "Fit"), "{opts:?}");
|
||||
// A typed A or F is still refused.
|
||||
s.cmdline("A").unwrap();
|
||||
assert!(s.log.iter().any(|l| l.contains("Align and Fit")), "{:?}", s.log);
|
||||
s.cmdline("*Cancel*").ok();
|
||||
|
||||
let mut t = session();
|
||||
t.cmdline("text").unwrap();
|
||||
t.cmdline("J").unwrap();
|
||||
let opts = justify_options(&t);
|
||||
assert!(opts.iter().any(|o| o == "Align") && opts.iter().any(|o| o == "Fit"), "{opts:?}");
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
//! Block libraries (the Blocks palette): BLOCKLIBRARY lists a folder of drawings or the blocks
|
||||
//! of one drawing, BLOCKLIBIMPORT defines a library block in the current drawing, and
|
||||
//! BLOCKLIBRARIES keeps the list of libraries.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use cadcraft_engine::cmd::file::{IoHooks, set_io};
|
||||
use cadcraft_engine::doc::geom::Vec3;
|
||||
use cadcraft_engine::doc::{Block, Drawing, Entity, EntityKind, Handle, Layer, Line};
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::json;
|
||||
|
||||
/// How many times a library file was parsed.
|
||||
static READS: AtomicUsize = AtomicUsize::new(0);
|
||||
|
||||
/// Every library file reads as a drawing with blocks "Valve" (a line on layer Pipes, base point
|
||||
/// (1, 1)) and "Pump" (empty), whatever its bytes.
|
||||
fn read(_bytes: &[u8], name: &str) -> Result<Drawing, String> {
|
||||
READS.fetch_add(1, Ordering::SeqCst);
|
||||
let mut d = Drawing::new_metric();
|
||||
d.layers.push(Layer { name: "Pipes".into(), ..Layer::default() });
|
||||
d.layers.push(Layer { name: "Spare".into(), ..Layer::default() });
|
||||
let mut valve = Block::new("Valve");
|
||||
valve.description = "Gate valve".into();
|
||||
valve.annotative = true;
|
||||
valve.units = 6;
|
||||
valve.explodable = false;
|
||||
valve.base = Vec3::new(1.0, 1.0, 0.0);
|
||||
let mut line = Entity::new(Handle(0x70), EntityKind::Line(Line { a: Vec3::new(0.0, 0.0, 0.0), b: Vec3::new(4.0, 0.0, 0.0) }));
|
||||
line.common.layer = "Pipes".into();
|
||||
valve.entities.push(line);
|
||||
d.blocks.insert("Valve".into(), Arc::new(valve));
|
||||
d.blocks.insert("Pump".into(), Arc::new(Block::new("Pump")));
|
||||
// "Outer" holds a reference to "Valve" and nothing else.
|
||||
let mut s = Session::new();
|
||||
*s.doc_mut().unwrap() = d;
|
||||
s.execute("insert", &json!({ "name": "Valve", "at": [2, 2] })).unwrap();
|
||||
let handles: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
|
||||
s.execute("block", &json!({ "name": "Outer", "base": [0, 0], "handles": handles, "keep": "delete" })).unwrap();
|
||||
// A dimension style nothing uses, with an arrowhead block of its own.
|
||||
if name.contains("arrow") {
|
||||
let d = s.doc_mut().unwrap();
|
||||
d.blocks.insert("TipArrow".into(), Arc::new(Block::new("TipArrow")));
|
||||
d.dim_styles.push(cadcraft_engine::doc::DimStyle { name: "Spare".into(), arrow_block: "TipArrow".into(), ..Default::default() });
|
||||
}
|
||||
// A crafted file: "Valve" holds "Outer", which holds "Valve".
|
||||
if name.contains("cycle") {
|
||||
let mut back = (**s.doc().unwrap().block("Outer").unwrap().entities.iter().next().unwrap()).clone();
|
||||
if let EntityKind::Insert(i) = &mut back.kind {
|
||||
i.block = "Outer".into();
|
||||
}
|
||||
let d = s.doc_mut().unwrap();
|
||||
let mut valve = (**d.block("Valve").unwrap()).clone();
|
||||
valve.entities.push(back);
|
||||
d.blocks.insert("Valve".into(), Arc::new(valve));
|
||||
}
|
||||
Ok(s.doc().unwrap().clone())
|
||||
}
|
||||
|
||||
/// A new folder with two drawings and a file that is not one.
|
||||
fn folder() -> std::path::PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!("cadcraft-blocklibrary-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
for f in ["b-pumps.dwg", "A-valves.dxf", "notes.txt"] {
|
||||
std::fs::write(dir.join(f), b"x").unwrap();
|
||||
}
|
||||
dir
|
||||
}
|
||||
|
||||
/// Listing a drawing file and importing its blocks.
|
||||
fn lists_and_imports(s: &mut Session, file: &str) {
|
||||
// A drawing file lists its blocks.
|
||||
let r = s.execute("blocklibrary", &json!({ "path": file })).unwrap();
|
||||
assert_eq!(r["kind"], "file");
|
||||
assert_eq!(
|
||||
r["blocks"],
|
||||
json!([{ "name": "Outer", "description": "" }, { "name": "Pump", "description": "" }, { "name": "Valve", "description": "Gate valve" }])
|
||||
);
|
||||
|
||||
// Importing defines the block (and its layer) here, under another name when asked.
|
||||
let r = s.execute("blocklibimport", &json!({ "path": file, "block": "Valve", "name": "Gate" })).unwrap();
|
||||
assert_eq!(r["name"], "Gate");
|
||||
let d = s.doc().unwrap();
|
||||
let gate = d.block("Gate").unwrap();
|
||||
assert_eq!(gate.entities.iter().count(), 1);
|
||||
assert_eq!(gate.base, Vec3::new(1.0, 1.0, 0.0));
|
||||
assert_eq!((gate.description.as_str(), gate.annotative, gate.units, gate.explodable), ("Gate valve", true, 6, false));
|
||||
assert!(d.layers.iter().any(|l| l.name == "Pipes"));
|
||||
// Only what the block needs comes along: not the file's other layers or blocks.
|
||||
assert!(!d.layers.iter().any(|l| l.name == "Spare"), "an unused layer of the library stays out");
|
||||
assert!(d.block("Pump").is_none(), "an unused block of the library stays out");
|
||||
s.execute("insert", &json!({ "name": "Gate", "at": [10, 10] })).unwrap();
|
||||
// A block already here is never replaced, whatever the letter case.
|
||||
assert!(s.execute("blocklibimport", &json!({ "path": file, "block": "Pump", "name": "gate" })).is_err());
|
||||
assert_eq!(s.doc().unwrap().block("Gate").unwrap().entities.iter().count(), 1);
|
||||
assert!(s.doc().unwrap().block("Pump").is_none());
|
||||
// A block made of another block brings that one too (and its layer), not the unused ones.
|
||||
s.execute("blocklibimport", &json!({ "path": file, "block": "Outer", "name": "Assembly" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert!(d.block("Assembly").is_some());
|
||||
assert!(d.block("Valve").is_some(), "the nested block stays");
|
||||
assert!(d.block("Pump").is_none());
|
||||
assert!(d.layers.iter().any(|l| l.name == "Pipes"));
|
||||
// A whole drawing is named after its file and brings its objects (here none: model space is empty).
|
||||
let r = s.execute("blocklibimport", &json!({ "path": file })).unwrap();
|
||||
assert_eq!(r["name"], "A-valves");
|
||||
assert!(!s.doc().unwrap().layers.iter().any(|l| l.name == "Spare"));
|
||||
assert!(s.execute("blocklibimport", &json!({ "path": file, "block": "Nope" })).is_err());
|
||||
assert!(s.execute("blocklibimport", &json!({ "path": file, "block": "Valve", "name": "bad/name" })).is_err());
|
||||
}
|
||||
|
||||
/// A dimension style nothing uses is left out, and its arrowhead block with it.
|
||||
fn leaves_out_an_unused_dimension_style(s: &mut Session, dir: &std::path::Path) {
|
||||
let file = dir.join("arrow-set.dxf").to_string_lossy().to_string();
|
||||
std::fs::write(&file, b"x").unwrap();
|
||||
s.execute("blocklibimport", &json!({ "path": file, "block": "Valve", "name": "Tap" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert!(d.block("Tap").is_some());
|
||||
assert!(!d.dim_styles.iter().any(|t| t.name == "Spare"), "an unused dimension style stays out");
|
||||
assert!(d.block("TipArrow").is_none(), "so does its arrowhead block");
|
||||
}
|
||||
|
||||
/// Adding and removing libraries.
|
||||
fn keeps_the_list(s: &mut Session, dir: &std::path::Path, dir_s: &str, file: &str) {
|
||||
// The list: add (once), refuse what is not a library, remove.
|
||||
let l = s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).unwrap();
|
||||
assert_eq!(l["libraries"], json!([dir_s]));
|
||||
// The same path again is kept once; letter case only matters on case-sensitive file systems.
|
||||
let again = s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).unwrap();
|
||||
assert_eq!(again["libraries"], json!([dir_s]));
|
||||
if cfg!(any(windows, target_os = "macos")) {
|
||||
let upper = s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s.to_uppercase() })).unwrap();
|
||||
assert_eq!(upper["libraries"], json!([dir_s]), "the same folder in other letters is the same library");
|
||||
assert_eq!(upper["path"], json!(dir_s), "the entry keeps its first spelling");
|
||||
}
|
||||
s.execute("blocklibraries", &json!({ "op": "add", "path": file })).unwrap();
|
||||
assert_eq!(s.execute("blocklibraries", &json!({})).unwrap()["libraries"], json!([dir_s, file]));
|
||||
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": dir.join("notes.txt").to_string_lossy() })).is_err());
|
||||
let l = s.execute("blocklibraries", &json!({ "op": "remove", "path": file })).unwrap();
|
||||
assert_eq!(l["libraries"], json!([dir_s]));
|
||||
s.execute("blocklibraries", &json!({ "op": "remove", "path": dir_s })).unwrap();
|
||||
}
|
||||
|
||||
/// Names, paths and files that try to pass for something else.
|
||||
fn refuses_hostile_input(s: &mut Session, dir: &std::path::Path, dir_s: &str) {
|
||||
// A block whose name looks like `name=path` is that block: INSERT reads no file for it.
|
||||
let reads = READS.load(Ordering::SeqCst);
|
||||
let mut odd = Session::new();
|
||||
odd.doc_mut().unwrap().blocks.insert("a=b".into(), Arc::new(Block::new("a=b")));
|
||||
odd.start("insert").unwrap();
|
||||
odd.input(Input::Text("a=b".into())).unwrap();
|
||||
assert!(odd.prompt_text().starts_with("INSERT Specify insertion point"), "{}", odd.prompt_text());
|
||||
assert_eq!(READS.load(Ordering::SeqCst), reads, "no file was read");
|
||||
odd.input(Input::Cancel).unwrap();
|
||||
|
||||
// What is not a readable drawing fails with an error.
|
||||
assert!(s.execute("blocklibimport", &json!({ "path": dir_s })).is_err(), "a folder is not a drawing");
|
||||
assert!(s.execute("blocklibrary", &json!({ "path": dir.join("missing.dxf").to_string_lossy() })).is_err());
|
||||
|
||||
// A file is a library by its name, not by its bytes: `part.bin` is refused before it is read.
|
||||
let bin = dir.join("part.bin").to_string_lossy().to_string();
|
||||
std::fs::write(&bin, b"x").unwrap();
|
||||
let reads = READS.load(Ordering::SeqCst);
|
||||
assert!(s.execute("blocklibrary", &json!({ "path": bin })).is_err());
|
||||
assert!(s.execute("blocklibimport", &json!({ "path": bin, "block": "Valve", "name": "FromBin" })).is_err());
|
||||
assert!(cadcraft_engine::cmd::read_library_file(&bin).is_err());
|
||||
assert_eq!(READS.load(Ordering::SeqCst), reads, "the file was not parsed");
|
||||
assert!(s.doc().unwrap().block("FromBin").is_none());
|
||||
|
||||
// A library whose blocks hold each other imports without hanging, and the session goes on.
|
||||
let cycle = dir.join("cycle.dxf").to_string_lossy().to_string();
|
||||
std::fs::write(&cycle, b"x").unwrap();
|
||||
let _ = s.execute("blocklibimport", &json!({ "path": cycle, "block": "Outer", "name": "Loop" }));
|
||||
s.execute("line", &json!({ "points": [[0, 0], [1, 1]] })).unwrap();
|
||||
}
|
||||
|
||||
/// The Blocks palette can open on the Start tab: listing a library and the kept list need no
|
||||
/// drawing; importing one does.
|
||||
#[test]
|
||||
fn the_library_commands_that_read_no_drawing_run_without_one() {
|
||||
let mut s = Session::empty();
|
||||
let dir = std::env::temp_dir().join(format!("cadcraft-blocklibrary-nodoc-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("pumps.dwg"), b"x").unwrap();
|
||||
let r = s.execute("blocklibrary", &json!({ "path": dir.to_string_lossy() })).unwrap();
|
||||
assert_eq!(r["files"].as_array().map(Vec::len), Some(1));
|
||||
s.execute("blocklibraries", &json!({})).unwrap();
|
||||
let err = s.execute("blocklibimport", &json!({ "path": dir.join("pumps.dwg").to_string_lossy() })).unwrap_err();
|
||||
assert!(err.to_string().contains("no drawing"), "{err}");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// A file with a huge block table.
|
||||
fn bounds_a_huge_table() {
|
||||
// A file with a huge block table lists a bounded part of it, and says so.
|
||||
let mut many = Session::new();
|
||||
let d = many.doc_mut().unwrap();
|
||||
for i in 0..10_001 {
|
||||
let name = format!("B{i}");
|
||||
d.blocks.insert(name.clone(), Arc::new(Block::new(&name)));
|
||||
}
|
||||
let r = many.execute("blockspalette", &json!({})).unwrap();
|
||||
let names: Vec<&str> = r["blocks"].as_array().unwrap().iter().map(|b| b["name"].as_str().unwrap()).collect();
|
||||
assert_eq!(names.len(), 10_000);
|
||||
assert_eq!(r["truncated"], true);
|
||||
// The first ones by name, sorted: B9999 comes last of all, so it is the one left out.
|
||||
assert_eq!(names.first(), Some(&"B0"));
|
||||
assert!(!names.contains(&"B9999"));
|
||||
assert!(names.windows(2).all(|w| w[0].to_ascii_lowercase() <= w[1].to_ascii_lowercase()));
|
||||
}
|
||||
|
||||
/// BLOCKSPALETTE counts every object that draws a block: references and multileader block content.
|
||||
fn counts_what_draws_each_block() {
|
||||
let mut s = Session::new();
|
||||
s.doc_mut().unwrap().blocks.insert("Tag".into(), Arc::new(Block::new("Tag")));
|
||||
s.execute("insert", &json!({ "name": "Tag", "at": [0, 0] })).unwrap();
|
||||
s.execute("mleader", &json!({ "points": [[0, 0], [10, 5]], "block": "tag" })).unwrap();
|
||||
let r = s.execute("blockspalette", &json!({})).unwrap();
|
||||
assert_eq!(r["blocks"], json!([{ "name": "Tag", "description": "", "references": 2 }]));
|
||||
}
|
||||
|
||||
/// The list file in the settings folder.
|
||||
fn checks_the_list_file(s: &mut Session, dir: &std::path::Path, dir_s: &str) {
|
||||
// The list file is checked when it is read: junk, bad entries, too many, too big.
|
||||
let list = dir.join("block-libraries.json");
|
||||
let libraries = |s: &mut Session| s.execute("blocklibraries", &json!({})).unwrap()["libraries"].as_array().unwrap().clone();
|
||||
std::fs::write(&list, "not json").unwrap();
|
||||
assert!(libraries(s).is_empty());
|
||||
// A file that is there but unreadable is never written over: the list stays as the user left it.
|
||||
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).is_err());
|
||||
assert!(s.execute("blocklibraries", &json!({ "op": "remove", "path": dir_s })).is_err());
|
||||
assert_eq!(std::fs::read(&list).unwrap(), b"not json");
|
||||
let mut hostile: Vec<String> = (0..100).map(|i| format!("C:/lib{i}")).collect();
|
||||
hostile.insert(0, String::new());
|
||||
hostile.insert(1, "bad\nname".into());
|
||||
hostile.insert(2, "x".repeat(10_000));
|
||||
std::fs::write(&list, serde_json::to_vec(&hostile).unwrap()).unwrap();
|
||||
let kept = libraries(s);
|
||||
assert_eq!(kept.len(), 64);
|
||||
assert_eq!(kept[0], "C:/lib0");
|
||||
std::fs::write(&list, vec![b' '; 300 << 10]).unwrap();
|
||||
assert!(libraries(s).is_empty());
|
||||
// What the list file holds after an addition is the list, whole.
|
||||
std::fs::remove_file(&list).unwrap();
|
||||
s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).unwrap();
|
||||
assert_eq!(serde_json::from_slice::<Vec<String>>(&std::fs::read(&list).unwrap()).unwrap(), vec![dir_s.to_string()]);
|
||||
// Paths with control characters or of absurd length are refused.
|
||||
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": format!("{dir_s}\nx") })).is_err());
|
||||
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": "y".repeat(5000) })).is_err());
|
||||
}
|
||||
|
||||
/// A file named at INSERT's prompt defines its block before the insertion point is asked for, and
|
||||
/// Escape there keeps the definition and places nothing, as in AutoCAD 2027.
|
||||
fn a_cancelled_insert_keeps_the_definition_from_a_file(s: &mut Session, file: &str) {
|
||||
let placed = s.doc().unwrap().model.iter().count();
|
||||
s.start("insert").unwrap();
|
||||
s.input(Input::Text(format!("FromFile={file}"))).unwrap();
|
||||
assert!(s.prompt_text().starts_with("INSERT Specify insertion point"), "{}", s.prompt_text());
|
||||
assert!(s.doc().unwrap().block("FromFile").is_some());
|
||||
s.input(Input::Cancel).unwrap();
|
||||
assert!(s.doc().unwrap().block("FromFile").is_some());
|
||||
assert_eq!(s.doc().unwrap().model.iter().count(), placed);
|
||||
}
|
||||
|
||||
/// One test: the file hooks and the settings folder are global to the process.
|
||||
#[test]
|
||||
fn libraries_list_import_and_are_kept() {
|
||||
set_io(IoHooks { read, write: |_, _| Err("no writer in this test".into()), plot: None });
|
||||
// No settings folder: the list lives in memory, and the real one is never written.
|
||||
cadcraft_engine::settings_dir::set(None);
|
||||
let dir = folder();
|
||||
let dir_s = dir.to_string_lossy().to_string();
|
||||
let mut s = Session::new();
|
||||
|
||||
// A folder lists its drawings by name, case-insensitively sorted; other files are not drawings.
|
||||
let r = s.execute("blocklibrary", &json!({ "path": dir_s })).unwrap();
|
||||
assert_eq!(r["kind"], "folder");
|
||||
let names: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f["name"].as_str().unwrap()).collect();
|
||||
assert_eq!(names, ["A-valves", "b-pumps"]);
|
||||
|
||||
let reads_before = READS.load(Ordering::SeqCst);
|
||||
let file = dir.join("A-valves.dxf").to_string_lossy().to_string();
|
||||
lists_and_imports(&mut s, &file);
|
||||
// The file was parsed once for all of that, and again only when it changes.
|
||||
assert_eq!(READS.load(Ordering::SeqCst) - reads_before, 1, "the file is parsed once, not for every block placed");
|
||||
std::fs::write(&file, b"changed contents, another size").unwrap();
|
||||
s.execute("blocklibrary", &json!({ "path": file })).unwrap();
|
||||
assert_eq!(READS.load(Ordering::SeqCst) - reads_before, 2, "a changed file is read again");
|
||||
// Refresh in the palette reads it again even when its size and time look the same.
|
||||
cadcraft_engine::cmd::clear_library_cache();
|
||||
let listed = s.execute("blocklibrary", &json!({ "path": file })).unwrap();
|
||||
assert_eq!(READS.load(Ordering::SeqCst) - reads_before, 3, "a cleared file is read again");
|
||||
// The palette's worker thread gets the same answer without a session.
|
||||
assert_eq!(cadcraft_engine::cmd::list_library(&file).unwrap(), listed);
|
||||
|
||||
leaves_out_an_unused_dimension_style(&mut s, &dir);
|
||||
a_cancelled_insert_keeps_the_definition_from_a_file(&mut s, &file);
|
||||
keeps_the_list(&mut s, &dir, &dir_s, &file);
|
||||
refuses_hostile_input(&mut s, &dir, &dir_s);
|
||||
bounds_a_huge_table();
|
||||
counts_what_draws_each_block();
|
||||
cadcraft_engine::settings_dir::set(Some(dir.clone()));
|
||||
checks_the_list_file(&mut s, &dir, &dir_s);
|
||||
cadcraft_engine::settings_dir::set(None);
|
||||
|
||||
std::fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
@@ -130,7 +130,7 @@ fn the_prompts_are_autocads() {
|
||||
// A wrong answer, or a justification not available here, is asked again.
|
||||
for typed in ["X", "_A"] {
|
||||
s.cmdline(typed).unwrap();
|
||||
assert!(s.prompt_text().contains("[Left/Center/Right/Align/Middle/Fit/TL/"), "{typed}: {}", s.prompt_text());
|
||||
assert!(s.prompt_text().contains("[Left/Center/Right/Middle/TL/"), "{typed}: {}", s.prompt_text());
|
||||
}
|
||||
s.cmdline("_MC").unwrap();
|
||||
assert!(s.prompt_text().ends_with("Specify middle point of text:"), "{}", s.prompt_text());
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
//! The dimension shortcut menu's style commands: Remove Style Overrides clears the selected
|
||||
//! dimensions' overrides, and Save as New Style makes a style of a dimension's settings (its
|
||||
//! overrides included) and gives it to the dimension.
|
||||
|
||||
use cadcraft_engine::doc::{Dimension, EntityKind, Handle};
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::json;
|
||||
|
||||
fn dimension(s: &mut Session, y: f64) -> Handle {
|
||||
s.execute("dimlinear", &json!({ "p1": [0, y], "p2": [10, y], "at": [5, y + 3.0] })).unwrap();
|
||||
s.doc().unwrap().model.last().unwrap().handle
|
||||
}
|
||||
|
||||
fn dim(s: &Session, h: Handle) -> Dimension {
|
||||
match &s.doc().unwrap().entity(h).unwrap().kind {
|
||||
EntityKind::Dimension(d) => d.clone(),
|
||||
k => panic!("not a dimension: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_style_overrides_clears_the_selected_dimensions() {
|
||||
let mut s = Session::new();
|
||||
let (a, b) = (dimension(&mut s, 0.0), dimension(&mut s, 10.0));
|
||||
s.execute("properties.set", &json!({ "handles": [a.hex(), b.hex()], "textHeight": 0.3 })).unwrap();
|
||||
s.execute("dimoverride.clear", &json!({ "handles": [a.hex()] })).unwrap();
|
||||
assert!(dim(&s, a).overrides.is_empty() && !dim(&s, b).overrides.is_empty());
|
||||
// From the menu: the selected dimensions, in one undo step.
|
||||
s.set_selection(vec![b]);
|
||||
s.start("dimoverride.clear").unwrap();
|
||||
assert!(s.running.is_none() && dim(&s, b).overrides.is_empty());
|
||||
s.undo().unwrap();
|
||||
assert_eq!(dim(&s, b).overrides.get("textHeight"), Some(&json!(0.3)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_as_new_style_takes_the_dimensions_settings() {
|
||||
let mut s = Session::new();
|
||||
let h = dimension(&mut s, 0.0);
|
||||
s.execute("properties.set", &json!({ "handles": [h.hex()], "textHeight": 0.3, "DIMDEC": 2 })).unwrap();
|
||||
let r = s.execute("dimstyle.saveas", &json!({ "handle": h.hex(), "name": "Detail" })).unwrap();
|
||||
assert_eq!(r["style"], "Detail");
|
||||
let d = dim(&s, h);
|
||||
assert!(d.style == "Detail" && d.overrides.is_empty(), "{d:?}");
|
||||
let st = s.execute("dimstyle.list", &json!({ "name": "Detail" })).unwrap();
|
||||
assert_eq!((st["variables"]["DIMTXT"].as_f64(), st["variables"]["DIMDEC"].as_u64()), (Some(0.3), Some(2)));
|
||||
// The dimension looks the same, and the current style is still Standard.
|
||||
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &d);
|
||||
assert!((g.text_height - 0.3).abs() < 1e-12 && g.value == "10.00", "{} {}", g.text_height, g.value);
|
||||
assert_eq!(s.doc().unwrap().header.str("DIMSTYLE", "Standard"), "Standard");
|
||||
// A new name that a style can have (no `~`, which -DIMSTYLE Restore reads as compare).
|
||||
for name in ["detail", " ", "a<b", "~Plan"] {
|
||||
assert!(s.execute("dimstyle.saveas", &json!({ "handle": h.hex(), "name": name })).is_err(), "{name}");
|
||||
}
|
||||
// Only dimensions.
|
||||
s.execute("circle", &json!({ "center": [0, 0], "radius": 1 })).unwrap();
|
||||
let c = s.doc().unwrap().model.last().unwrap().handle;
|
||||
assert!(s.execute("dimstyle.saveas", &json!({ "handle": c.hex(), "name": "Other" })).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_as_new_style_from_the_menu_asks_for_a_name() {
|
||||
let mut s = Session::new();
|
||||
let h = dimension(&mut s, 0.0);
|
||||
s.execute("properties.set", &json!({ "handles": [h.hex()], "textHeight": 0.3 })).unwrap();
|
||||
s.set_selection(vec![h]);
|
||||
s.start("dimstyle.saveas").unwrap();
|
||||
assert!(s.prompt_text().contains("name of new dimension style"), "{}", s.prompt_text());
|
||||
// A name already taken is refused, said why, and asked again.
|
||||
let _ = s.input(Input::Text("Standard".into()));
|
||||
assert!(s.running.is_some(), "a taken name asks again");
|
||||
assert!(s.log.iter().any(|l| l.contains("already exists")), "{:?}", s.log);
|
||||
s.input(Input::Text("Detail".into())).unwrap();
|
||||
assert!(s.running.is_none());
|
||||
assert_eq!(dim(&s, h).style, "Detail");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_as_new_style_picks_a_dimension_when_none_is_selected() {
|
||||
let mut s = Session::new();
|
||||
let h = dimension(&mut s, 0.0);
|
||||
s.start("dimstyle.saveas").unwrap();
|
||||
assert!(s.prompt_text().contains("Select a dimension"), "{}", s.prompt_text());
|
||||
// The dimension line of the dimension.
|
||||
s.input(Input::Point(cadcraft_engine::geom::Vec2::new(5.0, 3.0))).unwrap();
|
||||
s.input(Input::Text("Picked".into())).unwrap();
|
||||
assert_eq!(dim(&s, h).style, "Picked");
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
//! A negative DIMGAP draws a frame around the dimension text: SETVAR takes the negative value, a
|
||||
//! new dimension draws the frame, and EXPLODE turns it into four lines.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::{EntityKind, Handle};
|
||||
use serde_json::json;
|
||||
|
||||
/// Draw a linear dimension with DIMGAP `gap`, explode it, and return the number of lines the
|
||||
/// dimension drew and the number of LINEs EXPLODE left.
|
||||
fn explode_with_gap(gap: f64) -> (usize, usize) {
|
||||
let mut s = Session::new();
|
||||
s.execute("setvar", &json!({ "name": "DIMGAP", "value": gap })).unwrap();
|
||||
let r = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [30, 0], "at": [15, 5] })).unwrap();
|
||||
let h = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
|
||||
let drawn = match &s.doc().unwrap().entity(h).unwrap().kind {
|
||||
EntityKind::Dimension(dm) => cadcraft_engine::render::dimension_in(s.doc().unwrap(), dm).lines.len(),
|
||||
k => panic!("not a dimension: {k:?}"),
|
||||
};
|
||||
s.execute("explode", &json!({ "handles": [h.hex()] })).unwrap();
|
||||
let lines = s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count();
|
||||
(drawn, lines)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn negative_dimgap_frame_is_drawn_and_exploded() {
|
||||
let (plain_drawn, plain_lines) = explode_with_gap(0.09);
|
||||
let (drawn, lines) = explode_with_gap(-0.09);
|
||||
assert_eq!(drawn, plain_drawn + 4);
|
||||
assert_eq!(lines, plain_lines + 4);
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
//! -DIMSTYLE at the command line and as JSON (save, annotative, restore, status, variables,
|
||||
//! apply, list), and `dimstyle.overrides`, which sets the current style's overrides.
|
||||
|
||||
use cadcraft_engine::doc::{Dimension, EntityKind, Handle};
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::json;
|
||||
|
||||
fn dimension(s: &mut Session) -> Handle {
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
s.doc().unwrap().model.last().unwrap().handle
|
||||
}
|
||||
|
||||
fn dim(s: &Session, h: Handle) -> Dimension {
|
||||
match &s.doc().unwrap().entity(h).unwrap().kind {
|
||||
EntityKind::Dimension(d) => d.clone(),
|
||||
k => panic!("not a dimension: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn current(s: &Session) -> String {
|
||||
s.doc().unwrap().header.str("DIMSTYLE", "")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn save_restore_status_and_variables_as_json() {
|
||||
let mut s = Session::new();
|
||||
// A current-style override (SETVAR) goes into the saved style.
|
||||
s.execute("setvar", &json!({ "name": "DIMTXT", "value": 0.25 })).unwrap();
|
||||
let r = s.execute("-dimstyle", &json!({ "option": "save", "name": "Plan" })).unwrap();
|
||||
assert_eq!(r["style"], "Plan");
|
||||
assert_eq!(current(&s), "Plan");
|
||||
let d = s.doc().unwrap();
|
||||
assert!(d.dim_overrides().is_empty(), "saved into the style");
|
||||
assert_eq!(d.dim_style("Plan").unwrap().text_height, 0.25);
|
||||
// A name in use is redefined only when asked to.
|
||||
assert!(s.execute("-dimstyle", &json!({ "option": "save", "name": "plan" })).is_err());
|
||||
s.execute("-dimstyle", &json!({ "option": "save", "name": "plan", "replace": true })).unwrap();
|
||||
assert_eq!(s.doc().unwrap().dim_styles.iter().filter(|st| st.name.eq_ignore_ascii_case("plan")).count(), 1);
|
||||
s.execute("-dimstyle", &json!({ "option": "restore", "name": "standard" })).unwrap();
|
||||
assert_eq!(current(&s), "Standard");
|
||||
let status = s.execute("-dimstyle", &json!({ "option": "status" })).unwrap();
|
||||
assert_eq!(status["variables"]["DIMTXT"], 0.18);
|
||||
let vars = s.execute("-dimstyle", &json!({ "option": "variables", "name": "Plan" })).unwrap();
|
||||
assert_eq!(vars["variables"]["DIMTXT"], 0.25);
|
||||
s.execute("-dimstyle", &json!({ "option": "annotative", "name": "Anno" })).unwrap();
|
||||
assert!(s.doc().unwrap().dim_style("Anno").unwrap().annotative);
|
||||
let list = s.execute("-dimstyle", &json!({ "option": "list", "pattern": "p*" })).unwrap();
|
||||
assert_eq!(list["styles"], json!(["Plan"]));
|
||||
// A dimension's style becomes current; its variables include its overrides.
|
||||
let h = dimension(&mut s);
|
||||
s.execute("properties.set", &json!({ "handles": [h.hex()], "textHeight": 0.4 })).unwrap();
|
||||
let vars = s.execute("-dimstyle", &json!({ "option": "variables", "handle": h.hex() })).unwrap();
|
||||
assert_eq!(vars["variables"]["DIMTXT"], 0.4);
|
||||
s.execute("-dimstyle", &json!({ "option": "restore", "handle": h.hex() })).unwrap();
|
||||
assert_eq!(current(&s), "Anno");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_gives_dimensions_the_current_settings() {
|
||||
let mut s = Session::new();
|
||||
let h = dimension(&mut s);
|
||||
s.execute("dimstyle", &json!({ "name": "Plan", "DIMTXT": 0.3 })).unwrap();
|
||||
s.execute("setvar", &json!({ "name": "DIMDEC", "value": 1 })).unwrap();
|
||||
let r = s.execute("-dimstyle", &json!({ "option": "apply", "handles": [h.hex()] })).unwrap();
|
||||
assert_eq!(r["changed"], 1);
|
||||
let d = dim(&s, h);
|
||||
assert_eq!(d.style, "Plan");
|
||||
assert_eq!(d.overrides.get("decimals"), Some(&json!(1)));
|
||||
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &d);
|
||||
assert_eq!(g.value, "10.0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_command_line_asks_like_autocad() {
|
||||
let mut s = Session::new();
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
assert!(s.prompt_text().contains("ANnotative"), "{}", s.prompt_text());
|
||||
s.cmdline("S").unwrap();
|
||||
s.cmdline("Plan").unwrap();
|
||||
assert!(s.running.is_none());
|
||||
assert_eq!(current(&s), "Plan");
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("R").unwrap();
|
||||
s.cmdline("Standard").unwrap();
|
||||
assert_eq!(current(&s), "Standard");
|
||||
let before = s.log.len();
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("ST").unwrap();
|
||||
assert!(s.log[before..].iter().any(|l| l.starts_with("DIMTXT") && l.contains("Text height")), "{:?}", &s.log[before..]);
|
||||
// A name in use asks to redefine it.
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("S").unwrap();
|
||||
s.cmdline("Plan").unwrap();
|
||||
assert!(s.prompt_text().contains("redefine"), "{}", s.prompt_text());
|
||||
s.cmdline("Y").unwrap();
|
||||
assert!(s.running.is_none());
|
||||
// Apply: the objects to give the current settings.
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("R").unwrap();
|
||||
s.cmdline("Standard").unwrap();
|
||||
let h = dimension(&mut s);
|
||||
s.execute("dimstyle.current", &json!({ "name": "Plan" })).unwrap();
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("A").unwrap();
|
||||
s.input(Input::Pick(vec![h])).unwrap();
|
||||
s.input(Input::Enter).unwrap();
|
||||
assert!(s.running.is_none());
|
||||
assert_eq!(dim(&s, h).style, "Plan");
|
||||
// ~name compares a style with the current settings.
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("R").unwrap();
|
||||
let before = s.log.len();
|
||||
s.cmdline("~Standard").unwrap();
|
||||
assert!(s.log[before..].iter().any(|l| l.contains("Differences")), "{:?}", &s.log[before..]);
|
||||
s.cancel();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn style_overrides_are_set_in_one_step() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimstyle.overrides", &json!({ "textHeight": 0.3, "DIMCLRT": 1 })).unwrap();
|
||||
let o = s.doc().unwrap().dim_overrides();
|
||||
assert_eq!(o.get("textHeight"), Some(&json!(0.3)));
|
||||
assert!(o.contains_key("textColor"), "{o:?}");
|
||||
s.undo().unwrap();
|
||||
assert!(s.doc().unwrap().dim_overrides().is_empty(), "one undo step");
|
||||
// Unusable values change nothing; names that aren't variables are refused.
|
||||
assert!(s.execute("dimstyle.overrides", &json!({ "textHeight": -1, "DIMDEC": 2 })).is_err());
|
||||
assert!(s.execute("dimstyle.overrides", &json!({ "nope": 1 })).is_err());
|
||||
assert!(s.doc().unwrap().dim_overrides().is_empty());
|
||||
s.execute("dimstyle.overrides", &json!({ "DIMDEC": 2 })).unwrap();
|
||||
// Clear drops them only when every value is usable.
|
||||
assert!(s.execute("dimstyle.overrides", &json!({ "clear": true, "textHeight": -1 })).is_err());
|
||||
assert!(s.execute("dimstyle.overrides", &json!({ "clear": true, "nope": 1 })).is_err());
|
||||
assert_eq!(s.doc().unwrap().dim_overrides().get("decimals"), Some(&json!(2)));
|
||||
s.execute("dimstyle.overrides", &json!({ "clear": true, "textGap": 0.05 })).unwrap();
|
||||
let o = s.doc().unwrap().dim_overrides();
|
||||
assert_eq!((o.len(), o.get("textGap")), (1, Some(&json!(0.05))));
|
||||
s.execute("dimstyle.overrides", &json!({ "clear": true })).unwrap();
|
||||
assert!(s.doc().unwrap().dim_overrides().is_empty());
|
||||
// A lineweight by name goes in as the number the header variable holds.
|
||||
s.execute("dimstyle.overrides", &json!({ "clear": true, "DIMLWD": "bylayer" })).unwrap();
|
||||
assert_eq!(s.doc().unwrap().header.i64("DIMLWD", 0), -1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refused_calls_leave_no_undo_step() {
|
||||
let mut s = Session::new();
|
||||
s.execute("-dimstyle", &json!({ "option": "save", "name": "Plan" })).unwrap();
|
||||
assert!(s.execute("-dimstyle", &json!({ "option": "save", "name": "plan" })).is_err());
|
||||
assert!(s.execute("-dimstyle", &json!({ "option": "restore", "name": "Nope" })).is_err());
|
||||
// Apply to objects none of which is a dimension changes nothing, and makes no step either.
|
||||
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
|
||||
let line = s.doc().unwrap().model.last().unwrap().handle.hex();
|
||||
assert_eq!(s.execute("-dimstyle", &json!({ "option": "apply", "handles": [line] })).unwrap()["changed"], 0);
|
||||
// The undo steps are the line and the save: none for the refused calls or that Apply.
|
||||
s.undo().unwrap();
|
||||
assert!(s.doc().unwrap().dim_style("Plan").is_some(), "the first undo is the line's");
|
||||
s.undo().unwrap();
|
||||
assert!(s.doc().unwrap().dim_style("Plan").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_and_renamed_styles_take_the_names_dimstyle_takes() {
|
||||
let mut s = Session::new();
|
||||
for name in ["~Plan", "a*b", "x?"] {
|
||||
assert!(s.execute("dimstyle", &json!({ "name": name })).is_err(), "{name}");
|
||||
}
|
||||
s.execute("dimstyle", &json!({ "name": "Plan", "current": false })).unwrap();
|
||||
assert!(s.execute("dimstyle.rename", &json!({ "from": "Plan", "to": "~Plan" })).is_err());
|
||||
s.execute("dimstyle.rename", &json!({ "from": "Plan", "to": "Site" })).unwrap();
|
||||
assert!(s.doc().unwrap().dim_style("Site").is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_refused_answer_asks_the_same_question() {
|
||||
let mut s = Session::new();
|
||||
s.cmdline("-DIMSTYLE").unwrap();
|
||||
s.cmdline("R").unwrap();
|
||||
// A style to compare with that doesn't exist.
|
||||
let _ = s.cmdline("~Nope");
|
||||
assert!(s.prompt_text().contains("Enter a dimension style name"), "{}", s.prompt_text());
|
||||
// Words at "Select dimension".
|
||||
s.cmdline("").unwrap();
|
||||
let _ = s.cmdline("Standard");
|
||||
assert!(s.prompt_text().contains("Select dimension"), "{}", s.prompt_text());
|
||||
s.cancel();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn listing_with_many_stars_takes_no_time() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimstyle", &json!({ "name": "a".repeat(200), "current": false })).unwrap();
|
||||
let start = std::time::Instant::now();
|
||||
for pattern in ["*".repeat(255) + "x", "*a".repeat(120) + "b"] {
|
||||
let r = s.execute("-dimstyle", &json!({ "option": "list", "pattern": pattern })).unwrap();
|
||||
assert_eq!(r["styles"], json!([]));
|
||||
}
|
||||
assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
|
||||
let r = s.execute("-dimstyle", &json!({ "option": "list", "pattern": "a*a?" })).unwrap();
|
||||
assert_eq!(r["styles"], json!(["a".repeat(200)]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_requests_never_panic() {
|
||||
let mut s = Session::new();
|
||||
let h = dimension(&mut s);
|
||||
for p in [
|
||||
json!({ "option": "save", "name": "" }),
|
||||
json!({ "option": "save", "name": "a*b" }),
|
||||
json!({ "option": "restore", "handle": "zz" }),
|
||||
json!({ "option": "variables", "handle": 1e300 }),
|
||||
json!({ "option": "apply", "handles": [h.hex(), "1", 5] }),
|
||||
json!({ "option": "list", "pattern": "*".repeat(100_000) }),
|
||||
json!({ "option": 5 }),
|
||||
] {
|
||||
let r = s.execute("-dimstyle", &p);
|
||||
assert!(!matches!(r, Err(cadcraft_engine::EngineError::Internal(..))), "{p}: {r:?}");
|
||||
}
|
||||
for p in [json!({ "DIMTXT": "x" }), json!({ "DIMBLK": [1] }), json!({ "DIMCLRT": { "a": 1 } }), json!({ "clear": "yes" })] {
|
||||
let r = s.execute("dimstyle.overrides", &p);
|
||||
assert!(!matches!(r, Err(cadcraft_engine::EngineError::Internal(..))), "{p}: {r:?}");
|
||||
}
|
||||
for line in ["-DIMSTYLE", "?", "", "-DIMSTYLE", "V", "", "-DIMSTYLE", "AN", "N", "?", "Bad/Name", "Good"] {
|
||||
let _ = s.cmdline(line);
|
||||
}
|
||||
s.cancel();
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
//! Enter or Space at INSERT's insertion point prompt asks again, as in AutoCAD 2027; Escape ends
|
||||
//! the command (the Blocks palette's Repeat Placement stops this way).
|
||||
|
||||
use cadcraft_engine::geom::Vec2;
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn enter_at_the_insertion_point_asks_again() {
|
||||
let mut s = Session::new();
|
||||
s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap();
|
||||
let hs: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
|
||||
s.execute("block", &json!({"name": "A", "base": [0, 0], "handles": hs, "keep": "delete"})).unwrap();
|
||||
|
||||
s.start("insert").unwrap();
|
||||
s.input(Input::Text("A".into())).unwrap();
|
||||
assert!(s.prompt_text().starts_with("INSERT Specify insertion point"), "{}", s.prompt_text());
|
||||
s.input(Input::Enter).unwrap();
|
||||
assert!(s.prompt_text().starts_with("INSERT Specify insertion point"), "{}", s.prompt_text());
|
||||
s.input(Input::Cancel).unwrap();
|
||||
assert_eq!(s.prompt_text(), "Command:");
|
||||
assert_eq!(s.doc().unwrap().model.iter().count(), 0, "nothing is placed");
|
||||
assert_eq!(s.last_finished, None, "ending it this way is cancelling it");
|
||||
}
|
||||
|
||||
/// A cancelled INSERT leaves the drawing as it was: it takes no undo step, or the next undo would
|
||||
/// seem to do nothing (Repeat Placement always ends this way). A placed block keeps its name.
|
||||
#[test]
|
||||
fn a_cancelled_insert_takes_no_undo_step() {
|
||||
let mut s = Session::new();
|
||||
s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap();
|
||||
let hs: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
|
||||
s.execute("block", &json!({"name": "A", "base": [0, 0], "handles": hs, "keep": "delete"})).unwrap();
|
||||
let steps = s.state().unwrap().undo.len();
|
||||
|
||||
s.start("insert").unwrap();
|
||||
s.input(Input::Text("A".into())).unwrap();
|
||||
s.input(Input::Cancel).unwrap();
|
||||
assert_eq!(s.state().unwrap().undo.len(), steps);
|
||||
assert_eq!(s.doc().unwrap().header.str("INSNAME", ""), "");
|
||||
|
||||
s.start("insert").unwrap();
|
||||
s.input(Input::Text("A".into())).unwrap();
|
||||
s.input(Input::Keyword("Scale".into())).unwrap();
|
||||
s.input(Input::Text("1".into())).unwrap();
|
||||
s.input(Input::Keyword("Rotate".into())).unwrap();
|
||||
s.input(Input::Text("0".into())).unwrap();
|
||||
s.input(Input::Point(Vec2::new(1.0, 1.0))).unwrap();
|
||||
assert_eq!(s.state().unwrap().undo.len(), steps + 1);
|
||||
assert_eq!(s.doc().unwrap().header.str("INSNAME", ""), "A");
|
||||
}
|
||||
|
||||
/// How the last command ended: by itself, with what it added; a cancelled one changes nothing.
|
||||
#[test]
|
||||
fn the_last_finished_command_says_whether_it_added_objects() {
|
||||
let mut s = Session::new();
|
||||
s.start("line").unwrap();
|
||||
s.input(Input::Point(Vec2::new(0.0, 0.0))).unwrap();
|
||||
s.input(Input::Point(Vec2::new(1.0, 1.0))).unwrap();
|
||||
s.input(Input::Enter).unwrap();
|
||||
let line = (s.commands_started, true);
|
||||
assert_eq!(s.last_finished, Some(line));
|
||||
s.start("circle").unwrap();
|
||||
s.input(Input::Cancel).unwrap();
|
||||
assert_eq!(s.last_finished, Some(line));
|
||||
}
|
||||
|
||||
/// A transparent command runs inside the current one: it does not count as a new command.
|
||||
#[test]
|
||||
fn only_a_command_of_its_own_counts_as_started() {
|
||||
let mut s = Session::new();
|
||||
s.start("line").unwrap();
|
||||
let started = s.commands_started;
|
||||
s.start("'zoom").unwrap();
|
||||
assert_eq!(s.commands_started, started);
|
||||
s.start("circle").unwrap();
|
||||
assert_eq!(s.commands_started, started + 1);
|
||||
}
|
||||
@@ -6,7 +6,7 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::cmd::file::{EntityCodec, set_entity_codec};
|
||||
use cadcraft_engine::cmd::file::{EntityCodec, set_entity_codec, set_object_records};
|
||||
use cadcraft_engine::doc::Entity;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
@@ -220,6 +220,8 @@ fn run_case(dir: &Path) -> Result<(), String> {
|
||||
#[test]
|
||||
fn autolisp_corpus() {
|
||||
set_entity_codec(EntityCodec { groups: cadcraft_io::entity_groups, entity: cadcraft_io::entity_from_groups });
|
||||
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
|
||||
set_object_records(cadcraft_io::object_records);
|
||||
let Some(dir) = cases_dir() else {
|
||||
eprintln!("CADCRAFT_LISP_CORPUS is not set: the AutoLISP corpus is skipped");
|
||||
return;
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
//! LISP `findfile` finds folders as well as files (#2985): routines test whether an optional
|
||||
//! module is installed with `(findfile "module/.")`.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use serde_json::json;
|
||||
|
||||
#[path = "../support/temp_dir.rs"]
|
||||
mod temp_dir;
|
||||
|
||||
use temp_dir::TempDir;
|
||||
|
||||
/// `(findfile name)` as LISP prints it.
|
||||
fn findfile(name: &str) -> String {
|
||||
let mut s = Session::new();
|
||||
let r = s.execute("lisp", &json!({ "code": format!("(findfile \"{name}\")") })).unwrap();
|
||||
r["value"].as_str().unwrap().to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn findfile_finds_a_folder_with_and_without_a_trailing_dot() {
|
||||
let dir = TempDir::new("findfile-folder");
|
||||
std::fs::create_dir_all(dir.join("module")).unwrap();
|
||||
// Forward slashes, so the name needs no escaping in the LISP string on Windows.
|
||||
let folder = dir.join("module").to_string_lossy().replace('\\', "/");
|
||||
assert_eq!(findfile(&folder), format!("\"{folder}\""));
|
||||
assert_eq!(findfile(&format!("{folder}/.")), format!("\"{folder}/.\""));
|
||||
// A folder that isn't there is still nil.
|
||||
assert_eq!(findfile(&format!("{folder}-missing")), "nil");
|
||||
assert_eq!(findfile(&format!("{folder}-missing/.")), "nil");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn findfile_still_finds_a_file() {
|
||||
let dir = TempDir::new("findfile-file");
|
||||
let file = dir.file("routine.lsp", "(princ)").replace('\\', "/");
|
||||
assert_eq!(findfile(&file), format!("\"{file}\""));
|
||||
}
|
||||
@@ -39,7 +39,10 @@ mod dim_explode_text;
|
||||
mod dim_properties;
|
||||
mod dim_radial_inside;
|
||||
mod dim_radial_outside;
|
||||
mod dim_style_menu;
|
||||
mod dim_text_frame;
|
||||
mod dim_vars;
|
||||
mod dimstyle_cli;
|
||||
mod dimtedit_prompts;
|
||||
mod drafting_spacing;
|
||||
mod draw_prompts;
|
||||
@@ -68,6 +71,7 @@ mod inquiry_keywords;
|
||||
mod inquiry_variables;
|
||||
mod inquiry_z;
|
||||
mod insert_attribute_prompts;
|
||||
mod insert_enter;
|
||||
mod insert_prompts;
|
||||
mod isometric;
|
||||
mod join_close;
|
||||
@@ -79,6 +83,7 @@ mod layout_prompts;
|
||||
mod leader_command;
|
||||
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
mod lisp_corpus;
|
||||
mod lisp_findfile;
|
||||
mod lisp_undo_in_routine;
|
||||
mod malformed_handles;
|
||||
mod matchprop;
|
||||
@@ -116,7 +121,9 @@ mod polyface_explode;
|
||||
mod post_command_passes;
|
||||
mod prompt_keywords;
|
||||
mod prompt_or_once;
|
||||
mod properties_describe;
|
||||
mod properties_set_locked;
|
||||
mod properties_set_text_dims;
|
||||
mod props_bad_lineweight;
|
||||
mod props_insert_scale_attribs;
|
||||
mod purge_mlinestyles;
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
//! `properties.describe`: the Properties palette's rows for text, mtext and dimensions, with
|
||||
//! shared values, *VARIES*, units, and the reason a dimension's text height can't be edited.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
fn handle(r: &Value) -> String {
|
||||
r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap().to_string()
|
||||
}
|
||||
|
||||
fn last(s: &Session) -> String {
|
||||
s.doc().unwrap().model.last().unwrap().handle.hex()
|
||||
}
|
||||
|
||||
fn describe(s: &mut Session, p: Value) -> Value {
|
||||
s.execute("properties.describe", &p).unwrap()
|
||||
}
|
||||
|
||||
/// The row `key` in group `group`.
|
||||
fn row<'a>(desc: &'a Value, group: &str, key: &str) -> &'a Value {
|
||||
let g = desc["groups"].as_array().unwrap().iter().find(|g| g["name"] == group).unwrap_or_else(|| panic!("no group {group}: {desc}"));
|
||||
g["rows"].as_array().unwrap().iter().find(|r| r["key"] == key).unwrap_or_else(|| panic!("no row {key} in {group}: {g}"))
|
||||
}
|
||||
|
||||
fn group_names(desc: &Value) -> Vec<String> {
|
||||
desc["groups"].as_array().unwrap().iter().map(|g| g["name"].as_str().unwrap().to_string()).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_rows_share_values_and_vary() {
|
||||
let mut s = Session::new();
|
||||
let a = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 2.5 })).unwrap());
|
||||
let b = handle(&s.execute("text", &json!({ "at": [0, 5], "text": "B", "height": 1, "justify": "MC" })).unwrap());
|
||||
let one = describe(&mut s, json!({ "handles": [a] }));
|
||||
assert_eq!(group_names(&one), ["General", "Text", "Geometry"]);
|
||||
let h = row(&one, "Text", "height");
|
||||
assert_eq!((h["value"].as_f64(), h["display"].as_str(), h["kind"].as_str()), (Some(2.5), Some("2.5000"), Some("distance")));
|
||||
assert_eq!(row(&one, "Text", "justify")["display"], "Left");
|
||||
assert_eq!(row(&one, "Text", "style")["value"], "Standard");
|
||||
assert!(row(&one, "Text", "style")["options"].as_array().unwrap().iter().any(|o| o["value"] == "Standard"));
|
||||
assert_eq!(row(&one, "Text", "text")["value"], "A");
|
||||
|
||||
let both = describe(&mut s, json!({ "handles": [a, b] }));
|
||||
assert_eq!(both["count"], 2);
|
||||
let h = row(&both, "Text", "height");
|
||||
assert_eq!((h["varies"].as_bool(), h["display"].as_str(), h["value"].is_null()), (Some(true), Some("*VARIES*"), true));
|
||||
// Both are rotated 0 and in the same style.
|
||||
assert_eq!(row(&both, "Text", "rotation")["varies"], false);
|
||||
assert_eq!(row(&both, "Text", "style")["display"], "Standard");
|
||||
assert_eq!(row(&both, "Text", "justify")["varies"], true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mixed_selections_show_general_rows_unless_filtered() {
|
||||
let mut s = Session::new();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
|
||||
s.execute("circle", &json!({ "center": [0, 0], "radius": 1 })).unwrap();
|
||||
let c = last(&s);
|
||||
let mixed = describe(&mut s, json!({ "handles": [t, c] }));
|
||||
assert_eq!(group_names(&mixed), ["General"]);
|
||||
assert_eq!(mixed["types"], json!([{ "type": "Text", "count": 1 }, { "type": "Circle", "count": 1 }]));
|
||||
assert_eq!(row(&mixed, "General", "layer")["value"], "0");
|
||||
let texts = describe(&mut s, json!({ "handles": [t, c], "type": "text" }));
|
||||
assert_eq!((texts["filter"].as_str(), texts["count"].as_u64()), (Some("Text"), Some(1)));
|
||||
assert_eq!(group_names(&texts), ["General", "Text", "Geometry"]);
|
||||
// An unknown filter describes everything.
|
||||
assert_eq!(describe(&mut s, json!({ "handles": [t, c], "type": "nope" }))["count"], 2);
|
||||
// Nothing selected, or handles that name nothing: no rows.
|
||||
assert_eq!(describe(&mut s, json!({ "handles": [] }))["groups"], json!([]));
|
||||
assert_eq!(describe(&mut s, json!({ "handles": ["FFFFFF"] }))["count"], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mtext_rows() {
|
||||
let mut s = Session::new();
|
||||
let r = s.execute("mtext", &json!({ "at": [0, 0], "text": "one\\Ptwo", "height": 3, "width": 40, "justify": "MC", "lineSpacing": 1.5 })).unwrap();
|
||||
let m = handle(&r);
|
||||
let d = describe(&mut s, json!({ "handles": [m] }));
|
||||
assert_eq!(group_names(&d), ["General", "Text", "Geometry"]);
|
||||
assert_eq!(row(&d, "Text", "justify")["value"], "MC");
|
||||
assert_eq!(row(&d, "Text", "justify")["display"], "Middle center");
|
||||
assert_eq!(row(&d, "Text", "text")["kind"], "contents");
|
||||
assert_eq!(row(&d, "Text", "lineSpacing")["value"], 1.5);
|
||||
// Line space distance: factor × height × 5/3.
|
||||
let dist = row(&d, "Text", "lineSpacingDistance")["value"].as_f64().unwrap();
|
||||
assert!((dist - 1.5 * 3.0 * 5.0 / 3.0).abs() < 1e-9, "{dist}");
|
||||
assert_eq!(row(&d, "Text", "lineSpacingStyle")["value"], "atLeast");
|
||||
assert_eq!(row(&d, "Text", "width")["value"], 40.0);
|
||||
let cols = row(&d, "Text", "columns");
|
||||
assert_eq!((cols["display"].as_str(), cols["editable"].as_bool()), (Some("None"), Some(false)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dimension_rows_come_from_the_style_and_its_overrides() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
let d = describe(&mut s, json!({ "handles": [dm] }));
|
||||
assert_eq!(group_names(&d), ["General", "Misc", "Lines & Arrows", "Text", "Fit", "Primary Units", "Alternate Units", "Tolerances"]);
|
||||
let th = row(&d, "Text", "textHeight");
|
||||
assert_eq!((th["value"].as_f64(), th["editable"].as_bool(), th.get("overridden")), (Some(0.18), Some(true), None));
|
||||
assert_eq!(row(&d, "Misc", "dimStyle")["value"], "Standard");
|
||||
assert_eq!(row(&d, "Text", "textAbove")["display"], "Centered");
|
||||
assert_eq!(row(&d, "Primary Units", "decimals")["display"], "0.0000");
|
||||
assert_eq!(row(&d, "Lines & Arrows", "arrowBlock1")["display"], "Closed filled");
|
||||
assert_eq!(row(&d, "Lines & Arrows", "dimLineColor")["value"], "ByBlock");
|
||||
let m = row(&d, "Text", "measurement");
|
||||
assert_eq!((m["editable"].as_bool(), m["display"].as_str()), (Some(false), Some("10.0000")));
|
||||
assert_eq!(row(&d, "Text", "textOverride")["value"], "");
|
||||
|
||||
// A Properties edit is an override of this dimension; the row says so.
|
||||
let r = s.execute("properties.set", &json!({ "handles": [dm], "textHeight": 0.3 })).unwrap();
|
||||
assert_eq!(r["ignored"], json!([]));
|
||||
let d = describe(&mut s, json!({ "handles": [dm] }));
|
||||
let th = row(&d, "Text", "textHeight");
|
||||
assert_eq!((th["value"].as_f64(), th["overridden"].as_bool()), (Some(0.3), Some(true)));
|
||||
// The style itself is unchanged.
|
||||
let st = s.execute("dimstyle.list", &json!({ "name": "Standard" })).unwrap();
|
||||
assert_eq!(st["variables"]["DIMTXT"], 0.18);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fixed_height_text_style_decides_dimension_text_height() {
|
||||
let mut s = Session::new();
|
||||
s.execute("style", &json!({ "name": "Fixed", "height": 0.5, "current": false })).unwrap();
|
||||
s.execute("dimstyle", &json!({ "name": "FixedDims", "textStyle": "Fixed" })).unwrap();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
let d = describe(&mut s, json!({ "handles": [dm] }));
|
||||
let th = row(&d, "Text", "textHeight");
|
||||
assert_eq!((th["editable"].as_bool(), th["display"].as_str()), (Some(false), Some("0.5000")));
|
||||
assert!(th["note"].as_str().unwrap().contains("Fixed"), "{th}");
|
||||
// Fixed heights that differ vary, whatever their DIMTXT says.
|
||||
s.execute("style", &json!({ "name": "Large", "height": 0.75, "current": false })).unwrap();
|
||||
s.execute("dimstyle", &json!({ "name": "LargeDims", "textStyle": "Large" })).unwrap();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 10], "p2": [10, 10], "at": [5, 13] })).unwrap();
|
||||
let large = last(&s);
|
||||
let d = describe(&mut s, json!({ "handles": [dm, large] }));
|
||||
let th = row(&d, "Text", "textHeight");
|
||||
assert_eq!((th["editable"].as_bool(), th["display"].as_str()), (Some(false), Some("*VARIES*")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measurements_read_as_each_dimension_writes_them() {
|
||||
let mut s = Session::new();
|
||||
let shown =
|
||||
|s: &mut Session, hs: Value| row(&describe(s, json!({ "handles": hs })), "Text", "measurement")["display"].as_str().unwrap().to_string();
|
||||
s.execute("dimangular", &json!({ "vertex": [0, 0], "p1": [10, 0], "p2": [0, 10], "at": [3, 3] })).unwrap();
|
||||
let angle = last(&s);
|
||||
assert_eq!(shown(&mut s, json!([angle])), "90°");
|
||||
// In the dimension's angle format.
|
||||
s.execute("properties.set", &json!({ "handles": [angle], "angularUnit": 3, "angularDecimals": 2 })).unwrap();
|
||||
assert_eq!(shown(&mut s, json!([angle])), "1.57r");
|
||||
// The same length written at two precisions varies.
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let a = last(&s);
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 20], "p2": [10, 20], "at": [5, 23] })).unwrap();
|
||||
let b = last(&s);
|
||||
assert_eq!(shown(&mut s, json!([a, b])), "10.0000");
|
||||
s.execute("properties.set", &json!({ "handles": [b], "precision": 1 })).unwrap();
|
||||
assert_eq!(shown(&mut s, json!([a, b])), "*VARIES*");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rows_show_lengths_in_the_drawing_units() {
|
||||
let mut s = Session::new();
|
||||
s.execute("setvar", &json!({ "name": "LUNITS", "value": 4 })).unwrap();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 18 })).unwrap());
|
||||
let d = describe(&mut s, json!({ "handles": [t] }));
|
||||
assert_eq!(row(&d, "Text", "height")["display"], "1'-6\"");
|
||||
assert_eq!(row(&d, "Text", "height")["value"], 18.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_requests_never_panic() {
|
||||
let mut s = Session::new();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
|
||||
for p in [json!({}), json!({ "handles": "x" }), json!({ "handles": [t, t, t] }), json!({ "handles": [t], "type": 5 }), json!({ "type": "Text" })]
|
||||
{
|
||||
let _ = s.execute("properties.describe", &p);
|
||||
}
|
||||
// Duplicates count once.
|
||||
assert_eq!(describe(&mut s, json!({ "handles": [t, t] }))["count"], 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rotations_show_as_the_drawing_measures_directions() {
|
||||
let mut s = Session::new();
|
||||
s.execute("text", &json!({ "at": [0, 0], "text": "N", "height": 1, "rotation": 2.22729505553431 })).unwrap();
|
||||
// Clockwise from north (ANGBASE 90, ANGDIR 1): AutoCAD shows the text turned 2.23° as 87.77
|
||||
// (#1275); the value stays from +X counterclockwise, as properties.set takes it.
|
||||
for (name, value) in [("ANGDIR", json!(1)), ("ANGBASE", json!(90)), ("AUPREC", json!(2))] {
|
||||
s.execute("setvar", &json!({ "name": name, "value": value })).unwrap();
|
||||
}
|
||||
let h = last(&s);
|
||||
let desc = describe(&mut s, json!({ "handles": [h] }));
|
||||
let r = row(&desc, "Text", "rotation");
|
||||
assert_eq!(r["kind"], "direction");
|
||||
assert_eq!(r["display"], "87.77");
|
||||
assert!((r["value"].as_f64().unwrap() - 2.22729505553431).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_arrowheads_read_as_the_ones_drawn() {
|
||||
use cadcraft_engine::doc::DimStyle;
|
||||
use cadcraft_engine::properties::{DIM_PROPS, dim_value};
|
||||
let st = serde_json::to_value(DimStyle { arrow_block: "_DOT".into(), ..DimStyle::default() }).unwrap();
|
||||
let p = |field: &str| DIM_PROPS.iter().find(|p| p.field == field).unwrap();
|
||||
// An empty per-end arrowhead draws DIMBLK's; an empty leader arrowhead is closed filled.
|
||||
assert_eq!(dim_value(p("arrowBlock1"), &st), json!("_DOT"));
|
||||
assert_eq!(dim_value(p("arrowBlock"), &st), json!("_DOT"));
|
||||
assert_eq!(dim_value(p("leaderArrowBlock"), &st), json!(""));
|
||||
}
|
||||
|
||||
/// Float noise is no difference between two objects' values (7 and 7.0000000000001), but values
|
||||
/// the display rounds alike still vary (7 and 7.000001 both show as 7.0000).
|
||||
#[test]
|
||||
fn float_noise_does_not_vary_but_a_real_difference_does() {
|
||||
let mut s = Session::new();
|
||||
let a = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 7.0 })).unwrap());
|
||||
let b = handle(&s.execute("text", &json!({ "at": [0, 5], "text": "B", "height": 7.0 + 1e-13 })).unwrap());
|
||||
let both = describe(&mut s, json!({ "handles": [a.clone(), b.clone()] }));
|
||||
let h = row(&both, "Text", "height");
|
||||
assert_eq!((h["varies"].as_bool(), h["display"].as_str()), (Some(false), Some("7.0000")));
|
||||
s.execute("properties.set", &json!({ "handles": [b.clone()], "height": 7.000001 })).unwrap();
|
||||
let both = describe(&mut s, json!({ "handles": [a, b] }));
|
||||
assert_eq!(row(&both, "Text", "height")["varies"], true);
|
||||
}
|
||||
@@ -0,0 +1,366 @@
|
||||
//! `properties.set` for text, mtext and dimensions: the edits the Properties palette makes, keys
|
||||
//! nobody took coming back as `ignored`, and style edits reaching dimensions read from files.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::{EntityKind, HAlign, Handle, MText, Text};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
fn handle(r: &Value) -> String {
|
||||
r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap().to_string()
|
||||
}
|
||||
|
||||
fn last(s: &Session) -> String {
|
||||
s.doc().unwrap().model.last().unwrap().handle.hex()
|
||||
}
|
||||
|
||||
fn set(s: &mut Session, h: &str, p: Value) -> Value {
|
||||
let mut p = p;
|
||||
p["handles"] = json!([h]);
|
||||
s.execute("properties.set", &p).unwrap()
|
||||
}
|
||||
|
||||
fn text(s: &Session, h: &str) -> Text {
|
||||
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
|
||||
EntityKind::Text(t) => t.clone(),
|
||||
k => panic!("not text: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn mtext(s: &Session, h: &str) -> MText {
|
||||
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
|
||||
EntityKind::MText(t) => t.clone(),
|
||||
k => panic!("not mtext: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn dim(s: &Session, h: &str) -> cadcraft_engine::doc::Dimension {
|
||||
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
|
||||
EntityKind::Dimension(d) => d.clone(),
|
||||
k => panic!("not a dimension: {k:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn near(a: f64, b: f64) -> bool {
|
||||
(a - b).abs() < 1e-9
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_style_justify_oblique_and_position() {
|
||||
let mut s = Session::new();
|
||||
s.execute("style", &json!({ "name": "Notes", "current": false })).unwrap();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [5, 5], "text": "Hello", "height": 2 })).unwrap());
|
||||
let r = set(&mut s, &t, json!({ "style": "notes", "oblique": 15, "bogus": 1 }));
|
||||
assert_eq!(r["ignored"], json!(["bogus"]));
|
||||
assert_eq!(text(&s, &t).style, "Notes");
|
||||
assert!(near(text(&s, &t).oblique.to_degrees(), 15.0));
|
||||
// A style that doesn't exist is refused; an oblique past 85 degrees is ignored.
|
||||
assert!(s.execute("properties.set", &json!({ "handles": [t], "style": "Nope" })).is_err());
|
||||
assert_eq!(set(&mut s, &t, json!({ "oblique": 90 }))["ignored"], json!(["oblique"]));
|
||||
|
||||
// Justify keeps the point the text is placed by: the text moves around it.
|
||||
set(&mut s, &t, json!({ "justify": "MC" }));
|
||||
let j = text(&s, &t);
|
||||
assert_eq!((j.halign, j.justify_point().x, j.justify_point().y), (HAlign::Center, 5.0, 5.0));
|
||||
// Position X moves the text along X only.
|
||||
set(&mut s, &t, json!({ "positionX": 20 }));
|
||||
let j = text(&s, &t);
|
||||
assert_eq!((j.justify_point().x, j.justify_point().y), (20.0, 5.0));
|
||||
// Fit puts the second point at the end of the text, along its rotation.
|
||||
set(&mut s, &t, json!({ "justify": "Fit" }));
|
||||
let f = text(&s, &t);
|
||||
let end = f.align_pt.unwrap();
|
||||
assert!(f.halign == HAlign::Fit && near(f.insert.x, 20.0) && end.x > 20.0 && near(end.y, 5.0), "{f:?}");
|
||||
// The second point alone (the text refits between them).
|
||||
set(&mut s, &t, json!({ "alignmentX": 40 }));
|
||||
assert!(near(text(&s, &t).align_pt.unwrap().x, 40.0) && near(text(&s, &t).insert.x, 20.0));
|
||||
// Back to left: one point, where the fit text started.
|
||||
set(&mut s, &t, json!({ "justify": "Left" }));
|
||||
let l = text(&s, &t);
|
||||
assert!(l.align_pt.is_none() && near(l.insert.x, 20.0));
|
||||
// Alignment points belong to aligned and fit text only.
|
||||
assert_eq!(set(&mut s, &t, json!({ "alignmentX": 1 }))["ignored"], json!(["alignmentX"]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mtext_style_justify_and_line_spacing() {
|
||||
let mut s = Session::new();
|
||||
s.execute("style", &json!({ "name": "Notes", "current": false })).unwrap();
|
||||
let m = handle(&s.execute("mtext", &json!({ "at": [0, 10], "text": "one\\Ptwo", "height": 3, "width": 40 })).unwrap());
|
||||
set(&mut s, &m, json!({ "style": "Notes", "justify": "MC", "lineSpacing": 2, "lineSpacingStyle": "Exactly" }));
|
||||
let t = mtext(&s, &m);
|
||||
assert_eq!((t.style.as_str(), t.attach, t.line_spacing, t.line_spacing_exact), ("Notes", 5, 2.0, true));
|
||||
// The attachment point stays put.
|
||||
assert!(near(t.insert.x, 0.0) && near(t.insert.y, 10.0));
|
||||
// MTEXT's factors run from 0.25 to 4.
|
||||
assert_eq!(set(&mut s, &m, json!({ "lineSpacing": 10 }))["ignored"], json!(["lineSpacing"]));
|
||||
// A distance between lines sets the factor: factor × height × 5/3.
|
||||
set(&mut s, &m, json!({ "lineSpacingDistance": 7.5 }));
|
||||
assert!(near(mtext(&s, &m).line_spacing, 1.5));
|
||||
set(&mut s, &m, json!({ "lineSpacingStyle": "atLeast", "positionX": 4, "positionY": 6 }));
|
||||
let t = mtext(&s, &m);
|
||||
assert!(!t.line_spacing_exact && near(t.insert.x, 4.0) && near(t.insert.y, 6.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dimension_variables_become_overrides_of_each_dimension() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
set(&mut s, &dm, json!({ "textHeight": 0.3 }));
|
||||
assert_eq!(dim(&s, &dm).overrides.get("textHeight"), Some(&json!(0.3)));
|
||||
let geometry = |s: &Session| cadcraft_engine::render::dimension_in(s.doc().unwrap(), &dim(s, &dm));
|
||||
assert!(near(geometry(&s).text_height, 0.3));
|
||||
// A DIM* name replaces the override under its field name.
|
||||
set(&mut s, &dm, json!({ "DIMTXT": 0.25, "DIMGAP": 0.05 }));
|
||||
let o = dim(&s, &dm).overrides;
|
||||
assert_eq!((o.len(), o.get("textHeight"), o.get("textGap")), (2, Some(&json!(0.25)), Some(&json!(0.05))));
|
||||
// Clear one, then all.
|
||||
set(&mut s, &dm, json!({ "clear": ["DIMGAP"] }));
|
||||
assert_eq!(dim(&s, &dm).overrides.keys().collect::<Vec<_>>(), ["textHeight"]);
|
||||
set(&mut s, &dm, json!({ "clearOverrides": true }));
|
||||
assert!(dim(&s, &dm).overrides.is_empty());
|
||||
assert!(near(geometry(&s).text_height, 0.18));
|
||||
// Bad values and unknown text styles don't become overrides.
|
||||
// An unusable text height is refused (as Properties' dimension rows refuse it, #1473).
|
||||
assert!(s.execute("properties.set", &json!({ "handles": [dm], "textHeight": -1 })).is_err());
|
||||
assert!(s.execute("properties.set", &json!({ "handles": [dm], "textStyle": "Nope" })).is_err());
|
||||
assert!(dim(&s, &dm).overrides.is_empty());
|
||||
// A refused call makes no layer either.
|
||||
assert!(s.execute("properties.set", &json!({ "handles": [dm], "layer": "Notes", "dimStyle": "Nope" })).is_err());
|
||||
assert!(s.doc().unwrap().layer("Notes").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closed_filled_for_one_end_is_drawn_whatever_dimblk_says() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimstyle", &json!({ "name": "Ticks", "arrowBlock": "_ARCHTICK" })).unwrap();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
// Closed filled is "" among the arrowheads; for one end it's named, as "" there is DIMBLK's.
|
||||
set(&mut s, &dm, json!({ "arrowBlock1": "" }));
|
||||
assert_eq!(dim(&s, &dm).overrides.get("arrowBlock1"), Some(&json!("_CLOSEDFILLED")));
|
||||
let rows = s.execute("properties.describe", &json!({ "handles": [dm] })).unwrap();
|
||||
let arrow = |key: &str| {
|
||||
rows["groups"].as_array().unwrap().iter().flat_map(|g| g["rows"].as_array().unwrap()).find(|r| r["key"] == key).unwrap()["value"].clone()
|
||||
};
|
||||
assert_eq!((arrow("arrowBlock1"), arrow("arrowBlock2")), (json!(""), json!("_ARCHTICK")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dimension_text_rows() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
set(&mut s, &dm, json!({ "prefix": "~", "suffix": " mm", "textRotation": 30, "textPositionX": 2 }));
|
||||
let d = dim(&s, &dm);
|
||||
assert_eq!(d.overrides.get("post"), Some(&json!("~<> mm")));
|
||||
assert!(near(d.text_rotation.to_degrees(), 30.0));
|
||||
assert!(d.user_text_pos && near(d.text_mid.x, 2.0));
|
||||
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &d);
|
||||
assert!(g.value.starts_with('~') && g.value.ends_with(" mm"), "{}", g.value);
|
||||
// A suffix alone keeps the prefix.
|
||||
set(&mut s, &dm, json!({ "suffix": "" }));
|
||||
assert_eq!(dim(&s, &dm).overrides.get("post"), Some(&json!("~<>")));
|
||||
// Together with other edits, the prefix goes into what those leave: here no suffix override.
|
||||
set(&mut s, &dm, json!({ "suffix": " mm" }));
|
||||
set(&mut s, &dm, json!({ "clearOverrides": true, "prefix": "=" }));
|
||||
assert_eq!(dim(&s, &dm).overrides.get("post"), Some(&json!("=<>")));
|
||||
// The prefix and suffix rows are DIMPOST's halves: overridden with it, reset with it.
|
||||
let rows = s.execute("properties.describe", &json!({ "handles": [dm] })).unwrap();
|
||||
let prefix =
|
||||
rows["groups"].as_array().unwrap().iter().flat_map(|g| g["rows"].as_array().unwrap()).find(|r| r["key"] == "prefix").unwrap().clone();
|
||||
assert_eq!(prefix["overridden"], true, "{prefix}");
|
||||
set(&mut s, &dm, json!({ "clear": ["prefix"] }));
|
||||
assert!(dim(&s, &dm).overrides.get("post").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rotating_aligned_text_turns_its_baseline() {
|
||||
let mut s = Session::new();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "Wide", "height": 1 })).unwrap());
|
||||
set(&mut s, &t, json!({ "justify": "Align" }));
|
||||
let long = text(&s, &t).align_pt.unwrap().x;
|
||||
assert!(long > 0.0);
|
||||
set(&mut s, &t, json!({ "rotation": 90 }));
|
||||
let end = text(&s, &t).align_pt.unwrap();
|
||||
assert!(near(end.x, 0.0) && near(end.y, long), "{end:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn justify_in_one_call_with_other_edits_takes_them_in() {
|
||||
// Fit with new contents measures the new text; with a rotation, the baseline runs along it.
|
||||
let mut s = Session::new();
|
||||
let short = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
|
||||
let long = handle(&s.execute("text", &json!({ "at": [0, 5], "text": "Much longer", "height": 1 })).unwrap());
|
||||
set(&mut s, &long, json!({ "justify": "Fit" }));
|
||||
set(&mut s, &short, json!({ "text": "Much longer", "justify": "Fit", "rotation": 90 }));
|
||||
let (a, b) = (text(&s, &short), text(&s, &long));
|
||||
let len = |t: &Text| t.insert.xy().dist(t.align_pt.unwrap().xy());
|
||||
assert!(near(len(&a), len(&b)), "{} {}", len(&a), len(&b));
|
||||
let end = a.align_pt.unwrap();
|
||||
assert!(near(end.x, 0.0) && end.y > 0.0, "{end:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scale_is_no_dimension_override() {
|
||||
// `scale` is an insert's or hatch's; a dimension's overall scale is `dimScale`.
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
assert_eq!(set(&mut s, &dm, json!({ "scale": 2 }))["ignored"], json!(["scale"]));
|
||||
assert!(dim(&s, &dm).overrides.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn making_a_style_current_keeps_the_dimensions_read_from_a_file() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
|
||||
s.open_drawing(back, "dims", None);
|
||||
let dm = last(&s);
|
||||
assert!(dim(&s, &dm).block.is_some());
|
||||
// No field changes: the geometry the file stored stays.
|
||||
s.execute("dimstyle", &json!({ "name": "Standard" })).unwrap();
|
||||
s.execute("style", &json!({ "name": "Standard" })).unwrap();
|
||||
assert!(dim(&s, &dm).block.is_some());
|
||||
// A change redraws it.
|
||||
s.execute("dimstyle", &json!({ "name": "Standard", "DIMTXT": 0.3 })).unwrap();
|
||||
assert!(dim(&s, &dm).block.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hatch_pattern_edits_go_as_hatchedits_do() {
|
||||
let mut s = Session::new();
|
||||
s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
|
||||
s.execute("gradient", &json!({ "points": [[5, 5]], "color1": "1", "color2": "3" })).unwrap();
|
||||
let h = s.doc().unwrap().model.iter().find(|e| matches!(e.kind, EntityKind::Hatch(_))).unwrap().handle.hex();
|
||||
let hatch = |s: &Session| match &s.doc().unwrap().entity(Handle::parse_hex(&h).unwrap()).unwrap().kind {
|
||||
EntityKind::Hatch(x) => x.clone(),
|
||||
k => panic!("not a hatch: {k:?}"),
|
||||
};
|
||||
assert!(hatch(&s).gradient.is_some());
|
||||
// SOLID is a plain fill, not the gradient.
|
||||
set(&mut s, &h, json!({ "pattern": "SOLID" }));
|
||||
assert!(hatch(&s).solid && hatch(&s).gradient.is_none());
|
||||
// A blank name changes nothing.
|
||||
assert_eq!(set(&mut s, &h, json!({ "pattern": " " }))["ignored"], json!(["pattern"]));
|
||||
assert_eq!(hatch(&s).pattern, "SOLID");
|
||||
// A name no pattern has is refused, as HATCHEDIT refuses it; a defined one is taken.
|
||||
assert!(s.execute("properties.set", &json!({ "handles": [h], "pattern": "ANSI3" })).is_err());
|
||||
assert_eq!(hatch(&s).pattern, "SOLID");
|
||||
set(&mut s, &h, json!({ "pattern": "ansi31" }));
|
||||
assert_eq!(hatch(&s).pattern, "ANSI31");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_object_that_is_not_there_refuses_the_whole_call() {
|
||||
let mut s = Session::new();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
|
||||
assert!(s.execute("properties.set", &json!({ "handles": [t, "FFFFF"], "height": 3, "layer": "Notes" })).is_err());
|
||||
assert_eq!(text(&s, &t).height, 1.0);
|
||||
assert!(s.doc().unwrap().layer("Notes").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edits_of_a_dimension_read_from_a_file_redraw_it() {
|
||||
let mut s = Session::new();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
// Read back from DXF, a dimension draws the block it was saved with.
|
||||
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
|
||||
s.open_drawing(back, "dims", None);
|
||||
let dm = last(&s);
|
||||
assert!(dim(&s, &dm).block.is_some());
|
||||
// Nothing changed: the block stays.
|
||||
set(&mut s, &dm, json!({ "clear": [], "color": "ByLayer" }));
|
||||
assert!(dim(&s, &dm).block.is_some());
|
||||
set(&mut s, &dm, json!({ "textHeight": 0.4 }));
|
||||
assert!(dim(&s, &dm).block.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn style_edits_redraw_dimensions_read_from_a_file() {
|
||||
let mut s = Session::new();
|
||||
s.execute("style", &json!({ "name": "DimText", "current": false })).unwrap();
|
||||
s.execute("dimstyle", &json!({ "name": "Plan", "textStyle": "DimText" })).unwrap();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
s.execute("dimstyle", &json!({ "name": "Other" })).unwrap();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 10], "p2": [10, 10], "at": [5, 13] })).unwrap();
|
||||
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
|
||||
s.open_drawing(back, "dims", None);
|
||||
let dims: Vec<(String, cadcraft_engine::doc::Dimension)> = s
|
||||
.doc()
|
||||
.unwrap()
|
||||
.model
|
||||
.iter()
|
||||
.filter_map(|e| if let EntityKind::Dimension(d) = &e.kind { Some((e.handle.hex(), d.clone())) } else { None })
|
||||
.collect();
|
||||
let plan = dims.iter().find(|(_, d)| d.style == "Plan").unwrap().0.clone();
|
||||
let other = dims.iter().find(|(_, d)| d.style == "Other").unwrap().0.clone();
|
||||
assert!(dim(&s, &plan).block.is_some() && dim(&s, &other).block.is_some());
|
||||
// Editing a dimension style redraws the dimensions that use it, and only those.
|
||||
s.execute("dimstyle", &json!({ "name": "Plan", "DIMTXT": 0.5, "current": false })).unwrap();
|
||||
assert!(dim(&s, &plan).block.is_none() && dim(&s, &other).block.is_some());
|
||||
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &dim(&s, &plan));
|
||||
assert!(near(g.text_height, 0.5));
|
||||
// Editing a text style redraws the dimensions whose text uses it.
|
||||
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
|
||||
s.open_drawing(back, "dims", None);
|
||||
let plan = s.doc().unwrap().model.iter().find(|e| matches!(&e.kind, EntityKind::Dimension(d) if d.style == "Plan")).unwrap().handle.hex();
|
||||
assert!(dim(&s, &plan).block.is_some());
|
||||
s.execute("style", &json!({ "name": "DimText", "widthFactor": 0.8, "current": false })).unwrap();
|
||||
assert!(dim(&s, &plan).block.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn renaming_a_text_style_follows_dimension_overrides() {
|
||||
let mut s = Session::new();
|
||||
s.execute("style", &json!({ "name": "Old", "current": false })).unwrap();
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
set(&mut s, &dm, json!({ "textStyle": "Old" }));
|
||||
s.execute("style.rename", &json!({ "from": "Old", "to": "New" })).unwrap();
|
||||
assert_eq!(dim(&s, &dm).overrides.get("textStyle"), Some(&json!("New")));
|
||||
// A style only a dimension override names is in use: it can't be deleted.
|
||||
assert!(s.execute("style.delete", &json!({ "name": "New" })).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_values_never_panic() {
|
||||
let mut s = Session::new();
|
||||
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
|
||||
let m = handle(&s.execute("mtext", &json!({ "at": [0, 5], "text": "B", "height": 1 })).unwrap());
|
||||
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
|
||||
let dm = last(&s);
|
||||
for v in [json!(null), json!("x"), json!(1e308), json!(-1e308), json!([1, 2]), json!({ "a": 1 }), json!(true)] {
|
||||
let mut p = json!({ "handles": [t, m, dm] });
|
||||
for k in [
|
||||
"justify",
|
||||
"oblique",
|
||||
"positionX",
|
||||
"positionZ",
|
||||
"alignmentX",
|
||||
"lineSpacing",
|
||||
"lineSpacingDistance",
|
||||
"lineSpacingStyle",
|
||||
"textRotation",
|
||||
"textPositionX",
|
||||
"prefix",
|
||||
"suffix",
|
||||
"altPrefix",
|
||||
"clear",
|
||||
"clearOverrides",
|
||||
"DIMTXT",
|
||||
"DIMBLK1",
|
||||
"DIMCLRT",
|
||||
"DIMLWD",
|
||||
"DIMLTYPE",
|
||||
] {
|
||||
p[k] = v.clone();
|
||||
}
|
||||
let _ = s.execute("properties.set", &p);
|
||||
let _ = s.execute("properties.describe", &json!({ "handles": [t, m, dm] }));
|
||||
}
|
||||
// Every dimension still draws.
|
||||
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &dim(&s, &dm));
|
||||
assert!(g.text_height.is_finite());
|
||||
}
|
||||
@@ -4,7 +4,7 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_engine::doc::{Block, Common, Entity, EntityKind, Handle, Insert, MLine, MLineJust, MLineStyle, Space};
|
||||
use cadcraft_engine::doc::{Attrib, Block, Common, Entity, EntityKind, Handle, Insert, MLine, MLineElement, MLineJust, MLineStyle, Space};
|
||||
use cadcraft_engine::geom::{Vec2, Vec3};
|
||||
use serde_json::json;
|
||||
|
||||
@@ -75,3 +75,67 @@ fn purge_mlinestyles_at_the_command_line() {
|
||||
assert!(s.running.is_none(), "{}", s.prompt_text());
|
||||
assert_eq!(styles(&s), ["STANDARD", "Model", "InBlock", "Gone", "Current"]);
|
||||
}
|
||||
|
||||
/// A linetype is in use when only a dimension style, a dimension override, a multiline style, a
|
||||
/// multiline's copy of its style or an attribute override names it.
|
||||
#[test]
|
||||
fn linetypes_named_by_styles_and_attributes_are_kept() {
|
||||
let mut s = session();
|
||||
let d = s.doc_mut().unwrap();
|
||||
for name in ["InDimStyle", "InOverride", "InMline", "InMlineCopy", "InAttribute", "Unused"] {
|
||||
let mut lt = d.linetypes[0].clone();
|
||||
lt.name = name.into();
|
||||
d.linetypes.push(lt);
|
||||
}
|
||||
d.dim_styles[0].ext_linetype2 = "InDimStyle".into();
|
||||
let element = MLineElement { linetype: "InMline".into(), ..MLineElement::default() };
|
||||
d.mline_styles.iter_mut().for_each(|t| t.elements.push(element.clone()));
|
||||
let at = serde_json::to_value(Vec3::ZERO).unwrap();
|
||||
let mut attrib: Attrib = serde_json::from_value(json!({ "tag": "A", "text": { "insert": at, "height": 1.0, "value": "1" } })).unwrap();
|
||||
attrib.props.linetype = Some("InAttribute".into());
|
||||
let Some(EntityKind::Insert(mut ins)) = d.model.iter().find_map(|e| matches!(e.kind, EntityKind::Insert(_)).then(|| e.kind.clone())) else {
|
||||
return;
|
||||
};
|
||||
ins.attribs.push(attrib);
|
||||
d.add(&Space::Model, Common::default(), EntityKind::Insert(ins)).unwrap();
|
||||
let copy = MLineElement { linetype: "InMlineCopy".into(), ..MLineElement::default() };
|
||||
let drawn = MLineStyle { name: "Model".into(), elements: vec![copy], ..MLineStyle::default() };
|
||||
d.add(&Space::Model, Common::default(), mline(&drawn)).unwrap();
|
||||
let dim = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
|
||||
let handle = dim["handle"].clone();
|
||||
s.execute("dimoverride", &json!({ "handles": [handle], "DIMLTYPE": "InOverride" })).unwrap();
|
||||
s.execute("purge", &json!({ "type": "linetypes" })).unwrap();
|
||||
let names: Vec<String> = s.doc().unwrap().linetypes.iter().map(|l| l.name.clone()).collect();
|
||||
for kept in ["InDimStyle", "InOverride", "InMline", "InMlineCopy", "InAttribute"] {
|
||||
assert!(names.iter().any(|n| n == kept), "{kept}: {names:?}");
|
||||
}
|
||||
assert!(!names.iter().any(|n| n == "Unused"), "{names:?}");
|
||||
}
|
||||
|
||||
/// A dimension override given as a number names a text style, linetype or arrowhead block all
|
||||
/// the same (DIMOVERRIDE keeps the number, the dimension is drawn with it as text): PURGE keeps
|
||||
/// them.
|
||||
#[test]
|
||||
fn numbers_in_dimension_overrides_name_what_they_use() {
|
||||
let mut s = session();
|
||||
let d = s.doc_mut().unwrap();
|
||||
for name in ["123", "Spare"] {
|
||||
let mut t = d.text_styles[0].clone();
|
||||
t.name = name.into();
|
||||
d.text_styles.push(t);
|
||||
}
|
||||
for name in ["7", "Spare"] {
|
||||
let mut lt = d.linetypes[0].clone();
|
||||
lt.name = name.into();
|
||||
d.linetypes.push(lt);
|
||||
}
|
||||
d.blocks.insert("45".into(), Arc::new(Block::new("45")));
|
||||
let h = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap()["handle"].clone();
|
||||
s.execute("dimoverride", &json!({ "handles": [h], "DIMTXSTY": 123, "DIMLTYPE": 7, "DIMBLK1": 45 })).unwrap();
|
||||
let r = s.execute("purge", &json!({ "type": "all" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert!(d.text_style("123").is_some(), "{r}");
|
||||
assert!(d.linetypes.iter().any(|l| l.name == "7"), "{r}");
|
||||
assert!(d.block("45").is_some(), "{r}");
|
||||
assert_eq!((r["purged"]["textstyles"].clone(), r["purged"]["linetypes"].clone()), (json!(["Spare"]), json!(["Spare"])), "{r}");
|
||||
}
|
||||
|
||||
@@ -88,6 +88,27 @@ fn massprop_self_check_reports_skipped_objects() {
|
||||
assert_eq!(sc["implausible"], json!([]));
|
||||
}
|
||||
|
||||
/// REGION typed with nothing selected asks for objects, as in AutoCAD, instead of reporting
|
||||
/// "0 Region(s) created."; with objects already selected it converts them at once.
|
||||
#[test]
|
||||
fn typed_region_asks_for_objects() {
|
||||
let mut s = Session::new();
|
||||
let r = h(&s.execute("rectang", &json!({"p1": [0, 0], "p2": [10, 4]})).unwrap());
|
||||
s.set_selection(Vec::new());
|
||||
s.cmdline("region").unwrap();
|
||||
assert!(s.running.is_some(), "REGION should ask for objects: {}", s.prompt_text());
|
||||
s.cmdline("l").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
assert!(s.running.is_none(), "{}", s.prompt_text());
|
||||
assert!(matches!(s.doc().unwrap().entity(r).unwrap().kind, EntityKind::Region(_)));
|
||||
// Preselected objects are converted at once.
|
||||
let c = h(&s.execute("circle", &json!({"center": [20, 0], "radius": 2})).unwrap());
|
||||
s.set_selection(vec![c]);
|
||||
s.cmdline("region").unwrap();
|
||||
assert!(s.running.is_none(), "{}", s.prompt_text());
|
||||
assert!(matches!(s.doc().unwrap().entity(c).unwrap().kind, EntityKind::Region(_)));
|
||||
}
|
||||
|
||||
/// Make `hd` invisible: it no longer counts towards the drawing extents.
|
||||
fn hide(s: &mut Session, hd: Handle) {
|
||||
s.doc_mut().unwrap().modify_entity(hd, |e| e.common.visible = false).unwrap();
|
||||
|
||||
@@ -128,6 +128,23 @@ fn hatch_uses_a_pattern_from_a_pat_file_and_keeps_its_definition() {
|
||||
assert!(hatches(&s).pop().unwrap().pattern_lines.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn properties_pattern_edits_keep_a_pat_files_definition() {
|
||||
let mut s = Session::new();
|
||||
s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
|
||||
s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": "ANSI31", "patternText": PAT })).unwrap();
|
||||
let hx = s.doc().unwrap().model.iter().find(|e| matches!(e.kind, EntityKind::Hatch(_))).unwrap().handle.hex();
|
||||
// As HATCHEDIT: a loaded pattern brings its lines, and they stay.
|
||||
s.execute("properties.set", &json!({ "handles": [hx], "pattern": "MYSTEPS" })).unwrap();
|
||||
let h = hatches(&s).pop().unwrap();
|
||||
assert_eq!((h.pattern.as_str(), h.pattern_lines.len()), ("MYSTEPS", 1));
|
||||
// The same name again keeps them, and a library pattern drops them.
|
||||
s.execute("properties.set", &json!({ "handles": [hx], "pattern": "mysteps" })).unwrap();
|
||||
assert_eq!(hatches(&s).pop().unwrap().pattern_lines[0].dashes, [0.25, -0.25]);
|
||||
s.execute("properties.set", &json!({ "handles": [hx], "pattern": "ANSI37" })).unwrap();
|
||||
assert!(hatches(&s).pop().unwrap().pattern_lines.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hatch_pattern_prompt_takes_a_pat_file_name() {
|
||||
let dir = TempDir::new("lin-pat");
|
||||
|
||||
@@ -11,6 +11,7 @@ workspace = true
|
||||
[dependencies]
|
||||
cadcraft-geom = { workspace = true }
|
||||
craft-dxf = { workspace = true }
|
||||
craft-font-catalog = { workspace = true }
|
||||
craft-shx = { workspace = true }
|
||||
skrifa = { workspace = true }
|
||||
harfrust = { workspace = true }
|
||||
|
||||
+23
-338
@@ -1,344 +1,29 @@
|
||||
//! The shape pen program: vector length/direction bytes and special codes 0–14, run into
|
||||
//! polylines. Bounded everywhere: subshape depth, location stack, steps, points, coordinates.
|
||||
//!
|
||||
//! - A byte with a non-zero high nibble is a vector: length (high nibble) in one of 16
|
||||
//! directions (low nibble, counter-clockwise from east in 22.5° steps; the off-axis ones
|
||||
//! are half-unit or unit steps on the minor axis).
|
||||
//! - 0 end, 1 pen down, 2 pen up, 3/4 divide/multiply vector lengths by the next byte,
|
||||
//! 5/6 push/pop the location, 7 subshape (one byte; two bytes high first in a Unicode font;
|
||||
//! `0`, a two-byte number, base point, width and height in an extended big font),
|
||||
//! 8 one X-Y displacement, 9 displacements up to (0,0), 10 octant arc (radius,
|
||||
//! ±0SC: sign = clockwise, S start octant, C octants, 0 = 8), 11 fractional arc (start
|
||||
//! offset, end offset, high and low radius, ±0SC; offsets in 1/256 of 45° from the octant
|
||||
//! boundaries), 12 bulge arc (dx, dy, bulge: ±127 = semicircle), 13 bulge arcs up to (0,0),
|
||||
//! 14 the next command is for vertical text only (dual-orientation fonts).
|
||||
//! - Displacements and bulges are two's complement bytes; the arc direction byte keeps its
|
||||
//! sign in the high bit.
|
||||
|
||||
use std::f64::consts::{FRAC_PI_4, TAU};
|
||||
|
||||
//! Map the shared SHX pen interpreter's neutral strokes into CAD geometry.
|
||||
use super::{ShxFont, ShxGlyph, ShxKind};
|
||||
use cadcraft_geom::Vec2;
|
||||
|
||||
use super::{ShxFont, ShxGlyph, ShxKind};
|
||||
|
||||
/// Subshape nesting (a cycle ends here).
|
||||
const MAX_DEPTH: usize = 16;
|
||||
/// Location stack (the format promises four).
|
||||
const MAX_STACK: usize = 64;
|
||||
/// Bytes run per glyph, subshapes included.
|
||||
const MAX_STEPS: usize = 200_000;
|
||||
/// Points per glyph.
|
||||
const MAX_POINTS: usize = 50_000;
|
||||
/// Coordinates in font units.
|
||||
const MAX_COORD: f64 = 1.0e7;
|
||||
/// Arc segments per full turn.
|
||||
const ARC_STEPS: f64 = 64.0;
|
||||
|
||||
/// Why a program stops early: the glyph is then not drawn.
|
||||
#[derive(Debug)]
|
||||
pub(super) struct Broken;
|
||||
|
||||
type Res = Result<(), Broken>;
|
||||
|
||||
struct Pen<'a> {
|
||||
font: &'a ShxFont,
|
||||
vertical: bool,
|
||||
pos: Vec2,
|
||||
down: bool,
|
||||
/// Vector length factor (codes 3 and 4).
|
||||
scale: f64,
|
||||
/// Per-axis factor of an extended big font subshape.
|
||||
axes: Vec2,
|
||||
stack: Vec<Vec2>,
|
||||
strokes: Vec<Vec<Vec2>>,
|
||||
active: Vec<Vec2>,
|
||||
steps: usize,
|
||||
points: usize,
|
||||
}
|
||||
|
||||
pub(super) fn outline(font: &ShxFont, number: u16, vertical: bool) -> Result<ShxGlyph, Broken> {
|
||||
let mut pen = Pen {
|
||||
font,
|
||||
vertical,
|
||||
pos: Vec2::ZERO,
|
||||
down: true,
|
||||
scale: 1.0,
|
||||
axes: Vec2::new(1.0, 1.0),
|
||||
stack: Vec::new(),
|
||||
strokes: Vec::new(),
|
||||
active: Vec::new(),
|
||||
steps: 0,
|
||||
points: 0,
|
||||
};
|
||||
pen.run(number, 0)?;
|
||||
pen.flush();
|
||||
Ok(ShxGlyph { strokes: pen.strokes, advance: pen.pos })
|
||||
}
|
||||
|
||||
/// The 16 vector directions (unit length on the major axis).
|
||||
fn direction(d: u8) -> Vec2 {
|
||||
let (x, y) = match d & 15 {
|
||||
0 => (1.0, 0.0),
|
||||
1 => (1.0, 0.5),
|
||||
2 => (1.0, 1.0),
|
||||
3 => (0.5, 1.0),
|
||||
4 => (0.0, 1.0),
|
||||
5 => (-0.5, 1.0),
|
||||
6 => (-1.0, 1.0),
|
||||
7 => (-1.0, 0.5),
|
||||
8 => (-1.0, 0.0),
|
||||
9 => (-1.0, -0.5),
|
||||
10 => (-1.0, -1.0),
|
||||
11 => (-0.5, -1.0),
|
||||
12 => (0.0, -1.0),
|
||||
13 => (0.5, -1.0),
|
||||
14 => (1.0, -1.0),
|
||||
_ => (1.0, -0.5),
|
||||
};
|
||||
Vec2::new(x, y)
|
||||
}
|
||||
|
||||
/// A two's complement operand byte.
|
||||
fn signed(b: u8) -> f64 {
|
||||
f64::from(i8::from_le_bytes([b]))
|
||||
}
|
||||
|
||||
/// A program being read: its bytes and position.
|
||||
struct Cur<'p> {
|
||||
b: &'p [u8],
|
||||
pos: usize,
|
||||
}
|
||||
|
||||
impl Cur<'_> {
|
||||
fn byte(&mut self) -> Result<u8, Broken> {
|
||||
let v = self.b.get(self.pos).copied().ok_or(Broken)?;
|
||||
self.pos += 1;
|
||||
Ok(v)
|
||||
impl craft_shx::program::Font for ShxFont {
|
||||
fn kind(&self) -> ShxKind {
|
||||
self.kind
|
||||
}
|
||||
fn dual(&self) -> bool {
|
||||
self.dual
|
||||
}
|
||||
fn above(&self) -> f64 {
|
||||
self.above
|
||||
}
|
||||
fn char_width(&self) -> f64 {
|
||||
self.char_width
|
||||
}
|
||||
fn program(&self, number: u16) -> Option<&[u8]> {
|
||||
ShxFont::program(self, number)
|
||||
}
|
||||
}
|
||||
|
||||
impl Pen<'_> {
|
||||
fn step(&mut self) -> Res {
|
||||
self.steps += 1;
|
||||
if self.steps > MAX_STEPS { Err(Broken) } else { Ok(()) }
|
||||
}
|
||||
|
||||
fn flush(&mut self) {
|
||||
if self.active.len() >= 2 {
|
||||
self.strokes.push(std::mem::take(&mut self.active));
|
||||
} else {
|
||||
self.active.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// Move the pen by `d` font units (already scaled), drawing when the pen is down.
|
||||
fn to(&mut self, target: Vec2) -> Res {
|
||||
if !target.is_finite() || target.x.abs().max(target.y.abs()) > MAX_COORD {
|
||||
return Err(Broken);
|
||||
}
|
||||
if self.down {
|
||||
if self.active.is_empty() {
|
||||
self.active.push(self.pos);
|
||||
self.points += 1;
|
||||
}
|
||||
self.active.push(target);
|
||||
self.points += 1;
|
||||
if self.points > MAX_POINTS {
|
||||
return Err(Broken);
|
||||
}
|
||||
} else {
|
||||
self.flush();
|
||||
}
|
||||
self.pos = target;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A displacement in vector units (times the length factor and the subshape axes).
|
||||
fn by(&mut self, d: Vec2) -> Res {
|
||||
let k = d * self.scale;
|
||||
self.to(self.pos + Vec2::new(k.x * self.axes.x, k.y * self.axes.y))
|
||||
}
|
||||
|
||||
/// An arc of `radius` vector units from the pen, starting at angle `start` on its circle
|
||||
/// and turning `sweep` radians (positive counter-clockwise).
|
||||
fn arc(&mut self, radius: f64, start: f64, sweep: f64) -> Res {
|
||||
let r = radius * self.scale;
|
||||
if !(r.is_finite() && r > 0.0 && sweep.is_finite()) {
|
||||
return Ok(());
|
||||
}
|
||||
let n = if self.down { (sweep.abs() / TAU * ARC_STEPS).ceil().clamp(1.0, ARC_STEPS) as usize } else { 1 };
|
||||
let from = self.pos;
|
||||
let s0 = Vec2::new(start.cos(), start.sin());
|
||||
for i in 1..=n {
|
||||
let a = start + sweep * i as f64 / n as f64;
|
||||
let d = (Vec2::new(a.cos(), a.sin()) - s0) * r;
|
||||
self.to(from + Vec2::new(d.x * self.axes.x, d.y * self.axes.y))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// An arc to the displacement `d` with `bulge` (−127..127, ±127 a semicircle).
|
||||
fn bulge(&mut self, d: Vec2, bulge: f64) -> Res {
|
||||
let b = bulge.clamp(-127.0, 127.0) / 127.0;
|
||||
if b == 0.0 || !self.down || d.len2() == 0.0 {
|
||||
return self.by(d);
|
||||
}
|
||||
// Centre from the chord midpoint along its left normal; sweep 4·atan(b).
|
||||
let centre = d * 0.5 + Vec2::new(-d.y, d.x) * ((1.0 - b * b) / (4.0 * b));
|
||||
let rel = -centre;
|
||||
self.arc(rel.len(), rel.y.atan2(rel.x), 4.0 * b.atan())
|
||||
}
|
||||
|
||||
/// The octant byte `±0SC`: (clockwise, start octant, octants with 0 = 8).
|
||||
fn octants(spec: u8) -> (f64, f64, f64) {
|
||||
let sign = if spec & 0x80 != 0 { -1.0 } else { 1.0 };
|
||||
let s = f64::from((spec >> 4) & 7);
|
||||
let c = match spec & 7 {
|
||||
0 => 8.0,
|
||||
c => f64::from(c),
|
||||
};
|
||||
(sign, s, c)
|
||||
}
|
||||
|
||||
/// The vector unit size of an extended big font's subshape cell.
|
||||
fn cell(&self) -> Vec2 {
|
||||
let h = if self.font.above > 0.0 { self.font.above } else { 1.0 };
|
||||
let w = if self.font.char_width > 0.0 { self.font.char_width } else { h };
|
||||
Vec2::new(w, h)
|
||||
}
|
||||
|
||||
fn run(&mut self, number: u16, depth: usize) -> Res {
|
||||
if depth >= MAX_DEPTH {
|
||||
return Err(Broken);
|
||||
}
|
||||
let program = self.font.program(number).ok_or(Broken)?;
|
||||
let mut r = Cur { b: program, pos: 0 };
|
||||
let mut skip = false;
|
||||
while r.pos < r.b.len() {
|
||||
self.step()?;
|
||||
let code = r.byte()?;
|
||||
// Code 14: in a dual-orientation font the next command is for vertical text only.
|
||||
let exec = !skip;
|
||||
skip = false;
|
||||
match code {
|
||||
0 => return Ok(()),
|
||||
1 if exec => self.down = true,
|
||||
2 if exec => {
|
||||
self.down = false;
|
||||
self.flush();
|
||||
}
|
||||
3 | 4 => {
|
||||
let k = f64::from(r.byte()?);
|
||||
if exec && k > 0.0 {
|
||||
let s = if code == 3 { self.scale / k } else { self.scale * k };
|
||||
if !(1e-9..=MAX_COORD).contains(&s) {
|
||||
return Err(Broken);
|
||||
}
|
||||
self.scale = s;
|
||||
}
|
||||
}
|
||||
5 if exec => {
|
||||
if self.stack.len() >= MAX_STACK {
|
||||
return Err(Broken);
|
||||
}
|
||||
self.stack.push(self.pos);
|
||||
}
|
||||
6 if exec => {
|
||||
self.flush();
|
||||
if let Some(p) = self.stack.pop() {
|
||||
self.pos = p;
|
||||
}
|
||||
}
|
||||
7 => self.subshape(&mut r, exec, depth)?,
|
||||
8 | 9 | 12 | 13 => loop {
|
||||
self.step()?;
|
||||
let d = Vec2::new(signed(r.byte()?), signed(r.byte()?));
|
||||
if matches!(code, 9 | 13) && d == Vec2::ZERO {
|
||||
break;
|
||||
}
|
||||
let bulge = if matches!(code, 12 | 13) { signed(r.byte()?) } else { 0.0 };
|
||||
if exec {
|
||||
self.bulge(d, bulge)?;
|
||||
}
|
||||
if matches!(code, 8 | 12) {
|
||||
break;
|
||||
}
|
||||
},
|
||||
10 => {
|
||||
let radius = f64::from(r.byte()?);
|
||||
let (sign, s, c) = Self::octants(r.byte()?);
|
||||
if exec {
|
||||
self.arc(radius, s * FRAC_PI_4, sign * c * FRAC_PI_4)?;
|
||||
}
|
||||
}
|
||||
11 => {
|
||||
let start = f64::from(r.byte()?) / 256.0;
|
||||
let end = match r.byte()? {
|
||||
0 => 1.0,
|
||||
e => f64::from(e) / 256.0,
|
||||
};
|
||||
let radius = f64::from(u16::from_be_bytes([r.byte()?, r.byte()?]));
|
||||
let (sign, s, c) = Self::octants(r.byte()?);
|
||||
if exec {
|
||||
// From `start` past the first octant boundary to `end` past the last
|
||||
// octant's.
|
||||
self.arc(radius, (s + sign * start) * FRAC_PI_4, sign * (c - 1.0 + end - start) * FRAC_PI_4)?;
|
||||
}
|
||||
}
|
||||
14 => skip = self.font.dual && !self.vertical && exec,
|
||||
1..=15 => {}
|
||||
v => {
|
||||
if exec {
|
||||
self.by(direction(v) * f64::from(v >> 4))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Code 7 and its operands.
|
||||
fn subshape(&mut self, r: &mut Cur, exec: bool, depth: usize) -> Res {
|
||||
match self.font.kind {
|
||||
ShxKind::Unifont => {
|
||||
let n = u16::from_be_bytes([r.byte()?, r.byte()?]);
|
||||
if exec {
|
||||
self.run(n, depth + 1)?;
|
||||
}
|
||||
}
|
||||
ShxKind::BigFont => {
|
||||
let first = r.byte()?;
|
||||
if first != 0 {
|
||||
if exec {
|
||||
self.run(u16::from(first), depth + 1)?;
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
// Extended: the primitive drawn in the box (x, y, width, height) of the cell.
|
||||
let n = u16::from_be_bytes([r.byte()?, r.byte()?]);
|
||||
let (x, y, w, h) = (f64::from(r.byte()?), f64::from(r.byte()?), f64::from(r.byte()?), f64::from(r.byte()?));
|
||||
if !exec {
|
||||
return Ok(());
|
||||
}
|
||||
let (pos, axes, down) = (self.pos, self.axes, self.down);
|
||||
let cell = self.cell();
|
||||
self.flush();
|
||||
self.pos = pos + Vec2::new(x * axes.x, y * axes.y) * self.scale;
|
||||
self.axes = Vec2::new(axes.x * w / cell.x, axes.y * h / cell.y);
|
||||
let res = self.run(n, depth + 1);
|
||||
self.flush();
|
||||
self.axes = axes;
|
||||
self.pos = pos;
|
||||
self.down = down;
|
||||
res?;
|
||||
}
|
||||
ShxKind::Shapes => {
|
||||
let n = u16::from(r.byte()?);
|
||||
if exec {
|
||||
self.run(n, depth + 1)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub(super) fn outline(font: &ShxFont, number: u16, vertical: bool) -> Result<ShxGlyph, craft_shx::program::Broken> {
|
||||
let glyph = craft_shx::program::outline(font, number, vertical)?;
|
||||
Ok(ShxGlyph {
|
||||
strokes: glyph.strokes.into_iter().map(|stroke| stroke.into_iter().map(|p| Vec2::new(p.x, p.y)).collect()).collect(),
|
||||
advance: Vec2::new(glyph.advance.x, glyph.advance.y),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -3,50 +3,14 @@
|
||||
//! never embedded; callers draw their text as outlines instead. Fonts without TrueType outlines
|
||||
//! (CFF-flavoured OpenType) aren't embedded either.
|
||||
|
||||
use skrifa::FontRef;
|
||||
use skrifa::raw::types::Tag;
|
||||
|
||||
use crate::ttf::Face;
|
||||
|
||||
/// Whether a face may be embedded as a subset.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Embedding {
|
||||
/// Installable, editable or preview & print embedding (or no OS/2 table).
|
||||
Allowed,
|
||||
/// `fsType` restricted licence: no embedding.
|
||||
Restricted,
|
||||
/// `fsType` bit 8: the font may only be embedded whole.
|
||||
NoSubsetting,
|
||||
/// `fsType` bit 9: only bitmaps may be embedded.
|
||||
BitmapOnly,
|
||||
/// No TrueType outlines (`glyf` / `loca`), or the font doesn't parse.
|
||||
NotTrueType,
|
||||
}
|
||||
|
||||
fn table<'a>(f: &FontRef<'a>, t: [u8; 4]) -> Option<&'a [u8]> {
|
||||
f.table_data(Tag::new(&t)).map(|d| d.as_bytes())
|
||||
}
|
||||
|
||||
fn u16_at(b: &[u8], i: usize) -> Option<u16> {
|
||||
Some(u16::from_be_bytes([*b.get(i)?, *b.get(i + 1)?]))
|
||||
}
|
||||
pub use craft_font_catalog::SubsetEmbedding as Embedding;
|
||||
|
||||
/// The embedding permission of a face.
|
||||
pub fn embedding(face: &Face) -> Embedding {
|
||||
let Ok(f) = FontRef::from_index(&face.bytes, face.index) else { return Embedding::NotTrueType };
|
||||
if table(&f, *b"glyf").is_none() || table(&f, *b"loca").is_none() || table(&f, *b"head").is_none() {
|
||||
return Embedding::NotTrueType;
|
||||
}
|
||||
let Some(fs_type) = table(&f, *b"OS/2").and_then(|o| u16_at(o, 8)) else { return Embedding::Allowed };
|
||||
if fs_type & 0x0200 != 0 {
|
||||
Embedding::BitmapOnly
|
||||
} else if fs_type & 0x000F == 0x0002 {
|
||||
Embedding::Restricted
|
||||
} else if fs_type & 0x0100 != 0 {
|
||||
Embedding::NoSubsetting
|
||||
} else {
|
||||
Embedding::Allowed
|
||||
}
|
||||
craft_font_catalog::subset_embedding(&face.bytes, face.index)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -14,17 +14,17 @@ cadcraft-color = { workspace = true }
|
||||
cadcraft-doc = { workspace = true }
|
||||
craft-dxf = { workspace = true }
|
||||
craft-dwg = { workspace = true }
|
||||
craft-svg = { workspace = true }
|
||||
craft-image-codecs = { workspace = true }
|
||||
cadcraft-render = { workspace = true }
|
||||
cadcraft-fonts = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
miniz_oxide = "0.9"
|
||||
craft-pdf = { workspace = true, features = ["write"] }
|
||||
quick-xml = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
miniz_oxide = "0.9"
|
||||
tiff = "0.11"
|
||||
image = { workspace = true }
|
||||
tiny-skia = { workspace = true }
|
||||
|
||||
@@ -455,6 +455,10 @@ pub(crate) fn read(secs: &[Section], d: &mut Drawing) {
|
||||
}
|
||||
if !f.is_empty() {
|
||||
f.version = file_version(secs);
|
||||
}
|
||||
// The file's handles of the objects CADCraft writes itself (AutoLISP's `handent`).
|
||||
f.handles = ids.iter().filter(|(h, _)| !ents.contains_key(*h)).filter_map(|(h, k)| Some((handle(h)?, k.clone()))).take(MAX_OBJECTS).collect();
|
||||
if !f.is_empty() || !f.handles.is_empty() {
|
||||
d.foreign = Arc::new(f);
|
||||
}
|
||||
}
|
||||
@@ -771,6 +775,33 @@ fn written_records(tags: &[Tag]) -> Vec<Rec> {
|
||||
out
|
||||
}
|
||||
|
||||
/// A non-graphic record as written: its type, its groups after the type (its handle in group 5)
|
||||
/// and its role when it has one.
|
||||
pub type ObjectRecord = (String, Vec<Tag>, Option<ForeignKey>);
|
||||
|
||||
/// The drawing's non-graphic records as a DXF file of it holds them: the tables and their
|
||||
/// records, the BLOCK records and the objects, in file order, each with its role (a table record,
|
||||
/// a block, the named object dictionary or one of its entries) when it has one. Their handles are
|
||||
/// the written file's: the same for the same drawing. AutoLISP's dictionary and table functions
|
||||
/// (`namedobjdict`, `dictsearch`, `tblobjname`, `entget` of a non-graphic object) read it.
|
||||
pub fn object_records(d: &Drawing) -> Vec<ObjectRecord> {
|
||||
let tags = crate::dxf_write::tags(d, craft_dxf::Version::R2018);
|
||||
let recs = written_records(&tags);
|
||||
let body = |r: &Rec| tags.get(r.start + 1..r.end).unwrap_or(&[]);
|
||||
let by_sec = |name: &str| -> Recs {
|
||||
recs.iter().filter(|r| r.sec == name && r.kind != "SECTION" && r.kind != "ENDSEC").map(|r| (r.kind.clone(), r.start, body(r))).collect()
|
||||
};
|
||||
let (tables, blocks, objects) = (by_sec("TABLES"), by_sec("BLOCKS"), by_sec("OBJECTS"));
|
||||
let ids = identities(&tables, &blocks, &objects);
|
||||
let tables = tables.iter().filter(|(k, _, _)| k != "ENDTAB");
|
||||
let blocks = blocks.iter().filter(|(k, _, _)| k == "BLOCK");
|
||||
tables
|
||||
.chain(blocks)
|
||||
.chain(objects.iter())
|
||||
.map(|(kind, _, t)| (kind.clone(), t.to_vec(), head(t).handle.and_then(|h| ids.get(&h).cloned())))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Remaps the kept data's handles onto a written file.
|
||||
struct Map<'a> {
|
||||
f: &'a Foreign,
|
||||
|
||||
@@ -32,6 +32,7 @@ use std::path::{Path, PathBuf};
|
||||
|
||||
pub use cadcraft_doc::Format;
|
||||
pub use craft_dxf::Version;
|
||||
pub use dxf_raw::{ObjectRecord, object_records};
|
||||
pub use dxf_read::entity_from_groups;
|
||||
pub use dxf_write::entity_groups;
|
||||
pub use pdf::{PdfOptions, pdf, plot};
|
||||
|
||||
+2
-12
@@ -4,7 +4,7 @@
|
||||
|
||||
use crate::{IoError, Result};
|
||||
use cadcraft_doc::Raster;
|
||||
use craft_image_codecs::{ChannelLayout, DecodeOptions, DecodeWarning, EncodeOptions, Format, Image, Limits, PngRows, SampleType};
|
||||
use craft_image_codecs::{ChannelLayout, DecodeOptions, DecodeWarning, Format, Limits, SampleType};
|
||||
|
||||
/// Largest image file read (bytes).
|
||||
pub const MAX_IMAGE_BYTES: usize = 256 << 20;
|
||||
@@ -61,17 +61,7 @@ pub fn decode(bytes: &[u8]) -> Result<Raster> {
|
||||
|
||||
/// `raster` as a PNG file, encoded in rows to avoid a full extra image copy.
|
||||
pub fn encode_png(raster: &Raster) -> Result<Vec<u8>> {
|
||||
let stride = usize::try_from(raster.width()).ok().and_then(|w| w.checked_mul(4)).filter(|s| *s > 0).ok_or_else(|| bad("invalid image width"))?;
|
||||
let mut chunks = raster.rgba().chunks_exact(stride);
|
||||
let first = chunks.next().ok_or_else(|| bad("the image is empty"))?;
|
||||
let row = |data: &[u8]| Image::from_u8(raster.width(), 1, ChannelLayout::Rgba, data.to_vec()).map_err(bad);
|
||||
let first = row(first)?;
|
||||
let mut out = Vec::new();
|
||||
let mut writer = PngRows::new(&mut out, &first, raster.height(), &EncodeOptions::default()).map_err(bad)?;
|
||||
writer.push(&first).map_err(bad)?;
|
||||
for chunk in chunks {
|
||||
writer.push(&row(chunk)?).map_err(bad)?;
|
||||
}
|
||||
writer.finish().map_err(bad)?;
|
||||
cadcraft_render::raster::write_rgba_png(&mut out, raster.width(), raster.height(), raster.rgba()).ok_or_else(|| bad("PNG encoding failed"))?;
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
+48
-43
@@ -1,7 +1,5 @@
|
||||
//! SVG export of a space (vector, for the web and documents).
|
||||
|
||||
use std::fmt::Write as _;
|
||||
|
||||
use cadcraft_color::Rgb;
|
||||
use cadcraft_doc::{Drawing, Space};
|
||||
use cadcraft_geom::Bounds2;
|
||||
@@ -25,12 +23,9 @@ pub fn export_window_with(d: &Drawing, space: &Space, window: Option<Bounds2>, t
|
||||
export_list(&list, window)
|
||||
}
|
||||
|
||||
/// ` opacity="…"` for a transparent primitive (none for an opaque one or a wipeout's mask).
|
||||
fn opacity(p: &cadcraft_render::DPrim) -> String {
|
||||
if p.kind == Kind::Mask || p.transparency == 0 {
|
||||
return String::new();
|
||||
}
|
||||
format!(r#" opacity="{:.2}""#, f64::from(p.alpha()) / 255.0)
|
||||
/// Opacity for a transparent primitive (none for an opaque one or a wipeout's mask).
|
||||
fn opacity(p: &cadcraft_render::DPrim) -> Option<String> {
|
||||
(p.kind != Kind::Mask && p.transparency != 0).then(|| format!("{:.2}", f64::from(p.alpha()) / 255.0))
|
||||
}
|
||||
|
||||
/// Write a display list (as [`export_window`] does for a space's own).
|
||||
@@ -59,13 +54,15 @@ pub fn export_list(list: &cadcraft_render::DisplayList, window: Option<Bounds2>)
|
||||
let stroke = vw.max(vh) / 1500.0;
|
||||
// Decimals: at least 6, more when the stroke would otherwise lose its leading digits.
|
||||
let dp = (3.0 - stroke.log10().floor()).clamp(6.0, 15.0) as usize;
|
||||
let mut s = String::new();
|
||||
let _ = write!(
|
||||
s,
|
||||
r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {vw:.dp$} {vh:.dp$}" width="{:.0}" height="{:.0}"><rect width="100%" height="100%" fill="white"/>"#,
|
||||
1600.0,
|
||||
1600.0 * vh / vw
|
||||
);
|
||||
use craft_svg::write::{SvgWriter, num};
|
||||
let mut writer = SvgWriter::fragment();
|
||||
writer
|
||||
.root()
|
||||
.attr("viewBox", format!("0 0 {} {}", num(vw, dp), num(vh, dp)))
|
||||
.attr("width", format!("{:.0}", 1600.0))
|
||||
.attr("height", format!("{:.0}", 1600.0 * vh / vw))
|
||||
.open();
|
||||
writer.tag("rect").attr("width", "100%").attr("height", "100%").attr("fill", "white").empty();
|
||||
let white = Rgb(255, 255, 255);
|
||||
let tx = |x: f64| x - x0;
|
||||
let ty = |y: f64| y1 - y;
|
||||
@@ -75,52 +72,60 @@ pub fn export_list(list: &cadcraft_render::DisplayList, window: Option<Bounds2>)
|
||||
let pts = list.points(p);
|
||||
match p.kind {
|
||||
Kind::Polyline => {
|
||||
let _ = write!(
|
||||
s,
|
||||
r#"<polyline fill="none" stroke="{c}"{op} stroke-width="{stroke:.dp$}" stroke-linecap="round" stroke-linejoin="round" points=""#
|
||||
);
|
||||
for q in pts {
|
||||
let _ = write!(s, "{:.dp$},{:.dp$} ", tx(q.x), ty(q.y));
|
||||
let points = craft_svg::drawing_write::points(pts.iter().map(|q| [tx(q.x), ty(q.y)]), dp);
|
||||
let mut tag = writer.tag("polyline").attr("fill", "none").attr("stroke", &c);
|
||||
if let Some(op) = &op {
|
||||
tag = tag.attr("opacity", op);
|
||||
}
|
||||
s.push_str(r#""/>"#);
|
||||
tag.attr("stroke-width", num(stroke, dp))
|
||||
.attr("stroke-linecap", "round")
|
||||
.attr("stroke-linejoin", "round")
|
||||
.attr("points", points)
|
||||
.empty();
|
||||
}
|
||||
Kind::Tris | Kind::Mask => {
|
||||
// A wipeout's mask hides what lies under it with the white background.
|
||||
let c = if p.kind == Kind::Mask { white.hex() } else { c };
|
||||
let _ = write!(s, r#"<path fill="{c}"{op} d=""#);
|
||||
for t in pts.chunks(3) {
|
||||
if let [a, b2, cc] = t {
|
||||
let _ =
|
||||
write!(s, "M{:.dp$} {:.dp$}L{:.dp$} {:.dp$}L{:.dp$} {:.dp$}Z", tx(a.x), ty(a.y), tx(b2.x), ty(b2.y), tx(cc.x), ty(cc.y));
|
||||
}
|
||||
let triangles = pts
|
||||
.chunks(3)
|
||||
.filter_map(|t| if let [a, b, c] = t { Some([[tx(a.x), ty(a.y)], [tx(b.x), ty(b.y)], [tx(c.x), ty(c.y)]]) } else { None });
|
||||
let path = craft_svg::drawing_write::triangles(triangles, dp);
|
||||
let mut tag = writer.tag("path").attr("fill", &c);
|
||||
if let Some(op) = &op {
|
||||
tag = tag.attr("opacity", op);
|
||||
}
|
||||
s.push_str(r#""/>"#);
|
||||
tag.attr("d", path).empty();
|
||||
}
|
||||
// Raster images are not written to SVG yet: their frame is.
|
||||
Kind::Image { .. } => {}
|
||||
Kind::Point => {
|
||||
if let Some(q) = pts.first() {
|
||||
let _ = write!(s, r#"<circle cx="{:.dp$}" cy="{:.dp$}" r="{:.dp$}" fill="{c}"{op}/>"#, tx(q.x), ty(q.y), stroke);
|
||||
let mut tag =
|
||||
writer.tag("circle").attr("cx", num(tx(q.x), dp)).attr("cy", num(ty(q.y), dp)).attr("r", num(stroke, dp)).attr("fill", &c);
|
||||
if let Some(op) = &op {
|
||||
tag = tag.attr("opacity", op);
|
||||
}
|
||||
tag.empty();
|
||||
}
|
||||
}
|
||||
Kind::Infinite { ray } => {
|
||||
if let (Some(bp), Some(dir)) = (pts.first(), pts.get(1)) {
|
||||
// A window can lie far from the base point: reach past it.
|
||||
let far = (vw + vh) * 2.0 + if window.is_some() { bp.dist(b.center()) } else { 0.0 };
|
||||
let a = if ray { *bp } else { *bp - *dir * far };
|
||||
let e = *bp + *dir * far;
|
||||
let _ = write!(
|
||||
s,
|
||||
r#"<line x1="{:.dp$}" y1="{:.dp$}" x2="{:.dp$}" y2="{:.dp$}" stroke="{c}"{op} stroke-width="{stroke:.dp$}"/>"#,
|
||||
tx(a.x),
|
||||
ty(a.y),
|
||||
tx(e.x),
|
||||
ty(e.y)
|
||||
);
|
||||
let mut tag = writer
|
||||
.tag("line")
|
||||
.attr("x1", num(tx(a.x), dp))
|
||||
.attr("y1", num(ty(a.y), dp))
|
||||
.attr("x2", num(tx(e.x), dp))
|
||||
.attr("y2", num(ty(e.y), dp))
|
||||
.attr("stroke", &c);
|
||||
if let Some(op) = &op {
|
||||
tag = tag.attr("opacity", op);
|
||||
}
|
||||
tag.attr("stroke-width", num(stroke, dp)).empty();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
s.push_str("</svg>");
|
||||
s
|
||||
writer.close();
|
||||
writer.finish()
|
||||
}
|
||||
|
||||
+101
-731
@@ -13,14 +13,11 @@
|
||||
//! line segments instead of losing the shape). What the drawing shows of those (all but fills,
|
||||
//! gradients and patterns) is named in a read note, so it is never left out silently.
|
||||
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{Circle, Common, Drawing, Ellipse, EntityKind, Layer, Line, LwPolyline, Space};
|
||||
use cadcraft_geom::{Mat3, PolyVertex, Spline, Vec2, Vec3};
|
||||
use quick_xml::Reader;
|
||||
use quick_xml::XmlVersion;
|
||||
use quick_xml::events::{BytesStart, Event};
|
||||
|
||||
use crate::{IoError, Result};
|
||||
|
||||
@@ -28,47 +25,20 @@ use crate::{IoError, Result};
|
||||
const MAX_DECOMPRESSED: usize = 64 << 20;
|
||||
/// Shape elements per file (rect, circle, path, …; each counted once).
|
||||
const MAX_ELEMENTS: usize = 500_000;
|
||||
/// Path data segments per `d` attribute.
|
||||
const MAX_PATH_SEGMENTS: usize = 100_000;
|
||||
/// Vertices in one polyline, and control points in one spline.
|
||||
const MAX_CURVE_POINTS: usize = 100_001;
|
||||
/// Layers created from Inkscape layer groups.
|
||||
const MAX_LAYERS: usize = 256;
|
||||
/// Nested `<g>`/`<svg>` transforms.
|
||||
const MAX_TRANSFORM_DEPTH: usize = 64;
|
||||
/// Flattened chords per elliptical arc under a non-uniform transform.
|
||||
const MAX_ARC_CHORDS: usize = 10_000;
|
||||
/// Generated vertices retained across the whole document (all paths and shapes), so repeated
|
||||
/// arc/curve flattening cannot amplify a compact input into unbounded geometry.
|
||||
const MAX_TOTAL_VERTS: usize = 8_000_000;
|
||||
|
||||
/// Elements whose whole subtree is skipped (paint servers, text, raster images, metadata).
|
||||
const SKIP: &[&[u8]] = &[
|
||||
b"defs",
|
||||
b"symbol",
|
||||
b"clipPath",
|
||||
b"mask",
|
||||
b"pattern",
|
||||
b"marker",
|
||||
b"linearGradient",
|
||||
b"radialGradient",
|
||||
b"filter",
|
||||
b"style",
|
||||
b"text",
|
||||
b"image",
|
||||
b"title",
|
||||
b"desc",
|
||||
b"metadata",
|
||||
];
|
||||
|
||||
/// Elements that hold children and push a transform stack frame.
|
||||
const CONTAINERS: &[&[u8]] = &[b"g", b"svg", b"a", b"switch"];
|
||||
|
||||
/// Read an SVG document, or a gzip-compressed one (`.svgz`, Inkscape's "Compressed SVG").
|
||||
pub fn read(bytes: &[u8]) -> Result<Drawing> {
|
||||
let unpacked;
|
||||
let plain: &[u8] = if bytes.starts_with(&[0x1f, 0x8b]) {
|
||||
unpacked = gunzip(bytes)?;
|
||||
unpacked =
|
||||
craft_svg::svgz::inflate(bytes, MAX_DECOMPRESSED).map_err(|_| IoError::Format("this SVGZ file's gzip stream is damaged".into()))?;
|
||||
&unpacked
|
||||
} else {
|
||||
bytes
|
||||
@@ -79,39 +49,6 @@ pub fn read(bytes: &[u8]) -> Result<Drawing> {
|
||||
Ok(parser.drawing)
|
||||
}
|
||||
|
||||
/// Decompress a gzip member (RFC 1952) with a hard output cap.
|
||||
fn gunzip(bytes: &[u8]) -> Result<Vec<u8>> {
|
||||
let damaged = || IoError::Format("this SVGZ file's gzip stream is damaged".into());
|
||||
if bytes.get(2) != Some(&8) {
|
||||
return Err(damaged());
|
||||
}
|
||||
let flg = bytes.get(3).copied().unwrap_or(0);
|
||||
let mut pos = 10usize;
|
||||
if flg & 0x04 != 0 {
|
||||
// FEXTRA
|
||||
let extra = bytes.get(pos..pos + 2).ok_or_else(damaged)?;
|
||||
pos += 2 + usize::from(u16::from_le_bytes([extra[0], extra[1]]));
|
||||
}
|
||||
if flg & 0x08 != 0 {
|
||||
pos = skip_cstring(bytes, pos).ok_or_else(damaged)?; // FNAME
|
||||
}
|
||||
if flg & 0x10 != 0 {
|
||||
pos = skip_cstring(bytes, pos).ok_or_else(damaged)?; // FCOMMENT
|
||||
}
|
||||
if flg & 0x02 != 0 {
|
||||
pos = pos.saturating_add(2); // FHCRC
|
||||
}
|
||||
let end = bytes.len().checked_sub(8).filter(|e| *e >= pos).ok_or_else(damaged)?;
|
||||
miniz_oxide::inflate::decompress_to_vec_with_limit(&bytes[pos..end], MAX_DECOMPRESSED).map_err(|_| damaged())
|
||||
}
|
||||
|
||||
/// Skip a NUL-terminated field; `None` when the terminator is missing.
|
||||
fn skip_cstring(bytes: &[u8], from: usize) -> Option<usize> {
|
||||
let rest = bytes.get(from..)?;
|
||||
let nul = rest.iter().position(|b| *b == 0)?;
|
||||
Some(from + nul + 1)
|
||||
}
|
||||
|
||||
fn parse_err<E: std::fmt::Display>(e: E) -> IoError {
|
||||
IoError::Format(format!("SVG: {e}"))
|
||||
}
|
||||
@@ -126,15 +63,11 @@ struct Parser {
|
||||
stack: Vec<Mat3>,
|
||||
/// Current Inkscape layer name.
|
||||
layer: String,
|
||||
layers: HashSet<String>,
|
||||
layer_color: u8,
|
||||
elements: usize,
|
||||
/// Generated vertices still allowed across the whole document. Arc/curve flattening can turn
|
||||
/// a compact path into many samples, and each flushed run is retained, so without a shared
|
||||
/// budget repeated arcs amplify a small input into gigabytes of geometry (CWE-400).
|
||||
verts_left: usize,
|
||||
/// > 0 while inside a skipped subtree; counts the starts seen there.
|
||||
skip: usize,
|
||||
/// What was left out, by kind ([`LeftOut`]).
|
||||
left_out: BTreeMap<LeftOut, usize>,
|
||||
}
|
||||
@@ -150,15 +83,6 @@ enum LeftOut {
|
||||
}
|
||||
|
||||
impl LeftOut {
|
||||
/// The kind of a skipped element ([`SKIP`]) that the drawing shows.
|
||||
fn of(name: &[u8]) -> Option<Self> {
|
||||
match name {
|
||||
b"text" => Some(Self::Text),
|
||||
b"image" => Some(Self::Image),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn describe(self, n: usize) -> String {
|
||||
let (one, many) = match self {
|
||||
Self::Text => ("text", "texts"),
|
||||
@@ -178,19 +102,12 @@ impl Parser {
|
||||
drawing: Drawing::new_metric(),
|
||||
stack: vec![Mat3::IDENTITY],
|
||||
layer: "0".into(),
|
||||
layers: HashSet::from(["0".to_string()]),
|
||||
layer_color: 1,
|
||||
elements: 0,
|
||||
verts_left: MAX_TOTAL_VERTS,
|
||||
skip: 0,
|
||||
left_out: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn left_out(&mut self, kind: LeftOut) {
|
||||
*self.left_out.entry(kind).or_default() += 1;
|
||||
}
|
||||
|
||||
/// The read note on what was left out, if anything was.
|
||||
fn note(&self) -> Option<String> {
|
||||
if self.left_out.is_empty() {
|
||||
@@ -201,140 +118,85 @@ impl Parser {
|
||||
}
|
||||
|
||||
fn parse(&mut self, text: &str) -> Result<()> {
|
||||
let mut reader = Reader::from_str(text);
|
||||
reader.config_mut().trim_text(true);
|
||||
loop {
|
||||
match reader.read_event().map_err(parse_err)? {
|
||||
Event::Start(e) => {
|
||||
let name = e.name();
|
||||
self.on_start(name.into_inner().as_bytes(), &e)?;
|
||||
use craft_svg::neutral_document::{self, Event, Skipped};
|
||||
let mut failure = None;
|
||||
let mut layer_color = 1u8;
|
||||
let result = neutral_document::visit(text, &mut |event| {
|
||||
let r = match event {
|
||||
Event::Layer(name) => {
|
||||
let color = Color::Index(layer_color);
|
||||
layer_color = if layer_color >= 7 { 1 } else { layer_color + 1 };
|
||||
self.drawing.layers.push(Layer { name, color, ..Layer::default() });
|
||||
Ok(())
|
||||
}
|
||||
Event::Empty(e) => {
|
||||
let name = e.name();
|
||||
self.on_element(name.into_inner().as_bytes(), &e)?;
|
||||
}
|
||||
Event::End(e) => {
|
||||
let name = e.name();
|
||||
self.on_end(name.into_inner().as_bytes());
|
||||
}
|
||||
Event::Eof => break,
|
||||
_ => {}
|
||||
}
|
||||
Event::Shape(shape) => self.map_shape(shape),
|
||||
};
|
||||
r.map_err(|e| {
|
||||
failure = Some(e);
|
||||
neutral_document::Error("CAD geometry mapping failed".into())
|
||||
})
|
||||
});
|
||||
if let Some(e) = failure {
|
||||
return Err(e);
|
||||
}
|
||||
let doc = result.map_err(|e| IoError::Format(e.to_string()))?;
|
||||
for (kind, count) in doc.skipped {
|
||||
let kind = match kind {
|
||||
Skipped::Text => LeftOut::Text,
|
||||
Skipped::Image => LeftOut::Image,
|
||||
Skipped::Use => LeftOut::Use,
|
||||
Skipped::Style => LeftOut::Style,
|
||||
Skipped::RoundedCorners => LeftOut::RoundedCorners,
|
||||
};
|
||||
self.left_out.insert(kind, count);
|
||||
}
|
||||
self.drawing.read_notes.extend(self.note());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A start tag: open a transform frame, descend into a skipped subtree, or treat a
|
||||
/// shape written as start+end the same as a self-closed one.
|
||||
fn on_start(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
|
||||
// A style sheet applies wherever it is (Inkscape keeps it in `<defs>`).
|
||||
if name == b"style" {
|
||||
self.left_out(LeftOut::Style);
|
||||
fn map_shape(&mut self, shape: craft_svg::neutral_document::Shape) -> Result<()> {
|
||||
use craft_svg::neutral_document::Primitive;
|
||||
let point = |p: craft_svg::path_data::Point| Vec2::new(p.x, p.y);
|
||||
let [a, b, c, d, e, f] = shape.transform;
|
||||
if let Some(current) = self.stack.first_mut() {
|
||||
*current = Mat3 { a, b, c, d, e, f };
|
||||
}
|
||||
if self.skip > 0 {
|
||||
self.skip += 1;
|
||||
return Ok(());
|
||||
}
|
||||
if hidden(e) {
|
||||
self.skip = 1;
|
||||
return Ok(());
|
||||
}
|
||||
if SKIP.contains(&name) {
|
||||
if let Some(kind) = LeftOut::of(name) {
|
||||
self.left_out(kind);
|
||||
self.layer = shape.layer;
|
||||
match shape.primitive {
|
||||
Primitive::Rect { x, y, width, height } => {
|
||||
let pts = [Vec2::new(x, y), Vec2::new(x + width, y), Vec2::new(x + width, y + height), Vec2::new(x, y + height)];
|
||||
self.add_polyline(&pts.map(|p| self.map(p)), true)?;
|
||||
}
|
||||
self.skip = 1;
|
||||
return Ok(());
|
||||
}
|
||||
if CONTAINERS.contains(&name) { self.enter_group(name, e) } else { self.on_element(name, e) }
|
||||
}
|
||||
|
||||
fn on_element(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
|
||||
if self.skip > 0 {
|
||||
return Ok(());
|
||||
}
|
||||
if SKIP.contains(&name) || hidden(e) {
|
||||
if !hidden(e)
|
||||
&& let Some(kind) = LeftOut::of(name)
|
||||
{
|
||||
self.left_out(kind);
|
||||
Primitive::Circle { center, radius } => self.add_rounded(point(center), radius, radius)?,
|
||||
Primitive::Ellipse { center, rx, ry } => self.add_rounded(point(center), rx, ry)?,
|
||||
Primitive::Line { a, b } => self.add(EntityKind::Line(Line { a: v3(self.map(point(a))), b: v3(self.map(point(b))) }))?,
|
||||
Primitive::Polyline { points, closed } => {
|
||||
self.add_polyline(&points.into_iter().map(|p| self.map(point(p))).collect::<Vec<_>>(), closed)?
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
// A shape's own `transform` (SVG 1.1 §7.5) maps it after its groups', for this element only.
|
||||
let local = attr(e, b"transform").as_deref().and_then(parse_transform);
|
||||
if let Some(local) = local {
|
||||
self.stack.push(self.cur().then_before(local));
|
||||
}
|
||||
let read = self.shape(name, e);
|
||||
if local.is_some() {
|
||||
self.stack.pop();
|
||||
}
|
||||
read
|
||||
}
|
||||
|
||||
fn shape(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
|
||||
match name {
|
||||
b"use" => {
|
||||
self.left_out(LeftOut::Use);
|
||||
Ok(())
|
||||
}
|
||||
b"rect" => self.rect(e),
|
||||
b"circle" => self.circle(e),
|
||||
b"ellipse" => self.ellipse(e),
|
||||
b"line" => self.line(e),
|
||||
b"polyline" => self.poly_points(e, false),
|
||||
b"polygon" => self.poly_points(e, true),
|
||||
b"path" => self.path(e),
|
||||
_ => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
fn on_end(&mut self, name: &[u8]) {
|
||||
if self.skip > 0 {
|
||||
self.skip -= 1;
|
||||
} else if CONTAINERS.contains(&name) && self.stack.len() > 1 {
|
||||
self.stack.pop();
|
||||
}
|
||||
}
|
||||
|
||||
fn enter_group(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
|
||||
if name == b"svg" && self.stack.len() == 1 {
|
||||
self.stack[0] = viewport(e)?;
|
||||
}
|
||||
if name == b"g" && attr(e, b"inkscape:groupmode").as_deref() == Some("layer") {
|
||||
let raw = attr(e, b"inkscape:label").or_else(|| attr(e, b"id"));
|
||||
if let Some(raw) = raw {
|
||||
self.set_layer(&raw);
|
||||
Primitive::Path(paths) => {
|
||||
for path in paths {
|
||||
let path = Subpath {
|
||||
start: point(path.start),
|
||||
closed: path.closed,
|
||||
segs: path
|
||||
.segs
|
||||
.into_iter()
|
||||
.map(|seg| match seg {
|
||||
craft_svg::path_data::Segment::Line(p) => Seg::Line(point(p)),
|
||||
craft_svg::path_data::Segment::Cubic(a, b, c) => Seg::Cubic(point(a), point(b), point(c)),
|
||||
craft_svg::path_data::Segment::Arc { rx, ry, rot, large, sweep, end } => {
|
||||
Seg::Arc { rx, ry, rot, large, sweep, end: point(end) }
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
};
|
||||
self.emit_subpath(&path)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
if self.stack.len() >= MAX_TRANSFORM_DEPTH {
|
||||
return Err(IoError::Format(format!("SVG: more than {MAX_TRANSFORM_DEPTH} nested groups")));
|
||||
}
|
||||
let current = *self.stack.last().unwrap_or(&Mat3::IDENTITY);
|
||||
let next = match attr(e, b"transform").as_deref().and_then(parse_transform) {
|
||||
Some(local) => current.then_before(local),
|
||||
None => current,
|
||||
};
|
||||
self.stack.push(next);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_layer(&mut self, raw: &str) {
|
||||
let name = sanitize_layer(raw);
|
||||
if !self.layers.contains(&name) {
|
||||
if self.layers.len() >= MAX_LAYERS {
|
||||
return;
|
||||
}
|
||||
let color = Color::Index(self.layer_color);
|
||||
self.layer_color = if self.layer_color >= 7 { 1 } else { self.layer_color + 1 };
|
||||
self.drawing.layers.push(Layer { name: name.clone(), color, ..Layer::default() });
|
||||
self.layers.insert(name.clone());
|
||||
}
|
||||
self.layer = name;
|
||||
}
|
||||
|
||||
/// The composed mapping for the current nesting: SVG user units → drawing units (mm).
|
||||
fn cur(&self) -> Mat3 {
|
||||
*self.stack.last().unwrap_or(&Mat3::IDENTITY)
|
||||
@@ -366,40 +228,6 @@ impl Parser {
|
||||
self.drawing.add(&Space::Model, common, kind).map(|_| ()).map_err(parse_err)
|
||||
}
|
||||
|
||||
// --- shapes -------------------------------------------------------------
|
||||
|
||||
fn rect(&mut self, e: &BytesStart) -> Result<()> {
|
||||
let x = num(e, b"x", 0.0);
|
||||
let y = num(e, b"y", 0.0);
|
||||
let w = num(e, b"width", 0.0);
|
||||
let h = num(e, b"height", 0.0);
|
||||
if w <= 0.0 || h <= 0.0 {
|
||||
return Ok(());
|
||||
}
|
||||
if num(e, b"rx", 0.0) > 0.0 || num(e, b"ry", 0.0) > 0.0 {
|
||||
self.left_out(LeftOut::RoundedCorners);
|
||||
}
|
||||
let pts = [Vec2::new(x, y), Vec2::new(x + w, y), Vec2::new(x + w, y + h), Vec2::new(x, y + h)];
|
||||
self.add_polyline(&pts.map(|p| self.map(p)), true)
|
||||
}
|
||||
|
||||
fn circle(&mut self, e: &BytesStart) -> Result<()> {
|
||||
let r = num(e, b"r", 0.0);
|
||||
if r <= 0.0 {
|
||||
return Ok(());
|
||||
}
|
||||
self.add_rounded(Vec2::new(num(e, b"cx", 0.0), num(e, b"cy", 0.0)), r, r)
|
||||
}
|
||||
|
||||
fn ellipse(&mut self, e: &BytesStart) -> Result<()> {
|
||||
let rx = num(e, b"rx", 0.0);
|
||||
let ry = num(e, b"ry", 0.0);
|
||||
if rx <= 0.0 || ry <= 0.0 {
|
||||
return Ok(());
|
||||
}
|
||||
self.add_rounded(Vec2::new(num(e, b"cx", 0.0), num(e, b"cy", 0.0)), rx, ry)
|
||||
}
|
||||
|
||||
/// A circle or ellipse through a transform. A circle stays a `CIRCLE` under rotations,
|
||||
/// uniform scales and reflections; anything else becomes an `ELLIPSE` holding the axes
|
||||
/// of the transformed shape — a linear map sends the unit circle to an ellipse whose
|
||||
@@ -413,9 +241,10 @@ impl Parser {
|
||||
if lbx.is_finite() && lby.is_finite() && (lbx - lby).abs() <= 1e-9 * (lbx + lby) && dot.abs() <= 1e-9 * lbx * lby {
|
||||
return self.add(EntityKind::Circle(Circle { center: v3(center), radius: lbx }));
|
||||
}
|
||||
let xx = bx.x * bx.x + bx.y * bx.y;
|
||||
let yy = by.x * by.x + by.y * by.y;
|
||||
let xy = bx.x * by.x + bx.y * by.y;
|
||||
// `B·Bᵀ` (B = [bx by]) lives in the output plane, so its eigenvectors are the axes.
|
||||
let xx = bx.x * bx.x + by.x * by.x;
|
||||
let yy = bx.y * bx.y + by.y * by.y;
|
||||
let xy = bx.x * bx.y + by.x * by.y;
|
||||
let trace = xx + yy;
|
||||
let disc = (trace * trace - 4.0 * (xx * yy - xy * xy)).max(0.0).sqrt();
|
||||
let l_max = 0.5 * (trace + disc);
|
||||
@@ -439,24 +268,6 @@ impl Parser {
|
||||
self.add(EntityKind::Ellipse(Ellipse { center: v3(center), major: v3(major), ratio, start: 0.0, end: std::f64::consts::TAU }))
|
||||
}
|
||||
|
||||
fn line(&mut self, e: &BytesStart) -> Result<()> {
|
||||
let a = Vec2::new(num(e, b"x1", 0.0), num(e, b"y1", 0.0));
|
||||
let b = Vec2::new(num(e, b"x2", 0.0), num(e, b"y2", 0.0));
|
||||
self.add(EntityKind::Line(Line { a: v3(self.map(a)), b: v3(self.map(b)) }))
|
||||
}
|
||||
|
||||
fn poly_points(&mut self, e: &BytesStart, closed: bool) -> Result<()> {
|
||||
let Some(raw) = attr(e, b"points") else {
|
||||
return Ok(());
|
||||
};
|
||||
let nums: Vec<f64> = Numbers::new(&raw).collect();
|
||||
let mut pts: Vec<Vec2> = nums.as_chunks::<2>().0.iter().map(|[x, y]| self.map(Vec2::new(*x, *y))).collect();
|
||||
if pts.len() > MAX_CURVE_POINTS {
|
||||
pts.truncate(MAX_CURVE_POINTS);
|
||||
}
|
||||
self.add_polyline(&pts, closed)
|
||||
}
|
||||
|
||||
fn add_polyline(&mut self, pts: &[Vec2], closed: bool) -> Result<()> {
|
||||
if pts.len() < 2 {
|
||||
return Ok(());
|
||||
@@ -465,18 +276,6 @@ impl Parser {
|
||||
self.add(EntityKind::LwPolyline(LwPolyline { vertices, closed, const_width: 0.0, elevation: 0.0, plinegen: false }))
|
||||
}
|
||||
|
||||
// --- path data ----------------------------------------------------------
|
||||
|
||||
fn path(&mut self, e: &BytesStart) -> Result<()> {
|
||||
let Some(d) = attr(e, b"d") else {
|
||||
return Ok(());
|
||||
};
|
||||
for sp in parse_path(&d)? {
|
||||
self.emit_subpath(&sp)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Emit one subpath: runs of lines and arcs become an `LWPOLYLINE` (an arc becomes a
|
||||
/// bulge vertex, exactly like DXF's polyline bulge), runs of Bézier curves become a
|
||||
/// `SPLINE`. Under a non-uniform transform a circular arc is no longer circular, so it
|
||||
@@ -581,182 +380,6 @@ impl Parser {
|
||||
}
|
||||
}
|
||||
|
||||
/// The element is not rendered (`display="none"`, or a style that says so).
|
||||
fn hidden(e: &BytesStart) -> bool {
|
||||
if attr(e, b"display").as_deref() == Some("none") {
|
||||
return true;
|
||||
}
|
||||
attr(e, b"style").is_some_and(|s| s.replace(' ', "").contains("display:none"))
|
||||
}
|
||||
|
||||
fn attr(e: &BytesStart, name: &[u8]) -> Option<String> {
|
||||
// Stop at the first malformed attribute: skipping errors resumed the parser's duplicate check,
|
||||
// which rescans the attributes before it each time, so many duplicates were quadratic.
|
||||
for a in e.attributes() {
|
||||
let Ok(a) = a else { return None };
|
||||
if a.key.into_inner().as_bytes() == name {
|
||||
return a.normalized_value(XmlVersion::Explicit1_0).ok().map(|v| v.into_owned());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn num(e: &BytesStart, name: &[u8], fallback: f64) -> f64 {
|
||||
attr(e, name).as_deref().and_then(parse_length_mm).unwrap_or(fallback)
|
||||
}
|
||||
|
||||
/// A bare number, or a number with an absolute CSS/SVG unit: millimetres here, everything
|
||||
/// else (px, the default; pt, pc, in, cm) through the CSS reference pixel (96 per inch).
|
||||
fn parse_length_mm(s: &str) -> Option<f64> {
|
||||
let s = s.trim();
|
||||
let cut = s.find(|c: char| !(c.is_ascii_digit() || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E')).unwrap_or(s.len());
|
||||
let (n, unit) = s.split_at(cut);
|
||||
let value: f64 = n.trim().parse().ok()?;
|
||||
if !value.is_finite() {
|
||||
return None;
|
||||
}
|
||||
match unit.trim() {
|
||||
"" | "px" => Some(value),
|
||||
"mm" => Some(value),
|
||||
"cm" => Some(value * 10.0),
|
||||
"in" => Some(value * 25.4),
|
||||
"pt" => Some(value * 25.4 / 72.0),
|
||||
"pc" => Some(value * 25.4 / 6.0),
|
||||
_ => Some(value * 25.4 / 96.0),
|
||||
}
|
||||
}
|
||||
|
||||
/// The root mapping: `viewBox` and unit-bearing `width`/`height` become millimetres per user
|
||||
/// unit, and the page's Y axis is flipped so the drawing keeps its appearance with Y up.
|
||||
fn viewport(e: &BytesStart) -> Result<Mat3> {
|
||||
let vb = attr(e, b"viewBox").and_then(|raw| {
|
||||
let nums: Vec<f64> = Numbers::new(&raw).collect();
|
||||
match nums.as_slice() {
|
||||
[x, y, w, h] if w.is_finite() && h.is_finite() && *w > 0.0 && *h > 0.0 => Some((*x, *y, *w, *h)),
|
||||
_ => None,
|
||||
}
|
||||
});
|
||||
// A bare or `px` root size is in CSS pixels, not millimetres.
|
||||
let root_mm = |name: &[u8]| {
|
||||
let raw = attr(e, name)?;
|
||||
let mm = parse_length_mm(&raw)?;
|
||||
let unit = raw.trim().trim_start_matches(|c: char| c.is_ascii_digit() || matches!(c, '.' | '-' | '+' | 'e' | 'E')).trim();
|
||||
Some(if matches!(unit, "" | "px") { mm * 25.4 / 96.0 } else { mm })
|
||||
};
|
||||
let w_mm = root_mm(b"width");
|
||||
let h_mm = root_mm(b"height");
|
||||
let unit = match (vb, w_mm, h_mm) {
|
||||
(Some((_, _, vw, _)), Some(w), _) if w > 0.0 => w / vw,
|
||||
(Some((_, _, _, vh)), _, Some(h)) if h > 0.0 => h / vh,
|
||||
(Some(_), _, _) => 25.4 / 96.0,
|
||||
(None, _, _) => 25.4 / 96.0,
|
||||
};
|
||||
let (vx, vy, vh) = match vb {
|
||||
Some((x, y, _, h)) => (x, y, h),
|
||||
None => (0.0, 0.0, 0.0),
|
||||
};
|
||||
Ok(Mat3 { a: unit, b: 0.0, c: 0.0, d: -unit, e: -vx * unit, f: (vy + vh) * unit })
|
||||
}
|
||||
|
||||
/// `transform="…"`: a list of functions, applied left to right.
|
||||
fn parse_transform(s: &str) -> Option<Mat3> {
|
||||
let mut out: Option<Mat3> = None;
|
||||
let mut rest = s.trim();
|
||||
while !rest.is_empty() {
|
||||
let open = rest.find('(')?;
|
||||
let name = rest[..open].trim();
|
||||
let close = rest[open..].find(')')? + open;
|
||||
let args: Vec<f64> = Numbers::new(&rest[open + 1..close]).collect();
|
||||
let m = match (name, args.as_slice()) {
|
||||
("matrix", [a, b, c, d, e, f]) => Mat3 { a: *a, b: *b, c: *c, d: *d, e: *e, f: *f },
|
||||
("translate", [x]) => Mat3::translate(Vec2::new(*x, 0.0)),
|
||||
("translate", [x, y]) => Mat3::translate(Vec2::new(*x, *y)),
|
||||
("scale", [s]) => Mat3::scale(*s, *s),
|
||||
("scale", [sx, sy]) => Mat3::scale(*sx, *sy),
|
||||
("rotate", [a]) => Mat3::rotate(a.to_radians()),
|
||||
("rotate", [a, cx, cy]) => Mat3::rotate_about(Vec2::new(*cx, *cy), a.to_radians()),
|
||||
("skewX", [a]) => Mat3 { a: 1.0, b: 0.0, c: a.to_radians().tan(), d: 1.0, e: 0.0, f: 0.0 },
|
||||
("skewY", [a]) => Mat3 { a: 1.0, b: a.to_radians().tan(), c: 0.0, d: 1.0, e: 0.0, f: 0.0 },
|
||||
_ => return None,
|
||||
};
|
||||
out = Some(match out {
|
||||
Some(prev) => prev.then_before(m),
|
||||
None => m,
|
||||
});
|
||||
rest = rest[close + 1..].trim_start_matches(|c: char| c == ',' || c.is_whitespace());
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn sanitize_layer(raw: &str) -> String {
|
||||
let cleaned: String =
|
||||
raw.trim().chars().map(|c| if c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '$') { c } else { '_' }).take(128).collect();
|
||||
let cleaned = cleaned.trim_matches('_').to_string();
|
||||
if cleaned.is_empty() { "SVG".into() } else { cleaned }
|
||||
}
|
||||
|
||||
/// A scanner over an SVG number list: separators are whitespace and commas, and a sign
|
||||
/// starts a new number, so `10-20` is two numbers and `1e-5 2` is two numbers.
|
||||
struct Numbers<'a> {
|
||||
s: &'a [u8],
|
||||
i: usize,
|
||||
}
|
||||
|
||||
impl<'a> Numbers<'a> {
|
||||
fn new(s: &'a str) -> Self {
|
||||
Numbers { s: s.as_bytes(), i: 0 }
|
||||
}
|
||||
|
||||
fn skip_seps(&mut self) {
|
||||
while matches!(self.s.get(self.i), Some(b' ' | b'\t' | b'\r' | b'\n' | b',')) {
|
||||
self.i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn next_num(&mut self) -> Option<f64> {
|
||||
self.skip_seps();
|
||||
let start = self.i;
|
||||
if matches!(self.s.get(self.i), Some(b'+' | b'-')) {
|
||||
self.i += 1;
|
||||
}
|
||||
let mut digits = 0;
|
||||
let mut dot = false;
|
||||
let mut exp = false;
|
||||
while let Some(c) = self.s.get(self.i) {
|
||||
match c {
|
||||
b'0'..=b'9' => {
|
||||
digits += 1;
|
||||
self.i += 1;
|
||||
}
|
||||
b'.' if !dot && !exp => {
|
||||
dot = true;
|
||||
self.i += 1;
|
||||
}
|
||||
b'e' | b'E' if !exp && digits > 0 => {
|
||||
exp = true;
|
||||
self.i += 1;
|
||||
if matches!(self.s.get(self.i), Some(b'+' | b'-')) {
|
||||
self.i += 1;
|
||||
}
|
||||
}
|
||||
_ => break,
|
||||
}
|
||||
}
|
||||
if digits == 0 {
|
||||
self.i = start;
|
||||
return None;
|
||||
}
|
||||
std::str::from_utf8(&self.s[start..self.i]).ok()?.parse::<f64>().ok().filter(|v| v.is_finite())
|
||||
}
|
||||
}
|
||||
|
||||
impl Iterator for Numbers<'_> {
|
||||
type Item = f64;
|
||||
fn next(&mut self) -> Option<f64> {
|
||||
self.next_num()
|
||||
}
|
||||
}
|
||||
|
||||
/// One `M …` run of a `d` attribute.
|
||||
struct Subpath {
|
||||
start: Vec2,
|
||||
@@ -770,252 +393,9 @@ enum Seg {
|
||||
Arc { rx: f64, ry: f64, rot: f64, large: bool, sweep: bool, end: Vec2 },
|
||||
}
|
||||
|
||||
/// Tokens of a `d` attribute: command letters and numbers, in order.
|
||||
enum Tok {
|
||||
Cmd(u8),
|
||||
Num(f64),
|
||||
}
|
||||
|
||||
struct Tokenizer<'a> {
|
||||
s: &'a [u8],
|
||||
i: usize,
|
||||
/// Start of the most recently returned token.
|
||||
tok_start: usize,
|
||||
}
|
||||
|
||||
impl<'a> Tokenizer<'a> {
|
||||
fn new(s: &'a str) -> Self {
|
||||
Tokenizer { s: s.as_bytes(), i: 0, tok_start: 0 }
|
||||
}
|
||||
|
||||
/// Read an arc flag: a single `0` or `1` character, which needs no separator after it.
|
||||
fn next_flag(&mut self) -> Option<f64> {
|
||||
let mut nums = Numbers { s: self.s, i: self.i };
|
||||
nums.skip_seps();
|
||||
let v = match self.s.get(nums.i)? {
|
||||
b'0' => 0.0,
|
||||
b'1' => 1.0,
|
||||
_ => return None,
|
||||
};
|
||||
self.i = nums.i + 1;
|
||||
Some(v)
|
||||
}
|
||||
|
||||
fn next_tok(&mut self) -> Option<Tok> {
|
||||
let mut nums = Numbers { s: self.s, i: self.i };
|
||||
nums.skip_seps();
|
||||
self.i = nums.i;
|
||||
self.tok_start = self.i;
|
||||
let c = self.s.get(self.i).copied()?;
|
||||
if c.is_ascii_alphabetic() {
|
||||
self.i += 1;
|
||||
return Some(Tok::Cmd(c));
|
||||
}
|
||||
let tok = nums.next_num().map(Tok::Num);
|
||||
self.i = nums.i;
|
||||
tok
|
||||
}
|
||||
}
|
||||
|
||||
/// Split `d` into subpaths, resolving relative commands and the S/T control reflections.
|
||||
fn parse_path(d: &str) -> Result<Vec<Subpath>> {
|
||||
let mut tk = Tokenizer::new(d);
|
||||
let mut lookahead: Option<Tok> = None;
|
||||
let mut cmd = 0u8;
|
||||
let mut cur = Vec2::ZERO;
|
||||
let mut start = Vec2::ZERO;
|
||||
let mut segs: Vec<Seg> = Vec::new();
|
||||
let mut out: Vec<Subpath> = Vec::new();
|
||||
let closed = false;
|
||||
let mut prev_cubic: Option<Vec2> = None;
|
||||
let mut prev_quad: Option<Vec2> = None;
|
||||
let mut segments = 0usize;
|
||||
|
||||
let next_num = |tk: &mut Tokenizer, look: &mut Option<Tok>| -> Result<f64> {
|
||||
match look.take() {
|
||||
Some(Tok::Num(v)) => Ok(v),
|
||||
Some(other @ Tok::Cmd(_)) => {
|
||||
*look = Some(other);
|
||||
Err(IoError::Format("SVG: path command is missing coordinates".into()))
|
||||
}
|
||||
None => match tk.next_tok() {
|
||||
Some(Tok::Num(v)) => Ok(v),
|
||||
Some(other @ Tok::Cmd(_)) => {
|
||||
*look = Some(other);
|
||||
Err(IoError::Format("SVG: path command is missing coordinates".into()))
|
||||
}
|
||||
None => Err(IoError::Format("SVG: path command is missing coordinates".into())),
|
||||
},
|
||||
}
|
||||
};
|
||||
|
||||
while let Some(tok) = lookahead.take().or_else(|| tk.next_tok()) {
|
||||
let rel = match tok {
|
||||
Tok::Cmd(c) => {
|
||||
if c.eq_ignore_ascii_case(&b'z') {
|
||||
if !segs.is_empty() {
|
||||
out.push(Subpath { start, segs, closed: true });
|
||||
segs = Vec::new();
|
||||
}
|
||||
cur = start;
|
||||
cmd = 0;
|
||||
continue;
|
||||
}
|
||||
cmd = c;
|
||||
c.is_ascii_lowercase()
|
||||
}
|
||||
tok @ Tok::Num(_) => {
|
||||
if cmd == 0 {
|
||||
return Err(IoError::Format("SVG: path data does not start with a command".into()));
|
||||
}
|
||||
lookahead = Some(tok);
|
||||
cmd.is_ascii_lowercase()
|
||||
}
|
||||
};
|
||||
let abs = cmd.to_ascii_uppercase();
|
||||
let count = match abs {
|
||||
b'M' | b'L' => 2,
|
||||
b'H' | b'V' | b'T' => 1,
|
||||
b'C' => 6,
|
||||
b'S' | b'Q' => 4,
|
||||
b'A' => 7,
|
||||
_ => return Err(IoError::Format(format!("SVG: unknown path command `{}`", cmd as char))),
|
||||
};
|
||||
let mut args = [0.0f64; 7];
|
||||
for (idx, slot) in args.iter_mut().enumerate().take(count) {
|
||||
if abs == b'A' && (idx == 3 || idx == 4) {
|
||||
// Flags are single characters; re-scan a pending number token from its start.
|
||||
if matches!(lookahead, Some(Tok::Num(_))) {
|
||||
lookahead = None;
|
||||
tk.i = tk.tok_start;
|
||||
}
|
||||
if lookahead.is_none() {
|
||||
*slot = tk.next_flag().ok_or_else(|| IoError::Format("SVG: path command is missing coordinates".into()))?;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
*slot = next_num(&mut tk, &mut lookahead)?;
|
||||
}
|
||||
let point = |x: f64, y: f64| if rel { cur + Vec2::new(x, y) } else { Vec2::new(x, y) };
|
||||
match abs {
|
||||
b'M' => {
|
||||
if !segs.is_empty() {
|
||||
out.push(Subpath { start, segs, closed: false });
|
||||
segs = Vec::new();
|
||||
}
|
||||
cur = point(args[0], args[1]);
|
||||
start = cur;
|
||||
cmd = if rel { b'l' } else { b'L' };
|
||||
prev_cubic = None;
|
||||
prev_quad = None;
|
||||
}
|
||||
b'L' => {
|
||||
cur = point(args[0], args[1]);
|
||||
segs.push(Seg::Line(cur));
|
||||
prev_cubic = None;
|
||||
prev_quad = None;
|
||||
}
|
||||
b'H' => {
|
||||
cur = Vec2::new(if rel { cur.x + args[0] } else { args[0] }, cur.y);
|
||||
segs.push(Seg::Line(cur));
|
||||
prev_cubic = None;
|
||||
prev_quad = None;
|
||||
}
|
||||
b'V' => {
|
||||
cur = Vec2::new(cur.x, if rel { cur.y + args[0] } else { args[0] });
|
||||
segs.push(Seg::Line(cur));
|
||||
prev_cubic = None;
|
||||
prev_quad = None;
|
||||
}
|
||||
b'C' => {
|
||||
let (c1, c2, p) = (point(args[0], args[1]), point(args[2], args[3]), point(args[4], args[5]));
|
||||
segs.push(Seg::Cubic(c1, c2, p));
|
||||
prev_cubic = Some(c2);
|
||||
prev_quad = None;
|
||||
cur = p;
|
||||
}
|
||||
b'S' => {
|
||||
let c1 = prev_cubic.map_or(cur, |c2| cur * 2.0 - c2);
|
||||
let (c2, p) = (point(args[0], args[1]), point(args[2], args[3]));
|
||||
segs.push(Seg::Cubic(c1, c2, p));
|
||||
prev_cubic = Some(c2);
|
||||
prev_quad = None;
|
||||
cur = p;
|
||||
}
|
||||
b'Q' => {
|
||||
let (q, p) = (point(args[0], args[1]), point(args[2], args[3]));
|
||||
segs.push(Seg::Cubic(cur + (q - cur) * (2.0 / 3.0), p + (q - p) * (2.0 / 3.0), p));
|
||||
prev_quad = Some(q);
|
||||
prev_cubic = None;
|
||||
cur = p;
|
||||
}
|
||||
b'T' => {
|
||||
let reflect = prev_quad.map_or(cur, |q| cur * 2.0 - q);
|
||||
let p = point(args[0], args[1]);
|
||||
segs.push(Seg::Cubic(cur + (reflect - cur) * (2.0 / 3.0), p + (reflect - p) * (2.0 / 3.0), p));
|
||||
prev_quad = Some(reflect);
|
||||
prev_cubic = None;
|
||||
cur = p;
|
||||
}
|
||||
b'A' => {
|
||||
let end = point(args[5], args[6]);
|
||||
segs.push(Seg::Arc { rx: args[0].abs(), ry: args[1].abs(), rot: args[2], large: args[3] != 0.0, sweep: args[4] != 0.0, end });
|
||||
cur = end;
|
||||
prev_cubic = None;
|
||||
prev_quad = None;
|
||||
}
|
||||
_ => return Err(IoError::Format("SVG: unsupported path command".into())),
|
||||
}
|
||||
segments += 1;
|
||||
if segments > MAX_PATH_SEGMENTS {
|
||||
return Err(IoError::Format("SVG: path has too many segments".into()));
|
||||
}
|
||||
if segs.len() > MAX_CURVE_POINTS {
|
||||
return Err(IoError::Format("SVG: path has too many segments".into()));
|
||||
}
|
||||
}
|
||||
if !segs.is_empty() {
|
||||
out.push(Subpath { start, segs, closed });
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The centre and signed sweep of a circular arc from `p0` to `p1` in a Y-up frame, per the
|
||||
/// SVG endpoint parameterisation (F.6.5). Radii that cannot span the chord are scaled up,
|
||||
/// as the specification requires.
|
||||
fn arc_center_circular(p0: Vec2, p1: Vec2, r: f64, large: bool, sweep: bool) -> Option<(Vec2, f64)> {
|
||||
if r <= 0.0 || !r.is_finite() {
|
||||
return None;
|
||||
}
|
||||
let d = p1 - p0;
|
||||
let dist = d.x.hypot(d.y);
|
||||
let r = if dist > 2.0 * r { dist / 2.0 } else { r };
|
||||
if dist <= f64::EPSILON {
|
||||
return None;
|
||||
}
|
||||
let mid = (p0 + p1) * 0.5;
|
||||
let h = (r * r - (dist * dist) / 4.0).max(0.0).sqrt();
|
||||
let n = Vec2::new(-d.y / dist, d.x / dist);
|
||||
let sign = if large != sweep { 1.0 } else { -1.0 };
|
||||
let center = mid + n * (h * sign);
|
||||
let a0 = (p0.y - center.y).atan2(p0.x - center.x);
|
||||
let a1 = (p1.y - center.y).atan2(p1.x - center.x);
|
||||
let ccw = (a1 - a0).rem_euclid(std::f64::consts::TAU);
|
||||
Some((center, pick_sweep(ccw, large, sweep)))
|
||||
}
|
||||
|
||||
/// The signed sweep (CCW positive) for a chord sweep `ccw` in `[0, 2π)`: the centre is
|
||||
/// already chosen so that the magnitude matches `large`, so only the direction is left.
|
||||
fn pick_sweep(ccw: f64, large: bool, sweep: bool) -> f64 {
|
||||
let tau = std::f64::consts::TAU;
|
||||
let eps = f64::EPSILON;
|
||||
if sweep {
|
||||
if ccw <= eps { if large { tau } else { eps } } else { ccw }
|
||||
} else if ccw >= tau - eps {
|
||||
if large { -tau } else { -eps }
|
||||
} else {
|
||||
ccw - tau
|
||||
}
|
||||
let point = |p: Vec2| craft_svg::path_data::Point::new(p.x, p.y);
|
||||
craft_svg::path_data::arc_center_circular(point(p0), point(p1), r, large, sweep).map(|(p, angle)| (Vec2::new(p.x, p.y), angle))
|
||||
}
|
||||
|
||||
/// Flatten a general elliptical arc (any `rx`/`ry`/rotation) from `p0` to `p1` in user
|
||||
@@ -1041,44 +421,34 @@ fn flatten_arc(m: &Mat3, p0: Vec2, p1: Vec2, (rx, ry): (f64, f64), rot_deg: f64,
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Endpoint → centre parameterisation for a rotated elliptical arc (SVG F.6.5), in the
|
||||
/// frame the points are given in. Returns the centre, the start parameter and the signed
|
||||
/// sweep.
|
||||
fn elliptical_params(p0: Vec2, p1: Vec2, rx: f64, ry: f64, phi: f64, large: bool, sweep: bool) -> Option<(Vec2, f64, f64)> {
|
||||
if rx <= 0.0 || ry <= 0.0 {
|
||||
return None;
|
||||
}
|
||||
let (sphi, cphi) = phi.sin_cos();
|
||||
let dx = (p0.x - p1.x) / 2.0;
|
||||
let dy = (p0.y - p1.y) / 2.0;
|
||||
let x1 = cphi * dx + sphi * dy;
|
||||
let y1 = -sphi * dx + cphi * dy;
|
||||
let (rx, ry) = {
|
||||
let lambda = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry);
|
||||
if lambda > 1.0 {
|
||||
let s = lambda.sqrt();
|
||||
(rx * s, ry * s)
|
||||
} else {
|
||||
(rx, ry)
|
||||
}
|
||||
};
|
||||
let num = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1;
|
||||
let den = rx * rx * y1 * y1 + ry * ry * x1 * x1;
|
||||
let coef = if sweep != large { 1.0 } else { -1.0 } * (num.max(0.0) / den.max(f64::MIN_POSITIVE)).sqrt();
|
||||
let cxp = coef * rx * y1 / ry;
|
||||
let cyp = -coef * ry * x1 / rx;
|
||||
let center = Vec2::new(cphi * cxp - sphi * cyp + (p0.x + p1.x) / 2.0, sphi * cxp + cphi * cyp + (p0.y + p1.y) / 2.0);
|
||||
let angle = |ux: f64, uy: f64, vx: f64, vy: f64| {
|
||||
let dot = ux * vx + uy * vy;
|
||||
let det = ux * vy - uy * vx;
|
||||
let denom = (ux.hypot(uy) * vx.hypot(vy)).max(f64::MIN_POSITIVE);
|
||||
(dot / denom).clamp(-1.0, 1.0).acos().copysign(det)
|
||||
};
|
||||
let (ux, uy) = ((x1 - cxp) / rx, (y1 - cyp) / ry);
|
||||
let (vx, vy) = ((-x1 - cxp) / rx, (-y1 - cyp) / ry);
|
||||
let theta = angle(1.0, 0.0, ux, uy);
|
||||
let ccw = angle(ux, uy, vx, vy).rem_euclid(std::f64::consts::TAU);
|
||||
Some((center, theta, pick_sweep(ccw, large, sweep)))
|
||||
let point = |p: Vec2| craft_svg::path_data::Point::new(p.x, p.y);
|
||||
craft_svg::path_data::elliptical_params(point(p0), point(p1), rx, ry, phi, large, sweep)
|
||||
.map(|(p, start, sweep)| (Vec2::new(p.x, p.y), start, sweep))
|
||||
}
|
||||
|
||||
/// Convert shared SVG path segments to CADCraft's geometry types.
|
||||
#[cfg(test)]
|
||||
fn parse_path(d: &str) -> Result<Vec<Subpath>> {
|
||||
use craft_svg::path_data::{Point, Segment};
|
||||
let point = |p: Point| Vec2::new(p.x, p.y);
|
||||
let paths = craft_svg::path_data::parse_path(d).map_err(|e| IoError::Format(e.to_string()))?;
|
||||
Ok(paths
|
||||
.into_iter()
|
||||
.map(|sp| Subpath {
|
||||
start: point(sp.start),
|
||||
closed: sp.closed,
|
||||
segs: sp
|
||||
.segs
|
||||
.into_iter()
|
||||
.map(|seg| match seg {
|
||||
Segment::Line(p) => Seg::Line(point(p)),
|
||||
Segment::Cubic(c1, c2, p) => Seg::Cubic(point(c1), point(c2), point(p)),
|
||||
Segment::Arc { rx, ry, rot, large, sweep, end } => Seg::Arc { rx, ry, rot, large, sweep, end: point(end) },
|
||||
})
|
||||
.collect(),
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -2943,6 +2943,15 @@ fn svg_path_lines_curves_and_arcs() {
|
||||
assert!((bulge.abs() - 1.0).abs() < 1e-6, "semicircle bulge is ±1, got {bulge}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_smooth_quadratic_has_two_coordinates() {
|
||||
let smooth = format!("{SVG_PAGE}<path d=\"M0 0 Q3 3 6 0 T12 0\"/></svg>");
|
||||
let explicit = format!("{SVG_PAGE}<path d=\"M0 0 Q3 3 6 0 Q9 -3 12 0\"/></svg>");
|
||||
let smooth = read(smooth.as_bytes(), "smooth.svg").unwrap();
|
||||
let explicit = read(explicit.as_bytes(), "explicit.svg").unwrap();
|
||||
assert_eq!(geometry(&smooth), geometry(&explicit));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_group_transforms_apply() {
|
||||
let svg = format!("{SVG_PAGE}<g transform=\"translate(5,2)\"><line x1=\"0\" y1=\"0\" x2=\"10\" y2=\"0\"/></g></svg>");
|
||||
@@ -3072,6 +3081,33 @@ fn svgz_gunzips_to_the_same_drawing() {
|
||||
assert_eq!(plain.model.iter().map(|e| &e.kind).collect::<Vec<_>>(), packed.model.iter().map(|e| &e.kind).collect::<Vec<_>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svgz_checks_the_gzip_trailer_and_combines_members() {
|
||||
let svg = format!("{SVG_PAGE}<circle cx=\"5\" cy=\"5\" r=\"1\"/></svg>");
|
||||
let split = svg.len() / 2;
|
||||
let mut members = gzip_of(&svg.as_bytes()[..split]);
|
||||
members.extend(gzip_of(&svg.as_bytes()[split..]));
|
||||
let plain = read(svg.as_bytes(), "a.svg").unwrap();
|
||||
let decoded = read(&members, "a.svgz").unwrap();
|
||||
assert_eq!(plain.model.iter().map(|e| &e.kind).collect::<Vec<_>>(), decoded.model.iter().map(|e| &e.kind).collect::<Vec<_>>());
|
||||
|
||||
let mut corrupt = gzip_of(svg.as_bytes());
|
||||
let crc_offset = corrupt.len() - 8;
|
||||
corrupt[crc_offset] ^= 1;
|
||||
assert!(read(&corrupt, "a.svgz").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svgz_open_and_svg_export_follow_the_public_dispatch() {
|
||||
let source = format!("{SVG_PAGE}<line x1=\"1\" y1=\"2\" x2=\"9\" y2=\"7\"/></svg>");
|
||||
let drawing = read(&gzip_of(source.as_bytes()), "input.svgz").unwrap();
|
||||
assert_eq!(kinds(&drawing), ["Line"]);
|
||||
let output = write(&drawing, "output.svg").unwrap();
|
||||
assert!(std::str::from_utf8(&output).unwrap().contains("<polyline"));
|
||||
let reopened = read(&output, "output.svg").unwrap();
|
||||
assert!(!reopened.model.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_read_dispatches_by_extension() {
|
||||
let svg = format!("{SVG_PAGE}<circle cx=\"5\" cy=\"5\" r=\"1\"/></svg>");
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
//! A negative DIMGAP draws a frame around the dimension text. The `*D` block written for the
|
||||
//! dimension holds the frame's four sides, the negative DIMGAP reads back from the file, and a
|
||||
//! PDF plot draws the frame.
|
||||
|
||||
use cadcraft_doc::{Common, DimKind, Dimension, Drawing, EntityKind, Space};
|
||||
use cadcraft_geom::Vec3;
|
||||
|
||||
use crate::pdf_read;
|
||||
|
||||
fn linear() -> Dimension {
|
||||
Dimension {
|
||||
kind: DimKind::Linear { rotation: 0.0 },
|
||||
defpt: Vec3::new(15.0, 5.0, 0.0),
|
||||
text_mid: Vec3::ZERO,
|
||||
p13: Vec3::ZERO,
|
||||
p14: Vec3::new(30.0, 0.0, 0.0),
|
||||
p15: Vec3::ZERO,
|
||||
p16: Vec3::ZERO,
|
||||
text: String::new(),
|
||||
style: "Standard".into(),
|
||||
measurement: 0.0,
|
||||
text_rotation: 0.0,
|
||||
user_text_pos: false,
|
||||
block: None,
|
||||
insertion_point: Vec3::ZERO,
|
||||
overrides: Default::default(),
|
||||
assoc: Vec::new(),
|
||||
marks: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Save a drawing with one dimension in a Standard style of DIMGAP `gap`, read it back, and
|
||||
/// return the style's DIMGAP and the number of LINEs in the dimension's `*D` block.
|
||||
fn roundtrip(gap: f64) -> (f64, usize) {
|
||||
let mut d = Drawing::new_imperial();
|
||||
d.dim_styles.iter_mut().for_each(|s| s.text_gap = gap);
|
||||
d.add(&Space::Model, Common::default(), EntityKind::Dimension(linear())).unwrap();
|
||||
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(&d).as_bytes()).unwrap();
|
||||
let dm = back
|
||||
.model
|
||||
.iter()
|
||||
.find_map(|e| match &e.kind {
|
||||
EntityKind::Dimension(dm) => Some(dm.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
let block = back.block(dm.block.as_deref().unwrap()).unwrap();
|
||||
let lines = block.entities.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count();
|
||||
(back.dim_style("Standard").unwrap().text_gap, lines)
|
||||
}
|
||||
|
||||
/// The number of path segments (`l`) in the PDF of a drawing with one dimension in a Standard
|
||||
/// style of DIMGAP `gap`.
|
||||
fn pdf_segments(gap: f64) -> usize {
|
||||
let mut d = Drawing::new_imperial();
|
||||
d.dim_styles.iter_mut().for_each(|s| s.text_gap = gap);
|
||||
d.add(&Space::Model, Common::default(), EntityKind::Dimension(linear())).unwrap();
|
||||
let doc = pdf_read::read(&cadcraft_io::plot(&d, &Space::Model, &serde_json::json!({"compress": false})).unwrap());
|
||||
pdf_read::count(&doc.pages[0].content, "l")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pdf_draws_the_text_frame() {
|
||||
assert_eq!(pdf_segments(-0.09), pdf_segments(0.09) + 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dimension_block_holds_the_text_frame() {
|
||||
let (gap, plain) = roundtrip(0.09);
|
||||
assert!((gap - 0.09).abs() < 1e-12, "{gap}");
|
||||
let (gap, framed) = roundtrip(-0.09);
|
||||
assert!((gap + 0.09).abs() < 1e-12, "{gap}");
|
||||
assert_eq!(framed, plain + 4);
|
||||
}
|
||||
@@ -14,6 +14,7 @@ mod codepages;
|
||||
mod dim_block_resave_roundtrip;
|
||||
mod dim_block_text;
|
||||
mod dim_marks_roundtrip;
|
||||
mod dim_text_frame;
|
||||
mod dimstyle_vars_roundtrip;
|
||||
mod dimtfill_roundtrip;
|
||||
mod drafting_spacing;
|
||||
@@ -72,6 +73,7 @@ mod spline_fit_data;
|
||||
mod split_entities_section;
|
||||
mod style_typeface;
|
||||
mod svg_arc_budget;
|
||||
mod svg_ellipse_transform_axis;
|
||||
mod svg_tiny_extents;
|
||||
mod table_cellstyle_roundtrip;
|
||||
mod tables_objects_roundtrip;
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
//! SVG import of an ellipse under a rotation, skew or non-uniform scale: the major axis of the
|
||||
//! resulting `ELLIPSE` must point along the major axis of the transformed shape in the output plane.
|
||||
|
||||
use cadcraft_doc::EntityKind;
|
||||
use cadcraft_io::read;
|
||||
|
||||
/// Reads `<ellipse rx=20 ry=10>` under `transform` and returns (major direction angle, ratio).
|
||||
fn import(transform: &str) -> (f64, f64) {
|
||||
let svg = format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><g transform="{transform}"><ellipse cx="0" cy="0" rx="20" ry="10"/></g></svg>"#);
|
||||
let d = read(svg.as_bytes(), "a.svg").unwrap();
|
||||
let e = d
|
||||
.model
|
||||
.iter()
|
||||
.find_map(|e| match &e.kind {
|
||||
EntityKind::Ellipse(el) => Some(el.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
let (dx, dy) = (e.major.x - e.center.x, e.major.y - e.center.y);
|
||||
(dy.atan2(dx), e.ratio)
|
||||
}
|
||||
|
||||
/// Major-axis angle and ratio of the image of the ellipse under the 2x2 map `[a c; b d]`, with
|
||||
/// the SVG y axis flipped (eigenvectors of `B·Bᵀ`, where B's columns are the transformed radii).
|
||||
fn expected(a: f64, b: f64, c: f64, d: f64) -> (f64, f64) {
|
||||
let (bx, by) = ((20.0 * a, -20.0 * b), (10.0 * c, -10.0 * d));
|
||||
let m11 = bx.0 * bx.0 + by.0 * by.0;
|
||||
let m22 = bx.1 * bx.1 + by.1 * by.1;
|
||||
let m12 = bx.0 * bx.1 + by.0 * by.1;
|
||||
let angle = 0.5 * (2.0 * m12).atan2(m11 - m22);
|
||||
let tr = m11 + m22;
|
||||
let disc = ((m11 - m22).powi(2) + 4.0 * m12 * m12).sqrt();
|
||||
(angle, ((tr - disc) / (tr + disc)).sqrt())
|
||||
}
|
||||
|
||||
/// Angles equal up to the sign of the axis (modulo π).
|
||||
fn same_axis(got: f64, want: f64) -> bool {
|
||||
let diff = (got - want).rem_euclid(std::f64::consts::PI);
|
||||
diff < 1e-6 || std::f64::consts::PI - diff < 1e-6
|
||||
}
|
||||
|
||||
fn check(transform: &str, m: (f64, f64, f64, f64)) {
|
||||
let (angle, ratio) = import(transform);
|
||||
let (want_angle, want_ratio) = expected(m.0, m.1, m.2, m.3);
|
||||
assert!(same_axis(angle, want_angle), "{transform}: major axis at {}°, want {}°", angle.to_degrees(), want_angle.to_degrees());
|
||||
assert!((ratio - want_ratio).abs() < 1e-9, "{transform}: ratio {ratio}, want {want_ratio}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rotated_ellipse_keeps_its_major_axis_direction() {
|
||||
let (s, c) = 30f64.to_radians().sin_cos();
|
||||
check("rotate(30)", (c, s, -s, c));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn skewed_ellipse_gets_the_output_space_major_axis() {
|
||||
check("skewX(30)", (1.0, 0.0, 30f64.to_radians().tan(), 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scaled_after_rotation_ellipse_gets_the_output_space_major_axis() {
|
||||
let (s, c) = 30f64.to_radians().sin_cos();
|
||||
check("matrix(2 0 0 1 0 0) rotate(30)", (2.0 * c, s, -2.0 * s, c));
|
||||
}
|
||||
@@ -361,6 +361,22 @@ pub fn dimension_geometry_with(d: &Dimension, st: &DimStyle, dimscale: f64, font
|
||||
let (hw, hh) = (w / 2.0 + gap, h / 2.0 + gap);
|
||||
g.text_fill = [(-hw, -hh), (hw, -hh), (hw, hh), (-hw, hh)].into_iter().map(|(px, py)| text_mid + x * px + y * py).collect();
|
||||
}
|
||||
// DIMGAP below 0: a frame around the text and the arc symbol over it, widened by |DIMGAP| on
|
||||
// every side. A DIMINSPECT frame takes its place.
|
||||
if st.text_gap < 0.0 && !g.mtext.is_empty() && d.marks.inspect.as_ref().is_none_or(|ins| ins.shape >= 2) {
|
||||
let (w, h) = measure(&g.mtext);
|
||||
let (x, y) = (Vec2::from_angle(text_angle), Vec2::from_angle(text_angle).perp());
|
||||
// DIMARCSYM 1: the arc symbol's half width and how far its top is above the text's middle.
|
||||
let arc_over =
|
||||
(matches!(d.kind, DimKind::ArcLength) && st.arc_symbol == 1).then(|| ((w / 2.0).max(th / 2.0), h / 2.0 + gap / 2.0 + th * 0.35));
|
||||
let (hw, top) = arc_over.map_or((w / 2.0, h / 2.0), |(half, peak)| ((w / 2.0).max(half), (h / 2.0).max(peak)));
|
||||
let (hw, top, bottom) = (hw + gap, top + gap, h / 2.0 + gap);
|
||||
let corners: Vec<Vec2> =
|
||||
[(-hw, -bottom), (hw, -bottom), (hw, top), (-hw, top)].into_iter().map(|(px, py)| text_mid + x * px + y * py).collect();
|
||||
for (a, b) in corners.iter().zip(corners.iter().cycle().skip(1)) {
|
||||
g.text_mark(vec![*a, *b]);
|
||||
}
|
||||
}
|
||||
g.value = decode_value(&cadcraft_fonts::plain_mtext(&g.mtext));
|
||||
if !g.mtext.is_empty() {
|
||||
let l = cadcraft_fonts::layout_mtext_with(&g.mtext, ¶ms(text_mid, text_angle));
|
||||
|
||||
@@ -77,7 +77,7 @@ fn prepare_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_mid: Vec2) -
|
||||
let axis = Vec2::from_angle(angle);
|
||||
(text_width * axis.dot(u).abs() + text_height * axis.perp().dot(u).abs()) / 2.0
|
||||
};
|
||||
let inside_angle = if st.text_inside_horizontal { 0.0 } else { along_angle };
|
||||
let inside_angle = text_angle(config, st.text_inside_horizontal, along_angle);
|
||||
let tvp = if st.text_above == 0 && st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 };
|
||||
let centred = st.text_above == 0 && tvp.abs() < 0.7;
|
||||
let text_need = if centred { 2.0 * (extent(inside_angle) + config.gap) } else { 2.0 * extent(inside_angle) };
|
||||
@@ -129,6 +129,20 @@ fn prepare_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_mid: Vec2) -
|
||||
}
|
||||
}
|
||||
|
||||
/// The text's angle: an explicit text rotation (DIMTEDIT Angle, the Properties palette's Text
|
||||
/// rotation) turns it, so the dimension line leaves room for the text as turned; otherwise
|
||||
/// horizontal (DIMTIH inside, DIMTOH outside) or `along` the line.
|
||||
fn text_angle(config: &DimConfig<'_>, horizontal: bool, along: f64) -> f64 {
|
||||
let rotation = config.dimension.text_rotation;
|
||||
if rotation != 0.0 && rotation.is_finite() {
|
||||
rotation
|
||||
} else if horizontal {
|
||||
0.0
|
||||
} else {
|
||||
along
|
||||
}
|
||||
}
|
||||
|
||||
fn position_linear_text(config: &DimConfig<'_>, state: &mut LinearDimState) {
|
||||
let st = config.style;
|
||||
let along_angle = readable(state.u.angle());
|
||||
@@ -136,8 +150,8 @@ fn position_linear_text(config: &DimConfig<'_>, state: &mut LinearDimState) {
|
||||
let axis = Vec2::from_angle(angle);
|
||||
(state.text_width * axis.dot(state.u).abs() + state.text_height * axis.perp().dot(state.u).abs()) / 2.0
|
||||
};
|
||||
let inside_angle = if st.text_inside_horizontal { 0.0 } else { along_angle };
|
||||
state.angle = if state.text_outside { if st.text_outside_horizontal { 0.0 } else { along_angle } } else { inside_angle };
|
||||
let inside_angle = text_angle(config, st.text_inside_horizontal, along_angle);
|
||||
state.angle = if state.text_outside { text_angle(config, st.text_outside_horizontal, along_angle) } else { inside_angle };
|
||||
state.half_extent = extent(state.angle);
|
||||
state.along_center = if state.text_outside {
|
||||
state.f2 + state.u * (2.0 * config.arrow_size.max(config.tick_size) + config.gap + state.half_extent)
|
||||
|
||||
@@ -167,6 +167,159 @@ fn dimtvp_uses_the_dimension_text_height() {
|
||||
assert!((g.text_pos.y - 6.6).abs() < 1e-6, "text y={} height={}", g.text_pos.y, g.text_height);
|
||||
}
|
||||
|
||||
/// The last four lines of `g` as a frame: four sides, each starting where the one before ends.
|
||||
fn frame_of(g: &DimGeometry) -> Vec<Vec<Vec2>> {
|
||||
let sides: Vec<Vec<Vec2>> = g.lines.iter().rev().take(4).rev().cloned().collect();
|
||||
assert_eq!(sides.len(), 4);
|
||||
for (a, b) in sides.iter().zip(sides.iter().cycle().skip(1)) {
|
||||
assert_eq!(a.len(), 2);
|
||||
assert!(a[1].dist(b[0]) < 1e-9, "{sides:?}");
|
||||
}
|
||||
sides
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn negative_dimgap_draws_a_frame_around_the_text() {
|
||||
let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
|
||||
let plain = dimension_geometry(&d, &st_with(|s| s.text_gap = 0.09), 1.0);
|
||||
let framed = dimension_geometry(&d, &st_with(|s| s.text_gap = -0.09), 1.0);
|
||||
// The same text place and dimension line break as DIMGAP 0.09, and four more lines.
|
||||
assert!(framed.text_pos.dist(plain.text_pos) < 1e-12);
|
||||
assert_eq!(framed.lines.len(), plain.lines.len() + 4);
|
||||
assert_eq!(framed.lines_of(LineRole::Dim).count(), plain.lines_of(LineRole::Dim).count() + 4);
|
||||
// The frame is the text box widened by 0.09 on every side, around the text.
|
||||
let frame = bbox(&frame_of(&framed));
|
||||
let l = cadcraft_fonts::layout_mtext_with(&framed.mtext, &MTextParams { attach: 5, ..MTextParams::new(Vec2::ZERO, 0.18) });
|
||||
assert!((frame.width() - (l.bounds.width() + 0.18)).abs() < 1e-9, "{frame:?}");
|
||||
assert!((frame.height() - (l.bounds.height() + 0.18)).abs() < 1e-9, "{frame:?}");
|
||||
let text = bbox(&framed.text);
|
||||
assert!(frame.min.x < text.min.x && text.max.x < frame.max.x && frame.min.y < text.min.y && text.max.y < frame.max.y);
|
||||
assert!((frame.center().dist(framed.text_pos)) < 1e-9, "{frame:?}");
|
||||
// DIMGAP 0 and above: no frame.
|
||||
assert_eq!(dimension_geometry(&d, &st_with(|s| s.text_gap = 0.0), 1.0).lines.len(), plain.lines.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_dimgap_frame_holds_every_line_of_a_multi_line_text() {
|
||||
let mut d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
|
||||
let one = frame_of(&dimension_geometry(&d, &st_with(|s| s.text_gap = -0.09), 1.0));
|
||||
d.text = "<>\\PTYP".into();
|
||||
let g = dimension_geometry(&d, &st_with(|s| s.text_gap = -0.09), 1.0);
|
||||
let frame = bbox(&frame_of(&g));
|
||||
let l = cadcraft_fonts::layout_mtext_with(&g.mtext, &MTextParams { attach: 5, ..MTextParams::new(Vec2::ZERO, 0.18) });
|
||||
assert!(l.bounds.height() > 0.18 * 1.5, "two lines: {:?}", l.bounds);
|
||||
assert!((frame.height() - (l.bounds.height() + 0.18)).abs() < 1e-9, "{frame:?}");
|
||||
assert!(frame.height() > bbox(&one).height(), "{frame:?}");
|
||||
let text = bbox(&g.text);
|
||||
assert!(frame.min.x < text.min.x && text.max.x < frame.max.x && frame.min.y < text.min.y && text.max.y < frame.max.y, "{frame:?} {text:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_dimgap_frame_is_drawn_over_a_text_background() {
|
||||
let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
|
||||
let g = dimension_geometry(
|
||||
&d,
|
||||
&st_with(|s| {
|
||||
s.text_gap = -0.09;
|
||||
s.text_fill = 1;
|
||||
}),
|
||||
1.0,
|
||||
);
|
||||
assert_eq!(g.text_fill.len(), 4);
|
||||
// The four sides are text marks, which are drawn after the background.
|
||||
let n = g.lines.len();
|
||||
for i in n - 4..n {
|
||||
assert!(g.text_marks.contains(&i), "{:?}", g.text_marks);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_frame_turns_with_the_text() {
|
||||
let d = lin((0.0, 0.0), (0.0, 10.0), (5.0, 0.0), std::f64::consts::FRAC_PI_2);
|
||||
let g = dimension_geometry(
|
||||
&d,
|
||||
&st_with(|s| {
|
||||
s.text_gap = -0.09;
|
||||
s.text_inside_horizontal = false;
|
||||
}),
|
||||
1.0,
|
||||
);
|
||||
assert!((g.text_angle.abs() - std::f64::consts::FRAC_PI_2).abs() < 1e-9, "{}", g.text_angle);
|
||||
// Two sides along the text, two across it, the long ones along the dimension line.
|
||||
for s in frame_of(&g) {
|
||||
let v = s[1] - s[0];
|
||||
assert!(v.x.abs() < 1e-9 || v.y.abs() < 1e-9, "{v:?}");
|
||||
}
|
||||
let frame = bbox(&frame_of(&g));
|
||||
assert!(frame.height() > frame.width(), "{frame:?}");
|
||||
assert!(bbox(&g.text).max.y < frame.max.y && frame.min.y < bbox(&g.text).min.y);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_frame_takes_in_the_arc_symbol_over_the_text() {
|
||||
let mut d = lin((10.0, 0.0), (0.0, 10.0), (12.0, 0.0), 0.0);
|
||||
d.kind = DimKind::ArcLength;
|
||||
let g = dimension_geometry(
|
||||
&d,
|
||||
&st_with(|s| {
|
||||
s.text_gap = -0.09;
|
||||
s.arc_symbol = 1;
|
||||
s.text_inside_horizontal = true;
|
||||
}),
|
||||
1.0,
|
||||
);
|
||||
let frame = bbox(&frame_of(&g));
|
||||
// The arc symbol is the line drawn just before the frame.
|
||||
let sym = &g.lines[g.lines.len() - 5];
|
||||
assert_eq!(sym.len(), 13);
|
||||
let s = bbox(std::slice::from_ref(sym));
|
||||
assert!((frame.max.y - (s.max.y + 0.09)).abs() < 1e-9, "{frame:?} {s:?}");
|
||||
assert!(frame.min.x < s.min.x && s.max.x < frame.max.x, "{frame:?} {s:?}");
|
||||
let text = bbox(&g.text);
|
||||
assert!(frame.min.y < text.min.y && text.max.y < frame.max.y, "{frame:?} {text:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_arc_symbol_and_the_frame_turn_with_a_text_angle() {
|
||||
let mut d = lin((10.0, 0.0), (0.0, 10.0), (12.0, 0.0), 0.0);
|
||||
d.kind = DimKind::ArcLength;
|
||||
d.text_rotation = 0.5;
|
||||
let g = dimension_geometry(
|
||||
&d,
|
||||
&st_with(|s| {
|
||||
s.text_gap = -0.09;
|
||||
s.arc_symbol = 1;
|
||||
}),
|
||||
1.0,
|
||||
);
|
||||
assert!((g.text_angle - 0.5).abs() < 1e-12);
|
||||
// In the text's own axes, the frame is upright and holds the symbol 0.09 below its top.
|
||||
let (x, y) = (Vec2::from_angle(0.5), Vec2::from_angle(0.5).perp());
|
||||
let local = |pts: &[Vec<Vec2>]| -> Vec<Vec<Vec2>> {
|
||||
pts.iter().map(|l| l.iter().map(|p| Vec2::new((*p - g.text_pos).dot(x), (*p - g.text_pos).dot(y))).collect()).collect()
|
||||
};
|
||||
let frame = bbox(&local(&frame_of(&g)));
|
||||
let sym = bbox(&local(std::slice::from_ref(&g.lines[g.lines.len() - 5])));
|
||||
assert!((frame.max.y - (sym.max.y + 0.09)).abs() < 1e-9, "{frame:?} {sym:?}");
|
||||
assert!(frame.min.x < sym.min.x && sym.max.x < frame.max.x, "{frame:?} {sym:?}");
|
||||
// The symbol's ends sit level in the text's axes.
|
||||
let s = &local(std::slice::from_ref(&g.lines[g.lines.len() - 5]))[0];
|
||||
assert!((s[0].y - s[12].y).abs() < 1e-9, "{s:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_inspection_frame_takes_the_place_of_the_dimgap_frame() {
|
||||
let mut d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
|
||||
d.marks.inspect = Some(cadcraft_doc::Inspection { shape: 0, label: "A".into(), rate: "50%".into() });
|
||||
let st = |gap: f64| st_with(|s| s.text_gap = gap);
|
||||
let inspected = dimension_geometry(&d, &st(0.09), 1.0).lines.len();
|
||||
assert_eq!(dimension_geometry(&d, &st(-0.09), 1.0).lines.len(), inspected);
|
||||
// Shape none draws no inspection frame, so DIMGAP's frame is drawn.
|
||||
d.marks.inspect = Some(cadcraft_doc::Inspection { shape: 2, label: String::new(), rate: String::new() });
|
||||
let none = dimension_geometry(&d, &st(0.09), 1.0).lines.len();
|
||||
assert_eq!(dimension_geometry(&d, &st(-0.09), 1.0).lines.len(), none + 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dimtad_one_uses_autocad_text_clearance() {
|
||||
let d = lin((0.0, 0.10), (0.0, 0.70), (0.30, 0.40), std::f64::consts::FRAC_PI_2);
|
||||
@@ -201,6 +354,21 @@ fn text_alignment_vertical_dimension() {
|
||||
assert!((a.text_angle - std::f64::consts::FRAC_PI_2).abs() < 1e-9, "aligned: {}", a.text_angle);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_text_rotation_widens_the_dimension_line_gap() {
|
||||
// A vertical dimension's text, horizontal by DIMTIH, turned along the line (DIMTEDIT Angle,
|
||||
// the Properties palette's Text rotation): the line's gap fits the text as turned.
|
||||
let mut d = lin((0.0, 0.0), (0.0, 40.0), (5.0, 0.0), std::f64::consts::FRAC_PI_2);
|
||||
d.text_rotation = std::f64::consts::FRAC_PI_2;
|
||||
let g = dimension_geometry(&d, &DimStyle::default(), 1.0);
|
||||
let text = bbox(&g.text);
|
||||
assert!(text.height() > 2.0 * text.width(), "turned along the line: {text:?}");
|
||||
for l in g.lines_of(LineRole::Dim) {
|
||||
let b = bbox(std::slice::from_ref(l));
|
||||
assert!(b.max.y <= text.min.y + 1e-9 || b.min.y >= text.max.y - 1e-9, "the dimension line {l:?} crosses the text {text:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn justification_moves_text() {
|
||||
let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
|
||||
|
||||
@@ -276,7 +276,9 @@ pub(super) fn draw_arc_length(config: &DimConfig<'_>, g: &mut DimGeometry, text_
|
||||
if st.arc_symbol == 1 {
|
||||
// A small arc over the text.
|
||||
let (tw, tht) = measure(&g.mtext);
|
||||
let (x, y) = (Vec2::from_angle(text_angle), Vec2::from_angle(text_angle).perp());
|
||||
// The symbol turns with the text, a DIMTEDIT Angle included.
|
||||
let a = if d.text_rotation != 0.0 && d.text_rotation.is_finite() { d.text_rotation } else { text_angle };
|
||||
let (x, y) = (Vec2::from_angle(a), Vec2::from_angle(a).perp());
|
||||
let half = (tw / 2.0).max(th / 2.0);
|
||||
let base = text_mid + y * (tht / 2.0 + gap / 2.0);
|
||||
let sym: Vec<Vec2> = (0..=12)
|
||||
|
||||
@@ -354,6 +354,25 @@ fn premultiplied(r: &cadcraft_doc::Raster) -> Option<Pixmap> {
|
||||
Pixmap::from_vec(data, tiny_skia::IntSize::from_wh(r.width(), r.height())?)
|
||||
}
|
||||
|
||||
/// Write straight-alpha RGBA8 pixels as PNG a row at a time.
|
||||
pub fn write_rgba_png(mut output: impl std::io::Write, width: u32, height: u32, pixels: &[u8]) -> Option<()> {
|
||||
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
|
||||
let stride = usize::try_from(width).ok()?.checked_mul(4).filter(|n| *n > 0)?;
|
||||
let expected = stride.checked_mul(usize::try_from(height).ok()?)?;
|
||||
if height == 0 || pixels.len() != expected {
|
||||
return None;
|
||||
}
|
||||
let mut rows = pixels.chunks_exact(stride);
|
||||
let row = |data: &[u8]| Image::from_u8(width, 1, ChannelLayout::Rgba, data.to_vec()).ok();
|
||||
let first = row(rows.next()?)?;
|
||||
let mut encoder = PngRows::new(&mut output, &first, height, &EncodeOptions::default()).ok()?;
|
||||
encoder.push(&first).ok()?;
|
||||
for data in rows {
|
||||
encoder.push(&row(data)?).ok()?;
|
||||
}
|
||||
encoder.finish().ok()
|
||||
}
|
||||
|
||||
/// Encode a premultiplied pixmap as PNG without a second full-frame copy.
|
||||
pub fn encode_png(pixmap: &Pixmap) -> Option<Vec<u8>> {
|
||||
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
|
||||
|
||||
@@ -16,6 +16,8 @@ cadcraft-color = { workspace = true }
|
||||
cadcraft-doc = { workspace = true }
|
||||
cadcraft-render = { workspace = true }
|
||||
cadcraft-engine = { workspace = true }
|
||||
cadcraft-io = { workspace = true }
|
||||
craft-image-codecs = { workspace = true }
|
||||
cadcraft-fonts = { workspace = true }
|
||||
craft-window = { workspace = true }
|
||||
egui = { workspace = true }
|
||||
@@ -40,8 +42,6 @@ craft-ui = { workspace = true, features = ["native-windows"] }
|
||||
egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }
|
||||
# Validates the canvas WGSL and its GLSL ES 3.0 (WebGL2) translation in tests (same naga wgpu uses).
|
||||
naga = { version = "30", features = ["wgsl-in", "glsl-out"] }
|
||||
# Reads the synthetic dynamic-block fixture of the io tests for the dynamic grips tests.
|
||||
cadcraft-io = { workspace = true }
|
||||
|
||||
[build-dependencies]
|
||||
serde_json = { workspace = true }
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -186,6 +186,10 @@ pub struct CanvasState {
|
||||
/// The right-click that opened the shortcut menu held Shift or Ctrl: it is the object snap
|
||||
/// menu ([`crate::context_menu`]).
|
||||
pub snap_menu: bool,
|
||||
/// The number (in the session's count of commands) of the INSERT the Blocks palette started
|
||||
/// and is placing: a quick right-click at its insertion point cancels it
|
||||
/// ([`right_click_cancels_placing`]).
|
||||
pub palette_insert: Option<u64>,
|
||||
/// Tab was pressed over a snap marker: show the next candidate ([`SnapCycle`]).
|
||||
pub snap_tab: bool,
|
||||
pub snap_cycle: Option<SnapCycle>,
|
||||
@@ -783,6 +787,15 @@ fn collect_prompt_clicks(app: &mut CadApp, ui: &egui::Ui, context: PromptClickCo
|
||||
pressed_primary
|
||||
}
|
||||
|
||||
/// Whether a quick right-click cancels the running command instead of acting as Enter: it asks for
|
||||
/// the insertion point of an INSERT the Blocks palette started. AutoCAD's Enter asks the point again,
|
||||
/// and Escape (or this) is how a placement ends, so the palette's own placements get a way out
|
||||
/// with the mouse.
|
||||
pub(crate) fn right_click_cancels_placing(app: &CadApp) -> bool {
|
||||
app.canvas.palette_insert == Some(app.session.commands_started)
|
||||
&& app.session.current_prompt().is_some_and(|p| p.message == "Specify insertion point")
|
||||
}
|
||||
|
||||
/// Draw the drawing area and handle its input (zoom and pan, picking, the crosshair) for this
|
||||
/// frame.
|
||||
///
|
||||
@@ -969,7 +982,11 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
|
||||
app.canvas.snap_menu = mods.shift || mods.ctrl;
|
||||
}
|
||||
if crate::context_menu::in_command(app, ui, inside, pressed_secondary) {
|
||||
let _ = app.session.input(Input::Enter);
|
||||
if right_click_cancels_placing(app) {
|
||||
crate::cmdline::escape(app);
|
||||
} else {
|
||||
let _ = app.session.input(Input::Enter);
|
||||
}
|
||||
}
|
||||
// Right-click on a grip with options (polyline vertex, line end…) opens the grip menu.
|
||||
if inside && pressed_secondary && idle && !app.canvas.snap_menu {
|
||||
|
||||
@@ -372,11 +372,7 @@ pub fn keyboard(app: &mut CadApp, ctx: &egui::Context) {
|
||||
egui::Event::Ime(_) => {}
|
||||
egui::Event::Key { key, pressed: true, repeat, modifiers, .. } => match key {
|
||||
Key::Enter => submit(app),
|
||||
Key::Escape => {
|
||||
app.cmd.buffer.clear();
|
||||
app.cmd.preedit.clear();
|
||||
app.session.cancel();
|
||||
}
|
||||
Key::Escape => escape(app),
|
||||
Key::Backspace => {
|
||||
let press = KeyPress { repeat, plain: !(modifiers.alt || modifiers.ctrl || modifiers.command) };
|
||||
let erase = backspace_erases(
|
||||
@@ -425,6 +421,14 @@ pub fn keyboard(app: &mut CadApp, ctx: &egui::Context) {
|
||||
}
|
||||
}
|
||||
|
||||
/// What Escape does, and the right-click or menu "Cancel" that stand for it: what was typed so far
|
||||
/// goes, and so does the running command.
|
||||
pub fn escape(app: &mut CadApp) {
|
||||
app.cmd.buffer.clear();
|
||||
app.cmd.preedit.clear();
|
||||
app.session.cancel();
|
||||
}
|
||||
|
||||
pub fn submit(app: &mut CadApp) {
|
||||
app.cmd.preedit.clear();
|
||||
// Grip dimensional input: the typed lengths and angles place the grip.
|
||||
|
||||
@@ -22,6 +22,7 @@
|
||||
use cadcraft_doc::EntityKind;
|
||||
use cadcraft_engine::snap::mode;
|
||||
use cadcraft_engine::{Input, find_command};
|
||||
use serde_json::json;
|
||||
|
||||
use crate::CadApp;
|
||||
use crate::menus::{Entry, activate, entry_ui};
|
||||
@@ -58,6 +59,10 @@ pub const TYPE: &str = "type:";
|
||||
pub const KEYWORD: &str = "keyword:";
|
||||
/// An object snap menu item ([`choose_snap`]).
|
||||
pub const SNAP: &str = "snap:";
|
||||
/// Dimension Style ▸ item: the selected dimensions take the style that follows.
|
||||
pub const DIM_STYLE: &str = "dimstyle:";
|
||||
/// Precision ▸ item: the selected dimensions show this many decimal places (an override).
|
||||
pub const DIM_PRECISION: &str = "dimprecision:";
|
||||
|
||||
fn item(app: &CadApp, id: &str, label: Option<&str>) -> Option<Entry> {
|
||||
let spec = find_command(id)?;
|
||||
@@ -158,15 +163,18 @@ fn object_commands(app: &CadApp) -> Vec<(&'static str, Option<&'static str>)> {
|
||||
}
|
||||
}
|
||||
|
||||
/// [`object_commands`] that are registered, as menu items. The Edit Text entry of a single
|
||||
/// selected text, mtext or attribute definition opens the Edit Text window instead of the
|
||||
/// TEXTEDIT command line; the double-click keeps its in-place editing (#842), and several
|
||||
/// selected texts still take the command line.
|
||||
/// [`object_commands`] that are registered, as menu items, then the dimension shortcut menu's
|
||||
/// items when the selection is dimensions. The Edit Text entry of a single selected text, mtext or
|
||||
/// attribute definition opens the Edit Text window instead of the TEXTEDIT command line; the
|
||||
/// double-click keeps its in-place editing (#842), and several selected texts still take the
|
||||
/// command line.
|
||||
pub fn object_entries(app: &CadApp) -> Vec<Entry> {
|
||||
object_commands(app)
|
||||
let mut out: Vec<Entry> = object_commands(app)
|
||||
.into_iter()
|
||||
.filter_map(|(id, label)| if id == "textedit" { edit_text_window_entry(app).or_else(|| item(app, id, label)) } else { item(app, id, label) })
|
||||
.collect()
|
||||
.collect();
|
||||
out.extend(dimension_entries(app));
|
||||
out
|
||||
}
|
||||
|
||||
/// The Edit Text entry as the `textedit:<handle>` dialog id, for a single selected text, mtext
|
||||
@@ -183,6 +191,64 @@ fn edit_text_window_entry(app: &CadApp) -> Option<Entry> {
|
||||
Some(Entry::Item { label: "Edit Text".into(), id: format!("textedit:{}", h.hex()), shortcut: None, enabled: true })
|
||||
}
|
||||
|
||||
/// For selected dimensions (and only dimensions): Align Text ▸, Dimension Style ▸ (the
|
||||
/// drawing's styles, then Save as New Style), Precision ▸ and Remove Style Overrides.
|
||||
fn dimension_entries(app: &CadApp) -> Vec<Entry> {
|
||||
let Ok(d) = app.session.doc() else { return Vec::new() };
|
||||
let sel = app.session.selection();
|
||||
let dims: Vec<&cadcraft_doc::Dimension> =
|
||||
sel.iter().filter_map(|h| d.entity(*h)).filter_map(|e| if let EntityKind::Dimension(dm) = &e.kind { Some(dm) } else { None }).collect();
|
||||
if dims.is_empty() || dims.len() != sel.len() {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut out: Vec<Entry> =
|
||||
sub("Align Text", items(app, &["dimtedit.home", "dimtedit.angle", "dimtedit.left", "dimtedit.center", "dimtedit.right"]))
|
||||
.into_iter()
|
||||
.collect();
|
||||
// Style names are the drawing's own.
|
||||
let mut styles: Vec<Entry> = d
|
||||
.dim_styles
|
||||
.iter()
|
||||
.map(|st| Entry::Item { label: st.name.clone(), id: format!("{DIM_STYLE}{}", st.name), shortcut: None, enabled: true })
|
||||
.collect();
|
||||
styles.extend(item(app, "dimstyle.saveas", None));
|
||||
out.extend(sub("Dimension Style", styles));
|
||||
let precision = (0..=8usize)
|
||||
.map(|n| Entry::Item {
|
||||
label: if n == 0 { "0".into() } else { format!("0.{}", "0".repeat(n)) },
|
||||
id: format!("{DIM_PRECISION}{n}"),
|
||||
shortcut: None,
|
||||
enabled: true,
|
||||
})
|
||||
.collect();
|
||||
out.extend(sub("Precision", precision));
|
||||
// Available while some selected dimension overrides its style.
|
||||
if let Some(Entry::Item { label, id, shortcut, .. }) = item(app, "dimoverride.clear", None) {
|
||||
out.push(Entry::Item { label, id, shortcut, enabled: dims.iter().any(|dm| !dm.overrides.is_empty()) });
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Precision ▸: the selected dimensions show `places` decimal places (DIMDEC, or DIMADEC for
|
||||
/// angular dimensions), as overrides.
|
||||
fn set_precision(app: &mut CadApp, places: u8) {
|
||||
let (mut linear, mut angular) = (Vec::new(), Vec::new());
|
||||
if let Ok(d) = app.session.doc() {
|
||||
for h in app.session.selection() {
|
||||
if let Some(EntityKind::Dimension(dm)) = d.entity(h).map(|e| &e.kind) {
|
||||
let list =
|
||||
if matches!(dm.kind, cadcraft_doc::DimKind::Angular | cadcraft_doc::DimKind::Angular3P) { &mut angular } else { &mut linear };
|
||||
list.push(h.hex());
|
||||
}
|
||||
}
|
||||
}
|
||||
for (hs, key) in [(linear, "decimals"), (angular, "angularDecimals")] {
|
||||
if !hs.is_empty() {
|
||||
let _ = app.run("properties.set", json!({ "handles": hs, key: places }));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The command menu while a command runs (`None` when none does): Enter and Cancel, Recent Input,
|
||||
/// the prompt's options, Snap Overrides at point prompts, Pan and Zoom.
|
||||
pub fn command_entries(app: &CadApp) -> Option<Vec<Vec<Entry>>> {
|
||||
@@ -225,9 +291,7 @@ pub fn choose(app: &mut CadApp, id: &str) {
|
||||
app.cmd.buffer.clear();
|
||||
app.cmdline("");
|
||||
} else if id == CANCEL {
|
||||
// Escape.
|
||||
app.cmd.buffer.clear();
|
||||
app.session.cancel();
|
||||
crate::cmdline::escape(app);
|
||||
} else if let Some(text) = id.strip_prefix(TYPE) {
|
||||
app.cmd.buffer.clear();
|
||||
app.cmdline(text);
|
||||
@@ -241,6 +305,11 @@ pub fn choose(app: &mut CadApp, id: &str) {
|
||||
} else if id.starts_with("textedit:") {
|
||||
// The Edit Text window of the single selected text object; the id carries the handle.
|
||||
app.ui.dialog = Some(id.to_string());
|
||||
} else if let Some(name) = id.strip_prefix(DIM_STYLE) {
|
||||
let hs: Vec<String> = app.session.selection().iter().map(|h| h.hex()).collect();
|
||||
let _ = app.run("properties.set", json!({ "handles": hs, "dimStyle": name }));
|
||||
} else if let Some(n) = id.strip_prefix(DIM_PRECISION).and_then(|n| n.parse::<u8>().ok()) {
|
||||
set_precision(app, n.min(8));
|
||||
} else {
|
||||
activate(app, id);
|
||||
}
|
||||
|
||||
@@ -691,6 +691,29 @@ impl Drop for PathlessShots {
|
||||
}
|
||||
}
|
||||
|
||||
fn write_screenshot_png(img: &image::RgbaImage, output: impl std::io::Write) -> std::io::Result<()> {
|
||||
cadcraft_render::raster::write_rgba_png(output, img.width(), img.height(), img.as_raw())
|
||||
.ok_or_else(|| std::io::Error::other("PNG encoding failed"))
|
||||
}
|
||||
|
||||
fn save_explicit_screenshot(img: &image::RgbaImage, path: &str) -> std::io::Result<()> {
|
||||
use craft_image_codecs::{ChannelLayout, EncodeOptions, Format, Image};
|
||||
let format = match image::ImageFormat::from_path(path).map_err(std::io::Error::other)? {
|
||||
image::ImageFormat::Png => Format::Png,
|
||||
image::ImageFormat::Jpeg => Format::Jpeg,
|
||||
image::ImageFormat::Bmp => Format::Bmp,
|
||||
image::ImageFormat::Tiff => Format::Tiff,
|
||||
_ => return Err(std::io::Error::other("unsupported screenshot format")),
|
||||
};
|
||||
if format == Format::Png {
|
||||
return write_screenshot_png(img, std::fs::File::create(path)?);
|
||||
}
|
||||
let pixels = Image::from_u8(img.width(), img.height(), ChannelLayout::Rgba, img.as_raw().clone()).map_err(std::io::Error::other)?;
|
||||
let opts = EncodeOptions { jpeg_quality: 75, jpeg_chroma_subsampling: false, ..EncodeOptions::default() };
|
||||
let bytes = craft_image_codecs::encode(&pixels, format, &opts).map_err(std::io::Error::other)?;
|
||||
std::fs::write(path, bytes)
|
||||
}
|
||||
|
||||
/// Save a pathless screenshot into the private per-process directory: re-validate or recreate it as an owner-only real directory (0700 on Unix; plain create elsewhere), then create up to 64 exclusive files (0600 on Unix) and write a PNG.
|
||||
fn save_pathless_screenshot(img: &image::RgbaImage, token: u64) -> std::io::Result<std::path::PathBuf> {
|
||||
use std::io::Write as _;
|
||||
@@ -713,7 +736,7 @@ fn save_pathless_screenshot(img: &image::RgbaImage, token: u64) -> std::io::Resu
|
||||
let path = dir.join(format!("cadcraft-shot-{token}-{}.png", next_pathless_nonce()));
|
||||
match create_private_file(&path) {
|
||||
Ok(mut file) => {
|
||||
let written = img.write_to(&mut file, image::ImageFormat::Png).map_err(std::io::Error::other).and_then(|()| file.flush());
|
||||
let written = write_screenshot_png(img, &mut file).and_then(|()| file.flush());
|
||||
if let Err(e) = written {
|
||||
// The reply carries no path on failure, so nobody else could remove the partial file.
|
||||
drop(file);
|
||||
@@ -752,7 +775,7 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>, token: u64)
|
||||
return inline_screenshot(&img, token);
|
||||
}
|
||||
let saved = match path {
|
||||
Some(path) => img.save(path).map(|()| path.to_string()).map_err(std::io::Error::other),
|
||||
Some(path) => save_explicit_screenshot(&img, path).map(|()| path.to_string()),
|
||||
None => save_pathless_screenshot(&img, token).map(|path| path.to_string_lossy().into_owned()),
|
||||
};
|
||||
match saved {
|
||||
@@ -766,7 +789,7 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>, token: u64)
|
||||
fn inline_screenshot(img: &image::RgbaImage, token: u64) -> Value {
|
||||
let (w, h) = img.dimensions();
|
||||
let mut png = Vec::new();
|
||||
if let Err(e) = img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png) {
|
||||
if let Err(e) = write_screenshot_png(img, &mut png) {
|
||||
return json!({"ok": false, "error": e.to_string(), "request": token});
|
||||
}
|
||||
json!({"ok": true, "request": token, "result": {"pngBase64": cadcraft_engine::cmd::file::base64_encode(&png), "width": w, "height": h, "bytes": png.len()}})
|
||||
@@ -776,6 +799,25 @@ fn inline_screenshot(img: &image::RgbaImage, token: u64) -> Value {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn explicit_screenshot_retains_supported_file_formats() {
|
||||
let img = image::RgbaImage::from_pixel(3, 2, image::Rgba([10, 20, 30, 128]));
|
||||
for ext in ["png", "bmp", "tiff", "jpg"] {
|
||||
let path = std::env::temp_dir().join(format!("cadcraft-format-{}-{}.{}", std::process::id(), next_pathless_nonce(), ext));
|
||||
let name = path.to_string_lossy().to_string();
|
||||
save_explicit_screenshot(&img, &name).unwrap();
|
||||
let decoded = image::open(&path).unwrap().to_rgba8();
|
||||
assert_eq!(decoded.dimensions(), img.dimensions(), "{ext}");
|
||||
if ext != "jpg" {
|
||||
let mut original = std::io::Cursor::new(Vec::new());
|
||||
img.write_to(&mut original, image::ImageFormat::from_path(&path).unwrap()).unwrap();
|
||||
let original = image::load_from_memory(&original.into_inner()).unwrap().to_rgba8();
|
||||
assert_eq!(decoded.as_raw(), original.as_raw(), "{ext}");
|
||||
}
|
||||
std::fs::remove_file(path).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_inline_screenshot_carries_the_png_and_its_size() {
|
||||
let img = image::RgbaImage::from_pixel(3, 2, image::Rgba([10, 20, 30, 255]));
|
||||
|
||||
+99
-170
@@ -28,7 +28,6 @@ pub fn show(app: &mut CadApp, ctx: &egui::Context) {
|
||||
"about" => about(ctx, &mut open),
|
||||
"preview" => crate::exchange::dialog(app, ctx, &mut open),
|
||||
"commands" => commands(app, ctx, &mut open),
|
||||
"blocks" => blocks(app, ctx, &mut open),
|
||||
"bedit" => crate::bedit::dialog(app, ctx, &mut open),
|
||||
"authoring" => crate::bedit::authoring_dialog(app, ctx, &mut open),
|
||||
"stylesmanager" => crate::plotstyles::dialog(app, ctx, &mut open),
|
||||
@@ -46,104 +45,112 @@ pub fn show(app: &mut CadApp, ctx: &egui::Context) {
|
||||
fn dsettings(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
let settings = app.session.drafting_settings();
|
||||
let (mut snapunit, mut gridunit) = (settings.snapunit, settings.gridunit);
|
||||
egui::Window::new(crate::tl!("Drafting Settings")).id(egui::Id::unique("Drafting Settings")).open(open).resizable(false).show(ctx, |ui| {
|
||||
let s = &mut app.session.settings;
|
||||
ui.heading(crate::tl!("Snap and Grid"));
|
||||
ui.checkbox(&mut s.snapmode, crate::tl!("Snap On (F9)"));
|
||||
// SNAPSTYL: the isometric snap and grid (ISODRAFT).
|
||||
ui.horizontal(|ui| {
|
||||
ui.radio_value(&mut s.isodraft, false, crate::tl!("Rectangular snap"));
|
||||
ui.radio_value(&mut s.isodraft, true, crate::tl!("Isometric snap"));
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
let x_label = ui.label(crate::tl!("Snap X spacing"));
|
||||
ui.add(egui::DragValue::new(&mut snapunit.x).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(x_label.id);
|
||||
let y_label = ui.label(crate::tl!("Y"));
|
||||
ui.add(egui::DragValue::new(&mut snapunit.y).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(y_label.id);
|
||||
});
|
||||
// SNAPTYPE and POLARDIST.
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(crate::tl!("Snap type"));
|
||||
ui.radio_value(&mut s.polarsnap, false, crate::tl!("Grid snap"));
|
||||
ui.radio_value(&mut s.polarsnap, true, crate::tl!("PolarSnap"));
|
||||
});
|
||||
ui.add_enabled_ui(s.polarsnap, |ui| {
|
||||
let window = egui::Window::new(crate::tl!("Drafting Settings")).id(egui::Id::unique("Drafting Settings")).open(open).resizable(false);
|
||||
// Taller than a short screen, so the options scroll to keep the window on screen and every one
|
||||
// reachable (#2339). Asking for the screen's height every frame (egui caps it to the screen)
|
||||
// gives the scroll area all of it, not the 420-point default or a height kept from a shorter
|
||||
// screen; the window still takes the height of its contents when they fit.
|
||||
let window = window.min_height(ctx.content_rect().height());
|
||||
window.show(ctx, |ui| {
|
||||
egui::ScrollArea::vertical().show(ui, |ui| {
|
||||
let s = &mut app.session.settings;
|
||||
ui.heading(crate::tl!("Snap and Grid"));
|
||||
ui.checkbox(&mut s.snapmode, crate::tl!("Snap On (F9)"));
|
||||
// SNAPSTYL: the isometric snap and grid (ISODRAFT).
|
||||
ui.horizontal(|ui| {
|
||||
let label = ui.label(crate::tl!("Polar distance"));
|
||||
ui.add(egui::DragValue::new(&mut s.polardist).speed(0.05).range(0.0..=1e6)).labelled_by(label.id);
|
||||
ui.radio_value(&mut s.isodraft, false, crate::tl!("Rectangular snap"));
|
||||
ui.radio_value(&mut s.isodraft, true, crate::tl!("Isometric snap"));
|
||||
});
|
||||
});
|
||||
ui.checkbox(&mut s.gridmode, crate::tl!("Grid On (F7)"));
|
||||
ui.horizontal(|ui| {
|
||||
let grid_label = ui.label(crate::tl!("Grid spacing"));
|
||||
ui.add(egui::DragValue::new(&mut gridunit.x).speed(0.05).range(0.0..=1e6).clamp_existing_to_range(false)).labelled_by(grid_label.id);
|
||||
let major_label = ui.label(crate::tl!("Major line every"));
|
||||
ui.add(egui::DragValue::new(&mut s.gridmajor).range(1..=100)).labelled_by(major_label.id);
|
||||
});
|
||||
ui.separator();
|
||||
ui.heading(crate::tl!("Polar Tracking"));
|
||||
ui.checkbox(&mut s.polarmode, crate::tl!("Polar Tracking On (F10)"));
|
||||
// POLARANG is held in radians and 15 or 30 come back as 14.999999999999998: round like
|
||||
// the additional angles, and write back only a newly picked angle.
|
||||
let current = (s.polarang.to_degrees() * 1e6).round() / 1e6;
|
||||
let mut deg = current;
|
||||
ui.horizontal(|ui| {
|
||||
let label = ui.label(crate::tl!("Increment angle"));
|
||||
let combo = craft_ui::ComboBox::from_id_salt("polarang").selected_text(format!("{deg}")).show_ui(ui, |ui| {
|
||||
for a in [90.0, 45.0, 30.0, 22.5, 18.0, 15.0, 10.0, 5.0] {
|
||||
ui.selectable_value(&mut deg, a, format!("{a}"));
|
||||
}
|
||||
ui.horizontal(|ui| {
|
||||
let x_label = ui.label(crate::tl!("Snap X spacing"));
|
||||
ui.add(egui::DragValue::new(&mut snapunit.x).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(x_label.id);
|
||||
let y_label = ui.label(crate::tl!("Y"));
|
||||
ui.add(egui::DragValue::new(&mut snapunit.y).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(y_label.id);
|
||||
});
|
||||
combo.response.labelled_by(label.id);
|
||||
});
|
||||
if deg != current {
|
||||
s.polarang = deg.to_radians();
|
||||
}
|
||||
tracking_options(ui, s);
|
||||
ui.separator();
|
||||
ui.heading(crate::tl!("Object Snap"));
|
||||
let mut on = s.osmode & cadcraft_engine::snap::mode::OFF == 0;
|
||||
if ui.checkbox(&mut on, crate::tl!("Object Snap On (F3)")).changed() {
|
||||
if on {
|
||||
s.osmode &= !cadcraft_engine::snap::mode::OFF;
|
||||
} else {
|
||||
s.osmode |= cadcraft_engine::snap::mode::OFF;
|
||||
// SNAPTYPE and POLARDIST.
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(crate::tl!("Snap type"));
|
||||
ui.radio_value(&mut s.polarsnap, false, crate::tl!("Grid snap"));
|
||||
ui.radio_value(&mut s.polarsnap, true, crate::tl!("PolarSnap"));
|
||||
});
|
||||
ui.add_enabled_ui(s.polarsnap, |ui| {
|
||||
ui.horizontal(|ui| {
|
||||
let label = ui.label(crate::tl!("Polar distance"));
|
||||
ui.add(egui::DragValue::new(&mut s.polardist).speed(0.05).range(0.0..=1e6)).labelled_by(label.id);
|
||||
});
|
||||
});
|
||||
ui.checkbox(&mut s.gridmode, crate::tl!("Grid On (F7)"));
|
||||
ui.horizontal(|ui| {
|
||||
let grid_label = ui.label(crate::tl!("Grid spacing"));
|
||||
ui.add(egui::DragValue::new(&mut gridunit.x).speed(0.05).range(0.0..=1e6).clamp_existing_to_range(false)).labelled_by(grid_label.id);
|
||||
let major_label = ui.label(crate::tl!("Major line every"));
|
||||
ui.add(egui::DragValue::new(&mut s.gridmajor).range(1..=100)).labelled_by(major_label.id);
|
||||
});
|
||||
ui.separator();
|
||||
ui.heading(crate::tl!("Polar Tracking"));
|
||||
ui.checkbox(&mut s.polarmode, crate::tl!("Polar Tracking On (F10)"));
|
||||
// POLARANG is held in radians and 15 or 30 come back as 14.999999999999998: round like
|
||||
// the additional angles, and write back only a newly picked angle.
|
||||
let current = (s.polarang.to_degrees() * 1e6).round() / 1e6;
|
||||
let mut deg = current;
|
||||
ui.horizontal(|ui| {
|
||||
let label = ui.label(crate::tl!("Increment angle"));
|
||||
let combo = craft_ui::ComboBox::from_id_salt("polarang").selected_text(format!("{deg}")).show_ui(ui, |ui| {
|
||||
for a in [90.0, 45.0, 30.0, 22.5, 18.0, 15.0, 10.0, 5.0] {
|
||||
ui.selectable_value(&mut deg, a, format!("{a}"));
|
||||
}
|
||||
});
|
||||
combo.response.labelled_by(label.id);
|
||||
});
|
||||
if deg != current {
|
||||
s.polarang = deg.to_radians();
|
||||
}
|
||||
}
|
||||
egui::Grid::new("osnap_grid").num_columns(2).show(ui, |ui| {
|
||||
for (i, (bit, name)) in cadcraft_engine::snap::mode::ALL.iter().enumerate() {
|
||||
let mut v = s.osmode & bit != 0;
|
||||
if ui.checkbox(&mut v, crate::i18n::t(name)).changed() {
|
||||
if v {
|
||||
s.osmode |= bit;
|
||||
} else {
|
||||
s.osmode &= !bit;
|
||||
tracking_options(ui, s);
|
||||
ui.separator();
|
||||
ui.heading(crate::tl!("Object Snap"));
|
||||
let mut on = s.osmode & cadcraft_engine::snap::mode::OFF == 0;
|
||||
if ui.checkbox(&mut on, crate::tl!("Object Snap On (F3)")).changed() {
|
||||
if on {
|
||||
s.osmode &= !cadcraft_engine::snap::mode::OFF;
|
||||
} else {
|
||||
s.osmode |= cadcraft_engine::snap::mode::OFF;
|
||||
}
|
||||
}
|
||||
egui::Grid::new("osnap_grid").num_columns(2).show(ui, |ui| {
|
||||
for (i, (bit, name)) in cadcraft_engine::snap::mode::ALL.iter().enumerate() {
|
||||
let mut v = s.osmode & bit != 0;
|
||||
if ui.checkbox(&mut v, crate::i18n::t(name)).changed() {
|
||||
if v {
|
||||
s.osmode |= bit;
|
||||
} else {
|
||||
s.osmode &= !bit;
|
||||
}
|
||||
}
|
||||
if i % 2 == 1 {
|
||||
ui.end_row();
|
||||
}
|
||||
}
|
||||
if i % 2 == 1 {
|
||||
ui.end_row();
|
||||
}
|
||||
}
|
||||
});
|
||||
ui.separator();
|
||||
ui.checkbox(&mut s.dynmode, crate::tl!("Enable Dynamic Input (F12)"));
|
||||
// Pointer input format for second and next points (DYNPIFORMAT, DYNPICOORDS).
|
||||
ui.indent("dynpi", |ui| {
|
||||
ui.add_enabled_ui(s.dynmode, |ui| {
|
||||
ui.label(crate::tl!("Second and next points:"));
|
||||
ui.horizontal(|ui| {
|
||||
ui.radio_value(&mut s.dynpi_cartesian, false, crate::tl!("Polar (distance < angle)"));
|
||||
ui.radio_value(&mut s.dynpi_cartesian, true, crate::tl!("Cartesian (x, y)"));
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
ui.radio_value(&mut s.dynpi_absolute, false, crate::tl!("Relative"));
|
||||
ui.radio_value(&mut s.dynpi_absolute, true, crate::tl!("Absolute"));
|
||||
});
|
||||
// DYNPROMPT: the prompt and its options (Down Arrow) beside the cursor.
|
||||
ui.checkbox(&mut s.dynprompt, crate::tl!("Show command prompting near the crosshairs"));
|
||||
});
|
||||
});
|
||||
ui.checkbox(&mut s.orthomode, crate::tl!("Ortho (F8)"));
|
||||
ui.separator();
|
||||
ui.checkbox(&mut s.dynmode, crate::tl!("Enable Dynamic Input (F12)"));
|
||||
// Pointer input format for second and next points (DYNPIFORMAT, DYNPICOORDS).
|
||||
ui.indent("dynpi", |ui| {
|
||||
ui.add_enabled_ui(s.dynmode, |ui| {
|
||||
ui.label(crate::tl!("Second and next points:"));
|
||||
ui.horizontal(|ui| {
|
||||
ui.radio_value(&mut s.dynpi_cartesian, false, crate::tl!("Polar (distance < angle)"));
|
||||
ui.radio_value(&mut s.dynpi_cartesian, true, crate::tl!("Cartesian (x, y)"));
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
ui.radio_value(&mut s.dynpi_absolute, false, crate::tl!("Relative"));
|
||||
ui.radio_value(&mut s.dynpi_absolute, true, crate::tl!("Absolute"));
|
||||
});
|
||||
// DYNPROMPT: the prompt and its options (Down Arrow) beside the cursor.
|
||||
ui.checkbox(&mut s.dynprompt, crate::tl!("Show command prompting near the crosshairs"));
|
||||
});
|
||||
});
|
||||
ui.checkbox(&mut s.orthomode, crate::tl!("Ortho (F8)"));
|
||||
})
|
||||
});
|
||||
// Drawing edits go through the same command as the CLI, including dirty state and undo.
|
||||
for (name, before, after) in [("SNAPUNIT", settings.snapunit, snapunit), ("GRIDUNIT", settings.gridunit, gridunit)] {
|
||||
@@ -399,38 +406,6 @@ fn commands(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Blocks window listing named (non-anonymous) blocks; clicking one starts INSERT with that block name already supplied.
|
||||
fn blocks(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
let mut pick = None;
|
||||
egui::Window::new(crate::tl!("Blocks")).id(egui::Id::unique("Blocks")).open(open).default_size(vec2(320.0, 360.0)).show(ctx, |ui| {
|
||||
let Ok(d) = app.session.doc() else { return };
|
||||
let names: Vec<&String> = d.blocks.keys().filter(|k| !k.starts_with('*')).collect();
|
||||
if names.is_empty() {
|
||||
ui.label(crate::tl!("No blocks defined in this drawing."));
|
||||
}
|
||||
for n in names {
|
||||
if ui.button(n).on_hover_text(crate::tl!("Insert this block")).clicked() {
|
||||
pick = Some(n.clone());
|
||||
}
|
||||
}
|
||||
});
|
||||
if let Some(n) = pick {
|
||||
insert_block(app, &n);
|
||||
}
|
||||
}
|
||||
|
||||
/// Start INSERT with `name` already given at its block name prompt, so the next prompt asks for
|
||||
/// the insertion point.
|
||||
fn insert_block(app: &mut CadApp, name: &str) {
|
||||
app.start("insert");
|
||||
if app.session.running.as_ref().is_none_or(|r| r.id != "insert") {
|
||||
return;
|
||||
}
|
||||
if let Err(e) = app.session.input(cadcraft_engine::Input::Text(name.to_string())) {
|
||||
app.session.echo(e.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
/// Interface Language combo; selecting a language runs `ui.language` with its code.
|
||||
fn language(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
egui::Window::new(crate::tl!("Interface Language")).id(egui::Id::unique("interface_language")).open(open).resizable(false).show(ctx, |ui| {
|
||||
@@ -447,13 +422,6 @@ fn language(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use cadcraft_engine::doc::EntityKind;
|
||||
use cadcraft_engine::geom::Vec2;
|
||||
use cadcraft_engine::{Input, Session};
|
||||
use serde_json::json;
|
||||
|
||||
use crate::{CadApp, Services};
|
||||
|
||||
#[test]
|
||||
fn fractional_length_precisions_list_binary_fractions() {
|
||||
let labels = ["1\"", "1/2\"", "1/4\"", "1/8\"", "1/16\"", "1/32\"", "1/64\"", "1/128\"", "1/256\""];
|
||||
@@ -462,43 +430,4 @@ mod tests {
|
||||
assert_eq!(super::length_precisions(5), want);
|
||||
assert_eq!(super::length_precisions(2).len(), 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn picking_a_block_starts_insert_with_its_name() {
|
||||
let mut app = CadApp::new(Session::new(), Services::default());
|
||||
let c = app.session.execute("circle", &json!({"center": [0, 0], "radius": 1})).unwrap();
|
||||
let h = c["handle"].as_str().unwrap().to_string();
|
||||
app.session.execute("block", &json!({"name": "Door 2", "base": [0, 0], "handles": [h], "keep": "delete"})).unwrap();
|
||||
// A command already running is replaced, as when a command is typed.
|
||||
app.start("line");
|
||||
|
||||
super::insert_block(&mut app, "Door 2");
|
||||
assert!(app.session.running.as_ref().is_some_and(|r| r.id == "insert"));
|
||||
assert_eq!(app.session.current_prompt().map(|p| p.message), Some("Specify insertion point".to_string()));
|
||||
|
||||
app.session.input(Input::Point(Vec2::new(5.0, 6.0))).unwrap();
|
||||
// X scale, Y scale and rotation take their defaults.
|
||||
for _ in 0..3 {
|
||||
app.session.input(Input::Enter).unwrap();
|
||||
}
|
||||
assert!(app.session.running.is_none());
|
||||
let d = app.session.doc().unwrap();
|
||||
let mut ins = Vec::new();
|
||||
for e in d.model.iter() {
|
||||
if let EntityKind::Insert(i) = &e.kind {
|
||||
ins.push(i.clone());
|
||||
}
|
||||
}
|
||||
assert_eq!(ins.len(), 1);
|
||||
assert_eq!(ins[0].block, "Door 2");
|
||||
assert!((ins[0].insert.x - 5.0).abs() < 1e-9 && (ins[0].insert.y - 6.0).abs() < 1e-9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn picking_a_missing_block_keeps_asking_for_a_name() {
|
||||
let mut app = CadApp::new(Session::new(), Services::default());
|
||||
super::insert_block(&mut app, "Nope");
|
||||
assert!(app.session.running.as_ref().is_some_and(|r| r.id == "insert"));
|
||||
assert_eq!(app.session.current_prompt().map(|p| p.message), Some("Enter block name".to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,6 +19,7 @@ pub enum Panel {
|
||||
Properties,
|
||||
#[serde(rename = "externalReferences")]
|
||||
ExternalRefs,
|
||||
Blocks,
|
||||
}
|
||||
|
||||
impl Panel {
|
||||
@@ -31,6 +32,7 @@ impl Panel {
|
||||
Self::Layers => "layers",
|
||||
Self::Properties => "properties",
|
||||
Self::ExternalRefs => "externalReferences",
|
||||
Self::Blocks => "blocks",
|
||||
}
|
||||
}
|
||||
fn label(self) -> &'static str {
|
||||
@@ -41,6 +43,7 @@ impl Panel {
|
||||
Self::Layers => "Layers",
|
||||
Self::Properties => "Properties",
|
||||
Self::ExternalRefs => "External References",
|
||||
Self::Blocks => "Blocks",
|
||||
}
|
||||
}
|
||||
/// The icon a palette shows in a column collapsed to icons.
|
||||
@@ -53,10 +56,11 @@ impl Panel {
|
||||
Self::Layers => Some(Icon::Layers),
|
||||
Self::Properties => Some(Icon::Properties),
|
||||
Self::ExternalRefs => Some(Icon::Attach),
|
||||
Self::Blocks => Some(Icon::Blocks),
|
||||
}
|
||||
}
|
||||
/// Palettes outside the default arrangement, opened on request (QUICKCALC).
|
||||
pub const ON_DEMAND: &[Self] = &[Self::QuickCalc];
|
||||
pub const ON_DEMAND: &[Self] = &[Self::QuickCalc, Self::Blocks];
|
||||
}
|
||||
|
||||
/// The drawing view never moves, floats, closes or takes tabs; palettes dock beside it.
|
||||
@@ -149,6 +153,7 @@ fn home_anchor(layout: &Layout<Panel>, panel: Panel) -> Option<(Panel, bool)> {
|
||||
Panel::Properties => &[(Panel::Layers, true), (Panel::ExternalRefs, false)],
|
||||
Panel::ExternalRefs => &[(Panel::Properties, true), (Panel::Layers, true)],
|
||||
Panel::QuickCalc => &[(Panel::ExternalRefs, true), (Panel::Properties, true), (Panel::Layers, true)],
|
||||
Panel::Blocks => &[(Panel::QuickCalc, true), (Panel::ExternalRefs, true), (Panel::Properties, true), (Panel::Layers, true)],
|
||||
};
|
||||
if let Some(found) = neighbours.iter().copied().find(|(neighbour, _)| docked(layout, *neighbour)) {
|
||||
return Some(found);
|
||||
@@ -414,6 +419,12 @@ impl DockContent<Panel> for Panels<'_> {
|
||||
Panel::ExternalRefs => {
|
||||
egui::ScrollArea::both().id_salt("dock-xrefs").auto_shrink([false, false]).show(ui, |ui| crate::xrefs::section(app, ui));
|
||||
}
|
||||
Panel::Blocks => {
|
||||
egui::ScrollArea::vertical()
|
||||
.id_salt("dock-blocks")
|
||||
.auto_shrink([false, false])
|
||||
.show(ui, |ui| crate::blocks_palette::section(app, ui));
|
||||
}
|
||||
}
|
||||
}
|
||||
fn logical_label(&self, panel: &Panel) -> String {
|
||||
@@ -442,6 +453,7 @@ fn panel_limits(panel: &Panel) -> PanelLimits {
|
||||
Panel::QuickCalc => (egui::vec2(240.0, 160.0), 600.0),
|
||||
Panel::ToolSets => (egui::vec2(220.0, 150.0), 480.0),
|
||||
Panel::Layers | Panel::Properties | Panel::ExternalRefs => (egui::vec2(220.0, 100.0), 720.0),
|
||||
Panel::Blocks => (egui::vec2(240.0, 260.0), 720.0),
|
||||
};
|
||||
PanelLimits { min, max: egui::vec2(max_width, 1_000_000.0) }
|
||||
}
|
||||
|
||||
@@ -70,16 +70,12 @@ fn render(app: &mut CadApp, ctx: &egui::Context) -> Result<(TextureHandle, Strin
|
||||
if let Some(f) = ctx.data(|d| d.get_temp::<FromPlot>(egui::Id::unique(FROM_PLOT))) {
|
||||
let r = app.session.execute("plot", &f.params).map_err(|e| e.to_string())?;
|
||||
let png = r["data"].as_str().and_then(cadcraft_engine::cmd::file::base64_decode).ok_or("the preview has no image")?;
|
||||
let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| e.to_string())?.to_rgba8();
|
||||
let size = [img.width() as usize, img.height() as usize];
|
||||
let tex = ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR);
|
||||
let tex = preview_texture(ctx, &png)?;
|
||||
return Ok((tex, f.info));
|
||||
}
|
||||
let r = app.session.execute("preview", &json!({ "width": 1600 })).map_err(|e| e.to_string())?;
|
||||
let png = r["data"].as_str().and_then(cadcraft_engine::cmd::file::base64_decode).ok_or("the preview has no image")?;
|
||||
let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| e.to_string())?.to_rgba8();
|
||||
let size = [img.width() as usize, img.height() as usize];
|
||||
let tex = ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR);
|
||||
let tex = preview_texture(ctx, &png)?;
|
||||
let mut info = format!("{} · {}", r["layout"].as_str().unwrap_or(""), r["paper"].as_str().unwrap_or(""));
|
||||
if r["landscape"].as_bool() == Some(true) {
|
||||
info.push_str(" · landscape");
|
||||
@@ -87,6 +83,15 @@ fn render(app: &mut CadApp, ctx: &egui::Context) -> Result<(TextureHandle, Strin
|
||||
Ok((tex, info))
|
||||
}
|
||||
|
||||
fn preview_texture(ctx: &egui::Context, png: &[u8]) -> Result<TextureHandle, String> {
|
||||
if !png.starts_with(b"\x89PNG\r\n\x1a\n") {
|
||||
return Err("the preview is not a PNG".into());
|
||||
}
|
||||
let img = cadcraft_io::raster::decode(png).map_err(|e| e.to_string())?;
|
||||
let size = [img.width() as usize, img.height() as usize];
|
||||
Ok(ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.rgba()), egui::TextureOptions::LINEAR))
|
||||
}
|
||||
|
||||
/// The Plot Preview window: the sheet as it plots, with Print and Close.
|
||||
pub fn dialog(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
|
||||
let id = egui::Id::unique("cc_plot_preview");
|
||||
@@ -169,6 +174,16 @@ mod tests {
|
||||
(CadApp::new(Session::new(), services), asked)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plot_preview_reads_shared_png_and_rejects_other_bytes() {
|
||||
let ctx = egui::Context::default();
|
||||
let mut png = Vec::new();
|
||||
cadcraft_render::raster::write_rgba_png(&mut png, 1, 1, &[10, 20, 30, 255]).unwrap();
|
||||
let texture = super::preview_texture(&ctx, &png).unwrap();
|
||||
assert_eq!(texture.size(), [1, 1]);
|
||||
assert!(super::preview_texture(&ctx, b"not a PNG").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_and_menu_commands_ask_json_calls_never_do() {
|
||||
let (mut app, asked) = app();
|
||||
|
||||
@@ -906,6 +906,7 @@
|
||||
Set Current Viewport تعيين إطار العرض الحالي
|
||||
Set Layer Properties تعيين خصائص الطبقة
|
||||
Set Properties تعيين الخصائص
|
||||
Describe Properties وصف الخصائص
|
||||
Set Table Cell تعيين خلية الجدول
|
||||
Set Table Cell Style تعيين نمط خلية الجدول
|
||||
Set Variable تعيين متغير
|
||||
@@ -1368,6 +1369,33 @@ menu View عرض
|
||||
overrides built-in يتجاوز المدمج
|
||||
{alias} is already defined; select it and use Edit. {alias} معرَّف مسبقاً؛ حدده واستخدم «تحرير».
|
||||
{command} is an unknown command. {command} أمر غير معروف.
|
||||
Add a drawing file as a block library إضافة ملف رسم كمكتبة كتل
|
||||
Add a folder of drawings or a drawing file to use its blocks. أضف مجلدًا يحتوي على رسومات أو ملف رسم لاستخدام كتله.
|
||||
Block Libraries مكتبات الكتل
|
||||
Block Library مكتبة الكتل
|
||||
Blocks Palette لوحة الكتل
|
||||
Click a block, then pick its insertion point. انقر على كتلة ثم حدّد نقطة إدراجها.
|
||||
Current Drawing الرسم الحالي
|
||||
Details التفاصيل
|
||||
Extra Large Icons أيقونات كبيرة جدًا
|
||||
Folder or file مجلد أو ملف
|
||||
Import Library Block استيراد كتلة من المكتبة
|
||||
Insert and Explode إدراج وتفجير
|
||||
Large Icons أيقونات كبيرة
|
||||
Libraries المكتبات
|
||||
Medium Icons أيقونات متوسطة
|
||||
No block matches the filter. لا توجد كتلة تطابق عامل التصفية.
|
||||
This block is already in the drawing, so its definition is used. هذه الكتلة موجودة بالفعل في الرسم، لذلك يتم استخدام تعريفها.
|
||||
Open Library... فتح مكتبة...
|
||||
Read the library again إعادة قراءة المكتبة
|
||||
Reading the library... جارٍ قراءة المكتبة...
|
||||
Refresh تحديث
|
||||
Remove from the list إزالة من القائمة
|
||||
Repeat Placement تكرار الوضع
|
||||
Small Icons أيقونات صغيرة
|
||||
This drawing has no blocks. لا يحتوي هذا الرسم على كتل.
|
||||
This library has no drawings or blocks. لا تحتوي هذه المكتبة على رسومات أو كتل.
|
||||
Only the first {n} are shown. يتم عرض أول {n} فقط.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 1336 and column 24.
|
@@ -1444,6 +1444,33 @@ menu Modify Izmijeni
|
||||
Save changes to block "{name}"? Sačuvati promjene u bloku „{name}”?
|
||||
Layouts Rasporedi
|
||||
Associate Poveži
|
||||
Add a drawing file as a block library Dodaj datoteku crteža kao biblioteku blokova
|
||||
Add a folder of drawings or a drawing file to use its blocks. Dodajte mapu s crtežima ili datoteku crteža da biste koristili njene blokove.
|
||||
Block Libraries Biblioteke blokova
|
||||
Block Library Biblioteka blokova
|
||||
Blocks Palette Paleta blokova
|
||||
Click a block, then pick its insertion point. Kliknite na blok, zatim odredite njegovu tačku umetanja.
|
||||
Current Drawing Trenutni crtež
|
||||
Details Detalji
|
||||
Extra Large Icons Veoma velike ikone
|
||||
Folder or file Mapa ili datoteka
|
||||
Import Library Block Uvezi blok iz biblioteke
|
||||
Insert and Explode Umetni i rastavi
|
||||
Large Icons Velike ikone
|
||||
Libraries Biblioteke
|
||||
Medium Icons Srednje ikone
|
||||
No block matches the filter. Nijedan blok ne odgovara filteru.
|
||||
This block is already in the drawing, so its definition is used. Ovaj blok već postoji u crtežu, pa se koristi njegova definicija.
|
||||
Open Library... Otvori biblioteku...
|
||||
Read the library again Ponovo učitaj biblioteku
|
||||
Reading the library... Čitanje biblioteke...
|
||||
Refresh Osvježi
|
||||
Remove from the list Ukloni s liste
|
||||
Repeat Placement Ponovi postavljanje
|
||||
Small Icons Male ikone
|
||||
This drawing has no blocks. Ovaj crtež nema blokova.
|
||||
This library has no drawings or blocks. Ova biblioteka nema crteža ni blokova.
|
||||
Only the first {n} are shown. Prikazano je samo prvih {n}.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 1444 and column 24.
|
@@ -840,6 +840,7 @@
|
||||
Set Current Viewport Nastavit aktuální výřez
|
||||
Set Layer Properties Nastavit vlastnosti hladiny
|
||||
Set Properties Nastavit vlastnosti
|
||||
Describe Properties Popsat vlastnosti
|
||||
Set Table Cell Nastavit buňku tabulky
|
||||
Set Table Cell Style Nastavit styl buňky tabulky
|
||||
Set Variable Nastavit proměnnou
|
||||
@@ -1224,6 +1225,33 @@ menu Modify Modifikace
|
||||
Check for Updates… Zkontrolovat aktualizace…
|
||||
CADCraft is up to date. CADCraft je aktuální.
|
||||
Could not check for updates. Aktualizace se nepodařilo zkontrolovat.
|
||||
Add a drawing file as a block library Přidat výkresový soubor jako knihovnu bloků
|
||||
Add a folder of drawings or a drawing file to use its blocks. Přidejte složku s výkresy nebo výkresový soubor, abyste mohli používat jeho bloky.
|
||||
Block Libraries Knihovny bloků
|
||||
Block Library Knihovna bloků
|
||||
Blocks Palette Paleta bloků
|
||||
Click a block, then pick its insertion point. Klikněte na blok a poté určete jeho vkládací bod.
|
||||
Current Drawing Aktuální výkres
|
||||
Details Podrobnosti
|
||||
Extra Large Icons Extra velké ikony
|
||||
Folder or file Složka nebo soubor
|
||||
Import Library Block Importovat blok z knihovny
|
||||
Insert and Explode Vložit a rozložit
|
||||
Large Icons Velké ikony
|
||||
Libraries Knihovny
|
||||
Medium Icons Střední ikony
|
||||
No block matches the filter. Filtru neodpovídá žádný blok.
|
||||
This block is already in the drawing, so its definition is used. Tento blok už v kresbě je, proto se použije jeho definice.
|
||||
Open Library... Otevřít knihovnu...
|
||||
Read the library again Načíst knihovnu znovu
|
||||
Reading the library... Načítání knihovny...
|
||||
Refresh Obnovit
|
||||
Remove from the list Odebrat ze seznamu
|
||||
Repeat Placement Opakovat umístění
|
||||
Small Icons Malé ikony
|
||||
This drawing has no blocks. Tento výkres neobsahuje žádné bloky.
|
||||
This library has no drawings or blocks. Tato knihovna neobsahuje žádné výkresy ani bloky.
|
||||
Only the first {n} are shown. Zobrazuje se pouze prvních {n}.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -729,6 +729,7 @@
|
||||
Set Current Text Style Textstil als aktuell festlegen
|
||||
Set Layer Properties Layer-Eigenschaften festlegen
|
||||
Set Properties Eigenschaften festlegen
|
||||
Describe Properties Eigenschaften beschreiben
|
||||
Set Table Cell Tabellenzelle festlegen
|
||||
Set Variable Variable festlegen
|
||||
Set View Ansicht festlegen
|
||||
@@ -1041,6 +1042,34 @@
|
||||
Check for Updates… Nach Updates suchen…
|
||||
CADCraft is up to date. CADCraft ist auf dem neuesten Stand.
|
||||
Could not check for updates. Die Suche nach Updates ist fehlgeschlagen.
|
||||
Add a drawing file as a block library Zeichnungsdatei als Blockbibliothek hinzufügen
|
||||
Add a folder of drawings or a drawing file to use its blocks. Fügen Sie einen Ordner mit Zeichnungen oder eine Zeichnungsdatei hinzu, um deren Blöcke zu verwenden.
|
||||
Block Libraries Blockbibliotheken
|
||||
Block Library Blockbibliothek
|
||||
Blocks Palette Blockpalette
|
||||
Click a block, then pick its insertion point. Klicken Sie auf einen Block und geben Sie dann den Einfügepunkt an.
|
||||
Current Drawing Aktuelle Zeichnung
|
||||
Details Details
|
||||
Extra Large Icons Extragroße Symbole
|
||||
Folder or file Ordner oder Datei
|
||||
Import Library Block Bibliotheksblock importieren
|
||||
Insert and Explode Einfügen und auflösen
|
||||
Large Icons Große Symbole
|
||||
Libraries Bibliotheken
|
||||
Medium Icons Mittelgroße Symbole
|
||||
No block matches the filter. Kein Block entspricht dem Filter.
|
||||
This block is already in the drawing, so its definition is used. Dieser Block ist bereits in der Zeichnung, daher wird seine Definition verwendet.
|
||||
Open Library... Bibliothek öffnen...
|
||||
Read the library again Bibliothek erneut lesen
|
||||
Reading the library... Bibliothek wird gelesen...
|
||||
Refresh Aktualisieren
|
||||
Remove from the list Aus der Liste entfernen
|
||||
Repeat Placement Platzierung wiederholen
|
||||
Small Icons Kleine Symbole
|
||||
This drawing has no blocks. Diese Zeichnung enthält keine Blöcke.
|
||||
This library has no drawings or blocks. Diese Bibliothek enthält keine Zeichnungen oder Blöcke.
|
||||
Options Optionen
|
||||
Only the first {n} are shown. Nur die ersten {n} werden angezeigt.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -1381,6 +1381,33 @@ menu View Προβολή
|
||||
Check for Updates… Έλεγχος για ενημερώσεις…
|
||||
CADCraft is up to date. Το CADCraft είναι ενημερωμένο.
|
||||
Could not check for updates. Δεν ήταν δυνατός ο έλεγχος για ενημερώσεις.
|
||||
Add a drawing file as a block library Προσθήκη αρχείου σχεδίου ως βιβλιοθήκης μπλοκ
|
||||
Add a folder of drawings or a drawing file to use its blocks. Προσθέστε έναν φάκελο με σχέδια ή ένα αρχείο σχεδίου για να χρησιμοποιήσετε τα μπλοκ του.
|
||||
Block Libraries Βιβλιοθήκες μπλοκ
|
||||
Block Library Βιβλιοθήκη μπλοκ
|
||||
Blocks Palette Παλέτα μπλοκ
|
||||
Click a block, then pick its insertion point. Κάντε κλικ σε ένα μπλοκ και μετά ορίστε το σημείο εισαγωγής του.
|
||||
Current Drawing Τρέχον σχέδιο
|
||||
Details Λεπτομέρειες
|
||||
Extra Large Icons Πολύ μεγάλα εικονίδια
|
||||
Folder or file Φάκελος ή αρχείο
|
||||
Import Library Block Εισαγωγή μπλοκ βιβλιοθήκης
|
||||
Insert and Explode Εισαγωγή και διάσπαση
|
||||
Large Icons Μεγάλα εικονίδια
|
||||
Libraries Βιβλιοθήκες
|
||||
Medium Icons Μεσαία εικονίδια
|
||||
No block matches the filter. Κανένα μπλοκ δεν ταιριάζει με το φίλτρο.
|
||||
This block is already in the drawing, so its definition is used. Αυτό το μπλοκ υπάρχει ήδη στο σχέδιο, οπότε χρησιμοποιείται ο ορισμός του.
|
||||
Open Library... Άνοιγμα βιβλιοθήκης...
|
||||
Read the library again Επανάγνωση της βιβλιοθήκης
|
||||
Reading the library... Ανάγνωση της βιβλιοθήκης...
|
||||
Refresh Ανανέωση
|
||||
Remove from the list Αφαίρεση από τη λίστα
|
||||
Repeat Placement Επανάληψη τοποθέτησης
|
||||
Small Icons Μικρά εικονίδια
|
||||
This drawing has no blocks. Αυτό το σχέδιο δεν έχει μπλοκ.
|
||||
This library has no drawings or blocks. Αυτή η βιβλιοθήκη δεν έχει σχέδια ή μπλοκ.
|
||||
Only the first {n} are shown. Εμφανίζονται μόνο τα πρώτα {n}.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 234 and column 24.
|
@@ -933,6 +933,7 @@
|
||||
Set Current Text Style Establecer estilo de texto actual
|
||||
Set Layer Properties Establecer propiedades de capa
|
||||
Set Properties Establecer propiedades
|
||||
Describe Properties Describir propiedades
|
||||
Set Table Cell Establecer celda de tabla
|
||||
Set Variable Establecer variable
|
||||
Set View Establecer vista
|
||||
@@ -1255,6 +1256,33 @@
|
||||
Check for Updates… Buscar actualizaciones…
|
||||
CADCraft is up to date. CADCraft está actualizado.
|
||||
Could not check for updates. No se pudo buscar actualizaciones.
|
||||
Add a drawing file as a block library Añadir un archivo de dibujo como biblioteca de bloques
|
||||
Add a folder of drawings or a drawing file to use its blocks. Añada una carpeta de dibujos o un archivo de dibujo para usar sus bloques.
|
||||
Block Libraries Bibliotecas de bloques
|
||||
Block Library Biblioteca de bloques
|
||||
Blocks Palette Paleta de bloques
|
||||
Click a block, then pick its insertion point. Haga clic en un bloque y luego indique su punto de inserción.
|
||||
Current Drawing Dibujo actual
|
||||
Details Detalles
|
||||
Extra Large Icons Iconos extragrandes
|
||||
Folder or file Carpeta o archivo
|
||||
Import Library Block Importar bloque de biblioteca
|
||||
Insert and Explode Insertar y descomponer
|
||||
Large Icons Iconos grandes
|
||||
Libraries Bibliotecas
|
||||
Medium Icons Iconos medianos
|
||||
No block matches the filter. Ningún bloque coincide con el filtro.
|
||||
This block is already in the drawing, so its definition is used. Este bloque ya está en el dibujo, así que se usa su definición.
|
||||
Open Library... Abrir biblioteca...
|
||||
Read the library again Volver a leer la biblioteca
|
||||
Reading the library... Leyendo la biblioteca...
|
||||
Refresh Actualizar
|
||||
Remove from the list Quitar de la lista
|
||||
Repeat Placement Repetir colocación
|
||||
Small Icons Iconos pequeños
|
||||
This drawing has no blocks. Este dibujo no tiene bloques.
|
||||
This library has no drawings or blocks. Esta biblioteca no tiene dibujos ni bloques.
|
||||
Only the first {n} are shown. Solo se muestran los primeros {n}.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -723,6 +723,7 @@
|
||||
Set Current Text Style Définir le style de texte courant
|
||||
Set Layer Properties Définir les propriétés du calque
|
||||
Set Properties Définir les propriétés
|
||||
Describe Properties Décrire les propriétés
|
||||
Set Table Cell Définir la cellule de tableau
|
||||
Set Variable Définir la variable
|
||||
Set View Définir la vue
|
||||
@@ -1014,6 +1015,34 @@
|
||||
Check for Updates… Rechercher des mises à jour…
|
||||
CADCraft is up to date. CADCraft est à jour.
|
||||
Could not check for updates. Impossible de rechercher les mises à jour.
|
||||
Add a drawing file as a block library Ajouter un fichier de dessin comme bibliothèque de blocs
|
||||
Add a folder of drawings or a drawing file to use its blocks. Ajoutez un dossier de dessins ou un fichier de dessin pour utiliser ses blocs.
|
||||
Block Libraries Bibliothèques de blocs
|
||||
Block Library Bibliothèque de blocs
|
||||
Blocks Palette Palette des blocs
|
||||
Click a block, then pick its insertion point. Cliquez sur un bloc, puis indiquez son point d'insertion.
|
||||
Current Drawing Dessin courant
|
||||
Details Détails
|
||||
Extra Large Icons Très grandes icônes
|
||||
Folder or file Dossier ou fichier
|
||||
Import Library Block Importer un bloc de bibliothèque
|
||||
Insert and Explode Insérer et décomposer
|
||||
Large Icons Grandes icônes
|
||||
Libraries Bibliothèques
|
||||
Medium Icons Icônes moyennes
|
||||
No block matches the filter. Aucun bloc ne correspond au filtre.
|
||||
This block is already in the drawing, so its definition is used. Ce bloc est déjà dans le dessin ; sa définition est utilisée.
|
||||
Open Library... Ouvrir une bibliothèque...
|
||||
Read the library again Relire la bibliothèque
|
||||
Reading the library... Lecture de la bibliothèque...
|
||||
Refresh Actualiser
|
||||
Remove from the list Retirer de la liste
|
||||
Repeat Placement Répéter le placement
|
||||
Small Icons Petites icônes
|
||||
This drawing has no blocks. Ce dessin ne contient aucun bloc.
|
||||
This library has no drawings or blocks. Cette bibliothèque ne contient ni dessin ni bloc.
|
||||
Options Options
|
||||
Only the first {n} are shown. Seuls les {n} premiers sont affichés.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -1346,6 +1346,33 @@ menu View Nézet
|
||||
Check for Updates… Frissítések keresése…
|
||||
CADCraft is up to date. A CADCraft naprakész.
|
||||
Could not check for updates. A frissítések keresése nem sikerült.
|
||||
Add a drawing file as a block library Rajzfájl hozzáadása blokkkönyvtárként
|
||||
Add a folder of drawings or a drawing file to use its blocks. Adj hozzá egy rajzokat tartalmazó mappát vagy egy rajzfájlt, hogy használhasd a blokkjait.
|
||||
Block Libraries Blokkkönyvtárak
|
||||
Block Library Blokkkönyvtár
|
||||
Blocks Palette Blokkpaletta
|
||||
Click a block, then pick its insertion point. Kattints egy blokkra, majd add meg a beszúrási pontját.
|
||||
Current Drawing Aktuális rajz
|
||||
Details Részletek
|
||||
Extra Large Icons Extra nagy ikonok
|
||||
Folder or file Mappa vagy fájl
|
||||
Import Library Block Könyvtárblokk importálása
|
||||
Insert and Explode Beszúrás és szétbontás
|
||||
Large Icons Nagy ikonok
|
||||
Libraries Könyvtárak
|
||||
Medium Icons Közepes ikonok
|
||||
No block matches the filter. Egy blokk sem felel meg a szűrőnek.
|
||||
This block is already in the drawing, so its definition is used. Ez a blokk már szerepel a rajzban, ezért a meglévő definícióját használjuk.
|
||||
Open Library... Könyvtár megnyitása...
|
||||
Read the library again Könyvtár újraolvasása
|
||||
Reading the library... Könyvtár olvasása...
|
||||
Refresh Frissítés
|
||||
Remove from the list Eltávolítás a listáról
|
||||
Repeat Placement Elhelyezés ismétlése
|
||||
Small Icons Kis ikonok
|
||||
This drawing has no blocks. Ez a rajz nem tartalmaz blokkokat.
|
||||
This library has no drawings or blocks. Ez a könyvtár nem tartalmaz rajzokat vagy blokkokat.
|
||||
Only the first {n} are shown. Csak az első {n} látható.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 16 and column 72.
|
@@ -847,6 +847,7 @@ menu Modify Edita
|
||||
Set Current Viewport Imposta finestra corrente
|
||||
Set Layer Properties Imposta proprietà layer
|
||||
Set Properties Imposta proprietà
|
||||
Describe Properties Descrivi proprietà
|
||||
Set Table Cell Imposta cella tabella
|
||||
Set Table Cell Style Imposta stile cella tabella
|
||||
Set Variable Imposta variabile
|
||||
@@ -1366,6 +1367,33 @@ menu Modify Edita
|
||||
Check for Updates… Verifica aggiornamenti…
|
||||
CADCraft is up to date. CADCraft è aggiornato.
|
||||
Could not check for updates. Impossibile verificare gli aggiornamenti.
|
||||
Add a drawing file as a block library Aggiungi un file di disegno come libreria di blocchi
|
||||
Add a folder of drawings or a drawing file to use its blocks. Aggiungi una cartella di disegni o un file di disegno per usarne i blocchi.
|
||||
Block Libraries Librerie di blocchi
|
||||
Block Library Libreria di blocchi
|
||||
Blocks Palette Tavolozza blocchi
|
||||
Click a block, then pick its insertion point. Fai clic su un blocco, quindi indica il punto di inserimento.
|
||||
Current Drawing Disegno corrente
|
||||
Details Dettagli
|
||||
Extra Large Icons Icone molto grandi
|
||||
Folder or file Cartella o file
|
||||
Import Library Block Importa blocco da libreria
|
||||
Insert and Explode Inserisci ed esplodi
|
||||
Large Icons Icone grandi
|
||||
Libraries Librerie
|
||||
Medium Icons Icone medie
|
||||
No block matches the filter. Nessun blocco corrisponde al filtro.
|
||||
This block is already in the drawing, so its definition is used. Questo blocco è già nel disegno, quindi viene usata la sua definizione.
|
||||
Open Library... Apri libreria...
|
||||
Read the library again Rileggi la libreria
|
||||
Reading the library... Lettura della libreria...
|
||||
Refresh Aggiorna
|
||||
Remove from the list Rimuovi dall'elenco
|
||||
Repeat Placement Ripeti posizionamento
|
||||
Small Icons Icone piccole
|
||||
This drawing has no blocks. Questo disegno non contiene blocchi.
|
||||
This library has no drawings or blocks. Questa libreria non contiene disegni o blocchi.
|
||||
Only the first {n} are shown. Vengono mostrati solo i primi {n}.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -1472,6 +1472,33 @@ menu View ხედი
|
||||
Text to find მოსაძებნი ტექსტი
|
||||
Whole words მთლიანი სიტყვები
|
||||
Nothing found ვერაფერი მოიძებნა
|
||||
Add a drawing file as a block library ნახაზის ფაილის დამატება ბლოკების ბიბლიოთეკად
|
||||
Add a folder of drawings or a drawing file to use its blocks. დაამატეთ ნახაზების საქაღალდე ან ნახაზის ფაილი მისი ბლოკების გამოსაყენებლად.
|
||||
Block Libraries ბლოკების ბიბლიოთეკები
|
||||
Block Library ბლოკების ბიბლიოთეკა
|
||||
Blocks Palette ბლოკების პალიტრა
|
||||
Click a block, then pick its insertion point. დაწკაპეთ ბლოკზე, შემდეგ მიუთითეთ მისი ჩასმის წერტილი.
|
||||
Current Drawing მიმდინარე ნახაზი
|
||||
Details დეტალები
|
||||
Extra Large Icons ძალიან დიდი ხატულები
|
||||
Folder or file საქაღალდე ან ფაილი
|
||||
Import Library Block ბიბლიოთეკის ბლოკის იმპორტი
|
||||
Insert and Explode ჩასმა და დაშლა
|
||||
Large Icons დიდი ხატულები
|
||||
Libraries ბიბლიოთეკები
|
||||
Medium Icons საშუალო ხატულები
|
||||
No block matches the filter. ფილტრს არც ერთი ბლოკი არ შეესაბამება.
|
||||
This block is already in the drawing, so its definition is used. ეს ბლოკი ნახაზში უკვე არის, ამიტომ გამოიყენება მისი განსაზღვრება.
|
||||
Open Library... ბიბლიოთეკის გახსნა...
|
||||
Read the library again ბიბლიოთეკის თავიდან წაკითხვა
|
||||
Reading the library... ბიბლიოთეკა იკითხება...
|
||||
Refresh განახლება
|
||||
Remove from the list სიიდან მოცილება
|
||||
Repeat Placement განთავსების გამეორება
|
||||
Small Icons პატარა ხატულები
|
||||
This drawing has no blocks. ამ ნახაზში ბლოკები არ არის.
|
||||
This library has no drawings or blocks. ამ ბიბლიოთეკაში ნახაზები ან ბლოკები არ არის.
|
||||
Only the first {n} are shown. ნაჩვენებია მხოლოდ პირველი {n}.
|
||||
|
||||
# ArtCraft feature naming
|
||||
Additional Tools დამატებითი ხელსაწყოები
|
||||
|
||||
|
Can't render this file because it contains an unexpected character in line 10 and column 14.
|
@@ -837,6 +837,7 @@
|
||||
Set Current Viewport 현재 뷰포트 설정
|
||||
Set Layer Properties 도면층 특성 설정
|
||||
Set Properties 특성 설정
|
||||
Describe Properties 특성 설명
|
||||
Set Table Cell 표 셀 설정
|
||||
Set Table Cell Style 표 셀 스타일 설정
|
||||
Set Variable 변수 설정
|
||||
@@ -1244,6 +1245,33 @@ menu Modify 수정
|
||||
Check for Updates… 업데이트 확인…
|
||||
CADCraft is up to date. CADCraft가 최신 버전입니다.
|
||||
Could not check for updates. 업데이트를 확인하지 못했습니다.
|
||||
Add a drawing file as a block library 도면 파일을 블록 라이브러리로 추가
|
||||
Add a folder of drawings or a drawing file to use its blocks. 블록을 사용하려면 도면이 들어 있는 폴더나 도면 파일을 추가하세요.
|
||||
Block Libraries 블록 라이브러리
|
||||
Block Library 블록 라이브러리
|
||||
Blocks Palette 블록 팔레트
|
||||
Click a block, then pick its insertion point. 블록을 클릭한 다음 삽입점을 지정하세요.
|
||||
Current Drawing 현재 도면
|
||||
Details 자세히
|
||||
Extra Large Icons 매우 큰 아이콘
|
||||
Folder or file 폴더 또는 파일
|
||||
Import Library Block 라이브러리 블록 가져오기
|
||||
Insert and Explode 삽입 후 분해
|
||||
Large Icons 큰 아이콘
|
||||
Libraries 라이브러리
|
||||
Medium Icons 보통 아이콘
|
||||
No block matches the filter. 필터와 일치하는 블록이 없습니다.
|
||||
This block is already in the drawing, so its definition is used. 이 블록은 이미 도면에 있으므로 기존 정의를 사용합니다.
|
||||
Open Library... 라이브러리 열기...
|
||||
Read the library again 라이브러리 다시 읽기
|
||||
Reading the library... 라이브러리를 읽는 중...
|
||||
Refresh 새로 고침
|
||||
Remove from the list 목록에서 제거
|
||||
Repeat Placement 배치 반복
|
||||
Small Icons 작은 아이콘
|
||||
This drawing has no blocks. 이 도면에는 블록이 없습니다.
|
||||
This library has no drawings or blocks. 이 라이브러리에는 도면이나 블록이 없습니다.
|
||||
Only the first {n} are shown. 처음 {n}개만 표시됩니다.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -928,6 +928,7 @@
|
||||
Set Current Text Style Definir estilo de texto atual
|
||||
Set Layer Properties Definir propriedades da camada
|
||||
Set Properties Definir propriedades
|
||||
Describe Properties Descrever propriedades
|
||||
Set Table Cell Definir célula da tabela
|
||||
Set Variable Definir variável
|
||||
Set View Definir vista
|
||||
@@ -1253,6 +1254,33 @@
|
||||
Check for Updates… Verificar atualizações…
|
||||
CADCraft is up to date. O CADCraft está atualizado.
|
||||
Could not check for updates. Não foi possível verificar atualizações.
|
||||
Add a drawing file as a block library Adicionar um arquivo de desenho como biblioteca de blocos
|
||||
Add a folder of drawings or a drawing file to use its blocks. Adicione uma pasta de desenhos ou um arquivo de desenho para usar seus blocos.
|
||||
Block Libraries Bibliotecas de blocos
|
||||
Block Library Biblioteca de blocos
|
||||
Blocks Palette Paleta de blocos
|
||||
Click a block, then pick its insertion point. Clique em um bloco e depois indique o ponto de inserção.
|
||||
Current Drawing Desenho atual
|
||||
Details Detalhes
|
||||
Extra Large Icons Ícones extragrandes
|
||||
Folder or file Pasta ou arquivo
|
||||
Import Library Block Importar bloco da biblioteca
|
||||
Insert and Explode Inserir e explodir
|
||||
Large Icons Ícones grandes
|
||||
Libraries Bibliotecas
|
||||
Medium Icons Ícones médios
|
||||
No block matches the filter. Nenhum bloco corresponde ao filtro.
|
||||
This block is already in the drawing, so its definition is used. Este bloco já está no desenho, então sua definição é usada.
|
||||
Open Library... Abrir biblioteca...
|
||||
Read the library again Ler a biblioteca novamente
|
||||
Reading the library... Lendo a biblioteca...
|
||||
Refresh Atualizar
|
||||
Remove from the list Remover da lista
|
||||
Repeat Placement Repetir posicionamento
|
||||
Small Icons Ícones pequenos
|
||||
This drawing has no blocks. Este desenho não tem blocos.
|
||||
This library has no drawings or blocks. Esta biblioteca não tem desenhos nem blocos.
|
||||
Only the first {n} are shown. Apenas os primeiros {n} são exibidos.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
@@ -723,6 +723,7 @@
|
||||
Set Current Text Style Сделать текстовый стиль текущим
|
||||
Set Layer Properties Задать свойства слоя
|
||||
Set Properties Задать свойства
|
||||
Describe Properties Описать свойства
|
||||
Set Table Cell Задать ячейку таблицы
|
||||
Set Variable Задать переменную
|
||||
Set View Задать вид
|
||||
@@ -1015,6 +1016,34 @@
|
||||
Check for Updates… Проверить обновления…
|
||||
CADCraft is up to date. У вас последняя версия CADCraft.
|
||||
Could not check for updates. Не удалось проверить обновления.
|
||||
Add a drawing file as a block library Добавить файл чертежа как библиотеку блоков
|
||||
Add a folder of drawings or a drawing file to use its blocks. Добавьте папку с чертежами или файл чертежа, чтобы использовать его блоки.
|
||||
Block Libraries Библиотеки блоков
|
||||
Block Library Библиотека блоков
|
||||
Blocks Palette Палитра блоков
|
||||
Click a block, then pick its insertion point. Щелкните блок, затем укажите точку вставки.
|
||||
Current Drawing Текущий чертеж
|
||||
Details Подробно
|
||||
Extra Large Icons Огромные значки
|
||||
Folder or file Папка или файл
|
||||
Import Library Block Импортировать блок из библиотеки
|
||||
Insert and Explode Вставить и расчленить
|
||||
Large Icons Крупные значки
|
||||
Libraries Библиотеки
|
||||
Medium Icons Обычные значки
|
||||
No block matches the filter. Нет блоков, соответствующих фильтру.
|
||||
This block is already in the drawing, so its definition is used. Этот блок уже есть в чертеже, поэтому используется его определение.
|
||||
Open Library... Открыть библиотеку...
|
||||
Read the library again Прочитать библиотеку заново
|
||||
Reading the library... Чтение библиотеки...
|
||||
Refresh Обновить
|
||||
Remove from the list Убрать из списка
|
||||
Repeat Placement Повторять размещение
|
||||
Small Icons Мелкие значки
|
||||
This drawing has no blocks. В этом чертеже нет блоков.
|
||||
This library has no drawings or blocks. В этой библиотеке нет чертежей и блоков.
|
||||
Options Параметры
|
||||
Only the first {n} are shown. Показаны только первые {n}.
|
||||
Find All Find All
|
||||
Find what: Find what:
|
||||
Match case Match case
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user