diff --git a/.github/workflows/ast-grep.yml b/.github/workflows/ast-grep.yml new file mode 100644 index 000000000..aab570b63 --- /dev/null +++ b/.github/workflows/ast-grep.yml @@ -0,0 +1,26 @@ +# Structural rules for the command-line code (RFC-0012): lint/ast-grep's rule tests, then a scan. +# Seconds, no Rust build. +name: ast-grep + +on: + push: + branches: [main] + paths: ["lint/ast-grep/**", "apps/cadcraft-cli/src/**", "apps/cadcraft/src/launch_args.rs", "apps/cadcraft/src/main.rs", ".github/workflows/ast-grep.yml"] + pull_request: + paths: ["lint/ast-grep/**", "apps/cadcraft-cli/src/**", "apps/cadcraft/src/launch_args.rs", "apps/cadcraft/src/main.rs", ".github/workflows/ast-grep.yml"] + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: ast-grep-${{ github.ref }} + cancel-in-progress: true + +jobs: + scan: + # Tracked at @main like the other shared workflows. + uses: storytold/craft-common-actions/.github/workflows/ast-grep.yml@main + with: + config: lint/ast-grep/sgconfig.yml + paths: apps/cadcraft-cli/src apps/cadcraft/src/launch_args.rs apps/cadcraft/src/main.rs diff --git a/.github/workflows/packaging-lint.yml b/.github/workflows/packaging-lint.yml index f54b0538b..ea61d8430 100644 --- a/.github/workflows/packaging-lint.yml +++ b/.github/workflows/packaging-lint.yml @@ -21,3 +21,27 @@ jobs: lint: # 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/packaging-lint.yml@main + + windows-install-policy: + timeout-minutes: 10 + name: Windows installation policy (no app build) + runs-on: windows-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Install the pinned packaging toolchain + shell: pwsh + run: | + $tools = Join-Path $env:RUNNER_TEMP 'craft-install-policy-wix' + dotnet tool install --tool-path $tools wix --version 5.0.2 + if ($LASTEXITCODE -ne 0) { throw 'WiX installation failed.' } + $tools >> $env:GITHUB_PATH + $policy = Get-Content -Raw -LiteralPath packaging/windows/install-policy.json | ConvertFrom-Json + foreach ($extension in @($policy.extensions)) { + & (Join-Path $tools 'wix.exe') extension add -g "WixToolset.$extension.wixext/5.0.2" + if ($LASTEXITCODE -ne 0) { throw "WiX extension $extension installation failed." } + } + - name: Build and check non-executable installer fixtures + shell: pwsh + run: ./packaging/windows/test-install-policy.ps1 -OutputDirectory (Join-Path $env:RUNNER_TEMP 'craft-install-policy-tests') diff --git a/.github/workflows/windows-arm64.yml b/.github/workflows/windows-arm64.yml index f7bb0996e..a671ff2f2 100644 --- a/.github/workflows/windows-arm64.yml +++ b/.github/workflows/windows-arm64.yml @@ -25,8 +25,10 @@ permissions: jobs: windows-arm64: - # 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/windows-arm64.yml@main + # Immutable supporting workflow revision until the new install contract lands upstream. + uses: storytold/craft-common-actions/.github/workflows/windows-arm64.yml@8bb4e5ab95443171104ad88113fe1ef9b0e5ce3f with: app-name: cadcraft app-dir: CADCraft + install-relative-path: Programs/ArtCraft/CADCraft + install-scope: perUser diff --git a/AGENTS.md b/AGENTS.md index cd6de23e3..e436894b2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -19,7 +19,7 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr - **Bound recursion** (nested/cyclic block references: `MAX_BLOCK_DEPTH`). - **Last-resort guard:** `Session::execute` and every step of an interactive command (its factory, `begin`, input, `prompt` and `preview`; `crates/engine/src/guard.rs`) run under `catch_unwind`; an escaped panic restores the drawing and reports an error. - **Prove it:** every crash fix lands with a regression test (see `hostile_params_never_panic`, `hostile_dxf_does_not_panic`). -- Every production crate root carries `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`. +- Every workspace crate manifest carries `[lints] workspace = true` to inherit `[workspace.lints]`; every production crate root carries `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`. ## Non-negotiables - **Clean-room.** AutoCAD is installed on the dev machine and may be *observed* black-box: run it, use its UI with synthetic drawings, take screenshots (by window id) stored only under `plan/autocad/screenshots/` (never committed). **Never** read, disassemble or copy anything inside the AutoCAD bundle (names/listings only); never copy Autodesk fonts (SHX), hatch patterns (`.pat`), linetypes (`.lin`), templates, CUI/PGP files, icons, artwork or help text; never commit files produced by AutoCAD. File formats come from public specifications (Autodesk's published DXF Reference, the Open Design Alliance's public DWG specification) and our own synthetic tests. Never copy or link GPL/LGPL/AGPL code (LibreDWG, LibreCAD, QCAD, FreeCAD's planegcs, SolveSpace, OpenCASCADE) — don't even read their sources. diff --git a/CLAUDE.md b/CLAUDE.md index f15d4522b..33e6a2121 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -19,7 +19,7 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr - **Bound recursion** (nested/cyclic block references: `MAX_BLOCK_DEPTH`). - **Last-resort guard:** `Session::execute` and every step of an interactive command (its factory, `begin`, input, `prompt` and `preview`; `crates/engine/src/guard.rs`) run under `catch_unwind`; an escaped panic restores the drawing and reports an error. - **Prove it:** every crash fix lands with a regression test (see `hostile_params_never_panic`, `hostile_dxf_does_not_panic`). -- Every production crate root carries `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`. +- Every workspace crate manifest carries `[lints] workspace = true` to inherit `[workspace.lints]`; every production crate root carries `#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]`. ## Non-negotiables - **Clean-room.** AutoCAD is installed on the dev machine and may be *observed* black-box: run it, use its UI with synthetic drawings, take screenshots (by window id) stored only under `plan/autocad/screenshots/` (never committed). **Never** read, disassemble or copy anything inside the AutoCAD bundle (names/listings only); never copy Autodesk fonts (SHX), hatch patterns (`.pat`), linetypes (`.lin`), templates, CUI/PGP files, icons, artwork or help text; never commit files produced by AutoCAD. File formats come from public specifications (Autodesk's published DXF Reference, the Open Design Alliance's public DWG specification) and our own synthetic tests. Never copy or link GPL/LGPL/AGPL code (LibreDWG, LibreCAD, QCAD, FreeCAD's planegcs, SolveSpace, OpenCASCADE) — don't even read their sources. diff --git a/Cargo.lock b/Cargo.lock index 0633f38f3..ab48c95da 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -196,6 +196,56 @@ dependencies = [ "libc", ] +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.2", +] + [[package]] name = "anyhow" version = "1.0.104" @@ -571,6 +621,7 @@ dependencies = [ "cadcraft-mcp", "cadcraft-ui-egui", "chrono", + "clap", "craft-ui", "craft-update", "craft-window", @@ -583,6 +634,7 @@ dependencies = [ "rfd", "serde_json", "sys-locale", + "thiserror 2.0.21", "windows", "winit", "winresource", @@ -597,7 +649,12 @@ dependencies = [ "cadcraft-io", "cadcraft-mcp", "cadcraft-render", + "clap", + "clap_complete", + "clap_mangen", + "same-file", "serde_json", + "thiserror 2.0.21", ] [[package]] @@ -710,6 +767,7 @@ dependencies = [ "cadcraft-engine", "cadcraft-io", "cadcraft-render", + "clap", "getrandom 0.4.3", "log", "serde_json", @@ -863,6 +921,65 @@ dependencies = [ "num-traits", ] +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_complete" +version = "4.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037e2a1a92236d0aff7e845093f64661d6df4c02c9fcc61a60e9e1d736fa392f" +dependencies = [ + "clap", +] + +[[package]] +name = "clap_derive" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "clap_mangen" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "211d617eaa4b735c96c9e0228fcbdb5120ef623f2b8cb67ffb84c3e02dbc28a4" +dependencies = [ + "clap", + "roff", +] + [[package]] name = "clipboard-win" version = "5.4.3" @@ -907,6 +1024,12 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + [[package]] name = "colored" version = "2.2.0" @@ -2085,6 +2208,12 @@ dependencies = [ "stable_deref_trait", ] +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + [[package]] name = "hermit-abi" version = "0.5.3" @@ -2387,6 +2516,12 @@ dependencies = [ "once_cell", ] +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + [[package]] name = "itertools" version = "0.15.0" @@ -3241,6 +3376,12 @@ version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + [[package]] name = "open" version = "5.4.5" @@ -3813,6 +3954,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "roff" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "323c417e1d9665a65b263ec744ba09030cfb277e9daa0b018a4ab62e57bc8189" + [[package]] name = "ron" version = "0.12.2" @@ -4328,6 +4475,12 @@ dependencies = [ "unicode-properties", ] +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + [[package]] name = "subsetter" version = "0.2.6" @@ -4801,6 +4954,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + [[package]] name = "uuid" version = "1.29.0" diff --git a/Cargo.toml b/Cargo.toml index 8c4230e22..2b38a218f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,9 +29,13 @@ craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-l # 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 } +clap = { version = "4", features = ["derive", "env"] } +clap_complete = "4.6.11" +clap_mangen = { version = "0.3.3", features = ["env"] } # foundation thiserror = "2" +same-file = "1" serde = { version = "1", features = ["derive", "rc"] } serde_json = { version = "1", features = ["float_roundtrip"] } log = "0.4" @@ -69,9 +73,11 @@ arboard = { version = "3.6", default-features = false } unsafe_code = "forbid" [workspace.lints.clippy] +cognitive_complexity = "deny" +too_many_arguments = "deny" +wildcard_imports = "deny" dbg_macro = "warn" todo = "warn" -too_many_arguments = "allow" type_complexity = "allow" [profile.dev.package."*"] diff --git a/README.md b/README.md index dd0abd25d..c45b619dc 100644 --- a/README.md +++ b/README.md @@ -196,7 +196,7 @@ crashed survives the next start. The file stops growing at 16 MiB. `--version` w | Variable | Effect | |---|---| -| `CADCRAFT_CONFIG_DIR` | Use this directory instead of the platform settings directory (the log goes to its `logs/`) | +| `CADCRAFT_CONFIG_DIR` | Use this directory instead of the platform settings directory (the log goes to its `logs/`); empty means no settings folder (no log file, autosave, workspace or plotters) | | `RUST_LOG` | Log levels for standard error and the log file. Default: `info` for CADCraft's own crates, `warn` for everything else. env_logger-style directives replace that, e.g. `RUST_LOG=debug`, `RUST_LOG=warn,cadcraft_io=trace` or `RUST_LOG=info,wgpu_core=warn`; a directive ending in `*` covers every target starting with it (`cadcraft*=debug`). `cadcraft_engine=debug` also logs every command-line message. | The logger is `apps/cadcraft/src/logging.rs`; the web build logs to the browser console instead. @@ -238,6 +238,9 @@ MCP tools include `command_line` (type at the prompt), `execute` (any command wi To run LISP routines, scripts and alias files, or to drive CADCraft from your own programs, see [docs/customization.md](docs/customization.md). +`cadcraft-cli --help` documents every subcommand and flag; exit codes, streams, environment +variables and its RFC-0012 conventions are in [docs/cli.md](docs/cli.md). + ## Architecture ```text @@ -311,6 +314,7 @@ See [ROADMAP.md](ROADMAP.md) for the stage, measured parity and the estimate of Installers and executables are code-signed. The installer adds CADCraft to the Start menu and asks whether to add a desktop shortcut too (unticked by default). For a silent install with the desktop shortcut: `msiexec /i cadcraft--windows-x64.msi /qn DESKTOPSHORTCUT=1`. +A silent install is per-user by default; add `ALLUSERS=1`, from an elevated terminal or deployment tool, for an all-users install. **If the app doesn't open on Windows:** the desktop app initializes only DirectX 12 by default. Letting wgpu also create an OpenGL instance can crash some graphics drivers (AMD's diff --git a/apps/cadcraft-cli/Cargo.toml b/apps/cadcraft-cli/Cargo.toml index b852183f4..cac076c17 100644 --- a/apps/cadcraft-cli/Cargo.toml +++ b/apps/cadcraft-cli/Cargo.toml @@ -6,6 +6,14 @@ edition.workspace = true license.workspace = true publish = false +[lib] +name = "cadcraft_cli" +path = "src/lib.rs" + +[[bin]] +name = "cadcraft-cli" +path = "src/main.rs" + [lints] workspace = true @@ -14,4 +22,13 @@ cadcraft-engine = { workspace = true } cadcraft-io = { workspace = true } cadcraft-mcp = { workspace = true } cadcraft-render = { workspace = true } +clap = { workspace = true } +same-file = { workspace = true } serde_json = { workspace = true } +thiserror = { workspace = true } + +[dev-dependencies] +# Shell completions and man pages (examples/man-and-completions.rs, for the Linux packages); not +# in the binary. +clap_complete = { workspace = true } +clap_mangen = { workspace = true } diff --git a/apps/cadcraft-cli/examples/man-and-completions.rs b/apps/cadcraft-cli/examples/man-and-completions.rs new file mode 100644 index 000000000..ddcfbf062 --- /dev/null +++ b/apps/cadcraft-cli/examples/man-and-completions.rs @@ -0,0 +1,41 @@ +//! Writes cadcraft-cli's shell completions ([`clap_complete`]: bash, zsh, fish, elvish, +//! PowerShell) and man pages ([`clap_mangen`]: `cadcraft-cli.1` and one per subcommand, such as +//! `cadcraft-cli-convert.1`) into a directory. The Linux packages ship them +//! (`packaging/linux/package.sh`): +//! +//! ```sh +//! cargo run -p cadcraft-cli --example man-and-completions -- +//! ``` + +use std::path::Path; +use std::process::ExitCode; + +use clap::ValueEnum; +use clap_complete::Shell; + +fn main() -> ExitCode { + let mut args = std::env::args_os().skip(1); + let (Some(dir), None) = (args.next(), args.next()) else { + eprintln!("usage: man-and-completions "); + return ExitCode::from(2); + }; + let dir = Path::new(&dir); + match generate(dir) { + Ok(()) => ExitCode::SUCCESS, + Err(e) => { + eprintln!("error: {}: {e}", dir.display()); + ExitCode::FAILURE + } + } +} + +pub(crate) fn generate(dir: &Path) -> std::io::Result<()> { + std::fs::create_dir_all(dir)?; + let mut cmd = cadcraft_cli::command(); + for &shell in Shell::value_variants() { + clap_complete::generate_to(shell, &mut cmd, "cadcraft-cli", dir)?; + } + // A fresh command: `clap_complete::generate_to` built `cmd`, adding the `help` subcommand, + // which `clap_mangen` would otherwise give pages of its own (`cadcraft-cli-help-convert.1`). + clap_mangen::generate_to(cadcraft_cli::command(), dir) +} diff --git a/apps/cadcraft-cli/src/args.rs b/apps/cadcraft-cli/src/args.rs new file mode 100644 index 000000000..16b57eeb7 --- /dev/null +++ b/apps/cadcraft-cli/src/args.rs @@ -0,0 +1,786 @@ +//! The command line, as clap types. Values are parsed into their types here and the relations +//! between flags are checked, so a bad value or combination is a usage error (exit 2) naming the +//! flag, before any work starts; the handlers receive typed values only. A flag a subcommand +//! doesn't take is a usage error too, so a typo can't be silently ignored. A value flag never takes +//! the next flag as its value: a value starting with `-` is written `--save=-out.dxf` (or +//! `./-out.dxf`). + +use std::ffi::{OsStr, OsString}; +use std::path::{Path, PathBuf}; + +use cadcraft_engine::geom::{Bounds2, Vec2}; +use cadcraft_io::Format; +use cadcraft_mcp::args::{blank_env_is_unset, name_env_vars}; +use clap::builder::{OsStringValueParser, PathBufValueParser, TypedValueParser}; +use clap::error::ErrorKind; +use clap::parser::ValueSource; +use clap::{ArgAction, ArgGroup, ArgMatches, Args, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum}; +use serde_json::Value; + +/// Help text that names the formats of `list`, built once from [`Format::READ`] or [`Format::WRITE`] +/// so it can't drift from what the code accepts. +fn with_formats(cell: &'static std::sync::OnceLock, before: &str, list: &[Format], after: &str) -> &'static str { + cell.get_or_init(|| format!("{before}({}){after}", Format::list(list))) +} + +/// The drawing an input argument names. +fn read_help() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + with_formats(&C, "The drawing to read ", Format::READ, "") +} + +fn open_help() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + with_formats(&C, "Drawings to open ", Format::READ, "") +} + +fn write_help() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + with_formats(&C, "The file to write; its extension picks the format ", Format::WRITE, "") +} + +fn save_help() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + with_formats(&C, "Save the drawing to this file; its extension picks the format ", Format::WRITE, "") +} + +fn export_help() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + with_formats(&C, "Export the drawing to this file; its extension picks the format ", Format::WRITE, "") +} + +fn convert_about() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + with_formats(&C, "Convert a drawing; OUT's extension picks the format ", Format::WRITE, "") +} + +fn convert_long_about() -> &'static str { + static C: std::sync::OnceLock = std::sync::OnceLock::new(); + C.get_or_init(|| { + format!( + "{}\n\nImage output (png 2400x1600, svg, pdf) shows model space, fitted to the drawing extents unless\n--window or --view says otherwise.", + convert_about() + ) + }) +} + +/// cadcraft-cli: headless CADCraft +#[derive(Parser)] +#[command(name = "cadcraft-cli", version = cadcraft_engine::build_version(), arg_required_else_help = true)] +pub(crate) struct Cli { + #[command(subcommand)] + pub(crate) command: Command, +} + +#[derive(Subcommand)] +pub(crate) enum Command { + Info(InfoArgs), + Convert(ConvertArgs), + Run(RunArgs), + Commands(CommandsArgs), + Mcp(McpArgs), + Perf(PerfArgs), + Sample(SampleArgs), +} + +/// Print a drawing's summary as JSON +#[derive(Args)] +pub(crate) struct InfoArgs { + #[arg(help = read_help())] + pub(crate) file: PathBuf, + /// One line of JSON instead of pretty-printed + #[arg(long)] + pub(crate) compact: bool, +} + +/// Convert a drawing; OUT's extension picks the format +#[derive(Args)] +#[command(about = convert_about(), long_about = convert_long_about())] +pub(crate) struct ConvertArgs { + #[arg(value_name = "IN", help = read_help())] + pub(crate) input: PathBuf, + #[arg(value_name = "OUT", help = write_help())] + pub(crate) output: PathBuf, + #[command(flatten)] + pub(crate) framing: FramingArgs, + /// Allow an output that is an input file, replacing the original + #[arg(long)] + pub(crate) in_place: bool, + #[command(flatten)] + pub(crate) settings: Settings, +} + +/// The settings the desktop app reads from its environment, for the subcommands that draw or run +/// commands. A variable is the flag's fallback; an empty one counts as unset, except +/// `CADCRAFT_CONFIG_DIR`. +#[derive(Args)] +#[command(next_help_heading = "Settings")] +pub(crate) struct Settings { + /// The settings folder; plotter configurations are in its `plotters` folder (default: the + /// platform's settings folder). An empty value means no settings folder + // Not RFC-0012 rule 1.7's "an empty variable counts as unset": an empty value is the + // documented way to run with no settings folder (isolated runs, tests), and it predates the + // CLI port. Keep it out of any blanket treatment of empty variables. + #[arg(long, value_name = "DIR", env = "CADCRAFT_CONFIG_DIR", value_parser = OsStringValueParser::new().map(PathBuf::from))] + pub(crate) config_dir: Option, + /// The font that replaces a missing one (FONTALT) + #[arg(long, value_name = "FONT", env = "CADCRAFT_FONTALT")] + pub(crate) fontalt: Option, + /// The fonts tried, in order, for characters a font lacks, comma-separated (FONTFALLBACK) + #[arg(long, value_name = "FONTS", env = "CADCRAFT_FONTFALLBACK")] + pub(crate) fontfallback: Option, +} + +impl Settings { + /// Install the settings for this run; an unset one is the default. An empty or blank + /// `--config-dir` is no settings folder. + pub(crate) fn apply(&self) { + cadcraft_engine::settings_dir::set(self.settings_dir()); + cadcraft_engine::fonts::ttf::set_font_alt(self.fontalt.as_deref().unwrap_or("")); + cadcraft_engine::fonts::ttf::set_fallback_fonts(self.fontfallback.as_deref().unwrap_or("")); + } + + /// The settings folder: `--config-dir`, else the platform's; `None` when the flag is empty or + /// blank. + fn settings_dir(&self) -> Option { + match &self.config_dir { + Some(dir) if dir.to_str().is_some_and(|d| d.trim().is_empty()) => None, + Some(dir) => Some(dir.clone()), + None => cadcraft_engine::settings_dir::platform(|k| std::env::var_os(k)), + } + } +} + +// What part of model space an image shows: shared by `convert` and `run`. +#[derive(Args)] +pub(crate) struct FramingArgs { + /// Show this rectangle (drawing units, x0, + /// What part of model space the image shows (case-insensitive) + #[arg(long, value_name = "extents|current", value_enum, ignore_case = true)] + pub(crate) view: Option, +} + +/// `--view`. +#[derive(Clone, Copy, Debug, PartialEq, ValueEnum)] +pub(crate) enum ViewMode { + /// Always fit the drawing extents + Extents, + /// The current view, as last set by zoom, pan or view.set (a freshly opened drawing's view is + /// its extents plus a 10% margin) + Current, +} + +/// Open drawings (or start a new one), run scripts and commands in order, save or export the result +/// +/// Drawings open in the order given, and the last one is current; without any, a new imperial +/// drawing is used. --script, --script-file and --cmd steps run in the order given, and each +/// --cmd prints its JSON result on one line (JSON lines); a command with no result prints nothing. +/// An image --export (png 2400x1600, svg, pdf) shows model space: +/// the current view if the steps changed it (zoom, pan, view.set…), otherwise the drawing +/// extents, unless --window or --view says otherwise. +#[derive(Args)] +#[command(group(ArgGroup::new("framing").args(["window", "view"]).multiple(true).requires("export")))] +#[command(after_long_help = r#"--cmd chaining: + A --cmd parameter value of exactly "{last}" is replaced with the last object handle an + earlier --cmd in the same run returned, so a command can act on what the previous one made: + --cmd 'mview {"p1":[20,20],"p2":[200,150]}' prints {"viewports":["100"]} + --cmd 'viewport.set {"handle":"{last}","scale":1}' changes viewport 100 + It works in any parameter, at any depth (e.g. "handles":["{last}"]); every other string is + passed unchanged. With no earlier returned handle the run fails and says so."#)] +pub(crate) struct RunArgs { + #[arg(value_name = "FILE", help = open_help())] + pub(crate) files: Vec, + /// Open the built-in sample drawing + #[arg(long)] + pub(crate) sample: bool, + /// Start a new metric drawing + #[arg(long)] + pub(crate) metric: bool, + /// Command-line script text to run (`\n` separates lines) + #[arg(long, value_name = "TEXT", action = ArgAction::Append)] + pub(crate) script: Vec, + /// A script file (.scr) to run + #[arg(long, value_name = "F.scr", action = ArgAction::Append)] + pub(crate) script_file: Vec, + /// An engine command and its JSON parameters (default {}); see "--cmd chaining" in --help + #[arg(long, value_name = "id {json}", action = ArgAction::Append, value_parser = cmd_step)] + pub(crate) cmd: Vec, + #[arg(long, value_name = "OUT.dxf", help = save_help())] + pub(crate) save: Option, + #[arg(long, value_name = "OUT.png", help = export_help())] + pub(crate) export: Option, + #[command(flatten)] + pub(crate) framing: FramingArgs, + /// Allow an output that is an input file, replacing the original + #[arg(long)] + pub(crate) in_place: bool, + #[command(flatten)] + pub(crate) settings: Settings, + /// The drawings, in command-line order, set by [`parse`]. + #[arg(skip)] + pub(crate) drawings: Vec, + /// The steps, in command-line order, set by [`parse`]. + #[arg(skip)] + pub(crate) steps: Vec, +} + +/// A drawing `run` opens. +#[derive(Clone, Debug, PartialEq)] +pub(crate) enum Drawing { + File(PathBuf), + Sample, + Metric, +} + +/// A `--script`, `--script-file` or `--cmd` of `run`. +#[derive(Clone, Debug, PartialEq)] +pub(crate) enum Step { + Script(String), + ScriptFile(PathBuf), + Cmd(CmdStep), +} + +/// `--cmd 'id {json}'`: an engine command and its parameters. `{last}` placeholders are filled in +/// when it runs. +#[derive(Clone, Debug, PartialEq)] +pub(crate) struct CmdStep { + pub(crate) id: String, + pub(crate) params: Value, +} + +/// Print the command catalog as JSON +#[derive(Args)] +pub(crate) struct CommandsArgs { + /// Only the commands whose id or label contains this text (case-insensitive) + pub(crate) filter: Option, + /// One line of JSON instead of pretty-printed + #[arg(long)] + pub(crate) compact: bool, +} + +/// Run the MCP server on stdio: a headless drawing session, or a bridge to the running app +#[derive(Args)] +pub(crate) struct McpArgs { + /// Bridge to the app's control channel (its --control port, e.g. 127.0.0.1:7979) + #[arg(long, value_name = "HOST:PORT", value_parser = connect_addr)] + pub(crate) connect: Option, + /// Reach the app at the first call instead of at startup, so the server can start before the + /// app is open + #[arg(long, requires = "connect")] + pub(crate) lazy: bool, + /// Like --lazy, and a call that finds nothing at HOST:PORT opens the app with that control + /// port first (macOS) + #[arg(long, requires = "connect")] + pub(crate) launch: bool, + #[command(flatten)] + pub(crate) settings: Settings, +} + +/// Time the engine on a synthetic N-entity drawing (default 200000), or the canvas display-list +/// build of a drawing, zoomed in step by step +#[derive(Args)] +pub(crate) struct PerfArgs { + /// An entity count (clamped to 1-20000000), or a drawing to time + #[arg(value_name = "N|FILE", value_parser = PathBufValueParser::new().map(perf_target))] + pub(crate) target: Option, +} + +/// What `perf` times. +#[derive(Clone, Debug, PartialEq)] +pub(crate) enum PerfTarget { + /// A synthetic drawing with this many entities, within [`MAX_PERF_COUNT`]. + Count(usize), + File(PathBuf), +} + +/// The largest synthetic drawing `perf` builds. +const MAX_PERF_COUNT: usize = 20_000_000; + +/// `perf N|FILE`: a value that reads as a count is one, clamped to 1..=[`MAX_PERF_COUNT`] so `perf +/// 0` still times something; anything else is a drawing. +fn perf_target(p: PathBuf) -> PerfTarget { + match p.to_str().and_then(|t| t.parse::().ok()) { + Some(n) => PerfTarget::Count(n.clamp(1, MAX_PERF_COUNT)), + None => PerfTarget::File(p), + } +} + +/// Write a built-in sample drawing +#[derive(Args)] +pub(crate) struct SampleArgs { + /// Which sample + #[arg(value_name = "bracket|floorplan", value_enum)] + pub(crate) name: SampleName, + #[arg(value_name = "OUT", help = write_help())] + pub(crate) output: PathBuf, + #[command(flatten)] + pub(crate) settings: Settings, +} + +/// `sample`'s drawings. +#[derive(Clone, Copy, Debug, PartialEq, ValueEnum)] +pub(crate) enum SampleName { + Bracket, + #[value(alias = "floor")] + Floorplan, +} + +/// What part of model space an image export shows. +#[derive(Clone, Copy, Debug, PartialEq)] +pub(crate) enum Framing { + /// `run`: the current view if the commands changed it, else the extents. `convert`: extents. + Auto, + Extents, + Current, + Window(Bounds2), +} + +/// Why a `--window` value is refused: clap prints it after the flag and its value (exit 2). +#[derive(Debug, thiserror::Error)] +pub(crate) enum WindowError { + #[error("expected four numbers x0,y0,x1,y1")] + NeedsFour, + #[error("{name} must be a finite number, got `{value}`")] + NotFinite { name: &'static str, value: String }, + #[error("need x0 < x1 and y0 < y1 (lower-left corner first)")] + Order, + #[error(transparent)] + Limits(#[from] cadcraft_io::IoError), +} + +/// Why a value is refused: clap prints it after the flag and its value (exit 2). +#[derive(Debug, thiserror::Error)] +pub(crate) enum ValueError { + #[error("expected HOST:PORT (the app's --control port, e.g. 127.0.0.1:7979)")] + Connect, + #[error("expected a command id, then optionally its JSON parameters")] + CmdId, + #[error(transparent)] + CmdJson(#[from] serde_json::Error), +} + +/// Why `parse` refuses flags clap accepted: clap prints it as a usage error (exit 2). +#[derive(Debug, thiserror::Error)] +enum UsageError { + /// The framing flags choose what an image shows; a drawing file has nothing to frame. + #[error("{flag} only applies to image output (png, svg, pdf), not `{}`", .out.display())] + FramingNeedsImage { flag: &'static str, out: PathBuf }, + /// 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), +} + +impl UsageError { + fn into_clap(self, cmd: &mut clap::Command) -> clap::Error { + let kind = match self { + Self::FramingNeedsImage { .. } | Self::OutIsInput(_) => ErrorKind::ArgumentConflict, + }; + cmd.error(kind, self) + } +} + +/// Parse `--window x0,y0,x1,y1` (min corner first). Hostile values are errors, never panics. +pub(crate) fn parse_window(text: &str) -> Result { + let parts: Vec<&str> = text.split(',').map(str::trim).collect(); + let [x0, y0, x1, y1] = parts.as_slice() else { + return Err(WindowError::NeedsFour); + }; + let num = |name: &'static str, v: &str| -> Result { + match v.parse::() { + Ok(n) if n.is_finite() => Ok(n), + _ => Err(WindowError::NotFinite { name, value: v.to_string() }), + } + }; + let (x0, y0, x1, y1) = (num("x0", x0)?, num("y0", y0)?, num("x1", x1)?, num("y1", y1)?); + if !(x0 < x1 && y0 < y1) { + return Err(WindowError::Order); + } + let w = Bounds2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) }; + cadcraft_io::check_window(&w)?; + Ok(w) +} + +/// `run --cmd 'id {json}'`: the id up to the first space, then JSON parameters (default `{}`). +/// Whether they suit the command is the command's to say. +fn cmd_step(s: &str) -> Result { + let (id, json) = s.split_once(' ').unwrap_or((s, "{}")); + if id.is_empty() { + return Err(ValueError::CmdId); + } + Ok(CmdStep { id: id.to_string(), params: serde_json::from_str(json)? }) +} + +impl FramingArgs { + /// The framing `--window` or `--view` asks for (clap refuses both together). + pub(crate) fn framing(&self) -> Framing { + match (self.window, self.view) { + (Some(w), _) => Framing::Window(w), + (None, Some(ViewMode::Extents)) => Framing::Extents, + (None, Some(ViewMode::Current)) => Framing::Current, + (None, None) => Framing::Auto, + } + } + + /// The framing flag given, if any. + fn flag(&self) -> Option<&'static str> { + if self.window.is_some() { + Some("--window") + } else if self.view.is_some() { + Some("--view") + } else { + None + } + } +} + +/// A framing flag given with an output that isn't an image (the extension decides). `run` without +/// `--export` is clap's `requires` error. +fn framing_error(cli: &Cli) -> Option { + let (framing, out): (&FramingArgs, Option<&Path>) = match &cli.command { + Command::Convert(c) => (&c.framing, Some(&c.output)), + Command::Run(r) => (&r.framing, r.export.as_deref()), + _ => return None, + }; + let (flag, out) = (framing.flag()?, out?); + (!cadcraft_io::is_image(out)).then(|| UsageError::FramingNeedsImage { flag, out: out.to_path_buf() }) +} + +/// 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 { + let same = |input: &Path, out: &Path| out.exists() && same_file::is_same_file(input, out).unwrap_or(false); + match &cli.command { + Command::Convert(c) if !c.in_place && same(&c.input, &c.output) => Some(UsageError::OutIsInput(c.output.clone())), + Command::Run(r) if !r.in_place => { + let inputs = r.drawings.iter().filter_map(|d| if let Drawing::File(f) = d { Some(f) } else { None }); + let inputs: Vec<&PathBuf> = inputs.collect(); + [&r.save, &r.export].into_iter().flatten().find(|out| inputs.iter().any(|i| same(i, out))).map(|out| UsageError::OutIsInput(out.clone())) + } + _ => None, + } +} + +/// The backend `cadcraft-cli mcp` serves from. +#[derive(Debug, PartialEq, Eq)] +pub(crate) enum McpTarget { + /// 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 { + 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, + } + } +} + +/// `mcp --connect`: an empty, flag-like or port-less address is an error, never a silent fall back +/// to a headless session (#103). The host is not resolved here. +fn connect_addr(s: &str) -> Result { + let s = s.trim(); + let valid = !s.starts_with('-') + && s.rsplit_once(':').is_some_and(|(host, port)| { + let host = host.strip_prefix('[').and_then(|h| h.strip_suffix(']')).unwrap_or(host); + !host.is_empty() && port.parse::().is_ok() + }); + if valid { Ok(s.to_string()) } else { Err(ValueError::Connect) } +} + +/// The values of `id` with their command-line indices. +fn indexed<'a, T: Clone + Send + Sync + 'static>(m: &'a ArgMatches, id: &str) -> impl Iterator { + let at = m.indices_of(id).into_iter().flatten(); + let values = m.try_get_many::(id).ok().flatten().into_iter().flatten(); + at.zip(values) +} + +/// The command-line index of flag `id`, when it was given. +fn flag_index(m: &ArgMatches, id: &str) -> Option { + if m.value_source(id) == Some(ValueSource::CommandLine) { m.indices_of(id).and_then(Iterator::last) } else { None } +} + +/// `run`'s drawings and steps back in command-line order: clap keeps each flag's values apart, +/// their indices say how they interleave. +fn run_order(m: &ArgMatches) -> (Vec, Vec) { + let mut drawings: Vec<(usize, Drawing)> = indexed(m, "files").map(|(i, f): (_, &PathBuf)| (i, Drawing::File(f.clone()))).collect(); + drawings.extend(flag_index(m, "sample").map(|i| (i, Drawing::Sample))); + drawings.extend(flag_index(m, "metric").map(|i| (i, Drawing::Metric))); + drawings.sort_by_key(|d| d.0); + let mut steps: Vec<(usize, Step)> = indexed(m, "script").map(|(i, s): (_, &String)| (i, Step::Script(s.clone()))).collect(); + steps.extend(indexed(m, "script_file").map(|(i, s): (_, &PathBuf)| (i, Step::ScriptFile(s.clone())))); + steps.extend(indexed(m, "cmd").map(|(i, c): (_, &CmdStep)| (i, Step::Cmd(c.clone())))); + steps.sort_by_key(|s| s.0); + (drawings.into_iter().map(|d| d.1).collect(), steps.into_iter().map(|s| s.1).collect()) +} + +/// Parse the arguments (without the binary name). clap reads them as `OsString`s: a path need not +/// be valid Unicode, text must. A bare `--help` or `-h` is help even after a mistake on the same +/// line (`run --script --help`): clap reports the mistake first. +pub(crate) fn parse(args: &[OsString]) -> Result { + parse_with(command(|k| std::env::var_os(k)), args) +} + +/// The command line. An empty or blank variable counts as unset, except `CADCRAFT_CONFIG_DIR`: +/// empty means no settings folder. `var` looks a variable up. +fn command(var: impl Fn(&OsStr) -> Option + Copy) -> clap::Command { + let blank = move |a: clap::Arg| if a.get_id() == "config_dir" { a } else { blank_env_is_unset(a, var) }; + Cli::command().mut_args(blank).mut_subcommands(|s| s.mut_args(blank)) +} + +/// [`parse`] with `cmd` from [`command`]; a bad value from a variable is a usage error naming the +/// variable. +fn parse_with(mut cmd: clap::Command, args: &[OsString]) -> Result { + let argv = std::iter::once(OsString::from("cadcraft-cli")).chain(args.iter().cloned()); + let matches = match cmd.try_get_matches_from_mut(argv) { + // `use_stderr`: a real error, not the help `-h` asked for (a retry would make it `--help`). + Err(e) if e.use_stderr() && args.iter().take_while(|a| *a != "--").any(|a| *a == "--help" || *a == "-h") => { + let help = [OsString::from("cadcraft-cli"), args.first().cloned().unwrap_or_default(), OsString::from("--help")]; + return Err(cmd.try_get_matches_from_mut(help).err().unwrap_or(e)); + } + matches => matches.map_err(|e| name_env_vars(e, &cmd, args))?, + }; + let mut cli = Cli::from_arg_matches(&matches)?; + 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)) { + if let Some(sub) = matches.subcommand_name().and_then(|n| cmd.find_subcommand_mut(n)) { + return Err(e.into_clap(sub)); + } + return Err(e.into_clap(&mut cmd)); + } + Ok(cli) +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn parse_args(a: &[&str]) -> Result { + parse(&a.iter().map(OsString::from).collect::>()) + } + + fn mcp(a: &[&str]) -> Result { + let args: Vec<&str> = std::iter::once("mcp").chain(a.iter().copied()).collect(); + match parse_args(&args)?.command { + Command::Mcp(m) => Ok(m.target()), + _ => panic!("{a:?} is not mcp"), + } + } + + /// Every file argument's help names each format of the list it uses. + #[test] + fn help_names_every_format() { + let cli = Cli::command(); + let help = |sub: &str, arg: &str| { + let a = cli.find_subcommand(sub).and_then(|c| c.get_arguments().find(|a| a.get_id() == arg)).expect("argument exists"); + a.get_help().map(|h| h.to_string()).unwrap_or_default() + }; + let cases: [(&str, &str, &[Format]); 8] = [ + ("info", "file", Format::READ), + ("convert", "input", Format::READ), + ("convert", "output", Format::WRITE), + ("run", "files", Format::READ), + ("run", "save", Format::WRITE), + ("run", "export", Format::WRITE), + ("sample", "output", Format::WRITE), + ("convert", "", Format::WRITE), + ]; + for (sub, arg, list) in cases { + let text = if arg.is_empty() { + cli.find_subcommand(sub).and_then(|c| c.get_about()).map(|a| a.to_string()).unwrap_or_default() + } else { + help(sub, arg) + }; + for f in list { + assert!(text.contains(f.extension()), "`{sub} {arg}` help `{text}` lacks {}", f.extension()); + } + } + } + + #[test] + fn mcp_without_connect_is_headless() { + assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless); + } + + #[test] + fn mcp_connect_with_address_selects_remote() { + let to = |addr: &str, lazy, launch| McpTarget::Connect { addr: addr.into(), lazy, launch }; + assert_eq!(mcp(&["--connect", "127.0.0.1:7979"]).unwrap(), to("127.0.0.1:7979", false, false)); + assert_eq!(mcp(&["--connect", " localhost:7979 "]).unwrap(), to("localhost:7979", false, false)); + assert_eq!(mcp(&["--lazy", "--connect", "localhost:7979"]).unwrap(), to("localhost:7979", true, false)); + assert_eq!(mcp(&["--connect", "localhost:7979", "--launch"]).unwrap(), to("localhost:7979", true, true)); + assert_eq!(mcp(&["--connect", "[::1]:7979"]).unwrap(), to("[::1]:7979", false, false)); + // Without an app to reach they mean nothing: never a headless session. + for flag in ["--lazy", "--launch"] { + assert_eq!(mcp(&[flag]).unwrap_err().kind(), clap::error::ErrorKind::MissingRequiredArgument, "{flag}"); + } + } + + #[test] + fn mcp_connect_without_address_is_an_error_not_headless() { + for bad in [ + &["--connect"][..], + &["--connect", ""], + &["--connect", " "], + &["--connect=-v"], + &["--connect", "example.com"], + &["--connect", ":7979"], + &["--connect", "host:99999"], + &["--connect", "[]:1"], + ] { + let r = mcp(bad); + let Err(e) = r else { panic!("{bad:?} should be rejected, got {r:?}") }; + assert_eq!(e.exit_code(), 2, "{bad:?}"); + assert!(e.to_string().contains("--connect "), "{bad:?}: {e}"); + } + } + + #[test] + fn mcp_rejects_unknown_and_repeated_arguments() { + assert!(mcp(&["--conect", "127.0.0.1:7979"]).is_err()); + assert!(mcp(&["127.0.0.1:7979"]).is_err()); + // clap names the unknown flag, not the value it left missing. + for flag in ["--foo", "-v"] { + assert_eq!(mcp(&["--connect", flag]).unwrap_err().kind(), clap::error::ErrorKind::UnknownArgument, "{flag}"); + } + assert!(mcp(&["--connect", "127.0.0.1:1", "--connect", "127.0.0.1:2"]).is_err()); + } + + #[test] + fn run_keeps_command_line_order() { + let args = + ["run", "a.dxf", "--script", "S1", "--metric", "--cmd", "c1", "b.dxf", "--script-file", "f.scr", "--sample", "--cmd", "c2 {\"n\":1}"]; + let Command::Run(r) = parse_args(&args).unwrap().command else { panic!("not run") }; + let file = |f: &str| Drawing::File(f.into()); + let cmd = |id: &str, params| Step::Cmd(CmdStep { id: id.into(), params }); + assert_eq!(r.drawings, [file("a.dxf"), Drawing::Metric, file("b.dxf"), Drawing::Sample]); + assert_eq!(r.steps, [Step::Script("S1".into()), cmd("c1", json!({})), Step::ScriptFile("f.scr".into()), cmd("c2", json!({"n": 1}))]); + } + + #[test] + fn cmd_values() { + assert_eq!(cmd_step("line").unwrap(), CmdStep { id: "line".into(), params: json!({}) }); + assert_eq!(cmd_step("line [1]").unwrap(), CmdStep { id: "line".into(), params: json!([1]) }); + for bad in ["", " {}", "line {bad json", "line "] { + assert!(cmd_step(bad).is_err(), "`{bad}` should be rejected"); + } + } + + #[test] + fn perf_targets() { + let target = |a: &[&str]| -> Option { + let args: Vec<&str> = std::iter::once("perf").chain(a.iter().copied()).collect(); + let Command::Perf(p) = parse_args(&args).unwrap().command else { panic!("not perf") }; + p.target + }; + assert_eq!(target(&[]), None); + assert_eq!(target(&["5"]), Some(PerfTarget::Count(5))); + assert_eq!(target(&["0"]), Some(PerfTarget::Count(1))); + assert_eq!(target(&["999999999"]), Some(PerfTarget::Count(MAX_PERF_COUNT))); + assert_eq!(target(&["a.dxf"]), Some(PerfTarget::File("a.dxf".into()))); + assert_eq!(target(&["1e3"]), Some(PerfTarget::File("1e3".into()))); + } + + #[test] + fn framing_options() { + let framing = |out: &str, a: &[&str]| -> Result { + let args: Vec<&str> = ["convert", "a.dxf", out].iter().chain(a).copied().collect(); + let Command::Convert(c) = parse_args(&args)?.command else { panic!("not convert") }; + Ok(c.framing.framing()) + }; + let b = |x0, y0, x1, y1| Bounds2::new(Vec2::new(x0, y0), Vec2::new(x1, y1)); + assert_eq!(framing("b.png", &[]).unwrap(), Framing::Auto); + assert_eq!(framing("b.png", &["--view", "extents"]).unwrap(), Framing::Extents); + assert_eq!(framing("b.png", &["--view", "CURRENT"]).unwrap(), Framing::Current); + assert_eq!(framing("b.png", &["--window", "0,0,2,1"]).unwrap(), Framing::Window(b(0.0, 0.0, 2.0, 1.0))); + assert_eq!(framing("b.dxf", &[]).unwrap(), Framing::Auto); + let kind = |out: &str, a: &[&str]| framing(out, a).map(|_| ()).unwrap_err().kind(); + assert_eq!(kind("b.png", &["--view", "selection"]), ErrorKind::InvalidValue); + assert_eq!(kind("b.png", &["--window", "0,0,2,1", "--view", "extents"]), ErrorKind::ArgumentConflict); + assert_eq!(kind("b.dxf", &["--view", "extents"]), ErrorKind::ArgumentConflict); + assert_eq!(kind("b.dxf", &["--window", "0,0,2,1"]), ErrorKind::ArgumentConflict); + } + + #[test] + fn window_parses() { + let b = |x0, y0, x1, y1| Bounds2::new(Vec2::new(x0, y0), Vec2::new(x1, y1)); + assert_eq!(parse_window("0,0,30,20").unwrap(), b(0.0, 0.0, 30.0, 20.0)); + assert_eq!(parse_window(" -5.5, -1e3 ,2e3,4 ").unwrap(), b(-5.5, -1000.0, 2000.0, 4.0)); + } + + #[test] + fn hostile_window_is_an_error() { + for w in [ + "", + "1,2,3", + "1,2,3,4,5", + "a,0,1,1", + "NaN,0,1,1", + "0,0,inf,1", + "0,0,1e400,1", + "0,0,0,1", + "0,0,1,0", + "5,0,1,1", + "0,5,1,1", + "-1e300,-1e300,1e300,1e300", + "0,0,1e-12,1e-12", + ] { + assert!(parse_window(w).is_err(), "`{w}` should be rejected"); + } + } + + /// The subcommands that draw or run commands take the settings flags; the others refuse them. + #[test] + fn settings_flags() { + let Command::Convert(c) = + parse_args(&["convert", "a.dxf", "b.png", "--config-dir", "/p", "--fontalt", "Noto Sans", "--fontfallback="]).unwrap().command + else { + panic!("not convert") + }; + assert_eq!(c.settings.config_dir, Some(PathBuf::from("/p"))); + assert_eq!((c.settings.fontalt.as_deref(), c.settings.fontfallback.as_deref()), (Some("Noto Sans"), Some(""))); + for empty in ["--config-dir=", "--config-dir= "] { + let Command::Run(r) = parse_args(&["run", "--sample", empty]).unwrap().command else { panic!("not run") }; + assert_eq!(r.settings.settings_dir(), None, "`{empty}` is no settings folder"); + } + let Command::Convert(c) = parse_args(&["convert", "a.dxf", "b.png", "--config-dir", "/p"]).unwrap().command else { panic!("not convert") }; + assert_eq!(c.settings.settings_dir(), Some(PathBuf::from("/p"))); + assert!(parse_args(&["sample", "bracket", "b.dxf", "--fontalt", "x"]).is_ok()); + assert!(parse_args(&["mcp", "--config-dir", "/p"]).is_ok()); + assert!(parse_args(&["info", "a.dxf", "--config-dir", "/p"]).is_err()); + } + + #[test] + fn blank_variables_count_as_unset_except_the_config_dir() { + let cmd = command(|_| Some("".into())); + for sub in cmd.get_subcommands().filter(|s| s.get_arguments().any(|a| a.get_id() == "fontalt")) { + let env = |id: &str| sub.get_arguments().find(|a| a.get_id() == id).and_then(|a| a.get_env()); + assert_eq!((env("fontalt"), env("fontfallback")), (None, None), "{}", sub.get_name()); + assert_eq!(env("config_dir"), Some(OsStr::new("CADCRAFT_CONFIG_DIR")), "{}", sub.get_name()); + } + } + + /// `--fontalt` falls back to `PATH` and rejects every value here, as a bad value from a + /// variable would; tests can't set a variable (`set_var` is unsafe). + #[test] + fn a_bad_value_from_a_variable_names_the_variable() { + // Cargo sets CARGO_PKG_NAME for every test binary, so the variable always has a value. + let reject = clap::builder::PossibleValuesParser::new(["never"]); + let cmd = || Cli::command().mut_subcommand("sample", |s| s.mut_arg("fontalt", |a| a.env("CARGO_PKG_NAME").value_parser(reject.clone()))); + let args = |a: &[&str]| a.iter().map(OsString::from).collect::>(); + let text = parse_with(cmd(), &args(&["sample"])).err().map(|e| e.to_string()).unwrap_or_default(); + assert!(text.contains("for 'CARGO_PKG_NAME'") && !text.contains("--fontalt"), "{text}"); + let text = parse_with(cmd(), &args(&["sample", "--fontalt", "x"])).err().map(|e| e.to_string()).unwrap_or_default(); + assert!(text.contains("--fontalt"), "{text}"); + } +} diff --git a/apps/cadcraft-cli/src/commands.rs b/apps/cadcraft-cli/src/commands.rs new file mode 100644 index 000000000..51fc06606 --- /dev/null +++ b/apps/cadcraft-cli/src/commands.rs @@ -0,0 +1,17 @@ +use super::args::CommandsArgs; +use super::error::Result; +use super::output::Streams; +use cadcraft_engine::Session; +use serde_json::Value; + +pub(crate) fn commands(a: &CommandsArgs, io: &mut Streams) -> Result { + let s = Session::new(); + let f = a.filter.as_ref().map(|x| x.to_ascii_lowercase()); + let v: Vec = cadcraft_engine::command_specs() + .iter() + .filter(|c| f.as_ref().is_none_or(|f| c.id.contains(f.as_str()) || c.label.to_ascii_lowercase().contains(f.as_str()))) + .map(|c| serde_json::to_value(c.info(&s)).unwrap_or_default()) + .collect(); + io.json(&Value::Array(v), a.compact); + Ok(()) +} diff --git a/apps/cadcraft-cli/src/convert.rs b/apps/cadcraft-cli/src/convert.rs new file mode 100644 index 000000000..6a9c4edbf --- /dev/null +++ b/apps/cadcraft-cli/src/convert.rs @@ -0,0 +1,22 @@ +use super::args::ConvertArgs; +use super::error::Result; +use super::output::{Streams, export_framed, export_window, skipped_message, undrawn_message}; +use super::{open, unicode}; +use cadcraft_engine::Session; + +pub(crate) fn convert(a: &ConvertArgs, io: &mut Streams) -> Result { + let i = unicode(&a.input)?; + let framing = a.framing.framing(); + let mut s = Session::empty(); + open(&mut s, &a.input)?; + if let Some(m) = skipped_message(s.doc()?, i) { + io.errln(format_args!("{m}")); + } + if cadcraft_io::is_image(&a.output) + && let Some(m) = undrawn_message(s.doc()?, i) + { + io.errln(format_args!("{m}")); + } + let window = export_window(&s, framing, None)?; + export_framed(&s, &a.output, window, io) +} diff --git a/apps/cadcraft-cli/src/error.rs b/apps/cadcraft-cli/src/error.rs new file mode 100644 index 000000000..51b816890 --- /dev/null +++ b/apps/cadcraft-cli/src/error.rs @@ -0,0 +1,29 @@ +use crate::output::OutputError; +use crate::perf::PerfError; +use crate::run::RunError; + +/// Why a subcommand failed: printed as `error: {e}`, exit 1. +#[derive(Debug, thiserror::Error)] +pub(crate) enum CliError { + #[error(transparent)] + Engine(#[from] cadcraft_engine::EngineError), + #[error(transparent)] + Doc(#[from] cadcraft_engine::doc::DocError), + #[error(transparent)] + Format(#[from] cadcraft_io::IoError), + #[error(transparent)] + Io(#[from] std::io::Error), + #[error(transparent)] + Run(#[from] RunError), + #[error(transparent)] + Output(#[from] OutputError), + #[error(transparent)] + Perf(#[from] PerfError), + /// The engine and io crates take file names as text. + #[error("{}: the file name is not valid Unicode", .0.display())] + NotUnicode(std::path::PathBuf), + #[error("cannot connect to {addr}: {source}")] + McpConnect { addr: String, source: std::io::Error }, +} + +pub(crate) type Result = std::result::Result; diff --git a/apps/cadcraft-cli/src/info.rs b/apps/cadcraft-cli/src/info.rs new file mode 100644 index 000000000..bac94108e --- /dev/null +++ b/apps/cadcraft-cli/src/info.rs @@ -0,0 +1,14 @@ +use super::args::InfoArgs; +use super::error::Result; +use super::open; +use super::output::Streams; +use cadcraft_engine::Session; +use serde_json::json; + +pub(crate) fn info(a: &InfoArgs, io: &mut Streams) -> Result { + let mut s = Session::empty(); + open(&mut s, &a.file)?; + let v = s.execute("drawing.inspect", &json!({ "entities": false }))?; + io.json(&v, a.compact); + Ok(()) +} diff --git a/apps/cadcraft-cli/src/lib.rs b/apps/cadcraft-cli/src/lib.rs new file mode 100644 index 000000000..c858417e2 --- /dev/null +++ b/apps/cadcraft-cli/src/lib.rs @@ -0,0 +1,315 @@ +//! `cadcraft-cli`: headless CADCraft. The subcommands and their options are the clap types in +//! `args.rs`; `cadcraft-cli --help` lists them. +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] + +use std::ffi::OsString; +use std::io::Write; + +use cadcraft_engine::Session; +use serde_json::json; + +mod args; +mod commands; +mod convert; +mod error; +mod info; +mod mcp; +mod output; +mod perf; +mod run; +mod sample; + +#[cfg(test)] +use args::Framing; +use args::{Command, parse}; +use clap::CommandFactory; +use commands::commands; +use convert::convert; +use error::Result; +use info::info; +use mcp::mcp; +use output::Streams; +#[cfg(test)] +use output::{export_window, model_views, write_atomic}; +use perf::perf; +use run::run_cmds; +#[cfg(test)] +use run::{fill_last, returned_handle}; +use sample::sample; + +fn install_io() { + cadcraft_engine::cmd::file::set_io(cadcraft_engine::cmd::file::IoHooks { + read: |b, name| cadcraft_io::read(b, name).map_err(|e| e.to_string()), + write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()), + plot: Some(|d, space, opts| cadcraft_io::plotter::plot(d, space, opts).map_err(|e| e.to_string())), + }); + cadcraft_engine::cmd::file::set_write_as(|d, name, o| { + cadcraft_io::write_with(d, name, &cadcraft_io::SaveOptions { version: o.version, binary: o.binary }).map_err(|e| e.to_string()) + }); + // AutoLISP's entget, entmake and entmod see entities as DXF groups. + cadcraft_engine::cmd::file::set_entity_codec(cadcraft_engine::cmd::file::EntityCodec { + groups: cadcraft_io::entity_groups, + entity: cadcraft_io::entity_from_groups, + }); +} + +/// `path` as text, for the engine and io calls that take a file name as a string. +fn unicode(path: &std::path::Path) -> Result<&str> { + path.to_str().ok_or_else(|| error::CliError::NotUnicode(path.to_path_buf())) +} + +fn open(s: &mut Session, path: &std::path::Path) -> Result { + s.execute("open", &json!({ "path": unicode(path)? }))?; + Ok(()) +} + +/// The command line's clap definition, for generating shell completions and man pages. +pub fn command() -> clap::Command { + args::Cli::command() +} + +/// Run the CLI on its arguments (without the program name). Returns the process exit code (0 ok, +/// 1 failure, 2 usage). clap reads the arguments as they are: a value that is not valid Unicode +/// is a usage error, never a panic as with `std::env::args()`. +pub fn run(args: I, out: &mut dyn Write, err: &mut dyn Write) -> i32 +where + I: IntoIterator, + T: Into, +{ + let args: Vec = args.into_iter().map(Into::into).collect(); + // Help and `--version` (`help`, `-h`, ` --help`, `-V`) come back as errors too, + // for `out`, exit 0: the subcommand never runs. + let cli = match parse(&args) { + Ok(cli) => cli, + Err(e) => { + let to: &mut dyn Write = if e.use_stderr() { err } else { out }; + return match write!(to, "{}", e.render()) { + Err(w) if w.kind() != std::io::ErrorKind::BrokenPipe => { + let _ = writeln!(err, "error: can't write the output: {w}"); + 1 + } + _ => e.exit_code(), + }; + } + }; + // The engine's hooks are set-once, so installing them on every call is harmless. + install_io(); + match &cli.command { + Command::Convert(a) => a.settings.apply(), + Command::Run(a) => a.settings.apply(), + Command::Mcp(a) => a.settings.apply(), + Command::Sample(a) => a.settings.apply(), + Command::Info(_) | Command::Commands(_) | Command::Perf(_) => {} + } + let mut io = Streams::new(out, err); + let result = match &cli.command { + Command::Info(a) => info(a, &mut io), + Command::Convert(a) => convert(a, &mut io), + Command::Run(a) => run_cmds(a, &mut io), + Command::Commands(a) => commands(a, &mut io), + Command::Mcp(a) => mcp(a), + Command::Perf(a) => perf(a.target.as_ref(), &mut io), + Command::Sample(a) => sample(a, &mut io), + }; + let mut code = 0; + if let Err(e) = result { + io.errln(format_args!("error: {e}")); + code = 1; + } + io.finish(); + if io.stdout_failed() { 1 } else { code } +} + +#[cfg(test)] +mod tests { + use super::*; + use cadcraft_engine::doc::Space; + use cadcraft_engine::geom::{Bounds2, Vec2}; + + fn scratch_dir(tag: &str) -> std::path::PathBuf { + let dir = std::env::temp_dir().join(format!("cadcraft-cli-{tag}-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).expect("create scratch dir"); + dir + } + + struct FailingWriter(std::io::ErrorKind); + + impl Write for FailingWriter { + fn write(&mut self, _: &[u8]) -> std::io::Result { + Err(self.0.into()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + #[test] + fn a_failed_write_of_help_exits_1_unless_the_pipe_is_closed() { + let mut err = Vec::new(); + assert_eq!(run(["--help"], &mut FailingWriter(std::io::ErrorKind::StorageFull), &mut err), 1); + assert!(String::from_utf8_lossy(&err).starts_with("error: ")); + assert_eq!(run(["--help"], &mut FailingWriter(std::io::ErrorKind::BrokenPipe), &mut Vec::new()), 0); + } + + #[test] + fn write_atomic_replaces_file_and_leaves_no_staging_files() { + let dir = scratch_dir("replace"); + let out = dir.join("a.dxf"); + write_atomic(&out, b"old").expect("create"); + write_atomic(&out, b"new").expect("overwrite"); + assert_eq!(std::fs::read(&out).expect("read"), b"new"); + assert_eq!(std::fs::read_dir(&dir).expect("list").count(), 1); + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn write_atomic_failure_keeps_destination_and_cleans_up() { + let dir = scratch_dir("fail"); + let out = dir.join("target"); + std::fs::create_dir(&out).expect("dir as destination"); + std::fs::write(out.join("keep"), b"x").expect("seed"); + assert!(write_atomic(&out, b"new").is_err()); + assert_eq!(std::fs::read(out.join("keep")).expect("kept"), b"x"); + assert_eq!(std::fs::read_dir(&dir).expect("list").count(), 1); + let _ = std::fs::remove_dir_all(&dir); + } + + fn b(x0: f64, y0: f64, x1: f64, y1: f64) -> Bounds2 { + Bounds2::new(Vec2::new(x0, y0), Vec2::new(x1, y1)) + } + + fn sample_session() -> Session { + let mut s = Session::empty(); + s.open_drawing(cadcraft_engine::sample::default_sample(), "Bracket", None); + s + } + + fn view_box(svg: &str) -> String { + let i = svg.find("viewBox=\"").map(|i| i + 9).unwrap_or(0); + svg[i..].split('"').next().unwrap_or("").to_string() + } + + fn assert_near(a: Bounds2, e: Bounds2) { + let d = (a.min - e.min).len().max((a.max - e.max).len()); + assert!(d < 1e-9, "{a:?} != {e:?}"); + } + + #[test] + fn last_placeholder_takes_the_previous_handle() { + let mut s = sample_session(); + let r = s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap(); + let h = returned_handle(&s, &r).expect("LINE returns its handle"); + assert_eq!(fill_last(&json!({"handle": "{last}"}), Some(h)).unwrap(), json!({"handle": h.hex()})); + // Nested, as in a selection list. + assert_eq!(fill_last(&json!({"handles": ["{last}", "1"]}), Some(h)).unwrap(), json!({"handles": [h.hex(), "1"]})); + // Only the exact token: a name or a sentence that merely contains it stays as written. + for p in [json!("last"), json!("{last} "), json!({"name": "last"})] { + assert_eq!(fill_last(&p, Some(h)).unwrap(), p); + } + // Nothing returned yet: an error, not a token passed to the command as a bad handle. + assert!(fill_last(&json!({"handle": "{last}"}), None).unwrap_err().to_string().contains("{last}")); + } + + /// Handles are read from a result by looking the strings up in the drawing: counts and names + /// are not mistaken for handles, and `mview`'s `viewports` works like `handle`/`handles`. + #[test] + fn returned_handle_reads_only_real_handles() { + let mut s = Session::empty(); + s.new_drawing(false); + s.execute("layout.set", &json!({"name": "Layout1"})).unwrap(); + let r = s.execute("mview", &json!({"p1": [20, 20], "p2": [200, 150]})).unwrap(); + let h = returned_handle(&s, &r).expect("mview returns its viewport handle"); + assert!(r["viewports"].as_array().is_some_and(|a| a.iter().any(|v| v.as_str() == Some(h.hex().as_str()))), "{r}"); + assert_eq!(returned_handle(&s, &json!({"changed": 3, "name": "A1"})), None); + // The most recent of several. + let a = s.execute("line", &json!({"points": [[0, 0], [1, 0]]})).unwrap(); + let b = s.execute("line", &json!({"points": [[0, 0], [2, 0]]})).unwrap(); + let (ha, hb) = (returned_handle(&s, &a).unwrap(), returned_handle(&s, &b).unwrap()); + assert_eq!(returned_handle(&s, &json!({"handles": [ha.hex(), hb.hex()]})), Some(hb)); + } + + #[test] + fn default_framing_is_extents() { + // convert: nothing ran, always the extents. + let s = sample_session(); + assert_eq!(export_window(&s, Framing::Auto, None).unwrap(), None); + // run: commands that leave the view alone keep the extents framing. + let mut s = sample_session(); + let before = model_views(&s); + s.script("LINE 0,0 10,10\n\n").unwrap(); + assert_eq!(export_window(&s, Framing::Auto, Some(&before)).unwrap(), None); + // A fresh drawing too. + let mut s = Session::empty(); + s.new_drawing(false); + let before = model_views(&s); + s.execute("circle", &json!({"center": [0, 0], "radius": 5})).unwrap(); + assert_eq!(export_window(&s, Framing::Auto, Some(&before)).unwrap(), None); + } + + #[test] + fn zoom_window_frames_export() { + let mut s = sample_session(); + let before = model_views(&s); + s.execute("zoom", &json!({"mode": "window", "p1": [0, 0], "p2": [30, 20]})).unwrap(); + let w = export_window(&s, Framing::Auto, Some(&before)).unwrap().unwrap(); + // The CLI viewport is 3:2, so a 3:2 window is shown exactly. + assert_near(w, b(0.0, 0.0, 30.0, 20.0)); + assert_eq!(export_window(&s, Framing::Current, Some(&before)).unwrap(), Some(w)); + // --view extents and --window override the zoom. + assert_eq!(export_window(&s, Framing::Extents, Some(&before)).unwrap(), None); + let explicit = b(1.0, 1.0, 2.0, 2.0); + assert_eq!(export_window(&s, Framing::Window(explicit), Some(&before)).unwrap(), Some(explicit)); + // A taller window keeps its height; the 3:2 image adds room left and right. + s.execute("zoom", &json!({"mode": "center", "center": [5, 5], "height": 4})).unwrap(); + assert_near(export_window(&s, Framing::Auto, Some(&before)).unwrap().unwrap(), b(2.0, 3.0, 8.0, 7.0)); + } + + #[test] + fn zoom_object_frames_the_selection() { + let mut s = sample_session(); + let before = model_views(&s); + // The smallest entity with an area, selected then framed with ZOOM Object. + let d = s.doc().unwrap(); + let bounds = |e: &cadcraft_engine::doc::Entity| cadcraft_engine::doc::entity_bounds(d, e, 0); + let e = d + .model + .iter() + .filter(|e| bounds(e).width() > 0.0 && bounds(e).height() > 0.0) + .min_by(|a, b| bounds(a).width().total_cmp(&bounds(b).width())) + .unwrap(); + let (h, eb, ext) = (e.handle, bounds(e), d.extents(&Space::Model)); + s.set_selection(vec![h]); + s.execute("zoom", &json!({"mode": "object"})).unwrap(); + let w = export_window(&s, Framing::Auto, Some(&before)).unwrap().unwrap(); + assert!(w.contains(eb.min) && w.contains(eb.max)); + assert!(w.width() < ext.width() && w.height() < ext.height(), "{w:?} vs extents {ext:?}"); + } + + #[test] + fn run_export_honours_zoom() { + let dir = std::env::temp_dir().join(format!("cadcraft-cli-165-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let path = |n: &str| dir.join(n).to_string_lossy().to_string(); + let run_svg = |extra: &[&str], out: &str| -> String { + let mut args: Vec = ["run", "--sample"].iter().chain(extra).map(|a| a.to_string()).collect(); + args.extend(["--export".to_string(), path(out)]); + assert_eq!(run(args, &mut Vec::new(), &mut Vec::new()), 0); + std::fs::read_to_string(path(out)).unwrap() + }; + let base = run_svg(&[], "base.svg"); + let zoomed = run_svg(&["--cmd", r#"zoom {"mode":"window","p1":[0,0],"p2":[30,20]}"#], "zoom.svg"); + let window = run_svg(&["--window", "0,0,30,20"], "window.svg"); + let forced = run_svg(&["--cmd", r#"zoom {"mode":"window","p1":[0,0],"p2":[30,20]}"#, "--view", "extents"], "forced.svg"); + assert_ne!(view_box(&zoomed), view_box(&base)); + assert_eq!(view_box(&zoomed), "0 0 30.000000 20.000000"); + assert_eq!(zoomed, window); + assert_eq!(forced, base); + // Hostile --window: a usage error, nothing written. + let mut err = Vec::new(); + assert_eq!(run(["run", "--sample", "--window", "0,0,NaN,1", "--export", &path("bad.png")], &mut Vec::new(), &mut err), 2); + assert!(String::from_utf8_lossy(&err).contains("--window")); + assert!(!dir.join("bad.png").exists()); + let _ = std::fs::remove_dir_all(&dir); + } +} diff --git a/apps/cadcraft-cli/src/main.rs b/apps/cadcraft-cli/src/main.rs index 99a8b4282..7561b96b5 100644 --- a/apps/cadcraft-cli/src/main.rs +++ b/apps/cadcraft-cli/src/main.rs @@ -1,1111 +1,8 @@ -//! `cadcraft-cli`: headless CADCraft. -//! -//! ```text -//! cadcraft-cli info FILE.dxf summary as JSON -//! cadcraft-cli convert IN.dxf OUT.(dxf|svg|png) [--window x0,y0,x1,y1 | --view extents|current] -//! cadcraft-cli run [FILE|--sample|--metric] [--script TEXT|--script-file F.scr] [--cmd 'id {json}']... [--save OUT] [--export OUT.png] [--window ... | --view ...] -//! cadcraft-cli commands [FILTER] command catalog (JSON) -//! cadcraft-cli mcp [--connect HOST:PORT [--lazy] [--launch]] MCP server on stdio (headless or bridged to the app) -//! cadcraft-cli perf [N] timing table on a synthetic N-entity drawing -//! cadcraft-cli perf FILE canvas display-list build of a drawing, zoomed in step by step -//! cadcraft-cli sample (bracket|floorplan) OUT write a built-in sample drawing -//! ``` #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] -/// `println!` that doesn't panic when stdout is closed (`cadcraft-cli commands | head`) with -/// "failed printing to stdout: Broken pipe (os error 32)". Once stdout has failed, later output is -/// dropped and the work goes on: see `stdout_failed`. -macro_rules! outln { - ($($arg:tt)*) => {{ - use std::io::Write as _; - if !$crate::stdout_gone() { - if let Err(e) = writeln!(std::io::stdout(), $($arg)*) { - $crate::stdout_failed(e); - } - } - }}; -} - -use std::process::ExitCode; - -use cadcraft_engine::doc::{Handle, Space}; -use cadcraft_engine::geom::{Bounds2, Vec2}; -use cadcraft_engine::{Session, View}; -use serde_json::{Value, json}; -use std::sync::atomic::{AtomicBool, Ordering}; - -/// Set once a write to stdout has failed; later output is dropped. -static STDOUT_GONE: AtomicBool = AtomicBool::new(false); -/// Set when stdout failed for a reason other than a closed reader: the exit status becomes 1. -static STDOUT_ERROR: AtomicBool = AtomicBool::new(false); - -fn stdout_gone() -> bool { - STDOUT_GONE.load(Ordering::Relaxed) -} - -/// stdout went away. The program doesn't stop there: the rest of `run` (later `--cmd` results, -/// `--save`, `--export`) still happens, so `cadcraft-cli run … --save out.dxf | head` keeps the -/// drawing. A reader that stopped early (a closed pipe) is not an error, as in ripgrep; any other -/// write error is reported and makes the exit status 1. -fn stdout_failed(e: std::io::Error) { - if STDOUT_GONE.swap(true, Ordering::Relaxed) || e.kind() == std::io::ErrorKind::BrokenPipe { - return; - } - eprintln!("cadcraft-cli: can't write to stdout: {e}"); - STDOUT_ERROR.store(true, Ordering::Relaxed); -} - -const USAGE: &str = "usage: - cadcraft-cli info FILE.dxf - cadcraft-cli convert IN.dxf OUT.(dxf|dwg|svg|png|pdf) [FRAMING] - cadcraft-cli run [FILE | --sample | --metric] [--script TEXT] [--script-file F.scr] [--cmd 'id {json}']... [--save OUT.dxf] [--export OUT.(png|svg|pdf)] [FRAMING] - cadcraft-cli commands [FILTER] - cadcraft-cli mcp [--connect HOST:PORT [--lazy] [--launch]] - cadcraft-cli perf [N | FILE] - cadcraft-cli sample (bracket|floorplan) OUT.(dxf|dwg|svg|png) - cadcraft-cli --version - -image framing (png 2400x1600, svg, pdf; always model space): - default convert: fit the drawing extents. - run --export: the current view if the script/commands changed it - (zoom, pan, view.set...), otherwise fit the drawing extents. - --window x0,y0,x1,y1 show this rectangle (drawing units, x0 Result { - let parts: Vec<&str> = text.split(',').map(str::trim).collect(); - let [x0, y0, x1, y1] = parts.as_slice() else { - return Err(format!("--window needs four numbers x0,y0,x1,y1, got `{text}`")); - }; - let num = |name: &str, v: &str| -> Result { - match v.parse::() { - Ok(n) if n.is_finite() => Ok(n), - _ => Err(format!("--window: {name} must be a finite number, got `{v}`")), - } - }; - let (x0, y0, x1, y1) = (num("x0", x0)?, num("y0", y0)?, num("x1", x1)?, num("y1", y1)?); - if !(x0 < x1 && y0 < y1) { - return Err(format!("--window: need x0 < x1 and y0 < y1 (lower-left corner first), got {x0},{y0},{x1},{y1}")); - } - let w = Bounds2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) }; - cadcraft_io::check_window(&w).map_err(|e| format!("--window: {e}"))?; - Ok(w) -} - -/// Parse a framing option (`--window`, `--view`) at `a`, taking its value from `it`. `Ok(false)` -/// means `a` is not a framing option. -fn framing_option<'a>(a: &str, it: &mut impl Iterator, framing: &mut Framing) -> Result { - let f = match a { - "--window" => Framing::Window(parse_window(it.next().ok_or("--window needs x0,y0,x1,y1")?)?), - "--view" => match it.next().map(|v| v.to_ascii_lowercase()).as_deref() { - Some("extents") => Framing::Extents, - Some("current") => Framing::Current, - _ => return Err("--view needs `extents` or `current`".into()), - }, - _ => return Ok(false), - }; - if *framing != Framing::Auto && std::mem::discriminant(framing) != std::mem::discriminant(&f) { - return Err("use only one of --window and --view".into()); - } - *framing = f; - Ok(true) -} - -/// The model-space view of every open drawing, by drawing id (to tell whether commands changed it). -fn model_views(s: &Session) -> Vec<(u64, Option)> { - s.docs.iter().map(|st| (st.uid, st.views.iter().find(|(sp, _)| *sp == Space::Model).map(|(_, v)| *v))).collect() -} - -/// The active drawing's current model-space view as a rectangle with the viewport's aspect ratio -/// (the CLI viewport is 3:2 like the PNG export, so the image shows exactly this view). -fn current_window(s: &Session) -> Option { - let st = s.state().ok()?; - let v = st.views.iter().find(|(sp, _)| *sp == Space::Model).map(|(_, v)| *v)?; - let (w, h) = s.viewport_px; - let half = Vec2::new(v.height * w / h.max(1.0), v.height) * 0.5; - Some(Bounds2::new(v.center - half, v.center + half)) -} - -/// The window an image export shows, or `None` to fit the extents. `before` is [`model_views`] -/// taken before the commands ran (`None` for `convert`, where nothing ran). -fn export_window(s: &Session, framing: Framing, before: Option<&[(u64, Option)]>) -> Result, String> { - match framing { - Framing::Window(w) => Ok(Some(w)), - Framing::Extents => Ok(None), - Framing::Current => current_window(s).map(Some).ok_or_else(|| "--view current: the drawing has no model-space view".into()), - Framing::Auto => { - let Some(before) = before else { return Ok(None) }; - let Ok(st) = s.state() else { return Ok(None) }; - let now = model_views(s); - let was = before.iter().find(|(uid, _)| *uid == st.uid); - let is = now.iter().find(|(uid, _)| *uid == st.uid); - // Only a view the commands changed counts; a drawing opened by the commands keeps - // the extents framing. - match (was, is) { - (Some(a), Some(b)) if a.1 != b.1 => Ok(current_window(s)), - _ => Ok(None), - } - } - } -} - -fn install_io() { - cadcraft_engine::cmd::file::set_io(cadcraft_engine::cmd::file::IoHooks { - read: |b, name| cadcraft_io::read(b, name).map_err(|e| e.to_string()), - write: |d, name| cadcraft_io::write(d, name).map_err(|e| e.to_string()), - plot: Some(|d, space, opts| cadcraft_io::plotter::plot(d, space, opts).map_err(|e| e.to_string())), - }); - cadcraft_engine::cmd::file::set_write_as(|d, name, o| { - cadcraft_io::write_with(d, name, &cadcraft_io::SaveOptions { version: o.version, binary: o.binary }).map_err(|e| e.to_string()) - }); - // AutoLISP's entget, entmake and entmod see entities as DXF groups. - cadcraft_engine::cmd::file::set_entity_codec(cadcraft_engine::cmd::file::EntityCodec { - groups: cadcraft_io::entity_groups, - entity: cadcraft_io::entity_from_groups, - }); -} - -fn open(s: &mut Session, path: &str) -> Result<(), String> { - s.execute("open", &json!({ "path": path })).map(|_| ()).map_err(|e| e.to_string()) -} - -#[derive(Clone, Copy)] -struct OptionSpec { - name: &'static str, - takes_value: bool, -} - -fn validate_options(command: &str, args: &[String], specs: &[OptionSpec]) -> Result<(), String> { - let mut i = 0; - while let Some(arg) = args.get(i) { - if let Some(name) = arg.strip_prefix("--") { - let Some(spec) = specs.iter().find(|spec| spec.name == arg) else { - return Err(format!("{command}: unknown option --{name}")); - }; - if spec.takes_value && args.get(i + 1).is_some_and(|value| !value.starts_with("--")) { - i += 2; - } else { - i += 1; - } - } else { - i += 1; - } - } - Ok(()) -} - -const NO_OPTIONS: &[OptionSpec] = &[]; - -fn info(path: &str) -> Result<(), String> { - let mut s = Session::empty(); - open(&mut s, path)?; - let v = s.execute("drawing.inspect", &json!({ "entities": false })).map_err(|e| e.to_string())?; - outln!("{}", serde_json::to_string_pretty(&v).unwrap_or_default()); - Ok(()) -} - -/// Write `bytes` to `out` through the engine's atomic writer (an exclusively created sibling file -/// renamed over `out`), so a failed or interrupted write leaves the previous file untouched. -fn write_atomic(out: &str, bytes: &[u8]) -> std::io::Result<()> { - cadcraft_engine::atomic_write::write_atomic(std::path::Path::new(out), bytes) -} - -fn export(s: &Session, out: &str) -> Result<(), String> { - export_framed(s, out, None) -} - -fn export_framed(s: &Session, out: &str, window: Option) -> Result<(), String> { - let d = s.doc().map_err(|e| e.to_string())?; - let bytes = cadcraft_io::write_framed(d, out, window).map_err(|e| e.to_string())?; - write_atomic(out, &bytes).map_err(|e| format!("{out}: {e}"))?; - eprintln!("wrote {out} ({} bytes)", bytes.len()); - if cadcraft_engine::cmd::file::drops_unknown(out) { - let lost = cadcraft_engine::cmd::file::not_saved(d); - if let Some(m) = cadcraft_engine::cmd::file::not_saved_message(&lost) { - eprintln!("{m}"); - } - } - Ok(()) -} - -fn sample(args: &[String]) -> Result<(), String> { - let (Some(which), Some(out)) = (args.first(), args.get(1)) else { return Err(USAGE.into()) }; - let d = match which.as_str() { - "bracket" => cadcraft_engine::sample::bracket(), - "floorplan" | "floor" => cadcraft_engine::sample::floor_plan(), - other => return Err(format!("unknown sample `{other}` (bracket, floorplan)")), - }; - let bytes = cadcraft_io::write(&d, out).map_err(|e| e.to_string())?; - write_atomic(out, &bytes).map_err(|e| format!("{out}: {e}"))?; - eprintln!("wrote {out} ({} bytes)", bytes.len()); - Ok(()) -} - -/// Reject an explicit framing option without an image output to apply it to. -fn check_framed_output(framing: Framing, out: Option<&str>) -> Result<(), String> { - match out { - _ if framing == Framing::Auto => Ok(()), - Some(o) if !cadcraft_io::is_image(o) => Err(format!("--window/--view only apply to image output (png, svg, pdf), not `{o}`")), - Some(_) => Ok(()), - None => Err("--window/--view need an image output (--export OUT.png|svg|pdf)".into()), - } -} - -fn convert(args: &[String]) -> Result<(), String> { - let mut framing = Framing::Auto; - let mut files = Vec::new(); - let mut it = args.iter(); - while let Some(a) = it.next() { - if !framing_option(a, &mut it, &mut framing)? { - files.push(a); - } - } - let [i, o] = files.as_slice() else { return Err(USAGE.into()) }; - check_framed_output(framing, Some(o))?; - let mut s = Session::empty(); - open(&mut s, i)?; - if let Some(m) = skipped_message(s.doc().map_err(|e| e.to_string())?, i) { - eprintln!("{m}"); - } - if cadcraft_io::is_image(o) - && let Some(m) = undrawn_message(s.doc().map_err(|e| e.to_string())?, i) - { - eprintln!("{m}"); - } - let window = export_window(&s, framing, None)?; - export_framed(&s, o, window) -} - -/// The warning for the model-space entities of `path` an image can't show, by type (those kept -/// as unknown objects, `Proxy` in `info`), or `None` when there are none. -fn undrawn_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option { - let mut types: std::collections::BTreeMap<&str, usize> = std::collections::BTreeMap::new(); - for e in d.model.iter() { - if let cadcraft_engine::doc::EntityKind::Unknown(u) = &e.kind { - let n = types.entry(u.dxf_type.as_str()).or_insert(0); - *n = n.saturating_add(1); - } - } - let n = types.values().fold(0usize, |a, n| a.saturating_add(*n)); - if n == 0 { - return None; - } - let list: Vec = types.iter().map(|(t, n)| format!("{t}: {n}")).collect(); - let entities = if n == 1 { "entity" } else { "entities" }; - Some(format!("{path}: {n} {entities} not drawn ({})", list.join(", "))) -} - -/// The warning for the records of `path` the reader could not place, or `None` when there are none. -fn skipped_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option { - let n = d.skipped_records.values().fold(0usize, |a, n| a.saturating_add(*n)); - if n == 0 { - return None; - } - let list: Vec = d.skipped_records.iter().map(|(section, n)| format!("{section}: {n}")).collect(); - let records = if n == 1 { "record" } else { "records" }; - Some(format!("{path}: {n} {records} could not be read and are left out ({})", list.join(", "))) -} - -/// A `--cmd` parameter value of exactly `{last}` is filled in with the last object handle an -/// earlier `--cmd` in the same run returned: `mview` answers `{"viewports":["100"]}`, so -/// `viewport.set {"handle":"{last}","scale":1}` changes viewport 100. Any other string is passed -/// through unchanged, and `--script` text is never rewritten. -const LAST_HANDLE: &str = "{last}"; - -/// How deep [`result_handles`] walks a command result (results are the engine's own JSON). -const RESULT_DEPTH: usize = 16; - -/// Result keys whose values are object references: the engine's result convention for handles. -/// A handle can be a string (`handle`, `viewport`, `insert`…) or a list of them (`handles`, -/// `viewports`, `members`…). Every other field may hold a user-defined name, a message or a -/// count, and is never read as a handle — a group named `100` is a name, not object `100`. -fn handle_field(key: &str) -> bool { - matches!( - key, - "handle" - | "handles" - | "viewport" - | "viewports" - | "boundary" - | "clip" - | "insert" - | "members" - | "source" - | "objects" - | "entities" - | "selection" - | "parts" - | "refs" - | "matches" - | "line" - | "arc" - | "blocks" - ) -} - -/// Collect the handles of `v`, a value under a handle field: a handle string, an array of them, -/// or objects that carry handle fields of their own (`entities`, `parts`). -fn collect_result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec) { - if depth > RESULT_DEPTH { - return; - } - match v { - Value::String(t) => { - if let Some(h) = Handle::parse_hex(t) - && s.doc().is_ok_and(|d| d.entity(h).is_some()) - { - out.push(h); - } - } - Value::Array(a) => a.iter().for_each(|x| collect_result_handles(s, x, depth + 1, out)), - Value::Object(m) => { - for (k, x) in m { - if handle_field(k) { - collect_result_handles(s, x, depth + 1, out); - } else { - find_result_handles(s, x, depth + 1, out); - } - } - } - _ => {} - } -} - -/// Find handle fields nested in containers that are not handles themselves (`groups` in -/// `groups.list`, whose members are handles): strings here are names, never references. -fn find_result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec) { - if depth > RESULT_DEPTH { - return; - } - match v { - Value::Array(a) => a.iter().for_each(|x| find_result_handles(s, x, depth + 1, out)), - Value::Object(m) => { - for (k, x) in m { - if handle_field(k) { - collect_result_handles(s, x, depth + 1, out); - } else { - find_result_handles(s, x, depth + 1, out); - } - } - } - _ => {} - } -} - -/// The object handles a command result mentions, in the order it lists them. A handle-only result -/// (a handle string or an array of them) counts as it is; otherwise only handle fields do. -fn result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec) { - match v { - Value::String(_) => collect_result_handles(s, v, depth, out), - Value::Array(a) if a.iter().all(Value::is_string) => collect_result_handles(s, v, depth, out), - Value::Array(_) | Value::Object(_) => find_result_handles(s, v, depth, out), - _ => {} - } -} - -/// The last handle `r` returned: what a later `{last}` stands for. -fn returned_handle(s: &Session, r: &Value) -> Option { - let mut hs = Vec::new(); - result_handles(s, r, 0, &mut hs); - hs.last().copied() -} - -/// The active drawing's identity ([`cadcraft_engine::DocState::uid`]): a handle is only meaningful -/// in the drawing it came from, and `new`, `open`, `document.switch` and `close` can make another -/// drawing current. -fn active_drawing(s: &Session) -> Option { - s.docs.get(s.active).map(|st| st.uid) -} - -/// Every `{last}` in `p`, at any depth, replaced by `h`. With no handle to fill in it is an -/// error, never a token reaching the command as a (bad) handle. -fn fill_last(p: &Value, h: Option) -> Result { - match p { - Value::String(t) if t.as_str() == LAST_HANDLE => match h { - Some(h) => Ok(Value::String(h.hex())), - None => Err(format!("`{LAST_HANDLE}` needs an earlier --cmd in this run to have returned a handle")), - }, - Value::Array(a) => a.iter().map(|x| fill_last(x, h)).collect::, _>>().map(Value::Array), - Value::Object(m) => { - m.iter().map(|(k, x)| Ok((k.clone(), fill_last(x, h)?))).collect::, _>>().map(Value::Object) - } - other => Ok(other.clone()), - } -} - -fn run(args: &[String]) -> Result<(), String> { - let mut s = Session::empty(); - let mut it = args.iter(); - let mut save = None; - let mut exp: Option = None; - let mut framing = Framing::Auto; - let mut steps: Vec<(String, String)> = Vec::new(); - while let Some(a) = it.next() { - if framing_option(a, &mut it, &mut framing)? { - continue; - } - match a.as_str() { - "--sample" => { - s.open_drawing(cadcraft_engine::sample::default_sample(), "Bracket", None); - } - "--metric" => { - s.new_drawing(true); - } - "--script" => steps.push(("script".into(), it.next().ok_or("--script needs text")?.replace("\\n", "\n"))), - "--script-file" => { - let p = it.next().ok_or("--script-file needs a path")?; - steps.push(("script".into(), std::fs::read_to_string(p).map_err(|e| format!("{p}: {e}"))?)); - } - "--cmd" => steps.push(("cmd".into(), it.next().ok_or("--cmd needs `id {json}`")?.clone())), - "--save" => save = Some(it.next().ok_or("--save needs a path")?.clone()), - "--export" => exp = Some(it.next().ok_or("--export needs a path")?.clone()), - f if !f.starts_with("--") => open(&mut s, f)?, - other => return Err(format!("unknown option {other}")), - } - } - if s.docs.is_empty() { - s.new_drawing(false); - } - check_framed_output(framing, exp.as_deref())?; - let before = model_views(&s); - let mut last_handle: Option = None; - for (kind, body) in steps { - // A handle belongs to the drawing that returned it: if this step makes another drawing - // current (`new`, `open`, `document.switch`, `close`, or a script running one of them), - // the remembered handle is stale. A handle the step itself returns is taken afterwards, - // so it is a handle of the drawing it made current. - let drawing = active_drawing(&s); - match kind.as_str() { - "script" => { - s.script(&body).map_err(|e| e.to_string())?; - if active_drawing(&s) != drawing { - last_handle = None; - } - } - _ => { - let (id, json) = body.split_once(' ').unwrap_or((&body, "{}")); - let params: Value = serde_json::from_str(json).map_err(|e| format!("--cmd {id}: {e}"))?; - let params = fill_last(¶ms, last_handle).map_err(|e| format!("--cmd {id}: {e}"))?; - let r = s.execute(id, ¶ms).map_err(|e| e.to_string())?; - if active_drawing(&s) != drawing { - last_handle = None; - } - if let Some(h) = returned_handle(&s, &r) { - last_handle = Some(h); - } - if !r.is_null() { - outln!("{r}"); - } - } - } - } - for l in &s.log { - eprintln!("{l}"); - } - if let Some(p) = save { - export(&s, &p)?; - } - if let Some(p) = exp { - let window = if cadcraft_io::is_image(&p) { export_window(&s, framing, Some(&before))? } else { None }; - export_framed(&s, &p, window)?; - } - Ok(()) -} - -/// Small deterministic generator (xorshift64*) so perf runs are repeatable without a dependency. -struct Rng(u64); - -impl Rng { - fn next(&mut self) -> f64 { - self.0 ^= self.0 >> 12; - self.0 ^= self.0 << 25; - self.0 ^= self.0 >> 27; - (self.0.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 11) as f64 / (1u64 << 53) as f64 - } - fn range(&mut self, lo: f64, hi: f64) -> f64 { - lo + (hi - lo) * self.next() - } -} - -/// A synthetic drawing with `n` mixed entities (lines, circles, arcs, polylines, text) spread -/// over a square whose side grows with sqrt(n), so density stays constant. -fn synthetic(n: usize, side: f64) -> Result { - use cadcraft_engine::doc::{self as d, Common, EntityKind, Space}; - use cadcraft_engine::geom::{PolyVertex, Vec2, Vec3}; - let mut dr = d::Drawing::new_imperial(); - let mut r = Rng(0x9E37_79B9_7F4A_7C15); - let v3 = |x: f64, y: f64| Vec3::new(x, y, 0.0); - for i in 0..n { - let (x, y) = (r.range(0.0, side), r.range(0.0, side)); - let s = r.range(0.5, 8.0); - let kind = match i % 5 { - 0 => EntityKind::Line(d::Line { a: v3(x, y), b: v3(x + r.range(-s, s), y + r.range(-s, s)) }), - 1 => EntityKind::Circle(d::Circle { center: v3(x, y), radius: s * 0.5 }), - 2 => EntityKind::Arc(d::Arc { center: v3(x, y), radius: s * 0.5, start: r.range(0.0, 3.0), end: r.range(3.2, 6.2) }), - 3 => EntityKind::LwPolyline(d::LwPolyline { - vertices: (0..6) - .map(|k| PolyVertex { - p: Vec2::new(x + f64::from(k) * s * 0.3, y + r.range(-s, s) * 0.3), - bulge: if k == 2 { 0.4 } else { 0.0 }, - start_width: 0.0, - end_width: 0.0, - }) - .collect(), - closed: i % 2 == 0, - const_width: 0.0, - elevation: 0.0, - plinegen: false, - }), - _ => EntityKind::Text(d::Text { - insert: v3(x, y), - align_pt: None, - height: s * 0.2, - value: format!("T{i}"), - rotation: 0.0, - width_factor: 1.0, - oblique: 0.0, - style: "Standard".into(), - halign: d::HAlign::Left, - valign: d::VAlign::Baseline, - }), - }; - dr.add(&Space::Model, Common::default(), kind).map_err(|e| e.to_string())?; - } - Ok(dr) -} - -/// `perf FILE`: the display list built as the canvas builds it (a 1600 x 1000 px view at the -/// drawing's centre: tolerance, dash level of detail and view window from the zoom band), at -/// zoom extents and zoomed in 4x at a time, next to the full-detail build plots use. -fn perf_file(path: &str) -> Result<(), String> { - use cadcraft_engine::geom::{Bounds2, Vec2}; - use cadcraft_engine::render::{Options, build}; - use std::time::Instant; - let ms = |t: Instant| t.elapsed().as_secs_f64() * 1000.0; - let mut s = Session::empty(); - let t = Instant::now(); - open(&mut s, path)?; - let open_ms = ms(t); - let st = s.state().map_err(|e| e.to_string())?; - let (d, space) = (&st.doc, &st.space); - let ext = d.extents(space); - let size = ext.width().max(ext.height()); - if ext.is_empty() || !(size.is_finite() && size > 0.0) { - return Err("perf: the drawing is empty".into()); - } - outln!("open {open_ms:.0} ms, {} entities, extents {:.1} x {:.1}", d.entity_count(), ext.width(), ext.height()); - outln!("{:>8} {:>10} {:>10}", "zoom", "build ms", "prims"); - let mut finest = Options::default(); - for k in 0..5 { - let zoom = 4f64.powi(k); - let h = size / zoom; - let pixel = 2f64.powi((h / 1000.0).max(1e-300).log2().floor() as i32); - let half = Vec2::new(h * 0.8, h * 0.5); - let visible = Bounds2::new(ext.center() - half, ext.center() + half); - let screen = Options { tolerance: pixel * 0.5, min_dash: pixel * 2.0, view: Some(visible.expand(h * 0.8)), ..Default::default() }; - let t = Instant::now(); - let n = build(d, space, &screen).prims.len(); - outln!("{:>7}x {:>10.1} {n:>10}", zoom, ms(t)); - finest = screen; - } - // Plots: every pattern line, everywhere (last, so its large list doesn't weigh on the above). - let t = Instant::now(); - let n = build(d, space, &Options { min_dash: 0.0, view: None, ..finest }).prims.len(); - outln!("{:>8} {:>10.1} {n:>10}", "full", ms(t)); - Ok(()) -} - -fn perf(args: &[String]) -> Result<(), String> { - use cadcraft_engine::doc::Space; - use cadcraft_engine::geom::{Bounds2, Vec2}; - use cadcraft_engine::{select, snap}; - use std::time::Instant; - if let Some(path) = args.first().filter(|a| a.parse::().is_err()) { - return perf_file(path); - } - let n: usize = match args.first() { - Some(a) => a.parse().map_err(|_| format!("perf: bad entity count {a}"))?, - None => 200_000, - }; - let n = n.clamp(1, 20_000_000); - let side = (n as f64).sqrt() * 10.0; - let mut rows: Vec<(String, f64, String)> = Vec::new(); - let ms = |t: Instant| t.elapsed().as_secs_f64() * 1000.0; - - let t = Instant::now(); - let d = synthetic(n, side)?; - rows.push(("build synthetic drawing".into(), ms(t), format!("{n} entities"))); - - // Display list at a 1600 px wide "zoom extents" view (tolerance = half a pixel). - let px = side / 1600.0; - let opts = cadcraft_engine::render::Options { tolerance: px * 0.5, min_dash: px * 2.0, ..Default::default() }; - let t = Instant::now(); - let list = cadcraft_engine::render::build(&d, &Space::Model, &opts); - rows.push(("display list build".into(), ms(t), format!("{} prims, {} segments", list.prims.len(), list.segment_count()))); - - // Hit testing on a zoomed-in view (aperture = 5 px at 0.02 units/px). - let ap = 0.1; - let mut r = Rng(42); - let pts: Vec = (0..1000).map(|_| Vec2::new(r.range(0.0, side), r.range(0.0, side))).collect(); - let t = Instant::now(); - let first = select::pick(&d, &Space::Model, pts.first().copied().unwrap_or(Vec2::ZERO), ap); - rows.push(("first pick (incl. index build)".into(), ms(t), format!("{first:?}"))); - let t = Instant::now(); - let hits = pts.iter().filter(|p| select::pick(&d, &Space::Model, **p, ap).is_some()).count(); - let total = ms(t); - rows.push(("pick x1000".into(), total, format!("{hits} hits, {:.3} ms/pick", total / 1000.0))); - - // One edit, then a pick: only the touched chunk is re-indexed. - let mut edited = d.clone(); - if let Some(h) = edited.model.last().map(|e| e.handle) { - edited.model.modify(h, |e| e.common.layer = "0".into()); - } - let t = Instant::now(); - let _ = select::pick(&edited, &Space::Model, pts.first().copied().unwrap_or(Vec2::ZERO), ap); - rows.push(("pick after one edit (incremental re-index)".into(), ms(t), String::new())); - - let mut sel = 0usize; - let t = Instant::now(); - for k in 0..20 { - let c = Vec2::new(r.range(0.0, side), r.range(0.0, side)); - let half = side * 0.05; - sel += select::select_window(&d, &Space::Model, Bounds2::new(c - Vec2::new(half, half), c + Vec2::new(half, half)), k % 2 == 1).len(); - } - rows.push(("window/crossing select x20 (10% side)".into(), ms(t), format!("{sel} selected"))); - - let t = Instant::now(); - let fence: Vec = (0..4).map(|_| Vec2::new(r.range(0.0, side), r.range(0.0, side))).collect(); - let fsel = select::select_fence(&d, &Space::Model, &fence).len(); - rows.push(("fence select (3 legs)".into(), ms(t), format!("{fsel} selected"))); - - let osmode = snap::mode::END | snap::mode::MID | snap::mode::CEN | snap::mode::QUA | snap::mode::INT; - let t = Instant::now(); - let snaps = pts.iter().filter(|p| snap::osnap(&d, &Space::Model, **p, ap * 2.0, osmode, None, false).is_some()).count(); - let total = ms(t); - rows.push(("osnap x1000".into(), total, format!("{snaps} hits, {:.3} ms/query", total / 1000.0))); - - let t = Instant::now(); - let bytes = cadcraft_io::write(&d, "perf.dxf").map_err(|e| e.to_string())?; - rows.push(("DXF write".into(), ms(t), format!("{:.1} MB", bytes.len() as f64 / 1e6))); - let t = Instant::now(); - let back = cadcraft_io::read(&bytes, "perf.dxf").map_err(|e| e.to_string())?; - rows.push(("DXF read".into(), ms(t), format!("{} entities", back.entity_count()))); - - outln!("{:<40} {:>12} notes", "operation", "ms"); - outln!("{}", "-".repeat(80)); - for (name, t, note) in rows { - outln!("{name:<40} {t:>12.2} {note}"); - } - Ok(()) -} - -/// The backend `cadcraft-cli mcp` serves from. -#[derive(Debug, PartialEq, Eq)] -enum McpTarget { - /// 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 }, -} - -/// Parses the arguments after `mcp`. `--connect` must be followed by a `HOST:PORT`; a missing, -/// empty or flag-like value is an error, never a silent fall back to a headless session (#103). -fn parse_mcp_args(args: &[String]) -> Result { - let mut addr: Option = None; - let (mut lazy, mut launch) = (false, false); - let mut it = args.iter(); - while let Some(a) = it.next() { - match a.as_str() { - "--connect" => { - let a = it - .next() - .map(|v| v.trim()) - .filter(|v| !v.is_empty() && !v.starts_with('-')) - .ok_or("--connect needs HOST:PORT (the app's --control port, e.g. 127.0.0.1:7979)")?; - if addr.is_some() { - return Err("--connect given more than once".into()); - } - addr = Some(a.to_string()); - } - "--lazy" => lazy = true, - "--launch" => launch = true, - other => return Err(format!("mcp: unknown argument {other}\n{USAGE}")), - } - } - match addr { - // `--launch` connects at the first call too (the app opens then). - Some(addr) => Ok(McpTarget::Connect { addr, lazy: lazy || launch, launch }), - None if lazy || launch => Err("--lazy and --launch need --connect HOST:PORT".into()), - None => Ok(McpTarget::Headless), - } -} - -fn mcp(args: &[String]) -> Result<(), String> { - let backend: Box = match parse_mcp_args(args)? { - McpTarget::Connect { addr, lazy: true, launch } => Box::new(cadcraft_mcp::Remote::lazy(&addr, launch)), - McpTarget::Connect { addr, .. } => match cadcraft_mcp::Remote::connect(&addr) { - Ok(r) => Box::new(r), - Err(e) => return Err(format!("cadcraft-cli: cannot connect to {addr}: {e}")), - }, - McpTarget::Headless => Box::new(cadcraft_mcp::Headless::default()), - }; - let stdin = std::io::stdin(); - let stdout = std::io::stdout(); - cadcraft_mcp::Server::new(backend).serve(stdin.lock(), stdout.lock()).map_err(|e| e.to_string()) -} - -#[cfg(test)] -mod mcp_args_tests { - use super::*; - - fn args(a: &[&str]) -> Vec { - a.iter().map(|s| s.to_string()).collect() - } - - #[test] - fn mcp_without_connect_is_headless() { - assert_eq!(parse_mcp_args(&args(&[])), Ok(McpTarget::Headless)); - } - - #[test] - fn mcp_connect_with_address_selects_remote() { - let to = |addr: &str, lazy, launch| Ok(McpTarget::Connect { addr: addr.into(), lazy, launch }); - assert_eq!(parse_mcp_args(&args(&["--connect", "127.0.0.1:7979"])), to("127.0.0.1:7979", false, false)); - assert_eq!(parse_mcp_args(&args(&["--connect", "localhost:7979"])), to("localhost:7979", false, false)); - assert_eq!(parse_mcp_args(&args(&["--lazy", "--connect", "localhost:7979"])), to("localhost:7979", true, false)); - assert_eq!(parse_mcp_args(&args(&["--connect", "localhost:7979", "--launch"])), to("localhost:7979", true, true)); - // Without an app to reach they mean nothing: never a headless session. - assert!(parse_mcp_args(&args(&["--lazy"])).is_err()); - assert!(parse_mcp_args(&args(&["--launch"])).is_err()); - } - - #[test] - fn mcp_connect_without_address_is_an_error_not_headless() { - for bad in [&["--connect"][..], &["--connect", ""], &["--connect", " "], &["--connect", "--foo"], &["--connect", "-v"]] { - let r = parse_mcp_args(&args(bad)); - let Err(e) = r else { panic!("{bad:?} should be rejected, got {r:?}") }; - assert!(e.contains("--connect needs HOST:PORT"), "{bad:?}: {e}"); - } - } - - #[test] - fn mcp_rejects_unknown_and_repeated_arguments() { - assert!(parse_mcp_args(&args(&["--conect", "127.0.0.1:7979"])).is_err()); - assert!(parse_mcp_args(&args(&["127.0.0.1:7979"])).is_err()); - assert!(parse_mcp_args(&args(&["--connect", "127.0.0.1:1", "--connect", "127.0.0.1:2"])).is_err()); - } -} - -fn main() -> ExitCode { - let code = cli(); - if STDOUT_ERROR.load(Ordering::Relaxed) { ExitCode::FAILURE } else { code } -} - -fn cli() -> ExitCode { - install_io(); - let args: Vec = std::env::args().skip(1).collect(); - let rest: Vec = args.iter().skip(1).cloned().collect(); - let r = match args.first().map(String::as_str) { - Some("info") => validate_options("info", &rest, NO_OPTIONS).and_then(|_| rest.first().ok_or_else(|| USAGE.to_string())).and_then(|p| info(p)), - Some("convert") => convert(&rest), - Some("run") => run(&rest), - Some("perf") => validate_options("perf", &rest, NO_OPTIONS).and_then(|_| perf(&rest)), - Some("sample") => validate_options("sample", &rest, NO_OPTIONS).and_then(|_| sample(&rest)), - Some("commands") => validate_options("commands", &rest, NO_OPTIONS).map(|_| { - let s = Session::new(); - let f = rest.first().map(|x| x.to_ascii_lowercase()); - let v: Vec = cadcraft_engine::command_specs() - .iter() - .filter(|c| f.as_ref().is_none_or(|f| c.id.contains(f.as_str()) || c.label.to_ascii_lowercase().contains(f.as_str()))) - .map(|c| serde_json::to_value(c.info(&s)).unwrap_or_default()) - .collect(); - outln!("{}", serde_json::to_string_pretty(&v).unwrap_or_default()); - }), - Some("mcp") => mcp(&rest), - Some("--version" | "-V") => { - outln!("cadcraft-cli {}", env!("CARGO_PKG_VERSION")); - Ok(()) - } - Some("--help" | "-h" | "help") => { - outln!("{USAGE}"); - Ok(()) - } - _ => Err(USAGE.into()), - }; - match r { - Ok(()) => ExitCode::SUCCESS, - Err(e) => { - eprintln!("{e}"); - ExitCode::FAILURE - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn scratch_dir(tag: &str) -> std::path::PathBuf { - let dir = std::env::temp_dir().join(format!("cadcraft-cli-{tag}-{}", std::process::id())); - let _ = std::fs::remove_dir_all(&dir); - std::fs::create_dir_all(&dir).expect("create scratch dir"); - dir - } - - #[test] - fn write_atomic_replaces_file_and_leaves_no_staging_files() { - let dir = scratch_dir("replace"); - let out = dir.join("a.dxf"); - let out = out.to_str().expect("utf-8 path"); - write_atomic(out, b"old").expect("create"); - write_atomic(out, b"new").expect("overwrite"); - assert_eq!(std::fs::read(out).expect("read"), b"new"); - assert_eq!(std::fs::read_dir(&dir).expect("list").count(), 1); - let _ = std::fs::remove_dir_all(&dir); - } - - #[test] - fn write_atomic_failure_keeps_destination_and_cleans_up() { - let dir = scratch_dir("fail"); - let out = dir.join("target"); - std::fs::create_dir(&out).expect("dir as destination"); - std::fs::write(out.join("keep"), b"x").expect("seed"); - assert!(write_atomic(out.to_str().expect("utf-8 path"), b"new").is_err()); - assert_eq!(std::fs::read(out.join("keep")).expect("kept"), b"x"); - assert_eq!(std::fs::read_dir(&dir).expect("list").count(), 1); - let _ = std::fs::remove_dir_all(&dir); - } - - fn b(x0: f64, y0: f64, x1: f64, y1: f64) -> Bounds2 { - Bounds2::new(Vec2::new(x0, y0), Vec2::new(x1, y1)) - } - - fn sample_session() -> Session { - let mut s = Session::empty(); - s.open_drawing(cadcraft_engine::sample::default_sample(), "Bracket", None); - s - } - - fn view_box(svg: &str) -> String { - let i = svg.find("viewBox=\"").map(|i| i + 9).unwrap_or(0); - svg[i..].split('"').next().unwrap_or("").to_string() - } - - fn assert_near(a: Bounds2, e: Bounds2) { - let d = (a.min - e.min).len().max((a.max - e.max).len()); - assert!(d < 1e-9, "{a:?} != {e:?}"); - } - - #[test] - fn window_parses() { - assert_eq!(parse_window("0,0,30,20"), Ok(b(0.0, 0.0, 30.0, 20.0))); - assert_eq!(parse_window(" -5.5, -1e3 ,2e3,4 "), Ok(b(-5.5, -1000.0, 2000.0, 4.0))); - } - - #[test] - fn hostile_window_is_an_error() { - for w in [ - "", - "1,2,3", - "1,2,3,4,5", - "a,0,1,1", - "NaN,0,1,1", - "0,0,inf,1", - "0,0,1e400,1", - "0,0,0,1", - "0,0,1,0", - "5,0,1,1", - "0,5,1,1", - "-1e300,-1e300,1e300,1e300", - "0,0,1e-12,1e-12", - ] { - assert!(parse_window(w).is_err(), "`{w}` should be rejected"); - } - } - - #[test] - fn framing_options() { - let parse = |args: &[&str]| -> Result { - let args: Vec = args.iter().map(|a| a.to_string()).collect(); - let mut f = Framing::Auto; - let mut it = args.iter(); - while let Some(a) = it.next() { - assert!(framing_option(a, &mut it, &mut f)?, "{a} is a framing option"); - } - Ok(f) - }; - assert_eq!(parse(&["--view", "extents"]), Ok(Framing::Extents)); - assert_eq!(parse(&["--view", "CURRENT"]), Ok(Framing::Current)); - assert_eq!(parse(&["--window", "0,0,2,1"]), Ok(Framing::Window(b(0.0, 0.0, 2.0, 1.0)))); - assert!(parse(&["--view"]).is_err()); - assert!(parse(&["--view", "selection"]).is_err()); - assert!(parse(&["--window"]).is_err()); - assert!(parse(&["--window", "0,0,2,1", "--view", "extents"]).is_err()); - assert!(check_framed_output(Framing::Extents, Some("a.dxf")).is_err()); - assert!(check_framed_output(Framing::Extents, None).is_err()); - assert!(check_framed_output(Framing::Extents, Some("a.png")).is_ok()); - assert!(check_framed_output(Framing::Auto, Some("a.dxf")).is_ok()); - } - - #[test] - fn last_placeholder_takes_the_previous_handle() { - let mut s = sample_session(); - let r = s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap(); - let h = returned_handle(&s, &r).expect("LINE returns its handle"); - assert_eq!(fill_last(&json!({"handle": "{last}"}), Some(h)), Ok(json!({"handle": h.hex()}))); - // Nested, as in a selection list. - assert_eq!(fill_last(&json!({"handles": ["{last}", "1"]}), Some(h)), Ok(json!({"handles": [h.hex(), "1"]}))); - // Only the exact token: a name or a sentence that merely contains it stays as written. - for p in [json!("last"), json!("{last} "), json!({"name": "last"})] { - assert_eq!(fill_last(&p, Some(h)), Ok(p.clone())); - } - // Nothing returned yet: an error, not a token passed to the command as a bad handle. - assert!(fill_last(&json!({"handle": "{last}"}), None).unwrap_err().contains("{last}")); - } - - /// Handles are read from a result by looking the strings up in the drawing: counts and names - /// are not mistaken for handles, and `mview`'s `viewports` works like `handle`/`handles`. - #[test] - fn returned_handle_reads_only_real_handles() { - let mut s = Session::empty(); - s.new_drawing(false); - s.execute("layout.set", &json!({"name": "Layout1"})).unwrap(); - let r = s.execute("mview", &json!({"p1": [20, 20], "p2": [200, 150]})).unwrap(); - let h = returned_handle(&s, &r).expect("mview returns its viewport handle"); - assert!(r["viewports"].as_array().is_some_and(|a| a.iter().any(|v| v.as_str() == Some(h.hex().as_str()))), "{r}"); - assert_eq!(returned_handle(&s, &json!({"changed": 3, "name": "A1"})), None); - // The most recent of several. - let a = s.execute("line", &json!({"points": [[0, 0], [1, 0]]})).unwrap(); - let b = s.execute("line", &json!({"points": [[0, 0], [2, 0]]})).unwrap(); - let (ha, hb) = (returned_handle(&s, &a).unwrap(), returned_handle(&s, &b).unwrap()); - assert_eq!(returned_handle(&s, &json!({"handles": [ha.hex(), hb.hex()]})), Some(hb)); - } - - #[test] - fn default_framing_is_extents() { - // convert: nothing ran, always the extents. - let s = sample_session(); - assert_eq!(export_window(&s, Framing::Auto, None), Ok(None)); - // run: commands that leave the view alone keep the extents framing. - let mut s = sample_session(); - let before = model_views(&s); - s.script("LINE 0,0 10,10\n\n").unwrap(); - assert_eq!(export_window(&s, Framing::Auto, Some(&before)), Ok(None)); - // A fresh drawing too. - let mut s = Session::empty(); - s.new_drawing(false); - let before = model_views(&s); - s.execute("circle", &json!({"center": [0, 0], "radius": 5})).unwrap(); - assert_eq!(export_window(&s, Framing::Auto, Some(&before)), Ok(None)); - } - - #[test] - fn zoom_window_frames_export() { - let mut s = sample_session(); - let before = model_views(&s); - s.execute("zoom", &json!({"mode": "window", "p1": [0, 0], "p2": [30, 20]})).unwrap(); - let w = export_window(&s, Framing::Auto, Some(&before)).unwrap().unwrap(); - // The CLI viewport is 3:2, so a 3:2 window is shown exactly. - assert_near(w, b(0.0, 0.0, 30.0, 20.0)); - assert_eq!(export_window(&s, Framing::Current, Some(&before)), Ok(Some(w))); - // --view extents and --window override the zoom. - assert_eq!(export_window(&s, Framing::Extents, Some(&before)), Ok(None)); - let explicit = b(1.0, 1.0, 2.0, 2.0); - assert_eq!(export_window(&s, Framing::Window(explicit), Some(&before)), Ok(Some(explicit))); - // A taller window keeps its height; the 3:2 image adds room left and right. - s.execute("zoom", &json!({"mode": "center", "center": [5, 5], "height": 4})).unwrap(); - assert_near(export_window(&s, Framing::Auto, Some(&before)).unwrap().unwrap(), b(2.0, 3.0, 8.0, 7.0)); - } - - #[test] - fn zoom_object_frames_the_selection() { - let mut s = sample_session(); - let before = model_views(&s); - // The smallest entity with an area, selected then framed with ZOOM Object. - let d = s.doc().unwrap(); - let bounds = |e: &cadcraft_engine::doc::Entity| cadcraft_engine::doc::entity_bounds(d, e, 0); - let e = d - .model - .iter() - .filter(|e| bounds(e).width() > 0.0 && bounds(e).height() > 0.0) - .min_by(|a, b| bounds(a).width().total_cmp(&bounds(b).width())) - .unwrap(); - let (h, eb, ext) = (e.handle, bounds(e), d.extents(&Space::Model)); - s.set_selection(vec![h]); - s.execute("zoom", &json!({"mode": "object"})).unwrap(); - let w = export_window(&s, Framing::Auto, Some(&before)).unwrap().unwrap(); - assert!(w.contains(eb.min) && w.contains(eb.max)); - assert!(w.width() < ext.width() && w.height() < ext.height(), "{w:?} vs extents {ext:?}"); - } - - #[test] - fn run_export_honours_zoom() { - let dir = std::env::temp_dir().join(format!("cadcraft-cli-165-{}", std::process::id())); - std::fs::create_dir_all(&dir).unwrap(); - let path = |n: &str| dir.join(n).to_string_lossy().to_string(); - let run_svg = |extra: &[&str], out: &str| -> String { - let mut args: Vec = ["--sample"].iter().chain(extra).map(|a| a.to_string()).collect(); - args.extend(["--export".to_string(), path(out)]); - run(&args).unwrap(); - std::fs::read_to_string(path(out)).unwrap() - }; - let base = run_svg(&[], "base.svg"); - let zoomed = run_svg(&["--cmd", r#"zoom {"mode":"window","p1":[0,0],"p2":[30,20]}"#], "zoom.svg"); - let window = run_svg(&["--window", "0,0,30,20"], "window.svg"); - let forced = run_svg(&["--cmd", r#"zoom {"mode":"window","p1":[0,0],"p2":[30,20]}"#, "--view", "extents"], "forced.svg"); - assert_ne!(view_box(&zoomed), view_box(&base)); - assert_eq!(view_box(&zoomed), "0 0 30.000000 20.000000"); - assert_eq!(zoomed, window); - assert_eq!(forced, base); - // Hostile --window: a clear error, nothing written. - let bad: Vec = ["--sample", "--window", "0,0,NaN,1", "--export", &path("bad.png")].iter().map(|a| a.to_string()).collect(); - assert!(run(&bad).unwrap_err().contains("--window")); - assert!(!dir.join("bad.png").exists()); - let _ = std::fs::remove_dir_all(&dir); - } - - fn args(values: &[&str]) -> Vec { - values.iter().map(|value| (*value).into()).collect() - } - - #[test] - fn validators_accept_only_the_documented_options() { - assert!(validate_options("info", &args(&["file.dxf"]), NO_OPTIONS).is_ok()); - assert!(validate_options("perf", &args(&["100"]), NO_OPTIONS).is_ok()); - assert!(validate_options("sample", &args(&["bracket", "out.dxf"]), NO_OPTIONS).is_ok()); - assert!(validate_options("commands", &args(&["line"]), NO_OPTIONS).is_ok()); - for (command, specs) in [("info", NO_OPTIONS), ("perf", NO_OPTIONS), ("sample", NO_OPTIONS), ("commands", NO_OPTIONS)] { - assert!(validate_options(command, &args(&["--typo"]), specs).is_err()); - } - } - - #[test] - fn unknown_options_are_rejected_before_side_effects() { - assert_eq!(validate_options("info", &args(&["missing.dxf", "--typo"]), NO_OPTIONS), Err("info: unknown option --typo".into())); - assert_eq!(validate_options("perf", &args(&["1", "--typo"]), NO_OPTIONS), Err("perf: unknown option --typo".into())); - assert_eq!(validate_options("sample", &args(&["bracket", "out.dxf", "--typo"]), NO_OPTIONS), Err("sample: unknown option --typo".into())); - } +fn main() { + // `args_os`, not `args`: a non-Unicode argument (a Latin-1 file name on Linux) must be + // reported as an error, not panic before anything is printed. + let code = cadcraft_cli::run(std::env::args_os().skip(1), &mut std::io::stdout(), &mut std::io::stderr()); + std::process::exit(code); } diff --git a/apps/cadcraft-cli/src/mcp.rs b/apps/cadcraft-cli/src/mcp.rs new file mode 100644 index 000000000..960c80a5e --- /dev/null +++ b/apps/cadcraft-cli/src/mcp.rs @@ -0,0 +1,17 @@ +use super::args::{McpArgs, McpTarget}; +use super::error::{CliError, Result}; + +pub(crate) fn mcp(a: &McpArgs) -> Result { + let backend: Box = match a.target() { + McpTarget::Connect { addr, lazy: true, launch } => Box::new(cadcraft_mcp::Remote::lazy(&addr, launch)), + McpTarget::Connect { addr, .. } => match cadcraft_mcp::Remote::connect(&addr) { + Ok(r) => Box::new(r), + Err(source) => return Err(CliError::McpConnect { addr, source }), + }, + McpTarget::Headless => Box::new(cadcraft_mcp::Headless::default()), + }; + let stdin = std::io::stdin(); + let stdout = std::io::stdout(); + cadcraft_mcp::Server::new(backend).serve(stdin.lock(), stdout.lock())?; + Ok(()) +} diff --git a/apps/cadcraft-cli/src/output.rs b/apps/cadcraft-cli/src/output.rs new file mode 100644 index 000000000..d783267dc --- /dev/null +++ b/apps/cadcraft-cli/src/output.rs @@ -0,0 +1,177 @@ +use super::args::Framing; +use super::error::Result; +use cadcraft_engine::doc::Space; +use cadcraft_engine::geom::{Bounds2, Vec2}; +use cadcraft_engine::{Session, View}; +use std::io::Write; +use std::path::{Path, PathBuf}; + +/// The process's output streams. A write to stdout that fails never stops the program: once +/// stdout has failed, later output is dropped and the work goes on, so the rest of `run` (later +/// `--cmd` results, `--save`, `--export`) still happens and `cadcraft-cli run … --save out.dxf | +/// head` keeps the drawing. A reader that stopped early (a closed pipe, `cadcraft-cli commands | +/// head`) is not an error, as in ripgrep; any other write error is reported once on stderr and +/// makes the exit status 1. +pub(crate) struct Streams<'a> { + out: &'a mut dyn Write, + err: &'a mut dyn Write, + /// Set once a write to `out` has failed; later output is dropped. + gone: bool, + /// Set when `out` failed for a reason other than a closed reader. + failed: bool, +} + +impl<'a> Streams<'a> { + pub(crate) fn new(out: &'a mut dyn Write, err: &'a mut dyn Write) -> Self { + Streams { out, err, gone: false, failed: false } + } + + /// Write a line to stdout. + pub(crate) fn outln(&mut self, args: std::fmt::Arguments) { + if !self.gone + && let Err(e) = writeln!(self.out, "{args}") + { + self.out_failed(e); + } + } + + /// Write `v` to stdout: pretty-printed, or on one line with `compact` (`--compact`). + pub(crate) fn json(&mut self, v: &serde_json::Value, compact: bool) { + if compact { + self.outln(format_args!("{v}")); + } else { + self.outln(format_args!("{v:#}")); + } + } + + /// Write a line to stderr. A failing stderr has nowhere to report to, so it is ignored. + pub(crate) fn errln(&mut self, args: std::fmt::Arguments) { + let _ = writeln!(self.err, "{args}"); + } + + /// Flush stdout (a pipe that closed during buffered output surfaces here). + pub(crate) fn finish(&mut self) { + if !self.gone + && let Err(e) = self.out.flush() + { + self.out_failed(e); + } + } + + /// Whether stdout failed for a reason other than a closed reader: the exit status is 1. + pub(crate) fn stdout_failed(&self) -> bool { + self.failed + } + + fn out_failed(&mut self, e: std::io::Error) { + if std::mem::replace(&mut self.gone, true) || e.kind() == std::io::ErrorKind::BrokenPipe { + return; + } + self.errln(format_args!("cadcraft-cli: can't write to stdout: {e}")); + self.failed = true; + } +} + +/// Why writing or framing an output failed. +#[derive(Debug, thiserror::Error)] +pub(crate) enum OutputError { + #[error("--view current: the drawing has no model-space view")] + NoModelView, + #[error("{}: {source}", path.display())] + Write { path: PathBuf, source: std::io::Error }, +} + +/// The model-space view of every open drawing, by drawing id (to tell whether commands changed it). +pub(crate) fn model_views(s: &Session) -> Vec<(u64, Option)> { + s.docs.iter().map(|st| (st.uid, st.views.iter().find(|(sp, _)| *sp == Space::Model).map(|(_, v)| *v))).collect() +} + +/// The active drawing's current model-space view as a rectangle with the viewport's aspect ratio +/// (the CLI viewport is 3:2 like the PNG export, so the image shows exactly this view). +fn current_window(s: &Session) -> Option { + let st = s.state().ok()?; + let v = st.views.iter().find(|(sp, _)| *sp == Space::Model).map(|(_, v)| *v)?; + let (w, h) = s.viewport_px; + let half = Vec2::new(v.height * w / h.max(1.0), v.height) * 0.5; + Some(Bounds2::new(v.center - half, v.center + half)) +} + +/// The window an image export shows, or `None` to fit the extents. `before` is [`model_views`] +/// taken before the commands ran (`None` for `convert`, where nothing ran). +pub(crate) fn export_window(s: &Session, framing: Framing, before: Option<&[(u64, Option)]>) -> Result, OutputError> { + match framing { + Framing::Window(w) => Ok(Some(w)), + Framing::Extents => Ok(None), + Framing::Current => current_window(s).map(Some).ok_or(OutputError::NoModelView), + Framing::Auto => { + let Some(before) = before else { return Ok(None) }; + let Ok(st) = s.state() else { return Ok(None) }; + let now = model_views(s); + let was = before.iter().find(|(uid, _)| *uid == st.uid); + let is = now.iter().find(|(uid, _)| *uid == st.uid); + // Only a view the commands changed counts; a drawing opened by the commands keeps + // the extents framing. + match (was, is) { + (Some(a), Some(b)) if a.1 != b.1 => Ok(current_window(s)), + _ => Ok(None), + } + } + } +} + +/// Write `bytes` to `out` through the engine's atomic writer (an exclusively created sibling file +/// renamed over `out`), so a failed or interrupted write leaves the previous file untouched. An +/// existing `out` is resolved first: the rename would otherwise replace a symlink with a file and +/// leave the file it points to (`--in-place` through a link) unchanged. +pub(crate) fn write_atomic(out: &Path, bytes: &[u8]) -> Result<(), OutputError> { + let target = std::fs::canonicalize(out).unwrap_or_else(|_| out.to_path_buf()); + cadcraft_engine::atomic_write::write_atomic(&target, bytes).map_err(|source| OutputError::Write { path: out.to_path_buf(), source }) +} + +pub(crate) fn export(s: &Session, out: &Path, io: &mut Streams) -> Result { + export_framed(s, out, None, io) +} + +pub(crate) fn export_framed(s: &Session, out: &Path, window: Option, io: &mut Streams) -> Result { + let d = s.doc()?; + let bytes = cadcraft_io::write_framed(d, out, window)?; + write_atomic(out, &bytes)?; + io.errln(format_args!("wrote {} ({} bytes)", out.display(), bytes.len())); + if cadcraft_engine::cmd::file::drops_unknown(out) { + let lost = cadcraft_engine::cmd::file::not_saved(d); + if let Some(m) = cadcraft_engine::cmd::file::not_saved_message(&lost) { + io.errln(format_args!("{m}")); + } + } + Ok(()) +} + +/// The warning for the model-space entities of `path` an image can't show, by type (those kept +/// as unknown objects, `Proxy` in `info`), or `None` when there are none. +pub(crate) fn undrawn_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option { + let mut types: std::collections::BTreeMap<&str, usize> = std::collections::BTreeMap::new(); + for e in d.model.iter() { + if let cadcraft_engine::doc::EntityKind::Unknown(u) = &e.kind { + let n = types.entry(u.dxf_type.as_str()).or_insert(0); + *n = n.saturating_add(1); + } + } + let n = types.values().fold(0usize, |a, n| a.saturating_add(*n)); + if n == 0 { + return None; + } + let list: Vec = types.iter().map(|(t, n)| format!("{t}: {n}")).collect(); + let entities = if n == 1 { "entity" } else { "entities" }; + Some(format!("{path}: {n} {entities} not drawn ({})", list.join(", "))) +} + +/// The warning for the records of `path` the reader could not place, or `None` when there are none. +pub(crate) fn skipped_message(d: &cadcraft_engine::doc::Drawing, path: &str) -> Option { + let n = d.skipped_records.values().fold(0usize, |a, n| a.saturating_add(*n)); + if n == 0 { + return None; + } + let list: Vec = d.skipped_records.iter().map(|(section, n)| format!("{section}: {n}")).collect(); + let records = if n == 1 { "record" } else { "records" }; + Some(format!("{path}: {n} {records} could not be read and are left out ({})", list.join(", "))) +} diff --git a/apps/cadcraft-cli/src/perf.rs b/apps/cadcraft-cli/src/perf.rs new file mode 100644 index 000000000..e52b6107b --- /dev/null +++ b/apps/cadcraft-cli/src/perf.rs @@ -0,0 +1,196 @@ +use super::args::PerfTarget; +use super::error::Result; +use super::open; +use super::output::Streams; +use cadcraft_engine::Session; + +/// Why `perf` cannot run. +#[derive(Debug, thiserror::Error)] +pub(crate) enum PerfError { + #[error("perf: the drawing is empty")] + EmptyDrawing, +} + +/// Small deterministic generator (xorshift64*) so perf runs are repeatable without a dependency. +struct Rng(u64); + +impl Rng { + fn next(&mut self) -> f64 { + self.0 ^= self.0 >> 12; + self.0 ^= self.0 << 25; + self.0 ^= self.0 >> 27; + (self.0.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 11) as f64 / (1u64 << 53) as f64 + } + fn range(&mut self, lo: f64, hi: f64) -> f64 { + lo + (hi - lo) * self.next() + } +} + +/// A synthetic drawing with `n` mixed entities (lines, circles, arcs, polylines, text) spread +/// over a square whose side grows with sqrt(n), so density stays constant. +fn synthetic(n: usize, side: f64) -> Result { + use cadcraft_engine::doc::{self as d, Common, EntityKind, Space}; + use cadcraft_engine::geom::{PolyVertex, Vec2, Vec3}; + let mut dr = d::Drawing::new_imperial(); + let mut r = Rng(0x9E37_79B9_7F4A_7C15); + let v3 = |x: f64, y: f64| Vec3::new(x, y, 0.0); + for i in 0..n { + let (x, y) = (r.range(0.0, side), r.range(0.0, side)); + let s = r.range(0.5, 8.0); + let kind = match i % 5 { + 0 => EntityKind::Line(d::Line { a: v3(x, y), b: v3(x + r.range(-s, s), y + r.range(-s, s)) }), + 1 => EntityKind::Circle(d::Circle { center: v3(x, y), radius: s * 0.5 }), + 2 => EntityKind::Arc(d::Arc { center: v3(x, y), radius: s * 0.5, start: r.range(0.0, 3.0), end: r.range(3.2, 6.2) }), + 3 => EntityKind::LwPolyline(d::LwPolyline { + vertices: (0..6) + .map(|k| PolyVertex { + p: Vec2::new(x + f64::from(k) * s * 0.3, y + r.range(-s, s) * 0.3), + bulge: if k == 2 { 0.4 } else { 0.0 }, + start_width: 0.0, + end_width: 0.0, + }) + .collect(), + closed: i % 2 == 0, + const_width: 0.0, + elevation: 0.0, + plinegen: false, + }), + _ => EntityKind::Text(d::Text { + insert: v3(x, y), + align_pt: None, + height: s * 0.2, + value: format!("T{i}"), + rotation: 0.0, + width_factor: 1.0, + oblique: 0.0, + style: "Standard".into(), + halign: d::HAlign::Left, + valign: d::VAlign::Baseline, + }), + }; + dr.add(&Space::Model, Common::default(), kind)?; + } + Ok(dr) +} + +/// `perf FILE`: the display list built as the canvas builds it (a 1600 x 1000 px view at the +/// drawing's centre: tolerance, dash level of detail and view window from the zoom band), at +/// zoom extents and zoomed in 4x at a time, next to the full-detail build plots use. +fn perf_file(path: &std::path::Path, io: &mut Streams) -> Result { + use cadcraft_engine::geom::{Bounds2, Vec2}; + use cadcraft_engine::render::{Options, build}; + use std::time::Instant; + let ms = |t: Instant| t.elapsed().as_secs_f64() * 1000.0; + let mut s = Session::empty(); + let t = Instant::now(); + open(&mut s, path)?; + let open_ms = ms(t); + let st = s.state()?; + let (d, space) = (&st.doc, &st.space); + let ext = d.extents(space); + let size = ext.width().max(ext.height()); + if ext.is_empty() || !(size.is_finite() && size > 0.0) { + return Err(PerfError::EmptyDrawing.into()); + } + io.outln(format_args!("open {open_ms:.0} ms, {} entities, extents {:.1} x {:.1}", d.entity_count(), ext.width(), ext.height())); + io.outln(format_args!("{:>8} {:>10} {:>10}", "zoom", "build ms", "prims")); + let mut finest = Options::default(); + for k in 0..5 { + let zoom = 4f64.powi(k); + let h = size / zoom; + let pixel = 2f64.powi((h / 1000.0).max(1e-300).log2().floor() as i32); + let half = Vec2::new(h * 0.8, h * 0.5); + let visible = Bounds2::new(ext.center() - half, ext.center() + half); + let screen = Options { tolerance: pixel * 0.5, min_dash: pixel * 2.0, view: Some(visible.expand(h * 0.8)), ..Default::default() }; + let t = Instant::now(); + let n = build(d, space, &screen).prims.len(); + io.outln(format_args!("{:>7}x {:>10.1} {n:>10}", zoom, ms(t))); + finest = screen; + } + // Plots: every pattern line, everywhere (last, so its large list doesn't weigh on the above). + let t = Instant::now(); + let n = build(d, space, &Options { min_dash: 0.0, view: None, ..finest }).prims.len(); + io.outln(format_args!("{:>8} {:>10.1} {n:>10}", "full", ms(t))); + Ok(()) +} + +pub(crate) fn perf(target: Option<&PerfTarget>, io: &mut Streams) -> Result { + use cadcraft_engine::doc::Space; + use cadcraft_engine::geom::{Bounds2, Vec2}; + use cadcraft_engine::{select, snap}; + use std::time::Instant; + let n = match target { + Some(PerfTarget::File(path)) => return perf_file(path, io), + Some(PerfTarget::Count(n)) => *n, + None => 200_000, + }; + let side = (n as f64).sqrt() * 10.0; + let mut rows: Vec<(String, f64, String)> = Vec::new(); + let ms = |t: Instant| t.elapsed().as_secs_f64() * 1000.0; + + let t = Instant::now(); + let d = synthetic(n, side)?; + rows.push(("build synthetic drawing".into(), ms(t), format!("{n} entities"))); + + // Display list at a 1600 px wide "zoom extents" view (tolerance = half a pixel). + let px = side / 1600.0; + let opts = cadcraft_engine::render::Options { tolerance: px * 0.5, min_dash: px * 2.0, ..Default::default() }; + let t = Instant::now(); + let list = cadcraft_engine::render::build(&d, &Space::Model, &opts); + rows.push(("display list build".into(), ms(t), format!("{} prims, {} segments", list.prims.len(), list.segment_count()))); + + // Hit testing on a zoomed-in view (aperture = 5 px at 0.02 units/px). + let ap = 0.1; + let mut r = Rng(42); + let pts: Vec = (0..1000).map(|_| Vec2::new(r.range(0.0, side), r.range(0.0, side))).collect(); + let t = Instant::now(); + let first = select::pick(&d, &Space::Model, pts.first().copied().unwrap_or(Vec2::ZERO), ap); + rows.push(("first pick (incl. index build)".into(), ms(t), format!("{first:?}"))); + let t = Instant::now(); + let hits = pts.iter().filter(|p| select::pick(&d, &Space::Model, **p, ap).is_some()).count(); + let total = ms(t); + rows.push(("pick x1000".into(), total, format!("{hits} hits, {:.3} ms/pick", total / 1000.0))); + + // One edit, then a pick: only the touched chunk is re-indexed. + let mut edited = d.clone(); + if let Some(h) = edited.model.last().map(|e| e.handle) { + edited.model.modify(h, |e| e.common.layer = "0".into()); + } + let t = Instant::now(); + let _ = select::pick(&edited, &Space::Model, pts.first().copied().unwrap_or(Vec2::ZERO), ap); + rows.push(("pick after one edit (incremental re-index)".into(), ms(t), String::new())); + + let mut sel = 0usize; + let t = Instant::now(); + for k in 0..20 { + let c = Vec2::new(r.range(0.0, side), r.range(0.0, side)); + let half = side * 0.05; + sel += select::select_window(&d, &Space::Model, Bounds2::new(c - Vec2::new(half, half), c + Vec2::new(half, half)), k % 2 == 1).len(); + } + rows.push(("window/crossing select x20 (10% side)".into(), ms(t), format!("{sel} selected"))); + + let t = Instant::now(); + let fence: Vec = (0..4).map(|_| Vec2::new(r.range(0.0, side), r.range(0.0, side))).collect(); + let fsel = select::select_fence(&d, &Space::Model, &fence).len(); + rows.push(("fence select (3 legs)".into(), ms(t), format!("{fsel} selected"))); + + let osmode = snap::mode::END | snap::mode::MID | snap::mode::CEN | snap::mode::QUA | snap::mode::INT; + let t = Instant::now(); + let snaps = pts.iter().filter(|p| snap::osnap(&d, &Space::Model, **p, ap * 2.0, osmode, None, false).is_some()).count(); + let total = ms(t); + rows.push(("osnap x1000".into(), total, format!("{snaps} hits, {:.3} ms/query", total / 1000.0))); + + let t = Instant::now(); + let bytes = cadcraft_io::write(&d, "perf.dxf")?; + rows.push(("DXF write".into(), ms(t), format!("{:.1} MB", bytes.len() as f64 / 1e6))); + let t = Instant::now(); + let back = cadcraft_io::read(&bytes, "perf.dxf")?; + rows.push(("DXF read".into(), ms(t), format!("{} entities", back.entity_count()))); + + io.outln(format_args!("{:<40} {:>12} notes", "operation", "ms")); + io.outln(format_args!("{}", "-".repeat(80))); + for (name, t, note) in rows { + io.outln(format_args!("{name:<40} {t:>12.2} {note}")); + } + Ok(()) +} diff --git a/apps/cadcraft-cli/src/run.rs b/apps/cadcraft-cli/src/run.rs new file mode 100644 index 000000000..56b4626e2 --- /dev/null +++ b/apps/cadcraft-cli/src/run.rs @@ -0,0 +1,223 @@ +use super::args::{CmdStep, Drawing, RunArgs, Step}; +use super::error::Result; +use super::open; +use super::output::{Streams, export, export_framed, export_window, model_views}; +use cadcraft_engine::Session; +use cadcraft_engine::doc::Handle; +use serde_json::Value; + +/// A `--cmd` parameter value of exactly `{last}` is filled in with the last object handle an +/// earlier `--cmd` in the same run returned: `mview` answers `{"viewports":["100"]}`, so +/// `viewport.set {"handle":"{last}","scale":1}` changes viewport 100. Any other string is passed +/// through unchanged, and `--script` text is never rewritten. +const LAST_HANDLE: &str = "{last}"; + +/// Why a `run` step fails. +#[derive(Debug, thiserror::Error)] +pub(crate) enum RunError { + #[error("{}: {source}", .path.display())] + ReadScript { path: std::path::PathBuf, source: std::io::Error }, + #[error("--cmd {id}: {source}")] + CmdLast { id: String, source: NoLastHandle }, +} + +/// A `{last}` placeholder with no handle to fill in. +#[derive(Debug, PartialEq, thiserror::Error)] +#[error("`{{last}}` needs an earlier --cmd in this run to have returned a handle")] +pub(crate) struct NoLastHandle; + +/// How deep [`result_handles`] walks a command result (results are the engine's own JSON). +const RESULT_DEPTH: usize = 16; + +/// Result keys whose values are object references: the engine's result convention for handles. +/// A handle can be a string (`handle`, `viewport`, `insert`…) or a list of them (`handles`, +/// `viewports`, `members`…). Every other field may hold a user-defined name, a message or a +/// count, and is never read as a handle — a group named `100` is a name, not object `100`. +fn handle_field(key: &str) -> bool { + matches!( + key, + "handle" + | "handles" + | "viewport" + | "viewports" + | "boundary" + | "clip" + | "insert" + | "members" + | "source" + | "objects" + | "entities" + | "selection" + | "parts" + | "refs" + | "matches" + | "line" + | "arc" + | "blocks" + ) +} + +/// Collect the handles of `v`, a value under a handle field: a handle string, an array of them, +/// or objects that carry handle fields of their own (`entities`, `parts`). +fn collect_result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec) { + if depth > RESULT_DEPTH { + return; + } + match v { + Value::String(t) => { + if let Some(h) = Handle::parse_hex(t) + && s.doc().is_ok_and(|d| d.entity(h).is_some()) + { + out.push(h); + } + } + Value::Array(a) => a.iter().for_each(|x| collect_result_handles(s, x, depth + 1, out)), + Value::Object(m) => { + for (k, x) in m { + if handle_field(k) { + collect_result_handles(s, x, depth + 1, out); + } else { + find_result_handles(s, x, depth + 1, out); + } + } + } + _ => {} + } +} + +/// Find handle fields nested in containers that are not handles themselves (`groups` in +/// `groups.list`, whose members are handles): strings here are names, never references. +fn find_result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec) { + if depth > RESULT_DEPTH { + return; + } + match v { + Value::Array(a) => a.iter().for_each(|x| find_result_handles(s, x, depth + 1, out)), + Value::Object(m) => { + for (k, x) in m { + if handle_field(k) { + collect_result_handles(s, x, depth + 1, out); + } else { + find_result_handles(s, x, depth + 1, out); + } + } + } + _ => {} + } +} + +/// The object handles a command result mentions, in the order it lists them. A handle-only result +/// (a handle string or an array of them) counts as it is; otherwise only handle fields do. +fn result_handles(s: &Session, v: &Value, depth: usize, out: &mut Vec) { + match v { + Value::String(_) => collect_result_handles(s, v, depth, out), + Value::Array(a) if a.iter().all(Value::is_string) => collect_result_handles(s, v, depth, out), + Value::Array(_) | Value::Object(_) => find_result_handles(s, v, depth, out), + _ => {} + } +} + +/// The last handle `r` returned: what a later `{last}` stands for. +pub(crate) fn returned_handle(s: &Session, r: &Value) -> Option { + let mut hs = Vec::new(); + result_handles(s, r, 0, &mut hs); + hs.last().copied() +} + +/// The active drawing's identity ([`cadcraft_engine::DocState::uid`]): a handle is only meaningful +/// in the drawing it came from, and `new`, `open`, `document.switch` and `close` can make another +/// drawing current. +fn active_drawing(s: &Session) -> Option { + s.docs.get(s.active).map(|st| st.uid) +} + +/// Every `{last}` in `p`, at any depth, replaced by `h`. With no handle to fill in it is an +/// error, never a token reaching the command as a (bad) handle. +pub(crate) fn fill_last(p: &Value, h: Option) -> Result { + match p { + Value::String(t) if t.as_str() == LAST_HANDLE => match h { + Some(h) => Ok(Value::String(h.hex())), + None => Err(NoLastHandle), + }, + Value::Array(a) => a.iter().map(|x| fill_last(x, h)).collect::, _>>().map(Value::Array), + Value::Object(m) => { + m.iter().map(|(k, x)| Ok((k.clone(), fill_last(x, h)?))).collect::, _>>().map(Value::Object) + } + other => Ok(other.clone()), + } +} + +/// A step ready to run: script text, or a command. +enum Ready<'a> { + Script(String), + Cmd(&'a CmdStep), +} + +pub(crate) fn run_cmds(a: &RunArgs, io: &mut Streams) -> Result { + let framing = a.framing.framing(); + let (save, export_to) = (a.save.as_deref(), a.export.as_deref()); + let mut s = Session::empty(); + for d in &a.drawings { + match d { + Drawing::File(f) => open(&mut s, f)?, + Drawing::Sample => { + s.open_drawing(cadcraft_engine::sample::default_sample(), "Bracket", None); + } + Drawing::Metric => { + s.new_drawing(true); + } + } + } + let mut steps: Vec = Vec::new(); + for step in &a.steps { + steps.push(match step { + Step::Script(text) => Ready::Script(text.replace("\\n", "\n")), + Step::ScriptFile(p) => Ready::Script(std::fs::read_to_string(p).map_err(|source| RunError::ReadScript { path: p.clone(), source })?), + Step::Cmd(c) => Ready::Cmd(c), + }); + } + if s.docs.is_empty() { + s.new_drawing(false); + } + let before = model_views(&s); + let mut last_handle: Option = None; + for step in steps { + // A handle belongs to the drawing that returned it: if this step makes another drawing + // current (`new`, `open`, `document.switch`, `close`, or a script running one of them), + // the remembered handle is stale. A handle the step itself returns is taken afterwards, + // so it is a handle of the drawing it made current. + let drawing = active_drawing(&s); + match step { + Ready::Script(body) => { + s.script(&body)?; + if active_drawing(&s) != drawing { + last_handle = None; + } + } + Ready::Cmd(CmdStep { id, params }) => { + let params = fill_last(params, last_handle).map_err(|source| RunError::CmdLast { id: id.clone(), source })?; + let r = s.execute(id, ¶ms)?; + if active_drawing(&s) != drawing { + last_handle = None; + } + if let Some(h) = returned_handle(&s, &r) { + last_handle = Some(h); + } + if !r.is_null() { + io.outln(format_args!("{r}")); + } + } + } + } + for l in &s.log { + io.errln(format_args!("{l}")); + } + if let Some(p) = save { + export(&s, p, io)?; + } + if let Some(p) = export_to { + let window = if cadcraft_io::is_image(p) { export_window(&s, framing, Some(&before))? } else { None }; + export_framed(&s, p, window, io)?; + } + Ok(()) +} diff --git a/apps/cadcraft-cli/src/sample.rs b/apps/cadcraft-cli/src/sample.rs new file mode 100644 index 000000000..9b6405cb5 --- /dev/null +++ b/apps/cadcraft-cli/src/sample.rs @@ -0,0 +1,14 @@ +use super::args::{SampleArgs, SampleName}; +use super::error::Result; +use super::output::{Streams, write_atomic}; + +pub(crate) fn sample(a: &SampleArgs, io: &mut Streams) -> Result { + let d = match a.name { + SampleName::Bracket => cadcraft_engine::sample::bracket(), + SampleName::Floorplan => cadcraft_engine::sample::floor_plan(), + }; + let bytes = cadcraft_io::write(&d, &a.output)?; + write_atomic(&a.output, &bytes)?; + io.errln(format_args!("wrote {} ({} bytes)", a.output.display(), bytes.len())); + Ok(()) +} diff --git a/apps/cadcraft-cli/tests/it/help.rs b/apps/cadcraft-cli/tests/it/help.rs index 24df988af..65f8bad97 100644 --- a/apps/cadcraft-cli/tests/it/help.rs +++ b/apps/cadcraft-cli/tests/it/help.rs @@ -1,23 +1,23 @@ //! `--help` is a request, not a failure (#1525): it goes to stdout with exit 0, like `--version`. -//! Bare `cadcraft-cli` keeps reporting on stderr with exit 1. +//! Bare `cadcraft-cli` is a usage error: the help on stderr, exit 2. use std::process::Command; #[test] -fn help_flags_print_usage_to_stdout_and_exit_zero() { +fn help_flags_print_help_to_stdout_and_exit_zero() { for args in [&["--help"][..], &["-h"], &["help"]] { let out = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli")).args(args).output().expect("run cadcraft-cli"); assert!(out.status.success(), "{args:?}: {:?}", out.status); let stdout = String::from_utf8_lossy(&out.stdout); - assert!(stdout.starts_with("usage:"), "{args:?}: {stdout:?}"); + assert!(stdout.starts_with("cadcraft-cli: headless CADCraft\n"), "{args:?}: {stdout:?}"); assert!(String::from_utf8_lossy(&out.stderr).is_empty(), "{args:?}: stderr should be empty"); } } #[test] -fn bare_invocation_still_reports_on_stderr() { +fn bare_invocation_reports_on_stderr() { let out = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli")).output().expect("run cadcraft-cli"); - assert_eq!(out.status.code(), Some(1)); - assert!(out.stdout.is_empty(), "bare invocation keeps its usage on stderr"); - assert!(String::from_utf8_lossy(&out.stderr).starts_with("usage:")); + assert_eq!(out.status.code(), Some(2)); + assert!(out.stdout.is_empty(), "bare invocation keeps its help on stderr"); + assert!(String::from_utf8_lossy(&out.stderr).starts_with("cadcraft-cli: headless CADCraft\n")); } diff --git a/apps/cadcraft-cli/tests/it/main.rs b/apps/cadcraft-cli/tests/it/main.rs index efd49c7dd..adb3f3749 100644 --- a/apps/cadcraft-cli/tests/it/main.rs +++ b/apps/cadcraft-cli/tests/it/main.rs @@ -4,3 +4,4 @@ mod help; mod mcp_connect; mod skipped_records; mod undrawn_entities; +mod usage; diff --git a/apps/cadcraft-cli/tests/it/mcp_connect.rs b/apps/cadcraft-cli/tests/it/mcp_connect.rs index c12e71c82..4211f3595 100644 --- a/apps/cadcraft-cli/tests/it/mcp_connect.rs +++ b/apps/cadcraft-cli/tests/it/mcp_connect.rs @@ -33,12 +33,15 @@ fn replies(out: &Output) -> Vec { #[test] fn connect_without_address_fails_before_serving() { let input = format!("{INIT}\n{CIRCLE}\n"); - for args in [&["--connect"][..], &["--connect", ""], &["--connect", "--foo"]] { + // clap names an unknown flag rather than the value it left missing. + for (args, named) in + [(&["--connect"][..], "--connect "), (&["--connect", ""], "--connect "), (&["--connect", "--foo"], "'--foo'")] + { let out = mcp(args, &input); - assert!(!out.status.success(), "{args:?} must exit non-zero"); + assert_eq!(out.status.code(), Some(2), "{args:?} is a usage error"); assert!(out.stdout.is_empty(), "{args:?} must not answer MCP requests: {}", String::from_utf8_lossy(&out.stdout)); let err = String::from_utf8_lossy(&out.stderr); - assert!(err.contains("--connect needs HOST:PORT"), "{args:?}: {err}"); + assert!(err.contains(named), "{args:?}: {err}"); } } diff --git a/apps/cadcraft-cli/tests/it/usage.rs b/apps/cadcraft-cli/tests/it/usage.rs new file mode 100644 index 000000000..2e9f6e907 --- /dev/null +++ b/apps/cadcraft-cli/tests/it/usage.rs @@ -0,0 +1,950 @@ +//! The command line's behaviour: exit codes, streams and messages for help requests, unknown and +//! malformed options, value flags in both spellings, repeats and arity. Every case goes through +//! `invoke`, so the table rows are the record of what each input does. Usage errors are clap's +//! (exit 2, stderr); a subcommand's own failures are `error: …` with exit 1. + +use std::path::{Path, PathBuf}; + +struct Invoke { + code: i32, + stdout: String, + stderr: String, +} + +fn invoke(args: &[&str]) -> Invoke { + let (mut out, mut err) = (Vec::new(), Vec::new()); + let code = cadcraft_cli::run(args, &mut out, &mut err); + Invoke { code, stdout: String::from_utf8_lossy(&out).into_owned(), stderr: String::from_utf8_lossy(&err).into_owned() } +} + +/// What a stream holds. +#[derive(Clone, Copy)] +enum Expect { + Empty, + /// The first line equals this. + Line(&'static str), + /// The first line starts with this. + Starts(&'static str), +} + +use Expect::{Empty, Line, Starts}; + +struct Case { + name: &'static str, + args: &'static [&'static str], + code: i32, + stdout: Expect, + stderr: Expect, +} + +const fn case(name: &'static str, args: &'static [&'static str], code: i32, stdout: Expect, stderr: Expect) -> Case { + Case { name, args, code, stdout, stderr } +} + +/// A scratch directory holding `b.dxf` (the bracket sample) and `s.scr` (a one-line script). +struct Scratch(PathBuf); + +impl Scratch { + fn new(tag: &str) -> Scratch { + let dir = std::env::temp_dir().join(format!("cc-cli-usage-{tag}-{}", std::process::id())); + std::fs::create_dir_all(&dir).expect("create scratch dir"); + let b = dir.join("b.dxf"); + let r = invoke(&["sample", "bracket", b.to_str().expect("utf-8 path")]); + assert_eq!(r.code, 0, "{}", r.stderr); + std::fs::write(dir.join("s.scr"), "LINE 0,0 1,1\n").expect("write script"); + Scratch(dir) + } + + /// Replaces `{dir}` with the scratch directory and `{b}` with the sample drawing. + fn expand(&self, text: &str) -> String { + let dir = self.0.to_str().expect("utf-8 path"); + text.replace("{b}", &Path::new(dir).join("b.dxf").to_string_lossy()).replace("{dir}", dir) + } +} + +impl Drop for Scratch { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +fn check(what: &str, stream: &str, got: &str, expect: Expect, scratch: &Scratch) { + let first = got.lines().next().unwrap_or(""); + match expect { + Empty => assert!(got.is_empty(), "{what}: {stream} should be empty, got {got:?}"), + Line(l) => assert_eq!(first, scratch.expand(l), "{what}: {stream}"), + Starts(p) => assert!(first.starts_with(&scratch.expand(p)), "{what}: {stream} should start with {p:?}, got {first:?}"), + } +} + +fn run_cases(tag: &str, cases: &[Case]) { + let scratch = Scratch::new(tag); + for c in cases { + let args: Vec = c.args.iter().map(|a| scratch.expand(a)).collect(); + let args: Vec<&str> = args.iter().map(String::as_str).collect(); + let what = format!("{}: {args:?}", c.name); + let r = invoke(&args); + assert_eq!(r.code, c.code, "{what}: exit code (stderr {:?})", r.stderr); + check(&what, "stdout", &r.stdout, c.stdout, &scratch); + check(&what, "stderr", &r.stderr, c.stderr, &scratch); + } +} + +#[test] +fn top_level_requests() { + run_cases( + "top", + &[ + case("--help", &["--help"], 0, Line("cadcraft-cli: headless CADCraft"), Empty), + case("-h", &["-h"], 0, Line("cadcraft-cli: headless CADCraft"), Empty), + case("help", &["help"], 0, Line("cadcraft-cli: headless CADCraft"), Empty), + case("--version", &["--version"], 0, Starts("cadcraft-cli "), Empty), + case("-V", &["-V"], 0, Starts("cadcraft-cli "), Empty), + case("version is not a subcommand", &["version"], 2, Empty, Line("error: unrecognized subcommand 'version'")), + case("bare", &[], 2, Empty, Line("cadcraft-cli: headless CADCraft")), + case("unknown subcommand", &["foo"], 2, Empty, Line("error: unrecognized subcommand 'foo'")), + case("unknown top-level flag", &["--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("empty subcommand", &[""], 2, Empty, Line("error: unrecognized subcommand ''")), + ], + ); +} + +/// Each subcommand's help, from `--help`, `-h` or `help `: its first line is the +/// subcommand's summary. +#[test] +fn subcommand_help_requests() { + run_cases( + "subhelp", + &[ + case("info --help", &["info", "--help"], 0, Line("Print a drawing's summary as JSON"), Empty), + case("info -h", &["info", "-h"], 0, Line("Print a drawing's summary as JSON"), Empty), + case( + "convert --help", + &["convert", "--help"], + 0, + Line("Convert a drawing; OUT's extension picks the format (dxf, dwg, dwt, svg, png, pdf)"), + Empty, + ), + case( + "convert -h", + &["convert", "-h"], + 0, + Line("Convert a drawing; OUT's extension picks the format (dxf, dwg, dwt, svg, png, pdf)"), + Empty, + ), + case( + "run --help", + &["run", "--help"], + 0, + Line("Open drawings (or start a new one), run scripts and commands in order, save or export the result"), + Empty, + ), + case( + "run -h", + &["run", "-h"], + 0, + Line("Open drawings (or start a new one), run scripts and commands in order, save or export the result"), + Empty, + ), + case("commands --help", &["commands", "--help"], 0, Line("Print the command catalog as JSON"), Empty), + case( + "mcp --help", + &["mcp", "--help"], + 0, + Line("Run the MCP server on stdio: a headless drawing session, or a bridge to the running app"), + Empty, + ), + case( + "perf --help", + &["perf", "--help"], + 0, + Line( + "Time the engine on a synthetic N-entity drawing (default 200000), or the canvas display-list build of a drawing, zoomed in step by step", + ), + Empty, + ), + case("sample --help", &["sample", "--help"], 0, Line("Write a built-in sample drawing"), Empty), + case( + "help run", + &["help", "run"], + 0, + Line("Open drawings (or start a new one), run scripts and commands in order, save or export the result"), + Empty, + ), + case("help info", &["help", "info"], 0, Line("Print a drawing's summary as JSON"), Empty), + case( + "help after a flag missing its value", + &["run", "--sample", "--script", "--help"], + 0, + Line("Open drawings (or start a new one), run scripts and commands in order, save or export the result"), + Empty, + ), + case( + "help after an unknown flag", + &["run", "--bogus", "--help"], + 0, + Line("Open drawings (or start a new one), run scripts and commands in order, save or export the result"), + Empty, + ), + case("help after an extra argument", &["info", "{b}", "extra", "-h"], 0, Line("Print a drawing's summary as JSON"), Empty), + case("--help after -- is a file name", &["run", "--", "--help"], 1, Empty, Starts("error: invalid parameters for `open`: --help:")), + case("run --version", &["run", "--version"], 2, Empty, Line("error: unexpected argument '--version' found")), + case("info --version", &["info", "--version"], 2, Empty, Line("error: unexpected argument '--version' found")), + ], + ); +} + +#[test] +fn unknown_flags_on_every_subcommand() { + run_cases( + "unknown", + &[ + case("info", &["info", "{b}", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("info, flag first", &["info", "--bogus", "{b}"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("info, short flag", &["info", "-x"], 2, Empty, Line("error: unexpected argument '-x' found")), + case("info, a file name starting with - after --", &["info", "--", "-x"], 1, Empty, Starts("error: invalid parameters for `open`: -x:")), + case("convert", &["convert", "{b}", "{dir}/o.svg", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("run", &["run", "--sample", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("run, flag first", &["run", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("commands", &["commands", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("commands -- ends the options", &["commands", "--"], 0, Line("["), Empty), + case("mcp", &["mcp", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("mcp positional", &["mcp", "extra"], 2, Empty, Line("error: unexpected argument 'extra' found")), + case("perf", &["perf", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("sample", &["sample", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + case("sample after name", &["sample", "bracket", "--bogus"], 2, Empty, Line("error: unexpected argument '--bogus' found")), + ], + ); +} + +/// `--x=v` is a spelling of `--x v`, and the one a value starting with `-` needs. +#[test] +fn value_flags_in_both_forms() { + run_cases( + "forms", + &[ + case("--window v", &["convert", "{b}", "{dir}/w1.svg", "--window", "0,0,100,100"], 0, Empty, Starts("wrote {dir}/w1.svg (")), + case("--window=v", &["convert", "{b}", "{dir}/w2.svg", "--window=0,0,100,100"], 0, Empty, Starts("wrote {dir}/w2.svg (")), + case( + "run --window v", + &["run", "--sample", "--window", "0,0,100,100", "--export", "{dir}/w3.svg"], + 0, + Empty, + Starts("wrote {dir}/w3.svg ("), + ), + case( + "run --window=v", + &["run", "--sample", "--window=0,0,100,100", "--export", "{dir}/w4.svg"], + 0, + Empty, + Starts("wrote {dir}/w4.svg ("), + ), + case("--view v", &["convert", "{b}", "{dir}/v1.svg", "--view", "extents"], 0, Empty, Starts("wrote {dir}/v1.svg (")), + case("--view=v", &["convert", "{b}", "{dir}/v2.svg", "--view=extents"], 0, Empty, Starts("wrote {dir}/v2.svg (")), + case("run --view v", &["run", "--sample", "--view", "current", "--export", "{dir}/v3.svg"], 0, Empty, Starts("wrote {dir}/v3.svg (")), + case("run --view=v", &["run", "--sample", "--view=extents", "--export={dir}/v4.svg"], 0, Empty, Starts("wrote {dir}/v4.svg (")), + case("--script v", &["run", "--sample", "--script", "LINE 0,0 1,1"], 0, Empty, Line("Command: LINE")), + case("--script=v", &["run", "--sample", "--script=LINE 0,0 1,1"], 0, Empty, Line("Command: LINE")), + case("--script-file v", &["run", "--sample", "--script-file", "{dir}/s.scr"], 0, Empty, Starts("Command: LINE")), + case("--script-file=v", &["run", "--sample", "--script-file={dir}/s.scr"], 0, Empty, Starts("Command: LINE")), + case("--cmd v", &["run", "--sample", "--cmd", "nosuch"], 1, Empty, Line("error: unknown command `nosuch`")), + case("--cmd=v", &["run", "--sample", "--cmd=nosuch"], 1, Empty, Line("error: unknown command `nosuch`")), + case("--cmd=-v", &["run", "--sample", "--cmd=-x"], 1, Empty, Line("error: unknown command `-x`")), + case("--save v", &["run", "--sample", "--save", "{dir}/s1.dxf"], 0, Empty, Starts("wrote {dir}/s1.dxf (")), + case("--save=v", &["run", "--sample", "--save={dir}/s2.dxf"], 0, Empty, Starts("wrote {dir}/s2.dxf (")), + case("--export v", &["run", "--sample", "--export", "{dir}/e1.svg"], 0, Empty, Starts("wrote {dir}/e1.svg (")), + case("--export=v", &["run", "--sample", "--export={dir}/e2.svg"], 0, Empty, Starts("wrote {dir}/e2.svg (")), + case( + "--window=-v: negative coordinates need =", + &["convert", "{b}", "{dir}/w5.svg", "--window=-1000,-1000,1000,1000"], + 0, + Empty, + Starts("wrote {dir}/w5.svg ("), + ), + case( + "--window -v: a value starting with - is a flag", + &["convert", "{b}", "{dir}/w6.svg", "--window", "-1000,-1000,1000,1000"], + 2, + Empty, + Line("error: unexpected argument '-1' found"), + ), + case("--connect v", &["mcp", "--connect", "127.0.0.1:1"], 1, Empty, Starts("error: cannot connect to 127.0.0.1:1:")), + case("--connect=v", &["mcp", "--connect=127.0.0.1:1"], 1, Empty, Starts("error: cannot connect to 127.0.0.1:1:")), + ], + ); +} + +/// A value flag at the end of the arguments, or followed by another flag, is missing its value: +/// a flag is never taken as a value. +#[test] +fn flags_missing_their_value() { + run_cases( + "missing", + &[ + case( + "convert --window last", + &["convert", "{b}", "{dir}/o.svg", "--window"], + 2, + Empty, + Line("error: a value is required for '--window ' but none was supplied"), + ), + case( + "convert --view last", + &["convert", "{b}", "{dir}/o.svg", "--view"], + 2, + Empty, + Line("error: a value is required for '--view ' but none was supplied"), + ), + case( + "convert --window then flag", + &["convert", "{b}", "{dir}/o.svg", "--window", "--view", "extents"], + 2, + Empty, + Line("error: a value is required for '--window ' but none was supplied"), + ), + case( + "convert --view then flag", + &["convert", "{b}", "{dir}/o.svg", "--view", "--window", "0,0,1,1"], + 2, + Empty, + Line("error: a value is required for '--view ' but none was supplied"), + ), + case( + "run --window last", + &["run", "--sample", "--window"], + 2, + Empty, + Line("error: a value is required for '--window ' but none was supplied"), + ), + case( + "run --view last", + &["run", "--sample", "--view"], + 2, + Empty, + Line("error: a value is required for '--view ' but none was supplied"), + ), + case( + "run --script last", + &["run", "--sample", "--script"], + 2, + Empty, + Line("error: a value is required for '--script ' but none was supplied"), + ), + case( + "run --script then flag", + &["run", "--sample", "--script", "--sample"], + 2, + Empty, + Line("error: a value is required for '--script ' but none was supplied"), + ), + case( + "run --script-file last", + &["run", "--script-file"], + 2, + Empty, + Line("error: a value is required for '--script-file ' but none was supplied"), + ), + case( + "run --script-file then flag", + &["run", "--sample", "--script-file", "--sample"], + 2, + Empty, + Line("error: a value is required for '--script-file ' but none was supplied"), + ), + case( + "run --cmd last", + &["run", "--sample", "--cmd"], + 2, + Empty, + Line("error: a value is required for '--cmd ' but none was supplied"), + ), + case( + "run --cmd then flag", + &["run", "--sample", "--cmd", "--sample"], + 2, + Empty, + Line("error: a value is required for '--cmd ' but none was supplied"), + ), + case( + "run --save last", + &["run", "--sample", "--save"], + 2, + Empty, + Line("error: a value is required for '--save ' but none was supplied"), + ), + case( + "run --export last", + &["run", "--sample", "--export"], + 2, + Empty, + Line("error: a value is required for '--export ' but none was supplied"), + ), + case( + "mcp --connect last", + &["mcp", "--connect"], + 2, + Empty, + Line("error: a value is required for '--connect ' but none was supplied"), + ), + case( + "mcp --connect then flag", + &["mcp", "--connect", "--lazy"], + 2, + Empty, + Line("error: a value is required for '--connect ' but none was supplied"), + ), + case( + "mcp --connect empty", + &["mcp", "--connect", " "], + 2, + Empty, + Line("error: invalid value ' ' for '--connect ': expected HOST:PORT (the app's --control port, e.g. 127.0.0.1:7979)"), + ), + case( + "mcp --connect without a port", + &["mcp", "--connect", "example.com"], + 2, + Empty, + Line( + "error: invalid value 'example.com' for '--connect ': expected HOST:PORT (the app's --control port, e.g. 127.0.0.1:7979)", + ), + ), + case( + "mcp --connect port out of range", + &["mcp", "--connect", "host:99999"], + 2, + Empty, + Line( + "error: invalid value 'host:99999' for '--connect ': expected HOST:PORT (the app's --control port, e.g. 127.0.0.1:7979)", + ), + ), + case( + "mcp --connect=-v", + &["mcp", "--connect=-v"], + 2, + Empty, + Line("error: invalid value '-v' for '--connect ': expected HOST:PORT (the app's --control port, e.g. 127.0.0.1:7979)"), + ), + ], + ); +} + +#[test] +fn repeated_and_combined_flags() { + run_cases( + "repeat", + &[ + case( + "--save twice", + &["run", "--sample", "--save", "{dir}/a.dxf", "--save", "{dir}/b2.dxf"], + 2, + Empty, + Line("error: the argument '--save ' cannot be used multiple times"), + ), + case( + "--export twice", + &["run", "--sample", "--export", "{dir}/x1.svg", "--export", "{dir}/x2.svg"], + 2, + Empty, + Line("error: the argument '--export ' cannot be used multiple times"), + ), + case( + "--window twice", + &["run", "--sample", "--window", "0,0,1,1", "--window", "0,0,2,2", "--export", "{dir}/ww.svg"], + 2, + Empty, + Line("error: the argument '--window ' cannot be used multiple times"), + ), + case( + "convert --window twice", + &["convert", "{b}", "{dir}/cw.svg", "--window", "0,0,1,1", "--window", "0,0,2,2"], + 2, + Empty, + Line("error: the argument '--window ' cannot be used multiple times"), + ), + case( + "--view twice, different", + &["run", "--sample", "--view", "extents", "--view", "current", "--export", "{dir}/vv.svg"], + 2, + Empty, + Line("error: the argument '--view ' cannot be used multiple times"), + ), + case( + "--view twice, same", + &["run", "--sample", "--view", "extents", "--view", "extents", "--export", "{dir}/vs.svg"], + 2, + Empty, + Line("error: the argument '--view ' cannot be used multiple times"), + ), + case("--sample twice", &["run", "--sample", "--sample"], 2, Empty, Line("error: the argument '--sample' cannot be used multiple times")), + case("--metric twice", &["run", "--metric", "--metric"], 2, Empty, Line("error: the argument '--metric' cannot be used multiple times")), + case( + "--lazy twice", + &["mcp", "--connect", "127.0.0.1:1", "--lazy", "--lazy"], + 2, + Empty, + Line("error: the argument '--lazy' cannot be used multiple times"), + ), + case( + "--launch twice", + &["mcp", "--connect", "127.0.0.1:1", "--launch", "--launch"], + 2, + Empty, + Line("error: the argument '--launch' cannot be used multiple times"), + ), + case( + "--script, --script-file and --cmd repeat", + &[ + "run", + "--sample", + "--script", + "LINE 0,0 1,1", + "--script", + "LINE 0,0 2,2", + "--script-file", + "{dir}/s.scr", + "--script-file", + "{dir}/s.scr", + ], + 0, + Empty, + Starts("Command: LINE"), + ), + case( + "--window and --view", + &["run", "--sample", "--window", "0,0,1,1", "--view", "extents", "--export", "{dir}/wv.svg"], + 2, + Empty, + Line("error: the argument '--window ' cannot be used with '--view '"), + ), + case( + "convert --window and --view", + &["convert", "{b}", "{dir}/cwv.svg", "--window", "0,0,1,1", "--view", "extents"], + 2, + Empty, + Line("error: the argument '--window ' cannot be used with '--view '"), + ), + case( + "--view is case-insensitive", + &["run", "--sample", "--view", "EXTENTS", "--export", "{dir}/vu.svg"], + 0, + Empty, + Starts("wrote {dir}/vu.svg ("), + ), + case( + "--connect twice", + &["mcp", "--connect", "127.0.0.1:1", "--connect", "127.0.0.1:2"], + 2, + Empty, + Line("error: the argument '--connect ' cannot be used multiple times"), + ), + case("--lazy without --connect", &["mcp", "--lazy"], 2, Empty, Line("error: the following required arguments were not provided:")), + case("--launch without --connect", &["mcp", "--launch"], 2, Empty, Line("error: the following required arguments were not provided:")), + case("--sample --metric: both accepted", &["run", "--sample", "--metric"], 0, Empty, Empty), + case("--sample and a file", &["run", "--sample", "{b}"], 0, Empty, Empty), + case("two files", &["run", "{b}", "{b}"], 0, Empty, Empty), + case( + "--window without export", + &["run", "--sample", "--window", "0,0,1,1"], + 2, + Empty, + Line("error: the following required arguments were not provided:"), + ), + case( + "--view without export", + &["run", "--sample", "--view", "current"], + 2, + Empty, + Line("error: the following required arguments were not provided:"), + ), + case( + "--window with a dxf output", + &["convert", "{b}", "{dir}/o.dxf", "--window", "0,0,1,1"], + 2, + Empty, + Line("error: --window only applies to image output (png, svg, pdf), not `{dir}/o.dxf`"), + ), + case( + "--view with a dxf output", + &["convert", "{b}", "{dir}/o.dxf", "--view", "extents"], + 2, + Empty, + Line("error: --view only applies to image output (png, svg, pdf), not `{dir}/o.dxf`"), + ), + case( + "run --window with a dxf export", + &["run", "--sample", "--window", "0,0,1,1", "--export", "{dir}/o.dxf"], + 2, + Empty, + Line("error: --window only applies to image output (png, svg, pdf), not `{dir}/o.dxf`"), + ), + case( + "run --view with a dxf export", + &["run", "--sample", "--view", "current", "--export", "{dir}/o.dxf"], + 2, + Empty, + Line("error: --view only applies to image output (png, svg, pdf), not `{dir}/o.dxf`"), + ), + ], + ); +} + +#[test] +fn arity_and_positional_arguments() { + run_cases( + "arity", + &[ + case("info without a file", &["info"], 2, Empty, Line("error: the following required arguments were not provided:")), + case("info with two files", &["info", "{b}", "extra"], 2, Empty, Line("error: unexpected argument 'extra' found")), + case("info missing file", &["info", "missing.dxf"], 1, Empty, Starts("error: invalid parameters for `open`: missing.dxf:")), + case("convert with no files", &["convert"], 2, Empty, Line("error: the following required arguments were not provided:")), + case("convert with one file", &["convert", "{b}"], 2, Empty, Line("error: the following required arguments were not provided:")), + case( + "convert with three files", + &["convert", "{b}", "{dir}/o.svg", "{dir}/x.svg"], + 2, + Empty, + Line("error: unexpected argument '{dir}/x.svg' found"), + ), + case("run missing file", &["run", "missing.dxf"], 1, Empty, Starts("error: invalid parameters for `open`: missing.dxf:")), + case("commands, no match", &["commands", "zzzznomatch"], 0, Line("[]"), Empty), + case( + "commands with an extra argument", + &["commands", "zzzznomatch", "extra"], + 2, + Empty, + Line("error: unexpected argument 'extra' found"), + ), + case("sample without arguments", &["sample"], 2, Empty, Line("error: the following required arguments were not provided:")), + case("sample without an output", &["sample", "bracket"], 2, Empty, Line("error: the following required arguments were not provided:")), + case( + "sample with a bad name", + &["sample", "nosuch", "{dir}/o.dxf"], + 2, + Empty, + Line("error: invalid value 'nosuch' for ''"), + ), + case( + "sample names are case-sensitive", + &["sample", "Bracket", "{dir}/o.dxf"], + 2, + Empty, + Line("error: invalid value 'Bracket' for ''"), + ), + case( + "sample with an empty output", + &["sample", "bracket", ""], + 2, + Empty, + Line("error: a value is required for '' but none was supplied"), + ), + case("info with an empty file name", &["info", ""], 2, Empty, Line("error: a value is required for '' but none was supplied")), + case("perf with an empty file name", &["perf", ""], 2, Empty, Line("error: a value is required for '[N|FILE]' but none was supplied")), + case( + "sample with an extra argument", + &["sample", "bracket", "{dir}/sx.dxf", "extra"], + 2, + Empty, + Line("error: unexpected argument 'extra' found"), + ), + case("sample floor alias", &["sample", "floor", "{dir}/sf.dxf"], 0, Empty, Starts("wrote {dir}/sf.dxf (")), + case("sample with a bad extension", &["sample", "bracket", "{dir}/o.xyz"], 1, Empty, Line("error: unsupported file type `xyz`")), + case("perf with a word", &["perf", "abc"], 1, Empty, Starts("error: invalid parameters for `open`: abc:")), + case("perf with a negative number", &["perf", "-5"], 2, Empty, Line("error: unexpected argument '-5' found")), + case("perf with a missing file", &["perf", "missing.dxf"], 1, Empty, Starts("error: invalid parameters for `open`: missing.dxf:")), + case("perf 1", &["perf", "1"], 0, Starts("operation"), Empty), + case("perf 0 is raised to 1", &["perf", "0"], 0, Starts("operation"), Empty), + case("perf with two counts", &["perf", "1", "2"], 2, Empty, Line("error: unexpected argument '2' found")), + ], + ); +} + +#[test] +fn bad_values() { + run_cases( + "values", + &[ + case( + "--view sideways", + &["convert", "{b}", "{dir}/o.svg", "--view", "sideways"], + 2, + Empty, + Line("error: invalid value 'sideways' for '--view '"), + ), + case( + "run --view sideways", + &["run", "--sample", "--view", "sideways"], + 2, + Empty, + Line("error: invalid value 'sideways' for '--view '"), + ), + case( + "--view sideways before the output check", + &["convert", "{b}", "{dir}/o.dxf", "--view", "sideways"], + 2, + Empty, + Line("error: invalid value 'sideways' for '--view '"), + ), + case( + "--window 3 numbers", + &["convert", "{b}", "{dir}/o.svg", "--window", "1,2,3"], + 2, + Empty, + Line("error: invalid value '1,2,3' for '--window ': expected four numbers x0,y0,x1,y1"), + ), + case( + "--window 5 numbers", + &["convert", "{b}", "{dir}/o.svg", "--window", "1,2,3,4,5"], + 2, + Empty, + Line("error: invalid value '1,2,3,4,5' for '--window ': expected four numbers x0,y0,x1,y1"), + ), + case( + "--window reversed", + &["convert", "{b}", "{dir}/o.svg", "--window", "3,3,1,1"], + 2, + Empty, + Line("error: invalid value '3,3,1,1' for '--window ': need x0 < x1 and y0 < y1 (lower-left corner first)"), + ), + case( + "--window not numbers", + &["convert", "{b}", "{dir}/o.svg", "--window", "a,b,c,d"], + 2, + Empty, + Line("error: invalid value 'a,b,c,d' for '--window ': x0 must be a finite number, got `a`"), + ), + case( + "--window NaN", + &["convert", "{b}", "{dir}/o.svg", "--window", "NaN,0,1,1"], + 2, + Empty, + Line("error: invalid value 'NaN,0,1,1' for '--window ': x0 must be a finite number, got `NaN`"), + ), + case( + "--window too large", + &["convert", "{b}", "{dir}/o.svg", "--window", "0,0,1e13,1"], + 2, + Empty, + Line("error: invalid value '0,0,1e13,1' for '--window ': export window: coordinates must lie within ±1e12"), + ), + case( + "run --window 3 numbers", + &["run", "--sample", "--window", "1,2,3", "--export", "{dir}/o.svg"], + 2, + Empty, + Line("error: invalid value '1,2,3' for '--window ': expected four numbers x0,y0,x1,y1"), + ), + case( + "run --window reversed", + &["run", "--sample", "--window", "3,3,1,1", "--export", "{dir}/o.svg"], + 2, + Empty, + Line("error: invalid value '3,3,1,1' for '--window ': need x0 < x1 and y0 < y1 (lower-left corner first)"), + ), + case( + "--cmd bad json", + &["run", "--sample", "--cmd", "line {bad json"], + 2, + Empty, + Line("error: invalid value 'line {bad json' for '--cmd ': key must be a string at line 1 column 2"), + ), + case( + "--cmd bad json after a good step: nothing runs", + &["run", "--sample", "--cmd", "line {\"points\":[[0,0],[1,1]]}", "--cmd", "line {"], + 2, + Empty, + Starts("error: invalid value 'line {' for '--cmd ': "), + ), + case( + "--cmd without an id", + &["run", "--sample", "--cmd", " {}"], + 2, + Empty, + Line("error: invalid value ' {}' for '--cmd ': expected a command id, then optionally its JSON parameters"), + ), + case( + "--cmd empty", + &["run", "--sample", "--cmd="], + 2, + Empty, + Line("error: invalid value '' for '--cmd ': expected a command id, then optionally its JSON parameters"), + ), + case("--cmd unknown id", &["run", "--sample", "--cmd", "nosuch"], 1, Empty, Line("error: unknown command `nosuch`")), + case( + "--cmd {last} with no earlier handle", + &["run", "--sample", "--cmd", "erase {\"handles\":[\"{last}\"]}"], + 1, + Empty, + Line("error: --cmd erase: `{last}` needs an earlier --cmd in this run to have returned a handle"), + ), + case("--script-file missing", &["run", "--sample", "--script-file", "missing.scr"], 1, Empty, Starts("error: missing.scr:")), + ], + ); +} + +/// `mcp` serves on the process's real stdin and stdout, so the headless server runs through the +/// binary, with a closed stdin. +#[test] +fn mcp_headless_with_a_closed_stdin() { + let out = std::process::Command::new(env!("CARGO_BIN_EXE_cadcraft-cli")) + .arg("mcp") + .stdin(std::process::Stdio::null()) + .output() + .expect("run cadcraft-cli"); + assert_eq!(out.status.code(), Some(0)); + assert!(out.stdout.is_empty() && out.stderr.is_empty()); +} + +/// A drawing to open whose name isn't valid Unicode reaches the handler as a path; the engine opens +/// files by text name, so it is refused there (exit 1), naming the file. Text that isn't Unicode is +/// a usage error. +#[cfg(unix)] +#[test] +fn non_unicode_arguments() { + use std::ffi::OsString; + use std::os::unix::ffi::OsStringExt; + let invoke_os = |args: Vec| { + let (mut out, mut err) = (Vec::new(), Vec::new()); + let code = cadcraft_cli::run(args, &mut out, &mut err); + assert!(out.is_empty()); + (code, String::from_utf8_lossy(&err).into_owned()) + }; + let latin1 = || OsString::from_vec(b"caf\xe9.dxf".to_vec()); + let (code, err) = invoke_os(vec![OsString::from("info"), latin1()]); + assert_eq!(code, 1); + assert_eq!(err.lines().next(), Some("error: caf\u{FFFD}.dxf: the file name is not valid Unicode")); + let (code, err) = invoke_os(vec![OsString::from("run"), OsString::from("--sample"), OsString::from("--cmd"), latin1()]); + assert_eq!(code, 2); + assert!(err.starts_with("error: invalid UTF-8 was detected"), "{err}"); +} + +/// An output name that isn't valid Unicode is written as given: only its extension picks the format. +#[cfg(unix)] +#[test] +fn non_unicode_output_names() { + use std::ffi::OsString; + use std::os::unix::ffi::OsStringExt; + let s = Scratch::new("nonunicode-out"); + let latin1 = |ext: &str| { + let mut n = b"caf\xe9.".to_vec(); + n.extend_from_slice(ext.as_bytes()); + s.0.join(OsString::from_vec(n)) + }; + let run = |args: Vec| { + let (mut out, mut err) = (Vec::new(), Vec::new()); + let code = cadcraft_cli::run(args, &mut out, &mut err); + (code, String::from_utf8_lossy(&err).into_owned()) + }; + let b = s.0.join("b.dxf"); + let cases: [(Vec, std::path::PathBuf); 3] = [ + (vec!["sample".into(), "bracket".into(), latin1("dxf").into()], latin1("dxf")), + (vec!["convert".into(), b.clone().into(), latin1("svg").into()], latin1("svg")), + (vec!["run".into(), "--sample".into(), "--save".into(), latin1("dwg").into()], latin1("dwg")), + ]; + for (args, path) in cases { + let (code, err) = run(args.clone()); + assert_eq!(code, 0, "{args:?}: {err}"); + assert!(path.exists(), "{path:?}"); + assert!(std::fs::metadata(&path).expect("stat output").len() > 0, "{path:?}"); + } + // An input with such a name is still refused. + let (code, err) = run(vec!["info".into(), latin1("dxf").into()]); + assert_eq!(code, 1); + assert!(err.contains("not valid Unicode"), "{err}"); +} + +/// An output that is an input file is refused before any work (exit 2, the input untouched) unless +/// `--in-place` allows it; the same file under another spelling counts, another existing file doesn't. +#[test] +fn output_that_replaces_an_input() { + let s = Scratch::new("inplace"); + let dir = s.0.to_str().expect("utf-8 path").to_string(); + let b = format!("{dir}/b.dxf"); + let original = std::fs::read(&b).expect("read input"); + std::fs::create_dir_all(format!("{dir}/sub")).expect("create sub"); + let dotted = format!("{dir}/sub/../b.dxf"); + #[allow(unused_mut)] + let mut spellings = vec![b.clone(), dotted]; + #[cfg(unix)] + { + let link = format!("{dir}/link.dxf"); + std::os::unix::fs::symlink(&b, &link).expect("symlink"); + spellings.push(link); + } + for out in &spellings { + for args in [vec!["convert", &b, out], vec!["run", &b, "--save", out], vec!["run", &b, "--export", out]] { + let r = invoke(&args); + assert_eq!(r.code, 2, "{args:?}: {}", r.stderr); + assert!(r.stdout.is_empty(), "{args:?}"); + assert!(r.stderr.starts_with(&format!("error: {out} is an input file")), "{args:?}: {}", r.stderr); + assert!(r.stderr.contains("--in-place"), "{args:?}: {}", r.stderr); + assert_eq!(std::fs::read(&b).expect("read input"), original, "{args:?}: input changed"); + } + } + + // Another existing file is replaced as before. + let other = format!("{dir}/other.dxf"); + std::fs::write(&other, "x").expect("write other"); + let r = invoke(&["convert", &b, &other]); + assert_eq!(r.code, 0, "{}", r.stderr); + assert_ne!(std::fs::read(&other).expect("read other"), b"x"); + + // --in-place allows it, for each spelling and flag: the input itself is rewritten, and a + // symlink stays a link to it. + let line = "line {\"points\":[[0,0],[1,1]]}"; + let lines = |p: &str| std::fs::read_to_string(p).expect("read input").lines().filter(|l| l.trim_end() == "LINE").count(); + let before = lines(&b); + for out in &spellings { + std::fs::write(&b, &original).expect("restore input"); + let r = invoke(&["convert", &b, out, "--in-place"]); + assert_eq!(r.code, 0, "convert {out}: {}", r.stderr); + assert_eq!(lines(&b), before, "convert {out} keeps the drawing"); + for flag in ["--save", "--export"] { + std::fs::write(&b, &original).expect("restore input"); + let r = invoke(&["run", &b, "--cmd", line, "--in-place", flag, out]); + assert_eq!(r.code, 0, "{flag} {out}: {}", r.stderr); + assert_eq!(lines(&b), before + 1, "{flag} {out}: the input gains the line"); + } + } + #[cfg(unix)] + { + let link = format!("{dir}/link.dxf"); + assert!(std::fs::symlink_metadata(&link).expect("stat link").file_type().is_symlink(), "{link} is still a symlink"); + } + + // An output that doesn't exist yet is never an input. + let new = format!("{dir}/new.dxf"); + let r = invoke(&["run", &b, "--save", &new]); + assert_eq!(r.code, 0, "{}", r.stderr); + assert!(std::path::Path::new(&new).is_file(), "{new} written"); +} + +/// JSON results are pretty-printed; `--compact` puts each on one line (RFC-0012 rule 1.3). `run` +/// prints one line per `--cmd` result either way. +#[test] +fn json_output_is_pretty_unless_compact() { + let s = Scratch::new("compact"); + let b = format!("{}/b.dxf", s.0.to_str().expect("utf-8 path")); + for args in [&["info", b.as_str()][..], &["commands", "ellipse"]] { + let help = invoke(&[args[0], "--help"]); + assert!( + help.stdout.contains("--compact") && help.stdout.contains("One line of JSON instead of pretty-printed"), + "{} --help: {}", + args[0], + help.stdout + ); + let pretty = invoke(args); + assert_eq!(pretty.code, 0, "{args:?}: {}", pretty.stderr); + assert!(pretty.stdout.lines().count() > 1, "{args:?} is pretty-printed: {}", pretty.stdout); + let compact = invoke(&[args, &["--compact"]].concat()); + assert_eq!(compact.code, 0, "{args:?} --compact: {}", compact.stderr); + assert_eq!(compact.stdout.lines().count(), 1, "{args:?} --compact is one line: {}", compact.stdout); + let a: serde_json::Value = serde_json::from_str(&pretty.stdout).expect("pretty JSON"); + let c: serde_json::Value = serde_json::from_str(&compact.stdout).expect("compact JSON"); + assert_eq!(a, c, "{args:?}: same JSON either way"); + } + let r = invoke(&["run", "--sample", "--cmd", "drawing.inspect", "--cmd", "drawing.inspect"]); + assert_eq!(r.code, 0, "{}", r.stderr); + assert_eq!(r.stdout.lines().count(), 2, "one line per --cmd result: {}", r.stdout); + assert_eq!(invoke(&["run", "--sample", "--compact"]).code, 2, "run takes no --compact"); +} diff --git a/apps/cadcraft-cli/tests/man_and_completions.rs b/apps/cadcraft-cli/tests/man_and_completions.rs new file mode 100644 index 000000000..df6dea90c --- /dev/null +++ b/apps/cadcraft-cli/tests/man_and_completions.rs @@ -0,0 +1,30 @@ +//! The clap definition is consistent, and `examples/man-and-completions.rs` writes every shell's +//! completions and every man page under the names `packaging/linux/package.sh` installs. + +// The example itself, so the test runs its code; its `main` is unused here. +#[allow(dead_code)] +#[path = "../examples/man-and-completions.rs"] +mod example; + +#[test] +fn command_is_consistent() { + cadcraft_cli::command().debug_assert(); +} + +#[test] +fn the_example_writes_the_files_the_packages_install() { + let dir = std::path::Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("man-and-completions-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + example::generate(&dir).unwrap(); + + let mut written: Vec = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name().into_string().unwrap()).collect(); + written.sort(); + let completions = ["cadcraft-cli.bash", "_cadcraft-cli", "cadcraft-cli.fish", "cadcraft-cli.elv", "_cadcraft-cli.ps1"]; + let subcommands = ["info", "convert", "run", "commands", "mcp", "perf", "sample"]; + let mut expected: Vec = completions.map(String::from).into(); + expected.push("cadcraft-cli.1".into()); + expected.extend(subcommands.iter().map(|s| format!("cadcraft-cli-{s}.1"))); + expected.sort(); + assert_eq!(written, expected); + std::fs::remove_dir_all(&dir).unwrap(); +} diff --git a/apps/cadcraft/Cargo.toml b/apps/cadcraft/Cargo.toml index 48c2c2d15..d8b4ef4c5 100644 --- a/apps/cadcraft/Cargo.toml +++ b/apps/cadcraft/Cargo.toml @@ -21,6 +21,8 @@ eframe = { workspace = true, features = ["clipboard", "wgpu", "accesskit", "wayl egui = { workspace = true } serde_json = { workspace = true } log = { workspace = true } +clap = { workspace = true } +thiserror = { workspace = true } chrono = { workspace = true } [build-dependencies] diff --git a/apps/cadcraft/src/env.rs b/apps/cadcraft/src/env.rs new file mode 100644 index 000000000..76df8aa15 --- /dev/null +++ b/apps/cadcraft/src/env.rs @@ -0,0 +1,172 @@ +//! The `CADCRAFT_*` variables of the desktop app, read once at startup into [`Env`] and passed on +//! from there; no library crate reads them. `--help` lists them from [`VARS`]. `--control`'s +//! fallback, `CADCRAFT_CONTROL_PORT`, is clap's (see `launch_args`). + +use std::ffi::OsString; +use std::fmt::Write as _; +use std::path::PathBuf; + +use cadcraft_ui_egui::switch::Switch; + +const CONFIG_DIR: &str = "CADCRAFT_CONFIG_DIR"; +const LOCALE: &str = "CADCRAFT_LOCALE"; +const VSYNC: &str = "CADCRAFT_VSYNC"; +const WAYLAND: &str = "CADCRAFT_WAYLAND"; +const NO_NATIVE_MENU: &str = "CADCRAFT_NO_NATIVE_MENU"; +const SYSTEM_CURSOR: &str = "CADCRAFT_SYSTEM_CURSOR"; +const FONTALT: &str = "CADCRAFT_FONTALT"; +const FONTFALLBACK: &str = "CADCRAFT_FONTFALLBACK"; + +/// Every variable [`Env`] reads, with its `--help` line. +pub(crate) const VARS: &[(&str, &str)] = &[ + (CONFIG_DIR, "the settings folder (logs, autosave, workspace, plotters); empty means no settings folder"), + (LOCALE, "the interface language, instead of the system's"), + (VSYNC, "1 presents with vsync, 0 without it (default: without on Linux and BSD)"), + (WAYLAND, "1 keeps the native Wayland backend instead of XWayland; 0 or unset is off"), + (NO_NATIVE_MENU, "macOS: 1 keeps the menus inside the window; 0 or unset is off"), + (SYSTEM_CURSOR, "1 uses the system cursor instead of the drawn crosshair; 0 or unset is off"), + (FONTALT, "the font that replaces a missing one"), + (FONTFALLBACK, "the fonts tried, in order, for characters a font lacks"), +]; + +/// The process environment, read once at startup. A blank variable counts as unset, except +/// `CADCRAFT_CONFIG_DIR`. +#[derive(Debug, PartialEq)] +pub(crate) struct Env { + /// The settings folder (logs, autosave, workspace, plotters): `CADCRAFT_CONFIG_DIR`; else, when + /// that is unset, the platform's (`cadcraft_engine::settings_dir::platform`). `None`: no + /// folder, because the variable is empty or blank (the way to run without one) or the + /// platform has none. + pub(crate) config_dir: Option, + /// The interface language, instead of the system's. + pub(crate) locale: Option, + /// Present with vsync (default: off on Linux and BSD, on elsewhere). + pub(crate) vsync: Switch, + /// Keep the native Wayland backend instead of XWayland. + #[cfg_attr(not(all(unix, not(target_os = "macos"))), allow(dead_code))] + pub(crate) wayland: Switch, + /// macOS: keep the menus inside the window. + #[cfg_attr(not(target_os = "macos"), allow(dead_code))] + pub(crate) no_native_menu: Switch, + /// Use the system cursor instead of the drawn crosshair. + pub(crate) system_cursor: Switch, + /// FONTALT at startup. + pub(crate) font_alt: Option, + /// FONTFALLBACK at startup. + pub(crate) font_fallback: Option, +} + +impl Env { + pub(crate) fn read() -> Env { + Env::from_vars(|k| std::env::var_os(k)) + } + + /// [`Env::read`] with `var` looking a variable up. + pub(crate) fn from_vars(var: impl Fn(&str) -> Option) -> Env { + let text = |k: &str| var(k).and_then(|v| v.into_string().ok()).filter(|v| !v.trim().is_empty()); + let switch = |k: &str| Switch::parse(k, var(k).map(|v| v.to_string_lossy().into_owned()).as_deref()); + Env { + config_dir: match var(CONFIG_DIR) { + Some(dir) if dir.to_str().is_some_and(|d| d.trim().is_empty()) => None, + Some(dir) => Some(PathBuf::from(dir)), + None => cadcraft_engine::settings_dir::platform(&var), + }, + locale: text(LOCALE), + vsync: switch(VSYNC), + wayland: switch(WAYLAND), + no_native_menu: switch(NO_NATIVE_MENU), + system_cursor: switch(SYSTEM_CURSOR), + font_alt: text(FONTALT), + font_fallback: text(FONTFALLBACK), + } + } +} + +/// The `--help` section that lists [`VARS`]. +pub(crate) fn help() -> String { + let width = VARS.iter().map(|(name, _)| name.len()).max().unwrap_or(0) + 3; + VARS.iter().fold(String::from("Environment:"), |mut help, (name, line)| { + let _ = write!(help, "\n {name:(vars: &'a [(&'a str, &'a str)]) -> impl Fn(&str) -> Option + 'a { + move |k| vars.iter().find(|(n, _)| *n == k).map(|(_, v)| OsString::from(v)) + } + + #[test] + fn every_variable_read_is_in_the_help_and_every_listed_one_is_read() { + let asked = RefCell::new(Vec::new()); + Env::from_vars(|k| { + asked.borrow_mut().push(k.to_owned()); + None + }); + let ours: Vec = asked.into_inner().into_iter().filter(|k| k.starts_with("CADCRAFT_")).collect(); + let help = help(); + let unset = Env::from_vars(|_| None); + for k in &ours { + assert!(VARS.iter().any(|(name, _)| name == k), "{k} is read but not in VARS"); + } + for (name, line) in VARS { + assert!(ours.iter().any(|k| k == name), "{name} is in VARS but not read"); + assert_ne!(Env::from_vars(env(&[(name, "1")])), unset, "{name} sets no field"); + assert!(help.lines().any(|l| l.trim_start().starts_with(name) && l.ends_with(line)), "{help}"); + } + } + + #[test] + fn values_are_read_and_blank_ones_are_unset() { + let vars = [ + (CONFIG_DIR, "/private/cc"), + ("HOME", "/home/u"), + ("XDG_CONFIG_HOME", "/x"), + ("APPDATA", "C:\\a"), + (LOCALE, "cs-CZ"), + (VSYNC, " On "), + (WAYLAND, "0"), + (NO_NATIVE_MENU, "yes"), + (SYSTEM_CURSOR, "maybe"), + (FONTALT, "Noto Sans"), + (FONTFALLBACK, "Vazirmatn, msjh.ttc"), + ]; + let read = Env::from_vars(env(&vars)); + assert_eq!( + read, + Env { + config_dir: Some(PathBuf::from("/private/cc")), + locale: Some("cs-CZ".into()), + vsync: Switch::On, + wayland: Switch::Off, + no_native_menu: Switch::On, + system_cursor: Switch::Default, + font_alt: Some("Noto Sans".into()), + font_fallback: Some("Vazirmatn, msjh.ttc".into()), + } + ); + let blank = vars.map(|(k, _)| (k, if k == FONTALT { " " } else { "" })); + let read = Env::from_vars(env(&blank)); + assert_eq!(read.config_dir, None, "an empty variable means no directory, not the working directory"); + assert_eq!((read.locale, read.font_alt, read.font_fallback), (None, None, None)); + assert_eq!([read.vsync, read.wayland, read.no_native_menu, read.system_cursor], [Switch::Default; 4]); + } + + #[test] + fn config_dir_unset_is_the_platform_folder_set_is_that_folder_blank_is_none() { + let platform = [("HOME", "/home/u"), ("XDG_CONFIG_HOME", "/x"), ("APPDATA", "C:\\a")]; + let expected = cadcraft_engine::settings_dir::platform(env(&platform)); + assert!(expected.is_some()); + assert_eq!(Env::from_vars(env(&platform)).config_dir, expected); + let set = [platform.as_slice(), &[(CONFIG_DIR, "/private/cc")]].concat(); + assert_eq!(Env::from_vars(env(&set)).config_dir, Some(PathBuf::from("/private/cc"))); + for blank in ["", " "] { + let vars = [platform.as_slice(), &[(CONFIG_DIR, blank)]].concat(); + assert_eq!(Env::from_vars(env(&vars)).config_dir, None, "{blank:?} means no settings folder, not the platform's"); + } + } +} diff --git a/apps/cadcraft/src/launch_args.rs b/apps/cadcraft/src/launch_args.rs new file mode 100644 index 000000000..c6329907a --- /dev/null +++ b/apps/cadcraft/src/launch_args.rs @@ -0,0 +1,158 @@ +//! The desktop app's command line, as clap types: `cadcraft --help` comes from these doc comments +//! and its Environment section from [`crate::env::VARS`], so the help and the parsers can't disagree. Anything they don't declare is a usage error naming +//! it (exit status 2), so a typo such as `--sampel` doesn't open the window and then fail to open +//! the flag as a file; so is a flag without its value, a repeated flag and a bad port, from the +//! flag or from `CADCRAFT_CONTROL_PORT`. A value never starts with `-`, and a file whose name +//! starts with `-` goes after `--`. + +use std::ffi::OsString; +use std::path::PathBuf; + +use cadcraft_mcp::args::{blank_env_is_unset, name_env_vars}; +use clap::{Command, CommandFactory, FromArgMatches, Parser}; + +/// Opens CADCraft with the given files +#[derive(Parser)] +#[command(name = "cadcraft", version = cadcraft_engine::build_version(), after_help = crate::env::help())] +pub(crate) struct LaunchArgs { + /// Files to open. Put `--` before a name that starts with `-` + pub(crate) files: Vec, + /// Start the localhost JSON-lines control server on this port + // allow_negative_numbers makes `--control -1` a bad value rather than a missing one. + #[arg(long, value_name = "PORT", env = "CADCRAFT_CONTROL_PORT", value_parser = control_port, allow_negative_numbers = true)] + pub(crate) control: Option, + /// Open with the sample drawing + #[arg(long)] + pub(crate) sample: bool, +} + +/// The command line. An empty or blank variable counts as unset. +pub(crate) fn command() -> Command { + LaunchArgs::command().mut_args(|a| blank_env_is_unset(a, |k| std::env::var_os(k))) +} + +/// Parse the launch arguments (without the binary name) with `cmd`, from [`command`]. Old macOS +/// passes a process serial number (`-psn_…`) when launched from Finder: it is dropped first, unless +/// it comes after `--`. A bad value from a variable is a usage error naming the variable. +pub(crate) fn parse(mut cmd: Command, args: impl IntoIterator) -> Result { + let mut options = true; + let args: Vec = args + .into_iter() + .filter(|a| { + options &= a != "--"; + !(options && a.to_str().is_some_and(|s| s.starts_with("-psn_"))) + }) + .collect(); + let argv = std::iter::once(OsString::from("cadcraft")).chain(args.iter().cloned()); + let matches = cmd.try_get_matches_from_mut(argv).map_err(|e| name_env_vars(e, &cmd, &args))?; + LaunchArgs::from_arg_matches(&matches) +} + +/// A control port, for clap's `value_parser`: `--control` and `CADCRAFT_CONTROL_PORT`, which may +/// carry spaces. +fn control_port(s: &str) -> Result { + s.trim().parse().map_err(|_| NotAPort) +} + +/// A [`control_port`] value that isn't a port. +#[derive(Debug, PartialEq, Eq, thiserror::Error)] +#[error("expected a port, 0-65535")] +struct NotAPort; + +#[cfg(test)] +mod tests { + use super::*; + use clap::error::ErrorKind; + + /// Parse without the variables, so one exported where the tests run can't change them. + fn parse_args(args: &[&str]) -> Result { + parse(command().mut_args(|a| a.env(None::<&str>)), args.iter().map(OsString::from)) + } + + fn usage_error(args: &[&str]) -> String { + let Err(e) = parse_args(args) else { panic!("{args:?} parsed") }; + assert_eq!(e.exit_code(), 2, "{args:?}: {e}"); + e.to_string() + } + + #[test] + fn values_are_parsed() { + let parsed = parse_args(&["--control", " 50494 ", "--sample", "a.dxf", "b.dwg"]).unwrap(); + assert_eq!((parsed.control, parsed.sample), (Some(50494), true)); + assert_eq!(parsed.files, [PathBuf::from("a.dxf"), PathBuf::from("b.dwg")]); + let parsed = parse_args(&[]).unwrap(); + assert_eq!((parsed.control, parsed.sample, parsed.files.len()), (None, false, 0)); + } + + #[test] + fn control_port_rejects_unparseable_values_naming_them() { + for bad in ["78787", "-1", "abc", "99999999999999999999"] { + assert!(usage_error(&["--control", bad]).contains(&format!("invalid value '{bad}' for '--control '")), "{bad}"); + } + assert!(usage_error(&["--control="]).contains("invalid value '' for '--control '")); + } + + #[test] + fn usage_errors_exit_2() { + assert!(usage_error(&["--sampel"]).contains("unexpected argument '--sampel'")); + assert!(usage_error(&["--control"]).contains("a value is required for '--control '")); + // A following flag is never taken as the value. + assert!(usage_error(&["--control", "--sample"]).contains("a value is required for '--control '")); + assert!(usage_error(&["--sample", "--sample"]).contains("cannot be used multiple times")); + assert!(usage_error(&["--control", "1", "--control", "2"]).contains("cannot be used multiple times")); + } + + #[test] + fn version_stops_parsing() { + let e = parse_args(&["-V", "--control"]).err().unwrap(); + assert_eq!((e.kind(), e.exit_code()), (ErrorKind::DisplayVersion, 0)); + assert_eq!(e.to_string(), format!("{}\n", crate::version_string())); + let e = parse_args(&["--version", "--bogus"]).err().unwrap(); + assert_eq!(e.kind(), ErrorKind::DisplayVersion); + } + + #[test] + fn help_stops_parsing_and_double_dash_ends_options() { + let e = parse_args(&["-h", "--sampel", "--control"]).err().unwrap(); + assert_eq!((e.kind(), e.exit_code()), (ErrorKind::DisplayHelp, 0)); + let help = parse_args(&["--help"]).err().unwrap().to_string(); + assert!(help.contains("--control ") && help.contains("CADCRAFT_CONFIG_DIR"), "{help}"); + + assert!(usage_error(&["--sampel", "--", "--help"]).contains("unexpected argument '--sampel'")); + let parsed = parse_args(&["a.dxf", "--", "--help", "-x"]).unwrap(); + assert_eq!(parsed.files, ["a.dxf", "--help", "-x"].map(PathBuf::from)); + } + + #[test] + fn a_finder_process_serial_number_is_dropped() { + let parsed = parse_args(&["-psn_0_12345", "a.dxf"]).unwrap(); + assert_eq!(parsed.files, [PathBuf::from("a.dxf")]); + let parsed = parse_args(&["--", "-psn_x.dxf"]).unwrap(); + assert_eq!(parsed.files, [PathBuf::from("-psn_x.dxf")]); + } + + /// A name that isn't valid Unicode is kept as given. + #[cfg(unix)] + #[test] + fn non_unicode_file_names_are_kept() { + use std::os::unix::ffi::OsStringExt as _; + let latin1 = OsString::from_vec(b"caf\xe9.dxf".to_vec()); + let parsed = parse(command().mut_args(|a| a.env(None::<&str>)), [latin1.clone(), OsString::from("b.dxf")]).unwrap(); + assert_eq!(parsed.files, [PathBuf::from(&latin1), PathBuf::from("b.dxf")]); + } + + /// `--control` falls back to `PATH` here instead of `CADCRAFT_CONTROL_PORT`: `PATH` is set + /// wherever the tests run and is never a port, and tests can't set a variable (`set_var` is + /// unsafe). + #[test] + fn the_flag_wins_over_its_variable_and_a_bad_value_names_the_variable() { + let Some(path) = std::env::var_os("PATH").filter(|p| !p.is_empty()) else { return }; + let path_fallback = || command().mut_args(|a| a.env(None::<&str>)).mut_arg("control", |a| a.env("PATH")); + let e = parse(path_fallback(), []).err().unwrap(); + assert_eq!(e.exit_code(), 2); + let text = e.to_string(); + assert!(text.contains(&format!("invalid value '{}' for 'PATH'", path.to_string_lossy())), "{text}"); + assert!(!text.contains("--control '"), "{text}"); + assert_eq!(parse(path_fallback(), ["--control", "7"].map(OsString::from)).unwrap().control, Some(7)); + } +} diff --git a/apps/cadcraft/src/logging.rs b/apps/cadcraft/src/logging.rs index 4113de54f..724d09c1a 100644 --- a/apps/cadcraft/src/logging.rs +++ b/apps/cadcraft/src/logging.rs @@ -3,7 +3,7 @@ //! Without a logger every `log::warn!`/`log::error!`/`log::info!` in the workspace (a broken app //! icon, the GPU canvas set-up, the control server) vanished. A launch from a desktop menu has no //! terminal, so the file is what a bug report can attach: `/logs/cadcraft.log` -//! (`CADCRAFT_CONFIG_DIR`, or the platform settings directory; see `config_dir` in `main.rs`). +//! (`CADCRAFT_CONFIG_DIR`, or the platform settings directory; empty means none; see `env.rs`). //! Each start moves the previous log to `cadcraft.1.log` (and that one to `.2`), so the log of a //! run that crashed survives the next launch. //! diff --git a/apps/cadcraft/src/main.rs b/apps/cadcraft/src/main.rs index 1007fc0c1..19546d6ce 100644 --- a/apps/cadcraft/src/main.rs +++ b/apps/cadcraft/src/main.rs @@ -1,6 +1,6 @@ //! CADCraft desktop app. //! -//! Usage: `cadcraft [--control ] [--sample] [files…]` +//! Usage: `cadcraft [--control ] [--sample] [files…]` (`cadcraft --help` lists the rest; see [`launch_args`]) //! //! `--control ` (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,…}`. @@ -10,14 +10,16 @@ //! present mode (`CADCRAFT_VSYNC=0` selects that elsewhere); see `cadcraft_ui_egui::gpu::surface_config`. //! //! `log` records go to standard error and `/logs/cadcraft.log` (`RUST_LOG` sets the -//! levels); see [`logging`] and [`config_dir`]. +//! levels); see [`logging`]. The `CADCRAFT_*` variables are read once, at startup; see [`env`]. #![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")] #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] mod control_server; mod desktop_theme; +mod env; #[cfg(any(target_os = "windows", test))] mod graphics; +mod launch_args; mod logging; #[cfg(target_os = "macos")] mod native_menu; @@ -26,6 +28,7 @@ mod system_animations; mod workspace; use cadcraft_engine::Session; +use cadcraft_ui_egui::switch::Switch; use cadcraft_ui_egui::{CadApp, Services, i18n}; struct App { @@ -39,6 +42,9 @@ struct App { workspace_error: Option, #[cfg(target_os = "macos")] native_menu: Option, + /// `CADCRAFT_NO_NATIVE_MENU`: the menus stay inside the window. + #[cfg(target_os = "macos")] + menus_in_window: bool, /// The `movable` flag last set on the main window. #[cfg(target_os = "macos")] movable: Option, @@ -88,7 +94,7 @@ impl eframe::App for App { if ctx.current_pass_index() == 0 { #[cfg(target_os = "macos")] { - if self.native_menu.is_none() && std::env::var_os("CADCRAFT_NO_NATIVE_MENU").is_none() { + if self.native_menu.is_none() && !self.menus_in_window { self.native_menu = Some(native_menu::NativeMenu::install(&mut self.cad, ctx)); } if let Some(m) = &mut self.native_menu { @@ -188,30 +194,6 @@ fn filters_for_save(name: &str) -> [(&'static str, &'static str); 6] { filters } -/// The per-user settings directory (it holds `logs/` and `autosave/`): `CADCRAFT_CONFIG_DIR` if set, else -/// `$XDG_CONFIG_HOME/cadcraft` or `~/.config/cadcraft` on Linux and the BSDs, -/// `~/Library/Application Support/CADCraft` on macOS, `%APPDATA%\CADCraft` on Windows. -fn config_dir() -> Option { - config_dir_from(|k| std::env::var_os(k)) -} - -/// [`config_dir`] with the environment passed in (`var` looks a variable up). An empty variable -/// counts as unset, so a blank value never means the working directory. -fn config_dir_from(var: impl Fn(&str) -> Option) -> Option { - let set = |k: &str| var(k).filter(|v| !v.is_empty()).map(std::path::PathBuf::from); - if let Some(dir) = set("CADCRAFT_CONFIG_DIR") { - return Some(dir); - } - if cfg!(target_os = "macos") { - set("HOME").map(|h| h.join("Library/Application Support/CADCraft")) - } else if cfg!(windows) { - set("APPDATA").map(|a| a.join("CADCraft")) - } else { - // The XDG spec ignores a relative XDG_CONFIG_HOME. - set("XDG_CONFIG_HOME").filter(|p| p.is_absolute()).or_else(|| set("HOME").map(|h| h.join(".config"))).map(|c| c.join("cadcraft")) - } -} - const APP_ID: &str = "ai.storyteller.cadcraft"; /// Stencil bits of the window's render pass (see `NativeOptions::stencil_buffer`). @@ -227,32 +209,7 @@ fn app_icon() -> Option { } fn version_string() -> String { - let sha = option_env!("CADCRAFT_BUILD_SHA").unwrap_or("dev"); - format!("cadcraft {} ({sha})", env!("CARGO_PKG_VERSION")) -} - -/// The control port from `--control ` or `CADCRAFT_CONTROL_PORT` (`source`); a value that is -/// not a port is logged and ignored instead of silently starting no control channel. -fn control_port_from(source: &str, value: Option) -> Option { - let value = value?; - let port = value.trim().parse().ok(); - if port.is_none() { - log::warn!("{source}: {value:?} is not a port number; the control channel is off"); - } - port -} - -/// `--control` followed by `value`: a bare `--control` (last argument) keeps the port already -/// read from `CADCRAFT_CONTROL_PORT` (`current`) instead of turning the control channel off. -fn control_flag(current: Option, value: Option) -> Option { - if value.is_some() { - return control_port_from("--control", value); - } - match current { - Some(port) => log::warn!("--control: no port given; using CADCRAFT_CONTROL_PORT ({port})"), - None => log::warn!("--control: no port given; the control channel is off"), - } - current + format!("cadcraft {}", cadcraft_engine::build_version()) } /// Parse CLI options (`--control`, `--sample`, files, `--version`), install logging and I/O hooks, build the services and app, and run eframe. @@ -268,37 +225,33 @@ fn main() -> eframe::Result { } return Ok(()); } - // lossy, so a value that is not Unicode is reported like any other bad port instead of ignored - let mut control_port = - control_port_from("CADCRAFT_CONTROL_PORT", std::env::var_os("CADCRAFT_CONTROL_PORT").map(|p| p.to_string_lossy().into_owned())); - let mut files = Vec::new(); - let mut sample = false; - let mut args = std::env::args().skip(1); - while let Some(a) = args.next() { - match a.as_str() { - "--control" => control_port = control_flag(control_port, args.next()), - "--sample" => sample = true, - "--version" | "-V" => { - println!("{}", version_string()); - return Ok(()); - } - _ => files.push(a), - } - } + // `--help` and `--version` print to standard output and exit 0. A usage error (an unknown or + // repeated flag, a missing or bad value, a bad CADCRAFT_CONTROL_PORT) names the argument on + // standard error and exits 2 before the window opens. + let launch = launch_args::parse(launch_args::command(), std::env::args_os().skip(1)).unwrap_or_else(|e| e.exit()); + let vars = env::Env::read(); + let (control_port, sample, files) = (launch.control, launch.sample, launch.files); // The log file lives under the settings directory; opened after the arguments, so `--version` // leaves no file behind. Records logged until now are written to it first. if let Some(logger) = logger { - match config_dir().map(|d| logger.attach_dir(&d.join(logging::LOG_DIR))) { + match vars.config_dir.as_ref().map(|d| logger.attach_dir(&d.join(logging::LOG_DIR))) { Some(Ok(path)) => log::info!("{} ({} {}), log file {}", version_string(), std::env::consts::OS, std::env::consts::ARCH, path.display()), Some(Err(e)) => log::warn!("no log file: {e}"), None => { logger.stderr_only(); - log::warn!("no log file: no settings directory (set CADCRAFT_CONFIG_DIR)"); + log::warn!("no log file: no settings directory (an empty CADCRAFT_CONFIG_DIR turns it off)"); } } } install_io(); - let surface = cadcraft_ui_egui::gpu::surface_config(std::env::var("CADCRAFT_VSYNC").ok().as_deref(), cfg!(all(unix, not(target_os = "macos")))); + cadcraft_engine::settings_dir::set(vars.config_dir.clone()); + if let Some(name) = &vars.font_alt { + cadcraft_engine::fonts::ttf::set_font_alt(name); + } + if let Some(list) = &vars.font_fallback { + cadcraft_engine::fonts::ttf::set_fallback_fonts(list); + } + let surface = cadcraft_ui_egui::gpu::surface_config(vars.vsync, cfg!(all(unix, not(target_os = "macos")))); let mut options = eframe::NativeOptions { // The crosshair is drawn by the app: present without a queue on Linux/BSD, where X11 // swapchains hold two frames back under vsync (`CADCRAFT_VSYNC=1` restores vsync). @@ -341,7 +294,7 @@ fn main() -> eframe::Result { // manager showed a "no" cursor. Run through XWayland when it's there; CADCRAFT_WAYLAND=1 // keeps the native Wayland backend. #[cfg(all(unix, not(target_os = "macos")))] - if std::env::var_os("DISPLAY").is_some() && std::env::var_os("CADCRAFT_WAYLAND").is_none() { + if std::env::var_os("DISPLAY").is_some() && vars.wayland != Switch::On { options.event_loop_builder = Some(Box::new(|b| { use winit::platform::x11::EventLoopBuilderExtX11; b.with_x11(); @@ -352,15 +305,16 @@ fn main() -> eframe::Result { options, Box::new(move |cc| { let mut app = CadApp::new(Session::empty(), services()); - let (workspace, restored, workspace_error) = workspace::Workspace::load(); + let (workspace, restored, workspace_error) = workspace::Workspace::load(vars.config_dir.as_deref()); if let Some(ui) = restored { app.ui = ui; } + app.set_system_cursor_default(vars.system_cursor == Switch::On); if let Some(error) = &workspace_error { eprintln!("CADCraft workspace: {error}"); app.set_status(error); } - app.system_languages = std::env::var("CADCRAFT_LOCALE").map(|s| vec![s]).unwrap_or_else(|_| sys_locale::get_locales().collect()); + app.system_languages = vars.locale.map(|s| vec![s]).unwrap_or_else(|| sys_locale::get_locales().collect()); // The user profile (Options): drafting settings, selection sizes, drawing-area colours. if let Some(profile) = cc.storage.and_then(|s| s.get_string(cadcraft_ui_egui::options::PROFILE_KEY)) { app.load_profile(&profile); @@ -372,7 +326,7 @@ fn main() -> eframe::Result { cadcraft_ui_egui::autosave::load_prefs(&prefs); } // Autosave files (SAVEFILEPATH) default to `/autosave`. - if let Some(dir) = config_dir() { + if let Some(dir) = &vars.config_dir { app.enable_autosave(&dir.join("autosave")); app.enable_update_check(); // Startup LISP (acad.lsp, acaddoc.lsp) is read from `/support`; the @@ -419,6 +373,8 @@ fn main() -> eframe::Result { #[cfg(target_os = "macos")] native_menu: None, #[cfg(target_os = "macos")] + menus_in_window: vars.no_native_menu == Switch::On, + #[cfg(target_os = "macos")] movable: None, })) }), @@ -427,13 +383,7 @@ fn main() -> eframe::Result { #[cfg(test)] mod tests { - use super::{config_dir_from, control_flag, control_port_from, filters_for_save, follow_desktop}; - use std::ffi::OsString; - use std::path::PathBuf; - - fn env<'a>(vars: &'a [(&'a str, &'a str)]) -> impl Fn(&str) -> Option + 'a { - move |k| vars.iter().find(|(n, _)| *n == k).map(|(_, v)| OsString::from(v)) - } + use super::{filters_for_save, follow_desktop}; #[test] fn save_dialog_offers_dwg_with_the_drawing_format_first() { @@ -451,59 +401,6 @@ mod tests { } } - #[test] - fn control_port_values_that_are_not_ports_are_ignored() { - assert_eq!(control_port_from("--control", Some("7979".into())), Some(7979)); - assert_eq!(control_port_from("--control", Some(" 7979 ".into())), Some(7979)); - assert_eq!(control_port_from("--control", None), None); - for bad in ["", "abc", "-1", "65536", "99999999999999999999", "\u{0}"] { - assert_eq!(control_port_from("--control", Some(bad.into())), None, "{bad:?}"); - } - } - - #[test] - fn control_without_a_port_keeps_the_environment_port() { - // `CADCRAFT_CONTROL_PORT=47321 cadcraft --control` (#844) - assert_eq!(control_flag(Some(47321), None), Some(47321)); - assert_eq!(control_flag(None, None), None); - // A port given on the command line still wins over the variable. - assert_eq!(control_flag(Some(47321), Some("7979".into())), Some(7979)); - assert_eq!(control_flag(Some(47321), Some("abc".into())), None); - } - - #[test] - fn the_override_variable_wins_and_empty_values_are_unset() { - let vars = [("CADCRAFT_CONFIG_DIR", "/tmp/cc"), ("HOME", "/home/u"), ("XDG_CONFIG_HOME", "/x"), ("APPDATA", "C:\\a")]; - assert_eq!(config_dir_from(env(&vars)), Some(PathBuf::from("/tmp/cc"))); - let empty = [("CADCRAFT_CONFIG_DIR", ""), ("HOME", ""), ("XDG_CONFIG_HOME", ""), ("APPDATA", "")]; - assert_eq!(config_dir_from(env(&empty)), None, "no usable variable means no directory, not the working directory"); - assert_eq!(config_dir_from(env(&[])), None); - } - - #[cfg(all(unix, not(target_os = "macos")))] - #[test] - fn linux_and_bsd_follow_xdg_config_home() { - assert_eq!(config_dir_from(env(&[("XDG_CONFIG_HOME", "/x"), ("HOME", "/home/u")])), Some(PathBuf::from("/x/cadcraft"))); - assert_eq!(config_dir_from(env(&[("HOME", "/home/u")])), Some(PathBuf::from("/home/u/.config/cadcraft"))); - // The XDG spec says a relative XDG_CONFIG_HOME is ignored. - assert_eq!(config_dir_from(env(&[("XDG_CONFIG_HOME", "rel"), ("HOME", "/home/u")])), Some(PathBuf::from("/home/u/.config/cadcraft"))); - } - - #[cfg(target_os = "macos")] - #[test] - fn macos_uses_application_support() { - assert_eq!(config_dir_from(env(&[("HOME", "/Users/u")])), Some(PathBuf::from("/Users/u/Library/Application Support/CADCraft"))); - } - - #[cfg(windows)] - #[test] - fn windows_uses_appdata() { - assert_eq!( - config_dir_from(env(&[("APPDATA", "C:\\Users\\u\\AppData\\Roaming")])), - Some(PathBuf::from("C:\\Users\\u\\AppData\\Roaming").join("CADCraft")) - ); - } - /// 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] diff --git a/apps/cadcraft/src/workspace.rs b/apps/cadcraft/src/workspace.rs index b8e541ed3..b75c9bc70 100644 --- a/apps/cadcraft/src/workspace.rs +++ b/apps/cadcraft/src/workspace.rs @@ -1,6 +1,5 @@ //! Native workspace preferences. Drawing data and transient dialogs never enter this file. -use std::ffi::OsString; use std::fs::{self, File, OpenOptions}; use std::io::{Read, Write}; use std::path::{Path, PathBuf}; @@ -24,18 +23,6 @@ pub struct Workspace { last_write: Option, } -fn config_dir_from(platform: &str, get: impl Fn(&str) -> Option) -> Option { - if let Some(root) = get("CADCRAFT_CONFIG_DIR") { - return (!root.is_empty()).then(|| PathBuf::from(root)); - } - let nonempty = |key| get(key).filter(|value| !value.is_empty()).map(PathBuf::from); - match platform { - "macos" => nonempty("HOME").map(|home| home.join("Library/Application Support/CADCraft")), - "windows" => nonempty("APPDATA").map(|root| root.join("CADCraft")), - _ => nonempty("XDG_CONFIG_HOME").map(|root| root.join("cadcraft")).or_else(|| nonempty("HOME").map(|home| home.join(".config/cadcraft"))), - } -} - fn snapshot(ui: &UiState) -> Result { cadcraft_ui_egui::docking::validate(&ui.docking)?; if !matches!(ui.toolset_tab.as_str(), "Drafting" | "Modeling") { @@ -139,8 +126,9 @@ fn write(path: &Path, workspace: &Value) -> Result<(), String> { } impl Workspace { - pub fn load() -> (Self, Option, Option) { - Self::at(config_dir_from(std::env::consts::OS, |key| std::env::var_os(key)).map(|root| root.join("workspace.json"))) + /// The workspace file in the settings directory `config_dir`; without one nothing is kept. + pub fn load(config_dir: Option<&Path>) -> (Self, Option, Option) { + Self::at(config_dir.map(|root| root.join("workspace.json"))) } fn at(path: Option) -> (Self, Option, Option) { @@ -195,6 +183,7 @@ impl Workspace { #[cfg(test)] mod tests { use super::*; + use std::ffi::OsString; fn temp_dir() -> PathBuf { let sequence = TEMP_SEQUENCE.fetch_add(1, Ordering::Relaxed); @@ -205,20 +194,18 @@ mod tests { #[test] fn profile_override_isolated_or_explicitly_disabled() { - let get = |key: &str| match key { - "CADCRAFT_CONFIG_DIR" => Some(OsString::from("/private/test-state")), - "HOME" | "APPDATA" | "XDG_CONFIG_HOME" => Some(OsString::from("/unrelated-user-profile")), - _ => None, + let vars = |config: Option<&'static str>| { + move |key: &str| match key { + "CADCRAFT_CONFIG_DIR" => config.map(OsString::from), + "HOME" | "APPDATA" | "XDG_CONFIG_HOME" => Some(OsString::from("/unrelated-user-profile")), + _ => None, + } }; - for platform in ["macos", "windows", "linux", "freebsd"] { - assert_eq!(config_dir_from(platform, get), Some(PathBuf::from("/private/test-state"))); - assert_eq!(config_dir_from(platform, |key| if key == "CADCRAFT_CONFIG_DIR" { Some(OsString::new()) } else { get(key) }), None); - } - assert_eq!( - config_dir_from("linux", |key| (key == "XDG_CONFIG_HOME").then(|| OsString::from("/config"))), - Some(PathBuf::from("/config/cadcraft")) - ); - assert_eq!(config_dir_from("macos", |_| None), None); + let dir = |config| crate::env::Env::from_vars(vars(config)).config_dir; + assert_eq!(dir(Some("/private/test-state")), Some(PathBuf::from("/private/test-state"))); + assert_eq!(dir(Some("")), None); + let (_, restored, error) = Workspace::load(dir(Some("")).as_deref()); + assert!(restored.is_none() && error.is_none(), "no settings folder, no workspace file"); } #[test] diff --git a/clippy.toml b/clippy.toml index 287e14edc..3522a15b6 100644 --- a/clippy.toml +++ b/clippy.toml @@ -5,3 +5,4 @@ allow-indexing-slicing-in-tests = true disallowed-types = [ { path = "egui::ComboBox", reason = "use craft_ui::ComboBox: egui's combo box menu can't grow back while open (egui#5225)" }, ] +cognitive-complexity-threshold = 30 diff --git a/crates/constraints/src/residual.rs b/crates/constraints/src/residual.rs index be5723fec..05794b720 100644 --- a/crates/constraints/src/residual.rs +++ b/crates/constraints/src/residual.rs @@ -3,7 +3,7 @@ use cadcraft_doc::{Constraint, ConstraintKind, DistAxis, GeomRef}; use cadcraft_geom::Vec2; -use crate::curves::circle_at; +use crate::curves::{Ell, circle_at}; use crate::model::Model; /// Contact parameter samples per curve when guessing where two curves touch. @@ -205,42 +205,7 @@ impl Built { }; b.rows = 1; } - K::Tangent | K::Smooth => { - if n != 2 { - return need("two objects"); - } - if c.refs.iter().any(|r| m.is_spline(r)) { - return Self::spline_form(b, m, x); - } - b.rows = 1; - if let (Some((a, bb)), Some((cc, _))) = (ln(0), ci(1)) { - b.form = Form::LC { swap: false }; - b.sign = sgn(dir_n(a, bb).cross(cc - a)); - } else if let (Some((a, bb)), Some((cc, _))) = (ln(1), ci(0)) { - b.form = Form::LC { swap: true }; - b.sign = sgn(dir_n(a, bb).cross(cc - a)); - } else if let (Some((c1, r1)), Some((c2, r2))) = (ci(0), ci(1)) { - b.form = Form::CC; - // sign > 0: external tangency; < 0: internal. - let d = c1.dist(c2); - b.sign = if d >= r1.abs().max(r2.abs()) { 1.0 } else { -1.0 }; - b.target = sgn(r1 - r2); - } else if let (Some((a, bb)), Some(e)) = (ln(0), el(1)) { - b.form = Form::LE { swap: false }; - b.sign = sgn(dir_n(a, bb).cross(e.c - a)); - } else if let (Some((a, bb)), Some(e)) = (ln(1), el(0)) { - b.form = Form::LE { swap: true }; - b.sign = sgn(dir_n(a, bb).cross(e.c - a)); - } else if (ci(0).is_some() || el(0).is_some()) && (ci(1).is_some() || el(1).is_some()) { - b.form = Form::Contact; - b.rows = 3; - b.aux_init = b.contact_guess(m, x).ok_or_else(|| format!("{} could not find where the curves touch", c.kind.name()))?; - } else if ln(0).is_some() && ln(1).is_some() && c.kind == K::Smooth { - b.form = Form::LL; - } else { - return need("a line and a circle/arc/ellipse, two curves, or a spline end and a curve"); - } - } + K::Tangent | K::Smooth => return Self::tangent_form(b, c, m, x), K::Symmetric => { if n != 3 || ln(2).is_none() { return need("two objects and a symmetry line"); @@ -347,154 +312,8 @@ impl Built { out.resize(start + self.rows, 0.0); } - fn eval_inner(&self, m: &Model, x: &[f64], out: &mut Vec) -> Option<()> { - use ConstraintKind as K; - let r = |i: usize| self.refs.get(i); - let pt = |i: usize| m.point(x, r(i)?); - let ln = |i: usize| m.line(x, r(i)?); - let ci = |i: usize| m.circle(x, r(i)?); - let el = |i: usize| m.ellipse(x, r(i)?); - match (self.kind, self.form) { - (_, Form::Lock) => {} - (_, Form::PE { swap }) => { - let (p, e) = if swap { (pt(1)?, el(0)?) } else { (pt(0)?, el(1)?) }; - out.push(e.on(p)); - } - (_, Form::LE { swap }) => { - let ((a, b), e) = if swap { (ln(1)?, el(0)?) } else { (ln(0)?, el(1)?) }; - let d = dir_n(a, b); - out.push(self.sign * d.cross(e.c - a) - e.support(d.perp())); - } - (_, Form::Contact) => { - let (p0, d0) = self.curve_at(m, x, 0, *x.get(self.aux)?)?; - let (p1, d1) = self.curve_at(m, x, 1, *x.get(self.aux + 1)?)?; - out.extend([p0.x - p1.x, p0.y - p1.y, d0.normalized().cross(d1.normalized())]); - } - (_, Form::EndOn { spline, at_end }) => { - let f = m.end_frame(x, r(spline)?, at_end)?; - let o = 1 - spline.min(1); - if let Some((a, b)) = ln(o) { - let d = dir_n(a, b); - out.extend([d.cross(f.p - a), f.t.cross(d)]); - } else if let Some((c, rad)) = ci(o) { - out.extend([f.p.dist(c) - rad, f.t.dot(dir_n(c, f.p))]); - } else { - let e = el(o)?; - out.extend([e.on(f.p), f.t.dot(e.normal(f.p))]); - } - } - (_, Form::Join { a_end, b_end, g2 }) => { - // Orient both so the first curve runs into the joint and the second out of it. - let fa = m.end_frame(x, r(0)?, a_end)?; - let fb = m.end_frame(x, r(1)?, b_end)?; - let fa = if a_end { fa } else { fa.reversed() }; - let fb = if b_end { fb.reversed() } else { fb }; - out.extend([fa.p.x - fb.p.x, fa.p.y - fb.p.y, fa.t.cross(fb.t)]); - if g2 { - out.push(fa.k - fb.k); - } - } - (_, Form::Anchor(a)) => { - let p = pt(0)?; - out.extend([p.x - a.x, p.y - a.y]); - } - (K::Coincident, Form::PP) => { - let (p, q) = (pt(0)?, pt(1)?); - out.extend([p.x - q.x, p.y - q.y]); - } - (K::Coincident, Form::PL { swap }) => { - let (p, (a, b)) = if swap { (pt(1)?, ln(0)?) } else { (pt(0)?, ln(1)?) }; - out.push(dir_n(a, b).cross(p - a)); - } - (K::Coincident, Form::PC { swap }) => { - let (p, (c, rad)) = if swap { (pt(1)?, ci(0)?) } else { (pt(0)?, ci(1)?) }; - out.push(p.dist(c) - rad); - } - (K::Horizontal | K::Vertical, f) => { - let (a, b) = if f == Form::L1 { ln(0).or_else(|| el(0).map(|e| (e.c - e.mj, e.c + e.mj)))? } else { (pt(0)?, pt(1)?) }; - out.push(if self.kind == K::Horizontal { a.y - b.y } else { a.x - b.x }); - } - (K::Parallel | K::Smooth, Form::LL) => { - let ((a1, b1), (a2, b2)) = (ln(0)?, ln(1)?); - out.push(dir_n(a1, b1).cross(dir_n(a2, b2))); - } - (K::Perpendicular, _) => { - let ((a1, b1), (a2, b2)) = (ln(0)?, ln(1)?); - out.push(dir_n(a1, b1).dot(dir_n(a2, b2))); - } - (K::Collinear, _) => { - let ((a1, b1), (a2, b2)) = (ln(0)?, ln(1)?); - let d = dir_n(a1, b1); - out.extend([d.cross(a2 - a1), d.cross(b2 - a1)]); - } - (K::Concentric, _) => { - let center = |i: usize| ci(i).map(|(c, _)| c).or_else(|| el(i).map(|e| e.c)).or_else(|| pt(i)); - let (p, q) = (center(0)?, center(1)?); - out.extend([p.x - q.x, p.y - q.y]); - } - (K::Equal, Form::LL) => { - let ((a1, b1), (a2, b2)) = (ln(0)?, ln(1)?); - out.push(a1.dist(b1) - a2.dist(b2)); - } - (K::Equal, _) => { - let ((_, r1), (_, r2)) = (ci(0)?, ci(1)?); - out.push(r1 - r2); - } - (K::Tangent | K::Smooth, Form::LC { swap }) => { - let ((a, b), (c, rad)) = if swap { (ln(1)?, ci(0)?) } else { (ln(0)?, ci(1)?) }; - out.push(self.sign * dir_n(a, b).cross(c - a) - rad); - } - (K::Tangent | K::Smooth, _) => { - let ((c1, r1), (c2, r2)) = (ci(0)?, ci(1)?); - let d = c1.dist(c2); - out.push(if self.sign > 0.0 { d - (r1 + r2) } else { d - self.target * (r1 - r2) }); - } - (K::Symmetric, Form::PP) => { - let (p, q, (a, b)) = (pt(0)?, pt(1)?, ln(2)?); - let d = dir_n(a, b); - out.extend([d.cross(p.mid(q) - a), d.dot(q - p)]); - } - (K::Symmetric, Form::SymLines { crossed }) => { - let ((a1, b1), (a2, b2), (a, b)) = (ln(0)?, ln(1)?, ln(2)?); - let (a2, b2) = if crossed { (b2, a2) } else { (a2, b2) }; - let d = dir_n(a, b); - out.extend([d.cross(a1.mid(a2) - a), d.dot(a2 - a1), d.cross(b1.mid(b2) - a), d.dot(b2 - b1)]); - } - (K::Symmetric, _) => { - let ((p, r1), (q, r2), (a, b)) = (ci(0)?, ci(1)?, ln(2)?); - let d = dir_n(a, b); - out.extend([d.cross(p.mid(q) - a), d.dot(q - p), r1 - r2]); - } - (K::Distance(axis), f) => { - let v = match (axis, f) { - (_, Form::PL { swap }) => { - let (p, (a, b)) = if swap { (pt(1)?, ln(0)?) } else { (pt(0)?, ln(1)?) }; - dir_n(a, b).cross(p - a) - } - _ => { - let (a, b) = if f == Form::L1 { ln(0)? } else { (pt(0)?, pt(1)?) }; - match axis { - DistAxis::Aligned => a.dist(b), - DistAxis::Horizontal => b.x - a.x, - DistAxis::Vertical => b.y - a.y, - } - } - }; - out.push(self.sign * v - self.target); - } - (K::Angular, Form::ArcSweep) => { - out.push(m.arc_sweep(x, r(0)?)? - self.target); - } - (K::Angular, Form::Rays { rev }) => { - let ((a1, b1), (a2, b2)) = (ln(0)?, ln(1)?); - let (d1, d2) = (ray(a1, b1, rev[0]), ray(a2, b2, rev[1])); - out.push(wrap(d1.cross(d2).atan2(d1.dot(d2)) - self.sign * self.target)); - } - (K::Radius, _) => out.push(ci(0)?.1 - self.target), - (K::Diameter, _) => out.push(2.0 * ci(0)?.1 - self.target), - _ => {} - } - Some(()) + fn eval_inner(&self, model: &Model, values: &[f64], out: &mut Vec) -> Option<()> { + ResidualEval { built: self, model, values, out }.evaluate() } /// Point and derivative of curve reference `i` (circle, arc or ellipse) at parameter `t`. @@ -527,6 +346,54 @@ impl Built { /// Tangent or Smooth with a spline: the spline end and the other curve's nearest end are /// joined (Smooth: G2; Tangent between splines: G1), or the spline's end touches a line, /// circle, arc or ellipse tangentially. A `start`/`end` reference picks the end. + fn tangent_form(mut built: Built, constraint: &Constraint, model: &Model, values: &[f64]) -> Result { + use ConstraintKind as K; + + let need = |what: &str| Err(format!("{} needs {what}", constraint.kind.name())); + if built.refs.len() != 2 { + return need("two objects"); + } + if constraint.refs.iter().any(|reference| model.is_spline(reference)) { + return Self::spline_form(built, model, values); + } + + let line = |index| r_at(constraint, index).and_then(|reference| model.line(values, reference)); + let circle = |index| r_at(constraint, index).and_then(|reference| model.circle(values, reference)); + let ellipse = |index| r_at(constraint, index).and_then(|reference| model.ellipse(values, reference)); + built.rows = 1; + + if let (Some((start, end)), Some((center, _))) = (line(0), circle(1)) { + built.form = Form::LC { swap: false }; + built.sign = sgn(dir_n(start, end).cross(center - start)); + } else if let (Some((start, end)), Some((center, _))) = (line(1), circle(0)) { + built.form = Form::LC { swap: true }; + built.sign = sgn(dir_n(start, end).cross(center - start)); + } else if let (Some((first_center, first_radius)), Some((second_center, second_radius))) = (circle(0), circle(1)) { + built.form = Form::CC; + // sign > 0: external tangency; < 0: internal. + let distance = first_center.dist(second_center); + built.sign = if distance >= first_radius.abs().max(second_radius.abs()) { 1.0 } else { -1.0 }; + built.target = sgn(first_radius - second_radius); + } else if let (Some((start, end)), Some(ellipse)) = (line(0), ellipse(1)) { + built.form = Form::LE { swap: false }; + built.sign = sgn(dir_n(start, end).cross(ellipse.c - start)); + } else if let (Some((start, end)), Some(ellipse)) = (line(1), ellipse(0)) { + built.form = Form::LE { swap: true }; + built.sign = sgn(dir_n(start, end).cross(ellipse.c - start)); + } else if (circle(0).is_some() || ellipse(0).is_some()) && (circle(1).is_some() || ellipse(1).is_some()) { + built.form = Form::Contact; + built.rows = 3; + built.aux_init = + built.contact_guess(model, values).ok_or_else(|| format!("{} could not find where the curves touch", constraint.kind.name()))?; + } else if line(0).is_some() && line(1).is_some() && constraint.kind == K::Smooth { + built.form = Form::LL; + } else { + return need("a line and a circle/arc/ellipse, two curves, or a spline end and a curve"); + } + + Ok(built) + } + fn spline_form(mut b: Built, m: &Model, x: &[f64]) -> Result { let (Some(r0), Some(r1)) = (b.refs.first().copied(), b.refs.get(1).copied()) else { return Err(format!("{} needs two objects", b.kind.name())); @@ -596,3 +463,292 @@ impl Built { if self.kind == ConstraintKind::Angular { v.to_degrees() } else { v } } } + +/// Shared access to a constraint's geometry, values, and output while evaluating one residual. +struct ResidualEval<'a> { + built: &'a Built, + model: &'a Model, + values: &'a [f64], + out: &'a mut Vec, +} + +impl ResidualEval<'_> { + fn evaluate(&mut self) -> Option<()> { + use ConstraintKind as K; + + match (self.built.kind, self.built.form) { + (_, Form::Lock) => Some(()), + (_, Form::PE { swap }) => self.eval_point_ellipse(swap), + (_, Form::LE { swap }) => self.eval_line_ellipse(swap), + (_, Form::Contact) => self.eval_contact(), + (_, Form::EndOn { spline, at_end }) => self.eval_end_on(spline, at_end), + (_, Form::Join { a_end, b_end, g2 }) => self.eval_join(a_end, b_end, g2), + (_, Form::Anchor(anchor)) => self.eval_anchor(anchor), + (K::Coincident, Form::PP) => self.eval_coincident_points(), + (K::Coincident, Form::PL { swap }) => self.eval_point_line(swap), + (K::Coincident, Form::PC { swap }) => self.eval_point_circle(swap), + (K::Horizontal | K::Vertical, form) => self.eval_horizontal_vertical(form), + (K::Parallel | K::Smooth, Form::LL) => self.eval_parallel(), + (K::Perpendicular, _) => self.eval_perpendicular(), + (K::Collinear, _) => self.eval_collinear(), + (K::Concentric, _) => self.eval_concentric(), + (K::Equal, Form::LL) => self.eval_equal_lines(), + (K::Equal, _) => self.eval_equal_circles(), + (K::Tangent | K::Smooth, Form::LC { swap }) => self.eval_tangent_line_circle(swap), + (K::Tangent | K::Smooth, _) => self.eval_tangent_circles(), + (K::Symmetric, Form::PP) => self.eval_symmetric_points(), + (K::Symmetric, Form::SymLines { crossed }) => self.eval_symmetric_lines(crossed), + (K::Symmetric, _) => self.eval_symmetric_circles(), + (K::Distance(axis), form) => self.eval_distance(axis, form), + (K::Angular, Form::ArcSweep) => self.eval_angular_arc(), + (K::Angular, Form::Rays { rev }) => self.eval_angular_rays(rev), + (K::Radius, _) => self.eval_radius(), + (K::Diameter, _) => self.eval_diameter(), + _ => Some(()), + } + } + + fn reference(&self, index: usize) -> Option<&GeomRef> { + self.built.refs.get(index) + } + + fn point(&self, index: usize) -> Option { + self.model.point(self.values, self.reference(index)?) + } + + fn line(&self, index: usize) -> Option<(Vec2, Vec2)> { + self.model.line(self.values, self.reference(index)?) + } + + fn circle(&self, index: usize) -> Option<(Vec2, f64)> { + self.model.circle(self.values, self.reference(index)?) + } + + fn ellipse(&self, index: usize) -> Option { + self.model.ellipse(self.values, self.reference(index)?) + } + + fn eval_point_ellipse(&mut self, swap: bool) -> Option<()> { + let (point, ellipse) = if swap { (self.point(1)?, self.ellipse(0)?) } else { (self.point(0)?, self.ellipse(1)?) }; + self.out.push(ellipse.on(point)); + Some(()) + } + + fn eval_line_ellipse(&mut self, swap: bool) -> Option<()> { + let (line, ellipse) = if swap { (self.line(1)?, self.ellipse(0)?) } else { (self.line(0)?, self.ellipse(1)?) }; + let (start, end) = line; + let direction = dir_n(start, end); + self.out.push(self.built.sign * direction.cross(ellipse.c - start) - ellipse.support(direction.perp())); + Some(()) + } + + fn eval_contact(&mut self) -> Option<()> { + let first_parameter = *self.values.get(self.built.aux)?; + let second_parameter = *self.values.get(self.built.aux + 1)?; + let (first_point, first_tangent) = self.built.curve_at(self.model, self.values, 0, first_parameter)?; + let (second_point, second_tangent) = self.built.curve_at(self.model, self.values, 1, second_parameter)?; + self.out.extend([ + first_point.x - second_point.x, + first_point.y - second_point.y, + first_tangent.normalized().cross(second_tangent.normalized()), + ]); + Some(()) + } + + fn eval_end_on(&mut self, spline: usize, at_end: bool) -> Option<()> { + let frame = self.model.end_frame(self.values, self.reference(spline)?, at_end)?; + let other = 1 - spline.min(1); + if let Some((start, end)) = self.line(other) { + let direction = dir_n(start, end); + self.out.extend([direction.cross(frame.p - start), frame.t.cross(direction)]); + } else if let Some((center, radius)) = self.circle(other) { + self.out.extend([frame.p.dist(center) - radius, frame.t.dot(dir_n(center, frame.p))]); + } else { + let ellipse = self.ellipse(other)?; + self.out.extend([ellipse.on(frame.p), frame.t.dot(ellipse.normal(frame.p))]); + } + Some(()) + } + + fn eval_join(&mut self, a_end: bool, b_end: bool, g2: bool) -> Option<()> { + let first = self.model.end_frame(self.values, self.reference(0)?, a_end)?; + let second = self.model.end_frame(self.values, self.reference(1)?, b_end)?; + let first = if a_end { first } else { first.reversed() }; + let second = if b_end { second.reversed() } else { second }; + self.out.extend([first.p.x - second.p.x, first.p.y - second.p.y, first.t.cross(second.t)]); + if g2 { + self.out.push(first.k - second.k); + } + Some(()) + } + + fn eval_anchor(&mut self, anchor: Vec2) -> Option<()> { + let point = self.point(0)?; + self.out.extend([point.x - anchor.x, point.y - anchor.y]); + Some(()) + } + + fn eval_coincident_points(&mut self) -> Option<()> { + let (first, second) = (self.point(0)?, self.point(1)?); + self.out.extend([first.x - second.x, first.y - second.y]); + Some(()) + } + + fn eval_point_line(&mut self, swap: bool) -> Option<()> { + let (point, (start, end)) = if swap { (self.point(1)?, self.line(0)?) } else { (self.point(0)?, self.line(1)?) }; + self.out.push(dir_n(start, end).cross(point - start)); + Some(()) + } + + fn eval_point_circle(&mut self, swap: bool) -> Option<()> { + let (point, (center, radius)) = if swap { (self.point(1)?, self.circle(0)?) } else { (self.point(0)?, self.circle(1)?) }; + self.out.push(point.dist(center) - radius); + Some(()) + } + + fn eval_horizontal_vertical(&mut self, form: Form) -> Option<()> { + use ConstraintKind as K; + + let (first, second) = if form == Form::L1 { + self.line(0).or_else(|| self.ellipse(0).map(|ellipse| (ellipse.c - ellipse.mj, ellipse.c + ellipse.mj)))? + } else { + (self.point(0)?, self.point(1)?) + }; + let value = if self.built.kind == K::Horizontal { first.y - second.y } else { first.x - second.x }; + self.out.push(value); + Some(()) + } + + fn eval_parallel(&mut self) -> Option<()> { + let ((first_start, first_end), (second_start, second_end)) = (self.line(0)?, self.line(1)?); + self.out.push(dir_n(first_start, first_end).cross(dir_n(second_start, second_end))); + Some(()) + } + + fn eval_perpendicular(&mut self) -> Option<()> { + let ((first_start, first_end), (second_start, second_end)) = (self.line(0)?, self.line(1)?); + self.out.push(dir_n(first_start, first_end).dot(dir_n(second_start, second_end))); + Some(()) + } + + fn eval_collinear(&mut self) -> Option<()> { + let ((first_start, first_end), (second_start, second_end)) = (self.line(0)?, self.line(1)?); + let direction = dir_n(first_start, first_end); + self.out.extend([direction.cross(second_start - first_start), direction.cross(second_end - first_start)]); + Some(()) + } + + fn eval_concentric(&mut self) -> Option<()> { + let center = |index| { + self.circle(index).map(|(center, _)| center).or_else(|| self.ellipse(index).map(|ellipse| ellipse.c)).or_else(|| self.point(index)) + }; + let (first, second) = (center(0)?, center(1)?); + self.out.extend([first.x - second.x, first.y - second.y]); + Some(()) + } + + fn eval_equal_lines(&mut self) -> Option<()> { + let ((first_start, first_end), (second_start, second_end)) = (self.line(0)?, self.line(1)?); + self.out.push(first_start.dist(first_end) - second_start.dist(second_end)); + Some(()) + } + + fn eval_equal_circles(&mut self) -> Option<()> { + let ((_, first_radius), (_, second_radius)) = (self.circle(0)?, self.circle(1)?); + self.out.push(first_radius - second_radius); + Some(()) + } + + fn eval_tangent_line_circle(&mut self, swap: bool) -> Option<()> { + let ((start, end), (center, radius)) = if swap { (self.line(1)?, self.circle(0)?) } else { (self.line(0)?, self.circle(1)?) }; + self.out.push(self.built.sign * dir_n(start, end).cross(center - start) - radius); + Some(()) + } + + fn eval_tangent_circles(&mut self) -> Option<()> { + let ((first_center, first_radius), (second_center, second_radius)) = (self.circle(0)?, self.circle(1)?); + let distance = first_center.dist(second_center); + let residual = if self.built.sign > 0.0 { + distance - (first_radius + second_radius) + } else { + distance - self.built.target * (first_radius - second_radius) + }; + self.out.push(residual); + Some(()) + } + + fn eval_symmetric_points(&mut self) -> Option<()> { + let (first, second, (line_start, line_end)) = (self.point(0)?, self.point(1)?, self.line(2)?); + let direction = dir_n(line_start, line_end); + self.out.extend([direction.cross(first.mid(second) - line_start), direction.dot(second - first)]); + Some(()) + } + + fn eval_symmetric_lines(&mut self, crossed: bool) -> Option<()> { + let ((first_start, first_end), (second_start, second_end), (line_start, line_end)) = (self.line(0)?, self.line(1)?, self.line(2)?); + let (second_start, second_end) = if crossed { (second_end, second_start) } else { (second_start, second_end) }; + let direction = dir_n(line_start, line_end); + self.out.extend([ + direction.cross(first_start.mid(second_start) - line_start), + direction.dot(second_start - first_start), + direction.cross(first_end.mid(second_end) - line_start), + direction.dot(second_end - first_end), + ]); + Some(()) + } + + fn eval_symmetric_circles(&mut self) -> Option<()> { + let ((first_center, first_radius), (second_center, second_radius), (line_start, line_end)) = + (self.circle(0)?, self.circle(1)?, self.line(2)?); + let direction = dir_n(line_start, line_end); + self.out.extend([ + direction.cross(first_center.mid(second_center) - line_start), + direction.dot(second_center - first_center), + first_radius - second_radius, + ]); + Some(()) + } + + fn eval_distance(&mut self, axis: DistAxis, form: Form) -> Option<()> { + let value = match (axis, form) { + (_, Form::PL { swap }) => { + let (point, (start, end)) = if swap { (self.point(1)?, self.line(0)?) } else { (self.point(0)?, self.line(1)?) }; + dir_n(start, end).cross(point - start) + } + _ => { + let (first, second) = if form == Form::L1 { self.line(0)? } else { (self.point(0)?, self.point(1)?) }; + match axis { + DistAxis::Aligned => first.dist(second), + DistAxis::Horizontal => second.x - first.x, + DistAxis::Vertical => second.y - first.y, + } + } + }; + self.out.push(self.built.sign * value - self.built.target); + Some(()) + } + + fn eval_angular_arc(&mut self) -> Option<()> { + let reference = self.reference(0)?; + self.out.push(self.model.arc_sweep(self.values, reference)? - self.built.target); + Some(()) + } + + fn eval_angular_rays(&mut self, reversed: [bool; 2]) -> Option<()> { + let ((first_start, first_end), (second_start, second_end)) = (self.line(0)?, self.line(1)?); + let (first, second) = (ray(first_start, first_end, reversed[0]), ray(second_start, second_end, reversed[1])); + let residual = wrap(first.cross(second).atan2(first.dot(second)) - self.built.sign * self.built.target); + self.out.push(residual); + Some(()) + } + + fn eval_radius(&mut self) -> Option<()> { + self.out.push(self.circle(0)?.1 - self.built.target); + Some(()) + } + + fn eval_diameter(&mut self) -> Option<()> { + self.out.push(2.0 * self.circle(0)?.1 - self.built.target); + Some(()) + } +} diff --git a/crates/doc/src/dynblock.rs b/crates/doc/src/dynblock.rs index 6887459a4..ef0a88be2 100644 --- a/crates/doc/src/dynblock.rs +++ b/crates/doc/src/dynblock.rs @@ -5,7 +5,7 @@ //! whose `ACAD_ENHANCEDBLOCK` entry is an evaluation graph (`ACAD_EVALUATION_GRAPH`), and the //! graph lists the block's *parameters* (a distance, a point, visibility states, a lookup…) and //! *actions* (what changing a parameter does to the block's objects: stretch, move, look up…). -//! [`dynamic_block`] reads them into the model below without changing the kept data, so a drawing +//! [`dynamic_block`](crate::dynblock::dynamic_block) reads them into the model below without changing the kept data, so a drawing //! saved again still carries them exactly as read. //! //! Every count and index here comes from the file: they are capped by the data actually present diff --git a/crates/doc/src/entity/block.rs b/crates/doc/src/entity/block.rs index 166afee27..3d6665e0b 100644 --- a/crates/doc/src/entity/block.rs +++ b/crates/doc/src/entity/block.rs @@ -1,6 +1,6 @@ use super::common::{Common, Lineweight}; use super::text::{MText, Text}; -use super::*; +use super::{Color, Deserialize, EntityKind, Mat3, Serialize, Vec2, Vec3}; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] diff --git a/crates/doc/src/entity/common.rs b/crates/doc/src/entity/common.rs index 6f7867ab3..17fc43c75 100644 --- a/crates/doc/src/entity/common.rs +++ b/crates/doc/src/entity/common.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Color, Deserialize, Serialize, Vec3}; /// A database handle (DXF group 5), unique per drawing. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)] diff --git a/crates/doc/src/entity/curves.rs b/crates/doc/src/entity/curves.rs index 770b22559..8eeb556c4 100644 --- a/crates/doc/src/entity/curves.rs +++ b/crates/doc/src/entity/curves.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Deserialize, PolyVertex, Serialize, Vec3}; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct Line { diff --git a/crates/doc/src/entity/dim.rs b/crates/doc/src/entity/dim.rs index 396e74c6f..d10237b26 100644 --- a/crates/doc/src/entity/dim.rs +++ b/crates/doc/src/entity/dim.rs @@ -1,7 +1,7 @@ use super::block::Insert; use super::common::Handle; use super::text::MText; -use super::*; +use super::{Deserialize, GSpline, Serialize, Vec2, Vec3, one, standard, yes}; #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -92,7 +92,7 @@ impl DimMarks { *self == DimMarks::default() } - /// Transform the points and angles (part of [`EntityKind::transform`]). + /// Transform the points and angles (part of [`super::EntityKind::transform`]). pub(super) fn transform(&mut self, t3: &dyn Fn(&mut Vec3), rot: f64, s: f64, mirror: bool) { if let Some(a) = &mut self.oblique { *a = cadcraft_geom::norm_angle(if mirror { rot - (*a - rot) } else { *a + rot }); diff --git a/crates/doc/src/entity/fill.rs b/crates/doc/src/entity/fill.rs index 1b69108a0..6790b0a7c 100644 --- a/crates/doc/src/entity/fill.rs +++ b/crates/doc/src/entity/fill.rs @@ -1,5 +1,5 @@ use super::common::Handle; -use super::*; +use super::{Color, Deserialize, PolyVertex, Serialize, Vec2, one}; /// A hatch boundary loop: closed polyline with bulges. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] diff --git a/crates/doc/src/entity/layout.rs b/crates/doc/src/entity/layout.rs index 7ebe49eee..be1b9584d 100644 --- a/crates/doc/src/entity/layout.rs +++ b/crates/doc/src/entity/layout.rs @@ -1,5 +1,5 @@ use super::common::Handle; -use super::*; +use super::{Color, Deserialize, Serialize, Vec2, Vec3, standard, yes}; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] diff --git a/crates/doc/src/entity/text.rs b/crates/doc/src/entity/text.rs index a4eff0427..75857eb30 100644 --- a/crates/doc/src/entity/text.rs +++ b/crates/doc/src/entity/text.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Deserialize, Serialize, Vec2, Vec3, one, standard}; #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] diff --git a/crates/doc/src/format.rs b/crates/doc/src/format.rs new file mode 100644 index 000000000..132a8c1aa --- /dev/null +++ b/crates/doc/src/format.rs @@ -0,0 +1,100 @@ +use std::path::Path; + +/// A file format, chosen by the file name's extension (ASCII case-insensitive). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Format { + Dxf, + Dwg, + /// A drawing template: DWG content. + Dwt, + Svg, + /// Gzip-compressed SVG. + Svgz, + Png, + Pdf, +} + +impl Format { + /// The formats a drawing can be read from by name. DXF and DWG are also recognised by content. + pub const READ: &'static [Format] = &[Format::Dxf, Format::Dwg, Format::Svg, Format::Svgz]; + /// The formats a drawing can be written to. + pub const WRITE: &'static [Format] = &[Format::Dxf, Format::Dwg, Format::Dwt, Format::Svg, Format::Png, Format::Pdf]; + + /// The format `path`'s extension names. A name without an extension is DXF; an unknown + /// extension is `None`. + pub fn from_path(p: impl AsRef) -> Option { + let ext = p.as_ref().extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default(); + Some(match ext.as_str() { + "dxf" | "" => Format::Dxf, + "dwg" => Format::Dwg, + "dwt" => Format::Dwt, + "svg" => Format::Svg, + "svgz" => Format::Svgz, + "png" => Format::Png, + "pdf" => Format::Pdf, + _ => return None, + }) + } + + /// The extension, lower case and without the dot. + pub fn extension(self) -> &'static str { + match self { + Format::Dxf => "dxf", + Format::Dwg => "dwg", + Format::Dwt => "dwt", + Format::Svg => "svg", + Format::Svgz => "svgz", + Format::Png => "png", + Format::Pdf => "pdf", + } + } + + /// Written as an image (model space fitted to a frame), so framing applies. SVGZ is read only. + pub fn is_image(self) -> bool { + matches!(self, Format::Svg | Format::Png | Format::Pdf) + } + + /// A drawing file (DXF, DWG, template) rather than an image. + pub fn is_drawing(self) -> bool { + matches!(self, Format::Dxf | Format::Dwg | Format::Dwt) + } + + /// Written as DWG, which drops the object types the DWG writer doesn't know. + pub fn drops_unknown(self) -> bool { + matches!(self, Format::Dwg | Format::Dwt) + } + + /// `formats` as "dxf, dwg, svg": the list help text shows. + pub fn list(formats: &[Format]) -> String { + formats.iter().map(|f| f.extension()).collect::>().join(", ") + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn from_path_by_extension() { + for f in [Format::Dxf, Format::Dwg, Format::Dwt, Format::Svg, Format::Svgz, Format::Png, Format::Pdf] { + assert_eq!(Format::from_path(format!("a/b.{}", f.extension())), Some(f)); + assert_eq!(Format::from_path(format!("B.{}", f.extension().to_ascii_uppercase())), Some(f)); + } + assert_eq!(Format::from_path("Drawing1"), Some(Format::Dxf), "no extension is DXF"); + assert_eq!(Format::from_path("dir.dwg/Drawing1"), Some(Format::Dxf)); + assert_eq!(Format::from_path("a."), Some(Format::Dxf)); + assert_eq!(Format::from_path("a.txt"), None); + assert_eq!(Format::from_path("a.dxf.bak"), None); + assert_eq!(Format::from_path(std::path::Path::new("x.PnG")), Some(Format::Png)); + } + + #[test] + fn classes() { + assert!(Format::READ.contains(&Format::Svgz) && !Format::WRITE.contains(&Format::Svgz)); + assert!(Format::WRITE.contains(&Format::Dwt) && !Format::READ.contains(&Format::Dwt)); + assert!(Format::WRITE.iter().filter(|f| f.is_image()).count() == 3 && !Format::Svgz.is_image()); + assert!(Format::Dwt.drops_unknown() && Format::Dwg.drops_unknown() && !Format::Dxf.drops_unknown()); + assert!(Format::Dwt.is_drawing() && !Format::Pdf.is_drawing()); + assert_eq!(Format::list(Format::READ), "dxf, dwg, svg, svgz"); + } +} diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs index eafea9e27..d970a6a56 100644 --- a/crates/doc/src/lib.rs +++ b/crates/doc/src/lib.rs @@ -10,6 +10,7 @@ mod array; mod constraint; mod entity; mod extents; +mod format; mod gdt; mod header; pub mod library; @@ -27,6 +28,7 @@ pub use cadcraft_geom as geom; pub use constraint::*; pub use entity::*; pub use extents::{MAX_BLOCK_DEPTH, entity_bounds}; +pub use format::Format; pub use gdt::*; pub use header::{HVal, Header}; pub use plotstyle::*; diff --git a/crates/engine/src/autosave.rs b/crates/engine/src/autosave.rs index 4da107449..14b363996 100644 --- a/crates/engine/src/autosave.rs +++ b/crates/engine/src/autosave.rs @@ -256,7 +256,10 @@ mod native { use std::path::Path; use std::time::{Duration, SystemTime}; - use super::*; + use super::{ + Autosaver, Drawing, HEARTBEAT_SECS, HashMap, Job, Recoverable, STALE_LOCK_SECS, Session, is_instance_id, parse_file_name, parse_lock_name, + savefilepath, savetime, + }; /// A new instance id: the process id and the start time. pub fn instance_id() -> String { diff --git a/crates/engine/src/cmd/annotate/angular.rs b/crates/engine/src/cmd/annotate/angular.rs index e576798ca..98ee88c79 100644 --- a/crates/engine/src/cmd/annotate/angular.rs +++ b/crates/engine/src/cmd/annotate/angular.rs @@ -1,5 +1,8 @@ use super::common::{DimText, add_dim, assoc_enabled, dim, hex_param, pick_at, segment_at, with_assoc}; -use super::*; +use super::{ + Accept, AssocSnap, DimAssoc, DimKind, EntityKind, Handle, Input, Interactive, Prompt, Result, Segment, Session, Step, Value, Vec2, bad, json, + point_req, targets, v3, +}; /// Two-line angular dimension (type 2) between two lines, attached to them. fn angular_from_lines(s: &Session, h1: Handle, h2: Handle, at: Vec2) -> Option { diff --git a/crates/engine/src/cmd/annotate/common.rs b/crates/engine/src/cmd/annotate/common.rs index 2dec75558..2267f16bf 100644 --- a/crates/engine/src/cmd/annotate/common.rs +++ b/crates/engine/src/cmd/annotate/common.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Accept, DimAssoc, DimKind, Dimension, EntityKind, Handle, Input, Prompt, Result, Segment, Session, Value, Vec2, Vec3, v3}; pub(super) fn style(s: &Session) -> String { s.doc().map(|d| d.header.str("DIMSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into()) diff --git a/crates/engine/src/cmd/annotate/edit.rs b/crates/engine/src/cmd/annotate/edit.rs index 74292bc81..38f02005f 100644 --- a/crates/engine/src/cmd/annotate/edit.rs +++ b/crates/engine/src/cmd/annotate/edit.rs @@ -1,5 +1,8 @@ use super::common::{hex_param, style}; -use super::*; +use super::{ + Accept, DimKind, EntityKind, Handle, Input, Interactive, Prompt, Result, SelOutcome, SelectPhase, Session, Step, Value, Vec2, bad, json, + point_param, str_param, targets, v3, +}; pub(super) fn run_update(s: &mut Session, p: &Value) -> Result { let hs = targets(s, p)?; diff --git a/crates/engine/src/cmd/annotate/linear.rs b/crates/engine/src/cmd/annotate/linear.rs index ab0a14214..6bcf8fbdb 100644 --- a/crates/engine/src/cmd/annotate/linear.rs +++ b/crates/engine/src/cmd/annotate/linear.rs @@ -1,5 +1,8 @@ use super::common::{DimText, add_dim, assoc_enabled, circle_of, dim, linear_kind, pick_at}; -use super::*; +use super::{ + Accept, DimKind, Dimension, EngineError, EntityKind, Handle, Input, Interactive, Prim, Prompt, Result, Segment, Session, Step, Value, Vec2, bad, + json, point_req, points_param, str_param, v3, +}; pub(super) fn run_linear(s: &mut Session, p: &Value) -> Result { let (a, b) = match p.get("object").and_then(|v| v.as_str().and_then(Handle::parse_hex).or_else(|| v.as_u64().map(Handle))) { diff --git a/crates/engine/src/cmd/annotate/mleader.rs b/crates/engine/src/cmd/annotate/mleader.rs index c2e0a63df..536e83b8c 100644 --- a/crates/engine/src/cmd/annotate/mleader.rs +++ b/crates/engine/src/cmd/annotate/mleader.rs @@ -1,5 +1,8 @@ use super::common::style; -use super::*; +use super::{ + Accept, EngineError, EntityKind, Input, Interactive, LeaderOrder, MLeader, MLeaderOptions, MText, Prompt, Result, Session, Step, Value, Vec2, + bad, json, points_param, str_param, v3, +}; /// A multileader from arrowhead to landing; `landing` false leaves out the landing line (dogleg). fn mleader_kind(s: &Session, pts: &[Vec2], text: &str, landing: bool) -> Option { diff --git a/crates/engine/src/cmd/annotate/radial.rs b/crates/engine/src/cmd/annotate/radial.rs index a83f7dfd2..cee5dcc01 100644 --- a/crates/engine/src/cmd/annotate/radial.rs +++ b/crates/engine/src/cmd/annotate/radial.rs @@ -1,5 +1,5 @@ use super::common::{DimText, add_dim, circle_of, dim, pick_at, text_at}; -use super::*; +use super::{Accept, DimKind, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, bad, json, point_param, targets}; fn radial(s: &mut Session, p: &Value, diameter: bool) -> Result { let id = if diameter { "dimdiameter" } else { "dimradius" }; diff --git a/crates/engine/src/cmd/draw/circle.rs b/crates/engine/src/cmd/draw/circle.rs index 146b4de50..789cb5366 100644 --- a/crates/engine/src/cmd/draw/circle.rs +++ b/crates/engine/src/cmd/draw/circle.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Arc, Circle, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, added, arc, bad, circle, f64_req, line, number, + point_param, size_param, +}; pub(super) fn run_circle(s: &mut Session, p: &Value) -> Result { let c = if let Some(center) = point_param(p, "center") { diff --git a/crates/engine/src/cmd/draw/ellipse.rs b/crates/engine/src/cmd/draw/ellipse.rs index 87391c263..c1e7967d9 100644 --- a/crates/engine/src/cmd/draw/ellipse.rs +++ b/crates/engine/src/cmd/draw/ellipse.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Ellipse, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, added, bad, f64_or, f64_req, line, number, + point_req, v3, +}; pub(super) fn run_ellipse(s: &mut Session, p: &Value) -> Result { if p.get("isocircle").is_some() { diff --git a/crates/engine/src/cmd/draw/line_pline.rs b/crates/engine/src/cmd/draw/line_pline.rs index b7ad2455c..9f6df5fa6 100644 --- a/crates/engine/src/cmd/draw/line_pline.rs +++ b/crates/engine/src/cmd/draw/line_pline.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Input, Interactive, Outcome, PlineAsk, PolyVertex, Prompt, Result, Session, Step, Value, Vec2, added, arc_to_bulge, bad, + bool_or, bulge_to_arc, distinct_points, f64_or, json, line, lwpoly, number, point_value, points_param, size_param, snap, +}; // ---------------- JSON forms ---------------- diff --git a/crates/engine/src/cmd/draw/point.rs b/crates/engine/src/cmd/draw/point.rs index 507b0b10d..17f486b76 100644 --- a/crates/engine/src/cmd/draw/point.rs +++ b/crates/engine/src/cmd/draw/point.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Input, Interactive, Point, PolyVertex, Prompt, RayLine, Result, Session, Step, Value, Vec2, added, bad, json, lwpoly, number, + point_param, point_req, points_param, size_param, v3, +}; pub(super) fn run_point(s: &mut Session, p: &Value) -> Result { let pts = match point_param(p, "at") { diff --git a/crates/engine/src/cmd/draw/polygon.rs b/crates/engine/src/cmd/draw/polygon.rs index d67aa62e6..d13618683 100644 --- a/crates/engine/src/cmd/draw/polygon.rs +++ b/crates/engine/src/cmd/draw/polygon.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, added, bad, bool_or, lwpoly, number, point_req, points_param, + polygon_from_edge, polygon_typed_radius_point, polygon_vertices, size_param, +}; pub(super) fn run_polygon(s: &mut Session, p: &Value) -> Result { // A `sides` that is not a whole number (e.g. -3) is refused, not replaced by the default 4. diff --git a/crates/engine/src/cmd/draw/spline.rs b/crates/engine/src/cmd/draw/spline.rs index f10a0dd80..498f1a9f2 100644 --- a/crates/engine/src/cmd/draw/spline.rs +++ b/crates/engine/src/cmd/draw/spline.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Input, Interactive, Prompt, Result, Session, Spline, Step, Value, Vec2, added, bad, bool_or, distinct_points, find_command, + points_param, +}; pub(super) fn run_spline(s: &mut Session, p: &Value) -> Result { if p.get("object").is_some() { diff --git a/crates/engine/src/cmd/draw/text.rs b/crates/engine/src/cmd/draw/text.rs index 2ca220a9b..21962c469 100644 --- a/crates/engine/src/cmd/draw/text.rs +++ b/crates/engine/src/cmd/draw/text.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, HAlign, Input, Interactive, MText, PolyVertex, Prompt, Result, Session, Step, Text, VAlign, Value, Vec2, added, bad, bool_or, + f64_or, lwpoly, number, point_req, str_param, v3, +}; /// Justification code → (halign, valign). pub(crate) fn justify(j: &str) -> Option<(HAlign, VAlign)> { diff --git a/crates/engine/src/cmd/draw2/arc.rs b/crates/engine/src/cmd/draw2/arc.rs index f219348df..332f22653 100644 --- a/crates/engine/src/cmd/draw2/arc.rs +++ b/crates/engine/src/cmd/draw2/arc.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Arc, Circle, EntityKind, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, added, arc, bad, circle, curves, line, + norm_angle, number, other, point_param, point_req, point_value, +}; // ===================================================================================== // Generic point/value sequences (arc and circle variants) diff --git a/crates/engine/src/cmd/draw2/centermark.rs b/crates/engine/src/cmd/draw2/centermark.rs index 00edfbcc3..2a13a8e02 100644 --- a/crates/engine/src/cmd/draw2/centermark.rs +++ b/crates/engine/src/cmd/draw2/centermark.rs @@ -1,4 +1,6 @@ -use super::*; +use super::{ + Accept, EntityKind, Handle, Input, Interactive, Prompt, Result, Session, Step, Value, Vec2, added, bad, curves, json, line, other, targets, +}; // ===================================================================================== // CENTERMARK / CENTERLINE diff --git a/crates/engine/src/cmd/draw2/curves3d.rs b/crates/engine/src/cmd/draw2/curves3d.rs index 70af51c53..005c49f07 100644 --- a/crates/engine/src/cmd/draw2/curves3d.rs +++ b/crates/engine/src/cmd/draw2/curves3d.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Handle, Helix, HelixConstrain, Input, Interactive, MAX_GEN, Polyline3d, Prompt, Result, Session, Spline, Step, Value, Vec2, + Vec3, added, bad, bool_or, circle, curves, f64_or, f64_req, line, number, other, point_req, points_param, v3, +}; // ===================================================================================== // 3DPOLY diff --git a/crates/engine/src/cmd/draw2/divide.rs b/crates/engine/src/cmd/draw2/divide.rs index 1ba624c15..6b6ea28e3 100644 --- a/crates/engine/src/cmd/draw2/divide.rs +++ b/crates/engine/src/cmd/draw2/divide.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Chain, EntityKind, Handle, Input, Interactive, MAX_GEN, Point, Prompt, Result, Session, Step, Value, Vec2, bad, bool_or, curves, f64_req, + json, number, other, point_param, str_param, targets, v3, +}; // ===================================================================================== // DIVIDE / MEASURE diff --git a/crates/engine/src/cmd/draw2/ellipse.rs b/crates/engine/src/cmd/draw2/ellipse.rs index ca3f9c6e2..e699eac58 100644 --- a/crates/engine/src/cmd/draw2/ellipse.rs +++ b/crates/engine/src/cmd/draw2/ellipse.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Ellipse, EntityKind, Line, Result, Session, TAU, Value, Vec2, added, bad, f64_req, point_param, point_req, v3}; // ---------------- ellipse entries ---------------- diff --git a/crates/engine/src/cmd/draw2/rect.rs b/crates/engine/src/cmd/draw2/rect.rs index 84db5093a..4b19dc703 100644 --- a/crates/engine/src/cmd/draw2/rect.rs +++ b/crates/engine/src/cmd/draw2/rect.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Input, Interactive, PolyVertex, Prompt, Result, Session, Step, Value, Vec2, added, bad, bool_or, curves, f64_or, lwpoly, + number, other, point_param, point_req, rect_with_corners, size_param, +}; // ===================================================================================== // RECTANG with Area / Dimensions / Rotation / Width / Elevation / Thickness diff --git a/crates/engine/src/cmd/draw2/revcloud.rs b/crates/engine/src/cmd/draw2/revcloud.rs index 83d8cbb75..634456b05 100644 --- a/crates/engine/src/cmd/draw2/revcloud.rs +++ b/crates/engine/src/cmd/draw2/revcloud.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Chain, Circle, Ellipse, EntityKind, Handle, Input, Interactive, Line, MAX_GEN, PolyVertex, Polyline, Prompt, Result, Session, Step, + Value, Vec2, added, bad, bool_or, curves, lwpoly, number, other, point_param, points_param, rect_vertices, shoelace, str_param, +}; // ===================================================================================== // REVCLOUD diff --git a/crates/engine/src/cmd/draw2/tancircle.rs b/crates/engine/src/cmd/draw2/tancircle.rs index 48268987a..0d4cd9ca7 100644 --- a/crates/engine/src/cmd/draw2/tancircle.rs +++ b/crates/engine/src/cmd/draw2/tancircle.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Circle, Handle, Input, Interactive, Prompt, Result, Session, Step, TanObj, Value, Vec2, added, bad, circle, curves, f64_req, number, + other, point_param, point_req, +}; pub(super) fn run_circle_variant(s: &mut Session, p: &Value) -> Result { let c = if let (Some(c), Some(d)) = (point_param(p, "center"), p.get("diameter").and_then(Value::as_f64)) { diff --git a/crates/engine/src/cmd/draw2/wipeout.rs b/crates/engine/src/cmd/draw2/wipeout.rs index 212b645f3..e5ec3387f 100644 --- a/crates/engine/src/cmd/draw2/wipeout.rs +++ b/crates/engine/src/cmd/draw2/wipeout.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Handle, Input, Interactive, MAX_GEN, PolyVertex, Prompt, Result, Session, Step, Value, Vec2, Wipeout, added, bad, bool_or, + curves, json, lwpoly, other, points_param, shoelace, str_param, +}; // ===================================================================================== // WIPEOUT diff --git a/crates/engine/src/cmd/draw2/xline.rs b/crates/engine/src/cmd/draw2/xline.rs index 1e4b6cdae..31f152d16 100644 --- a/crates/engine/src/cmd/draw2/xline.rs +++ b/crates/engine/src/cmd/draw2/xline.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Handle, Input, Interactive, Polyline, Prompt, RayLine, Result, Session, Step, Value, Vec2, added, bad, bool_or, curves, + f64_req, number, other, point_param, point_req, v3, +}; // ===================================================================================== // XLINE with Hor/Ver/Ang/Bisect/Offset diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs index 95975a4e2..3a5296e88 100644 --- a/crates/engine/src/cmd/file.rs +++ b/crates/engine/src/cmd/file.rs @@ -7,7 +7,7 @@ mod template; use std::sync::OnceLock; -use cadcraft_doc::Drawing; +use cadcraft_doc::{Drawing, Format}; pub use cadcraft_dxf::Version; use serde_json::{Value, json}; @@ -136,8 +136,7 @@ fn save_options(cmd: &str, p: &Value) -> Result { /// Whether `path` names a DXF file (or has no extension, which saves as DXF). fn is_dxf(path: &str) -> bool { - let ext = std::path::Path::new(path).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default(); - matches!(ext.as_str(), "dxf" | "") + Format::from_path(path) == Some(Format::Dxf) } /// The drawing written to `path` with `opts`: through [`IoHooks::write`] when no option is set, @@ -273,17 +272,21 @@ pub struct ReadFile { } /// Read and decode `path` (the slow half of `OPEN {path}`). Needs no session; runs anywhere. -pub fn read_file(path: &str) -> std::result::Result { +pub fn read_file(path: &std::path::Path) -> std::result::Result { #[cfg(not(target_arch = "wasm32"))] { let r = std::panic::catch_unwind(|| { - let bytes = - crate::capped_read::read_capped(std::path::Path::new(path), MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{path}: {e}")))?; - read_bytes(&bytes, path, Some(path.to_string())) + let shown = path.display(); + // The session keeps paths as text; a name that isn't Unicode could never be saved back to. + 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"))); + }; + 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())) }); match r { Ok(r) => r.map_err(|e| e.to_string()), - Err(_) => Err(bad("open", format!("{path}: the file could not be read")).to_string()), + Err(_) => Err(bad("open", format!("{}: the file could not be read", path.display())).to_string()), } } #[cfg(target_arch = "wasm32")] @@ -515,7 +518,7 @@ fn run_bytes(s: &mut Session, p: &Value) -> Result { let lost = not_saved_as(s.doc()?, version); let bytes = write_bytes(s, "document.bytes", &format!("drawing.{fmt}"), &opts)?; let mut r = json!({ "data": base64_encode(&bytes), "bytes": bytes.len() }); - if drops_unknown(&format!("drawing.{fmt}")) { + if drops_unknown(format!("drawing.{fmt}")) { report_not_saved(s, &mut r, &lost); } Ok(r) @@ -563,15 +566,13 @@ pub fn not_saved_message(lost: &std::collections::BTreeMap) -> Op /// Whether saving to `path` leaves out the entities [`not_saved`] counts: DWG does (the DWG /// bridge drops types it doesn't know); DXF writes them back as read. -pub fn drops_unknown(path: &str) -> bool { - // Templates (.dwt) are written as DWG too. - std::path::Path::new(path).extension().is_some_and(|e| e.eq_ignore_ascii_case("dwg") || e.eq_ignore_ascii_case("dwt")) +pub fn drops_unknown(path: impl AsRef) -> bool { + Format::from_path(path).is_some_and(Format::drops_unknown) } /// Whether `path` is saved as a drawing (DXF, DWG) rather than exported as an image. -fn is_drawing_file(path: &str) -> bool { - let ext = std::path::Path::new(path).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default(); - matches!(ext.as_str(), "dxf" | "dwg" | "dwt" | "") +fn is_drawing_file(path: impl AsRef) -> bool { + Format::from_path(path).is_some_and(Format::is_drawing) } /// Say on the command line what the file couldn't keep, and list it in the result's `notSaved`. diff --git a/crates/engine/src/cmd/hatch.rs b/crates/engine/src/cmd/hatch.rs index d0221a00a..df0fef550 100644 --- a/crates/engine/src/cmd/hatch.rs +++ b/crates/engine/src/cmd/hatch.rs @@ -10,7 +10,7 @@ use cadcraft_geom::{Bounds2, PolyVertex, Polyline, Vec2, point_in_polygon}; use serde_json::{Value, json}; use super::helpers::lwpoly; -use super::*; +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}; diff --git a/crates/engine/src/cmd/layout.rs b/crates/engine/src/cmd/layout.rs index 9821055e9..a538d73b5 100644 --- a/crates/engine/src/cmd/layout.rs +++ b/crates/engine/src/cmd/layout.rs @@ -9,7 +9,7 @@ use cadcraft_geom::{Bounds2, Vec2}; use serde_json::{Value, json}; use super::file::{base64_encode, io}; -use super::*; +use super::{CommandSpec, bad, bool_or, find_command, point_param, point_value, str_param, targets}; use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step}; use viewports::MviewM; diff --git a/crates/engine/src/cmd/modify/break_join.rs b/crates/engine/src/cmd/modify/break_join.rs index 16892c199..c7432e223 100644 --- a/crates/engine/src/cmd/modify/break_join.rs +++ b/crates/engine/src/cmd/modify/break_join.rs @@ -1,5 +1,8 @@ use super::trim::{param_on, sub_polyline}; -use super::*; +use super::{ + Accept, Arc, EngineError, Entity, EntityKind, Handle, Input, Interactive, Line, PolyVertex, Polyline, Prompt, Result, Segment, Session, Step, + 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 { diff --git a/crates/engine/src/cmd/modify/explode.rs b/crates/engine/src/cmd/modify/explode.rs index 3b25ccfee..46ada655d 100644 --- a/crates/engine/src/cmd/modify/explode.rs +++ b/crates/engine/src/cmd/modify/explode.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Entity, EntityKind, Handle, PolyVertex, Polyline, Result, Segment, Session, Value, Vec2, arc, json, line, lwpoly, targets, v3}; // ---------------- explode / array / order / break / join ---------------- diff --git a/crates/engine/src/cmd/modify/fillet.rs b/crates/engine/src/cmd/modify/fillet.rs index 01d701817..963de2607 100644 --- a/crates/engine/src/cmd/modify/fillet.rs +++ b/crates/engine/src/cmd/modify/fillet.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Arc, EngineError, Entity, EntityKind, Handle, Input, Interactive, Line, PolyVertex, Prompt, Result, Session, Step, Value, Vec2, arc, bad, + bool_or, ccw_sweep, f64_or, json, line, line_line_infinite, number, point_param, +}; // ---------------- fillet / chamfer ---------------- diff --git a/crates/engine/src/cmd/modify/offset.rs b/crates/engine/src/cmd/modify/offset.rs index 67bdd7ec7..01ca46c04 100644 --- a/crates/engine/src/cmd/modify/offset.rs +++ b/crates/engine/src/cmd/modify/offset.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Arc, EngineError, Entity, EntityKind, Handle, Input, Interactive, Line, PolyVertex, Polyline, Prompt, Result, Segment, Session, Step, + Value, Vec2, arc, bad, bool_or, ccw_sweep, circle, f64_req, intersect_ext, json, line, lwpoly, number, point_req, str_param, targets, v3, +}; /// Whether OFFSET can work on this kind of object at all. fn offsettable(k: &EntityKind) -> bool { diff --git a/crates/engine/src/cmd/modify/select_then.rs b/crates/engine/src/cmd/modify/select_then.rs index 75264990c..10bf08399 100644 --- a/crates/engine/src/cmd/modify/select_then.rs +++ b/crates/engine/src/cmd/modify/select_then.rs @@ -1,7 +1,9 @@ use super::break_join::join; use super::explode::explode; use super::transform::{erase, transform_entities}; -use super::*; +use super::{ + Accept, EngineError, EntityKind, Handle, Input, Interactive, Mat3, Prompt, Result, SelOutcome, SelectPhase, Session, Step, Vec2, line, number, +}; // ---------------- interactive ---------------- diff --git a/crates/engine/src/cmd/modify/stretch.rs b/crates/engine/src/cmd/modify/stretch.rs index 5aa91bbef..a277f9774 100644 --- a/crates/engine/src/cmd/modify/stretch.rs +++ b/crates/engine/src/cmd/modify/stretch.rs @@ -1,5 +1,8 @@ use super::transform::{delta_of, transform_entities}; -use super::*; +use super::{ + Accept, Entity, EntityKind, Handle, Input, Interactive, Mat3, Prompt, Result, SelectKind, SelectMode, Session, Step, Value, Vec2, bad, json, + line, points_param, +}; /// An area whose vertices STRETCH moves: a window's box, or a polygon closed back to its first /// point. diff --git a/crates/engine/src/cmd/modify/transform.rs b/crates/engine/src/cmd/modify/transform.rs index 760e37cbc..5474dde16 100644 --- a/crates/engine/src/cmd/modify/transform.rs +++ b/crates/engine/src/cmd/modify/transform.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Entity, Handle, Mat3, Result, Session, Value, Vec2, bad, bool_or, f64_req, json, point_param, point_req, targets}; // ---------------- core operations ---------------- diff --git a/crates/engine/src/cmd/modify/trim.rs b/crates/engine/src/cmd/modify/trim.rs index 4caaadfb6..66eab0be8 100644 --- a/crates/engine/src/cmd/modify/trim.rs +++ b/crates/engine/src/cmd/modify/trim.rs @@ -1,4 +1,7 @@ -use super::*; +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, +}; // ---------------- trim / extend ---------------- diff --git a/crates/engine/src/cmd/modify2/align.rs b/crates/engine/src/cmd/modify2/align.rs index 90e13887d..edb7ef22c 100644 --- a/crates/engine/src/cmd/modify2/align.rs +++ b/crates/engine/src/cmd/modify2/align.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, EntityKind, Handle, Input, Interactive, Mat3, Prompt, Result, SelOutcome, SelectPhase, Session, Step, Value, Vec2, bool_or, curves, json, + line, point_param, point_req, targets, +}; // ===================================================================================== // ALIGN diff --git a/crates/engine/src/cmd/modify2/blend.rs b/crates/engine/src/cmd/modify2/blend.rs index 72dae0f43..32b477eea 100644 --- a/crates/engine/src/cmd/modify2/blend.rs +++ b/crates/engine/src/cmd/modify2/blend.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Chain, EntityKind, Handle, Input, Interactive, Prompt, Result, Session, Spline, Step, Value, Vec2, bad, curves, json, other, point_req, + str_param, +}; // ===================================================================================== // BLEND diff --git a/crates/engine/src/cmd/modify2/fillet.rs b/crates/engine/src/cmd/modify2/fillet.rs index bdc5dded6..20062a87f 100644 --- a/crates/engine/src/cmd/modify2/fillet.rs +++ b/crates/engine/src/cmd/modify2/fillet.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Arc, EntityKind, Handle, LwPolyline, PolyVertex, Result, Session, TanObj, Vec2, arc, ccw_sweep, curve_edits, curves, line, line_circle, + line_line_infinite, other, push_entity, set_kind, +}; // ===================================================================================== // FILLET extensions (arcs, circles, polylines) diff --git a/crates/engine/src/cmd/modify2/lengthen.rs b/crates/engine/src/cmd/modify2/lengthen.rs index d3021cb42..0c86c2c9c 100644 --- a/crates/engine/src/cmd/modify2/lengthen.rs +++ b/crates/engine/src/cmd/modify2/lengthen.rs @@ -1,5 +1,8 @@ use super::trimext::ellipse_of; -use super::*; +use super::{ + Accept, Arc, Chain, EntityKind, Handle, Input, Interactive, LwPolyline, Polyline, Prompt, Result, Session, Step, TAU, Value, Vec2, bad, + ccw_sweep, curve_edits, curves, json, number, other, point_param, set_kind, targets, +}; // ===================================================================================== // LENGTHEN diff --git a/crates/engine/src/cmd/modify2/ncopy.rs b/crates/engine/src/cmd/modify2/ncopy.rs index 237110a5e..475256e84 100644 --- a/crates/engine/src/cmd/modify2/ncopy.rs +++ b/crates/engine/src/cmd/modify2/ncopy.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Common, EntityKind, Handle, Input, Interactive, MAX_BLOCK_DEPTH, MAX_GEN, Mat3, Prompt, Result, Session, Step, Value, Vec2, bad, curves, + json, other, point_param, push_entity, targets, +}; // ===================================================================================== // NCOPY diff --git a/crates/engine/src/cmd/modify2/patharray.rs b/crates/engine/src/cmd/modify2/patharray.rs index e8f03fc6b..3f9445249 100644 --- a/crates/engine/src/cmd/modify2/patharray.rs +++ b/crates/engine/src/cmd/modify2/patharray.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Accept, Chain, Handle, Input, Interactive, Mat3, Prompt, Result, SelOutcome, SelectPhase, Session, Step, Value, bad, bool_or, curves, json, + number, other, targets, +}; // ===================================================================================== // ARRAYPATH (non-associative copies along a curve) diff --git a/crates/engine/src/cmd/modify2/pedit.rs b/crates/engine/src/cmd/modify2/pedit.rs index 399759cf4..ae9110e48 100644 --- a/crates/engine/src/cmd/modify2/pedit.rs +++ b/crates/engine/src/cmd/modify2/pedit.rs @@ -1,4 +1,8 @@ -use super::*; +use super::{ + Accept, Chain, EntityKind, Handle, Input, Interactive, LwPolyline, MAX_GEN, PolyVertex, Prompt, Result, SelOutcome, SelectPhase, Session, Spline, + Step, Value, Vec2, as_lwpoly, bad, bool_or, curves, f64_or, f64_req, json, line, number, other, pedit_vertex, point_req, set_kind, str_param, + targets, +}; /// Fit curve: a tangent-continuous pair of arcs (biarc) per segment through every vertex, /// following the tangent directions given per vertex (Edit vertex Tangent). diff --git a/crates/engine/src/cmd/modify2/selop.rs b/crates/engine/src/cmd/modify2/selop.rs index 90330bbbf..f1b63e3ce 100644 --- a/crates/engine/src/cmd/modify2/selop.rs +++ b/crates/engine/src/cmd/modify2/selop.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + EntityKind, Handle, Input, Interactive, LwPolyline, Mat3, PolyVertex, Prompt, Result, SelOutcome, SelectPhase, Session, Space, Step, Value, + curves, json, lwpoly, other, set_kind, str_param, targets, +}; // ===================================================================================== // REVERSE / CHSPACE / FLATTEN (select, then act) diff --git a/crates/engine/src/cmd/modify2/splinedit.rs b/crates/engine/src/cmd/modify2/splinedit.rs index f5ba767fb..ae01e89c6 100644 --- a/crates/engine/src/cmd/modify2/splinedit.rs +++ b/crates/engine/src/cmd/modify2/splinedit.rs @@ -499,6 +499,94 @@ impl SplineditM { } } +impl SplineditM { + fn input_main(&mut self, s: &mut Session, h: Handle, sp: &Spline, enter: bool, kw: &str) -> Result> { + match (enter, kw) { + (true, _) | (_, "exit" | "x") => { + s.set_selection(Vec::new()); + return Ok(Some(Step::Done)); + } + (_, "close" | "c") => self.apply(s, json!({ "option": "close" }))?, + (_, "open" | "o") => self.apply(s, json!({ "option": "open" }))?, + (_, "reverse" | "r") => self.apply(s, json!({ "option": "reverse" }))?, + (_, "convert to polyline" | "p") => self.sub = Sub::Precision, + (_, "fit data" | "f") if sp.fit.is_empty() => s.echo("The spline has no fit data."), + (_, "fit data" | "f") => self.sub = Sub::Fit, + (_, "edit vertex" | "e") => { + self.mark = 0; + self.sub = Sub::Vertex; + } + (_, "join" | "j") if sp.closed => s.echo("Cannot join to a closed spline."), + (_, "join" | "j") => { + self.join = SelectPhase::default(); + self.sub = Sub::Join; + } + (_, "undo" | "u") => { + if let Some((at, ents)) = self.joined.last() + && *at == self.history.len() + { + let d = s.doc_mut()?; + for (space, e) in ents { + if let Some(st) = d.space_mut(space) { + st.push(e.clone()); + } + } + self.joined.pop(); + } + match self.history.pop() { + Some(k) => set_kind(s, h, k)?, + None => s.echo("All edits have been undone."), + } + } + (_, "") => {} + _ => return Err(other("Invalid option keyword.")), + } + Ok(None) + } + + fn input_fit(&mut self, s: &mut Session, sp: &Spline, enter: bool, kw: &str) -> Result<()> { + match (enter, kw) { + (true, _) | (_, "exit" | "x") => self.sub = Sub::Main, + (_, "add" | "a") => self.sub = Sub::FitAddPick, + (_, "close" | "c") => self.apply(s, json!({ "option": "close" }))?, + (_, "open" | "o") => self.apply(s, json!({ "option": "open" }))?, + (_, "delete" | "d") => self.sub = Sub::FitDelete, + (_, "kink" | "k") => self.sub = Sub::FitKink, + (_, "move" | "m") => { + self.mark = 0; + self.sub = Sub::FitMove; + } + (_, "purge" | "p") => { + self.apply(s, json!({ "option": "purge" }))?; + self.sub = Sub::Main; + } + (_, "tangents" | "t") if sp.closed => s.echo("A closed spline has no end tangents."), + (_, "tangents" | "t") => self.sub = Sub::FitStartTangent, + (_, "tolerance" | "l") => self.sub = Sub::FitTolerance, + (_, "") => {} + _ => return Err(other("Invalid option keyword.")), + } + Ok(()) + } + + fn input_join(&mut self, s: &mut Session, h: Handle, sp: &Spline, input: &Input) -> Result<()> { + match self.join.feed(s, input)? { + SelOutcome::More => {} + SelOutcome::Empty => self.sub = Sub::Main, + SelOutcome::Done(handles) => { + self.sub = Sub::Main; + let before = curves::entity(s, h)?.kind; + let removed = join(s, h, sp, &handles)?; + self.history.push(before); + s.echo(format!("{} object(s) joined into the spline", removed.len())); + self.joined.push((self.history.len(), removed)); + s.set_selection(vec![h]); + } + } + Ok(()) + } +} + impl Interactive for SplineditM { fn name(&self) -> &'static str { "SPLINEDIT" @@ -578,60 +666,12 @@ impl Interactive for SplineditM { let enter = i == Input::Enter; let sp = self.spline(s).ok_or_else(|| other("The spline was erased."))?; match self.sub { - Sub::Main => match (enter, kw) { - (true, _) | (_, "exit" | "x") => { - s.set_selection(Vec::new()); - return Ok(Step::Done); + Sub::Main => { + if let Some(step) = self.input_main(s, h, &sp, enter, kw)? { + return Ok(step); } - (_, "close" | "c") => self.apply(s, json!({ "option": "close" }))?, - (_, "open" | "o") => self.apply(s, json!({ "option": "open" }))?, - (_, "reverse" | "r") => self.apply(s, json!({ "option": "reverse" }))?, - (_, "convert to polyline" | "p") => self.sub = Sub::Precision, - (_, "fit data" | "f") if sp.fit.is_empty() => s.echo("The spline has no fit data."), - (_, "fit data" | "f") => self.sub = Sub::Fit, - (_, "edit vertex" | "e") => { - self.mark = 0; - self.sub = Sub::Vertex; - } - (_, "join" | "j") if sp.closed => s.echo("Cannot join to a closed spline."), - (_, "join" | "j") => { - self.join = SelectPhase::default(); - self.sub = Sub::Join; - } - (_, "undo" | "u") => { - // Undoing a join brings the joined objects back. - if let Some((at, ents)) = self.joined.last() - && *at == self.history.len() - { - let d = s.doc_mut()?; - for (space, e) in ents { - if let Some(st) = d.space_mut(space) { - st.push(e.clone()); - } - } - self.joined.pop(); - } - match self.history.pop() { - Some(k) => set_kind(s, h, k)?, - None => s.echo("All edits have been undone."), - } - } - (_, "") => {} - _ => return Err(other("Invalid option keyword.")), - }, - Sub::Join => match self.join.feed(s, &i)? { - SelOutcome::More => {} - SelOutcome::Empty => self.sub = Sub::Main, - SelOutcome::Done(hs) => { - self.sub = Sub::Main; - let before = curves::entity(s, h)?.kind; - let removed = join(s, h, &sp, &hs)?; - self.history.push(before); - s.echo(format!("{} object(s) joined into the spline", removed.len())); - self.joined.push((self.history.len(), removed)); - s.set_selection(vec![h]); - } - }, + } + Sub::Join => self.input_join(s, h, &sp, &i)?, Sub::Precision => { let precision = match &i { Input::Text(t) => number(t).filter(|n| (0.0..=99.0).contains(n)).ok_or_else(|| other("Requires an integer between 0 and 99."))?, @@ -641,27 +681,7 @@ impl Interactive for SplineditM { s.set_selection(Vec::new()); return Ok(Step::Done); } - Sub::Fit => match (enter, kw) { - (true, _) | (_, "exit" | "x") => self.sub = Sub::Main, - (_, "add" | "a") => self.sub = Sub::FitAddPick, - (_, "close" | "c") => self.apply(s, json!({ "option": "close" }))?, - (_, "open" | "o") => self.apply(s, json!({ "option": "open" }))?, - (_, "delete" | "d") => self.sub = Sub::FitDelete, - (_, "kink" | "k") => self.sub = Sub::FitKink, - (_, "move" | "m") => { - self.mark = 0; - self.sub = Sub::FitMove; - } - (_, "purge" | "p") => { - self.apply(s, json!({ "option": "purge" }))?; - self.sub = Sub::Main; - } - (_, "tangents" | "t") if sp.closed => s.echo("A closed spline has no end tangents."), - (_, "tangents" | "t") => self.sub = Sub::FitStartTangent, - (_, "tolerance" | "l") => self.sub = Sub::FitTolerance, - (_, "") => {} - _ => return Err(other("Invalid option keyword.")), - }, + Sub::Fit => self.input_fit(s, &sp, enter, kw)?, Sub::FitAddPick => match point { Some(p) => { self.mark = nearest(&sp.fit, p).ok_or_else(|| other("The spline has no fit data."))?; @@ -806,6 +826,7 @@ impl Interactive for SplineditM { } Ok(Step::Continue) } + fn preview(&self, s: &Session, c: Vec2) -> Vec { let marked = matches!(self.sub, Sub::FitMove | Sub::VertexMove | Sub::VertexWeight | Sub::FitAddNew); let Some(v) = marked.then(|| self.marks(s).get(self.mark).copied()).flatten() else { return Vec::new() }; diff --git a/crates/engine/src/cmd/modify2/tests.rs b/crates/engine/src/cmd/modify2/tests.rs index 7c8f92625..98b2f40d9 100644 --- a/crates/engine/src/cmd/modify2/tests.rs +++ b/crates/engine/src/cmd/modify2/tests.rs @@ -148,6 +148,11 @@ fn pedit_command_line() { #[test] fn splinedit_json_and_command_line() { + splinedit_json_edits(); + splinedit_command_line_edits(); +} + +fn splinedit_json_edits() { let mut s = Session::new(); let sp = h(&s.execute("spline", &json!({"fit": [[0, 0], [2, 2], [4, 0], [6, 2]]})).unwrap()); s.execute("splinedit", &json!({"handle": sp, "option": "close"})).unwrap(); @@ -167,7 +172,9 @@ fn splinedit_json_and_command_line() { s.execute("splinedit", &json!({"handle": sp, "option": "polyline", "precision": 4})).unwrap(); assert!(matches!(kind(&s, &sp), EntityKind::LwPolyline(p) if p.vertices.len() > 4)); assert!(s.execute("splinedit", &json!({"handle": sp, "option": "close"})).is_err()); +} +fn splinedit_command_line_edits() { let mut s = Session::new(); s.execute("spline", &json!({"control": [[0, 0], [2, 3], [4, 0], [6, 3]]})).unwrap(); s.cmdline("splinedit 0,0 c").unwrap(); diff --git a/crates/engine/src/cmd/modify2/textedit.rs b/crates/engine/src/cmd/modify2/textedit.rs index d160d992f..10ca46245 100644 --- a/crates/engine/src/cmd/modify2/textedit.rs +++ b/crates/engine/src/cmd/modify2/textedit.rs @@ -1,4 +1,6 @@ -use super::*; +use super::{ + Accept, EntityKind, Handle, Input, Interactive, Prompt, Result, Session, Step, Value, bad, curves, json, other, set_kind, str_param, targets, +}; // ===================================================================================== // TEXTEDIT diff --git a/crates/engine/src/cmd/modify2/trimext.rs b/crates/engine/src/cmd/modify2/trimext.rs index f5258dc43..8a18e4a85 100644 --- a/crates/engine/src/cmd/modify2/trimext.rs +++ b/crates/engine/src/cmd/modify2/trimext.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Ellipse, EntityKind, Line, Result, Segment, TAU, Vec2, ccw_sweep, curve_edits, curves, intersect_ext, norm_angle, other, v3}; // ===================================================================================== // TRIM / EXTEND for ellipses and splines diff --git a/crates/engine/src/cmd/options.rs b/crates/engine/src/cmd/options.rs index 9dbeeddbf..b9a24580b 100644 --- a/crates/engine/src/cmd/options.rs +++ b/crates/engine/src/cmd/options.rs @@ -8,7 +8,7 @@ use serde_json::{Map, Value, json}; -use super::*; +use super::{CommandSpec, always, bad}; use crate::{Result, Session, Settings}; /// The profile variables, in the order [`profile`] lists them. diff --git a/crates/engine/src/cmd/plotters.rs b/crates/engine/src/cmd/plotters.rs index 370f03518..903ef1bc4 100644 --- a/crates/engine/src/cmd/plotters.rs +++ b/crates/engine/src/cmd/plotters.rs @@ -61,23 +61,13 @@ impl PlotterStore { } } - /// The `plotters` folder of the CADCraft settings directory (`CADCRAFT_CONFIG_DIR`, else - /// the platform's settings directory). + /// The `plotters` folder of the CADCraft settings directory ([`crate::settings_dir::current`]). #[cfg(not(target_arch = "wasm32"))] pub fn settings_folder() -> PlotterStore { fn dir() -> std::result::Result { - use std::path::PathBuf; - let get = |k: &str| std::env::var_os(k).filter(|v| !v.is_empty()).map(PathBuf::from); - let root = match std::env::var_os("CADCRAFT_CONFIG_DIR") { - Some(r) if !r.is_empty() => Some(PathBuf::from(r)), - Some(_) => None, - None => match std::env::consts::OS { - "macos" => get("HOME").map(|h| h.join("Library/Application Support/CADCraft")), - "windows" => get("APPDATA").map(|r| r.join("CADCraft")), - _ => get("XDG_CONFIG_HOME").map(|r| r.join("cadcraft")).or_else(|| get("HOME").map(|h| h.join(".config/cadcraft"))), - }, - }; - root.map(|r| r.join("plotters")).ok_or_else(|| "there is no settings folder for plotter configurations".to_string()) + crate::settings_dir::current() + .map(|r| r.join("plotters")) + .ok_or_else(|| "there is no settings folder for plotter configurations".to_string()) } /// A plain file name of ours (no separators, no parent references). fn file(n: &str) -> std::result::Result { diff --git a/crates/engine/src/cmd/props.rs b/crates/engine/src/cmd/props.rs index f9fbf2969..817ff77a2 100644 --- a/crates/engine/src/cmd/props.rs +++ b/crates/engine/src/cmd/props.rs @@ -216,212 +216,249 @@ fn run_set(s: &mut Session, p: &Value) -> Result { .transpose()?; let dim_over = dim_overrides(p)?; 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| { - // 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::set_annotative(e, a, &anno_scale); - } - if let Some(l) = str_param(p, "layer") { - e.common.layer = l.to_string(); - } - if let Some(c) = color { - e.common.color = c; - } - if let Some(lt) = &linetype { - e.common.linetype.clone_from(lt); - } - if let Some(w) = lw { - e.common.lineweight = w; - } - if let Some(x) = p.get("ltscale").and_then(Value::as_f64).filter(|x| *x > 0.0) { - e.common.ltscale = x; - } - if let Some(t) = transparency { - e.common.transparency = t; - } - if let Some(th) = thickness { - e.common.thickness = th; - } - if let Some(v) = p.get("visible").and_then(Value::as_bool) { - e.common.visible = v; - } - let num = |k: &str| p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite()); - match &mut e.kind { - EntityKind::Line(l) => { - if let Some(v) = p.get("start") { - set_xy(&mut l.a, v); - } - if let Some(v) = p.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) = p.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) = p.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(p, "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) = p.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(p, "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(); - } - } - EntityKind::LwPolyline(pl) => { - if let Some(x) = num("width").filter(|x| *x >= 0.0) { - pl.const_width = x; - } - if let Some(c) = p.get("closed").and_then(Value::as_bool) { - pl.closed = c; - } - } - EntityKind::Insert(i) => { - if let Some(x) = 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); - } - } - } - if let Some(x) = 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); - } - } - EntityKind::Dimension(dm) => { - if let Some(v) = str_param(p, "textOverride") { - dm.text = v.to_string(); - dm.block = None; - } - if let Some(st) = &dim_style { - dm.style.clone_from(st); - dm.block = None; - } - if !dim_over.is_empty() { - dm.overrides.extend(dim_over.clone()); - dm.block = None; - } - } - EntityKind::Hatch(h) => { - if let Some(v) = str_param(p, "pattern") { - if !h.pattern.eq_ignore_ascii_case(v) { - h.pattern_lines = super::hatch::lines_for(v); - } - h.pattern = v.to_ascii_uppercase(); - // The old pattern's definition lines no longer apply. - h.pattern_lines.clear(); - h.solid = h.pattern == "SOLID"; - if !h.solid { - // A named pattern replaces the gradient fill; the renderer draws the gradient first when it is set. - h.gradient = None; - } - } - if let Some(x) = num("scale").filter(|x| *x > 0.0) { - h.scale = x; - } - if let Some(x) = num("angle") { - h.angle = x.to_radians(); - } - } - _ => {} - } + set_common_properties(e, p, &common); + apply_kind_properties(e, p, dim_style.as_ref(), &dim_over); })?; } Ok(json!({ "changed": hs.len() })) } +fn apply_kind_properties( + entity: &mut cadcraft_doc::Entity, + params: &Value, + dim_style: Option<&String>, + dim_overrides: &serde_json::Map, +) { + 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(); + } + } + 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, +) { + 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, + linetype: Option<&'a str>, + lineweight: Option, + transparency: Option, + thickness: Option, +} + +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 { let c = p.get("color").and_then(parse_color).ok_or_else(|| bad("color", "`color` is required"))?; set_current_color(s.doc_mut()?, c); diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs index 8934df872..c70989a58 100644 --- a/crates/engine/src/doc_state.rs +++ b/crates/engine/src/doc_state.rs @@ -1,5 +1,5 @@ use super::view::{ModelTiles, View, usable_view}; -use super::*; +use super::{Arc, Drawing, Handle, Space, blockedit, undoctl}; #[derive(Clone, Debug)] pub struct Snapshot { diff --git a/crates/engine/src/grips.rs b/crates/engine/src/grips.rs index a7dee5b0b..a3b8921aa 100644 --- a/crates/engine/src/grips.rs +++ b/crates/engine/src/grips.rs @@ -119,74 +119,19 @@ pub fn stretch_grip(kind: &EntityKind, index: usize, to: Vec2) -> Option { - let g = Arc::new(a.center.xy(), a.radius, a.start, a.end); - let (mut s, mut m, mut e) = (g.start_point(), g.mid_point(), g.end_point()); - match index { - 0 => s = to, - 1 => m = to, - 2 => e = to, - _ => return Some(translated(kind, delta)), - } - let na = Arc::from_3_points(s, m, e)?; - return Some(crate::cmd::helpers::arc(&na)); + return stretch_arc(kind, a, index, to, delta); } EntityKind::Ellipse(e) => { - let c = e.center.xy(); - let mj = e.major.xy(); - let a = mj.len(); - if a <= EPS { + if e.major.xy().len() <= EPS { return None; } - let b = a * e.ratio; - match index { - 0 => return Some(translated(kind, delta)), - 1 | 3 => { - let v = if index == 1 { to - c } else { c - to }; - let l = v.len(); - if l <= EPS { - return None; - } - if l >= b { - e.major = v.to3(0.0); - e.ratio = (b / l).clamp(1e-9, 1.0); - } else { - e.major = (v.normalized().perp() * b).to3(0.0); - e.ratio = (l / b).clamp(1e-9, 1.0); - shift_params(e, -std::f64::consts::FRAC_PI_2); - } - } - _ => { - let u = mj / a; - let l = (to - c).dot(u.perp()).abs(); - if l <= EPS { - return None; - } - if l <= a { - e.ratio = (l / a).clamp(1e-9, 1.0); - } else { - e.major = (u.perp() * l).to3(0.0); - e.ratio = (a / l).clamp(1e-9, 1.0); - shift_params(e, -std::f64::consts::FRAC_PI_2); - } - } + if index == 0 { + return Some(translated(kind, delta)); } + stretch_ellipse(e, index, to)?; } EntityKind::LwPolyline(p) => { - let n = p.vertices.len(); - match poly_grip(p, index)? { - PolyGrip::Vertex(i) => p.vertices.get_mut(i)?.p = to, - PolyGrip::Mid(i) => { - let j = (i + 1) % n.max(1); - let (a, b) = (p.vertices.get(i)?.p, p.vertices.get(j)?.p); - if p.vertices.get(i)?.bulge.abs() > 1e-12 { - // Arc segment: reshape through the dragged midpoint. - p.vertices.get_mut(i)?.bulge = crate::cmd::curves::bulge_through(a, to, b); - } else { - p.vertices.get_mut(i)?.p = a + delta; - p.vertices.get_mut(j)?.p = b + delta; - } - } - } + stretch_polyline(p, index, to, delta)?; } EntityKind::Polyline3d(p) => set_xy(p.points.get_mut(index)?, to), EntityKind::Spline(sp) => { @@ -300,6 +245,86 @@ pub fn stretch_grip(kind: &EntityKind, index: usize, to: Vec2) -> Option Option { + let geometry = Arc::new(arc.center.xy(), arc.radius, arc.start, arc.end); + let (mut start, mut mid, mut end) = (geometry.start_point(), geometry.mid_point(), geometry.end_point()); + match index { + 0 => start = to, + 1 => mid = to, + 2 => end = to, + _ => return Some(translated(kind, delta)), + } + let adjusted = Arc::from_3_points(start, mid, end)?; + Some(crate::cmd::helpers::arc(&adjusted)) +} + +fn stretch_ellipse(ellipse: &mut cadcraft_doc::Ellipse, index: usize, to: Vec2) -> Option<()> { + let center = ellipse.center.xy(); + let major = ellipse.major.xy(); + let major_len = major.len(); + if major_len <= EPS { + return None; + } + let minor_len = major_len * ellipse.ratio; + match index { + 1 | 3 => stretch_ellipse_major(ellipse, index, to, center, minor_len)?, + _ => stretch_ellipse_minor(ellipse, to, center, major, major_len)?, + } + Some(()) +} + +fn stretch_ellipse_major(ellipse: &mut cadcraft_doc::Ellipse, index: usize, to: Vec2, center: Vec2, minor_len: f64) -> Option<()> { + let axis = if index == 1 { to - center } else { center - to }; + let len = axis.len(); + if len <= EPS { + return None; + } + if len >= minor_len { + ellipse.major = axis.to3(0.0); + ellipse.ratio = (minor_len / len).clamp(1e-9, 1.0); + } else { + ellipse.major = (axis.normalized().perp() * minor_len).to3(0.0); + ellipse.ratio = (len / minor_len).clamp(1e-9, 1.0); + shift_params(ellipse, -std::f64::consts::FRAC_PI_2); + } + Some(()) +} + +fn stretch_ellipse_minor(ellipse: &mut cadcraft_doc::Ellipse, to: Vec2, center: Vec2, major: Vec2, major_len: f64) -> Option<()> { + let unit = major / major_len; + let minor_len = (to - center).dot(unit.perp()).abs(); + if minor_len <= EPS { + return None; + } + if minor_len <= major_len { + ellipse.ratio = (minor_len / major_len).clamp(1e-9, 1.0); + } else { + ellipse.major = (unit.perp() * minor_len).to3(0.0); + ellipse.ratio = (major_len / minor_len).clamp(1e-9, 1.0); + shift_params(ellipse, -std::f64::consts::FRAC_PI_2); + } + Some(()) +} + +fn stretch_polyline(polyline: &mut LwPolyline, index: usize, to: Vec2, delta: Vec2) -> Option<()> { + let count = polyline.vertices.len(); + match poly_grip(polyline, index)? { + PolyGrip::Vertex(i) => polyline.vertices.get_mut(i)?.p = to, + PolyGrip::Mid(i) => { + let next = (i + 1) % count.max(1); + let (start, end) = (polyline.vertices.get(i)?.p, polyline.vertices.get(next)?.p); + if polyline.vertices.get(i)?.bulge.abs() > 1e-12 { + // Arc segment: reshape through the dragged midpoint. + polyline.vertices.get_mut(i)?.bulge = crate::cmd::curves::bulge_through(start, to, end); + } else { + polyline.vertices.get_mut(i)?.p = start + delta; + polyline.vertices.get_mut(next)?.p = end + delta; + } + } + } + Some(()) +} + fn shift_params(e: &mut cadcraft_doc::Ellipse, by: f64) { let full = (cadcraft_geom::ccw_sweep(e.start, e.end) - cadcraft_geom::TAU).abs() < 1e-9; if !full { diff --git a/crates/engine/src/grips/tests.rs b/crates/engine/src/grips/tests.rs index 39c43cd01..971937704 100644 --- a/crates/engine/src/grips/tests.rs +++ b/crates/engine/src/grips/tests.rs @@ -75,6 +75,18 @@ fn arc_and_ellipse_grips() { assert!(matches!(kind(&s, e), EntityKind::Ellipse(x) if (x.major.xy().len() - 8.0).abs() < 1e-9 && (x.ratio - 0.75).abs() < 1e-9)); } +#[test] +fn degenerate_ellipse_cannot_move_from_its_center_grip() { + let ellipse = EntityKind::Ellipse(cadcraft_doc::Ellipse { + center: cadcraft_geom::Vec3::ZERO, + major: cadcraft_geom::Vec3::ZERO, + ratio: 0.5, + start: 0.0, + end: cadcraft_geom::TAU, + }); + assert!(super::stretch_grip(&ellipse, 0, v(1.0, 1.0)).is_none()); +} + #[test] fn polyline_grips() { let mut s = Session::new(); diff --git a/crates/engine/src/last_used.rs b/crates/engine/src/last_used.rs index e984d9feb..73c610329 100644 --- a/crates/engine/src/last_used.rs +++ b/crates/engine/src/last_used.rs @@ -1,4 +1,4 @@ -use super::*; +use super::cmd; /// Options and values the interactive commands remember for the rest of the session, offered as /// the `` the next time they ask (as AutoCAD does). Values AutoCAD keeps in a drawing diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index caeda8d7d..dbb1d0e6b 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -29,6 +29,7 @@ pub mod prompt; mod recent; pub mod sample; pub mod select; +pub mod settings_dir; pub mod snap; pub mod spatial; pub mod sysvars; @@ -43,6 +44,7 @@ use serde::{Deserialize, Serialize}; use serde_json::Value; pub use cadcraft_doc as doc; +pub use cadcraft_fonts as fonts; pub use cadcraft_geom as geom; pub use cadcraft_render as render; pub use cmd::hatch::{HatchPicks, PatternChoice, PickMode, pattern_choices}; @@ -64,6 +66,14 @@ pub use running::{PendingWindow, Running}; pub use settings::Settings; pub use view::{ModelTile, ModelTiles, View}; +/// ` ()`, what `--version` prints after the program name in the app and the CLI. +/// The commit comes from `CADCRAFT_BUILD_SHA` at build time, `dev` without it. +pub fn build_version() -> &'static str { + static VERSION: std::sync::LazyLock = + std::sync::LazyLock::new(|| format!("{} ({})", env!("CARGO_PKG_VERSION"), option_env!("CADCRAFT_BUILD_SHA").unwrap_or("dev"))); + &VERSION +} + /// The editor session: open drawings, settings, the running command and the command log. pub struct Session { pub docs: Vec, diff --git a/crates/engine/src/lisp/builtins/args.rs b/crates/engine/src/lisp/builtins/args.rs index 9ac9c3427..1bb986cb3 100644 --- a/crates/engine/src/lisp/builtins/args.rs +++ b/crates/engine/src/lisp/builtins/args.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Arc, LispError, Value}; pub(super) type R = Result; diff --git a/crates/engine/src/lisp/builtins/files.rs b/crates/engine/src/lisp/builtins/files.rs index 6a1f90957..44452ae89 100644 --- a/crates/engine/src/lisp/builtins/files.rs +++ b/crates/engine/src/lisp/builtins/files.rs @@ -1,6 +1,6 @@ use super::args::{R, arity, string}; use super::output::emit; -use super::*; +use super::{Ctx, Flow, LispError, Value, charge_bytes}; // ---------------- files ---------------- @@ -73,17 +73,17 @@ pub(super) fn findfile(a: &[Value]) -> R { /// Read a regular text file up to 64 MiB, replacing invalid UTF-8 and returning `None` on read failure. #[cfg(not(target_arch = "wasm32"))] -pub fn read_text_file(path: &str) -> Option { +pub fn read_text_file(path: impl AsRef) -> Option { // Read through a byte-limited, regular-file-only reader so a path naming an endless device // cannot exhaust memory before the 64 MiB cap is enforced (CWE-400). const MAX: usize = 64 * 1024 * 1024; - let bytes = crate::capped_read::read_capped(std::path::Path::new(path), MAX).ok()?; + let bytes = crate::capped_read::read_capped(path.as_ref(), MAX).ok()?; Some(String::from_utf8_lossy(&bytes).into_owned()) } /// Return `None` on the web, where native filesystem paths are unavailable. #[cfg(target_arch = "wasm32")] -pub fn read_text_file(_path: &str) -> Option { +pub fn read_text_file(_path: impl AsRef) -> Option { None } diff --git a/crates/engine/src/lisp/builtins/functions.rs b/crates/engine/src/lisp/builtins/functions.rs index 2f53d1651..2f94218f3 100644 --- a/crates/engine/src/lisp/builtins/functions.rs +++ b/crates/engine/src/lisp/builtins/functions.rs @@ -1,5 +1,5 @@ use super::args::{R, arity, list_arg, string}; -use super::*; +use super::{Arc, Ctx, Flow, LispError, Sym, Value, read, to_text}; // ---------------- functions of functions ---------------- diff --git a/crates/engine/src/lisp/builtins/geometry.rs b/crates/engine/src/lisp/builtins/geometry.rs index 7de673666..059d64d3c 100644 --- a/crates/engine/src/lisp/builtins/geometry.rs +++ b/crates/engine/src/lisp/builtins/geometry.rs @@ -1,5 +1,5 @@ +use super::Value; use super::args::{R, arity, num, point}; -use super::*; // ---------------- geometry ---------------- diff --git a/crates/engine/src/lisp/builtins/lists.rs b/crates/engine/src/lisp/builtins/lists.rs index ea5a4fb2c..6975ed5e0 100644 --- a/crates/engine/src/lisp/builtins/lists.rs +++ b/crates/engine/src/lisp/builtins/lists.rs @@ -1,5 +1,5 @@ use super::args::{R, arity, int, list_arg, num, string}; -use super::*; +use super::{LispError, Value, eq, equal}; // ---------------- predicates and lists ---------------- diff --git a/crates/engine/src/lisp/builtins/numbers.rs b/crates/engine/src/lisp/builtins/numbers.rs index e1baa86f8..2dfb6911c 100644 --- a/crates/engine/src/lisp/builtins/numbers.rs +++ b/crates/engine/src/lisp/builtins/numbers.rs @@ -1,5 +1,5 @@ use super::args::{R, arity, int, num, real_or_int}; -use super::*; +use super::{LispError, Ordering, Value, eq}; // ---------------- numbers ---------------- diff --git a/crates/engine/src/lisp/builtins/output.rs b/crates/engine/src/lisp/builtins/output.rs index 21db3f87d..d64fd84e3 100644 --- a/crates/engine/src/lisp/builtins/output.rs +++ b/crates/engine/src/lisp/builtins/output.rs @@ -1,5 +1,5 @@ use super::args::{arity, string}; -use super::*; +use super::{Arc, Ctx, Flow, LispError, Sym, Value, charge_bytes, real_text, to_text}; // ---------------- output ---------------- diff --git a/crates/engine/src/lisp/builtins/strings.rs b/crates/engine/src/lisp/builtins/strings.rs index 08456d3ca..46d985bf1 100644 --- a/crates/engine/src/lisp/builtins/strings.rs +++ b/crates/engine/src/lisp/builtins/strings.rs @@ -1,5 +1,5 @@ use super::args::{R, arity, int, list_arg, string}; -use super::*; +use super::{LispError, OsStr, Value, check_string_len, read, to_text}; // ---------------- strings ---------------- diff --git a/crates/engine/src/lisp/builtins/wcmatch.rs b/crates/engine/src/lisp/builtins/wcmatch.rs index 1f171b253..441086b6e 100644 --- a/crates/engine/src/lisp/builtins/wcmatch.rs +++ b/crates/engine/src/lisp/builtins/wcmatch.rs @@ -1,5 +1,5 @@ use super::args::{R, arity, string}; -use super::*; +use super::{LispError, Value}; /// `wcmatch`: `#` a digit, `@` a letter, `.` neither, `*` any run, `?` any character, `~` (first) /// not, `[…]` a set (`[~…]` not in it, ranges `a-z`), `` ` `` the next character as is, `,` diff --git a/crates/engine/src/lisp/drawing.rs b/crates/engine/src/lisp/drawing.rs index b4076fce6..0042ea434 100644 --- a/crates/engine/src/lisp/drawing.rs +++ b/crates/engine/src/lisp/drawing.rs @@ -1097,5 +1097,5 @@ pub fn load_source(s: &Session, name: &str) -> Option { // As given (a path, or relative to the working folder), then in the support folder. let support = s.lisp_support_dir().map(|d| candidates.iter().map(|c| d.join(c).to_string_lossy().into_owned()).collect::>()).unwrap_or_default(); - candidates.iter().chain(&support).find_map(|c| super::builtins::read_text_file(c)) + candidates.iter().chain(&support).find_map(super::builtins::read_text_file) } diff --git a/crates/engine/src/lisp/startup.rs b/crates/engine/src/lisp/startup.rs index 118f4e7a1..392f88095 100644 --- a/crates/engine/src/lisp/startup.rs +++ b/crates/engine/src/lisp/startup.rs @@ -42,7 +42,7 @@ impl Session { if once && self.lisp.acad_loaded && !per_drawing { continue; } - let Some(text) = super::builtins::read_text_file(&dir.join(name).to_string_lossy()) else { continue }; + let Some(text) = super::builtins::read_text_file(dir.join(name)) else { continue }; if once { self.lisp.acad_loaded = true; } diff --git a/crates/engine/src/lisp/tests.rs b/crates/engine/src/lisp/tests.rs index a48c04eba..d65795631 100644 --- a/crates/engine/src/lisp/tests.rs +++ b/crates/engine/src/lisp/tests.rs @@ -106,46 +106,54 @@ fn equality_compares_symbols_as_autolisp_does() { #[test] fn lists_and_strings() { let mut s = session(); - assert_eq!(ok(&mut s, "(cons 1 '(2 3))"), "(1 2 3)"); - assert_eq!(ok(&mut s, "(cons 8 \"0\")"), "(8 . \"0\")"); - assert_eq!(ok(&mut s, "(cadr '(1 2 3))"), "2"); - assert_eq!(ok(&mut s, "(cdr (assoc 40 '((10 1.0 2.0 0.0) (40 . 2.5))))"), "2.5"); - assert_eq!(ok(&mut s, "(subst '(40 . 5.0) '(40 . 2.5) '((8 . \"0\") (40 . 2.5)))"), "((8 . \"0\") (40 . 5.0))"); - assert_eq!(ok(&mut s, "(append '(1) '(2 3) nil '(4))"), "(1 2 3 4)"); - assert_eq!(ok(&mut s, "(reverse '(1 2 3))"), "(3 2 1)"); - assert_eq!(ok(&mut s, "(nth 1 '(a b c))"), "B"); - assert_eq!(ok(&mut s, "(member 2 '(1 2 3))"), "(2 3)"); - assert_eq!(ok(&mut s, "(length '(1 2 3))"), "3"); - assert_eq!(ok(&mut s, "(last '(1 2 3))"), "3"); - assert_eq!(ok(&mut s, "(mapcar '+ '(1 2 3) '(10 20 30))"), "(11 22 33)"); - assert_eq!(ok(&mut s, "(mapcar '(lambda (x) (* x x)) '(1 2 3))"), "(1 4 9)"); - assert_eq!(ok(&mut s, "(apply 'max '(3 9 2))"), "9"); - assert_eq!(ok(&mut s, "(vl-sort '(3 1 2) '<)"), "(1 2 3)"); - assert_eq!(ok(&mut s, "(vl-sort '(3 1 2) (function (lambda (a b) (> a b))))"), "(3 2 1)"); - assert_eq!(ok(&mut s, "(vl-remove-if 'minusp '(1 -2 3))"), "(1 3)"); - assert_eq!(ok(&mut s, "(strcat \"a\" \"b\" \"c\")"), "\"abc\""); - assert_eq!(ok(&mut s, "(substr \"Hello\" 2 3)"), "\"ell\""); - assert_eq!(ok(&mut s, "(strcase \"abc\")"), "\"ABC\""); - assert_eq!(ok(&mut s, "(strlen \"abc\" \"de\")"), "5"); - assert_eq!(ok(&mut s, "(itoa 42)"), "\"42\""); - assert_eq!(ok(&mut s, "(atoi \"12abc\")"), "12"); - assert_eq!(ok(&mut s, "(atof \"2.5mm\")"), "2.5"); - assert_eq!(ok(&mut s, "(atof \"x\")"), "0.0"); - assert_eq!(ok(&mut s, "(wcmatch \"Name\" \"N*\")"), "T"); - assert_eq!(ok(&mut s, "(wcmatch \"A12\" \"@##\")"), "T"); - assert_eq!(ok(&mut s, "(wcmatch \"abc\" \"x*,a?c\")"), "T"); - assert_eq!(ok(&mut s, "(wcmatch \"abc\" \"~a*\")"), "nil"); - assert_eq!(ok(&mut s, "(wcmatch \"b\" \"[a-c]\")"), "T"); + list_builtins(&mut s); + string_builtins(&mut s); +} + +fn list_builtins(s: &mut Session) { + assert_eq!(ok(s, "(cons 1 '(2 3))"), "(1 2 3)"); + assert_eq!(ok(s, "(cons 8 \"0\")"), "(8 . \"0\")"); + assert_eq!(ok(s, "(cadr '(1 2 3))"), "2"); + assert_eq!(ok(s, "(cdr (assoc 40 '((10 1.0 2.0 0.0) (40 . 2.5))))"), "2.5"); + assert_eq!(ok(s, "(subst '(40 . 5.0) '(40 . 2.5) '((8 . \"0\") (40 . 2.5)))"), "((8 . \"0\") (40 . 5.0))"); + assert_eq!(ok(s, "(append '(1) '(2 3) nil '(4))"), "(1 2 3 4)"); + assert_eq!(ok(s, "(reverse '(1 2 3))"), "(3 2 1)"); + assert_eq!(ok(s, "(nth 1 '(a b c))"), "B"); + assert_eq!(ok(s, "(member 2 '(1 2 3))"), "(2 3)"); + assert_eq!(ok(s, "(length '(1 2 3))"), "3"); + assert_eq!(ok(s, "(last '(1 2 3))"), "3"); + assert_eq!(ok(s, "(mapcar '+ '(1 2 3) '(10 20 30))"), "(11 22 33)"); + assert_eq!(ok(s, "(mapcar '(lambda (x) (* x x)) '(1 2 3))"), "(1 4 9)"); + assert_eq!(ok(s, "(apply 'max '(3 9 2))"), "9"); + assert_eq!(ok(s, "(vl-sort '(3 1 2) '<)"), "(1 2 3)"); + assert_eq!(ok(s, "(vl-sort '(3 1 2) (function (lambda (a b) (> a b))))"), "(3 2 1)"); + assert_eq!(ok(s, "(vl-remove-if 'minusp '(1 -2 3))"), "(1 3)"); +} + +fn string_builtins(s: &mut Session) { + assert_eq!(ok(s, "(strcat \"a\" \"b\" \"c\")"), "\"abc\""); + assert_eq!(ok(s, "(substr \"Hello\" 2 3)"), "\"ell\""); + assert_eq!(ok(s, "(strcase \"abc\")"), "\"ABC\""); + assert_eq!(ok(s, "(strlen \"abc\" \"de\")"), "5"); + assert_eq!(ok(s, "(itoa 42)"), "\"42\""); + assert_eq!(ok(s, "(atoi \"12abc\")"), "12"); + assert_eq!(ok(s, "(atof \"2.5mm\")"), "2.5"); + assert_eq!(ok(s, "(atof \"x\")"), "0.0"); + assert_eq!(ok(s, "(wcmatch \"Name\" \"N*\")"), "T"); + assert_eq!(ok(s, "(wcmatch \"A12\" \"@##\")"), "T"); + assert_eq!(ok(s, "(wcmatch \"abc\" \"x*,a?c\")"), "T"); + assert_eq!(ok(s, "(wcmatch \"abc\" \"~a*\")"), "nil"); + assert_eq!(ok(s, "(wcmatch \"b\" \"[a-c]\")"), "T"); let many = format!("(wcmatch \"{}\" \"{}\")", "a".repeat(80), "*a".repeat(80)); - assert_eq!(ok(&mut s, &many), "T"); + assert_eq!(ok(s, &many), "T"); let too_deep = format!("(wcmatch \"{}\" \"{}\")", "a".repeat(400), "*a".repeat(400)); - assert!(eval(&mut s, &too_deep).is_err()); - assert_eq!(ok(&mut s, "(vl-string-subst \"X\" \"b\" \"abcb\")"), "\"aXcb\""); - assert_eq!(ok(&mut s, "(vl-string-search \"c\" \"abc\")"), "2"); - assert_eq!(ok(&mut s, "(read \"(1 2)\")"), "(1 2)"); - assert_eq!(ok(&mut s, "(type \"x\")"), "STR"); - assert_eq!(ok(&mut s, "(type 'x)"), "SYM"); - assert_eq!(ok(&mut s, "(equal '(1 2.0) '(1 2.0000001) 1e-3)"), "T"); + assert!(eval(s, &too_deep).is_err()); + assert_eq!(ok(s, "(vl-string-subst \"X\" \"b\" \"abcb\")"), "\"aXcb\""); + assert_eq!(ok(s, "(vl-string-search \"c\" \"abc\")"), "2"); + assert_eq!(ok(s, "(read \"(1 2)\")"), "(1 2)"); + assert_eq!(ok(s, "(type \"x\")"), "STR"); + assert_eq!(ok(s, "(type 'x)"), "SYM"); + assert_eq!(ok(s, "(equal '(1 2.0) '(1 2.0000001) 1e-3)"), "T"); } #[test] diff --git a/crates/engine/src/running.rs b/crates/engine/src/running.rs index afcd0b38f..4ff8ce429 100644 --- a/crates/engine/src/running.rs +++ b/crates/engine/src/running.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Arc, Drawing, Handle, Interactive, Serialize, Vec2}; /// An interactive command in progress. pub struct Running { diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index ef9bf8d73..d1ae67ee1 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -2,7 +2,10 @@ use super::doc_state::{DocState, Snapshot}; use super::error::{EngineError, Result}; use super::running::{PendingWindow, Running}; use super::view::View; -use super::*; +use super::{ + Arc, Bounds2, Drag, Drawing, Entity, Handle, Input, Prompt, Session, Space, Step, Value, Vec2, assoc, cmd, find_command, guard, lisp, pointmod, + prompt, select, snap, sysvars, units, +}; mod cmdline; mod execute; diff --git a/crates/engine/src/session/cmdline.rs b/crates/engine/src/session/cmdline.rs index 5a57e329e..7b9bd53a2 100644 --- a/crates/engine/src/session/cmdline.rs +++ b/crates/engine/src/session/cmdline.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{EngineError, Input, Result, Session, Value, Vec2, cmd, lisp, prompt, snap, units}; impl Session { /// Process one line typed at the command line (Enter pressed). Spaces separate inputs as in a diff --git a/crates/engine/src/session/execute.rs b/crates/engine/src/session/execute.rs index 165ec0863..7b0547404 100644 --- a/crates/engine/src/session/execute.rs +++ b/crates/engine/src/session/execute.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Arc, EngineError, Result, Session, Snapshot, Value, cmd, find_command}; impl Session { // ---------------- programmatic execution ---------------- diff --git a/crates/engine/src/session/files.rs b/crates/engine/src/session/files.rs index f0270c798..95d439f8c 100644 --- a/crates/engine/src/session/files.rs +++ b/crates/engine/src/session/files.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{DocState, Drawing, EngineError, Result, Session, Space, Value, Vec2, View, cmd}; impl Session { /// Append a new untitled drawing (`DrawingN`, metric or imperial default view), end a running command, make it active, bump the document epoch and return its index. diff --git a/crates/engine/src/session/interactive.rs b/crates/engine/src/session/interactive.rs index 335004349..e7cb07450 100644 --- a/crates/engine/src/session/interactive.rs +++ b/crates/engine/src/session/interactive.rs @@ -1,4 +1,7 @@ -use super::*; +use super::{ + Arc, Bounds2, Drag, Drawing, EngineError, Entity, Handle, Input, PendingWindow, Prompt, Result, Running, Session, Snapshot, Step, Value, Vec2, + assoc, cmd, find_command, guard, pointmod, select, snap, sysvars, +}; impl Session { // ---------------- interactive commands ---------------- diff --git a/crates/engine/src/session/picking.rs b/crates/engine/src/session/picking.rs index 2c7a61108..5646e8569 100644 --- a/crates/engine/src/session/picking.rs +++ b/crates/engine/src/session/picking.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Bounds2, Handle, Input, PendingWindow, Result, Session, Vec2, cmd, select}; impl Session { // ---------------- picking without a command ---------------- diff --git a/crates/engine/src/session/zoom.rs b/crates/engine/src/session/zoom.rs index 68be05a38..3936f3d14 100644 --- a/crates/engine/src/session/zoom.rs +++ b/crates/engine/src/session/zoom.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Bounds2, Result, Session, Space, Vec2, View}; impl Session { // ---------------- views ---------------- diff --git a/crates/engine/src/settings.rs b/crates/engine/src/settings.rs index de936b0c7..32507162f 100644 --- a/crates/engine/src/settings.rs +++ b/crates/engine/src/settings.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Deserialize, Serialize, Vec2, snap}; /// Session-level drafting settings. [`Session::drafting_settings`] supplies the active drawing's /// snap/grid spacing in the corresponding fields for UI and JSON consumers. diff --git a/crates/engine/src/settings_dir.rs b/crates/engine/src/settings_dir.rs new file mode 100644 index 000000000..689a5ade2 --- /dev/null +++ b/crates/engine/src/settings_dir.rs @@ -0,0 +1,82 @@ +//! The per-user CADCraft settings directory (logs, autosave, plotter configurations). The host +//! chooses it ([`set`], possibly to none); without a choice it is the platform's ([`platform`]). + +use std::ffi::OsString; +use std::path::PathBuf; +use std::sync::Mutex; + +/// `None`: no choice yet; `Some(None)`: the host chose to have no settings directory. +static CHOSEN: Mutex>> = Mutex::new(None); + +/// The platform's settings directory, with `var` looking up the OS variables: `$XDG_CONFIG_HOME/cadcraft` +/// or `~/.config/cadcraft` on Linux and the BSDs, `~/Library/Application Support/CADCraft` on +/// macOS, `%APPDATA%\CADCraft` on Windows. An empty variable counts as unset, so a blank value +/// never means the working directory. +pub fn platform(var: impl Fn(&str) -> Option) -> Option { + let set = |k: &str| var(k).filter(|v| !v.is_empty()).map(PathBuf::from); + if cfg!(target_os = "macos") { + set("HOME").map(|h| h.join("Library/Application Support/CADCraft")) + } else if cfg!(windows) { + set("APPDATA").map(|a| a.join("CADCraft")) + } else { + // The XDG spec ignores a relative XDG_CONFIG_HOME. + set("XDG_CONFIG_HOME").filter(|p| p.is_absolute()).or_else(|| set("HOME").map(|h| h.join(".config"))).map(|c| c.join("cadcraft")) + } +} + +/// Use `dir` as the settings directory; `None` means there is none (plotter configurations are +/// neither read nor written). +pub fn set(dir: Option) { + if let Ok(mut chosen) = CHOSEN.lock() { + *chosen = Some(dir); + } +} + +/// The settings directory: the host's choice, else the platform's. +pub fn current() -> Option { + match CHOSEN.lock().ok().and_then(|c| c.clone()) { + Some(choice) => choice, + None => platform(|k| std::env::var_os(k)), + } +} + +#[cfg(test)] +mod tests { + use super::platform; + use std::ffi::OsString; + use std::path::PathBuf; + + fn env<'a>(vars: &'a [(&'a str, &'a str)]) -> impl Fn(&str) -> Option + 'a { + move |k| vars.iter().find(|(n, _)| *n == k).map(|(_, v)| OsString::from(v)) + } + + #[test] + fn empty_values_are_unset() { + assert_eq!(platform(env(&[("HOME", ""), ("XDG_CONFIG_HOME", ""), ("APPDATA", "")])), None, "not the working directory"); + assert_eq!(platform(env(&[])), None); + } + + #[cfg(all(unix, not(target_os = "macos")))] + #[test] + fn linux_and_bsd_follow_xdg_config_home() { + assert_eq!(platform(env(&[("XDG_CONFIG_HOME", "/x"), ("HOME", "/home/u")])), Some(PathBuf::from("/x/cadcraft"))); + assert_eq!(platform(env(&[("HOME", "/home/u")])), Some(PathBuf::from("/home/u/.config/cadcraft"))); + // The XDG spec says a relative XDG_CONFIG_HOME is ignored. + assert_eq!(platform(env(&[("XDG_CONFIG_HOME", "rel"), ("HOME", "/home/u")])), Some(PathBuf::from("/home/u/.config/cadcraft"))); + } + + #[cfg(target_os = "macos")] + #[test] + fn macos_uses_application_support() { + assert_eq!(platform(env(&[("HOME", "/Users/u")])), Some(PathBuf::from("/Users/u/Library/Application Support/CADCraft"))); + } + + #[cfg(windows)] + #[test] + fn windows_uses_appdata() { + assert_eq!( + platform(env(&[("APPDATA", "C:\\Users\\u\\AppData\\Roaming")])), + Some(PathBuf::from("C:\\Users\\u\\AppData\\Roaming").join("CADCraft")) + ); + } +} diff --git a/crates/engine/src/snap.rs b/crates/engine/src/snap.rs index 956d919c7..8def404d2 100644 --- a/crates/engine/src/snap.rs +++ b/crates/engine/src/snap.rs @@ -588,101 +588,110 @@ impl Sink<'_> { } None => p, }; - let cands = &mut *self.cands; - match &p { - Prim::Seg(s) => { - if osmode & mode::END != 0 { - cands.push((mode::END, s.start())); - cands.push((mode::END, s.end())); - } - if osmode & mode::MID != 0 { - cands.push((mode::MID, s.mid())); - } - if let Segment::Arc { arc, .. } = s { - if osmode & mode::CEN != 0 { - cands.push((mode::CEN, arc.center)); - } - if osmode & mode::QUA != 0 { - for k in 0..4 { - let a = k as f64 * PI / 2.0; - if arc.contains_angle(a) { - cands.push((mode::QUA, Vec2::polar(arc.center, arc.radius, a))); - } - } - } - } - } - Prim::Circle(c) => { - if osmode & mode::CEN != 0 { - cands.push((mode::CEN, c.center)); - } - if osmode & mode::QUA != 0 { - for k in 0..4 { - cands.push((mode::QUA, Vec2::polar(c.center, c.radius, k as f64 * PI / 2.0))); - } - } - } - Prim::Ellipse(el) => { - if osmode & mode::CEN != 0 { - cands.push((mode::CEN, el.center)); - } - if osmode & mode::QUA != 0 { - // Only the quadrant points the arc passes through. - for k in 0..4 { - let t = k as f64 * PI / 2.0; - if cadcraft_geom::angle_in_sweep(t, el.start, el.end) { - cands.push((mode::QUA, el.at_param(t))); - } - } - } - if osmode & mode::END != 0 && !el.is_full() { - cands.push((mode::END, el.at_param(el.start))); - cands.push((mode::END, el.at_param(el.end))); - } - if osmode & mode::MID != 0 - && let Some(m) = curves::ellipse_mid(el) - { - cands.push((mode::MID, m)); - } - } - Prim::Spline(s) => { - if osmode & mode::END != 0 && !s.closed { - let (lo, hi) = s.domain(); - cands.push((mode::END, s.eval(lo))); - cands.push((mode::END, s.eval(hi))); - } - if osmode & mode::MID != 0 - && let Some(m) = curves::spline_mid(s) - { - cands.push((mode::MID, m)); - } - } - Prim::Point(pt) => { - if osmode & mode::NOD != 0 && matches!(kind, EntityKind::Point(_)) { - cands.push((mode::NOD, *pt)); - } - } - Prim::Infinite { base, .. } => { - if osmode & mode::END != 0 && matches!(kind, EntityKind::Ray(_)) { - cands.push((mode::END, *base)); - } - } - Prim::Fill(_) => {} - } - self.near.push(p); + self.primitive(kind, p); } if osmode & mode::GCEN != 0 { - // The centroid of the area a closed polyline or spline encloses. - let pts = match kind { - EntityKind::LwPolyline(pl) if pl.closed => { - cadcraft_geom::Polyline { vertices: pl.vertices.clone(), closed: true }.tessellate(self.aperture / 10.0) + self.closed_centroid(kind, &at); + } + } + + fn primitive(&mut self, kind: &EntityKind, p: Prim) { + let osmode = self.osmode; + let cands = &mut *self.cands; + match &p { + Prim::Seg(s) => { + if osmode & mode::END != 0 { + cands.push((mode::END, s.start())); + cands.push((mode::END, s.end())); + } + if osmode & mode::MID != 0 { + cands.push((mode::MID, s.mid())); + } + if let Segment::Arc { arc, .. } = s { + if osmode & mode::CEN != 0 { + cands.push((mode::CEN, arc.center)); + } + if osmode & mode::QUA != 0 { + for k in 0..4 { + let a = k as f64 * PI / 2.0; + if arc.contains_angle(a) { + cands.push((mode::QUA, Vec2::polar(arc.center, arc.radius, a))); + } + } + } } - EntityKind::Spline(s) if s.closed => s.tessellate(1e-3), - _ => Vec::new(), - }; - if let Some(c) = centroid(&pts) { - self.cands.push((mode::GCEN, at(c))); } + Prim::Circle(c) => { + if osmode & mode::CEN != 0 { + cands.push((mode::CEN, c.center)); + } + if osmode & mode::QUA != 0 { + for k in 0..4 { + cands.push((mode::QUA, Vec2::polar(c.center, c.radius, k as f64 * PI / 2.0))); + } + } + } + Prim::Ellipse(el) => { + if osmode & mode::CEN != 0 { + cands.push((mode::CEN, el.center)); + } + if osmode & mode::QUA != 0 { + // Only the quadrant points the arc passes through. + for k in 0..4 { + let t = k as f64 * PI / 2.0; + if cadcraft_geom::angle_in_sweep(t, el.start, el.end) { + cands.push((mode::QUA, el.at_param(t))); + } + } + } + if osmode & mode::END != 0 && !el.is_full() { + cands.push((mode::END, el.at_param(el.start))); + cands.push((mode::END, el.at_param(el.end))); + } + if osmode & mode::MID != 0 + && let Some(m) = curves::ellipse_mid(el) + { + cands.push((mode::MID, m)); + } + } + Prim::Spline(s) => { + if osmode & mode::END != 0 && !s.closed { + let (lo, hi) = s.domain(); + cands.push((mode::END, s.eval(lo))); + cands.push((mode::END, s.eval(hi))); + } + if osmode & mode::MID != 0 + && let Some(m) = curves::spline_mid(s) + { + cands.push((mode::MID, m)); + } + } + Prim::Point(pt) => { + if osmode & mode::NOD != 0 && matches!(kind, EntityKind::Point(_)) { + cands.push((mode::NOD, *pt)); + } + } + Prim::Infinite { base, .. } => { + if osmode & mode::END != 0 && matches!(kind, EntityKind::Ray(_)) { + cands.push((mode::END, *base)); + } + } + Prim::Fill(_) => {} + } + self.near.push(p); + } + + fn closed_centroid(&mut self, kind: &EntityKind, at: &impl Fn(Vec2) -> Vec2) { + // The centroid of the area a closed polyline or spline encloses. + let pts = match kind { + EntityKind::LwPolyline(pl) if pl.closed => { + cadcraft_geom::Polyline { vertices: pl.vertices.clone(), closed: true }.tessellate(self.aperture / 10.0) + } + EntityKind::Spline(s) if s.closed => s.tessellate(1e-3), + _ => Vec::new(), + }; + if let Some(c) = centroid(&pts) { + self.cands.push((mode::GCEN, at(c))); } } } diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rs index 9fd1e3f79..9f08b4fc5 100644 --- a/crates/engine/src/view.rs +++ b/crates/engine/src/view.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Deserialize, Serialize, Vec2}; /// A 2D view of a space: world centre and visible height in drawing units. #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] diff --git a/crates/engine/tests/read_file_unicode.rs b/crates/engine/tests/read_file_unicode.rs new file mode 100644 index 000000000..4c3c520e8 --- /dev/null +++ b/crates/engine/tests/read_file_unicode.rs @@ -0,0 +1,25 @@ +//! A drawing path that isn't valid Unicode is refused: the session keeps paths as text, so it +//! could never be saved back to. + +#![cfg(unix)] + +use std::ffi::OsString; +use std::os::unix::ffi::OsStringExt; + +use cadcraft_doc::Drawing; +use cadcraft_engine::cmd::file::{IoHooks, read_file, set_io}; + +#[test] +fn read_file_refuses_a_name_that_is_not_unicode() { + set_io(IoHooks { read: |_, _| Ok(Drawing::new_metric()), write: |_, _| Ok(Vec::new()), plot: None }); + let dir = std::env::temp_dir().join(format!("cadcraft-nonunicode-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let good = dir.join("good.dxf"); + let bad = dir.join(OsString::from_vec(b"bad-\xff.dxf".to_vec())); + std::fs::write(&good, b"0\nEOF\n").unwrap(); + std::fs::write(&bad, b"0\nEOF\n").unwrap(); + let e = read_file(&bad).err().expect("a non-Unicode name is refused"); + assert!(e.contains("not valid Unicode") && e.contains("bad-"), "{e}"); + assert!(read_file(&good).is_ok()); + let _ = std::fs::remove_dir_all(&dir); +} diff --git a/crates/engine/tests/xref.rs b/crates/engine/tests/xref.rs index 405f71c66..d53e37886 100644 --- a/crates/engine/tests/xref.rs +++ b/crates/engine/tests/xref.rs @@ -29,7 +29,7 @@ fn folder(tag: &str) -> PathBuf { } fn save(d: &Drawing, path: &Path) { - std::fs::write(path, cadcraft_io::write(d, &path.to_string_lossy()).unwrap()).unwrap(); + std::fs::write(path, cadcraft_io::write(d, path).unwrap()).unwrap(); } fn line(d: &mut Drawing, layer: &str, a: (f64, f64), b: (f64, f64)) { diff --git a/crates/fonts/src/mtext.rs b/crates/fonts/src/mtext.rs index 0c6cb074c..23736d017 100644 --- a/crates/fonts/src/mtext.rs +++ b/crates/fonts/src/mtext.rs @@ -537,6 +537,69 @@ pub fn layout_mtext(contents: &str, insert: Vec2, height: f64, width: f64, attac layout_mtext_with(contents, &MTextParams { insert, height, width, attach, rotation, line_spacing, ..MTextParams::new(insert, height) }) } +fn plain_lines(atoms: &[Atom], fmts: &[Fmt], base: &Fmt, width: f64) -> Vec { + let fmt = |index: usize| fmts.get(index).unwrap_or(base); + let mut lines = Vec::new(); + let mut line = Line::default(); + let mut pending_space = None; + let mut last_fmt = 0usize; + let mut paragraph = 0usize; + let finish = |lines: &mut Vec, line: &mut Line, format: &Fmt, paragraph: usize| { + if line.items.is_empty() { + line.max_h = format.height; + } + line.para = paragraph; + lines.push(std::mem::take(line)); + }; + + for atom in atoms { + match atom { + Atom::Space(format) => { + if !line.items.is_empty() || pending_space.is_some() { + pending_space = Some(*format); + } + last_fmt = *format; + } + Atom::Para(format) => { + pending_space = None; + finish(&mut lines, &mut line, fmt(*format), paragraph); + paragraph += 1; + last_fmt = *format; + } + Atom::Word(segments) => { + let word_width: f64 = segments.iter().map(|(segment, format)| seg_width(segment, fmt(*format))).sum(); + let space_width = + pending_space.map(|format| crate::space_width(&fmt(format).font, fmt(format).height, fmt(format).wf)).unwrap_or(0.0); + if width > 0.0 && !line.items.is_empty() && line.width + space_width + word_width > width + 1e-9 { + finish(&mut lines, &mut line, fmt(last_fmt), paragraph); + } else if !line.items.is_empty() || pending_space.is_some() { + if let Some(format) = pending_space { + let at = line.chars; + line.items.push(Item { seg: None, fmt: format, x: line.width, w: space_width, at }); + line.text.push(' '); + line.chars += 1; + } + line.width += space_width; + } + pending_space = None; + for (segment, format) in segments { + let segment_width = seg_width(segment, fmt(*format)); + line.max_h = line.max_h.max(fmt(*format).height); + let at = line.chars; + let plain = seg_plain(segment); + line.chars += plain.chars().count(); + line.text.push_str(&plain); + line.items.push(Item { seg: Some(segment.clone()), fmt: *format, x: line.width, w: segment_width, at }); + line.width += segment_width; + last_fmt = *format; + } + } + } + } + finish(&mut lines, &mut line, fmt(last_fmt), paragraph); + lines +} + /// Lay out MTEXT: inline formatting runs, stacked fractions, paragraphs, word wrap to the /// column width and the attachment point. pub fn layout_mtext_with(contents: &str, p: &MTextParams) -> MTextLayout { @@ -550,62 +613,7 @@ pub fn layout_mtext_with(contents: &str, p: &MTextParams) -> MTextLayout { return para::layout(contents, p, &base); } let fmt = |i: usize| fmts.get(i).unwrap_or(&base); - let mut lines: Vec = Vec::new(); - let mut line = Line::default(); - let mut pending_space: Option = None; - let mut last_fmt = 0usize; - let mut para = 0usize; - let finish = |lines: &mut Vec, line: &mut Line, f: &Fmt, para: usize| { - if line.items.is_empty() { - line.max_h = f.height; - } - line.para = para; - lines.push(std::mem::take(line)); - }; - for a in &atoms { - match a { - Atom::Space(f) => { - if !line.items.is_empty() || pending_space.is_some() { - pending_space = Some(*f); - } - last_fmt = *f; - } - Atom::Para(f) => { - pending_space = None; - finish(&mut lines, &mut line, fmt(*f), para); - para += 1; - last_fmt = *f; - } - Atom::Word(segs) => { - let ww: f64 = segs.iter().map(|(sg, f)| seg_width(sg, fmt(*f))).sum(); - let sw = pending_space.map(|f| crate::space_width(&fmt(f).font, fmt(f).height, fmt(f).wf)).unwrap_or(0.0); - if width > 0.0 && !line.items.is_empty() && line.width + sw + ww > width + 1e-9 { - finish(&mut lines, &mut line, fmt(last_fmt), para); - } else if !line.items.is_empty() || pending_space.is_some() { - if let Some(f) = pending_space { - let at = line.chars; - line.items.push(Item { seg: None, fmt: f, x: line.width, w: sw, at }); - line.text.push(' '); - line.chars += 1; - } - line.width += sw; - } - pending_space = None; - for (sg, f) in segs { - let fw = seg_width(sg, fmt(*f)); - line.max_h = line.max_h.max(fmt(*f).height); - let at = line.chars; - let plain = seg_plain(sg); - line.chars += plain.chars().count(); - line.text.push_str(&plain); - line.items.push(Item { seg: Some(sg.clone()), fmt: *f, x: line.width, w: fw, at }); - line.width += fw; - last_fmt = *f; - } - } - } - } - finish(&mut lines, &mut line, fmt(last_fmt), para); + let mut lines = plain_lines(&atoms, &fmts, &base, width); // Right-to-left text: each line in display order, its paragraph's direction from the // paragraph's first strong character. let mut bases: Vec> = Vec::new(); diff --git a/crates/fonts/src/mtext/para.rs b/crates/fonts/src/mtext/para.rs index d31f6a79d..064e62d02 100644 --- a/crates/fonts/src/mtext/para.rs +++ b/crates/fonts/src/mtext/para.rs @@ -402,6 +402,154 @@ fn split_tabs(segs: &[(Seg, usize)]) -> Vec { out } +struct LineBuilder<'a> { + paragraphs: &'a Paragraphs, + formats: &'a [Fmt], + base: &'a Fmt, + width: f64, + height: f64, + lines: Vec, + line: PLine, + paragraph: usize, + pending_space: Option, + last_format: usize, +} + +impl<'a> LineBuilder<'a> { + fn new(paragraphs: &'a Paragraphs, formats: &'a [Fmt], base: &'a Fmt, width: f64, height: f64) -> Self { + let first = paragraphs.props(0); + Self { + paragraphs, + formats, + base, + width, + height, + lines: Vec::new(), + line: PLine { width: (first.left + first.first).max(0.0), ..Default::default() }, + paragraph: 0, + pending_space: None, + last_format: 0, + } + } + + fn format(&self, index: usize) -> &Fmt { + self.formats.get(index).unwrap_or(self.base) + } + + fn build(mut self, atoms: &[Atom]) -> Vec { + for atom in atoms { + self.push_atom(atom); + } + self.finish(true, 0.0); + self.lines + } + + fn push_atom(&mut self, atom: &Atom) { + match atom { + Atom::Space(format) => { + if !self.line.items.is_empty() || self.pending_space.is_some() { + self.pending_space = Some(*format); + } + self.last_format = *format; + } + Atom::Para(format) => { + self.pending_space = None; + let next_start = self.first_start(self.paragraph + 1); + self.last_format = *format; + self.finish(true, next_start); + self.paragraph += 1; + } + Atom::Word(segments) => self.push_word(segments), + } + } + + fn first_start(&self, paragraph: usize) -> f64 { + let props = self.paragraphs.props(paragraph); + (props.left + props.first).max(0.0) + } + + fn finish(&mut self, paragraph_end: bool, next_start: f64) { + if self.line.items.is_empty() { + self.line.max_h = self.format(self.last_format).height; + } + self.line.para = self.paragraph; + self.line.para_end = paragraph_end; + let next = PLine { width: next_start, ..Default::default() }; + self.lines.push(std::mem::replace(&mut self.line, next)); + } + + fn push_word(&mut self, segments: &[(Seg, usize)]) { + let parts = split_tabs(segments); + for (index, part) in parts.iter().enumerate() { + match part { + Part::Tab => self.push_tab(&parts, index), + Part::Text(text) => self.push_text(index, text), + } + } + } + + fn push_tab(&mut self, parts: &[Part], index: usize) { + self.pending_space = None; + let (available, left) = { + let props = self.paragraphs.props(self.paragraph); + (self.available_width(props), props.left.max(0.0)) + }; + let (stop, kind) = next_tab(self.line.width, self.paragraphs.props(self.paragraph), self.height); + let next_width: f64 = match parts.get(index + 1) { + Some(Part::Text(segments)) => segments.iter().map(|(segment, format)| seg_width(segment, self.format(*format))).sum(), + _ => 0.0, + }; + let x = match kind { + TabKind::Left => stop, + TabKind::Center => (stop - next_width / 2.0).max(self.line.width), + TabKind::Right | TabKind::Decimal => (stop - next_width).max(self.line.width), + }; + if x > available + 1e-9 && !self.line.items.is_empty() { + self.finish(false, left); + } else { + self.line.width = x; + self.line.text.push(' '); + } + } + + fn push_text(&mut self, index: usize, segments: &[(Seg, usize)]) { + let word_width: f64 = segments.iter().map(|(segment, format)| seg_width(segment, self.format(*format))).sum(); + let space_width = if index == 0 { + self.pending_space + .map(|format| crate::space_width(&self.format(format).font, self.format(format).height, self.format(format).wf)) + .unwrap_or(0.0) + } else { + 0.0 + }; + let (available, left) = { + let props = self.paragraphs.props(self.paragraph); + (self.available_width(props), props.left.max(0.0)) + }; + if self.width > 0.0 && !self.line.items.is_empty() && self.line.width + space_width + word_width > available + 1e-9 { + self.finish(false, left); + } else if index == 0 && (!self.line.items.is_empty() || self.pending_space.is_some()) { + self.line.width += space_width; + if self.pending_space.is_some() { + self.line.text.push(' '); + self.line.gaps += 1; + } + } + self.pending_space = None; + for (segment, format) in segments { + let segment_width = seg_width(segment, self.format(*format)); + self.line.max_h = self.line.max_h.max(self.format(*format).height); + self.line.text.push_str(&seg_plain(segment)); + self.line.items.push(Item { seg: segment.clone(), fmt: *format, x: self.line.width, gap: self.line.gaps }); + self.line.width += segment_width; + self.last_format = *format; + } + } + + fn available_width(&self, props: &ParaProps) -> f64 { + if self.width > 0.0 { (self.width - props.right).max(0.0) } else { f64::INFINITY } + } +} + /// The next tab stop right of `x`: the paragraph's stops, the left indent of a hanging indent, /// then every [`DEFAULT_TAB`] text heights. fn next_tab(x: f64, pp: &ParaProps, h: f64) -> (f64, TabKind) { @@ -427,94 +575,7 @@ pub(super) fn layout(contents: &str, p: &MTextParams, base: &Fmt) -> MTextLayout let paras = Paragraphs::scan(contents); let (atoms, fmts) = parse(contents, base.clone()); let fmt = |i: usize| fmts.get(i).unwrap_or(base); - let space_w = |f: usize| crate::space_width(&fmt(f).font, fmt(f).height, fmt(f).wf); - - let mut lines: Vec = Vec::new(); - let mut k = 0usize; - let first_start = |k: usize| { - let pp = paras.props(k); - (pp.left + pp.first).max(0.0) - }; - let mut line = PLine { width: first_start(0), ..Default::default() }; - let mut pending_space: Option = None; - let mut last_fmt = 0usize; - let finish = |lines: &mut Vec, line: &mut PLine, f: &Fmt, k: usize, para_end: bool, next_start: f64| { - if line.items.is_empty() { - line.max_h = f.height; - } - line.para = k; - line.para_end = para_end; - let next = PLine { width: next_start, ..Default::default() }; - lines.push(std::mem::replace(line, next)); - }; - for a in &atoms { - let pp = paras.props(k); - let avail = if width > 0.0 { (width - pp.right).max(0.0) } else { f64::INFINITY }; - let left = pp.left.max(0.0); - match a { - Atom::Space(f) => { - if !line.items.is_empty() || pending_space.is_some() { - pending_space = Some(*f); - } - last_fmt = *f; - } - Atom::Para(f) => { - pending_space = None; - finish(&mut lines, &mut line, fmt(*f), k, true, first_start(k + 1)); - k += 1; - last_fmt = *f; - } - Atom::Word(segs) => { - let parts = split_tabs(segs); - for (pi, part) in parts.iter().enumerate() { - match part { - Part::Tab => { - pending_space = None; - let (stop, kind) = next_tab(line.width, pp, h); - let next_w: f64 = match parts.get(pi + 1) { - Some(Part::Text(s)) => s.iter().map(|(sg, f)| seg_width(sg, fmt(*f))).sum(), - _ => 0.0, - }; - let x = match kind { - TabKind::Left => stop, - TabKind::Center => (stop - next_w / 2.0).max(line.width), - TabKind::Right | TabKind::Decimal => (stop - next_w).max(line.width), - }; - if x > avail + 1e-9 && !line.items.is_empty() { - finish(&mut lines, &mut line, fmt(last_fmt), k, false, left); - } else { - line.width = x; - line.text.push(' '); - } - } - Part::Text(segs) => { - let ww: f64 = segs.iter().map(|(sg, f)| seg_width(sg, fmt(*f))).sum(); - let sw = if pi == 0 { pending_space.map(space_w).unwrap_or(0.0) } else { 0.0 }; - if width > 0.0 && !line.items.is_empty() && line.width + sw + ww > avail + 1e-9 { - finish(&mut lines, &mut line, fmt(last_fmt), k, false, left); - } else if pi == 0 && (!line.items.is_empty() || pending_space.is_some()) { - line.width += sw; - if pending_space.is_some() { - line.text.push(' '); - line.gaps += 1; - } - } - pending_space = None; - for (sg, f) in segs { - let fw = seg_width(sg, fmt(*f)); - line.max_h = line.max_h.max(fmt(*f).height); - line.text.push_str(&seg_plain(sg)); - line.items.push(Item { seg: sg.clone(), fmt: *f, x: line.width, gap: line.gaps }); - line.width += fw; - last_fmt = *f; - } - } - } - } - } - } - } - finish(&mut lines, &mut line, fmt(last_fmt), k, true, 0.0); + let lines = LineBuilder::new(¶s, &fmts, base, width, h).build(&atoms); // Vertical placement: baselines below the top of each line's column. let ls = if p.line_spacing > 0.0 && p.line_spacing.is_finite() { p.line_spacing } else { 1.0 }; @@ -634,6 +695,7 @@ mod tests { for (s, w, a) in [ ("the quick brown fox jumps over the lazy dog", 8.0, 1u8), ("one\\Ptwo\\P\\Pfour", 0.0, 5), + ("\\H3x;\\Psmall", 0.0, 1), ("alpha {\\H2x;beta} gamma delta", 6.0, 9), ("A{\\C1;B}C \\S1/2; x", 0.0, 2), (" lead spaces and\\P more", 5.0, 3), diff --git a/crates/fonts/src/ttf.rs b/crates/fonts/src/ttf.rs index 52998900c..6b4c5ebdd 100644 --- a/crates/fonts/src/ttf.rs +++ b/crates/fonts/src/ttf.rs @@ -11,8 +11,7 @@ //! - [`fallback_fonts`] (`FONTFALLBACK`): fonts tried first for characters the text's font //! lacks (CJK in an SHX big font, for example), before the automatic system font search. //! -//! On native builds both start from the `CADCRAFT_FONTALT` / `CADCRAFT_FONTFALLBACK` -//! environment variables. +//! Both start empty; the host sets its starting values ([`set_font_alt`], [`set_fallback_fonts`]). use std::collections::HashMap; use std::path::PathBuf; @@ -524,16 +523,8 @@ struct Prefs { } fn prefs() -> MutexGuard<'static, Prefs> { - static P: OnceLock> = OnceLock::new(); - P.get_or_init(|| { - #[cfg(not(target_arch = "wasm32"))] - let env = |k: &str| std::env::var(k).unwrap_or_default(); - #[cfg(target_arch = "wasm32")] - let env = |_: &str| String::new(); - Mutex::new(Prefs { alt: clean_name(&env("CADCRAFT_FONTALT")), fallback: split_list(&env("CADCRAFT_FONTFALLBACK")) }) - }) - .lock() - .unwrap_or_else(PoisonError::into_inner) + static P: Mutex = Mutex::new(Prefs { alt: String::new(), fallback: Vec::new() }); + P.lock().unwrap_or_else(PoisonError::into_inner) } /// A font name setting: trimmed, capped, "." = none. diff --git a/crates/io/src/dxf_raw.rs b/crates/io/src/dxf_raw.rs index 7fdf28232..a46443428 100644 --- a/crates/io/src/dxf_raw.rs +++ b/crates/io/src/dxf_raw.rs @@ -328,22 +328,10 @@ pub(crate) fn read(secs: &[Section], d: &mut Drawing) { let get = |name: &str| secs.iter().find(|s| s.name == name).map(|s| split(&s.tags)).unwrap_or_default(); let (classes, tables, blocks, entities, objects) = (get("CLASSES"), get("TABLES"), get("BLOCKS"), get("ENTITIES"), get("OBJECTS")); // The drawing's entities by handle: whether each is of a type CADCraft doesn't model. - let mut ents: HashMap = HashMap::new(); - for e in all_entities(d) { - ents.entry(e.handle.hex()).or_insert(matches!(e.kind, EntityKind::Unknown(_))); - } + let ents = entity_types(d); let ids = identities(&tables, &blocks, &objects); // Extension dictionaries of entities and records: owner → dictionary. - let mut xdict_of: HashMap = HashMap::new(); - for (kind, _, t) in tables.iter().chain(&blocks).chain(&entities) { - if kind == "ENDBLK" { - continue; - } - let h = head(t); - if let (Some(o), Some(x)) = (h.handle, h.xdict) { - xdict_of.entry(o).or_insert(x); - } - } + let xdict_of = extension_dictionaries(&tables, &blocks, &entities); // Objects by handle: the first of each, and none that has an entity's handle. let mut by_handle: HashMap = HashMap::new(); for (i, (_, _, t)) in objects.iter().enumerate() { @@ -361,48 +349,7 @@ pub(crate) fn read(secs: &[Section], d: &mut Drawing) { let (Some(h), Some(o)) = (hd.handle, hd.owner) else { return false }; !by_handle.contains_key(&o) && xdict_of.get(&o) == Some(&h) && (ents.contains_key(&o) || ids.contains_key(&o)) }; - let modelled_entry = |t: &[Tag], h: &str| entries(t).iter().any(|(k, eh)| eh == h && MODELLED_XDICT_KEYS.contains(&up(k).as_str())); - // Which objects to keep: those under a named object dictionary entry CADCraft doesn't model, - // under the extension dictionary of an entity or record (minus modelled entries; one left - // empty goes), or owned by an entity of a type CADCraft doesn't model. Memoized along each - // ownership chain; cycles and over-long chains are not kept. - let mut memo: HashMap = HashMap::new(); - for i in 0..objects.len() { - let mut path: Vec = Vec::new(); - let mut cur = i; - let verdict = loop { - if let Some(&v) = memo.get(&cur) { - break v; - } - if path.contains(&cur) || path.len() >= MAX_DEPTH { - break false; - } - path.push(cur); - let Some((_, _, t)) = objects.get(cur) else { break false }; - let hd = head(t); - let (Some(h), Some(o)) = (hd.handle, hd.owner) else { break false }; - if by_handle.get(&h) != Some(&cur) { - break false; - } - if Some(&o) == root.as_ref() { - break root_key(&h).is_some_and(|k| !modelled_key(&k)); - } - if let Some(&j) = by_handle.get(&o) { - if is_xdict(j) && objects.get(j).is_some_and(|p| modelled_entry(p.2, &h)) { - break false; - } - cur = j; - continue; - } - if is_xdict(cur) { - break entries(t).iter().any(|(k, _)| !MODELLED_XDICT_KEYS.contains(&up(k).as_str())); - } - break ents.get(&o) == Some(&true); - }; - for p in path { - memo.insert(p, verdict); - } - } + let memo = retained_objects(&objects, &ents, &ids, &by_handle, root.as_deref(), &root_entries, &xdict_of); let mut f = Foreign::default(); let mut kept: HashSet = HashSet::new(); for (i, (kind, _, t)) in objects.iter().enumerate() { @@ -511,6 +458,92 @@ pub(crate) fn read(secs: &[Section], d: &mut Drawing) { } } +fn entity_types(drawing: &Drawing) -> HashMap { + let mut types = HashMap::new(); + for entity in all_entities(drawing) { + types.entry(entity.handle.hex()).or_insert(matches!(entity.kind, EntityKind::Unknown(_))); + } + types +} + +fn extension_dictionaries( + tables: &[(String, usize, &[Tag])], + blocks: &[(String, usize, &[Tag])], + entities: &[(String, usize, &[Tag])], +) -> HashMap { + let mut dictionaries = HashMap::new(); + for (kind, _, tags) in tables.iter().chain(blocks).chain(entities) { + if kind == "ENDBLK" { + continue; + } + let header = head(tags); + if let (Some(owner), Some(dictionary)) = (header.handle, header.xdict) { + dictionaries.entry(owner).or_insert(dictionary); + } + } + dictionaries +} + +/// Determine which objects belong to unmodelled dictionary entries or owners. +fn retained_objects( + objects: &[(String, usize, &[Tag])], + entities: &HashMap, + records: &HashMap, + by_handle: &HashMap, + root: Option<&str>, + root_entries: &[(String, String)], + xdict_of: &HashMap, +) -> HashMap { + let root_key = |handle: &str| root_entries.iter().find(|(_, entry_handle)| entry_handle == handle).map(|(key, _)| key); + let is_xdict = |index: usize| { + let Some((_, _, tags)) = objects.get(index) else { return false }; + let header = head(tags); + let (Some(handle), Some(owner)) = (header.handle, header.owner) else { return false }; + !by_handle.contains_key(&owner) && xdict_of.get(&owner) == Some(&handle) && (entities.contains_key(&owner) || records.contains_key(&owner)) + }; + let modelled_entry = |tags: &[Tag], handle: &str| { + entries(tags).iter().any(|(key, entry_handle)| entry_handle == handle && MODELLED_XDICT_KEYS.contains(&up(key).as_str())) + }; + let mut retained = HashMap::new(); + for index in 0..objects.len() { + let mut path = Vec::new(); + let mut current = index; + let keep = loop { + if let Some(&known) = retained.get(¤t) { + break known; + } + if path.contains(¤t) || path.len() >= MAX_DEPTH { + break false; + } + path.push(current); + let Some((_, _, tags)) = objects.get(current) else { break false }; + let header = head(tags); + let (Some(handle), Some(owner)) = (header.handle, header.owner) else { break false }; + if by_handle.get(&handle) != Some(¤t) { + break false; + } + if root == Some(owner.as_str()) { + break root_key(&handle).is_some_and(|key| !modelled_key(key)); + } + if let Some(&parent) = by_handle.get(&owner) { + if is_xdict(parent) && objects.get(parent).is_some_and(|object| modelled_entry(object.2, &handle)) { + break false; + } + current = parent; + continue; + } + if is_xdict(current) { + break entries(tags).iter().any(|(key, _)| !MODELLED_XDICT_KEYS.contains(&up(key).as_str())); + } + break entities.get(&owner) == Some(&true); + }; + for visited in path { + retained.insert(visited, keep); + } + } + retained +} + /// Proxy records (DXF Reference, ACAD_PROXY_OBJECT and ACAD_PROXY_ENTITY): another application's /// objects and entities, whose class is named by number in group 91. fn is_proxy(kind: &str) -> bool { diff --git a/crates/io/src/dxf_read.rs b/crates/io/src/dxf_read.rs index 88d1801c3..1489f4def 100644 --- a/crates/io/src/dxf_read.rs +++ b/crates/io/src/dxf_read.rs @@ -3,7 +3,12 @@ use std::collections::HashMap; use cadcraft_color::{Color, Rgb}; -use cadcraft_doc::*; +use cadcraft_doc::{ + Arc, AssocSnap, Attrib, AttribModes, AttribProps, Block, Circle, Common, DashElement, DimAssoc, DimKind, DimStyle, Dimension, Drawing, Ellipse, + Entity, EntityKind, Face3d, Gradient, Group, HAlign, HVal, Handle, Hatch, HatchLoop, Helix, HelixConstrain, Insert, Layer, Layout, Leader, Line, + Linetype, Lineweight, LwPolyline, MAX_FRAME_CHARS, MLeaderStyle, MText, MultilineAttrib, NamedView, PageSetup, Point, Polyline3d, RawTag, + RayLine, Solid, Table, TableCell, Text, TextStyle, Tolerance, Transparency, Ucs, Unknown, VAlign, Viewport, VportConfig, VportTile, Wipeout, +}; use cadcraft_dxf::{Tag, records, sections}; use cadcraft_geom::{PolyVertex, Spline, Vec2, Vec3}; diff --git a/crates/io/src/dxf_read/common.rs b/crates/io/src/dxf_read/common.rs index 18e8edd8e..9cba18171 100644 --- a/crates/io/src/dxf_read/common.rs +++ b/crates/io/src/dxf_read/common.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Color, Common, Lineweight, Rgb, Tag, Transparency, Vec2, Vec3}; /// Value lookup helpers over an entity's tags. pub(super) struct T<'a>(pub(super) &'a [Tag]); diff --git a/crates/io/src/dxf_read/dimassoc.rs b/crates/io/src/dxf_read/dimassoc.rs index a6219c1d4..fb4fc5aa1 100644 --- a/crates/io/src/dxf_read/dimassoc.rs +++ b/crates/io/src/dxf_read/dimassoc.rs @@ -1,5 +1,5 @@ use super::common::T; -use super::*; +use super::{Arc, AssocSnap, Circle, DimAssoc, DimKind, Dimension, Drawing, EntityKind, Handle, Tag, Vec2, Vec3}; /// Associativity from a DIMASSOC object (files from other writers). The dimension kind decides /// which definition points the references name, in the order AutoCAD writes them: `p13`/`p14` diff --git a/crates/io/src/dxf_read/document.rs b/crates/io/src/dxf_read/document.rs index 245bda331..2e16afbf3 100644 --- a/crates/io/src/dxf_read/document.rs +++ b/crates/io/src/dxf_read/document.rs @@ -1,7 +1,7 @@ use super::common::T; use super::entities::{entity_extras, entity_plot_style, entity_with_table_budget, insert_attribs, polyline_entity}; use super::objects::{MAX_OBJECTS, Objects, page_setup}; -use super::*; +use super::{Block, BlockDef, Drawing, Entity, EntityKind, Handle, HashMap, Layout, LayoutDef, Rx, Tag, records}; pub(super) fn parse_entities( recs: &[(String, Vec)], diff --git a/crates/io/src/dxf_read/entities.rs b/crates/io/src/dxf_read/entities.rs index 9f0816d2a..aba1bdc4e 100644 --- a/crates/io/src/dxf_read/entities.rs +++ b/crates/io/src/dxf_read/entities.rs @@ -1,7 +1,11 @@ use super::common::{T, common, ocs}; use super::hatch::hatch; use super::text::{attdef, attrib_modes, attrib_props, mtext_from, multiline_attrib, split_embedded, text_from}; -use super::*; +use super::{ + Arc, Attrib, Circle, Common, DimKind, Dimension, Ellipse, EntityKind, Face3d, Handle, HashMap, Helix, HelixConstrain, Insert, Leader, Line, + LwPolyline, MAX_FRAME_CHARS, Point, PolyVertex, Polyline3d, RawTag, RayLine, Rx, Solid, Spline, Table, TableCell, Tag, Tolerance, Unknown, Vec2, + Vec3, Viewport, Wipeout, records, +}; /// Parse one entity record. POLYLINE/INSERT followers are handled by the caller. pub(super) fn entity(kind: &str, tags: &[Tag]) -> Option<(Common, EntityKind)> { diff --git a/crates/io/src/dxf_read/hatch.rs b/crates/io/src/dxf_read/hatch.rs index 18fe81531..13013a85d 100644 --- a/crates/io/src/dxf_read/hatch.rs +++ b/crates/io/src/dxf_read/hatch.rs @@ -1,5 +1,5 @@ use super::common::T; -use super::*; +use super::{Color, EntityKind, Gradient, Handle, Hatch, HatchLoop, PolyVertex, Rgb, Spline, Tag, Vec2}; pub(super) fn hatch(tags: &[Tag], t: &T) -> Option { let (origin, background) = hatch_xdata(tags); @@ -19,181 +19,11 @@ pub(super) fn hatch(tags: &[Tag], t: &T) -> Option { let flags = get(i)?.i64(); i += 1; let outer = flags & 1 != 0; - let mut verts: Vec = Vec::new(); - if flags & 2 != 0 { - // Polyline boundary: 72 has-bulge, 73 closed, 93 count, then 10/20/42. - let has_bulge = get(i).filter(|x| x.code == 72).map(Tag::i64).unwrap_or(0) != 0; - while get(i).is_some_and(|x| x.code != 93) { - i += 1; - } - let n = get(i)?.i64().clamp(0, 1_000_000) as usize; - i += 1; - for _ in 0..n { - let x = get(i).filter(|t| t.code == 10)?.f64(); - let y = get(i + 1).filter(|t| t.code == 20)?.f64(); - i += 2; - let mut b = 0.0; - if has_bulge && get(i).is_some_and(|t| t.code == 42) { - b = get(i)?.f64(); - i += 1; - } - verts.push(PolyVertex::with_bulge(Vec2::new(x, y), b)); - } - } else { - // Edge boundary: 93 edge count, each 72 edge type. - while get(i).is_some_and(|x| x.code != 93) { - i += 1; - } - let n = get(i)?.i64().clamp(0, 1_000_000) as usize; - i += 1; - for _ in 0..n { - while get(i).is_some_and(|x| x.code != 72) { - i += 1; - } - let ty = get(i)?.i64(); - i += 1; - let f = |i: usize| get(i).map(Tag::f64).unwrap_or(0.0); - match ty { - 1 => { - let a = Vec2::new(f(i), f(i + 1)); - let b = Vec2::new(f(i + 2), f(i + 3)); - i += 4; - if verts.last().is_none_or(|l| !l.p.near(a, 1e-9)) { - verts.push(PolyVertex::new(a)); - } - verts.push(PolyVertex::new(b)); - } - 2 => { - let c = Vec2::new(f(i), f(i + 1)); - let r = f(i + 2); - let sa = f(i + 3).to_radians(); - let ea = f(i + 4).to_radians(); - let ccw = get(i + 5).map(Tag::i64).unwrap_or(1) != 0; - i += 6; - let (s, e) = if ccw { (sa, ea) } else { (-sa, -ea) }; - let p0 = Vec2::polar(c, r, s); - let p1 = Vec2::polar(c, r, e); - let sweep = if ccw { cadcraft_geom::ccw_sweep(s, e) } else { -cadcraft_geom::ccw_sweep(e, s) }; - if verts.last().is_none_or(|l| !l.p.near(p0, 1e-9)) { - verts.push(PolyVertex::new(p0)); - } - // A full circle (0 to 360) starts and ends on the same point, which one - // bulge can't span: it goes in as two half circles. - let full = (sweep.abs() - std::f64::consts::TAU).abs() < 1e-9; - let bulge = cadcraft_geom::arc_to_bulge(if full { sweep / 2.0 } else { sweep }); - if let Some(l) = verts.last_mut() { - l.bulge = bulge; - } - if full { - verts.push(PolyVertex::with_bulge(Vec2::polar(c, r, s + sweep / 2.0), bulge)); - } - verts.push(PolyVertex::new(p1)); - } - 3 => { - // Elliptic arc: approximate with points. - let c = Vec2::new(f(i), f(i + 1)); - let m = Vec2::new(f(i + 2), f(i + 3)); - let ratio = f(i + 4); - let sa = f(i + 5).to_radians(); - let ea = f(i + 6).to_radians(); - let ccw = get(i + 7).filter(|t| t.code == 73).map(Tag::i64).unwrap_or(1) != 0; - i += 8; - // A clockwise edge stores its parameters mirrored, as an arc edge does: it - // runs from -start clockwise to -end, the ccw sweep from -end to -start - // walked backwards. - let (s, e) = if ccw { (sa, ea) } else { (-ea, -sa) }; - let e = cadcraft_geom::Ellipse { center: c, major: m, ratio, start: s, end: e }; - let mut pts = Vec::new(); - e.tessellate(m.len() * 1e-3, &mut pts); - if !ccw { - pts.reverse(); - } - verts.extend(pts.into_iter().map(PolyVertex::new)); - } - 4 => { - // Spline edge: 94 degree, 73 rational, 74 periodic, 95 knot count, 96 - // control point count, then the 40 knots, the 10/20 control points (each - // with a 42 weight when rational), and 97 fit point count with 11/21 fit - // points and 12/22, 13/23 end tangents (R2010+). - let (mut degree, mut nk, mut nc) = (3, 0, 0); - while let Some(x) = get(i).filter(|x| matches!(x.code, 94 | 73 | 74 | 95 | 96)) { - let n = x.i64().clamp(0, 100_000) as usize; - match x.code { - 94 => degree = n.clamp(1, 10), // same cap as the SPLINE reader - 95 => nk = n, - 96 => nc = n, - _ => {} - } - i += 1; - } - let mut knots = Vec::new(); - while knots.len() < nk && get(i).is_some_and(|x| x.code == 40) { - knots.push(f(i)); - i += 1; - } - let (mut control, mut weights) = (Vec::new(), Vec::new()); - while control.len() < nc && get(i).is_some_and(|x| x.code == 10) { - control.push(Vec2::new(f(i), f(i + 1))); - i += 2; - if get(i).is_some_and(|t| t.code == 42) { - weights.push(f(i)); - i += 1; - } - } - let mut fit = Vec::new(); - if get(i).is_some_and(|x| x.code == 97) { - let n = get(i).map(Tag::i64).unwrap_or(0).clamp(0, 100_000) as usize; - i += 1; - while fit.len() < n && get(i).is_some_and(|x| x.code == 11) { - fit.push(Vec2::new(f(i), f(i + 1))); - i += 2; - } - } - if weights.len() != control.len() { - weights.clear(); - } - let sp = Spline { degree, knots, control, weights, ..Spline::default() }; - let sp = if sp.is_valid() { - sp - } else if sp.control.is_empty() && fit.len() > 1 { - Spline::from_fit_points(&fit) - } else { - Spline::from_control(sp.control, degree) - }; - let pts = sp.tessellate(1e-3); - let skip = usize::from(verts.last().zip(pts.first()).is_some_and(|(l, p)| l.p.near(*p, 1e-9))); - verts.extend(pts.into_iter().skip(skip).map(PolyVertex::new)); - } - _ => {} - } - } - } + let mut verts = if flags & 2 != 0 { polyline_boundary(tags, &mut i)? } else { edge_boundary(tags, &mut i)? }; if verts.len() > 1 && verts.first().map(|f| f.p).zip(verts.last().map(|l| l.p)).is_some_and(|(a, b)| a.near(b, 1e-9)) { verts.pop(); } - // 97: number of source boundary objects, then their handles (330). A spline edge's fit - // data count is a 97 too, followed by its fit points instead. - let mut sources = Vec::new(); - for _ in 0..2 { - while get(i).is_some_and(|x| !matches!(x.code, 97 | 92 | 75)) { - i += 1; - } - if get(i).is_none_or(|x| x.code != 97) { - break; - } - let n = get(i).map(Tag::i64).unwrap_or(0).clamp(0, MAX_HATCH_SOURCES as i64) as usize; - i += 1; - if get(i).is_some_and(|x| !matches!(x.code, 330 | 92 | 75)) { - continue; - } - while sources.len() < n - && let Some(x) = get(i).filter(|x| x.code == 330) - { - sources.extend(Handle::parse_hex(&x.str()).filter(|h| h.0 != 0)); - i += 1; - } - break; - } + let sources = boundary_sources(tags, &mut i); loops.push(HatchLoop { vertices: verts, outer, sources }); } let solid = solid || pattern.eq_ignore_ascii_case("SOLID"); @@ -219,6 +49,191 @@ pub(super) fn hatch(tags: &[Tag], t: &T) -> Option { })) } +fn seek_code(tags: &[Tag], index: &mut usize, code: i32) { + while tags.get(*index).is_some_and(|tag| tag.code != code) { + *index += 1; + } +} + +fn polyline_boundary(tags: &[Tag], index: &mut usize) -> Option> { + let get = |i: usize| tags.get(i); + let has_bulge = get(*index).filter(|tag| tag.code == 72).map(Tag::i64).unwrap_or(0) != 0; + seek_code(tags, index, 93); + let count = get(*index)?.i64().clamp(0, 1_000_000) as usize; + *index += 1; + let mut vertices = Vec::new(); + for _ in 0..count { + let x = get(*index).filter(|tag| tag.code == 10)?.f64(); + let y = get(*index + 1).filter(|tag| tag.code == 20)?.f64(); + *index += 2; + let mut bulge = 0.0; + if has_bulge && get(*index).is_some_and(|tag| tag.code == 42) { + bulge = get(*index)?.f64(); + *index += 1; + } + vertices.push(PolyVertex::with_bulge(Vec2::new(x, y), bulge)); + } + Some(vertices) +} + +fn edge_boundary(tags: &[Tag], index: &mut usize) -> Option> { + let get = |i: usize| tags.get(i); + seek_code(tags, index, 93); + let count = get(*index)?.i64().clamp(0, 1_000_000) as usize; + *index += 1; + let mut vertices = Vec::new(); + for _ in 0..count { + seek_code(tags, index, 72); + let kind = get(*index)?.i64(); + *index += 1; + match kind { + 1 => line_edge(tags, index, &mut vertices), + 2 => circular_edge(tags, index, &mut vertices), + 3 => elliptic_edge(tags, index, &mut vertices), + 4 => spline_edge(tags, index, &mut vertices), + _ => {} + } + } + Some(vertices) +} + +fn edge_value(tags: &[Tag], index: usize) -> f64 { + tags.get(index).map(Tag::f64).unwrap_or(0.0) +} + +fn line_edge(tags: &[Tag], index: &mut usize, vertices: &mut Vec) { + let start = Vec2::new(edge_value(tags, *index), edge_value(tags, *index + 1)); + let end = Vec2::new(edge_value(tags, *index + 2), edge_value(tags, *index + 3)); + *index += 4; + if vertices.last().is_none_or(|last| !last.p.near(start, 1e-9)) { + vertices.push(PolyVertex::new(start)); + } + vertices.push(PolyVertex::new(end)); +} + +fn circular_edge(tags: &[Tag], index: &mut usize, vertices: &mut Vec) { + let center = Vec2::new(edge_value(tags, *index), edge_value(tags, *index + 1)); + let radius = edge_value(tags, *index + 2); + let start_angle = edge_value(tags, *index + 3).to_radians(); + let end_angle = edge_value(tags, *index + 4).to_radians(); + let ccw = tags.get(*index + 5).map(Tag::i64).unwrap_or(1) != 0; + *index += 6; + let (start, end) = if ccw { (start_angle, end_angle) } else { (-start_angle, -end_angle) }; + let start_point = Vec2::polar(center, radius, start); + let end_point = Vec2::polar(center, radius, end); + let sweep = if ccw { cadcraft_geom::ccw_sweep(start, end) } else { -cadcraft_geom::ccw_sweep(end, start) }; + if vertices.last().is_none_or(|last| !last.p.near(start_point, 1e-9)) { + vertices.push(PolyVertex::new(start_point)); + } + // A full circle needs two bulges because one bulge cannot span coincident endpoints. + let full = (sweep.abs() - std::f64::consts::TAU).abs() < 1e-9; + let bulge = cadcraft_geom::arc_to_bulge(if full { sweep / 2.0 } else { sweep }); + if let Some(last) = vertices.last_mut() { + last.bulge = bulge; + } + if full { + vertices.push(PolyVertex::with_bulge(Vec2::polar(center, radius, start + sweep / 2.0), bulge)); + } + vertices.push(PolyVertex::new(end_point)); +} + +fn elliptic_edge(tags: &[Tag], index: &mut usize, vertices: &mut Vec) { + let center = Vec2::new(edge_value(tags, *index), edge_value(tags, *index + 1)); + let major = Vec2::new(edge_value(tags, *index + 2), edge_value(tags, *index + 3)); + let ratio = edge_value(tags, *index + 4); + let start_angle = edge_value(tags, *index + 5).to_radians(); + let end_angle = edge_value(tags, *index + 6).to_radians(); + let ccw = tags.get(*index + 7).filter(|tag| tag.code == 73).map(Tag::i64).unwrap_or(1) != 0; + *index += 8; + let (start, end) = if ccw { (start_angle, end_angle) } else { (-end_angle, -start_angle) }; + let ellipse = cadcraft_geom::Ellipse { center, major, ratio, start, end }; + let mut points = Vec::new(); + ellipse.tessellate(major.len() * 1e-3, &mut points); + if !ccw { + points.reverse(); + } + vertices.extend(points.into_iter().map(PolyVertex::new)); +} + +fn spline_edge(tags: &[Tag], index: &mut usize, vertices: &mut Vec) { + let get = |i: usize| tags.get(i); + let mut degree = 3; + let (mut knot_count, mut control_count) = (0, 0); + while let Some(tag) = get(*index).filter(|tag| matches!(tag.code, 94 | 73 | 74 | 95 | 96)) { + let count = tag.i64().clamp(0, 100_000) as usize; + match tag.code { + 94 => degree = count.clamp(1, 10), + 95 => knot_count = count, + 96 => control_count = count, + _ => {} + } + *index += 1; + } + let mut knots = Vec::new(); + while knots.len() < knot_count && get(*index).is_some_and(|tag| tag.code == 40) { + knots.push(edge_value(tags, *index)); + *index += 1; + } + let (mut control, mut weights) = (Vec::new(), Vec::new()); + while control.len() < control_count && get(*index).is_some_and(|tag| tag.code == 10) { + control.push(Vec2::new(edge_value(tags, *index), edge_value(tags, *index + 1))); + *index += 2; + if get(*index).is_some_and(|tag| tag.code == 42) { + weights.push(edge_value(tags, *index)); + *index += 1; + } + } + let mut fit = Vec::new(); + if get(*index).is_some_and(|tag| tag.code == 97) { + let count = get(*index).map(Tag::i64).unwrap_or(0).clamp(0, 100_000) as usize; + *index += 1; + while fit.len() < count && get(*index).is_some_and(|tag| tag.code == 11) { + fit.push(Vec2::new(edge_value(tags, *index), edge_value(tags, *index + 1))); + *index += 2; + } + } + if weights.len() != control.len() { + weights.clear(); + } + let spline = Spline { degree, knots, control, weights, ..Spline::default() }; + let spline = if spline.is_valid() { + spline + } else if spline.control.is_empty() && fit.len() > 1 { + Spline::from_fit_points(&fit) + } else { + Spline::from_control(spline.control, degree) + }; + let points = spline.tessellate(1e-3); + let skip = usize::from(vertices.last().zip(points.first()).is_some_and(|(last, point)| last.p.near(*point, 1e-9))); + vertices.extend(points.into_iter().skip(skip).map(PolyVertex::new)); +} + +fn boundary_sources(tags: &[Tag], index: &mut usize) -> Vec { + let get = |i: usize| tags.get(i); + let mut sources = Vec::new(); + for _ in 0..2 { + while get(*index).is_some_and(|tag| !matches!(tag.code, 97 | 92 | 75)) { + *index += 1; + } + if get(*index).is_none_or(|tag| tag.code != 97) { + break; + } + let count = get(*index).map(Tag::i64).unwrap_or(0).clamp(0, MAX_HATCH_SOURCES as i64) as usize; + *index += 1; + if get(*index).is_some_and(|tag| !matches!(tag.code, 330 | 92 | 75)) { + continue; + } + while sources.len() < count + && let Some(tag) = get(*index).filter(|tag| tag.code == 330) + { + sources.extend(Handle::parse_hex(&tag.str()).filter(|handle| handle.0 != 0)); + *index += 1; + } + break; + } + sources +} + /// Upper bound on the source boundary objects of one HATCH loop. const MAX_HATCH_SOURCES: usize = 4096; diff --git a/crates/io/src/dxf_read/objects.rs b/crates/io/src/dxf_read/objects.rs index 97b30c786..4d692ccee 100644 --- a/crates/io/src/dxf_read/objects.rs +++ b/crates/io/src/dxf_read/objects.rs @@ -1,7 +1,7 @@ use super::common::T; use super::dimassoc::dimassoc; use super::document::sortents_table; -use super::*; +use super::{Drawing, EntityKind, Group, Handle, HashMap, MLeaderStyle, PageSetup, Rx, Tag, Vec2}; /// Non-graphical objects applied once every entity is placed. #[derive(Default)] diff --git a/crates/io/src/dxf_read/tables.rs b/crates/io/src/dxf_read/tables.rs index 9419a081e..8a57f7f9e 100644 --- a/crates/io/src/dxf_read/tables.rs +++ b/crates/io/src/dxf_read/tables.rs @@ -1,6 +1,9 @@ use super::common::T; use super::objects::MAX_OBJECTS; -use super::*; +use super::{ + Color, DashElement, DimStyle, Drawing, HVal, HashMap, Layer, Linetype, Lineweight, NamedView, Rgb, Rx, Tag, TextStyle, Ucs, Vec2, Vec3, + VportConfig, VportTile, records, +}; pub(super) fn header(tags: &[Tag], d: &mut Drawing) { let mut i = 0; @@ -99,30 +102,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) { }) .collect(); // Handle maps first: DIMSTYLE records refer to text styles and arrow blocks by handle. - for (kind, tg) in &recs { - let t = T(tg); - let (Some(h), Some(n)) = (t.s(5), t.s(2)) else { continue }; - match kind.as_str() { - "STYLE" => { - rx.styles.insert(h.trim().to_ascii_uppercase(), n); - } - "BLOCK_RECORD" => { - let units = t.i(70).and_then(|u| u8::try_from(u).ok()).unwrap_or(0); - rx.block_props.insert(n.to_ascii_uppercase(), (units, t.i(280).unwrap_or(1) != 0)); - if let Some(a) = crate::dxf_ext::read_array(tg) { - rx.block_arrays.insert(n.to_ascii_uppercase(), a); - } - rx.brs.insert(h.trim().to_ascii_uppercase(), n); - } - "LTYPE" => { - rx.ltypes.insert(h.trim().to_ascii_uppercase(), n); - } - "LAYER" => { - rx.layers.insert(h.trim().to_ascii_uppercase(), n); - } - _ => {} - } - } + index_table_handles(&recs, rx); let mut active_vport = false; // Index of layers already appended, by lower-cased name, so each LAYER record updates or // appends in O(1) instead of scanning the growing layer list — otherwise many distinct layer @@ -300,6 +280,33 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) { d.vports.retain(|c| c.tiles.len() > usize::from(c.is_active())); } +fn index_table_handles(recs: &[(String, Vec)], rx: &mut Rx) { + for (kind, tags) in recs { + let table = T(tags); + let (Some(handle), Some(name)) = (table.s(5), table.s(2)) else { continue }; + match kind.as_str() { + "STYLE" => { + rx.styles.insert(handle.trim().to_ascii_uppercase(), name); + } + "BLOCK_RECORD" => { + let units = table.i(70).and_then(|units| u8::try_from(units).ok()).unwrap_or(0); + rx.block_props.insert(name.to_ascii_uppercase(), (units, table.i(280).unwrap_or(1) != 0)); + if let Some(array) = crate::dxf_ext::read_array(tags) { + rx.block_arrays.insert(name.to_ascii_uppercase(), array); + } + rx.brs.insert(handle.trim().to_ascii_uppercase(), name); + } + "LTYPE" => { + rx.ltypes.insert(handle.trim().to_ascii_uppercase(), name); + } + "LAYER" => { + rx.layers.insert(handle.trim().to_ascii_uppercase(), name); + } + _ => {} + } + } +} + /// Most tiles a viewport configuration keeps. const MAX_VPORT_TILES: usize = 64; diff --git a/crates/io/src/dxf_read/text.rs b/crates/io/src/dxf_read/text.rs index 45ee2f003..10d770c0e 100644 --- a/crates/io/src/dxf_read/text.rs +++ b/crates/io/src/dxf_read/text.rs @@ -1,5 +1,5 @@ use super::common::{T, common, ocs_n}; -use super::*; +use super::{Attrib, AttribModes, AttribProps, Common, HAlign, MText, MultilineAttrib, Tag, Text, VAlign, Vec2, Vec3, mtext_dxf}; /// The properties an ATTRIB carries itself: those it has groups for. Its layer counts only when /// it differs from its block reference's (an attribute defined on layer 0 goes on the reference's diff --git a/crates/io/src/dxf_write.rs b/crates/io/src/dxf_write.rs index 75360ebae..4ec9fc636 100644 --- a/crates/io/src/dxf_write.rs +++ b/crates/io/src/dxf_write.rs @@ -6,7 +6,11 @@ use std::collections::HashMap; use cadcraft_color::Color; -use cadcraft_doc::*; +use cadcraft_doc::{ + AssocSnap, Attrib, Block, Common, DimAssoc, DimKind, DimStyle, Dimension, Drawing, Entity, EntityKind, EntityStore, Gradient, Group, HAlign, + HVal, Handle, Hatch, Insert, Layout, Leader, Line, Lineweight, LwPolyline, MLeader, MLeaderStyle, MText, PageSetup, Point, Solid, Space, Table, + TableStyle, Text, Transparency, VAlign, VportConfig, VportTile, +}; use cadcraft_dxf::{Tag, Version}; use cadcraft_geom::{Bounds2, Vec2, Vec3}; diff --git a/crates/io/src/dxf_write/assoc.rs b/crates/io/src/dxf_write/assoc.rs index 9d9a607aa..45a14df22 100644 --- a/crates/io/src/dxf_write/assoc.rs +++ b/crates/io/src/dxf_write/assoc.rs @@ -1,5 +1,5 @@ use super::ctx::OsnapRef; -use super::*; +use super::{AssocSnap, DimAssoc, DimKind, Dimension, Drawing, EntityKind, LwPolyline}; /// Whether a DIMASSOC point reference to `k` names a point of it without naming a segment: /// true for objects made of one curve. Polylines are referenced by segment ([`polyline_vertex_ref`]); diff --git a/crates/io/src/dxf_write/blocks.rs b/crates/io/src/dxf_write/blocks.rs index 6514d49bc..2de1400cf 100644 --- a/crates/io/src/dxf_write/blocks.rs +++ b/crates/io/src/dxf_write/blocks.rs @@ -1,4 +1,6 @@ -use super::*; +use super::{ + Block, Color, Common, Dimension, Drawing, Entity, EntityKind, EntityStore, Handle, HashMap, Line, MText, Solid, Table, Vec2, Vec3, dxf_ext, +}; /// What happens to the anonymous `*D` blocks read from a file (#495): a dimension that still /// names its block regenerates its geometry under that name, keeping the block's entity diff --git a/crates/io/src/dxf_write/common.rs b/crates/io/src/dxf_write/common.rs index 91e00d888..bf8fad449 100644 --- a/crates/io/src/dxf_write/common.rs +++ b/crates/io/src/dxf_write/common.rs @@ -1,5 +1,8 @@ use super::ctx::{AssocObj, Ctx}; -use super::*; +use super::{ + Attrib, Color, Common, DimKind, DimStyle, Dimension, Drawing, Entity, EntityKind, HAlign, HashMap, Insert, Lineweight, Text, Transparency, + VAlign, Vec3, Version, W, dxf_ext, +}; /// `AcadAnnotative` xdata marking an annotative style. pub(super) fn annotative_xdata(w: &mut W) { diff --git a/crates/io/src/dxf_write/ctx.rs b/crates/io/src/dxf_write/ctx.rs index 11c679a95..ce9c38b7a 100644 --- a/crates/io/src/dxf_write/ctx.rs +++ b/crates/io/src/dxf_write/ctx.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{DimVal, Handle, HashMap, K, Vec3, Version, dxf_ext}; /// The `DIMASSOC` object of an associative dimension (stored in the dimension's extension /// dictionary under `ACAD_DIMASSOC`). diff --git a/crates/io/src/dxf_write/entity.rs b/crates/io/src/dxf_write/entity.rs index 6c58cdfac..cd41cdf91 100644 --- a/crates/io/src/dxf_write/entity.rs +++ b/crates/io/src/dxf_write/entity.rs @@ -2,7 +2,9 @@ use super::blocks::table_size; use super::common::{attrib_common, common, common_x, dim_xdata, layer_and_props, multiline_tags, oblique_52, text_tags}; use super::ctx::Ctx; use super::layout::paper_view; -use super::*; +use super::{ + Bounds2, Color, DimKind, Drawing, Entity, EntityKind, Gradient, Handle, HashMap, Hatch, Leader, MLeader, Point, Vec2, Vec3, Version, W, dxf_ext, +}; /// The persistent reactors of boundary objects: each source object of an associative hatch in /// the same space or block → the hatches it bounds (AutoCAD links the two both ways; without the @@ -31,6 +33,19 @@ pub(super) fn hatch_reactors(d: &Drawing) -> HashMap> { } pub(super) fn entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + write_basic_entity(w, d, e, owner, paper, cx); + write_text_entity(w, d, e, owner, paper, cx); + write_insert_entity(w, d, e, owner, paper, cx); + write_dimension_entity(w, d, e, owner, paper, cx); + write_table_entity(w, d, e, owner, paper, cx); + write_annotations_entity(w, d, e, owner, paper, cx); + write_hatch_entity(w, d, e, owner, paper, cx); + write_viewport_entity(w, d, e, owner, paper, cx); + write_wipeout_entity(w, d, e, owner, paper, cx); + write_other_entity(w, d, e, owner, paper, cx); +} + +fn write_basic_entity(w: &mut W, _d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { match &e.kind { EntityKind::Line(l) => { w.s(0, "LINE"); @@ -199,6 +214,12 @@ pub(super) fn entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: boo w.p(10, r.base); w.p(11, r.dir); } + _ => {} + } +} + +fn write_text_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + match &e.kind { EntityKind::Text(t) => { w.s(0, "TEXT"); common(w, e, owner, paper, "AcDbText"); @@ -255,196 +276,211 @@ pub(super) fn entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: boo w.f(44, t.line_spacing); w.t.extend(crate::dxf_read::mtext_dxf::column_tags(t)); } - EntityKind::Insert(i) => { - w.s(0, "INSERT"); - common(w, e, owner, paper, "AcDbBlockReference"); - if !i.attribs.is_empty() { - w.i(66, 1); - } - w.s(2, &i.block); - w.p(10, i.insert); - w.f(41, i.scale.x); - w.f(42, i.scale.y); - w.f(43, i.scale.z); - w.f(50, i.rotation.to_degrees()); - if i.cols > 1 || i.rows > 1 { - w.i(70, i64::from(i.cols)); - w.i(71, i64::from(i.rows)); - w.f(44, i.col_spacing); - w.f(45, i.row_spacing); - } - if !i.attribs.is_empty() { - for a in &i.attribs { - let ah = w.h(); - w.s(0, "ATTRIB"); - w.s(5, ah); - w.s(330, e.handle.hex()); - w.s(100, "AcDbEntity"); - let (c, base) = attrib_common(d, e, i, a); - layer_and_props(w, &c, Some(&base)); - // Hidden with its definition (a dynamic block's visibility state hides it). - if !base.visible { - w.i(60, 1); - } - w.s(100, "AcDbText"); - text_tags(w, d, &a.text, Some((a, cx.target)), None); - if cx.target >= Version::R2007 { - multiline_tags(w, a, false); - } - } - let sh = w.h(); - w.s(0, "SEQEND"); - w.s(5, sh); + _ => {} + } +} + +fn write_insert_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + if let EntityKind::Insert(i) = &e.kind { + w.s(0, "INSERT"); + common(w, e, owner, paper, "AcDbBlockReference"); + if !i.attribs.is_empty() { + w.i(66, 1); + } + w.s(2, &i.block); + w.p(10, i.insert); + w.f(41, i.scale.x); + w.f(42, i.scale.y); + w.f(43, i.scale.z); + w.f(50, i.rotation.to_degrees()); + if i.cols > 1 || i.rows > 1 { + w.i(70, i64::from(i.cols)); + w.i(71, i64::from(i.rows)); + w.f(44, i.col_spacing); + w.f(45, i.row_spacing); + } + if !i.attribs.is_empty() { + for a in &i.attribs { + let ah = w.h(); + w.s(0, "ATTRIB"); + w.s(5, ah); w.s(330, e.handle.hex()); w.s(100, "AcDbEntity"); - w.s(8, &e.common.layer); + let (c, base) = attrib_common(d, e, i, a); + layer_and_props(w, &c, Some(&base)); + // Hidden with its definition (a dynamic block's visibility state hides it). + if !base.visible { + w.i(60, 1); + } + w.s(100, "AcDbText"); + text_tags(w, d, &a.text, Some((a, cx.target)), None); + if cx.target >= Version::R2007 { + multiline_tags(w, a, false); + } + } + let sh = w.h(); + w.s(0, "SEQEND"); + w.s(5, sh); + w.s(330, e.handle.hex()); + w.s(100, "AcDbEntity"); + w.s(8, &e.common.layer); + } + } +} + +fn write_dimension_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + if let EntityKind::Dimension(dm) = &e.kind { + w.s(0, "DIMENSION"); + common_x(w, e, owner, paper, "AcDbDimension", cx.assoc.get(&e.handle)); + let bname = cx.dim_blocks.get(&e.handle).cloned().or_else(|| dm.block.clone()).unwrap_or_default(); + w.s(2, bname); + w.p(10, dm.defpt); + let style = d.dim_style(&dm.style).cloned().unwrap_or_default(); + let g = cadcraft_render::dimension_geometry(dm, &style, d.header.f64("DIMSCALE", 1.0)); + w.p(11, if dm.user_text_pos { dm.text_mid } else { g.text_pos.to3(0.0) }); + let ty: i64 = match dm.kind { + DimKind::Linear { .. } => 0, + DimKind::Aligned => 1, + DimKind::Angular => 2, + DimKind::Diameter => 3, + DimKind::Radius => 4, + DimKind::Angular3P => 5, + DimKind::Ordinate { x_type } => 6 | if x_type { 64 } else { 0 }, + // Written as aligned, marked by CADCraft xdata (see `dim_xdata`). + DimKind::ArcLength => 1, + }; + w.i(70, ty | 32 | if dm.user_text_pos { 128 } else { 0 }); + // The actual measurement (read-only in DXF): AutoLISP's entget shows it. + w.f(42, g.measurement); + if !dm.text.is_empty() { + w.s(1, &dm.text); + } + w.s(3, &dm.style); + if dm.text_rotation != 0.0 { + w.f(53, dm.text_rotation.to_degrees()); + } + match dm.kind { + DimKind::Linear { rotation } => { + w.s(100, "AcDbAlignedDimension"); + w.p(13, dm.p13); + w.p(14, dm.p14); + w.f(50, rotation.to_degrees()); + oblique_52(w, dm, rotation); + w.s(100, "AcDbRotatedDimension"); + } + DimKind::Aligned | DimKind::ArcLength => { + w.s(100, "AcDbAlignedDimension"); + w.p(13, dm.p13); + w.p(14, dm.p14); + if matches!(dm.kind, DimKind::Aligned) { + oblique_52(w, dm, (dm.p14.xy() - dm.p13.xy()).angle()); + } + } + DimKind::Radius => { + w.s(100, "AcDbRadialDimension"); + w.p(15, dm.p15); + w.f(40, 0.0); + } + DimKind::Diameter => { + w.s(100, "AcDbDiametricDimension"); + w.p(15, dm.p15); + w.f(40, 0.0); + } + DimKind::Angular => { + w.s(100, "AcDb2LineAngularDimension"); + w.p(13, dm.p13); + w.p(14, dm.p14); + w.p(15, dm.p15); + w.p(16, dm.p16); + } + DimKind::Angular3P => { + w.s(100, "AcDb3PointAngularDimension"); + w.p(13, dm.p13); + w.p(14, dm.p14); + w.p(15, dm.p15); + } + DimKind::Ordinate { .. } => { + w.s(100, "AcDbOrdinateDimension"); + w.p(13, dm.p13); + w.p(14, dm.p14); } } - EntityKind::Dimension(dm) => { - w.s(0, "DIMENSION"); - common_x(w, e, owner, paper, "AcDbDimension", cx.assoc.get(&e.handle)); - let bname = cx.dim_blocks.get(&e.handle).cloned().or_else(|| dm.block.clone()).unwrap_or_default(); - w.s(2, bname); - w.p(10, dm.defpt); - let style = d.dim_style(&dm.style).cloned().unwrap_or_default(); - let g = cadcraft_render::dimension_geometry(dm, &style, d.header.f64("DIMSCALE", 1.0)); - w.p(11, if dm.user_text_pos { dm.text_mid } else { g.text_pos.to3(0.0) }); - let ty: i64 = match dm.kind { - DimKind::Linear { .. } => 0, - DimKind::Aligned => 1, - DimKind::Angular => 2, - DimKind::Diameter => 3, - DimKind::Radius => 4, - DimKind::Angular3P => 5, - DimKind::Ordinate { x_type } => 6 | if x_type { 64 } else { 0 }, - // Written as aligned, marked by CADCraft xdata (see `dim_xdata`). - DimKind::ArcLength => 1, - }; - w.i(70, ty | 32 | if dm.user_text_pos { 128 } else { 0 }); - // The actual measurement (read-only in DXF): AutoLISP's entget shows it. - w.f(42, g.measurement); - if !dm.text.is_empty() { - w.s(1, &dm.text); - } - w.s(3, &dm.style); - if dm.text_rotation != 0.0 { - w.f(53, dm.text_rotation.to_degrees()); - } - match dm.kind { - DimKind::Linear { rotation } => { - w.s(100, "AcDbAlignedDimension"); - w.p(13, dm.p13); - w.p(14, dm.p14); - w.f(50, rotation.to_degrees()); - oblique_52(w, dm, rotation); - w.s(100, "AcDbRotatedDimension"); - } - DimKind::Aligned | DimKind::ArcLength => { - w.s(100, "AcDbAlignedDimension"); - w.p(13, dm.p13); - w.p(14, dm.p14); - if matches!(dm.kind, DimKind::Aligned) { - oblique_52(w, dm, (dm.p14.xy() - dm.p13.xy()).angle()); - } - } - DimKind::Radius => { - w.s(100, "AcDbRadialDimension"); - w.p(15, dm.p15); - w.f(40, 0.0); - } - DimKind::Diameter => { - w.s(100, "AcDbDiametricDimension"); - w.p(15, dm.p15); - w.f(40, 0.0); - } - DimKind::Angular => { - w.s(100, "AcDb2LineAngularDimension"); - w.p(13, dm.p13); - w.p(14, dm.p14); - w.p(15, dm.p15); - w.p(16, dm.p16); - } - DimKind::Angular3P => { - w.s(100, "AcDb3PointAngularDimension"); - w.p(13, dm.p13); - w.p(14, dm.p14); - w.p(15, dm.p15); - } - DimKind::Ordinate { .. } => { - w.s(100, "AcDbOrdinateDimension"); - w.p(13, dm.p13); - w.p(14, dm.p14); - } - } - dim_xdata(w, dm, cx); + dim_xdata(w, dm, cx); + } +} + +fn write_table_entity(w: &mut W, _d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + if let EntityKind::Table(t) = &e.kind { + // Tables without a generated block (none expected) are not written. + let Some((bname, brh)) = cx.tables.get(&e.handle) else { return }; + w.s(0, "ACAD_TABLE"); + common(w, e, owner, paper, "AcDbBlockReference"); + w.s(2, bname); + w.p(10, t.insert); + w.s(100, "AcDbTable"); + w.i(280, 0); + w.s(342, cx.table_style(&t.style)); + w.s(343, brh); + w.p(11, Vec3::new(1.0, 0.0, 0.0)); + w.i(90, 0); + let (rows, cols) = table_size(t); + w.i(91, rows as i64); + w.i(92, cols as i64); + for c in [93, 94, 95, 96] { + w.i(c, 0); } - EntityKind::Table(t) => { - // Tables without a generated block (none expected) are not written. - let Some((bname, brh)) = cx.tables.get(&e.handle) else { return }; - w.s(0, "ACAD_TABLE"); - common(w, e, owner, paper, "AcDbBlockReference"); - w.s(2, bname); - w.p(10, t.insert); - w.s(100, "AcDbTable"); - w.i(280, 0); - w.s(342, cx.table_style(&t.style)); - w.s(343, brh); - w.p(11, Vec3::new(1.0, 0.0, 0.0)); - w.i(90, 0); - let (rows, cols) = table_size(t); - w.i(91, rows as i64); - w.i(92, cols as i64); - for c in [93, 94, 95, 96] { - w.i(c, 0); - } - for h in t.row_heights.iter().take(rows) { - w.f(141, *h); - } - for c in t.col_widths.iter().take(cols) { - w.f(142, *c); - } - let cov = cadcraft_render::table_covered(t); - let span = |v: u32| i64::from(v.min(i16::MAX as u32)); - for r in 0..rows { - for c in 0..cols { - let cell = t.cells.get(r).and_then(|x| x.get(c)); - let covered = cov.get(r).and_then(|x| x.get(c)).copied().unwrap_or(false); - let merge = cell.and_then(|x| x.merged).filter(|&(a, b)| a >= 1 && b >= 1 && (a, b) != (1, 1)); - w.i(171, 1); - w.i(172, 0); - w.i(173, i64::from(covered || merge.is_some())); - w.i(174, 0); - let (rs, cs) = if covered { (0, 0) } else { merge.map(|(a, b)| (span(a), span(b))).unwrap_or((1, 1)) }; - w.i(175, cs); - w.i(176, rs); - w.i(91, 0); - w.i(178, 0); - w.f(145, 0.0); - if let Some(h) = cell.and_then(|x| x.text_height).filter(|h| h.is_finite() && *h > 0.0) { - w.f(140, h); - } - // Long text: 250-character code-2 chunks, the rest in code 1. - let chars: Vec = cell.map(|x| x.text.chars().collect()).unwrap_or_default(); - let chunks: Vec = chars.chunks(250).map(|c| c.iter().collect()).collect(); - let n = chunks.len(); - for (i, ch) in chunks.into_iter().enumerate() { - w.s(if i + 1 == n { 1 } else { 2 }, ch); - } - if n == 0 { - w.s(1, ""); - } + for h in t.row_heights.iter().take(rows) { + w.f(141, *h); + } + for c in t.col_widths.iter().take(cols) { + w.f(142, *c); + } + let cov = cadcraft_render::table_covered(t); + let span = |v: u32| i64::from(v.min(i16::MAX as u32)); + for r in 0..rows { + for c in 0..cols { + let cell = t.cells.get(r).and_then(|x| x.get(c)); + let covered = cov.get(r).and_then(|x| x.get(c)).copied().unwrap_or(false); + let merge = cell.and_then(|x| x.merged).filter(|&(a, b)| a >= 1 && b >= 1 && (a, b) != (1, 1)); + w.i(171, 1); + w.i(172, 0); + w.i(173, i64::from(covered || merge.is_some())); + w.i(174, 0); + let (rs, cs) = if covered { (0, 0) } else { merge.map(|(a, b)| (span(a), span(b))).unwrap_or((1, 1)) }; + w.i(175, cs); + w.i(176, rs); + w.i(91, 0); + w.i(178, 0); + w.f(145, 0.0); + if let Some(h) = cell.and_then(|x| x.text_height).filter(|h| h.is_finite() && *h > 0.0) { + w.f(140, h); + } + // Long text: 250-character code-2 chunks, the rest in code 1. + let chars: Vec = cell.map(|x| x.text.chars().collect()).unwrap_or_default(); + let chunks: Vec = chars.chunks(250).map(|c| c.iter().collect()).collect(); + let n = chunks.len(); + for (i, ch) in chunks.into_iter().enumerate() { + w.s(if i + 1 == n { 1 } else { 2 }, ch); + } + if n == 0 { + w.s(1, ""); } - } - w.s(1001, dxf_ext::APP); - w.s(1000, "TABLE"); - w.i(1070, i64::from(t.title)); - w.i(1070, i64::from(t.header)); - w.f(1040, t.text_height); - w.s(1000, &t.style); - for c in crate::dxf_table::table_xdata(t) { - w.s(1000, c); } } + w.s(1001, dxf_ext::APP); + w.s(1000, "TABLE"); + w.i(1070, i64::from(t.title)); + w.i(1070, i64::from(t.header)); + w.f(1040, t.text_height); + w.s(1000, &t.style); + for c in crate::dxf_table::table_xdata(t) { + w.s(1000, c); + } + } +} + +fn write_annotations_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + match &e.kind { EntityKind::MLeader(m) if !cx.native_mleader() => mleader_fallback(w, d, e, m, owner, paper, cx), EntityKind::MLeader(m) => { w.s(0, "MULTILEADER"); @@ -493,142 +529,157 @@ pub(super) fn entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: boo w.p(13, f.corners[3]); w.i(70, i64::from(f.hidden_edges)); } - EntityKind::Hatch(h) => { - w.s(0, "HATCH"); - common(w, e, owner, paper, "AcDbHatch"); - w.p(10, Vec3::new(0.0, 0.0, h.elevation)); - w.p(210, Vec3::Z); - w.s(2, &h.pattern); - w.i(70, i64::from(h.solid)); - w.i(71, i64::from(h.associative)); - w.i(91, h.loops.len() as i64); - for l in &h.loops { - w.i(92, 2 | if l.outer { 1 } else { 0 }); - let has_bulge = l.vertices.iter().any(|v| v.bulge != 0.0); - w.i(72, i64::from(has_bulge)); - w.i(73, 1); - w.i(93, l.vertices.len() as i64); - for v in &l.vertices { - w.p2(10, v.p); - if has_bulge { - w.f(42, v.bulge); - } - } - // Source boundary objects of an associative hatch (the ones still beside it, in - // its space or block, which carry the hatch as a reactor). - let own = e.handle.hex(); - let sources: Vec = - l.sources.iter().filter(|s| h.associative && w.reactors.get(*s).is_some_and(|r| r.contains(&own))).map(|s| s.hex()).collect(); - w.i(97, sources.len() as i64); - for s in &sources { - w.s(330, s); + _ => {} + } +} + +fn write_hatch_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, _cx: &Ctx) { + if let EntityKind::Hatch(h) = &e.kind { + w.s(0, "HATCH"); + common(w, e, owner, paper, "AcDbHatch"); + w.p(10, Vec3::new(0.0, 0.0, h.elevation)); + w.p(210, Vec3::Z); + w.s(2, &h.pattern); + w.i(70, i64::from(h.solid)); + w.i(71, i64::from(h.associative)); + w.i(91, h.loops.len() as i64); + for l in &h.loops { + w.i(92, 2 | if l.outer { 1 } else { 0 }); + let has_bulge = l.vertices.iter().any(|v| v.bulge != 0.0); + w.i(72, i64::from(has_bulge)); + w.i(73, 1); + w.i(93, l.vertices.len() as i64); + for v in &l.vertices { + w.p2(10, v.p); + if has_bulge { + w.f(42, v.bulge); } } - w.i(75, i64::from(h.style)); - w.i(76, 1); - if !h.solid { - w.f(52, h.angle.to_degrees()); - w.f(41, h.scale); - w.i(77, 0); - // The lines read from the file, else the library's pattern of that name. - let lines = if h.pattern_lines.is_empty() { - cadcraft_doc::library::pattern_for(d, &h.pattern).map(|p| p.lines).unwrap_or_default() - } else { - h.pattern_lines.clone() - }; - w.i(78, lines.len() as i64); - for pl in lines { - let ang = pl.angle.to_radians() + h.angle; - w.f(53, ang.to_degrees()); - let o = h.origin + Vec2::new(pl.origin.0, pl.origin.1).rotate(h.angle) * h.scale; - w.f(43, o.x); - w.f(44, o.y); - let dl = Vec2::new(pl.delta.0, pl.delta.1).rotate(ang) * h.scale; - w.f(45, dl.x); - w.f(46, dl.y); - w.i(79, pl.dashes.len() as i64); - for dsh in pl.dashes { - w.f(49, dsh * h.scale); - } - } + // Source boundary objects of an associative hatch (the ones still beside it, in + // its space or block, which carry the hatch as a reactor). + let own = e.handle.hex(); + let sources: Vec = + l.sources.iter().filter(|s| h.associative && w.reactors.get(*s).is_some_and(|r| r.contains(&own))).map(|s| s.hex()).collect(); + w.i(97, sources.len() as i64); + for s in &sources { + w.s(330, s); } - w.i(98, 0); - if let Some(g) = &h.gradient { - gradient(w, g); - } - hatch_xdata(w, h); } - EntityKind::Viewport(v) => { - paper_view(w, d, e, owner, cx); - w.s(0, "VIEWPORT"); - common(w, e, owner, paper, "AcDbViewport"); - w.p(10, v.center); - w.f(40, v.width); - w.f(41, v.height); - // Status 68: a positive value is "on" (the stacking order; 1 is the active viewport), 0 off. - w.i(68, if v.on { i64::from(v.id.clamp(1, 32767)) } else { 0 }); - w.i(69, i64::from(v.id)); - w.p2(12, v.view_center); - w.f(45, v.view_height); - // Status flags: 16384 = display locked, 32768 = always set, 65536 = clipped by the - // 340 entity, 131072 = off. - let clip = v.clip.filter(|h| *h != e.handle && d.entity(*h).is_some()); - let flags = 32768 | if v.locked { 16384 } else { 0 } | if clip.is_some() { 65536 } else { 0 } | if v.on { 0 } else { 131072 }; - w.i(90, flags); - if let Some(h) = clip { - w.s(340, h.hex()); - } - // AutoCAD's frozen-layer list: one soft pointer per layer, to its LAYER record. Other - // programs read only this; CADCraft prefers its own xdata below when present. - for name in &v.frozen_layers { - if let Some(h) = w.layers.get(&name.to_ascii_uppercase()).cloned() { - w.s(341, h); - } - } - // One CADCraft xdata group holds both lists: readers stop at the first group of an app. - if !v.frozen_layers.is_empty() || !v.layer_colors.is_empty() { - w.s(1001, dxf_ext::APP); - if !v.frozen_layers.is_empty() { - w.xdata(dxf_ext::frozen_xdata(&v.frozen_layers)); - } - if !v.layer_colors.is_empty() { - w.xdata(dxf_ext::layer_colors_xdata(&v.layer_colors)); + w.i(75, i64::from(h.style)); + w.i(76, 1); + if !h.solid { + w.f(52, h.angle.to_degrees()); + w.f(41, h.scale); + w.i(77, 0); + // The lines read from the file, else the library's pattern of that name. + let lines = if h.pattern_lines.is_empty() { + cadcraft_doc::library::pattern_for(d, &h.pattern).map(|p| p.lines).unwrap_or_default() + } else { + h.pattern_lines.clone() + }; + w.i(78, lines.len() as i64); + for pl in lines { + let ang = pl.angle.to_radians() + h.angle; + w.f(53, ang.to_degrees()); + let o = h.origin + Vec2::new(pl.origin.0, pl.origin.1).rotate(h.angle) * h.scale; + w.f(43, o.x); + w.f(44, o.y); + let dl = Vec2::new(pl.delta.0, pl.delta.1).rotate(ang) * h.scale; + w.f(45, dl.x); + w.f(46, dl.y); + w.i(79, pl.dashes.len() as i64); + for dsh in pl.dashes { + w.f(49, dsh * h.scale); } } } - EntityKind::Wipeout(wo) => { - // A 1x1 image spanning the boundary's extents. Clip vertices are in pixel space, whose origin is - // the image's top-left corner with y pointing down: the reader maps each vertex back through - // insert + u * (x + 0.5) + v * (0.5 - y). - // Polygonal clip boundaries are closed, so the first vertex is repeated when needed. - let b = Bounds2::from_points(wo.boundary.iter().copied()); - let o = if b.is_empty() { Vec2::ZERO } else { b.min }; - let (sx, sy) = (if b.width() > 0.0 { b.width() } else { 1.0 }, if b.height() > 0.0 { b.height() } else { 1.0 }); - w.s(0, "WIPEOUT"); - common(w, e, owner, paper, "AcDbWipeout"); - w.i(90, 0); - w.p(10, Vec3::new(o.x, o.y, 0.0)); - w.p(11, Vec3::new(sx, 0.0, 0.0)); - w.p(12, Vec3::new(0.0, sy, 0.0)); - w.p2(13, Vec2::new(1.0, 1.0)); - // Display flags 7 = show image, show unaligned, use clipping boundary; clipping on; default brightness/contrast/fade. - w.i(70, 7); - w.i(280, 1); - w.i(281, 50); - w.i(282, 50); - w.i(283, 0); - w.i(71, 2); - let mut pts = wo.boundary.clone(); - if let (Some(first), Some(last)) = (pts.first().copied(), pts.last().copied()) - && first != last - { - pts.push(first); - } - w.i(91, pts.len() as i64); - for q in pts { - w.p2(14, Vec2::new((q.x - o.x) / sx - 0.5, 0.5 - (q.y - o.y) / sy)); + w.i(98, 0); + if let Some(g) = &h.gradient { + gradient(w, g); + } + hatch_xdata(w, h); + } +} + +fn write_viewport_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bool, cx: &Ctx) { + if let EntityKind::Viewport(v) = &e.kind { + paper_view(w, d, e, owner, cx); + w.s(0, "VIEWPORT"); + common(w, e, owner, paper, "AcDbViewport"); + w.p(10, v.center); + w.f(40, v.width); + w.f(41, v.height); + // Status 68: a positive value is "on" (the stacking order; 1 is the active viewport), 0 off. + w.i(68, if v.on { i64::from(v.id.clamp(1, 32767)) } else { 0 }); + w.i(69, i64::from(v.id)); + w.p2(12, v.view_center); + w.f(45, v.view_height); + // Status flags: 16384 = display locked, 32768 = always set, 65536 = clipped by the + // 340 entity, 131072 = off. + let clip = v.clip.filter(|h| *h != e.handle && d.entity(*h).is_some()); + let flags = 32768 | if v.locked { 16384 } else { 0 } | if clip.is_some() { 65536 } else { 0 } | if v.on { 0 } else { 131072 }; + w.i(90, flags); + if let Some(h) = clip { + w.s(340, h.hex()); + } + // AutoCAD's frozen-layer list: one soft pointer per layer, to its LAYER record. Other + // programs read only this; CADCraft prefers its own xdata below when present. + for name in &v.frozen_layers { + if let Some(h) = w.layers.get(&name.to_ascii_uppercase()).cloned() { + w.s(341, h); } } + // One CADCraft xdata group holds both lists: readers stop at the first group of an app. + if !v.frozen_layers.is_empty() || !v.layer_colors.is_empty() { + w.s(1001, dxf_ext::APP); + if !v.frozen_layers.is_empty() { + w.xdata(dxf_ext::frozen_xdata(&v.frozen_layers)); + } + if !v.layer_colors.is_empty() { + w.xdata(dxf_ext::layer_colors_xdata(&v.layer_colors)); + } + } + } +} + +fn write_wipeout_entity(w: &mut W, _d: &Drawing, e: &Entity, owner: &str, paper: bool, _cx: &Ctx) { + if let EntityKind::Wipeout(wo) = &e.kind { + // A 1x1 image spanning the boundary's extents. Clip vertices are in pixel space, whose origin is + // the image's top-left corner with y pointing down: the reader maps each vertex back through + // insert + u * (x + 0.5) + v * (0.5 - y). + // Polygonal clip boundaries are closed, so the first vertex is repeated when needed. + let b = Bounds2::from_points(wo.boundary.iter().copied()); + let o = if b.is_empty() { Vec2::ZERO } else { b.min }; + let (sx, sy) = (if b.width() > 0.0 { b.width() } else { 1.0 }, if b.height() > 0.0 { b.height() } else { 1.0 }); + w.s(0, "WIPEOUT"); + common(w, e, owner, paper, "AcDbWipeout"); + w.i(90, 0); + w.p(10, Vec3::new(o.x, o.y, 0.0)); + w.p(11, Vec3::new(sx, 0.0, 0.0)); + w.p(12, Vec3::new(0.0, sy, 0.0)); + w.p2(13, Vec2::new(1.0, 1.0)); + // Display flags 7 = show image, show unaligned, use clipping boundary; clipping on; default brightness/contrast/fade. + w.i(70, 7); + w.i(280, 1); + w.i(281, 50); + w.i(282, 50); + w.i(283, 0); + w.i(71, 2); + let mut pts = wo.boundary.clone(); + if let (Some(first), Some(last)) = (pts.first().copied(), pts.last().copied()) + && first != last + { + pts.push(first); + } + w.i(91, pts.len() as i64); + for q in pts { + w.p2(14, Vec2::new((q.x - o.x) / sx - 0.5, 0.5 - (q.y - o.y) / sy)); + } + } +} + +fn write_other_entity(w: &mut W, _d: &Drawing, e: &Entity, owner: &str, paper: bool, _cx: &Ctx) { + match &e.kind { EntityKind::Tolerance(t) => { w.s(0, "TOLERANCE"); common(w, e, owner, paper, "AcDbFcf"); @@ -639,6 +690,7 @@ pub(super) fn entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: boo } // Entity types CADCraft doesn't model aren't written; the save command reports them. EntityKind::Unknown(_) => {} + _ => {} } } diff --git a/crates/io/src/dxf_write/header.rs b/crates/io/src/dxf_write/header.rs index edd62eb13..b628a5c3d 100644 --- a/crates/io/src/dxf_write/header.rs +++ b/crates/io/src/dxf_write/header.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{DimVal, Drawing, HVal, K, Version, W, dxf_ext}; /// Header variables we write, with their group codes (DXF Reference, HEADER section). /// `P2`/`P3` = 2D/3D point. diff --git a/crates/io/src/dxf_write/layout.rs b/crates/io/src/dxf_write/layout.rs index ccffa2929..4ad19ffbb 100644 --- a/crates/io/src/dxf_write/layout.rs +++ b/crates/io/src/dxf_write/layout.rs @@ -1,5 +1,5 @@ use super::ctx::Ctx; -use super::*; +use super::{Bounds2, Drawing, Entity, EntityKind, Handle, HashMap, Layout, Vec2, Vec3, VportConfig, VportTile, W, dxf_ext}; /// Layouts with viewports but without the paper-space viewport (id 1, the sheet itself), keyed /// by their first viewport. AutoCAD and DWG take a layout's first viewport as its paper-space diff --git a/crates/io/src/dxf_write/objects.rs b/crates/io/src/dxf_write/objects.rs index 2227ae096..83fe3c7ca 100644 --- a/crates/io/src/dxf_write/objects.rs +++ b/crates/io/src/dxf_write/objects.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Drawing, Group, MLeaderStyle, TableStyle, W, dxf_ext}; /// A TABLESTYLE object (DXF Reference, OBJECTS: TABLESTYLE): margins, title/header /// suppression and per row type (data, column header, title) text and border settings. diff --git a/crates/io/src/dxf_write/sections.rs b/crates/io/src/dxf_write/sections.rs index 7b1676514..710f932c1 100644 --- a/crates/io/src/dxf_write/sections.rs +++ b/crates/io/src/dxf_write/sections.rs @@ -6,7 +6,879 @@ use super::entity::{entity, hatch_reactors}; use super::header::{code_page, header_vars}; use super::layout::{paper_views, record_head, sheet_first, table_head, vport_table}; use super::objects::{cadcraft_fonts_name, group_obj, mleader_style_obj, scale_list, table_style_obj}; -use super::*; +use super::{ + Block, Color, DimStyle, DimVal, Drawing, Entity, EntityKind, EntityStore, Group, HVal, Handle, HashMap, Layout, MLeaderStyle, PageSetup, Space, + TableStyle, Tag, Vec2, Vec3, Version, W, dxf_ext, +}; + +struct TableWritePlan<'a> { + d: &'a Drawing, + version: Version, + cx: &'a mut Ctx, + ext: cadcraft_geom::Bounds2, +} + +fn write_tables(w: &mut W, plan: TableWritePlan<'_>) -> HashMap { + let d = plan.d; + let version = plan.version; + let cx = plan.cx; + let ext = plan.ext; + // ---------------- TABLES ---------------- + w.s(0, "SECTION"); + w.s(2, "TABLES"); + vport_table(w, d, ext); + // LTYPE. Embedded text and shapes point at STYLE records (340), which get their handles + // in the STYLE table below: (tag position, style name, is a shape) are filled in there. + let mut ltype_handles: HashMap = HashMap::new(); + let mut ltype_style_refs: Vec<(usize, Option, bool)> = Vec::new(); + let th = table_head(w, "LTYPE", d.linetypes.len()); + for lt in &d.linetypes { + let h = record_head(w, "LTYPE", &th, "AcDbLinetypeTableRecord"); + ltype_handles.entry(lt.name.to_ascii_uppercase()).or_insert(h.clone()); + cx.ltypes.entry(lt.name.to_ascii_uppercase()).or_insert(h); + w.s(2, <.name); + w.i(70, if crate::dxf_xref::dependent(<.name) { 48 } else { 0 }); + w.s(3, <.description); + w.i(72, 65); + w.i(73, lt.pattern.len() as i64); + w.f(40, lt.pattern_length()); + for el in <.pattern { + w.f(49, el.length); + // 74: 2 = text, 4 = shape, + 1 when the rotation is absolute (DXF Reference, LTYPE). + let (kind, shape) = match (&el.text, el.shape) { + (Some(_), _) => (2, 0), + (None, Some(n)) => (4, n), + (None, None) => (0, 0), + }; + if kind == 0 { + w.i(74, 0); + continue; + } + w.i(74, kind | i64::from(el.absolute)); + w.i(75, i64::from(shape)); + ltype_style_refs.push((w.t.len(), el.style.clone(), kind == 4)); + w.s(340, "0"); + w.f(46, el.scale); + w.f(50, el.rotation); + w.f(44, el.offset.x); + w.f(45, el.offset.y); + if let Some(t) = &el.text { + w.s(9, t.clone()); + } + } + } + w.s(0, "ENDTAB"); + write_layer_table(w, d); + // STYLE. Linetype shapes from a shape file that isn't a text style get an unnamed shape + // style record (70 bit 1) naming the file. + let mut shape_files: Vec = Vec::new(); + for (_, style, shape) in <ype_style_refs { + let Some(f) = style.as_deref().map(str::trim).filter(|f| *shape && !f.is_empty() && d.text_style(f).is_none()) else { continue }; + if !shape_files.iter().any(|x| x.eq_ignore_ascii_case(f)) { + shape_files.push(f.to_string()); + } + } + let th = table_head(w, "STYLE", d.text_styles.len() + shape_files.len()); + for s in &d.text_styles { + let h = record_head(w, "STYLE", &th, "AcDbTextStyleTableRecord"); + cx.styles.entry(s.name.to_ascii_uppercase()).or_insert(h); + w.s(2, &s.name); + // 70 bit 4: vertical; 71 bits 2/4: backwards / upside down. + w.i(70, if s.vertical { 4 } else { 0 }); + w.f(40, s.height); + w.f(41, s.width_factor); + w.f(50, s.oblique.to_degrees()); + w.i(71, if s.backwards { 2 } else { 0 } | if s.upside_down { 4 } else { 0 }); + w.f(42, 0.2); + // The built-in font goes out as `txt`, which every reader has; CADCraft's own name + // travels in `CADCRAFT` xdata (`1000 FONT`, name) so the style reopens with it. + let file = if s.font == cadcraft_fonts_name() { "txt" } else { s.font.as_str() }; + w.s(3, file); + w.s(4, &s.big_font); + if s.annotative { + annotative_xdata(w); + } + if file != s.font { + w.s(1001, dxf_ext::APP); + w.s(1000, "FONT"); + w.s(1000, dxf_ext::xdata_str(&s.font)); + } + } + let mut shape_handles: HashMap = HashMap::new(); + for f in &shape_files { + let h = record_head(w, "STYLE", &th, "AcDbTextStyleTableRecord"); + shape_handles.insert(f.to_ascii_uppercase(), h); + w.s(2, ""); + w.i(70, 1); + w.f(40, 0.0); + w.f(41, 1.0); + w.f(50, 0.0); + w.i(71, 0); + w.f(42, 0.2); + w.s(3, f.clone()); + w.s(4, ""); + } + w.s(0, "ENDTAB"); + // Linetype text and shapes without a known style use Standard (else the first style). + let fallback_style = cx.style("Standard").or_else(|| d.text_styles.first().and_then(|s| cx.style(&s.name))).unwrap_or_else(|| "0".into()); + for (pos, style, shape) in ltype_style_refs { + let name = style.as_deref().map(str::trim).unwrap_or_default(); + let h = shape.then(|| shape_handles.get(&name.to_ascii_uppercase()).cloned()).flatten().or_else(|| cx.style(name)); + if let Some(t) = w.t.get_mut(pos) { + *t = Tag::s(340, h.unwrap_or_else(|| fallback_style.clone())); + } + } + // VIEW: named views (DXF Reference, VIEW). A view's layer state is CADCraft xdata. + let th = table_head(w, "VIEW", d.views.len()); + for v in &d.views { + record_head(w, "VIEW", &th, "AcDbViewTableRecord"); + w.s(2, &v.name); + w.i(70, i64::from(v.layout.is_some())); + w.f(40, v.height); + w.p2(10, v.center); + w.f(41, v.width); + w.p(11, Vec3::Z); + w.p(12, Vec3::ZERO); + w.f(42, 50.0); + w.f(43, 0.0); + w.f(44, 0.0); + w.f(50, if v.twist.is_finite() { v.twist.to_degrees() } else { 0.0 }); + w.i(71, 0); + w.i(281, 0); + w.i(72, 0); + let xdata = [("LAYERSTATE", v.layer_state.as_deref()), ("LAYOUT", v.layout.as_deref().filter(|l| !l.is_empty()))]; + if xdata.iter().any(|(_, x)| x.is_some()) { + w.s(1001, dxf_ext::APP); + for (key, value) in xdata { + if let Some(value) = value { + w.s(1000, key); + w.s(1000, dxf_ext::xdata_str(value)); + } + } + } + } + w.s(0, "ENDTAB"); + // UCS: named user coordinate systems (DXF Reference, UCS). + let th = table_head(w, "UCS", d.ucss.len()); + for u in &d.ucss { + record_head(w, "UCS", &th, "AcDbUCSTableRecord"); + w.s(2, &u.name); + w.i(70, 0); + w.p(10, u.origin); + w.p(11, u.x_axis); + w.p(12, u.y_axis); + w.i(79, 0); + w.f(146, 0.0); + } + w.s(0, "ENDTAB"); + let apps = ["ACAD", dxf_ext::APP, "AcadAnnotative", dxf_ext::LAYER_TRANSPARENCY_APP, dxf_ext::LAYER_DESCRIPTION_APP]; + let th = table_head(w, "APPID", apps.len()); + for app in apps { + record_head(w, "APPID", &th, "AcDbRegAppTableRecord"); + w.s(2, app); + w.i(70, 0); + } + w.s(0, "ENDTAB"); + write_dimstyles(w, d, cx, version); + ltype_handles +} + +fn write_layer_table(w: &mut W, d: &Drawing) { + let th = table_head(w, "LAYER", d.layers.len()); + for l in &d.layers { + let lh = record_head(w, "LAYER", &th, "AcDbLayerTableRecord"); + w.layers.insert(l.name.to_ascii_uppercase(), lh); + w.s(2, &l.name); + // 16 | 32: an xref's layer (`xref|name`), externally dependent and resolved. + let xref = if crate::dxf_xref::dependent(&l.name) { 48 } else { 0 }; + w.i(70, i64::from(l.frozen) | if l.vp_freeze_new { 2 } else { 0 } | if l.locked { 4 } else { 0 } | xref); + let aci = match l.color { + Color::True(rgb) => i64::from(cadcraft_color::nearest_aci(rgb)), + c => i64::from(c.to_aci()).clamp(1, 255), + }; + w.i(62, if l.on { aci } else { -aci }); + if let Color::True(rgb) = l.color { + w.i(420, i64::from(rgb.to_u32())); + } + w.s(6, &l.linetype); + if !l.plot { + w.i(290, 0); + } + w.i(370, i64::from(l.lineweight.to_dxf())); + let normal = w.pstyles.get(&cadcraft_doc::NORMAL_STYLE.to_ascii_uppercase()).cloned(); + if let Some(h) = w.pstyles.get(&l.plot_style.trim().to_ascii_uppercase()).cloned().or(normal) { + w.s(390, h); + } + if l.transparency > 0 { + w.s(1001, dxf_ext::LAYER_TRANSPARENCY_APP); + w.i(1071, dxf_ext::transparency_to_dxf(l.transparency)); + } + if !l.description.is_empty() { + // The first string is the layer standard's name, unused here. + w.s(1001, dxf_ext::LAYER_DESCRIPTION_APP); + w.s(1000, ""); + w.s(1000, dxf_ext::xdata_str(&l.description)); + } + } + w.s(0, "ENDTAB"); +} + +fn write_dimstyles(w: &mut W, d: &Drawing, cx: &mut Ctx, version: Version) { + // DIMSTYLE + let th = { + let h = w.h(); + w.s(0, "TABLE"); + w.s(2, "DIMSTYLE"); + w.s(5, h.clone()); + w.s(330, "0"); + w.s(100, "AcDbSymbolTable"); + w.i(70, d.dim_styles.len() as i64); + w.s(100, "AcDbDimStyleTable"); + w.i(71, 0); + h + }; + for s in &d.dim_styles { + record_head(w, "DIMSTYLE", &th, "AcDbDimStyleTableRecord"); + w.s(2, &s.name); + w.i(70, 0); + let v = serde_json::to_value(s).unwrap_or_default(); + let defaults = serde_json::to_value(DimStyle::default()).unwrap_or_default(); + let mut newer = W { t: Vec::new(), next: 0, pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() }; + for (field, code, kind) in dxf_ext::DIM_CODES { + let Some(enc) = v.get(*field).and_then(|x| cx.encode(*kind, x)) else { continue }; + // DIMPOST is written even when empty: a reader that defaults a missing one to "<>" + // (the DWG bridge's) would otherwise give radius and diameter dimensions no "R" or + // "Ø" in AutoCAD (#1053). + if *code == dxf_ext::DIMPOST + && let DimVal::Str(t) = &enc + && t.is_empty() + { + w.s(*code, ""); + continue; + } + if !dxf_ext::NEWER_CODES.contains(code) { + w.dimval(*code, enc, false); + continue; + } + // Table groups where the file version has them, else xdata. DIMTFILL and DIMTFILLCLR + // are written only when set, as other writers do, so a style without a text + // background has a single 70 (its flags). + if version >= dxf_ext::newer_since(*code) { + if matches!(*code, 69 | 70) && v.get(*field) == defaults.get(*field) { + continue; + } + w.dimval(*code, enc, false); + } else if v.get(*field) != defaults.get(*field) { + newer.i(1070, i64::from(*code)); + newer.dimval(*code, enc, true); + } + } + if !s.arrow_block1.trim().is_empty() || !s.arrow_block2.trim().is_empty() { + w.i(dxf_ext::DIMSAH, 1); + } + if s.annotative { + annotative_xdata(w); + } + if !newer.t.is_empty() { + w.s(1001, dxf_ext::APP); + w.s(1000, dxf_ext::DIMVARS_LIST); + w.s(1002, "{"); + w.xdata(newer.t); + w.s(1002, "}"); + } + } + w.s(0, "ENDTAB"); +} + +fn write_header(w: &mut W, d: &Drawing, version: Version) -> usize { + w.s(0, "SECTION"); + w.s(2, "HEADER"); + w.s(9, "$ACADVER"); + w.s(1, version.code()); + w.s(9, "$DWGCODEPAGE"); + w.s(3, code_page(d, version)); + let ext = d.extents(&Space::Model); + if !ext.is_empty() { + w.s(9, "$EXTMIN"); + w.p(10, ext.min.to3(0.0)); + w.s(9, "$EXTMAX"); + w.p(10, ext.max.to3(0.0)); + } + header_vars(w, d); + let seed_pos = w.t.len(); + w.s(9, "$HANDSEED"); + w.s(5, "0"); + w.s(0, "ENDSEC"); + + seed_pos +} + +fn write_classes(w: &mut W, cx: &Ctx, every: &[&Entity]) { + w.s(0, "SECTION"); + w.s(2, "CLASSES"); + let mut classes = vec![ + ("TABLESTYLE", "AcDbTableStyle", 4095, false), + ("MLEADERSTYLE", "AcDbMLeaderStyle", 4095, false), + ("ACDBDICTIONARYWDFLT", "AcDbDictionaryWithDefault", 0, false), + ("ACDBPLACEHOLDER", "AcDbPlaceHolder", 0, false), + ]; + if !cx.tables.is_empty() { + classes.push(("ACAD_TABLE", "AcDbTable", 1025, true)); + } + if every.iter().any(|e| matches!(e.kind, EntityKind::Helix(_))) { + classes.push(("HELIX", "AcDbHelix", 4095, true)); + } + if !cx.assoc.is_empty() { + classes.push(("DIMASSOC", "AcDbDimAssoc", 0, false)); + } + if cx.native_mleader() && every.iter().any(|e| matches!(e.kind, EntityKind::MLeader(_))) { + classes.push(("MULTILEADER", "AcDbMLeader", 1025, true)); + } + if every.iter().any(|e| matches!(e.kind, EntityKind::Wipeout(_))) { + classes.push(("WIPEOUT", "AcDbWipeout", 127, true)); + } + if !cx.images.is_empty() { + classes.push(("IMAGE", "AcDbRasterImage", 127, true)); + classes.push(("IMAGEDEF", "AcDbRasterImageDef", 0, false)); + classes.push(("IMAGEDEF_REACTOR", "AcDbRasterImageDefReactor", 1, false)); + classes.push(("RASTERVARIABLES", "AcDbRasterVariables", 0, false)); + } + classes.push(("SCALE", "AcDbScale", 0, false)); + for (dxf_name, cpp, proxy, is_entity) in classes { + w.s(0, "CLASS"); + w.s(1, dxf_name); + w.s(2, cpp); + w.s(3, "ObjectDBX Classes"); + w.i(90, proxy); + w.i(280, 0); + w.i(281, i64::from(is_entity)); + } + w.s(0, "ENDSEC"); +} + +fn write_entities(w: &mut W, d: &Drawing, ms_br: &str, ps_brs: &[(String, String, &Layout)], cx: &Ctx) { + w.s(0, "SECTION"); + w.s(2, "ENTITIES"); + for e in d.model.iter() { + entity(w, d, e, ms_br, false, cx); + } + if let Some((_, h, l)) = ps_brs.first() { + for e in sheet_first(l) { + entity(w, d, e, h, true, cx); + } + } + w.s(0, "ENDSEC"); +} + +struct LayoutWriteContext<'a> { + drawing: &'a Drawing, + dictionary: &'a str, +} + +struct LayoutWriteData<'a> { + handle: &'a str, + name: &'a str, + tab: i64, + block_record: &'a str, + flags: i64, + page: &'a PageSetup, + view: Option<(Vec2, f64)>, +} + +fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData<'_>) { + let d = context.drawing; + let layout_dict = context.dictionary; + let h = data.handle; + let name = data.name; + let tab = data.tab; + let brh = data.block_record; + let flags = data.flags; + let page = data.page; + let view = data.view; + // Plot scale: a standard scale when fitting or 1:1, otherwise custom (142 paper units + // per 143 drawing units). + let scale = if page.scale.is_finite() && page.scale > 0.0 { page.scale } else { 1.0 }; + let standard = page.scale_to_fit || scale == 1.0; + let plot_flags = 512 + | 32 + | if standard { 16 } else { 0 } + | if page.lineweights { 128 } else { 0 } + | if page.center { 4 } else { 0 } + | if page.show_plot_styles { 2 } else { 0 }; + let plot_type = match page.plot_area.as_str() { + "display" => 0, + "extents" => 1, + "limits" => 2, + "window" => 4, + _ => 5, + }; + w.s(0, "LAYOUT"); + w.s(5, h); + w.s(330, layout_dict.to_string()); + w.s(100, "AcDbPlotSettings"); + w.s(1, ""); + let device = page.device.trim(); + w.s(2, if device.is_empty() || device.eq_ignore_ascii_case("None") { "none_device" } else { device }); + w.s(4, page.paper.replace(' ', "_")); + w.s(6, ""); + for (c, v) in [ + (40, page.margins_mm[0]), + (41, page.margins_mm[1]), + (42, page.margins_mm[2]), + (43, page.margins_mm[3]), + (44, page.width_mm), + (45, page.height_mm), + (46, 0.0), + (47, 0.0), + (48, page.plot_window[0]), + (49, page.plot_window[1]), + (140, page.plot_window[2]), + (141, page.plot_window[3]), + (142, scale), + (143, 1.0), + ] { + w.f(c, v); + } + w.i(70, plot_flags); + // Plot paper units: 1 millimetres, 0 inches (#1058). + w.i(72, i64::from(cadcraft_render::paper::page_unit_mm(d, page) == 1.0)); + w.i(73, i64::from(page.landscape)); + w.i(74, plot_type); + w.s(7, &page.plot_style_table); + w.i(75, if page.scale_to_fit { 0 } else { 16 }); + w.f(147, scale); + w.f(148, 0.0); + w.f(149, 0.0); + w.s(100, "AcDbLayout"); + w.s(1, name); + w.i(70, flags); + w.i(71, tab); + w.p2(10, Vec2::ZERO); + w.p2(11, Vec2::new(12.0, 9.0)); + w.p(12, Vec3::ZERO); + w.p(14, Vec3::ZERO); + w.p(15, Vec3::ZERO); + w.f(146, 0.0); + w.p(13, Vec3::ZERO); + w.p(16, Vec3::new(1.0, 0.0, 0.0)); + w.p(17, Vec3::new(0.0, 1.0, 0.0)); + w.i(76, 0); + w.s(330, brh); + // The saved paper-space view (centre, height) as CADCraft xdata. + if let Some((c, height)) = view.filter(|(c, v)| c.x.is_finite() && c.y.is_finite() && v.is_finite()) { + w.s(1001, dxf_ext::APP); + w.s(1000, "PSVIEW"); + w.s(1002, "{"); + w.p(1010, c.to3(0.0)); + w.f(1040, height); + w.s(1002, "}"); + } +} + +struct ObjectWritePlan<'a> { + d: &'a Drawing, + cx: &'a Ctx, + root_dict: &'a String, + group_dict: &'a String, + layout_dict: &'a String, + table_style_dict: &'a String, + pstyle_dict: &'a String, + scale_dict: &'a String, + model_layout: &'a String, + ms_br: &'a String, + ps_brs: &'a [(String, String, &'a Layout)], + layout_handles: &'a [String], + xrecords: &'a [(&'static str, String, Vec)], + scales: &'a [(&'a cadcraft_doc::AnnoScale, String)], + pstyles: &'a [(String, String)], + table_styles: &'a [TableStyle], + mleader_styles: &'a [MLeaderStyle], + ltype_handles: &'a HashMap, +} + +fn write_layout_objects(w: &mut W, plan: &ObjectWritePlan<'_>) { + let d = plan.d; + let root_dict = plan.root_dict; + let layout_dict = plan.layout_dict; + let model_layout = plan.model_layout; + let ms_br = plan.ms_br; + let ps_brs = plan.ps_brs; + let layout_handles = plan.layout_handles; + w.s(0, "DICTIONARY"); + w.s(5, layout_dict.clone()); + w.s(330, root_dict.clone()); + w.s(100, "AcDbDictionary"); + w.i(281, 1); + w.s(3, "Model"); + w.s(350, model_layout.clone()); + for (i, (_, _, l)) in ps_brs.iter().enumerate() { + w.s(3, &l.name); + w.s(350, layout_handles.get(i).cloned().unwrap_or_default()); + } + // Model space has no page setup of its own: write what PLOT does for it, the drawing extents + // fitted to the paper (plot type 1, scaled to fit). The default page's "layout" area is + // plot type 5, "Layout information" (DXF Reference, PLOTSETTINGS group 74), which means + // nothing for model space: another program's Plot dialog then shows no plot area or scale. + let model_page = PageSetup { plot_area: "extents".into(), scale_to_fit: true, ..PageSetup::default() }; + layout_obj( + w, + LayoutWriteContext { drawing: d, dictionary: layout_dict }, + LayoutWriteData { handle: model_layout, name: "Model", tab: 0, block_record: ms_br, flags: 1, page: &model_page, view: None }, + ); + for (i, (_, brh, l)) in ps_brs.iter().enumerate() { + let h = layout_handles.get(i).cloned().unwrap_or_default(); + layout_obj( + w, + LayoutWriteContext { drawing: d, dictionary: layout_dict }, + LayoutWriteData { + handle: &h, + name: &l.name, + tab: i64::from(l.tab_order.max(1)), + block_record: brh, + flags: 1, + page: &l.page, + view: l.view, + }, + ); + } +} + +fn write_root_group_objects( + w: &mut W, + plan: &ObjectWritePlan<'_>, + groups: &[(&Group, String)], + group_owner: &str, + written: &std::collections::HashSet, + mleader_dict: &str, +) { + let cx = plan.cx; + let root_dict = plan.root_dict; + let group_dict = plan.group_dict; + let layout_dict = plan.layout_dict; + let table_style_dict = plan.table_style_dict; + let pstyle_dict = plan.pstyle_dict; + let scale_dict = plan.scale_dict; + let xrecords = plan.xrecords; + w.s(0, "SECTION"); + w.s(2, "OBJECTS"); + w.s(0, "DICTIONARY"); + w.s(5, root_dict.clone()); + w.s(330, "0"); + w.s(100, "AcDbDictionary"); + w.i(281, 1); + w.s(3, "ACAD_GROUP"); + w.s(350, group_dict.clone()); + if !cx.images.is_empty() { + w.s(3, "ACAD_IMAGE_DICT"); + w.s(350, cx.images.dict.clone()); + w.s(3, "ACAD_IMAGE_VARS"); + w.s(350, cx.images.vars.clone()); + } + w.s(3, "ACAD_LAYOUT"); + w.s(350, layout_dict.clone()); + w.s(3, "ACAD_MLEADERSTYLE"); + w.s(350, mleader_dict.to_string()); + w.s(3, "ACAD_MLINESTYLE"); + w.s(350, cx.mlines.dict.clone()); + w.s(3, dxf_ext::PLOT_STYLE_NAMES_KEY); + w.s(350, pstyle_dict.clone()); + w.s(3, "ACAD_TABLESTYLE"); + w.s(350, table_style_dict.clone()); + for (key, h, _) in xrecords { + w.s(3, *key); + w.s(350, h); + } + w.s(3, "ACAD_SCALELIST"); + w.s(350, scale_dict.clone()); + w.s(0, "DICTIONARY"); + w.s(5, group_dict); + w.s(330, root_dict.clone()); + w.s(100, "AcDbDictionary"); + w.i(281, 1); + for (g, h) in groups { + w.s(3, &g.name); + w.s(350, h); + } + for (g, h) in groups { + group_obj(w, g, h, group_owner, written); + } +} + +fn write_style_objects(w: &mut W, plan: &ObjectWritePlan<'_>, mleader_dict: &str, mleader_handles: &[String]) { + let d = plan.d; + let cx = plan.cx; + let root_dict = plan.root_dict; + let table_style_dict = plan.table_style_dict; + let mleader_styles = plan.mleader_styles; + let table_styles = plan.table_styles; + let ltype_handles = plan.ltype_handles; + // Multileader styles. + w.s(0, "DICTIONARY"); + w.s(5, mleader_dict.to_string()); + w.s(330, root_dict.clone()); + w.s(100, "AcDbDictionary"); + w.i(281, 1); + for (s, h) in mleader_styles.iter().zip(mleader_handles) { + w.s(3, &s.name); + w.s(350, h); + } + let byblock_ltype = ltype_handles.get("BYBLOCK").cloned(); + for (s, h) in mleader_styles.iter().zip(mleader_handles) { + mleader_style_obj(w, s, h, mleader_dict, byblock_ltype.as_deref(), cx.style(&s.text_style)); + } + // Multiline styles. + w.t.extend(crate::dxf_mline::objects(&cx.mlines, root_dict)); + // Table styles. + w.s(0, "DICTIONARY"); + w.s(5, table_style_dict.clone()); + w.s(330, root_dict.clone()); + w.s(100, "AcDbDictionary"); + w.i(281, 1); + for (name, h) in &cx.table_styles { + w.s(3, name); + w.s(350, h); + } + for (s, (_, h)) in table_styles.iter().zip(&cx.table_styles) { + table_style_obj(w, d, s, h, table_style_dict); + } +} + +fn write_named_objects(w: &mut W, plan: &ObjectWritePlan<'_>) { + let root_dict = plan.root_dict; + let pstyle_dict = plan.pstyle_dict; + let xrecords = plan.xrecords; + let pstyles = plan.pstyles; + let scales = plan.scales; + let scale_dict = plan.scale_dict; + // Plot style names: a dictionary with a default (Normal) of placeholder objects. + w.s(0, "ACDBDICTIONARYWDFLT"); + w.s(5, pstyle_dict.clone()); + w.group("ACAD_REACTORS", 330, &[root_dict]); + w.s(330, root_dict.clone()); + w.s(100, "AcDbDictionary"); + w.i(281, 1); + for (n, h) in pstyles { + w.s(3, n); + w.s(350, h); + } + w.s(100, "AcDbDictionaryWithDefault"); + w.s(340, pstyles.first().map(|(_, h)| h.clone()).unwrap_or_default()); + for (_, h) in pstyles { + w.s(0, "ACDBPLACEHOLDER"); + w.s(5, h); + w.group("ACAD_REACTORS", 330, &[pstyle_dict]); + w.s(330, pstyle_dict.clone()); + } + // Parametric constraints and parameters, saved layer states, plot style tables (CADCraft + // data). + for (_, h, chunks) in xrecords { + w.s(0, "XRECORD"); + w.s(5, h); + w.group("ACAD_REACTORS", 330, &[root_dict]); + w.s(330, root_dict.clone()); + w.s(100, "AcDbXrecord"); + w.i(280, 1); + for c in chunks { + w.s(1, c.clone()); + } + } + scale_list(w, scales, scale_dict, root_dict); +} + +fn write_associative_objects(w: &mut W, cx: &Ctx) { + // Dimension associativity: extension dictionary + DIMASSOC per dimension. + let mut assoc: Vec<(&Handle, &AssocObj)> = cx.assoc.iter().collect(); + assoc.sort_by_key(|(h, _)| **h); + for (dim, a) in assoc { + let dh = dim.hex(); + w.s(0, "DICTIONARY"); + w.s(5, a.xdict.clone()); + w.group("ACAD_REACTORS", 330, &[&dh]); + w.s(330, dh.clone()); + w.s(100, "AcDbDictionary"); + w.i(280, 1); + w.i(281, 1); + w.s(3, "ACAD_DIMASSOC"); + w.s(360, a.handle.clone()); + w.s(0, "DIMASSOC"); + w.s(5, a.handle.clone()); + w.group("ACAD_REACTORS", 330, &[&a.xdict]); + w.s(330, a.xdict.clone()); + w.s(100, "AcDbDimAssoc"); + w.s(330, dh); + w.i(90, a.flags); + w.i(70, 0); + w.i(71, 0); + for r in &a.refs { + w.s(1, "AcDbOsnapPointRef"); + w.i(72, r.osnap); + w.s(331, r.main.hex()); + w.i(73, if r.segment > 0 { 2 } else { 0 }); + w.i(91, r.segment); + w.s(301, ""); + w.f(40, r.param); + w.p(10, r.point); + if let Some(o) = r.other { + w.s(332, o.hex()); + w.i(74, 0); + w.i(92, 0); + w.s(302, ""); + } + w.i(75, 0); + } + } +} + +fn write_objects(w: &mut W, plan: ObjectWritePlan<'_>) { + // Groups (members that still exist) and multileader styles. + let group_owner = plan.group_dict.clone(); + let written: std::collections::HashSet = w.t.iter().filter(|t| t.code == 5).map(Tag::str).collect(); + let groups: Vec<(&Group, String)> = plan.d.groups.iter().filter(|g| !g.name.is_empty()).map(|g| (g, w.h())).collect(); + let mleader_dict = w.h(); + let mleader_handles: Vec = plan.cx.mleader_styles.iter().map(|(_, h)| h.clone()).collect(); + write_root_group_objects(w, &plan, &groups, &group_owner, &written, &mleader_dict); + write_style_objects(w, &plan, &mleader_dict, &mleader_handles); + write_named_objects(w, &plan); + write_associative_objects(w, plan.cx); + write_layout_objects(w, &plan); + // Raster image definitions. + w.t.extend(crate::dxf_image::objects(&plan.cx.images, plan.root_dict)); + w.s(0, "ENDSEC"); +} + +fn dimension_block_definitions( + d: &Drawing, + all_spaces: &[&EntityStore], + dim_plan: &super::blocks::DimBlockPlan, + w: &mut W, + cx: &mut Ctx, +) -> Vec<(String, String, Vec)> { + let mut dim_defs = Vec::new(); + let mut n = 1; + let mut reused_handles = std::collections::HashSet::new(); + for st in all_spaces { + for e in st.iter() { + if let EntityKind::Dimension(dm) = &e.kind { + let reused = dim_plan.reuse.get(&e.handle); + let ents: Vec; + let name = match reused { + // A dimension still linked to the block it was read with hasn't changed since + // (edits drop the link, and the screen draws that block): the block is written + // as read, so other programs show it as they drew it. + Some(b) if !b.entities.is_empty() => { + ents = b.entities.iter().map(|x| x.as_ref().clone()).collect(); + reused_handles.extend(ents.iter().map(|x| x.handle).filter(|h| h.0 != 0)); + b.name.clone() + } + Some(b) => { + let mut fresh = dim_block_entities(d, dm, &e.common.layer); + reuse_handles(&mut fresh, b, &mut reused_handles); + ents = fresh; + b.name.clone() + } + None => { + ents = dim_block_entities(d, dm, &e.common.layer); + let mut name = format!("*D{n}"); + while d.block(&name).is_some() { + n += 1; + name = format!("*D{n}"); + } + n += 1; + name + } + }; + let brh = w.h(); + cx.dim_blocks.insert(e.handle, name.clone()); + dim_defs.push((name, brh, ents)); + } + } + } + dim_defs +} + +fn arrow_block_definitions( + d: &Drawing, + every: &[&Entity], + user_blocks: &[(String, String, &Block)], + w: &mut W, + cx: &mut Ctx, +) -> Vec<(String, String, Vec)> { + let mut arrow_names: Vec = Vec::new(); + for s in &d.dim_styles { + arrow_names.extend([s.arrow_block.clone(), s.arrow_block1.clone(), s.arrow_block2.clone(), s.leader_arrow_block.clone()]); + } + for e in every { + if let EntityKind::Dimension(dm) = &e.kind { + for (k, v) in &dm.overrides { + let Some(f) = DimStyle::field_name(k).filter(|f| f.starts_with("arrowBlock") || *f == "leaderArrowBlock") else { continue }; + if let Some(s) = dxf_ext::canonical(f, v).as_ref().and_then(|v| v.as_str()) { + arrow_names.push(s.to_string()); + } + } + } + } + let mut arrow_defs: Vec<(String, String, Vec)> = Vec::new(); + for name in arrow_names { + let key = name.trim().to_ascii_uppercase(); + if key.is_empty() || cx.arrows.contains_key(&key) { + continue; + } + if let Some((_, h, _)) = user_blocks.iter().find(|(n, _, _)| n.eq_ignore_ascii_case(name.trim())) { + cx.arrows.insert(key, h.clone()); + continue; + } + let Some((bname, kind)) = dxf_ext::arrow_block_name(&name) else { continue }; + let existing = arrow_defs.iter().find(|(n, _, _)| n.eq_ignore_ascii_case(&bname)).map(|(_, h, _)| h.clone()); + let existing = existing.or_else(|| user_blocks.iter().find(|(n, _, _)| n.eq_ignore_ascii_case(&bname)).map(|(_, h, _)| h.clone())); + let h = match existing { + Some(h) => h, + None => { + let h = w.h(); + arrow_defs.push((bname, h.clone(), arrow_block_entities(kind))); + h + } + }; + cx.arrows.insert(key, h); + } + + arrow_defs +} + +fn table_block_definitions(d: &Drawing, every: &[&Entity], w: &mut W, cx: &mut Ctx) -> Vec<(String, String, Vec)> { + let mut table_defs = Vec::new(); + let mut tn = 1; + for e in every { + if let EntityKind::Table(t) = &e.kind { + if cx.tables.contains_key(&e.handle) { + continue; + } + let mut name = format!("*T{tn}"); + while d.block(&name).is_some() { + tn += 1; + name = format!("*T{tn}"); + } + tn += 1; + let brh = w.h(); + cx.tables.insert(e.handle, (name.clone(), brh.clone())); + table_defs.push((name, brh, table_block_entities(d, t, &e.common.layer))); + } + } + + table_defs +} + +fn plan_dimension_associations(d: &Drawing, all_spaces: &[&EntityStore], w: &mut W, cx: &mut Ctx) { + for st in all_spaces { + for e in st.iter() { + if let EntityKind::Dimension(dm) = &e.kind { + let (flags, refs) = std_assoc_refs(d, dm); + if !refs.is_empty() { + cx.assoc.insert(e.handle, AssocObj { xdict: w.h(), handle: w.h(), flags, refs }); + } + } + } + } +} /// The drawing's DXF tags, declaring `version` in `$ACADVER`, with what `target` (the version the /// file ends up in: `version`, or the DWG version the bridge writes) has. @@ -45,125 +917,20 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version) -> Vec = user_blocks.into_iter().map(|(n, _, b)| (n, w.h(), b)).collect(); let mut cx = Ctx { paper_views: paper_views(d), target, ..Ctx::default() }; cx.block_records = user_blocks.iter().map(|(n, h, _)| (n.to_ascii_uppercase(), h.clone())).collect(); - // Dimension blocks. - let mut dim_defs: Vec<(String, String, Vec)> = Vec::new(); // filled below - let mut n = 1; - let mut reused_handles = std::collections::HashSet::new(); let all_spaces: Vec<&EntityStore> = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).collect(); - for st in &all_spaces { - for e in st.iter() { - if let EntityKind::Dimension(dm) = &e.kind { - let reused = dim_plan.reuse.get(&e.handle); - let ents: Vec; - let name = match reused { - // A dimension still linked to the block it was read with hasn't changed since - // (edits drop the link, and the screen draws that block): the block is written - // as read, so other programs show it as they drew it. - Some(b) if !b.entities.is_empty() => { - ents = b.entities.iter().map(|x| x.as_ref().clone()).collect(); - reused_handles.extend(ents.iter().map(|x| x.handle).filter(|h| h.0 != 0)); - b.name.clone() - } - Some(b) => { - let mut fresh = dim_block_entities(d, dm, &e.common.layer); - reuse_handles(&mut fresh, b, &mut reused_handles); - ents = fresh; - b.name.clone() - } - None => { - ents = dim_block_entities(d, dm, &e.common.layer); - let mut name = format!("*D{n}"); - while d.block(&name).is_some() { - n += 1; - name = format!("*D{n}"); - } - n += 1; - name - } - }; - let brh = w.h(); - cx.dim_blocks.insert(e.handle, name.clone()); - dim_defs.push((name, brh, ents)); - } - } - } + let mut dim_defs = dimension_block_definitions(d, &all_spaces, &dim_plan, &mut w, &mut cx); // Every entity, including block contents (for arrows, tables and overrides). let every: Vec<&Entity> = all_spaces .iter() .flat_map(|s| s.iter().map(|e| e.as_ref())) .chain(d.blocks.values().flat_map(|b| b.entities.iter().map(|e| e.as_ref()))) .collect(); - // Arrowhead blocks: user blocks by name, otherwise generated from our own geometry. - let mut arrow_names: Vec = Vec::new(); - for s in &d.dim_styles { - arrow_names.extend([s.arrow_block.clone(), s.arrow_block1.clone(), s.arrow_block2.clone(), s.leader_arrow_block.clone()]); - } - for e in &every { - if let EntityKind::Dimension(dm) = &e.kind { - for (k, v) in &dm.overrides { - let Some(f) = DimStyle::field_name(k).filter(|f| f.starts_with("arrowBlock") || *f == "leaderArrowBlock") else { continue }; - if let Some(s) = dxf_ext::canonical(f, v).as_ref().and_then(|v| v.as_str()) { - arrow_names.push(s.to_string()); - } - } - } - } - let mut arrow_defs: Vec<(String, String, Vec)> = Vec::new(); - for name in arrow_names { - let key = name.trim().to_ascii_uppercase(); - if key.is_empty() || cx.arrows.contains_key(&key) { - continue; - } - if let Some((_, h, _)) = user_blocks.iter().find(|(n, _, _)| n.eq_ignore_ascii_case(name.trim())) { - cx.arrows.insert(key, h.clone()); - continue; - } - let Some((bname, kind)) = dxf_ext::arrow_block_name(&name) else { continue }; - let existing = arrow_defs.iter().find(|(n, _, _)| n.eq_ignore_ascii_case(&bname)).map(|(_, h, _)| h.clone()); - let existing = existing.or_else(|| user_blocks.iter().find(|(n, _, _)| n.eq_ignore_ascii_case(&bname)).map(|(_, h, _)| h.clone())); - let h = match existing { - Some(h) => h, - None => { - let h = w.h(); - arrow_defs.push((bname, h.clone(), arrow_block_entities(kind))); - h - } - }; - cx.arrows.insert(key, h); - } - // Table blocks (`*T`). - let mut table_defs: Vec<(String, String, Vec)> = Vec::new(); - let mut tn = 1; - for e in &every { - if let EntityKind::Table(t) = &e.kind { - if cx.tables.contains_key(&e.handle) { - continue; - } - let mut name = format!("*T{tn}"); - while d.block(&name).is_some() { - tn += 1; - name = format!("*T{tn}"); - } - tn += 1; - let brh = w.h(); - cx.tables.insert(e.handle, (name.clone(), brh.clone())); - table_defs.push((name, brh, table_block_entities(d, t, &e.common.layer))); - } - } + let mut arrow_defs = arrow_block_definitions(d, &every, &user_blocks, &mut w, &mut cx); + let mut table_defs = table_block_definitions(d, &every, &mut w, &mut cx); // Image definitions (IMAGEDEF objects) of raster images anywhere in the drawing. cx.images = crate::dxf_image::plan(every.iter().copied(), || w.h()); cx.mlines = crate::dxf_mline::plan(d, every.iter().copied(), || w.h()); - // DIMASSOC objects of associative dimensions in model and paper space. - for st in &all_spaces { - for e in st.iter() { - if let EntityKind::Dimension(dm) = &e.kind { - let (flags, refs) = std_assoc_refs(d, dm); - if !refs.is_empty() { - cx.assoc.insert(e.handle, AssocObj { xdict: w.h(), handle: w.h(), flags, refs }); - } - } - } - } + plan_dimension_associations(d, &all_spaces, &mut w, &mut cx); let default_table_style = [TableStyle::default()]; let table_styles: &[TableStyle] = if d.table_styles.is_empty() { &default_table_style } else { &d.table_styles }; cx.table_styles = table_styles.iter().map(|s| (s.name.clone(), w.h())).collect(); @@ -213,325 +980,12 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version) -> Vec = ps_brs.iter().map(|_| w.h()).collect(); - // ---------------- HEADER ---------------- - w.s(0, "SECTION"); - w.s(2, "HEADER"); - w.s(9, "$ACADVER"); - w.s(1, version.code()); - w.s(9, "$DWGCODEPAGE"); - w.s(3, code_page(d, version)); - let ext = d.extents(&Space::Model); - if !ext.is_empty() { - w.s(9, "$EXTMIN"); - w.p(10, ext.min.to3(0.0)); - w.s(9, "$EXTMAX"); - w.p(10, ext.max.to3(0.0)); - } - header_vars(&mut w, d); - let seed_pos = w.t.len(); - w.s(9, "$HANDSEED"); - w.s(5, "0"); - w.s(0, "ENDSEC"); + let seed_pos = write_header(&mut w, d, version); - // ---------------- CLASSES ---------------- - w.s(0, "SECTION"); - w.s(2, "CLASSES"); - let mut classes = vec![ - ("TABLESTYLE", "AcDbTableStyle", 4095, false), - ("MLEADERSTYLE", "AcDbMLeaderStyle", 4095, false), - ("ACDBDICTIONARYWDFLT", "AcDbDictionaryWithDefault", 0, false), - ("ACDBPLACEHOLDER", "AcDbPlaceHolder", 0, false), - ]; - if !cx.tables.is_empty() { - classes.push(("ACAD_TABLE", "AcDbTable", 1025, true)); - } - if every.iter().any(|e| matches!(e.kind, EntityKind::Helix(_))) { - classes.push(("HELIX", "AcDbHelix", 4095, true)); - } - if !cx.assoc.is_empty() { - classes.push(("DIMASSOC", "AcDbDimAssoc", 0, false)); - } - if cx.native_mleader() && every.iter().any(|e| matches!(e.kind, EntityKind::MLeader(_))) { - classes.push(("MULTILEADER", "AcDbMLeader", 1025, true)); - } - if every.iter().any(|e| matches!(e.kind, EntityKind::Wipeout(_))) { - classes.push(("WIPEOUT", "AcDbWipeout", 127, true)); - } - if !cx.images.is_empty() { - classes.push(("IMAGE", "AcDbRasterImage", 127, true)); - classes.push(("IMAGEDEF", "AcDbRasterImageDef", 0, false)); - classes.push(("IMAGEDEF_REACTOR", "AcDbRasterImageDefReactor", 1, false)); - classes.push(("RASTERVARIABLES", "AcDbRasterVariables", 0, false)); - } - classes.push(("SCALE", "AcDbScale", 0, false)); - for (dxf_name, cpp, proxy, is_entity) in classes { - w.s(0, "CLASS"); - w.s(1, dxf_name); - w.s(2, cpp); - w.s(3, "ObjectDBX Classes"); - w.i(90, proxy); - w.i(280, 0); - w.i(281, i64::from(is_entity)); - } - w.s(0, "ENDSEC"); + write_classes(&mut w, &cx, &every); + + let ltype_handles = write_tables(&mut w, TableWritePlan { d, version, cx: &mut cx, ext: d.extents(&Space::Model) }); - // ---------------- TABLES ---------------- - w.s(0, "SECTION"); - w.s(2, "TABLES"); - vport_table(&mut w, d, ext); - // LTYPE. Embedded text and shapes point at STYLE records (340), which get their handles - // in the STYLE table below: (tag position, style name, is a shape) are filled in there. - let mut ltype_handles: HashMap = HashMap::new(); - let mut ltype_style_refs: Vec<(usize, Option, bool)> = Vec::new(); - let th = table_head(&mut w, "LTYPE", d.linetypes.len()); - for lt in &d.linetypes { - let h = record_head(&mut w, "LTYPE", &th, "AcDbLinetypeTableRecord"); - ltype_handles.entry(lt.name.to_ascii_uppercase()).or_insert(h.clone()); - cx.ltypes.entry(lt.name.to_ascii_uppercase()).or_insert(h); - w.s(2, <.name); - w.i(70, if crate::dxf_xref::dependent(<.name) { 48 } else { 0 }); - w.s(3, <.description); - w.i(72, 65); - w.i(73, lt.pattern.len() as i64); - w.f(40, lt.pattern_length()); - for el in <.pattern { - w.f(49, el.length); - // 74: 2 = text, 4 = shape, + 1 when the rotation is absolute (DXF Reference, LTYPE). - let (kind, shape) = match (&el.text, el.shape) { - (Some(_), _) => (2, 0), - (None, Some(n)) => (4, n), - (None, None) => (0, 0), - }; - if kind == 0 { - w.i(74, 0); - continue; - } - w.i(74, kind | i64::from(el.absolute)); - w.i(75, i64::from(shape)); - ltype_style_refs.push((w.t.len(), el.style.clone(), kind == 4)); - w.s(340, "0"); - w.f(46, el.scale); - w.f(50, el.rotation); - w.f(44, el.offset.x); - w.f(45, el.offset.y); - if let Some(t) = &el.text { - w.s(9, t.clone()); - } - } - } - w.s(0, "ENDTAB"); - // LAYER - let th = table_head(&mut w, "LAYER", d.layers.len()); - for l in &d.layers { - let lh = record_head(&mut w, "LAYER", &th, "AcDbLayerTableRecord"); - w.layers.insert(l.name.to_ascii_uppercase(), lh); - w.s(2, &l.name); - // 16 | 32: an xref's layer (`xref|name`), externally dependent and resolved. - let xref = if crate::dxf_xref::dependent(&l.name) { 48 } else { 0 }; - w.i(70, i64::from(l.frozen) | if l.vp_freeze_new { 2 } else { 0 } | if l.locked { 4 } else { 0 } | xref); - let aci = match l.color { - Color::True(rgb) => i64::from(cadcraft_color::nearest_aci(rgb)), - c => i64::from(c.to_aci()).clamp(1, 255), - }; - w.i(62, if l.on { aci } else { -aci }); - if let Color::True(rgb) = l.color { - w.i(420, i64::from(rgb.to_u32())); - } - w.s(6, &l.linetype); - if !l.plot { - w.i(290, 0); - } - w.i(370, i64::from(l.lineweight.to_dxf())); - let normal = w.pstyles.get(&cadcraft_doc::NORMAL_STYLE.to_ascii_uppercase()).cloned(); - if let Some(h) = w.pstyles.get(&l.plot_style.trim().to_ascii_uppercase()).cloned().or(normal) { - w.s(390, h); - } - if l.transparency > 0 { - w.s(1001, dxf_ext::LAYER_TRANSPARENCY_APP); - w.i(1071, dxf_ext::transparency_to_dxf(l.transparency)); - } - if !l.description.is_empty() { - // The first string is the layer standard's name, unused here. - w.s(1001, dxf_ext::LAYER_DESCRIPTION_APP); - w.s(1000, ""); - w.s(1000, dxf_ext::xdata_str(&l.description)); - } - } - w.s(0, "ENDTAB"); - // STYLE. Linetype shapes from a shape file that isn't a text style get an unnamed shape - // style record (70 bit 1) naming the file. - let mut shape_files: Vec = Vec::new(); - for (_, style, shape) in <ype_style_refs { - let Some(f) = style.as_deref().map(str::trim).filter(|f| *shape && !f.is_empty() && d.text_style(f).is_none()) else { continue }; - if !shape_files.iter().any(|x| x.eq_ignore_ascii_case(f)) { - shape_files.push(f.to_string()); - } - } - let th = table_head(&mut w, "STYLE", d.text_styles.len() + shape_files.len()); - for s in &d.text_styles { - let h = record_head(&mut w, "STYLE", &th, "AcDbTextStyleTableRecord"); - cx.styles.entry(s.name.to_ascii_uppercase()).or_insert(h); - w.s(2, &s.name); - // 70 bit 4: vertical; 71 bits 2/4: backwards / upside down. - w.i(70, if s.vertical { 4 } else { 0 }); - w.f(40, s.height); - w.f(41, s.width_factor); - w.f(50, s.oblique.to_degrees()); - w.i(71, if s.backwards { 2 } else { 0 } | if s.upside_down { 4 } else { 0 }); - w.f(42, 0.2); - // The built-in font goes out as `txt`, which every reader has; CADCraft's own name - // travels in `CADCRAFT` xdata (`1000 FONT`, name) so the style reopens with it. - let file = if s.font == cadcraft_fonts_name() { "txt" } else { s.font.as_str() }; - w.s(3, file); - w.s(4, &s.big_font); - if s.annotative { - annotative_xdata(&mut w); - } - if file != s.font { - w.s(1001, dxf_ext::APP); - w.s(1000, "FONT"); - w.s(1000, dxf_ext::xdata_str(&s.font)); - } - } - let mut shape_handles: HashMap = HashMap::new(); - for f in &shape_files { - let h = record_head(&mut w, "STYLE", &th, "AcDbTextStyleTableRecord"); - shape_handles.insert(f.to_ascii_uppercase(), h); - w.s(2, ""); - w.i(70, 1); - w.f(40, 0.0); - w.f(41, 1.0); - w.f(50, 0.0); - w.i(71, 0); - w.f(42, 0.2); - w.s(3, f.clone()); - w.s(4, ""); - } - w.s(0, "ENDTAB"); - // Linetype text and shapes without a known style use Standard (else the first style). - let fallback_style = cx.style("Standard").or_else(|| d.text_styles.first().and_then(|s| cx.style(&s.name))).unwrap_or_else(|| "0".into()); - for (pos, style, shape) in ltype_style_refs { - let name = style.as_deref().map(str::trim).unwrap_or_default(); - let h = shape.then(|| shape_handles.get(&name.to_ascii_uppercase()).cloned()).flatten().or_else(|| cx.style(name)); - if let Some(t) = w.t.get_mut(pos) { - *t = Tag::s(340, h.unwrap_or_else(|| fallback_style.clone())); - } - } - // VIEW: named views (DXF Reference, VIEW). A view's layer state is CADCraft xdata. - let th = table_head(&mut w, "VIEW", d.views.len()); - for v in &d.views { - record_head(&mut w, "VIEW", &th, "AcDbViewTableRecord"); - w.s(2, &v.name); - w.i(70, i64::from(v.layout.is_some())); - w.f(40, v.height); - w.p2(10, v.center); - w.f(41, v.width); - w.p(11, Vec3::Z); - w.p(12, Vec3::ZERO); - w.f(42, 50.0); - w.f(43, 0.0); - w.f(44, 0.0); - w.f(50, if v.twist.is_finite() { v.twist.to_degrees() } else { 0.0 }); - w.i(71, 0); - w.i(281, 0); - w.i(72, 0); - let xdata = [("LAYERSTATE", v.layer_state.as_deref()), ("LAYOUT", v.layout.as_deref().filter(|l| !l.is_empty()))]; - if xdata.iter().any(|(_, x)| x.is_some()) { - w.s(1001, dxf_ext::APP); - for (key, value) in xdata { - if let Some(value) = value { - w.s(1000, key); - w.s(1000, dxf_ext::xdata_str(value)); - } - } - } - } - w.s(0, "ENDTAB"); - // UCS: named user coordinate systems (DXF Reference, UCS). - let th = table_head(&mut w, "UCS", d.ucss.len()); - for u in &d.ucss { - record_head(&mut w, "UCS", &th, "AcDbUCSTableRecord"); - w.s(2, &u.name); - w.i(70, 0); - w.p(10, u.origin); - w.p(11, u.x_axis); - w.p(12, u.y_axis); - w.i(79, 0); - w.f(146, 0.0); - } - w.s(0, "ENDTAB"); - let apps = ["ACAD", dxf_ext::APP, "AcadAnnotative", dxf_ext::LAYER_TRANSPARENCY_APP, dxf_ext::LAYER_DESCRIPTION_APP]; - let th = table_head(&mut w, "APPID", apps.len()); - for app in apps { - record_head(&mut w, "APPID", &th, "AcDbRegAppTableRecord"); - w.s(2, app); - w.i(70, 0); - } - w.s(0, "ENDTAB"); - // DIMSTYLE - let th = { - let h = w.h(); - w.s(0, "TABLE"); - w.s(2, "DIMSTYLE"); - w.s(5, h.clone()); - w.s(330, "0"); - w.s(100, "AcDbSymbolTable"); - w.i(70, d.dim_styles.len() as i64); - w.s(100, "AcDbDimStyleTable"); - w.i(71, 0); - h - }; - for s in &d.dim_styles { - record_head(&mut w, "DIMSTYLE", &th, "AcDbDimStyleTableRecord"); - w.s(2, &s.name); - w.i(70, 0); - let v = serde_json::to_value(s).unwrap_or_default(); - let defaults = serde_json::to_value(DimStyle::default()).unwrap_or_default(); - let mut newer = W { t: Vec::new(), next: 0, pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() }; - for (field, code, kind) in dxf_ext::DIM_CODES { - let Some(enc) = v.get(*field).and_then(|x| cx.encode(*kind, x)) else { continue }; - // DIMPOST is written even when empty: a reader that defaults a missing one to "<>" - // (the DWG bridge's) would otherwise give radius and diameter dimensions no "R" or - // "Ø" in AutoCAD (#1053). - if *code == dxf_ext::DIMPOST - && let DimVal::Str(t) = &enc - && t.is_empty() - { - w.s(*code, ""); - continue; - } - if !dxf_ext::NEWER_CODES.contains(code) { - w.dimval(*code, enc, false); - continue; - } - // Table groups where the file version has them, else xdata. DIMTFILL and DIMTFILLCLR - // are written only when set, as other writers do, so a style without a text - // background has a single 70 (its flags). - if version >= dxf_ext::newer_since(*code) { - if matches!(*code, 69 | 70) && v.get(*field) == defaults.get(*field) { - continue; - } - w.dimval(*code, enc, false); - } else if v.get(*field) != defaults.get(*field) { - newer.i(1070, i64::from(*code)); - newer.dimval(*code, enc, true); - } - } - if !s.arrow_block1.trim().is_empty() || !s.arrow_block2.trim().is_empty() { - w.i(dxf_ext::DIMSAH, 1); - } - if s.annotative { - annotative_xdata(&mut w); - } - if !newer.t.is_empty() { - w.s(1001, dxf_ext::APP); - w.s(1000, dxf_ext::DIMVARS_LIST); - w.s(1002, "{"); - w.xdata(newer.t); - w.s(1002, "}"); - } - } - w.s(0, "ENDTAB"); // BLOCK_RECORD let th = table_head(&mut w, "BLOCK_RECORD", 1 + ps_brs.len() + user_blocks.len() + dim_defs.len() + arrow_defs.len() + table_defs.len()); let br_rec = |w: &mut W, h: &str, name: &str, layout: Option<&str>, blk: Option<&Block>| { @@ -559,7 +1013,7 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version) -> Vec Vec = w.t.iter().filter(|t| t.code == 5).map(Tag::str).collect(); - let groups: Vec<(&Group, String)> = d.groups.iter().filter(|g| !g.name.is_empty()).map(|g| (g, w.h())).collect(); - let mleader_dict = w.h(); - let mleader_handles: Vec = cx.mleader_styles.iter().map(|(_, h)| h.clone()).collect(); - w.s(0, "SECTION"); - w.s(2, "OBJECTS"); - w.s(0, "DICTIONARY"); - w.s(5, root_dict.clone()); - w.s(330, "0"); - w.s(100, "AcDbDictionary"); - w.i(281, 1); - w.s(3, "ACAD_GROUP"); - w.s(350, group_dict.clone()); - if !cx.images.is_empty() { - w.s(3, "ACAD_IMAGE_DICT"); - w.s(350, cx.images.dict.clone()); - w.s(3, "ACAD_IMAGE_VARS"); - w.s(350, cx.images.vars.clone()); - } - w.s(3, "ACAD_LAYOUT"); - w.s(350, layout_dict.clone()); - w.s(3, "ACAD_MLEADERSTYLE"); - w.s(350, mleader_dict.clone()); - w.s(3, "ACAD_MLINESTYLE"); - w.s(350, cx.mlines.dict.clone()); - w.s(3, dxf_ext::PLOT_STYLE_NAMES_KEY); - w.s(350, pstyle_dict.clone()); - w.s(3, "ACAD_TABLESTYLE"); - w.s(350, table_style_dict.clone()); - for (key, h, _) in &xrecords { - w.s(3, *key); - w.s(350, h); - } - w.s(3, "ACAD_SCALELIST"); - w.s(350, scale_dict.clone()); - w.s(0, "DICTIONARY"); - w.s(5, group_dict); - w.s(330, root_dict.clone()); - w.s(100, "AcDbDictionary"); - w.i(281, 1); - for (g, h) in &groups { - w.s(3, &g.name); - w.s(350, h); - } - for (g, h) in &groups { - group_obj(&mut w, g, h, &group_owner, &written); - } - // Multileader styles. - w.s(0, "DICTIONARY"); - w.s(5, mleader_dict.clone()); - w.s(330, root_dict.clone()); - w.s(100, "AcDbDictionary"); - w.i(281, 1); - for (s, h) in mleader_styles.iter().zip(&mleader_handles) { - w.s(3, &s.name); - w.s(350, h); - } - let byblock_ltype = ltype_handles.get("BYBLOCK").cloned(); - for (s, h) in mleader_styles.iter().zip(&mleader_handles) { - mleader_style_obj(&mut w, s, h, &mleader_dict, byblock_ltype.as_deref(), cx.style(&s.text_style)); - } - // Multiline styles. - w.t.extend(crate::dxf_mline::objects(&cx.mlines, &root_dict)); - // Table styles. - w.s(0, "DICTIONARY"); - w.s(5, table_style_dict.clone()); - w.s(330, root_dict.clone()); - w.s(100, "AcDbDictionary"); - w.i(281, 1); - for (name, h) in &cx.table_styles { - w.s(3, name); - w.s(350, h); - } - for (s, (_, h)) in table_styles.iter().zip(&cx.table_styles) { - table_style_obj(&mut w, d, s, h, &table_style_dict); - } - // Plot style names: a dictionary with a default (Normal) of placeholder objects. - w.s(0, "ACDBDICTIONARYWDFLT"); - w.s(5, pstyle_dict.clone()); - w.group("ACAD_REACTORS", 330, &[&root_dict]); - w.s(330, root_dict.clone()); - w.s(100, "AcDbDictionary"); - w.i(281, 1); - for (n, h) in &pstyles { - w.s(3, n); - w.s(350, h); - } - w.s(100, "AcDbDictionaryWithDefault"); - w.s(340, pstyles.first().map(|(_, h)| h.clone()).unwrap_or_default()); - for (_, h) in &pstyles { - w.s(0, "ACDBPLACEHOLDER"); - w.s(5, h); - w.group("ACAD_REACTORS", 330, &[&pstyle_dict]); - w.s(330, pstyle_dict.clone()); - } - // Parametric constraints and parameters, saved layer states, plot style tables (CADCraft - // data). - for (_, h, chunks) in &xrecords { - w.s(0, "XRECORD"); - w.s(5, h); - w.group("ACAD_REACTORS", 330, &[&root_dict]); - w.s(330, root_dict.clone()); - w.s(100, "AcDbXrecord"); - w.i(280, 1); - for c in chunks { - w.s(1, c.clone()); - } - } - scale_list(&mut w, &scales, &scale_dict, &root_dict); - // Dimension associativity: extension dictionary + DIMASSOC per dimension. - let mut assoc: Vec<(&Handle, &AssocObj)> = cx.assoc.iter().collect(); - assoc.sort_by_key(|(h, _)| **h); - for (dim, a) in assoc { - let dh = dim.hex(); - w.s(0, "DICTIONARY"); - w.s(5, a.xdict.clone()); - w.group("ACAD_REACTORS", 330, &[&dh]); - w.s(330, dh.clone()); - w.s(100, "AcDbDictionary"); - w.i(280, 1); - w.i(281, 1); - w.s(3, "ACAD_DIMASSOC"); - w.s(360, a.handle.clone()); - w.s(0, "DIMASSOC"); - w.s(5, a.handle.clone()); - w.group("ACAD_REACTORS", 330, &[&a.xdict]); - w.s(330, a.xdict.clone()); - w.s(100, "AcDbDimAssoc"); - w.s(330, dh); - w.i(90, a.flags); - w.i(70, 0); - w.i(71, 0); - for r in &a.refs { - w.s(1, "AcDbOsnapPointRef"); - w.i(72, r.osnap); - w.s(331, r.main.hex()); - w.i(73, if r.segment > 0 { 2 } else { 0 }); - w.i(91, r.segment); - w.s(301, ""); - w.f(40, r.param); - w.p(10, r.point); - if let Some(o) = r.other { - w.s(332, o.hex()); - w.i(74, 0); - w.i(92, 0); - w.s(302, ""); - } - w.i(75, 0); - } - } - w.s(0, "DICTIONARY"); - w.s(5, layout_dict.clone()); - w.s(330, root_dict.clone()); - w.s(100, "AcDbDictionary"); - w.i(281, 1); - w.s(3, "Model"); - w.s(350, model_layout.clone()); - for (i, (_, _, l)) in ps_brs.iter().enumerate() { - w.s(3, &l.name); - w.s(350, layout_handles.get(i).cloned().unwrap_or_default()); - } - let layout_obj = |w: &mut W, h: &str, (name, tab): (&str, i64), brh: &str, flags: i64, page: &PageSetup, view: Option<(Vec2, f64)>| { - // Plot scale: a standard scale when fitting or 1:1, otherwise custom (142 paper units - // per 143 drawing units). - let scale = if page.scale.is_finite() && page.scale > 0.0 { page.scale } else { 1.0 }; - let standard = page.scale_to_fit || scale == 1.0; - let plot_flags = 512 - | 32 - | if standard { 16 } else { 0 } - | if page.lineweights { 128 } else { 0 } - | if page.center { 4 } else { 0 } - | if page.show_plot_styles { 2 } else { 0 }; - let plot_type = match page.plot_area.as_str() { - "display" => 0, - "extents" => 1, - "limits" => 2, - "window" => 4, - _ => 5, - }; - w.s(0, "LAYOUT"); - w.s(5, h); - w.s(330, layout_dict.clone()); - w.s(100, "AcDbPlotSettings"); - w.s(1, ""); - let device = page.device.trim(); - w.s(2, if device.is_empty() || device.eq_ignore_ascii_case("None") { "none_device" } else { device }); - w.s(4, page.paper.replace(' ', "_")); - w.s(6, ""); - for (c, v) in [ - (40, page.margins_mm[0]), - (41, page.margins_mm[1]), - (42, page.margins_mm[2]), - (43, page.margins_mm[3]), - (44, page.width_mm), - (45, page.height_mm), - (46, 0.0), - (47, 0.0), - (48, page.plot_window[0]), - (49, page.plot_window[1]), - (140, page.plot_window[2]), - (141, page.plot_window[3]), - (142, scale), - (143, 1.0), - ] { - w.f(c, v); - } - w.i(70, plot_flags); - // Plot paper units: 1 millimetres, 0 inches (#1058). - w.i(72, i64::from(cadcraft_render::paper::page_unit_mm(d, page) == 1.0)); - w.i(73, i64::from(page.landscape)); - w.i(74, plot_type); - w.s(7, &page.plot_style_table); - w.i(75, if page.scale_to_fit { 0 } else { 16 }); - w.f(147, scale); - w.f(148, 0.0); - w.f(149, 0.0); - w.s(100, "AcDbLayout"); - w.s(1, name); - w.i(70, flags); - w.i(71, tab); - w.p2(10, Vec2::ZERO); - w.p2(11, Vec2::new(12.0, 9.0)); - w.p(12, Vec3::ZERO); - w.p(14, Vec3::ZERO); - w.p(15, Vec3::ZERO); - w.f(146, 0.0); - w.p(13, Vec3::ZERO); - w.p(16, Vec3::new(1.0, 0.0, 0.0)); - w.p(17, Vec3::new(0.0, 1.0, 0.0)); - w.i(76, 0); - w.s(330, brh); - // The saved paper-space view (centre, height) as CADCraft xdata. - if let Some((c, height)) = view.filter(|(c, v)| c.x.is_finite() && c.y.is_finite() && v.is_finite()) { - w.s(1001, dxf_ext::APP); - w.s(1000, "PSVIEW"); - w.s(1002, "{"); - w.p(1010, c.to3(0.0)); - w.f(1040, height); - w.s(1002, "}"); - } - }; - // Model space has no page setup of its own: write what PLOT does for it, the drawing extents - // fitted to the paper (plot type 1, scaled to fit). The default page's "layout" area is - // plot type 5, "Layout information" (DXF Reference, PLOTSETTINGS group 74), which means - // nothing for model space: another program's Plot dialog then shows no plot area or scale. - let model_page = PageSetup { plot_area: "extents".into(), scale_to_fit: true, ..PageSetup::default() }; - layout_obj(&mut w, &model_layout, ("Model", 0), &ms_br, 1, &model_page, None); - for (i, (_, brh, l)) in ps_brs.iter().enumerate() { - let h = layout_handles.get(i).cloned().unwrap_or_default(); - layout_obj(&mut w, &h, (&l.name, i64::from(l.tab_order.max(1))), brh, 1, &l.page, l.view); - } - // Raster image definitions. - w.t.extend(crate::dxf_image::objects(&cx.images, &root_dict)); - w.s(0, "ENDSEC"); w.s(0, "EOF"); let seed = format!("{:X}", w.next); if let Some(t) = w.t.get_mut(seed_pos + 1) { diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs index ef56e6602..8cad3f24f 100644 --- a/crates/io/src/lib.rs +++ b/crates/io/src/lib.rs @@ -22,7 +22,9 @@ mod dxf_mline; use cadcraft_doc::{Drawing, Space}; use cadcraft_geom::Bounds2; +use std::path::{Path, PathBuf}; +pub use cadcraft_doc::Format; pub use cadcraft_dxf::Version; pub use dxf_read::entity_from_groups; pub use dxf_write::entity_groups; @@ -53,40 +55,42 @@ pub enum IoError { pub type Result = std::result::Result; -fn ext(name: &str) -> String { - std::path::Path::new(name).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default() +fn ext(name: impl AsRef) -> String { + name.as_ref().extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default() } /// Read a drawing; the format comes from the content (DXF ASCII/binary, DWG) or the name /// (SVG and gzip-compressed SVGZ). -pub fn read(bytes: &[u8], name: &str) -> Result { +pub fn read(bytes: &[u8], name: impl AsRef) -> Result { + let name = name.as_ref(); if cadcraft_dwg::is_dwg(bytes) { let (dxf, notes) = cadcraft_dwg::dwg_to_dxf_noted(bytes, cadcraft_dwg::Limits::DEFAULT).map_err(IoError::Format)?; let mut d = dxf_read::read(&dxf).map_err(|e| IoError::Format(format!("{e} (in the DXF converted from this DWG)")))?; d.read_notes = notes; return Ok(d); } - match ext(name).as_str() { - "svg" | "svgz" => svg_read::read(bytes), - "dxf" | "" => dxf_read::read(bytes), - e if bytes.len() > 4 => dxf_read::read(bytes).map_err(|_| IoError::Unsupported(e.to_string())), - e => Err(IoError::Unsupported(e.to_string())), + match (Format::from_path(name), ext(name).as_str()) { + (Some(Format::Svg | Format::Svgz), _) => svg_read::read(bytes), + (Some(Format::Dxf), _) => dxf_read::read(bytes), + (_, e) if bytes.len() > 4 => dxf_read::read(bytes).map_err(|_| IoError::Unsupported(e.to_string())), + (_, e) => Err(IoError::Unsupported(e.to_string())), } } /// Write a drawing in the format chosen by the name's extension. Images (PNG, SVG, PDF) show /// model space fitted to its extents. DXF and DWG are written in the drawing's version /// ([`save_version`]), DXF as ASCII. -pub fn write(d: &Drawing, name: &str) -> Result> { +pub fn write(d: &Drawing, name: impl AsRef) -> Result> { write_framed(d, name, None) } /// Like [`write`], with the DXF/DWG version and binary DXF chosen by `opts`. Binary applies to /// DXF only; asking for it with another format is an error. -pub fn write_with(d: &Drawing, name: &str, opts: &SaveOptions) -> Result> { +pub fn write_with(d: &Drawing, name: impl AsRef, opts: &SaveOptions) -> Result> { + let name = name.as_ref(); let version = opts.version.unwrap_or_else(|| save_version(d)); - match ext(name).as_str() { - "dxf" | "" => { + match Format::from_path(name) { + Some(Format::Dxf) => { let tags = dxf_write::tags(d, version); Ok(if opts.binary { cadcraft_dxf::write_binary(&tags, version.utf8()) @@ -97,11 +101,11 @@ pub fn write_with(d: &Drawing, name: &str, opts: &SaveOptions) -> Result // The DWG bridge reads our R2000 DXF and writes the DWG at the version asked for. Without // one, at least 2004: R2000 DWG has no true colours, transparency, table styles or // gradients, so a drawing from an R2000 DXF doesn't lose them by default. - "dwg" if !opts.binary => { + Some(Format::Dwg) if !opts.binary => { let version = opts.version.unwrap_or_else(|| version.max(Version::R2004)); cadcraft_dwg::dxf_to_dwg_as(dxf_write::dwg_bridge(d, version).as_bytes(), version.code()).map_err(IoError::Format) } - e if opts.binary => Err(IoError::Format(format!("binary output is for DXF files, not `{e}`"))), + _ if opts.binary => Err(IoError::Format(format!("binary output is for DXF files, not `{}`", ext(name)))), _ => write_framed(d, name, None), } } @@ -110,28 +114,32 @@ pub fn write_with(d: &Drawing, name: &str, opts: &SaveOptions) -> Result /// drawing units, centred and scaled to fit the image without distortion) instead of the /// extents. Formats that are not images (DXF, DWG) ignore the window. The window is checked with /// [`check_window`]. -pub fn write_framed(d: &Drawing, name: &str, window: Option) -> Result> { +pub fn write_framed(d: &Drawing, name: impl AsRef, window: Option) -> Result> { + let name = name.as_ref(); // A drawing template (.dwt) is DWG content. - if ext(name) == "dwt" { - return write_framed(d, &format!("{name}.dwg"), None); + let format = Format::from_path(name); + if format == Some(Format::Dwt) { + let mut dwg = name.as_os_str().to_owned(); + dwg.push(".dwg"); + return write_framed(d, PathBuf::from(dwg), None); } if let Some(w) = &window && is_image(name) { check_window(w)?; } - match ext(name).as_str() { - "dxf" | "" | "dwg" => write_with(d, name, &SaveOptions::default()), - "svg" => Ok(svg::export_window(d, &Space::Model, window).into_bytes()), - "png" => png_framed(d, &Space::Model, 2400, 1600, window), - "pdf" => pdf::pdf(d, &Space::Model, &PdfOptions { compress: true, window, ..PdfOptions::default() }), - e => Err(IoError::Unsupported(e.to_string())), + match format { + Some(Format::Dxf | Format::Dwg) => write_with(d, name, &SaveOptions::default()), + Some(Format::Svg) => Ok(svg::export_window(d, &Space::Model, window).into_bytes()), + Some(Format::Png) => png_framed(d, &Space::Model, 2400, 1600, window), + Some(Format::Pdf) => pdf::pdf(d, &Space::Model, &PdfOptions { compress: true, window, ..PdfOptions::default() }), + _ => Err(IoError::Unsupported(ext(name))), } } /// Whether `name` is written as an image (PNG, SVG, PDF), i.e. whether framing applies to it. -pub fn is_image(name: &str) -> bool { - matches!(ext(name).as_str(), "png" | "svg" | "pdf") +pub fn is_image(name: impl AsRef) -> bool { + Format::from_path(name).is_some_and(Format::is_image) } /// Largest coordinate magnitude accepted in an export window. diff --git a/crates/io/src/tests.rs b/crates/io/src/tests.rs index de813435e..3af927837 100644 --- a/crates/io/src/tests.rs +++ b/crates/io/src/tests.rs @@ -2851,3 +2851,17 @@ fn proxies_keep_their_class_when_classes_are_rewritten() { dxf_records(&pairs, "ACAD_PROXY_OBJECT").iter().map(|r| classes[own_91(r).parse::().unwrap() - 500].clone()).collect(); assert_eq!(names, ["VISUALSTYLE", "WIDGETX"]); } + +/// A name that isn't valid Unicode still picks its format by extension. +#[cfg(unix)] +#[test] +fn non_unicode_names_pick_the_format_by_extension() { + use std::os::unix::ffi::OsStringExt as _; + let name = |ext: &str| std::path::PathBuf::from(std::ffi::OsString::from_vec([b"caf\xe9.".as_slice(), ext.as_bytes()].concat())); + assert!(is_image(name("png")) && !is_image(name("dxf"))); + let d = sample(); + let bytes = write(&d, name("dxf")).unwrap(); + assert!(read(&bytes, name("dxf")).is_ok()); + assert!(write(&d, name("png")).unwrap().starts_with(b"\x89PNG")); + assert!(write(&d, name("dwt")).is_ok(), "a template is written as DWG"); +} diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml index 955a6b6d2..1359fbdda 100644 --- a/crates/mcp/Cargo.toml +++ b/crates/mcp/Cargo.toml @@ -12,6 +12,7 @@ workspace = true cadcraft-engine = { workspace = true } cadcraft-render = { workspace = true } cadcraft-io = { workspace = true } +clap = { workspace = true } serde_json = { workspace = true } log = { workspace = true } # Secure randomness for the per-session control token (MIT OR Apache-2.0). diff --git a/crates/mcp/src/args.rs b/crates/mcp/src/args.rs new file mode 100644 index 000000000..a47a90bdd --- /dev/null +++ b/crates/mcp/src/args.rs @@ -0,0 +1,51 @@ +//! Helpers for clap parsers shared by the apps: environment variables as flag fallbacks. +//! +//! Apply [`blank_env_is_unset`] to the arguments, so an empty variable counts as unset, and pass a +//! parse error through [`name_env_vars`], so a bad value names the variable it came from. + +use std::ffi::{OsStr, OsString}; + +use clap::{Arg, Command}; + +/// For `Command::mut_args`: an empty or blank variable counts as unset, so `CADCRAFT_CONTROL_PORT=` +/// turns a fallback off without `unset`. clap would pass the empty value to the parser. `var` +/// looks the variable up. +pub fn blank_env_is_unset(arg: Arg, var: impl Fn(&OsStr) -> Option) -> Arg { + let blank = arg.get_env().and_then(var).is_some_and(|v| v.to_str().is_some_and(|v| v.trim().is_empty())); + if blank { arg.env(None::<&str>) } else { arg } +} + +/// clap names the flag when a value from its variable is bad or conflicts with another, as if the +/// flag had been given: name the variable instead when the flag isn't among `args` (without the +/// binary name; a first one naming a subcommand selects whose arguments to look in). +pub fn name_env_vars(mut error: clap::Error, cmd: &Command, args: &[OsString]) -> clap::Error { + use clap::error::{ContextKind, ContextValue}; + // `--flag value` or `--flag=value`. + let given = + |long: &str| args.iter().filter_map(|a| a.to_str()?.strip_prefix("--")?.strip_prefix(long)).any(|r| r.is_empty() || r.starts_with('=')); + let sub = args.first().and_then(|name| cmd.find_subcommand(name)).unwrap_or(cmd); + for kind in [ContextKind::InvalidArg, ContextKind::PriorArg] { + let Some(ContextValue::String(shown)) = error.get(kind) else { continue }; + let Some(arg) = sub.get_arguments().find(|a| a.to_string() == *shown) else { continue }; + let (Some(long), Some(var)) = (arg.get_long(), arg.get_env()) else { continue }; + if !given(long) { + error.insert(kind, ContextValue::String(var.to_string_lossy().into_owned())); + } + } + error +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn blank_variables_count_as_unset() { + let arg = || Arg::new("control").long("control").env("CADCRAFT_CONTROL_PORT"); + for value in ["", " "] { + assert_eq!(blank_env_is_unset(arg(), |_| Some(value.into())).get_env(), None, "{value:?}"); + } + assert!(blank_env_is_unset(arg(), |_| Some(" 50494 ".into())).get_env().is_some()); + assert!(blank_env_is_unset(arg(), |_| None).get_env().is_some()); + } +} diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rs index 7fcf4849d..932d855e4 100644 --- a/crates/mcp/src/lib.rs +++ b/crates/mcp/src/lib.rs @@ -8,6 +8,7 @@ #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] #![forbid(unsafe_code)] +pub mod args; mod backend; pub mod control_token; mod server; diff --git a/crates/render/src/blocks.rs b/crates/render/src/blocks.rs index d8a62fddc..ad4689682 100644 --- a/crates/render/src/blocks.rs +++ b/crates/render/src/blocks.rs @@ -1,7 +1,7 @@ use super::draw::entity; use super::props::{resolve, resolve_common, transparency}; use super::text_entity::{mtext, place_text_entity}; -use super::*; +use super::{Builder, Color, Ctx, Entity, EntityKind, Ink, Lineweight, Mat3, Vec2}; pub(crate) fn sub_ctx<'a>(ctx: &Ctx<'a>, e: &Entity, m: Mat3) -> Ctx<'a> { let layer = if e.common.layer == "0" { ctx.block_layer.clone() } else { Some(e.common.layer.clone()) }; diff --git a/crates/render/src/dim.rs b/crates/render/src/dim.rs index a2f0021a2..967a2962c 100644 --- a/crates/render/src/dim.rs +++ b/crates/render/src/dim.rs @@ -8,9 +8,9 @@ use cadcraft_doc::{DimKind, DimStyle, Dimension}; use cadcraft_fonts::{MTextParams, TextFont}; -use cadcraft_geom::{Arc, Vec2, ccw_sweep}; +use cadcraft_geom::Vec2; -use crate::units::{NumFormat, format_angle_with_separator, format_decimal, format_linear}; +use crate::units::{NumFormat, format_decimal, format_linear}; mod arrowheads; mod text; @@ -18,7 +18,6 @@ mod text; use arrowheads::tick; pub use arrowheads::{ArrowGeom, Arrowhead, arrow, arrowhead}; pub use text::{DimText, format_linear_value}; -use text::{apply_override, inspected, linear_text}; /// Most DIMBREAK gaps drawn per dimension. const MAX_BREAKS: usize = 1000; @@ -216,6 +215,75 @@ fn readable(a: f64) -> f64 { a } +struct DimConfig<'a> { + dimension: &'a Dimension, + style: &'a DimStyle, + font: &'a DimText, + scale: f64, + arrow_size: f64, + text_height: f64, + gap: f64, + tick_size: f64, + ticks: bool, + first_arrow: Arrowhead, + second_arrow: Arrowhead, + width_factor: f64, +} + +impl<'a> DimConfig<'a> { + fn new(dimension: &'a Dimension, style: &'a DimStyle, dimscale: f64, font: &'a DimText) -> Self { + let scale = style.effective_scale(dimscale); + let arrow_size = style.arrow_size * scale; + let text_height = if font.fixed_height > 0.0 { font.fixed_height } else { style.text_height * scale }; + let tick_size = style.tick_size * scale; + let first_arrow = if style.arrow_block1.is_empty() { &style.arrow_block } else { &style.arrow_block1 }; + let second_arrow = if style.arrow_block2.is_empty() { &style.arrow_block } else { &style.arrow_block2 }; + Self { + dimension, + style, + font, + scale, + arrow_size, + text_height, + gap: style.text_gap.abs() * scale, + tick_size, + ticks: tick_size > 0.0, + first_arrow: Arrowhead::parse(first_arrow), + second_arrow: Arrowhead::parse(second_arrow), + width_factor: if font.width_factor > 0.0 && font.width_factor.is_finite() { font.width_factor } else { 1.0 }, + } + } + + fn text_params(&self, at: Vec2, rotation: f64) -> MTextParams { + MTextParams { + attach: 5, + rotation, + font: self.font.font.clone(), + width_factor: self.width_factor, + oblique: self.font.oblique, + ..MTextParams::new(at, self.text_height) + } + } + + fn measure(&self, text: &str) -> (f64, f64) { + if text.is_empty() { + return (0.0, 0.0); + } + let layout = cadcraft_fonts::layout_mtext_with(text, &self.text_params(Vec2::ZERO, 0.0)); + (layout.bounds.width(), layout.bounds.height()) + } + + fn end(&self, geometry: &mut DimGeometry, kind: Arrowhead, tip: Vec2, direction: Vec2) -> f64 { + if self.ticks { + geometry.dim(tick(tip, direction, self.tick_size)); + 0.0 + } else { + geometry.add_arrow(arrowhead(kind, tip, direction, self.arrow_size)); + kind.inset(self.arrow_size) + } + } +} + /// Generate the geometry of a dimension with the stroke font. pub fn dimension_geometry(d: &Dimension, st: &DimStyle, dimscale: f64) -> DimGeometry { dimension_geometry_with(d, st, dimscale, &DimText { width_factor: 1.0, ..Default::default() }) @@ -223,470 +291,24 @@ pub fn dimension_geometry(d: &Dimension, st: &DimStyle, dimscale: f64) -> DimGeo /// Generate the geometry of a dimension. The dimension's own overrides are applied to `st`. pub fn dimension_geometry_with(d: &Dimension, st: &DimStyle, dimscale: f64, font: &DimText) -> DimGeometry { - let st = &st.with_overrides(&d.overrides); - let k = st.effective_scale(dimscale); - let asz = st.arrow_size * k; - let th = if font.fixed_height > 0.0 { font.fixed_height } else { st.text_height * k }; - let gap = st.text_gap.abs() * k; - let tsz = st.tick_size * k; - let ticks = tsz > 0.0; - let blk1 = Arrowhead::parse(if st.arrow_block1.is_empty() { &st.arrow_block } else { &st.arrow_block1 }); - let blk2 = Arrowhead::parse(if st.arrow_block2.is_empty() { &st.arrow_block } else { &st.arrow_block2 }); + let overridden = st.with_overrides(&d.overrides); + let config = DimConfig::new(d, &overridden, dimscale, font); + let st = config.style; + let th = config.text_height; + let gap = config.gap; let mut g = DimGeometry { text_height: th, ..Default::default() }; - // Measure the text: lay it out once at the origin, centred. - let wf = if font.width_factor > 0.0 && font.width_factor.is_finite() { font.width_factor } else { 1.0 }; - let params = |mt: Vec2, rot: f64| MTextParams { - attach: 5, - rotation: rot, - font: font.font.clone(), - width_factor: wf, - oblique: font.oblique, - ..MTextParams::new(mt, th) - }; - let measure = |text: &str| { - if text.is_empty() { - return (0.0, 0.0); - } - let l = cadcraft_fonts::layout_mtext_with(text, ¶ms(Vec2::ZERO, 0.0)); - (l.bounds.width(), l.bounds.height()) - }; + let params = |at: Vec2, rotation: f64| config.text_params(at, rotation); + let measure = |text: &str| config.measure(text); let mut text_angle = 0.0; let mut text_mid = d.text_mid.xy(); // Place an end marker: tick or arrowhead. Returns how far the dimension line stops short. - let end = |g: &mut DimGeometry, kind: Arrowhead, tip: Vec2, dir: Vec2| -> f64 { - if ticks { - g.dim(tick(tip, dir, tsz)); - 0.0 - } else { - g.add_arrow(arrowhead(kind, tip, dir, asz)); - kind.inset(asz) - } - }; match d.kind { - DimKind::Linear { .. } | DimKind::Aligned => { - let p1 = d.p13.xy(); - let p2 = d.p14.xy(); - let on = d.defpt.xy(); - let dir = match d.kind { - DimKind::Linear { rotation } => Vec2::from_angle(rotation), - _ => (p2 - p1).normalized(), - }; - let dir = if dir == Vec2::ZERO || !dir.is_finite() { Vec2::X } else { dir }; - // DIMEDIT Oblique: extension lines at their own angle (not along the dimension line). - let oblique = d.marks.oblique.map(Vec2::from_angle).filter(|e| e.is_finite() && e.cross(dir).abs() > 1e-6); - let foot = |p: Vec2| match oblique { - Some(e) => p + e * ((on - p).cross(dir) / e.cross(dir)), - None => on + dir * (p - on).dot(dir), - }; - let f1 = foot(p1); - let f2 = foot(p2); - // The measurement is along the dimension direction whatever the extension lines do. - let meas = (p2 - p1).dot(dir).abs(); - g.mtext = linear_text(meas, d, st, ""); - g.measurement = meas; - // From here on: the length drawn between the extension lines. - let meas = f1.dist(f2); - if !st.suppress_ext1 { - g.ext_n(ext_line(p1, f1, st, k), false); - } - if !st.suppress_ext2 { - g.ext_n(ext_line(p2, f2, st, k), true); - } - let u = (f2 - f1).normalized(); - let u = if u == Vec2::ZERO || !u.is_finite() { dir } else { u }; - let n = u.perp(); - let (tw, tht) = measure(&g.mtext); - let has_text = tw > 0.0; - let tick_like = ticks || (blk1.is_tick() && blk2.is_tick()); - let aw = if tick_like { 0.0 } else { asz }; - let arrows_fit = tick_like || meas > 2.0 * asz + 1e-9; - // Text orientation: inside / outside horizontal. - let along_ang = readable(u.angle()); - let extent = |ang: f64| { - // Half-extent of the text box projected on the dimension line. - let r = Vec2::from_angle(ang); - (tw * r.dot(u).abs() + tht * r.perp().dot(u).abs()) / 2.0 - }; - let inside_ang = if st.text_inside_horizontal { 0.0 } else { along_ang }; - // DIMTVP (with DIMTAD 0) lifts the text off the line once it is 0.7 text heights or more. - let tvp = if st.text_above == 0 && st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 }; - let centred = st.text_above == 0 && tvp.abs() < 0.7; - let text_need = if centred { 2.0 * (extent(inside_ang) + gap) } else { 2.0 * extent(inside_ang) }; - let fits = !has_text || meas >= text_need + 2.0 * aw; - let text_fits = !has_text || meas >= text_need; - let just = st.text_just.min(4); - // DIMATFIT / DIMTIX: what goes outside the extension lines when text and arrows - // don't both fit between them. Text the user placed, or over an extension line, is - // not part of the fit. - let (text_in, arrows_inside) = if d.user_text_pos || !has_text || just >= 3 { - (true, arrows_fit) - } else if fits { - (true, true) - } else if st.text_inside { - (true, false) - } else { - match st.fit { - 0 => (false, false), - 1 => (text_fits, false), - 2 => (false, arrows_fit), - _ if arrows_fit => (false, true), - _ => (text_fits, false), - } - }; - let text_outside = !text_in; - text_angle = if text_outside { if st.text_outside_horizontal { 0.0 } else { along_ang } } else { inside_ang }; - let half = extent(text_angle); - // DIMTMOVE 1 / 2: text that doesn't fit is moved off the dimension line, which stays put. - let moved = text_outside && st.text_move != 0; - // DIMSOXD: arrowheads that don't fit inside are left out. - let outside_arrows = !arrows_inside && !st.suppress_outside_arrows; - // Text centre along the dimension line. - let along_c = if text_outside { - f2 + u * (2.0 * asz.max(tsz) + gap + half) - } else { - match just { - 1 => f1 + u * (aw + gap + half + asz), - 2 => f2 - u * (aw + gap + half + asz), - _ => f1.mid(f2), - } - }; - // Perpendicular offset per DIMTAD. - let side_out = if (on - p1).dot(n) >= 0.0 { n } else { -n }; - let tr = Vec2::from_angle(text_angle); - let off_along = |m: Vec2| { - let glyph_extent = tw * tr.dot(m).abs() / 2.0 + tht * tr.perp().dot(m).abs() * if st.text_above == 1 { 0.6 } else { 0.5 }; - // Empirical #2004 match: 0.595× height with SHX and 0.601× with TrueType. - gap + glyph_extent - }; - let above = if text_angle.abs() < 1e-12 && n.y.abs() > 1e-9 { - if n.y > 0.0 { n } else { -n } - } else if text_angle.abs() < 1e-12 { - if n.x < 0.0 { n } else { -n } - } else if tr.perp().dot(n) >= 0.0 { - n - } else { - -n - }; - let offset = match st.text_above { - 0 => above * (tvp * th), - 2 => side_out * off_along(side_out), - 4 => -above * off_along(-above), - _ => above * off_along(above), - }; - if just >= 3 && !d.user_text_pos && has_text { - // Over an extension line, aligned with it. - let (p, f) = if just == 3 { (p1, f1) } else { (p2, f2) }; - let e = (f - p).normalized(); - let e = if e == Vec2::ZERO { side_out } else { e }; - text_angle = readable(e.angle()); - let outward = if just == 3 { -u } else { u }; - text_mid = f + e * (st.ext_extend * k + gap + tw / 2.0) + outward * (gap + tht / 2.0); - } else if moved { - // Over the middle of the line, clear of the arrowheads, on the side away from the - // measured points; with DIMTMOVE 1 it starts there and a leader joins it. - let mid = f1.mid(f2); - let lift = off_along(side_out) + 2.0 * asz.max(tsz); - text_mid = if st.text_move == 1 { mid + side_out * lift + u * half } else { mid + side_out * (lift + off_along(side_out)) }; - } else if !d.user_text_pos { - text_mid = along_c + offset; - } - // Dimension line. DIMSD1 / DIMSD2 leave out its first / second half (with the arrow). - let dle = if tick_like { st.dim_line_extend * k } else { 0.0 }; - let lo = if st.suppress_dim1 { meas / 2.0 } else { f64::NEG_INFINITY }; - let hi = if st.suppress_dim2 { meas / 2.0 } else { f64::INFINITY }; - let seg = |g: &mut DimGeometry, a: Vec2, b: Vec2| { - let (ta, tb) = ((a - f1).dot(u), (b - f1).dot(u)); - let (t0, t1) = (ta.min(tb).max(lo), ta.max(tb).min(hi)); - if t1 > t0 + 1e-12 { - g.dim(vec![f1 + u * t0, f1 + u * t1]); - } - }; - // The line between `a` and `b`, broken around centred text between the extension lines. - let inner = |g: &mut DimGeometry, a: Vec2, b: Vec2| { - if centred && has_text && !text_outside && just <= 2 && !d.user_text_pos { - let h = extent(text_angle) + gap; - let (t0, t1) = ((along_c - u * h - f1).dot(u), (along_c + u * h - f1).dot(u)); - if t0 > (a - f1).dot(u) + 1e-9 { - seg(g, a, f1 + u * t0); - } - if t1 < (b - f1).dot(u) - 1e-9 { - seg(g, f1 + u * t1, b); - } - } else { - seg(g, a, b); - } - }; - // Out to text outside the extension lines, from `from` along the line. - let to_text = |g: &mut DimGeometry, from: Vec2| { - let to = text_mid - offset - u * (half + gap); - if text_outside && (to - from).dot(u) > 0.0 { - seg(g, from, from + u * (to - from).dot(u)); - } - }; - if arrows_inside { - let i1 = if st.suppress_dim1 { 0.0 } else { end(&mut g, blk1, f1, -u) }; - let i2 = if st.suppress_dim2 { 0.0 } else { end(&mut g, blk2, f2, u) }; - inner(&mut g, f1 - u * dle + u * i1, f2 + u * dle - u * i2); - to_text(&mut g, f2); - } else { - let stub = asz * 2.0; - if outside_arrows { - if !st.suppress_dim1 { - end(&mut g, blk1, f1, u); - } - if !st.suppress_dim2 { - end(&mut g, blk2, f2, -u); - } - seg(&mut g, f1 - u * stub, f1); - seg(&mut g, f2, f2 + u * stub); - } - // DIMTOFL: the line between the extension lines as well. - if st.force_line_inside { - inner(&mut g, f1, f2); - } - to_text(&mut g, if outside_arrows { f2 + u * stub } else { f2 }); - } - // DIMTMOVE 1: a leader from the dimension line to text moved off it. - if (d.user_text_pos || moved) && st.text_move == 1 && has_text { - let base = f1.mid(f2); - let off = (text_mid - base).dot(n).abs(); - if off > tht / 2.0 + gap + 1e-9 { - let side = if (base - text_mid).dot(tr) >= 0.0 { tr } else { -tr }; - g.dim(vec![base, text_mid + side * (tw / 2.0 + gap)]); - } - } - // DIMJOGLINE: a zigzag in the dimension line, 1.5 text heights tall. - if let Some(j) = d.marks.jog_line { - let at = f1 + u * (j.xy() - f1).dot(u); - let h = 1.5 * th; - if at.is_finite() && h > 0.0 { - let r = h / 2.0; - g.cut(at, r, Some(LineRole::Dim)); - g.dim(vec![at - u * r, at - u * (r / 4.0) + n * (h / 2.0), at + u * (r / 4.0) - n * (h / 2.0), at + u * r]); - } - } - } - DimKind::Radius if d.marks.jogged.is_some() => 'jogged: { - // DIMJOGGED: from the arrowhead on the arc toward the centre, a jog at DIMJOGANG, - // then on to the overriding centre (parallel to the first part). - let center = d.defpt.xy(); - let tip = d.p15.xy(); - let r = center.dist(tip); - let j = d.marks.jogged.clone().unwrap_or_default(); - let (o, jp) = (j.center.xy(), j.jog.xy()); - g.mtext = linear_text(r, d, st, "R"); - // A NaN or infinite radius leaves no line to draw (and NaN is no bound for `clamp`). - if !r.is_finite() { - break 'jogged; - } - let (tw, _) = measure(&g.mtext); - let u = (tip - center).normalized(); - let u = if u == Vec2::ZERO || !u.is_finite() { Vec2::X } else { u }; - let n = u.perp(); - let h = (o - center).dot(n); - let ang = if st.jog_angle.is_finite() { st.jog_angle.clamp(5.0, 90.0) } else { 45.0 }.to_radians(); - let run = h.abs() / ang.tan().max(1e-6); - let tj = (jp - center).dot(u).clamp(0.0, r); - let (j1, j2) = (center + u * (tj + run / 2.0), center + u * (tj - run / 2.0) + n * h); - g.dim(vec![tip, j1, j2, o]); - end(&mut g, blk2, tip, u); - let tpos = if d.user_text_pos { text_mid } else { tip + u * (asz.max(tsz) * 3.0) }; - if tpos.dist(center) > r { - g.dim(vec![tip, tpos]); - } - text_angle = if st.text_outside_horizontal { 0.0 } else { readable(u.angle()) }; - if !d.user_text_pos { - let x = Vec2::from_angle(text_angle); - let x = if x.dot(u) >= 0.0 { x } else { -x }; - text_mid = tpos + x * (tw / 2.0 + gap); - } - } - DimKind::Radius | DimKind::Diameter => { - let a = d.defpt.xy(); - let b = d.p15.xy(); - let radius = matches!(d.kind, DimKind::Radius); - let (center, r) = if radius { (a, a.dist(b)) } else { (a.mid(b), a.dist(b) / 2.0) }; - let meas = if radius { r } else { 2.0 * r }; - g.mtext = linear_text(meas, d, st, if radius { "R" } else { "%%c" }); - g.measurement = meas; - let (tw, tht) = measure(&g.mtext); - let u = (b - center).normalized(); - let u = if u == Vec2::ZERO || !u.is_finite() { Vec2::X } else { u }; - let tip = center + u * r; - let tpos = if d.user_text_pos { text_mid } else { tip + u * (asz.max(tsz) * 3.0) }; - // Text placed inside the circle (a dimension line location picked inside): the text - // sits on the dimension line, which runs from the text out to the arrowhead (for a - // diameter it spans the circle, broken around the text). DIMTIH turns it horizontal. - let inside = d.user_text_pos && text_mid.dist(center) < r; - let horizontal = if inside { st.text_inside_horizontal } else { st.text_outside_horizontal }; - if inside { - let tr = Vec2::from_angle(if horizontal { 0.0 } else { readable(u.angle()) }); - let half = if tw > 0.0 { (tw * tr.dot(u).abs() + tht * tr.perp().dot(u).abs()) / 2.0 + gap } else { 0.0 }; - let start = if radius { center } else { center - u * r }; - let (t0, t1) = ((text_mid - start).dot(u) - half, (text_mid - start).dot(u) + half); - if !radius { - if t0 > 0.0 { - g.dim(vec![start, start + u * t0]); - } - end(&mut g, blk1, start, -u); - } - if t1 < tip.dist(start) { - g.dim(vec![start + u * t1.max(0.0), tip]); - } - } else { - // Text outside: a diameter line spans the circle and a radius line runs in to the - // centre only with DIMTOFL; otherwise just the leader to the text. - if st.force_line_inside { - let start = if radius { center } else { center - u * r }; - g.dim(vec![start, tip]); - if !radius { - end(&mut g, blk1, start, -u); - } - } - // Text the user placed: the leader stops short of it by the offset the default - // placement leaves between leader end and text. - let lead = if !d.user_text_pos { - tpos - } else if horizontal { - text_mid - Vec2::new(tw / 2.0 + gap, 0.0) * if u.x >= 0.0 { 1.0 } else { -1.0 } - } else { - text_mid - u * (tw / 2.0 + gap) - }; - g.dim(vec![tip, lead]); - } - end(&mut g, blk2, tip, u); - if horizontal { - text_angle = 0.0; - let sx = if u.x >= 0.0 { 1.0 } else { -1.0 }; - if !d.user_text_pos { - text_mid = tpos + Vec2::new(tw / 2.0 + gap, 0.0) * sx; - } - } else { - text_angle = readable(u.angle()); - if !d.user_text_pos { - text_mid = tpos + u * (tw / 2.0 + gap); - } - } - // The DIMCEN mark is drawn only when no dimension line runs inside the circle (text - // outside without DIMTOFL), never with a line through the centre. - let line_outside = !st.force_line_inside && tpos.dist(center) >= r; - if line_outside && st.center_mark != 0.0 && st.center_mark.is_finite() { - let c = st.center_mark.abs() * k; - g.ext(vec![center - Vec2::X * c, center + Vec2::X * c]); - g.ext(vec![center - Vec2::Y * c, center + Vec2::Y * c]); - if st.center_mark < 0.0 && r > 2.0 * c { - // Centre lines out past the circle. - for dv in [Vec2::X, -Vec2::X, Vec2::Y, -Vec2::Y] { - g.ext(vec![center + dv * (2.0 * c), center + dv * (r + c)]); - } - } - } - } - DimKind::Angular | DimKind::Angular3P => { - // Angular3P: p15 vertex, p13/p14 on the legs, defpt on the arc. - // Angular (2 lines): lines p13-p14 and defpt-p15; p16 on the arc. - let (vertex, a1, a2, arc_pt) = if matches!(d.kind, DimKind::Angular3P) { - (d.p15.xy(), d.p13.xy(), d.p14.xy(), d.defpt.xy()) - } else { - let v = cadcraft_geom::line_line_infinite(d.p13.xy(), d.p14.xy(), d.defpt.xy(), d.p15.xy()).map(|x| x.0).unwrap_or(d.p14.xy()); - (v, d.p14.xy(), d.p15.xy(), d.p16.xy()) - }; - let r = vertex.dist(arc_pt).max(1e-9); - let s = vertex.angle_to(a1); - let e = vertex.angle_to(a2); - let arc = - if cadcraft_geom::angle_in_sweep(vertex.angle_to(arc_pt), s, e) { Arc::new(vertex, r, s, e) } else { Arc::new(vertex, r, e, s) }; - let sweep = ccw_sweep(arc.start, arc.end); - g.measurement = sweep; - // DIMAZIN 1 / 2 suppress leading / trailing zeros (DIMZIN's bits 4 / 8). - let azin = (st.angular_zero_suppression & 3) * 4; - let txt = format_angle_with_separator(sweep, st.angular_unit, st.angular_decimals, azin, &st.decimal_separator); - // DIMPOST is a linear-dimension prefix/suffix; angles have their own format only. - g.mtext = inspected(apply_override(&txt, d), d); - let mut pts = Vec::new(); - arc.tessellate(r * 1e-3, &mut pts); - g.dim(pts); - let sp = arc.start_point(); - let ep = arc.end_point(); - // The arc's ends with the outward tangents there, paired with leg 1 and leg 2: when - // the arc location is outside the leg 1 → leg 2 sweep the arc runs from leg 2 to - // leg 1, and each leg keeps its own extension line, DIMSE1/2 and DIMBLK1/2. - let (start, finish) = ((sp, -(sp - vertex).perp().normalized()), (ep, (ep - vertex).perp().normalized())); - let ((p1, dir1), (p2, dir2)) = - if cadcraft_geom::angle_in_sweep(vertex.angle_to(arc_pt), s, e) { (start, finish) } else { (finish, start) }; - if !st.suppress_ext1 { - g.ext_n(ext_line(vertex + (p1 - vertex).normalized() * vertex.dist(a1).min(r), p1, st, k), false); - } - if !st.suppress_ext2 { - g.ext_n(ext_line(vertex + (p2 - vertex).normalized() * vertex.dist(a2).min(r), p2, st, k), true); - } - end(&mut g, blk1, p1, dir1); - end(&mut g, blk2, p2, dir2); - let (tw, tht) = measure(&g.mtext); - let mid = arc.mid_point(); - let radial = (mid - vertex).normalized(); - text_angle = if st.text_inside_horizontal { 0.0 } else { readable(radial.perp().angle()) }; - if !d.user_text_pos { - let tr = Vec2::from_angle(text_angle); - let off = gap + (tw * tr.dot(radial).abs() + tht * tr.perp().dot(radial).abs()) / 2.0; - text_mid = mid + radial * off; - } - } - DimKind::Ordinate { x_type } => { - let feature = d.p13.xy(); - let leader_end = d.p14.xy(); - let origin = d.defpt.xy(); - let meas = if x_type { (feature.x - origin.x).abs() } else { (feature.y - origin.y).abs() }; - g.mtext = linear_text(meas, d, st, ""); - g.measurement = meas; - let (tw, _) = measure(&g.mtext); - g.dim(vec![feature, leader_end]); - if x_type { - text_angle = std::f64::consts::FRAC_PI_2; - } - if !d.user_text_pos { - let dirv = (leader_end - feature).normalized(); - let dirv = if dirv == Vec2::ZERO { if x_type { Vec2::Y } else { Vec2::X } } else { dirv }; - text_mid = leader_end + dirv * (tw / 2.0 + gap); - } - } - DimKind::ArcLength => { - let c = d.p15.xy(); - let r = c.dist(d.p13.xy()); - let arc = Arc::new(c, c.dist(d.defpt.xy()).max(1e-9), c.angle_to(d.p13.xy()), c.angle_to(d.p14.xy())); - let meas = r * arc.sweep(); - // DIMARCSYM: the arc symbol before the text (0), over it (1) or none (2). - g.mtext = linear_text(meas, d, st, if st.arc_symbol == 0 { "⌒" } else { "" }); - g.measurement = meas; - let mut pts = Vec::new(); - arc.tessellate(arc.radius * 1e-3, &mut pts); - g.dim(pts); - for (i, (p, q)) in [(d.p13.xy(), arc.start_point()), (d.p14.xy(), arc.end_point())].into_iter().enumerate() { - g.ext_n(ext_line(p, q, st, k), i == 1); - } - end(&mut g, blk1, arc.start_point(), -(arc.start_point() - c).perp().normalized()); - end(&mut g, blk2, arc.end_point(), (arc.end_point() - c).perp().normalized()); - let m = arc.mid_point(); - let radial = (m - c).normalized(); - text_angle = if st.text_inside_horizontal { 0.0 } else { readable(radial.perp().angle()) }; - if !d.user_text_pos { - text_mid = m + radial * (gap + th / 2.0); - } - if st.arc_symbol == 1 { - // A small arc over the text. - let (tw, tht) = measure(&g.mtext); - let (x, y) = (Vec2::from_angle(text_angle), Vec2::from_angle(text_angle).perp()); - let half = (tw / 2.0).max(th / 2.0); - let base = text_mid + y * (tht / 2.0 + gap / 2.0); - let sym: Vec = (0..=12) - .map(|i| { - let t = f64::from(i) / 6.0 - 1.0; - base + x * (t * half) + y * ((1.0 - t * t).max(0.0).sqrt() * th * 0.35) - }) - .collect(); - g.text_mark(sym); - } - } + DimKind::Linear { .. } | DimKind::Aligned => linear::draw_linear(&config, &mut g, &mut text_angle, &mut text_mid), + DimKind::Radius if d.marks.jogged.is_some() => variants::draw_jogged_radius(&config, &mut g, &mut text_angle, &mut text_mid), + DimKind::Radius | DimKind::Diameter => variants::draw_radius_or_diameter(&config, &mut g, &mut text_angle, &mut text_mid), + DimKind::Angular | DimKind::Angular3P => variants::draw_angular(&config, &mut g, &mut text_angle, &mut text_mid), + DimKind::Ordinate { x_type } => variants::draw_ordinate(&config, &mut g, &mut text_angle, &mut text_mid, x_type), + DimKind::ArcLength => variants::draw_arc_length(&config, &mut g, &mut text_angle, &mut text_mid), } // DIMTEDIT Angle: an explicit text rotation wins. if d.text_rotation != 0.0 && d.text_rotation.is_finite() { @@ -754,6 +376,8 @@ pub fn dimension_geometry_with(d: &Dimension, st: &DimStyle, dimscale: f64, font g } +mod linear; +mod variants; /// `%%` codes in the plain value become their characters (`%%c` → ⌀, `%%p` → ±, `%%d` → °). fn decode_value(s: &str) -> String { cadcraft_fonts::decode_controls(s).into_iter().map(|(c, _, _)| c).collect() diff --git a/crates/render/src/dim/arrowheads.rs b/crates/render/src/dim/arrowheads.rs index 5940a27e9..c9c607a48 100644 --- a/crates/render/src/dim/arrowheads.rs +++ b/crates/render/src/dim/arrowheads.rs @@ -1,4 +1,4 @@ -use super::*; +use super::Vec2; /// The arrowheads drawn in code (DIMBLK names; our own geometry). #[derive(Clone, Copy, Debug, PartialEq, Eq)] diff --git a/crates/render/src/dim/linear.rs b/crates/render/src/dim/linear.rs new file mode 100644 index 000000000..40b684832 --- /dev/null +++ b/crates/render/src/dim/linear.rs @@ -0,0 +1,268 @@ +use super::text::linear_text; +use super::{DimConfig, DimGeometry, DimKind, LineRole, Vec2, ext_line, readable}; + +struct LinearDimState { + p1: Vec2, + p2: Vec2, + f1: Vec2, + f2: Vec2, + u: Vec2, + n: Vec2, + measurement: f64, + text_width: f64, + text_height: f64, + has_text: bool, + tick_like: bool, + arrow_width: f64, + arrows_inside: bool, + text_outside: bool, + just: u8, + centred: bool, + moved: bool, + outside_arrows: bool, + angle: f64, + half_extent: f64, + along_center: Vec2, + side_out: Vec2, + text_axis: Vec2, + offset: Vec2, + text_mid: Vec2, +} + +pub(super) fn draw_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2) { + let mut state = prepare_linear(config, g, *text_mid_out); + position_linear_text(config, &mut state); + draw_linear_lines(config, g, &state); + *text_angle_out = state.angle; + *text_mid_out = state.text_mid; +} + +fn prepare_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_mid: Vec2) -> LinearDimState { + let d = config.dimension; + let st = config.style; + let p1 = d.p13.xy(); + let p2 = d.p14.xy(); + let on = d.defpt.xy(); + let direction = match d.kind { + DimKind::Linear { rotation } => Vec2::from_angle(rotation), + _ => (p2 - p1).normalized(), + }; + let direction = if direction == Vec2::ZERO || !direction.is_finite() { Vec2::X } else { direction }; + let oblique = d.marks.oblique.map(Vec2::from_angle).filter(|axis| axis.is_finite() && axis.cross(direction).abs() > 1e-6); + let foot = |point: Vec2| match oblique { + Some(axis) => point + axis * ((on - point).cross(direction) / axis.cross(direction)), + None => on + direction * (point - on).dot(direction), + }; + let (f1, f2) = (foot(p1), foot(p2)); + let raw_measurement = (p2 - p1).dot(direction).abs(); + g.mtext = linear_text(raw_measurement, d, st, ""); + g.measurement = raw_measurement; + let measurement = f1.dist(f2); + if !st.suppress_ext1 { + g.ext_n(ext_line(p1, f1, st, config.scale), false); + } + if !st.suppress_ext2 { + g.ext_n(ext_line(p2, f2, st, config.scale), true); + } + let dimension_axis = (f2 - f1).normalized(); + let u = if dimension_axis == Vec2::ZERO || !dimension_axis.is_finite() { direction } else { dimension_axis }; + let n = u.perp(); + let (text_width, text_height) = config.measure(&g.mtext); + let has_text = text_width > 0.0; + let tick_like = config.ticks || (config.first_arrow.is_tick() && config.second_arrow.is_tick()); + let arrow_width = if tick_like { 0.0 } else { config.arrow_size }; + let arrows_fit = tick_like || measurement > 2.0 * config.arrow_size + 1e-9; + let along_angle = readable(u.angle()); + let extent = |angle: f64| { + let axis = Vec2::from_angle(angle); + (text_width * axis.dot(u).abs() + text_height * axis.perp().dot(u).abs()) / 2.0 + }; + let inside_angle = if st.text_inside_horizontal { 0.0 } else { along_angle }; + let tvp = if st.text_above == 0 && st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 }; + let centred = st.text_above == 0 && tvp.abs() < 0.7; + let text_need = if centred { 2.0 * (extent(inside_angle) + config.gap) } else { 2.0 * extent(inside_angle) }; + let fits = !has_text || measurement >= text_need + 2.0 * arrow_width; + let text_fits = !has_text || measurement >= text_need; + let just = st.text_just.min(4); + let (text_inside, arrows_inside) = if d.user_text_pos || !has_text || just >= 3 { + (true, arrows_fit) + } else if fits { + (true, true) + } else if st.text_inside { + (true, false) + } else { + match st.fit { + 0 => (false, false), + 1 => (text_fits, false), + 2 => (false, arrows_fit), + _ if arrows_fit => (false, true), + _ => (text_fits, false), + } + }; + let text_outside = !text_inside; + LinearDimState { + p1, + p2, + f1, + f2, + u, + n, + measurement, + text_width, + text_height, + has_text, + tick_like, + arrow_width, + arrows_inside, + text_outside, + just, + centred, + moved: text_outside && st.text_move != 0, + outside_arrows: !arrows_inside && !st.suppress_outside_arrows, + angle: 0.0, + half_extent: 0.0, + along_center: f1.mid(f2), + side_out: n, + text_axis: Vec2::X, + offset: Vec2::ZERO, + text_mid, + } +} + +fn position_linear_text(config: &DimConfig<'_>, state: &mut LinearDimState) { + let st = config.style; + let along_angle = readable(state.u.angle()); + let extent = |angle: f64| { + let axis = Vec2::from_angle(angle); + (state.text_width * axis.dot(state.u).abs() + state.text_height * axis.perp().dot(state.u).abs()) / 2.0 + }; + let inside_angle = if st.text_inside_horizontal { 0.0 } else { along_angle }; + state.angle = if state.text_outside { if st.text_outside_horizontal { 0.0 } else { along_angle } } else { inside_angle }; + state.half_extent = extent(state.angle); + state.along_center = if state.text_outside { + state.f2 + state.u * (2.0 * config.arrow_size.max(config.tick_size) + config.gap + state.half_extent) + } else { + match state.just { + 1 => state.f1 + state.u * (state.arrow_width + config.gap + state.half_extent + config.arrow_size), + 2 => state.f2 - state.u * (state.arrow_width + config.gap + state.half_extent + config.arrow_size), + _ => state.f1.mid(state.f2), + } + }; + state.side_out = if (config.dimension.defpt.xy() - state.p1).dot(state.n) >= 0.0 { state.n } else { -state.n }; + state.text_axis = Vec2::from_angle(state.angle); + let off_along = |axis: Vec2| { + let glyph_extent = state.text_width * state.text_axis.dot(axis).abs() / 2.0 + + state.text_height * state.text_axis.perp().dot(axis).abs() * if st.text_above == 1 { 0.6 } else { 0.5 }; + config.gap + glyph_extent + }; + let above = if state.angle.abs() < 1e-12 && state.n.y.abs() > 1e-9 { + if state.n.y > 0.0 { state.n } else { -state.n } + } else if state.angle.abs() < 1e-12 { + if state.n.x < 0.0 { state.n } else { -state.n } + } else if state.text_axis.perp().dot(state.n) >= 0.0 { + state.n + } else { + -state.n + }; + state.offset = match st.text_above { + 0 => above * (if st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 } * config.text_height), + 2 => state.side_out * off_along(state.side_out), + 4 => -above * off_along(-above), + _ => above * off_along(above), + }; + if state.just >= 3 && !config.dimension.user_text_pos && state.has_text { + let (point, foot) = if state.just == 3 { (state.p1, state.f1) } else { (state.p2, state.f2) }; + let extension_axis = (foot - point).normalized(); + let extension_axis = if extension_axis == Vec2::ZERO { state.side_out } else { extension_axis }; + state.angle = readable(extension_axis.angle()); + let outward = if state.just == 3 { -state.u } else { state.u }; + state.text_mid = foot + + extension_axis * (st.ext_extend * config.scale + config.gap + state.text_width / 2.0) + + outward * (config.gap + state.text_height / 2.0); + } else if state.moved { + let mid = state.f1.mid(state.f2); + let lift = off_along(state.side_out) + 2.0 * config.arrow_size.max(config.tick_size); + state.text_mid = if st.text_move == 1 { + mid + state.side_out * lift + state.u * state.half_extent + } else { + mid + state.side_out * (lift + off_along(state.side_out)) + }; + } else if !config.dimension.user_text_pos { + state.text_mid = state.along_center + state.offset; + } +} + +fn draw_linear_lines(config: &DimConfig<'_>, g: &mut DimGeometry, state: &LinearDimState) { + let d = config.dimension; + let st = config.style; + let (u, n) = (state.u, state.n); + let dle = if state.tick_like { st.dim_line_extend * config.scale } else { 0.0 }; + let lo = if st.suppress_dim1 { state.measurement / 2.0 } else { f64::NEG_INFINITY }; + let hi = if st.suppress_dim2 { state.measurement / 2.0 } else { f64::INFINITY }; + let seg = |geometry: &mut DimGeometry, a: Vec2, b: Vec2| { + let (ta, tb) = ((a - state.f1).dot(u), (b - state.f1).dot(u)); + let (t0, t1) = (ta.min(tb).max(lo), ta.max(tb).min(hi)); + if t1 > t0 + 1e-12 { + geometry.dim(vec![state.f1 + u * t0, state.f1 + u * t1]); + } + }; + let inner = |geometry: &mut DimGeometry, a: Vec2, b: Vec2| { + if state.centred && state.has_text && !state.text_outside && state.just <= 2 && !d.user_text_pos { + let half = state.half_extent + config.gap; + let (t0, t1) = ((state.along_center - u * half - state.f1).dot(u), (state.along_center + u * half - state.f1).dot(u)); + if t0 > (a - state.f1).dot(u) + 1e-9 { + seg(geometry, a, state.f1 + u * t0); + } + if t1 < (b - state.f1).dot(u) - 1e-9 { + seg(geometry, state.f1 + u * t1, b); + } + } else { + seg(geometry, a, b); + } + }; + let to_text = |geometry: &mut DimGeometry, from: Vec2| { + let to = state.text_mid - state.offset - u * (state.half_extent + config.gap); + if state.text_outside && (to - from).dot(u) > 0.0 { + seg(geometry, from, from + u * (to - from).dot(u)); + } + }; + if state.arrows_inside { + let first_inset = if st.suppress_dim1 { 0.0 } else { config.end(g, config.first_arrow, state.f1, -u) }; + let second_inset = if st.suppress_dim2 { 0.0 } else { config.end(g, config.second_arrow, state.f2, u) }; + inner(g, state.f1 - u * dle + u * first_inset, state.f2 + u * dle - u * second_inset); + to_text(g, state.f2); + } else { + let stub = config.arrow_size * 2.0; + if state.outside_arrows { + if !st.suppress_dim1 { + config.end(g, config.first_arrow, state.f1, u); + } + if !st.suppress_dim2 { + config.end(g, config.second_arrow, state.f2, -u); + } + seg(g, state.f1 - u * stub, state.f1); + seg(g, state.f2, state.f2 + u * stub); + } + if st.force_line_inside { + inner(g, state.f1, state.f2); + } + to_text(g, if state.outside_arrows { state.f2 + u * stub } else { state.f2 }); + } + if (d.user_text_pos || state.moved) && st.text_move == 1 && state.has_text { + let base = state.f1.mid(state.f2); + let offset = (state.text_mid - base).dot(n).abs(); + if offset > state.text_height / 2.0 + config.gap + 1e-9 { + let side = if (base - state.text_mid).dot(state.text_axis) >= 0.0 { state.text_axis } else { -state.text_axis }; + g.dim(vec![base, state.text_mid + side * (state.text_width / 2.0 + config.gap)]); + } + } + if let Some(jog) = d.marks.jog_line { + let at = state.f1 + u * (jog.xy() - state.f1).dot(u); + let height = 1.5 * config.text_height; + if at.is_finite() && height > 0.0 { + let radius = height / 2.0; + g.cut(at, radius, Some(LineRole::Dim)); + g.dim(vec![at - u * radius, at - u * (radius / 4.0) + n * (height / 2.0), at + u * (radius / 4.0) - n * (height / 2.0), at + u * radius]); + } + } +} diff --git a/crates/render/src/dim/tests.rs b/crates/render/src/dim/tests.rs index 4f9143874..fd439097c 100644 --- a/crates/render/src/dim/tests.rs +++ b/crates/render/src/dim/tests.rs @@ -153,6 +153,19 @@ fn text_above_and_centred() { assert!(outside2.text_pos.y < 5.0); } +#[test] +fn dimtvp_uses_the_dimension_text_height() { + let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0); + let style = st_with(|s| { + s.text_above = 0; + s.text_vertical_pos = 2.0; + s.text_height = 0.18; + }); + let font = DimText { fixed_height: 0.8, width_factor: 1.0, ..Default::default() }; + let g = dimension_geometry_with(&d, &style, 1.0, &font); + assert!((g.text_pos.y - 6.6).abs() < 1e-6, "text y={} height={}", g.text_pos.y, g.text_height); +} + #[test] fn dimtad_one_uses_autocad_text_clearance() { let d = lin((0.0, 0.10), (0.0, 0.70), (0.30, 0.40), std::f64::consts::FRAC_PI_2); diff --git a/crates/render/src/dim/text.rs b/crates/render/src/dim/text.rs index fb3d6eda7..91e6b568c 100644 --- a/crates/render/src/dim/text.rs +++ b/crates/render/src/dim/text.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{DimStyle, Dimension, NumFormat, TextFont, format_decimal, format_linear}; /// Format a linear measurement per the style (plain text). pub fn format_linear_value(v: f64, st: &DimStyle) -> String { diff --git a/crates/render/src/dim/variants.rs b/crates/render/src/dim/variants.rs new file mode 100644 index 000000000..240b5e88d --- /dev/null +++ b/crates/render/src/dim/variants.rs @@ -0,0 +1,291 @@ +use super::text::{apply_override, inspected, linear_text}; +use super::{Arrowhead, DimConfig, DimGeometry, DimKind, Vec2, ext_line, readable}; +use crate::units::format_angle_with_separator; +use cadcraft_geom::{Arc, ccw_sweep}; + +pub(super) fn draw_jogged_radius(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2) { + let d = config.dimension; + let st = config.style; + let asz = config.arrow_size; + let gap = config.gap; + let tsz = config.tick_size; + let blk2 = config.second_arrow; + let measure = |text: &str| config.measure(text); + let end = |geometry: &mut DimGeometry, kind: Arrowhead, tip: Vec2, direction: Vec2| config.end(geometry, kind, tip, direction); + let mut text_angle = 0.0; + let mut text_mid = *text_mid_out; + 'jogged: { + // DIMJOGGED: from the arrowhead on the arc toward the centre, a jog at DIMJOGANG, + // then on to the overriding centre (parallel to the first part). + let center = d.defpt.xy(); + let tip = d.p15.xy(); + let r = center.dist(tip); + let j = d.marks.jogged.clone().unwrap_or_default(); + let (o, jp) = (j.center.xy(), j.jog.xy()); + g.mtext = linear_text(r, d, st, "R"); + // A NaN or infinite radius leaves no line to draw (and NaN is no bound for `clamp`). + if !r.is_finite() { + break 'jogged; + } + let (tw, _) = measure(&g.mtext); + let u = (tip - center).normalized(); + let u = if u == Vec2::ZERO || !u.is_finite() { Vec2::X } else { u }; + let n = u.perp(); + let h = (o - center).dot(n); + let ang = if st.jog_angle.is_finite() { st.jog_angle.clamp(5.0, 90.0) } else { 45.0 }.to_radians(); + let run = h.abs() / ang.tan().max(1e-6); + let tj = (jp - center).dot(u).clamp(0.0, r); + let (j1, j2) = (center + u * (tj + run / 2.0), center + u * (tj - run / 2.0) + n * h); + g.dim(vec![tip, j1, j2, o]); + end(g, blk2, tip, u); + let tpos = if d.user_text_pos { text_mid } else { tip + u * (asz.max(tsz) * 3.0) }; + if tpos.dist(center) > r { + g.dim(vec![tip, tpos]); + } + text_angle = if st.text_outside_horizontal { 0.0 } else { readable(u.angle()) }; + if !d.user_text_pos { + let x = Vec2::from_angle(text_angle); + let x = if x.dot(u) >= 0.0 { x } else { -x }; + text_mid = tpos + x * (tw / 2.0 + gap); + } + } + *text_angle_out = text_angle; + *text_mid_out = text_mid; +} + +pub(super) fn draw_radius_or_diameter(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2) { + let d = config.dimension; + let st = config.style; + let k = config.scale; + let asz = config.arrow_size; + let gap = config.gap; + let tsz = config.tick_size; + let blk1 = config.first_arrow; + let blk2 = config.second_arrow; + let measure = |text: &str| config.measure(text); + let end = |geometry: &mut DimGeometry, kind: Arrowhead, tip: Vec2, direction: Vec2| config.end(geometry, kind, tip, direction); + let text_angle: f64; + let mut text_mid = *text_mid_out; + + let a = d.defpt.xy(); + let b = d.p15.xy(); + let radius = matches!(d.kind, DimKind::Radius); + let (center, r) = if radius { (a, a.dist(b)) } else { (a.mid(b), a.dist(b) / 2.0) }; + let meas = if radius { r } else { 2.0 * r }; + g.mtext = linear_text(meas, d, st, if radius { "R" } else { "%%c" }); + g.measurement = meas; + let (tw, tht) = measure(&g.mtext); + let u = (b - center).normalized(); + let u = if u == Vec2::ZERO || !u.is_finite() { Vec2::X } else { u }; + let tip = center + u * r; + let tpos = if d.user_text_pos { text_mid } else { tip + u * (asz.max(tsz) * 3.0) }; + // Text placed inside the circle (a dimension line location picked inside): the text + // sits on the dimension line, which runs from the text out to the arrowhead (for a + // diameter it spans the circle, broken around the text). DIMTIH turns it horizontal. + let inside = d.user_text_pos && text_mid.dist(center) < r; + let horizontal = if inside { st.text_inside_horizontal } else { st.text_outside_horizontal }; + if inside { + let tr = Vec2::from_angle(if horizontal { 0.0 } else { readable(u.angle()) }); + let half = if tw > 0.0 { (tw * tr.dot(u).abs() + tht * tr.perp().dot(u).abs()) / 2.0 + gap } else { 0.0 }; + let start = if radius { center } else { center - u * r }; + let (t0, t1) = ((text_mid - start).dot(u) - half, (text_mid - start).dot(u) + half); + if !radius { + if t0 > 0.0 { + g.dim(vec![start, start + u * t0]); + } + end(g, blk1, start, -u); + } + if t1 < tip.dist(start) { + g.dim(vec![start + u * t1.max(0.0), tip]); + } + } else { + // Text outside: a diameter line spans the circle and a radius line runs in to the + // centre only with DIMTOFL; otherwise just the leader to the text. + if st.force_line_inside { + let start = if radius { center } else { center - u * r }; + g.dim(vec![start, tip]); + if !radius { + end(g, blk1, start, -u); + } + } + // Text the user placed: the leader stops short of it by the offset the default + // placement leaves between leader end and text. + let lead = if !d.user_text_pos { + tpos + } else if horizontal { + text_mid - Vec2::new(tw / 2.0 + gap, 0.0) * if u.x >= 0.0 { 1.0 } else { -1.0 } + } else { + text_mid - u * (tw / 2.0 + gap) + }; + g.dim(vec![tip, lead]); + } + end(g, blk2, tip, u); + if horizontal { + text_angle = 0.0; + let sx = if u.x >= 0.0 { 1.0 } else { -1.0 }; + if !d.user_text_pos { + text_mid = tpos + Vec2::new(tw / 2.0 + gap, 0.0) * sx; + } + } else { + text_angle = readable(u.angle()); + if !d.user_text_pos { + text_mid = tpos + u * (tw / 2.0 + gap); + } + } + // The DIMCEN mark is drawn only when no dimension line runs inside the circle (text + // outside without DIMTOFL), never with a line through the centre. + let line_outside = !st.force_line_inside && tpos.dist(center) >= r; + if line_outside && st.center_mark != 0.0 && st.center_mark.is_finite() { + let c = st.center_mark.abs() * k; + g.ext(vec![center - Vec2::X * c, center + Vec2::X * c]); + g.ext(vec![center - Vec2::Y * c, center + Vec2::Y * c]); + if st.center_mark < 0.0 && r > 2.0 * c { + // Centre lines out past the circle. + for dv in [Vec2::X, -Vec2::X, Vec2::Y, -Vec2::Y] { + g.ext(vec![center + dv * (2.0 * c), center + dv * (r + c)]); + } + } + } + *text_angle_out = text_angle; + *text_mid_out = text_mid; +} + +pub(super) fn draw_angular(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2) { + let d = config.dimension; + let st = config.style; + let k = config.scale; + let gap = config.gap; + let blk1 = config.first_arrow; + let blk2 = config.second_arrow; + let measure = |text: &str| config.measure(text); + let end = |geometry: &mut DimGeometry, kind: Arrowhead, tip: Vec2, direction: Vec2| config.end(geometry, kind, tip, direction); + let mut text_mid = *text_mid_out; + + // Angular3P: p15 vertex, p13/p14 on the legs, defpt on the arc. + // Angular (2 lines): lines p13-p14 and defpt-p15; p16 on the arc. + let (vertex, a1, a2, arc_pt) = if matches!(d.kind, DimKind::Angular3P) { + (d.p15.xy(), d.p13.xy(), d.p14.xy(), d.defpt.xy()) + } else { + let v = cadcraft_geom::line_line_infinite(d.p13.xy(), d.p14.xy(), d.defpt.xy(), d.p15.xy()).map(|x| x.0).unwrap_or(d.p14.xy()); + (v, d.p14.xy(), d.p15.xy(), d.p16.xy()) + }; + let r = vertex.dist(arc_pt).max(1e-9); + let s = vertex.angle_to(a1); + let e = vertex.angle_to(a2); + let arc = if cadcraft_geom::angle_in_sweep(vertex.angle_to(arc_pt), s, e) { Arc::new(vertex, r, s, e) } else { Arc::new(vertex, r, e, s) }; + let sweep = ccw_sweep(arc.start, arc.end); + g.measurement = sweep; + // DIMAZIN 1 / 2 suppress leading / trailing zeros (DIMZIN's bits 4 / 8). + let azin = (st.angular_zero_suppression & 3) * 4; + let txt = format_angle_with_separator(sweep, st.angular_unit, st.angular_decimals, azin, &st.decimal_separator); + // DIMPOST is a linear-dimension prefix/suffix; angles have their own format only. + g.mtext = inspected(apply_override(&txt, d), d); + let mut pts = Vec::new(); + arc.tessellate(r * 1e-3, &mut pts); + g.dim(pts); + let sp = arc.start_point(); + let ep = arc.end_point(); + // The arc's ends with the outward tangents there, paired with leg 1 and leg 2: when + // the arc location is outside the leg 1 → leg 2 sweep the arc runs from leg 2 to + // leg 1, and each leg keeps its own extension line, DIMSE1/2 and DIMBLK1/2. + let (start, finish) = ((sp, -(sp - vertex).perp().normalized()), (ep, (ep - vertex).perp().normalized())); + let ((p1, dir1), (p2, dir2)) = if cadcraft_geom::angle_in_sweep(vertex.angle_to(arc_pt), s, e) { (start, finish) } else { (finish, start) }; + if !st.suppress_ext1 { + g.ext_n(ext_line(vertex + (p1 - vertex).normalized() * vertex.dist(a1).min(r), p1, st, k), false); + } + if !st.suppress_ext2 { + g.ext_n(ext_line(vertex + (p2 - vertex).normalized() * vertex.dist(a2).min(r), p2, st, k), true); + } + end(g, blk1, p1, dir1); + end(g, blk2, p2, dir2); + let (tw, tht) = measure(&g.mtext); + let mid = arc.mid_point(); + let radial = (mid - vertex).normalized(); + let text_angle = if st.text_inside_horizontal { 0.0 } else { readable(radial.perp().angle()) }; + if !d.user_text_pos { + let tr = Vec2::from_angle(text_angle); + let off = gap + (tw * tr.dot(radial).abs() + tht * tr.perp().dot(radial).abs()) / 2.0; + text_mid = mid + radial * off; + } + *text_angle_out = text_angle; + *text_mid_out = text_mid; +} + +pub(super) fn draw_ordinate(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2, x_type: bool) { + let d = config.dimension; + let st = config.style; + let gap = config.gap; + let measure = |text: &str| config.measure(text); + let mut text_angle = 0.0; + let mut text_mid = *text_mid_out; + + let feature = d.p13.xy(); + let leader_end = d.p14.xy(); + let origin = d.defpt.xy(); + let meas = if x_type { (feature.x - origin.x).abs() } else { (feature.y - origin.y).abs() }; + g.mtext = linear_text(meas, d, st, ""); + g.measurement = meas; + let (tw, _) = measure(&g.mtext); + g.dim(vec![feature, leader_end]); + if x_type { + text_angle = std::f64::consts::FRAC_PI_2; + } + if !d.user_text_pos { + let dirv = (leader_end - feature).normalized(); + let dirv = if dirv == Vec2::ZERO { if x_type { Vec2::Y } else { Vec2::X } } else { dirv }; + text_mid = leader_end + dirv * (tw / 2.0 + gap); + } + *text_angle_out = text_angle; + *text_mid_out = text_mid; +} + +pub(super) fn draw_arc_length(config: &DimConfig<'_>, g: &mut DimGeometry, text_angle_out: &mut f64, text_mid_out: &mut Vec2) { + let d = config.dimension; + let st = config.style; + let k = config.scale; + let th = config.text_height; + let gap = config.gap; + let blk1 = config.first_arrow; + let blk2 = config.second_arrow; + let measure = |text: &str| config.measure(text); + let end = |geometry: &mut DimGeometry, kind: Arrowhead, tip: Vec2, direction: Vec2| config.end(geometry, kind, tip, direction); + let mut text_mid = *text_mid_out; + + let c = d.p15.xy(); + let r = c.dist(d.p13.xy()); + let arc = Arc::new(c, c.dist(d.defpt.xy()).max(1e-9), c.angle_to(d.p13.xy()), c.angle_to(d.p14.xy())); + let meas = r * arc.sweep(); + // DIMARCSYM: the arc symbol before the text (0), over it (1) or none (2). + g.mtext = linear_text(meas, d, st, if st.arc_symbol == 0 { "⌒" } else { "" }); + g.measurement = meas; + let mut pts = Vec::new(); + arc.tessellate(arc.radius * 1e-3, &mut pts); + g.dim(pts); + for (i, (p, q)) in [(d.p13.xy(), arc.start_point()), (d.p14.xy(), arc.end_point())].into_iter().enumerate() { + g.ext_n(ext_line(p, q, st, k), i == 1); + } + end(g, blk1, arc.start_point(), -(arc.start_point() - c).perp().normalized()); + end(g, blk2, arc.end_point(), (arc.end_point() - c).perp().normalized()); + let m = arc.mid_point(); + let radial = (m - c).normalized(); + let text_angle = if st.text_inside_horizontal { 0.0 } else { readable(radial.perp().angle()) }; + if !d.user_text_pos { + text_mid = m + radial * (gap + th / 2.0); + } + if st.arc_symbol == 1 { + // A small arc over the text. + let (tw, tht) = measure(&g.mtext); + let (x, y) = (Vec2::from_angle(text_angle), Vec2::from_angle(text_angle).perp()); + let half = (tw / 2.0).max(th / 2.0); + let base = text_mid + y * (tht / 2.0 + gap / 2.0); + let sym: Vec = (0..=12) + .map(|i| { + let t = f64::from(i) / 6.0 - 1.0; + base + x * (t * half) + y * ((1.0 - t * t).max(0.0).sqrt() * th * 0.35) + }) + .collect(); + g.text_mark(sym); + } + *text_angle_out = text_angle; + *text_mid_out = text_mid; +} diff --git a/crates/render/src/dim_draw.rs b/crates/render/src/dim_draw.rs index b31ff13b4..b83a33128 100644 --- a/crates/render/src/dim_draw.rs +++ b/crates/render/src/dim_draw.rs @@ -2,7 +2,7 @@ use super::display::Kind; use super::draw::stroke_with; use super::props::default_lineweight; use super::text_entity::{layout_mtext_entity, place_text_entity, text_style}; -use super::*; +use super::{Builder, Color, Ctx, DimGeometry, DimText, Drawing, Entity, EntityKind, LineRole, Lineweight, Vec2, dim, ink}; /// The font settings of a dimension style's text style. pub fn dim_text(d: &Drawing, st: &cadcraft_doc::DimStyle) -> DimText { diff --git a/crates/render/src/display.rs b/crates/render/src/display.rs index b260daf8a..e6ba6b7e9 100644 --- a/crates/render/src/display.rs +++ b/crates/render/src/display.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Bounds2, Handle, Pen, Rgb, Sheet, Vec2, outline}; /// Handle carried by model-space geometry drawn inside a paper-space viewport (it belongs to no /// single paper-space entity, so selection highlighting never matches it). diff --git a/crates/render/src/draw.rs b/crates/render/src/draw.rs index 5ce0bd6c0..04e2651c5 100644 --- a/crates/render/src/draw.rs +++ b/crates/render/src/draw.rs @@ -3,7 +3,10 @@ use super::dim_draw::{MAX_FILL_SOLIDS, MAX_FILL_TEXTS, block_text_box, dim_text_ use super::display::{Kind, NO_LAYER, VIEWPORT_CONTENT}; use super::props::{resolve, transparency}; use super::text_entity::{mtext, place_text_entity}; -use super::*; +use super::{ + Builder, Ctx, DimGeometry, Drawing, Entity, EntityKind, Handle, Ink, Mat3, Polyline, Prim, Vec2, dim, fill, hatch, linetype, linetype_text, + mline, point, table, tolerance, wide, +}; /// The layer `e` is drawn on, as an index in the layer table: layer 0 inside a block is the /// block reference's layer. @@ -114,50 +117,7 @@ fn entity_parts(b: &mut Builder, ctx: &Ctx, e: &Entity) { mtext(b, ctx, t, rgb, lw); } EntityKind::Insert(ins) => insert(b, ctx, e, ins, rgb), - EntityKind::Dimension(dm) => { - if let Some(blk) = dm.block.as_ref().and_then(|n| ctx.d.block(n)) - && ctx.depth < cadcraft_doc::MAX_BLOCK_DEPTH - { - let sub = Ctx { block_pstyle: b.named, block_transparency: b.transparency, ..sub_ctx(ctx, e, Mat3::IDENTITY) }; - // DIMTFILL: the block's MTEXT carries no background mask here, so a background - // around each of the block's texts is drawn before the block's first text or first - // line of the text's marks, except for a text that a SOLID of the block covers. - let style = ctx.d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides); - let g = if style.text_fill != 0 { dimension_in(ctx.d, dm) } else { DimGeometry::default() }; - let gap = style.text_gap.abs() * style.effective_scale(ctx.d.header.f64("DIMSCALE", 1.0)); - let boxes: Vec> = if g.text_fill.is_empty() { - Vec::new() - } else { - let solids: Vec<&Entity> = - blk.entities.iter().map(|be| &**be).filter(|be| matches!(be.kind, EntityKind::Solid(_))).take(MAX_FILL_SOLIDS).collect(); - // A text's own box (no gap): a SOLID holding all its corners is its background. - let covered = - |be: &Entity| block_text_box(ctx.d, be, 0.0).is_some_and(|t| solids.iter().any(|s| t.iter().all(|p| solid_covers(s, *p)))); - blk.entities - .iter() - .filter(|be| matches!(be.kind, EntityKind::MText(_) | EntityKind::Text(_))) - .take(MAX_FILL_TEXTS) - .filter(|be| !covered(be)) - .filter_map(|be| block_text_box(ctx.d, be, gap)) - .collect() - }; - let mut fill_pending = !boxes.is_empty(); - for be in blk.entities.iter() { - if !b.expand() { - break; - } - if fill_pending && starts_text_marks(be, &g) { - for corners in &boxes { - dim_text_fill(b, ctx, e, &style, corners); - } - fill_pending = false; - } - entity(b, &sub, be); - } - } else { - dimension(b, ctx, e, dm, lw, lt.as_ref(), ltscale); - } - } + EntityKind::Dimension(dm) => draw_dimension(b, ctx, e, dm, lw, lt.as_ref(), ltscale), EntityKind::Hatch(h) => hatch::draw(b, ctx, e, h, rgb, lw, tol), EntityKind::MLine(m) => mline::draw(b, ctx, e, m, rgb, lw, tol), EntityKind::LwPolyline(p) if p.const_width > 0.0 || p.vertices.iter().any(|v| v.start_width > 0.0 || v.end_width > 0.0) => { @@ -221,29 +181,7 @@ fn entity_parts(b: &mut Builder, ctx: &Ctx, e: &Entity) { b.polyline(ctx, rgb, lw, &[q[0], q[1], q[2], q[3], q[0]]); } } - EntityKind::Wipeout(w) => { - // Hide what was drawn before it (draw order), then the frame per WIPEOUTFRAME: - // 0 = none, 1 = shown and plotted, 2 = shown but not plotted. - if b.opts.fill { - let n = b.list.prims.len(); - b.tris(ctx, rgb, &fill::triangulate_evenodd(std::slice::from_ref(&w.boundary))); - if let Some(p) = b.list.prims.get_mut(n) { - p.kind = Kind::Mask; - } - } - let frame = match ctx.d.header.i64("WIPEOUTFRAME", 1) { - 0 => false, - 2 => !b.plotting, - _ => true, - }; - if frame { - let mut pts = w.boundary.clone(); - if let Some(f) = pts.first().copied() { - pts.push(f); - } - b.polyline(ctx, rgb, lw, &pts); - } - } + EntityKind::Wipeout(w) => draw_wipeout(b, ctx, w, rgb, lw), EntityKind::Image(i) => { let o = i.insert.xy(); let u = i.u.xy() * i.size.x; @@ -272,29 +210,7 @@ fn entity_parts(b: &mut Builder, ctx: &Ctx, e: &Entity) { b.tris(ctx, rgb, &g.tris); } } - EntityKind::MLeader(m) => { - // Straight or spline leader lines; block content draws like a block reference. - for pts in m.leader_paths() { - b.polyline(ctx, rgb, lw, &pts); - if let (Some(a), Some(n)) = (pts.first(), pts.get(1)) { - b.tris(ctx, rgb, &dim::arrow(*a, (*a - *n).normalized(), m.arrow_size)); - } - } - if let Some(t) = &m.text { - let land = m.landing.xy(); - let dir = if t.insert.x >= land.x { 1.0 } else { -1.0 }; - b.polyline(ctx, rgb, lw, &[land, land + Vec2::new(m.dogleg * dir, 0.0)]); - mtext(b, ctx, t, rgb, lw); - } - if let Some(ins) = &m.block { - if m.dogleg > 0.0 && !m.leaders.is_empty() { - let land = m.landing.xy(); - let dir = if ins.insert.x >= land.x { 1.0 } else { -1.0 }; - b.polyline(ctx, rgb, lw, &[land, land + Vec2::new(m.dogleg * dir, 0.0)]); - } - insert(b, ctx, e, ins, rgb); - } - } + EntityKind::MLeader(m) => draw_mleader(b, ctx, e, m, rgb, lw), EntityKind::Point(p) => { // Relative sizes follow the view: undo the block / viewport scale. let view = b.opts.view_height / ctx.xf.scale_factor().max(1e-12); @@ -338,6 +254,98 @@ fn entity_parts(b: &mut Builder, ctx: &Ctx, e: &Entity) { } } +fn draw_mleader(b: &mut Builder, ctx: &Ctx, e: &Entity, m: &cadcraft_doc::MLeader, rgb: Ink, lw: f32) { + // Straight or spline leader lines; block content draws like a block reference. + for pts in m.leader_paths() { + b.polyline(ctx, rgb, lw, &pts); + if let (Some(a), Some(n)) = (pts.first(), pts.get(1)) { + b.tris(ctx, rgb, &dim::arrow(*a, (*a - *n).normalized(), m.arrow_size)); + } + } + if let Some(t) = &m.text { + let land = m.landing.xy(); + let dir = if t.insert.x >= land.x { 1.0 } else { -1.0 }; + b.polyline(ctx, rgb, lw, &[land, land + Vec2::new(m.dogleg * dir, 0.0)]); + mtext(b, ctx, t, rgb, lw); + } + if let Some(ins) = &m.block { + if m.dogleg > 0.0 && !m.leaders.is_empty() { + let land = m.landing.xy(); + let dir = if ins.insert.x >= land.x { 1.0 } else { -1.0 }; + b.polyline(ctx, rgb, lw, &[land, land + Vec2::new(m.dogleg * dir, 0.0)]); + } + insert(b, ctx, e, ins, rgb); + } +} + +fn draw_wipeout(b: &mut Builder, ctx: &Ctx, w: &cadcraft_doc::Wipeout, rgb: Ink, lw: f32) { + // Hide what was drawn before it (draw order), then the frame per WIPEOUTFRAME: + // 0 = none, 1 = shown and plotted, 2 = shown but not plotted. + if b.opts.fill { + let n = b.list.prims.len(); + b.tris(ctx, rgb, &fill::triangulate_evenodd(std::slice::from_ref(&w.boundary))); + if let Some(p) = b.list.prims.get_mut(n) { + p.kind = Kind::Mask; + } + } + let frame = match ctx.d.header.i64("WIPEOUTFRAME", 1) { + 0 => false, + 2 => !b.plotting, + _ => true, + }; + if frame { + let mut pts = w.boundary.clone(); + if let Some(f) = pts.first().copied() { + pts.push(f); + } + b.polyline(ctx, rgb, lw, &pts); + } +} + +fn draw_dimension(b: &mut Builder, ctx: &Ctx, e: &Entity, dm: &cadcraft_doc::Dimension, lw: f32, lt: Option<&cadcraft_doc::Linetype>, ltscale: f64) { + if let Some(blk) = dm.block.as_ref().and_then(|n| ctx.d.block(n)) + && ctx.depth < cadcraft_doc::MAX_BLOCK_DEPTH + { + let sub = Ctx { block_pstyle: b.named, block_transparency: b.transparency, ..sub_ctx(ctx, e, Mat3::IDENTITY) }; + // DIMTFILL: the block's MTEXT carries no background mask here, so a background + // around each of the block's texts is drawn before the block's first text or first + // line of the text's marks, except for a text that a SOLID of the block covers. + let style = ctx.d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides); + let g = if style.text_fill != 0 { dimension_in(ctx.d, dm) } else { DimGeometry::default() }; + let gap = style.text_gap.abs() * style.effective_scale(ctx.d.header.f64("DIMSCALE", 1.0)); + let boxes: Vec> = if g.text_fill.is_empty() { + Vec::new() + } else { + let solids: Vec<&Entity> = + blk.entities.iter().map(|be| &**be).filter(|be| matches!(be.kind, EntityKind::Solid(_))).take(MAX_FILL_SOLIDS).collect(); + // A text's own box (no gap): a SOLID holding all its corners is its background. + let covered = |be: &Entity| block_text_box(ctx.d, be, 0.0).is_some_and(|t| solids.iter().any(|s| t.iter().all(|p| solid_covers(s, *p)))); + blk.entities + .iter() + .filter(|be| matches!(be.kind, EntityKind::MText(_) | EntityKind::Text(_))) + .take(MAX_FILL_TEXTS) + .filter(|be| !covered(be)) + .filter_map(|be| block_text_box(ctx.d, be, gap)) + .collect() + }; + let mut fill_pending = !boxes.is_empty(); + for be in blk.entities.iter() { + if !b.expand() { + break; + } + if fill_pending && starts_text_marks(be, &g) { + for corners in &boxes { + dim_text_fill(b, ctx, e, &style, corners); + } + fill_pending = false; + } + entity(b, &sub, be); + } + } else { + dimension(b, ctx, e, dm, lw, lt, ltscale); + } +} + /// Draw a polyline with a linetype (None: continuous). pub(crate) fn stroke_with(b: &mut Builder, ctx: &Ctx, rgb: Ink, lw: f32, lt: Option<&cadcraft_doc::Linetype>, ltscale: f64, pts: &[Vec2]) { match lt { diff --git a/crates/render/src/pipeline.rs b/crates/render/src/pipeline.rs index 3427c61a4..8cbcb95b9 100644 --- a/crates/render/src/pipeline.rs +++ b/crates/render/src/pipeline.rs @@ -3,7 +3,7 @@ use super::display::append; use super::display::{DisplayList, Kind, NO_LAYER, PlotText, VIEWPORT_CONTENT}; use super::draw::entity; use super::viewports::{MAX_VIEWPORTS, viewport}; -use super::*; +use super::{Bounds2, Builder, Color, Ctx, Drawing, Entity, EntityKind, Handle, Lineweight, Mat3, Space, Vec2, paper, pen, plotstyle, point}; /// Build options. #[derive(Clone, Debug)] diff --git a/crates/render/src/props.rs b/crates/render/src/props.rs index 91419b0cb..ad001b40c 100644 --- a/crates/render/src/props.rs +++ b/crates/render/src/props.rs @@ -1,5 +1,5 @@ use super::display::MAX_TRANSPARENCY; -use super::*; +use super::{Color, Ctx, Drawing, Entity, Ink, Lineweight, ink}; /// An object's colour, lineweight (mm), linetype, linetype scale, visibility and the transparency /// of the layer it is drawn on (for ByLayer, see [`transparency`]). diff --git a/crates/render/src/text_entity.rs b/crates/render/src/text_entity.rs index 54b556139..f7989e2c8 100644 --- a/crates/render/src/text_entity.rs +++ b/crates/render/src/text_entity.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Bounds2, Builder, Color, Ctx, Drawing, Ink, Rgb, ink}; /// The text style of an entity (Standard defaults when missing). pub(crate) fn text_style(d: &Drawing, name: &str) -> cadcraft_doc::TextStyle { diff --git a/crates/render/src/viewports.rs b/crates/render/src/viewports.rs index e78106fa1..6f1e57517 100644 --- a/crates/render/src/viewports.rs +++ b/crates/render/src/viewports.rs @@ -5,7 +5,7 @@ use super::draw::entity; #[cfg(not(target_arch = "wasm32"))] use super::pipeline::PARALLEL_CHUNK; use super::pipeline::{Options, style_table, top_ctx, with_point_view}; -use super::*; +use super::{Bounds2, Builder, Ctx, Drawing, Entity, EntityKind, Handle, MAX_BLOCK_EXPANSION, Mat3, Space, Vec2, clip, paper, pen, plotstyle}; /// Upper bound on viewports drawn per layout (hostile files). pub(crate) const MAX_VIEWPORTS: usize = 256; diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index 787aa1a2f..fcc464be3 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -217,6 +217,507 @@ pub struct SnapCycle { index: usize, } +#[derive(Clone, Copy)] +struct PointerInput { + hover_pos: Option, + scroll: egui::Vec2, + mods: egui::Modifiers, + middle_down: bool, + pressed_primary: bool, + pressed_secondary: bool, + dbl_middle: bool, + dbl_primary: bool, +} + +struct Navigation<'a> { + rect: Rect, + tiles: &'a [(Rect, cadcraft_engine::ModelTile)], + response: &'a egui::Response, + xf: Xf, + pointer: PointerInput, +} + +fn navigate_canvas(app: &mut CadApp, ui: &mut egui::Ui, nav: &Navigation<'_>) -> Option<(bool, bool)> { + let p = nav.pointer; + let inside = p.hover_pos.is_some_and(|at| nav.rect.contains(at) && ui.ctx().layer_id_at(at) == Some(ui.layer_id()) && nav.response.hovered()); + let on_menu = p.hover_pos.is_some_and(|at| over_canvas_menu(app, at)); + app.session.ctrl_down = p.mods.ctrl; + ui.input(|i| { + for event in &i.raw.events { + if let egui::Event::MouseWheel { unit, .. } = event { + app.canvas.scroll_pans = cfg!(target_os = "macos") && *unit == egui::MouseWheelUnit::Point; + } + } + }); + handle_scroll_zoom(app, ui, nav, inside); + handle_button_navigation(app, nav, inside); + if nav.response.dragged_by(egui::PointerButton::Primary) && app.session.realtime_zoom_active() { + let _ = app.session.realtime_zoom(f64::from(nav.response.drag_delta().y)); + } + if p.pressed_primary + && let Some(at) = p.hover_pos + && !nav.rect.contains(at) + && let Some(i) = nav.tiles.iter().position(|(r, _)| r.contains(at)) + { + if let Err(e) = app.session.click_tile(i) { + app.session.echo(e.to_string()); + } + ui.ctx().request_repaint(); + return None; + } + Some((inside, on_menu)) +} + +fn handle_scroll_zoom(app: &mut CadApp, ui: &mut egui::Ui, nav: &Navigation<'_>, inside: bool) { + let p = nav.pointer; + if inside + && app.canvas.scroll_pans + && p.scroll != egui::Vec2::ZERO + && let Ok(st) = app.session.state_mut() + { + let view = st.view(); + st.set_view_quiet(cadcraft_engine::View { + center: view.center - Vec2::new(f64::from(p.scroll.x) / nav.xf.scale, -f64::from(p.scroll.y) / nav.xf.scale), + height: view.height, + }); + } + let opts = ui.ctx().options(|o| o.input_options); + let wheel = ui.input(|i| wheel_zoom_points(&i.raw.events, &opts, nav.rect.height())); + if inside + && !app.canvas.scroll_pans + && wheel != 0.0 + && let Some(at) = p.hover_pos + { + let factor = app.session.wheel_zoom_factor(f64::from(wheel)); + let about = nav.xf.to_world(at); + let _ = app.session.zoom_about(factor, about); + } + let pinch = ui.input(|i| crate::animation::zoom_delta(i, &opts, app.shows_animations())); + if inside + && (pinch - 1.0).abs() > 1e-4 + && let Some(at) = p.hover_pos + { + let _ = app.session.zoom_about(f64::from(pinch), nav.xf.to_world(at)); + } +} + +fn handle_button_navigation(app: &mut CadApp, nav: &Navigation<'_>, inside: bool) { + let p = nav.pointer; + let middle_pressed = nav.response.ctx.input(|i| i.pointer.button_pressed(egui::PointerButton::Middle)); + let focused = nav.response.ctx.input(|i| i.focused); + if p.middle_down + && focused + && (app.canvas.pan_last.is_some() || (middle_pressed && inside)) + && let Some(at) = p.hover_pos + { + if let Some(last) = app.canvas.pan_last { + let delta = at - last; + if let Ok(st) = app.session.state_mut() { + let view = st.view(); + st.set_view_quiet(cadcraft_engine::View { + center: view.center - Vec2::new(f64::from(delta.x) / nav.xf.scale, -f64::from(delta.y) / nav.xf.scale), + height: view.height, + }); + } + } + app.canvas.pan_last = Some(at); + } else { + app.canvas.pan_last = None; + } + if p.dbl_middle && inside { + let _ = app.session.zoom_extents(); + } +} + +struct CanvasPaint<'a> { + app: &'a mut CadApp, + ui: &'a mut egui::Ui, + painter: &'a egui::Painter, + tokens: Tokens, + full: Rect, + tiles: &'a [(Rect, cadcraft_engine::ModelTile)], + rect: Rect, + xf: Xf, + xf_paper: Xf, + view: cadcraft_engine::View, + active_vp: Option, + active_clip: Option, + inside: bool, + on_menu: bool, + hover_pos: Option, + raw_world: Option, +} + +fn paint_content_highlights(frame: &mut CanvasPaint<'_>, bg: Rgb, sel: &[Handle], preview_look: Look, selection_look: Option) { + let app = &mut *frame.app; + let painter = frame.painter; + let xf_paper = frame.xf_paper; + let rect = frame.rect; + let xf = frame.xf; + let t = frame.tokens; + let ui = &mut *frame.ui; + let active_vp = &frame.active_vp; + let active_clip = &frame.active_clip; + let scale = frame.xf.scale; + // The active viewport's contents, drawn apart from the layout's list, under its own objects. + // `masked`: its outline is in the stencil buffer this frame. + let mut masked = false; + if let Some(f) = ensure_vp_content(app, &xf_paper, ui.ctx()) { + let gpu = app.canvas.gpu.is_some(); + let clipped = painter.with_clip_rect(f.on_screen.intersect(rect)); + draw_vp_content(&mut app.canvas.vp, gpu, &clipped, &f, &xf_paper, bg, app.session.settings.lwdisplay); + masked = gpu && f.outline.is_some(); + } + if app.canvas.gpu.is_some() { + draw_list_gpu(&mut app.canvas, painter, &xf_paper, bg, app.session.settings.lwdisplay); + } else if let Some(list) = &app.canvas.list { + draw_list(painter, &xf_paper, list, bg, app.session.settings.lwdisplay); + } + if let Some(vp) = &active_vp { + // The active viewport: a heavy border, highlights in model units clipped to it. + let r = Rect::from_two_pos( + xf_paper.to_screen(Vec2::new(vp.center.x - vp.width / 2.0, vp.center.y + vp.height / 2.0)), + xf_paper.to_screen(Vec2::new(vp.center.x + vp.width / 2.0, vp.center.y - vp.height / 2.0)), + ); + let heavy = Stroke::new(3.0, Color32::from_rgb(0x2a, 0x2a, 0x2a)); + match &active_clip { + Some(c) => { + let mut pts: Vec = c.polygon().iter().map(|q| xf_paper.to_screen(*q)).collect(); + pts.extend(pts.first().copied()); + painter.add(egui::Shape::line(pts, heavy)); + } + None => { + painter.rect_stroke(r, 0.0, heavy, egui::StrokeKind::Middle); + } + } + if let Ok(st) = app.session.state() { + // A clipped viewport's outline bounds (its outline is masked when `masked`). + let bounds = active_clip.as_ref().map_or(r, |c| { + let b = c.bounds(); + Rect::from_two_pos(xf_paper.to_screen(Vec2::new(b.min.x, b.max.y)), xf_paper.to_screen(Vec2::new(b.max.x, b.min.y))) + }); + let clipped = painter.with_clip_rect(bounds.intersect(rect)); + let c = &mut app.canvas; + if let Some(h) = c.hover + && !sel.contains(&h) + { + c.vp_hover.update(st, &[h], scale); + let list = &c.vp_hover.list; + draw_highlight(&clipped, &xf, list, &(0..list.prims.len()).collect::>(), t.hover, preview_look); + } + if let Some(look) = selection_look + && !sel.is_empty() + { + c.vp_sel.update(st, sel, scale); + let list = &c.vp_sel.list; + let all = || (0..list.prims.len()).collect::>(); + if c.gpu.is_some() { + // Shares the GPU highlight layer with the layout's own selection; the high bit + // keeps this list's generations apart from the layout list's. + let list_id = c.vp_sel.list_gen | 1 << 63; + let stencil = if masked { crate::gpu::Stencil::Inside } else { crate::gpu::Stencil::Off }; + let hl = (&mut c.hl_key, &c.hl_slot, &mut c.hl_origin, &mut c.hl_infinite); + draw_highlight_gpu(&clipped, &xf, list, list_id, all, sel, t.selection, look, hl, stencil); + draw_highlight(&clipped, &xf, list, &c.hl_infinite, t.selection, look); + } else { + draw_highlight(&clipped, &xf, list, &all(), t.selection, look); + } + } + } + } else if let CanvasState { list: Some(list), list_gen, prim_index, hover, gpu, hl_key, hl_slot, hl_origin, hl_infinite, .. } = &mut app.canvas { + if let Some(h) = *hover + && !sel.contains(&h) + { + draw_highlight(painter, &xf, list, &prim_index.prims(*list_gen, list, &[h]), t.hover, preview_look); + } + if let Some(look) = selection_look { + if gpu.is_some() && !sel.is_empty() { + let list_id = *list_gen; + let hl = (hl_key, &*hl_slot, hl_origin, &mut *hl_infinite); + draw_highlight_gpu( + painter, + &xf, + list, + list_id, + || prim_index.prims(list_id, list, sel), + sel, + t.selection, + look, + hl, + crate::gpu::Stencil::Off, + ); + draw_highlight(painter, &xf, list, hl_infinite, t.selection, look); + } else { + draw_highlight(painter, &xf, list, &prim_index.prims(*list_gen, list, sel), t.selection, look); + } + } + } +} + +fn paint_pointer_overlay( + frame: &mut CanvasPaint<'_>, + paper_rect: Option, + surround: Color32, + selecting: bool, + sheet: Option, +) { + let app = &mut *frame.app; + let ui = &mut *frame.ui; + let painter = frame.painter; + let t = frame.tokens; + let rect = frame.rect; + let full = frame.full; + let tiles = frame.tiles; + let xf = frame.xf; + let inside = frame.inside; + let on_menu = frame.on_menu; + let hover_pos = frame.hover_pos; + let view = frame.view; + // Acquired tracking points and the polar / tracking paths under the cursor. + if app.canvas.cursor.is_some() { + draw_tracking(painter, &xf, &app.session.tracking.acquired, app.canvas.track.as_ref(), view.height * 4.0); + } + if let (Some(hit), Some(_)) = (app.canvas.snap, app.canvas.cursor) { + draw_snap_marker(painter, xf.to_screen(hit.point), &hit); + } + draw_tiles(app, ui, tiles); + // UCS icon, ViewCube and viewport label. + if app.ui.show_ucs_icon { + draw_ucs_icon(painter, rect); + crate::viewcube::ucs_icon(app, ui, rect); + } + if app.ui.show_viewcube && sheet.is_none() { + draw_viewcube(app, ui, rect); + } + viewport_label(painter, rect); + // Typing and Escape reach the command line even when its overlay is hidden. + crate::cmdline::keyboard(app, ui.ctx()); + // Command line overlay. + if app.ui.show_command_line { + crate::cmdline::show(app, ui, full); + } + // Crosshair cursor. + if inside && !on_menu { + // Hide the OS cursor under the drawn crosshair, unless assistive tech needs it (#39). + ui.ctx().set_cursor_icon(if app.ui.system_cursor { egui::CursorIcon::Crosshair } else { egui::CursorIcon::None }); + if let Some(hp) = hover_pos { + // Use the painted sheet even in MSPACE, where the editing transform follows a + // model viewport. The whole cursor takes one colour from its centre. + let ink = paper_rect.map_or(t.crosshair, |paper| crate::theme::crosshair_color(if paper.contains(hp) { t.paper } else { surround })); + draw_crosshair(app, painter, rect, hp, selecting, ink); + if app.canvas.cycle_badge && app.canvas.cycle.is_none() { + cycle_badge(painter, hp); + } + } + } + if inside + && app.session.settings.dynmode + && let Some(hp) = hover_pos + { + // A stretched grip shows its dimensions instead of the pointer boxes; a prompt asking for + // a distance shows its one field and keeps the prompt and its options. + let fields = crate::grip_dyn::draw(app, painter); + if !fields || app.session.current_prompt().is_some_and(|p| p.distance) { + dynamic_input(app, painter, hp, fields); + } + } + // Over the crosshair, so the row under the pointer reads clearly. + cycle_list(app, painter); + // No continuous repaint while hovering: input events repaint by themselves. Repainting every + // frame kept a vsync swapchain's queue full (every frame waited behind queued ones) and would + // spin the CPU with the low-latency present mode (`gpu::surface_config`). +} +struct DoubleClickContext<'a> { + inside: bool, + double: bool, + hover: Option, + xf: Xf, + xf_paper: Xf, + scale: f64, + active_viewport: &'a Option, + active_clip: &'a Option, +} + +fn handle_double_click(app: &mut CadApp, ctx: DoubleClickContext<'_>) -> Option { + let DoubleClickContext { inside, double, hover, xf, xf_paper, scale, active_viewport, active_clip } = ctx; + if inside + && double + && !app.session.prompting() + && matches!(app.session.layout_space(), cadcraft_doc::Space::Paper(_)) + && let Some(hp) = hover + { + let pp = xf_paper.to_world(hp); + let in_rect = |v: &cadcraft_doc::Viewport| (pp.x - v.center.x).abs() <= v.width / 2.0 && (pp.y - v.center.y).abs() <= v.height / 2.0; + let in_active = active_viewport.as_ref().is_some_and(|v| active_clip.as_ref().map_or(in_rect(v), |c| c.contains(pp))); + if !in_active { + app.canvas.hot_grips.clear(); + app.session.pending_window = None; + app.canvas.drag_window = false; + if app.run("mspace", serde_json::json!({"at": [pp.x, pp.y]})).is_err() && active_viewport.is_some() { + let _ = app.run("pspace", serde_json::json!({})); + } + app.session.pending_window = None; + app.canvas.drag_window = false; + app.canvas.list = None; + return None; + } + } + // Double-click text to edit it, as in AutoCAD: TEXTEDIT with that object already picked. + if inside + && double + && app.session.running.is_none() + && let Some(hp) = hover + && edit_text_at(app, xf.to_world(hp)) + { + return None; + } + + let mut hatch_dialog = false; + // Double-click a hatch (no command running) to edit it in the Hatch Edit dialog. The click is + // used up: it must not also start a grip edit on the hatch's centre grip below. + if inside + && double + && app.session.running.is_none() + && let Some(hp) = hover + && let Some(h) = hatch_at(app, xf.to_world(hp), scale) + { + app.session.set_selection(vec![h]); + crate::hatchdlg::open_edit(app); + hatch_dialog = true; + } + + Some(hatch_dialog) +} + +fn update_canvas_cursor( + app: &mut CadApp, + ui: &egui::Ui, + xf: &Xf, + inside: bool, + hover: Option, +) -> (Option, Option) { + let raw_world = hover.filter(|_| inside).map(|p| xf.to_world(p)); + let dyn_frame = crate::cmdline::dyn_frame(app); + if let Some(w) = raw_world { + let mut eff = effective_point(app, w, xf, ui.ctx()); + // A locked Dynamic Input value (`40,` or `40<` typed) holds the cursor and overrides snaps. + if let Some(f) = dyn_frame + && let Some(e) = crate::dyninput::parse(&app.cmd.buffer, &f) + && e.first_locked().is_some() + { + eff = crate::dyninput::constrain(&e, &f, eff, app.cmd.second_locked()); + app.canvas.snap = None; + app.canvas.track = None; + } + // Grip dimensional input: typed lengths and angles hold the grip and override snaps. + let grip_held = crate::grip_dyn::constrain(app, eff); + if let Some(q) = grip_held { + eff = q; + app.canvas.snap = None; + app.canvas.track = None; + } + app.canvas.cursor = Some(eff); + app.session.cursor = eff; + app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred); + // Typed or menu snap overrides (END, NON…) and Tab cycling; a locked Dynamic Input value wins. + if dyn_frame.and_then(|f| crate::dyninput::parse(&app.cmd.buffer, &f)).is_none_or(|e| e.first_locked().is_none()) { + override_cursor(app, w, xf); + } + // Typed grip dimensions win over snap overrides too. + if let Some(q) = grip_held { + app.canvas.cursor = Some(q); + app.session.cursor = q; + app.canvas.snap = None; + app.session.cursor_deferred = None; + } + } else { + app.canvas.cursor = None; + app.canvas.snap = None; + app.session.cursor_deferred = None; + } + + (raw_world, dyn_frame) +} + +fn update_hover(app: &mut CadApp, ui: &egui::Ui, inside: bool, hover_pos: Option, raw_world: Option, scale: f64) { + // The cursor picks objects (pick box, rollover highlight): "Select objects" and single-object + // prompts, or no command with PICKFIRST on; SELECTIONPREVIEW says in which of those it shows. + let selecting = app.session.previews_selection(); + if inside && selecting && app.session.pending_window.is_none() { + if hover_pos != app.canvas.hover_at + && let (Some(w), Ok(st)) = (raw_world, app.session.state()) + { + let filter = app.session.settings.previewfilter; + app.canvas.hover = cadcraft_engine::select::pick(&st.doc, &st.edit_space(), w, app.session.settings.pickbox.max(1.0) * 1.5 / scale) + .filter(|h| st.doc.entity(*h).is_none_or(|e| !cadcraft_engine::select::preview_filtered(&st.doc, e, filter))); + app.canvas.hover_at = hover_pos; + } + } else { + app.canvas.hover = None; + app.canvas.hover_at = None; + } + // The open selection cycling list highlights the object of the row under the pointer. + if app.canvas.cycle.is_some() && ui.input(|i| i.key_pressed(egui::Key::Escape)) { + app.canvas.cycle = None; + } + if let Some(c) = &app.canvas.cycle { + app.canvas.hover = hover_pos.and_then(|hp| c.row_at(hp)); + app.canvas.hover_at = None; + } + shift_space_cycle(app, ui, hover_pos.filter(|_| inside), raw_world); + if inside && hover_pos != app.canvas.cycle_badge_at { + app.canvas.cycle_badge = raw_world.is_some_and(|w| app.session.cycling_badge(w)); + app.canvas.cycle_badge_at = hover_pos; + } else if !inside { + app.canvas.cycle_badge = false; + app.canvas.cycle_badge_at = None; + } +} + +struct PromptClickContext<'a> { + rect: Rect, + xf: Xf, + inside: bool, + middle_down: bool, + primary_clicked: bool, + response: &'a egui::Response, +} + +fn collect_prompt_clicks(app: &mut CadApp, ui: &egui::Ui, context: PromptClickContext<'_>) -> bool { + // egui drops a click whose button comes up a few pixels from where it went down (a drag to it), + // and eframe hands a slow frame's clicks over together, which egui reports as one. + let point_prompt = app.session.current_prompt().is_some_and(|p| cadcraft_engine::pointmod::accepts(&p)) + && app.session.pending_window.is_none() + && !app.session.realtime_zoom_active(); + let pressed_primary = context.primary_clicked || (point_prompt && context.response.drag_stopped_by(egui::PointerButton::Primary)); + if point_prompt && context.inside && pressed_primary && !context.middle_down && app.cmd.options.is_none() && app.cmd.buffer.is_empty() { + let releases: Vec = ui.input(|i| { + i.events + .iter() + .filter_map(|e| match e { + egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, .. } => Some(*pos), + _ => None, + }) + .collect() + }); + // The last one is placed below, at the cursor, like any click. + if let Some((_, earlier)) = releases.split_last() { + for pos in earlier.iter().filter(|p| context.rect.contains(**p)) { + let w = effective_point(app, context.xf.to_world(*pos), &context.xf, ui.ctx()); + let result = match app.canvas.snap { + Some(hit) => app.session.input_snapped(hit), + None => app.session.input(Input::Point(w)), + }; + if let Err(e) = result { + app.session.echo(e.to_string()); + } + } + } + } + + pressed_primary +} + /// Draw the drawing area and handle its input (zoom and pan, picking, the crosshair) for this /// frame. /// @@ -247,116 +748,19 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { app.canvas.xf = Some(xf); // ---------- input ---------- - let (hover_pos, scroll, mods, middle_down, pressed_primary, pressed_secondary, dbl_middle, dbl_primary) = ui.input(|i| { - ( - i.pointer.hover_pos(), - i.smooth_scroll_delta, - i.modifiers, - i.pointer.middle_down(), - i.pointer.primary_clicked(), - i.pointer.secondary_clicked(), - i.pointer.button_double_clicked(egui::PointerButton::Middle), - i.pointer.button_double_clicked(egui::PointerButton::Primary), - ) + let pointer = ui.input(|i| PointerInput { + hover_pos: i.pointer.hover_pos(), + scroll: i.smooth_scroll_delta, + mods: i.modifiers, + middle_down: i.pointer.middle_down(), + pressed_primary: i.pointer.primary_clicked(), + pressed_secondary: i.pointer.secondary_clicked(), + dbl_middle: i.pointer.button_double_clicked(egui::PointerButton::Middle), + dbl_primary: i.pointer.button_double_clicked(egui::PointerButton::Primary), }); - // The drawing area alone: a menu popup's frame (between its items and its border), a tooltip - // or a floating palette lives on a layer above the canvas, where `hovered()` alone still - // counts the canvas. Over those the OS cursor stays visible and the crosshair stays put, as - // over the menu bar (#1701). - let inside = hover_pos.is_some_and(|p| rect.contains(p) && ui.ctx().layer_id_at(p) == Some(ui.layer_id()) && resp.hovered()); - // The menus the canvas paints itself (selection cycling's rows, Dynamic Input's options) are - // menus too, but they share the canvas's layer: `layer_id_at` reports the drawing under them, - // so only their rectangles tell them apart from it ([`over_canvas_menu`]). They are excluded - // from the cursor contract below, though not from the canvas's input: a click on a row is - // taken by the row. - let on_menu = hover_pos.is_some_and(|p| over_canvas_menu(app, p)); - // Whether Ctrl is held right now. Written every frame (not just while a command prompts), so - // previews that read `Session::ctrl_down` always see the current state. The engine - // deliberately does not carry modifiers through `Input`, which is UI-agnostic (see PR - // #407's Limits note: modifiers used to be dropped on the floor at this point). - app.session.ctrl_down = mods.ctrl; - // Which device is scrolling? On macOS, trackpads (and Magic Mouse) report precise point - // deltas; notched mouse wheels report lines. The answer is sticky because egui spreads a wheel - // notch over several frames. Elsewhere (browsers, Wayland smooth-scroll mice) ordinary wheels - // also report points, so the wheel keeps zooming there. - ui.input(|i| { - for e in &i.raw.events { - if let egui::Event::MouseWheel { unit, .. } = e { - app.canvas.scroll_pans = cfg!(target_os = "macos") && *unit == egui::MouseWheelUnit::Point; - } - } - }); - if inside && app.canvas.scroll_pans && scroll != egui::Vec2::ZERO { - // Two-finger swipe pans: the drawing follows the fingers, like a middle-drag. - // Pinch (and Cmd+scroll) still zoom via `zoom_delta` below. - if let Ok(st) = app.session.state_mut() { - let v = st.view(); - st.set_view_quiet(cadcraft_engine::View { - center: v.center - Vec2::new(f64::from(scroll.x) / scale, -f64::from(scroll.y) / scale), - height: v.height, - }); - } - } - let opts = ui.ctx().options(|o| o.input_options); - let wheel = ui.input(|i| wheel_zoom_points(&i.raw.events, &opts, rect.height())); - if inside - && !app.canvas.scroll_pans - && wheel != 0.0 - && let Some(hp) = hover_pos - { - // Zoom with the mouse wheel about the cursor, each notch at once. - let f = app.session.wheel_zoom_factor(f64::from(wheel)); - let about = xf.to_world(hp); - let _ = app.session.zoom_about(f, about); - } - let zoom_pinch = ui.input(|i| crate::animation::zoom_delta(i, &opts, app.shows_animations())); - if inside - && (zoom_pinch - 1.0).abs() > 1e-4 - && let Some(hp) = hover_pos - { - let _ = app.session.zoom_about(f64::from(zoom_pinch), xf.to_world(hp)); - } - // Pan with the middle button (or Shift+right-drag / two-finger drag on trackpads is scroll). - let middle_pressed = ui.input(|i| i.pointer.button_pressed(egui::PointerButton::Middle)); - let focused = ui.input(|i| i.focused); - if middle_down - && focused - && (app.canvas.pan_last.is_some() || (middle_pressed && inside)) - && let Some(hp) = hover_pos - { - if let Some(last) = app.canvas.pan_last { - let d = hp - last; - if let Ok(st) = app.session.state_mut() { - let v = st.view(); - st.set_view_quiet(cadcraft_engine::View { - center: v.center - Vec2::new(f64::from(d.x) / scale, -f64::from(d.y) / scale), - height: v.height, - }); - } - } - app.canvas.pan_last = Some(hp); - } else { - app.canvas.pan_last = None; - } - if dbl_middle && inside { - let _ = app.session.zoom_extents(); - } - // ZOOM Realtime: dragging up zooms in, down zooms out. - if resp.dragged_by(egui::PointerButton::Primary) && app.session.realtime_zoom_active() { - let _ = app.session.realtime_zoom(f64::from(resp.drag_delta().y)); - } - // A click in another tile makes it current (or answers -VPORTS Join's prompts). - if pressed_primary - && let Some(hp) = hover_pos - && !rect.contains(hp) - && let Some(i) = tiles.iter().position(|(r, _)| r.contains(hp)) - { - if let Err(e) = app.session.click_tile(i) { - app.session.echo(e.to_string()); - } - ui.ctx().request_repaint(); - return; - } + let navigation = Navigation { rect, tiles: &tiles, response: &resp, xf, pointer }; + let Some((inside, on_menu)) = navigate_canvas(app, ui, &navigation) else { return }; + let PointerInput { hover_pos, mods, middle_down, pressed_primary, pressed_secondary, dbl_primary, .. } = pointer; // Re-read the view after navigation. let view = app.session.state().map(|s| s.view()).unwrap_or(view); let scale = f64::from(rect.height()) / view.height.max(1e-12); @@ -373,124 +777,26 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { }; // A clipped active viewport's outline (picks and its heavy border follow it). let active_clip = app.session.state().ok().and_then(|st| st.active_viewport().and_then(|(h, v)| cadcraft_render::viewport_clip(&st.doc, h, &v))); - // Double-click a viewport to work inside it; double-click the sheet outside it to return. - if inside - && dbl_primary - && !app.session.prompting() - && matches!(app.session.layout_space(), cadcraft_doc::Space::Paper(_)) - && let Some(hp) = hover_pos - { - let pp = xf_paper.to_world(hp); - let in_rect = |v: &cadcraft_doc::Viewport| (pp.x - v.center.x).abs() <= v.width / 2.0 && (pp.y - v.center.y).abs() <= v.height / 2.0; - let in_active = active_vp.as_ref().is_some_and(|v| active_clip.as_ref().map_or(in_rect(v), |c| c.contains(pp))); - if !in_active { - app.canvas.hot_grips.clear(); - app.session.pending_window = None; - app.canvas.drag_window = false; - if app.run("mspace", serde_json::json!({"at": [pp.x, pp.y]})).is_err() && active_vp.is_some() { - let _ = app.run("pspace", serde_json::json!({})); - } - app.session.pending_window = None; - app.canvas.drag_window = false; - app.canvas.list = None; - return; - } - } - // Double-click text to edit it, as in AutoCAD: TEXTEDIT with that object already picked. - if inside - && dbl_primary - && app.session.running.is_none() - && let Some(hp) = hover_pos - && edit_text_at(app, xf.to_world(hp)) - { + let Some(hatch_dialog) = handle_double_click( + app, + DoubleClickContext { + inside, + double: dbl_primary, + hover: hover_pos, + xf, + xf_paper, + scale, + active_viewport: &active_vp, + active_clip: &active_clip, + }, + ) else { return; - } + }; - // Double-click a hatch (no command running) to edit it in the Hatch Edit dialog. The click is - // used up: it must not also start a grip edit on the hatch's centre grip below. - let mut hatch_dialog = false; - if inside - && dbl_primary - && app.session.running.is_none() - && let Some(hp) = hover_pos - && let Some(h) = hatch_at(app, xf.to_world(hp), scale) - { - app.session.set_selection(vec![h]); - crate::hatchdlg::open_edit(app); - hatch_dialog = true; - } + let pressed_primary = + collect_prompt_clicks(app, ui, PromptClickContext { rect, xf, inside, middle_down, primary_clicked: pressed_primary, response: &resp }); - // While a command asks for a point, every click places one, however fast the drafting (#815). - // egui drops a click whose button comes up a few pixels from where it went down (a drag to it), - // and eframe hands a slow frame's clicks over together, which egui reports as one. - let point_prompt = app.session.current_prompt().is_some_and(|p| cadcraft_engine::pointmod::accepts(&p)) - && app.session.pending_window.is_none() - && !app.session.realtime_zoom_active(); - let pressed_primary = pressed_primary || (point_prompt && resp.drag_stopped_by(egui::PointerButton::Primary)); - if point_prompt && inside && pressed_primary && !middle_down && app.cmd.options.is_none() && app.cmd.buffer.is_empty() { - let releases: Vec = ui.input(|i| { - i.events - .iter() - .filter_map(|e| match e { - egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, .. } => Some(*pos), - _ => None, - }) - .collect() - }); - // The last one is placed below, at the cursor, like any click. - if let Some((_, earlier)) = releases.split_last() { - for pos in earlier.iter().filter(|p| rect.contains(**p)) { - let w = effective_point(app, xf.to_world(*pos), &xf, ui.ctx()); - let result = match app.canvas.snap { - Some(hit) => app.session.input_snapped(hit), - None => app.session.input(Input::Point(w)), - }; - if let Err(e) = result { - app.session.echo(e.to_string()); - } - } - } - } - - let raw_world = hover_pos.filter(|_| inside).map(|p| xf.to_world(p)); - let dyn_frame = crate::cmdline::dyn_frame(app); - if let Some(w) = raw_world { - let mut eff = effective_point(app, w, &xf, ui.ctx()); - // A locked Dynamic Input value (`40,` or `40<` typed) holds the cursor and overrides snaps. - if let Some(f) = dyn_frame - && let Some(e) = crate::dyninput::parse(&app.cmd.buffer, &f) - && e.first_locked().is_some() - { - eff = crate::dyninput::constrain(&e, &f, eff, app.cmd.second_locked()); - app.canvas.snap = None; - app.canvas.track = None; - } - // Grip dimensional input: typed lengths and angles hold the grip and override snaps. - let grip_held = crate::grip_dyn::constrain(app, eff); - if let Some(q) = grip_held { - eff = q; - app.canvas.snap = None; - app.canvas.track = None; - } - app.canvas.cursor = Some(eff); - app.session.cursor = eff; - app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred); - // Typed or menu snap overrides (END, NON…) and Tab cycling; a locked Dynamic Input value wins. - if dyn_frame.and_then(|f| crate::dyninput::parse(&app.cmd.buffer, &f)).is_none_or(|e| e.first_locked().is_none()) { - override_cursor(app, w, &xf); - } - // Typed grip dimensions win over snap overrides too. - if let Some(q) = grip_held { - app.canvas.cursor = Some(q); - app.session.cursor = q; - app.canvas.snap = None; - app.session.cursor_deferred = None; - } - } else { - app.canvas.cursor = None; - app.canvas.snap = None; - app.session.cursor_deferred = None; - } + let (raw_world, dyn_frame) = update_canvas_cursor(app, ui, &xf, inside, hover_pos); // A click on the Dynamic Input options menu picks the keyword; elsewhere it closes the menu. let mut picked = false; @@ -610,41 +916,49 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { crate::context_menu::show(app, &resp); } - // Hover highlight (throttled to cursor movement). - // The cursor picks objects (pick box, rollover highlight): "Select objects" and single-object - // prompts, or no command with PICKFIRST on; SELECTIONPREVIEW says in which of those it shows. - let selecting = app.session.previews_selection(); - if inside && selecting && app.session.pending_window.is_none() { - if hover_pos != app.canvas.hover_at - && let (Some(w), Ok(st)) = (raw_world, app.session.state()) - { - let filter = app.session.settings.previewfilter; - app.canvas.hover = cadcraft_engine::select::pick(&st.doc, &st.edit_space(), w, app.session.settings.pickbox.max(1.0) * 1.5 / scale) - .filter(|h| st.doc.entity(*h).is_none_or(|e| !cadcraft_engine::select::preview_filtered(&st.doc, e, filter))); - app.canvas.hover_at = hover_pos; - } - } else { - app.canvas.hover = None; - app.canvas.hover_at = None; - } - // The open selection cycling list highlights the object of the row under the pointer. - if app.canvas.cycle.is_some() && ui.input(|i| i.key_pressed(egui::Key::Escape)) { - app.canvas.cycle = None; - } - if let Some(c) = &app.canvas.cycle { - app.canvas.hover = hover_pos.and_then(|hp| c.row_at(hp)); - app.canvas.hover_at = None; - } - shift_space_cycle(app, ui, hover_pos.filter(|_| inside), raw_world); - if inside && hover_pos != app.canvas.cycle_badge_at { - app.canvas.cycle_badge = raw_world.is_some_and(|w| app.session.cycling_badge(w)); - app.canvas.cycle_badge_at = hover_pos; - } else if !inside { - app.canvas.cycle_badge = false; - app.canvas.cycle_badge_at = None; - } + update_hover(app, ui, inside, hover_pos, raw_world, scale); - // ---------- paint ---------- + paint_canvas(CanvasPaint { + app, + ui, + painter: &painter, + tokens: t, + full, + tiles: &tiles, + rect, + xf, + xf_paper, + view, + active_vp, + active_clip, + inside, + on_menu, + hover_pos, + raw_world, + }); +} + +fn paint_canvas(frame: CanvasPaint<'_>) { + let CanvasPaint { + app, + ui, + painter, + tokens: t, + full, + tiles, + rect, + xf, + xf_paper, + view, + active_vp, + active_clip, + inside, + on_menu, + hover_pos, + raw_world, + } = frame; + let scale = xf.scale; + let selecting = app.session.previews_selection(); painter.rect_filled(rect, 0.0, t.canvas); let t0 = crate::now_ms(); let mut views = vec![(xf_paper.world_bounds(), 1.0 / xf_paper.scale)]; @@ -673,8 +987,8 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { (Rgb(t.paper.r(), t.paper.g(), t.paper.b()), Some(paper)) } None => { - blockedit::wash(app, &painter, rect); - draw_grid(app, &painter, &xf); + blockedit::wash(app, painter, rect); + draw_grid(app, painter, &xf); (Rgb(t.canvas.r(), t.canvas.g(), t.canvas.b()), None) } }; @@ -682,102 +996,33 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { // How the object under the cursor and the selected ones are highlighted (PREVIEWEFFECT, // HIGHLIGHT, SELECTIONEFFECT); with HIGHLIGHT off only their grips show. let (preview_look, selection_look) = (Look::preview(&app.session.settings), Look::selection(&app.session.settings)); - // The active viewport's contents, drawn apart from the layout's list, under its own objects. - // `masked`: its outline is in the stencil buffer this frame. - let mut masked = false; - if let Some(f) = ensure_vp_content(app, &xf_paper, ui.ctx()) { - let gpu = app.canvas.gpu.is_some(); - let clipped = painter.with_clip_rect(f.on_screen.intersect(rect)); - draw_vp_content(&mut app.canvas.vp, gpu, &clipped, &f, &xf_paper, bg, app.session.settings.lwdisplay); - masked = gpu && f.outline.is_some(); - } - if app.canvas.gpu.is_some() { - draw_list_gpu(&mut app.canvas, &painter, &xf_paper, bg, app.session.settings.lwdisplay); - } else if let Some(list) = &app.canvas.list { - draw_list(&painter, &xf_paper, list, bg, app.session.settings.lwdisplay); - } - if let Some(vp) = &active_vp { - // The active viewport: a heavy border, highlights in model units clipped to it. - let r = Rect::from_two_pos( - xf_paper.to_screen(Vec2::new(vp.center.x - vp.width / 2.0, vp.center.y + vp.height / 2.0)), - xf_paper.to_screen(Vec2::new(vp.center.x + vp.width / 2.0, vp.center.y - vp.height / 2.0)), - ); - let heavy = Stroke::new(3.0, Color32::from_rgb(0x2a, 0x2a, 0x2a)); - match &active_clip { - Some(c) => { - let mut pts: Vec = c.polygon().iter().map(|q| xf_paper.to_screen(*q)).collect(); - pts.extend(pts.first().copied()); - painter.add(egui::Shape::line(pts, heavy)); - } - None => { - painter.rect_stroke(r, 0.0, heavy, egui::StrokeKind::Middle); - } - } - if let Ok(st) = app.session.state() { - // A clipped viewport's outline bounds (its outline is masked when `masked`). - let bounds = active_clip.as_ref().map_or(r, |c| { - let b = c.bounds(); - Rect::from_two_pos(xf_paper.to_screen(Vec2::new(b.min.x, b.max.y)), xf_paper.to_screen(Vec2::new(b.max.x, b.min.y))) - }); - let clipped = painter.with_clip_rect(bounds.intersect(rect)); - let c = &mut app.canvas; - if let Some(h) = c.hover - && !sel.contains(&h) - { - c.vp_hover.update(st, &[h], scale); - let list = &c.vp_hover.list; - draw_highlight(&clipped, &xf, list, &(0..list.prims.len()).collect::>(), t.hover, preview_look); - } - if let Some(look) = selection_look - && !sel.is_empty() - { - c.vp_sel.update(st, &sel, scale); - let list = &c.vp_sel.list; - let all = || (0..list.prims.len()).collect::>(); - if c.gpu.is_some() { - // Shares the GPU highlight layer with the layout's own selection; the high bit - // keeps this list's generations apart from the layout list's. - let list_id = c.vp_sel.list_gen | 1 << 63; - let stencil = if masked { crate::gpu::Stencil::Inside } else { crate::gpu::Stencil::Off }; - let hl = (&mut c.hl_key, &c.hl_slot, &mut c.hl_origin, &mut c.hl_infinite); - draw_highlight_gpu(&clipped, &xf, list, list_id, all, &sel, t.selection, look, hl, stencil); - draw_highlight(&clipped, &xf, list, &c.hl_infinite, t.selection, look); - } else { - draw_highlight(&clipped, &xf, list, &all(), t.selection, look); - } - } - } - } else if let CanvasState { list: Some(list), list_gen, prim_index, hover, gpu, hl_key, hl_slot, hl_origin, hl_infinite, .. } = &mut app.canvas { - if let Some(h) = *hover - && !sel.contains(&h) - { - draw_highlight(&painter, &xf, list, &prim_index.prims(*list_gen, list, &[h]), t.hover, preview_look); - } - if let Some(look) = selection_look { - if gpu.is_some() && !sel.is_empty() { - let list_id = *list_gen; - let hl = (hl_key, &*hl_slot, hl_origin, &mut *hl_infinite); - draw_highlight_gpu( - &painter, - &xf, - list, - list_id, - || prim_index.prims(list_id, list, &sel), - &sel, - t.selection, - look, - hl, - crate::gpu::Stencil::Off, - ); - draw_highlight(&painter, &xf, list, hl_infinite, t.selection, look); - } else { - draw_highlight(&painter, &xf, list, &prim_index.prims(*list_gen, list, &sel), t.selection, look); - } - } - } + paint_content_highlights( + &mut CanvasPaint { + app, + ui, + painter, + tokens: t, + full, + tiles, + rect, + xf, + xf_paper, + view, + active_vp: active_vp.clone(), + active_clip: active_clip.clone(), + inside, + on_menu, + hover_pos, + raw_world, + }, + bg, + &sel, + preview_look, + selection_look, + ); app.canvas.draw_ms = crate::now_ms() - t0; - compare::paint(app, ui.ctx(), &painter, &xf_paper, rect); - blockedit::paint(app, ui.ctx(), &painter, &xf_paper, rect); + compare::paint(app, ui.ctx(), painter, &xf_paper, rect); + blockedit::paint(app, ui.ctx(), painter, &xf_paper, rect); // Constraint bars and dynamic dimensional constraints (model space, or inside a viewport). if sheet.is_none() || active_vp.is_some() { let clip = match &active_vp { @@ -831,7 +1076,7 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { } } } - crate::dyngrips::draw(app, &painter, &xf, rect, hover_pos); + crate::dyngrips::draw(app, painter, &xf, rect, hover_pos); } // Rubber band preview of the active command. // `xf` is the space being edited: paper space, or model space inside the active viewport. @@ -843,9 +1088,9 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { if let Ok(st) = app.session.state() { let serial = app.session.clipboard_source.as_ref().map_or(0, |c| c.serial); let transparency = app.session.settings.transparency_display; - draw_drag_gpu(&mut app.canvas, &painter, &xf, &st.doc, &drag, (&app.session.clipboard, serial), bg, transparency); + draw_drag_gpu(&mut app.canvas, painter, &xf, &st.doc, &drag, (&app.session.clipboard, serial), bg, transparency); let list = rebuilt_preview(&st.doc, extra.iter(), scale); - draw_list(&painter, &xf, &list, bg, false); + draw_list(painter, &xf, &list, bg, false); } } else if let (Some(c), true) = (app.canvas.cursor, app.session.prompting()) { let ents = app.session.preview(c); @@ -853,7 +1098,7 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { && let Ok(st) = app.session.state() { let list = rebuilt_preview(&st.doc, ents.iter(), scale); - draw_list(&painter, &xf, &list, bg, false); + draw_list(painter, &xf, &list, bg, false); } } // Pending selection window. @@ -873,59 +1118,30 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) { painter.rect_stroke(r, 0.0, st, egui::StrokeKind::Middle); } } - // Acquired tracking points and the polar / tracking paths under the cursor. - if app.canvas.cursor.is_some() { - draw_tracking(&painter, &xf, &app.session.tracking.acquired, app.canvas.track.as_ref(), view.height * 4.0); - } - if let (Some(hit), Some(_)) = (app.canvas.snap, app.canvas.cursor) { - draw_snap_marker(&painter, xf.to_screen(hit.point), &hit); - } - draw_tiles(app, ui, &tiles); - // UCS icon, ViewCube and viewport label. - if app.ui.show_ucs_icon { - draw_ucs_icon(&painter, rect); - crate::viewcube::ucs_icon(app, ui, rect); - } - if app.ui.show_viewcube && sheet.is_none() { - draw_viewcube(app, ui, rect); - } - viewport_label(&painter, rect); - // Typing and Escape reach the command line even when its overlay is hidden. - crate::cmdline::keyboard(app, ui.ctx()); - // Command line overlay. - if app.ui.show_command_line { - crate::cmdline::show(app, ui, full); - } - // Crosshair cursor. - if inside && !on_menu { - // Hide the OS cursor under the drawn crosshair, unless assistive tech needs it (#39). - ui.ctx().set_cursor_icon(if app.ui.system_cursor { egui::CursorIcon::Crosshair } else { egui::CursorIcon::None }); - if let Some(hp) = hover_pos { - // Use the painted sheet even in MSPACE, where the editing transform follows a - // model viewport. The whole cursor takes one colour from its centre. - let ink = paper_rect.map_or(t.crosshair, |paper| crate::theme::crosshair_color(if paper.contains(hp) { t.paper } else { surround })); - draw_crosshair(app, &painter, rect, hp, selecting, ink); - if app.canvas.cycle_badge && app.canvas.cycle.is_none() { - cycle_badge(&painter, hp); - } - } - } - if inside - && app.session.settings.dynmode - && let Some(hp) = hover_pos - { - // A stretched grip shows its dimensions instead of the pointer boxes; a prompt asking for - // a distance shows its one field and keeps the prompt and its options. - let fields = crate::grip_dyn::draw(app, &painter); - if !fields || app.session.current_prompt().is_some_and(|p| p.distance) { - dynamic_input(app, &painter, hp, fields); - } - } - // Over the crosshair, so the row under the pointer reads clearly. - cycle_list(app, &painter); - // No continuous repaint while hovering: input events repaint by themselves. Repainting every - // frame kept a vsync swapchain's queue full (every frame waited behind queued ones) and would - // spin the CPU with the low-latency present mode (`gpu::surface_config`). + paint_pointer_overlay( + &mut CanvasPaint { + app, + ui, + painter, + tokens: t, + full, + tiles, + rect, + xf, + xf_paper, + view, + active_vp: active_vp.clone(), + active_clip: active_clip.clone(), + inside, + on_menu, + hover_pos, + raw_world, + }, + paper_rect, + surround, + selecting, + sheet, + ); } #[cfg(test)] diff --git a/crates/ui-egui/src/canvas/cursor.rs b/crates/ui-egui/src/canvas/cursor.rs index 427445561..02f1cf4c2 100644 --- a/crates/ui-egui/src/canvas/cursor.rs +++ b/crates/ui-egui/src/canvas/cursor.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{CadApp, Color32, Pos2, Rect, Shape, SnapCycle, SnapHit, Stroke, Tokens, Vec2, Xf, pos2, snap, vec2}; pub(super) fn draw_snap_marker(p: &egui::Painter, at: Pos2, hit: &SnapHit) { let t = Tokens::get(); diff --git a/crates/ui-egui/src/canvas/cycle.rs b/crates/ui-egui/src/canvas/cycle.rs index f32123c8d..e7dae44bc 100644 --- a/crates/ui-egui/src/canvas/cycle.rs +++ b/crates/ui-egui/src/canvas/cycle.rs @@ -1,5 +1,5 @@ use super::grips::grip_at; -use super::*; +use super::{CadApp, Handle, Pos2, Rect, Stroke, Tokens, Vec2, Xf, pos2, vec2}; /// The objects under a click that selection cycling lets the user choose between: where the click /// was, each object with its row's label (type and layer), Shift held, and the rows as drawn. diff --git a/crates/ui-egui/src/canvas/draw.rs b/crates/ui-egui/src/canvas/draw.rs index 0c11eb635..9ca1d9314 100644 --- a/crates/ui-egui/src/canvas/draw.rs +++ b/crates/ui-egui/src/canvas/draw.rs @@ -1,5 +1,5 @@ use super::list::preview_options; -use super::*; +use super::{Bounds2, CanvasState, Color32, DisplayList, Handle, Kind, ListKey, Pos2, Rect, Rgb, Shape, Stroke, Vec2, Xf, vec2}; fn color32(c: Rgb) -> Color32 { Color32::from_rgb(c.0, c.1, c.2) @@ -336,6 +336,7 @@ pub(super) fn selection_area_fill(s: &cadcraft_engine::Settings, crossing: bool) #[cfg(test)] mod highlight_stability_tests { use super::*; + use egui::pos2; fn frame(list: &DisplayList, look: Look, pointer: Pos2) -> Vec { let ctx = egui::Context::default(); diff --git a/crates/ui-egui/src/canvas/dyn_boxes.rs b/crates/ui-egui/src/canvas/dyn_boxes.rs index 686f09110..b0bcfb9e2 100644 --- a/crates/ui-egui/src/canvas/dyn_boxes.rs +++ b/crates/ui-egui/src/canvas/dyn_boxes.rs @@ -1,5 +1,5 @@ use super::widgets::draw_lock; -use super::*; +use super::{CadApp, Pos2, Rect, Shape, Stroke, Tokens, Vec2, pos2, vec2}; /// The Dynamic Input tooltip beside the cursor, styled like the command line. At a point prompt /// it shows the pair of value boxes, a view of the command-line text (see [`crate::dyninput`]); diff --git a/crates/ui-egui/src/canvas/grid.rs b/crates/ui-egui/src/canvas/grid.rs index c2e616aaf..a07f4e092 100644 --- a/crates/ui-egui/src/canvas/grid.rs +++ b/crates/ui-egui/src/canvas/grid.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{Bounds2, CadApp, Shape, Stroke, Tokens, Vec2, Xf, pos2}; /// Grid spacing adapted to the zoom: multiply the unit until lines are at least `min_px` apart. fn adaptive(unit: f64, scale: f64, min_px: f64) -> f64 { diff --git a/crates/ui-egui/src/canvas/grips.rs b/crates/ui-egui/src/canvas/grips.rs index 65e1cbc16..8bd0e6467 100644 --- a/crates/ui-egui/src/canvas/grips.rs +++ b/crates/ui-egui/src/canvas/grips.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{CadApp, Handle, Input, Pos2, Rect, Xf, vec2}; /// A click on grip `g` (idle): Shift+click makes it hot or cold again; a plain click starts /// editing it, with the other hot grips when it is one of them. diff --git a/crates/ui-egui/src/canvas/list.rs b/crates/ui-egui/src/canvas/list.rs index 0e15fc01e..2d548264e 100644 --- a/crates/ui-egui/src/canvas/list.rs +++ b/crates/ui-egui/src/canvas/list.rs @@ -1,5 +1,5 @@ use super::viewport::{split_viewport, stencil_clip}; -use super::*; +use super::{Bounds2, CadApp, DisplayList, Handle, ListKey, Rgb, Tokens, Xf, rebuild, same_content}; /// Primitives of `list` sorted by entity handle, built on the first highlight after each list /// rebuild. Highlighting the hovered entity used to scan every primitive on every frame: ~2.5 ms diff --git a/crates/ui-egui/src/canvas/pick.rs b/crates/ui-egui/src/canvas/pick.rs index ea970a8d0..3bd28b017 100644 --- a/crates/ui-egui/src/canvas/pick.rs +++ b/crates/ui-egui/src/canvas/pick.rs @@ -1,4 +1,4 @@ -use super::*; +use super::{CadApp, Handle, Input, Vec2}; /// The vertical wheel scroll this frame that zooms, in points, read from the raw wheel events so /// each notch zooms by its whole step at once, as in standard CAD (#660). egui's smoothed delta diff --git a/crates/ui-egui/src/canvas/viewport.rs b/crates/ui-egui/src/canvas/viewport.rs index c96a2bc83..c79354b6c 100644 --- a/crates/ui-egui/src/canvas/viewport.rs +++ b/crates/ui-egui/src/canvas/viewport.rs @@ -1,5 +1,5 @@ use super::draw::draw_list; -use super::*; +use super::{Bounds2, CadApp, DisplayList, Handle, Kind, Rect, Rgb, Vec2, Xf}; /// The active MSPACE viewport when its contents are drawn apart from the layout's list (see /// [`VpContent`]), with its clip outline when it is clipped. A clipped viewport is clipped with diff --git a/crates/ui-egui/src/canvas/widgets.rs b/crates/ui-egui/src/canvas/widgets.rs index cd55a7f67..d10e40af3 100644 --- a/crates/ui-egui/src/canvas/widgets.rs +++ b/crates/ui-egui/src/canvas/widgets.rs @@ -1,6 +1,6 @@ use super::draw::draw_list; use super::grid::draw_grid; -use super::*; +use super::{CadApp, Color32, Pos2, Rect, Rgb, Shape, Stroke, Tokens, Xf, pos2, vec2}; pub(super) fn tile_rects(app: &CadApp, full: Rect) -> Vec<(Rect, cadcraft_engine::ModelTile)> { let x = |f: f64| full.left() + full.width() * f.clamp(0.0, 1.0) as f32; diff --git a/crates/ui-egui/src/chrome.rs b/crates/ui-egui/src/chrome.rs index f3a935d79..7639dbba1 100644 --- a/crates/ui-egui/src/chrome.rs +++ b/crates/ui-egui/src/chrome.rs @@ -290,6 +290,43 @@ fn visible_tabs(widths: &[f32], active: Option, room: f32) -> std::ops::R start..active + 1 } +fn draw_status_toggles( + app: &mut CadApp, + ui: &mut egui::Ui, + painter: &egui::Painter, + t: Tokens, + toggles: &[(Icon, bool, &str, &str)], + layout: (Rect, f32, f32), +) { + let (rect, mut rx, size) = layout; + let mut toggle_cmd = None; + for &(icon, on, cmd, tip) in toggles { + let br = Rect::from_min_size(pos2(rx, rect.center().y - size / 2.0), vec2(size, size)); + let resp = ui.interact(br, ui.scope_id().with(("tg", tip)), Sense::click()); + if on { + painter.rect_filled(br, 3.0, t.toggle_on.gamma_multiply(0.35)); + } else if resp.hovered() { + painter.rect_filled(br, 3.0, t.control_hover.gamma_multiply(0.5)); + } + icons::paint(painter, br.shrink(2.5), icon, false); + if on { + // Re-tint the icon blue-ish by an underline. + painter.hline(br.x_range().shrink(4.0), br.bottom() - 1.0, Stroke::new(1.5, t.toggle_on)); + } + icons::describe_control(ui, &resp, tip, Some(on), false); + if resp.on_hover_text(crate::i18n::t(tip)).clicked() { + toggle_cmd = Some(cmd); + } + rx += size + 4.0; + } + // The toggles don't cancel the active command (#1108); the dialog buttons start theirs. + match toggle_cmd { + Some(c) if c.starts_with("ui.") => app.start(c), + Some(c) => crate::menus::run_transparent(app, c), + None => {} + } +} + /// Status bar: layout tabs follow the left-hand layout actions, independent of palette docking. /// Coordinates and drafting toggles remain on the right. pub fn status_bar(app: &mut CadApp, ui: &mut egui::Ui) { @@ -343,7 +380,7 @@ pub fn status_bar(app: &mut CadApp, ui: &mut egui::Ui) { (Icon::Gear, false, "ui.dialog.dsettings", "Drafting Settings"), ]; let size = 20.0; - let mut rx = r.right() - 8.0 - toggles.len() as f32 * (size + 4.0); + let rx = r.right() - 8.0 - toggles.len() as f32 * (size + 4.0); // Coordinates. let coord = app.canvas.cursor.map(|c| { let (lu, lp) = app.session.doc().map(|d| (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4))).unwrap_or((2, 4)); @@ -486,32 +523,7 @@ pub fn status_bar(app: &mut CadApp, ui: &mut egui::Ui) { ui.interact(rect, ui.scope_id().with("status_readout"), Sense::hover()).on_hover_text(text); } } - let mut toggle_cmd = None; - for (icon, on, cmd, tip) in toggles { - let br = Rect::from_min_size(pos2(rx, r.center().y - size / 2.0), vec2(size, size)); - let resp = ui.interact(br, ui.scope_id().with(("tg", tip)), Sense::click()); - if on { - p.rect_filled(br, 3.0, t.toggle_on.gamma_multiply(0.35)); - } else if resp.hovered() { - p.rect_filled(br, 3.0, t.control_hover.gamma_multiply(0.5)); - } - icons::paint(&p, br.shrink(2.5), icon, false); - if on { - // Re-tint the icon blue-ish by an underline. - p.hline(br.x_range().shrink(4.0), br.bottom() - 1.0, Stroke::new(1.5, t.toggle_on)); - } - icons::describe_control(ui, &resp, tip, Some(on), false); - if resp.on_hover_text(crate::i18n::t(tip)).clicked() { - toggle_cmd = Some(cmd); - } - rx += size + 4.0; - } - // The toggles don't cancel the active command (#1108); the dialog buttons start theirs. - match toggle_cmd { - Some(c) if c.starts_with("ui.") => app.start(c), - Some(c) => crate::menus::run_transparent(app, c), - None => {} - } + draw_status_toggles(app, ui, &p, t, &toggles, (r, rx, size)); }); } @@ -563,7 +575,7 @@ pub fn start_page(app: &mut CadApp, ui: &mut egui::Ui) { y += 46.0; } if let Some(path) = recent { - app.open_path(&path); + app.open_path(std::path::Path::new(&path)); } else if app.ui.recent_files.is_empty() { p.text( pos2(main.center().x, main.center().y), diff --git a/crates/ui-egui/src/docking.rs b/crates/ui-egui/src/docking.rs index bbbf08902..50fb52a25 100644 --- a/crates/ui-egui/src/docking.rs +++ b/crates/ui-egui/src/docking.rs @@ -350,9 +350,9 @@ pub fn show(app: &mut crate::CadApp, ui: &mut egui::Ui) { #[cfg(not(target_arch = "wasm32"))] for files in std::mem::take(&mut output.window_files) { for file in files.dropped { - let path = file.path().to_string_lossy().to_string(); - if !path.is_empty() { - app.open_path(&path); + let path = file.path(); + if !path.as_os_str().is_empty() { + app.open_path(path); } } } diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rs index 3c0be7611..30f3b0a85 100644 --- a/crates/ui-egui/src/gpu.rs +++ b/crates/ui-egui/src/gpu.rs @@ -23,6 +23,8 @@ use cadcraft_render::{DisplayList, Kind}; use egui_wgpu::wgpu; use egui_wgpu::wgpu::util::DeviceExt; +use crate::switch::Switch; + /// Line/triangle vertex: position (2 × f32, relative to the origin) + sRGB colour (4 × u8, /// premultiplied by its alpha: transparent objects blend with what is under them). const VERTEX_SIZE: usize = 12; @@ -44,12 +46,8 @@ const POINT_SIZE: f32 = 1.5; /// then Mailbox, then falls back to FIFO, so it is valid on every surface; under a compositor the /// compositor still syncs to the display. `vsync` is the `CADCRAFT_VSYNC` override: `1`/`on` /// forces FIFO (tear-free without a compositor), `0`/`off` forces the low-latency mode. -pub fn surface_config(vsync: Option<&str>, low_latency: bool) -> egui_wgpu::SurfaceConfig { - let no_vsync = match vsync.map(|v| v.trim().to_ascii_lowercase()).as_deref() { - Some("1" | "on" | "true" | "yes") => false, - Some("0" | "off" | "false" | "no") => true, - _ => low_latency, - }; +pub fn surface_config(vsync: Switch, low_latency: bool) -> egui_wgpu::SurfaceConfig { + let no_vsync = !vsync.or(!low_latency); egui_wgpu::SurfaceConfig { present_mode: if no_vsync { wgpu::PresentMode::AutoNoVsync } else { wgpu::PresentMode::AutoVsync }, desired_maximum_frame_latency: Some(1), @@ -801,17 +799,11 @@ mod tests { #[test] fn surface_config_prefers_low_latency_where_asked_and_honours_override() { use wgpu::PresentMode::{AutoNoVsync, AutoVsync}; - assert_eq!(surface_config(None, true).present_mode, AutoNoVsync); - assert_eq!(surface_config(None, false).present_mode, AutoVsync); - for on in ["1", "on", " TRUE ", "yes"] { - assert_eq!(surface_config(Some(on), true).present_mode, AutoVsync, "{on}"); - } - for off in ["0", "Off", "false", "no"] { - assert_eq!(surface_config(Some(off), false).present_mode, AutoNoVsync, "{off}"); - } - assert_eq!(surface_config(Some("maybe"), true).present_mode, AutoNoVsync); - assert_eq!(surface_config(Some(""), false).present_mode, AutoVsync); - assert_eq!(surface_config(None, true).desired_maximum_frame_latency, Some(1)); + assert_eq!(surface_config(Switch::Default, true).present_mode, AutoNoVsync); + assert_eq!(surface_config(Switch::Default, false).present_mode, AutoVsync); + assert_eq!(surface_config(Switch::On, true).present_mode, AutoVsync); + assert_eq!(surface_config(Switch::Off, false).present_mode, AutoNoVsync); + assert_eq!(surface_config(Switch::Default, true).desired_maximum_frame_latency, Some(1)); } #[cfg(not(target_arch = "wasm32"))] diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs index 9524b2e9f..0e1e23e19 100644 --- a/crates/ui-egui/src/i18n/tests.rs +++ b/crates/ui-egui/src/i18n/tests.rs @@ -157,8 +157,7 @@ fn module_files(dir: &std::path::Path, files: &mut Vec) { } } -#[test] -fn locale_and_saved_preference_resolution() { +fn assert_primary_locale_aliases() { for tag in ["uk", "uk-UA", "uk_UA.UTF-8", "UK-ua", " uk-UA ", "uk_UA@euro"] { assert_eq!(locale_language(tag), Some("uk"), "{tag}"); } @@ -168,12 +167,18 @@ fn locale_and_saved_preference_resolution() { for (tag, code) in [("ru", "ru"), ("ru-RU", "ru"), ("ru_RU.UTF-8", "ru"), ("fr", "fr"), ("fr-FR", "fr"), ("fr_CA.UTF-8", "fr")] { assert_eq!(locale_language(tag), Some(code), "{tag}"); } +} + +fn assert_portuguese_and_spanish_aliases() { for tag in ["pt", "pt-BR", "pt_BR.UTF-8", "PT-br", "pt-PT"] { assert_eq!(locale_language(tag), Some("pt-BR"), "{tag}"); } for tag in ["es", "es-ES", "es_MX.UTF-8", "ES-ar"] { assert_eq!(locale_language(tag), Some("es"), "{tag}"); } +} + +fn assert_additional_locale_aliases() { for (code, tags) in [ ("cs", &["cs", "cs-CZ", "cs_CZ.UTF-8", "CS-cz", " cs-CZ ", "cs_CZ@euro"][..]), ("it", &["it", "it-IT", "it_IT.UTF-8", "IT-ch", " it-CH ", "it_IT@euro"]), @@ -188,12 +193,18 @@ fn locale_and_saved_preference_resolution() { assert_eq!(locale_language(tag), Some(code), "{tag}"); } } +} + +fn assert_unrecognized_locale_tags() { // Look-alike codes, three-letter codes and endonyms pick nothing: `se` is Northern Sami. let look_alikes = ["ua", "ukulele", "pl-PL", "", "garbage", "💙", "ptolemy", "cz", "csharp", "csomething", "italic"]; let others = ["kr", "korean", "kotlin", "se", "swe", "svenska", "hun", "magyar", "tur", "türkçe", "elvish"]; for tag in look_alikes.into_iter().chain(others) { assert_eq!(locale_language(tag), None, "{tag}"); } +} + +fn assert_auto_locale_precedence() { assert_eq!(Preference::Auto.resolve(&["pl-PL".into(), "pt-BR".into()]), "pt-BR"); assert_eq!(Preference::Auto.resolve(&["fr-FR".into(), "pt-BR".into()]), "fr"); assert_eq!(Preference::Auto.resolve(&["es-ES".into(), "pt-BR".into()]), "es"); @@ -202,30 +213,51 @@ fn locale_and_saved_preference_resolution() { assert_eq!(Preference::English.resolve(&locales), "en"); assert_eq!(Preference::Auto.resolve(&["en-US".into(), "uk-UA".into()]), "en"); assert_eq!(Preference::Auto.resolve(&[]), "en"); +} + +fn assert_saved_preference_restoration(preference: Preference) { + assert_eq!(Preference::restore(Some(preference.code())), preference); + let saved = serde_json::to_string(&preference).unwrap(); + assert_eq!(saved, format!("\"{}\"", preference.code())); + assert_eq!(serde_json::from_str::(&saved).unwrap(), preference); + assert_eq!(serde_json::from_value::(json!(preference.code())).unwrap(), preference); +} + +fn assert_preference_resolution(preference: Preference) { + if preference == Preference::Auto { + return; + } + assert_eq!(Preference::parse(preference.code()), Some(preference)); + // A chosen language wins over the system's; Auto takes the first system language there is. + assert_eq!(preference.resolve(&["uk-UA".into()]), preference.code()); + if preference != Preference::English { + assert_eq!(Preference::Auto.resolve(&["pl-PL".into(), preference.code().into(), "en-US".into()]), preference.code()); + } +} + +fn assert_saved_preference_persistence(preference: Preference) { + let mut app = CadApp::new(Session::new(), Services::default()); + app.ui.interface_language = preference; + let mut restored = CadApp::new(Session::new(), Services::default()); + restored.load_prefs(&app.prefs_json()); + assert_eq!(restored.ui.interface_language, preference); + restored.load_prefs(r#"{"interfaceLanguage":"klingon"}"#); + assert_eq!(restored.ui.interface_language, preference); +} + +#[test] +fn locale_and_saved_preference_resolution() { + assert_primary_locale_aliases(); + assert_portuguese_and_spanish_aliases(); + assert_additional_locale_aliases(); + assert_unrecognized_locale_tags(); + assert_auto_locale_precedence(); assert_eq!(Preference::restore(None), Preference::Auto); assert_eq!(Preference::restore(Some("obsolete")), Preference::Auto); for preference in Preference::ALL { - assert_eq!(Preference::restore(Some(preference.code())), preference); - let saved = serde_json::to_string(&preference).unwrap(); - assert_eq!(saved, format!("\"{}\"", preference.code())); - assert_eq!(serde_json::from_str::(&saved).unwrap(), preference); - if preference == Preference::Auto { - continue; - } - assert_eq!(Preference::parse(preference.code()), Some(preference)); - // A chosen language wins over the system's; Auto takes the first system language there is. - assert_eq!(preference.resolve(&["uk-UA".into()]), preference.code()); - if preference != Preference::English { - assert_eq!(Preference::Auto.resolve(&["pl-PL".into(), preference.code().into(), "en-US".into()]), preference.code()); - } - // Saved with the host's other preferences; a bad saved value keeps the current choice. - let mut a = CadApp::new(Session::new(), Services::default()); - a.ui.interface_language = preference; - let mut b = CadApp::new(Session::new(), Services::default()); - b.load_prefs(&a.prefs_json()); - assert_eq!(b.ui.interface_language, preference); - b.load_prefs(r#"{"interfaceLanguage":"klingon"}"#); - assert_eq!(b.ui.interface_language, preference); + assert_saved_preference_restoration(preference); + assert_preference_resolution(preference); + assert_saved_preference_persistence(preference); } assert!(serde_json::from_str::("\"unsupported\"").is_err()); assert_eq!(serde_json::from_value::(json!({})).unwrap().interface_language, Preference::Auto); diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs index 1f018df2e..8e0f89963 100644 --- a/crates/ui-egui/src/icons.rs +++ b/crates/ui-egui/src/icons.rs @@ -230,6 +230,19 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { let alpha = |c: Color32| if dim { c.gamma_multiply(0.4) } else { c }; let pen = Pen { p, r: rect, w: (rect.width() / 16.0).clamp(1.0, 1.6), base: alpha(t.icon), acc: alpha(t.icon_accent), pt: alpha(t.icon_point) }; let (b, a) = (pen.base, pen.acc); + paint_file_view(&pen, icon, b, a, dim); + paint_document_tools(&pen, icon, b, a, dim); + paint_draw_tools(&pen, icon, b, a, dim); + paint_edit_tools(&pen, icon, b, a, dim); + paint_dimensions(&pen, icon, b, a, dim); + paint_block_tools(&pen, icon, b, a, dim); + paint_layer_tools(&pen, icon, b, a, dim); + paint_display_toggles(&pen, icon, b, a, dim); + paint_navigation_controls(&pen, icon, b, a, dim); + paint_constraints(&pen, icon, b, a, dim); +} + +fn paint_file_view(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, _dim: bool) { use Icon::*; match icon { New => { @@ -331,6 +344,13 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { b, ); } + _ => {} + } +} + +fn paint_document_tools(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, _dim: bool) { + use Icon::*; + match icon { Orbit => { pen.c(12.0, 12.0, 4.0, b); pen.arc(12.0, 12.0, 9.0, 20.0, 160.0, a); @@ -355,6 +375,13 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.poly(&[(3.0, y + 2.0), (12.0, *y - 2.0), (21.0, y + 2.0), (12.0, y + 6.0)], true, c); } } + _ => {} + } +} + +fn paint_draw_tools(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, dim: bool) { + use Icon::*; + match icon { Help => { pen.c(12.0, 12.0, 9.0, b); pen.text(12.0, 12.5, "?", 12.0, b); @@ -485,6 +512,13 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.la(14.0, 18.0, 21.0, 18.0); pen.la(14.0, 21.0, 19.0, 21.0); } + _ => {} + } +} + +fn paint_edit_tools(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, _dim: bool) { + use Icon::*; + match icon { Move => { pen.la(12.0, 3.0, 12.0, 21.0); pen.la(3.0, 12.0, 21.0, 12.0); @@ -604,6 +638,13 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.poly(&[(20.0, 6.0), (20.0, 11.0), (11.0, 11.0), (11.0, 14.0)], false, b); pen.fill_rect(9.5, 14.0, 3.0, 8.0, a); } + _ => {} + } +} + +fn paint_dimensions(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, _dim: bool) { + use Icon::*; + match icon { DimLinear | DimAligned | DimBaseline | DimContinue | QDim => { let (y0, y1) = (8.0, 18.0); pen.l(4.0, y1, 4.0, 5.0); @@ -673,6 +714,13 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { _ => pen.text(19.0, 19.0, "A", 9.0, a), } } + _ => {} + } +} + +fn paint_block_tools(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, _dim: bool) { + use Icon::*; + match icon { LayerOff | LayerIso | LayerFreeze | LayerLock | LayerMatch | MakeCurrent | LayerPrev => { pen.poly(&[(2.0, 9.0), (10.0, 5.0), (18.0, 9.0), (10.0, 13.0)], true, b); pen.poly(&[(2.0, 13.0), (10.0, 17.0), (18.0, 13.0)], false, b); @@ -691,11 +739,27 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { } } } + _ => {} + } +} + +fn paint_layer_tools(pen: &Pen<'_>, icon: Icon, _b: Color32, _a: Color32, dim: bool) { + let alpha = |c: Color32| if dim { c.gamma_multiply(0.4) } else { c }; + use Icon::*; + match icon { Bulb | BulbOff => { let c = if icon == Bulb { Color32::from_rgb(0xf5, 0xd0, 0x3b) } else { Color32::from_rgb(0x70, 0x78, 0x86) }; pen.fill_c(12.0, 10.0, 6.0, alpha(c)); pen.fill_rect(9.5, 15.0, 5.0, 4.0, alpha(Color32::from_rgb(0xb0, 0xb4, 0xba))); } + _ => {} + } +} + +fn paint_display_toggles(pen: &Pen<'_>, icon: Icon, b: Color32, _a: Color32, dim: bool) { + let alpha = |c: Color32| if dim { c.gamma_multiply(0.4) } else { c }; + use Icon::*; + match icon { Lock | Unlock => { let c = alpha(Color32::from_rgb(0xe6, 0xb4, 0x3c)); pen.fill_rect(6.0, 11.0, 12.0, 9.0, c); @@ -762,7 +826,7 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { Lineweight => { for (k, w) in [1.0f32, 2.0, 3.5].iter().enumerate() { let y = 6.0 + k as f32 * 6.0; - p.line_segment([pen.at(3.0, y), pen.at(21.0, y)], Stroke::new(w * pen.sc(), b)); + pen.p.line_segment([pen.at(3.0, y), pen.at(21.0, y)], Stroke::new(w * pen.sc(), b)); } } Transparency => { @@ -784,7 +848,7 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.c(12.0, 12.0, 4.0, b); for i in 0..8 { let ang = (i as f32 * 45.0).to_radians(); - p.line_segment( + pen.p.line_segment( [pen.at(12.0 + 6.0 * ang.cos(), 12.0 + 6.0 * ang.sin()), pen.at(12.0 + 9.0 * ang.cos(), 12.0 + 9.0 * ang.sin())], Stroke::new(2.2 * pen.sc(), b), ); @@ -801,6 +865,13 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.l(9.0, 4.0, 9.0, 20.0); pen.l(9.0, 9.0, 21.0, 9.0); } + _ => {} + } +} + +fn paint_navigation_controls(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, _dim: bool) { + use Icon::*; + match icon { ChevronDown => pen.poly(&[(6.0, 9.0), (12.0, 15.0), (18.0, 9.0)], false, b), ChevronUp => pen.poly(&[(6.0, 15.0), (12.0, 9.0), (18.0, 15.0)], false, b), ChevronLeft => pen.poly(&[(15.0, 6.0), (9.0, 12.0), (15.0, 18.0)], false, b), @@ -827,6 +898,14 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.l(4.0, y, 20.0, y); } } + _ => {} + } +} + +fn paint_constraints(pen: &Pen<'_>, icon: Icon, b: Color32, a: Color32, dim: bool) { + let alpha = |c: Color32| if dim { c.gamma_multiply(0.4) } else { c }; + use Icon::*; + match icon { Constraint | Fix => { pen.fill_rect(7.0, 11.0, 10.0, 9.0, Color32::from_rgb(0xe6, 0xb4, 0x3c)); pen.arc(12.0, 11.0, 4.0, 0.0, 180.0, Color32::from_rgb(0xe6, 0xb4, 0x3c)); @@ -940,6 +1019,7 @@ pub fn paint(p: &Painter, rect: Rect, icon: Icon, dim: bool) { pen.poly(&[(3.0, 4.0), (19.0, 4.0), (13.0, 11.0), (13.0, 19.0), (9.0, 17.0), (9.0, 11.0)], true, b); pen.poly(&[(20.0, 10.0), (16.5, 15.5), (20.0, 15.5), (17.0, 21.0)], false, a); } + _ => {} } } diff --git a/crates/ui-egui/src/layers.rs b/crates/ui-egui/src/layers.rs index 8a95138eb..1801265fd 100644 --- a/crates/ui-egui/src/layers.rs +++ b/crates/ui-egui/src/layers.rs @@ -377,7 +377,19 @@ pub fn dialog(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) { } ui.end_row(); for l in &shown { - row(ui, l, &cur, &used, vp.as_ref(), &linetypes, &library, &mut st, &mut actions); + row( + ui, + LayerRow { + layer: l, + current: &cur, + used: &used, + viewport: vp.as_ref(), + linetypes: &linetypes, + library: &library, + state: &mut st, + actions: &mut actions, + }, + ); ui.end_row(); } }, @@ -405,91 +417,22 @@ pub fn dialog(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) { } } -/// One Layer Properties Manager row: status/name, on/freeze/lock/plot, colour, linetype, lineweight, transparency, viewport overrides, new-viewport freeze and description. -/// Edits update `st` and push commands into `actions`. -#[allow(clippy::too_many_arguments)] -fn row( - ui: &mut egui::Ui, - l: &Layer, - cur: &str, - used: &std::collections::HashSet, - vp: Option<&(Handle, cadcraft_doc::Viewport)>, - linetypes: &[cadcraft_doc::Linetype], - library: &[String], - st: &mut LpmState, - actions: &mut Vec<(&'static str, Value)>, -) { +/// One Layer Properties Manager row. +struct LayerRow<'a> { + layer: &'a Layer, + current: &'a str, + used: &'a std::collections::HashSet, + viewport: Option<&'a (Handle, cadcraft_doc::Viewport)>, + linetypes: &'a [cadcraft_doc::Linetype], + library: &'a [String], + state: &'a mut LpmState, + actions: &'a mut Vec<(&'static str, Value)>, +} + +fn row(ui: &mut egui::Ui, args: LayerRow<'_>) { + let LayerRow { layer: l, current: cur, used, viewport: vp, linetypes, library, state: st, actions } = args; let t = Tokens::get(); - let name = l.name.clone(); - let current = name.eq_ignore_ascii_case(cur); - let is_used = used.contains(&name.to_ascii_lowercase()); - let selected = st.selected.as_deref().is_some_and(|s| s.eq_ignore_ascii_case(&name)); - // Status. - let (sr, sresp) = ui.allocate_exact_size(vec2(22.0, 20.0), Sense::click()); - if selected { - ui.painter().rect_filled(sr, 2.0, t.accent.gamma_multiply(0.35)); - } - status_icon(ui.painter(), sr.shrink(2.0), current, is_used); - let tip = if current { - "Current layer" - } else if is_used { - "Layer contains objects (double-click to make current)" - } else { - "Layer is empty (double-click to make current)" - }; - if sresp.on_hover_text(crate::i18n::t(tip)).double_clicked() { - actions.push(("layer.current", json!({ "name": name }))); - } - // Name (double-click or F2-style rename). - match st.renaming.clone() { - Some((n, mut buf)) if n.eq_ignore_ascii_case(&name) => { - let r = ui - .add(egui::TextEdit::singleline(&mut buf).desired_width(150.0).id(egui::Id::unique(("lpm_rename", &name)))) - .accessible_name(crate::tl!("Name")); - if !r.has_focus() && !r.lost_focus() { - r.request_focus(); - } - if r.lost_focus() { - let cancel = ui.input(|i| i.key_pressed(egui::Key::Escape)); - if !cancel && buf.trim() != name && !buf.trim().is_empty() { - actions.push(("layer.set", json!({ "name": name, "newName": buf.trim() }))); - st.selected = Some(buf.trim().to_string()); - } - st.renaming = None; - } else { - st.renaming = Some((n, buf)); - } - } - _ => { - let (nr, r) = ui.allocate_exact_size(vec2(150.0, 20.0), Sense::click()); - if selected { - ui.painter().rect_filled(nr, 2.0, t.accent.gamma_multiply(0.45)); - } else if r.hovered() { - ui.painter().rect_filled(nr, 2.0, t.control_hover.gamma_multiply(0.5)); - } - ui.painter().text(pos2(nr.left() + 4.0, nr.center().y), egui::Align2::LEFT_CENTER, &name, crate::theme::body(), t.text); - if r.clicked() { - st.selected = Some(name.clone()); - } - if r.double_clicked() && name != "0" && !name.eq_ignore_ascii_case("Defpoints") { - st.renaming = Some((name.clone(), name.clone())); - } - r.context_menu(|ui| { - if ui.button(crate::tl!("Set Current")).clicked() { - actions.push(("layer.current", json!({ "name": name }))); - ui.close(); - } - if ui.button(crate::tl!("Rename Layer")).clicked() { - st.renaming = Some((name.clone(), name.clone())); - ui.close(); - } - if ui.button(crate::tl!("Delete Layer")).clicked() { - actions.push(("layer.delete", json!({ "name": name }))); - ui.close(); - } - }); - } - } + let name = layer_identity(ui, l, cur, used, st, actions); // On / Freeze / Lock / Plot. if icons::button(ui, if l.on { Icon::Bulb } else { Icon::BulbOff }, 20.0, "On/Off", false).clicked() { actions.push(("layer.set", json!({ "name": name, "on": !l.on }))); @@ -684,7 +627,88 @@ fn row( } } -/// Lower-case names of layers with objects on them. +fn layer_identity( + ui: &mut egui::Ui, + l: &Layer, + cur: &str, + used: &std::collections::HashSet, + st: &mut LpmState, + actions: &mut Vec<(&'static str, Value)>, +) -> String { + let t = Tokens::get(); + let name = l.name.clone(); + let current = name.eq_ignore_ascii_case(cur); + let is_used = used.contains(&name.to_ascii_lowercase()); + let selected = st.selected.as_deref().is_some_and(|s| s.eq_ignore_ascii_case(&name)); + // Status. + let (sr, sresp) = ui.allocate_exact_size(vec2(22.0, 20.0), Sense::click()); + if selected { + ui.painter().rect_filled(sr, 2.0, t.accent.gamma_multiply(0.35)); + } + status_icon(ui.painter(), sr.shrink(2.0), current, is_used); + let tip = if current { + "Current layer" + } else if is_used { + "Layer contains objects (double-click to make current)" + } else { + "Layer is empty (double-click to make current)" + }; + if sresp.on_hover_text(crate::i18n::t(tip)).double_clicked() { + actions.push(("layer.current", json!({ "name": name }))); + } + // Name (double-click or F2-style rename). + match st.renaming.clone() { + Some((n, mut buf)) if n.eq_ignore_ascii_case(&name) => { + let r = ui + .add(egui::TextEdit::singleline(&mut buf).desired_width(150.0).id(egui::Id::unique(("lpm_rename", &name)))) + .accessible_name(crate::tl!("Name")); + if !r.has_focus() && !r.lost_focus() { + r.request_focus(); + } + if r.lost_focus() { + let cancel = ui.input(|i| i.key_pressed(egui::Key::Escape)); + if !cancel && buf.trim() != name && !buf.trim().is_empty() { + actions.push(("layer.set", json!({ "name": name, "newName": buf.trim() }))); + st.selected = Some(buf.trim().to_string()); + } + st.renaming = None; + } else { + st.renaming = Some((n, buf)); + } + } + _ => { + let (nr, r) = ui.allocate_exact_size(vec2(150.0, 20.0), Sense::click()); + if selected { + ui.painter().rect_filled(nr, 2.0, t.accent.gamma_multiply(0.45)); + } else if r.hovered() { + ui.painter().rect_filled(nr, 2.0, t.control_hover.gamma_multiply(0.5)); + } + ui.painter().text(pos2(nr.left() + 4.0, nr.center().y), egui::Align2::LEFT_CENTER, &name, crate::theme::body(), t.text); + if r.clicked() { + st.selected = Some(name.clone()); + } + if r.double_clicked() && name != "0" && !name.eq_ignore_ascii_case("Defpoints") { + st.renaming = Some((name.clone(), name.clone())); + } + r.context_menu(|ui| { + if ui.button(crate::tl!("Set Current")).clicked() { + actions.push(("layer.current", json!({ "name": name }))); + ui.close(); + } + if ui.button(crate::tl!("Rename Layer")).clicked() { + st.renaming = Some((name.clone(), name.clone())); + ui.close(); + } + if ui.button(crate::tl!("Delete Layer")).clicked() { + actions.push(("layer.delete", json!({ "name": name }))); + ui.close(); + } + }); + } + } + name +} + fn used_layers(d: &cadcraft_doc::Drawing) -> std::collections::HashSet { let mut set = std::collections::HashSet::new(); let ents = d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).chain(d.blocks.values().flat_map(|b| b.entities.iter())); diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 017cf5a42..22e325cbe 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -27,6 +27,7 @@ pub mod hatchdlg; mod mtext_editor; mod panel_state; pub mod spacemouse; +pub mod switch; // The External References palette. pub mod xrefs; @@ -55,6 +56,7 @@ pub mod vpscale; pub mod exchange; +use std::path::Path; use std::sync::mpsc::Receiver; use cadcraft_engine::Session; @@ -88,7 +90,7 @@ pub struct UiState { /// Keep the system cursor visible over the drawing area (a small crosshair at the centre of the /// drawn one) instead of hiding it. Screen magnifiers (Windows Magnifier "follow the mouse /// pointer"), screen readers, recorders and remote desktops track the system cursor and lose it - /// when it is hidden. Off by default; `CADCRAFT_SYSTEM_CURSOR=1` turns it on at startup. + /// when it is hidden. Off unless the host defaults to it ([`CadApp::set_system_cursor_default`]). pub system_cursor: bool, /// "Drafting" or "Modeling". pub toolset_tab: String, @@ -173,7 +175,7 @@ impl Default for UiState { show_viewcube: true, show_ucs_icon: true, show_layer_list: false, - system_cursor: std::env::var("CADCRAFT_SYSTEM_CURSOR").is_ok_and(|v| !matches!(v.trim(), "" | "0" | "false" | "off")), + system_cursor: false, toolset_tab: "Drafting".into(), collapsed_groups: Vec::new(), hidden_tools: Vec::new(), @@ -211,6 +213,8 @@ pub struct CadApp { /// Whether the operating system shows animations, as the host reads it; `None` when the OS /// states nothing or the host cannot ask ([`animation`]). pub system_animations: Option, + /// What `ui.system_cursor` goes back to when the interface is reset ([`Self::set_system_cursor_default`]). + pub system_cursor_default: bool, pub session: Session, pub ui: UiState, /// The interface's own preferences from the Options dialog ([`options`]). @@ -296,6 +300,7 @@ impl CadApp { CadApp { system_languages: Vec::new(), system_animations: None, + system_cursor_default: false, session, ui: UiState::default(), options: options::UiOptions::default(), @@ -469,6 +474,15 @@ impl CadApp { } } + /// Make the system cursor the interface default (`on`) and turn it on; saved preferences and + /// resets never turn it off then. + pub fn set_system_cursor_default(&mut self, on: bool) { + self.system_cursor_default = on; + if on { + self.ui.system_cursor = true; + } + } + pub fn set_status(&mut self, s: impl Into) { self.status = Some((s.into(), now_ms())); } @@ -481,12 +495,12 @@ impl CadApp { /// Open the drawing at `path`. Natively the file is read on a worker thread while an /// "Opening ..." card shows ([`opening`]); [`Self::finish_opening`] adds it when ready. On the /// web it opens at once. - pub fn open_path(&mut self, path: &str) { + pub fn open_path(&mut self, path: &Path) { // A LISP file (dropped on the window): loaded as APPLOAD loads it. if is_lisp_file(path) { match cadcraft_engine::lisp::builtins::read_text_file(path) { - Some(text) => self.load_lisp(path, &text), - None => self.open_failed(format!("APPLOAD: can't read {path}")), + Some(text) => self.load_lisp(&path.to_string_lossy(), &text), + None => self.open_failed(format!("APPLOAD: can't read {}", path.display())), } return; } @@ -496,7 +510,10 @@ impl CadApp { } #[cfg(target_arch = "wasm32")] { - let r = self.run("open", json!({ "path": path })); + let r = match path.to_str() { + Some(text) => self.run("open", json!({ "path": text })), + None => Err(format!("open: {}: the path is not valid Unicode", path.display())), + }; self.opened(r); } } @@ -800,9 +817,9 @@ impl CadApp { { let dropped = ctx.input_mut(|input| std::mem::take(&mut input.raw.dropped_files)); for file in dropped { - let path = file.path().to_string_lossy().to_string(); - if !path.is_empty() { - self.open_path(&path); + let path = file.path(); + if !path.as_os_str().is_empty() { + self.open_path(path); } } } @@ -889,8 +906,8 @@ pub fn now_ms() -> f64 { } /// A LISP source file, by its name. -fn is_lisp_file(name: &str) -> bool { - std::path::Path::new(name).extension().is_some_and(|e| e.eq_ignore_ascii_case("lsp")) +fn is_lisp_file(name: impl AsRef) -> bool { + name.as_ref().extension().is_some_and(|e| e.eq_ignore_ascii_case("lsp")) } #[cfg(test)] diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs index 43b135d19..58055542f 100644 --- a/crates/ui-egui/src/menus.rs +++ b/crates/ui-egui/src/menus.rs @@ -85,7 +85,7 @@ pub fn run_ui_command(app: &mut CadApp, id: &str, params: &Value) -> Option Option> { +fn route_ui_subsystems(app: &mut CadApp, id: &str, params: &Value) -> Option> { if let Some(result) = crate::spacemouse::route(app, id, params) { return Some(result); } @@ -118,43 +118,208 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option Option> { if id == RECENT_CLEAR { app.ui.recent_files.clear(); return Some(Ok(Value::Null)); } if let Some(i) = id.strip_prefix(RECENT_ITEM).and_then(|n| n.parse::().ok()) { let Some(path) = app.ui.recent_files.get(i).cloned() else { return Some(Err(format!("no recent file {i}"))) }; - app.open_path(&path); + app.open_path(std::path::Path::new(&path)); return Some(Ok(Value::Null)); } + None +} + +fn run_preference_command(app: &mut CadApp, id: &str, params: &Value) -> Option> { let r = match id { - "ui.language" => { - let Some(preference) = params.get("lang").and_then(Value::as_str).and_then(crate::i18n::Preference::parse) else { - return Some(Err(format!("language must be {}", crate::i18n::Preference::codes()))); - }; - app.ui.interface_language = preference; - let shown = app.language(); - if shown != preference.resolve(&app.system_languages) { - app.set_status(if preference.resolve(&app.system_languages) == "ko" { - "No font covers the Korean interface, so it stays in English. Install a Hangul font (Malgun Gothic or Nanum Gothic), or build with a Hang/Kore craft-fonts face." - } else { - "No Chinese font is installed, so the interface stays in English. Install one (Noto Sans CJK, for example) to use Chinese." - }); - } - Ok(json!({"interfaceLanguage": preference.code(), "shown": shown})) + "ui.theme.system" | "ui.theme.light" | "ui.theme.dark" => { + let pref = crate::theme::ThemePref::parse(id.trim_start_matches("ui.theme.")).unwrap_or_default(); + set_theme(app, pref) } + // `{"theme": "system"|"light"|"dark"}` sets the choice; without it, reports it. + "ui.theme" => match params.get("theme").and_then(Value::as_str) { + Some(name) => match crate::theme::ThemePref::parse(name) { + Some(pref) => set_theme(app, pref), + None => Err(format!("unknown theme \"{name}\" (system, light or dark)")), + }, + None => Ok(theme_json(app)), + }, + "ui.animations.system" | "ui.animations.on" | "ui.animations.off" => { + let pref = crate::animation::AnimationPref::parse(id.trim_start_matches("ui.animations.")).unwrap_or_default(); + Ok(set_animations(app, pref)) + } + // `{"animations": "system"|"on"|"off"}` sets the choice; without it, reports it. + "ui.animations" => match params.get("animations").and_then(Value::as_str) { + Some(name) => match crate::animation::AnimationPref::parse(name) { + Some(pref) => Ok(set_animations(app, pref)), + None => Err(format!("unknown animations choice \"{}\" (system, on or off)", name.chars().take(40).collect::())), + }, + None => Ok(animations_json(app)), + }, + "ui.saveformat.dxf" | "ui.saveformat.dwg" => { + let format = crate::SaveFormat::parse(id.trim_start_matches("ui.saveformat.")).unwrap_or_default(); + Ok(set_save_format(app, format)) + } + // `{"format": "dxf"|"dwg"}` sets the default save format for new drawings; without it, + // reports it. + "ui.saveformat" => match params.get("format").and_then(Value::as_str) { + Some(name) => match crate::SaveFormat::parse(name) { + Some(format) => Ok(set_save_format(app, format)), + None => Err(format!("unknown save format \"{name}\" (dxf or dwg)")), + }, + None => Ok(json!({ "saveFormat": app.ui.save_format.as_str() })), + }, + // `{"version": "2000"…"2018"}` sets the version new drawings are saved in; without it, + // reports it. + id if id.starts_with("ui.saveversion") => { + let name = id + .strip_prefix("ui.saveversion.") + .map(str::to_string) + .or_else(|| params.get("version").map(|v| v.as_str().map_or_else(|| v.to_string(), str::to_string))); + match name { + Some(name) => match crate::SaveVersion::parse(&name) { + Some(v) => { + app.ui.save_version = v.year().to_string(); + app.session.echo(format!("New drawings will be saved as version {v}")); + Ok(json!({ "saveVersion": app.ui.save_version })) + } + None => Err(format!("unknown version \"{}\" (2000, 2004, 2007, 2010, 2013 or 2018)", name.chars().take(40).collect::())), + }, + None => Ok(json!({ "saveVersion": app.ui.save_version })), + } + } + _ => return None, + }; + Some(r) +} + +fn run_ui_toggle_command(app: &mut CadApp, id: &str, params: &Value) -> Option> { + let toggle = |b: &mut bool, p: &Value| { + *b = p.get("on").and_then(Value::as_bool).unwrap_or(!*b); + }; + let result = match id { + "ui.toggle.toolsets" => { + if params.get("on").and_then(Value::as_bool) == Some(true) { + return Some(crate::docking::command(app, false, &json!({"operation":"open", "panel":"toolSets"}))); + } + toggle(&mut app.ui.show_toolsets, params); + Ok(Value::Null) + } + "ui.toggle.palettes" => { + toggle(&mut app.ui.show_palettes, params); + Ok(Value::Null) + } + "ui.toggle.toolbar" => { + toggle(&mut app.ui.show_toolbar, params); + Ok(Value::Null) + } + "ui.toggle.filetabs" => { + toggle(&mut app.ui.show_file_tabs, params); + Ok(Value::Null) + } + "ui.toggle.statusbar" => { + toggle(&mut app.ui.show_status_bar, params); + Ok(Value::Null) + } + "ui.toggle.cmdline" => { + toggle(&mut app.ui.show_command_line, params); + Ok(Value::Null) + } + "ui.toggle.systemcursor" => { + toggle(&mut app.ui.system_cursor, params); + Ok(Value::Null) + } + "ui.toggle.viewcube" => { + toggle(&mut app.ui.show_viewcube, params); + Ok(Value::Null) + } + "ui.toggle.ucsicon" => { + toggle(&mut app.ui.show_ucs_icon, params); + Ok(Value::Null) + } + "ui.toggle.menubar" => { + toggle(&mut app.ui.in_window_menu, params); + Ok(Value::Null) + } + "ui.toggle.history" | "textscr" => { + let open = json!({"on": true}); + toggle(&mut app.cmd.expanded, if id == "textscr" { &open } else { params }); + Ok(json!({ "on": app.cmd.expanded })) + } + _ => return None, + }; + Some(result) +} + +fn run_language_command(app: &mut CadApp, id: &str, params: &Value) -> Option> { + if id != "ui.language" { + return None; + } + let Some(preference) = params.get("lang").and_then(Value::as_str).and_then(crate::i18n::Preference::parse) else { + return Some(Err(format!("language must be {}", crate::i18n::Preference::codes()))); + }; + app.ui.interface_language = preference; + let shown = app.language(); + if shown != preference.resolve(&app.system_languages) { + app.set_status(if preference.resolve(&app.system_languages) == "ko" { + "No font covers the Korean interface, so it stays in English. Install a Hangul font (Malgun Gothic or Nanum Gothic), or build with a Hang/Kore craft-fonts face." + } else { + "No Chinese font is installed, so the interface stays in English. Install one (Noto Sans CJK, for example) to use Chinese." + }); + } + Some(Ok(json!({"interfaceLanguage": preference.code(), "shown": shown}))) +} + +fn run_close_command(app: &mut CadApp, id: &str, params: &Value) -> Option> { + match id { + "close" if params.is_null() => { + app.request_close(None); + Some(Ok(Value::Null)) + } + "closeall" if params.is_null() => { + app.request_close_all(); + Some(Ok(Value::Null)) + } + _ => None, + } +} + +fn should_pick_file_path(id: &str, params: &Value) -> bool { + if id.starts_with("ui.") { params.is_null() || (params.get("path").is_none() && params.get("data").is_none()) } else { params.is_null() } +} + +fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option> { + if let Some(result) = route_ui_subsystems(app, id, params) { + return Some(result); + } + // When a file command should ask for a file. The `ui.*` commands are the pickers; the engine's + // OPEN/SAVEAS/QSAVE ask only when typed or chosen from a menu (no parameters), so JSON calls + // never open a picker. + let no_path = should_pick_file_path(id, params); + if let Some(result) = run_recent_file_command(app, id) { + return Some(result); + } + if let Some(result) = run_preference_command(app, id, params) { + return Some(result); + } + if let Some(result) = run_ui_toggle_command(app, id, params) { + return Some(result); + } + if let Some(result) = run_language_command(app, id, params) { + return Some(result); + } + if let Some(result) = run_close_command(app, id, params) { + return Some(result); + } + let r = match id { "ui.open" | "open" if no_path => { let picked = app.services.pick_open.as_ref().and_then(|f| f()); if let Some(p) = picked { - app.open_path(&p); + app.open_path(std::path::Path::new(&p)); } Ok(Value::Null) } @@ -228,109 +393,9 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option { - if params.get("on").and_then(Value::as_bool) == Some(true) { - return Some(crate::docking::command(app, false, &json!({"operation":"open", "panel":"toolSets"}))); - } - toggle(&mut app.ui.show_toolsets, params); - Ok(Value::Null) - } - "ui.toggle.palettes" => { - toggle(&mut app.ui.show_palettes, params); - Ok(Value::Null) - } - "ui.toggle.toolbar" => { - toggle(&mut app.ui.show_toolbar, params); - Ok(Value::Null) - } - "ui.toggle.filetabs" => { - toggle(&mut app.ui.show_file_tabs, params); - Ok(Value::Null) - } - // Typed or chosen from a menu or the tool bar: ask for the file (or show the preview). "export" | "exp" | "import" | "imp" | "publish" | "preview" | "pre" if params.is_null() && app.session.state().is_ok() => { return Some(crate::exchange::route(app, id)); } - "ui.toggle.statusbar" => { - toggle(&mut app.ui.show_status_bar, params); - Ok(Value::Null) - } - "ui.toggle.cmdline" => { - toggle(&mut app.ui.show_command_line, params); - Ok(Value::Null) - } - "ui.toggle.systemcursor" => { - toggle(&mut app.ui.system_cursor, params); - Ok(Value::Null) - } - "ui.toggle.viewcube" => { - toggle(&mut app.ui.show_viewcube, params); - Ok(Value::Null) - } - "ui.toggle.ucsicon" => { - toggle(&mut app.ui.show_ucs_icon, params); - Ok(Value::Null) - } - "ui.toggle.menubar" => { - toggle(&mut app.ui.in_window_menu, params); - Ok(Value::Null) - } - "ui.theme.system" | "ui.theme.light" | "ui.theme.dark" => { - let pref = crate::theme::ThemePref::parse(id.trim_start_matches("ui.theme.")).unwrap_or_default(); - set_theme(app, pref) - } - // `{"theme": "system"|"light"|"dark"}` sets the choice; without it, reports it. - "ui.theme" => match params.get("theme").and_then(Value::as_str) { - Some(name) => match crate::theme::ThemePref::parse(name) { - Some(pref) => set_theme(app, pref), - None => Err(format!("unknown theme \"{name}\" (system, light or dark)")), - }, - None => Ok(theme_json(app)), - }, - "ui.animations.system" | "ui.animations.on" | "ui.animations.off" => { - let pref = crate::animation::AnimationPref::parse(id.trim_start_matches("ui.animations.")).unwrap_or_default(); - Ok(set_animations(app, pref)) - } - // `{"animations": "system"|"on"|"off"}` sets the choice; without it, reports it. - "ui.animations" => match params.get("animations").and_then(Value::as_str) { - Some(name) => match crate::animation::AnimationPref::parse(name) { - Some(pref) => Ok(set_animations(app, pref)), - None => Err(format!("unknown animations choice \"{}\" (system, on or off)", name.chars().take(40).collect::())), - }, - None => Ok(animations_json(app)), - }, - "ui.saveformat.dxf" | "ui.saveformat.dwg" => { - let format = crate::SaveFormat::parse(id.trim_start_matches("ui.saveformat.")).unwrap_or_default(); - Ok(set_save_format(app, format)) - } - // `{"format": "dxf"|"dwg"}` sets the default save format for new drawings; without it, - // reports it. - "ui.saveformat" => match params.get("format").and_then(Value::as_str) { - Some(name) => match crate::SaveFormat::parse(name) { - Some(format) => Ok(set_save_format(app, format)), - None => Err(format!("unknown save format \"{name}\" (dxf or dwg)")), - }, - None => Ok(json!({ "saveFormat": app.ui.save_format.as_str() })), - }, - // `{"version": "2000"…"2018"}` sets the version new drawings are saved in; without it, - // reports it. - id if id.starts_with("ui.saveversion") => { - let name = id - .strip_prefix("ui.saveversion.") - .map(str::to_string) - .or_else(|| params.get("version").map(|v| v.as_str().map_or_else(|| v.to_string(), str::to_string))); - match name { - Some(name) => match crate::SaveVersion::parse(&name) { - Some(v) => { - app.ui.save_version = v.year().to_string(); - app.session.echo(format!("New drawings will be saved as version {v}")); - Ok(json!({ "saveVersion": app.ui.save_version })) - } - None => Err(format!("unknown version \"{}\" (2000, 2004, 2007, 2010, 2013 or 2018)", name.chars().take(40).collect::())), - }, - None => Ok(json!({ "saveVersion": app.ui.save_version })), - } - } "ui.hidepalettes" => { app.ui.show_palettes = false; app.ui.show_toolsets = false; @@ -339,7 +404,17 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option { let (menu, theme, interface_language, save_format) = (app.ui.in_window_menu, app.ui.theme, app.ui.interface_language, app.ui.save_format); let (animations, save_version) = (app.ui.animations, std::mem::take(&mut app.ui.save_version)); - app.ui = crate::UiState { in_window_menu: menu, theme, animations, interface_language, save_format, save_version, ..Default::default() }; + let system_cursor = app.system_cursor_default; + app.ui = crate::UiState { + in_window_menu: menu, + theme, + animations, + interface_language, + save_format, + save_version, + system_cursor, + ..Default::default() + }; Ok(Value::Null) } "ui.start" => { @@ -347,12 +422,6 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option { - let open = json!({"on": true}); - toggle(&mut app.cmd.expanded, if id == "textscr" { &open } else { params }); - Ok(json!({ "on": app.cmd.expanded })) - } - // `{"lines": n}`: how many history lines show above the command line (0–12); without it, reports it. "ui.cmdline.lines" => { if let Some(n) = params.get("lines").and_then(Value::as_u64) { app.ui.history_lines = n.min(crate::cmdline::MAX_LINES as u64) as usize; @@ -389,14 +458,6 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option Ok(Value::Null), // From a menu or typed, closing asks about unsaved changes; JSON calls close without asking. - "close" if params.is_null() => { - app.request_close(None); - Ok(Value::Null) - } - "closeall" if params.is_null() => { - app.request_close_all(); - Ok(Value::Null) - } "layer" | "la" | "layers" if params.is_null() => { app.ui.dialog = Some("layers".into()); Ok(Value::Null) diff --git a/crates/ui-egui/src/opening.rs b/crates/ui-egui/src/opening.rs index b0b2f8781..d6ae999c8 100644 --- a/crates/ui-egui/src/opening.rs +++ b/crates/ui-egui/src/opening.rs @@ -3,6 +3,7 @@ //! a spinner and the elapsed time and keeps painting. The finished drawing is added to the session //! on the UI thread. The web build has no threads and opens synchronously. +use std::path::{Path, PathBuf}; use std::sync::mpsc::{Receiver, TryRecvError, channel}; use std::time::{Duration, Instant}; @@ -13,7 +14,7 @@ use crate::theme::Tokens; type Outcome = Result; struct Job { - path: String, + path: PathBuf, started: Instant, rx: Receiver, } @@ -26,20 +27,20 @@ pub struct Opening { impl Opening { /// Start reading `path` on a worker thread. - pub fn start(&mut self, path: &str) { + pub fn start(&mut self, path: &Path) { let (tx, rx) = channel(); - let p = path.to_string(); + let p = path.to_path_buf(); let spawned = std::thread::Builder::new().name("cadcraft-open".into()).spawn(move || { let _ = tx.send(read_file(&p)); }); if spawned.is_err() { // No thread to read on: report it like any other failed open. let (tx, rx2) = channel(); - let _ = tx.send(Err(format!("open: {path}: could not start a reader thread"))); - self.jobs.push(Job { path: path.to_string(), started: Instant::now(), rx: rx2 }); + let _ = tx.send(Err(format!("open: {}: could not start a reader thread", path.display()))); + self.jobs.push(Job { path: path.to_path_buf(), started: Instant::now(), rx: rx2 }); return; } - self.jobs.push(Job { path: path.to_string(), started: Instant::now(), rx }); + self.jobs.push(Job { path: path.to_path_buf(), started: Instant::now(), rx }); } /// Whether any file is still being read. @@ -48,7 +49,7 @@ impl Opening { } /// The finished reads, as (path, result). A reader that died without answering is an error. - pub fn poll(&mut self) -> Vec<(String, Outcome)> { + pub fn poll(&mut self) -> Vec<(PathBuf, Outcome)> { let mut done = Vec::new(); self.jobs.retain(|j| match j.rx.try_recv() { Ok(r) => { @@ -57,7 +58,7 @@ impl Opening { } Err(TryRecvError::Empty) => true, Err(TryRecvError::Disconnected) => { - done.push((j.path.clone(), Err(format!("open: {}: the file could not be read", j.path)))); + done.push((j.path.clone(), Err(format!("open: {}: the file could not be read", j.path.display())))); false } }); @@ -67,7 +68,7 @@ impl Opening { /// The text of the card: the file and how long it has taken, or how many files are queued. fn label(&self) -> Option { let first = self.jobs.first()?; - let name = std::path::Path::new(&first.path).file_name().map_or_else(|| first.path.clone(), |n| n.to_string_lossy().to_string()); + let name = first.path.file_name().unwrap_or(first.path.as_os_str()).to_string_lossy(); let secs = first.started.elapsed().as_secs_f32(); let more = self.jobs.len() - 1; Some(if more == 0 { format!("Opening {name}... {secs:.0} s") } else { format!("Opening {name} and {more} more... {secs:.0} s") }) @@ -100,6 +101,7 @@ impl Opening { #[cfg(test)] mod tests { + use std::path::Path; use std::time::{Duration, Instant}; use cadcraft_engine::Session; @@ -114,7 +116,7 @@ mod tests { let before = app.session.docs.len(); let missing = std::env::temp_dir().join(format!("cadcraft-missing-{}.dxf", std::process::id())); let p = missing.to_string_lossy().to_string(); - app.open_path(&p); + app.open_path(&missing); assert!(app.opening.busy() || app.status.is_some(), "the read starts in the background"); let t = Instant::now(); while app.opening.busy() && t.elapsed() < Duration::from_secs(10) { @@ -133,8 +135,8 @@ mod tests { fn card_text_names_the_file_and_counts_queued_ones() { let mut o = super::Opening::default(); assert!(o.label().is_none()); - o.start("/nonexistent/dir/a.dxf"); - o.start("/nonexistent/dir/b.dxf"); + o.start(Path::new("/nonexistent/dir/a.dxf")); + o.start(Path::new("/nonexistent/dir/b.dxf")); let l = o.label().unwrap_or_default(); assert!(l.starts_with("Opening a.dxf and 1 more"), "{l}"); } diff --git a/crates/ui-egui/src/options.rs b/crates/ui-egui/src/options.rs index c8b94c310..8bf147bcf 100644 --- a/crates/ui-egui/src/options.rs +++ b/crates/ui-egui/src/options.rs @@ -310,7 +310,7 @@ fn reset_ui(app: &mut CadApp) { app.ui.animations = d.animations; app.ui.save_format = d.save_format; app.ui.save_version = d.save_version; - app.ui.system_cursor = d.system_cursor; + app.ui.system_cursor = app.system_cursor_default; app.ui.history_lines = d.history_lines; app.options = UiOptions::default(); } @@ -353,7 +353,7 @@ impl CadApp { let _ = parse_ui(key, value, &mut c); } } - // CADCRAFT_SYSTEM_CURSOR=1 turns the system cursor on whatever was saved. + // A saved `false` leaves the host's default (`set_system_cursor_default`) in place. if c.system_cursor == Some(true) { self.ui.system_cursor = true; } diff --git a/crates/ui-egui/src/parametric.rs b/crates/ui-egui/src/parametric.rs index ade7a39fa..fb9edec5b 100644 --- a/crates/ui-egui/src/parametric.rs +++ b/crates/ui-egui/src/parametric.rs @@ -259,18 +259,20 @@ enum Act { } /// Draw constraint bars and dynamic constraints. `xf` maps model space to the screen. -pub fn draw_overlay(app: &mut CadApp, ui: &mut egui::Ui, painter: &egui::Painter, xf: &Xf) { - refresh(app); - let Ok(d) = app.session.doc() else { return }; - if d.constraints.is_empty() { - app.canvas.param.editing = None; - return; - } - let t = Tokens::get(); - let set = &d.parametric.settings; - let mut act: Option = None; - let glyphs = &app.canvas.param.glyphs; - let (lu, lp) = (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4)); +struct DimensionalContext<'a> { + doc: &'a Drawing, + settings: &'a cadcraft_doc::ParametricSettings, + glyphs: &'a [Glyph], + xf: &'a Xf, + painter: &'a egui::Painter, + ui: &'a mut egui::Ui, + tokens: Tokens, + units: (i64, i64), +} + +fn draw_dimensional_constraints(frame: DimensionalContext<'_>) -> Option { + let DimensionalContext { doc: d, settings: set, glyphs, xf, painter, ui, tokens: t, units: (lu, lp) } = frame; + let mut act = None; // ----- dynamic (dimensional) constraints ----- let dim_c = Color32::from_rgb(0x9f, 0xb6, 0xd6); let off_px: f32 = 26.0; @@ -403,6 +405,13 @@ pub fn draw_overlay(app: &mut CadApp, ui: &mut egui::Ui, painter: &egui::Painter expression = c.expr )); } + act +} + +fn draw_geometric_constraints(app: &CadApp, ui: &mut egui::Ui, painter: &egui::Painter, xf: &Xf, t: Tokens) { + let Ok(d) = app.session.doc() else { return }; + let set = &d.parametric.settings; + let glyphs = &app.canvas.param.glyphs; // ----- geometric constraint bars ----- let mut bars: Vec<(Handle, Vec2, Vec<(&str, u32)>)> = Vec::new(); let mut dots: Vec = Vec::new(); @@ -488,6 +497,21 @@ pub fn draw_overlay(app: &mut CadApp, ui: &mut egui::Ui, painter: &egui::Painter painter.rect_filled(r, 2.0, t.canvas.gamma_multiply(0.85)); painter.galley(at + vec2(4.0, 2.0), galley, col); } +} + +pub fn draw_overlay(app: &mut CadApp, ui: &mut egui::Ui, painter: &egui::Painter, xf: &Xf) { + refresh(app); + let Ok(d) = app.session.doc() else { return }; + if d.constraints.is_empty() { + app.canvas.param.editing = None; + return; + } + let t = Tokens::get(); + let set = &d.parametric.settings; + let glyphs = &app.canvas.param.glyphs; + let (lu, lp) = (d.header.i64("LUNITS", 2), d.header.i64("LUPREC", 4)); + let act = draw_dimensional_constraints(DimensionalContext { doc: d, settings: set, glyphs, xf, painter, ui, tokens: t, units: (lu, lp) }); + draw_geometric_constraints(app, ui, painter, xf, t); let _ = act_take(app, act, ui); } diff --git a/crates/ui-egui/src/switch.rs b/crates/ui-egui/src/switch.rs new file mode 100644 index 000000000..0095a14e5 --- /dev/null +++ b/crates/ui-egui/src/switch.rs @@ -0,0 +1,54 @@ +//! Boolean environment switches (`CADCRAFT_VSYNC`, `CADCRAFT_WAYLAND`, ...): one parser, so every +//! variable accepts the same spellings. + +/// `1/on/true/yes` or `0/off/false/no`, case- and space-insensitive. Blank or unset is `Default`; +/// anything else is `Default` and logged. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Switch { + On, + Off, + Default, +} + +impl Switch { + /// Parse the value of the variable `name`; `name` only appears in the warning. + pub fn parse(name: &str, value: Option<&str>) -> Switch { + let Some(value) = value else { return Switch::Default }; + match value.trim().to_ascii_lowercase().as_str() { + "1" | "on" | "true" | "yes" => Switch::On, + "0" | "off" | "false" | "no" => Switch::Off, + "" => Switch::Default, + _ => { + log::warn!("{name}={value:?} is not 1/on/true/yes or 0/off/false/no; using the default"); + Switch::Default + } + } + } + + /// Whether the switch is on, with `default` for `Default`. + pub fn or(self, default: bool) -> bool { + match self { + Switch::On => true, + Switch::Off => false, + Switch::Default => default, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_every_spelling() { + for v in ["1", "on", "true", "yes", "ON", "True", " Yes ", "\t1\n"] { + assert_eq!(Switch::parse("X", Some(v)), Switch::On, "{v:?}"); + } + for v in ["0", "off", "false", "no", "OFF", "False", " No ", " 0 "] { + assert_eq!(Switch::parse("X", Some(v)), Switch::Off, "{v:?}"); + } + for v in [None, Some(""), Some(" "), Some("maybe"), Some("2"), Some("onn")] { + assert_eq!(Switch::parse("X", v), Switch::Default, "{v:?}"); + } + } +} diff --git a/crates/ui-egui/tests/bedit_dialog.rs b/crates/ui-egui/tests/bedit_dialog.rs index 85367e407..95fdb4adc 100644 --- a/crates/ui-egui/tests/bedit_dialog.rs +++ b/crates/ui-egui/tests/bedit_dialog.rs @@ -133,7 +133,7 @@ fn opening_a_drawing_with_authoring_elements_offers_the_block_editor() { let symbol = dir.join("Symbol.dxf"); std::fs::write(&symbol, "authoring").unwrap(); let mut app = CadApp::new(Session::new(), Services::default()); - app.open_path(&symbol.to_string_lossy()); + app.open_path(&symbol); // The file is read in the background (#797): wait for it to be added. let t = std::time::Instant::now(); while app.opening.busy() && t.elapsed() < std::time::Duration::from_secs(10) { @@ -163,7 +163,7 @@ fn opening_a_drawing_with_authoring_elements_offers_the_block_editor() { let plain = dir.join("Plain.dxf"); std::fs::write(&plain, "plain").unwrap(); let mut app = CadApp::new(Session::new(), Services::default()); - app.open_path(&plain.to_string_lossy()); + app.open_path(&plain); // The file is read in the background (#797): wait for it to be added. let t = std::time::Instant::now(); while app.opening.busy() && t.elapsed() < std::time::Duration::from_secs(10) { diff --git a/crates/ui-egui/tests/it/system_cursor.rs b/crates/ui-egui/tests/it/system_cursor.rs index ff2c8942f..e2067e519 100644 --- a/crates/ui-egui/tests/it/system_cursor.rs +++ b/crates/ui-egui/tests/it/system_cursor.rs @@ -35,3 +35,23 @@ fn system_cursor_stays_visible_over_the_canvas_when_requested() { assert!(app.ui.system_cursor); assert_eq!(canvas_cursor(&mut app), egui::CursorIcon::Crosshair, "systemCursor keeps an OS cursor for magnifiers"); } + +/// The host's default (the desktop app's `CADCRAFT_SYSTEM_CURSOR`) turns it on; a saved `false` +/// and the resets keep it. +#[test] +fn the_host_default_survives_saved_profiles_and_resets() { + let mut app = CadApp::new(Session::new(), Services::default()); + app.run("options", serde_json::json!({ "reset": true })).unwrap(); + assert!(!app.ui.system_cursor, "off without a host default"); + + app.set_system_cursor_default(true); + assert!(app.ui.system_cursor); + app.load_profile(r#"{"systemCursor": false}"#); + assert!(app.ui.system_cursor); + app.ui.system_cursor = false; + app.run("options", serde_json::json!({ "reset": true })).unwrap(); + assert!(app.ui.system_cursor); + app.ui.system_cursor = false; + app.run("ui.resetpalettes", serde_json::json!({})).unwrap(); + assert!(app.ui.system_cursor); +} diff --git a/crates/ui-egui/tests/recent_files.rs b/crates/ui-egui/tests/recent_files.rs index 6211ab899..946a6792a 100644 --- a/crates/ui-egui/tests/recent_files.rs +++ b/crates/ui-egui/tests/recent_files.rs @@ -53,15 +53,15 @@ fn opened_drawings_are_listed_newest_first_and_survive_a_restart() { let mut app = CadApp::new(Session::empty(), Services::default()); assert!(app.ui.recent_files.is_empty()); - app.open_path(&plan); + app.open_path(std::path::Path::new(&plan)); settle(&mut app); - app.open_path(§ion); + app.open_path(std::path::Path::new(§ion)); settle(&mut app); - app.open_path(&plan); + app.open_path(std::path::Path::new(&plan)); settle(&mut app); assert_eq!(app.ui.recent_files, [plan.clone(), section.clone()], "newest first, each file once"); // A file that could not be opened is not listed. - app.open_path("/nonexistent/missing.dxf"); + app.open_path(std::path::Path::new("/nonexistent/missing.dxf")); settle(&mut app); assert_eq!(app.ui.recent_files, [plan.clone(), section.clone()]); diff --git a/docs/cli.md b/docs/cli.md new file mode 100644 index 000000000..ba68a1d09 --- /dev/null +++ b/docs/cli.md @@ -0,0 +1,58 @@ +# cadcraft-cli + +`cadcraft-cli` is headless CADCraft: it reads, converts and exports drawings, runs scripts and +commands, prints the command catalog and serves MCP. It follows +[RFC-0012: Command-line conventions](https://github.com/storytold/craft-contrib/pull/18). + +`cadcraft-cli --help` and `cadcraft-cli help ` (or ` --help`) are the +reference for every subcommand, flag and value; this page doesn't repeat them. Examples are in the +[README](../README.md#drive-it-from-agents-mcp-and-the-cli), MCP setup in [mcp.md](mcp.md), +scripts and the JSON command forms in [customization.md](customization.md). + +## Conventions + +| | | +|---|---| +| Exit codes | `0` success, `1` the command failed, `2` usage error. | +| Streams | Results on stdout. `info` and `commands` print pretty JSON, or one line with `--compact`; `run` prints one JSON line per `--cmd` result (JSON lines); a command with no result (JSON `null`) prints no line. Errors (`error: …`), warnings and `wrote …` lines on stderr. `mcp` speaks MCP on stdout and writes nothing else there. | +| Usage errors | An unknown or repeated flag, a missing or malformed value (`--window`, `--view`, `--cmd` JSON, a sample name), flags that conflict (`--window` with `--view`) or that need another (`run --window` without `--export`) stop before any work, with exit 2. `--script`, `--script-file`, `--cmd` and `run`'s files repeat and run in command-line order. | +| Outputs that replace an input | `convert IN OUT` and `run FILE… --save OUT` / `--export OUT` refuse an OUT that is the same file as an input (any spelling or symlink of it): usage error, exit 2, nothing opened or written. `--in-place` allows it. A save a script or `--cmd` runs is the engine's. | +| Values starting with `-` | Written with `=`: `--window=-10,-10,10,10`, `--export=-plan.png`. | +| Paths | Read as given, including names that aren't valid Unicode. The engine opens files by text name, so such a name is reported as an error (exit 1) where a drawing is opened; an output takes any name whose extension is ASCII. | +| Completions and man pages | The Linux packages install them. To generate them yourself: `cargo run -p cadcraft-cli --example man-and-completions -- `. | + +## Environment variables + +Variables are fallbacks for flags; `--help` shows each next to its flag. An empty value counts as +unset and the flag wins over the variable, except for `CADCRAFT_CONFIG_DIR` (see below). + +| Variable | Flag | Subcommands | +|---|---|---| +| `CADCRAFT_CONFIG_DIR` | `--config-dir` (the settings folder; plotter configurations are in its `plotters` folder; empty means no settings folder) | `convert`, `run`, `mcp`, `sample` | +| `CADCRAFT_FONTALT` | `--fontalt` (FONTALT) | `convert`, `run`, `mcp`, `sample` | +| `CADCRAFT_FONTFALLBACK` | `--fontfallback` (FONTFALLBACK) | `convert`, `run`, `mcp`, `sample` | + +The desktop app's are listed by `cadcraft --help`; its one flag fallback is +`CADCRAFT_CONTROL_PORT` for `--control`, where a bad value is a usage error that names the +variable. + +## Not followed yet + +- **`CADCRAFT_CONFIG_DIR` is the one flag fallback where an empty variable doesn't count as + unset** (RFC-0012 rule 1.7): empty (or `--config-dir ""`) means no settings folder, as it did + before the port. +- **No variable for `mcp --connect`.** Photocraft's `mcp --bridge` falls back to its + `*_CONTROL_PORT` variable. Here an exported `CADCRAFT_CONTROL_PORT` would silently switch `mcp` + from a headless session to the running app, so `--connect` stays a flag only. +- **The desktop app on Windows** is built without a console, so a usage error in its launch flags + isn't visible there; the app exits with code 2. +- **The `string-error` ast-grep rule** covers the CLI code only. The engine's file hooks + (`cadcraft_engine::cmd::file::IoHooks`) still return `Result<_, String>`, so `install_io` maps + errors to strings at that boundary. +- **No AGENTS.md line for the ast-grep scan.** RFC-0012 asks an app's AGENTS.md to have coding + agents run the scan before pushing (`ast-grep scan -c lint/ast-grep/sgconfig.yml`); CI runs it + on every PR that touches the CLI code. +- **`perf` prints a text table**, with no `--json` (whether text listings get one is an open + question in RFC-0012). +- **Saves a command or script runs** (`--cmd 'saveas {…}'`, a script's `SAVEAS`) are the engine's + and are not checked against the opened drawings; only `--save` and `--export` are. diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 1c3f30626..98db28330 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -124,7 +124,7 @@ height and related chrome choices. It does not store drawings, command buffers, current Start tab. The default directory is `~/Library/Application Support/CADCraft` on macOS, `%APPDATA%/CADCraft` on Windows, and `$XDG_CONFIG_HOME/cadcraft` or `~/.config/cadcraft` elsewhere. Set `CADCRAFT_CONFIG_DIR` to a private directory for an isolated profile; an explicitly empty -value disables workspace reads and writes. An invalid, oversized or newer-version file is +value disables all settings reads and writes (workspace, logs, autosave, plotters). An invalid, oversized or newer-version file is reported and left untouched, with persistence disabled for that launch. Repair or move that file before restarting to resume saving workspace choices. diff --git a/docs/plotters.md b/docs/plotters.md index 7ca7c785d..92e10afce 100644 --- a/docs/plotters.md +++ b/docs/plotters.md @@ -32,7 +32,8 @@ settings directory: | macOS | `~/Library/Application Support/CADCraft/plotters` | | Windows | `%APPDATA%\CADCraft\plotters` | -`CADCRAFT_CONFIG_DIR` replaces the settings directory. On the web, devices last for the +`CADCRAFT_CONFIG_DIR` replaces the settings directory; empty means none (`cadcraft-cli`: +`--config-dir`, which falls back to the same variable). On the web, devices last for the session unless the host provides storage (`cmd::plotters::set_plotter_store`). Binary `.pc3` files are not read; we haven't found a public specification of that format. diff --git a/lint/ast-grep/rule-tests/args-os-test.yml b/lint/ast-grep/rule-tests/args-os-test.yml new file mode 100644 index 000000000..03ff2c4da --- /dev/null +++ b/lint/ast-grep/rule-tests/args-os-test.yml @@ -0,0 +1,19 @@ +id: args-os +valid: + - let code = photocraft_cli::run(std::env::args_os().skip(1), &mut out, &mut err); + - "let args: Vec = env::args_os().collect();" + - | + use std::env::args_os; + fn main() { let a: Vec<_> = args_os().collect(); } + - | + fn args() -> Vec { Vec::new() } + fn main() { let a = args(); } +invalid: + - "let args: Vec = std::env::args().collect();" + - for a in env::args().skip(1) {} + - | + use std::env::args; + fn main() { let a: Vec = args().collect(); } + - | + use std::env::{args, var}; + fn main() { for a in args() {} } diff --git a/lint/ast-grep/rule-tests/clap-error-message-test.yml b/lint/ast-grep/rule-tests/clap-error-message-test.yml new file mode 100644 index 000000000..385d46e96 --- /dev/null +++ b/lint/ast-grep/rule-tests/clap-error-message-test.yml @@ -0,0 +1,13 @@ +id: clap-error-message +valid: + - cmd.error(ErrorKind::ArgumentConflict, UsageError::BridgeRoots) + - cmd.error(ErrorKind::ArgumentConflict, Conflict { a, b }) + - sub.error(kind, self) + - log.error("not a clap error") +invalid: + - cmd.error(ErrorKind::ArgumentConflict, "configure automation roots on the desktop app") + - sub.error(ErrorKind::MissingRequiredArgument, format!("{flag} requires {transport}")) + - sub.error(ErrorKind::ArgumentConflict, BRIDGE_ROOTS) + - cmd.error(ErrorKind::InvalidValue, e.to_string()) + - cmd.error(ErrorKind::InvalidValue, String::from("bad value")) + - clap::Error::raw(ErrorKind::InvalidValue, "bad value") diff --git a/lint/ast-grep/rule-tests/clap-error-message-variable-test.yml b/lint/ast-grep/rule-tests/clap-error-message-variable-test.yml new file mode 100644 index 000000000..18d6e443a --- /dev/null +++ b/lint/ast-grep/rule-tests/clap-error-message-variable-test.yml @@ -0,0 +1,47 @@ +id: clap-error-message-variable +valid: + - | + fn conflict(cmd: &mut Command, a: String, b: String) -> clap::Error { + cmd.error(ErrorKind::ArgumentConflict, Conflict { a, b }) + } + - | + fn wrap(cmd: &mut Command, e: UsageError) -> clap::Error { + cmd.error(ErrorKind::ValueValidation, e) + } + - | + fn unrelated(cmd: &mut Command, e: UsageError) -> clap::Error { + let shown = format!("{e}"); + eprintln!("{shown}"); + cmd.error(ErrorKind::ValueValidation, e) + } + - | + fn cloned(cmd: &mut Command, e: &UsageError) -> clap::Error { + let owned = e.to_owned(); + cmd.error(ErrorKind::ValueValidation, owned) + } +invalid: + - | + fn conflict(cmd: &mut Command, a: &str, b: &str) -> clap::Error { + let message = format!("the argument '{a}' cannot be used with '{b}'"); + cmd.error(ErrorKind::ArgumentConflict, message) + } + - | + fn bad(cmd: &mut Command, e: UsageError) -> clap::Error { + let message = e.to_string(); + cmd.error(ErrorKind::ValueValidation, message) + } + - | + fn typed(cmd: &mut Command, flag: &str) -> clap::Error { + let message: String = flag.into(); + clap::Error::raw(ErrorKind::InvalidValue, message) + } + - | + fn literal(cmd: &mut Command) -> clap::Error { + let message = "bad value".to_owned(); + cmd.error(ErrorKind::InvalidValue, message) + } + - | + fn from(cmd: &mut Command) -> clap::Error { + let message = String::from("bad value"); + cmd.error(ErrorKind::InvalidValue, message) + } diff --git a/lint/ast-grep/rule-tests/string-error-test.yml b/lint/ast-grep/rule-tests/string-error-test.yml new file mode 100644 index 000000000..4f14197c8 --- /dev/null +++ b/lint/ast-grep/rule-tests/string-error-test.yml @@ -0,0 +1,14 @@ +id: string-error +valid: + - "fn parse(s: &str) -> Result { todo!() }" + - "fn name() -> Option { None }" + - "fn ok() -> Result { Ok(String::new()) }" + - Err(PortError::Range) + - Err(e) +invalid: + - "fn parse(s: &str) -> Result { todo!() }" + - "type R = Result<(), String>;" + - Err(format!("bad port {s}")) + - Err(e.to_string()) + - Err(String::from("bad port")) + - Err("bad port") diff --git a/lint/ast-grep/rules/args-os.yml b/lint/ast-grep/rules/args-os.yml new file mode 100644 index 000000000..ab1916c9e --- /dev/null +++ b/lint/ast-grep/rules/args-os.yml @@ -0,0 +1,21 @@ +id: args-os +language: rust +severity: error +message: std::env::args() panics on an argument that isn't valid Unicode +note: | + Read std::env::args_os() and let clap parse the OsStrings, so a Latin-1 file name reaches the + command (or is a usage error) instead of aborting before anything is printed (photocraft#1108). +rule: + any: + - pattern: std::env::args() + - pattern: env::args() + # A bare args() only where the file imports std::env::args, not any function named args. + - all: + - pattern: args() + - inside: + kind: source_file + stopBy: end + has: + kind: use_declaration + stopBy: end + regex: std::env::(args\b|\{[^}]*\bargs\b) diff --git a/lint/ast-grep/rules/clap-error-message-variable.yml b/lint/ast-grep/rules/clap-error-message-variable.yml new file mode 100644 index 000000000..3f476be4b --- /dev/null +++ b/lint/ast-grep/rules/clap-error-message-variable.yml @@ -0,0 +1,35 @@ +id: clap-error-message-variable +language: rust +severity: error +message: clap error built from a string held in a variable +note: | + The message was built with format!, .to_string(), String::from or a literal's .to_owned() a + few lines up. Give it a variant on a + #[derive(thiserror::Error)] enum instead, with the parts as fields, and pass the variant. +rule: + # In this order: the call binds $MSG, then the function must hold a `let` of that same name. + all: + - any: + - pattern: $CMD.error($KIND, $MSG) + - pattern: Error::raw($KIND, $MSG) + - pattern: clap::Error::raw($KIND, $MSG) + - inside: + kind: function_item + stopBy: end + has: + stopBy: end + any: + - pattern: let $MSG = format!($$$); + - pattern: "let $MSG: String = $VAL;" + - pattern: let $MSG = $SRC.to_string(); + - pattern: let $MSG = String::from($$$); + # .to_owned() only on a string literal: on anything else it may clone a typed error. + - all: + - kind: let_declaration + - regex: '=\s*"(?s:.*)"\s*\.to_owned\(\)\s*;?$' + - has: + field: pattern + pattern: $MSG +constraints: + MSG: + kind: identifier diff --git a/lint/ast-grep/rules/clap-error-message.yml b/lint/ast-grep/rules/clap-error-message.yml new file mode 100644 index 000000000..e18b824b3 --- /dev/null +++ b/lint/ast-grep/rules/clap-error-message.yml @@ -0,0 +1,26 @@ +id: clap-error-message +language: rust +severity: error +message: clap error built from a string +note: | + Give the message a variant on a #[derive(thiserror::Error)] enum and pass the variant, e.g. + `cmd.error(ErrorKind::ArgumentConflict, UsageError::BridgeRoots)`. A string literal, format!, + .to_string() or a SCREAMING_CASE const keeps the message apart from the error's type. +rule: + any: + - pattern: $CMD.error($KIND, $MSG) + - pattern: Error::raw($KIND, $MSG) + - pattern: clap::Error::raw($KIND, $MSG) +constraints: + MSG: + any: + - kind: string_literal + - all: + - kind: macro_invocation + - regex: ^format! + - all: + - kind: identifier + - regex: ^[A-Z][A-Z0-9_]*$ + - all: + - kind: call_expression + - regex: \.(to_string|to_owned)\(\)$|^String::from\( diff --git a/lint/ast-grep/rules/string-error.yml b/lint/ast-grep/rules/string-error.yml new file mode 100644 index 000000000..e79b83d05 --- /dev/null +++ b/lint/ast-grep/rules/string-error.yml @@ -0,0 +1,21 @@ +id: string-error +language: rust +severity: error +message: String as an error type +note: | + Return a #[derive(thiserror::Error)] enum, so a caller can match on what failed and the + messages live with their variants. +rule: + any: + - pattern: + context: type T = Result<$OK, String>; + selector: generic_type + - pattern: Err(format!($$$)) + - pattern: Err($S.to_string()) + - pattern: Err(String::from($$$)) + - all: + - pattern: Err($S) + - has: + kind: arguments + has: + kind: string_literal diff --git a/lint/ast-grep/sgconfig.yml b/lint/ast-grep/sgconfig.yml new file mode 100644 index 000000000..9c94bd0ae --- /dev/null +++ b/lint/ast-grep/sgconfig.yml @@ -0,0 +1,6 @@ +# Structural rules for the command-line code (RFC-0012), run by .github/workflows/ast-grep.yml. +# Each rule in rules/ has its cases in rule-tests/, which CI checks before the scan. +ruleDirs: + - rules +testConfigs: + - testDir: rule-tests diff --git a/packaging/linux/package.sh b/packaging/linux/package.sh index 7ad0c4016..f9146c86a 100755 --- a/packaging/linux/package.sh +++ b/packaging/linux/package.sh @@ -44,11 +44,16 @@ BASENAME="cadcraft-$VERSION-linux-$ARCH" echo "==> CADCraft $VERSION for Linux $ARCH ($FORMATS)" +# The man-and-completions example writes cadcraft-cli's man pages and shell completions below. It +# is built in its own cargo run: built with the binaries, its dev-dependencies' features would be +# unified into them. if [[ "$SKIP_BUILD" = 0 ]]; then if [[ -n "${CROSS_TARGET:-}" ]]; then (cd "$ROOT" && cargo build --release --locked -p cadcraft -p cadcraft-cli --target "$CROSS_TARGET") + (cd "$ROOT" && cargo build --release --locked -p cadcraft-cli --example man-and-completions --target "$CROSS_TARGET") else (cd "$ROOT" && cargo build --release --locked -p cadcraft -p cadcraft-cli) + (cd "$ROOT" && cargo build --release --locked -p cadcraft-cli --example man-and-completions) fi fi BIN="$CARGO_TARGET_DIR/${CROSS_TARGET:+$CROSS_TARGET/}release" @@ -69,6 +74,26 @@ mkdir -p "$STAGE/usr/share/icons" cp -R "$ROOT/assets/app-icon/hicolor" "$STAGE/usr/share/icons/" mkdir -p "$STAGE/usr/share/doc/cadcraft" copy_docs "$STAGE/usr/share/doc/cadcraft" +# cadcraft-cli's man pages and shell completions, from its clap definition, written by the +# example built above. A cross build runs it through $EMULATOR, like the --version check at the +# end, and leaves them out without one, as a --skip-build run whose prebuilt binaries came without +# the example does. zsh reads site-functions on Fedora and openSUSE. +CLI_DOCS="$BIN/examples/man-and-completions" +if [[ -n "${CROSS_TARGET:-}" ]] && [[ -z "${EMULATOR:-}" ]]; then + warn "no EMULATOR to run the $CROSS_TARGET build, so cadcraft-cli's man pages and completions are left out" +elif [[ ! -x "$CLI_DOCS" ]]; then + warn "$CLI_DOCS is not built, so cadcraft-cli's man pages and completions are left out" +else + if [[ -n "${CROSS_TARGET:-}" ]]; then + "$EMULATOR" "$CLI_DOCS" "$WORK/cli-docs" + else + "$CLI_DOCS" "$WORK/cli-docs" + fi + install -Dm644 -t "$STAGE/usr/share/man/man1" "$WORK"/cli-docs/*.1 + install -Dm644 "$WORK/cli-docs/cadcraft-cli.bash" "$STAGE/usr/share/bash-completion/completions/cadcraft-cli" + install -Dm644 "$WORK/cli-docs/_cadcraft-cli" "$STAGE/usr/share/zsh/site-functions/_cadcraft-cli" + install -Dm644 "$WORK/cli-docs/cadcraft-cli.fish" "$STAGE/usr/share/fish/vendor_completions.d/cadcraft-cli.fish" +fi if command -v desktop-file-validate >/dev/null; then desktop-file-validate "$STAGE/usr/share/applications/$APP_ID.desktop" diff --git a/packaging/windows/INSTALLATION.md b/packaging/windows/INSTALLATION.md new file mode 100644 index 000000000..982a5b420 --- /dev/null +++ b/packaging/windows/INSTALLATION.md @@ -0,0 +1,35 @@ +# Windows installation policy checks + +New installations default to the current account under `Programs\ArtCraft\`. +The first setup page offers installation for everyone. Scope is selected before duplicate +checks and directory costing. An update uses the existing context's remembered exact folder; +`INSTALLFOLDER` supplied explicitly is never replaced. It is a secure MSI property so the +chosen folder reaches the elevated installer. Silent machine updates pass `ALLUSERS=1`. +A cross-context copy is refused; changing context means uninstalling the old copy first. + +App registration follows the selected context. Existing optional shortcuts and file-handler +choices stay app-owned. No new cleanup operation or model/settings migration is introduced. +Packaged resources remain package-owned; separately downloaded shared models are not caches +and are outside this installer's ownership. + +## Repeatable metadata tests + +On Windows with WiX 5.0.2 and its matching UI/Util extensions: + +```powershell +./packaging/windows/test-install-policy.ps1 -OutputDirectory ./target/install-policy-tests +``` + +The script builds x64, x86 and arm64 packages with deliberately non-executable payloads. It +uses the actual package source and compiled database. A safe Windows Installer session checks +24 scope/registration/maintenance cases, remembered and explicit custom folders, sequencing, +upgrade identity and the original registration inventory recorded in `install-policy.json`. +The release packaging script runs the compiled checker before signing. Packaging CI runs the +small fixture builds without compiling the Rust application. + +Never install or distribute the `NOT-INSTALLABLE.msi` fixtures as an app. Passing these checks +does not prove real installation, elevation, legacy-version upgrades, registry writes, optional +shortcut/menu behaviour, cancellation, rollback or uninstall. Those still require the real +payload in an authorised clean Windows test environment. Cross-architecture metadata is not +execution evidence on those architectures. Existing open installer/association PRs must be +reconciled before publication. Nothing here changes macOS/Linux native packaging conventions. diff --git a/packaging/windows/cadcraft.wxs b/packaging/windows/cadcraft.wxs index d59cc41b3..152a67dc2 100644 --- a/packaging/windows/cadcraft.wxs +++ b/packaging/windows/cadcraft.wxs @@ -1,35 +1,14 @@ - - - + + + - + @@ -39,7 +18,9 @@ - + + + @@ -50,44 +31,42 @@ - - - + + - + - + - + + + - + - + - - - - - + + + + + + @@ -97,12 +76,9 @@ - - - + + + @@ -137,18 +113,14 @@ - - + + - - + + diff --git a/packaging/windows/check-install-policy.ps1 b/packaging/windows/check-install-policy.ps1 new file mode 100644 index 000000000..cc9416e9c --- /dev/null +++ b/packaging/windows/check-install-policy.ps1 @@ -0,0 +1,296 @@ +<# +.SYNOPSIS + Check the compiled installation policy without installing any product. +.DESCRIPTION + Uses Windows Installer's safe session (OpenPackage option 1). Only property-setting custom + actions are exercised. No AppSearch, install, repair, removal or file-writing action runs. +#> +param([Parameter(Mandatory = $true)] [string] $MsiPath) +$ErrorActionPreference = 'Stop' +Set-StrictMode -Version Latest +$policy = Get-Content -Raw -LiteralPath (Join-Path $PSScriptRoot 'install-policy.json') | ConvertFrom-Json +function Read-Rows($Database, [string] $Sql, [int] $Columns) { + $view = $Database.OpenView($Sql) + try { + [void]$view.Execute() + while ($null -ne ($record = $view.Fetch())) { + try { + $values = @(for ($i = 1; $i -le $Columns; $i++) { + $record.GetType().InvokeMember('StringData', 'GetProperty', $null, $record, @($i)) + }) + ,$values + } finally { [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($record) } + } + } finally { + [void]$view.Close() + [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($view) + } +} +function Set-SessionProperty($Session, [string] $Name, [string] $Value) { + [void]$Session.GetType().InvokeMember('Property', 'SetProperty', $null, $Session, @($Name, $Value)) +} +function Get-SessionProperty($Session, [string] $Name) { + $Session.GetType().InvokeMember('Property', 'GetProperty', $null, $Session, @($Name)) +} +function Get-PackageTemplate($Database) { + # Summary information property 7 is the platform: "Intel;1033", "x64;1033" or "Arm64;1033". + $summary = $Database.GetType().InvokeMember('SummaryInformation', 'GetProperty', $null, $Database, @(0)) + try { [string]$summary.GetType().InvokeMember('Property', 'GetProperty', $null, $summary, @(7)) } + finally { [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($summary) } +} +$installer = $null; $database = $null; $session = $null +try { + $installer = New-Object -ComObject WindowsInstaller.Installer + $file = (Resolve-Path -LiteralPath $MsiPath).Path + $database = $installer.OpenDatabase($file, 0) + $session = $installer.OpenPackage($file, 1) + $properties = @{} + foreach ($row in (Read-Rows $database 'SELECT `Property`, `Value` FROM `Property`' 2)) { $properties[$row[0]] = $row[1] } + $secureProperties = @($properties['SecureCustomProperties'] -split ';') + if ('INSTALLFOLDER' -notin $secureProperties) { + throw 'The selected installation folder must survive elevation (secure INSTALLFOLDER).' + } + if ($policy.mode -eq 'perUser') { + if ($properties.ContainsKey('ALLUSERS')) { throw 'Launcher must remain per-user; machine self-update is not part of this change.' } + if ($properties['UpgradeCode'].Trim('{}') -ne $policy.upgradeCode) { throw 'Launcher upgrade identity changed.' } + $dirs = @{} + foreach ($row in (Read-Rows $database 'SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`' 3)) { $dirs[$row[0]] = @($row[1],$row[2]) } + if ($dirs['INSTALLFOLDER'][0] -ne 'CraftSuiteFolder' -or $dirs['CraftSuiteFolder'][1] -ne 'ArtCraft' -or + $dirs['CraftSuiteFolder'][0] -ne 'LocalProgramsFolder' -or $dirs['LocalProgramsFolder'][0] -ne 'LocalAppDataFolder') { + throw 'Launcher new-install folder must be under the per-user ArtCraft suite root.' + } + foreach ($explicit in @('', 'F:\Chosen exact launcher')) { + Set-SessionProperty $session 'PREVIOUSINSTALLFOLDER' 'E:\Existing exact launcher' + Set-SessionProperty $session 'INSTALLFOLDER' $explicit + $row = @(Read-Rows $database 'SELECT `Condition` FROM `InstallUISequence` WHERE `Action` = ''CraftRestoreLauncherFolder''' 1)[0] + if ($session.EvaluateCondition($row[0]) -eq 1) { + if ($session.DoAction('CraftRestoreLauncherFolder') -ne 1) { throw 'Launcher restore action failed.' } + } + $expected = if ($explicit) { $explicit } else { 'E:\Existing exact launcher' } + if ((Get-SessionProperty $session 'INSTALLFOLDER') -ne $expected) { throw 'Launcher custom or existing path was lost.' } + } + $rows = @(Read-Rows $database 'SELECT `Root`, `Key`, `Name`, `Value` FROM `Registry`' 4) + if (@($rows | Where-Object { $_[0] -ne '1' }).Count) { throw 'Launcher registration must stay under the current account.' } + foreach ($entry in $policy.registry) { + if (@($rows | Where-Object { $_[0] -eq $entry[0] -and $_[1] -eq $entry[1] -and $_[2] -eq $entry[2] -and $_[3] -eq $entry[3] }).Count -ne 1) { + throw 'Launcher registration or shortcut preference changed unexpectedly.' + } + } + Write-Output 'PASS ArtCraft Launcher: per-user scope, suite folder, remembered/custom paths and existing registration. No installation performed.' + return + } + if ($properties['ALLUSERS'] -ne '2' -or $properties['MSIINSTALLPERUSER'] -ne '1') { + throw 'Policy regression: new packages must default to the per-user dual-scope context.' + } + if ($properties['UpgradeCode'].Trim('{}') -ne $policy.upgradeCode) { throw 'The existing upgrade identity must not change.' } + $directories = @{} + foreach ($row in (Read-Rows $database 'SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`' 3)) { + $directories[$row[0]] = @($row[1], $row[2]) + } + if ($directories['INSTALLFOLDER'][0] -ne 'CraftSuiteFolder' -or + $directories['CraftSuiteFolder'][1] -ne 'ArtCraft') { throw 'Expected the app under the ArtCraft suite folder.' } + $programs = $directories['CraftSuiteFolder'][0] + if ($programs -eq 'ProgramFiles6432Folder') { $programs = $directories[$programs][0] } + if ($programs -notin 'ProgramFilesFolder', 'ProgramFiles64Folder') { + throw 'Use Windows Installer native folder redirection, not a hard-coded profile path.' + } + $guards = @(Read-Rows $database 'SELECT `Condition`, `Description` FROM `LaunchCondition`' 2 | + Where-Object { $_[0] -match 'CRAFT_(USER|MACHINE)_DIR' }) + if ($guards.Count -ne 2) { throw 'Expected both duplicate-installation guards.' } + $cases = 0 + foreach ($scope in @('', '2', '1')) { + foreach ($user in @('', 'D:\Existing user app')) { + foreach ($machine in @('', 'E:\Existing machine app')) { + foreach ($installed in @('', '1')) { + Set-SessionProperty $session 'ALLUSERS' $scope + Set-SessionProperty $session 'Installed' $installed + Set-SessionProperty $session 'CRAFT_USER_DIR' $user + Set-SessionProperty $session 'CRAFT_MACHINE_DIR' $machine + $allowed = $true + foreach ($guard in $guards) { + $value = $session.EvaluateCondition($guard[0]) + if ($value -notin 0, 1) { throw 'Invalid duplicate guard.' } + if ($value -eq 0) { $allowed = $false } + } + $opposite = if ($scope -eq '1') { $user } else { $machine } + $expected = [bool]$installed -or -not [bool]$opposite + if ($allowed -ne $expected) { throw "Scope regression: ALLUSERS='$scope', user=$([bool]$user), machine=$([bool]$machine), maintenance=$([bool]$installed)." } + $cases++ + } + } + } + } + # Execute the actual authored type-51 actions in a safe session, not copied resolver logic. + foreach ($scope in @('', '2', '1')) { + foreach ($explicit in @('', 'F:\Chosen exact app')) { + Set-SessionProperty $session 'ALLUSERS' $scope + Set-SessionProperty $session 'INSTALLFOLDER' $explicit + Set-SessionProperty $session 'CRAFT_USER_DIR' 'D:\Existing user app' + Set-SessionProperty $session 'CRAFT_MACHINE_DIR' 'E:\Existing machine app' + $action = if ($scope -eq '1') { 'CraftRestoreMachineFolder' } else { 'CraftRestoreUserFolder' } + # Evaluate the compiled condition, so the test exercises it instead of calling the action directly. + $restore = @(Read-Rows $database ('SELECT `Condition` FROM `InstallExecuteSequence` WHERE `Action` = ''{0}''' -f $action) 1)[0] + $selected = $session.EvaluateCondition($restore[0]) -eq 1 + if ($selected -eq [bool]$explicit) { throw "$action must run only when no folder was supplied (condition: $($restore[0]))." } + if ($selected -and $session.DoAction($action) -ne 1) { throw 'Remembered-folder property action failed.' } + $expected = if ($explicit) { $explicit } elseif ($scope -eq '1') { 'E:\Existing machine app' } else { 'D:\Existing user app' } + if ((Get-SessionProperty $session 'INSTALLFOLDER') -ne $expected) { throw 'Custom or remembered folder was not preserved.' } + } + } + $ui = @{} + foreach ($row in (Read-Rows $database 'SELECT `Action`, `Sequence` FROM `InstallUISequence`' 2)) { $ui[$row[0]] = [int]$row[1] } + if (-not ($ui['AppSearch'] -lt $ui['CraftPreferMachineScope'] -and + $ui['CraftPreferMachineScope'] -lt $ui['CraftScopeDlg'] -and + $ui['CraftScopeDlg'] -lt $ui['FindRelatedProducts'] -and + $ui['FindRelatedProducts'] -lt $ui['LaunchConditions'] -and + $ui['CraftScopeDlg'] -lt $ui['CraftRestoreUserFolder'] -and $ui['CraftRestoreUserFolder'] -lt $ui['CostInitialize'])) { + throw 'Scope must be chosen after AppSearch and before FindRelatedProducts, launch checks and costing.' + } + # Windows Installer resolves Program Files for the context it started in, before the wizard's scope choice. + # The wizard therefore sets the new-install folder itself, and only in the wizard. + $defaults = @(Read-Rows $database 'SELECT `Action`, `Sequence`, `Condition` FROM `InstallUISequence`' 3 | Where-Object { $_[0] -like 'CraftDefault*' }) + if ($defaults.Count -lt 2) { throw 'The wizard must set the new-install folder after the scope page; Program Files is resolved before the choice.' } + foreach ($row in $defaults) { + if (-not ($ui['CraftScopeDlg'] -lt [int]$row[1] -and [int]$row[1] -lt $ui['CostInitialize'])) { throw "$($row[0]) must run after the scope page and before costing." } + } + if (@(Read-Rows $database 'SELECT `Action` FROM `InstallExecuteSequence`' 1 | Where-Object { $_[0] -like 'CraftDefault*' }).Count) { + throw 'Silent installs must not use the wizard-only default folder actions.' + } + # The machine default comes from the environment of the package architecture, not from a folder name. + # x86 packages use Program Files (x86) on 64-bit Windows; x64 and Arm64 packages use the 64-bit root. + $machineRoot = if ((Get-PackageTemplate $database) -match '^Intel') { + if (Get-SessionProperty $session 'VersionNT64') { ${env:ProgramFiles(x86)} } else { $env:ProgramFiles } + } elseif ($env:ProgramW6432) { $env:ProgramW6432 } else { $env:ProgramFiles } + $machineFolder = (Join-Path $machineRoot "ArtCraft\$($policy.name)") + '\' + foreach ($scope in @('1', '')) { + Set-SessionProperty $session 'ALLUSERS' $scope + Set-SessionProperty $session 'INSTALLFOLDER' '' + Set-SessionProperty $session 'CRAFT_MACHINE_DIR' '' + Set-SessionProperty $session 'CRAFT_USER_DIR' '' + foreach ($row in @($defaults | Sort-Object { [int]$_[1] })) { + if ($session.EvaluateCondition($row[2]) -eq 1 -and $session.DoAction($row[0]) -ne 1) { throw "$($row[0]) failed." } + } + $folder = Get-SessionProperty $session 'INSTALLFOLDER' + $wanted = if ($scope -eq '1') { $machineFolder } else { (Join-Path $env:LOCALAPPDATA "Programs\ArtCraft\$($policy.name)") + '\' } + if ($folder -ine $wanted) { throw "Wizard default folder for ALLUSERS='$scope' is '$folder', expected '$wanted'." } + } + $execute = @{} + foreach ($row in (Read-Rows $database 'SELECT `Action`, `Sequence` FROM `InstallExecuteSequence`' 2)) { $execute[$row[0]] = [int]$row[1] } + foreach ($action in @('CraftRestoreUserFolder','CraftRestoreMachineFolder')) { + if (-not ($execute['AppSearch'] -lt $execute[$action] -and $execute[$action] -lt $execute['CostInitialize'])) { + throw 'Silent updates must restore the folder before directory costing.' + } + } + foreach ($resolver in @('CraftUFromLegacyExe','CraftMFromLegacyExe')) { + if (-not ($execute['AppSearch'] -lt $execute[$resolver] -and $execute[$resolver] -lt $execute['LaunchConditions'])) { + throw 'Both legacy folder resolvers must run after AppSearch and before the launch checks.' + } + } + # Switching the first-page choice must reset BOTH properties, including a back-and-forth change. + $events = @(Read-Rows $database 'SELECT `Event`, `Argument`, `Condition`, `Ordering` FROM `ControlEvent` WHERE `Dialog_` = ''CraftScopeDlg'' AND `Control_` = ''Next'' ORDER BY `Ordering`' 4) + # Model the full-UI upgrade entry with an existing machine-wide copy. Run + # the actual preference action, then the compiled Next events before discovery. + Set-SessionProperty $session 'ALLUSERS' '2' + Set-SessionProperty $session 'CRAFT_SCOPE' 'user' + Set-SessionProperty $session 'CRAFT_USER_DIR' '' + Set-SessionProperty $session 'CRAFT_MACHINE_DIR' 'E:\Existing machine app' + $preference = @(Read-Rows $database 'SELECT `Condition` FROM `InstallUISequence` WHERE `Action` = ''CraftPreferMachineScope''' 1)[0] + if ($session.EvaluateCondition($preference[0]) -ne 1 -or $session.DoAction('CraftPreferMachineScope') -ne 1 -or + (Get-SessionProperty $session 'CRAFT_SCOPE') -ne 'machine') { + throw 'Full-UI machine upgrades must initially select the existing machine context.' + } + foreach ($choice in @('machine','user','machine','user')) { + Set-SessionProperty $session 'CRAFT_SCOPE' $choice + foreach ($event in $events) { + if ($event[0] -notmatch '^\[([^\]]+)\]$') { continue } + $property = $Matches[1] + if ($session.EvaluateCondition($event[2]) -eq 1) { + Set-SessionProperty $session $property $(if ($event[1] -eq '{}') { '' } else { $event[1] }) + } + } + $allUsers = Get-SessionProperty $session 'ALLUSERS' + $perUser = Get-SessionProperty $session 'MSIINSTALLPERUSER' + if (($choice -eq 'machine' -and ($allUsers -ne '1' -or $perUser)) -or + ($choice -eq 'user' -and ($allUsers -or $perUser -ne '1'))) { + throw 'Scope selector does not reset the requested installation context.' + } + } + $actions = @(Read-Rows $database 'SELECT `Action`, `Source`, `Target`, `Type` FROM `CustomAction`' 4) + $savedOptions = @($actions | Where-Object { $_[0] -match '^CraftLoadOption[0-9]+M$' }) + foreach ($option in $savedOptions) { + if ([int]$option[3] -ne 51) { throw 'Saved-option test may run only property-setting actions.' } + $number = [regex]::Match($option[0], '[0-9]+').Value + foreach ($scope in @('2','1')) { + Set-SessionProperty $session 'ALLUSERS' $scope + Set-SessionProperty $session "CRAFT_OPTION_${number}_M" 'saved-machine-choice' + Set-SessionProperty $session "CRAFT_OPTION_${number}_U" 'saved-user-choice' + Set-SessionProperty $session $option[1] '' + $action = "CraftLoadOption$number" + $(if ($scope -eq '1') { 'M' } else { 'U' }) + if ($session.DoAction($action) -ne 1) { throw 'Saved-option property action failed.' } + $expected = if ($scope -eq '1') { 'saved-machine-choice' } else { 'saved-user-choice' } + if ((Get-SessionProperty $session $option[1]) -ne $expected) { throw 'Saved installer choices leaked across contexts.' } + } + } + # Follow the compiled control conditions, not the source's intended appearance. + $controls = @(Read-Rows $database 'SELECT `Dialog_`, `Control`, `Type`, `Attributes`, `Text` FROM `Control`' 5) + $conditions = @() + if (@(Read-Rows $database 'SELECT `Name` FROM `_Tables` WHERE `Name` = ''ControlCondition''' 1).Count) { + $conditions = @(Read-Rows $database 'SELECT `Dialog_`, `Control_`, `Action`, `Condition` FROM `ControlCondition`' 4) + } + function Test-ControlVisible($Control) { + $visible = ([int]$Control[3] -band 1) -ne 0 + foreach ($condition in $conditions) { + if ($condition[0] -eq $Control[0] -and $condition[1] -eq $Control[1] -and $session.EvaluateCondition($condition[3]) -eq 1) { + if ($condition[2] -eq 'Show') { $visible = $true } + if ($condition[2] -eq 'Hide') { $visible = $false } + } + } + return $visible + } + foreach ($button in @($controls | Where-Object { $_[0] -in 'InstallWelcome','InstallMaintenance','DesktopShortcutDlg' -and ([int]$_[3] -band 8388608) -ne 0 })) { + $plain = @($controls | Where-Object { $_[0] -eq $button[0] -and $_[1] -eq ($button[1] + 'User') }) + if ($plain.Count -ne 1 -or ([int]$plain[0][3] -band 8388608)) { throw 'Scope-aware buttons need an unshielded per-user counterpart.' } + foreach ($scope in @('', '2', '1')) { + Set-SessionProperty $session 'ALLUSERS' $scope + if ((Test-ControlVisible $button) -ne ($scope -eq '1') -or (Test-ControlVisible $plain[0]) -ne ($scope -ne '1')) { + throw 'The elevation shield must follow the selected scope.' + } + } + $dialog = $button[0]; $shieldId = $button[1]; $plainId = $plain[0][1] + $shieldEvents = @(Read-Rows $database "SELECT ``Event``, ``Argument``, ``Condition``, ``Ordering`` FROM ``ControlEvent`` WHERE ``Dialog_`` = '$dialog' AND ``Control_`` = '$shieldId' ORDER BY ``Ordering``" 4 | ForEach-Object { $_ -join '|' }) + $plainEvents = @(Read-Rows $database "SELECT ``Event``, ``Argument``, ``Condition``, ``Ordering`` FROM ``ControlEvent`` WHERE ``Dialog_`` = '$dialog' AND ``Control_`` = '$plainId' ORDER BY ``Ordering``" 4 | ForEach-Object { $_ -join '|' }) + if (($shieldEvents -join "`n") -ne ($plainEvents -join "`n")) { throw 'Per-user and machine buttons must perform the same operation.' } + } + foreach ($scope in @('', '2', '1')) { + Set-SessionProperty $session 'ALLUSERS' $scope + foreach ($text in @($controls | Where-Object { $_[4] -like '*for all users*' })) { + if ((Test-ControlVisible $text) -ne ($scope -eq '1')) { throw 'The welcome-page scope text must follow the selected scope.' } + } + } + if ($policy.id -in 'deckcraft','filmcraft','soundcraft') { + foreach ($route in @(@('WelcomeDlg','Next','InstallDirDlg'),@('InstallDirDlg','Back','WelcomeDlg'))) { + $dialog = $route[0]; $control = $route[1] + $routes = @(Read-Rows $database "SELECT ``Argument``, ``Condition`` FROM ``ControlEvent`` WHERE ``Dialog_`` = '$dialog' AND ``Control_`` = '$control' AND ``Event`` = 'NewDialog' ORDER BY ``Ordering``" 2) + Set-SessionProperty $session 'Installed' '' + $destination = '' + foreach ($event in $routes) { if ($session.EvaluateCondition($event[1]) -eq 1) { $destination = $event[0] } } + if ($destination -ne $route[2]) { throw 'Skipping the licence page must work in both navigation directions.' } + } + } + $registry = @(Read-Rows $database 'SELECT `Root`, `Key`, `Name`, `Value` FROM `Registry`' 4) + if (@($registry | Where-Object { $_[0] -in '1', '2' }).Count) { throw 'Registration must follow the selected context, not force HKCU or HKLM.' } + if (@($registry | Where-Object { $_[0] -eq '0' -and $_[1] -match '^Software\\Classes(\\|$)' }).Count) { + throw 'HKCR keys must be relative to Classes.' + } + foreach ($entry in $policy.registry) { + $found = @($registry | Where-Object { $_[0] -eq $entry[0] -and $_[1] -eq $entry[1] -and $_[2] -eq $entry[2] -and $_[3] -eq $entry[3] }) + if ($found.Count -ne 1) { throw "Lost or changed registration: $($entry[1]) / $($entry[2])" } + } + $installDir = @($registry | Where-Object { $_[0] -eq '-1' -and $_[1] -eq "Software\$($policy.name)" -and $_[2] -eq 'InstallDir' -and $_[3] -eq '[INSTALLFOLDER]' }) + if ($installDir.Count -ne 1) { throw 'A context-sensitive installation-folder record is required.' } + Write-Output "PASS $($policy.name): $cases scope cases, folder preservation, action sequencing and registry contract. No installation performed." +} finally { + foreach ($com in @($session, $database, $installer)) { + if ($null -ne $com) { [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($com) } + } +} diff --git a/packaging/windows/install-policy.json b/packaging/windows/install-policy.json new file mode 100644 index 000000000..e5c63e72d --- /dev/null +++ b/packaging/windows/install-policy.json @@ -0,0 +1,56 @@ +{ + "id": "cadcraft", + "name": "CADCraft", + "upgradeCode": "119D7D76-0167-4A9E-8F37-09DA0235F68E", + "sources": [ + "cadcraft.wxs" + ], + "icon": "assets/app-icon/cadcraft.ico", + "localization": [], + "extensions": [ + "UI" + ], + "payloads": [ + "cadcraft-cli.exe", + "cadcraft.exe" + ], + "registry": [ + [ + "-1", + "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\cadcraft.exe", + "", + "[#CadcraftExe]" + ], + [ + "-1", + "Software\\Classes\\Applications\\cadcraft.exe\\shell\\open\\command", + "", + "\"[#CadcraftExe]\" \"%1\"" + ], + [ + "-1", + "Software\\Classes\\.dxf\\OpenWithProgids", + "CADCraft.Drawing", + "" + ], + [ + "-1", + "Software\\Classes\\.dwg\\OpenWithProgids", + "CADCraft.Drawing", + "" + ], + [ + "-1", + "Software\\Classes\\CADCraft.Drawing\\shell\\open\\command", + "", + "\"[#CadcraftExe]\" \"%1\"" + ], + [ + "-1", + "Software\\Learning Machines LLC\\CADCraft", + "DesktopShortcut", + "1" + ] + ], + "mode": "dualScope" +} diff --git a/packaging/windows/install-policy.wxi b/packaging/windows/install-policy.wxi new file mode 100644 index 000000000..407c41cf3 --- /dev/null +++ b/packaging/windows/install-policy.wxi @@ -0,0 +1,71 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packaging/windows/package.ps1 b/packaging/windows/package.ps1 index 92b48e134..042b46f73 100644 --- a/packaging/windows/package.ps1 +++ b/packaging/windows/package.ps1 @@ -115,6 +115,8 @@ Invoke-Native 'wix build' { -d "DocsDir=$Docs" -d "HasCraftFontLicences=$HasCraftFontLicences" ` -o $Msi } +# Check the compiled scope, path and registration contract before signing. +& (Join-Path $PSScriptRoot 'check-install-policy.ps1') -MsiPath $Msi # wix writes its debug symbols (.wixpdb) next to the MSI; keep them out of the release assets. Remove-Item -Force -ErrorAction SilentlyContinue ([IO.Path]::ChangeExtension($Msi, '.wixpdb')) & (Join-Path $PSScriptRoot 'sign.ps1') $Msi diff --git a/packaging/windows/test-install-policy.ps1 b/packaging/windows/test-install-policy.ps1 new file mode 100644 index 000000000..d455d19d1 --- /dev/null +++ b/packaging/windows/test-install-policy.ps1 @@ -0,0 +1,54 @@ +<# +.SYNOPSIS + Build non-executable installer metadata fixtures; never install them. +#> +param( + [Parameter(Mandatory = $true)] [string] $OutputDirectory, + [ValidateSet('x64','x86','arm64')] [string[]] $Architectures = @('x64','x86','arm64') +) +$ErrorActionPreference = 'Stop' +Set-StrictMode -Version Latest +$root = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path +$policy = Get-Content -Raw -LiteralPath (Join-Path $PSScriptRoot 'install-policy.json') | ConvertFrom-Json +[void](New-Item -ItemType Directory -Force -Path $OutputDirectory) +$output = (Resolve-Path -LiteralPath $OutputDirectory).Path +Add-Type -AssemblyName System.Drawing +foreach ($arch in $Architectures) { + $stage = Join-Path $output $arch + [void](New-Item -ItemType Directory -Force -Path $stage) + foreach ($name in $policy.payloads) { + $destination = Join-Path $stage $name + [void](New-Item -ItemType Directory -Force -Path ([IO.Path]::GetDirectoryName($destination))) + Set-Content -LiteralPath $destination -Encoding Ascii -Value 'NON-EXECUTABLE MSI METADATA TEST FIXTURE' + } + foreach ($folder in @('docs','models','notices')) { + $path = Join-Path $stage $folder + [void](New-Item -ItemType Directory -Force -Path $path) + Set-Content -LiteralPath (Join-Path $path "$folder-fixture.txt") -Value 'Metadata test fixture, not a user file or model.' + } + foreach ($model in @('metadata-one.rten','metadata-two.rten')) { + Set-Content -LiteralPath (Join-Path (Join-Path $stage 'models') $model) -Encoding Ascii -Value 'NON-EXECUTABLE MODEL METADATA FIXTURE' + } + foreach ($spec in @(@('banner.bmp',493,58),@('dialog.bmp',493,312))) { + $bitmap = [Drawing.Bitmap]::new($spec[1],$spec[2],[Drawing.Imaging.PixelFormat]::Format24bppRgb) + try { $bitmap.Save((Join-Path $stage $spec[0]),[Drawing.Imaging.ImageFormat]::Bmp) } + finally { $bitmap.Dispose() } + } + Set-Content -LiteralPath (Join-Path $stage 'licence.rtf') -Encoding Ascii -Value '{\rtf1 Metadata test fixture.}' + $sources = @($policy.sources | ForEach-Object { Join-Path $PSScriptRoot $_ }) + $msi = Join-Path $stage "$($policy.id)-NOT-INSTALLABLE.msi" + $extensions = @($policy.extensions | ForEach-Object { '-ext'; "WixToolset.$_.wixext" }) + & wix build @sources -arch $arch @extensions ` + -culture en-US -d 'Version=0.0.1' -d 'DisplayVersion=0.0.1-metadata-test' ` + -d "BinDir=$stage" -d "IconPath=$(Join-Path $root $policy.icon)" ` + -d "DocsDir=$(Join-Path $stage 'docs')" -d "ModelsDir=$(Join-Path $stage 'models')" ` + -d "AppNoticesDir=$(Join-Path $stage 'notices')" -d 'HasCraftFontLicences=1' -d 'HasCli=1' ` + -d "BannerBmp=$(Join-Path $stage 'banner.bmp')" -d "DialogBmp=$(Join-Path $stage 'dialog.bmp')" ` + -d "UiBannerBmp=$(Join-Path $stage 'banner.bmp')" -d "UiDialogBmp=$(Join-Path $stage 'dialog.bmp')" ` + -d "LicenseRtf=$(Join-Path $stage 'licence.rtf')" -o $msi @($policy.localization | ForEach-Object { '-loc'; Join-Path $PSScriptRoot $_ }) + if ($LASTEXITCODE -ne 0) { throw "WiX validation failed for $arch (exit $LASTEXITCODE)." } + $shell = (Get-Process -Id $PID).Path + & $shell -NoProfile -ExecutionPolicy Bypass -File (Join-Path $PSScriptRoot 'check-install-policy.ps1') -MsiPath $msi + if ($LASTEXITCODE -ne 0) { throw "Compiled installer policy failed for $arch (exit $LASTEXITCODE)." } + Write-Output "PASS $arch metadata-only package. This is not an executable installer." +} diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml index 701013cdc..aaa577fa7 100644 --- a/xtask/Cargo.toml +++ b/xtask/Cargo.toml @@ -5,6 +5,9 @@ edition.workspace = true license.workspace = true publish = false +[lints] +workspace = true + [dependencies] serde_json = { workspace = true } chrono = { workspace = true }