Compare commits

..
353 Commits
Author SHA1 Message Date
Tanish Manku 5a5cb1a676 UCS stack: asking UCSICON or an empty UCS Previous leaves the drawing unmodified 2026-11-19 15:16:52 -07:00
Tanish Manku cbacaff9e0 UCS stack: LISP trans display coordinates follow the view twist 2026-11-19 15:16:49 -07:00
Tanish Manku b86caba676 UCS stack: the UCS icon turns with the view twist 2026-11-19 15:16:49 -07:00
Tanish Manku 23962d68e2 UCS stack: leave parity docs to maintainers 2026-11-19 14:36:27 -07:00
Tanish Manku 61d0575611 Merge branch 'pr1547' into stack/ucs 2026-11-19 14:36:21 -07:00
Tanish Manku 7cb74443c4 Merge branch 'pr1533' into stack/ucs 2026-11-19 14:36:18 -07:00
a770fa5a5e Dimension Style Manager, -DIMSTYLE and dimension properties (#1460)
Adds the Dimension Style Manager: DIMSTYLE, D, DST, DDIM and both menu items open it, with the style list, a preview, Set Current, New, Modify, Override, Compare, Delete, Rename and the seven tabs. Also adds -DIMSTYLE and dimstyle.overrides; properties.describe and properties.set rows for text, mtext and dimensions in the Properties palette; and the dimension shortcut menu. Ported from #1042 (with #954, #994 and #1008), on top of this PR's dialog and its validation.

An open manager page is cancelled when another drawing becomes active (from #2322).

Fixes #1459, #1417, #1389.

Co-authored-by: eldrir <jamie@eldrir.com>
Co-authored-by: Slopapalooza <ai.slopapalooza@gmail.com>
Co-authored-by: Luminati <347279204+luminatiguy@users.noreply.github.com>
Signed-off-by: FredApps <153173854+FredApps@users.noreply.github.com>
2026-11-18 21:46:38 +07:00
CA b23d172885 LISP: entlast sees a routine's own edits; entmod keeps a block reference's attributes; HANDSEED is live (#2514)
- LISP: entlast sees a routine's own edits; entmod keeps INSERT attributes; HANDSEED is live
- lisp: drop a closed drawing's environment; keep entlast's order across property edits
- lisp: HANDSEED skips the handles the file's objects hold; hold the order in its cache test
2026-11-18 19:34:56 +07:00
Tyrel Haveman 11d66cc3cd AutoLISP: namedobjdict, dictsearch, dictnext, tblobjname; handent and entget of non-graphic objects (#1659, #1661) (#1802)
- lisp: namedobjdict, dictsearch, dictnext, tblobjname; handent and entget of non-graphic objects (#1659, #1661)
- lisp: tblobjname matches names as the roles spell them; records cache held by a weak drawing reference (#1659)
- lisp: CodeRabbit follow-ups on non-graphic objects (#1659, #1661)
- lisp: test an imported DIMSTYLE's group-105 handle (#1659, #1661)
- docs: a DIMSTYLE's own name is in group 105 (#1659)
- engine: install AutoLISP's object records with their own setter (#1659, #1661)
2026-11-18 18:04:56 +07:00
NetterSilver 83a2b4c373 Fix ACI grey entries 8, 9 and 250-254 RGB values (#1759)
- Fix ACI grey entries 8, 9 and 250-254 RGB values
2026-11-18 16:40:47 +07:00
Alex-BB44 2ed5614e46 Windows: a file opened while CADCraft runs opens as a tab in the running window (#2561)
- Windows: a file opened while CADCraft runs opens as a tab in the running window
- single instance: only a refused or missing socket counts as stale (review)
- single instance: the Windows socket test removes its temporary folder (review)
- single instance: the socket is named after the whole session name (review)
- single instance: a short fixed socket name, relative paths refused (review)
- single instance: Cargo.lock lists uds_windows, the fallbacks log at warn (review)

Co-authored-by: Alex-BB44 <273073052+Alex-BB44@users.noreply.github.com>
2026-11-18 16:35:00 +07:00
austin62jake ad5ac32662 fix(engine): REGION typed with nothing selected asks for objects (#2447)
- fix(engine): REGION typed with nothing selected asks for objects
2026-11-18 16:34:44 +07:00
austin62jake 92b718f912 fix(ui): scroll Drafting Settings on a short screen (#2441)
- fix(ui): scroll Drafting Settings on a short screen
2026-11-18 16:34:29 +07:00
NetterSilver 766af02ec4 Fix major axis of transformed ellipses on SVG import (#2072)
- Fix major axis of transformed ellipses on SVG import
2026-11-18 16:34:14 +07:00
FredApps d9d6c78a28 Merge pull request #2111 from dotCooCoo/feat/dimgap-text-frame
Dimensions: a negative DIMGAP draws a frame around the dimension text
2026-11-18 16:33:53 +07:00
FredApps 0ebb256d33 Merge pull request #1855 from SBaksa/lisp-block-entities
AutoLISP: read block definitions: tblsearch BLOCK gives the first entity (-2), entnext and entget walk a block's entities (part of #1700)
2026-11-18 16:33:41 +07:00
FredApps 730907b9b8 Merge pull request #1720 from SBaksa/attdef-justify-style
ATTDEF: justify and style parameters, as TEXT and MTEXT take them (fixes #1658)
2026-11-18 16:33:29 +07:00
.CooCoo f1b76fab54 Updates: take craft-update from craft-libs main at e9829954 (#3057)
* Updates: take craft-update from craft-libs main at 6e03f65bf

* Updates: take craft-update from craft-libs main at e9829954

Moves craft-update to craft-libs e98299546f5c5c3c22388d16507f8b5e61a5f280,
which includes storytold/craft-libs#923: the update check's thread now
reads whether the copy can install itself, so Updater::tick no longer
walks the installed files.
2026-11-17 21:51:02 -06:00
Obtrusive8276andClaude Opus 5.5 65ed2fb7f0 Blocks palette: previews, block libraries and placement (#2122)
* Blocks palette: list/medium/large icon modes, visible-only preview cache, grab-and-drop placement

* Address CodeRabbit review: repeat-placement tracking, Arc<Drawing> clone, contains_pointer, docstrings

* Keep repeat INSERT inside engine state machine and leave canvas hover check intact

* Handle Repeat/NoRepeat across all INSERT stages and bound preview work budget

* Fix Blocks palette review findings and preflight polyline previews

* Fix Blocks palette review findings and menu click ownership

* Restore bounded hatch thumbnails and exclude navigation clicks

* Support faithful hatch previews with shared work budget and bounded contour fallback

* Allow checking Repeat placement while block insertion is already in progress

* Address PR 2122 review feedback on hatch budget, ViewCube hit-testing and preview test

* Charge leader and wipeout expansion and bound MLeader array inserts in preview preflight

* Charge MLeader paths in preview preflight and match ViewCube hit-testing to displayed sheet

* Allow block insertion while rename editor is open and clarify hatch preview docs

* Limit palette repeat placement to palette-started insertions

* Account hatch preview comparisons as work occurs

* Bound attribute thumbnail work and preserve palette rotation

* Charge spline sampling work to the block preview budget

* Charge splines at 1/32 of their sampling cap so ordinary blocks still preview

* Charge text lengths in block preview budget and preserve inline INSERT arguments

* Bound MText column metadata in block previews

* Allow detailed block palette previews

* Explain refused block previews and keep them cached while scrolling

Previews now return Ready, Empty or Unavailable(reason) instead of an
ambiguous empty display list, so a refused thumbnail is no longer shown
like an empty block. Preflight separates input, computation and retained
output, and reuses the geometry/render sampling rules at a thumbnail
tolerance instead of a 4,000-sample worst case. A 64 MiB / 512-result LRU
replaces retain_visible. Insertion never depends on preview success.

Also: invalid-but-finite splines draw as their control polygon, and the
insertion-point prompt advertises REpeat so R keeps meaning Rotate.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Remove changes unrelated to the Blocks palette

Drop the contributor entry and the two xtask test adjustments so the PR
only contains palette, preview and insertion changes.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Document the functions touched by the Blocks palette preview work

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Keep placement on unchanged rename and tighten palette click ownership

Confirming a block name unchanged no longer cancels the INSERT in progress.
Command-line releases are not placed as points when two arrive in one frame,
and menu ownership of a press is taken from the press position of the last
press in the frame.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Translate palette refusal messages and track canvas click ownership per release

Mark the five preview refusal texts for translation and add the palette status
texts to the other catalogs. Give each primary release in a frame the owner of
its own press, and place a release at its own position when the cursor has
moved onto a menu or a new press has begun.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Treat navigation controls as release owners in batched canvas clicks

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Track INSERT ownership and refuse palette edits during a foreign INSERT

The palette now cancels only the INSERT it started (identified by a per-run serial), advertises REpeat/NoRepeat at every numeric and point prompt, and refuses Edit, Create, Rename and Delete while an INSERT it did not start is running, so undoing that insertion cannot also undo a palette edit.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Keep clicks on command-line keywords from placing canvas points

The command line now records one rectangle covering the bar and every inline keyword, and the canvas treats a press, release or ordinary click there as the command line's, so a keyword pushed past the bar by a long prompt cannot also send a point.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Decide whether the ViewCube is shown from the current space, not the display list

The display list is rebuilt after a frame's clicks are handled, so right after a layout switch it was stale or cleared. A click where the ViewCube had just disappeared was dropped, and a click on one that had just appeared reached the drawing as a point. Painting and hit-testing now share viewcube_shown, which follows the layout space.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Treat only a refused charge as hatch budget exhaustion

Spending the hatch budget exactly left zero remaining, which hatch::draw and the preview builder read as exhaustion, so a valid preview could lose its hatches or be refused. HatchBudget now records a refused reservation separately and both checks use it.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Keep CLOSEALL's confirmation, widen the command-line click area, persist the Blocks window choice

Only {json} calls and INSERT with inline arguments bypass the UI router, so CLOSEALL Y still asks before discarding drawings. The command line's click rectangle now includes the history lines or window, the resize grip and the AutoComplete rows. The floating-window preference of the Blocks palette is saved and restored with the other preferences.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Update Z and axis presets with a comma scale; grey the palette's Y scale when exploding

A comma-separated scale preset now sets Z to the size of X and the axis presets to X, Y and that Z, so an earlier Scale cannot leave a stale Z. The Blocks palette disables its Y scale while Explode is on, with a tooltip saying the exploded insertion scales both axes by X.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Fix doc comments on the BLOCK and ATTDEF input methods and the INSERT tests

BlockM::input and AttdefM::input named the INSERT state machine; the NoRepeat description sat on the comma-scale test instead of the repeat test, and the two newer INSERT tests had none of their own.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Reset the Verify counter between repeated INSERT placements

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: previews, block libraries and placement

Rewrite this PR on a smaller base. The Blocks window becomes a dockable
palette with a Current Drawing tab and a Libraries tab, icon and list views,
a kept list of block libraries (folders and DWG/DXF files) and one-click
placement through the existing interactive INSERT.

- Previews are built only for the visible tiles, a few per frame, under a
  time and point budget, in a bounded least-recently-used cache.
- BLOCKLIBRARY, BLOCKLIBIMPORT and BLOCKLIBRARIES are commands; importing a
  library block brings only the layers, linetypes, styles and blocks it needs.
- INSERT: Enter at the insertion point ends the command, as in AutoCAD.
- Hostile library files and block data are bounded; nothing panics.
- The canvas, ViewCube, command-line and interactive INSERT changes of the
  earlier version are gone.
- Translations in all interface languages.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: read libraries off the UI thread, bound preview work

CodeRabbit's reviews of f2ae408 and 62bff60:

- A library is listed on a worker thread (the web reads it at once), with
  a "Reading the library..." message in every catalog. Refresh waits for
  the read, and now parses the file again even when its size and time
  look the same. `list_library` is what BLOCKLIBRARY answers, without a
  session.
- A preview's work is counted before anything is drawn: vertices, text,
  and the blocks references, dimensions and multileaders draw. An object
  with nothing in it still costs one visit. The pass that finds the size
  draws no dashes, and a block of points no longer scans the drawing's
  extents.
- A block listing keeps the first blocks by name without sorting the
  whole table, for BLOCKSPALETTE too.
- Merging a drawing removes nothing from a drawing too big for the purge
  scan: past its limit, a layer or style in use can look unused.

Also fixed: a block with more than 100,000 references could lose the
blocks it needs on import, because the walk counted repeated names. The
same count in `used_blocks`, which PURGE shares, could drop the arrowhead
of a merged dimension style, so that limit goes too: each block is walked
once, so the walk ends, cycles included.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Blocks palette: repeat a placement only after its own INSERT placed

The palette took any new handle as proof that its INSERT had placed the
block. Queued control requests can cancel that INSERT and run another
command to its end between two frames, and that command's handles then
started a placement nobody asked for.

The session now says how the last command ended: `commands_started`
numbers the commands, nested transparent ones left out, and
`last_finished` holds the number of the last one that ended by itself and
whether it added to the drawing. The palette repeats only when that is its
own INSERT, which also removes its handle counter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Blocks palette: a command started after a placement ends the repeat

A command with no prompt, such as REGEN, started right after INSERT placed
the block left `last_finished` on that INSERT, so the palette started
placing again after the user had moved on. The palette now also requires
that no command has started since.

A JSON command still does not end the repeat, on purpose: it never stops a
running command, so one that lands a frame later finds the next INSERT
running and leaves it alone. Ending the repeat only when it lands before
the frame would make the result depend on timing. A test pins this.

Also adds the doc comments CodeRabbit's coverage check asks for, on this
PR's own functions and tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* INSERT: a cancelled placement takes no undo step

INSERT wrote INSNAME when the name was given, so cancelling it left a
changed drawing and an undo step that undid nothing visible. Repeat
Placement, on by default, always ends with a cancelled INSERT, so the first
undo after placing a block from the palette appeared to do nothing.

INSNAME is now written when the block is placed. A cancelled INSERT no
longer offers its name as the next default.

Tests go through the palette where they only imitated it: the scale set in
the palette, and the two undo steps of a block from a library. The palette
places with two clicks, so the wording about a drag is gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Block import: keep what a block names and says about itself

BLOCKLIBIMPORT defined a new block from the chosen one's objects and base
point, so its description, annotative flag, units and explodable flag were
lost. They now come along.

The import's clean-up uses PURGE's scan, which only read the linetypes of
objects and layers. A linetype named only by a dimension style, a dimension
override, a multiline style, a multiline's copy of its style or an attribute
override looked unused, so the import dropped it and PURGE removed it while
the style still named it. The scan reads them all now.

A reference to a renamed anonymous block kept the drawing's block of that
name when it spelled the name in another case, or when it was a multileader's
block content. Both now take the new name, found as Drawing::block finds a
block.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* INSERT: Enter asks again at the insertion point, arrowheads follow renames

This PR made Enter and Space at the insertion point end INSERT, "as in
AutoCAD". AutoCAD 2027 does not: from -INSERT, from its palette and during
repeated placement it answers that a point or option is needed and asks
again. Only Escape ends it, so that change is gone.

A file named at the block name prompt defines its block before the insertion
point is asked for, and Escape keeps that definition, which is what AutoCAD
2027 does too. A test pins it.

An anonymous arrowhead block renamed by a merge kept its old name in the
dimension styles that came along and in dimension overrides, so they pointed
at this drawing's block. Both follow the rename now; a style this drawing
already had keeps its own.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Block import and palette: keep every named style and layer, skip unused counts

Selective import uses PURGE's scans, which missed dimension styles named by
leaders, text styles named by linetype pattern elements, table cell styles,
dimension DIMTXSTY overrides and multiline or multileader-content attributes,
plus layers and linetypes named by attributes on multileader block content.
They all count as in use now.

The palette asks BLOCKSPALETTE for no reference counts so it does not read
every object after each edit, and cancels any running command before importing
a library block so the import keeps its own undo step.

* Blocks palette: a quick right-click at the insertion point cancels the placement

A placement started from the palette had no way out with the mouse: Enter at
the insertion point asks again, as AutoCAD 2027 does, and a quick right-click
is Enter. At that prompt only, for an INSERT the palette started, a quick
right-click now ends the command like Escape, which also ends Repeat
Placement. A typed INSERT and the scale and rotation prompts keep Enter, and
holding the button still opens the command menu.

Escape, the menu's Cancel and this right-click share one function that also
clears the half-typed text and the IME preedit; the menu's Cancel left the
preedit behind.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: a transparent command no longer stops Repeat Placement

A 'ZOOM or 'PAN run while the palette's INSERT asks for the insertion point
shows the prompt `>>ZOOM`, which the palette took for another command and so
stopped repeating the placement. A transparent command inside the INSERT does
not start a command; it is now the count of commands started that tells
whether the user moved on. A test pins it.

The blocklibrary params string names the `truncated` field both results
return.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: a transparent command ending inside INSERT is not its end; bound library reads

A transparent command that finishes inside a running one ('ZOOM in an INSERT)
recorded its end under the outer command's number. With an object added
meanwhile, cancelling the resumed INSERT looked like a placement and the
palette started another. Only a top-level command records its end now.

Switching quickly between big libraries started a reading thread for each. At
most four libraries are read at once; a further one waits, and the palette
says it is reading until a place comes back.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: BLOCKLIBIMPORT never replaces a block; BLOCKSPALETTE counts every object that draws one

BLOCKLIBIMPORT refuses a name the drawing already has (any letter case),
the rule the palette already follows, so a direct JSON call can no longer
change existing references. BLOCKSPALETTE counts block references,
dimensions and multileader block content through `referenced_block`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Blocks palette: a library file must be named .dwg or .dxf

cached_drawing read any regular path, and the reader sniffs the bytes, so a
DXF named part.bin was listed by BLOCKLIBRARY, imported by BLOCKLIBIMPORT and
loaded by the palette. It now refuses other names before the cache lookup, so
the three callers share the check. Regression test with a part.bin.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: library listing needs no drawing; a preview's two passes share one deadline

BLOCKLIBRARY and BLOCKLIBRARIES ignore the session but had the has_doc guard,
so the palette opened on the Start tab got "no drawing open", kept an empty
library list and never reloaded it. They are now always enabled; BLOCKLIBIMPORT
still needs a drawing.

outline() gave each of its two build passes the full PREVIEW_DEADLINE, so one
preview could take twice the limit. The detailed pass now gets what the coarse
pass left.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Blocks palette: a dimension override given as a number names its style, linetype or arrowhead

DIMOVERRIDE keeps a number as given (DIMTXSTY 123) and the dimension is
drawn with it as text, but the in-use scans only read strings, so PURGE,
style deletion and import cleanup could drop a style, linetype or
arrowhead block still in use. `purge::override_name` reads either, for
text styles, linetypes, arrowheads (main's `override_arrows` had the same
defect) and the arrowhead rename at import, which now rewrites an
override only when its block is really renamed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Blocks palette: put show()'s doc comment back on show()

right_click_cancels_placing had been inserted between show()'s doc comment
(the cursor-visibility contract, #1701) and show() itself, so the contract
documented the wrong function. Moved, no code change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* i18n(ka): add the 27 Blocks palette strings

Georgian rows for the strings this PR adds to the other catalogs (cargo test -p cadcraft-ui-egui translation_gaps -- --ignored --nocapture lists none of them any more).

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-18 08:43:17 +07:00
SBaksa 7515b2bc69 Merge branch 'ucs-core' into ucs-drafting 2026-11-17 02:38:47 +11:00
SBaksa 9e3d38fd5f Merge origin/main into ucs-core 2026-11-17 02:22:46 +11:00
FredApps 16341b665f Merge pull request #3215 from storytold/docs/shared-library-guidance
docs: prefer shared Craft libraries for reusable features
2026-11-16 13:51:51 +01:00
Dylan M. Taylor 259d892a33 docs: prefer shared Craft libraries for reusable features 2026-11-16 06:28:11 -05:00
Zinadin Zidan 2ccf5874b0 LISP: findfile finds folders (#2985) (#3165)
findfile only accepted regular files, so (findfile "dir") and
(findfile "dir/.") gave nil for a folder that exists. Routines test
whether an optional module is installed with (findfile "module/.").
A folder now counts too; the name is returned as given, as for a file.
2026-11-16 10:22:06 +01:00
FredApps ed0fbce27c Merge pull request #3188 from storytold/codex/cad-neutral-svg-consumer
Use shared SVG import and export
2026-11-16 08:10:09 +01:00
FredApps e1b86d5743 Merge pull request #3195 from storytold/codex/cad-shared-shx-glyph
Use shared SHX glyph interpreter
2026-11-16 08:09:00 +01:00
FredApps cb36b573c3 Merge pull request #3203 from storytold/codex/shared-font-embedding
Use shared TrueType font embedding classification
2026-11-16 08:08:47 +01:00
FredApps 32dfdef71c Merge main into codex/cad-shared-shx-glyph 2026-11-16 07:44:49 +01:00
FredApps 29e17181bf Merge main into codex/shared-font-embedding 2026-11-16 07:44:31 +01:00
FredApps b21747b30b Merge main into codex/cad-neutral-svg-consumer 2026-11-16 07:44:13 +01:00
FredApps b3d11070e4 Merge pull request #3194 from storytold/codex/cad-shared-shx-reader
Use shared SHX container reader
2026-11-16 07:42:21 +01:00
FredApps 155fd45d61 Merge pull request #3191 from storytold/codex/cad-ui-shared-raster
Use shared codecs for preview and screenshots
2026-11-16 07:24:21 +01:00
FredApps 0bc69feed0 Merge main into codex/shared-font-embedding 2026-11-16 07:24:07 +01:00
FredApps 13f4d09b6d Merge main into codex/cad-neutral-svg-consumer 2026-11-16 07:23:52 +01:00
FredApps 27256f0ba5 Merge main into codex/cad-shared-shx-reader 2026-11-16 07:23:33 +01:00
FredApps 386750bd56 Merge pull request #3193 from storytold/codex/cad-shared-shx-compiler
Use the shared SHP to SHX compiler
2026-11-16 07:22:41 +01:00
FredApps eec225a218 Merge pull request #3198 from storytold/codex/cad-shared-mtext-tokenizer
Use shared MTEXT tokenizer for CAD text
2026-11-16 07:22:26 +01:00
FredApps 7013ce459c Merge main into codex/cad-shared-mtext-tokenizer
Resolve the MTEXT conflicts with #3197 (jayzed80's #2952 fix) on the
shared tokenizer: Token::Unknown is now shown as typed (backslash kept,
code read as text) in plain_mtext, the layout parser and the paragraph
scan, matching main's behaviour. Drop the now-unneeded too_many_lines
expectation on parse.
2026-11-16 07:02:25 +01:00
FredApps 7b525189c0 Merge main into codex/shared-font-embedding 2026-11-16 06:57:10 +01:00
FredApps 13de76e5b2 Merge main into codex/cad-ui-shared-raster after #3189 was squash-merged 2026-11-16 06:56:19 +01:00
FredApps afe77dc0d4 Merge main into codex/cad-neutral-svg-consumer 2026-11-16 06:50:32 +01:00
FredApps e5091e052e Merge main into codex/cad-shared-shx-compiler 2026-11-16 06:49:46 +01:00
FredApps d267d6580e Merge pull request #3197 from storytold/codex/cad-shared-mtext-escapes
Use shared MTEXT escape decoding
2026-11-16 06:43:13 +01:00
Dylan M. TaylorandFredApps 2974d74bdc Use shared raster image codecs (#3189)
* Use shared raster image codecs

* Encode rendered PNGs through shared codecs

* Update raster probe and use supported BMP dimensions

* Check raster depth and TIFF page fidelity

---------

Co-authored-by: FredApps <153173854+FredApps@users.noreply.github.com>
2026-11-15 19:30:49 -05:00
Dylan M. Taylor 0e3f62f50d Merge pull request #3190 from storytold/codex/mcp-shared
Route MCP protocol through shared libraries
2026-11-15 17:25:51 -05:00
jayzed80 007a24ef94 Fonts: MTEXT shows a malformed \U+ or \M+ escape and an unknown code as typed (#2952)
AutoCAD 2024 shows a \U+ without four hex digits, a malformed \M+ and an
unknown code such as \Z as typed, backslash included. plain_mtext, the
layout and the paragraph scan dropped the backslash and the code instead.
They now keep the backslash and read on from the code.
2026-11-15 17:20:57 -05:00
Dylan M. Taylor f9c0c96e63 Merge pull request #2573 from AxylumRust/refactor/geom-clippy-pedantic
refactor(geom): apply behavior-preserving cleanups
2026-11-15 16:51:34 -05:00
Dylan M. Taylor 1069c8217a Merge pull request #2568 from AxylumRust/refactor/fonts-clippy-pedantic
refactor(fonts): apply behavior-preserving cleanups
2026-11-15 16:45:22 -05:00
Dylan M. Taylor 6dfc0ef6a2 Merge pull request #2565 from AxylumRust/refactor/clippy-pedantic
refactor(color): satisfy Clippy pedantic lints
2026-11-15 16:36:51 -05:00
Dylan M. Taylor 11e90d34fb Merge branch 'codex/cad-shared-mtext-escapes' into codex/cad-shared-mtext-tokenizer
# Conflicts:
#	Cargo.lock
2026-11-15 19:03:33 +00:00
Dylan M. Taylor 0dae816499 Merge remote-tracking branch 'origin/main' into codex/cad-shared-mtext-escapes
# Conflicts:
#	Cargo.lock
2026-11-15 19:02:59 +00:00
Dylan M. Taylor a009f7d022 Use shared TrueType embedding classification 2026-11-15 18:46:31 +00:00
Dylan M. Taylor e7a51dcc3d Merge remote-tracking branch 'origin/main' into codex/mcp-shared
# Conflicts:
#	Cargo.lock
2026-11-15 18:41:57 +00:00
Dylan M. Taylor c985814fcb Merge pull request #3192 from storytold/codex/cad-shared-base64
Use shared Base64 for file and control data
2026-11-15 13:39:46 -05:00
Dylan M. Taylor a853649ffa Merge branch 'codex/cad-shared-mtext-escapes' into codex/cad-shared-mtext-tokenizer 2026-11-15 18:22:54 +00:00
Dylan M. Taylor ed6377fc46 Update code page fixtures for Johab support 2026-11-15 18:22:40 +00:00
Dylan M. Taylor 7cb07b2f3b Merge branch 'codex/cad-shared-mtext-escapes' of https://github.com/storytold/cadcraft into codex/cad-shared-mtext-tokenizer
# Conflicts:
#	Cargo.lock
#	Cargo.toml
2026-11-15 18:03:30 +00:00
Dylan M. Taylor 923f4174a6 Pin MTEXT escapes to merged shared decoder 2026-11-15 17:38:18 +00:00
Dylan M. Taylor 9789562ac7 Pin Base64 consumer to merged shared compatibility API 2026-11-15 17:17:19 +00:00
Dylan M. Taylor a20a46f7c3 Pin MCP cutover to merged shared protocol revision 2026-11-15 17:14:50 +00:00
Dylan M. Taylor 682034d737 Pin shared SVG reader to merged official revision 2026-11-15 17:12:17 +00:00
Dylan M. Taylor db70717001 Use shared MTEXT lexical tokens 2026-11-15 16:06:13 +00:00
Dylan M. Taylor 173cdf6e8a Use shared MTEXT escape decoding 2026-11-15 16:00:46 +00:00
Dylan M. Taylor 5b170664aa Use shared SHX glyph interpreter 2026-11-15 15:52:39 +00:00
Dylan M. Taylor 305f452283 Use shared SHX container reader 2026-11-15 15:49:47 +00:00
Dylan M. Taylor 78bcdce794 Wire shared compiler into CAD font API 2026-11-15 15:47:14 +00:00
Dylan M. Taylor fd11b47915 Use shared SHP to SHX compiler 2026-11-15 15:47:03 +00:00
Dylan M. Taylor 91b14c83cf Use shared Base64 for file and control data 2026-11-15 15:39:16 +00:00
Dylan M. Taylor ca6c100342 Encode plot previews with shared PNG writer 2026-11-15 15:35:55 +00:00
Dylan M. Taylor 072ec4500a Use shared codecs for preview and screenshots 2026-11-15 15:32:54 +00:00
Dylan M. Taylor 8a4e275466 Route MCP protocol through shared libraries 2026-11-15 15:30:38 +00:00
Dylan M. Taylor 58a13b5a64 Update raster probe and use supported BMP dimensions 2026-11-15 15:24:39 +00:00
Dylan M. Taylor a5a5550165 Update shared SVG candidate revision 2026-11-15 15:23:12 +00:00
Dylan M. Taylor 281f86d602 Encode rendered PNGs through shared codecs 2026-11-15 15:22:04 +00:00
Dylan M. Taylor caaa0e37f7 Use shared raster image codecs 2026-11-15 15:20:04 +00:00
Dylan M. Taylor c07b6a2ff7 Use shared SVG document reader and writer 2026-11-15 15:17:57 +00:00
Dimitrios Vidalis 7064a685a8 Greek: commands, aliases and prompt keywords typed with the Greek layout, and 46 missing Greek rows (#2722)
**What**

Typing a command with the Greek keyboard layout active (ΛΙΝΕ for LINE, ΜΙΡΡΟΡ for MIRROR) now works like typing the Latin name, in four places: starting a command, answering a prompt keyword (ΘΝΔΟ = Undo), the selection words at "Select objects" (ΑΛΛ = ALL), and command-line AutoComplete. The layout puts each Greek letter on the key of the Latin letter it sounds like (θ on U, ψ on C, ω on V, Q types `;`, W the final sigma), so `keyboard::latin_keys` maps letter by letter and ignores accents, including a combining tonos or dialytika straight after its letter. It returns `None` for a word with no Greek letter, so Latin input is never touched. ASCII characters in a Greek word are kept, in lower case (the dash of `-ΛΑΥΕΡ`), and a word with any other character is not read as Latin keys.

A command the interface handles itself answers to its Greek-typed name too: ΨΛΟΣΕ asks about unsaved changes as CLOSE does, `;ΣΑΩΕ` opens the Save picker for a drawing without a file, ΛΑΥΕΡ opens the Layers dialog.

What keeps existing behaviour:
- A word that is already a command, alias or LISP function keeps its own meaning, as typed or in another case or accent (a Greek `(defun c:ΛΙΝΕ …)` runs as itself, also when typed λινε).
- A keyword a prompt offers in its own Greek spelling (a LISP program's list) wins over its Latin reading, with Greek case folded.
- A selection word wins over a keyword on the same key, as it does for Latin typing: at COUNT's "Select object to count or [List/Spaces]", Λ is Last, like L.
- A name that exists wins over the keyword or selection word its keys spell: an existing block at BEDIT's "block name or select" and at BLOCKREPLACE's two name prompts (a block called Μ opens at BEDIT, it is not Multiple), and a loaded hatch pattern at HATCH's pattern prompt (a pattern called ΣΟΛΙΔ is that pattern, not Solid). The name is found in any case or accent and the command gets it as stored.
- Only the lookup reads the Greek keys: text that is no selection word reaches the command as typed (a Greek block name at BEDIT's "block name or select"), and an unknown Greek command is reported as typed.

Known and accepted:
- At a prompt that takes a name and offers a keyword, a Greek word whose keys spell the keyword is the keyword while no block has that name (Σ is Select at BLOCKREPLACE), as the Latin `S` is there.
- Two aliases whose Greek names differ only in case or accent can both exist (the alias editor folds ASCII only). Each runs when typed as stored; another spelling of the word runs the first of them in the store's order.
- Object snap overrides and the other point modifiers (END, FROM, M2P, TT, TK, `.X`) are not read from Greek-layout typing. They need the Latin layout, as before.
- Calls by command id are unchanged: a `cmd {json}` line and `execute` (control channel, MCP) do not read a Greek-typed name.
- In a script a line that starts with `;` is still a comment, so a line `;ΣΑΩΕ` there is not QSAVE.

Also adds 46 `el.tsv` rows for strings that were in the source but missing from the catalog when the rows were written (alias editor, save-on-close and units dialogs, a few menu and command labels). On this head the i18n report lists 39 strings that fall back to English for `el` (mostly keyboard shortcuts, right-click customization and alias import); they are not in this PR. Four command labels keep the English name in parentheses, like the rest of the catalog. The `el.tsv` row of `ATTRIBUTION.md` credits these rows (AI-assisted, read by the contributor, a native Greek speaker), and `contributors/people.toml` has the author's entry.

**Tests**
- `keyboard::tests`: the mapping, non-Greek words left alone, combining marks only straight after a Greek letter, one Greek word in any case, accent or final sigma, a character the layout does not type is no spelling of a Greek letter (the micro sign is not μ), 100 000-letter and malformed input do not panic
- `engine/tests/it/greek_keyboard.rs`: ΛΙΝΕ draws a line (lower case and accents too), `;ΣΑΩΕ`, an unknown Greek word is reported as typed, the selection word ΑΛΛ, Λ, λ and ΛΑΣΤ at COUNT's prompt count like L (Last, not the List option), keywords at MIRROR's prompt (Ν is read as No and keeps the sources, Υ erases them), a Greek LISP command runs as itself and in any case or accent, a Greek block name at BEDIT reaches the command as typed, a block called Μ opens at BEDIT (in either case), a block called Σ at BLOCKREPLACE, a loaded pattern called ΣΟΛΙΔ at HATCH's pattern prompt (upper case, lower case, accented)
- `engine/tests/greek_keyboard_aliases.rs` (its own binary, the alias store is process-global): a Greek alias keeps its meaning, as typed and in any case or accent; a word of 1 000 000 Greek letters is looked up among 5 000 Greek aliases within 5 s (170 s before the word was folded once per lookup)
- `prompt::tests`: a Greek keyword is matched as spelled, before its Latin reading
- `ui-egui`: ΨΛΟΣΕ asks before it closes a drawing with unsaved changes, and a LISP `c:ΨΛΟΣΕ` still runs as itself; ΛΑΥΕΡ (also λάυερ) opens the Layers dialog and `;ΣΑΩΕ` the Save picker; AutoComplete reads a Greek prefix as Latin keys, offers the Greek alias that Enter would run, and leaves a Greek word the drawing's LISP defines as typed
- Each fix after review landed with a test that failed before it.

**What ran** on e171e083, `cargo xtask ci` step by step: `cargo fmt --all -- --check` and `cargo clippy --workspace --all-targets -- -D warnings` clean; `cargo test --workspace --lib --bins --tests --no-fail-fast`: 3759 passed, 0 failed, 28 ignored; the doctest step (the workspace has no doctests), the i18n report, `cargo xtask assets`, `cargo xtask layers` and `cargo xtask wasm` passed. The same steps passed on e171e083 merged with main at e1d379ad, a local merge that is not pushed: 3761 passed, 0 failed, 28 ignored.

Main is merged in. The merge commit e3b3a2e0 had kept only this branch's side of `cmd/file.rs` and `cmd/file/pgp.rs`; e8a79d19 restores main's alias-persistence helpers and exports next to `greek_alias`, so those two files are main's again plus this PR's own lines.

**Docs (not edited here, per AGENTS.md)**: `docs/localization.md` "Greek (`el`) interface" and `docs/localization-parity.md` row "Greek | el" (its row count) could mention that commands typed with the Greek layout are accepted.

Nothing here is Autodesk-derived: the mapping is the standard Greek layout, written from the layout itself.

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->

## Summary by CodeRabbit

* **New Features**
  * Greek keyboard-layout input is recognized as Latin keystrokes when entering commands, aliases, autocomplete prefixes, selection keywords, and prompt options.
  * Greek commands and aliases can be matched across case and accent variants. Existing commands, aliases, and matching block names take precedence over Greek-layout interpretations; unrecognized input retains its original text.
  * At prompts that accept either a block name or a selection keyword, Greek input is treated as a name when a matching block exists; otherwise, it can be interpreted as a selection keyword.
  * Greek-layout input can also match loaded or built-in hatch pattern names, which take precedence over prompt keyword interpretation.
  * In BLOCKREPLACE prompts, you can select a block reference to choose a block.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
2026-11-15 12:12:28 +01:00
Dimitrios Vidalis e43c39c55e Selection and grips respect the layers frozen in the active viewport (#3055) (#3124)
Fixes #3055.

## What
Inside an MSPACE viewport an object on a layer frozen in that viewport (VPLAYER, VP Freeze) is not drawn, but it
could still be picked, window-selected and edited through the viewport, and a selected one kept its grips.
`Drawing::is_visible` has no viewport, and selection and grips asked only that.

Three questions now take the active viewport into account:
- `select::selectable(d, e, frozen)`: what a selection can take. `frozen` is `DocState::viewport_frozen()`, the
  layers frozen in the active MSPACE viewport (empty in paper space and on the Model tab). The selection functions
  have `_in` variants that take it (`pick_in`, `pick_all_in`, `select_window_in`, `select_fence_in`,
  `select_polygon_in`, `select_group_in`, `SelectMode::select_in`); the existing functions keep their signatures
  and select as before.
- `DocState::shows(e)`: what the view being edited shows, `is_visible` plus the active viewport. Grips ask it where
  #3048 made them ask `is_visible`.
- `Session::selection()`: the selection as the view being edited has it, without the model-space objects the active
  viewport does not draw (`DocState::shown_selection`). The stored selection, `DocState::selection`, keeps them.

**Selecting.** Every selection made in the space being edited passes the active viewport's frozen layers:
- idle clicks and windows, "Select objects" (a pick, the implied window, W, C, BOX, F, WP, CP, ALL, G, and L and P,
  which take the last object the viewport draws and the part of the Previous set it draws), selection cycling, and
  prompts that pick one object;
- `select`, `selectall`, `selectsimilar`, and the group members a pick brings (PICKSTYLE);
- the commands that select for themselves: STRETCH (JSON and typed, with its own All, Last and Previous and its
  multiline vertex rule), TRIM and EXTEND by fence and by crossing window;
- AutoLISP `ssget` (W, C, F, WP, CP, a point, P, L) and `entsel`;
- in the UI, the rollover highlight and the hatch under the cursor that a double-click edits. The object under
  the cursor and selection cycling's badge are worked out again when the active viewport's frozen layers change
  under a pointer that does not move.

**Already selected.** An object that is selected when its layer is frozen in the active viewport stays in the
stored selection until the selection is replaced or cleared, and counts as selected again once the layer is thawed
there. Until then `Session::selection()` leaves it out, and with it everything that starts from the selection: the
selection made before a command (PICKFIRST), a JSON command that names no objects, Delete, the grip edits that
cover the selection, AutoLISP's implied selection (`ssget`, `ssget "I"`, `ssgetfirst`), the palettes, and what the
session reports as the selection (`summary`, `drawing.inspect`). Two UI functions read the stored selection
themselves and now read `shown_selection` too: the hatch editor's edit mode and BEDIT's choice between editor and
dialog. The selection highlight inside the active viewport leaves the object out as well.

Adding to the selection or removing from it (a click, a window, `select` with `add` or with nothing to select
with, QSELECT appending) starts from the stored selection (`Session::stored_selection()`), so such an object is not
dropped while the selection changes around it. A command that takes the selection, or a new selection, replaces
it as before. `Session::selection()` gives the stored selection unchanged wherever the active viewport hides
none of the selected objects: in paper space, on the Model tab, and in a viewport that freezes no layer.

The UI asks for the selection several times a frame, so `DocState::drawn_in_viewport` does not look every selected
object up: a few handles are looked up one by one, and beyond that it passes over model space once.

**Grips.** Static grip painting and hit testing, hot grips (`click_grip`), the grip edit's targets and the typed
GRIP command (`griphot.rs`), and dynamic grips ask `shows`. The dynamic-grip cache key now holds the active
viewport's frozen layers: entering another viewport changes which references are shown without changing the
drawing revision, so the key did not change. The grip code asks for itself, as it does for `is_visible` since
#3048, so it does not depend on who hands it the objects.

A viewport's frozen layers hide model-space objects only, never an object on the sheet. Layer names are compared
the way the renderer compares them. Outside a viewport, and in a viewport that freezes no layer, nothing changes.

## Test
The tests build two viewports on one layout, one of which freezes a layer. Most take the same path through both:
through the viewport that freezes the layer the object on it is left out, through the other one it is taken as
before. The ones about an object that is already selected freeze and thaw its layer in the viewport being edited.

`crates/engine/tests/it/viewport_frozen_selection.rs`, 22 tests:
- selecting: a pick, window / crossing / fence, idle clicks and windows, selection cycling, every answer to
  "Select objects" (with ERASE), group members, `selectall` and `selectsimilar`, STRETCH (JSON; typed crossing
  window, All, a pick, Last, Previous; the multiline vertex rule), TRIM by fence and by crossing window, a prompt
  for one object (BREAK), LEADER's Copy, AutoLISP `ssget` and `entsel`;
- already selected: a typed command with PICKFIRST, a JSON command without handles and Delete; Previous and Last;
  the grip edits that cover the selection; what the session reports, with paper space and the Model tab unchanged;
  adding to and removing from the selection; a small and a large selection (the two paths of
  `drawn_in_viewport`, in a drawing whose draw order is not the order of its handles);
- grips: a shared grip, the grips of an object whose layer is frozen and thawed again while it is selected, and
  what the edited view shows (model-space objects only, never an object on the sheet).

`crates/ui-egui`, 9 unit tests (hot grips, the grip and the hatch under the cursor, the viewport highlight, dynamic
grips and their cache key, BEDIT's choice, the hatch editor's edit mode, selection cycling's badge under a resting
pointer) and `tests/viewport_frozen_grips.rs`, 3 tests (no grips painted for a selected object the viewport does
not draw; the rollover highlight; the highlight under a resting pointer while the layer is frozen and thawed).

EXTEND runs TRIM's selection code and has no test of its own.

Without the change these tests fail, checked call by call with a temporary switch that is not in this PR: each of
the 60 calls of `viewport_frozen`, `shows`, `hidden_in_viewport`, `drawn_in_viewport`, `shown_selection`, `last_in`
and `stored_selection` outside tests was put back to the old behaviour on its own. 51 of them made at least one
test fail directly; 5 grip checks that sit behind `Session::selection()` did so with the getter switched back as
well; the other 4 are calls inside `DocState` that the same tests reach through their callers. Each path of
`drawn_in_viewport`, and its sort, fails a test when switched off. Of the 42 calls of `Session::selection()`, 10
have a test that fails when that one call reads the stored selection; the other 32 receive the same list and have
no test of their own. The second commit's two conditions (the hover and the badge under a resting pointer) each
have a test that fails without them.

## What ran
The seven steps of `cargo xtask ci`, one by one, on this branch at 6754b960 (main at ddfa833b plus its two commits):
fmt, clippy (workspace, all targets, `-D warnings`), test (3725 passed, 0 failed, 26 ignored; the doctest
step ran, the workspace has no doctests), the i18n report, assets, layers and wasm. All pass.

## Not in this PR
- A selected object whose layer is turned off or frozen for the whole drawing is still taken by a command that
  starts from the selection, as before (ran: ERASE and MOVE typed and as JSON, and Delete, edit it). The issue asks
  to keep the drawing-wide behaviour, so this PR leaves it alone.
- A command that is given object handles (`handles` in JSON, an entity name from AutoLISP) acts on them as before,
  whatever the viewport draws. QSELECT and `ssget "X"` look at the whole drawing; what they put in the stored
  selection is then left out like any other selected object the viewport does not draw.
- `ssget "L"` takes the last object of any space, as before; inside a viewport it now passes over the objects
  that viewport does not draw.
- Object snap, hatch boundary detection, the implied cutting edges of TRIM and EXTEND, constraint inference, and
  the Z that ID and DIST read from an object under the point are not selections and are unchanged.
- A block reference on a layer the viewport draws, with parts on a layer frozen in the viewport: the parts are not
  drawn, but the hit geometry of a reference is built without the viewport, so a pick where such a part would be
  still finds the reference. Ran on eaae189f with a test that is not in the PR: a pick, a crossing window and a
  fence on such a part select the reference, and a window around the drawn part alone does not; with the layer
  frozen for the whole drawing it is the other way round. It needs extents that know the viewport, which
  `crates/doc` does not have, so it is left for its own change.
- Visibility that changes while an interactive command is already waiting, or while a grip list is open, is #3056.

## Compared with AutoCAD 2022
Observed as a black box, in a drawing made there for this and driven by a script: two lines, one of them on a layer
frozen (VPLAYER) in one of two layout viewports. No file from it is in this PR.

Inside the viewport that freezes the layer, the same there and here: a pick, a window, a crossing window, a fence
and a crossing polygon (`ssget`), ALL, Last, a crossing window and a fence at "Select objects", `ssget "L"`, select
all, and STRETCH's crossing window leave the object out; `ssget "X"` returns it; a command that is given the object
itself (its entity name there, `handles` here) changes it. Through the other viewport the pick, the windows, the
fence, ALL, Last and STRETCH took it.

Different, where the issue asks for more ("cannot be edited through that viewport, including when they were
already selected"):
- An object selected through the other viewport stays in the implied selection when the viewport that freezes its
  layer becomes the active one (`ssgetfirst`, `ssget "I"`), and ERASE typed there erased it. Here the commands leave
  it out.
- Previous: `ssget "P"` returned the set made through the other viewport whole, and CHPROP with Previous changed
  the object. Here Previous takes the part of that set the viewport draws.

A comment on the issue asks which of the two is wanted. This PR follows the issue as written; if AutoCAD's
behaviour is preferred for these two cases, I will change them here.

Not observed there: grips (a script cannot read them), and freezing the layer while objects are selected (VPLAYER
is a command and cleared the selection).

## Parity rows
U5 (grips) and F15 (viewports) in docs/gaps.md. No docs edited.

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->

## Summary by CodeRabbit

* **New Features**
  * Selection, picking, hover highlighting, and grip interactions now respect layers frozen in the active model-space viewport.
  * Selection reports and editing tools show only objects visible in the active viewport, while stored selections retain hidden objects.
  * Window, crossing, fence, point, and other selection modes now apply viewport visibility consistently.
* **Bug Fixes**
  * Changing viewports or freezing and thawing layers now updates selection highlights, hover targets, and grips to match what the active viewport displays.
  * Selection commands and object inspection now consistently reflect viewport visibility.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
2026-11-15 12:11:56 +01:00
neronek22 deff6cb092 Add Polish localization (#218)
Register Polish interface localization with catalog provenance, locale fallback and plural-form regressions.

Original contribution by @neronek22.
2026-11-15 00:34:02 -06:00
FredAppsandFredApps 67514021ae Release: CADCraft v0.21.0 on main (#3172)
Co-authored-by: FredApps <FredApps@users.noreply.github.com>
2026-11-14 21:45:54 +01:00
Cédric Legrand 6749299b95 fix(fonts): preserve SHX suffix handling for path-prefixed names 2026-11-14 16:56:09 +01:00
Cédric Legrand 4072f84290 style(fonts): remove review churn 2026-11-14 16:56:09 +01:00
Cédric Legrand f877213876 fix(fonts): preserve SHX dotfile handling 2026-11-14 16:56:09 +01:00
Cédric Legrand 06203e4958 refactor(fonts): satisfy Clippy pedantic lints 2026-11-14 16:56:09 +01:00
Zinadin Zidan 8e69890223 DXF: write a MINSERT with the AcDbMInsertBlock marker (#3127) (#3131)
An INSERT repeated in rows or columns (groups 70/71 above 1) was written with
the subclass marker AcDbBlockReference, the marker of a single block
reference. Readers that go by the marker, BricsCAD among them, then drew only
the first copy of the array. The writer now marks such a reference
AcDbMInsertBlock, as AutoCAD does, and a plain INSERT keeps
AcDbBlockReference. The reader does not look at the marker, so CADCraft reads
both back as before.
2026-11-14 15:22:22 +01:00
SBaksa 8c2d67531c Merge branch 'ucs-core' into ucs-drafting 2026-11-14 15:41:58 +11:00
SBaksa 1d16bb8ba0 Merge remote-tracking branch 'origin/main' into ucs-core 2026-11-14 15:41:58 +11:00
Dylan M. Taylor fbb083803b Merge pull request #3143 from storytold/codex/craft-dwg-cutover
Move CADCraft DWG bridge to craft-libs
2026-11-13 20:49:19 -05:00
Dylan M. Taylor 54dfb2ee00 Preserve CADCraft DWG diagnostics 2026-11-14 00:32:49 +00:00
FredAppsandFredApps fa7a97728b Naming: use Additional Tools for the utility menu (#2945)
* Naming: use Additional Tools for the utility menu

* test(naming): guard neutral display labels

* test(ui): handle escaped literals in feature-name guard

---------

Co-authored-by: FredApps <FredApps@users.noreply.github.com>
2026-11-14 01:18:12 +01:00
Dylan M. Taylor 2a9fc8f241 Use shared DWG bridge in CADCraft 2026-11-13 23:50:21 +00:00
Dimitrios Vidalis ddfa833bc2 Grips: hidden objects paint no grips and take no grip hits (#3048)
* ui: omit hidden objects from grip painting and hit tests

Respect the drawing's existing visibility predicate when painting selection
grips and finding the grip under the pointer. A hidden handle restored through
another selection path must not show or activate grips.

The visibility predicate also suppresses grips for entities on off or frozen
layers, not only objects hidden with HIDEOBJECTS.

The frame regression uses ordinary model geometry and HIDEOBJECTS, with an
on-screen selected-object control.

* Grips: a hidden object takes no hot-grip stretch and no dynamic grips

Clicking a hot grip stretches every hot-grip object, and the set can still hold
an object that was hidden after it became hot (its grips are no longer painted,
but the stretch still moved it). `click_grip` now drops hidden objects from the
hot-grip set first.

Dynamic-block grips come from the selection, which Undo or another selection
source can restore with a hidden block reference in it; `dyngrips::of_selection`
now skips hidden references as ordinary grips already do.

Adds a test for each, a doc comment on the test helpers, and `cadcraft-io` as a
dev-dependency of the UI crate so the dynamic grips test can read the synthetic
dynamic-block fixture of the io tests.

* Grips: a hidden object in the selection takes no part in a grip edit

A grip edit took the whole selection as its targets. A hidden object that was back in the
selection (Undo, sssetfirst, a control call) was stretched with a visible object's grip that
shared its point, and the Move, Rotate, Scale and Mirror modes transformed it.

The grip edit now leaves out what the drawing does not show when a grip becomes hot: a hidden
object's own grip is never made hot, the object is not among the targets, and the typed GRIP
command does not find its grips. A grip edit with no grip left does not start.
2026-11-13 14:12:27 +01:00
FredApps bf581c2376 CI: use the shared git-sources check (#3089)
nix.yml ran its own copy of the git-sources job; it now calls
craft-common-actions git-sources.yml. release.yml's copy is removed:
the shared release.yml runs the same check before any build.
2026-11-13 14:05:25 +01:00
dotCooCoo e347afbc63 Merge main into feat/dimgap-text-frame
Main added the insertion_point field to Dimension; the DIMGAP frame test in cadcraft-io now sets it.
2026-11-12 09:06:02 -08:00
dotCooCoo 39011d2552 Dimensions: test the DIMGAP frame around multi-line text
A negative DIMGAP frame around a two-line dimension text is the measured text height plus |DIMGAP| on each side, and holds both lines.
2026-11-12 07:32:15 -08:00
Khuong DoanandClaude Opus 5.5 ca87680fb0 xtask: clippy passes on Windows again (#3091)
stats.rs's test helper fresh_dir mutates its DirBuilder only on Unix
(DirBuilderExt::mode), so on Windows `cargo clippy --workspace
--all-targets -- -D warnings`, and with it `cargo xtask ci`, fails with
unused_mut. Allow that lint off Unix on that binding.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 23:19:16 -05:00
Dylan M. Taylor c736e488ba Use craft-dxf from craft-libs for DXF tags (#3040)
* Use craft-dxf from craft-libs; remove crates/dxf

cadcraft-dxf moved to craft-libs unchanged as craft-dxf
(storytold/craft-libs#791) so VectorCraft can write DXF through the same tag
layer. CADCRAFT_MAX_DXF_TAGS still sets the tag limit.

* Pin craft-dxf to the merge of storytold/craft-libs#796

* address review: restore the dated measurement text in file-format-parity.md
2026-11-11 19:51:53 -05:00
FredApps 2ef7c3bed1 CI: nightly release dry run (#3088)
release.yml also runs nightly on main with craft-common-actions' dry-run: every release build
except macOS, with nothing signed, pushed or drafted. Breakage that only the release build hits
(riscv64, Flatpak, FreeBSD, packaging) then shows up the next morning instead of on release
day, as it did on 11 Nov 2026.
2026-11-11 23:03:49 +01:00
Dylan M. Taylor 5a6aa9b65f fix: bound or confine seven name, path and file inputs (#2732)
* fix: bound or confine seven name, path and file inputs (QSELECT wildcard, layout template name, LISP OPEN/CLOSE, font manifest, xref palette, test walkers)

* address review: reserved device names, fresh fifo test dir, stat before open in build.rs

* review: honour the name alias and Unicode case in exact xrefs, reserve Windows device basenames, charge line headers, skip non-directories in the module walk

* address review: distinct exact xref names, exact-capacity LISP line queue, fail the module walk on entry errors

* address review: xrefs differing only by case cannot be loaded together; panic-free default template name

* address review: refuse detach and path changes across case-variant xrefs; ASCII case folding for xref names

* address review: report the case-variant xref a load skips; assert both xref paths in the test
2026-11-11 16:11:19 -05:00
Dylan M. Taylor b460a3b8d9 fix(engine): an atomic replacement keeps the old file's group, or drops the group bits (#2743)
* fix(engine): an atomic replacement keeps the old file's group, or drops the group bits

* address review: backup group bits, skip no-op fchown

* fix(engine): keep atomic writes of one path serialized, backup bits capped by the drawing's group

* fix(engine): the first backup takes the drawing's group, else drops its group bits
2026-11-11 16:10:52 -05:00
Dylan M. Taylor cb96c182ef fix(fonts): one retained-point allowance per MTEXT layout and per stroke line (#3070)
* fix(fonts): one retained-point allowance per MTEXT layout and per stroke line

* fix(fonts): the layout allowance counts both retained copies
2026-11-11 16:10:25 -05:00
Dylan M. Taylor e1d379ad9f chore: bump version to 0.20.1 for the Flatpak update fix (#3084) 2026-11-11 14:55:43 -05:00
Dylan M. Taylor dc7f382cec Fix Flatpak permissions for update checks and self-updates (#3075)
* fix(flatpak): allow release checks and self-update helpers

* test: keep Flatpak permission parsing within strict Clippy rules
2026-11-11 14:24:01 -05:00
FredApps e5021f0175 Merge pull request #3047 from V1dalTheAbidal/pr/bsaveas-source
Block Editor: BSAVEAS keeps the source block's last saved definition
2026-11-11 18:56:45 +01:00
Dylan M. Taylor 2d25308cfc Merge pull request #3068 from storytold/chore/craft-update-6e03f65
Updates: take craft-update from craft-libs main at 6e03f65bf
2026-11-11 12:43:38 -05:00
Dylan M. Taylor 20b4472f0b Updates: take craft-update from craft-libs main at 6e03f65bf 2026-11-11 12:43:30 -05:00
Dylan M. Taylor ecb362aa55 ci: run Harden-Runner on every job (#3058)
Adds step-security/harden-runner (audit, pinned to v2.22.4 like
craft-common-actions) as the first step of each job that did not have it,
so every workflow in the org's public repos reports its egress to
StepSecurity. Audit, not block: block-mode allow lists come from each
job's observed traffic.
2026-11-11 12:09:19 -05:00
Cédric Legrand fefb973754 fix(geom): move NURBS lint expectations to velocity 2026-11-11 17:30:12 +01:00
Cédric Legrand ff2163ddfe style(geom): remove review churn 2026-11-11 17:29:41 +01:00
Cédric Legrand 64f707968f test(geom): use assert_eq for NaN arc bound 2026-11-11 17:29:41 +01:00
Cédric Legrand 2ac6d98dac refactor(geom): satisfy Clippy pedantic lints 2026-11-11 17:29:41 +01:00
FredApps dea9f2d048 Release: CADCraft v0.20.0 (#3054) 2026-11-11 16:38:50 +01:00
Dylan M. Taylor d6d16bd474 fix(io): make four DXF/SVG passes linear in their input (#2721)
* fix(io): make four DXF/SVG passes linear in their input

Preserving foreign objects looked each root-owned object's key up by scanning the root dictionary; applying annotation scales searched every layout for each handle model space lacked; writing CLASS instance counts inserted each missing group into the middle of the tag list; and SVG attribute lookup resumed after a malformed attribute, re-running the parser's duplicate scan each time. Each is now one indexed or single pass with the same results.

* address review: first layout wins for duplicate handles; move tags instead of cloning in class count pass

* address review: reserve room for the added class counts, correct the peak-memory note
2026-11-11 05:01:27 -05:00
Dylan M. Taylor 2410a1fd07 hatch: one canonical key per source loop before tessellation (#3043) 2026-11-11 04:32:31 -05:00
V1dalTheAbidal f132d81609 Document the BSAVEAS source test 2026-11-11 11:14:22 +02:00
Dylan M. Taylor a1574780c2 fix(render): bound hatch swatches, charge boundary sweeps and cap linetype label points (#2744)
* fix(render): bound hatch swatches, charge boundary sweeps and cap linetype label points

* address review: charge hatch boundary transform, count glyph slots in linetype text

* fix(render): charge boundary transforms and scanline sorts to the shared hatch budget
2026-11-11 04:06:57 -05:00
Dylan M. Taylor ea2637ae73 fix(lisp): charge READ text, EQUAL string bytes, SETVAR and ENTMAKE copies, and nested callbacks against one budget (#2741)
* fix(lisp): charge READ text, EQUAL string bytes, SETVAR and ENTMAKE copies, and nested callbacks against one budget

* address review: charge callback steps live and reject completion past the shared allowance
2026-11-11 03:55:17 -05:00
Dylan M. Taylor 7e780548be fix: bound MOCORO copies, array EXPLODE, COMPARE bounds, attribute extraction, PDF links and control-server parsing (#2738)
* fix: bound MOCORO copies, array EXPLODE, COMPARE bounds, attribute extraction, PDF links and control-server parsing

* address review: key extract cache by exact block, count live MOCORO objects, PDF link budget

* review: select extraction columns before copying values, count live objects for MOCORO copies

* address review: count exploded array objects before cloning; scan each block's constants once
2026-11-11 03:16:11 -05:00
Dylan M. Taylor 6d744887f4 fix(mcp): send the control token only to 127.0.0.1:PORT and read it only from a private file (#2718)
The bridge picked the token by port alone and sent it to whatever the address resolved to, so a listener another account opened on ::1 with the same port received the desktop's credential. The token is now attached only when the connected peer is exactly 127.0.0.1:PORT, where the app listens. Reading the token refuses a symlink, a non-plain file and a file others can read, and the shared temporary directory is no longer a fallback location for it.
2026-11-10 21:33:51 -05:00
Dylan M. Taylor 2c25c2d700 fix: index or bound array replacements, DIM field spellings, path samples, hatch refills and broken tables (#2734)
* fix: index or bound array replacements, DIM field spellings, path samples, hatch refills and broken tables

* address review: index placeable array replacements, search past zero-length DIVIDE runs, per-part broken-table outlines
2026-11-10 21:33:42 -05:00
Dylan M. Taylor 95fdf8d11a fix: bound region grid registrations, island containment tests, snap_ends visits, inference duplicate searches and font name decoding (#2742)
* fix: bound region grid registrations, island containment tests, snap_ends visits, inference duplicate searches and font name decoding

* address review: charge empty curves only in snap_ends search

* fix(geom): report a spent containment budget instead of partial islands

* address review: count pending point candidates in the perpendicular cap
2026-11-10 21:33:39 -05:00
Dylan M. Taylor 0843770389 fix(engine): read local files for RECOVER, INSERT, IMPORT, COMPARE, NEW, DATALINK and STYLESMANAGER through the capped reader (#2687)
A path naming an endless device or a FIFO was buffered to EOF before any size check ran, so one short command could exhaust memory or block. These paths now go through capped_read::read_capped, which refuses non-regular files and enforces the byte limit while reading.
2026-11-10 21:29:52 -05:00
Dylan M. Taylor 36f5ad64f9 fix(engine): move LISP output to the command history in one pass (#2714)
lisp_flush drained each line from the front of the output buffer, shifting everything after it every time, so newline-dense PRINC output cost quadratic time outside the interpreter's step budget. It now walks the buffer once and drops the printed prefix once.
2026-11-10 21:29:48 -05:00
Dylan M. Taylor 7804e94ee0 fix(geom): bound the points one polyline tessellation samples (#2723)
* fix(geom): bound the points one polyline tessellation samples

Polyline::tessellate sampled every arc segment (up to 4096 points each) with no total limit, and hatch boundary preparation did this for every loop, so compact curved vertices expanded into gigabytes. tessellate_within takes a point budget; once spent, remaining arcs are drawn as chords. Hatch loops share one budget.

* address review: correct tessellate_within doc
2026-11-10 21:29:40 -05:00
Dylan M. Taylor bc9ad6b059 fix: index or bound four small lookups (DOF selection, xref palette, QSELECT colours, log lines) (#2728)
* fix: index or bound four small lookups (DOF selection, xref palette, QSELECT colours, log lines)

DOF scanned the selection list per slot; the xref palette scanned the xref list per INSERT; QSELECT parsed a possibly long layer name as a colour for every entity; and a log message could carry CR/LF or other control characters that started apparent extra records. Each now uses a set or map, a length bound, or escaping, with the same results for ordinary input.

* address review: trim colour text before length limit
2026-11-10 21:29:35 -05:00
V1dalTheAbidal 650ae383f2 Block Editor: BSAVEAS keeps the source block's last saved definition
After BSAVE the editor's block table can still hold the older source definition.
Restore the saved source block from the host when composing a copy and when
reconciling the editor and its history, so a later save of the copy keeps it.
2026-11-11 01:32:16 +02:00
Michael Higginsandmocenigo 2f8f186188 macOS: file dialogs no longer run inside the window's event handler (#1534)
On macOS the Open and Save panels ran modally inside winit's event handler, and resizing one aborted the app (#1527). Every file dialog now goes through CadApp::pick_then / pick_then_open. On macOS, Services::start_pick shows the dialog as a sheet on the window and the answer is acted on in a later frame. The answer is bound to the drawing that asked for it. Windows and Linux are unchanged.

Fixes #1527

Co-authored-by: mocenigo <4894657+mocenigo@users.noreply.github.com>
2026-11-10 19:20:25 +01:00
.CooCoo 6f0f1fefa8 Fonts: the MTEXT strip test expects a short \U+ escape to keep its digits (#2954)
strips_formatting expected `\U+12` to strip to nothing. plain_mtext
dropped every unknown code up to the next `;` when that assertion was
written. #1036 limits this to the codes in takes_arg, and `\U` is not
one of them, so plain_mtext returns `+12`. The layout and paragraph
paths give the same text, and
unicode_escapes_are_decoded_in_every_parser already expects it.

The test has failed on main since both changes merged, and the failure
stops the gate at its test step. The test module now also checks the
short escape in both layout paths.
2026-11-10 12:01:17 +01:00
SBaksa 7a65b01453 Merge remote-tracking branch 'origin/main' into ucs-drafting
# Conflicts:
#	docs/ui-parity.md
2026-11-09 17:10:44 +11:00
Dylan M. Taylor a3d9348f63 Merge pull request #2951 from dotCooCoo/chore/craft-update-1b34eba41
Updates: take craft-update from craft-libs main at 1b34eba41
2026-11-08 23:01:58 -05:00
dotCooCoo 3074f18960 Updates: take craft-update from craft-libs main at 1b34eba41 2026-11-08 19:45:36 -08:00
Dylan M. Taylor 10ffb7c7bd Merge pull request #2947 from dotCooCoo/chore/craft-update-updater-fixes
Updates: the updater reports installing, ready, installed and failed, and installs at exit
2026-11-08 22:12:58 -05:00
skylar taylor-barrick 4744b4cffb Merge pull request #1034 from vangel76/fix/fonts-bidi-hardening
fix(fonts): paragraph direction skips bidi isolates; harakat no longer block the Lam-Alef ligature
2026-11-09 01:41:49 +01:00
skylar taylor-barrick d9e62df1dd Merge pull request #1273 from vangel76/fix/fonts-mtext-width-factor
fix(fonts): MTEXT \W…x multiplies the width factor; document the atom cap
2026-11-09 01:41:42 +01:00
FredApps 9bd7f8f8f1 Merge pull request #819 from vangel76/docs/gaps-audit-2026-10-12
docs: re-audit gaps.md and parity docs against main
2026-11-09 00:07:54 +01:00
FredApps d847eac134 Merge pull request #1036 from vangel76/fix/fonts-mtext-hardening
fix(fonts): MTEXT keeps the text after an unterminated code; bound oblique, line spacing and relative heights
2026-11-09 00:07:20 +01:00
FredApps cd71385da9 Merge pull request #2436 from vangel76/perf/region-build-no-siphash-set
Region build: test candidate pairs once in their lowest shared cell
2026-11-09 00:06:43 +01:00
FredApps 004cbecd48 Merge pull request #2435 from vangel76/perf/spline-solve-band
perf(geom): limit the spline fit solver to the matrix band
2026-11-09 00:05:17 +01:00
FredApps 0e7e0f59f0 Merge pull request #2434 from vangel76/perf-nurbs-derivative-stack
perf(geom): make NURBS derivative allocation-free up to degree 10
2026-11-09 00:04:03 +01:00
FredApps 6cb8e9b1a0 Merge pull request #2755 from vangel76/contributors-vangel76
contributors: set names for vangel76
2026-11-09 00:02:16 +01:00
dotCooCoo 3a9aebc210 Updates: the updater reports installing, ready, installed and failed, and installs at exit
craft-update moves from craft-libs c5a1cbfb to c7c84230, a branch that is
craft-libs main at 0a9d1f48 with storytold/craft-libs#687 and #696 merged
in. Cargo.lock changes the craft-update entry and drops zopfli from zip.

The check result window now shows whenever the updater's status is not
idle, not only after Help > Check for Updates, and never over the startup
prompt. At the first start after an update it reports that the update
installed or why it failed. Restart to Update calls
Updater::restart_to_update. The install helper starts when the app exits
and drops the updater, so a canceled close keeps the update ready.
2026-11-08 12:45:18 -08:00
FredApps 909af5e389 Merge pull request #2939 from FredApps/fix/freebsd-arm64-alpha
Fix FreeBSD ARM64 all-targets test build
2026-11-08 17:24:24 +01:00
FredApps 78810069c7 Merge main and gate the remaining DWG-only unit test 2026-11-08 17:02:58 +01:00
FredApps bd4a47491a Merge pull request #2919 from mkzung/fix/dxf-hard-owned-objects
DXF/DWG: an object a kept object holds by a hard owner reference is kept
2026-11-08 16:57:04 +01:00
FredApps 54c973c919 Merge main to validate proxy preservation and hard-owner retention together 2026-11-08 16:47:57 +01:00
FredApps 53962a5cd5 Merge pull request #2654 from mkzung/fix/opaque-proxy-roundtrip
DWG: keep opaque registered entities and their source classes
2026-11-08 16:44:27 +01:00
FredApps 1434d1017b Use public DXF codecs in the streaming class scanner 2026-11-08 16:31:40 +01:00
FredApps baf2424164 Keep hard-owner liveness monotonic and deduplicate holders in linear time 2026-11-08 16:31:08 +01:00
FredApps ec09c87c43 Keep DXF regressions enabled without the DWG bridge 2026-11-08 16:26:26 +01:00
FredApps a0dfe07f5a Preserve decoded proxy class identities through the DWG bridge 2026-11-08 16:25:00 +01:00
FredApps 9ec5728159 Fix FreeBSD ARM64 test dependency gating 2026-11-08 16:11:26 +01:00
mkzungandClaude Opus 5.5 42490afe8e Merge main into fix/opaque-proxy-roundtrip
Main now has its own proxy class handling for DWG saves (`proxy_classes`, from bf137e2c,
31935157 and 946af874) and the application object conversion of #2917. This branch is
brought onto that:

- Cargo.lock, crates/dwg/Cargo.toml and xtask/src/layers.rs are main's. `dwg` no longer
  depends on `dxf`: the source classes are read from the bridge's ASCII DXF by a bounded
  scan in `proxy_transport::source_classes`, as main's `dxf_class_names` reads their names.
- Saving as DWG 2013 or later restores the source classes in their places (duplicate
  names and metadata kept) when every CLASS record can be written back. Otherwise (before
  2013, a binary DXF, a malformed or unused bad CLASS) main's `proxy_classes` runs: proxies
  are matched by name or left out and counted as unwritten. Nothing returns an error any
  more, so a drawing with proxies saves in its own pre-2013 version, without them, as the
  save report says. A proxy whose number names no source class is left out and counted.
- The loss report is main's `not_saved_as` (`Foreign::proxy_class`);
  `preserves_proxy_entity` and this branch's report test are gone.
- On DWG read, `prepare` runs after `application_objects`, so the proxy objects that makes
  are numbered as the DXF numbers them. It uses main's `proxy_dwg_version`. A registered
  entity with decoded properties and opaque data now stays as read, as on main, and a read
  note names it, instead of being dropped.

Tests: `cargo test -p cadcraft-dwg` 37 passed, `-p cadcraft-io` all passed (25 ignored),
`-p cadcraft-doc`, `-p cadcraft-engine --test save_reports_not_saved` and `--test it`
passed; clippy `-p cadcraft-dwg -p cadcraft-io -p cadcraft-doc -p cadcraft-engine
--all-targets -D warnings`, fmt, `cargo xtask layers` and the wasm32 check of cadcraft-io
pass. `registered_proxy` now checks that a pre-2013 DWG save leaves the proxy out and
keeps the rest; main's proxy tests in crates/io/src/tests.rs pass unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H43qQA41CJLauqXnPgBQ7r
2026-11-08 14:27:18 +00:00
mkzungandClaude Opus 5.5 adf02f9f04 DXF/DWG: a null-owner object goes with a hard owner that is kept
hard_owners took the first object naming a null-owner object in a 360 as its owner, kept or not.
When an object that is left out named it first, the reader dropped the object, though a kept one
held it too, and the save wrote the kept holder's 360 as 0.

hard_owners now lists every object naming it, in file order, and owner_of takes the first of
them that is kept, else the first. The read (retained_objects) and the write liveness pass in
finish run until what they keep settles; a file where no object has two hard owners takes one
pass, as before. The write pass no longer keeps a converted copy of every object's groups.

The test adds an object nothing keeps that names the held record before its holder does: the
held record stays with the holder and the stray object is dropped, DXF and DWG, twice. It fails
before this change ("DXF 1: no record held").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H43qQA41CJLauqXnPgBQ7r
2026-11-08 14:15:03 +00:00
FredApps e56cc4beeb Merge pull request #2917 from mkzung/fix/dwg-application-object-proxies
DWG: another application's objects are kept as proxy objects of their class
2026-11-08 14:52:50 +01:00
SBaksa ead93c6797 Merge remote-tracking branch 'fork/ucs-core' into ucs-drafting 2026-11-08 22:29:33 +11:00
SBaksa c0cc3f8509 UCS View: normalise the view twist and say in the params doc that X follows it 2026-11-08 22:27:14 +11:00
SBaksa ee8922b1d7 UCS View follows the view twist: the X axis is the screen's horizontal (review on #1533) 2026-11-08 22:13:02 +11:00
Luis 7a9ec9bae3 Release: refresh contributor credits for each release (#2880) (#2881)
About > Contributors still showed an old snapshot, because nothing
regenerated contributors/contributors.json before a release. Opt in to
the shared refresh from craft-common-actions: a read-only credits job
regenerates the snapshot for the release commit, and the shared release
workflow installs it before every source build. The snapshot is not
committed back.
2026-11-08 01:44:24 +01:00
mkzungandClaude Opus 5.5 1363afb883 DXF/DWG: an object a kept object holds by a hard owner reference is kept
An object whose owner (group 330) is null but which another kept object
holds by a hard owner reference (group 360), as one application's proxy
object held by another, broke the owner chain the reader and writer follow
to decide what to keep: it was dropped, and the holder kept a reference to
nothing. Such an object's owner is now the object that hard-owns it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H43qQA41CJLauqXnPgBQ7r
2026-11-07 23:32:34 +00:00
mkzungandClaude Opus 5.5 3f9e45f726 DWG: another application's objects are kept as proxy objects of their class
An object of another application's class that acadrust has no model for is
read only as its DWG record (ObjectType::Unknown), which its DXF writer
leaves out. The DWG to DXF bridge lost every such object with no note, and
the references to it went too (an extension dictionary entry naming the
object, say).

Each one is now carried as a proxy object of its class (ACAD_PROXY_OBJECT):
the record is split into its common object data (owner, reactors, extension
dictionary) and the streams after it (data bits, R2007+ strings, object
references), as the Open Design Specification for .dwg describes them. The
references are read to the end of the handle stream (to its exact length
from R2010 on), null ones too: a null reference is an empty field, and the
references after it belong to the next fields. Objects of the drawing
database's own classes, and records that don't split, stay as they were and
are named in a note.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H43qQA41CJLauqXnPgBQ7r
2026-11-07 23:32:34 +00:00
vangel76andClaude Sonnet 5.5 5ece420543 docs: XCLIP, existing-MTEXT editing and Vietnamese are shipped; date the 245/491 and 233/491 references
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 18:18:39 +01:00
vangel76 bd37c89ca1 Merge upstream/main into docs/gaps-audit-2026-10-12 2026-11-07 18:17:35 +01:00
vangel76andClaude Sonnet 5.5 62caaa30d9 docs: alpha-gate drafting gap, POLARMODE bit, DWG failsafe boundary, ACIS wording, breadth metric label
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 16:33:15 +01:00
FredApps 486d558a78 Merge pull request #2887 from helenkwok/web/page-api
cadcraft-web: window.cadcraft, the page command API from craft-web-api
2026-11-07 15:36:49 +01:00
Helen Kwok 6304abd8f0 cadcraft: keep the ui.screenshot web note inside the table row 2026-11-07 15:29:59 +08:00
Helen Kwok 07b6b8c53a cadcraft: document that ui.screenshot ignores path in the web build 2026-11-07 10:28:05 +08:00
Helen Kwok 14a6cc3cdc cadcraft-ui-egui: ui.screenshot returns the PNG inline on wasm
Without a path the screenshot was written into a private temp directory, and std::env::temp_dir panics on wasm32 (no file system), which stopped the whole web app: the page's call never got a reply and nothing after it ran. On wasm the PNG now comes back inline (pngBase64, width, height, bytes), as ui.render's does. Native builds are unchanged.
2026-11-07 08:11:48 +08:00
Helen Kwok 85b35fc5b9 cadcraft-web: window.cadcraft, the page command API from craft-web-api
The web shell queues the page's calls as control requests (the channel the desktop control server uses) and answers them on the next frame. PendingReply gains try_reply, so a transport that cannot block can poll it, and cancels a request the app has not started when it is dropped, as a timed-out wait does: the page was told the call failed, so the app skips it. The API is installed in every mode; opening, saving, the file name and the unsaved flag stay with the host messages.
2026-11-07 07:59:36 +08:00
Tanish Manku 865fa9afb0 Merge pull request #2874 from storytold/stack/s3
Stage 1 stack 3: land #2403, #1105, #1002, #1908, #1907, #2134, #2371
2026-11-06 15:33:47 -07:00
Tanish Manku 1452ab6f9f Stack 3: CodeRabbit on #2874: editor limits for braces and deep nesting, OK on a rewritten but unedited text, round-off next to zero in the palette, test folder cleanup 2026-11-06 14:58:21 -07:00
Tanish Manku 0140e275f3 Stack 3: the multileader save test saves as 2007 DXF, where a multileader stays one 2026-11-06 14:33:18 -07:00
Tanish Manku 098fa7fd80 Stack 3: #1105's multileader height field takes #2403's ids as they are 2026-11-06 13:44:57 -07:00
Tanish Manku 32db96f5e3 Stage 1 stack 3: review fixes on #1105, #1002, #1908, #1907, #2134, #2371 2026-11-06 13:35:40 -07:00
Tanish Manku 4e36021812 Merge branch 'stk-2371' into stack/s3
# Conflicts:
#	crates/ui-egui/src/i18n/it.tsv
#	crates/ui-egui/src/i18n/uk.tsv
#	crates/ui-egui/src/options.rs
#	docs/gaps.md
#	docs/ui-parity.md
2026-11-06 13:33:05 -07:00
Tanish Manku fafc9e1910 Merge branch 'stk-2134' into stack/s3
# Conflicts:
#	crates/ui-egui/src/i18n/fr.tsv
#	crates/ui-egui/src/i18n/uk.tsv
#	crates/ui-egui/src/lib.rs
2026-11-06 13:32:34 -07:00
Tanish Manku a42760af80 Merge branch 'stk-1907' into stack/s3
# Conflicts:
#	docs/customization.md
2026-11-06 13:32:16 -07:00
Tanish Manku b1263ed3a4 Merge branch 'stk-1908' into stack/s3 2026-11-06 13:31:50 -07:00
Tanish Manku 141a1ac8cd Merge branch 'stk-1002' into stack/s3
# Conflicts:
#	crates/engine/src/cmd/modify2/textedit.rs
#	crates/ui-egui/src/mtext_editor.rs
2026-11-06 13:29:50 -07:00
Tanish Manku 42c1dca89d Merge branch 'stk-1105' into stack/s3 2026-11-06 13:29:27 -07:00
Tanish Manku b36d7aea40 Merge branch 'stk-2403' into stack/s3 2026-11-06 13:29:26 -07:00
SBaksa e04ceb2d5d Merge remote-tracking branch 'origin/main' into ucs-drafting 2026-11-07 02:55:03 +11:00
SBaksa 81b3e6ba08 Merge ucs-core and origin/main into ucs-drafting
Keep the checked grid ranges and view-twist rendering from main, with the UCS snap frame and UCS axes applied on top. Preserve the extreme-view regression test.
2026-11-07 02:55:02 +11:00
FredApps a655cee0c1 Merge pull request #2850 from storytold/house-rules
Copy the shared house rules into AGENTS.md
2026-11-06 14:59:06 +01:00
SBaksa 78506d3bd2 Merge origin/main into ucs-core 2026-11-06 23:54:26 +11:00
SBaksa d8d5041d75 Merge remote-tracking branch 'origin/main' into lisp-block-entities 2026-11-06 23:53:22 +11:00
SBaksa c13976c657 Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-11-06 23:53:21 +11:00
SBaksa 03f9139344 Merge branch 'ucs-core' into ucs-drafting 2026-11-05 16:06:22 +11:00
SBaksa 9cfe8a6daa UCS: ssget windows match SELECT; origin default in a tilted UCS, formatted; named World UCS delete (review)
ssget W/C go back to the world box around the converted corners, as SELECT's
window is. The origin default tested input_ucs() (always planar) instead of
the current UCS, so the tilted branch never ran; it also printed raw floats
and -0, now formatted like other numbers. Deleting the named World UCS of a
layout left Some(world); it is None again. DIST's ucs params doc says which
frame it is. Tests for each.
2026-11-05 16:06:14 +11:00
SBaksa 3c135760b5 Merge remote-tracking branch 'origin/main' into lisp-block-entities 2026-11-05 15:56:38 +11:00
SBaksa e1d3520c9e Merge remote-tracking branch 'origin/main' into lisp-block-entities 2026-11-05 15:56:38 +11:00
SBaksa 7ffabe0fc0 Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-11-05 15:56:37 +11:00
SBaksa 4f57426bad Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-11-05 15:56:36 +11:00
SBaksa 41f1496f7d Merge branch 'ucs-core' into ucs-drafting 2026-11-05 15:05:14 +11:00
SBaksa 67124500c6 UCS: read the VPORT UCSICON setting in its own function (clippy complexity) 2026-11-05 15:02:36 +11:00
SBaksa 30e3ae0767 UCS: grid snap reads the frame without the name (review)
grid_frame_in went through ucs::current, which copies the UCS name on every
grid snap; current_frame returns the same frame without it.
2026-11-05 14:39:20 +11:00
SBaksa a284313f27 Merge branch 'ucs-core' into ucs-drafting 2026-11-05 14:39:12 +11:00
SBaksa 026f7d906b UCS: UCSICON in the active VPORT record; DIST keeps world values with a ucs object (review)
The public DXF reference has no UCSICON header variable; the setting is
group 74 of the *ACTIVE VPORT record, so write and read it there. DIST's
top-level angle and deltas are world values again, as ID's are, with the
UCS values its message shows under ucs, computed once.
2026-11-05 14:38:44 +11:00
SBaksa 5b622c3d32 UCS: ssget windows in a turned UCS; UCS Previous after a delete; origin defaults (review)
ssget W/C built a world-aligned box from two converted corners (zero width
at 45 degrees); it now selects with the four converted corners as a polygon.
Deleting the current named UCS pushed the old frame under the deleted name
onto UCS Previous; the name is now cleared there and in every layout's
history. Enter at the 3 Point origin prompt went on to nothing; it keeps the
origin and asks for the X axis. The origin default is shown in the frame
input is read in (world while the UCS is tilted). Tests for each.
2026-11-05 14:38:43 +11:00
mkzung 968b5bd648 Merge remote-tracking branch 'origin/main' into rebase/opaque-proxy-onto-2026-11-05-main 2026-11-05 02:21:44 +00:00
SBaksa 56246049bc UCS: point filters take their coordinates in the UCS (review)
.X/.Y/.XY combined the two points' world coordinates, so in a turned UCS
the result was not the point the user meant. Combine them in the UCS and
convert back. Test point_filters_and_ortho_follow_the_ucs (ortho and
tracking were already done in this PR).
2026-11-05 13:15:29 +11:00
vangel76andClaude Sonnet 5.5 35545af16d Merge upstream/main into docs/gaps-audit-2026-10-12
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-05 02:58:56 +01:00
SBaksa 97f753d6c1 Merge branch 'ucs-core' into ucs-drafting 2026-11-05 12:28:05 +11:00
SBaksa 404988f67a UCS: DIST JSON matches its message; no allocation per angle; origin prompt default (review)
DIST's JSON angle and deltas were world values while its message is in the
UCS; they now match the message and the world values sit under "world".
Session::ucs() went through ucs_named() and allocated the name on every
angle and point; a name-free current_frame() serves it. The origin prompt
showed the world origin although input is read in the UCS; it shows 0,0,0.
Tests: dist_json_matches_its_message_in_a_ucs,
pressing_enter_at_the_origin_prompt_keeps_the_origin.
2026-11-05 12:24:15 +11:00
SBaksa d75bc7fa60 UCS: UCSICON is saved with the drawing; deleting a named UCS clears it everywhere (review)
UCSICON became a drawing setting but the DXF header did not carry it, so
it came back on after a save; write and read it (group 70). The menu toggle
is disabled with no drawing open and no longer fails on doc_mut. UCS NAmed
Delete cleared the name only in the current space; clear it in model space
and every layout. Tests: ucsicon_survives_a_dxf_round_trip,
deleting_a_named_ucs_clears_it_in_every_space.
2026-11-05 12:24:14 +11:00
SBaksa 935e13cc52 UCS: LISP picks, selection points, deferred polar and angtof use the right frame (review)
entsel's pick point passed to (command ...) and ssget's W/C/F/WP/CP/pick
points were read as world points though getpoint/getcorner answer in the
UCS; the deferred-tangent polar text ignored the UCS; angtof depended on it.
Convert UCS to world there, read @d<a through the direction path, and make
angtof use the angle settings without the UCS rotation. Tests for each.
2026-11-05 12:24:02 +11:00
mkzung 876e103488 Merge branch 'rebase/opaque-proxy-onto-2026-11-03-main' into rebase/opaque-proxy-onto-2026-11-05-main 2026-11-05 00:18:23 +00:00
vangel76andClaude Sonnet 5.5 01e28fc0d4 contributors: set names for vangel76
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 02:12:01 +01:00
lforgiariniandClaude Sonnet 5.5 bd639d3204 Properties palette: a text row that holds the separator is shown whole
shown_part took off everything after U+001F, so a Contents or dimension
text with that character was shown cut off and an edit wrote the cut-off
text back. Only a tail that reads as the tagged number is taken off now.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-03 21:31:03 +01:00
ATARYS-LABandClaude Opus 5.5 cce67d27c7 Shortcuts: outside macOS Ctrl and Cmd are one key when checking who has a shortcut
One Ctrl press runs a Ctrl and a Cmd shortcut alike on Windows and Linux, so
two commands could hold Ctrl+K and Cmd+K and only the first would ever run.
same() now compares them as one key there; macOS keeps Control apart.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XkJ8y75DE7yLZ7utxSRDeP
2026-11-03 18:45:14 +01:00
ATARYS-LABandClaude Opus 5.5 d23c5f0182 Keyboard Shortcuts: the Chinese label of its menu item, as main's catalog test asks since #2510
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XkJ8y75DE7yLZ7utxSRDeP
2026-11-03 17:19:34 +01:00
ATARYS-LABandClaude Opus 5.5 789c4e9542 Shortcuts: ui.set checks them as the preferences do, and a malformed preference keeps them
ui.set took any map: bad keys, unknown or fixed commands and keys taken twice
reached the menus. A preference value that isn't an object cleared the
shortcuts instead of being ignored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XkJ8y83ji68FwkuL22Qf4n
2026-11-03 17:19:34 +01:00
ATARYS-LABandClaude Opus 5.5 5aa0e2da9e egui 0.37 ids in the Keyboard Shortcuts dialog: Id::unique, as the rest of the UI
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XkJ8yA6ibQ4twvHAJjDU3d
2026-11-03 17:19:34 +01:00
ATARYS-LABandClaude Opus 5.5 cdbc32ac8f Shortcuts: Cmd+Alt+C/X/V stay clipboard keys; one key per command from prefs
egui-winit turns Cmd+C, X and V into clipboard events whatever else is held,
so Alt variants are refused too. Preferences that give one key to two
commands keep it for the first and drop the other, so no menu shows a
shortcut that runs something else.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DRnJvmr59vS3DS5p2E8FhG
2026-11-03 17:19:34 +01:00
ATARYS-LABandClaude Opus 5.5 7e141247dd Shortcuts: keep a macOS Control key, and Shift+Cmd+C/V stay clipboard keys
A recorded or JSON Ctrl+K (macOS Control) was stored as Cmd+K and Cmd+Ctrl
lost its Control: shortcuts are now written the same on every platform,
Cmd for the command key and Ctrl for a Control that isn't it. Copy with
Base Point and Paste as Block arrive as clipboard events like Copy and
Paste, so their keys can't be given to another command and they keep theirs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DRnJvmr59vS3DS5p2E8FhG
2026-11-03 17:19:34 +01:00
2cbd67f963 Keyboard Shortcuts dialog: any command gets a shortcut, and the user's wins
Tools ▸ Customize ▸ Keyboard Shortcuts lists every command with its
shortcut, a filter, and a button to record a new one (click, press the
keys, Esc cancels), Clear, Default and Reset to Defaults. A shortcut the
user gives wins over a built-in one: the command that had it loses it and
the dialog says which; menus show the shortcut in force. Shortcuts are
kept with the preferences (`shortcuts`), hostile entries dropped. JSON
form `ui.shortcuts {set: {command: key or ""}, reset}` never opens the
dialog. Clipboard keys, Delete and Cmd+Q stay as they are.

Recording and the conflict rules come from the storey shortcuts of #1703.

Co-authored-by: Alex-BB44 <273073052+Alex-BB44@users.noreply.github.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DRnJvmr59vS3DS5p2E8FhG
2026-11-03 17:19:34 +01:00
mkzung 56dc397680 DWG: reconcile proxy preservation with current worker and lockfile 2026-11-03 09:19:16 +00:00
mkzung d2052eb4c7 DWG: isolate proxy conversion failures and normalize proxy names 2026-11-03 09:15:24 +00:00
mkzung 0722afc5bd DWG: keep opaque registered entities and their source classes 2026-11-03 09:15:24 +00:00
SBaksa feedca47dc WIP row 71: dynamic-block merge awaits checks and end-to-end validation 2026-11-03 18:24:40 +11:00
SBaksa 2fa8997548 Merge remote-tracking branch 'origin/main' into attdef-justify-style
# Conflicts:
#	crates/engine/src/cmd/blocks.rs
#	docs/parity-checklist.md
2026-11-03 17:33:14 +11:00
SBaksa 8157cd2fc1 Drop the parity checklist change (maintainers regenerate it) 2026-11-03 15:43:33 +11:00
SBaksa f99307f2cd Parity checklist: regenerated after merging main 2026-11-03 15:11:08 +11:00
SBaksa a8be418d8c Merge remote-tracking branch 'origin/main' into ucs-drafting 2026-11-03 14:59:36 +11:00
SBaksa a0c76b6726 Merge branch 'ucs-core' into ucs-drafting 2026-11-03 14:59:35 +11:00
SBaksa 51b3e8b112 UCS: Chinese strings for the UCS menu and fmt after merging main 2026-11-03 14:59:25 +11:00
SBaksa f1790d2be7 Drop the parity checklist change (maintainers regenerate it) 2026-11-03 14:49:47 +11:00
SBaksa deca6b1062 Parity checklist: regenerated after merging main 2026-11-03 14:25:33 +11:00
SBaksa cddef1755b Merge remote-tracking branch 'origin/main' into ucs-core 2026-11-03 14:08:45 +11:00
vangel76andClaude Sonnet 5.5 5ca4b220aa Merge upstream/main into fix/fonts-mtext-hardening
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-02 19:43:32 +01:00
Nicholas Gower b254a28a5e aliases: keep the APPLOAD picker beside the PGP picker on main 2026-11-02 08:38:27 -08:00
Nicholas Gower 168f4a699a Alias Editor: point the web at ALIASEDIT's text parameter (#1900)
Without a native picker the Import… message told users to give ALIASEDIT a
path, but the web has no file system and rejects paths. Name the supported
route instead: the file's contents in ALIASEDIT's text parameter. The
Ukrainian reference translation and the customization docs follow the new
wording; the desktop picker path is unchanged.
2026-11-02 08:37:05 -08:00
Nicholas Gower ff6b0e375b Alias Editor: import an existing .pgp file (#1900) 2026-11-02 08:37:05 -08:00
Nicholas Gower f977b6e7cc docs: leave the parity tables to the maintainers
The affected rows are named in the pull request description, as AGENTS.md asks.
2026-11-02 08:09:44 -08:00
Nicholas Gower c9082d974d aliases: the profile loader accepts a full alias set (#1899)
`MAX_PROFILE_BYTES` (64 KiB) was smaller than a valid profile: ALIASEDIT holds
up to 10,000 aliases, and a serialized full set can be megabytes. On restart
`load_profile` then dropped the whole profile, aliases and unrelated settings
included.

The engine now states the largest alias section `alias_profile` can produce
(`MAX_ALIAS_PROFILE_BYTES`, from the alias count, name and command-id limits,
and the alias file path); the loader's cap is that plus fixed room for the
sysvars and interface preferences. Hostile input over the cap is still
rejected without changing anything.

Tests: a full 10,000-alias profile (620 KB, far past the old 64 KiB) restores
completely, one byte over the new cap is refused, every catalog command id
fits the bound, and the hostile-profile tests now pad past the real cap.
2026-11-02 08:09:17 -08:00
Nicholas Gower fd3a0b9e15 aliases: persist ALIASEDIT aliases in the user profile (#1899)
ALIASEDIT kept its aliases in a process-wide store and nothing saved or
restored them, so they were gone after a restart. The engine now gives
the set and the alias file REINIT reads to the host profile
(alias_profile) and restores them (restore_aliases) in CadApp's
profile_json / load_profile, bounded and safe on a malformed saved set;
command names still win. The Command Aliases dialog says where the
aliases are kept.
2026-11-02 08:09:17 -08:00
lforgiariniandClaude Sonnet 5.5 b8efe39acc fix(ui): Properties palette tells values apart that the display rounds alike
The shared values of several objects were compared as the text each row shows, so a
text height of 7 and one of 7.000001 (both "7.0000") read as one common value. Numeric
rows now carry the number they were formatted from and compare it to 12 significant
digits, which separates anything the display could show at 8 decimals and ignores float
noise.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-01 12:42:12 +01:00
lforgiariniandClaude Sonnet 5.5 b1bab3043c test(ui): Properties palette with several objects: undo, mixed types, one object
Covers the cases a reviewer asked for: one undo restores every edited
object, a mixed selection shows General only (no Radius row), and one
object shows its own value with nothing varying.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-01 09:20:46 +01:00
Cédric Legrand a84de56183 refactor(color): satisfy Clippy pedantic lints 2026-10-31 15:31:08 +01:00
vangel76andClaude Sonnet 5.5 0e949bffe1 Merge upstream/main into docs/gaps-audit-2026-10-12
Resolve the gaps and parity-doc conflicts: keep this branch's re-audit
rows and history, fold in upstream's newer QSAVE and justification
changes, and recount the file tests (88) and catalogs (16).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 11:18:17 +01:00
lforgiariniandClaude Sonnet 5.5 50bc6c1158 fix(ui): Properties palette keeps the polyline Closed value untranslated in its memo
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:38:12 +01:00
lforgiariniandClaude Sonnet 5.5 f8f0504b9a perf(ui): Properties palette keeps the selection's shared values per revision and selection
Working out every shared value on each frame made the palette slow with thousands of
objects selected. The values (and the selected handles' hex ids) are kept in ui.data
until the drawing revision, the selection or the units change. Entity helpers no longer
clone whole hatches, texts or polylines for one field. Tests: a value typed in the
palette reaches every selected object; the shown values follow revision and selection.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:38:12 +01:00
lforgiariniandClaude Sonnet 5.5 6ecabc3451 fix(ui): several block references show the dynamic block's name; gaps.md status line
The Name row of the several-objects Properties palette used the block's own name, which for a
dynamic block is an anonymous `*U..` that differs from one reference to the next. It now resolves
each reference's name as the single-object palette does. docs/gaps.md: status line updated for the
revision entry.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:38:11 +01:00
lforgiariniandClaude Sonnet 5.5 c223550cb3 feat(ui): Properties palette shows the type's properties for several objects of one type
With more than one object selected the palette showed only General. When all selected objects are
of one type (line, circle, arc, text, mtext, polyline, hatch, block reference, dimension) it now
shows that type's properties, `*VARIES*` where they differ; an edit applies to every selected
object. Positions stay read-only, since typing one would move all objects to the same place.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:38:10 +01:00
SBaksa 38933e7f91 Parity checklist: regenerated after merging main 2026-10-31 14:20:50 +11:00
SBaksa 9397db72e6 Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-10-31 14:20:49 +11:00
SBaksa f0c1b4ff29 -ATTDEF: the Justify prompt leaves out Align and Fit, which it refuses; TEXT keeps them (#1720)
-ATTDEF can't take Align or Fit (they need two points), but its Justify prompt listed them
because it shared TEXT's prompt. justify_prompt now filters them out of the one shared option
list for -ATTDEF; typed A or F is still refused. Test:
attdef_justify_prompt_leaves_out_align_and_fit_but_text_keeps_them.
2026-10-31 14:20:48 +11:00
vangel76andClaude Haiku 5.5 ef167c3140 Merge upstream/main into docs/gaps-audit-2026-10-12
Resolve the parity-doc conflicts: take upstream's header lines and newer
catalog rows, and keep this branch's re-audit history rows and the
re-audit line in each header.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-30 23:39:55 +01:00
SBaksa e65132c77a -ATTDEF: the start-point prompt takes [Justify/Style] (#1720)
Typing J or S at the typed -ATTDEF start-point prompt did nothing. The prompt is now
'Specify start point of text or [Justify/Style]' and both options are handled: Justify
shares TEXT's option prompt and the JSON form's code check (Align and Fit refused,
unknown codes refused), Style takes an existing style name with its width factor and
oblique angle and refuses an unknown one the way the JSON form does, each asking again.
Tests: the five typed_* and start_point_prompt tests in attdef_justify_style.rs.
2026-10-30 19:43:43 +11:00
SBaksa 4415f4e5dc Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-10-30 18:32:45 +11:00
SBaksa 28428b0cc3 attdef: a non-string justify or style is an error; the definition takes the style's width factor and oblique (#1720)
justify and style given as a number, boolean or array were read as absent, so the
definition came out left-aligned in the current style. They are now refused. The
definition also kept width factor 1 and oblique 0 whatever the chosen text style said,
and the renderer uses the entity's values; it now copies both from the style.
Tests: a_non_string_justify_or_style_is_refused,
the_definition_takes_the_styles_width_factor_and_oblique.
2026-10-30 15:27:25 +11:00
SBaksa abd72f3f19 xtask: take main's stats.rs (the merge kept a test import Linux clippy rejects) 2026-10-30 14:51:08 +11:00
SBaksa d80c055839 xtask: take main's stats.rs (the merge kept a test import Linux clippy rejects) 2026-10-30 14:51:05 +11:00
SBaksa 7983a25e38 Parity checklist: regenerated after merging main 2026-10-30 13:39:44 +11:00
SBaksa 0b9f1ed74a Merge remote-tracking branch 'origin/main' into attdef-justify-style
# Conflicts:
#	docs/parity-checklist.md
2026-10-30 13:36:32 +11:00
SBaksa 7f590216eb Parity checklist: regenerated after merging main 2026-10-30 13:34:46 +11:00
SBaksa df1e333229 Merge remote-tracking branch 'origin/main' into lisp-block-entities
# Conflicts:
#	docs/parity-checklist.md
2026-10-30 13:31:36 +11:00
SBaksa 7ce2eea0c0 Parity checklist: regenerated after merging main 2026-10-30 13:20:04 +11:00
SBaksa 2616d46ec4 Merge remote-tracking branch 'origin/main' into ucs-drafting
# Conflicts:
#	docs/parity-checklist.md
#	xtask/src/parity.rs
2026-10-30 13:16:54 +11:00
SBaksa adc1876809 Parity checklist: regenerated after merging main 2026-10-30 13:15:13 +11:00
SBaksa 54d6c4eed8 Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	docs/parity-checklist.md
#	xtask/src/parity.rs
2026-10-30 12:42:25 +11:00
SBaksa a06bb18b58 Test: a layout's far named UCS keeps its name only where it is (#1547) 2026-10-30 10:57:53 +11:00
vangel76andClaude Sonnet 5.5 08ea23ec2d geom: tighten region oracle test budget assertions
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-28 23:59:45 +01:00
vangel76andClaude Sonnet 5.5 98b47c1984 perf(geom): limit the spline fit solver to the matrix band
`solve` ran dense Gaussian elimination on a banded matrix. The pivot
scan, the elimination and the back-substitution now stop at the band
measured from the matrix. The skipped operations only combine exact
zeros, so results are bit-identical; the cyclic matrix of a closed fit
has full bandwidth and keeps the full sweep. The old solver stays as a
test-only oracle.

Part of #2432

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-28 23:58:35 +01:00
vangel76andClaude Sonnet 5.5 1f75a9fb25 geom: test region candidate pairs once, in their lowest shared grid cell
The region build kept a SipHash HashSet of tested pairs over a SipHash
HashMap grid. Each pair is now tested only in the lowest grid cell both
segments occupy, and the grid is a flat Vec. The pairs tested, the visit
and distinct-pair budgets and the output are unchanged; the old search is
kept as a test oracle.

Closes #2430

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-28 23:57:30 +01:00
vangel76andClaude Sonnet 5.5 c2175377fd perf(geom): make NURBS derivative allocation-free up to degree 10
derivative_unchecked allocated six Vecs per call and computed the degree
p-1 basis separately although the degree p recurrence passes through it.
Up to degree 10 both bases now come from one sweep into stack buffers;
higher degrees keep the previous heap path. The operations and their order
are unchanged, so results are bit-identical.

The old implementation stays as a test-only oracle, compared bit for bit
over random splines of degree 1 to 12.

Closes #2431

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-28 23:55:20 +01:00
dotCooCoo 23d5918a62 Dimensions: draw the DIMGAP frame over a DIMTFILL background 2026-10-28 14:24:15 -07:00
dotCooCoo 43896056e2 Merge branch 'main' into feat/dimgap-text-frame 2026-10-28 14:19:11 -07:00
Aldo Zarate c1d7e4415b Merge remote-tracking branch 'upstream/main' into feat/mleader-text 2026-10-28 10:10:05 -06:00
Aldo ZarateandClaude Opus 5.5 1e02e6f263 Text editor: relative heights stay relative, long texts are refused, focus stays put
A \H2x; height is written back as \H2x; (relative over the text's own height), so the part
keeps scaling when the text's height changes; an absolute height stays absolute. TEXTEDIT
refuses a text longer than the editor holds instead of opening it cut short, which OK would
have saved. With the text empty the editor takes the focus back only when nothing else has
it, so a click on the height field keeps it there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 10:10:04 -06:00
Aldo ZarateandClaude Opus 5.5 d0ab457f31 Relative height codes kept when a text opens in the editor
\H2x; with no inline height before it scaled nothing and was dropped, so saving a multileader's
(or an MTEXT's) text from the editor lost it. The editor now parses the contents against the
text's own height.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 09:24:29 -06:00
Aldo Zarate eae1fb98bf Merge remote-tracking branch 'upstream/main' into feat/mleader-text 2026-10-28 09:21:31 -06:00
SBaksa 853ca574bd lisp: entget and handent on block entities use the cached block index
The per-drawing index now maps each block entity handle to the entity and its
successor, so entget/handent/entnext are hash lookups instead of scanning every
block. Test: entget_and_handent_reach_every_block_entity_also_after_a_redefinition.
2026-10-28 23:23:09 +11:00
SBaksa 9938d5aa0e Parity checklist: regenerated after merging main 2026-10-28 19:04:30 +11:00
SBaksa a3b81b6ac2 ui-egui: drop unused imports in canvas/grid.rs 2026-10-28 18:58:54 +11:00
SBaksa 2cfd068c1f ui-egui: explicit imports in canvas/grid.rs (clippy wildcard_imports) 2026-10-28 18:51:59 +11:00
SBaksa 744e99cafd lisp: entnext through block entities uses a cached successor index
Replaces the per-call scan of every block (containment) and of the block's
entities (successor) with a per-drawing hash map built once, invalidated when
ENDBLK redefines a block.
2026-10-28 18:50:56 +11:00
SBaksa 9c862c01ba Parity checklist: regenerated after merging main 2026-10-28 18:43:00 +11:00
SBaksa 37a8c6e036 Merge branch 'ucs-core' into ucs-drafting
# Conflicts:
#	crates/ui-egui/src/canvas.rs
#	crates/ui-egui/src/canvas/grid.rs
2026-10-28 18:36:51 +11:00
SBaksa 07a78159e4 Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	crates/io/src/dxf_read/tables.rs
#	crates/io/src/dxf_write/layout.rs
#	crates/io/src/dxf_write/sections.rs
#	crates/ui-egui/src/canvas.rs
#	crates/ui-egui/src/chrome.rs
#	crates/ui-egui/src/menus.rs
#	docs/parity-checklist.md
2026-10-28 18:23:43 +11:00
Aldo Zarate c35d18e803 Merge remote-tracking branch 'upstream/main' into feat/mleader-text
# Conflicts:
#	crates/engine/src/cmd/props.rs
2026-10-27 19:04:13 -06:00
Francesco BVandClaude Opus 5.5 811bd3cb4e Options: Right-Click Customization (click duration; Default, Edit and Command modes) (F20)
Options > User Preferences > Right-Click Customization... sets the
time-sensitive right-click and its duration (rightClickDuration, 100-2000 ms),
what a right-click does with nothing or something selected and no command
running (rightClickDefault, rightClickEdit: the shortcut menu or repeat the
last command), and, with the time-sensitive right-click off, while a command
runs (rightClickCommand: the menu, Enter, or the menu only when the prompt has
options). The defaults keep today's behaviour; the settings are kept in the
profile.

context_menu::show repeats Session::last_command in Repeat mode, and
in_command uses the configured hold time and Command mode.

Italian and Ukrainian strings; gaps F20 and ui-parity updated.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-27 21:30:24 +01:00
vangel76andClaude Sonnet 5.5 603e1acaf9 Merge upstream/main into docs/gaps-audit-2026-10-12
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 20:13:08 +01:00
SBaksa 98a05c66f9 Parity checklist: regenerated after merging main 2026-10-27 19:59:02 +11:00
SBaksa 3e0de6246f ATTDEF: reach justify through draw's re-export now that draw.rs is split 2026-10-27 19:57:10 +11:00
SBaksa 9f71170368 Parity checklist: regenerated after merging main 2026-10-27 19:45:51 +11:00
SBaksa 4abc2dee5b Merge remote-tracking branch 'origin/main' into lisp-block-entities 2026-10-27 19:24:48 +11:00
SBaksa 4ca8136379 Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-10-27 19:24:47 +11:00
SBaksa 9419abb274 Merge branch 'ucs-core' into ucs-drafting
# Conflicts:
#	crates/engine/src/cmd/annotate.rs
#	crates/engine/src/lib.rs
#	crates/io/src/dxf_read.rs
#	crates/ui-egui/src/canvas.rs
2026-10-27 18:29:01 +11:00
SBaksa 5dd37f917f Merge remote-tracking branch 'fork/ucs-drafting' into ucs-drafting
# Conflicts:
#	crates/io/src/dxf_read.rs
#	crates/ui-egui/tests/cursor_contrast.rs
#	docs/gaps.md
#	docs/parity-checklist.md
2026-10-27 18:25:05 +11:00
SBaksa 4a4012d22f Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	crates/engine/src/lib.rs
#	crates/io/src/dxf_read.rs
#	crates/io/src/dxf_write.rs
#	crates/ui-egui/src/canvas.rs
2026-10-27 18:24:37 +11:00
SBaksa fb5f68328d Merge remote-tracking branch 'fork/ucs-core' into ucs-core
# Conflicts:
#	crates/io/src/dxf_read.rs
#	crates/ui-egui/tests/cursor_contrast.rs
#	docs/gaps.md
#	docs/parity-checklist.md
2026-10-27 17:53:57 +11:00
Claude d204518d8a Regenerate the parity checklist (cargo xtask parity) 2026-10-27 03:04:43 +00:00
Claude 25014b77b8 Regenerate the parity checklist (cargo xtask parity) 2026-10-27 03:04:41 +00:00
Aldo Zarate 5585298128 Merge remote-tracking branch 'upstream/main' into feat/mleader-text
# Conflicts:
#	crates/engine/src/cmd/modify2.rs
#	crates/ui-egui/src/canvas.rs
2026-10-26 19:45:50 -06:00
Aldo Zarate e67de34cf0 Merge remote-tracking branch 'upstream/main' into feat/dblclick-edit
# Conflicts:
#	crates/engine/src/cmd/modify2.rs
2026-10-26 19:45:47 -06:00
Claude e98201c282 Format the merged dimension calls 2026-10-27 01:33:47 +00:00
Claude 97f889733d Hide the UCS icon in the cursor contrast test through UCSICON 2026-10-27 01:33:26 +00:00
Claude 3f347ea431 Merge branch 'ucs-core' into ucs-drafting 2026-10-27 01:33:26 +00:00
Claude a44308f4aa Merge branch 'ucs-core' into ucs-drafting
# Conflicts:
#	crates/engine/src/cmd/annotate.rs
#	crates/ui-egui/src/canvas.rs
2026-10-27 01:11:43 +00:00
Claude f6e56d97f6 Merge remote-tracking branch 'upstream/main' into ucs-core
# Conflicts:
#	crates/engine/src/lisp/mod.rs
#	crates/engine/src/sysvars.rs
#	crates/io/src/dxf_read.rs
#	crates/io/src/dxf_write.rs
#	crates/ui-egui/src/canvas.rs
#	crates/ui-egui/src/viewcube.rs
#	docs/file-format-parity.md
#	docs/gaps.md
#	docs/parity-checklist.md
2026-10-27 01:10:51 +00:00
SBaksa 940e3de914 Merge branch 'ucs-core' into ucs-drafting 2026-10-27 11:31:08 +11:00
SBaksa b29a1398a4 Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	crates/io/src/dxf_read.rs
2026-10-27 11:31:07 +11:00
SBaksa 372be8db01 Merge remote-tracking branch 'origin/main' into lisp-block-entities 2026-10-27 11:29:47 +11:00
SBaksa 3c0c5b1f61 Merge remote-tracking branch 'origin/main' into attdef-justify-style 2026-10-27 11:29:46 +11:00
SBaksa 4346beec72 Format annotate.rs after merging main 2026-10-26 12:07:19 +11:00
SBaksa f8f81b431d cursor_contrast test: turn the UCS icon off through UCSICON, which replaced UiState::show_ucs_icon 2026-10-26 12:07:16 +11:00
SBaksa 3711c8c762 Merge branch 'ucs-core' into ucs-drafting 2026-10-26 12:07:16 +11:00
SBaksa e660b0dbe4 Parity checklist: regenerated after merging main 2026-10-26 12:01:42 +11:00
SBaksa b077e22f40 Parity checklist: regenerated after merging main 2026-10-26 11:46:25 +11:00
SBaksa 33aaf7096c Merge branch 'ucs-core' into ucs-drafting
# Conflicts:
#	crates/engine/src/cmd/annotate.rs
#	crates/ui-egui/src/canvas.rs
2026-10-26 11:39:28 +11:00
SBaksa baf1889912 Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	crates/engine/src/lisp/mod.rs
#	crates/engine/src/sysvars.rs
#	crates/io/src/dxf_write.rs
#	crates/ui-egui/src/canvas.rs
#	crates/ui-egui/src/viewcube.rs
#	docs/file-format-parity.md
#	docs/gaps.md
#	docs/parity-checklist.md
2026-10-26 11:37:32 +11:00
SBaksa f67e5ccd38 Merge remote-tracking branch 'origin/main' into lisp-block-entities
# Conflicts:
#	crates/engine/src/lisp/tests.rs
#	docs/autolisp.md
2026-10-26 11:11:11 +11:00
vangel76andClaude Sonnet 5.5 ec37f02f46 Merge upstream/main into docs/gaps-audit-2026-10-12
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-26 00:56:01 +01:00
Aldo ZarateandClaude Opus 5.5 f02ac726ba MTEXT editor: a state kept for another MTEXT is not reused
The editor's state was kept between frames and only dropped by a frame with no text prompt, so
TEXTEDIT moving to the next MTEXT within one frame (Enter, then a point) opened it with the first
one's text, and OK wrote that text to it. The state now remembers the MTEXT it was made for (its
insertion point and contents when it opened) and is made afresh for another.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 16:53:24 -06:00
Aldo ZarateandClaude Opus 5.5 f892a6f60d Merge upstream/main into feat/mleader-text
Keeps main's accessible name for the MTEXT editor with the focus taken on the first frame, and
the multileader text field uses scope_id like main's other Properties fields (egui update).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 09:05:01 -06:00
Aldo ZarateandClaude Opus 5.5 0934a629e6 Merge upstream/main into feat/dblclick-edit
Keeps main's accessible name for the MTEXT editor's text box with the focus taken on the first
frame; main's new editor tests build State with `focused`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 08:53:58 -06:00
vangel76andClaude Sonnet 5.5 22c6b398fd Merge upstream/main into docs/gaps-audit-2026-10-12
Conflicts in docs/gaps.md and docs/target-app-parity.md resolved by keeping both
sides' log rows and headers; docs/parity-checklist.md taken from main (generated).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:22:12 +01:00
dotCooCoo 800b0319ac Dimensions: a negative DIMGAP draws a frame around the dimension text
CADCraft used only the size of DIMGAP, so a negative value (Draw Frame
Around Text on the Text tab of the Dimension Style Manager) placed the text
like a positive one and drew no frame. A dimension whose DIMGAP is below 0
now draws a rectangle around its text: the text box widened by |DIMGAP| on
every side, turned with the text, as four dimension lines in DIMCLRD. On an
arc-length dimension with DIMARCSYM 1 the frame also takes in the arc
symbol over the text. The frame is one of the dimension's lines, so the
screen, plots and PDF draw it, the dimension's *D block holds it, and
EXPLODE turns it into four LINEs. No help page says how this frame combines
with a DIMINSPECT frame; CADCraft draws an inspection frame with round or
angular ends in place of the DIMGAP frame.

The arc symbol over the text now turns with a DIMTEDIT text angle. It was
placed at the angle from before the override, so the text turned and the
symbol did not.
2026-10-24 19:17:58 -07:00
vangel76andClaude Sonnet 5.5 609148a444 Merge upstream/main into docs/gaps-audit-2026-10-12 and re-audit against main 41d9b5e95
Conflicts in file-format-parity, localization-parity, target-app-parity and
ui-parity resolved by starting from upstream and keeping only the audit
claims that still hold on main. Re-measured: catalog row counts and English
fallback counts for all fifteen catalogs, io test count (86), geometry test
counts, open PR and issue counts, acadrust version (0.6.5). Corrected rows
that main has overtaken: CI gate on pull requests (#1987), MVIEW Restore
(#633), PDF plot margins, selection cycling, Korean/Greek/Hungarian/Turkish
catalogs in the language table. Regenerated docs/parity-checklist.md with
cargo xtask parity.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 14:49:55 +02:00
SBaksa 6125f57084 Merge upstream updates into ucs-drafting and keep Windows checks passing 2026-10-24 15:37:18 +11:00
SBaksa 3203a607e2 Merge upstream main into ucs-core and fix Windows tooling tests 2026-10-24 14:51:53 +11:00
Aldo ZarateandClaude Opus 5.5 2830c7c176 Merge upstream/main into feat/mleader-text
The multileader text test moves into tests/it (one test binary per crate, #1989).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 11:41:26 -06:00
Aldo Zarate a841f225cf Merge remote-tracking branch 'upstream/main' into feat/mleader-text 2026-10-23 11:39:14 -06:00
SBaksa ef4bb85059 Merge branch 'ucs-core' into ucs-drafting 2026-10-23 10:53:57 +11:00
SBaksa 5da9d3f539 Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	crates/io/src/dxf_write.rs
2026-10-23 10:53:52 +11:00
SBaksa 9e022cf31c AutoLISP: read block definitions: tblsearch BLOCK gives the first entity (-2), entnext and entget walk a block's entities (part of #1700)
A routine couldn't reach the entities of a block definition, so the text
a dimension's *D block stores (which CADCraft keeps and draws) was out of
reach. tblsearch "BLOCK" now gives the first entity in -2, entnext goes
from one entity of a definition to the next (nil after the last), entget
lists them without a layout (410), and handent finds them. entmod and
entdel still leave definitions alone.
2026-10-22 00:46:28 +11:00
SBaksa 3e42b346ff ATTDEF: refuse Align and Fit, which need two points; test the current style with a non-Standard one
Review follow-up on #1720: justify A or F gave a definition with a
zero-length span (attdef takes one point), so they are refused with an
error now; the omitted-style test also runs with ROMANS current, so a
run that always picked Standard fails it.
2026-10-20 23:49:15 +11:00
SBaksa afcb6aa743 ATTDEF: justify and style parameters, as TEXT and MTEXT take them (fixes #1658)
attdef always made a left/baseline definition in the current text style,
so a centred or right-aligned title-block attribute needed an entmod.
It now takes justify (TEXT's codes, via draw::justify; any but Left keeps
the point as the alignment point) and style (a text style name, any
case). An unknown code or style is refused; without them nothing changes.
2026-10-20 21:01:57 +11:00
SBaksa 72add0b90e Merge branch 'ucs-core' into ucs-drafting 2026-10-20 12:09:55 +11:00
SBaksa a0e023d758 Angles: shown and entered directions are measured in the current UCS
AngleSettings::shown and ::unshown (the Properties and Quick Properties
palettes' Rotation) now measure from the current UCS's X axis, as typed
directions are read: in a turned UCS what is typed as 0 shows as 0, and
an entered 0 is that same direction. Unchanged in the World UCS.
2026-10-20 12:09:54 +11:00
SBaksa 44547941cc Merge branch 'ucs-core' into ucs-drafting
# Conflicts:
#	crates/engine/src/lib.rs
#	docs/ui-parity.md
2026-10-20 11:21:21 +11:00
SBaksa 99e3b93bd5 Merge remote-tracking branch 'origin/main' into ucs-core
# Conflicts:
#	crates/engine/src/cmd/inquiry.rs
#	crates/engine/src/cmd/mod.rs
#	crates/io/src/dxf_write.rs
#	crates/ui-egui/src/canvas.rs
#	crates/ui-egui/src/i18n/uk.tsv
#	docs/file-format-parity.md
#	docs/gaps.md
#	docs/parity-checklist.md
2026-10-20 11:18:24 +11:00
vangel76andClaude Sonnet 5.5 6549b97b6c Merge upstream/main into docs/gaps-audit-2026-10-12
Resolve doc conflicts in favour of upstream's newer rows; refresh open-PR count, file test count and catalog list.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 01:05:12 +02:00
SBaksa b692cbe0dd Merge branch 'ucs-core' into ucs-drafting 2026-10-20 01:06:05 +11:00
SBaksa 99b7dc808f UCS names in DXF: one rule everywhere, tight at any distance, and the active VPORT names it
- A UCS name is kept, read or written, only while the current frame is
  that record's (dxf_ext::named_ucs): a $UCSNAME or a layout's group 345
  read from a file naming a UCS with another frame is dropped, the frame
  kept unnamed.
- The origin matches to printing round-off only (1e-9 + 1e-14 of the
  value), so a 0.5 move at 1e12 is a different UCS.
- The active VPORT carries group 345 for model space's named UCS (its
  handle filled in once the UCS table has one).
- The undo test checks redo of UCS Previous before a new command clears
  the redo stack.
2026-10-20 01:06:04 +11:00
SBaksa fed42f45b2 Merge branch 'ucs-core' into ucs-drafting 2026-10-19 21:57:47 +11:00
SBaksa be56597e5f UCS in DXF: one axis rule for reading and writing, a tight origin match, layout names only while they fit
- A named UCS's origin is matched to printing round-off only (relative
  1e-12), so far from the World origin a real move is a different UCS.
- Layout UCS axes are written by the rule the reader accepts them by
  (dxf_ext::usable_axes): short but square axes no longer become the
  World UCS's on save.
- A layout's group 345 (its named UCS) is written only while the layout's
  frame is still that record's, as for model space.
2026-10-19 21:57:47 +11:00
SBaksa 1350e1b18f Merge branch 'ucs-core' into ucs-drafting 2026-10-19 15:27:52 +11:00
SBaksa d7de5ccdf3 UCS: write model space's UCS name only while the UCS is still that named frame
A $UCSNAME beside an origin or axes that differ from its UCS table record
was written back as the current named UCS, so restoring that name later
would move the UCS. The writer now keeps the name only when the current
frame is the record's, by the same rule the reader uses to restore it
(dxf_ext::is_named_frame, now shared).
2026-10-19 15:27:51 +11:00
SBaksa 0bf32bba90 Merge branch 'ucs-core' into ucs-drafting 2026-10-19 14:44:42 +11:00
SBaksa 821b8ad18c UCS: UCSICON is undoable, one message per failed menu pick, no stray UCS name in DXF
- UCSICON gets its own undo step, as SETVAR does: it lives in the drawing,
  so undoing the edit before it put the old icon setting back.
- A failed pick in the coordinate-system menu is reported once (CadApp::run
  already echoes it).
- Model space's UCS name is written to DXF ($UCSNAME and CADCraft's copy)
  only for a UCS the drawing has, beside the axes it came with.
2026-10-19 14:44:41 +11:00
SBaksa 5cfe5f84b0 Merge branch 'ucs-core' into ucs-drafting 2026-10-19 12:07:55 +11:00
SBaksa e3aeff2a9b UCS: review fixes (UCSAXISANG 30, icon placement and hits, LISP preview, Previous history)
- UCSAXISANG accepts 30.
- The UCS icon at the corner is placed by its turned arms' bounds, so it
  stays on the canvas at any angle, and takes clicks only near its arms
  rather than anywhere in their boxes.
- getpoint/getcorner previews start at the routine's base point in the
  world (it is a UCS point) and getcorner's rectangle runs along the UCS.
- UCS Previous history lives in the drawing (never written to a file):
  model space's on the Drawing, each layout's on its Layout. Undo and redo
  restore it with the UCS, it follows a layout rename, and goes with a
  delete.
- The hostile layout UCS test really tests parallel axes, accepts a
  refused file, and saves and reopens what it reads.
2026-10-19 12:07:55 +11:00
SBaksa 3f14431a33 UCS drafting: grid lines and tracking tooltip angle as tested helpers
The drawn rectangular grid comes from snap::iso::rect_grid_lines, which
shares the isometric grid's line families (clipped to the view, capped at
MAX_GRID_LINES), and the tracking tooltip angle from tooltip_angle; both
now have tests. Ortho with isometric snap reuses the cursor's settings
instead of cloning all of Settings again on every mouse move.
2026-10-19 02:08:10 +11:00
SBaksa 9f833f3d16 UCS: ortho, snap, grid, polar and object snap tracking, and DIMLINEAR follow the current UCS (part of #1106)
The drafting aids worked along the world axes whatever the UCS; now they
work along the current UCS's.

- Ortho (and direct distance entry with it, and TK tracking) along the
  UCS axes; the isometric axes turn with the UCS. Settings::ucs_angle,
  filled in by drafting_settings(), carries the UCS rotation.
- Grid and grid snap in the UCS: SNAPBASE is a UCS point and SNAPANG an
  angle from its X axis (snap::grid_frame_in). The rectangular grid is
  drawn in that frame, so it also honours SNAPANG and SNAPBASE now (its
  snap already did); the red and green axes are the UCS's.
- Polar tracking measured from ANGBASE off the UCS X axis; object snap
  tracking's orthogonal paths along the UCS axes; the tracking tooltip
  reads the angle in the UCS.
- DIMLINEAR horizontal and vertical (automatic and the keywords) along
  the UCS axes at the command line; JSON stays in world coordinates.
- Ortho at the cursor keeps the full drafting settings (isometric snap
  steps), not the copy grid snap hands back.

Tests: ortho through the cursor and direct distance entry, grid snap and
the grid frame with SNAPBASE/SNAPANG, polar tracking and the tracking
configuration, isometric axes, DIMLINEAR, and the World UCS unchanged.
2026-10-18 13:27:36 +11:00
SBaksa 4fee981bd4 Merge remote-tracking branch 'origin/main' into ucs-core 2026-10-18 12:11:22 +11:00
SBaksa bc7357ffb8 UCS: the UCS command, and points, angles and coordinates in the current UCS (part of #1106)
A current user coordinate system, per space: model space's in the header
(UCSORG, UCSXDIR, UCSYDIR, UCSNAME), each layout's on the layout. The
drawing stays in world coordinates; a UCS changes how points are read and
shown, so drawing and regenerating cost nothing more.

- UCS: origin, then points on the X axis and the XY plane (the default),
  World, Previous (ten per space), NAmed (Restore, Save, Delete, ?), OBject
  (lines, arcs, circles, polylines, points, text, blocks, 2D solids, 3D
  faces, dimensions), View and Z (UCSAXISANG). X, Y, ZAxis and Face tilt the
  UCS out of the XY plane and say they are not available yet. Tools > New
  UCS > World / Origin / 3 Point / View / Z. A UCS change is undone as an
  edit is.
- Typed points are read in the UCS: x,y from its origin along its axes,
  @dx,dy along its axes, polar angles from its X axis, # absolute in the
  UCS, * and @* world. Every direction prompt (and ANGBASE) is measured
  from the UCS X axis; sizes of angles aren't affected. JSON parameters stay
  in world coordinates.
- Dynamic Input reads and shows its values in the UCS; the status bar, ID
  and DIST show coordinates in it (their JSON results keep world values).
- UCSNAME, UCSORG, UCSXDIR, UCSYDIR, WORLDUCS (read-only), UCSAXISANG and
  UCSICON. UCSICON ON/OFF/Noorigin/ORigin; the icon turns with the UCS, sits
  at its origin when that fits on screen, and has the square only in the
  World UCS. View > UCS Icon > Origin. The ViewCube pill shows the UCS name
  and its menu restores World or a named UCS. The icon takes clicks only at
  the Command prompt, so snaps at the origin reach the drawing.
- AutoLISP: getpoint, getcorner, entsel and getangle answer in the UCS,
  command takes UCS points, trans converts between the WCS, the UCS,
  display coordinates and an object's OCS; entity lists stay in WCS.
- Files: model space's UCS in the header and the shown VPORT (110-112),
  each layout's in its LAYOUT object (13, 16, 17, 345 for a named UCS),
  through DXF and DWG. The DWG bridge drops $UCSNAME: a CADCraft XRECORD
  keeps it, used only while the UCS still is that named one. Broken values
  aren't written back.
- A UCS tilted out of the XY plane read from a file is kept and saved as it
  is; points are read in the World UCS meanwhile, and the user is told once.

Tests: engine (command, every option, previous, named, object rules, undo,
paper space, typed input, directions, displays, variables, UCSICON, tilted,
hostile), LISP (trans, getpoint, command, getangle), files (DXF, DWG twice,
named layout UCS, stale name copy, tilted, broken, hostile), Dynamic Input
and the icon.
2026-10-18 12:06:13 +11:00
vangel76andClaude Sonnet 5.5 1d29b626e6 fix(fonts): MTEXT \W...x multiplies the width factor; document the atom cap (#1272)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-14 23:49:56 +02:00
Aldo ZarateandClaude Opus 5.5 cab962a7cb Let multileader text be edited (double-click, TEXTEDIT, Properties)
Double-clicking a multileader's text now opens the in-place editor, the
same as MTEXT. TEXTEDIT accepts a multileader and edits its MText
contents (newlines round-trip as \P). The Properties palette shows a
Contents field and a Text height field for a multileader with text, and
properties.set writes them back.

Fixes #1081.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-13 20:21:59 -06:00
vangel76andClaude Sonnet 5.5 101397d9c5 fix(fonts): MTEXT keeps the text after an unterminated code; bound oblique, line spacing and relative heights (#1035)
- \U+hhhh (with surrogate pairs; a lone surrogate gives U+FFFD) and \M+nhhhh are
  decoded before plain_mtext, the layout parser and Paragraphs::scan read the
  contents. An unknown code without an argument now drops only the backslash and
  the code character instead of everything up to the next ';'.
- layout_mtext_with: a non-finite oblique is 0; line spacing is 1 when not finite
  and positive, and clamped to 0.25..=4 (also in the paragraph layout).
- Relative \H...x heights stay within 1e-3..1e3 times the MTEXT height.
- cadcraft-fonts depends on cadcraft-dxf (L0) for the \M+ code page tables;
  mif_escape_at is public for that.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 21:50:47 +02:00
vangel76andClaude Sonnet 5.5 c32c0f5e30 fix(fonts): paragraph direction skips bidi isolates; harakat no longer block the Lam-Alef ligature (#1033)
base_rtl now ignores strong characters between an isolate initiator and its PDI (or the end, when unmatched), per UBA P2. presentation_forms looks past combining marks for the Alef after a Lam and emits the marks after the ligature.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 21:48:35 +02:00
vangel76andClaude Sonnet 5.5 950453c7fd docs: re-audit gaps.md and the parity docs against main e707ab4d
Redo of the earlier audit after ~100 PRs landed on 2026-10-13. Every change
cites a merged PR, a file or a count taken from the code; claims that could
not be verified are left as they were. Percentages and hours are not
re-scored (listed in the PR description).

Corrected: REFEDIT (#818), dynamic block references (#838-#883), Block
Editor, MLEADEREDIT/ALIGN/COLLECT (#816), in-place MTEXT editor (#792),
AutoLISP (#855), MVIEW Restore and model-space PDF margins (#633),
SpaceMouse 2D navigation (#650), ACIS data kept on save (#781),
attribute modes (#876), polyline offset bulges (#825), acadrust 0.6.4
(#859), twelve interface catalogs with re-measured row counts, closed
winit PRs #110-#119, PR/issue counts and test counts, and ui-parity rows
that earlier work had already closed.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 20:15:38 +02:00
Aldo ZarateandClaude Opus 5.5 7003c5b930 TEXTEDIT on an MTEXT opens it in the in-place editor (part of #842)
Double-clicking an MTEXT (#868) starts TEXTEDIT, which only asked for
the new text on the command line, with its formatting codes. Now TEXTEDIT
on an MTEXT reports it as the text being edited, so the in-place editor
(#792) opens on it with its text and formats; OK writes the edited
contents back, and TEXTEDIT goes on asking for objects as before. An
editor emptied while editing keeps the text, as an empty answer does.

The editor also takes keyboard focus when it opens on existing text,
with the caret at the end: it only did so for an empty box, so typing
into an existing text went to the command line.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-13 10:50:32 -06:00
395 changed files with 31016 additions and 9144 deletions
+2 -36
View File
@@ -23,39 +23,5 @@ jobs:
uses: storytold/craft-common-actions/.github/workflows/nix.yml@main
git-sources:
name: Git dependencies come from storytold
runs-on: ubuntu-latest
timeout-minutes: 5
steps:
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- name: Git dependencies come from storytold
run: |
set -euo pipefail
test -f Cargo.lock || { echo "Cargo.lock is missing"; exit 1; }
# Source replacement, patches and path overrides in cargo config never show up
# in Cargo.lock. Parsed rather than grepped: TOML has many spellings of one key.
# Cargo still reads the legacy .cargo/config.
python3 - <<'PY'
import os, sys, tomllib
for path in (".cargo/config", ".cargo/config.toml"):
if not os.path.exists(path):
continue
config = tomllib.load(open(path, "rb"))
replaced = [name for name, source in config.get("source", {}).items()
if isinstance(source, dict) and "replace-with" in source]
if replaced or "patch" in config or "paths" in config:
print(f"{path} replaces, patches or overrides a source")
sys.exit(1)
PY
# Fails when Cargo.lock is out of date with the manifests.
cargo metadata --locked --format-version 1 > /dev/null
python3 - <<'PY'
import sys, tomllib
lock = tomllib.load(open("Cargo.lock", "rb"))
bad = sorted({p["source"] for p in lock.get("package", [])
if p.get("source", "").startswith("git+")
and not p["source"].startswith("git+https://github.com/storytold/")})
if bad:
print("Git dependencies outside github.com/storytold:", *bad, sep="\n")
sys.exit(1)
PY
# Tracks @main so suite-wide CI fixes reach every app without a PR in each repository.
uses: storytold/craft-common-actions/.github/workflows/git-sources.yml@main
+4
View File
@@ -27,6 +27,10 @@ jobs:
name: Windows installation policy (no app build)
runs-on: windows-latest
steps:
- name: Harden runner
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
with:
egress-policy: audit
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
with:
persist-credentials: false
+11 -37
View File
@@ -1,6 +1,10 @@
name: Release
on:
# A nightly dry run on main: every release build except macOS, nothing signed or released
# (craft-common-actions release.yml `dry-run`). Finds release-only breakage before release day.
schedule:
- cron: "8 1 * * *"
push:
branches: [release]
workflow_dispatch:
@@ -18,47 +22,15 @@ concurrency:
cancel-in-progress: false
jobs:
git-sources:
name: Git dependencies come from storytold
runs-on: ubuntu-latest
# Regenerates contributors/contributors.json for the release commit; every build bundles it.
credits:
permissions:
contents: read
steps:
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- name: Git dependencies come from storytold
run: |
set -euo pipefail
test -f Cargo.lock || { echo "Cargo.lock is missing"; exit 1; }
# Source replacement, patches and path overrides in cargo config never show up
# in Cargo.lock. Parsed rather than grepped: TOML has many spellings of one key.
# Cargo still reads the legacy .cargo/config.
python3 - <<'PY'
import os, sys, tomllib
for path in (".cargo/config", ".cargo/config.toml"):
if not os.path.exists(path):
continue
config = tomllib.load(open(path, "rb"))
replaced = [name for name, source in config.get("source", {}).items()
if isinstance(source, dict) and "replace-with" in source]
if replaced or "patch" in config or "paths" in config:
print(f"{path} replaces, patches or overrides a source")
sys.exit(1)
PY
# Fails when Cargo.lock is out of date with the manifests.
cargo metadata --locked --format-version 1 > /dev/null
python3 - <<'PY'
import sys, tomllib
lock = tomllib.load(open("Cargo.lock", "rb"))
bad = sorted({p["source"] for p in lock.get("package", [])
if p.get("source", "").startswith("git+")
and not p["source"].startswith("git+https://github.com/storytold/")})
if bad:
print("Git dependencies outside github.com/storytold:", *bad, sep="\n")
sys.exit(1)
PY
pull-requests: read
uses: storytold/craft-common-actions/.github/workflows/refresh-contributors.yml@main
release:
needs: git-sources
needs: credits
permissions:
# The reusable release workflow tags and uploads the draft release.
contents: write
@@ -66,10 +38,12 @@ jobs:
# Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
uses: storytold/craft-common-actions/.github/workflows/release.yml@main
with:
dry-run: ${{ github.event_name == 'schedule' }}
app-name: cadcraft
app-title: CADCraft
craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
version: ${{ inputs.version }}
contributors-artifact: ${{ needs.credits.outputs.artifact-name }}
secrets:
APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+4
View File
@@ -114,3 +114,7 @@ People trust CADCraft with their drawings; a crash loses their work. **This outr
- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
## Shared libraries
Before adding or changing file-format, codec, protocol, or reusable UI code, check `storytold/craft-libs` and its open PRs first; reuse or extend the shared library rather than duplicating it locally, keep app-specific policy and model mapping in the app, and preserve behavior, security/resource limits, attribution, and regression coverage during cutovers.
+3 -1
View File
@@ -23,6 +23,7 @@ Generated-in-code assets are original and have no file to list:
| Asset | Author | Source | Licence | Notes |
|---|---|---|---|---|
| `licenses/jpeg-encoder-0.6.1/` | jpeg-encoder contributors and Independent JPEG Group | [jpeg-encoder 0.6.1](https://crates.io/crates/jpeg-encoder/0.6.1) | (MIT OR Apache-2.0) AND IJG | Dependency license and SIMD notices; source hashes in SOURCE.json. |
| `epaint_default_fonts::EGUI_ICONS`, `epaint_default_fonts::EMOJI_ICON` (dependency font inputs) | John Slegers | [egui 173cc737](https://github.com/storytold/egui/tree/6d518fc799681571963842f95b55a6b68431b15a/crates/epaint_default_fonts/fonts), [emoji-icon-font](https://github.com/jslegers/emoji-icon-font) | MIT (Copyright (c) 2014 John Slegers; full upstream text in `NOTICE`) | egui-icons.ttf is the five-glyph subset; emoji-icon-font.ttf is the full monochrome fallback. Registered by the production default font definitions; dependency assets unmodified here, no font file copied into this repository. |
| `krilla 0.8.2 / icc/sGrey-v2-magic.icc` (dependency-embedded) | Clinton Ingram | [craft-libs 9f89fe8 vendor/krilla/icc/sGrey-v2-magic.icc](https://github.com/storytold/craft-libs/blob/9f89fe8f6d72ab4db4cc06f186381a6a254463ab/vendor/krilla/icc/sGrey-v2-magic.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `4110169287e5f1b5149ca9f1da1814d32943905bba8030e849d1a3b729a19481`. |
| `krilla 0.8.2 / icc/sGrey-v4.icc` (dependency-embedded) | Clinton Ingram | [craft-libs 9f89fe8 vendor/krilla/icc/sGrey-v4.icc](https://github.com/storytold/craft-libs/blob/9f89fe8f6d72ab4db4cc06f186381a6a254463ab/vendor/krilla/icc/sGrey-v4.icc) (Krilla 0.8.2 upstream 3ffdf0588cf98050aad6edba51ca70162e1fb5b5) | CC0-1.0 | Embedded by the pinned PDF writer (`craft-pdf` 0.1.0, Krilla 0.8.2); unmodified dependency asset, no file copied into this repository. SHA-256 `00c0f94e09127520a17dc0e1d9264b5702081d96dbdb1549ee88e3631ce42a9d`. |
@@ -62,6 +63,7 @@ Generated-in-code assets are original and have no file to list:
| Asset | Author | Source | Licence | Notes |
|---|---|---|---|---|
| `crates/ui-egui/src/i18n/uk.tsv` | @dmatviichuk | Original Ukrainian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
| `crates/ui-egui/src/i18n/pl.tsv` | @neronek22 (Echo Rozumu & Gadajło; AI-assisted) | Original Polish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
| `crates/ui-egui/src/i18n/de.tsv` | the CADCraft contributors | Original German translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
| `crates/ui-egui/src/i18n/es.tsv` | @PedroGuille | Original Spanish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
| `crates/ui-egui/src/i18n/pt_br.tsv` | @WladmirJunior | Original Brazilian Portuguese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
@@ -76,6 +78,6 @@ Generated-in-code assets are original and have no file to list:
| `crates/ui-egui/src/i18n/ar.tsv` | @hasan-sdaif | Original Arabic translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
| `crates/ui-egui/src/i18n/hu.tsv` | @Skaywalker | Original Hungarian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied |
| `crates/ui-egui/src/i18n/tr.tsv` | @ogzhnklvz (AI-assisted) | Original Turkish translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; written from the English strings, no other catalog used as a source; the running app reviewed by a native speaker |
| `crates/ui-egui/src/i18n/el.tsv` | @Camthalion77 with ChatGPT (AI-assisted) | Original Greek translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; independent native proofreading pending |
| `crates/ui-egui/src/i18n/el.tsv` | @Camthalion77 with ChatGPT (AI-assisted); 46 later rows: @V1dalTheAbidal with Claude Code (AI-assisted) | Original Greek translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; the 46 later rows were read by their contributor, a native Greek speaker; independent native proofreading of the whole file pending |
| `crates/ui-egui/src/i18n/vi.tsv` | @2ez4gcx with Claude Code (AI-assisted) | Original Vietnamese translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; terminology chosen with a native speaker, full proofreading pending |
| `crates/ui-egui/src/i18n/ka.tsv` | Davit Matchakhelidze (@devius), native speaker, with Claude Code | Original Georgian translations of CADCraft English strings | MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`) | No proprietary localization resources copied; written from the English strings, no other catalog used as a source; terminology and doubtful strings decided by a native Georgian speaker; no font assets added (the Georgian face comes from craft-fonts) |
Generated
+443 -50
View File
@@ -156,6 +156,21 @@ dependencies = [
"zerocopy",
]
[[package]]
name = "alloc-no-stdlib"
version = "3.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a"
[[package]]
name = "alloc-stdlib"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1"
dependencies = [
"alloc-no-stdlib",
]
[[package]]
name = "allocator-api2"
version = "0.2.21"
@@ -284,6 +299,9 @@ name = "arrayvec"
version = "0.7.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
dependencies = [
"serde",
]
[[package]]
name = "as-raw-xcb-connection"
@@ -513,6 +531,12 @@ version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
[[package]]
name = "bit_field"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb2907cc03d08cdb1c6724ad0670ce67c4a71e1c45a6d7635224011714cfc4b1"
[[package]]
name = "bitflags"
version = "1.3.2"
@@ -568,6 +592,16 @@ dependencies = [
"piper",
]
[[package]]
name = "brotli-decompressor"
version = "6.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc031cd87c6529082b0b65c604e86af0ed7744841b17ccfe60b1e31fa606179e"
dependencies = [
"alloc-no-stdlib",
"alloc-stdlib",
]
[[package]]
name = "bumpalo"
version = "3.20.3"
@@ -614,7 +648,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
[[package]]
name = "cadcraft"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-engine",
"cadcraft-io",
@@ -631,11 +665,13 @@ dependencies = [
"log",
"muda",
"objc2-app-kit 0.3.2",
"pollster 1.0.1",
"rfd",
"ron",
"serde_json",
"sys-locale",
"thiserror 2.0.21",
"uds_windows",
"windows",
"winit",
"winresource",
@@ -644,7 +680,7 @@ dependencies = [
[[package]]
name = "cadcraft-cli"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-engine",
"cadcraft-io",
@@ -660,14 +696,14 @@ dependencies = [
[[package]]
name = "cadcraft-color"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"serde",
]
[[package]]
name = "cadcraft-constraints"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-doc",
"cadcraft-geom",
@@ -677,7 +713,7 @@ dependencies = [
[[package]]
name = "cadcraft-doc"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-color",
"cadcraft-geom",
@@ -686,36 +722,20 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "cadcraft-dwg"
version = "0.17.0"
dependencies = [
"acadrust",
"log",
]
[[package]]
name = "cadcraft-dxf"
version = "0.17.0"
dependencies = [
"encoding_rs",
"log",
"thiserror 2.0.21",
]
[[package]]
name = "cadcraft-engine"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-color",
"cadcraft-constraints",
"cadcraft-doc",
"cadcraft-dxf",
"cadcraft-fonts",
"cadcraft-geom",
"cadcraft-io",
"cadcraft-render",
"craft-docpath",
"craft-dxf",
"craft-mime",
"libc",
"log",
"rstar",
@@ -726,9 +746,12 @@ dependencies = [
[[package]]
name = "cadcraft-fonts"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-geom",
"craft-dxf",
"craft-font-catalog",
"craft-shx",
"encoding_rs",
"harfrust 0.14.0",
"icu_segmenter",
@@ -738,42 +761,47 @@ dependencies = [
[[package]]
name = "cadcraft-geom"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"serde",
]
[[package]]
name = "cadcraft-io"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"acadrust",
"cadcraft-color",
"cadcraft-doc",
"cadcraft-dwg",
"cadcraft-dxf",
"cadcraft-fonts",
"cadcraft-geom",
"cadcraft-render",
"craft-dwg",
"craft-dxf",
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"craft-pdf",
"craft-svg",
"image",
"miniz_oxide 0.9.1",
"quick-xml 0.42.0",
"serde",
"serde_json",
"thiserror 2.0.21",
"tiff",
"tiny-skia",
]
[[package]]
name = "cadcraft-mcp"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-engine",
"cadcraft-io",
"cadcraft-render",
"clap",
"craft-jsonrpc",
"craft-mcp",
"getrandom 0.4.3",
"libc",
"log",
"serde_json",
"tiny-skia",
@@ -781,12 +809,13 @@ dependencies = [
[[package]]
name = "cadcraft-render"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-color",
"cadcraft-doc",
"cadcraft-fonts",
"cadcraft-geom",
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"lyon_tessellation",
"rayon",
"serde_json",
@@ -795,15 +824,17 @@ dependencies = [
[[package]]
name = "cadcraft-ui-egui"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-color",
"cadcraft-doc",
"cadcraft-engine",
"cadcraft-fonts",
"cadcraft-geom",
"cadcraft-io",
"cadcraft-render",
"chrono",
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"craft-ui",
"craft-update",
"craft-window",
@@ -822,15 +853,17 @@ dependencies = [
[[package]]
name = "cadcraft-web"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"cadcraft-engine",
"cadcraft-fonts",
"cadcraft-io",
"cadcraft-ui-egui",
"craft-web-api",
"craft-web-host",
"eframe",
"egui",
"js-sys",
"log",
"serde_json",
"wasm-bindgen",
@@ -1142,11 +1175,52 @@ dependencies = [
"libc",
]
[[package]]
name = "craft-codepage"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=0325b2d73676d736e94097dbcef01219cf25c7db#0325b2d73676d736e94097dbcef01219cf25c7db"
[[package]]
name = "craft-codepage"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=9ed120e6b1bd5116a4649c578d1272d60cf932b9#9ed120e6b1bd5116a4649c578d1272d60cf932b9"
[[package]]
name = "craft-docpath"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
[[package]]
name = "craft-dwg"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf#7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf"
dependencies = [
"acadrust",
"log",
]
[[package]]
name = "craft-dxf"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=9ed120e6b1bd5116a4649c578d1272d60cf932b9#9ed120e6b1bd5116a4649c578d1272d60cf932b9"
dependencies = [
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=9ed120e6b1bd5116a4649c578d1272d60cf932b9)",
"encoding_rs",
"kurbo",
"log",
"thiserror 2.0.21",
]
[[package]]
name = "craft-font-catalog"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c07e38090879ffa994f893df9956c6d5b96c049c#c07e38090879ffa994f893df9956c6d5b96c049c"
dependencies = [
"skrifa 0.47.0",
"thiserror 2.0.21",
"windows-registry",
]
[[package]]
name = "craft-fonts-build"
version = "0.1.0"
@@ -1175,6 +1249,123 @@ dependencies = [
"writeable",
]
[[package]]
name = "craft-image-codecs"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
dependencies = [
"craft-jpeg 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"craft-metadata 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"crc32fast",
"exr",
"flate2",
"half",
"hayro-jpeg2000",
"image",
"image-webp",
"jpeg-encoder",
"png",
"rayon",
"serde_json",
"thiserror 2.0.21",
"tiff",
"zune-core",
"zune-jpeg",
"zune-jpegxl",
]
[[package]]
name = "craft-image-codecs"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"craft-jpeg 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"craft-metadata 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"crc32fast",
"exr",
"flate2",
"half",
"hayro-jpeg2000",
"image",
"image-webp",
"jpeg-encoder",
"png",
"rayon",
"serde_json",
"thiserror 2.0.21",
"tiff",
"zune-core",
"zune-jpeg",
"zune-jpegxl",
]
[[package]]
name = "craft-jpeg"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-jpeg"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-jsonrpc"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=b6222158fbc2a628f27d2c1fff9f648cd194404c#b6222158fbc2a628f27d2c1fff9f648cd194404c"
dependencies = [
"serde_json",
]
[[package]]
name = "craft-mcp"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=b6222158fbc2a628f27d2c1fff9f648cd194404c#b6222158fbc2a628f27d2c1fff9f648cd194404c"
dependencies = [
"craft-jsonrpc",
"serde_json",
]
[[package]]
name = "craft-metadata"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
dependencies = [
"brotli-decompressor",
"chrono",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"quick-xml 0.41.0",
"serde",
]
[[package]]
name = "craft-metadata"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"brotli-decompressor",
"chrono",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"quick-xml 0.41.0",
"serde",
]
[[package]]
name = "craft-mime"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=0325b2d73676d736e94097dbcef01219cf25c7db#0325b2d73676d736e94097dbcef01219cf25c7db"
dependencies = [
"chrono",
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=0325b2d73676d736e94097dbcef01219cf25c7db)",
"encoding_rs",
]
[[package]]
name = "craft-pdf"
version = "0.1.0"
@@ -1185,6 +1376,45 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-shx"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=2f2d1d84e3a36b3f93e81507aeff3f0da97a7162#2f2d1d84e3a36b3f93e81507aeff3f0da97a7162"
[[package]]
name = "craft-svg"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"craft-xml",
"flate2",
"kurbo",
"quick-xml 0.41.0",
"roxmltree",
"thiserror 2.0.21",
"vectorcraft-geom",
"vectorcraft-pathops",
]
[[package]]
name = "craft-tiff"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
dependencies = [
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-tiff"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-ui"
version = "0.1.0"
@@ -1209,7 +1439,7 @@ dependencies = [
[[package]]
name = "craft-update"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"chrono",
"dunce",
@@ -1219,6 +1449,7 @@ dependencies = [
"image",
"log",
"plist",
"rustix 1.1.5",
"semver",
"serde",
"serde_json",
@@ -1232,10 +1463,21 @@ dependencies = [
"zip",
]
[[package]]
name = "craft-web-api"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
dependencies = [
"js-sys",
"serde_json",
"wasm-bindgen",
"wasm-bindgen-futures",
]
[[package]]
name = "craft-web-host"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=2e2312ddaf21bc3d85cd3395d0955c7d239306f6#2e2312ddaf21bc3d85cd3395d0955c7d239306f6"
source = "git+https://github.com/storytold/craft-libs?rev=fd5e2feff6ea25bed371a99cc732b3968d621505#fd5e2feff6ea25bed371a99cc732b3968d621505"
dependencies = [
"wasm-bindgen",
"web-sys",
@@ -1252,6 +1494,16 @@ dependencies = [
"wayland-client",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"quick-xml 0.41.0",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "crc32fast"
version = "1.5.3"
@@ -1741,6 +1993,22 @@ dependencies = [
"pin-project-lite",
]
[[package]]
name = "exr"
version = "1.74.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb29d0be702adf92c645d9b2f93472906ba83d400e59f98adb3770ce5c18c2f6"
dependencies = [
"bit_field",
"half",
"lebe",
"miniz_oxide 0.8.9",
"multiversion",
"rayon-core",
"smallvec",
"zune-inflate",
]
[[package]]
name = "fastrand"
version = "2.5.0"
@@ -2245,6 +2513,9 @@ name = "hayro-jpeg2000"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c75ab947623ef4ccaa7acf0579edf7cbb5a73838e3839a7be73335e522f433a1"
dependencies = [
"fearless_simd",
]
[[package]]
name = "hayro-syntax"
@@ -2547,9 +2818,12 @@ checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
dependencies = [
"bytemuck",
"byteorder-lite",
"color_quant",
"gif",
"moxcms",
"num-traits",
"png",
"qoi",
"tiff",
"zune-core",
"zune-jpeg",
@@ -2689,6 +2963,12 @@ dependencies = [
"libc",
]
[[package]]
name = "jpeg-encoder"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b454d911ac55068f53495488d8ccd0646eaa540c033a28ee15b07838afafb01f"
[[package]]
name = "js-sys"
version = "0.3.106"
@@ -2772,6 +3052,7 @@ dependencies = [
"arrayvec",
"euclid",
"polycool",
"serde",
"smallvec",
]
@@ -2781,6 +3062,12 @@ version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
[[package]]
name = "lebe"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
[[package]]
name = "libc"
version = "0.2.191"
@@ -2821,6 +3108,19 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4"
[[package]]
name = "linesweeper"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a25df1b0c5432893f41bba817150e323703ee5f6d974f3a6808ac7fd7f046d18"
dependencies = [
"arrayvec",
"kurbo",
"polycool",
"rustc-hash 2.1.3",
"smallvec",
]
[[package]]
name = "linux-raw-sys"
version = "0.4.15"
@@ -2973,6 +3273,28 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "multiversion"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eb8a68be21d0755f83bfe47e79b896cc732687cf1903f0e50585e8d6ecc53076"
dependencies = [
"multiversion-macros",
"target-features",
]
[[package]]
name = "multiversion-macros"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a05e0c3c3e4edaa21d87c645852ed0b0c3663752bcc6ec43353bd6189dce35e1"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
"target-features",
]
[[package]]
name = "multiversion_no_op"
version = "1.0.0"
@@ -3841,6 +4163,15 @@ version = "0.1.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
[[package]]
name = "qoi"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
dependencies = [
"bytemuck",
]
[[package]]
name = "quick-error"
version = "2.0.1"
@@ -3951,6 +4282,17 @@ dependencies = [
"once_cell",
]
[[package]]
name = "read-fonts"
version = "0.44.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5a0cf4bb6cbce4c29756270d189a5e400ac05e91192161d83a0bcb6e68492e8"
dependencies = [
"bytemuck",
"font-types 0.12.7",
"once_cell",
]
[[package]]
name = "read-fonts"
version = "0.45.1"
@@ -4058,6 +4400,15 @@ dependencies = [
"unicode-ident",
]
[[package]]
name = "roxmltree"
version = "0.21.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9da7f59328b09405b181fee1018925fad50f157afb43c0c0f5c522c256dd5907"
dependencies = [
"memchr",
]
[[package]]
name = "rstar"
version = "0.13.0"
@@ -4415,6 +4766,16 @@ dependencies = [
"read-fonts 0.41.0",
]
[[package]]
name = "skrifa"
version = "0.47.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "526e654b303ff4ad73a5a40b25de2b3ce3d039c5e3b6da5f89ae6e57004cb40f"
dependencies = [
"bytemuck",
"read-fonts 0.44.0",
]
[[package]]
name = "skrifa"
version = "0.48.0"
@@ -4638,6 +4999,12 @@ dependencies = [
"libc",
]
[[package]]
name = "target-features"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1bbb9f3c5c463a01705937a24fdabc5047929ac764b2d5b9cf681c1f5041ed5"
[[package]]
name = "tempfile"
version = "3.27.0"
@@ -5055,6 +5422,27 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "vectorcraft-geom"
version = "0.18.0"
source = "git+https://github.com/storytold/vectorcraft.git?rev=6b3a6b8788ebcb420d69449199cbdf323888d27e#6b3a6b8788ebcb420d69449199cbdf323888d27e"
dependencies = [
"kurbo",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "vectorcraft-pathops"
version = "0.18.0"
source = "git+https://github.com/storytold/vectorcraft.git?rev=6b3a6b8788ebcb420d69449199cbdf323888d27e#6b3a6b8788ebcb420d69449199cbdf323888d27e"
dependencies = [
"kurbo",
"linesweeper",
"thiserror 2.0.21",
"vectorcraft-geom",
]
[[package]]
name = "vello_common"
version = "0.2.0"
@@ -5977,7 +6365,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
[[package]]
name = "xtask"
version = "0.17.0"
version = "0.21.0"
dependencies = [
"chrono",
"serde_json",
@@ -6210,7 +6598,6 @@ dependencies = [
"nix 0.31.3",
"typed-path",
"windows-sys 0.61.2",
"zopfli",
]
[[package]]
@@ -6225,24 +6612,21 @@ version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
[[package]]
name = "zopfli"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11"
dependencies = [
"bumpalo",
"crc32fast",
"log",
"simd-adler32",
]
[[package]]
name = "zune-core"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"
[[package]]
name = "zune-inflate"
version = "0.2.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
dependencies = [
"simd-adler32",
]
[[package]]
name = "zune-jpeg"
version = "0.5.15"
@@ -6252,6 +6636,15 @@ dependencies = [
"zune-core",
]
[[package]]
name = "zune-jpegxl"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cba11ecd07cc23351500e840ae03841b7e4997923ec8e4832ee3ae199ea0b6b4"
dependencies = [
"zune-core",
]
[[package]]
name = "zvariant"
version = "5.15.1"
+14 -4
View File
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
# default-members
[workspace.package]
version = "0.17.0"
version = "0.21.0"
edition = "2024"
license = "MIT OR Apache-2.0"
rust-version = "1.95"
@@ -13,8 +13,12 @@ repository = "https://github.com/storytold/cadcraft"
[workspace.dependencies]
# internal
cadcraft-geom = { path = "crates/geom" }
cadcraft-dxf = { path = "crates/dxf" }
cadcraft-dwg = { path = "crates/dwg" }
# DXF tags: the shared reader and writer (moved from crates/dxf; craft-libs#791).
craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "9ed120e6b1bd5116a4649c578d1272d60cf932b9" }
craft-dwg = { git = "https://github.com/storytold/craft-libs", rev = "7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf" }
craft-shx = { git = "https://github.com/storytold/craft-libs", rev = "2f2d1d84e3a36b3f93e81507aeff3f0da97a7162" }
craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "ae5020c1ed922cf7976a3a5545f05b07f466be12" }
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "0325b2d73676d736e94097dbcef01219cf25c7db" }
cadcraft-color = { path = "crates/color" }
cadcraft-doc = { path = "crates/doc" }
cadcraft-constraints = { path = "crates/constraints" }
@@ -24,11 +28,17 @@ cadcraft-io = { path = "crates/io" }
cadcraft-engine = { path = "crates/engine" }
cadcraft-ui-egui = { path = "crates/ui-egui" }
cadcraft-mcp = { path = "crates/mcp" }
craft-mcp = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
craft-jsonrpc = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
# SVG/SVGZ import and export geometry (craft-libs#778).
craft-svg = { git = "https://github.com/storytold/craft-libs", rev = "c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52" }
# Which paths stored in a drawing (xrefs, data links) may be opened.
craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
# PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
# craft-pdf's patched backends to the same revision (Cargo ignores dependency-local patches).
craft-pdf = { version = "=0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", default-features = false }
# TrueType embedding-permission classification for plotted fonts (craft-libs#778).
craft-font-catalog = { git = "https://github.com/storytold/craft-libs", rev = "c07e38090879ffa994f893df9956c6d5b96c049c", default-features = false }
clap = { version = "4", features = ["derive", "env"] }
clap_complete = "4.6.11"
clap_mangen = { version = "0.3.3", features = ["env"] }
@@ -71,7 +81,7 @@ egui-wgpu = "0.37"
# Monotonic time on native and web (performance.now on wasm).
web-time = "1.1"
# craft-update: app-specific pretend versions apply to startup and manual checks.
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", features = ["egui"] }
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", features = ["egui"] }
rfd = "0.17"
arboard = { version = "3.6", default-features = false }
+125 -1
View File
@@ -11,7 +11,7 @@ Third-party material
Software dependencies are listed in Cargo.lock. One is under a weak-copyleft licence: the acadrust
crate (DWG reading and writing, https://github.com/hakanaktt/acadrust) is licensed under the
Mozilla Public License 2.0 and is used unmodified as a separate library (crates/dwg). Its source
Mozilla Public License 2.0 and is used unmodified as a separate library via craft-dwg. Its source
is available from crates.io and the repository above.
@@ -48,3 +48,127 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
JPEG encoding dependency: jpeg-encoder 0.6.1
Source: https://crates.io/crates/jpeg-encoder/0.6.1
Declared license: (MIT OR Apache-2.0) AND IJG.
This software is based in part on the work of the Independent JPEG Group.
The MIT license and unaltered upstream IJG and SIMD notices follow. The Apache-2.0
alternative is also retained in licenses/jpeg-encoder-0.6.1 at the repository root
(https://github.com/storytold/craft-libs/tree/main/licenses/jpeg-encoder-0.6.1).
The dependency is used unmodified; no encoder implementation is vendored here.
LICENSE-MIT
Copyright (c) 2021 Volker Ströbel <volkerstroebel@mysurdity.de>
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
Original src/fdct.rs opening notice
/*
* Ported from mozjpeg to rust
*
* This file was part of the Independent JPEG Group's software:
* Copyright (C) 1991-1996, Thomas G. Lane.
* libjpeg-turbo Modifications:
* Copyright (C) 2015, 2020, D. R. Commander.
*
* Conditions of distribution and use:
* In plain English:
*
* 1. We don't promise that this software works. (But if you find any bugs,
* please let us know!)
* 2. You can use this software for whatever you want. You don't have to pay us.
* 3. You may not pretend that you wrote this software. If you use it in a
* program, you must acknowledge somewhere in your documentation that
* you've used the IJG code.
*
* In legalese:
*
* The authors make NO WARRANTY or representation, either express or implied,
* with respect to this software, its quality, accuracy, merchantability, or
* fitness for a particular purpose. This software is provided "AS IS", and you,
* its user, assume the entire risk as to its quality and accuracy.
*
* This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
* All Rights Reserved except as specified below.
*
* Permission is hereby granted to use, copy, modify, and distribute this
* software (or portions thereof) for any purpose, without fee, subject to these
* conditions:
* (1) If any part of the source code for this software is distributed, then this
* README file must be included, with this copyright and no-warranty notice
* unaltered; and any additions, deletions, or changes to the original files
* must be clearly indicated in accompanying documentation.
* (2) If only executable code is distributed, then the accompanying
* documentation must state that "this software is based in part on the work of
* the Independent JPEG Group".
* (3) Permission for use of this software is granted only if the user accepts
* full responsibility for any undesirable consequences; the authors accept
* NO LIABILITY for damages of any kind.
*
* These conditions apply to any software derived from or based on the IJG code,
* not just to the unmodified library. If you use our work, you ought to
* acknowledge us.
*
* Permission is NOT granted for the use of any IJG author's name or company name
* in advertising or publicity relating to this software or products derived from
* it. This software may be referred to only as "the Independent JPEG Group's
* software".
*
* We specifically permit and encourage the use of this software as the basis of
* commercial products, provided that all warranty or liability claims are
* assumed by the product vendor.
*
* This file contains a slower but more accurate integer implementation of the
* forward DCT (Discrete Cosine Transform).
*
* A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
* on each column. Direct algorithms are also available, but they are
* much more complex and seem not to be any faster when reduced to code.
*
* This implementation is based on an algorithm described in
* C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
* Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
* Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
* The primary algorithm described there uses 11 multiplies and 29 adds.
* We use their alternate method with 12 multiplies and 32 adds.
* The advantage of this method is that no data path contains more than one
* multiplication; this allows a very simple and accurate implementation in
* scaled fixed-point arithmetic, with a minimal number of shifts.
*/
Original src/avx2/fdct.rs opening notice
/*
* Ported from mozjpeg / jfdctint-avx2.asm to rust
* Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
* Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander.
*
* Based on the x86 SIMD extension for IJG JPEG library
* Copyright (C) 1999-2006, MIYASAKA Masaru.
*/
+27 -24
View File
@@ -2,16 +2,18 @@
**Stage: pre-alpha** · next: alpha, ~2 points (38% → 40% ready for real work) and ~125–190 Opus 5.5 hours away (the four failing core workflows of the [alpha gate](docs/roadmap.md#alpha-gate))
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-21 · **Change:** trivial (progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027
> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-10-24 · **Change:** minor (re-audit against main 41d9b5e95: language table, CI gate, open-PR count; previously: progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027
CADCraft targets full parity with AutoCAD (2D drafting first, then annotation, layouts and
plotting, DWG, parametrics and 3D), plus what AutoCAD doesn't have: agent control over MCP, a
scriptable CLI, a web build, Linux and FreeBSD builds, and a free licence.
**Why pre-alpha:** four of AutoCAD's five core workflows fail the [alpha gate](docs/roadmap.md#alpha-gate).
Precise drafting lacks object snap tracking and has stubbed TRIM/EXTEND/OFFSET options; blocks
can't be edited in a block editor (REFEDIT edits them in place, xrefs not yet); plots ignore plot styles; and a DWG saved by
CADCraft drops everything it doesn't model and has never been checked in
Precise drafting still has approximate ellipse and spline intersections and a few stubbed prompt options
(object snap tracking, TRIM/EXTEND/OFFSET options and typed snap overrides have landed); dynamic blocks can't be
authored and xrefs can't be edited in place (the Block Editor, REFEDIT, dynamic block editing and XCLIP have landed);
plots go only to PDF, PNG and SVG files (plot styles and the Plot dialog have landed); and a DWG saved by
CADCraft drops what acadrust doesn't model and has never been checked in
AutoCAD. Dimensioning passes. Ready for real work (≈ 38%) is also under the ~40% alpha bar. Beta
is ≈ 600–930 h away.
@@ -19,7 +21,7 @@ is ≈ 600–930 h away.
| Number | Value | Kind |
|---|---|---|
| Feature breadth (AutoCAD for Mac menu items with a live command) | **50%** (245 / 491; 2D menus only ≈ 65%) | measured ([parity-checklist.md](docs/parity-checklist.md) + UI-only commands) |
| Feature breadth (AutoCAD for Mac menu items with a live command) | **50%** (245 / 491 at the 2026-10-10 re-measure, including UI-only commands; not re-measured since; the generated checklist counts engine commands only and now reads 298 / 491; 2D menus only ≈ 65%) | measured ([parity-checklist.md](docs/parity-checklist.md) + UI-only commands) |
| Ready for real work | **≈ 38%** | estimated ([target-app-parity.md](docs/target-app-parity.md)) |
| Mainstream practitioner (2D drafter) | **≈ 28%** (lower than the full number: file exchange, stability and interaction discounts multiply) | estimated ([target-app-parity.md](docs/target-app-parity.md#mainstream-practitioner)) |
| Essentials user | **≈ 46%** | estimated ([target-app-parity.md](docs/target-app-parity.md#essentials-user)) |
@@ -80,40 +82,40 @@ Hours are Opus 5.5 agent wall-clock hours, calibrated on this repo's own build:
## Languages
AutoCAD 2027 for Mac ships 8 interface languages; CADCraft ships English plus partial
Ukrainian and German. Detail: [localization-parity.md](docs/localization-parity.md).
AutoCAD 2027 for Mac ships 8 interface languages; CADCraft ships English plus eighteen catalogs
(Ukrainian, Brazilian Portuguese, German, Spanish, Czech, Russian, French, Simplified Chinese, Italian, Korean, Swedish, Arabic, Greek, Hungarian, Turkish, Bosnian, Georgian and Vietnamese). Detail: [localization-parity.md](docs/localization-parity.md).
| Language | Status | UI translated |
|---|---|---:|
| English | full | 100% |
| Simplified Chinese | none | 0% |
| Spanish | none | 0% |
| Simplified Chinese | partial | 1,337 catalog rows |
| Spanish | partial | 1,243 catalog rows |
| Hindi | none | 0% |
| Arabic | none | 0% |
| French | none | 0% |
| Portuguese | none | 0% |
| Arabic | partial | 1,229 catalog rows |
| French | partial | 1,004 catalog rows |
| Portuguese (Brazilian) | partial | 1,243 catalog rows |
| Indonesian | none | 0% |
| Japanese | none | 0% |
| Greek | complete current catalog | 1,330 current source keys; independent proofreading pending |
| German | partial | ≈ 100% of the catalog (989 rows) |
| Korean | none | 0% |
| Vietnamese | none | 0% |
| Greek | partial | 1,330 catalog rows; independent proofreading pending |
| German | partial | 1,031 catalog rows |
| Korean | partial | 1,235 catalog rows |
| Vietnamese | partial | 1,460 catalog rows (2026-11-07); native review pending |
Other languages shipped: Ukrainian and German (989 catalog rows each; Ukrainian landed with #36), Brazilian Portuguese, Spanish, Czech, Russian, French, Simplified Chinese and Italian (1,227 rows, 2026-10-12); engine messages stay English.
Other languages shipped: Ukrainian (1,357 rows, the reference catalog, #36), Czech (1,215), Russian (1,005), Italian (1,352), Swedish (1,382), Hungarian (1,326) and Turkish (1,330), counted 2026-10-24; engine messages stay English. Every catalog but Ukrainian's has strings added since it landed that still fall back to English: 6 (Italian, Swedish) to 296 (French) per `cargo xtask i18n` ([localization-parity.md](docs/localization-parity.md)).
## Upcoming
Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md).
1. Gate and land: fix fmt on main, run `cargo xtask ci` on every PR, land the 47 open PRs (15–25 h).
2. Stop losing data on save; native MULTILEADER; save DWG/DXF at a chosen version (30–45 h).
1. Gate and land: CI runs `cargo xtask ci` on every PR since #1987 (fmt on main is fixed); land the 450 open PRs (2026-10-24) (15–25 h).
2. Stop losing data on save (DXF done, #528; native MULTILEADER, #459, and the save version, #421, done; through DWG, acadrust still drops some content) (30–45 h).
3. Real-file DWG/DXF corpus and a black-box check in AutoCAD (10–15 h + owner).
4. Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
editable dynamic input (25–35 h).
5. Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER (15–25 h).
6. Autosave, recovery, AUDIT, RECOVER (10–15 h).
4. ~~Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
editable dynamic input.~~ Done (#379, #441, #60, #519; `snap/tracking.rs`, `pointmod.rs`, `dyninput.rs`).
5. ~~Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER.~~ Done (#397, #408, #547); the stubs left are in gaps F1.
6. ~~Autosave, recovery, AUDIT, RECOVER.~~ Done on the desktop (#406, #416); the web build has no autosave (gaps F4).
7. Exact ellipse/spline geometry and correct polyline offsets (30–50 h).
8. Xrefs, block editor, groups, then dynamic blocks (80–120 h).
8. Xrefs, block editor, groups, then dynamic blocks (80–120 h): xrefs (#525), groups (#417), the Block Editor (#824, #833, #885), REFEDIT (#818), XCLIP and XCLIPFRAME (#2354) and dynamic block references (#838–#883) landed; left: dynamic-block authoring, editing an xref in place.
## Progress log
@@ -136,6 +138,7 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
| Date | Change | Summary |
|---|---|---|
| 2026-10-24 | minor | Re-audit against main 41d9b5e95: language table, CI gate and open-PR count re-checked against main 41d9b5e95 |
| 2026-10-21 | trivial | Progress log: proxy objects keep their class through a save (#1812) |
| 2026-10-14 | minor | Progress log: HATCHEDIT boundary add/remove |
| 2026-10-12 | trivial | Progress log: closed-polyline TRIM (#726) |
+2
View File
@@ -54,6 +54,8 @@ fn install_io() {
groups: cadcraft_io::entity_groups,
entity: cadcraft_io::entity_from_groups,
});
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
}
/// `path` as text, for the engine and io calls that take a file name as a string.
+4 -1
View File
@@ -20,7 +20,9 @@ cadcraft-ui-egui = { workspace = true }
cadcraft-io = { workspace = true }
cadcraft-fonts = { workspace = true }
# The host messages (storytold/craft-libs): one contract and one bridge for the web builds.
craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "2e2312ddaf21bc3d85cd3395d0955c7d239306f6", version = "0.1.0" }
# The page command API (storytold/craft-libs#413): window.cadcraft over the control channel.
craft-web-api = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
craft-web-host = { git = "https://github.com/storytold/craft-libs", rev = "fd5e2feff6ea25bed371a99cc732b3968d621505", version = "0.1.0" }
egui = { workspace = true }
log = { workspace = true }
serde_json = { workspace = true }
@@ -33,4 +35,5 @@ web-sys = { version = "0.3", features = ["HtmlInputElement", "FileList", "File"]
eframe = { workspace = true, features = ["persistence", "wgpu", "accesskit"] }
wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4"
js-sys = "0.3"
web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "Location", "Navigator", "Blob", "BlobPropertyBag", "Url", "MessageEvent", "UrlSearchParams", "MediaQueryList", "Event", "EventTarget", "CustomEvent", "CustomEventInit"] }
+61
View File
@@ -0,0 +1,61 @@
//! `window.cadcraft`: the page command API (`craft-web-api`, storytold/craft-libs#413) over the app's
//! own control channel, the one the desktop control server drives (`docs/control-protocol.md`).
//!
//! The crate owns the JavaScript side (`request`, `execute`, `commands`, `docInspect`, `uiInspect`,
//! `screenshot`, as promises with a timeout). This module is CADCraft's part: a [`Request`] that
//! queues a [`ControlRequest`] for the app, which answers it on its next frame, and waits for the
//! reply. A call the page gave up on drops its [`PendingReply`], which cancels a request the app has
//! not started, so the app skips it instead of running it late.
use std::rc::Rc;
use std::sync::mpsc::{Receiver, channel};
use cadcraft_ui_egui::{ControlRequest, PendingReply};
use craft_web_api::methods::Methods;
use craft_web_api::page::{PageApi, Request};
use serde_json::{Value, json};
use wasm_bindgen_futures::JsFuture;
/// The app id in `window.<app>`.
const APP: &str = "cadcraft";
/// How often a waiting call looks for the app's reply, in milliseconds (about a frame).
const POLL_MS: i32 = 16;
/// Put `window.cadcraft` on the page and return the queue the app drains each frame (hand it to
/// `CadApp::with_control`). An existing `window.cadcraft` keeps the functions it already has.
pub fn install(ctx: egui::Context) -> Receiver<ControlRequest> {
let (queue, requests) = channel::<ControlRequest>();
let request: Request = Rc::new(move |method, params| {
let (control, reply) = ControlRequest::new(method, params);
if queue.send(control).is_err() {
return Box::pin(async { json!({"ok": false, "error": "the app is not running"}) });
}
ctx.request_repaint();
Box::pin(wait(reply))
});
if let Err(e) = Rc::new(PageApi::new(APP, Methods::default(), request)).install() {
log::warn!("couldn't install window.{APP}: {e:?}");
}
requests
}
/// The app's reply, polled about once a frame. Dropping this future (the page's timeout) drops
/// `reply`, which cancels the request if the app has not started it.
async fn wait(reply: PendingReply) -> Value {
loop {
if let Some(reply) = reply.try_reply() {
return reply;
}
sleep(POLL_MS).await;
}
}
async fn sleep(ms: i32) {
let promise = js_sys::Promise::new(&mut |resolve, _| {
if let Some(window) = web_sys::window() {
let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms);
}
});
let _ = JsFuture::from(promise).await;
}
+6 -1
View File
@@ -10,6 +10,8 @@
//! `data-host="page"` on the canvas, talking over DOM `CustomEvent`s on it (`host.rs`).
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#[cfg(target_arch = "wasm32")]
mod api;
#[cfg(target_arch = "wasm32")]
pub mod download;
#[cfg(target_arch = "wasm32")]
@@ -126,6 +128,8 @@ mod web {
groups: cadcraft_io::entity_groups,
entity: cadcraft_io::entity_from_groups,
});
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
let Some(canvas) = app_canvas() else {
log::error!("missing <canvas id=\"{CANVAS_ID}\">");
return;
@@ -160,7 +164,8 @@ mod web {
Box::new(move |cc| {
// Embedded, the host sends the drawing: start on the Start tab, not Drawing1.
let session = if app_bridge.is_some() { Session::empty() } else { Session::new() };
let mut app = CadApp::new(session, services());
let control = crate::api::install(cc.egui_ctx.clone());
let mut app = CadApp::new(session, services()).with_control(control);
app.system_languages =
web_sys::window().map(|w| w.navigator().languages().iter().filter_map(|v| v.as_string()).collect()).unwrap_or_default();
if let Some(profile) = cc.storage.and_then(|s| s.get_string(cadcraft_ui_egui::options::PROFILE_KEY)) {
+8 -1
View File
@@ -55,7 +55,11 @@ muda = { version = "0.21", default-features = false }
objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSWorkspace", "NSAccessibility"] }
# The same winit eframe uses (the storytold fork, patched in the workspace): its opt-in that turns
# AppKit's terminate (Cmd+Q, Dock Quit) into a close request, so unsaved changes are asked about.
winit = { version = "0.30", default-features = false }
# `rwh_06`: the window handle a file dialog shown as a sheet attaches to (src/sheet.rs).
winit = { version = "0.30", default-features = false, features = ["rwh_06"] }
# Waits for the answer of a file dialog shown as a sheet (src/sheet.rs). MIT OR Apache-2.0, already
# in Cargo.lock through eframe.
pollster = "1"
# Rust HID backends: no proprietary SDK or C HID library.
[target.'cfg(target_os = "windows")'.dependencies]
@@ -63,6 +67,9 @@ hidapi = { version = "2.6.7", default-features = false, features = ["windows-nat
# View ▸ Accessibility ▸ Animation Effects ▸ Use System Setting: Windows' Animation effects
# setting (system_animations.rs). Already in Cargo.lock through wgpu's DirectX 12 backend.
windows = { version = "0.62", features = ["UI_ViewManagement"] }
# One CADCraft per sign-in: later launches hand their files over an AF_UNIX socket
# (single_instance.rs). Already in Cargo.lock through zbus.
uds_windows = "1.2.1"
[target.'cfg(target_os = "linux")'.dependencies]
hidapi = { version = "2.6.7", default-features = false, features = ["linux-native-basic-udev"] }
+7 -6
View File
@@ -250,17 +250,18 @@ fn parse_line(bytes: &[u8]) -> Line {
Ok(v) => v,
Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
};
let Some(obj) = msg.as_object() else {
let Value::Object(mut obj) = msg else {
return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
};
let Some(method) = obj.get("method").and_then(Value::as_str) else {
let Some(Value::String(method)) = obj.remove("method") else {
return Line::Reject("not a control request (missing string `method`); closing the connection".into());
};
// Moved out of the parsed object, not cloned: `params` can be most of the line.
Line::Request {
id: obj.get("id").cloned().unwrap_or(Value::Null),
method: method.to_string(),
params: obj.get("params").cloned().unwrap_or(json!({})),
token: obj.get("token").and_then(Value::as_str).map(str::to_string),
id: obj.remove("id").unwrap_or(Value::Null),
method,
params: obj.remove("params").unwrap_or(json!({})),
token: obj.remove("token").and_then(|t| if let Value::String(t) = t { Some(t) } else { None }),
}
}
+7 -1
View File
@@ -24,6 +24,9 @@ pub(crate) struct LaunchArgs {
/// Open with the sample drawing
#[arg(long)]
pub(crate) sample: bool,
/// Open the files in a new window, even if CADCraft is already running (Windows)
#[arg(long)]
pub(crate) new_window: bool,
}
/// The command line. An empty or blank variable counts as unset.
@@ -81,7 +84,10 @@ mod tests {
assert_eq!((parsed.control, parsed.sample), (Some(50494), true));
assert_eq!(parsed.files, [PathBuf::from("a.dxf"), PathBuf::from("b.dwg")]);
let parsed = parse_args(&[]).unwrap();
assert_eq!((parsed.control, parsed.sample, parsed.files.len()), (None, false, 0));
assert_eq!((parsed.control, parsed.sample, parsed.new_window, parsed.files.len()), (None, false, false, 0));
let parsed = parse_args(&["--new-window", "a.dwg"]).unwrap();
assert!(parsed.new_window);
assert_eq!(parsed.files, [PathBuf::from("a.dwg")]);
}
#[test]
+22 -3
View File
@@ -148,7 +148,20 @@ pub fn rotate(dir: &Path) -> std::io::Result<(PathBuf, File)> {
/// One formatted log line: `<timestamp> <LEVEL> [<thread>] <target>: <message>\n`.
pub fn format_line(ts: &str, level: log::Level, thread: &str, target: &str, message: &str) -> String {
let message = message.strip_suffix('\n').unwrap_or(message);
format!("{ts} {level:<5} [{thread}] {target}: {message}\n")
// A message can carry text from a file (a code page name, a path), so it must not be able to
// start what looks like another record: control characters other than tab and line feed are
// shown escaped, and every continuation line is indented, so only this function's own
// timestamp is ever at the start of a line.
let mut safe = String::with_capacity(message.len());
for c in message.chars() {
match c {
'\n' => safe.push_str("\n "),
'\t' => safe.push('\t'),
c if c.is_control() => safe.extend(c.escape_default()),
c => safe.push(c),
}
}
format!("{ts} {level:<5} [{thread}] {target}: {safe}\n")
}
/// Where formatted lines go besides standard error: kept in memory until a file is attached,
@@ -441,8 +454,14 @@ mod tests {
format_line("2026-10-08T07:59:17.728Z", log::Level::Warn, "main", "cadcraft", "app icon: invalid PNG signature"),
"2026-10-08T07:59:17.728Z WARN [main] cadcraft: app icon: invalid PNG signature\n"
);
// A multi-line message keeps its lines; the record still ends in exactly one newline.
assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\nb\n"));
// A multi-line message keeps its lines, indented so they can't pass for records; the
// record still ends in exactly one newline.
assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\n b\n"));
// Control characters in a message (from a file) can't forge a record.
let forged = format_line("t", log::Level::Warn, "w", "x", "page\r\n2026-01-01T00:00:00Z ERROR [main] x: fake\u{1b}[0m");
assert_eq!(forged.lines().count(), 2);
assert!(forged.lines().skip(1).all(|l| l.starts_with(" ")));
assert!(!forged.contains('\r') && !forged.contains('\u{1b}'));
}
#[test]
+72 -22
View File
@@ -1,6 +1,6 @@
//! CADCraft desktop app.
//!
//! Usage: `cadcraft [--control <port>] [--sample] [files…]` (`cadcraft --help` lists the rest; see [`launch_args`])
//! Usage: `cadcraft [--control <port>] [--sample] [--new-window] [files…]` (`cadcraft --help` lists the rest; see [`launch_args`])
//!
//! `--control <port>` (or `CADCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server:
//! `{"id":1,"method":"cmdline.input","params":{"text":"circle 0,0 5"}}` → `{"id":1,"ok":true,…}`.
@@ -23,13 +23,16 @@ mod launch_args;
mod logging;
#[cfg(target_os = "macos")]
mod native_menu;
#[cfg(target_os = "macos")]
mod sheet;
mod single_instance;
mod spacemouse;
mod system_animations;
mod workspace;
use cadcraft_engine::Session;
use cadcraft_ui_egui::switch::Switch;
use cadcraft_ui_egui::{CadApp, Services, i18n};
use cadcraft_ui_egui::{CadApp, Pick, Services, i18n};
struct App {
cad: CadApp,
@@ -40,6 +43,8 @@ struct App {
system_animations: system_animations::SystemAnimations,
workspace: workspace::Workspace,
workspace_error: Option<String>,
/// The first CADCraft of this sign-in: files that later launches hand over (Windows).
single_instance: Option<single_instance::Server>,
#[cfg(target_os = "macos")]
native_menu: Option<native_menu::NativeMenu>,
/// `CADCRAFT_NO_NATIVE_MENU`: the menus stay inside the window.
@@ -85,6 +90,17 @@ impl eframe::App for App {
/// eframe logic callback: syncs the OS animation setting and runs `CadApp::logic`; when the pass index is 0 (the first pass or a hidden tick) it also installs/polls the macOS native menu, polls the spacemouse and persists the workspace; a quit request closes the viewport.
fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
self.cad.system_animations = self.system_animations.current();
// Files another launch handed over open as tabs here, and the window comes forward.
if let Some(server) = &self.single_instance {
let paths = server.take_paths();
if !paths.is_empty() {
ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(false));
ctx.send_viewport_cmd(egui::ViewportCommand::Focus);
for p in &paths {
self.cad.open_path(p);
}
}
}
// Consume control/open/screenshot queues and time-based autosave, including hidden ticks.
self.cad.guarded_logic(ctx);
// Host frame work runs here, once per frame, and so also on a hidden logic-only tick (which
@@ -155,32 +171,47 @@ pub fn install_io() {
groups: cadcraft_io::entity_groups,
entity: cadcraft_io::entity_from_groups,
});
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
}
fn services() -> Services {
Services {
pick_open: Some(Box::new(|| {
rfd::FileDialog::new()
.add_filter(i18n::t("Drawings (DWG, DXF)"), &["dwg", "dxf", "dwt"])
.add_filter(i18n::t("SVG drawings (SVG, SVGZ)"), &["svg", "svgz"])
.add_filter(i18n::t("All files"), &["*"])
.pick_file()
.map(|p| p.to_string_lossy().to_string())
})),
pick_save: Some(Box::new(|name: &str| {
filters_for_save(name)
.iter()
.fold(rfd::FileDialog::new().set_file_name(name), |d, (label, ext)| d.add_filter(i18n::t(label), &[*ext]))
.save_file()
.map(|p| p.to_string_lossy().to_string())
})),
pick_open: Some(Box::new(|| file_dialog(&Pick::Open).pick_file().map(|p| p.to_string_lossy().to_string()))),
pick_save: Some(Box::new(|name: &str| file_dialog(&Pick::Save(name.into())).save_file().map(|p| p.to_string_lossy().to_string()))),
// macOS shows the dialogs as sheets (`sheet::start_pick`), set once the window exists.
start_pick: None,
// APPLOAD: AutoLISP routines only, starting where the last one was loaded from.
pick_lisp: Some(Box::new(|dir: &str| {
let dialog = rfd::FileDialog::new().add_filter(i18n::t("AutoLISP (LSP)"), &["lsp"]).add_filter(i18n::t("All files"), &["*"]);
let dialog = if dir.is_empty() { dialog } else { dialog.set_directory(dir) };
dialog.pick_file().map(|p| p.to_string_lossy().to_string())
})),
pick_lisp: Some(Box::new(|dir: &str| file_dialog(&Pick::Lisp(dir.into())).pick_file().map(|p| p.to_string_lossy().to_string()))),
no_file_system: false,
pick_pgp: Some(Box::new(|dir: Option<&str>| {
file_dialog(&Pick::Pgp(dir.unwrap_or_default().into())).pick_file().map(|p| p.to_string_lossy().to_string())
})),
}
}
/// The file types `pick` offers: (label, extensions). Shared by the blocking dialogs and the
/// macOS sheets.
fn filters(pick: &Pick) -> Vec<(&'static str, Vec<&'static str>)> {
match pick {
Pick::Open => vec![
(i18n::t("Drawings (DWG, DXF)"), vec!["dwg", "dxf", "dwt"]),
(i18n::t("SVG drawings (SVG, SVGZ)"), vec!["svg", "svgz"]),
(i18n::t("All files"), vec!["*"]),
],
Pick::Save(name) => filters_for_save(name).iter().map(|(label, ext)| (i18n::t(label), vec![*ext])).collect(),
Pick::Lisp(_) => vec![(i18n::t("AutoLISP (LSP)"), vec!["lsp"]), (i18n::t("All files"), vec!["*"])],
Pick::Pgp(_) => vec![(i18n::t("Alias files (PGP)"), vec!["pgp"])],
}
}
/// The blocking dialog for `pick` (Windows, Linux, FreeBSD).
fn file_dialog(pick: &Pick) -> rfd::FileDialog {
let dialog = filters(pick).iter().fold(rfd::FileDialog::new(), |d, (label, exts)| d.add_filter(*label, exts));
match pick {
Pick::Save(name) => dialog.set_file_name(name),
Pick::Lisp(dir) | Pick::Pgp(dir) if !dir.is_empty() => dialog.set_directory(dir),
_ => dialog,
}
}
@@ -293,6 +324,14 @@ fn main() -> eframe::Result {
}
}
}
// A launch that only names files hands them to the CADCraft already running and exits.
let handed = single_instance::absolute(&files);
let may_hand_off = handed.is_some() && !launch.new_window && !files.is_empty() && control_port.is_none() && !sample;
let instance = match single_instance::claim(handed.as_deref().unwrap_or_default(), may_hand_off) {
single_instance::Claim::HandedOff => return Ok(()),
single_instance::Claim::Primary(server) => Some(server),
single_instance::Claim::Alone => None,
};
install_io();
cadcraft_engine::settings_dir::set(vars.config_dir.clone());
if let Some(dir) = &vars.config_dir {
@@ -353,6 +392,12 @@ fn main() -> eframe::Result {
options,
Box::new(move |cc| {
let mut app = CadApp::new(Session::empty(), services());
// File dialogs are sheets on macOS: a modal loop inside the event handler crashes the
// app when the dialog is resized (#1527).
#[cfg(target_os = "macos")]
if let Some(window) = cc.winit_window().cloned() {
app.services.start_pick = Some(sheet::start_pick(window, cc.egui_ctx.clone()));
}
let (workspace, restored, workspace_error) = workspace::Workspace::load(vars.config_dir.as_deref());
if let Some(ui) = restored {
app.ui = ui;
@@ -407,6 +452,10 @@ fn main() -> eframe::Result {
let metric = app.session.settings.measureinit;
app.session.new_drawing(metric);
}
if let Some(server) = &instance {
let ctx = cc.egui_ctx.clone();
server.set_wake(move || ctx.request_repaint());
}
let ctx = cc.egui_ctx.clone();
let desktop_theme = desktop_theme::DesktopTheme::start(move || ctx.request_repaint());
let ctx = cc.egui_ctx.clone();
@@ -418,6 +467,7 @@ fn main() -> eframe::Result {
spacemouse: spacemouse::SpaceMouse::start(cc.egui_ctx.clone()),
workspace,
workspace_error,
single_instance: instance,
#[cfg(target_os = "macos")]
native_menu: None,
#[cfg(target_os = "macos")]
+51
View File
@@ -0,0 +1,51 @@
//! macOS file dialogs as sheets. Shown in line, or from a helper thread that rfd hands to the main
//! thread's modal loop, a panel runs AppKit's modal event loop; resizing it sends window events
//! back into winit's event handler and winit aborts the app (#1527). A sheet returns at once and
//! the window keeps running; a thread of its own waits for the answer.
use std::sync::Arc;
use cadcraft_ui_egui::{Pick, StartPick};
type Answer = std::pin::Pin<Box<dyn std::future::Future<Output = Option<String>> + Send>>;
/// `Services::start_pick`: shows `pick` as a sheet on `window`; `ui` is woken when it answers.
pub fn start_pick(window: Arc<winit::window::Window>, ui: egui::Context) -> StartPick {
Box::new(move |pick, done| {
let (sheet_tx, sheet_rx) = std::sync::mpsc::channel::<Answer>();
let ui = ui.clone();
// The thread first, so the answer of a sheet once shown always has somewhere to go. If it
// cannot start, `done` is dropped unanswered and the app says the dialog could not be
// shown.
let spawned = std::thread::Builder::new().name("file-dialog".into()).spawn(move || {
if let Ok(answer) = sheet_rx.recv() {
done(pollster::block_on(answer));
ui.request_repaint();
}
});
if let Err(e) = spawned {
log::warn!("file dialog: {e}");
return;
}
// rfd builds the panel and begins the sheet here, on the main thread (as it must).
let dialog =
crate::filters(&pick).iter().fold(rfd::AsyncFileDialog::new().set_parent(&*window), |d, (label, exts)| d.add_filter(*label, exts));
let path = |f: rfd::FileHandle| f.path().to_string_lossy().to_string();
let answer: Answer = match pick {
Pick::Save(name) => {
let picked = dialog.set_file_name(name).save_file();
Box::pin(async move { picked.await.map(path) })
}
Pick::Lisp(dir) | Pick::Pgp(dir) => {
let dialog = if dir.is_empty() { dialog } else { dialog.set_directory(dir) };
let picked = dialog.pick_file();
Box::pin(async move { picked.await.map(path) })
}
Pick::Open => {
let picked = dialog.pick_file();
Box::pin(async move { picked.await.map(path) })
}
};
let _ = sheet_tx.send(answer);
})
}
+393
View File
@@ -0,0 +1,393 @@
//! One CADCraft per Windows sign-in: a launch that only names files hands them to the CADCraft
//! that is already running, where they open as tabs, and exits.
//!
//! Outlook attachments, Explorer double-clicks and Open With all start `cadcraft.exe "<file>"`, so
//! without single instance, every file got its own process and window. The first CADCraft listens on a Unix
//! domain socket (Windows 10 1803 and later) in `%LOCALAPPDATA%\CADCraft`. The socket is named after the
//! Windows session (`instance-Console.sock`), so two sign-ins of the same user never open files in each
//! other's windows. The exchange is one line each way, a JSON request naming absolute paths and `ok`,
//! and the running app opens the paths exactly as File ▸ Open would. `--new-window` opens a window
//! of its own, and so does a launch with anything besides files (`--control`, `--sample`).
use std::path::PathBuf;
use std::sync::{Arc, Mutex, PoisonError};
#[cfg(windows)]
use std::time::Duration;
/// Longest request read: one line of JSON, far longer than any real list of paths.
#[cfg_attr(not(windows), allow(dead_code))]
const MAX_REQUEST: u64 = 1 << 20;
/// How long either side waits for the other before giving up.
#[cfg(windows)]
const TIMEOUT: Duration = Duration::from_secs(5);
/// What this launch should do.
#[cfg_attr(not(windows), allow(dead_code))]
pub enum Claim {
/// The running CADCraft took the files: exit without a window.
HandedOff,
/// This is the first CADCraft: open a window and accept later launches' files.
Primary(Server),
/// Open a window of its own and accept nothing.
Alone,
}
/// Files that later launches handed over, and how to wake the UI for them.
#[derive(Default)]
struct Inbox {
paths: Vec<PathBuf>,
wake: Option<Box<dyn Fn() + Send>>,
}
/// The first CADCraft's end of the socket. A background thread accepts launches until the
/// process exits; the UI picks their files up through [`Server::take_paths`].
#[derive(Clone)]
pub struct Server {
inbox: Arc<Mutex<Inbox>>,
}
impl Server {
#[cfg_attr(not(windows), allow(dead_code))]
fn new() -> Self {
Self { inbox: Arc::default() }
}
/// Queue files from another launch and wake the UI.
#[cfg_attr(not(windows), allow(dead_code))]
fn deliver(&self, paths: Vec<String>) {
let mut inbox = self.inbox.lock().unwrap_or_else(PoisonError::into_inner);
inbox.paths.extend(paths.into_iter().map(PathBuf::from));
if let Some(wake) = &inbox.wake {
wake();
}
}
/// Register a callback to wake the UI when new files arrive.
pub fn set_wake(&self, wake: impl Fn() + Send + 'static) {
self.inbox.lock().unwrap_or_else(PoisonError::into_inner).wake = Some(Box::new(wake));
}
/// Take any queued paths delivered to this server.
pub fn take_paths(&self) -> Vec<PathBuf> {
std::mem::take(&mut self.inbox.lock().unwrap_or_else(PoisonError::into_inner).paths)
}
}
/// The request a launch sends: `{"open":[…]}` and a newline.
#[cfg_attr(not(windows), allow(dead_code))]
pub fn request(paths: &[String]) -> String {
let mut line = serde_json::json!({ "open": paths }).to_string();
line.push('\n');
line
}
/// The paths a request names, or `None` when it isn't a request.
#[cfg_attr(not(windows), allow(dead_code))]
pub fn parse_request(line: &str) -> Option<Vec<String>> {
let value: serde_json::Value = serde_json::from_str(line.trim_end()).ok()?;
let open = value.get("open")?.as_array()?;
let paths = open.iter().map(|p| p.as_str().filter(|s| !s.is_empty()).map(str::to_string)).collect::<Option<Vec<String>>>()?;
(!paths.is_empty()).then_some(paths)
}
/// File arguments made absolute against this launch's working folder, as the request names them.
/// `None` when one isn't valid Unicode: JSON can't carry it unchanged, so that launch opens its
/// own window.
pub fn absolute(paths: &[PathBuf]) -> Option<Vec<String>> {
paths.iter().map(|p| std::path::absolute(p).unwrap_or_else(|_| p.clone()).into_os_string().into_string().ok()).collect()
}
/// Decide what this launch does. `files` are absolute ([`absolute`]); `may_hand_off` is false
/// when the launch asked for anything besides opening files, so it gets its own window.
pub fn claim(files: &[String], may_hand_off: bool) -> Claim {
#[cfg(windows)]
{
match socket_path() {
Some(path) => claim_at(&path, files, may_hand_off),
None => Claim::Alone,
}
}
#[cfg(not(windows))]
{
let _ = (files, may_hand_off);
Claim::Alone
}
}
/// The socket in `%LOCALAPPDATA%\CADCraft`.
#[cfg(windows)]
fn socket_path() -> Option<std::path::PathBuf> {
let name = socket_name(std::env::var("SESSIONNAME").ok().as_deref());
std::env::var_os("LOCALAPPDATA").filter(|v| !v.is_empty()).map(|d| std::path::PathBuf::from(d).join("CADCraft").join(name))
}
/// The socket's file name for a Windows session (`SESSIONNAME`: `Console`, `RDP-Tcp#3`…): a 64-bit
/// FNV-1a hash of the whole name, so two sessions of one user practically never share a socket
/// (`RDP-Tcp#3` and `RDP-Tcp3` stay apart; a user has a handful of sessions, not billions), and the
/// name has a fixed, short length. A Windows socket path holds at most 107
/// bytes including `%LOCALAPPDATA%\CADCraft\`, so the name must not grow with the session's.
#[cfg_attr(not(windows), allow(dead_code))]
fn socket_name(session: Option<&str>) -> String {
let hash = session.unwrap_or_default().bytes().fold(0xcbf2_9ce4_8422_2325_u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3));
format!("{hash:016x}.sock")
}
/// Held while a launch finds out whether it is the first, so launches that start together take turns.
#[cfg(windows)]
fn election(socket: &std::path::Path) -> Option<std::fs::File> {
if let Some(dir) = socket.parent() {
let _ = std::fs::create_dir_all(dir);
}
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).open(socket.with_extension("lock")).ok()?;
let deadline = std::time::Instant::now() + TIMEOUT;
loop {
match file.try_lock() {
Ok(()) => return Some(file),
Err(std::fs::TryLockError::WouldBlock) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
Err(e) => {
log::info!("single instance: no election lock ({e})");
return None;
}
}
}
}
/// [`claim`] with the socket at `path`.
#[cfg(windows)]
fn claim_at(path: &std::path::Path, files: &[String], may_hand_off: bool) -> Claim {
use uds_windows::{UnixListener, UnixStream};
let _election = election(path);
for _ in 0..3 {
match UnixStream::connect(path) {
Ok(stream) => {
if !may_hand_off {
return Claim::Alone;
}
return match hand_off(&stream, files) {
Ok(()) => Claim::HandedOff,
Err(e) => {
log::warn!("couldn't hand the files to the running CADCraft ({e}); opening a new window");
Claim::Alone
}
};
}
// Only a refused or missing socket is stale: any other failure may come from a
// listener that is alive, whose socket must not be taken over.
Err(e) if !matches!(e.kind(), std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::NotFound) => {
log::warn!("single instance off: can't reach {} ({e})", path.display());
return Claim::Alone;
}
Err(_) => match std::fs::remove_file(path) {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
std::thread::sleep(Duration::from_millis(50));
continue;
}
Err(e) => {
log::warn!("single instance off: can't clear {} ({e})", path.display());
return Claim::Alone;
}
},
}
if let Some(dir) = path.parent() {
let _ = std::fs::create_dir_all(dir);
}
match UnixListener::bind(path) {
Ok(listener) => return serve(listener),
Err(e) if e.kind() == std::io::ErrorKind::AddrInUse => continue,
Err(e) => {
log::warn!("single instance off: can't listen at {} ({e})", path.display());
return Claim::Alone;
}
}
}
Claim::Alone
}
/// Send `files` over `stream` and wait for the running app's `ok`.
#[cfg(windows)]
fn hand_off(stream: &uds_windows::UnixStream, files: &[String]) -> std::io::Result<()> {
use std::io::{BufRead, Read, Write};
stream.set_read_timeout(Some(TIMEOUT))?;
stream.set_write_timeout(Some(TIMEOUT))?;
let mut writer = stream;
writer.write_all(request(files).as_bytes())?;
let mut reply = String::new();
std::io::BufReader::new(stream.take(16)).read_line(&mut reply)?;
if reply == "ok\n" { Ok(()) } else { Err(std::io::Error::other("the running CADCraft didn't confirm")) }
}
/// Accept launches on a background thread for as long as the process runs.
#[cfg(windows)]
fn serve(listener: uds_windows::UnixListener) -> Claim {
let server = Server::new();
let inbox = Server { inbox: Arc::clone(&server.inbox) };
let started = std::thread::Builder::new().name("single-instance".into()).spawn(move || {
for stream in listener.incoming() {
let result = stream.and_then(|s| receive(&s, &inbox));
if let Err(e) = result {
log::warn!("single instance: a launch's request failed ({e})");
std::thread::sleep(Duration::from_millis(100));
}
}
});
match started {
Ok(_) => Claim::Primary(server),
Err(e) => {
log::warn!("single instance off: no listener thread ({e})");
Claim::Alone
}
}
}
/// Read one launch's request, queue its files and confirm.
#[cfg(windows)]
fn receive(stream: &uds_windows::UnixStream, server: &Server) -> std::io::Result<()> {
use std::io::{BufRead, Read, Write};
stream.set_read_timeout(Some(TIMEOUT))?;
stream.set_write_timeout(Some(TIMEOUT))?;
let mut line = String::new();
std::io::BufReader::new(stream.take(MAX_REQUEST)).read_line(&mut line)?;
if line.is_empty() {
return Ok(());
}
let paths = parse_request(&line)
.filter(|paths| paths.iter().all(|p| std::path::Path::new(p).is_absolute()))
.ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidData, "not an open request of absolute paths"))?;
server.deliver(paths);
let mut writer = stream;
writer.write_all(b"ok\n")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_request_names_its_paths_and_parses_back() {
let paths = vec![r"C:\Plans\Ground floor.dwg".to_string(), "C:\\Plans\\Schnitt ä.dxf".to_string()];
let line = request(&paths);
assert!(line.ends_with('\n') && !line.trim_end().contains('\n'), "{line:?}");
assert_eq!(parse_request(&line), Some(paths));
}
#[test]
fn anything_else_is_not_a_request() {
for line in ["", "ok\n", "{}", r#"{"open":[]}"#, r#"{"open":[""]}"#, r#"{"open":["a",1]}"#, r#"{"open":"a"}"#, "[\"a\"]"] {
assert_eq!(parse_request(line), None, "{line:?}");
}
}
#[test]
fn the_socket_is_named_after_the_session() {
let names = [None, Some(""), Some("Console"), Some("RDP-Tcp#3"), Some("RDP-Tcp3"), Some(r"..\x")];
let sockets: Vec<String> = names.iter().map(|n| socket_name(*n)).collect();
// No session name is the same as an empty one; every other name gets its own socket.
assert_eq!(sockets[0], sockets[1]);
let distinct: std::collections::HashSet<&String> = sockets[1..].iter().collect();
assert_eq!(distinct.len(), names.len() - 1, "{sockets:?}");
// Short, fixed and safe as a file name, whatever the session is called.
let long = socket_name(Some(&"\u{10ffff}".repeat(32)));
for s in sockets.iter().chain([&long]) {
assert_eq!(s.len(), 21, "{s}");
assert!(s.strip_suffix(".sock").is_some_and(|h| h.bytes().all(|b| b.is_ascii_hexdigit())), "{s}");
}
// Names that differ only past the 32nd character stay apart.
let long = "S".repeat(40);
assert_ne!(socket_name(Some(&long)), socket_name(Some(&long[..39])));
}
#[test]
fn files_are_made_absolute() {
let files = absolute(&[PathBuf::from("a.dwg")]).unwrap();
assert_eq!(files.len(), 1);
assert!(std::path::Path::new(&files[0]).is_absolute() && files[0].ends_with("a.dwg"), "{files:?}");
}
#[test]
fn delivered_files_wait_for_the_ui_and_wake_it() {
let server = Server::new();
let woken = Arc::new(Mutex::new(0));
let count = Arc::clone(&woken);
server.set_wake(move || *count.lock().unwrap() += 1);
server.deliver(vec!["a.dwg".into()]);
server.deliver(vec!["b.dxf".into()]);
assert_eq!(*woken.lock().unwrap(), 2);
assert_eq!(server.take_paths(), [PathBuf::from("a.dwg"), PathBuf::from("b.dxf")]);
assert!(server.take_paths().is_empty());
}
/// Removes a test's folder when the test ends, best effort: the listener thread keeps its socket
/// open until the process exits.
#[cfg(windows)]
struct Cleanup(PathBuf);
#[cfg(windows)]
impl Drop for Cleanup {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A fresh folder for one test, and its socket path.
#[cfg(windows)]
fn socket_dir(test: &str) -> (Cleanup, PathBuf) {
let dir = std::env::temp_dir().join(format!("cadcraft-single-instance-{}-{test}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("instance-test.sock");
(Cleanup(dir), path)
}
/// The whole exchange over a real socket: a stale socket file is taken over, a later launch
/// hands its files to that listener, one that asked for its own window gets it, and a request
/// naming a relative path is refused.
#[cfg(windows)]
#[test]
fn a_later_launch_hands_its_files_to_the_first() {
let (dir, path) = socket_dir("handoff");
drop(uds_windows::UnixListener::bind(&path).unwrap());
assert!(path.exists(), "the stale socket file stays behind");
let Claim::Primary(server) = claim_at(&path, &[], false) else { panic!("the stale socket wasn't taken over") };
let files = vec![dir.0.join("a.dwg").to_string_lossy().into_owned()];
// The listener queues the files before it confirms, so they are there once this returns.
assert!(matches!(claim_at(&path, &files, true), Claim::HandedOff));
assert_eq!(server.take_paths(), [PathBuf::from(&files[0])]);
assert!(matches!(claim_at(&path, &files, false), Claim::Alone));
assert!(server.take_paths().is_empty());
// Not confirmed, so that launch opens its own window and nothing is queued.
assert!(matches!(claim_at(&path, &["a.dwg".to_string()], true), Claim::Alone));
assert!(server.take_paths().is_empty());
}
/// Launches that start together take turns: one opens the window, the others hand it their files.
#[cfg(windows)]
#[test]
fn launches_at_once_open_one_window() {
const LAUNCHES: usize = 6;
let (dir, path) = socket_dir("together");
let start = Arc::new(std::sync::Barrier::new(LAUNCHES));
let launches: Vec<_> = (0..LAUNCHES)
.map(|i| {
let (path, start) = (path.clone(), Arc::clone(&start));
let file = dir.0.join(format!("{i}.dwg")).to_string_lossy().into_owned();
std::thread::spawn(move || {
start.wait();
(file.clone(), claim_at(&path, &[file], true))
})
})
.collect();
let results: Vec<(String, Claim)> = launches.into_iter().map(|t| t.join().unwrap()).collect();
let servers: Vec<&Server> = results.iter().filter_map(|(_, c)| if let Claim::Primary(s) = c { Some(s) } else { None }).collect();
assert_eq!(servers.len(), 1, "one window");
let mut handed: Vec<PathBuf> = results.iter().filter(|(_, c)| matches!(c, Claim::HandedOff)).map(|(f, _)| PathBuf::from(f)).collect();
assert_eq!(handed.len(), LAUNCHES - 1, "the rest handed their files over");
let mut received = servers[0].take_paths();
handed.sort();
received.sort();
assert_eq!(received, handed);
}
}
-1
View File
@@ -44,7 +44,6 @@ fn snapshot(ui: &UiState) -> Result<Value, String> {
"showStatusBar": ui.show_status_bar,
"showCommandLine": ui.show_command_line,
"showViewcube": ui.show_viewcube,
"showUcsIcon": ui.show_ucs_icon,
"showLayerList": ui.show_layer_list,
"toolsetTab": ui.toolset_tab,
"collapsedGroups": ui.collapsed_groups,
+13 -1
View File
@@ -37,7 +37,9 @@ display_name = "Tasos Sangiotis"
sync_github_name = false
[people.vangel76]
sync_github_name = true
real_name = "Valentin Klein"
display_name = "vangel76"
sync_github_name = false
[people.WladmirJunior]
real_name = "Wladmir Júnior"
@@ -104,6 +106,10 @@ sync_github_name = true
[people.GULERTOLGA]
sync_github_name = true
[people.Obtrusive8276]
display_name = "Nicopicks"
sync_github_name = false
[people.Tyler-Chiriboga]
real_name = "Tyler Chiriboga"
sync_github_name = true
@@ -116,3 +122,9 @@ sync_github_name = true
[people.helenkwok]
real_name = "Helen Kwok"
[people.V1dalTheAbidal]
sync_github_name = true
[people.tyrel]
real_name = "Tyrel Haveman"
+53 -26
View File
@@ -1,5 +1,5 @@
//! CAD colours: the 256-entry colour index (ACI), 24-bit true colour, and the logical
//! ByLayer / ByBlock values. The index palette is generated from its well-known structure
//! `ByLayer` / `ByBlock` values. The index palette is generated from its well-known structure
//! (24 hues × 5 values × 2 saturations, plus primaries and greys), not copied from any file.
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
@@ -11,12 +11,15 @@ use serde::{Deserialize, Serialize};
pub struct Rgb(pub u8, pub u8, pub u8);
impl Rgb {
#[must_use]
pub fn to_u32(self) -> u32 {
(u32::from(self.0) << 16) | (u32::from(self.1) << 8) | u32::from(self.2)
}
#[must_use]
pub fn from_u32(v: u32) -> Rgb {
Rgb(((v >> 16) & 0xff) as u8, ((v >> 8) & 0xff) as u8, (v & 0xff) as u8)
}
#[must_use]
pub fn hex(self) -> String {
format!("#{:02x}{:02x}{:02x}", self.0, self.1, self.2)
}
@@ -29,6 +32,7 @@ impl Rgb {
u32::from_str_radix(s, 16).ok().map(Rgb::from_u32)
}
/// Relative luminance (0..1) for contrast decisions.
#[must_use]
pub fn luma(self) -> f64 {
(0.2126 * f64::from(self.0) + 0.7152 * f64::from(self.1) + 0.0722 * f64::from(self.2)) / 255.0
}
@@ -48,7 +52,8 @@ pub enum Color {
impl Color {
pub const WHITE: Color = Color::Index(7);
/// DXF group 62 value: 0 = ByBlock, 256 = ByLayer.
/// DXF group 62 value: 0 = `ByBlock`, 256 = `ByLayer`.
#[must_use]
pub fn to_aci(self) -> i16 {
match self {
Color::ByLayer => 256,
@@ -57,14 +62,16 @@ impl Color {
Color::True(rgb) => i16::from(nearest_aci(rgb)),
}
}
#[must_use]
pub fn from_aci(v: i16) -> Color {
match v {
0 => Color::ByBlock,
1..=255 => Color::Index(v as u8),
1..=255 => u8::try_from(v).map_or(Color::ByLayer, Color::Index),
_ => Color::ByLayer,
}
}
/// Resolve to RGB given the layer and block colours.
#[must_use]
pub fn resolve(self, layer: Color, block: Color) -> Rgb {
match self {
Color::ByLayer => match layer {
@@ -79,7 +86,8 @@ impl Color {
Color::True(c) => c,
}
}
/// Short display name like AutoCAD's Properties palette ("ByLayer", "Red", "Color 34", "255,128,0").
/// Short display name like `AutoCAD`'s Properties palette ("`ByLayer`", "Red", "Color 34", "255,128,0").
#[must_use]
pub fn name(self) -> String {
match self {
Color::ByLayer => "ByLayer".into(),
@@ -102,7 +110,7 @@ impl Color {
let t = s.trim().to_ascii_lowercase();
let named = ["", "red", "yellow", "green", "cyan", "blue", "magenta", "white"];
if let Some(i) = named.iter().position(|n| !n.is_empty() && *n == t) {
return Some(Color::Index(i as u8));
return u8::try_from(i).ok().map(Color::Index);
}
match t.as_str() {
"bylayer" => return Some(Color::ByLayer),
@@ -117,7 +125,7 @@ impl Color {
return match i {
0 => Some(Color::ByBlock),
256 => Some(Color::ByLayer),
1..=255 => Some(Color::Index(i as u8)),
1..=255 => u8::try_from(i).ok().map(Color::Index),
_ => None,
};
}
@@ -145,11 +153,16 @@ pub fn aci_rgb(i: u8) -> Rgb {
PALETTE.get(usize::from(i)).copied().unwrap_or(Rgb(255, 255, 255))
}
/// The palette as a 256-entry table (entry 0 = ByBlock placeholder = black).
/// The palette as a 256-entry table (entry 0 = `ByBlock` placeholder = black).
pub static PALETTE: std::sync::LazyLock<[Rgb; 256]> = std::sync::LazyLock::new(build_palette);
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "Palette channels are finite and clamped to the u8 range before conversion."
)]
fn build_palette() -> [Rgb; 256] {
let mut p = [Rgb(0, 0, 0); 256];
let mut palette = [Rgb(0, 0, 0); 256];
let base = [
Rgb(0, 0, 0),
Rgb(255, 0, 0),
@@ -159,37 +172,38 @@ fn build_palette() -> [Rgb; 256] {
Rgb(0, 0, 255),
Rgb(255, 0, 255),
Rgb(255, 255, 255),
Rgb(65, 65, 65),
Rgb(128, 128, 128),
Rgb(192, 192, 192),
];
for (slot, c) in p.iter_mut().zip(base) {
*slot = c;
for (slot, colour) in palette.iter_mut().zip(base) {
*slot = colour;
}
let values = [255.0, 204.0, 153.0, 127.0, 76.0];
for i in 10..250usize {
let hue = (i - 10) / 10; // 0..24, 15° each
let sub = i % 10;
let v: f64 = values.get(sub / 2).copied().unwrap_or(255.0);
for index in 10..250usize {
let hue = (index - 10) / 10; // 0..24, 15° each
let sub = index % 10;
let value: f64 = values.get(sub / 2).copied().unwrap_or(255.0);
let half = sub % 2 == 1;
let (r, g, b) = hue_fractions(hue);
let ch = |f: f64| -> u8 {
let f = if half { 0.5 + 0.5 * f } else { f };
(v * f).floor().clamp(0.0, 255.0) as u8
let (red, green, blue) = hue_fractions(hue);
let channel = |fraction: f64| -> u8 {
let fraction = if half { 0.5 + 0.5 * fraction } else { fraction };
(value * fraction).floor().clamp(0.0, 255.0) as u8
};
if let Some(slot) = p.get_mut(i) {
*slot = Rgb(ch(r), ch(g), ch(b));
if let Some(slot) = palette.get_mut(index) {
*slot = Rgb(channel(red), channel(green), channel(blue));
}
}
let greys = [51u8, 91, 132, 173, 214, 255];
for (k, g) in greys.iter().enumerate() {
if let Some(slot) = p.get_mut(250 + k) {
*slot = Rgb(*g, *g, *g);
let greys = [51u8, 80, 105, 130, 190, 255];
for (offset, shade) in greys.iter().enumerate() {
if let Some(slot) = palette.get_mut(250 + offset) {
*slot = Rgb(*shade, *shade, *shade);
}
}
p
palette
}
/// Channel fractions for hue step 0..24 (red → yellow → green → cyan → blue → magenta → red).
#[expect(clippy::cast_precision_loss, reason = "Only the four hue offsets 0..=3 are converted; they are exact in f64.")]
fn hue_fractions(h: usize) -> (f64, f64, f64) {
let seg = h / 4;
let t = (h % 4) as f64 / 4.0;
@@ -204,6 +218,7 @@ fn hue_fractions(h: usize) -> (f64, f64, f64) {
}
/// The closest index colour to an RGB value (1..=255).
#[must_use]
pub fn nearest_aci(c: Rgb) -> u8 {
let mut best = (u32::MAX, 7u8);
for i in 1..=255u8 {
@@ -220,6 +235,7 @@ pub fn nearest_aci(c: Rgb) -> u8 {
/// Display colour of `c` on `background`. Colour 7 (`aci7`) flips to contrast with the
/// background, white on dark and black on light (paper), as CAD programs draw it; every other
/// colour, including a true-colour or index white or black, keeps its RGB.
#[must_use]
pub fn display_rgb(c: Rgb, aci7: bool, background: Rgb) -> Rgb {
if !aci7 {
c
@@ -286,6 +302,17 @@ mod tests {
assert_eq!(aci_rgb(255), Rgb(255, 255, 255));
}
#[test]
fn palette_fixed_greys() {
assert_eq!(aci_rgb(8), Rgb(65, 65, 65));
assert_eq!(aci_rgb(9), Rgb(128, 128, 128));
for (i, g) in [(250u8, 51u8), (251, 80), (252, 105), (253, 130), (254, 190)] {
assert_eq!(aci_rgb(i), Rgb(g, g, g));
}
assert_eq!(nearest_aci(Rgb(65, 65, 65)), 8);
assert_eq!(nearest_aci(Rgb(128, 128, 128)), 9);
}
#[test]
fn aci_roundtrip_and_parse() {
assert_eq!(Color::from_aci(256), Color::ByLayer);
+12 -6
View File
@@ -232,6 +232,10 @@ pub fn infer_placed(d: &Drawing, placed: &[Handle], others: &[Handle], o: &Infer
let mut extra = Vec::new();
let mut on = Vec::new();
for (rp, p) in g.points.iter().filter(|(r, _)| placed.contains(&r.handle)) {
// Nothing is added once the candidates are full, so the points left need no search.
if extra.len() + on.len() + out.len() >= MAX_CANDIDATES {
break;
}
if out.iter().any(|c| c.kind == ConstraintKind::Coincident && c.refs.contains(rp)) {
continue;
}
@@ -267,20 +271,22 @@ pub fn infer_placed(d: &Drawing, placed: &[Handle], others: &[Handle], o: &Infer
// Perpendicular lines meeting in a T (a perpendicular snap onto the middle of a line).
let atol = if o.angle_tolerance.is_finite() { o.angle_tolerance.clamp(0.0, 45.0).to_radians() } else { 0.0 };
let allow_per = o.types.is_empty() || o.types.iter().any(|t| t.eq_ignore_ascii_case(ConstraintKind::Perpendicular.name()));
for (r1, a1, b1) in g.lines.iter().filter(|(r, _, _)| placed.contains(&r.handle)) {
'per: for (r1, a1, b1) in g.lines.iter().filter(|(r, _, _)| allow_per && placed.contains(&r.handle)) {
for (r2, a2, b2) in g.lines.iter().filter(|(r, _, _)| r.handle != r1.handle) {
// Full: nothing more can be added, so the pairs left need no geometry or duplicate search.
if out.len() + extra.len() + on.len() >= MAX_CANDIDATES {
break 'per;
}
let (l1, l2) = (Line::new(*a1, *b1), Line::new(*a2, *b2));
let touches = |l: &Line, p: Vec2| l.dist(p) <= tol && (0.0..=1.0).contains(&l.param_of(p));
let tee = [*a1, *b1].iter().any(|p| touches(&l2, *p)) || [*a2, *b2].iter().any(|p| touches(&l1, *p));
let ang = ang_between(*b1 - *a1, *b2 - *a2);
let dup = out.iter().any(|c| c.kind == ConstraintKind::Perpendicular && c.refs.contains(r1) && c.refs.contains(r2));
if allow_per
&& tee
&& !dup
// The duplicate search scans every candidate, so it comes after the cheap tests.
if tee
&& (std::f64::consts::FRAC_PI_2 - ang).abs() <= atol
&& l1.len() > tol
&& l2.len() > tol
&& out.len() < MAX_CANDIDATES
&& !out.iter().any(|c| c.kind == ConstraintKind::Perpendicular && c.refs.contains(r1) && c.refs.contains(r2))
{
out.push(Constraint { id: 0, kind: ConstraintKind::Perpendicular, refs: vec![*r1, *r2], name: String::new(), expr: String::new() });
}
+3 -1
View File
@@ -138,7 +138,9 @@ pub fn dof(d: &Drawing, handles: &[Handle]) -> Result<DofReport, SolveError> {
let cons: Vec<&Constraint> = d.constraints.iter().take(MAX_CONSTRAINTS).collect();
let mut prep = Prep::new(crate::model::MAX_RIGID_WORK);
let (comps, _) = build_with(d, &cons, &SolveOptions::default(), &mut prep)?;
let want = |h: Handle| handles.is_empty() || handles.contains(&h);
// The selection as a set, built once: a scan of the list per slot multiplied the two sizes.
let selected: HashSet<Handle> = handles.iter().copied().collect();
let want = |h: Handle| handles.is_empty() || selected.contains(&h);
let mut objects = Vec::new();
let mut seen = HashSet::new();
let mut total = Some(0usize);
+31 -1
View File
@@ -204,6 +204,23 @@ impl ArrayParams {
self.replaced.iter().rev().find(|r| (r.i, r.j, r.level) == (i, j, level)).map_or(self.source.as_str(), |r| r.block.as_str())
}
/// [`block_for`](Self::block_for) for many items: the replacements are indexed once (the last
/// entry for a place wins, as there), so each lookup is O(1) instead of a scan of `replaced`.
pub fn block_lookup<'a>(&'a self) -> impl Fn(u32, u32, u32) -> &'a str + 'a {
// Only places `items()` generates are indexed, so stray out-of-range records cost nothing.
let (cols, rows) = match &self.kind {
ArrayKind::Rect(r) => (r.cols, r.rows),
ArrayKind::Polar(p) => (p.items, p.rows),
};
let index: std::collections::HashMap<(u32, u32, u32), &str> = self
.replaced
.iter()
.filter(|r| r.i < cols && r.j < rows && r.level < self.levels)
.map(|r| ((r.i, r.j, r.level), r.block.as_str()))
.collect();
move |i, j, level| index.get(&(i, j, level)).copied().unwrap_or(self.source.as_str())
}
/// The block references that make up the array block: one per item, on layer 0 with ByBlock
/// properties so they take the array's. Handles are allocated from `d`. `None` when the
/// parameters are not [valid](Self::is_valid).
@@ -217,9 +234,10 @@ impl ArrayParams {
..Common::default()
};
let mut out = Vec::with_capacity(items.len());
let block_for = self.block_lookup();
for it in items {
let ins = Insert {
block: self.block_for(it.i, it.j, it.level).to_string(),
block: block_for(it.i, it.j, it.level).to_string(),
insert: it.insert,
scale: Vec3::new(1.0, 1.0, 1.0),
rotation: it.rotation,
@@ -301,6 +319,18 @@ mod tests {
}
}
#[test]
fn block_lookup_agrees_with_block_for_and_the_last_replacement_wins() {
let mut p = rect(3, 2);
let r = |i, j, level, b: &str| ReplacedItem { i, j, level, block: b.into() };
p.replaced = vec![r(1, 0, 0, "A"), r(1, 0, 0, "B"), r(2, 1, 1, "C")];
let look = p.block_lookup();
for (i, j, level) in [(0, 0, 0), (1, 0, 0), (2, 1, 1), (2, 1, 0)] {
assert_eq!(look(i, j, level), p.block_for(i, j, level));
}
assert_eq!((look(1, 0, 0), look(0, 0, 0)), ("B", "*U1"));
}
#[test]
fn rect_items_go_column_row_level() {
let items = rect(3, 2).items().unwrap_or_default();
+6
View File
@@ -674,6 +674,10 @@ fn apply(
/// Associative hatches of block `b` whose loop is one closed polyline of the block take its
/// outline again (it may have been stretched).
fn refill_hatches(b: &mut Block) {
// Each loop gets its own copy of the outline, so many small loops on one big outline multiply it;
// past this many vertices in all, the remaining loops keep the outline they have.
const MAX_REFILLED_VERTICES: usize = 4_000_000;
let mut budget = MAX_REFILLED_VERTICES;
let outlines: HashMap<Handle, Vec<cadcraft_geom::PolyVertex>> = b
.entities
.iter()
@@ -689,7 +693,9 @@ fn refill_hatches(b: &mut Block) {
for l in &mut hh.loops {
if let [s] = l.sources.as_slice()
&& let Some(vs) = outlines.get(s)
&& let Some(left) = budget.checked_sub(vs.len())
{
budget = left;
l.vertices.clone_from(vs);
}
}
+6
View File
@@ -55,6 +55,8 @@ impl ForeignExtra {
pub struct Foreign {
/// CLASS records (groups after `0 CLASS`) of the kept objects' and entities' types.
pub classes: Vec<Vec<RawTag>>,
/// Classes retain every source position, including duplicate names.
pub complete_class_table: bool,
/// Kept objects, in file order.
pub objects: Vec<ForeignObject>,
/// Entries of the named object dictionary that CADCraft doesn't write itself: (key, object).
@@ -70,6 +72,10 @@ pub struct Foreign {
/// proxy objects or entities: a proxy's class number (group 91) is 500 plus its class's place
/// here, and saving renumbers it to the written CLASSES (#1812).
pub class_order: Vec<String>,
/// The roles of every file handle of an object CADCraft writes itself (table records, tables,
/// blocks, the named object dictionary and its entries), so that AutoLISP names those objects
/// as the file did (`handent`). Saving gives them new handles; not part of [`Foreign::is_empty`].
pub handles: BTreeMap<Handle, ForeignKey>,
/// The file's data store section (ACDSDATA, AutoCAD 2013 and later), as read: its groups
/// after the section name. It holds the ACIS geometry of 3D solids, regions, bodies and
/// surfaces, which from 2013 on those entities don't carry themselves: each `ACDSRECORD`
+18 -3
View File
@@ -130,6 +130,10 @@ pub struct Drawing {
/// Objects hidden for this session by ISOLATEOBJECTS / HIDEOBJECTS. Never written to a file:
/// a drawing opens with everything shown again.
pub hidden_objects: BTreeSet<Handle>,
/// Model space's earlier UCSs for UCS Previous, oldest first (each layout keeps its own,
/// [`Layout::ucs_previous`]). Part of the drawing so undo restores them with the UCS. Never
/// written to a file.
pub ucs_previous: Vec<Ucs>,
/// What reading the file left out (a DWG's object records the reader couldn't decode), told
/// to the user when the drawing opens. Never written to a file.
pub read_notes: Vec<String>,
@@ -201,6 +205,7 @@ impl Drawing {
scales: imperial_scales(),
handseed: 0x100,
hidden_objects: BTreeSet::new(),
ucs_previous: Vec::new(),
read_notes: Vec::new(),
refedit: None,
skipped_records: BTreeMap::new(),
@@ -209,12 +214,22 @@ impl Drawing {
}
}
/// Allocate a fresh handle.
/// Allocate a fresh handle. It skips the handles the drawing's file gave the objects CADCraft
/// writes itself ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a
/// file CADCraft wrote numbers them above its `$HANDSEED` (#495).
pub fn new_handle(&mut self) -> Handle {
let h = Handle(self.handseed);
self.handseed = self.handseed.saturating_add(1);
let h = self.next_handle();
self.handseed = h.0.saturating_add(1);
h
}
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it.
pub fn next_handle(&self) -> Handle {
let mut h = self.handseed;
while self.foreign.handles.contains_key(&Handle(h)) && h < u64::MAX {
h = h.saturating_add(1);
}
Handle(h)
}
/// Make sure future handles don't collide with `h` (after loading a file).
pub fn bump_handseed(&mut self, h: Handle) {
if h.0 >= self.handseed {
+28 -2
View File
@@ -476,6 +476,7 @@ impl DimStyle {
match field {
"textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
"scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
"decimals" | "altDecimals" | "tolDecimals" => x.is_some_and(|x| !(0.0..=8.0).contains(&x)),
"fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
"textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
"dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
@@ -486,16 +487,24 @@ impl DimStyle {
/// Set fields from a JSON object of field or DIM* variable names (numbers, booleans as
/// 0/1, colours as ACI numbers or names). Returns the names that were not recognised or
/// had unusable values.
/// had unusable values. When several spellings name one field, the last one wins and the
/// superseded ones are not validated.
pub fn apply_fields(&mut self, src: &serde_json::Map<String, serde_json::Value>) -> Vec<String> {
use serde_json::Value;
let mut rejected = Vec::new();
let Ok(mut cur) = serde_json::to_value(&*self) else { return src.keys().cloned().collect() };
// Spellings of one field (`DIMPOST`, `dimpost`, `textPrefix`…): only the last is applied, so
// the style is checked once per field, not once per spelling (each check copies its strings).
let last_spelling: std::collections::HashMap<&str, &String> =
src.keys().filter_map(|k| DimStyle::field_name(k).filter(|f| *f != "name").map(|f| (f, k))).collect();
for (k, v) in src {
let Some(field) = DimStyle::field_name(k).filter(|f| *f != "name") else {
rejected.push(k.clone());
continue;
};
if last_spelling.get(field) != Some(&k) {
continue;
}
let Some(obj) = cur.as_object_mut() else { break };
let Some(old) = obj.get(field).cloned() else {
rejected.push(k.clone());
@@ -848,6 +857,14 @@ pub struct Layout {
/// Saved paper-space view (centre, height).
#[serde(default)]
pub view: Option<(Vec2, f64)>,
/// The layout's current paper-space UCS (the LAYOUT object's groups 13, 16, 17 and 345);
/// `None`: the World UCS. Its name is empty when it isn't a named UCS.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ucs: Option<Ucs>,
/// The layout's earlier UCSs for UCS Previous, oldest first: they go with the layout when it
/// is renamed and with it when it is deleted. Never written to a file.
#[serde(skip)]
pub ucs_previous: Vec<Ucs>,
/// The layout's limits (LAYOUT groups 10/11, lower left and upper right) as the file had
/// them; `None` for a layout CADCraft made, written as 0,0 to 12,9 (#2109).
#[serde(default, skip_serializing_if = "Option::is_none")]
@@ -856,7 +873,16 @@ pub struct Layout {
impl Layout {
pub fn new(name: &str, tab_order: u32) -> Self {
Layout { name: name.into(), tab_order, page: PageSetup::default(), entities: EntityStore::new(), view: None, limits: None }
Layout {
name: name.into(),
tab_order,
page: PageSetup::default(),
entities: EntityStore::new(),
view: None,
ucs: None,
ucs_previous: Vec::new(),
limits: None,
}
}
}
+22
View File
@@ -714,3 +714,25 @@ fn space_names_its_tab() {
assert_eq!(p.layout(), Some("Sheet A"));
assert_eq!(p.tab_name(), "Sheet A");
}
#[test]
fn new_handles_skip_the_files_object_handles() {
let mut d = Drawing::new_metric();
let next = d.handseed;
let f = std::sync::Arc::make_mut(&mut d.foreign);
f.handles.insert(Handle(next), ("LAYER".into(), "0".into()));
f.handles.insert(Handle(next + 1), ("NOD".into(), String::new()));
assert_eq!(d.new_handle(), Handle(next + 2));
assert_eq!(d.new_handle(), Handle(next + 3));
}
/// Several spellings of one DIM field apply once, the last in the map's order, and none is rejected.
#[test]
fn dim_style_spellings_of_one_field_apply_once() {
let mut st = DimStyle::default();
let m = serde_json::json!({ "textHeight": 2.5, "TEXTHEIGHT": 3.5, "DIMTXT": 4.5 });
let m = m.as_object().unwrap();
let want = m.values().next_back().and_then(serde_json::Value::as_f64).unwrap();
assert!(st.apply_fields(m).is_empty());
assert_eq!(st.text_height, want);
}
-19
View File
@@ -1,19 +0,0 @@
[package]
name = "cadcraft-dwg"
description = "CADCraft DWG bridge: converts DWG to and from DXF bytes using the acadrust crate (MPL-2.0, used unmodified)"
version.workspace = true
edition.workspace = true
license.workspace = true
[lints]
workspace = true
[dependencies]
log = { workspace = true }
# The same targets as build.rs's `no_dwg_bridge` leave acadrust out: wasm32, and FreeBSD aarch64,
# where acadrust 0.6.6 passes a `*const c_char` (u8 there) to its own `*const i8` sysctlbyname.
# 0.6.7 and 0.6.8 fix that but read some damaged DWGs as empty with no note (tests.rs, #800).
[target.'cfg(not(any(target_arch = "wasm32", all(target_os = "freebsd", target_arch = "aarch64"))))'.dependencies]
# MPL-2.0: used as an unmodified dependency only (see plan/adr/0001 and NOTICE).
acadrust = "0.6.6"
-12
View File
@@ -1,12 +0,0 @@
//! Sets `no_dwg_bridge` on the targets built without acadrust (see Cargo.toml): the DWG functions
//! there return an error that says to use DXF.
fn main() {
println!("cargo:rerun-if-changed=build.rs");
println!("cargo::rustc-check-cfg=cfg(no_dwg_bridge)");
let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
if arch == "wasm32" || (os == "freebsd" && arch == "aarch64") {
println!("cargo::rustc-cfg=no_dwg_bridge");
}
}
File diff suppressed because it is too large Load Diff
-378
View File
@@ -1,378 +0,0 @@
//! The DWG reader and writer in a child process.
//!
//! An allocation failure or stack overflow in the third-party code ends the process it runs in, and
//! `catch_unwind` can't stop that. So the app runs them in a copy of itself: [`use_own_worker`] says
//! how to start one, and [`serve_if_asked`], first thing in `main`, turns the copy into a worker
//! that reads one request from standard input and writes one reply to standard output. A file that
//! kills the worker then costs that one open or save, and every other open drawing stays safe.
//!
//! Without a worker (libraries, tests, a build that can't start one) [`decode`] and [`encode_as`]
//! run in the calling process, as they always did. There's no memory limit on the worker yet: that
//! takes per-platform system calls, which `unsafe_code = "forbid"` keeps out of this crate.
//!
//! A reply comes from a process that just handled a possibly hostile file, so it is parsed as
//! untrusted input.
use std::ffi::OsString;
use std::io::{Read, Write};
use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::sync::Mutex;
use std::sync::mpsc::{RecvTimeoutError, channel};
use std::time::Duration;
use super::Limits;
/// The argument that makes the app a worker.
pub const WORKER_ARG: &str = "--dwg-worker";
/// Bumped when the messages change: an app updated while running may start a newer copy.
const PROTOCOL: u8 = 2;
const DECODE: u8 = 1;
const ENCODE: u8 = 2;
const CRASH: u8 = 0xff;
/// How long one file may take before the worker is stopped. It can't be interrupted otherwise.
const TIMEOUT: Duration = Duration::from_secs(30 * 60);
/// Most bytes accepted for what a reply carries besides the drawing.
const MAX_NOTES_BYTES: u64 = 64 << 20;
/// Most bytes accepted as a written DWG.
const MAX_DWG_REPLY: u64 = 2 << 30;
/// Most bytes one request holds: the largest input, whichever the direction, and its header.
const MAX_REQUEST: u64 = (2 << 30) + 256;
struct Worker {
program: PathBuf,
args: Vec<OsString>,
}
static WORKER: Mutex<Option<Worker>> = Mutex::new(None);
/// Start `program args` as the worker from now on. `program` must call [`serve_if_asked`].
pub fn use_worker(program: PathBuf, args: Vec<OsString>) {
if let Ok(mut w) = WORKER.lock() {
*w = Some(Worker { program, args });
}
}
/// Use a copy of this program as the worker, started with [`WORKER_ARG`]. If its path can't be
/// found, the reader and writer stay in this process.
pub fn use_own_worker() {
match std::env::current_exe() {
Ok(program) => use_worker(program, vec![WORKER_ARG.into()]),
Err(e) => log::warn!("DWG worker: can't find this program: {e}"),
}
}
/// Serve one request and return the exit code if this process was started as a worker.
pub fn serve_if_asked() -> Option<i32> {
(std::env::args_os().nth(1)? == WORKER_ARG).then(|| serve(std::io::stdin().lock(), std::io::stdout().lock()))
}
/// [`super::dwg_to_dxf_noted`] in the worker, when there is one.
pub fn decode(bytes: &[u8], limits: Limits) -> Result<(Vec<u8>, Vec<String>), String> {
// Before starting a process, and so the same limit holds with or without one.
if bytes.len() > limits.max_dwg_bytes {
return super::dwg_to_dxf_noted(bytes, limits);
}
let reply_limit = (limits.max_dxf_bytes as u64).saturating_add(MAX_NOTES_BYTES);
match call(&request(DECODE, limits, ""), bytes, reply_limit, "reading this file") {
Some(reply) => reply?,
None => super::dwg_to_dxf_noted(bytes, limits),
}
}
/// [`super::dxf_to_dwg_as`] in the worker, when there is one.
pub fn encode_as(dxf: &[u8], version: &str) -> Result<Vec<u8>, String> {
encode_noted(dxf, version).map(|(dwg, _)| dwg)
}
/// [`super::dxf_to_dwg_noted`] in the worker, when there is one. What the writer left out comes
/// back as notes of `TYPE<tab>count`.
pub fn encode_noted(dxf: &[u8], version: &str) -> Result<(Vec<u8>, super::Unwritten), String> {
encode_kept_noted(dxf, version, None)
}
/// [`encode_noted`] for a DXF whose carried-over groups were read from a file of version `kept`
/// ([`super::dxf_to_dwg_kept_noted`]); `None` is [`encode_noted`].
pub fn encode_kept_noted(dxf: &[u8], version: &str, kept: Option<&str>) -> Result<(Vec<u8>, super::Unwritten), String> {
if u8::try_from(version.len()).is_err() {
return Err(super::unsupported(version));
}
// A kept version too long to send is no version CADCraft knows: it changes nothing.
let kept = kept.filter(|k| u8::try_from(k.len()).is_ok());
let mut header = request(ENCODE, Limits::DEFAULT, version);
push_str(&mut header, kept.unwrap_or(""));
match call(&header, dxf, MAX_DWG_REPLY, "writing this file") {
Some(reply) => reply?.map(|(dwg, notes)| (dwg, unwritten_from(&notes))),
None => encode_here(dxf, version, kept),
}
}
/// The conversion in this process.
fn encode_here(dxf: &[u8], version: &str, kept: Option<&str>) -> Result<(Vec<u8>, super::Unwritten), String> {
match kept {
Some(kept) => super::dxf_to_dwg_kept_noted(dxf, version, kept),
None => super::dxf_to_dwg_noted(dxf, version),
}
}
fn unwritten_from(notes: &[String]) -> super::Unwritten {
notes.iter().filter_map(|n| n.split_once('\t')).filter_map(|(kind, n)| Some((kind.to_string(), n.parse::<usize>().ok()?))).fold(
super::Unwritten::new(),
|mut m, (kind, n)| {
*m.entry(kind).or_insert(0) = n;
m
},
)
}
/// Make the worker abort, as the third-party code can: what the tests prove isolation with.
#[doc(hidden)]
pub fn crash_worker_for_test() -> Result<(), String> {
call(&request(CRASH, Limits::DEFAULT, ""), &[], 1024, "testing").ok_or("no worker")??.map(|_| ())
}
fn request(op: u8, limits: Limits, version: &str) -> Vec<u8> {
let mut r = vec![PROTOCOL, op];
r.extend((limits.max_dwg_bytes as u64).to_le_bytes());
r.extend((limits.max_dxf_bytes as u64).to_le_bytes());
push_str(&mut r, version);
r
}
/// `text` with a one-byte length before it; callers keep it under 256 bytes.
fn push_str(r: &mut Vec<u8>, text: &str) {
r.push(u8::try_from(text.len()).unwrap_or(0));
r.extend(text.as_bytes());
}
type Reply = Result<(Vec<u8>, Vec<String>), String>;
/// Run one request in a worker. `None`: none could be started, so the caller does the work.
/// `Err`: the worker went wrong, and `doing` says at what, for the user.
fn call(header: &[u8], payload: &[u8], reply_limit: u64, doing: &str) -> Option<Result<Reply, String>> {
let mut command = {
let worker = WORKER.lock().ok()?;
let worker = worker.as_ref()?;
let mut c = Command::new(&worker.program);
c.args(&worker.args);
c
};
command.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null());
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
command.creation_flags(CREATE_NO_WINDOW);
}
let mut child = match command.spawn() {
Ok(c) => c,
Err(e) => {
log::warn!("DWG worker: can't start it: {e}");
return None;
}
};
let (Some(mut to_child), Some(from_child)) = (child.stdin.take(), child.stdout.take()) else {
let _ = child.kill();
let _ = child.wait();
return None;
};
let received = std::thread::scope(|scope| {
// Written beside the read: a worker that replies before it has read everything, or dies,
// must block neither side. A failed write shows up as the reply going wrong.
scope.spawn(move || {
let _ = to_child.write_all(header).and_then(|()| to_child.write_all(payload));
});
let (tx, rx) = channel();
scope.spawn(move || {
let mut reply = Vec::new();
let read = from_child.take(reply_limit).read_to_end(&mut reply);
let _ = tx.send(read.map(|_| reply));
});
let received = rx.recv_timeout(TIMEOUT);
if matches!(received, Err(RecvTimeoutError::Timeout)) {
let _ = child.kill();
}
received
});
let status = child.wait();
let stopped = || format!("the DWG worker stopped while {doing}; nothing else is affected");
Some(match (received, status) {
(Err(RecvTimeoutError::Timeout), _) => Err(format!("{doing} took too long, so the DWG worker was stopped; nothing else is affected")),
(Ok(Ok(reply)), Ok(status)) if status.success() => parse_reply(reply).ok_or_else(stopped),
_ => Err(stopped()),
})
}
/// Take `n` bytes off the front of `b`.
fn take<'a>(b: &mut &'a [u8], n: usize) -> Option<&'a [u8]> {
let (head, tail) = b.split_at_checked(n)?;
*b = tail;
Some(head)
}
fn take_u32(b: &mut &[u8]) -> Option<usize> {
let bytes: [u8; 4] = take(b, 4)?.try_into().ok()?;
usize::try_from(u32::from_le_bytes(bytes)).ok()
}
fn take_u64(b: &mut &[u8]) -> Option<u64> {
Some(u64::from_le_bytes(take(b, 8)?.try_into().ok()?))
}
/// A reply: 0, the note count, each note with its length, then the bytes with their length; or 1
/// and a message. `None` when it isn't one, whole. Takes the reply, because the bytes can be most
/// of the memory the app may use: they are kept, not copied.
fn parse_reply(mut reply: Vec<u8>) -> Option<Reply> {
let total = reply.len();
let mut b = &reply[..];
match *take(&mut b, 1)?.first()? {
0 => {
let count = take_u32(&mut b)?;
let mut notes = Vec::new();
for _ in 0..count {
let n = take_u32(&mut b)?;
notes.push(String::from_utf8_lossy(take(&mut b, n)?).into_owned());
}
let n = usize::try_from(take_u64(&mut b)?).ok()?;
if b.len() != n {
return None;
}
reply.drain(..total - n);
Some(Ok((reply, notes)))
}
1 => Some(Err(String::from_utf8_lossy(b).into_owned())),
_ => None,
}
}
fn write_reply(out: &mut impl Write, reply: Reply) -> std::io::Result<()> {
match reply {
Ok((bytes, notes)) => {
out.write_all(&[0])?;
out.write_all(&u32::try_from(notes.len()).unwrap_or(0).to_le_bytes())?;
for note in &notes {
out.write_all(&u32::try_from(note.len()).unwrap_or(0).to_le_bytes())?;
if u32::try_from(note.len()).is_ok() {
out.write_all(note.as_bytes())?;
}
}
out.write_all(&(bytes.len() as u64).to_le_bytes())?;
out.write_all(&bytes)?;
}
Err(e) => {
out.write_all(&[1])?;
out.write_all(e.as_bytes())?;
}
}
out.flush()
}
/// What a request asks for, or why it can't be served.
fn handle(mut b: &[u8]) -> Reply {
let bad = || "the DWG worker got a request it can't read (a different CADCraft version?)".to_string();
if take(&mut b, 1).and_then(<[u8]>::first) != Some(&PROTOCOL) {
return Err(bad());
}
let op = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
let max_dwg_bytes = take_u64(&mut b).and_then(|n| usize::try_from(n).ok()).ok_or_else(bad)?;
let max_dxf_bytes = take_u64(&mut b).and_then(|n| usize::try_from(n).ok()).ok_or_else(bad)?;
let version_len = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
let version = take(&mut b, usize::from(version_len)).and_then(|v| std::str::from_utf8(v).ok()).ok_or_else(bad)?;
match op {
DECODE => super::dwg_to_dxf_noted(b, Limits { max_dwg_bytes, max_dxf_bytes }),
ENCODE => {
// The version the DXF's carried-over groups were read from; empty for none.
let kept_len = take(&mut b, 1).and_then(<[u8]>::first).copied().ok_or_else(bad)?;
let kept = take(&mut b, usize::from(kept_len)).and_then(|v| std::str::from_utf8(v).ok()).ok_or_else(bad)?;
encode_here(b, version, (!kept.is_empty()).then_some(kept))
.map(|(dwg, left_out)| (dwg, left_out.iter().map(|(kind, n)| format!("{kind}\t{n}")).collect()))
}
CRASH => std::process::abort(),
_ => Err(bad()),
}
}
/// Serve the one request on `input`. The exit code is 0 unless the reply couldn't be sent.
fn serve(input: impl Read, mut output: impl Write) -> i32 {
let mut request = Vec::new();
let reply = match input.take(MAX_REQUEST).read_to_end(&mut request) {
Ok(_) => handle(&request),
Err(e) => Err(format!("the DWG worker could not read its request: {e}")),
};
i32::from(write_reply(&mut output, reply).is_err())
}
#[cfg(test)]
mod tests {
use super::*;
fn wire(reply: Reply) -> Vec<u8> {
let mut out = Vec::new();
write_reply(&mut out, reply).unwrap();
out
}
#[test]
fn what_the_writer_left_out_survives_the_reply() {
let notes = vec!["ACME_WIDGET\t2".to_string(), "not a count".to_string(), "X\tmany".to_string()];
assert_eq!(unwritten_from(&notes), [("ACME_WIDGET".to_string(), 2)].into_iter().collect());
}
#[test]
fn replies_round_trip() {
let ok: Reply = Ok((b"bytes".to_vec(), vec!["one".into(), "two é".into()]));
assert_eq!(parse_reply(wire(ok.clone())), Some(ok));
let failed: Reply = Err("DWG: no".into());
assert_eq!(parse_reply(wire(failed.clone())), Some(failed));
}
#[test]
fn a_reply_cut_short_or_made_up_is_refused() {
let whole = wire(Ok((b"bytes".to_vec(), vec!["note".into()])));
for n in 0..whole.len() {
assert_eq!(parse_reply(whole[..n].to_vec()), None, "cut at {n}");
}
assert_eq!(parse_reply(vec![7, 0, 0]), None);
// A note count far beyond what follows ends at the first missing note.
assert_eq!(parse_reply(vec![0, 0xff, 0xff, 0xff, 0xff]), None);
assert_eq!(parse_reply(vec![0, 1, 0, 0, 0, 0xff, 0xff, 0xff, 0xff]), None);
}
#[test]
fn a_request_it_cannot_read_is_an_error_not_a_crash() {
for request in [
&[][..],
&[PROTOCOL + 1, DECODE],
&[PROTOCOL],
&[PROTOCOL, DECODE, 1, 2, 3],
&[PROTOCOL, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
] {
assert!(handle(request).is_err(), "{request:?}");
}
}
/// An encode request carries the kept version after the target one; a request without it is
/// one it can't read, and one with it reaches the converter.
#[test]
fn an_encode_request_carries_the_kept_version() {
let bad = "the DWG worker got a request it can't read (a different CADCraft version?)";
let short = self::request(ENCODE, Limits::DEFAULT, "AC1032");
assert_eq!(handle(&short).unwrap_err(), bad);
for kept in ["", "AC1032"] {
let mut request = self::request(ENCODE, Limits::DEFAULT, "AC1032");
push_str(&mut request, kept);
request.extend(b"not a drawing");
let err = handle(&request).unwrap_err();
assert_ne!(err, bad, "kept {kept:?}");
}
}
#[test]
fn serving_reports_a_decode_failure_as_a_reply() {
let mut request = self::request(DECODE, Limits::DEFAULT, "");
request.extend(b"AC1032 not really a drawing");
let mut out = Vec::new();
assert_eq!(serve(&request[..], &mut out), 0);
assert!(matches!(parse_reply(out.clone()), Some(Err(_))), "{out:?}");
}
}
-14
View File
@@ -1,14 +0,0 @@
[package]
name = "cadcraft-dxf"
description = "Standalone DXF tag reader/writer (ASCII and binary, pre-2007 code pages), from the published DXF reference"
version.workspace = true
edition.workspace = true
license.workspace = true
[lints]
workspace = true
[dependencies]
thiserror = { workspace = true }
log = { workspace = true }
encoding_rs = { workspace = true }
-398
View File
@@ -1,398 +0,0 @@
//! Text decoding for DXF files.
//!
//! R2007 (AC1021) and later DXF files are UTF-8. Older ones store text in the code page named by
//! the `$DWGCODEPAGE` header variable (`ANSI_1252`, `ANSI_932`, `DOS850`, …); characters outside
//! it are written as `\U+XXXX` (any character) or `\M+nXXXX` (a double-byte character of an East
//! Asian code page) escapes, which [`crate::parse`] decodes after the bytes.
//!
//! The Windows, ISO and East Asian code pages are decoded with `encoding_rs`; DOS 437, 850 and
//! 852 with the tables below (the upper halves of the IBM PC code pages; the lower halves are
//! ASCII). Decoding never fails: a byte sequence that is invalid in the code page (a truncated
//! double-byte character, an unassigned byte) becomes U+FFFD and the bytes after it decode
//! normally, so line ends and the group structure survive.
use std::borrow::Cow;
use encoding_rs::Encoding;
/// How the bytes of a code page become text.
#[derive(Clone, Copy, Debug)]
pub(crate) enum Decoder {
Utf8,
Encoding(&'static Encoding),
/// Single-byte DOS code page: ASCII, then these 128 characters for bytes 0x80–0xFF.
Table(&'static [char; 128]),
}
/// The decoder for a `$DWGCODEPAGE` value (case-insensitive), or `None` when CADCraft doesn't
/// know the code page.
pub(crate) fn decoder(code_page: &str) -> Option<Decoder> {
use encoding_rs as e;
let name = code_page.trim().to_ascii_uppercase().replace(['-', ' '], "_");
let enc = match name.as_str() {
"UTF8" | "UTF_8" | "UNICODE" => return Some(Decoder::Utf8),
"ASCII" | "ANSI_1252" | "ISO8859_1" | "ISO_8859_1" => e::WINDOWS_1252,
"ANSI_874" => e::WINDOWS_874,
"ANSI_932" | "DOS932" | "SHIFT_JIS" => e::SHIFT_JIS,
"ANSI_936" | "GB2312" | "GBK" => e::GBK,
"ANSI_949" | "KSC5601" | "KOREAN" => e::EUC_KR,
"ANSI_950" | "BIG5" => e::BIG5,
"ANSI_1250" => e::WINDOWS_1250,
"ANSI_1251" => e::WINDOWS_1251,
"ANSI_1253" => e::WINDOWS_1253,
"ANSI_1254" | "ISO8859_9" | "ISO_8859_9" => e::WINDOWS_1254,
"ANSI_1255" => e::WINDOWS_1255,
"ANSI_1256" => e::WINDOWS_1256,
"ANSI_1257" => e::WINDOWS_1257,
"ANSI_1258" => e::WINDOWS_1258,
"ISO8859_2" | "ISO_8859_2" => e::ISO_8859_2,
"ISO8859_3" | "ISO_8859_3" => e::ISO_8859_3,
"ISO8859_4" | "ISO_8859_4" => e::ISO_8859_4,
"ISO8859_5" | "ISO_8859_5" => e::ISO_8859_5,
"ISO8859_6" | "ISO_8859_6" => e::ISO_8859_6,
"ISO8859_7" | "ISO_8859_7" => e::ISO_8859_7,
"ISO8859_8" | "ISO_8859_8" => e::ISO_8859_8,
"DOS866" => e::IBM866,
"MACINTOSH" | "MAC_ROMAN" => e::MACINTOSH,
"DOS437" => return Some(Decoder::Table(&DOS437)),
"DOS850" => return Some(Decoder::Table(&DOS850)),
"DOS852" => return Some(Decoder::Table(&DOS852)),
_ => return None,
};
Some(Decoder::Encoding(enc))
}
/// Decode `bytes` from the code page `code_page` names (a `$DWGCODEPAGE` value such as
/// `ANSI_1251`), or `None` when CADCraft doesn't know that code page. Invalid sequences become
/// U+FFFD; escapes (`\U+XXXX`, `\M+nXXXX`) are left as they are.
pub fn decode_code_page(bytes: &[u8], code_page: &str) -> Option<String> {
decoder(code_page).map(|d| decode(bytes, d).into_owned())
}
/// The code page a pre-2007 file's text is written in, or `None` for pure ASCII with escapes:
/// when CADCraft doesn't know `code_page`, and for `ASCII` (the reader takes such files as
/// Windows-1252, but a writer must keep them ASCII) and `UTF8`/`UNICODE`, which no pre-2007
/// reader expects.
pub(crate) fn encoder(code_page: &str) -> Option<Decoder> {
if code_page.trim().eq_ignore_ascii_case("ASCII") {
return None;
}
decoder(code_page).filter(|d| !matches!(d, Decoder::Utf8))
}
/// Append the bytes of the non-ASCII character `c` in the code page `d`, and return true, when
/// the code page has it; otherwise append nothing and return false (the caller escapes it).
pub(crate) fn encode_char(c: char, d: Decoder, out: &mut Vec<u8>) -> bool {
let mut buf = [0; 4];
match d {
// Not a pre-2007 code page ([`encoder`] never gives it): escaped.
Decoder::Utf8 => return false,
Decoder::Encoding(e) => {
let (bytes, _, unmappable) = e.encode(c.encode_utf8(&mut buf));
// A code page byte that is ASCII would read back as another character, and a NUL,
// CR or LF would break the group, so only all-high-bit sequences or proper double-byte
// characters are kept (their trail byte may be ASCII, as in Shift-JIS).
if unmappable || bytes.is_empty() || !bytes.first().is_some_and(|b| *b >= 0x80) || bytes.iter().any(|b| matches!(b, 0 | b'\r' | b'\n')) {
return false;
}
out.extend_from_slice(&bytes);
}
Decoder::Table(t) => {
let Some(i) = t.iter().position(|&x| x == c).and_then(|i| u8::try_from(i).ok()) else { return false };
out.push(0x80 | i);
}
}
true
}
/// Decode bytes with a decoder. UTF-8 that isn't valid falls back to Windows-1252.
pub(crate) fn decode(bytes: &[u8], d: Decoder) -> Cow<'_, str> {
match d {
Decoder::Utf8 => match std::str::from_utf8(bytes) {
Ok(s) => Cow::Borrowed(s),
Err(_) => encoding_rs::WINDOWS_1252.decode_without_bom_handling(bytes).0,
},
Decoder::Encoding(e) => e.decode_without_bom_handling(bytes).0,
Decoder::Table(t) => match std::str::from_utf8(bytes) {
Ok(s) if s.is_ascii() => Cow::Borrowed(s),
_ => Cow::Owned(
bytes
.iter()
.map(|&b| if b.is_ascii() { char::from(b) } else { t.get(usize::from(b & 0x7F)).copied().unwrap_or('\u{FFFD}') })
.collect(),
),
},
}
}
/// The `$DWGCODEPAGE` value of an ASCII DXF file: the line two lines after a `$DWGCODEPAGE`
/// line (the group code `3` between them), looked for in the HEADER section only (the scan stops
/// at the first `ENDSEC`). Works on the raw bytes, before they are decoded.
fn ascii_code_page(bytes: &[u8]) -> Option<&[u8]> {
let mut lines = bytes.split(|&b| b == b'\n' || b == b'\r').map(<[u8]>::trim_ascii).filter(|l| !l.is_empty());
while let Some(line) = lines.next() {
if line == b"ENDSEC" {
return None;
}
if line.eq_ignore_ascii_case(b"$DWGCODEPAGE") {
return match (lines.next(), lines.next()) {
(Some(b"3"), Some(value)) => Some(value),
_ => None,
};
}
}
None
}
impl Decoder {
/// True for the multi-byte East Asian code pages (Shift-JIS, GBK, EUC-KR/Wansung, Big5).
/// Their short double-byte strings are often also valid UTF-8, so UTF-8 is only trusted for
/// a whole file there (see [`decode_ascii_file`] and [`BinaryText`]).
fn is_east_asian(self) -> bool {
use encoding_rs as e;
matches!(self, Decoder::Encoding(x) if x == e::SHIFT_JIS || x == e::GBK || x == e::EUC_KR || x == e::BIG5)
}
}
/// Decode one line of an ASCII DXF file: valid UTF-8 is read as UTF-8 (R2007+ files, pure-ASCII
/// text, and older files from writers that ignored the code page); anything else comes from the
/// code page `d`, so one stray byte spoils one line, not the whole file. Binary strings don't use
/// this rule: a pre-R2007 binary file has no way to escape to UTF-8, so its strings are read
/// from the code page (see [`BinaryText::string`]).
pub(crate) fn decode_text(bytes: &[u8], d: Decoder) -> Cow<'_, str> {
match std::str::from_utf8(bytes) {
Ok(s) => Cow::Borrowed(s),
Err(_) => decode(bytes, d),
}
}
/// Decode a whole ASCII DXF file. A file that is valid UTF-8 throughout is UTF-8. Otherwise, for
/// a single-byte code page, each line is decoded on its own (see [`decode_text`]): lines that
/// aren't valid UTF-8 come from the file's `$DWGCODEPAGE`, or from Windows-1252 (the usual
/// `ANSI_1252`) when the header has none or names a code page CADCraft doesn't know, which is
/// logged as a warning. For a multi-byte East Asian code page the whole file is decoded from
/// that code page, because a short double-byte string (two half-width katakana, many kanji
/// pairs) can be valid UTF-8 by accident and must not be misread line by line.
pub(crate) fn decode_ascii_file(bytes: &[u8]) -> Cow<'_, str> {
if let Ok(s) = std::str::from_utf8(bytes) {
return Cow::Borrowed(s);
}
let d = match ascii_code_page(bytes) {
Some(name) => {
let name = String::from_utf8_lossy(name);
decoder(&name).unwrap_or_else(|| {
log::warn!("DXF: unknown code page `{name}`; reading the text as ANSI_1252");
Decoder::Utf8
})
}
None => Decoder::Utf8,
};
if d.is_east_asian() {
return decode(bytes, d);
}
// Split after each line terminator (CR, LF or CRLF are all ASCII, so they never occur inside
// a multi-byte character of the supported code pages) and decode each line on its own.
let mut out = String::with_capacity(bytes.len());
for line in bytes.split_inclusive(|&b| b == b'\n' || b == b'\r') {
out.push_str(&decode_text(line, d));
}
Cow::Owned(out)
}
/// The text state of a binary DXF file, learnt from the header as the tags go by: `$ACADVER`
/// (R2007+ strings are UTF-8) and `$DWGCODEPAGE` (the code page of older files). Both come
/// first in the HEADER section and are ASCII, so every later string is decoded right.
#[derive(Default)]
pub(crate) struct BinaryText {
/// The header variable whose value comes next (after a group 9).
var: Option<HeaderVar>,
utf8: bool,
code_page: Option<Decoder>,
/// Decode every string of an East Asian code page file from the code page, never as UTF-8
/// (the second pass of [`BinaryText::needs_code_page_pass`]).
code_page_only: bool,
/// Non-ASCII strings seen under an East Asian code page: valid UTF-8 / not valid UTF-8.
ea_utf8: bool,
ea_other: bool,
}
#[derive(Clone, Copy, PartialEq)]
enum HeaderVar {
AcadVer,
CodePage,
}
impl BinaryText {
/// The state for the second pass over a file whose strings are a mix of valid UTF-8 and
/// not: every string of an East Asian code page is decoded from that code page.
pub(crate) fn code_page_pass() -> Self {
Self { code_page_only: true, ..Self::default() }
}
/// True when the file declared a multi-byte East Asian code page and its non-ASCII strings are
/// not all valid UTF-8 although some are: those can be short double-byte strings that look
/// like UTF-8 by accident, so the file must be parsed again with [`Self::code_page_pass`]. (A
/// file whose strings are all valid UTF-8 is UTF-8; one with none is plainly the code page.)
pub(crate) fn needs_code_page_pass(&self) -> bool {
!self.code_page_only && self.ea_utf8 && self.ea_other
}
/// Decode one string value of group `code` and update the state from it. Strings of R2007+
/// files, and of files without a code page, are UTF-8 when valid (else Windows-1252); a
/// pre-R2007 file's strings are in its code page, which a binary DXF cannot escape to, so
/// they are read from the code page even when their bytes are valid UTF-8 by accident —
/// except under an East Asian code page, where a file of all-valid-UTF-8 strings is taken
/// as UTF-8 (see [`Self::needs_code_page_pass`]).
pub(crate) fn string(&mut self, code: i32, raw: &[u8]) -> String {
let d = if self.utf8 { Decoder::Utf8 } else { self.code_page.unwrap_or(Decoder::Utf8) };
let s = if d.is_east_asian() && !self.code_page_only {
if !raw.is_ascii() {
if std::str::from_utf8(raw).is_ok() {
self.ea_utf8 = true;
} else {
self.ea_other = true;
}
}
decode_text(raw, d).into_owned()
} else {
decode(raw, d).into_owned()
};
match (code, self.var.take()) {
(9, _) => {
self.var = match s.trim() {
"$ACADVER" => Some(HeaderVar::AcadVer),
"$DWGCODEPAGE" => Some(HeaderVar::CodePage),
_ => None,
}
}
(1, Some(HeaderVar::AcadVer)) => self.utf8 = is_utf8_version(&s),
(3, Some(HeaderVar::CodePage)) => {
self.code_page = decoder(&s);
if self.code_page.is_none() {
log::warn!("DXF: unknown code page `{}`; reading the text as ANSI_1252", s.trim());
}
}
_ => {}
}
s
}
}
/// True for an `$ACADVER` of R2007 (AC1021) or later, whose text is UTF-8.
fn is_utf8_version(acadver: &str) -> bool {
acadver.trim().strip_prefix("AC").and_then(|n| n.parse::<u32>().ok()).is_some_and(|n| n >= 1021)
}
/// The double-byte code page of a `\M+n` escape: 1 Japanese (Shift-JIS), 2 Traditional Chinese
/// (Big5), 3 Korean (Wansung), 5 Simplified Chinese (GB 2312). 4 (Korean Johab) is not
/// supported, so its escapes stay literal.
pub(crate) fn mif_encoding(n: char) -> Option<&'static Encoding> {
match n {
'1' => Some(encoding_rs::SHIFT_JIS),
'2' => Some(encoding_rs::BIG5),
'3' => Some(encoding_rs::EUC_KR),
'5' => Some(encoding_rs::GBK),
_ => None,
}
}
// Generated from the IBM PC code page definitions (bytes 0x80–0xFF in order).
const DOS437: [char; 128] = [
'\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{00E0}', '\u{00E5}', '\u{00E7}', '\u{00EA}', '\u{00EB}', '\u{00E8}', '\u{00EF}',
'\u{00EE}', '\u{00EC}', '\u{00C4}', '\u{00C5}', '\u{00C9}', '\u{00E6}', '\u{00C6}', '\u{00F4}', '\u{00F6}', '\u{00F2}', '\u{00FB}', '\u{00F9}',
'\u{00FF}', '\u{00D6}', '\u{00DC}', '\u{00A2}', '\u{00A3}', '\u{00A5}', '\u{20A7}', '\u{0192}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
'\u{00F1}', '\u{00D1}', '\u{00AA}', '\u{00BA}', '\u{00BF}', '\u{2310}', '\u{00AC}', '\u{00BD}', '\u{00BC}', '\u{00A1}', '\u{00AB}', '\u{00BB}',
'\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{2561}', '\u{2562}', '\u{2556}', '\u{2555}', '\u{2563}', '\u{2551}', '\u{2557}',
'\u{255D}', '\u{255C}', '\u{255B}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{255E}', '\u{255F}',
'\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{2567}', '\u{2568}', '\u{2564}', '\u{2565}', '\u{2559}',
'\u{2558}', '\u{2552}', '\u{2553}', '\u{256B}', '\u{256A}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{258C}', '\u{2590}', '\u{2580}',
'\u{03B1}', '\u{00DF}', '\u{0393}', '\u{03C0}', '\u{03A3}', '\u{03C3}', '\u{00B5}', '\u{03C4}', '\u{03A6}', '\u{0398}', '\u{03A9}', '\u{03B4}',
'\u{221E}', '\u{03C6}', '\u{03B5}', '\u{2229}', '\u{2261}', '\u{00B1}', '\u{2265}', '\u{2264}', '\u{2320}', '\u{2321}', '\u{00F7}', '\u{2248}',
'\u{00B0}', '\u{2219}', '\u{00B7}', '\u{221A}', '\u{207F}', '\u{00B2}', '\u{25A0}', '\u{00A0}',
];
const DOS850: [char; 128] = [
'\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{00E0}', '\u{00E5}', '\u{00E7}', '\u{00EA}', '\u{00EB}', '\u{00E8}', '\u{00EF}',
'\u{00EE}', '\u{00EC}', '\u{00C4}', '\u{00C5}', '\u{00C9}', '\u{00E6}', '\u{00C6}', '\u{00F4}', '\u{00F6}', '\u{00F2}', '\u{00FB}', '\u{00F9}',
'\u{00FF}', '\u{00D6}', '\u{00DC}', '\u{00F8}', '\u{00A3}', '\u{00D8}', '\u{00D7}', '\u{0192}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
'\u{00F1}', '\u{00D1}', '\u{00AA}', '\u{00BA}', '\u{00BF}', '\u{00AE}', '\u{00AC}', '\u{00BD}', '\u{00BC}', '\u{00A1}', '\u{00AB}', '\u{00BB}',
'\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{00C1}', '\u{00C2}', '\u{00C0}', '\u{00A9}', '\u{2563}', '\u{2551}', '\u{2557}',
'\u{255D}', '\u{00A2}', '\u{00A5}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{00E3}', '\u{00C3}',
'\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{00A4}', '\u{00F0}', '\u{00D0}', '\u{00CA}', '\u{00CB}',
'\u{00C8}', '\u{0131}', '\u{00CD}', '\u{00CE}', '\u{00CF}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{00A6}', '\u{00CC}', '\u{2580}',
'\u{00D3}', '\u{00DF}', '\u{00D4}', '\u{00D2}', '\u{00F5}', '\u{00D5}', '\u{00B5}', '\u{00FE}', '\u{00DE}', '\u{00DA}', '\u{00DB}', '\u{00D9}',
'\u{00FD}', '\u{00DD}', '\u{00AF}', '\u{00B4}', '\u{00AD}', '\u{00B1}', '\u{2017}', '\u{00BE}', '\u{00B6}', '\u{00A7}', '\u{00F7}', '\u{00B8}',
'\u{00B0}', '\u{00A8}', '\u{00B7}', '\u{00B9}', '\u{00B3}', '\u{00B2}', '\u{25A0}', '\u{00A0}',
];
const DOS852: [char; 128] = [
'\u{00C7}', '\u{00FC}', '\u{00E9}', '\u{00E2}', '\u{00E4}', '\u{016F}', '\u{0107}', '\u{00E7}', '\u{0142}', '\u{00EB}', '\u{0150}', '\u{0151}',
'\u{00EE}', '\u{0179}', '\u{00C4}', '\u{0106}', '\u{00C9}', '\u{0139}', '\u{013A}', '\u{00F4}', '\u{00F6}', '\u{013D}', '\u{013E}', '\u{015A}',
'\u{015B}', '\u{00D6}', '\u{00DC}', '\u{0164}', '\u{0165}', '\u{0141}', '\u{00D7}', '\u{010D}', '\u{00E1}', '\u{00ED}', '\u{00F3}', '\u{00FA}',
'\u{0104}', '\u{0105}', '\u{017D}', '\u{017E}', '\u{0118}', '\u{0119}', '\u{00AC}', '\u{017A}', '\u{010C}', '\u{015F}', '\u{00AB}', '\u{00BB}',
'\u{2591}', '\u{2592}', '\u{2593}', '\u{2502}', '\u{2524}', '\u{00C1}', '\u{00C2}', '\u{011A}', '\u{015E}', '\u{2563}', '\u{2551}', '\u{2557}',
'\u{255D}', '\u{017B}', '\u{017C}', '\u{2510}', '\u{2514}', '\u{2534}', '\u{252C}', '\u{251C}', '\u{2500}', '\u{253C}', '\u{0102}', '\u{0103}',
'\u{255A}', '\u{2554}', '\u{2569}', '\u{2566}', '\u{2560}', '\u{2550}', '\u{256C}', '\u{00A4}', '\u{0111}', '\u{0110}', '\u{010E}', '\u{00CB}',
'\u{010F}', '\u{0147}', '\u{00CD}', '\u{00CE}', '\u{011B}', '\u{2518}', '\u{250C}', '\u{2588}', '\u{2584}', '\u{0162}', '\u{016E}', '\u{2580}',
'\u{00D3}', '\u{00DF}', '\u{00D4}', '\u{0143}', '\u{0144}', '\u{0148}', '\u{0160}', '\u{0161}', '\u{0154}', '\u{00DA}', '\u{0155}', '\u{0170}',
'\u{00FD}', '\u{00DD}', '\u{0163}', '\u{00B4}', '\u{00AD}', '\u{02DD}', '\u{02DB}', '\u{02C7}', '\u{02D8}', '\u{00A7}', '\u{00F7}', '\u{00B8}',
'\u{00B0}', '\u{00A8}', '\u{02D9}', '\u{0171}', '\u{0158}', '\u{0159}', '\u{25A0}', '\u{00A0}',
];
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn code_page_names() {
let d = |bytes: &[u8], cp: &str| decode_code_page(bytes, cp);
assert_eq!(d(b"\xCF\xF0\xE8\xE2\xE5\xF2", "ANSI_1251").as_deref(), Some("Привет"));
assert_eq!(d(b"\xCF\xF0\xE8\xE2\xE5\xF2", " ansi_1251 ").as_deref(), Some("Привет"));
assert_eq!(d(b"\x90\x7D\x96\xCA", "ANSI_932").as_deref(), Some("図面"));
assert_eq!(d(b"\xCD\xBC\xB2\xE3", "GB2312").as_deref(), Some("图层"));
assert_eq!(d(b"\xB9\xCF\xBC\x68", "BIG5").as_deref(), Some("圖層"));
assert_eq!(d(b"\xB5\xB5\xB8\xE9", "ANSI_949").as_deref(), Some("도면"));
assert_eq!(d(b"\xD3\xF7\xDD\xE4\xE9\xEF", "ANSI_1253").as_deref(), Some("Σχέδιο"));
assert_eq!(d(b"\xC0\xD2\xBE", "ANSI_874").as_deref(), Some("ภาพ"));
assert_eq!(d(b"\x80", "ANSI_1252").as_deref(), Some("€"));
// DOS 437 and 850 agree on letters but differ on 0x9B (¢ / ø).
assert_eq!(d(b"Gr\x94\xE1e \x9B", "DOS437").as_deref(), Some("Größe ¢"));
assert_eq!(d(b"Gr\x94\xE1e \x9B", "dos850").as_deref(), Some("Größe ø"));
assert_eq!(d(b"\xBD\xA2\x88w", "DOS852").as_deref(), Some("Żółw"));
assert_eq!(d(b"\x91\xAB\xAE\xA9", "DOS866").as_deref(), Some("Слой"));
assert_eq!(d("é".as_bytes(), "UTF8").as_deref(), Some("é"));
assert_eq!(d(b"x", "ANSI_1361"), None);
assert_eq!(d(b"x", "EBCDIC"), None);
assert_eq!(d(b"x", ""), None);
}
#[test]
fn invalid_sequences_become_replacement_characters() {
// A Shift-JIS lead byte cut off by the line end keeps the line end.
assert_eq!(decode_code_page(b"\x90\n1\n", "ANSI_932").as_deref(), Some("\u{FFFD}\n1\n"));
assert_eq!(decode_code_page(b"\x90", "ANSI_932").as_deref(), Some("\u{FFFD}"));
assert_eq!(decode_code_page(b"\xFF\xFF", "ANSI_936").as_deref(), Some("\u{FFFD}\u{FFFD}"));
}
#[test]
fn header_scan() {
let head = b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1251\r\n0\nENDSEC\n";
assert_eq!(ascii_code_page(head), Some(&b"ANSI_1251"[..]));
// Only the HEADER section counts.
assert_eq!(ascii_code_page(b"0\nSECTION\n2\nHEADER\n0\nENDSEC\n9\n$DWGCODEPAGE\n3\nANSI_1251\n"), None);
// Wrong group code, or the file ends early.
assert_eq!(ascii_code_page(b"9\n$DWGCODEPAGE\n1\nANSI_1251\n"), None);
assert_eq!(ascii_code_page(b"9\n$DWGCODEPAGE\n3"), None);
assert!(is_utf8_version("AC1021") && is_utf8_version(" AC1032 "));
assert!(!is_utf8_version("AC1018") && !is_utf8_version("AC1009") && !is_utf8_version("garbage"));
}
#[test]
fn mif_escapes() {
let one = |s: &str| crate::parse(format!("1\n{s}\n0\nEOF\n").as_bytes()).unwrap()[0].str();
assert_eq!(one("\\M+5BCFE\\M+1907D\\M+2B9CF\\M+3B5B5!"), "件図圖도!");
assert_eq!(one("\\M+5BCFE\\U+0021"), "件!");
// Johab, unknown code pages, bad hex, short escapes and unassigned codes stay literal.
for s in ["\\M+4ABCD", "\\M+9BCFE", "\\M+5GGGG", "\\M+5BC", "\\M+", "\\M+50041", "\\M+5FFFF"] {
assert_eq!(one(s), s);
}
}
}
-925
View File
@@ -1,925 +0,0 @@
//! A standalone DXF tag reader and writer.
//!
//! DXF is a sequence of (group code, value) pairs. This crate parses ASCII and binary DXF into a
//! flat list of [`Tag`]s, splits them into sections and entities, and writes tags back. Mapping
//! tags to a drawing model is left to the caller. Written from Autodesk's published DXF
//! Reference; depends on nothing else in the workspace.
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
use std::fmt::Write as _;
use std::io::Write as _;
mod version;
pub use version::Version;
#[derive(Debug, thiserror::Error)]
pub enum DxfError {
#[error("not a DXF file")]
NotDxf,
#[error("line {line}: bad group code `{text}`")]
BadCode { line: usize, text: String },
#[error("unexpected end of file")]
Eof,
/// More group codes than [`MAX_TAGS`]: `tags` is the count found (or the count read when the
/// limit was reached), `limit` the maximum.
#[error("drawing too large: {tags} DXF group codes, more than the {limit} CADCraft reads (set CADCRAFT_MAX_DXF_TAGS to read more)")]
TooLarge { tags: usize, limit: usize },
/// The memory for `tags` group codes couldn't be had: an error, not the process ending.
#[error("not enough memory to read this drawing's {tags} DXF group codes")]
OutOfMemory { tags: usize },
}
pub type Result<T> = std::result::Result<T, DxfError>;
/// A typed group value.
#[derive(Clone, Debug, PartialEq)]
pub enum Value {
Str(String),
Real(f64),
Int(i64),
Bool(bool),
/// Binary chunk (310–319, 1004) as hex text.
Hex(String),
}
impl Value {
pub fn as_str(&self) -> String {
match self {
Value::Str(s) | Value::Hex(s) => s.clone(),
Value::Real(r) => format_real(*r),
Value::Int(i) => i.to_string(),
Value::Bool(b) => i64::from(*b).to_string(),
}
}
pub fn as_f64(&self) -> f64 {
match self {
Value::Real(r) if r.is_finite() => *r,
Value::Int(i) => *i as f64,
Value::Str(s) => s.trim().parse::<f64>().ok().filter(|v| v.is_finite()).unwrap_or(0.0),
Value::Bool(b) => f64::from(u8::from(*b)),
_ => 0.0,
}
}
pub fn as_i64(&self) -> i64 {
match self {
Value::Int(i) => *i,
Value::Real(r) if r.is_finite() => *r as i64,
Value::Str(s) => {
s.trim().parse::<i64>().unwrap_or_else(|_| s.trim().parse::<f64>().ok().filter(|f| f.is_finite()).map_or(0, |f| f as i64))
}
Value::Bool(b) => i64::from(*b),
_ => 0,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Tag {
pub code: i32,
pub value: Value,
}
impl Tag {
pub fn new(code: i32, value: Value) -> Self {
Tag { code, value }
}
pub fn s(code: i32, v: impl Into<String>) -> Self {
Tag { code, value: Value::Str(v.into()) }
}
pub fn f(code: i32, v: f64) -> Self {
Tag { code, value: Value::Real(if v.is_finite() { v } else { 0.0 }) }
}
pub fn i(code: i32, v: i64) -> Self {
Tag { code, value: Value::Int(v) }
}
pub fn str(&self) -> String {
self.value.as_str()
}
pub fn f64(&self) -> f64 {
self.value.as_f64()
}
pub fn i64(&self) -> i64 {
self.value.as_i64()
}
}
/// The value type for a group code (DXF Reference, "Group Code Value Types").
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Kind {
Str,
Real,
Int16,
Int32,
Int64,
Bool,
Hex,
}
pub fn kind_of(code: i32) -> Kind {
match code {
0..=9 => Kind::Str,
10..=59 => Kind::Real,
60..=79 => Kind::Int16,
90..=99 => Kind::Int32,
100..=109 => Kind::Str,
110..=149 => Kind::Real,
160..=169 => Kind::Int64,
170..=179 => Kind::Int16,
210..=239 => Kind::Real,
270..=289 => Kind::Int16,
290..=299 => Kind::Bool,
300..=309 => Kind::Str,
310..=319 => Kind::Hex,
320..=369 => Kind::Str,
370..=389 => Kind::Int16,
390..=399 => Kind::Str,
400..=409 => Kind::Int16,
410..=419 => Kind::Str,
420..=429 => Kind::Int32,
430..=439 => Kind::Str,
440..=449 => Kind::Int32,
450..=459 => Kind::Int32,
460..=469 => Kind::Real,
470..=479 => Kind::Str,
480..=481 => Kind::Str,
999 => Kind::Str,
1000..=1003 => Kind::Str,
1004 => Kind::Hex,
1005..=1009 => Kind::Str,
1010..=1059 => Kind::Real,
1060..=1070 => Kind::Int16,
1071 => Kind::Int32,
_ => Kind::Str,
}
}
fn typed(code: i32, text: &str) -> Value {
let t = text.trim();
match kind_of(code) {
Kind::Real => t.parse::<f64>().ok().filter(|v| v.is_finite()).map(Value::Real).unwrap_or(Value::Real(0.0)),
Kind::Int16 | Kind::Int32 | Kind::Int64 => {
// A float spelling ("1e3", "12.0") is accepted when finite, clamped to what the
// group's width holds, signed or unsigned (files write 16-bit flags up to 65535, as
// the integer spelling reads them); NaN, inf and text become 0.
let (lo, hi) = match kind_of(code) {
Kind::Int16 => (i64::from(i16::MIN), i64::from(u16::MAX)),
Kind::Int32 => (i64::from(i32::MIN), i64::from(u32::MAX)),
_ => (i64::MIN, i64::MAX),
};
t.parse::<i64>()
.map(Value::Int)
.unwrap_or_else(|_| Value::Int(t.parse::<f64>().ok().filter(|f| f.is_finite()).map_or(0, |f| (f as i64).clamp(lo, hi))))
}
Kind::Bool => Value::Bool(t.parse::<i64>().unwrap_or(0) != 0),
Kind::Hex => Value::Hex(normalize_hex(t)),
Kind::Str => Value::Str(text.trim_end_matches(['\r', '\n']).to_string()),
}
}
const BINARY_SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
const UTF8_BOM: &[u8] = b"\xEF\xBB\xBF";
/// Most group codes read from one file by default. A `Tag` takes 40 bytes plus its text, so this
/// bounds the tag list to about 4 GB plus text. 50 million rejected large DWGs that converted fine
/// (a 172 MB drawing has 56 million, issue #1948). The file-size limits bound memory too: 512 MB
/// for a DXF opened directly, 1 GB for a DWG's DXF rendition. Set `CADCRAFT_MAX_DXF_TAGS` to
/// raise or lower it.
pub const MAX_TAGS: usize = 100_000_000;
/// Environment variable overriding [`MAX_TAGS`] (a positive integer).
pub const MAX_TAGS_ENV: &str = "CADCRAFT_MAX_DXF_TAGS";
/// The group-code limit in effect: [`MAX_TAGS_ENV`] when set to a positive integer, else
/// [`MAX_TAGS`].
pub fn max_tags() -> usize {
max_tags_from(std::env::var(MAX_TAGS_ENV).ok().as_deref())
}
fn max_tags_from(v: Option<&str>) -> usize {
v.and_then(|s| s.trim().replace('_', "").parse::<usize>().ok()).filter(|&n| n > 0).unwrap_or(MAX_TAGS)
}
mod codepage;
pub use codepage::decode_code_page;
/// Parse a DXF file (ASCII or binary).
pub fn parse(bytes: &[u8]) -> Result<Vec<Tag>> {
parse_with_limit(bytes, max_tags())
}
/// [`parse`] with an explicit group-code limit. For ASCII DXF the limit is checked up front from
/// the line count, before the text is decoded or any tag allocated, so an oversized file fails in
/// milliseconds instead of after it has filled memory.
pub fn parse_with_limit(bytes: &[u8], max_tags: usize) -> Result<Vec<Tag>> {
if let Some(body) = bytes.strip_prefix(BINARY_SENTINEL) {
return parse_binary_with_limit(body, max_tags);
}
let bytes = bytes.strip_prefix(UTF8_BOM).unwrap_or(bytes);
// Count nonblank group-code/value pairs (LF, CRLF and a lone CR each end a line), stopping at
// EOF just as the parser does. Blank lines do not count toward the limit.
let mut lines = byte_lines(bytes);
let mut tags = 0;
while let Some(code) = lines.next() {
let code = code.trim_ascii();
if code.is_empty() {
continue;
}
let Some(value) = lines.next() else { break };
tags += 1;
if code == b"0" && value.trim_ascii() == b"EOF" {
break;
}
}
if tags > max_tags {
return Err(DxfError::TooLarge { tags, limit: max_tags });
}
parse_ascii_counted(&codepage::decode_ascii_file(bytes), max_tags, tags)
}
/// The four hex digits of a `\U+XXXX` escape starting at `chars[i]`, if there is one.
fn escape_at(chars: &[char], i: usize) -> Option<u32> {
if chars.get(i) != Some(&'\\') || chars.get(i + 1) != Some(&'U') || chars.get(i + 2) != Some(&'+') {
return None;
}
let hex = chars.get(i + 3..i + 7)?;
if !hex.iter().all(char::is_ascii_hexdigit) {
return None;
}
hex.iter().try_fold(0u32, |acc, c| Some(acc * 16 + c.to_digit(16)?))
}
/// The character of a `\M+nXXXX` escape starting at `chars[i]`, if there is one: `n` names a
/// double-byte code page and `XXXX` is the character's two bytes in hex.
fn mif_escape_at(chars: &[char], i: usize) -> Option<char> {
if chars.get(i) != Some(&'\\') || chars.get(i + 1) != Some(&'M') || chars.get(i + 2) != Some(&'+') {
return None;
}
let enc = codepage::mif_encoding(*chars.get(i + 3)?)?;
let hex = chars.get(i + 4..i + 8)?;
if !hex.iter().all(char::is_ascii_hexdigit) {
return None;
}
let code = hex.iter().try_fold(0u16, |acc, c| Some(acc * 16 + u16::try_from(c.to_digit(16)?).ok()?))?;
let bytes = code.to_be_bytes();
let text = enc.decode_without_bom_handling_and_without_replacement(&bytes)?;
let mut it = text.chars();
it.next().filter(|_| it.next().is_none())
}
/// Unescape the `\U+XXXX` sequences pre-R2007 DXF uses for characters outside the file's code
/// page (four hex digits, one UTF-16 code unit; characters above U+FFFF are a surrogate pair of
/// escapes), and the `\M+nXXXX` sequences for double-byte East Asian characters. Malformed
/// escapes, unpaired surrogates and unknown `\M+` code pages are kept as literal text.
fn unescape_unicode(s: &str) -> String {
if !s.contains("\\U+") && !s.contains("\\M+") {
return s.to_string();
}
let mut out = String::with_capacity(s.len());
let chars: Vec<char> = s.chars().collect();
let mut i = 0;
while let Some(&c) = chars.get(i) {
if let Some(ch) = mif_escape_at(&chars, i) {
out.push(ch);
i += 8;
continue;
}
if let Some(unit) = escape_at(&chars, i) {
if let Some(ch) = char::from_u32(unit) {
out.push(ch);
i += 7;
continue;
}
if (0xD800..0xDC00).contains(&unit)
&& let Some(low) = escape_at(&chars, i + 7).filter(|u| (0xDC00..0xE000).contains(u))
&& let Some(ch) = char::from_u32(0x10000 + ((unit - 0xD800) << 10) + (low - 0xDC00))
{
out.push(ch);
i += 14;
continue;
}
}
out.push(c);
i += 1;
}
out
}
/// The lines of an ASCII DXF text: LF, CRLF and a lone CR (old Mac files) all end a line, like
/// [`str::lines`] otherwise (no empty line after a final terminator).
fn ascii_lines(text: &str) -> impl Iterator<Item = &str> {
let mut rest = text;
std::iter::from_fn(move || {
if rest.is_empty() {
return None;
}
let end = rest.find(['\r', '\n']).unwrap_or(rest.len());
let line = rest.get(..end).unwrap_or_default();
let after = rest.get(end..).unwrap_or_default();
rest = after.strip_prefix("\r\n").or_else(|| after.strip_prefix(['\r', '\n'])).unwrap_or(after);
Some(line)
})
}
/// Byte-level twin of [`ascii_lines`] for the up-front limit check, so the count matches the parser.
fn byte_lines(mut rest: &[u8]) -> impl Iterator<Item = &[u8]> {
std::iter::from_fn(move || {
if rest.is_empty() {
return None;
}
let end = rest.iter().position(|&b| b == b'\r' || b == b'\n').unwrap_or(rest.len());
let line = &rest[..end];
let after = &rest[end..];
rest = match after {
[b'\r', b'\n', tail @ ..] | [b'\r' | b'\n', tail @ ..] => tail,
_ => after,
};
Some(line)
})
}
pub fn parse_ascii(text: &str) -> Result<Vec<Tag>> {
parse_ascii_counted(text, max_tags(), 0)
}
/// [`parse_ascii`] of a file known to hold `expected` group codes. Their list is reserved first,
/// with an allocation that can fail: where the system refuses that much memory, opening the file
/// is an error instead of the end of the app. Growing the list instead could also briefly take
/// half as much again.
#[allow(clippy::while_let_loop)]
fn parse_ascii_counted(text: &str, max_tags: usize, expected: usize) -> Result<Vec<Tag>> {
let mut tags = Vec::new();
tags.try_reserve_exact(expected.min(max_tags)).map_err(|_| DxfError::OutOfMemory { tags: expected })?;
let mut lines = ascii_lines(text.strip_prefix('\u{feff}').unwrap_or(text)).enumerate();
loop {
let Some((ln, code_line)) = lines.next() else { break };
let ct = code_line.trim();
if ct.is_empty() {
continue;
}
let code: i32 = ct.parse().map_err(|_| DxfError::BadCode { line: ln + 1, text: ct.chars().take(40).collect() })?;
let Some((_, val)) = lines.next() else { return Err(DxfError::Eof) };
let v = typed(code, val);
let v = match v {
Value::Str(s) => Value::Str(unescape_unicode(&s)),
o => o,
};
tags.push(Tag { code, value: v });
if tags.len() > max_tags {
return Err(DxfError::TooLarge { tags: tags.len(), limit: max_tags });
}
if code == 0 && tags.last().is_some_and(|t| t.str().trim_end() == "EOF") {
break;
}
}
if tags.is_empty() {
return Err(DxfError::NotDxf);
}
Ok(tags)
}
struct Cur<'a> {
b: &'a [u8],
p: usize,
}
impl<'a> Cur<'a> {
fn take(&mut self, n: usize) -> Result<&[u8]> {
let end = self.p.checked_add(n).ok_or(DxfError::Eof)?;
let s = self.b.get(self.p..end).ok_or(DxfError::Eof)?;
self.p = end;
Ok(s)
}
fn u8(&mut self) -> Result<u8> {
Ok(*self.take(1)?.first().ok_or(DxfError::Eof)?)
}
fn i16(&mut self) -> Result<i16> {
let s = self.take(2)?;
Ok(i16::from_le_bytes([s[0], s[1]]))
}
fn i32(&mut self) -> Result<i32> {
let s = self.take(4)?;
Ok(i32::from_le_bytes([s[0], s[1], s[2], s[3]]))
}
fn i64(&mut self) -> Result<i64> {
let s = self.take(8)?;
let mut a = [0u8; 8];
a.copy_from_slice(s);
Ok(i64::from_le_bytes(a))
}
fn f64(&mut self) -> Result<f64> {
let s = self.take(8)?;
let mut a = [0u8; 8];
a.copy_from_slice(s);
Ok(f64::from_le_bytes(a))
}
/// The bytes of a zero-terminated string (without the zero), decoded by the caller.
fn cstr(&mut self) -> Result<&'a [u8]> {
let start = self.p;
while self.p < self.b.len() && self.b.get(self.p) != Some(&0) {
self.p += 1;
}
let s = self.b.get(start..self.p).unwrap_or(&[]);
if self.p >= self.b.len() {
return Err(DxfError::Eof);
}
self.p += 1;
Ok(s)
}
}
/// Binary DXF (R13+: 2-byte group codes).
pub fn parse_binary(b: &[u8]) -> Result<Vec<Tag>> {
parse_binary_with_limit(b, max_tags())
}
fn parse_binary_with_limit(b: &[u8], max_tags: usize) -> Result<Vec<Tag>> {
let mut text = codepage::BinaryText::default();
let tags = parse_binary_pass(b, max_tags, &mut text)?;
if !text.needs_code_page_pass() {
return Ok(tags);
}
// The first pass's tags go before the second pass runs: both held at once would double
// the peak near the tag limit.
drop(tags);
parse_binary_pass(b, max_tags, &mut codepage::BinaryText::code_page_pass())
}
fn parse_binary_pass(b: &[u8], max_tags: usize, text: &mut codepage::BinaryText) -> Result<Vec<Tag>> {
let mut c = Cur { b, p: 0 };
let mut tags = Vec::new();
while c.p < b.len() {
let mut code = i32::from(c.i16()?);
if code == 255 {
code = i32::from(c.i16()?);
}
let v = match kind_of(code) {
Kind::Str => Value::Str(unescape_unicode(&text.string(code, c.cstr()?))),
Kind::Real => Value::Real(Some(c.f64()?).filter(|v| v.is_finite()).unwrap_or(0.0)),
Kind::Int16 => Value::Int(i64::from(c.i16()?)),
Kind::Int32 => Value::Int(i64::from(c.i32()?)),
Kind::Int64 => Value::Int(c.i64()?),
Kind::Bool => Value::Bool(c.u8()? != 0),
Kind::Hex => {
let n = usize::from(c.u8()?);
let bytes = c.take(n)?;
let mut s = String::with_capacity(n * 2);
for x in bytes {
let _ = write!(s, "{x:02X}");
}
Value::Hex(s)
}
};
let eof = code == 0 && matches!(&v, Value::Str(s) if s.trim_end() == "EOF");
tags.push(Tag { code, value: v });
if tags.len() > max_tags {
return Err(DxfError::TooLarge { tags: tags.len(), limit: max_tags });
}
if eof {
break;
}
}
if tags.is_empty() {
return Err(DxfError::NotDxf);
}
Ok(tags)
}
/// Format a real the way DXF writers usually do (shortest round-trip, with a decimal point).
pub fn format_real(v: f64) -> String {
if !v.is_finite() {
return "0.0".into();
}
let s = format!("{v}");
if s.contains('.') || s.contains('e') || s.contains("inf") || s.contains("NaN") { s } else { format!("{s}.0") }
}
/// Write tags as ASCII DXF (CRLF line ends, codes right-aligned to 3 as is conventional).
///
/// The output is pure ASCII: non-ASCII characters in strings are written as `\U+XXXX` escapes,
/// the pre-R2007 convention, so it is correct whatever `$DWGCODEPAGE` the header declares.
pub fn write_ascii(tags: &[Tag]) -> String {
write_ascii_as(tags, false)
}
/// Write tags as ASCII DXF with text in UTF-8 (`utf8`, the R2007+ convention: non-ASCII
/// characters as they are) or escaped as `\U+XXXX` (older versions, see [`write_ascii`]). Line
/// breaks inside strings become spaces either way.
pub fn write_ascii_as(tags: &[Tag], utf8: bool) -> String {
let bytes = ascii(tags, if utf8 { Strings::Utf8 } else { Strings::Escaped(None) });
// Both forms are UTF-8 (the escaped one is ASCII).
String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned())
}
/// Write tags as pre-R2007 ASCII DXF with text in the code page `code_page` names (a
/// `$DWGCODEPAGE` value such as `ANSI_1252`), as the DXF Reference describes for those versions:
/// a character the code page has is written as its bytes, any other as a `\U+XXXX` escape. A
/// code page CADCraft doesn't know, `ASCII`, and `UTF8`/`UNICODE` (not a pre-2007 code page)
/// give [`write_ascii`]'s pure ASCII output. So does a file whose code page bytes happen to be
/// valid UTF-8 (`СІ` in ANSI_1251 is D1 B2, U+0472), since readers, ours included, take an ASCII
/// DXF that is valid UTF-8 as UTF-8.
pub fn write_ascii_in(tags: &[Tag], code_page: &str) -> Vec<u8> {
let bytes = ascii(tags, Strings::Escaped(codepage::encoder(code_page)));
if !bytes.is_ascii() && std::str::from_utf8(&bytes).is_ok() {
return ascii(tags, Strings::Escaped(None));
}
bytes
}
/// How a writer stores string values.
#[derive(Clone, Copy)]
enum Strings {
/// As they are (R2007+).
Utf8,
/// ASCII as it is, other characters in this code page when it has them, otherwise as
/// `\U+XXXX` escapes (before R2007).
Escaped(Option<codepage::Decoder>),
}
fn ascii(tags: &[Tag], strings: Strings) -> Vec<u8> {
let mut out = Vec::with_capacity(tags.len() * 16);
for t in tags {
let _ = write!(out, "{:>3}\r\n", t.code);
match &t.value {
Value::Str(s) => push_string(s, strings, &mut out),
Value::Real(r) => out.extend_from_slice(format_real(*r).as_bytes()),
Value::Int(i) => out.extend_from_slice(i.to_string().as_bytes()),
Value::Bool(b) => out.extend_from_slice(i64::from(*b).to_string().as_bytes()),
Value::Hex(h) => {
// The DXF Reference limits a binary chunk line to 254 hex digits (127 bytes);
// longer data continues in further groups of the same code. Only hex digits are
// written, so a hostile value can't inject tags.
let digits = normalize_hex(h);
let mut chunks: Vec<&str> = digits.as_bytes().chunks(254).map(|c| std::str::from_utf8(c).unwrap_or_default()).collect();
if chunks.is_empty() {
chunks.push("");
}
for (n, chunk) in chunks.into_iter().enumerate() {
if n > 0 {
let _ = write!(out, "\r\n{:>3}\r\n", t.code);
}
out.extend_from_slice(chunk.as_bytes());
}
}
}
out.extend_from_slice(b"\r\n");
}
out
}
/// Write tags as binary DXF (DXF Reference, "Binary DXF Files", R13+ layout): the sentinel,
/// then per tag a 2-byte little-endian group code and the value in the binary form of the code's
/// [`Kind`]: a zero-terminated string, an 8-byte real, a 2-, 4- or 8-byte integer, a 1-byte
/// boolean, or a binary chunk (one length byte, then up to 255 bytes; longer data is split into
/// several groups of the same code). Strings are UTF-8 when `utf8` (R2007+), otherwise escaped as
/// in [`write_ascii`]. A tag's value is converted to its code's kind, so a number written as text
/// is stored as a number; a code outside the 16-bit range is skipped.
pub fn write_binary(tags: &[Tag], utf8: bool) -> Vec<u8> {
binary(tags, if utf8 { Strings::Utf8 } else { Strings::Escaped(None) })
}
/// Write tags as pre-R2007 binary DXF with text in the code page `code_page` names, as
/// [`write_ascii_in`] does.
pub fn write_binary_in(tags: &[Tag], code_page: &str) -> Vec<u8> {
binary(tags, Strings::Escaped(codepage::encoder(code_page)))
}
fn binary(tags: &[Tag], strings: Strings) -> Vec<u8> {
let mut out = Vec::with_capacity(BINARY_SENTINEL.len() + tags.len() * 12);
out.extend_from_slice(BINARY_SENTINEL);
for t in tags {
let Ok(code) = i16::try_from(t.code) else { continue };
let code_bytes = code.to_le_bytes();
match kind_of(t.code) {
Kind::Str => {
out.extend_from_slice(&code_bytes);
let s = match &t.value {
Value::Str(s) => s.clone(),
v => v.as_str(),
};
let mut text = Vec::with_capacity(s.len());
push_string(&s, strings, &mut text);
out.extend(text.into_iter().filter(|&b| b != 0));
out.push(0);
}
Kind::Real => {
out.extend_from_slice(&code_bytes);
out.extend_from_slice(&t.value.as_f64().to_le_bytes());
}
Kind::Int16 => {
out.extend_from_slice(&code_bytes);
out.extend_from_slice(&wrap_i16(t.value.as_i64()));
}
Kind::Int32 => {
out.extend_from_slice(&code_bytes);
out.extend_from_slice(&wrap_i32(t.value.as_i64()));
}
Kind::Int64 => {
out.extend_from_slice(&code_bytes);
out.extend_from_slice(&t.value.as_i64().to_le_bytes());
}
Kind::Bool => {
out.extend_from_slice(&code_bytes);
out.push(u8::from(t.value.as_i64() != 0));
}
Kind::Hex => {
let bytes = hex_bytes(&t.value.as_str());
// An empty chunk is still one group, as in ASCII.
let mut chunks: Vec<&[u8]> = bytes.chunks(255).collect();
if chunks.is_empty() {
chunks.push(&[]);
}
for chunk in chunks {
out.extend_from_slice(&code_bytes);
out.push(u8::try_from(chunk.len()).unwrap_or(u8::MAX));
out.extend_from_slice(chunk);
}
}
}
}
out
}
/// Hex text cleaned up: only the hex digits are kept, and an odd trailing digit is padded with
/// `0` (so the bytes before it are never shifted). Used by the reader and both writers.
fn normalize_hex(s: &str) -> String {
let mut out: String = s.chars().filter(char::is_ascii_hexdigit).collect();
if out.len() % 2 == 1 {
out.push('0');
}
out
}
/// The bytes of hex text, two digits each (see [`normalize_hex`]).
fn hex_bytes(s: &str) -> Vec<u8> {
let digits: Vec<u8> = normalize_hex(s).bytes().filter_map(|b| char::from(b).to_digit(16).and_then(|d| u8::try_from(d).ok())).collect();
digits.as_chunks::<2>().0.iter().map(|[hi, lo]| (hi << 4) | lo).collect()
}
/// A 16- or 32-bit integer for binary DXF: values that fit the unsigned width wrap into the
/// signed one (65535 is -1, as writers that store unsigned flags expect); anything else clamps.
fn wrap_i16(v: i64) -> [u8; 2] {
match u16::try_from(v) {
Ok(u) => u.to_le_bytes(),
Err(_) => i16::try_from(v.clamp(i64::from(i16::MIN), i64::from(i16::MAX))).unwrap_or_default().to_le_bytes(),
}
}
fn wrap_i32(v: i64) -> [u8; 4] {
match u32::try_from(v) {
Ok(u) => u.to_le_bytes(),
Err(_) => i32::try_from(v.clamp(i64::from(i32::MIN), i64::from(i32::MAX))).unwrap_or_default().to_le_bytes(),
}
}
/// Whether `bytes` are a binary DXF file (they start with the binary sentinel).
pub fn is_binary(bytes: &[u8]) -> bool {
bytes.starts_with(BINARY_SENTINEL)
}
/// A string value as `strings` stores it. Line breaks become spaces. Before R2007 the text is
/// in the `$DWGCODEPAGE` code page: ASCII stays as it is, a character the code page has becomes
/// its bytes, and every other one `\U+XXXX` (a surrogate pair of escapes above U+FFFF). Without
/// a code page the result is ASCII, so it is valid in any code page. In every form a backslash
/// that would start a `\U+` or `\M+` sequence is written as `\U+005C`, so the reader gives back
/// the literal text (#2050). So is a double-byte character whose trail byte is 0x5C (`\`) in that
/// place, such as Shift-JIS `表` or Big5 `許`: CADCraft decodes the code page before it looks for
/// escapes, but a reader that looks first would take that byte and the `U+` after it for one.
fn push_string(s: &str, strings: Strings, out: &mut Vec<u8>) {
let chars: Vec<char> = s.chars().collect();
let escape_at = |j: usize| matches!(chars.get(j), Some('U' | 'M')) && chars.get(j + 1) == Some(&'+');
for (i, &c) in chars.iter().enumerate() {
match (c, strings) {
('\r' | '\n', _) => out.push(b' '),
('\\', _) if escape_at(i + 1) => {
out.extend_from_slice(b"\\U+005C");
}
(c, Strings::Utf8) => out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
(c, _) if c.is_ascii() => out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes()),
(c, Strings::Escaped(Some(d))) if code_page_bytes(c, d, escape_at(i + 1), out) => {}
(c, Strings::Escaped(_)) => {
let mut units = [0u16; 2];
for u in c.encode_utf16(&mut units) {
let _ = write!(out, "\\U+{u:04X}");
}
}
}
}
}
/// `c` in the code page `d`, if it has it, unless it is a double-byte character whose trail byte
/// is 0x5C and an escape's `U+` or `M+` follows (`before_escape`): see [`push_string`].
fn code_page_bytes(c: char, d: codepage::Decoder, before_escape: bool, out: &mut Vec<u8>) -> bool {
let start = out.len();
if !codepage::encode_char(c, d, out) {
return false;
}
if before_escape && out.len() - start > 1 && out.last() == Some(&b'\\') {
out.truncate(start);
return false;
}
true
}
/// A section: `0 SECTION / 2 NAME ... 0 ENDSEC`.
#[derive(Clone, Debug, Default)]
pub struct Section {
pub name: String,
pub tags: Vec<Tag>,
}
/// Split a tag stream into sections.
pub fn sections(tags: &[Tag]) -> Vec<Section> {
let mut out = Vec::new();
let mut i = 0;
while i < tags.len() {
let is_sec = tags.get(i).is_some_and(|t| t.code == 0 && t.str().trim_end() == "SECTION");
if is_sec {
let name = tags.get(i + 1).filter(|t| t.code == 2).map(|t| t.str().trim_end().to_string()).unwrap_or_default();
let start = i + 2;
let mut j = start;
while j < tags.len() && !(tags.get(j).is_some_and(|t| t.code == 0 && t.str().trim_end() == "ENDSEC")) {
j += 1;
}
out.push(Section { name, tags: tags.get(start..j).unwrap_or(&[]).to_vec() });
i = j + 1;
} else {
i += 1;
}
}
out
}
/// Split a run of tags into records starting at each code-0 tag: (type, tags after the 0).
pub fn records(tags: &[Tag]) -> Vec<(String, Vec<Tag>)> {
let mut out: Vec<(String, Vec<Tag>)> = Vec::new();
for t in tags {
if t.code == 0 {
out.push((t.str(), Vec::new()));
} else if let Some(last) = out.last_mut() {
last.1.push(t.clone());
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn literal_escape_text_roundtrips() {
for utf8 in [false, true] {
for text in ["\\U+00E9", "\\M+183A4F", "a\\nb \\P", "\\\\U+00E9", "\\U+005C"] {
let tags = vec![Tag::s(8, text)];
let back = parse_ascii(&write_ascii_as(&tags, utf8)).unwrap();
assert_eq!(back, tags, "utf8={utf8} {text}");
let back = parse_binary(&write_binary(&tags, utf8)).unwrap();
assert_eq!(back[1..], tags[..], "binary utf8={utf8} {text}");
}
}
}
#[test]
fn blank_lines_do_not_consume_group_code_limit() {
let tags = parse_with_limit(b"0\nEOF\n\n\n", 1).expect("one group code should fit a limit of one");
assert_eq!(tags, vec![Tag::s(0, "EOF")]);
}
#[test]
fn ascii_roundtrip() {
let tags = vec![
Tag::s(0, "SECTION"),
Tag::s(2, "ENTITIES"),
Tag::s(0, "LINE"),
Tag::s(8, "0"),
Tag::f(10, 1.5),
Tag::f(20, 2.0),
Tag::i(62, 1),
Tag::s(0, "ENDSEC"),
Tag::s(0, "EOF"),
];
let text = write_ascii(&tags);
let back = parse(text.as_bytes()).unwrap();
assert_eq!(back, tags);
let secs = sections(&back);
assert_eq!(secs.len(), 1);
assert_eq!(secs[0].name, "ENTITIES");
let recs = records(&secs[0].tags);
assert_eq!(recs[0].0, "LINE");
assert_eq!(recs[0].1.len(), 4);
}
#[test]
fn binary_parse() {
let mut b = BINARY_SENTINEL.to_vec();
let push_str = |b: &mut Vec<u8>, code: i16, s: &str| {
b.extend_from_slice(&code.to_le_bytes());
b.extend_from_slice(s.as_bytes());
b.push(0);
};
push_str(&mut b, 0, "LINE");
b.extend_from_slice(&10i16.to_le_bytes());
b.extend_from_slice(&3.25f64.to_le_bytes());
b.extend_from_slice(&62i16.to_le_bytes());
b.extend_from_slice(&5i16.to_le_bytes());
push_str(&mut b, 0, "EOF");
let tags = parse(&b).unwrap();
assert_eq!(tags[1], Tag::f(10, 3.25));
assert_eq!(tags[2], Tag::i(62, 5));
}
#[test]
fn malformed_inputs() {
assert!(parse(b"").is_err());
assert!(parse(b"abc\nxyz\n").is_err());
assert!(parse(b"0\n").is_err());
let mut b = BINARY_SENTINEL.to_vec();
b.extend_from_slice(&10i16.to_le_bytes());
b.extend_from_slice(&[1, 2, 3]);
assert!(parse(&b).is_err());
// Bad numbers become 0 rather than failing.
let t = parse(b"10\nnotanumber\n0\nEOF\n").unwrap();
assert_eq!(t[0].f64(), 0.0);
}
#[test]
fn unicode_escapes_and_latin1() {
let t = parse(b"1\nCaf\\U+00E9\n0\nEOF\n").unwrap();
assert_eq!(t[0].str(), "Café");
let t = parse(b"1\nCaf\xe9\n0\nEOF\n").unwrap();
assert_eq!(t[0].str(), "Café");
}
#[test]
fn surrogate_pair_escapes() {
let t = parse(b"1\n\\U+D83D\\U+DE00 \\u+56fe\\U+53f7\n0\nEOF\n").unwrap();
assert_eq!(t[0].str(), "😀 \\u+56fe号");
}
#[test]
fn hostile_escapes_stay_literal() {
for s in [
"\\U+",
"\\U",
"\\",
"a\\U+ZZZZ",
"\\U+12",
"\\U+D800",
"\\U+DC00",
"\\U+D800\\U+0041",
"\\U+D83D\\U+DE",
"\\U++123",
"\\U+-123",
"x\\U+12\u{e9}4",
] {
let t = parse(format!("1\n{s}\n0\nEOF\n").as_bytes()).unwrap();
let expect = if s == "\\U+D800\\U+0041" { "\\U+D800A" } else { s };
assert_eq!(t[0].str(), expect, "{s:?}");
}
}
#[test]
fn writes_non_ascii_as_escapes() {
let tags = vec![Tag::s(1, "图号 İø 😀\r\nend"), Tag::s(1000, "Ø"), Tag::s(0, "EOF")];
let text = write_ascii(&tags);
assert!(text.is_ascii());
assert!(text.contains("\\U+56FE\\U+53F7 \\U+00C4\\U+00B0\\U+00F8 \\U+D83D\\U+DE00 end\r\n"));
let back = parse(text.as_bytes()).unwrap();
assert_eq!(back[0].str(), "图号 İø 😀 end");
assert_eq!(back[1].str(), "Ø");
}
#[test]
fn binary_strings_unescape() {
let mut b = BINARY_SENTINEL.to_vec();
b.extend_from_slice(&1i16.to_le_bytes());
b.extend_from_slice(b"\\U+56FE\\U+53F7\0");
b.extend_from_slice(&0i16.to_le_bytes());
b.extend_from_slice(b"EOF\0");
assert_eq!(parse(&b).unwrap()[0].str(), "图号");
}
}
#[cfg(test)]
mod limit_tests {
use super::*;
#[test]
fn tag_limit_defaults_and_env_override() {
assert_eq!(max_tags_from(None), MAX_TAGS);
assert_eq!(max_tags_from(Some("")), MAX_TAGS);
assert_eq!(max_tags_from(Some("0")), MAX_TAGS);
assert_eq!(max_tags_from(Some("abc")), MAX_TAGS);
assert_eq!(max_tags_from(Some(" 400_000_000 ")), 400_000_000);
// Issue #1948: the default must admit a DXF rendition well above 50 million group codes.
const { assert!(MAX_TAGS >= 100_000_000) };
}
#[test]
fn the_tag_list_is_reserved_once_and_a_refusal_is_an_error() {
let tags = parse_ascii_counted("0\nSECTION\n0\nENDSEC\n0\nEOF\n", MAX_TAGS, 3).unwrap();
assert_eq!((tags.len(), tags.capacity()), (3, 3));
let e = parse_ascii_counted("0\nEOF\n", usize::MAX, usize::MAX).unwrap_err();
assert!(matches!(e, DxfError::OutOfMemory { .. }), "{e}");
}
}
-117
View File
@@ -1,117 +0,0 @@
//! The DXF/DWG file versions CADCraft writes (DXF Reference, HEADER `$ACADVER`).
/// A file version CADCraft can save: the AutoCAD release that introduced the format. Each format
/// also serves the releases after it (2018 is still AutoCAD's current format).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Version {
/// AutoCAD 2000/2002 (AC1015).
R2000,
/// AutoCAD 2004–2006 (AC1018).
R2004,
/// AutoCAD 2007–2009 (AC1021): the first version whose DXF text is UTF-8.
R2007,
/// AutoCAD 2010–2012 (AC1024).
R2010,
/// AutoCAD 2013–2017 (AC1027).
R2013,
/// AutoCAD 2018 and later (AC1032), the default.
#[default]
R2018,
}
impl Version {
/// Every version, oldest first.
pub const ALL: [Version; 6] = [Version::R2000, Version::R2004, Version::R2007, Version::R2010, Version::R2013, Version::R2018];
/// The `$ACADVER` code ("AC1032").
pub fn code(self) -> &'static str {
match self {
Version::R2000 => "AC1015",
Version::R2004 => "AC1018",
Version::R2007 => "AC1021",
Version::R2010 => "AC1024",
Version::R2013 => "AC1027",
Version::R2018 => "AC1032",
}
}
/// The release year that names the version ("2018").
pub fn year(self) -> &'static str {
match self {
Version::R2000 => "2000",
Version::R2004 => "2004",
Version::R2007 => "2007",
Version::R2010 => "2010",
Version::R2013 => "2013",
Version::R2018 => "2018",
}
}
/// A version named by its year ("2018", "R2018") or its `$ACADVER` code ("AC1032"), any case.
pub fn parse(s: &str) -> Option<Version> {
let s = s.trim();
let year = s.strip_prefix(['R', 'r']).unwrap_or(s);
Version::ALL.into_iter().find(|v| v.year() == year || v.code().eq_ignore_ascii_case(s))
}
/// The version to save a file of `$ACADVER` `code` in: the same version when CADCraft writes
/// it, else the nearest one it does (R2000 for older files, 2018 for newer ones); `None` when
/// the code isn't a version code at all.
pub fn for_acadver(code: &str) -> Option<Version> {
let code = code.trim();
if let Some(v) = Version::ALL.into_iter().find(|v| v.code().eq_ignore_ascii_case(code)) {
return Some(v);
}
code.get(..2).filter(|p| p.eq_ignore_ascii_case("AC"))?;
let n = code.get(2..).filter(|d| d.bytes().all(|b| b.is_ascii_digit())).and_then(|d| d.parse::<u32>().ok())?;
Some(match n {
..1018 => Version::R2000,
1018..1021 => Version::R2004,
1021..1024 => Version::R2007,
1024..1027 => Version::R2010,
1027..1032 => Version::R2013,
_ => Version::R2018,
})
}
/// Whether text in this version's DXF is UTF-8 (2007 and later). Older versions keep text in
/// the `$DWGCODEPAGE` code page, which CADCraft avoids by escaping non-ASCII as `\U+XXXX`.
pub fn utf8(self) -> bool {
self >= Version::R2007
}
}
impl std::fmt::Display for Version {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.year())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_years_and_codes() {
assert_eq!(Version::parse("2018"), Some(Version::R2018));
assert_eq!(Version::parse(" r2004 "), Some(Version::R2004));
assert_eq!(Version::parse("ac1021"), Some(Version::R2007));
assert_eq!(Version::parse("2005"), None);
assert_eq!(Version::parse(""), None);
for v in Version::ALL {
assert_eq!(Version::parse(v.code()), Some(v));
assert_eq!(Version::parse(v.year()), Some(v));
}
}
#[test]
fn file_versions_map_to_the_nearest_writable_one() {
assert_eq!(Version::for_acadver("AC1009"), Some(Version::R2000));
assert_eq!(Version::for_acadver("AC1014"), Some(Version::R2000));
assert_eq!(Version::for_acadver("AC1024"), Some(Version::R2010));
assert_eq!(Version::for_acadver("AC1035"), Some(Version::R2018));
assert_eq!(Version::for_acadver("MC0.0"), None);
assert_eq!(Version::for_acadver("AC"), None);
assert_eq!(Version::for_acadver("AC99999999999999999999"), None);
}
}
-19
View File
@@ -1,19 +0,0 @@
//! A UTF-8 byte order mark at the start of an ASCII DXF is skipped.
const BODY: &str = " 0\r\nSECTION\r\n 2\r\nENTITIES\r\n 0\r\nENDSEC\r\n 0\r\nEOF\r\n";
#[test]
fn utf8_bom_bytes_are_skipped() {
let plain = cadcraft_dxf::parse(BODY.as_bytes()).expect("plain parses");
let mut bytes = vec![0xEF, 0xBB, 0xBF];
bytes.extend_from_slice(BODY.as_bytes());
let with_bom = cadcraft_dxf::parse(&bytes);
assert!(with_bom.is_ok(), "{with_bom:?}");
assert_eq!(with_bom.map(|t| t.len()).unwrap_or(0), plain.len());
}
#[test]
fn bom_text_is_skipped() {
let text = format!("\u{feff}{BODY}");
assert!(cadcraft_dxf::parse_ascii(&text).is_ok());
}
-75
View File
@@ -1,75 +0,0 @@
//! Binary DXF writing (#421): every value kind round-trips through `write_binary` and `parse`,
//! and hostile binary input never panics.
use cadcraft_dxf::{Tag, Value, is_binary, parse, write_ascii_as, write_binary};
fn sample() -> Vec<Tag> {
vec![
Tag::s(0, "SECTION"),
Tag::s(2, "ENTITIES"),
Tag::s(0, "TEXT"),
Tag::s(5, "1F"),
Tag::f(10, -3.25),
Tag::i(62, 5),
Tag::i(90, 70_000),
Tag::i(160, 1 << 40),
Tag::new(290, Value::Bool(true)),
Tag::new(310, Value::Hex("00FFA5".into())),
Tag::s(1, "图号 Café 😀"),
Tag::i(1071, -2),
Tag::s(0, "ENDSEC"),
Tag::s(0, "EOF"),
]
}
#[test]
fn binary_roundtrips_every_value_kind() {
for utf8 in [false, true] {
let bytes = write_binary(&sample(), utf8);
assert!(is_binary(&bytes));
assert_eq!(parse(&bytes).unwrap(), sample(), "utf8 = {utf8}");
}
// Pre-2007 strings are escaped to ASCII, 2007+ ones are UTF-8.
let old = write_binary(&sample(), false);
assert!(old.windows(7).any(|w| w == b"\\U+56FE"));
let new = write_binary(&sample(), true);
assert!(new.windows("图号".len()).any(|w| w == "图号".as_bytes()));
}
#[test]
fn binary_converts_values_to_their_codes_kind() {
// A number held as text at a numeric code, an out-of-range 16-bit value, a long chunk.
let long = "AB".repeat(300);
let tags = vec![Tag::s(70, "12"), Tag::i(62, 1 << 20), Tag::new(310, Value::Hex(long)), Tag::s(0, "EOF")];
let back = parse(&write_binary(&tags, true)).unwrap();
assert_eq!(back[0], Tag::i(70, 12));
assert_eq!(back[1], Tag::i(62, i64::from(i16::MAX)));
assert_eq!(back[2].code, 310);
assert_eq!(back[3].code, 310, "300 bytes are split into chunks of at most 255");
assert_eq!(back[2].str().len() + back[3].str().len(), 600);
}
#[test]
fn utf8_ascii_keeps_text_and_drops_line_breaks() {
let text = write_ascii_as(&[Tag::s(1, "图号\r\nÄ"), Tag::s(0, "EOF")], true);
assert!(text.contains("图号 Ä\r\n"));
assert_eq!(parse(text.as_bytes()).unwrap()[0].str(), "图号 Ä");
}
#[test]
fn hostile_binary_input_never_panics() {
let good = write_binary(&sample(), true);
// Every truncation, and every single-byte corruption of the body.
for n in 0..good.len() {
let _ = parse(good.get(..n).unwrap());
}
for i in 22..good.len() {
for b in [0u8, 0x7f, 0xff] {
let mut bad = good.clone();
bad[i] = b;
let _ = parse(&bad);
}
}
// A sentinel and nothing else is not a drawing.
assert!(parse(b"AutoCAD Binary DXF\r\n\x1a\0").is_err());
}
-116
View File
@@ -1,116 +0,0 @@
//! Pre-R2007 DXF text is written in the `$DWGCODEPAGE` code page: characters it has as their
//! bytes, the others as `\U+XXXX` escapes; every form reads back to the same text.
use cadcraft_dxf::{Tag, parse, write_ascii, write_ascii_in, write_binary_in};
fn file(code_page: &str, text: &str) -> Vec<Tag> {
vec![
Tag::s(0, "SECTION"),
Tag::s(2, "HEADER"),
Tag::s(9, "$ACADVER"),
Tag::s(1, "AC1015"),
Tag::s(9, "$DWGCODEPAGE"),
Tag::s(3, code_page),
Tag::s(0, "ENDSEC"),
Tag::s(0, "SECTION"),
Tag::s(2, "ENTITIES"),
Tag::s(0, "TEXT"),
Tag::s(1, text),
Tag::s(0, "ENDSEC"),
Tag::s(0, "EOF"),
]
}
fn contains(bytes: &[u8], part: &[u8]) -> bool {
bytes.windows(part.len()).any(|w| w == part)
}
#[test]
fn text_is_written_in_the_code_page() {
// (code page, text, the bytes written for it)
let cases: [(&str, &str, &[u8]); 6] = [
("ANSI_1252", "Ação € 图", b"A\xE7\xE3o \x80 \\U+56FE"),
("ANSI_1251", "Слой é", b"\xD1\xEB\xEE\xE9 \\U+00E9"),
("ANSI_932", "表図面 é", b"\x95\x5C\x90\x7D\x96\xCA \\U+00E9"),
("DOS850", "Größe €", b"Gr\x94\xE1e \\U+20AC"),
("ANSI_1252", "😀", b"\\U+D83D\\U+DE00"),
// A code page CADCraft doesn't know: everything non-ASCII is escaped.
("ANSI_1361", "Ação", b"A\\U+00E7\\U+00E3o"),
];
for (cp, text, raw) in cases {
let tags = file(cp, text);
for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
assert!(contains(&bytes, raw), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
}
}
}
/// Without a known code page, and for `ASCII`, `UTF8` and `UNICODE` headers, the output is what
/// `write_ascii` writes (pure ASCII with escapes), line breaks included.
#[test]
fn unknown_ascii_and_utf8_code_pages_are_pure_ascii() {
for cp in ["EBCDIC", "ASCII", "ascii ", "UTF8", "UNICODE"] {
let tags = file(cp, "Ação\r\nfim");
let bytes = write_ascii_in(&tags, cp);
assert!(bytes.is_ascii(), "{cp}");
assert_eq!(bytes, write_ascii(&tags).into_bytes(), "{cp}");
assert!(contains(&bytes, b"A\\U+00E7\\U+00E3o fim"), "{cp}");
assert!(write_binary_in(&tags, cp).iter().all(u8::is_ascii), "{cp} binary");
}
}
/// Code page bytes that happen to form valid UTF-8 (`СІ` in ANSI_1251 is D1 B2, which is U+0472
/// in UTF-8) would be read back as UTF-8 from an ASCII file, so that file is written with
/// escapes. Binary DXF reads strings by the header's code page and keeps the bytes.
#[test]
fn code_page_bytes_that_are_valid_utf8_are_escaped_in_ascii() {
let tags = file("ANSI_1251", "СІ");
let ascii = write_ascii_in(&tags, "ANSI_1251");
assert!(ascii.is_ascii(), "{:?}", String::from_utf8_lossy(&ascii));
assert!(contains(&ascii, b"\\U+0421\\U+0406"));
assert_eq!(parse(&ascii).unwrap()[10].str(), "СІ");
let binary = write_binary_in(&tags, "ANSI_1251");
assert!(contains(&binary, b"\xD1\xB2"));
assert_eq!(parse(&binary).unwrap()[10].str(), "СІ");
// Bytes that are not valid UTF-8 stay as they are.
assert!(contains(&write_ascii_in(&file("ANSI_1251", "Слой"), "ANSI_1251"), b"\xD1\xEB\xEE\xE9"));
}
/// A literal `\U+` or `\M+` in the text (#2050) reads back as written alongside code page bytes,
/// in ASCII and binary, including an ASCII file that falls back to escapes because its bytes
/// would read as UTF-8.
#[test]
fn literal_escapes_survive_code_page_text() {
for (cp, text) in
[("ANSI_1252", "Ação \\U+00E9 \\M+183A4F"), ("ANSI_1251", "Слой \\U+0041"), ("ANSI_1251", "СІ \\U+0041"), ("ANSI_932", "表 \\M+1")]
{
let tags = file(cp, text);
for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
assert!(contains(&bytes, b"\\U+005C"), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
}
}
}
/// Double-byte code pages whose trail byte can be 0x5C (`\\`): Shift-JIS `表` (95 5C) and `ソ`
/// (83 5C), Big5 `許` (B3 5C), GBK `乗` (81 5C). Right before `U+` or `M+`, such a character is
/// written as an escape, so even a reader that looks for escapes before it decodes the code page
/// reads it right. Elsewhere it stays as its bytes. Both forms read back as written.
#[test]
fn a_trail_byte_backslash_never_starts_an_escape() {
let cases: [(&str, &str, &[u8], &[u8]); 4] = [
("ANSI_932", "表U+0041 表示", b"\\U+8868U+0041 \x95\x5C\x8E\xA6", b"\x95\x5CU+"),
("ANSI_932", "ソM+1A2B", b"\\U+30BDM+1A2B", b"\x83\x5CM+"),
("ANSI_950", "許U+0041", b"\\U+8A31U+0041", b"\xB3\x5CU+"),
("ANSI_936", "乗U+0041", b"\\U+4E57U+0041", b"\x81\x5CU+"),
];
for (cp, text, written, never) in cases {
let tags = file(cp, text);
for (bytes, what) in [(write_ascii_in(&tags, cp), "ASCII"), (write_binary_in(&tags, cp), "binary")] {
assert!(contains(&bytes, written), "{cp} {what}: {:?}", String::from_utf8_lossy(&bytes));
assert!(!contains(&bytes, never), "{cp} {what}: a trail byte starts an escape");
assert_eq!(parse(&bytes).unwrap()[10].str(), text, "{cp} {what}");
}
}
}
-145
View File
@@ -1,145 +0,0 @@
//! Small independent byte fixtures for DXF tag types, text encoding, framing and failures.
//! Handwritten examples, not files from a CAD application or generated by our writer.
//! Background on the tag model and file structure:
//! https://ezdxf.readthedocs.io/en/stable/dxfinternals/dxftags.html
//! https://ezdxf.readthedocs.io/en/stable/dxfinternals/filestructure.html
//! ASCII spacing is our writer's documented convention; binary fixtures specify actual bytes.
use cadcraft_dxf::{DxfError, Tag, Value, parse, parse_with_limit, write_ascii_as, write_binary};
const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
fn fixtures() -> Vec<(Tag, &'static [u8], &'static [u8])> {
vec![
(Tag::s(1, " A "), b" 1\r\n A \r\n", b"\x01\0 A \0"),
(Tag::s(1, ""), b" 1\r\n\r\n", b"\x01\0\0"),
(Tag::s(105, "AB12"), b"105\r\nAB12\r\n", b"\x69\0AB12\0"),
(Tag::new(10, Value::Real(-3.25)), b" 10\r\n-3.25\r\n", b"\x0a\0\0\0\0\0\0\0\x0a\xc0"),
(Tag::i(70, -32768), b" 70\r\n-32768\r\n", b"\x46\0\0\x80"),
(Tag::i(90, -2147483648), b" 90\r\n-2147483648\r\n", b"\x5a\0\0\0\0\x80"),
(Tag::i(160, 9223372036854775807), b"160\r\n9223372036854775807\r\n", b"\xa0\0\xff\xff\xff\xff\xff\xff\xff\x7f"),
(Tag::new(290, Value::Bool(false)), b"290\r\n0\r\n", b"\x22\x01\0"),
(Tag::new(299, Value::Bool(true)), b"299\r\n1\r\n", b"\x2b\x01\x01"),
(Tag::new(310, Value::Hex("00FF80".into())), b"310\r\n00FF80\r\n", b"\x36\x01\x03\0\xff\x80"),
(Tag::new(1004, Value::Hex(String::new())), b"1004\r\n\r\n", b"\xec\x03\0"),
(Tag::i(1070, -2), b"1070\r\n-2\r\n", b"\x2e\x04\xfe\xff"),
(Tag::i(1071, 65536), b"1071\r\n65536\r\n", b"\x2f\x04\0\0\x01\0"),
]
}
#[test]
fn reads_independently_authored_ascii_and_binary_values() {
for (expected, ascii, binary) in fixtures() {
assert_eq!(parse(ascii).unwrap(), std::slice::from_ref(&expected), "ASCII code {}", expected.code);
let bytes = [SENTINEL, binary].concat();
assert_eq!(parse(&bytes).unwrap(), std::slice::from_ref(&expected), "binary code {}", expected.code);
}
}
#[test]
fn writes_independently_specified_ascii_and_binary_bytes() {
for (tag, ascii, binary) in fixtures() {
for utf8 in [false, true] {
let tags = std::slice::from_ref(&tag);
assert_eq!(write_ascii_as(tags, utf8).as_bytes(), ascii, "ASCII code {}", tag.code);
assert_eq!(write_binary(tags, utf8), [SENTINEL, binary].concat(), "binary code {}", tag.code);
}
}
}
#[test]
fn integer_code_ranges_have_independent_binary_widths() {
// Specification ranges and widths, never kind_of(): a shared reader/writer mistake
// can round-trip every boundary value while still using the wrong number of bytes.
let widths = [
(vec![60..=79, 170..=179, 270..=289, 370..=389, 400..=409, 1060..=1070], 2, i64::from(i16::MIN), i64::from(i16::MAX)),
(vec![90..=99, 420..=429, 440..=459, 1071..=1071], 4, i64::from(i32::MIN), i64::from(i32::MAX)),
(std::iter::once(160..=169).collect(), 8, i64::MIN, i64::MAX),
];
for (ranges, width, min, max) in widths {
for code in ranges.into_iter().flatten() {
for value in [min, min + 1, -1, 0, 1, max - 1, max] {
// Binary DXF uses a little-endian 16-bit group code and a fixed-width,
// little-endian two's-complement integer. Encoding is version-independent.
let code_bytes = u16::try_from(code).unwrap().to_le_bytes();
let value_bytes = value.to_le_bytes();
let expected = [SENTINEL, &code_bytes, &value_bytes[..width]].concat();
let tags = [Tag::i(code, value)];
for utf8 in [false, true] {
assert_eq!(write_binary(&tags, utf8), expected, "code={code} value={value} utf8={utf8}");
}
assert_eq!(parse(&expected).unwrap(), tags, "code={code} value={value}");
}
}
}
}
#[test]
fn text_encoding_has_independent_wire_expectations() {
let tags = [Tag::s(1, "é😀")];
let escaped = b"\\U+00E9\\U+D83D\\U+DE00";
let utf8 = b"\xc3\xa9\xf0\x9f\x98\x80";
for (unicode, text) in [(false, escaped.as_slice()), (true, utf8.as_slice())] {
let ascii = [b" 1\r\n".as_slice(), text, b"\r\n"].concat();
let binary = [SENTINEL, b"\x01\0", text, b"\0"].concat();
assert_eq!(write_ascii_as(&tags, unicode).as_bytes(), ascii, "utf8={unicode}");
assert_eq!(write_binary(&tags, unicode), binary, "utf8={unicode}");
assert_eq!(parse(&ascii).unwrap(), tags);
assert_eq!(parse(&binary).unwrap(), tags);
}
// Pre-2007 code-page bytes are independent of the writer, which emits Unicode escapes.
let ascii = b"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1015\n9\n$DWGCODEPAGE\n3\nANSI_1252\n0\nENDSEC\n1\n\x80\xe9\n0\nEOF\n";
let binary = [
SENTINEL,
b"\0\0SECTION\0\x02\0HEADER\0\x09\0$ACADVER\0\x01\0AC1015\0\x09\0$DWGCODEPAGE\0\x03\0ANSI_1252\0\0\0ENDSEC\0\x01\0\x80\xe9\0\0\0EOF\0",
]
.concat();
for bytes in [ascii.as_slice(), binary.as_slice()] {
let tags = parse(bytes).unwrap();
assert_eq!(tags[7], Tag::s(1, "ێ"));
}
}
#[test]
fn ascii_accepts_line_endings_padding_and_no_final_newline() {
let expected = [Tag::i(70, -7), Tag::s(1, " text "), Tag::s(0, "EOF")];
for newline in ["\n", "\r\n"] {
for final_newline in [false, true] {
let mut text = [" 70 ", " -7 ", "1", " text ", "0", "EOF"].join(newline);
if final_newline {
text.push_str(newline);
}
assert_eq!(parse(text.as_bytes()).unwrap(), expected, "newline={newline:?} final={final_newline}");
}
}
}
#[test]
fn malformed_and_truncated_values_are_errors_not_panics() {
assert!(matches!(parse(b""), Err(DxfError::NotDxf)));
assert!(matches!(parse(b"oops\nvalue\n"), Err(DxfError::BadCode { line: 1, .. })));
assert!(matches!(parse(b"10\n"), Err(DxfError::Eof)));
assert!(matches!(parse(SENTINEL), Err(DxfError::NotDxf)));
for (_, _, binary) in fixtures() {
// Every cut inside the first record is an error, unlike cuts between complete records:
// the tag API deliberately accepts streams without an EOF record.
for cut in 1..binary.len() {
let bytes = [SENTINEL, &binary[..cut]].concat();
assert!(matches!(parse(&bytes), Err(DxfError::Eof)), "binary={binary:?} cut={cut}");
}
}
}
#[test]
fn tag_limit_accepts_the_exact_boundary_and_rejects_one_less() {
let ascii = b"1\nA\n70\n-7\n0\nEOF\n";
let binary = [SENTINEL, b"\x01\0A\0\x46\0\xf9\xff\0\0EOF\0"].concat();
for bytes in [ascii.as_slice(), binary.as_slice()] {
for limit in 0..3 {
assert!(matches!(parse_with_limit(bytes, limit), Err(DxfError::TooLarge { limit: actual, .. }) if actual == limit));
}
for limit in [3, 4] {
assert_eq!(parse_with_limit(bytes, limit).unwrap(), [Tag::s(1, "A"), Tag::i(70, -7), Tag::s(0, "EOF")]);
}
}
}
-220
View File
@@ -1,220 +0,0 @@
//! Hostile-input hardening of the DXF reader and writer (#1025): one regression test per finding.
use cadcraft_dxf::{Tag, Value, parse, parse_with_limit, sections, write_ascii, write_binary};
const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
fn bin_with(f: impl FnOnce(&mut Vec<u8>)) -> Vec<u8> {
let mut b = SENTINEL.to_vec();
f(&mut b);
b.extend_from_slice(&0i16.to_le_bytes());
b.extend_from_slice(b"EOF\0");
b
}
#[test]
fn binary_reals_that_are_not_finite_become_zero() {
for bits in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
let b = bin_with(|b| {
b.extend_from_slice(&10i16.to_le_bytes());
b.extend_from_slice(&bits.to_le_bytes());
});
let tags = parse(&b).unwrap();
assert_eq!(tags[0], Tag::f(10, 0.0), "{bits}");
}
}
#[test]
fn ascii_accepts_bom_and_cr_only_line_ends() {
let want = vec![Tag::s(0, "SECTION"), Tag::s(2, "ENTITIES"), Tag::s(0, "ENDSEC"), Tag::s(0, "EOF")];
let text = "0\rSECTION\r2\rENTITIES\r0\rENDSEC\r0\rEOF\r";
assert_eq!(parse(text.as_bytes()).unwrap(), want);
let mut bom = b"\xEF\xBB\xBF".to_vec();
bom.extend_from_slice(text.replace('\r', "\r\n").as_bytes());
assert_eq!(parse(&bom).unwrap(), want);
// Mixed terminators.
assert_eq!(parse(b"0\r\nSECTION\r2\nENTITIES\n0\rENDSEC\r\n0\nEOF").unwrap(), want);
}
#[test]
fn cr_only_files_count_against_the_tag_limit() {
let mut text = String::new();
for _ in 0..50 {
text.push_str("999\rcomment\r");
}
text.push_str("0\rEOF\r");
assert!(parse_with_limit(text.as_bytes(), 10).is_err());
assert_eq!(parse_with_limit(text.as_bytes(), 100).unwrap().len(), 51);
}
#[test]
fn one_bad_byte_spoils_one_line_not_the_file() {
// Header says ANSI_1251; one line is UTF-8, one is Windows-1251, one has a stray byte.
let mut b = b"9\n$DWGCODEPAGE\n3\nANSI_1251\n1\n".to_vec();
b.extend_from_slice("Größe".as_bytes());
b.extend_from_slice(b"\n1\n\xCF\xF0\xE8\xE2\xE5\xF2\n0\nEOF\n");
let t = parse(&b).unwrap();
assert_eq!(t[1].str(), "ANSI_1251");
assert_eq!(t[2].str(), "Größe");
assert_eq!(t[3].str(), "Привет");
}
#[test]
fn ascii_uses_utf8_per_line_and_binary_stays_in_the_code_page() {
// ANSI_1252 file with UTF-8 bytes in one string and a Latin-1 byte in another. The ASCII
// reader takes a line that is valid UTF-8 as UTF-8; the binary reader reads every string
// from the code page, because a pre-R2007 binary file has no way to escape to UTF-8.
let utf8 = "Größe".as_bytes();
let latin = b"Caf\xE9";
let mut a = b"9\n$DWGCODEPAGE\n3\nANSI_1252\n1\n".to_vec();
a.extend_from_slice(utf8);
a.extend_from_slice(b"\n1\n");
a.extend_from_slice(latin);
a.extend_from_slice(b"\n0\nEOF\n");
let from_ascii = parse(&a).unwrap();
let b = bin_with(|b| {
for (code, s) in [(9i16, &b"$DWGCODEPAGE"[..]), (3, b"ANSI_1252"), (1, utf8), (1, latin)] {
b.extend_from_slice(&code.to_le_bytes());
b.extend_from_slice(s);
b.push(0);
}
});
let from_binary = parse(&b).unwrap();
assert_eq!(from_ascii[2].str(), "Größe");
assert_eq!(from_ascii[3].str(), "Café");
assert_eq!(from_binary[2].str(), "Größe");
assert_eq!(from_binary[3].str(), "Café");
}
#[test]
fn trailing_spaces_keep_sections_and_eof() {
let t = parse(b"0\nSECTION \n2\nENTITIES \n0\nLINE\n0\nENDSEC \n0\nEOF \n0\nSECTION\n2\nX\n0\nENDSEC\n").unwrap();
// The EOF with a trailing space still ends the file.
assert_eq!(t.len(), 5);
let s = sections(&t);
assert_eq!(s.len(), 1);
assert_eq!(s[0].name, "ENTITIES");
assert_eq!(s[0].tags.len(), 1);
// Binary EOF too.
let mut b = SENTINEL.to_vec();
b.extend_from_slice(&0i16.to_le_bytes());
b.extend_from_slice(b"EOF \0");
b.extend_from_slice(&1i16.to_le_bytes());
b.extend_from_slice(b"after\0");
assert_eq!(parse(&b).unwrap().len(), 1);
}
#[test]
fn integer_groups_reject_non_finite_and_clamp() {
let t = parse(b"70\ninf\n70\nNaN\n70\n1e30\n70\n-1e30\n90\n1e30\n160\n1e30\n160\n-inf\n62\n12.0\n0\nEOF\n").unwrap();
assert_eq!(t[0], Tag::i(70, 0));
assert_eq!(t[1], Tag::i(70, 0));
// Clamped to what the group's width holds, unsigned values included (the binary writer
// keeps up to 65535 and 4294967295 as their bit patterns).
assert_eq!(t[2], Tag::i(70, i64::from(u16::MAX)));
assert_eq!(t[3], Tag::i(70, i64::from(i16::MIN)));
assert_eq!(t[4], Tag::i(90, i64::from(u32::MAX)));
assert_eq!(t[5], Tag::i(160, i64::MAX));
assert_eq!(t[6], Tag::i(160, 0));
assert_eq!(t[7], Tag::i(62, 12));
assert_eq!(Value::Str("inf".into()).as_i64(), 0);
}
/// An unsigned value spelled as a float reads as the same spelled as an integer (#1026 review):
/// `65535.0` is 65535 like `65535`, not 32767.
#[test]
fn unsigned_values_read_the_same_in_either_spelling() {
let t = parse(b"70\n65535.0\n70\n65535\n90\n4294967295.0\n90\n4294967295\n0\nEOF\n").unwrap();
assert_eq!(t[0], t[1]);
assert_eq!(t[0], Tag::i(70, 65535));
assert_eq!(t[2], t[3]);
assert_eq!(t[2], Tag::i(90, 4_294_967_295));
}
#[test]
fn hex_groups_pad_odd_digits_and_drop_junk() {
let t = parse(b"310\nABC\n310\nA-B zC1\n310\n\n1004\n0aF\n0\nEOF\n").unwrap();
assert_eq!(t[0].value, Value::Hex("ABC0".into()));
assert_eq!(t[1].value, Value::Hex("ABC1".into()));
assert_eq!(t[2].value, Value::Hex(String::new()));
assert_eq!(t[3].value, Value::Hex("0aF0".into()));
// The binary writer agrees with the reader: the odd digit is padded, nothing shifts.
let back = parse(&write_binary(&[Tag::new(310, Value::Hex("ABC".into())), Tag::s(0, "EOF")], true)).unwrap();
assert_eq!(back[0].value, Value::Hex("ABC0".into()));
}
#[test]
fn ascii_hex_cannot_inject_tags_and_is_split_at_254_digits() {
let evil = Tag::new(310, Value::Hex("AB\r\n0\r\nEOF".into()));
let text = write_ascii(&[evil, Tag::s(0, "EOF")]);
let back = parse(text.as_bytes()).unwrap();
assert_eq!(back.len(), 2, "{text:?}");
assert_eq!(back[0].value, Value::Hex("AB0EF0".into()));
let long = "AB".repeat(300);
let back = parse(write_ascii(&[Tag::new(310, Value::Hex(long)), Tag::s(0, "EOF")]).as_bytes()).unwrap();
let sizes: Vec<usize> = back.iter().filter(|t| t.code == 310).map(|t| t.str().len()).collect();
assert_eq!(sizes, vec![254, 254, 92]);
// An empty chunk is still one group.
let back = parse(write_ascii(&[Tag::new(310, Value::Hex(String::new())), Tag::s(0, "EOF")]).as_bytes()).unwrap();
assert_eq!(back[0].code, 310);
}
#[test]
fn binary_sixteen_and_thirty_two_bit_values_wrap_in_range_and_clamp_outside() {
let tags = [
Tag::i(70, 65535),
Tag::i(70, 40000),
Tag::i(70, 70000),
Tag::i(70, -40000),
Tag::i(90, 0xFFFF_FFFF),
Tag::i(90, 1 << 40),
Tag::i(90, -(1 << 40)),
Tag::s(0, "EOF"),
];
let back = parse(&write_binary(&tags, true)).unwrap();
assert_eq!(back[0], Tag::i(70, -1));
assert_eq!(back[1], Tag::i(70, 40000 - 65536));
assert_eq!(back[2], Tag::i(70, i64::from(i16::MAX)));
assert_eq!(back[3], Tag::i(70, i64::from(i16::MIN)));
assert_eq!(back[4], Tag::i(90, -1));
assert_eq!(back[5], Tag::i(90, i64::from(i32::MAX)));
assert_eq!(back[6], Tag::i(90, i64::from(i32::MIN)));
}
/// Strings of a `$DWGCODEPAGE`-declared file as ASCII text and as a binary file.
fn both_forms(code_page: &str, strings: &[&[u8]]) -> [Vec<Tag>; 2] {
let mut a = format!("9\n$DWGCODEPAGE\n3\n{code_page}\n").into_bytes();
for s in strings {
a.extend_from_slice(b"1\n");
a.extend_from_slice(s);
a.push(b'\n');
}
a.extend_from_slice(b"0\nEOF\n");
let b = bin_with(|b| {
for (code, s) in [(9i16, &b"$DWGCODEPAGE"[..]), (3, code_page.as_bytes())].into_iter().chain(strings.iter().map(|s| (1, *s))) {
b.extend_from_slice(&code.to_le_bytes());
b.extend_from_slice(s);
b.push(0);
}
});
[parse(&a).unwrap(), parse(&b).unwrap()]
}
#[test]
fn east_asian_short_strings_that_look_like_utf8_stay_in_the_code_page() {
// C3 B1 is valid UTF-8 ("ñ") but is also two half-width katakana in Shift-JIS; the second
// string is plainly Shift-JIS, so the file is not UTF-8.
for t in both_forms("ANSI_932", &[b"\xC3\xB1", b"\x90\x7D\x96\xCA"]) {
assert_eq!(t[2].str(), "\u{FF83}\u{FF71}");
assert_eq!(t[3].str(), "図面");
}
}
#[test]
fn east_asian_file_that_is_all_utf8_reads_as_utf8() {
for t in both_forms("ANSI_932", &["図面".as_bytes(), b"\xC3\xB1", b"plain"]) {
assert_eq!(t[2].str(), "図面");
assert_eq!(t[3].str(), "ñ");
assert_eq!(t[4].str(), "plain");
}
}
-119
View File
@@ -1,119 +0,0 @@
//! Hex payload conformance is distinct from binary framing capacity: DXF groups 310–319 and
//! 1004 specify at most 127 payload bytes per chunk, even though a length byte represents 255.
//! Inspect writer bytes without our parser; accept any compliant partition preserving payload,
//! code and following-record framing. Oversized binary read fixtures test tolerance only.
//! Pending writer regressions extend the chunk-size finding in issue #1025.
//! Public DXF Reference, Group Codes in Numerical Order and Binary DXF Files:
//! https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-3F0380A5-1C15-464D-BC66-2C5F094BCFB9.htm
//! https://help.autodesk.com/cloudhelp/2025/ENU/AutoCAD-DXF/files/GUID-FC1C3C69-DBC2-49E4-893A-000D6538C0FE.htm
use cadcraft_dxf::{Tag, Value, parse, write_ascii_as, write_binary};
const SENTINEL: &[u8] = b"AutoCAD Binary DXF\r\n\x1a\0";
const FOLLOWING_BINARY: &[u8] = b"\x46\0\xf9\xff"; // group 70, signed i16 -7
fn payload(length: usize) -> Vec<u8> {
(0..length).map(|index| u8::try_from(index * 37 % 256).unwrap()).collect()
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|byte| format!("{byte:02X}")).collect()
}
fn input(code: i32, bytes: &[u8]) -> [Tag; 2] {
[Tag::new(code, Value::Hex(hex(bytes))), Tag::i(70, -7)]
}
fn check_ascii(code: i32, bytes: &[u8], utf8: bool) {
let wire = write_ascii_as(&input(code, bytes), utf8);
let lines: Vec<_> = wire.lines().collect();
let (chunks, following) = lines.split_at(lines.len().checked_sub(2).unwrap());
assert_eq!(following[0].trim(), "70");
assert_eq!(following[1], "-7");
assert!(!chunks.is_empty(), "an empty payload must still have a tag");
let (records, remainder) = chunks.as_chunks::<2>();
assert!(remainder.is_empty(), "incomplete group/value pair");
let context = format!("ASCII code={code} bytes={} utf8={utf8}", bytes.len());
let mut back = Vec::new();
for record in records {
assert_eq!(record[0].trim().parse::<i32>().unwrap(), code, "{context}");
let text = record[1];
assert!(text.len() <= 254, "{context}: {} hex characters exceed 127 payload bytes", text.len());
assert!(text.bytes().all(|b| b.is_ascii_hexdigit()), "{context}: invalid hex");
let (pairs, remainder) = text.as_bytes().as_chunks::<2>();
assert!(remainder.is_empty(), "{context}: partial byte");
back.extend(pairs.iter().map(|pair| u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap()));
}
assert_eq!(back, bytes, "{context}: complete payload and byte order");
}
fn check_binary(code: i32, bytes: &[u8], utf8: bool) {
let wire = write_binary(&input(code, bytes), utf8);
let mut chunks = wire.strip_prefix(SENTINEL).unwrap().strip_suffix(FOLLOWING_BINARY).unwrap();
assert!(!chunks.is_empty(), "an empty payload must still have a tag");
let context = format!("binary code={code} bytes={} utf8={utf8}", bytes.len());
let mut back = Vec::new();
while !chunks.is_empty() {
let (&[lo, hi, length], rest) = chunks.split_first_chunk::<3>().unwrap();
assert_eq!(i32::from(u16::from_le_bytes([lo, hi])), code, "{context}");
assert!(length <= 127, "{context}: {length} bytes exceed the documented group limit");
let (chunk, next) = rest.split_at(usize::from(length));
back.extend_from_slice(chunk);
chunks = next;
}
assert_eq!(back, bytes, "{context}: complete payload and byte order");
}
#[test]
fn conforming_payloads_have_independent_ascii_and_binary_wire_checks() {
for code in (310..=319).chain([1004]) {
for length in [0, 1, 2, 126, 127] {
for utf8 in [false, true] {
let bytes = payload(length);
check_ascii(code, &bytes, utf8);
check_binary(code, &bytes, utf8);
}
}
}
}
#[test]
fn binary_reader_tolerates_the_full_length_byte_domain() {
// This is deliberately permissive input, not an assertion that oversized chunks conform
// or that the writer should produce them. The following record catches framing mistakes.
for code in (310_u16..=319).chain([1004]) {
for length in 0..=u8::MAX {
let bytes = payload(usize::from(length));
let mut wire = SENTINEL.to_vec();
wire.extend_from_slice(&code.to_le_bytes());
wire.push(length);
wire.extend_from_slice(&bytes);
wire.extend_from_slice(FOLLOWING_BINARY);
assert_eq!(parse(&wire).unwrap(), input(i32::from(code), &bytes), "code={code} length={length}");
}
}
}
#[test]
#[ignore = "Confirmed ASCII DXF writer nonconformance: hex payloads above 127 bytes are emitted as one oversized chunk"]
fn ascii_writer_splits_large_payloads_into_conforming_chunks() {
for code in (310..=319).chain([1004]) {
for length in [128, 254, 255, 256, 1024] {
for utf8 in [false, true] {
check_ascii(code, &payload(length), utf8);
}
}
}
}
#[test]
#[ignore = "Confirmed binary DXF writer nonconformance: 255-byte partitioning exceeds the documented 127-byte group limit"]
fn binary_writer_splits_large_payloads_into_conforming_chunks() {
for code in (310..=319).chain([1004]) {
for length in [128, 254, 255, 256, 1024] {
for utf8 in [false, true] {
check_binary(code, &payload(length), utf8);
}
}
}
}
-148
View File
@@ -1,148 +0,0 @@
//! Deterministic tag preservation through the public byte API, in both encodings and every
//! supported version. Inputs have the group code's type and representable values; lossy
//! coercions are not accepted as round-trip equality. Real values must retain their bits.
use cadcraft_dxf::{Tag, Value, Version, is_binary, parse, write_ascii_as, write_binary};
fn check(case: &str, body: &[Tag]) {
for version in Version::ALL {
let mut original = vec![
Tag::s(0, "SECTION"),
Tag::s(2, "HEADER"),
Tag::s(9, "$ACADVER"),
Tag::s(1, version.code()),
Tag::s(9, "$DWGCODEPAGE"),
Tag::s(3, "ANSI_1252"),
Tag::s(0, "ENDSEC"),
Tag::s(0, "SECTION"),
Tag::s(2, "ENTITIES"),
];
original.extend_from_slice(body);
original.extend([Tag::s(0, "ENDSEC"), Tag::s(0, "EOF")]);
for binary in [false, true] {
let mut current = original.clone();
for pass in 1..=2 {
let context = format!("{case} · {version} · binary={binary} · pass={pass}");
let bytes = if binary { write_binary(&current, version.utf8()) } else { write_ascii_as(&current, version.utf8()).into_bytes() };
assert_eq!(is_binary(&bytes), binary, "{context}");
let back = parse(&bytes).unwrap_or_else(|e| panic!("{context}: {e}"));
assert_eq!(back.len(), original.len(), "{context}: tag count");
for (index, (expected, actual)) in original.iter().zip(&back).enumerate() {
assert_eq!(actual, expected, "{context}: tag[{index}]");
if let (Value::Real(a), Value::Real(b)) = (&expected.value, &actual.value) {
assert_eq!(b.to_bits(), a.to_bits(), "{context}: tag[{index}] real bits");
}
}
assert_eq!(back, current, "{context}: no additional changes on resave");
current = back;
}
}
}
}
#[test]
fn integer_width_boundaries() {
// Explicit reference ranges, not obtained from the codec's kind_of().
let widths = [
(vec![60..=79, 170..=179, 270..=289, 370..=389, 400..=409, 1060..=1070], i64::from(i16::MIN), i64::from(i16::MAX)),
(vec![90..=99, 420..=429, 440..=459, 1071..=1071], i64::from(i32::MIN), i64::from(i32::MAX)),
(std::iter::once(160..=169).collect(), i64::MIN, i64::MAX),
];
for (ranges, min, max) in widths {
for value in [min, min + 1, -1, 0, 1, max - 1, max] {
let tags: Vec<_> = ranges.iter().cloned().flatten().map(|code| Tag::i(code, value)).collect();
check(&format!("integer/{min}..{max}/{value}"), &tags);
}
}
}
#[test]
fn finite_reals_keep_all_bits() {
let values = [
0.0,
-0.0,
f64::from_bits(1),
-f64::from_bits(1),
f64::MIN_POSITIVE,
f64::MIN_POSITIVE.next_down(),
0.1,
-3.25,
1.0_f64.next_down(),
1.0,
1.0_f64.next_up(),
1e-100,
-1e100,
f64::MAX,
f64::MIN,
];
for value in values {
let tags: Vec<_> =
[10..=59, 110..=149, 210..=239, 460..=469, 1010..=1059].into_iter().flatten().map(|code| Tag::new(code, Value::Real(value))).collect();
check(&format!("real/{:016X}", value.to_bits()), &tags);
}
}
#[test]
fn booleans() {
for value in [false, true] {
let tags: Vec<_> = (290..=299).map(|code| Tag::new(code, Value::Bool(value))).collect();
check(&format!("bool/{value}"), &tags);
}
}
#[test]
fn strings_preserve_whitespace_unicode_and_literal_escapes() {
// No CR/LF or NUL: those are line/string delimiters, not losslessly writable payloads.
let values = [
("empty", ""),
("spaces", " leading and trailing "),
("tabs", "\tindented\t"),
("unicode", "Café Ø 图号 Україна 😀 e\u{301}"),
("literal-escapes", r"\U+0041 \M+183A4 \U+D83D\U+DE00 \\U+005C \P %%c"),
("malformed-escapes", r"\U+ \U+ZZZZ \U+D800 \U+DC00 \M+9FFFF"),
];
for (case, value) in values {
let tags: Vec<_> =
[0..=9, 100..=100, 102..=102, 105..=105, 300..=309, 320..=369, 410..=419, 430..=439, 470..=479, 480..=481, 1000..=1003, 1005..=1005]
.into_iter()
.flatten()
.map(|code| Tag::s(code, value))
.collect();
check(case, &tags);
}
for length in [1, 254, 255, 256, 1024] {
check(&format!("string/length={length}"), &[Tag::s(1, "x".repeat(length))]);
}
}
#[test]
fn hex_chunks_keep_bytes_and_order() {
// DXF groups 310–319 and 1004 permit 127 payload bytes per chunk. A binary length
// byte can represent more, but that is reader tolerance, not writer conformance.
// Larger payloads need chunk-size/reassembly checks rather than exact tag equality;
// see hex_chunks.rs for the independent wire checks and pending writer regressions.
for length in [0, 1, 2, 126, 127] {
let hex: String = (0..length).map(|i| format!("{:02X}", (i * 37) % 256)).collect();
let tags: Vec<_> = (310..=319).chain([1004]).map(|code| Tag::new(code, Value::Hex(hex.clone()))).collect();
check(&format!("hex/bytes={length}"), &tags);
}
}
#[test]
fn mixed_values_and_repeated_codes_keep_order() {
check(
"mixed/repeated-codes",
&[
Tag::s(0, "TEST"),
Tag::f(10, 1.25),
Tag::s(1, "first"),
Tag::f(10, -2.5),
Tag::i(70, -7),
Tag::s(1, "second"),
Tag::new(290, Value::Bool(true)),
Tag::new(310, Value::Hex("00FF80".into())),
Tag::i(160, i64::MAX),
Tag::s(1, ""),
],
);
}
+2 -1
View File
@@ -12,7 +12,8 @@ workspace = true
cadcraft-geom = { workspace = true }
cadcraft-color = { workspace = true }
cadcraft-doc = { workspace = true }
cadcraft-dxf = { workspace = true }
craft-mime = { workspace = true }
craft-dxf = { workspace = true }
cadcraft-constraints = { workspace = true }
cadcraft-fonts = { workspace = true }
cadcraft-render = { workspace = true }
+85 -1
View File
@@ -16,10 +16,31 @@ use std::fs::{File, OpenOptions, Permissions};
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock, Weak};
/// Monotonic counter making temporary names unique within this process without a RNG dependency.
static SEQ: AtomicU64 = AtomicU64::new(0);
/// Locks held from destination metadata inspection through rename, so concurrent writes cannot
/// combine permissions from one version of a path with the group of another.
fn path_lock(path: &Path) -> Arc<Mutex<()>> {
static LOCKS: OnceLock<Mutex<std::collections::HashMap<PathBuf, Weak<Mutex<()>>>>> = OnceLock::new();
let absolute = if path.is_absolute() { path.to_path_buf() } else { std::env::current_dir().unwrap_or_default().join(path) };
let key = match (absolute.parent(), absolute.file_name()) {
(Some(parent), Some(name)) => std::fs::canonicalize(parent).unwrap_or_else(|_| parent.to_path_buf()).join(name),
_ => absolute,
};
let mut locks = LOCKS.get_or_init(|| Mutex::new(std::collections::HashMap::new())).lock().unwrap_or_else(std::sync::PoisonError::into_inner);
locks.retain(|_, lock| lock.strong_count() > 0);
if let Some(lock) = locks.get(&key).and_then(Weak::upgrade) {
lock
} else {
let lock = Arc::new(Mutex::new(()));
locks.insert(key, Arc::downgrade(&lock));
lock
}
}
/// How many fresh temporary names to try before giving up (each collision is another local race).
const MAX_TRIES: u32 = 32;
@@ -33,13 +54,15 @@ pub fn write_atomic(path: &Path, bytes: &[u8]) -> io::Result<()> {
// A symlinked destination is resolved so the link stays a link and its target is replaced.
let resolved = resolve_symlink(path)?;
let path = resolved.as_deref().unwrap_or(path);
let lock = path_lock(path);
let _guard = lock.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let permissions = match std::fs::symlink_metadata(path) {
Ok(meta) if meta.is_file() => Some(meta.permissions()),
Ok(_) => None,
Err(e) if e.kind() == io::ErrorKind::NotFound => None,
Err(e) => return Err(e),
};
write_atomic_with(path, permissions, |file| file.write_all(bytes))
write_atomic_with_locked(path, permissions, |file| file.write_all(bytes))
}
/// The topmost folder missing above `path`: what [`write_atomic_making_folders`] will create.
@@ -67,10 +90,30 @@ pub fn write_atomic_making_folders(path: &Path, bytes: &[u8]) -> io::Result<()>
/// with `permissions` given to it from its creation (`None`: the usual creation mode). A symlink
/// at `path` is replaced by the new file, never written through.
pub fn write_atomic_with(path: &Path, permissions: Option<Permissions>, fill: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> {
let lock = path_lock(path);
let _guard = lock.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
write_atomic_with_locked(path, permissions, fill)
}
/// [`write_atomic_with`] with permissions derived under the same destination lock as the write.
pub fn write_atomic_with_permissions(
path: &Path,
permissions: impl FnOnce() -> io::Result<Option<Permissions>>,
fill: impl FnOnce(&mut File) -> io::Result<()>,
) -> io::Result<()> {
let lock = path_lock(path);
let _guard = lock.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let permissions = permissions()?;
write_atomic_with_locked(path, permissions, fill)
}
fn write_atomic_with_locked(path: &Path, permissions: Option<Permissions>, fill: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> {
let dir = path.parent().filter(|p| !p.as_os_str().is_empty()).map_or_else(|| PathBuf::from("."), Path::to_path_buf);
let (mut file, tmp) = create_temp(&dir, permissions.as_ref())?;
let write = (|| {
if let Some(permissions) = permissions {
#[cfg(unix)]
let permissions = keep_group(&file, path, permissions);
file.set_permissions(permissions)?;
}
fill(&mut file)?;
@@ -90,6 +133,20 @@ pub fn write_atomic_with(path: &Path, permissions: Option<Permissions>, fill: im
Ok(())
}
/// `permissions` for the new file when `path` already exists: the group bits mean "this group" only
/// if the file is still in the old file's group, so the group is restored first. When it can't be
/// (the user is not a member of it), the group bits are dropped rather than handed to another group.
#[cfg(unix)]
fn keep_group(file: &File, path: &Path, permissions: Permissions) -> Permissions {
use std::os::unix::fs::{MetadataExt, PermissionsExt, fchown};
let Ok(old) = std::fs::symlink_metadata(path) else { return permissions };
// A file already in the old group needs no change (and a restrictive syscall policy may refuse a no-op fchown).
if !old.is_file() || file.metadata().is_ok_and(|m| m.gid() == old.gid()) || fchown(file, None, Some(old.gid())).is_ok() {
return permissions;
}
Permissions::from_mode(permissions.mode() & !0o070)
}
/// Flush `dir` so a rename just made in it survives a crash or power loss (POSIX records a
/// rename in the directory, not in the file). Best effort: some file systems (network shares)
/// refuse to sync a directory, and the file itself is already on disk.
@@ -231,6 +288,33 @@ mod tests {
std::fs::remove_dir_all(&dir).ok();
}
/// The replacement keeps the old file's group (when the user is in another group, as `id -G`
/// says) together with its mode, so the group bits never name a different group.
#[cfg(unix)]
#[test]
fn keeps_the_group_and_mode_of_the_file_it_replaces() {
use std::os::unix::fs::{MetadataExt, PermissionsExt, chown};
let dir = std::env::temp_dir().join(format!("cadcraft-aw-grp-{}-{}", std::process::id(), SEQ.fetch_add(1, Ordering::Relaxed)));
std::fs::create_dir_all(&dir).unwrap();
let dest = dir.join("out.bin");
std::fs::write(&dest, b"old").unwrap();
std::fs::set_permissions(&dest, Permissions::from_mode(0o640)).unwrap();
let own = std::fs::metadata(&dest).unwrap().gid();
let other = std::process::Command::new("id")
.arg("-G")
.output()
.ok()
.and_then(|o| String::from_utf8_lossy(&o.stdout).split_whitespace().filter_map(|g| g.parse::<u32>().ok()).find(|g| *g != own));
if let Some(gid) = other {
chown(&dest, None, Some(gid)).unwrap();
}
let want = std::fs::metadata(&dest).unwrap();
write_atomic(&dest, b"new").unwrap();
let got = std::fs::metadata(&dest).unwrap();
assert_eq!((got.gid(), got.mode() & 0o777), (want.gid(), 0o640));
std::fs::remove_dir_all(&dir).ok();
}
#[cfg(unix)]
#[test]
fn does_not_follow_a_planted_temp_symlink() {
+9 -12
View File
@@ -144,10 +144,10 @@ impl BlockEdit {
}
let host = &self.host.doc;
let mut d = editor.clone();
// When the block is saved under another name, the edited block keeps the drawing's
// description and block `name` gets the description changed in the editor.
// When saving a copy, the source keeps its last saved definition. The editor's own
// table entry can still be the one from before BSAVE; the copy gets the edited data.
if !name.eq_ignore_ascii_case(&self.name) {
keep_description(&mut d, host, &self.name);
restore_saved_definition(&mut d, host, &self.name);
}
d.model = host.model.clone();
d.layouts = host.layouts.clone();
@@ -176,16 +176,13 @@ impl BlockEdit {
}
}
/// Give block `name` of `d` the description `host` has for it, or, when `host` has no such block,
/// drop the empty definition a description gives a block the editor started and never saved.
fn keep_description(d: &mut Drawing, host: &Drawing, name: &str) {
/// Keep the source block's saved objects and metadata when the edited objects are saved as a copy.
/// Without a saved source, drop the empty definition an editor description may have created.
fn restore_saved_definition(d: &mut Drawing, host: &Drawing, name: &str) {
match host.block(name) {
Some(h) => {
if let Some((_, b)) = d.blocks.iter_mut().find(|(k, _)| k.eq_ignore_ascii_case(name))
&& b.description != h.description
{
Arc::make_mut(b).description = h.description.clone();
}
let key = d.blocks.keys().find(|key| key.eq_ignore_ascii_case(name)).cloned().unwrap_or_else(|| h.name.clone());
d.blocks.insert(key, h.clone());
}
None => d.blocks.retain(|k, b| !(k.eq_ignore_ascii_case(name) && b.entities.is_empty())),
}
@@ -302,7 +299,7 @@ impl DocState {
let was = be.name.clone();
let reconcile = |doc: &mut Arc<Drawing>| {
let editor = Arc::make_mut(doc);
keep_description(editor, &d, &was);
restore_saved_definition(editor, &d, &was);
editor.blocks.retain(|k, _| !k.eq_ignore_ascii_case(&name));
editor.blocks.insert(name.clone(), b.clone());
};
+8
View File
@@ -8,6 +8,8 @@ mod audit;
pub(crate) mod blocks;
pub mod clipboard;
pub mod constraints;
mod dimstyle_cli;
mod dimstyles;
mod draw;
mod draw2;
mod draworder;
@@ -34,6 +36,8 @@ mod overkill;
mod pline_opts;
pub mod plotters;
mod props;
pub use blocks::library::{clear_library_cache, list_library, read_library_file};
pub use dimstyle_cli::usable_dim_style_name;
pub use draw2::breakline::BreaklineOptions;
pub use props::MatchProps;
pub(crate) use props::UNIT_RANGES;
@@ -47,6 +51,7 @@ mod tolerance;
mod trimextend;
mod txt2mtxt;
pub use txt2mtxt::Txt2MtxtOptions;
mod ucs;
mod utility;
mod view;
@@ -183,9 +188,12 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(qselect::specs());
v.extend(selecttools::specs());
v.extend(view::specs());
v.extend(ucs::specs());
v.extend(draw::specs());
v.extend(draw2::specs());
v.extend(annotate::specs());
v.extend(dimstyles::specs());
v.extend(dimstyle_cli::specs());
v.extend(mleader_edit::specs());
v.extend(annoscale::specs());
v.extend(hatch::specs());
+9 -2
View File
@@ -35,8 +35,15 @@ fn auto_rotation(p1: Vec2, p2: Vec2, at: Vec2) -> f64 {
if outside_x && !outside_y { std::f64::consts::FRAC_PI_2 } else { 0.0 }
}
pub(super) fn linear_kind(p1: Vec2, p2: Vec2, at: Vec2, rotation: Option<f64>, aligned: bool) -> DimKind {
if aligned { DimKind::Aligned } else { DimKind::Linear { rotation: rotation.unwrap_or_else(|| auto_rotation(p1, p2, at)) } }
/// A linear or aligned dimension's kind; without a rotation, horizontal or vertical along axes turned
/// `ucs` radians (the current UCS's at the command line; the world's for JSON).
pub(super) fn linear_kind(p1: Vec2, p2: Vec2, at: Vec2, rotation: Option<f64>, aligned: bool, ucs: f64) -> DimKind {
if aligned {
return DimKind::Aligned;
}
let ucs = if ucs.is_finite() { ucs } else { 0.0 };
let auto = || auto_rotation(p1.rotate(-ucs), p2.rotate(-ucs), at.rotate(-ucs)) + ucs;
DimKind::Linear { rotation: rotation.unwrap_or_else(auto) }
}
/// Add a dimension. With DIMASSOC on, definition points that sit on object endpoints,
+14 -5
View File
@@ -11,7 +11,7 @@ pub(super) fn run_linear(s: &mut Session, p: &Value) -> Result<Value> {
};
let at = point_req("dimlinear", p, "at")?;
let rot = p.get("rotation").and_then(Value::as_f64).map(f64::to_radians);
let k = dim(s, linear_kind(a, b, at, rot, false), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
let k = dim(s, linear_kind(a, b, at, rot, false, 0.0), at, a, b, Vec2::ZERO, str_param(p, "text").unwrap_or(""));
Ok(json!({ "handle": add_dim(s, k)?.hex() }))
}
@@ -216,7 +216,8 @@ impl Interactive for LinearM {
}
(_, Input::Point(at)) => {
let (Some(&a), Some(&b)) = (self.pts.first(), self.pts.get(1)) else { return Ok(Step::Continue) };
let k = self.text.apply(dim(s, linear_kind(a, b, at, self.rotation, self.aligned), at, a, b, Vec2::ZERO, ""));
let k =
self.text.apply(dim(s, linear_kind(a, b, at, self.rotation, self.aligned, s.input_ucs().rotation()), at, a, b, Vec2::ZERO, ""));
add_dim(s, k)?;
if let Some(EntityKind::Dimension(d)) = s.last_dim.and_then(|h| s.doc().ok()?.entity(h).map(|e| e.kind.clone())) {
let st = s.doc()?.dim_style(&d.style).cloned().unwrap_or_default();
@@ -227,8 +228,8 @@ impl Interactive for LinearM {
}
(_, Input::Keyword(k)) => {
match k.as_str() {
"Horizontal" => self.rotation = Some(0.0),
"Vertical" => self.rotation = Some(std::f64::consts::FRAC_PI_2),
"Horizontal" => self.rotation = Some(s.input_ucs().rotation()),
"Vertical" => self.rotation = Some(s.input_ucs().rotation() + std::f64::consts::FRAC_PI_2),
"Rotated" => self.rotating = true,
other => {
self.text.keyword(other);
@@ -243,7 +244,15 @@ impl Interactive for LinearM {
fn preview(&self, s: &Session, c: Vec2) -> Vec<EntityKind> {
match self.pts.as_slice() {
[a] => vec![crate::cmd::helpers::line(*a, c)],
[a, b] => vec![self.text.apply(dim(s, linear_kind(*a, *b, c, self.rotation, self.aligned), c, *a, *b, Vec2::ZERO, ""))],
[a, b] => vec![self.text.apply(dim(
s,
linear_kind(*a, *b, c, self.rotation, self.aligned, s.input_ucs().rotation()),
c,
*a,
*b,
Vec2::ZERO,
"",
))],
_ => Vec::new(),
}
}
+24 -2
View File
@@ -178,14 +178,34 @@ fn create(s: &mut Session, objs: &[Handle], base: Vec2, p: ArrayParams, assoc: b
Ok(json!({ "created": n }))
}
/// The most objects EXPLODE of one associative array makes from its source objects (ten times the
/// default MAXARRAY).
const MAX_EXPLODED_OBJECTS: usize = 1_000_000;
/// EXPLODE of an associative array: every item becomes the objects of its block (the source
/// objects, or a replacement block's reference), in world coordinates. `None` for other objects.
///
/// An array that would explode into more than [`MAX_EXPLODED_OBJECTS`] objects (items times the
/// objects of the source block, which a file sets freely) is not expanded here: `None`, so EXPLODE
/// takes the array block's own items.
pub(crate) fn explode_array(d: &Drawing, e: &Entity) -> Option<Vec<Entity>> {
let EntityKind::Insert(ins) = &e.kind else { return None };
let p = d.array_params(e)?;
let blk = d.block(&ins.block)?;
let m = ins.transform(blk.base.xy());
let mut out = Vec::new();
// Count first: a hostile array must be refused before any entity is cloned.
let total = blk
.entities
.iter()
.map(|it| match &it.kind {
EntityKind::Insert(i) if i.block.eq_ignore_ascii_case(&p.source) => d.block(&i.block).map_or(1, |b| b.entities.len()),
_ => 1,
})
.fold(0usize, usize::saturating_add);
if total > MAX_EXPLODED_OBJECTS {
return None;
}
let mut out = Vec::with_capacity(total);
for item in blk.entities.iter() {
let item = placed(e, item, &m);
let source = match &item.kind {
@@ -193,7 +213,9 @@ pub(crate) fn explode_array(d: &Drawing, e: &Entity) -> Option<Vec<Entity>> {
_ => None,
};
match source {
Some((im, b)) => out.extend(b.entities.iter().map(|se| placed(&item, se, &im))),
Some((im, b)) => {
out.extend(b.entities.iter().map(|se| placed(&item, se, &im)));
}
None => out.push(item),
}
}
+2 -1
View File
@@ -188,8 +188,9 @@ fn item_at(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Option<(u32, u32, u32)
let mut best: Option<((u32, u32, u32), f64)> = None;
// Each block's own extents, measured once.
let mut extents: HashMap<String, (Vec2, Bounds2)> = HashMap::new();
let block_for = p.block_lookup();
for it in p.items()? {
let name = p.block_for(it.i, it.j, it.level);
let name = block_for(it.i, it.j, it.level);
let (base, local) = match extents.get(name) {
Some(x) => *x,
None => {
+1 -1
View File
@@ -157,7 +157,7 @@ fn write_audit_log(_: &Session, _: &crate::audit::Report) {}
#[cfg(not(target_arch = "wasm32"))]
fn read_path(cmd: &str, path: &str) -> Result<Vec<u8>> {
std::fs::read(path).map_err(|e| bad(cmd, format!("{path}: {e}")))
crate::capped_read::read_capped(std::path::Path::new(path), file::MAX_DRAWING_BYTES).map_err(|e| bad(cmd, format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+129 -11
View File
@@ -44,13 +44,17 @@ pub fn specs() -> Vec<CommandSpec> {
.alias(&["i", "-insert", "ddinsert"])
.params("{name (\"*NAME\": exploded), file?: DXF/DWG path (defines or redefines block `name`, default the file name, from its model space; base point $INSBASE), at: [x,y], scale?: number | [x, y], rotation? (degrees), basePoint?: [x,y] (block coordinates), attribs?: {TAG: value}, explode?: bool}")
.interactive(|_| Ok(Box::new(InsertM::default()))),
CommandSpec::new("blockspalette", "Blocks Palette", run_blockspalette)
.params("{references?: bool (default true; counting reads every object)} → {blocks: [{name, description, references?}], truncated} (the app opens the Blocks palette instead)")
.enabled(has_doc)
.noundo(),
CommandSpec::new("minsert", "Multiple Insert", run_minsert)
.params("{name, file?: DXF/DWG path (as INSERT), at: [x,y], scale?: number | [x, y], rotation? (degrees), basePoint?: [x,y], attribs?: {TAG: value}, rows?: 1..32767 (default 1), columns?: 1..32767 (default 1), rowSpacing?, columnSpacing? (along the reference's own axes, not scaled with it)}")
.interactive(|_| Ok(Box::new(InsertM { minsert: true, ..InsertM::default() }))),
CommandSpec::new("attdef", "Define Attributes...", run_attdef)
.menu(&["Draw", "Block", "Define Attributes..."])
.alias(&["att", "-attdef"])
.params("{tag, prompt?, default?, at, height?, invisible?}")
.params("{tag, prompt?, default?, at, height?, invisible?, justify?: L|C|R|M|TL|TC|TR|ML|MC|MR|BL|BC|BR, style? (default the current text style)}")
.interactive(|_| Ok(Box::new(attdef::AttdefM::default()))),
attedit::attedit_spec(),
attedit::dash_attedit_spec(),
@@ -92,6 +96,7 @@ pub fn specs() -> Vec<CommandSpec> {
.into_iter()
.chain(attribs::attdisp_menu_specs())
.chain(xref::specs())
.chain(library::specs())
.chain(refedit::specs())
.chain(xclip::specs())
.chain(bedit::specs())
@@ -113,6 +118,15 @@ fn referenced_block(e: &Entity) -> Option<String> {
}
}
/// The attributes an object carries: a block reference's, or those of a multileader's block content.
pub(crate) fn object_attribs(e: &Entity) -> &[Attrib] {
match &e.kind {
EntityKind::Insert(i) => &i.attribs,
EntityKind::MLeader(m) => m.block.as_ref().map_or(&[][..], |b| b.attribs.as_slice()),
_ => &[],
}
}
/// Whether any of `ents` refers to block `name`, directly or through nested block references,
/// dimension blocks and multileader block content.
pub(crate) fn references_block(d: &cadcraft_doc::Drawing, ents: &[Entity], name: &str) -> bool {
@@ -346,6 +360,40 @@ fn run_block(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "block": name, "insert": r.map(|h| h.hex()) }))
}
/// BLOCKSPALETTE as a JSON call: the drawing's own blocks (no anonymous, layout or xref blocks)
/// with their descriptions and how many objects draw each (block references, dimensions and
/// multileader block content). The app opens the palette instead.
fn run_blockspalette(s: &mut Session, p: &Value) -> Result<Value> {
let d = s.doc()?;
let counting = bool_or(p, "references", true);
let mut counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
if counting {
let mut count = |store: &cadcraft_doc::EntityStore| {
for e in store.iter() {
if let Some(block) = referenced_block(e) {
let n = counts.entry(block.to_ascii_lowercase()).or_insert(0);
*n = n.saturating_add(1);
}
}
};
count(&d.model);
d.layouts.iter().for_each(|l| count(&l.entities));
d.blocks.values().for_each(|b| count(&b.entities));
}
let (blocks, truncated) = library::library_blocks(d);
let list: Vec<Value> = blocks
.iter()
.map(|b| {
let mut block = json!({ "name": b.name, "description": b.description });
if counting {
block["references"] = json!(counts.get(&b.name.to_ascii_lowercase()).copied().unwrap_or(0));
}
block
})
.collect();
Ok(json!({ "blocks": list, "truncated": truncated }))
}
fn run_insert(s: &mut Session, p: &Value) -> Result<Value> {
insert_json(s, p, "insert", Grid::ONE)
}
@@ -400,21 +448,79 @@ fn insert_json(s: &mut Session, p: &Value, cmd: &str, grid: Grid) -> Result<Valu
Ok(attedit::with_unknown_tags(s, h, &vals, json!({ "handle": h.hex() })))
}
fn attdef_kind(s: &Session, tag: &str, prompt: &str, default: &str, at: Vec2, height: f64, invisible: bool) -> EntityKind {
let style = s.doc().map(|d| d.header.str("TEXTSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into());
/// The current text style (TEXTSTYLE).
fn current_text_style(s: &Session) -> String {
s.doc().map(|d| d.header.str("TEXTSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into())
}
/// A text style's name as the table spells it, with the width factor and oblique angle an
/// attribute definition takes from it (the renderer uses the entity's own values). `None` when
/// the drawing has no such style.
fn style_values(s: &Session, name: &str) -> Result<Option<(String, f64, f64)>> {
Ok(s.doc()?.text_style(name).map(|t| (t.name.clone(), t.width_factor, t.oblique)))
}
/// The current text style (TEXTSTYLE) with its width factor and oblique angle.
fn current_style_values(s: &Session) -> (String, f64, f64) {
let name = current_text_style(s);
style_values(s, &name).ok().flatten().unwrap_or((name, 1.0, 0.0))
}
/// A justification code as `-ATTDEF` takes it, typed or in `justify`. Align and Fit run between
/// two baseline points; `attdef` has one, so it can't express them.
fn attdef_justify(code: &str) -> Result<(HAlign, VAlign)> {
let j = super::draw::justify(code.trim()).ok_or_else(|| bad("attdef", "unknown justification"))?;
if matches!(j.0, HAlign::Aligned | HAlign::Fit) {
return Err(bad("attdef", "Align and Fit need two points, which attdef doesn't take yet; use L, C, R, M or TL … BR"));
}
Ok(j)
}
/// The named text style with its width factor and oblique angle, or the error both the JSON form
/// and the typed `Style` option give for a style the drawing doesn't have.
fn resolve_style(s: &Session, name: &str) -> Result<(String, f64, f64)> {
style_values(s, name)?.ok_or_else(|| bad("attdef", format!("no text style \"{name}\"")))
}
/// An optional string parameter: absent or null is `None`, a string is `Some`, anything else is
/// an error rather than being ignored.
fn opt_str_param<'a>(cmd: &str, p: &'a Value, key: &str) -> Result<Option<&'a str>> {
match p.get(key) {
None | Some(Value::Null) => Ok(None),
Some(Value::String(v)) => Ok(Some(v)),
Some(v) => Err(bad(cmd, format!("`{key}` must be a string, got {v}"))),
}
}
/// An attribute definition at `at` with justification `j` (as TEXT: any but Left keeps `at` as
/// its alignment point) in text style `style`.
#[allow(clippy::too_many_arguments)]
fn attdef_kind(
tag: &str,
prompt: &str,
default: &str,
at: Vec2,
height: f64,
invisible: bool,
j: (HAlign, VAlign),
style: (String, f64, f64),
) -> EntityKind {
let (halign, valign) = j;
let (style, width_factor, oblique) = style;
let left = halign == HAlign::Left && valign == VAlign::Baseline;
EntityKind::AttDef(Attrib {
tag: tag.to_ascii_uppercase(),
text: Text {
insert: v3(at),
align_pt: None,
align_pt: if left { None } else { Some(v3(at)) },
height,
value: default.into(),
rotation: 0.0,
width_factor: 1.0,
oblique: 0.0,
width_factor,
oblique,
style,
halign: HAlign::Left,
valign: VAlign::Baseline,
halign,
valign,
},
invisible,
constant: false,
@@ -432,7 +538,14 @@ fn run_attdef(s: &mut Session, p: &Value) -> Result<Value> {
}
let at = point_req("attdef", p, "at")?;
let h = f64_or(p, "height", s.doc()?.header.f64("TEXTSIZE", 0.2));
let k = attdef_kind(s, tag, str_param(p, "prompt").unwrap_or(tag), str_param(p, "default").unwrap_or(""), at, h, bool_or(p, "invisible", false));
// Justification and text style as TEXT and MTEXT take them (#1658).
let j = attdef_justify(opt_str_param("attdef", p, "justify")?.unwrap_or("L"))?;
let style = match opt_str_param("attdef", p, "style")? {
Some(n) => resolve_style(s, n)?,
None => current_style_values(s),
};
let (prompt, default) = (str_param(p, "prompt").unwrap_or(tag), str_param(p, "default").unwrap_or(""));
let k = attdef_kind(tag, prompt, default, at, h, bool_or(p, "invisible", false), j, style);
Ok(json!({ "handle": s.add_entity(k)?.hex() }))
}
@@ -601,6 +714,7 @@ impl BlockM {
}
mod insert_file;
pub(crate) mod library;
pub(crate) mod xref;
/// Where the command-line INSERT is in its prompt sequence.
@@ -705,6 +819,9 @@ impl InsertM {
if self.explode {
insert_file::explode_insert(s, h)?;
}
// Written here, not when the name is given: a cancelled INSERT leaves the drawing as
// it was, so it takes no undo step that would undo nothing visible.
s.doc_mut()?.header.set_str("INSNAME", &n);
return Ok(Step::Done);
}
Ok(Step::Continue)
@@ -760,13 +877,14 @@ impl InsertM {
})
.collect()
};
s.doc_mut()?.header.set_str("INSNAME", &b.name);
self.name = Some(b.name.clone());
self.stage = InsStage::Point;
Ok(())
}
/// Define the block from a file, then choose it; a file that can't be read is reported.
/// Define the block from a file, then choose it; a file that can't be read is reported. The
/// definition comes before the insertion point and stays when INSERT is then cancelled, as in
/// AutoCAD 2027.
fn choose_file(&mut self, s: &mut Session, f: &insert_file::FileRef) -> Result<()> {
match f.define(s) {
Ok(name) => self.choose(s, &name),
+5 -4
View File
@@ -103,6 +103,7 @@ impl AttdefM {
fn finish(&mut self, s: &mut Session, rotation: f64) -> Result<Step> {
let (h, v) = self.justify;
let left = h == HAlign::Left && v == VAlign::Baseline;
let (style, width_factor, oblique) = super::resolve_style(s, &self.style)?;
s.add_entity(EntityKind::AttDef(Attrib {
tag: self.tag.to_uppercase(),
text: Text {
@@ -111,9 +112,9 @@ impl AttdefM {
height: self.height,
value: std::mem::take(&mut self.value),
rotation,
width_factor: 1.0,
oblique: 0.0,
style: self.style.clone(),
width_factor,
oblique,
style,
halign: h,
valign: v,
},
@@ -156,7 +157,7 @@ impl Interactive for AttdefM {
Prompt::new(self.point_prompt(), Accept::POINT).kw(&["Justify", "Style"])
}
Ask::Point => Prompt::new(self.point_prompt(), Accept::POINT),
Ask::Justify => Prompt::new("Enter an option", Accept::TEXT).kw(&JUSTIFY),
Ask::Justify => crate::cmd::draw::justify_prompt(false),
Ask::Style => Prompt::new("Enter style name", Accept::TEXT).kw(&["?"]).default(self.style.clone()),
Ask::Height => {
let th = s.doc().map(|d| d.header.f64("TEXTSIZE", 0.2)).unwrap_or(0.2);
+5 -3
View File
@@ -15,7 +15,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
pub(super) fn blockreplace_spec() -> CommandSpec {
CommandSpec::new("blockreplace", "Replace Block...", run_blockreplace)
.menu(&["Tools", "Express Tools", "Replace Block..."])
.menu(&["Tools", "Additional Tools", "Replace Block..."])
.alias(&["-blockreplace"])
.params("{block (the block whose references are replaced), with (the replacement block), purge?: bool (default false: remove the replaced block's definition when nothing references it any more)} → {block, with, replaced, purged}")
.interactive(|_| Ok(Box::new(BlockreplaceM::default())))
@@ -184,8 +184,10 @@ impl Interactive for BlockreplaceM {
}
fn prompt(&self, _s: &Session) -> Prompt {
match self.stage {
Stage::Old => Prompt::new("Enter the name of the block to replace", Accept::TEXT).kw(&["?", "Select"]),
Stage::New => Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]),
Stage::Old => Prompt::new("Enter the name of the block to replace", Accept::TEXT).kw(&["?", "Select"]).takes_block(),
Stage::New => {
Prompt::new(format!("Enter the name of the replacement block for {}", self.old), Accept::TEXT).kw(&["?", "Select"]).takes_block()
}
Stage::Select => Prompt::new("Select a block reference", Accept::SELECT),
Stage::Purge => Prompt::new(format!("Purge the unreferenced block definition {}?", self.old), KW).kw(&["Yes", "No"]).default("Yes"),
}
+1 -1
View File
@@ -12,7 +12,7 @@ use crate::{Result, Session};
pub(super) fn burst_spec() -> CommandSpec {
CommandSpec::new("burst", "Explode Attributes to Text", run_burst)
.menu(&["Tools", "Express Tools", "Explode Attributes to Text"])
.menu(&["Tools", "Additional Tools", "Explode Attributes to Text"])
.params("{handles?} (block references; other objects are left alone) → {handles}")
.interactive(|_| Ok(Box::new(SelectRun::new("burst", "BURST"))))
}
+75 -15
View File
@@ -2,9 +2,9 @@
//! block name and values, or one row per reference with its handle, layer, position and
//! rotation — returned, written to a CSV file and/or inserted as a table. Tags match in any case.
use std::collections::BTreeMap;
use std::collections::{BTreeMap, HashMap};
use cadcraft_doc::{EntityKind, Insert};
use cadcraft_doc::{Drawing, EntityKind, Insert};
use cadcraft_geom::Vec2;
use serde_json::{Value, json};
@@ -88,22 +88,75 @@ fn matches(spec: &str, text: &str) -> bool {
spec.split(',').any(|p| wildcard(p.trim(), text))
}
/// The attribute values of `ins`: its own, then the constant ones of its block.
fn values(d: &cadcraft_doc::Drawing, ins: &Insert) -> Vec<(String, String)> {
let mut v: Vec<(String, String)> = ins.attribs.iter().map(|a| (a.tag.to_ascii_uppercase(), a.text.value.clone())).collect();
if let Some(b) = d.block(&ins.block) {
for e in b.entities.iter() {
if let EntityKind::AttDef(a) = &e.kind
&& a.constant
&& !v.iter().any(|(t, _)| t.eq_ignore_ascii_case(&a.tag))
{
v.push((a.tag.to_ascii_uppercase(), a.text.value.clone()));
}
/// The constant attribute values of a block definition whose tags are selected for output.
fn constants(b: &cadcraft_doc::Block, selected: &[String]) -> Vec<(String, String)> {
let mut v: Vec<(String, String)> = Vec::new();
for e in b.entities.iter() {
if let EntityKind::AttDef(a) = &e.kind
&& a.constant
&& selected.iter().any(|tag| tag == &a.tag.to_ascii_uppercase())
&& !v.iter().any(|(t, _)| t.eq_ignore_ascii_case(&a.tag))
{
v.push((a.tag.to_ascii_uppercase(), a.text.value.clone()));
}
}
v
}
/// The attribute values of `ins` that `o.tags` selects: its own, then the constant ones of its
/// block (`consts`, read once per block). Values no column shows are not copied.
fn values(ins: &Insert, consts: &[(String, String)], selected: &[String]) -> Vec<(String, String)> {
let mut v: Vec<(String, String)> = ins
.attribs
.iter()
.map(|a| (a.tag.to_ascii_uppercase(), a))
.filter(|(t, _)| selected.contains(t))
.map(|(t, a)| (t, a.text.value.clone()))
.collect();
for (t, val) in consts {
if !v.iter().any(|(k, _)| k.eq_ignore_ascii_case(t)) {
v.push((t.clone(), val.clone()));
}
}
v
}
/// Select the output columns before copying any attribute text. A block definition can contain
/// many large constants that do not survive the table's 190-column limit.
fn selected_tags(ents: &[std::sync::Arc<cadcraft_doc::Entity>], d: &Drawing, o: &Options) -> Vec<String> {
let mut selected = Vec::new();
let mut add = |tag: &str| {
let tag = tag.to_ascii_uppercase();
if selected.len() < MAX_TAGS && matches(&o.tags, &tag) && !selected.contains(&tag) {
selected.push(tag);
}
};
let mut scanned = std::collections::HashSet::new();
for entity in ents {
let EntityKind::Insert(ins) = &entity.kind else { continue };
let anonymous = ins.block.starts_with('*') || d.block(&ins.block).is_some_and(|b| b.anonymous);
if anonymous || !matches(&o.blocks, &ins.block) {
continue;
}
for attribute in &ins.attribs {
add(&attribute.tag);
}
// A block's constants are read once, however many inserts reference it.
if scanned.insert(ins.block.as_str())
&& let Some(block) = d.block(&ins.block)
{
for entity in block.entities.iter() {
if let EntityKind::AttDef(attribute) = &entity.kind
&& attribute.constant
{
add(&attribute.tag);
}
}
}
}
selected
}
/// The block references to extract from: `handles` when given, else model space and the layouts.
fn found(s: &Session, p: &Value, o: &Options) -> Result<Vec<Found>> {
let d = s.doc()?;
@@ -112,7 +165,9 @@ fn found(s: &Session, p: &Value, o: &Options) -> Result<Vec<Found>> {
} else {
d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).cloned().collect()
};
let selected = selected_tags(&ents, d, o);
let mut out = Vec::new();
let mut consts: HashMap<String, Vec<(String, String)>> = HashMap::new();
for e in &ents {
let EntityKind::Insert(ins) = &e.kind else { continue };
let anonymous = ins.block.starts_with('*') || d.block(&ins.block).is_some_and(|b| b.anonymous);
@@ -121,12 +176,17 @@ fn found(s: &Session, p: &Value, o: &Options) -> Result<Vec<Found>> {
}
let block = d.block(&ins.block).map(|b| b.name.clone()).unwrap_or_else(|| ins.block.clone());
out.push(Found {
block,
handle: e.handle.hex(),
layer: e.common.layer.clone(),
at: ins.insert.xy(),
rotation: ins.rotation.to_degrees(),
values: values(d, ins),
block: block.clone(),
values: values(
ins,
// Keyed by the resolved definition's exact name: `Part` and `PART` can both exist.
consts.entry(block.clone()).or_insert_with(|| d.block(&ins.block).map(|b| constants(b, &selected)).unwrap_or_default()),
&selected,
),
});
}
Ok(out)
+478 -12
View File
@@ -6,7 +6,7 @@
//! (names this drawing already has keep this drawing's definitions). The file is read through the
//! host's io hooks like OPEN, so the engine stays I/O-agnostic.
use std::collections::BTreeMap;
use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;
use cadcraft_doc::{Block, Drawing, Entity, EntityKind, Handle};
@@ -14,7 +14,8 @@ use serde_json::{Value, json};
use super::super::file::io;
use super::super::modify::explode_kind;
use super::{references_block, valid_block_name};
use super::purge::{Kind, candidates, is_arrow_override, override_arrows, override_name, scan_reads_everything};
use super::{referenced_block, references_block, valid_block_name};
use crate::cmd::{bad, str_param};
use crate::{EngineError, Result, Session};
@@ -37,7 +38,7 @@ impl FileRef {
/// Read the file and (re)define its block. Returns the block's name.
pub fn define(&self, s: &mut Session) -> Result<String> {
let src = read_drawing(&self.path)?;
define_from(s, &src, &self.name)
define_from(s, &src, &self.name, false)
}
}
@@ -45,6 +46,11 @@ impl FileRef {
/// path (it has a folder separator or a .dwg/.dxf extension) that isn't the name of a block.
pub(super) fn file_ref(s: &Session, t: &str) -> Option<FileRef> {
let t = t.trim();
// A block of this drawing is that block, whatever its name looks like: a name read from a file
// must not pass for `name=path` and make INSERT read another file (CWE-74).
if s.doc().is_ok_and(|d| d.block(t).is_some()) {
return None;
}
if let Some((name, path)) = t.split_once('=') {
let name = name.trim();
let path = if path.trim().is_empty() { name } else { path.trim() };
@@ -52,7 +58,7 @@ pub(super) fn file_ref(s: &Session, t: &str) -> Option<FileRef> {
}
let lower = t.to_ascii_lowercase();
let pathlike = t.contains(['/', '\\']) || lower.ends_with(".dwg") || lower.ends_with(".dxf");
if !pathlike || s.doc().is_ok_and(|d| d.block(t).is_some()) {
if !pathlike {
return None;
}
Some(FileRef { name: stem(t), path: t.to_string(), explicit: false })
@@ -68,7 +74,7 @@ pub(super) fn stem(path: &str) -> String {
}
/// Read a drawing file through the io hooks; a path without extension tries .dwg, then .dxf.
fn read_drawing(path: &str) -> Result<Drawing> {
pub(super) fn read_drawing(path: &str) -> Result<Drawing> {
let hooks = io().ok_or_else(|| bad("insert", "file formats are not available in this build"))?;
let has_ext = stem(path) != path.rsplit(['/', '\\']).next().unwrap_or(path);
let candidates = if has_ext { vec![path.to_string()] } else { vec![path.to_string(), format!("{path}.dwg"), format!("{path}.dxf")] };
@@ -85,25 +91,37 @@ fn read_drawing(path: &str) -> Result<Drawing> {
fn read_file(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
std::fs::read(_path).map_err(|e| bad("insert", format!("{_path}: {e}")))
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
.map_err(|e| bad("insert", format!("{_path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
Err(bad("insert", "paths are not available on the web"))
}
/// (Re)define block `name` from `src`'s model space with base point `$INSBASE`, adding the
/// layers, linetypes, styles and blocks of `src` this drawing doesn't have. Nothing changes when
/// the definition fails (an invalid name, or a block that would contain itself).
fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
/// layers, linetypes, styles and blocks of `src` this drawing doesn't have. With `only_needed`
/// the layers, linetypes and styles that nothing uses are left out again, as when a block is
/// taken from a library drawing: only what the block needs comes along. Nothing changes when the
/// definition fails (an invalid name, or a block that would contain itself).
pub(super) fn define_from(s: &mut Session, src: &Drawing, name: &str, only_needed: bool) -> Result<String> {
if !valid_block_name(name) {
return Err(bad("insert", format!("\"{name}\" is not a valid block name")));
}
let mut d = s.doc()?.clone();
let before = TableNames::of(&d);
// Redefining keeps the existing definition's name (block names are case-insensitive).
let name = d.blocks.keys().find(|k| k.eq_ignore_ascii_case(name)).cloned().unwrap_or_else(|| name.to_string());
let own_dim_styles = names_of(&d, Kind::Dimstyles);
merge_tables(&mut d, src);
let renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
for (from, to) in &renames {
let mut renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
if only_needed {
// The other blocks of the file are not copied at all.
let need = needed_blocks(src);
renames.retain(|from, _| need.contains(&from.to_ascii_uppercase()));
}
let renames = Renames::new(renames);
rename_style_arrows(&mut d, &own_dim_styles, &renames);
for (from, to) in &renames.exact {
let Some(b) = src.blocks.get(from) else { continue };
let mut nb = (**b).clone();
nb.name = to.clone();
@@ -129,10 +147,129 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
b.entities.push(e);
}
d.blocks.insert(name.clone(), Arc::new(b));
if only_needed {
drop_unused_new(&mut d, &before, &name);
}
*s.doc_mut()? = d;
Ok(name)
}
/// The tables a drawing merge adds to, in an order where removing the unused entries of one
/// frees the next (blocks free layers, layers free linetypes, dimension styles free text styles).
const MERGED: [Kind; 8] =
[Kind::Blocks, Kind::Dimstyles, Kind::MleaderStyles, Kind::MlineStyles, Kind::TableStyles, Kind::Layers, Kind::Linetypes, Kind::TextStyles];
/// The names (lower case) in one of those tables.
fn names_of(d: &Drawing, kind: Kind) -> BTreeSet<String> {
let lower = |it: &mut dyn Iterator<Item = &String>| it.map(|n| n.to_ascii_lowercase()).collect::<BTreeSet<String>>();
match kind {
Kind::Blocks => lower(&mut d.blocks.keys()),
Kind::Dimstyles => lower(&mut d.dim_styles.iter().map(|t| &t.name)),
Kind::MleaderStyles => lower(&mut d.mleader_styles.iter().map(|t| &t.name)),
Kind::MlineStyles => lower(&mut d.mline_styles.iter().map(|t| &t.name)),
Kind::TableStyles => lower(&mut d.table_styles.iter().map(|t| &t.name)),
Kind::Layers => lower(&mut d.layers.iter().map(|t| &t.name)),
Kind::Linetypes => lower(&mut d.linetypes.iter().map(|t| &t.name)),
Kind::TextStyles => lower(&mut d.text_styles.iter().map(|t| &t.name)),
_ => BTreeSet::new(),
}
}
/// The names in the merged tables, by kind.
struct TableNames(Vec<(Kind, BTreeSet<String>)>);
impl TableNames {
fn of(d: &Drawing) -> Self {
TableNames(MERGED.iter().map(|k| (*k, names_of(d, *k))).collect())
}
}
/// Upper-case names of the blocks `roots` and every block they need, through nested references,
/// dimension blocks, multileader block content and dimension arrowheads.
fn reachable(d: &Drawing, roots: Vec<String>) -> BTreeSet<String> {
let mut seen = BTreeSet::new();
let mut todo = roots;
// Each block is walked once, so this ends, cycles included.
while let Some(n) = todo.pop() {
if !seen.insert(n.to_ascii_uppercase()) {
continue;
}
let Some(b) = d.block(&n) else { continue };
for e in b.entities.iter() {
todo.extend(referenced_block(e));
if let EntityKind::Dimension(dm) = &e.kind {
todo.extend(override_arrows(dm));
}
}
}
seen
}
/// Upper-case names of the blocks the model space of `src` needs: the ones it refers to, what
/// those need, and the arrowheads of its dimension styles.
fn needed_blocks(src: &Drawing) -> BTreeSet<String> {
let mut roots: Vec<String> = Vec::new();
for e in src.model.iter() {
roots.extend(referenced_block(e));
if let EntityKind::Dimension(dm) = &e.kind {
roots.extend(override_arrows(dm));
}
}
for st in &src.dim_styles {
let arrows = [&st.arrow_block, &st.arrow_block1, &st.arrow_block2, &st.leader_arrow_block];
roots.extend(arrows.into_iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()));
}
reachable(src, roots)
}
/// Remove the blocks, layers, linetypes and styles that were not in the drawing `before` and that
/// nothing uses (PURGE's scan), in an order where removing one frees the next. `keep` is the
/// block just defined: nothing refers to it yet, so it and the blocks it needs stay. Nothing goes
/// from a drawing too big for that scan: an unused entry stays, but a used one would be lost.
fn drop_unused_new(d: &mut Drawing, before: &TableNames, keep: &str) {
if !scan_reads_everything(d) {
return;
}
// Removing a dimension style frees its arrowhead block, which an earlier table already
// scanned: scan again until a pass removes nothing (a chain is never longer than the tables).
for _ in 0..MERGED.len() {
if !drop_unused_pass(d, before, keep) {
break;
}
}
}
/// One scan of the merged tables; `true` when it removed something.
fn drop_unused_pass(d: &mut Drawing, before: &TableNames, keep: &str) -> bool {
let mut removed = false;
for (kind, old) in &before.0 {
// Nothing was added to this table: nothing to scan for.
if names_of(d, *kind).is_subset(old) {
continue;
}
let keep_blocks = if matches!(kind, Kind::Blocks) { reachable(d, vec![keep.to_string()]) } else { BTreeSet::new() };
let fresh: BTreeSet<String> = candidates(d, *kind)
.into_iter()
.filter(|n| !old.contains(&n.to_ascii_lowercase()) && !keep_blocks.contains(&n.to_ascii_uppercase()))
.map(|n| n.to_ascii_lowercase())
.collect();
let gone = |name: &str| fresh.contains(&name.to_ascii_lowercase());
removed |= !fresh.is_empty();
match kind {
Kind::Blocks => d.blocks.retain(|k, _| !gone(k)),
Kind::Dimstyles => d.dim_styles.retain(|t| !gone(&t.name)),
Kind::MleaderStyles => d.mleader_styles.retain(|t| !gone(&t.name)),
Kind::MlineStyles => d.mline_styles.retain(|t| !gone(&t.name)),
Kind::TableStyles => d.table_styles.retain(|t| !gone(&t.name)),
Kind::Layers => d.layers.retain(|t| !gone(&t.name)),
Kind::Linetypes => d.linetypes.retain(|t| !gone(&t.name)),
Kind::TextStyles => d.text_styles.retain(|t| !gone(&t.name)),
_ => {}
}
}
removed
}
/// Add the source's layers, linetypes and styles that this drawing doesn't have (a name that
/// exists keeps this drawing's definition).
fn merge_tables(d: &mut Drawing, src: &Drawing) {
@@ -146,9 +283,42 @@ fn merge_tables(d: &mut Drawing, src: &Drawing) {
merge(&mut d.mline_styles, &src.mline_styles, |t| &t.name);
}
/// The names the copied source blocks take, found as `Drawing::block` finds a block: a reference
/// may spell a name differently from its definition.
struct Renames {
exact: BTreeMap<String, String>,
upper: BTreeMap<String, String>,
}
impl Renames {
fn new(exact: BTreeMap<String, String>) -> Self {
let mut upper = BTreeMap::new();
for (from, to) in &exact {
upper.entry(from.to_ascii_uppercase()).or_insert_with(|| to.clone());
}
Renames { exact, upper }
}
fn get(&self, name: &str) -> Option<&String> {
self.exact.get(name).or_else(|| self.upper.get(&name.to_ascii_uppercase()))
}
}
/// Point the dimension styles the source brought at their renamed arrowhead blocks. The styles
/// this drawing already had (`own`) name this drawing's blocks.
fn rename_style_arrows(d: &mut Drawing, own: &BTreeSet<String>, renames: &Renames) {
for st in d.dim_styles.iter_mut().filter(|t| !own.contains(&t.name.to_ascii_lowercase())) {
for arrow in [&mut st.arrow_block, &mut st.arrow_block1, &mut st.arrow_block2, &mut st.leader_arrow_block] {
if let Some(n) = renames.get(arrow.trim()) {
arrow.clone_from(n);
}
}
}
}
/// A copy of a source entity for this drawing: a fresh handle, block references renamed, and
/// links to other source objects (associative dimension points) dropped.
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &Renames) -> Entity {
let mut e = e.clone();
let old = e.handle;
e.handle = d.new_handle();
@@ -173,6 +343,23 @@ fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String,
if let Some(n) = dm.block.as_ref().and_then(|b| renames.get(b)) {
dm.block = Some(n.clone());
}
for (key, value) in dm.overrides.iter_mut() {
// Only a block that was renamed changes the value: a number naming a block that
// kept its name stays as it was given.
if is_arrow_override(key)
&& let Some(b) = override_name(value)
&& let Some(n) = renames.get(&b).filter(|n| **n != b)
{
*value = json!(n);
}
}
}
EntityKind::MLeader(m) => {
if let Some(b) = &mut m.block
&& let Some(n) = renames.get(&b.block)
{
b.block = n.clone();
}
}
_ => {}
}
@@ -233,6 +420,78 @@ mod tests {
assert!(file_ref(&s, "BOLT").is_none());
}
/// A block holding very many references still reaches every block it needs.
#[test]
fn a_block_of_many_references_keeps_all_it_needs() {
let reference = |handle: u64, block: &str| {
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": block, "insert": [0, 0, 0] })).unwrap();
Entity::new(Handle(handle), EntityKind::Insert(insert))
};
let mut big = Block::new("Big");
big.entities.push(reference(0x100, "Deep"));
for i in 0..100_001 {
big.entities.push(reference(0x200 + i, "Leaf"));
}
let mut d = Drawing::default();
d.blocks.insert("Big".into(), Arc::new(big));
d.blocks.insert("Deep".into(), Arc::new(Block::new("Deep")));
d.blocks.insert("Leaf".into(), Arc::new(Block::new("Leaf")));
assert!(reachable(&d, vec!["Big".into()]).contains("DEEP"));
}
/// A drawing with very many references does not lose the arrowhead of a merged dimension
/// style: the arrowheads are the last thing PURGE's walk looks at.
#[test]
fn many_references_keep_a_merged_arrowhead() {
let mut d = Drawing::new_metric();
d.blocks.insert("Leaf".into(), Arc::new(Block::new("Leaf")));
for i in 0..100_001 {
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": "Leaf", "insert": [0, 0, 0] })).unwrap();
d.model.push(Entity::new(Handle(0x200 + i), EntityKind::Insert(insert)));
}
let before = TableNames::of(&d);
d.blocks.insert("Tip".into(), Arc::new(Block::new("Tip")));
d.dim_styles.push(cadcraft_doc::DimStyle { name: "Late".into(), arrow_block: "Tip".into(), ..Default::default() });
d.header.set_str("DIMSTYLE", "Late");
d.blocks.insert("Merged".into(), Arc::new(Block::new("Merged")));
drop_unused_new(&mut d, &before, "Merged");
assert!(d.block("Tip").is_some());
}
/// Past the purge scan's limit nothing is called unused: a merged block's dimension style and
/// layer stay even when the scan never reaches its objects.
#[test]
fn a_drawing_too_big_for_the_scan_keeps_what_was_merged() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
dim.common.layer = "Late".into();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.style = "Late".into();
}
// One definition under many names: millions of objects for the scan, thousands in memory.
let mut filler = Block::new("Filler");
for i in 0..10_000 {
filler.entities.push(Entity::new(Handle(0x1000 + i), dim.kind.clone()));
}
let filler = Arc::new(filler);
let mut d = Drawing::new_metric();
for i in 0..501 {
d.blocks.insert(format!("F{i:03}"), filler.clone());
}
let before = TableNames::of(&d);
assert!(!scan_reads_everything(&d));
d.layers.push(cadcraft_doc::Layer { name: "Late".into(), ..Default::default() });
d.dim_styles.push(cadcraft_doc::DimStyle { name: "Late".into(), ..Default::default() });
// Sorted after every filler, so past the limit.
let mut merged = Block::new("Z");
merged.entities.push(dim);
d.blocks.insert("Z".into(), Arc::new(merged));
drop_unused_new(&mut d, &before, "Z");
assert!(d.layers.iter().any(|l| l.name == "Late"));
assert!(d.dim_styles.iter().any(|t| t.name == "Late"));
}
#[test]
fn inserted_file_brings_its_mline_styles() {
let mut src = Drawing::default();
@@ -245,4 +504,211 @@ mod tests {
merge_tables(&mut d, &src);
assert_eq!(d.mline_styles.len(), before);
}
/// A block reference, for the fixtures below.
fn reference(handle: u64, block: &str) -> Entity {
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": block, "insert": [0, 0, 0] })).unwrap();
Entity::new(Handle(handle), EntityKind::Insert(insert))
}
/// An anonymous block `*U1` that its description tells apart.
fn anonymous(description: &str) -> Arc<Block> {
let mut b = Block::new("*U1");
b.description = description.into();
Arc::new(b)
}
/// Takes `model`, whose `*U1` is the file's, into a drawing with a `*U1` of its own, and says
/// which of the two the one object of block "Part" refers to.
fn colliding_block_after_import(model: Entity) -> String {
let mut src = Drawing::new_metric();
src.blocks.insert("*U1".into(), anonymous("from the file"));
src.model.push(model);
let mut s = Session::new();
s.doc_mut().unwrap().blocks.insert("*U1".into(), anonymous("from the drawing"));
define_from(&mut s, &src, "Part", true).unwrap();
let d = s.doc().unwrap();
let part = d.block("Part").unwrap();
let to = part.entities.iter().next().and_then(|e| referenced_block(e)).unwrap();
d.block(&to).unwrap().description.clone()
}
/// Block names are case-insensitive, so `*u1` is the file's `*U1` and takes its new name.
#[test]
fn a_renamed_block_is_found_whatever_the_case_of_the_reference() {
assert_eq!(colliding_block_after_import(reference(0x500, "*u1")), "from the file");
}
/// The block content of a multileader takes the new name like any other reference.
#[test]
fn a_multileader_follows_its_renamed_block() {
let EntityKind::Insert(content) = reference(0x500, "*U1").kind else { return };
let mut m: cadcraft_doc::MLeader =
serde_json::from_value(json!({ "leaders": [], "landing": [0, 0, 0], "dogleg": 0.0, "text": null })).unwrap();
m.block = Some(content);
assert_eq!(colliding_block_after_import(Entity::new(Handle(0x501), EntityKind::MLeader(m))), "from the file");
}
/// An arrowhead override given as a number names its block: the block comes along, and the
/// override is left as given when the block keeps its name.
#[test]
fn a_numeric_arrowhead_override_brings_its_block() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.overrides.insert("DIMBLK1".into(), json!(45));
}
let mut src = Drawing::new_metric();
src.blocks.insert("45".into(), Arc::new(Block::new("45")));
src.model.push(dim);
let mut t = Session::new();
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
assert!(d.block("45").is_some());
let e = d.block("Part").unwrap().entities.iter().next().unwrap().clone();
let EntityKind::Dimension(dm) = &e.kind else { panic!("not a dimension") };
assert_eq!(dm.overrides["DIMBLK1"], json!(45));
}
/// Arrowheads are references too: a dimension style that came along and a dimension's override
/// follow the renamed block, and a style this drawing already had keeps its own.
#[test]
fn arrowheads_follow_a_renamed_block() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.style = "Came".into();
dm.overrides.insert("DIMBLK1".into(), json!("*U1"));
}
let style = |name: &str| cadcraft_doc::DimStyle { name: name.into(), arrow_block: "*U1".into(), ..Default::default() };
let mut src = Drawing::new_metric();
src.blocks.insert("*U1".into(), anonymous("from the file"));
src.dim_styles.extend([style("Came"), style("Own")]);
src.model.push(dim);
let mut t = Session::new();
let d = t.doc_mut().unwrap();
d.blocks.insert("*U1".into(), anonymous("from the drawing"));
d.dim_styles.push(style("Own"));
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
let of = |name: &str| d.block(name).unwrap().description.clone();
let arrow = |name: &str| d.dim_styles.iter().find(|st| st.name == name).unwrap().arrow_block.clone();
assert_eq!(of(&arrow("Came")), "from the file");
assert_eq!(of(&arrow("Own")), "from the drawing");
let e = d.block("Part").unwrap().entities.iter().next().unwrap().clone();
let EntityKind::Dimension(dm) = &e.kind else { return };
assert_eq!(of(dm.overrides["DIMBLK1"].as_str().unwrap()), "from the file");
}
/// What the objects of an imported block name comes along, directly or through another table:
/// a leader's dimension style, a dimension's text style override, the text style in a linetype,
/// an attribute's layer and multiline text style, here on a block reference and on a
/// multileader's block content. What nothing names stays out.
#[test]
fn an_import_keeps_every_style_and_layer_its_objects_name() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.overrides.insert("DIMTXSTY".into(), json!("InOverride"));
}
let attrib = |style: &str, layer: &str| {
let mut a: cadcraft_doc::Attrib = serde_json::from_value(json!({
"tag": "A",
"text": { "insert": [0, 0, 0], "height": 1.0, "value": "1" },
"multiline": { "mtext": { "insert": [0, 0, 0], "height": 1.0, "contents": "1", "style": style }, "readAs": "1" },
}))
.unwrap();
a.props.layer = Some(layer.into());
a
};
let mut placed = reference(0x500, "Inner");
if let EntityKind::Insert(i) = &mut placed.kind {
i.attribs.push(attrib("InAttribute", "OnAttribute"));
}
let EntityKind::Insert(mut content) = reference(0x501, "Inner").kind else { return };
content.attribs.push(attrib("InContent", "OnContent"));
let mut multileader: cadcraft_doc::MLeader =
serde_json::from_value(json!({ "leaders": [], "landing": [0, 0, 0], "dogleg": 0.0, "text": null })).unwrap();
multileader.block = Some(content);
let leader: cadcraft_doc::Leader = serde_json::from_value(json!({ "vertices": [], "style": "ForLeader" })).unwrap();
let line = cadcraft_doc::Line { a: cadcraft_geom::Vec3::ZERO, b: cadcraft_geom::Vec3::new(1.0, 0.0, 0.0) };
let mut line = Entity::new(Handle(0x502), EntityKind::Line(line));
line.common.linetype = "WithText".into();
let mut src = Drawing::new_metric();
src.blocks.insert("Inner".into(), Arc::new(Block::new("Inner")));
for name in ["InOverride", "InAttribute", "InContent", "InLinetype", "Spare"] {
let mut t = src.text_styles[0].clone();
t.name = name.into();
src.text_styles.push(t);
}
for name in ["OnAttribute", "OnContent", "Unused"] {
src.layers.push(cadcraft_doc::Layer { name: name.into(), ..Default::default() });
}
let dash = cadcraft_doc::DashElement { style: Some("InLinetype".into()), ..cadcraft_doc::DashElement::dash(1.0) };
src.linetypes.push(cadcraft_doc::Linetype { name: "WithText".into(), description: String::new(), pattern: vec![dash] });
src.dim_styles.push(cadcraft_doc::DimStyle { name: "ForLeader".into(), ..Default::default() });
src.model.push(dim);
src.model.push(placed);
src.model.push(Entity::new(Handle(0x503), EntityKind::MLeader(multileader)));
src.model.push(Entity::new(Handle(0x504), EntityKind::Leader(leader)));
src.model.push(line);
let mut t = Session::new();
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
let styles: Vec<&str> = d.text_styles.iter().map(|t| t.name.as_str()).collect();
for name in ["InOverride", "InAttribute", "InContent", "InLinetype"] {
assert!(styles.contains(&name), "{name}: {styles:?}");
}
assert!(!styles.contains(&"Spare"), "{styles:?}");
let layers: Vec<&str> = d.layers.iter().map(|l| l.name.as_str()).collect();
assert!(layers.contains(&"OnAttribute") && layers.contains(&"OnContent"), "{layers:?}");
assert!(!layers.contains(&"Unused"), "{layers:?}");
assert!(d.dim_styles.iter().any(|st| st.name == "ForLeader"));
}
/// The text style of a table style's cell style is in use.
#[test]
fn a_table_style_keeps_its_cell_styles_text_style() {
let mut d = Drawing::new_metric();
let mut t = d.text_styles[0].clone();
t.name = "InCell".into();
d.text_styles.push(t);
let mut cell = cadcraft_doc::TableStyle::default().cell_style("Data");
cell.text_style = "InCell".into();
d.table_styles[0].cell_styles.push(cell);
assert!(!candidates(&d, Kind::TextStyles).iter().any(|n| n == "InCell"));
}
/// A linetype of the file stays when a dimension style that came along names it, and stays out
/// when only a style that did not come along does.
#[test]
fn a_linetype_follows_the_dimension_style_that_names_it() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.style = "Used".into();
}
let mut src = Drawing::new_metric();
for name in ["Kept", "Left"] {
let mut lt = src.linetypes[0].clone();
lt.name = name.into();
src.linetypes.push(lt);
}
src.dim_styles.push(cadcraft_doc::DimStyle { name: "Used".into(), dim_linetype: "Kept".into(), ..Default::default() });
src.dim_styles.push(cadcraft_doc::DimStyle { name: "Spare".into(), ext_linetype1: "Left".into(), ..Default::default() });
src.model.push(dim);
let mut t = Session::new();
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
assert!(d.linetypes.iter().any(|l| l.name == "Kept"));
assert!(!d.dim_styles.iter().any(|st| st.name == "Spare"));
assert!(!d.linetypes.iter().any(|l| l.name == "Left"));
}
}
+378
View File
@@ -0,0 +1,378 @@
//! Block libraries for the Blocks palette: a folder of drawings or a single drawing file whose
//! blocks can be placed in the current drawing.
//!
//! BLOCKLIBRARY lists what a library holds, BLOCKLIBRARIES keeps the list of libraries the user
//! added (in the settings folder; in memory where there is none), and BLOCKLIBIMPORT defines a
//! library block in the current drawing so that INSERT can place it. Files are read through the
//! host's io hooks like OPEN, so the engine stays I/O-agnostic.
use std::path::Path;
#[cfg(not(target_arch = "wasm32"))]
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::SystemTime;
use cadcraft_doc::Drawing;
use serde_json::{Value, json};
use super::insert_file::{define_from, read_drawing, stem};
use super::valid_block_name;
use crate::cmd::{CommandSpec, always, bad, has_doc, str_param};
use crate::{Result, Session};
/// Most drawings one folder library lists.
#[cfg(not(target_arch = "wasm32"))]
const MAX_FILES: usize = 2000;
/// Most directory entries looked at in a folder library.
#[cfg(not(target_arch = "wasm32"))]
const MAX_SCANNED: usize = 100_000;
/// Most blocks a palette listing holds: the rest of a hostile file's table is left out.
const MAX_LISTED: usize = 10_000;
/// Most libraries the list keeps.
const MAX_LIBRARIES: usize = 64;
/// The longest library path kept.
const MAX_PATH_BYTES: usize = 4096;
/// The file in the settings folder that keeps the library list, and its largest size.
#[cfg(not(target_arch = "wasm32"))]
const LIST_FILE: &str = "block-libraries.json";
#[cfg(not(target_arch = "wasm32"))]
const MAX_LIST_BYTES: usize = 256 << 10;
/// How many parsed library drawings stay in memory.
const CACHE_MAX: usize = 4;
/// A library drawing already read, and the file's size and time then.
struct Cached {
path: String,
stamp: (u64, Option<SystemTime>),
drawing: Arc<Drawing>,
}
static CACHE: Mutex<Vec<Cached>> = Mutex::new(Vec::new());
/// Forget the library drawings read so far: the next read parses each file again, even one whose
/// size and time did not change (Refresh in the palette).
pub fn clear_library_cache() {
if let Ok(mut cache) = CACHE.lock() {
cache.clear();
}
}
/// The file's size and modification time; `None` where it cannot be told (nothing is kept then).
fn stamp(path: &str) -> Option<(u64, Option<SystemTime>)> {
if cfg!(target_arch = "wasm32") {
return None;
}
std::fs::metadata(path).ok().filter(std::fs::Metadata::is_file).map(|m| (m.len(), m.modified().ok()))
}
/// A library drawing, read once and kept while the file is as it was: placing a block must not
/// parse the whole file again.
fn cached_drawing(path: &str) -> Result<Arc<Drawing>> {
// The reader sniffs the bytes, so a DXF named `part.bin` would load: the contract is DWG/DXF by name.
if !is_drawing(Path::new(path)) {
return Err(bad("blocklibrary", format!("{path}: expected a DWG or DXF file")));
}
let now = stamp(path);
if let Some(now) = now
&& let Ok(cache) = CACHE.lock()
&& let Some(hit) = cache.iter().find(|c| c.path == path && c.stamp == now)
{
return Ok(hit.drawing.clone());
}
// The palette reads previews outside a command, so a parser panic stops here too.
let read = std::panic::catch_unwind(|| read_drawing(path));
let drawing = Arc::new(read.unwrap_or_else(|p| Err(bad("blocklibrary", format!("{path}: {}", crate::guard::message(p.as_ref())))))?);
if let Some(now) = now
&& let Ok(mut cache) = CACHE.lock()
{
cache.retain(|c| c.path != path);
cache.push(Cached { path: path.to_string(), stamp: now, drawing: drawing.clone() });
while cache.len() > CACHE_MAX {
cache.remove(0);
}
}
Ok(drawing)
}
/// The list where no settings folder keeps it, and the copy read from it.
static MEMORY: Mutex<Vec<String>> = Mutex::new(Vec::new());
/// The last write of the list failed: the copy in memory is newer than the file.
static UNSAVED: AtomicBool = AtomicBool::new(false);
/// The commands the Blocks palette uses: BLOCKLIBRARY, BLOCKLIBIMPORT and BLOCKLIBRARIES.
pub(super) fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("blocklibrary", "Block Library", run_library)
.params("{path: a folder of DWG/DXF files, or one such file} → {kind: \"folder\", path, files: [{name, file}], truncated} | {kind: \"file\", path, blocks: [{name, description}], truncated}")
.enabled(always)
.noundo(),
CommandSpec::new("blocklibraries", "Block Libraries", run_libraries)
.params("{op?: \"list\" (default)|\"add\"|\"remove\", path? (add, remove)} → {libraries: [path], path? (add: the entry as kept)}")
.enabled(always)
.noundo(),
CommandSpec::new("blocklibimport", "Import Library Block", run_import)
.params("{path: DWG/DXF file, block?: the block to take from it (default: the whole drawing), name?: the block to define (default: `block`, else the file name; never one the drawing already has)} → {name}")
.enabled(has_doc),
]
}
/// A drawing file by its extension.
fn is_drawing(p: &Path) -> bool {
p.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("dwg") || e.eq_ignore_ascii_case("dxf"))
}
/// The drawings in a folder, by name: `(block name, full path)`, and whether some were left out.
fn folder_files(dir: &Path) -> Result<(Vec<(String, String)>, bool)> {
#[cfg(not(target_arch = "wasm32"))]
{
let rd = std::fs::read_dir(dir).map_err(|e| bad("blocklibrary", format!("{}: {e}", dir.display())))?;
let entries: Vec<PathBuf> = rd.filter_map(|e| e.ok()).map(|e| e.path()).take(MAX_SCANNED.saturating_add(1)).collect();
let mut truncated = entries.len() > MAX_SCANNED;
let mut out: Vec<(String, String)> = entries
.iter()
.take(MAX_SCANNED)
.filter(|p| is_drawing(p) && p.is_file())
.filter_map(|p| p.to_str().map(|s| (stem(s), s.to_string())))
.collect();
out.sort_by_key(|(n, _)| n.to_ascii_lowercase());
truncated |= out.len() > MAX_FILES;
out.truncate(MAX_FILES);
Ok((out, truncated))
}
#[cfg(target_arch = "wasm32")]
{
let _ = dir;
Err(bad("blocklibrary", "paths are not available on the web"))
}
}
/// Whether two library paths name the same place: letter case counts except where the file
/// system ignores it (Windows, and macOS by default).
fn same_path(a: &str, b: &str) -> bool {
if cfg!(any(windows, target_os = "macos")) { a.eq_ignore_ascii_case(b) } else { a == b }
}
/// Whether `path` is a folder.
fn is_folder(path: &str) -> bool {
!cfg!(target_arch = "wasm32") && Path::new(path).is_dir()
}
/// The first `MAX_LISTED` named blocks of a library drawing by name (no generated or layout
/// blocks, no xrefs), and whether there were more. The names are made lower case once, and only
/// the blocks that are kept are sorted.
pub(crate) fn library_blocks(d: &Drawing) -> (Vec<&std::sync::Arc<cadcraft_doc::Block>>, bool) {
let mut keyed: Vec<(String, &std::sync::Arc<cadcraft_doc::Block>)> = d
.blocks
.values()
.filter(|b| !b.anonymous && b.xref_path.is_none() && !b.name.starts_with('*') && !b.name.contains('|'))
.map(|b| (b.name.to_ascii_lowercase(), b))
.collect();
let truncated = keyed.len() > MAX_LISTED;
if truncated {
keyed.select_nth_unstable_by(MAX_LISTED, |a, b| a.0.cmp(&b.0));
keyed.truncate(MAX_LISTED);
}
keyed.sort_by(|a, b| a.0.cmp(&b.0));
(keyed.into_iter().map(|(_, b)| b).collect(), truncated)
}
/// Read a library file (for the palette's previews too), kept until the file changes.
pub fn read_library_file(path: &str) -> Result<Arc<Drawing>> {
cached_drawing(path)
}
/// What BLOCKLIBRARY answers for `path`. It needs no session, so the palette reads big drawings
/// and slow folders on a worker thread.
pub fn list_library(path: &str) -> Result<Value> {
if is_folder(path) {
let (files, truncated) = folder_files(Path::new(path))?;
let list: Vec<Value> = files.iter().map(|(name, file)| json!({ "name": name, "file": file })).collect();
return Ok(json!({ "kind": "folder", "path": path, "files": list, "truncated": truncated }));
}
let d = cached_drawing(path)?;
let (blocks, truncated) = library_blocks(&d);
let list: Vec<Value> = blocks.iter().map(|b| json!({ "name": b.name, "description": b.description })).collect();
Ok(json!({ "kind": "file", "path": path, "blocks": list, "truncated": truncated }))
}
/// BLOCKLIBRARY: list a folder's drawings or a drawing's blocks.
fn run_library(_s: &mut Session, p: &Value) -> Result<Value> {
let path = str_param(p, "path").map(str::trim).filter(|s| !s.is_empty()).ok_or_else(|| bad("blocklibrary", "`path` is required"))?;
list_library(path)
}
/// BLOCKLIBIMPORT: define a library block (or a whole drawing) in the current drawing, under a
/// name it does not have yet.
fn run_import(s: &mut Session, p: &Value) -> Result<Value> {
let path = str_param(p, "path").map(str::trim).filter(|s| !s.is_empty()).ok_or_else(|| bad("blocklibimport", "`path` is required"))?;
let block = str_param(p, "block").map(str::trim).filter(|s| !s.is_empty());
// A whole drawing is named after its file; a block of it after itself.
let name = str_param(p, "name")
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string)
.unwrap_or_else(|| block.map_or_else(|| stem(path), str::to_string));
if !valid_block_name(&name) {
return Err(bad("blocklibimport", format!("\"{name}\" is not a valid block name")));
}
// A block the drawing already has is never replaced, as in the palette: its references
// would change with it.
if s.doc()?.block(&name).is_some() {
return Err(bad("blocklibimport", format!("block \"{name}\" is already in the drawing")));
}
let mut src = (*cached_drawing(path)?).clone();
let mut picked = None;
if let Some(block) = block {
let b = src.block(block).cloned().ok_or_else(|| bad("blocklibimport", format!("{path} has no block \"{block}\"")))?;
// The block is a drawing of its own: its objects as model space and its base point as
// $INSBASE, with the file's other blocks around it.
src.model = b.entities.clone();
src.header.set("INSBASE", cadcraft_doc::HVal::Point(b.base));
picked = Some(b);
}
// Only the layers, linetypes and styles the block needs come along, not the whole file's.
let name = define_from(s, &src, &name, true)?;
// The definition is a new one: what the block says about itself still comes along.
if let Some(from) = picked
&& let Some(b) = s.doc_mut()?.blocks.get_mut(&name)
{
let b = Arc::make_mut(b);
b.annotative = from.annotative;
b.description.clone_from(&from.description);
b.units = from.units;
b.explodable = from.explodable;
}
Ok(json!({ "name": name }))
}
/// Where the library list is kept.
#[cfg(not(target_arch = "wasm32"))]
fn list_path() -> Option<PathBuf> {
crate::settings_dir::current().map(|d| d.join(LIST_FILE))
}
/// A path the list can hold: short enough, with no control characters.
fn acceptable(path: &str) -> bool {
!path.is_empty() && path.len() <= MAX_PATH_BYTES && !path.chars().any(char::is_control)
}
/// The list in the settings folder. The file is hand-editable, so what it holds is checked here.
/// `Ok(None)`: no settings folder or no file yet. `Err`: a file that is there but unreadable.
#[cfg(not(target_arch = "wasm32"))]
fn read_list() -> std::result::Result<Option<Vec<String>>, String> {
let Some(path) = list_path() else { return Ok(None) };
if !path.exists() {
return Ok(None);
}
let bytes = crate::capped_read::read_capped(&path, MAX_LIST_BYTES).map_err(|e| format!("{}: {e}", path.display()))?;
let list: Vec<String> = serde_json::from_slice(&bytes).map_err(|e| format!("{}: {e}", path.display()))?;
Ok(Some(list.into_iter().filter(|p| acceptable(p)).take(MAX_LIBRARIES).collect()))
}
/// On the web there is no settings folder: the list lives in memory only.
#[cfg(target_arch = "wasm32")]
fn read_list() -> std::result::Result<Option<Vec<String>>, String> {
Ok(None)
}
/// The list, and why the file could not be read when it exists but is unreadable. Such a file is
/// never written over: `run_libraries` refuses to change the list while it stays unreadable.
fn load_list() -> (Vec<String>, Option<String>) {
let memory = || MEMORY.lock().map(|m| m.clone()).unwrap_or_default();
if UNSAVED.load(Ordering::Relaxed) {
return (memory(), None);
}
match read_list() {
Ok(Some(list)) => (list, None),
Ok(None) => (memory(), None),
Err(why) => (memory(), Some(why)),
}
}
/// Write the list to `path`, its folder made if needed. `false` when it could not be written.
#[cfg(not(target_arch = "wasm32"))]
fn write_list(path: &Path, list: &[String]) -> bool {
let Ok(bytes) = serde_json::to_vec_pretty(list) else { return false };
if let Some(dir) = path.parent() {
let _ = std::fs::create_dir_all(dir);
}
crate::atomic_write::write_atomic(path, &bytes).is_ok()
}
/// Keep the list in memory and write it to the settings folder.
fn save_list(list: &[String]) {
if let Ok(mut m) = MEMORY.lock() {
*m = list.to_vec();
}
// A list that cannot be written is still kept for this session.
#[cfg(not(target_arch = "wasm32"))]
if let Some(p) = list_path() {
UNSAVED.store(!write_list(&p, list), Ordering::Relaxed);
}
}
/// BLOCKLIBRARIES: list, add to or remove from the libraries.
fn run_libraries(_s: &mut Session, p: &Value) -> Result<Value> {
let (mut list, unreadable) = load_list();
let op = str_param(p, "op").unwrap_or("list");
if let (Some(why), "add" | "remove") = (&unreadable, op) {
return Err(bad("blocklibraries", format!("the library list cannot be read, so it is left as it is ({why})")));
}
let path = str_param(p, "path").map(str::trim).filter(|s| !s.is_empty());
match op {
"list" => {}
"add" => {
let path = path.ok_or_else(|| bad("blocklibraries", "`path` is required"))?;
let drawing = is_drawing(Path::new(path)) && Path::new(path).is_file();
if !acceptable(path) || !(is_folder(path) || drawing) {
return Err(bad("blocklibraries", "a library is a folder or a DWG/DXF file"));
}
let stored = match list.iter().find(|l| same_path(l, path)) {
Some(l) => l.clone(),
None => {
if list.len() >= MAX_LIBRARIES {
return Err(bad("blocklibraries", format!("at most {MAX_LIBRARIES} libraries")));
}
list.push(path.to_string());
path.to_string()
}
};
save_list(&list);
return Ok(json!({ "libraries": list, "path": stored }));
}
"remove" => {
let path = path.ok_or_else(|| bad("blocklibraries", "`path` is required"))?;
list.retain(|l| !same_path(l, path));
save_list(&list);
}
other => return Err(bad("blocklibraries", format!("unknown op \"{other}\""))),
}
Ok(json!({ "libraries": list }))
}
#[cfg(test)]
mod tests {
use super::*;
/// A list that could not be written stays the list of this session, whatever the file says.
#[test]
fn a_failed_write_keeps_the_list_in_memory() {
let dir = std::env::temp_dir().join(format!("cadcraft-library-list-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let blocker = dir.join("a-file");
std::fs::write(&blocker, b"x").unwrap();
let list = vec!["C:/kept".to_string()];
// A folder that is a file: neither the folder nor the list can be made.
assert!(!write_list(&blocker.join("block-libraries.json"), &list));
assert!(write_list(&dir.join("block-libraries.json"), &list));
*MEMORY.lock().unwrap() = list.clone();
UNSAVED.store(true, Ordering::Relaxed);
assert_eq!(load_list().0, list);
UNSAVED.store(false, Ordering::Relaxed);
MEMORY.lock().unwrap().clear();
std::fs::remove_dir_all(&dir).unwrap();
}
}
+59 -24
View File
@@ -114,17 +114,40 @@ fn json_key(kind: Kind) -> &'static str {
}
}
/// Most objects PURGE's scan reads, as the scan of used layers does.
const MAX_SCAN: usize = 5_000_000;
fn all_entities(d: &Drawing) -> impl Iterator<Item = &std::sync::Arc<cadcraft_doc::Entity>> {
d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).chain(d.blocks.values().flat_map(|b| b.entities.iter()))
}
fn entities(d: &Drawing) -> impl Iterator<Item = &std::sync::Arc<cadcraft_doc::Entity>> {
d.model.iter().chain(d.layouts.iter().flat_map(|l| l.entities.iter())).chain(d.blocks.values().flat_map(|b| b.entities.iter())).take(5_000_000)
all_entities(d).take(MAX_SCAN)
}
/// Whether the scan reads the whole drawing: past its limit, what is in use can look unused.
pub(in crate::cmd) fn scan_reads_everything(d: &Drawing) -> bool {
all_entities(d).nth(MAX_SCAN).is_none()
}
/// Whether a dimension override sets an arrowhead block.
pub(in crate::cmd) fn is_arrow_override(key: &str) -> bool {
cadcraft_doc::DimStyle::field_name(key).is_some_and(|f| f.starts_with("arrowBlock") || f == "leaderArrowBlock")
}
/// The name a dimension override gives a style, linetype or arrowhead block. A number names one
/// too: DIMOVERRIDE keeps it as given, and the dimension is drawn with it as text.
pub(in crate::cmd) fn override_name(v: &Value) -> Option<String> {
match v {
Value::String(n) => Some(n.trim().to_string()),
Value::Number(n) => Some(n.to_string()),
_ => None,
}
}
/// The arrowhead block names a dimension's overrides set.
pub(in crate::cmd) fn override_arrows(dm: &cadcraft_doc::Dimension) -> impl Iterator<Item = String> + '_ {
dm.overrides
.iter()
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k).is_some_and(|f| f.starts_with("arrowBlock") || f == "leaderArrowBlock"))
.filter_map(|(_, v)| v.as_str().map(|n| n.trim().to_string()))
.filter(|n| !n.is_empty())
dm.overrides.iter().filter(|(k, _)| is_arrow_override(k)).filter_map(|(_, v)| override_name(v)).filter(|n| !n.is_empty())
}
/// Upper-case names of blocks reachable from model space, the layouts and dimensions, and the
@@ -151,10 +174,9 @@ pub(in crate::cmd) fn used_blocks(d: &Drawing) -> HashSet<String> {
_ => {}
}
}
let mut guard = 0;
// Each block is walked once, so this ends, cycles included.
while let Some(n) = frontier.pop() {
guard += 1;
if guard > 100_000 || !used.insert(n.to_ascii_uppercase()) {
if !used.insert(n.to_ascii_uppercase()) {
continue;
}
if let Some(b) = d.block(&n) {
@@ -178,6 +200,33 @@ fn is(name: &str, list: &[&str]) -> bool {
list.iter().any(|n| n.eq_ignore_ascii_case(name))
}
/// The linetypes an object names besides its own: its attributes' overrides, its dimension
/// overrides, and the copy of its style a multiline keeps.
fn linetypes_inside(e: &cadcraft_doc::Entity) -> Vec<String> {
let mut out: Vec<String> = super::object_attribs(e).iter().filter_map(|a| a.props.linetype.clone()).collect();
match &e.kind {
EntityKind::Dimension(dm) => out.extend(
dm.overrides
.iter()
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k).is_some_and(|f| matches!(f, "dimLinetype" | "extLinetype1" | "extLinetype2")))
.filter_map(|(_, v)| override_name(v)),
),
EntityKind::MLine(m) => out.extend(m.def.elements.iter().map(|e| e.linetype.clone())),
_ => {}
}
out
}
/// The linetypes named by objects, layers, dimension styles and multiline styles.
fn linetypes_in_use(d: &Drawing) -> impl Iterator<Item = String> + '_ {
let objects = entities(d).map(|e| e.common.linetype.clone());
let inside = entities(d).flat_map(|e| linetypes_inside(e));
let layers = d.layers.iter().map(|l| l.linetype.clone());
let dims = d.dim_styles.iter().flat_map(|t| [t.dim_linetype.clone(), t.ext_linetype1.clone(), t.ext_linetype2.clone()]);
let mlines = d.mline_styles.iter().flat_map(|t| t.elements.iter().map(|e| e.linetype.clone()));
objects.chain(inside).chain(layers).chain(dims).chain(mlines)
}
/// Names of the unused objects of a named kind, in table order. This is PURGE's scan; `USAGE`
/// reads it too, without purging anything.
pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
@@ -197,21 +246,7 @@ pub(in crate::cmd) fn candidates(d: &Drawing, kind: Kind) -> Vec<String> {
.collect()
}
Kind::Linetypes => {
// Objects and layers use linetypes, and so do dimension styles and a dimension's own
// overrides (DIMLTYPE, DIMLTEX1, DIMLTEX2), and multiline styles' elements.
let styles = d.dim_styles.iter().flat_map(|s| [s.dim_linetype.clone(), s.ext_linetype1.clone(), s.ext_linetype2.clone()]);
let overrides = entities(d).filter_map(|e| if let EntityKind::Dimension(dm) = &e.kind { Some(dm) } else { None }).flat_map(|dm| {
["dimLinetype", "extLinetype1", "extLinetype2"].into_iter().filter_map(|k| dm.overrides.get(k)?.as_str().map(str::to_string))
});
let mlines = d.mline_styles.iter().flat_map(|s| s.elements.iter().map(|el| el.linetype.clone()));
let used = lower(
&mut entities(d)
.map(|e| e.common.linetype.clone())
.chain(d.layers.iter().map(|l| l.linetype.clone()))
.chain(styles)
.chain(overrides)
.chain(mlines),
);
let used = lower(&mut linetypes_in_use(d));
let cur = d.header.str("CELTYPE", "ByLayer");
d.linetypes
.iter()
+56 -1
View File
@@ -34,7 +34,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
.noundo(),
CommandSpec::new("-xref", "External References", run_dash_xref)
.alias(&["-xr"])
.params("{option: \"?\"|bind|detach|path|unload|reload|overlay|attach|type, names?: \"A,B*\" (default *), path? (path, attach, overlay), insert?: bool (bind: Insert type), overlay?: bool (type), at?, scale?, rotation? (attach)}")
.params("{option: \"?\"|bind|detach|path|unload|reload|overlay|attach|type, names?: \"A,B*\" (default *), exact?: bool (names are literal xref names, no wildcards or commas), path? (path, attach, overlay), insert?: bool (bind: Insert type), overlay?: bool (type), at?, scale?, rotation? (attach)}")
.interactive(|_| Ok(Box::new(XrefM::new("-XREF", XStage::Option)))),
CommandSpec::new("xbind", "Bind...", run_xbind)
.menu(&["Modify", "Object", "External Reference", "Bind..."])
@@ -201,6 +201,46 @@ fn run_xattach(s: &mut Session, p: &Value) -> Result<Value> {
/// The xrefs a JSON call names (`names`, default all); an error when none match.
fn named(s: &Session, cmd: &str, p: &Value) -> Result<Vec<String>> {
if p.get("exact").and_then(Value::as_bool) == Some(true) {
let lits: Vec<&str> = match p.get("names") {
Some(Value::Array(a)) => a.iter().filter_map(Value::as_str).collect(),
Some(Value::String(t)) => vec![t.as_str()],
_ => str_param(p, "name").into_iter().collect(),
};
let d = s.doc()?;
let mut names = Vec::new();
let mut selected = std::collections::HashSet::new();
// Symbol names are case-insensitive: two xrefs that differ only by case can't be loaded together.
let mut folded = std::collections::HashMap::new();
for literal in &lits {
if let Some(block) = xrefs(d).find(|block| block.name == *literal) {
if let Some(first) = folded.insert(block.name.to_ascii_lowercase(), block.name.clone()).filter(|f| *f != block.name) {
return Err(bad(cmd, format!("xref names \"{first}\" and \"{}\" differ only by case", block.name)));
}
if selected.insert(block.name.clone()) {
names.push(block.name.clone());
}
continue;
}
let normalized = literal.to_ascii_lowercase();
let mut matches = xrefs(d).filter(|block| block.name.to_ascii_lowercase() == normalized);
if let Some(block) = matches.next() {
if matches.next().is_some() {
return Err(bad(cmd, format!("xref name \"{literal}\" is ambiguous ignoring case")));
}
if let Some(first) = folded.insert(block.name.to_ascii_lowercase(), block.name.clone()).filter(|f| *f != block.name) {
return Err(bad(cmd, format!("xref names \"{first}\" and \"{}\" differ only by case", block.name)));
}
if selected.insert(block.name.clone()) {
names.push(block.name.clone());
}
}
}
if names.is_empty() {
return Err(bad(cmd, format!("no xref named \"{}\"", lits.join(","))));
}
return Ok(names);
}
let pattern = match p.get("names") {
Some(Value::Array(a)) => a.iter().filter_map(Value::as_str).collect::<Vec<_>>().join(","),
Some(Value::String(t)) => t.clone(),
@@ -223,6 +263,19 @@ fn run_xref(s: &mut Session, _p: &Value) -> Result<Value> {
Ok(r)
}
/// An error when two of `names` (or, with `all`, one of them and any other attached xref) differ only
/// by case: symbol names are case-insensitive, so such xrefs cannot be handled together, and the
/// command must refuse before it changes anything.
fn refuse_case_clash(d: &Drawing, cmd: &str, names: &[String], all: bool) -> Result<()> {
let others: Vec<&str> = if all { xrefs(d).map(|b| b.name.as_str()).collect() } else { names.iter().map(String::as_str).collect() };
for n in names {
if let Some(o) = others.iter().find(|o| *o != n && o.eq_ignore_ascii_case(n)) {
return Err(bad(cmd, format!("xref names \"{n}\" and \"{o}\" differ only by case")));
}
}
Ok(())
}
fn run_dash_xref(s: &mut Session, p: &Value) -> Result<Value> {
let option = str_param(p, "option").unwrap_or("?").trim().to_ascii_lowercase();
let host = host(s);
@@ -252,6 +305,7 @@ fn run_dash_xref(s: &mut Session, p: &Value) -> Result<Value> {
}
"detach" | "d" => {
let names = named(s, "-xref", p)?;
refuse_case_clash(s.doc()?, "-xref", &names, true)?;
let mut erased = 0;
for n in &names {
erased += load::detach(s.doc_mut()?, n);
@@ -276,6 +330,7 @@ fn run_dash_xref(s: &mut Session, p: &Value) -> Result<Value> {
"path" | "p" => {
let path = str_param(p, "path").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("-xref", "`path` is required"))?.to_string();
let names = named(s, "-xref", p)?;
refuse_case_clash(s.doc()?, "-xref", &names, false)?;
let d = s.doc_mut()?;
for n in &names {
if let Some(b) = d.blocks.get_mut(n) {
+17 -1
View File
@@ -313,7 +313,23 @@ pub(crate) fn load(d: &mut Drawing, name: &str, host: Option<&str>, chosen: bool
/// [`load`] the xrefs `names` within one set of limits.
pub(crate) fn load_each(d: &mut Drawing, names: &[String], host: Option<&str>, chosen: bool) -> Vec<Outcome> {
let mut cx = Ctx::new(host);
names.iter().flat_map(|n| load_with(d, n, host, chosen, &mut cx)).collect()
// Names are case-insensitive, so a name that differs only by case from an earlier one is the same xref.
let mut seen = std::collections::HashMap::new();
names
.iter()
.flat_map(|n| match seen.entry(n.to_ascii_lowercase()) {
std::collections::hash_map::Entry::Vacant(v) => {
v.insert(n.as_str());
load_with(d, n, host, chosen, &mut cx)
}
// Reported, not silent: the skipped xref keeps its status and is not loaded here.
std::collections::hash_map::Entry::Occupied(o) => vec![Outcome {
name: String::new(),
status: XrefStatus::Unresolved,
detail: format!("xref \"{n}\" not loaded: it differs only by case from \"{}\"", o.get()),
}],
})
.collect()
}
impl Ctx {
+54 -8
View File
@@ -453,14 +453,32 @@ impl Chain {
}
/// Point and unit tangent at arc length `d` from the start (clamped).
pub fn at_length(&self, d: f64) -> Option<(Vec2, Vec2)> {
let mut acc = 0.0;
for s in &self.segs {
let l = s.len();
if d <= acc + l + 1e-12 && l > 0.0 {
let t = ((d - acc) / l).clamp(0.0, 1.0);
return Some((s.at(t), s.tangent(t)));
}
acc += l;
self.at_length_in(&self.end_lengths(), d)
}
/// The arc length from the chain's start to the end of each segment, for [`Self::at_length_in`].
pub fn end_lengths(&self) -> Vec<f64> {
self.segs
.iter()
.scan(0.0, |acc, s| {
*acc += s.len();
Some(*acc)
})
.collect()
}
/// [`Self::at_length`] with the segment end lengths computed once (`ends` from
/// [`Self::end_lengths`]), so many samples along one chain each cost a binary search.
pub fn at_length_in(&self, ends: &[f64], d: f64) -> Option<(Vec2, Vec2)> {
let first = ends.partition_point(|e| d > e + 1e-12);
// A segment of no length can't hold the point; the next one that has length does.
// `ends` never decreases, so the first segment past `first` with length is found by search
// (a run of zero-length segments can be long) instead of a scan.
let base = first.checked_sub(1).and_then(|p| ends.get(p)).copied().unwrap_or(0.0);
let i = first + ends.get(first..).unwrap_or_default().partition_point(|e| *e <= base);
let i = (i < self.segs.len()).then_some(i);
if let Some(s) = i.and_then(|i| self.segs.get(i)) {
let start = i.and_then(|i| i.checked_sub(1)).and_then(|p| ends.get(p)).copied().unwrap_or(0.0);
let t = ((d - start) / s.len()).clamp(0.0, 1.0);
return Some((s.at(t), s.tangent(t)));
}
self.segs.last().map(|s| (s.end(), s.tangent(1.0)))
}
@@ -640,6 +658,34 @@ pub fn reverse_vertices(vs: &[PolyVertex], closed: bool) -> Vec<PolyVertex> {
mod tests {
use super::*;
/// The indexed lookup gives the point and tangent a scan from the start gives, also past the
/// ends and over a segment of no length.
#[test]
fn at_length_in_matches_a_scan() {
let l = |a: (f64, f64), b: (f64, f64)| Segment::Line(Line::new(Vec2::new(a.0, a.1), Vec2::new(b.0, b.1)));
let c = Chain {
segs: vec![l((0.0, 0.0), (0.0, 0.0)), l((0.0, 0.0), (4.0, 0.0)), l((4.0, 0.0), (4.0, 0.0)), l((4.0, 0.0), (4.0, 3.0))],
closed: false,
};
let ends = c.end_lengths();
for d in [-1.0, 0.0, 1.5, 4.0, 4.0 + 1e-13, 5.0, 7.0, 9.0] {
// The scan this replaced.
let mut acc = 0.0;
let mut want = c.segs.last().map(|s| (s.end(), s.tangent(1.0)));
for s in &c.segs {
let len = s.len();
if d <= acc + len + 1e-12 && len > 0.0 {
let t = ((d - acc) / len).clamp(0.0, 1.0);
want = Some((s.at(t), s.tangent(t)));
break;
}
acc += len;
}
assert_eq!(c.at_length_in(&ends, d), want, "d = {d}");
assert_eq!(c.at_length(d), want);
}
}
#[test]
fn arc_builders() {
let a = arc_sca(Vec2::new(1.0, 0.0), Vec2::ZERO, std::f64::consts::FRAC_PI_2).unwrap();
+509
View File
@@ -0,0 +1,509 @@
//! -DIMSTYLE, dimension styles at the command line (scripts, the keyboard): save the current
//! settings as a style (annotative or not), make a style current, list the current settings or
//! a style's or a dimension's, compare a style with the current one, give the current settings
//! to dimensions, list the styles. Also `dimstyle.overrides`, which sets the current style's
//! overrides (what the Dimension Style Manager's Override edits), in one undo step.
use cadcraft_doc::{DimStyle, Drawing, EntityKind, Handle};
use serde_json::{Value, json};
use super::machines::{SelOutcome, SelectPhase};
use super::{CommandSpec, bad, bool_or, curves, str_param, targets};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
const CMD: &str = "-dimstyle";
fn other(m: impl Into<String>) -> EngineError {
EngineError::Other(m.into())
}
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("-dimstyle", "Dimension Style", run)
.params(
"{option: save | annotative | restore | status | variables | apply | list, name?, handle?, handles?, replace?: bool, pattern?} \
→ save (annotative: an annotative style): the current settings (style and its overrides) as style `name`, made current \
(`replace` redefines one); restore: style `name` (or dimension `handle`'s style) made current; status: {variables} of the \
current settings; variables: {variables} of style `name` or dimension `handle`; apply: the current settings given to \
`handles` (default: the selection); list: {styles} matching `pattern` (*, ? and #)",
)
.interactive(|_| Ok(Box::new(DashDimStyle::default()))),
CommandSpec::new("dimstyle.overrides", "Dimension Style Overrides", run_overrides).params(
"{<style fields or DIM* variables: values>, clear?: bool} → {overrides} (the current style's overrides, which new \
dimensions take; `clear` drops them all first)",
),
]
}
/// What new dimensions are drawn with: the current style with its overrides.
fn current_settings(d: &Drawing) -> DimStyle {
let name = d.header.str("DIMSTYLE", "Standard");
let mut st = d.dim_style(&name).cloned().unwrap_or_default().with_overrides(&d.dim_overrides());
st.name = name;
st
}
/// A style's variables (DIM* name → value) as `dimstyle.list` reports them.
fn variables(st: &DimStyle) -> serde_json::Map<String, Value> {
let v = serde_json::to_value(st).unwrap_or(Value::Null);
cadcraft_doc::DIMVARS.iter().filter_map(|(var, field)| v.get(*field).map(|x| ((*var).to_string(), x.clone()))).collect()
}
/// A variable's value as the command line shows it.
fn shown(v: &Value) -> String {
if v.is_object()
&& let Ok(c) = serde_json::from_value::<cadcraft_color::Color>(v.clone())
{
return c.name();
}
match v {
Value::String(s) if s.is_empty() => "\"\"".into(),
Value::String(s) => s.clone(),
Value::Bool(b) => (if *b { "On" } else { "Off" }).into(),
other => other.to_string(),
}
}
/// One line per variable: name, value and what it is.
fn listing(vars: &serde_json::Map<String, Value>) -> Vec<String> {
cadcraft_doc::DIMVARS
.iter()
.filter_map(|(var, field)| {
let v = vars.get(*var)?;
let label = crate::properties::dim_prop(field).map_or(*field, |p| p.label);
Some(format!("{var:<10} {:<20} {label}", shown(v)))
})
.collect()
}
/// The variables of `b` that differ from `a`'s: (name, a's value, b's value).
fn differences(a: &DimStyle, b: &DimStyle) -> Vec<(String, Value, Value)> {
let (va, vb) = (variables(a), variables(b));
cadcraft_doc::DIMVARS
.iter()
.filter_map(|(var, _)| {
let (x, y) = (va.get(*var)?, vb.get(*var)?);
(x != y).then(|| ((*var).to_string(), x.clone(), y.clone()))
})
.collect()
}
/// `name` against a pattern with `*` (any run), `?` (any character) and `#` (a digit), ignoring
/// case: QSELECT's matcher, which takes time in proportion to the lengths (a pattern that backs
/// up at every `*` can't hang the command).
fn matches(pattern: &str, name: &str) -> bool {
let p = pattern.trim();
p.is_empty() || super::qselect::wildcard(p, name)
}
fn styles_matching(d: &Drawing, pattern: &str) -> Vec<String> {
d.dim_styles.iter().filter(|s| matches(pattern, &s.name)).map(|s| s.name.clone()).collect()
}
/// A usable dimension style name, trimmed: for -DIMSTYLE and `dimstyle.saveas` alike. No `~`,
/// which Restore reads as "compare with".
pub(super) fn check_name(name: &str) -> Result<String> {
let name = name.trim();
if !usable_dim_style_name(name) {
return Err(bad(CMD, "bad style name"));
}
Ok(name.to_string())
}
/// Whether `name` (trimmed) is one a new dimension style can have: what -DIMSTYLE,
/// `dimstyle.saveas`, `dimstyle` and `dimstyle.rename` take, for dialogs to check before OK.
pub fn usable_dim_style_name(name: &str) -> bool {
let name = name.trim();
!(name.is_empty() || name.len() > 255 || name.contains(['<', '>', '/', '\\', '"', ':', ';', '?', '*', '|', ',', '=', '`', '~']))
}
/// Save the current settings as style `name` and make it current.
fn save(s: &mut Session, name: &str, annotative: Option<bool>, replace: bool) -> Result<Value> {
let name = check_name(name)?;
// Refused before the drawing is touched: a failed call leaves no (empty) undo step.
if !replace && s.doc()?.dim_style(&name).is_some() {
return Err(bad(CMD, format!("a dimension style `{name}` already exists")));
}
let d = s.doc_mut()?;
let mut st = current_settings(d);
if let Some(a) = annotative {
st.annotative = a;
}
let name = match d.dim_styles.iter_mut().find(|x| x.name.eq_ignore_ascii_case(&name)) {
Some(existing) if replace => {
let kept = existing.name.clone();
*existing = DimStyle { name: kept.clone(), ..st };
kept
}
Some(_) => return Err(bad(CMD, format!("a dimension style `{name}` already exists"))),
None => {
d.dim_styles.push(DimStyle { name: name.clone(), ..st });
name
}
};
d.header.set_str("DIMSTYLE", &name);
d.sync_dim_vars();
// A redefined style redraws the dimensions that use it.
super::props::regen_dims(d, |dm| dm.style.eq_ignore_ascii_case(&name))?;
Ok(json!({ "style": name }))
}
/// Make style `name` current (its overrides go).
fn restore(s: &mut Session, name: &str) -> Result<Value> {
let n = s.doc()?.dim_style(name).map(|t| t.name.clone()).ok_or_else(|| bad(CMD, format!("no dimension style `{name}`")))?;
let d = s.doc_mut()?;
d.header.set_str("DIMSTYLE", &n);
d.sync_dim_vars();
Ok(json!({ "current": n }))
}
/// Give dimensions the current settings: the current style and its overrides.
fn apply(s: &mut Session, hs: &[Handle]) -> Result<Value> {
// The dimensions among them, found before the drawing is touched: none leaves no undo step.
let d = s.doc()?;
let dims: Vec<Handle> = hs.iter().copied().filter(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Dimension(_)))).collect();
if dims.is_empty() {
return Ok(json!({ "changed": 0 }));
}
let d = s.doc_mut()?;
let style = d.header.str("DIMSTYLE", "Standard");
let overrides = d.dim_overrides();
let mut n = 0;
for h in dims {
d.modify_entity(h, |e| {
if let EntityKind::Dimension(dm) = &mut e.kind {
dm.style.clone_from(&style);
dm.overrides.clone_from(&overrides);
dm.block = None;
n += 1;
}
})?;
}
Ok(json!({ "changed": n }))
}
/// The style and effective settings of dimension `h`.
fn dimension_settings(s: &Session, h: Handle) -> Result<DimStyle> {
let d = s.doc()?;
match d.entity(h).map(|e| &e.kind) {
Some(EntityKind::Dimension(dm)) => Ok(d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides)),
_ => Err(bad(CMD, "not a dimension")),
}
}
fn handle_param(p: &Value) -> Option<Handle> {
p.get("handle").and_then(|v| v.as_str().and_then(Handle::parse_hex).or_else(|| v.as_u64().map(Handle)))
}
fn run(s: &mut Session, p: &Value) -> Result<Value> {
let option = str_param(p, "option").unwrap_or("restore").trim().to_ascii_lowercase();
match option.as_str() {
"save" | "annotative" => {
let name = str_param(p, "name").ok_or_else(|| bad(CMD, "`name` is required"))?.to_string();
let anno = if option == "annotative" { Some(true) } else { p.get("annotative").and_then(Value::as_bool) };
save(s, &name, anno, bool_or(p, "replace", false))
}
"restore" => match handle_param(p) {
Some(h) => {
let name = dimension_settings(s, h)?.name;
restore(s, &name)
}
None => restore(s, str_param(p, "name").ok_or_else(|| bad(CMD, "`name` or `handle` is required"))?),
},
"status" => Ok(json!({ "variables": variables(&current_settings(s.doc()?)) })),
"variables" => {
let st = match handle_param(p) {
Some(h) => dimension_settings(s, h)?,
None => {
let name = str_param(p, "name").ok_or_else(|| bad(CMD, "`name` or `handle` is required"))?;
s.doc()?.dim_style(name).cloned().ok_or_else(|| bad(CMD, format!("no dimension style `{name}`")))?
}
};
Ok(json!({ "style": st.name, "variables": variables(&st) }))
}
"apply" => {
let hs = targets(s, p)?;
apply(s, &hs)
}
"list" | "?" => Ok(json!({ "styles": styles_matching(s.doc()?, str_param(p, "pattern").unwrap_or("*")) })),
_ => Err(bad(CMD, "`option` is save, annotative, restore, status, variables, apply or list")),
}
}
/// `dimstyle.overrides`: set the current style's overrides (the header DIM* variables).
fn run_overrides(s: &mut Session, p: &Value) -> Result<Value> {
let clear = bool_or(p, "clear", false);
let mut given = serde_json::Map::new();
for (k, v) in p.as_object().into_iter().flatten() {
if k == "clear" {
continue;
}
let field = DimStyle::field_name(k)
.filter(|f| !matches!(*f, "name" | "annotative"))
.ok_or_else(|| bad("dimstyle.overrides", format!("`{k}` is not a dimension variable")))?;
given.insert(field.to_string(), v.clone());
}
// Checked first (against the style alone when its overrides go), so nothing changes when
// one value is unusable: a command's error doesn't undo what it did.
let d = s.doc()?;
let mut base = current_settings(d);
if clear {
base = d.dim_style(&base.name).cloned().unwrap_or_default();
}
let rejected = base.apply_fields(&given);
if !rejected.is_empty() {
return Err(bad("dimstyle.overrides", format!("unusable values for {}", rejected.join(", "))));
}
// The values as the style took them (a lineweight named ByLayer is -1, ...): what the
// header variables hold, so writing them can't fail halfway.
let taken = serde_json::to_value(&base).unwrap_or(Value::Null);
if clear {
s.doc_mut()?.sync_dim_vars();
}
for (field, v) in &given {
let Some((var, _)) = cadcraft_doc::DIMVARS.iter().find(|(_, f)| f == field) else { continue };
let v = taken.get(field.as_str()).unwrap_or(v);
// Colors are stored as color numbers in the header.
let v = match serde_json::from_value::<cadcraft_color::Color>(v.clone()).ok().or_else(|| v.as_str().and_then(cadcraft_color::Color::parse)) {
Some(c) if field.ends_with("Color") => json!(c.to_aci()),
_ => v.clone(),
};
crate::sysvars::set(s, var, &v)?;
}
Ok(json!({ "overrides": s.doc()?.dim_overrides() }))
}
/// What -DIMSTYLE asks next.
#[derive(Clone, Default)]
enum Ask {
#[default]
Option,
Annotative,
SaveName {
annotative: Option<bool>,
},
Redefine {
name: String,
annotative: Option<bool>,
},
RestoreName,
RestorePick,
VariablesName,
VariablesPick,
Apply,
ListPattern,
}
#[derive(Default)]
struct DashDimStyle {
ask: Ask,
sel: SelectPhase,
}
impl DashDimStyle {
fn list(&self, s: &mut Session, pattern: &str) -> Result<()> {
let names = styles_matching(s.doc()?, pattern);
s.echo(format!("Named dimension styles: {}", if names.is_empty() { "none".into() } else { names.join(", ") }));
Ok(())
}
fn show_variables(&self, s: &mut Session, st: &DimStyle) {
s.echo(format!("Dimension style: {}", st.name));
for line in listing(&variables(st)) {
s.echo(line);
}
}
fn answer(&mut self, s: &mut Session, i: Input) -> Result<Step> {
let ask = std::mem::take(&mut self.ask);
let text = match &i {
Input::Text(t) | Input::Keyword(t) => Some(t.trim().to_string()),
_ => None,
};
match ask {
Ask::Option => {
let k = text.unwrap_or_else(|| "Restore".into());
self.ask = match k.to_ascii_lowercase().as_str() {
"annotative" | "an" => Ask::Annotative,
"save" | "s" => Ask::SaveName { annotative: None },
"restore" | "r" | "" => Ask::RestoreName,
"status" | "st" => {
let st = current_settings(s.doc()?);
self.show_variables(s, &st);
return Ok(Step::Done);
}
"variables" | "v" => Ask::VariablesName,
"apply" | "a" => Ask::Apply,
"?" => Ask::ListPattern,
_ => return Err(other("Enter one of the options.")),
};
Ok(Step::Continue)
}
Ask::Annotative => {
let yes = !matches!(text.as_deref().map(str::to_ascii_lowercase).as_deref(), Some("no" | "n"));
self.ask = Ask::SaveName { annotative: Some(yes) };
Ok(Step::Continue)
}
Ask::SaveName { annotative } => match text.as_deref() {
None | Some("") => Ok(Step::Done),
Some("?") => {
self.list(s, "*")?;
self.ask = Ask::SaveName { annotative };
Ok(Step::Continue)
}
Some(name) => {
let name = match check_name(name) {
Ok(n) => n,
Err(e) => {
self.ask = Ask::SaveName { annotative };
return Err(e);
}
};
if s.doc()?.dim_style(&name).is_some() {
self.ask = Ask::Redefine { name, annotative };
return Ok(Step::Continue);
}
save(s, &name, annotative, false)?;
Ok(Step::Done)
}
},
Ask::Redefine { name, annotative } => {
if matches!(text.as_deref().map(str::to_ascii_lowercase).as_deref(), Some("yes" | "y")) {
save(s, &name, annotative, true)?;
Ok(Step::Done)
} else {
self.ask = Ask::SaveName { annotative };
Ok(Step::Continue)
}
}
Ask::RestoreName => match text.as_deref() {
None | Some("") => {
self.ask = Ask::RestorePick;
Ok(Step::Continue)
}
Some("?") => {
self.list(s, "*")?;
self.ask = Ask::RestoreName;
Ok(Step::Continue)
}
// ~name: how style `name` differs from the current settings.
Some(t) if t.starts_with('~') => {
let d = s.doc()?;
let other_style = d.dim_style(t.trim_start_matches('~').trim()).cloned().ok_or_else(|| other("No such dimension style."))?;
let current = current_settings(d);
let diff = differences(&current, &other_style);
s.echo(format!("Differences between {} and current settings:", other_style.name));
if diff.is_empty() {
s.echo("None".to_string());
}
for (var, cur, theirs) in diff {
s.echo(format!("{var:<10} {:<20} {}", shown(&theirs), shown(&cur)));
}
self.ask = Ask::RestoreName;
Ok(Step::Continue)
}
Some(name) => {
if let Err(e) = restore(s, name) {
self.ask = Ask::RestoreName;
return Err(e);
}
Ok(Step::Done)
}
},
Ask::RestorePick | Ask::VariablesPick => {
let restoring = matches!(ask, Ask::RestorePick);
let Input::Point(p) = i else {
if matches!(i, Input::Enter) {
return Ok(Step::Done);
}
// Anything else asks for the dimension again.
self.ask = ask;
return Ok(Step::Continue);
};
let picked = curves::pick_at(s, p).and_then(|h| dimension_settings(s, h).ok());
let Some(st) = picked else {
self.ask = if restoring { Ask::RestorePick } else { Ask::VariablesPick };
return Err(other("Select a dimension."));
};
if restoring {
restore(s, &st.name)?;
} else {
self.show_variables(s, &st);
}
Ok(Step::Done)
}
Ask::VariablesName => match text.as_deref() {
None | Some("") => {
self.ask = Ask::VariablesPick;
Ok(Step::Continue)
}
Some("?") => {
self.list(s, "*")?;
self.ask = Ask::VariablesName;
Ok(Step::Continue)
}
Some(name) => {
let Some(st) = s.doc()?.dim_style(name).cloned() else {
self.ask = Ask::VariablesName;
return Err(other("No such dimension style."));
};
self.show_variables(s, &st);
Ok(Step::Done)
}
},
Ask::Apply => match self.sel.feed(s, &i)? {
SelOutcome::More => {
self.ask = Ask::Apply;
Ok(Step::Continue)
}
SelOutcome::Empty => Ok(Step::Done),
SelOutcome::Done(hs) => {
let r = apply(s, &hs)?;
s.echo(format!("{} dimension(s) take the current settings.", r["changed"]));
s.set_selection(Vec::new());
Ok(Step::Done)
}
},
Ask::ListPattern => {
self.list(s, text.as_deref().filter(|t| !t.is_empty()).unwrap_or("*"))?;
Ok(Step::Done)
}
}
}
}
impl Interactive for DashDimStyle {
fn name(&self) -> &'static str {
"-DIMSTYLE"
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
let d = s.doc()?;
let current = d.header.str("DIMSTYLE", "Standard");
let annotative = d.dim_style(&current).is_some_and(|st| st.annotative);
let overridden = if d.dim_overrides().is_empty() { "" } else { " (with overrides)" };
s.echo(format!("Current dimension style: {current}{overridden} Annotative: {}", if annotative { "Yes" } else { "No" }));
Ok(Step::Continue)
}
fn prompt(&self, _s: &Session) -> Prompt {
match &self.ask {
Ask::Option => Prompt::new("Enter a dimension style option", curves::KW)
.kw(&["ANnotative", "Save", "Restore", "STatus", "Variables", "Apply", "?"])
.default("Restore"),
Ask::Annotative => Prompt::new("Create annotative dimension style", curves::KW).kw(&["Yes", "No"]).default("Yes"),
Ask::SaveName { .. } => Prompt::new("Enter name for new dimension style or [?]", Accept::TEXT).kw(&["?"]),
Ask::Redefine { .. } => Prompt::new("That name is already in use, redefine it?", curves::KW).kw(&["Yes", "No"]).default("No"),
Ask::RestoreName => Prompt::new("Enter a dimension style name, [?] or <select dimension>", Accept::TEXT).kw(&["?"]),
Ask::RestorePick | Ask::VariablesPick => Prompt::new("Select dimension", Accept::POINT),
Ask::VariablesName => Prompt::new("Enter a dimension style name, [?] or <select dimensions>", Accept::TEXT).kw(&["?"]),
Ask::Apply => self.sel.prompt(),
Ask::ListPattern => Prompt::new("Enter dimension style(s) to list", Accept::TEXT).default("*"),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
// A refused answer asks the same question again.
let asked = self.ask.clone();
let r = self.answer(s, i);
if r.is_err() {
self.ask = asked;
}
r
}
}
+108
View File
@@ -0,0 +1,108 @@
//! Dimension style commands of the dimension shortcut menu: Remove Style Overrides (DIMOVERRIDE
//! Clear for the selected dimensions) and Save as New Style (a style made of a dimension's
//! settings, its overrides included, which the dimension then uses).
use cadcraft_doc::{DimStyle, EntityKind, Handle};
use serde_json::{Value, json};
use super::machines::SelectRun;
use super::{CommandSpec, bad, curves, str_param, targets};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
fn other(m: impl Into<String>) -> EngineError {
EngineError::Other(m.into())
}
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("dimoverride.clear", "Remove Style Overrides", run_clear)
.params("{handles?} (dimensions; they draw with their style's settings again) → {changed}")
.interactive(|_| Ok(Box::new(SelectRun::new("dimoverride.clear", "DIMOVERRIDE")))),
CommandSpec::new("dimstyle.saveas", "Save as New Style...", run_save_as)
.params(
"{handle? (default: the first selected dimension), name} → {style, handle} (a new dimension style with the dimension's \
settings, overrides included; the dimension takes it and its overrides are cleared; the current style is unchanged)",
)
.interactive(|_| Ok(Box::new(SaveAsM::default()))),
]
}
fn run_clear(s: &mut Session, p: &Value) -> Result<Value> {
let hs: Vec<String> = targets(s, p)?.iter().map(|h| h.hex()).collect();
super::props::dim_override(s, &json!({ "handles": hs, "clear": true }))
}
fn is_dim(s: &Session, h: Handle) -> bool {
s.doc().ok().and_then(|d| d.entity(h)).is_some_and(|e| matches!(e.kind, EntityKind::Dimension(_)))
}
/// A usable new dimension style name (as -DIMSTYLE takes one).
fn new_name(s: &Session, name: &str) -> Result<String> {
let name = super::dimstyle_cli::check_name(name).map_err(|_| bad("dimstyle.saveas", "bad style name"))?;
if s.doc()?.dim_style(&name).is_some() {
return Err(bad("dimstyle.saveas", format!("a dimension style `{name}` already exists")));
}
Ok(name)
}
/// Make style `name` from dimension `h`'s settings and give it to the dimension.
fn save_as(s: &mut Session, h: Handle, name: &str) -> Result<Value> {
let name = new_name(s, name)?;
let d = s.doc_mut()?;
let Some(EntityKind::Dimension(dm)) = d.entity(h).map(|e| e.kind.clone()) else { return Err(bad("dimstyle.saveas", "not a dimension")) };
let st = d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides);
d.dim_styles.push(DimStyle { name: name.clone(), ..st });
d.modify_entity(h, |e| {
if let EntityKind::Dimension(dm) = &mut e.kind {
dm.style.clone_from(&name);
dm.overrides.clear();
dm.block = None;
}
})?;
Ok(json!({ "style": name, "handle": h.hex() }))
}
fn run_save_as(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "name").ok_or_else(|| bad("dimstyle.saveas", "`name` is required"))?.to_string();
let hs = targets(s, p)?;
let h = hs.into_iter().find(|h| is_dim(s, *h)).ok_or_else(|| bad("dimstyle.saveas", "select a dimension"))?;
save_as(s, h, &name)
}
/// Save as New Style: the selected dimension (or one picked), then the new style's name.
#[derive(Default)]
struct SaveAsM {
dim: Option<Handle>,
}
impl Interactive for SaveAsM {
fn name(&self) -> &'static str {
"DIMSTYLE"
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
self.dim = s.selection().into_iter().find(|h| is_dim(s, *h));
Ok(Step::Continue)
}
fn prompt(&self, _s: &Session) -> Prompt {
match self.dim {
None => Prompt::new("Select a dimension", Accept::POINT),
Some(_) => Prompt::new("Enter name of new dimension style", Accept::TEXT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.dim, i) {
(None, Input::Point(p)) => {
let h = curves::pick_at(s, p).filter(|h| is_dim(s, *h)).ok_or_else(|| other("Select a dimension."))?;
self.dim = Some(h);
Ok(Step::Continue)
}
(Some(h), Input::Text(t) | Input::Keyword(t)) => {
let r = save_as(s, h, &t)?;
s.echo(format!("Dimension style {} created from the dimension.", r["style"].as_str().unwrap_or_default()));
Ok(Step::Done)
}
(_, Input::Enter) => Ok(Step::Done),
_ => Ok(Step::Continue),
}
}
}
+2 -1
View File
@@ -33,8 +33,9 @@ use point::{DonutM, PointM, RayM, run_donut, run_point, run_ray};
use polygon::{PolygonM, run_polygon};
use solid::{SolidM, run_solid};
use spline::{SplineM, run_spline};
pub(crate) use text::justify;
use text::{MTextM, TextM, run_mtext, run_text};
pub(crate) use text::{justify, justify_prompt};
/// Every draw command's spec: JSON parameters, menu path, aliases and the interactive prompt
/// machine each command starts.
+11 -2
View File
@@ -25,6 +25,16 @@ pub(crate) fn justify(j: &str) -> Option<(HAlign, VAlign)> {
})
}
/// The justification options TEXT offers, in prompt order.
const JUSTIFY_OPTIONS: [&str; 15] = ["Left", "Center", "Right", "Align", "Middle", "Fit", "TL", "TC", "TR", "ML", "MC", "MR", "BL", "BC", "BR"];
/// The prompt for a justification option. Align and Fit run between two baseline points, so a
/// command that takes one point (`-ATTDEF`) passes `two_points: false` and doesn't list them.
pub(crate) fn justify_prompt(two_points: bool) -> Prompt {
let options: Vec<&str> = JUSTIFY_OPTIONS.into_iter().filter(|o| two_points || !matches!(*o, "Align" | "Fit")).collect();
Prompt::new("Enter an option", Accept::TEXT).kw(&options)
}
pub(crate) fn make_text(s: &Session, at: Vec2, value: &str, height: f64, rotation: f64, j: (HAlign, VAlign)) -> EntityKind {
let style = s.doc().map(|d| d.header.str("TEXTSTYLE", "Standard")).unwrap_or_else(|_| "Standard".into());
let (h, v) = j;
@@ -119,8 +129,7 @@ impl Interactive for TextM {
fn prompt(&self, s: &Session) -> Prompt {
let th = s.doc().map(|d| d.header.f64("TEXTSIZE", 0.2)).unwrap_or(0.2);
if self.asking_justify {
return Prompt::new("Enter an option", Accept::TEXT)
.kw(&["Left", "Center", "Right", "Align", "Middle", "Fit", "TL", "TC", "TR", "ML", "MC", "MR", "BL", "BC", "BR"]);
return justify_prompt(true);
}
match (self.at, self.height, self.rotation) {
(None, _, _) => Prompt::new("Specify start point of text", Accept::POINT).kw(&["Justify", "Style"]),
+1 -1
View File
@@ -20,7 +20,7 @@ use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, St
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("breakline", "Break-line Symbol", run_breakline)
.menu(&["Tools", "Express Tools", "Break-line Symbol"])
.menu(&["Tools", "Additional Tools", "Break-line Symbol"])
.params(
"{p1, p2, at?: [x,y] (symbol location; default the midpoint), size? (default 1, times DIMSCALE), \
extension? (past both points; default 0), block? (a block with two points on Defpoints; default the built-in symbol)} → {handle}",
+4 -2
View File
@@ -36,16 +36,18 @@ fn check_block(s: &Session, b: Option<&str>) -> Result<()> {
pub(crate) fn divide_points(c: &Chain, n: usize) -> Vec<(Vec2, Vec2)> {
let l = c.len();
let range = if c.closed { 0..n } else { 1..n };
range.filter_map(|i| c.at_length(l * i as f64 / n as f64)).collect()
let ends = c.end_lengths();
range.filter_map(|i| c.at_length_in(&ends, l * i as f64 / n as f64)).collect()
}
pub(crate) fn measure_points(c: &Chain, step: f64) -> Vec<(Vec2, Vec2)> {
let l = c.len();
let ends = c.end_lengths();
let mut out = Vec::new();
let mut k = 1usize;
while (k as f64) * step < l - 1e-9 && out.len() < MAX_GEN {
let d = k as f64 * step;
out.extend(c.at_length(d));
out.extend(c.at_length_in(&ends, d));
k += 1;
}
out
+2 -1
View File
@@ -58,8 +58,9 @@ pub(crate) fn cloud_vertices(boundary: &[Vec2], arc_len: f64, per_edge: bool, re
closed: true,
};
let k = ((perim / arc_len).round() as usize).clamp(3, MAX_GEN);
let ends = chain.end_lengths();
for j in 0..k {
out.extend(chain.at_length(perim * j as f64 / k as f64).map(|x| x.0));
out.extend(chain.at_length_in(&ends, perim * j as f64 / k as f64).map(|x| x.0));
}
}
let b = if reverse { -0.5 } else { 0.5 };
+15 -6
View File
@@ -557,9 +557,15 @@ fn run_clear(s: &mut Session, _p: &Value) -> Result<Value> {
fn run_selectall(s: &mut Session, _p: &Value) -> Result<Value> {
let space = s.space();
let d = s.doc()?;
let frozen = s.viewport_frozen();
let hs: Vec<Handle> = d
.space(&space)
.map(|st| st.iter().filter(|e| d.is_visible(e) && d.layer(&e.common.layer).is_none_or(|l| !l.locked)).map(|e| e.handle).collect())
.map(|st| {
st.iter()
.filter(|e| crate::select::selectable(d, e, frozen) && d.layer(&e.common.layer).is_none_or(|l| !l.locked))
.map(|e| e.handle)
.collect()
})
.unwrap_or_default();
let n = hs.len();
s.set_selection(hs);
@@ -580,16 +586,19 @@ fn run_select(s: &mut Session, p: &Value) -> Result<Value> {
let add = bool_or(p, "add", false);
let picked: Vec<Handle> = if let Some(w) = points_param(p, "window") {
let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("select", "window needs 2 corners")) };
crate::select::select_window(s.doc()?, &space, Bounds2::new(*a, *b), bool_or(p, "crossing", false))
crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), Bounds2::new(*a, *b), bool_or(p, "crossing", false))
} else if let Some(at) = point_param(p, "at") {
let ap = f64_or(p, "aperture", s.pixel_size() * s.settings.pickbox * 1.5);
crate::select::pick(s.doc()?, &space, at, ap).into_iter().collect()
crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), at, ap).into_iter().collect()
} else if let Some(f) = points_param(p, "fence") {
crate::select::select_fence(s.doc()?, &space, &f)
} else {
crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &f)
} else if ["handles", "handle"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null())) {
targets(s, p)?
} else {
// Nothing to select with: the selection stays, also what the active viewport does not draw.
s.stored_selection()
};
let mut sel = if add { s.selection() } else { Vec::new() };
let mut sel = if add { s.stored_selection() } else { Vec::new() };
sel.extend(picked);
s.set_selection(sel);
let sel = s.selection();
+3 -2
View File
@@ -204,7 +204,8 @@ fn import_drawing(s: &mut Session, src: &Drawing, at: Vec2, scale: f64, file: &s
fn read_file(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
std::fs::read(_path).map_err(|e| bad("import", format!("{_path}: {e}")))
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
.map_err(|e| bad("import", format!("{_path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
Err(bad("import", "paths are not available on the web; pass `data`"))
@@ -362,7 +363,7 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
let (a, b) = (screen(Vec2::new(min.x, max.y)), screen(Vec2::new(max.x, min.y)));
cadcraft_render::raster::blank_outside_pixels(&mut pm, a, b);
}
let png = pm.encode_png().map_err(|_| bad("preview", "rendering the preview failed"))?;
let png = cadcraft_render::raster::encode_png(&pm).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
let layout = space.tab_name();
Ok(json!({ "data": base64_encode(&png), "width": w, "height": h, "layout": layout, "paper": page.paper, "landscape": page.landscape }))
}
+126 -56
View File
@@ -8,7 +8,7 @@ mod template;
use std::sync::OnceLock;
use cadcraft_doc::{Drawing, Format};
pub use cadcraft_dxf::Version;
pub use craft_dxf::Version;
use serde_json::{Value, json};
use super::{CommandSpec, EngineError, Interactive, always, bad, bool_or, find_command, ok, str_param};
@@ -16,15 +16,15 @@ use super::{CommandSpec, EngineError, Interactive, always, bad, bool_or, find_co
use crate::{Accept, Input, Prompt, Result, Session, Step};
/// The rules the Command Aliases dialog checks before it sends an alias to ALIASEDIT.
pub use pgp::{MAX_ALIASES, alias_name, command_id};
pub(crate) use pgp::{specs as alias_specs, user_alias};
pub use pgp::{MAX_ALIAS_PROFILE_BYTES, MAX_ALIASES, alias_name, alias_profile, command_id, restore_aliases};
pub(crate) use pgp::{greek_alias, specs as alias_specs, user_alias};
pub use template::{qnew_template, set_qnew_template};
/// Largest drawing accepted from a local path, matching the per-file xref limit. A path naming an
/// endless device must be rejected before it exhausts memory (CWE-400), so native opens read
/// through [`crate::capped_read`] rather than buffering to EOF.
#[cfg(not(target_arch = "wasm32"))]
const MAX_DRAWING_BYTES: usize = 512 << 20;
pub(crate) const MAX_DRAWING_BYTES: usize = 512 << 20;
/// Largest `.scr` script accepted from a local path.
#[cfg(not(target_arch = "wasm32"))]
const MAX_SCRIPT_BYTES: usize = 64 << 20;
@@ -53,9 +53,9 @@ pub fn io() -> Option<&'static IoHooks> {
/// (installed by the app with the DXF reader and writer, a lower layer).
pub struct EntityCodec {
/// The entity's type name and the groups of its record, without its `0` group.
pub groups: fn(&Drawing, &cadcraft_doc::Entity) -> (String, Vec<cadcraft_dxf::Tag>),
pub groups: fn(&Drawing, &cadcraft_doc::Entity) -> (String, Vec<craft_dxf::Tag>),
/// An entity from a type name and groups.
pub entity: fn(&str, &[cadcraft_dxf::Tag]) -> Option<(cadcraft_doc::Common, cadcraft_doc::EntityKind)>,
pub entity: fn(&str, &[craft_dxf::Tag]) -> Option<(cadcraft_doc::Common, cadcraft_doc::EntityKind)>,
}
static CODEC: OnceLock<EntityCodec> = OnceLock::new();
@@ -67,6 +67,22 @@ pub fn entity_codec() -> Option<&'static EntityCodec> {
CODEC.get()
}
/// The drawing's non-graphic records as written (tables, BLOCK records, objects): each one's
/// type, groups after the type and role (see [`cadcraft_doc::foreign::ForeignKey`]). AutoLISP's
/// `namedobjdict`, `tblobjname` and `handent` of non-graphic objects read them (installed by the
/// app with the DXF writer, a lower layer; kept apart from [`EntityCodec`] so hosts that only
/// need entities don't have to provide it).
pub type ObjectRecords = fn(&Drawing) -> Vec<(String, Vec<craft_dxf::Tag>, Option<cadcraft_doc::foreign::ForeignKey>)>;
static OBJECT_RECORDS: OnceLock<ObjectRecords> = OnceLock::new();
pub fn set_object_records(f: ObjectRecords) {
let _ = OBJECT_RECORDS.set(f);
}
pub fn object_records() -> Option<ObjectRecords> {
OBJECT_RECORDS.get().copied()
}
/// COMPARE (drawing comparison).
pub mod compare;
@@ -340,7 +356,7 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
}
Ok(ReadFile { drawing, binary_dxf: cadcraft_dxf::is_binary(bytes), name: name.to_string(), path })
Ok(ReadFile { drawing, binary_dxf: craft_dxf::is_binary(bytes), name: name.to_string(), path })
}
fn add_read(s: &mut Session, drawing: Drawing, binary_dxf: bool, name: &str, path: Option<String>) -> usize {
@@ -408,6 +424,7 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
}
s.cancel();
s.docs.remove(i);
s.lisp_forget_closed();
if i < s.active {
// An earlier drawing went away: the active one shifted down by one.
s.active -= 1;
@@ -423,6 +440,7 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
fn run_closeall(s: &mut Session, _p: &Value) -> Result<Value> {
s.cancel();
s.docs.clear();
s.lisp_forget_closed();
s.active = 0;
s.bump_doc_epoch();
ok()
@@ -503,7 +521,7 @@ pub fn backup_path(path: &std::path::Path) -> std::path::PathBuf {
pub fn looks_like_drawing(bytes: &[u8]) -> bool {
// DWG: a version tag like `AC1032` (R12 is `AC1009`).
let dwg = bytes.len() >= 6 && bytes.starts_with(b"AC") && bytes[2..6].iter().all(|b| b.is_ascii_digit());
if dwg || cadcraft_dxf::is_binary(bytes) {
if dwg || craft_dxf::is_binary(bytes) {
return true;
}
// ASCII DXF: optional comments (999), then group 0 SECTION.
@@ -533,7 +551,7 @@ pub fn completeness(head: &[u8], tail: &[u8], len: u64) -> Option<bool> {
// Too short for any DWG's header: cut off, not unknown.
return if head.len() < 256 { Some(false) } else { dwg_complete(head, len) };
}
if cadcraft_dxf::is_binary(head) {
if craft_dxf::is_binary(head) {
return Some(tail.ends_with(b"EOF\0"));
}
let text = String::from_utf8_lossy(tail);
@@ -625,6 +643,40 @@ pub fn save_keeps_current(_path: &std::path::Path) -> bool {
false
}
/// The mode of a new backup: no more open than the drawing (`src_mode`, group `src_gid`) nor than the
/// `.bak` it replaces (`old`: mode and group). The backup keeps the old `.bak`'s group, so when that
/// differs from the drawing's group, its group bits are dropped and its other bits are capped by
/// the drawing's group bits: a member of the drawing's group must not gain access through `other`.
#[cfg(unix)]
fn backup_mode(src_mode: u32, src_gid: u32, old: Option<(u32, u32)>) -> u32 {
let mut mode = src_mode & 0o777;
if let Some((old_mode, old_gid)) = old {
mode &= old_mode;
if old_gid != src_gid {
mode = without_group(src_mode, mode);
}
}
mode
}
/// `mode` for a backup that is not in the drawing's group: no group bits, and `other` capped by the
/// drawing's group bits (`src_mode`).
#[cfg(unix)]
fn without_group(src_mode: u32, mode: u32) -> u32 {
(mode & !0o070) & (!0o007 | ((src_mode & 0o070) >> 3))
}
/// A first backup is created in the process's (or folder's) group, not the drawing's: move it to the
/// drawing's group before any data is written, else drop its group bits ([`without_group`]).
#[cfg(unix)]
fn adopt_source_group(out: &std::fs::File, src: &std::fs::Metadata) -> std::io::Result<()> {
use std::os::unix::fs::{MetadataExt, PermissionsExt, fchown};
if out.metadata()?.gid() == src.gid() || fchown(out, None, Some(src.gid())).is_ok() {
return Ok(());
}
out.set_permissions(std::fs::Permissions::from_mode(without_group(src.mode(), src.mode() & 0o777)))
}
/// Before `path` is replaced: copy it to its `.bak`, streamed and written atomically too
/// ([`crate::atomic_write::write_atomic_with`]). Nothing
/// to keep when there is no file yet. A file that doesn't look like a drawing
@@ -648,19 +700,23 @@ fn backup(path: &std::path::Path) -> std::io::Result<()> {
// failed write leaves the old .bak as it was; a symlink at the .bak is replaced, never
// written through.
#[cfg(unix)]
let permissions = {
use std::os::unix::fs::PermissionsExt;
let mut mode = src.metadata()?.permissions().mode() & 0o777;
if let Ok(m) = std::fs::symlink_metadata(&bak)
&& m.is_file()
{
mode &= m.permissions().mode();
}
Some(std::fs::Permissions::from_mode(mode))
let source_metadata = src.metadata()?;
#[cfg(unix)]
let first_backup = std::cell::Cell::new(false);
#[cfg(unix)]
let permissions = || {
use std::os::unix::fs::{MetadataExt, PermissionsExt};
let old = std::fs::symlink_metadata(&bak).ok().filter(|m| m.is_file());
first_backup.set(old.is_none());
Ok(Some(std::fs::Permissions::from_mode(backup_mode(source_metadata.mode(), source_metadata.gid(), old.map(|m| (m.mode(), m.gid()))))))
};
#[cfg(not(unix))]
let permissions = None;
crate::atomic_write::write_atomic_with(&bak, permissions, |out| {
let permissions = || Ok(None);
crate::atomic_write::write_atomic_with_permissions(&bak, permissions, |out| {
#[cfg(unix)]
if first_backup.get() {
adopt_source_group(out, &source_metadata)?;
}
std::io::Write::write_all(out, &head)?;
std::io::copy(&mut src, out).map(|_| ())
})
@@ -982,46 +1038,14 @@ fn run_saveas_reporting(s: &mut Session, p: &Value) -> Result<Value> {
save_reporting(s, p, run_saveas, asked)
}
const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// Encode bytes with the standard padded Base64 alphabet.
pub fn base64_encode(data: &[u8]) -> String {
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
for chunk in data.chunks(3) {
let b = [chunk.first().copied().unwrap_or(0), chunk.get(1).copied().unwrap_or(0), chunk.get(2).copied().unwrap_or(0)];
let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
for i in 0..4 {
if i <= chunk.len() {
out.push(char::from(B64[((n >> (18 - 6 * i)) & 63) as usize]));
} else {
out.push('=');
}
}
}
out
craft_mime::base64::STANDARD.encode(data)
}
/// Decode the legacy file/control Base64 form, retaining its permissive alphabet and padding.
pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
let mut out = Vec::with_capacity(s.len() * 3 / 4);
let mut buf = 0u32;
let mut bits = 0;
for c in s.bytes() {
let v = match c {
b'A'..=b'Z' => c - b'A',
b'a'..=b'z' => c - b'a' + 26,
b'0'..=b'9' => c - b'0' + 52,
b'+' | b'-' => 62,
b'/' | b'_' => 63,
b'=' | b'\n' | b'\r' | b' ' => continue,
_ => return None,
};
buf = (buf << 6) | u32::from(v);
bits += 6;
if bits >= 8 {
bits -= 8;
out.push(((buf >> bits) & 0xff) as u8);
}
}
Some(out)
craft_mime::base64_compat::decode(s).ok()
}
#[cfg(test)]
@@ -1031,6 +1055,52 @@ mod tests {
use crate::Session;
use crate::temp_dir::TempDir;
/// A backup is never more open than the drawing or the old `.bak`, and loses the group bits when
/// it would keep the old `.bak`'s group while the drawing is in another.
#[cfg(unix)]
#[test]
fn backup_mode_drops_group_bits_for_a_different_group() {
use super::backup_mode;
assert_eq!(backup_mode(0o640, 10, None), 0o640);
assert_eq!(backup_mode(0o640, 10, Some((0o664, 10))), 0o640);
assert_eq!(backup_mode(0o640, 10, Some((0o664, 20))), 0o600);
assert_eq!(backup_mode(0o644, 10, Some((0o644, 20))), 0o604);
assert_eq!(backup_mode(0o600, 10, Some((0o664, 10))), 0o600);
}
/// With no `.bak` yet, the first backup takes the drawing's group (when the user is in another
/// group, as `id -G` says), never the group the new file would be created in.
#[cfg(unix)]
#[test]
fn first_backup_takes_the_drawings_group() {
use std::os::unix::fs::{MetadataExt, PermissionsExt, chown};
let dir = TempDir::new("first-bak-grp");
let src = dir.join("a.dxf");
std::fs::write(&src, "0\nSECTION\n2\nHEADER\n0\nENDSEC\n0\nEOF\n").unwrap();
std::fs::set_permissions(&src, std::fs::Permissions::from_mode(0o640)).unwrap();
let own = std::fs::metadata(&src).unwrap().gid();
let other = std::process::Command::new("id")
.arg("-G")
.output()
.ok()
.and_then(|o| String::from_utf8_lossy(&o.stdout).split_whitespace().filter_map(|g| g.parse::<u32>().ok()).find(|g| *g != own));
if let Some(gid) = other {
chown(&src, None, Some(gid)).unwrap();
}
super::backup(&src).unwrap();
let (s, b) = (std::fs::metadata(&src).unwrap(), std::fs::metadata(super::backup_path(&src)).unwrap());
assert_eq!((b.gid(), b.mode() & 0o777), (s.gid(), 0o640));
}
/// The fail-safe when the group cannot be adopted: no group bits, `other` capped by the group's.
#[cfg(unix)]
#[test]
fn without_group_drops_group_bits_and_caps_other() {
assert_eq!(super::without_group(0o640, 0o640), 0o600);
assert_eq!(super::without_group(0o604, 0o604), 0o600);
assert_eq!(super::without_group(0o644, 0o644), 0o604);
}
fn active_title(s: &Session) -> String {
s.state().unwrap().title.clone()
}
+13 -9
View File
@@ -8,7 +8,7 @@ use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::sync::Arc;
use cadcraft_doc::{Drawing, Entity, EntityKind, Handle, MAX_BLOCK_DEPTH, Space, entity_bounds};
use cadcraft_doc::{BlockBoundsCache, Drawing, Entity, EntityKind, Handle, MAX_BLOCK_DEPTH, Space, entity_bounds_cached};
use cadcraft_geom::{Bounds2, Vec2};
use serde_json::{Value, json};
@@ -110,7 +110,7 @@ fn other_drawing(s: &Session, p: &Value) -> Result<(Arc<Drawing>, String)> {
fn read_path(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
std::fs::read(_path).map_err(|e| bad("compare", format!("{_path}: {e}")))
crate::capped_read::read_capped(std::path::Path::new(_path), super::MAX_DRAWING_BYTES).map_err(|e| bad("compare", format!("{_path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
Err(bad("compare", "paths are not available on the web: open the other drawing and compare with it by name (`document`)"))
@@ -375,16 +375,20 @@ fn run_compare(s: &mut Session, p: &Value) -> Result<Value> {
}
let Diff { added, removed, changed, common, truncated } = diff(&cur, &other, &space);
let mut boxes = Vec::new();
let mut bound = |d: &Drawing, h: Handle| {
if let Some(b) = d.entity(h).map(|e| entity_bounds(d, e, 0)).filter(|b| !b.is_empty() && b.min.is_finite() && b.max.is_finite()) {
// One block-bounds cache for each drawing, so a block many differing entities refer to is
// measured once, not once per entity.
let (mut cur_cache, mut other_cache) = (BlockBoundsCache::default(), BlockBoundsCache::default());
fn bound<'a>(boxes: &mut Vec<Bounds2>, d: &'a Drawing, h: Handle, cache: &mut BlockBoundsCache<'a>) {
if let Some(b) = d.entity(h).map(|e| entity_bounds_cached(d, e, 0, cache)).filter(|b| !b.is_empty() && b.min.is_finite() && b.max.is_finite())
{
boxes.push(b);
}
};
added.iter().for_each(|h| bound(&cur, *h));
removed.iter().for_each(|h| bound(&other, *h));
}
added.iter().for_each(|h| bound(&mut boxes, &cur, *h, &mut cur_cache));
removed.iter().for_each(|h| bound(&mut boxes, &other, *h, &mut other_cache));
for (a, b, _, _) in &changed {
bound(&cur, *a);
bound(&other, *b);
bound(&mut boxes, &cur, *a, &mut cur_cache);
bound(&mut boxes, &other, *b, &mut other_cache);
}
let regions = regions(&boxes);
let ch: Vec<Value> = changed
+89 -2
View File
@@ -1,11 +1,16 @@
//! The user's command alias file (the publicly documented `.pgp` format: `ALIAS, *COMMAND` lines,
//! `;` comments): ALIASEDIT and REINIT.
//!
//! A loaded file adds aliases or overrides the built-in ones for the rest of the session, for
//! every drawing; command names themselves always win. Lines that define external commands
//! A loaded file replaces the user aliases, which add to or override the built-in ones for every
//! drawing; command names themselves always win. Lines that define external commands
//! (programs the file would have the application start) are never run: they are skipped with a
//! note. CADCraft ships no alias file; the aliases built into the command catalog stay the
//! defaults.
//!
//! The aliases are user settings, never part of a drawing: [`alias_profile`] gives them (and the
//! file REINIT reads) to the host's user profile, and [`restore_aliases`] brings them back on the
//! next start. The desktop and web hosts keep that profile; the headless CLI has no profile, so
//! aliases set in a script last for that session only.
use std::collections::BTreeMap;
use std::sync::{Mutex, MutexGuard, OnceLock, PoisonError};
@@ -20,10 +25,21 @@ use super::{CommandSpec, Result, Session, bad, bool_or, find_command};
pub const MAX_ALIASES: usize = 10_000;
/// Longest alias name.
const MAX_ALIAS_CHARS: usize = 64;
/// Longest command id (the catalog's longest is `texttofront.dimensions`; a test keeps it true).
const MAX_COMMAND_ID_CHARS: usize = 32;
/// Longest line read.
const MAX_LINE_CHARS: usize = 4096;
/// Most warnings reported.
const MAX_WARNINGS: usize = 100;
/// Longest alias file path kept in the user profile.
const MAX_ALIAS_FILE_CHARS: usize = 1024;
/// The largest alias section [`alias_profile`] can produce: [`MAX_ALIASES`] entries, each a
/// [`MAX_ALIAS_CHARS`]-character name (up to four UTF-8 bytes per character, and JSON adds its
/// quotes) mapped to a command id, plus the alias file path and the section's keys. A host that
/// keeps the section in its user profile allows at least this much, so a full set always comes
/// back after a restart.
pub const MAX_ALIAS_PROFILE_BYTES: usize = MAX_ALIASES * (MAX_ALIAS_CHARS * 4 + MAX_COMMAND_ID_CHARS + 6) + MAX_ALIAS_FILE_CHARS * 4 + 64;
#[derive(Default)]
struct Aliases {
@@ -43,6 +59,55 @@ pub(crate) fn user_alias(name: &str) -> Option<String> {
store().map.get(name).cloned()
}
/// The user alias that is the Greek word `word` in another case or accent.
pub(crate) fn greek_alias(word: &str) -> Option<String> {
let same = crate::keyboard::same_greek_word_as(word)?;
store().map.keys().find(|alias| same(alias)).cloned()
}
/// The user aliases and the file REINIT reads, as the host's user profile keeps them:
/// `{"aliases": {alias: command}, "file": path or null}`. Not drawing data.
pub fn alias_profile() -> Value {
let st = store();
// A path [`restore_aliases`] would refuse is left out, so it can't grow the profile either.
json!({ "aliases": st.map, "file": st.file.as_deref().filter(|f| keepable_path(f)) })
}
/// Whether the profile keeps an alias file path: short enough, and no control characters.
fn keepable_path(f: &str) -> bool {
f.chars().count() <= MAX_ALIAS_FILE_CHARS && !f.chars().any(char::is_control)
}
/// Restore aliases saved by [`alias_profile`], replacing the user aliases and the file.
///
/// The saved set is untrusted (a hand-edited or older profile): entries that are not aliases of
/// real commands are skipped, command names are never aliased, at most [`MAX_ALIASES`] are kept,
/// and a malformed section changes nothing.
pub fn restore_aliases(saved: &Value) {
let Some(obj) = saved.as_object() else { return };
let file = match obj.get("file") {
None | Some(Value::Null) => None,
Some(Value::String(f)) if keepable_path(f) => Some(f.clone()),
Some(Value::String(_)) => None,
// A file entry that is not a path makes the section malformed: keep the aliases as they are.
Some(_) => return,
};
let Some(map) = obj.get("aliases").and_then(Value::as_object) else { return };
let mut aliases = BTreeMap::new();
// Entries that are skipped don't use up the cap.
for (alias, target) in map {
if aliases.len() >= MAX_ALIASES {
break;
}
let Ok(name) = alias_name(alias) else { continue };
let Some(id) = target.as_str().and_then(command_id) else { continue };
aliases.insert(name, id);
}
let mut st = store();
st.map = aliases;
st.file = file;
}
/// The command id `target` names (`*LINE`, `_.line`, `-LAYER`…), if there is such a command.
pub fn command_id(target: &str) -> Option<String> {
let t = target.trim().trim_start_matches('*').trim().trim_start_matches(['_', '.']).to_ascii_lowercase();
@@ -201,3 +266,25 @@ pub(crate) fn specs() -> Vec<CommandSpec> {
CommandSpec::new("reinit", "Reinitialize", run_reinit).params("{file? | text?} (default: the alias file loaded last)").enabled(always).noundo(),
]
}
#[cfg(test)]
mod tests {
use super::MAX_COMMAND_ID_CHARS;
/// [`super::MAX_ALIAS_PROFILE_BYTES`] bounds a saved alias's command id by the longest id in
/// the catalog: keep that true as commands are added.
#[test]
fn every_command_id_fits_the_saved_alias_bound() {
for spec in crate::cmd::command_specs() {
assert!(spec.id.chars().count() <= MAX_COMMAND_ID_CHARS, "`{}` exceeds the alias profile bound", spec.id);
}
}
/// An alias file path the profile couldn't restore isn't saved in it.
#[test]
fn only_paths_the_profile_restores_are_saved() {
assert!(super::keepable_path("C:\\support\\mine.pgp"));
assert!(!super::keepable_path(&"x".repeat(super::MAX_ALIAS_FILE_CHARS + 1)));
assert!(!super::keepable_path("mine\n.pgp"));
}
}
+1 -1
View File
@@ -74,7 +74,7 @@ fn read_template(path: &str) -> Result<Drawing> {
#[cfg(not(target_arch = "wasm32"))]
fn read_bytes(path: &str) -> Result<Vec<u8>> {
std::fs::read(path).map_err(|e| bad("new", format!("template {path}: {e}")))
crate::capped_read::read_capped(std::path::Path::new(path), super::MAX_DRAWING_BYTES).map_err(|e| bad("new", format!("template {path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+25 -6
View File
@@ -43,7 +43,8 @@ pub(crate) struct GripEdit {
hot: Vec<(Handle, usize)>,
/// Typed `GRIP`: still collecting grips ("Select grips").
picking: bool,
/// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the selection.
/// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the objects of the
/// selection that the view being edited shows.
targets: Vec<Handle>,
base: Vec2,
mode: GripMode,
@@ -69,6 +70,13 @@ fn positive(v: Option<f64>) -> Result<f64> {
v.filter(|f| f.is_finite() && *f > 1e-12).ok_or_else(|| other("Requires a positive number."))
}
/// Whether the view being edited shows `h`. A hidden object (HIDEOBJECTS, an off or frozen layer,
/// a layer frozen in the active MSPACE viewport) takes no part in a grip edit, even when Undo or
/// a selection command put it back into the selection.
fn shown(s: &Session, h: Handle) -> bool {
s.state().is_ok_and(|st| st.doc.entity(h).is_some_and(|e| st.shows(e)))
}
impl GripEdit {
fn new(s: &Session, hot: Vec<(Handle, usize)>) -> Result<Self> {
let mut g = GripEdit {
@@ -87,16 +95,22 @@ impl GripEdit {
Ok(g)
}
/// Make grip `index` of `h` hot (the first one becomes the base point).
/// Make grip `index` of `h` hot (the first one becomes the base point). The grip of an object
/// the view being edited does not show is left out, and so are the hidden objects of the
/// selection.
fn add_hot(&mut self, s: &Session, (h, i): (Handle, usize)) -> Result<()> {
if self.hot.contains(&(h, i)) || self.hot.len() >= MAX_HOT {
return Ok(());
}
let p = s.grips_of(h)?.get(i).copied().ok_or_else(|| other("no such grip"))?;
// After the lookup: a missing object or grip stays the error it was.
if !shown(s, h) {
return Ok(());
}
if self.hot.is_empty() {
self.base = p;
self.targets.push(h);
self.targets.extend(s.selection().into_iter().filter(|x| *x != h));
self.targets.extend(s.selection().into_iter().filter(|x| *x != h && shown(s, *x)));
} else if !self.targets.contains(&h) {
self.targets.push(h);
}
@@ -107,13 +121,13 @@ impl GripEdit {
/// The grips of the selected objects at `p` (typed `GRIP`): all objects with a grip there.
fn grips_at(s: &Session, p: Vec2) -> Vec<(Handle, usize)> {
let tol = (s.pixel_size() * (s.settings.gripsize + 3.0)).max(1e-9 * (1.0 + p.len()));
let Ok(d) = s.doc() else { return Vec::new() };
let Ok(st) = s.state() else { return Vec::new() };
let mut out = Vec::new();
for h in s.selection().into_iter().take(MAX_HOT) {
if super::curves::is_locked(s, h) {
continue;
}
let Some(e) = d.entity(h) else { continue };
let Some(e) = st.doc.entity(h).filter(|e| st.shows(e)) else { continue };
let gs = e.kind.grips();
// The nearest grip of this object within the tolerance.
let best = gs
@@ -470,7 +484,9 @@ impl Interactive for GripEdit {
impl Session {
/// Make grips hot and start editing them (the UI's click on a grip; Shift+click collects
/// several first). `hot` lists (object, grip index); the first is the base grip. The grip
/// modes and their options then run at the command line like any prompt.
/// modes and their options then run at the command line like any prompt. Grips of objects the
/// view being edited does not show are left out (the first grip left is the base grip), and it
/// is an error when none is left.
pub fn start_grip_edit(&mut self, hot: &[(Handle, usize)]) -> Result<()> {
if self.running.is_some() {
self.cancel();
@@ -479,6 +495,9 @@ impl Session {
return Err(other("no grip"));
}
let g = GripEdit::new(self, hot.to_vec())?;
if g.hot.is_empty() {
return Err(other("no grip"));
}
let label = g.label();
let machine = crate::guard::Guarded::wrap(Box::new(g));
let st = self.state()?;
+4 -2
View File
@@ -28,7 +28,8 @@ pub fn specs() -> Vec<CommandSpec> {
const MEMBER_PICKS: &[&str] = &["groupedit", "-group"];
/// `hs` plus the other members of the selectable groups they belong to (in the space being
/// edited, visible), when PICKSTYLE has group selection on. Order: `hs` first.
/// edited, visible, and inside an MSPACE viewport not on a layer frozen in it), when PICKSTYLE
/// has group selection on. Order: `hs` first.
pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
if s.settings.pickstyle & 1 == 0 || hs.is_empty() || s.running.as_ref().is_some_and(|r| MEMBER_PICKS.contains(&r.id.as_str())) {
return hs;
@@ -39,6 +40,7 @@ pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
}
let space = s.space();
let Some(store) = d.space(&space) else { return hs };
let frozen = s.viewport_frozen();
// Member → its selectable groups, built once (window selections may hold many objects).
let mut of: HashMap<Handle, Vec<usize>> = HashMap::new();
for (i, g) in d.groups.iter().enumerate().filter(|(_, g)| g.selectable) {
@@ -56,7 +58,7 @@ pub(crate) fn expand(s: &Session, hs: Vec<Handle>) -> Vec<Handle> {
}
let Some(g) = d.groups.get(*gi) else { continue };
for m in &g.members {
if store.get(*m).is_some_and(|e| d.is_visible(e)) && seen.insert(*m) {
if store.get(*m).is_some_and(|e| crate::select::selectable(d, e, frozen)) && seen.insert(*m) {
out.push(*m);
}
}
+23 -3
View File
@@ -1,8 +1,9 @@
//! HATCH, GRADIENT, BOUNDARY, REGION: boundaries from pick points or selected closed objects.
mod patfile;
pub(super) use edit::{set_pattern, takes_pattern};
pub(super) use patfile::run_patterns;
pub use patfile::{PatternChoice, pattern_choices};
pub(super) use patfile::{lines_for, run_patterns};
use cadcraft_color::Color;
use cadcraft_doc::{Drawing, Entity, EntityKind, Gradient, Handle, Hatch, HatchLoop, Space, entity_bounds};
@@ -10,6 +11,7 @@ use cadcraft_geom::{Bounds2, PolyVertex, Polyline, Vec2, point_in_polygon};
use serde_json::{Value, json};
use super::helpers::lwpoly;
use super::machines::SelectRun;
use super::{CommandSpec, bad, bool_or, f64_or, point_param, points_param, size_param, str_param, targets};
use crate::{Accept, EngineError, Input, Interactive, Picker, Prompt, Result, Session, Step};
@@ -27,7 +29,12 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("hatch", "Hatch...", run_hatch).menu(&["Draw", "Hatch..."]).alias(&["h", "bh", "-hatch"]).params("{points?: [[x,y]] (internal points) and/or handles?: [hex] (closed objects), pattern?: \"ANSI31\" (built in, or defined by patternFile | patternText), patternFile?: path to a .pat file | patternText?: its contents (loads the patterns it defines), scale?, angle? (degrees), associative? (HPASSOC), separate? (HPSEPARATE: a hatch per point/object), origin?: [x,y] (HPORIGIN) | originMode?: \"current\"|\"bottomLeft\"|\"bottomRight\"|\"topLeft\"|\"topRight\"|\"center\" (HPORIGINMODE), style?: \"normal\"|\"outer\"|\"ignore\" (HPISLANDDETECTION)} — gaps up to HPGAPTOL close").interactive(|s| Ok(Box::new(HatchM::new(s, false)))),
CommandSpec::new("gradient", "Gradient...", run_gradient).menu(&["Draw", "Gradient..."]).alias(&["gd"]).params("{points? and/or handles?, name?: \"LINEAR\"|\"CYLINDER\"|\"CURVED\"|\"SPHERICAL\"|\"HEMISPHERICAL\" or INV… (colours swapped), color1?, color2?, angle? (degrees), centered? (default true)}").interactive(|s| Ok(Box::new(HatchM::new(s, true)))),
CommandSpec::new("boundary", "Boundary...", run_boundary).menu(&["Draw", "Boundary..."]).alias(&["bo", "bpoly"]).params("{points: [[x,y]]}").interactive(|_| Ok(Box::new(BoundaryM { region: false }))),
CommandSpec::new("region", "Region", run_region).menu(&["Draw", "Region"]).alias(&["reg"]).params("{handles?}"),
CommandSpec::new("region", "Region", run_region)
.menu(&["Draw", "Region"])
.alias(&["reg"])
.params("{handles?}")
// Typed with nothing selected it asks for objects, as in AutoCAD, rather than converting none.
.interactive(|_| Ok(Box::new(SelectRun::new("region", "REGION")))),
CommandSpec::new("hatchedit", "Hatch Edit", edit::run_hatchedit).menu(&["Modify", "Object", "Hatch..."]).alias(&["he", "-hatchedit"]).params("{handles?, pattern?, scale?, angle?, gradient?: {name?, color1?, color2?, angle? (degrees), centered?} (makes or changes a gradient fill; `pattern` turns it back), associative?: bool (false unlinks; true links each loop to a closed object of the same shape, or to `boundary` objects), boundary?: [hex], addPoints?: [[x,y]], addBoundary?: [hex], removeLoops?: [zero-based index] (geometry edits require one hatch), style?, origin? | originMode?, separate?: true, recreate?: \"polyline\"|\"region\", associate?: bool (link to the recreated boundary)}").interactive(|s| Ok(Box::new(edit::HatchEditM::new(s)))),
CommandSpec::new("hatchpick", "Hatch Pick", pick::run_hatchpick)
.params("{points?: [[x,y]] (internal points), handles?: [hex] (closed objects)} (typed: Points, Objects, oRigin or Hatch, then the picks): the Hatch and Gradient dialog's picks, kept in the session; changes nothing")
@@ -533,6 +540,19 @@ fn run_region(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "message": format!("{n} Region(s) created.") }))
}
/// Whether the upper-case `name` is a pattern: a standard one or a loaded one.
fn pattern_exists(name: &str) -> bool {
cadcraft_doc::library::pattern(name).is_some() || patfile::user_pattern(name).is_some()
}
/// The existing pattern `name` means, typed at the pattern prompt: read upper-cased, else a loaded
/// pattern's own name when only its Greek spelling differs in case or accent (σολιδ for ΣΟΛΙΔ).
pub(crate) fn pattern_named(name: &str) -> Option<String> {
let name = name.trim();
let up = name.to_ascii_uppercase();
if pattern_exists(&up) { Some(up) } else { patfile::user_pattern_name(name) }
}
/// The origin sub-prompt's keywords (a point sets a new origin).
const ORIGIN_KW: [&str; 6] = ["Bottom left", "bottom Right", "Top left", "top riGht", "Center", "Use current"];
@@ -597,7 +617,7 @@ impl HatchM {
Some(n) => n,
None => t.trim().to_ascii_uppercase(),
};
if cadcraft_doc::library::pattern(&up).is_some() || patfile::user_pattern(&up).is_some() {
if pattern_exists(&up) {
self.settings.pattern = up.clone();
s.doc_mut()?.header.set_str("HPNAME", &up);
} else {
+40 -18
View File
@@ -143,21 +143,8 @@ fn separate(s: &mut Session, handle: Handle) -> Result<Vec<Handle>> {
/// Pattern, scale and angle (degrees) from the parameters.
fn properties(h: &mut Hatch, p: &Value) {
if let Some(v) = str_param(p, "pattern").map(str::trim).filter(|v| !v.is_empty()) {
h.pattern = v.to_ascii_uppercase();
h.solid = h.pattern == "SOLID";
// A named pattern, SOLID included, replaces the gradient fill; the renderer draws the
// gradient first when it is set.
h.gradient = None;
if !h.solid {
// A library pattern is drawn from the library; a loaded .pat pattern brings its lines;
// any other name is the hatch's own and keeps its definition.
if cadcraft_doc::library::pattern(&h.pattern).is_some() {
h.pattern_lines.clear();
} else if let Some(user) = super::patfile::user_pattern(&h.pattern) {
h.pattern_lines = user.lines;
}
}
if let Some(v) = str_param(p, "pattern") {
set_pattern(h, v);
}
if let Some(x) = p.get("scale").and_then(Value::as_f64).filter(|x| x.is_finite() && *x > 0.0) {
h.scale = x;
@@ -167,6 +154,43 @@ fn properties(h: &mut Hatch, p: &Value) {
}
}
/// Whether the pattern called `up` (upper case) is defined: SOLID, one CADCraft defines, or a
/// loaded .pat pattern.
fn defined_pattern(up: &str) -> bool {
up == "SOLID" || cadcraft_doc::library::pattern(up).is_some() || super::patfile::user_pattern(up).is_some()
}
/// Whether `h` can take the pattern called `name`: a defined one, or the hatch's own (a pattern
/// read from a file keeps its definition).
pub(crate) fn takes_pattern(h: &Hatch, name: &str) -> bool {
let up = name.trim().to_ascii_uppercase();
defined_pattern(&up) || h.pattern.eq_ignore_ascii_case(&up)
}
/// Give `h` the pattern called `name` (HATCHEDIT's and Properties' pattern edit); false, and
/// nothing changes, for a blank name or one the hatch can't take ([`takes_pattern`]).
pub(crate) fn set_pattern(h: &mut Hatch, name: &str) -> bool {
let name = name.trim();
if name.is_empty() || !takes_pattern(h, name) {
return false;
}
h.pattern = name.to_ascii_uppercase();
h.solid = h.pattern == "SOLID";
// A named pattern, SOLID included, replaces the gradient fill; the renderer draws the
// gradient first when it is set.
h.gradient = None;
if !h.solid {
// A library pattern is drawn from the library; a loaded .pat pattern brings its lines;
// any other name is the hatch's own and keeps its definition.
if cadcraft_doc::library::pattern(&h.pattern).is_some() {
h.pattern_lines.clear();
} else if let Some(user) = super::patfile::user_pattern(&h.pattern) {
h.pattern_lines = user.lines;
}
}
true
}
/// HATCHEDIT's `gradient`: the fields to change, all checked before any hatch is touched.
struct GradientEdit {
name: Option<&'static str>,
@@ -389,9 +413,7 @@ pub(super) fn run_hatchedit(s: &mut Session, p: &Value) -> Result<Value> {
// Like the prompt: a pattern must be one CADCraft defines, SOLID, or the hatches' own (a
// pattern read from a file keeps its definition).
if let Some(up) = str_param(p, "pattern").map(|v| v.trim().to_ascii_uppercase()).filter(|v| !v.is_empty())
&& up != "SOLID"
&& cadcraft_doc::library::pattern(&up).is_none()
&& super::patfile::user_pattern(&up).is_none()
&& !defined_pattern(&up)
{
let d = s.doc()?;
let own = hs.iter().all(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Hatch(x)) if x.pattern == up));
+7
View File
@@ -28,6 +28,13 @@ pub(crate) fn user_pattern(name: &str) -> Option<UserPattern> {
store().iter().find(|p| p.name.eq_ignore_ascii_case(name)).cloned()
}
/// The name of the user pattern that is the Greek word `name` in another case or accent
/// ([`user_pattern`] folds ASCII only).
pub(crate) fn user_pattern_name(name: &str) -> Option<String> {
let same = crate::keyboard::same_greek_word_as(name)?;
store().iter().find(|p| same(&p.name)).map(|p| p.name.clone())
}
/// The line families a new hatch of pattern `name` carries: a user pattern's, else none (the
/// library's patterns are drawn and saved from the library).
pub(crate) fn lines_for(name: &str) -> Vec<PatternLine> {
+28 -9
View File
@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("dist", "Distance", run_dist)
.menu(&["Tools", "Inquiry", "Distance"])
.alias(&["di"])
.params("{p1, p2}")
.params("{p1, p2} -> {distance, angle, angleFromXY, dx, dy, dz (world), ucs: {angle, angleFromXY, dx, dy, dz} (in the frame typed points are read in: the current UCS, or the World UCS while the UCS is tilted; as the message), message}")
.noundo()
.transparent()
.interactive(|_| Ok(Box::new(DistM::default()))),
@@ -192,11 +192,18 @@ fn angle_from_xy(d: Vec3) -> f64 {
d.z.atan2(d.xy().len())
}
fn dist_text(s: &Session, a: Vec3, b: Vec3) -> String {
let d = b - a;
/// The delta from `a` to `b` along the axes of the current UCS (the World UCS while that is
/// tilted): what DIST's report shows.
fn dist_delta(s: &Session, a: Vec3, b: Vec3) -> Vec3 {
let u = s.input_ucs();
u.to_ucs3(b) - u.to_ucs3(a)
}
/// DIST's report: the distance, the angles and the deltas `d`, measured in the current UCS.
fn dist_text(s: &Session, dist: f64, d: Vec3) -> String {
format!(
"Distance = {}, Angle in XY Plane = {}, Angle from XY Plane = {}\nDelta X = {}, Delta Y = {}, Delta Z = {}",
fmt_d(s, (b - a).len()),
fmt_d(s, dist),
fmt_a(s, d.xy().angle()),
fmt_a(s, angle_from_xy(d)),
fmt_d(s, d.x),
@@ -222,6 +229,8 @@ fn run_dist(s: &mut Session, p: &Value) -> Result<Value> {
}
s.distance = d.len();
s.last_point = a.xy();
// Top level: the world values, as ID's x, y, z are; `ucs` has what the message shows.
let du = dist_delta(s, a, b);
Ok(json!({
"distance": d.len(),
"angle": d.xy().angle().to_degrees(),
@@ -229,18 +238,28 @@ fn run_dist(s: &mut Session, p: &Value) -> Result<Value> {
"dx": d.x,
"dy": d.y,
"dz": d.z,
"message": dist_text(s, a, b),
"ucs": {
"angle": du.xy().angle().to_degrees(),
"angleFromXY": angle_from_xy(du).to_degrees(),
"dx": du.x,
"dy": du.y,
"dz": du.z,
},
"message": dist_text(s, d.len(), du),
}))
}
/// ID's report: the point in the current UCS.
fn id_text(s: &Session, a: Vec3) -> String {
format!("X = {} Y = {} Z = {}", fmt_d(s, a.x), fmt_d(s, a.y), fmt_d(s, a.z))
let u = s.input_ucs().to_ucs3(a);
format!("X = {} Y = {} Z = {}", fmt_d(s, u.x), fmt_d(s, u.y), fmt_d(s, u.z))
}
fn run_id(s: &mut Session, p: &Value) -> Result<Value> {
let a = point3_req(s, "id", p, "at")?;
s.last_point = a.xy();
Ok(json!({ "x": a.x, "y": a.y, "z": a.z, "message": id_text(s, a) }))
let u = s.input_ucs().to_ucs3(a);
Ok(json!({ "x": a.x, "y": a.y, "z": a.z, "ucs": [u.x, u.y, u.z], "message": id_text(s, a) }))
}
/// The Z of what is drawn at `p`: the object a pick finds there, at that point, or the current
@@ -591,7 +610,7 @@ fn run_inspect(s: &mut Session, p: &Value) -> Result<Value> {
"dimStyles": d.dim_styles.iter().map(|l| l.name.clone()).collect::<Vec<_>>(),
"blocks": d.blocks.keys().filter(|k| !k.starts_with('*')).cloned().collect::<Vec<_>>(),
"layouts": d.layouts.iter().map(|l| l.name.clone()).collect::<Vec<_>>(),
"selection": st.selection.iter().map(|h| h.hex()).collect::<Vec<_>>(),
"selection": st.shown_selection().iter().map(|h| h.hex()).collect::<Vec<_>>(),
"undo": st.undo.iter().rev().take(20).map(|u| u.label.clone()).collect::<Vec<_>>(),
"view": { "center": [st.view().center.x, st.view().center.y], "height": st.view().height },
// Records of the file the drawing came from that the reader could not place.
@@ -900,7 +919,7 @@ impl Interactive for DistM {
s.last_point = first;
return Err(bad("dist", "the distance is too large"));
}
let t = dist_text(s, a, b);
let t = dist_text(s, (b - a).len(), dist_delta(s, a, b));
for l in t.lines() {
s.echo(l.to_string());
}
+4
View File
@@ -106,6 +106,10 @@ pub fn used_layers(d: &cadcraft_doc::Drawing) -> std::collections::HashSet<Strin
if !set.contains(&e.common.layer.to_ascii_lowercase()) {
set.insert(e.common.layer.to_ascii_lowercase());
}
// An attribute can sit on a layer of its own.
for layer in super::blocks::object_attribs(e).iter().filter_map(|a| a.props.layer.as_ref()) {
set.insert(layer.to_ascii_lowercase());
}
}
set
}
+10 -1
View File
@@ -313,7 +313,16 @@ fn run_copy(s: &mut Session, p: &Value) -> Result<Value> {
let h = d.new_handle();
store.push(Entity { handle: h, ..Entity::clone(e) });
}
d.layouts.push(Layout { name: to.clone(), tab_order: order, page: src.page, entities: store, view: src.view, limits: src.limits });
d.layouts.push(Layout {
name: to.clone(),
tab_order: order,
page: src.page,
entities: store,
view: src.view,
ucs: src.ucs,
ucs_previous: Vec::new(),
limits: src.limits,
});
Ok(json!({ "name": to }))
}
+3 -5
View File
@@ -303,11 +303,9 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
(None, Some(_path)) => {
#[cfg(not(target_arch = "wasm32"))]
{
let meta = std::fs::metadata(_path).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
if meta.len() > cadcraft_doc::MAX_TABLE_FILE as u64 {
return Err(bad(cmd, format!("{_path}: the plot style table file is too large")));
}
std::fs::read_to_string(_path).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
let bytes = crate::capped_read::read_capped(std::path::Path::new(_path), cadcraft_doc::MAX_TABLE_FILE)
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
String::from_utf8(bytes).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
}
#[cfg(target_arch = "wasm32")]
return Err(bad(cmd, "files can't be read here: pass `text`"));
+52 -4
View File
@@ -26,11 +26,30 @@ const MAX_PURGE_PASSES: usize = 64;
/// The file a SAveas typed at the command line suggests: `<layout>.dwt` beside the drawing.
pub(super) fn default_path(s: &Session, layout: &str) -> String {
let file = format!("{layout}.dwt");
match s.state().ok().and_then(|st| st.path.clone()) {
Some(p) => std::path::Path::new(&p).with_file_name(&file).to_string_lossy().into_owned(),
None => file,
// A layout name from a file may hold path separators or `..`; the suggestion is one file name
// beside the drawing, so those become `_`.
let name: String = layout.chars().map(|c| if matches!(c, '/' | '\\' | ':') || c.is_control() { '_' } else { c }).collect();
// Windows reserves device names (`CON`, `NUL`, `COM1`...) with any extension, so prefix them.
let base = name.split('.').next().unwrap_or("").trim_end().to_ascii_uppercase();
let reserved = matches!(base.as_str(), "CON" | "PRN" | "AUX" | "NUL")
|| (base.len() == 4 && (base.starts_with("COM") || base.starts_with("LPT")) && base.ends_with(|c: char| ('1'..='9').contains(&c)));
let file = if reserved { format!("_{name}.dwt") } else { format!("{name}.dwt") };
let candidate = match s.state().ok().and_then(|st| st.path.clone()) {
Some(p) => std::path::Path::new(&p).with_file_name(&file),
None => std::path::PathBuf::from(file),
};
if !candidate.exists() {
return candidate.to_string_lossy().into_owned();
}
let stem = candidate.file_stem().and_then(|s| s.to_str()).unwrap_or("layout");
let extension = candidate.extension().and_then(|e| e.to_str()).unwrap_or("dwt");
let parent = candidate.parent().unwrap_or_else(|| std::path::Path::new(""));
// The suffix range never ends in practice; the fallback only keeps the code panic-free.
let alternative = (2u64..)
.map(|suffix| parent.join(format!("{stem}-{suffix}.{extension}")))
.find(|alternative| !alternative.exists())
.unwrap_or(candidate.clone());
alternative.to_string_lossy().into_owned()
}
/// `path` with `.dwt` added when it has no extension; an error for any other file type.
@@ -133,3 +152,32 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
super::super::exchange::deliver_file("layout.saveas", path, bytes, super::super::file::deliver())
}
}
#[cfg(test)]
mod default_path_tests {
use super::*;
/// A layout name with separators suggests a file beside the drawing, not a path elsewhere.
#[test]
fn layout_name_is_one_file_name() {
let s = Session::empty();
for name in ["../../etc/x", "a/b", "a\\b", "C:x"] {
let p = default_path(&s, name);
assert!(!p.contains('/') && !p.contains('\\') && !p.contains(':'), "{p}");
assert!(p.ends_with(".dwt"));
}
assert_eq!(default_path(&s, "Layout1"), "Layout1.dwt");
}
/// Windows device names are prefixed so the suggestion is never a device.
#[test]
fn reserved_device_names_are_prefixed() {
let s = Session::empty();
for name in ["CON", "nul", "Com1", "LPT9", "aux.x"] {
assert_eq!(default_path(&s, name), format!("_{name}.dwt"));
}
for name in ["COM0", "CONSOLE", "COM10"] {
assert_eq!(default_path(&s, name), format!("{name}.dwt"));
}
}
}
+27 -18
View File
@@ -21,14 +21,17 @@ impl StretchArea {
}
}
/// Add to `hs` the visible multilines in `space` with a control vertex inside `area`. A crossing
/// selection tests the drawn element lines, which sit away from the control vertices by the
/// multiline's scale, so a small area around a vertex alone would miss them.
fn add_mline_vertex_hits(d: &cadcraft_doc::Drawing, space: &cadcraft_doc::Space, area: &StretchArea, hs: &mut Vec<Handle>) {
let Some(store) = d.space(space) else { return };
/// Add to `hs` the multilines in the edit space that a selection can take there (visible, and
/// inside an MSPACE viewport not on a layer frozen in it) with a control vertex inside `area`. A
/// crossing selection tests the drawn element lines, which sit away from the control vertices by
/// the multiline's scale, so a small area around a vertex alone would miss them.
fn add_mline_vertex_hits(s: &Session, area: &StretchArea, hs: &mut Vec<Handle>) {
let Ok(d) = s.doc() else { return };
let Some(store) = d.space(&s.space()) else { return };
let frozen = s.viewport_frozen();
for e in store.iter() {
if let EntityKind::MLine(m) = &e.kind
&& d.is_visible(e)
&& crate::select::selectable(d, e, frozen)
&& !hs.contains(&e.handle)
&& m.vertices.iter().any(|v| area.contains(v.p.xy()))
{
@@ -94,19 +97,19 @@ pub(super) fn run_stretch(s: &mut Session, p: &Value) -> Result<Value> {
};
// A fence marks no area: the objects it crosses move whole.
if let Some(fence) = listed("fence", 2)? {
let hs = crate::select::select_fence(s.doc()?, &space, &fence);
let hs = crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &fence);
let moved = transform_entities(s, &hs, &Mat3::translate(d), false)?;
return Ok(json!({ "stretched": moved.len() }));
}
let (mut hs, area) = if let Some(poly) = listed("polygon", 3)? {
(crate::select::select_polygon(s.doc()?, &space, &poly, true), StretchArea::Polygon(poly))
(crate::select::select_polygon_in(s.doc()?, &space, s.viewport_frozen(), &poly, true), StretchArea::Polygon(poly))
} else {
let w = points_param(p, "window").ok_or_else(|| bad("stretch", "`window` [[x,y],[x,y]], `polygon` or `fence` is required"))?;
let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("stretch", "window needs 2 corners")) };
let bx = cadcraft_geom::Bounds2::new(*a, *b);
(crate::select::select_window(s.doc()?, &space, bx, true), StretchArea::Box(bx))
(crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, true), StretchArea::Box(bx))
};
add_mline_vertex_hits(s.doc()?, &space, &area, &mut hs);
add_mline_vertex_hits(s, &area, &mut hs);
hs.retain(|h| !crate::cmd::curves::is_locked(s, *h));
let doc = s.doc_mut()?;
let areas = [area];
@@ -173,7 +176,7 @@ impl StretchM {
/// of two) the mode is dropped.
fn finish_mode(&mut self, s: &mut Session, m: SelectMode) -> Result<()> {
let space = s.space();
let Some(mut hs) = m.select(s.doc()?, &space) else { return Ok(()) };
let Some(mut hs) = m.select_in(s.doc()?, &space, s.viewport_frozen()) else { return Ok(()) };
let crossing = match (m.kind, m.pts.first().zip(m.pts.get(1))) {
(SelectKind::Crossing | SelectKind::CPolygon, _) => true,
(SelectKind::Box, Some((a, b))) => b.x < a.x,
@@ -189,7 +192,7 @@ impl StretchM {
};
let whole = area.is_none();
if let (Some(a), true, false) = (&area, crossing, self.removing) {
add_mline_vertex_hits(s.doc()?, &space, a, &mut hs);
add_mline_vertex_hits(s, a, &mut hs);
}
if let (Some(a), false) = (area, self.removing) {
self.windows.push(a);
@@ -228,10 +231,10 @@ impl StretchM {
Some(c) => {
let bx = cadcraft_geom::Bounds2::new(c, p);
let space = s.space();
let mut hs = crate::select::select_window(s.doc()?, &space, bx, p.x < c.x);
let mut hs = crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, p.x < c.x);
if !self.removing {
if p.x < c.x {
add_mline_vertex_hits(s.doc()?, &space, &StretchArea::Box(bx), &mut hs);
add_mline_vertex_hits(s, &StretchArea::Box(bx), &mut hs);
}
self.windows.push(StretchArea::Box(bx));
}
@@ -240,7 +243,7 @@ impl StretchM {
None => {
let aperture = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
match crate::select::pick(s.doc()?, &space, p, aperture) {
match crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), p, aperture) {
Some(h) => self.add(s, vec![h], true),
None => self.corner = Some(p),
}
@@ -251,6 +254,7 @@ impl StretchM {
self.corner = None;
let d = s.doc()?;
let store = d.space(&s.space());
let frozen = s.viewport_frozen();
let word = t.trim().to_ascii_lowercase();
// `_C`, `_L`: the English name, as scripts write it.
let word = word.strip_prefix('_').unwrap_or(&word).to_string();
@@ -267,9 +271,14 @@ impl StretchM {
self.removing = false;
None
}
"all" => Some(store.map(|st| st.iter().filter(|e| d.is_visible(e)).map(|e| e.handle).collect()).unwrap_or_default()),
"l" | "last" => Some(store.and_then(|st| st.last()).map(|e| vec![e.handle]).unwrap_or_default()),
"p" | "previous" => Some(s.state()?.previous_selection.clone()),
"all" => Some(
store.map(|st| st.iter().filter(|e| crate::select::selectable(d, e, frozen)).map(|e| e.handle).collect()).unwrap_or_default(),
),
"l" | "last" => Some(store.and_then(|st| crate::select::last_in(st, frozen)).map(|h| vec![h]).unwrap_or_default()),
"p" | "previous" => {
let st = s.state()?;
Some(st.drawn_in_viewport(&st.previous_selection))
}
_ => {
s.echo("*Invalid selection*");
None
+1 -1
View File
@@ -65,7 +65,7 @@ pub fn specs() -> Vec<CommandSpec> {
.params("{handle (block reference), pick?: [x,y] (nearest nested object; default all), delta? | from,to}")
.interactive(|_| Ok(Box::new(NcopyM::default()))),
CommandSpec::new("mocoro", "Move/Copy/Rotate", mocoro::run_mocoro)
.menu(&["Tools", "Express Tools", "Move/Copy/Rotate"])
.menu(&["Tools", "Additional Tools", "Move/Copy/Rotate"])
.params("{handles?, base: [x,y], ops: [{move: [x,y]} | {copy: [x,y]} | {rotate: degrees} | {scale: factor} | {base: [x,y]}]} → {handles (copies)}")
.interactive(|_| Ok(Box::new(mocoro::MocoroM::default()))),
CommandSpec::new("chspace", "Change Space", run_chspace)
+12
View File
@@ -117,6 +117,12 @@ pub(super) fn run_mocoro(s: &mut Session, p: &Value) -> Result<Value> {
_ => {}
}
}
// Each Copy clones every selected object: the copies together stay within MAXARRAY, as an array's do.
// Erased handles are skipped by `apply`, so only live objects count (none: nothing is copied).
let live = counts(s, &objs)?.0;
if live > 0 {
crate::cmd::array::check_size(s, ops.iter().filter(|o| matches!(o, Op::Copy(_))).count() as u64, live)?;
}
let mut copies = Vec::new();
for op in ops {
copies.extend(apply(s, &objs, &mut base, op)?);
@@ -150,6 +156,12 @@ pub(super) struct MocoroM {
impl MocoroM {
fn run(&mut self, s: &mut Session, op: Op) -> Result<Step> {
if matches!(op, Op::Copy(_)) {
let live = counts(s, &self.objs)?.0;
if live > 0 {
crate::cmd::array::check_size(s, 1, live)?;
}
}
let before = s.state()?.doc.clone();
let base = self.base;
apply(s, &self.objs, &mut self.base, op)?;
+4 -2
View File
@@ -34,10 +34,12 @@ pub(crate) fn arraypath(
_ => (6, if c.closed { l / 6.0 } else { l / 5.0 }),
};
crate::cmd::array::check_size(s, n as u64, objs.len())?;
let Some((p0, t0)) = c.at_length(0.0) else { return Ok(Vec::new()) };
// Segment end lengths once: each sample is then a binary search, not a scan from the start.
let ends = c.end_lengths();
let Some((p0, t0)) = c.at_length_in(&ends, 0.0) else { return Ok(Vec::new()) };
let mut mats = Vec::new();
for i in 1..n {
let Some((p, t)) = c.at_length(step * i as f64) else { continue };
let Some((p, t)) = c.at_length_in(&ends, step * i as f64) else { continue };
let mut m = Mat3::translate(p - p0);
if align {
m = Mat3::rotate_about(p, t.angle() - t0.angle()).then_before(m);
+34 -2
View File
@@ -11,6 +11,8 @@ fn text_of(k: &EntityKind) -> Option<String> {
EntityKind::Text(t) => Some(t.value.clone()),
EntityKind::AttDef(a) => Some(a.text.value.clone()),
EntityKind::MText(t) => Some(t.contents.replace("\\P", "\n")),
// A multileader's text (one with a block instead has none, #1081).
EntityKind::MLeader(m) => m.text.as_ref().map(|t| t.contents.replace("\\P", "\n")),
EntityKind::Dimension(d) => Some(if d.text.is_empty() { "<>".into() } else { d.text.clone() }),
_ => None,
}
@@ -25,11 +27,16 @@ pub(crate) fn set_text(s: &mut Session, h: Handle, text: &str) -> Result<()> {
EntityKind::Text(t) => t.value = text.to_string(),
EntityKind::AttDef(a) => a.text.value = text.to_string(),
EntityKind::MText(t) => t.contents = text.replace('\n', "\\P"),
EntityKind::MLeader(m) if m.text.is_some() => {
if let Some(t) = &mut m.text {
t.contents = text.replace('\n', "\\P");
}
}
EntityKind::Dimension(d) => {
d.text = if text == "<>" { String::new() } else { text.to_string() };
d.block = None;
}
_ => return Err(other("Select a text, mtext, attribute definition or dimension.")),
_ => return Err(other("Select a text, mtext, multileader, attribute definition or dimension.")),
}
set_kind(s, h, k)
}
@@ -53,12 +60,18 @@ pub(super) struct TextEditM {
single: bool,
/// Asking for the edit mode.
mode: bool,
/// The MTEXT being edited, for the in-place editor (#842).
mtext: Option<cadcraft_doc::MText>,
}
impl Interactive for TextEditM {
fn name(&self) -> &'static str {
"TEXTEDIT"
}
/// An MTEXT asking for its new text opens in the in-place editor with its contents.
fn editing_mtext(&self) -> Option<cadcraft_doc::MText> {
self.h.as_ref().and(self.mtext.clone())
}
fn prompt(&self, _s: &Session) -> Prompt {
if self.mode {
let current = if self.single { "Single" } else { "Multiple" };
@@ -83,7 +96,24 @@ impl Interactive for TextEditM {
match (&self.h, i) {
(None, Input::Point(p)) => {
let h = curves::pick_at(s, p).ok_or_else(|| other("*Invalid selection*"))?;
let old = text_of(&curves::entity(s, h)?.kind).ok_or_else(|| other("Select a text, mtext, attribute definition or dimension."))?;
// Refused when picked, not after the new text has been typed.
if curves::is_locked(s, h) {
return Err(other("The object is on a locked layer."));
}
let kind = curves::entity(s, h)?.kind;
let old = text_of(&kind).ok_or_else(|| other("Select a text, mtext, multileader, attribute definition or dimension."))?;
self.mtext = match kind {
EntityKind::MText(m) => Some(m),
// A multileader's text opens in the same editor (#1081).
EntityKind::MLeader(m) => m.text,
_ => None,
};
// The editor would drop part of a text this long, and saving would lose it: the
// command line asks for it instead.
if self.mtext.as_ref().is_some_and(|m| !crate::mtext_edit::Formatted::fits(&m.contents)) {
self.mtext = None;
s.echo("This text is too long for the editor; enter the new text at the command line.");
}
self.h = Some((h, old));
Ok(Step::Continue)
}
@@ -93,10 +123,12 @@ impl Interactive for TextEditM {
set_text(s, h, &t)?;
self.edits.push((h, before));
self.h = None;
self.mtext = None;
Ok(if self.single { Step::Done } else { Step::Continue })
}
(Some(_), Input::Enter) => {
self.h = None;
self.mtext = None;
Ok(if self.single { Step::Done } else { Step::Continue })
}
(None, Input::Enter) => Ok(Step::Done),
+107 -363
View File
@@ -6,22 +6,31 @@ mod chprop;
mod dash_units;
mod matchprop;
mod rename;
mod set;
pub use matchprop::MatchProps;
use set::run_set;
use cadcraft_color::Color;
use cadcraft_doc::{EntityKind, Handle, Lineweight, Transparency};
use cadcraft_geom::Vec3;
use cadcraft_doc::{EntityKind, Lineweight, Transparency};
use serde_json::{Value, json};
use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, point_value, str_param, targets};
use super::{CommandSpec, always, bad, bool_or, f64_req, find_command, ok, point_req, str_param, targets};
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("properties", "Properties", run_get).menu(&["Modify", "Properties"]).alias(&["pr", "props", "ch"]).params("{handles?} → properties of the selection").noundo(),
CommandSpec::new("properties.set", "Set Properties", run_set).params("{handles?, layer?, color?, linetype?, lineweight?, ltscale?, thickness?, transparency?: \"ByLayer\" | \"ByBlock\" | 0..90, visible?, <geometry fields: radius, center, start, end, text, height, rotation…>; dimensions: textOverride, dimStyle, textHeight, arrowSize, dimScale, precision (per-dimension overrides)} → {changed, locked, message?}: objects on locked layers (and, during REFEDIT, outside the working set) are left out, and `message` says how many"),
CommandSpec::new("properties.set", "Set Properties", run_set).params(
"{handles?, layer?, color?, linetype?, lineweight?, ltscale?, thickness?, transparency?: \"ByLayer\" | \"ByBlock\" | 0..90, visible?, annotative?, \
<geometry fields: radius, center, start, end, text, height, rotation…>, text: style?, justify?, oblique?, positionX/Y/Z?, alignmentX/Y?, \
mtext: style?, justify?, lineSpacing?, lineSpacingDistance?, lineSpacingStyle?: atLeast | exactly, positionX/Y/Z?, \
dimension: dimStyle?, textOverride?, textRotation?, textPositionX/Y?, prefix?, suffix?, altPrefix?, altSuffix?, dimScale?, precision?, \
<dimension style variables (field or DIM* name, e.g. textHeight / DIMTXT) set as overrides of each dimension>, clearOverrides?, clear?: [variable]} \
→ {changed, locked, message?, ignored: keys no selected object took} (the keys are those of `properties.describe` rows): objects on locked layers \
(and, during REFEDIT, outside the working set) are left out, and `message` says how many",
),
CommandSpec::new("chprop", "Change Properties", run_set)
.params("as properties.set, leaving out objects on locked layers (and, during REFEDIT, outside the working set) → {changed, locked, message?} (the command line asks Color, LAyer, LType, ltScale, LWeight, Thickness and TRansparency in turn)")
.interactive(|_| Ok(Box::new(chprop::ChpropM::new()))),
@@ -29,6 +38,13 @@ pub fn specs() -> Vec<CommandSpec> {
.alias(&["-ch"])
.params("{handles?, point?: [x, y], elevation?} → {changed, ignored, differingZ, detachedHatches, locked}: the point moves the nearer end of each line to it (level or plumb with the other end under ORTHOMODE) and, when it is the one object, passes a circle through it or places a text, attribute definition or block reference at it (`ignored` otherwise); `elevation` sets the z of objects whose points share one (`differingZ` otherwise); objects on locked layers are left out (the command line asks Specify change point or [Properties], then about each circle, text, attribute definition and block reference in turn)")
.interactive(|_| Ok(Box::new(change::ChangeM::new()))),
CommandSpec::new("properties.describe", "Describe Properties", run_describe)
.params(
"{handles?, type?: one of the `types` names, to describe only those objects} → {types: [{type, count}], filter?, count, \
groups: [{name, rows: [{key, label, kind, value, varies, display, editable, note?, overridden?, options?: [{value, label}], quick?}]}]} \
(each row's `key` is the `properties.set` key that changes it; text, mtext and dimensions have their own groups)",
)
.noundo(),
CommandSpec::new("matchprop", "Match Properties", matchprop::run_matchprop)
.menu(&["Modify", "Match Properties"])
.alias(&["ma", "painter"])
@@ -172,10 +188,13 @@ fn parse_color(v: &Value) -> Option<Color> {
/// A transparency as JSON, in the form `properties.set` takes: "ByLayer", "ByBlock" or a percentage.
pub(super) fn transparency_value(t: Transparency) -> Value {
match t {
Transparency::Percent(p) => json!(p),
other => json!(other.name()),
}
crate::properties::transparency_value(t)
}
fn run_describe(s: &mut Session, p: &Value) -> Result<Value> {
let hs = targets(s, p)?;
let d = s.doc()?;
Ok(serde_json::to_value(crate::properties::describe(d, &hs, str_param(p, "type"))).unwrap_or(Value::Null))
}
/// "ByLayer", "ByBlock" or a percentage 0..=90 (a number, or a string such as "50" or "50%").
@@ -189,358 +208,6 @@ fn parse_transparency(v: &Value) -> Option<Transparency> {
(pct.is_finite() && (0.0..=90.0).contains(&pct)).then(|| Transparency::Percent(pct.round() as u8))
}
fn set_xy(p: &mut Vec3, v: &Value) {
if let Some(q) = point_value(v) {
p.x = q.x;
p.y = q.y;
}
}
/// The objects `properties.set` leaves alone, as CHPROP, MATCHPROP and MOVE do: those on locked
/// layers and, while a reference is edited in place, those outside the working set.
#[derive(Default)]
struct LeftOut {
locked: usize,
outside: usize,
}
impl LeftOut {
/// `hs` without the objects that can't be edited, each object once, and how many those were. A
/// handle that names no object is an error, before anything changes.
fn split(s: &Session, hs: Vec<Handle>) -> Result<(Vec<Handle>, LeftOut)> {
let d = s.doc()?;
// The working set, once: `RefEdit::is_working` searches a list.
let working: Option<std::collections::HashSet<Handle>> = d.refedit.as_ref().map(|r| r.items.iter().map(|i| i.copy).collect());
let mut seen = std::collections::HashSet::new();
let mut out = LeftOut::default();
let mut free = Vec::new();
for h in hs {
let Some(e) = d.entity(h) else {
return Err(cadcraft_doc::DocError::NoEntity(h).into());
};
if !seen.insert(h) {
continue;
}
if working.as_ref().is_some_and(|w| !w.contains(&h)) {
out.outside += 1;
} else if d.layer(&e.common.layer).is_some_and(|l| l.locked) {
out.locked += 1;
} else {
free.push(h);
}
}
Ok((free, out))
}
/// `{changed, locked}`, and a message saying how many were left out when any were.
fn result(&self, changed: usize) -> Value {
let mut notes = Vec::new();
match self.locked {
0 => {}
1 => notes.push("1 object was on a locked layer.".to_string()),
n => notes.push(format!("{n} objects were on a locked layer.")),
}
match self.outside {
0 => {}
1 => notes.push("1 object was not in the working set.".to_string()),
n => notes.push(format!("{n} objects were not in the working set.")),
}
if changed == 0 && !notes.is_empty() {
notes.push("Nothing was changed.".to_string());
}
let mut r = json!({ "changed": changed, "locked": self.locked + self.outside });
if !notes.is_empty()
&& let Some(o) = r.as_object_mut()
{
o.insert("message".into(), json!(notes.join(" ")));
}
r
}
}
fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
let hs = targets(s, p)?;
if hs.is_empty() {
return Err(bad("properties.set", "nothing selected"));
}
let (hs, left_out) = LeftOut::split(s, hs)?;
let color = p.get("color").map(|c| parse_color(c).ok_or_else(|| bad("properties.set", "bad colour"))).transpose()?;
let transparency = p
.get("transparency")
.map(|v| parse_transparency(v).ok_or_else(|| bad("properties.set", "transparency must be ByLayer, ByBlock or a percentage from 0 to 90")))
.transpose()?;
let thickness = p
.get("thickness")
.map(|v| v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("properties.set", "thickness must be a finite number")))
.transpose()?;
let lw = p.get("lineweight").map(|v| super::layer::parse_lw(v).ok_or_else(|| bad("properties.set", "bad lineweight"))).transpose()?;
let d = s.doc()?;
// An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
let linetype = str_param(p, "linetype")
.map(|n| {
if n.eq_ignore_ascii_case("ByLayer") || n.eq_ignore_ascii_case("ByBlock") {
Ok(n.to_string())
} else {
d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))
}
})
.transpose()?;
let dim_style = str_param(p, "dimStyle")
.map(|n| d.dim_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("dimension style `{n}` not found"))))
.transpose()?;
let dim_over = dim_overrides(p)?;
if hs.is_empty() {
// Every object was left out: the drawing stays as it was, with no undo step.
return Ok(left_out.result(0));
}
let d = s.doc_mut()?;
if let Some(l) = str_param(p, "layer") {
d.ensure_layer(l);
}
let anno_scale = d.current_anno_scale();
let common = CommonEntityProperties { anno_scale: &anno_scale, color, linetype: linetype.as_deref(), lineweight: lw, transparency, thickness };
for h in &hs {
d.modify_entity(*h, |e| {
set_common_properties(e, p, &common);
apply_kind_properties(e, p, dim_style.as_ref(), &dim_over);
})?;
}
Ok(left_out.result(hs.len()))
}
fn apply_kind_properties(
entity: &mut cadcraft_doc::Entity,
params: &Value,
dim_style: Option<&String>,
dim_overrides: &serde_json::Map<String, Value>,
) {
let num = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
match &mut entity.kind {
EntityKind::Line(l) => {
if let Some(v) = params.get("start") {
set_xy(&mut l.a, v);
}
if let Some(v) = params.get("end") {
set_xy(&mut l.b, v);
}
// Length / angle keep the start point and move the end point.
let (a, b) = (l.a.xy(), l.b.xy());
let len = num("length").filter(|x| *x > 0.0 && *x < 1e15).unwrap_or_else(|| a.dist(b));
let ang = num("angle").map(f64::to_radians).unwrap_or_else(|| a.angle_to(b));
if num("length").is_some() || num("angle").is_some() {
let e = cadcraft_geom::Vec2::polar(a, len, ang);
if e.is_finite() {
l.b.x = e.x;
l.b.y = e.y;
}
}
}
EntityKind::Circle(c) => {
if let Some(v) = params.get("center") {
set_xy(&mut c.center, v);
}
if let Some(r) = num("radius").filter(|r| *r > 0.0) {
c.radius = r;
}
if let Some(dm) = num("diameter").filter(|r| *r > 0.0) {
c.radius = dm / 2.0;
}
if let Some(cf) = num("circumference").filter(|x| *x > 0.0) {
c.radius = cf / cadcraft_geom::TAU;
}
if let Some(a) = num("area").filter(|x| *x > 0.0) {
c.radius = (a / cadcraft_geom::PI).sqrt();
}
}
EntityKind::Arc(a) => {
if let Some(v) = params.get("center") {
set_xy(&mut a.center, v);
}
if let Some(r) = num("radius").filter(|r| *r > 0.0) {
a.radius = r;
}
if let Some(x) = num("startAngle") {
a.start = cadcraft_geom::norm_angle(x.to_radians());
}
if let Some(x) = num("endAngle") {
a.end = cadcraft_geom::norm_angle(x.to_radians());
}
}
EntityKind::Text(t) => {
if let Some(v) = str_param(params, "text") {
t.value = v.to_string();
}
if let Some(x) = num("height").filter(|x| *x > 0.0) {
t.height = x;
}
if let Some(x) = num("rotation") {
t.rotation = x.to_radians();
}
if let Some(x) = num("widthFactor").filter(|x| *x > 0.0) {
t.width_factor = x;
}
// The position is the point the text is placed by: moving it moves the text.
if let Some(to) = params.get("position").and_then(point_value) {
let d = to - t.justify_point();
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
q.x += d.x;
q.y += d.y;
}
}
}
EntityKind::MText(t) => {
if let Some(v) = str_param(params, "text") {
t.contents = v.replace('\n', "\\P");
}
if let Some(x) = num("height").filter(|x| *x > 0.0) {
t.height = x;
}
if let Some(x) = num("width").filter(|x| *x >= 0.0) {
t.width = x;
}
if let Some(x) = num("rotation") {
t.rotation = x.to_radians();
}
}
EntityKind::LwPolyline(pl) => {
if let Some(x) = num("width").filter(|x| *x >= 0.0) {
pl.const_width = x;
}
if let Some(c) = params.get("closed").and_then(Value::as_bool) {
pl.closed = c;
}
}
EntityKind::Insert(insert) => set_insert_properties(insert, params),
EntityKind::Dimension(dimension) => set_dimension_properties(dimension, params, dim_style, dim_overrides),
EntityKind::Hatch(hatch) => set_hatch_properties(hatch, params),
_ => {}
}
}
fn set_insert_properties(insert: &mut cadcraft_doc::Insert, params: &Value) {
let number = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
if let Some(x) = number("rotation") {
let turn = x.to_radians() - insert.rotation;
insert.rotation = x.to_radians();
// The attached text turns with the reference, around its insertion point (as ROTATE does).
let base = insert.insert.xy();
for a in &mut insert.attribs {
let t = &mut a.text;
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
let r = q.xy().rotate_about(base, turn);
q.x = r.x;
q.y = r.y;
}
t.rotation = cadcraft_geom::norm_angle(t.rotation + turn);
if let Some(ml) = &mut a.multiline {
let r = ml.mtext.insert.xy().rotate_about(base, turn);
ml.mtext.insert.x = r.x;
ml.mtext.insert.y = r.y;
ml.mtext.rotation = cadcraft_geom::norm_angle(ml.mtext.rotation + turn);
}
}
}
if let Some(x) = number("scale").filter(|x| *x != 0.0) {
// A new positive scale carries the attached attribute text with it, like SCALE about the insertion point.
if x > 0.0 && insert.scale.x > 0.0 {
let m = cadcraft_geom::Mat3::scale_about(insert.insert.xy(), x / insert.scale.x);
for a in &mut insert.attribs {
let mut k = EntityKind::Text(a.text.clone());
k.transform(&m);
if let EntityKind::Text(t) = k {
a.text = t;
}
a.transform_multiline(&m);
}
}
insert.scale = Vec3::new(x, x, x);
}
}
fn set_dimension_properties(
dimension: &mut cadcraft_doc::Dimension,
params: &Value,
style: Option<&String>,
overrides: &serde_json::Map<String, Value>,
) {
if let Some(v) = str_param(params, "textOverride") {
dimension.text = v.to_string();
dimension.block = None;
}
if let Some(st) = style {
dimension.style.clone_from(st);
dimension.block = None;
}
if !overrides.is_empty() {
dimension.overrides.extend(overrides.clone());
dimension.block = None;
}
}
fn set_hatch_properties(hatch: &mut cadcraft_doc::Hatch, params: &Value) {
let number = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
if let Some(v) = str_param(params, "pattern") {
if !hatch.pattern.eq_ignore_ascii_case(v) {
hatch.pattern_lines = super::hatch::lines_for(v);
}
hatch.pattern = v.to_ascii_uppercase();
// The old pattern's definition lines no longer apply.
hatch.pattern_lines.clear();
hatch.solid = hatch.pattern == "SOLID";
if !hatch.solid {
// A named pattern replaces the gradient fill; the renderer draws the gradient first when it is set.
hatch.gradient = None;
}
}
if let Some(x) = number("scale").filter(|x| *x > 0.0) {
hatch.scale = x;
}
if let Some(x) = number("angle") {
hatch.angle = x.to_radians();
}
}
struct CommonEntityProperties<'a> {
anno_scale: &'a cadcraft_doc::AnnoScale,
color: Option<Color>,
linetype: Option<&'a str>,
lineweight: Option<Lineweight>,
transparency: Option<Transparency>,
thickness: Option<f64>,
}
fn set_common_properties(entity: &mut cadcraft_doc::Entity, params: &Value, common: &CommonEntityProperties<'_>) {
if let Some(annotative) = params.get("annotative").and_then(Value::as_bool) {
cadcraft_doc::set_annotative(entity, annotative, common.anno_scale);
}
if let Some(layer) = str_param(params, "layer") {
entity.common.layer = layer.to_string();
}
if let Some(color) = common.color {
entity.common.color = color;
}
if let Some(linetype) = common.linetype {
entity.common.linetype = linetype.to_string();
}
if let Some(lineweight) = common.lineweight {
entity.common.lineweight = lineweight;
}
if let Some(scale) = params.get("ltscale").and_then(Value::as_f64).filter(|scale| *scale > 0.0) {
entity.common.ltscale = scale;
}
if let Some(transparency) = common.transparency {
entity.common.transparency = transparency;
}
if let Some(thickness) = common.thickness {
entity.common.thickness = thickness;
}
if let Some(visible) = params.get("visible").and_then(Value::as_bool) {
entity.common.visible = visible;
}
}
fn run_color(s: &mut Session, p: &Value) -> Result<Value> {
let c = p.get("color").and_then(parse_color).ok_or_else(|| bad("color", "`color` is required"))?;
set_current_color(s.doc_mut()?, c);
@@ -780,6 +447,8 @@ fn run_style(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad("style", "bad style name"));
}
let d = s.doc_mut()?;
// As it was (none for a new style), so dimensions are redrawn only when it changes.
let before = d.text_style(&name).cloned();
let idx = match d.text_styles.iter().position(|t| t.name.eq_ignore_ascii_case(&name)) {
Some(i) => i,
None => {
@@ -815,6 +484,13 @@ fn run_style(s: &mut Session, p: &Value) -> Result<Value> {
}
}
}
// Dimensions whose text uses the style drop the geometry they were read with when it
// changed: their text changes with it. Only making it current keeps that geometry.
if before.as_ref() != d.text_styles.get(idx) {
let text_style_of: std::collections::HashMap<String, String> =
d.dim_styles.iter().map(|st| (st.name.to_ascii_lowercase(), st.text_style.clone())).collect();
regen_dims(d, |dm| dim_text_style(dm, &text_style_of).eq_ignore_ascii_case(&name))?;
}
if bool_or(p, "current", true) {
d.header.set_str("TEXTSTYLE", &name);
}
@@ -843,12 +519,19 @@ pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
let stores = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).chain(d.blocks.values().map(|b| &b.entities));
for st in stores {
for e in st.iter() {
out.extend(super::blocks::object_attribs(e).iter().flat_map(attrib_text_styles));
match &e.kind {
EntityKind::Text(t) => out.push(t.style.clone()),
EntityKind::MText(t) => out.push(t.style.clone()),
EntityKind::AttDef(a) => out.push(a.text.style.clone()),
EntityKind::Insert(i) => out.extend(i.attribs.iter().map(|a| a.text.style.clone())),
EntityKind::AttDef(a) => out.extend(attrib_text_styles(a)),
EntityKind::MLeader(m) => out.extend(m.text.iter().map(|t| t.style.clone())),
// A dimension's own text style (a DIMTXSTY override), which a rename follows too.
EntityKind::Dimension(dm) => out.extend(
dm.overrides
.iter()
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k) == Some("textStyle"))
.filter_map(|(_, v)| super::blocks::purge::override_name(v)),
),
_ => {}
}
}
@@ -856,6 +539,11 @@ pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
out
}
/// The text styles of an attribute or attribute definition, its multiline text included.
fn attrib_text_styles(a: &cadcraft_doc::Attrib) -> impl Iterator<Item = String> + '_ {
std::iter::once(a.text.style.clone()).chain(a.multiline.iter().map(|m| m.mtext.style.clone()))
}
fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
let from = str_param(p, "from").ok_or_else(|| bad("style.rename", "`from` is required"))?.to_string();
let to = str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("style.rename", "`to` is required"))?.to_string();
@@ -885,6 +573,7 @@ fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
EntityKind::AttDef(a) => a.text.style.eq_ignore_ascii_case(&from),
EntityKind::Insert(i) => i.attribs.iter().any(|a| a.text.style.eq_ignore_ascii_case(&from)),
EntityKind::MLeader(m) => m.text.iter().any(|t| t.style.eq_ignore_ascii_case(&from)),
EntityKind::Dimension(dm) => dm.overrides.iter().any(|(k, v)| is_text_style_override(k, v, &from)),
_ => false,
};
let repoint = |k: &mut EntityKind| match k {
@@ -893,6 +582,8 @@ fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
EntityKind::AttDef(a) => fix(&mut a.text.style),
EntityKind::Insert(i) => i.attribs.iter_mut().for_each(|a| fix(&mut a.text.style)),
EntityKind::MLeader(m) => m.text.iter_mut().for_each(|t| fix(&mut t.style)),
// A dimension's own text style (a DIMTXSTY override).
EntityKind::Dimension(dm) => dm.overrides.iter_mut().filter(|(k, v)| is_text_style_override(k, v, &from)).for_each(|(_, v)| *v = json!(to)),
_ => {}
};
let mut hs: Vec<cadcraft_doc::Handle> = d.model.iter().filter(|e| uses(&e.kind)).map(|e| e.handle).collect();
@@ -942,7 +633,14 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
if name.is_empty() || name.len() > 255 {
return Err(bad("dimstyle", "bad style name"));
}
// A new style's name is one -DIMSTYLE takes (no `~`, which its Restore reads as compare, or
// wildcards); a style read from a file keeps the name it has.
if s.doc()?.dim_style(&name).is_none() {
super::dimstyle_cli::check_name(&name).map_err(|_| bad("dimstyle", "bad style name"))?;
}
let d = s.doc_mut()?;
// As it was (none for a new style), so dimensions are redrawn only when it changes.
let before = d.dim_style(&name).cloned();
let base = d.dim_style(&d.header.str("DIMSTYLE", "Standard")).cloned().unwrap_or_default();
let idx = match d.dim_styles.iter().position(|t| t.name.eq_ignore_ascii_case(&name)) {
Some(i) => i,
@@ -957,6 +655,12 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
src.iter().filter(|(k, _)| !matches!(k.as_str(), "name" | "current")).map(|(k, v)| (k.clone(), v.clone())).collect();
rejected = st.apply_fields(&fields);
}
// Dimensions with the style drop the geometry they were read with when it changed, so they
// show the edit (as AutoCAD updates every dimension that uses a style; their overrides still
// win). Only making it current keeps that geometry.
if before.as_ref() != d.dim_styles.get(idx) {
regen_dims(d, |dm| dm.style.eq_ignore_ascii_case(&name))?;
}
if bool_or(p, "current", true) {
d.header.set_str("DIMSTYLE", &name);
}
@@ -968,7 +672,8 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
if !rejected.is_empty()
&& let Some(o) = out.as_object_mut()
{
o.insert("ignored".into(), json!(rejected));
o.insert("ignored".into(), json!(rejected.clone()));
o.insert("message".into(), json!(format!("Ignored invalid value for: {}", rejected.join(", "))));
}
Ok(out)
}
@@ -999,6 +704,44 @@ fn run_dimstyle_current(s: &mut Session, p: &Value) -> Result<Value> {
Ok(dimstyles_json(d))
}
/// Dimensions (in model space, layouts and block definitions) that `uses` matches drop the
/// geometry block they were read with, so they are drawn and saved from their style again.
pub(super) fn regen_dims(d: &mut cadcraft_doc::Drawing, uses: impl Fn(&cadcraft_doc::Dimension) -> bool) -> Result<()> {
let stale = |e: &cadcraft_doc::Entity| matches!(&e.kind, EntityKind::Dimension(dm) if dm.block.is_some() && uses(dm));
let regen = |e: &mut cadcraft_doc::Entity| {
if let EntityKind::Dimension(dm) = &mut e.kind {
dm.block = None;
}
};
let mut hs: Vec<cadcraft_doc::Handle> = d.model.iter().filter(|e| stale(e)).map(|e| e.handle).collect();
hs.extend(d.layouts.iter().flat_map(|l| l.entities.iter().filter(|e| stale(e)).map(|e| e.handle)));
for h in hs {
d.modify_entity(h, regen)?;
}
for block in d.blocks.values_mut() {
let hs: Vec<cadcraft_doc::Handle> = block.entities.iter().filter(|e| stale(e)).map(|e| e.handle).collect();
if !hs.is_empty() {
let b = std::sync::Arc::make_mut(block);
for h in hs {
b.entities.modify(h, regen);
}
}
}
Ok(())
}
/// The text style a dimension's text is drawn with: its DIMTXSTY override, else its style's
/// (`text_style_of`: lower-case dimension style name → text style).
fn dim_text_style(dm: &cadcraft_doc::Dimension, text_style_of: &std::collections::HashMap<String, String>) -> String {
let own = dm.overrides.iter().find(|(k, _)| cadcraft_doc::DimStyle::field_name(k) == Some("textStyle")).and_then(|(_, v)| v.as_str());
own.map(str::to_string).or_else(|| text_style_of.get(&dm.style.to_ascii_lowercase()).cloned()).unwrap_or_else(|| "Standard".into())
}
/// Whether a dimension override `k: v` names text style `style`.
fn is_text_style_override(k: &str, v: &Value, style: &str) -> bool {
cadcraft_doc::DimStyle::field_name(k) == Some("textStyle") && v.as_str().is_some_and(|n| n.eq_ignore_ascii_case(style))
}
fn dims_using(d: &cadcraft_doc::Drawing, name: &str) -> Vec<(cadcraft_doc::Space, cadcraft_doc::Handle)> {
let mut out = Vec::new();
for space in std::iter::once(cadcraft_doc::Space::Model).chain(d.layouts.iter().map(|l| cadcraft_doc::Space::Paper(l.name.clone()))) {
@@ -1041,6 +784,7 @@ fn block_dims_using(d: &cadcraft_doc::Drawing, name: &str) -> Vec<(String, cadcr
fn run_dimstyle_rename(s: &mut Session, p: &Value) -> Result<Value> {
let from = str_param(p, "from").ok_or_else(|| bad("dimstyle.rename", "`from` is required"))?.to_string();
let to = str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("dimstyle.rename", "`to` is required"))?.to_string();
let to = super::dimstyle_cli::check_name(&to).map_err(|_| bad("dimstyle.rename", "bad style name"))?;
let d = s.doc_mut()?;
if from.eq_ignore_ascii_case("Standard") {
return Err(bad("dimstyle.rename", "the Standard style cannot be renamed"));
+781
View File
@@ -0,0 +1,781 @@
//! `properties.set`: change properties of the selected objects, the way the Properties palette
//! edits them. Keys that no selected object takes come back in `ignored`.
use std::collections::{BTreeSet, HashMap};
use cadcraft_color::Color;
use cadcraft_doc::{
AnnoScale, Arc, Circle, DimStyle, Dimension, Drawing, Entity, EntityKind, HAlign, Handle, Hatch, Insert, Line, Lineweight, MText, Text,
Transparency, VAlign,
};
use cadcraft_geom::{Vec2, Vec3};
use serde_json::{Value, json};
use super::{parse_color, parse_transparency};
use crate::cmd::{bad, point_value, str_param, targets};
use crate::properties::{LINE_PITCH, is_dim_linetype, join_post, split_post};
use crate::{Result, Session};
fn set_xy(p: &mut Vec3, v: &Value) {
if let Some(q) = point_value(v) {
p.x = q.x;
p.y = q.y;
}
}
/// Keys `properties.set` handles itself; the rest that name a dimension style variable (a field
/// such as `textHeight` or a DIM* name such as `DIMTXT`) set per-dimension overrides.
const SET_KEYS: &[&str] = &[
"handles",
"handle",
"layer",
"color",
"linetype",
"lineweight",
"ltscale",
"thickness",
"transparency",
"visible",
"annotative",
"dimStyle",
"textOverride",
"textRotation",
"textPositionX",
"textPositionY",
"clearOverrides",
"clear",
"prefix",
"suffix",
"altPrefix",
"altSuffix",
// An insert's or hatch's scale; a dimension's overall scale is `dimScale` (or DIMSCALE).
"scale",
];
/// The dimension style variables of a call, checked once: canonical field names with their
/// values, and the keys they were given as. Unusable values are left out (and so `ignored`).
struct DimVars {
fields: Vec<(&'static str, Value)>,
keys: Vec<String>,
}
impl DimVars {
fn new(d: &Drawing, p: &Value) -> Result<Self> {
// Text height, arrow size, overall scale (`dimScale`) and precision are refused, not
// ignored, when unusable, and the last two have names of their own (#1473).
let checked = super::dim_overrides(p)?;
let mut given = serde_json::Map::new();
for (k, v) in p.as_object().into_iter().flatten() {
if SET_KEYS.contains(&k.as_str()) {
continue;
}
let Some(field) = DimStyle::field_name(k).filter(|f| !matches!(*f, "name" | "annotative")) else { continue };
let v = match (field, v.as_str()) {
// A text style or linetype that doesn't exist would fall back without a word.
("textStyle", Some(n)) => {
json!(d.text_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("text style `{n}` not found")))?)
}
(f, Some(n)) if is_dim_linetype(f) => {
if n.is_empty() || n.eq_ignore_ascii_case("ByBlock") {
json!("")
} else {
json!(d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))?)
}
}
// Closed filled is `""` among the arrowheads, but an empty per-end arrowhead draws
// DIMBLK's: chosen for one end, it's named.
("arrowBlock1" | "arrowBlock2", Some("")) => json!("_CLOSEDFILLED"),
_ => v.clone(),
};
given.insert(k.clone(), v);
}
let rejected = DimStyle::default().apply_fields(&given);
let mut out = DimVars { fields: Vec::new(), keys: Vec::new() };
for (k, v) in given {
if rejected.contains(&k) {
continue;
}
if let Some(f) = DimStyle::field_name(&k) {
out.fields.push((f, v));
out.keys.push(k);
}
}
for (key, field) in [("dimScale", "scale"), ("precision", "decimals")] {
if let Some(v) = checked.get(field) {
out.fields.push((field, v.clone()));
out.keys.push(key.to_string());
}
}
Ok(out)
}
}
/// What some edits need to know about objects before they change.
#[derive(Default)]
struct Prepared {
/// TEXT made aligned or fit: where its baseline ends (its width along its rotation).
ends: HashMap<Handle, Vec2>,
/// Dimensions: where their text is drawn now.
text_pos: HashMap<Handle, Vec2>,
/// The DIMPOST and DIMAPOST templates of each dimension style (by lowercase name), when a
/// prefix or suffix is edited: a dimension's are worked out after its other edits.
posts: Option<HashMap<String, (String, String)>>,
}
impl Prepared {
fn new(d: &Drawing, p: &Value, hs: &[Handle]) -> Self {
let mut out = Prepared::default();
let two_points = str_param(p, "justify").and_then(crate::cmd::draw::justify).is_some_and(|(h, _)| matches!(h, HAlign::Aligned | HAlign::Fit));
let moves_text = p.get("textPositionX").is_some() || p.get("textPositionY").is_some();
let posts = ["prefix", "suffix", "altPrefix", "altSuffix"].iter().any(|k| p.get(*k).is_some());
if !(two_points || moves_text || posts) {
return out;
}
for h in hs {
let Some(e) = d.entity(*h) else { continue };
match &e.kind {
EntityKind::Text(t) if two_points => {
// The text as this call leaves it: its contents, style, height, width factor
// and rotation, where the call sets them too.
let num = |k: &str| p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite());
let style = str_param(p, "style").and_then(|n| d.text_style(n)).map_or(t.style.as_str(), |s| s.name.as_str());
let value = str_param(p, "text").unwrap_or(&t.value);
let height = num("height").filter(|x| *x > 0.0).unwrap_or(t.height);
let width_factor = num("widthFactor").filter(|x| *x > 0.0).unwrap_or(t.width_factor);
let rotation = num("rotation").map_or(t.rotation, f64::to_radians);
let font = cadcraft_fonts::TextFont::resolve(&d.text_style(style).cloned().unwrap_or_default().font);
let w = cadcraft_fonts::text_width(&font, value, height, width_factor);
let w = if w.is_finite() && w > 1e-9 { w } else { height.max(1e-9) };
out.ends.insert(*h, Vec2::polar(t.justify_point(), w, rotation));
}
EntityKind::Dimension(dm) if moves_text => {
out.text_pos.insert(*h, cadcraft_render::dimension_in(d, dm).text_pos);
}
_ => {}
}
}
if posts {
out.posts = Some(d.dim_styles.iter().map(|st| (st.name.to_ascii_lowercase(), (st.post.clone(), st.alt_post.clone()))).collect());
}
out
}
}
/// Give TEXT a justification. It keeps the point it is placed by, so the text moves (as
/// AutoCAD's Properties Justify does); aligned and fit text then ends at `end`.
fn set_justify(t: &mut Text, h: HAlign, v: VAlign, end: Option<Vec2>) {
let at = t.justify_point();
let z = t.insert.z;
let was_two_points = matches!(t.halign, HAlign::Aligned | HAlign::Fit) && t.align_pt.is_some();
let two_points = matches!(h, HAlign::Aligned | HAlign::Fit);
t.halign = h;
t.valign = if two_points { VAlign::Baseline } else { v };
if two_points {
// Between aligned and fit the two points stay.
if !was_two_points {
t.insert = at.to3(z);
t.align_pt = Some(end.unwrap_or_else(|| Vec2::polar(at, t.height.max(1e-9), t.rotation)).to3(z));
}
} else if (h, v) == (HAlign::Left, VAlign::Baseline) {
t.insert = at.to3(z);
t.align_pt = None;
} else {
t.insert = at.to3(z);
t.align_pt = Some(at.to3(z));
}
}
/// Move TEXT by `d` (both of its points).
fn shift(t: &mut Text, d: Vec2) {
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
q.x += d.x;
q.y += d.y;
}
}
/// Set a per-dimension override, replacing the same variable under another spelling (a DIM*
/// name read from a file).
fn set_override(dm: &mut cadcraft_doc::Dimension, field: &'static str, v: Value) {
dm.overrides.retain(|k, _| DimStyle::field_name(k) != Some(field));
dm.overrides.insert(field.to_string(), v);
}
/// A `properties.set` call, checked before any object changes: the values every object takes,
/// and what the edits need to know beforehand.
struct Call<'a> {
p: &'a Value,
color: Option<Color>,
transparency: Option<Transparency>,
thickness: Option<f64>,
lineweight: Option<Lineweight>,
linetype: Option<String>,
dim_style: Option<String>,
text_style: Option<String>,
dim_vars: DimVars,
prep: Prepared,
anno_scale: AnnoScale,
}
/// The keys some object took.
type Used<'c> = BTreeSet<&'c str>;
impl Call<'_> {
/// A finite number under `k`.
fn num(&self, k: &str) -> Option<f64> {
self.p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite())
}
}
/// The objects `properties.set` leaves alone, as CHPROP, MATCHPROP and MOVE do: those on locked
/// layers and, while a reference is edited in place, those outside the working set.
#[derive(Default)]
struct LeftOut {
locked: usize,
outside: usize,
}
impl LeftOut {
/// `hs` without the objects that can't be edited, each object once, and how many those were. A
/// handle that names no object is an error, before anything changes.
fn split(s: &Session, hs: Vec<Handle>) -> Result<(Vec<Handle>, LeftOut)> {
let d = s.doc()?;
// The working set, once: `RefEdit::is_working` searches a list.
let working: Option<std::collections::HashSet<Handle>> = d.refedit.as_ref().map(|r| r.items.iter().map(|i| i.copy).collect());
let mut seen = std::collections::HashSet::new();
let mut out = LeftOut::default();
let mut free = Vec::new();
for h in hs {
let Some(e) = d.entity(h) else {
return Err(cadcraft_doc::DocError::NoEntity(h).into());
};
if !seen.insert(h) {
continue;
}
if working.as_ref().is_some_and(|w| !w.contains(&h)) {
out.outside += 1;
} else if d.layer(&e.common.layer).is_some_and(|l| l.locked) {
out.locked += 1;
} else {
free.push(h);
}
}
Ok((free, out))
}
/// `{changed, locked, ignored}`, and a message saying how many were left out when any were.
fn result(&self, changed: usize, ignored: &[&str]) -> Value {
let mut notes = Vec::new();
match self.locked {
0 => {}
1 => notes.push("1 object was on a locked layer.".to_string()),
n => notes.push(format!("{n} objects were on a locked layer.")),
}
match self.outside {
0 => {}
1 => notes.push("1 object was not in the working set.".to_string()),
n => notes.push(format!("{n} objects were not in the working set.")),
}
if changed == 0 && !notes.is_empty() {
notes.push("Nothing was changed.".to_string());
}
let mut r = json!({ "changed": changed, "locked": self.locked + self.outside, "ignored": ignored });
if !notes.is_empty()
&& let Some(o) = r.as_object_mut()
{
o.insert("message".into(), json!(notes.join(" ")));
}
r
}
}
pub(super) fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
let hs = targets(s, p)?;
if hs.is_empty() {
return Err(bad("properties.set", "nothing selected"));
}
let (hs, left_out) = LeftOut::split(s, hs)?;
let color = p.get("color").map(|c| parse_color(c).ok_or_else(|| bad("properties.set", "bad colour"))).transpose()?;
let transparency = p
.get("transparency")
.map(|v| parse_transparency(v).ok_or_else(|| bad("properties.set", "transparency must be ByLayer, ByBlock or a percentage from 0 to 90")))
.transpose()?;
let thickness = p
.get("thickness")
.map(|v| v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("properties.set", "thickness must be a finite number")))
.transpose()?;
let lineweight =
p.get("lineweight").map(|v| crate::cmd::layer::parse_lw(v).ok_or_else(|| bad("properties.set", "bad lineweight"))).transpose()?;
// Every check reads the drawing first: a refused call leaves no empty undo step.
let d = s.doc()?;
// An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
let linetype = str_param(p, "linetype")
.map(|n| {
if n.eq_ignore_ascii_case("ByLayer") || n.eq_ignore_ascii_case("ByBlock") {
Ok(n.to_string())
} else {
d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))
}
})
.transpose()?;
let dim_style = str_param(p, "dimStyle")
.map(|n| d.dim_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("dimension style `{n}` not found"))))
.transpose()?;
let text_style = str_param(p, "style")
.map(|n| d.text_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("text style `{n}` not found"))))
.transpose()?;
let dim_vars = DimVars::new(d, p)?;
// A pattern must be one each hatch can take, as HATCHEDIT refuses others.
if let Some(v) = str_param(p, "pattern").filter(|v| !v.trim().is_empty())
&& hs.iter().any(|h| matches!(d.entity(*h).map(|e| &e.kind), Some(EntityKind::Hatch(x)) if !crate::cmd::hatch::takes_pattern(x, v)))
{
return Err(bad("properties.set", format!("unknown pattern {}", v.trim().to_ascii_uppercase())));
}
if hs.is_empty() {
// Every object was left out: the drawing stays as it was, with no undo step.
return Ok(left_out.result(0, &[]));
}
let prep = Prepared::new(d, p, &hs);
let anno_scale = d.current_anno_scale();
let c = Call { p, color, transparency, thickness, lineweight, linetype, dim_style, text_style, dim_vars, prep, anno_scale };
// A failed call changes nothing (a command's error doesn't undo what it did), so the drawing
// is taken for writing, and the layer made, only after every check.
let d = s.doc_mut()?;
if let Some(l) = str_param(p, "layer") {
d.ensure_layer(l);
}
let mut used = Used::new();
for h in &hs {
let h = *h;
d.modify_entity(h, |e| {
common(e, &c, &mut used);
match &mut e.kind {
EntityKind::Line(l) => line(l, &c, &mut used),
EntityKind::Circle(ci) => circle(ci, &c, &mut used),
EntityKind::Arc(a) => arc(a, &c, &mut used),
EntityKind::Text(t) => {
text(t, &c, h, &mut used);
text_position(t, &c, &mut used);
}
EntityKind::MText(t) => mtext(t, &c, &mut used),
EntityKind::MLeader(m) => mleader(m, &c, &mut used),
EntityKind::LwPolyline(pl) => {
if let Some(x) = c.num("width").filter(|x| *x >= 0.0) {
pl.const_width = x;
used.insert("width");
}
if let Some(closed) = p.get("closed").and_then(Value::as_bool) {
pl.closed = closed;
used.insert("closed");
}
}
EntityKind::Insert(i) => insert(i, &c, &mut used),
EntityKind::Dimension(dm) => dimension(dm, &c, h, &mut used),
EntityKind::Hatch(ha) => hatch(ha, &c, &mut used),
_ => {}
}
})?;
}
let ignored: Vec<&str> = p
.as_object()
.map(|o| o.keys().map(String::as_str).filter(|k| !matches!(*k, "handles" | "handle") && !used.contains(k)).collect())
.unwrap_or_default();
Ok(left_out.result(hs.len(), &ignored))
}
/// A multileader's text: its contents (#1081) and height.
fn mleader<'c>(m: &mut cadcraft_doc::MLeader, c: &'c Call<'_>, used: &mut Used<'c>) {
let Some(t) = &mut m.text else { return };
if let Some(v) = str_param(c.p, "text") {
t.contents = v.replace('\n', "\\P");
used.insert("text");
}
if let Some(x) = c.num("height").filter(|x| *x > 0.0) {
t.height = x;
used.insert("height");
}
}
/// The properties every object has: annotative, layer, color, linetype, lineweight, linetype
/// scale, transparency, thickness and visibility.
fn common<'c>(e: &mut Entity, c: &'c Call<'_>, used: &mut Used<'c>) {
let p = c.p;
// Annotative: Yes supports the current annotation scale; No drops every scale.
if let Some(a) = p.get("annotative").and_then(Value::as_bool)
&& cadcraft_doc::can_be_annotative(&e.kind)
{
cadcraft_doc::set_annotative(e, a, &c.anno_scale);
if let EntityKind::Dimension(dm) = &mut e.kind {
dm.block = None;
}
used.insert("annotative");
}
if let Some(l) = str_param(p, "layer") {
e.common.layer = l.to_string();
used.insert("layer");
}
if let Some(color) = c.color {
e.common.color = color;
used.insert("color");
}
if let Some(lt) = &c.linetype {
e.common.linetype.clone_from(lt);
used.insert("linetype");
}
if let Some(w) = c.lineweight {
e.common.lineweight = w;
used.insert("lineweight");
}
if let Some(x) = p.get("ltscale").and_then(Value::as_f64).filter(|x| *x > 0.0 && x.is_finite()) {
e.common.ltscale = x;
used.insert("ltscale");
}
if let Some(t) = c.transparency {
e.common.transparency = t;
used.insert("transparency");
}
if let Some(th) = c.thickness {
e.common.thickness = th;
used.insert("thickness");
}
if let Some(v) = p.get("visible").and_then(Value::as_bool) {
e.common.visible = v;
used.insert("visible");
}
}
fn line(l: &mut Line, c: &Call<'_>, used: &mut Used<'_>) {
if let Some(v) = c.p.get("start") {
set_xy(&mut l.a, v);
used.insert("start");
}
if let Some(v) = c.p.get("end") {
set_xy(&mut l.b, v);
used.insert("end");
}
// Length / angle keep the start point and move the end point.
let (a, b) = (l.a.xy(), l.b.xy());
let length = c.num("length").filter(|x| *x > 0.0 && *x < 1e15);
let len = length.unwrap_or_else(|| a.dist(b));
let ang = c.num("angle").map(f64::to_radians).unwrap_or_else(|| a.angle_to(b));
if length.is_some() || c.num("angle").is_some() {
let e = Vec2::polar(a, len, ang);
if e.is_finite() {
l.b.x = e.x;
l.b.y = e.y;
if length.is_some() {
used.insert("length");
}
if c.num("angle").is_some() {
used.insert("angle");
}
}
}
}
fn circle(ci: &mut Circle, c: &Call<'_>, used: &mut Used<'_>) {
if let Some(v) = c.p.get("center") {
set_xy(&mut ci.center, v);
used.insert("center");
}
if let Some(r) = c.num("radius").filter(|r| *r > 0.0) {
ci.radius = r;
used.insert("radius");
}
if let Some(dm) = c.num("diameter").filter(|r| *r > 0.0) {
ci.radius = dm / 2.0;
used.insert("diameter");
}
if let Some(cf) = c.num("circumference").filter(|x| *x > 0.0) {
ci.radius = cf / cadcraft_geom::TAU;
used.insert("circumference");
}
if let Some(a) = c.num("area").filter(|x| *x > 0.0) {
ci.radius = (a / cadcraft_geom::PI).sqrt();
used.insert("area");
}
}
fn arc(a: &mut Arc, c: &Call<'_>, used: &mut Used<'_>) {
if let Some(v) = c.p.get("center") {
set_xy(&mut a.center, v);
used.insert("center");
}
if let Some(r) = c.num("radius").filter(|r| *r > 0.0) {
a.radius = r;
used.insert("radius");
}
if let Some(x) = c.num("startAngle") {
a.start = cadcraft_geom::norm_angle(x.to_radians());
used.insert("startAngle");
}
if let Some(x) = c.num("endAngle") {
a.end = cadcraft_geom::norm_angle(x.to_radians());
used.insert("endAngle");
}
}
/// TEXT's contents, style, size, angles and justification.
fn text(t: &mut Text, c: &Call<'_>, h: Handle, used: &mut Used<'_>) {
let p = c.p;
if let Some(v) = str_param(p, "text") {
t.value = v.to_string();
used.insert("text");
}
if let Some(st) = &c.text_style {
t.style.clone_from(st);
used.insert("style");
}
if let Some(x) = c.num("height").filter(|x| *x > 0.0) {
t.height = x;
used.insert("height");
}
if let Some(x) = c.num("rotation") {
t.rotation = x.to_radians();
// Aligned and fit text run along their baseline's two ends: it turns too.
if matches!(t.halign, HAlign::Aligned | HAlign::Fit)
&& let Some(end) = t.align_pt
{
let e = Vec2::polar(t.insert.xy(), t.insert.xy().dist(end.xy()), t.rotation);
t.align_pt = Some(Vec3::new(e.x, e.y, end.z));
}
used.insert("rotation");
}
if let Some(x) = c.num("widthFactor").filter(|x| *x > 0.0) {
t.width_factor = x;
used.insert("widthFactor");
}
if let Some(x) = c.num("oblique").filter(|x| x.abs() <= 85.0) {
t.oblique = x.to_radians();
used.insert("oblique");
}
if let Some((ha, va)) = str_param(p, "justify").and_then(crate::cmd::draw::justify) {
set_justify(t, ha, va, c.prep.ends.get(&h).copied());
used.insert("justify");
}
}
/// Where TEXT is: its position (the point it's placed by), and an aligned or fit text's second
/// point.
fn text_position(t: &mut Text, c: &Call<'_>, used: &mut Used<'_>) {
// The position is the point the text is placed by: moving it moves the text.
if let Some(to) = c.p.get("position").and_then(point_value) {
shift(t, to - t.justify_point());
used.insert("position");
}
let (x, y) = (c.num("positionX"), c.num("positionY"));
if x.is_some() || y.is_some() {
let at = t.justify_point();
shift(t, Vec2::new(x.unwrap_or(at.x), y.unwrap_or(at.y)) - at);
used.extend(["positionX", "positionY"].into_iter().filter(|k| c.num(k).is_some()));
}
if let Some(z) = c.num("positionZ") {
t.insert.z = z;
if let Some(a) = &mut t.align_pt {
a.z = z;
}
used.insert("positionZ");
}
// Aligned and fit text: the second point alone (the text refits between them).
if matches!(t.halign, HAlign::Aligned | HAlign::Fit)
&& let Some(a) = &mut t.align_pt
{
if let Some(x) = c.num("alignmentX") {
a.x = x;
used.insert("alignmentX");
}
if let Some(y) = c.num("alignmentY") {
a.y = y;
used.insert("alignmentY");
}
}
}
fn mtext(t: &mut MText, c: &Call<'_>, used: &mut Used<'_>) {
let p = c.p;
if let Some(v) = str_param(p, "text") {
t.contents = v.replace('\n', "\\P");
used.insert("text");
}
if let Some(st) = &c.text_style {
t.style.clone_from(st);
used.insert("style");
}
if let Some(x) = c.num("height").filter(|x| *x > 0.0) {
t.height = x;
used.insert("height");
}
if let Some(x) = c.num("width").filter(|x| *x >= 0.0) {
t.width = x;
used.insert("width");
}
if let Some(x) = c.num("rotation") {
t.rotation = x.to_radians();
used.insert("rotation");
}
// The attachment point stays where it is; the text moves around it.
if let Some(n) = str_param(p, "justify").and_then(crate::cmd::mtext_opts::attach_code) {
t.attach = n;
used.insert("justify");
}
mtext_spacing(t, c, used);
if let Some(to) = p.get("position").and_then(point_value) {
t.insert.x = to.x;
t.insert.y = to.y;
used.insert("position");
}
for (k, slot) in [("positionX", &mut t.insert.x), ("positionY", &mut t.insert.y), ("positionZ", &mut t.insert.z)] {
if let Some(v) = c.num(k) {
*slot = v;
used.insert(k);
}
}
}
/// MTEXT's line spacing: a factor, a distance, or its style.
fn mtext_spacing(t: &mut MText, c: &Call<'_>, used: &mut Used<'_>) {
// MTEXT's Line spacing option takes factors from 0.25 to 4.
let factor = |f: f64| f.is_finite() && (0.25 - 1e-9..=4.0 + 1e-9).contains(&f);
if let Some(x) = c.num("lineSpacing").filter(|x| factor(*x)) {
t.line_spacing = x;
used.insert("lineSpacing");
}
if let Some(f) = c.num("lineSpacingDistance").map(|x| x / (t.height * LINE_PITCH)).filter(|f| factor(*f)) {
t.line_spacing = f;
used.insert("lineSpacingDistance");
}
// "atLeast", "At least", "exactly"…
let spacing = str_param(c.p, "lineSpacingStyle").map(|v| v.chars().filter(char::is_ascii_alphabetic).collect::<String>().to_ascii_lowercase());
if let Some(exact) = match spacing.as_deref() {
Some("atleast") => Some(false),
Some("exactly") => Some(true),
_ => None,
} {
t.line_spacing_exact = exact;
used.insert("lineSpacingStyle");
}
}
fn insert(i: &mut Insert, c: &Call<'_>, used: &mut Used<'_>) {
if let Some(x) = c.num("rotation") {
let turn = x.to_radians() - i.rotation;
i.rotation = x.to_radians();
// The attached text turns with the reference, around its insertion point (as ROTATE does).
let base = i.insert.xy();
for a in &mut i.attribs {
let t = &mut a.text;
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
let r = q.xy().rotate_about(base, turn);
q.x = r.x;
q.y = r.y;
}
t.rotation = cadcraft_geom::norm_angle(t.rotation + turn);
if let Some(ml) = &mut a.multiline {
let r = ml.mtext.insert.xy().rotate_about(base, turn);
ml.mtext.insert.x = r.x;
ml.mtext.insert.y = r.y;
ml.mtext.rotation = cadcraft_geom::norm_angle(ml.mtext.rotation + turn);
}
}
used.insert("rotation");
}
if let Some(x) = c.num("scale").filter(|x| *x != 0.0) {
// A new positive scale carries the attached attribute text with it, like SCALE about the insertion point.
if x > 0.0 && i.scale.x > 0.0 {
let m = cadcraft_geom::Mat3::scale_about(i.insert.xy(), x / i.scale.x);
for a in &mut i.attribs {
let mut k = EntityKind::Text(a.text.clone());
k.transform(&m);
if let EntityKind::Text(t) = k {
a.text = t;
}
a.transform_multiline(&m);
}
}
i.scale = Vec3::new(x, x, x);
used.insert("scale");
}
}
fn dimension<'c>(dm: &mut Dimension, c: &'c Call<'_>, h: Handle, used: &mut Used<'c>) {
let p = c.p;
let before = dm.clone();
if let Some(v) = str_param(p, "textOverride") {
dm.text = v.to_string();
used.insert("textOverride");
}
if let Some(st) = &c.dim_style {
dm.style.clone_from(st);
used.insert("dimStyle");
}
// Overrides: clear first, then set (as DIMOVERRIDE does).
if p.get("clearOverrides").and_then(Value::as_bool) == Some(true) {
dm.overrides.clear();
used.insert("clearOverrides");
}
if let Some(names) = p.get("clear").and_then(Value::as_array) {
// Prefix and suffix rows reset DIMPOST (DIMAPOST), the variable they're halves of.
let field = |n: &str| match n {
"prefix" | "suffix" => Some("post"),
"altPrefix" | "altSuffix" => Some("altPost"),
n => DimStyle::field_name(n),
};
for f in names.iter().filter_map(Value::as_str).filter_map(field) {
dm.overrides.retain(|k, _| DimStyle::field_name(k) != Some(f));
}
used.insert("clear");
}
for (f, v) in &c.dim_vars.fields {
set_override(dm, f, v.clone());
}
used.extend(c.dim_vars.keys.iter().map(String::as_str));
if let Some(x) = c.num("textRotation") {
dm.text_rotation = x.to_radians();
used.insert("textRotation");
}
let (x, y) = (c.num("textPositionX"), c.num("textPositionY"));
if x.is_some() || y.is_some() {
let at = c.prep.text_pos.get(&h).copied().unwrap_or_else(|| dm.text_mid.xy());
dm.text_mid.x = x.unwrap_or(at.x);
dm.text_mid.y = y.unwrap_or(at.y);
dm.user_text_pos = true;
used.extend(["textPositionX", "textPositionY"].into_iter().filter(|k| c.num(k).is_some()));
}
dimension_posts(dm, c, used);
// The geometry block read from a file no longer matches: draw and save it anew.
if *dm != before {
dm.block = None;
}
}
/// A dimension's prefix and suffix edits, which go into the DIMPOST and DIMAPOST templates it
/// draws with after the call's other edits (its style, cleared and new overrides).
fn dimension_posts(dm: &mut Dimension, c: &Call<'_>, used: &mut Used<'_>) {
let Some(styles) = &c.prep.posts else { return };
let (post, alt) = styles.get(&dm.style.to_ascii_lowercase()).cloned().unwrap_or_default();
let st = DimStyle { post, alt_post: alt, ..DimStyle::default() }.with_overrides(&dm.overrides);
for (field, template, keys) in [("post", &st.post, ["prefix", "suffix"]), ("altPost", &st.alt_post, ["altPrefix", "altSuffix"])] {
let (pre, suf) = (str_param(c.p, keys[0]), str_param(c.p, keys[1]));
if pre.is_some() || suf.is_some() {
let (pre0, suf0) = split_post(template);
set_override(dm, field, json!(join_post(pre.unwrap_or(&pre0), suf.unwrap_or(&suf0))));
used.extend(keys.into_iter().filter(|k| str_param(c.p, k).is_some()));
}
}
}
fn hatch(ha: &mut Hatch, c: &Call<'_>, used: &mut Used<'_>) {
// HATCHEDIT's pattern edit (a blank name changes nothing, so it's ignored).
if let Some(v) = str_param(c.p, "pattern")
&& crate::cmd::hatch::set_pattern(ha, v)
{
used.insert("pattern");
}
if let Some(x) = c.num("scale").filter(|x| *x > 0.0) {
ha.scale = x;
used.insert("scale");
}
if let Some(x) = c.num("angle") {
ha.angle = x.to_radians();
used.insert("angle");
}
}
+35 -5
View File
@@ -108,8 +108,9 @@ fn property(d: &Drawing, e: &Entity, name: &str) -> Option<Value> {
/// Glob match, case-insensitive: `*` any run, `?` one character, `#` one digit.
pub fn wildcard(pat: &str, text: &str) -> bool {
let p: Vec<char> = pat.to_lowercase().chars().take(1024).collect();
let t: Vec<char> = text.to_lowercase().chars().take(4096).collect();
// Only the characters that can match are lower-cased, so a huge text isn't copied whole.
let p: Vec<char> = pat.chars().take(1024).flat_map(char::to_lowercase).collect();
let t: Vec<char> = text.chars().take(4096).flat_map(char::to_lowercase).collect();
// Iterative matcher with single back-track point (linear-ish, no recursion).
let (mut pi, mut ti) = (0usize, 0usize);
let mut star: Option<(usize, usize)> = None;
@@ -175,8 +176,14 @@ pub fn compare(prop: &Value, op: Op, value: &Value) -> bool {
if ptxt.eq_ignore_ascii_case(vtxt.trim()) {
return true;
}
// Colours: `red` = `1` = `Red`; `bylayer` = `ByLayer`.
match (Color::parse(&ptxt), Color::parse(vtxt.trim())) {
// Colours: `red` = `1` = `Red`; `bylayer` = `ByLayer`. No colour spelling is long, so a
// long text (a layer name from a file) isn't parsed, copied and split per entity.
const MAX_COLOR_TEXT: usize = 64;
let (pc, vc) = (ptxt.trim(), vtxt.trim());
if pc.len() > MAX_COLOR_TEXT || vc.len() > MAX_COLOR_TEXT {
return false;
}
match (Color::parse(pc), Color::parse(vc)) {
(Some(a), Some(b)) => a == b,
_ => false,
}
@@ -273,7 +280,7 @@ fn run_qselect(s: &mut Session, p: &Value) -> Result<Value> {
let sel = match mode.as_str() {
"exclude" => excluded,
"append" => {
let mut cur = s.selection();
let mut cur = s.stored_selection();
for h in matched {
if !cur.contains(&h) {
cur.push(h);
@@ -400,3 +407,26 @@ mod tests {
assert!(!wildcard(&"*a".repeat(500), &"b".repeat(4000)));
}
}
#[cfg(test)]
mod long_text_tests {
use super::*;
/// A long string property is compared as text only, and a colour name still equals its index.
#[test]
fn long_values_skip_colour_parsing() {
let long = Value::String("x".repeat(100_000));
assert!(compare(&long, Op::Eq, &long));
assert!(!compare(&long, Op::Eq, &Value::String("red".into())));
assert!(compare(&Value::String("red".into()), Op::Eq, &Value::String("1".into())));
}
/// Padding is trimmed before the length limit, so a padded colour still matches.
#[test]
fn padded_colours_still_match() {
let padded = |c: &str| Value::String(format!("{}{c}{}", " ".repeat(100), " ".repeat(100)));
assert!(compare(&padded("red"), Op::Eq, &Value::String("1".into())));
assert!(compare(&Value::String("red".into()), Op::Eq, &padded("1")));
assert!(!compare(&padded("red"), Op::Ne, &padded("1")));
}
}
+9 -2
View File
@@ -99,14 +99,21 @@ pub(crate) fn similar(e: &Entity, r: &Entity, mode: u32) -> bool {
&& (mode & NAME == 0 || same_text(object_name(e), object_name(r)))
}
/// The visible objects of the current space like any of `refs`.
/// The objects of the current space like any of `refs` that a selection can take there: visible,
/// and inside an MSPACE viewport not on a layer frozen in it.
fn similar_objects(s: &Session, d: &Drawing, refs: &[Handle], mode: u32) -> Vec<Handle> {
let refs: Vec<&Entity> = refs.iter().filter_map(|h| d.entity(*h).map(|e| e.as_ref())).collect();
if refs.is_empty() {
return Vec::new();
}
let Some(store) = d.space(&s.space()) else { return Vec::new() };
store.iter().take(MAX_SCAN).filter(|e| d.is_visible(e) && refs.iter().any(|r| similar(e, r, mode))).map(|e| e.handle).collect()
let frozen = s.viewport_frozen();
store
.iter()
.take(MAX_SCAN)
.filter(|e| crate::select::selectable(d, e, frozen) && refs.iter().any(|r| similar(e, r, mode)))
.map(|e| e.handle)
.collect()
}
fn mode_param(s: &Session, p: &Value) -> Result<u32> {
+14 -6
View File
@@ -12,7 +12,7 @@ use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
/// Largest linked file read (bytes).
#[cfg(not(target_arch = "wasm32"))]
const MAX_LINK_BYTES: u64 = 8 << 20;
const MAX_LINK_BYTES: usize = 8 << 20;
pub fn specs() -> Vec<CommandSpec> {
vec![
@@ -238,11 +238,9 @@ fn read_link(id: &str, file: &std::path::Path) -> Result<String> {
let path = file.display();
#[cfg(not(target_arch = "wasm32"))]
{
let meta = std::fs::metadata(file).map_err(|e| bad(id, format!("{path}: {e}")))?;
if meta.len() > MAX_LINK_BYTES {
return Err(bad(id, format!("{path}: larger than {} MB", MAX_LINK_BYTES >> 20)));
}
let bytes = std::fs::read(file).map_err(|e| bad(id, format!("{path}: {e}")))?;
// The limit is enforced on the bytes read, not on reported metadata, so a device or FIFO
// that misreports its length can't be buffered to EOF.
let bytes = crate::capped_read::read_capped(file, MAX_LINK_BYTES).map_err(|e| bad(id, format!("{path}: {e}")))?;
let text = String::from_utf8_lossy(&bytes);
Ok(text.strip_prefix('\u{feff}').unwrap_or(&text).to_owned())
}
@@ -370,6 +368,16 @@ fn run_update(s: &mut Session, p: &Value) -> Result<Value> {
mod tests {
use super::*;
/// A linked path naming an endless device is refused instead of buffered to EOF.
#[cfg(all(unix, not(target_arch = "wasm32")))]
#[test]
fn link_to_endless_device_is_rejected() {
let dev = std::path::Path::new("/dev/zero");
if dev.exists() {
assert!(read_link("datalink", dev).is_err());
}
}
#[test]
fn csv_parsing() {
assert_eq!(parse_csv("a,b\r\n\"c,d\",\"e\"\"f\"\n", ','), vec![vec!["a", "b"], vec!["c,d", "e\"f"]]);
+2 -2
View File
@@ -59,7 +59,7 @@ fn fence(s: &mut Session, pts: &[Vec2], extending: bool, edges: Edges, quick: bo
let fb = Bounds2::from_points(pts.iter().copied());
let tol = crate::select::window_tol(&fb);
let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
for h in crate::select::select_fence(d, &space, pts) {
for h in crate::select::select_fence_in(d, &space, s.viewport_frozen(), pts) {
let Some(e) = d.entity(h) else { continue };
let polys = crate::select::hit_polylines(d, e, tol);
let mut xs: Vec<Vec2> = Vec::new();
@@ -96,7 +96,7 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu
];
let inside = |p: Vec2| bx.expand(tol).contains(p);
let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
for h in crate::select::select_window(d, &space, bx, true) {
for h in crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, true) {
let Some(e) = d.entity(h) else { continue };
let mut best: Option<Vec2> = None;
for pl in crate::select::hit_polylines(d, e, tol) {

Some files were not shown because too many files have changed in this diff Show More