mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-20 04:41:47 -06:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9349579052 | ||
|
|
871141ac08 |
@@ -27,6 +27,7 @@ permissions:
|
||||
jobs:
|
||||
freebsd:
|
||||
# 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/freebsd.yml@main
|
||||
uses: storytold/craft-common-actions/.github/workflows/freebsd.yml@e1ca595ea8837f21bfecda718a145ed8dcf46508
|
||||
with:
|
||||
architectures: '["aarch64"]'
|
||||
craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
|
||||
|
||||
@@ -114,7 +114,3 @@ 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.
|
||||
|
||||
+1
-3
@@ -23,7 +23,6 @@ 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`. |
|
||||
@@ -63,7 +62,6 @@ 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 |
|
||||
@@ -78,6 +76,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); 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/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/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
+3
-391
@@ -156,21 +156,6 @@ 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"
|
||||
@@ -299,9 +284,6 @@ 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"
|
||||
@@ -531,12 +513,6 @@ 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"
|
||||
@@ -592,16 +568,6 @@ 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"
|
||||
@@ -668,11 +634,9 @@ dependencies = [
|
||||
"pollster 1.0.1",
|
||||
"rfd",
|
||||
"ron",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sys-locale",
|
||||
"thiserror 2.0.21",
|
||||
"uds_windows",
|
||||
"windows",
|
||||
"winit",
|
||||
"winresource",
|
||||
@@ -718,7 +682,6 @@ version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-color",
|
||||
"cadcraft-geom",
|
||||
"craft-dxf",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
@@ -737,7 +700,6 @@ dependencies = [
|
||||
"cadcraft-render",
|
||||
"craft-docpath",
|
||||
"craft-dxf",
|
||||
"craft-mime",
|
||||
"libc",
|
||||
"log",
|
||||
"rstar",
|
||||
@@ -752,8 +714,6 @@ version = "0.21.0"
|
||||
dependencies = [
|
||||
"cadcraft-geom",
|
||||
"craft-dxf",
|
||||
"craft-font-catalog",
|
||||
"craft-shx",
|
||||
"encoding_rs",
|
||||
"harfrust 0.14.0",
|
||||
"icu_segmenter",
|
||||
@@ -780,15 +740,13 @@ dependencies = [
|
||||
"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",
|
||||
]
|
||||
|
||||
@@ -800,8 +758,6 @@ dependencies = [
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"clap",
|
||||
"craft-jsonrpc",
|
||||
"craft-mcp",
|
||||
"getrandom 0.4.3",
|
||||
"libc",
|
||||
"log",
|
||||
@@ -817,7 +773,6 @@ dependencies = [
|
||||
"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",
|
||||
@@ -836,7 +791,6 @@ dependencies = [
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"chrono",
|
||||
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
|
||||
"craft-ui",
|
||||
"craft-update",
|
||||
"craft-window",
|
||||
@@ -1177,16 +1131,6 @@ 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=219c1d0b14177af6f291395d6587f61a5e09043a#219c1d0b14177af6f291395d6587f61a5e09043a"
|
||||
|
||||
[[package]]
|
||||
name = "craft-docpath"
|
||||
version = "0.1.0"
|
||||
@@ -1204,25 +1148,13 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-dxf"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=219c1d0b14177af6f291395d6587f61a5e09043a#219c1d0b14177af6f291395d6587f61a5e09043a"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=006e4df225fca57e95ead0fb1f91920900798a99#006e4df225fca57e95ead0fb1f91920900798a99"
|
||||
dependencies = [
|
||||
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=219c1d0b14177af6f291395d6587f61a5e09043a)",
|
||||
"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"
|
||||
@@ -1251,123 +1183,6 @@ 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"
|
||||
@@ -1378,45 +1193,6 @@ 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"
|
||||
@@ -1441,7 +1217,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-update"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"dunce",
|
||||
@@ -1496,16 +1272,6 @@ 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"
|
||||
@@ -1995,22 +1761,6 @@ 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"
|
||||
@@ -2515,9 +2265,6 @@ 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"
|
||||
@@ -2820,12 +2567,9 @@ checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"byteorder-lite",
|
||||
"color_quant",
|
||||
"gif",
|
||||
"moxcms",
|
||||
"num-traits",
|
||||
"png",
|
||||
"qoi",
|
||||
"tiff",
|
||||
"zune-core",
|
||||
"zune-jpeg",
|
||||
@@ -2965,12 +2709,6 @@ 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"
|
||||
@@ -3054,7 +2792,6 @@ dependencies = [
|
||||
"arrayvec",
|
||||
"euclid",
|
||||
"polycool",
|
||||
"serde",
|
||||
"smallvec",
|
||||
]
|
||||
|
||||
@@ -3064,12 +2801,6 @@ 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"
|
||||
@@ -3110,19 +2841,6 @@ 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"
|
||||
@@ -3275,28 +2993,6 @@ 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"
|
||||
@@ -4165,15 +3861,6 @@ 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"
|
||||
@@ -4284,17 +3971,6 @@ 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"
|
||||
@@ -4402,15 +4078,6 @@ 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"
|
||||
@@ -4768,16 +4435,6 @@ 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"
|
||||
@@ -5001,12 +4658,6 @@ 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"
|
||||
@@ -5424,27 +5075,6 @@ 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"
|
||||
@@ -6620,15 +6250,6 @@ 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"
|
||||
@@ -6638,15 +6259,6 @@ 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"
|
||||
|
||||
+3
-12
@@ -14,11 +14,8 @@ repository = "https://github.com/storytold/cadcraft"
|
||||
# internal
|
||||
cadcraft-geom = { path = "crates/geom" }
|
||||
# DXF tags: the shared reader and writer (moved from crates/dxf; craft-libs#791).
|
||||
craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "219c1d0b14177af6f291395d6587f61a5e09043a" }
|
||||
craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "006e4df225fca57e95ead0fb1f91920900798a99" }
|
||||
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" }
|
||||
@@ -28,17 +25,11 @@ 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"] }
|
||||
@@ -47,7 +38,7 @@ clap_mangen = { version = "0.3.3", features = ["env"] }
|
||||
thiserror = "2"
|
||||
same-file = "1"
|
||||
serde = { version = "1", features = ["derive", "rc"] }
|
||||
serde_json = { version = "1", features = ["float_roundtrip", "raw_value"] }
|
||||
serde_json = { version = "1", features = ["float_roundtrip"] }
|
||||
log = "0.4"
|
||||
# All date/time conversion goes through chrono (no hand-rolled calendar code beyond the 400-year range extension; AGENTS.md).
|
||||
chrono = { version = "0.4.45", default-features = false, features = ["std"] }
|
||||
@@ -81,7 +72,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 = "e98299546f5c5c3c22388d16507f8b5e61a5f280", features = ["egui"] }
|
||||
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", 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 via craft-dwg. Its source
|
||||
Mozilla Public License 2.0 and is used unmodified as a separate library (crates/dwg). Its source
|
||||
is available from crates.io and the repository above.
|
||||
|
||||
|
||||
@@ -48,127 +48,3 @@ 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.
|
||||
*/
|
||||
|
||||
@@ -208,8 +208,6 @@ The logger is `apps/cadcraft/src/logging.rs`; the web build logs to the browser
|
||||
cadcraft-cli mcp
|
||||
# …or bridged to the running app (start it with --control 7979):
|
||||
cadcraft-cli mcp --connect 127.0.0.1:7979
|
||||
# …or headless, with the agent confined to a work folder:
|
||||
cadcraft-cli mcp --automation-read-root ~/work --automation-write-root ~/work/out
|
||||
|
||||
# One-shot headless runs:
|
||||
cadcraft-cli run --sample --script 'CIRCLE 22,3 1\n' --save out.dxf --export out.png
|
||||
|
||||
+21
-50
@@ -1,23 +1,21 @@
|
||||
# CADCraft roadmap
|
||||
|
||||
**Stage: pre-alpha** · next: alpha, when the six rows of the [alpha gate](docs/roadmap.md#alpha-gate) pass (five fail today; the gate was revised on 2026-11-19 and its hours are not re-estimated yet)
|
||||
**Stage: pre-alpha** · next: alpha, ~2 points (38% → 40% ready for real work) and ~125–190 Opus 5.5 hours away (the four failing core workflows of the [alpha gate](docs/roadmap.md#alpha-gate))
|
||||
|
||||
> **Last reviewed:** 2026-11-19 · **Last updated:** 2026-11-19 · **Change:** major (alpha gate revised from user reports: six rows, Windows first; Upcoming re-ranked into three priority tiers; previously minor: re-audit against main 41d9b5e95) · **Target:** Autodesk AutoCAD 2027
|
||||
> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-10-24 · **Change:** minor (re-audit against main 41d9b5e95: language table, CI gate, open-PR count; previously: progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027
|
||||
|
||||
CADCraft targets full parity with AutoCAD (2D drafting first, then annotation, layouts and
|
||||
plotting, DWG, parametrics and 3D), plus what AutoCAD doesn't have: agent control over MCP, a
|
||||
scriptable CLI, a web build, Linux and FreeBSD builds, and a free licence.
|
||||
|
||||
**Why pre-alpha:** five of the six rows of the [alpha gate](docs/roadmap.md#alpha-gate) fail. The gate
|
||||
was revised on 2026-11-19 from what people report: about 525 of the issues open or closed in the
|
||||
last 30 days come from people describing their own drawings, hardware or workflow, and the ones that
|
||||
name a platform name Windows most (135; Linux 57, macOS 36, web 14). They report an app that
|
||||
doesn't start on older graphics hardware, large or foreign DWG files that are refused, freeze or open
|
||||
wrong, clicks lost while the mouse moves, layouts in the wrong units, and a menu bar or panels that
|
||||
can't be brought back. Drafting, dimensioning and annotating a sheet nearly passes. Dynamic-block
|
||||
authoring, editing an xref in place and exact ellipse and spline geometry had almost no reports behind
|
||||
them and moved to the beta checklist. Ready for real work (≈ 38%, not re-scored since 2026-10-10) is
|
||||
also under the ~40% alpha bar. Beta is ≈ 600–930 h away.
|
||||
**Why pre-alpha:** four of AutoCAD's five core workflows fail the [alpha gate](docs/roadmap.md#alpha-gate).
|
||||
Precise drafting still has approximate ellipse and spline intersections and a few stubbed prompt options
|
||||
(object snap tracking, TRIM/EXTEND/OFFSET options and typed snap overrides have landed); dynamic blocks can't be
|
||||
authored and xrefs can't be edited in place (the Block Editor, REFEDIT, dynamic block editing and XCLIP have landed);
|
||||
plots go only to PDF, PNG and SVG files (plot styles and the Plot dialog have landed); and a DWG saved by
|
||||
CADCraft drops what acadrust doesn't model and has never been checked in
|
||||
AutoCAD. Dimensioning passes. Ready for real work (≈ 38%) is also under the ~40% alpha bar. Beta
|
||||
is ≈ 600–930 h away.
|
||||
|
||||
## Headline numbers
|
||||
|
||||
@@ -27,7 +25,7 @@ also under the ~40% alpha bar. Beta is ≈ 600–930 h away.
|
||||
| Ready for real work | **≈ 38%** | estimated ([target-app-parity.md](docs/target-app-parity.md)) |
|
||||
| Mainstream practitioner (2D drafter) | **≈ 28%** (lower than the full number: file exchange, stability and interaction discounts multiply) | estimated ([target-app-parity.md](docs/target-app-parity.md#mainstream-practitioner)) |
|
||||
| Essentials user | **≈ 46%** | estimated ([target-app-parity.md](docs/target-app-parity.md#essentials-user)) |
|
||||
| Remaining to alpha | **≈ 125–190 h** (estimated 2026-10-10 for the previous gate; not re-estimated for the revised one) | estimated |
|
||||
| Remaining to alpha | **≈ 125–190 h** (the gate rows) | estimated |
|
||||
| Remaining to beta | **≈ 600–930 h** (≈ 150–250 h elapsed with 4–6 agents) | estimated |
|
||||
| Remaining to full parity | **≈ 1,300–2,100 h** (≈ 330–550 h elapsed) | estimated |
|
||||
|
||||
@@ -107,43 +105,17 @@ Other languages shipped: Ukrainian (1,357 rows, the reference catalog, #36), Cze
|
||||
|
||||
## Upcoming
|
||||
|
||||
Ranked in three tiers; a higher tier goes first whenever it has work. Within a tier, a fix that is
|
||||
already written and waiting in a pull request lands before new work starts, whoever wrote it. Detail
|
||||
and the beta checklist are in [docs/roadmap.md](docs/roadmap.md).
|
||||
Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md).
|
||||
|
||||
**1. Urgent: security fixes, leaks, crashes and lost work.**
|
||||
- The open findings of the security audit (#1919–#1935): check each against the input limits that
|
||||
landed on 2026-11-11, close what is fixed and fix the rest. A crafted handle that makes new entities
|
||||
overwrite existing ones (#1921) is fixed by #1276.
|
||||
- Hostile-input fixes waiting in pull requests (#2820, #2821, #2765).
|
||||
- Crashes and hangs with a reproduction: the web build on a large DXF (#1603), a DWG with 3D content
|
||||
(#2174), startup on older graphics hardware (#1724, #1631, #3222).
|
||||
|
||||
**2. Parity with AutoCAD: the alpha gate rows, then the beta checklist (apart from its items named under tier 3).**
|
||||
- It starts on common hardware (#1596, then an automatic fallback renderer).
|
||||
- It opens the DWG and DXF files people already have: large files (#3102, #2633, #1088), layouts and
|
||||
paper units (#1672, #2836), and a corpus of real files run in CI.
|
||||
- Saving loses nothing and other CAD programs open the result (#2904, #1687, #3234, #2632).
|
||||
- Input feels like AutoCAD for Windows: clicks while the mouse moves (#1001, #2092), right-click and
|
||||
Space as Enter (#1387), double-click to edit text (#842).
|
||||
- The prompt options that still say "not available yet", and TRIM/EXTEND depth.
|
||||
- Layouts print at scale on a system printer, and the menu bar and panels can always be restored
|
||||
(#3216, #1240).
|
||||
- 714 pull requests are open (2026-11-19). About 230 are mergeable, pass CI and are small; they are
|
||||
reviewed and landed in this order, the longest-waiting authors first within a row.
|
||||
|
||||
**3. Lower priority: affects fewer people and nothing breaks without it.**
|
||||
- Dynamic-block authoring, editing an xref in place, exact ellipse and spline geometry, correct
|
||||
polyline offsets.
|
||||
- Prompt options that need 3D (DVIEW's camera options, -RENAME Material); 3D itself comes after 1.0,
|
||||
but a file with 3D content must open safely (tier 1).
|
||||
- Menu breadth against AutoCAD for Mac as a headline number.
|
||||
|
||||
Done since the last ranking: precision input (#379, #441, #60, #519), prompt options in TRIM/EXTEND,
|
||||
OFFSET, ROTATE, PLINE, SPLINE, MTEXT and MLEADER (#397, #408, #547), autosave, recovery, AUDIT and
|
||||
RECOVER on the desktop (#406, #416), xrefs (#525), groups (#417), the Block Editor (#824, #833, #885),
|
||||
REFEDIT (#818), XCLIP (#2354), dynamic block references (#838–#883), and the Dimension Style Manager
|
||||
(#1460).
|
||||
1. Gate and land: CI runs `cargo xtask ci` on every PR since #1987 (fmt on main is fixed); land the 450 open PRs (2026-10-24) (15–25 h).
|
||||
2. Stop losing data on save (DXF done, #528; native MULTILEADER, #459, and the save version, #421, done; through DWG, acadrust still drops some content) (30–45 h).
|
||||
3. Real-file DWG/DXF corpus and a black-box check in AutoCAD (10–15 h + owner).
|
||||
4. ~~Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
|
||||
editable dynamic input.~~ Done (#379, #441, #60, #519; `snap/tracking.rs`, `pointmod.rs`, `dyninput.rs`).
|
||||
5. ~~Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER.~~ Done (#397, #408, #547); the stubs left are in gaps F1.
|
||||
6. ~~Autosave, recovery, AUDIT, RECOVER.~~ Done on the desktop (#406, #416); the web build has no autosave (gaps F4).
|
||||
7. Exact ellipse/spline geometry and correct polyline offsets (30–50 h).
|
||||
8. Xrefs, block editor, groups, then dynamic blocks (80–120 h): xrefs (#525), groups (#417), the Block Editor (#824, #833, #885), REFEDIT (#818), XCLIP and XCLIPFRAME (#2354) and dynamic block references (#838–#883) landed; left: dynamic-block authoring, editing an xref in place.
|
||||
|
||||
## Progress log
|
||||
|
||||
@@ -166,7 +138,6 @@ REFEDIT (#818), XCLIP (#2354), dynamic block references (#838–#883), and the D
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-11-19 | major | Alpha gate revised from user reports (six rows, Windows first; block authoring, xref editing in place and exact curve geometry moved to beta); Upcoming re-ranked into three tiers: urgent (security, leaks, crashes, lost work), parity, lower priority; percentages and hours not re-scored |
|
||||
| 2026-10-24 | minor | Re-audit against main 41d9b5e95: language table, CI gate and open-PR count re-checked against main 41d9b5e95 |
|
||||
| 2026-10-21 | trivial | Progress log: proxy objects keep their class through a save (#1812) |
|
||||
| 2026-10-14 | minor | Progress log: HATCHEDIT boundary add/remove |
|
||||
|
||||
@@ -276,13 +276,6 @@ pub(crate) struct McpArgs {
|
||||
/// port first (macOS)
|
||||
#[arg(long, requires = "connect")]
|
||||
pub(crate) launch: bool,
|
||||
/// The only folder the agent's commands may read from; reads are also allowed under the write
|
||||
/// root (headless only)
|
||||
#[arg(long, value_name = "DIR")]
|
||||
pub(crate) automation_read_root: Option<String>,
|
||||
/// The only folder the agent's commands may write to, never the folder itself (headless only)
|
||||
#[arg(long, value_name = "DIR")]
|
||||
pub(crate) automation_write_root: Option<String>,
|
||||
#[command(flatten)]
|
||||
pub(crate) settings: Settings,
|
||||
}
|
||||
@@ -415,18 +408,12 @@ enum UsageError {
|
||||
/// The output is one of the input files, so writing it would replace the original.
|
||||
#[error("{} is an input file, so the result would replace the original: choose another output, or pass --in-place to overwrite it", .0.display())]
|
||||
OutIsInput(PathBuf),
|
||||
/// The automation roots confine the headless server; a running app enforces its own access.
|
||||
#[error(
|
||||
"--automation-read-root and --automation-write-root confine the headless MCP server; a running app enforces its own file access (not yet available: see issue #1585)"
|
||||
)]
|
||||
AutomationRootsNeedHeadless,
|
||||
}
|
||||
|
||||
impl UsageError {
|
||||
/// This error in clap's form, so it prints with the usual usage text.
|
||||
fn into_clap(self, cmd: &mut clap::Command) -> clap::Error {
|
||||
let kind = match self {
|
||||
Self::FramingNeedsImage { .. } | Self::OutIsInput(_) | Self::AutomationRootsNeedHeadless => ErrorKind::ArgumentConflict,
|
||||
Self::FramingNeedsImage { .. } | Self::OutIsInput(_) => ErrorKind::ArgumentConflict,
|
||||
};
|
||||
cmd.error(kind, self)
|
||||
}
|
||||
@@ -498,13 +485,6 @@ fn framing_error(cli: &Cli) -> Option<UsageError> {
|
||||
(!cadcraft_io::is_image(out)).then(|| UsageError::FramingNeedsImage { flag, out: out.to_path_buf() })
|
||||
}
|
||||
|
||||
/// The automation roots confine the headless server only, as the other Craft apps' do.
|
||||
fn roots_need_headless(cli: &Cli) -> Option<UsageError> {
|
||||
let Command::Mcp(m) = &cli.command else { return None };
|
||||
(m.connect.is_some() && (m.automation_read_root.is_some() || m.automation_write_root.is_some()))
|
||||
.then_some(UsageError::AutomationRootsNeedHeadless)
|
||||
}
|
||||
|
||||
/// An output that is the same file as an input, without `--in-place`. An output that doesn't exist
|
||||
/// can't be an input, and an I/O error in the comparison is left to the open or write that follows.
|
||||
fn out_is_input(cli: &Cli) -> Option<UsageError> {
|
||||
@@ -523,20 +503,19 @@ fn out_is_input(cli: &Cli) -> Option<UsageError> {
|
||||
/// The backend `cadcraft-cli mcp` serves from.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub(crate) enum McpTarget {
|
||||
/// An in-process drawing session (no `--connect`), optionally confined to the two folders.
|
||||
Headless { read_root: Option<String>, write_root: Option<String> },
|
||||
/// An in-process drawing session (no `--connect`).
|
||||
Headless,
|
||||
/// The running app's control channel at `HOST:PORT`; `lazy`: reached at the first call;
|
||||
/// `launch`: opened then if it isn't running.
|
||||
Connect { addr: String, lazy: bool, launch: bool },
|
||||
}
|
||||
|
||||
impl McpArgs {
|
||||
/// What these arguments ask the server to talk to.
|
||||
pub(crate) fn target(&self) -> McpTarget {
|
||||
match &self.connect {
|
||||
// `--launch` connects at the first call too (the app opens then).
|
||||
Some(addr) => McpTarget::Connect { addr: addr.clone(), lazy: self.lazy || self.launch, launch: self.launch },
|
||||
None => McpTarget::Headless { read_root: self.automation_read_root.clone(), write_root: self.automation_write_root.clone() },
|
||||
None => McpTarget::Headless,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -609,7 +588,7 @@ fn parse_with(mut cmd: clap::Command, args: &[OsString]) -> Result<Cli, clap::Er
|
||||
if let (Command::Run(r), Some((_, m))) = (&mut cli.command, matches.subcommand()) {
|
||||
(r.drawings, r.steps) = run_order(m);
|
||||
}
|
||||
if let Some(e) = framing_error(&cli).or_else(|| out_is_input(&cli)).or_else(|| roots_need_headless(&cli)) {
|
||||
if let Some(e) = framing_error(&cli).or_else(|| out_is_input(&cli)) {
|
||||
if let Some(sub) = matches.subcommand_name().and_then(|n| cmd.find_subcommand_mut(n)) {
|
||||
return Err(e.into_clap(sub));
|
||||
}
|
||||
@@ -665,24 +644,9 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// Without `--connect` the server runs headless, confining nothing unless asked.
|
||||
#[test]
|
||||
fn mcp_without_connect_is_headless() {
|
||||
assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless { read_root: None, write_root: None });
|
||||
}
|
||||
|
||||
/// The automation roots confine a headless server; `--connect` is refused with the reason
|
||||
/// (the running app's control channel is not confined yet, #1585).
|
||||
#[test]
|
||||
fn mcp_automation_roots_confine_a_headless_server_only() {
|
||||
assert_eq!(
|
||||
mcp(&["--automation-read-root", "/work", "--automation-write-root=/work/out"]).unwrap(),
|
||||
McpTarget::Headless { read_root: Some("/work".into()), write_root: Some("/work/out".into()) }
|
||||
);
|
||||
let e = mcp(&["--connect", "127.0.0.1:7979", "--automation-read-root", "/work"]).unwrap_err().to_string();
|
||||
assert!(e.contains("headless MCP server") && e.contains("#1585"), "{e}");
|
||||
let e = mcp(&["--automation-write-root=/work", "--connect", "127.0.0.1:7979"]).unwrap_err().to_string();
|
||||
assert!(e.contains("headless MCP server"), "{e}");
|
||||
assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -27,9 +27,6 @@ pub(crate) enum CliError {
|
||||
NotUnicode(std::path::PathBuf),
|
||||
#[error("cannot connect to {addr}: {source}")]
|
||||
McpConnect { addr: String, source: std::io::Error },
|
||||
/// An `--automation-*-root` that cannot be opened (missing, a file, a link that escapes).
|
||||
#[error("{0}")]
|
||||
AutomationRoots(String),
|
||||
}
|
||||
|
||||
pub(crate) type Result<T = (), E = CliError> = std::result::Result<T, E>;
|
||||
|
||||
@@ -54,8 +54,6 @@ 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.
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
use super::args::{McpArgs, McpTarget};
|
||||
use super::error::{CliError, Result};
|
||||
|
||||
/// Serve MCP on stdin and stdout against the running app or a headless session held to any roots given.
|
||||
pub(crate) fn mcp(a: &McpArgs) -> Result {
|
||||
let backend: Box<dyn cadcraft_mcp::Backend> = match a.target() {
|
||||
McpTarget::Connect { addr, lazy: true, launch } => Box::new(cadcraft_mcp::Remote::lazy(&addr, launch)),
|
||||
@@ -9,14 +8,7 @@ pub(crate) fn mcp(a: &McpArgs) -> Result {
|
||||
Ok(r) => Box::new(r),
|
||||
Err(source) => return Err(CliError::McpConnect { addr, source }),
|
||||
},
|
||||
McpTarget::Headless { read_root, write_root } => {
|
||||
let roots = cadcraft_engine::file_access::AutomationRoots::new(
|
||||
read_root.as_deref().map(std::path::Path::new),
|
||||
write_root.as_deref().map(std::path::Path::new),
|
||||
)
|
||||
.map_err(CliError::AutomationRoots)?;
|
||||
Box::new(cadcraft_mcp::Headless::default().with_automation_roots(roots))
|
||||
}
|
||||
McpTarget::Headless => Box::new(cadcraft_mcp::Headless::default()),
|
||||
};
|
||||
let stdin = std::io::stdin();
|
||||
let stdout = std::io::stdout();
|
||||
|
||||
@@ -1,404 +0,0 @@
|
||||
//! `cadcraft-cli mcp --automation-read-root <dir> --automation-write-root <dir>` (#1472): through
|
||||
//! the MCP protocol, files open only from inside the read root and are saved, exported, plotted and
|
||||
//! rendered only inside the write root; `..` and links that leave a root are refused, and nothing is
|
||||
//! written outside. Without roots nothing changes.
|
||||
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Never crash).
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Output, Stdio};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const INIT: &str = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}"#;
|
||||
|
||||
/// A folder of a test's own, removed when the test ends, also when it fails.
|
||||
struct TestDir(PathBuf);
|
||||
|
||||
impl std::ops::Deref for TestDir {
|
||||
type Target = Path;
|
||||
/// The folder itself.
|
||||
fn deref(&self) -> &Path {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TestDir {
|
||||
/// Removes the folder and all it holds; a failure here must not hide the test's own.
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// A new folder of this test's own: made here, so nothing else put it there first.
|
||||
fn fresh_dir(tag: &str) -> TestDir {
|
||||
let mut n = 0u32;
|
||||
loop {
|
||||
let dir = std::env::temp_dir().join(format!("cc-mcp-roots-{tag}-{}-{n}", std::process::id()));
|
||||
match std::fs::create_dir(&dir) {
|
||||
Ok(()) => return TestDir(dir),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
|
||||
Err(e) => panic!("{}: {e}", dir.display()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A folder holding `in` (the read root, with `a.dxf`), `out` (the write root), `outside` (with
|
||||
/// `b.dxf`) and `in2` (a sibling with the same prefix as `in`).
|
||||
fn folders(tag: &str) -> TestDir {
|
||||
let base = fresh_dir(tag);
|
||||
for d in ["in", "out", "outside", "in2"] {
|
||||
std::fs::create_dir_all(base.join(d)).unwrap();
|
||||
}
|
||||
for p in ["in/a.dxf", "outside/b.dxf", "in2/c.dxf"] {
|
||||
let drawing = cadcraft_engine::doc::Drawing::new_imperial();
|
||||
std::fs::write(base.join(p), cadcraft_io::write(&drawing, "x.dxf").unwrap()).unwrap();
|
||||
}
|
||||
base
|
||||
}
|
||||
|
||||
/// `p` as the text a tool call passes.
|
||||
fn s(p: &Path) -> String {
|
||||
p.to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
/// One tool call's result: `isError` and its first text block.
|
||||
struct Tool {
|
||||
error: bool,
|
||||
text: String,
|
||||
}
|
||||
|
||||
/// Run `cadcraft-cli mcp` with `args`, initialise, then make each call in order.
|
||||
fn run(args: &[&str], calls: &[(&str, Value)]) -> (Output, Vec<Tool>) {
|
||||
run_env(args, calls, &[])
|
||||
}
|
||||
|
||||
/// [`run`], with `env` set for the server process (a private settings folder).
|
||||
fn run_env(args: &[&str], calls: &[(&str, Value)], env: &[(&str, &str)]) -> (Output, Vec<Tool>) {
|
||||
let mut input = format!("{INIT}\n");
|
||||
for (i, (name, arguments)) in calls.iter().enumerate() {
|
||||
let req = json!({"jsonrpc": "2.0", "id": i + 2, "method": "tools/call", "params": {"name": name, "arguments": arguments}});
|
||||
input.push_str(&req.to_string());
|
||||
input.push('\n');
|
||||
}
|
||||
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
|
||||
.arg("mcp")
|
||||
.args(args)
|
||||
.envs(env.iter().copied())
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()
|
||||
.expect("spawn cadcraft-cli");
|
||||
if let Some(mut stdin) = child.stdin.take() {
|
||||
stdin.write_all(input.as_bytes()).unwrap();
|
||||
}
|
||||
let out = child.wait_with_output().expect("wait for cadcraft-cli");
|
||||
let replies: Vec<Value> = String::from_utf8_lossy(&out.stdout).lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
|
||||
let tools = calls
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, (name, arguments))| {
|
||||
let id = (i + 2) as u64;
|
||||
let reply = replies.iter().find(|v| v["id"] == id).unwrap_or_else(|| panic!("no reply to {name} {arguments}: {replies:?}"));
|
||||
assert!(reply.get("error").is_none() && reply["result"].is_object(), "{name} {arguments} got an error reply, not a tool result: {reply}");
|
||||
let result = &reply["result"];
|
||||
Tool { error: result["isError"] == true, text: result["content"][0]["text"].as_str().unwrap_or_default().to_string() }
|
||||
})
|
||||
.collect();
|
||||
(out, tools)
|
||||
}
|
||||
|
||||
/// The call succeeded.
|
||||
fn ok(t: &Tool) {
|
||||
assert!(!t.error, "should be allowed: {}", t.text);
|
||||
}
|
||||
|
||||
/// The call was refused, saying `why`.
|
||||
fn refused(t: &Tool, why: &str) {
|
||||
assert!(t.error, "should be refused ({why}): {}", t.text);
|
||||
assert!(t.text.contains(why), "should say `{why}`: {}", t.text);
|
||||
}
|
||||
|
||||
/// `open` and every other read stay inside the read root or the write root.
|
||||
#[test]
|
||||
fn files_open_only_from_inside_the_read_root() {
|
||||
let base = folders("open");
|
||||
let (out, t) = run(
|
||||
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
|
||||
&[
|
||||
("open", json!({"path": s(&base.join("in/a.dxf"))})),
|
||||
("open", json!({"path": s(&base.join("outside/b.dxf"))})),
|
||||
("open", json!({"path": s(&base.join("in2/c.dxf"))})),
|
||||
("open", json!({"path": format!("{}/../outside/b.dxf", s(&base.join("in")))})),
|
||||
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
ok(&t[0]);
|
||||
refused(&t[1], "outside the read root");
|
||||
refused(&t[2], "outside the read root");
|
||||
refused(&t[3], "outside the read root");
|
||||
// A refused path is an ordinary tool error; the session keeps working.
|
||||
ok(&t[4]);
|
||||
}
|
||||
|
||||
/// Writes stay inside the write root, the root itself is refused, and no temporary file is left outside.
|
||||
#[test]
|
||||
fn writes_go_only_into_the_write_root_and_leave_no_temp_file_outside() {
|
||||
let base = folders("write");
|
||||
let out = s(&base.join("out"));
|
||||
let (out_run, t) = run(
|
||||
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &out],
|
||||
&[
|
||||
("open", json!({"path": s(&base.join("in/a.dxf"))})),
|
||||
("save", json!({"path": s(&base.join("out/saved.dxf"))})),
|
||||
("save", json!({"path": s(&base.join("outside/saved.dxf"))})),
|
||||
("save", json!({"path": s(&base.join("in/a.dxf"))})),
|
||||
("save", json!({"path": format!("{}/../outside/up.dxf", s(&base.join("out")))})),
|
||||
("save", json!({"path": out})),
|
||||
("save", json!({"path": format!("{out}/../out")})),
|
||||
("execute", json!({"command": "export", "params": {"path": s(&base.join("out/art.png")), "format": "png"}})),
|
||||
("execute", json!({"command": "export", "params": {"path": s(&base.join("outside/art.png")), "format": "png"}})),
|
||||
("render", json!({"path": s(&base.join("out/view.png"))})),
|
||||
("render", json!({"path": s(&base.join("outside/view.png"))})),
|
||||
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
|
||||
],
|
||||
);
|
||||
assert!(out_run.status.success(), "stderr: {}", String::from_utf8_lossy(&out_run.stderr));
|
||||
ok(&t[0]);
|
||||
ok(&t[1]);
|
||||
assert!(base.join("out/saved.dxf").is_file());
|
||||
refused(&t[2], "outside the write root");
|
||||
refused(&t[3], "outside the write root");
|
||||
refused(&t[4], "outside the write root");
|
||||
refused(&t[5], "the write root itself cannot be written");
|
||||
refused(&t[6], "the write root itself cannot be written");
|
||||
ok(&t[7]);
|
||||
assert!(base.join("out/art.png").is_file());
|
||||
refused(&t[8], "outside the write root");
|
||||
ok(&t[9]);
|
||||
assert!(base.join("out/view.png").is_file());
|
||||
refused(&t[10], "outside the write root");
|
||||
ok(&t[11]);
|
||||
|
||||
assert!(!base.join("outside/saved.dxf").exists());
|
||||
assert!(!base.join("outside/art.png").exists());
|
||||
assert!(!base.join("outside/view.png").exists());
|
||||
// The save's temporary file is beside the destination, inside the root; none is outside.
|
||||
assert!(!base.join("outside/saved.dxf.cadcraft-tmp").exists());
|
||||
assert!(!base.join("outside/up.dxf.cadcraft-tmp").exists());
|
||||
assert!(!base.join("out.cadcraft-tmp").exists(), "writing to the root must not leave its temporary file beside it");
|
||||
let leftovers: Vec<String> =
|
||||
std::fs::read_dir(base.join("outside")).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
|
||||
assert_eq!(leftovers, ["b.dxf"], "nothing was written outside the roots");
|
||||
let temps: Vec<String> =
|
||||
std::fs::read_dir(&*base).unwrap().filter_map(|e| e.ok()?.file_name().into_string().ok()).filter(|n| n.ends_with(".cadcraft-tmp")).collect();
|
||||
assert!(temps.is_empty(), "no temporary file beside or outside the roots: {temps:?}");
|
||||
}
|
||||
|
||||
/// A root left out grants none of its own access: a read root allows no writes, while a write root also allows reads.
|
||||
#[test]
|
||||
fn a_root_left_out_grants_none_of_its_access() {
|
||||
let base = folders("left-out");
|
||||
let (out, t) = run(
|
||||
&["--automation-read-root", &s(&base.join("in"))],
|
||||
&[("open", json!({"path": s(&base.join("in/a.dxf"))})), ("save", json!({"path": s(&base.join("out/a.dxf"))})), ("save", json!({}))],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
ok(&t[0]);
|
||||
refused(&t[1], "write authority is absent");
|
||||
// QSAVE writes over the opened drawing's own path, which is not writable either.
|
||||
refused(&t[2], "write authority is absent");
|
||||
|
||||
let (out, t) = run(
|
||||
&["--automation-write-root", &s(&base.join("out"))],
|
||||
&[
|
||||
("open", json!({"path": s(&base.join("in/a.dxf"))})),
|
||||
("save", json!({"path": s(&base.join("out/new.dxf"))})),
|
||||
// Reads are allowed under the write root: the agent can reopen what it saved.
|
||||
("open", json!({"path": s(&base.join("out/new.dxf"))})),
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
refused(&t[0], "outside the read root (or the write root)");
|
||||
ok(&t[1]);
|
||||
assert!(base.join("out/new.dxf").is_file());
|
||||
ok(&t[2]);
|
||||
}
|
||||
|
||||
/// The shared plotter settings folder is outside the roots: every action refuses and it is unchanged.
|
||||
#[test]
|
||||
fn plotter_settings_outside_the_roots_are_refused() {
|
||||
let base = folders("plotters");
|
||||
let config = base.join("config");
|
||||
let settings = config.join("plotters");
|
||||
std::fs::create_dir_all(&settings).unwrap();
|
||||
let device = cadcraft_engine::doc::PlotterConfig {
|
||||
name: "Office".into(),
|
||||
description: "not the agent's".into(),
|
||||
papers: vec![cadcraft_engine::doc::DevicePaper { name: "A4".into(), width: 210.0, height: 297.0, margins: [5.0; 4] }],
|
||||
..Default::default()
|
||||
};
|
||||
let file = settings.join("Office.plotter.json");
|
||||
let original = device.to_file_text();
|
||||
std::fs::write(&file, &original).unwrap();
|
||||
|
||||
let text = original.clone();
|
||||
let (out, t) = run_env(
|
||||
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
|
||||
&[
|
||||
("execute", json!({"command": "plottermanager", "params": {}})),
|
||||
("execute", json!({"command": "plottermanager", "params": {"action": "get", "name": "Office"}})),
|
||||
("execute", json!({"command": "plottermanager", "params": {"action": "new", "name": "Leak", "output": "pdf"}})),
|
||||
("execute", json!({"command": "plottermanager", "params": {"action": "set", "name": "Office", "description": "changed"}})),
|
||||
("execute", json!({"command": "plottermanager", "params": {"action": "load", "text": text, "name": "Leaked Copy"}})),
|
||||
("execute", json!({"command": "plottermanager", "params": {"action": "delete", "name": "Office"}})),
|
||||
],
|
||||
&[("CADCRAFT_CONFIG_DIR", &s(&config))],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
refused(&t[0], "outside the read root (or the write root)");
|
||||
refused(&t[1], "unknown plotter");
|
||||
refused(&t[2], "outside the write root");
|
||||
refused(&t[3], "unknown plotter");
|
||||
refused(&t[4], "outside the write root");
|
||||
refused(&t[5], "unknown plotter");
|
||||
|
||||
assert_eq!(std::fs::read_to_string(&file).unwrap(), original, "the shared file is unchanged");
|
||||
let names: Vec<String> = std::fs::read_dir(&settings).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
|
||||
assert_eq!(names, ["Office.plotter.json"], "nothing was created or deleted in the settings folder");
|
||||
assert!(!settings.join("Office.plotter.json.cadcraft-tmp").exists());
|
||||
}
|
||||
|
||||
/// With no roots nothing changes: files anywhere can be reached.
|
||||
#[test]
|
||||
fn without_roots_files_are_reachable_as_before() {
|
||||
let base = folders("none");
|
||||
let (out, t) =
|
||||
run(&[], &[("open", json!({"path": s(&base.join("outside/b.dxf"))})), ("save", json!({"path": s(&base.join("outside/new.dxf"))}))]);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
ok(&t[0]);
|
||||
ok(&t[1]);
|
||||
assert!(base.join("outside/new.dxf").is_file());
|
||||
}
|
||||
|
||||
/// A link inside a root leading out is refused for reads and writes.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn links_out_of_a_root_are_refused() {
|
||||
let base = folders("links");
|
||||
std::os::unix::fs::symlink(base.join("outside"), base.join("out/away")).unwrap();
|
||||
std::os::unix::fs::symlink(base.join("outside/b.dxf"), base.join("in/leak.dxf")).unwrap();
|
||||
let (out, t) = run(
|
||||
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
|
||||
&[("open", json!({"path": s(&base.join("in/leak.dxf"))})), ("save", json!({"path": s(&base.join("out/away/new.dxf"))}))],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
refused(&t[0], "outside the read root");
|
||||
refused(&t[1], "outside the write root");
|
||||
assert!(!base.join("outside/new.dxf").exists());
|
||||
}
|
||||
|
||||
/// Each kind of command that touches a file is refused outside the roots.
|
||||
#[test]
|
||||
fn every_file_a_command_touches_is_held_to_the_roots() {
|
||||
let base = folders("commands");
|
||||
let drawing = cadcraft_engine::doc::Drawing::new_imperial();
|
||||
std::fs::write(base.join("in/x.dxf"), cadcraft_io::write(&drawing, "x.dxf").unwrap()).unwrap();
|
||||
std::fs::write(base.join("in/ok.scr"), "CIRCLE 0,0 1\n").unwrap();
|
||||
std::fs::write(base.join("outside/bad.scr"), "CIRCLE 0,0 1\n").unwrap();
|
||||
let (out, t) = run(
|
||||
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
|
||||
&[
|
||||
("open", json!({"path": s(&base.join("in/a.dxf"))})),
|
||||
// SCRIPT
|
||||
("execute", json!({"command": "script", "params": {"path": s(&base.join("in/ok.scr"))}})),
|
||||
("execute", json!({"command": "script", "params": {"path": s(&base.join("outside/bad.scr"))}})),
|
||||
// XATTACH reads the referenced drawing, INSERT and IMPORT read their files.
|
||||
("execute", json!({"command": "xattach", "params": {"path": s(&base.join("in/x.dxf")), "name": "ok"}})),
|
||||
("execute", json!({"command": "xattach", "params": {"path": s(&base.join("outside/b.dxf")), "name": "bad"}})),
|
||||
("execute", json!({"command": "insert", "params": {"name": "blk", "file": s(&base.join("outside/b.dxf")), "at": [0, 0]}})),
|
||||
("execute", json!({"command": "import", "params": {"path": s(&base.join("outside/b.dxf"))}})),
|
||||
// Support files (a linetype file here) and a plot style table.
|
||||
("execute", json!({"command": "linetype", "params": {"file": s(&base.join("outside/b.dxf"))}})),
|
||||
("execute", json!({"command": "stylesmanager", "params": {"action": "load", "path": s(&base.join("outside/b.dxf"))}})),
|
||||
// PLOT writes only inside the write root; the inside plot works.
|
||||
("execute", json!({"command": "plot", "params": {"path": s(&base.join("out/plot.pdf"))}})),
|
||||
("execute", json!({"command": "plot", "params": {"path": s(&base.join("outside/plot.pdf"))}})),
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
ok(&t[0]);
|
||||
ok(&t[1]);
|
||||
refused(&t[2], "outside the read root");
|
||||
ok(&t[3]);
|
||||
refused(&t[4], "outside the read root");
|
||||
refused(&t[5], "outside the read root");
|
||||
refused(&t[6], "outside the read root");
|
||||
refused(&t[7], "outside the read root");
|
||||
refused(&t[8], "outside the read root");
|
||||
ok(&t[9]);
|
||||
assert!(base.join("out/plot.pdf").is_file());
|
||||
refused(&t[10], "outside the write root");
|
||||
assert!(!base.join("outside/plot.pdf").exists());
|
||||
}
|
||||
|
||||
/// A root that can't be opened, or roots with `--connect`, stop the server at startup.
|
||||
#[test]
|
||||
fn missing_roots_and_roots_with_connect_fail_at_startup() {
|
||||
let base = folders("bad-roots");
|
||||
let input = format!("{INIT}\n");
|
||||
let start = |args: &[&str]| {
|
||||
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
|
||||
.arg("mcp")
|
||||
.args(args)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()
|
||||
.expect("spawn cadcraft-cli");
|
||||
if let Some(mut stdin) = child.stdin.take() {
|
||||
let _ = stdin.write_all(input.as_bytes());
|
||||
}
|
||||
child.wait_with_output().expect("wait for cadcraft-cli")
|
||||
};
|
||||
let out = start(&["--automation-read-root", &s(&base.join("nope"))]);
|
||||
assert!(!out.status.success() && out.stdout.is_empty());
|
||||
assert!(String::from_utf8_lossy(&out.stderr).contains("cannot open the automation read root"));
|
||||
|
||||
let out = start(&["--automation-write-root", &s(&base.join("in/a.dxf"))]);
|
||||
assert!(!out.status.success() && out.stdout.is_empty());
|
||||
assert!(String::from_utf8_lossy(&out.stderr).contains("cannot open the automation write root"));
|
||||
|
||||
let out = start(&["--connect", "127.0.0.1:1", "--automation-read-root", &s(&base.join("in"))]);
|
||||
assert!(!out.status.success() && out.stdout.is_empty());
|
||||
assert!(String::from_utf8_lossy(&out.stderr).contains("headless MCP server"));
|
||||
}
|
||||
|
||||
/// A UNC, device or non-disk verbatim path is refused by the server before it is opened.
|
||||
/// The reply names the prefix. It is not an operating-system error from opening the path.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_network_path_is_refused_before_it_is_opened() {
|
||||
let base = folders("unc");
|
||||
let (out, t) = run(
|
||||
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
|
||||
&[
|
||||
("open", json!({"path": r"\\203.0.113.5\s\x.dwg"})),
|
||||
("open", json!({"path": r"\\?\UNC\203.0.113.5\s\x.dwg"})),
|
||||
("open", json!({"path": r"\\host@SSL\share\x.dwg"})),
|
||||
("open", json!({"path": r"\\.\PhysicalDrive0"})),
|
||||
("open", json!({"path": r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x.dwg"})),
|
||||
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
|
||||
],
|
||||
);
|
||||
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
|
||||
let kinds = ["UNC", "UNC", "UNC", "device path", "verbatim path"];
|
||||
for (tool, kind) in t.iter().zip(kinds) {
|
||||
refused(tool, kind);
|
||||
assert!(!tool.text.contains("cannot resolve") && !tool.text.to_ascii_lowercase().contains("os error"), "{}", tool.text);
|
||||
}
|
||||
ok(&t[5]);
|
||||
}
|
||||
@@ -1,749 +0,0 @@
|
||||
//! Walks every command in the registry through the real MCP server with paths outside the
|
||||
//! automation roots (#1472). Reads show as a changed access time and writes as a changed size or
|
||||
//! modification time, a removed file, or a file that was not there before, whatever the command
|
||||
//! does with the path. The same walk without roots has to find escapes, or finding none under
|
||||
//! roots would prove nothing.
|
||||
#![cfg(unix)]
|
||||
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Never crash).
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::fs::{File, FileTimes};
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Child, ChildStdin, Command, Stdio};
|
||||
use std::sync::mpsc::{Receiver, channel};
|
||||
use std::time::{Duration, SystemTime};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
/// Longest a call may take before the server counts as hung.
|
||||
const CALL_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
/// The extensions commands choose their behaviour by.
|
||||
const EXTENSIONS: &[&str] = &["dxf", "dwg", "dwt", "scr", "lsp", "lin", "pat", "pgp", "csv", "txt", "png", "pdf", "svg", "ctb"];
|
||||
/// The parameter names a command might take a path under.
|
||||
const PATH_KEYS: &[&str] =
|
||||
&["path", "file", "template", "patternFile", "from", "to", "source", "target", "output", "folder", "dir", "filename", "document"];
|
||||
/// A valid 1x1 PNG.
|
||||
const PNG: &[u8] = &[
|
||||
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0, 0x0D, 0x49, 0x48, 0x44, 0x52, 0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 0x1F, 0x15, 0xC4,
|
||||
0x89, 0, 0, 0, 0x0A, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0, 1, 0, 0, 5, 0, 1, 0x0D, 0x0A, 0x2D, 0xB4, 0, 0, 0, 0, 0x49, 0x45, 0x4E, 0x44,
|
||||
0xAE, 0x42, 0x60, 0x82,
|
||||
];
|
||||
|
||||
/// `p` as the text a tool call passes.
|
||||
fn s(p: &Path) -> String {
|
||||
p.to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
/// A running `cadcraft-cli mcp`.
|
||||
struct Server {
|
||||
child: Child,
|
||||
stdin: ChildStdin,
|
||||
replies: Receiver<Value>,
|
||||
next: u64,
|
||||
}
|
||||
|
||||
impl Server {
|
||||
/// Start the real binary as an MCP server and initialize it.
|
||||
fn start(args: &[String], cwd: &Path, config: &Path) -> Self {
|
||||
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
|
||||
.arg("mcp")
|
||||
.args(args)
|
||||
.current_dir(cwd)
|
||||
.env("CADCRAFT_CONFIG_DIR", config)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.expect("spawn cadcraft-cli");
|
||||
let stdin = child.stdin.take().unwrap();
|
||||
let stdout = child.stdout.take().unwrap();
|
||||
let (tx, replies) = channel();
|
||||
std::thread::spawn(move || {
|
||||
for line in BufReader::new(stdout).lines().map_while(Result::ok) {
|
||||
if let Ok(v) = serde_json::from_str::<Value>(&line)
|
||||
&& tx.send(v).is_err()
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
let mut server = Self { child, stdin, replies, next: 1 };
|
||||
server.request("initialize", json!({"protocolVersion": "2025-06-18"})).expect("initialize");
|
||||
server
|
||||
}
|
||||
|
||||
/// Send one JSON-RPC request; `None` if the server stopped answering.
|
||||
fn request(&mut self, method: &str, params: Value) -> Option<Value> {
|
||||
let id = self.next;
|
||||
self.next += 1;
|
||||
let req = json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params});
|
||||
writeln!(self.stdin, "{req}").ok()?;
|
||||
loop {
|
||||
let reply = self.replies.recv_timeout(CALL_TIMEOUT).ok()?;
|
||||
if reply["id"] == id {
|
||||
return Some(reply);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A tool's first text block, or `None` when the server hung or stopped.
|
||||
fn tool(&mut self, name: &str, arguments: Value) -> Option<String> {
|
||||
let reply = self.request("tools/call", json!({"name": name, "arguments": arguments}))?;
|
||||
Some(reply["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string())
|
||||
}
|
||||
|
||||
/// Like [`Self::tool`] for a call that must work: an error reply, or a result flagged as an
|
||||
/// error, fails the test.
|
||||
fn tool_ok(&mut self, name: &str, arguments: Value) -> String {
|
||||
let reply = self.request("tools/call", json!({"name": name, "arguments": arguments})).expect("the server answered");
|
||||
assert!(reply.get("error").is_none() && reply["result"]["isError"] != true, "{name} should have worked: {reply}");
|
||||
reply["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string()
|
||||
}
|
||||
|
||||
/// Run an engine command through the `execute` tool.
|
||||
fn execute(&mut self, command: &str, params: Value) -> Option<String> {
|
||||
self.tool("execute", json!({"command": command, "params": params}))
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Server {
|
||||
/// Stops the server it started.
|
||||
fn drop(&mut self) {
|
||||
let _ = self.child.kill();
|
||||
let _ = self.child.wait();
|
||||
}
|
||||
}
|
||||
|
||||
/// The folders of one walk: `in` and `out` are the roots, nothing under `outside` may be touched.
|
||||
/// A new folder of this test's own: made here, so nothing else put it there first.
|
||||
fn fresh_dir(tag: &str) -> PathBuf {
|
||||
let mut n = 0u32;
|
||||
loop {
|
||||
let dir = std::env::temp_dir().join(format!("cc-walk-{tag}-{}-{n}", std::process::id()));
|
||||
match std::fs::create_dir(&dir) {
|
||||
Ok(()) => return dir,
|
||||
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
|
||||
Err(e) => panic!("{}: {e}", dir.display()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Remove the file or folder at `p`.
|
||||
fn remove(p: &Path) {
|
||||
let _ = if p.is_dir() { std::fs::remove_dir_all(p) } else { std::fs::remove_file(p) };
|
||||
}
|
||||
|
||||
/// Remove what `dir` holds, if it exists.
|
||||
fn clear(dir: &Path) {
|
||||
for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() {
|
||||
remove(&entry.path());
|
||||
}
|
||||
}
|
||||
|
||||
struct Fixture {
|
||||
base: PathBuf,
|
||||
outside: PathBuf,
|
||||
/// Each path under `outside`, with its size, modification time and access time.
|
||||
baseline: BTreeMap<PathBuf, (u64, SystemTime, SystemTime)>,
|
||||
/// Whether this file system records reads at all (`noatime` doesn't).
|
||||
sees_reads: bool,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
/// A new fixture, finding out whether this file system records reads.
|
||||
fn new(tag: &str) -> Self {
|
||||
let base = fresh_dir(tag);
|
||||
for d in ["in", "out"] {
|
||||
std::fs::create_dir(base.join(d)).unwrap();
|
||||
}
|
||||
let probe = base.join("probe");
|
||||
std::fs::write(&probe, "x").unwrap();
|
||||
age_access_time(&probe);
|
||||
let before = std::fs::metadata(&probe).unwrap().accessed().unwrap();
|
||||
std::fs::read(&probe).unwrap();
|
||||
let sees_reads = std::fs::metadata(&probe).unwrap().accessed().unwrap() != before;
|
||||
let outside = base.join("outside");
|
||||
let mut f = Self { base, outside, baseline: BTreeMap::new(), sees_reads };
|
||||
f.reset();
|
||||
f
|
||||
}
|
||||
|
||||
/// Lay out `outside` afresh and start watching it.
|
||||
fn reset(&mut self) {
|
||||
let o = self.outside.clone();
|
||||
// The running server's working directory stays: without it a relative path can't be resolved.
|
||||
clear(&o.join("cwd"));
|
||||
for entry in std::fs::read_dir(&o).into_iter().flatten().flatten() {
|
||||
if entry.file_name() != "cwd" {
|
||||
remove(&entry.path());
|
||||
}
|
||||
}
|
||||
for d in ["cwd", "config/plotters", "recover"] {
|
||||
std::fs::create_dir_all(o.join(d)).unwrap();
|
||||
}
|
||||
let dxf = cadcraft_io::write(&cadcraft_engine::doc::Drawing::new_imperial(), "x.dxf").unwrap();
|
||||
for ext in EXTENSIONS {
|
||||
let body: &[u8] = match *ext {
|
||||
"dxf" | "dwg" | "dwt" => &dxf,
|
||||
"scr" => b"CIRCLE 0,0 5\n",
|
||||
"lsp" => b"(princ 1)\n",
|
||||
"lin" => b"*WALK,walk\nA,1,-1\n",
|
||||
"pat" => b"*WALK,walk\n0,0,0,0,1\n",
|
||||
"pgp" => b"W,*LINE\n",
|
||||
"csv" | "txt" => b"a,b\n1,2\n",
|
||||
"png" => PNG,
|
||||
_ => b"canary",
|
||||
};
|
||||
std::fs::write(o.join(format!("canary.{ext}")), body).unwrap();
|
||||
}
|
||||
// Two images, so that a drawing naming both loads them on threads of their own.
|
||||
std::fs::write(o.join("second.png"), PNG).unwrap();
|
||||
let device = cadcraft_engine::doc::PlotterConfig { name: "Office".into(), ..Default::default() };
|
||||
std::fs::write(o.join("config/plotters/Office.plotter.json"), device.to_file_text()).unwrap();
|
||||
self.watch();
|
||||
}
|
||||
|
||||
/// Start watching what is under `outside` now.
|
||||
fn watch(&mut self) {
|
||||
let o = self.outside.clone();
|
||||
self.baseline.clear();
|
||||
for p in tree(&o) {
|
||||
age_access_time(&p);
|
||||
let m = std::fs::metadata(&p).unwrap();
|
||||
self.baseline.insert(p, (m.len(), m.modified().unwrap(), m.accessed().unwrap()));
|
||||
}
|
||||
}
|
||||
|
||||
/// What happened under `outside` since [`Self::reset`]. Metadata is read before any directory
|
||||
/// listing, and directory access times are put back afterwards: the listing is how a new file
|
||||
/// is seen when the folder's modification time has not moved, and it must not look like a read.
|
||||
fn touched(&self) -> Vec<String> {
|
||||
let mut seen = Vec::new();
|
||||
for (p, (len, modified, accessed)) in &self.baseline {
|
||||
let name = p.strip_prefix(&self.outside).unwrap_or(p).display();
|
||||
match std::fs::metadata(p) {
|
||||
Err(_) => seen.push(format!("removed {name}")),
|
||||
Ok(m) if m.modified().unwrap() != *modified || (!m.is_dir() && m.len() != *len) => seen.push(format!("wrote {name}")),
|
||||
Ok(m) if self.sees_reads && m.accessed().unwrap() != *accessed => seen.push(format!("read {name}")),
|
||||
Ok(_) => {}
|
||||
}
|
||||
}
|
||||
for p in tree(&self.outside) {
|
||||
if !self.baseline.contains_key(&p) {
|
||||
let name = p.strip_prefix(&self.outside).unwrap_or(&p).display();
|
||||
seen.push(format!("created {name}"));
|
||||
}
|
||||
}
|
||||
for (p, (_, _, accessed)) in &self.baseline {
|
||||
if p.is_dir() {
|
||||
let _ = File::open(p).and_then(|f| f.set_times(FileTimes::new().set_accessed(*accessed)));
|
||||
}
|
||||
}
|
||||
seen
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Fixture {
|
||||
/// Removes the fixture folder when the test ends, also when it fails.
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.base);
|
||||
}
|
||||
}
|
||||
|
||||
/// Every file and folder under `dir`.
|
||||
fn tree(dir: &Path) -> Vec<PathBuf> {
|
||||
let mut out = vec![dir.to_path_buf()];
|
||||
for e in std::fs::read_dir(dir).unwrap().flatten() {
|
||||
if e.path().is_dir() {
|
||||
out.extend(tree(&e.path()));
|
||||
} else {
|
||||
out.push(e.path());
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Put `p`'s access time in the past, so that the next read updates it even under `relatime`.
|
||||
fn age_access_time(p: &Path) {
|
||||
let past = SystemTime::now() - Duration::from_secs(3 * 24 * 3600);
|
||||
File::open(p).unwrap().set_times(FileTimes::new().set_accessed(past)).unwrap();
|
||||
}
|
||||
|
||||
/// The `action` or `option` values a parameter doc lists: `action?: list|open|discard (…)`.
|
||||
fn actions(doc: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
for key in ["action", "option"] {
|
||||
let Some(at) = doc.find(key) else { continue };
|
||||
let rest = doc[at + key.len()..].trim_start_matches(['?', ':', ' ']);
|
||||
let end = rest.find([',', '}', '(']).unwrap_or(rest.len());
|
||||
out.extend(rest[..end].split('|').map(|w| w.trim().trim_matches('"').to_string()).filter(|w| !w.is_empty()));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The calls to try for command `id`: every path-like key set to `target`, with each action.
|
||||
fn variants(doc: &str, target: &str, handle: &str, table: &str) -> Vec<Value> {
|
||||
let mut base = json!({"handle": table, "handles": [handle], "at": [0, 0], "name": "walk"});
|
||||
for key in PATH_KEYS {
|
||||
base[*key] = json!(target);
|
||||
}
|
||||
let mut named = base.clone();
|
||||
named["name"] = json!(target);
|
||||
let mut device = base.clone();
|
||||
device["name"] = json!("Office");
|
||||
// Commands refuse parameters that don't go together, so each key the doc names goes on its own too.
|
||||
let lower = doc.to_ascii_lowercase();
|
||||
let documented = PATH_KEYS.iter().filter(|key| **key == "path" || lower.contains(&key.to_ascii_lowercase()));
|
||||
let alone = documented.flat_map(|key| {
|
||||
[
|
||||
json!({*key: target}),
|
||||
json!({*key: target, "handles": [handle]}),
|
||||
json!({*key: target, "handle": table}),
|
||||
json!({*key: target, "name": "Office"}),
|
||||
]
|
||||
});
|
||||
let mut out = Vec::new();
|
||||
for v in [base, named, device].into_iter().chain(alone) {
|
||||
out.push(v.clone());
|
||||
for a in actions(doc) {
|
||||
let mut with = v.clone();
|
||||
with["action"] = json!(a);
|
||||
with["option"] = json!(a);
|
||||
out.push(with);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Whether a command's doc says it takes a file. These get every extension; the rest, one.
|
||||
fn takes_a_file(doc: &str) -> bool {
|
||||
let d = doc.to_ascii_lowercase();
|
||||
["path", "file", "template", "folder", "action", "option"].iter().any(|w| d.contains(w))
|
||||
}
|
||||
|
||||
/// A fresh drawing with a circle and a table, selected; the circle's and table's handles.
|
||||
fn seed(server: &mut Server) -> Option<(String, String)> {
|
||||
// Closed first: the walk starts tens of thousands of drawings, and they would all stay open.
|
||||
server.execute("closeall", json!({}))?;
|
||||
server.execute("new", json!({}))?;
|
||||
let handle_of = |text: &str| serde_json::from_str::<Value>(text).ok().and_then(|v| v["handle"].as_str().map(str::to_string)).unwrap_or_default();
|
||||
let circle = server.execute("circle", json!({"center": [0, 0], "radius": 1}))?;
|
||||
let table = server.execute("table", json!({"at": [5, 5], "rows": 2, "columns": 2}))?;
|
||||
server.execute("selectall", json!({}))?;
|
||||
Some((handle_of(&circle), handle_of(&table)))
|
||||
}
|
||||
|
||||
/// What one walk saw.
|
||||
struct Walk {
|
||||
/// The command and the call that touched each file outside.
|
||||
escapes: BTreeMap<String, Vec<String>>,
|
||||
calls: usize,
|
||||
commands: usize,
|
||||
/// Calls that hung or stopped the server.
|
||||
lost: Vec<String>,
|
||||
sees_reads: bool,
|
||||
}
|
||||
|
||||
/// Run the walk, under `in` and `out` as roots or with no roots at all.
|
||||
fn walk(tag: &str, roots: bool) -> Walk {
|
||||
let mut f = Fixture::new(tag);
|
||||
let args = if roots {
|
||||
vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))]
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
let cwd = f.outside.join("cwd");
|
||||
let config = f.outside.join("config");
|
||||
let start = |f: &mut Fixture| {
|
||||
let server = Server::start(&args, &cwd, &config);
|
||||
f.reset();
|
||||
server
|
||||
};
|
||||
let mut server = start(&mut f);
|
||||
let listed = server.tool("list_commands", json!({})).expect("list_commands");
|
||||
let specs: Vec<Value> = serde_json::from_str(&listed).expect("the command list");
|
||||
assert!(specs.len() > 400, "the walk has to see the registry: {} commands", specs.len());
|
||||
let mut result = Walk { escapes: BTreeMap::new(), calls: 0, commands: specs.len(), lost: Vec::new(), sees_reads: f.sees_reads };
|
||||
|
||||
let mut steps: Vec<(String, Value)> = Vec::new();
|
||||
let o = f.outside.clone();
|
||||
let canary = |ext: &str| s(&o.join(format!("canary.{ext}")));
|
||||
let (circle, table) = seed(&mut server).expect("seed");
|
||||
assert!(!circle.is_empty(), "the seed circle has no handle");
|
||||
assert!(!table.is_empty(), "the seed table has no handle");
|
||||
for spec in &specs {
|
||||
let id = spec["id"].as_str().unwrap().to_string();
|
||||
let doc = spec["params"].as_str().unwrap_or_default();
|
||||
let mut targets: Vec<String> = if takes_a_file(doc) { EXTENSIONS.iter().map(|e| canary(e)).collect() } else { vec![canary("dxf")] };
|
||||
if takes_a_file(doc) {
|
||||
// A file that isn't there yet, in a folder that isn't there yet, and a relative path.
|
||||
targets.extend(["dxf", "png", "pdf", "csv"].iter().map(|e| s(&o.join(format!("fresh/x.{e}")))));
|
||||
targets.push("../canary.dxf".to_string());
|
||||
}
|
||||
for target in targets {
|
||||
for v in variants(doc, &target, &circle, &table) {
|
||||
steps.push((id.clone(), v));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let run_step =
|
||||
|server: &mut Server, f: &mut Fixture, result: &mut Walk, id: &str, label: String, call: &mut dyn FnMut(&mut Server) -> Option<String>| {
|
||||
result.calls += 1;
|
||||
let done = call(server);
|
||||
let touched = f.touched();
|
||||
if !touched.is_empty() {
|
||||
for what in touched {
|
||||
result.escapes.entry(id.to_string()).or_default().push(format!("{what}: {label}"));
|
||||
}
|
||||
}
|
||||
if done.is_none() {
|
||||
result.lost.push(format!("{id}: {label}"));
|
||||
}
|
||||
done.is_some()
|
||||
};
|
||||
|
||||
for (id, params) in &steps {
|
||||
let label = params.to_string();
|
||||
let params = params.clone();
|
||||
let alive = run_step(&mut server, &mut f, &mut result, id, label, &mut |sv| sv.execute(id, params.clone()));
|
||||
let dirty = !f.touched().is_empty();
|
||||
if !alive {
|
||||
server = start(&mut f);
|
||||
} else if dirty {
|
||||
f.reset();
|
||||
}
|
||||
// A command can stop the server without its own reply being lost.
|
||||
if seed(&mut server).is_none() {
|
||||
result.lost.push(format!("after {id}: {params}"));
|
||||
server = start(&mut f);
|
||||
seed(&mut server);
|
||||
}
|
||||
}
|
||||
|
||||
// The ways in that aren't one command with a path parameter.
|
||||
let dxf = canary("dxf");
|
||||
let png = canary("png");
|
||||
let scr = canary("scr");
|
||||
let lsp = canary("lsp");
|
||||
let tools: Vec<(&str, &str, Value)> = vec![
|
||||
("tool:open", "open", json!({"path": dxf})),
|
||||
("tool:save", "save", json!({"path": dxf})),
|
||||
("tool:save-new", "save", json!({"path": s(&o.join("fresh/y.dxf"))})),
|
||||
("tool:render", "render", json!({"path": png})),
|
||||
("tool:command_line", "command_line", json!({"text": format!("SCRIPT {scr}")})),
|
||||
("tool:command_line", "command_line", json!({"text": format!("OPEN {dxf}")})),
|
||||
("tool:command_line", "command_line", json!({"text": format!("SAVEAS {dxf}")})),
|
||||
("tool:script", "script", json!({"text": format!("OPEN {dxf}\n")})),
|
||||
];
|
||||
for (label, name, a) in tools {
|
||||
let text = a.to_string();
|
||||
let a = a.clone();
|
||||
let alive = run_step(&mut server, &mut f, &mut result, label, text, &mut |sv| sv.tool(name, a.clone()));
|
||||
if alive {
|
||||
f.reset();
|
||||
} else {
|
||||
server = start(&mut f);
|
||||
}
|
||||
seed(&mut server);
|
||||
}
|
||||
let lisp = [
|
||||
format!("(setq f (open {dxf:?} \"r\")) (read-line f) (close f)"),
|
||||
format!("(setq f (open {dxf:?} \"w\")) (write-line \"x\" f) (close f)"),
|
||||
format!("(setq f (open {:?} \"w\")) (write-line \"x\" f) (close f)", s(&o.join("new.txt"))),
|
||||
format!("(load {lsp:?})"),
|
||||
];
|
||||
for code in lisp {
|
||||
let label = code.clone();
|
||||
run_step(&mut server, &mut f, &mut result, "lisp:code", label, &mut |sv| sv.execute("lisp", json!({"code": code})));
|
||||
f.reset();
|
||||
seed(&mut server);
|
||||
}
|
||||
// Settings that name a file or a folder, then the commands that use them.
|
||||
let chained: Vec<(&str, Vec<(&str, Value)>)> = vec![
|
||||
(
|
||||
"stylesmanager",
|
||||
vec![
|
||||
("stylesmanager", json!({"action": "new", "name": "walk.ctb"})),
|
||||
("stylesmanager", json!({"action": "save", "name": "walk.ctb", "path": canary("ctb")})),
|
||||
("stylesmanager", json!({"action": "load", "path": canary("ctb")})),
|
||||
],
|
||||
),
|
||||
(
|
||||
"pdfbook",
|
||||
vec![("pline", json!({"points": [[0, 0], [210, 0], [210, 297], [0, 297]], "closed": true})), ("pdfbook", json!({"path": canary("pdf")}))],
|
||||
),
|
||||
("setvar:SAVEFILEPATH", vec![("setvar", json!({"name": "SAVEFILEPATH", "value": s(&o.join("recover"))})), ("drawingrecovery", json!({}))]),
|
||||
("setvar:QNEWTEMPLATE", vec![("setvar", json!({"name": "QNEWTEMPLATE", "value": dxf})), ("new", json!({}))]),
|
||||
];
|
||||
for (label, calls) in chained {
|
||||
for (id, params) in calls {
|
||||
run_step(&mut server, &mut f, &mut result, label, format!("{id} {params}"), &mut |sv| sv.execute(id, params.clone()));
|
||||
}
|
||||
f.reset();
|
||||
seed(&mut server);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// One line saying what a walk saw.
|
||||
fn summary(w: &Walk) -> String {
|
||||
format!(
|
||||
"{} commands, {} calls, reads seen: {}, {} commands touched files outside, {} calls lost the server",
|
||||
w.commands,
|
||||
w.calls,
|
||||
w.sees_reads,
|
||||
w.escapes.len(),
|
||||
w.lost.len()
|
||||
)
|
||||
}
|
||||
|
||||
/// Under roots, nothing in the registry reaches a file outside them.
|
||||
#[test]
|
||||
fn no_command_escapes_the_roots() {
|
||||
let w = walk("roots", true);
|
||||
println!("under roots: {}", summary(&w));
|
||||
let found: Vec<String> = w.escapes.iter().flat_map(|(id, what)| what.iter().take(3).map(move |l| format!("{id}: {l}"))).collect();
|
||||
assert!(found.is_empty(), "escapes under the roots:\n{}", found.join("\n"));
|
||||
assert!(w.lost.is_empty(), "calls that lost the server: {:?}", w.lost);
|
||||
}
|
||||
|
||||
/// The control: without roots the same walk finds these commands reaching the same files. If this
|
||||
/// fails, the walk has stopped reaching them and [`no_command_escapes_the_roots`] proves nothing.
|
||||
#[test]
|
||||
fn the_walk_finds_escapes_without_roots() {
|
||||
let w = walk("control", false);
|
||||
println!("without roots: {}", summary(&w));
|
||||
let found: BTreeSet<&str> = w.escapes.keys().map(String::as_str).collect();
|
||||
println!("touched files outside: {}", found.iter().copied().collect::<Vec<_>>().join(" "));
|
||||
let writers = [
|
||||
"saveas",
|
||||
"export",
|
||||
"plot",
|
||||
"exportpdf",
|
||||
"publish",
|
||||
"pdfbook",
|
||||
"wblock",
|
||||
"-wblock",
|
||||
"layout.saveas",
|
||||
"layout",
|
||||
"stylesmanager",
|
||||
"tableexport",
|
||||
"dataextraction",
|
||||
"tool:save",
|
||||
"tool:save-new",
|
||||
"tool:render",
|
||||
"lisp:code",
|
||||
];
|
||||
// What a command touched is kept with its kind (`wrote`, `created`, `removed`, `read`): a writer
|
||||
// must show a write, not just a read, or a writer that only reads would still pass.
|
||||
let kinds = |id: &str, kinds: &[&str]| w.escapes.get(id).is_some_and(|e| e.iter().any(|l| kinds.iter().any(|k| l.starts_with(k))));
|
||||
let not_writing: Vec<&str> = writers.into_iter().filter(|id| !kinds(id, &["wrote ", "created ", "removed "])).collect();
|
||||
assert!(not_writing.is_empty(), "the walk no longer finds these writing outside: {not_writing:?}; touched: {:?}", w.escapes);
|
||||
if w.sees_reads {
|
||||
for id in [
|
||||
"open",
|
||||
"new",
|
||||
"recover",
|
||||
"script",
|
||||
"import",
|
||||
"insert",
|
||||
"minsert",
|
||||
"xattach",
|
||||
"-xref",
|
||||
"compare",
|
||||
"imageattach",
|
||||
"attach",
|
||||
"aliasedit",
|
||||
"linetype",
|
||||
"hatch.patterns",
|
||||
"plottermanager",
|
||||
"appload",
|
||||
"datalink",
|
||||
"tool:open",
|
||||
"setvar:QNEWTEMPLATE",
|
||||
"setvar:SAVEFILEPATH",
|
||||
] {
|
||||
assert!(kinds(id, &["read "]), "the walk no longer finds `{id}` reading outside: {found:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A drawing inside the roots can't bring in what it names outside them: an image or an xref saved
|
||||
/// with a path outside stays unloaded, and nothing outside is read.
|
||||
#[test]
|
||||
fn a_drawing_cannot_reach_files_it_names_outside_the_roots() {
|
||||
let mut f = Fixture::new("named");
|
||||
let host = f.base.join("in/host.dxf");
|
||||
{
|
||||
// Made without roots: a drawing someone hands the agent.
|
||||
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
free.execute("new", json!({})).unwrap();
|
||||
let image = free.execute("imageattach", json!({"path": s(&f.outside.join("canary.png"))})).unwrap();
|
||||
assert!(image.contains("handle"), "the image attaches: {image}");
|
||||
let second = free.execute("imageattach", json!({"path": s(&f.outside.join("second.png"))})).unwrap();
|
||||
assert!(second.contains("handle"), "the second image attaches: {second}");
|
||||
let xref = free.execute("xattach", json!({"path": s(&f.outside.join("canary.dxf")), "name": "walk"})).unwrap();
|
||||
assert!(xref.contains("handle"), "the xref attaches: {xref}");
|
||||
free.execute("saveas", json!({"path": s(&host)})).unwrap();
|
||||
}
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
f.reset();
|
||||
let opened = server.tool("open", json!({"path": s(&host)})).unwrap();
|
||||
let images = server.execute("image", json!({})).unwrap();
|
||||
let xrefs = server.execute("xref", json!({})).unwrap();
|
||||
server.tool_ok("render", json!({}));
|
||||
let touched = f.touched();
|
||||
assert!(touched.is_empty(), "{touched:?}\nopen: {opened}\nimage: {images}\nxref: {xrefs}");
|
||||
assert!(images.contains("canary.png") && !images.contains("\"Loaded\""), "the image stays unloaded: {images}");
|
||||
assert!(images.contains("\"foundAt\": null") || images.contains("\"foundAt\":null"), "and it isn't said to exist: {images}");
|
||||
assert!(!xrefs.contains("\"Loaded\""), "the xref stays unloaded: {xrefs}");
|
||||
}
|
||||
|
||||
/// A font linked into the drawing's folder isn't read from where the link leads.
|
||||
#[test]
|
||||
fn a_font_linked_beside_a_drawing_is_not_followed_out() {
|
||||
let mut f = Fixture::new("font");
|
||||
let host = f.base.join("in/host.dxf");
|
||||
{
|
||||
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
free.execute("new", json!({})).unwrap();
|
||||
free.execute("style", json!({"name": "Walk", "font": "walkfont.shx"})).unwrap();
|
||||
free.execute("style.current", json!({"name": "Walk"})).unwrap();
|
||||
let text = free.execute("text", json!({"at": [0, 0], "height": 5, "text": "walk"})).unwrap();
|
||||
assert!(text.contains("handle"), "the text is drawn: {text}");
|
||||
free.execute("saveas", json!({"path": s(&host)})).unwrap();
|
||||
}
|
||||
let saved = std::fs::read_to_string(&host).unwrap();
|
||||
assert!(saved.to_ascii_lowercase().contains("walkfont.shx"), "the drawing names the font");
|
||||
std::fs::write(f.outside.join("walkfont.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
|
||||
std::os::unix::fs::symlink(f.outside.join("walkfont.shx"), f.base.join("in/walkfont.shx")).unwrap();
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
f.reset();
|
||||
std::fs::write(f.outside.join("walkfont.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
|
||||
f.watch();
|
||||
server.tool_ok("open", json!({"path": s(&host)}));
|
||||
server.tool_ok("render", json!({}));
|
||||
let touched = f.touched();
|
||||
assert!(touched.is_empty(), "{touched:?}");
|
||||
}
|
||||
|
||||
/// Saving through a link that stands outside the roots and points in doesn't leave a backup
|
||||
/// beside the link.
|
||||
#[test]
|
||||
fn a_backup_stays_inside_the_roots() {
|
||||
let f = Fixture::new("backup");
|
||||
let target = f.base.join("out/t.dxf");
|
||||
std::fs::write(&target, cadcraft_io::write(&cadcraft_engine::doc::Drawing::new_imperial(), "x.dxf").unwrap()).unwrap();
|
||||
let link = f.outside.join("link.dxf");
|
||||
std::os::unix::fs::symlink(&target, &link).unwrap();
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
server.tool("new_drawing", json!({})).unwrap();
|
||||
let saved = server.tool("save", json!({"path": s(&link)})).unwrap();
|
||||
assert!(saved.contains("outside the write root"), "{saved}");
|
||||
assert!(!f.outside.join("link.dxf.bak").exists() && !f.outside.join("link.bak").exists(), "{saved}");
|
||||
}
|
||||
|
||||
/// Deleting a plotter acts on the entry in the settings folder, whatever it points at.
|
||||
#[test]
|
||||
fn a_plotter_link_outside_the_roots_is_not_removed() {
|
||||
let f = Fixture::new("plotter");
|
||||
let inside = f.base.join("out/kept.plotter.json");
|
||||
std::fs::write(&inside, cadcraft_engine::doc::PlotterConfig { name: "Kept".into(), ..Default::default() }.to_file_text()).unwrap();
|
||||
let entry = f.outside.join("config/plotters/Kept.plotter.json");
|
||||
std::os::unix::fs::symlink(&inside, &entry).unwrap();
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
let reply = server.execute("plottermanager", json!({"action": "delete", "name": "Kept"})).unwrap();
|
||||
assert!(std::fs::symlink_metadata(&entry).is_ok(), "the link is still there: {reply}");
|
||||
}
|
||||
|
||||
/// Without roots, a settings folder that can't be read leaves the built-in devices listed.
|
||||
#[test]
|
||||
fn without_roots_an_unreadable_settings_folder_still_lists_devices() {
|
||||
let f = Fixture::new("devices");
|
||||
let not_a_folder = f.outside.join("canary.txt");
|
||||
let mut server = Server::start(&[], &f.outside.join("cwd"), ¬_a_folder);
|
||||
let list = server.execute("plottermanager", json!({"action": "list"})).unwrap();
|
||||
assert!(list.contains("devices"), "{list}");
|
||||
}
|
||||
|
||||
/// A font beside a drawing inside the roots is still used.
|
||||
#[test]
|
||||
fn a_font_beside_a_drawing_inside_the_roots_is_used() {
|
||||
let f = Fixture::new("font-inside");
|
||||
let host = f.base.join("in/host.dxf");
|
||||
{
|
||||
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
free.execute("new", json!({})).unwrap();
|
||||
free.execute("style", json!({"name": "Walk", "font": "walkinside.shx"})).unwrap();
|
||||
free.execute("style.current", json!({"name": "Walk"})).unwrap();
|
||||
free.execute("text", json!({"at": [0, 0], "height": 5, "text": "walk"})).unwrap();
|
||||
free.execute("saveas", json!({"path": s(&host)})).unwrap();
|
||||
}
|
||||
let font = f.base.join("in/walkinside.shx");
|
||||
std::fs::write(&font, b"AutoCAD-86 shapes 1.0").unwrap();
|
||||
age_access_time(&font);
|
||||
let before = std::fs::metadata(&font).unwrap().accessed().unwrap();
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
server.tool_ok("open", json!({"path": s(&host)}));
|
||||
server.tool_ok("render", json!({}));
|
||||
if f.sees_reads {
|
||||
assert_ne!(std::fs::metadata(&font).unwrap().accessed().unwrap(), before, "the font was read");
|
||||
}
|
||||
}
|
||||
|
||||
/// One font that is a link leading out doesn't cost the drawing the other fonts beside it, and
|
||||
/// nothing outside is touched.
|
||||
#[test]
|
||||
fn a_font_link_leading_out_does_not_cost_the_fonts_beside_it() {
|
||||
let mut f = Fixture::new("font-mixed");
|
||||
let host = f.base.join("in/host.dxf");
|
||||
{
|
||||
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
free.execute("new", json!({})).unwrap();
|
||||
for (style, font) in [("Good", "walkgood.shx"), ("Bad", "walkbad.shx")] {
|
||||
free.execute("style", json!({"name": style, "font": font})).unwrap();
|
||||
free.execute("style.current", json!({"name": style})).unwrap();
|
||||
free.execute("text", json!({"at": [0, 0], "height": 5, "text": style})).unwrap();
|
||||
}
|
||||
free.execute("saveas", json!({"path": s(&host)})).unwrap();
|
||||
}
|
||||
let good = f.base.join("in/walkgood.shx");
|
||||
std::fs::write(&good, b"AutoCAD-86 shapes 1.0").unwrap();
|
||||
age_access_time(&good);
|
||||
let before = std::fs::metadata(&good).unwrap().accessed().unwrap();
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
f.reset();
|
||||
std::fs::write(f.outside.join("walkbad.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
|
||||
std::os::unix::fs::symlink(f.outside.join("walkbad.shx"), f.base.join("in/walkbad.shx")).unwrap();
|
||||
f.watch();
|
||||
server.tool_ok("open", json!({"path": s(&host)}));
|
||||
server.tool_ok("render", json!({}));
|
||||
let touched = f.touched();
|
||||
assert!(touched.is_empty(), "{touched:?}");
|
||||
if f.sees_reads {
|
||||
assert_ne!(std::fs::metadata(&good).unwrap().accessed().unwrap(), before, "the good font was read");
|
||||
}
|
||||
}
|
||||
|
||||
/// The fixture leaves the server's working directory in place, so a relative path meets the roots
|
||||
/// and not a folder that has gone.
|
||||
#[test]
|
||||
fn a_relative_path_is_refused_by_the_roots() {
|
||||
let mut f = Fixture::new("relative");
|
||||
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
|
||||
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
|
||||
f.reset();
|
||||
let reply = server.tool("open", json!({"path": "../canary.dxf"})).unwrap();
|
||||
assert!(reply.contains("outside the read root"), "{reply}");
|
||||
let touched = f.touched();
|
||||
assert!(touched.is_empty(), "{touched:?}");
|
||||
}
|
||||
@@ -128,8 +128,6 @@ 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;
|
||||
|
||||
@@ -20,8 +20,6 @@ cadcraft-mcp = { workspace = true }
|
||||
eframe = { workspace = true, features = ["clipboard", "wgpu", "accesskit", "wayland", "x11", "links", "persistence"] }
|
||||
egui = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
# The control request parser reads only its own keys (control_server.rs `Fields`).
|
||||
serde = { workspace = true }
|
||||
log = { workspace = true }
|
||||
clap = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
@@ -69,9 +67,6 @@ 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"] }
|
||||
|
||||
@@ -221,17 +221,12 @@ fn read_bounded_line(reader: &mut impl BufRead, buf: &mut Vec<u8>, max: usize, h
|
||||
}
|
||||
}
|
||||
|
||||
/// Longest request `id` (it is copied into the reply).
|
||||
const MAX_ID_BYTES: usize = 4096;
|
||||
|
||||
/// One request line, parsed.
|
||||
enum Line<'a> {
|
||||
enum Line {
|
||||
Request {
|
||||
id: Value,
|
||||
method: String,
|
||||
/// Left as text until the token is checked: decoding it first would let an unauthenticated
|
||||
/// peer turn a flat array into many owned JSON values.
|
||||
params: Option<&'a serde_json::value::RawValue>,
|
||||
params: Value,
|
||||
token: Option<String>,
|
||||
},
|
||||
Blank,
|
||||
@@ -240,7 +235,7 @@ enum Line<'a> {
|
||||
}
|
||||
|
||||
/// Parse a UTF-8 JSON request and its optional token, distinguishing blank lines from rejected input.
|
||||
fn parse_line(bytes: &[u8]) -> Line<'_> {
|
||||
fn parse_line(bytes: &[u8]) -> Line {
|
||||
let Ok(text) = std::str::from_utf8(bytes) else {
|
||||
return Line::Reject("not a control request (invalid UTF-8); closing the connection".into());
|
||||
};
|
||||
@@ -251,78 +246,22 @@ fn parse_line(bytes: &[u8]) -> Line<'_> {
|
||||
if is_http_request_line(text) {
|
||||
return Line::Reject("HTTP is not served here: this port takes JSON lines; closing the connection".into());
|
||||
}
|
||||
// Checked without building values; then only the object's own keys are read, each value kept as text.
|
||||
if let Err(e) = serde_json::from_str::<&serde_json::value::RawValue>(text) {
|
||||
return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection"));
|
||||
}
|
||||
let Ok(obj) = serde_json::from_str::<Fields<'_>>(text) else {
|
||||
let msg = match serde_json::from_str::<Value>(text) {
|
||||
Ok(v) => v,
|
||||
Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
|
||||
};
|
||||
let Value::Object(mut obj) = msg else {
|
||||
return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
|
||||
};
|
||||
// `method` and `token` are decoded as strings only (anything else is no string); `id` is echoed back
|
||||
// in replies, so it is decoded but bounded.
|
||||
let string = |v: Option<&serde_json::value::RawValue>| v.and_then(|r| serde_json::from_str::<String>(r.get()).ok());
|
||||
let Some(method) = string(obj.method) else {
|
||||
let Some(Value::String(method)) = obj.remove("method") else {
|
||||
return Line::Reject("not a control request (missing string `method`); closing the connection".into());
|
||||
};
|
||||
let id = match obj.id {
|
||||
None => Value::Null,
|
||||
Some(r) if r.get().len() <= MAX_ID_BYTES => match serde_json::from_str(r.get()) {
|
||||
Ok(v) => v,
|
||||
Err(e) => return Line::Reject(format!("bad `id` ({e}); closing the connection")),
|
||||
},
|
||||
Some(_) => return Line::Reject(format!("`id` is longer than {MAX_ID_BYTES} bytes; closing the connection")),
|
||||
};
|
||||
Line::Request { id, method, params: obj.params, token: string(obj.token) }
|
||||
}
|
||||
|
||||
/// The request object's own keys, each value kept as JSON text. Other keys are skipped without
|
||||
/// being stored: collecting them (in a map) would let an unauthenticated peer turn a line of many
|
||||
/// short distinct keys into many owned strings and map nodes. A repeated key takes the last value.
|
||||
#[derive(Default)]
|
||||
struct Fields<'a> {
|
||||
id: Option<&'a serde_json::value::RawValue>,
|
||||
method: Option<&'a serde_json::value::RawValue>,
|
||||
params: Option<&'a serde_json::value::RawValue>,
|
||||
token: Option<&'a serde_json::value::RawValue>,
|
||||
}
|
||||
|
||||
impl<'de> serde::Deserialize<'de> for Fields<'de> {
|
||||
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
|
||||
#[derive(serde::Deserialize)]
|
||||
#[serde(field_identifier, rename_all = "lowercase")]
|
||||
enum Key {
|
||||
Id,
|
||||
Method,
|
||||
Params,
|
||||
Token,
|
||||
#[serde(other)]
|
||||
Other,
|
||||
}
|
||||
struct Object;
|
||||
impl<'de> serde::de::Visitor<'de> for Object {
|
||||
type Value = Fields<'de>;
|
||||
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
||||
f.write_str("a JSON object")
|
||||
}
|
||||
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
|
||||
let mut fields = Fields::default();
|
||||
while let Some(key) = map.next_key::<Key>()? {
|
||||
let slot = match key {
|
||||
Key::Id => &mut fields.id,
|
||||
Key::Method => &mut fields.method,
|
||||
Key::Params => &mut fields.params,
|
||||
Key::Token => &mut fields.token,
|
||||
Key::Other => {
|
||||
map.next_value::<serde::de::IgnoredAny>()?;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
*slot = Some(map.next_value()?);
|
||||
}
|
||||
Ok(fields)
|
||||
}
|
||||
}
|
||||
d.deserialize_map(Object)
|
||||
// Moved out of the parsed object, not cloned: `params` can be most of the line.
|
||||
Line::Request {
|
||||
id: obj.remove("id").unwrap_or(Value::Null),
|
||||
method,
|
||||
params: obj.remove("params").unwrap_or(json!({})),
|
||||
token: obj.remove("token").and_then(|t| if let Value::String(t) = t { Some(t) } else { None }),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -366,16 +305,6 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
|
||||
let _ = writeln!(out, "{r}");
|
||||
break;
|
||||
}
|
||||
// Absent `params` is `{}`; ones that cannot be decoded (an unpaired surrogate escape) are an
|
||||
// error, not a request run with defaults.
|
||||
let params = match params.map(|r| serde_json::from_str::<Value>(r.get())) {
|
||||
None => json!({}),
|
||||
Some(Ok(v)) => v,
|
||||
Some(Err(e)) => {
|
||||
let _ = writeln!(out, "{}", json!({"ok": false, "error": format!("bad params ({e}); closing the connection"), "id": id}));
|
||||
break;
|
||||
}
|
||||
};
|
||||
let (req, pending) = ControlRequest::new(method, params);
|
||||
let mut r = match tx.try_send(req) {
|
||||
Ok(()) => {
|
||||
@@ -443,36 +372,6 @@ mod tests {
|
||||
assert_eq!(input.len(), 100 - 11, "the rest of the line is left unread");
|
||||
}
|
||||
|
||||
/// The parameters stay text until the token is checked, and a request decodes as before.
|
||||
#[test]
|
||||
fn params_are_decoded_only_as_text_by_the_parser() {
|
||||
let line = br#"{"id":7,"method":"m","token":"t","params":[1,2,{"a":[3]}],"extra":null}"#;
|
||||
let Line::Request { id, method, params, token } = parse_line(line) else { panic!("a request") };
|
||||
assert_eq!((id, method.as_str(), token.as_deref()), (json!(7), "m", Some("t")));
|
||||
assert_eq!(params.map(|p| p.get()), Some(r#"[1,2,{"a":[3]}]"#));
|
||||
assert!(matches!(parse_line(b"[1,2,3]"), Line::Reject(e) if e.contains("expected a JSON object")));
|
||||
assert!(matches!(parse_line(b"{\"method\":"), Line::Reject(e) if e.contains("bad JSON")));
|
||||
assert!(matches!(parse_line(br#"{"id":[1],"method":5}"#), Line::Reject(e) if e.contains("missing string `method`")));
|
||||
let long_id = format!(r#"{{"id":"{}","method":"m"}}"#, "x".repeat(MAX_ID_BYTES));
|
||||
assert!(matches!(parse_line(long_id.as_bytes()), Line::Reject(e) if e.contains("`id` is longer")));
|
||||
assert!(matches!(parse_line(br#"{"id":"\ud800","method":"m"}"#), Line::Reject(e) if e.contains("bad `id`")));
|
||||
assert!(matches!(parse_line(br#"{"id":1}"#), Line::Reject(e) if e.contains("missing string `method`")));
|
||||
}
|
||||
|
||||
/// Keys other than the request's own are skipped, not kept, however many there are; a repeated
|
||||
/// key still takes the last value, and an escaped key name is the same key.
|
||||
#[test]
|
||||
fn unknown_keys_are_skipped_and_the_last_repeated_key_wins() {
|
||||
let mut line = String::from(r#"{"method":"first","#);
|
||||
for i in 0..100_000 {
|
||||
line.push_str(&format!(r#""k{i}":{i},"#));
|
||||
}
|
||||
line.push_str(r#""method":"m","params":{"a":1},"params":[2],"token":"t"}"#);
|
||||
let Line::Request { id, method, params, token } = parse_line(line.as_bytes()) else { panic!("a request") };
|
||||
assert_eq!((id, method.as_str(), token.as_deref()), (Value::Null, "m", Some("t")));
|
||||
assert_eq!(params.map(|p| p.get()), Some("[2]"));
|
||||
}
|
||||
|
||||
fn held() -> Held {
|
||||
Held::new(Budget::new(usize::MAX))
|
||||
}
|
||||
|
||||
@@ -24,9 +24,6 @@ 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.
|
||||
@@ -84,10 +81,7 @@ 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.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")]);
|
||||
assert_eq!((parsed.control, parsed.sample, parsed.files.len()), (None, false, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! CADCraft desktop app.
|
||||
//!
|
||||
//! Usage: `cadcraft [--control <port>] [--sample] [--new-window] [files…]` (`cadcraft --help` lists the rest; see [`launch_args`])
|
||||
//! Usage: `cadcraft [--control <port>] [--sample] [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,7 +25,6 @@ mod logging;
|
||||
mod native_menu;
|
||||
#[cfg(target_os = "macos")]
|
||||
mod sheet;
|
||||
mod single_instance;
|
||||
mod spacemouse;
|
||||
mod system_animations;
|
||||
mod workspace;
|
||||
@@ -43,8 +42,6 @@ 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.
|
||||
@@ -90,17 +87,6 @@ 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
|
||||
@@ -171,8 +157,6 @@ 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 {
|
||||
@@ -233,39 +217,11 @@ fn saved_window(app_ron: &str) -> bool {
|
||||
ron::from_str::<std::collections::HashMap<String, String>>(app_ron).is_ok_and(|kv| kv.contains_key(WINDOW_KEY))
|
||||
}
|
||||
|
||||
/// The window state from the last session is saved and will be restored (#2595). A saved size
|
||||
/// below the minimum (seen on Windows: 64×64 points, which eframe restores un-maximized and
|
||||
/// unusable) is dropped first, so the window opens at its default size.
|
||||
/// The window state from the last session is saved and will be restored (#2595).
|
||||
fn restores_window() -> bool {
|
||||
let Some(path) = eframe::storage_dir(APP_ID).map(|dir| dir.join("app.ron")) else { return false };
|
||||
let Ok(mut ron) = std::fs::read_to_string(&path) else { return false };
|
||||
// Through a temporary file: a failed write (a full disk) keeps the other saved settings.
|
||||
if let Some(fixed) = without_tiny_window(&ron)
|
||||
&& cadcraft_engine::atomic_write::write_atomic(&path, fixed.as_bytes()).is_ok()
|
||||
{
|
||||
ron = fixed;
|
||||
}
|
||||
saved_window(&ron)
|
||||
eframe::storage_dir(APP_ID).and_then(|dir| std::fs::read_to_string(dir.join("app.ron")).ok()).is_some_and(|ron| saved_window(&ron))
|
||||
}
|
||||
|
||||
/// `app_ron` without its window entry when that entry's inner size is below `MIN_INNER_SIZE`;
|
||||
/// `None` when there is nothing to drop (no entry, a usable size, or an unreadable file).
|
||||
fn without_tiny_window(app_ron: &str) -> Option<String> {
|
||||
let mut kv = ron::from_str::<std::collections::BTreeMap<String, String>>(app_ron).ok()?;
|
||||
let w = kv.get(WINDOW_KEY)?;
|
||||
let size = &w[w.find("inner_size_points:")?..];
|
||||
let num = |k: &str| size[size.find(k)? + k.len()..].split([',', ')']).next()?.trim().parse::<f32>().ok();
|
||||
let (x, y) = (num("x:")?, num("y:")?);
|
||||
if x >= MIN_INNER_SIZE[0] && y >= MIN_INNER_SIZE[1] {
|
||||
return None;
|
||||
}
|
||||
kv.remove(WINDOW_KEY);
|
||||
ron::ser::to_string_pretty(&kv, ron::ser::PrettyConfig::default()).ok()
|
||||
}
|
||||
|
||||
/// The smallest main window, in points.
|
||||
const MIN_INNER_SIZE: [f32; 2] = [900.0, 560.0];
|
||||
|
||||
/// The main window: its size, title bar, placement and rendering needs. `restoring`: a window state
|
||||
/// saved by the last session is restored instead of opening centred.
|
||||
fn window_options(restoring: bool) -> eframe::NativeOptions {
|
||||
@@ -273,7 +229,7 @@ fn window_options(restoring: bool) -> eframe::NativeOptions {
|
||||
viewport: egui::ViewportBuilder::default()
|
||||
.with_title("CADCraft")
|
||||
.with_inner_size([1600.0, 1000.0])
|
||||
.with_min_inner_size(MIN_INNER_SIZE)
|
||||
.with_min_inner_size([900.0, 560.0])
|
||||
.with_drag_and_drop(true)
|
||||
.with_fullsize_content_view(true)
|
||||
.with_titlebar_shown(false)
|
||||
@@ -352,14 +308,6 @@ 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 {
|
||||
@@ -431,9 +379,6 @@ fn main() -> eframe::Result {
|
||||
app.ui = ui;
|
||||
}
|
||||
app.set_system_cursor_default(vars.system_cursor == Switch::On);
|
||||
// macOS: CADCRAFT_NO_NATIVE_MENU=1 keeps the menus inside the window.
|
||||
#[cfg(target_os = "macos")]
|
||||
app.set_native_menus(vars.no_native_menu != Switch::On);
|
||||
if let Some(error) = &workspace_error {
|
||||
eprintln!("CADCraft workspace: {error}");
|
||||
app.set_status(error);
|
||||
@@ -483,10 +428,6 @@ 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();
|
||||
@@ -498,7 +439,6 @@ 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")]
|
||||
@@ -512,7 +452,7 @@ fn main() -> eframe::Result {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{filters_for_save, follow_desktop, saved_window, window_options, without_tiny_window};
|
||||
use super::{filters_for_save, follow_desktop, saved_window, window_options};
|
||||
|
||||
#[test]
|
||||
fn save_dialog_offers_dwg_with_the_drawing_format_first() {
|
||||
@@ -556,17 +496,6 @@ mod tests {
|
||||
assert!(!saved_window("not ron at all"));
|
||||
}
|
||||
|
||||
/// A saved 64×64 window (below the minimum) is dropped; a usable one is kept.
|
||||
#[test]
|
||||
fn a_tiny_saved_window_is_dropped() {
|
||||
let tiny = r#"{"window": "(normal_geometry:(outer_position_pixels:Some((x:0.0,y:0.0)),scale_factor:1.25,inner_size_points:(x:64.0,y:64.0)),fullscreen:false,maximized:true)", "cadcraft.prefs": "{}"}"#;
|
||||
let fixed = without_tiny_window(tiny).expect("dropped");
|
||||
assert!(!saved_window(&fixed) && fixed.contains("cadcraft.prefs"));
|
||||
let ok = tiny.replace("x:64.0,y:64.0)),", "x:1600.0,y:1000.0)),");
|
||||
assert_eq!(without_tiny_window(&ok), None);
|
||||
assert_eq!(without_tiny_window("not ron"), None);
|
||||
}
|
||||
|
||||
/// View ▸ Theme ▸ System on Linux: winit reports no theme, so the desktop's answer stands in;
|
||||
/// without one (or where winit answers and the desktop doesn't) the input is left alone.
|
||||
#[test]
|
||||
|
||||
@@ -1,393 +0,0 @@
|
||||
//! 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,6 +44,7 @@ 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,10 +106,6 @@ 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
|
||||
@@ -122,14 +118,3 @@ sync_github_name = true
|
||||
|
||||
[people.helenkwok]
|
||||
real_name = "Helen Kwok"
|
||||
|
||||
[people.V1dalTheAbidal]
|
||||
sync_github_name = true
|
||||
|
||||
[people.tyrel]
|
||||
real_name = "Tyrel Haveman"
|
||||
|
||||
[people.Sladrian]
|
||||
real_name = "Sladrian Pedroso"
|
||||
display_name = "Sladrian Pedroso"
|
||||
sync_github_name = false
|
||||
|
||||
+26
-53
@@ -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,15 +11,12 @@ 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)
|
||||
}
|
||||
@@ -32,7 +29,6 @@ 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
|
||||
}
|
||||
@@ -52,8 +48,7 @@ pub enum Color {
|
||||
|
||||
impl Color {
|
||||
pub const WHITE: Color = Color::Index(7);
|
||||
/// DXF group 62 value: 0 = `ByBlock`, 256 = `ByLayer`.
|
||||
#[must_use]
|
||||
/// DXF group 62 value: 0 = ByBlock, 256 = ByLayer.
|
||||
pub fn to_aci(self) -> i16 {
|
||||
match self {
|
||||
Color::ByLayer => 256,
|
||||
@@ -62,16 +57,14 @@ 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 => u8::try_from(v).map_or(Color::ByLayer, Color::Index),
|
||||
1..=255 => Color::Index(v as u8),
|
||||
_ => 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 {
|
||||
@@ -86,8 +79,7 @@ impl Color {
|
||||
Color::True(c) => c,
|
||||
}
|
||||
}
|
||||
/// Short display name like `AutoCAD`'s Properties palette ("`ByLayer`", "Red", "Color 34", "255,128,0").
|
||||
#[must_use]
|
||||
/// Short display name like AutoCAD's Properties palette ("ByLayer", "Red", "Color 34", "255,128,0").
|
||||
pub fn name(self) -> String {
|
||||
match self {
|
||||
Color::ByLayer => "ByLayer".into(),
|
||||
@@ -110,7 +102,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 u8::try_from(i).ok().map(Color::Index);
|
||||
return Some(Color::Index(i as u8));
|
||||
}
|
||||
match t.as_str() {
|
||||
"bylayer" => return Some(Color::ByLayer),
|
||||
@@ -125,7 +117,7 @@ impl Color {
|
||||
return match i {
|
||||
0 => Some(Color::ByBlock),
|
||||
256 => Some(Color::ByLayer),
|
||||
1..=255 => u8::try_from(i).ok().map(Color::Index),
|
||||
1..=255 => Some(Color::Index(i as u8)),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@@ -153,16 +145,11 @@ 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 palette = [Rgb(0, 0, 0); 256];
|
||||
let mut p = [Rgb(0, 0, 0); 256];
|
||||
let base = [
|
||||
Rgb(0, 0, 0),
|
||||
Rgb(255, 0, 0),
|
||||
@@ -172,38 +159,37 @@ fn build_palette() -> [Rgb; 256] {
|
||||
Rgb(0, 0, 255),
|
||||
Rgb(255, 0, 255),
|
||||
Rgb(255, 255, 255),
|
||||
Rgb(65, 65, 65),
|
||||
Rgb(128, 128, 128),
|
||||
Rgb(192, 192, 192),
|
||||
];
|
||||
for (slot, colour) in palette.iter_mut().zip(base) {
|
||||
*slot = colour;
|
||||
for (slot, c) in p.iter_mut().zip(base) {
|
||||
*slot = c;
|
||||
}
|
||||
let values = [255.0, 204.0, 153.0, 127.0, 76.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);
|
||||
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);
|
||||
let half = sub % 2 == 1;
|
||||
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
|
||||
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
|
||||
};
|
||||
if let Some(slot) = palette.get_mut(index) {
|
||||
*slot = Rgb(channel(red), channel(green), channel(blue));
|
||||
if let Some(slot) = p.get_mut(i) {
|
||||
*slot = Rgb(ch(r), ch(g), ch(b));
|
||||
}
|
||||
}
|
||||
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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
palette
|
||||
p
|
||||
}
|
||||
|
||||
/// 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;
|
||||
@@ -218,7 +204,6 @@ 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 {
|
||||
@@ -235,7 +220,6 @@ 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
|
||||
@@ -302,17 +286,6 @@ 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);
|
||||
|
||||
@@ -11,7 +11,6 @@ workspace = true
|
||||
[dependencies]
|
||||
cadcraft-geom = { workspace = true }
|
||||
cadcraft-color = { workspace = true }
|
||||
craft-dxf = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
|
||||
@@ -72,10 +72,6 @@ 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`
|
||||
|
||||
+5
-87
@@ -44,11 +44,6 @@ pub use store::EntityStore;
|
||||
pub use tables::*;
|
||||
pub use xclip::{ClipBoundary, MAX_CLIP_VERTICES};
|
||||
|
||||
/// Handles at or above this are not followed: a file may name one (an object's handle, or its
|
||||
/// `$HANDSEED`), and the four billion handles above the limit stay free for the drawing's own
|
||||
/// growth. A file's handles keep their identity, however high they are (#913, #939).
|
||||
pub const HANDLE_LIMIT: u64 = u64::MAX - 0xFFFF_FFFF;
|
||||
|
||||
/// File data CADCraft doesn't model, kept for saving (#528).
|
||||
pub mod dynblock;
|
||||
pub mod foreign;
|
||||
@@ -132,17 +127,9 @@ pub struct Drawing {
|
||||
pub scales: Vec<AnnoScale>,
|
||||
/// Next free handle.
|
||||
pub handseed: u64,
|
||||
/// Handles a file's records hold in the reserved band, recorded while reading before the
|
||||
/// record is placed: [`Drawing::new_handle`] skips them meanwhile. [`Drawing::bump_handseed`]
|
||||
/// does not follow them (#913). Emptied once the file is read; never written to a file.
|
||||
pub reserved_handles: BTreeSet<u64>,
|
||||
/// 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>,
|
||||
@@ -213,9 +200,7 @@ impl Drawing {
|
||||
parametric: Parametric::default(),
|
||||
scales: imperial_scales(),
|
||||
handseed: 0x100,
|
||||
reserved_handles: BTreeSet::new(),
|
||||
hidden_objects: BTreeSet::new(),
|
||||
ucs_previous: Vec::new(),
|
||||
read_notes: Vec::new(),
|
||||
refedit: None,
|
||||
skipped_records: BTreeMap::new(),
|
||||
@@ -224,83 +209,16 @@ impl Drawing {
|
||||
}
|
||||
}
|
||||
|
||||
/// Allocate a fresh handle: [`Drawing::next_handle`], with the seed moved past it. Past the
|
||||
/// top of the range the drawing goes on growing in the reserved band (#913).
|
||||
/// Allocate a fresh handle.
|
||||
pub fn new_handle(&mut self) -> Handle {
|
||||
let h = self.next_handle();
|
||||
self.handseed = h.0.checked_add(1).unwrap_or(HANDLE_LIMIT);
|
||||
let h = Handle(self.handseed);
|
||||
self.handseed = self.handseed.saturating_add(1);
|
||||
h
|
||||
}
|
||||
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it:
|
||||
/// the first one at or above the seed that nothing holds. 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);
|
||||
/// - handles an object or a file record being read holds in the reserved band above
|
||||
/// [`HANDLE_LIMIT`]. A hostile or damaged file may name a `$HANDSEED` there, and a file
|
||||
/// object may hold that same handle; the seed does not follow a file's handles in the band,
|
||||
/// so taking it as-is would hand the file's object's handle to a new object and
|
||||
/// `EntityStore` would replace it (#913, #1921);
|
||||
/// - handle 0, which a file reads as "no handle".
|
||||
///
|
||||
/// Off the top of the range it goes on at the bottom of the band.
|
||||
///
|
||||
/// Cost: below the band the reader and [`Drawing::bump_handseed`] keep the seed above every
|
||||
/// handle an object holds (AUDIT repairs a drawing where that fails), and reserved handles are
|
||||
/// all in the band, so there only `foreign.handles` is looked up. The scan of every space and
|
||||
/// block definition runs only for a candidate in the band. Every handle skipped is a distinct
|
||||
/// one something holds, so the walk ends within one step more than the count of held handles.
|
||||
pub fn next_handle(&self) -> Handle {
|
||||
let held = |h: u64| {
|
||||
h == 0
|
||||
|| self.foreign.handles.contains_key(&Handle(h))
|
||||
|| (h >= HANDLE_LIMIT && (self.reserved_handles.contains(&h) || self.handle_in_use(Handle(h))))
|
||||
};
|
||||
let mut h = self.handseed;
|
||||
// Counted only once a handle is skipped, so the usual first-try answer costs nothing.
|
||||
let mut steps_left: Option<usize> = None;
|
||||
while held(h) {
|
||||
let left = steps_left.get_or_insert_with(|| self.held_handle_count());
|
||||
let Some(rest) = left.checked_sub(1) else { break };
|
||||
*left = rest;
|
||||
h = h.checked_add(1).unwrap_or(HANDLE_LIMIT);
|
||||
}
|
||||
Handle(h)
|
||||
}
|
||||
|
||||
/// Whether an object in any space or block definition already holds `h`.
|
||||
fn handle_in_use(&self, h: Handle) -> bool {
|
||||
self.model.contains(h) || self.layouts.iter().any(|l| l.entities.contains(h)) || self.blocks.values().any(|b| b.entities.contains(h))
|
||||
}
|
||||
/// An upper bound on how many handles [`Drawing::next_handle`] can find held, plus handle 0.
|
||||
fn held_handle_count(&self) -> usize {
|
||||
let spaces = self.layouts.iter().map(|l| l.entities.len()).chain(self.blocks.values().map(|b| b.entities.len()));
|
||||
spaces
|
||||
.fold(self.model.len(), usize::saturating_add)
|
||||
.saturating_add(self.foreign.handles.len())
|
||||
.saturating_add(self.reserved_handles.len())
|
||||
.saturating_add(1)
|
||||
}
|
||||
/// Record a handle a file's record holds in the reserved band, before the record is placed in
|
||||
/// the drawing, so [`Drawing::new_handle`] does not hand it to an object read earlier (#1276).
|
||||
///
|
||||
/// Only handles at or above [`HANDLE_LIMIT`] are recorded: below it [`Drawing::bump_handseed`]
|
||||
/// already moves the seed past them. The reservation stays separate from the seed because the
|
||||
/// writer's growth lives above the limit and a file's handles there are not followed (#913).
|
||||
pub fn reserve_handle(&mut self, h: Handle) {
|
||||
if h.0 >= HANDLE_LIMIT {
|
||||
self.reserved_handles.insert(h.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// Make sure future handles don't collide with `h` (after loading a file).
|
||||
///
|
||||
/// A handle at or above [`HANDLE_LIMIT`] is the file's own and stays as it is: it is not
|
||||
/// followed, so a new object is never given the top handle and the file's object is never
|
||||
/// replaced (#913). The handles above the limit are the drawing's room to grow.
|
||||
pub fn bump_handseed(&mut self, h: Handle) {
|
||||
if h.0 >= self.handseed && h.0 < HANDLE_LIMIT {
|
||||
self.handseed = h.0 + 1;
|
||||
if h.0 >= self.handseed {
|
||||
self.handseed = h.0.saturating_add(1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+314
-46
@@ -1,14 +1,32 @@
|
||||
//! Readers for the user's own linetype (`.lin`) and hatch pattern (`.pat`) files.
|
||||
//!
|
||||
//! Grammar and hostile-input capping live in [`craft_dxf::lin_pat`]; this module maps the
|
||||
//! parsed definitions into CADCraft's [`Linetype`] and [`UserPattern`] document types.
|
||||
|
||||
use cadcraft_geom::Vec2;
|
||||
pub use craft_dxf::lin_pat::{MAX_DEFINITIONS, MAX_LINE_CHARS, MAX_LINETYPE_ELEMENTS, MAX_PATTERN_DASHES, MAX_PATTERN_FAMILIES, MAX_VALUE, Parsed};
|
||||
//! Both follow the publicly documented text formats: a header line `*NAME[,description]`, then
|
||||
//! the definition (`A,dash,gap,…` for a linetype, `angle, x, y, dx, dy[, dash, …]` lines for
|
||||
//! a pattern), with `;` starting a comment line. CADCraft ships no such file; these read the
|
||||
//! files users bring. Everything here treats the text as hostile: lines, definitions, dashes,
|
||||
//! families and warnings are capped, numbers must be finite and reasonable, and nothing panics.
|
||||
//! Problems become warnings and the definitions that can be read are kept.
|
||||
|
||||
use super::PatternLine;
|
||||
use crate::{DashElement, Linetype};
|
||||
|
||||
/// Longest line read; longer lines are skipped with a warning.
|
||||
pub const MAX_LINE_CHARS: usize = 4096;
|
||||
/// Most definitions (linetypes or patterns) read from one file.
|
||||
pub const MAX_DEFINITIONS: usize = 4096;
|
||||
/// Most elements in one linetype.
|
||||
pub const MAX_LINETYPE_ELEMENTS: usize = 256;
|
||||
/// Most line families in one hatch pattern (what the renderer draws, too).
|
||||
pub const MAX_PATTERN_FAMILIES: usize = 1024;
|
||||
/// Most dashes in one pattern line family (as for a pattern definition read from DXF).
|
||||
pub const MAX_PATTERN_DASHES: usize = 256;
|
||||
/// Largest magnitude accepted for a length, offset or scale.
|
||||
pub const MAX_VALUE: f64 = 1.0e6;
|
||||
/// Longest name or description kept.
|
||||
const MAX_NAME_CHARS: usize = 255;
|
||||
/// Most warnings collected; the rest are counted in a last line.
|
||||
const MAX_WARNINGS: usize = 100;
|
||||
|
||||
/// A hatch pattern read from a user's `.pat` file.
|
||||
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
|
||||
pub struct UserPattern {
|
||||
@@ -17,57 +35,307 @@ pub struct UserPattern {
|
||||
pub lines: Vec<PatternLine>,
|
||||
}
|
||||
|
||||
/// What a file held: the definitions that could be read, and why anything else was skipped.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Parsed<T> {
|
||||
pub items: Vec<T>,
|
||||
pub warnings: Vec<String>,
|
||||
}
|
||||
|
||||
impl<T> Default for Parsed<T> {
|
||||
fn default() -> Self {
|
||||
Parsed { items: Vec::new(), warnings: Vec::new() }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Parsed<T> {
|
||||
fn warn(&mut self, line: usize, msg: impl Into<String>) {
|
||||
match self.warnings.len() {
|
||||
n if n < MAX_WARNINGS => self.warnings.push(format!("line {line}: {}", msg.into())),
|
||||
MAX_WARNINGS => self.warnings.push("more problems not listed".into()),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A header line `*NAME[,description]`: the name and description, or why it can't be used.
|
||||
fn header(rest: &str) -> std::result::Result<(String, String), String> {
|
||||
let (name, desc) = rest.split_once(',').unwrap_or((rest, ""));
|
||||
let name = name.trim();
|
||||
if name.is_empty() {
|
||||
return Err("a definition without a name".into());
|
||||
}
|
||||
if name.chars().count() > MAX_NAME_CHARS || name.chars().any(char::is_control) {
|
||||
return Err("a definition name that is too long or has control characters".into());
|
||||
}
|
||||
let desc: String = desc.trim().chars().filter(|c| !c.is_control()).take(MAX_NAME_CHARS).collect();
|
||||
Ok((name.to_string(), desc))
|
||||
}
|
||||
|
||||
/// A finite number within ±[`MAX_VALUE`].
|
||||
fn number(t: &str) -> Option<f64> {
|
||||
t.trim().parse::<f64>().ok().filter(|v| v.is_finite() && v.abs() <= MAX_VALUE)
|
||||
}
|
||||
|
||||
/// The file's text lines with 1-based numbers, without a leading byte-order mark.
|
||||
fn lines(text: &str) -> impl Iterator<Item = (usize, &str)> {
|
||||
text.trim_start_matches('\u{feff}').lines().enumerate().map(|(i, l)| (i.saturating_add(1), l.trim()))
|
||||
}
|
||||
|
||||
// ---------- LIN ----------
|
||||
|
||||
/// Read the linetypes of a `.lin` file. Simple linetypes and complex ones with embedded text
|
||||
/// (`["TEXT",STYLE,S=…,R=…,A=…,U=…,X=…,Y=…]`) are read; shape elements (`[SHAPE,file.shx,…]`)
|
||||
/// need SHX shape fonts, so they are left out with a warning and the dashes around them kept.
|
||||
/// Lengths are in drawing units as written: a user's file is never rescaled.
|
||||
pub fn parse_lin(text: &str) -> Parsed<Linetype> {
|
||||
let parsed = craft_dxf::lin_pat::parse_lin(text);
|
||||
Parsed {
|
||||
items: parsed
|
||||
.items
|
||||
.into_iter()
|
||||
.map(|d| Linetype {
|
||||
name: d.name,
|
||||
description: d.description,
|
||||
pattern: d
|
||||
.pattern
|
||||
.into_iter()
|
||||
.map(|e| DashElement {
|
||||
length: e.length,
|
||||
text: e.text,
|
||||
shape: None,
|
||||
style: e.style,
|
||||
scale: e.scale,
|
||||
rotation: e.rotation,
|
||||
offset: Vec2::new(e.offset[0], e.offset[1]),
|
||||
absolute: e.absolute,
|
||||
})
|
||||
.collect(),
|
||||
})
|
||||
.collect(),
|
||||
warnings: parsed.warnings,
|
||||
let mut out = Parsed::default();
|
||||
// The definition being read: name, description, header line.
|
||||
let mut pending: Option<(String, String, usize)> = None;
|
||||
for (no, line) in lines(text) {
|
||||
if line.is_empty() || line.starts_with(';') {
|
||||
continue;
|
||||
}
|
||||
if line.chars().count() > MAX_LINE_CHARS {
|
||||
out.warn(no, "line too long; skipped");
|
||||
continue;
|
||||
}
|
||||
if let Some(rest) = line.strip_prefix('*') {
|
||||
if let Some((name, _, at)) = pending.take() {
|
||||
out.warn(at, format!("linetype {name} has no pattern line; skipped"));
|
||||
}
|
||||
match header(rest) {
|
||||
Ok((name, desc)) => pending = Some((name, desc, no)),
|
||||
Err(e) => out.warn(no, format!("{e}; skipped")),
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let Some((name, description, _)) = pending.take() else {
|
||||
out.warn(no, "pattern line without a *NAME line before it; skipped");
|
||||
continue;
|
||||
};
|
||||
if out.items.len() >= MAX_DEFINITIONS {
|
||||
out.warn(no, format!("more than {MAX_DEFINITIONS} linetypes; the rest are skipped"));
|
||||
break;
|
||||
}
|
||||
if out.items.iter().any(|l: &Linetype| l.name.eq_ignore_ascii_case(&name)) {
|
||||
out.warn(no, format!("linetype {name} is defined twice; the first definition is kept"));
|
||||
continue;
|
||||
}
|
||||
match lin_pattern(line, no, &name, &mut out) {
|
||||
Ok(pattern) => out.items.push(Linetype { name, description, pattern }),
|
||||
Err(e) => out.warn(no, format!("linetype {name}: {e}; skipped")),
|
||||
}
|
||||
}
|
||||
if let Some((name, _, at)) = pending {
|
||||
out.warn(at, format!("linetype {name} has no pattern line; skipped"));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Split a pattern line at commas outside `[…]` and `"…"`.
|
||||
fn lin_fields(line: &str) -> std::result::Result<Vec<&str>, String> {
|
||||
let mut out = Vec::new();
|
||||
let (mut depth, mut quoted, mut start) = (0usize, false, 0usize);
|
||||
for (i, c) in line.char_indices() {
|
||||
match c {
|
||||
'"' => quoted = !quoted,
|
||||
'[' if !quoted => depth = depth.saturating_add(1),
|
||||
']' if !quoted => depth = depth.checked_sub(1).ok_or("a ] without its [")?,
|
||||
',' if !quoted && depth == 0 => {
|
||||
out.push(line.get(start..i).unwrap_or("").trim());
|
||||
start = i.saturating_add(1);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if out.len() > MAX_LINETYPE_ELEMENTS.saturating_mul(2) {
|
||||
return Err(format!("more than {MAX_LINETYPE_ELEMENTS} elements"));
|
||||
}
|
||||
}
|
||||
if quoted || depth != 0 {
|
||||
return Err("an unclosed [ or \"".into());
|
||||
}
|
||||
out.push(line.get(start..).unwrap_or("").trim());
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The elements of a pattern line `A,dash,gap,[…],…`.
|
||||
fn lin_pattern(line: &str, no: usize, name: &str, out: &mut Parsed<Linetype>) -> std::result::Result<Vec<DashElement>, String> {
|
||||
let mut fields = lin_fields(line)?;
|
||||
// The alignment field ("A") comes first; a line of plain numbers is read as well.
|
||||
if fields.first().is_some_and(|f| f.eq_ignore_ascii_case("a")) {
|
||||
fields.remove(0);
|
||||
} else if fields.first().is_some_and(|f| number(f).is_none() && !f.starts_with('[')) {
|
||||
return Err(format!("unknown alignment `{}` (expected A)", fields.first().copied().unwrap_or("")));
|
||||
}
|
||||
let mut pattern: Vec<DashElement> = Vec::new();
|
||||
for f in fields.into_iter().filter(|f| !f.is_empty()) {
|
||||
if pattern.len() >= MAX_LINETYPE_ELEMENTS {
|
||||
return Err(format!("more than {MAX_LINETYPE_ELEMENTS} elements"));
|
||||
}
|
||||
let Some(inner) = f.strip_prefix('[') else {
|
||||
let len = number(f).ok_or_else(|| format!("`{f}` is not a dash length"))?;
|
||||
pattern.push(DashElement::dash(len));
|
||||
continue;
|
||||
};
|
||||
let inner = inner.strip_suffix(']').ok_or_else(|| format!("`{f}` is not a complete [ ] element"))?;
|
||||
match lin_text(inner)? {
|
||||
Some(text) => {
|
||||
// The text sits at the end of the element before it (a zero-length one if none).
|
||||
if pattern.last().is_none_or(|e| e.text.is_some()) {
|
||||
pattern.push(DashElement::dash(0.0));
|
||||
}
|
||||
if let Some(last) = pattern.last_mut() {
|
||||
*last = DashElement { length: last.length, ..text };
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let shape = inner.split(',').next().unwrap_or("").trim();
|
||||
out.warn(no, format!("linetype {name}: shape {shape} needs an SHX shape file, which CADCraft can't read; left out"));
|
||||
}
|
||||
}
|
||||
}
|
||||
if pattern.is_empty() {
|
||||
return Err("no dashes".into());
|
||||
}
|
||||
if pattern.iter().all(|e| e.length == 0.0) && pattern.iter().all(|e| e.text.is_none()) {
|
||||
return Err("every element has zero length".into());
|
||||
}
|
||||
Ok(pattern)
|
||||
}
|
||||
|
||||
/// A `"TEXT",STYLE,key=value…` element (the inside of `[…]`), or `None` for a shape element.
|
||||
fn lin_text(inner: &str) -> std::result::Result<Option<DashElement>, String> {
|
||||
let inner = inner.trim();
|
||||
let Some(after) = inner.strip_prefix('"') else { return Ok(None) };
|
||||
let (text, rest) = after.split_once('"').ok_or("unclosed text quote")?;
|
||||
if text.chars().count() > MAX_NAME_CHARS || text.chars().any(char::is_control) {
|
||||
return Err("embedded text that is too long or has control characters".into());
|
||||
}
|
||||
let mut parts = rest.split(',').map(str::trim);
|
||||
if !parts.next().unwrap_or("").is_empty() {
|
||||
return Err("text element: expected a comma after the text".into());
|
||||
}
|
||||
let style = parts.next().unwrap_or("").trim();
|
||||
if style.is_empty() || style.contains('=') {
|
||||
return Err("text element: the text style is missing".into());
|
||||
}
|
||||
let mut e = DashElement { text: Some(text.to_string()), style: Some(style.to_string()), ..DashElement::dash(0.0) };
|
||||
for kv in parts.filter(|p| !p.is_empty()) {
|
||||
let (k, v) = kv.split_once('=').ok_or_else(|| format!("text element: `{kv}` is not key=value"))?;
|
||||
match k.trim().to_ascii_uppercase().as_str() {
|
||||
"S" => e.scale = number(v).filter(|s| *s > 0.0).ok_or_else(|| format!("text element: bad scale `{v}`"))?,
|
||||
"X" => e.offset.x = number(v).ok_or_else(|| format!("text element: bad X offset `{v}`"))?,
|
||||
"Y" => e.offset.y = number(v).ok_or_else(|| format!("text element: bad Y offset `{v}`"))?,
|
||||
// Upright text keeps a rotation relative to the line, like R.
|
||||
k @ ("R" | "A" | "U") => {
|
||||
e.rotation = angle(v).ok_or_else(|| format!("text element: bad rotation `{v}`"))?;
|
||||
e.absolute = k == "A";
|
||||
}
|
||||
other => return Err(format!("text element: unknown option `{other}`")),
|
||||
}
|
||||
}
|
||||
Ok(Some(e))
|
||||
}
|
||||
|
||||
/// An angle in degrees, or with a `d` (degrees), `r` (radians) or `g` (grads) suffix; radians out.
|
||||
fn angle(t: &str) -> Option<f64> {
|
||||
let t = t.trim().to_ascii_lowercase();
|
||||
let (num, unit) = match t.char_indices().last() {
|
||||
Some((i, c @ ('d' | 'r' | 'g'))) => (t.get(..i)?, c),
|
||||
_ => (t.as_str(), 'd'),
|
||||
};
|
||||
let v = num.trim().parse::<f64>().ok().filter(|v| v.is_finite() && v.abs() <= 1.0e5)?;
|
||||
Some(match unit {
|
||||
'r' => v,
|
||||
'g' => v * std::f64::consts::PI / 200.0,
|
||||
_ => v.to_radians(),
|
||||
})
|
||||
}
|
||||
|
||||
// ---------- PAT ----------
|
||||
|
||||
/// Read the hatch patterns of a `.pat` file. Values are used as written (an inch file for inch
|
||||
/// drawings, a millimetre file for metric ones).
|
||||
pub fn parse_pat(text: &str) -> Parsed<UserPattern> {
|
||||
let parsed = craft_dxf::lin_pat::parse_pat(text);
|
||||
Parsed {
|
||||
items: parsed
|
||||
.items
|
||||
.into_iter()
|
||||
.map(|p| UserPattern {
|
||||
name: p.name,
|
||||
description: p.description,
|
||||
lines: p
|
||||
.lines
|
||||
.into_iter()
|
||||
.map(|l| PatternLine { angle: l.angle, origin: (l.origin[0], l.origin[1]), delta: (l.delta[0], l.delta[1]), dashes: l.dashes })
|
||||
.collect(),
|
||||
})
|
||||
.collect(),
|
||||
warnings: parsed.warnings,
|
||||
let mut out: Parsed<UserPattern> = Parsed::default();
|
||||
// The pattern being read, its header line, and whether it already failed.
|
||||
let mut cur: Option<(UserPattern, usize, bool)> = None;
|
||||
let finish = |cur: Option<(UserPattern, usize, bool)>, out: &mut Parsed<UserPattern>| {
|
||||
let Some((p, at, failed)) = cur else { return };
|
||||
if failed {
|
||||
return;
|
||||
}
|
||||
if p.lines.is_empty() {
|
||||
out.warn(at, format!("pattern {} has no line families; skipped", p.name));
|
||||
} else if out.items.len() >= MAX_DEFINITIONS {
|
||||
out.warn(at, format!("more than {MAX_DEFINITIONS} patterns; {} skipped", p.name));
|
||||
} else if out.items.iter().any(|q| q.name.eq_ignore_ascii_case(&p.name)) {
|
||||
out.warn(at, format!("pattern {} is defined twice; the first definition is kept", p.name));
|
||||
} else {
|
||||
out.items.push(p);
|
||||
}
|
||||
};
|
||||
for (no, line) in lines(text) {
|
||||
// A comment runs to the end of the line.
|
||||
let line = line.split(';').next().unwrap_or("").trim();
|
||||
if line.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if line.chars().count() > MAX_LINE_CHARS {
|
||||
out.warn(no, "line too long; skipped");
|
||||
continue;
|
||||
}
|
||||
if let Some(rest) = line.strip_prefix('*') {
|
||||
finish(cur.take(), &mut out);
|
||||
match header(rest) {
|
||||
Ok((name, description)) => cur = Some((UserPattern { name: name.to_ascii_uppercase(), description, lines: Vec::new() }, no, false)),
|
||||
Err(e) => out.warn(no, format!("{e}; skipped")),
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let Some((p, _, failed)) = cur.as_mut() else {
|
||||
out.warn(no, "line family without a *NAME line before it; skipped");
|
||||
continue;
|
||||
};
|
||||
if *failed {
|
||||
continue;
|
||||
}
|
||||
if p.lines.len() >= MAX_PATTERN_FAMILIES {
|
||||
out.warn(no, format!("pattern {}: more than {MAX_PATTERN_FAMILIES} line families; skipped", p.name));
|
||||
*failed = true;
|
||||
continue;
|
||||
}
|
||||
match pat_family(line) {
|
||||
Ok(l) => p.lines.push(l),
|
||||
Err(e) => {
|
||||
out.warn(no, format!("pattern {}: {e}; skipped", p.name));
|
||||
*failed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
finish(cur, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// One line family: `angle, x-origin, y-origin, delta-x, delta-y[, dash-1, dash-2, …]`.
|
||||
fn pat_family(line: &str) -> std::result::Result<PatternLine, String> {
|
||||
let mut v = Vec::new();
|
||||
for f in line.split(',') {
|
||||
if v.len() >= MAX_PATTERN_DASHES.saturating_add(5) {
|
||||
return Err(format!("more than {MAX_PATTERN_DASHES} dashes in a line family"));
|
||||
}
|
||||
let f = f.trim();
|
||||
if f.is_empty() && v.len() >= 5 {
|
||||
continue;
|
||||
}
|
||||
v.push(number(f).ok_or_else(|| format!("`{f}` is not a number"))?);
|
||||
}
|
||||
let (Some(&angle), Some(&x), Some(&y), Some(&dx), Some(&dy)) = (v.first(), v.get(1), v.get(2), v.get(3), v.get(4)) else {
|
||||
return Err("a line family needs angle, x, y, delta-x and delta-y".into());
|
||||
};
|
||||
if dy.abs() < 1e-9 {
|
||||
return Err("a line family with zero spacing (delta-y)".into());
|
||||
}
|
||||
Ok(PatternLine { angle, origin: (x, y), delta: (dx, dy), dashes: v.get(5..).unwrap_or(&[]).to_vec() })
|
||||
}
|
||||
|
||||
@@ -476,7 +476,6 @@ 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)),
|
||||
@@ -805,11 +804,9 @@ pub struct PageSetup {
|
||||
/// Plot objects with their transparency ("Plot transparency"; PLOTTRANSPARENCYOVERRIDE can
|
||||
/// override it). The DXF plot layout flags have no bit for it, so it is not saved in DXF.
|
||||
pub plot_transparency: bool,
|
||||
/// Explicit paper-space unit for the layout: `Some(true)` for millimetres (plot paper units 1
|
||||
/// in DXF), `Some(false)` for inches, or `None` to follow the drawing's `MEASUREMENT` (#1058,
|
||||
/// #3249).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub paper_mm: Option<bool>,
|
||||
/// The layout's paper units are millimetres (plot paper units 1 in DXF) whatever the
|
||||
/// drawing's MEASUREMENT says; otherwise paper units follow MEASUREMENT (#1058).
|
||||
pub paper_mm: bool,
|
||||
/// Paper size (DXF groups 44, 45) and plot rotation (group 73) as the file stored them.
|
||||
/// Saving writes them back while they still describe `width_mm`, `height_mm` and
|
||||
/// `landscape`, so each program's convention for media defined wider than tall survives a
|
||||
@@ -841,7 +838,7 @@ impl Default for PageSetup {
|
||||
lineweights: true,
|
||||
show_plot_styles: false,
|
||||
plot_transparency: false,
|
||||
paper_mm: None,
|
||||
paper_mm: false,
|
||||
file_paper: None,
|
||||
image_origin: None,
|
||||
}
|
||||
@@ -859,14 +856,6 @@ 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")]
|
||||
@@ -875,16 +864,7 @@ 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,
|
||||
ucs: None,
|
||||
ucs_previous: Vec::new(),
|
||||
limits: None,
|
||||
}
|
||||
Layout { name: name.into(), tab_order, page: PageSetup::default(), entities: EntityStore::new(), view: None, limits: None }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -950,49 +930,11 @@ pub struct Ucs {
|
||||
pub y_axis: Vec3,
|
||||
}
|
||||
|
||||
/// A saved layer state (LAYERSTATE), as AutoCAD keeps one in the LAYER table's
|
||||
/// `ACAD_LAYERSTATES` dictionary.
|
||||
/// A saved layer state (LAYERSTATE).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(default)]
|
||||
pub struct LayerState {
|
||||
pub name: String,
|
||||
pub layers: Vec<Layer>,
|
||||
/// The properties restoring sets ([`LayerState::ON`] …): AutoCAD's mask (group 91 of the
|
||||
/// state's XRECORD). Bits CADCraft doesn't use are kept as read.
|
||||
pub mask: u32,
|
||||
/// The layer restoring makes current; empty, or a layer the drawing doesn't have, leaves the
|
||||
/// current layer as it is (AutoCAD 2024, measured).
|
||||
pub current: String,
|
||||
/// Group 301 of the state's XRECORD: empty as AutoCAD 2024's -LAYER saves a state; a text a
|
||||
/// file holds there is kept.
|
||||
pub description: String,
|
||||
}
|
||||
|
||||
impl Default for LayerState {
|
||||
fn default() -> Self {
|
||||
LayerState { name: String::new(), layers: Vec::new(), mask: LayerState::ALL, current: String::new(), description: String::new() }
|
||||
}
|
||||
}
|
||||
|
||||
impl LayerState {
|
||||
pub const ON: u32 = 1;
|
||||
pub const FROZEN: u32 = 2;
|
||||
pub const LOCKED: u32 = 4;
|
||||
pub const PLOT: u32 = 8;
|
||||
pub const VP_FREEZE_NEW: u32 = 16;
|
||||
pub const COLOR: u32 = 32;
|
||||
pub const LINETYPE: u32 = 64;
|
||||
pub const LINEWEIGHT: u32 = 128;
|
||||
pub const PLOT_STYLE: u32 = 256;
|
||||
pub const TRANSPARENCY: u32 = 1024;
|
||||
/// Every property: the mask of AutoCAD 2024's -LAYER stAte Save with its defaults (2047; bit
|
||||
/// 512, which no property toggles, is always set).
|
||||
pub const ALL: u32 = 2047;
|
||||
|
||||
/// A state of every property of `layers`, with `current` the layer restoring makes current.
|
||||
pub fn new(name: impl Into<String>, layers: Vec<Layer>, current: impl Into<String>) -> Self {
|
||||
LayerState { name: name.into(), layers, current: current.into(), ..LayerState::default() }
|
||||
}
|
||||
}
|
||||
|
||||
/// A named group of entities (GROUP).
|
||||
|
||||
@@ -715,45 +715,6 @@ 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));
|
||||
}
|
||||
|
||||
/// In the reserved band a new handle skips the file's kept object handles (#2514) and the handles
|
||||
/// objects hold in model space, a layout and a block definition, or that a file record reserved
|
||||
/// (#913); off the top of the range it goes on at the bottom of the band. HANDSEED reports the
|
||||
/// handle `new_handle` takes.
|
||||
#[test]
|
||||
fn new_handles_in_the_reserved_band_skip_every_held_handle_and_wrap() {
|
||||
let mut d = Drawing::new_metric();
|
||||
let top = u64::MAX;
|
||||
d.model.push(Entity::new(Handle(top - 4), line((0.0, 0.0), (1.0, 0.0))));
|
||||
let mut sheet = Layout::new("Sheet", 1);
|
||||
sheet.entities.push(Entity::new(Handle(top - 3), line((0.0, 0.0), (1.0, 0.0))));
|
||||
d.layouts.push(sheet);
|
||||
let mut b = Block::new("B");
|
||||
b.entities.push(Entity::new(Handle(top - 2), line((0.0, 0.0), (1.0, 0.0))));
|
||||
d.blocks.insert("B".into(), std::sync::Arc::new(b));
|
||||
std::sync::Arc::make_mut(&mut d.foreign).handles.insert(Handle(top - 1), ("LAYER".into(), "0".into()));
|
||||
d.reserve_handle(Handle(top));
|
||||
d.model.push(Entity::new(Handle(HANDLE_LIMIT), line((0.0, 0.0), (1.0, 0.0))));
|
||||
d.handseed = top - 5;
|
||||
assert_eq!(d.new_handle(), Handle(top - 5));
|
||||
assert_eq!(d.next_handle(), Handle(HANDLE_LIMIT + 1), "a held handle was offered");
|
||||
assert_eq!(d.new_handle(), Handle(HANDLE_LIMIT + 1));
|
||||
assert_eq!(d.handseed, HANDLE_LIMIT + 2);
|
||||
// Handle 0 means "no handle" in a file; a seed there moves on.
|
||||
d.handseed = 0;
|
||||
assert_eq!(d.new_handle(), Handle(1));
|
||||
}
|
||||
|
||||
/// 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() {
|
||||
|
||||
@@ -12,7 +12,6 @@ workspace = true
|
||||
cadcraft-geom = { workspace = true }
|
||||
cadcraft-color = { workspace = true }
|
||||
cadcraft-doc = { workspace = true }
|
||||
craft-mime = { workspace = true }
|
||||
craft-dxf = { workspace = true }
|
||||
cadcraft-constraints = { workspace = true }
|
||||
cadcraft-fonts = { workspace = true }
|
||||
|
||||
@@ -319,14 +319,8 @@ fn all_handles(d: &Drawing) -> HashSet<Handle> {
|
||||
}
|
||||
|
||||
/// The next handle is above every handle in use, so new objects never take an existing one.
|
||||
///
|
||||
/// A handle at or above [`cadcraft_doc::HANDLE_LIMIT`] is the file's own and is deliberately not
|
||||
/// followed: the seed never moves past it, and new objects take free handles in the band above
|
||||
/// the limit. Reporting it would repeat the same repair on every audit, so it is not an issue.
|
||||
/// Such a handle is left out of the maximum too, or the largest handle would hide every ordinary
|
||||
/// one behind it and the seed would never be repaired past them.
|
||||
fn handseed(d: &mut Drawing, out: &mut Vec<Issue>) {
|
||||
let Some(max) = each_entity(d).map(|e| e.handle).filter(|h| h.0 < cadcraft_doc::HANDLE_LIMIT).max() else { return };
|
||||
let Some(max) = each_entity(d).map(|e| e.handle).max() else { return };
|
||||
if max.0 >= d.handseed {
|
||||
out.push(issue(
|
||||
"handseed",
|
||||
|
||||
@@ -8,8 +8,6 @@ mod audit;
|
||||
pub(crate) mod blocks;
|
||||
pub mod clipboard;
|
||||
pub mod constraints;
|
||||
mod dimstyle_cli;
|
||||
mod dimstyles;
|
||||
mod draw;
|
||||
mod draw2;
|
||||
mod draworder;
|
||||
@@ -22,7 +20,6 @@ pub(crate) mod groups;
|
||||
pub(crate) mod hatch;
|
||||
mod image;
|
||||
mod inquiry;
|
||||
pub mod interface;
|
||||
mod layer;
|
||||
mod layout;
|
||||
mod lisp;
|
||||
@@ -37,8 +34,6 @@ 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;
|
||||
@@ -52,7 +47,6 @@ mod tolerance;
|
||||
mod trimextend;
|
||||
mod txt2mtxt;
|
||||
pub use txt2mtxt::Txt2MtxtOptions;
|
||||
mod ucs;
|
||||
mod utility;
|
||||
mod view;
|
||||
|
||||
@@ -189,12 +183,9 @@ 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());
|
||||
@@ -215,7 +206,6 @@ pub fn command_specs() -> &'static [CommandSpec] {
|
||||
v.extend(inquiry::specs());
|
||||
v.extend(settings::specs());
|
||||
v.extend(options::specs());
|
||||
v.extend(interface::specs());
|
||||
v.extend(utility::specs());
|
||||
v.extend(table::specs());
|
||||
v.extend(tolerance::specs());
|
||||
|
||||
@@ -35,15 +35,8 @@ fn auto_rotation(p1: Vec2, p2: Vec2, at: Vec2) -> f64 {
|
||||
if outside_x && !outside_y { std::f64::consts::FRAC_PI_2 } else { 0.0 }
|
||||
}
|
||||
|
||||
/// 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) }
|
||||
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)) } }
|
||||
}
|
||||
|
||||
/// 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, 0.0), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
|
||||
let k = dim(s, linear_kind(a, b, at, rot, false), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
|
||||
Ok(json!({ "handle": add_dim(s, k)?.hex() }))
|
||||
}
|
||||
|
||||
@@ -133,26 +133,11 @@ pub(super) struct LinearM {
|
||||
selecting: bool,
|
||||
/// Asking for the dimension line angle (Rotated).
|
||||
rotating: bool,
|
||||
/// A selected circle (centre, radius): measured across its diameter along the dimension line.
|
||||
circle: Option<(Vec2, f64)>,
|
||||
}
|
||||
|
||||
impl LinearM {
|
||||
pub(super) fn new(aligned: bool) -> Self {
|
||||
LinearM { aligned, pts: Vec::new(), rotation: None, text: DimText::default(), selecting: false, rotating: false, circle: None }
|
||||
}
|
||||
|
||||
/// The extension line origins and the kind of the dimension placed at `at`. A selected circle
|
||||
/// is measured between the ends of its diameter along the dimension line, whichever way the
|
||||
/// line runs (with a turned UCS, Horizontal is not world horizontal).
|
||||
fn placed(&self, s: &Session, at: Vec2) -> Option<(Vec2, Vec2, DimKind)> {
|
||||
let (&a, &b) = (self.pts.first()?, self.pts.get(1)?);
|
||||
let kind = linear_kind(a, b, at, self.rotation, self.aligned, s.input_ucs().rotation());
|
||||
if let (Some((c, r)), DimKind::Linear { rotation }) = (self.circle, kind) {
|
||||
let d = Vec2::from_angle(rotation) * r;
|
||||
return Some((c - d, c + d, kind));
|
||||
}
|
||||
Some((a, b, kind))
|
||||
LinearM { aligned, pts: Vec::new(), rotation: None, text: DimText::default(), selecting: false, rotating: false }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -210,11 +195,7 @@ impl Interactive for LinearM {
|
||||
}
|
||||
None => {
|
||||
if let Some((c, r)) = circle_of(s, h) {
|
||||
// Across the diameter along the UCS X axis, until the dimension line
|
||||
// says which way to measure.
|
||||
let x = Vec2::from_angle(s.input_ucs().rotation());
|
||||
self.pts = vec![c - x * r, c + x * r];
|
||||
self.circle = Some((c, r));
|
||||
self.pts = vec![c - Vec2::X * r, c + Vec2::X * r];
|
||||
self.selecting = false;
|
||||
} else {
|
||||
s.echo("Object cannot be dimensioned this way.");
|
||||
@@ -234,8 +215,8 @@ impl Interactive for LinearM {
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(_, Input::Point(at)) => {
|
||||
let Some((a, b, kind)) = self.placed(s, at) else { return Ok(Step::Continue) };
|
||||
let k = self.text.apply(dim(s, kind, at, a, b, Vec2::ZERO, ""));
|
||||
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, ""));
|
||||
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();
|
||||
@@ -246,8 +227,8 @@ impl Interactive for LinearM {
|
||||
}
|
||||
(_, Input::Keyword(k)) => {
|
||||
match k.as_str() {
|
||||
"Horizontal" => self.rotation = Some(s.input_ucs().rotation()),
|
||||
"Vertical" => self.rotation = Some(s.input_ucs().rotation() + std::f64::consts::FRAC_PI_2),
|
||||
"Horizontal" => self.rotation = Some(0.0),
|
||||
"Vertical" => self.rotation = Some(std::f64::consts::FRAC_PI_2),
|
||||
"Rotated" => self.rotating = true,
|
||||
other => {
|
||||
self.text.keyword(other);
|
||||
@@ -262,7 +243,7 @@ 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)],
|
||||
[_, _] => self.placed(s, c).map(|(a, b, kind)| self.text.apply(dim(s, kind, c, a, b, Vec2::ZERO, ""))).into_iter().collect(),
|
||||
[a, b] => vec![self.text.apply(dim(s, linear_kind(*a, *b, c, self.rotation, self.aligned), c, *a, *b, Vec2::ZERO, ""))],
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
+12
-107
@@ -27,10 +27,6 @@ mod edit;
|
||||
|
||||
/// Most preview entities drawn while the array is edited.
|
||||
const PREVIEW_LIMIT: usize = 2000;
|
||||
/// Most objects whose key points are searched for a Key point base point.
|
||||
const MAX_KEY_OBJECTS: usize = 10_000;
|
||||
/// The prompt after the Key point option of a base point.
|
||||
const KEY_POINT_PROMPT: &str = "Specify key point on source objects to use as base point";
|
||||
/// Keyword-only prompts: each typed token is matched on its own (no free text).
|
||||
const KEYWORDS: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
|
||||
|
||||
@@ -45,13 +41,13 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("arrayrect", "Rectangular Array", run_arrayrect)
|
||||
.menu(&["Modify", "Array", "Rectangular Array"])
|
||||
.params(
|
||||
"{handles?, rows, cols, rowSpacing, colSpacing, levels? (1), levelSpacing?, rowElevation?, axisAngle? (degrees), base? ([x, y], default the objects' centre), keyPoint? ([x, y]: the base point is the objects' key point nearest it), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
|
||||
"{handles?, rows, cols, rowSpacing, colSpacing, levels? (1), levelSpacing?, rowElevation?, axisAngle? (degrees), base? ([x, y], default the objects' centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(RectM::default()))),
|
||||
CommandSpec::new("arraypolar", "Polar Array", run_arraypolar)
|
||||
.menu(&["Modify", "Array", "Polar Array"])
|
||||
.params(
|
||||
"{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), keyPoint? ([x, y]: the base point is the objects' key point nearest it), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
|
||||
"{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(PolarM::default()))),
|
||||
CommandSpec::new("-array", "Array", classic::run_classic)
|
||||
@@ -250,62 +246,6 @@ fn bounds(d: &Drawing, hs: &[Handle]) -> Bounds2 {
|
||||
hs.iter().filter_map(|h| d.entity(*h).map(|e| cadcraft_doc::entity_bounds(d, e, 0))).fold(Bounds2::EMPTY, |a, b| a.union(&b))
|
||||
}
|
||||
|
||||
/// The key point of `ents`, placed by `m`, nearest `at`: one of their grips (end points,
|
||||
/// midpoints, centres, vertices, insertion points). `None` when they have none. More than
|
||||
/// [`MAX_KEY_OBJECTS`] objects are refused: searching only some could miss the nearest one.
|
||||
pub(crate) fn nearest_key_point<'a>(ents: impl Iterator<Item = &'a Entity>, m: &Mat3, at: Vec2) -> Result<Option<Vec2>> {
|
||||
if !at.is_finite() {
|
||||
return Ok(None);
|
||||
}
|
||||
let stretched = m.similarity_scale().is_none();
|
||||
let mut best: Option<(Vec2, f64)> = None;
|
||||
for (n, e) in ents.enumerate() {
|
||||
if n >= MAX_KEY_OBJECTS {
|
||||
return Err(other(format!("Too many objects to search for a key point (at most {MAX_KEY_OBJECTS}); specify a point.")));
|
||||
}
|
||||
let k = match &e.kind {
|
||||
// Under an uneven scale a circle is drawn as an ellipse: its key points are the ellipse's.
|
||||
EntityKind::Circle(c) if stretched => {
|
||||
let g = cadcraft_geom::Ellipse::full(c.center.xy(), Vec2::X * c.radius, 1.0).transformed(m);
|
||||
EntityKind::Ellipse(cadcraft_doc::Ellipse {
|
||||
center: g.center.to3(c.center.z),
|
||||
major: g.major.to3(0.0),
|
||||
ratio: g.ratio,
|
||||
start: g.start,
|
||||
end: g.end,
|
||||
})
|
||||
}
|
||||
kind => {
|
||||
let mut k = kind.clone();
|
||||
k.transform(m);
|
||||
k
|
||||
}
|
||||
};
|
||||
for g in k.grips().into_iter().filter(|g| g.is_finite()) {
|
||||
let d = g.dist(at);
|
||||
if best.is_none_or(|(_, bd)| d < bd) {
|
||||
best = Some((g, d));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(best.map(|b| b.0))
|
||||
}
|
||||
|
||||
/// `keyPoint` of a JSON form: absent or null is none; anything else must be a point, rather than
|
||||
/// be taken as none and the base point found another way.
|
||||
pub(crate) fn key_point_param(cmd: &str, p: &Value) -> Result<Option<Vec2>> {
|
||||
match p.get("keyPoint") {
|
||||
None | Some(Value::Null) => Ok(None),
|
||||
Some(_) => point_param(p, "keyPoint").map(Some).ok_or_else(|| bad(cmd, "`keyPoint` must be a point [x, y]")),
|
||||
}
|
||||
}
|
||||
|
||||
/// The key point of objects `hs` in the drawing nearest `at`.
|
||||
pub(crate) fn key_point_of(d: &Drawing, hs: &[Handle], at: Vec2) -> Result<Vec2> {
|
||||
nearest_key_point(hs.iter().filter_map(|h| d.entity(*h)).map(|e| &**e), &Mat3::IDENTITY, at)?
|
||||
.ok_or_else(|| other("The objects have no key point; specify a point."))
|
||||
}
|
||||
|
||||
/// The centre of the first object (the point a non-rotated polar copy is moved by).
|
||||
fn first_center(d: &Drawing, hs: &[Handle]) -> Option<Vec2> {
|
||||
hs.first().and_then(|h| d.entity(*h)).map(|e| cadcraft_doc::entity_bounds(d, e, 0).center()).filter(|c| c.is_finite())
|
||||
@@ -446,10 +386,9 @@ fn run_arrayrect(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
row_elevation: f64_or(p, "rowElevation", 0.0),
|
||||
});
|
||||
let rs = f64_or(p, "rowSpacing", 1.0);
|
||||
let base = match (key_point_param("arrayrect", p)?, point_param(p, "base")) {
|
||||
(Some(k), _) => key_point_of(s.doc()?, &hs, k)?,
|
||||
(None, Some(b)) => b,
|
||||
(None, None) => Some(bounds(s.doc()?, &hs).center()).filter(|c| c.is_finite()).unwrap_or_default(),
|
||||
let base = match point_param(p, "base") {
|
||||
Some(b) => b,
|
||||
None => Some(bounds(s.doc()?, &hs).center()).filter(|c| c.is_finite()).unwrap_or_default(),
|
||||
};
|
||||
let p2 = params(kind, levels, f64_or(p, "levelSpacing", rs));
|
||||
let associative = bool_or(p, "associative", assoc_default(s));
|
||||
@@ -463,10 +402,7 @@ fn run_arraypolar(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let rows = count_or("arraypolar", p, "rows", 1)?;
|
||||
let levels = count_or("arraypolar", p, "levels", 1)?;
|
||||
check_size(s, n.saturating_mul(rows).saturating_mul(levels), hs.len())?;
|
||||
let base = match key_point_param("arraypolar", p)? {
|
||||
Some(k) => key_point_of(s.doc()?, &hs, k)?,
|
||||
None => point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c),
|
||||
};
|
||||
let base = point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c);
|
||||
let row_spacing = f64_or(p, "rowSpacing", 1.0);
|
||||
let fill = f64_or(p, "angle", 360.0);
|
||||
if !(fill.abs() >= 1e-9 && fill.abs() <= 360.0 + 1e-9) {
|
||||
@@ -567,8 +503,6 @@ enum RStage {
|
||||
Main,
|
||||
Assoc,
|
||||
Base,
|
||||
/// Base point: Key point (a grip of the source objects).
|
||||
BaseKey,
|
||||
/// COUnt: columns, then rows.
|
||||
CountCols,
|
||||
CountRows,
|
||||
@@ -729,7 +663,6 @@ impl Interactive for RectM {
|
||||
.default("eXit"),
|
||||
Assoc => assoc_prompt(self.assoc),
|
||||
Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
|
||||
BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
|
||||
CountCols | ColsCount => cols(),
|
||||
CountRows | RowsCount => rows(),
|
||||
SpaceCols => dist("Specify the distance between columns", self.cs).kw(&["Unit cell"]),
|
||||
@@ -779,12 +712,10 @@ impl Interactive for RectM {
|
||||
self.base = self.centroid;
|
||||
Main
|
||||
}
|
||||
(Base, Input::Keyword(_)) => BaseKey,
|
||||
(BaseKey, Input::Point(p)) => {
|
||||
self.base = key_point_of(s.doc()?, &self.objs, *p)?;
|
||||
Main
|
||||
(Base, Input::Keyword(_)) => {
|
||||
s.echo("Key points are not available yet; specify a point.");
|
||||
Base
|
||||
}
|
||||
(BaseKey, Input::Enter) => Base,
|
||||
(CountCols | ColsCount, _) => match count(&i, self.cols, max_count(s, self.rows.saturating_mul(self.levels), n))? {
|
||||
Some(c) => {
|
||||
self.cols = c;
|
||||
@@ -927,9 +858,6 @@ enum PStage {
|
||||
Main,
|
||||
Assoc,
|
||||
Base,
|
||||
/// Key point of the base point asked from the center prompt, or from the main prompt.
|
||||
CenterBaseKey,
|
||||
BaseKey,
|
||||
Items,
|
||||
Between,
|
||||
Fill,
|
||||
@@ -1106,7 +1034,6 @@ impl Interactive for PolarM {
|
||||
match self.stage {
|
||||
Center => Prompt::new("Specify center point of array", Accept::POINT).kw(&["Base point", "Axis of rotation"]),
|
||||
CenterBase | Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
|
||||
CenterBaseKey | BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
|
||||
Main => Prompt::new("Select grip to edit array", Accept::POINT)
|
||||
.kw(&["ASsociative", "Base point", "Items", "Angle between", "Fill angle", "ROWs", "Levels", "ROTate items", "eXit"])
|
||||
.default("eXit"),
|
||||
@@ -1165,14 +1092,10 @@ impl Interactive for PolarM {
|
||||
self.base = None;
|
||||
if stage == CenterBase { Center } else { Main }
|
||||
}
|
||||
(CenterBase, Input::Keyword(_)) => CenterBaseKey,
|
||||
(Base, Input::Keyword(_)) => BaseKey,
|
||||
(CenterBaseKey | BaseKey, Input::Point(p)) => {
|
||||
self.base = Some(key_point_of(s.doc()?, &self.objs, *p)?);
|
||||
if stage == CenterBaseKey { Center } else { Main }
|
||||
(CenterBase | Base, Input::Keyword(_)) => {
|
||||
s.echo("Key points are not available yet; specify a point.");
|
||||
stage
|
||||
}
|
||||
(CenterBaseKey, Input::Enter) => CenterBase,
|
||||
(BaseKey, Input::Enter) => Base,
|
||||
(Items, _) => match count(&i, self.items, max_count(s, self.rows.saturating_mul(self.levels), n))? {
|
||||
Some(c) => {
|
||||
self.items = c;
|
||||
@@ -1312,22 +1235,4 @@ mod tests {
|
||||
let c = at(&polar(4, -360.0));
|
||||
assert!(c[2].near(Vec2::new(0.0, 1.0), 1e-9));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_circle_under_an_uneven_scale_offers_the_drawn_ellipses_key_points() {
|
||||
let c = Entity {
|
||||
handle: Handle(1),
|
||||
common: Default::default(),
|
||||
kind: EntityKind::Circle(cadcraft_doc::Circle { center: v3(Vec2::ZERO), radius: 1.0 }),
|
||||
};
|
||||
// Scaled (2, 1) the circle is drawn as an ellipse with semi-axes 2 and 1.
|
||||
let m = Mat3::scale(2.0, 1.0);
|
||||
let key = |at: Vec2| nearest_key_point(std::iter::once(&c), &m, at).unwrap().unwrap();
|
||||
assert!(key(Vec2::new(0.1, 1.2)).near(Vec2::new(0.0, 1.0), 1e-9), "{:?}", key(Vec2::new(0.1, 1.2)));
|
||||
assert!(key(Vec2::new(2.2, 0.1)).near(Vec2::new(2.0, 0.0), 1e-9), "{:?}", key(Vec2::new(2.2, 0.1)));
|
||||
// A uniform scale keeps the circle.
|
||||
let m = Mat3::scale(2.0, 2.0);
|
||||
let k = nearest_key_point(std::iter::once(&c), &m, Vec2::new(0.1, 2.2)).unwrap().unwrap();
|
||||
assert!(k.near(Vec2::new(0.0, 2.0), 1e-9), "{k:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,9 +18,7 @@ use super::super::helpers::v3;
|
||||
use super::super::machines::{SelOutcome, SelectPhase, number};
|
||||
use super::super::{CommandSpec, bad, bool_or, point_param, targets};
|
||||
|
||||
use super::{
|
||||
KEY_POINT_PROMPT, KEYWORDS, angle, check_size, count, fmt, key_point_of, key_point_param, nearest_key_point, nesting, other, yes, yes_no,
|
||||
};
|
||||
use super::{KEYWORDS, angle, check_size, count, fmt, nesting, other, yes, yes_no};
|
||||
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
@@ -28,7 +26,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("arrayedit", "Edit Array", run_arrayedit)
|
||||
.menu(&["Modify", "Object", "Array"])
|
||||
.params(
|
||||
"{handle, cols?, rows?, colSpacing?, rowSpacing?, axisAngle? (degrees), rowElevation?, levels?, levelSpacing?, items?, angle? (fill, degrees), angleBetween?, rotate?: bool, center? ([x, y]), base? ([x, y], the new base point), reset?: bool, replace?: {handles, base? ([x, y], default the objects' centre), items: [[i, j, level]…] | \"source\"}, keyPoint? ([x, y]: the new base point is the source objects' key point nearest it, on the item there), replace?.keyPoint? ([x, y]: the replacement objects' key point nearest it is their base point), source?: {item? ([i, j, level], default [0, 0, 0])} (places the source objects for editing; ARRAYCLOSE ends)}",
|
||||
"{handle, cols?, rows?, colSpacing?, rowSpacing?, axisAngle? (degrees), rowElevation?, levels?, levelSpacing?, items?, angle? (fill, degrees), angleBetween?, rotate?: bool, center? ([x, y]), base? ([x, y], the new base point), reset?: bool, replace?: {handles, base? ([x, y], default the objects' centre), items: [[i, j, level]…] | \"source\"}, source?: {item? ([i, j, level], default [0, 0, 0])} (places the source objects for editing; ARRAYCLOSE ends)}",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(EditM::default()))),
|
||||
CommandSpec::new("arrayclose", "Close Array Editing", run_arrayclose)
|
||||
@@ -217,16 +215,6 @@ fn item_at(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Option<(u32, u32, u32)
|
||||
best.map(|b| b.0)
|
||||
}
|
||||
|
||||
/// ARRAYEDIT Key point: the key point of the source objects nearest `at`, with the objects as
|
||||
/// placed at the item under `at` (within `tol`).
|
||||
fn source_key_point(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Result<Vec2> {
|
||||
let item = item_at(d, h, at, tol).ok_or_else(|| other("No array item there; specify a point on an item of the array."))?;
|
||||
let (ins, blk, p) = array_of(d, h)?;
|
||||
let src = d.block(&p.source).ok_or_else(|| other("The array's source block is missing."))?;
|
||||
let m = ins.transform(blk.base.xy()).then_before(item_place(&p, item)?).then_before(Mat3::translate(-src.base.xy()));
|
||||
nearest_key_point(src.entities.iter().map(|e| e.as_ref()), &m, at)?.ok_or_else(|| other("The source objects have no key point; specify a point."))
|
||||
}
|
||||
|
||||
/// Move the base point of array `h` to world point `base` without moving the items.
|
||||
fn rebase(s: &mut Session, h: Handle, base: Vec2) -> Result<()> {
|
||||
let d = s.doc()?;
|
||||
@@ -244,30 +232,6 @@ fn rebase(s: &mut Session, h: Handle, base: Vec2) -> Result<()> {
|
||||
ns.name = d.anonymous_block_name("*U");
|
||||
p.source.clone_from(&ns.name);
|
||||
d.blocks.insert(ns.name.clone(), Arc::new(ns));
|
||||
// A replacement is placed as the source is, so its base point moves the same way (each block
|
||||
// once, however many items share it). Records no item uses keep their names.
|
||||
let used: Vec<bool> = {
|
||||
let block_for = p.block_lookup();
|
||||
p.replaced.iter().map(|r| block_for(r.i, r.j, r.level) == r.block).collect()
|
||||
};
|
||||
let mut moved: HashMap<String, String> = HashMap::new();
|
||||
for (r, used) in p.replaced.iter_mut().zip(used) {
|
||||
if !used {
|
||||
continue;
|
||||
}
|
||||
let key = r.block.to_ascii_uppercase();
|
||||
if let Some(n) = moved.get(&key) {
|
||||
r.block.clone_from(n);
|
||||
continue;
|
||||
}
|
||||
let Some(rb) = d.block(&r.block).cloned() else { continue };
|
||||
let mut nb = (*rb).clone();
|
||||
nb.base = (nb.base.xy() + b).to3(nb.base.z);
|
||||
nb.name = d.anonymous_block_name("*U");
|
||||
moved.insert(key, nb.name.clone());
|
||||
r.block.clone_from(&nb.name);
|
||||
d.blocks.insert(nb.name.clone(), Arc::new(nb));
|
||||
}
|
||||
if let ArrayKind::Polar(k) = &mut p.kind {
|
||||
k.center -= b;
|
||||
}
|
||||
@@ -379,9 +343,6 @@ fn close_source(s: &mut Session, save: bool) -> Result<Value> {
|
||||
|
||||
// ---------------- JSON ----------------
|
||||
|
||||
/// How far outside an item's extents a JSON `keyPoint` may be.
|
||||
const KEY_POINT_TOLERANCE: f64 = 1e-6;
|
||||
|
||||
fn item_param(v: &Value) -> Option<(u32, u32, u32)> {
|
||||
let a = v.as_array()?;
|
||||
let n = |k: usize| a.get(k).and_then(Value::as_u64).and_then(|x| u32::try_from(x).ok());
|
||||
@@ -488,22 +449,17 @@ fn fill_from_between(b: f64, items: u32) -> Result<f64> {
|
||||
fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let h = super::super::curves::handle_param(p, "handle").ok_or_else(|| bad("arrayedit", "`handle` (the array) is required"))?;
|
||||
refuse_while_editing(s)?;
|
||||
array_of(s.doc()?, h)?;
|
||||
// Both key points are read before anything changes: a bad one leaves the array as it was.
|
||||
let replace = p.get("replace").filter(|v| !v.is_null());
|
||||
let rep_key = replace.map(|r| key_point_param("arrayedit", r)).transpose()?.flatten();
|
||||
let key = key_point_param("arrayedit", p)?;
|
||||
let (ins, blk, _) = array_of(s.doc()?, h)?;
|
||||
let w = ins.transform(blk.base.xy());
|
||||
let to_local = w.inverse().ok_or_else(|| other("The array's scale is zero."))?;
|
||||
if bool_or(p, "reset", false) {
|
||||
let (_, _, mut a) = array_of(s.doc()?, h)?;
|
||||
a.replaced.clear();
|
||||
rebuild(s, h, a, None)?;
|
||||
}
|
||||
if let Some(r) = replace {
|
||||
if let Some(r) = p.get("replace").filter(|v| !v.is_null()) {
|
||||
let hs = targets(s, r)?;
|
||||
let base = match rep_key {
|
||||
Some(k) => key_point_of(s.doc()?, &hs, k)?,
|
||||
None => point_param(r, "base").unwrap_or_else(|| s.doc().map(|d| centroid(d, &hs)).unwrap_or_default()),
|
||||
};
|
||||
let base = point_param(r, "base").unwrap_or_else(|| s.doc().map(|d| centroid(d, &hs)).unwrap_or_default());
|
||||
let name = block_from(s, h, &hs, base)?;
|
||||
let (_, _, mut a) = array_of(s.doc()?, h)?;
|
||||
match r.get("items") {
|
||||
@@ -521,13 +477,7 @@ fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if let Some(b) = point_param(p, "base") {
|
||||
rebase(s, h, b)?;
|
||||
}
|
||||
if let Some(k) = key {
|
||||
let at = source_key_point(s.doc()?, h, k, KEY_POINT_TOLERANCE)?;
|
||||
rebase(s, h, at)?;
|
||||
}
|
||||
// A new base point moves the array's insertion point: read `center` in its placement after.
|
||||
let (ins, blk, mut a) = array_of(s.doc()?, h)?;
|
||||
let to_local = ins.transform(blk.base.xy()).inverse().ok_or_else(|| other("The array's scale is zero."))?;
|
||||
let (_, _, mut a) = array_of(s.doc()?, h)?;
|
||||
let before = a.clone();
|
||||
apply_params(&mut a, p, &to_local)?;
|
||||
if a != before {
|
||||
@@ -557,8 +507,6 @@ enum Stage {
|
||||
Select,
|
||||
Main,
|
||||
Base,
|
||||
/// Base point: Key point (of the source objects).
|
||||
BaseKey,
|
||||
ColsCount,
|
||||
ColsSpace,
|
||||
ColsTotal,
|
||||
@@ -576,8 +524,6 @@ enum Stage {
|
||||
/// REPlace: objects, their base point, then the items to replace.
|
||||
RepSelect,
|
||||
RepBase,
|
||||
/// REPlace base point: Key point (of the replacement objects).
|
||||
RepKey,
|
||||
RepItems,
|
||||
/// Source: the item whose objects are placed for editing.
|
||||
SourceItem,
|
||||
@@ -713,7 +659,6 @@ impl Interactive for EditM {
|
||||
.kw(&["Source", "REPlace", "Base point", "Rows", "Columns", "Levels", "RESet", "eXit"])
|
||||
.default("eXit"),
|
||||
Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
|
||||
BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
|
||||
ColsCount => Prompt::new("Enter the number of columns", Accept::NUMBER).default(cols.to_string()),
|
||||
ColsSpace => dist("Specify the distance between columns", cs).kw(&["Total"]),
|
||||
ColsTotal => dist("Specify the distance between the first and last column", total(cols, cs)),
|
||||
@@ -742,7 +687,6 @@ impl Interactive for EditM {
|
||||
Rotate => Prompt::new("Rotate arrayed items?", KEYWORDS).kw(&["Yes", "No"]).default(yes(polar.as_ref().is_none_or(|k| k.rotate))),
|
||||
RepSelect => Prompt::new("Select replacement objects", Accept::SELECT),
|
||||
RepBase => Prompt::new("Select base point of replacement objects", Accept::POINT).kw(&["Key point"]).default("centroid"),
|
||||
RepKey => Prompt::new("Specify key point on replacement objects to use as base point", Accept::POINT),
|
||||
RepItems => Prompt::new("Select an item in array to replace", Accept::POINT).kw(&["Source objects"]),
|
||||
SourceItem => Prompt::new("Select item in array", Accept::POINT),
|
||||
}
|
||||
@@ -802,21 +746,10 @@ impl Interactive for EditM {
|
||||
}
|
||||
Main
|
||||
}
|
||||
(Base, Input::Keyword(_)) => BaseKey,
|
||||
(RepBase, Input::Keyword(_)) => RepKey,
|
||||
(BaseKey, Input::Point(p)) => {
|
||||
let tol = s.pixel_size() * s.settings.pickbox;
|
||||
let at = source_key_point(s.doc()?, h, *p, tol)?;
|
||||
rebase(s, h, at)?;
|
||||
Main
|
||||
(Base | RepBase, Input::Keyword(_)) => {
|
||||
s.echo("Key points are not available yet; specify a point.");
|
||||
stage
|
||||
}
|
||||
(BaseKey, Input::Enter) => Base,
|
||||
(RepKey, Input::Point(p)) => {
|
||||
let base = key_point_of(s.doc()?, &self.rep_objs, *p)?;
|
||||
self.rep_block = Some(block_from(s, h, &self.rep_objs.clone(), base)?);
|
||||
RepItems
|
||||
}
|
||||
(RepKey, Input::Enter) => RepBase,
|
||||
(ColsCount | Items, _) => match count(&i, c64, self.max_for(s, r64.saturating_mul(l64)))? {
|
||||
Some(n) => {
|
||||
let n = super::count32(n);
|
||||
|
||||
@@ -134,7 +134,6 @@ fn run_recover(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(r)
|
||||
}
|
||||
|
||||
/// Write the report to the `.adt` file beside the saved drawing, held to the automation roots.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn write_audit_log(s: &Session, report: &crate::audit::Report) {
|
||||
let (path_str, title) = match s.state() {
|
||||
@@ -144,10 +143,6 @@ fn write_audit_log(s: &Session, report: &crate::audit::Report) {
|
||||
// An unsaved drawing has no folder of its own to hold the log.
|
||||
let Some(path) = &path_str else { return };
|
||||
let adt_path = std::path::PathBuf::from(path).with_extension("adt");
|
||||
if let Err(e) = crate::file_access::check_write(&adt_path) {
|
||||
log::warn!("AUDITCTL: not writing audit log {}: {e}", adt_path.display());
|
||||
return;
|
||||
}
|
||||
let content = report.format_adt(&title, path_str.as_deref());
|
||||
// Write through an exclusively-created temporary and rename over the companion path, so a
|
||||
// planted `.adt` symlink beside the drawing cannot redirect the report onto another file
|
||||
@@ -161,13 +156,10 @@ fn write_audit_log(s: &Session, report: &crate::audit::Report) {
|
||||
fn write_audit_log(_: &Session, _: &crate::audit::Report) {}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
/// The bytes of the file at `path`, once the automation roots allow reading it.
|
||||
fn read_path(cmd: &str, path: &str) -> Result<Vec<u8>> {
|
||||
crate::file_access::check_read(path).map_err(|e| bad(cmd, e))?;
|
||||
crate::capped_read::read_capped(std::path::Path::new(path), file::MAX_DRAWING_BYTES).map_err(|e| bad(cmd, format!("{path}: {e}")))
|
||||
}
|
||||
|
||||
/// The bytes of the drawing at `path`, held to the automation roots.
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn read_path(cmd: &str, _path: &str) -> Result<Vec<u8>> {
|
||||
Err(bad(cmd, "paths are not available on the web; pass `data`"))
|
||||
|
||||
+11
-129
@@ -44,17 +44,13 @@ 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?, justify?: L|C|R|M|TL|TC|TR|ML|MC|MR|BL|BC|BR, style? (default the current text style)}")
|
||||
.params("{tag, prompt?, default?, at, height?, invisible?}")
|
||||
.interactive(|_| Ok(Box::new(attdef::AttdefM::default()))),
|
||||
attedit::attedit_spec(),
|
||||
attedit::dash_attedit_spec(),
|
||||
@@ -96,7 +92,6 @@ 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())
|
||||
@@ -118,15 +113,6 @@ 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 {
|
||||
@@ -360,40 +346,6 @@ 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)
|
||||
}
|
||||
@@ -448,79 +400,21 @@ 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() })))
|
||||
}
|
||||
|
||||
/// 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;
|
||||
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());
|
||||
EntityKind::AttDef(Attrib {
|
||||
tag: tag.to_ascii_uppercase(),
|
||||
text: Text {
|
||||
insert: v3(at),
|
||||
align_pt: if left { None } else { Some(v3(at)) },
|
||||
align_pt: None,
|
||||
height,
|
||||
value: default.into(),
|
||||
rotation: 0.0,
|
||||
width_factor,
|
||||
oblique,
|
||||
width_factor: 1.0,
|
||||
oblique: 0.0,
|
||||
style,
|
||||
halign,
|
||||
valign,
|
||||
halign: HAlign::Left,
|
||||
valign: VAlign::Baseline,
|
||||
},
|
||||
invisible,
|
||||
constant: false,
|
||||
@@ -538,14 +432,7 @@ 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));
|
||||
// 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);
|
||||
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));
|
||||
Ok(json!({ "handle": s.add_entity(k)?.hex() }))
|
||||
}
|
||||
|
||||
@@ -714,7 +601,6 @@ impl BlockM {
|
||||
}
|
||||
|
||||
mod insert_file;
|
||||
pub(crate) mod library;
|
||||
pub(crate) mod xref;
|
||||
|
||||
/// Where the command-line INSERT is in its prompt sequence.
|
||||
@@ -819,9 +705,6 @@ 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)
|
||||
@@ -877,14 +760,13 @@ 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. The
|
||||
/// definition comes before the insertion point and stays when INSERT is then cancelled, as in
|
||||
/// AutoCAD 2027.
|
||||
/// Define the block from a file, then choose it; a file that can't be read is reported.
|
||||
fn choose_file(&mut self, s: &mut Session, f: &insert_file::FileRef) -> Result<()> {
|
||||
match f.define(s) {
|
||||
Ok(name) => self.choose(s, &name),
|
||||
|
||||
@@ -103,7 +103,6 @@ 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 {
|
||||
@@ -112,9 +111,9 @@ impl AttdefM {
|
||||
height: self.height,
|
||||
value: std::mem::take(&mut self.value),
|
||||
rotation,
|
||||
width_factor,
|
||||
oblique,
|
||||
style,
|
||||
width_factor: 1.0,
|
||||
oblique: 0.0,
|
||||
style: self.style.clone(),
|
||||
halign: h,
|
||||
valign: v,
|
||||
},
|
||||
@@ -157,7 +156,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 => crate::cmd::draw::justify_prompt(false),
|
||||
Ask::Justify => Prompt::new("Enter an option", Accept::TEXT).kw(&JUSTIFY),
|
||||
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);
|
||||
|
||||
@@ -4,7 +4,6 @@
|
||||
|
||||
use cadcraft_doc::color::Color;
|
||||
use cadcraft_doc::{AttribProps, Common, EntityKind, HAlign, Handle, Text, VAlign};
|
||||
use cadcraft_geom::Vec3;
|
||||
use serde_json::{Map, Value, json};
|
||||
|
||||
use crate::cmd::curves::KW;
|
||||
@@ -154,47 +153,6 @@ fn set_value(text: &mut Text, value: String) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Move `text` so the point it is placed by lands on `to`: the alignment point of justified text,
|
||||
/// else the insertion point. Both points move by the same offset, so aligned and fit text keep the
|
||||
/// baseline between them.
|
||||
fn move_text(text: &mut Text, to: cadcraft_geom::Vec2) {
|
||||
let anchor = match text.align_pt {
|
||||
Some(ap) if !matches!((text.halign, text.valign), (HAlign::Left, VAlign::Baseline) | (HAlign::Aligned | HAlign::Fit, _)) => ap,
|
||||
_ => text.insert,
|
||||
};
|
||||
let d = Vec3::new(to.x - anchor.x, to.y - anchor.y, 0.0);
|
||||
text.insert = text.insert + d;
|
||||
text.align_pt = text.align_pt.map(|ap| ap + d);
|
||||
}
|
||||
|
||||
/// Move attribute `a` so the point it is placed by lands on `to`. A multiline attribute is drawn
|
||||
/// as its multiline text: that text's insertion point lands on `to`, and the single-line text
|
||||
/// moves with it.
|
||||
fn move_attrib(a: &mut cadcraft_doc::Attrib, to: cadcraft_geom::Vec2) {
|
||||
match &mut a.multiline {
|
||||
Some(m) => {
|
||||
let d = Vec3::new(to.x - m.mtext.insert.x, to.y - m.mtext.insert.y, 0.0);
|
||||
m.mtext.insert = m.mtext.insert + d;
|
||||
a.text.insert = a.text.insert + d;
|
||||
a.text.align_pt = a.text.align_pt.map(|ap| ap + d);
|
||||
}
|
||||
None => move_text(&mut a.text, to),
|
||||
}
|
||||
}
|
||||
|
||||
/// Turn `text` to angle `ang` (radians). Aligned and fit text is drawn along its baseline from
|
||||
/// the insertion point to the alignment point, so that baseline turns about the insertion point,
|
||||
/// its length kept.
|
||||
fn turn_text(text: &mut Text, ang: f64) {
|
||||
text.rotation = ang;
|
||||
if matches!(text.halign, HAlign::Aligned | HAlign::Fit)
|
||||
&& let Some(ap) = text.align_pt
|
||||
{
|
||||
let to = text.insert.xy() + cadcraft_geom::Vec2::from_angle(ang) * ap.xy().dist(text.insert.xy());
|
||||
text.align_pt = Some(to.to3(ap.z));
|
||||
}
|
||||
}
|
||||
|
||||
/// Change the properties set on attribute `k` of block reference `h`.
|
||||
fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut AttribProps)) -> Result<()> {
|
||||
s.doc_mut()?.modify_entity(h, |e| {
|
||||
@@ -207,18 +165,6 @@ fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut Attri
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Modify the attribute `k` of block reference `h`.
|
||||
fn modify_attrib(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut cadcraft_doc::Attrib)) -> Result<()> {
|
||||
s.doc_mut()?.modify_entity(h, |e| {
|
||||
if let EntityKind::Insert(ins) = &mut e.kind
|
||||
&& let Some(a) = ins.attribs.get_mut(k)
|
||||
{
|
||||
f(a);
|
||||
}
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The layer and colour attribute `k` of block reference `h` is drawn with: its own, else its
|
||||
/// definition's (layer 0 is the reference's layer).
|
||||
fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)> {
|
||||
@@ -234,24 +180,6 @@ fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)
|
||||
Some((layer, c.color))
|
||||
}
|
||||
|
||||
/// The current text properties of attribute `k` of block reference `h`.
|
||||
fn current_text(s: &Session, (h, k): (Handle, usize)) -> Option<cadcraft_doc::Text> {
|
||||
let d = s.doc().ok()?;
|
||||
let e = d.entity(h)?;
|
||||
let EntityKind::Insert(ins) = &e.kind else { return None };
|
||||
ins.attribs.get(k).map(|a| a.text.clone())
|
||||
}
|
||||
|
||||
/// The point attribute `k` of block reference `h` is placed by, which a picked height or angle is
|
||||
/// measured from: a multiline attribute's multiline text insertion point, else the text's
|
||||
/// alignment point when justified, else its insertion point.
|
||||
fn placement_point(s: &Session, (h, k): (Handle, usize)) -> Option<cadcraft_geom::Vec2> {
|
||||
let d = s.doc().ok()?;
|
||||
let EntityKind::Insert(ins) = &d.entity(h)?.kind else { return None };
|
||||
let a = ins.attribs.get(k)?;
|
||||
Some(a.multiline.as_ref().map_or_else(|| a.text.justify_point(), |m| m.mtext.insert.xy()))
|
||||
}
|
||||
|
||||
/// Replace every `find` in `value` with `with`, unless the result would be too long.
|
||||
fn replaced(value: &str, find: &str, with: &str) -> Option<String> {
|
||||
if find.is_empty() || !value.contains(find) {
|
||||
@@ -364,10 +292,6 @@ enum Stage {
|
||||
Select,
|
||||
/// One at a time: what to do with the current attribute.
|
||||
Option,
|
||||
Position,
|
||||
Height,
|
||||
Angle,
|
||||
Style,
|
||||
ValueKind,
|
||||
NewValue,
|
||||
Layer,
|
||||
@@ -441,7 +365,6 @@ impl Interactive for DashAtteditM {
|
||||
}
|
||||
fn prompt(&self, s: &Session) -> Prompt {
|
||||
let cur = self.items.get(self.cur).and_then(|it| current_props(s, *it));
|
||||
let cur_text = self.items.get(self.cur).and_then(|it| current_text(s, *it));
|
||||
match self.stage {
|
||||
Stage::OneAtATime => Prompt::new("Edit attributes one at a time?", KW).kw(&["Yes", "No"]).default("Y"),
|
||||
Stage::VisibleOnly => Prompt::new("Edit only attributes visible on screen?", KW).kw(&["Yes", "No"]).default("Y"),
|
||||
@@ -449,31 +372,7 @@ impl Interactive for DashAtteditM {
|
||||
Stage::TagSpec => Prompt::new("Enter attribute tag specification", Accept::TEXT).default("*"),
|
||||
Stage::ValueSpec => Prompt::new("Enter attribute value specification", Accept::TEXT).default("*"),
|
||||
Stage::Select => Prompt::new("Select attributes", Accept::SELECT),
|
||||
Stage::Option => {
|
||||
Prompt::new("Enter an option", KW).kw(&["Value", "Position", "Height", "Angle", "Style", "Layer", "Color", "Next"]).default("N")
|
||||
}
|
||||
Stage::Position => Prompt::new("Enter new text insertion point", Accept::POINT),
|
||||
Stage::Height => {
|
||||
let p = Prompt::new("Enter new text height", Accept::POINT_OR_NUMBER);
|
||||
match cur_text {
|
||||
Some(t) => p.default(format!("{:.4}", t.height)),
|
||||
None => p,
|
||||
}
|
||||
}
|
||||
Stage::Angle => {
|
||||
let p = Prompt::new("Enter new text rotation angle", Accept::POINT_OR_NUMBER);
|
||||
match cur_text {
|
||||
Some(t) => p.default(format!("{:.4}", t.rotation.to_degrees())),
|
||||
None => p,
|
||||
}
|
||||
}
|
||||
Stage::Style => {
|
||||
let p = Prompt::new("Enter new text style", Accept::TEXT);
|
||||
match cur_text {
|
||||
Some(t) => p.default(t.style),
|
||||
None => p,
|
||||
}
|
||||
}
|
||||
Stage::Option => Prompt::new("Enter an option", KW).kw(&["Value", "Layer", "Color", "Next"]).default("N"),
|
||||
Stage::ValueKind => Prompt::new("Enter type of value modification", KW).kw(&["Change", "Replace"]).default("R"),
|
||||
Stage::NewValue => Prompt::new("Enter new attribute value", Accept::TEXT),
|
||||
Stage::Layer => {
|
||||
@@ -547,10 +446,6 @@ impl Interactive for DashAtteditM {
|
||||
}
|
||||
Stage::Option => match &i {
|
||||
Input::Keyword(k) if k == "Value" => self.stage = Stage::ValueKind,
|
||||
Input::Keyword(k) if k == "Position" => self.stage = Stage::Position,
|
||||
Input::Keyword(k) if k == "Height" => self.stage = Stage::Height,
|
||||
Input::Keyword(k) if k == "Angle" => self.stage = Stage::Angle,
|
||||
Input::Keyword(k) if k == "Style" => self.stage = Stage::Style,
|
||||
Input::Keyword(k) if k == "Layer" => self.stage = Stage::Layer,
|
||||
Input::Keyword(k) if k == "Color" => self.stage = Stage::Color,
|
||||
Input::Keyword(_) | Input::Enter => {
|
||||
@@ -562,114 +457,14 @@ impl Interactive for DashAtteditM {
|
||||
}
|
||||
Input::Text(t) => {
|
||||
let tl = t.trim().to_ascii_lowercase();
|
||||
let opts = ["Value", "Position", "Height", "Angle", "Style", "Layer", "Color", "Next"];
|
||||
match opts.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
|
||||
Some(&"Value") => self.stage = Stage::ValueKind,
|
||||
Some(&"Position") => self.stage = Stage::Position,
|
||||
Some(&"Height") => self.stage = Stage::Height,
|
||||
Some(&"Angle") => self.stage = Stage::Angle,
|
||||
Some(&"Style") => self.stage = Stage::Style,
|
||||
Some(&"Layer") => self.stage = Stage::Layer,
|
||||
Some(&"Color") => self.stage = Stage::Color,
|
||||
Some(&"Next") => {
|
||||
self.cur += 1;
|
||||
if self.cur >= self.items.len() {
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
self.show_current(s);
|
||||
}
|
||||
_ => return Err(invalid_keyword()),
|
||||
}
|
||||
let later = ["Position", "Height", "Angle", "Style"];
|
||||
return match later.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
|
||||
Some(k) => Err(EngineError::Other(format!("{k} is not available yet."))),
|
||||
None => Err(invalid_keyword()),
|
||||
};
|
||||
}
|
||||
_ => {}
|
||||
},
|
||||
Stage::Position => {
|
||||
let p = match i {
|
||||
Input::Point(p) => p,
|
||||
Input::Enter => {
|
||||
self.stage = Stage::Option;
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
_ => return Ok(Step::Continue),
|
||||
};
|
||||
if let Some(it) = self.items.get(self.cur).copied() {
|
||||
modify_attrib(s, it, |a| move_attrib(a, p))?;
|
||||
}
|
||||
self.stage = Stage::Option;
|
||||
}
|
||||
Stage::Height => {
|
||||
let h = match &i {
|
||||
Input::Point(p) => {
|
||||
let cur_pt = self.items.get(self.cur).and_then(|it| placement_point(s, *it));
|
||||
match cur_pt {
|
||||
Some(base) => base.dist(*p).max(1e-9),
|
||||
None => p.len().max(1e-9),
|
||||
}
|
||||
}
|
||||
Input::Text(t) if !t.trim().is_empty() => crate::units::parse_distance(t.trim())
|
||||
.filter(|v| *v > 0.0)
|
||||
.ok_or_else(|| EngineError::Other("Requires a positive number.".into()))?,
|
||||
Input::Enter => {
|
||||
self.stage = Stage::Option;
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
_ => return Ok(Step::Continue),
|
||||
};
|
||||
if let Some(it) = self.items.get(self.cur).copied() {
|
||||
modify_attrib(s, it, |a| {
|
||||
a.text.height = h;
|
||||
if let Some(m) = &mut a.multiline {
|
||||
m.mtext.height = h;
|
||||
}
|
||||
})?;
|
||||
}
|
||||
self.stage = Stage::Option;
|
||||
}
|
||||
Stage::Angle => {
|
||||
let ang = match &i {
|
||||
Input::Point(p) => {
|
||||
let cur_pt = self.items.get(self.cur).and_then(|it| placement_point(s, *it));
|
||||
match cur_pt {
|
||||
Some(base) => base.angle_to(*p),
|
||||
None => p.y.atan2(p.x),
|
||||
}
|
||||
}
|
||||
Input::Text(t) if !t.trim().is_empty() => {
|
||||
s.angle_settings().direction(t.trim()).ok_or_else(|| EngineError::Other("Requires an angle.".into()))?
|
||||
}
|
||||
Input::Enter => {
|
||||
self.stage = Stage::Option;
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
_ => return Ok(Step::Continue),
|
||||
};
|
||||
if let Some(it) = self.items.get(self.cur).copied() {
|
||||
modify_attrib(s, it, |a| {
|
||||
turn_text(&mut a.text, ang);
|
||||
if let Some(m) = &mut a.multiline {
|
||||
m.mtext.rotation = ang;
|
||||
}
|
||||
})?;
|
||||
}
|
||||
self.stage = Stage::Option;
|
||||
}
|
||||
Stage::Style => {
|
||||
let Some(t) = text else { return Ok(Step::Continue) };
|
||||
let t = t.trim();
|
||||
if !t.is_empty() {
|
||||
let st =
|
||||
s.doc()?.text_style(t).map(|st| st.name.clone()).ok_or_else(|| EngineError::Other(format!("Cannot find style \"{t}\".")))?;
|
||||
if let Some(it) = self.items.get(self.cur).copied() {
|
||||
modify_attrib(s, it, |a| {
|
||||
if let Some(m) = &mut a.multiline {
|
||||
m.mtext.style.clone_from(&st);
|
||||
}
|
||||
a.text.style = st;
|
||||
})?;
|
||||
}
|
||||
}
|
||||
self.stage = Stage::Option;
|
||||
}
|
||||
Stage::ValueKind => match &i {
|
||||
Input::Keyword(k) if k == "Change" => self.stage = Stage::Find,
|
||||
Input::Keyword(_) | Input::Enter => self.stage = Stage::NewValue,
|
||||
|
||||
@@ -184,10 +184,8 @@ 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"]).takes_block(),
|
||||
Stage::New => {
|
||||
Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]).takes_block()
|
||||
}
|
||||
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::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"),
|
||||
}
|
||||
|
||||
@@ -260,11 +260,9 @@ fn csv(columns: &[String], rows: &[Vec<Cell>], sep: char) -> String {
|
||||
out
|
||||
}
|
||||
|
||||
/// Write the extracted table to `path`, held to the automation roots.
|
||||
fn write_file(path: &str, text: &str) -> Result<()> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_write(path).map_err(EngineError::Other)?;
|
||||
std::fs::write(path, text).map_err(|e| EngineError::Other(format!("{path}: {e}")))
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
|
||||
@@ -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, BTreeSet};
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use cadcraft_doc::{Block, Drawing, Entity, EntityKind, Handle};
|
||||
@@ -14,8 +14,7 @@ use serde_json::{Value, json};
|
||||
|
||||
use super::super::file::io;
|
||||
use super::super::modify::explode_kind;
|
||||
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 super::{references_block, valid_block_name};
|
||||
use crate::cmd::{bad, str_param};
|
||||
use crate::{EngineError, Result, Session};
|
||||
|
||||
@@ -38,7 +37,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, false)
|
||||
define_from(s, &src, &self.name)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -46,11 +45,6 @@ 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() };
|
||||
@@ -58,7 +52,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 {
|
||||
if !pathlike || s.doc().is_ok_and(|d| d.block(t).is_some()) {
|
||||
return None;
|
||||
}
|
||||
Some(FileRef { name: stem(t), path: t.to_string(), explicit: false })
|
||||
@@ -74,7 +68,7 @@ pub(super) fn stem(path: &str) -> String {
|
||||
}
|
||||
|
||||
/// Read a drawing file through the io hooks; a path without extension tries .dwg, then .dxf.
|
||||
pub(super) fn read_drawing(path: &str) -> Result<Drawing> {
|
||||
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")] };
|
||||
@@ -88,11 +82,9 @@ pub(super) fn read_drawing(path: &str) -> Result<Drawing> {
|
||||
Err(last.unwrap_or_else(|| bad("insert", format!("{path}: file not found"))))
|
||||
}
|
||||
|
||||
/// The bytes of the drawing to insert, held to the automation roots.
|
||||
fn read_file(_path: &str) -> Result<Vec<u8>> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(_path).map_err(|e| bad("insert", e))?;
|
||||
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
|
||||
.map_err(|e| bad("insert", format!("{_path}: {e}")))
|
||||
}
|
||||
@@ -101,29 +93,18 @@ 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. 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> {
|
||||
/// 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> {
|
||||
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 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 renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
|
||||
for (from, to) in &renames {
|
||||
let Some(b) = src.blocks.get(from) else { continue };
|
||||
let mut nb = (**b).clone();
|
||||
nb.name = to.clone();
|
||||
@@ -149,129 +130,10 @@ pub(super) fn define_from(s: &mut Session, src: &Drawing, name: &str, only_neede
|
||||
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) {
|
||||
@@ -285,42 +147,9 @@ 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: &Renames) -> Entity {
|
||||
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
|
||||
let mut e = e.clone();
|
||||
let old = e.handle;
|
||||
e.handle = d.new_handle();
|
||||
@@ -345,23 +174,6 @@ fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &Renames) -> Entit
|
||||
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();
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@@ -422,78 +234,6 @@ 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();
|
||||
@@ -506,211 +246,4 @@ 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"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,403 +0,0 @@
|
||||
//! 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>> {
|
||||
// Before the cache too: a drawing read earlier must not be handed out past the roots.
|
||||
crate::file_access::check_read(path).map_err(|e| bad("blocklibrary", e))?;
|
||||
// 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> {
|
||||
// Before anything looks at the path: a folder's listing, or whether it is one, says what is
|
||||
// outside the automation roots.
|
||||
crate::file_access::check_read(path).map_err(|e| bad("blocklibrary", e))?;
|
||||
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::*;
|
||||
|
||||
/// Under the automation roots a library folder or file outside them is refused before it is
|
||||
/// listed or read.
|
||||
#[test]
|
||||
fn the_automation_roots_hold_library_paths() {
|
||||
let base = std::env::temp_dir().join(format!("cadcraft-library-roots-{}", std::process::id()));
|
||||
let (inside, outside) = (base.join("in"), base.join("outside"));
|
||||
std::fs::create_dir_all(&inside).unwrap();
|
||||
std::fs::create_dir_all(&outside).unwrap();
|
||||
std::fs::write(outside.join("parts.dxf"), b"0\nEOF\n").unwrap();
|
||||
let roots = crate::file_access::AutomationRoots::new(Some(&inside), None).unwrap();
|
||||
crate::file_access::confine(roots.as_ref(), || {
|
||||
let folder = list_library(&outside.to_string_lossy()).map(|v| v.to_string());
|
||||
assert!(folder.as_ref().is_err_and(|e| e.to_string().contains("automation")), "{folder:?}");
|
||||
let file = list_library(&outside.join("parts.dxf").to_string_lossy()).map(|v| v.to_string());
|
||||
assert!(file.as_ref().is_err_and(|e| e.to_string().contains("automation")), "{file:?}");
|
||||
assert!(list_library(&inside.to_string_lossy()).is_ok());
|
||||
});
|
||||
let _ = std::fs::remove_dir_all(&base);
|
||||
}
|
||||
|
||||
/// 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,40 +114,17 @@ 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>> {
|
||||
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,
|
||||
}
|
||||
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)
|
||||
}
|
||||
|
||||
/// 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, _)| is_arrow_override(k)).filter_map(|(_, v)| override_name(v)).filter(|n| !n.is_empty())
|
||||
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())
|
||||
}
|
||||
|
||||
/// Upper-case names of blocks reachable from model space, the layouts and dimensions, and the
|
||||
@@ -174,9 +151,10 @@ pub(in crate::cmd) fn used_blocks(d: &Drawing) -> HashSet<String> {
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
// Each block is walked once, so this ends, cycles included.
|
||||
let mut guard = 0;
|
||||
while let Some(n) = frontier.pop() {
|
||||
if !used.insert(n.to_ascii_uppercase()) {
|
||||
guard += 1;
|
||||
if guard > 100_000 || !used.insert(n.to_ascii_uppercase()) {
|
||||
continue;
|
||||
}
|
||||
if let Some(b) = d.block(&n) {
|
||||
@@ -200,33 +178,6 @@ 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> {
|
||||
@@ -246,7 +197,21 @@ pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
|
||||
.collect()
|
||||
}
|
||||
Kind::Linetypes => {
|
||||
let used = lower(&mut linetypes_in_use(d));
|
||||
// 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 cur = d.header.str("CELTYPE", "ByLayer");
|
||||
d.linetypes
|
||||
.iter()
|
||||
|
||||
@@ -105,8 +105,6 @@ fn write(s: &Session, cmd: &str, path: &str, what: Source) -> Result<(usize, usi
|
||||
let bytes = (hooks.write)(&d, path).map_err(|e| bad(cmd, e))?;
|
||||
// Through a temporary file, as SAVE writes, so a failed write keeps the file it replaces.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
|
||||
let lost = if drops_unknown(path) { not_saved(&d) } else { BTreeMap::new() };
|
||||
Ok((d.model.len(), bytes.len(), lost))
|
||||
@@ -172,9 +170,7 @@ fn output_path(typed: &str) -> String {
|
||||
fn exists(path: &str) -> bool {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
// Outside the automation roots the answer would say whether a file is there; the write
|
||||
// that follows is refused anyway.
|
||||
crate::file_access::check_write(path).is_ok() && std::path::Path::new(path).exists()
|
||||
std::path::Path::new(path).exists()
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
{
|
||||
|
||||
@@ -408,7 +408,6 @@ fn run_xbind(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "bound": bound }))
|
||||
}
|
||||
|
||||
/// Open the file a selected reference points at, as its own drawing.
|
||||
fn run_xopen(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let d = s.doc()?;
|
||||
let name = match str_param(p, "name") {
|
||||
@@ -430,9 +429,6 @@ fn run_xopen(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let file = load::find(&path, host.as_deref().map(std::path::Path::new), false).map_err(|m| match m {
|
||||
load::Missing::NotFound => bad("xopen", format!("{path}: file not found")),
|
||||
load::Missing::Refused(r) => bad("xopen", format!("{path}: not opened, {r}")),
|
||||
load::Missing::OutsideRoots => {
|
||||
bad("xopen", format!("{path}: not opened, automation path rejected: outside the read root (or the write root)"))
|
||||
}
|
||||
})?;
|
||||
s.execute("open", &json!({ "path": file.to_string_lossy() }))
|
||||
}
|
||||
|
||||
@@ -145,12 +145,9 @@ pub(crate) enum Missing {
|
||||
NotFound,
|
||||
/// The saved path isn't followed, and there is no file of its name beside the host.
|
||||
Refused(Refused),
|
||||
/// The automation roots don't reach the file ([`crate::file_access`]).
|
||||
OutsideRoots,
|
||||
}
|
||||
|
||||
impl Missing {
|
||||
/// The status and message a reference gets when its file can't be loaded.
|
||||
fn outcome(self, path: &str) -> (XrefStatus, String) {
|
||||
match self {
|
||||
Self::NotFound => {
|
||||
@@ -158,9 +155,6 @@ impl Missing {
|
||||
(XrefStatus::NotFound, format!("{path}: {why}"))
|
||||
}
|
||||
Self::Refused(r) => (XrefStatus::Unresolved, format!("{path}: not opened, {r}")),
|
||||
Self::OutsideRoots => {
|
||||
(XrefStatus::Unresolved, format!("{path}: not opened, automation path rejected: outside the read root (or the write root)"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -214,36 +208,14 @@ pub(crate) fn find(path: &str, host: Option<&Path>, chosen: bool) -> Result<Path
|
||||
return Err(Missing::NotFound);
|
||||
}
|
||||
let (files, refused) = candidates(path, host, chosen);
|
||||
// Outside the automation roots a place isn't even looked at, so the answer can't tell whether a
|
||||
// file is there. A match found by ignoring case is checked again: it can be a link leading out.
|
||||
let allowed = |p: &PathBuf| crate::file_access::check_read(p).is_ok();
|
||||
let looked_for = files.len();
|
||||
let files: Vec<PathBuf> = files.into_iter().filter(allowed).collect();
|
||||
let outside = files.len() < looked_for;
|
||||
// A match found by ignoring case that the roots refuse counts as outside them too.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
let mut refused_match = false;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| {
|
||||
files.iter().find_map(|p| {
|
||||
let c = match case_insensitive(p) {
|
||||
Ok(Some(c)) => c,
|
||||
Ok(None) => return None,
|
||||
Err(()) => {
|
||||
refused_match = true;
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let ok = allowed(&c);
|
||||
refused_match |= !ok;
|
||||
ok.then_some(c)
|
||||
})
|
||||
});
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
let outside = outside || refused_match;
|
||||
let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| files.iter().find_map(|p| case_insensitive(p)));
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
let found: Option<PathBuf> = None;
|
||||
found.ok_or(if outside { Missing::OutsideRoots } else { refused.map_or(Missing::NotFound, Missing::Refused) })
|
||||
let found: Option<PathBuf> = {
|
||||
let _ = files;
|
||||
None
|
||||
};
|
||||
found.ok_or(refused.map_or(Missing::NotFound, Missing::Refused))
|
||||
}
|
||||
|
||||
/// Upper bound on directory entries scanned per path component by [`case_insensitive`].
|
||||
@@ -253,16 +225,10 @@ const MAX_CASE_SCAN: usize = 10_000;
|
||||
/// The existing file `p` names when its letters' case is ignored, on file systems that don't
|
||||
/// ignore it themselves. Drawings made on Windows often store a reference as `PLAN.DWG` for
|
||||
/// `Plan.dwg`; Windows finds it, and so should Linux. Each missing component is matched against
|
||||
/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing. `Err` when
|
||||
/// the automation roots refuse a place it would have to look in.
|
||||
/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn case_insensitive(p: &Path) -> Result<Option<PathBuf>, ()> {
|
||||
fn case_insensitive(p: &Path) -> Option<PathBuf> {
|
||||
use std::path::Component;
|
||||
// Under the automation roots a place is probed only when the roots allow it, or when it lies on
|
||||
// the way to `p` as it was spelled (which was checked): a name corrected to another case could be
|
||||
// a link leading out, and looking inside it would look outside the roots.
|
||||
let mut corrected = false;
|
||||
let probe = |q: &Path, corrected: bool| (!corrected && p.starts_with(q)) || crate::file_access::check_read(q).is_ok();
|
||||
let mut out = PathBuf::new();
|
||||
for c in p.components() {
|
||||
let Component::Normal(name) = c else {
|
||||
@@ -270,27 +236,23 @@ fn case_insensitive(p: &Path) -> Result<Option<PathBuf>, ()> {
|
||||
continue;
|
||||
};
|
||||
let exact = out.join(name);
|
||||
if !probe(&exact, corrected) {
|
||||
return Err(());
|
||||
}
|
||||
if exact.exists() {
|
||||
out = exact;
|
||||
continue;
|
||||
}
|
||||
let Some(want) = name.to_str().map(str::to_lowercase) else { return Ok(None) };
|
||||
let Ok(entries) = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out }) else { return Ok(None) };
|
||||
let mut hits = entries.take(MAX_CASE_SCAN).flatten().filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
|
||||
let Some(hit) = hits.next() else { return Ok(None) };
|
||||
let want = name.to_str()?.to_lowercase();
|
||||
let mut hits = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out })
|
||||
.ok()?
|
||||
.take(MAX_CASE_SCAN)
|
||||
.flatten()
|
||||
.filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
|
||||
let hit = hits.next()?;
|
||||
if hits.next().is_some() {
|
||||
return Ok(None);
|
||||
return None;
|
||||
}
|
||||
out.push(hit.file_name());
|
||||
corrected = true;
|
||||
if !probe(&out, corrected) {
|
||||
return Err(());
|
||||
}
|
||||
}
|
||||
Ok(out.is_file().then_some(out))
|
||||
out.is_file().then_some(out)
|
||||
}
|
||||
|
||||
/// Read a drawing file through the host's io hooks, counting its bytes against the load's total.
|
||||
@@ -299,7 +261,6 @@ fn read(file: &Path, cx: &mut Ctx) -> Result<Drawing, String> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
use std::io::Read;
|
||||
crate::file_access::check_read(file)?;
|
||||
let left = MAX_XREF_TOTAL_BYTES.saturating_sub(cx.bytes);
|
||||
let limit = MAX_XREF_BYTES.min(left);
|
||||
let mut f = std::fs::File::open(file).map_err(|e| e.to_string())?;
|
||||
@@ -642,48 +603,6 @@ mod tests {
|
||||
assert_eq!(find("", Some(&host), false), Err(Missing::NotFound));
|
||||
}
|
||||
|
||||
/// A name corrected to another case is checked against the roots before it is looked inside, and a
|
||||
/// match they refuse leaves the other candidates to be tried.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_name_corrected_to_a_link_out_of_the_roots_is_not_looked_inside() {
|
||||
use crate::file_access::{AutomationRoots, confine};
|
||||
let base = std::env::temp_dir().join(format!("cc-xref-case-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&base);
|
||||
for d in ["in/sub", "outside"] {
|
||||
std::fs::create_dir_all(base.join(d)).unwrap();
|
||||
}
|
||||
std::fs::write(base.join("outside/target.dxf"), "x").unwrap();
|
||||
std::fs::write(base.join("in/Mixed.dxf"), "x").unwrap();
|
||||
std::os::unix::fs::symlink(base.join("outside"), base.join("in/Alias")).unwrap();
|
||||
std::os::unix::fs::symlink(base.join("outside/target.dxf"), base.join("in/sub/Mixed.dxf")).unwrap();
|
||||
if base.join("in/alias").exists() {
|
||||
// A case-insensitive file system never needs a name corrected: nothing to test.
|
||||
eprintln!("skipped: this file system ignores case");
|
||||
std::fs::remove_dir_all(&base).unwrap();
|
||||
return;
|
||||
}
|
||||
let roots = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
|
||||
confine(Some(&roots), || {
|
||||
// `alias` isn't there but `Alias` is, a link out: the probe stops before looking in it.
|
||||
assert_eq!(case_insensitive(&base.join("in/alias/target.dxf")), Err(()));
|
||||
// A match that leaves the roots doesn't end the search: the next candidate is tried.
|
||||
let host = base.join("in/host.dxf");
|
||||
let found = find("sub/mixed.dxf", Some(&host), true).unwrap();
|
||||
assert_eq!(found, base.join("in/Mixed.dxf"));
|
||||
// With no other candidate it is still a refusal by the roots, not a missing file.
|
||||
std::fs::create_dir_all(base.join("in/lone")).unwrap();
|
||||
std::os::unix::fs::symlink(base.join("outside/target.dxf"), base.join("in/lone/Only.dxf")).unwrap();
|
||||
assert_eq!(find("lone/only.dxf", Some(&host), true), Err(Missing::OutsideRoots));
|
||||
});
|
||||
assert_eq!(
|
||||
case_insensitive(&base.join("in/alias/target.dxf")),
|
||||
Ok(Some(base.join("in/Alias/target.dxf"))),
|
||||
"without roots the link is followed"
|
||||
);
|
||||
std::fs::remove_dir_all(&base).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prefixes_ignore_case() {
|
||||
assert!(has_prefix("SITE|Walls", "site|"));
|
||||
|
||||
@@ -564,17 +564,7 @@ pub fn seg_param(s: &Segment, p: Vec2) -> f64 {
|
||||
match s {
|
||||
Segment::Line(l) => l.param_of(p).clamp(0.0, 1.0),
|
||||
Segment::Arc { arc, ccw } => {
|
||||
// A point just outside the sweep (on the arc within tolerance of an end) goes to the
|
||||
// nearer end: a hair before the start is the start, not round the circle to the end.
|
||||
let a = cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start);
|
||||
let sweep = arc.sweep().max(1e-15);
|
||||
let t = if a <= sweep {
|
||||
a / sweep
|
||||
} else if a - sweep < TAU - a {
|
||||
1.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let t = (cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15)).clamp(0.0, 1.0);
|
||||
if *ccw { t } else { 1.0 - t }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,509 +0,0 @@
|
||||
//! -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
|
||||
}
|
||||
}
|
||||
@@ -1,108 +0,0 @@
|
||||
//! 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,9 +33,8 @@ 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,16 +25,6 @@ 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;
|
||||
@@ -129,7 +119,8 @@ 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 justify_prompt(true);
|
||||
return Prompt::new("Enter an option", Accept::TEXT)
|
||||
.kw(&["Left", "Center", "Right", "Align", "Middle", "Fit", "TL", "TC", "TR", "ML", "MC", "MR", "BL", "BC", "BR"]);
|
||||
}
|
||||
match (self.at, self.height, self.rotation) {
|
||||
(None, _, _) => Prompt::new("Specify start point of text", Accept::POINT).kw(&["Justify", "Style"]),
|
||||
|
||||
@@ -601,25 +601,6 @@ fn measure_spline_by_its_own_parameter() {
|
||||
assert!(pts.len() == 3 && [7.0, 4.0, 1.0].iter().all(|x| pts.iter().any(|p| near(*p, *x, 0.0))), "{pts:?}");
|
||||
}
|
||||
|
||||
/// A pick a hair outside an arc's sweep beside its start is at its start, for an arc and for a
|
||||
/// polyline's arc span alike: MEASURE runs from there (round the circle it was the far end).
|
||||
#[test]
|
||||
fn measure_from_a_pick_a_hair_before_an_arcs_start() {
|
||||
let curves = [
|
||||
("arc", json!({"center": [0, 0], "radius": 1, "start": 0, "end": 180})),
|
||||
("pline", json!({"vertices": [{"p": [1, 0], "bulge": 1}, [-1, 0]]})),
|
||||
];
|
||||
for (cmd, args) in curves {
|
||||
let mut s = Session::new();
|
||||
let e = h(&s.execute(cmd, &args).unwrap());
|
||||
s.execute("measure", &json!({"handle": e, "length": 1, "from": [1, -1e-13]})).unwrap();
|
||||
let pts: Vec<Vec2> =
|
||||
s.doc().unwrap().model.iter().filter_map(|e| if let EntityKind::Point(p) = &e.kind { Some(p.p.xy()) } else { None }).collect();
|
||||
// From (1, 0), a point every radian.
|
||||
assert!(pts.len() == 3 && [1.0f64, 2.0, 3.0].iter().all(|a| pts.iter().any(|p| near(*p, a.cos(), a.sin()))), "{cmd}: {pts:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// MEASURE counts every vertex in a polyline's parameter, coincident ones too (AutoCAD's polyline
|
||||
/// parameter is the vertex index; the chain drops zero-length spans), and picks an ellipse's end
|
||||
/// by the ellipse parameter like any other curve: AutoCAD 2024 runs both measured cases below from
|
||||
|
||||
@@ -557,15 +557,9 @@ 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| crate::select::selectable(d, e, frozen) && d.layer(&e.common.layer).is_none_or(|l| !l.locked))
|
||||
.map(|e| e.handle)
|
||||
.collect()
|
||||
})
|
||||
.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())
|
||||
.unwrap_or_default();
|
||||
let n = hs.len();
|
||||
s.set_selection(hs);
|
||||
@@ -586,19 +580,16 @@ 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_in(s.doc()?, &space, s.viewport_frozen(), Bounds2::new(*a, *b), bool_or(p, "crossing", false))
|
||||
crate::select::select_window(s.doc()?, &space, 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_in(s.doc()?, &space, s.viewport_frozen(), at, ap).into_iter().collect()
|
||||
crate::select::pick(s.doc()?, &space, at, ap).into_iter().collect()
|
||||
} else if let Some(f) = points_param(p, "fence") {
|
||||
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)?
|
||||
crate::select::select_fence(s.doc()?, &space, &f)
|
||||
} else {
|
||||
// Nothing to select with: the selection stays, also what the active viewport does not draw.
|
||||
s.stored_selection()
|
||||
targets(s, p)?
|
||||
};
|
||||
let mut sel = if add { s.stored_selection() } else { Vec::new() };
|
||||
let mut sel = if add { s.selection() } else { Vec::new() };
|
||||
sel.extend(picked);
|
||||
s.set_selection(sel);
|
||||
let sel = s.selection();
|
||||
|
||||
@@ -11,7 +11,7 @@ use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use cadcraft_color::Rgb;
|
||||
use cadcraft_doc::{Drawing, Entity, EntityKind, Space};
|
||||
use cadcraft_doc::{Drawing, Entity, EntityKind, PageSetup, Space};
|
||||
use cadcraft_geom::{Bounds2, Mat3, Vec2};
|
||||
use cadcraft_render::paper::{self, Sheet};
|
||||
use cadcraft_render::raster::{RasterOptions, View};
|
||||
@@ -82,7 +82,6 @@ fn write_file(cmd: &str, path: &str, bytes: &[u8]) -> Result<()> {
|
||||
{
|
||||
// Exclusively create a fresh temporary file and rename it into place so a planted
|
||||
// `<path>.cadcraft-tmp` symlink cannot redirect the export write (CWE-59).
|
||||
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
|
||||
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
@@ -202,11 +201,9 @@ fn import_drawing(s: &mut Session, src: &Drawing, at: Vec2, scale: f64, file: &s
|
||||
}))
|
||||
}
|
||||
|
||||
/// The bytes of the file to import, held to the automation roots.
|
||||
fn read_file(_path: &str) -> Result<Vec<u8>> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(_path).map_err(|e| bad("import", e))?;
|
||||
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
|
||||
.map_err(|e| bad("import", format!("{_path}: {e}")))
|
||||
}
|
||||
@@ -279,8 +276,18 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let d = s.doc()?;
|
||||
let mut page = match space.layout() {
|
||||
Some(n) => d.layout(n).map(|l| l.page.clone()).unwrap_or_default(),
|
||||
// Model space plots on ISO A4 (metric) or ANSI A, like the PDF plotter.
|
||||
None => paper::model_page(d),
|
||||
None => {
|
||||
// Model space plots on A4 (metric) or ANSI A, like the PDF plotter.
|
||||
let mut page = PageSetup::default();
|
||||
if paper::paper_unit_mm(d) == 1.0
|
||||
&& let Some(a4) = paper::paper_size("A4")
|
||||
{
|
||||
page.paper = a4.name.into();
|
||||
page.width_mm = a4.width_mm;
|
||||
page.height_mm = a4.height_mm;
|
||||
}
|
||||
page
|
||||
}
|
||||
};
|
||||
if let Some(name) = str_param(p, "paper") {
|
||||
let ps = paper::paper_size(name).ok_or_else(|| bad("preview", format!("unknown paper size `{name}`")))?;
|
||||
@@ -288,10 +295,6 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
page.width_mm = ps.width_mm;
|
||||
page.height_mm = ps.height_mm;
|
||||
}
|
||||
// A model-space plot takes its units from the paper it was given (a layout keeps its page setup's).
|
||||
if matches!(space, Space::Model) {
|
||||
paper::apply_model_paper_units(&mut page);
|
||||
}
|
||||
if let Some(l) = p.get("landscape").and_then(Value::as_bool) {
|
||||
page.landscape = l;
|
||||
}
|
||||
@@ -360,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 = cadcraft_render::raster::encode_png(&pm).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
|
||||
let png = pm.encode_png().map_err(|_| 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 }))
|
||||
}
|
||||
|
||||
@@ -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::{greek_alias, specs as alias_specs, user_alias};
|
||||
pub(crate) use pgp::{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
|
||||
@@ -67,22 +67,6 @@ 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;
|
||||
|
||||
@@ -240,7 +224,6 @@ fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = _path;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(path).map_err(|e| bad("script", e))?;
|
||||
let bytes =
|
||||
crate::capped_read::read_capped(std::path::Path::new(path), MAX_SCRIPT_BYTES).map_err(|e| bad("script", format!("{path}: {e}")))?;
|
||||
String::from_utf8_lossy(&bytes).into_owned()
|
||||
@@ -321,7 +304,6 @@ pub fn read_file(path: &std::path::Path) -> std::result::Result<ReadFile, String
|
||||
let Some(text_path) = path.to_str() else {
|
||||
return Err(bad("open", format!("{shown}: the file name is not valid Unicode, so CADCraft can't save back to it")));
|
||||
};
|
||||
crate::file_access::check_read(text_path).map_err(|e| bad("open", e))?;
|
||||
let bytes = crate::capped_read::read_capped(path, MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{shown}: {e}")))?;
|
||||
read_bytes(&bytes, text_path, Some(text_path.to_string()))
|
||||
});
|
||||
@@ -346,7 +328,6 @@ pub fn finish_open(s: &mut Session, f: ReadFile) -> Result<Value> {
|
||||
Ok(opened(s, i, true))
|
||||
}
|
||||
|
||||
/// Parse a drawing's bytes, and search its folder for fonts where the automation roots allow.
|
||||
fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile> {
|
||||
let hooks = io().ok_or_else(|| bad("open", "file formats are not available in this build"))?;
|
||||
let drawing = (hooks.read)(bytes, name).map_err(|e| bad("open", e))?;
|
||||
@@ -357,17 +338,7 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
|
||||
if let Some(dir) = path.as_deref().and_then(|p| std::path::Path::new(p).parent()) {
|
||||
// A bare file name is in the current folder.
|
||||
let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
|
||||
let dir = std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf());
|
||||
match crate::file_access::current() {
|
||||
None => cadcraft_fonts::shx::add_drawing_dir(&dir),
|
||||
// The folder holds no record of the roots, and a font's name there can be a link leading
|
||||
// out of them: the search asks the roots about each file before it opens one.
|
||||
Some(roots) => {
|
||||
let owner = format!("{:?}|{:?}", roots.read_root(), roots.write_root());
|
||||
let guard = std::sync::Arc::new(move |font: &std::path::Path| roots.check(font, crate::file_access::Access::Read).is_ok());
|
||||
cadcraft_fonts::shx::add_drawing_dir_guarded(&dir, &owner, guard);
|
||||
}
|
||||
}
|
||||
cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
|
||||
}
|
||||
Ok(ReadFile { drawing, binary_dxf: craft_dxf::is_binary(bytes), name: name.to_string(), path })
|
||||
}
|
||||
@@ -410,7 +381,6 @@ fn run_open(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = _path;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(path).map_err(|e| bad("open", e))?;
|
||||
let bytes =
|
||||
crate::capped_read::read_capped(std::path::Path::new(path), MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{path}: {e}")))?;
|
||||
let i = open_bytes(s, &bytes, path, Some(path.to_string()))?;
|
||||
@@ -438,7 +408,6 @@ 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;
|
||||
@@ -454,7 +423,6 @@ 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()
|
||||
@@ -496,7 +464,6 @@ fn save_as(s: &mut Session, cmd: &str, path: &str, opts: &SaveAs) -> Result<usiz
|
||||
fn store(path: &str, bytes: &[u8]) -> Result<()> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_write(path).map_err(|e| bad("save", e))?;
|
||||
// A file in a folder still to be made has nothing to back up.
|
||||
if is_drawing_file(path) && crate::autosave::isavebak() && crate::atomic_write::missing_folder(std::path::Path::new(path)).is_none() {
|
||||
backup(std::path::Path::new(path))
|
||||
@@ -706,9 +673,7 @@ fn backup(path: &std::path::Path) -> std::io::Result<()> {
|
||||
};
|
||||
let (head, tail, len) = ends(&mut src)?;
|
||||
let bak = backup_path(path);
|
||||
// Whether the .bak name is taken is asked without following a link there: a link leading out of
|
||||
// the roots (or to another computer) isn't looked at.
|
||||
if !backup_replaced(&head, &tail, len, std::fs::symlink_metadata(&bak).is_ok()) {
|
||||
if !backup_replaced(&head, &tail, len, bak.exists()) {
|
||||
log::warn!("save: {} doesn't look like a whole drawing; its backup is left as it was", path.display());
|
||||
return Ok(());
|
||||
}
|
||||
@@ -1055,14 +1020,46 @@ fn run_saveas_reporting(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
save_reporting(s, p, run_saveas, asked)
|
||||
}
|
||||
|
||||
/// Encode bytes with the standard padded Base64 alphabet.
|
||||
const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
pub fn base64_encode(data: &[u8]) -> String {
|
||||
craft_mime::base64::STANDARD.encode(data)
|
||||
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
|
||||
}
|
||||
|
||||
/// Decode the legacy file/control Base64 form, retaining its permissive alphabet and padding.
|
||||
pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
|
||||
craft_mime::base64_compat::decode(s).ok()
|
||||
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)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -1072,20 +1069,6 @@ mod tests {
|
||||
use crate::Session;
|
||||
use crate::temp_dir::TempDir;
|
||||
|
||||
/// Whether the `.bak` name is taken is asked without following a link there: a dangling link
|
||||
/// counts as taken, so a file that doesn't look like a drawing leaves it alone.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_link_at_the_bak_name_counts_as_a_backup_without_being_followed() {
|
||||
let dir = TempDir::new("cc-bak-link");
|
||||
let path = dir.join("plain.dxf");
|
||||
std::fs::write(&path, "just some text, not a drawing").unwrap();
|
||||
let bak = super::backup_path(&path);
|
||||
std::os::unix::fs::symlink(dir.join("nowhere"), &bak).unwrap();
|
||||
super::backup(&path).unwrap();
|
||||
assert!(std::fs::symlink_metadata(&bak).unwrap().file_type().is_symlink(), "the link is left as it was");
|
||||
}
|
||||
|
||||
/// A backup is never more open than the drawing or the old `.bak`, and loses the group bits when
|
||||
/// it would keep the old `.bak`'s group while the drawing is in another.
|
||||
#[cfg(unix)]
|
||||
|
||||
@@ -107,11 +107,9 @@ fn other_drawing(s: &Session, p: &Value) -> Result<(Arc<Drawing>, String)> {
|
||||
Ok((Arc::new(d), name))
|
||||
}
|
||||
|
||||
/// The bytes of the drawing to compare with, held to the automation roots.
|
||||
fn read_path(_path: &str) -> Result<Vec<u8>> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(_path).map_err(|e| bad("compare", e))?;
|
||||
crate::capped_read::read_capped(std::path::Path::new(_path), super::MAX_DRAWING_BYTES).map_err(|e| bad("compare", format!("{_path}: {e}")))
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
|
||||
@@ -59,12 +59,6 @@ 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 {
|
||||
@@ -128,8 +122,8 @@ pub fn alias_name(a: &str) -> std::result::Result<String, String> {
|
||||
}
|
||||
|
||||
/// The aliases of a `.pgp` file's text, and its problems.
|
||||
fn parse(text: &str) -> (BTreeMap<String, String>, Vec<String>) {
|
||||
let mut out = BTreeMap::new();
|
||||
fn parse(text: &str) -> (Vec<(String, String)>, Vec<String>) {
|
||||
let mut out: Vec<(String, String)> = Vec::new();
|
||||
let mut warnings = Vec::new();
|
||||
let mut warn = |no: usize, msg: String| {
|
||||
if warnings.len() < MAX_WARNINGS {
|
||||
@@ -165,13 +159,13 @@ fn parse(text: &str) -> (BTreeMap<String, String>, Vec<String>) {
|
||||
warn(no, format!("{}: unknown command {}; skipped", alias.trim(), target.trim()));
|
||||
continue;
|
||||
};
|
||||
// Once full, stop at the next valid definition, even if it repeats an alias.
|
||||
if out.len() >= MAX_ALIASES {
|
||||
warn(no, format!("more than {MAX_ALIASES} aliases; the rest are skipped"));
|
||||
break;
|
||||
}
|
||||
// A later definition wins without scanning all the aliases accumulated so far.
|
||||
out.insert(name, id);
|
||||
// A later line for the same alias wins, as it would when typed into the file twice.
|
||||
out.retain(|(a, _)| *a != name);
|
||||
out.push((name, id));
|
||||
}
|
||||
(out, warnings)
|
||||
}
|
||||
@@ -185,7 +179,7 @@ fn listing(warnings: &[String], added: usize) -> Value {
|
||||
fn load(text: &str, path: Option<String>) -> (usize, Vec<String>) {
|
||||
let (aliases, warnings) = parse(text);
|
||||
let mut st = store();
|
||||
st.map = aliases;
|
||||
st.map = aliases.into_iter().collect();
|
||||
if path.is_some() {
|
||||
st.file = path;
|
||||
}
|
||||
|
||||
@@ -73,13 +73,10 @@ fn read_template(path: &str) -> Result<Drawing> {
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
/// The bytes of the template at `path`, once the automation roots allow reading it.
|
||||
fn read_bytes(path: &str) -> Result<Vec<u8>> {
|
||||
crate::file_access::check_read(path).map_err(|e| bad("new", e))?;
|
||||
crate::capped_read::read_capped(std::path::Path::new(path), super::MAX_DRAWING_BYTES).map_err(|e| bad("new", format!("template {path}: {e}")))
|
||||
}
|
||||
|
||||
/// The bytes of the template at `path`, held to the automation roots.
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn read_bytes(path: &str) -> Result<Vec<u8>> {
|
||||
Err(bad("new", format!("template {path}: paths are not available on the web")))
|
||||
|
||||
@@ -44,7 +44,7 @@ pub(crate) struct GripEdit {
|
||||
/// Typed `GRIP`: still collecting grips ("Select grips").
|
||||
picking: bool,
|
||||
/// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the objects of the
|
||||
/// selection that the view being edited shows.
|
||||
/// selection that the drawing shows.
|
||||
targets: Vec<Handle>,
|
||||
base: Vec2,
|
||||
mode: GripMode,
|
||||
@@ -70,11 +70,10 @@ 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.
|
||||
/// Whether the drawing shows `h`. A hidden object (HIDEOBJECTS, an off or frozen layer) 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)))
|
||||
s.doc().is_ok_and(|d| d.entity(h).is_some_and(|e| d.is_visible(e)))
|
||||
}
|
||||
|
||||
impl GripEdit {
|
||||
@@ -96,8 +95,7 @@ impl GripEdit {
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// the drawing 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(());
|
||||
@@ -121,13 +119,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(st) = s.state() else { return Vec::new() };
|
||||
let Ok(d) = s.doc() 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) = st.doc.entity(h).filter(|e| st.shows(e)) else { continue };
|
||||
let Some(e) = d.entity(h).filter(|e| d.is_visible(e)) else { continue };
|
||||
let gs = e.kind.grips();
|
||||
// The nearest grip of this object within the tolerance.
|
||||
let best = gs
|
||||
@@ -485,8 +483,8 @@ 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. 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.
|
||||
/// drawing 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();
|
||||
|
||||
@@ -28,8 +28,7 @@ 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, and inside an MSPACE viewport not on a layer frozen in it), when PICKSTYLE
|
||||
/// has group selection on. Order: `hs` first.
|
||||
/// edited, visible), 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;
|
||||
@@ -40,7 +39,6 @@ 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) {
|
||||
@@ -58,7 +56,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| crate::select::selectable(d, e, frozen)) && seen.insert(*m) {
|
||||
if store.get(*m).is_some_and(|e| d.is_visible(e)) && seen.insert(*m) {
|
||||
out.push(*m);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
//! 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};
|
||||
@@ -11,7 +10,6 @@ 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};
|
||||
@@ -29,12 +27,7 @@ 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?}")
|
||||
// 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("region", "Region", run_region).menu(&["Draw", "Region"]).alias(&["reg"]).params("{handles?}"),
|
||||
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")
|
||||
@@ -540,19 +533,6 @@ 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"];
|
||||
|
||||
@@ -617,7 +597,7 @@ impl HatchM {
|
||||
Some(n) => n,
|
||||
None => t.trim().to_ascii_uppercase(),
|
||||
};
|
||||
if pattern_exists(&up) {
|
||||
if cadcraft_doc::library::pattern(&up).is_some() || patfile::user_pattern(&up).is_some() {
|
||||
self.settings.pattern = up.clone();
|
||||
s.doc_mut()?.header.set_str("HPNAME", &up);
|
||||
} else {
|
||||
|
||||
@@ -143,8 +143,21 @@ 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") {
|
||||
set_pattern(h, v);
|
||||
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(x) = p.get("scale").and_then(Value::as_f64).filter(|x| x.is_finite() && *x > 0.0) {
|
||||
h.scale = x;
|
||||
@@ -154,43 +167,6 @@ 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>,
|
||||
@@ -413,7 +389,9 @@ 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())
|
||||
&& !defined_pattern(&up)
|
||||
&& up != "SOLID"
|
||||
&& cadcraft_doc::library::pattern(&up).is_none()
|
||||
&& super::patfile::user_pattern(&up).is_none()
|
||||
{
|
||||
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,13 +28,6 @@ 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> {
|
||||
|
||||
@@ -115,10 +115,8 @@ pub fn support_text(cmd: &str, p: &serde_json::Value, path_key: &str, text_key:
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
/// The text of the support file at `path`, once the automation roots allow reading it, up to the size limit.
|
||||
fn read_support_file(cmd: &str, path: &str) -> crate::Result<String> {
|
||||
use std::io::Read;
|
||||
crate::file_access::check_read(path).map_err(|e| super::bad(cmd, e))?;
|
||||
let f = std::fs::File::open(path).map_err(|e| super::bad(cmd, format!("{path}: {e}")))?;
|
||||
let mut bytes = Vec::new();
|
||||
f.take(MAX_SUPPORT_FILE_BYTES + 1).read_to_end(&mut bytes).map_err(|e| super::bad(cmd, format!("{path}: {e}")))?;
|
||||
@@ -128,7 +126,6 @@ fn read_support_file(cmd: &str, path: &str) -> crate::Result<String> {
|
||||
Ok(String::from_utf8_lossy(&bytes).into_owned())
|
||||
}
|
||||
|
||||
/// The text of a support file (a linetype or hatch pattern file, say), size-limited and held to the automation roots.
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn read_support_file(cmd: &str, _path: &str) -> crate::Result<String> {
|
||||
Err(super::bad(cmd, "paths are not available on the web; pass the file's contents"))
|
||||
|
||||
@@ -18,13 +18,8 @@ use crate::{Result, Session};
|
||||
/// Most image files loaded per drawing.
|
||||
const MAX_IMAGE_FILES: usize = 1000;
|
||||
/// Largest image file read (bytes).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const MAX_IMAGE_BYTES: u64 = 256 << 20;
|
||||
/// Longest base64 text taken for `data`: what a file of [`MAX_IMAGE_BYTES`] encodes to.
|
||||
const MAX_IMAGE_BASE64: u64 = MAX_IMAGE_BYTES.div_ceil(3) * 4;
|
||||
/// Longest `data` text with the line breaks and spaces base64 may carry (MIME breaks every 76
|
||||
/// characters, under 3% more): the characters past [`MAX_IMAGE_BASE64`] are counted only up to
|
||||
/// here, which also bounds what decoding sets aside.
|
||||
const MAX_IMAGE_TEXT: u64 = MAX_IMAGE_BASE64 + MAX_IMAGE_BASE64 / 16;
|
||||
/// Most decoded pixel bytes kept per drawing; images past it stay unloaded.
|
||||
const MAX_LOADED_BYTES: u64 = 2 << 30;
|
||||
/// Most image files decoded at the same time when a drawing opens.
|
||||
@@ -75,23 +70,11 @@ fn paths(d: &Drawing) -> Vec<String> {
|
||||
paths
|
||||
}
|
||||
|
||||
/// Whether `path` is a full path here, or on Windows where a drawing may have been written (a
|
||||
/// drive, `C:\maps\a.png`, or a share, `\\server\maps`), which other systems read as relative.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn full_path(path: &str) -> bool {
|
||||
let b = path.trim().as_bytes();
|
||||
std::path::Path::new(path.trim()).is_absolute() || b.starts_with(b"\\\\") || matches!(b, [d, b':', b'\\' | b'/', ..] if d.is_ascii_alphabetic())
|
||||
}
|
||||
|
||||
/// The contents of the image file saved as `path` in a drawing at `host`.
|
||||
fn read_file(path: &str, host: Option<&str>) -> std::result::Result<Vec<u8>, String> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
let file = super::blocks::xref::find_file(path, host).ok_or_else(|| {
|
||||
// An unsaved drawing has no folder for a relative path to be relative to.
|
||||
if host.is_none() && !full_path(path) { "file not found (save the drawing first, or give a full path)" } else { "file not found" }
|
||||
})?;
|
||||
crate::file_access::check_read(&file)?;
|
||||
let file = super::blocks::xref::find_file(path, host).ok_or("file not found")?;
|
||||
let len = std::fs::metadata(&file).map_err(|e| e.to_string())?.len();
|
||||
if len > MAX_IMAGE_BYTES {
|
||||
return Err(format!("the file is larger than {} MB", MAX_IMAGE_BYTES >> 20));
|
||||
@@ -197,18 +180,14 @@ fn decode_files(paths: &[&str], host: Option<&str>) -> Vec<std::result::Result<R
|
||||
if loaders > 1 {
|
||||
// Each loader takes the next file nobody has started.
|
||||
let next = AtomicUsize::new(0);
|
||||
// The automation roots are per thread, so they go along with each loader.
|
||||
let roots = crate::file_access::current();
|
||||
let work = || {
|
||||
crate::file_access::confine(roots.as_ref(), || {
|
||||
let mut done = Vec::new();
|
||||
loop {
|
||||
let index = next.fetch_add(1, Ordering::Relaxed);
|
||||
let Some(path) = paths.get(index) else { break };
|
||||
done.push((index, load(path)));
|
||||
}
|
||||
done
|
||||
})
|
||||
let mut done = Vec::new();
|
||||
loop {
|
||||
let index = next.fetch_add(1, Ordering::Relaxed);
|
||||
let Some(path) = paths.get(index) else { break };
|
||||
done.push((index, load(path)));
|
||||
}
|
||||
done
|
||||
};
|
||||
let finished: Vec<_> = std::thread::scope(|scope| {
|
||||
let started: Vec<_> = (0..loaders).filter_map(|_| std::thread::Builder::new().spawn_scoped(scope, work).ok()).collect();
|
||||
@@ -325,19 +304,7 @@ fn pixels(s: &Session, p: &Value, path: &str) -> Result<Arc<Raster>> {
|
||||
let bytes = match p.get("data") {
|
||||
Some(data) => {
|
||||
let text = data.as_str().ok_or_else(|| bad(ID, "`data` must be base64 text"))?;
|
||||
// Refused before decoding, which would hold all of it in memory. Line breaks and
|
||||
// spaces, which decoding skips, don't count.
|
||||
let len = u64::try_from(text.len()).unwrap_or(u64::MAX);
|
||||
let digits = || u64::try_from(text.bytes().filter(|b| !matches!(b, b'\n' | b'\r' | b' ')).count()).unwrap_or(u64::MAX);
|
||||
if len > MAX_IMAGE_TEXT || (len > MAX_IMAGE_BASE64 && digits() > MAX_IMAGE_BASE64) {
|
||||
return Err(bad(ID, format!("`data` is larger than {} MB", MAX_IMAGE_BYTES >> 20)));
|
||||
}
|
||||
let bytes = base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?;
|
||||
// The longest text allowed can still hold a byte or two more than the limit.
|
||||
if u64::try_from(bytes.len()).unwrap_or(u64::MAX) > MAX_IMAGE_BYTES {
|
||||
return Err(bad(ID, format!("`data` is larger than {} MB", MAX_IMAGE_BYTES >> 20)));
|
||||
}
|
||||
bytes
|
||||
base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?
|
||||
}
|
||||
None => {
|
||||
if let Some(loaded) = s.doc()?.rasters.get(path) {
|
||||
|
||||
@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("dist", "Distance", run_dist)
|
||||
.menu(&["Tools", "Inquiry", "Distance"])
|
||||
.alias(&["di"])
|
||||
.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}")
|
||||
.params("{p1, p2}")
|
||||
.noundo()
|
||||
.transparent()
|
||||
.interactive(|_| Ok(Box::new(DistM::default()))),
|
||||
@@ -56,7 +56,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("usage", "Analyze Usage", usage::run).params(usage::PARAMS).noundo(),
|
||||
CommandSpec::new("loops", "Implied Loops", loops::run).params(loops::PARAMS).noundo(),
|
||||
CommandSpec::new("texts", "Query Texts", run_texts)
|
||||
.params("{contains?: text (any case; `query` is the same filter), layer?, window?: [[x,y],[x,y]] (by insertion point), limit? (default 200), offset?} → {count (all matches), returned, offset, texts: [{handle, type, layer, text, at, height, rotation (degrees), style, tag? (attributes)}]}: the readable text of TEXT, MTEXT (formatting removed), block attributes and multileaders")
|
||||
.params("{contains?: text (any case), layer?, window?: [[x,y],[x,y]] (by insertion point), limit? (default 200), offset?} → {count (all matches), returned, offset, texts: [{handle, type, layer, text, at, height, rotation (degrees), style, tag? (attributes)}]}: the readable text of TEXT, MTEXT (formatting removed), block attributes and multileaders")
|
||||
.noundo(),
|
||||
CommandSpec::new("countlist", "Count List", count::run_countlist)
|
||||
.params("{space?: all (default)|current|model|<layout>, nested?: bool} → per-block counts, as COUNT")
|
||||
@@ -192,21 +192,11 @@ fn angle_from_xy(d: Vec3) -> f64 {
|
||||
d.z.atan2(d.xy().len())
|
||||
}
|
||||
|
||||
/// 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();
|
||||
// The difference turned onto the axes: converting each point first would subtract a far
|
||||
// origin and round a short distance away.
|
||||
fn dist_text(s: &Session, a: Vec3, b: Vec3) -> String {
|
||||
let d = b - a;
|
||||
Vec3::new(d.dot(u.x), d.dot(u.y), d.dot(u.z()))
|
||||
}
|
||||
|
||||
/// 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, dist),
|
||||
fmt_d(s, (b - a).len()),
|
||||
fmt_a(s, d.xy().angle()),
|
||||
fmt_a(s, angle_from_xy(d)),
|
||||
fmt_d(s, d.x),
|
||||
@@ -232,8 +222,6 @@ 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(),
|
||||
@@ -241,28 +229,18 @@ fn run_dist(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
"dx": d.x,
|
||||
"dy": d.y,
|
||||
"dz": d.z,
|
||||
"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),
|
||||
"message": dist_text(s, a, b),
|
||||
}))
|
||||
}
|
||||
|
||||
/// ID's report: the point in the current UCS.
|
||||
fn id_text(s: &Session, a: Vec3) -> String {
|
||||
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))
|
||||
format!("X = {} Y = {} Z = {}", fmt_d(s, a.x), fmt_d(s, a.y), fmt_d(s, a.z))
|
||||
}
|
||||
|
||||
fn run_id(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let a = point3_req(s, "id", p, "at")?;
|
||||
s.last_point = a.xy();
|
||||
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) }))
|
||||
Ok(json!({ "x": a.x, "y": a.y, "z": a.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
|
||||
@@ -613,7 +591,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.shown_selection().iter().map(|h| h.hex()).collect::<Vec<_>>(),
|
||||
"selection": st.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.
|
||||
@@ -686,12 +664,7 @@ fn run_texts(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
v.as_u64().map(|n| usize::try_from(n).unwrap_or(usize::MAX)).ok_or_else(|| bad(CMD, format!("`{k}` must be a whole number, 0 or more")))
|
||||
})
|
||||
};
|
||||
// `query` is what agents tend to call the filter; without this alias it was silently ignored
|
||||
// and every text came back (#3011).
|
||||
let contains = match text("contains")? {
|
||||
Some(c) => Some(c),
|
||||
None => text("query")?,
|
||||
};
|
||||
let contains = text("contains")?;
|
||||
let layer = text("layer")?;
|
||||
let window = given("window")
|
||||
.map(|w| {
|
||||
@@ -927,7 +900,7 @@ impl Interactive for DistM {
|
||||
s.last_point = first;
|
||||
return Err(bad("dist", "the distance is too large"));
|
||||
}
|
||||
let t = dist_text(s, (b - a).len(), dist_delta(s, a, b));
|
||||
let t = dist_text(s, a, b);
|
||||
for l in t.lines() {
|
||||
s.echo(l.to_string());
|
||||
}
|
||||
|
||||
@@ -1,134 +0,0 @@
|
||||
//! MENUBAR and TOOLBAR: show or hide the window's menu bar and tool bar from the command line, as
|
||||
//! in AutoCAD. With the menu bar hidden on Windows and Linux (where it is the only menu), typing
|
||||
//! these is the way back.
|
||||
//!
|
||||
//! The UI owns the bars: it reports what it shows in [`Session::bars_shown`] and applies
|
||||
//! [`Session::bars_request`], which these commands set.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::{CommandSpec, always, bad};
|
||||
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
/// The interface bars MENUBAR and TOOLBAR control.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct InterfaceBars {
|
||||
pub menubar: bool,
|
||||
pub toolbar: bool,
|
||||
}
|
||||
|
||||
impl Default for InterfaceBars {
|
||||
fn default() -> Self {
|
||||
InterfaceBars { menubar: true, toolbar: true }
|
||||
}
|
||||
}
|
||||
|
||||
/// A change MENUBAR or TOOLBAR asked for: only the bars a command set, so the UI leaves the other
|
||||
/// as it is (it may have been changed since).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub struct BarsRequest {
|
||||
pub menubar: Option<bool>,
|
||||
pub toolbar: Option<bool>,
|
||||
}
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
CommandSpec::new("menubar", "Menu Bar", run_menubar)
|
||||
.params("{value?: 0|1} (1 shows the in-window menu bar, 0 hides it; without it, reports it)")
|
||||
.enabled(always)
|
||||
.noundo()
|
||||
.interactive(|s| Ok(Box::new(MenubarM { current: s.bars_shown.menubar }))),
|
||||
CommandSpec::new("toolbar", "Tool Bar", run_toolbar)
|
||||
.alias(&["-toolbar"])
|
||||
.params("{show?: bool} (without it, reports it)")
|
||||
.enabled(always)
|
||||
.noundo()
|
||||
.interactive(|_| Ok(Box::new(ToolbarM))),
|
||||
]
|
||||
}
|
||||
|
||||
fn set_menubar(s: &mut Session, on: bool) {
|
||||
s.bars_shown.menubar = on;
|
||||
s.bars_request.menubar = Some(on);
|
||||
}
|
||||
|
||||
fn set_toolbar(s: &mut Session, show: bool) {
|
||||
s.bars_shown.toolbar = show;
|
||||
s.bars_request.toolbar = Some(show);
|
||||
}
|
||||
|
||||
fn run_menubar(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let v = match p.get("value") {
|
||||
None | Some(Value::Null) => return Ok(json!({ "value": u8::from(s.bars_shown.menubar) })),
|
||||
Some(v) => v
|
||||
.as_u64()
|
||||
.or_else(|| v.as_str().and_then(|t| t.trim().parse().ok()))
|
||||
.filter(|v| *v <= 1)
|
||||
.ok_or_else(|| bad("menubar", "`value` must be 0 or 1"))?,
|
||||
};
|
||||
set_menubar(s, v == 1);
|
||||
Ok(json!({ "value": v }))
|
||||
}
|
||||
|
||||
fn run_toolbar(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let Some(show) = p.get("show").filter(|v| !v.is_null()) else { return Ok(json!({ "show": s.bars_shown.toolbar })) };
|
||||
let show = show.as_bool().ok_or_else(|| bad("toolbar", "`show` must be true or false"))?;
|
||||
set_toolbar(s, show);
|
||||
Ok(json!({ "show": show }))
|
||||
}
|
||||
|
||||
/// Typed MENUBAR: "Enter new value for MENUBAR <1>:".
|
||||
struct MenubarM {
|
||||
current: bool,
|
||||
}
|
||||
|
||||
impl Interactive for MenubarM {
|
||||
fn name(&self) -> &'static str {
|
||||
"MENUBAR"
|
||||
}
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
Prompt::new("Enter new value for MENUBAR", Accept::NUMBER).default(u8::from(self.current).to_string())
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
match i {
|
||||
Input::Enter => Ok(Step::Done),
|
||||
Input::Text(t) => match run_menubar(s, &json!({ "value": t })) {
|
||||
Ok(_) => Ok(Step::Done),
|
||||
Err(_) => {
|
||||
s.echo("Requires 0 or 1.");
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
},
|
||||
_ => Ok(Step::Continue),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Typed TOOLBAR: "Enter tool bar option [Show/Hide] <Show>:" (CADCraft has one tool bar).
|
||||
struct ToolbarM;
|
||||
|
||||
impl Interactive for ToolbarM {
|
||||
fn name(&self) -> &'static str {
|
||||
"TOOLBAR"
|
||||
}
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
Prompt::new("Enter tool bar option", Accept::TEXT).kw(&["Show", "Hide"]).default("Show")
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
let word = match &i {
|
||||
Input::Enter => "show".to_string(),
|
||||
Input::Keyword(k) | Input::Text(k) => k.trim().to_ascii_lowercase(),
|
||||
_ => return Ok(Step::Continue),
|
||||
};
|
||||
let show = if !word.is_empty() && "show".starts_with(&word) {
|
||||
true
|
||||
} else if !word.is_empty() && "hide".starts_with(&word) {
|
||||
false
|
||||
} else {
|
||||
s.echo("Invalid option keyword.");
|
||||
return Ok(Step::Continue);
|
||||
};
|
||||
run_toolbar(s, &json!({ "show": show }))?;
|
||||
Ok(Step::Done)
|
||||
}
|
||||
}
|
||||
+16
-250
@@ -1,7 +1,6 @@
|
||||
//! Layers: LAYER (programmatic sub-ids, -LAYER prompts), layer tools (LAYMCUR, LAYISO, LAYOFF, LAYFRZ…).
|
||||
|
||||
mod prompts;
|
||||
mod state_prompts;
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{Layer, Lineweight};
|
||||
@@ -56,9 +55,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("layon", "Turn All Layers On", |s, _| all_layers(s, |l| l.on = true)),
|
||||
CommandSpec::new("laythw", "Thaw All Layers", |s, _| all_layers(s, |l| l.frozen = false)),
|
||||
CommandSpec::new("layerp", "Previous Layer", run_layerp).menu(&["Format", "Layer Tools", "Previous Layer"]),
|
||||
CommandSpec::new("layerstate.save", "Save Layer State", run_state_save)
|
||||
.menu(&["Format", "Layer States Manager..."])
|
||||
.params("{name, mask? (properties restoring sets: 1 on, 2 frozen, 4 locked, 8 plot, 16 new viewport freeze, 32 color, 64 linetype, 128 lineweight, 256 plot style, 1024 transparency; default all)}"),
|
||||
CommandSpec::new("layerstate.save", "Save Layer State", run_state_save).menu(&["Format", "Layer States Manager..."]).params("{name}"),
|
||||
CommandSpec::new("layerstate.restore", "Restore Layer State", run_state_restore).params("{name}"),
|
||||
CommandSpec::new("layerstate.list", "List Layer States", run_state_list).params("{} → states").noundo(),
|
||||
CommandSpec::new("layerstate.delete", "Delete Layer State", run_state_delete).params("{name}"),
|
||||
@@ -109,10 +106,6 @@ 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
|
||||
}
|
||||
@@ -403,108 +396,31 @@ fn all_layers(s: &mut Session, f: fn(&mut Layer)) -> Result<Value> {
|
||||
}
|
||||
|
||||
fn run_state_save(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
use cadcraft_doc::LayerState as S;
|
||||
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.save", "`name` is required"))?.to_string();
|
||||
// As -LAYER stAte Save and layerstate.rename take names: none empty, over 255 characters, with a
|
||||
// control character or with one AutoCAD 2024 refuses (measured for Save).
|
||||
if !valid_name(&name) {
|
||||
return Err(bad("layerstate.save", "invalid name"));
|
||||
}
|
||||
// The properties restoring sets; bit 512, which no property toggles, is always set, as AutoCAD
|
||||
// 2024 saves it (measured: On alone is 513).
|
||||
let mask = match p.get("mask") {
|
||||
None | Some(Value::Null) => S::ALL,
|
||||
Some(v) => {
|
||||
let m = v.as_u64().filter(|m| m & !u64::from(S::ALL) == 0);
|
||||
m.and_then(|m| u32::try_from(m).ok()).ok_or_else(|| bad("layerstate.save", "`mask` must be a sum of layer state bits (0 to 2047)"))? | 512
|
||||
}
|
||||
};
|
||||
let d = s.doc_mut()?;
|
||||
let layers = d.layers.clone();
|
||||
let current = d.header.str("CLAYER", "0");
|
||||
// Replace the state Restore and Delete reach (the same spelling, else another case), so a
|
||||
// drawing keeps one state per name: AutoCAD 2024 finds states without regard to case. Its
|
||||
// -LAYER stAte Save and layerstate-save refuse `s1` after `S1` (measured), as the command line
|
||||
// here does; this command replaces, as it does a state of the same spelling. When a file holds
|
||||
// both `S1` and `s1`, only the one spelled so is replaced.
|
||||
if let Some(i) = state_index(d, &name) {
|
||||
d.layer_states.remove(i);
|
||||
}
|
||||
d.layer_states.push(S { mask, ..S::new(name, layers, current) });
|
||||
d.layer_states.retain(|st| st.name != name);
|
||||
d.layer_states.push(cadcraft_doc::LayerState { name, layers });
|
||||
ok()
|
||||
}
|
||||
|
||||
/// The saved state called `name`: the one spelled so, else the first whose name differs only in
|
||||
/// case. AutoCAD 2024 finds layer states without regard to case (measured: Restore, Edit, Name
|
||||
/// and Delete of `s1` reach `S1`); case is compared as for layers and view snapshots.
|
||||
pub(super) fn state_index(d: &cadcraft_doc::Drawing, name: &str) -> Option<usize> {
|
||||
d.layer_states.iter().position(|st| st.name == name).or_else(|| d.layer_states.iter().position(|st| st.name.eq_ignore_ascii_case(name)))
|
||||
}
|
||||
|
||||
fn run_state_restore(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.restore", "`name` is required"))?;
|
||||
let d = s.doc_mut()?;
|
||||
let st = state_index(d, name).and_then(|i| d.layer_states.get(i)).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
|
||||
restore_state(d, &st);
|
||||
let st = d.layer_states.iter().find(|st| st.name == name).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
|
||||
restore_layers(d, st.layers);
|
||||
ok()
|
||||
}
|
||||
|
||||
/// Restore a saved layer state as AutoCAD 2024 does (measured): first the current layer it
|
||||
/// names, when the drawing has it and the restore doesn't leave it frozen, then on each drawing
|
||||
/// layer the state names (without regard to case) the properties its mask covers. The current
|
||||
/// layer is never frozen; other properties (descriptions, names) stay as they are.
|
||||
pub(crate) fn restore_state(d: &mut cadcraft_doc::Drawing, st: &cadcraft_doc::LayerState) {
|
||||
use cadcraft_doc::LayerState as S;
|
||||
// A frozen layer only thaws with Frozen in the mask and an entry of its own: without one
|
||||
// AutoCAD 2024 keeps the current layer (measured).
|
||||
let thaws = |l: &Layer| st.mask & S::FROZEN != 0 && st.layers.iter().any(|saved| saved.name.eq_ignore_ascii_case(&l.name));
|
||||
if let Some(l) = d.layer(&st.current).filter(|l| !l.frozen || thaws(l)) {
|
||||
let name = l.name.clone();
|
||||
d.header.set_str("CLAYER", &name);
|
||||
}
|
||||
let current = d.header.str("CLAYER", "0");
|
||||
let index = layer_index(d);
|
||||
let has = |bit: u32| st.mask & bit != 0;
|
||||
for saved in &st.layers {
|
||||
let Some(l) = index.get(&saved.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) else { continue };
|
||||
if has(S::ON) {
|
||||
l.on = saved.on;
|
||||
}
|
||||
if has(S::FROZEN) {
|
||||
l.frozen = saved.frozen && !l.name.eq_ignore_ascii_case(¤t);
|
||||
}
|
||||
if has(S::LOCKED) {
|
||||
l.locked = saved.locked;
|
||||
}
|
||||
if has(S::PLOT) {
|
||||
l.plot = saved.plot;
|
||||
}
|
||||
if has(S::VP_FREEZE_NEW) {
|
||||
l.vp_freeze_new = saved.vp_freeze_new;
|
||||
}
|
||||
if has(S::COLOR) {
|
||||
l.color = saved.color;
|
||||
}
|
||||
if has(S::LINETYPE) {
|
||||
l.linetype.clone_from(&saved.linetype);
|
||||
}
|
||||
if has(S::LINEWEIGHT) {
|
||||
l.lineweight = saved.lineweight;
|
||||
}
|
||||
if has(S::PLOT_STYLE) {
|
||||
l.plot_style.clone_from(&saved.plot_style);
|
||||
}
|
||||
if has(S::TRANSPARENCY) {
|
||||
l.transparency = saved.transparency;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Put the saved layers back over the drawing's layers of the same name (without regard to case);
|
||||
/// saved layers the drawing no longer has are skipped. Both lists can come from a file, so the
|
||||
/// drawing's layers are looked up in an index rather than scanned per saved layer.
|
||||
pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
|
||||
let index = layer_index(d);
|
||||
let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::with_capacity(d.layers.len());
|
||||
for (i, l) in d.layers.iter().enumerate() {
|
||||
// The first of names that differ only in case, as `Drawing::layer_mut` finds it.
|
||||
index.entry(l.name.to_ascii_lowercase()).or_insert(i);
|
||||
}
|
||||
for layer in saved {
|
||||
if let Some(l) = index.get(&layer.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) {
|
||||
*l = layer;
|
||||
@@ -512,16 +428,6 @@ pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The drawing's layers by lower-case name: the first of names that differ only in case, as
|
||||
/// `Drawing::layer_mut` finds it.
|
||||
fn layer_index(d: &cadcraft_doc::Drawing) -> std::collections::HashMap<String, usize> {
|
||||
let mut index = std::collections::HashMap::with_capacity(d.layers.len());
|
||||
for (i, l) in d.layers.iter().enumerate() {
|
||||
index.entry(l.name.to_ascii_lowercase()).or_insert(i);
|
||||
}
|
||||
index
|
||||
}
|
||||
|
||||
fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
let d = s.doc()?;
|
||||
let states: Vec<Value> = d.layer_states.iter().map(|st| json!({ "name": st.name, "layers": st.layers.len() })).collect();
|
||||
@@ -536,8 +442,10 @@ fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
fn run_state_delete(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.delete", "`name` is required"))?;
|
||||
let d = s.doc_mut()?;
|
||||
let i = state_index(d, name).ok_or_else(|| bad("layerstate.delete", "no such layer state"))?;
|
||||
d.layer_states.remove(i);
|
||||
if !d.layer_states.iter().any(|st| st.name == name) {
|
||||
return Err(bad("layerstate.delete", "no such layer state"));
|
||||
}
|
||||
d.layer_states.retain(|st| st.name != name);
|
||||
ok()
|
||||
}
|
||||
|
||||
@@ -548,12 +456,10 @@ fn run_state_rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
return Err(bad("layerstate.rename", "invalid name"));
|
||||
}
|
||||
let d = s.doc_mut()?;
|
||||
// A name in another case counts, the state's own too (AutoCAD 2024 refuses `S1` to `s1`,
|
||||
// measured).
|
||||
if d.layer_states.iter().any(|st| st.name.eq_ignore_ascii_case(&to)) {
|
||||
if d.layer_states.iter().any(|st| st.name == to) {
|
||||
return Err(bad("layerstate.rename", format!("layer state `{to}` already exists")));
|
||||
}
|
||||
let st = state_index(d, from).and_then(|i| d.layer_states.get_mut(i)).ok_or_else(|| bad("layerstate.rename", "no such layer state"))?;
|
||||
let st = d.layer_states.iter_mut().find(|st| st.name == from).ok_or_else(|| bad("layerstate.rename", "no such layer state"))?;
|
||||
st.name = to;
|
||||
ok()
|
||||
}
|
||||
@@ -606,146 +512,6 @@ mod tests {
|
||||
assert!(used.contains(&true) && used.contains(&false));
|
||||
}
|
||||
|
||||
/// Restoring follows AutoCAD 2024 (measured with -LAYER stAte and states written into a DXF):
|
||||
/// the current layer first, then only the properties the mask covers; the current layer stays
|
||||
/// thawed; a current layer that is empty or gone leaves the current layer as it is.
|
||||
#[test]
|
||||
fn layer_state_restore_follows_the_mask_and_current_layer() {
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::LayerState;
|
||||
let mut s = Session::new();
|
||||
s.execute("layer.new", &json!({ "name": "A", "color": 1, "current": true })).unwrap();
|
||||
s.execute("layer.new", &json!({ "name": "B" })).unwrap();
|
||||
s.execute("layerstate.save", &json!({ "name": "all" })).unwrap();
|
||||
let saved = s.doc().unwrap().layer_states[0].clone();
|
||||
assert_eq!((saved.mask, saved.current.as_str()), (LayerState::ALL, "A"));
|
||||
// Only On: A's colour stays green, B comes back on (AutoCAD's S7, mask 513).
|
||||
let d = s.doc_mut().unwrap();
|
||||
d.layer_states.push(LayerState { name: "on".into(), mask: LayerState::ON | 512, ..saved.clone() });
|
||||
s.execute("layer.set", &json!({ "name": "A", "color": 3 })).unwrap();
|
||||
s.execute("layer.set", &json!({ "name": "B", "on": false, "locked": true })).unwrap();
|
||||
s.execute("layer.current", &json!({ "name": "B" })).unwrap();
|
||||
s.execute("layerstate.restore", &json!({ "name": "on" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "A");
|
||||
let (a, b) = (d.layer("A").unwrap(), d.layer("B").unwrap());
|
||||
assert_eq!((a.color, b.on, b.locked), (Color::Index(3), true, true));
|
||||
// Every property.
|
||||
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!((d.layer("A").unwrap().color, d.layer("B").unwrap().locked), (Color::Index(1), false));
|
||||
// A state that freezes B with no current layer of its own (or one that is gone), restored
|
||||
// with B current: B stays current and thawed; A is turned off.
|
||||
for current in ["", "NOSUCH"] {
|
||||
let mut frozen = s.doc().unwrap().layers.clone();
|
||||
for l in &mut frozen {
|
||||
l.frozen = l.name == "B";
|
||||
l.on = l.name != "A";
|
||||
}
|
||||
s.doc_mut().unwrap().layer_states.push(LayerState::new(format!("f{current}"), frozen.clone(), current));
|
||||
s.execute("layer.current", &json!({ "name": "B" })).unwrap();
|
||||
s.execute("layerstate.restore", &json!({ "name": format!("f{current}") })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "B", "{current:?}");
|
||||
assert!(!d.layer("B").unwrap().frozen && !d.layer("A").unwrap().on, "{current:?}");
|
||||
// Naming A current, it becomes current and B freezes.
|
||||
s.doc_mut().unwrap().layer_states.push(LayerState::new("fA", frozen, "A"));
|
||||
s.execute("layerstate.restore", &json!({ "name": "fA" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "A");
|
||||
assert!(d.layer("B").unwrap().frozen);
|
||||
s.doc_mut().unwrap().layer_states.retain(|st| st.name != "fA");
|
||||
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
|
||||
}
|
||||
// A current layer the state's mask leaves frozen doesn't become current (AutoCAD's S9: On
|
||||
// only, current B; restored with A current and B frozen).
|
||||
let mut on_only = s.doc().unwrap().layer_states[0].clone();
|
||||
(on_only.name, on_only.mask, on_only.current) = ("S9".into(), LayerState::ON | 512, "B".into());
|
||||
s.doc_mut().unwrap().layer_states.push(on_only);
|
||||
s.execute("layer.current", &json!({ "name": "A" })).unwrap();
|
||||
s.execute("layer.set", &json!({ "name": "B", "frozen": true })).unwrap();
|
||||
s.execute("layerstate.restore", &json!({ "name": "S9" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "A");
|
||||
assert!(d.layer("B").unwrap().frozen);
|
||||
// With Frozen in the mask B is thawed and made current.
|
||||
let mut thaw = s.doc().unwrap().layer_states[0].clone();
|
||||
(thaw.name, thaw.current) = ("thaw".into(), "B".into());
|
||||
s.doc_mut().unwrap().layer_states.push(thaw);
|
||||
s.execute("layerstate.restore", &json!({ "name": "thaw" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "B");
|
||||
assert!(!d.layer("B").unwrap().frozen);
|
||||
// Frozen in the mask, but no entry for B (a state written elsewhere): nothing would thaw
|
||||
// B, so A stays current and B frozen (AutoCAD 2024, measured).
|
||||
let mut no_entry = s.doc().unwrap().layer_states[0].clone();
|
||||
(no_entry.name, no_entry.current) = ("no entry".into(), "B".into());
|
||||
no_entry.layers.retain(|l| l.name != "B");
|
||||
s.doc_mut().unwrap().layer_states.push(no_entry);
|
||||
s.execute("layer.current", &json!({ "name": "A" })).unwrap();
|
||||
s.execute("layer.set", &json!({ "name": "B", "frozen": true })).unwrap();
|
||||
s.execute("layerstate.restore", &json!({ "name": "no entry" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "A");
|
||||
assert!(d.layer("B").unwrap().frozen);
|
||||
// An entry spelled in another case is B's (layer names ignore case, as the restore of the
|
||||
// properties does): B is thawed and made current.
|
||||
let mut other_case = s.doc().unwrap().layer_states[0].clone();
|
||||
(other_case.name, other_case.current) = ("other case".into(), "B".into());
|
||||
for l in other_case.layers.iter_mut().filter(|l| l.name == "B") {
|
||||
l.name = "b".into();
|
||||
}
|
||||
s.doc_mut().unwrap().layer_states.push(other_case);
|
||||
s.execute("layerstate.restore", &json!({ "name": "other case" })).unwrap();
|
||||
let d = s.doc().unwrap();
|
||||
assert_eq!(d.header.str("CLAYER", ""), "B");
|
||||
assert!(!d.layer("B").unwrap().frozen);
|
||||
// What a state doesn't hold stays: the description.
|
||||
s.execute("layer.set", &json!({ "name": "A", "description": "kept" })).unwrap();
|
||||
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layer("A").unwrap().description, "kept");
|
||||
}
|
||||
|
||||
/// Plotting, freezing in new viewports, linetype, lineweight, plot style and transparency each
|
||||
/// come back under their own mask bit only: a state of one bit restores that property and
|
||||
/// leaves the other five as they are.
|
||||
#[test]
|
||||
fn layer_state_restores_each_property_under_its_own_bit_only() {
|
||||
use cadcraft_doc::{Drawing, LayerState as S, Lineweight};
|
||||
let mut s = Session::new();
|
||||
s.execute("layer.new", &json!({ "name": "A" })).unwrap();
|
||||
s.execute("layerstate.save", &json!({ "name": "all" })).unwrap();
|
||||
let saved = s.doc().unwrap().layer_states[0].clone();
|
||||
let props = |d: &Drawing| {
|
||||
let l = d.layer("A").unwrap();
|
||||
(l.plot, l.vp_freeze_new, l.linetype.clone(), l.lineweight, l.plot_style.clone(), l.transparency)
|
||||
};
|
||||
let change = |d: &mut Drawing| {
|
||||
let l = d.layer_mut("A").unwrap();
|
||||
(l.plot, l.vp_freeze_new, l.linetype, l.lineweight, l.plot_style, l.transparency) =
|
||||
(false, true, "DASHED".into(), Lineweight::from_dxf(50), "Thick".into(), 40);
|
||||
};
|
||||
let before = props(s.doc().unwrap());
|
||||
change(s.doc_mut().unwrap());
|
||||
let after = props(s.doc().unwrap());
|
||||
for bit in [S::PLOT, S::VP_FREEZE_NEW, S::LINETYPE, S::LINEWEIGHT, S::PLOT_STYLE, S::TRANSPARENCY] {
|
||||
let name = format!("b{bit}");
|
||||
s.doc_mut().unwrap().layer_states.push(S { name: name.clone(), mask: bit | 512, ..saved.clone() });
|
||||
change(s.doc_mut().unwrap());
|
||||
s.execute("layerstate.restore", &json!({ "name": name })).unwrap();
|
||||
let mut want = after.clone();
|
||||
match bit {
|
||||
S::PLOT => want.0 = before.0,
|
||||
S::VP_FREEZE_NEW => want.1 = before.1,
|
||||
S::LINETYPE => want.2.clone_from(&before.2),
|
||||
S::LINEWEIGHT => want.3 = before.3,
|
||||
S::PLOT_STYLE => want.4.clone_from(&before.4),
|
||||
_ => want.5 = before.5,
|
||||
}
|
||||
assert_eq!(props(s.doc().unwrap()), want, "mask {bit}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_layer_set_changes_nothing() {
|
||||
let mut s = Session::new();
|
||||
|
||||
@@ -8,7 +8,6 @@ use serde_json::{Value, json};
|
||||
|
||||
use super::super::find_command;
|
||||
use super::super::qselect::wildcard;
|
||||
use super::state_prompts;
|
||||
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
const OPTIONS: &[&str] = &[
|
||||
@@ -35,9 +34,9 @@ const OPTIONS: &[&str] = &[
|
||||
];
|
||||
|
||||
/// Keyword-only: spaces separate inputs.
|
||||
pub(super) const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
|
||||
const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
|
||||
/// A name or value: Space ends the input, as it does in AutoCAD scripts.
|
||||
pub(super) const NAME: Accept = Accept { number: true, ..Accept::TEXT };
|
||||
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
|
||||
|
||||
/// A per-layer change applied to a list of layer names.
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -112,8 +111,6 @@ enum Stage {
|
||||
Layers(Change),
|
||||
/// Turning the current layer off asks first.
|
||||
ConfirmOff(Vec<String>),
|
||||
/// stAte and its options.
|
||||
State(state_prompts::Stage),
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
@@ -126,19 +123,19 @@ fn current_layer(s: &Session) -> String {
|
||||
}
|
||||
|
||||
/// Run a layer command's body directly: the running command records the single undo step.
|
||||
pub(super) fn call(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
|
||||
fn call(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
|
||||
let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.into()))?;
|
||||
(spec.run)(s, p)
|
||||
}
|
||||
|
||||
pub(super) fn message(e: &EngineError) -> String {
|
||||
fn message(e: &EngineError) -> String {
|
||||
match e {
|
||||
EngineError::BadParams { msg, .. } => msg.clone(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn retry(msg: impl Into<String>) -> EngineError {
|
||||
fn retry(msg: impl Into<String>) -> EngineError {
|
||||
EngineError::Other(msg.into())
|
||||
}
|
||||
|
||||
@@ -191,9 +188,8 @@ impl LayerM {
|
||||
"LOck" => Stage::Layers(Change::Lock),
|
||||
"Unlock" => Stage::Layers(Change::Unlock),
|
||||
"Description" => Stage::Description,
|
||||
"stAte" => Stage::State(state_prompts::Stage::Option),
|
||||
other => {
|
||||
// MATerial, rEconcile: report and stay at the option prompt.
|
||||
// MATerial, stAte, rEconcile: report and stay at the option prompt.
|
||||
s.echo(format!("-LAYER {other} is not available yet."));
|
||||
Stage::Option
|
||||
}
|
||||
@@ -266,7 +262,7 @@ impl LayerM {
|
||||
Ok(Step::Continue)
|
||||
};
|
||||
match stage {
|
||||
Stage::Option | Stage::State(_) => Ok(Step::Continue),
|
||||
Stage::Option => Ok(Step::Continue),
|
||||
Stage::List => {
|
||||
self.list(s, text.as_deref().unwrap_or("*"));
|
||||
Ok(Step::Continue)
|
||||
@@ -438,18 +434,9 @@ impl Interactive for LayerM {
|
||||
if enter_is_current { p.default(cur) } else { p }
|
||||
}
|
||||
Stage::ConfirmOff(_) => Prompt::new(format!("Really want layer \"{cur}\" (the CURRENT layer) off?"), KW).kw(&["Yes", "No"]).default("N"),
|
||||
Stage::State(st) => st.prompt(),
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
if let Stage::State(st) = &mut self.stage
|
||||
&& !matches!(i, Input::Cancel)
|
||||
{
|
||||
if !st.input(s, &i)? {
|
||||
self.stage = Stage::Option;
|
||||
}
|
||||
return Ok(Step::Continue);
|
||||
}
|
||||
match (&self.stage, &i) {
|
||||
(_, Input::Cancel) => Ok(Step::Cancel),
|
||||
(Stage::Option, Input::Enter) => Ok(Step::Done),
|
||||
|
||||
@@ -1,256 +0,0 @@
|
||||
//! -LAYER stAte: save, restore, edit, rename, delete and list the drawing's layer states, with
|
||||
//! AutoCAD 2024's prompts and messages (measured). Save, Restore, Name and Delete run the
|
||||
//! `layerstate.*` commands; Edit changes the state's mask in place.
|
||||
|
||||
use cadcraft_doc::LayerState as LS;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::prompts::{KW, NAME, call, message, retry};
|
||||
use super::{state_index, valid_name};
|
||||
use crate::{Input, Prompt, Result, Session};
|
||||
|
||||
/// The options after stAte. Import and EXport (layer state files) are not available yet.
|
||||
const OPTIONS: &[&str] = &["?", "Save", "Restore", "Edit", "Name", "Delete", "Import", "EXport"];
|
||||
|
||||
/// "Enter states to change": each keyword, the name AutoCAD 2024 lists it by and its mask bit, in
|
||||
/// AutoCAD's order.
|
||||
const TOGGLES: [(&str, &str, u32); 10] = [
|
||||
("On", "On", LS::ON),
|
||||
("Frozen", "Frozen", LS::FROZEN),
|
||||
("Lock", "Lock", LS::LOCKED),
|
||||
("Plot", "Plot", LS::PLOT),
|
||||
("Newvpfreeze", "Newvpfreeze", LS::VP_FREEZE_NEW),
|
||||
("Color", "Color", LS::COLOR),
|
||||
("lineType", "lineType", LS::LINETYPE),
|
||||
("lineWeight", "lineWeight", LS::LINEWEIGHT),
|
||||
("TRansparency", "Transparency", LS::TRANSPARENCY),
|
||||
("plotStyle", "plotStyle", LS::PLOT_STYLE),
|
||||
];
|
||||
|
||||
/// The options that ask for a saved state's name.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(super) enum Pick {
|
||||
Restore,
|
||||
Edit,
|
||||
Name,
|
||||
Delete,
|
||||
}
|
||||
|
||||
impl Pick {
|
||||
fn verb(self) -> &'static str {
|
||||
match self {
|
||||
Pick::Restore => "restore",
|
||||
Pick::Edit => "edit",
|
||||
Pick::Name => "rename",
|
||||
Pick::Delete => "delete",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub(super) enum Stage {
|
||||
#[default]
|
||||
Option,
|
||||
/// Save: the new state's name.
|
||||
SaveName,
|
||||
/// Restore, Edit, Name or Delete: the saved state's name.
|
||||
Pick(Pick),
|
||||
/// Name: the new name of the state called so.
|
||||
RenameTo(String),
|
||||
/// "Enter states to change" for the state `name`: one Save makes on Enter, or one Edit
|
||||
/// changes (`edit`).
|
||||
Toggles { name: String, mask: u32, edit: bool },
|
||||
}
|
||||
|
||||
impl Stage {
|
||||
pub(super) fn prompt(&self) -> Prompt {
|
||||
match self {
|
||||
Stage::Option => Prompt::new("Enter an option", KW).kw(OPTIONS),
|
||||
Stage::SaveName | Stage::RenameTo(_) => Prompt::new("Enter new layer state name", NAME),
|
||||
Stage::Pick(p) => Prompt::new(format!("Enter name of layer state to {}", p.verb()), NAME).kw(&["?"]),
|
||||
Stage::Toggles { .. } => Prompt::new("Enter states to change", KW).kw(&TOGGLES.map(|t| t.0)),
|
||||
}
|
||||
}
|
||||
|
||||
/// One input. `Ok(false)`: back to -LAYER's options. An invalid input leaves the stage as it
|
||||
/// is, so the prompt is asked again.
|
||||
pub(super) fn input(&mut self, s: &mut Session, i: &Input) -> Result<bool> {
|
||||
let text = match i {
|
||||
Input::Text(t) | Input::Keyword(t) => Some(t.trim().to_string()).filter(|t| !t.is_empty()),
|
||||
_ => None,
|
||||
};
|
||||
let next = match std::mem::take(self) {
|
||||
Stage::Option => match i {
|
||||
Input::Enter => return Ok(false),
|
||||
Input::Keyword(k) => option(s, k),
|
||||
_ => return Err(retry("Invalid option keyword.")),
|
||||
},
|
||||
Stage::SaveName => match text {
|
||||
None => Stage::Option,
|
||||
Some(n) => save_name(s, n),
|
||||
},
|
||||
Stage::Pick(p) => match (i, text) {
|
||||
(Input::Keyword(k), _) if k == "?" => {
|
||||
list(s);
|
||||
Stage::Pick(p)
|
||||
}
|
||||
(_, None) => Stage::Option,
|
||||
(_, Some(n)) => pick(s, p, &n),
|
||||
},
|
||||
Stage::RenameTo(from) => {
|
||||
if let Some(to) = text {
|
||||
rename(s, &from, &to);
|
||||
}
|
||||
Stage::Option
|
||||
}
|
||||
Stage::Toggles { name, mut mask, edit } => match i {
|
||||
Input::Keyword(k) => {
|
||||
if let Some(&(_, _, bit)) = TOGGLES.iter().find(|t| t.0 == k) {
|
||||
mask ^= bit;
|
||||
}
|
||||
show(s, mask);
|
||||
Stage::Toggles { name, mask, edit }
|
||||
}
|
||||
Input::Enter => {
|
||||
finish(s, &name, mask, edit);
|
||||
Stage::Option
|
||||
}
|
||||
_ => {
|
||||
*self = Stage::Toggles { name, mask, edit };
|
||||
return Err(retry("Invalid option keyword."));
|
||||
}
|
||||
},
|
||||
};
|
||||
*self = next;
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn option(s: &mut Session, k: &str) -> Stage {
|
||||
match k {
|
||||
"?" => {
|
||||
list(s);
|
||||
Stage::Option
|
||||
}
|
||||
"Save" => Stage::SaveName,
|
||||
"Restore" => Stage::Pick(Pick::Restore),
|
||||
"Edit" => Stage::Pick(Pick::Edit),
|
||||
"Name" => Stage::Pick(Pick::Name),
|
||||
"Delete" => Stage::Pick(Pick::Delete),
|
||||
other => {
|
||||
s.echo(format!("-LAYER stAte {other} is not available yet."));
|
||||
Stage::Option
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a saved state has the name `n` in any case.
|
||||
fn taken(s: &Session, n: &str) -> bool {
|
||||
s.doc().is_ok_and(|d| d.layer_states.iter().any(|st| st.name.eq_ignore_ascii_case(n)))
|
||||
}
|
||||
|
||||
/// Save's name: refused (asked again) when it has a character AutoCAD 2024 refuses (the layer
|
||||
/// name ones, measured one by one), is longer than 255 characters (measured 256), or is a saved
|
||||
/// state's name in any case (measured `s1` after `S1`).
|
||||
fn save_name(s: &mut Session, n: String) -> Stage {
|
||||
if !valid_name(&n) {
|
||||
s.echo(format!("\"{n}\" is an invalid layer state name."));
|
||||
return Stage::SaveName;
|
||||
}
|
||||
if taken(s, &n) {
|
||||
s.echo(format!("Layer state \"{n}\" already exists."));
|
||||
return Stage::SaveName;
|
||||
}
|
||||
let mask = s.settings.layer_state_mask;
|
||||
show(s, mask);
|
||||
Stage::Toggles { name: n, mask, edit: false }
|
||||
}
|
||||
|
||||
fn pick(s: &mut Session, p: Pick, n: &str) -> Stage {
|
||||
let found = s.doc().ok().and_then(|d| state_index(d, n).and_then(|i| d.layer_states.get(i)).map(|st| (st.name.clone(), st.mask)));
|
||||
let Some((name, mask)) = found else {
|
||||
s.echo("Unknown layer state name.");
|
||||
return Stage::Pick(p);
|
||||
};
|
||||
match p {
|
||||
Pick::Restore => {
|
||||
run(s, "layerstate.restore", &json!({ "name": name }));
|
||||
Stage::Option
|
||||
}
|
||||
Pick::Delete => {
|
||||
run(s, "layerstate.delete", &json!({ "name": name }));
|
||||
Stage::Option
|
||||
}
|
||||
Pick::Edit => {
|
||||
show(s, mask);
|
||||
Stage::Toggles { name, mask, edit: true }
|
||||
}
|
||||
Pick::Name => Stage::RenameTo(name),
|
||||
}
|
||||
}
|
||||
|
||||
/// Name's new name. A name some state has in any case, the state's own too, is refused with
|
||||
/// AutoCAD 2024's two lines (measured `S2` onto `S2`, `S1` onto `s1`). A name with a character
|
||||
/// AutoCAD refuses leaves the state as it is with no message, as AutoCAD does (measured `a,b`,
|
||||
/// `a<b`); AutoCAD renames to a name starting with "*" as an anonymous `*A1`, and CADCraft leaves
|
||||
/// that state as it is too.
|
||||
fn rename(s: &mut Session, from: &str, to: &str) {
|
||||
if taken(s, to) {
|
||||
s.echo("Layer state could not be renamed.");
|
||||
s.echo(format!("{to} already exists."));
|
||||
} else if valid_name(to) {
|
||||
run(s, "layerstate.rename", &json!({ "from": from, "to": to }));
|
||||
}
|
||||
}
|
||||
|
||||
/// Enter at "Enter states to change": Save makes the state with this mask and keeps the toggles
|
||||
/// for the next Save; Edit sets the state's mask and keeps the bits no toggle reaches (AutoCAD's
|
||||
/// 65536 after a restore). Edit leaves the next Save's toggles alone (measured).
|
||||
fn finish(s: &mut Session, name: &str, mask: u32, edit: bool) {
|
||||
if !edit {
|
||||
if run(s, "layerstate.save", &json!({ "name": name, "mask": mask & LS::ALL })) {
|
||||
s.settings.layer_state_mask = mask & LS::ALL;
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Only a changed mask touches the drawing.
|
||||
let Ok(d) = s.doc() else { return };
|
||||
let Some(i) = state_index(d, name).filter(|&i| d.layer_states.get(i).is_some_and(|st| st.mask != mask)) else { return };
|
||||
if let Ok(d) = s.doc_mut()
|
||||
&& let Some(st) = d.layer_states.get_mut(i)
|
||||
{
|
||||
st.mask = mask;
|
||||
}
|
||||
}
|
||||
|
||||
/// Run a `layerstate.*` command, reporting a refusal; `true` when it ran.
|
||||
fn run(s: &mut Session, id: &str, p: &Value) -> bool {
|
||||
match call(s, id, p) {
|
||||
Ok(_) => true,
|
||||
Err(e) => {
|
||||
s.echo(message(&e));
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The toggles as AutoCAD 2024 lists them before "Enter states to change".
|
||||
fn show(s: &mut Session, mask: u32) {
|
||||
s.echo("States");
|
||||
for (_, label, bit) in TOGGLES {
|
||||
s.echo(format!("{label:<20}{}", if mask & bit != 0 { "Yes" } else { "No" }));
|
||||
}
|
||||
}
|
||||
|
||||
/// `?`: every saved state by name without regard to case, as AutoCAD 2024 lists them (measured:
|
||||
/// `S2`, `b`, `S1` saved in that order list as `b`, `S1`, `S2`; a name starting with "*", its
|
||||
/// `*A1`, is listed too).
|
||||
fn list(s: &mut Session) {
|
||||
let mut names: Vec<String> = s.doc().map(|d| d.layer_states.iter().map(|st| st.name.clone()).collect()).unwrap_or_default();
|
||||
names.sort_by_cached_key(|n| n.to_ascii_lowercase());
|
||||
s.echo("Layer state");
|
||||
s.echo("-".repeat(29));
|
||||
for n in names {
|
||||
s.echo(n);
|
||||
}
|
||||
}
|
||||
@@ -78,7 +78,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("pagesetup", "Page Setup Manager...", run_pagesetup)
|
||||
.menu(&["File", "Page Setup Manager..."])
|
||||
.params(
|
||||
"{layout?: current, device?: plotter name (PLOTTERMANAGER) | \"None\", paper?: the device's paper | \"A4\"|\"A3\"|\"Letter\"|\"ANSI B\"|…, width?, height? (mm), landscape?, paperUnits?: \"mm\"|\"inches\" (one paper-space unit on the layout), margins?: [l,b,r,t] mm, lineweights?, plotArea?, scale?, scaleToFit?, center?, plotStyleTable?: \"monochrome.ctb\"|\"grayscale.ctb\"|\"default.ctb\"|\"None\"|…, displayPlotStyles?: bool, plotTransparency?: bool}",
|
||||
"{layout?: current, device?: plotter name (PLOTTERMANAGER) | \"None\", paper?: the device's paper | \"A4\"|\"A3\"|\"Letter\"|\"ANSI B\"|…, width?, height? (mm), landscape?, margins?: [l,b,r,t] mm, lineweights?, plotArea?, scale?, scaleToFit?, center?, plotStyleTable?: \"monochrome.ctb\"|\"grayscale.ctb\"|\"default.ctb\"|\"None\"|…, displayPlotStyles?: bool, plotTransparency?: bool}",
|
||||
),
|
||||
CommandSpec::new("plot", "Print...", |s, p| run_plot(s, &super::plotters::plot_options(s, p, "plot")?, "plot"))
|
||||
.menu(&["File", "Print..."])
|
||||
@@ -313,16 +313,7 @@ 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,
|
||||
ucs: src.ucs,
|
||||
ucs_previous: Vec::new(),
|
||||
limits: src.limits,
|
||||
});
|
||||
d.layouts.push(Layout { name: to.clone(), tab_order: order, page: src.page, entities: store, view: src.view, limits: src.limits });
|
||||
Ok(json!({ "name": to }))
|
||||
}
|
||||
|
||||
@@ -650,7 +641,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
"width",
|
||||
"height",
|
||||
"landscape",
|
||||
"paperUnits",
|
||||
"margins",
|
||||
"lineweights",
|
||||
"plotArea",
|
||||
@@ -680,9 +670,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}));
|
||||
};
|
||||
let mut page = s.doc()?.layout(&name).map(|l| l.page.clone()).unwrap_or_default();
|
||||
// The standard size the layout had before this call, so that resubmitting it (the Plot
|
||||
// dialog's Apply to Layout always sends `paper`) keeps the layout's paper units.
|
||||
let old_paper = cadcraft_render::paper_size(&page.paper).map(|ps| ps.name);
|
||||
// A plotter's own papers (with their printable areas) come first.
|
||||
let device_paper = super::plotters::page_device(cmd, p, &mut page)?;
|
||||
if let Some(paper) = p.get("paper").filter(|_| !device_paper) {
|
||||
@@ -695,24 +682,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
page.width_mm = ps.width_mm;
|
||||
page.height_mm = ps.height_mm;
|
||||
}
|
||||
// The picked paper's own units become the layout's paper units: millimetres for a metric
|
||||
// paper, else the drawing's MEASUREMENT. Otherwise ISO A0 in a new (imperial) drawing's
|
||||
// layout is 33.11 x 46.81 units (#2836). This holds for a standard size from the page's
|
||||
// device's list too (the built-in devices list every standard size), and a device's own
|
||||
// paper that is not a standard size keeps the layout's units. Only a saved page setup changes
|
||||
// units; a one-off plot's `paper` keeps the layout's, so its objects stay the size they were
|
||||
// drawn. A custom `width` and `height` in the same call replace this paper below, and a
|
||||
// custom size keeps the layout's units, with `paper` or without it. The same paper the layout
|
||||
// already has keeps its units too, so an explicit choice survives it. An explicit
|
||||
// `paperUnits` in the same call wins (below).
|
||||
if p.get("paper").is_some()
|
||||
&& p.get("width").is_none()
|
||||
&& p.get("height").is_none()
|
||||
&& let Some(ps) = cadcraft_render::paper_size(&page.paper)
|
||||
&& old_paper != Some(ps.name)
|
||||
{
|
||||
page.paper_mm = (!ps.imperial).then_some(true);
|
||||
}
|
||||
let mm = |k: &str| p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite() && *v > 0.0 && *v <= 5080.0);
|
||||
match (mm("width"), mm("height")) {
|
||||
(Some(w), Some(h)) => {
|
||||
@@ -726,15 +695,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if let Some(l) = p.get("landscape").and_then(Value::as_bool) {
|
||||
page.landscape = l;
|
||||
}
|
||||
// Paper units: what one paper-space unit is on this layout, whatever the paper's own family
|
||||
// (an ARCH D sheet can be drawn in millimetres, #3249).
|
||||
if let Some(v) = p.get("paperUnits") {
|
||||
page.paper_mm = Some(match v.as_str().map(str::to_ascii_lowercase).as_deref() {
|
||||
Some("mm" | "millimeters" | "millimetres") => true,
|
||||
Some("in" | "inch" | "inches") => false,
|
||||
_ => return Err(bad(cmd, "`paperUnits` must be \"mm\" or \"inches\"")),
|
||||
});
|
||||
}
|
||||
if let Some(m) = p.get("margins") {
|
||||
let a: Vec<f64> = m.as_array().map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
|
||||
match a[..] {
|
||||
@@ -904,7 +864,6 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
|
||||
let path = _path;
|
||||
// Exclusively create a fresh temporary file and rename it into place so a planted
|
||||
// `<path>.cadcraft-tmp` symlink cannot redirect the plot write (CWE-59).
|
||||
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
|
||||
let folder = super::file::new_folder(path);
|
||||
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
|
||||
let mut r = json!({ "path": path, "bytes": bytes.len(), "layout": layout, "pages": pages, "format": format });
|
||||
|
||||
@@ -187,7 +187,6 @@ fn edit_style(cmd: &str, st: &mut PlotStyle, v: &Value) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// List, read, change, load and export plot style tables; any file is held to the automation roots.
|
||||
fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "stylesmanager";
|
||||
let action = str_param(p, "action").unwrap_or("list").to_ascii_lowercase();
|
||||
@@ -265,23 +264,16 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
return Err(bad(cmd, format!("`{name}` has no style `{rm}`")));
|
||||
}
|
||||
}
|
||||
let mut changed: Option<String> = None;
|
||||
if let Some(v) = p.get("style") {
|
||||
let sname = v.get("name").and_then(Value::as_str).map(str::trim).filter(|n| !n.is_empty());
|
||||
let sname = sname.ok_or_else(|| bad(cmd, "`style.name` is required"))?;
|
||||
// The name as it is stored (at most 255 characters, as `sanitized` cuts it, and
|
||||
// without a space the cut leaves at the end, which `sanitized` trims), so a long
|
||||
// name finds the style it was stored as and the reply finds the edited style.
|
||||
let cut: String = sname.chars().take(255).collect();
|
||||
let sname = cut.trim_end();
|
||||
changed = Some(sname.to_string());
|
||||
let idx = match t.styles.iter().position(|x| x.name.eq_ignore_ascii_case(sname)) {
|
||||
Some(i) => i,
|
||||
None if t.kind == PlotStyleKind::Named => {
|
||||
if t.styles.len() >= cadcraft_doc::MAX_NAMED_STYLES {
|
||||
return Err(bad(cmd, "the table has too many styles"));
|
||||
}
|
||||
t.styles.push(PlotStyle::object(sname));
|
||||
t.styles.push(PlotStyle::object(&sname.chars().take(255).collect::<String>()));
|
||||
t.styles.len() - 1
|
||||
}
|
||||
None => return Err(bad(cmd, format!("`{name}` has no style `{sname}` (colour-dependent styles are Color_1 to Color_255)"))),
|
||||
@@ -291,21 +283,7 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
let t = t.sanitized();
|
||||
// Only what changed, not the table (a colour-dependent one has 255 styles): the table's
|
||||
// name, the description if given, the edited style and the removed style's name.
|
||||
let mut out = json!({ "name": t.name });
|
||||
if let Some(o) = out.as_object_mut() {
|
||||
if str_param(p, "description").is_some() {
|
||||
o.insert("description".into(), json!(t.description));
|
||||
}
|
||||
let edited = changed.and_then(|n| t.styles.iter().find(|x| x.name.eq_ignore_ascii_case(&n)));
|
||||
if let Some(e) = edited.and_then(|x| serde_json::to_value(x).ok()) {
|
||||
o.insert("style".into(), e);
|
||||
}
|
||||
if let Some(r) = str_param(p, "removeStyle") {
|
||||
o.insert("removedStyle".into(), json!(r.trim()));
|
||||
}
|
||||
}
|
||||
let out = serde_json::to_value(&t).unwrap_or(Value::Null);
|
||||
store(s.doc_mut()?, t);
|
||||
Ok(out)
|
||||
}
|
||||
@@ -325,7 +303,6 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
(None, Some(_path)) => {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(_path).map_err(|e| bad(cmd, e))?;
|
||||
let bytes = crate::capped_read::read_capped(std::path::Path::new(_path), cadcraft_doc::MAX_TABLE_FILE)
|
||||
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
|
||||
String::from_utf8(bytes).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
|
||||
@@ -354,7 +331,6 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Some(_path) => {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_write(_path).map_err(|e| bad(cmd, e))?;
|
||||
crate::atomic_write::write_atomic(std::path::Path::new(_path), text.as_bytes())
|
||||
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
|
||||
Ok(json!({ "name": name, "path": _path, "bytes": text.len() }))
|
||||
|
||||
@@ -145,7 +145,6 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
|
||||
{
|
||||
// Exclusively create a fresh temporary file and rename it into place so a planted
|
||||
// `<path>.cadcraft-tmp` symlink cannot redirect the write (CWE-59).
|
||||
crate::file_access::check_write(path).map_err(|e| bad("layout.saveas", e))?;
|
||||
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad("layout.saveas", format!("{path}: {e}")))
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
|
||||
@@ -165,57 +165,14 @@ fn viewport_scale_lock_and_layers() {
|
||||
}
|
||||
}
|
||||
|
||||
/// #2836: picking a paper sets the layout's paper units from it. In a new drawing (imperial,
|
||||
/// MEASUREMENT 0) ISO A0 was 46.81 x 33.11 units, the inch equivalent; now it is 1189 x 841.
|
||||
/// An inch paper gives the layout back the drawing's units.
|
||||
#[test]
|
||||
fn pagesetup_paper_sets_the_layout_paper_units() {
|
||||
let mut s = Session::new();
|
||||
assert_eq!(cadcraft_render::paper::paper_unit_mm(s.doc().unwrap()), 25.4, "a new drawing is imperial");
|
||||
let size = |s: &Session| {
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
((sheet.size.x * 100.0).round() / 100.0, (sheet.size.y * 100.0).round() / 100.0, sheet.unit_mm)
|
||||
};
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A0", "landscape": true})).unwrap();
|
||||
assert_eq!(r["page"]["paperMm"], true);
|
||||
assert_eq!(size(&s), (1189.0, 841.0, 1.0), "ISO A0 in millimetres");
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ANSI D"})).unwrap();
|
||||
assert_eq!(size(&s), (34.0, 22.0, 25.4), "ANSI D in the drawing's inches");
|
||||
// A custom size replaces the named paper in the same call and keeps the layout's units.
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A4", "width": 254, "height": 508})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, None, "the layout still follows MEASUREMENT");
|
||||
assert_eq!(size(&s), (20.0, 10.0, 25.4), "the custom size in the layout's inches");
|
||||
}
|
||||
|
||||
/// #2836 through a device: the built-in devices list every standard size, so a paper picked in
|
||||
/// Page Setup with CADCraft PDF as the device comes from the device's list. It sets the layout's
|
||||
/// paper units as a paper picked with no device does.
|
||||
#[test]
|
||||
fn pagesetup_device_paper_sets_the_layout_paper_units() {
|
||||
let mut s = Session::new();
|
||||
let size = |s: &Session| {
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
((sheet.size.x * 100.0).round() / 100.0, (sheet.size.y * 100.0).round() / 100.0, sheet.unit_mm)
|
||||
};
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "device": "CADCraft PDF", "landscape": true})).unwrap();
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ISO A0 (841.00 x 1189.00 MM)"})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.device, "CADCraft PDF");
|
||||
assert_eq!(size(&s), (1189.0, 841.0, 1.0), "ISO A0 from the device's list in millimetres");
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ANSI D"})).unwrap();
|
||||
assert_eq!(size(&s), (34.0, 22.0, 25.4), "ANSI D from the device's list in the drawing's inches");
|
||||
// An explicit choice in the same call wins over the paper's own units (#3249).
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "paperUnits": "mm"})).unwrap();
|
||||
assert_eq!(size(&s), (914.4, 609.6, 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pagesetup_paper_table() {
|
||||
let mut s = Session::new();
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A3", "landscape": true, "margins": [5, 5, 5, 5]})).unwrap();
|
||||
assert_eq!(r["page"]["widthMm"], 297.0);
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
// An imperial drawing, but a metric paper: the layout's paper units are millimetres (#2836).
|
||||
assert!((sheet.size.x - 420.0).abs() < 1e-9 && (sheet.size.y - 297.0).abs() < 1e-9);
|
||||
// Imperial drawing: paper units are inches.
|
||||
assert!((sheet.size.x - 420.0 / 25.4).abs() < 1e-9 && (sheet.size.y - 297.0 / 25.4).abs() < 1e-9);
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "Z12"})).is_err());
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "margins": [1, 2]})).is_err());
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "width": 1e308, "height": 5})).is_err());
|
||||
@@ -233,57 +190,6 @@ fn pagesetup_paper_table() {
|
||||
assert_eq!((p.width_mm, p.height_mm), (300.0, 500.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pagesetup_paper_units_make_an_inch_sheet_metric() {
|
||||
// An ARCH D sheet in a drawing that measures in millimetres (#3249): the page setup's paper
|
||||
// units decide the paper-space unit, so the sheet can be 914.4 x 609.6 mm.
|
||||
let mut s = Session::new();
|
||||
s.execute("units", &json!({"insunits": 4})).unwrap();
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "landscape": true, "paperUnits": "mm"})).unwrap();
|
||||
assert_eq!(r["page"]["paperMm"], true);
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((sheet.size.x - 914.4).abs() < 1e-9 && (sheet.size.y - 609.6).abs() < 1e-9, "{:?}", sheet.size);
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "Inches"})).unwrap();
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((sheet.size.x - 36.0).abs() < 1e-9 && (sheet.size.y - 24.0).abs() < 1e-9, "{:?}", sheet.size);
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "millimeters"})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, Some(true));
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "feet"})).is_err());
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": 4})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pagesetup_paper_units_inches_overrides_metric_measurement() {
|
||||
let mut s = Session::new();
|
||||
s.execute("setvar", &json!({"name": "MEASUREMENT", "value": 1})).unwrap();
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "landscape": true})).unwrap();
|
||||
// Without an explicit paperUnits choice, MEASUREMENT = 1 keeps the sheet in millimetres.
|
||||
let metric = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((metric.size.x - 914.4).abs() < 1e-9 && (metric.size.y - 609.6).abs() < 1e-9, "{:?}", metric.size);
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "inches"})).unwrap();
|
||||
assert_eq!(r["page"]["paperMm"], false);
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, Some(false));
|
||||
let inch = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((inch.size.x - 36.0).abs() < 1e-9 && (inch.size.y - 24.0).abs() < 1e-9, "{:?}", inch.size);
|
||||
}
|
||||
|
||||
/// The Plot dialog's Apply to Layout sends the layout's paper every time. Resubmitting the paper
|
||||
/// the layout already has keeps an explicit paper-units choice; a different paper still sets
|
||||
/// the units from that paper (#2836, #3249).
|
||||
#[test]
|
||||
fn pagesetup_same_paper_keeps_explicit_paper_units() {
|
||||
let mut s = Session::new();
|
||||
let units = |s: &Session| s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm;
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "landscape": true, "paperUnits": "mm"})).unwrap();
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "landscape": true, "lineweights": true})).unwrap();
|
||||
assert_eq!(units(&s), Some(true), "millimetres on an inch paper survive resubmitting it");
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A4", "paperUnits": "inches"})).unwrap();
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ISO A4 (210.00 x 297.00 MM)"})).unwrap();
|
||||
assert_eq!(units(&s), Some(false), "inches on a metric paper survive resubmitting it by its full name");
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A3"})).unwrap();
|
||||
assert_eq!(units(&s), Some(true), "a different paper still sets the units");
|
||||
}
|
||||
|
||||
fn fake_plot(d: &Drawing, space: &Space, opts: &Value) -> std::result::Result<Vec<u8>, String> {
|
||||
let _ = d;
|
||||
Ok(format!("%PDF-1.4 fake {space:?} {opts}").into_bytes())
|
||||
|
||||
@@ -26,7 +26,7 @@ mod stretch;
|
||||
mod transform;
|
||||
mod trim;
|
||||
|
||||
use break_join::{BreakAtPointM, BreakM, run_break, run_breakat, run_join};
|
||||
use break_join::{BreakM, run_break, run_breakat, run_join};
|
||||
use explode::run_explode;
|
||||
pub(crate) use explode::{explode_kind, explode_with};
|
||||
use fillet::{FilletM, run_chamfer, run_fillet};
|
||||
@@ -37,7 +37,7 @@ use select_then::{DisplaceM, Op, SelectThen};
|
||||
use stretch::{StretchM, run_stretch};
|
||||
pub(crate) use transform::{holds_ole_frame, ole_refusal, refuse_ole_frames, transform_entities};
|
||||
use transform::{run_copy, run_erase, run_mirror, run_move, run_rotate, run_scale};
|
||||
pub(crate) use trim::{CUT_ONCE, Edges, extend, json_pick_error, trim};
|
||||
pub(crate) use trim::{Edges, extend, trim};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![
|
||||
@@ -85,24 +85,14 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("trim", "Trim", trimextend::run_trim)
|
||||
.menu(&["Modify", "Trim"])
|
||||
.alias(&["tr"])
|
||||
.params(concat!(
|
||||
"{handle, pick: [x,y]} | {fence: [[x,y],...]} | {crossing: [[x,y],[x,y]]}; edges?: [hex] (default: every object; a polyline that is one of them, or every object in Standard mode, also cuts itself at its vertices and crossings), edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\" ",
|
||||
"→ {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing). ",
|
||||
"For handle+pick: handle is the object to trim; pick selects the portion of that object to remove ",
|
||||
"(normally a point on it, away from a cutting intersection); edges are the cutting edges. The JSON default is standard mode."
|
||||
))
|
||||
.params(
|
||||
"{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\"} → {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing)",
|
||||
)
|
||||
.interactive(|_| Ok(Box::new(TrimM::new(false)))),
|
||||
CommandSpec::new("extend", "Extend", trimextend::run_extend)
|
||||
.menu(&["Modify", "Extend"])
|
||||
.alias(&["ex"])
|
||||
.params(concat!(
|
||||
"{handle, pick: [x,y]} | {fence: [[x,y],...]} | {crossing: [[x,y],[x,y]]}; ",
|
||||
"edges?: [hex], edgeMode?: \"extend\"|\"none\". ",
|
||||
"For handle+pick: handle is the object to extend; pick points toward the boundary to extend to ",
|
||||
"(normally a point on that boundary), selecting the nearer end of the object ",
|
||||
"(of an open polyline, the end on the pick's side of its middle parameter); ",
|
||||
"edges are the boundary edges, and the nearest forward intersection is used."
|
||||
))
|
||||
.params("{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\"}")
|
||||
.interactive(|_| Ok(Box::new(TrimM::new(true)))),
|
||||
CommandSpec::new("fillet", "Fillet", run_fillet)
|
||||
.menu(&["Modify", "Fillet"])
|
||||
@@ -124,10 +114,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
.alias(&["br"])
|
||||
.params("{handle, p1, p2} → {handles: the object (kept, reshaped) then the new pieces; none when nothing is left}")
|
||||
.interactive(|_| Ok(Box::new(BreakM::default()))),
|
||||
CommandSpec::new("breakatpoint", "Break At Point", run_breakat)
|
||||
.menu(&["Modify", "Break At Point"])
|
||||
.params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}")
|
||||
.interactive(|_| Ok(Box::new(BreakAtPointM::default()))),
|
||||
CommandSpec::new("breakatpoint", "Break At Point", run_breakat).menu(&["Modify", "Break At Point"]).params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}"),
|
||||
CommandSpec::new("join", "Join", run_join)
|
||||
.menu(&["Modify", "Join"])
|
||||
.alias(&["j"])
|
||||
|
||||
@@ -4,6 +4,16 @@ use super::{
|
||||
Value, Vec2, arc, bad, json, lwpoly, norm_angle, point_param, point_req, targets,
|
||||
};
|
||||
|
||||
/// Gives a rebuilt arc piece its source centre Z, or a rebuilt polyline piece its source elevation.
|
||||
fn with_z(mut k: EntityKind, z: f64) -> EntityKind {
|
||||
match &mut k {
|
||||
EntityKind::Arc(a) => a.center.z = z,
|
||||
EntityKind::LwPolyline(p) => p.elevation = z,
|
||||
_ => {}
|
||||
}
|
||||
k
|
||||
}
|
||||
|
||||
/// Break `h` between two points (or at one point when p1 == p2).
|
||||
pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Result<Vec<Handle>> {
|
||||
if crate::cmd::curves::is_locked(s, h) {
|
||||
@@ -29,12 +39,12 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
|
||||
}
|
||||
EntityKind::Circle(c) => {
|
||||
if p1.near(p2, 1e-12) {
|
||||
return Err(EngineError::Other("Arc cannot be full 360 degrees".into()));
|
||||
return Err(EngineError::Other("Arc cannot be full 360 degrees.".into()));
|
||||
}
|
||||
let a1 = c.center.xy().angle_to(p1);
|
||||
let a2 = c.center.xy().angle_to(p2);
|
||||
// AutoCAD removes the CCW portion from the first to the second point.
|
||||
vec![arc(&Arc::new(c.center.xy(), c.radius, a2, a1))]
|
||||
vec![with_z(arc(&Arc::new(c.center.xy(), c.radius, a2, a1)), c.center.z)]
|
||||
}
|
||||
EntityKind::Arc(a) => {
|
||||
let ga = Arc::new(a.center.xy(), a.radius, a.start, a.end);
|
||||
@@ -45,10 +55,10 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
|
||||
}
|
||||
let mut v = Vec::new();
|
||||
if t1 > 1e-12 {
|
||||
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)));
|
||||
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)), a.center.z));
|
||||
}
|
||||
if t2 < ga.sweep() - 1e-12 {
|
||||
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)));
|
||||
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)), a.center.z));
|
||||
}
|
||||
v
|
||||
}
|
||||
@@ -71,32 +81,24 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
|
||||
};
|
||||
let (mut t1, mut t2) = (lp(p1), lp(p2));
|
||||
if p.closed {
|
||||
let (lo, hi) = if t1 <= t2 { (t1, t2) } else { (t2, t1) };
|
||||
let tol = 1e-9 * (1.0 + total);
|
||||
if hi - lo < tol {
|
||||
// One point: the outline opens at its start vertex and splits at the point;
|
||||
// at the start vertex itself it stays whole and closed.
|
||||
if lo < tol || lo > total - tol {
|
||||
return Ok(vec![h]);
|
||||
}
|
||||
vec![lwpoly(sub_polyline(&segs, 0.0, lo), false), lwpoly(sub_polyline(&segs, lo, total), false)]
|
||||
} else {
|
||||
// The stretch between the points that doesn't run through the start vertex
|
||||
// goes, whichever point came first; what is left runs from the later point
|
||||
// round through the start vertex to the earlier one.
|
||||
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
|
||||
vec![lwpoly(sub_polyline(&doubled, hi, lo + total), false)]
|
||||
if (t1 - t2).abs() < 1e-9 {
|
||||
return Err(EngineError::Other("Cannot break a closed polyline at a single point.".into()));
|
||||
}
|
||||
// Like a circle: the stretch from the first point to the second, along the
|
||||
// vertices, goes; what is left runs from the second point round to the first.
|
||||
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
|
||||
let end = if t1 > t2 { t1 } else { t1 + total };
|
||||
vec![with_z(lwpoly(sub_polyline(&doubled, t2, end), false), p.elevation)]
|
||||
} else {
|
||||
if t1 > t2 {
|
||||
std::mem::swap(&mut t1, &mut t2);
|
||||
}
|
||||
let mut v = Vec::new();
|
||||
if t1 > 1e-12 {
|
||||
v.push(lwpoly(sub_polyline(&segs, 0.0, t1), false));
|
||||
v.push(with_z(lwpoly(sub_polyline(&segs, 0.0, t1), false), p.elevation));
|
||||
}
|
||||
if t2 < total - 1e-12 {
|
||||
v.push(lwpoly(sub_polyline(&segs, t2, total), false));
|
||||
v.push(with_z(lwpoly(sub_polyline(&segs, t2, total), false), p.elevation));
|
||||
}
|
||||
v
|
||||
}
|
||||
@@ -213,41 +215,6 @@ pub(super) fn run_join(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "handle": r.map(|h| h.hex()) }))
|
||||
}
|
||||
|
||||
/// The object picked at `p` for BREAK and BREAKATPOINT ("*Invalid selection*" when there is none).
|
||||
/// One on a locked layer is refused there, and the command asks for an object again, as AutoCAD
|
||||
/// 2024 does; the pick doesn't fall through to an object under it.
|
||||
fn pick_to_break(s: &mut Session, p: Vec2) -> Result<Option<Handle>> {
|
||||
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
|
||||
let space = s.space();
|
||||
match s.pick_object(&space, p, ap)? {
|
||||
Some(h) if crate::cmd::curves::is_locked(s, h) => {
|
||||
s.echo("The object is on a locked layer.");
|
||||
Ok(None)
|
||||
}
|
||||
Some(h) => {
|
||||
s.set_selection(vec![h]);
|
||||
Ok(Some(h))
|
||||
}
|
||||
None => {
|
||||
s.echo("*Invalid selection*");
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Break `h` from `p1` to `p2` and end the command. As in AutoCAD 2024, a break that can't be made
|
||||
/// (a whole circle at one point: "Arc cannot be full 360 degrees") is reported and ends the
|
||||
/// command too, leaving the object as it was.
|
||||
fn break_and_end(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Result<Step> {
|
||||
match break_entity(s, h, p1, p2) {
|
||||
Ok(_) => {}
|
||||
Err(EngineError::Other(m)) => s.echo(m),
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
s.set_selection(Vec::new());
|
||||
Ok(Step::Done)
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct BreakM {
|
||||
obj: Option<(Handle, Vec2)>,
|
||||
@@ -266,17 +233,17 @@ impl Interactive for BreakM {
|
||||
Some(_) => Prompt::new("Specify second break point", Accept::POINT).kw(&["First point"]),
|
||||
}
|
||||
}
|
||||
/// Esc after the object is picked drops the selection the pick made, as Enter does.
|
||||
fn cancelled(&mut self, s: &mut Session) {
|
||||
if self.obj.is_some() {
|
||||
s.set_selection(Vec::new());
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
match (self.obj, i) {
|
||||
(None, Input::Point(p)) => {
|
||||
if let Some(h) = pick_to_break(s, p)? {
|
||||
self.obj = Some((h, p));
|
||||
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
|
||||
let space = s.space();
|
||||
match s.pick_object(&space, p, ap)? {
|
||||
Some(h) => {
|
||||
self.obj = Some((h, p));
|
||||
s.set_selection(vec![h]);
|
||||
}
|
||||
None => s.echo("*Invalid selection*"),
|
||||
}
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
@@ -289,52 +256,12 @@ impl Interactive for BreakM {
|
||||
self.first_point = false;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Some((h, p1)), Input::Point(p2)) => break_and_end(s, h, p1, p2),
|
||||
(Some(_), Input::Enter) => {
|
||||
(Some((h, p1)), Input::Point(p2)) => {
|
||||
break_entity(s, h, p1, p2)?;
|
||||
s.set_selection(Vec::new());
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(None, Input::Enter) => Ok(Step::Done),
|
||||
_ => Ok(Step::Continue),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// BREAKATPOINT at the command line, with AutoCAD 2024's prompts: "Select object:", then "Specify
|
||||
/// break point:"; the object is split there with no gap (the point projects onto it).
|
||||
#[derive(Default)]
|
||||
pub(super) struct BreakAtPointM {
|
||||
obj: Option<Handle>,
|
||||
}
|
||||
|
||||
impl Interactive for BreakAtPointM {
|
||||
fn name(&self) -> &'static str {
|
||||
"BREAKATPOINT"
|
||||
}
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
match self.obj {
|
||||
None => Prompt::new("Select object", Accept::POINT),
|
||||
Some(_) => Prompt::new("Specify break point", Accept::POINT),
|
||||
}
|
||||
}
|
||||
/// Esc after the object is picked drops the selection the pick made, as Enter does.
|
||||
fn cancelled(&mut self, s: &mut Session) {
|
||||
if self.obj.is_some() {
|
||||
s.set_selection(Vec::new());
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
match (self.obj, i) {
|
||||
(None, Input::Point(p)) => {
|
||||
self.obj = pick_to_break(s, p)?;
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
(Some(h), Input::Point(p)) => break_and_end(s, h, p, p),
|
||||
(Some(_), Input::Enter) => {
|
||||
s.set_selection(Vec::new());
|
||||
Ok(Step::Done)
|
||||
}
|
||||
(None, Input::Enter) => Ok(Step::Done),
|
||||
(_, Input::Enter) => Ok(Step::Done),
|
||||
_ => Ok(Step::Continue),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,17 +21,14 @@ impl StretchArea {
|
||||
}
|
||||
}
|
||||
|
||||
/// 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();
|
||||
/// 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 };
|
||||
for e in store.iter() {
|
||||
if let EntityKind::MLine(m) = &e.kind
|
||||
&& crate::select::selectable(d, e, frozen)
|
||||
&& d.is_visible(e)
|
||||
&& !hs.contains(&e.handle)
|
||||
&& m.vertices.iter().any(|v| area.contains(v.p.xy()))
|
||||
{
|
||||
@@ -97,19 +94,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_in(s.doc()?, &space, s.viewport_frozen(), &fence);
|
||||
let hs = crate::select::select_fence(s.doc()?, &space, &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_in(s.doc()?, &space, s.viewport_frozen(), &poly, true), StretchArea::Polygon(poly))
|
||||
(crate::select::select_polygon(s.doc()?, &space, &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_in(s.doc()?, &space, s.viewport_frozen(), bx, true), StretchArea::Box(bx))
|
||||
(crate::select::select_window(s.doc()?, &space, bx, true), StretchArea::Box(bx))
|
||||
};
|
||||
add_mline_vertex_hits(s, &area, &mut hs);
|
||||
add_mline_vertex_hits(s.doc()?, &space, &area, &mut hs);
|
||||
hs.retain(|h| !crate::cmd::curves::is_locked(s, *h));
|
||||
let doc = s.doc_mut()?;
|
||||
let areas = [area];
|
||||
@@ -176,7 +173,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_in(s.doc()?, &space, s.viewport_frozen()) else { return Ok(()) };
|
||||
let Some(mut hs) = m.select(s.doc()?, &space) 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,
|
||||
@@ -192,7 +189,7 @@ impl StretchM {
|
||||
};
|
||||
let whole = area.is_none();
|
||||
if let (Some(a), true, false) = (&area, crossing, self.removing) {
|
||||
add_mline_vertex_hits(s, a, &mut hs);
|
||||
add_mline_vertex_hits(s.doc()?, &space, a, &mut hs);
|
||||
}
|
||||
if let (Some(a), false) = (area, self.removing) {
|
||||
self.windows.push(a);
|
||||
@@ -231,10 +228,10 @@ impl StretchM {
|
||||
Some(c) => {
|
||||
let bx = cadcraft_geom::Bounds2::new(c, p);
|
||||
let space = s.space();
|
||||
let mut hs = crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, p.x < c.x);
|
||||
let mut hs = crate::select::select_window(s.doc()?, &space, bx, p.x < c.x);
|
||||
if !self.removing {
|
||||
if p.x < c.x {
|
||||
add_mline_vertex_hits(s, &StretchArea::Box(bx), &mut hs);
|
||||
add_mline_vertex_hits(s.doc()?, &space, &StretchArea::Box(bx), &mut hs);
|
||||
}
|
||||
self.windows.push(StretchArea::Box(bx));
|
||||
}
|
||||
@@ -243,8 +240,7 @@ impl StretchM {
|
||||
None => {
|
||||
let aperture = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
|
||||
let space = s.space();
|
||||
// A removal names its object (`picks_one`): the named one is found, not another lying there.
|
||||
match s.pick_object(&space, p, aperture)? {
|
||||
match crate::select::pick(s.doc()?, &space, p, aperture) {
|
||||
Some(h) => self.add(s, vec![h], true),
|
||||
None => self.corner = Some(p),
|
||||
}
|
||||
@@ -255,7 +251,6 @@ 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();
|
||||
@@ -272,14 +267,9 @@ impl StretchM {
|
||||
self.removing = false;
|
||||
None
|
||||
}
|
||||
"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))
|
||||
}
|
||||
"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()),
|
||||
_ => {
|
||||
s.echo("*Invalid selection*");
|
||||
None
|
||||
@@ -324,16 +314,13 @@ impl Interactive for StretchM {
|
||||
s.echo("Select objects to stretch by crossing-window or crossing-polygon...");
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
/// Returns the active interactive prompt for the current `STRETCH` phase.
|
||||
fn prompt(&self, _s: &Session) -> Prompt {
|
||||
if let (StretchPhase::Select, Some(m)) = (self.phase, &self.mode) {
|
||||
return m.prompt();
|
||||
}
|
||||
match (self.phase, self.corner) {
|
||||
(StretchPhase::Select, Some(c)) => Prompt::new("Specify opposite corner", Accept::POINT).corner(c),
|
||||
(StretchPhase::Select, None) => {
|
||||
Prompt { picks_one: self.removing, ..Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT) }
|
||||
}
|
||||
(StretchPhase::Select, None) => Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT),
|
||||
(StretchPhase::Base, _) => Prompt::new("Specify base point", Accept::POINT).kw(&["Displacement"]).default("Displacement"),
|
||||
(StretchPhase::Displacement, _) => Prompt::new("Specify displacement", Accept::POINT).default("0,0"),
|
||||
(StretchPhase::Second, _) => Prompt::new("Specify second point or <use first point as displacement>", Accept::POINT).base_opt(self.base),
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
use cadcraft_geom::Bounds2;
|
||||
|
||||
use super::{
|
||||
Arc, EngineError, Entity, EntityKind, Handle, Line, PolyVertex, Polyline, Prim, Result, Segment, Session, TAU, Vec2, angle_in_sweep, arc,
|
||||
ccw_sweep, intersect_ext, line, lwpoly, norm_angle,
|
||||
@@ -93,62 +91,13 @@ fn prim_to_segments(p: &Prim) -> Vec<Segment> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Explain the generic line failures for JSON handle+pick calls, and a line TRIM picked on its
|
||||
/// only cuts ([`ON_THE_CUT`]). Other curves retain their own diagnostics: their nearest-parameter
|
||||
/// rules do not prove that a pick is invalid.
|
||||
pub(crate) fn json_pick_error(s: &Session, h: Handle, pick: Vec2, edges: Edges, extending: bool, error: EngineError) -> EngineError {
|
||||
let generic = if extending { "Object does not intersect an edge." } else { "Object does not intersect a cutting edge." };
|
||||
if !matches!(&error, EngineError::Other(message) if message == generic || (!extending && message == ON_THE_CUT)) {
|
||||
return error;
|
||||
}
|
||||
let Ok(d) = s.doc() else { return error };
|
||||
let Some(e) = d.entity(h) else { return error };
|
||||
let EntityKind::Line(l) = &e.kind else { return error };
|
||||
let Ok(cut) = edge_segments(s, edges, h) else { return error };
|
||||
let ln = Line::new(l.a.xy(), l.b.xy());
|
||||
let message = if extending {
|
||||
// The selected end already failed. Check the opposite end with the same ray and
|
||||
// forward-intersection rules before attributing the failure to the pick's end choice.
|
||||
let (fixed, end) = if pick.dist(ln.b) < pick.dist(ln.a) { (ln.b, ln.a) } else { (ln.a, ln.b) };
|
||||
let dir = (end - fixed).normalized();
|
||||
let ray = Segment::Line(Line::new(end, end + dir * 1e8));
|
||||
let opposite_hit = cut.iter().flat_map(|c| intersect_ext(&ray, c, false)).any(|x| (x - end).dot(dir) > 1e-9);
|
||||
if opposite_hit {
|
||||
"The `pick` point selects an end with no boundary ahead; choose `pick` toward the boundary to extend to."
|
||||
} else {
|
||||
"No usable boundary intersection was found for either end of the object to extend."
|
||||
}
|
||||
} else {
|
||||
let pick_param = ln.param_of(pick).clamp(0.0, 1.0);
|
||||
let has_cut = cut.iter().flat_map(|c| intersect_ext(&Segment::Line(ln), c, false)).any(|x| {
|
||||
let t = ln.param_of(x);
|
||||
t > 1e-9 && t < 1.0 - 1e-9
|
||||
});
|
||||
if !has_cut {
|
||||
"No usable cutting-edge intersection in the interior of the object to trim."
|
||||
} else if pick_param.is_nan() {
|
||||
return error;
|
||||
} else if !ln.at(pick_param).near(pick, 1e-9_f64.max(64.0 * f64::EPSILON * (1.0 + pick.len().max(ln.a.len()).max(ln.b.len())))) {
|
||||
"The `pick` point is off the line and projects onto a cutting intersection; pick away from that intersection."
|
||||
} else {
|
||||
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection."
|
||||
}
|
||||
};
|
||||
EngineError::Other(message.into())
|
||||
}
|
||||
|
||||
/// Trim `h` at the piece containing `pick`. Returns the handles that replace it.
|
||||
/// Trim `h` at the piece containing `pick`. Returns what it became: its pieces, `h` first
|
||||
/// ([`replace_with_pieces`]).
|
||||
pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Result<Vec<Handle>> {
|
||||
if crate::cmd::curves::is_locked(s, h) {
|
||||
return Err(EngineError::Other("The object is on a locked layer.".into()));
|
||||
}
|
||||
let e = s.doc()?.entity(h).map(|e| (**e).clone()).ok_or_else(|| EngineError::Other("no such object".into()))?;
|
||||
let cut = edge_segments(s, edges, h)?;
|
||||
// A polyline that is one of the edges (picked, or with every object in either mode) cuts
|
||||
// itself too.
|
||||
let itself = edges.only.is_none_or(|o| o.contains(&h));
|
||||
let pieces: Vec<EntityKind> = match &e.kind {
|
||||
EntityKind::Line(l) => {
|
||||
let ln = Line::new(l.a.xy(), l.b.xy());
|
||||
@@ -160,12 +109,10 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
|
||||
.collect();
|
||||
ts.sort_by(f64::total_cmp);
|
||||
let tp = ln.param_of(pick).clamp(0.0, 1.0);
|
||||
let found = ts.len();
|
||||
ts.retain(|t| (t - tp).abs() * ln.len() > ON_CUT);
|
||||
let lo = ts.iter().copied().filter(|t| *t < tp).fold(0.0, f64::max);
|
||||
let hi = ts.iter().copied().filter(|t| *t > tp).fold(1.0, f64::min);
|
||||
if lo == 0.0 && hi == 1.0 {
|
||||
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
|
||||
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
|
||||
}
|
||||
let mut v = Vec::new();
|
||||
if lo > 0.0 {
|
||||
@@ -184,14 +131,11 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
|
||||
let mut ts: Vec<f64> =
|
||||
cut.iter().flat_map(|c| intersect_ext(&seg, c, false)).map(param).filter(|t| *t > 1e-9 && *t < sweep - 1e-9).collect();
|
||||
ts.sort_by(f64::total_cmp);
|
||||
// A pick off the arc is at the end it is nearer, round the circle.
|
||||
let tp = crate::cmd::curves::seg_param(&seg, pick) * sweep;
|
||||
let found = ts.len();
|
||||
ts.retain(|t| (t - tp).abs() * ga.radius > ON_CUT);
|
||||
let tp = param(pick).min(sweep);
|
||||
let lo = ts.iter().copied().filter(|t| *t < tp).fold(0.0, f64::max);
|
||||
let hi = ts.iter().copied().filter(|t| *t > tp).fold(sweep, f64::min);
|
||||
if lo == 0.0 && hi == sweep {
|
||||
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
|
||||
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
|
||||
}
|
||||
let mut v = Vec::new();
|
||||
if lo > 0.0 {
|
||||
@@ -207,16 +151,10 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
|
||||
let mut angs: Vec<f64> = cut.iter().flat_map(|x| intersect_ext(&full, x, false)).map(|p| c.center.xy().angle_to(p)).collect();
|
||||
angs.sort_by(f64::total_cmp);
|
||||
angs.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
|
||||
let ap = c.center.xy().angle_to(pick);
|
||||
let found = angs.len();
|
||||
angs.retain(|a| {
|
||||
let d = norm_angle(a - ap);
|
||||
d.min(TAU - d) * c.radius > ON_CUT
|
||||
});
|
||||
if angs.len() < 2 {
|
||||
let why = if found >= 2 { ON_THE_CUT } else { "Circle must intersect cutting edges at two or more points." };
|
||||
return Err(EngineError::Other(why.into()));
|
||||
return Err(EngineError::Other("Circle must intersect cutting edges at two or more points.".into()));
|
||||
}
|
||||
let ap = c.center.xy().angle_to(pick);
|
||||
// The removed arc runs between the two intersections around the pick.
|
||||
let n = angs.len();
|
||||
let mut keep = None;
|
||||
@@ -229,10 +167,7 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
|
||||
}
|
||||
keep.into_iter().collect()
|
||||
}
|
||||
EntityKind::LwPolyline(p) => match trim_polyline(p, &cut, pick, itself)? {
|
||||
Some(pieces) => pieces,
|
||||
None => return Ok(vec![h]),
|
||||
},
|
||||
EntityKind::LwPolyline(p) => trim_polyline(p, &cut, pick)?,
|
||||
k => crate::cmd::modify2::trim_other(k, &cut, pick)?,
|
||||
};
|
||||
replace_with_pieces(s, h, pieces)
|
||||
@@ -246,20 +181,19 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
|
||||
/// in its middle keeps its handle on the piece from its start point, the piece to its end point is
|
||||
/// new; a circle broken or trimmed becomes an arc with the circle's handle.)
|
||||
///
|
||||
/// Each piece keeps what the object had beyond its outline ([`inherit`]). Dimensions attached to
|
||||
/// the object follow [`crate::assoc::follow_pieces`]. Its parametric constraints are removed: its
|
||||
/// new shape no longer meets them, and solving them again would move the objects they tie it to.
|
||||
/// Dimensions attached to the object follow [`crate::assoc::follow_pieces`]. Its parametric
|
||||
/// constraints are removed: its new shape no longer meets them, and solving them again would move
|
||||
/// the objects they tie it to.
|
||||
pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<EntityKind>) -> Result<Vec<Handle>> {
|
||||
let d = s.doc_mut()?;
|
||||
if pieces.is_empty() {
|
||||
let mut pieces = pieces.into_iter();
|
||||
let Some(first) = pieces.next() else {
|
||||
d.remove_entity(h);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
};
|
||||
let (Some(space), Some(old)) = (d.space_of(h), d.entity(h).cloned()) else {
|
||||
return Err(EngineError::Other("no such object".into()));
|
||||
};
|
||||
let mut pieces = pieces.into_iter().map(|k| inherit(&old.kind, k));
|
||||
let Some(first) = pieces.next() else { return Ok(Vec::new()) };
|
||||
d.modify_entity(h, |e| e.kind = first)?;
|
||||
let mut out = vec![h];
|
||||
for kind in pieces {
|
||||
@@ -279,31 +213,6 @@ pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<Entity
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// `piece`, cut from `source`, with what it keeps of it as AutoCAD 2024's BREAK and TRIM leave
|
||||
/// pieces: a line's Z along it, an arc's (or a circle's) centre Z, and a polyline's elevation,
|
||||
/// constant width and linetype generation.
|
||||
fn inherit(source: &EntityKind, mut piece: EntityKind) -> EntityKind {
|
||||
match (source, &mut piece) {
|
||||
(EntityKind::Line(s), EntityKind::Line(p)) => {
|
||||
let ln = Line::new(s.a.xy(), s.b.xy());
|
||||
if ln.len() > 0.0 {
|
||||
let z = |t: f64| s.a.z + (s.b.z - s.a.z) * t;
|
||||
p.a.z = z(ln.param_of(p.a.xy()));
|
||||
p.b.z = z(ln.param_of(p.b.xy()));
|
||||
}
|
||||
}
|
||||
(EntityKind::Arc(s), EntityKind::Arc(p)) => p.center.z = s.center.z,
|
||||
(EntityKind::Circle(s), EntityKind::Arc(p)) => p.center.z = s.center.z,
|
||||
(EntityKind::LwPolyline(s), EntityKind::LwPolyline(p)) => {
|
||||
p.elevation = s.elevation;
|
||||
p.const_width = s.const_width;
|
||||
p.plinegen = s.plinegen;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
piece
|
||||
}
|
||||
|
||||
/// Sub-polyline between length parameters `a` and `b` (open polylines).
|
||||
pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex> {
|
||||
let mut out: Vec<PolyVertex> = Vec::new();
|
||||
@@ -336,132 +245,15 @@ pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex>
|
||||
out
|
||||
}
|
||||
|
||||
/// Two line segments of a polyline within this sine of parallel run on as one, straight on or
|
||||
/// doubling back: the vertex between them doesn't cut it, and they don't cut each other. AutoCAD
|
||||
/// 2024 cuts at a bend of 1e-8 and not at one of 8e-9, whatever the lengths.
|
||||
const STRAIGHT: f64 = 1e-8;
|
||||
|
||||
/// Upper bounds on one trim's search for where a polyline crosses itself (hostile files): the pairs
|
||||
/// of segments searched (those the piece picked can reach, times those near them) and the
|
||||
/// crossings found. Past either the trim is refused, rather than made at some of its cuts.
|
||||
const MAX_SELF_PAIRS: usize = 1 << 24;
|
||||
const MAX_SELF_CROSSINGS: usize = 1 << 16;
|
||||
|
||||
/// How near a cut a pick is on it, along the object. AutoCAD 2024 trims nothing for a pick that
|
||||
/// near one of a polyline's own cuts, and passes over a cut by another edge, the trim running on
|
||||
/// across it, on lines, arcs and circles too. On open polylines from 1e-3 to 1e9 long it was within
|
||||
/// 5e-7, and 5.1e-7 away trimmed at the cut (around a closed rectangle it reached a little further,
|
||||
/// to 1e-6; on a line, further still, to 5e-4 on one 10 long).
|
||||
const ON_CUT: f64 = 5e-7;
|
||||
|
||||
/// The refusal when every cut was passed over ([`ON_CUT`]): the object meets an edge, at the pick,
|
||||
/// so Quick mode leaves it in place rather than erasing it as one no edge crosses.
|
||||
const ON_THE_CUT: &str = "The pick is on the cut: nothing to trim.";
|
||||
|
||||
/// AutoCAD 2024's refusal to trim a closed polyline cut at one point only.
|
||||
pub(crate) const CUT_ONCE: &str = "Curve must intersect cutting edges at least twice.";
|
||||
|
||||
/// Whether segments `a` and `b` of a polyline run on as one ([`STRAIGHT`]).
|
||||
fn runs_on(a: &Segment, b: &Segment) -> bool {
|
||||
let (Segment::Line(a), Segment::Line(b)) = (a, b) else { return false };
|
||||
let (u, v) = (a.b - a.a, b.b - b.a);
|
||||
u.cross(v).abs() < STRAIGHT * u.len() * v.len()
|
||||
}
|
||||
|
||||
/// Where a polyline that is one of the cutting edges cuts itself around segment `k`, the one
|
||||
/// picked, as lengths along it: at its vertices (every vertex of a closed one, its start included)
|
||||
/// but those it runs straight on through ([`runs_on`]), and, on `k` and the segments it runs
|
||||
/// straight on into, where another of its segments crosses them or a vertex of it (an end
|
||||
/// included) touches them. The piece picked lies within those segments, so crossings elsewhere
|
||||
/// don't bound it. AutoCAD 2024 trims a polyline that is one of the cutting edges at these.
|
||||
fn self_cuts(segs: &[Segment], closed: bool, k: usize) -> Result<Vec<f64>> {
|
||||
let n = segs.len();
|
||||
let mut starts = Vec::with_capacity(n);
|
||||
let mut acc = 0.0;
|
||||
for s in segs {
|
||||
starts.push(acc);
|
||||
acc += s.len();
|
||||
}
|
||||
let before = |i: usize| {
|
||||
if i > 0 {
|
||||
Some(i - 1)
|
||||
} else if closed {
|
||||
n.checked_sub(1)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
let after = |i: usize| {
|
||||
if i + 1 < n {
|
||||
Some(i + 1)
|
||||
} else if closed {
|
||||
Some(0)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
// Whether the polyline runs straight on through the vertex segment `i` starts at.
|
||||
let straight = |i: usize| matches!((before(i).and_then(|j| segs.get(j)), segs.get(i)), (Some(a), Some(b)) if runs_on(a, b));
|
||||
let mut ts: Vec<f64> = (usize::from(!closed)..n).filter(|i| !straight(*i)).filter_map(|i| starts.get(i).copied()).collect();
|
||||
let mut run = vec![k];
|
||||
let mut i = k;
|
||||
while let Some(j) = before(i).filter(|_| straight(i) && run.len() < n) {
|
||||
run.push(j);
|
||||
i = j;
|
||||
}
|
||||
let mut i = k;
|
||||
while let Some(j) = after(i).filter(|j| straight(*j) && run.len() < n) {
|
||||
run.push(j);
|
||||
i = j;
|
||||
}
|
||||
let boxes: Vec<_> = segs.iter().map(Segment::bounds).collect();
|
||||
let reach = run.iter().filter_map(|i| boxes.get(*i)).fold(Bounds2::EMPTY, |r, b| r.union(b));
|
||||
let near: Vec<usize> = (0..n).filter(|j| boxes.get(*j).is_some_and(|b| b.intersects(&reach))).collect();
|
||||
if run.len().saturating_mul(near.len()) > MAX_SELF_PAIRS {
|
||||
return Err(EngineError::Other("Too many segments to trim the polyline where it crosses itself.".into()));
|
||||
}
|
||||
// A crossing, or a vertex of another segment touching this one, cuts it; so does a crossing
|
||||
// where it runs straight on into the next. Two segments meeting at a vertex cut nothing more.
|
||||
// An open polyline's ends are no cuts, so a crossing that near one, in parameter, still cuts
|
||||
// it (those within 1e-9 of the ends along it are dropped later).
|
||||
let open_before = |i: usize| before(i).is_none() || straight(i);
|
||||
let open_after = |i: usize| after(i).is_none_or(straight);
|
||||
let cuts = |t: f64, i: usize| (t > 1e-9 && t < 1.0 - 1e-9) || (t <= 1e-9 && open_before(i)) || (t >= 1.0 - 1e-9 && open_after(i));
|
||||
let vertices = ts.len();
|
||||
for &i in &run {
|
||||
let (Some(a), Some(box_a), Some(a0)) = (segs.get(i), boxes.get(i), starts.get(i)) else { continue };
|
||||
for &j in &near {
|
||||
let (Some(b), Some(box_b)) = (segs.get(j), boxes.get(j)) else { continue };
|
||||
if j == i || runs_on(a, b) || !box_a.intersects(box_b) {
|
||||
continue;
|
||||
}
|
||||
for x in intersect_ext(a, b, false) {
|
||||
let t = param_on(a, x);
|
||||
if cuts(t, i) {
|
||||
ts.push(a0 + t * a.len());
|
||||
if ts.len() - vertices > MAX_SELF_CROSSINGS {
|
||||
return Err(EngineError::Other("Too many crossings to trim the polyline where it crosses itself.".into()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(ts)
|
||||
}
|
||||
|
||||
/// Trim a polyline at the piece containing `pick`, between the cuts by `cut` and, when it is one
|
||||
/// of the cutting edges (`itself`), by its own ([`self_cuts`]). `None`: the pick is on one of its
|
||||
/// own cuts ([`ON_CUT`]), which trims nothing.
|
||||
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itself: bool) -> Result<Option<Vec<EntityKind>>> {
|
||||
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> Result<Vec<EntityKind>> {
|
||||
let pl = Polyline { vertices: p.vertices.clone(), closed: p.closed };
|
||||
let segs = pl.segments();
|
||||
let total: f64 = segs.iter().map(Segment::len).sum();
|
||||
let mut ts: Vec<f64> = Vec::new();
|
||||
let mut acc = 0.0;
|
||||
// The pick's length along the polyline and the segment it is on.
|
||||
let (mut tp, mut k) = (0.0, 0);
|
||||
let mut tp = 0.0;
|
||||
let mut best = f64::INFINITY;
|
||||
for (i, s) in segs.iter().enumerate() {
|
||||
for s in &segs {
|
||||
let len = s.len();
|
||||
for x in cut.iter().flat_map(|c| intersect_ext(s, c, false)) {
|
||||
ts.push(acc + param_on(s, x) * len);
|
||||
@@ -470,34 +262,13 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itse
|
||||
if c.dist(pick) < best {
|
||||
best = c.dist(pick);
|
||||
tp = acc + param_on(s, c) * len;
|
||||
k = i;
|
||||
}
|
||||
acc += len;
|
||||
}
|
||||
let mut own = if itself { self_cuts(&segs, p.closed, k)? } else { Vec::new() };
|
||||
// An open polyline's ends cut nothing; a closed one's start vertex cuts it like any other (a
|
||||
// cut there is at 0 or at its length, which the pieces below take as one).
|
||||
if !p.closed {
|
||||
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
|
||||
own.retain(|t| *t > 1e-9 && *t < total - 1e-9);
|
||||
}
|
||||
// How far apart two lengths along the polyline are, round its start too when it is closed.
|
||||
let apart = |s: f64, t: f64| if p.closed { (s - t).abs().min(total - (s - t).abs()) } else { (s - t).abs() };
|
||||
// A pick on one of its own cuts trims nothing; a cut by another edge there is passed over, and
|
||||
// the piece runs on across it.
|
||||
if own.iter().any(|t| apart(*t, tp) <= ON_CUT) {
|
||||
return Ok(None);
|
||||
}
|
||||
let found = ts.len();
|
||||
ts.retain(|t| apart(*t, tp) > ON_CUT);
|
||||
let passed = ts.len() < found;
|
||||
ts.extend(own);
|
||||
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
|
||||
ts.sort_by(f64::total_cmp);
|
||||
if ts.is_empty() {
|
||||
return Err(EngineError::Other(if passed { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
|
||||
}
|
||||
if p.closed && ts.first().is_some_and(|f| ts.iter().all(|t| apart(*f, *t) <= ON_CUT)) {
|
||||
return Err(EngineError::Other(CUT_ONCE.into()));
|
||||
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
|
||||
}
|
||||
let lo = ts.iter().copied().filter(|t| *t < tp).fold(f64::NEG_INFINITY, f64::max);
|
||||
let hi = ts.iter().copied().filter(|t| *t > tp).fold(f64::INFINITY, f64::min);
|
||||
@@ -512,33 +283,33 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itse
|
||||
if hi.is_finite() { hi } else { ts.first().copied().unwrap_or(total) + total },
|
||||
);
|
||||
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
|
||||
let (a, b) = if hi > total { (hi - total, lo) } else { (hi, lo + total) };
|
||||
let (a, mut b) = if hi > total { (hi - total, lo) } else { (hi, lo + total) };
|
||||
// A single cut leaves the whole outline, opened there.
|
||||
if b <= a + 1e-9 {
|
||||
b += total;
|
||||
}
|
||||
out.push(mk(sub_polyline(&doubled, a, b)));
|
||||
} else {
|
||||
// A piece whose ends meet (the polyline touched itself there) is closed, without its
|
||||
// repeated vertex, as AutoCAD leaves it.
|
||||
let piece = |mut vs: Vec<PolyVertex>| {
|
||||
// Within rounding of the coordinates, however far from the origin, and no more. Two
|
||||
// spans close only when one is an arc: two lines there would run back on themselves.
|
||||
let spans = vs.len() >= 4 || (vs.len() == 3 && vs.iter().take(2).any(|v| v.bulge.abs() > 1e-12));
|
||||
let meets = spans
|
||||
&& matches!((vs.first(), vs.last()), (Some(a), Some(b)) if a.p.near(b.p, 64.0 * f64::EPSILON * (1.0 + a.p.len().max(b.p.len()))));
|
||||
if meets {
|
||||
vs.pop();
|
||||
}
|
||||
lwpoly(vs, meets)
|
||||
};
|
||||
if lo.is_finite() {
|
||||
out.push(piece(sub_polyline(&segs, 0.0, lo)));
|
||||
out.push(mk(sub_polyline(&segs, 0.0, lo)));
|
||||
}
|
||||
if hi.is_finite() {
|
||||
out.push(piece(sub_polyline(&segs, hi, total)));
|
||||
out.push(mk(sub_polyline(&segs, hi, total)));
|
||||
}
|
||||
}
|
||||
Ok(Some(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect()))
|
||||
Ok(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect())
|
||||
}
|
||||
|
||||
pub(super) use crate::cmd::curves::seg_param as param_on;
|
||||
pub(super) fn param_on(s: &Segment, p: Vec2) -> f64 {
|
||||
match s {
|
||||
Segment::Line(l) => l.param_of(p).clamp(0.0, 1.0),
|
||||
Segment::Arc { arc, ccw } => {
|
||||
let t = norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15);
|
||||
let t = t.clamp(0.0, 1.0);
|
||||
if *ccw { t } else { 1.0 - t }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A polyline arc segment on `ga`'s circle that ends at `end` after turning through `sweep`
|
||||
/// (signed, positive counterclockwise), run on round the circle to the nearest boundary edge: the
|
||||
@@ -601,13 +372,7 @@ pub(crate) fn extend(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Re
|
||||
EntityKind::LwPolyline(p) if !p.closed && p.vertices.len() >= 2 => {
|
||||
let mut vs = p.vertices.clone();
|
||||
let n = vs.len();
|
||||
// The pick's parameter: the segment it is nearest, plus how far along it. AutoCAD 2024
|
||||
// extends the end on that side of the polyline's middle parameter, the last from the
|
||||
// middle on, not the end nearer the pick. A repeated vertex counts as a segment, so
|
||||
// these come from the vertices, not `Polyline::segments`, which skips it.
|
||||
let spans: Vec<_> = vs.windows(2).filter_map(|w| Some((w.first()?.p, w.get(1)?.p, w.first()?.bulge))).collect();
|
||||
let at = crate::cmd::curves::vertex_param_of(&spans, pick);
|
||||
let from_end = 2.0 * at >= (n - 1) as f64;
|
||||
let from_end = vs.last().is_some_and(|l| pick.dist(l.p) < vs.first().map(|f| pick.dist(f.p)).unwrap_or(f64::INFINITY));
|
||||
let (i_end, i_prev) = if from_end { (n - 1, n - 2) } else { (0, 1) };
|
||||
let end = vs.get(i_end).map(|v| v.p).unwrap_or_default();
|
||||
let prev = vs.get(i_prev).map(|v| v.p).unwrap_or_default();
|
||||
|
||||
@@ -79,9 +79,7 @@ impl PlotterStore {
|
||||
}
|
||||
PlotterStore {
|
||||
list: || {
|
||||
let d = dir()?;
|
||||
crate::file_access::check_read(&d)?;
|
||||
let rd = match std::fs::read_dir(d) {
|
||||
let rd = match std::fs::read_dir(dir()?) {
|
||||
Ok(rd) => rd,
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
|
||||
Err(e) => return Err(e.to_string()),
|
||||
@@ -94,7 +92,6 @@ impl PlotterStore {
|
||||
},
|
||||
read: |n| {
|
||||
let p = file(n)?;
|
||||
crate::file_access::check_read(&p)?;
|
||||
let len = std::fs::metadata(&p).map_err(|e| format!("{n}: {e}"))?.len();
|
||||
if len > cadcraft_doc::MAX_PLOTTER_FILE as u64 {
|
||||
return Err(format!("{n}: the plotter configuration file is too large"));
|
||||
@@ -103,16 +100,10 @@ impl PlotterStore {
|
||||
},
|
||||
write: |n, t| {
|
||||
let p = file(n)?;
|
||||
// Checked before the folder it lives in is created. The temporary file sits beside it.
|
||||
crate::file_access::check_write(&p)?;
|
||||
std::fs::create_dir_all(dir()?).map_err(|e| e.to_string())?;
|
||||
crate::atomic_write::write_atomic(&p, t.as_bytes()).map_err(|e| format!("{n}: {e}"))
|
||||
},
|
||||
delete: |n| {
|
||||
let p = file(n)?;
|
||||
crate::file_access::check_write(&p)?;
|
||||
std::fs::remove_file(p).map_err(|e| format!("{n}: {e}"))
|
||||
},
|
||||
delete: |n| std::fs::remove_file(file(n)?).map_err(|e| format!("{n}: {e}")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -556,18 +547,11 @@ fn edit_device(cmd: &str, c: &mut PlotterConfig, p: &Value) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// List, read, change, load, export and delete plotter configurations; any file is held to the automation roots.
|
||||
fn run_plottermanager(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "plottermanager";
|
||||
let action = str_param(p, "action").unwrap_or("list").trim().to_ascii_lowercase();
|
||||
match action.as_str() {
|
||||
"list" => {
|
||||
// Under the roots a refused settings folder is an error, not a short list.
|
||||
if crate::file_access::current().is_some() {
|
||||
(store().list)().map_err(|e| bad(cmd, e))?;
|
||||
}
|
||||
Ok(json!({ "devices": devices().iter().map(summary).collect::<Vec<_>>() }))
|
||||
}
|
||||
"list" => Ok(json!({ "devices": devices().iter().map(summary).collect::<Vec<_>>() })),
|
||||
"get" => {
|
||||
let n = device_name(cmd, p)?;
|
||||
let c = find_device(&n).ok_or_else(|| unknown_device(cmd, &n))?;
|
||||
@@ -652,7 +636,6 @@ fn run_plottermanager(_s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Some(_path) => {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_write(_path).map_err(|e| bad(cmd, e))?;
|
||||
std::fs::write(_path, &text).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
|
||||
Ok(json!({ "name": name, "path": _path }))
|
||||
}
|
||||
|
||||
+376
-109
@@ -6,31 +6,22 @@ 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, Lineweight, Transparency};
|
||||
use cadcraft_doc::{EntityKind, Handle, Lineweight, Transparency};
|
||||
use cadcraft_geom::Vec3;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, str_param, targets};
|
||||
use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, point_value, 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?, 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("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("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()))),
|
||||
@@ -38,13 +29,6 @@ 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"])
|
||||
@@ -101,7 +85,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("rename", "Rename...", run_rename)
|
||||
.menu(&["Format", "Rename..."])
|
||||
.alias(&["ren", "-rename"])
|
||||
.params("{table: layer|linetype|style|dimstyle|block|mleaderstyle|tablestyle|view|ucs|vport, from, to}")
|
||||
.params("{table: layer|linetype|style|dimstyle|block|mleaderstyle|tablestyle|view|ucs, from, to}")
|
||||
.interactive(|_| Ok(Box::new(rename::RenameM::default()))),
|
||||
]
|
||||
}
|
||||
@@ -188,13 +172,10 @@ 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 {
|
||||
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))
|
||||
match t {
|
||||
Transparency::Percent(p) => json!(p),
|
||||
other => json!(other.name()),
|
||||
}
|
||||
}
|
||||
|
||||
/// "ByLayer", "ByBlock" or a percentage 0..=90 (a number, or a string such as "50" or "50%").
|
||||
@@ -208,6 +189,369 @@ 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);
|
||||
@@ -447,8 +791,6 @@ 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 => {
|
||||
@@ -484,13 +826,6 @@ 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);
|
||||
}
|
||||
@@ -519,19 +854,12 @@ 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.extend(attrib_text_styles(a)),
|
||||
EntityKind::AttDef(a) => out.push(a.text.style.clone()),
|
||||
EntityKind::Insert(i) => out.extend(i.attribs.iter().map(|a| a.text.style.clone())),
|
||||
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)),
|
||||
),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
@@ -539,11 +867,6 @@ 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();
|
||||
@@ -573,7 +896,6 @@ 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 {
|
||||
@@ -582,8 +904,6 @@ 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();
|
||||
@@ -633,14 +953,7 @@ 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,
|
||||
@@ -655,12 +968,6 @@ 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);
|
||||
}
|
||||
@@ -672,8 +979,7 @@ 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.clone()));
|
||||
o.insert("message".into(), json!(format!("Ignored invalid value for: {}", rejected.join(", "))));
|
||||
o.insert("ignored".into(), json!(rejected));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
@@ -704,44 +1010,6 @@ 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()))) {
|
||||
@@ -784,7 +1052,6 @@ 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"));
|
||||
@@ -995,7 +1262,7 @@ fn run_rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
"block" => rename::block(s, &from, &to)?,
|
||||
"mleaderstyle" | "multileaderstyle" => rename::simple(s, "mleaderstyle", &from, &to)?,
|
||||
"tablestyle" | "view" | "ucs" | "vport" => rename::simple(s, &table, &from, &to)?,
|
||||
"tablestyle" | "view" | "ucs" => rename::simple(s, &table, &from, &to)?,
|
||||
"style" | "textstyle" => {
|
||||
run_style_rename(s, &json!({ "from": from, "to": to }))?;
|
||||
}
|
||||
|
||||
@@ -93,8 +93,6 @@ pub(super) fn simple(s: &mut Session, table: &str, from: &str, to: &str) -> Resu
|
||||
"tablestyle" => d.table_styles.iter_mut().map(|t| &mut t.name).collect(),
|
||||
"view" => d.views.iter_mut().map(|t| &mut t.name).collect(),
|
||||
"ucs" => d.ucss.iter_mut().map(|t| &mut t.name).collect(),
|
||||
// A saved viewport configuration, every tile of it; never the one shown (`*Active`).
|
||||
"vport" => d.vports.iter_mut().filter(|v| !v.is_active()).map(|t| &mut t.name).collect(),
|
||||
_ => return Err(bad("rename", "unsupported table")),
|
||||
};
|
||||
if !to.eq_ignore_ascii_case(from) && names.iter().any(|n| n.eq_ignore_ascii_case(&to)) {
|
||||
@@ -136,47 +134,35 @@ const TYPES: &[(&str, Option<&str>, &str)] = &[
|
||||
("Plotstyle", None, "plot style"),
|
||||
("textStyle", Some("style"), "text style"),
|
||||
("Tablestyle", Some("tablestyle"), "table style"),
|
||||
("Ucs", Some("ucs"), "ucs"),
|
||||
("Ucs", Some("ucs"), "UCS"),
|
||||
("VIew", Some("view"), "view"),
|
||||
("VPort", Some("vport"), "viewport configuration"),
|
||||
("VPort", None, "viewport configuration"),
|
||||
];
|
||||
|
||||
/// The noun in "Cannot find …" and "Invalid … name.": AutoCAD 2024 writes "UCS" there, "ucs" in
|
||||
/// its prompts and in "A ucs named … already exists." (measured).
|
||||
fn title(noun: &str) -> &str {
|
||||
if noun == "ucs" { "UCS" } else { noun }
|
||||
}
|
||||
|
||||
/// Keyword-only: spaces separate inputs.
|
||||
const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
|
||||
/// A name: Space ends the input.
|
||||
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
|
||||
|
||||
fn any_named<'a>(mut names: impl Iterator<Item = &'a String>, name: &str) -> Option<String> {
|
||||
names.find(|n| n.eq_ignore_ascii_case(name)).cloned()
|
||||
fn any_named<'a>(mut names: impl Iterator<Item = &'a String>, name: &str) -> bool {
|
||||
names.any(|n| n.eq_ignore_ascii_case(name))
|
||||
}
|
||||
|
||||
/// The name as the drawing spells it of the `table` entry named `name` (without regard to case).
|
||||
fn stored(d: &Drawing, table: &str, name: &str) -> Option<String> {
|
||||
fn exists(d: &Drawing, table: &str, name: &str) -> bool {
|
||||
match table {
|
||||
"block" => d.block(name).map(|t| t.name.clone()),
|
||||
"layer" => d.layer(name).map(|t| t.name.clone()),
|
||||
"linetype" => d.linetype(name).map(|t| t.name.clone()),
|
||||
"style" => d.text_style(name).map(|t| t.name.clone()),
|
||||
"dimstyle" => d.dim_style(name).map(|t| t.name.clone()),
|
||||
"block" => d.block(name).is_some(),
|
||||
"layer" => d.layer(name).is_some(),
|
||||
"linetype" => d.linetype(name).is_some(),
|
||||
"style" => d.text_style(name).is_some(),
|
||||
"dimstyle" => d.dim_style(name).is_some(),
|
||||
"mleaderstyle" => any_named(d.mleader_styles.iter().map(|t| &t.name), name),
|
||||
"tablestyle" => any_named(d.table_styles.iter().map(|t| &t.name), name),
|
||||
"view" => any_named(d.views.iter().map(|t| &t.name), name),
|
||||
"ucs" => any_named(d.ucss.iter().map(|t| &t.name), name),
|
||||
"vport" => any_named(d.vports.iter().filter(|v| !v.is_active()).map(|t| &t.name), name),
|
||||
_ => Some(name.to_string()),
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
fn exists(d: &Drawing, table: &str, name: &str) -> bool {
|
||||
stored(d, table, name).is_some()
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
enum Stage {
|
||||
#[default]
|
||||
@@ -213,15 +199,6 @@ impl Interactive for RenameM {
|
||||
}
|
||||
}
|
||||
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
|
||||
// No new name is an invalid one (AutoCAD 2024, measured for layers, blocks, views and
|
||||
// viewport configurations).
|
||||
if i == Input::Enter
|
||||
&& let Stage::New(t, _) = &self.stage
|
||||
&& let Some((_, Some(_), noun)) = TYPES.get(*t)
|
||||
{
|
||||
s.echo(format!("Invalid {} name.", title(noun)));
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
if matches!(i, Input::Cancel | Input::Enter) {
|
||||
return Ok(if i == Input::Cancel { Step::Cancel } else { Step::Done });
|
||||
}
|
||||
@@ -240,41 +217,12 @@ impl Interactive for RenameM {
|
||||
self.stage = Stage::Old(t);
|
||||
return Ok(Step::Continue);
|
||||
};
|
||||
// AutoCAD 2024 ends -RENAME on an old name it won't rename (measured): "Invalid … name."
|
||||
// for a viewport configuration or block whose name starts with "*" (*Active,
|
||||
// *Model_Space, an anonymous block's *U0) and for linetypes ByLayer and ByBlock;
|
||||
// "Cannot rename …" and "*Invalid*" for layer 0 and linetype Continuous.
|
||||
let invalid = match *table {
|
||||
Some("vport" | "block") => name.starts_with('*'),
|
||||
Some("linetype") => name.eq_ignore_ascii_case("bylayer") || name.eq_ignore_ascii_case("byblock"),
|
||||
_ => false,
|
||||
};
|
||||
if invalid {
|
||||
s.echo(format!("Invalid {} name.", title(noun)));
|
||||
return Ok(Step::Done);
|
||||
if let Some(table) = table
|
||||
&& !exists(s.doc()?, table, &name)
|
||||
{
|
||||
self.stage = Stage::Old(t);
|
||||
return Err(EngineError::Other(format!("No {noun} named \"{name}\".")));
|
||||
}
|
||||
let fixed = match *table {
|
||||
Some("layer") => name == "0",
|
||||
Some("linetype") => name.eq_ignore_ascii_case("continuous"),
|
||||
_ => false,
|
||||
};
|
||||
if fixed {
|
||||
s.echo(format!("Cannot rename {} \"{name}\".", title(noun)));
|
||||
s.echo("*Invalid*");
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
// The old name as the drawing spells it: a new name in another case than that is a
|
||||
// rename, even when it is the old name as typed (AutoCAD 2024, measured).
|
||||
let name = match table {
|
||||
Some(table) => match stored(s.doc()?, table, &name) {
|
||||
Some(n) => n,
|
||||
None => {
|
||||
s.echo(format!("Cannot find {} \"{name}\".", title(noun)));
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
},
|
||||
None => name,
|
||||
};
|
||||
self.stage = Stage::New(t, name);
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
@@ -287,19 +235,6 @@ impl Interactive for RenameM {
|
||||
s.echo(format!("Renaming a {noun} is not available yet."));
|
||||
return Ok(Step::Done);
|
||||
};
|
||||
// AutoCAD 2024's messages, each ending the command (measured).
|
||||
if !valid_name(&name) {
|
||||
s.echo(format!("Invalid {} name.", title(noun)));
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
if !name.eq_ignore_ascii_case(&old) && exists(s.doc()?, table, &name) {
|
||||
s.echo(format!("A {noun} named \"{name}\" already exists."));
|
||||
s.echo("*Invalid*");
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
if name == old {
|
||||
return Ok(Step::Done);
|
||||
}
|
||||
match super::run_rename(s, &json!({ "table": table, "from": old, "to": name })) {
|
||||
Ok(_) => Ok(Step::Done),
|
||||
Err(e) => {
|
||||
|
||||
@@ -1,781 +0,0 @@
|
||||
//! `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.stored_selection();
|
||||
let mut cur = s.selection();
|
||||
for h in matched {
|
||||
if !cur.contains(&h) {
|
||||
cur.push(h);
|
||||
|
||||
@@ -99,21 +99,14 @@ pub(crate) fn similar(e: &Entity, r: &Entity, mode: u32) -> bool {
|
||||
&& (mode & NAME == 0 || same_text(object_name(e), object_name(r)))
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// The visible objects of the current space like any of `refs`.
|
||||
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() };
|
||||
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()
|
||||
store.iter().take(MAX_SCAN).filter(|e| d.is_visible(e) && refs.iter().any(|r| similar(e, r, mode))).map(|e| e.handle).collect()
|
||||
}
|
||||
|
||||
fn mode_param(s: &Session, p: &Value) -> Result<u32> {
|
||||
|
||||
@@ -238,7 +238,6 @@ fn read_link(id: &str, file: &std::path::Path) -> Result<String> {
|
||||
let path = file.display();
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_read(file).map_err(|e| bad(id, e))?;
|
||||
// The limit is enforced on the bytes read, not on reported metadata, so a device or FIFO
|
||||
// that misreports its length can't be buffered to EOF.
|
||||
let bytes = crate::capped_read::read_capped(file, MAX_LINK_BYTES).map_err(|e| bad(id, format!("{path}: {e}")))?;
|
||||
|
||||
@@ -514,7 +514,6 @@ pub(crate) fn table_csv(t: &Table, sep: char) -> String {
|
||||
fn write_text(path: &str, text: &str) -> Result<()> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
crate::file_access::check_write(path).map_err(|e| bad("tableexport", e))?;
|
||||
std::fs::write(path, text).map_err(|e| bad("tableexport", format!("{path}: {e}")))
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
|
||||
@@ -8,9 +8,8 @@ use cadcraft_doc::{Drawing, EntityKind, Handle};
|
||||
use cadcraft_geom::{Bounds2, Line, Vec2, line_line};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::curves::KW;
|
||||
use super::helpers::{line, lwpoly, rect_vertices};
|
||||
use super::modify::{CUT_ONCE, Edges, extend, json_pick_error, trim};
|
||||
use super::modify::{Edges, extend, trim};
|
||||
use super::{bad, point_param, points_param};
|
||||
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
|
||||
|
||||
@@ -32,10 +31,8 @@ fn proj_mode(s: &Session) -> i64 {
|
||||
}
|
||||
|
||||
/// Whether a trim error says the object meets no cutting edge (a Quick-mode trim then erases it).
|
||||
/// A closed polyline cut at one point meets one, and is left as it is.
|
||||
fn misses_edges(e: &EngineError) -> bool {
|
||||
let m = e.to_string();
|
||||
m.contains("intersect") && m != CUT_ONCE
|
||||
e.to_string().contains("intersect")
|
||||
}
|
||||
|
||||
/// Trim or extend `h` at `at`. A Quick-mode (`quick`) trim of an object no cutting edge crosses
|
||||
@@ -62,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_in(d, &space, s.viewport_frozen(), pts) {
|
||||
for h in crate::select::select_fence(d, &space, 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();
|
||||
@@ -84,11 +81,6 @@ fn fence(s: &mut Session, pts: &[Vec2], extending: bool, edges: Edges, quick: bo
|
||||
run_picks(s, work, extending, edges, quick, tol)
|
||||
}
|
||||
|
||||
/// How far along a segment from its end a crossing window's pick is kept: past the 5e-7 within
|
||||
/// which a pick is on a polyline's own cut at that vertex. A cut this near the end is taken as at
|
||||
/// the end, the pick landing just past it.
|
||||
const OFF_VERTEX: f64 = 1e-6;
|
||||
|
||||
/// Trim (or extend) every object a crossing window from `a` to `b` touches, picked at its point
|
||||
/// in the window nearest the first corner `a`.
|
||||
fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, quick: bool) -> Result<usize> {
|
||||
@@ -104,21 +96,14 @@ 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_in(d, &space, s.viewport_frozen(), bx, true) {
|
||||
for h in crate::select::select_window(d, &space, 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) {
|
||||
for w in pl.windows(2) {
|
||||
let (Some(p), Some(q)) = (w.first(), w.get(1)) else { continue };
|
||||
let seg = Line::new(*p, *q);
|
||||
// Kept off the segment's ends: a vertex, where two segments meet, is a cut of a
|
||||
// polyline that is one of its own edges, and a pick on a cut trims nothing. No
|
||||
// further than [`OFF_VERTEX`] (or `tol`, in a smaller window), so the pick stays
|
||||
// before a cut near the end, whatever the window's size.
|
||||
let e = (tol.min(OFF_VERTEX) / seg.len()).min(0.5);
|
||||
let cands = [seg.at(e), seg.at(1.0 - e), seg.at(seg.param_of(a).clamp(e, 1.0 - e))]
|
||||
.into_iter()
|
||||
.chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
|
||||
let cands = [*p, *q, seg.closest(a)].into_iter().chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
|
||||
for c in cands.filter(|c| inside(*c)) {
|
||||
if best.is_none_or(|b| c.dist(a) < b.dist(a)) {
|
||||
best = Some(c);
|
||||
@@ -188,6 +173,7 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
|
||||
let cmd = if extending { "extend" } else { "trim" };
|
||||
let only: Option<Vec<Handle>> =
|
||||
p.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(|v| v.as_str().and_then(Handle::parse_hex)).collect());
|
||||
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
|
||||
let quick = match p.get("mode") {
|
||||
None | Some(Value::Null) => false,
|
||||
Some(v) => match v.as_str().map(|m| m.trim().to_ascii_lowercase()).as_deref() {
|
||||
@@ -196,7 +182,6 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
|
||||
_ => return Err(bad(cmd, "`mode` must be \"quick\" or \"standard\"")),
|
||||
},
|
||||
};
|
||||
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
|
||||
let key = if extending { "extended" } else { "trimmed" };
|
||||
if p.get("fence").is_some_and(|v| !v.is_null()) {
|
||||
let pts = points_param(p, "fence")
|
||||
@@ -212,19 +197,8 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
|
||||
return Ok(json!({ key: n }));
|
||||
}
|
||||
let h = super::targets(s, p)?.first().copied().ok_or_else(|| bad(cmd, "`handle` is required"))?;
|
||||
let pick = point_param(p, "pick").ok_or_else(|| {
|
||||
bad(
|
||||
cmd,
|
||||
if extending {
|
||||
"`pick` ([x, y]) is required: point toward the boundary to extend to, selecting the nearer end"
|
||||
} else {
|
||||
"`pick` ([x, y]) is required: select the portion of the object to trim away"
|
||||
},
|
||||
)
|
||||
})?;
|
||||
// Diagnose only an existing single-pick JSON failure. Successful calls, Quick-mode
|
||||
// erasure, fence/crossing and the interactive command keep their existing behavior.
|
||||
let r = apply(s, h, pick, extending, edges, quick).map_err(|e| json_pick_error(s, h, pick, edges, extending, e))?;
|
||||
let pick = point_param(p, "pick").ok_or_else(|| bad(cmd, "`pick` ([x, y]) is required"))?;
|
||||
let r = apply(s, h, pick, extending, edges, quick)?;
|
||||
if extending { Ok(Value::Null) } else { Ok(json!({ "handles": r.iter().map(|h| h.hex()).collect::<Vec<_>>() })) }
|
||||
}
|
||||
|
||||
@@ -246,8 +220,6 @@ enum Stage {
|
||||
Edges(Vec<Handle>),
|
||||
/// Fence points so far.
|
||||
Fence(Vec<Vec2>),
|
||||
/// Quick mode's two-point fence, started by a pick in empty space: its first point.
|
||||
QuickFence(Vec2),
|
||||
/// A crossing window: its first corner once picked.
|
||||
Crossing(Option<Vec2>),
|
||||
Mode,
|
||||
@@ -384,12 +356,11 @@ impl Interactive for TrimM {
|
||||
None => Prompt::new("Specify first fence point", Accept::POINT),
|
||||
Some(l) => Prompt::new("Specify next fence point", Accept::POINT).kw(&["Undo"]).base(*l),
|
||||
},
|
||||
Stage::QuickFence(a) => Prompt::new("Specify next fence point", Accept::POINT).base(*a),
|
||||
Stage::Crossing(None) => Prompt::new("Specify first corner", Accept::POINT),
|
||||
Stage::Crossing(Some(_)) => Prompt::new("Specify opposite corner", Accept::POINT),
|
||||
Stage::Mode => {
|
||||
let msg = if self.extend { "Enter an extend mode option" } else { "Enter a trim mode option" };
|
||||
Prompt::new(msg, KW).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
|
||||
Prompt::new(msg, Accept::TEXT).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
|
||||
}
|
||||
Stage::Project => {
|
||||
let cur = match proj_mode(s) {
|
||||
@@ -397,9 +368,9 @@ impl Interactive for TrimM {
|
||||
2 => "View",
|
||||
_ => "Ucs",
|
||||
};
|
||||
Prompt::new("Enter a projection option", KW).kw(&["None", "Ucs", "View"]).default(cur)
|
||||
Prompt::new("Enter a projection option", Accept::TEXT).kw(&["None", "Ucs", "View"]).default(cur)
|
||||
}
|
||||
Stage::Edge => Prompt::new("Enter an implied edge extension mode", KW).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
|
||||
Stage::Edge => Prompt::new("Enter an implied edge extension mode", Accept::TEXT).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
|
||||
"Extend"
|
||||
} else {
|
||||
"No extend"
|
||||
@@ -484,16 +455,6 @@ impl Interactive for TrimM {
|
||||
}
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Stage::QuickFence(a) => {
|
||||
self.stage = Stage::Pick;
|
||||
if let Input::Point(b) = i {
|
||||
let r = self.step(s, |m, s| fence(s, &[a, b], extending, m.edges(quick, implied), quick).map(|_| ()));
|
||||
if let Err(e) = r {
|
||||
s.echo(e.to_string());
|
||||
}
|
||||
}
|
||||
Ok(Step::Continue)
|
||||
}
|
||||
Stage::Crossing(first) => {
|
||||
match (first, i) {
|
||||
(None, Input::Point(p)) => self.stage = Stage::Crossing(Some(p)),
|
||||
@@ -514,9 +475,8 @@ impl Interactive for TrimM {
|
||||
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
|
||||
let space = s.space();
|
||||
let Some(h) = s.pick_object(&space, p, ap)? else {
|
||||
// A pick in empty space starts a two-point fence in Quick mode (as in
|
||||
// AutoCAD, #1594) and a crossing window in Standard mode.
|
||||
self.stage = if quick { Stage::QuickFence(p) } else { Stage::Crossing(Some(p)) };
|
||||
// A pick in empty space opens a crossing window there.
|
||||
self.stage = Stage::Crossing(Some(p));
|
||||
return Ok(Step::Continue);
|
||||
};
|
||||
let r = self.step(s, |m, s| apply(s, h, p, extending, m.edges(quick, implied), quick).map(|_| ()));
|
||||
@@ -565,7 +525,6 @@ impl Interactive for TrimM {
|
||||
.windows(2)
|
||||
.filter_map(|w| Some(line(*w.first()?, *w.get(1)?)))
|
||||
.collect(),
|
||||
Stage::QuickFence(a) => vec![line(*a, c)],
|
||||
Stage::Crossing(Some(a)) => vec![lwpoly(rect_vertices(*a, c), true)],
|
||||
_ => Vec::new(),
|
||||
}
|
||||
|
||||
@@ -1,706 +0,0 @@
|
||||
//! 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, Space, 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?}`. A Z that is given
|
||||
/// must be a number (only a missing or null one is 0).
|
||||
fn point3(v: &Value) -> Option<Vec3> {
|
||||
let z = |z: Option<&Value>| match z {
|
||||
None | Some(Value::Null) => Some(0.0),
|
||||
Some(z) => z.as_f64(),
|
||||
};
|
||||
let p = if let Some(a) = v.as_array() {
|
||||
Vec3::new(a.first()?.as_f64()?, a.get(1)?.as_f64()?, z(a.get(2))?)
|
||||
} else {
|
||||
Vec3::new(v.get("x")?.as_f64()?, v.get("y")?.as_f64()?, z(v.get("z"))?)
|
||||
};
|
||||
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()))?;
|
||||
// Only new axes are refused out of the XY plane: a new origin alone keeps the axes the UCS
|
||||
// has, tilted or not, as the interactive Origin option does.
|
||||
if x.is_some() && !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();
|
||||
// Refused before the drawing is touched, so a refused save leaves it unmodified.
|
||||
let d = s.doc().map_err(|e| e.to_string())?;
|
||||
let replaced = exists(d, &n);
|
||||
if replaced && !replace {
|
||||
return Err(format!("UCS \"{n}\" already exists."));
|
||||
}
|
||||
if !replaced && d.ucss.len() >= MAX_NAMED {
|
||||
return Err(format!("A drawing keeps at most {MAX_NAMED} named UCSs."));
|
||||
}
|
||||
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(u) => *u = frame.record(&u.name.clone()),
|
||||
None => 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);
|
||||
if replaced {
|
||||
// A UCS that still carries the name but not the new frame (another space's current UCS, a
|
||||
// UCS Previous entry) is no longer that named UCS: it keeps its axes and loses the name.
|
||||
unname_where(d, |u| u.name.trim().eq_ignore_ascii_case(&kept) && UcsFrame::of(u).is_none_or(|f| !same_frame(&f, &frame)));
|
||||
}
|
||||
s.set_ucs(frame, &kept).map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Whether two frames are the same UCS to rounding (the rule the DXF reader and writer use to
|
||||
/// keep a current UCS's name).
|
||||
fn same_frame(a: &UcsFrame, b: &UcsFrame) -> bool {
|
||||
(a.origin - b.origin).len() <= 1e-9 + 1e-14 * a.origin.len() && (a.x - b.x).len() <= 1e-9 && (a.y - b.y).len() <= 1e-9
|
||||
}
|
||||
|
||||
/// Wherever a UCS is `stale` (model space's current UCS, every layout's, the UCS Previous
|
||||
/// histories) it keeps its axes and loses its name.
|
||||
fn unname_where(d: &mut Drawing, stale: impl Fn(&Ucs) -> bool) {
|
||||
let model = crate::ucs::current_frame(d, &Space::Model).record(&d.header.str("UCSNAME", ""));
|
||||
if stale(&model) {
|
||||
d.header.set_str("UCSNAME", "");
|
||||
}
|
||||
let unname = |u: &mut Ucs| {
|
||||
if stale(&*u) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/// 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.
|
||||
unname_where(s.doc_mut()?, |u| gone.iter().any(|g| g.eq_ignore_ascii_case(u.name.trim())));
|
||||
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));
|
||||
// Axes are directions: turned onto the current axes, never added to a (possibly far) origin.
|
||||
let axis = |a: Vec3| Vec3::new(a.dot(cur.x), a.dot(cur.y), a.dot(cur.z()));
|
||||
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 {
|
||||
// Still listed, so it can be found and deleted.
|
||||
out.push_str(&format!("\n\n{}\n Its axes are unusable.", u.name));
|
||||
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.x)),
|
||||
pt(axis(fr.y)),
|
||||
pt(axis(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,7 +55,6 @@ 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).
|
||||
|
||||
@@ -138,7 +138,7 @@ fn save(s: &mut Session, name: &str, window: Option<Bounds2>, snapshot: bool) ->
|
||||
let layer_state = snapshot.then(|| {
|
||||
let state = snapshot_name(name);
|
||||
d.layer_states.retain(|l| !l.name.eq_ignore_ascii_case(&state));
|
||||
d.layer_states.push(LayerState::new(state.clone(), d.layers.clone(), ""));
|
||||
d.layer_states.push(LayerState { name: state.clone(), layers: d.layers.clone() });
|
||||
state
|
||||
});
|
||||
if let Some(old) = &replaced {
|
||||
|
||||
@@ -8,12 +8,6 @@ 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 {
|
||||
@@ -41,8 +35,6 @@ 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
|
||||
@@ -74,7 +66,6 @@ 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(),
|
||||
}
|
||||
@@ -128,65 +119,13 @@ 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)),
|
||||
cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v.clone())),
|
||||
_ => 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()
|
||||
}
|
||||
|
||||
@@ -1,781 +0,0 @@
|
||||
//! The folders automation may read and write (#1472).
|
||||
//!
|
||||
//! `cadcraft-cli mcp --automation-read-root <dir> --automation-write-root <dir>` confines the files
|
||||
//! an agent's commands reach. [`AutomationRoots`] holds the two folders. While they are in force,
|
||||
//! every path a command reads goes through [`check_read`] and every path it writes through
|
||||
//! [`check_write`]:
|
||||
//!
|
||||
//! - The path is made absolute against the working directory, as the file system reads it. Its
|
||||
//! links are followed: for a file that doesn't exist yet, the links of its nearest existing
|
||||
//! folder, the rest of the path being plain names (`..` below a missing folder is refused, and so
|
||||
//! is a link that leads nowhere).
|
||||
//! - On Windows a network path (`\\server\share`, `\\?\UNC\...`), a device path (`\\.\...`) or a
|
||||
//! verbatim path that isn't a disk is refused before anything opens it, unless a root is already
|
||||
//! on that same server and share (or that same device or prefix). A link whose target is one of
|
||||
//! those is refused from the target text, before the link is followed. Opening such a path would
|
||||
//! contact a host the agent named.
|
||||
//! - The result must lie inside the root, compared by whole components (`/work2` isn't inside
|
||||
//! `/work`) and exactly: both sides have been through the file system, which gives each folder
|
||||
//! its real name, and a Windows folder can be case sensitive, with `Root` beside `root`.
|
||||
//! - Reads may lie under either root; writes only under the write root, and never at the write
|
||||
//! root itself (its save-style temporary file would be outside). A root given alone grants
|
||||
//! reads under it even when it is the write root; a read root grants no writes.
|
||||
//!
|
||||
//! Roots are in force on a thread inside [`confine`]. The MCP headless backend runs every call in
|
||||
//! it; without roots nothing is checked, so the app and the command line keep working everywhere.
|
||||
//!
|
||||
//! A path is checked, then opened: a process that can change the folders in between (swapping in
|
||||
//! a link) can still win that race. A network, device or non-disk verbatim path is not opened at
|
||||
//! all. The roots keep an agent to the files it was given; they don't guard against other
|
||||
//! programs on the computer.
|
||||
|
||||
pub mod commands;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::ffi::OsString;
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Read access or write access.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Access {
|
||||
Read,
|
||||
Write,
|
||||
}
|
||||
|
||||
/// The folders automation may read and write; a root left out grants no access of its kind.
|
||||
#[derive(Debug)]
|
||||
pub struct AutomationRoots {
|
||||
read: Option<PathBuf>,
|
||||
write: Option<PathBuf>,
|
||||
}
|
||||
|
||||
/// The folder at `path`, which must exist, made absolute with its links followed: what paths are
|
||||
/// compared with.
|
||||
fn open_root(path: &Path, access: Access) -> Result<PathBuf, String> {
|
||||
let kind = match access {
|
||||
Access::Read => "read",
|
||||
Access::Write => "write",
|
||||
};
|
||||
std::fs::canonicalize(path)
|
||||
.and_then(|p| if p.is_dir() { Ok(p) } else { Err(std::io::ErrorKind::NotADirectory.into()) })
|
||||
.map_err(|e| format!("cannot open the automation {kind} root `{}`: {e}", path.display()))
|
||||
}
|
||||
|
||||
impl AutomationRoots {
|
||||
/// The roots `read` and `write`, which must be existing folders; `None` when neither is given
|
||||
/// (nothing is confined then).
|
||||
pub fn new(read: Option<&Path>, write: Option<&Path>) -> Result<Option<Arc<Self>>, String> {
|
||||
if read.is_none() && write.is_none() {
|
||||
return Ok(None);
|
||||
}
|
||||
let read = read.map(|p| open_root(p, Access::Read)).transpose()?;
|
||||
let write = write.map(|p| open_root(p, Access::Write)).transpose()?;
|
||||
Ok(Some(Arc::new(Self { read, write })))
|
||||
}
|
||||
|
||||
/// The read root, absolute with its links followed.
|
||||
pub fn read_root(&self) -> Option<&Path> {
|
||||
self.read.as_deref()
|
||||
}
|
||||
|
||||
/// The write root, absolute with its links followed.
|
||||
pub fn write_root(&self) -> Option<&Path> {
|
||||
self.write.as_deref()
|
||||
}
|
||||
|
||||
/// May the file or folder at `path` be read (or written)? `Err` says why not.
|
||||
///
|
||||
/// A read may lie under either root: the read root, or the write root (files the agent may
|
||||
/// write it may also read back). A write may lie only under the write root, and not at the
|
||||
/// root itself, whose save-style temporary file would sit beside it. Its name must stand there
|
||||
/// too: a link outside pointing in is refused, since what is written beside the name (a
|
||||
/// drawing's `.bak`) or done to it (a delete) happens in the folder that holds it.
|
||||
///
|
||||
/// A path is taken as it is: turned into text on the way, a name that isn't text would name a
|
||||
/// different file.
|
||||
pub fn check(&self, given: impl AsRef<Path>, access: Access) -> Result<(), String> {
|
||||
let given = given.as_ref();
|
||||
let target = resolve(given, self)?;
|
||||
let path = given.display();
|
||||
if access == Access::Read {
|
||||
let roots = [self.read.as_ref(), self.write.as_ref()];
|
||||
if roots.iter().flatten().any(|r| inside(&target, r)) {
|
||||
return Ok(());
|
||||
}
|
||||
if roots.iter().all(|r| r.is_none()) {
|
||||
return Err(format!("automation filesystem access is not granted: read authority is absent: {path}"));
|
||||
}
|
||||
return Err(format!("automation path rejected: outside the read root (or the write root): {path}"));
|
||||
}
|
||||
let Some(folder) = self.write.as_ref() else {
|
||||
return Err(format!("automation filesystem access is not granted: write authority is absent: {path}"));
|
||||
};
|
||||
if !inside(&target, folder) {
|
||||
return Err(format!("automation path rejected: outside the write root {}: {path}", folder.display()));
|
||||
}
|
||||
// A write to the root itself would put its temporary file beside the root, outside it.
|
||||
if same(&target, folder) {
|
||||
return Err(format!("automation path rejected: the write root itself cannot be written: {path}"));
|
||||
}
|
||||
if !inside(&resolve(given.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(Path::new(".")), self)?, folder) {
|
||||
return Err(format!("automation path rejected: stands outside the write root {}: {path}", folder.display()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
/// The roots in force on this thread.
|
||||
static ROOTS: RefCell<Option<Arc<AutomationRoots>>> = const { RefCell::new(None) };
|
||||
}
|
||||
|
||||
/// Puts the roots it replaced back when dropped (also when `f` panics).
|
||||
struct Restore(Option<Arc<AutomationRoots>>);
|
||||
|
||||
impl Drop for Restore {
|
||||
/// Puts the roots it replaced back.
|
||||
fn drop(&mut self) {
|
||||
ROOTS.with(|r| *r.borrow_mut() = self.0.take());
|
||||
}
|
||||
}
|
||||
|
||||
/// Run `f` with `roots` in force on this thread (`None`: as things stand).
|
||||
pub fn confine<T>(roots: Option<&Arc<AutomationRoots>>, f: impl FnOnce() -> T) -> T {
|
||||
let previous = ROOTS.with(|r| r.replace(roots.cloned()));
|
||||
let _restore = Restore(previous);
|
||||
f()
|
||||
}
|
||||
|
||||
/// This thread's roots, if any.
|
||||
pub fn current() -> Option<Arc<AutomationRoots>> {
|
||||
ROOTS.with(|r| r.borrow().clone())
|
||||
}
|
||||
|
||||
/// May `path` be read here? Always, without roots in force.
|
||||
pub fn check_read(path: impl AsRef<Path>) -> Result<(), String> {
|
||||
current().map_or(Ok(()), |r| r.check(path, Access::Read))
|
||||
}
|
||||
|
||||
/// May `path` be written here? Always, without roots in force.
|
||||
pub fn check_write(path: impl AsRef<Path>) -> Result<(), String> {
|
||||
current().map_or(Ok(()), |r| r.check(path, Access::Write))
|
||||
}
|
||||
|
||||
/// `path` made absolute with its links followed; for a path that doesn't exist (yet), its nearest
|
||||
/// existing folder's links followed and the rest appended.
|
||||
///
|
||||
/// A Windows network, device or non-disk verbatim prefix is refused before any of that, unless
|
||||
/// `roots` already stands on the same server and share (or the same device or prefix).
|
||||
fn resolve(path: &Path, roots: &AutomationRoots) -> Result<PathBuf, String> {
|
||||
let shown = path.display();
|
||||
if path.as_os_str().is_empty() {
|
||||
return Err("automation path rejected: path is empty".into());
|
||||
}
|
||||
// Checked as given: making `…\NUL` absolute gives the device path `\\.\NUL` on Windows.
|
||||
if cfg!(windows) && path.components().any(|c| matches!(c, Component::Normal(n) if n.to_str().is_some_and(is_device_name))) {
|
||||
return Err(format!("automation path rejected: reserved device names are not allowed: {shown}"));
|
||||
}
|
||||
// Before `absolute` too: on Windows that call asks the system about the path.
|
||||
if let Some(why) = refused_prefix(path, roots) {
|
||||
return Err(format!("automation path rejected: {why}: {shown}"));
|
||||
}
|
||||
let absolute = std::path::absolute(path).map_err(|e| format!("automation path rejected: cannot resolve {shown}: {e}"))?;
|
||||
if let Some(why) = refused_prefix(&absolute, roots) {
|
||||
return Err(format!("automation path rejected: {why}: {shown}"));
|
||||
}
|
||||
// The names below the nearest existing folder, last first.
|
||||
let mut missing: Vec<OsString> = vec![];
|
||||
let mut at = absolute.as_path();
|
||||
loop {
|
||||
// A link to a network path is judged from the target text. Canonicalizing it would follow
|
||||
// the link and contact that host. Only Windows has those prefixes, so other targets skip
|
||||
// the walk.
|
||||
#[cfg(windows)]
|
||||
if let Some(why) = link_leads_to_refused_prefix(at, roots) {
|
||||
return Err(format!("automation path rejected: {why}: {shown}"));
|
||||
}
|
||||
match std::fs::canonicalize(at) {
|
||||
Ok(mut found) => {
|
||||
found.extend(missing.iter().rev());
|
||||
return Ok(found);
|
||||
}
|
||||
Err(e) => match std::fs::symlink_metadata(at) {
|
||||
Ok(m) if m.file_type().is_symlink() => return Err(format!("automation path rejected: a link that leads nowhere: {shown}")),
|
||||
// There, yet its real path can't be had (no permission): nothing to compare.
|
||||
Ok(_) => return Err(format!("automation path rejected: cannot resolve {shown}: {e}")),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(e) => return Err(format!("automation path rejected: cannot resolve {shown}: {e}")),
|
||||
},
|
||||
}
|
||||
let parent = at.parent();
|
||||
match (at.components().next_back(), parent) {
|
||||
(Some(Component::Normal(name)), Some(parent)) => {
|
||||
missing.push(name.to_os_string());
|
||||
at = parent;
|
||||
}
|
||||
(Some(Component::ParentDir), _) => {
|
||||
return Err(format!("automation path rejected: parent traversal below a folder that doesn't exist: {shown}"));
|
||||
}
|
||||
// Down to the root (or drive) and it doesn't exist either.
|
||||
_ => {
|
||||
let e = std::io::Error::from(std::io::ErrorKind::NotFound);
|
||||
return Err(format!("automation path rejected: cannot resolve {shown}: {e}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Why `path` must not be opened: it is a Windows network, device or non-disk verbatim path, and
|
||||
/// no root already uses that prefix. A local disk path returns `None`.
|
||||
///
|
||||
/// The comparison is ASCII case only, so `FileServer` matches `fileserver` and U+212A does not
|
||||
/// match `k`. Matching only decides whether that host may be contacted; [`inside`] still decides
|
||||
/// the folder.
|
||||
fn refused_prefix(path: &Path, roots: &AutomationRoots) -> Option<&'static str> {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
let key = windows_prefix(path)?;
|
||||
let allowed = [roots.read.as_ref(), roots.write.as_ref()]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.any(|root| windows_prefix(root).is_some_and(|root_key| prefixes_match(&root_key, &key)));
|
||||
if allowed { None } else { Some(key.refusal()) }
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
let _ = (path, roots);
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// The refusal for a link in `path`, taken from the link's own text.
|
||||
///
|
||||
/// Folders are inspected from the root downward with [`std::fs::symlink_metadata`], which does not
|
||||
/// follow a link, and the target is read with [`std::fs::read_link`]. A link to a network path is
|
||||
/// therefore refused before [`std::fs::canonicalize`] would open that host, including when the
|
||||
/// link is only an ancestor of the name. At most [`MAX_LINK_HOPS`] links are followed; one more,
|
||||
/// or a link whose target cannot be read, is refused instead of being opened.
|
||||
#[cfg(windows)]
|
||||
fn link_leads_to_refused_prefix(path: &Path, roots: &AutomationRoots) -> Option<&'static str> {
|
||||
follow_links(path, roots, MAX_LINK_HOPS)
|
||||
}
|
||||
|
||||
/// [`link_leads_to_refused_prefix`], with `hops_left` links still allowed.
|
||||
#[cfg(windows)]
|
||||
fn follow_links(path: &Path, roots: &AutomationRoots, hops_left: usize) -> Option<&'static str> {
|
||||
if let Some(why) = refused_prefix(path, roots) {
|
||||
return Some(why);
|
||||
}
|
||||
let mut ancestors: Vec<&Path> = path.ancestors().collect();
|
||||
ancestors.reverse();
|
||||
for prefix in ancestors {
|
||||
// A relative path's ancestor list ends at an empty name. Absolute paths, which are all
|
||||
// this is called with, have no empty ancestor; skip it rather than treating it as missing.
|
||||
if prefix.as_os_str().is_empty() {
|
||||
continue;
|
||||
}
|
||||
if let Some(why) = refused_prefix(prefix, roots) {
|
||||
return Some(why);
|
||||
}
|
||||
let Ok(meta) = std::fs::symlink_metadata(prefix) else { return None };
|
||||
if !meta.file_type().is_symlink() {
|
||||
continue;
|
||||
}
|
||||
if hops_left == 0 {
|
||||
return Some("too many links");
|
||||
}
|
||||
let Ok(target) = std::fs::read_link(prefix) else { return Some("a link that leads nowhere") };
|
||||
let joined = if target.is_absolute() {
|
||||
target
|
||||
} else {
|
||||
match prefix.parent() {
|
||||
Some(parent) if !parent.as_os_str().is_empty() => parent.join(target),
|
||||
_ => target,
|
||||
}
|
||||
};
|
||||
let rest = match path.strip_prefix(prefix) {
|
||||
Ok(rest) if !rest.as_os_str().is_empty() => rest,
|
||||
_ => Path::new(""),
|
||||
};
|
||||
let next = if rest.as_os_str().is_empty() { joined } else { joined.join(rest) };
|
||||
if let Some(why) = refused_prefix(&next, roots) {
|
||||
return Some(why);
|
||||
}
|
||||
return follow_links(&next, roots, hops_left - 1);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// How many links [`link_leads_to_refused_prefix`] follows before it stops.
|
||||
#[cfg(windows)]
|
||||
const MAX_LINK_HOPS: usize = 40;
|
||||
|
||||
/// A Windows prefix that is not a local disk.
|
||||
#[cfg(windows)]
|
||||
enum WindowsPrefix {
|
||||
/// `\\server\share` or `\\?\UNC\server\share`.
|
||||
Unc(OsString, OsString),
|
||||
/// `\\.\device`.
|
||||
Device(OsString),
|
||||
/// `\\?\` that is neither a disk nor `UNC`.
|
||||
Verbatim(OsString),
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
impl WindowsPrefix {
|
||||
/// The error text for a path with this prefix.
|
||||
fn refusal(&self) -> &'static str {
|
||||
match self {
|
||||
Self::Unc(_, _) => "UNC paths are refused unless a root is on the same server and share",
|
||||
Self::Device(_) => "device paths are refused unless a root uses the same device",
|
||||
Self::Verbatim(_) => "verbatim paths are refused unless a root uses the same prefix",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `path`'s Windows prefix when it is not a local disk.
|
||||
#[cfg(windows)]
|
||||
fn windows_prefix(path: &Path) -> Option<WindowsPrefix> {
|
||||
use std::path::Prefix;
|
||||
let Component::Prefix(prefix) = path.components().next()? else { return None };
|
||||
match prefix.kind() {
|
||||
Prefix::Disk(_) | Prefix::VerbatimDisk(_) => None,
|
||||
Prefix::UNC(server, share) | Prefix::VerbatimUNC(server, share) => Some(WindowsPrefix::Unc(server.to_os_string(), share.to_os_string())),
|
||||
Prefix::DeviceNS(device) => Some(WindowsPrefix::Device(device.to_os_string())),
|
||||
Prefix::Verbatim(rest) => Some(WindowsPrefix::Verbatim(rest.to_os_string())),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether `path` may be opened because `root` already stands on the same server and share,
|
||||
/// device or verbatim prefix. ASCII case only.
|
||||
#[cfg(windows)]
|
||||
fn prefixes_match(root: &WindowsPrefix, path: &WindowsPrefix) -> bool {
|
||||
let same = |a: &std::ffi::OsStr, b: &std::ffi::OsStr| a.eq_ignore_ascii_case(b);
|
||||
match (root, path) {
|
||||
(WindowsPrefix::Unc(server, share), WindowsPrefix::Unc(path_server, path_share)) => same(server, path_server) && same(share, path_share),
|
||||
(WindowsPrefix::Device(root_device), WindowsPrefix::Device(path_device)) => same(root_device, path_device),
|
||||
(WindowsPrefix::Verbatim(root_prefix), WindowsPrefix::Verbatim(path_prefix)) => same(root_prefix, path_prefix),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Is `path` (resolved) `root` or inside it, component by component?
|
||||
fn inside(path: &Path, root: &Path) -> bool {
|
||||
let mut path = path.components();
|
||||
root.components().all(|r| path.next() == Some(r))
|
||||
}
|
||||
|
||||
/// Is `path` (resolved) exactly `root`, compared like [`inside`] does?
|
||||
fn same(path: &Path, root: &Path) -> bool {
|
||||
path.components().eq(root.components())
|
||||
}
|
||||
|
||||
/// A Windows device name (`CON`, `NUL`, `COM1`, `LPT¹`… also with an extension or a `:`), which
|
||||
/// names no file.
|
||||
fn is_device_name(component: &str) -> bool {
|
||||
let stem = component.split(['.', ':']).next().unwrap_or(component).trim_end_matches(' ').to_ascii_uppercase();
|
||||
let numbered = |prefix: &str| {
|
||||
stem.strip_prefix(prefix).is_some_and(|n| matches!(n, "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "¹" | "²" | "³"))
|
||||
};
|
||||
matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CLOCK$" | "CONIN$" | "CONOUT$") || numbered("COM") || numbered("LPT")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A folder of a test's own, removed when the test ends, also when it fails.
|
||||
struct TestDir(PathBuf);
|
||||
|
||||
impl std::ops::Deref for TestDir {
|
||||
type Target = Path;
|
||||
/// The folder itself.
|
||||
fn deref(&self) -> &Path {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TestDir {
|
||||
/// Removes the folder and all it holds; a failure here must not hide the test's own.
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// A new folder of this test's own: made here, so nothing else put it there first.
|
||||
fn fresh_dir(tag: &str) -> TestDir {
|
||||
let mut n = 0u32;
|
||||
loop {
|
||||
let dir = std::env::temp_dir().join(format!("cc-file-access-{tag}-{}-{n}", std::process::id()));
|
||||
match std::fs::create_dir(&dir) {
|
||||
Ok(()) => return TestDir(dir),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
|
||||
Err(e) => panic!("{}: {e}", dir.display()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A fresh folder holding `in` (read root), `out` (write root) and `outside`.
|
||||
fn folders(name: &str) -> (TestDir, Arc<AutomationRoots>) {
|
||||
let base = fresh_dir(name);
|
||||
for d in ["in/sub", "out", "outside", "in2"] {
|
||||
std::fs::create_dir_all(base.join(d)).unwrap();
|
||||
}
|
||||
std::fs::write(base.join("in/a.dxf"), "0\nEOF\n").unwrap();
|
||||
std::fs::write(base.join("outside/secret.dxf"), "0\nEOF\n").unwrap();
|
||||
let roots = AutomationRoots::new(Some(&base.join("in")), Some(&base.join("out"))).unwrap().unwrap();
|
||||
(base, roots)
|
||||
}
|
||||
|
||||
/// `p` as a string a command would pass.
|
||||
fn s(p: PathBuf) -> String {
|
||||
p.to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
/// Paths under either root may be read; writes stay inside the write root.
|
||||
#[test]
|
||||
fn paths_inside_the_roots_pass_and_others_dont() {
|
||||
let (base, roots) = folders("inside");
|
||||
assert_eq!(roots.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
|
||||
assert_eq!(roots.check(s(base.join("in")), Access::Read), Ok(()), "the root itself");
|
||||
assert_eq!(roots.check(s(base.join("in/sub/new.dxf")), Access::Read), Ok(()), "missing files are checked by their folder");
|
||||
assert_eq!(roots.check(s(base.join("out/new/deeper/x.png")), Access::Write), Ok(()), "and by their nearest folder");
|
||||
let e = roots.check(s(base.join("outside/secret.dxf")), Access::Read).unwrap_err();
|
||||
assert!(e.starts_with("automation path rejected: outside the read root"), "{e}");
|
||||
// Reads are allowed under the write root too; writes are not allowed under the read root.
|
||||
assert_eq!(roots.check(s(base.join("out/x.png")), Access::Read), Ok(()), "the write root also grants reads");
|
||||
let e = roots.check(s(base.join("in/a.dxf")), Access::Write).unwrap_err();
|
||||
assert!(e.contains("outside the write root"), "{e}");
|
||||
}
|
||||
|
||||
/// A write-only root still permits reads inside it; reads outside both roots are refused.
|
||||
#[test]
|
||||
fn reads_are_allowed_under_either_root() {
|
||||
let (base, _) = folders("either");
|
||||
let write_only = AutomationRoots::new(None, Some(&base.join("out"))).unwrap().unwrap();
|
||||
assert_eq!(write_only.check(s(base.join("out/new.dxf")), Access::Read), Ok(()), "a file to read back");
|
||||
let e = write_only.check(s(base.join("in/a.dxf")), Access::Read).unwrap_err();
|
||||
assert!(e.contains("outside the read root (or the write root)"), "{e}");
|
||||
let read_only = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
|
||||
assert_eq!(read_only.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
|
||||
assert!(read_only.check(s(base.join("out/new.dxf")), Access::Read).is_err(), "a read root alone grants no read of another folder");
|
||||
}
|
||||
|
||||
/// A write to the write root itself would put its `.cadcraft-tmp` file beside the root: refused.
|
||||
#[test]
|
||||
fn writing_to_the_write_root_itself_is_refused() {
|
||||
let (base, roots) = folders("write-root");
|
||||
let out = s(base.join("out"));
|
||||
let sep = std::path::MAIN_SEPARATOR;
|
||||
for p in [out.clone(), format!("{out}{sep}."), format!("{out}{sep}..{sep}out")] {
|
||||
let e = roots.check(&p, Access::Write).unwrap_err();
|
||||
assert!(e.contains("the write root itself cannot be written"), "{p}: {e}");
|
||||
}
|
||||
assert_eq!(roots.check(&out, Access::Read), Ok(()), "reading the root stays allowed");
|
||||
assert_eq!(roots.check(s(base.join("out/new/x.png")), Access::Write), Ok(()), "a normal save inside still works");
|
||||
}
|
||||
|
||||
/// `in2` starts like `in` and isn't inside it.
|
||||
#[test]
|
||||
fn a_sibling_with_the_same_prefix_is_outside() {
|
||||
let (base, roots) = folders("prefix");
|
||||
std::fs::write(base.join("in2/b.dxf"), "0\nEOF\n").unwrap();
|
||||
assert!(roots.check(s(base.join("in2/b.dxf")), Access::Read).is_err(), "in2 is not inside in");
|
||||
assert!(roots.check(format!("{}2/c.dxf", s(base.join("in"))), Access::Read).is_err());
|
||||
}
|
||||
|
||||
/// `..` is followed where it can be, and refused below a missing folder.
|
||||
#[test]
|
||||
fn parent_traversal_is_resolved_or_refused() {
|
||||
let (base, roots) = folders("dotdot");
|
||||
let sep = std::path::MAIN_SEPARATOR;
|
||||
let up = format!("{}{sep}..{sep}outside{sep}secret.dxf", s(base.join("in")));
|
||||
assert!(roots.check(&up, Access::Read).unwrap_err().contains("outside the read root"), "`..` out of the root");
|
||||
let back = format!("{}{sep}..{sep}a.dxf", s(base.join("in/sub")));
|
||||
assert_eq!(roots.check(&back, Access::Read), Ok(()), "`..` that stays inside");
|
||||
let missing = format!("{}{sep}nope{sep}..{sep}..{sep}outside{sep}x.dxf", s(base.join("out")));
|
||||
let e = roots.check(&missing, Access::Write).unwrap_err();
|
||||
// Windows resolves `..` by name first (so does opening the file there): then it's outside.
|
||||
assert!(e.contains("parent traversal below a folder that doesn't exist") || e.contains("outside the write root"), "{e}");
|
||||
}
|
||||
|
||||
/// A relative path means the working directory, and an empty one is refused.
|
||||
#[test]
|
||||
fn relative_paths_resolve_against_the_working_directory() {
|
||||
let (_base, roots) = folders("relative");
|
||||
// The tests' working directory is the crate's folder: not inside the roots.
|
||||
assert!(roots.check("a.dxf", Access::Read).unwrap_err().contains("outside the read root"));
|
||||
assert!(roots.check("", Access::Read).unwrap_err().contains("path is empty"));
|
||||
}
|
||||
|
||||
/// A root must be a folder that exists; no roots at all confines nothing.
|
||||
#[test]
|
||||
fn a_missing_root_is_an_error_and_none_is_no_confinement() {
|
||||
let (base, _) = folders("missing");
|
||||
let e = AutomationRoots::new(Some(&base.join("nope")), None).unwrap_err();
|
||||
assert!(e.starts_with("cannot open the automation read root"), "{e}");
|
||||
let e = AutomationRoots::new(None, Some(&base.join("in/a.dxf"))).unwrap_err();
|
||||
assert!(
|
||||
e.starts_with("cannot open the automation write root")
|
||||
&& e.ends_with(&std::io::Error::from(std::io::ErrorKind::NotADirectory).to_string()),
|
||||
"{e}"
|
||||
);
|
||||
assert!(AutomationRoots::new(Some(Path::new("")), None).unwrap_err().starts_with("cannot open the automation read root ``"));
|
||||
assert!(AutomationRoots::new(None, None).unwrap().is_none());
|
||||
// One root alone grants only its own access.
|
||||
let read_only = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
|
||||
let e = read_only.check(s(base.join("in/x.dxf")), Access::Write).unwrap_err();
|
||||
assert!(e.contains("write authority is absent"), "{e}");
|
||||
}
|
||||
|
||||
/// Links are judged by where they lead, so a link out is refused and one inside is fine.
|
||||
#[test]
|
||||
fn links_are_followed_before_comparing() {
|
||||
let (base, roots) = folders("links");
|
||||
#[cfg(unix)]
|
||||
let made = |target: &Path, link: &Path| std::os::unix::fs::symlink(target, link).is_ok();
|
||||
#[cfg(windows)]
|
||||
let made = |target: &Path, link: &Path| {
|
||||
let made =
|
||||
if target.is_dir() { std::os::windows::fs::symlink_dir(target, link) } else { std::os::windows::fs::symlink_file(target, link) };
|
||||
made.is_ok()
|
||||
};
|
||||
#[cfg(not(any(unix, windows)))]
|
||||
let made = |_: &Path, _: &Path| false;
|
||||
// Windows needs Developer Mode or elevation to make links: nothing to test without them.
|
||||
if !made(&base.join("outside/secret.dxf"), &base.join("in/leak.dxf")) {
|
||||
eprintln!("skipped: symbolic links can't be made here");
|
||||
return;
|
||||
}
|
||||
assert!(roots.check(s(base.join("in/leak.dxf")), Access::Read).unwrap_err().contains("outside the read root"), "a file link out");
|
||||
assert!(made(&base.join("outside"), &base.join("out/away")));
|
||||
let e = roots.check(s(base.join("out/away/new.png")), Access::Write).unwrap_err();
|
||||
assert!(e.contains("outside the write root"), "a folder link out: {e}");
|
||||
assert!(made(&base.join("outside/gone.dxf"), &base.join("out/dangling.png")));
|
||||
let e = roots.check(s(base.join("out/dangling.png")), Access::Write).unwrap_err();
|
||||
assert!(e.contains("a link that leads nowhere"), "writing would create the file outside: {e}");
|
||||
// A link to a folder inside the root stays inside.
|
||||
assert!(made(&base.join("in/sub"), &base.join("in/alias")));
|
||||
assert_eq!(roots.check(s(base.join("in/alias/x.dxf")), Access::Read), Ok(()));
|
||||
// A root given through a link is the folder it leads to.
|
||||
assert!(made(&base.join("in"), &base.join("in-link")));
|
||||
let linked = AutomationRoots::new(Some(&base.join("in-link")), None).unwrap().unwrap();
|
||||
assert_eq!(linked.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
|
||||
}
|
||||
|
||||
/// Names are compared exactly: `Root` isn't `root`, which a case-sensitive folder can hold beside it.
|
||||
#[test]
|
||||
fn a_name_differing_only_in_case_is_not_the_root() {
|
||||
assert!(!inside(Path::new("/w/Root/x"), Path::new("/w/root")));
|
||||
assert!(!same(Path::new("/w/Root"), Path::new("/w/root")));
|
||||
assert!(inside(Path::new("/w/root/x"), Path::new("/w/root")));
|
||||
assert!(same(Path::new("/w/root"), Path::new("/w/root")));
|
||||
}
|
||||
|
||||
/// The superscript ports, `COM0`, `LPT0` and the `:` form are device names.
|
||||
#[test]
|
||||
fn device_names_include_the_superscript_ports() {
|
||||
for d in ["CON", "nul", "Com1", "LPT9.txt", "aux.dxf", "NUL ", "COM¹", "lpt³.txt", "com²", "NUL:", "con:stream", "COM0", "lpt0.txt"] {
|
||||
assert!(is_device_name(d), "{d}");
|
||||
}
|
||||
for d in ["console.txt", "COM", "COM10", "LPT⁴", "a.nul", "nullable"] {
|
||||
assert!(!is_device_name(d), "{d}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A name that isn't text is checked as itself: the text of it names a file that isn't there,
|
||||
/// which would pass, when the name itself is a link leading out.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_name_that_is_not_text_is_judged_as_itself() {
|
||||
use std::os::unix::ffi::OsStrExt;
|
||||
let (base, roots) = folders("not-text");
|
||||
let name = std::ffi::OsStr::from_bytes(b"a\xff.dxf");
|
||||
let link = base.join("in").join(name);
|
||||
// APFS and others refuse such a name: nothing to test there.
|
||||
if std::os::unix::fs::symlink(base.join("outside/secret.dxf"), &link).is_err() {
|
||||
eprintln!("skipped: this file system refuses a name that isn't text");
|
||||
return;
|
||||
}
|
||||
assert!(roots.check(&link, Access::Read).is_err());
|
||||
assert_eq!(roots.check(&*link.to_string_lossy(), Access::Read), Ok(()), "as text it is another file, which isn't there");
|
||||
}
|
||||
|
||||
/// A name is judged by the folder it stands in as well as by where it leads.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn a_link_standing_outside_the_write_root_is_refused() {
|
||||
let (base, roots) = folders("entry");
|
||||
std::fs::write(base.join("out/t.dxf"), "x").unwrap();
|
||||
let link = base.join("outside/link.dxf");
|
||||
std::os::unix::fs::symlink(base.join("out/t.dxf"), &link).unwrap();
|
||||
assert!(roots.check(&link, Access::Write).unwrap_err().contains("stands outside the write root"));
|
||||
assert_eq!(roots.check(&link, Access::Read), Ok(()), "reading it reads what is inside");
|
||||
let inner = base.join("out/link.dxf");
|
||||
std::os::unix::fs::symlink(base.join("out/t.dxf"), &inner).unwrap();
|
||||
assert_eq!(roots.check(&inner, Access::Write), Ok(()));
|
||||
assert_eq!(roots.check(base.join("out/new/deep/x.dxf"), Access::Write), Ok(()));
|
||||
}
|
||||
|
||||
/// On a real case-sensitive folder, `Root` beside the root `root` is outside it.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_case_sensitive_windows_folder_can_hold_a_sibling_of_the_root() {
|
||||
let base = fresh_dir("sensitive");
|
||||
let sensitive = std::process::Command::new("fsutil").args(["file", "setCaseSensitiveInfo"]).arg(&*base).arg("enable").output();
|
||||
if !sensitive.is_ok_and(|o| o.status.success()) {
|
||||
eprintln!("this runner can't make a case-sensitive folder: skipped");
|
||||
return;
|
||||
}
|
||||
std::fs::create_dir(base.join("root")).unwrap();
|
||||
std::fs::create_dir(base.join("Root")).unwrap();
|
||||
std::fs::write(base.join("Root/secret.dxf"), "x").unwrap();
|
||||
let roots = AutomationRoots::new(Some(&base.join("root")), Some(&base.join("root"))).unwrap().unwrap();
|
||||
for p in ["Root/secret.dxf", "Root/new.dxf"] {
|
||||
assert!(roots.check(s(base.join(p)), Access::Read).is_err(), "{p}");
|
||||
assert!(roots.check(s(base.join(p)), Access::Write).is_err(), "{p}");
|
||||
}
|
||||
assert_eq!(roots.check(s(base.join("root/new.dxf")), Access::Write), Ok(()));
|
||||
}
|
||||
|
||||
/// On an ordinary Windows folder any case finds the root, and device names are refused.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn windows_gives_a_root_its_real_spelling_and_refuses_devices() {
|
||||
let (base, roots) = folders("case");
|
||||
let upper = s(base.join("IN/A.DXF"));
|
||||
assert_eq!(roots.check(upper.as_str(), Access::Read), Ok(()), "{upper}");
|
||||
assert_eq!(roots.check(s(base.join("In/Sub/New.dxf")), Access::Read), Ok(()));
|
||||
let e = roots.check(s(base.join("out/NUL")), Access::Write).unwrap_err();
|
||||
assert!(e.contains("reserved device names"), "{e}");
|
||||
assert!(roots.check(s(base.join("out/com1.txt")), Access::Write).is_err());
|
||||
assert!(roots.check(s(base.join("out/COM¹")), Access::Write).is_err());
|
||||
assert_eq!(roots.check(s(base.join("out/console.txt")), Access::Write), Ok(()));
|
||||
}
|
||||
|
||||
/// A network, device or non-disk verbatim path is refused before the file system is asked.
|
||||
/// The error names the prefix. It is not the error canonicalize would return.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_network_path_is_refused_before_it_is_opened() {
|
||||
let (base, roots) = folders("unc");
|
||||
let paths = [
|
||||
(r"\\203.0.113.5\s\x.dwg", "UNC"),
|
||||
(r"\\?\UNC\203.0.113.5\s\x.dwg", "UNC"),
|
||||
(r"//203.0.113.5/s/x.dwg", "UNC"),
|
||||
(r"\\host@SSL\share\x.dwg", "UNC"),
|
||||
(r"\\host@SSL@443\share\x.dwg", "UNC"),
|
||||
(r"\\.\PhysicalDrive0", "device path"),
|
||||
(r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x.dwg", "verbatim path"),
|
||||
];
|
||||
for (p, kind) in paths {
|
||||
for access in [Access::Read, Access::Write] {
|
||||
let e = roots.check(p, access).unwrap_err();
|
||||
assert!(e.starts_with("automation path rejected:"), "{p}: {e}");
|
||||
assert!(e.contains(kind), "{p}: {e}");
|
||||
assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{p}: {e}");
|
||||
}
|
||||
}
|
||||
let e = roots.check(s(base.join("outside/secret.dxf")), Access::Read).unwrap_err();
|
||||
assert!(e.contains("outside the read root"), "{e}");
|
||||
|
||||
let root = windows_prefix(Path::new(r"\\?\UNC\FileServer\Projects\work")).unwrap();
|
||||
let same = windows_prefix(Path::new(r"\\fileserver\projects\a.dwg")).unwrap();
|
||||
let other_share = windows_prefix(Path::new(r"\\fileserver\secret\a.dwg")).unwrap();
|
||||
let other_host = windows_prefix(Path::new(r"\\203.0.113.5\Projects\a.dwg")).unwrap();
|
||||
let kelvin = windows_prefix(Path::new("\\\\wor\u{212a}\\Projects\\a.dwg")).unwrap();
|
||||
assert!(prefixes_match(&root, &same), "the same server and share, in either spelling");
|
||||
assert!(!prefixes_match(&root, &other_share));
|
||||
assert!(!prefixes_match(&root, &other_host));
|
||||
assert!(!prefixes_match(&root, &kelvin), "U+212A is not k");
|
||||
assert!(windows_prefix(Path::new(r"C:\Projects\a.dwg")).is_none());
|
||||
assert!(windows_prefix(Path::new(r"\\?\C:\Projects\a.dwg")).is_none());
|
||||
}
|
||||
|
||||
/// U+212A is a different folder from `k`, so a write there is outside the root and creates nothing.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_kelvin_sign_is_not_a_way_out_of_the_write_root() {
|
||||
let base = fresh_dir("kelvin");
|
||||
let root = base.join("work");
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
let roots = AutomationRoots::new(Some(&root), Some(&root)).unwrap().unwrap();
|
||||
let sibling = base.join("wor\u{212a}").join("x.dwg");
|
||||
let e = roots.check(s(sibling), Access::Write).unwrap_err();
|
||||
assert!(e.contains("outside the write root"), "{e}");
|
||||
assert!(!base.join("wor\u{212a}").exists(), "the check must not create the folder");
|
||||
assert_eq!(roots.check(s(root.join("new.dxf")), Access::Write), Ok(()));
|
||||
}
|
||||
|
||||
/// A junction needs no extra privilege. One that leads out of the write root is outside it.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_junction_out_of_the_write_root_is_refused() {
|
||||
let (base, roots) = folders("junction");
|
||||
let link = base.join("out").join("away");
|
||||
let made = std::process::Command::new("cmd").args(["/c", "mklink", "/J"]).arg(&link).arg(base.join("outside")).status();
|
||||
if !made.is_ok_and(|s| s.success()) {
|
||||
eprintln!("skipped: junctions can't be made here");
|
||||
return;
|
||||
}
|
||||
let e = roots.check(s(link.join("new.png")), Access::Write).unwrap_err();
|
||||
assert!(e.contains("outside the write root"), "{e}");
|
||||
assert!(!base.join("outside/new.png").exists());
|
||||
}
|
||||
|
||||
/// A link whose text names a network path is refused before that path is opened.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_link_to_a_network_path_is_refused_before_it_is_followed() {
|
||||
let (base, roots) = folders("unc-link");
|
||||
let link = base.join("in/leak.dxf");
|
||||
if std::os::windows::fs::symlink_file(r"\\203.0.113.5\s\x.dwg", &link).is_err() {
|
||||
eprintln!("skipped: symbolic links can't be made here");
|
||||
return;
|
||||
}
|
||||
let e = roots.check(link.as_path(), Access::Read).unwrap_err();
|
||||
assert!(e.contains("UNC"), "{e}");
|
||||
assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}");
|
||||
}
|
||||
|
||||
/// An alternate data stream is still the file it hangs off: outside the roots it is refused.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn an_alternate_stream_outside_the_roots_is_refused() {
|
||||
let (base, roots) = folders("ads");
|
||||
let e = roots.check(s(base.join("outside/secret.dxf:zone")), Access::Read).unwrap_err();
|
||||
assert!(e.contains("outside the read root"), "{e}");
|
||||
assert_eq!(roots.check(s(base.join("out/new.dxf:zone")), Access::Write), Ok(()));
|
||||
}
|
||||
|
||||
/// Roots end with their scope, also when a nested scope or a panic ends it.
|
||||
#[test]
|
||||
fn scopes_nest_and_restore_after_a_panic() {
|
||||
let (base, roots) = folders("scopes");
|
||||
let outside = s(base.join("outside/secret.dxf"));
|
||||
assert_eq!(check_read(&outside), Ok(()), "nothing is confined by default");
|
||||
confine(Some(&roots), || {
|
||||
assert!(check_read(&outside).is_err());
|
||||
// A nested scope replaces the outer one and gives it back on the way out.
|
||||
confine(None, || assert_eq!(check_read(&outside), Ok(())));
|
||||
assert!(check_read(&outside).is_err(), "restored after the inner scope");
|
||||
});
|
||||
assert_eq!(check_read(&outside), Ok(()), "restored after confine");
|
||||
let r = std::panic::catch_unwind(|| confine(Some(&roots), || panic!("boom")));
|
||||
assert!(r.is_err());
|
||||
assert_eq!(check_read(&outside), Ok(()), "restored after a panic");
|
||||
assert_eq!(confine(None, || check_read(&outside)), Ok(()));
|
||||
}
|
||||
|
||||
/// The plain device names, and names that only look like them.
|
||||
#[test]
|
||||
fn device_names() {
|
||||
for d in ["CON", "nul", "Com1", "LPT9.txt", "aux.svg", "NUL "] {
|
||||
assert!(is_device_name(d), "{d}");
|
||||
}
|
||||
for f in ["console", "com10", "lpt", "a.svg", "nul-x"] {
|
||||
assert!(!is_device_name(f), "{f}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,561 +0,0 @@
|
||||
//! Which commands automation may run while the automation roots are in force ([`super`]).
|
||||
//!
|
||||
//! The checks that hold a path to the roots sit where the file is touched, and a new command that
|
||||
//! touches a file through a new route would get past them. So a command runs under the roots only
|
||||
//! if it is listed here: anything else is refused, whatever it does. Adding a command to the
|
||||
//! registry means adding it to one of these lists (`every_command_is_classified` says so).
|
||||
|
||||
/// Commands that read or write files, each path held to the roots where the file is touched.
|
||||
pub const FILES: &[&str] = &[
|
||||
"-linetype",
|
||||
"-plottermanager",
|
||||
"-wblock",
|
||||
"-xref",
|
||||
"aliasedit",
|
||||
"appload",
|
||||
"attach",
|
||||
"blocklibimport",
|
||||
"blocklibrary",
|
||||
"audit",
|
||||
"compare",
|
||||
"compareexport",
|
||||
"dataextraction",
|
||||
"datalink",
|
||||
"datalinkupdate",
|
||||
"eattext",
|
||||
"export",
|
||||
"exportpdf",
|
||||
"hatch",
|
||||
"hatch.patterns",
|
||||
"image",
|
||||
"imageattach",
|
||||
"import",
|
||||
"insert",
|
||||
"layout",
|
||||
"layout.saveas",
|
||||
"linetype",
|
||||
"lisp",
|
||||
"minsert",
|
||||
"new",
|
||||
"open",
|
||||
"options",
|
||||
"pagesetup",
|
||||
"pdfbook",
|
||||
"plot",
|
||||
"plotstyle",
|
||||
"plottermanager",
|
||||
"preview",
|
||||
"publish",
|
||||
"qsave",
|
||||
"recover",
|
||||
"reinit",
|
||||
"saveas",
|
||||
"script",
|
||||
"setvar",
|
||||
"share",
|
||||
"stylesmanager",
|
||||
"tableexport",
|
||||
"wblock",
|
||||
"xattach",
|
||||
"xbind",
|
||||
"xopen",
|
||||
"xref",
|
||||
];
|
||||
|
||||
/// Commands that can't be held to the roots, and why.
|
||||
pub const REFUSED: &[(&str, &str)] = &[
|
||||
("drawingrecovery", "it works on the autosave folder (SAVEFILEPATH), which is the server's own"),
|
||||
("blocklibraries", "it keeps its list of libraries in the settings folder, which is the server's own"),
|
||||
];
|
||||
|
||||
/// Commands that touch no file.
|
||||
pub const NO_FILES: &[&str] = &[
|
||||
"ucs",
|
||||
"ucs.3point",
|
||||
"ucs.origin",
|
||||
"ucs.view",
|
||||
"ucs.world",
|
||||
"ucs.z",
|
||||
"ucsicon",
|
||||
"menubar",
|
||||
"toolbar",
|
||||
"blockspalette",
|
||||
"dimoverride.clear",
|
||||
"-dimstyle",
|
||||
"dimstyle.overrides",
|
||||
"dimstyle.saveas",
|
||||
"properties.describe",
|
||||
"close",
|
||||
"closeall",
|
||||
"document.switch",
|
||||
"document.bytes",
|
||||
"u",
|
||||
"undo",
|
||||
"redo",
|
||||
"mredo",
|
||||
"cutclip",
|
||||
"cutbase",
|
||||
"copyclip",
|
||||
"copybase",
|
||||
"pasteclip",
|
||||
"pasteblock",
|
||||
"pasteorig",
|
||||
"erase.selection",
|
||||
"selectall",
|
||||
"ai_deselect",
|
||||
"select",
|
||||
"qselect",
|
||||
"qselect.info",
|
||||
"selectsimilar",
|
||||
"isolateobjects",
|
||||
"hideobjects",
|
||||
"unisolateobjects",
|
||||
"xclip",
|
||||
"xclipframe",
|
||||
"zoom",
|
||||
"zoom.realtime",
|
||||
"zoom.dynamic",
|
||||
"zoom.previous",
|
||||
"zoom.window",
|
||||
"zoom.in",
|
||||
"zoom.out",
|
||||
"zoom.all",
|
||||
"zoom.extents",
|
||||
"zoom.object",
|
||||
"pan",
|
||||
"pan.left",
|
||||
"pan.right",
|
||||
"pan.up",
|
||||
"pan.down",
|
||||
"regen",
|
||||
"regenall",
|
||||
"redraw",
|
||||
"dview",
|
||||
"view.set",
|
||||
"view.get",
|
||||
"layout.set",
|
||||
"view",
|
||||
"-vports",
|
||||
"vports.activate",
|
||||
"vports.named",
|
||||
"line",
|
||||
"pline",
|
||||
"circle",
|
||||
"arc",
|
||||
"rectang",
|
||||
"polygon",
|
||||
"ellipse",
|
||||
"point",
|
||||
"point.multiple",
|
||||
"xline",
|
||||
"ray",
|
||||
"spline",
|
||||
"donut",
|
||||
"solid",
|
||||
"text",
|
||||
"mtext",
|
||||
"arc.sce",
|
||||
"arc.sca",
|
||||
"arc.scl",
|
||||
"arc.sea",
|
||||
"arc.sed",
|
||||
"arc.ser",
|
||||
"arc.cse",
|
||||
"arc.csa",
|
||||
"arc.csl",
|
||||
"arc.continue",
|
||||
"circle.cd",
|
||||
"circle.2p",
|
||||
"circle.3p",
|
||||
"circle.ttr",
|
||||
"circle.ttt",
|
||||
"ellipse.axis",
|
||||
"ellipse.arc",
|
||||
"divide",
|
||||
"measure",
|
||||
"revcloud",
|
||||
"revcloud.polygonal",
|
||||
"revcloud.freehand",
|
||||
"wipeout",
|
||||
"3dpoly",
|
||||
"helix",
|
||||
"spline.cv",
|
||||
"centermark",
|
||||
"centerline",
|
||||
"mline",
|
||||
"mlstyle",
|
||||
"mledit",
|
||||
"breakline",
|
||||
"dimlinear",
|
||||
"dimaligned",
|
||||
"dimradius",
|
||||
"dimdiameter",
|
||||
"dimangular",
|
||||
"dimarc",
|
||||
"dimordinate",
|
||||
"dimcontinue",
|
||||
"dimbaseline",
|
||||
"qdim",
|
||||
"dim",
|
||||
"mleader",
|
||||
"leader",
|
||||
"dimstyle.update",
|
||||
"dimoverride",
|
||||
"dimreassociate",
|
||||
"dimdisassociate",
|
||||
"dimtedit.home",
|
||||
"dimtedit.angle",
|
||||
"dimtedit.left",
|
||||
"dimtedit.center",
|
||||
"dimtedit.right",
|
||||
"dimtedit",
|
||||
"dimspace",
|
||||
"dimedit",
|
||||
"dimedit.oblique",
|
||||
"dimjogged",
|
||||
"dimjogline",
|
||||
"dimbreak",
|
||||
"diminspect",
|
||||
"mleaderedit",
|
||||
"mleaderedit.add",
|
||||
"mleaderedit.remove",
|
||||
"mleaderalign",
|
||||
"mleadercollect",
|
||||
"scalelistedit",
|
||||
"objectscale",
|
||||
"aiobjectscaleadd",
|
||||
"aiobjectscaleremove",
|
||||
"annoreset",
|
||||
"annoupdate",
|
||||
"annovisible.current",
|
||||
"annovisible.all",
|
||||
"annovisible.toggle",
|
||||
"gradient",
|
||||
"boundary",
|
||||
"region",
|
||||
"hatchedit",
|
||||
"hatchpick",
|
||||
"overkill",
|
||||
"block",
|
||||
"-block",
|
||||
"attdef",
|
||||
"attedit",
|
||||
"-attedit",
|
||||
"base",
|
||||
"blocks.dynamic",
|
||||
"blocks.reference",
|
||||
"blocks.reference.set",
|
||||
"blocks.reference.grips",
|
||||
"blocks.reference.grip",
|
||||
"purge",
|
||||
"blocks.list",
|
||||
"battman",
|
||||
"attdisp",
|
||||
"attsync",
|
||||
"burst",
|
||||
"blockreplace",
|
||||
"blocks.description",
|
||||
"attdisp.normal",
|
||||
"attdisp.on",
|
||||
"attdisp.off",
|
||||
"refedit",
|
||||
"refset",
|
||||
"refclose",
|
||||
"bedit",
|
||||
"bsave",
|
||||
"bsaveas",
|
||||
"bclose",
|
||||
"erase",
|
||||
"oops",
|
||||
"move",
|
||||
"copy",
|
||||
"rotate",
|
||||
"scale",
|
||||
"mirror",
|
||||
"stretch",
|
||||
"offset",
|
||||
"trim",
|
||||
"extend",
|
||||
"fillet",
|
||||
"chamfer",
|
||||
"explode",
|
||||
"break",
|
||||
"breakatpoint",
|
||||
"join",
|
||||
"draworder",
|
||||
"draworder.front",
|
||||
"draworder.back",
|
||||
"draworder.above",
|
||||
"draworder.under",
|
||||
"texttofront",
|
||||
"texttofront.text",
|
||||
"texttofront.dimensions",
|
||||
"texttofront.leaders",
|
||||
"texttofront.all",
|
||||
"hatchtoback",
|
||||
"array",
|
||||
"arrayrect",
|
||||
"arraypolar",
|
||||
"-array",
|
||||
"arrayedit",
|
||||
"arrayclose",
|
||||
"pedit",
|
||||
"splinedit",
|
||||
"lengthen",
|
||||
"align",
|
||||
"blend",
|
||||
"reverse",
|
||||
"ncopy",
|
||||
"mocoro",
|
||||
"chspace",
|
||||
"flatten",
|
||||
"arraypath",
|
||||
"textedit",
|
||||
"group",
|
||||
"ungroup",
|
||||
"groupedit",
|
||||
"groups.list",
|
||||
"-group",
|
||||
"pickstyle",
|
||||
"grip.move",
|
||||
"grip.stretch",
|
||||
"grip.rotate",
|
||||
"grip.scale",
|
||||
"grip.mirror",
|
||||
"grip.option",
|
||||
"grip",
|
||||
"compare.next",
|
||||
"compare.previous",
|
||||
"compareclose",
|
||||
"layer",
|
||||
"layer.new",
|
||||
"layer.set",
|
||||
"layer.current",
|
||||
"layer.delete",
|
||||
"laymcur",
|
||||
"laymch",
|
||||
"laycur",
|
||||
"layiso",
|
||||
"layuniso",
|
||||
"layfrz",
|
||||
"layoff",
|
||||
"laylck",
|
||||
"layulk",
|
||||
"layon",
|
||||
"laythw",
|
||||
"layerp",
|
||||
"layerstate.save",
|
||||
"layerstate.restore",
|
||||
"layerstate.list",
|
||||
"layerstate.delete",
|
||||
"layerstate.rename",
|
||||
"laymrg",
|
||||
"laydel",
|
||||
"layout.new",
|
||||
"layout.delete",
|
||||
"layout.rename",
|
||||
"layout.copy",
|
||||
"layout.list",
|
||||
"mview",
|
||||
"mview.polygonal",
|
||||
"vpclip",
|
||||
"vports",
|
||||
"vports.1",
|
||||
"vports.2",
|
||||
"vports.3",
|
||||
"vports.4",
|
||||
"viewport.set",
|
||||
"vplayer",
|
||||
"mspace",
|
||||
"pspace",
|
||||
"plotwindow",
|
||||
"3dorbit",
|
||||
"properties",
|
||||
"properties.set",
|
||||
"chprop",
|
||||
"change",
|
||||
"matchprop",
|
||||
"color",
|
||||
"lweight",
|
||||
"ltscale",
|
||||
"units",
|
||||
"-units",
|
||||
"thickness",
|
||||
"limits",
|
||||
"style",
|
||||
"style.list",
|
||||
"style.rename",
|
||||
"style.delete",
|
||||
"style.current",
|
||||
"dimstyle",
|
||||
"dimstyle.dimension",
|
||||
"dimstyle.list",
|
||||
"dimstyle.rename",
|
||||
"dimstyle.delete",
|
||||
"dimstyle.current",
|
||||
"dimstyle.override",
|
||||
"tablestyle",
|
||||
"mleaderstyle",
|
||||
"ddptype",
|
||||
"rename",
|
||||
"dist",
|
||||
"id",
|
||||
"list",
|
||||
"area",
|
||||
"time",
|
||||
"status",
|
||||
"drawing.inspect",
|
||||
"entities",
|
||||
"shapes",
|
||||
"usage",
|
||||
"loops",
|
||||
"texts",
|
||||
"countlist",
|
||||
"counttable",
|
||||
"count",
|
||||
"union",
|
||||
"subtract",
|
||||
"intersect",
|
||||
"massprop",
|
||||
"ortho",
|
||||
"grid",
|
||||
"snap",
|
||||
"polar",
|
||||
"otrack",
|
||||
"dynmode",
|
||||
"lwdisplay",
|
||||
"isodraft",
|
||||
"isoplane",
|
||||
"transparencydisplay",
|
||||
"qpmode",
|
||||
"selectioncycling",
|
||||
"osnap",
|
||||
"dsettings",
|
||||
"getvar",
|
||||
"sysvars",
|
||||
"cal",
|
||||
"quickcalc.pick",
|
||||
"find",
|
||||
"measuregeom",
|
||||
"radius.measure",
|
||||
"angle.measure",
|
||||
"volume.measure",
|
||||
"table",
|
||||
"table.set",
|
||||
"table.insertrow",
|
||||
"table.deleterow",
|
||||
"table.insertcol",
|
||||
"table.deletecol",
|
||||
"table.merge",
|
||||
"table.unmerge",
|
||||
"tablestyle.cellstyle",
|
||||
"table.cellstyle",
|
||||
"table.formula",
|
||||
"table.recalc",
|
||||
"tabledit",
|
||||
"table.break",
|
||||
"tolerance",
|
||||
"txt2mtxt",
|
||||
"geomconstraint",
|
||||
"gccoincident",
|
||||
"gcperpendicular",
|
||||
"gcparallel",
|
||||
"gctangent",
|
||||
"gchorizontal",
|
||||
"gcvertical",
|
||||
"gccollinear",
|
||||
"gcconcentric",
|
||||
"gcsmooth",
|
||||
"gcsymmetric",
|
||||
"gcequal",
|
||||
"gcfix",
|
||||
"autoconstrain",
|
||||
"constraintbar",
|
||||
"constraintbar.showall",
|
||||
"constraintbar.hideall",
|
||||
"dimconstraint",
|
||||
"dcaligned",
|
||||
"dchorizontal",
|
||||
"dcvertical",
|
||||
"dcangular",
|
||||
"dcradius",
|
||||
"dcdiameter",
|
||||
"dclinear",
|
||||
"dcdisplay",
|
||||
"dcdisplay.showall",
|
||||
"dcdisplay.hideall",
|
||||
"delconstraint",
|
||||
"parameters",
|
||||
"constraintsettings",
|
||||
"constraintinfer",
|
||||
"constraints.inspect",
|
||||
"constraints.dof",
|
||||
];
|
||||
|
||||
/// Why command `id` may not run here; `None` when it may. Without roots in force everything may.
|
||||
pub fn refusal(id: &str) -> Option<String> {
|
||||
super::current()?;
|
||||
if let Some((_, why)) = REFUSED.iter().find(|(c, _)| *c == id) {
|
||||
return Some(format!("automation command refused: {why}"));
|
||||
}
|
||||
if FILES.contains(&id) || NO_FILES.contains(&id) {
|
||||
return None;
|
||||
}
|
||||
Some("automation command refused: it is not classified for the automation roots".to_string())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[allow(clippy::unwrap_used, clippy::panic)]
|
||||
mod tests {
|
||||
use super::super::{AutomationRoots, confine};
|
||||
use super::*;
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
/// Words in a command's parameter doc that usually name a file. In these commands they don't:
|
||||
/// `array` and `arraypath` follow a path of objects, and `blocks.reference.grips` reports a
|
||||
/// direction.
|
||||
const NOT_FILES: &[&str] = &["array", "arraypath", "blocks.reference.grips"];
|
||||
|
||||
/// The words of a command's documentation, lower case.
|
||||
fn words(doc: &str) -> BTreeSet<String> {
|
||||
doc.to_ascii_lowercase().split(|c: char| !c.is_ascii_alphanumeric()).map(str::to_string).collect()
|
||||
}
|
||||
|
||||
/// Walks the registry: every command is on exactly one list, and the lists name no command
|
||||
/// that is gone. A command whose parameters name a file can't be on the no-files list.
|
||||
#[test]
|
||||
fn every_command_is_classified() {
|
||||
let refused: Vec<&str> = REFUSED.iter().map(|(c, _)| *c).collect();
|
||||
let lists = [FILES, refused.as_slice(), NO_FILES];
|
||||
let specs = crate::command_specs();
|
||||
for spec in specs {
|
||||
let on = lists.iter().filter(|l| l.contains(&spec.id)).count();
|
||||
assert_eq!(on, 1, "`{}` is on {on} lists: add it to one in file_access/commands.rs", spec.id);
|
||||
let doc = words(spec.params);
|
||||
let names_a_file = ["path", "file", "template", "patternfile", "folder", "dir"].iter().any(|w| doc.contains(*w));
|
||||
if names_a_file && NO_FILES.contains(&spec.id) && !NOT_FILES.contains(&spec.id) {
|
||||
panic!("`{}` takes a file ({}): it belongs on FILES, with its paths checked", spec.id, spec.params);
|
||||
}
|
||||
}
|
||||
for id in lists.iter().flat_map(|l| l.iter()) {
|
||||
assert!(specs.iter().any(|s| s.id == *id), "`{id}` is listed but no longer a command");
|
||||
}
|
||||
}
|
||||
|
||||
/// Under roots a command nobody classified is refused; without roots it isn't this table's business.
|
||||
#[test]
|
||||
fn an_unclassified_command_fails_closed() {
|
||||
let base = std::env::temp_dir().join(format!("cc-commands-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&base).unwrap();
|
||||
let roots = AutomationRoots::new(Some(&base), None).unwrap();
|
||||
assert_eq!(refusal("made.up"), None);
|
||||
confine(roots.as_ref(), || {
|
||||
assert!(refusal("made.up").unwrap().contains("not classified"));
|
||||
assert!(refusal("drawingrecovery").unwrap().contains("autosave"));
|
||||
assert!(refusal("blocklibraries").unwrap().contains("settings folder"));
|
||||
assert_eq!(refusal("open"), None);
|
||||
assert_eq!(refusal("line"), None);
|
||||
});
|
||||
let _ = std::fs::remove_dir_all(base);
|
||||
}
|
||||
}
|
||||
@@ -1,186 +0,0 @@
|
||||
//! 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -18,17 +18,14 @@ pub mod blockedit;
|
||||
pub mod capped_read;
|
||||
pub mod cmd;
|
||||
pub mod doc_path;
|
||||
pub mod file_access;
|
||||
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;
|
||||
@@ -37,7 +34,6 @@ pub mod settings_dir;
|
||||
pub mod snap;
|
||||
pub mod spatial;
|
||||
pub mod sysvars;
|
||||
pub mod ucs;
|
||||
pub mod undoctl;
|
||||
pub mod units;
|
||||
|
||||
@@ -88,11 +84,6 @@ 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;
|
||||
@@ -158,10 +149,6 @@ pub struct Session {
|
||||
lisp_last: Option<std::result::Result<lisp::value::Value, String>>,
|
||||
/// What the last HATCHPICK kept (the Hatch and Gradient dialog's picks).
|
||||
pub hatch_picks: Option<cmd::hatch::HatchPicks>,
|
||||
/// The window's menu bar and tool bar as the UI shows them (it reports them every frame).
|
||||
pub bars_shown: cmd::interface::InterfaceBars,
|
||||
/// The bars MENUBAR or TOOLBAR asked to change, for the UI to apply.
|
||||
pub bars_request: cmd::interface::BarsRequest,
|
||||
/// The object named with a point for the input a prompt picking one object is taking
|
||||
/// ([`Session::input_object`]): a pick at exactly that point picks that object
|
||||
/// ([`Session::pick_object`]).
|
||||
@@ -188,8 +175,6 @@ impl Session {
|
||||
doc_epoch: 0,
|
||||
settings: Settings::default(),
|
||||
running: None,
|
||||
commands_started: 0,
|
||||
last_finished: None,
|
||||
in_script: false,
|
||||
suspended: None,
|
||||
log: Vec::new(),
|
||||
@@ -221,8 +206,6 @@ impl Session {
|
||||
lisp: lisp::LispState::default(),
|
||||
lisp_last: None,
|
||||
hatch_picks: None,
|
||||
bars_shown: Default::default(),
|
||||
bars_request: Default::default(),
|
||||
pick_hint: None,
|
||||
}
|
||||
}
|
||||
@@ -247,33 +230,17 @@ 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>) {
|
||||
|
||||
+13
-49
@@ -5,14 +5,10 @@
|
||||
//! (`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;
|
||||
@@ -58,20 +54,13 @@ 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 (`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>)>,
|
||||
/// Every entity's handle in creation order, for the drawing it was taken from (`entnext`).
|
||||
pub order: Option<(usize, Arc<Vec<Handle>>)>,
|
||||
/// `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>,
|
||||
@@ -88,10 +77,8 @@ 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);
|
||||
@@ -139,9 +126,6 @@ pub struct LispState {
|
||||
/// Interpreter steps all synchronous callbacks have run, nested ones included. A callback's
|
||||
/// allowance counts what ran since it started, so the callbacks it calls spend its steps.
|
||||
pub(crate) callback_used: u64,
|
||||
/// Work synchronous callbacks did inside the running step, already counted in `callback_used`:
|
||||
/// the step is charged it without charging the enclosing callback a second time.
|
||||
pub(crate) callback_work: u64,
|
||||
/// The `callback_used` value the callback running now (and so every one it calls) must not
|
||||
/// pass: the lowest of its own and its callers' allowances.
|
||||
pub(crate) callback_ceiling: Option<u64>,
|
||||
@@ -223,19 +207,8 @@ 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) {
|
||||
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));
|
||||
self.lisp.envs.insert(uid, env);
|
||||
}
|
||||
|
||||
/// A routine is running (possibly waiting for input).
|
||||
@@ -386,14 +359,6 @@ impl Session {
|
||||
let uid = run.uid;
|
||||
self.lisp_flush(&mut env, false);
|
||||
self.lisp_env_put(uid, env);
|
||||
// The work the slice did, which one step can take far past the slice. After a panic
|
||||
// `used` is still the previous slice's; the run ends with the error anyway.
|
||||
run.steps = run.steps.saturating_add(run.machine.used);
|
||||
if run.blocking && run.steps > BLOCKING_CAP && matches!(outcome, Outcome::Wait(_)) {
|
||||
self.lisp.run = Some(run);
|
||||
self.lisp_error(LispError::quit(format!("routine stopped after {BLOCKING_CAP} steps")));
|
||||
return;
|
||||
}
|
||||
match outcome {
|
||||
Outcome::Done(v) => {
|
||||
self.lisp.run = Some(run);
|
||||
@@ -406,7 +371,13 @@ impl Session {
|
||||
return;
|
||||
}
|
||||
Outcome::Wait(Need::Yield) => {
|
||||
run.steps = run.steps.saturating_add(SLICE);
|
||||
if run.blocking {
|
||||
if run.steps > BLOCKING_CAP {
|
||||
self.lisp.run = Some(run);
|
||||
self.lisp_error(LispError::quit(format!("routine stopped after {BLOCKING_CAP} steps")));
|
||||
return;
|
||||
}
|
||||
self.lisp.run = Some(run);
|
||||
continue;
|
||||
}
|
||||
@@ -480,7 +451,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_env_put(run.uid, env);
|
||||
self.lisp.envs.insert(run.uid, env);
|
||||
if let (Ok(v), true) = (&result, run.print) {
|
||||
let text = value::to_text(v, true);
|
||||
if !builtins::is_null_symbol(v) {
|
||||
@@ -563,7 +534,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(&self.input_ucs())),
|
||||
Need::Get(req) => Some(req.prompt()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
@@ -574,15 +545,10 @@ 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) });
|
||||
// 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);
|
||||
let Some(b) = req.first.or(req.base).map(|p| cadcraft_geom::Vec2::new(p[0], p[1])) else { return Some(Vec::new()) };
|
||||
Some(match req.kind {
|
||||
input::GetKind::Corner => {
|
||||
// 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)));
|
||||
let (c1, c2) = (cadcraft_geom::Vec2::new(cursor.x, b.y), cadcraft_geom::Vec2::new(b.x, cursor.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)],
|
||||
@@ -761,8 +727,6 @@ fn file_key(name: &str) -> String {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
#[cfg(test)]
|
||||
mod ucs_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod block_tests;
|
||||
|
||||
@@ -234,40 +234,3 @@ 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, objects, read};
|
||||
use super::{Env, LispError, drawing, input, read};
|
||||
|
||||
macro_rules! cxrs {
|
||||
($($name:ident $path:literal),*) => {
|
||||
@@ -262,10 +262,6 @@ 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),
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user