mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-19 20:30:42 -06:00
Compare commits
220
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5a5cb1a676 | ||
|
|
cbacaff9e0 | ||
|
|
b86caba676 | ||
|
|
23962d68e2 | ||
|
|
61d0575611 | ||
|
|
7cb74443c4 | ||
|
|
a770fa5a5e | ||
|
|
b23d172885 | ||
|
|
11d66cc3cd | ||
|
|
83a2b4c373 | ||
|
|
2ed5614e46 | ||
|
|
ad5ac32662 | ||
|
|
92b718f912 | ||
|
|
766af02ec4 | ||
|
|
d9d6c78a28 | ||
|
|
0ebb256d33 | ||
|
|
730907b9b8 | ||
|
|
f1b76fab54 | ||
|
|
65ed2fb7f0 | ||
|
|
7515b2bc69 | ||
|
|
9e3d38fd5f | ||
|
|
16341b665f | ||
|
|
259d892a33 | ||
|
|
2ccf5874b0 | ||
|
|
ed0fbce27c | ||
|
|
e1b86d5743 | ||
|
|
cb36b573c3 | ||
|
|
32dfdef71c | ||
|
|
29e17181bf | ||
|
|
b21747b30b | ||
|
|
b3d11070e4 | ||
|
|
155fd45d61 | ||
|
|
0bc69feed0 | ||
|
|
13f4d09b6d | ||
|
|
27256f0ba5 | ||
|
|
386750bd56 | ||
|
|
eec225a218 | ||
|
|
7013ce459c | ||
|
|
7b525189c0 | ||
|
|
13de76e5b2 | ||
|
|
afe77dc0d4 | ||
|
|
e5091e052e | ||
|
|
d267d6580e | ||
|
|
2974d74bdc | ||
|
|
0e3f62f50d | ||
|
|
007a24ef94 | ||
|
|
f9c0c96e63 | ||
|
|
1069c8217a | ||
|
|
6dfc0ef6a2 | ||
|
|
11e90d34fb | ||
|
|
0dae816499 | ||
|
|
a009f7d022 | ||
|
|
e7a51dcc3d | ||
|
|
c985814fcb | ||
|
|
a853649ffa | ||
|
|
ed6377fc46 | ||
|
|
7cb07b2f3b | ||
|
|
923f4174a6 | ||
|
|
9789562ac7 | ||
|
|
a20a46f7c3 | ||
|
|
682034d737 | ||
|
|
db70717001 | ||
|
|
173cdf6e8a | ||
|
|
5b170664aa | ||
|
|
305f452283 | ||
|
|
78bcdce794 | ||
|
|
fd11b47915 | ||
|
|
91b14c83cf | ||
|
|
ca6c100342 | ||
|
|
072ec4500a | ||
|
|
8a4e275466 | ||
|
|
58a13b5a64 | ||
|
|
a5a5550165 | ||
|
|
281f86d602 | ||
|
|
caaa0e37f7 | ||
|
|
c07b6a2ff7 | ||
|
|
7064a685a8 | ||
|
|
e43c39c55e | ||
|
|
deff6cb092 | ||
|
|
67514021ae | ||
|
|
6749299b95 | ||
|
|
4072f84290 | ||
|
|
f877213876 | ||
|
|
06203e4958 | ||
|
|
8e69890223 | ||
|
|
8c2d67531c | ||
|
|
1d16bb8ba0 | ||
|
|
fbb083803b | ||
|
|
54dfb2ee00 | ||
|
|
fa7a97728b | ||
|
|
2a9fc8f241 | ||
|
|
ddfa833bc2 | ||
|
|
bf581c2376 | ||
|
|
e347afbc63 | ||
|
|
39011d2552 | ||
|
|
ca87680fb0 | ||
|
|
c736e488ba | ||
|
|
2ef7c3bed1 | ||
|
|
fefb973754 | ||
|
|
ff2163ddfe | ||
|
|
64f707968f | ||
|
|
2ac6d98dac | ||
|
|
7a65b01453 | ||
|
|
ead93c6797 | ||
|
|
c0cc3f8509 | ||
|
|
ee8922b1d7 | ||
|
|
e04ceb2d5d | ||
|
|
81b3e6ba08 | ||
|
|
78506d3bd2 | ||
|
|
d8d5041d75 | ||
|
|
c13976c657 | ||
|
|
03f9139344 | ||
|
|
9cfe8a6daa | ||
|
|
3c135760b5 | ||
|
|
e1d3520c9e | ||
|
|
7ffabe0fc0 | ||
|
|
4f57426bad | ||
|
|
41f1496f7d | ||
|
|
67124500c6 | ||
|
|
30e3ae0767 | ||
|
|
a284313f27 | ||
|
|
026f7d906b | ||
|
|
5b622c3d32 | ||
|
|
56246049bc | ||
|
|
97f753d6c1 | ||
|
|
404988f67a | ||
|
|
d75bc7fa60 | ||
|
|
935e13cc52 | ||
|
|
feedca47dc | ||
|
|
2fa8997548 | ||
|
|
8157cd2fc1 | ||
|
|
f99307f2cd | ||
|
|
a8be418d8c | ||
|
|
a0c76b6726 | ||
|
|
51b3e8b112 | ||
|
|
f1790d2be7 | ||
|
|
deca6b1062 | ||
|
|
cddef1755b | ||
|
|
a84de56183 | ||
|
|
38933e7f91 | ||
|
|
9397db72e6 | ||
|
|
f0c1b4ff29 | ||
|
|
e65132c77a | ||
|
|
4415f4e5dc | ||
|
|
28428b0cc3 | ||
|
|
abd72f3f19 | ||
|
|
d80c055839 | ||
|
|
7983a25e38 | ||
|
|
0b9f1ed74a | ||
|
|
7f590216eb | ||
|
|
df1e333229 | ||
|
|
7ce2eea0c0 | ||
|
|
2616d46ec4 | ||
|
|
adc1876809 | ||
|
|
54d6c4eed8 | ||
|
|
a06bb18b58 | ||
|
|
23d5918a62 | ||
|
|
43896056e2 | ||
|
|
853ca574bd | ||
|
|
9938d5aa0e | ||
|
|
a3b81b6ac2 | ||
|
|
2cfd068c1f | ||
|
|
744e99cafd | ||
|
|
9c862c01ba | ||
|
|
37a8c6e036 | ||
|
|
07a78159e4 | ||
|
|
98a05c66f9 | ||
|
|
3e0de6246f | ||
|
|
9f71170368 | ||
|
|
4abc2dee5b | ||
|
|
4ca8136379 | ||
|
|
9419abb274 | ||
|
|
5dd37f917f | ||
|
|
4a4012d22f | ||
|
|
fb5f68328d | ||
|
|
d204518d8a | ||
|
|
25014b77b8 | ||
|
|
e98201c282 | ||
|
|
97f889733d | ||
|
|
3f347ea431 | ||
|
|
a44308f4aa | ||
|
|
f6e56d97f6 | ||
|
|
940e3de914 | ||
|
|
b29a1398a4 | ||
|
|
372be8db01 | ||
|
|
3c0c5b1f61 | ||
|
|
4346beec72 | ||
|
|
f8f81b431d | ||
|
|
3711c8c762 | ||
|
|
e660b0dbe4 | ||
|
|
b077e22f40 | ||
|
|
33aaf7096c | ||
|
|
baf1889912 | ||
|
|
f67e5ccd38 | ||
|
|
800b0319ac | ||
|
|
6125f57084 | ||
|
|
3203a607e2 | ||
|
|
ef4bb85059 | ||
|
|
5da9d3f539 | ||
|
|
9e022cf31c | ||
|
|
3e42b346ff | ||
|
|
afcb6aa743 | ||
|
|
72add0b90e | ||
|
|
a0e023d758 | ||
|
|
44547941cc | ||
|
|
99e3b93bd5 | ||
|
|
b692cbe0dd | ||
|
|
99b7dc808f | ||
|
|
fed42f45b2 | ||
|
|
be56597e5f | ||
|
|
1350e1b18f | ||
|
|
d7de5ccdf3 | ||
|
|
0bf32bba90 | ||
|
|
821b8ad18c | ||
|
|
5cfe5f84b0 | ||
|
|
e3aeff2a9b | ||
|
|
3f14431a33 | ||
|
|
9f833f3d16 | ||
|
|
4fee981bd4 | ||
|
|
bc7357ffb8 |
@@ -1,6 +1,10 @@
|
||||
name: Release
|
||||
|
||||
on:
|
||||
# A nightly dry run on main: every release build except macOS, nothing signed or released
|
||||
# (craft-common-actions release.yml `dry-run`). Finds release-only breakage before release day.
|
||||
schedule:
|
||||
- cron: "8 1 * * *"
|
||||
push:
|
||||
branches: [release]
|
||||
workflow_dispatch:
|
||||
@@ -34,6 +38,7 @@ jobs:
|
||||
# Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
|
||||
uses: storytold/craft-common-actions/.github/workflows/release.yml@main
|
||||
with:
|
||||
dry-run: ${{ github.event_name == 'schedule' }}
|
||||
app-name: cadcraft
|
||||
app-title: CADCraft
|
||||
craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
|
||||
|
||||
@@ -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.
|
||||
|
||||
+3
-1
@@ -23,6 +23,7 @@ Generated-in-code assets are original and have no file to list:
|
||||
|
||||
| Asset | Author | Source | Licence | Notes |
|
||||
|---|---|---|---|---|
|
||||
| `licenses/jpeg-encoder-0.6.1/` | jpeg-encoder contributors and Independent JPEG Group | [jpeg-encoder 0.6.1](https://crates.io/crates/jpeg-encoder/0.6.1) | (MIT OR Apache-2.0) AND IJG | Dependency license and SIMD notices; source hashes in SOURCE.json. |
|
||||
| `epaint_default_fonts::EGUI_ICONS`, `epaint_default_fonts::EMOJI_ICON` (dependency font inputs) | John Slegers | [egui 173cc737](https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts), [emoji-icon-font](https://github.com/jslegers/emoji-icon-font) | MIT (Copyright (c) 2014 John Slegers; full upstream text in `NOTICE`) | egui-icons.ttf is the five-glyph subset; emoji-icon-font.ttf is the full monochrome fallback. Registered by the production default font definitions; dependency assets unmodified here, no font file copied into this repository. |
|
||||
| `krilla 0.8.2 / icc/sGrey-v2-magic.icc` (dependency-embedded) | Clinton Ingram | [craft-libs 9f89fe8 vendor/krilla/icc/sGrey-v2-magic.icc](https://github.com/storytold/craft-libs/blob/9f89fe8f6d72ab4db4cc06f186381a6a254463ab/vendor/krilla/icc/sGrey-v2-magic.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `4110169287e5f1b5149ca9f1da1814d32943905bba8030e849d1a3b729a19481`. |
|
||||
| `krilla 0.8.2 / icc/sGrey-v4.icc` (dependency-embedded) | Clinton Ingram | [craft-libs 9f89fe8 vendor/krilla/icc/sGrey-v4.icc](https://github.com/storytold/craft-libs/blob/9f89fe8f6d72ab4db4cc06f186381a6a254463ab/vendor/krilla/icc/sGrey-v4.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `00c0f94e09127520a17dc0e1d9264b5702081d96dbdb1549ee88e3631ce42a9d`. |
|
||||
@@ -62,6 +63,7 @@ Generated-in-code assets are original and have no file to list:
|
||||
| Asset | Author | Source | Licence | Notes |
|
||||
|---|---|---|---|---|
|
||||
| `crates/ui-egui/src/i18n/uk.tsv` | @dmatviichuk | Original Ukrainian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
| `crates/ui-egui/src/i18n/pl.tsv` | @neronek22 (Echo Rozumu & Gadajło; AI-assisted) | Original Polish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
| `crates/ui-egui/src/i18n/de.tsv` | the CADCraft contributors | Original German translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
| `crates/ui-egui/src/i18n/es.tsv` | @PedroGuille | Original Spanish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
| `crates/ui-egui/src/i18n/pt_br.tsv` | @WladmirJunior | Original Brazilian Portuguese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
@@ -76,6 +78,6 @@ Generated-in-code assets are original and have no file to list:
|
||||
| `crates/ui-egui/src/i18n/ar.tsv` | @hasan-sdaif | Original Arabic translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
| `crates/ui-egui/src/i18n/hu.tsv` | @Skaywalker | Original Hungarian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
|
||||
| `crates/ui-egui/src/i18n/tr.tsv` | @ogzhnklvz (AI-assisted) | Original Turkish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; written from the English strings, no other catalog used as a source; the running app reviewed by a native speaker |
|
||||
| `crates/ui-egui/src/i18n/el.tsv` | @Camthalion77 with ChatGPT (AI-assisted) | Original Greek translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; independent native proofreading pending |
|
||||
| `crates/ui-egui/src/i18n/el.tsv` | @Camthalion77 with ChatGPT (AI-assisted); 46 later rows: @V1dalTheAbidal with Claude Code (AI-assisted) | Original Greek translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; the 46 later rows were read by their contributor, a native Greek speaker; independent native proofreading of the whole file pending |
|
||||
| `crates/ui-egui/src/i18n/vi.tsv` | @2ez4gcx with Claude Code (AI-assisted) | Original Vietnamese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; terminology chosen with a native speaker, full proofreading pending |
|
||||
| `crates/ui-egui/src/i18n/ka.tsv` | Davit Matchakhelidze (@devius), native speaker, with Claude Code | Original Georgian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; written from the English strings, no other catalog used as a source; terminology and doubtful strings decided by a native Georgian speaker; no font assets added (the Georgian face comes from craft-fonts) |
|
||||
|
||||
Generated
+426
-37
@@ -156,6 +156,21 @@ dependencies = [
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "alloc-no-stdlib"
|
||||
version = "3.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a"
|
||||
|
||||
[[package]]
|
||||
name = "alloc-stdlib"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1"
|
||||
dependencies = [
|
||||
"alloc-no-stdlib",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "allocator-api2"
|
||||
version = "0.2.21"
|
||||
@@ -284,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"
|
||||
@@ -513,6 +531,12 @@ version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
|
||||
|
||||
[[package]]
|
||||
name = "bit_field"
|
||||
version = "0.10.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cb2907cc03d08cdb1c6724ad0670ce67c4a71e1c45a6d7635224011714cfc4b1"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
@@ -568,6 +592,16 @@ dependencies = [
|
||||
"piper",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "brotli-decompressor"
|
||||
version = "6.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cc031cd87c6529082b0b65c604e86af0ed7744841b17ccfe60b1e31fa606179e"
|
||||
dependencies = [
|
||||
"alloc-no-stdlib",
|
||||
"alloc-stdlib",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bumpalo"
|
||||
version = "3.20.3"
|
||||
@@ -614,7 +648,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-engine",
|
||||
"cadcraft-io",
|
||||
@@ -637,6 +671,7 @@ dependencies = [
|
||||
"serde_json",
|
||||
"sys-locale",
|
||||
"thiserror 2.0.21",
|
||||
"uds_windows",
|
||||
"windows",
|
||||
"winit",
|
||||
"winresource",
|
||||
@@ -645,7 +680,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-cli"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-engine",
|
||||
"cadcraft-io",
|
||||
@@ -661,14 +696,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-color"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-constraints"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-doc",
|
||||
"cadcraft-geom",
|
||||
@@ -678,7 +713,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-doc"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-color",
|
||||
"cadcraft-geom",
|
||||
@@ -687,36 +722,20 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-dwg"
|
||||
version = "0.20.1"
|
||||
dependencies = [
|
||||
"acadrust",
|
||||
"log",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-dxf"
|
||||
version = "0.20.1"
|
||||
dependencies = [
|
||||
"encoding_rs",
|
||||
"log",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-engine"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-color",
|
||||
"cadcraft-constraints",
|
||||
"cadcraft-doc",
|
||||
"cadcraft-dxf",
|
||||
"cadcraft-fonts",
|
||||
"cadcraft-geom",
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"craft-docpath",
|
||||
"craft-dxf",
|
||||
"craft-mime",
|
||||
"libc",
|
||||
"log",
|
||||
"rstar",
|
||||
@@ -727,10 +746,12 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-fonts"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-dxf",
|
||||
"cadcraft-geom",
|
||||
"craft-dxf",
|
||||
"craft-font-catalog",
|
||||
"craft-shx",
|
||||
"encoding_rs",
|
||||
"harfrust 0.14.0",
|
||||
"icu_segmenter",
|
||||
@@ -740,41 +761,45 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-geom"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-io"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"acadrust",
|
||||
"cadcraft-color",
|
||||
"cadcraft-doc",
|
||||
"cadcraft-dwg",
|
||||
"cadcraft-dxf",
|
||||
"cadcraft-fonts",
|
||||
"cadcraft-geom",
|
||||
"cadcraft-render",
|
||||
"craft-dwg",
|
||||
"craft-dxf",
|
||||
"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",
|
||||
"tiff",
|
||||
"tiny-skia",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-mcp"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-engine",
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"clap",
|
||||
"craft-jsonrpc",
|
||||
"craft-mcp",
|
||||
"getrandom 0.4.3",
|
||||
"libc",
|
||||
"log",
|
||||
@@ -784,12 +809,13 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-render"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-color",
|
||||
"cadcraft-doc",
|
||||
"cadcraft-fonts",
|
||||
"cadcraft-geom",
|
||||
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"lyon_tessellation",
|
||||
"rayon",
|
||||
"serde_json",
|
||||
@@ -798,15 +824,17 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-ui-egui"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-color",
|
||||
"cadcraft-doc",
|
||||
"cadcraft-engine",
|
||||
"cadcraft-fonts",
|
||||
"cadcraft-geom",
|
||||
"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",
|
||||
@@ -825,7 +853,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cadcraft-web"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-engine",
|
||||
"cadcraft-fonts",
|
||||
@@ -1147,11 +1175,52 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-codepage"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=0325b2d73676d736e94097dbcef01219cf25c7db#0325b2d73676d736e94097dbcef01219cf25c7db"
|
||||
|
||||
[[package]]
|
||||
name = "craft-codepage"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=9ed120e6b1bd5116a4649c578d1272d60cf932b9#9ed120e6b1bd5116a4649c578d1272d60cf932b9"
|
||||
|
||||
[[package]]
|
||||
name = "craft-docpath"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
|
||||
|
||||
[[package]]
|
||||
name = "craft-dwg"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf#7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf"
|
||||
dependencies = [
|
||||
"acadrust",
|
||||
"log",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-dxf"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=9ed120e6b1bd5116a4649c578d1272d60cf932b9#9ed120e6b1bd5116a4649c578d1272d60cf932b9"
|
||||
dependencies = [
|
||||
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=9ed120e6b1bd5116a4649c578d1272d60cf932b9)",
|
||||
"encoding_rs",
|
||||
"kurbo",
|
||||
"log",
|
||||
"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"
|
||||
@@ -1180,6 +1249,123 @@ dependencies = [
|
||||
"writeable",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-image-codecs"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
|
||||
dependencies = [
|
||||
"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",
|
||||
"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-jpeg"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
|
||||
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"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=b6222158fbc2a628f27d2c1fff9f648cd194404c#b6222158fbc2a628f27d2c1fff9f648cd194404c"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-mcp"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=b6222158fbc2a628f27d2c1fff9f648cd194404c#b6222158fbc2a628f27d2c1fff9f648cd194404c"
|
||||
dependencies = [
|
||||
"craft-jsonrpc",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-metadata"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
|
||||
dependencies = [
|
||||
"brotli-decompressor",
|
||||
"chrono",
|
||||
"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",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-mime"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=0325b2d73676d736e94097dbcef01219cf25c7db#0325b2d73676d736e94097dbcef01219cf25c7db"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=0325b2d73676d736e94097dbcef01219cf25c7db)",
|
||||
"encoding_rs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-pdf"
|
||||
version = "0.1.0"
|
||||
@@ -1190,6 +1376,45 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-shx"
|
||||
version = "0.1.0"
|
||||
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"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"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"
|
||||
@@ -1214,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",
|
||||
@@ -1269,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"
|
||||
@@ -1758,6 +1993,22 @@ dependencies = [
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "exr"
|
||||
version = "1.74.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cb29d0be702adf92c645d9b2f93472906ba83d400e59f98adb3770ce5c18c2f6"
|
||||
dependencies = [
|
||||
"bit_field",
|
||||
"half",
|
||||
"lebe",
|
||||
"miniz_oxide 0.8.9",
|
||||
"multiversion",
|
||||
"rayon-core",
|
||||
"smallvec",
|
||||
"zune-inflate",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fastrand"
|
||||
version = "2.5.0"
|
||||
@@ -2262,6 +2513,9 @@ name = "hayro-jpeg2000"
|
||||
version = "0.3.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c75ab947623ef4ccaa7acf0579edf7cbb5a73838e3839a7be73335e522f433a1"
|
||||
dependencies = [
|
||||
"fearless_simd",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hayro-syntax"
|
||||
@@ -2564,9 +2818,12 @@ checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"byteorder-lite",
|
||||
"color_quant",
|
||||
"gif",
|
||||
"moxcms",
|
||||
"num-traits",
|
||||
"png",
|
||||
"qoi",
|
||||
"tiff",
|
||||
"zune-core",
|
||||
"zune-jpeg",
|
||||
@@ -2706,6 +2963,12 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "jpeg-encoder"
|
||||
version = "0.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b454d911ac55068f53495488d8ccd0646eaa540c033a28ee15b07838afafb01f"
|
||||
|
||||
[[package]]
|
||||
name = "js-sys"
|
||||
version = "0.3.106"
|
||||
@@ -2789,6 +3052,7 @@ dependencies = [
|
||||
"arrayvec",
|
||||
"euclid",
|
||||
"polycool",
|
||||
"serde",
|
||||
"smallvec",
|
||||
]
|
||||
|
||||
@@ -2798,6 +3062,12 @@ version = "1.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
|
||||
|
||||
[[package]]
|
||||
name = "lebe"
|
||||
version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.191"
|
||||
@@ -2838,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"
|
||||
@@ -2990,6 +3273,28 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "multiversion"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "eb8a68be21d0755f83bfe47e79b896cc732687cf1903f0e50585e8d6ecc53076"
|
||||
dependencies = [
|
||||
"multiversion-macros",
|
||||
"target-features",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "multiversion-macros"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a05e0c3c3e4edaa21d87c645852ed0b0c3663752bcc6ec43353bd6189dce35e1"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
"target-features",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "multiversion_no_op"
|
||||
version = "1.0.0"
|
||||
@@ -3858,6 +4163,15 @@ version = "0.1.30"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
|
||||
|
||||
[[package]]
|
||||
name = "qoi"
|
||||
version = "0.4.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quick-error"
|
||||
version = "2.0.1"
|
||||
@@ -3968,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"
|
||||
@@ -4075,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"
|
||||
@@ -4432,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"
|
||||
@@ -4655,6 +4999,12 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "target-features"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c1bbb9f3c5c463a01705937a24fdabc5047929ac764b2d5b9cf681c1f5041ed5"
|
||||
|
||||
[[package]]
|
||||
name = "tempfile"
|
||||
version = "3.27.0"
|
||||
@@ -5072,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"
|
||||
@@ -5994,7 +6365,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
|
||||
|
||||
[[package]]
|
||||
name = "xtask"
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"serde_json",
|
||||
@@ -6247,6 +6618,15 @@ version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"
|
||||
|
||||
[[package]]
|
||||
name = "zune-inflate"
|
||||
version = "0.2.54"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
|
||||
dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zune-jpeg"
|
||||
version = "0.5.15"
|
||||
@@ -6256,6 +6636,15 @@ dependencies = [
|
||||
"zune-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zune-jpegxl"
|
||||
version = "0.5.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cba11ecd07cc23351500e840ae03841b7e4997923ec8e4832ee3ae199ea0b6b4"
|
||||
dependencies = [
|
||||
"zune-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zvariant"
|
||||
version = "5.15.1"
|
||||
|
||||
+14
-4
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
|
||||
# default-members
|
||||
|
||||
[workspace.package]
|
||||
version = "0.20.1"
|
||||
version = "0.21.0"
|
||||
edition = "2024"
|
||||
license = "MIT OR Apache-2.0"
|
||||
rust-version = "1.95"
|
||||
@@ -13,8 +13,12 @@ repository = "https://github.com/storytold/cadcraft"
|
||||
[workspace.dependencies]
|
||||
# internal
|
||||
cadcraft-geom = { path = "crates/geom" }
|
||||
cadcraft-dxf = { path = "crates/dxf" }
|
||||
cadcraft-dwg = { path = "crates/dwg" }
|
||||
# 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 = "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" }
|
||||
cadcraft-doc = { path = "crates/doc" }
|
||||
cadcraft-constraints = { path = "crates/constraints" }
|
||||
@@ -24,11 +28,17 @@ cadcraft-io = { path = "crates/io" }
|
||||
cadcraft-engine = { path = "crates/engine" }
|
||||
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"] }
|
||||
@@ -71,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 }
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@ Third-party material
|
||||
|
||||
Software dependencies are listed in Cargo.lock. One is under a weak-copyleft licence: the acadrust
|
||||
crate (DWG reading and writing, https://github.com/hakanaktt/acadrust) is licensed under the
|
||||
Mozilla Public License 2.0 and is used unmodified as a separate library (crates/dwg). Its source
|
||||
Mozilla Public License 2.0 and is used unmodified as a separate library via craft-dwg. Its source
|
||||
is available from crates.io and the repository above.
|
||||
|
||||
|
||||
@@ -48,3 +48,127 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
JPEG encoding dependency: jpeg-encoder 0.6.1
|
||||
|
||||
Source: https://crates.io/crates/jpeg-encoder/0.6.1
|
||||
Declared license: (MIT OR Apache-2.0) AND IJG.
|
||||
This software is based in part on the work of the Independent JPEG Group.
|
||||
|
||||
The MIT license and unaltered upstream IJG and SIMD notices follow. The Apache-2.0
|
||||
alternative is also retained in licenses/jpeg-encoder-0.6.1 at the repository root
|
||||
(https://github.com/storytold/craft-libs/tree/main/licenses/jpeg-encoder-0.6.1).
|
||||
The dependency is used unmodified; no encoder implementation is vendored here.
|
||||
|
||||
LICENSE-MIT
|
||||
|
||||
Copyright (c) 2021 Volker Ströbel <volkerstroebel@mysurdity.de>
|
||||
|
||||
Permission is hereby granted, free of charge, to any
|
||||
person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the
|
||||
Software without restriction, including without
|
||||
limitation the rights to use, copy, modify, merge,
|
||||
publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software
|
||||
is furnished to do so, subject to the following
|
||||
conditions:
|
||||
|
||||
The above copyright notice and this permission notice
|
||||
shall be included in all copies or substantial portions
|
||||
of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
Original src/fdct.rs opening notice
|
||||
|
||||
/*
|
||||
* Ported from mozjpeg to rust
|
||||
*
|
||||
* This file was part of the Independent JPEG Group's software:
|
||||
* Copyright (C) 1991-1996, Thomas G. Lane.
|
||||
* libjpeg-turbo Modifications:
|
||||
* Copyright (C) 2015, 2020, D. R. Commander.
|
||||
*
|
||||
* Conditions of distribution and use:
|
||||
* In plain English:
|
||||
*
|
||||
* 1. We don't promise that this software works. (But if you find any bugs,
|
||||
* please let us know!)
|
||||
* 2. You can use this software for whatever you want. You don't have to pay us.
|
||||
* 3. You may not pretend that you wrote this software. If you use it in a
|
||||
* program, you must acknowledge somewhere in your documentation that
|
||||
* you've used the IJG code.
|
||||
*
|
||||
* In legalese:
|
||||
*
|
||||
* The authors make NO WARRANTY or representation, either express or implied,
|
||||
* with respect to this software, its quality, accuracy, merchantability, or
|
||||
* fitness for a particular purpose. This software is provided "AS IS", and you,
|
||||
* its user, assume the entire risk as to its quality and accuracy.
|
||||
*
|
||||
* This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
|
||||
* All Rights Reserved except as specified below.
|
||||
*
|
||||
* Permission is hereby granted to use, copy, modify, and distribute this
|
||||
* software (or portions thereof) for any purpose, without fee, subject to these
|
||||
* conditions:
|
||||
* (1) If any part of the source code for this software is distributed, then this
|
||||
* README file must be included, with this copyright and no-warranty notice
|
||||
* unaltered; and any additions, deletions, or changes to the original files
|
||||
* must be clearly indicated in accompanying documentation.
|
||||
* (2) If only executable code is distributed, then the accompanying
|
||||
* documentation must state that "this software is based in part on the work of
|
||||
* the Independent JPEG Group".
|
||||
* (3) Permission for use of this software is granted only if the user accepts
|
||||
* full responsibility for any undesirable consequences; the authors accept
|
||||
* NO LIABILITY for damages of any kind.
|
||||
*
|
||||
* These conditions apply to any software derived from or based on the IJG code,
|
||||
* not just to the unmodified library. If you use our work, you ought to
|
||||
* acknowledge us.
|
||||
*
|
||||
* Permission is NOT granted for the use of any IJG author's name or company name
|
||||
* in advertising or publicity relating to this software or products derived from
|
||||
* it. This software may be referred to only as "the Independent JPEG Group's
|
||||
* software".
|
||||
*
|
||||
* We specifically permit and encourage the use of this software as the basis of
|
||||
* commercial products, provided that all warranty or liability claims are
|
||||
* assumed by the product vendor.
|
||||
*
|
||||
* This file contains a slower but more accurate integer implementation of the
|
||||
* forward DCT (Discrete Cosine Transform).
|
||||
*
|
||||
* A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
|
||||
* on each column. Direct algorithms are also available, but they are
|
||||
* much more complex and seem not to be any faster when reduced to code.
|
||||
*
|
||||
* This implementation is based on an algorithm described in
|
||||
* C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
|
||||
* Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
|
||||
* Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
|
||||
* The primary algorithm described there uses 11 multiplies and 29 adds.
|
||||
* We use their alternate method with 12 multiplies and 32 adds.
|
||||
* The advantage of this method is that no data path contains more than one
|
||||
* multiplication; this allows a very simple and accurate implementation in
|
||||
* scaled fixed-point arithmetic, with a minimal number of shifts.
|
||||
*/
|
||||
|
||||
Original src/avx2/fdct.rs opening notice
|
||||
|
||||
/*
|
||||
* Ported from mozjpeg / jfdctint-avx2.asm to rust
|
||||
* Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
|
||||
* Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander.
|
||||
*
|
||||
* Based on the x86 SIMD extension for IJG JPEG library
|
||||
* Copyright (C) 1999-2006, MIYASAKA Masaru.
|
||||
*/
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -44,7 +44,6 @@ fn snapshot(ui: &UiState) -> Result<Value, String> {
|
||||
"showStatusBar": ui.show_status_bar,
|
||||
"showCommandLine": ui.show_command_line,
|
||||
"showViewcube": ui.show_viewcube,
|
||||
"showUcsIcon": ui.show_ucs_icon,
|
||||
"showLayerList": ui.show_layer_list,
|
||||
"toolsetTab": ui.toolset_tab,
|
||||
"collapsedGroups": ui.collapsed_groups,
|
||||
|
||||
@@ -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
|
||||
@@ -118,3 +122,9 @@ sync_github_name = true
|
||||
|
||||
[people.helenkwok]
|
||||
real_name = "Helen Kwok"
|
||||
|
||||
[people.V1dalTheAbidal]
|
||||
sync_github_name = true
|
||||
|
||||
[people.tyrel]
|
||||
real_name = "Tyrel Haveman"
|
||||
|
||||
+53
-26
@@ -1,5 +1,5 @@
|
||||
//! CAD colours: the 256-entry colour index (ACI), 24-bit true colour, and the logical
|
||||
//! ByLayer / ByBlock values. The index palette is generated from its well-known structure
|
||||
//! `ByLayer` / `ByBlock` values. The index palette is generated from its well-known structure
|
||||
//! (24 hues × 5 values × 2 saturations, plus primaries and greys), not copied from any file.
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
#![forbid(unsafe_code)]
|
||||
@@ -11,12 +11,15 @@ use serde::{Deserialize, Serialize};
|
||||
pub struct Rgb(pub u8, pub u8, pub u8);
|
||||
|
||||
impl Rgb {
|
||||
#[must_use]
|
||||
pub fn to_u32(self) -> u32 {
|
||||
(u32::from(self.0) << 16) | (u32::from(self.1) << 8) | u32::from(self.2)
|
||||
}
|
||||
#[must_use]
|
||||
pub fn from_u32(v: u32) -> Rgb {
|
||||
Rgb(((v >> 16) & 0xff) as u8, ((v >> 8) & 0xff) as u8, (v & 0xff) as u8)
|
||||
}
|
||||
#[must_use]
|
||||
pub fn hex(self) -> String {
|
||||
format!("#{:02x}{:02x}{:02x}", self.0, self.1, self.2)
|
||||
}
|
||||
@@ -29,6 +32,7 @@ impl Rgb {
|
||||
u32::from_str_radix(s, 16).ok().map(Rgb::from_u32)
|
||||
}
|
||||
/// Relative luminance (0..1) for contrast decisions.
|
||||
#[must_use]
|
||||
pub fn luma(self) -> f64 {
|
||||
(0.2126 * f64::from(self.0) + 0.7152 * f64::from(self.1) + 0.0722 * f64::from(self.2)) / 255.0
|
||||
}
|
||||
@@ -48,7 +52,8 @@ pub enum Color {
|
||||
|
||||
impl Color {
|
||||
pub const WHITE: Color = Color::Index(7);
|
||||
/// DXF group 62 value: 0 = ByBlock, 256 = ByLayer.
|
||||
/// DXF group 62 value: 0 = `ByBlock`, 256 = `ByLayer`.
|
||||
#[must_use]
|
||||
pub fn to_aci(self) -> i16 {
|
||||
match self {
|
||||
Color::ByLayer => 256,
|
||||
@@ -57,14 +62,16 @@ impl Color {
|
||||
Color::True(rgb) => i16::from(nearest_aci(rgb)),
|
||||
}
|
||||
}
|
||||
#[must_use]
|
||||
pub fn from_aci(v: i16) -> Color {
|
||||
match v {
|
||||
0 => Color::ByBlock,
|
||||
1..=255 => Color::Index(v as u8),
|
||||
1..=255 => u8::try_from(v).map_or(Color::ByLayer, Color::Index),
|
||||
_ => Color::ByLayer,
|
||||
}
|
||||
}
|
||||
/// Resolve to RGB given the layer and block colours.
|
||||
#[must_use]
|
||||
pub fn resolve(self, layer: Color, block: Color) -> Rgb {
|
||||
match self {
|
||||
Color::ByLayer => match layer {
|
||||
@@ -79,7 +86,8 @@ impl Color {
|
||||
Color::True(c) => c,
|
||||
}
|
||||
}
|
||||
/// Short display name like AutoCAD's Properties palette ("ByLayer", "Red", "Color 34", "255,128,0").
|
||||
/// Short display name like `AutoCAD`'s Properties palette ("`ByLayer`", "Red", "Color 34", "255,128,0").
|
||||
#[must_use]
|
||||
pub fn name(self) -> String {
|
||||
match self {
|
||||
Color::ByLayer => "ByLayer".into(),
|
||||
@@ -102,7 +110,7 @@ impl Color {
|
||||
let t = s.trim().to_ascii_lowercase();
|
||||
let named = ["", "red", "yellow", "green", "cyan", "blue", "magenta", "white"];
|
||||
if let Some(i) = named.iter().position(|n| !n.is_empty() && *n == t) {
|
||||
return Some(Color::Index(i as u8));
|
||||
return u8::try_from(i).ok().map(Color::Index);
|
||||
}
|
||||
match t.as_str() {
|
||||
"bylayer" => return Some(Color::ByLayer),
|
||||
@@ -117,7 +125,7 @@ impl Color {
|
||||
return match i {
|
||||
0 => Some(Color::ByBlock),
|
||||
256 => Some(Color::ByLayer),
|
||||
1..=255 => Some(Color::Index(i as u8)),
|
||||
1..=255 => u8::try_from(i).ok().map(Color::Index),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@@ -145,11 +153,16 @@ pub fn aci_rgb(i: u8) -> Rgb {
|
||||
PALETTE.get(usize::from(i)).copied().unwrap_or(Rgb(255, 255, 255))
|
||||
}
|
||||
|
||||
/// The palette as a 256-entry table (entry 0 = ByBlock placeholder = black).
|
||||
/// The palette as a 256-entry table (entry 0 = `ByBlock` placeholder = black).
|
||||
pub static PALETTE: std::sync::LazyLock<[Rgb; 256]> = std::sync::LazyLock::new(build_palette);
|
||||
|
||||
#[expect(
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "Palette channels are finite and clamped to the u8 range before conversion."
|
||||
)]
|
||||
fn build_palette() -> [Rgb; 256] {
|
||||
let mut p = [Rgb(0, 0, 0); 256];
|
||||
let mut palette = [Rgb(0, 0, 0); 256];
|
||||
let base = [
|
||||
Rgb(0, 0, 0),
|
||||
Rgb(255, 0, 0),
|
||||
@@ -159,37 +172,38 @@ 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, c) in p.iter_mut().zip(base) {
|
||||
*slot = c;
|
||||
for (slot, colour) in palette.iter_mut().zip(base) {
|
||||
*slot = colour;
|
||||
}
|
||||
let values = [255.0, 204.0, 153.0, 127.0, 76.0];
|
||||
for i in 10..250usize {
|
||||
let hue = (i - 10) / 10; // 0..24, 15° each
|
||||
let sub = i % 10;
|
||||
let v: f64 = values.get(sub / 2).copied().unwrap_or(255.0);
|
||||
for index in 10..250usize {
|
||||
let hue = (index - 10) / 10; // 0..24, 15° each
|
||||
let sub = index % 10;
|
||||
let value: f64 = values.get(sub / 2).copied().unwrap_or(255.0);
|
||||
let half = sub % 2 == 1;
|
||||
let (r, g, b) = hue_fractions(hue);
|
||||
let ch = |f: f64| -> u8 {
|
||||
let f = if half { 0.5 + 0.5 * f } else { f };
|
||||
(v * f).floor().clamp(0.0, 255.0) as u8
|
||||
let (red, green, blue) = hue_fractions(hue);
|
||||
let channel = |fraction: f64| -> u8 {
|
||||
let fraction = if half { 0.5 + 0.5 * fraction } else { fraction };
|
||||
(value * fraction).floor().clamp(0.0, 255.0) as u8
|
||||
};
|
||||
if let Some(slot) = p.get_mut(i) {
|
||||
*slot = Rgb(ch(r), ch(g), ch(b));
|
||||
if let Some(slot) = palette.get_mut(index) {
|
||||
*slot = Rgb(channel(red), channel(green), channel(blue));
|
||||
}
|
||||
}
|
||||
let greys = [51u8, 91, 132, 173, 214, 255];
|
||||
for (k, g) in greys.iter().enumerate() {
|
||||
if let Some(slot) = p.get_mut(250 + k) {
|
||||
*slot = Rgb(*g, *g, *g);
|
||||
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);
|
||||
}
|
||||
}
|
||||
p
|
||||
palette
|
||||
}
|
||||
|
||||
/// Channel fractions for hue step 0..24 (red → yellow → green → cyan → blue → magenta → red).
|
||||
#[expect(clippy::cast_precision_loss, reason = "Only the four hue offsets 0..=3 are converted; they are exact in f64.")]
|
||||
fn hue_fractions(h: usize) -> (f64, f64, f64) {
|
||||
let seg = h / 4;
|
||||
let t = (h % 4) as f64 / 4.0;
|
||||
@@ -204,6 +218,7 @@ fn hue_fractions(h: usize) -> (f64, f64, f64) {
|
||||
}
|
||||
|
||||
/// The closest index colour to an RGB value (1..=255).
|
||||
#[must_use]
|
||||
pub fn nearest_aci(c: Rgb) -> u8 {
|
||||
let mut best = (u32::MAX, 7u8);
|
||||
for i in 1..=255u8 {
|
||||
@@ -220,6 +235,7 @@ pub fn nearest_aci(c: Rgb) -> u8 {
|
||||
/// Display colour of `c` on `background`. Colour 7 (`aci7`) flips to contrast with the
|
||||
/// background, white on dark and black on light (paper), as CAD programs draw it; every other
|
||||
/// colour, including a true-colour or index white or black, keeps its RGB.
|
||||
#[must_use]
|
||||
pub fn display_rgb(c: Rgb, aci7: bool, background: Rgb) -> Rgb {
|
||||
if !aci7 {
|
||||
c
|
||||
@@ -286,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`
|
||||
|
||||
+18
-3
@@ -130,6 +130,10 @@ pub struct Drawing {
|
||||
/// Objects hidden for this session by ISOLATEOBJECTS / HIDEOBJECTS. Never written to a file:
|
||||
/// a drawing opens with everything shown again.
|
||||
pub hidden_objects: BTreeSet<Handle>,
|
||||
/// Model space's earlier UCSs for UCS Previous, oldest first (each layout keeps its own,
|
||||
/// [`Layout::ucs_previous`]). Part of the drawing so undo restores them with the UCS. Never
|
||||
/// written to a file.
|
||||
pub ucs_previous: Vec<Ucs>,
|
||||
/// What reading the file left out (a DWG's object records the reader couldn't decode), told
|
||||
/// to the user when the drawing opens. Never written to a file.
|
||||
pub read_notes: Vec<String>,
|
||||
@@ -201,6 +205,7 @@ impl Drawing {
|
||||
scales: imperial_scales(),
|
||||
handseed: 0x100,
|
||||
hidden_objects: BTreeSet::new(),
|
||||
ucs_previous: Vec::new(),
|
||||
read_notes: Vec::new(),
|
||||
refedit: None,
|
||||
skipped_records: BTreeMap::new(),
|
||||
@@ -209,12 +214,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)),
|
||||
@@ -856,6 +857,14 @@ pub struct Layout {
|
||||
/// Saved paper-space view (centre, height).
|
||||
#[serde(default)]
|
||||
pub view: Option<(Vec2, f64)>,
|
||||
/// The layout's current paper-space UCS (the LAYOUT object's groups 13, 16, 17 and 345);
|
||||
/// `None`: the World UCS. Its name is empty when it isn't a named UCS.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub ucs: Option<Ucs>,
|
||||
/// The layout's earlier UCSs for UCS Previous, oldest first: they go with the layout when it
|
||||
/// is renamed and with it when it is deleted. Never written to a file.
|
||||
#[serde(skip)]
|
||||
pub ucs_previous: Vec<Ucs>,
|
||||
/// The layout's limits (LAYOUT groups 10/11, lower left and upper right) as the file had
|
||||
/// them; `None` for a layout CADCraft made, written as 0,0 to 12,9 (#2109).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
@@ -864,7 +873,16 @@ pub struct Layout {
|
||||
|
||||
impl Layout {
|
||||
pub fn new(name: &str, tab_order: u32) -> Self {
|
||||
Layout { name: name.into(), tab_order, page: PageSetup::default(), entities: EntityStore::new(), view: None, limits: None }
|
||||
Layout {
|
||||
name: name.into(),
|
||||
tab_order,
|
||||
page: PageSetup::default(),
|
||||
entities: EntityStore::new(),
|
||||
view: None,
|
||||
ucs: None,
|
||||
ucs_previous: Vec::new(),
|
||||
limits: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
[package]
|
||||
name = "cadcraft-dwg"
|
||||
description = "CADCraft DWG bridge: converts DWG to and from DXF bytes using the acadrust crate (MPL-2.0, used unmodified)"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
log = { workspace = true }
|
||||
|
||||
# The same targets as build.rs's `no_dwg_bridge` leave acadrust out: wasm32, and FreeBSD aarch64,
|
||||
# where acadrust 0.6.6 passes a `*const c_char` (u8 there) to its own `*const i8` sysctlbyname.
|
||||
# 0.6.7 and 0.6.8 fix that but read some damaged DWGs as empty with no note (tests.rs, #800).
|
||||
[target.'cfg(not(any(target_arch = "wasm32", all(target_os = "freebsd", target_arch = "aarch64"))))'.dependencies]
|
||||
# MPL-2.0: used as an unmodified dependency only (see plan/adr/0001 and NOTICE).
|
||||
acadrust = "0.6.6"
|
||||
@@ -1,12 +0,0 @@
|
||||
//! Sets `no_dwg_bridge` on the targets built without acadrust (see Cargo.toml): the DWG functions
|
||||
//! there return an error that says to use DXF.
|
||||
|
||||
fn main() {
|
||||
println!("cargo:rerun-if-changed=build.rs");
|
||||
println!("cargo::rustc-check-cfg=cfg(no_dwg_bridge)");
|
||||
let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
|
||||
let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
|
||||
if arch == "wasm32" || (os == "freebsd" && arch == "aarch64") {
|
||||
println!("cargo::rustc-cfg=no_dwg_bridge");
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,632 +0,0 @@
|
||||
//! Another application's entities and their classes through the DWG bridge: on reading a DWG,
|
||||
//! registered entities acadrust has no model for become proxy entities of their class; on writing
|
||||
//! one, the DWG gets the source DXF's classes in their places, so every proxy names its own class.
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use acadrust::CadDocument;
|
||||
use acadrust::classes::{DxfClass, ProxyFlags};
|
||||
use acadrust::entities::{EntityType, ExtendedEntityData, ProxyEntityData};
|
||||
use acadrust::objects::{ObjectType, ProxyPayload};
|
||||
|
||||
fn class_number(index: usize) -> Result<i16, String> {
|
||||
index.checked_add(500).and_then(|n| i16::try_from(n).ok()).ok_or_else(|| "DXF: too many application classes".into())
|
||||
}
|
||||
|
||||
/// After a DWG read: each registered entity of another application's class that acadrust keeps
|
||||
/// only as its record and opaque data (no decoded properties) becomes a proxy entity of that class
|
||||
/// (DXF Reference, ACAD_PROXY_ENTITY), with its graphics, data bits, R2007+ strings and object
|
||||
/// references, so the DXF keeps it; and every proxy's class number becomes 500 plus its class's
|
||||
/// place in the classes, as a DXF numbers it. A record that can't be converted (its class is
|
||||
/// missing or not unique) is left out and named in the notes; one with decoded properties stays as
|
||||
/// read, also named, as its opaque data has no DXF form beside them.
|
||||
pub(super) fn prepare(doc: &mut CadDocument) -> Vec<String> {
|
||||
let classes: Vec<_> = doc.classes.iter().cloned().collect();
|
||||
let mut numbers = HashMap::new();
|
||||
let mut identities = HashMap::new();
|
||||
for (index, class) in classes.iter().enumerate() {
|
||||
let number = class_number(index).ok();
|
||||
numbers.entry(i32::from(class.class_number)).and_modify(|v| *v = None).or_insert(number.map(i32::from));
|
||||
let identity = (class.dxf_name.as_str(), class.cpp_class_name.as_str(), class.is_an_entity);
|
||||
identities.entry(identity).and_modify(|v| *v = None).or_insert(number);
|
||||
}
|
||||
let identity = |dxf: &str, cpp: &str, entity: bool| {
|
||||
identities
|
||||
.get(&(dxf, cpp, entity))
|
||||
.copied()
|
||||
.flatten()
|
||||
.map(i32::from)
|
||||
.ok_or_else(|| format!("missing or ambiguous application CLASS for {dxf:.80} ({cpp:.80})"))
|
||||
};
|
||||
let Some(dwg_version) = super::native::proxy_dwg_version(doc.dwg_source_version.unwrap_or(doc.version)) else { return Vec::new() };
|
||||
let maintenance = i32::from(doc.maintenance_version);
|
||||
let remap = |id: i32| numbers.get(&id).copied().flatten().ok_or_else(|| format!("proxy names missing or ambiguous application class {id}"));
|
||||
// Only mutate proxies: entities_mut invalidates the decoder's verbatim records for every entity.
|
||||
let handles: Vec<_> = doc
|
||||
.entities()
|
||||
.filter_map(|e| match e {
|
||||
EntityType::Extended(e) => match &e.data {
|
||||
ExtendedEntityData::Proxy(_) => Some(e.common.handle),
|
||||
ExtendedEntityData::RegisteredClass(data) if data.properties.is_empty() || data.payload.bit_count > 0 => Some(e.common.handle),
|
||||
_ => None,
|
||||
},
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
let mut notes = Vec::new();
|
||||
let mut entity_count = 0usize;
|
||||
let mut object_count = 0usize;
|
||||
let mut semantic = 0usize;
|
||||
for handle in handles {
|
||||
// Ok(None): not an application record; Ok(Some(None)): kept as read, with its properties.
|
||||
let converted = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<Option<Option<ExtendedEntityData>>, String> {
|
||||
let Some(EntityType::Extended(entity)) = doc.get_entity(handle) else { return Ok(None) };
|
||||
let data = match &entity.data {
|
||||
ExtendedEntityData::Proxy(data) => {
|
||||
let mut proxy = data.clone();
|
||||
proxy.class_id = remap(proxy.class_id)?;
|
||||
ExtendedEntityData::Proxy(proxy)
|
||||
}
|
||||
ExtendedEntityData::RegisteredClass(data) => {
|
||||
if !data.properties.is_empty() {
|
||||
return Ok(Some(None));
|
||||
}
|
||||
let class_id = identity(&data.dxf_name, &data.cpp_class_name, true)?;
|
||||
let text_payload = entity.common.raw_record.as_deref().map(registered_text).transpose()?.unwrap_or_default();
|
||||
ExtendedEntityData::Proxy(ProxyEntityData {
|
||||
proxy_id: 498,
|
||||
class_id,
|
||||
dxf_subclass: String::new(),
|
||||
version: (maintenance << 16) | dwg_version,
|
||||
dwg_version,
|
||||
maintenance_version: maintenance,
|
||||
from_dxf: false,
|
||||
graphics: ProxyPayload::from_bytes(entity.common.graphic_data.as_deref().unwrap_or_default()),
|
||||
payload: data.payload.clone(),
|
||||
text_payload,
|
||||
object_ids: data.object_ids.clone(),
|
||||
})
|
||||
}
|
||||
_ => return Ok(None),
|
||||
};
|
||||
Ok(Some(Some(data)))
|
||||
}))
|
||||
.unwrap_or_else(|_| Err("application record conversion failed".into()));
|
||||
match converted {
|
||||
Ok(Some(Some(data))) => {
|
||||
if let Some(EntityType::Extended(entity)) = doc.get_entity_mut(handle) {
|
||||
entity.data = data;
|
||||
}
|
||||
}
|
||||
Ok(Some(None)) => semantic = semantic.saturating_add(1),
|
||||
Ok(None) => {}
|
||||
Err(why) => {
|
||||
doc.remove_entity(handle);
|
||||
entity_count = entity_count.saturating_add(1);
|
||||
skipped_note(&mut notes, "entity", handle, &why);
|
||||
}
|
||||
}
|
||||
}
|
||||
doc.objects.retain(|handle, object| {
|
||||
if let ObjectType::ProxyObject(proxy) = object {
|
||||
match remap(proxy.class_id) {
|
||||
Ok(id) => proxy.class_id = id,
|
||||
Err(why) => {
|
||||
object_count = object_count.saturating_add(1);
|
||||
skipped_note(&mut notes, "object", *handle, &why);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
true
|
||||
});
|
||||
if entity_count > 0 || object_count > 0 {
|
||||
notes.insert(0, format!("DWG: partial read; application proxy records left out (entities: {entity_count}, objects: {object_count})"));
|
||||
}
|
||||
if semantic > 0 {
|
||||
notes.push(format!(
|
||||
"DWG: {semantic} registered entities with decoded properties keep them, without their other data; saving over the original file would lose it"
|
||||
));
|
||||
}
|
||||
notes
|
||||
}
|
||||
|
||||
fn skipped_note(notes: &mut Vec<String>, kind: &str, handle: acadrust::types::Handle, why: &str) {
|
||||
if notes.len() < 6 {
|
||||
let why: String = why.chars().take(256).collect();
|
||||
notes.push(format!("DWG: proxy {kind} {handle} left out: {why}"));
|
||||
}
|
||||
}
|
||||
|
||||
/// The decoder's registered-class representation omits the separate R2007+ string stream.
|
||||
fn registered_text(raw: &acadrust::entities::RawRecord) -> Result<ProxyPayload, String> {
|
||||
use acadrust::io::dwg::DwgVersion;
|
||||
use acadrust::io::dwg::dwg_stream_readers::object_reader::DwgObjectReader;
|
||||
use acadrust::io::dwg::dwg_stream_writers::bit_writer::DwgBitWriter;
|
||||
use acadrust::types::DxfVersion;
|
||||
|
||||
if raw.version < DxfVersion::AC1021 {
|
||||
return Ok(ProxyPayload::default());
|
||||
}
|
||||
let version = DwgVersion::from_dxf_version(raw.version).map_err(|e| format!("DWG proxy text: {e}"))?;
|
||||
let handle_bits = usize::try_from(raw.handle_bits).map_err(|_| "DWG proxy text: negative handle stream size")?;
|
||||
let total_bits = raw.data.len().checked_mul(8).ok_or("DWG proxy text: record too large")?;
|
||||
if handle_bits > total_bits {
|
||||
return Err("DWG proxy text: handle stream exceeds record".into());
|
||||
}
|
||||
// Frame the verbatim record for the dependency's checked object reader.
|
||||
let mut frame = DwgBitWriter::new(version, raw.version);
|
||||
frame.write_modular_short(raw.data.len());
|
||||
if raw.version >= DxfVersion::AC1024 {
|
||||
frame.write_modular_char(handle_bits);
|
||||
}
|
||||
frame.write_bytes(&raw.data);
|
||||
let reader = DwgObjectReader::new(frame.into_bytes(), raw.version, HashMap::new()).map_err(|e| format!("DWG proxy text: {e}"))?;
|
||||
let (kind, mut streams) = reader.read_record_at(0).map_err(|e| format!("DWG proxy text: {e}"))?;
|
||||
reader.read_common_entity_data(&mut streams, kind);
|
||||
if kind == 498 {
|
||||
// An existing registered-class envelope is a proxy and carries its class name first.
|
||||
streams.read_variable_text();
|
||||
} else if kind < 500 {
|
||||
return Err("DWG proxy text: registered entity has no application class".into());
|
||||
}
|
||||
streams.check_error().map_err(|e| format!("DWG proxy text: {e}"))?;
|
||||
let bits = usize::try_from(streams.text_remaining_bits()).map_err(|_| "DWG proxy text: negative string stream size")?;
|
||||
if bits > total_bits {
|
||||
return Err("DWG proxy text: string stream exceeds record".into());
|
||||
}
|
||||
let count = u32::try_from(bits).map_err(|_| "DWG proxy text: string stream too large")?;
|
||||
let mut bytes = vec![0; bits.div_ceil(8)];
|
||||
for (index, byte) in bytes.iter_mut().enumerate() {
|
||||
for bit in 0..8.min(bits.saturating_sub(index * 8)) {
|
||||
if streams.read_text_bit() {
|
||||
*byte |= 0x80 >> bit;
|
||||
}
|
||||
}
|
||||
}
|
||||
streams.check_error().map_err(|e| format!("DWG proxy text: {e}"))?;
|
||||
Ok(ProxyPayload::from_bits(&bytes, count))
|
||||
}
|
||||
|
||||
/// ASCII DXF pairs decoded with the bridge's public code-page and escape codecs. A malformed
|
||||
/// pair yields `None`, so both class scans fall back rather than guessing its identity.
|
||||
pub(super) fn text_pairs(dxf: &[u8]) -> Option<impl Iterator<Item = Option<(i32, String)>> + '_> {
|
||||
use acadrust::io::dxf::code_page::{decode_legacy_escapes, encoding_from_code_page};
|
||||
|
||||
if dxf.starts_with(b"AutoCAD Binary DXF") {
|
||||
return None;
|
||||
}
|
||||
let version =
|
||||
super::native::header_value(dxf, b"$ACADVER").and_then(|(_, v)| std::str::from_utf8(v).ok()).map(acadrust::DxfVersion::from_version_string);
|
||||
let unicode = version.is_some_and(|v| v >= acadrust::DxfVersion::AC1021);
|
||||
let encoding = if version.is_some_and(|v| v < acadrust::DxfVersion::AC1021) {
|
||||
super::native::header_value(dxf, b"$DWGCODEPAGE").and_then(|(_, page)| std::str::from_utf8(page).ok()).and_then(encoding_from_code_page)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut lines = dxf.split(|b| *b == b'\n').map(|line| line.strip_suffix(b"\r").unwrap_or(line));
|
||||
Some(std::iter::from_fn(move || {
|
||||
let code = lines.next()?;
|
||||
let Some(value) = lines.next() else { return (!code.trim_ascii().is_empty()).then_some(None) };
|
||||
let pair = || {
|
||||
let code = std::str::from_utf8(code).ok()?.trim().parse().ok()?;
|
||||
let text = if let Some(encoding) = encoding {
|
||||
encoding.decode(value).0.into_owned()
|
||||
} else if unicode {
|
||||
String::from_utf8_lossy(value).into_owned()
|
||||
} else {
|
||||
// The decoder uses UTF-8 with Latin-1 fallback when no encoding was declared.
|
||||
std::str::from_utf8(value).map_or_else(|_| value.iter().map(|&b| char::from(b)).collect(), str::to_string)
|
||||
};
|
||||
let text = decode_legacy_escapes(&text);
|
||||
// DXF's escaped control characters are decoded after CIF/MIF, as in the bridge.
|
||||
let text = text.replace("^J", "\n").replace("^M", "\r").replace("^I", "\t").replace("^ ", "^");
|
||||
Some((code, text))
|
||||
};
|
||||
Some(pair())
|
||||
}))
|
||||
}
|
||||
|
||||
/// The CLASS records of an ASCII DXF, in CLASSES order and numbered by place from 500 (DXF
|
||||
/// Reference, CLASSES; a proxy's group 91 is that number). `None` for a binary DXF (CADCraft's own
|
||||
/// bridge DXF is ASCII), and for one with a record that can't be written back as it is: no names,
|
||||
/// flags or instance count out of range, more classes than the numbers allow. Then
|
||||
/// `proxy_classes` matches the classes by name instead.
|
||||
pub(super) fn source_classes(dxf: &[u8]) -> Option<Vec<DxfClass>> {
|
||||
let pairs = text_pairs(dxf)?;
|
||||
let mut records: Vec<Vec<(i32, String)>> = Vec::new();
|
||||
let (mut section, mut in_classes) = (false, false);
|
||||
for pair in pairs {
|
||||
let (code, value) = pair?;
|
||||
match (code, value.as_str()) {
|
||||
(0, "ENDSEC") if in_classes => break,
|
||||
(0, "SECTION") => section = true,
|
||||
(2, name) if section => {
|
||||
in_classes = name == "CLASSES";
|
||||
section = false;
|
||||
}
|
||||
(0, kind) if in_classes => {
|
||||
if kind != "CLASS" {
|
||||
return None;
|
||||
}
|
||||
records.push(Vec::new());
|
||||
}
|
||||
(code, value) if in_classes => records.last_mut()?.push((code, value.to_string())),
|
||||
_ => section = false,
|
||||
}
|
||||
}
|
||||
records.iter().enumerate().map(|(index, groups)| source_class(groups, class_number(index).ok()?)).collect()
|
||||
}
|
||||
|
||||
/// One CLASS record's groups as the class `number`, or `None` when it can't be written back.
|
||||
fn source_class(groups: &[(i32, String)], number: i16) -> Option<DxfClass> {
|
||||
let text = |code| groups.iter().find(|(c, _)| *c == code).map(|(_, v)| v.clone()).unwrap_or_default();
|
||||
let integer = |code| groups.iter().find(|(c, _)| *c == code).map_or(Some(0), |(_, v)| v.trim().parse::<i64>().ok());
|
||||
let mut class = DxfClass::new(text(1), text(2));
|
||||
if class.dxf_name.is_empty() || class.cpp_class_name.is_empty() {
|
||||
return None;
|
||||
}
|
||||
class.application_name = text(3);
|
||||
class.proxy_flags = ProxyFlags(u16::try_from(integer(90)?).ok()?);
|
||||
class.instance_count = i32::try_from(integer(91)?).ok()?;
|
||||
class.was_zombie = integer(280)? != 0;
|
||||
class.is_an_entity = integer(281)? != 0;
|
||||
class.item_class_id = if class.is_an_entity { 498 } else { 499 };
|
||||
class.class_number = number;
|
||||
Some(class)
|
||||
}
|
||||
|
||||
/// Give a DWG of 2013 or later the source DXF's classes (`classes`, from [`source_classes`]) in
|
||||
/// their places, with their metadata and duplicate names, so each proxy's DXF class number names
|
||||
/// its own class; the decoder's default classes the source lacks follow them. A proxy whose number
|
||||
/// names no source class is left out, as `proxy_classes` leaves it out. Returns how many proxy objects and
|
||||
/// entities were left out; nothing changes when the drawing has no proxies. `None`, with nothing
|
||||
/// changed, when the classes would be more than the class numbers allow.
|
||||
pub(super) fn restore_classes(doc: &mut CadDocument, classes: Vec<DxfClass>) -> Option<(usize, usize)> {
|
||||
let fits = |number: i32| number.checked_sub(500).and_then(|n| usize::try_from(n).ok()).is_some_and(|i| i < classes.len());
|
||||
let mut any = false;
|
||||
let mut entities = Vec::new();
|
||||
for entity in doc.entities() {
|
||||
if let EntityType::Extended(e) = entity
|
||||
&& let ExtendedEntityData::Proxy(p) = &e.data
|
||||
{
|
||||
any = true;
|
||||
if !fits(p.class_id) {
|
||||
entities.push(e.common.handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut objects = Vec::new();
|
||||
for (handle, object) in &doc.objects {
|
||||
if let ObjectType::ProxyObject(p) = object {
|
||||
any = true;
|
||||
if !fits(p.class_id) {
|
||||
objects.push(*handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
if !any {
|
||||
return Some((0, 0));
|
||||
}
|
||||
let mut names: HashSet<_> = classes.iter().map(|c| c.dxf_name.to_uppercase()).collect();
|
||||
let defaults: Vec<_> = doc.classes.iter().filter(|c| names.insert(c.dxf_name.to_uppercase())).cloned().collect();
|
||||
if let Some(last) = classes.len().checked_add(defaults.len())?.checked_sub(1) {
|
||||
class_number(last).ok()?;
|
||||
}
|
||||
for handle in &entities {
|
||||
doc.remove_entity(*handle);
|
||||
}
|
||||
for handle in &objects {
|
||||
doc.objects.remove(handle);
|
||||
}
|
||||
doc.classes.clear();
|
||||
for (index, mut class) in classes.into_iter().chain(defaults).enumerate() {
|
||||
class.class_number = class_number(index).ok()?;
|
||||
doc.classes.push_preserving(class);
|
||||
}
|
||||
Some((objects.len(), entities.len()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use acadrust::entities::{EntityCommon, ExtendedEntity, RegisteredClassEntityData};
|
||||
use acadrust::types::DxfVersion;
|
||||
|
||||
fn proxy_doc() -> CadDocument {
|
||||
let mut doc = CadDocument::new();
|
||||
doc.version = DxfVersion::AC1032;
|
||||
doc.add_entity(EntityType::Extended(Box::new(ExtendedEntity {
|
||||
common: EntityCommon::default(),
|
||||
data: ExtendedEntityData::Proxy(ProxyEntityData {
|
||||
proxy_id: 498,
|
||||
class_id: 501,
|
||||
dxf_subclass: String::new(),
|
||||
version: 33,
|
||||
dwg_version: 33,
|
||||
maintenance_version: 0,
|
||||
from_dxf: false,
|
||||
graphics: ProxyPayload::default(),
|
||||
payload: ProxyPayload::from_bits(&[0x80], 1),
|
||||
text_payload: ProxyPayload::default(),
|
||||
object_ids: vec![],
|
||||
}),
|
||||
})))
|
||||
.unwrap();
|
||||
doc
|
||||
}
|
||||
|
||||
/// An ASCII DXF of `groups`, `(code, value)` per pair of lines.
|
||||
fn dxf(groups: &[(i32, &str)]) -> Vec<u8> {
|
||||
groups.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect::<String>().into_bytes()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn source_classes_keep_duplicates_and_metadata_before_defaults() {
|
||||
let bytes = dxf(&[
|
||||
(0, "SECTION"),
|
||||
(2, "HEADER"),
|
||||
(9, "$DIMSTYLE"),
|
||||
(2, "CLASSES"),
|
||||
(0, "ENDSEC"),
|
||||
(0, "SECTION"),
|
||||
(2, "CLASSES"),
|
||||
(0, "CLASS"),
|
||||
(1, "Объект"),
|
||||
(2, "First"),
|
||||
(3, "Первый"),
|
||||
(90, "1025"),
|
||||
(91, "7"),
|
||||
(280, "1"),
|
||||
(281, "1"),
|
||||
(0, "CLASS"),
|
||||
(1, "Объект"),
|
||||
(2, "Second"),
|
||||
(3, "Второй"),
|
||||
(90, "128"),
|
||||
(281, "1"),
|
||||
(0, "ENDSEC"),
|
||||
(0, "EOF"),
|
||||
]);
|
||||
let classes = source_classes(&bytes).unwrap();
|
||||
assert_eq!(classes.len(), 2);
|
||||
assert_eq!(classes[0].application_name, "Первый");
|
||||
assert_eq!(classes[0].proxy_flags.0, 1025);
|
||||
assert_eq!(classes[0].instance_count, 7);
|
||||
assert!(classes[0].was_zombie);
|
||||
assert_eq!((classes[0].class_number, classes[1].class_number), (500, 501));
|
||||
assert_eq!(classes[1].cpp_class_name, "Second");
|
||||
let mut doc = proxy_doc();
|
||||
assert_eq!(restore_classes(&mut doc, classes.clone()), Some((0, 0)));
|
||||
assert_eq!(doc.classes.iter().take(2).cloned().collect::<Vec<_>>(), classes);
|
||||
// A binary DXF, and a CLASS record that can't be written back as it is, give no classes.
|
||||
assert!(source_classes(b"AutoCAD Binary DXF\r\n\x1a\0").is_none());
|
||||
for (code, value) in [(1, ""), (2, ""), (90, "65536"), (91, "9223372036854775807"), (281, "x")] {
|
||||
let mut class = vec![(1, "A"), (2, "A")];
|
||||
class.retain(|(c, _)| *c != code);
|
||||
class.push((code, value));
|
||||
let mut groups = vec![(0, "SECTION"), (2, "CLASSES"), (0, "CLASS")];
|
||||
groups.extend(class);
|
||||
groups.extend([(0, "ENDSEC"), (0, "EOF")]);
|
||||
assert!(source_classes(&dxf(&groups)).is_none(), "{code} {value}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn source_classes_decode_escapes_once_and_respect_legacy_code_pages() {
|
||||
let body = "0\nCLASS\n1\n\\U+041E\\U+0431\\U+044A\\U+0435\\U+043A\\U+0442\n2\nClass\n3\nCaf\\U+00E9\\U+D83D\\U+DE42\\U+005CU+0041\n281\n1\n0\nENDSEC\n0\nEOF\n";
|
||||
let text = format!("0\nSECTION\n2\nCLASSES\n{body}");
|
||||
let classes = source_classes(text.as_bytes()).unwrap();
|
||||
assert_eq!(classes[0].dxf_name, "Объект");
|
||||
assert_eq!(classes[0].application_name, "Café🙂\\U+0041");
|
||||
|
||||
let prefix =
|
||||
b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1251\n0\nENDSEC\n0\nSECTION\n2\nCLASSES\n0\nCLASS\n1\n";
|
||||
let encoded = [prefix.as_slice(), b"\xCF\xF0\xE8\xEC\xE5\xF0", b"\n2\nClass\n3\nApp\n281\n1\n0\nENDSEC\n0\nEOF\n"].concat();
|
||||
assert_eq!(source_classes(&encoded).unwrap()[0].dxf_name, "Пример");
|
||||
// R2007+ text is UTF-8 even with a legacy code-page declaration.
|
||||
let modern = String::from_utf8_lossy(prefix).replace("AC1015", "AC1032") + "Пример\n2\nClass\n3\nApp\n281\n1\n0\nENDSEC\n0\nEOF\n";
|
||||
assert_eq!(source_classes(modern.as_bytes()).unwrap()[0].dxf_name, "Пример");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn proxies_of_missing_classes_are_left_out() {
|
||||
for id in [-1, 499, 501, i32::MAX] {
|
||||
let mut doc = proxy_doc();
|
||||
if let Some(EntityType::Extended(e)) = doc.entities_mut().next()
|
||||
&& let ExtendedEntityData::Proxy(p) = &mut e.data
|
||||
{
|
||||
p.class_id = id;
|
||||
}
|
||||
let mut class = DxfClass::new_entity("ENTITY", "Entity");
|
||||
class.class_number = 500;
|
||||
assert_eq!(restore_classes(&mut doc, vec![class]), Some((0, 1)), "{id}");
|
||||
assert_eq!(doc.entities().count(), 0);
|
||||
}
|
||||
// Class 501 is there: the proxy keeps it, in its place.
|
||||
let mut doc = proxy_doc();
|
||||
assert_eq!(restore_classes(&mut doc, vec![DxfClass::new("A", "A"), DxfClass::new_entity("B", "B")]), Some((0, 0)));
|
||||
assert_eq!(doc.entities().count(), 1);
|
||||
assert_eq!(doc.classes.iter().nth(1).map(|c| (c.dxf_name.clone(), c.class_number)), Some(("B".to_string(), 501)));
|
||||
// Without proxies the classes stay the decoder's.
|
||||
let mut doc = CadDocument::new();
|
||||
let before: Vec<_> = doc.classes.iter().cloned().collect();
|
||||
assert_eq!(restore_classes(&mut doc, vec![DxfClass::new("A", "A")]), Some((0, 0)));
|
||||
assert_eq!(doc.classes.iter().cloned().collect::<Vec<_>>(), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unrepresentable_proxies_keep_other_geometry_and_bounded_diagnostics() {
|
||||
use acadrust::entities::{Line, RawRecord};
|
||||
use acadrust::objects::ProxyObject;
|
||||
use acadrust::types::{Handle, Vector3};
|
||||
for count in [1, 10] {
|
||||
let mut doc = proxy_doc();
|
||||
if let Some(EntityType::Extended(e)) = doc.entities_mut().next()
|
||||
&& let ExtendedEntityData::Proxy(p) = &mut e.data
|
||||
{
|
||||
p.class_id = i32::MAX;
|
||||
}
|
||||
let template = doc.entities().next().unwrap().clone();
|
||||
for _ in 1..count {
|
||||
let mut entity = template.clone();
|
||||
entity.common_mut().handle = Handle::NULL;
|
||||
doc.add_entity(entity).unwrap();
|
||||
}
|
||||
let object = Handle::new(u64::MAX - 1);
|
||||
assert!(!doc.objects.contains_key(&object));
|
||||
doc.objects.insert(object, ObjectType::ProxyObject(ProxyObject { handle: object, class_id: i32::MAX, ..Default::default() }));
|
||||
let line = doc.add_entity(EntityType::Line(Line::from_points(Vector3::new(2.0, 3.0, 0.0), Vector3::new(12.0, 13.0, 0.0)))).unwrap();
|
||||
let raw = RawRecord { data: vec![0xAA, 0x55], handle_bits: 0, version: DxfVersion::AC1032 };
|
||||
doc.get_entity_mut(line).unwrap().common_mut().raw_record = Some(std::sync::Arc::new(raw.clone()));
|
||||
let notes = prepare(&mut doc);
|
||||
assert_eq!(notes.len(), (count + 1).min(6) + 1);
|
||||
assert!(notes.iter().all(|n| n.starts_with("DWG:")));
|
||||
assert!(notes[0].contains(&format!("entities: {count}, objects: 1")));
|
||||
assert_eq!(doc.entities().count(), 1);
|
||||
assert!(!doc.objects.contains_key(&object));
|
||||
let Some(EntityType::Line(actual)) = doc.get_entity(line) else { panic!("readable line") };
|
||||
assert_eq!(actual.start, Vector3::new(2.0, 3.0, 0.0));
|
||||
assert_eq!(actual.end, Vector3::new(12.0, 13.0, 0.0));
|
||||
assert_eq!(doc.get_entity(line).unwrap().common().raw_record.as_deref(), Some(&raw));
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn opaque_registered_class_ambiguity_is_not_guessed() {
|
||||
let mut doc = CadDocument::new();
|
||||
doc.classes.push_preserving(DxfClass::new_entity("CUSTOM", "Custom"));
|
||||
doc.classes.push_preserving(DxfClass::new_entity("CUSTOM", "Custom"));
|
||||
doc.add_entity(EntityType::Extended(Box::new(ExtendedEntity {
|
||||
common: EntityCommon::default(),
|
||||
data: ExtendedEntityData::RegisteredClass(RegisteredClassEntityData {
|
||||
dxf_name: "CUSTOM".into(),
|
||||
cpp_class_name: "Custom".into(),
|
||||
properties: vec![],
|
||||
payload: ProxyPayload::from_bits(&[0x80], 1),
|
||||
object_ids: vec![],
|
||||
}),
|
||||
})))
|
||||
.unwrap();
|
||||
assert!(prepare(&mut doc).iter().any(|n| n.contains("ambiguous")));
|
||||
assert_eq!(doc.entities().count(), 0);
|
||||
assert!(class_number(usize::MAX).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn semantic_records_keep_verbatim_data_and_mixed_payloads_are_reported() {
|
||||
use acadrust::entities::RawRecord;
|
||||
use acadrust::objects::{SemanticProperty, SemanticPropertyValue};
|
||||
for payload in [ProxyPayload::default(), ProxyPayload::from_bits(&[0x80], 1)] {
|
||||
let mut doc = CadDocument::new();
|
||||
let raw = RawRecord { data: vec![0xAA], handle_bits: 0, version: DxfVersion::AC1032 };
|
||||
let handle = doc
|
||||
.add_entity(EntityType::Extended(Box::new(ExtendedEntity {
|
||||
common: EntityCommon::default(),
|
||||
data: ExtendedEntityData::RegisteredClass(RegisteredClassEntityData {
|
||||
dxf_name: "SEMANTIC".into(),
|
||||
cpp_class_name: "Semantic".into(),
|
||||
properties: vec![SemanticProperty {
|
||||
subclass: "Semantic".into(),
|
||||
code: 1,
|
||||
value: SemanticPropertyValue::Text("value".into()),
|
||||
}],
|
||||
payload: payload.clone(),
|
||||
object_ids: vec![],
|
||||
}),
|
||||
})))
|
||||
.unwrap();
|
||||
doc.get_entity_mut(handle).unwrap().common_mut().raw_record = Some(std::sync::Arc::new(raw.clone()));
|
||||
assert_eq!(doc.get_entity(handle).unwrap().common().raw_record.as_deref(), Some(&raw));
|
||||
if payload.bit_count == 0 {
|
||||
assert!(prepare(&mut doc).is_empty());
|
||||
assert_eq!(doc.get_entity(handle).unwrap().common().raw_record.as_deref(), Some(&raw));
|
||||
} else {
|
||||
// Kept as read, and named: its opaque data has no DXF form beside the properties.
|
||||
assert!(prepare(&mut doc).iter().any(|n| n.contains("decoded properties")));
|
||||
assert_eq!(doc.get_entity(handle).unwrap().common().raw_record.as_deref(), Some(&raw));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod string_stream_tests {
|
||||
use super::*;
|
||||
use acadrust::entities::{EntityCommon, ExtendedEntity, RawRecord, RegisteredClassEntityData};
|
||||
use acadrust::types::DxfVersion;
|
||||
use std::io::Cursor;
|
||||
|
||||
#[test]
|
||||
fn registered_transport_recovers_separate_non_byte_aligned_strings() {
|
||||
for version in [DxfVersion::AC1027, DxfVersion::AC1032] {
|
||||
let mut source = CadDocument::new();
|
||||
source.version = version;
|
||||
source.classes.add_or_update(DxfClass::new_entity("CUSTOM_TEXT", "CustomText"));
|
||||
let class_id = i32::from(source.classes.get_by_name("CUSTOM_TEXT").unwrap().class_number);
|
||||
let text = ProxyPayload::from_bits(&[0xA5, 0xC7, 0xE0], 19);
|
||||
let payload = ProxyPayload::from_bits(&[0x80], 1);
|
||||
source
|
||||
.add_entity(EntityType::Extended(Box::new(ExtendedEntity {
|
||||
common: EntityCommon::default(),
|
||||
data: ExtendedEntityData::Proxy(ProxyEntityData {
|
||||
proxy_id: 498,
|
||||
class_id,
|
||||
dxf_subclass: "CustomText".into(),
|
||||
version: 33,
|
||||
dwg_version: 33,
|
||||
maintenance_version: 0,
|
||||
from_dxf: false,
|
||||
graphics: ProxyPayload::default(),
|
||||
payload: payload.clone(),
|
||||
text_payload: text.clone(),
|
||||
object_ids: vec![],
|
||||
}),
|
||||
})))
|
||||
.unwrap();
|
||||
let bytes = acadrust::DwgWriter::write_to_vec(&source).unwrap();
|
||||
let mut decoded = acadrust::DwgReader::from_stream(Cursor::new(bytes)).read().unwrap();
|
||||
let entity = decoded.entities().next().unwrap();
|
||||
let handle = entity.common().handle;
|
||||
let raw = entity.common().raw_record.clone().unwrap();
|
||||
assert_eq!(registered_text(&raw).unwrap().data(), text.data());
|
||||
assert_eq!(registered_text(&raw).unwrap().bit_count, 19);
|
||||
let EntityType::Extended(entity) = decoded.get_entity_mut(handle).unwrap() else { panic!() };
|
||||
entity.data = ExtendedEntityData::RegisteredClass(RegisteredClassEntityData {
|
||||
dxf_name: "CUSTOM_TEXT".into(),
|
||||
cpp_class_name: "CustomText".into(),
|
||||
properties: vec![],
|
||||
payload: payload.clone(),
|
||||
object_ids: vec![],
|
||||
});
|
||||
entity.common.raw_record = Some(raw);
|
||||
assert!(prepare(&mut decoded).is_empty());
|
||||
for _ in 0..2 {
|
||||
let mut dxf = Vec::new();
|
||||
acadrust::DxfWriter::new(&decoded).write_to_writer(&mut dxf).unwrap();
|
||||
let bytes = crate::dxf_to_dwg_as(&dxf, "AC1032").unwrap();
|
||||
decoded = acadrust::DwgReader::from_stream(Cursor::new(bytes)).read().unwrap();
|
||||
let p = decoded
|
||||
.entities()
|
||||
.find_map(|e| match e {
|
||||
EntityType::Extended(e) => match &e.data {
|
||||
ExtendedEntityData::Proxy(p) => Some(p),
|
||||
_ => None,
|
||||
},
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(p.payload.bit_count, 1);
|
||||
assert_eq!(p.payload.data(), payload.data());
|
||||
assert_eq!(p.text_payload.bit_count, 19);
|
||||
assert_eq!(p.text_payload.data(), text.data());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_string_stream_boundaries_return_errors() {
|
||||
for handle_bits in [-1, 1000] {
|
||||
let raw = RawRecord { data: vec![0; 8], handle_bits, version: DxfVersion::AC1032 };
|
||||
assert!(registered_text(&raw).is_err());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,378 +0,0 @@
|
||||
//! The DWG reader and writer in a child process.
|
||||
//!
|
||||
//! An allocation failure or stack overflow in the third-party code ends the process it runs in, and
|
||||
//! `catch_unwind` can't stop that. So the app runs them in a copy of itself: [`use_own_worker`] says
|
||||
//! how to start one, and [`serve_if_asked`], first thing in `main`, turns the copy into a worker
|
||||
//! that reads one request from standard input and writes one reply to standard output. A file that
|
||||
//! kills the worker then costs that one open or save, and every other open drawing stays safe.
|
||||
//!
|
||||
//! Without a worker (libraries, tests, a build that can't start one) [`decode`] and [`encode_as`]
|
||||
//! run in the calling process, as they always did. There's no memory limit on the worker yet: that
|
||||
//! takes per-platform system calls, which `unsafe_code = "forbid"` keeps out of this crate.
|
||||
//!
|
||||
//! A reply comes from a process that just handled a possibly hostile file, so it is parsed as
|
||||
//! untrusted input.
|
||||
|
||||
use std::ffi::OsString;
|
||||
use std::io::{Read, Write};
|
||||
use std::path::PathBuf;
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::Mutex;
|
||||
use std::sync::mpsc::{RecvTimeoutError, channel};
|
||||
use std::time::Duration;
|
||||
|
||||
use super::Limits;
|
||||
|
||||
/// The argument that makes the app a worker.
|
||||
pub const WORKER_ARG: &str = "--dwg-worker";
|
||||
/// Bumped when the messages change: an app updated while running may start a newer copy.
|
||||
const PROTOCOL: u8 = 2;
|
||||
const DECODE: u8 = 1;
|
||||
const ENCODE: u8 = 2;
|
||||
const CRASH: u8 = 0xff;
|
||||
/// How long one file may take before the worker is stopped. It can't be interrupted otherwise.
|
||||
const TIMEOUT: Duration = Duration::from_secs(30 * 60);
|
||||
/// Most bytes accepted for what a reply carries besides the drawing.
|
||||
const MAX_NOTES_BYTES: u64 = 64 << 20;
|
||||
/// Most bytes accepted as a written DWG.
|
||||
const MAX_DWG_REPLY: u64 = 2 << 30;
|
||||
/// Most bytes one request holds: the largest input, whichever the direction, and its header.
|
||||
const MAX_REQUEST: u64 = (2 << 30) + 256;
|
||||
|
||||
struct Worker {
|
||||
program: PathBuf,
|
||||
args: Vec<OsString>,
|
||||
}
|
||||
|
||||
static WORKER: Mutex<Option<Worker>> = Mutex::new(None);
|
||||
|
||||
/// Start `program args` as the worker from now on. `program` must call [`serve_if_asked`].
|
||||
pub fn use_worker(program: PathBuf, args: Vec<OsString>) {
|
||||
if let Ok(mut w) = WORKER.lock() {
|
||||
*w = Some(Worker { program, args });
|
||||
}
|
||||
}
|
||||
|
||||
/// Use a copy of this program as the worker, started with [`WORKER_ARG`]. If its path can't be
|
||||
/// found, the reader and writer stay in this process.
|
||||
pub fn use_own_worker() {
|
||||
match std::env::current_exe() {
|
||||
Ok(program) => use_worker(program, vec![WORKER_ARG.into()]),
|
||||
Err(e) => log::warn!("DWG worker: can't find this program: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Serve one request and return the exit code if this process was started as a worker.
|
||||
pub fn serve_if_asked() -> Option<i32> {
|
||||
(std::env::args_os().nth(1)? == WORKER_ARG).then(|| serve(std::io::stdin().lock(), std::io::stdout().lock()))
|
||||
}
|
||||
|
||||
/// [`super::dwg_to_dxf_noted`] in the worker, when there is one.
|
||||
pub fn decode(bytes: &[u8], limits: Limits) -> Result<(Vec<u8>, Vec<String>), String> {
|
||||
// Before starting a process, and so the same limit holds with or without one.
|
||||
if bytes.len() > limits.max_dwg_bytes {
|
||||
return super::dwg_to_dxf_noted(bytes, limits);
|
||||
}
|
||||
let reply_limit = (limits.max_dxf_bytes as u64).saturating_add(MAX_NOTES_BYTES);
|
||||
match call(&request(DECODE, limits, ""), bytes, reply_limit, "reading this file") {
|
||||
Some(reply) => reply?,
|
||||
None => super::dwg_to_dxf_noted(bytes, limits),
|
||||
}
|
||||
}
|
||||
|
||||
/// [`super::dxf_to_dwg_as`] in the worker, when there is one.
|
||||
pub fn encode_as(dxf: &[u8], version: &str) -> Result<Vec<u8>, String> {
|
||||
encode_noted(dxf, version).map(|(dwg, _)| dwg)
|
||||
}
|
||||
|
||||
/// [`super::dxf_to_dwg_noted`] in the worker, when there is one. What the writer left out comes
|
||||
/// back as notes of `TYPE<tab>count`.
|
||||
pub fn encode_noted(dxf: &[u8], version: &str) -> Result<(Vec<u8>, super::Unwritten), String> {
|
||||
encode_kept_noted(dxf, version, None)
|
||||
}
|
||||
|
||||
/// [`encode_noted`] for a DXF whose carried-over groups were read from a file of version `kept`
|
||||
/// ([`super::dxf_to_dwg_kept_noted`]); `None` is [`encode_noted`].
|
||||
pub fn encode_kept_noted(dxf: &[u8], version: &str, kept: Option<&str>) -> Result<(Vec<u8>, super::Unwritten), String> {
|
||||
if u8::try_from(version.len()).is_err() {
|
||||
return Err(super::unsupported(version));
|
||||
}
|
||||
// A kept version too long to send is no version CADCraft knows: it changes nothing.
|
||||
let kept = kept.filter(|k| u8::try_from(k.len()).is_ok());
|
||||
let mut header = request(ENCODE, Limits::DEFAULT, version);
|
||||
push_str(&mut header, kept.unwrap_or(""));
|
||||
match call(&header, dxf, MAX_DWG_REPLY, "writing this file") {
|
||||
Some(reply) => reply?.map(|(dwg, notes)| (dwg, unwritten_from(¬es))),
|
||||
None => encode_here(dxf, version, kept),
|
||||
}
|
||||
}
|
||||
|
||||
/// The conversion in this process.
|
||||
fn encode_here(dxf: &[u8], version: &str, kept: Option<&str>) -> Result<(Vec<u8>, super::Unwritten), String> {
|
||||
match kept {
|
||||
Some(kept) => super::dxf_to_dwg_kept_noted(dxf, version, kept),
|
||||
None => super::dxf_to_dwg_noted(dxf, version),
|
||||
}
|
||||
}
|
||||
|
||||
fn unwritten_from(notes: &[String]) -> super::Unwritten {
|
||||
notes.iter().filter_map(|n| n.split_once('\t')).filter_map(|(kind, n)| Some((kind.to_string(), n.parse::<usize>().ok()?))).fold(
|
||||
super::Unwritten::new(),
|
||||
|mut m, (kind, n)| {
|
||||
*m.entry(kind).or_insert(0) = n;
|
||||
m
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Make the worker abort, as the third-party code can: what the tests prove isolation with.
|
||||
#[doc(hidden)]
|
||||
pub fn crash_worker_for_test() -> Result<(), String> {
|
||||
call(&request(CRASH, Limits::DEFAULT, ""), &[], 1024, "testing").ok_or("no worker")??.map(|_| ())
|
||||
}
|
||||
|
||||
fn request(op: u8, limits: Limits, version: &str) -> Vec<u8> {
|
||||
let mut r = vec![PROTOCOL, op];
|
||||
r.extend((limits.max_dwg_bytes as u64).to_le_bytes());
|
||||
r.extend((limits.max_dxf_bytes as u64).to_le_bytes());
|
||||
push_str(&mut r, version);
|
||||
r
|
||||
}
|
||||
|
||||
/// `text` with a one-byte length before it; callers keep it under 256 bytes.
|
||||
fn push_str(r: &mut Vec<u8>, text: &str) {
|
||||
r.push(u8::try_from(text.len()).unwrap_or(0));
|
||||
r.extend(text.as_bytes());
|
||||
}
|
||||
|
||||
type Reply = Result<(Vec<u8>, Vec<String>), String>;
|
||||
|
||||
/// Run one request in a worker. `None`: none could be started, so the caller does the work.
|
||||
/// `Err`: the worker went wrong, and `doing` says at what, for the user.
|
||||
fn call(header: &[u8], payload: &[u8], reply_limit: u64, doing: &str) -> Option<Result<Reply, String>> {
|
||||
let mut command = {
|
||||
let worker = WORKER.lock().ok()?;
|
||||
let worker = worker.as_ref()?;
|
||||
let mut c = Command::new(&worker.program);
|
||||
c.args(&worker.args);
|
||||
c
|
||||
};
|
||||
command.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null());
|
||||
#[cfg(windows)]
|
||||
{
|
||||
use std::os::windows::process::CommandExt;
|
||||
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
|
||||
command.creation_flags(CREATE_NO_WINDOW);
|
||||
}
|
||||
let mut child = match command.spawn() {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
log::warn!("DWG worker: can't start it: {e}");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let (Some(mut to_child), Some(from_child)) = (child.stdin.take(), child.stdout.take()) else {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return None;
|
||||
};
|
||||
let received = std::thread::scope(|scope| {
|
||||
// Written beside the read: a worker that replies before it has read everything, or dies,
|
||||
// must block neither side. A failed write shows up as the reply going wrong.
|
||||
scope.spawn(move || {
|
||||
let _ = to_child.write_all(header).and_then(|()| to_child.write_all(payload));
|
||||
});
|
||||
let (tx, rx) = channel();
|
||||
scope.spawn(move || {
|
||||
let mut reply = Vec::new();
|
||||
let read = from_child.take(reply_limit).read_to_end(&mut reply);
|
||||
let _ = tx.send(read.map(|_| reply));
|
||||
});
|
||||
let received = rx.recv_timeout(TIMEOUT);
|
||||
if matches!(received, Err(RecvTimeoutError::Timeout)) {
|
||||
let _ = child.kill();
|
||||
}
|
||||
received
|
||||
});
|
||||
let status = child.wait();
|
||||
let stopped = || format!("the DWG worker stopped while {doing}; nothing else is affected");
|
||||
Some(match (received, status) {
|
||||
(Err(RecvTimeoutError::Timeout), _) => Err(format!("{doing} took too long, so the DWG worker was stopped; nothing else is affected")),
|
||||
(Ok(Ok(reply)), Ok(status)) if status.success() => parse_reply(reply).ok_or_else(stopped),
|
||||
_ => Err(stopped()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Take `n` bytes off the front of `b`.
|
||||
fn take<'a>(b: &mut &'a [u8], n: usize) -> Option<&'a [u8]> {
|
||||
let (head, tail) = b.split_at_checked(n)?;
|
||||
*b = tail;
|
||||
Some(head)
|
||||
}
|
||||
|
||||
fn take_u32(b: &mut &[u8]) -> Option<usize> {
|
||||
let bytes: [u8; 4] = take(b, 4)?.try_into().ok()?;
|
||||
usize::try_from(u32::from_le_bytes(bytes)).ok()
|
||||
}
|
||||
|
||||
fn take_u64(b: &mut &[u8]) -> Option<u64> {
|
||||
Some(u64::from_le_bytes(take(b, 8)?.try_into().ok()?))
|
||||
}
|
||||
|
||||
/// A reply: 0, the note count, each note with its length, then the bytes with their length; or 1
|
||||
/// and a message. `None` when it isn't one, whole. Takes the reply, because the bytes can be most
|
||||
/// of the memory the app may use: they are kept, not copied.
|
||||
fn parse_reply(mut reply: Vec<u8>) -> Option<Reply> {
|
||||
let total = reply.len();
|
||||
let mut b = &reply[..];
|
||||
match *take(&mut b, 1)?.first()? {
|
||||
0 => {
|
||||
let count = take_u32(&mut b)?;
|
||||
let mut notes = Vec::new();
|
||||
for _ in 0..count {
|
||||
let n = take_u32(&mut b)?;
|
||||
notes.push(String::from_utf8_lossy(take(&mut b, n)?).into_owned());
|
||||
}
|
||||
let n = usize::try_from(take_u64(&mut b)?).ok()?;
|
||||
if b.len() != n {
|
||||
return None;
|
||||
}
|
||||
reply.drain(..total - n);
|
||||
Some(Ok((reply, notes)))
|
||||
}
|
||||
1 => Some(Err(String::from_utf8_lossy(b).into_owned())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn write_reply(out: &mut impl Write, reply: Reply) -> std::io::Result<()> {
|
||||
match reply {
|
||||
Ok((bytes, notes)) => {
|
||||
out.write_all(&[0])?;
|
||||
out.write_all(&u32::try_from(notes.len()).unwrap_or(0).to_le_bytes())?;
|
||||
for note in ¬es {
|
||||
out.write_all(&u32::try_from(note.len()).unwrap_or(0).to_le_bytes())?;
|
||||
if u32::try_from(note.len()).is_ok() {
|
||||
out.write_all(note.as_bytes())?;
|
||||
}
|
||||
}
|
||||
out.write_all(&(bytes.len() as u64).to_le_bytes())?;
|
||||
out.write_all(&bytes)?;
|
||||
}
|
||||
Err(e) => {
|
||||
out.write_all(&[1])?;
|
||||
out.write_all(e.as_bytes())?;
|
||||
}
|
||||
}
|
||||
out.flush()
|
||||
}
|
||||
|
||||
/// What a request asks for, or why it can't be served.
|
||||
fn handle(mut b: &[u8]) -> Reply {
|
||||
let bad = || "the DWG worker got a request it can't read (a different CADCraft version?)".to_string();
|
||||
if take(&mut b, 1).and_then(<[u8]>::first) != Some(&PROTOCOL) {
|
||||
return Err(bad());
|
||||
}
|
||||
let op = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
|
||||
let max_dwg_bytes = take_u64(&mut b).and_then(|n| usize::try_from(n).ok()).ok_or_else(bad)?;
|
||||
let max_dxf_bytes = take_u64(&mut b).and_then(|n| usize::try_from(n).ok()).ok_or_else(bad)?;
|
||||
let version_len = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
|
||||
let version = take(&mut b, usize::from(version_len)).and_then(|v| std::str::from_utf8(v).ok()).ok_or_else(bad)?;
|
||||
match op {
|
||||
DECODE => super::dwg_to_dxf_noted(b, Limits { max_dwg_bytes, max_dxf_bytes }),
|
||||
ENCODE => {
|
||||
// The version the DXF's carried-over groups were read from; empty for none.
|
||||
let kept_len = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
|
||||
let kept = take(&mut b, usize::from(kept_len)).and_then(|v| std::str::from_utf8(v).ok()).ok_or_else(bad)?;
|
||||
encode_here(b, version, (!kept.is_empty()).then_some(kept))
|
||||
.map(|(dwg, left_out)| (dwg, left_out.iter().map(|(kind, n)| format!("{kind}\t{n}")).collect()))
|
||||
}
|
||||
CRASH => std::process::abort(),
|
||||
_ => Err(bad()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Serve the one request on `input`. The exit code is 0 unless the reply couldn't be sent.
|
||||
fn serve(input: impl Read, mut output: impl Write) -> i32 {
|
||||
let mut request = Vec::new();
|
||||
let reply = match input.take(MAX_REQUEST).read_to_end(&mut request) {
|
||||
Ok(_) => handle(&request),
|
||||
Err(e) => Err(format!("the DWG worker could not read its request: {e}")),
|
||||
};
|
||||
i32::from(write_reply(&mut output, reply).is_err())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn wire(reply: Reply) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
write_reply(&mut out, reply).unwrap();
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn what_the_writer_left_out_survives_the_reply() {
|
||||
let notes = vec!["ACME_WIDGET\t2".to_string(), "not a count".to_string(), "X\tmany".to_string()];
|
||||
assert_eq!(unwritten_from(¬es), [("ACME_WIDGET".to_string(), 2)].into_iter().collect());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replies_round_trip() {
|
||||
let ok: Reply = Ok((b"bytes".to_vec(), vec!["one".into(), "two é".into()]));
|
||||
assert_eq!(parse_reply(wire(ok.clone())), Some(ok));
|
||||
let failed: Reply = Err("DWG: no".into());
|
||||
assert_eq!(parse_reply(wire(failed.clone())), Some(failed));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_reply_cut_short_or_made_up_is_refused() {
|
||||
let whole = wire(Ok((b"bytes".to_vec(), vec!["note".into()])));
|
||||
for n in 0..whole.len() {
|
||||
assert_eq!(parse_reply(whole[..n].to_vec()), None, "cut at {n}");
|
||||
}
|
||||
assert_eq!(parse_reply(vec![7, 0, 0]), None);
|
||||
// A note count far beyond what follows ends at the first missing note.
|
||||
assert_eq!(parse_reply(vec![0, 0xff, 0xff, 0xff, 0xff]), None);
|
||||
assert_eq!(parse_reply(vec![0, 1, 0, 0, 0, 0xff, 0xff, 0xff, 0xff]), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_request_it_cannot_read_is_an_error_not_a_crash() {
|
||||
for request in [
|
||||
&[][..],
|
||||
&[PROTOCOL + 1, DECODE],
|
||||
&[PROTOCOL],
|
||||
&[PROTOCOL, DECODE, 1, 2, 3],
|
||||
&[PROTOCOL, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
] {
|
||||
assert!(handle(request).is_err(), "{request:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// An encode request carries the kept version after the target one; a request without it is
|
||||
/// one it can't read, and one with it reaches the converter.
|
||||
#[test]
|
||||
fn an_encode_request_carries_the_kept_version() {
|
||||
let bad = "the DWG worker got a request it can't read (a different CADCraft version?)";
|
||||
let short = self::request(ENCODE, Limits::DEFAULT, "AC1032");
|
||||
assert_eq!(handle(&short).unwrap_err(), bad);
|
||||
for kept in ["", "AC1032"] {
|
||||
let mut request = self::request(ENCODE, Limits::DEFAULT, "AC1032");
|
||||
push_str(&mut request, kept);
|
||||
request.extend(b"not a drawing");
|
||||
let err = handle(&request).unwrap_err();
|
||||
assert_ne!(err, bad, "kept {kept:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn serving_reports_a_decode_failure_as_a_reply() {
|
||||
let mut request = self::request(DECODE, Limits::DEFAULT, "");
|
||||
request.extend(b"AC1032 not really a drawing");
|
||||
let mut out = Vec::new();
|
||||
assert_eq!(serve(&request[..], &mut out), 0);
|
||||
assert!(matches!(parse_reply(out.clone()), Some(Err(_))), "{out:?}");
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
[package]
|
||||
name = "cadcraft-dxf"
|
||||
description = "Standalone DXF tag reader/writer (ASCII and binary, pre-2007 code pages), from the published DXF reference"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
thiserror = { workspace = true }
|
||||
log = { workspace = true }
|
||||
encoding_rs = { workspace = true }
|
||||
@@ -1,398 +0,0 @@
|
||||
//! Text decoding for DXF files.
|
||||
//!
|
||||
//! R2007 (AC1021) and later DXF files are UTF-8. Older ones store text in the code page named by
|
||||
//! the `$DWGCODEPAGE` header variable (`ANSI_1252`, `ANSI_932`, `DOS850`, …); characters outside
|
||||
//! it are written as `\U+XXXX` (any character) or `\M+nXXXX` (a double-byte character of an East
|
||||
//! Asian code page) escapes, which [`crate::parse`] decodes after the bytes.
|
||||
//!
|
||||
//! The Windows, ISO and East Asian code pages are decoded with `encoding_rs`; DOS 437, 850 and
|
||||
//! 852 with the tables below (the upper halves of the IBM PC code pages; the lower halves are
|
||||
//! ASCII). Decoding never fails: a byte sequence that is invalid in the code page (a truncated
|
||||
//! double-byte character, an unassigned byte) becomes U+FFFD and the bytes after it decode
|
||||
//! normally, so line ends and the group structure survive.
|
||||
|
||||
use std::borrow::Cow;
|
||||
|
||||
use encoding_rs::Encoding;
|
||||
|
||||
/// How the bytes of a code page become text.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(crate) enum Decoder {
|
||||
Utf8,
|
||||
Encoding(&'static Encoding),
|
||||
/// Single-byte DOS code page: ASCII, then these 128 characters for bytes 0x80–0xFF.
|
||||
Table(&'static [char; 128]),
|
||||
}
|
||||
|
||||
/// The decoder for a `$DWGCODEPAGE` value (case-insensitive), or `None` when CADCraft doesn't
|
||||
/// know the code page.
|
||||
pub(crate) fn decoder(code_page: &str) -> Option<Decoder> {
|
||||
use encoding_rs as e;
|
||||
let name = code_page.trim().to_ascii_uppercase().replace(['-', ' '], "_");
|
||||
let enc = match name.as_str() {
|
||||
"UTF8" | "UTF_8" | "UNICODE" => return Some(Decoder::Utf8),
|
||||
"ASCII" | "ANSI_1252" | "ISO8859_1" | "ISO_8859_1" => e::WINDOWS_1252,
|
||||
"ANSI_874" => e::WINDOWS_874,
|
||||
"ANSI_932" | "DOS932" | "SHIFT_JIS" => e::SHIFT_JIS,
|
||||
"ANSI_936" | "GB2312" | "GBK" => e::GBK,
|
||||
"ANSI_949" | "KSC5601" | "KOREAN" => e::EUC_KR,
|
||||
"ANSI_950" | "BIG5" => e::BIG5,
|
||||
"ANSI_1250" => e::WINDOWS_1250,
|
||||
"ANSI_1251" => e::WINDOWS_1251,
|
||||
"ANSI_1253" => e::WINDOWS_1253,
|
||||
"ANSI_1254" | "ISO8859_9" | "ISO_8859_9" => e::WINDOWS_1254,
|
||||
"ANSI_1255" => e::WINDOWS_1255,
|
||||
"ANSI_1256" => e::WINDOWS_1256,
|
||||
"ANSI_1257" => e::WINDOWS_1257,
|
||||
"ANSI_1258" => e::WINDOWS_1258,
|
||||
"ISO8859_2" | "ISO_8859_2" => e::ISO_8859_2,
|
||||
"ISO8859_3" | "ISO_8859_3" => e::ISO_8859_3,
|
||||
"ISO8859_4" | "ISO_8859_4" => e::ISO_8859_4,
|
||||
"ISO8859_5" | "ISO_8859_5" => e::ISO_8859_5,
|
||||
"ISO8859_6" | "ISO_8859_6" => e::ISO_8859_6,
|
||||
"ISO8859_7" | "ISO_8859_7" => e::ISO_8859_7,
|
||||
"ISO8859_8" | "ISO_8859_8" => e::ISO_8859_8,
|
||||
"DOS866" => e::IBM866,
|
||||
"MACINTOSH" | "MAC_ROMAN" => e::MACINTOSH,
|
||||
"DOS437" => return Some(Decoder::Table(&DOS437)),
|
||||
"DOS850" => return Some(Decoder::Table(&DOS850)),
|
||||
"DOS852" => return Some(Decoder::Table(&DOS852)),
|
||||
_ => return None,
|
||||
};
|
||||
Some(Decoder::Encoding(enc))
|
||||
}
|
||||
|
||||
/// Decode `bytes` from the code page `code_page` names (a `$DWGCODEPAGE` value such as
|
||||
/// `ANSI_1251`), or `None` when CADCraft doesn't know that code page. Invalid sequences become
|
||||
/// U+FFFD; escapes (`\U+XXXX`, `\M+nXXXX`) are left as they are.
|
||||
pub fn decode_code_page(bytes: &[u8], code_page: &str) -> Option<String> {
|
||||
decoder(code_page).map(|d| decode(bytes, d).into_owned())
|
||||
}
|
||||
|
||||
/// The code page a pre-2007 file's text is written in, or `None` for pure ASCII with escapes:
|
||||
/// when CADCraft doesn't know `code_page`, and for `ASCII` (the reader takes such files as
|
||||
/// Windows-1252, but a writer must keep them ASCII) and `UTF8`/`UNICODE`, which no pre-2007
|
||||
/// reader expects.
|
||||
pub(crate) fn encoder(code_page: &str) -> Option<Decoder> {
|
||||
if code_page.trim().eq_ignore_ascii_case("ASCII") {
|
||||
return None;
|
||||
}
|
||||
decoder(code_page).filter(|d| !matches!(d, Decoder::Utf8))
|
||||
}
|
||||
|
||||
/// Append the bytes of the non-ASCII character `c` in the code page `d`, and return true, when
|
||||
/// the code page has it; otherwise append nothing and return false (the caller escapes it).
|
||||
pub(crate) fn encode_char(c: char, d: Decoder, out: &mut Vec<u8>) -> bool {
|
||||
let mut buf = [0; 4];
|
||||
match d {
|
||||
// Not a pre-2007 code page ([`encoder`] never gives it): escaped.
|
||||
Decoder::Utf8 => return false,
|
||||
Decoder::Encoding(e) => {
|
||||
let (bytes, _, unmappable) = e.encode(c.encode_utf8(&mut buf));
|
||||
// A code page byte that is ASCII would read back as another character, and a NUL,
|
||||
// CR or LF would break the group, so only all-high-bit sequences or proper double-byte
|
||||
// characters are kept (their trail byte may be ASCII, as in Shift-JIS).
|
||||
if unmappable || bytes.is_empty() || !bytes.first().is_some_and(|b| *b >= 0x80) || bytes.iter().any(|b| matches!(b, 0 | b'\r' | b'\n')) {
|
||||
return false;
|
||||
}
|
||||
out.extend_from_slice(&bytes);
|
||||
}
|
||||
Decoder::Table(t) => {
|
||||
let Some(i) = t.iter().position(|&x| x == c).and_then(|i| u8::try_from(i).ok()) else { return false };
|
||||
out.push(0x80 | i);
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// Decode bytes with a decoder. UTF-8 that isn't valid falls back to Windows-1252.
|
||||
pub(crate) fn decode(bytes: &[u8], d: Decoder) -> Cow<'_, str> {
|
||||
match d {
|
||||
Decoder::Utf8 => match std::str::from_utf8(bytes) {
|
||||
Ok(s) => Cow::Borrowed(s),
|
||||
Err(_) => encoding_rs::WINDOWS_1252.decode_without_bom_handling(bytes).0,
|
||||
},
|
||||
Decoder::Encoding(e) => e.decode_without_bom_handling(bytes).0,
|
||||
Decoder::Table(t) => match std::str::from_utf8(bytes) {
|
||||
Ok(s) if s.is_ascii() => Cow::Borrowed(s),
|
||||
_ => Cow::Owned(
|
||||
bytes
|
||||
.iter()
|
||||
.map(|&b| if b.is_ascii() { char::from(b) } else { t.get(usize::from(b & 0x7F)).copied().unwrap_or('\u{FFFD}') })
|
||||
.collect(),
|
||||
),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// The `$DWGCODEPAGE` value of an ASCII DXF file: the line two lines after a `$DWGCODEPAGE`
|
||||
/// line (the group code `3` between them), looked for in the HEADER section only (the scan stops
|
||||
/// at the first `ENDSEC`). Works on the raw bytes, before they are decoded.
|
||||
fn ascii_code_page(bytes: &[u8]) -> Option<&[u8]> {
|
||||
let mut lines = bytes.split(|&b| b == b'\n' || b == b'\r').map(<[u8]>::trim_ascii).filter(|l| !l.is_empty());
|
||||
while let Some(line) = lines.next() {
|
||||
if line == b"ENDSEC" {
|
||||
return None;
|
||||
}
|
||||
if line.eq_ignore_ascii_case(b"$DWGCODEPAGE") {
|
||||
return match (lines.next(), lines.next()) {
|
||||
(Some(b"3"), Some(value)) => Some(value),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
impl Decoder {
|
||||
/// True for the multi-byte East Asian code pages (Shift-JIS, GBK, EUC-KR/Wansung, Big5).
|
||||
/// Their short double-byte strings are often also valid UTF-8, so UTF-8 is only trusted for
|
||||
/// a whole file there (see [`decode_ascii_file`] and [`BinaryText`]).
|
||||
fn is_east_asian(self) -> bool {
|
||||
use encoding_rs as e;
|
||||
matches!(self, Decoder::Encoding(x) if x == e::SHIFT_JIS || x == e::GBK || x == e::EUC_KR || x == e::BIG5)
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode one line of an ASCII DXF file: valid UTF-8 is read as UTF-8 (R2007+ files, pure-ASCII
|
||||
/// text, and older files from writers that ignored the code page); anything else comes from the
|
||||
/// code page `d`, so one stray byte spoils one line, not the whole file. Binary strings don't use
|
||||
/// this rule: a pre-R2007 binary file has no way to escape to UTF-8, so its strings are read
|
||||
/// from the code page (see [`BinaryText::string`]).
|
||||
pub(crate) fn decode_text(bytes: &[u8], d: Decoder) -> Cow<'_, str> {
|
||||
match std::str::from_utf8(bytes) {
|
||||
Ok(s) => Cow::Borrowed(s),
|
||||
Err(_) => decode(bytes, d),
|
||||
}
|
||||
}
|
||||
|
||||
/// Decode a whole ASCII DXF file. A file that is valid UTF-8 throughout is UTF-8. Otherwise, for
|
||||
/// a single-byte code page, each line is decoded on its own (see [`decode_text`]): lines that
|
||||
/// aren't valid UTF-8 come from the file's `$DWGCODEPAGE`, or from Windows-1252 (the usual
|
||||
/// `ANSI_1252`) when the header has none or names a code page CADCraft doesn't know, which is
|
||||
/// logged as a warning. For a multi-byte East Asian code page the whole file is decoded from
|
||||
/// that code page, because a short double-byte string (two half-width katakana, many kanji
|
||||
/// pairs) can be valid UTF-8 by accident and must not be misread line by line.
|
||||
pub(crate) fn decode_ascii_file(bytes: &[u8]) -> Cow<'_, str> {
|
||||
if let Ok(s) = std::str::from_utf8(bytes) {
|
||||
return Cow::Borrowed(s);
|
||||
}
|
||||
let d = match ascii_code_page(bytes) {
|
||||
Some(name) => {
|
||||
let name = String::from_utf8_lossy(name);
|
||||
decoder(&name).unwrap_or_else(|| {
|
||||
log::warn!("DXF: unknown code page `{name}`; reading the text as ANSI_1252");
|
||||
Decoder::Utf8
|
||||
})
|
||||
}
|
||||
None => Decoder::Utf8,
|
||||
};
|
||||
if d.is_east_asian() {
|
||||
return decode(bytes, d);
|
||||
}
|
||||
// Split after each line terminator (CR, LF or CRLF are all ASCII, so they never occur inside
|
||||
// a multi-byte character of the supported code pages) and decode each line on its own.
|
||||
let mut out = String::with_capacity(bytes.len());
|
||||
for line in bytes.split_inclusive(|&b| b == b'\n' || b == b'\r') {
|
||||
out.push_str(&decode_text(line, d));
|
||||
}
|
||||
Cow::Owned(out)
|
||||
}
|
||||
|
||||
/// The text state of a binary DXF file, learnt from the header as the tags go by: `$ACADVER`
|
||||
/// (R2007+ strings are UTF-8) and `$DWGCODEPAGE` (the code page of older files). Both come
|
||||
/// first in the HEADER section and are ASCII, so every later string is decoded right.
|
||||
#[derive(Default)]
|
||||
pub(crate) struct BinaryText {
|
||||
/// The header variable whose value comes next (after a group 9).
|
||||
var: Option<HeaderVar>,
|
||||
utf8: bool,
|
||||
code_page: Option<Decoder>,
|
||||
/// Decode every string of an East Asian code page file from the code page, never as UTF-8
|
||||
/// (the second pass of [`BinaryText::needs_code_page_pass`]).
|
||||
code_page_only: bool,
|
||||
/// Non-ASCII strings seen under an East Asian code page: valid UTF-8 / not valid UTF-8.
|
||||
ea_utf8: bool,
|
||||
ea_other: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum HeaderVar {
|
||||
AcadVer,
|
||||
CodePage,
|
||||
}
|
||||
|
||||
impl BinaryText {
|
||||
/// The state for the second pass over a file whose strings are a mix of valid UTF-8 and
|
||||
/// not: every string of an East Asian code page is decoded from that code page.
|
||||
pub(crate) fn code_page_pass() -> Self {
|
||||
Self { code_page_only: true, ..Self::default() }
|
||||
}
|
||||
|
||||
/// True when the file declared a multi-byte East Asian code page and its non-ASCII strings are
|
||||
/// not all valid UTF-8 although some are: those can be short double-byte strings that look
|
||||
/// like UTF-8 by accident, so the file must be parsed again with [`Self::code_page_pass`]. (A
|
||||
/// file whose strings are all valid UTF-8 is UTF-8; one with none is plainly the code page.)
|
||||
pub(crate) fn needs_code_page_pass(&self) -> bool {
|
||||
!self.code_page_only && self.ea_utf8 && self.ea_other
|
||||
}
|
||||
|
||||
/// Decode one string value of group `code` and update the state from it. Strings of R2007+
|
||||
/// files, and of files without a code page, are UTF-8 when valid (else Windows-1252); a
|
||||
/// pre-R2007 file's strings are in its code page, which a binary DXF cannot escape to, so
|
||||
/// they are read from the code page even when their bytes are valid UTF-8 by accident —
|
||||
/// except under an East Asian code page, where a file of all-valid-UTF-8 strings is taken
|
||||
/// as UTF-8 (see [`Self::needs_code_page_pass`]).
|
||||
pub(crate) fn string(&mut self, code: i32, raw: &[u8]) -> String {
|
||||
let d = if self.utf8 { Decoder::Utf8 } else { self.code_page.unwrap_or(Decoder::Utf8) };
|
||||
let s = if d.is_east_asian() && !self.code_page_only {
|
||||
if !raw.is_ascii() {
|
||||
if std::str::from_utf8(raw).is_ok() {
|
||||
self.ea_utf8 = true;
|
||||
} else {
|
||||
self.ea_other = true;
|
||||
}
|
||||
}
|
||||
decode_text(raw, d).into_owned()
|
||||
} else {
|
||||
decode(raw, d).into_owned()
|
||||
};
|
||||
match (code, self.var.take()) {
|
||||
(9, _) => {
|
||||
self.var = match s.trim() {
|
||||
"$ACADVER" => Some(HeaderVar::AcadVer),
|
||||
"$DWGCODEPAGE" => Some(HeaderVar::CodePage),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
(1, Some(HeaderVar::AcadVer)) => self.utf8 = is_utf8_version(&s),
|
||||
(3, Some(HeaderVar::CodePage)) => {
|
||||
self.code_page = decoder(&s);
|
||||
if self.code_page.is_none() {
|
||||
log::warn!("DXF: unknown code page `{}`; reading the text as ANSI_1252", s.trim());
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
/// True for an `$ACADVER` of R2007 (AC1021) or later, whose text is UTF-8.
|
||||
fn is_utf8_version(acadver: &str) -> bool {
|
||||
acadver.trim().strip_prefix("AC").and_then(|n| n.parse::<u32>().ok()).is_some_and(|n| n >= 1021)
|
||||
}
|
||||
|
||||
/// The double-byte code page of a `\M+n` escape: 1 Japanese (Shift-JIS), 2 Traditional Chinese
|
||||
/// (Big5), 3 Korean (Wansung), 5 Simplified Chinese (GB 2312). 4 (Korean Johab) is not
|
||||
/// supported, so its escapes stay literal.
|
||||
pub(crate) fn mif_encoding(n: char) -> Option<&'static Encoding> {
|
||||
match n {
|
||||
'1' => Some(encoding_rs::SHIFT_JIS),
|
||||
'2' => Some(encoding_rs::BIG5),
|
||||
'3' => Some(encoding_rs::EUC_KR),
|
||||
'5' => Some(encoding_rs::GBK),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
// Generated from the IBM PC code page definitions (bytes 0x80–0xFF in order).
|
||||
const DOS437: [char; 128] = [
|
||||
'\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{00E0}', '\u{00E5}', '\u{00E7}', '\u{00EA}', '\u{00EB}', '\u{00E8}', '\u{00EF}',
|
||||
'\u{00EE}', '\u{00EC}', '\u{00C4}', '\u{00C5}', '\u{00C9}', '\u{00E6}', '\u{00C6}', '\u{00F4}', '\u{00F6}', '\u{00F2}', '\u{00FB}', '\u{00F9}',
|
||||
'\u{00FF}', '\u{00D6}', '\u{00DC}', '\u{00A2}', '\u{00A3}', '\u{00A5}', '\u{20A7}', '\u{0192}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
|
||||
'\u{00F1}', '\u{00D1}', '\u{00AA}', '\u{00BA}', '\u{00BF}', '\u{2310}', '\u{00AC}', '\u{00BD}', '\u{00BC}', '\u{00A1}', '\u{00AB}', '\u{00BB}',
|
||||
'\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{2561}', '\u{2562}', '\u{2556}', '\u{2555}', '\u{2563}', '\u{2551}', '\u{2557}',
|
||||
'\u{255D}', '\u{255C}', '\u{255B}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{255E}', '\u{255F}',
|
||||
'\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{2567}', '\u{2568}', '\u{2564}', '\u{2565}', '\u{2559}',
|
||||
'\u{2558}', '\u{2552}', '\u{2553}', '\u{256B}', '\u{256A}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{258C}', '\u{2590}', '\u{2580}',
|
||||
'\u{03B1}', '\u{00DF}', '\u{0393}', '\u{03C0}', '\u{03A3}', '\u{03C3}', '\u{00B5}', '\u{03C4}', '\u{03A6}', '\u{0398}', '\u{03A9}', '\u{03B4}',
|
||||
'\u{221E}', '\u{03C6}', '\u{03B5}', '\u{2229}', '\u{2261}', '\u{00B1}', '\u{2265}', '\u{2264}', '\u{2320}', '\u{2321}', '\u{00F7}', '\u{2248}',
|
||||
'\u{00B0}', '\u{2219}', '\u{00B7}', '\u{221A}', '\u{207F}', '\u{00B2}', '\u{25A0}', '\u{00A0}',
|
||||
];
|
||||
const DOS850: [char; 128] = [
|
||||
'\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{00E0}', '\u{00E5}', '\u{00E7}', '\u{00EA}', '\u{00EB}', '\u{00E8}', '\u{00EF}',
|
||||
'\u{00EE}', '\u{00EC}', '\u{00C4}', '\u{00C5}', '\u{00C9}', '\u{00E6}', '\u{00C6}', '\u{00F4}', '\u{00F6}', '\u{00F2}', '\u{00FB}', '\u{00F9}',
|
||||
'\u{00FF}', '\u{00D6}', '\u{00DC}', '\u{00F8}', '\u{00A3}', '\u{00D8}', '\u{00D7}', '\u{0192}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
|
||||
'\u{00F1}', '\u{00D1}', '\u{00AA}', '\u{00BA}', '\u{00BF}', '\u{00AE}', '\u{00AC}', '\u{00BD}', '\u{00BC}', '\u{00A1}', '\u{00AB}', '\u{00BB}',
|
||||
'\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{00C1}', '\u{00C2}', '\u{00C0}', '\u{00A9}', '\u{2563}', '\u{2551}', '\u{2557}',
|
||||
'\u{255D}', '\u{00A2}', '\u{00A5}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{00E3}', '\u{00C3}',
|
||||
'\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{00A4}', '\u{00F0}', '\u{00D0}', '\u{00CA}', '\u{00CB}',
|
||||
'\u{00C8}', '\u{0131}', '\u{00CD}', '\u{00CE}', '\u{00CF}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{00A6}', '\u{00CC}', '\u{2580}',
|
||||
'\u{00D3}', '\u{00DF}', '\u{00D4}', '\u{00D2}', '\u{00F5}', '\u{00D5}', '\u{00B5}', '\u{00FE}', '\u{00DE}', '\u{00DA}', '\u{00DB}', '\u{00D9}',
|
||||
'\u{00FD}', '\u{00DD}', '\u{00AF}', '\u{00B4}', '\u{00AD}', '\u{00B1}', '\u{2017}', '\u{00BE}', '\u{00B6}', '\u{00A7}', '\u{00F7}', '\u{00B8}',
|
||||
'\u{00B0}', '\u{00A8}', '\u{00B7}', '\u{00B9}', '\u{00B3}', '\u{00B2}', '\u{25A0}', '\u{00A0}',
|
||||
];
|
||||
const DOS852: [char; 128] = [
|
||||
'\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{016F}', '\u{0107}', '\u{00E7}', '\u{0142}', '\u{00EB}', '\u{0150}', '\u{0151}',
|
||||
'\u{00EE}', '\u{0179}', '\u{00C4}', '\u{0106}', '\u{00C9}', '\u{0139}', '\u{013A}', '\u{00F4}', '\u{00F6}', '\u{013D}', '\u{013E}', '\u{015A}',
|
||||
'\u{015B}', '\u{00D6}', '\u{00DC}', '\u{0164}', '\u{0165}', '\u{0141}', '\u{00D7}', '\u{010D}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
|
||||
'\u{0104}', '\u{0105}', '\u{017D}', '\u{017E}', '\u{0118}', '\u{0119}', '\u{00AC}', '\u{017A}', '\u{010C}', '\u{015F}', '\u{00AB}', '\u{00BB}',
|
||||
'\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{00C1}', '\u{00C2}', '\u{011A}', '\u{015E}', '\u{2563}', '\u{2551}', '\u{2557}',
|
||||
'\u{255D}', '\u{017B}', '\u{017C}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{0102}', '\u{0103}',
|
||||
'\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{00A4}', '\u{0111}', '\u{0110}', '\u{010E}', '\u{00CB}',
|
||||
'\u{010F}', '\u{0147}', '\u{00CD}', '\u{00CE}', '\u{011B}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{0162}', '\u{016E}', '\u{2580}',
|
||||
'\u{00D3}', '\u{00DF}', '\u{00D4}', '\u{0143}', '\u{0144}', '\u{0148}', '\u{0160}', '\u{0161}', '\u{0154}', '\u{00DA}', '\u{0155}', '\u{0170}',
|
||||
'\u{00FD}', '\u{00DD}', '\u{0163}', '\u{00B4}', '\u{00AD}', '\u{02DD}', '\u{02DB}', '\u{02C7}', '\u{02D8}', '\u{00A7}', '\u{00F7}', '\u{00B8}',
|
||||
'\u{00B0}', '\u{00A8}', '\u{02D9}', '\u{0171}', '\u{0158}', '\u{0159}', '\u{25A0}', '\u{00A0}',
|
||||
];
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn code_page_names() {
|
||||
let d = |bytes: &[u8], cp: &str| decode_code_page(bytes, cp);
|
||||
assert_eq!(d(b"\xCF\xF0\xE8\xE2\xE5\xF2", "ANSI_1251").as_deref(), Some("Привет"));
|
||||
assert_eq!(d(b"\xCF\xF0\xE8\xE2\xE5\xF2", " ansi_1251 ").as_deref(), Some("Привет"));
|
||||
assert_eq!(d(b"\x90\x7D\x96\xCA", "ANSI_932").as_deref(), Some("図面"));
|
||||
assert_eq!(d(b"\xCD\xBC\xB2\xE3", "GB2312").as_deref(), Some("图层"));
|
||||
assert_eq!(d(b"\xB9\xCF\xBC\x68", "BIG5").as_deref(), Some("圖層"));
|
||||
assert_eq!(d(b"\xB5\xB5\xB8\xE9", "ANSI_949").as_deref(), Some("도면"));
|
||||
assert_eq!(d(b"\xD3\xF7\xDD\xE4\xE9\xEF", "ANSI_1253").as_deref(), Some("Σχέδιο"));
|
||||
assert_eq!(d(b"\xC0\xD2\xBE", "ANSI_874").as_deref(), Some("ภาพ"));
|
||||
assert_eq!(d(b"\x80", "ANSI_1252").as_deref(), Some("€"));
|
||||
// DOS 437 and 850 agree on letters but differ on 0x9B (¢ / ø).
|
||||
assert_eq!(d(b"Gr\x94\xE1e \x9B", "DOS437").as_deref(), Some("Größe ¢"));
|
||||
assert_eq!(d(b"Gr\x94\xE1e \x9B", "dos850").as_deref(), Some("Größe ø"));
|
||||
assert_eq!(d(b"\xBD\xA2\x88w", "DOS852").as_deref(), Some("Żółw"));
|
||||
assert_eq!(d(b"\x91\xAB\xAE\xA9", "DOS866").as_deref(), Some("Слой"));
|
||||
assert_eq!(d("é".as_bytes(), "UTF8").as_deref(), Some("é"));
|
||||
assert_eq!(d(b"x", "ANSI_1361"), None);
|
||||
assert_eq!(d(b"x", "EBCDIC"), None);
|
||||
assert_eq!(d(b"x", ""), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_sequences_become_replacement_characters() {
|
||||
// A Shift-JIS lead byte cut off by the line end keeps the line end.
|
||||
assert_eq!(decode_code_page(b"\x90\n1\n", "ANSI_932").as_deref(), Some("\u{FFFD}\n1\n"));
|
||||
assert_eq!(decode_code_page(b"\x90", "ANSI_932").as_deref(), Some("\u{FFFD}"));
|
||||
assert_eq!(decode_code_page(b"\xFF\xFF", "ANSI_936").as_deref(), Some("\u{FFFD}\u{FFFD}"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn header_scan() {
|
||||
let head = b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1251\r\n0\nENDSEC\n";
|
||||
assert_eq!(ascii_code_page(head), Some(&b"ANSI_1251"[..]));
|
||||
// Only the HEADER section counts.
|
||||
assert_eq!(ascii_code_page(b"0\nSECTION\n2\nHEADER\n0\nENDSEC\n9\n$DWGCODEPAGE\n3\nANSI_1251\n"), None);
|
||||
// Wrong group code, or the file ends early.
|
||||
assert_eq!(ascii_code_page(b"9\n$DWGCODEPAGE\n1\nANSI_1251\n"), None);
|
||||
assert_eq!(ascii_code_page(b"9\n$DWGCODEPAGE\n3"), None);
|
||||
assert!(is_utf8_version("AC1021") && is_utf8_version(" AC1032 "));
|
||||
assert!(!is_utf8_version("AC1018") && !is_utf8_version("AC1009") && !is_utf8_version("garbage"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mif_escapes() {
|
||||
let one = |s: &str| crate::parse(format!("1\n{s}\n0\nEOF\n").as_bytes()).unwrap()[0].str();
|
||||
assert_eq!(one("\\M+5BCFE\\M+1907D\\M+2B9CF\\M+3B5B5!"), "件図圖도!");
|
||||
assert_eq!(one("\\M+5BCFE\\U+0021"), "件!");
|
||||
// Johab, unknown code pages, bad hex, short escapes and unassigned codes stay literal.
|
||||
for s in ["\\M+4ABCD", "\\M+9BCFE", "\\M+5GGGG", "\\M+5BC", "\\M+", "\\M+50041", "\\M+5FFFF"] {
|
||||
assert_eq!(one(s), s);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,925 +0,0 @@
|
||||
//! A standalone DXF tag reader and writer.
|
||||
//!
|
||||
//! DXF is a sequence of (group code, value) pairs. This crate parses ASCII and binary DXF into a
|
||||
//! flat list of [`Tag`]s, splits them into sections and entities, and writes tags back. Mapping
|
||||
//! tags to a drawing model is left to the caller. Written from Autodesk's published DXF
|
||||
//! Reference; depends on nothing else in the workspace.
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
use std::fmt::Write as _;
|
||||
use std::io::Write as _;
|
||||
|
||||
mod version;
|
||||
pub use version::Version;
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum DxfError {
|
||||
#[error("not a DXF file")]
|
||||
NotDxf,
|
||||
#[error("line {line}: bad group code `{text}`")]
|
||||
BadCode { line: usize, text: String },
|
||||
#[error("unexpected end of file")]
|
||||
Eof,
|
||||
/// More group codes than [`MAX_TAGS`]: `tags` is the count found (or the count read when the
|
||||
/// limit was reached), `limit` the maximum.
|
||||
#[error("drawing too large: {tags} DXF group codes, more than the {limit} CADCraft reads (set CADCRAFT_MAX_DXF_TAGS to read more)")]
|
||||
TooLarge { tags: usize, limit: usize },
|
||||
/// The memory for `tags` group codes couldn't be had: an error, not the process ending.
|
||||
#[error("not enough memory to read this drawing's {tags} DXF group codes")]
|
||||
OutOfMemory { tags: usize },
|
||||
}
|
||||
|
||||
pub type Result<T> = std::result::Result<T, DxfError>;
|
||||
|
||||
/// A typed group value.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Value {
|
||||
Str(String),
|
||||
Real(f64),
|
||||
Int(i64),
|
||||
Bool(bool),
|
||||
/// Binary chunk (310–319, 1004) as hex text.
|
||||
Hex(String),
|
||||
}
|
||||
|
||||
impl Value {
|
||||
pub fn as_str(&self) -> String {
|
||||
match self {
|
||||
Value::Str(s) | Value::Hex(s) => s.clone(),
|
||||
Value::Real(r) => format_real(*r),
|
||||
Value::Int(i) => i.to_string(),
|
||||
Value::Bool(b) => i64::from(*b).to_string(),
|
||||
}
|
||||
}
|
||||
pub fn as_f64(&self) -> f64 {
|
||||
match self {
|
||||
Value::Real(r) if r.is_finite() => *r,
|
||||
Value::Int(i) => *i as f64,
|
||||
Value::Str(s) => s.trim().parse::<f64>().ok().filter(|v| v.is_finite()).unwrap_or(0.0),
|
||||
Value::Bool(b) => f64::from(u8::from(*b)),
|
||||
_ => 0.0,
|
||||
}
|
||||
}
|
||||
pub fn as_i64(&self) -> i64 {
|
||||
match self {
|
||||
Value::Int(i) => *i,
|
||||
Value::Real(r) if r.is_finite() => *r as i64,
|
||||
Value::Str(s) => {
|
||||
s.trim().parse::<i64>().unwrap_or_else(|_| s.trim().parse::<f64>().ok().filter(|f| f.is_finite()).map_or(0, |f| f as i64))
|
||||
}
|
||||
Value::Bool(b) => i64::from(*b),
|
||||
_ => 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Tag {
|
||||
pub code: i32,
|
||||
pub value: Value,
|
||||
}
|
||||
|
||||
impl Tag {
|
||||
pub fn new(code: i32, value: Value) -> Self {
|
||||
Tag { code, value }
|
||||
}
|
||||
pub fn s(code: i32, v: impl Into<String>) -> Self {
|
||||
Tag { code, value: Value::Str(v.into()) }
|
||||
}
|
||||
pub fn f(code: i32, v: f64) -> Self {
|
||||
Tag { code, value: Value::Real(if v.is_finite() { v } else { 0.0 }) }
|
||||
}
|
||||
pub fn i(code: i32, v: i64) -> Self {
|
||||
Tag { code, value: Value::Int(v) }
|
||||
}
|
||||
pub fn str(&self) -> String {
|
||||
self.value.as_str()
|
||||
}
|
||||
pub fn f64(&self) -> f64 {
|
||||
self.value.as_f64()
|
||||
}
|
||||
pub fn i64(&self) -> i64 {
|
||||
self.value.as_i64()
|
||||
}
|
||||
}
|
||||
|
||||
/// The value type for a group code (DXF Reference, "Group Code Value Types").
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Kind {
|
||||
Str,
|
||||
Real,
|
||||
Int16,
|
||||
Int32,
|
||||
Int64,
|
||||
Bool,
|
||||
Hex,
|
||||
}
|
||||
|
||||
pub fn kind_of(code: i32) -> Kind {
|
||||
match code {
|
||||
0..=9 => Kind::Str,
|
||||
10..=59 => Kind::Real,
|
||||
60..=79 => Kind::Int16,
|
||||
90..=99 => Kind::Int32,
|
||||
100..=109 => Kind::Str,
|
||||
110..=149 => Kind::Real,
|
||||
160..=169 => Kind::Int64,
|
||||
170..=179 => Kind::Int16,
|
||||
210..=239 => Kind::Real,
|
||||
270..=289 => Kind::Int16,
|
||||
290..=299 => Kind::Bool,
|
||||
300..=309 => Kind::Str,
|
||||
310..=319 => Kind::Hex,
|
||||
320..=369 => Kind::Str,
|
||||
370..=389 => Kind::Int16,
|
||||
390..=399 => Kind::Str,
|
||||
400..=409 => Kind::Int16,
|
||||
410..=419 => Kind::Str,
|
||||
420..=429 => Kind::Int32,
|
||||
430..=439 => Kind::Str,
|
||||
440..=449 => Kind::Int32,
|
||||
450..=459 => Kind::Int32,
|
||||
460..=469 => Kind::Real,
|
||||
470..=479 => Kind::Str,
|
||||
480..=481 => Kind::Str,
|
||||
999 => Kind::Str,
|
||||
1000..=1003 => Kind::Str,
|
||||
1004 => Kind::Hex,
|
||||
1005..=1009 => Kind::Str,
|
||||
1010..=1059 => Kind::Real,
|
||||
1060..=1070 => Kind::Int16,
|
||||
1071 => Kind::Int32,
|
||||
_ => Kind::Str,
|
||||
}
|
||||
}
|
||||
|
||||
fn typed(code: i32, text: &str) -> Value {
|
||||
let t = text.trim();
|
||||
match kind_of(code) {
|
||||
Kind::Real => t.parse::<f64>().ok().filter(|v| v.is_finite()).map(Value::Real).unwrap_or(Value::Real(0.0)),
|
||||
Kind::Int16 | Kind::Int32 | Kind::Int64 => {
|
||||
// A float spelling ("1e3", "12.0") is accepted when finite, clamped to what the
|
||||
// group's width holds, signed or unsigned (files write 16-bit flags up to 65535, as
|
||||
// the integer spelling reads them); NaN, inf and text become 0.
|
||||
let (lo, hi) = match kind_of(code) {
|
||||
Kind::Int16 => (i64::from(i16::MIN), i64::from(u16::MAX)),
|
||||
Kind::Int32 => (i64::from(i32::MIN), i64::from(u32::MAX)),
|
||||
_ => (i64::MIN, i64::MAX),
|
||||
};
|
||||
t.parse::<i64>()
|
||||
.map(Value::Int)
|
||||
.unwrap_or_else(|_| Value::Int(t.parse::<f64>().ok().filter(|f| f.is_finite()).map_or(0, |f| (f as i64).clamp(lo, hi))))
|
||||
}
|
||||
Kind::Bool => Value::Bool(t.parse::<i64>().unwrap_or(0) != 0),
|
||||
Kind::Hex => Value::Hex(normalize_hex(t)),
|
||||
Kind::Str => Value::Str(text.trim_end_matches(['\r', '\n']).to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
const BINARY_SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
|
||||
const UTF8_BOM: &[u8] = b"\xEF\xBB\xBF";
|
||||
/// Most group codes read from one file by default. A `Tag` takes 40 bytes plus its text, so this
|
||||
/// bounds the tag list to about 4 GB plus text. 50 million rejected large DWGs that converted fine
|
||||
/// (a 172 MB drawing has 56 million, issue #1948). The file-size limits bound memory too: 512 MB
|
||||
/// for a DXF opened directly, 1 GB for a DWG's DXF rendition. Set `CADCRAFT_MAX_DXF_TAGS` to
|
||||
/// raise or lower it.
|
||||
pub const MAX_TAGS: usize = 100_000_000;
|
||||
|
||||
/// Environment variable overriding [`MAX_TAGS`] (a positive integer).
|
||||
pub const MAX_TAGS_ENV: &str = "CADCRAFT_MAX_DXF_TAGS";
|
||||
|
||||
/// The group-code limit in effect: [`MAX_TAGS_ENV`] when set to a positive integer, else
|
||||
/// [`MAX_TAGS`].
|
||||
pub fn max_tags() -> usize {
|
||||
max_tags_from(std::env::var(MAX_TAGS_ENV).ok().as_deref())
|
||||
}
|
||||
|
||||
fn max_tags_from(v: Option<&str>) -> usize {
|
||||
v.and_then(|s| s.trim().replace('_', "").parse::<usize>().ok()).filter(|&n| n > 0).unwrap_or(MAX_TAGS)
|
||||
}
|
||||
|
||||
mod codepage;
|
||||
pub use codepage::decode_code_page;
|
||||
|
||||
/// Parse a DXF file (ASCII or binary).
|
||||
pub fn parse(bytes: &[u8]) -> Result<Vec<Tag>> {
|
||||
parse_with_limit(bytes, max_tags())
|
||||
}
|
||||
|
||||
/// [`parse`] with an explicit group-code limit. For ASCII DXF the limit is checked up front from
|
||||
/// the line count, before the text is decoded or any tag allocated, so an oversized file fails in
|
||||
/// milliseconds instead of after it has filled memory.
|
||||
pub fn parse_with_limit(bytes: &[u8], max_tags: usize) -> Result<Vec<Tag>> {
|
||||
if let Some(body) = bytes.strip_prefix(BINARY_SENTINEL) {
|
||||
return parse_binary_with_limit(body, max_tags);
|
||||
}
|
||||
let bytes = bytes.strip_prefix(UTF8_BOM).unwrap_or(bytes);
|
||||
// Count nonblank group-code/value pairs (LF, CRLF and a lone CR each end a line), stopping at
|
||||
// EOF just as the parser does. Blank lines do not count toward the limit.
|
||||
let mut lines = byte_lines(bytes);
|
||||
let mut tags = 0;
|
||||
while let Some(code) = lines.next() {
|
||||
let code = code.trim_ascii();
|
||||
if code.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let Some(value) = lines.next() else { break };
|
||||
tags += 1;
|
||||
if code == b"0" && value.trim_ascii() == b"EOF" {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if tags > max_tags {
|
||||
return Err(DxfError::TooLarge { tags, limit: max_tags });
|
||||
}
|
||||
parse_ascii_counted(&codepage::decode_ascii_file(bytes), max_tags, tags)
|
||||
}
|
||||
|
||||
/// The four hex digits of a `\U+XXXX` escape starting at `chars[i]`, if there is one.
|
||||
fn escape_at(chars: &[char], i: usize) -> Option<u32> {
|
||||
if chars.get(i) != Some(&'\\') || chars.get(i + 1) != Some(&'U') || chars.get(i + 2) != Some(&'+') {
|
||||
return None;
|
||||
}
|
||||
let hex = chars.get(i + 3..i + 7)?;
|
||||
if !hex.iter().all(char::is_ascii_hexdigit) {
|
||||
return None;
|
||||
}
|
||||
hex.iter().try_fold(0u32, |acc, c| Some(acc * 16 + c.to_digit(16)?))
|
||||
}
|
||||
|
||||
/// The character of a `\M+nXXXX` escape starting at `chars[i]`, if there is one: `n` names a
|
||||
/// double-byte code page and `XXXX` is the character's two bytes in hex.
|
||||
pub fn mif_escape_at(chars: &[char], i: usize) -> Option<char> {
|
||||
if chars.get(i) != Some(&'\\') || chars.get(i + 1) != Some(&'M') || chars.get(i + 2) != Some(&'+') {
|
||||
return None;
|
||||
}
|
||||
let enc = codepage::mif_encoding(*chars.get(i + 3)?)?;
|
||||
let hex = chars.get(i + 4..i + 8)?;
|
||||
if !hex.iter().all(char::is_ascii_hexdigit) {
|
||||
return None;
|
||||
}
|
||||
let code = hex.iter().try_fold(0u16, |acc, c| Some(acc * 16 + u16::try_from(c.to_digit(16)?).ok()?))?;
|
||||
let bytes = code.to_be_bytes();
|
||||
let text = enc.decode_without_bom_handling_and_without_replacement(&bytes)?;
|
||||
let mut it = text.chars();
|
||||
it.next().filter(|_| it.next().is_none())
|
||||
}
|
||||
|
||||
/// Unescape the `\U+XXXX` sequences pre-R2007 DXF uses for characters outside the file's code
|
||||
/// page (four hex digits, one UTF-16 code unit; characters above U+FFFF are a surrogate pair of
|
||||
/// escapes), and the `\M+nXXXX` sequences for double-byte East Asian characters. Malformed
|
||||
/// escapes, unpaired surrogates and unknown `\M+` code pages are kept as literal text.
|
||||
fn unescape_unicode(s: &str) -> String {
|
||||
if !s.contains("\\U+") && !s.contains("\\M+") {
|
||||
return s.to_string();
|
||||
}
|
||||
let mut out = String::with_capacity(s.len());
|
||||
let chars: Vec<char> = s.chars().collect();
|
||||
let mut i = 0;
|
||||
while let Some(&c) = chars.get(i) {
|
||||
if let Some(ch) = mif_escape_at(&chars, i) {
|
||||
out.push(ch);
|
||||
i += 8;
|
||||
continue;
|
||||
}
|
||||
if let Some(unit) = escape_at(&chars, i) {
|
||||
if let Some(ch) = char::from_u32(unit) {
|
||||
out.push(ch);
|
||||
i += 7;
|
||||
continue;
|
||||
}
|
||||
if (0xD800..0xDC00).contains(&unit)
|
||||
&& let Some(low) = escape_at(&chars, i + 7).filter(|u| (0xDC00..0xE000).contains(u))
|
||||
&& let Some(ch) = char::from_u32(0x10000 + ((unit - 0xD800) << 10) + (low - 0xDC00))
|
||||
{
|
||||
out.push(ch);
|
||||
i += 14;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
out.push(c);
|
||||
i += 1;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The lines of an ASCII DXF text: LF, CRLF and a lone CR (old Mac files) all end a line, like
|
||||
/// [`str::lines`] otherwise (no empty line after a final terminator).
|
||||
fn ascii_lines(text: &str) -> impl Iterator<Item = &str> {
|
||||
let mut rest = text;
|
||||
std::iter::from_fn(move || {
|
||||
if rest.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let end = rest.find(['\r', '\n']).unwrap_or(rest.len());
|
||||
let line = rest.get(..end).unwrap_or_default();
|
||||
let after = rest.get(end..).unwrap_or_default();
|
||||
rest = after.strip_prefix("\r\n").or_else(|| after.strip_prefix(['\r', '\n'])).unwrap_or(after);
|
||||
Some(line)
|
||||
})
|
||||
}
|
||||
|
||||
/// Byte-level twin of [`ascii_lines`] for the up-front limit check, so the count matches the parser.
|
||||
fn byte_lines(mut rest: &[u8]) -> impl Iterator<Item = &[u8]> {
|
||||
std::iter::from_fn(move || {
|
||||
if rest.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let end = rest.iter().position(|&b| b == b'\r' || b == b'\n').unwrap_or(rest.len());
|
||||
let line = &rest[..end];
|
||||
let after = &rest[end..];
|
||||
rest = match after {
|
||||
[b'\r', b'\n', tail @ ..] | [b'\r' | b'\n', tail @ ..] => tail,
|
||||
_ => after,
|
||||
};
|
||||
Some(line)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn parse_ascii(text: &str) -> Result<Vec<Tag>> {
|
||||
parse_ascii_counted(text, max_tags(), 0)
|
||||
}
|
||||
|
||||
/// [`parse_ascii`] of a file known to hold `expected` group codes. Their list is reserved first,
|
||||
/// with an allocation that can fail: where the system refuses that much memory, opening the file
|
||||
/// is an error instead of the end of the app. Growing the list instead could also briefly take
|
||||
/// half as much again.
|
||||
#[allow(clippy::while_let_loop)]
|
||||
fn parse_ascii_counted(text: &str, max_tags: usize, expected: usize) -> Result<Vec<Tag>> {
|
||||
let mut tags = Vec::new();
|
||||
tags.try_reserve_exact(expected.min(max_tags)).map_err(|_| DxfError::OutOfMemory { tags: expected })?;
|
||||
let mut lines = ascii_lines(text.strip_prefix('\u{feff}').unwrap_or(text)).enumerate();
|
||||
loop {
|
||||
let Some((ln, code_line)) = lines.next() else { break };
|
||||
let ct = code_line.trim();
|
||||
if ct.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let code: i32 = ct.parse().map_err(|_| DxfError::BadCode { line: ln + 1, text: ct.chars().take(40).collect() })?;
|
||||
let Some((_, val)) = lines.next() else { return Err(DxfError::Eof) };
|
||||
let v = typed(code, val);
|
||||
let v = match v {
|
||||
Value::Str(s) => Value::Str(unescape_unicode(&s)),
|
||||
o => o,
|
||||
};
|
||||
tags.push(Tag { code, value: v });
|
||||
if tags.len() > max_tags {
|
||||
return Err(DxfError::TooLarge { tags: tags.len(), limit: max_tags });
|
||||
}
|
||||
if code == 0 && tags.last().is_some_and(|t| t.str().trim_end() == "EOF") {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if tags.is_empty() {
|
||||
return Err(DxfError::NotDxf);
|
||||
}
|
||||
Ok(tags)
|
||||
}
|
||||
|
||||
struct Cur<'a> {
|
||||
b: &'a [u8],
|
||||
p: usize,
|
||||
}
|
||||
|
||||
impl<'a> Cur<'a> {
|
||||
fn take(&mut self, n: usize) -> Result<&[u8]> {
|
||||
let end = self.p.checked_add(n).ok_or(DxfError::Eof)?;
|
||||
let s = self.b.get(self.p..end).ok_or(DxfError::Eof)?;
|
||||
self.p = end;
|
||||
Ok(s)
|
||||
}
|
||||
fn u8(&mut self) -> Result<u8> {
|
||||
Ok(*self.take(1)?.first().ok_or(DxfError::Eof)?)
|
||||
}
|
||||
fn i16(&mut self) -> Result<i16> {
|
||||
let s = self.take(2)?;
|
||||
Ok(i16::from_le_bytes([s[0], s[1]]))
|
||||
}
|
||||
fn i32(&mut self) -> Result<i32> {
|
||||
let s = self.take(4)?;
|
||||
Ok(i32::from_le_bytes([s[0], s[1], s[2], s[3]]))
|
||||
}
|
||||
fn i64(&mut self) -> Result<i64> {
|
||||
let s = self.take(8)?;
|
||||
let mut a = [0u8; 8];
|
||||
a.copy_from_slice(s);
|
||||
Ok(i64::from_le_bytes(a))
|
||||
}
|
||||
fn f64(&mut self) -> Result<f64> {
|
||||
let s = self.take(8)?;
|
||||
let mut a = [0u8; 8];
|
||||
a.copy_from_slice(s);
|
||||
Ok(f64::from_le_bytes(a))
|
||||
}
|
||||
/// The bytes of a zero-terminated string (without the zero), decoded by the caller.
|
||||
fn cstr(&mut self) -> Result<&'a [u8]> {
|
||||
let start = self.p;
|
||||
while self.p < self.b.len() && self.b.get(self.p) != Some(&0) {
|
||||
self.p += 1;
|
||||
}
|
||||
let s = self.b.get(start..self.p).unwrap_or(&[]);
|
||||
if self.p >= self.b.len() {
|
||||
return Err(DxfError::Eof);
|
||||
}
|
||||
self.p += 1;
|
||||
Ok(s)
|
||||
}
|
||||
}
|
||||
|
||||
/// Binary DXF (R13+: 2-byte group codes).
|
||||
pub fn parse_binary(b: &[u8]) -> Result<Vec<Tag>> {
|
||||
parse_binary_with_limit(b, max_tags())
|
||||
}
|
||||
|
||||
fn parse_binary_with_limit(b: &[u8], max_tags: usize) -> Result<Vec<Tag>> {
|
||||
let mut text = codepage::BinaryText::default();
|
||||
let tags = parse_binary_pass(b, max_tags, &mut text)?;
|
||||
if !text.needs_code_page_pass() {
|
||||
return Ok(tags);
|
||||
}
|
||||
// The first pass's tags go before the second pass runs: both held at once would double
|
||||
// the peak near the tag limit.
|
||||
drop(tags);
|
||||
parse_binary_pass(b, max_tags, &mut codepage::BinaryText::code_page_pass())
|
||||
}
|
||||
|
||||
fn parse_binary_pass(b: &[u8], max_tags: usize, text: &mut codepage::BinaryText) -> Result<Vec<Tag>> {
|
||||
let mut c = Cur { b, p: 0 };
|
||||
let mut tags = Vec::new();
|
||||
while c.p < b.len() {
|
||||
let mut code = i32::from(c.i16()?);
|
||||
if code == 255 {
|
||||
code = i32::from(c.i16()?);
|
||||
}
|
||||
let v = match kind_of(code) {
|
||||
Kind::Str => Value::Str(unescape_unicode(&text.string(code, c.cstr()?))),
|
||||
Kind::Real => Value::Real(Some(c.f64()?).filter(|v| v.is_finite()).unwrap_or(0.0)),
|
||||
Kind::Int16 => Value::Int(i64::from(c.i16()?)),
|
||||
Kind::Int32 => Value::Int(i64::from(c.i32()?)),
|
||||
Kind::Int64 => Value::Int(c.i64()?),
|
||||
Kind::Bool => Value::Bool(c.u8()? != 0),
|
||||
Kind::Hex => {
|
||||
let n = usize::from(c.u8()?);
|
||||
let bytes = c.take(n)?;
|
||||
let mut s = String::with_capacity(n * 2);
|
||||
for x in bytes {
|
||||
let _ = write!(s, "{x:02X}");
|
||||
}
|
||||
Value::Hex(s)
|
||||
}
|
||||
};
|
||||
let eof = code == 0 && matches!(&v, Value::Str(s) if s.trim_end() == "EOF");
|
||||
tags.push(Tag { code, value: v });
|
||||
if tags.len() > max_tags {
|
||||
return Err(DxfError::TooLarge { tags: tags.len(), limit: max_tags });
|
||||
}
|
||||
if eof {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if tags.is_empty() {
|
||||
return Err(DxfError::NotDxf);
|
||||
}
|
||||
Ok(tags)
|
||||
}
|
||||
|
||||
/// Format a real the way DXF writers usually do (shortest round-trip, with a decimal point).
|
||||
pub fn format_real(v: f64) -> String {
|
||||
if !v.is_finite() {
|
||||
return "0.0".into();
|
||||
}
|
||||
let s = format!("{v}");
|
||||
if s.contains('.') || s.contains('e') || s.contains("inf") || s.contains("NaN") { s } else { format!("{s}.0") }
|
||||
}
|
||||
|
||||
/// Write tags as ASCII DXF (CRLF line ends, codes right-aligned to 3 as is conventional).
|
||||
///
|
||||
/// The output is pure ASCII: non-ASCII characters in strings are written as `\U+XXXX` escapes,
|
||||
/// the pre-R2007 convention, so it is correct whatever `$DWGCODEPAGE` the header declares.
|
||||
pub fn write_ascii(tags: &[Tag]) -> String {
|
||||
write_ascii_as(tags, false)
|
||||
}
|
||||
|
||||
/// Write tags as ASCII DXF with text in UTF-8 (`utf8`, the R2007+ convention: non-ASCII
|
||||
/// characters as they are) or escaped as `\U+XXXX` (older versions, see [`write_ascii`]). Line
|
||||
/// breaks inside strings become spaces either way.
|
||||
pub fn write_ascii_as(tags: &[Tag], utf8: bool) -> String {
|
||||
let bytes = ascii(tags, if utf8 { Strings::Utf8 } else { Strings::Escaped(None) });
|
||||
// Both forms are UTF-8 (the escaped one is ASCII).
|
||||
String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned())
|
||||
}
|
||||
|
||||
/// Write tags as pre-R2007 ASCII DXF with text in the code page `code_page` names (a
|
||||
/// `$DWGCODEPAGE` value such as `ANSI_1252`), as the DXF Reference describes for those versions:
|
||||
/// a character the code page has is written as its bytes, any other as a `\U+XXXX` escape. A
|
||||
/// code page CADCraft doesn't know, `ASCII`, and `UTF8`/`UNICODE` (not a pre-2007 code page)
|
||||
/// give [`write_ascii`]'s pure ASCII output. So does a file whose code page bytes happen to be
|
||||
/// valid UTF-8 (`СІ` in ANSI_1251 is D1 B2, U+0472), since readers, ours included, take an ASCII
|
||||
/// DXF that is valid UTF-8 as UTF-8.
|
||||
pub fn write_ascii_in(tags: &[Tag], code_page: &str) -> Vec<u8> {
|
||||
let bytes = ascii(tags, Strings::Escaped(codepage::encoder(code_page)));
|
||||
if !bytes.is_ascii() && std::str::from_utf8(&bytes).is_ok() {
|
||||
return ascii(tags, Strings::Escaped(None));
|
||||
}
|
||||
bytes
|
||||
}
|
||||
|
||||
/// How a writer stores string values.
|
||||
#[derive(Clone, Copy)]
|
||||
enum Strings {
|
||||
/// As they are (R2007+).
|
||||
Utf8,
|
||||
/// ASCII as it is, other characters in this code page when it has them, otherwise as
|
||||
/// `\U+XXXX` escapes (before R2007).
|
||||
Escaped(Option<codepage::Decoder>),
|
||||
}
|
||||
|
||||
fn ascii(tags: &[Tag], strings: Strings) -> Vec<u8> {
|
||||
let mut out = Vec::with_capacity(tags.len() * 16);
|
||||
for t in tags {
|
||||
let _ = write!(out, "{:>3}\r\n", t.code);
|
||||
match &t.value {
|
||||
Value::Str(s) => push_string(s, strings, &mut out),
|
||||
Value::Real(r) => out.extend_from_slice(format_real(*r).as_bytes()),
|
||||
Value::Int(i) => out.extend_from_slice(i.to_string().as_bytes()),
|
||||
Value::Bool(b) => out.extend_from_slice(i64::from(*b).to_string().as_bytes()),
|
||||
Value::Hex(h) => {
|
||||
// The DXF Reference limits a binary chunk line to 254 hex digits (127 bytes);
|
||||
// longer data continues in further groups of the same code. Only hex digits are
|
||||
// written, so a hostile value can't inject tags.
|
||||
let digits = normalize_hex(h);
|
||||
let mut chunks: Vec<&str> = digits.as_bytes().chunks(254).map(|c| std::str::from_utf8(c).unwrap_or_default()).collect();
|
||||
if chunks.is_empty() {
|
||||
chunks.push("");
|
||||
}
|
||||
for (n, chunk) in chunks.into_iter().enumerate() {
|
||||
if n > 0 {
|
||||
let _ = write!(out, "\r\n{:>3}\r\n", t.code);
|
||||
}
|
||||
out.extend_from_slice(chunk.as_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
out.extend_from_slice(b"\r\n");
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Write tags as binary DXF (DXF Reference, "Binary DXF Files", R13+ layout): the sentinel,
|
||||
/// then per tag a 2-byte little-endian group code and the value in the binary form of the code's
|
||||
/// [`Kind`]: a zero-terminated string, an 8-byte real, a 2-, 4- or 8-byte integer, a 1-byte
|
||||
/// boolean, or a binary chunk (one length byte, then up to 255 bytes; longer data is split into
|
||||
/// several groups of the same code). Strings are UTF-8 when `utf8` (R2007+), otherwise escaped as
|
||||
/// in [`write_ascii`]. A tag's value is converted to its code's kind, so a number written as text
|
||||
/// is stored as a number; a code outside the 16-bit range is skipped.
|
||||
pub fn write_binary(tags: &[Tag], utf8: bool) -> Vec<u8> {
|
||||
binary(tags, if utf8 { Strings::Utf8 } else { Strings::Escaped(None) })
|
||||
}
|
||||
|
||||
/// Write tags as pre-R2007 binary DXF with text in the code page `code_page` names, as
|
||||
/// [`write_ascii_in`] does.
|
||||
pub fn write_binary_in(tags: &[Tag], code_page: &str) -> Vec<u8> {
|
||||
binary(tags, Strings::Escaped(codepage::encoder(code_page)))
|
||||
}
|
||||
|
||||
fn binary(tags: &[Tag], strings: Strings) -> Vec<u8> {
|
||||
let mut out = Vec::with_capacity(BINARY_SENTINEL.len() + tags.len() * 12);
|
||||
out.extend_from_slice(BINARY_SENTINEL);
|
||||
for t in tags {
|
||||
let Ok(code) = i16::try_from(t.code) else { continue };
|
||||
let code_bytes = code.to_le_bytes();
|
||||
match kind_of(t.code) {
|
||||
Kind::Str => {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
let s = match &t.value {
|
||||
Value::Str(s) => s.clone(),
|
||||
v => v.as_str(),
|
||||
};
|
||||
let mut text = Vec::with_capacity(s.len());
|
||||
push_string(&s, strings, &mut text);
|
||||
out.extend(text.into_iter().filter(|&b| b != 0));
|
||||
out.push(0);
|
||||
}
|
||||
Kind::Real => {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
out.extend_from_slice(&t.value.as_f64().to_le_bytes());
|
||||
}
|
||||
Kind::Int16 => {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
out.extend_from_slice(&wrap_i16(t.value.as_i64()));
|
||||
}
|
||||
Kind::Int32 => {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
out.extend_from_slice(&wrap_i32(t.value.as_i64()));
|
||||
}
|
||||
Kind::Int64 => {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
out.extend_from_slice(&t.value.as_i64().to_le_bytes());
|
||||
}
|
||||
Kind::Bool => {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
out.push(u8::from(t.value.as_i64() != 0));
|
||||
}
|
||||
Kind::Hex => {
|
||||
let bytes = hex_bytes(&t.value.as_str());
|
||||
// An empty chunk is still one group, as in ASCII.
|
||||
let mut chunks: Vec<&[u8]> = bytes.chunks(255).collect();
|
||||
if chunks.is_empty() {
|
||||
chunks.push(&[]);
|
||||
}
|
||||
for chunk in chunks {
|
||||
out.extend_from_slice(&code_bytes);
|
||||
out.push(u8::try_from(chunk.len()).unwrap_or(u8::MAX));
|
||||
out.extend_from_slice(chunk);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Hex text cleaned up: only the hex digits are kept, and an odd trailing digit is padded with
|
||||
/// `0` (so the bytes before it are never shifted). Used by the reader and both writers.
|
||||
fn normalize_hex(s: &str) -> String {
|
||||
let mut out: String = s.chars().filter(char::is_ascii_hexdigit).collect();
|
||||
if out.len() % 2 == 1 {
|
||||
out.push('0');
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The bytes of hex text, two digits each (see [`normalize_hex`]).
|
||||
fn hex_bytes(s: &str) -> Vec<u8> {
|
||||
let digits: Vec<u8> = normalize_hex(s).bytes().filter_map(|b| char::from(b).to_digit(16).and_then(|d| u8::try_from(d).ok())).collect();
|
||||
digits.as_chunks::<2>().0.iter().map(|[hi, lo]| (hi << 4) | lo).collect()
|
||||
}
|
||||
|
||||
/// A 16- or 32-bit integer for binary DXF: values that fit the unsigned width wrap into the
|
||||
/// signed one (65535 is -1, as writers that store unsigned flags expect); anything else clamps.
|
||||
fn wrap_i16(v: i64) -> [u8; 2] {
|
||||
match u16::try_from(v) {
|
||||
Ok(u) => u.to_le_bytes(),
|
||||
Err(_) => i16::try_from(v.clamp(i64::from(i16::MIN), i64::from(i16::MAX))).unwrap_or_default().to_le_bytes(),
|
||||
}
|
||||
}
|
||||
|
||||
fn wrap_i32(v: i64) -> [u8; 4] {
|
||||
match u32::try_from(v) {
|
||||
Ok(u) => u.to_le_bytes(),
|
||||
Err(_) => i32::try_from(v.clamp(i64::from(i32::MIN), i64::from(i32::MAX))).unwrap_or_default().to_le_bytes(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether `bytes` are a binary DXF file (they start with the binary sentinel).
|
||||
pub fn is_binary(bytes: &[u8]) -> bool {
|
||||
bytes.starts_with(BINARY_SENTINEL)
|
||||
}
|
||||
|
||||
/// A string value as `strings` stores it. Line breaks become spaces. Before R2007 the text is
|
||||
/// in the `$DWGCODEPAGE` code page: ASCII stays as it is, a character the code page has becomes
|
||||
/// its bytes, and every other one `\U+XXXX` (a surrogate pair of escapes above U+FFFF). Without
|
||||
/// a code page the result is ASCII, so it is valid in any code page. In every form a backslash
|
||||
/// that would start a `\U+` or `\M+` sequence is written as `\U+005C`, so the reader gives back
|
||||
/// the literal text (#2050). So is a double-byte character whose trail byte is 0x5C (`\`) in that
|
||||
/// place, such as Shift-JIS `表` or Big5 `許`: CADCraft decodes the code page before it looks for
|
||||
/// escapes, but a reader that looks first would take that byte and the `U+` after it for one.
|
||||
fn push_string(s: &str, strings: Strings, out: &mut Vec<u8>) {
|
||||
let chars: Vec<char> = s.chars().collect();
|
||||
let escape_at = |j: usize| matches!(chars.get(j), Some('U' | 'M')) && chars.get(j + 1) == Some(&'+');
|
||||
for (i, &c) in chars.iter().enumerate() {
|
||||
match (c, strings) {
|
||||
('\r' | '\n', _) => out.push(b' '),
|
||||
('\\', _) if escape_at(i + 1) => {
|
||||
out.extend_from_slice(b"\\U+005C");
|
||||
}
|
||||
(c, Strings::Utf8) => out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
|
||||
(c, _) if c.is_ascii() => out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
|
||||
(c, Strings::Escaped(Some(d))) if code_page_bytes(c, d, escape_at(i + 1), out) => {}
|
||||
(c, Strings::Escaped(_)) => {
|
||||
let mut units = [0u16; 2];
|
||||
for u in c.encode_utf16(&mut units) {
|
||||
let _ = write!(out, "\\U+{u:04X}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `c` in the code page `d`, if it has it, unless it is a double-byte character whose trail byte
|
||||
/// is 0x5C and an escape's `U+` or `M+` follows (`before_escape`): see [`push_string`].
|
||||
fn code_page_bytes(c: char, d: codepage::Decoder, before_escape: bool, out: &mut Vec<u8>) -> bool {
|
||||
let start = out.len();
|
||||
if !codepage::encode_char(c, d, out) {
|
||||
return false;
|
||||
}
|
||||
if before_escape && out.len() - start > 1 && out.last() == Some(&b'\\') {
|
||||
out.truncate(start);
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// A section: `0 SECTION / 2 NAME ... 0 ENDSEC`.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Section {
|
||||
pub name: String,
|
||||
pub tags: Vec<Tag>,
|
||||
}
|
||||
|
||||
/// Split a tag stream into sections.
|
||||
pub fn sections(tags: &[Tag]) -> Vec<Section> {
|
||||
let mut out = Vec::new();
|
||||
let mut i = 0;
|
||||
while i < tags.len() {
|
||||
let is_sec = tags.get(i).is_some_and(|t| t.code == 0 && t.str().trim_end() == "SECTION");
|
||||
if is_sec {
|
||||
let name = tags.get(i + 1).filter(|t| t.code == 2).map(|t| t.str().trim_end().to_string()).unwrap_or_default();
|
||||
let start = i + 2;
|
||||
let mut j = start;
|
||||
while j < tags.len() && !(tags.get(j).is_some_and(|t| t.code == 0 && t.str().trim_end() == "ENDSEC")) {
|
||||
j += 1;
|
||||
}
|
||||
out.push(Section { name, tags: tags.get(start..j).unwrap_or(&[]).to_vec() });
|
||||
i = j + 1;
|
||||
} else {
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Split a run of tags into records starting at each code-0 tag: (type, tags after the 0).
|
||||
pub fn records(tags: &[Tag]) -> Vec<(String, Vec<Tag>)> {
|
||||
let mut out: Vec<(String, Vec<Tag>)> = Vec::new();
|
||||
for t in tags {
|
||||
if t.code == 0 {
|
||||
out.push((t.str(), Vec::new()));
|
||||
} else if let Some(last) = out.last_mut() {
|
||||
last.1.push(t.clone());
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn literal_escape_text_roundtrips() {
|
||||
for utf8 in [false, true] {
|
||||
for text in ["\\U+00E9", "\\M+183A4F", "a\\nb \\P", "\\\\U+00E9", "\\U+005C"] {
|
||||
let tags = vec![Tag::s(8, text)];
|
||||
let back = parse_ascii(&write_ascii_as(&tags, utf8)).unwrap();
|
||||
assert_eq!(back, tags, "utf8={utf8} {text}");
|
||||
let back = parse_binary(&write_binary(&tags, utf8)).unwrap();
|
||||
assert_eq!(back[1..], tags[..], "binary utf8={utf8} {text}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blank_lines_do_not_consume_group_code_limit() {
|
||||
let tags = parse_with_limit(b"0\nEOF\n\n\n", 1).expect("one group code should fit a limit of one");
|
||||
assert_eq!(tags, vec![Tag::s(0, "EOF")]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ascii_roundtrip() {
|
||||
let tags = vec![
|
||||
Tag::s(0, "SECTION"),
|
||||
Tag::s(2, "ENTITIES"),
|
||||
Tag::s(0, "LINE"),
|
||||
Tag::s(8, "0"),
|
||||
Tag::f(10, 1.5),
|
||||
Tag::f(20, 2.0),
|
||||
Tag::i(62, 1),
|
||||
Tag::s(0, "ENDSEC"),
|
||||
Tag::s(0, "EOF"),
|
||||
];
|
||||
let text = write_ascii(&tags);
|
||||
let back = parse(text.as_bytes()).unwrap();
|
||||
assert_eq!(back, tags);
|
||||
let secs = sections(&back);
|
||||
assert_eq!(secs.len(), 1);
|
||||
assert_eq!(secs[0].name, "ENTITIES");
|
||||
let recs = records(&secs[0].tags);
|
||||
assert_eq!(recs[0].0, "LINE");
|
||||
assert_eq!(recs[0].1.len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_parse() {
|
||||
let mut b = BINARY_SENTINEL.to_vec();
|
||||
let push_str = |b: &mut Vec<u8>, code: i16, s: &str| {
|
||||
b.extend_from_slice(&code.to_le_bytes());
|
||||
b.extend_from_slice(s.as_bytes());
|
||||
b.push(0);
|
||||
};
|
||||
push_str(&mut b, 0, "LINE");
|
||||
b.extend_from_slice(&10i16.to_le_bytes());
|
||||
b.extend_from_slice(&3.25f64.to_le_bytes());
|
||||
b.extend_from_slice(&62i16.to_le_bytes());
|
||||
b.extend_from_slice(&5i16.to_le_bytes());
|
||||
push_str(&mut b, 0, "EOF");
|
||||
let tags = parse(&b).unwrap();
|
||||
assert_eq!(tags[1], Tag::f(10, 3.25));
|
||||
assert_eq!(tags[2], Tag::i(62, 5));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_inputs() {
|
||||
assert!(parse(b"").is_err());
|
||||
assert!(parse(b"abc\nxyz\n").is_err());
|
||||
assert!(parse(b"0\n").is_err());
|
||||
let mut b = BINARY_SENTINEL.to_vec();
|
||||
b.extend_from_slice(&10i16.to_le_bytes());
|
||||
b.extend_from_slice(&[1, 2, 3]);
|
||||
assert!(parse(&b).is_err());
|
||||
// Bad numbers become 0 rather than failing.
|
||||
let t = parse(b"10\nnotanumber\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0].f64(), 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unicode_escapes_and_latin1() {
|
||||
let t = parse(b"1\nCaf\\U+00E9\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0].str(), "Café");
|
||||
let t = parse(b"1\nCaf\xe9\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0].str(), "Café");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn surrogate_pair_escapes() {
|
||||
let t = parse(b"1\n\\U+D83D\\U+DE00 \\u+56fe\\U+53f7\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0].str(), "😀 \\u+56fe号");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_escapes_stay_literal() {
|
||||
for s in [
|
||||
"\\U+",
|
||||
"\\U",
|
||||
"\\",
|
||||
"a\\U+ZZZZ",
|
||||
"\\U+12",
|
||||
"\\U+D800",
|
||||
"\\U+DC00",
|
||||
"\\U+D800\\U+0041",
|
||||
"\\U+D83D\\U+DE",
|
||||
"\\U++123",
|
||||
"\\U+-123",
|
||||
"x\\U+12\u{e9}4",
|
||||
] {
|
||||
let t = parse(format!("1\n{s}\n0\nEOF\n").as_bytes()).unwrap();
|
||||
let expect = if s == "\\U+D800\\U+0041" { "\\U+D800A" } else { s };
|
||||
assert_eq!(t[0].str(), expect, "{s:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_non_ascii_as_escapes() {
|
||||
let tags = vec![Tag::s(1, "图号 İø 😀\r\nend"), Tag::s(1000, "Ø"), Tag::s(0, "EOF")];
|
||||
let text = write_ascii(&tags);
|
||||
assert!(text.is_ascii());
|
||||
assert!(text.contains("\\U+56FE\\U+53F7 \\U+00C4\\U+00B0\\U+00F8 \\U+D83D\\U+DE00 end\r\n"));
|
||||
let back = parse(text.as_bytes()).unwrap();
|
||||
assert_eq!(back[0].str(), "图号 İø 😀 end");
|
||||
assert_eq!(back[1].str(), "Ø");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_strings_unescape() {
|
||||
let mut b = BINARY_SENTINEL.to_vec();
|
||||
b.extend_from_slice(&1i16.to_le_bytes());
|
||||
b.extend_from_slice(b"\\U+56FE\\U+53F7\0");
|
||||
b.extend_from_slice(&0i16.to_le_bytes());
|
||||
b.extend_from_slice(b"EOF\0");
|
||||
assert_eq!(parse(&b).unwrap()[0].str(), "图号");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod limit_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn tag_limit_defaults_and_env_override() {
|
||||
assert_eq!(max_tags_from(None), MAX_TAGS);
|
||||
assert_eq!(max_tags_from(Some("")), MAX_TAGS);
|
||||
assert_eq!(max_tags_from(Some("0")), MAX_TAGS);
|
||||
assert_eq!(max_tags_from(Some("abc")), MAX_TAGS);
|
||||
assert_eq!(max_tags_from(Some(" 400_000_000 ")), 400_000_000);
|
||||
// Issue #1948: the default must admit a DXF rendition well above 50 million group codes.
|
||||
const { assert!(MAX_TAGS >= 100_000_000) };
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_tag_list_is_reserved_once_and_a_refusal_is_an_error() {
|
||||
let tags = parse_ascii_counted("0\nSECTION\n0\nENDSEC\n0\nEOF\n", MAX_TAGS, 3).unwrap();
|
||||
assert_eq!((tags.len(), tags.capacity()), (3, 3));
|
||||
let e = parse_ascii_counted("0\nEOF\n", usize::MAX, usize::MAX).unwrap_err();
|
||||
assert!(matches!(e, DxfError::OutOfMemory { .. }), "{e}");
|
||||
}
|
||||
}
|
||||
@@ -1,117 +0,0 @@
|
||||
//! The DXF/DWG file versions CADCraft writes (DXF Reference, HEADER `$ACADVER`).
|
||||
|
||||
/// A file version CADCraft can save: the AutoCAD release that introduced the format. Each format
|
||||
/// also serves the releases after it (2018 is still AutoCAD's current format).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub enum Version {
|
||||
/// AutoCAD 2000/2002 (AC1015).
|
||||
R2000,
|
||||
/// AutoCAD 2004–2006 (AC1018).
|
||||
R2004,
|
||||
/// AutoCAD 2007–2009 (AC1021): the first version whose DXF text is UTF-8.
|
||||
R2007,
|
||||
/// AutoCAD 2010–2012 (AC1024).
|
||||
R2010,
|
||||
/// AutoCAD 2013–2017 (AC1027).
|
||||
R2013,
|
||||
/// AutoCAD 2018 and later (AC1032), the default.
|
||||
#[default]
|
||||
R2018,
|
||||
}
|
||||
|
||||
impl Version {
|
||||
/// Every version, oldest first.
|
||||
pub const ALL: [Version; 6] = [Version::R2000, Version::R2004, Version::R2007, Version::R2010, Version::R2013, Version::R2018];
|
||||
|
||||
/// The `$ACADVER` code ("AC1032").
|
||||
pub fn code(self) -> &'static str {
|
||||
match self {
|
||||
Version::R2000 => "AC1015",
|
||||
Version::R2004 => "AC1018",
|
||||
Version::R2007 => "AC1021",
|
||||
Version::R2010 => "AC1024",
|
||||
Version::R2013 => "AC1027",
|
||||
Version::R2018 => "AC1032",
|
||||
}
|
||||
}
|
||||
|
||||
/// The release year that names the version ("2018").
|
||||
pub fn year(self) -> &'static str {
|
||||
match self {
|
||||
Version::R2000 => "2000",
|
||||
Version::R2004 => "2004",
|
||||
Version::R2007 => "2007",
|
||||
Version::R2010 => "2010",
|
||||
Version::R2013 => "2013",
|
||||
Version::R2018 => "2018",
|
||||
}
|
||||
}
|
||||
|
||||
/// A version named by its year ("2018", "R2018") or its `$ACADVER` code ("AC1032"), any case.
|
||||
pub fn parse(s: &str) -> Option<Version> {
|
||||
let s = s.trim();
|
||||
let year = s.strip_prefix(['R', 'r']).unwrap_or(s);
|
||||
Version::ALL.into_iter().find(|v| v.year() == year || v.code().eq_ignore_ascii_case(s))
|
||||
}
|
||||
|
||||
/// The version to save a file of `$ACADVER` `code` in: the same version when CADCraft writes
|
||||
/// it, else the nearest one it does (R2000 for older files, 2018 for newer ones); `None` when
|
||||
/// the code isn't a version code at all.
|
||||
pub fn for_acadver(code: &str) -> Option<Version> {
|
||||
let code = code.trim();
|
||||
if let Some(v) = Version::ALL.into_iter().find(|v| v.code().eq_ignore_ascii_case(code)) {
|
||||
return Some(v);
|
||||
}
|
||||
code.get(..2).filter(|p| p.eq_ignore_ascii_case("AC"))?;
|
||||
let n = code.get(2..).filter(|d| d.bytes().all(|b| b.is_ascii_digit())).and_then(|d| d.parse::<u32>().ok())?;
|
||||
Some(match n {
|
||||
..1018 => Version::R2000,
|
||||
1018..1021 => Version::R2004,
|
||||
1021..1024 => Version::R2007,
|
||||
1024..1027 => Version::R2010,
|
||||
1027..1032 => Version::R2013,
|
||||
_ => Version::R2018,
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether text in this version's DXF is UTF-8 (2007 and later). Older versions keep text in
|
||||
/// the `$DWGCODEPAGE` code page, which CADCraft avoids by escaping non-ASCII as `\U+XXXX`.
|
||||
pub fn utf8(self) -> bool {
|
||||
self >= Version::R2007
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Version {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(self.year())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn parses_years_and_codes() {
|
||||
assert_eq!(Version::parse("2018"), Some(Version::R2018));
|
||||
assert_eq!(Version::parse(" r2004 "), Some(Version::R2004));
|
||||
assert_eq!(Version::parse("ac1021"), Some(Version::R2007));
|
||||
assert_eq!(Version::parse("2005"), None);
|
||||
assert_eq!(Version::parse(""), None);
|
||||
for v in Version::ALL {
|
||||
assert_eq!(Version::parse(v.code()), Some(v));
|
||||
assert_eq!(Version::parse(v.year()), Some(v));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn file_versions_map_to_the_nearest_writable_one() {
|
||||
assert_eq!(Version::for_acadver("AC1009"), Some(Version::R2000));
|
||||
assert_eq!(Version::for_acadver("AC1014"), Some(Version::R2000));
|
||||
assert_eq!(Version::for_acadver("AC1024"), Some(Version::R2010));
|
||||
assert_eq!(Version::for_acadver("AC1035"), Some(Version::R2018));
|
||||
assert_eq!(Version::for_acadver("MC0.0"), None);
|
||||
assert_eq!(Version::for_acadver("AC"), None);
|
||||
assert_eq!(Version::for_acadver("AC99999999999999999999"), None);
|
||||
}
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
//! A UTF-8 byte order mark at the start of an ASCII DXF is skipped.
|
||||
|
||||
const BODY: &str = " 0\r\nSECTION\r\n 2\r\nENTITIES\r\n 0\r\nENDSEC\r\n 0\r\nEOF\r\n";
|
||||
|
||||
#[test]
|
||||
fn utf8_bom_bytes_are_skipped() {
|
||||
let plain = cadcraft_dxf::parse(BODY.as_bytes()).expect("plain parses");
|
||||
let mut bytes = vec![0xEF, 0xBB, 0xBF];
|
||||
bytes.extend_from_slice(BODY.as_bytes());
|
||||
let with_bom = cadcraft_dxf::parse(&bytes);
|
||||
assert!(with_bom.is_ok(), "{with_bom:?}");
|
||||
assert_eq!(with_bom.map(|t| t.len()).unwrap_or(0), plain.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bom_text_is_skipped() {
|
||||
let text = format!("\u{feff}{BODY}");
|
||||
assert!(cadcraft_dxf::parse_ascii(&text).is_ok());
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
//! Binary DXF writing (#421): every value kind round-trips through `write_binary` and `parse`,
|
||||
//! and hostile binary input never panics.
|
||||
|
||||
use cadcraft_dxf::{Tag, Value, is_binary, parse, write_ascii_as, write_binary};
|
||||
|
||||
fn sample() -> Vec<Tag> {
|
||||
vec![
|
||||
Tag::s(0, "SECTION"),
|
||||
Tag::s(2, "ENTITIES"),
|
||||
Tag::s(0, "TEXT"),
|
||||
Tag::s(5, "1F"),
|
||||
Tag::f(10, -3.25),
|
||||
Tag::i(62, 5),
|
||||
Tag::i(90, 70_000),
|
||||
Tag::i(160, 1 << 40),
|
||||
Tag::new(290, Value::Bool(true)),
|
||||
Tag::new(310, Value::Hex("00FFA5".into())),
|
||||
Tag::s(1, "图号 Café 😀"),
|
||||
Tag::i(1071, -2),
|
||||
Tag::s(0, "ENDSEC"),
|
||||
Tag::s(0, "EOF"),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_roundtrips_every_value_kind() {
|
||||
for utf8 in [false, true] {
|
||||
let bytes = write_binary(&sample(), utf8);
|
||||
assert!(is_binary(&bytes));
|
||||
assert_eq!(parse(&bytes).unwrap(), sample(), "utf8 = {utf8}");
|
||||
}
|
||||
// Pre-2007 strings are escaped to ASCII, 2007+ ones are UTF-8.
|
||||
let old = write_binary(&sample(), false);
|
||||
assert!(old.windows(7).any(|w| w == b"\\U+56FE"));
|
||||
let new = write_binary(&sample(), true);
|
||||
assert!(new.windows("图号".len()).any(|w| w == "图号".as_bytes()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_converts_values_to_their_codes_kind() {
|
||||
// A number held as text at a numeric code, an out-of-range 16-bit value, a long chunk.
|
||||
let long = "AB".repeat(300);
|
||||
let tags = vec![Tag::s(70, "12"), Tag::i(62, 1 << 20), Tag::new(310, Value::Hex(long)), Tag::s(0, "EOF")];
|
||||
let back = parse(&write_binary(&tags, true)).unwrap();
|
||||
assert_eq!(back[0], Tag::i(70, 12));
|
||||
assert_eq!(back[1], Tag::i(62, i64::from(i16::MAX)));
|
||||
assert_eq!(back[2].code, 310);
|
||||
assert_eq!(back[3].code, 310, "300 bytes are split into chunks of at most 255");
|
||||
assert_eq!(back[2].str().len() + back[3].str().len(), 600);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn utf8_ascii_keeps_text_and_drops_line_breaks() {
|
||||
let text = write_ascii_as(&[Tag::s(1, "图号\r\nÄ"), Tag::s(0, "EOF")], true);
|
||||
assert!(text.contains("图号 Ä\r\n"));
|
||||
assert_eq!(parse(text.as_bytes()).unwrap()[0].str(), "图号 Ä");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_binary_input_never_panics() {
|
||||
let good = write_binary(&sample(), true);
|
||||
// Every truncation, and every single-byte corruption of the body.
|
||||
for n in 0..good.len() {
|
||||
let _ = parse(good.get(..n).unwrap());
|
||||
}
|
||||
for i in 22..good.len() {
|
||||
for b in [0u8, 0x7f, 0xff] {
|
||||
let mut bad = good.clone();
|
||||
bad[i] = b;
|
||||
let _ = parse(&bad);
|
||||
}
|
||||
}
|
||||
// A sentinel and nothing else is not a drawing.
|
||||
assert!(parse(b"AutoCAD Binary DXF\r\n\x1a\0").is_err());
|
||||
}
|
||||
@@ -1,116 +0,0 @@
|
||||
//! Pre-R2007 DXF text is written in the `$DWGCODEPAGE` code page: characters it has as their
|
||||
//! bytes, the others as `\U+XXXX` escapes; every form reads back to the same text.
|
||||
|
||||
use cadcraft_dxf::{Tag, parse, write_ascii, write_ascii_in, write_binary_in};
|
||||
|
||||
fn file(code_page: &str, text: &str) -> Vec<Tag> {
|
||||
vec![
|
||||
Tag::s(0, "SECTION"),
|
||||
Tag::s(2, "HEADER"),
|
||||
Tag::s(9, "$ACADVER"),
|
||||
Tag::s(1, "AC1015"),
|
||||
Tag::s(9, "$DWGCODEPAGE"),
|
||||
Tag::s(3, code_page),
|
||||
Tag::s(0, "ENDSEC"),
|
||||
Tag::s(0, "SECTION"),
|
||||
Tag::s(2, "ENTITIES"),
|
||||
Tag::s(0, "TEXT"),
|
||||
Tag::s(1, text),
|
||||
Tag::s(0, "ENDSEC"),
|
||||
Tag::s(0, "EOF"),
|
||||
]
|
||||
}
|
||||
|
||||
fn contains(bytes: &[u8], part: &[u8]) -> bool {
|
||||
bytes.windows(part.len()).any(|w| w == part)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_is_written_in_the_code_page() {
|
||||
// (code page, text, the bytes written for it)
|
||||
let cases: [(&str, &str, &[u8]); 6] = [
|
||||
("ANSI_1252", "Ação € 图", b"A\xE7\xE3o \x80 \\U+56FE"),
|
||||
("ANSI_1251", "Слой é", b"\xD1\xEB\xEE\xE9 \\U+00E9"),
|
||||
("ANSI_932", "表図面 é", b"\x95\x5C\x90\x7D\x96\xCA \\U+00E9"),
|
||||
("DOS850", "Größe €", b"Gr\x94\xE1e \\U+20AC"),
|
||||
("ANSI_1252", "😀", b"\\U+D83D\\U+DE00"),
|
||||
// A code page CADCraft doesn't know: everything non-ASCII is escaped.
|
||||
("ANSI_1361", "Ação", b"A\\U+00E7\\U+00E3o"),
|
||||
];
|
||||
for (cp, text, raw) in cases {
|
||||
let tags = file(cp, text);
|
||||
for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
|
||||
assert!(contains(&bytes, raw), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
|
||||
assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Without a known code page, and for `ASCII`, `UTF8` and `UNICODE` headers, the output is what
|
||||
/// `write_ascii` writes (pure ASCII with escapes), line breaks included.
|
||||
#[test]
|
||||
fn unknown_ascii_and_utf8_code_pages_are_pure_ascii() {
|
||||
for cp in ["EBCDIC", "ASCII", "ascii ", "UTF8", "UNICODE"] {
|
||||
let tags = file(cp, "Ação\r\nfim");
|
||||
let bytes = write_ascii_in(&tags, cp);
|
||||
assert!(bytes.is_ascii(), "{cp}");
|
||||
assert_eq!(bytes, write_ascii(&tags).into_bytes(), "{cp}");
|
||||
assert!(contains(&bytes, b"A\\U+00E7\\U+00E3o fim"), "{cp}");
|
||||
assert!(write_binary_in(&tags, cp).iter().all(u8::is_ascii), "{cp} binary");
|
||||
}
|
||||
}
|
||||
|
||||
/// Code page bytes that happen to form valid UTF-8 (`СІ` in ANSI_1251 is D1 B2, which is U+0472
|
||||
/// in UTF-8) would be read back as UTF-8 from an ASCII file, so that file is written with
|
||||
/// escapes. Binary DXF reads strings by the header's code page and keeps the bytes.
|
||||
#[test]
|
||||
fn code_page_bytes_that_are_valid_utf8_are_escaped_in_ascii() {
|
||||
let tags = file("ANSI_1251", "СІ");
|
||||
let ascii = write_ascii_in(&tags, "ANSI_1251");
|
||||
assert!(ascii.is_ascii(), "{:?}", String::from_utf8_lossy(&ascii));
|
||||
assert!(contains(&ascii, b"\\U+0421\\U+0406"));
|
||||
assert_eq!(parse(&ascii).unwrap()[10].str(), "СІ");
|
||||
let binary = write_binary_in(&tags, "ANSI_1251");
|
||||
assert!(contains(&binary, b"\xD1\xB2"));
|
||||
assert_eq!(parse(&binary).unwrap()[10].str(), "СІ");
|
||||
// Bytes that are not valid UTF-8 stay as they are.
|
||||
assert!(contains(&write_ascii_in(&file("ANSI_1251", "Слой"), "ANSI_1251"), b"\xD1\xEB\xEE\xE9"));
|
||||
}
|
||||
|
||||
/// A literal `\U+` or `\M+` in the text (#2050) reads back as written alongside code page bytes,
|
||||
/// in ASCII and binary, including an ASCII file that falls back to escapes because its bytes
|
||||
/// would read as UTF-8.
|
||||
#[test]
|
||||
fn literal_escapes_survive_code_page_text() {
|
||||
for (cp, text) in
|
||||
[("ANSI_1252", "Ação \\U+00E9 \\M+183A4F"), ("ANSI_1251", "Слой \\U+0041"), ("ANSI_1251", "СІ \\U+0041"), ("ANSI_932", "表 \\M+1")]
|
||||
{
|
||||
let tags = file(cp, text);
|
||||
for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
|
||||
assert!(contains(&bytes, b"\\U+005C"), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
|
||||
assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Double-byte code pages whose trail byte can be 0x5C (`\\`): Shift-JIS `表` (95 5C) and `ソ`
|
||||
/// (83 5C), Big5 `許` (B3 5C), GBK `乗` (81 5C). Right before `U+` or `M+`, such a character is
|
||||
/// written as an escape, so even a reader that looks for escapes before it decodes the code page
|
||||
/// reads it right. Elsewhere it stays as its bytes. Both forms read back as written.
|
||||
#[test]
|
||||
fn a_trail_byte_backslash_never_starts_an_escape() {
|
||||
let cases: [(&str, &str, &[u8], &[u8]); 4] = [
|
||||
("ANSI_932", "表U+0041 表示", b"\\U+8868U+0041 \x95\x5C\x8E\xA6", b"\x95\x5CU+"),
|
||||
("ANSI_932", "ソM+1A2B", b"\\U+30BDM+1A2B", b"\x83\x5CM+"),
|
||||
("ANSI_950", "許U+0041", b"\\U+8A31U+0041", b"\xB3\x5CU+"),
|
||||
("ANSI_936", "乗U+0041", b"\\U+4E57U+0041", b"\x81\x5CU+"),
|
||||
];
|
||||
for (cp, text, written, never) in cases {
|
||||
let tags = file(cp, text);
|
||||
for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
|
||||
assert!(contains(&bytes, written), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
|
||||
assert!(!contains(&bytes, never), "{cp} {what}: a trail byte starts an escape");
|
||||
assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,145 +0,0 @@
|
||||
//! Small independent byte fixtures for DXF tag types, text encoding, framing and failures.
|
||||
//! Handwritten examples, not files from a CAD application or generated by our writer.
|
||||
//! Background on the tag model and file structure:
|
||||
//! https://ezdxf.readthedocs.io/en/stable/dxfinternals/dxftags.html
|
||||
//! https://ezdxf.readthedocs.io/en/stable/dxfinternals/filestructure.html
|
||||
//! ASCII spacing is our writer's documented convention; binary fixtures specify actual bytes.
|
||||
|
||||
use cadcraft_dxf::{DxfError, Tag, Value, parse, parse_with_limit, write_ascii_as, write_binary};
|
||||
|
||||
const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
|
||||
|
||||
fn fixtures() -> Vec<(Tag, &'static [u8], &'static [u8])> {
|
||||
vec![
|
||||
(Tag::s(1, " A "), b" 1\r\n A \r\n", b"\x01\0 A \0"),
|
||||
(Tag::s(1, ""), b" 1\r\n\r\n", b"\x01\0\0"),
|
||||
(Tag::s(105, "AB12"), b"105\r\nAB12\r\n", b"\x69\0AB12\0"),
|
||||
(Tag::new(10, Value::Real(-3.25)), b" 10\r\n-3.25\r\n", b"\x0a\0\0\0\0\0\0\0\x0a\xc0"),
|
||||
(Tag::i(70, -32768), b" 70\r\n-32768\r\n", b"\x46\0\0\x80"),
|
||||
(Tag::i(90, -2147483648), b" 90\r\n-2147483648\r\n", b"\x5a\0\0\0\0\x80"),
|
||||
(Tag::i(160, 9223372036854775807), b"160\r\n9223372036854775807\r\n", b"\xa0\0\xff\xff\xff\xff\xff\xff\xff\x7f"),
|
||||
(Tag::new(290, Value::Bool(false)), b"290\r\n0\r\n", b"\x22\x01\0"),
|
||||
(Tag::new(299, Value::Bool(true)), b"299\r\n1\r\n", b"\x2b\x01\x01"),
|
||||
(Tag::new(310, Value::Hex("00FF80".into())), b"310\r\n00FF80\r\n", b"\x36\x01\x03\0\xff\x80"),
|
||||
(Tag::new(1004, Value::Hex(String::new())), b"1004\r\n\r\n", b"\xec\x03\0"),
|
||||
(Tag::i(1070, -2), b"1070\r\n-2\r\n", b"\x2e\x04\xfe\xff"),
|
||||
(Tag::i(1071, 65536), b"1071\r\n65536\r\n", b"\x2f\x04\0\0\x01\0"),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_independently_authored_ascii_and_binary_values() {
|
||||
for (expected, ascii, binary) in fixtures() {
|
||||
assert_eq!(parse(ascii).unwrap(), std::slice::from_ref(&expected), "ASCII code {}", expected.code);
|
||||
let bytes = [SENTINEL, binary].concat();
|
||||
assert_eq!(parse(&bytes).unwrap(), std::slice::from_ref(&expected), "binary code {}", expected.code);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn writes_independently_specified_ascii_and_binary_bytes() {
|
||||
for (tag, ascii, binary) in fixtures() {
|
||||
for utf8 in [false, true] {
|
||||
let tags = std::slice::from_ref(&tag);
|
||||
assert_eq!(write_ascii_as(tags, utf8).as_bytes(), ascii, "ASCII code {}", tag.code);
|
||||
assert_eq!(write_binary(tags, utf8), [SENTINEL, binary].concat(), "binary code {}", tag.code);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn integer_code_ranges_have_independent_binary_widths() {
|
||||
// Specification ranges and widths, never kind_of(): a shared reader/writer mistake
|
||||
// can round-trip every boundary value while still using the wrong number of bytes.
|
||||
let widths = [
|
||||
(vec![60..=79, 170..=179, 270..=289, 370..=389, 400..=409, 1060..=1070], 2, i64::from(i16::MIN), i64::from(i16::MAX)),
|
||||
(vec![90..=99, 420..=429, 440..=459, 1071..=1071], 4, i64::from(i32::MIN), i64::from(i32::MAX)),
|
||||
(std::iter::once(160..=169).collect(), 8, i64::MIN, i64::MAX),
|
||||
];
|
||||
for (ranges, width, min, max) in widths {
|
||||
for code in ranges.into_iter().flatten() {
|
||||
for value in [min, min + 1, -1, 0, 1, max - 1, max] {
|
||||
// Binary DXF uses a little-endian 16-bit group code and a fixed-width,
|
||||
// little-endian two's-complement integer. Encoding is version-independent.
|
||||
let code_bytes = u16::try_from(code).unwrap().to_le_bytes();
|
||||
let value_bytes = value.to_le_bytes();
|
||||
let expected = [SENTINEL, &code_bytes, &value_bytes[..width]].concat();
|
||||
let tags = [Tag::i(code, value)];
|
||||
for utf8 in [false, true] {
|
||||
assert_eq!(write_binary(&tags, utf8), expected, "code={code} value={value} utf8={utf8}");
|
||||
}
|
||||
assert_eq!(parse(&expected).unwrap(), tags, "code={code} value={value}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_encoding_has_independent_wire_expectations() {
|
||||
let tags = [Tag::s(1, "é😀")];
|
||||
let escaped = b"\\U+00E9\\U+D83D\\U+DE00";
|
||||
let utf8 = b"\xc3\xa9\xf0\x9f\x98\x80";
|
||||
for (unicode, text) in [(false, escaped.as_slice()), (true, utf8.as_slice())] {
|
||||
let ascii = [b" 1\r\n".as_slice(), text, b"\r\n"].concat();
|
||||
let binary = [SENTINEL, b"\x01\0", text, b"\0"].concat();
|
||||
assert_eq!(write_ascii_as(&tags, unicode).as_bytes(), ascii, "utf8={unicode}");
|
||||
assert_eq!(write_binary(&tags, unicode), binary, "utf8={unicode}");
|
||||
assert_eq!(parse(&ascii).unwrap(), tags);
|
||||
assert_eq!(parse(&binary).unwrap(), tags);
|
||||
}
|
||||
// Pre-2007 code-page bytes are independent of the writer, which emits Unicode escapes.
|
||||
let ascii = b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1252\n0\nENDSEC\n1\n\x80\xe9\n0\nEOF\n";
|
||||
let binary = [
|
||||
SENTINEL,
|
||||
b"\0\0SECTION\0\x02\0HEADER\0\x09\0$ACADVER\0\x01\0AC1015\0\x09\0$DWGCODEPAGE\0\x03\0ANSI_1252\0\0\0ENDSEC\0\x01\0\x80\xe9\0\0\0EOF\0",
|
||||
]
|
||||
.concat();
|
||||
for bytes in [ascii.as_slice(), binary.as_slice()] {
|
||||
let tags = parse(bytes).unwrap();
|
||||
assert_eq!(tags[7], Tag::s(1, "ێ"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ascii_accepts_line_endings_padding_and_no_final_newline() {
|
||||
let expected = [Tag::i(70, -7), Tag::s(1, " text "), Tag::s(0, "EOF")];
|
||||
for newline in ["\n", "\r\n"] {
|
||||
for final_newline in [false, true] {
|
||||
let mut text = [" 70 ", " -7 ", "1", " text ", "0", "EOF"].join(newline);
|
||||
if final_newline {
|
||||
text.push_str(newline);
|
||||
}
|
||||
assert_eq!(parse(text.as_bytes()).unwrap(), expected, "newline={newline:?} final={final_newline}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_and_truncated_values_are_errors_not_panics() {
|
||||
assert!(matches!(parse(b""), Err(DxfError::NotDxf)));
|
||||
assert!(matches!(parse(b"oops\nvalue\n"), Err(DxfError::BadCode { line: 1, .. })));
|
||||
assert!(matches!(parse(b"10\n"), Err(DxfError::Eof)));
|
||||
assert!(matches!(parse(SENTINEL), Err(DxfError::NotDxf)));
|
||||
for (_, _, binary) in fixtures() {
|
||||
// Every cut inside the first record is an error, unlike cuts between complete records:
|
||||
// the tag API deliberately accepts streams without an EOF record.
|
||||
for cut in 1..binary.len() {
|
||||
let bytes = [SENTINEL, &binary[..cut]].concat();
|
||||
assert!(matches!(parse(&bytes), Err(DxfError::Eof)), "binary={binary:?} cut={cut}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tag_limit_accepts_the_exact_boundary_and_rejects_one_less() {
|
||||
let ascii = b"1\nA\n70\n-7\n0\nEOF\n";
|
||||
let binary = [SENTINEL, b"\x01\0A\0\x46\0\xf9\xff\0\0EOF\0"].concat();
|
||||
for bytes in [ascii.as_slice(), binary.as_slice()] {
|
||||
for limit in 0..3 {
|
||||
assert!(matches!(parse_with_limit(bytes, limit), Err(DxfError::TooLarge { limit: actual, .. }) if actual == limit));
|
||||
}
|
||||
for limit in [3, 4] {
|
||||
assert_eq!(parse_with_limit(bytes, limit).unwrap(), [Tag::s(1, "A"), Tag::i(70, -7), Tag::s(0, "EOF")]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,220 +0,0 @@
|
||||
//! Hostile-input hardening of the DXF reader and writer (#1025): one regression test per finding.
|
||||
|
||||
use cadcraft_dxf::{Tag, Value, parse, parse_with_limit, sections, write_ascii, write_binary};
|
||||
|
||||
const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
|
||||
|
||||
fn bin_with(f: impl FnOnce(&mut Vec<u8>)) -> Vec<u8> {
|
||||
let mut b = SENTINEL.to_vec();
|
||||
f(&mut b);
|
||||
b.extend_from_slice(&0i16.to_le_bytes());
|
||||
b.extend_from_slice(b"EOF\0");
|
||||
b
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_reals_that_are_not_finite_become_zero() {
|
||||
for bits in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
|
||||
let b = bin_with(|b| {
|
||||
b.extend_from_slice(&10i16.to_le_bytes());
|
||||
b.extend_from_slice(&bits.to_le_bytes());
|
||||
});
|
||||
let tags = parse(&b).unwrap();
|
||||
assert_eq!(tags[0], Tag::f(10, 0.0), "{bits}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ascii_accepts_bom_and_cr_only_line_ends() {
|
||||
let want = vec![Tag::s(0, "SECTION"), Tag::s(2, "ENTITIES"), Tag::s(0, "ENDSEC"), Tag::s(0, "EOF")];
|
||||
let text = "0\rSECTION\r2\rENTITIES\r0\rENDSEC\r0\rEOF\r";
|
||||
assert_eq!(parse(text.as_bytes()).unwrap(), want);
|
||||
let mut bom = b"\xEF\xBB\xBF".to_vec();
|
||||
bom.extend_from_slice(text.replace('\r', "\r\n").as_bytes());
|
||||
assert_eq!(parse(&bom).unwrap(), want);
|
||||
// Mixed terminators.
|
||||
assert_eq!(parse(b"0\r\nSECTION\r2\nENTITIES\n0\rENDSEC\r\n0\nEOF").unwrap(), want);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cr_only_files_count_against_the_tag_limit() {
|
||||
let mut text = String::new();
|
||||
for _ in 0..50 {
|
||||
text.push_str("999\rcomment\r");
|
||||
}
|
||||
text.push_str("0\rEOF\r");
|
||||
assert!(parse_with_limit(text.as_bytes(), 10).is_err());
|
||||
assert_eq!(parse_with_limit(text.as_bytes(), 100).unwrap().len(), 51);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_bad_byte_spoils_one_line_not_the_file() {
|
||||
// Header says ANSI_1251; one line is UTF-8, one is Windows-1251, one has a stray byte.
|
||||
let mut b = b"9\n$DWGCODEPAGE\n3\nANSI_1251\n1\n".to_vec();
|
||||
b.extend_from_slice("Größe".as_bytes());
|
||||
b.extend_from_slice(b"\n1\n\xCF\xF0\xE8\xE2\xE5\xF2\n0\nEOF\n");
|
||||
let t = parse(&b).unwrap();
|
||||
assert_eq!(t[1].str(), "ANSI_1251");
|
||||
assert_eq!(t[2].str(), "Größe");
|
||||
assert_eq!(t[3].str(), "Привет");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ascii_uses_utf8_per_line_and_binary_stays_in_the_code_page() {
|
||||
// ANSI_1252 file with UTF-8 bytes in one string and a Latin-1 byte in another. The ASCII
|
||||
// reader takes a line that is valid UTF-8 as UTF-8; the binary reader reads every string
|
||||
// from the code page, because a pre-R2007 binary file has no way to escape to UTF-8.
|
||||
let utf8 = "Größe".as_bytes();
|
||||
let latin = b"Caf\xE9";
|
||||
let mut a = b"9\n$DWGCODEPAGE\n3\nANSI_1252\n1\n".to_vec();
|
||||
a.extend_from_slice(utf8);
|
||||
a.extend_from_slice(b"\n1\n");
|
||||
a.extend_from_slice(latin);
|
||||
a.extend_from_slice(b"\n0\nEOF\n");
|
||||
let from_ascii = parse(&a).unwrap();
|
||||
let b = bin_with(|b| {
|
||||
for (code, s) in [(9i16, &b"$DWGCODEPAGE"[..]), (3, b"ANSI_1252"), (1, utf8), (1, latin)] {
|
||||
b.extend_from_slice(&code.to_le_bytes());
|
||||
b.extend_from_slice(s);
|
||||
b.push(0);
|
||||
}
|
||||
});
|
||||
let from_binary = parse(&b).unwrap();
|
||||
assert_eq!(from_ascii[2].str(), "Größe");
|
||||
assert_eq!(from_ascii[3].str(), "Café");
|
||||
assert_eq!(from_binary[2].str(), "Größe");
|
||||
assert_eq!(from_binary[3].str(), "Café");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trailing_spaces_keep_sections_and_eof() {
|
||||
let t = parse(b"0\nSECTION \n2\nENTITIES \n0\nLINE\n0\nENDSEC \n0\nEOF \n0\nSECTION\n2\nX\n0\nENDSEC\n").unwrap();
|
||||
// The EOF with a trailing space still ends the file.
|
||||
assert_eq!(t.len(), 5);
|
||||
let s = sections(&t);
|
||||
assert_eq!(s.len(), 1);
|
||||
assert_eq!(s[0].name, "ENTITIES");
|
||||
assert_eq!(s[0].tags.len(), 1);
|
||||
// Binary EOF too.
|
||||
let mut b = SENTINEL.to_vec();
|
||||
b.extend_from_slice(&0i16.to_le_bytes());
|
||||
b.extend_from_slice(b"EOF \0");
|
||||
b.extend_from_slice(&1i16.to_le_bytes());
|
||||
b.extend_from_slice(b"after\0");
|
||||
assert_eq!(parse(&b).unwrap().len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn integer_groups_reject_non_finite_and_clamp() {
|
||||
let t = parse(b"70\ninf\n70\nNaN\n70\n1e30\n70\n-1e30\n90\n1e30\n160\n1e30\n160\n-inf\n62\n12.0\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0], Tag::i(70, 0));
|
||||
assert_eq!(t[1], Tag::i(70, 0));
|
||||
// Clamped to what the group's width holds, unsigned values included (the binary writer
|
||||
// keeps up to 65535 and 4294967295 as their bit patterns).
|
||||
assert_eq!(t[2], Tag::i(70, i64::from(u16::MAX)));
|
||||
assert_eq!(t[3], Tag::i(70, i64::from(i16::MIN)));
|
||||
assert_eq!(t[4], Tag::i(90, i64::from(u32::MAX)));
|
||||
assert_eq!(t[5], Tag::i(160, i64::MAX));
|
||||
assert_eq!(t[6], Tag::i(160, 0));
|
||||
assert_eq!(t[7], Tag::i(62, 12));
|
||||
assert_eq!(Value::Str("inf".into()).as_i64(), 0);
|
||||
}
|
||||
|
||||
/// An unsigned value spelled as a float reads as the same spelled as an integer (#1026 review):
|
||||
/// `65535.0` is 65535 like `65535`, not 32767.
|
||||
#[test]
|
||||
fn unsigned_values_read_the_same_in_either_spelling() {
|
||||
let t = parse(b"70\n65535.0\n70\n65535\n90\n4294967295.0\n90\n4294967295\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0], t[1]);
|
||||
assert_eq!(t[0], Tag::i(70, 65535));
|
||||
assert_eq!(t[2], t[3]);
|
||||
assert_eq!(t[2], Tag::i(90, 4_294_967_295));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hex_groups_pad_odd_digits_and_drop_junk() {
|
||||
let t = parse(b"310\nABC\n310\nA-B zC1\n310\n\n1004\n0aF\n0\nEOF\n").unwrap();
|
||||
assert_eq!(t[0].value, Value::Hex("ABC0".into()));
|
||||
assert_eq!(t[1].value, Value::Hex("ABC1".into()));
|
||||
assert_eq!(t[2].value, Value::Hex(String::new()));
|
||||
assert_eq!(t[3].value, Value::Hex("0aF0".into()));
|
||||
// The binary writer agrees with the reader: the odd digit is padded, nothing shifts.
|
||||
let back = parse(&write_binary(&[Tag::new(310, Value::Hex("ABC".into())), Tag::s(0, "EOF")], true)).unwrap();
|
||||
assert_eq!(back[0].value, Value::Hex("ABC0".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ascii_hex_cannot_inject_tags_and_is_split_at_254_digits() {
|
||||
let evil = Tag::new(310, Value::Hex("AB\r\n0\r\nEOF".into()));
|
||||
let text = write_ascii(&[evil, Tag::s(0, "EOF")]);
|
||||
let back = parse(text.as_bytes()).unwrap();
|
||||
assert_eq!(back.len(), 2, "{text:?}");
|
||||
assert_eq!(back[0].value, Value::Hex("AB0EF0".into()));
|
||||
let long = "AB".repeat(300);
|
||||
let back = parse(write_ascii(&[Tag::new(310, Value::Hex(long)), Tag::s(0, "EOF")]).as_bytes()).unwrap();
|
||||
let sizes: Vec<usize> = back.iter().filter(|t| t.code == 310).map(|t| t.str().len()).collect();
|
||||
assert_eq!(sizes, vec![254, 254, 92]);
|
||||
// An empty chunk is still one group.
|
||||
let back = parse(write_ascii(&[Tag::new(310, Value::Hex(String::new())), Tag::s(0, "EOF")]).as_bytes()).unwrap();
|
||||
assert_eq!(back[0].code, 310);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_sixteen_and_thirty_two_bit_values_wrap_in_range_and_clamp_outside() {
|
||||
let tags = [
|
||||
Tag::i(70, 65535),
|
||||
Tag::i(70, 40000),
|
||||
Tag::i(70, 70000),
|
||||
Tag::i(70, -40000),
|
||||
Tag::i(90, 0xFFFF_FFFF),
|
||||
Tag::i(90, 1 << 40),
|
||||
Tag::i(90, -(1 << 40)),
|
||||
Tag::s(0, "EOF"),
|
||||
];
|
||||
let back = parse(&write_binary(&tags, true)).unwrap();
|
||||
assert_eq!(back[0], Tag::i(70, -1));
|
||||
assert_eq!(back[1], Tag::i(70, 40000 - 65536));
|
||||
assert_eq!(back[2], Tag::i(70, i64::from(i16::MAX)));
|
||||
assert_eq!(back[3], Tag::i(70, i64::from(i16::MIN)));
|
||||
assert_eq!(back[4], Tag::i(90, -1));
|
||||
assert_eq!(back[5], Tag::i(90, i64::from(i32::MAX)));
|
||||
assert_eq!(back[6], Tag::i(90, i64::from(i32::MIN)));
|
||||
}
|
||||
|
||||
/// Strings of a `$DWGCODEPAGE`-declared file as ASCII text and as a binary file.
|
||||
fn both_forms(code_page: &str, strings: &[&[u8]]) -> [Vec<Tag>; 2] {
|
||||
let mut a = format!("9\n$DWGCODEPAGE\n3\n{code_page}\n").into_bytes();
|
||||
for s in strings {
|
||||
a.extend_from_slice(b"1\n");
|
||||
a.extend_from_slice(s);
|
||||
a.push(b'\n');
|
||||
}
|
||||
a.extend_from_slice(b"0\nEOF\n");
|
||||
let b = bin_with(|b| {
|
||||
for (code, s) in [(9i16, &b"$DWGCODEPAGE"[..]), (3, code_page.as_bytes())].into_iter().chain(strings.iter().map(|s| (1, *s))) {
|
||||
b.extend_from_slice(&code.to_le_bytes());
|
||||
b.extend_from_slice(s);
|
||||
b.push(0);
|
||||
}
|
||||
});
|
||||
[parse(&a).unwrap(), parse(&b).unwrap()]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn east_asian_short_strings_that_look_like_utf8_stay_in_the_code_page() {
|
||||
// C3 B1 is valid UTF-8 ("ñ") but is also two half-width katakana in Shift-JIS; the second
|
||||
// string is plainly Shift-JIS, so the file is not UTF-8.
|
||||
for t in both_forms("ANSI_932", &[b"\xC3\xB1", b"\x90\x7D\x96\xCA"]) {
|
||||
assert_eq!(t[2].str(), "\u{FF83}\u{FF71}");
|
||||
assert_eq!(t[3].str(), "図面");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn east_asian_file_that_is_all_utf8_reads_as_utf8() {
|
||||
for t in both_forms("ANSI_932", &["図面".as_bytes(), b"\xC3\xB1", b"plain"]) {
|
||||
assert_eq!(t[2].str(), "図面");
|
||||
assert_eq!(t[3].str(), "ñ");
|
||||
assert_eq!(t[4].str(), "plain");
|
||||
}
|
||||
}
|
||||
@@ -1,119 +0,0 @@
|
||||
//! Hex payload conformance is distinct from binary framing capacity: DXF groups 310–319 and
|
||||
//! 1004 specify at most 127 payload bytes per chunk, even though a length byte represents 255.
|
||||
//! Inspect writer bytes without our parser; accept any compliant partition preserving payload,
|
||||
//! code and following-record framing. Oversized binary read fixtures test tolerance only.
|
||||
//! Pending writer regressions extend the chunk-size finding in issue #1025.
|
||||
//! Public DXF Reference, Group Codes in Numerical Order and Binary DXF Files:
|
||||
//! https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-3F0380A5-1C15-464D-BC66-2C5F094BCFB9.htm
|
||||
//! https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-FC1C3C69-DBC2-49E4-893A-000D6538C0FE.htm
|
||||
|
||||
use cadcraft_dxf::{Tag, Value, parse, write_ascii_as, write_binary};
|
||||
|
||||
const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
|
||||
const FOLLOWING_BINARY: &[u8] = b"\x46\0\xf9\xff"; // group 70, signed i16 -7
|
||||
|
||||
fn payload(length: usize) -> Vec<u8> {
|
||||
(0..length).map(|index| u8::try_from(index * 37 % 256).unwrap()).collect()
|
||||
}
|
||||
|
||||
fn hex(bytes: &[u8]) -> String {
|
||||
bytes.iter().map(|byte| format!("{byte:02X}")).collect()
|
||||
}
|
||||
|
||||
fn input(code: i32, bytes: &[u8]) -> [Tag; 2] {
|
||||
[Tag::new(code, Value::Hex(hex(bytes))), Tag::i(70, -7)]
|
||||
}
|
||||
|
||||
fn check_ascii(code: i32, bytes: &[u8], utf8: bool) {
|
||||
let wire = write_ascii_as(&input(code, bytes), utf8);
|
||||
let lines: Vec<_> = wire.lines().collect();
|
||||
let (chunks, following) = lines.split_at(lines.len().checked_sub(2).unwrap());
|
||||
assert_eq!(following[0].trim(), "70");
|
||||
assert_eq!(following[1], "-7");
|
||||
assert!(!chunks.is_empty(), "an empty payload must still have a tag");
|
||||
let (records, remainder) = chunks.as_chunks::<2>();
|
||||
assert!(remainder.is_empty(), "incomplete group/value pair");
|
||||
let context = format!("ASCII code={code} bytes={} utf8={utf8}", bytes.len());
|
||||
let mut back = Vec::new();
|
||||
for record in records {
|
||||
assert_eq!(record[0].trim().parse::<i32>().unwrap(), code, "{context}");
|
||||
let text = record[1];
|
||||
assert!(text.len() <= 254, "{context}: {} hex characters exceed 127 payload bytes", text.len());
|
||||
assert!(text.bytes().all(|b| b.is_ascii_hexdigit()), "{context}: invalid hex");
|
||||
let (pairs, remainder) = text.as_bytes().as_chunks::<2>();
|
||||
assert!(remainder.is_empty(), "{context}: partial byte");
|
||||
back.extend(pairs.iter().map(|pair| u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap()));
|
||||
}
|
||||
assert_eq!(back, bytes, "{context}: complete payload and byte order");
|
||||
}
|
||||
|
||||
fn check_binary(code: i32, bytes: &[u8], utf8: bool) {
|
||||
let wire = write_binary(&input(code, bytes), utf8);
|
||||
let mut chunks = wire.strip_prefix(SENTINEL).unwrap().strip_suffix(FOLLOWING_BINARY).unwrap();
|
||||
assert!(!chunks.is_empty(), "an empty payload must still have a tag");
|
||||
let context = format!("binary code={code} bytes={} utf8={utf8}", bytes.len());
|
||||
let mut back = Vec::new();
|
||||
while !chunks.is_empty() {
|
||||
let (&[lo, hi, length], rest) = chunks.split_first_chunk::<3>().unwrap();
|
||||
assert_eq!(i32::from(u16::from_le_bytes([lo, hi])), code, "{context}");
|
||||
assert!(length <= 127, "{context}: {length} bytes exceed the documented group limit");
|
||||
let (chunk, next) = rest.split_at(usize::from(length));
|
||||
back.extend_from_slice(chunk);
|
||||
chunks = next;
|
||||
}
|
||||
assert_eq!(back, bytes, "{context}: complete payload and byte order");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn conforming_payloads_have_independent_ascii_and_binary_wire_checks() {
|
||||
for code in (310..=319).chain([1004]) {
|
||||
for length in [0, 1, 2, 126, 127] {
|
||||
for utf8 in [false, true] {
|
||||
let bytes = payload(length);
|
||||
check_ascii(code, &bytes, utf8);
|
||||
check_binary(code, &bytes, utf8);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binary_reader_tolerates_the_full_length_byte_domain() {
|
||||
// This is deliberately permissive input, not an assertion that oversized chunks conform
|
||||
// or that the writer should produce them. The following record catches framing mistakes.
|
||||
for code in (310_u16..=319).chain([1004]) {
|
||||
for length in 0..=u8::MAX {
|
||||
let bytes = payload(usize::from(length));
|
||||
let mut wire = SENTINEL.to_vec();
|
||||
wire.extend_from_slice(&code.to_le_bytes());
|
||||
wire.push(length);
|
||||
wire.extend_from_slice(&bytes);
|
||||
wire.extend_from_slice(FOLLOWING_BINARY);
|
||||
assert_eq!(parse(&wire).unwrap(), input(i32::from(code), &bytes), "code={code} length={length}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "Confirmed ASCII DXF writer nonconformance: hex payloads above 127 bytes are emitted as one oversized chunk"]
|
||||
fn ascii_writer_splits_large_payloads_into_conforming_chunks() {
|
||||
for code in (310..=319).chain([1004]) {
|
||||
for length in [128, 254, 255, 256, 1024] {
|
||||
for utf8 in [false, true] {
|
||||
check_ascii(code, &payload(length), utf8);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "Confirmed binary DXF writer nonconformance: 255-byte partitioning exceeds the documented 127-byte group limit"]
|
||||
fn binary_writer_splits_large_payloads_into_conforming_chunks() {
|
||||
for code in (310..=319).chain([1004]) {
|
||||
for length in [128, 254, 255, 256, 1024] {
|
||||
for utf8 in [false, true] {
|
||||
check_binary(code, &payload(length), utf8);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,148 +0,0 @@
|
||||
//! Deterministic tag preservation through the public byte API, in both encodings and every
|
||||
//! supported version. Inputs have the group code's type and representable values; lossy
|
||||
//! coercions are not accepted as round-trip equality. Real values must retain their bits.
|
||||
|
||||
use cadcraft_dxf::{Tag, Value, Version, is_binary, parse, write_ascii_as, write_binary};
|
||||
|
||||
fn check(case: &str, body: &[Tag]) {
|
||||
for version in Version::ALL {
|
||||
let mut original = vec![
|
||||
Tag::s(0, "SECTION"),
|
||||
Tag::s(2, "HEADER"),
|
||||
Tag::s(9, "$ACADVER"),
|
||||
Tag::s(1, version.code()),
|
||||
Tag::s(9, "$DWGCODEPAGE"),
|
||||
Tag::s(3, "ANSI_1252"),
|
||||
Tag::s(0, "ENDSEC"),
|
||||
Tag::s(0, "SECTION"),
|
||||
Tag::s(2, "ENTITIES"),
|
||||
];
|
||||
original.extend_from_slice(body);
|
||||
original.extend([Tag::s(0, "ENDSEC"), Tag::s(0, "EOF")]);
|
||||
for binary in [false, true] {
|
||||
let mut current = original.clone();
|
||||
for pass in 1..=2 {
|
||||
let context = format!("{case} · {version} · binary={binary} · pass={pass}");
|
||||
let bytes = if binary { write_binary(¤t, version.utf8()) } else { write_ascii_as(¤t, version.utf8()).into_bytes() };
|
||||
assert_eq!(is_binary(&bytes), binary, "{context}");
|
||||
let back = parse(&bytes).unwrap_or_else(|e| panic!("{context}: {e}"));
|
||||
assert_eq!(back.len(), original.len(), "{context}: tag count");
|
||||
for (index, (expected, actual)) in original.iter().zip(&back).enumerate() {
|
||||
assert_eq!(actual, expected, "{context}: tag[{index}]");
|
||||
if let (Value::Real(a), Value::Real(b)) = (&expected.value, &actual.value) {
|
||||
assert_eq!(b.to_bits(), a.to_bits(), "{context}: tag[{index}] real bits");
|
||||
}
|
||||
}
|
||||
assert_eq!(back, current, "{context}: no additional changes on resave");
|
||||
current = back;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn integer_width_boundaries() {
|
||||
// Explicit reference ranges, not obtained from the codec's kind_of().
|
||||
let widths = [
|
||||
(vec![60..=79, 170..=179, 270..=289, 370..=389, 400..=409, 1060..=1070], i64::from(i16::MIN), i64::from(i16::MAX)),
|
||||
(vec![90..=99, 420..=429, 440..=459, 1071..=1071], i64::from(i32::MIN), i64::from(i32::MAX)),
|
||||
(std::iter::once(160..=169).collect(), i64::MIN, i64::MAX),
|
||||
];
|
||||
for (ranges, min, max) in widths {
|
||||
for value in [min, min + 1, -1, 0, 1, max - 1, max] {
|
||||
let tags: Vec<_> = ranges.iter().cloned().flatten().map(|code| Tag::i(code, value)).collect();
|
||||
check(&format!("integer/{min}..{max}/{value}"), &tags);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finite_reals_keep_all_bits() {
|
||||
let values = [
|
||||
0.0,
|
||||
-0.0,
|
||||
f64::from_bits(1),
|
||||
-f64::from_bits(1),
|
||||
f64::MIN_POSITIVE,
|
||||
f64::MIN_POSITIVE.next_down(),
|
||||
0.1,
|
||||
-3.25,
|
||||
1.0_f64.next_down(),
|
||||
1.0,
|
||||
1.0_f64.next_up(),
|
||||
1e-100,
|
||||
-1e100,
|
||||
f64::MAX,
|
||||
f64::MIN,
|
||||
];
|
||||
for value in values {
|
||||
let tags: Vec<_> =
|
||||
[10..=59, 110..=149, 210..=239, 460..=469, 1010..=1059].into_iter().flatten().map(|code| Tag::new(code, Value::Real(value))).collect();
|
||||
check(&format!("real/{:016X}", value.to_bits()), &tags);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn booleans() {
|
||||
for value in [false, true] {
|
||||
let tags: Vec<_> = (290..=299).map(|code| Tag::new(code, Value::Bool(value))).collect();
|
||||
check(&format!("bool/{value}"), &tags);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn strings_preserve_whitespace_unicode_and_literal_escapes() {
|
||||
// No CR/LF or NUL: those are line/string delimiters, not losslessly writable payloads.
|
||||
let values = [
|
||||
("empty", ""),
|
||||
("spaces", " leading and trailing "),
|
||||
("tabs", "\tindented\t"),
|
||||
("unicode", "Café Ø 图号 Україна 😀 e\u{301}"),
|
||||
("literal-escapes", r"\U+0041 \M+183A4 \U+D83D\U+DE00 \\U+005C \P %%c"),
|
||||
("malformed-escapes", r"\U+ \U+ZZZZ \U+D800 \U+DC00 \M+9FFFF"),
|
||||
];
|
||||
for (case, value) in values {
|
||||
let tags: Vec<_> =
|
||||
[0..=9, 100..=100, 102..=102, 105..=105, 300..=309, 320..=369, 410..=419, 430..=439, 470..=479, 480..=481, 1000..=1003, 1005..=1005]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|code| Tag::s(code, value))
|
||||
.collect();
|
||||
check(case, &tags);
|
||||
}
|
||||
for length in [1, 254, 255, 256, 1024] {
|
||||
check(&format!("string/length={length}"), &[Tag::s(1, "x".repeat(length))]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hex_chunks_keep_bytes_and_order() {
|
||||
// DXF groups 310–319 and 1004 permit 127 payload bytes per chunk. A binary length
|
||||
// byte can represent more, but that is reader tolerance, not writer conformance.
|
||||
// Larger payloads need chunk-size/reassembly checks rather than exact tag equality;
|
||||
// see hex_chunks.rs for the independent wire checks and pending writer regressions.
|
||||
for length in [0, 1, 2, 126, 127] {
|
||||
let hex: String = (0..length).map(|i| format!("{:02X}", (i * 37) % 256)).collect();
|
||||
let tags: Vec<_> = (310..=319).chain([1004]).map(|code| Tag::new(code, Value::Hex(hex.clone()))).collect();
|
||||
check(&format!("hex/bytes={length}"), &tags);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mixed_values_and_repeated_codes_keep_order() {
|
||||
check(
|
||||
"mixed/repeated-codes",
|
||||
&[
|
||||
Tag::s(0, "TEST"),
|
||||
Tag::f(10, 1.25),
|
||||
Tag::s(1, "first"),
|
||||
Tag::f(10, -2.5),
|
||||
Tag::i(70, -7),
|
||||
Tag::s(1, "second"),
|
||||
Tag::new(290, Value::Bool(true)),
|
||||
Tag::new(310, Value::Hex("00FF80".into())),
|
||||
Tag::i(160, i64::MAX),
|
||||
Tag::s(1, ""),
|
||||
],
|
||||
);
|
||||
}
|
||||
@@ -12,7 +12,8 @@ workspace = true
|
||||
cadcraft-geom = { workspace = true }
|
||||
cadcraft-color = { workspace = true }
|
||||
cadcraft-doc = { workspace = true }
|
||||
cadcraft-dxf = { workspace = true }
|
||||
craft-mime = { workspace = true }
|
||||
craft-dxf = { workspace = true }
|
||||
cadcraft-constraints = { workspace = true }
|
||||
cadcraft-fonts = { workspace = true }
|
||||
cadcraft-render = { workspace = true }
|
||||
|
||||
@@ -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;
|
||||
@@ -47,6 +51,7 @@ mod tolerance;
|
||||
mod trimextend;
|
||||
mod txt2mtxt;
|
||||
pub use txt2mtxt::Txt2MtxtOptions;
|
||||
mod ucs;
|
||||
mod utility;
|
||||
mod view;
|
||||
|
||||
@@ -183,9 +188,12 @@ pub fn command_specs() -> &'static [CommandSpec] {
|
||||
v.extend(qselect::specs());
|
||||
v.extend(selecttools::specs());
|
||||
v.extend(view::specs());
|
||||
v.extend(ucs::specs());
|
||||
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());
|
||||
|
||||
@@ -35,8 +35,15 @@ fn auto_rotation(p1: Vec2, p2: Vec2, at: Vec2) -> f64 {
|
||||
if outside_x && !outside_y { std::f64::consts::FRAC_PI_2 } else { 0.0 }
|
||||
}
|
||||
|
||||
pub(super) fn linear_kind(p1: Vec2, p2: Vec2, at: Vec2, rotation: Option<f64>, aligned: bool) -> DimKind {
|
||||
if aligned { DimKind::Aligned } else { DimKind::Linear { rotation: rotation.unwrap_or_else(|| auto_rotation(p1, p2, at)) } }
|
||||
/// A linear or aligned dimension's kind; without a rotation, horizontal or vertical along axes turned
|
||||
/// `ucs` radians (the current UCS's at the command line; the world's for JSON).
|
||||
pub(super) fn linear_kind(p1: Vec2, p2: Vec2, at: Vec2, rotation: Option<f64>, aligned: bool, ucs: f64) -> DimKind {
|
||||
if aligned {
|
||||
return DimKind::Aligned;
|
||||
}
|
||||
let ucs = if ucs.is_finite() { ucs } else { 0.0 };
|
||||
let auto = || auto_rotation(p1.rotate(-ucs), p2.rotate(-ucs), at.rotate(-ucs)) + ucs;
|
||||
DimKind::Linear { rotation: rotation.unwrap_or_else(auto) }
|
||||
}
|
||||
|
||||
/// Add a dimension. With DIMASSOC on, definition points that sit on object endpoints,
|
||||
|
||||
@@ -11,7 +11,7 @@ pub(super) fn run_linear(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
};
|
||||
let at = point_req("dimlinear", p, "at")?;
|
||||
let rot = p.get("rotation").and_then(Value::as_f64).map(f64::to_radians);
|
||||
let k = dim(s, linear_kind(a, b, at, rot, false), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
|
||||
let k = dim(s, linear_kind(a, b, at, rot, false, 0.0), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
|
||||
Ok(json!({ "handle": add_dim(s, k)?.hex() }))
|
||||
}
|
||||
|
||||
@@ -216,7 +216,8 @@ impl Interactive for LinearM {
|
||||
}
|
||||
(_, Input::Point(at)) => {
|
||||
let (Some(&a), Some(&b)) = (self.pts.first(), self.pts.get(1)) else { return Ok(Step::Continue) };
|
||||
let k = self.text.apply(dim(s, linear_kind(a, b, at, self.rotation, self.aligned), at, a, b, Vec2::ZERO, ""));
|
||||
let k =
|
||||
self.text.apply(dim(s, linear_kind(a, b, at, self.rotation, self.aligned, s.input_ucs().rotation()), at, a, b, Vec2::ZERO, ""));
|
||||
add_dim(s, k)?;
|
||||
if let Some(EntityKind::Dimension(d)) = s.last_dim.and_then(|h| s.doc().ok()?.entity(h).map(|e| e.kind.clone())) {
|
||||
let st = s.doc()?.dim_style(&d.style).cloned().unwrap_or_default();
|
||||
@@ -227,8 +228,8 @@ impl Interactive for LinearM {
|
||||
}
|
||||
(_, Input::Keyword(k)) => {
|
||||
match k.as_str() {
|
||||
"Horizontal" => self.rotation = Some(0.0),
|
||||
"Vertical" => self.rotation = Some(std::f64::consts::FRAC_PI_2),
|
||||
"Horizontal" => self.rotation = Some(s.input_ucs().rotation()),
|
||||
"Vertical" => self.rotation = Some(s.input_ucs().rotation() + std::f64::consts::FRAC_PI_2),
|
||||
"Rotated" => self.rotating = true,
|
||||
other => {
|
||||
self.text.keyword(other);
|
||||
@@ -243,7 +244,15 @@ impl Interactive for LinearM {
|
||||
fn preview(&self, s: &Session, c: Vec2) -> Vec<EntityKind> {
|
||||
match self.pts.as_slice() {
|
||||
[a] => vec![crate::cmd::helpers::line(*a, c)],
|
||||
[a, b] => vec![self.text.apply(dim(s, linear_kind(*a, *b, c, self.rotation, self.aligned), c, *a, *b, Vec2::ZERO, ""))],
|
||||
[a, b] => vec![self.text.apply(dim(
|
||||
s,
|
||||
linear_kind(*a, *b, c, self.rotation, self.aligned, s.input_ucs().rotation()),
|
||||
c,
|
||||
*a,
|
||||
*b,
|
||||
Vec2::ZERO,
|
||||
"",
|
||||
))],
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
+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);
|
||||
|
||||
@@ -15,7 +15,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
|
||||
|
||||
pub(super) fn blockreplace_spec() -> CommandSpec {
|
||||
CommandSpec::new("blockreplace", "Replace Block...", run_blockreplace)
|
||||
.menu(&["Tools", "Express Tools", "Replace Block..."])
|
||||
.menu(&["Tools", "Additional Tools", "Replace Block..."])
|
||||
.alias(&["-blockreplace"])
|
||||
.params("{block (the block whose references are replaced), with (the replacement block), purge?: bool (default false: remove the replaced block's definition when nothing references it any more)} → {block, with, replaced, purged}")
|
||||
.interactive(|_| Ok(Box::new(BlockreplaceM::default())))
|
||||
@@ -184,8 +184,10 @@ impl Interactive for BlockreplaceM {
|
||||
}
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
match self.stage {
|
||||
Stage::Old => Prompt::new("Enter the name of the block to replace", Accept::TEXT).kw(&["?", "Select"]),
|
||||
Stage::New => Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]),
|
||||
Stage::Old => Prompt::new("Enter the name of the block to replace", Accept::TEXT).kw(&["?", "Select"]).takes_block(),
|
||||
Stage::New => {
|
||||
Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]).takes_block()
|
||||
}
|
||||
Stage::Select => Prompt::new("Select a block reference", Accept::SELECT),
|
||||
Stage::Purge => Prompt::new(format!("Purge the unreferenced block definition {}?", self.old), KW).kw(&["Yes", "No"]).default("Yes"),
|
||||
}
|
||||
|
||||
@@ -12,7 +12,7 @@ use crate::{Result, Session};
|
||||
|
||||
pub(super) fn burst_spec() -> CommandSpec {
|
||||
CommandSpec::new("burst", "Explode Attributes to Text", run_burst)
|
||||
.menu(&["Tools", "Express Tools", "Explode Attributes to Text"])
|
||||
.menu(&["Tools", "Additional Tools", "Explode Attributes to Text"])
|
||||
.params("{handles?} (block references; other objects are left alone) → {handles}")
|
||||
.interactive(|_| Ok(Box::new(SelectRun::new("burst", "BURST"))))
|
||||
}
|
||||
|
||||
@@ -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"]),
|
||||
|
||||
@@ -20,7 +20,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("breakline", "Break-line Symbol", run_breakline)
|
||||
.menu(&["Tools", "Express Tools", "Break-line Symbol"])
|
||||
.menu(&["Tools", "Additional Tools", "Break-line Symbol"])
|
||||
.params(
|
||||
"{p1, p2, at?: [x,y] (symbol location; default the midpoint), size? (default 1, times DIMSCALE), \
|
||||
extension? (past both points; default 0), block? (a block with two points on Defpoints; default the built-in symbol)} → {handle}",
|
||||
|
||||
@@ -557,9 +557,15 @@ fn run_clear(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
fn run_selectall(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
let space = s.space();
|
||||
let d = s.doc()?;
|
||||
let frozen = s.viewport_frozen();
|
||||
let hs: Vec<Handle> = d
|
||||
.space(&space)
|
||||
.map(|st| st.iter().filter(|e| d.is_visible(e) && d.layer(&e.common.layer).is_none_or(|l| !l.locked)).map(|e| e.handle).collect())
|
||||
.map(|st| {
|
||||
st.iter()
|
||||
.filter(|e| crate::select::selectable(d, e, frozen) && d.layer(&e.common.layer).is_none_or(|l| !l.locked))
|
||||
.map(|e| e.handle)
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let n = hs.len();
|
||||
s.set_selection(hs);
|
||||
@@ -580,16 +586,19 @@ fn run_select(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let add = bool_or(p, "add", false);
|
||||
let picked: Vec<Handle> = if let Some(w) = points_param(p, "window") {
|
||||
let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("select", "window needs 2 corners")) };
|
||||
crate::select::select_window(s.doc()?, &space, Bounds2::new(*a, *b), bool_or(p, "crossing", false))
|
||||
crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), Bounds2::new(*a, *b), bool_or(p, "crossing", false))
|
||||
} else if let Some(at) = point_param(p, "at") {
|
||||
let ap = f64_or(p, "aperture", s.pixel_size() * s.settings.pickbox * 1.5);
|
||||
crate::select::pick(s.doc()?, &space, at, ap).into_iter().collect()
|
||||
crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), at, ap).into_iter().collect()
|
||||
} else if let Some(f) = points_param(p, "fence") {
|
||||
crate::select::select_fence(s.doc()?, &space, &f)
|
||||
} else {
|
||||
crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &f)
|
||||
} else if ["handles", "handle"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null())) {
|
||||
targets(s, p)?
|
||||
} else {
|
||||
// Nothing to select with: the selection stays, also what the active viewport does not draw.
|
||||
s.stored_selection()
|
||||
};
|
||||
let mut sel = if add { s.selection() } else { Vec::new() };
|
||||
let mut sel = if add { s.stored_selection() } else { Vec::new() };
|
||||
sel.extend(picked);
|
||||
s.set_selection(sel);
|
||||
let sel = s.selection();
|
||||
|
||||
@@ -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 }))
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@ mod template;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
use cadcraft_doc::{Drawing, Format};
|
||||
pub use cadcraft_dxf::Version;
|
||||
pub use craft_dxf::Version;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::{CommandSpec, EngineError, Interactive, always, bad, bool_or, find_command, ok, str_param};
|
||||
@@ -17,7 +17,7 @@ use crate::{Accept, Input, Prompt, Result, Session, Step};
|
||||
|
||||
/// The rules the Command Aliases dialog checks before it sends an alias to ALIASEDIT.
|
||||
pub use pgp::{MAX_ALIAS_PROFILE_BYTES, MAX_ALIASES, alias_name, alias_profile, command_id, restore_aliases};
|
||||
pub(crate) use pgp::{specs as alias_specs, user_alias};
|
||||
pub(crate) use pgp::{greek_alias, specs as alias_specs, user_alias};
|
||||
pub use template::{qnew_template, set_qnew_template};
|
||||
|
||||
/// Largest drawing accepted from a local path, matching the per-file xref limit. A path naming an
|
||||
@@ -53,9 +53,9 @@ pub fn io() -> Option<&'static IoHooks> {
|
||||
/// (installed by the app with the DXF reader and writer, a lower layer).
|
||||
pub struct EntityCodec {
|
||||
/// The entity's type name and the groups of its record, without its `0` group.
|
||||
pub groups: fn(&Drawing, &cadcraft_doc::Entity) -> (String, Vec<cadcraft_dxf::Tag>),
|
||||
pub groups: fn(&Drawing, &cadcraft_doc::Entity) -> (String, Vec<craft_dxf::Tag>),
|
||||
/// An entity from a type name and groups.
|
||||
pub entity: fn(&str, &[cadcraft_dxf::Tag]) -> Option<(cadcraft_doc::Common, cadcraft_doc::EntityKind)>,
|
||||
pub entity: fn(&str, &[craft_dxf::Tag]) -> Option<(cadcraft_doc::Common, cadcraft_doc::EntityKind)>,
|
||||
}
|
||||
|
||||
static CODEC: OnceLock<EntityCodec> = OnceLock::new();
|
||||
@@ -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;
|
||||
|
||||
@@ -340,7 +356,7 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
|
||||
let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
|
||||
cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
|
||||
}
|
||||
Ok(ReadFile { drawing, binary_dxf: cadcraft_dxf::is_binary(bytes), name: name.to_string(), path })
|
||||
Ok(ReadFile { drawing, binary_dxf: craft_dxf::is_binary(bytes), name: name.to_string(), path })
|
||||
}
|
||||
|
||||
fn add_read(s: &mut Session, drawing: Drawing, binary_dxf: bool, name: &str, path: Option<String>) -> usize {
|
||||
@@ -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()
|
||||
@@ -503,7 +521,7 @@ pub fn backup_path(path: &std::path::Path) -> std::path::PathBuf {
|
||||
pub fn looks_like_drawing(bytes: &[u8]) -> bool {
|
||||
// DWG: a version tag like `AC1032` (R12 is `AC1009`).
|
||||
let dwg = bytes.len() >= 6 && bytes.starts_with(b"AC") && bytes[2..6].iter().all(|b| b.is_ascii_digit());
|
||||
if dwg || cadcraft_dxf::is_binary(bytes) {
|
||||
if dwg || craft_dxf::is_binary(bytes) {
|
||||
return true;
|
||||
}
|
||||
// ASCII DXF: optional comments (999), then group 0 SECTION.
|
||||
@@ -533,7 +551,7 @@ pub fn completeness(head: &[u8], tail: &[u8], len: u64) -> Option<bool> {
|
||||
// Too short for any DWG's header: cut off, not unknown.
|
||||
return if head.len() < 256 { Some(false) } else { dwg_complete(head, len) };
|
||||
}
|
||||
if cadcraft_dxf::is_binary(head) {
|
||||
if craft_dxf::is_binary(head) {
|
||||
return Some(tail.ends_with(b"EOF\0"));
|
||||
}
|
||||
let text = String::from_utf8_lossy(tail);
|
||||
@@ -1020,46 +1038,14 @@ fn run_saveas_reporting(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
save_reporting(s, p, run_saveas, asked)
|
||||
}
|
||||
|
||||
const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
/// Encode bytes with the standard padded Base64 alphabet.
|
||||
pub fn base64_encode(data: &[u8]) -> String {
|
||||
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
|
||||
for chunk in data.chunks(3) {
|
||||
let b = [chunk.first().copied().unwrap_or(0), chunk.get(1).copied().unwrap_or(0), chunk.get(2).copied().unwrap_or(0)];
|
||||
let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
|
||||
for i in 0..4 {
|
||||
if i <= chunk.len() {
|
||||
out.push(char::from(B64[((n >> (18 - 6 * i)) & 63) as usize]));
|
||||
} else {
|
||||
out.push('=');
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
craft_mime::base64::STANDARD.encode(data)
|
||||
}
|
||||
|
||||
/// Decode the legacy file/control Base64 form, retaining its permissive alphabet and padding.
|
||||
pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
|
||||
let mut out = Vec::with_capacity(s.len() * 3 / 4);
|
||||
let mut buf = 0u32;
|
||||
let mut bits = 0;
|
||||
for c in s.bytes() {
|
||||
let v = match c {
|
||||
b'A'..=b'Z' => c - b'A',
|
||||
b'a'..=b'z' => c - b'a' + 26,
|
||||
b'0'..=b'9' => c - b'0' + 52,
|
||||
b'+' | b'-' => 62,
|
||||
b'/' | b'_' => 63,
|
||||
b'=' | b'\n' | b'\r' | b' ' => continue,
|
||||
_ => return None,
|
||||
};
|
||||
buf = (buf << 6) | u32::from(v);
|
||||
bits += 6;
|
||||
if bits >= 8 {
|
||||
bits -= 8;
|
||||
out.push(((buf >> bits) & 0xff) as u8);
|
||||
}
|
||||
}
|
||||
Some(out)
|
||||
craft_mime::base64_compat::decode(s).ok()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -59,6 +59,12 @@ pub(crate) fn user_alias(name: &str) -> Option<String> {
|
||||
store().map.get(name).cloned()
|
||||
}
|
||||
|
||||
/// The user alias that is the Greek word `word` in another case or accent.
|
||||
pub(crate) fn greek_alias(word: &str) -> Option<String> {
|
||||
let same = crate::keyboard::same_greek_word_as(word)?;
|
||||
store().map.keys().find(|alias| same(alias)).cloned()
|
||||
}
|
||||
|
||||
/// The user aliases and the file REINIT reads, as the host's user profile keeps them:
|
||||
/// `{"aliases": {alias: command}, "file": path or null}`. Not drawing data.
|
||||
pub fn alias_profile() -> Value {
|
||||
|
||||
@@ -43,7 +43,8 @@ pub(crate) struct GripEdit {
|
||||
hot: Vec<(Handle, usize)>,
|
||||
/// Typed `GRIP`: still collecting grips ("Select grips").
|
||||
picking: bool,
|
||||
/// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the selection.
|
||||
/// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the objects of the
|
||||
/// selection that the view being edited shows.
|
||||
targets: Vec<Handle>,
|
||||
base: Vec2,
|
||||
mode: GripMode,
|
||||
@@ -69,6 +70,13 @@ fn positive(v: Option<f64>) -> Result<f64> {
|
||||
v.filter(|f| f.is_finite() && *f > 1e-12).ok_or_else(|| other("Requires a positive number."))
|
||||
}
|
||||
|
||||
/// Whether the view being edited shows `h`. A hidden object (HIDEOBJECTS, an off or frozen layer,
|
||||
/// a layer frozen in the active MSPACE viewport) takes no part in a grip edit, even when Undo or
|
||||
/// a selection command put it back into the selection.
|
||||
fn shown(s: &Session, h: Handle) -> bool {
|
||||
s.state().is_ok_and(|st| st.doc.entity(h).is_some_and(|e| st.shows(e)))
|
||||
}
|
||||
|
||||
impl GripEdit {
|
||||
fn new(s: &Session, hot: Vec<(Handle, usize)>) -> Result<Self> {
|
||||
let mut g = GripEdit {
|
||||
@@ -87,16 +95,22 @@ impl GripEdit {
|
||||
Ok(g)
|
||||
}
|
||||
|
||||
/// Make grip `index` of `h` hot (the first one becomes the base point).
|
||||
/// Make grip `index` of `h` hot (the first one becomes the base point). The grip of an object
|
||||
/// the view being edited does not show is left out, and so are the hidden objects of the
|
||||
/// selection.
|
||||
fn add_hot(&mut self, s: &Session, (h, i): (Handle, usize)) -> Result<()> {
|
||||
if self.hot.contains(&(h, i)) || self.hot.len() >= MAX_HOT {
|
||||
return Ok(());
|
||||
}
|
||||
let p = s.grips_of(h)?.get(i).copied().ok_or_else(|| other("no such grip"))?;
|
||||
// After the lookup: a missing object or grip stays the error it was.
|
||||
if !shown(s, h) {
|
||||
return Ok(());
|
||||
}
|
||||
if self.hot.is_empty() {
|
||||
self.base = p;
|
||||
self.targets.push(h);
|
||||
self.targets.extend(s.selection().into_iter().filter(|x| *x != h));
|
||||
self.targets.extend(s.selection().into_iter().filter(|x| *x != h && shown(s, *x)));
|
||||
} else if !self.targets.contains(&h) {
|
||||
self.targets.push(h);
|
||||
}
|
||||
@@ -107,13 +121,13 @@ impl GripEdit {
|
||||
/// The grips of the selected objects at `p` (typed `GRIP`): all objects with a grip there.
|
||||
fn grips_at(s: &Session, p: Vec2) -> Vec<(Handle, usize)> {
|
||||
let tol = (s.pixel_size() * (s.settings.gripsize + 3.0)).max(1e-9 * (1.0 + p.len()));
|
||||
let Ok(d) = s.doc() else { return Vec::new() };
|
||||
let Ok(st) = s.state() else { return Vec::new() };
|
||||
let mut out = Vec::new();
|
||||
for h in s.selection().into_iter().take(MAX_HOT) {
|
||||
if super::curves::is_locked(s, h) {
|
||||
continue;
|
||||
}
|
||||
let Some(e) = d.entity(h) else { continue };
|
||||
let Some(e) = st.doc.entity(h).filter(|e| st.shows(e)) else { continue };
|
||||
let gs = e.kind.grips();
|
||||
// The nearest grip of this object within the tolerance.
|
||||
let best = gs
|
||||
@@ -470,7 +484,9 @@ impl Interactive for GripEdit {
|
||||
impl Session {
|
||||
/// Make grips hot and start editing them (the UI's click on a grip; Shift+click collects
|
||||
/// several first). `hot` lists (object, grip index); the first is the base grip. The grip
|
||||
/// modes and their options then run at the command line like any prompt.
|
||||
/// modes and their options then run at the command line like any prompt. Grips of objects the
|
||||
/// view being edited does not show are left out (the first grip left is the base grip), and it
|
||||
/// is an error when none is left.
|
||||
pub fn start_grip_edit(&mut self, hot: &[(Handle, usize)]) -> Result<()> {
|
||||
if self.running.is_some() {
|
||||
self.cancel();
|
||||
@@ -479,6 +495,9 @@ impl Session {
|
||||
return Err(other("no grip"));
|
||||
}
|
||||
let g = GripEdit::new(self, hot.to_vec())?;
|
||||
if g.hot.is_empty() {
|
||||
return Err(other("no grip"));
|
||||
}
|
||||
let label = g.label();
|
||||
let machine = crate::guard::Guarded::wrap(Box::new(g));
|
||||
let st = self.state()?;
|
||||
|
||||
@@ -28,7 +28,8 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
const MEMBER_PICKS: &[&str] = &["groupedit", "-group"];
|
||||
|
||||
/// `hs` plus the other members of the selectable groups they belong to (in the space being
|
||||
/// edited, visible), when PICKSTYLE has group selection on. Order: `hs` first.
|
||||
/// edited, visible, and inside an MSPACE viewport not on a layer frozen in it), when PICKSTYLE
|
||||
/// has group selection on. Order: `hs` first.
|
||||
pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
|
||||
if s.settings.pickstyle & 1 == 0 || hs.is_empty() || s.running.as_ref().is_some_and(|r| MEMBER_PICKS.contains(&r.id.as_str())) {
|
||||
return hs;
|
||||
@@ -39,6 +40,7 @@ pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
|
||||
}
|
||||
let space = s.space();
|
||||
let Some(store) = d.space(&space) else { return hs };
|
||||
let frozen = s.viewport_frozen();
|
||||
// Member → its selectable groups, built once (window selections may hold many objects).
|
||||
let mut of: HashMap<Handle, Vec<usize>> = HashMap::new();
|
||||
for (i, g) in d.groups.iter().enumerate().filter(|(_, g)| g.selectable) {
|
||||
@@ -56,7 +58,7 @@ pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
|
||||
}
|
||||
let Some(g) = d.groups.get(*gi) else { continue };
|
||||
for m in &g.members {
|
||||
if store.get(*m).is_some_and(|e| d.is_visible(e)) && seen.insert(*m) {
|
||||
if store.get(*m).is_some_and(|e| crate::select::selectable(d, e, frozen)) && seen.insert(*m) {
|
||||
out.push(*m);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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")
|
||||
@@ -533,6 +540,19 @@ fn run_region(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "message": format!("{n} Region(s) created.") }))
|
||||
}
|
||||
|
||||
/// Whether the upper-case `name` is a pattern: a standard one or a loaded one.
|
||||
fn pattern_exists(name: &str) -> bool {
|
||||
cadcraft_doc::library::pattern(name).is_some() || patfile::user_pattern(name).is_some()
|
||||
}
|
||||
|
||||
/// The existing pattern `name` means, typed at the pattern prompt: read upper-cased, else a loaded
|
||||
/// pattern's own name when only its Greek spelling differs in case or accent (σολιδ for ΣΟΛΙΔ).
|
||||
pub(crate) fn pattern_named(name: &str) -> Option<String> {
|
||||
let name = name.trim();
|
||||
let up = name.to_ascii_uppercase();
|
||||
if pattern_exists(&up) { Some(up) } else { patfile::user_pattern_name(name) }
|
||||
}
|
||||
|
||||
/// The origin sub-prompt's keywords (a point sets a new origin).
|
||||
const ORIGIN_KW: [&str; 6] = ["Bottom left", "bottom Right", "Top left", "top riGht", "Center", "Use current"];
|
||||
|
||||
@@ -597,7 +617,7 @@ impl HatchM {
|
||||
Some(n) => n,
|
||||
None => t.trim().to_ascii_uppercase(),
|
||||
};
|
||||
if cadcraft_doc::library::pattern(&up).is_some() || patfile::user_pattern(&up).is_some() {
|
||||
if pattern_exists(&up) {
|
||||
self.settings.pattern = up.clone();
|
||||
s.doc_mut()?.header.set_str("HPNAME", &up);
|
||||
} else {
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -28,6 +28,13 @@ pub(crate) fn user_pattern(name: &str) -> Option<UserPattern> {
|
||||
store().iter().find(|p| p.name.eq_ignore_ascii_case(name)).cloned()
|
||||
}
|
||||
|
||||
/// The name of the user pattern that is the Greek word `name` in another case or accent
|
||||
/// ([`user_pattern`] folds ASCII only).
|
||||
pub(crate) fn user_pattern_name(name: &str) -> Option<String> {
|
||||
let same = crate::keyboard::same_greek_word_as(name)?;
|
||||
store().iter().find(|p| same(&p.name)).map(|p| p.name.clone())
|
||||
}
|
||||
|
||||
/// The line families a new hatch of pattern `name` carries: a user pattern's, else none (the
|
||||
/// library's patterns are drawn and saved from the library).
|
||||
pub(crate) fn lines_for(name: &str) -> Vec<PatternLine> {
|
||||
|
||||
@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("dist", "Distance", run_dist)
|
||||
.menu(&["Tools", "Inquiry", "Distance"])
|
||||
.alias(&["di"])
|
||||
.params("{p1, p2}")
|
||||
.params("{p1, p2} -> {distance, angle, angleFromXY, dx, dy, dz (world), ucs: {angle, angleFromXY, dx, dy, dz} (in the frame typed points are read in: the current UCS, or the World UCS while the UCS is tilted; as the message), message}")
|
||||
.noundo()
|
||||
.transparent()
|
||||
.interactive(|_| Ok(Box::new(DistM::default()))),
|
||||
@@ -192,11 +192,18 @@ fn angle_from_xy(d: Vec3) -> f64 {
|
||||
d.z.atan2(d.xy().len())
|
||||
}
|
||||
|
||||
fn dist_text(s: &Session, a: Vec3, b: Vec3) -> String {
|
||||
let d = b - a;
|
||||
/// The delta from `a` to `b` along the axes of the current UCS (the World UCS while that is
|
||||
/// tilted): what DIST's report shows.
|
||||
fn dist_delta(s: &Session, a: Vec3, b: Vec3) -> Vec3 {
|
||||
let u = s.input_ucs();
|
||||
u.to_ucs3(b) - u.to_ucs3(a)
|
||||
}
|
||||
|
||||
/// DIST's report: the distance, the angles and the deltas `d`, measured in the current UCS.
|
||||
fn dist_text(s: &Session, dist: f64, d: Vec3) -> String {
|
||||
format!(
|
||||
"Distance = {}, Angle in XY Plane = {}, Angle from XY Plane = {}\nDelta X = {}, Delta Y = {}, Delta Z = {}",
|
||||
fmt_d(s, (b - a).len()),
|
||||
fmt_d(s, dist),
|
||||
fmt_a(s, d.xy().angle()),
|
||||
fmt_a(s, angle_from_xy(d)),
|
||||
fmt_d(s, d.x),
|
||||
@@ -222,6 +229,8 @@ fn run_dist(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
s.distance = d.len();
|
||||
s.last_point = a.xy();
|
||||
// Top level: the world values, as ID's x, y, z are; `ucs` has what the message shows.
|
||||
let du = dist_delta(s, a, b);
|
||||
Ok(json!({
|
||||
"distance": d.len(),
|
||||
"angle": d.xy().angle().to_degrees(),
|
||||
@@ -229,18 +238,28 @@ fn run_dist(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
"dx": d.x,
|
||||
"dy": d.y,
|
||||
"dz": d.z,
|
||||
"message": dist_text(s, a, b),
|
||||
"ucs": {
|
||||
"angle": du.xy().angle().to_degrees(),
|
||||
"angleFromXY": angle_from_xy(du).to_degrees(),
|
||||
"dx": du.x,
|
||||
"dy": du.y,
|
||||
"dz": du.z,
|
||||
},
|
||||
"message": dist_text(s, d.len(), du),
|
||||
}))
|
||||
}
|
||||
|
||||
/// ID's report: the point in the current UCS.
|
||||
fn id_text(s: &Session, a: Vec3) -> String {
|
||||
format!("X = {} Y = {} Z = {}", fmt_d(s, a.x), fmt_d(s, a.y), fmt_d(s, a.z))
|
||||
let u = s.input_ucs().to_ucs3(a);
|
||||
format!("X = {} Y = {} Z = {}", fmt_d(s, u.x), fmt_d(s, u.y), fmt_d(s, u.z))
|
||||
}
|
||||
|
||||
fn run_id(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let a = point3_req(s, "id", p, "at")?;
|
||||
s.last_point = a.xy();
|
||||
Ok(json!({ "x": a.x, "y": a.y, "z": a.z, "message": id_text(s, a) }))
|
||||
let u = s.input_ucs().to_ucs3(a);
|
||||
Ok(json!({ "x": a.x, "y": a.y, "z": a.z, "ucs": [u.x, u.y, u.z], "message": id_text(s, a) }))
|
||||
}
|
||||
|
||||
/// The Z of what is drawn at `p`: the object a pick finds there, at that point, or the current
|
||||
@@ -591,7 +610,7 @@ fn run_inspect(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
"dimStyles": d.dim_styles.iter().map(|l| l.name.clone()).collect::<Vec<_>>(),
|
||||
"blocks": d.blocks.keys().filter(|k| !k.starts_with('*')).cloned().collect::<Vec<_>>(),
|
||||
"layouts": d.layouts.iter().map(|l| l.name.clone()).collect::<Vec<_>>(),
|
||||
"selection": st.selection.iter().map(|h| h.hex()).collect::<Vec<_>>(),
|
||||
"selection": st.shown_selection().iter().map(|h| h.hex()).collect::<Vec<_>>(),
|
||||
"undo": st.undo.iter().rev().take(20).map(|u| u.label.clone()).collect::<Vec<_>>(),
|
||||
"view": { "center": [st.view().center.x, st.view().center.y], "height": st.view().height },
|
||||
// Records of the file the drawing came from that the reader could not place.
|
||||
@@ -900,7 +919,7 @@ impl Interactive for DistM {
|
||||
s.last_point = first;
|
||||
return Err(bad("dist", "the distance is too large"));
|
||||
}
|
||||
let t = dist_text(s, a, b);
|
||||
let t = dist_text(s, (b - a).len(), dist_delta(s, a, b));
|
||||
for l in t.lines() {
|
||||
s.echo(l.to_string());
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -313,7 +313,16 @@ fn run_copy(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let h = d.new_handle();
|
||||
store.push(Entity { handle: h, ..Entity::clone(e) });
|
||||
}
|
||||
d.layouts.push(Layout { name: to.clone(), tab_order: order, page: src.page, entities: store, view: src.view, limits: src.limits });
|
||||
d.layouts.push(Layout {
|
||||
name: to.clone(),
|
||||
tab_order: order,
|
||||
page: src.page,
|
||||
entities: store,
|
||||
view: src.view,
|
||||
ucs: src.ucs,
|
||||
ucs_previous: Vec::new(),
|
||||
limits: src.limits,
|
||||
});
|
||||
Ok(json!({ "name": to }))
|
||||
}
|
||||
|
||||
|
||||
@@ -21,14 +21,17 @@ impl StretchArea {
|
||||
}
|
||||
}
|
||||
|
||||
/// Add to `hs` the visible multilines in `space` with a control vertex inside `area`. A crossing
|
||||
/// selection tests the drawn element lines, which sit away from the control vertices by the
|
||||
/// multiline's scale, so a small area around a vertex alone would miss them.
|
||||
fn add_mline_vertex_hits(d: &cadcraft_doc::Drawing, space: &cadcraft_doc::Space, area: &StretchArea, hs: &mut Vec<Handle>) {
|
||||
let Some(store) = d.space(space) else { return };
|
||||
/// Add to `hs` the multilines in the edit space that a selection can take there (visible, and
|
||||
/// inside an MSPACE viewport not on a layer frozen in it) with a control vertex inside `area`. A
|
||||
/// crossing selection tests the drawn element lines, which sit away from the control vertices by
|
||||
/// the multiline's scale, so a small area around a vertex alone would miss them.
|
||||
fn add_mline_vertex_hits(s: &Session, area: &StretchArea, hs: &mut Vec<Handle>) {
|
||||
let Ok(d) = s.doc() else { return };
|
||||
let Some(store) = d.space(&s.space()) else { return };
|
||||
let frozen = s.viewport_frozen();
|
||||
for e in store.iter() {
|
||||
if let EntityKind::MLine(m) = &e.kind
|
||||
&& d.is_visible(e)
|
||||
&& crate::select::selectable(d, e, frozen)
|
||||
&& !hs.contains(&e.handle)
|
||||
&& m.vertices.iter().any(|v| area.contains(v.p.xy()))
|
||||
{
|
||||
@@ -94,19 +97,19 @@ pub(super) fn run_stretch(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
};
|
||||
// A fence marks no area: the objects it crosses move whole.
|
||||
if let Some(fence) = listed("fence", 2)? {
|
||||
let hs = crate::select::select_fence(s.doc()?, &space, &fence);
|
||||
let hs = crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &fence);
|
||||
let moved = transform_entities(s, &hs, &Mat3::translate(d), false)?;
|
||||
return Ok(json!({ "stretched": moved.len() }));
|
||||
}
|
||||
let (mut hs, area) = if let Some(poly) = listed("polygon", 3)? {
|
||||
(crate::select::select_polygon(s.doc()?, &space, &poly, true), StretchArea::Polygon(poly))
|
||||
(crate::select::select_polygon_in(s.doc()?, &space, s.viewport_frozen(), &poly, true), StretchArea::Polygon(poly))
|
||||
} else {
|
||||
let w = points_param(p, "window").ok_or_else(|| bad("stretch", "`window` [[x,y],[x,y]], `polygon` or `fence` is required"))?;
|
||||
let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("stretch", "window needs 2 corners")) };
|
||||
let bx = cadcraft_geom::Bounds2::new(*a, *b);
|
||||
(crate::select::select_window(s.doc()?, &space, bx, true), StretchArea::Box(bx))
|
||||
(crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, true), StretchArea::Box(bx))
|
||||
};
|
||||
add_mline_vertex_hits(s.doc()?, &space, &area, &mut hs);
|
||||
add_mline_vertex_hits(s, &area, &mut hs);
|
||||
hs.retain(|h| !crate::cmd::curves::is_locked(s, *h));
|
||||
let doc = s.doc_mut()?;
|
||||
let areas = [area];
|
||||
@@ -173,7 +176,7 @@ impl StretchM {
|
||||
/// of two) the mode is dropped.
|
||||
fn finish_mode(&mut self, s: &mut Session, m: SelectMode) -> Result<()> {
|
||||
let space = s.space();
|
||||
let Some(mut hs) = m.select(s.doc()?, &space) else { return Ok(()) };
|
||||
let Some(mut hs) = m.select_in(s.doc()?, &space, s.viewport_frozen()) else { return Ok(()) };
|
||||
let crossing = match (m.kind, m.pts.first().zip(m.pts.get(1))) {
|
||||
(SelectKind::Crossing | SelectKind::CPolygon, _) => true,
|
||||
(SelectKind::Box, Some((a, b))) => b.x < a.x,
|
||||
@@ -189,7 +192,7 @@ impl StretchM {
|
||||
};
|
||||
let whole = area.is_none();
|
||||
if let (Some(a), true, false) = (&area, crossing, self.removing) {
|
||||
add_mline_vertex_hits(s.doc()?, &space, a, &mut hs);
|
||||
add_mline_vertex_hits(s, a, &mut hs);
|
||||
}
|
||||
if let (Some(a), false) = (area, self.removing) {
|
||||
self.windows.push(a);
|
||||
@@ -228,10 +231,10 @@ impl StretchM {
|
||||
Some(c) => {
|
||||
let bx = cadcraft_geom::Bounds2::new(c, p);
|
||||
let space = s.space();
|
||||
let mut hs = crate::select::select_window(s.doc()?, &space, bx, p.x < c.x);
|
||||
let mut hs = crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, p.x < c.x);
|
||||
if !self.removing {
|
||||
if p.x < c.x {
|
||||
add_mline_vertex_hits(s.doc()?, &space, &StretchArea::Box(bx), &mut hs);
|
||||
add_mline_vertex_hits(s, &StretchArea::Box(bx), &mut hs);
|
||||
}
|
||||
self.windows.push(StretchArea::Box(bx));
|
||||
}
|
||||
@@ -240,7 +243,7 @@ impl StretchM {
|
||||
None => {
|
||||
let aperture = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
|
||||
let space = s.space();
|
||||
match crate::select::pick(s.doc()?, &space, p, aperture) {
|
||||
match crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), p, aperture) {
|
||||
Some(h) => self.add(s, vec![h], true),
|
||||
None => self.corner = Some(p),
|
||||
}
|
||||
@@ -251,6 +254,7 @@ impl StretchM {
|
||||
self.corner = None;
|
||||
let d = s.doc()?;
|
||||
let store = d.space(&s.space());
|
||||
let frozen = s.viewport_frozen();
|
||||
let word = t.trim().to_ascii_lowercase();
|
||||
// `_C`, `_L`: the English name, as scripts write it.
|
||||
let word = word.strip_prefix('_').unwrap_or(&word).to_string();
|
||||
@@ -267,9 +271,14 @@ impl StretchM {
|
||||
self.removing = false;
|
||||
None
|
||||
}
|
||||
"all" => Some(store.map(|st| st.iter().filter(|e| d.is_visible(e)).map(|e| e.handle).collect()).unwrap_or_default()),
|
||||
"l" | "last" => Some(store.and_then(|st| st.last()).map(|e| vec![e.handle]).unwrap_or_default()),
|
||||
"p" | "previous" => Some(s.state()?.previous_selection.clone()),
|
||||
"all" => Some(
|
||||
store.map(|st| st.iter().filter(|e| crate::select::selectable(d, e, frozen)).map(|e| e.handle).collect()).unwrap_or_default(),
|
||||
),
|
||||
"l" | "last" => Some(store.and_then(|st| crate::select::last_in(st, frozen)).map(|h| vec![h]).unwrap_or_default()),
|
||||
"p" | "previous" => {
|
||||
let st = s.state()?;
|
||||
Some(st.drawn_in_viewport(&st.previous_selection))
|
||||
}
|
||||
_ => {
|
||||
s.echo("*Invalid selection*");
|
||||
None
|
||||
|
||||
@@ -65,7 +65,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
.params("{handle (block reference), pick?: [x,y] (nearest nested object; default all), delta? | from,to}")
|
||||
.interactive(|_| Ok(Box::new(NcopyM::default()))),
|
||||
CommandSpec::new("mocoro", "Move/Copy/Rotate", mocoro::run_mocoro)
|
||||
.menu(&["Tools", "Express Tools", "Move/Copy/Rotate"])
|
||||
.menu(&["Tools", "Additional Tools", "Move/Copy/Rotate"])
|
||||
.params("{handles?, base: [x,y], ops: [{move: [x,y]} | {copy: [x,y]} | {rotate: degrees} | {scale: factor} | {base: [x,y]}]} → {handles (copies)}")
|
||||
.interactive(|_| Ok(Box::new(mocoro::MocoroM::default()))),
|
||||
CommandSpec::new("chspace", "Change Space", run_chspace)
|
||||
|
||||
+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");
|
||||
}
|
||||
}
|
||||
@@ -280,7 +280,7 @@ fn run_qselect(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let sel = match mode.as_str() {
|
||||
"exclude" => excluded,
|
||||
"append" => {
|
||||
let mut cur = s.selection();
|
||||
let mut cur = s.stored_selection();
|
||||
for h in matched {
|
||||
if !cur.contains(&h) {
|
||||
cur.push(h);
|
||||
|
||||
@@ -99,14 +99,21 @@ pub(crate) fn similar(e: &Entity, r: &Entity, mode: u32) -> bool {
|
||||
&& (mode & NAME == 0 || same_text(object_name(e), object_name(r)))
|
||||
}
|
||||
|
||||
/// The visible objects of the current space like any of `refs`.
|
||||
/// The objects of the current space like any of `refs` that a selection can take there: visible,
|
||||
/// and inside an MSPACE viewport not on a layer frozen in it.
|
||||
fn similar_objects(s: &Session, d: &Drawing, refs: &[Handle], mode: u32) -> Vec<Handle> {
|
||||
let refs: Vec<&Entity> = refs.iter().filter_map(|h| d.entity(*h).map(|e| e.as_ref())).collect();
|
||||
if refs.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let Some(store) = d.space(&s.space()) else { return Vec::new() };
|
||||
store.iter().take(MAX_SCAN).filter(|e| d.is_visible(e) && refs.iter().any(|r| similar(e, r, mode))).map(|e| e.handle).collect()
|
||||
let frozen = s.viewport_frozen();
|
||||
store
|
||||
.iter()
|
||||
.take(MAX_SCAN)
|
||||
.filter(|e| crate::select::selectable(d, e, frozen) && refs.iter().any(|r| similar(e, r, mode)))
|
||||
.map(|e| e.handle)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn mode_param(s: &Session, p: &Value) -> Result<u32> {
|
||||
|
||||
@@ -59,7 +59,7 @@ fn fence(s: &mut Session, pts: &[Vec2], extending: bool, edges: Edges, quick: bo
|
||||
let fb = Bounds2::from_points(pts.iter().copied());
|
||||
let tol = crate::select::window_tol(&fb);
|
||||
let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
|
||||
for h in crate::select::select_fence(d, &space, pts) {
|
||||
for h in crate::select::select_fence_in(d, &space, s.viewport_frozen(), pts) {
|
||||
let Some(e) = d.entity(h) else { continue };
|
||||
let polys = crate::select::hit_polylines(d, e, tol);
|
||||
let mut xs: Vec<Vec2> = Vec::new();
|
||||
@@ -96,7 +96,7 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu
|
||||
];
|
||||
let inside = |p: Vec2| bx.expand(tol).contains(p);
|
||||
let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
|
||||
for h in crate::select::select_window(d, &space, bx, true) {
|
||||
for h in crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, true) {
|
||||
let Some(e) = d.entity(h) else { continue };
|
||||
let mut best: Option<Vec2> = None;
|
||||
for pl in crate::select::hit_polylines(d, e, tol) {
|
||||
|
||||
@@ -18,7 +18,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("txt2mtxt", "Convert Text to Mtext", run_txt2mtxt)
|
||||
.menu(&["Tools", "Express Tools", "Convert Text to Mtext"])
|
||||
.menu(&["Tools", "Additional Tools", "Convert Text to Mtext"])
|
||||
.params(
|
||||
"{handles? (default the selection; TEXT, and MTEXT when combining), combine? (default true: one MTEXT; false: one per TEXT), \
|
||||
sort?: \"topdown\" (default) | \"selection\", wrap? (default false: one line per text)} → {handles}",
|
||||
|
||||
@@ -0,0 +1,675 @@
|
||||
//! UCS an UCSICON: the current user coordinate system ([`crate::ucs`]) and its icon.
|
||||
//!
|
||||
//! UCS sets the current UCS of the space commands act on: by an origin and points on the new X
|
||||
//! axis and XY plane (the default option), World, Previous, NAmed (Restore, Save, Delete, `?`),
|
||||
//! OBject (lined up with an object), View and Z (a turn about Z). X, Y, ZAxis and Face tilt the
|
||||
//! UCS out of the XY plane, which CADCraft doesn't draw in yet; they say so. A UCS change is part
|
||||
//! of the command's undo step, as an edit is.
|
||||
|
||||
use cadcraft_doc::{Drawing, EntityKind, Ucs};
|
||||
use cadcraft_geom::{Vec2, Vec3};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::utility::num_text;
|
||||
use super::{CommandSpec, bad, str_param};
|
||||
use crate::prompt::{Accept, Input, Interactive, Prompt, Step};
|
||||
use crate::ucs::{UcsFrame, named};
|
||||
use crate::{EngineError, Result, Session};
|
||||
|
||||
/// The UCS command's options, as typed.
|
||||
const OPTIONS: &[&str] = &["Face", "NAmed", "OBject", "Previous", "View", "World", "X", "Y", "Z", "ZAxis"];
|
||||
|
||||
/// Characters a UCS name can't hold.
|
||||
const BAD_NAME_CHARS: &[char] = &['<', '>', '/', '\\', '"', ':', ';', '?', '*', '|', ',', '=', '`'];
|
||||
|
||||
/// Longest UCS name.
|
||||
const MAX_NAME: usize = 255;
|
||||
|
||||
/// Most UCS table records a drawing keeps (a hostile script can't grow it without bound).
|
||||
const MAX_NAMED: usize = 10_000;
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("ucs", "UCS", run_ucs)
|
||||
.params(
|
||||
"{option?: origin|world|previous|named|object|view|z|x|y|zaxis|face (default origin), origin?: [x,y(,z)], xPoint?, xyPoint? \
|
||||
(origin: the new origin, and points on its positive X axis and on the positive-Y side of its XY plane; without them \
|
||||
the axes stay), angle? (z: degrees counterclockwise about Z, default UCSAXISANG), action?: restore|save|delete|list \
|
||||
(named), name? (named; delete and list take wildcards and commas), replace?: bool (save over an existing name), \
|
||||
handle?, at? (object: the object and the point it is picked at)} → {ucs: {name, origin, xAxis, yAxis}}. Points \
|
||||
are world coordinates. x, y, zaxis and face tilt the UCS out of the XY plane and are not available yet.",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(UcsM::default()))),
|
||||
CommandSpec::new("ucs.world", "World", |s, p| run_ucs(s, &with_option(p, "world")))
|
||||
.menu(&["Tools", "New UCS", "World"])
|
||||
.params("{} (the World UCS)"),
|
||||
CommandSpec::new("ucs.origin", "Origin", |s, p| run_ucs(s, &with_option(p, "origin")))
|
||||
.menu(&["Tools", "New UCS", "Origin"])
|
||||
.params("{origin: [x,y(,z)]} (moves the UCS, keeping its axes)")
|
||||
.interactive(|_| Ok(Box::new(UcsM::starting(Stage::OriginOnly)))),
|
||||
CommandSpec::new("ucs.3point", "3 Point", |s, p| run_ucs(s, &with_option(p, "origin")))
|
||||
.menu(&["Tools", "New UCS", "3 Point"])
|
||||
.params("{origin, xPoint?, xyPoint?} (as `ucs` origin)")
|
||||
.interactive(|_| Ok(Box::new(UcsM::starting(Stage::ThreePoint)))),
|
||||
CommandSpec::new("ucs.view", "View", |s, p| run_ucs(s, &with_option(p, "view")))
|
||||
.menu(&["Tools", "New UCS", "View"])
|
||||
.params("{} (XY plane square to the view, X along the screen's horizontal so it follows the view twist, origin kept)"),
|
||||
CommandSpec::new("ucs.z", "Z", |s, p| run_ucs(s, &with_option(p, "z")))
|
||||
.menu(&["Tools", "New UCS", "Z"])
|
||||
.params("{angle?} (degrees counterclockwise about Z, default UCSAXISANG)")
|
||||
.interactive(|_| Ok(Box::new(UcsM::starting(Stage::ZAngle)))),
|
||||
CommandSpec::new("ucsicon", "UCS Icon", run_ucsicon)
|
||||
.params("{on?: bool, origin?: bool} (UCSICON: the icon shown, and at the UCS origin when that is on screen) → {on, origin}")
|
||||
// Undoable like SETVAR: UCSICON lives in the drawing, so without a step of its own an
|
||||
// undo of the edit before it would put the old value back.
|
||||
.interactive(|_| Ok(Box::new(UcsIconM))),
|
||||
]
|
||||
}
|
||||
|
||||
fn with_option(p: &Value, option: &str) -> Value {
|
||||
let mut p = if p.is_object() { p.clone() } else { json!({}) };
|
||||
if let Some(o) = p.as_object_mut() {
|
||||
o.insert("option".into(), json!(option));
|
||||
}
|
||||
p
|
||||
}
|
||||
|
||||
/// A JSON point with an optional Z: `[x, y]`, `[x, y, z]` or `{x, y, z?}`.
|
||||
fn point3(v: &Value) -> Option<Vec3> {
|
||||
let p = if let Some(a) = v.as_array() {
|
||||
Vec3::new(a.first()?.as_f64()?, a.get(1)?.as_f64()?, a.get(2).and_then(Value::as_f64).unwrap_or(0.0))
|
||||
} else {
|
||||
Vec3::new(v.get("x")?.as_f64()?, v.get("y")?.as_f64()?, v.get("z").and_then(Value::as_f64).unwrap_or(0.0))
|
||||
};
|
||||
p.is_finite().then_some(p)
|
||||
}
|
||||
|
||||
fn point3_param(cmd: &str, p: &Value, key: &str) -> Result<Option<Vec3>> {
|
||||
match p.get(key) {
|
||||
None | Some(Value::Null) => Ok(None),
|
||||
Some(v) => point3(v).map(Some).ok_or_else(|| bad(cmd, format!("`{key}` must be a finite point [x, y] or [x, y, z]"))),
|
||||
}
|
||||
}
|
||||
|
||||
/// `UCS` as JSON: the result is the new current UCS.
|
||||
fn run_ucs(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let option = str_param(p, "option").unwrap_or("origin").trim().to_ascii_lowercase();
|
||||
match option.as_str() {
|
||||
"origin" | "3point" => {
|
||||
let origin = point3_param("ucs", p, "origin")?.ok_or_else(|| bad("ucs", "`origin` ([x, y] or [x, y, z]) is required"))?;
|
||||
let x = point3_param("ucs", p, "xPoint")?;
|
||||
let xy = point3_param("ucs", p, "xyPoint")?;
|
||||
if xy.is_some() && x.is_none() {
|
||||
return Err(bad("ucs", "`xyPoint` needs `xPoint`"));
|
||||
}
|
||||
set_by_points(s, origin, x, xy)?;
|
||||
}
|
||||
"world" | "w" => s.set_ucs(UcsFrame::WORLD, "")?,
|
||||
"previous" | "p" => {
|
||||
if !s.ucs_previous()? {
|
||||
return Err(bad("ucs", "there is no previous UCS"));
|
||||
}
|
||||
}
|
||||
"view" | "v" => s.set_ucs(view_ucs(s), "")?,
|
||||
"z" => {
|
||||
let deg = match p.get("angle") {
|
||||
None | Some(Value::Null) => axis_angle(s),
|
||||
Some(v) => v.as_f64().filter(|a| a.is_finite()).ok_or_else(|| bad("ucs", "`angle` must be a finite number of degrees"))?,
|
||||
};
|
||||
rotate_z(s, deg.to_radians())?;
|
||||
}
|
||||
"object" | "ob" => {
|
||||
let h = super::targets(s, p)?.first().copied().ok_or_else(|| bad("ucs", "`handle` (the object) is required"))?;
|
||||
let at = p.get("at").and_then(super::point_value);
|
||||
set_by_object(s, h, at)?;
|
||||
}
|
||||
"named" | "na" => {
|
||||
let action = str_param(p, "action").unwrap_or("restore").trim().to_ascii_lowercase();
|
||||
let name = str_param(p, "name").map(str::trim).unwrap_or_default().to_string();
|
||||
match action.as_str() {
|
||||
"restore" | "r" => restore(s, &name).map_err(|e| bad("ucs", e))?,
|
||||
"save" | "s" => save(s, &name, p.get("replace").and_then(Value::as_bool).unwrap_or(false)).map_err(|e| bad("ucs", e))?,
|
||||
"delete" | "d" => {
|
||||
let n = delete(s, if name.is_empty() { "" } else { &name })?;
|
||||
return Ok(json!({ "deleted": n, "ucs": ucs_json(s) }));
|
||||
}
|
||||
"list" | "?" => return Ok(json!({ "list": list(s, if name.is_empty() { "*" } else { &name }), "ucs": ucs_json(s) })),
|
||||
other => return Err(bad("ucs", format!("unknown named action `{other}` (restore, save, delete or list)"))),
|
||||
}
|
||||
}
|
||||
"x" | "y" | "zaxis" | "za" | "face" | "f" => return Err(bad("ucs", tilted_message(&option))),
|
||||
other => return Err(bad("ucs", format!("unknown option `{other}`"))),
|
||||
}
|
||||
Ok(json!({ "ucs": ucs_json(s) }))
|
||||
}
|
||||
|
||||
fn ucs_json(s: &Session) -> Value {
|
||||
let (u, name) = s.ucs_named();
|
||||
let p = |v: Vec3| json!([v.x, v.y, v.z]);
|
||||
json!({ "name": name, "origin": p(u.origin), "xAxis": p(u.x), "yAxis": p(u.y), "world": u.is_world() })
|
||||
}
|
||||
|
||||
fn tilted_message(option: &str) -> String {
|
||||
let label = match option {
|
||||
"x" => "UCS X",
|
||||
"y" => "UCS Y",
|
||||
"zaxis" | "za" => "UCS ZAxis",
|
||||
_ => "UCS Face",
|
||||
};
|
||||
format!("{label} tilts the UCS out of the XY plane, which is not available yet.")
|
||||
}
|
||||
|
||||
/// The UCSAXISANG default for Z, in degrees.
|
||||
fn axis_angle(s: &Session) -> f64 {
|
||||
s.doc().map(|d| d.header.i64("UCSAXISANG", 90)).unwrap_or(90) as f64
|
||||
}
|
||||
|
||||
/// A 2D point of the current UCS's XY plane as a 3D world point.
|
||||
fn on_plane(s: &Session, p: Vec2) -> Vec3 {
|
||||
p.to3(s.ucs().origin.z)
|
||||
}
|
||||
|
||||
/// The UCS through `origin`, with points on its X axis and in its XY plane (world points).
|
||||
fn set_by_points(s: &mut Session, origin: Vec3, x: Option<Vec3>, xy: Option<Vec3>) -> Result<()> {
|
||||
let f = s.ucs().from_points(origin, x, xy).ok_or_else(|| EngineError::Other("Those points don't define a UCS: they lie on one line.".into()))?;
|
||||
if !f.is_planar() {
|
||||
return Err(EngineError::Other("That UCS is tilted out of the XY plane (or turned over), which is not available yet.".into()));
|
||||
}
|
||||
s.set_ucs(f, "")
|
||||
}
|
||||
|
||||
/// UCS View: the XY plane square to the view (a plan view), at the current origin, with X
|
||||
/// along the screen's horizontal. The drawing appears turned by the view twist (the Model tab's,
|
||||
/// or the active layout viewport's), so the screen's X is the world direction at -twist.
|
||||
fn view_ucs(s: &Session) -> UcsFrame {
|
||||
let twist = cadcraft_geom::norm_angle(s.state().map_or(0.0, |st| st.view().twist));
|
||||
UcsFrame::WORLD.rotated_z(-twist).with_origin(s.ucs().origin)
|
||||
}
|
||||
|
||||
fn rotate_z(s: &mut Session, angle: f64) -> Result<()> {
|
||||
let f = s.ucs().rotated_z(angle);
|
||||
s.set_ucs(f, "")
|
||||
}
|
||||
|
||||
/// UCS OBject: the UCS lined up with object `h`, picked at `at` (world) when known.
|
||||
fn set_by_object(s: &mut Session, h: cadcraft_doc::Handle, at: Option<Vec2>) -> Result<()> {
|
||||
let d = s.doc()?;
|
||||
let e = d.entity(h).ok_or_else(|| EngineError::Other("No such object.".into()))?;
|
||||
let ext = e.common.extrusion;
|
||||
if ext.is_finite() && (ext.x.abs() > 1e-9 || ext.y.abs() > 1e-9 || ext.z < 0.0) {
|
||||
return Err(EngineError::Other("That object lies in a tilted plane; a UCS out of the XY plane is not available yet.".into()));
|
||||
}
|
||||
let f = object_frame(&s.ucs(), &e.kind, at)?;
|
||||
s.set_ucs(f, "")
|
||||
}
|
||||
|
||||
/// A frame at `o` whose X axis points along `dir` in the XY plane.
|
||||
fn along(o: Vec3, dir: Vec2) -> Result<UcsFrame> {
|
||||
UcsFrame::new(o, dir.to3(0.0), dir.perp().to3(0.0))
|
||||
.ok_or_else(|| EngineError::Other("That object has no direction to line the UCS up with.".into()))
|
||||
}
|
||||
|
||||
/// The UCS OBject rules: where each kind of object puts the origin and the X axis.
|
||||
fn object_frame(cur: &UcsFrame, kind: &EntityKind, at: Option<Vec2>) -> Result<UcsFrame> {
|
||||
let near = |a: Vec2, b: Vec2| at.is_none_or(|p| p.dist(a) <= p.dist(b));
|
||||
match kind {
|
||||
// The endpoint nearer the pick; X along the line.
|
||||
EntityKind::Line(l) => {
|
||||
let (o, other) = if near(l.a.xy(), l.b.xy()) { (l.a, l.b) } else { (l.b, l.a) };
|
||||
along(o, other.xy() - o.xy())
|
||||
}
|
||||
// The centre; X through the endpoint nearer the pick.
|
||||
EntityKind::Arc(a) => {
|
||||
let (e0, e1) = (Vec2::polar(a.center.xy(), a.radius, a.start), Vec2::polar(a.center.xy(), a.radius, a.end));
|
||||
let e = if near(e0, e1) { e0 } else { e1 };
|
||||
along(a.center, e - a.center.xy())
|
||||
}
|
||||
// The centre; X through the pick.
|
||||
EntityKind::Circle(c) => {
|
||||
let d = at.map(|p| p - c.center.xy()).filter(|d| d.len() > 1e-12).unwrap_or(cur.x.xy());
|
||||
along(c.center, d)
|
||||
}
|
||||
// The first vertex; X toward the next one.
|
||||
EntityKind::LwPolyline(p) => {
|
||||
let first = p.vertices.first().map(|v| v.p).ok_or_else(|| EngineError::Other("That polyline has no vertices.".into()))?;
|
||||
let next = p.vertices.iter().map(|v| v.p).find(|q| q.dist(first) > 1e-12).ok_or_else(|| EngineError::Other("That polyline has no length.".into()))?;
|
||||
along(first.to3(p.elevation), next - first)
|
||||
}
|
||||
// The point; the X axis stays as it is.
|
||||
EntityKind::Point(p) => along(p.p, cur.x.xy()),
|
||||
// The insertion point; X along the object's rotation.
|
||||
EntityKind::Text(t) => along(t.insert, Vec2::from_angle(t.rotation)),
|
||||
EntityKind::AttDef(a) => along(a.text.insert, Vec2::from_angle(a.text.rotation)),
|
||||
EntityKind::Insert(i) => along(i.insert, Vec2::from_angle(i.rotation)),
|
||||
// The first corner; X toward the second.
|
||||
EntityKind::Solid(so) | EntityKind::Trace(so) => {
|
||||
let [a, b, ..] = so.corners;
|
||||
along(a, b.xy() - a.xy())
|
||||
}
|
||||
// The first corner; X toward the second, Y toward the fourth.
|
||||
EntityKind::Face3d(f) => {
|
||||
let [a, b, _, d] = f.corners;
|
||||
let frame = UcsFrame::new(a, b - a, d - a).ok_or_else(|| EngineError::Other("That face has no area to line the UCS up with.".into()))?;
|
||||
if frame.is_planar() {
|
||||
Ok(frame)
|
||||
} else {
|
||||
Err(EngineError::Other("That face lies out of the XY plane; a UCS out of it is not available yet.".into()))
|
||||
}
|
||||
}
|
||||
// The middle of the text; the X axis stays as it is.
|
||||
EntityKind::Dimension(dm) => along(dm.text_mid, cur.x.xy()),
|
||||
_ => Err(EngineError::Other("The UCS can't be lined up with that kind of object (lines, arcs, circles, polylines, points, text, blocks, 2D solids, 3D faces and dimensions can).".into())),
|
||||
}
|
||||
}
|
||||
|
||||
/// A usable UCS name, or why not.
|
||||
fn check_name(name: &str) -> std::result::Result<String, String> {
|
||||
let n = name.trim();
|
||||
if n.is_empty() {
|
||||
return Err("A UCS name is required.".into());
|
||||
}
|
||||
if n.chars().count() > MAX_NAME {
|
||||
return Err(format!("A UCS name has at most {MAX_NAME} characters."));
|
||||
}
|
||||
if n.contains(BAD_NAME_CHARS) || n.chars().any(char::is_control) {
|
||||
return Err(format!("\"{n}\" is not a valid UCS name."));
|
||||
}
|
||||
if n.eq_ignore_ascii_case("*WORLD*") || n.eq_ignore_ascii_case("WORLD") {
|
||||
return Err("\"World\" is the World UCS; save under another name.".into());
|
||||
}
|
||||
Ok(n.to_string())
|
||||
}
|
||||
|
||||
fn restore(s: &mut Session, name: &str) -> std::result::Result<(), String> {
|
||||
let d = s.doc().map_err(|e| e.to_string())?;
|
||||
let (f, n) = named(d, name).ok_or_else(|| format!("Cannot find UCS \"{}\".", name.trim()))?;
|
||||
if !f.is_planar() {
|
||||
// Kept and saved as read, but not current until tilted UCSs are available.
|
||||
return Err(format!("UCS \"{n}\" is tilted out of the XY plane, which is not available yet."));
|
||||
}
|
||||
s.set_ucs(f, &n).map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
fn exists(d: &Drawing, name: &str) -> bool {
|
||||
d.ucss.iter().any(|u| u.name.eq_ignore_ascii_case(name))
|
||||
}
|
||||
|
||||
/// Save the current UCS as `name` (replacing a UCS of that name only with `replace`); it is then
|
||||
/// the current UCS's name.
|
||||
fn save(s: &mut Session, name: &str, replace: bool) -> std::result::Result<(), String> {
|
||||
let n = check_name(name)?;
|
||||
let frame = s.ucs();
|
||||
let d = s.doc_mut().map_err(|e| e.to_string())?;
|
||||
match d.ucss.iter_mut().find(|u| u.name.eq_ignore_ascii_case(&n)) {
|
||||
Some(_) if !replace => return Err(format!("UCS \"{n}\" already exists.")),
|
||||
Some(u) => *u = frame.record(&u.name.clone()),
|
||||
None => {
|
||||
if d.ucss.len() >= MAX_NAMED {
|
||||
return Err(format!("A drawing keeps at most {MAX_NAMED} named UCSs."));
|
||||
}
|
||||
d.ucss.push(frame.record(&n));
|
||||
}
|
||||
}
|
||||
let kept = d.ucss.iter().find(|u| u.name.eq_ignore_ascii_case(&n)).map(|u| u.name.clone()).unwrap_or(n);
|
||||
s.set_ucs(frame, &kept).map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Whether `name` matches one of the comma-separated wildcard patterns.
|
||||
fn matches(patterns: &str, name: &str) -> bool {
|
||||
patterns
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
.filter(|p| !p.is_empty())
|
||||
.any(|p| super::qselect::wildcard(&p.to_ascii_uppercase(), &name.to_ascii_uppercase()))
|
||||
}
|
||||
|
||||
/// Delete the named UCSs matching `patterns`; the current UCS keeps its axes but loses a deleted
|
||||
/// name. Returns how many went.
|
||||
fn delete(s: &mut Session, patterns: &str) -> Result<usize> {
|
||||
let gone: Vec<String> = s.doc()?.ucss.iter().filter(|u| matches(patterns, &u.name)).map(|u| u.name.clone()).collect();
|
||||
if gone.is_empty() {
|
||||
return Ok(0);
|
||||
}
|
||||
s.doc_mut()?.ucss.retain(|u| !gone.iter().any(|g| g == &u.name));
|
||||
// Wherever a deleted name is current (model space's UCSNAME, every layout's UCS) the UCS keeps
|
||||
// its axes and loses the name; the UCS Previous histories keep their frames the same way.
|
||||
let d = s.doc_mut()?;
|
||||
let is_gone = |n: &str| gone.iter().any(|g| g.eq_ignore_ascii_case(n.trim()));
|
||||
if is_gone(&d.header.str("UCSNAME", "")) {
|
||||
d.header.set_str("UCSNAME", "");
|
||||
}
|
||||
let unname = |u: &mut Ucs| {
|
||||
if is_gone(&u.name) {
|
||||
u.name.clear();
|
||||
}
|
||||
};
|
||||
d.ucs_previous.iter_mut().for_each(unname);
|
||||
for l in &mut d.layouts {
|
||||
l.ucs.iter_mut().for_each(unname);
|
||||
// A layout whose UCS is the World UCS again holds none, as `set_current` leaves it.
|
||||
if l.ucs.as_ref().is_some_and(|u| u.name.is_empty() && UcsFrame::of(u).is_some_and(|f| f.is_world())) {
|
||||
l.ucs = None;
|
||||
}
|
||||
l.ucs_previous.iter_mut().for_each(unname);
|
||||
}
|
||||
Ok(gone.len())
|
||||
}
|
||||
|
||||
/// How the current UCS is named in messages.
|
||||
fn shown_name(s: &Session) -> String {
|
||||
let (u, name) = s.ucs_named();
|
||||
if !name.is_empty() {
|
||||
name
|
||||
} else if u.is_world() {
|
||||
"*WORLD*".into()
|
||||
} else {
|
||||
"*NO NAME*".into()
|
||||
}
|
||||
}
|
||||
|
||||
/// `?`: the named UCSs matching `patterns`, their origins and axes relative to the current UCS.
|
||||
fn list(s: &Session, patterns: &str) -> String {
|
||||
let Ok(d) = s.doc() else { return String::new() };
|
||||
let cur = s.input_ucs();
|
||||
let (lu, lp) = (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4));
|
||||
let f = |v: f64| crate::units::format_distance(v, lu, lp);
|
||||
let pt = |v: Vec3| format!("<{},{},{}>", f(v.x), f(v.y), f(v.z));
|
||||
let axis = |o: Vec3, a: Vec3| cur.to_ucs3(o + a) - cur.to_ucs3(o);
|
||||
let mut out = format!("Current ucs name: {}\nSaved coordinate systems:", shown_name(s));
|
||||
let mut any = false;
|
||||
for u in d.ucss.iter().filter(|u| matches(patterns, &u.name)) {
|
||||
any = true;
|
||||
let Some(fr) = UcsFrame::of(u) else { continue };
|
||||
out.push_str(&format!(
|
||||
"\n\n{}\n Origin = {}, X Axis = {}\n Y Axis = {}, Z Axis = {}",
|
||||
u.name,
|
||||
pt(cur.to_ucs3(fr.origin)),
|
||||
pt(axis(fr.origin, fr.x)),
|
||||
pt(axis(fr.origin, fr.y)),
|
||||
pt(axis(fr.origin, fr.z()))
|
||||
));
|
||||
}
|
||||
if !any {
|
||||
out.push_str("\n\n(none)");
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Where the interactive UCS is.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
enum Stage {
|
||||
#[default]
|
||||
Main,
|
||||
/// Tools > New UCS > Origin: only the origin.
|
||||
OriginOnly,
|
||||
/// Tools > New UCS > 3 Point: the origin first, then the axes.
|
||||
ThreePoint,
|
||||
XPoint(Vec3),
|
||||
XyPoint(Vec3, Vec3),
|
||||
Named,
|
||||
Restore,
|
||||
Save,
|
||||
Replace(String),
|
||||
Delete,
|
||||
List,
|
||||
Object,
|
||||
ZAngle,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct UcsM {
|
||||
stage: Stage,
|
||||
}
|
||||
|
||||
impl UcsM {
|
||||
fn starting(stage: Stage) -> Self {
|
||||
UcsM { stage }
|
||||
}
|
||||
}
|
||||
|
||||
fn other(msg: impl Into<String>) -> EngineError {
|
||||
EngineError::Other(msg.into())
|
||||
}
|
||||
|
||||
impl Interactive for UcsM {
|
||||
fn name(&self) -> &'static str {
|
||||
"UCS"
|
||||
}
|
||||
fn begin(&mut self, s: &mut Session) -> Result<Step> {
|
||||
s.echo(format!("Current ucs name: {}", shown_name(s)));
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
fn prompt(&self, s: &Session) -> Prompt {
|
||||
match &self.stage {
|
||||
Stage::Main => Prompt::new("Specify origin of UCS", Accept::POINT).kw(OPTIONS).default("World"),
|
||||
Stage::OriginOnly | Stage::ThreePoint => {
|
||||
// The origin as input is read: in the UCS where that is the current one (so 0,0,0),
|
||||
// in the world while the current UCS is tilted out of the XY plane.
|
||||
let o = s.ucs().origin;
|
||||
let (p, z) = if s.ucs().is_planar() { (s.input_ucs().to_ucs(o.xy()), 0.0) } else { (o.xy(), o.z) };
|
||||
Prompt::new("Specify new origin point", Accept::POINT).default(format!("{},{},{}", num_text(p.x), num_text(p.y), num_text(z)))
|
||||
}
|
||||
Stage::XPoint(o) => Prompt::new("Specify point on X-axis", Accept::POINT).default("Accept").base(o.xy()),
|
||||
Stage::XyPoint(o, _) => Prompt::new("Specify point on the XY plane", Accept::POINT).default("Accept").base(o.xy()),
|
||||
Stage::Named => Prompt::new("Enter an option", Accept::TEXT).kw(&["Restore", "Save", "Delete", "?"]),
|
||||
Stage::Restore => Prompt::new("Enter name of UCS to restore", Accept::TEXT).kw(&["?"]),
|
||||
Stage::Save => Prompt::new("Enter name to save current UCS", Accept::TEXT).kw(&["?"]),
|
||||
Stage::Replace(n) => Prompt::new(format!("UCS \"{n}\" already exists. Replace it?"), Accept::TEXT).kw(&["Yes", "No"]).default("No"),
|
||||
Stage::Delete => Prompt::new("Enter UCS name(s) to delete", Accept::TEXT).default("none"),
|
||||
Stage::List => Prompt::new("Enter UCS name(s) to list", Accept::TEXT).default("*"),
|
||||
Stage::Object => Prompt::new("Select object to align UCS", Accept::POINT),
|
||||
Stage::ZAngle => Prompt::new("Specify rotation angle about Z axis", Accept::NUMBER).default(format!("{}", axis_angle(s))),
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
if i == Input::Cancel {
|
||||
return Ok(Step::Cancel);
|
||||
}
|
||||
match (self.stage.clone(), i) {
|
||||
(Stage::Main, Input::Enter) => {
|
||||
s.set_ucs(UcsFrame::WORLD, "")?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Main, Input::Keyword(k)) => match k.as_str() {
|
||||
"World" => {
|
||||
s.set_ucs(UcsFrame::WORLD, "")?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
"Previous" => {
|
||||
if !s.ucs_previous()? {
|
||||
s.echo("There is no previous UCS.");
|
||||
}
|
||||
Ok(Step::Done)
|
||||
}
|
||||
"View" => {
|
||||
let f = view_ucs(s);
|
||||
s.set_ucs(f, "")?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
"NAmed" => {
|
||||
self.stage = Stage::Named;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
"OBject" => {
|
||||
self.stage = Stage::Object;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
"Z" => {
|
||||
self.stage = Stage::ZAngle;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
"X" | "Y" | "ZAxis" | "Face" => {
|
||||
s.echo(tilted_message(&k.to_ascii_lowercase()));
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
_ => Ok(Step::Continue),
|
||||
},
|
||||
(Stage::Main | Stage::ThreePoint, Input::Point(p)) => {
|
||||
self.stage = Stage::XPoint(on_plane(s, p));
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Stage::OriginOnly, Input::Point(p)) => {
|
||||
let f = s.ucs().with_origin(on_plane(s, p));
|
||||
s.set_ucs(f, "")?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::OriginOnly, Input::Enter) => Ok(Step::Done),
|
||||
// Enter keeps the origin and goes on to the axes, as a typed point would.
|
||||
(Stage::ThreePoint, Input::Enter) => {
|
||||
self.stage = Stage::XPoint(s.ucs().origin);
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Stage::XPoint(o), Input::Enter) => {
|
||||
set_by_points(s, o, None, None)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::XPoint(o), Input::Point(p)) => {
|
||||
let x = on_plane(s, p);
|
||||
if x.xy().dist(o.xy()) <= 1e-12 {
|
||||
return Err(other("The point on the X axis must differ from the origin."));
|
||||
}
|
||||
self.stage = Stage::XyPoint(o, x);
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Stage::XyPoint(o, x), Input::Enter) => {
|
||||
set_by_points(s, o, Some(x), None)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::XyPoint(o, x), Input::Point(p)) => {
|
||||
set_by_points(s, o, Some(x), Some(on_plane(s, p)))?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Named, Input::Keyword(k)) => {
|
||||
self.stage = match k.as_str() {
|
||||
"Restore" => Stage::Restore,
|
||||
"Save" => Stage::Save,
|
||||
"Delete" => Stage::Delete,
|
||||
_ => Stage::List,
|
||||
};
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Stage::Named, Input::Enter) => Ok(Step::Done),
|
||||
(Stage::Restore | Stage::Save, Input::Keyword(_)) => {
|
||||
let l = list(s, "*");
|
||||
s.echo(l);
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Stage::Restore, Input::Text(t)) => {
|
||||
restore(s, &t).map_err(other)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Save, Input::Text(t)) => {
|
||||
let n = check_name(&t).map_err(other)?;
|
||||
if s.doc().is_ok_and(|d| exists(d, &n)) {
|
||||
self.stage = Stage::Replace(n);
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
save(s, &n, false).map_err(other)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Replace(n), Input::Keyword(k)) => {
|
||||
if k == "Yes" {
|
||||
save(s, &n, true).map_err(other)?;
|
||||
}
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Replace(_), Input::Enter) | (Stage::Restore | Stage::Save | Stage::Delete, Input::Enter) => Ok(Step::Done),
|
||||
(Stage::Delete, Input::Text(t)) => {
|
||||
let n = delete(s, &t)?;
|
||||
s.echo(format!("{n} UCS name(s) deleted."));
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::List, Input::Enter) => {
|
||||
let l = list(s, "*");
|
||||
s.echo(l);
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::List, Input::Text(t)) => {
|
||||
let l = list(s, &t);
|
||||
s.echo(l);
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Object, Input::Point(p)) => {
|
||||
let h = super::curves::pick_at(s, p).ok_or_else(|| other("No object found there; select an object."))?;
|
||||
set_by_object(s, h, Some(p))?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Object, Input::Enter) => Ok(Step::Done),
|
||||
(Stage::ZAngle, Input::Enter) => {
|
||||
let a = axis_angle(s).to_radians();
|
||||
rotate_z(s, a)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::ZAngle, Input::Text(t)) => {
|
||||
let a = s.angle_settings().amount(&t).filter(|a| a.is_finite()).ok_or_else(|| other("Requires a valid angle."))?;
|
||||
rotate_z(s, a)?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(Stage::Main, Input::Text(_)) => Err(other("Requires a point or an option keyword.")),
|
||||
_ => Err(other("Invalid input.")),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn set_ucsicon(s: &mut Session, on: Option<bool>, origin: Option<bool>) -> Result<Value> {
|
||||
let before = s.ucsicon_bits();
|
||||
let mut bits = before;
|
||||
if let Some(on) = on {
|
||||
bits = if on { bits | 1 } else { bits & !1 };
|
||||
}
|
||||
if let Some(o) = origin {
|
||||
bits = if o { bits | 2 } else { bits & !2 };
|
||||
}
|
||||
// Asking (or setting what is already set) leaves the drawing unmodified.
|
||||
if bits != before {
|
||||
s.doc_mut()?.header.set_i64("UCSICON", bits);
|
||||
}
|
||||
Ok(json!({ "on": bits & 1 != 0, "origin": bits & 2 != 0 }))
|
||||
}
|
||||
|
||||
fn run_ucsicon(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let flag = |k: &str| -> Result<Option<bool>> {
|
||||
match p.get(k) {
|
||||
None | Some(Value::Null) => Ok(None),
|
||||
Some(Value::Bool(b)) => Ok(Some(*b)),
|
||||
Some(v) => Err(bad("ucsicon", format!("`{k}` must be true or false, got {v}"))),
|
||||
}
|
||||
};
|
||||
let (on, origin) = (flag("on")?, flag("origin")?);
|
||||
set_ucsicon(s, on, origin)
|
||||
}
|
||||
|
||||
struct UcsIconM;
|
||||
|
||||
impl Interactive for UcsIconM {
|
||||
fn name(&self) -> &'static str {
|
||||
"UCSICON"
|
||||
}
|
||||
fn prompt(&self, s: &Session) -> Prompt {
|
||||
let on = s.ucsicon_bits() & 1 != 0;
|
||||
Prompt::new("Enter an option", Accept::TEXT).kw(&["ON", "OFF", "All", "Noorigin", "ORigin", "Selectable", "Properties"]).default(if on {
|
||||
"ON"
|
||||
} else {
|
||||
"OFF"
|
||||
})
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
match i {
|
||||
Input::Keyword(k) => {
|
||||
match k.as_str() {
|
||||
"ON" => set_ucsicon(s, Some(true), None).map(|_| ())?,
|
||||
"OFF" => set_ucsicon(s, Some(false), None).map(|_| ())?,
|
||||
"Noorigin" => set_ucsicon(s, None, Some(false)).map(|_| ())?,
|
||||
"ORigin" => set_ucsicon(s, None, Some(true)).map(|_| ())?,
|
||||
other => {
|
||||
s.echo(format!("UCSICON {other} is not available yet."));
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
}
|
||||
Ok(Step::Done)
|
||||
}
|
||||
Input::Enter | Input::Cancel => Ok(Step::Done),
|
||||
_ => Err(other("Requires an option keyword.")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -55,6 +55,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
// ---------------- CAL ----------------
|
||||
|
||||
mod calc;
|
||||
pub(super) use calc::num_text;
|
||||
|
||||
/// What QuickCalc's "get from the drawing" picks put on the command line before the value (the
|
||||
/// palette reads it back from there).
|
||||
|
||||
@@ -8,6 +8,12 @@ pub struct Snapshot {
|
||||
pub selection: Vec<Handle>,
|
||||
}
|
||||
|
||||
/// [`DocState::drawn_in_viewport`] looks its handles up one by one while there is fewer than one
|
||||
/// of them for every `LOOKUP_COST` objects of model space, and passes over model space once
|
||||
/// otherwise. Timed on drawings of 40,000 and of 200,000 lines, the two cost the same at about
|
||||
/// one handle for every 47 and for every 18 objects.
|
||||
const LOOKUP_COST: usize = 32;
|
||||
|
||||
/// One open drawing.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct DocState {
|
||||
@@ -35,6 +41,8 @@ pub struct DocState {
|
||||
/// The Block Editor (BEDIT), when it is open: `doc` is then the editor's drawing, and the
|
||||
/// drawing itself waits in it ([`DocState::drawing`]).
|
||||
pub block_edit: Option<blockedit::BlockEdit>,
|
||||
/// The user was told that the current UCS is tilted ([`Session::note_tilted_ucs`]).
|
||||
pub ucs_tilted_noted: bool,
|
||||
/// What the last erase removed, for OOPS.
|
||||
pub(crate) erased: crate::cmd::Erased,
|
||||
/// The fonts missing on Windows that a save last named: the next save names them again only
|
||||
@@ -66,6 +74,7 @@ impl DocState {
|
||||
uid: NEXT_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
|
||||
binary_dxf: false,
|
||||
block_edit: None,
|
||||
ucs_tilted_noted: false,
|
||||
erased: Default::default(),
|
||||
fonts_noted: String::new(),
|
||||
}
|
||||
@@ -119,13 +128,65 @@ impl DocState {
|
||||
}
|
||||
/// The active MSPACE viewport, if it still exists in the current layout.
|
||||
pub fn active_viewport(&self) -> Option<(Handle, cadcraft_doc::Viewport)> {
|
||||
self.active_viewport_ref().map(|(h, v)| (h, v.clone()))
|
||||
}
|
||||
/// [`DocState::active_viewport`] without copying the viewport.
|
||||
fn active_viewport_ref(&self) -> Option<(Handle, &cadcraft_doc::Viewport)> {
|
||||
let h = self.mspace?;
|
||||
let e = self.doc.space(&self.space)?.get(h)?;
|
||||
match &e.kind {
|
||||
cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v.clone())),
|
||||
cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
/// The layers frozen in the active MSPACE viewport (VPLAYER, "VP Freeze"): that viewport does
|
||||
/// not draw their objects, so picks, selections and grips made through it leave them out.
|
||||
/// Empty in paper space and on the Model tab.
|
||||
pub fn viewport_frozen(&self) -> &[String] {
|
||||
match self.active_viewport_ref() {
|
||||
Some((_, v)) => &v.frozen_layers,
|
||||
None => &[],
|
||||
}
|
||||
}
|
||||
/// Whether `e` is a model-space object the active MSPACE viewport does not draw: it is on a
|
||||
/// layer frozen in that viewport ([`DocState::viewport_frozen`]). Objects on the sheet are not
|
||||
/// drawn through the viewport, so its frozen layers do not hide them.
|
||||
pub fn hidden_in_viewport(&self, e: &cadcraft_doc::Entity) -> bool {
|
||||
crate::select::on_frozen_layer(self.viewport_frozen(), e) && self.doc.model.contains(e.handle)
|
||||
}
|
||||
/// Whether the view being edited shows `e`: the drawing shows it ([`Drawing::is_visible`]),
|
||||
/// and the active MSPACE viewport, if there is one, draws it
|
||||
/// ([`DocState::hidden_in_viewport`]).
|
||||
pub fn shows(&self, e: &cadcraft_doc::Entity) -> bool {
|
||||
self.doc.is_visible(e) && !self.hidden_in_viewport(e)
|
||||
}
|
||||
/// `handles` without the objects the active MSPACE viewport does not draw
|
||||
/// ([`DocState::hidden_in_viewport`]): a set of objects made earlier (the selection, the
|
||||
/// Previous set) as that viewport takes it. All of them anywhere else.
|
||||
pub(crate) fn drawn_in_viewport(&self, handles: &[Handle]) -> Vec<Handle> {
|
||||
let frozen = self.viewport_frozen();
|
||||
if frozen.is_empty() || handles.is_empty() {
|
||||
return handles.to_vec();
|
||||
}
|
||||
let model = &self.doc.model;
|
||||
let hidden = |e: &Arc<cadcraft_doc::Entity>| crate::select::on_frozen_layer(frozen, e);
|
||||
// The UI asks for the selection several times a frame. A few handles are looked up one
|
||||
// by one; beyond that, one pass over model space costs less than the lookups.
|
||||
if handles.len().saturating_mul(LOOKUP_COST) < model.len() {
|
||||
return handles.iter().copied().filter(|h| !model.get(*h).is_some_and(hidden)).collect();
|
||||
}
|
||||
let mut gone: Vec<Handle> = model.iter().filter(|e| hidden(e)).map(|e| e.handle).collect();
|
||||
gone.sort_unstable();
|
||||
handles.iter().copied().filter(|h| gone.binary_search(h).is_err()).collect()
|
||||
}
|
||||
/// The selection as the view being edited has it: [`DocState::selection`] without the objects
|
||||
/// the active MSPACE viewport does not draw. Those stay in [`DocState::selection`] until the
|
||||
/// selection is replaced or cleared, and count as selected again once that viewport draws
|
||||
/// them; until then nothing that starts from the selection (a command, a grip, a palette)
|
||||
/// edits them through that viewport.
|
||||
pub fn shown_selection(&self) -> Vec<Handle> {
|
||||
self.drawn_in_viewport(&self.selection)
|
||||
}
|
||||
pub fn paper_view(&self) -> View {
|
||||
self.views.iter().find(|(s, _)| *s == self.space).map(|(_, v)| *v).unwrap_or_default()
|
||||
}
|
||||
|
||||
@@ -0,0 +1,186 @@
|
||||
//! Words typed on a Greek keyboard layout.
|
||||
//!
|
||||
//! With the Greek layout active, the keys that type LINE produce ΛΙΝΕ. Command names, aliases and
|
||||
//! prompt keywords are Latin, so a Greek speaker would have to switch layouts for every command.
|
||||
//! [`latin_keys`] reads a word as the Latin keys that produced it (the layout puts each Greek
|
||||
//! letter on the key of the Latin letter it sounds like): the command line then accepts ΛΙΝΕ and
|
||||
//! ΣΤΡΕΤΨΗ as LINE and STRETCH. Accents (the layout's dead key) are ignored.
|
||||
|
||||
/// The Latin key a Greek letter is typed on (lower case, accents removed).
|
||||
fn key_of(c: char) -> Option<char> {
|
||||
Some(match c {
|
||||
'α' | 'ά' => 'a',
|
||||
'β' => 'b',
|
||||
'γ' => 'g',
|
||||
'δ' => 'd',
|
||||
'ε' | 'έ' => 'e',
|
||||
'ζ' => 'z',
|
||||
'η' | 'ή' => 'h',
|
||||
'θ' => 'u',
|
||||
'ι' | 'ί' | 'ϊ' | 'ΐ' => 'i',
|
||||
'κ' => 'k',
|
||||
'λ' => 'l',
|
||||
'μ' => 'm',
|
||||
'ν' => 'n',
|
||||
'ξ' => 'j',
|
||||
'ο' | 'ό' => 'o',
|
||||
'π' => 'p',
|
||||
'ρ' => 'r',
|
||||
'σ' => 's',
|
||||
// The W key types the final sigma.
|
||||
'ς' => 'w',
|
||||
'τ' => 't',
|
||||
'υ' | 'ύ' | 'ϋ' | 'ΰ' => 'y',
|
||||
'φ' => 'f',
|
||||
'χ' => 'x',
|
||||
'ψ' => 'c',
|
||||
'ω' | 'ώ' => 'v',
|
||||
// The Q key types the semicolon, which Greek text writes as ";" or U+037E.
|
||||
';' | '\u{37e}' => 'q',
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether `c` is a Greek letter (the basic and accented ranges the layout types).
|
||||
fn is_greek_letter(c: char) -> bool {
|
||||
matches!(c, '\u{386}'..='\u{3ce}') && c != '\u{387}'
|
||||
}
|
||||
|
||||
/// `word` read as the Latin keys of a Greek-layout keyboard, lower case: `Some` only when the word
|
||||
/// has a Greek letter and every character is a Greek letter the layout types, the semicolon on
|
||||
/// the Q key, or ASCII (itself, in lower case). A combining tonos or dialytika, the accent of
|
||||
/// decomposed text, is ignored like the accent of a precomposed letter, but only straight after
|
||||
/// the Greek letter it accents and once each: anywhere else the word is not Greek-layout typing.
|
||||
pub fn latin_keys(word: &str) -> Option<String> {
|
||||
let mut greek = false;
|
||||
// What the previous Greek letter already carries (tonos, dialytika); `None` when the previous
|
||||
// character is not a Greek letter, which leaves a combining mark nothing to accent.
|
||||
let mut marks: Option<(bool, bool)> = None;
|
||||
let mut out = String::with_capacity(word.len());
|
||||
for c in word.chars() {
|
||||
if matches!(c, '\u{301}' | '\u{308}') {
|
||||
let (tonos, dialytika) = marks.as_mut()?;
|
||||
if std::mem::replace(if c == '\u{301}' { tonos } else { dialytika }, true) {
|
||||
return None;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if c.is_ascii() {
|
||||
// The Q key types the ASCII semicolon in the Greek layout; every other ASCII character is itself.
|
||||
out.push(if c == ';' { 'q' } else { c.to_ascii_lowercase() });
|
||||
marks = None;
|
||||
continue;
|
||||
}
|
||||
let lower = c.to_lowercase().next().unwrap_or(c);
|
||||
out.push(key_of(lower)?);
|
||||
let letter = is_greek_letter(lower);
|
||||
greek |= letter;
|
||||
marks = letter.then_some((false, false));
|
||||
}
|
||||
greek.then_some(out)
|
||||
}
|
||||
|
||||
/// `word` with its case, accents and final sigma folded away, when it is Greek-layout typing: every
|
||||
/// spelling of one Greek word gives the same string. It is the word's keys, with the final sigma
|
||||
/// read as the letter sigma instead of the W key.
|
||||
pub fn greek_fold(word: &str) -> Option<String> {
|
||||
latin_keys(&word.replace('ς', "σ"))
|
||||
}
|
||||
|
||||
/// Whether `a` and `b` are one Greek word, whatever their case, accents or final sigma.
|
||||
pub fn same_greek_word(a: &str, b: &str) -> bool {
|
||||
same_greek_word_as(b).is_some_and(|same| same(a))
|
||||
}
|
||||
|
||||
/// A test for "is the Greek word `word`, whatever the case, accents or final sigma", or `None`
|
||||
/// when `word` is not Greek-layout typing. `word` is folded here, once: looking a typed word up
|
||||
/// among many names costs its length once, not once for every name.
|
||||
pub fn same_greek_word_as(word: &str) -> Option<impl Fn(&str) -> bool> {
|
||||
let fold = greek_fold(word)?;
|
||||
Some(move |name: &str| greek_fold(name).as_deref() == Some(fold.as_str()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{latin_keys, same_greek_word};
|
||||
|
||||
/// One Greek word compares equal in any case, accent or final sigma; another word, or a Latin
|
||||
/// one, does not.
|
||||
#[test]
|
||||
fn one_greek_word_is_the_same_in_any_case_accent_or_final_sigma() {
|
||||
for (a, b) in [("ΣΟΛΙΔ", "σολιδ"), ("ΣΟΛΙΔ", "σολίδ"), ("ΛΑΣ", "λας"), ("ΛΑΣ", "λασ"), ("ΛΙ\u{301}ΝΕ", "λινε")]
|
||||
{
|
||||
assert!(same_greek_word(a, b), "{a} {b}");
|
||||
}
|
||||
for (a, b) in [("ΣΟΛΙΔ", "ΣΟΛΙ"), ("ΣΟΛΙΔ", "solid"), ("solid", "SOLID")] {
|
||||
assert!(!same_greek_word(a, b), "{a} {b}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A character the layout does not type is never taken for the Greek letter Unicode upper-cases
|
||||
/// it to: the micro sign is not μ, the long s and the sharp s are not σ, an alpha with an iota
|
||||
/// subscript is not αι, the theta symbol is not θ.
|
||||
#[test]
|
||||
fn a_character_the_layout_does_not_type_is_no_spelling_of_a_greek_letter() {
|
||||
let pairs = [("\u{b5}", "μ"), ("Λ\u{17f}", "ΛΣ"), ("Λ\u{df}", "ΛΣΣ"), ("\u{1fb3}", "αι"), ("\u{3d1}", "θ")];
|
||||
let same: Vec<_> = pairs.iter().filter(|(a, b)| same_greek_word(a, b) || same_greek_word(b, a)).collect();
|
||||
assert!(same.is_empty(), "{same:?}");
|
||||
}
|
||||
|
||||
/// Greek-layout typing reads as its Latin keys: plain, accented and decomposed letters, the Q
|
||||
/// and W keys, ASCII prefixes.
|
||||
#[test]
|
||||
fn greek_layout_commands_read_as_their_latin_keys() {
|
||||
assert_eq!(latin_keys("ΛΙΝΕ").as_deref(), Some("line"));
|
||||
assert_eq!(latin_keys("λινε").as_deref(), Some("line"));
|
||||
assert_eq!(latin_keys("ΣΤΡΕΤΨΗ").as_deref(), Some("stretch"));
|
||||
assert_eq!(latin_keys("ΜΙΡΡΟΡ").as_deref(), Some("mirror"));
|
||||
assert_eq!(latin_keys("ΘΝΔΟ").as_deref(), Some("undo"));
|
||||
// The Q key types ";", the W key the final sigma.
|
||||
assert_eq!(latin_keys(";ΣΑΩΕ").as_deref(), Some("qsave"));
|
||||
assert_eq!(latin_keys("ςΒΛΟΨΚ").as_deref(), Some("wblock"));
|
||||
// Accented letters (the layout's dead key) read as the plain letter.
|
||||
assert_eq!(latin_keys("ΛΊΝΕ").as_deref(), Some("line"));
|
||||
assert_eq!(latin_keys("ΆΡΡΑΥ").as_deref(), Some("array"));
|
||||
// The same accents written as a combining mark after the letter (decomposed text).
|
||||
assert_eq!(latin_keys("ΛΙ\u{301}ΝΕ").as_deref(), Some("line"));
|
||||
assert_eq!(latin_keys("ΛΙΝΕ\u{301}").as_deref(), Some("line"));
|
||||
assert_eq!(latin_keys("ΛΙ\u{308}ΝΕ").as_deref(), Some("line"));
|
||||
assert_eq!(latin_keys("ΛΙ\u{308}\u{301}ΝΕ").as_deref(), Some("line"), "dialytika and tonos on one letter");
|
||||
// Prefixes and digits are kept.
|
||||
assert_eq!(latin_keys("-ΛΑΥΕΡ").as_deref(), Some("-layer"));
|
||||
assert_eq!(latin_keys("_ΛΙΝΕ").as_deref(), Some("_line"));
|
||||
}
|
||||
|
||||
/// A word with no Greek letter, or with a character the layout does not type, is not read.
|
||||
#[test]
|
||||
fn words_that_are_not_greek_layout_typing_are_left_alone() {
|
||||
assert_eq!(latin_keys("line"), None, "no Greek letter");
|
||||
assert_eq!(latin_keys(""), None);
|
||||
assert_eq!(latin_keys(";"), None, "a semicolon alone is not a word");
|
||||
assert_eq!(latin_keys("ΛΙΝΕ Ж"), None, "a letter the layout does not type");
|
||||
assert_eq!(latin_keys("ΛΙΝΕ 日本"), None);
|
||||
assert_eq!(latin_keys("\u{387}"), None, "the ano teleia is punctuation, not a letter");
|
||||
}
|
||||
|
||||
/// A combining tonos or dialytika counts only straight after a Greek letter, and once each.
|
||||
#[test]
|
||||
fn a_combining_mark_must_follow_the_greek_letter_it_accents() {
|
||||
assert_eq!(latin_keys("\u{301}ΛΙΝΕ"), None, "no letter before the mark");
|
||||
assert_eq!(latin_keys("\u{308}ΛΙΝΕ"), None);
|
||||
assert_eq!(latin_keys("ΛΙΝΕ-\u{301}"), None, "after punctuation");
|
||||
assert_eq!(latin_keys("a\u{301}ΛΙΝΕ"), None, "after a Latin letter");
|
||||
assert_eq!(latin_keys("Λ\u{301}\u{301}ΙΝΕ"), None, "a second tonos on one letter");
|
||||
assert_eq!(latin_keys("Λ\u{308}\u{308}ΙΝΕ"), None, "a second dialytika on one letter");
|
||||
}
|
||||
|
||||
/// A 100 000-letter word and odd code points are read or refused; nothing panics.
|
||||
#[test]
|
||||
fn hostile_text_never_panics() {
|
||||
let long = "Ω".repeat(100_000);
|
||||
assert_eq!(latin_keys(&long).map(|s| s.len()), Some(100_000));
|
||||
for s in ["\u{0}", "\u{301}", "ΛΙΝΕ\u{301}", "\u{10ffff}", "ς\u{3c2}\u{3a3}"] {
|
||||
let _ = latin_keys(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -22,10 +22,12 @@ mod finite;
|
||||
pub mod grip_dims;
|
||||
pub mod grips;
|
||||
mod guard;
|
||||
pub mod keyboard;
|
||||
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;
|
||||
@@ -34,6 +36,7 @@ pub mod settings_dir;
|
||||
pub mod snap;
|
||||
pub mod spatial;
|
||||
pub mod sysvars;
|
||||
pub mod ucs;
|
||||
pub mod undoctl;
|
||||
pub mod units;
|
||||
|
||||
@@ -84,6 +87,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;
|
||||
@@ -175,6 +183,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(),
|
||||
@@ -230,17 +240,33 @@ impl Session {
|
||||
settings.snapunit = d.header.snap_unit();
|
||||
settings.gridunit = d.header.grid_unit();
|
||||
}
|
||||
let a = self.input_ucs().rotation();
|
||||
settings.ucs_angle = if a.is_finite() { a } else { 0.0 };
|
||||
settings
|
||||
}
|
||||
/// The space commands act on (model space while working inside a layout viewport).
|
||||
pub fn space(&self) -> Space {
|
||||
self.state().map(DocState::edit_space).unwrap_or_default()
|
||||
}
|
||||
/// The layers frozen in the active MSPACE viewport ([`DocState::viewport_frozen`]): what a
|
||||
/// pick or a selection in [`Session::space`] leaves out. Empty with no drawing open.
|
||||
pub fn viewport_frozen(&self) -> &[String] {
|
||||
self.state().map(DocState::viewport_frozen).unwrap_or_default()
|
||||
}
|
||||
/// The tab being displayed: Model or a layout, regardless of MSPACE.
|
||||
pub fn layout_space(&self) -> Space {
|
||||
self.state().map(|s| s.space.clone()).unwrap_or_default()
|
||||
}
|
||||
/// The selected objects as the view being edited has them ([`DocState::shown_selection`]):
|
||||
/// inside an MSPACE viewport, without the objects on layers frozen in that viewport. Commands,
|
||||
/// grips and palettes start from this; [`DocState::selection`] holds every selected object.
|
||||
pub fn selection(&self) -> Vec<Handle> {
|
||||
self.state().map(DocState::shown_selection).unwrap_or_default()
|
||||
}
|
||||
/// Every selected object ([`DocState::selection`]), also the ones the active MSPACE viewport
|
||||
/// does not draw, which [`Session::selection`] leaves out. Adding to the selection or removing
|
||||
/// from it starts from this, so that it keeps them.
|
||||
pub(crate) fn stored_selection(&self) -> Vec<Handle> {
|
||||
self.state().map(|s| s.selection.clone()).unwrap_or_default()
|
||||
}
|
||||
pub fn set_selection(&mut self, sel: Vec<Handle>) {
|
||||
|
||||
@@ -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) {
|
||||
@@ -534,7 +558,7 @@ impl Session {
|
||||
/// A routine waits for the user's answer to a `get…` function: its prompt.
|
||||
pub(crate) fn lisp_prompt(&self) -> Option<Prompt> {
|
||||
match self.lisp.run.as_ref()?.waiting.as_ref()? {
|
||||
Need::Get(req) => Some(req.prompt()),
|
||||
Need::Get(req) => Some(req.prompt(&self.input_ucs())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
@@ -545,10 +569,15 @@ impl Session {
|
||||
let Need::Get(req) = self.lisp.run.as_ref()?.waiting.as_ref()? else { return None };
|
||||
let line =
|
||||
|a: cadcraft_geom::Vec2, b: cadcraft_geom::Vec2| cadcraft_doc::EntityKind::Line(cadcraft_doc::Line { a: a.to3(0.0), b: b.to3(0.0) });
|
||||
let Some(b) = req.first.or(req.base).map(|p| cadcraft_geom::Vec2::new(p[0], p[1])) else { return Some(Vec::new()) };
|
||||
// The base is a UCS point (as the routine gave it); the preview is drawn in world space.
|
||||
let ucs = self.input_ucs();
|
||||
let Some(bu) = req.first.or(req.base).map(|p| cadcraft_geom::Vec2::new(p[0], p[1])) else { return Some(Vec::new()) };
|
||||
let b = ucs.to_wcs(bu);
|
||||
Some(match req.kind {
|
||||
input::GetKind::Corner => {
|
||||
let (c1, c2) = (cadcraft_geom::Vec2::new(cursor.x, b.y), cadcraft_geom::Vec2::new(b.x, cursor.y));
|
||||
// The rectangle runs along the UCS axes, as the corner it returns is measured.
|
||||
let cu = ucs.to_ucs(cursor);
|
||||
let (c1, c2) = (ucs.to_wcs(cadcraft_geom::Vec2::new(cu.x, bu.y)), ucs.to_wcs(cadcraft_geom::Vec2::new(bu.x, cu.y)));
|
||||
vec![line(b, c1), line(c1, cursor), line(cursor, c2), line(c2, b)]
|
||||
}
|
||||
input::GetKind::Point | input::GetKind::Dist | input::GetKind::Angle { .. } => vec![line(b, cursor)],
|
||||
@@ -727,6 +756,8 @@ fn file_key(name: &str) -> String {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
#[cfg(test)]
|
||||
mod ucs_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod block_tests;
|
||||
|
||||
@@ -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_dxf::Tag;
|
||||
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)),
|
||||
@@ -114,10 +117,14 @@ pub fn command(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
Value::PickSet(p) => feed(ctx.s, Input::Pick(items(p))),
|
||||
Value::Cons(_) => {
|
||||
if let Some(p) = arg.as_point() {
|
||||
feed(ctx.s, Input::Point(Vec2::new(p[0], p[1])));
|
||||
// A routine's points are in the current UCS, as typed ones are.
|
||||
let w = ctx.s.input_ucs().to_wcs(Vec2::new(p[0], p[1]));
|
||||
feed(ctx.s, Input::Point(w));
|
||||
} else if let Value::Ename(h) = arg.car() {
|
||||
// An `entsel` result: (ename point).
|
||||
named(ctx.s, h, arg.cdr().car().as_point().map(|p| Vec2::new(p[0], p[1])));
|
||||
// The pick point is what `entsel` gave: a UCS point, like the ones above.
|
||||
let frame = ctx.s.input_ucs();
|
||||
named(ctx.s, h, arg.cdr().car().as_point().map(|p| frame.to_wcs(Vec2::new(p[0], p[1]))));
|
||||
} else {
|
||||
return Err(LispError::bad_arg("command argument", arg));
|
||||
}
|
||||
@@ -253,25 +260,25 @@ fn convert_angles(kind: &str, tags: &mut [Tag], f: fn(f64) -> f64) {
|
||||
continue;
|
||||
}
|
||||
let v = match t.value {
|
||||
cadcraft_dxf::Value::Real(r) => r,
|
||||
cadcraft_dxf::Value::Int(i) => i as f64,
|
||||
craft_dxf::Value::Real(r) => r,
|
||||
craft_dxf::Value::Int(i) => i as f64,
|
||||
_ => continue,
|
||||
};
|
||||
t.value = cadcraft_dxf::Value::Real(f(v));
|
||||
t.value = craft_dxf::Value::Real(f(v));
|
||||
}
|
||||
}
|
||||
|
||||
fn tag_value(t: &Tag) -> Value {
|
||||
match &t.value {
|
||||
cadcraft_dxf::Value::Str(s) | cadcraft_dxf::Value::Hex(s) => Value::str(s),
|
||||
cadcraft_dxf::Value::Real(r) => Value::Real(*r),
|
||||
cadcraft_dxf::Value::Int(i) => Value::Int(i32::try_from(*i).unwrap_or(if *i < 0 { i32::MIN } else { i32::MAX })),
|
||||
cadcraft_dxf::Value::Bool(b) => Value::Int(i32::from(*b)),
|
||||
craft_dxf::Value::Str(s) | craft_dxf::Value::Hex(s) => Value::str(s),
|
||||
craft_dxf::Value::Real(r) => Value::Real(*r),
|
||||
craft_dxf::Value::Int(i) => Value::Int(i32::try_from(*i).unwrap_or(if *i < 0 { i32::MIN } else { i32::MAX })),
|
||||
craft_dxf::Value::Bool(b) => Value::Int(i32::from(*b)),
|
||||
}
|
||||
}
|
||||
|
||||
/// 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 +363,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 +380,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 +508,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 +520,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 +528,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 +580,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 +659,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 +683,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 ----------------
|
||||
@@ -628,10 +718,13 @@ pub fn ssget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
}
|
||||
_ => (rest, None),
|
||||
};
|
||||
// The points are UCS points, as `getpoint` and `getcorner` give them: the selection runs in
|
||||
// the world.
|
||||
let frame = ctx.s.input_ucs();
|
||||
let point = |i: usize| -> Result<Vec2, LispError> {
|
||||
let v = pts.get(i).ok_or_else(|| args_err(true))?;
|
||||
let p = v.as_point().ok_or_else(|| LispError::bad_arg("2D/3D point", v))?;
|
||||
Ok(Vec2::new(p[0], p[1]))
|
||||
Ok(frame.to_wcs(Vec2::new(p[0], p[1])))
|
||||
};
|
||||
let s = &mut *ctx.s;
|
||||
let all = |s: &Session, all_spaces: bool| -> Vec<Handle> {
|
||||
@@ -651,24 +744,30 @@ pub fn ssget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
Some("X") => all(s, true),
|
||||
Some("L") => {
|
||||
let order = handles_in_order(ctx);
|
||||
order.last().copied().into_iter().collect()
|
||||
// Inside an MSPACE viewport, the objects that viewport does not draw are passed over.
|
||||
let st = ctx.s.state().ok();
|
||||
let drawn = |h: &Handle| st.is_none_or(|st| st.doc.entity(*h).is_none_or(|e| !st.hidden_in_viewport(e)));
|
||||
order.iter().rev().copied().find(drawn).into_iter().collect()
|
||||
}
|
||||
Some("P") => ctx.s.state().map(|st| st.previous_selection.clone()).unwrap_or_default(),
|
||||
Some("P") => ctx.s.state().map(|st| st.drawn_in_viewport(&st.previous_selection)).unwrap_or_default(),
|
||||
Some("I") => ctx.s.selection(),
|
||||
Some("W") | Some("C") => {
|
||||
// A selection window is the box around its corners in the world, like SELECT's: the
|
||||
// same corners typed at either pick the same objects.
|
||||
let (p1, p2) = (point(0)?, point(1)?);
|
||||
let s = &*ctx.s;
|
||||
let Ok(d) = s.doc() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
crate::select::select_window(d, &space, cadcraft_geom::Bounds2::from_points([p1, p2]), mode.as_deref() == Some("C"))
|
||||
let bx = cadcraft_geom::Bounds2::from_points([p1, p2]);
|
||||
crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, mode.as_deref() == Some("C"))
|
||||
}
|
||||
Some("F") | Some("WP") | Some("CP") => {
|
||||
let poly: Vec<Vec2> =
|
||||
pts.first().map(|l| l.iter().filter_map(|p| p.as_point().map(|q| Vec2::new(q[0], q[1]))).collect()).unwrap_or_default();
|
||||
pts.first().map(|l| l.iter().filter_map(|p| p.as_point().map(|q| frame.to_wcs(Vec2::new(q[0], q[1])))).collect()).unwrap_or_default();
|
||||
let s = &*ctx.s;
|
||||
let Ok(d) = s.doc() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
match mode.as_deref() {
|
||||
Some("F") => crate::select::select_fence(d, &space, &poly),
|
||||
m => crate::select::select_polygon(d, &space, &poly, m == Some("CP")),
|
||||
Some("F") => crate::select::select_fence_in(d, &space, s.viewport_frozen(), &poly),
|
||||
m => crate::select::select_polygon_in(d, &space, s.viewport_frozen(), &poly, m == Some("CP")),
|
||||
}
|
||||
}
|
||||
Some(":S") | Some("A") | None => {
|
||||
@@ -684,7 +783,7 @@ pub fn ssget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
let s = &*ctx.s;
|
||||
let ap = s.settings.pickbox.max(1.0) * s.pixel_size();
|
||||
let Ok(d) = s.doc() else { return Ok(Flow::Value(Value::Nil)) };
|
||||
crate::select::pick(d, &space, p, ap).into_iter().collect()
|
||||
crate::select::pick_in(d, &space, s.viewport_frozen(), p, ap).into_iter().collect()
|
||||
}
|
||||
}
|
||||
Some(m) => return Err(LispError::new(format!("bad argument value: ssget mode {m}"))),
|
||||
@@ -988,12 +1087,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
|
||||
@@ -1108,7 +1212,8 @@ pub fn distof(_ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
pub fn angtof(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 1, 2)?;
|
||||
let s = string(&a[0])?;
|
||||
let mut settings = ctx.s.angle_settings();
|
||||
// A pure string-to-angle conversion: ANGBASE and ANGDIR apply, the UCS does not.
|
||||
let mut settings = ctx.s.angle_settings().world();
|
||||
// AUNITS 0..=4; any other units argument is an error in AutoCAD, nil here.
|
||||
match a.get(1) {
|
||||
None | Some(Value::Nil) => {}
|
||||
@@ -1118,11 +1223,67 @@ pub fn angtof(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
Ok(Flow::Value(settings.direction(&s).map(Value::Real).unwrap_or_default()))
|
||||
}
|
||||
|
||||
/// `(trans pt from to [disp])`: points are in the world system throughout (no UCS yet).
|
||||
pub fn trans(_ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
/// A coordinate system `trans` converts from or to: its origin and axes in world coordinates.
|
||||
fn trans_system(ctx: &Ctx<'_>, v: &Value) -> Result<crate::ucs::UcsFrame, LispError> {
|
||||
use crate::ucs::UcsFrame;
|
||||
match v {
|
||||
// 0 the WCS; 3 paper space's display system, which lines up with paper space's WCS.
|
||||
Value::Int(0 | 3) => Ok(UcsFrame::WORLD),
|
||||
// 2 the display system: in a plan view, the WCS turned back by the view's twist (X runs
|
||||
// right across the screen).
|
||||
Value::Int(2) => {
|
||||
let twist = cadcraft_geom::norm_angle(ctx.s.state().map_or(0.0, |st| st.view().twist));
|
||||
Ok(UcsFrame::WORLD.rotated_z(-twist))
|
||||
}
|
||||
Value::Int(1) => Ok(ctx.s.input_ucs()),
|
||||
// An object: its OCS.
|
||||
Value::Ename(h) => {
|
||||
let d = ctx.s.doc().map_err(|e| LispError::new(e.to_string()))?;
|
||||
let e = d.entity(*h).ok_or_else(|| LispError::bad_arg("lentityp", v))?;
|
||||
ocs(e.common.extrusion).ok_or_else(|| LispError::bad_arg("lentityp", v))
|
||||
}
|
||||
// An extrusion direction: the OCS of objects with it.
|
||||
Value::Cons(_) => {
|
||||
let n = v.as_point().ok_or_else(|| LispError::bad_arg("coordinate system", v))?;
|
||||
ocs(cadcraft_geom::Vec3::new(n[0], n[1], n[2])).ok_or_else(|| LispError::bad_arg("coordinate system", v))
|
||||
}
|
||||
other => Err(LispError::bad_arg("coordinate system", other)),
|
||||
}
|
||||
}
|
||||
|
||||
/// The object coordinate system of extrusion direction `n` (the arbitrary axis algorithm of the
|
||||
/// DXF Reference): `None` for a direction with no length.
|
||||
fn ocs(n: cadcraft_geom::Vec3) -> Option<crate::ucs::UcsFrame> {
|
||||
use cadcraft_geom::Vec3;
|
||||
let l = n.len();
|
||||
if !(l > 1e-12 && l.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
let n = n * (1.0 / l);
|
||||
let w = if n.x.abs() < 1.0 / 64.0 && n.y.abs() < 1.0 / 64.0 { Vec3::new(0.0, 1.0, 0.0) } else { Vec3::Z };
|
||||
let ax = w.cross(n);
|
||||
crate::ucs::UcsFrame::new(Vec3::ZERO, ax, n.cross(ax))
|
||||
}
|
||||
|
||||
/// `(trans pt from to [disp])`: `pt` from coordinate system `from` to `to` (0 WCS, 1 UCS, 2 and 3
|
||||
/// display, an entity name for its OCS, or an extrusion direction); with `disp` non-nil `pt` is a
|
||||
/// displacement, which the systems' origins don't move.
|
||||
pub fn trans(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
|
||||
arity(&a, 3, 4)?;
|
||||
let p = a[0].as_point().ok_or_else(|| LispError::bad_arg("2D/3D point", &a[0]))?;
|
||||
Ok(Flow::Value(Value::point(&p)))
|
||||
let (from, to) = (trans_system(ctx, &a[1])?, trans_system(ctx, &a[2])?);
|
||||
let disp = a.get(3).is_some_and(|v| !v.is_nil());
|
||||
let p = cadcraft_geom::Vec3::new(p[0], p[1], p[2]);
|
||||
let q = if disp {
|
||||
let w = from.x * p.x + from.y * p.y + from.z() * p.z;
|
||||
cadcraft_geom::Vec3::new(w.dot(to.x), w.dot(to.y), w.dot(to.z()))
|
||||
} else {
|
||||
to.to_ucs3(from.to_wcs3(p))
|
||||
};
|
||||
if !q.is_finite() {
|
||||
return Err(LispError::bad_arg("2D/3D point", &a[0]));
|
||||
}
|
||||
Ok(Flow::Value(Value::point(&[q.x, q.y, q.z])))
|
||||
}
|
||||
|
||||
/// What `(load name)` reads: a file loaded through APPLOAD (the web), or one on disk, with
|
||||
|
||||
@@ -49,8 +49,8 @@ pub struct GetRequest {
|
||||
}
|
||||
|
||||
impl GetRequest {
|
||||
/// The prompt the command line shows.
|
||||
pub fn prompt(&self) -> Prompt {
|
||||
/// The prompt the command line shows (`ucs`: the UCS the routine's points are in).
|
||||
pub fn prompt(&self, ucs: &crate::ucs::UcsFrame) -> Prompt {
|
||||
let any = self.initget.bits & 128 != 0 || !self.initget.keywords.is_empty();
|
||||
let accept = match self.kind {
|
||||
GetKind::Point | GetKind::Corner | GetKind::EntSel => Accept { text: any, ..Accept::POINT },
|
||||
@@ -63,7 +63,7 @@ impl GetRequest {
|
||||
(None, true) => default_message(self.kind).to_string(),
|
||||
(None, false) => self.message.clone(),
|
||||
};
|
||||
let base = self.first.or(self.base).map(|p| Vec2::new(p[0], p[1]));
|
||||
let base = self.first.or(self.base).map(|p| ucs.to_wcs(Vec2::new(p[0], p[1])));
|
||||
let mut p = Prompt::new(message, accept).base_opt(base);
|
||||
p.keywords = self.initget.keywords.clone();
|
||||
p.raw = true;
|
||||
@@ -106,11 +106,21 @@ impl GetRequest {
|
||||
Ok(Value::Nil)
|
||||
}
|
||||
Input::Keyword(k) => Ok(Value::str(&k)),
|
||||
Input::Point(p) => self.point(s, [p.x, p.y, 0.0]),
|
||||
// Points come back in the current UCS, on its XY plane.
|
||||
Input::Point(p) => {
|
||||
let u = s.ucs_point(p);
|
||||
self.point(s, [u.x, u.y, 0.0])
|
||||
}
|
||||
// A deferred tangent/perpendicular snap is the point it was picked at here.
|
||||
Input::Deferred(d) => self.point(s, [d.at.x, d.at.y, 0.0]),
|
||||
Input::Deferred(d) => {
|
||||
let u = s.ucs_point(d.at);
|
||||
self.point(s, [u.x, u.y, 0.0])
|
||||
}
|
||||
Input::Pick(hs) => match (self.kind, hs.first()) {
|
||||
(GetKind::EntSel, Some(h)) => Ok(Value::list(vec![Value::Ename(*h), Value::point(&[s.last_point.x, s.last_point.y, 0.0])])),
|
||||
(GetKind::EntSel, Some(h)) => {
|
||||
let u = s.ucs_point(s.last_point);
|
||||
Ok(Value::list(vec![Value::Ename(*h), Value::point(&[u.x, u.y, 0.0])]))
|
||||
}
|
||||
_ => Err("Invalid point.".into()),
|
||||
},
|
||||
Input::Text(t) => self.text(s, &t),
|
||||
@@ -141,7 +151,8 @@ impl GetRequest {
|
||||
let ap = s.settings.pickbox.max(1.0) * s.pixel_size();
|
||||
let space = s.state().map(|st| st.edit_space()).map_err(|e| Again::Msg(e.to_string()))?;
|
||||
let d = s.doc().map_err(|e| Again::Msg(e.to_string()))?;
|
||||
match crate::select::pick(d, &space, Vec2::new(p[0], p[1]), ap) {
|
||||
// `p` is in the UCS; objects are picked at the world point.
|
||||
match crate::select::pick_in(d, &space, s.viewport_frozen(), s.input_ucs().to_wcs(Vec2::new(p[0], p[1])), ap) {
|
||||
Some(h) => Ok(Value::list(vec![Value::Ename(h), Value::point(&p)])),
|
||||
None => Err("Missed, try again.".into()),
|
||||
}
|
||||
@@ -187,6 +198,8 @@ impl GetRequest {
|
||||
},
|
||||
GetKind::Angle { orient } => match s.angle_settings().direction(t) {
|
||||
Some(a) => {
|
||||
// Measured in the UCS, as an angle from two points is.
|
||||
let a = a - s.angle_settings().ucs;
|
||||
let a = if orient { a } else { a - s.lisp_angbase() };
|
||||
self.check_number(a.rem_euclid(std::f64::consts::TAU), false)
|
||||
}
|
||||
|
||||
@@ -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,284 @@
|
||||
//! AutoLISP in a UCS (#1106): `getpoint` and friends answer in the current UCS, `command` takes
|
||||
//! UCS points, `trans` converts between the WCS, the UCS, display coordinates and an object's
|
||||
//! OCS, and entity lists stay in world coordinates.
|
||||
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use cadcraft_geom::Vec2;
|
||||
use serde_json::json;
|
||||
|
||||
use super::value::to_text;
|
||||
use crate::Session;
|
||||
use crate::cmd::file::{EntityCodec, set_entity_codec};
|
||||
|
||||
fn session() -> Session {
|
||||
set_entity_codec(EntityCodec { groups: cadcraft_io::entity_groups, entity: cadcraft_io::entity_from_groups });
|
||||
let mut s = Session::new();
|
||||
s.new_drawing(false);
|
||||
s
|
||||
}
|
||||
|
||||
fn ok(s: &mut Session, code: &str) -> String {
|
||||
match s.lisp_eval(code, false, true, Vec::new()) {
|
||||
Ok(Some(Ok(v))) => to_text(&v, true),
|
||||
other => panic!("{code}: {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn err(s: &mut Session, code: &str) -> bool {
|
||||
matches!(s.lisp_eval(code, false, true, Vec::new()), Ok(Some(Err(_))) | Err(_))
|
||||
}
|
||||
|
||||
/// The three numbers of a printed point.
|
||||
fn pt(text: &str) -> [f64; 3] {
|
||||
let v: Vec<f64> = text.trim_matches(['(', ')']).split_whitespace().map(|x| x.parse().unwrap()).collect();
|
||||
[v[0], v[1], v.get(2).copied().unwrap_or(0.0)]
|
||||
}
|
||||
|
||||
fn close(a: [f64; 3], b: [f64; 3]) -> bool {
|
||||
a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9)
|
||||
}
|
||||
|
||||
/// The UCS at (100, 50) turned 90° (UCS X is world +Y).
|
||||
fn turned(s: &mut Session) {
|
||||
s.execute("ucs", &json!({"option": "origin", "origin": [100, 50]})).unwrap();
|
||||
s.execute("ucs", &json!({"option": "z", "angle": 90})).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trans_between_world_ucs_and_display() {
|
||||
let mut s = session();
|
||||
turned(&mut s);
|
||||
// UCS (10, 0) is world (100, 60).
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(10 0 0) 1 0)")), [100.0, 60.0, 0.0]));
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(100 60 0) 0 1)")), [10.0, 0.0, 0.0]));
|
||||
// A 2D point is at Z 0.
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(10 0) 1 0)")), [100.0, 60.0, 0.0]));
|
||||
// Displacements turn but don't move.
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(10 0 0) 1 0 T)")), [0.0, 10.0, 0.0]));
|
||||
// The display system lines up with the world one in a plan view.
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(10 0 0) 1 2)")), [100.0, 60.0, 0.0]));
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(3 4 5) 2 0)")), [3.0, 4.0, 5.0]));
|
||||
// UCS → UCS and back is the identity.
|
||||
assert!(close(pt(&ok(&mut s, "(trans (trans '(7 -3 2) 1 0) 0 1)")), [7.0, -3.0, 2.0]));
|
||||
// In a view twisted 90° counterclockwise, world +X points up the screen and world -Y runs
|
||||
// right across it: display X.
|
||||
s.execute("dview", &json!({"twist": 90.0})).unwrap();
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(0 -10 0) 0 2)")), [10.0, 0.0, 0.0]));
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(10 0 0) 2 0)")), [0.0, -10.0, 0.0]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trans_to_and_from_an_objects_ocs() {
|
||||
let mut s = session();
|
||||
// A circle in the world XY plane: its OCS is the WCS.
|
||||
ok(&mut s, "(command \"_.CIRCLE\" '(5 5) 2)");
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(5 5 0) 0 (entlast))")), [5.0, 5.0, 0.0]));
|
||||
// An extrusion direction straight up is the WCS too; one along +X follows the arbitrary
|
||||
// axis algorithm (OCS X = world Y × N = (0, 0, -1)... the DXF Reference's rule).
|
||||
assert!(close(pt(&ok(&mut s, "(trans '(1 2 3) '(0 0 1) 0)")), [1.0, 2.0, 3.0]));
|
||||
let w = pt(&ok(&mut s, "(trans '(1 0 0) '(1 0 0) 0)"));
|
||||
assert!(close(w, [0.0, 1.0, 0.0]), "{w:?}");
|
||||
let back = pt(&ok(&mut s, "(trans (trans '(1 2 3) '(1 0 0) 0) 0 '(1 0 0))"));
|
||||
assert!(close(back, [1.0, 2.0, 3.0]), "{back:?}");
|
||||
// Bad systems and points are errors, not crashes.
|
||||
for bad in [
|
||||
"(trans '(1 2) 7 0)",
|
||||
"(trans '(1 2) \"x\" 0)",
|
||||
"(trans '(1 2) '(0 0 0) 0)",
|
||||
"(trans \"p\" 0 1)",
|
||||
"(trans '(1 2) 0)",
|
||||
"(trans '(1e308 1e308) '(1e-320 0 0) 0)",
|
||||
] {
|
||||
assert!(err(&mut s, bad), "{bad}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getpoint_answers_in_the_ucs_and_command_reads_ucs_points() {
|
||||
let mut s = session();
|
||||
turned(&mut s);
|
||||
s.cmdline("(setq p (getpoint))").unwrap();
|
||||
// The user clicks world (100, 60): the routine gets UCS (10, 0).
|
||||
s.input(crate::Input::Point(Vec2::new(100.0, 60.0))).unwrap();
|
||||
assert!(close(pt(&to_text(&s.lisp_var("P"), true)), [10.0, 0.0, 0.0]), "{}", to_text(&s.lisp_var("P"), true));
|
||||
// Typed at getpoint: read in the UCS, given back in it.
|
||||
s.cmdline("(setq q (getpoint))").unwrap();
|
||||
s.cmdline("3,4").unwrap();
|
||||
assert!(close(pt(&to_text(&s.lisp_var("Q"), true)), [3.0, 4.0, 0.0]));
|
||||
// `command` takes those points as UCS points: the line lands at the world places clicked.
|
||||
ok(&mut s, "(command \"_.LINE\" p q \"\")");
|
||||
let d = s.doc().unwrap();
|
||||
let l = d.model.iter().find_map(|e| if let cadcraft_doc::EntityKind::Line(l) = &e.kind { Some(l.clone()) } else { None }).unwrap();
|
||||
assert!(l.a.xy().dist(Vec2::new(100.0, 60.0)) < 1e-9 && l.b.xy().dist(Vec2::new(96.0, 53.0)) < 1e-9, "{l:?}");
|
||||
// Entity lists stay in world coordinates.
|
||||
let g = ok(&mut s, "(cdr (assoc 10 (entget (entlast))))");
|
||||
assert!(close(pt(&g), [100.0, 60.0, 0.0]), "{g}");
|
||||
// `!expr` at the command line is a UCS point too.
|
||||
s.cmdline("line").unwrap();
|
||||
s.cmdline("!p").unwrap();
|
||||
s.cmdline("!q").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
let n = s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, cadcraft_doc::EntityKind::Line(_))).count();
|
||||
assert_eq!(n, 2);
|
||||
let d = s.doc().unwrap();
|
||||
let last = d.model.iter().filter_map(|e| if let cadcraft_doc::EntityKind::Line(l) = &e.kind { Some(l.clone()) } else { None }).last().unwrap();
|
||||
assert!(last.a.xy().dist(Vec2::new(100.0, 60.0)) < 1e-9 && last.b.xy().dist(Vec2::new(96.0, 53.0)) < 1e-9, "{last:?}");
|
||||
}
|
||||
|
||||
/// The rubber band of `getpoint`/`getcorner` with a base point starts where that UCS point is in
|
||||
/// the world, and `getcorner`'s rectangle runs along the UCS axes.
|
||||
#[test]
|
||||
fn getpoint_and_getcorner_previews_start_at_the_ucs_base() {
|
||||
let ends = |k: &cadcraft_doc::EntityKind| match k {
|
||||
cadcraft_doc::EntityKind::Line(l) => (l.a.xy(), l.b.xy()),
|
||||
other => panic!("{other:?}"),
|
||||
};
|
||||
let near = |a: Vec2, b: Vec2| a.dist(b) < 1e-9;
|
||||
let mut s = session();
|
||||
turned(&mut s);
|
||||
// UCS (0, 0) is world (100, 50); the cursor is at world (90, 70), UCS (20, 10).
|
||||
let cursor = Vec2::new(90.0, 70.0);
|
||||
s.cmdline("(setq p (getpoint '(0 0)))").unwrap();
|
||||
let band = s.lisp_preview(cursor).unwrap();
|
||||
assert_eq!(band.len(), 1);
|
||||
let (a, b) = ends(&band[0]);
|
||||
assert!(near(a, Vec2::new(100.0, 50.0)) && near(b, cursor), "{a:?} {b:?}");
|
||||
s.input(crate::Input::Point(cursor)).unwrap();
|
||||
s.cmdline("(setq c (getcorner '(0 0)))").unwrap();
|
||||
let rect: Vec<(Vec2, Vec2)> = s.lisp_preview(cursor).unwrap().iter().map(ends).collect();
|
||||
// Along UCS X (world +Y) to UCS (20, 0), the cursor, UCS (0, 10) (world (90, 50)), back.
|
||||
let want = [(100.0, 50.0), (100.0, 70.0), (90.0, 70.0), (90.0, 50.0)].map(|(x, y)| Vec2::new(x, y));
|
||||
assert_eq!(rect.len(), 4);
|
||||
for (i, (a, b)) in rect.iter().enumerate() {
|
||||
assert!(near(*a, want[i]) && near(*b, want[(i + 1) % 4]), "side {i}: {a:?} {b:?}");
|
||||
}
|
||||
s.input(crate::Input::Point(cursor)).unwrap();
|
||||
assert!(close(pt(&to_text(&s.lisp_var("C"), true)), [20.0, 10.0, 0.0]), "the corner it returns, in the UCS");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn getangle_and_getdist_measure_in_the_ucs() {
|
||||
let mut s = session();
|
||||
turned(&mut s);
|
||||
// Two clicks one above the other in the world: along the UCS X axis, angle 0.
|
||||
s.cmdline("(setq a (getangle))").unwrap();
|
||||
s.input(crate::Input::Point(Vec2::new(100.0, 50.0))).unwrap();
|
||||
s.input(crate::Input::Point(Vec2::new(100.0, 70.0))).unwrap();
|
||||
let a: f64 = to_text(&s.lisp_var("A"), true).parse().unwrap();
|
||||
assert!(a.abs() < 1e-6 || (a - std::f64::consts::TAU).abs() < 1e-6, "{a}");
|
||||
// A typed angle is measured in the UCS as well.
|
||||
s.cmdline("(setq b (getangle))").unwrap();
|
||||
s.cmdline("45").unwrap();
|
||||
let b: f64 = to_text(&s.lisp_var("B"), true).parse().unwrap();
|
||||
assert!((b - std::f64::consts::FRAC_PI_4).abs() < 1e-6, "{b} (printed to 6 places)");
|
||||
// Distances don't depend on the UCS.
|
||||
s.cmdline("(setq d (getdist '(0 0)))").unwrap();
|
||||
s.cmdline("3,4").unwrap();
|
||||
assert_eq!(to_text(&s.lisp_var("D"), true), "5.0");
|
||||
// The UCS variables read from LISP.
|
||||
assert!(close(pt(&ok(&mut s, "(getvar \"UCSORG\")")), [100.0, 50.0, 0.0]));
|
||||
assert!(close(pt(&ok(&mut s, "(getvar \"UCSXDIR\")")), [0.0, 1.0, 0.0]));
|
||||
assert_eq!(ok(&mut s, "(getvar \"WORLDUCS\")"), "0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn entsel_and_getcorner_answer_in_the_ucs() {
|
||||
let mut s = session();
|
||||
s.execute("line", &json!({"points": [[100, 60], [100, 80]]})).unwrap();
|
||||
turned(&mut s);
|
||||
// entsel: the object, and the pick point in the UCS.
|
||||
s.cmdline("(setq e (entsel))").unwrap();
|
||||
s.input(crate::Input::Point(Vec2::new(100.0, 70.0))).unwrap();
|
||||
let v = to_text(&s.lisp_var("E"), true);
|
||||
assert!(v.contains("<Entity name"), "{v}");
|
||||
let p = ok(&mut s, "(cadr e)");
|
||||
assert!(close(pt(&p), [20.0, 0.0, 0.0]), "{p}");
|
||||
// entsel with the point typed in the UCS picks the object at its world place.
|
||||
s.cmdline("(setq e2 (entsel))").unwrap();
|
||||
s.cmdline("15,0").unwrap();
|
||||
assert!(to_text(&s.lisp_var("E2"), true).contains("<Entity name"), "{}", to_text(&s.lisp_var("E2"), true));
|
||||
// getcorner: the base point is a UCS point; the answer is in the UCS.
|
||||
s.cmdline("(setq c (getcorner '(0 0) \"Corner: \"))").unwrap();
|
||||
s.input(crate::Input::Point(Vec2::new(95.0, 60.0))).unwrap();
|
||||
assert!(close(pt(&to_text(&s.lisp_var("C"), true)), [10.0, 5.0, 0.0]), "{}", to_text(&s.lisp_var("C"), true));
|
||||
// A miss asks again rather than answering.
|
||||
s.cmdline("(setq e3 (entsel))").unwrap();
|
||||
s.input(crate::Input::Point(Vec2::new(500.0, 500.0))).unwrap();
|
||||
assert!(s.lisp_running(), "Missed, try again");
|
||||
s.cancel();
|
||||
}
|
||||
|
||||
fn model_lines(s: &Session) -> Vec<(Vec2, Vec2)> {
|
||||
s.doc()
|
||||
.unwrap()
|
||||
.model
|
||||
.iter()
|
||||
.filter_map(|e| if let cadcraft_doc::EntityKind::Line(l) = &e.kind { Some((l.a.xy(), l.b.xy())) } else { None })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The pick point of an `entsel` result handed to `command` is a UCS point, like the others.
|
||||
#[test]
|
||||
fn command_with_entsel_converts_the_pick_point_to_world() {
|
||||
let mut s = session();
|
||||
turned(&mut s);
|
||||
// World (100, 50) to (100, 150): UCS (0, 0) to (100, 0).
|
||||
s.execute("line", &json!({"points": [[100, 50], [100, 150]]})).unwrap();
|
||||
ok(&mut s, "(setq e (entlast))");
|
||||
// Break it from UCS (30, 0) to UCS (60, 0), picked the way `entsel` answers: (ename point).
|
||||
ok(&mut s, "(command \"_.BREAK\" (list e '(30 0)) '(60 0))");
|
||||
let mut l = model_lines(&s);
|
||||
l.sort_by(|a, b| a.0.y.total_cmp(&b.0.y));
|
||||
assert_eq!(l.len(), 2, "{l:?}");
|
||||
assert!(l[0].0.dist(Vec2::new(100.0, 50.0)) < 1e-9 && l[0].1.dist(Vec2::new(100.0, 80.0)) < 1e-9, "{l:?}");
|
||||
assert!(l[1].0.dist(Vec2::new(100.0, 110.0)) < 1e-9 && l[1].1.dist(Vec2::new(100.0, 150.0)) < 1e-9, "{l:?}");
|
||||
}
|
||||
|
||||
/// `ssget` windows, fences, polygons and single picks take UCS points, as `getpoint` gives them.
|
||||
#[test]
|
||||
fn ssget_window_takes_ucs_points() {
|
||||
let mut s = session();
|
||||
s.execute("ucs", &json!({"option": "origin", "origin": [1000, 1000]})).unwrap();
|
||||
s.execute("circle", &json!({"center": [1005, 1005], "radius": 1})).unwrap();
|
||||
s.execute("circle", &json!({"center": [5, 5], "radius": 1})).unwrap();
|
||||
assert_eq!(ok(&mut s, "(sslength (ssget \"W\" '(0 0) '(10 10)))"), "1");
|
||||
let found = ok(&mut s, "(cdr (assoc 10 (entget (ssname (ssget \"W\" '(0 0) '(10 10)) 0))))");
|
||||
assert!(close(pt(&found), [1005.0, 1005.0, 0.0]), "{found}");
|
||||
assert_eq!(ok(&mut s, "(sslength (ssget \"C\" '(-1 -1) '(11 11)))"), "1");
|
||||
assert_eq!(ok(&mut s, "(sslength (ssget \"WP\" '((0 0) (10 0) (10 10) (0 10))))"), "1");
|
||||
assert_eq!(ok(&mut s, "(sslength (ssget \"F\" '((0 0) (10 10))))"), "1");
|
||||
}
|
||||
|
||||
/// `angtof` converts text to radians: ANGBASE and ANGDIR apply, the UCS does not.
|
||||
#[test]
|
||||
fn angtof_ignores_the_ucs() {
|
||||
let mut s = session();
|
||||
turned(&mut s);
|
||||
assert_eq!(ok(&mut s, "(angtof \"0\")"), "0.0");
|
||||
assert_eq!(ok(&mut s, "(angtos (angtof \"45\"))"), "\"45\"");
|
||||
}
|
||||
|
||||
/// A selection window is the world box around its corners whatever the UCS: `ssget` and a SELECT
|
||||
/// window typed with the same corners pick the same objects.
|
||||
#[test]
|
||||
fn ssget_window_matches_select_in_a_turned_ucs() {
|
||||
let mut s = session();
|
||||
s.execute("ucs", &json!({"option": "z", "angle": 45})).unwrap();
|
||||
// The window's corners (UCS 0,0 and 10,4) are world (0,0) and (4.2,9.9): its world box.
|
||||
for c in [[3.0, 8.0], [1.0, 2.0], [0.0, 7.0], [5.0, 3.0], [40.0, 40.0]] {
|
||||
s.execute("circle", &json!({"center": c, "radius": 0.5})).unwrap();
|
||||
}
|
||||
let count = |s: &mut Session, w: &str| ok(s, &format!("(if (setq ss (ssget \"{w}\" '(0 0) '(10 4))) (sslength ss) 0)"));
|
||||
let (w, c) = (count(&mut s, "W"), count(&mut s, "C"));
|
||||
for (key, ssget) in [("w", w), ("c", c)] {
|
||||
s.cancel();
|
||||
s.cmdline("select").unwrap();
|
||||
s.cmdline(key).unwrap();
|
||||
s.cmdline("0,0").unwrap();
|
||||
s.cmdline("10,4").unwrap();
|
||||
s.cmdline("").unwrap();
|
||||
assert_ne!(ssget, "0", "window {key} finds something");
|
||||
assert_eq!(s.selection().len().to_string(), ssget, "window {key}");
|
||||
}
|
||||
}
|
||||
@@ -61,6 +61,13 @@ impl Axes {
|
||||
pub fn combine(self, first: Vec2, second: Vec2) -> Vec2 {
|
||||
Vec2::new(if self.x { first.x } else { second.x }, if self.y { first.y } else { second.y })
|
||||
}
|
||||
|
||||
/// [`Axes::combine`] with the coordinates read in the UCS `ucs`, where the user typed and saw
|
||||
/// the points: `.X` takes the first point's X along the UCS X axis, not the world's.
|
||||
pub fn combine_in(self, ucs: &crate::ucs::UcsFrame, first: Vec2, second: Vec2) -> Vec2 {
|
||||
let r = ucs.to_wcs(self.combine(ucs.to_ucs(first), ucs.to_ucs(second)));
|
||||
if r.is_finite() { r } else { self.combine(first, second) }
|
||||
}
|
||||
}
|
||||
|
||||
/// A pending point modifier.
|
||||
@@ -236,16 +243,16 @@ impl Session {
|
||||
// A distance at "Next point" of TK: straight across or up from the last tracking point,
|
||||
// the way the cursor lies from it.
|
||||
if let Some(Frame::Track { last: Some(l) }) = self.point_mods.last().copied()
|
||||
&& crate::prompt::parse_point_with(t, self.last_point, &self.angle_settings()).is_none()
|
||||
&& self.parse_typed_point(t, self.last_point).is_none()
|
||||
&& let Some(d) = crate::units::parse_distance(t)
|
||||
{
|
||||
let dir = (crate::snap::ortho(l, self.cursor) - l).normalized();
|
||||
let dir = (crate::snap::ortho_at(l, self.cursor, self.drafting_settings().ucs_angle) - l).normalized();
|
||||
let dir = if dir == Vec2::ZERO || !dir.is_finite() { Vec2::X } else { dir };
|
||||
return Some(self.modifier_point(l + dir * d));
|
||||
}
|
||||
if let Some(Frame::Angle { base, dir }) = self.point_mods.last().copied() {
|
||||
// Typed coordinates are explicit: they win over the override.
|
||||
if crate::prompt::parse_point_with(t, self.last_point, &self.angle_settings()).is_some() {
|
||||
if self.parse_typed_point(t, self.last_point).is_some() {
|
||||
self.point_mods.pop();
|
||||
return None;
|
||||
}
|
||||
@@ -328,7 +335,7 @@ impl Session {
|
||||
}
|
||||
Frame::Track { last } => {
|
||||
// Each point after the first goes straight across or up from the last one.
|
||||
let q = last.map_or(p, |l| crate::snap::ortho(l, p));
|
||||
let q = last.map_or(p, |l| crate::snap::ortho_at(l, p, self.drafting_settings().ucs_angle));
|
||||
self.point_mods.push(Frame::Track { last: Some(q) });
|
||||
self.last_point = q;
|
||||
return Ok(());
|
||||
@@ -336,7 +343,7 @@ impl Session {
|
||||
// The offset point is already measured from the base (`@` reads the last point).
|
||||
Frame::From { base: Some(_) } => {}
|
||||
Frame::Mid { first: Some(f) } => p = (f + p) * 0.5,
|
||||
Frame::Filter { keep, first: Some(f) } => p = keep.combine(f, p),
|
||||
Frame::Filter { keep, first: Some(f) } => p = keep.combine_in(&self.input_ucs(), f, p),
|
||||
Frame::Angle { base, dir } => p = base + dir * (p - base).dot(dir),
|
||||
Frame::Snap { mode: 0 } => {}
|
||||
Frame::Snap { mode } => {
|
||||
|
||||
+85
-12
@@ -102,6 +102,10 @@ pub struct Prompt {
|
||||
/// the routine writes, so it cannot be read for the word "Select" (#1598).
|
||||
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
||||
pub picks_one: bool,
|
||||
/// The prompt takes a block's name as well as its keywords: a Greek word that is an existing
|
||||
/// block's name is that block, not a keyword read from its Latin keys.
|
||||
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
||||
pub takes_block: bool,
|
||||
}
|
||||
|
||||
/// Parse `@distance<angle` (relative polar), returning `(distance, angle in radians)`.
|
||||
@@ -110,7 +114,10 @@ pub fn parse_polar_text(text: &str, angles: &crate::units::AngleSettings) -> Opt
|
||||
let body = text.trim().strip_prefix('@')?; // relative form only
|
||||
let (d, a) = body.split_once('<')?;
|
||||
let dist = d.trim().parse::<f64>().ok()?;
|
||||
let angle = angles.amount(a.trim())?;
|
||||
// The direction `@d<a` draws along, as `parse_point_in` reads it (ANGBASE, ANGDIR and the
|
||||
// UCS applied): a world angle.
|
||||
let a = a.trim();
|
||||
let angle = if a.starts_with('<') { angles.direction(&format!("<{a}"))? } else { angles.direction(a)? };
|
||||
(dist.is_finite() && angle.is_finite()).then_some((dist, angle))
|
||||
}
|
||||
|
||||
@@ -136,6 +143,11 @@ impl Prompt {
|
||||
self.picker = Some(p);
|
||||
self
|
||||
}
|
||||
/// Takes a block's name besides its keywords (the `takes_block` field).
|
||||
pub fn takes_block(mut self) -> Self {
|
||||
self.takes_block = true;
|
||||
self
|
||||
}
|
||||
pub fn kw(mut self, k: &[&str]) -> Self {
|
||||
self.keywords = k.iter().map(ToString::to_string).collect();
|
||||
self
|
||||
@@ -215,6 +227,24 @@ impl Prompt {
|
||||
return None;
|
||||
}
|
||||
let tl = t.to_ascii_lowercase();
|
||||
// A keyword typed with the Greek keyboard layout active (ΘΝΔΟ for Undo) is its Latin keys, unless
|
||||
// the prompt offers that spelling itself (a Greek keyword in a LISP program's list): its word
|
||||
// or a prefix of it as typed (ΘΝ for ΘΝΔΟ, not UN for Undo) is read before the Latin keys.
|
||||
if let Some(latin) = crate::keyboard::latin_keys(t) {
|
||||
// Greek letters have case, accents and a final sigma, which the ASCII-only folding above does not see.
|
||||
let typed = crate::keyboard::greek_fold(t).unwrap_or_else(|| latin.clone());
|
||||
let greek = || self.keywords.iter().filter_map(|k| crate::keyboard::greek_fold(k).map(|fold| (k, fold)));
|
||||
return greek()
|
||||
.find(|(_, k)| *k == typed)
|
||||
.or_else(|| greek().find(|(_, k)| k.starts_with(&typed)))
|
||||
.map(|(k, _)| k.clone())
|
||||
.or_else(|| self.match_latin_keyword(&latin));
|
||||
}
|
||||
self.match_latin_keyword(&tl)
|
||||
}
|
||||
|
||||
/// [`Prompt::match_keyword`] for text already read as Latin letters, in lower case.
|
||||
fn match_latin_keyword(&self, tl: &str) -> Option<String> {
|
||||
let keys = self.keywords.iter().map(|k| {
|
||||
let shortcut: String = k.chars().filter(|c| c.is_ascii_uppercase() || c.is_ascii_digit()).collect::<String>().to_ascii_lowercase();
|
||||
let shortcut =
|
||||
@@ -227,8 +257,8 @@ impl Prompt {
|
||||
// CHPROP: "Ambiguous response, please clarify..."), `LTS` is ltScale.
|
||||
let past_capitals = |k: &str| k.char_indices().rfind(|(_, c)| c.is_ascii_uppercase() || c.is_ascii_digit()).map_or(1, |(i, _)| i + 1);
|
||||
keys.clone()
|
||||
.find(|(_, kl, sc)| tl == *kl || tl == *sc)
|
||||
.or_else(|| keys.clone().find(|(k, kl, _)| tl.len() >= past_capitals(k) && kl.starts_with(&tl)))
|
||||
.find(|(_, kl, sc)| tl == kl.as_str() || tl == sc.as_str())
|
||||
.or_else(|| keys.clone().find(|(k, kl, _)| tl.len() >= past_capitals(k) && kl.starts_with(tl)))
|
||||
.map(|(k, _, _)| k.clone())
|
||||
}
|
||||
}
|
||||
@@ -323,10 +353,9 @@ pub struct Drag {
|
||||
}
|
||||
|
||||
/// Parse a typed point: `x,y[,z]`, `@dx,dy`, `@dist<angle`, `dist<angle`, `#x,y` (absolute),
|
||||
/// `*x,y` and `*@dx,dy`/`@*dx,dy` (world coordinates: the same as the plain forms, as there is no
|
||||
/// UCS yet).
|
||||
/// `*x,y` and `*@dx,dy`/`@*dx,dy` (world coordinates).
|
||||
/// Relative forms use `last`. Polar angles read the default angle settings (degrees from +X,
|
||||
/// counterclockwise); `parse_point_with` reads a drawing's.
|
||||
/// counterclockwise); `parse_point_with` reads a drawing's, `parse_point_in` a UCS too.
|
||||
pub fn parse_point(text: &str, last: Vec2) -> Option<Vec2> {
|
||||
parse_point_with(text, last, &crate::units::AngleSettings::default())
|
||||
}
|
||||
@@ -334,14 +363,31 @@ pub fn parse_point(text: &str, last: Vec2) -> Option<Vec2> {
|
||||
/// `parse_point` with polar angles read per `angles` (AUNITS, ANGBASE, ANGDIR); `d<<a` and
|
||||
/// `d<<<a` measure from +X counterclockwise (in degrees and in AUNITS).
|
||||
pub fn parse_point_with(text: &str, last: Vec2, angles: &crate::units::AngleSettings) -> Option<Vec2> {
|
||||
parse_point_in(text, last, angles, &crate::ucs::UcsFrame::WORLD)
|
||||
}
|
||||
|
||||
/// `parse_point_with` in a UCS: coordinates are UCS coordinates (`x,y` from its origin along its
|
||||
/// axes, `@dx,dy` along its axes), and polar angles are measured as `angles` says (which carries
|
||||
/// the UCS rotation, [`crate::units::AngleSettings::ucs`]). A `*` prefix reads the point in
|
||||
/// world coordinates instead. `last` and the result are world points.
|
||||
pub fn parse_point_in(text: &str, last: Vec2, angles: &crate::units::AngleSettings, ucs: &crate::ucs::UcsFrame) -> Option<Vec2> {
|
||||
let t = text.trim();
|
||||
if t.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let t = t.strip_prefix('*').map_or(t, str::trim_start);
|
||||
let (mut world, t) = match t.strip_prefix('*') {
|
||||
Some(r) => (true, r.trim_start()),
|
||||
None => (false, t),
|
||||
};
|
||||
let (rel, body) = if let Some(b) = t.strip_prefix('@') {
|
||||
let b = b.trim();
|
||||
(true, b.strip_prefix('*').map_or(b, str::trim_start))
|
||||
match b.strip_prefix('*') {
|
||||
Some(r) => {
|
||||
world = true;
|
||||
(true, r.trim_start())
|
||||
}
|
||||
None => (true, b),
|
||||
}
|
||||
} else if let Some(b) = t.strip_prefix('#') {
|
||||
(false, b.trim())
|
||||
} else {
|
||||
@@ -350,11 +396,15 @@ pub fn parse_point_with(text: &str, last: Vec2, angles: &crate::units::AngleSett
|
||||
if rel && body.is_empty() {
|
||||
return Some(last);
|
||||
}
|
||||
let (frame, angles) = if world { (crate::ucs::UcsFrame::WORLD, angles.world()) } else { (*ucs, *angles) };
|
||||
// `p`: a world displacement (polar, whose angle already says the UCS's direction), or UCS
|
||||
// coordinates (`x,y`).
|
||||
let p = if let Some((d, a)) = body.split_once('<') {
|
||||
let dist = crate::units::parse_distance(d)?;
|
||||
// `d<<a` / `d<<<a`: the override prefixes keep their `<<` / `<<<`.
|
||||
let ang = if a.starts_with('<') { angles.direction(&format!("<{a}"))? } else { angles.direction(a)? };
|
||||
Vec2::from_angle(ang) * dist
|
||||
let v = Vec2::from_angle(ang) * dist;
|
||||
if rel { last + v } else { frame.origin.xy() + v }
|
||||
} else {
|
||||
let parts: Vec<&str> = body.split(',').collect();
|
||||
if parts.len() < 2 || parts.len() > 3 {
|
||||
@@ -365,10 +415,10 @@ pub fn parse_point_with(text: &str, last: Vec2, angles: &crate::units::AngleSett
|
||||
if let Some(z) = parts.get(2) {
|
||||
crate::units::parse_distance(z)?;
|
||||
}
|
||||
Vec2::new(x, y)
|
||||
let v = Vec2::new(x, y);
|
||||
if rel { last + frame.vec_to_wcs(v) } else { frame.to_wcs(v) }
|
||||
};
|
||||
let r = if rel { last + p } else { p };
|
||||
r.is_finite().then_some(r)
|
||||
p.is_finite().then_some(p)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -394,6 +444,29 @@ mod tests {
|
||||
assert_eq!(parse_point("1,2,3,4", last), None);
|
||||
}
|
||||
|
||||
/// A keyword the prompt offers in Greek is matched as spelled (any case, accent or final sigma,
|
||||
/// or a prefix) before the Latin reading of the same keys; without one, the keys answer the
|
||||
/// Latin keyword.
|
||||
#[test]
|
||||
fn a_greek_keyword_is_matched_as_spelled_before_its_latin_reading() {
|
||||
// ΘΝΔΟ is the keys U-N-D-O, so it answers Undo, unless the prompt offers the Greek word itself
|
||||
// (a LISP program's keyword list).
|
||||
let both = Prompt::new("", Accept::TEXT).kw(&["Undo", "ΘΝΔΟ"]);
|
||||
assert_eq!(both.match_keyword("ΘΝΔΟ").as_deref(), Some("ΘΝΔΟ"));
|
||||
assert_eq!(both.match_keyword("θνδο").as_deref(), Some("ΘΝΔΟ"), "Greek case is folded like Latin case");
|
||||
assert_eq!(both.match_keyword("Undo").as_deref(), Some("Undo"));
|
||||
// A prefix of the Greek word as typed (ΘΝ) is that keyword, not the Latin prefix UN of Undo.
|
||||
assert_eq!(both.match_keyword("ΘΝ").as_deref(), Some("ΘΝΔΟ"));
|
||||
assert_eq!(both.match_keyword("θν").as_deref(), Some("ΘΝΔΟ"), "in either case");
|
||||
assert_eq!(both.match_keyword("θνδό").as_deref(), Some("ΘΝΔΟ"), "with an accent");
|
||||
let sigma = Prompt::new("", Accept::TEXT).kw(&["Last", "ΛΑΣΤ"]);
|
||||
assert_eq!(sigma.match_keyword("λας").as_deref(), Some("ΛΑΣΤ"), "a final sigma folds too");
|
||||
let latin = Prompt::new("", Accept::TEXT).kw(&["Undo"]);
|
||||
assert_eq!(latin.match_keyword("ΘΝ").as_deref(), Some("Undo"));
|
||||
assert_eq!(latin.match_keyword("ΘΝΔΟ").as_deref(), Some("Undo"));
|
||||
assert_eq!(latin.match_keyword("Θ").as_deref(), Some("Undo"), "a Greek-layout shortcut still works");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keywords() {
|
||||
let p = Prompt::new("Specify next point", Accept::POINT).kw(&["Undo", "Close"]);
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
+101
-21
@@ -152,8 +152,28 @@ fn in_box(pts: impl Iterator<Item = Vec2>, angle: f64, p: Vec2) -> bool {
|
||||
!b.is_empty() && b.contains(turn(p))
|
||||
}
|
||||
|
||||
fn selectable(d: &Drawing, e: &Entity) -> bool {
|
||||
d.is_visible(e)
|
||||
/// Whether `e` is on one of the layers in `frozen`: the layers frozen in a layout viewport, which
|
||||
/// does not draw their objects. The names are compared as the renderer compares them.
|
||||
pub(crate) fn on_frozen_layer(frozen: &[String], e: &Entity) -> bool {
|
||||
frozen.iter().any(|l| l.eq_ignore_ascii_case(&e.common.layer))
|
||||
}
|
||||
|
||||
/// The last object of `store`, in draw order, that is not on one of the layers in `frozen`, the
|
||||
/// layers frozen in the layout viewport the selection is made through: what the Last option
|
||||
/// takes there. With no such layers it is the last object, whether the drawing shows it or not.
|
||||
pub(crate) fn last_in(store: &cadcraft_doc::EntityStore, frozen: &[String]) -> Option<Handle> {
|
||||
if frozen.is_empty() {
|
||||
return store.last().map(|e| e.handle);
|
||||
}
|
||||
store.iter().filter(|e| !on_frozen_layer(frozen, e)).last().map(|e| e.handle)
|
||||
}
|
||||
|
||||
/// Whether a selection can take `e`: the drawing shows it ([`Drawing::is_visible`]) and it is not
|
||||
/// on one of the layers in `frozen`, the layers frozen in the layout viewport the selection is
|
||||
/// made through ([`crate::DocState::viewport_frozen`]; empty anywhere else). A viewport shows
|
||||
/// model space, so `frozen` goes with a selection in model space only.
|
||||
pub(crate) fn selectable(d: &Drawing, e: &Entity, frozen: &[String]) -> bool {
|
||||
d.is_visible(e) && !on_frozen_layer(frozen, e)
|
||||
}
|
||||
|
||||
/// Entities to test, in the order to test them, each with its bounds when already known.
|
||||
@@ -196,15 +216,28 @@ pub(crate) fn candidates<'a>(
|
||||
/// the nearest, as AutoCAD 2024 picks (two objects under the pickbox: the one drawn later is
|
||||
/// picked, and DRAWORDER changes which).
|
||||
pub fn pick(d: &Drawing, space: &Space, p: Vec2, aperture: f64) -> Option<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
pick_with(d, space, &ix, p, aperture)
|
||||
pick_in(d, space, &[], p, aperture)
|
||||
}
|
||||
|
||||
pub(crate) fn pick_with(d: &Drawing, space: &Space, ix: &Option<std::sync::Arc<SpatialIndex>>, p: Vec2, aperture: f64) -> Option<Handle> {
|
||||
/// [`pick`] through a layout viewport: the objects on the layers in `frozen`, the layers frozen
|
||||
/// in that viewport, are not drawn there and are not picked.
|
||||
pub fn pick_in(d: &Drawing, space: &Space, frozen: &[String], p: Vec2, aperture: f64) -> Option<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
pick_with(d, space, &ix, frozen, p, aperture)
|
||||
}
|
||||
|
||||
pub(crate) fn pick_with(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
ix: &Option<std::sync::Arc<SpatialIndex>>,
|
||||
frozen: &[String],
|
||||
p: Vec2,
|
||||
aperture: f64,
|
||||
) -> Option<Handle> {
|
||||
let probe = Bounds2::new(p, p).expand(aperture);
|
||||
// Candidates come topmost first: the first within the aperture is the one.
|
||||
for (e, known) in candidates(d, space, ix, &probe.expand(aperture), true, true)? {
|
||||
if !selectable(d, e) {
|
||||
if !selectable(d, e, frozen) {
|
||||
continue;
|
||||
}
|
||||
let infinite = is_infinite(e);
|
||||
@@ -221,11 +254,16 @@ pub(crate) fn pick_with(d: &Drawing, space: &Space, ix: &Option<std::sync::Arc<S
|
||||
/// Every entity within `aperture` of `p`, topmost first (so the first is what [`pick`] chooses):
|
||||
/// the objects selection cycling lists.
|
||||
pub fn pick_all(d: &Drawing, space: &Space, p: Vec2, aperture: f64) -> Vec<Handle> {
|
||||
pick_all_in(d, space, &[], p, aperture)
|
||||
}
|
||||
|
||||
/// [`pick_all`] through a layout viewport that freezes the layers in `frozen` ([`pick_in`]).
|
||||
pub fn pick_all_in(d: &Drawing, space: &Space, frozen: &[String], p: Vec2, aperture: f64) -> Vec<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
let probe = Bounds2::new(p, p).expand(aperture);
|
||||
let Some(cands) = candidates(d, space, &ix, &probe.expand(aperture), true, true) else { return Vec::new() };
|
||||
cands
|
||||
.filter(|(e, known)| selectable(d, e) && (is_infinite(e) || bounds_of(d, e, *known).expand(aperture).intersects(&probe)))
|
||||
.filter(|(e, known)| selectable(d, e, frozen) && (is_infinite(e) || bounds_of(d, e, *known).expand(aperture).intersects(&probe)))
|
||||
.filter(|(e, _)| entity_distance(d, e, p, aperture / 4.0) <= aperture)
|
||||
.map(|(e, _)| e.handle)
|
||||
.collect()
|
||||
@@ -253,14 +291,27 @@ fn seg_hits_box(a: Vec2, b: Vec2, bx: &Bounds2) -> bool {
|
||||
|
||||
/// Window selection (entirely inside) or crossing selection (inside or touching).
|
||||
pub fn select_window(d: &Drawing, space: &Space, bx: Bounds2, crossing: bool) -> Vec<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
select_window_with(d, space, &ix, bx, crossing)
|
||||
select_window_in(d, space, &[], bx, crossing)
|
||||
}
|
||||
|
||||
pub(crate) fn select_window_with(d: &Drawing, space: &Space, ix: &Option<std::sync::Arc<SpatialIndex>>, bx: Bounds2, crossing: bool) -> Vec<Handle> {
|
||||
/// [`select_window`] through a layout viewport: the objects on the layers in `frozen`, the layers
|
||||
/// frozen in that viewport, are not drawn there and are not selected.
|
||||
pub fn select_window_in(d: &Drawing, space: &Space, frozen: &[String], bx: Bounds2, crossing: bool) -> Vec<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
select_window_with(d, space, &ix, frozen, bx, crossing)
|
||||
}
|
||||
|
||||
pub(crate) fn select_window_with(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
ix: &Option<std::sync::Arc<SpatialIndex>>,
|
||||
frozen: &[String],
|
||||
bx: Bounds2,
|
||||
crossing: bool,
|
||||
) -> Vec<Handle> {
|
||||
let Some(cands) = candidates(d, space, ix, &bx, crossing, false) else { return Vec::new() };
|
||||
let tol = window_tol(&bx);
|
||||
cands.filter(|(e, known)| selectable(d, e) && in_window(d, e, *known, &bx, crossing, tol)).map(|(e, _)| e.handle).collect()
|
||||
cands.filter(|(e, known)| selectable(d, e, frozen) && in_window(d, e, *known, &bx, crossing, tol)).map(|(e, _)| e.handle).collect()
|
||||
}
|
||||
|
||||
/// The tessellation tolerance window and crossing tests use for a box.
|
||||
@@ -306,11 +357,23 @@ pub(crate) fn in_window(d: &Drawing, e: &Entity, known: Option<Bounds2>, bx: &Bo
|
||||
|
||||
/// Fence selection: entities crossed by the fence polyline.
|
||||
pub fn select_fence(d: &Drawing, space: &Space, fence: &[Vec2]) -> Vec<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
select_fence_with(d, space, &ix, fence)
|
||||
select_fence_in(d, space, &[], fence)
|
||||
}
|
||||
|
||||
pub(crate) fn select_fence_with(d: &Drawing, space: &Space, ix: &Option<std::sync::Arc<SpatialIndex>>, fence: &[Vec2]) -> Vec<Handle> {
|
||||
/// [`select_fence`] through a layout viewport that freezes the layers in `frozen`
|
||||
/// ([`select_window_in`]).
|
||||
pub fn select_fence_in(d: &Drawing, space: &Space, frozen: &[String], fence: &[Vec2]) -> Vec<Handle> {
|
||||
let ix = spatial::index(d, space);
|
||||
select_fence_with(d, space, &ix, frozen, fence)
|
||||
}
|
||||
|
||||
pub(crate) fn select_fence_with(
|
||||
d: &Drawing,
|
||||
space: &Space,
|
||||
ix: &Option<std::sync::Arc<SpatialIndex>>,
|
||||
frozen: &[String],
|
||||
fence: &[Vec2],
|
||||
) -> Vec<Handle> {
|
||||
let fb = Bounds2::from_points(fence.iter().copied());
|
||||
let tol = (fb.width() + fb.height()).max(1e-9) / 2000.0;
|
||||
let probe = fb.expand(tol);
|
||||
@@ -318,7 +381,7 @@ pub(crate) fn select_fence_with(d: &Drawing, space: &Space, ix: &Option<std::syn
|
||||
let mut out = Vec::new();
|
||||
for (e, known) in cands {
|
||||
// Infinite objects have no useful bounds; like window selection, test their geometry directly.
|
||||
if !selectable(d, e) || (!is_infinite(e) && !bounds_of(d, e, known).intersects(&probe)) {
|
||||
if !selectable(d, e, frozen) || (!is_infinite(e) && !bounds_of(d, e, known).intersects(&probe)) {
|
||||
continue;
|
||||
}
|
||||
let polys = hit_polylines(d, e, tol);
|
||||
@@ -339,6 +402,12 @@ pub(crate) fn select_fence_with(d: &Drawing, space: &Space, ix: &Option<std::syn
|
||||
/// Window polygon selection (entities entirely inside `poly`) or crossing polygon selection
|
||||
/// (inside or crossing its edges). The polygon closes back to its first point.
|
||||
pub fn select_polygon(d: &Drawing, space: &Space, poly: &[Vec2], crossing: bool) -> Vec<Handle> {
|
||||
select_polygon_in(d, space, &[], poly, crossing)
|
||||
}
|
||||
|
||||
/// [`select_polygon`] through a layout viewport that freezes the layers in `frozen`
|
||||
/// ([`select_window_in`]).
|
||||
pub fn select_polygon_in(d: &Drawing, space: &Space, frozen: &[String], poly: &[Vec2], crossing: bool) -> Vec<Handle> {
|
||||
let (Some(first), true) = (poly.first(), poly.len() >= 3) else { return Vec::new() };
|
||||
let ix = spatial::index(d, space);
|
||||
let pb = Bounds2::from_points(poly.iter().copied());
|
||||
@@ -349,7 +418,7 @@ pub fn select_polygon(d: &Drawing, space: &Space, poly: &[Vec2], crossing: bool)
|
||||
let mut out = Vec::new();
|
||||
for (e, known) in cands {
|
||||
let infinite = is_infinite(e);
|
||||
if !selectable(d, e) || (infinite && !crossing) {
|
||||
if !selectable(d, e, frozen) || (infinite && !crossing) {
|
||||
continue;
|
||||
}
|
||||
let eb = bounds_of(d, e, known);
|
||||
@@ -378,9 +447,15 @@ pub fn select_polygon(d: &Drawing, space: &Space, poly: &[Vec2], crossing: bool)
|
||||
/// The visible objects in `space` of the group called `name` (any case), or `None` when the
|
||||
/// drawing has no such group.
|
||||
pub fn select_group(d: &Drawing, space: &Space, name: &str) -> Option<Vec<Handle>> {
|
||||
select_group_in(d, space, &[], name)
|
||||
}
|
||||
|
||||
/// [`select_group`] through a layout viewport that freezes the layers in `frozen`: the group's
|
||||
/// objects on those layers are left out.
|
||||
pub fn select_group_in(d: &Drawing, space: &Space, frozen: &[String], name: &str) -> Option<Vec<Handle>> {
|
||||
let g = d.groups.iter().find(|g| g.name.eq_ignore_ascii_case(name.trim()))?;
|
||||
let store = d.space(space)?;
|
||||
Some(g.members.iter().copied().filter(|h| store.get(*h).is_some_and(|e| d.is_visible(e))).collect())
|
||||
Some(g.members.iter().copied().filter(|h| store.get(*h).is_some_and(|e| selectable(d, e, frozen))).collect())
|
||||
}
|
||||
|
||||
/// A selection mode typed at "Select objects", collecting its points before it selects.
|
||||
@@ -454,14 +529,19 @@ impl SelectMode {
|
||||
}
|
||||
/// The objects the mode selects, or `None` while it has too few points.
|
||||
pub fn select(&self, d: &Drawing, space: &Space) -> Option<Vec<Handle>> {
|
||||
self.select_in(d, space, &[])
|
||||
}
|
||||
/// [`SelectMode::select`] through a layout viewport: the objects on the layers in `frozen`,
|
||||
/// the layers frozen in that viewport, are not drawn there and are not selected.
|
||||
pub fn select_in(&self, d: &Drawing, space: &Space, frozen: &[String]) -> Option<Vec<Handle>> {
|
||||
match (self.kind, self.pts.as_slice()) {
|
||||
(SelectKind::Window | SelectKind::Crossing, [a, b, ..]) => {
|
||||
Some(select_window(d, space, Bounds2::new(*a, *b), self.kind == SelectKind::Crossing))
|
||||
Some(select_window_in(d, space, frozen, Bounds2::new(*a, *b), self.kind == SelectKind::Crossing))
|
||||
}
|
||||
(SelectKind::Box, [a, b, ..]) => Some(select_window(d, space, Bounds2::new(*a, *b), b.x < a.x)),
|
||||
(SelectKind::Fence, pts) if pts.len() >= 2 => Some(select_fence(d, space, pts)),
|
||||
(SelectKind::Box, [a, b, ..]) => Some(select_window_in(d, space, frozen, Bounds2::new(*a, *b), b.x < a.x)),
|
||||
(SelectKind::Fence, pts) if pts.len() >= 2 => Some(select_fence_in(d, space, frozen, pts)),
|
||||
(SelectKind::WPolygon | SelectKind::CPolygon, pts) if pts.len() >= 3 => {
|
||||
Some(select_polygon(d, space, pts, self.kind == SelectKind::CPolygon))
|
||||
Some(select_polygon_in(d, space, frozen, pts, self.kind == SelectKind::CPolygon))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
|
||||
@@ -107,7 +107,8 @@ impl Session {
|
||||
lisp::value::Value::Real(r) => self.typed_token(&format!("{r}"), false),
|
||||
lisp::value::Value::Str(s) => self.typed_token(&s, false),
|
||||
other => match other.as_point() {
|
||||
Some(p) => self.input(Input::Point(Vec2::new(p[0], p[1]))),
|
||||
// A point from LISP is in the current UCS, as typed coordinates are.
|
||||
Some(p) => self.input(Input::Point(self.input_ucs().to_wcs(Vec2::new(p[0], p[1])))),
|
||||
None => {
|
||||
self.echo(format!("Invalid input: {}", lisp::value::to_text(&other, true)));
|
||||
Ok(())
|
||||
@@ -116,9 +117,26 @@ impl Session {
|
||||
};
|
||||
}
|
||||
// At "Select objects" prompts the selection modes (Previous, Last, ALL) win over a command
|
||||
// keyword sharing the letter (HATCH's "picK internal point" against `P`).
|
||||
let selection_mode = prompt.accept.select
|
||||
&& matches!(tt.strip_prefix('_').unwrap_or(tt).to_ascii_lowercase().as_str(), "all" | "l" | "last" | "p" | "previous");
|
||||
// keyword sharing the letter (HATCH's "picK internal point" against `P`). A word typed with
|
||||
// the Greek keyboard layout active is read by its keys there too: Λ is Last at COUNT's prompt,
|
||||
// not List.
|
||||
let selection_mode = prompt.accept.select && {
|
||||
let word = tt.strip_prefix('_').unwrap_or(tt);
|
||||
let keys = crate::keyboard::latin_keys(word).unwrap_or_else(|| word.to_ascii_lowercase());
|
||||
matches!(keys.as_str(), "all" | "l" | "last" | "p" | "previous")
|
||||
};
|
||||
// A Greek word that is an existing name at a prompt that takes one is that name, in any case:
|
||||
// ΣΟΛΙΔ is also the keys of Solid.
|
||||
let existing = if matches!(prompt.picker, Some(crate::Picker::HatchPattern(_))) {
|
||||
crate::keyboard::greek_fold(tt).and_then(|_| cmd::hatch::pattern_named(tt))
|
||||
} else if prompt.takes_block {
|
||||
self.greek_block_name(tt)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(name) = existing {
|
||||
return self.input(Input::Text(name));
|
||||
}
|
||||
// A leading underscore asks for a keyword by its English name, whatever the interface
|
||||
// language (`_M`, `_Yes`): scripts and LISP routines write them that way. (Snap
|
||||
// overrides such as `_cen` were taken above.)
|
||||
@@ -129,7 +147,8 @@ impl Session {
|
||||
return self.input(Input::Keyword(k));
|
||||
}
|
||||
if prompt.accept.point {
|
||||
if let Some(p) = prompt::parse_point_with(tt, self.last_point, &self.angle_settings()) {
|
||||
self.note_tilted_ucs();
|
||||
if let Some(p) = self.parse_typed_point(tt, self.last_point) {
|
||||
self.last_polar = prompt::parse_polar_text(tt, &self.angle_settings());
|
||||
return self.input(Input::Point(p));
|
||||
}
|
||||
|
||||
@@ -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()))
|
||||
|
||||
@@ -8,6 +8,39 @@ use super::{
|
||||
impl Session {
|
||||
// ---------------- interactive commands ----------------
|
||||
|
||||
/// Whether `name`, as typed, is a command, an alias or a LISP command: the lookups
|
||||
/// [`Session::start`] dispatches by, so only ASCII is lower-cased and a Greek alias stays as stored.
|
||||
fn names_a_command(&self, name: &str) -> bool {
|
||||
let lower = name.trim_start_matches(['_', '.', '-']).to_ascii_lowercase();
|
||||
let dashed = name.trim_start_matches(['_', '.']);
|
||||
find_command(&cmd::resolve_alias(dashed)).is_some()
|
||||
|| find_command(&cmd::resolve_alias(&lower)).is_some()
|
||||
|| self.lisp_command(&lower).is_some()
|
||||
}
|
||||
|
||||
/// The alias or LISP command that is the Greek word `name` in another case or accent (λινε for
|
||||
/// c:ΛΙΝΕ): those lookups fold ASCII only.
|
||||
fn greek_command_name(&self, name: &str) -> Option<String> {
|
||||
let bare = name.trim_start_matches(['_', '.', '-']);
|
||||
let same = crate::keyboard::same_greek_word_as(bare)?;
|
||||
let lisp = || self.lisp_commands().into_iter().find(|c| same(c) && self.lisp_command(c).is_some());
|
||||
cmd::file::greek_alias(bare).or_else(lisp)
|
||||
}
|
||||
|
||||
/// Whether the Greek word `name` is a command of its own, which [`Session::start`] runs instead
|
||||
/// of the Latin name its keys type.
|
||||
pub fn greek_word_is_a_command(&self, name: &str) -> bool {
|
||||
self.names_a_command(name) || self.greek_command_name(name).is_some()
|
||||
}
|
||||
|
||||
/// The existing block that is the Greek word `word`: as spelled, else in another case or accent
|
||||
/// (μ for Μ).
|
||||
pub(super) fn greek_block_name(&self, word: &str) -> Option<String> {
|
||||
let same = crate::keyboard::same_greek_word_as(word)?;
|
||||
let blocks = &self.doc().ok()?.blocks;
|
||||
blocks.keys().find(|k| *k == word).or_else(|| blocks.keys().find(|k| same(k))).cloned()
|
||||
}
|
||||
|
||||
/// Start a command by name or alias as if typed at the command line.
|
||||
pub fn start(&mut self, name: &str) -> Result<()> {
|
||||
self.last_polar = None;
|
||||
@@ -17,6 +50,12 @@ impl Session {
|
||||
Some(n) => (true, n),
|
||||
None => (false, name),
|
||||
};
|
||||
// A name typed with the Greek keyboard layout active (ΛΙΝΕ for LINE) is the Latin name's keys,
|
||||
// unless it is a command, alias or LISP function of its own, in any case or accent.
|
||||
let typed = name;
|
||||
let latin =
|
||||
crate::keyboard::latin_keys(name).filter(|_| !self.names_a_command(name)).map(|latin| self.greek_command_name(name).unwrap_or(latin));
|
||||
let name = latin.as_deref().unwrap_or(name);
|
||||
let lower = name.trim_start_matches(['_', '.', '-']).to_ascii_lowercase();
|
||||
// A command-line form with an id of its own (-ATTEDIT) is not the command it prefixes.
|
||||
let dashed = cmd::resolve_alias(&name.trim_start_matches(['_', '.']).to_ascii_lowercase());
|
||||
@@ -24,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();
|
||||
}
|
||||
@@ -37,7 +77,7 @@ impl Session {
|
||||
self.start(if transparent { "'setvar" } else { "setvar" })?;
|
||||
return self.input(Input::Text(var));
|
||||
}
|
||||
return Err(EngineError::UnknownCommand(name.to_string()));
|
||||
return Err(EngineError::UnknownCommand(typed.to_string()));
|
||||
};
|
||||
if transparent && spec.transparent && self.running.is_some() {
|
||||
// Transparent commands (zoom, pan…) run without cancelling the active one.
|
||||
@@ -57,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) {
|
||||
@@ -175,17 +218,33 @@ impl Session {
|
||||
Input::Text(t) => Input::Text(t.trim().strip_prefix('_').map(str::to_string).unwrap_or(t)),
|
||||
other => other,
|
||||
};
|
||||
if let Input::Text(t) | Input::Keyword(t) = &input
|
||||
&& let Some(m) = select::SelectMode::from_keyword(t)
|
||||
// A selection word typed with the Greek keyboard layout active (ΑΛΛ for ALL) is looked up as its
|
||||
// Latin keys. Only the lookup is: text that is no selection word (a block name at BEDIT's prompt,
|
||||
// which also takes a selection) reaches the command as typed. The name of an existing block at
|
||||
// a prompt that takes a name reaches it as stored, in whatever case it was typed: a block
|
||||
// called Μ is that block there, not Multiple.
|
||||
let block = match &input {
|
||||
Input::Text(t) if prompt.accept.text => self.greek_block_name(t.trim()),
|
||||
_ => None,
|
||||
};
|
||||
let is_block = block.is_some();
|
||||
let input = block.map_or(input, Input::Text);
|
||||
let word = match &input {
|
||||
Input::Text(t) => Some(crate::keyboard::latin_keys(t.trim()).filter(|_| !is_block).unwrap_or_else(|| t.clone())),
|
||||
Input::Keyword(k) => Some(k.clone()),
|
||||
_ => None,
|
||||
};
|
||||
if let Some(w) = &word
|
||||
&& let Some(m) = select::SelectMode::from_keyword(w)
|
||||
{
|
||||
self.pending_window = None;
|
||||
self.select_mode = Some(m);
|
||||
return Ok(None);
|
||||
}
|
||||
if let Input::Text(t) | Input::Keyword(t) = &input
|
||||
&& !prompt.keywords.iter().any(|k| k.eq_ignore_ascii_case(t.trim()))
|
||||
if let Some(w) = &word
|
||||
&& !prompt.keywords.iter().any(|k| k.eq_ignore_ascii_case(w.trim()))
|
||||
{
|
||||
match t.trim().to_ascii_lowercase().as_str() {
|
||||
match w.trim().to_ascii_lowercase().as_str() {
|
||||
"si" | "single" => {
|
||||
self.select_single = true;
|
||||
return Ok(None);
|
||||
@@ -202,10 +261,10 @@ impl Session {
|
||||
let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5;
|
||||
if let Some(pw) = self.pending_window.take() {
|
||||
let crossing = self.window_is_crossing(pw.corner, p);
|
||||
let hs = select::select_window(self.doc()?, &space, Bounds2::new(pw.corner, p), crossing);
|
||||
let hs = select::select_window_in(self.doc()?, &space, self.viewport_frozen(), Bounds2::new(pw.corner, p), crossing);
|
||||
return Ok(Some(Input::Pick(cmd::groups::expand(self, hs))));
|
||||
}
|
||||
match select::pick(self.doc()?, &space, p, ap) {
|
||||
match select::pick_in(self.doc()?, &space, self.viewport_frozen(), p, ap) {
|
||||
Some(h) => Ok(Some(Input::Pick(cmd::groups::expand(self, vec![h])))),
|
||||
None => {
|
||||
self.pending_window = Some(PendingWindow { corner: p, during_command: true });
|
||||
@@ -213,14 +272,18 @@ impl Session {
|
||||
}
|
||||
}
|
||||
}
|
||||
Input::Text(ref t) | Input::Keyword(ref t) => {
|
||||
let tl = t.trim().to_ascii_lowercase();
|
||||
Input::Text(_) | Input::Keyword(_) => {
|
||||
let tl = word.as_deref().unwrap_or_default().trim().to_ascii_lowercase();
|
||||
let d = self.doc()?;
|
||||
let store = d.space(&space);
|
||||
let frozen = self.viewport_frozen();
|
||||
let picked = match tl.as_str() {
|
||||
"all" => store.map(|s| s.iter().filter(|e| d.is_visible(e)).map(|e| e.handle).collect()),
|
||||
"l" | "last" => store.and_then(|s| s.last()).map(|e| vec![e.handle]),
|
||||
"p" | "previous" => Some(self.state()?.previous_selection.clone()),
|
||||
"all" => store.map(|s| s.iter().filter(|e| select::selectable(d, e, frozen)).map(|e| e.handle).collect()),
|
||||
"l" | "last" => store.and_then(|s| select::last_in(s, frozen)).map(|h| vec![h]),
|
||||
"p" | "previous" => {
|
||||
let st = self.state()?;
|
||||
Some(st.drawn_in_viewport(&st.previous_selection))
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
match picked {
|
||||
@@ -241,8 +304,9 @@ impl Session {
|
||||
fn select_mode_input(&mut self, input: Input) -> Result<Option<Input>> {
|
||||
let Some(mut mode) = self.select_mode.take() else { return Ok(Some(input)) };
|
||||
if mode.kind == select::SelectKind::Group {
|
||||
let space = self.space();
|
||||
return match input {
|
||||
Input::Text(name) | Input::Keyword(name) => match select::select_group(self.doc()?, &self.space(), &name) {
|
||||
Input::Text(name) | Input::Keyword(name) => match select::select_group_in(self.doc()?, &space, self.viewport_frozen(), &name) {
|
||||
Some(hs) => Ok(Some(Input::Pick(hs))),
|
||||
None => {
|
||||
self.echo(format!("No group named \"{}\".", name.trim()));
|
||||
@@ -262,14 +326,14 @@ impl Session {
|
||||
match input {
|
||||
Input::Point(p) => {
|
||||
if mode.push(p) {
|
||||
return Ok(mode.select(self.doc()?, &self.space()).map(Input::Pick));
|
||||
return Ok(mode.select_in(self.doc()?, &self.space(), self.viewport_frozen()).map(Input::Pick));
|
||||
}
|
||||
}
|
||||
Input::Keyword(k) if k == "Undo" => {
|
||||
mode.pts.pop();
|
||||
}
|
||||
// Enter ends a fence or polygon; with too few points the mode is dropped.
|
||||
Input::Enter => return Ok(mode.select(self.doc()?, &self.space()).map(Input::Pick)),
|
||||
Input::Enter => return Ok(mode.select_in(self.doc()?, &self.space(), self.viewport_frozen()).map(Input::Pick)),
|
||||
Input::Cancel | Input::Pick(_) => return Ok(Some(input)),
|
||||
_ => self.echo("Invalid point."),
|
||||
}
|
||||
@@ -318,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(())
|
||||
}
|
||||
|
||||
@@ -32,9 +32,9 @@ impl Session {
|
||||
let pickadd = self.settings.pickadd;
|
||||
if let Some(pw) = self.pending_window.take() {
|
||||
let crossing = self.window_is_crossing(pw.corner, p);
|
||||
let hs = select::select_window(self.doc()?, &space, Bounds2::new(pw.corner, p), crossing);
|
||||
let hs = select::select_window_in(self.doc()?, &space, self.viewport_frozen(), Bounds2::new(pw.corner, p), crossing);
|
||||
let hs = cmd::groups::expand(self, hs);
|
||||
let mut sel = if pickadd || shift { self.selection() } else { Vec::new() };
|
||||
let mut sel = if pickadd || shift { self.stored_selection() } else { Vec::new() };
|
||||
if shift && pickadd {
|
||||
sel.retain(|h| !hs.contains(h));
|
||||
} else {
|
||||
@@ -44,7 +44,7 @@ impl Session {
|
||||
return Ok(());
|
||||
}
|
||||
let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5;
|
||||
match select::pick(self.doc()?, &space, p, ap) {
|
||||
match select::pick_in(self.doc()?, &space, self.viewport_frozen(), p, ap) {
|
||||
Some(h) => self.idle_pick(h, shift),
|
||||
None => self.pending_window = Some(PendingWindow { corner: p, during_command: false }),
|
||||
}
|
||||
@@ -56,7 +56,7 @@ impl Session {
|
||||
let pickadd = self.settings.pickadd;
|
||||
// With group selection the object's selectable groups come (or go) with it.
|
||||
let hs = cmd::groups::expand(self, vec![h]);
|
||||
let mut sel = if pickadd || shift { self.selection() } else { Vec::new() };
|
||||
let mut sel = if pickadd || shift { self.stored_selection() } else { Vec::new() };
|
||||
let had = sel.contains(&h);
|
||||
if shift && (pickadd || had) {
|
||||
sel.retain(|x| !hs.contains(x));
|
||||
@@ -93,7 +93,7 @@ impl Session {
|
||||
return Vec::new();
|
||||
}
|
||||
let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5;
|
||||
self.doc().map(|d| select::pick_all(d, &self.space(), p, ap)).unwrap_or_default()
|
||||
self.doc().map(|d| select::pick_all_in(d, &self.space(), self.viewport_frozen(), p, ap)).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Whether selection cycling marks `p` with its badge (SELECTIONCYCLING 1 or 2): overlapping
|
||||
@@ -155,7 +155,8 @@ impl Session {
|
||||
|
||||
/// The object a prompt picking one object finds at `p` in `space`: the one named for that
|
||||
/// point ([`Session::input_object`]), which is none when it lies in another space, else the
|
||||
/// object under `p` within `aperture`.
|
||||
/// object under `p` within `aperture`. Inside an MSPACE viewport a pick in model space finds
|
||||
/// what that viewport draws: not the objects on the layers frozen in it.
|
||||
pub fn pick_object(&self, space: &Space, p: Vec2, aperture: f64) -> Result<Option<Handle>> {
|
||||
let d = self.doc()?;
|
||||
if let Some((h, q)) = self.pick_hint
|
||||
@@ -163,7 +164,9 @@ impl Session {
|
||||
{
|
||||
return Ok((d.space_of(h).as_ref() == Some(space)).then_some(h));
|
||||
}
|
||||
Ok(select::pick(d, space, p, aperture))
|
||||
// The viewport shows model space only: its frozen layers hide nothing on the sheet.
|
||||
let frozen = if *space == Space::Model { self.viewport_frozen() } else { &[] };
|
||||
Ok(select::pick_in(d, space, frozen, p, aperture))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -125,6 +125,10 @@ pub struct Settings {
|
||||
pub polarsnap: bool,
|
||||
/// POLARDIST: the PolarSnap step; 0 uses the snap X spacing.
|
||||
pub polardist: f64,
|
||||
/// The current UCS's X axis, radians from world +X: ortho, polar and object snap tracking
|
||||
/// work along the UCS axes. Filled in by [`Session::drafting_settings`]; not a setting.
|
||||
#[serde(skip)]
|
||||
pub ucs_angle: f64,
|
||||
/// AUDITCTL: 1 creates an audit report (.adt) file when AUDIT is run (default: 0).
|
||||
pub auditctl: bool,
|
||||
/// ATTREQ: 0 inserts blocks with their attributes' default values instead of asking for them
|
||||
@@ -193,6 +197,7 @@ impl Default for Settings {
|
||||
polaraddang: Vec::new(),
|
||||
polarsnap: false,
|
||||
polardist: 0.0,
|
||||
ucs_angle: 0.0,
|
||||
auditctl: false,
|
||||
attreq: true,
|
||||
}
|
||||
|
||||
@@ -1025,6 +1025,17 @@ pub fn ortho(base: Vec2, p: Vec2) -> Vec2 {
|
||||
if d.x.abs() >= d.y.abs() { Vec2::new(p.x, base.y) } else { Vec2::new(base.x, p.y) }
|
||||
}
|
||||
|
||||
/// [`ortho`] along axes turned by `angle` radians (the current UCS's).
|
||||
pub fn ortho_at(base: Vec2, p: Vec2, angle: f64) -> Vec2 {
|
||||
if !angle.is_finite() || angle == 0.0 {
|
||||
return ortho(base, p);
|
||||
}
|
||||
let d = (p - base).rotate(-angle);
|
||||
let along = if d.x.abs() >= d.y.abs() { Vec2::new(d.x, 0.0) } else { Vec2::new(0.0, d.y) };
|
||||
let r = base + along.rotate(angle);
|
||||
if r.is_finite() { r } else { p }
|
||||
}
|
||||
|
||||
/// Polar tracking: if the direction base→p is within `tol` radians of a multiple of `inc`,
|
||||
/// return the point projected onto that ray and the angle.
|
||||
pub fn polar(base: Vec2, p: Vec2, inc: f64, tol: f64) -> Option<(Vec2, f64)> {
|
||||
@@ -1058,12 +1069,26 @@ pub fn grid_snap(p: Vec2, unit: Vec2, origin: Vec2, angle: f64) -> Vec2 {
|
||||
if s.is_finite() { s } else { p }
|
||||
}
|
||||
|
||||
/// The snap grid's origin (SNAPBASE) and rotation in radians (SNAPANG, in degrees) of a drawing.
|
||||
/// The snap grid's origin (SNAPBASE) and rotation in radians (SNAPANG, in degrees) of a drawing,
|
||||
/// as stored: in the UCS ([`grid_frame_in`] places them in the world).
|
||||
pub fn grid_frame(d: &Drawing) -> (Vec2, f64) {
|
||||
let base = d.header.point("SNAPBASE").map(|p| p.xy()).filter(|p| p.is_finite()).unwrap_or(Vec2::ZERO);
|
||||
(base, d.header.f64("SNAPANG", 0.0).to_radians())
|
||||
}
|
||||
|
||||
/// The snap grid's origin and rotation in world coordinates, for `space`: SNAPBASE is a point of
|
||||
/// the current UCS and SNAPANG is measured from its X axis, so the grid and grid snap lie in the
|
||||
/// UCS (in the World UCS while it is tilted out of the XY plane).
|
||||
pub fn grid_frame_in(d: &Drawing, space: &Space) -> (Vec2, f64) {
|
||||
let (base, angle) = grid_frame(d);
|
||||
let ucs = crate::ucs::current_frame(d, space);
|
||||
if !ucs.is_planar() {
|
||||
return (base, angle);
|
||||
}
|
||||
let (o, a) = (ucs.to_wcs(base), ucs.rotation() + angle);
|
||||
if o.is_finite() && a.is_finite() { (o, a) } else { (base, angle) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -118,11 +118,11 @@ pub fn lattice_snap(p: Vec2, d: f64, origin: Vec2, angle: f64) -> Vec2 {
|
||||
/// isometric lattice, and the settings with grid snap off so the rectangular grid leaves it be.
|
||||
/// Otherwise both unchanged, also when PolarSnap (SNAPTYPE 1) is the snap type: snap mode then
|
||||
/// steps along the tracking paths instead.
|
||||
pub(crate) fn grid_snap(doc: &cadcraft_doc::Drawing, mut s: Settings, p: Vec2) -> (Vec2, Settings) {
|
||||
pub(crate) fn grid_snap(doc: &cadcraft_doc::Drawing, space: &cadcraft_doc::Space, mut s: Settings, p: Vec2) -> (Vec2, Settings) {
|
||||
if !(s.snapmode && s.isodraft) || s.polarsnap {
|
||||
return (p, s);
|
||||
}
|
||||
let (origin, angle) = super::grid_frame(doc);
|
||||
let (origin, angle) = super::grid_frame_in(doc, space);
|
||||
s.snapmode = false;
|
||||
(lattice_snap(p, s.snapunit.y, origin, angle), s)
|
||||
}
|
||||
@@ -144,10 +144,12 @@ fn nearest_axis(plane: IsoPlane, d: Vec2) -> Vec2 {
|
||||
/// Ortho without snapping: `p` constrained relative to `base` to the nearest axis of the current
|
||||
/// isometric plane (or to horizontal/vertical when isometric drafting is off).
|
||||
pub fn constrain(s: &Settings, base: Vec2, p: Vec2) -> Vec2 {
|
||||
// Along the current UCS's axes (`s.ucs_angle`), the isometric ones turned with it.
|
||||
if !s.isodraft {
|
||||
return super::ortho(base, p);
|
||||
return super::ortho_at(base, p, s.ucs_angle);
|
||||
}
|
||||
let dir = nearest_axis(s.isoplane, p - base);
|
||||
let a = if s.ucs_angle.is_finite() { s.ucs_angle } else { 0.0 };
|
||||
let dir = nearest_axis(s.isoplane, (p - base).rotate(-a)).rotate(a);
|
||||
let r = base + dir * (p - base).dot(dir);
|
||||
if r.is_finite() { r } else { p }
|
||||
}
|
||||
@@ -214,16 +216,29 @@ pub struct GridLine {
|
||||
/// major line. Empty when a family would need more than [`MAX_GRID_LINES`] lines.
|
||||
pub fn grid_lines(view: Bounds2, d: f64, origin: Vec2, angle: f64, major_every: u32) -> Vec<GridLine> {
|
||||
let Some(d) = spacing(d) else { return Vec::new() };
|
||||
// Neighbouring lines of a family are d·cos 30° apart.
|
||||
families(view, &[30.0, 90.0, 150.0], d * COS30, origin, angle, major_every)
|
||||
}
|
||||
|
||||
/// The rectangular grid lines (lines along X and along Y, `d` apart, through `origin`, turned by
|
||||
/// `angle`) that cross `view`; every `major_every`th line of a family is a major line. Empty when
|
||||
/// a family would need more than [`MAX_GRID_LINES`] lines.
|
||||
pub fn rect_grid_lines(view: Bounds2, d: f64, origin: Vec2, angle: f64, major_every: u32) -> Vec<GridLine> {
|
||||
let Some(d) = spacing(d) else { return Vec::new() };
|
||||
families(view, &[0.0, 90.0], d, origin, angle, major_every)
|
||||
}
|
||||
|
||||
/// Lines along each of `degs` (turned by `angle`), `gap` apart, one through `origin`, clipped to
|
||||
/// `view`.
|
||||
fn families(view: Bounds2, degs: &[f64], gap: f64, origin: Vec2, angle: f64, major_every: u32) -> Vec<GridLine> {
|
||||
let angle = if angle.is_finite() { angle } else { 0.0 };
|
||||
if !(view.min.is_finite() && view.max.is_finite() && origin.is_finite()) {
|
||||
return Vec::new();
|
||||
}
|
||||
let corners = [view.min, Vec2::new(view.max.x, view.min.y), view.max, Vec2::new(view.min.x, view.max.y)];
|
||||
// Neighbouring lines of a family are d·cos 30° apart.
|
||||
let gap = d * COS30;
|
||||
let major_every = i64::from(major_every.max(1));
|
||||
let mut out = Vec::new();
|
||||
for deg in [30.0f64, 90.0, 150.0] {
|
||||
for ° in degs {
|
||||
let dir = Vec2::from_angle(deg.to_radians() + angle);
|
||||
let n = dir.perp();
|
||||
let off = origin.dot(n);
|
||||
@@ -289,4 +304,50 @@ mod tests {
|
||||
assert!(grid_lines(v, 1e-9, Vec2::ZERO, 0.0, 5).is_empty());
|
||||
assert!(grid_lines(v, f64::NAN, Vec2::ZERO, 0.0, 5).is_empty());
|
||||
}
|
||||
|
||||
/// The rectangular grid: lines along X and Y through the snap base, `d` apart, every
|
||||
/// `major_every`th major, all turned by SNAPANG (in the World UCS too) and clipped to the view.
|
||||
#[test]
|
||||
fn rect_grid_lines_lie_in_the_snap_frame() {
|
||||
let v = Bounds2 { min: Vec2::new(0.0, 0.0), max: Vec2::new(10.0, 10.0) };
|
||||
let lines = rect_grid_lines(v, 1.0, Vec2::ZERO, 0.0, 5);
|
||||
// 0..=10 along each axis.
|
||||
assert_eq!(lines.len(), 22);
|
||||
let inside = |p: Vec2| p.x >= -1e-9 && p.x <= 10.0 + 1e-9 && p.y >= -1e-9 && p.y <= 10.0 + 1e-9;
|
||||
assert!(lines.iter().all(|l| inside(l.a) && inside(l.b)));
|
||||
let vertical_major: Vec<f64> = lines.iter().filter(|l| (l.a.x - l.b.x).abs() < 1e-9 && l.major).map(|l| l.a.x).collect();
|
||||
assert_eq!(vertical_major.len(), 3, "x = 0, 5 and 10");
|
||||
assert!(vertical_major.iter().all(|x| (x / 5.0 - (x / 5.0).round()).abs() < 1e-9));
|
||||
// Turned 30° about a base at (0.5, 0.25): every line runs at 30° or 120°, and one of each
|
||||
// passes through the base.
|
||||
let (base, a) = (Vec2::new(0.5, 0.25), 30f64.to_radians());
|
||||
let turned = rect_grid_lines(v, 1.0, base, a, 5);
|
||||
assert!(!turned.is_empty());
|
||||
let (ux, uy) = (Vec2::from_angle(a), Vec2::from_angle(a).perp());
|
||||
for l in &turned {
|
||||
let d = (l.b - l.a).normalized();
|
||||
assert!(d.cross(ux).abs() < 1e-9 || d.cross(uy).abs() < 1e-9, "{l:?}");
|
||||
// Each line is a whole number of steps from the base across its direction.
|
||||
let k = (l.a - base).cross(d);
|
||||
assert!((k - k.round()).abs() < 1e-9, "{l:?}");
|
||||
}
|
||||
let through = |dir: Vec2| turned.iter().any(|l| (l.b - l.a).normalized().cross(dir).abs() < 1e-9 && (base - l.a).cross(dir).abs() < 1e-9);
|
||||
assert!(through(ux) && through(uy));
|
||||
// Too many lines, or no spacing: nothing drawn.
|
||||
assert!(rect_grid_lines(v, 1e-6, Vec2::ZERO, 0.0, 5).is_empty());
|
||||
assert!(rect_grid_lines(v, f64::NAN, Vec2::ZERO, 0.0, 5).is_empty());
|
||||
assert!(rect_grid_lines(v, 1.0, Vec2::new(f64::INFINITY, 0.0), 0.0, 5).is_empty());
|
||||
}
|
||||
|
||||
/// A view far larger than any grid (a zoom to hostile extents) draws no grid instead of
|
||||
/// overflowing the line count.
|
||||
#[test]
|
||||
fn rect_grid_lines_survive_extreme_views() {
|
||||
let huge = Bounds2::new(Vec2::new(-1e300, -1e300), Vec2::new(1e300, 1e300));
|
||||
assert!(rect_grid_lines(huge, 1.0, Vec2::ZERO, 0.0, 5).is_empty());
|
||||
let far = Bounds2::new(Vec2::new(1e300, 1e300), Vec2::new(1e300 + 1.0, 1e300 + 1.0));
|
||||
assert!(rect_grid_lines(far, 1.0, Vec2::ZERO, 0.0, 5).len() <= 2 * (MAX_GRID_LINES + 1));
|
||||
let normal = Bounds2::new(Vec2::new(-5.0, 0.0), Vec2::new(5.0, 10.0));
|
||||
assert_eq!(rect_grid_lines(normal, 1.0, Vec2::ZERO, 0.0, 5).len(), 22);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -259,12 +259,14 @@ impl TrackConfig {
|
||||
/// direction (radians) of the last segment when the base point ends it.
|
||||
pub fn relative_to(s: &crate::Settings, angbase: f64, last: Option<f64>) -> Self {
|
||||
let additional: &[f64] = if s.polar_flags & polarmode::ADDITIONAL != 0 { &s.polaraddang } else { &[] };
|
||||
let absolute = polar_angles(s.polarang, additional, angbase);
|
||||
// Measured in the current UCS: from ANGBASE off its X axis.
|
||||
let ucs = if s.ucs_angle.is_finite() { s.ucs_angle } else { 0.0 };
|
||||
let absolute = polar_angles(s.polarang, additional, angbase + ucs);
|
||||
let polar = match last.filter(|a| a.is_finite() && s.polar_flags & polarmode::RELATIVE != 0) {
|
||||
Some(a) => polar_angles(s.polarang, additional, a),
|
||||
None => absolute.clone(),
|
||||
};
|
||||
let track_angles = if s.polar_flags & polarmode::TRACK_POLAR != 0 { absolute } else { orthogonal() };
|
||||
let track_angles = if s.polar_flags & polarmode::TRACK_POLAR != 0 { absolute } else { orthogonal(ucs) };
|
||||
TrackConfig {
|
||||
otrack: s.otrack,
|
||||
osmode: s.osmode,
|
||||
@@ -279,9 +281,9 @@ impl TrackConfig {
|
||||
}
|
||||
}
|
||||
|
||||
/// Horizontal and vertical, both ways.
|
||||
fn orthogonal() -> Vec<f64> {
|
||||
vec![0.0, PI / 2.0, PI, 1.5 * PI]
|
||||
/// Along the UCS axes (turned `ucs` radians from the world's), both ways.
|
||||
fn orthogonal(ucs: f64) -> Vec<f64> {
|
||||
[0.0, PI / 2.0, PI, 1.5 * PI].iter().map(|a| norm_angle(a + ucs)).collect()
|
||||
}
|
||||
|
||||
/// Every multiple of the increment `inc` (POLARANG) around the circle, plus the `additional`
|
||||
@@ -807,10 +809,11 @@ impl crate::Session {
|
||||
return CursorSnap { point: h.point, snap: Some(h), track: None, wait };
|
||||
}
|
||||
// Isometric snap (SNAPSTYL 1): its lattice in place of the rectangular grid.
|
||||
let (raw, s) = super::iso::grid_snap(&doc, s, raw);
|
||||
let snapmode = s.snapmode;
|
||||
let (raw, mut s) = super::iso::grid_snap(&doc, &space, s, raw);
|
||||
let mut p = raw;
|
||||
if s.snapmode && !s.polarsnap {
|
||||
let (origin, angle) = super::grid_frame(&doc);
|
||||
let (origin, angle) = super::grid_frame_in(&doc, &space);
|
||||
p = super::grid_snap(p, doc.header.snap_unit(), origin, angle);
|
||||
}
|
||||
if let Some(mut t) = self.tracking.track(&doc, &space, p, q.aperture, q.tol, &cfg, q.base) {
|
||||
@@ -829,7 +832,10 @@ impl crate::Session {
|
||||
&& s.orthomode
|
||||
&& !q.corner
|
||||
{
|
||||
p = super::iso::ortho(&self.settings, b, p);
|
||||
// Grid snap as it was before the isometric lattice took it (`grid_snap` turns it off),
|
||||
// so ortho keeps whole snap steps along the isometric axes.
|
||||
s.snapmode = snapmode;
|
||||
p = super::iso::ortho(&s, b, p);
|
||||
}
|
||||
CursorSnap { point: p, snap: None, track: None, wait }
|
||||
}
|
||||
|
||||
@@ -424,8 +424,8 @@ mod tests {
|
||||
for k in 0..400 {
|
||||
let p = Vec2::new(r.r(-5.0, 105.0), r.r(-5.0, 105.0));
|
||||
let ap = [0.05, 0.3, 1.5][k % 3];
|
||||
let a = select::pick_with(&d, &Space::Model, &ix, p, ap);
|
||||
let b = select::pick_with(&d, &Space::Model, &None, p, ap);
|
||||
let a = select::pick_with(&d, &Space::Model, &ix, &[], p, ap);
|
||||
let b = select::pick_with(&d, &Space::Model, &None, &[], p, ap);
|
||||
assert_eq!(a, b, "seed {seed} p {p:?} ap {ap}");
|
||||
hits += usize::from(a.is_some());
|
||||
}
|
||||
@@ -444,12 +444,15 @@ mod tests {
|
||||
let b = a + Vec2::new(r.r(-40.0, 40.0), r.r(-40.0, 40.0));
|
||||
let bx = Bounds2::new(a, b);
|
||||
for crossing in [false, true] {
|
||||
let x = select::select_window_with(&d, &Space::Model, &ix, bx, crossing);
|
||||
let y = select::select_window_with(&d, &Space::Model, &None, bx, crossing);
|
||||
let x = select::select_window_with(&d, &Space::Model, &ix, &[], bx, crossing);
|
||||
let y = select::select_window_with(&d, &Space::Model, &None, &[], bx, crossing);
|
||||
assert_eq!(x, y, "seed {seed} box {bx:?} crossing {crossing}");
|
||||
}
|
||||
let fence: Vec<Vec2> = (0..(2 + k % 3)).map(|_| Vec2::new(r.r(0.0, 100.0), r.r(0.0, 100.0))).collect();
|
||||
assert_eq!(select::select_fence_with(&d, &Space::Model, &ix, &fence), select::select_fence_with(&d, &Space::Model, &None, &fence));
|
||||
assert_eq!(
|
||||
select::select_fence_with(&d, &Space::Model, &ix, &[], &fence),
|
||||
select::select_fence_with(&d, &Space::Model, &None, &[], &fence)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -484,10 +487,13 @@ mod tests {
|
||||
for (p, ap) in
|
||||
[(Vec2::new(f64::NAN, 1.0), 1.0), (Vec2::new(1.0, 1.0), f64::NAN), (Vec2::new(f64::INFINITY, 0.0), 1.0), (Vec2::new(50.0, 50.0), 1e300)]
|
||||
{
|
||||
assert_eq!(select::pick_with(&d, &Space::Model, &ix, p, ap), select::pick_with(&d, &Space::Model, &None, p, ap));
|
||||
assert_eq!(select::pick_with(&d, &Space::Model, &ix, &[], p, ap), select::pick_with(&d, &Space::Model, &None, &[], p, ap));
|
||||
}
|
||||
let bx = Bounds2 { min: Vec2::new(f64::NEG_INFINITY, 0.0), max: Vec2::new(f64::INFINITY, 50.0) };
|
||||
assert_eq!(select::select_window_with(&d, &Space::Model, &ix, bx, true), select::select_window_with(&d, &Space::Model, &None, bx, true));
|
||||
assert_eq!(
|
||||
select::select_window_with(&d, &Space::Model, &ix, &[], bx, true),
|
||||
select::select_window_with(&d, &Space::Model, &None, &[], bx, true)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -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)),
|
||||
@@ -184,6 +188,19 @@ pub fn get(s: &Session, name: &str) -> Option<Value> {
|
||||
json!([v.center.x, v.center.y, 0.0])
|
||||
}
|
||||
"VIEWSIZE" => json!(s.state().ok()?.view().height),
|
||||
// The current UCS of the space commands act on (paper space has its own per layout),
|
||||
// set by the UCS command.
|
||||
"UCSNAME" | "UCSORG" | "UCSXDIR" | "UCSYDIR" | "WORLDUCS" => {
|
||||
let (u, name) = s.ucs_named();
|
||||
let p = |v: cadcraft_geom::Vec3| json!([v.x, v.y, v.z]);
|
||||
match n.as_str() {
|
||||
"UCSNAME" => json!(name),
|
||||
"UCSORG" => p(u.origin),
|
||||
"UCSXDIR" => p(u.x),
|
||||
"UCSYDIR" => p(u.y),
|
||||
_ => json!(i32::from(u.is_world())),
|
||||
}
|
||||
}
|
||||
// The view twist (DVIEW TWist), in degrees counterclockwise.
|
||||
"VIEWTWIST" => json!(s.state().ok()?.view().twist.to_degrees()),
|
||||
"EXTMIN" | "EXTMAX" => {
|
||||
@@ -254,6 +271,7 @@ const READ_ONLY: &[&str] = &[
|
||||
"TILEMODE",
|
||||
"PLATFORM",
|
||||
"DBMOD",
|
||||
"HANDSEED",
|
||||
"BLOCKEDITOR",
|
||||
"CTAB",
|
||||
"LASTPOINT",
|
||||
@@ -267,6 +285,11 @@ const READ_ONLY: &[&str] = &[
|
||||
"EXTMAX",
|
||||
"UNDOCTL",
|
||||
"UNDOMARKS",
|
||||
"UCSNAME",
|
||||
"UCSORG",
|
||||
"UCSXDIR",
|
||||
"UCSYDIR",
|
||||
"WORLDUCS",
|
||||
];
|
||||
|
||||
pub fn is_read_only(name: &str) -> bool {
|
||||
|
||||
@@ -73,6 +73,9 @@ const HEADER: &[(&str, Kind, Def)] = &[
|
||||
("TEXTFILL", Kind::Choice(&[0, 1]), Def::Int(1)),
|
||||
("TRIMEXTENDMODE", Kind::Choice(&[0, 1]), Def::Int(1)),
|
||||
("TRIMMODE", Kind::Choice(&[0, 1]), Def::Int(1)),
|
||||
("UCSAXISANG", Kind::Choice(&[5, 10, 15, 18, 22, 30, 45, 90, 180]), Def::Int(90)),
|
||||
// 1: the UCS icon is shown; 2: at the UCS origin when that is on screen.
|
||||
("UCSICON", Kind::Int(0, 3), Def::Int(3)),
|
||||
("WIPEOUTFRAME", Kind::Choice(&[0, 1, 2]), Def::Int(1)),
|
||||
// XCLIP boundaries: 0 hidden, 1 shown and plotted, 2 shown but not plotted.
|
||||
("XCLIPFRAME", Kind::Choice(&[0, 1, 2]), Def::Int(2)),
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user