Compare commits

..
Author SHA1 Message Date
Tanish Manku 60233f87ff docs: gate criteria check object content; tier 3 items are carved out of the beta checklist 2026-11-19 19:13:56 -07:00
Tanish Manku 4831f26ca6 docs: alpha gate revised from user reports; priorities in three tiers 2026-11-19 15:20:38 -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
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 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
Dylan M. Taylor a009f7d022 Use shared TrueType embedding classification 2026-11-15 18:46:31 +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 5b170664aa Use shared SHX glyph interpreter 2026-11-15 15:52:39 +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 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
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
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 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 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 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
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 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
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
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 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 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 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 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
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
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
124 changed files with 12730 additions and 2009 deletions
+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.
Generated
+169 -8
View File
@@ -299,6 +299,9 @@ name = "arrayvec"
version = "0.7.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
dependencies = [
"serde",
]
[[package]]
name = "as-raw-xcb-connection"
@@ -668,6 +671,7 @@ dependencies = [
"serde_json",
"sys-locale",
"thiserror 2.0.21",
"uds_windows",
"windows",
"winit",
"winresource",
@@ -746,6 +750,7 @@ version = "0.21.0"
dependencies = [
"cadcraft-geom",
"craft-dxf",
"craft-font-catalog",
"craft-shx",
"encoding_rs",
"harfrust 0.14.0",
@@ -773,11 +778,11 @@ dependencies = [
"cadcraft-render",
"craft-dwg",
"craft-dxf",
"craft-image-codecs",
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"craft-pdf",
"craft-svg",
"image",
"miniz_oxide 0.9.1",
"quick-xml 0.42.0",
"serde",
"serde_json",
"thiserror 2.0.21",
@@ -810,7 +815,7 @@ dependencies = [
"cadcraft-doc",
"cadcraft-fonts",
"cadcraft-geom",
"craft-image-codecs",
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"lyon_tessellation",
"rayon",
"serde_json",
@@ -829,6 +834,7 @@ dependencies = [
"cadcraft-io",
"cadcraft-render",
"chrono",
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"craft-ui",
"craft-update",
"craft-window",
@@ -1205,6 +1211,16 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-font-catalog"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c07e38090879ffa994f893df9956c6d5b96c049c#c07e38090879ffa994f893df9956c6d5b96c049c"
dependencies = [
"skrifa 0.47.0",
"thiserror 2.0.21",
"windows-registry",
]
[[package]]
name = "craft-fonts-build"
version = "0.1.0"
@@ -1238,8 +1254,33 @@ name = "craft-image-codecs"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12#ae5020c1ed922cf7976a3a5545f05b07f466be12"
dependencies = [
"craft-jpeg",
"craft-metadata",
"craft-jpeg 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"craft-metadata 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"crc32fast",
"exr",
"flate2",
"half",
"hayro-jpeg2000",
"image",
"image-webp",
"jpeg-encoder",
"png",
"rayon",
"serde_json",
"thiserror 2.0.21",
"tiff",
"zune-core",
"zune-jpeg",
"zune-jpegxl",
]
[[package]]
name = "craft-image-codecs"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"craft-jpeg 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"craft-metadata 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"crc32fast",
"exr",
"flate2",
@@ -1266,6 +1307,14 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-jpeg"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-jsonrpc"
version = "0.1.0"
@@ -1290,7 +1339,19 @@ source = "git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a
dependencies = [
"brotli-decompressor",
"chrono",
"craft-tiff",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ae5020c1ed922cf7976a3a5545f05b07f466be12)",
"quick-xml 0.41.0",
"serde",
]
[[package]]
name = "craft-metadata"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"brotli-decompressor",
"chrono",
"craft-tiff 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"quick-xml 0.41.0",
"serde",
]
@@ -1318,7 +1379,23 @@ dependencies = [
[[package]]
name = "craft-shx"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=3c5007339754def577b3c5274f523d96384a35c4#3c5007339754def577b3c5274f523d96384a35c4"
source = "git+https://github.com/storytold/craft-libs?rev=2f2d1d84e3a36b3f93e81507aeff3f0da97a7162#2f2d1d84e3a36b3f93e81507aeff3f0da97a7162"
[[package]]
name = "craft-svg"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"craft-image-codecs 0.1.0 (git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52)",
"craft-xml",
"flate2",
"kurbo",
"quick-xml 0.41.0",
"roxmltree",
"thiserror 2.0.21",
"vectorcraft-geom",
"vectorcraft-pathops",
]
[[package]]
name = "craft-tiff"
@@ -1329,6 +1406,15 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-tiff"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-ui"
version = "0.1.0"
@@ -1353,7 +1439,7 @@ dependencies = [
[[package]]
name = "craft-update"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b"
source = "git+https://github.com/storytold/craft-libs?rev=e98299546f5c5c3c22388d16507f8b5e61a5f280#e98299546f5c5c3c22388d16507f8b5e61a5f280"
dependencies = [
"chrono",
"dunce",
@@ -1408,6 +1494,16 @@ dependencies = [
"wayland-client",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52#c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52"
dependencies = [
"quick-xml 0.41.0",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "crc32fast"
version = "1.5.3"
@@ -2956,6 +3052,7 @@ dependencies = [
"arrayvec",
"euclid",
"polycool",
"serde",
"smallvec",
]
@@ -3011,6 +3108,19 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4"
[[package]]
name = "linesweeper"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a25df1b0c5432893f41bba817150e323703ee5f6d974f3a6808ac7fd7f046d18"
dependencies = [
"arrayvec",
"kurbo",
"polycool",
"rustc-hash 2.1.3",
"smallvec",
]
[[package]]
name = "linux-raw-sys"
version = "0.4.15"
@@ -4172,6 +4282,17 @@ dependencies = [
"once_cell",
]
[[package]]
name = "read-fonts"
version = "0.44.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5a0cf4bb6cbce4c29756270d189a5e400ac05e91192161d83a0bcb6e68492e8"
dependencies = [
"bytemuck",
"font-types 0.12.7",
"once_cell",
]
[[package]]
name = "read-fonts"
version = "0.45.1"
@@ -4279,6 +4400,15 @@ dependencies = [
"unicode-ident",
]
[[package]]
name = "roxmltree"
version = "0.21.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9da7f59328b09405b181fee1018925fad50f157afb43c0c0f5c522c256dd5907"
dependencies = [
"memchr",
]
[[package]]
name = "rstar"
version = "0.13.0"
@@ -4636,6 +4766,16 @@ dependencies = [
"read-fonts 0.41.0",
]
[[package]]
name = "skrifa"
version = "0.47.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "526e654b303ff4ad73a5a40b25de2b3ce3d039c5e3b6da5f89ae6e57004cb40f"
dependencies = [
"bytemuck",
"read-fonts 0.44.0",
]
[[package]]
name = "skrifa"
version = "0.48.0"
@@ -5282,6 +5422,27 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "vectorcraft-geom"
version = "0.18.0"
source = "git+https://github.com/storytold/vectorcraft.git?rev=6b3a6b8788ebcb420d69449199cbdf323888d27e#6b3a6b8788ebcb420d69449199cbdf323888d27e"
dependencies = [
"kurbo",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "vectorcraft-pathops"
version = "0.18.0"
source = "git+https://github.com/storytold/vectorcraft.git?rev=6b3a6b8788ebcb420d69449199cbdf323888d27e#6b3a6b8788ebcb420d69449199cbdf323888d27e"
dependencies = [
"kurbo",
"linesweeper",
"thiserror 2.0.21",
"vectorcraft-geom",
]
[[package]]
name = "vello_common"
version = "0.2.0"
+6 -2
View File
@@ -16,7 +16,7 @@ cadcraft-geom = { path = "crates/geom" }
# DXF tags: the shared reader and writer (moved from crates/dxf; craft-libs#791).
craft-dxf = { git = "https://github.com/storytold/craft-libs", rev = "9ed120e6b1bd5116a4649c578d1272d60cf932b9" }
craft-dwg = { git = "https://github.com/storytold/craft-libs", rev = "7bb6c90076a0177d01cc4c482e7fd8dc9f31a8bf" }
craft-shx = { git = "https://github.com/storytold/craft-libs", rev = "3c5007339754def577b3c5274f523d96384a35c4" }
craft-shx = { git = "https://github.com/storytold/craft-libs", rev = "2f2d1d84e3a36b3f93e81507aeff3f0da97a7162" }
craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "ae5020c1ed922cf7976a3a5545f05b07f466be12" }
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "0325b2d73676d736e94097dbcef01219cf25c7db" }
cadcraft-color = { path = "crates/color" }
@@ -30,11 +30,15 @@ cadcraft-ui-egui = { path = "crates/ui-egui" }
cadcraft-mcp = { path = "crates/mcp" }
craft-mcp = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
craft-jsonrpc = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
# SVG/SVGZ import and export geometry (craft-libs#778).
craft-svg = { git = "https://github.com/storytold/craft-libs", rev = "c4c4547b7b0151e7c79ab50fa97cb64fbdff4e52" }
# Which paths stored in a drawing (xrefs, data links) may be opened.
craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
# PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
# craft-pdf's patched backends to the same revision (Cargo ignores dependency-local patches).
craft-pdf = { version = "=0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", default-features = false }
# TrueType embedding-permission classification for plotted fonts (craft-libs#778).
craft-font-catalog = { git = "https://github.com/storytold/craft-libs", rev = "c07e38090879ffa994f893df9956c6d5b96c049c", default-features = false }
clap = { version = "4", features = ["derive", "env"] }
clap_complete = "4.6.11"
clap_mangen = { version = "0.3.3", features = ["env"] }
@@ -77,7 +81,7 @@ egui-wgpu = "0.37"
# Monotonic time on native and web (performance.now on wasm).
web-time = "1.1"
# craft-update: app-specific pretend versions apply to startup and manual checks.
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] }
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", features = ["egui"] }
rfd = "0.17"
arboard = { version = "3.6", default-features = false }
+50 -21
View File
@@ -1,21 +1,23 @@
# CADCraft roadmap
**Stage: pre-alpha** · next: alpha, ~2 points (38% → 40% ready for real work) and ~125–190 Opus 5.5 hours away (the four failing core workflows of the [alpha gate](docs/roadmap.md#alpha-gate))
**Stage: pre-alpha** · next: alpha, when the six rows of the [alpha gate](docs/roadmap.md#alpha-gate) pass (five fail today; the gate was revised on 2026-11-19 and its hours are not re-estimated yet)
> **Last reviewed:** 2026-10-24 · **Last updated:** 2026-10-24 · **Change:** minor (re-audit against main 41d9b5e95: language table, CI gate, open-PR count; previously: progress log: proxy objects keep their class through a save, #1812; previously minor: HATCHEDIT boundary add/remove progress) · **Target:** Autodesk AutoCAD 2027
> **Last reviewed:** 2026-11-19 · **Last updated:** 2026-11-19 · **Change:** major (alpha gate revised from user reports: six rows, Windows first; Upcoming re-ranked into three priority tiers; previously minor: re-audit against main 41d9b5e95) · **Target:** Autodesk AutoCAD 2027
CADCraft targets full parity with AutoCAD (2D drafting first, then annotation, layouts and
plotting, DWG, parametrics and 3D), plus what AutoCAD doesn't have: agent control over MCP, a
scriptable CLI, a web build, Linux and FreeBSD builds, and a free licence.
**Why pre-alpha:** four of AutoCAD's five core workflows fail the [alpha gate](docs/roadmap.md#alpha-gate).
Precise drafting still has approximate ellipse and spline intersections and a few stubbed prompt options
(object snap tracking, TRIM/EXTEND/OFFSET options and typed snap overrides have landed); dynamic blocks can't be
authored and xrefs can't be edited in place (the Block Editor, REFEDIT, dynamic block editing and XCLIP have landed);
plots go only to PDF, PNG and SVG files (plot styles and the Plot dialog have landed); and a DWG saved by
CADCraft drops what acadrust doesn't model and has never been checked in
AutoCAD. Dimensioning passes. Ready for real work (≈ 38%) is also under the ~40% alpha bar. Beta
is ≈ 600–930 h away.
**Why pre-alpha:** five of the six rows of the [alpha gate](docs/roadmap.md#alpha-gate) fail. The gate
was revised on 2026-11-19 from what people report: about 525 of the issues open or closed in the
last 30 days come from people describing their own drawings, hardware or workflow, and the ones that
name a platform name Windows most (135; Linux 57, macOS 36, web 14). They report an app that
doesn't start on older graphics hardware, large or foreign DWG files that are refused, freeze or open
wrong, clicks lost while the mouse moves, layouts in the wrong units, and a menu bar or panels that
can't be brought back. Drafting, dimensioning and annotating a sheet nearly passes. Dynamic-block
authoring, editing an xref in place and exact ellipse and spline geometry had almost no reports behind
them and moved to the beta checklist. Ready for real work (≈ 38%, not re-scored since 2026-10-10) is
also under the ~40% alpha bar. Beta is ≈ 600–930 h away.
## Headline numbers
@@ -25,7 +27,7 @@ is ≈ 600–930 h away.
| Ready for real work | **≈ 38%** | estimated ([target-app-parity.md](docs/target-app-parity.md)) |
| Mainstream practitioner (2D drafter) | **≈ 28%** (lower than the full number: file exchange, stability and interaction discounts multiply) | estimated ([target-app-parity.md](docs/target-app-parity.md#mainstream-practitioner)) |
| Essentials user | **≈ 46%** | estimated ([target-app-parity.md](docs/target-app-parity.md#essentials-user)) |
| Remaining to alpha | **≈ 125–190 h** (the gate rows) | estimated |
| Remaining to alpha | **≈ 125–190 h** (estimated 2026-10-10 for the previous gate; not re-estimated for the revised one) | estimated |
| Remaining to beta | **≈ 600–930 h** (≈ 150–250 h elapsed with 4–6 agents) | estimated |
| Remaining to full parity | **≈ 1,300–2,100 h** (≈ 330–550 h elapsed) | estimated |
@@ -105,17 +107,43 @@ Other languages shipped: Ukrainian (1,357 rows, the reference catalog, #36), Cze
## Upcoming
Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md).
Ranked in three tiers; a higher tier goes first whenever it has work. Within a tier, a fix that is
already written and waiting in a pull request lands before new work starts, whoever wrote it. Detail
and the beta checklist are in [docs/roadmap.md](docs/roadmap.md).
1. Gate and land: CI runs `cargo xtask ci` on every PR since #1987 (fmt on main is fixed); land the 450 open PRs (2026-10-24) (15–25 h).
2. Stop losing data on save (DXF done, #528; native MULTILEADER, #459, and the save version, #421, done; through DWG, acadrust still drops some content) (30–45 h).
3. Real-file DWG/DXF corpus and a black-box check in AutoCAD (10–15 h + owner).
4. ~~Precision input: object snap tracking, extension/parallel snaps, FROM/M2P/TK, snap overrides,
editable dynamic input.~~ Done (#379, #441, #60, #519; `snap/tracking.rs`, `pointmod.rs`, `dyninput.rs`).
5. ~~Unstub prompt options in TRIM/EXTEND, OFFSET, ROTATE, PLINE, SPLINE, MTEXT, MLEADER.~~ Done (#397, #408, #547); the stubs left are in gaps F1.
6. ~~Autosave, recovery, AUDIT, RECOVER.~~ Done on the desktop (#406, #416); the web build has no autosave (gaps F4).
7. Exact ellipse/spline geometry and correct polyline offsets (30–50 h).
8. Xrefs, block editor, groups, then dynamic blocks (80–120 h): xrefs (#525), groups (#417), the Block Editor (#824, #833, #885), REFEDIT (#818), XCLIP and XCLIPFRAME (#2354) and dynamic block references (#838–#883) landed; left: dynamic-block authoring, editing an xref in place.
**1. Urgent: security fixes, leaks, crashes and lost work.**
- The open findings of the security audit (#1919–#1935): check each against the input limits that
landed on 2026-11-11, close what is fixed and fix the rest. A crafted handle that makes new entities
overwrite existing ones (#1921) is fixed by #1276.
- Hostile-input fixes waiting in pull requests (#2820, #2821, #2765).
- Crashes and hangs with a reproduction: the web build on a large DXF (#1603), a DWG with 3D content
(#2174), startup on older graphics hardware (#1724, #1631, #3222).
**2. Parity with AutoCAD: the alpha gate rows, then the beta checklist (apart from its items named under tier 3).**
- It starts on common hardware (#1596, then an automatic fallback renderer).
- It opens the DWG and DXF files people already have: large files (#3102, #2633, #1088), layouts and
paper units (#1672, #2836), and a corpus of real files run in CI.
- Saving loses nothing and other CAD programs open the result (#2904, #1687, #3234, #2632).
- Input feels like AutoCAD for Windows: clicks while the mouse moves (#1001, #2092), right-click and
Space as Enter (#1387), double-click to edit text (#842).
- The prompt options that still say "not available yet", and TRIM/EXTEND depth.
- Layouts print at scale on a system printer, and the menu bar and panels can always be restored
(#3216, #1240).
- 714 pull requests are open (2026-11-19). About 230 are mergeable, pass CI and are small; they are
reviewed and landed in this order, the longest-waiting authors first within a row.
**3. Lower priority: affects fewer people and nothing breaks without it.**
- Dynamic-block authoring, editing an xref in place, exact ellipse and spline geometry, correct
polyline offsets.
- Prompt options that need 3D (DVIEW's camera options, -RENAME Material); 3D itself comes after 1.0,
but a file with 3D content must open safely (tier 1).
- Menu breadth against AutoCAD for Mac as a headline number.
Done since the last ranking: precision input (#379, #441, #60, #519), prompt options in TRIM/EXTEND,
OFFSET, ROTATE, PLINE, SPLINE, MTEXT and MLEADER (#397, #408, #547), autosave, recovery, AUDIT and
RECOVER on the desktop (#406, #416), xrefs (#525), groups (#417), the Block Editor (#824, #833, #885),
REFEDIT (#818), XCLIP (#2354), dynamic block references (#838–#883), and the Dimension Style Manager
(#1460).
## Progress log
@@ -138,6 +166,7 @@ Ranked; detail and the full beta checklist in [docs/roadmap.md](docs/roadmap.md)
| Date | Change | Summary |
|---|---|---|
| 2026-11-19 | major | Alpha gate revised from user reports (six rows, Windows first; block authoring, xref editing in place and exact curve geometry moved to beta); Upcoming re-ranked into three tiers: urgent (security, leaks, crashes, lost work), parity, lower priority; percentages and hours not re-scored |
| 2026-10-24 | minor | Re-audit against main 41d9b5e95: language table, CI gate and open-PR count re-checked against main 41d9b5e95 |
| 2026-10-21 | trivial | Progress log: proxy objects keep their class through a save (#1812) |
| 2026-10-14 | minor | Progress log: HATCHEDIT boundary add/remove |
+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.
+2
View File
@@ -128,6 +128,8 @@ mod web {
groups: cadcraft_io::entity_groups,
entity: cadcraft_io::entity_from_groups,
});
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
let Some(canvas) = app_canvas() else {
log::error!("missing <canvas id=\"{CANVAS_ID}\">");
return;
+3
View File
@@ -67,6 +67,9 @@ hidapi = { version = "2.6.7", default-features = false, features = ["windows-nat
# View ▸ Accessibility ▸ Animation Effects ▸ Use System Setting: Windows' Animation effects
# setting (system_animations.rs). Already in Cargo.lock through wgpu's DirectX 12 backend.
windows = { version = "0.62", features = ["UI_ViewManagement"] }
# One CADCraft per sign-in: later launches hand their files over an AF_UNIX socket
# (single_instance.rs). Already in Cargo.lock through zbus.
uds_windows = "1.2.1"
[target.'cfg(target_os = "linux")'.dependencies]
hidapi = { version = "2.6.7", default-features = false, features = ["linux-native-basic-udev"] }
+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]
+30 -1
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,…}`.
@@ -25,6 +25,7 @@ mod logging;
mod native_menu;
#[cfg(target_os = "macos")]
mod sheet;
mod single_instance;
mod spacemouse;
mod system_animations;
mod workspace;
@@ -42,6 +43,8 @@ struct App {
system_animations: system_animations::SystemAnimations,
workspace: workspace::Workspace,
workspace_error: Option<String>,
/// The first CADCraft of this sign-in: files that later launches hand over (Windows).
single_instance: Option<single_instance::Server>,
#[cfg(target_os = "macos")]
native_menu: Option<native_menu::NativeMenu>,
/// `CADCRAFT_NO_NATIVE_MENU`: the menus stay inside the window.
@@ -87,6 +90,17 @@ impl eframe::App for App {
/// eframe logic callback: syncs the OS animation setting and runs `CadApp::logic`; when the pass index is 0 (the first pass or a hidden tick) it also installs/polls the macOS native menu, polls the spacemouse and persists the workspace; a quit request closes the viewport.
fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
self.cad.system_animations = self.system_animations.current();
// Files another launch handed over open as tabs here, and the window comes forward.
if let Some(server) = &self.single_instance {
let paths = server.take_paths();
if !paths.is_empty() {
ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(false));
ctx.send_viewport_cmd(egui::ViewportCommand::Focus);
for p in &paths {
self.cad.open_path(p);
}
}
}
// Consume control/open/screenshot queues and time-based autosave, including hidden ticks.
self.cad.guarded_logic(ctx);
// Host frame work runs here, once per frame, and so also on a hidden logic-only tick (which
@@ -157,6 +171,8 @@ pub fn install_io() {
groups: cadcraft_io::entity_groups,
entity: cadcraft_io::entity_from_groups,
});
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
cadcraft_engine::cmd::file::set_object_records(cadcraft_io::object_records);
}
fn services() -> Services {
@@ -308,6 +324,14 @@ fn main() -> eframe::Result {
}
}
}
// A launch that only names files hands them to the CADCraft already running and exits.
let handed = single_instance::absolute(&files);
let may_hand_off = handed.is_some() && !launch.new_window && !files.is_empty() && control_port.is_none() && !sample;
let instance = match single_instance::claim(handed.as_deref().unwrap_or_default(), may_hand_off) {
single_instance::Claim::HandedOff => return Ok(()),
single_instance::Claim::Primary(server) => Some(server),
single_instance::Claim::Alone => None,
};
install_io();
cadcraft_engine::settings_dir::set(vars.config_dir.clone());
if let Some(dir) = &vars.config_dir {
@@ -428,6 +452,10 @@ fn main() -> eframe::Result {
let metric = app.session.settings.measureinit;
app.session.new_drawing(metric);
}
if let Some(server) = &instance {
let ctx = cc.egui_ctx.clone();
server.set_wake(move || ctx.request_repaint());
}
let ctx = cc.egui_ctx.clone();
let desktop_theme = desktop_theme::DesktopTheme::start(move || ctx.request_repaint());
let ctx = cc.egui_ctx.clone();
@@ -439,6 +467,7 @@ fn main() -> eframe::Result {
spacemouse: spacemouse::SpaceMouse::start(cc.egui_ctx.clone()),
workspace,
workspace_error,
single_instance: instance,
#[cfg(target_os = "macos")]
native_menu: None,
#[cfg(target_os = "macos")]
+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);
}
}
+7
View File
@@ -106,6 +106,10 @@ sync_github_name = true
[people.GULERTOLGA]
sync_github_name = true
[people.Obtrusive8276]
display_name = "Nicopicks"
sync_github_name = false
[people.Tyler-Chiriboga]
real_name = "Tyler Chiriboga"
sync_github_name = true
@@ -121,3 +125,6 @@ real_name = "Helen Kwok"
[people.V1dalTheAbidal]
sync_github_name = true
[people.tyrel]
real_name = "Tyrel Haveman"
+13 -2
View File
@@ -172,8 +172,8 @@ fn build_palette() -> [Rgb; 256] {
Rgb(0, 0, 255),
Rgb(255, 0, 255),
Rgb(255, 255, 255),
Rgb(65, 65, 65),
Rgb(128, 128, 128),
Rgb(192, 192, 192),
];
for (slot, colour) in palette.iter_mut().zip(base) {
*slot = colour;
@@ -193,7 +193,7 @@ fn build_palette() -> [Rgb; 256] {
*slot = Rgb(channel(red), channel(green), channel(blue));
}
}
let greys = [51u8, 91, 132, 173, 214, 255];
let greys = [51u8, 80, 105, 130, 190, 255];
for (offset, shade) in greys.iter().enumerate() {
if let Some(slot) = palette.get_mut(250 + offset) {
*slot = Rgb(*shade, *shade, *shade);
@@ -302,6 +302,17 @@ mod tests {
assert_eq!(aci_rgb(255), Rgb(255, 255, 255));
}
#[test]
fn palette_fixed_greys() {
assert_eq!(aci_rgb(8), Rgb(65, 65, 65));
assert_eq!(aci_rgb(9), Rgb(128, 128, 128));
for (i, g) in [(250u8, 51u8), (251, 80), (252, 105), (253, 130), (254, 190)] {
assert_eq!(aci_rgb(i), Rgb(g, g, g));
}
assert_eq!(nearest_aci(Rgb(65, 65, 65)), 8);
assert_eq!(nearest_aci(Rgb(128, 128, 128)), 9);
}
#[test]
fn aci_roundtrip_and_parse() {
assert_eq!(Color::from_aci(256), Color::ByLayer);
+4
View File
@@ -72,6 +72,10 @@ pub struct Foreign {
/// proxy objects or entities: a proxy's class number (group 91) is 500 plus its class's place
/// here, and saving renumbers it to the written CLASSES (#1812).
pub class_order: Vec<String>,
/// The roles of every file handle of an object CADCraft writes itself (table records, tables,
/// blocks, the named object dictionary and its entries), so that AutoLISP names those objects
/// as the file did (`handent`). Saving gives them new handles; not part of [`Foreign::is_empty`].
pub handles: BTreeMap<Handle, ForeignKey>,
/// The file's data store section (ACDSDATA, AutoCAD 2013 and later), as read: its groups
/// after the section name. It holds the ACIS geometry of 3D solids, regions, bodies and
/// surfaces, which from 2013 on those entities don't carry themselves: each `ACDSRECORD`
+13 -3
View File
@@ -209,12 +209,22 @@ impl Drawing {
}
}
/// Allocate a fresh handle.
/// Allocate a fresh handle. It skips the handles the drawing's file gave the objects CADCraft
/// writes itself ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a
/// file CADCraft wrote numbers them above its `$HANDSEED` (#495).
pub fn new_handle(&mut self) -> Handle {
let h = Handle(self.handseed);
self.handseed = self.handseed.saturating_add(1);
let h = self.next_handle();
self.handseed = h.0.saturating_add(1);
h
}
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it.
pub fn next_handle(&self) -> Handle {
let mut h = self.handseed;
while self.foreign.handles.contains_key(&Handle(h)) && h < u64::MAX {
h = h.saturating_add(1);
}
Handle(h)
}
/// Make sure future handles don't collide with `h` (after loading a file).
pub fn bump_handseed(&mut self, h: Handle) {
if h.0 >= self.handseed {
+1
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)),
+11
View File
@@ -715,6 +715,17 @@ fn space_names_its_tab() {
assert_eq!(p.tab_name(), "Sheet A");
}
#[test]
fn new_handles_skip_the_files_object_handles() {
let mut d = Drawing::new_metric();
let next = d.handseed;
let f = std::sync::Arc::make_mut(&mut d.foreign);
f.handles.insert(Handle(next), ("LAYER".into(), "0".into()));
f.handles.insert(Handle(next + 1), ("NOD".into(), String::new()));
assert_eq!(d.new_handle(), Handle(next + 2));
assert_eq!(d.new_handle(), Handle(next + 3));
}
/// Several spellings of one DIM field apply once, the last in the map's order, and none is rejected.
#[test]
fn dim_style_spellings_of_one_field_apply_once() {
+6
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;
@@ -186,6 +190,8 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(draw::specs());
v.extend(draw2::specs());
v.extend(annotate::specs());
v.extend(dimstyles::specs());
v.extend(dimstyle_cli::specs());
v.extend(mleader_edit::specs());
v.extend(annoscale::specs());
v.extend(hatch::specs());
+129 -11
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);
+476 -11
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")] };
@@ -93,18 +99,29 @@ fn read_file(_path: &str) -> Result<Vec<u8>> {
}
/// (Re)define block `name` from `src`'s model space with base point `$INSBASE`, adding the
/// layers, linetypes, styles and blocks of `src` this drawing doesn't have. Nothing changes when
/// the definition fails (an invalid name, or a block that would contain itself).
fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
/// layers, linetypes, styles and blocks of `src` this drawing doesn't have. With `only_needed`
/// the layers, linetypes and styles that nothing uses are left out again, as when a block is
/// taken from a library drawing: only what the block needs comes along. Nothing changes when the
/// definition fails (an invalid name, or a block that would contain itself).
pub(super) fn define_from(s: &mut Session, src: &Drawing, name: &str, only_needed: bool) -> Result<String> {
if !valid_block_name(name) {
return Err(bad("insert", format!("\"{name}\" is not a valid block name")));
}
let mut d = s.doc()?.clone();
let before = TableNames::of(&d);
// Redefining keeps the existing definition's name (block names are case-insensitive).
let name = d.blocks.keys().find(|k| k.eq_ignore_ascii_case(name)).cloned().unwrap_or_else(|| name.to_string());
let own_dim_styles = names_of(&d, Kind::Dimstyles);
merge_tables(&mut d, src);
let renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
for (from, to) in &renames {
let mut renames = crate::cmd::merge::block_renames(&d, src, Some(&name));
if only_needed {
// The other blocks of the file are not copied at all.
let need = needed_blocks(src);
renames.retain(|from, _| need.contains(&from.to_ascii_uppercase()));
}
let renames = Renames::new(renames);
rename_style_arrows(&mut d, &own_dim_styles, &renames);
for (from, to) in &renames.exact {
let Some(b) = src.blocks.get(from) else { continue };
let mut nb = (**b).clone();
nb.name = to.clone();
@@ -130,10 +147,129 @@ fn define_from(s: &mut Session, src: &Drawing, name: &str) -> Result<String> {
b.entities.push(e);
}
d.blocks.insert(name.clone(), Arc::new(b));
if only_needed {
drop_unused_new(&mut d, &before, &name);
}
*s.doc_mut()? = d;
Ok(name)
}
/// The tables a drawing merge adds to, in an order where removing the unused entries of one
/// frees the next (blocks free layers, layers free linetypes, dimension styles free text styles).
const MERGED: [Kind; 8] =
[Kind::Blocks, Kind::Dimstyles, Kind::MleaderStyles, Kind::MlineStyles, Kind::TableStyles, Kind::Layers, Kind::Linetypes, Kind::TextStyles];
/// The names (lower case) in one of those tables.
fn names_of(d: &Drawing, kind: Kind) -> BTreeSet<String> {
let lower = |it: &mut dyn Iterator<Item = &String>| it.map(|n| n.to_ascii_lowercase()).collect::<BTreeSet<String>>();
match kind {
Kind::Blocks => lower(&mut d.blocks.keys()),
Kind::Dimstyles => lower(&mut d.dim_styles.iter().map(|t| &t.name)),
Kind::MleaderStyles => lower(&mut d.mleader_styles.iter().map(|t| &t.name)),
Kind::MlineStyles => lower(&mut d.mline_styles.iter().map(|t| &t.name)),
Kind::TableStyles => lower(&mut d.table_styles.iter().map(|t| &t.name)),
Kind::Layers => lower(&mut d.layers.iter().map(|t| &t.name)),
Kind::Linetypes => lower(&mut d.linetypes.iter().map(|t| &t.name)),
Kind::TextStyles => lower(&mut d.text_styles.iter().map(|t| &t.name)),
_ => BTreeSet::new(),
}
}
/// The names in the merged tables, by kind.
struct TableNames(Vec<(Kind, BTreeSet<String>)>);
impl TableNames {
fn of(d: &Drawing) -> Self {
TableNames(MERGED.iter().map(|k| (*k, names_of(d, *k))).collect())
}
}
/// Upper-case names of the blocks `roots` and every block they need, through nested references,
/// dimension blocks, multileader block content and dimension arrowheads.
fn reachable(d: &Drawing, roots: Vec<String>) -> BTreeSet<String> {
let mut seen = BTreeSet::new();
let mut todo = roots;
// Each block is walked once, so this ends, cycles included.
while let Some(n) = todo.pop() {
if !seen.insert(n.to_ascii_uppercase()) {
continue;
}
let Some(b) = d.block(&n) else { continue };
for e in b.entities.iter() {
todo.extend(referenced_block(e));
if let EntityKind::Dimension(dm) = &e.kind {
todo.extend(override_arrows(dm));
}
}
}
seen
}
/// Upper-case names of the blocks the model space of `src` needs: the ones it refers to, what
/// those need, and the arrowheads of its dimension styles.
fn needed_blocks(src: &Drawing) -> BTreeSet<String> {
let mut roots: Vec<String> = Vec::new();
for e in src.model.iter() {
roots.extend(referenced_block(e));
if let EntityKind::Dimension(dm) = &e.kind {
roots.extend(override_arrows(dm));
}
}
for st in &src.dim_styles {
let arrows = [&st.arrow_block, &st.arrow_block1, &st.arrow_block2, &st.leader_arrow_block];
roots.extend(arrows.into_iter().map(|n| n.trim().to_string()).filter(|n| !n.is_empty()));
}
reachable(src, roots)
}
/// Remove the blocks, layers, linetypes and styles that were not in the drawing `before` and that
/// nothing uses (PURGE's scan), in an order where removing one frees the next. `keep` is the
/// block just defined: nothing refers to it yet, so it and the blocks it needs stay. Nothing goes
/// from a drawing too big for that scan: an unused entry stays, but a used one would be lost.
fn drop_unused_new(d: &mut Drawing, before: &TableNames, keep: &str) {
if !scan_reads_everything(d) {
return;
}
// Removing a dimension style frees its arrowhead block, which an earlier table already
// scanned: scan again until a pass removes nothing (a chain is never longer than the tables).
for _ in 0..MERGED.len() {
if !drop_unused_pass(d, before, keep) {
break;
}
}
}
/// One scan of the merged tables; `true` when it removed something.
fn drop_unused_pass(d: &mut Drawing, before: &TableNames, keep: &str) -> bool {
let mut removed = false;
for (kind, old) in &before.0 {
// Nothing was added to this table: nothing to scan for.
if names_of(d, *kind).is_subset(old) {
continue;
}
let keep_blocks = if matches!(kind, Kind::Blocks) { reachable(d, vec![keep.to_string()]) } else { BTreeSet::new() };
let fresh: BTreeSet<String> = candidates(d, *kind)
.into_iter()
.filter(|n| !old.contains(&n.to_ascii_lowercase()) && !keep_blocks.contains(&n.to_ascii_uppercase()))
.map(|n| n.to_ascii_lowercase())
.collect();
let gone = |name: &str| fresh.contains(&name.to_ascii_lowercase());
removed |= !fresh.is_empty();
match kind {
Kind::Blocks => d.blocks.retain(|k, _| !gone(k)),
Kind::Dimstyles => d.dim_styles.retain(|t| !gone(&t.name)),
Kind::MleaderStyles => d.mleader_styles.retain(|t| !gone(&t.name)),
Kind::MlineStyles => d.mline_styles.retain(|t| !gone(&t.name)),
Kind::TableStyles => d.table_styles.retain(|t| !gone(&t.name)),
Kind::Layers => d.layers.retain(|t| !gone(&t.name)),
Kind::Linetypes => d.linetypes.retain(|t| !gone(&t.name)),
Kind::TextStyles => d.text_styles.retain(|t| !gone(&t.name)),
_ => {}
}
}
removed
}
/// Add the source's layers, linetypes and styles that this drawing doesn't have (a name that
/// exists keeps this drawing's definition).
fn merge_tables(d: &mut Drawing, src: &Drawing) {
@@ -147,9 +283,42 @@ fn merge_tables(d: &mut Drawing, src: &Drawing) {
merge(&mut d.mline_styles, &src.mline_styles, |t| &t.name);
}
/// The names the copied source blocks take, found as `Drawing::block` finds a block: a reference
/// may spell a name differently from its definition.
struct Renames {
exact: BTreeMap<String, String>,
upper: BTreeMap<String, String>,
}
impl Renames {
fn new(exact: BTreeMap<String, String>) -> Self {
let mut upper = BTreeMap::new();
for (from, to) in &exact {
upper.entry(from.to_ascii_uppercase()).or_insert_with(|| to.clone());
}
Renames { exact, upper }
}
fn get(&self, name: &str) -> Option<&String> {
self.exact.get(name).or_else(|| self.upper.get(&name.to_ascii_uppercase()))
}
}
/// Point the dimension styles the source brought at their renamed arrowhead blocks. The styles
/// this drawing already had (`own`) name this drawing's blocks.
fn rename_style_arrows(d: &mut Drawing, own: &BTreeSet<String>, renames: &Renames) {
for st in d.dim_styles.iter_mut().filter(|t| !own.contains(&t.name.to_ascii_lowercase())) {
for arrow in [&mut st.arrow_block, &mut st.arrow_block1, &mut st.arrow_block2, &mut st.leader_arrow_block] {
if let Some(n) = renames.get(arrow.trim()) {
arrow.clone_from(n);
}
}
}
}
/// A copy of a source entity for this drawing: a fresh handle, block references renamed, and
/// links to other source objects (associative dimension points) dropped.
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String, String>) -> Entity {
fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &Renames) -> Entity {
let mut e = e.clone();
let old = e.handle;
e.handle = d.new_handle();
@@ -174,6 +343,23 @@ fn adopt(d: &mut Drawing, src: &Drawing, e: &Entity, renames: &BTreeMap<String,
if let Some(n) = dm.block.as_ref().and_then(|b| renames.get(b)) {
dm.block = Some(n.clone());
}
for (key, value) in dm.overrides.iter_mut() {
// Only a block that was renamed changes the value: a number naming a block that
// kept its name stays as it was given.
if is_arrow_override(key)
&& let Some(b) = override_name(value)
&& let Some(n) = renames.get(&b).filter(|n| **n != b)
{
*value = json!(n);
}
}
}
EntityKind::MLeader(m) => {
if let Some(b) = &mut m.block
&& let Some(n) = renames.get(&b.block)
{
b.block = n.clone();
}
}
_ => {}
}
@@ -234,6 +420,78 @@ mod tests {
assert!(file_ref(&s, "BOLT").is_none());
}
/// A block holding very many references still reaches every block it needs.
#[test]
fn a_block_of_many_references_keeps_all_it_needs() {
let reference = |handle: u64, block: &str| {
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": block, "insert": [0, 0, 0] })).unwrap();
Entity::new(Handle(handle), EntityKind::Insert(insert))
};
let mut big = Block::new("Big");
big.entities.push(reference(0x100, "Deep"));
for i in 0..100_001 {
big.entities.push(reference(0x200 + i, "Leaf"));
}
let mut d = Drawing::default();
d.blocks.insert("Big".into(), Arc::new(big));
d.blocks.insert("Deep".into(), Arc::new(Block::new("Deep")));
d.blocks.insert("Leaf".into(), Arc::new(Block::new("Leaf")));
assert!(reachable(&d, vec!["Big".into()]).contains("DEEP"));
}
/// A drawing with very many references does not lose the arrowhead of a merged dimension
/// style: the arrowheads are the last thing PURGE's walk looks at.
#[test]
fn many_references_keep_a_merged_arrowhead() {
let mut d = Drawing::new_metric();
d.blocks.insert("Leaf".into(), Arc::new(Block::new("Leaf")));
for i in 0..100_001 {
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": "Leaf", "insert": [0, 0, 0] })).unwrap();
d.model.push(Entity::new(Handle(0x200 + i), EntityKind::Insert(insert)));
}
let before = TableNames::of(&d);
d.blocks.insert("Tip".into(), Arc::new(Block::new("Tip")));
d.dim_styles.push(cadcraft_doc::DimStyle { name: "Late".into(), arrow_block: "Tip".into(), ..Default::default() });
d.header.set_str("DIMSTYLE", "Late");
d.blocks.insert("Merged".into(), Arc::new(Block::new("Merged")));
drop_unused_new(&mut d, &before, "Merged");
assert!(d.block("Tip").is_some());
}
/// Past the purge scan's limit nothing is called unused: a merged block's dimension style and
/// layer stay even when the scan never reaches its objects.
#[test]
fn a_drawing_too_big_for_the_scan_keeps_what_was_merged() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
dim.common.layer = "Late".into();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.style = "Late".into();
}
// One definition under many names: millions of objects for the scan, thousands in memory.
let mut filler = Block::new("Filler");
for i in 0..10_000 {
filler.entities.push(Entity::new(Handle(0x1000 + i), dim.kind.clone()));
}
let filler = Arc::new(filler);
let mut d = Drawing::new_metric();
for i in 0..501 {
d.blocks.insert(format!("F{i:03}"), filler.clone());
}
let before = TableNames::of(&d);
assert!(!scan_reads_everything(&d));
d.layers.push(cadcraft_doc::Layer { name: "Late".into(), ..Default::default() });
d.dim_styles.push(cadcraft_doc::DimStyle { name: "Late".into(), ..Default::default() });
// Sorted after every filler, so past the limit.
let mut merged = Block::new("Z");
merged.entities.push(dim);
d.blocks.insert("Z".into(), Arc::new(merged));
drop_unused_new(&mut d, &before, "Z");
assert!(d.layers.iter().any(|l| l.name == "Late"));
assert!(d.dim_styles.iter().any(|t| t.name == "Late"));
}
#[test]
fn inserted_file_brings_its_mline_styles() {
let mut src = Drawing::default();
@@ -246,4 +504,211 @@ mod tests {
merge_tables(&mut d, &src);
assert_eq!(d.mline_styles.len(), before);
}
/// A block reference, for the fixtures below.
fn reference(handle: u64, block: &str) -> Entity {
let insert: cadcraft_doc::Insert = serde_json::from_value(json!({ "block": block, "insert": [0, 0, 0] })).unwrap();
Entity::new(Handle(handle), EntityKind::Insert(insert))
}
/// An anonymous block `*U1` that its description tells apart.
fn anonymous(description: &str) -> Arc<Block> {
let mut b = Block::new("*U1");
b.description = description.into();
Arc::new(b)
}
/// Takes `model`, whose `*U1` is the file's, into a drawing with a `*U1` of its own, and says
/// which of the two the one object of block "Part" refers to.
fn colliding_block_after_import(model: Entity) -> String {
let mut src = Drawing::new_metric();
src.blocks.insert("*U1".into(), anonymous("from the file"));
src.model.push(model);
let mut s = Session::new();
s.doc_mut().unwrap().blocks.insert("*U1".into(), anonymous("from the drawing"));
define_from(&mut s, &src, "Part", true).unwrap();
let d = s.doc().unwrap();
let part = d.block("Part").unwrap();
let to = part.entities.iter().next().and_then(|e| referenced_block(e)).unwrap();
d.block(&to).unwrap().description.clone()
}
/// Block names are case-insensitive, so `*u1` is the file's `*U1` and takes its new name.
#[test]
fn a_renamed_block_is_found_whatever_the_case_of_the_reference() {
assert_eq!(colliding_block_after_import(reference(0x500, "*u1")), "from the file");
}
/// The block content of a multileader takes the new name like any other reference.
#[test]
fn a_multileader_follows_its_renamed_block() {
let EntityKind::Insert(content) = reference(0x500, "*U1").kind else { return };
let mut m: cadcraft_doc::MLeader =
serde_json::from_value(json!({ "leaders": [], "landing": [0, 0, 0], "dogleg": 0.0, "text": null })).unwrap();
m.block = Some(content);
assert_eq!(colliding_block_after_import(Entity::new(Handle(0x501), EntityKind::MLeader(m))), "from the file");
}
/// An arrowhead override given as a number names its block: the block comes along, and the
/// override is left as given when the block keeps its name.
#[test]
fn a_numeric_arrowhead_override_brings_its_block() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.overrides.insert("DIMBLK1".into(), json!(45));
}
let mut src = Drawing::new_metric();
src.blocks.insert("45".into(), Arc::new(Block::new("45")));
src.model.push(dim);
let mut t = Session::new();
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
assert!(d.block("45").is_some());
let e = d.block("Part").unwrap().entities.iter().next().unwrap().clone();
let EntityKind::Dimension(dm) = &e.kind else { panic!("not a dimension") };
assert_eq!(dm.overrides["DIMBLK1"], json!(45));
}
/// Arrowheads are references too: a dimension style that came along and a dimension's override
/// follow the renamed block, and a style this drawing already had keeps its own.
#[test]
fn arrowheads_follow_a_renamed_block() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.style = "Came".into();
dm.overrides.insert("DIMBLK1".into(), json!("*U1"));
}
let style = |name: &str| cadcraft_doc::DimStyle { name: name.into(), arrow_block: "*U1".into(), ..Default::default() };
let mut src = Drawing::new_metric();
src.blocks.insert("*U1".into(), anonymous("from the file"));
src.dim_styles.extend([style("Came"), style("Own")]);
src.model.push(dim);
let mut t = Session::new();
let d = t.doc_mut().unwrap();
d.blocks.insert("*U1".into(), anonymous("from the drawing"));
d.dim_styles.push(style("Own"));
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
let of = |name: &str| d.block(name).unwrap().description.clone();
let arrow = |name: &str| d.dim_styles.iter().find(|st| st.name == name).unwrap().arrow_block.clone();
assert_eq!(of(&arrow("Came")), "from the file");
assert_eq!(of(&arrow("Own")), "from the drawing");
let e = d.block("Part").unwrap().entities.iter().next().unwrap().clone();
let EntityKind::Dimension(dm) = &e.kind else { return };
assert_eq!(of(dm.overrides["DIMBLK1"].as_str().unwrap()), "from the file");
}
/// What the objects of an imported block name comes along, directly or through another table:
/// a leader's dimension style, a dimension's text style override, the text style in a linetype,
/// an attribute's layer and multiline text style, here on a block reference and on a
/// multileader's block content. What nothing names stays out.
#[test]
fn an_import_keeps_every_style_and_layer_its_objects_name() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.overrides.insert("DIMTXSTY".into(), json!("InOverride"));
}
let attrib = |style: &str, layer: &str| {
let mut a: cadcraft_doc::Attrib = serde_json::from_value(json!({
"tag": "A",
"text": { "insert": [0, 0, 0], "height": 1.0, "value": "1" },
"multiline": { "mtext": { "insert": [0, 0, 0], "height": 1.0, "contents": "1", "style": style }, "readAs": "1" },
}))
.unwrap();
a.props.layer = Some(layer.into());
a
};
let mut placed = reference(0x500, "Inner");
if let EntityKind::Insert(i) = &mut placed.kind {
i.attribs.push(attrib("InAttribute", "OnAttribute"));
}
let EntityKind::Insert(mut content) = reference(0x501, "Inner").kind else { return };
content.attribs.push(attrib("InContent", "OnContent"));
let mut multileader: cadcraft_doc::MLeader =
serde_json::from_value(json!({ "leaders": [], "landing": [0, 0, 0], "dogleg": 0.0, "text": null })).unwrap();
multileader.block = Some(content);
let leader: cadcraft_doc::Leader = serde_json::from_value(json!({ "vertices": [], "style": "ForLeader" })).unwrap();
let line = cadcraft_doc::Line { a: cadcraft_geom::Vec3::ZERO, b: cadcraft_geom::Vec3::new(1.0, 0.0, 0.0) };
let mut line = Entity::new(Handle(0x502), EntityKind::Line(line));
line.common.linetype = "WithText".into();
let mut src = Drawing::new_metric();
src.blocks.insert("Inner".into(), Arc::new(Block::new("Inner")));
for name in ["InOverride", "InAttribute", "InContent", "InLinetype", "Spare"] {
let mut t = src.text_styles[0].clone();
t.name = name.into();
src.text_styles.push(t);
}
for name in ["OnAttribute", "OnContent", "Unused"] {
src.layers.push(cadcraft_doc::Layer { name: name.into(), ..Default::default() });
}
let dash = cadcraft_doc::DashElement { style: Some("InLinetype".into()), ..cadcraft_doc::DashElement::dash(1.0) };
src.linetypes.push(cadcraft_doc::Linetype { name: "WithText".into(), description: String::new(), pattern: vec![dash] });
src.dim_styles.push(cadcraft_doc::DimStyle { name: "ForLeader".into(), ..Default::default() });
src.model.push(dim);
src.model.push(placed);
src.model.push(Entity::new(Handle(0x503), EntityKind::MLeader(multileader)));
src.model.push(Entity::new(Handle(0x504), EntityKind::Leader(leader)));
src.model.push(line);
let mut t = Session::new();
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
let styles: Vec<&str> = d.text_styles.iter().map(|t| t.name.as_str()).collect();
for name in ["InOverride", "InAttribute", "InContent", "InLinetype"] {
assert!(styles.contains(&name), "{name}: {styles:?}");
}
assert!(!styles.contains(&"Spare"), "{styles:?}");
let layers: Vec<&str> = d.layers.iter().map(|l| l.name.as_str()).collect();
assert!(layers.contains(&"OnAttribute") && layers.contains(&"OnContent"), "{layers:?}");
assert!(!layers.contains(&"Unused"), "{layers:?}");
assert!(d.dim_styles.iter().any(|st| st.name == "ForLeader"));
}
/// The text style of a table style's cell style is in use.
#[test]
fn a_table_style_keeps_its_cell_styles_text_style() {
let mut d = Drawing::new_metric();
let mut t = d.text_styles[0].clone();
t.name = "InCell".into();
d.text_styles.push(t);
let mut cell = cadcraft_doc::TableStyle::default().cell_style("Data");
cell.text_style = "InCell".into();
d.table_styles[0].cell_styles.push(cell);
assert!(!candidates(&d, Kind::TextStyles).iter().any(|n| n == "InCell"));
}
/// A linetype of the file stays when a dimension style that came along names it, and stays out
/// when only a style that did not come along does.
#[test]
fn a_linetype_follows_the_dimension_style_that_names_it() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let mut dim = (**s.doc().unwrap().model.iter().next().unwrap()).clone();
if let EntityKind::Dimension(dm) = &mut dim.kind {
dm.style = "Used".into();
}
let mut src = Drawing::new_metric();
for name in ["Kept", "Left"] {
let mut lt = src.linetypes[0].clone();
lt.name = name.into();
src.linetypes.push(lt);
}
src.dim_styles.push(cadcraft_doc::DimStyle { name: "Used".into(), dim_linetype: "Kept".into(), ..Default::default() });
src.dim_styles.push(cadcraft_doc::DimStyle { name: "Spare".into(), ext_linetype1: "Left".into(), ..Default::default() });
src.model.push(dim);
let mut t = Session::new();
define_from(&mut t, &src, "Part", true).unwrap();
let d = t.doc().unwrap();
assert!(d.linetypes.iter().any(|l| l.name == "Kept"));
assert!(!d.dim_styles.iter().any(|st| st.name == "Spare"));
assert!(!d.linetypes.iter().any(|l| l.name == "Left"));
}
}
+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()
+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
@@ -363,7 +363,7 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
let (a, b) = (screen(Vec2::new(min.x, max.y)), screen(Vec2::new(max.x, min.y)));
cadcraft_render::raster::blank_outside_pixels(&mut pm, a, b);
}
let png = pm.encode_png().map_err(|_| bad("preview", "rendering the preview failed"))?;
let png = cadcraft_render::raster::encode_png(&pm).ok_or_else(|| bad("preview", "rendering the preview failed"))?;
let layout = space.tab_name();
Ok(json!({ "data": base64_encode(&png), "width": w, "height": h, "layout": layout, "paper": page.paper, "landscape": page.landscape }))
}
+18
View File
@@ -67,6 +67,22 @@ pub fn entity_codec() -> Option<&'static EntityCodec> {
CODEC.get()
}
/// The drawing's non-graphic records as written (tables, BLOCK records, objects): each one's
/// type, groups after the type and role (see [`cadcraft_doc::foreign::ForeignKey`]). AutoLISP's
/// `namedobjdict`, `tblobjname` and `handent` of non-graphic objects read them (installed by the
/// app with the DXF writer, a lower layer; kept apart from [`EntityCodec`] so hosts that only
/// need entities don't have to provide it).
pub type ObjectRecords = fn(&Drawing) -> Vec<(String, Vec<craft_dxf::Tag>, Option<cadcraft_doc::foreign::ForeignKey>)>;
static OBJECT_RECORDS: OnceLock<ObjectRecords> = OnceLock::new();
pub fn set_object_records(f: ObjectRecords) {
let _ = OBJECT_RECORDS.set(f);
}
pub fn object_records() -> Option<ObjectRecords> {
OBJECT_RECORDS.get().copied()
}
/// COMPARE (drawing comparison).
pub mod compare;
@@ -408,6 +424,7 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
}
s.cancel();
s.docs.remove(i);
s.lisp_forget_closed();
if i < s.active {
// An earlier drawing went away: the active one shifted down by one.
s.active -= 1;
@@ -423,6 +440,7 @@ fn run_close(s: &mut Session, p: &Value) -> Result<Value> {
fn run_closeall(s: &mut Session, _p: &Value) -> Result<Value> {
s.cancel();
s.docs.clear();
s.lisp_forget_closed();
s.active = 0;
s.bump_doc_epoch();
ok()
+9 -2
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")
+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));
+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
}
+107 -374
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,369 +208,6 @@ fn parse_transparency(v: &Value) -> Option<Transparency> {
(pct.is_finite() && (0.0..=90.0).contains(&pct)).then(|| Transparency::Percent(pct.round() as u8))
}
fn set_xy(p: &mut Vec3, v: &Value) {
if let Some(q) = point_value(v) {
p.x = q.x;
p.y = q.y;
}
}
/// The objects `properties.set` leaves alone, as CHPROP, MATCHPROP and MOVE do: those on locked
/// layers and, while a reference is edited in place, those outside the working set.
#[derive(Default)]
struct LeftOut {
locked: usize,
outside: usize,
}
impl LeftOut {
/// `hs` without the objects that can't be edited, each object once, and how many those were. A
/// handle that names no object is an error, before anything changes.
fn split(s: &Session, hs: Vec<Handle>) -> Result<(Vec<Handle>, LeftOut)> {
let d = s.doc()?;
// The working set, once: `RefEdit::is_working` searches a list.
let working: Option<std::collections::HashSet<Handle>> = d.refedit.as_ref().map(|r| r.items.iter().map(|i| i.copy).collect());
let mut seen = std::collections::HashSet::new();
let mut out = LeftOut::default();
let mut free = Vec::new();
for h in hs {
let Some(e) = d.entity(h) else {
return Err(cadcraft_doc::DocError::NoEntity(h).into());
};
if !seen.insert(h) {
continue;
}
if working.as_ref().is_some_and(|w| !w.contains(&h)) {
out.outside += 1;
} else if d.layer(&e.common.layer).is_some_and(|l| l.locked) {
out.locked += 1;
} else {
free.push(h);
}
}
Ok((free, out))
}
/// `{changed, locked}`, and a message saying how many were left out when any were.
fn result(&self, changed: usize) -> Value {
let mut notes = Vec::new();
match self.locked {
0 => {}
1 => notes.push("1 object was on a locked layer.".to_string()),
n => notes.push(format!("{n} objects were on a locked layer.")),
}
match self.outside {
0 => {}
1 => notes.push("1 object was not in the working set.".to_string()),
n => notes.push(format!("{n} objects were not in the working set.")),
}
if changed == 0 && !notes.is_empty() {
notes.push("Nothing was changed.".to_string());
}
let mut r = json!({ "changed": changed, "locked": self.locked + self.outside });
if !notes.is_empty()
&& let Some(o) = r.as_object_mut()
{
o.insert("message".into(), json!(notes.join(" ")));
}
r
}
}
fn run_set(s: &mut Session, p: &Value) -> Result<Value> {
let hs = targets(s, p)?;
if hs.is_empty() {
return Err(bad("properties.set", "nothing selected"));
}
let (hs, left_out) = LeftOut::split(s, hs)?;
let color = p.get("color").map(|c| parse_color(c).ok_or_else(|| bad("properties.set", "bad colour"))).transpose()?;
let transparency = p
.get("transparency")
.map(|v| parse_transparency(v).ok_or_else(|| bad("properties.set", "transparency must be ByLayer, ByBlock or a percentage from 0 to 90")))
.transpose()?;
let thickness = p
.get("thickness")
.map(|v| v.as_f64().filter(|x| x.is_finite()).ok_or_else(|| bad("properties.set", "thickness must be a finite number")))
.transpose()?;
let lw = p.get("lineweight").map(|v| super::layer::parse_lw(v).ok_or_else(|| bad("properties.set", "bad lineweight"))).transpose()?;
let d = s.doc()?;
// An explicit object linetype must be ByLayer, ByBlock or a loaded definition (as `linetype current` requires).
let linetype = str_param(p, "linetype")
.map(|n| {
if n.eq_ignore_ascii_case("ByLayer") || n.eq_ignore_ascii_case("ByBlock") {
Ok(n.to_string())
} else {
d.linetype(n).map(|t| t.name.clone()).ok_or_else(|| bad("properties.set", format!("linetype `{n}` is not loaded")))
}
})
.transpose()?;
let dim_style = str_param(p, "dimStyle")
.map(|n| d.dim_style(n).map(|st| st.name.clone()).ok_or_else(|| bad("properties.set", format!("dimension style `{n}` not found"))))
.transpose()?;
let dim_over = dim_overrides(p)?;
if hs.is_empty() {
// Every object was left out: the drawing stays as it was, with no undo step.
return Ok(left_out.result(0));
}
let d = s.doc_mut()?;
if let Some(l) = str_param(p, "layer") {
d.ensure_layer(l);
}
let anno_scale = d.current_anno_scale();
let common = CommonEntityProperties { anno_scale: &anno_scale, color, linetype: linetype.as_deref(), lineweight: lw, transparency, thickness };
for h in &hs {
d.modify_entity(*h, |e| {
set_common_properties(e, p, &common);
apply_kind_properties(e, p, dim_style.as_ref(), &dim_over);
})?;
}
Ok(left_out.result(hs.len()))
}
fn apply_kind_properties(
entity: &mut cadcraft_doc::Entity,
params: &Value,
dim_style: Option<&String>,
dim_overrides: &serde_json::Map<String, Value>,
) {
let num = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
match &mut entity.kind {
EntityKind::Line(l) => {
if let Some(v) = params.get("start") {
set_xy(&mut l.a, v);
}
if let Some(v) = params.get("end") {
set_xy(&mut l.b, v);
}
// Length / angle keep the start point and move the end point.
let (a, b) = (l.a.xy(), l.b.xy());
let len = num("length").filter(|x| *x > 0.0 && *x < 1e15).unwrap_or_else(|| a.dist(b));
let ang = num("angle").map(f64::to_radians).unwrap_or_else(|| a.angle_to(b));
if num("length").is_some() || num("angle").is_some() {
let e = cadcraft_geom::Vec2::polar(a, len, ang);
if e.is_finite() {
l.b.x = e.x;
l.b.y = e.y;
}
}
}
EntityKind::Circle(c) => {
if let Some(v) = params.get("center") {
set_xy(&mut c.center, v);
}
if let Some(r) = num("radius").filter(|r| *r > 0.0) {
c.radius = r;
}
if let Some(dm) = num("diameter").filter(|r| *r > 0.0) {
c.radius = dm / 2.0;
}
if let Some(cf) = num("circumference").filter(|x| *x > 0.0) {
c.radius = cf / cadcraft_geom::TAU;
}
if let Some(a) = num("area").filter(|x| *x > 0.0) {
c.radius = (a / cadcraft_geom::PI).sqrt();
}
}
EntityKind::Arc(a) => {
if let Some(v) = params.get("center") {
set_xy(&mut a.center, v);
}
if let Some(r) = num("radius").filter(|r| *r > 0.0) {
a.radius = r;
}
if let Some(x) = num("startAngle") {
a.start = cadcraft_geom::norm_angle(x.to_radians());
}
if let Some(x) = num("endAngle") {
a.end = cadcraft_geom::norm_angle(x.to_radians());
}
}
EntityKind::Text(t) => {
if let Some(v) = str_param(params, "text") {
t.value = v.to_string();
}
if let Some(x) = num("height").filter(|x| *x > 0.0) {
t.height = x;
}
if let Some(x) = num("rotation") {
t.rotation = x.to_radians();
}
if let Some(x) = num("widthFactor").filter(|x| *x > 0.0) {
t.width_factor = x;
}
// The position is the point the text is placed by: moving it moves the text.
if let Some(to) = params.get("position").and_then(point_value) {
let d = to - t.justify_point();
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
q.x += d.x;
q.y += d.y;
}
}
}
EntityKind::MText(t) => {
if let Some(v) = str_param(params, "text") {
t.contents = v.replace('\n', "\\P");
}
if let Some(x) = num("height").filter(|x| *x > 0.0) {
t.height = x;
}
if let Some(x) = num("width").filter(|x| *x >= 0.0) {
t.width = x;
}
if let Some(x) = num("rotation") {
t.rotation = x.to_radians();
}
}
// A multileader's text: its contents (#1081) and height.
EntityKind::MLeader(m) => {
if let Some(t) = &mut m.text {
if let Some(v) = str_param(params, "text") {
t.contents = v.replace('\n', "\\P");
}
if let Some(x) = num("height").filter(|x| *x > 0.0) {
t.height = x;
}
}
}
EntityKind::LwPolyline(pl) => {
if let Some(x) = num("width").filter(|x| *x >= 0.0) {
pl.const_width = x;
}
if let Some(c) = params.get("closed").and_then(Value::as_bool) {
pl.closed = c;
}
}
EntityKind::Insert(insert) => set_insert_properties(insert, params),
EntityKind::Dimension(dimension) => set_dimension_properties(dimension, params, dim_style, dim_overrides),
EntityKind::Hatch(hatch) => set_hatch_properties(hatch, params),
_ => {}
}
}
fn set_insert_properties(insert: &mut cadcraft_doc::Insert, params: &Value) {
let number = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
if let Some(x) = number("rotation") {
let turn = x.to_radians() - insert.rotation;
insert.rotation = x.to_radians();
// The attached text turns with the reference, around its insertion point (as ROTATE does).
let base = insert.insert.xy();
for a in &mut insert.attribs {
let t = &mut a.text;
for q in std::iter::once(&mut t.insert).chain(t.align_pt.as_mut()) {
let r = q.xy().rotate_about(base, turn);
q.x = r.x;
q.y = r.y;
}
t.rotation = cadcraft_geom::norm_angle(t.rotation + turn);
if let Some(ml) = &mut a.multiline {
let r = ml.mtext.insert.xy().rotate_about(base, turn);
ml.mtext.insert.x = r.x;
ml.mtext.insert.y = r.y;
ml.mtext.rotation = cadcraft_geom::norm_angle(ml.mtext.rotation + turn);
}
}
}
if let Some(x) = number("scale").filter(|x| *x != 0.0) {
// A new positive scale carries the attached attribute text with it, like SCALE about the insertion point.
if x > 0.0 && insert.scale.x > 0.0 {
let m = cadcraft_geom::Mat3::scale_about(insert.insert.xy(), x / insert.scale.x);
for a in &mut insert.attribs {
let mut k = EntityKind::Text(a.text.clone());
k.transform(&m);
if let EntityKind::Text(t) = k {
a.text = t;
}
a.transform_multiline(&m);
}
}
insert.scale = Vec3::new(x, x, x);
}
}
fn set_dimension_properties(
dimension: &mut cadcraft_doc::Dimension,
params: &Value,
style: Option<&String>,
overrides: &serde_json::Map<String, Value>,
) {
if let Some(v) = str_param(params, "textOverride") {
dimension.text = v.to_string();
dimension.block = None;
}
if let Some(st) = style {
dimension.style.clone_from(st);
dimension.block = None;
}
if !overrides.is_empty() {
dimension.overrides.extend(overrides.clone());
dimension.block = None;
}
}
fn set_hatch_properties(hatch: &mut cadcraft_doc::Hatch, params: &Value) {
let number = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite());
if let Some(v) = str_param(params, "pattern") {
if !hatch.pattern.eq_ignore_ascii_case(v) {
hatch.pattern_lines = super::hatch::lines_for(v);
}
hatch.pattern = v.to_ascii_uppercase();
// The old pattern's definition lines no longer apply.
hatch.pattern_lines.clear();
hatch.solid = hatch.pattern == "SOLID";
if !hatch.solid {
// A named pattern replaces the gradient fill; the renderer draws the gradient first when it is set.
hatch.gradient = None;
}
}
if let Some(x) = number("scale").filter(|x| *x > 0.0) {
hatch.scale = x;
}
if let Some(x) = number("angle") {
hatch.angle = x.to_radians();
}
}
struct CommonEntityProperties<'a> {
anno_scale: &'a cadcraft_doc::AnnoScale,
color: Option<Color>,
linetype: Option<&'a str>,
lineweight: Option<Lineweight>,
transparency: Option<Transparency>,
thickness: Option<f64>,
}
fn set_common_properties(entity: &mut cadcraft_doc::Entity, params: &Value, common: &CommonEntityProperties<'_>) {
if let Some(annotative) = params.get("annotative").and_then(Value::as_bool) {
cadcraft_doc::set_annotative(entity, annotative, common.anno_scale);
}
if let Some(layer) = str_param(params, "layer") {
entity.common.layer = layer.to_string();
}
if let Some(color) = common.color {
entity.common.color = color;
}
if let Some(linetype) = common.linetype {
entity.common.linetype = linetype.to_string();
}
if let Some(lineweight) = common.lineweight {
entity.common.lineweight = lineweight;
}
if let Some(scale) = params.get("ltscale").and_then(Value::as_f64).filter(|scale| *scale > 0.0) {
entity.common.ltscale = scale;
}
if let Some(transparency) = common.transparency {
entity.common.transparency = transparency;
}
if let Some(thickness) = common.thickness {
entity.common.thickness = thickness;
}
if let Some(visible) = params.get("visible").and_then(Value::as_bool) {
entity.common.visible = visible;
}
}
fn run_color(s: &mut Session, p: &Value) -> Result<Value> {
let c = p.get("color").and_then(parse_color).ok_or_else(|| bad("color", "`color` is required"))?;
set_current_color(s.doc_mut()?, c);
@@ -791,6 +447,8 @@ fn run_style(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad("style", "bad style name"));
}
let d = s.doc_mut()?;
// As it was (none for a new style), so dimensions are redrawn only when it changes.
let before = d.text_style(&name).cloned();
let idx = match d.text_styles.iter().position(|t| t.name.eq_ignore_ascii_case(&name)) {
Some(i) => i,
None => {
@@ -826,6 +484,13 @@ fn run_style(s: &mut Session, p: &Value) -> Result<Value> {
}
}
}
// Dimensions whose text uses the style drop the geometry they were read with when it
// changed: their text changes with it. Only making it current keeps that geometry.
if before.as_ref() != d.text_styles.get(idx) {
let text_style_of: std::collections::HashMap<String, String> =
d.dim_styles.iter().map(|st| (st.name.to_ascii_lowercase(), st.text_style.clone())).collect();
regen_dims(d, |dm| dim_text_style(dm, &text_style_of).eq_ignore_ascii_case(&name))?;
}
if bool_or(p, "current", true) {
d.header.set_str("TEXTSTYLE", &name);
}
@@ -854,12 +519,19 @@ pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
let stores = std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities)).chain(d.blocks.values().map(|b| &b.entities));
for st in stores {
for e in st.iter() {
out.extend(super::blocks::object_attribs(e).iter().flat_map(attrib_text_styles));
match &e.kind {
EntityKind::Text(t) => out.push(t.style.clone()),
EntityKind::MText(t) => out.push(t.style.clone()),
EntityKind::AttDef(a) => out.push(a.text.style.clone()),
EntityKind::Insert(i) => out.extend(i.attribs.iter().map(|a| a.text.style.clone())),
EntityKind::AttDef(a) => out.extend(attrib_text_styles(a)),
EntityKind::MLeader(m) => out.extend(m.text.iter().map(|t| t.style.clone())),
// A dimension's own text style (a DIMTXSTY override), which a rename follows too.
EntityKind::Dimension(dm) => out.extend(
dm.overrides
.iter()
.filter(|(k, _)| cadcraft_doc::DimStyle::field_name(k) == Some("textStyle"))
.filter_map(|(_, v)| super::blocks::purge::override_name(v)),
),
_ => {}
}
}
@@ -867,6 +539,11 @@ pub(super) fn text_styles_in_use(d: &cadcraft_doc::Drawing) -> Vec<String> {
out
}
/// The text styles of an attribute or attribute definition, its multiline text included.
fn attrib_text_styles(a: &cadcraft_doc::Attrib) -> impl Iterator<Item = String> + '_ {
std::iter::once(a.text.style.clone()).chain(a.multiline.iter().map(|m| m.mtext.style.clone()))
}
fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
let from = str_param(p, "from").ok_or_else(|| bad("style.rename", "`from` is required"))?.to_string();
let to = str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("style.rename", "`to` is required"))?.to_string();
@@ -896,6 +573,7 @@ fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
EntityKind::AttDef(a) => a.text.style.eq_ignore_ascii_case(&from),
EntityKind::Insert(i) => i.attribs.iter().any(|a| a.text.style.eq_ignore_ascii_case(&from)),
EntityKind::MLeader(m) => m.text.iter().any(|t| t.style.eq_ignore_ascii_case(&from)),
EntityKind::Dimension(dm) => dm.overrides.iter().any(|(k, v)| is_text_style_override(k, v, &from)),
_ => false,
};
let repoint = |k: &mut EntityKind| match k {
@@ -904,6 +582,8 @@ fn run_style_rename(s: &mut Session, p: &Value) -> Result<Value> {
EntityKind::AttDef(a) => fix(&mut a.text.style),
EntityKind::Insert(i) => i.attribs.iter_mut().for_each(|a| fix(&mut a.text.style)),
EntityKind::MLeader(m) => m.text.iter_mut().for_each(|t| fix(&mut t.style)),
// A dimension's own text style (a DIMTXSTY override).
EntityKind::Dimension(dm) => dm.overrides.iter_mut().filter(|(k, v)| is_text_style_override(k, v, &from)).for_each(|(_, v)| *v = json!(to)),
_ => {}
};
let mut hs: Vec<cadcraft_doc::Handle> = d.model.iter().filter(|e| uses(&e.kind)).map(|e| e.handle).collect();
@@ -953,7 +633,14 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
if name.is_empty() || name.len() > 255 {
return Err(bad("dimstyle", "bad style name"));
}
// A new style's name is one -DIMSTYLE takes (no `~`, which its Restore reads as compare, or
// wildcards); a style read from a file keeps the name it has.
if s.doc()?.dim_style(&name).is_none() {
super::dimstyle_cli::check_name(&name).map_err(|_| bad("dimstyle", "bad style name"))?;
}
let d = s.doc_mut()?;
// As it was (none for a new style), so dimensions are redrawn only when it changes.
let before = d.dim_style(&name).cloned();
let base = d.dim_style(&d.header.str("DIMSTYLE", "Standard")).cloned().unwrap_or_default();
let idx = match d.dim_styles.iter().position(|t| t.name.eq_ignore_ascii_case(&name)) {
Some(i) => i,
@@ -968,6 +655,12 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
src.iter().filter(|(k, _)| !matches!(k.as_str(), "name" | "current")).map(|(k, v)| (k.clone(), v.clone())).collect();
rejected = st.apply_fields(&fields);
}
// Dimensions with the style drop the geometry they were read with when it changed, so they
// show the edit (as AutoCAD updates every dimension that uses a style; their overrides still
// win). Only making it current keeps that geometry.
if before.as_ref() != d.dim_styles.get(idx) {
regen_dims(d, |dm| dm.style.eq_ignore_ascii_case(&name))?;
}
if bool_or(p, "current", true) {
d.header.set_str("DIMSTYLE", &name);
}
@@ -979,7 +672,8 @@ fn run_dimstyle(s: &mut Session, p: &Value) -> Result<Value> {
if !rejected.is_empty()
&& let Some(o) = out.as_object_mut()
{
o.insert("ignored".into(), json!(rejected));
o.insert("ignored".into(), json!(rejected.clone()));
o.insert("message".into(), json!(format!("Ignored invalid value for: {}", rejected.join(", "))));
}
Ok(out)
}
@@ -1010,6 +704,44 @@ fn run_dimstyle_current(s: &mut Session, p: &Value) -> Result<Value> {
Ok(dimstyles_json(d))
}
/// Dimensions (in model space, layouts and block definitions) that `uses` matches drop the
/// geometry block they were read with, so they are drawn and saved from their style again.
pub(super) fn regen_dims(d: &mut cadcraft_doc::Drawing, uses: impl Fn(&cadcraft_doc::Dimension) -> bool) -> Result<()> {
let stale = |e: &cadcraft_doc::Entity| matches!(&e.kind, EntityKind::Dimension(dm) if dm.block.is_some() && uses(dm));
let regen = |e: &mut cadcraft_doc::Entity| {
if let EntityKind::Dimension(dm) = &mut e.kind {
dm.block = None;
}
};
let mut hs: Vec<cadcraft_doc::Handle> = d.model.iter().filter(|e| stale(e)).map(|e| e.handle).collect();
hs.extend(d.layouts.iter().flat_map(|l| l.entities.iter().filter(|e| stale(e)).map(|e| e.handle)));
for h in hs {
d.modify_entity(h, regen)?;
}
for block in d.blocks.values_mut() {
let hs: Vec<cadcraft_doc::Handle> = block.entities.iter().filter(|e| stale(e)).map(|e| e.handle).collect();
if !hs.is_empty() {
let b = std::sync::Arc::make_mut(block);
for h in hs {
b.entities.modify(h, regen);
}
}
}
Ok(())
}
/// The text style a dimension's text is drawn with: its DIMTXSTY override, else its style's
/// (`text_style_of`: lower-case dimension style name → text style).
fn dim_text_style(dm: &cadcraft_doc::Dimension, text_style_of: &std::collections::HashMap<String, String>) -> String {
let own = dm.overrides.iter().find(|(k, _)| cadcraft_doc::DimStyle::field_name(k) == Some("textStyle")).and_then(|(_, v)| v.as_str());
own.map(str::to_string).or_else(|| text_style_of.get(&dm.style.to_ascii_lowercase()).cloned()).unwrap_or_else(|| "Standard".into())
}
/// Whether a dimension override `k: v` names text style `style`.
fn is_text_style_override(k: &str, v: &Value, style: &str) -> bool {
cadcraft_doc::DimStyle::field_name(k) == Some("textStyle") && v.as_str().is_some_and(|n| n.eq_ignore_ascii_case(style))
}
fn dims_using(d: &cadcraft_doc::Drawing, name: &str) -> Vec<(cadcraft_doc::Space, cadcraft_doc::Handle)> {
let mut out = Vec::new();
for space in std::iter::once(cadcraft_doc::Space::Model).chain(d.layouts.iter().map(|l| cadcraft_doc::Space::Paper(l.name.clone()))) {
@@ -1052,6 +784,7 @@ fn block_dims_using(d: &cadcraft_doc::Drawing, name: &str) -> Vec<(String, cadcr
fn run_dimstyle_rename(s: &mut Session, p: &Value) -> Result<Value> {
let from = str_param(p, "from").ok_or_else(|| bad("dimstyle.rename", "`from` is required"))?.to_string();
let to = str_param(p, "to").map(str::trim).filter(|t| !t.is_empty()).ok_or_else(|| bad("dimstyle.rename", "`to` is required"))?.to_string();
let to = super::dimstyle_cli::check_name(&to).map_err(|_| bad("dimstyle.rename", "bad style name"))?;
let d = s.doc_mut()?;
if from.eq_ignore_ascii_case("Standard") {
return Err(bad("dimstyle.rename", "the Standard style cannot be renamed"));
+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");
}
}
+8
View File
@@ -27,6 +27,7 @@ pub mod lisp;
pub mod mtext_edit;
pub mod pointmod;
pub mod prompt;
pub mod properties;
mod recent;
pub mod render_look;
pub mod sample;
@@ -85,6 +86,11 @@ pub struct Session {
pub doc_epoch: u64,
pub settings: Settings,
pub running: Option<Running>,
/// How many commands were started, nested transparent ones left out.
pub commands_started: u64,
/// The last command that ended by itself, not cancelled: its number in `commands_started`, and
/// whether it took new handles (it added to the drawing, and nothing took that back).
pub last_finished: Option<(u64, bool)>,
/// A script is running ([`Session::script`]); a SCRIPT command inside it is refused.
in_script: bool,
/// The command suspended while a transparent command (`'ZOOM`, `'PAN`…) prompts inside it;
@@ -176,6 +182,8 @@ impl Session {
doc_epoch: 0,
settings: Settings::default(),
running: None,
commands_started: 0,
last_finished: None,
in_script: false,
suspended: None,
log: Vec::new(),
+28 -4
View File
@@ -5,10 +5,14 @@
//! (`getpoint`, `pause`) and carry on later, so the interface keeps drawing while a routine
//! waits. Each drawing has its own symbols, as in AutoCAD. A run is one undo step.
/// A block-definition entity and its successor in the block, by handle.
pub type BlockSlots = HashMap<Handle, (Arc<cadcraft_doc::Entity>, Option<Handle>)>;
pub mod builtins;
mod drawing;
pub mod eval;
pub mod input;
mod objects;
pub mod read;
mod startup;
pub mod value;
@@ -54,13 +58,20 @@ pub struct Env {
pub next_file: u32,
/// Entities `entdel` deleted (it brings them back when called again), with their space.
pub deleted: HashMap<Handle, (cadcraft_doc::Space, Arc<cadcraft_doc::Entity>)>,
/// Every entity's handle in creation order, for the drawing it was taken from (`entnext`).
pub order: Option<(usize, Arc<Vec<Handle>>)>,
/// Every entity's handle in creation order (`entlast`, `entnext`), with clones of the spaces
/// it was taken from (model space, then each layout): it is reused only while the drawing's
/// spaces still share every chunk with them ([`cadcraft_doc::EntityStore::same_as`]).
pub order: Option<(Vec<cadcraft_doc::EntityStore>, Arc<Vec<Handle>>)>,
/// Each block-definition entity with its successor in its block (None for the last), for the drawing
/// it was taken from: `entnext`'s indexed lookup, which also tells whether a handle is a block's.
pub block_next: Option<(usize, Arc<BlockSlots>)>,
/// `tblnext`'s place in each table.
pub tblnext: HashMap<String, usize>,
/// A block definition `entmake` has begun (a BLOCK list) and not yet ended (ENDBLK): the
/// entities made meanwhile go into it, numbered when it ends.
pub pending_block: Option<(cadcraft_doc::Block, Vec<cadcraft_doc::Entity>)>,
/// Entity names of non-graphic objects (dictionaries, table records, layouts).
pub(crate) objects: objects::Names,
/// The command history's length after LISP last printed a line: when something else wrote since
/// (a prompt, a command's echo), a leading newline only ends that line.
pub printed_at: Option<usize>,
@@ -77,8 +88,10 @@ impl Default for Env {
next_file: 1,
deleted: HashMap::new(),
order: None,
block_next: None,
tblnext: HashMap::new(),
pending_block: None,
objects: objects::Names::default(),
printed_at: None,
};
builtins::install(&mut e);
@@ -207,8 +220,19 @@ impl Session {
self.lisp.envs.remove(&uid).unwrap_or_default()
}
/// Put a drawing's environment back, unless the drawing was closed meanwhile (a routine
/// cancelled by CLOSE ends after its drawing went away).
fn lisp_env_put(&mut self, uid: u64, env: Env) {
self.lisp.envs.insert(uid, env);
if uid == 0 || self.docs.iter().any(|d| d.uid == uid) {
self.lisp.envs.insert(uid, env);
}
}
/// Drop the environments of drawings no longer open: one holds clones of its drawing's
/// entity stores ([`Env::order`]), which would otherwise outlive the drawing.
pub(crate) fn lisp_forget_closed(&mut self) {
let docs = &self.docs;
self.lisp.envs.retain(|uid, _| *uid == 0 || docs.iter().any(|d| d.uid == *uid));
}
/// A routine is running (possibly waiting for input).
@@ -451,7 +475,7 @@ impl Session {
let steps = std::mem::take(&mut self.lisp.steps);
let mut env = self.lisp.envs.remove(&run.uid).unwrap_or_default();
self.lisp_flush(&mut env, true);
self.lisp.envs.insert(run.uid, env);
self.lisp_env_put(run.uid, env);
if let (Ok(v), true) = (&result, run.print) {
let text = value::to_text(v, true);
if !builtins::is_null_symbol(v) {
+37
View File
@@ -234,3 +234,40 @@ fn a_definition_that_isnt_added_leaves_no_layer() {
assert_eq!(ok(&mut s, ENDBLK), "\"EB\"");
assert!(has(&s, "PARTS"), "the block's layer exists once it is added");
}
/// entnext walks entmade block entities in order through the cached successor index, and a
/// redefinition (same drawing, same block name) is not served from the stale index.
#[test]
fn entnext_walks_entmade_blocks_and_sees_a_redefinition() {
let mut s = session();
let walk = r#"(progn (setq e (cdr (assoc -2 (tblsearch "BLOCK" "EB"))) types nil)
(while e (setq types (cons (cdr (assoc 0 (entget e))) types) e (entnext e)))
(reverse types))"#;
for code in [BLOCK_EB, LINE, CIRCLE, ENDBLK] {
ok(&mut s, code);
}
assert_eq!(ok(&mut s, walk), "(\"LINE\" \"CIRCLE\")");
assert_eq!(ok(&mut s, walk), "(\"LINE\" \"CIRCLE\")", "second walk from the cache");
for code in [BLOCK_EB, CIRCLE, LINE, LINE, ENDBLK] {
ok(&mut s, code);
}
assert_eq!(ok(&mut s, walk), "(\"CIRCLE\" \"LINE\" \"LINE\")");
}
/// entget and handent reach every entity of an entmade block through the cached index, and a
/// redefinition shows the new entities, not the old ones.
#[test]
fn entget_and_handent_reach_every_block_entity_also_after_a_redefinition() {
let mut s = session();
let walk = r#"(progn (setq e (cdr (assoc -2 (tblsearch "BLOCK" "EB"))) r nil)
(while e (setq r (cons (list (cdr (assoc 0 (entget e))) (equal (handent (cdr (assoc 5 (entget e)))) e)) r) e (entnext e)))
(reverse r))"#;
for code in [BLOCK_EB, LINE, CIRCLE, LINE, ENDBLK] {
ok(&mut s, code);
}
assert_eq!(ok(&mut s, walk), "((\"LINE\" T) (\"CIRCLE\" T) (\"LINE\" T))");
for code in [BLOCK_EB, CIRCLE, ENDBLK] {
ok(&mut s, code);
}
assert_eq!(ok(&mut s, walk), "((\"CIRCLE\" T))");
}
+5 -1
View File
@@ -11,7 +11,7 @@ use std::sync::Arc;
use super::eval::{Ctx, Flow, Special};
use super::value::{Builtin, BuiltinKind, Sym, Value, charge_bytes, check_string_len, eq, equal, real_text, to_text};
use super::{Env, LispError, drawing, input, read};
use super::{Env, LispError, drawing, input, objects, read};
macro_rules! cxrs {
($($name:ident $path:literal),*) => {
@@ -262,6 +262,10 @@ static BUILTINS: &[Builtin] = &[
ctx!("SSGETFIRST", drawing::ssgetfirst),
ctx!("TBLSEARCH", drawing::tblsearch),
ctx!("TBLNEXT", drawing::tblnext),
ctx!("TBLOBJNAME", objects::tblobjname),
ctx!("NAMEDOBJDICT", objects::namedobjdict),
ctx!("DICTSEARCH", objects::dictsearch),
ctx!("DICTNEXT", objects::dictnext),
ctx!("RTOS", drawing::rtos),
ctx!("ANGTOS", drawing::angtos),
ctx!("DISTOF", drawing::distof),
+3 -1
View File
@@ -126,9 +126,11 @@ fn write_text_file(path: &str, text: &str, append: bool) {
#[cfg(target_arch = "wasm32")]
fn write_text_file(_path: &str, _text: &str, _append: bool) {}
/// A file or a folder: routines test whether a module is installed with `(findfile "module/.")`.
#[cfg(not(target_arch = "wasm32"))]
fn file_exists(path: &str) -> bool {
std::path::Path::new(path).is_file()
let p = std::path::Path::new(path);
p.is_file() || p.is_dir()
}
#[cfg(target_arch = "wasm32")]
+113 -22
View File
@@ -1,5 +1,6 @@
//! Drawing access from LISP: `command`, system variables, entity lists (`entget`, `entmake`,
//! `entmod`, `entdel`, `entlast`, `entnext`, `handent`), selection sets (`ssget` and friends),
//! `entmod`, `entdel`, `entlast`, `entnext`, `handent`; non-graphic objects are in
//! [`super::objects`]), selection sets (`ssget` and friends),
//! symbol tables (`tblsearch`, `tblnext`) and unit conversions (`rtos`, `angtos`, `distof`,
//! `angtof`).
//!
@@ -7,19 +8,21 @@
//! [`crate::cmd::file::entity_codec`]), so what `entget` shows is what a DXF file holds, except
//! for angles, which are radians in a list and degrees in a file.
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use cadcraft_doc::{Entity, Handle, Space};
use cadcraft_geom::Vec2;
use craft_dxf::Tag;
use super::LispError;
use super::builtins::args_err;
use super::eval::{Ctx, Flow, Need};
use super::value::{PickSet, Value, to_text};
use super::{BlockSlots, LispError};
use crate::{Input, Session};
fn arity(a: &[Value], min: usize, max: usize) -> Result<(), LispError> {
pub(super) fn arity(a: &[Value], min: usize, max: usize) -> Result<(), LispError> {
if a.len() < min {
return Err(args_err(true));
}
@@ -29,14 +32,14 @@ fn arity(a: &[Value], min: usize, max: usize) -> Result<(), LispError> {
Ok(())
}
fn ename(v: &Value) -> Result<Handle, LispError> {
pub(super) fn ename(v: &Value) -> Result<Handle, LispError> {
match v {
Value::Ename(h) => Ok(*h),
other => Err(LispError::bad_arg("lentityp", other)),
}
}
fn string(v: &Value) -> Result<String, LispError> {
pub(super) fn string(v: &Value) -> Result<String, LispError> {
match v {
Value::Str(s) => Ok(s.to_string()),
other => Err(LispError::bad_arg("stringp", other)),
@@ -271,7 +274,7 @@ fn tag_value(t: &Tag) -> Value {
}
/// DXF groups as an association list: points combined into lists `(10 x y z)`.
fn groups_to_list(tags: &[Tag]) -> Vec<Value> {
pub(super) fn groups_to_list(tags: &[Tag]) -> Vec<Value> {
let mut out = Vec::new();
let mut i = 0;
while let Some(t) = tags.get(i) {
@@ -356,8 +359,16 @@ fn space_of(d: &cadcraft_doc::Drawing, h: Handle) -> Option<Space> {
pub fn entget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 1, 2)?;
let h = ename(&a[0])?;
let drawn = ctx.s.doc().is_ok_and(|d| d.entity(h).is_some());
let from_block = if drawn { None } else { block_entity(ctx, h) };
let Ok(d) = ctx.s.doc() else { return Ok(Flow::Value(Value::Nil)) };
let Some(e) = d.entity(h) else { return Ok(Flow::Value(Value::Nil)) };
// An entity of a block definition (#1700) has no layout.
let (e, in_block) = match (d.entity(h), &from_block) {
(Some(e), _) => (e, false),
(None, Some(e)) => (e, true),
// Not an entity: a table record, layout or dictionary (#1659, #1661).
(None, None) => return Ok(Flow::Value(super::objects::entget(ctx, h))),
};
let (kind, mut tags) = (codec()?.groups)(d, e);
convert_angles(&kind, &mut tags, f64::to_radians);
let layout = match space_of(d, h) {
@@ -365,7 +376,7 @@ pub fn entget(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
_ => "Model".into(),
};
let mut items = vec![Value::cons(Value::Int(-1), Value::Ename(h)), Value::cons(Value::Int(0), Value::str(&kind))];
let mut placed_layout = false;
let mut placed_layout = in_block;
for v in groups_to_list(&tags) {
// The layout name follows the AcDbEntity marker, as AutoCAD lists it.
let after_marker = !placed_layout && v.car().as_number() == Some(100.0) && matches!(v.cdr(), Value::Str(ref s) if &**s == "AcDbEntity");
@@ -493,6 +504,7 @@ fn end_block(ctx: &mut Ctx<'_>) -> Value {
}
let name = b.name.clone();
d.blocks.insert(name.clone(), Arc::new(b));
ctx.env.block_next = None;
ctx.s.touch();
Value::str(&name)
}
@@ -504,7 +516,7 @@ pub fn entmod(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
return Err(LispError::bad_arg("lentityp", &Value::Nil));
};
let Some(old) = ctx.s.doc().ok().and_then(|d| d.entity(h)).cloned() else { return Ok(Flow::Value(Value::Nil)) };
let (kind_name, common, kind) = match entity_from_list(ctx, list) {
let (kind_name, common, mut kind) = match entity_from_list(ctx, list) {
Ok(x) => x,
Err(_) => return Ok(Flow::Value(Value::Nil)),
};
@@ -512,6 +524,13 @@ pub fn entmod(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
if !kind_name.eq_ignore_ascii_case(old.kind.dxf_name()) {
return Ok(Flow::Value(Value::Nil));
}
// A block reference's attributes are entities of their own in AutoCAD, which entmod of the
// INSERT leaves alone; its list doesn't hold them, so they are kept from the reference.
if let (cadcraft_doc::EntityKind::Insert(new), cadcraft_doc::EntityKind::Insert(was)) = (&mut kind, &old.kind)
&& new.attribs.is_empty()
{
new.attribs = was.attribs.clone();
}
let Ok(d) = ctx.s.doc_mut() else { return Ok(Flow::Value(Value::Nil)) };
d.ensure_layer(&common.layer);
let ok = d
@@ -557,24 +576,76 @@ pub fn entdel(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
}
}
/// `b` holds the same handles as `a`, in the same chunks and order. A chunk `b` still shares
/// with `a` (which is held, so its chunks stay alive) is the same; only a chunk an edit copied is
/// compared handle by handle.
fn same_handles(a: &cadcraft_doc::EntityStore, b: &cadcraft_doc::EntityStore) -> bool {
if a.len() != b.len() {
return false;
}
let (mut x, mut y) = (a.chunk_slices(), b.chunk_slices());
loop {
match (x.next(), y.next()) {
(None, None) => return true,
(Some((ka, sa)), Some((kb, sb))) => {
if ka != kb && (sa.len() != sb.len() || sa.iter().zip(sb).any(|(p, q)| p.handle != q.handle)) {
return false;
}
}
_ => return false,
}
}
}
/// Every entity's handle in creation order (model space and layouts), cached per drawing.
///
/// The cache is keyed by content identity, as the spatial index is: it holds clones of the
/// spaces it was taken from, so any edit (`entmake`, `entmod`, `entdel`, a command, undo) copies
/// the chunk it touches and the cache no longer matches. The drawing's address is no key: an
/// edit in place keeps it, and a new drawing can be given the address of a dropped one.
fn handles_in_order(ctx: &mut Ctx<'_>) -> Arc<Vec<Handle>> {
let Ok(d) = ctx.s.doc() else { return Arc::default() };
let spaces = || std::iter::once(&d.model).chain(d.layouts.iter().map(|l| &l.entities));
if let Some((stores, v)) = &mut ctx.env.order
&& stores.len() == 1 + d.layouts.len()
&& stores.iter().zip(spaces()).all(|(a, b)| same_handles(a, b))
{
// An edit that left every handle in place (a property `entmod`) keeps the order: hold
// the spaces as they are now, so the next call finds their chunks shared again.
if !stores.iter().zip(spaces()).all(|(a, b)| a.same_as(b)) {
*stores = spaces().cloned().collect();
}
return v.clone();
}
let mut v: Vec<Handle> = spaces().flat_map(|s| s.iter().map(|e| e.handle)).collect();
v.sort_unstable();
let v = Arc::new(v);
ctx.env.order = Some((spaces().cloned().collect(), v.clone()));
v
}
/// Every block-definition entity with its successor within its block, cached per drawing like
/// [`handles_in_order`]: one pass over the blocks, then `entnext`, `entget` and `handent` on a
/// block's entity are hash lookups instead of scans of the block (and of every block, to find
/// which holds the entity).
fn block_slots(ctx: &mut Ctx<'_>) -> Arc<BlockSlots> {
let Ok(st) = ctx.s.state() else { return Arc::default() };
let key = Arc::as_ptr(&st.doc) as usize;
if let Some((k, v)) = &ctx.env.order
if let Some((k, v)) = &ctx.env.block_next
&& *k == key
{
return v.clone();
}
let d = &st.doc;
let mut v: Vec<Handle> = d.model.handles();
for l in &d.layouts {
v.extend(l.entities.handles());
let mut m = HashMap::new();
for b in st.doc.blocks.values() {
let mut it = b.entities.iter().peekable();
while let Some(e) = it.next() {
m.insert(e.handle, (e.clone(), it.peek().map(|n| n.handle)));
}
}
v.sort_unstable();
let v = Arc::new(v);
ctx.env.order = Some((key, v.clone()));
v
let m = Arc::new(m);
ctx.env.block_next = Some((key, m.clone()));
m
}
pub fn entlast(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
@@ -584,6 +655,15 @@ pub fn entlast(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
pub fn entnext(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 0, 1)?;
// From an entity of a block definition: the next one in that block, nil after the last (#1700).
if let Some(v) = a.first().filter(|v| !v.is_nil()) {
let h = ename(v)?;
if ctx.s.doc().is_ok_and(|d| d.entity(h).is_none())
&& let Some((_, next)) = block_slots(ctx).get(&h)
{
return Ok(Flow::Value(next.map(Value::Ename).unwrap_or_default()));
}
}
let order = handles_in_order(ctx);
let next = match a.first() {
None | Some(Value::Nil) => order.first().copied(),
@@ -599,8 +679,14 @@ pub fn entnext(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
pub fn handent(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 1, 1)?;
let s = string(&a[0])?;
let h = Handle::parse_hex(&s).filter(|h| ctx.s.doc().is_ok_and(|d| d.entity(*h).is_some()));
Ok(Flow::Value(h.map(Value::Ename).unwrap_or_default()))
let Some(h) = Handle::parse_hex(&s) else { return Ok(Flow::Value(Value::Nil)) };
let found = ctx.s.doc().is_ok_and(|d| d.entity(h).is_some()) || block_entity(ctx, h).is_some() || super::objects::exists(ctx, h);
Ok(Flow::Value(if found { Value::Ename(h) } else { Value::Nil }))
}
/// Entity `h` of a block definition (#1700), by the cached index.
fn block_entity(ctx: &mut Ctx<'_>, h: Handle) -> Option<Arc<Entity>> {
block_slots(ctx).get(&h).map(|(e, _)| e.clone())
}
// ---------------- selection sets ----------------
@@ -992,12 +1078,17 @@ fn table_records(d: &cadcraft_doc::Drawing, table: &str) -> Vec<Value> {
.blocks
.values()
.map(|b| {
Value::list(vec![
let mut items = vec![
pair(0, Value::str("BLOCK")),
pair(2, Value::str(&b.name)),
pair(70, Value::Int(0)),
Value::list(vec![Value::Int(10), Value::Real(b.base.x), Value::Real(b.base.y), Value::Real(b.base.z)]),
])
];
// Its first entity (-2): entnext walks the rest of the definition (#1700).
if let Some(first) = b.entities.iter().next() {
items.push(pair(-2, Value::Ename(first.handle)));
}
Value::list(items)
})
.collect(),
"DIMSTYLE" => d
+281
View File
@@ -0,0 +1,281 @@
//! Non-graphic objects from LISP: the named object dictionary and its dictionaries, table records
//! and layouts (`namedobjdict`, `dictsearch`, `dictnext`, `tblobjname`, and `handent` and
//! `entget` of such an object).
//!
//! CADCraft writes these objects from its own model and gives them handles only in a file, so
//! they are read from the drawing's records as a DXF file of it holds them
//! ([`crate::cmd::file::EntityCodec::objects`]). Each object gets an entity name that stays the
//! same for the drawing's session: the handle the drawing's file gave it, when the drawing was
//! read from a file that had it, otherwise a name above any file's handles. An object is known by
//! its role (a layer's name, a dictionary key, a layout's name), so its name follows it across
//! edits; one without a role (an object of a deeper dictionary) is known by its handle in the
//! written records, so its name holds only until the drawing changes (then it names nothing). Lists of these objects are
//! read-only: `entmod` and `entmake` don't take them.
use std::collections::HashMap;
use std::sync::{Arc, Weak};
use cadcraft_doc::foreign::ForeignKey;
use cadcraft_doc::{Drawing, Handle};
use craft_dxf::Tag;
use super::LispError;
use super::drawing::{arity, ename, groups_to_list, string};
use super::eval::{Ctx, Flow};
use super::value::Value;
/// The first entity name given to an object its drawing's file didn't name.
const OWN_NAMES: u64 = 0x7F00_0000_0000_0000;
/// The kind of a key for an object without a role: its written handle is the name.
const BY_HANDLE: &str = "@";
/// The entity names given to non-graphic objects, and what they are read from.
#[derive(Default)]
pub struct Names {
by_key: HashMap<ForeignKey, Handle>,
by_name: HashMap<Handle, ForeignKey>,
next: u64,
/// The written records of the drawing they were taken from (held weakly, so its address
/// can't be reused for another drawing while the records are kept).
records: Option<(Weak<Drawing>, Arc<Records>)>,
/// `dictnext`'s place in each dictionary.
dictnext: HashMap<Handle, usize>,
}
/// A drawing's non-graphic records as written.
struct Records {
list: Vec<(String, Vec<Tag>, Option<ForeignKey>)>,
/// Written handle → index in `list`.
by_handle: HashMap<String, usize>,
/// Role → written handle.
by_role: HashMap<ForeignKey, String>,
}
impl Records {
fn key(&self, written: &str) -> Option<ForeignKey> {
let i = *self.by_handle.get(written)?;
let (_, _, role) = self.list.get(i)?;
Some(role.clone().unwrap_or_else(|| (BY_HANDLE.into(), written.to_string())))
}
fn written(&self, key: &ForeignKey) -> Option<&str> {
if key.0 == BY_HANDLE {
return self.by_handle.get_key_value(&key.1).map(|(h, _)| h.as_str());
}
self.by_role.get(key).map(String::as_str)
}
fn record(&self, written: &str) -> Option<&(String, Vec<Tag>, Option<ForeignKey>)> {
self.list.get(*self.by_handle.get(written)?)
}
}
/// A record's own handle: group 5, or 105 for a DIMSTYLE (before any xdata).
fn own_handle(tags: &[Tag]) -> Option<&Tag> {
tags.iter().take_while(|t| t.code < 1000).find(|t| matches!(t.code, 5 | 105))
}
/// A handle as the records spell it (upper-case hex without leading zeros).
fn norm(hex: &str) -> Option<String> {
Handle::parse_hex(hex.trim()).map(Handle::hex)
}
fn records(names: &mut Names, d: &Arc<Drawing>) -> Option<Arc<Records>> {
if let Some((w, r)) = &names.records
&& std::ptr::eq(w.as_ptr(), Arc::as_ptr(d))
{
return Some(r.clone());
}
let list = crate::cmd::file::object_records()?(d);
let mut by_handle = HashMap::new();
let mut by_role = HashMap::new();
for (i, (_, tags, role)) in list.iter().enumerate() {
let Some(h) = own_handle(tags).and_then(|t| norm(&t.str())) else { continue };
if let Some(role) = role {
by_role.entry(role.clone()).or_insert_with(|| h.clone());
}
by_handle.entry(h).or_insert(i);
}
let r = Arc::new(Records { list, by_handle, by_role });
// Written handles change with the drawing: names given by them no longer hold.
names.by_key.retain(|k, _| k.0 != BY_HANDLE);
names.by_name.retain(|_, k| k.0 != BY_HANDLE);
names.records = Some((Arc::downgrade(d), r.clone()));
Some(r)
}
/// The entity name of the object with `key`, given out now if it has none yet.
fn name_of(names: &mut Names, d: &Drawing, key: &ForeignKey) -> Option<Handle> {
if let Some(h) = names.by_key.get(key) {
return Some(*h);
}
let free = |names: &Names, h: Handle| d.entity(h).is_none() && !names.by_name.contains_key(&h);
let file = (key.0 != BY_HANDLE).then(|| d.foreign.handles.iter().find(|(_, k)| *k == key).map(|(h, _)| *h)).flatten();
let h = match file.filter(|h| free(names, *h)) {
Some(h) => h,
None => {
// A name of its own, past any that is taken (a hostile file can use this range too).
let mut found = None;
for _ in 0..1024 {
let h = Handle(OWN_NAMES.checked_add(names.next)?);
names.next = names.next.checked_add(1)?;
if free(names, h) && !d.foreign.handles.contains_key(&h) {
found = Some(h);
break;
}
}
found?
}
};
names.by_key.insert(key.clone(), h);
names.by_name.insert(h, key.clone());
Some(h)
}
/// What an entity name of a non-graphic object stands for.
fn key_of(names: &Names, d: &Drawing, h: Handle) -> Option<ForeignKey> {
names.by_name.get(&h).cloned().or_else(|| d.foreign.handles.get(&h).cloned())
}
/// Groups that hold a handle (DXF Reference, group code value types): soft and hard pointers and
/// owners, arbitrary object handles and plot style handles.
fn pointer_group(code: i32) -> bool {
matches!(code, 320..=369 | 390..=399 | 480..=481)
}
/// The object `written` as an entity list: `(-1 . name)`, its type and its groups, with its
/// handle (group 5, a DIMSTYLE's 105) as its name's and pointers as entity names.
fn object_list(names: &mut Names, d: &Drawing, recs: &Records, name: Handle, written: &str) -> Value {
let Some((kind, tags, _)) = recs.record(written) else { return Value::Nil };
let mut items = vec![Value::cons(Value::Int(-1), Value::Ename(name)), Value::cons(Value::Int(0), Value::str(kind))];
for v in groups_to_list(tags) {
let code = v.car().as_number().map(|c| c as i32);
let text = match v.cdr() {
Value::Str(s) => Some(s.to_string()),
_ => None,
};
match (code, text) {
(Some(c @ (5 | 105)), Some(_)) => items.push(Value::cons(Value::Int(c), Value::str(&name.hex()))),
(Some(c), Some(t)) if pointer_group(c) => {
let Some(h) = norm(&t).filter(|h| h != "0") else { continue };
let target = Handle::parse_hex(&h).filter(|e| d.entity(*e).is_some());
let target = target.or_else(|| recs.key(&h).and_then(|k| name_of(names, d, &k)));
items.push(match target {
Some(e) => Value::cons(Value::Int(c), Value::Ename(e)),
None => v,
});
}
_ => items.push(v),
}
}
Value::list(items)
}
/// The written handle of the non-graphic object named `h`, if it still exists.
fn written_of(names: &Names, d: &Drawing, recs: &Records, h: Handle) -> Option<String> {
let key = key_of(names, d, h)?;
recs.written(&key).map(str::to_string)
}
/// `entget` of a non-graphic object: nil when `h` names none.
pub fn entget(ctx: &mut Ctx<'_>, h: Handle) -> Value {
let Ok(st) = ctx.s.state() else { return Value::Nil };
let names = &mut ctx.env.objects;
let Some(recs) = records(names, &st.doc) else { return Value::Nil };
let Some(w) = written_of(names, &st.doc, &recs, h) else { return Value::Nil };
object_list(names, &st.doc, &recs, h, &w)
}
/// `handent` of a non-graphic object: whether `h` names one that exists.
pub fn exists(ctx: &mut Ctx<'_>, h: Handle) -> bool {
let Ok(st) = ctx.s.state() else { return false };
let names = &mut ctx.env.objects;
let Some(recs) = records(names, &st.doc) else { return false };
written_of(names, &st.doc, &recs, h).is_some()
}
/// `(namedobjdict)`: the named object dictionary's entity name.
pub fn namedobjdict(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 0, 0)?;
let Ok(st) = ctx.s.state() else { return Ok(Flow::Value(Value::Nil)) };
let names = &mut ctx.env.objects;
let key: ForeignKey = ("NOD".into(), String::new());
let found = records(names, &st.doc).filter(|r| r.written(&key).is_some()).and_then(|_| name_of(names, &st.doc, &key));
Ok(Flow::Value(found.map(Value::Ename).unwrap_or_default()))
}
/// `(tblobjname table name)`: the entity name of a symbol table record (of the BLOCK entity for
/// the BLOCK table), nil when there is none.
pub fn tblobjname(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 2, 2)?;
let table = string(&a[0])?.trim().to_ascii_uppercase();
// As the roles spell names (upper case in ASCII only).
let name = string(&a[1])?.trim().to_ascii_uppercase();
let Ok(st) = ctx.s.state() else { return Ok(Flow::Value(Value::Nil)) };
let names = &mut ctx.env.objects;
let key: ForeignKey = (table, name);
let found = records(names, &st.doc).filter(|r| r.written(&key).is_some()).and_then(|_| name_of(names, &st.doc, &key));
Ok(Flow::Value(found.map(Value::Ename).unwrap_or_default()))
}
/// A dictionary's entries: (key, written handle of the entry), in order.
fn entries(kind: &str, tags: &[Tag]) -> Vec<(String, String)> {
if !matches!(kind, "DICTIONARY" | "ACDBDICTIONARYWDFLT") {
return Vec::new();
}
let mut out = Vec::new();
let mut key: Option<String> = None;
for t in tags {
match t.code {
3 => key = Some(t.str()),
350 | 360 => {
if let (Some(k), Some(h)) = (key.take(), norm(&t.str())) {
out.push((k, h));
}
}
_ => {}
}
}
out
}
/// The entity list of entry `i` of the dictionary named `dict`, and the number of entries.
fn entry(ctx: &mut Ctx<'_>, dict: Handle, pick: impl Fn(&[(String, String)]) -> Option<usize>) -> (Value, Option<usize>) {
let Ok(st) = ctx.s.state() else { return (Value::Nil, None) };
let names = &mut ctx.env.objects;
let Some(recs) = records(names, &st.doc) else { return (Value::Nil, None) };
let Some(w) = written_of(names, &st.doc, &recs, dict) else { return (Value::Nil, None) };
let Some((kind, tags, _)) = recs.record(&w) else { return (Value::Nil, None) };
let list = entries(kind, tags);
let Some(i) = pick(&list) else { return (Value::Nil, None) };
let Some((_, eh)) = list.get(i) else { return (Value::Nil, None) };
let Some(name) = recs.key(eh).and_then(|k| name_of(names, &st.doc, &k)) else { return (Value::Nil, Some(i)) };
(object_list(names, &st.doc, &recs, name, eh), Some(i))
}
/// `(dictsearch dict key [setnext])`: the entity list of the entry `key` (any case) of a
/// dictionary, nil when it has none; with `setnext`, `dictnext` goes on after it.
pub fn dictsearch(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 2, 3)?;
let dict = ename(&a[0])?;
let key = string(&a[1])?;
let (v, i) = entry(ctx, dict, |list| list.iter().position(|(k, _)| k.eq_ignore_ascii_case(&key)));
if let Some(i) = i
&& a.get(2).is_some_and(|v| !v.is_nil())
{
ctx.env.objects.dictnext.insert(dict, i.saturating_add(1));
}
Ok(Flow::Value(v))
}
/// `(dictnext dict [rewind])`: the entity list of a dictionary's next entry (its first with
/// `rewind`, or on the first call), nil after the last.
pub fn dictnext(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 1, 2)?;
let dict = ename(&a[0])?;
let rewind = a.get(1).is_some_and(|v| !v.is_nil());
let at = if rewind { 0 } else { ctx.env.objects.dictnext.get(&dict).copied().unwrap_or(0) };
let (v, _) = entry(ctx, dict, |list| (at < list.len()).then_some(at));
ctx.env.objects.dictnext.insert(dict, at.saturating_add(1));
Ok(Flow::Value(v))
}
+391 -1
View File
@@ -2,10 +2,12 @@
use super::value::{Value, to_text};
use crate::Session;
use crate::cmd::file::{EntityCodec, set_entity_codec};
use crate::cmd::file::{EntityCodec, set_entity_codec, set_object_records};
pub(super) fn session() -> Session {
set_entity_codec(EntityCodec { groups: cadcraft_io::entity_groups, entity: cadcraft_io::entity_from_groups });
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
set_object_records(cadcraft_io::object_records);
Session::new()
}
@@ -404,6 +406,147 @@ fn entity_lists_round_trip() {
assert_eq!(ok(&mut s, "(handent \"ZZZZZZ\")"), "nil");
}
/// entlast, entnext and (ssget "L") see what the routine itself just made, changed or deleted:
/// the order they share isn't kept past an edit, even one that leaves the drawing where it was.
#[test]
fn entlast_follows_edits_within_one_routine() {
let mut s = session();
assert_eq!(
ok(
&mut s,
"(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0))) (setq a (entlast))
(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 2.0 0.0 0.0))) (setq b (entlast))
(list (eq a b) (cdr (assoc 11 (entget b))) (eq (entnext a) b) (eq (ssname (ssget \"L\") 0) b))"
),
"(nil (2.0 0.0 0.0) T T)"
);
// Deleting the last makes the one before it last; entdel brings it back last again.
assert_eq!(ok(&mut s, "(entdel b) (setq c (entlast)) (entdel b) (list (eq c a) (eq (entlast) b))"), "(T T)");
// A command, an entmod and entlast, over and over in one routine: each entlast is the line
// just drawn.
assert_eq!(
ok(
&mut s,
"(setq seen nil i 0)
(repeat 40
(command \"_.LINE\" (list i 10) (list i 20) \"\")
(setq e (entlast) d (entget e))
(entmod (subst (cons 8 \"MOVED\") (assoc 8 d) d))
(if (and (not (member e seen)) (equal (cdr (assoc 10 (entget (entlast)))) (list (float i) 10.0 0.0) 1e-9))
(setq seen (cons e seen)))
(setq i (1+ i)))
(list (length seen) (cdr (assoc 8 (entget (entlast)))))"
),
"(40 \"MOVED\")"
);
// The same across routines, with an undo between them.
for i in 0..10 {
ok(&mut s, &format!("(entmake '((0 . \"CIRCLE\") (10 {i}.0 50.0 0.0) (40 . 1.0)))"));
assert_eq!(ok(&mut s, "(cadr (assoc 10 (entget (entlast))))"), format!("{i}.0"));
s.undo().unwrap();
ok(&mut s, &format!("(entmake '((0 . \"CIRCLE\") (10 {i}.0 60.0 0.0) (40 . 1.0)))"));
assert_eq!(ok(&mut s, "(caddr (assoc 10 (entget (entlast))))"), "60.0");
}
}
/// entmod of a block reference keeps its attributes and their values: they aren't in its list
/// (in AutoCAD they are entities of their own, which entmod of the INSERT leaves alone).
#[test]
fn entmod_of_a_block_reference_keeps_its_attributes() {
let mut s = session();
ok(
&mut s,
"(entmake '((0 . \"BLOCK\") (2 . \"TAGGED\") (70 . 0) (10 0.0 0.0 0.0)))
(entmake '((0 . \"CIRCLE\") (10 0.0 0.0 0.0) (40 . 1.0)))
(entmake '((0 . \"ATTDEF\") (10 0.0 2.0 0.0) (40 . 1.0) (1 . \"\") (3 . \"Name\") (2 . \"PSTN\") (70 . 0)))
(entmake '((0 . \"ENDBLK\")))",
);
s.execute("insert", &serde_json::json!({"name": "TAGGED", "at": [10, 10], "attribs": {"PSTN": "ARK1"}})).unwrap();
let insert = |s: &Session| {
s.doc()
.unwrap()
.model
.iter()
.find_map(|e| match &e.kind {
cadcraft_doc::EntityKind::Insert(i) => {
Some((e.common.layer.clone(), i.attribs.iter().map(|a| (a.tag.clone(), a.text.value.clone())).collect::<Vec<_>>()))
}
_ => None,
})
.unwrap()
};
let want = vec![("PSTN".to_string(), "ARK1".to_string())];
assert_eq!(insert(&s).1, want);
ok(&mut s, "(setq d (entget (entlast))) (entmod (subst (cons 8 \"UGO\") (assoc 8 d) d))");
assert_eq!(insert(&s), ("UGO".to_string(), want.clone()));
// A new rotation keeps them too.
ok(&mut s, "(setq d (entget (entlast))) (entmod (subst (cons 50 (/ pi 2)) (assoc 50 d) d))");
let rotation = s
.doc()
.unwrap()
.model
.iter()
.find_map(|e| match &e.kind {
cadcraft_doc::EntityKind::Insert(i) => Some(i.rotation),
_ => None,
})
.unwrap();
assert!((rotation - std::f64::consts::FRAC_PI_2).abs() < 1e-9, "the entmod took: {rotation}");
assert_eq!(insert(&s).1, want);
}
/// An edit that leaves every handle where it was (a layer change) keeps entlast's cached order;
/// one that adds an entity rebuilds it.
#[test]
fn entlast_keeps_its_order_across_property_edits() {
let mut s = session();
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0))) (entlast)");
let uid = s.state().unwrap().uid;
// The cached order itself is held, so a rebuilt one can't take its address.
let order = |s: &Session| s.lisp.envs[&uid].order.as_ref().unwrap().1.clone();
let before = order(&s);
assert_eq!(
ok(&mut s, "(setq d (entget (entlast))) (entmod (subst (cons 8 \"MOVED\") (assoc 8 d) d)) (cdr (assoc 8 (entget (entlast))))"),
"\"MOVED\""
);
assert!(std::sync::Arc::ptr_eq(&order(&s), &before), "a layer change keeps the order");
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 2.0 0.0 0.0))) (entlast)");
assert!(!std::sync::Arc::ptr_eq(&order(&s), &before), "a new entity rebuilds it");
}
/// Closing a drawing drops its LISP environment, and with it the entity stores its cached
/// order holds.
#[test]
fn closing_a_drawing_drops_its_environment() {
let mut s = session();
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0))) (entlast)");
let uid = s.state().unwrap().uid;
assert!(s.lisp.envs.get(&uid).is_some_and(|e| e.order.is_some()));
s.execute("close", &serde_json::json!({})).unwrap();
assert!(!s.lisp.envs.contains_key(&uid));
}
/// HANDSEED is the next handle the drawing gives out, in hex, and moves as objects are made.
#[test]
fn handseed_follows_new_objects() {
let mut s = session();
let seed = |s: &Session| format!("\"{:X}\"", s.doc().unwrap().next_handle().0);
let before = ok(&mut s, "(getvar \"HANDSEED\")");
assert_eq!(before, seed(&s));
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0)))");
let after = ok(&mut s, "(getvar \"HANDSEED\")");
assert_eq!(after, seed(&s));
assert_ne!(after, before);
assert!(eval(&mut s, "(setvar \"HANDSEED\" \"FFFFFF\")").is_err(), "read-only");
// A handle the file's own objects hold is skipped, as allocation skips it.
let d = s.doc_mut().unwrap();
let held = d.handseed;
std::sync::Arc::make_mut(&mut d.foreign).handles.insert(cadcraft_doc::Handle(held), ("NOD".into(), String::new()));
assert_eq!(ok(&mut s, "(getvar \"HANDSEED\")"), format!("\"{:X}\"", held + 1));
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 1.0 0.0 0.0)))");
assert_eq!(ok(&mut s, "(cdr (assoc 5 (entget (entlast))))"), format!("\"{:X}\"", held + 1));
}
#[test]
fn entity_lists_hold_angles_in_radians() {
let mut s = session();
@@ -1048,6 +1191,253 @@ fn a_panic_inside_a_routine_ends_it_with_an_error() {
assert_eq!(ok(&mut s, "(+ 1 2)"), "3");
}
/// The handle (group 5, a DIMSTYLE's 105) of the `kind` record named `name` (group 2, or 1 for a
/// LAYOUT; any for "") in DXF text.
fn dxf_handle(dxf: &str, kind: &str, name: &str) -> String {
let lines: Vec<&str> = dxf.lines().map(str::trim).collect();
let pairs: Vec<(&str, &str)> = lines.chunks(2).filter_map(|c| Some((*c.first()?, *c.get(1)?))).collect();
let mut i = 0;
while i < pairs.len() {
if pairs[i] == ("0", kind) {
let rec: Vec<(&str, &str)> = pairs[i + 1..].iter().take_while(|p| p.0 != "0").copied().collect();
let named = name.is_empty() || rec.iter().any(|p| (p.0 == "2" || (kind == "LAYOUT" && p.0 == "1")) && p.1 == name);
if named {
return rec.iter().find(|p| p.0 == "5" || p.0 == "105").unwrap().1.to_string();
}
}
i += 1;
}
panic!("no {kind} {name}")
}
#[test]
fn namedobjdict_and_dictsearch_reach_the_layouts() {
let mut s = session();
assert!(ok(&mut s, "(namedobjdict)").starts_with("<Entity name: "));
assert_eq!(ok(&mut s, "(eq (namedobjdict) (namedobjdict))"), "T");
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (namedobjdict))))"), "\"DICTIONARY\"");
// Keys in any case; the entry's own list, owned by the dictionary it is in.
ok(&mut s, "(setq layouts (dictsearch (namedobjdict) \"acad_layout\"))");
assert_eq!(ok(&mut s, "(cdr (assoc 0 layouts))"), "\"DICTIONARY\"");
assert_eq!(ok(&mut s, "(eq (cdr (assoc 330 layouts)) (namedobjdict))"), "T");
ok(&mut s, "(setq l1 (dictsearch (cdr (assoc -1 layouts)) \"Layout1\"))");
assert_eq!(ok(&mut s, "(list (cdr (assoc 0 l1)) (cdr (assoc 1 (member '(100 . \"AcDbLayout\") l1))))"), "(\"LAYOUT\" \"Layout1\")");
// The plot settings are there to read; the layout's block record is an entity name.
assert_eq!(ok(&mut s, "(cdr (assoc 2 l1))"), "\"none_device\"");
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (cdr (assoc 330 (reverse l1))))))"), "\"BLOCK_RECORD\"");
// The name in group 5 leads back to the object.
assert_eq!(ok(&mut s, "(eq (handent (cdr (assoc 5 l1))) (cdr (assoc -1 l1)))"), "T");
assert_eq!(ok(&mut s, "(dictsearch (namedobjdict) \"NO_SUCH_KEY\")"), "nil");
// A layer is not a dictionary: nothing to search.
assert_eq!(ok(&mut s, "(dictsearch (tblobjname \"LAYER\" \"0\") \"ACAD_LAYOUT\")"), "nil");
assert!(eval(&mut s, "(dictsearch \"ACAD_LAYOUT\" \"x\")").unwrap_err().contains("lentityp"));
assert!(eval(&mut s, "(namedobjdict 1)").is_err());
}
#[test]
fn dictnext_walks_a_dictionary() {
let mut s = session();
ok(&mut s, "(setq d (cdr (assoc -1 (dictsearch (namedobjdict) \"ACAD_LAYOUT\"))))");
let names = "(progn (setq out nil e (dictnext d T)) (while e (setq out (cons (cdr (assoc 1 (member '(100 . \"AcDbLayout\") e))) out) e (dictnext d))) (reverse out))";
assert_eq!(ok(&mut s, names), "(\"Model\" \"Layout1\" \"Layout2\")");
// Past the end it stays nil until rewound.
assert_eq!(ok(&mut s, "(dictnext d)"), "nil");
assert_eq!(ok(&mut s, "(cdr (assoc 0 (dictnext d T)))"), "\"LAYOUT\"");
// dictsearch with setnext: dictnext goes on after the entry found.
ok(&mut s, "(dictsearch d \"Model\" T)");
assert_eq!(ok(&mut s, "(cdr (assoc 1 (member '(100 . \"AcDbLayout\") (dictnext d))))"), "\"Layout1\"");
}
#[test]
fn tblobjname_names_table_records() {
let mut s = session();
ok(&mut s, "(setq l (tblobjname \"layer\" \"0\"))");
assert_eq!(ok(&mut s, "(list (cdr (assoc 0 (entget l))) (cdr (assoc 2 (entget l))))"), "(\"LAYER\" \"0\")");
// Its owner is the LAYER table.
assert_eq!(ok(&mut s, "(cdr (assoc 2 (entget (cdr (assoc 330 (entget l))))))"), "\"LAYER\"");
// The BLOCK table gives the block's BLOCK entity.
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (tblobjname \"BLOCK\" \"*Model_Space\"))))"), "\"BLOCK\"");
assert_eq!(ok(&mut s, "(tblobjname \"LAYER\" \"NO_SUCH_LAYER\")"), "nil");
// Names outside ASCII: found in the case they have, ASCII letters in any case.
s.execute("layer.new", &serde_json::json!({"name": "ébauche"})).unwrap();
assert_eq!(ok(&mut s, "(cdr (assoc 2 (entget (tblobjname \"LAYER\" \"éBAUCHE\"))))"), "\"ébauche\"");
assert_eq!(ok(&mut s, "(tblobjname \"NO_SUCH_TABLE\" \"0\")"), "nil");
// A DIMSTYLE has its handle in group 105.
ok(&mut s, "(setq ds (tblobjname \"DIMSTYLE\" (cdr (assoc 2 (tblnext \"DIMSTYLE\" T)))))");
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget ds)))"), "\"DIMSTYLE\"");
assert_eq!(ok(&mut s, "(eq ds (handent (cdr (assoc 105 (entget ds)))))"), "T");
assert!(eval(&mut s, "(tblobjname \"LAYER\")").is_err());
// The name holds while the drawing changes.
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 10.0 0.0 0.0)))");
assert_eq!(ok(&mut s, "(eq l (tblobjname \"LAYER\" \"0\"))"), "T");
assert_eq!(ok(&mut s, "(eq l (handent (cdr (assoc 5 (entget l)))))"), "T");
}
/// #1661: the handles of a layer and a layout in a file lead to them once the file is open.
#[test]
fn handent_names_a_files_layer_and_layout() {
let mut s = session();
ok(&mut s, "(entmake '((0 . \"LINE\") (10 0.0 0.0 0.0) (11 10.0 0.0 0.0)))");
let bytes = cadcraft_io::write(s.doc().unwrap(), "h.dxf").unwrap();
let dxf = String::from_utf8(bytes.clone()).unwrap();
let (layer, layout) = (dxf_handle(&dxf, "LAYER", "0"), dxf_handle(&dxf, "LAYOUT", "Layout1"));
let line = dxf_handle(&dxf, "LINE", "");
let dimstyle = dxf_handle(&dxf, "DIMSTYLE", "Standard");
let mut s = session();
s.open_drawing(cadcraft_io::read(&bytes, "h.dxf").unwrap(), "h.dxf", None);
assert_eq!(ok(&mut s, &format!("(cdr (assoc 0 (entget (handent \"{line}\"))))")), "\"LINE\"");
assert_eq!(ok(&mut s, &format!("(cdr (assoc 2 (entget (handent \"{layer}\"))))")), "\"0\"");
assert_eq!(ok(&mut s, &format!("(eq (handent \"{layer}\") (tblobjname \"LAYER\" \"0\"))")), "T");
assert_eq!(ok(&mut s, &format!("(cdr (assoc 0 (entget (handent \"{layout}\"))))")), "\"LAYOUT\"");
assert_eq!(ok(&mut s, &format!("(cdr (assoc 5 (entget (handent \"{layout}\"))))")), format!("\"{layout}\""));
// A DIMSTYLE's handle is in group 105, in the file and in its list.
assert_eq!(ok(&mut s, &format!("(cdr (assoc 0 (entget (handent \"{dimstyle}\"))))")), "\"DIMSTYLE\"");
assert_eq!(ok(&mut s, &format!("(cdr (assoc 105 (entget (handent \"{dimstyle}\"))))")), format!("\"{dimstyle}\""));
assert_eq!(ok(&mut s, &format!("(eq (handent \"{dimstyle}\") (tblobjname \"DIMSTYLE\" \"Standard\"))")), "T");
assert_eq!(ok(&mut s, "(handent \"FFFFF\")"), "nil");
assert_eq!(ok(&mut s, "(handent \"not hex\")"), "nil");
}
/// A drawing with a dictionary two levels below the named object dictionary (kept from its file):
/// NOD › MY_DICT › INNER › LEAF (an XRECORD).
fn nested_dictionary_file() -> Vec<u8> {
let s = session();
let bytes = cadcraft_io::write(s.doc().unwrap(), "n.dxf").unwrap();
let text = String::from_utf8(bytes).unwrap();
let lines: Vec<&str> = text.lines().collect();
let mut pairs: Vec<(String, String)> = lines.chunks(2).map(|c| (c[0].trim().to_string(), c[1].to_string())).collect();
let objects = pairs.iter().position(|p| p.0 == "2" && p.1 == "OBJECTS").unwrap();
let nod = objects + pairs[objects..].iter().position(|p| p.0 == "0" && p.1 == "DICTIONARY").unwrap();
let nod_handle = pairs[nod + 1].1.clone();
let after = nod + pairs[nod..].iter().position(|p| p.0 == "281").unwrap() + 1;
pairs.splice(after..after, [("3".into(), "MY_DICT".into()), ("350".into(), "AAA1".into())]);
let end = objects + pairs[objects..].iter().position(|p| p.0 == "0" && p.1 == "ENDSEC").unwrap();
let p = |c: &str, v: &str| (c.to_string(), v.to_string());
let added = vec![
p("0", "DICTIONARY"),
p("5", "AAA1"),
p("330", &nod_handle),
p("100", "AcDbDictionary"),
p("281", "1"),
p("3", "INNER"),
p("350", "AAA2"),
p("0", "DICTIONARY"),
p("5", "AAA2"),
p("330", "AAA1"),
p("100", "AcDbDictionary"),
p("281", "1"),
p("3", "LEAF"),
p("350", "AAA3"),
p("0", "XRECORD"),
p("5", "AAA3"),
p("330", "AAA2"),
p("100", "AcDbXrecord"),
p("280", "1"),
p("1", "hello"),
];
pairs.splice(end..end, added);
pairs.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect::<String>().into_bytes()
}
/// An object found below a dictionary entry has no role: once the drawing changes, its old name
/// finds nothing rather than whatever now has its written handle.
#[test]
fn a_deeper_objects_name_lapses_when_the_drawing_changes() {
let mut s = session();
s.open_drawing(cadcraft_io::read(&nested_dictionary_file(), "n.dxf").unwrap(), "n.dxf", None);
ok(&mut s, "(setq inner (cdr (assoc -1 (dictsearch (cdr (assoc -1 (dictsearch (namedobjdict) \"MY_DICT\"))) \"INNER\"))))");
ok(&mut s, "(setq leaf (cdr (assoc -1 (dictsearch inner \"LEAF\"))))");
assert_eq!(ok(&mut s, "(cdr (assoc 1 (entget leaf)))"), "\"hello\"");
// Unchanged drawing: the same name.
assert_eq!(ok(&mut s, "(eq leaf (cdr (assoc -1 (dictsearch inner \"LEAF\"))))"), "T");
s.execute("layer.new", &serde_json::json!({"name": "Walls"})).unwrap();
assert_eq!(ok(&mut s, "(entget leaf)"), "nil");
// Looked up again, it is there (under a new name); the entry with a role kept its name.
assert_eq!(ok(&mut s, "(cdr (assoc 1 (dictsearch inner \"LEAF\")))"), "\"hello\"");
}
// ---------------- entities of block definitions (#1700) ----------------
/// A drawing with one linear dimension measuring 100 whose `*D1` block, as stored in the file,
/// says 99.5 (a stale block: the defpoints moved, the block wasn't rebuilt).
fn stale_dimension() -> Session {
let mut s = session();
s.execute("dimlinear", &serde_json::json!({"p1": [0, 0], "p2": [100, 0], "at": [50, -20], "rotation": 0})).unwrap();
let dxf = cadcraft_io::write_dxf(s.doc().unwrap());
// The *D1 block's MTEXT says 100 (100.0000 here); make the file say 99.5.
let lines: Vec<&str> = dxf.lines().collect();
let (mut kind, mut block, mut out, mut changed) = (String::new(), String::new(), Vec::new(), 0);
for (i, l) in lines.iter().enumerate() {
let code = if i % 2 == 0 { l.trim() } else { "" };
let value = lines.get(i + 1).map(|v| v.trim()).unwrap_or("");
if code == "0" {
kind = value.to_string();
}
if code == "2" && kind == "BLOCK" {
block = value.to_string();
}
if i % 2 == 1 && kind == "MTEXT" && block == "*D1" && lines.get(i - 1).map(|c| c.trim()) == Some("1") && l.trim().starts_with("100") {
out.push("99.5".to_string());
changed += 1;
continue;
}
out.push(l.to_string());
}
assert_eq!(changed, 1, "the fixture found the *D1 text");
let mut s = session();
s.open_drawing(cadcraft_io::read_dxf(out.join("\n").as_bytes()).unwrap(), "stale", None);
s
}
/// The issue's use: a routine reads the text a dimension's block stores and compares it with the
/// measurement, so it finds the stale block.
#[test]
fn a_routine_reads_the_text_a_dimension_block_stores() {
let mut s = stale_dimension();
let code = r#"(progn
(defun dtext (dim / e txt)
(setq e (cdr (assoc -2 (tblsearch "BLOCK" (cdr (assoc 2 (entget dim)))))))
(while e
(if (= (cdr (assoc 0 (entget e))) "MTEXT") (setq txt (cdr (assoc 1 (entget e)))))
(setq e (entnext e)))
txt)
(setq dim (entlast))
(list (dtext dim) (cdr (assoc 42 (entget dim)))))"#;
assert_eq!(ok(&mut s, code), "(\"99.5\" 100.0)");
}
/// tblsearch names a block's first entity (-2); entnext walks the definition in order and ends
/// with nil; entget lists each one (without a layout); handent finds them by handle.
#[test]
fn entnext_and_entget_walk_a_block_definition() {
let mut s = session();
let l = s.execute("line", &serde_json::json!({"points": [[0, 0], [10, 0]]})).unwrap()["handles"][0].as_str().unwrap().to_string();
let c = s.execute("circle", &serde_json::json!({"center": [5, 5], "radius": 2})).unwrap()["handle"].as_str().unwrap().to_string();
s.execute("block", &serde_json::json!({"name": "B", "base": [0, 0], "handles": [l, c], "keep": "delete"})).unwrap();
s.execute("line", &serde_json::json!({"points": [[50, 0], [60, 0]]})).unwrap();
let walk = r#"(progn (setq e (cdr (assoc -2 (tblsearch "BLOCK" "B"))) types nil)
(while e (setq types (cons (cdr (assoc 0 (entget e))) types) e (entnext e)))
(reverse types))"#;
assert_eq!(ok(&mut s, walk), "(\"LINE\" \"CIRCLE\")", "the block's own entities, not the drawing's");
let first = "(cdr (assoc -2 (tblsearch \"BLOCK\" \"B\")))";
assert_eq!(ok(&mut s, &format!("(assoc 410 (entget {first}))")), "nil", "no layout");
assert_eq!(ok(&mut s, &format!("(equal (handent (cdr (assoc 5 (entget {first})))) {first})")), "T");
// The drawing's own entities walk as before.
assert_eq!(ok(&mut s, "(cdr (assoc 0 (entget (entnext))))"), "\"LINE\"");
assert_eq!(ok(&mut s, "(entnext (entlast))"), "nil");
// Editing a block's entity through entmod or entdel isn't offered: nil, nothing changes.
assert_eq!(ok(&mut s, &format!("(entdel {first})")), "nil");
assert_eq!(ok(&mut s, &format!("(entmod (entget {first}))")), "nil");
assert_eq!(s.doc().unwrap().block("B").unwrap().entities.len(), 2);
}
#[test]
fn an_empty_block_has_no_first_entity() {
let mut s = session();
s.doc_mut().unwrap().blocks.insert("EMPTY".into(), std::sync::Arc::new(cadcraft_doc::Block::new("EMPTY")));
assert_eq!(ok(&mut s, "(assoc -2 (tblsearch \"BLOCK\" \"EMPTY\"))"), "nil");
}
#[test]
fn angtof_reads_the_string_in_the_given_units() {
let mut s = Session::new();
+806
View File
@@ -0,0 +1,806 @@
//! What the Properties palette shows for a selection: groups of rows, each with the
//! `properties.set` key that changes it, the value the objects share (or *VARIES*), how the
//! value reads in the drawing's units, and whether it can be edited. `properties.describe`
//! returns the same description, so the palette, Quick Properties and agents read one list.
//!
//! Text, MText and Dimension have their own groups; other objects have the General group only
//! (the palette draws their rows itself). Dimension rows are the dimension style variables,
//! valued as the dimension draws them (its style with its overrides); setting one stores a
//! per-dimension override, as AutoCAD's Properties palette does (DIMOVERRIDE).
use std::collections::HashSet;
use cadcraft_doc::{DimKind, DimStyle, Dimension, Drawing, Entity, EntityKind, HAlign, Handle, Lineweight, MText, Text, Transparency, VAlign};
use serde::Serialize;
use serde_json::{Value, json};
use crate::units;
/// What a row shows when the described objects don't share a value.
pub const VARIES: &str = "*VARIES*";
/// MTEXT line pitch per unit of text height at line spacing factor 1 (the layout's 5/3 in
/// `cadcraft_fonts`): Line space distance = factor × text height × `LINE_PITCH`.
pub const LINE_PITCH: f64 = 5.0 / 3.0;
/// Above this many dimensions, their measurement and text position aren't worked out (each
/// needs the dimension's geometry); the rows show *VARIES*.
const GEOMETRY_CAP: usize = 256;
/// The Properties of a selection.
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct Description {
/// The object types selected and how many of each, in the order first selected.
pub types: Vec<TypeCount>,
/// The type the description is limited to; `None`: every selected object.
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<&'static str>,
/// How many objects the rows describe.
pub count: usize,
pub groups: Vec<Group>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct TypeCount {
#[serde(rename = "type")]
pub name: &'static str,
pub count: usize,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct Group {
pub name: &'static str,
pub rows: Vec<Row>,
}
/// One property of the described objects.
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Row {
/// The `properties.set` key that changes it.
pub key: &'static str,
pub label: &'static str,
pub kind: Kind,
/// The value every described object has; `null` when they differ.
pub value: Value,
pub varies: bool,
/// The value as shown: lengths in the drawing's units (LUNITS/LUPREC), angles in its angle
/// units (AUNITS/AUPREC), choices by their label; *VARIES* when the objects differ.
pub display: String,
pub editable: bool,
/// Why the row can't be edited, or what decides its value.
#[serde(skip_serializing_if = "Option::is_none")]
pub note: Option<String>,
/// Dimension rows: a described dimension overrides its style here.
#[serde(skip_serializing_if = "is_false")]
pub overridden: bool,
/// The values a choice or style row can take.
#[serde(skip_serializing_if = "Vec::is_empty")]
pub options: Vec<Choice>,
/// One of the rows Quick Properties shows.
#[serde(skip_serializing_if = "is_false")]
pub quick: bool,
}
fn is_false(b: &bool) -> bool {
!*b
}
impl Row {
fn quick(mut self) -> Self {
self.quick = true;
self
}
fn read_only(mut self) -> Self {
self.editable = false;
self
}
fn overridden_if(mut self, overridden: bool) -> Self {
self.overridden = overridden;
self
}
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct Choice {
pub value: Value,
pub label: String,
}
impl Choice {
fn new(value: Value, label: impl Into<String>) -> Self {
Choice { value, label: label.into() }
}
}
/// How a row's value is entered and shown.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum Kind {
/// One line of text.
Text,
/// MTEXT contents, inline formatting codes included.
Contents,
/// A plain number (factors, scales).
Number,
/// A length in drawing units.
Distance,
/// An angle in degrees.
Angle,
/// A direction (a text's rotation): `value` is in degrees counterclockwise from +X, as
/// `properties.set` takes it; `display` shows it as the drawing measures directions, from
/// ANGBASE in the ANGDIR sense (#1275).
Direction,
Bool,
/// One of `options`.
Choice,
Color,
Layer,
Linetype,
Lineweight,
Transparency,
TextStyle,
DimStyle,
}
/// A transparency as `properties.set` takes it: "ByLayer", "ByBlock" or a percentage.
pub fn transparency_value(t: Transparency) -> Value {
match t {
Transparency::Percent(p) => json!(p),
other => json!(other.name()),
}
}
/// The Properties of the objects `handles` (model space and layouts), limited to the objects
/// of type `filter` (a name from [`Description::types`]) when it names one. Handles that don't
/// name an object are left out.
pub fn describe(d: &Drawing, handles: &[Handle], filter: Option<&str>) -> Description {
let mut seen = HashSet::new();
let all: Vec<&Entity> = handles.iter().filter(|h| seen.insert(**h)).filter_map(|h| d.entity(*h).map(|e| &**e)).collect();
let mut types: Vec<TypeCount> = Vec::new();
for e in &all {
let name = e.kind.type_name();
match types.iter_mut().find(|t| t.name == name) {
Some(t) => t.count += 1,
None => types.push(TypeCount { name, count: 1 }),
}
}
let filter = filter.and_then(|f| types.iter().find(|t| t.name.eq_ignore_ascii_case(f.trim())).map(|t| t.name));
let ents: Vec<&Entity> = all.into_iter().filter(|e| filter.is_none_or(|f| e.kind.type_name() == f)).collect();
let c = Ctx::new(d);
let mut groups = Vec::new();
if !ents.is_empty() {
groups.push(general(&c, &ents));
let texts: Vec<&Text> = ents.iter().filter_map(|e| if let EntityKind::Text(t) = &e.kind { Some(t) } else { None }).collect();
let mtexts: Vec<&MText> = ents.iter().filter_map(|e| if let EntityKind::MText(t) = &e.kind { Some(t) } else { None }).collect();
let dims: Vec<&Dimension> = ents.iter().filter_map(|e| if let EntityKind::Dimension(t) = &e.kind { Some(t) } else { None }).collect();
// Type groups only when every described object is of that type (AutoCAD shows the
// common properties of a mixed selection).
if texts.len() == ents.len() {
groups.extend(text_groups(&c, &ents, &texts));
} else if mtexts.len() == ents.len() {
groups.extend(mtext_groups(&c, &ents, &mtexts));
} else if dims.len() == ents.len() {
groups.extend(dimension_groups(&c, &ents, &dims));
}
}
Description { types, filter, count: ents.len(), groups }
}
/// Unit settings and the drawing, for formatting rows.
struct Ctx<'a> {
d: &'a Drawing,
lunits: i64,
luprec: i64,
aunits: i64,
auprec: i64,
angles: units::AngleSettings,
}
impl<'a> Ctx<'a> {
fn new(d: &'a Drawing) -> Self {
let h = &d.header;
Ctx {
d,
lunits: h.i64("LUNITS", 2),
luprec: h.i64("LUPREC", 4),
aunits: h.i64("AUNITS", 0),
auprec: h.i64("AUPREC", 0),
angles: units::AngleSettings::from_header(h),
}
}
fn distance(&self, v: f64) -> String {
units::format_distance(v, self.lunits, self.luprec)
}
/// `deg` in the drawing's angle units.
fn angle(&self, deg: f64) -> String {
units::format_angle(deg.to_radians(), self.aunits, self.auprec)
}
fn show(&self, kind: Kind, v: &Value, options: &[Choice]) -> String {
match kind {
Kind::Distance => v.as_f64().map(|x| self.distance(x)).unwrap_or_default(),
Kind::Number => v.as_f64().map(|x| format!("{x:.4}")).unwrap_or_default(),
Kind::Angle => v.as_f64().map(|x| self.angle(x)).unwrap_or_default(),
Kind::Direction => v.as_f64().map(|x| self.angle(self.angles.shown(x.to_radians()).to_degrees())).unwrap_or_default(),
Kind::Bool => (if v.as_bool() == Some(true) { "Yes" } else { "No" }).to_string(),
Kind::Choice => options.iter().find(|o| o.value == *v).map(|o| o.label.clone()).unwrap_or_else(|| plain(v)),
_ => plain(v),
}
}
/// A row valued by `values` (one per described object).
fn row(&self, key: &'static str, label: &'static str, kind: Kind, values: impl IntoIterator<Item = Value>) -> Row {
self.choice(key, label, kind, Vec::new(), values)
}
/// A row with options (a choice, or a style picked from the drawing's styles).
fn choice(&self, key: &'static str, label: &'static str, kind: Kind, options: Vec<Choice>, values: impl IntoIterator<Item = Value>) -> Row {
let mut it = values.into_iter();
let first = it.next().unwrap_or(Value::Null);
let varies = it.any(|v| !same(&v, &first));
let (value, display) = if varies { (Value::Null, VARIES.to_string()) } else { (first.clone(), self.show(kind, &first, &options)) };
Row { key, label, kind, value, varies, display, editable: true, note: None, overridden: false, options, quick: false }
}
fn text_styles(&self) -> Vec<Choice> {
self.d.text_styles.iter().map(|t| Choice::new(json!(t.name), t.name.clone())).collect()
}
fn dim_styles(&self) -> Vec<Choice> {
self.d.dim_styles.iter().map(|t| Choice::new(json!(t.name), t.name.clone())).collect()
}
}
/// A value as plain text: strings as they are, numbers and booleans as JSON writes them.
fn plain(v: &Value) -> String {
match v {
Value::String(s) => s.clone(),
Value::Null => String::new(),
other => other.to_string(),
}
}
fn general(c: &Ctx, ents: &[&Entity]) -> Group {
let rows = vec![
c.row("color", "Color", Kind::Color, ents.iter().map(|e| json!(e.common.color.name()))),
c.row("layer", "Layer", Kind::Layer, ents.iter().map(|e| json!(e.common.layer))).quick(),
c.row("linetype", "Linetype", Kind::Linetype, ents.iter().map(|e| json!(e.common.linetype))),
c.row("ltscale", "Linetype scale", Kind::Number, ents.iter().map(|e| json!(e.common.ltscale))),
c.row("lineweight", "Lineweight", Kind::Lineweight, ents.iter().map(|e| json!(e.common.lineweight.name()))),
c.row("transparency", "Transparency", Kind::Transparency, ents.iter().map(|e| transparency_value(e.common.transparency))),
];
Group { name: "General", rows }
}
fn annotative(c: &Ctx, ents: &[&Entity]) -> Row {
c.row("annotative", "Annotative", Kind::Bool, ents.iter().map(|e| json!(cadcraft_doc::is_annotative(e)))).quick()
}
/// TEXT justifications as `properties.set` takes them, with their labels.
pub const TEXT_JUSTIFY: &[(&str, &str)] = &[
("Left", "Left"),
("Center", "Center"),
("Right", "Right"),
("Align", "Align"),
("Middle", "Middle"),
("Fit", "Fit"),
("TL", "Top left"),
("TC", "Top center"),
("TR", "Top right"),
("ML", "Middle left"),
("MC", "Middle center"),
("MR", "Middle right"),
("BL", "Bottom left"),
("BC", "Bottom center"),
("BR", "Bottom right"),
];
/// MTEXT attachments 1–9 as `properties.set` takes them, with their labels.
pub const MTEXT_JUSTIFY: &[(&str, &str)] = &[
("TL", "Top left"),
("TC", "Top center"),
("TR", "Top right"),
("ML", "Middle left"),
("MC", "Middle center"),
("MR", "Middle right"),
("BL", "Bottom left"),
("BC", "Bottom center"),
("BR", "Bottom right"),
];
fn options(list: &[(&str, &str)]) -> Vec<Choice> {
list.iter().map(|(v, l)| Choice::new(json!(v), *l)).collect()
}
/// The justification code of a TEXT (one of [`TEXT_JUSTIFY`]).
pub fn text_justify(t: &Text) -> &'static str {
match (t.halign, t.valign) {
(HAlign::Aligned, _) => "Align",
(HAlign::Fit, _) => "Fit",
(HAlign::Middle, _) => "Middle",
(HAlign::Left, VAlign::Baseline) => "Left",
(HAlign::Center, VAlign::Baseline) => "Center",
(HAlign::Right, VAlign::Baseline) => "Right",
(HAlign::Left, VAlign::Top) => "TL",
(HAlign::Center, VAlign::Top) => "TC",
(HAlign::Right, VAlign::Top) => "TR",
(HAlign::Left, VAlign::Middle) => "ML",
(HAlign::Center, VAlign::Middle) => "MC",
(HAlign::Right, VAlign::Middle) => "MR",
(HAlign::Left, VAlign::Bottom) => "BL",
(HAlign::Center, VAlign::Bottom) => "BC",
(HAlign::Right, VAlign::Bottom) => "BR",
}
}
/// The justification code of an MTEXT attachment (1–9; anything else reads as top left).
pub fn mtext_justify(attach: u8) -> &'static str {
MTEXT_JUSTIFY.get(usize::from(attach.max(1)) - 1).map_or("TL", |(code, _)| *code)
}
fn text_groups(c: &Ctx, ents: &[&Entity], texts: &[&Text]) -> Vec<Group> {
let mut text = vec![
c.row("text", "Contents", Kind::Text, texts.iter().map(|t| json!(t.value))).quick(),
c.choice("style", "Style", Kind::TextStyle, c.text_styles(), texts.iter().map(|t| json!(t.style))).quick(),
annotative(c, ents),
c.choice("justify", "Justification", Kind::Choice, options(TEXT_JUSTIFY), texts.iter().map(|t| json!(text_justify(t)))).quick(),
c.row("height", "Height", Kind::Distance, texts.iter().map(|t| json!(t.height))).quick(),
c.row("rotation", "Rotation", Kind::Direction, texts.iter().map(|t| json!(t.rotation.to_degrees()))).quick(),
c.row("widthFactor", "Width factor", Kind::Number, texts.iter().map(|t| json!(t.width_factor))),
c.row("oblique", "Obliquing", Kind::Angle, texts.iter().map(|t| json!(t.oblique.to_degrees()))),
];
// Aligned and fit text sit between two points: the second is the text alignment point.
let second: Option<Vec<cadcraft_geom::Vec3>> =
texts.iter().map(|t| if matches!(t.halign, HAlign::Aligned | HAlign::Fit) { t.align_pt } else { None }).collect();
if let Some(pts) = second {
text.push(c.row("alignmentX", "Text alignment X", Kind::Distance, pts.iter().map(|p| json!(p.x))));
text.push(c.row("alignmentY", "Text alignment Y", Kind::Distance, pts.iter().map(|p| json!(p.y))));
}
// The position is the point the text is placed by (see `Text::justify_point`).
let geometry = vec![
c.row("positionX", "Position X", Kind::Distance, texts.iter().map(|t| json!(t.justify_point().x))),
c.row("positionY", "Position Y", Kind::Distance, texts.iter().map(|t| json!(t.justify_point().y))),
c.row("positionZ", "Position Z", Kind::Distance, texts.iter().map(|t| json!(t.insert.z))),
];
vec![Group { name: "Text", rows: text }, Group { name: "Geometry", rows: geometry }]
}
fn mtext_groups(c: &Ctx, ents: &[&Entity], mts: &[&MText]) -> Vec<Group> {
let spacing = vec![Choice::new(json!("atLeast"), "At least"), Choice::new(json!("exactly"), "Exactly")];
let columns = |t: &MText| match &t.columns {
None => "None".to_string(),
Some(col) => match col.kind {
cadcraft_doc::MTextColumnType::Static => format!("Static ({})", col.count.max(1)),
cadcraft_doc::MTextColumnType::Dynamic => "Dynamic".to_string(),
},
};
let text = vec![
c.row("text", "Contents", Kind::Contents, mts.iter().map(|t| json!(t.contents))).quick(),
c.choice("style", "Style", Kind::TextStyle, c.text_styles(), mts.iter().map(|t| json!(t.style))).quick(),
annotative(c, ents),
c.choice("justify", "Justification", Kind::Choice, options(MTEXT_JUSTIFY), mts.iter().map(|t| json!(mtext_justify(t.attach)))).quick(),
c.row("height", "Text height", Kind::Distance, mts.iter().map(|t| json!(t.height))).quick(),
c.row("rotation", "Rotation", Kind::Direction, mts.iter().map(|t| json!(t.rotation.to_degrees()))).quick(),
c.row("lineSpacing", "Line space factor", Kind::Number, mts.iter().map(|t| json!(t.line_spacing))),
c.row("lineSpacingDistance", "Line space distance", Kind::Distance, mts.iter().map(|t| json!(t.line_spacing * t.height * LINE_PITCH))),
c.choice(
"lineSpacingStyle",
"Line space style",
Kind::Choice,
spacing,
mts.iter().map(|t| json!(if t.line_spacing_exact { "exactly" } else { "atLeast" })),
),
c.row("width", "Defined width", Kind::Distance, mts.iter().map(|t| json!(t.width))),
c.row("columns", "Columns", Kind::Text, mts.iter().map(|t| json!(columns(t)))).read_only(),
];
let geometry = vec![
c.row("positionX", "Position X", Kind::Distance, mts.iter().map(|t| json!(t.insert.x))),
c.row("positionY", "Position Y", Kind::Distance, mts.iter().map(|t| json!(t.insert.y))),
c.row("positionZ", "Position Z", Kind::Distance, mts.iter().map(|t| json!(t.insert.z))),
];
vec![Group { name: "Text", rows: text }, Group { name: "Geometry", rows: geometry }]
}
/// How a dimension style variable is entered.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DimPropKind {
Distance,
Number,
/// Degrees.
Angle,
Bool,
/// Numbers with labels.
Choice(&'static [(i64, &'static str)]),
/// Decimal places 0–8.
Precision,
Color,
TextStyle,
/// A linetype name; "" (and "ByBlock") is ByBlock.
Linetype,
/// Hundredths of a millimetre, or -1 ByLayer, -2 ByBlock, -3 Default.
Lineweight,
/// An arrowhead name ("" is closed filled).
Arrow,
/// The decimal separator.
Separator,
}
/// A dimension style variable as a Properties row.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct DimProp {
/// The [`DimStyle`] field (camelCase), which is also the `properties.set` key.
pub field: &'static str,
pub group: &'static str,
pub label: &'static str,
pub kind: DimPropKind,
/// Shown in the Properties palette (the rest belong to the style dialog only).
pub palette: bool,
}
const fn prop(field: &'static str, group: &'static str, label: &'static str, kind: DimPropKind) -> DimProp {
DimProp { field, group, label, kind, palette: true }
}
const fn style_only(field: &'static str, group: &'static str, label: &'static str, kind: DimPropKind) -> DimProp {
DimProp { field, group, label, kind, palette: false }
}
/// The groups dimension rows come in, in order (after Misc).
pub const DIM_GROUPS: &[&str] = &["Lines & Arrows", "Text", "Fit", "Primary Units", "Alternate Units", "Tolerances"];
const TEXT_POS_HOR: &[(i64, &str)] = &[(0, "Centered"), (1, "At Ext Line 1"), (2, "At Ext Line 2"), (3, "Over Ext Line 1"), (4, "Over Ext Line 2")];
const TEXT_POS_VERT: &[(i64, &str)] = &[(0, "Centered"), (1, "Above"), (2, "Outside"), (3, "JIS"), (4, "Below")];
const FIT: &[(i64, &str)] = &[(0, "Text and arrows"), (1, "Arrows"), (2, "Text"), (3, "Best fit")];
const TEXT_MOVE: &[(i64, &str)] = &[(0, "Keep dim line with text"), (1, "Move text, add leader"), (2, "Move text, no leader")];
const LINEAR_UNITS: &[(i64, &str)] =
&[(1, "Scientific"), (2, "Decimal"), (3, "Engineering"), (4, "Architectural"), (5, "Fractional"), (6, "Windows desktop")];
const ALT_UNITS: &[(i64, &str)] = &[
(1, "Scientific"),
(2, "Decimal"),
(3, "Engineering"),
(4, "Architectural stacked"),
(5, "Fractional stacked"),
(6, "Architectural"),
(7, "Fractional"),
(8, "Windows desktop"),
];
const ANGLE_FORMAT: &[(i64, &str)] = &[(0, "Decimal degrees"), (1, "Degrees Minutes Seconds"), (2, "Gradians"), (3, "Radians")];
const FRACTION_FORMAT: &[(i64, &str)] = &[(0, "Horizontal stacking"), (1, "Diagonal stacking"), (2, "Not stacked")];
const TOL_POS: &[(i64, &str)] = &[(0, "Bottom"), (1, "Middle"), (2, "Top")];
const ARC_SYMBOL: &[(i64, &str)] = &[(0, "Before text"), (1, "Above text"), (2, "None")];
/// Every modeled dimension style variable as a row, grouped as AutoCAD's Properties palette
/// groups dimension properties. The rows not shown in the palette are style settings only.
pub const DIM_PROPS: &[DimProp] = &[
// Lines & Arrows
prop("arrowBlock1", "Lines & Arrows", "Arrow 1", DimPropKind::Arrow),
prop("arrowBlock2", "Lines & Arrows", "Arrow 2", DimPropKind::Arrow),
style_only("arrowBlock", "Lines & Arrows", "Arrowheads", DimPropKind::Arrow),
prop("arrowSize", "Lines & Arrows", "Arrow size", DimPropKind::Distance),
prop("tickSize", "Lines & Arrows", "Tick size", DimPropKind::Distance),
prop("dimLineColor", "Lines & Arrows", "Dim line color", DimPropKind::Color),
prop("dimLinetype", "Lines & Arrows", "Dim line linetype", DimPropKind::Linetype),
prop("dimLineweight", "Lines & Arrows", "Dim line lineweight", DimPropKind::Lineweight),
prop("dimLineExtend", "Lines & Arrows", "Dim line ext", DimPropKind::Distance),
prop("suppressDim1", "Lines & Arrows", "Hide dim line 1", DimPropKind::Bool),
prop("suppressDim2", "Lines & Arrows", "Hide dim line 2", DimPropKind::Bool),
prop("extLineColor", "Lines & Arrows", "Ext line color", DimPropKind::Color),
prop("extLinetype1", "Lines & Arrows", "Ext line 1 linetype", DimPropKind::Linetype),
prop("extLinetype2", "Lines & Arrows", "Ext line 2 linetype", DimPropKind::Linetype),
prop("extLineweight", "Lines & Arrows", "Ext line lineweight", DimPropKind::Lineweight),
prop("extExtend", "Lines & Arrows", "Ext line ext", DimPropKind::Distance),
prop("extOffset", "Lines & Arrows", "Ext line offset", DimPropKind::Distance),
prop("fixedExt", "Lines & Arrows", "Ext line fixed", DimPropKind::Bool),
prop("fixedExtLength", "Lines & Arrows", "Ext line length", DimPropKind::Distance),
prop("suppressExt1", "Lines & Arrows", "Hide ext line 1", DimPropKind::Bool),
prop("suppressExt2", "Lines & Arrows", "Hide ext line 2", DimPropKind::Bool),
prop("centerMark", "Lines & Arrows", "Center mark size", DimPropKind::Distance),
prop("jogAngle", "Lines & Arrows", "Jog angle", DimPropKind::Angle),
prop("arcSymbol", "Lines & Arrows", "Arc length symbol", DimPropKind::Choice(ARC_SYMBOL)),
style_only("leaderArrowBlock", "Lines & Arrows", "Leader arrow", DimPropKind::Arrow),
style_only("baselineSpacing", "Lines & Arrows", "Baseline spacing", DimPropKind::Distance),
// Text
prop("textColor", "Text", "Text color", DimPropKind::Color),
prop("textHeight", "Text", "Text height", DimPropKind::Distance),
prop("textGap", "Text", "Text offset", DimPropKind::Distance),
prop("textOutsideHorizontal", "Text", "Text outside align", DimPropKind::Bool),
prop("textJust", "Text", "Text pos hor", DimPropKind::Choice(TEXT_POS_HOR)),
prop("textAbove", "Text", "Text pos vert", DimPropKind::Choice(TEXT_POS_VERT)),
prop("textStyle", "Text", "Text style", DimPropKind::TextStyle),
prop("textInsideHorizontal", "Text", "Text inside align", DimPropKind::Bool),
style_only("textVerticalPos", "Text", "Text vertical position", DimPropKind::Number),
// Fit
prop("forceLineInside", "Fit", "Dim line forced", DimPropKind::Bool),
prop("suppressOutsideArrows", "Fit", "Suppress arrows", DimPropKind::Bool),
prop("scale", "Fit", "Dim scale overall", DimPropKind::Number),
prop("fit", "Fit", "Fit", DimPropKind::Choice(FIT)),
prop("textInside", "Fit", "Text inside", DimPropKind::Bool),
prop("textMove", "Fit", "Text movement", DimPropKind::Choice(TEXT_MOVE)),
// Primary Units
prop("decimalSeparator", "Primary Units", "Decimal separator", DimPropKind::Separator),
prop("round", "Primary Units", "Dim roundoff", DimPropKind::Distance),
prop("linearFactor", "Primary Units", "Dim scale linear", DimPropKind::Number),
prop("linearUnit", "Primary Units", "Dim units", DimPropKind::Choice(LINEAR_UNITS)),
prop("decimals", "Primary Units", "Precision", DimPropKind::Precision),
prop("fractionFormat", "Primary Units", "Fraction format", DimPropKind::Choice(FRACTION_FORMAT)),
prop("angularUnit", "Primary Units", "Angle format", DimPropKind::Choice(ANGLE_FORMAT)),
prop("angularDecimals", "Primary Units", "Angle precision", DimPropKind::Precision),
style_only("post", "Primary Units", "Prefix and suffix", DimPropKind::Number),
style_only("zeroSuppression", "Primary Units", "Zero suppression", DimPropKind::Number),
style_only("angularZeroSuppression", "Primary Units", "Angular zero suppression", DimPropKind::Number),
// Alternate Units
prop("alt", "Alternate Units", "Alt enabled", DimPropKind::Bool),
prop("altUnit", "Alternate Units", "Alt format", DimPropKind::Choice(ALT_UNITS)),
prop("altDecimals", "Alternate Units", "Alt precision", DimPropKind::Precision),
prop("altFactor", "Alternate Units", "Alt scale factor", DimPropKind::Number),
prop("altRound", "Alternate Units", "Alt round", DimPropKind::Number),
style_only("altPost", "Alternate Units", "Alt prefix and suffix", DimPropKind::Number),
style_only("altZeroSuppression", "Alternate Units", "Alt zero suppression", DimPropKind::Number),
// Tolerances
prop("tolerance", "Tolerances", "Tolerances", DimPropKind::Bool),
prop("limits", "Tolerances", "Limits", DimPropKind::Bool),
prop("tolPlus", "Tolerances", "Upper tolerance", DimPropKind::Number),
prop("tolMinus", "Tolerances", "Lower tolerance", DimPropKind::Number),
prop("tolDecimals", "Tolerances", "Tolerance precision", DimPropKind::Precision),
prop("tolScale", "Tolerances", "Tolerance height", DimPropKind::Number),
prop("tolJust", "Tolerances", "Tolerance pos vert", DimPropKind::Choice(TOL_POS)),
style_only("tolZeroSuppression", "Tolerances", "Tolerance zero suppression", DimPropKind::Number),
];
/// The arrowheads drawn in code, by the DIMBLK name stored for them and their label.
pub const ARROWHEADS: &[(&str, &str)] = &[
("", "Closed filled"),
("_CLOSEDBLANK", "Closed blank"),
("_CLOSED", "Closed"),
("_DOT", "Dot"),
("_ARCHTICK", "Architectural tick"),
("_OBLIQUE", "Oblique"),
("_OPEN", "Open arrow"),
("_ORIGIN", "Origin indicator"),
("_ORIGIN2", "Origin indicator 2"),
("_OPEN90", "Right angle"),
("_OPEN30", "Open 30"),
("_DOTSMALL", "Dot small"),
("_DOTBLANK", "Dot blank"),
("_SMALL", "Small"),
("_BOXBLANK", "Box blank"),
("_BOXFILLED", "Box filled"),
("_DATUMBLANK", "Datum triangle"),
("_DATUMFILLED", "Datum triangle filled"),
("_INTEGRAL", "Integral"),
("_NONE", "None"),
];
/// The row for dimension style field `field`, if it has one.
pub fn dim_prop(field: &str) -> Option<&'static DimProp> {
DIM_PROPS.iter().find(|p| p.field.eq_ignore_ascii_case(field))
}
/// The dimension style fields whose value is a linetype name ("" is ByBlock).
pub fn is_dim_linetype(field: &str) -> bool {
matches!(field, "dimLinetype" | "extLinetype1" | "extLinetype2")
}
impl DimPropKind {
/// The values a choice kind can take, with their labels (none for the other kinds; text
/// styles are the drawing's).
pub fn options(self) -> Vec<Choice> {
match self {
DimPropKind::Choice(list) => list.iter().map(|(v, l)| Choice::new(json!(v), *l)).collect(),
DimPropKind::Precision => {
(0..=8u8).map(|n| Choice::new(json!(n), if n == 0 { "0".into() } else { format!("0.{}", "0".repeat(usize::from(n))) })).collect()
}
DimPropKind::Lineweight => {
let mut o = vec![Choice::new(json!(-2), "ByBlock"), Choice::new(json!(-1), "ByLayer"), Choice::new(json!(-3), "Default")];
o.extend(Lineweight::STANDARD.iter().map(|w| Choice::new(json!(w), Lineweight::Mm100(*w).name())));
o
}
DimPropKind::Arrow => ARROWHEADS.iter().map(|(v, l)| Choice::new(json!(v), *l)).collect(),
DimPropKind::Separator => [(".", "Period"), (",", "Comma"), (" ", "Space")].iter().map(|(v, l)| Choice::new(json!(v), *l)).collect(),
_ => Vec::new(),
}
}
fn row_kind(self, c: &Ctx) -> (Kind, Vec<Choice>) {
match self {
DimPropKind::Distance => (Kind::Distance, Vec::new()),
DimPropKind::Number => (Kind::Number, Vec::new()),
DimPropKind::Angle => (Kind::Angle, Vec::new()),
DimPropKind::Bool => (Kind::Bool, Vec::new()),
DimPropKind::Color => (Kind::Color, Vec::new()),
DimPropKind::TextStyle => (Kind::TextStyle, c.text_styles()),
DimPropKind::Linetype => (Kind::Linetype, Vec::new()),
DimPropKind::Choice(_) | DimPropKind::Precision | DimPropKind::Lineweight | DimPropKind::Arrow | DimPropKind::Separator => {
(Kind::Choice, self.options())
}
}
}
}
/// `name` normalized as the renderer reads arrowhead names ("_DOT", "dot" and "Dot" alike).
fn arrow_key(name: &str) -> String {
name.trim().trim_start_matches('_').chars().filter(char::is_ascii_alphanumeric).collect::<String>().to_ascii_lowercase()
}
/// A dimension style field's value as the row shows and `properties.set` takes it: a color's
/// name, ByBlock for an empty linetype, and the arrowhead an empty per-end arrowhead draws.
pub fn dim_value(p: &DimProp, st: &Value) -> Value {
let v = st.get(p.field).cloned().unwrap_or(Value::Null);
match p.kind {
DimPropKind::Color => serde_json::from_value::<cadcraft_color::Color>(v).map(|c| json!(c.name())).unwrap_or(Value::Null),
DimPropKind::Linetype => match v.as_str() {
Some("") | None => json!("ByBlock"),
Some(_) => v,
},
DimPropKind::Arrow => {
// Per-end arrowheads left empty use DIMBLK (an empty leader arrowhead is closed filled).
let name = v.as_str().filter(|s| !s.is_empty() || !matches!(p.field, "arrowBlock1" | "arrowBlock2")).map(str::to_string);
let name = name.unwrap_or_else(|| st.get("arrowBlock").and_then(Value::as_str).unwrap_or_default().to_string());
// A drawn arrowhead reads as its standard name; a block of the user's stays as it is.
match ARROWHEADS.iter().find(|(n, _)| arrow_key(n) == arrow_key(&name) || (n.is_empty() && arrow_key(&name) == "closedfilled")) {
Some((n, _)) => json!(n),
None => json!(name),
}
}
_ => v,
}
}
/// Whether dimension `dm` overrides style field `field`.
fn overrides(dm: &Dimension, field: &str) -> bool {
dm.overrides.keys().any(|k| DimStyle::field_name(k) == Some(field))
}
/// The prefix and suffix of a DIMPOST/DIMAPOST template: around `<>`, or the whole template
/// as a suffix when it has no `<>` (as the renderer reads it).
pub fn split_post(template: &str) -> (String, String) {
match template.split_once("<>") {
Some((pre, post)) => (pre.to_string(), post.to_string()),
None => (String::new(), template.to_string()),
}
}
/// A DIMPOST/DIMAPOST template from a prefix and a suffix.
pub fn join_post(prefix: &str, suffix: &str) -> String {
if prefix.is_empty() { suffix.to_string() } else { format!("{prefix}<>{suffix}") }
}
/// The measurement as the dimension writes it (its own units and precision).
fn measurement_text(dm: &Dimension, st: &DimStyle, meas: f64) -> String {
match dm.kind {
// As the renderer writes angles: DIMAUNIT, DIMADEC, and DIMAZIN's leading and trailing zeros.
DimKind::Angular | DimKind::Angular3P => {
cadcraft_render::units::format_angle(meas, st.angular_unit, st.angular_decimals, (st.angular_zero_suppression & 3) * 4)
}
_ => cadcraft_render::format_linear_value(meas, st),
}
}
fn dimension_groups(c: &Ctx, ents: &[&Entity], dims: &[&Dimension]) -> Vec<Group> {
let styles: Vec<DimStyle> = dims.iter().map(|dm| c.d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides)).collect();
let values: Vec<Value> = styles.iter().map(|st| serde_json::to_value(st).unwrap_or(Value::Null)).collect();
// Measurement and text position need each dimension's geometry.
let geometry: Option<Vec<cadcraft_render::DimGeometry>> =
(dims.len() <= GEOMETRY_CAP).then(|| dims.iter().map(|dm| cadcraft_render::dimension_in(c.d, dm)).collect());
let mut groups = vec![Group {
name: "Misc",
rows: vec![
c.choice("dimStyle", "Dim style", Kind::DimStyle, c.dim_styles(), dims.iter().map(|dm| json!(dm.style))).quick(),
annotative(c, ents),
],
}];
for &name in DIM_GROUPS {
let mut rows: Vec<Row> = Vec::new();
for p in DIM_PROPS.iter().filter(|p| p.group == name && p.palette) {
let (kind, options) = p.kind.row_kind(c);
let mut r = c.choice(p.field, p.label, kind, options, values.iter().map(|v| dim_value(p, v)));
r.overridden = dims.iter().any(|dm| overrides(dm, p.field));
if p.field == "textHeight" {
fixed_height(c, &mut r, &styles);
}
rows.push(r);
}
match name {
"Text" => {
let (xs, ys): (Vec<Value>, Vec<Value>) = match &geometry {
Some(g) => g.iter().map(|g| (json!(g.text_pos.x), json!(g.text_pos.y))).unzip(),
None => (vec![Value::Null, json!(VARIES)], vec![Value::Null, json!(VARIES)]),
};
rows.push(c.row("textPositionX", "Text position X", Kind::Distance, xs));
rows.push(c.row("textPositionY", "Text position Y", Kind::Distance, ys));
rows.push(c.row("textRotation", "Text rotation", Kind::Angle, dims.iter().map(|dm| json!(dm.text_rotation.to_degrees()))));
let measured: Vec<(Value, String)> = match &geometry {
Some(g) => g
.iter()
.zip(dims)
.zip(&styles)
.map(|((g, dm), st)| {
let angular = matches!(dm.kind, DimKind::Angular | DimKind::Angular3P);
(json!(if angular { g.measurement.to_degrees() } else { g.measurement }), measurement_text(dm, st, g.measurement))
})
.collect(),
None => vec![(Value::Null, String::new()), (json!(VARIES), String::new())],
};
// A length, or an angle in degrees, shown as the dimension writes it.
let mut m = c.row("measurement", "Measurement", Kind::Number, measured.iter().map(|(v, _)| v.clone())).read_only().quick();
let shown = measured.first().map(|(_, s)| s.clone()).unwrap_or_default();
// Equal measurements written differently (units, precision) vary too.
if measured.iter().any(|(_, s)| *s != shown) {
(m.value, m.varies, m.display) = (Value::Null, true, VARIES.to_string());
} else if !m.varies {
m.display = shown;
}
rows.push(m);
rows.push(c.row("textOverride", "Text override", Kind::Text, dims.iter().map(|dm| json!(dm.text))).quick());
}
"Primary Units" => {
let (pre, suf): (Vec<Value>, Vec<Value>) = styles.iter().map(|st| split_post(&st.post)).map(|(p, s)| (json!(p), json!(s))).unzip();
let at = rows.iter().position(|r| r.key == "round").unwrap_or(rows.len());
// Prefix and suffix are DIMPOST's two halves: overridden with it, and reset with it.
let posted = dims.iter().any(|dm| overrides(dm, "post"));
rows.insert(at, c.row("prefix", "Dim prefix", Kind::Text, pre).overridden_if(posted));
let at = rows.iter().position(|r| r.key == "linearUnit").unwrap_or(rows.len());
rows.insert(at, c.row("suffix", "Dim suffix", Kind::Text, suf).overridden_if(posted));
}
"Alternate Units" => {
let (pre, suf): (Vec<Value>, Vec<Value>) =
styles.iter().map(|st| split_post(&st.alt_post)).map(|(p, s)| (json!(p), json!(s))).unzip();
let posted = dims.iter().any(|dm| overrides(dm, "altPost"));
rows.push(c.row("altPrefix", "Alt prefix", Kind::Text, pre).overridden_if(posted));
rows.push(c.row("altSuffix", "Alt suffix", Kind::Text, suf).overridden_if(posted));
}
_ => {}
}
groups.push(Group { name, rows });
}
groups
}
/// Equal values, numbers to 12 significant digits, as the palette compares them: float noise
/// (7 and 7.0000000000001, or 1.2e-16 next to zero) is no difference, while values the display
/// rounds alike (7 and 7.000001) still differ.
fn same(a: &Value, b: &Value) -> bool {
fn tag(v: f64) -> String {
let v = if v.abs() < 1e-12 { 0.0 } else { v };
format!("{:.11e}", v + 0.0)
}
match (a, b) {
(Value::Number(x), Value::Number(y)) => match (x.as_f64(), y.as_f64()) {
(Some(x), Some(y)) => tag(x) == tag(y),
_ => x == y,
},
_ => a == b,
}
}
/// A fixed-height text style decides the dimension text height whatever DIMTXT says (as in
/// AutoCAD); the row says so instead of taking edits that change nothing.
fn fixed_height(c: &Ctx, r: &mut Row, styles: &[DimStyle]) {
let fixed: Vec<Option<(&str, f64)>> = styles
.iter()
.map(|st| c.d.text_style(&st.text_style).filter(|ts| ts.height > 0.0 && ts.height.is_finite()).map(|ts| (ts.name.as_str(), ts.height)))
.collect();
let Some(&Some((name, h))) = fixed.iter().find(|f| f.is_some()) else { return };
if fixed.iter().all(|f| *f == Some((name, h))) {
r.value = json!(h);
r.varies = false;
r.display = c.distance(h);
r.editable = false;
r.note =
Some(format!("Set by text style \"{name}\", which has a fixed height. Give the style a height of 0 to use the dimension text height."));
} else {
// Each dimension's text is its style's fixed height or its own DIMTXT.
let heights: Vec<f64> = fixed.iter().zip(styles).map(|(f, st)| f.map_or(st.text_height, |(_, h)| h)).collect();
let first = heights.first().copied().unwrap_or_default();
if heights.iter().all(|h| *h == first) {
(r.value, r.varies, r.display) = (json!(first), false, c.distance(first));
} else {
(r.value, r.varies, r.display) = (Value::Null, true, VARIES.to_string());
}
r.editable = fixed.iter().any(Option::is_none);
r.note = Some("Some of these dimensions take their text height from a fixed-height text style.".into());
}
}
+1
View File
@@ -61,6 +61,7 @@ impl Session {
Ok(r) => r,
Err(_) => {
self.docs.truncate(n);
self.lisp_forget_closed();
self.active = self.active.min(self.docs.len().saturating_sub(1));
self.bump_doc_epoch();
Err(EngineError::Internal("open".into(), "panic".into()))
+13 -2
View File
@@ -63,6 +63,7 @@ impl Session {
let Some(spec) = find_command(&id) else {
// A command defined in LISP: (defun c:NAME …).
if !transparent && let Some(f) = self.lisp_command(&lower) {
self.commands_started = self.commands_started.wrapping_add(1);
if self.running.is_some() {
self.cancel();
}
@@ -96,8 +97,11 @@ impl Session {
self.echo(format!("Command: {}", spec.id.to_ascii_uppercase()));
return self.input(Input::Keyword("Undo".into()));
}
if !nested && self.running.is_some() {
self.cancel();
if !nested {
self.commands_started = self.commands_started.wrapping_add(1);
if self.running.is_some() {
self.cancel();
}
}
(spec.enabled)(self).map_err(|m| EngineError::Disabled(spec.id.into(), m))?;
if let Some(why) = cmd::blocks::bedit::refused_in_editor(self, spec.id) {
@@ -378,7 +382,14 @@ impl Session {
Ok(())
}
Ok(Step::Done) => {
let seed = run.before.handseed;
self.finish(run, false);
let added = self.doc().is_ok_and(|d| d.handseed != seed);
// A transparent command ending inside another (`'ZOOM` in an INSERT) is not that
// command ending: it shares its number.
if self.suspended.is_none() {
self.last_finished = Some((self.commands_started, added));
}
self.resume_suspended();
Ok(())
}
+5
View File
@@ -166,6 +166,10 @@ pub fn get(s: &Session, name: &str) -> Option<Value> {
"CMDNAMES" => json!(s.running.as_ref().map(|r| r.id.to_ascii_uppercase()).unwrap_or_default()),
"DWGNAME" => json!(s.state().map(|d| d.title.clone()).unwrap_or_default()),
"DBMOD" => json!(s.state().map(|d| i32::from(d.is_dirty())).unwrap_or(0)),
// The next handle the drawing gives out, in hex as `$HANDSEED` (the header keeps the
// value the file was read with, which new objects don't move): past the handles the
// file's own objects hold, as allocation skips them.
"HANDSEED" => json!(format!("{:X}", s.doc().ok()?.next_handle().0)),
// The drawing's folder with a trailing separator ("" while it has no file); DWGTITLED is 1 once it has one.
"DWGPREFIX" => json!(s.state().ok().and_then(|d| d.path.as_deref()).map(dwg_prefix).unwrap_or_default()),
"DWGTITLED" => json!(s.state().map(|d| i32::from(d.path.is_some())).unwrap_or(0)),
@@ -254,6 +258,7 @@ const READ_ONLY: &[&str] = &[
"TILEMODE",
"PLATFORM",
"DBMOD",
"HANDSEED",
"BLOCKEDITOR",
"CTAB",
"LASTPOINT",
+254
View File
@@ -0,0 +1,254 @@
//! #1658: `attdef` takes a justification and a text style, as `text` and `mtext` do, so a
//! title-block attribute can be built centred or right-aligned in its style without an `entmod`.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Attrib, EntityKind, HAlign, Handle, VAlign};
use cadcraft_engine::geom::Vec3;
use serde_json::{Value, json};
fn h(v: &Value) -> Handle {
v["handle"].as_str().and_then(Handle::parse_hex).unwrap()
}
fn attdef(s: &Session, h: Handle) -> Attrib {
match &s.doc().unwrap().entity(h).unwrap().kind {
EntityKind::AttDef(a) => a.clone(),
k => panic!("{k:?}"),
}
}
/// Runs `attdef` with `p` and returns the definition it made.
fn add(s: &mut Session, p: Value) -> Attrib {
let made = h(&s.execute("attdef", &p).unwrap());
attdef(s, made)
}
/// The issue's drawing: a text style ROMANS beside the current Standard.
fn session() -> Session {
let mut s = Session::new();
s.execute("style", &json!({"name": "ROMANS", "font": "romans.shx"})).unwrap();
s.execute("style.current", &json!({"name": "Standard"})).unwrap();
s
}
#[test]
fn justify_and_style_are_applied() {
let mut s = session();
let a = add(&mut s, json!({"tag": "T", "at": [10, 10], "height": 2.5, "justify": "MC", "style": "ROMANS"}));
assert_eq!((a.text.halign, a.text.valign), (HAlign::Center, VAlign::Middle));
assert_eq!(a.text.style, "ROMANS");
assert_eq!(a.text.align_pt, Some(Vec3::new(10.0, 10.0, 0.0)), "justified text is placed by its alignment point");
// Every code `text` takes, and the style name in any case (kept as the table spells it).
for (j, want) in [
("BR", (HAlign::Right, VAlign::Bottom)),
("tl", (HAlign::Left, VAlign::Top)),
("C", (HAlign::Center, VAlign::Baseline)),
("M", (HAlign::Middle, VAlign::Baseline)),
] {
let a = add(&mut s, json!({"tag": "T", "at": [0, 0], "justify": j, "style": "romans"}));
assert_eq!((a.text.halign, a.text.valign), want, "{j}");
assert_eq!(a.text.style, "ROMANS");
}
}
#[test]
fn without_them_nothing_changes() {
let mut s = session();
let a = add(&mut s, json!({"tag": "T", "at": [10, 10]}));
assert_eq!((a.text.halign, a.text.valign, a.text.align_pt), (HAlign::Left, VAlign::Baseline, None));
assert_eq!(a.text.style, "Standard", "the current text style");
// With another current style, that one: not always Standard.
s.execute("style.current", &json!({"name": "ROMANS"})).unwrap();
let a = add(&mut s, json!({"tag": "T", "at": [10, 10]}));
assert_eq!(a.text.style, "ROMANS", "the current text style");
let a = add(&mut s, json!({"tag": "T", "at": [10, 10], "justify": "L"}));
assert_eq!((a.text.halign, a.text.valign, a.text.align_pt), (HAlign::Left, VAlign::Baseline, None));
assert_eq!(a.text.style, "ROMANS", "the current text style");
}
#[test]
fn a_bad_justification_or_style_is_refused() {
let mut s = session();
let n = s.doc().unwrap().model.len();
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "justify": "XX"})).is_err());
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "style": "NOPE"})).is_err());
// Align and Fit need a second baseline point, which attdef has no way to take.
for j in ["A", "ALIGN", "F", "fit"] {
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "justify": j})).is_err(), "{j}");
}
assert_eq!(s.doc().unwrap().model.len(), n, "nothing added");
}
/// The issue's use: a block built from the definition gives its attributes the same placement,
/// and a save and reopen keeps them.
#[test]
fn a_block_and_a_saved_file_keep_them() {
let mut s = session();
let ad =
h(&s.execute("attdef", &json!({"tag": "TITLE", "default": "x", "at": [50, 10], "height": 2.5, "justify": "MC", "style": "ROMANS"})).unwrap());
let l = s.execute("line", &json!({"points": [[0, 0], [100, 0]]})).unwrap()["handles"][0].as_str().and_then(Handle::parse_hex).unwrap();
s.execute("block", &json!({"name": "TB", "base": [0, 0], "handles": [ad.hex(), l.hex()], "keep": "delete"})).unwrap();
let ins = h(&s.execute("insert", &json!({"name": "TB", "at": [0, 0], "attribs": {"TITLE": "PLAN"}})).unwrap());
let EntityKind::Insert(i) = &s.doc().unwrap().entity(ins).unwrap().kind else { panic!() };
let att = i.attribs.first().unwrap();
assert_eq!(
(att.text.halign, att.text.valign, att.text.style.as_str(), att.text.value.as_str()),
(HAlign::Center, VAlign::Middle, "ROMANS", "PLAN")
);
let read = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
let def =
read.block("TB").unwrap().entities.iter().find_map(|e| if let EntityKind::AttDef(a) = &e.kind { Some(a.clone()) } else { None }).unwrap();
assert_eq!((def.text.halign, def.text.valign, def.text.style.as_str()), (HAlign::Center, VAlign::Middle, "ROMANS"), "reopened definition");
let att = read.model.iter().find_map(|e| if let EntityKind::Insert(i) = &e.kind { i.attribs.first().cloned() } else { None }).unwrap();
assert_eq!((att.text.halign, att.text.valign, att.text.style.as_str()), (HAlign::Center, VAlign::Middle, "ROMANS"), "reopened attribute");
}
/// A `justify` or `style` that is present but not a string is an error, not a silent default (#1720).
#[test]
fn a_non_string_justify_or_style_is_refused() {
let mut s = session();
let n = s.doc().unwrap().model.len();
for (key, bad) in [("justify", json!(1)), ("justify", json!(true)), ("style", json!(2)), ("style", json!(["ROMANS"]))] {
let mut p = json!({"tag": "T", "at": [0, 0]});
p[key] = bad.clone();
let err = s.execute("attdef", &p).unwrap_err().to_string();
assert!(err.contains(key) && err.contains("string"), "{key} = {bad}: {err}");
}
// Null means absent.
assert!(s.execute("attdef", &json!({"tag": "T", "at": [0, 0], "justify": null, "style": null})).is_ok());
assert_eq!(s.doc().unwrap().model.len(), n + 1, "only the null one was added");
}
/// The definition takes its text style's width factor and oblique angle (#1720).
#[test]
fn the_definition_takes_the_styles_width_factor_and_oblique() {
let mut s = session();
s.execute("style", &json!({"name": "SLANT", "font": "romans.shx", "widthFactor": 0.7, "oblique": 15, "current": false})).unwrap();
let a = add(&mut s, json!({"tag": "T", "at": [0, 0], "style": "SLANT"}));
assert!((a.text.width_factor - 0.7).abs() < 1e-12, "width factor {}", a.text.width_factor);
assert!((a.text.oblique - 15f64.to_radians()).abs() < 1e-12, "oblique {}", a.text.oblique);
// The current style, when none is named.
s.execute("style.current", &json!({"name": "SLANT"})).unwrap();
let a = add(&mut s, json!({"tag": "T", "at": [0, 0]}));
assert!((a.text.width_factor - 0.7).abs() < 1e-12 && (a.text.oblique - 15f64.to_radians()).abs() < 1e-12);
// A plain style keeps 1 and 0.
let a = add(&mut s, json!({"tag": "T", "at": [0, 0], "style": "Standard"}));
assert_eq!((a.text.width_factor, a.text.oblique), (1.0, 0.0));
}
/// `-ATTDEF` typed at the command line: accept modes, tag, prompt and default, then the point prompt.
fn typed_to_start_point(s: &mut Session) {
s.cmdline("-attdef").unwrap();
s.cmdline("").unwrap();
for line in ["TAG", "Prompt", "Default"] {
s.cmdline(line).unwrap();
}
}
fn last_attdef(s: &Session) -> Attrib {
let e = s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::AttDef(_))).last().unwrap();
attdef(s, e.handle)
}
#[test]
fn the_start_point_prompt_offers_justify_and_style() {
let mut s = session();
typed_to_start_point(&mut s);
assert!(s.prompt_text().contains("Specify start point of text or [Justify/Style]"), "{}", s.prompt_text());
}
#[test]
fn typed_justify_then_a_point_justifies_the_definition() {
let mut s = session();
typed_to_start_point(&mut s);
s.cmdline("J").unwrap();
assert!(s.prompt_text().contains("Enter an option"), "{}", s.prompt_text());
s.cmdline("MC").unwrap();
assert!(s.prompt_text().contains("Specify middle point of text"), "{}", s.prompt_text());
s.cmdline("10,10").unwrap();
s.cmdline("").unwrap();
s.cmdline("").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let a = last_attdef(&s);
assert_eq!((a.text.halign, a.text.valign), (HAlign::Center, VAlign::Middle));
assert_eq!(a.text.align_pt, Some(Vec3::new(10.0, 10.0, 0.0)), "stored as the JSON form does");
}
#[test]
fn typed_justify_refuses_align_fit_and_unknown_codes_and_asks_again() {
let mut s = session();
typed_to_start_point(&mut s);
s.cmdline("J").unwrap();
for bad in ["A", "Fit", "XX"] {
s.cmdline(bad).unwrap();
assert!(s.log.iter().any(|l| l.contains("Invalid option") || l.contains("Align and Fit")), "{bad}: {:?}", s.log);
s.log.clear();
assert!(s.prompt_text().contains("Enter an option"), "{bad}: {}", s.prompt_text());
}
s.cmdline("TR").unwrap();
s.cmdline("0,0").unwrap();
s.cmdline("").unwrap();
s.cmdline("").unwrap();
let a = last_attdef(&s);
assert_eq!((a.text.halign, a.text.valign), (HAlign::Right, VAlign::Top));
}
#[test]
fn typed_style_then_a_point_takes_the_styles_values() {
let mut s = session();
s.execute("style", &json!({"name": "SLANT", "font": "romans.shx", "widthFactor": 0.7, "oblique": 15, "current": false})).unwrap();
typed_to_start_point(&mut s);
s.cmdline("S").unwrap();
assert!(s.prompt_text().contains("Enter style name"), "{}", s.prompt_text());
s.cmdline("slant").unwrap();
s.cmdline("0,0").unwrap();
s.cmdline("").unwrap();
s.cmdline("").unwrap();
let a = last_attdef(&s);
assert_eq!(a.text.style, "SLANT");
assert!((a.text.width_factor - 0.7).abs() < 1e-12 && (a.text.oblique - 15f64.to_radians()).abs() < 1e-12);
}
#[test]
fn typed_style_that_does_not_exist_asks_again() {
let mut s = session();
typed_to_start_point(&mut s);
s.cmdline("S").unwrap();
s.cmdline("NOPE").unwrap();
assert!(s.log.iter().any(|l| l.contains("Cannot find text style \"NOPE\"")), "{:?}", s.log);
assert!(s.prompt_text().contains("Enter style name"), "{}", s.prompt_text());
s.cmdline("ROMANS").unwrap();
s.cmdline("0,0").unwrap();
s.cmdline("").unwrap();
s.cmdline("").unwrap();
assert_eq!(last_attdef(&s).text.style, "ROMANS");
}
/// The keywords a command's Justify prompt offers, from `[A/B/...]` in its prompt text.
fn justify_options(s: &Session) -> Vec<String> {
let p = s.prompt_text();
let inner = p.split_once('[').and_then(|(_, r)| r.split_once(']')).map(|(i, _)| i).unwrap_or("");
inner.split('/').map(str::to_string).collect()
}
/// `-ATTDEF`'s Justify prompt doesn't list Align and Fit, which it would only refuse (they run
/// between two points), while TEXT's still offers every option (#1720).
#[test]
fn attdef_justify_prompt_leaves_out_align_and_fit_but_text_keeps_them() {
let mut s = session();
typed_to_start_point(&mut s);
s.cmdline("J").unwrap();
let opts = justify_options(&s);
assert!(opts.iter().any(|o| o == "Left") && opts.iter().any(|o| o == "MC"), "{opts:?}");
assert!(!opts.iter().any(|o| o == "Align" || o == "Fit"), "{opts:?}");
// A typed A or F is still refused.
s.cmdline("A").unwrap();
assert!(s.log.iter().any(|l| l.contains("Align and Fit")), "{:?}", s.log);
s.cmdline("*Cancel*").ok();
let mut t = session();
t.cmdline("text").unwrap();
t.cmdline("J").unwrap();
let opts = justify_options(&t);
assert!(opts.iter().any(|o| o == "Align") && opts.iter().any(|o| o == "Fit"), "{opts:?}");
}
+308
View File
@@ -0,0 +1,308 @@
//! Block libraries (the Blocks palette): BLOCKLIBRARY lists a folder of drawings or the blocks
//! of one drawing, BLOCKLIBIMPORT defines a library block in the current drawing, and
//! BLOCKLIBRARIES keeps the list of libraries.
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use cadcraft_engine::cmd::file::{IoHooks, set_io};
use cadcraft_engine::doc::geom::Vec3;
use cadcraft_engine::doc::{Block, Drawing, Entity, EntityKind, Handle, Layer, Line};
use cadcraft_engine::{Input, Session};
use serde_json::json;
/// How many times a library file was parsed.
static READS: AtomicUsize = AtomicUsize::new(0);
/// Every library file reads as a drawing with blocks "Valve" (a line on layer Pipes, base point
/// (1, 1)) and "Pump" (empty), whatever its bytes.
fn read(_bytes: &[u8], name: &str) -> Result<Drawing, String> {
READS.fetch_add(1, Ordering::SeqCst);
let mut d = Drawing::new_metric();
d.layers.push(Layer { name: "Pipes".into(), ..Layer::default() });
d.layers.push(Layer { name: "Spare".into(), ..Layer::default() });
let mut valve = Block::new("Valve");
valve.description = "Gate valve".into();
valve.annotative = true;
valve.units = 6;
valve.explodable = false;
valve.base = Vec3::new(1.0, 1.0, 0.0);
let mut line = Entity::new(Handle(0x70), EntityKind::Line(Line { a: Vec3::new(0.0, 0.0, 0.0), b: Vec3::new(4.0, 0.0, 0.0) }));
line.common.layer = "Pipes".into();
valve.entities.push(line);
d.blocks.insert("Valve".into(), Arc::new(valve));
d.blocks.insert("Pump".into(), Arc::new(Block::new("Pump")));
// "Outer" holds a reference to "Valve" and nothing else.
let mut s = Session::new();
*s.doc_mut().unwrap() = d;
s.execute("insert", &json!({ "name": "Valve", "at": [2, 2] })).unwrap();
let handles: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
s.execute("block", &json!({ "name": "Outer", "base": [0, 0], "handles": handles, "keep": "delete" })).unwrap();
// A dimension style nothing uses, with an arrowhead block of its own.
if name.contains("arrow") {
let d = s.doc_mut().unwrap();
d.blocks.insert("TipArrow".into(), Arc::new(Block::new("TipArrow")));
d.dim_styles.push(cadcraft_engine::doc::DimStyle { name: "Spare".into(), arrow_block: "TipArrow".into(), ..Default::default() });
}
// A crafted file: "Valve" holds "Outer", which holds "Valve".
if name.contains("cycle") {
let mut back = (**s.doc().unwrap().block("Outer").unwrap().entities.iter().next().unwrap()).clone();
if let EntityKind::Insert(i) = &mut back.kind {
i.block = "Outer".into();
}
let d = s.doc_mut().unwrap();
let mut valve = (**d.block("Valve").unwrap()).clone();
valve.entities.push(back);
d.blocks.insert("Valve".into(), Arc::new(valve));
}
Ok(s.doc().unwrap().clone())
}
/// A new folder with two drawings and a file that is not one.
fn folder() -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!("cadcraft-blocklibrary-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
for f in ["b-pumps.dwg", "A-valves.dxf", "notes.txt"] {
std::fs::write(dir.join(f), b"x").unwrap();
}
dir
}
/// Listing a drawing file and importing its blocks.
fn lists_and_imports(s: &mut Session, file: &str) {
// A drawing file lists its blocks.
let r = s.execute("blocklibrary", &json!({ "path": file })).unwrap();
assert_eq!(r["kind"], "file");
assert_eq!(
r["blocks"],
json!([{ "name": "Outer", "description": "" }, { "name": "Pump", "description": "" }, { "name": "Valve", "description": "Gate valve" }])
);
// Importing defines the block (and its layer) here, under another name when asked.
let r = s.execute("blocklibimport", &json!({ "path": file, "block": "Valve", "name": "Gate" })).unwrap();
assert_eq!(r["name"], "Gate");
let d = s.doc().unwrap();
let gate = d.block("Gate").unwrap();
assert_eq!(gate.entities.iter().count(), 1);
assert_eq!(gate.base, Vec3::new(1.0, 1.0, 0.0));
assert_eq!((gate.description.as_str(), gate.annotative, gate.units, gate.explodable), ("Gate valve", true, 6, false));
assert!(d.layers.iter().any(|l| l.name == "Pipes"));
// Only what the block needs comes along: not the file's other layers or blocks.
assert!(!d.layers.iter().any(|l| l.name == "Spare"), "an unused layer of the library stays out");
assert!(d.block("Pump").is_none(), "an unused block of the library stays out");
s.execute("insert", &json!({ "name": "Gate", "at": [10, 10] })).unwrap();
// A block already here is never replaced, whatever the letter case.
assert!(s.execute("blocklibimport", &json!({ "path": file, "block": "Pump", "name": "gate" })).is_err());
assert_eq!(s.doc().unwrap().block("Gate").unwrap().entities.iter().count(), 1);
assert!(s.doc().unwrap().block("Pump").is_none());
// A block made of another block brings that one too (and its layer), not the unused ones.
s.execute("blocklibimport", &json!({ "path": file, "block": "Outer", "name": "Assembly" })).unwrap();
let d = s.doc().unwrap();
assert!(d.block("Assembly").is_some());
assert!(d.block("Valve").is_some(), "the nested block stays");
assert!(d.block("Pump").is_none());
assert!(d.layers.iter().any(|l| l.name == "Pipes"));
// A whole drawing is named after its file and brings its objects (here none: model space is empty).
let r = s.execute("blocklibimport", &json!({ "path": file })).unwrap();
assert_eq!(r["name"], "A-valves");
assert!(!s.doc().unwrap().layers.iter().any(|l| l.name == "Spare"));
assert!(s.execute("blocklibimport", &json!({ "path": file, "block": "Nope" })).is_err());
assert!(s.execute("blocklibimport", &json!({ "path": file, "block": "Valve", "name": "bad/name" })).is_err());
}
/// A dimension style nothing uses is left out, and its arrowhead block with it.
fn leaves_out_an_unused_dimension_style(s: &mut Session, dir: &std::path::Path) {
let file = dir.join("arrow-set.dxf").to_string_lossy().to_string();
std::fs::write(&file, b"x").unwrap();
s.execute("blocklibimport", &json!({ "path": file, "block": "Valve", "name": "Tap" })).unwrap();
let d = s.doc().unwrap();
assert!(d.block("Tap").is_some());
assert!(!d.dim_styles.iter().any(|t| t.name == "Spare"), "an unused dimension style stays out");
assert!(d.block("TipArrow").is_none(), "so does its arrowhead block");
}
/// Adding and removing libraries.
fn keeps_the_list(s: &mut Session, dir: &std::path::Path, dir_s: &str, file: &str) {
// The list: add (once), refuse what is not a library, remove.
let l = s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).unwrap();
assert_eq!(l["libraries"], json!([dir_s]));
// The same path again is kept once; letter case only matters on case-sensitive file systems.
let again = s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).unwrap();
assert_eq!(again["libraries"], json!([dir_s]));
if cfg!(any(windows, target_os = "macos")) {
let upper = s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s.to_uppercase() })).unwrap();
assert_eq!(upper["libraries"], json!([dir_s]), "the same folder in other letters is the same library");
assert_eq!(upper["path"], json!(dir_s), "the entry keeps its first spelling");
}
s.execute("blocklibraries", &json!({ "op": "add", "path": file })).unwrap();
assert_eq!(s.execute("blocklibraries", &json!({})).unwrap()["libraries"], json!([dir_s, file]));
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": dir.join("notes.txt").to_string_lossy() })).is_err());
let l = s.execute("blocklibraries", &json!({ "op": "remove", "path": file })).unwrap();
assert_eq!(l["libraries"], json!([dir_s]));
s.execute("blocklibraries", &json!({ "op": "remove", "path": dir_s })).unwrap();
}
/// Names, paths and files that try to pass for something else.
fn refuses_hostile_input(s: &mut Session, dir: &std::path::Path, dir_s: &str) {
// A block whose name looks like `name=path` is that block: INSERT reads no file for it.
let reads = READS.load(Ordering::SeqCst);
let mut odd = Session::new();
odd.doc_mut().unwrap().blocks.insert("a=b".into(), Arc::new(Block::new("a=b")));
odd.start("insert").unwrap();
odd.input(Input::Text("a=b".into())).unwrap();
assert!(odd.prompt_text().starts_with("INSERT Specify insertion point"), "{}", odd.prompt_text());
assert_eq!(READS.load(Ordering::SeqCst), reads, "no file was read");
odd.input(Input::Cancel).unwrap();
// What is not a readable drawing fails with an error.
assert!(s.execute("blocklibimport", &json!({ "path": dir_s })).is_err(), "a folder is not a drawing");
assert!(s.execute("blocklibrary", &json!({ "path": dir.join("missing.dxf").to_string_lossy() })).is_err());
// A file is a library by its name, not by its bytes: `part.bin` is refused before it is read.
let bin = dir.join("part.bin").to_string_lossy().to_string();
std::fs::write(&bin, b"x").unwrap();
let reads = READS.load(Ordering::SeqCst);
assert!(s.execute("blocklibrary", &json!({ "path": bin })).is_err());
assert!(s.execute("blocklibimport", &json!({ "path": bin, "block": "Valve", "name": "FromBin" })).is_err());
assert!(cadcraft_engine::cmd::read_library_file(&bin).is_err());
assert_eq!(READS.load(Ordering::SeqCst), reads, "the file was not parsed");
assert!(s.doc().unwrap().block("FromBin").is_none());
// A library whose blocks hold each other imports without hanging, and the session goes on.
let cycle = dir.join("cycle.dxf").to_string_lossy().to_string();
std::fs::write(&cycle, b"x").unwrap();
let _ = s.execute("blocklibimport", &json!({ "path": cycle, "block": "Outer", "name": "Loop" }));
s.execute("line", &json!({ "points": [[0, 0], [1, 1]] })).unwrap();
}
/// The Blocks palette can open on the Start tab: listing a library and the kept list need no
/// drawing; importing one does.
#[test]
fn the_library_commands_that_read_no_drawing_run_without_one() {
let mut s = Session::empty();
let dir = std::env::temp_dir().join(format!("cadcraft-blocklibrary-nodoc-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("pumps.dwg"), b"x").unwrap();
let r = s.execute("blocklibrary", &json!({ "path": dir.to_string_lossy() })).unwrap();
assert_eq!(r["files"].as_array().map(Vec::len), Some(1));
s.execute("blocklibraries", &json!({})).unwrap();
let err = s.execute("blocklibimport", &json!({ "path": dir.join("pumps.dwg").to_string_lossy() })).unwrap_err();
assert!(err.to_string().contains("no drawing"), "{err}");
let _ = std::fs::remove_dir_all(&dir);
}
/// A file with a huge block table.
fn bounds_a_huge_table() {
// A file with a huge block table lists a bounded part of it, and says so.
let mut many = Session::new();
let d = many.doc_mut().unwrap();
for i in 0..10_001 {
let name = format!("B{i}");
d.blocks.insert(name.clone(), Arc::new(Block::new(&name)));
}
let r = many.execute("blockspalette", &json!({})).unwrap();
let names: Vec<&str> = r["blocks"].as_array().unwrap().iter().map(|b| b["name"].as_str().unwrap()).collect();
assert_eq!(names.len(), 10_000);
assert_eq!(r["truncated"], true);
// The first ones by name, sorted: B9999 comes last of all, so it is the one left out.
assert_eq!(names.first(), Some(&"B0"));
assert!(!names.contains(&"B9999"));
assert!(names.windows(2).all(|w| w[0].to_ascii_lowercase() <= w[1].to_ascii_lowercase()));
}
/// BLOCKSPALETTE counts every object that draws a block: references and multileader block content.
fn counts_what_draws_each_block() {
let mut s = Session::new();
s.doc_mut().unwrap().blocks.insert("Tag".into(), Arc::new(Block::new("Tag")));
s.execute("insert", &json!({ "name": "Tag", "at": [0, 0] })).unwrap();
s.execute("mleader", &json!({ "points": [[0, 0], [10, 5]], "block": "tag" })).unwrap();
let r = s.execute("blockspalette", &json!({})).unwrap();
assert_eq!(r["blocks"], json!([{ "name": "Tag", "description": "", "references": 2 }]));
}
/// The list file in the settings folder.
fn checks_the_list_file(s: &mut Session, dir: &std::path::Path, dir_s: &str) {
// The list file is checked when it is read: junk, bad entries, too many, too big.
let list = dir.join("block-libraries.json");
let libraries = |s: &mut Session| s.execute("blocklibraries", &json!({})).unwrap()["libraries"].as_array().unwrap().clone();
std::fs::write(&list, "not json").unwrap();
assert!(libraries(s).is_empty());
// A file that is there but unreadable is never written over: the list stays as the user left it.
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).is_err());
assert!(s.execute("blocklibraries", &json!({ "op": "remove", "path": dir_s })).is_err());
assert_eq!(std::fs::read(&list).unwrap(), b"not json");
let mut hostile: Vec<String> = (0..100).map(|i| format!("C:/lib{i}")).collect();
hostile.insert(0, String::new());
hostile.insert(1, "bad\nname".into());
hostile.insert(2, "x".repeat(10_000));
std::fs::write(&list, serde_json::to_vec(&hostile).unwrap()).unwrap();
let kept = libraries(s);
assert_eq!(kept.len(), 64);
assert_eq!(kept[0], "C:/lib0");
std::fs::write(&list, vec![b' '; 300 << 10]).unwrap();
assert!(libraries(s).is_empty());
// What the list file holds after an addition is the list, whole.
std::fs::remove_file(&list).unwrap();
s.execute("blocklibraries", &json!({ "op": "add", "path": dir_s })).unwrap();
assert_eq!(serde_json::from_slice::<Vec<String>>(&std::fs::read(&list).unwrap()).unwrap(), vec![dir_s.to_string()]);
// Paths with control characters or of absurd length are refused.
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": format!("{dir_s}\nx") })).is_err());
assert!(s.execute("blocklibraries", &json!({ "op": "add", "path": "y".repeat(5000) })).is_err());
}
/// A file named at INSERT's prompt defines its block before the insertion point is asked for, and
/// Escape there keeps the definition and places nothing, as in AutoCAD 2027.
fn a_cancelled_insert_keeps_the_definition_from_a_file(s: &mut Session, file: &str) {
let placed = s.doc().unwrap().model.iter().count();
s.start("insert").unwrap();
s.input(Input::Text(format!("FromFile={file}"))).unwrap();
assert!(s.prompt_text().starts_with("INSERT Specify insertion point"), "{}", s.prompt_text());
assert!(s.doc().unwrap().block("FromFile").is_some());
s.input(Input::Cancel).unwrap();
assert!(s.doc().unwrap().block("FromFile").is_some());
assert_eq!(s.doc().unwrap().model.iter().count(), placed);
}
/// One test: the file hooks and the settings folder are global to the process.
#[test]
fn libraries_list_import_and_are_kept() {
set_io(IoHooks { read, write: |_, _| Err("no writer in this test".into()), plot: None });
// No settings folder: the list lives in memory, and the real one is never written.
cadcraft_engine::settings_dir::set(None);
let dir = folder();
let dir_s = dir.to_string_lossy().to_string();
let mut s = Session::new();
// A folder lists its drawings by name, case-insensitively sorted; other files are not drawings.
let r = s.execute("blocklibrary", &json!({ "path": dir_s })).unwrap();
assert_eq!(r["kind"], "folder");
let names: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f["name"].as_str().unwrap()).collect();
assert_eq!(names, ["A-valves", "b-pumps"]);
let reads_before = READS.load(Ordering::SeqCst);
let file = dir.join("A-valves.dxf").to_string_lossy().to_string();
lists_and_imports(&mut s, &file);
// The file was parsed once for all of that, and again only when it changes.
assert_eq!(READS.load(Ordering::SeqCst) - reads_before, 1, "the file is parsed once, not for every block placed");
std::fs::write(&file, b"changed contents, another size").unwrap();
s.execute("blocklibrary", &json!({ "path": file })).unwrap();
assert_eq!(READS.load(Ordering::SeqCst) - reads_before, 2, "a changed file is read again");
// Refresh in the palette reads it again even when its size and time look the same.
cadcraft_engine::cmd::clear_library_cache();
let listed = s.execute("blocklibrary", &json!({ "path": file })).unwrap();
assert_eq!(READS.load(Ordering::SeqCst) - reads_before, 3, "a cleared file is read again");
// The palette's worker thread gets the same answer without a session.
assert_eq!(cadcraft_engine::cmd::list_library(&file).unwrap(), listed);
leaves_out_an_unused_dimension_style(&mut s, &dir);
a_cancelled_insert_keeps_the_definition_from_a_file(&mut s, &file);
keeps_the_list(&mut s, &dir, &dir_s, &file);
refuses_hostile_input(&mut s, &dir, &dir_s);
bounds_a_huge_table();
counts_what_draws_each_block();
cadcraft_engine::settings_dir::set(Some(dir.clone()));
checks_the_list_file(&mut s, &dir, &dir_s);
cadcraft_engine::settings_dir::set(None);
std::fs::remove_dir_all(&dir).unwrap();
}
+1 -1
View File
@@ -130,7 +130,7 @@ fn the_prompts_are_autocads() {
// A wrong answer, or a justification not available here, is asked again.
for typed in ["X", "_A"] {
s.cmdline(typed).unwrap();
assert!(s.prompt_text().contains("[Left/Center/Right/Align/Middle/Fit/TL/"), "{typed}: {}", s.prompt_text());
assert!(s.prompt_text().contains("[Left/Center/Right/Middle/TL/"), "{typed}: {}", s.prompt_text());
}
s.cmdline("_MC").unwrap();
assert!(s.prompt_text().ends_with("Specify middle point of text:"), "{}", s.prompt_text());
+88
View File
@@ -0,0 +1,88 @@
//! The dimension shortcut menu's style commands: Remove Style Overrides clears the selected
//! dimensions' overrides, and Save as New Style makes a style of a dimension's settings (its
//! overrides included) and gives it to the dimension.
use cadcraft_engine::doc::{Dimension, EntityKind, Handle};
use cadcraft_engine::{Input, Session};
use serde_json::json;
fn dimension(s: &mut Session, y: f64) -> Handle {
s.execute("dimlinear", &json!({ "p1": [0, y], "p2": [10, y], "at": [5, y + 3.0] })).unwrap();
s.doc().unwrap().model.last().unwrap().handle
}
fn dim(s: &Session, h: Handle) -> Dimension {
match &s.doc().unwrap().entity(h).unwrap().kind {
EntityKind::Dimension(d) => d.clone(),
k => panic!("not a dimension: {k:?}"),
}
}
#[test]
fn remove_style_overrides_clears_the_selected_dimensions() {
let mut s = Session::new();
let (a, b) = (dimension(&mut s, 0.0), dimension(&mut s, 10.0));
s.execute("properties.set", &json!({ "handles": [a.hex(), b.hex()], "textHeight": 0.3 })).unwrap();
s.execute("dimoverride.clear", &json!({ "handles": [a.hex()] })).unwrap();
assert!(dim(&s, a).overrides.is_empty() && !dim(&s, b).overrides.is_empty());
// From the menu: the selected dimensions, in one undo step.
s.set_selection(vec![b]);
s.start("dimoverride.clear").unwrap();
assert!(s.running.is_none() && dim(&s, b).overrides.is_empty());
s.undo().unwrap();
assert_eq!(dim(&s, b).overrides.get("textHeight"), Some(&json!(0.3)));
}
#[test]
fn save_as_new_style_takes_the_dimensions_settings() {
let mut s = Session::new();
let h = dimension(&mut s, 0.0);
s.execute("properties.set", &json!({ "handles": [h.hex()], "textHeight": 0.3, "DIMDEC": 2 })).unwrap();
let r = s.execute("dimstyle.saveas", &json!({ "handle": h.hex(), "name": "Detail" })).unwrap();
assert_eq!(r["style"], "Detail");
let d = dim(&s, h);
assert!(d.style == "Detail" && d.overrides.is_empty(), "{d:?}");
let st = s.execute("dimstyle.list", &json!({ "name": "Detail" })).unwrap();
assert_eq!((st["variables"]["DIMTXT"].as_f64(), st["variables"]["DIMDEC"].as_u64()), (Some(0.3), Some(2)));
// The dimension looks the same, and the current style is still Standard.
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &d);
assert!((g.text_height - 0.3).abs() < 1e-12 && g.value == "10.00", "{} {}", g.text_height, g.value);
assert_eq!(s.doc().unwrap().header.str("DIMSTYLE", "Standard"), "Standard");
// A new name that a style can have (no `~`, which -DIMSTYLE Restore reads as compare).
for name in ["detail", " ", "a<b", "~Plan"] {
assert!(s.execute("dimstyle.saveas", &json!({ "handle": h.hex(), "name": name })).is_err(), "{name}");
}
// Only dimensions.
s.execute("circle", &json!({ "center": [0, 0], "radius": 1 })).unwrap();
let c = s.doc().unwrap().model.last().unwrap().handle;
assert!(s.execute("dimstyle.saveas", &json!({ "handle": c.hex(), "name": "Other" })).is_err());
}
#[test]
fn save_as_new_style_from_the_menu_asks_for_a_name() {
let mut s = Session::new();
let h = dimension(&mut s, 0.0);
s.execute("properties.set", &json!({ "handles": [h.hex()], "textHeight": 0.3 })).unwrap();
s.set_selection(vec![h]);
s.start("dimstyle.saveas").unwrap();
assert!(s.prompt_text().contains("name of new dimension style"), "{}", s.prompt_text());
// A name already taken is refused, said why, and asked again.
let _ = s.input(Input::Text("Standard".into()));
assert!(s.running.is_some(), "a taken name asks again");
assert!(s.log.iter().any(|l| l.contains("already exists")), "{:?}", s.log);
s.input(Input::Text("Detail".into())).unwrap();
assert!(s.running.is_none());
assert_eq!(dim(&s, h).style, "Detail");
}
#[test]
fn save_as_new_style_picks_a_dimension_when_none_is_selected() {
let mut s = Session::new();
let h = dimension(&mut s, 0.0);
s.start("dimstyle.saveas").unwrap();
assert!(s.prompt_text().contains("Select a dimension"), "{}", s.prompt_text());
// The dimension line of the dimension.
s.input(Input::Point(cadcraft_engine::geom::Vec2::new(5.0, 3.0))).unwrap();
s.input(Input::Text("Picked".into())).unwrap();
assert_eq!(dim(&s, h).style, "Picked");
}
+30
View File
@@ -0,0 +1,30 @@
//! A negative DIMGAP draws a frame around the dimension text: SETVAR takes the negative value, a
//! new dimension draws the frame, and EXPLODE turns it into four lines.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::json;
/// Draw a linear dimension with DIMGAP `gap`, explode it, and return the number of lines the
/// dimension drew and the number of LINEs EXPLODE left.
fn explode_with_gap(gap: f64) -> (usize, usize) {
let mut s = Session::new();
s.execute("setvar", &json!({ "name": "DIMGAP", "value": gap })).unwrap();
let r = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [30, 0], "at": [15, 5] })).unwrap();
let h = Handle::parse_hex(r["handle"].as_str().unwrap()).unwrap();
let drawn = match &s.doc().unwrap().entity(h).unwrap().kind {
EntityKind::Dimension(dm) => cadcraft_engine::render::dimension_in(s.doc().unwrap(), dm).lines.len(),
k => panic!("not a dimension: {k:?}"),
};
s.execute("explode", &json!({ "handles": [h.hex()] })).unwrap();
let lines = s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count();
(drawn, lines)
}
#[test]
fn negative_dimgap_frame_is_drawn_and_exploded() {
let (plain_drawn, plain_lines) = explode_with_gap(0.09);
let (drawn, lines) = explode_with_gap(-0.09);
assert_eq!(drawn, plain_drawn + 4);
assert_eq!(lines, plain_lines + 4);
}
+228
View File
@@ -0,0 +1,228 @@
//! -DIMSTYLE at the command line and as JSON (save, annotative, restore, status, variables,
//! apply, list), and `dimstyle.overrides`, which sets the current style's overrides.
use cadcraft_engine::doc::{Dimension, EntityKind, Handle};
use cadcraft_engine::{Input, Session};
use serde_json::json;
fn dimension(s: &mut Session) -> Handle {
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
s.doc().unwrap().model.last().unwrap().handle
}
fn dim(s: &Session, h: Handle) -> Dimension {
match &s.doc().unwrap().entity(h).unwrap().kind {
EntityKind::Dimension(d) => d.clone(),
k => panic!("not a dimension: {k:?}"),
}
}
fn current(s: &Session) -> String {
s.doc().unwrap().header.str("DIMSTYLE", "")
}
#[test]
fn save_restore_status_and_variables_as_json() {
let mut s = Session::new();
// A current-style override (SETVAR) goes into the saved style.
s.execute("setvar", &json!({ "name": "DIMTXT", "value": 0.25 })).unwrap();
let r = s.execute("-dimstyle", &json!({ "option": "save", "name": "Plan" })).unwrap();
assert_eq!(r["style"], "Plan");
assert_eq!(current(&s), "Plan");
let d = s.doc().unwrap();
assert!(d.dim_overrides().is_empty(), "saved into the style");
assert_eq!(d.dim_style("Plan").unwrap().text_height, 0.25);
// A name in use is redefined only when asked to.
assert!(s.execute("-dimstyle", &json!({ "option": "save", "name": "plan" })).is_err());
s.execute("-dimstyle", &json!({ "option": "save", "name": "plan", "replace": true })).unwrap();
assert_eq!(s.doc().unwrap().dim_styles.iter().filter(|st| st.name.eq_ignore_ascii_case("plan")).count(), 1);
s.execute("-dimstyle", &json!({ "option": "restore", "name": "standard" })).unwrap();
assert_eq!(current(&s), "Standard");
let status = s.execute("-dimstyle", &json!({ "option": "status" })).unwrap();
assert_eq!(status["variables"]["DIMTXT"], 0.18);
let vars = s.execute("-dimstyle", &json!({ "option": "variables", "name": "Plan" })).unwrap();
assert_eq!(vars["variables"]["DIMTXT"], 0.25);
s.execute("-dimstyle", &json!({ "option": "annotative", "name": "Anno" })).unwrap();
assert!(s.doc().unwrap().dim_style("Anno").unwrap().annotative);
let list = s.execute("-dimstyle", &json!({ "option": "list", "pattern": "p*" })).unwrap();
assert_eq!(list["styles"], json!(["Plan"]));
// A dimension's style becomes current; its variables include its overrides.
let h = dimension(&mut s);
s.execute("properties.set", &json!({ "handles": [h.hex()], "textHeight": 0.4 })).unwrap();
let vars = s.execute("-dimstyle", &json!({ "option": "variables", "handle": h.hex() })).unwrap();
assert_eq!(vars["variables"]["DIMTXT"], 0.4);
s.execute("-dimstyle", &json!({ "option": "restore", "handle": h.hex() })).unwrap();
assert_eq!(current(&s), "Anno");
}
#[test]
fn apply_gives_dimensions_the_current_settings() {
let mut s = Session::new();
let h = dimension(&mut s);
s.execute("dimstyle", &json!({ "name": "Plan", "DIMTXT": 0.3 })).unwrap();
s.execute("setvar", &json!({ "name": "DIMDEC", "value": 1 })).unwrap();
let r = s.execute("-dimstyle", &json!({ "option": "apply", "handles": [h.hex()] })).unwrap();
assert_eq!(r["changed"], 1);
let d = dim(&s, h);
assert_eq!(d.style, "Plan");
assert_eq!(d.overrides.get("decimals"), Some(&json!(1)));
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &d);
assert_eq!(g.value, "10.0");
}
#[test]
fn the_command_line_asks_like_autocad() {
let mut s = Session::new();
s.cmdline("-DIMSTYLE").unwrap();
assert!(s.prompt_text().contains("ANnotative"), "{}", s.prompt_text());
s.cmdline("S").unwrap();
s.cmdline("Plan").unwrap();
assert!(s.running.is_none());
assert_eq!(current(&s), "Plan");
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("R").unwrap();
s.cmdline("Standard").unwrap();
assert_eq!(current(&s), "Standard");
let before = s.log.len();
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("ST").unwrap();
assert!(s.log[before..].iter().any(|l| l.starts_with("DIMTXT") && l.contains("Text height")), "{:?}", &s.log[before..]);
// A name in use asks to redefine it.
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("S").unwrap();
s.cmdline("Plan").unwrap();
assert!(s.prompt_text().contains("redefine"), "{}", s.prompt_text());
s.cmdline("Y").unwrap();
assert!(s.running.is_none());
// Apply: the objects to give the current settings.
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("R").unwrap();
s.cmdline("Standard").unwrap();
let h = dimension(&mut s);
s.execute("dimstyle.current", &json!({ "name": "Plan" })).unwrap();
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("A").unwrap();
s.input(Input::Pick(vec![h])).unwrap();
s.input(Input::Enter).unwrap();
assert!(s.running.is_none());
assert_eq!(dim(&s, h).style, "Plan");
// ~name compares a style with the current settings.
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("R").unwrap();
let before = s.log.len();
s.cmdline("~Standard").unwrap();
assert!(s.log[before..].iter().any(|l| l.contains("Differences")), "{:?}", &s.log[before..]);
s.cancel();
}
#[test]
fn style_overrides_are_set_in_one_step() {
let mut s = Session::new();
s.execute("dimstyle.overrides", &json!({ "textHeight": 0.3, "DIMCLRT": 1 })).unwrap();
let o = s.doc().unwrap().dim_overrides();
assert_eq!(o.get("textHeight"), Some(&json!(0.3)));
assert!(o.contains_key("textColor"), "{o:?}");
s.undo().unwrap();
assert!(s.doc().unwrap().dim_overrides().is_empty(), "one undo step");
// Unusable values change nothing; names that aren't variables are refused.
assert!(s.execute("dimstyle.overrides", &json!({ "textHeight": -1, "DIMDEC": 2 })).is_err());
assert!(s.execute("dimstyle.overrides", &json!({ "nope": 1 })).is_err());
assert!(s.doc().unwrap().dim_overrides().is_empty());
s.execute("dimstyle.overrides", &json!({ "DIMDEC": 2 })).unwrap();
// Clear drops them only when every value is usable.
assert!(s.execute("dimstyle.overrides", &json!({ "clear": true, "textHeight": -1 })).is_err());
assert!(s.execute("dimstyle.overrides", &json!({ "clear": true, "nope": 1 })).is_err());
assert_eq!(s.doc().unwrap().dim_overrides().get("decimals"), Some(&json!(2)));
s.execute("dimstyle.overrides", &json!({ "clear": true, "textGap": 0.05 })).unwrap();
let o = s.doc().unwrap().dim_overrides();
assert_eq!((o.len(), o.get("textGap")), (1, Some(&json!(0.05))));
s.execute("dimstyle.overrides", &json!({ "clear": true })).unwrap();
assert!(s.doc().unwrap().dim_overrides().is_empty());
// A lineweight by name goes in as the number the header variable holds.
s.execute("dimstyle.overrides", &json!({ "clear": true, "DIMLWD": "bylayer" })).unwrap();
assert_eq!(s.doc().unwrap().header.i64("DIMLWD", 0), -1);
}
#[test]
fn refused_calls_leave_no_undo_step() {
let mut s = Session::new();
s.execute("-dimstyle", &json!({ "option": "save", "name": "Plan" })).unwrap();
assert!(s.execute("-dimstyle", &json!({ "option": "save", "name": "plan" })).is_err());
assert!(s.execute("-dimstyle", &json!({ "option": "restore", "name": "Nope" })).is_err());
// Apply to objects none of which is a dimension changes nothing, and makes no step either.
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
let line = s.doc().unwrap().model.last().unwrap().handle.hex();
assert_eq!(s.execute("-dimstyle", &json!({ "option": "apply", "handles": [line] })).unwrap()["changed"], 0);
// The undo steps are the line and the save: none for the refused calls or that Apply.
s.undo().unwrap();
assert!(s.doc().unwrap().dim_style("Plan").is_some(), "the first undo is the line's");
s.undo().unwrap();
assert!(s.doc().unwrap().dim_style("Plan").is_none());
}
#[test]
fn new_and_renamed_styles_take_the_names_dimstyle_takes() {
let mut s = Session::new();
for name in ["~Plan", "a*b", "x?"] {
assert!(s.execute("dimstyle", &json!({ "name": name })).is_err(), "{name}");
}
s.execute("dimstyle", &json!({ "name": "Plan", "current": false })).unwrap();
assert!(s.execute("dimstyle.rename", &json!({ "from": "Plan", "to": "~Plan" })).is_err());
s.execute("dimstyle.rename", &json!({ "from": "Plan", "to": "Site" })).unwrap();
assert!(s.doc().unwrap().dim_style("Site").is_some());
}
#[test]
fn a_refused_answer_asks_the_same_question() {
let mut s = Session::new();
s.cmdline("-DIMSTYLE").unwrap();
s.cmdline("R").unwrap();
// A style to compare with that doesn't exist.
let _ = s.cmdline("~Nope");
assert!(s.prompt_text().contains("Enter a dimension style name"), "{}", s.prompt_text());
// Words at "Select dimension".
s.cmdline("").unwrap();
let _ = s.cmdline("Standard");
assert!(s.prompt_text().contains("Select dimension"), "{}", s.prompt_text());
s.cancel();
}
#[test]
fn listing_with_many_stars_takes_no_time() {
let mut s = Session::new();
s.execute("dimstyle", &json!({ "name": "a".repeat(200), "current": false })).unwrap();
let start = std::time::Instant::now();
for pattern in ["*".repeat(255) + "x", "*a".repeat(120) + "b"] {
let r = s.execute("-dimstyle", &json!({ "option": "list", "pattern": pattern })).unwrap();
assert_eq!(r["styles"], json!([]));
}
assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
let r = s.execute("-dimstyle", &json!({ "option": "list", "pattern": "a*a?" })).unwrap();
assert_eq!(r["styles"], json!(["a".repeat(200)]));
}
#[test]
fn hostile_requests_never_panic() {
let mut s = Session::new();
let h = dimension(&mut s);
for p in [
json!({ "option": "save", "name": "" }),
json!({ "option": "save", "name": "a*b" }),
json!({ "option": "restore", "handle": "zz" }),
json!({ "option": "variables", "handle": 1e300 }),
json!({ "option": "apply", "handles": [h.hex(), "1", 5] }),
json!({ "option": "list", "pattern": "*".repeat(100_000) }),
json!({ "option": 5 }),
] {
let r = s.execute("-dimstyle", &p);
assert!(!matches!(r, Err(cadcraft_engine::EngineError::Internal(..))), "{p}: {r:?}");
}
for p in [json!({ "DIMTXT": "x" }), json!({ "DIMBLK": [1] }), json!({ "DIMCLRT": { "a": 1 } }), json!({ "clear": "yes" })] {
let r = s.execute("dimstyle.overrides", &p);
assert!(!matches!(r, Err(cadcraft_engine::EngineError::Internal(..))), "{p}: {r:?}");
}
for line in ["-DIMSTYLE", "?", "", "-DIMSTYLE", "V", "", "-DIMSTYLE", "AN", "N", "?", "Bad/Name", "Good"] {
let _ = s.cmdline(line);
}
s.cancel();
}
+78
View File
@@ -0,0 +1,78 @@
//! Enter or Space at INSERT's insertion point prompt asks again, as in AutoCAD 2027; Escape ends
//! the command (the Blocks palette's Repeat Placement stops this way).
use cadcraft_engine::geom::Vec2;
use cadcraft_engine::{Input, Session};
use serde_json::json;
#[test]
fn enter_at_the_insertion_point_asks_again() {
let mut s = Session::new();
s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap();
let hs: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
s.execute("block", &json!({"name": "A", "base": [0, 0], "handles": hs, "keep": "delete"})).unwrap();
s.start("insert").unwrap();
s.input(Input::Text("A".into())).unwrap();
assert!(s.prompt_text().starts_with("INSERT Specify insertion point"), "{}", s.prompt_text());
s.input(Input::Enter).unwrap();
assert!(s.prompt_text().starts_with("INSERT Specify insertion point"), "{}", s.prompt_text());
s.input(Input::Cancel).unwrap();
assert_eq!(s.prompt_text(), "Command:");
assert_eq!(s.doc().unwrap().model.iter().count(), 0, "nothing is placed");
assert_eq!(s.last_finished, None, "ending it this way is cancelling it");
}
/// A cancelled INSERT leaves the drawing as it was: it takes no undo step, or the next undo would
/// seem to do nothing (Repeat Placement always ends this way). A placed block keeps its name.
#[test]
fn a_cancelled_insert_takes_no_undo_step() {
let mut s = Session::new();
s.execute("line", &json!({"points": [[0, 0], [10, 0]]})).unwrap();
let hs: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
s.execute("block", &json!({"name": "A", "base": [0, 0], "handles": hs, "keep": "delete"})).unwrap();
let steps = s.state().unwrap().undo.len();
s.start("insert").unwrap();
s.input(Input::Text("A".into())).unwrap();
s.input(Input::Cancel).unwrap();
assert_eq!(s.state().unwrap().undo.len(), steps);
assert_eq!(s.doc().unwrap().header.str("INSNAME", ""), "");
s.start("insert").unwrap();
s.input(Input::Text("A".into())).unwrap();
s.input(Input::Keyword("Scale".into())).unwrap();
s.input(Input::Text("1".into())).unwrap();
s.input(Input::Keyword("Rotate".into())).unwrap();
s.input(Input::Text("0".into())).unwrap();
s.input(Input::Point(Vec2::new(1.0, 1.0))).unwrap();
assert_eq!(s.state().unwrap().undo.len(), steps + 1);
assert_eq!(s.doc().unwrap().header.str("INSNAME", ""), "A");
}
/// How the last command ended: by itself, with what it added; a cancelled one changes nothing.
#[test]
fn the_last_finished_command_says_whether_it_added_objects() {
let mut s = Session::new();
s.start("line").unwrap();
s.input(Input::Point(Vec2::new(0.0, 0.0))).unwrap();
s.input(Input::Point(Vec2::new(1.0, 1.0))).unwrap();
s.input(Input::Enter).unwrap();
let line = (s.commands_started, true);
assert_eq!(s.last_finished, Some(line));
s.start("circle").unwrap();
s.input(Input::Cancel).unwrap();
assert_eq!(s.last_finished, Some(line));
}
/// A transparent command runs inside the current one: it does not count as a new command.
#[test]
fn only_a_command_of_its_own_counts_as_started() {
let mut s = Session::new();
s.start("line").unwrap();
let started = s.commands_started;
s.start("'zoom").unwrap();
assert_eq!(s.commands_started, started);
s.start("circle").unwrap();
assert_eq!(s.commands_started, started + 1);
}
+3 -1
View File
@@ -6,7 +6,7 @@
use std::path::{Path, PathBuf};
use cadcraft_engine::Session;
use cadcraft_engine::cmd::file::{EntityCodec, set_entity_codec};
use cadcraft_engine::cmd::file::{EntityCodec, set_entity_codec, set_object_records};
use cadcraft_engine::doc::Entity;
use serde_json::{Value, json};
@@ -220,6 +220,8 @@ fn run_case(dir: &Path) -> Result<(), String> {
#[test]
fn autolisp_corpus() {
set_entity_codec(EntityCodec { groups: cadcraft_io::entity_groups, entity: cadcraft_io::entity_from_groups });
// ... and non-graphic objects (tables, dictionaries, layouts) as DXF records.
set_object_records(cadcraft_io::object_records);
let Some(dir) = cases_dir() else {
eprintln!("CADCRAFT_LISP_CORPUS is not set: the AutoLISP corpus is skipped");
return;
+37
View File
@@ -0,0 +1,37 @@
//! LISP `findfile` finds folders as well as files (#2985): routines test whether an optional
//! module is installed with `(findfile "module/.")`.
use cadcraft_engine::Session;
use serde_json::json;
#[path = "../support/temp_dir.rs"]
mod temp_dir;
use temp_dir::TempDir;
/// `(findfile name)` as LISP prints it.
fn findfile(name: &str) -> String {
let mut s = Session::new();
let r = s.execute("lisp", &json!({ "code": format!("(findfile \"{name}\")") })).unwrap();
r["value"].as_str().unwrap().to_string()
}
#[test]
fn findfile_finds_a_folder_with_and_without_a_trailing_dot() {
let dir = TempDir::new("findfile-folder");
std::fs::create_dir_all(dir.join("module")).unwrap();
// Forward slashes, so the name needs no escaping in the LISP string on Windows.
let folder = dir.join("module").to_string_lossy().replace('\\', "/");
assert_eq!(findfile(&folder), format!("\"{folder}\""));
assert_eq!(findfile(&format!("{folder}/.")), format!("\"{folder}/.\""));
// A folder that isn't there is still nil.
assert_eq!(findfile(&format!("{folder}-missing")), "nil");
assert_eq!(findfile(&format!("{folder}-missing/.")), "nil");
}
#[test]
fn findfile_still_finds_a_file() {
let dir = TempDir::new("findfile-file");
let file = dir.file("routine.lsp", "(princ)").replace('\\', "/");
assert_eq!(findfile(&file), format!("\"{file}\""));
}
+7
View File
@@ -39,7 +39,10 @@ mod dim_explode_text;
mod dim_properties;
mod dim_radial_inside;
mod dim_radial_outside;
mod dim_style_menu;
mod dim_text_frame;
mod dim_vars;
mod dimstyle_cli;
mod dimtedit_prompts;
mod drafting_spacing;
mod draw_prompts;
@@ -68,6 +71,7 @@ mod inquiry_keywords;
mod inquiry_variables;
mod inquiry_z;
mod insert_attribute_prompts;
mod insert_enter;
mod insert_prompts;
mod isometric;
mod join_close;
@@ -79,6 +83,7 @@ mod layout_prompts;
mod leader_command;
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod lisp_corpus;
mod lisp_findfile;
mod lisp_undo_in_routine;
mod malformed_handles;
mod matchprop;
@@ -116,7 +121,9 @@ mod polyface_explode;
mod post_command_passes;
mod prompt_keywords;
mod prompt_or_once;
mod properties_describe;
mod properties_set_locked;
mod properties_set_text_dims;
mod props_bad_lineweight;
mod props_insert_scale_attribs;
mod purge_mlinestyles;
@@ -0,0 +1,228 @@
//! `properties.describe`: the Properties palette's rows for text, mtext and dimensions, with
//! shared values, *VARIES*, units, and the reason a dimension's text height can't be edited.
use cadcraft_engine::Session;
use serde_json::{Value, json};
fn handle(r: &Value) -> String {
r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap().to_string()
}
fn last(s: &Session) -> String {
s.doc().unwrap().model.last().unwrap().handle.hex()
}
fn describe(s: &mut Session, p: Value) -> Value {
s.execute("properties.describe", &p).unwrap()
}
/// The row `key` in group `group`.
fn row<'a>(desc: &'a Value, group: &str, key: &str) -> &'a Value {
let g = desc["groups"].as_array().unwrap().iter().find(|g| g["name"] == group).unwrap_or_else(|| panic!("no group {group}: {desc}"));
g["rows"].as_array().unwrap().iter().find(|r| r["key"] == key).unwrap_or_else(|| panic!("no row {key} in {group}: {g}"))
}
fn group_names(desc: &Value) -> Vec<String> {
desc["groups"].as_array().unwrap().iter().map(|g| g["name"].as_str().unwrap().to_string()).collect()
}
#[test]
fn text_rows_share_values_and_vary() {
let mut s = Session::new();
let a = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 2.5 })).unwrap());
let b = handle(&s.execute("text", &json!({ "at": [0, 5], "text": "B", "height": 1, "justify": "MC" })).unwrap());
let one = describe(&mut s, json!({ "handles": [a] }));
assert_eq!(group_names(&one), ["General", "Text", "Geometry"]);
let h = row(&one, "Text", "height");
assert_eq!((h["value"].as_f64(), h["display"].as_str(), h["kind"].as_str()), (Some(2.5), Some("2.5000"), Some("distance")));
assert_eq!(row(&one, "Text", "justify")["display"], "Left");
assert_eq!(row(&one, "Text", "style")["value"], "Standard");
assert!(row(&one, "Text", "style")["options"].as_array().unwrap().iter().any(|o| o["value"] == "Standard"));
assert_eq!(row(&one, "Text", "text")["value"], "A");
let both = describe(&mut s, json!({ "handles": [a, b] }));
assert_eq!(both["count"], 2);
let h = row(&both, "Text", "height");
assert_eq!((h["varies"].as_bool(), h["display"].as_str(), h["value"].is_null()), (Some(true), Some("*VARIES*"), true));
// Both are rotated 0 and in the same style.
assert_eq!(row(&both, "Text", "rotation")["varies"], false);
assert_eq!(row(&both, "Text", "style")["display"], "Standard");
assert_eq!(row(&both, "Text", "justify")["varies"], true);
}
#[test]
fn mixed_selections_show_general_rows_unless_filtered() {
let mut s = Session::new();
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
s.execute("circle", &json!({ "center": [0, 0], "radius": 1 })).unwrap();
let c = last(&s);
let mixed = describe(&mut s, json!({ "handles": [t, c] }));
assert_eq!(group_names(&mixed), ["General"]);
assert_eq!(mixed["types"], json!([{ "type": "Text", "count": 1 }, { "type": "Circle", "count": 1 }]));
assert_eq!(row(&mixed, "General", "layer")["value"], "0");
let texts = describe(&mut s, json!({ "handles": [t, c], "type": "text" }));
assert_eq!((texts["filter"].as_str(), texts["count"].as_u64()), (Some("Text"), Some(1)));
assert_eq!(group_names(&texts), ["General", "Text", "Geometry"]);
// An unknown filter describes everything.
assert_eq!(describe(&mut s, json!({ "handles": [t, c], "type": "nope" }))["count"], 2);
// Nothing selected, or handles that name nothing: no rows.
assert_eq!(describe(&mut s, json!({ "handles": [] }))["groups"], json!([]));
assert_eq!(describe(&mut s, json!({ "handles": ["FFFFFF"] }))["count"], 0);
}
#[test]
fn mtext_rows() {
let mut s = Session::new();
let r = s.execute("mtext", &json!({ "at": [0, 0], "text": "one\\Ptwo", "height": 3, "width": 40, "justify": "MC", "lineSpacing": 1.5 })).unwrap();
let m = handle(&r);
let d = describe(&mut s, json!({ "handles": [m] }));
assert_eq!(group_names(&d), ["General", "Text", "Geometry"]);
assert_eq!(row(&d, "Text", "justify")["value"], "MC");
assert_eq!(row(&d, "Text", "justify")["display"], "Middle center");
assert_eq!(row(&d, "Text", "text")["kind"], "contents");
assert_eq!(row(&d, "Text", "lineSpacing")["value"], 1.5);
// Line space distance: factor × height × 5/3.
let dist = row(&d, "Text", "lineSpacingDistance")["value"].as_f64().unwrap();
assert!((dist - 1.5 * 3.0 * 5.0 / 3.0).abs() < 1e-9, "{dist}");
assert_eq!(row(&d, "Text", "lineSpacingStyle")["value"], "atLeast");
assert_eq!(row(&d, "Text", "width")["value"], 40.0);
let cols = row(&d, "Text", "columns");
assert_eq!((cols["display"].as_str(), cols["editable"].as_bool()), (Some("None"), Some(false)));
}
#[test]
fn dimension_rows_come_from_the_style_and_its_overrides() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
let d = describe(&mut s, json!({ "handles": [dm] }));
assert_eq!(group_names(&d), ["General", "Misc", "Lines & Arrows", "Text", "Fit", "Primary Units", "Alternate Units", "Tolerances"]);
let th = row(&d, "Text", "textHeight");
assert_eq!((th["value"].as_f64(), th["editable"].as_bool(), th.get("overridden")), (Some(0.18), Some(true), None));
assert_eq!(row(&d, "Misc", "dimStyle")["value"], "Standard");
assert_eq!(row(&d, "Text", "textAbove")["display"], "Centered");
assert_eq!(row(&d, "Primary Units", "decimals")["display"], "0.0000");
assert_eq!(row(&d, "Lines & Arrows", "arrowBlock1")["display"], "Closed filled");
assert_eq!(row(&d, "Lines & Arrows", "dimLineColor")["value"], "ByBlock");
let m = row(&d, "Text", "measurement");
assert_eq!((m["editable"].as_bool(), m["display"].as_str()), (Some(false), Some("10.0000")));
assert_eq!(row(&d, "Text", "textOverride")["value"], "");
// A Properties edit is an override of this dimension; the row says so.
let r = s.execute("properties.set", &json!({ "handles": [dm], "textHeight": 0.3 })).unwrap();
assert_eq!(r["ignored"], json!([]));
let d = describe(&mut s, json!({ "handles": [dm] }));
let th = row(&d, "Text", "textHeight");
assert_eq!((th["value"].as_f64(), th["overridden"].as_bool()), (Some(0.3), Some(true)));
// The style itself is unchanged.
let st = s.execute("dimstyle.list", &json!({ "name": "Standard" })).unwrap();
assert_eq!(st["variables"]["DIMTXT"], 0.18);
}
#[test]
fn a_fixed_height_text_style_decides_dimension_text_height() {
let mut s = Session::new();
s.execute("style", &json!({ "name": "Fixed", "height": 0.5, "current": false })).unwrap();
s.execute("dimstyle", &json!({ "name": "FixedDims", "textStyle": "Fixed" })).unwrap();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
let d = describe(&mut s, json!({ "handles": [dm] }));
let th = row(&d, "Text", "textHeight");
assert_eq!((th["editable"].as_bool(), th["display"].as_str()), (Some(false), Some("0.5000")));
assert!(th["note"].as_str().unwrap().contains("Fixed"), "{th}");
// Fixed heights that differ vary, whatever their DIMTXT says.
s.execute("style", &json!({ "name": "Large", "height": 0.75, "current": false })).unwrap();
s.execute("dimstyle", &json!({ "name": "LargeDims", "textStyle": "Large" })).unwrap();
s.execute("dimlinear", &json!({ "p1": [0, 10], "p2": [10, 10], "at": [5, 13] })).unwrap();
let large = last(&s);
let d = describe(&mut s, json!({ "handles": [dm, large] }));
let th = row(&d, "Text", "textHeight");
assert_eq!((th["editable"].as_bool(), th["display"].as_str()), (Some(false), Some("*VARIES*")));
}
#[test]
fn measurements_read_as_each_dimension_writes_them() {
let mut s = Session::new();
let shown =
|s: &mut Session, hs: Value| row(&describe(s, json!({ "handles": hs })), "Text", "measurement")["display"].as_str().unwrap().to_string();
s.execute("dimangular", &json!({ "vertex": [0, 0], "p1": [10, 0], "p2": [0, 10], "at": [3, 3] })).unwrap();
let angle = last(&s);
assert_eq!(shown(&mut s, json!([angle])), "90°");
// In the dimension's angle format.
s.execute("properties.set", &json!({ "handles": [angle], "angularUnit": 3, "angularDecimals": 2 })).unwrap();
assert_eq!(shown(&mut s, json!([angle])), "1.57r");
// The same length written at two precisions varies.
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let a = last(&s);
s.execute("dimlinear", &json!({ "p1": [0, 20], "p2": [10, 20], "at": [5, 23] })).unwrap();
let b = last(&s);
assert_eq!(shown(&mut s, json!([a, b])), "10.0000");
s.execute("properties.set", &json!({ "handles": [b], "precision": 1 })).unwrap();
assert_eq!(shown(&mut s, json!([a, b])), "*VARIES*");
}
#[test]
fn rows_show_lengths_in_the_drawing_units() {
let mut s = Session::new();
s.execute("setvar", &json!({ "name": "LUNITS", "value": 4 })).unwrap();
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 18 })).unwrap());
let d = describe(&mut s, json!({ "handles": [t] }));
assert_eq!(row(&d, "Text", "height")["display"], "1'-6\"");
assert_eq!(row(&d, "Text", "height")["value"], 18.0);
}
#[test]
fn hostile_requests_never_panic() {
let mut s = Session::new();
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
for p in [json!({}), json!({ "handles": "x" }), json!({ "handles": [t, t, t] }), json!({ "handles": [t], "type": 5 }), json!({ "type": "Text" })]
{
let _ = s.execute("properties.describe", &p);
}
// Duplicates count once.
assert_eq!(describe(&mut s, json!({ "handles": [t, t] }))["count"], 1);
}
#[test]
fn rotations_show_as_the_drawing_measures_directions() {
let mut s = Session::new();
s.execute("text", &json!({ "at": [0, 0], "text": "N", "height": 1, "rotation": 2.22729505553431 })).unwrap();
// Clockwise from north (ANGBASE 90, ANGDIR 1): AutoCAD shows the text turned 2.23° as 87.77
// (#1275); the value stays from +X counterclockwise, as properties.set takes it.
for (name, value) in [("ANGDIR", json!(1)), ("ANGBASE", json!(90)), ("AUPREC", json!(2))] {
s.execute("setvar", &json!({ "name": name, "value": value })).unwrap();
}
let h = last(&s);
let desc = describe(&mut s, json!({ "handles": [h] }));
let r = row(&desc, "Text", "rotation");
assert_eq!(r["kind"], "direction");
assert_eq!(r["display"], "87.77");
assert!((r["value"].as_f64().unwrap() - 2.22729505553431).abs() < 1e-9);
}
#[test]
fn empty_arrowheads_read_as_the_ones_drawn() {
use cadcraft_engine::doc::DimStyle;
use cadcraft_engine::properties::{DIM_PROPS, dim_value};
let st = serde_json::to_value(DimStyle { arrow_block: "_DOT".into(), ..DimStyle::default() }).unwrap();
let p = |field: &str| DIM_PROPS.iter().find(|p| p.field == field).unwrap();
// An empty per-end arrowhead draws DIMBLK's; an empty leader arrowhead is closed filled.
assert_eq!(dim_value(p("arrowBlock1"), &st), json!("_DOT"));
assert_eq!(dim_value(p("arrowBlock"), &st), json!("_DOT"));
assert_eq!(dim_value(p("leaderArrowBlock"), &st), json!(""));
}
/// Float noise is no difference between two objects' values (7 and 7.0000000000001), but values
/// the display rounds alike still vary (7 and 7.000001 both show as 7.0000).
#[test]
fn float_noise_does_not_vary_but_a_real_difference_does() {
let mut s = Session::new();
let a = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 7.0 })).unwrap());
let b = handle(&s.execute("text", &json!({ "at": [0, 5], "text": "B", "height": 7.0 + 1e-13 })).unwrap());
let both = describe(&mut s, json!({ "handles": [a.clone(), b.clone()] }));
let h = row(&both, "Text", "height");
assert_eq!((h["varies"].as_bool(), h["display"].as_str()), (Some(false), Some("7.0000")));
s.execute("properties.set", &json!({ "handles": [b.clone()], "height": 7.000001 })).unwrap();
let both = describe(&mut s, json!({ "handles": [a, b] }));
assert_eq!(row(&both, "Text", "height")["varies"], true);
}
@@ -0,0 +1,366 @@
//! `properties.set` for text, mtext and dimensions: the edits the Properties palette makes, keys
//! nobody took coming back as `ignored`, and style edits reaching dimensions read from files.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, HAlign, Handle, MText, Text};
use serde_json::{Value, json};
fn handle(r: &Value) -> String {
r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap().to_string()
}
fn last(s: &Session) -> String {
s.doc().unwrap().model.last().unwrap().handle.hex()
}
fn set(s: &mut Session, h: &str, p: Value) -> Value {
let mut p = p;
p["handles"] = json!([h]);
s.execute("properties.set", &p).unwrap()
}
fn text(s: &Session, h: &str) -> Text {
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
EntityKind::Text(t) => t.clone(),
k => panic!("not text: {k:?}"),
}
}
fn mtext(s: &Session, h: &str) -> MText {
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
EntityKind::MText(t) => t.clone(),
k => panic!("not mtext: {k:?}"),
}
}
fn dim(s: &Session, h: &str) -> cadcraft_engine::doc::Dimension {
match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind {
EntityKind::Dimension(d) => d.clone(),
k => panic!("not a dimension: {k:?}"),
}
}
fn near(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-9
}
#[test]
fn text_style_justify_oblique_and_position() {
let mut s = Session::new();
s.execute("style", &json!({ "name": "Notes", "current": false })).unwrap();
let t = handle(&s.execute("text", &json!({ "at": [5, 5], "text": "Hello", "height": 2 })).unwrap());
let r = set(&mut s, &t, json!({ "style": "notes", "oblique": 15, "bogus": 1 }));
assert_eq!(r["ignored"], json!(["bogus"]));
assert_eq!(text(&s, &t).style, "Notes");
assert!(near(text(&s, &t).oblique.to_degrees(), 15.0));
// A style that doesn't exist is refused; an oblique past 85 degrees is ignored.
assert!(s.execute("properties.set", &json!({ "handles": [t], "style": "Nope" })).is_err());
assert_eq!(set(&mut s, &t, json!({ "oblique": 90 }))["ignored"], json!(["oblique"]));
// Justify keeps the point the text is placed by: the text moves around it.
set(&mut s, &t, json!({ "justify": "MC" }));
let j = text(&s, &t);
assert_eq!((j.halign, j.justify_point().x, j.justify_point().y), (HAlign::Center, 5.0, 5.0));
// Position X moves the text along X only.
set(&mut s, &t, json!({ "positionX": 20 }));
let j = text(&s, &t);
assert_eq!((j.justify_point().x, j.justify_point().y), (20.0, 5.0));
// Fit puts the second point at the end of the text, along its rotation.
set(&mut s, &t, json!({ "justify": "Fit" }));
let f = text(&s, &t);
let end = f.align_pt.unwrap();
assert!(f.halign == HAlign::Fit && near(f.insert.x, 20.0) && end.x > 20.0 && near(end.y, 5.0), "{f:?}");
// The second point alone (the text refits between them).
set(&mut s, &t, json!({ "alignmentX": 40 }));
assert!(near(text(&s, &t).align_pt.unwrap().x, 40.0) && near(text(&s, &t).insert.x, 20.0));
// Back to left: one point, where the fit text started.
set(&mut s, &t, json!({ "justify": "Left" }));
let l = text(&s, &t);
assert!(l.align_pt.is_none() && near(l.insert.x, 20.0));
// Alignment points belong to aligned and fit text only.
assert_eq!(set(&mut s, &t, json!({ "alignmentX": 1 }))["ignored"], json!(["alignmentX"]));
}
#[test]
fn mtext_style_justify_and_line_spacing() {
let mut s = Session::new();
s.execute("style", &json!({ "name": "Notes", "current": false })).unwrap();
let m = handle(&s.execute("mtext", &json!({ "at": [0, 10], "text": "one\\Ptwo", "height": 3, "width": 40 })).unwrap());
set(&mut s, &m, json!({ "style": "Notes", "justify": "MC", "lineSpacing": 2, "lineSpacingStyle": "Exactly" }));
let t = mtext(&s, &m);
assert_eq!((t.style.as_str(), t.attach, t.line_spacing, t.line_spacing_exact), ("Notes", 5, 2.0, true));
// The attachment point stays put.
assert!(near(t.insert.x, 0.0) && near(t.insert.y, 10.0));
// MTEXT's factors run from 0.25 to 4.
assert_eq!(set(&mut s, &m, json!({ "lineSpacing": 10 }))["ignored"], json!(["lineSpacing"]));
// A distance between lines sets the factor: factor × height × 5/3.
set(&mut s, &m, json!({ "lineSpacingDistance": 7.5 }));
assert!(near(mtext(&s, &m).line_spacing, 1.5));
set(&mut s, &m, json!({ "lineSpacingStyle": "atLeast", "positionX": 4, "positionY": 6 }));
let t = mtext(&s, &m);
assert!(!t.line_spacing_exact && near(t.insert.x, 4.0) && near(t.insert.y, 6.0));
}
#[test]
fn dimension_variables_become_overrides_of_each_dimension() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
set(&mut s, &dm, json!({ "textHeight": 0.3 }));
assert_eq!(dim(&s, &dm).overrides.get("textHeight"), Some(&json!(0.3)));
let geometry = |s: &Session| cadcraft_engine::render::dimension_in(s.doc().unwrap(), &dim(s, &dm));
assert!(near(geometry(&s).text_height, 0.3));
// A DIM* name replaces the override under its field name.
set(&mut s, &dm, json!({ "DIMTXT": 0.25, "DIMGAP": 0.05 }));
let o = dim(&s, &dm).overrides;
assert_eq!((o.len(), o.get("textHeight"), o.get("textGap")), (2, Some(&json!(0.25)), Some(&json!(0.05))));
// Clear one, then all.
set(&mut s, &dm, json!({ "clear": ["DIMGAP"] }));
assert_eq!(dim(&s, &dm).overrides.keys().collect::<Vec<_>>(), ["textHeight"]);
set(&mut s, &dm, json!({ "clearOverrides": true }));
assert!(dim(&s, &dm).overrides.is_empty());
assert!(near(geometry(&s).text_height, 0.18));
// Bad values and unknown text styles don't become overrides.
// An unusable text height is refused (as Properties' dimension rows refuse it, #1473).
assert!(s.execute("properties.set", &json!({ "handles": [dm], "textHeight": -1 })).is_err());
assert!(s.execute("properties.set", &json!({ "handles": [dm], "textStyle": "Nope" })).is_err());
assert!(dim(&s, &dm).overrides.is_empty());
// A refused call makes no layer either.
assert!(s.execute("properties.set", &json!({ "handles": [dm], "layer": "Notes", "dimStyle": "Nope" })).is_err());
assert!(s.doc().unwrap().layer("Notes").is_none());
}
#[test]
fn closed_filled_for_one_end_is_drawn_whatever_dimblk_says() {
let mut s = Session::new();
s.execute("dimstyle", &json!({ "name": "Ticks", "arrowBlock": "_ARCHTICK" })).unwrap();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
// Closed filled is "" among the arrowheads; for one end it's named, as "" there is DIMBLK's.
set(&mut s, &dm, json!({ "arrowBlock1": "" }));
assert_eq!(dim(&s, &dm).overrides.get("arrowBlock1"), Some(&json!("_CLOSEDFILLED")));
let rows = s.execute("properties.describe", &json!({ "handles": [dm] })).unwrap();
let arrow = |key: &str| {
rows["groups"].as_array().unwrap().iter().flat_map(|g| g["rows"].as_array().unwrap()).find(|r| r["key"] == key).unwrap()["value"].clone()
};
assert_eq!((arrow("arrowBlock1"), arrow("arrowBlock2")), (json!(""), json!("_ARCHTICK")));
}
#[test]
fn dimension_text_rows() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
set(&mut s, &dm, json!({ "prefix": "~", "suffix": " mm", "textRotation": 30, "textPositionX": 2 }));
let d = dim(&s, &dm);
assert_eq!(d.overrides.get("post"), Some(&json!("~<> mm")));
assert!(near(d.text_rotation.to_degrees(), 30.0));
assert!(d.user_text_pos && near(d.text_mid.x, 2.0));
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &d);
assert!(g.value.starts_with('~') && g.value.ends_with(" mm"), "{}", g.value);
// A suffix alone keeps the prefix.
set(&mut s, &dm, json!({ "suffix": "" }));
assert_eq!(dim(&s, &dm).overrides.get("post"), Some(&json!("~<>")));
// Together with other edits, the prefix goes into what those leave: here no suffix override.
set(&mut s, &dm, json!({ "suffix": " mm" }));
set(&mut s, &dm, json!({ "clearOverrides": true, "prefix": "=" }));
assert_eq!(dim(&s, &dm).overrides.get("post"), Some(&json!("=<>")));
// The prefix and suffix rows are DIMPOST's halves: overridden with it, reset with it.
let rows = s.execute("properties.describe", &json!({ "handles": [dm] })).unwrap();
let prefix =
rows["groups"].as_array().unwrap().iter().flat_map(|g| g["rows"].as_array().unwrap()).find(|r| r["key"] == "prefix").unwrap().clone();
assert_eq!(prefix["overridden"], true, "{prefix}");
set(&mut s, &dm, json!({ "clear": ["prefix"] }));
assert!(dim(&s, &dm).overrides.get("post").is_none());
}
#[test]
fn rotating_aligned_text_turns_its_baseline() {
let mut s = Session::new();
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "Wide", "height": 1 })).unwrap());
set(&mut s, &t, json!({ "justify": "Align" }));
let long = text(&s, &t).align_pt.unwrap().x;
assert!(long > 0.0);
set(&mut s, &t, json!({ "rotation": 90 }));
let end = text(&s, &t).align_pt.unwrap();
assert!(near(end.x, 0.0) && near(end.y, long), "{end:?}");
}
#[test]
fn justify_in_one_call_with_other_edits_takes_them_in() {
// Fit with new contents measures the new text; with a rotation, the baseline runs along it.
let mut s = Session::new();
let short = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
let long = handle(&s.execute("text", &json!({ "at": [0, 5], "text": "Much longer", "height": 1 })).unwrap());
set(&mut s, &long, json!({ "justify": "Fit" }));
set(&mut s, &short, json!({ "text": "Much longer", "justify": "Fit", "rotation": 90 }));
let (a, b) = (text(&s, &short), text(&s, &long));
let len = |t: &Text| t.insert.xy().dist(t.align_pt.unwrap().xy());
assert!(near(len(&a), len(&b)), "{} {}", len(&a), len(&b));
let end = a.align_pt.unwrap();
assert!(near(end.x, 0.0) && end.y > 0.0, "{end:?}");
}
#[test]
fn scale_is_no_dimension_override() {
// `scale` is an insert's or hatch's; a dimension's overall scale is `dimScale`.
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
assert_eq!(set(&mut s, &dm, json!({ "scale": 2 }))["ignored"], json!(["scale"]));
assert!(dim(&s, &dm).overrides.is_empty());
}
#[test]
fn making_a_style_current_keeps_the_dimensions_read_from_a_file() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
s.open_drawing(back, "dims", None);
let dm = last(&s);
assert!(dim(&s, &dm).block.is_some());
// No field changes: the geometry the file stored stays.
s.execute("dimstyle", &json!({ "name": "Standard" })).unwrap();
s.execute("style", &json!({ "name": "Standard" })).unwrap();
assert!(dim(&s, &dm).block.is_some());
// A change redraws it.
s.execute("dimstyle", &json!({ "name": "Standard", "DIMTXT": 0.3 })).unwrap();
assert!(dim(&s, &dm).block.is_none());
}
#[test]
fn hatch_pattern_edits_go_as_hatchedits_do() {
let mut s = Session::new();
s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
s.execute("gradient", &json!({ "points": [[5, 5]], "color1": "1", "color2": "3" })).unwrap();
let h = s.doc().unwrap().model.iter().find(|e| matches!(e.kind, EntityKind::Hatch(_))).unwrap().handle.hex();
let hatch = |s: &Session| match &s.doc().unwrap().entity(Handle::parse_hex(&h).unwrap()).unwrap().kind {
EntityKind::Hatch(x) => x.clone(),
k => panic!("not a hatch: {k:?}"),
};
assert!(hatch(&s).gradient.is_some());
// SOLID is a plain fill, not the gradient.
set(&mut s, &h, json!({ "pattern": "SOLID" }));
assert!(hatch(&s).solid && hatch(&s).gradient.is_none());
// A blank name changes nothing.
assert_eq!(set(&mut s, &h, json!({ "pattern": " " }))["ignored"], json!(["pattern"]));
assert_eq!(hatch(&s).pattern, "SOLID");
// A name no pattern has is refused, as HATCHEDIT refuses it; a defined one is taken.
assert!(s.execute("properties.set", &json!({ "handles": [h], "pattern": "ANSI3" })).is_err());
assert_eq!(hatch(&s).pattern, "SOLID");
set(&mut s, &h, json!({ "pattern": "ansi31" }));
assert_eq!(hatch(&s).pattern, "ANSI31");
}
#[test]
fn an_object_that_is_not_there_refuses_the_whole_call() {
let mut s = Session::new();
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
assert!(s.execute("properties.set", &json!({ "handles": [t, "FFFFF"], "height": 3, "layer": "Notes" })).is_err());
assert_eq!(text(&s, &t).height, 1.0);
assert!(s.doc().unwrap().layer("Notes").is_none());
}
#[test]
fn edits_of_a_dimension_read_from_a_file_redraw_it() {
let mut s = Session::new();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
// Read back from DXF, a dimension draws the block it was saved with.
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
s.open_drawing(back, "dims", None);
let dm = last(&s);
assert!(dim(&s, &dm).block.is_some());
// Nothing changed: the block stays.
set(&mut s, &dm, json!({ "clear": [], "color": "ByLayer" }));
assert!(dim(&s, &dm).block.is_some());
set(&mut s, &dm, json!({ "textHeight": 0.4 }));
assert!(dim(&s, &dm).block.is_none());
}
#[test]
fn style_edits_redraw_dimensions_read_from_a_file() {
let mut s = Session::new();
s.execute("style", &json!({ "name": "DimText", "current": false })).unwrap();
s.execute("dimstyle", &json!({ "name": "Plan", "textStyle": "DimText" })).unwrap();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
s.execute("dimstyle", &json!({ "name": "Other" })).unwrap();
s.execute("dimlinear", &json!({ "p1": [0, 10], "p2": [10, 10], "at": [5, 13] })).unwrap();
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
s.open_drawing(back, "dims", None);
let dims: Vec<(String, cadcraft_engine::doc::Dimension)> = s
.doc()
.unwrap()
.model
.iter()
.filter_map(|e| if let EntityKind::Dimension(d) = &e.kind { Some((e.handle.hex(), d.clone())) } else { None })
.collect();
let plan = dims.iter().find(|(_, d)| d.style == "Plan").unwrap().0.clone();
let other = dims.iter().find(|(_, d)| d.style == "Other").unwrap().0.clone();
assert!(dim(&s, &plan).block.is_some() && dim(&s, &other).block.is_some());
// Editing a dimension style redraws the dimensions that use it, and only those.
s.execute("dimstyle", &json!({ "name": "Plan", "DIMTXT": 0.5, "current": false })).unwrap();
assert!(dim(&s, &plan).block.is_none() && dim(&s, &other).block.is_some());
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &dim(&s, &plan));
assert!(near(g.text_height, 0.5));
// Editing a text style redraws the dimensions whose text uses it.
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(s.doc().unwrap()).as_bytes()).unwrap();
s.open_drawing(back, "dims", None);
let plan = s.doc().unwrap().model.iter().find(|e| matches!(&e.kind, EntityKind::Dimension(d) if d.style == "Plan")).unwrap().handle.hex();
assert!(dim(&s, &plan).block.is_some());
s.execute("style", &json!({ "name": "DimText", "widthFactor": 0.8, "current": false })).unwrap();
assert!(dim(&s, &plan).block.is_none());
}
#[test]
fn renaming_a_text_style_follows_dimension_overrides() {
let mut s = Session::new();
s.execute("style", &json!({ "name": "Old", "current": false })).unwrap();
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
set(&mut s, &dm, json!({ "textStyle": "Old" }));
s.execute("style.rename", &json!({ "from": "Old", "to": "New" })).unwrap();
assert_eq!(dim(&s, &dm).overrides.get("textStyle"), Some(&json!("New")));
// A style only a dimension override names is in use: it can't be deleted.
assert!(s.execute("style.delete", &json!({ "name": "New" })).is_err());
}
#[test]
fn hostile_values_never_panic() {
let mut s = Session::new();
let t = handle(&s.execute("text", &json!({ "at": [0, 0], "text": "A", "height": 1 })).unwrap());
let m = handle(&s.execute("mtext", &json!({ "at": [0, 5], "text": "B", "height": 1 })).unwrap());
s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [10, 0], "at": [5, 3] })).unwrap();
let dm = last(&s);
for v in [json!(null), json!("x"), json!(1e308), json!(-1e308), json!([1, 2]), json!({ "a": 1 }), json!(true)] {
let mut p = json!({ "handles": [t, m, dm] });
for k in [
"justify",
"oblique",
"positionX",
"positionZ",
"alignmentX",
"lineSpacing",
"lineSpacingDistance",
"lineSpacingStyle",
"textRotation",
"textPositionX",
"prefix",
"suffix",
"altPrefix",
"clear",
"clearOverrides",
"DIMTXT",
"DIMBLK1",
"DIMCLRT",
"DIMLWD",
"DIMLTYPE",
] {
p[k] = v.clone();
}
let _ = s.execute("properties.set", &p);
let _ = s.execute("properties.describe", &json!({ "handles": [t, m, dm] }));
}
// Every dimension still draws.
let g = cadcraft_engine::render::dimension_in(s.doc().unwrap(), &dim(&s, &dm));
assert!(g.text_height.is_finite());
}
+65 -1
View File
@@ -4,7 +4,7 @@
use std::sync::Arc;
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Block, Common, Entity, EntityKind, Handle, Insert, MLine, MLineJust, MLineStyle, Space};
use cadcraft_engine::doc::{Attrib, Block, Common, Entity, EntityKind, Handle, Insert, MLine, MLineElement, MLineJust, MLineStyle, Space};
use cadcraft_engine::geom::{Vec2, Vec3};
use serde_json::json;
@@ -75,3 +75,67 @@ fn purge_mlinestyles_at_the_command_line() {
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(styles(&s), ["STANDARD", "Model", "InBlock", "Gone", "Current"]);
}
/// A linetype is in use when only a dimension style, a dimension override, a multiline style, a
/// multiline's copy of its style or an attribute override names it.
#[test]
fn linetypes_named_by_styles_and_attributes_are_kept() {
let mut s = session();
let d = s.doc_mut().unwrap();
for name in ["InDimStyle", "InOverride", "InMline", "InMlineCopy", "InAttribute", "Unused"] {
let mut lt = d.linetypes[0].clone();
lt.name = name.into();
d.linetypes.push(lt);
}
d.dim_styles[0].ext_linetype2 = "InDimStyle".into();
let element = MLineElement { linetype: "InMline".into(), ..MLineElement::default() };
d.mline_styles.iter_mut().for_each(|t| t.elements.push(element.clone()));
let at = serde_json::to_value(Vec3::ZERO).unwrap();
let mut attrib: Attrib = serde_json::from_value(json!({ "tag": "A", "text": { "insert": at, "height": 1.0, "value": "1" } })).unwrap();
attrib.props.linetype = Some("InAttribute".into());
let Some(EntityKind::Insert(mut ins)) = d.model.iter().find_map(|e| matches!(e.kind, EntityKind::Insert(_)).then(|| e.kind.clone())) else {
return;
};
ins.attribs.push(attrib);
d.add(&Space::Model, Common::default(), EntityKind::Insert(ins)).unwrap();
let copy = MLineElement { linetype: "InMlineCopy".into(), ..MLineElement::default() };
let drawn = MLineStyle { name: "Model".into(), elements: vec![copy], ..MLineStyle::default() };
d.add(&Space::Model, Common::default(), mline(&drawn)).unwrap();
let dim = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap();
let handle = dim["handle"].clone();
s.execute("dimoverride", &json!({ "handles": [handle], "DIMLTYPE": "InOverride" })).unwrap();
s.execute("purge", &json!({ "type": "linetypes" })).unwrap();
let names: Vec<String> = s.doc().unwrap().linetypes.iter().map(|l| l.name.clone()).collect();
for kept in ["InDimStyle", "InOverride", "InMline", "InMlineCopy", "InAttribute"] {
assert!(names.iter().any(|n| n == kept), "{kept}: {names:?}");
}
assert!(!names.iter().any(|n| n == "Unused"), "{names:?}");
}
/// A dimension override given as a number names a text style, linetype or arrowhead block all
/// the same (DIMOVERRIDE keeps the number, the dimension is drawn with it as text): PURGE keeps
/// them.
#[test]
fn numbers_in_dimension_overrides_name_what_they_use() {
let mut s = session();
let d = s.doc_mut().unwrap();
for name in ["123", "Spare"] {
let mut t = d.text_styles[0].clone();
t.name = name.into();
d.text_styles.push(t);
}
for name in ["7", "Spare"] {
let mut lt = d.linetypes[0].clone();
lt.name = name.into();
d.linetypes.push(lt);
}
d.blocks.insert("45".into(), Arc::new(Block::new("45")));
let h = s.execute("dimlinear", &json!({ "p1": [0, 0], "p2": [4, 0], "at": [2, 2] })).unwrap()["handle"].clone();
s.execute("dimoverride", &json!({ "handles": [h], "DIMTXSTY": 123, "DIMLTYPE": 7, "DIMBLK1": 45 })).unwrap();
let r = s.execute("purge", &json!({ "type": "all" })).unwrap();
let d = s.doc().unwrap();
assert!(d.text_style("123").is_some(), "{r}");
assert!(d.linetypes.iter().any(|l| l.name == "7"), "{r}");
assert!(d.block("45").is_some(), "{r}");
assert_eq!((r["purged"]["textstyles"].clone(), r["purged"]["linetypes"].clone()), (json!(["Spare"]), json!(["Spare"])), "{r}");
}
+21
View File
@@ -88,6 +88,27 @@ fn massprop_self_check_reports_skipped_objects() {
assert_eq!(sc["implausible"], json!([]));
}
/// REGION typed with nothing selected asks for objects, as in AutoCAD, instead of reporting
/// "0 Region(s) created."; with objects already selected it converts them at once.
#[test]
fn typed_region_asks_for_objects() {
let mut s = Session::new();
let r = h(&s.execute("rectang", &json!({"p1": [0, 0], "p2": [10, 4]})).unwrap());
s.set_selection(Vec::new());
s.cmdline("region").unwrap();
assert!(s.running.is_some(), "REGION should ask for objects: {}", s.prompt_text());
s.cmdline("l").unwrap();
s.cmdline("").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(matches!(s.doc().unwrap().entity(r).unwrap().kind, EntityKind::Region(_)));
// Preselected objects are converted at once.
let c = h(&s.execute("circle", &json!({"center": [20, 0], "radius": 2})).unwrap());
s.set_selection(vec![c]);
s.cmdline("region").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(matches!(s.doc().unwrap().entity(c).unwrap().kind, EntityKind::Region(_)));
}
/// Make `hd` invisible: it no longer counts towards the drawing extents.
fn hide(s: &mut Session, hd: Handle) {
s.doc_mut().unwrap().modify_entity(hd, |e| e.common.visible = false).unwrap();
+17
View File
@@ -128,6 +128,23 @@ fn hatch_uses_a_pattern_from_a_pat_file_and_keeps_its_definition() {
assert!(hatches(&s).pop().unwrap().pattern_lines.is_empty());
}
#[test]
fn properties_pattern_edits_keep_a_pat_files_definition() {
let mut s = Session::new();
s.execute("rectang", &json!({ "p1": [0, 0], "p2": [10, 10] })).unwrap();
s.execute("hatch", &json!({ "points": [[5, 5]], "pattern": "ANSI31", "patternText": PAT })).unwrap();
let hx = s.doc().unwrap().model.iter().find(|e| matches!(e.kind, EntityKind::Hatch(_))).unwrap().handle.hex();
// As HATCHEDIT: a loaded pattern brings its lines, and they stay.
s.execute("properties.set", &json!({ "handles": [hx], "pattern": "MYSTEPS" })).unwrap();
let h = hatches(&s).pop().unwrap();
assert_eq!((h.pattern.as_str(), h.pattern_lines.len()), ("MYSTEPS", 1));
// The same name again keeps them, and a library pattern drops them.
s.execute("properties.set", &json!({ "handles": [hx], "pattern": "mysteps" })).unwrap();
assert_eq!(hatches(&s).pop().unwrap().pattern_lines[0].dashes, [0.25, -0.25]);
s.execute("properties.set", &json!({ "handles": [hx], "pattern": "ANSI37" })).unwrap();
assert!(hatches(&s).pop().unwrap().pattern_lines.is_empty());
}
#[test]
fn hatch_pattern_prompt_takes_a_pat_file_name() {
let dir = TempDir::new("lin-pat");
+1
View File
@@ -11,6 +11,7 @@ workspace = true
[dependencies]
cadcraft-geom = { workspace = true }
craft-dxf = { workspace = true }
craft-font-catalog = { workspace = true }
craft-shx = { workspace = true }
skrifa = { workspace = true }
harfrust = { workspace = true }
+23 -338
View File
@@ -1,344 +1,29 @@
//! The shape pen program: vector length/direction bytes and special codes 0–14, run into
//! polylines. Bounded everywhere: subshape depth, location stack, steps, points, coordinates.
//!
//! - A byte with a non-zero high nibble is a vector: length (high nibble) in one of 16
//! directions (low nibble, counter-clockwise from east in 22.5° steps; the off-axis ones
//! are half-unit or unit steps on the minor axis).
//! - 0 end, 1 pen down, 2 pen up, 3/4 divide/multiply vector lengths by the next byte,
//! 5/6 push/pop the location, 7 subshape (one byte; two bytes high first in a Unicode font;
//! `0`, a two-byte number, base point, width and height in an extended big font),
//! 8 one X-Y displacement, 9 displacements up to (0,0), 10 octant arc (radius,
//! ±0SC: sign = clockwise, S start octant, C octants, 0 = 8), 11 fractional arc (start
//! offset, end offset, high and low radius, ±0SC; offsets in 1/256 of 45° from the octant
//! boundaries), 12 bulge arc (dx, dy, bulge: ±127 = semicircle), 13 bulge arcs up to (0,0),
//! 14 the next command is for vertical text only (dual-orientation fonts).
//! - Displacements and bulges are two's complement bytes; the arc direction byte keeps its
//! sign in the high bit.
use std::f64::consts::{FRAC_PI_4, TAU};
//! Map the shared SHX pen interpreter's neutral strokes into CAD geometry.
use super::{ShxFont, ShxGlyph, ShxKind};
use cadcraft_geom::Vec2;
use super::{ShxFont, ShxGlyph, ShxKind};
/// Subshape nesting (a cycle ends here).
const MAX_DEPTH: usize = 16;
/// Location stack (the format promises four).
const MAX_STACK: usize = 64;
/// Bytes run per glyph, subshapes included.
const MAX_STEPS: usize = 200_000;
/// Points per glyph.
const MAX_POINTS: usize = 50_000;
/// Coordinates in font units.
const MAX_COORD: f64 = 1.0e7;
/// Arc segments per full turn.
const ARC_STEPS: f64 = 64.0;
/// Why a program stops early: the glyph is then not drawn.
#[derive(Debug)]
pub(super) struct Broken;
type Res = Result<(), Broken>;
struct Pen<'a> {
font: &'a ShxFont,
vertical: bool,
pos: Vec2,
down: bool,
/// Vector length factor (codes 3 and 4).
scale: f64,
/// Per-axis factor of an extended big font subshape.
axes: Vec2,
stack: Vec<Vec2>,
strokes: Vec<Vec<Vec2>>,
active: Vec<Vec2>,
steps: usize,
points: usize,
}
pub(super) fn outline(font: &ShxFont, number: u16, vertical: bool) -> Result<ShxGlyph, Broken> {
let mut pen = Pen {
font,
vertical,
pos: Vec2::ZERO,
down: true,
scale: 1.0,
axes: Vec2::new(1.0, 1.0),
stack: Vec::new(),
strokes: Vec::new(),
active: Vec::new(),
steps: 0,
points: 0,
};
pen.run(number, 0)?;
pen.flush();
Ok(ShxGlyph { strokes: pen.strokes, advance: pen.pos })
}
/// The 16 vector directions (unit length on the major axis).
fn direction(d: u8) -> Vec2 {
let (x, y) = match d & 15 {
0 => (1.0, 0.0),
1 => (1.0, 0.5),
2 => (1.0, 1.0),
3 => (0.5, 1.0),
4 => (0.0, 1.0),
5 => (-0.5, 1.0),
6 => (-1.0, 1.0),
7 => (-1.0, 0.5),
8 => (-1.0, 0.0),
9 => (-1.0, -0.5),
10 => (-1.0, -1.0),
11 => (-0.5, -1.0),
12 => (0.0, -1.0),
13 => (0.5, -1.0),
14 => (1.0, -1.0),
_ => (1.0, -0.5),
};
Vec2::new(x, y)
}
/// A two's complement operand byte.
fn signed(b: u8) -> f64 {
f64::from(i8::from_le_bytes([b]))
}
/// A program being read: its bytes and position.
struct Cur<'p> {
b: &'p [u8],
pos: usize,
}
impl Cur<'_> {
fn byte(&mut self) -> Result<u8, Broken> {
let v = self.b.get(self.pos).copied().ok_or(Broken)?;
self.pos += 1;
Ok(v)
impl craft_shx::program::Font for ShxFont {
fn kind(&self) -> ShxKind {
self.kind
}
fn dual(&self) -> bool {
self.dual
}
fn above(&self) -> f64 {
self.above
}
fn char_width(&self) -> f64 {
self.char_width
}
fn program(&self, number: u16) -> Option<&[u8]> {
ShxFont::program(self, number)
}
}
impl Pen<'_> {
fn step(&mut self) -> Res {
self.steps += 1;
if self.steps > MAX_STEPS { Err(Broken) } else { Ok(()) }
}
fn flush(&mut self) {
if self.active.len() >= 2 {
self.strokes.push(std::mem::take(&mut self.active));
} else {
self.active.clear();
}
}
/// Move the pen by `d` font units (already scaled), drawing when the pen is down.
fn to(&mut self, target: Vec2) -> Res {
if !target.is_finite() || target.x.abs().max(target.y.abs()) > MAX_COORD {
return Err(Broken);
}
if self.down {
if self.active.is_empty() {
self.active.push(self.pos);
self.points += 1;
}
self.active.push(target);
self.points += 1;
if self.points > MAX_POINTS {
return Err(Broken);
}
} else {
self.flush();
}
self.pos = target;
Ok(())
}
/// A displacement in vector units (times the length factor and the subshape axes).
fn by(&mut self, d: Vec2) -> Res {
let k = d * self.scale;
self.to(self.pos + Vec2::new(k.x * self.axes.x, k.y * self.axes.y))
}
/// An arc of `radius` vector units from the pen, starting at angle `start` on its circle
/// and turning `sweep` radians (positive counter-clockwise).
fn arc(&mut self, radius: f64, start: f64, sweep: f64) -> Res {
let r = radius * self.scale;
if !(r.is_finite() && r > 0.0 && sweep.is_finite()) {
return Ok(());
}
let n = if self.down { (sweep.abs() / TAU * ARC_STEPS).ceil().clamp(1.0, ARC_STEPS) as usize } else { 1 };
let from = self.pos;
let s0 = Vec2::new(start.cos(), start.sin());
for i in 1..=n {
let a = start + sweep * i as f64 / n as f64;
let d = (Vec2::new(a.cos(), a.sin()) - s0) * r;
self.to(from + Vec2::new(d.x * self.axes.x, d.y * self.axes.y))?;
}
Ok(())
}
/// An arc to the displacement `d` with `bulge` (−127..127, ±127 a semicircle).
fn bulge(&mut self, d: Vec2, bulge: f64) -> Res {
let b = bulge.clamp(-127.0, 127.0) / 127.0;
if b == 0.0 || !self.down || d.len2() == 0.0 {
return self.by(d);
}
// Centre from the chord midpoint along its left normal; sweep 4·atan(b).
let centre = d * 0.5 + Vec2::new(-d.y, d.x) * ((1.0 - b * b) / (4.0 * b));
let rel = -centre;
self.arc(rel.len(), rel.y.atan2(rel.x), 4.0 * b.atan())
}
/// The octant byte `±0SC`: (clockwise, start octant, octants with 0 = 8).
fn octants(spec: u8) -> (f64, f64, f64) {
let sign = if spec & 0x80 != 0 { -1.0 } else { 1.0 };
let s = f64::from((spec >> 4) & 7);
let c = match spec & 7 {
0 => 8.0,
c => f64::from(c),
};
(sign, s, c)
}
/// The vector unit size of an extended big font's subshape cell.
fn cell(&self) -> Vec2 {
let h = if self.font.above > 0.0 { self.font.above } else { 1.0 };
let w = if self.font.char_width > 0.0 { self.font.char_width } else { h };
Vec2::new(w, h)
}
fn run(&mut self, number: u16, depth: usize) -> Res {
if depth >= MAX_DEPTH {
return Err(Broken);
}
let program = self.font.program(number).ok_or(Broken)?;
let mut r = Cur { b: program, pos: 0 };
let mut skip = false;
while r.pos < r.b.len() {
self.step()?;
let code = r.byte()?;
// Code 14: in a dual-orientation font the next command is for vertical text only.
let exec = !skip;
skip = false;
match code {
0 => return Ok(()),
1 if exec => self.down = true,
2 if exec => {
self.down = false;
self.flush();
}
3 | 4 => {
let k = f64::from(r.byte()?);
if exec && k > 0.0 {
let s = if code == 3 { self.scale / k } else { self.scale * k };
if !(1e-9..=MAX_COORD).contains(&s) {
return Err(Broken);
}
self.scale = s;
}
}
5 if exec => {
if self.stack.len() >= MAX_STACK {
return Err(Broken);
}
self.stack.push(self.pos);
}
6 if exec => {
self.flush();
if let Some(p) = self.stack.pop() {
self.pos = p;
}
}
7 => self.subshape(&mut r, exec, depth)?,
8 | 9 | 12 | 13 => loop {
self.step()?;
let d = Vec2::new(signed(r.byte()?), signed(r.byte()?));
if matches!(code, 9 | 13) && d == Vec2::ZERO {
break;
}
let bulge = if matches!(code, 12 | 13) { signed(r.byte()?) } else { 0.0 };
if exec {
self.bulge(d, bulge)?;
}
if matches!(code, 8 | 12) {
break;
}
},
10 => {
let radius = f64::from(r.byte()?);
let (sign, s, c) = Self::octants(r.byte()?);
if exec {
self.arc(radius, s * FRAC_PI_4, sign * c * FRAC_PI_4)?;
}
}
11 => {
let start = f64::from(r.byte()?) / 256.0;
let end = match r.byte()? {
0 => 1.0,
e => f64::from(e) / 256.0,
};
let radius = f64::from(u16::from_be_bytes([r.byte()?, r.byte()?]));
let (sign, s, c) = Self::octants(r.byte()?);
if exec {
// From `start` past the first octant boundary to `end` past the last
// octant's.
self.arc(radius, (s + sign * start) * FRAC_PI_4, sign * (c - 1.0 + end - start) * FRAC_PI_4)?;
}
}
14 => skip = self.font.dual && !self.vertical && exec,
1..=15 => {}
v => {
if exec {
self.by(direction(v) * f64::from(v >> 4))?;
}
}
}
}
Ok(())
}
/// Code 7 and its operands.
fn subshape(&mut self, r: &mut Cur, exec: bool, depth: usize) -> Res {
match self.font.kind {
ShxKind::Unifont => {
let n = u16::from_be_bytes([r.byte()?, r.byte()?]);
if exec {
self.run(n, depth + 1)?;
}
}
ShxKind::BigFont => {
let first = r.byte()?;
if first != 0 {
if exec {
self.run(u16::from(first), depth + 1)?;
}
return Ok(());
}
// Extended: the primitive drawn in the box (x, y, width, height) of the cell.
let n = u16::from_be_bytes([r.byte()?, r.byte()?]);
let (x, y, w, h) = (f64::from(r.byte()?), f64::from(r.byte()?), f64::from(r.byte()?), f64::from(r.byte()?));
if !exec {
return Ok(());
}
let (pos, axes, down) = (self.pos, self.axes, self.down);
let cell = self.cell();
self.flush();
self.pos = pos + Vec2::new(x * axes.x, y * axes.y) * self.scale;
self.axes = Vec2::new(axes.x * w / cell.x, axes.y * h / cell.y);
let res = self.run(n, depth + 1);
self.flush();
self.axes = axes;
self.pos = pos;
self.down = down;
res?;
}
ShxKind::Shapes => {
let n = u16::from(r.byte()?);
if exec {
self.run(n, depth + 1)?;
}
}
}
Ok(())
}
pub(super) fn outline(font: &ShxFont, number: u16, vertical: bool) -> Result<ShxGlyph, craft_shx::program::Broken> {
let glyph = craft_shx::program::outline(font, number, vertical)?;
Ok(ShxGlyph {
strokes: glyph.strokes.into_iter().map(|stroke| stroke.into_iter().map(|p| Vec2::new(p.x, p.y)).collect()).collect(),
advance: Vec2::new(glyph.advance.x, glyph.advance.y),
})
}
+2 -38
View File
@@ -3,50 +3,14 @@
//! never embedded; callers draw their text as outlines instead. Fonts without TrueType outlines
//! (CFF-flavoured OpenType) aren't embedded either.
use skrifa::FontRef;
use skrifa::raw::types::Tag;
use crate::ttf::Face;
/// Whether a face may be embedded as a subset.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Embedding {
/// Installable, editable or preview & print embedding (or no OS/2 table).
Allowed,
/// `fsType` restricted licence: no embedding.
Restricted,
/// `fsType` bit 8: the font may only be embedded whole.
NoSubsetting,
/// `fsType` bit 9: only bitmaps may be embedded.
BitmapOnly,
/// No TrueType outlines (`glyf` / `loca`), or the font doesn't parse.
NotTrueType,
}
fn table<'a>(f: &FontRef<'a>, t: [u8; 4]) -> Option<&'a [u8]> {
f.table_data(Tag::new(&t)).map(|d| d.as_bytes())
}
fn u16_at(b: &[u8], i: usize) -> Option<u16> {
Some(u16::from_be_bytes([*b.get(i)?, *b.get(i + 1)?]))
}
pub use craft_font_catalog::SubsetEmbedding as Embedding;
/// The embedding permission of a face.
pub fn embedding(face: &Face) -> Embedding {
let Ok(f) = FontRef::from_index(&face.bytes, face.index) else { return Embedding::NotTrueType };
if table(&f, *b"glyf").is_none() || table(&f, *b"loca").is_none() || table(&f, *b"head").is_none() {
return Embedding::NotTrueType;
}
let Some(fs_type) = table(&f, *b"OS/2").and_then(|o| u16_at(o, 8)) else { return Embedding::Allowed };
if fs_type & 0x0200 != 0 {
Embedding::BitmapOnly
} else if fs_type & 0x000F == 0x0002 {
Embedding::Restricted
} else if fs_type & 0x0100 != 0 {
Embedding::NoSubsetting
} else {
Embedding::Allowed
}
craft_font_catalog::subset_embedding(&face.bytes, face.index)
}
#[cfg(test)]
+2 -2
View File
@@ -14,17 +14,17 @@ cadcraft-color = { workspace = true }
cadcraft-doc = { workspace = true }
craft-dxf = { workspace = true }
craft-dwg = { workspace = true }
craft-svg = { workspace = true }
craft-image-codecs = { workspace = true }
cadcraft-render = { workspace = true }
cadcraft-fonts = { workspace = true }
thiserror = { workspace = true }
serde_json = { workspace = true }
serde = { workspace = true }
miniz_oxide = "0.9"
craft-pdf = { workspace = true, features = ["write"] }
quick-xml = { workspace = true }
[dev-dependencies]
miniz_oxide = "0.9"
tiff = "0.11"
image = { workspace = true }
tiny-skia = { workspace = true }
+31
View File
@@ -455,6 +455,10 @@ pub(crate) fn read(secs: &[Section], d: &mut Drawing) {
}
if !f.is_empty() {
f.version = file_version(secs);
}
// The file's handles of the objects CADCraft writes itself (AutoLISP's `handent`).
f.handles = ids.iter().filter(|(h, _)| !ents.contains_key(*h)).filter_map(|(h, k)| Some((handle(h)?, k.clone()))).take(MAX_OBJECTS).collect();
if !f.is_empty() || !f.handles.is_empty() {
d.foreign = Arc::new(f);
}
}
@@ -771,6 +775,33 @@ fn written_records(tags: &[Tag]) -> Vec<Rec> {
out
}
/// A non-graphic record as written: its type, its groups after the type (its handle in group 5)
/// and its role when it has one.
pub type ObjectRecord = (String, Vec<Tag>, Option<ForeignKey>);
/// The drawing's non-graphic records as a DXF file of it holds them: the tables and their
/// records, the BLOCK records and the objects, in file order, each with its role (a table record,
/// a block, the named object dictionary or one of its entries) when it has one. Their handles are
/// the written file's: the same for the same drawing. AutoLISP's dictionary and table functions
/// (`namedobjdict`, `dictsearch`, `tblobjname`, `entget` of a non-graphic object) read it.
pub fn object_records(d: &Drawing) -> Vec<ObjectRecord> {
let tags = crate::dxf_write::tags(d, craft_dxf::Version::R2018);
let recs = written_records(&tags);
let body = |r: &Rec| tags.get(r.start + 1..r.end).unwrap_or(&[]);
let by_sec = |name: &str| -> Recs {
recs.iter().filter(|r| r.sec == name && r.kind != "SECTION" && r.kind != "ENDSEC").map(|r| (r.kind.clone(), r.start, body(r))).collect()
};
let (tables, blocks, objects) = (by_sec("TABLES"), by_sec("BLOCKS"), by_sec("OBJECTS"));
let ids = identities(&tables, &blocks, &objects);
let tables = tables.iter().filter(|(k, _, _)| k != "ENDTAB");
let blocks = blocks.iter().filter(|(k, _, _)| k == "BLOCK");
tables
.chain(blocks)
.chain(objects.iter())
.map(|(kind, _, t)| (kind.clone(), t.to_vec(), head(t).handle.and_then(|h| ids.get(&h).cloned())))
.collect()
}
/// Remaps the kept data's handles onto a written file.
struct Map<'a> {
f: &'a Foreign,
+1
View File
@@ -32,6 +32,7 @@ use std::path::{Path, PathBuf};
pub use cadcraft_doc::Format;
pub use craft_dxf::Version;
pub use dxf_raw::{ObjectRecord, object_records};
pub use dxf_read::entity_from_groups;
pub use dxf_write::entity_groups;
pub use pdf::{PdfOptions, pdf, plot};
+2 -12
View File
@@ -4,7 +4,7 @@
use crate::{IoError, Result};
use cadcraft_doc::Raster;
use craft_image_codecs::{ChannelLayout, DecodeOptions, DecodeWarning, EncodeOptions, Format, Image, Limits, PngRows, SampleType};
use craft_image_codecs::{ChannelLayout, DecodeOptions, DecodeWarning, Format, Limits, SampleType};
/// Largest image file read (bytes).
pub const MAX_IMAGE_BYTES: usize = 256 << 20;
@@ -61,17 +61,7 @@ pub fn decode(bytes: &[u8]) -> Result<Raster> {
/// `raster` as a PNG file, encoded in rows to avoid a full extra image copy.
pub fn encode_png(raster: &Raster) -> Result<Vec<u8>> {
let stride = usize::try_from(raster.width()).ok().and_then(|w| w.checked_mul(4)).filter(|s| *s > 0).ok_or_else(|| bad("invalid image width"))?;
let mut chunks = raster.rgba().chunks_exact(stride);
let first = chunks.next().ok_or_else(|| bad("the image is empty"))?;
let row = |data: &[u8]| Image::from_u8(raster.width(), 1, ChannelLayout::Rgba, data.to_vec()).map_err(bad);
let first = row(first)?;
let mut out = Vec::new();
let mut writer = PngRows::new(&mut out, &first, raster.height(), &EncodeOptions::default()).map_err(bad)?;
writer.push(&first).map_err(bad)?;
for chunk in chunks {
writer.push(&row(chunk)?).map_err(bad)?;
}
writer.finish().map_err(bad)?;
cadcraft_render::raster::write_rgba_png(&mut out, raster.width(), raster.height(), raster.rgba()).ok_or_else(|| bad("PNG encoding failed"))?;
Ok(out)
}
+48 -43
View File
@@ -1,7 +1,5 @@
//! SVG export of a space (vector, for the web and documents).
use std::fmt::Write as _;
use cadcraft_color::Rgb;
use cadcraft_doc::{Drawing, Space};
use cadcraft_geom::Bounds2;
@@ -25,12 +23,9 @@ pub fn export_window_with(d: &Drawing, space: &Space, window: Option<Bounds2>, t
export_list(&list, window)
}
/// ` opacity="…"` for a transparent primitive (none for an opaque one or a wipeout's mask).
fn opacity(p: &cadcraft_render::DPrim) -> String {
if p.kind == Kind::Mask || p.transparency == 0 {
return String::new();
}
format!(r#" opacity="{:.2}""#, f64::from(p.alpha()) / 255.0)
/// Opacity for a transparent primitive (none for an opaque one or a wipeout's mask).
fn opacity(p: &cadcraft_render::DPrim) -> Option<String> {
(p.kind != Kind::Mask && p.transparency != 0).then(|| format!("{:.2}", f64::from(p.alpha()) / 255.0))
}
/// Write a display list (as [`export_window`] does for a space's own).
@@ -59,13 +54,15 @@ pub fn export_list(list: &cadcraft_render::DisplayList, window: Option<Bounds2>)
let stroke = vw.max(vh) / 1500.0;
// Decimals: at least 6, more when the stroke would otherwise lose its leading digits.
let dp = (3.0 - stroke.log10().floor()).clamp(6.0, 15.0) as usize;
let mut s = String::new();
let _ = write!(
s,
r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {vw:.dp$} {vh:.dp$}" width="{:.0}" height="{:.0}"><rect width="100%" height="100%" fill="white"/>"#,
1600.0,
1600.0 * vh / vw
);
use craft_svg::write::{SvgWriter, num};
let mut writer = SvgWriter::fragment();
writer
.root()
.attr("viewBox", format!("0 0 {} {}", num(vw, dp), num(vh, dp)))
.attr("width", format!("{:.0}", 1600.0))
.attr("height", format!("{:.0}", 1600.0 * vh / vw))
.open();
writer.tag("rect").attr("width", "100%").attr("height", "100%").attr("fill", "white").empty();
let white = Rgb(255, 255, 255);
let tx = |x: f64| x - x0;
let ty = |y: f64| y1 - y;
@@ -75,52 +72,60 @@ pub fn export_list(list: &cadcraft_render::DisplayList, window: Option<Bounds2>)
let pts = list.points(p);
match p.kind {
Kind::Polyline => {
let _ = write!(
s,
r#"<polyline fill="none" stroke="{c}"{op} stroke-width="{stroke:.dp$}" stroke-linecap="round" stroke-linejoin="round" points=""#
);
for q in pts {
let _ = write!(s, "{:.dp$},{:.dp$} ", tx(q.x), ty(q.y));
let points = craft_svg::drawing_write::points(pts.iter().map(|q| [tx(q.x), ty(q.y)]), dp);
let mut tag = writer.tag("polyline").attr("fill", "none").attr("stroke", &c);
if let Some(op) = &op {
tag = tag.attr("opacity", op);
}
s.push_str(r#""/>"#);
tag.attr("stroke-width", num(stroke, dp))
.attr("stroke-linecap", "round")
.attr("stroke-linejoin", "round")
.attr("points", points)
.empty();
}
Kind::Tris | Kind::Mask => {
// A wipeout's mask hides what lies under it with the white background.
let c = if p.kind == Kind::Mask { white.hex() } else { c };
let _ = write!(s, r#"<path fill="{c}"{op} d=""#);
for t in pts.chunks(3) {
if let [a, b2, cc] = t {
let _ =
write!(s, "M{:.dp$} {:.dp$}L{:.dp$} {:.dp$}L{:.dp$} {:.dp$}Z", tx(a.x), ty(a.y), tx(b2.x), ty(b2.y), tx(cc.x), ty(cc.y));
}
let triangles = pts
.chunks(3)
.filter_map(|t| if let [a, b, c] = t { Some([[tx(a.x), ty(a.y)], [tx(b.x), ty(b.y)], [tx(c.x), ty(c.y)]]) } else { None });
let path = craft_svg::drawing_write::triangles(triangles, dp);
let mut tag = writer.tag("path").attr("fill", &c);
if let Some(op) = &op {
tag = tag.attr("opacity", op);
}
s.push_str(r#""/>"#);
tag.attr("d", path).empty();
}
// Raster images are not written to SVG yet: their frame is.
Kind::Image { .. } => {}
Kind::Point => {
if let Some(q) = pts.first() {
let _ = write!(s, r#"<circle cx="{:.dp$}" cy="{:.dp$}" r="{:.dp$}" fill="{c}"{op}/>"#, tx(q.x), ty(q.y), stroke);
let mut tag =
writer.tag("circle").attr("cx", num(tx(q.x), dp)).attr("cy", num(ty(q.y), dp)).attr("r", num(stroke, dp)).attr("fill", &c);
if let Some(op) = &op {
tag = tag.attr("opacity", op);
}
tag.empty();
}
}
Kind::Infinite { ray } => {
if let (Some(bp), Some(dir)) = (pts.first(), pts.get(1)) {
// A window can lie far from the base point: reach past it.
let far = (vw + vh) * 2.0 + if window.is_some() { bp.dist(b.center()) } else { 0.0 };
let a = if ray { *bp } else { *bp - *dir * far };
let e = *bp + *dir * far;
let _ = write!(
s,
r#"<line x1="{:.dp$}" y1="{:.dp$}" x2="{:.dp$}" y2="{:.dp$}" stroke="{c}"{op} stroke-width="{stroke:.dp$}"/>"#,
tx(a.x),
ty(a.y),
tx(e.x),
ty(e.y)
);
let mut tag = writer
.tag("line")
.attr("x1", num(tx(a.x), dp))
.attr("y1", num(ty(a.y), dp))
.attr("x2", num(tx(e.x), dp))
.attr("y2", num(ty(e.y), dp))
.attr("stroke", &c);
if let Some(op) = &op {
tag = tag.attr("opacity", op);
}
tag.attr("stroke-width", num(stroke, dp)).empty();
}
}
}
}
s.push_str("</svg>");
s
writer.close();
writer.finish()
}
+101 -731
View File
@@ -13,14 +13,11 @@
//! line segments instead of losing the shape). What the drawing shows of those (all but fills,
//! gradients and patterns) is named in a read note, so it is never left out silently.
use std::collections::{BTreeMap, HashSet};
use std::collections::BTreeMap;
use cadcraft_color::Color;
use cadcraft_doc::{Circle, Common, Drawing, Ellipse, EntityKind, Layer, Line, LwPolyline, Space};
use cadcraft_geom::{Mat3, PolyVertex, Spline, Vec2, Vec3};
use quick_xml::Reader;
use quick_xml::XmlVersion;
use quick_xml::events::{BytesStart, Event};
use crate::{IoError, Result};
@@ -28,47 +25,20 @@ use crate::{IoError, Result};
const MAX_DECOMPRESSED: usize = 64 << 20;
/// Shape elements per file (rect, circle, path, …; each counted once).
const MAX_ELEMENTS: usize = 500_000;
/// Path data segments per `d` attribute.
const MAX_PATH_SEGMENTS: usize = 100_000;
/// Vertices in one polyline, and control points in one spline.
const MAX_CURVE_POINTS: usize = 100_001;
/// Layers created from Inkscape layer groups.
const MAX_LAYERS: usize = 256;
/// Nested `<g>`/`<svg>` transforms.
const MAX_TRANSFORM_DEPTH: usize = 64;
/// Flattened chords per elliptical arc under a non-uniform transform.
const MAX_ARC_CHORDS: usize = 10_000;
/// Generated vertices retained across the whole document (all paths and shapes), so repeated
/// arc/curve flattening cannot amplify a compact input into unbounded geometry.
const MAX_TOTAL_VERTS: usize = 8_000_000;
/// Elements whose whole subtree is skipped (paint servers, text, raster images, metadata).
const SKIP: &[&[u8]] = &[
b"defs",
b"symbol",
b"clipPath",
b"mask",
b"pattern",
b"marker",
b"linearGradient",
b"radialGradient",
b"filter",
b"style",
b"text",
b"image",
b"title",
b"desc",
b"metadata",
];
/// Elements that hold children and push a transform stack frame.
const CONTAINERS: &[&[u8]] = &[b"g", b"svg", b"a", b"switch"];
/// Read an SVG document, or a gzip-compressed one (`.svgz`, Inkscape's "Compressed SVG").
pub fn read(bytes: &[u8]) -> Result<Drawing> {
let unpacked;
let plain: &[u8] = if bytes.starts_with(&[0x1f, 0x8b]) {
unpacked = gunzip(bytes)?;
unpacked =
craft_svg::svgz::inflate(bytes, MAX_DECOMPRESSED).map_err(|_| IoError::Format("this SVGZ file's gzip stream is damaged".into()))?;
&unpacked
} else {
bytes
@@ -79,39 +49,6 @@ pub fn read(bytes: &[u8]) -> Result<Drawing> {
Ok(parser.drawing)
}
/// Decompress a gzip member (RFC 1952) with a hard output cap.
fn gunzip(bytes: &[u8]) -> Result<Vec<u8>> {
let damaged = || IoError::Format("this SVGZ file's gzip stream is damaged".into());
if bytes.get(2) != Some(&8) {
return Err(damaged());
}
let flg = bytes.get(3).copied().unwrap_or(0);
let mut pos = 10usize;
if flg & 0x04 != 0 {
// FEXTRA
let extra = bytes.get(pos..pos + 2).ok_or_else(damaged)?;
pos += 2 + usize::from(u16::from_le_bytes([extra[0], extra[1]]));
}
if flg & 0x08 != 0 {
pos = skip_cstring(bytes, pos).ok_or_else(damaged)?; // FNAME
}
if flg & 0x10 != 0 {
pos = skip_cstring(bytes, pos).ok_or_else(damaged)?; // FCOMMENT
}
if flg & 0x02 != 0 {
pos = pos.saturating_add(2); // FHCRC
}
let end = bytes.len().checked_sub(8).filter(|e| *e >= pos).ok_or_else(damaged)?;
miniz_oxide::inflate::decompress_to_vec_with_limit(&bytes[pos..end], MAX_DECOMPRESSED).map_err(|_| damaged())
}
/// Skip a NUL-terminated field; `None` when the terminator is missing.
fn skip_cstring(bytes: &[u8], from: usize) -> Option<usize> {
let rest = bytes.get(from..)?;
let nul = rest.iter().position(|b| *b == 0)?;
Some(from + nul + 1)
}
fn parse_err<E: std::fmt::Display>(e: E) -> IoError {
IoError::Format(format!("SVG: {e}"))
}
@@ -126,15 +63,11 @@ struct Parser {
stack: Vec<Mat3>,
/// Current Inkscape layer name.
layer: String,
layers: HashSet<String>,
layer_color: u8,
elements: usize,
/// Generated vertices still allowed across the whole document. Arc/curve flattening can turn
/// a compact path into many samples, and each flushed run is retained, so without a shared
/// budget repeated arcs amplify a small input into gigabytes of geometry (CWE-400).
verts_left: usize,
/// > 0 while inside a skipped subtree; counts the starts seen there.
skip: usize,
/// What was left out, by kind ([`LeftOut`]).
left_out: BTreeMap<LeftOut, usize>,
}
@@ -150,15 +83,6 @@ enum LeftOut {
}
impl LeftOut {
/// The kind of a skipped element ([`SKIP`]) that the drawing shows.
fn of(name: &[u8]) -> Option<Self> {
match name {
b"text" => Some(Self::Text),
b"image" => Some(Self::Image),
_ => None,
}
}
fn describe(self, n: usize) -> String {
let (one, many) = match self {
Self::Text => ("text", "texts"),
@@ -178,19 +102,12 @@ impl Parser {
drawing: Drawing::new_metric(),
stack: vec![Mat3::IDENTITY],
layer: "0".into(),
layers: HashSet::from(["0".to_string()]),
layer_color: 1,
elements: 0,
verts_left: MAX_TOTAL_VERTS,
skip: 0,
left_out: BTreeMap::new(),
}
}
fn left_out(&mut self, kind: LeftOut) {
*self.left_out.entry(kind).or_default() += 1;
}
/// The read note on what was left out, if anything was.
fn note(&self) -> Option<String> {
if self.left_out.is_empty() {
@@ -201,140 +118,85 @@ impl Parser {
}
fn parse(&mut self, text: &str) -> Result<()> {
let mut reader = Reader::from_str(text);
reader.config_mut().trim_text(true);
loop {
match reader.read_event().map_err(parse_err)? {
Event::Start(e) => {
let name = e.name();
self.on_start(name.into_inner().as_bytes(), &e)?;
use craft_svg::neutral_document::{self, Event, Skipped};
let mut failure = None;
let mut layer_color = 1u8;
let result = neutral_document::visit(text, &mut |event| {
let r = match event {
Event::Layer(name) => {
let color = Color::Index(layer_color);
layer_color = if layer_color >= 7 { 1 } else { layer_color + 1 };
self.drawing.layers.push(Layer { name, color, ..Layer::default() });
Ok(())
}
Event::Empty(e) => {
let name = e.name();
self.on_element(name.into_inner().as_bytes(), &e)?;
}
Event::End(e) => {
let name = e.name();
self.on_end(name.into_inner().as_bytes());
}
Event::Eof => break,
_ => {}
}
Event::Shape(shape) => self.map_shape(shape),
};
r.map_err(|e| {
failure = Some(e);
neutral_document::Error("CAD geometry mapping failed".into())
})
});
if let Some(e) = failure {
return Err(e);
}
let doc = result.map_err(|e| IoError::Format(e.to_string()))?;
for (kind, count) in doc.skipped {
let kind = match kind {
Skipped::Text => LeftOut::Text,
Skipped::Image => LeftOut::Image,
Skipped::Use => LeftOut::Use,
Skipped::Style => LeftOut::Style,
Skipped::RoundedCorners => LeftOut::RoundedCorners,
};
self.left_out.insert(kind, count);
}
self.drawing.read_notes.extend(self.note());
Ok(())
}
/// A start tag: open a transform frame, descend into a skipped subtree, or treat a
/// shape written as start+end the same as a self-closed one.
fn on_start(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
// A style sheet applies wherever it is (Inkscape keeps it in `<defs>`).
if name == b"style" {
self.left_out(LeftOut::Style);
fn map_shape(&mut self, shape: craft_svg::neutral_document::Shape) -> Result<()> {
use craft_svg::neutral_document::Primitive;
let point = |p: craft_svg::path_data::Point| Vec2::new(p.x, p.y);
let [a, b, c, d, e, f] = shape.transform;
if let Some(current) = self.stack.first_mut() {
*current = Mat3 { a, b, c, d, e, f };
}
if self.skip > 0 {
self.skip += 1;
return Ok(());
}
if hidden(e) {
self.skip = 1;
return Ok(());
}
if SKIP.contains(&name) {
if let Some(kind) = LeftOut::of(name) {
self.left_out(kind);
self.layer = shape.layer;
match shape.primitive {
Primitive::Rect { x, y, width, height } => {
let pts = [Vec2::new(x, y), Vec2::new(x + width, y), Vec2::new(x + width, y + height), Vec2::new(x, y + height)];
self.add_polyline(&pts.map(|p| self.map(p)), true)?;
}
self.skip = 1;
return Ok(());
}
if CONTAINERS.contains(&name) { self.enter_group(name, e) } else { self.on_element(name, e) }
}
fn on_element(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
if self.skip > 0 {
return Ok(());
}
if SKIP.contains(&name) || hidden(e) {
if !hidden(e)
&& let Some(kind) = LeftOut::of(name)
{
self.left_out(kind);
Primitive::Circle { center, radius } => self.add_rounded(point(center), radius, radius)?,
Primitive::Ellipse { center, rx, ry } => self.add_rounded(point(center), rx, ry)?,
Primitive::Line { a, b } => self.add(EntityKind::Line(Line { a: v3(self.map(point(a))), b: v3(self.map(point(b))) }))?,
Primitive::Polyline { points, closed } => {
self.add_polyline(&points.into_iter().map(|p| self.map(point(p))).collect::<Vec<_>>(), closed)?
}
return Ok(());
}
// A shape's own `transform` (SVG 1.1 §7.5) maps it after its groups', for this element only.
let local = attr(e, b"transform").as_deref().and_then(parse_transform);
if let Some(local) = local {
self.stack.push(self.cur().then_before(local));
}
let read = self.shape(name, e);
if local.is_some() {
self.stack.pop();
}
read
}
fn shape(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
match name {
b"use" => {
self.left_out(LeftOut::Use);
Ok(())
}
b"rect" => self.rect(e),
b"circle" => self.circle(e),
b"ellipse" => self.ellipse(e),
b"line" => self.line(e),
b"polyline" => self.poly_points(e, false),
b"polygon" => self.poly_points(e, true),
b"path" => self.path(e),
_ => Ok(()),
}
}
fn on_end(&mut self, name: &[u8]) {
if self.skip > 0 {
self.skip -= 1;
} else if CONTAINERS.contains(&name) && self.stack.len() > 1 {
self.stack.pop();
}
}
fn enter_group(&mut self, name: &[u8], e: &BytesStart) -> Result<()> {
if name == b"svg" && self.stack.len() == 1 {
self.stack[0] = viewport(e)?;
}
if name == b"g" && attr(e, b"inkscape:groupmode").as_deref() == Some("layer") {
let raw = attr(e, b"inkscape:label").or_else(|| attr(e, b"id"));
if let Some(raw) = raw {
self.set_layer(&raw);
Primitive::Path(paths) => {
for path in paths {
let path = Subpath {
start: point(path.start),
closed: path.closed,
segs: path
.segs
.into_iter()
.map(|seg| match seg {
craft_svg::path_data::Segment::Line(p) => Seg::Line(point(p)),
craft_svg::path_data::Segment::Cubic(a, b, c) => Seg::Cubic(point(a), point(b), point(c)),
craft_svg::path_data::Segment::Arc { rx, ry, rot, large, sweep, end } => {
Seg::Arc { rx, ry, rot, large, sweep, end: point(end) }
}
})
.collect(),
};
self.emit_subpath(&path)?;
}
}
}
if self.stack.len() >= MAX_TRANSFORM_DEPTH {
return Err(IoError::Format(format!("SVG: more than {MAX_TRANSFORM_DEPTH} nested groups")));
}
let current = *self.stack.last().unwrap_or(&Mat3::IDENTITY);
let next = match attr(e, b"transform").as_deref().and_then(parse_transform) {
Some(local) => current.then_before(local),
None => current,
};
self.stack.push(next);
Ok(())
}
fn set_layer(&mut self, raw: &str) {
let name = sanitize_layer(raw);
if !self.layers.contains(&name) {
if self.layers.len() >= MAX_LAYERS {
return;
}
let color = Color::Index(self.layer_color);
self.layer_color = if self.layer_color >= 7 { 1 } else { self.layer_color + 1 };
self.drawing.layers.push(Layer { name: name.clone(), color, ..Layer::default() });
self.layers.insert(name.clone());
}
self.layer = name;
}
/// The composed mapping for the current nesting: SVG user units → drawing units (mm).
fn cur(&self) -> Mat3 {
*self.stack.last().unwrap_or(&Mat3::IDENTITY)
@@ -366,40 +228,6 @@ impl Parser {
self.drawing.add(&Space::Model, common, kind).map(|_| ()).map_err(parse_err)
}
// --- shapes -------------------------------------------------------------
fn rect(&mut self, e: &BytesStart) -> Result<()> {
let x = num(e, b"x", 0.0);
let y = num(e, b"y", 0.0);
let w = num(e, b"width", 0.0);
let h = num(e, b"height", 0.0);
if w <= 0.0 || h <= 0.0 {
return Ok(());
}
if num(e, b"rx", 0.0) > 0.0 || num(e, b"ry", 0.0) > 0.0 {
self.left_out(LeftOut::RoundedCorners);
}
let pts = [Vec2::new(x, y), Vec2::new(x + w, y), Vec2::new(x + w, y + h), Vec2::new(x, y + h)];
self.add_polyline(&pts.map(|p| self.map(p)), true)
}
fn circle(&mut self, e: &BytesStart) -> Result<()> {
let r = num(e, b"r", 0.0);
if r <= 0.0 {
return Ok(());
}
self.add_rounded(Vec2::new(num(e, b"cx", 0.0), num(e, b"cy", 0.0)), r, r)
}
fn ellipse(&mut self, e: &BytesStart) -> Result<()> {
let rx = num(e, b"rx", 0.0);
let ry = num(e, b"ry", 0.0);
if rx <= 0.0 || ry <= 0.0 {
return Ok(());
}
self.add_rounded(Vec2::new(num(e, b"cx", 0.0), num(e, b"cy", 0.0)), rx, ry)
}
/// A circle or ellipse through a transform. A circle stays a `CIRCLE` under rotations,
/// uniform scales and reflections; anything else becomes an `ELLIPSE` holding the axes
/// of the transformed shape — a linear map sends the unit circle to an ellipse whose
@@ -413,9 +241,10 @@ impl Parser {
if lbx.is_finite() && lby.is_finite() && (lbx - lby).abs() <= 1e-9 * (lbx + lby) && dot.abs() <= 1e-9 * lbx * lby {
return self.add(EntityKind::Circle(Circle { center: v3(center), radius: lbx }));
}
let xx = bx.x * bx.x + bx.y * bx.y;
let yy = by.x * by.x + by.y * by.y;
let xy = bx.x * by.x + bx.y * by.y;
// `B·Bᵀ` (B = [bx by]) lives in the output plane, so its eigenvectors are the axes.
let xx = bx.x * bx.x + by.x * by.x;
let yy = bx.y * bx.y + by.y * by.y;
let xy = bx.x * bx.y + by.x * by.y;
let trace = xx + yy;
let disc = (trace * trace - 4.0 * (xx * yy - xy * xy)).max(0.0).sqrt();
let l_max = 0.5 * (trace + disc);
@@ -439,24 +268,6 @@ impl Parser {
self.add(EntityKind::Ellipse(Ellipse { center: v3(center), major: v3(major), ratio, start: 0.0, end: std::f64::consts::TAU }))
}
fn line(&mut self, e: &BytesStart) -> Result<()> {
let a = Vec2::new(num(e, b"x1", 0.0), num(e, b"y1", 0.0));
let b = Vec2::new(num(e, b"x2", 0.0), num(e, b"y2", 0.0));
self.add(EntityKind::Line(Line { a: v3(self.map(a)), b: v3(self.map(b)) }))
}
fn poly_points(&mut self, e: &BytesStart, closed: bool) -> Result<()> {
let Some(raw) = attr(e, b"points") else {
return Ok(());
};
let nums: Vec<f64> = Numbers::new(&raw).collect();
let mut pts: Vec<Vec2> = nums.as_chunks::<2>().0.iter().map(|[x, y]| self.map(Vec2::new(*x, *y))).collect();
if pts.len() > MAX_CURVE_POINTS {
pts.truncate(MAX_CURVE_POINTS);
}
self.add_polyline(&pts, closed)
}
fn add_polyline(&mut self, pts: &[Vec2], closed: bool) -> Result<()> {
if pts.len() < 2 {
return Ok(());
@@ -465,18 +276,6 @@ impl Parser {
self.add(EntityKind::LwPolyline(LwPolyline { vertices, closed, const_width: 0.0, elevation: 0.0, plinegen: false }))
}
// --- path data ----------------------------------------------------------
fn path(&mut self, e: &BytesStart) -> Result<()> {
let Some(d) = attr(e, b"d") else {
return Ok(());
};
for sp in parse_path(&d)? {
self.emit_subpath(&sp)?;
}
Ok(())
}
/// Emit one subpath: runs of lines and arcs become an `LWPOLYLINE` (an arc becomes a
/// bulge vertex, exactly like DXF's polyline bulge), runs of Bézier curves become a
/// `SPLINE`. Under a non-uniform transform a circular arc is no longer circular, so it
@@ -581,182 +380,6 @@ impl Parser {
}
}
/// The element is not rendered (`display="none"`, or a style that says so).
fn hidden(e: &BytesStart) -> bool {
if attr(e, b"display").as_deref() == Some("none") {
return true;
}
attr(e, b"style").is_some_and(|s| s.replace(' ', "").contains("display:none"))
}
fn attr(e: &BytesStart, name: &[u8]) -> Option<String> {
// Stop at the first malformed attribute: skipping errors resumed the parser's duplicate check,
// which rescans the attributes before it each time, so many duplicates were quadratic.
for a in e.attributes() {
let Ok(a) = a else { return None };
if a.key.into_inner().as_bytes() == name {
return a.normalized_value(XmlVersion::Explicit1_0).ok().map(|v| v.into_owned());
}
}
None
}
fn num(e: &BytesStart, name: &[u8], fallback: f64) -> f64 {
attr(e, name).as_deref().and_then(parse_length_mm).unwrap_or(fallback)
}
/// A bare number, or a number with an absolute CSS/SVG unit: millimetres here, everything
/// else (px, the default; pt, pc, in, cm) through the CSS reference pixel (96 per inch).
fn parse_length_mm(s: &str) -> Option<f64> {
let s = s.trim();
let cut = s.find(|c: char| !(c.is_ascii_digit() || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E')).unwrap_or(s.len());
let (n, unit) = s.split_at(cut);
let value: f64 = n.trim().parse().ok()?;
if !value.is_finite() {
return None;
}
match unit.trim() {
"" | "px" => Some(value),
"mm" => Some(value),
"cm" => Some(value * 10.0),
"in" => Some(value * 25.4),
"pt" => Some(value * 25.4 / 72.0),
"pc" => Some(value * 25.4 / 6.0),
_ => Some(value * 25.4 / 96.0),
}
}
/// The root mapping: `viewBox` and unit-bearing `width`/`height` become millimetres per user
/// unit, and the page's Y axis is flipped so the drawing keeps its appearance with Y up.
fn viewport(e: &BytesStart) -> Result<Mat3> {
let vb = attr(e, b"viewBox").and_then(|raw| {
let nums: Vec<f64> = Numbers::new(&raw).collect();
match nums.as_slice() {
[x, y, w, h] if w.is_finite() && h.is_finite() && *w > 0.0 && *h > 0.0 => Some((*x, *y, *w, *h)),
_ => None,
}
});
// A bare or `px` root size is in CSS pixels, not millimetres.
let root_mm = |name: &[u8]| {
let raw = attr(e, name)?;
let mm = parse_length_mm(&raw)?;
let unit = raw.trim().trim_start_matches(|c: char| c.is_ascii_digit() || matches!(c, '.' | '-' | '+' | 'e' | 'E')).trim();
Some(if matches!(unit, "" | "px") { mm * 25.4 / 96.0 } else { mm })
};
let w_mm = root_mm(b"width");
let h_mm = root_mm(b"height");
let unit = match (vb, w_mm, h_mm) {
(Some((_, _, vw, _)), Some(w), _) if w > 0.0 => w / vw,
(Some((_, _, _, vh)), _, Some(h)) if h > 0.0 => h / vh,
(Some(_), _, _) => 25.4 / 96.0,
(None, _, _) => 25.4 / 96.0,
};
let (vx, vy, vh) = match vb {
Some((x, y, _, h)) => (x, y, h),
None => (0.0, 0.0, 0.0),
};
Ok(Mat3 { a: unit, b: 0.0, c: 0.0, d: -unit, e: -vx * unit, f: (vy + vh) * unit })
}
/// `transform="…"`: a list of functions, applied left to right.
fn parse_transform(s: &str) -> Option<Mat3> {
let mut out: Option<Mat3> = None;
let mut rest = s.trim();
while !rest.is_empty() {
let open = rest.find('(')?;
let name = rest[..open].trim();
let close = rest[open..].find(')')? + open;
let args: Vec<f64> = Numbers::new(&rest[open + 1..close]).collect();
let m = match (name, args.as_slice()) {
("matrix", [a, b, c, d, e, f]) => Mat3 { a: *a, b: *b, c: *c, d: *d, e: *e, f: *f },
("translate", [x]) => Mat3::translate(Vec2::new(*x, 0.0)),
("translate", [x, y]) => Mat3::translate(Vec2::new(*x, *y)),
("scale", [s]) => Mat3::scale(*s, *s),
("scale", [sx, sy]) => Mat3::scale(*sx, *sy),
("rotate", [a]) => Mat3::rotate(a.to_radians()),
("rotate", [a, cx, cy]) => Mat3::rotate_about(Vec2::new(*cx, *cy), a.to_radians()),
("skewX", [a]) => Mat3 { a: 1.0, b: 0.0, c: a.to_radians().tan(), d: 1.0, e: 0.0, f: 0.0 },
("skewY", [a]) => Mat3 { a: 1.0, b: a.to_radians().tan(), c: 0.0, d: 1.0, e: 0.0, f: 0.0 },
_ => return None,
};
out = Some(match out {
Some(prev) => prev.then_before(m),
None => m,
});
rest = rest[close + 1..].trim_start_matches(|c: char| c == ',' || c.is_whitespace());
}
out
}
fn sanitize_layer(raw: &str) -> String {
let cleaned: String =
raw.trim().chars().map(|c| if c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '$') { c } else { '_' }).take(128).collect();
let cleaned = cleaned.trim_matches('_').to_string();
if cleaned.is_empty() { "SVG".into() } else { cleaned }
}
/// A scanner over an SVG number list: separators are whitespace and commas, and a sign
/// starts a new number, so `10-20` is two numbers and `1e-5 2` is two numbers.
struct Numbers<'a> {
s: &'a [u8],
i: usize,
}
impl<'a> Numbers<'a> {
fn new(s: &'a str) -> Self {
Numbers { s: s.as_bytes(), i: 0 }
}
fn skip_seps(&mut self) {
while matches!(self.s.get(self.i), Some(b' ' | b'\t' | b'\r' | b'\n' | b',')) {
self.i += 1;
}
}
fn next_num(&mut self) -> Option<f64> {
self.skip_seps();
let start = self.i;
if matches!(self.s.get(self.i), Some(b'+' | b'-')) {
self.i += 1;
}
let mut digits = 0;
let mut dot = false;
let mut exp = false;
while let Some(c) = self.s.get(self.i) {
match c {
b'0'..=b'9' => {
digits += 1;
self.i += 1;
}
b'.' if !dot && !exp => {
dot = true;
self.i += 1;
}
b'e' | b'E' if !exp && digits > 0 => {
exp = true;
self.i += 1;
if matches!(self.s.get(self.i), Some(b'+' | b'-')) {
self.i += 1;
}
}
_ => break,
}
}
if digits == 0 {
self.i = start;
return None;
}
std::str::from_utf8(&self.s[start..self.i]).ok()?.parse::<f64>().ok().filter(|v| v.is_finite())
}
}
impl Iterator for Numbers<'_> {
type Item = f64;
fn next(&mut self) -> Option<f64> {
self.next_num()
}
}
/// One `M …` run of a `d` attribute.
struct Subpath {
start: Vec2,
@@ -770,252 +393,9 @@ enum Seg {
Arc { rx: f64, ry: f64, rot: f64, large: bool, sweep: bool, end: Vec2 },
}
/// Tokens of a `d` attribute: command letters and numbers, in order.
enum Tok {
Cmd(u8),
Num(f64),
}
struct Tokenizer<'a> {
s: &'a [u8],
i: usize,
/// Start of the most recently returned token.
tok_start: usize,
}
impl<'a> Tokenizer<'a> {
fn new(s: &'a str) -> Self {
Tokenizer { s: s.as_bytes(), i: 0, tok_start: 0 }
}
/// Read an arc flag: a single `0` or `1` character, which needs no separator after it.
fn next_flag(&mut self) -> Option<f64> {
let mut nums = Numbers { s: self.s, i: self.i };
nums.skip_seps();
let v = match self.s.get(nums.i)? {
b'0' => 0.0,
b'1' => 1.0,
_ => return None,
};
self.i = nums.i + 1;
Some(v)
}
fn next_tok(&mut self) -> Option<Tok> {
let mut nums = Numbers { s: self.s, i: self.i };
nums.skip_seps();
self.i = nums.i;
self.tok_start = self.i;
let c = self.s.get(self.i).copied()?;
if c.is_ascii_alphabetic() {
self.i += 1;
return Some(Tok::Cmd(c));
}
let tok = nums.next_num().map(Tok::Num);
self.i = nums.i;
tok
}
}
/// Split `d` into subpaths, resolving relative commands and the S/T control reflections.
fn parse_path(d: &str) -> Result<Vec<Subpath>> {
let mut tk = Tokenizer::new(d);
let mut lookahead: Option<Tok> = None;
let mut cmd = 0u8;
let mut cur = Vec2::ZERO;
let mut start = Vec2::ZERO;
let mut segs: Vec<Seg> = Vec::new();
let mut out: Vec<Subpath> = Vec::new();
let closed = false;
let mut prev_cubic: Option<Vec2> = None;
let mut prev_quad: Option<Vec2> = None;
let mut segments = 0usize;
let next_num = |tk: &mut Tokenizer, look: &mut Option<Tok>| -> Result<f64> {
match look.take() {
Some(Tok::Num(v)) => Ok(v),
Some(other @ Tok::Cmd(_)) => {
*look = Some(other);
Err(IoError::Format("SVG: path command is missing coordinates".into()))
}
None => match tk.next_tok() {
Some(Tok::Num(v)) => Ok(v),
Some(other @ Tok::Cmd(_)) => {
*look = Some(other);
Err(IoError::Format("SVG: path command is missing coordinates".into()))
}
None => Err(IoError::Format("SVG: path command is missing coordinates".into())),
},
}
};
while let Some(tok) = lookahead.take().or_else(|| tk.next_tok()) {
let rel = match tok {
Tok::Cmd(c) => {
if c.eq_ignore_ascii_case(&b'z') {
if !segs.is_empty() {
out.push(Subpath { start, segs, closed: true });
segs = Vec::new();
}
cur = start;
cmd = 0;
continue;
}
cmd = c;
c.is_ascii_lowercase()
}
tok @ Tok::Num(_) => {
if cmd == 0 {
return Err(IoError::Format("SVG: path data does not start with a command".into()));
}
lookahead = Some(tok);
cmd.is_ascii_lowercase()
}
};
let abs = cmd.to_ascii_uppercase();
let count = match abs {
b'M' | b'L' => 2,
b'H' | b'V' | b'T' => 1,
b'C' => 6,
b'S' | b'Q' => 4,
b'A' => 7,
_ => return Err(IoError::Format(format!("SVG: unknown path command `{}`", cmd as char))),
};
let mut args = [0.0f64; 7];
for (idx, slot) in args.iter_mut().enumerate().take(count) {
if abs == b'A' && (idx == 3 || idx == 4) {
// Flags are single characters; re-scan a pending number token from its start.
if matches!(lookahead, Some(Tok::Num(_))) {
lookahead = None;
tk.i = tk.tok_start;
}
if lookahead.is_none() {
*slot = tk.next_flag().ok_or_else(|| IoError::Format("SVG: path command is missing coordinates".into()))?;
continue;
}
}
*slot = next_num(&mut tk, &mut lookahead)?;
}
let point = |x: f64, y: f64| if rel { cur + Vec2::new(x, y) } else { Vec2::new(x, y) };
match abs {
b'M' => {
if !segs.is_empty() {
out.push(Subpath { start, segs, closed: false });
segs = Vec::new();
}
cur = point(args[0], args[1]);
start = cur;
cmd = if rel { b'l' } else { b'L' };
prev_cubic = None;
prev_quad = None;
}
b'L' => {
cur = point(args[0], args[1]);
segs.push(Seg::Line(cur));
prev_cubic = None;
prev_quad = None;
}
b'H' => {
cur = Vec2::new(if rel { cur.x + args[0] } else { args[0] }, cur.y);
segs.push(Seg::Line(cur));
prev_cubic = None;
prev_quad = None;
}
b'V' => {
cur = Vec2::new(cur.x, if rel { cur.y + args[0] } else { args[0] });
segs.push(Seg::Line(cur));
prev_cubic = None;
prev_quad = None;
}
b'C' => {
let (c1, c2, p) = (point(args[0], args[1]), point(args[2], args[3]), point(args[4], args[5]));
segs.push(Seg::Cubic(c1, c2, p));
prev_cubic = Some(c2);
prev_quad = None;
cur = p;
}
b'S' => {
let c1 = prev_cubic.map_or(cur, |c2| cur * 2.0 - c2);
let (c2, p) = (point(args[0], args[1]), point(args[2], args[3]));
segs.push(Seg::Cubic(c1, c2, p));
prev_cubic = Some(c2);
prev_quad = None;
cur = p;
}
b'Q' => {
let (q, p) = (point(args[0], args[1]), point(args[2], args[3]));
segs.push(Seg::Cubic(cur + (q - cur) * (2.0 / 3.0), p + (q - p) * (2.0 / 3.0), p));
prev_quad = Some(q);
prev_cubic = None;
cur = p;
}
b'T' => {
let reflect = prev_quad.map_or(cur, |q| cur * 2.0 - q);
let p = point(args[0], args[1]);
segs.push(Seg::Cubic(cur + (reflect - cur) * (2.0 / 3.0), p + (reflect - p) * (2.0 / 3.0), p));
prev_quad = Some(reflect);
prev_cubic = None;
cur = p;
}
b'A' => {
let end = point(args[5], args[6]);
segs.push(Seg::Arc { rx: args[0].abs(), ry: args[1].abs(), rot: args[2], large: args[3] != 0.0, sweep: args[4] != 0.0, end });
cur = end;
prev_cubic = None;
prev_quad = None;
}
_ => return Err(IoError::Format("SVG: unsupported path command".into())),
}
segments += 1;
if segments > MAX_PATH_SEGMENTS {
return Err(IoError::Format("SVG: path has too many segments".into()));
}
if segs.len() > MAX_CURVE_POINTS {
return Err(IoError::Format("SVG: path has too many segments".into()));
}
}
if !segs.is_empty() {
out.push(Subpath { start, segs, closed });
}
Ok(out)
}
/// The centre and signed sweep of a circular arc from `p0` to `p1` in a Y-up frame, per the
/// SVG endpoint parameterisation (F.6.5). Radii that cannot span the chord are scaled up,
/// as the specification requires.
fn arc_center_circular(p0: Vec2, p1: Vec2, r: f64, large: bool, sweep: bool) -> Option<(Vec2, f64)> {
if r <= 0.0 || !r.is_finite() {
return None;
}
let d = p1 - p0;
let dist = d.x.hypot(d.y);
let r = if dist > 2.0 * r { dist / 2.0 } else { r };
if dist <= f64::EPSILON {
return None;
}
let mid = (p0 + p1) * 0.5;
let h = (r * r - (dist * dist) / 4.0).max(0.0).sqrt();
let n = Vec2::new(-d.y / dist, d.x / dist);
let sign = if large != sweep { 1.0 } else { -1.0 };
let center = mid + n * (h * sign);
let a0 = (p0.y - center.y).atan2(p0.x - center.x);
let a1 = (p1.y - center.y).atan2(p1.x - center.x);
let ccw = (a1 - a0).rem_euclid(std::f64::consts::TAU);
Some((center, pick_sweep(ccw, large, sweep)))
}
/// The signed sweep (CCW positive) for a chord sweep `ccw` in `[0, 2π)`: the centre is
/// already chosen so that the magnitude matches `large`, so only the direction is left.
fn pick_sweep(ccw: f64, large: bool, sweep: bool) -> f64 {
let tau = std::f64::consts::TAU;
let eps = f64::EPSILON;
if sweep {
if ccw <= eps { if large { tau } else { eps } } else { ccw }
} else if ccw >= tau - eps {
if large { -tau } else { -eps }
} else {
ccw - tau
}
let point = |p: Vec2| craft_svg::path_data::Point::new(p.x, p.y);
craft_svg::path_data::arc_center_circular(point(p0), point(p1), r, large, sweep).map(|(p, angle)| (Vec2::new(p.x, p.y), angle))
}
/// Flatten a general elliptical arc (any `rx`/`ry`/rotation) from `p0` to `p1` in user
@@ -1041,44 +421,34 @@ fn flatten_arc(m: &Mat3, p0: Vec2, p1: Vec2, (rx, ry): (f64, f64), rot_deg: f64,
Ok(out)
}
/// Endpoint → centre parameterisation for a rotated elliptical arc (SVG F.6.5), in the
/// frame the points are given in. Returns the centre, the start parameter and the signed
/// sweep.
fn elliptical_params(p0: Vec2, p1: Vec2, rx: f64, ry: f64, phi: f64, large: bool, sweep: bool) -> Option<(Vec2, f64, f64)> {
if rx <= 0.0 || ry <= 0.0 {
return None;
}
let (sphi, cphi) = phi.sin_cos();
let dx = (p0.x - p1.x) / 2.0;
let dy = (p0.y - p1.y) / 2.0;
let x1 = cphi * dx + sphi * dy;
let y1 = -sphi * dx + cphi * dy;
let (rx, ry) = {
let lambda = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry);
if lambda > 1.0 {
let s = lambda.sqrt();
(rx * s, ry * s)
} else {
(rx, ry)
}
};
let num = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1;
let den = rx * rx * y1 * y1 + ry * ry * x1 * x1;
let coef = if sweep != large { 1.0 } else { -1.0 } * (num.max(0.0) / den.max(f64::MIN_POSITIVE)).sqrt();
let cxp = coef * rx * y1 / ry;
let cyp = -coef * ry * x1 / rx;
let center = Vec2::new(cphi * cxp - sphi * cyp + (p0.x + p1.x) / 2.0, sphi * cxp + cphi * cyp + (p0.y + p1.y) / 2.0);
let angle = |ux: f64, uy: f64, vx: f64, vy: f64| {
let dot = ux * vx + uy * vy;
let det = ux * vy - uy * vx;
let denom = (ux.hypot(uy) * vx.hypot(vy)).max(f64::MIN_POSITIVE);
(dot / denom).clamp(-1.0, 1.0).acos().copysign(det)
};
let (ux, uy) = ((x1 - cxp) / rx, (y1 - cyp) / ry);
let (vx, vy) = ((-x1 - cxp) / rx, (-y1 - cyp) / ry);
let theta = angle(1.0, 0.0, ux, uy);
let ccw = angle(ux, uy, vx, vy).rem_euclid(std::f64::consts::TAU);
Some((center, theta, pick_sweep(ccw, large, sweep)))
let point = |p: Vec2| craft_svg::path_data::Point::new(p.x, p.y);
craft_svg::path_data::elliptical_params(point(p0), point(p1), rx, ry, phi, large, sweep)
.map(|(p, start, sweep)| (Vec2::new(p.x, p.y), start, sweep))
}
/// Convert shared SVG path segments to CADCraft's geometry types.
#[cfg(test)]
fn parse_path(d: &str) -> Result<Vec<Subpath>> {
use craft_svg::path_data::{Point, Segment};
let point = |p: Point| Vec2::new(p.x, p.y);
let paths = craft_svg::path_data::parse_path(d).map_err(|e| IoError::Format(e.to_string()))?;
Ok(paths
.into_iter()
.map(|sp| Subpath {
start: point(sp.start),
closed: sp.closed,
segs: sp
.segs
.into_iter()
.map(|seg| match seg {
Segment::Line(p) => Seg::Line(point(p)),
Segment::Cubic(c1, c2, p) => Seg::Cubic(point(c1), point(c2), point(p)),
Segment::Arc { rx, ry, rot, large, sweep, end } => Seg::Arc { rx, ry, rot, large, sweep, end: point(end) },
})
.collect(),
})
.collect())
}
#[cfg(test)]
+36
View File
@@ -2943,6 +2943,15 @@ fn svg_path_lines_curves_and_arcs() {
assert!((bulge.abs() - 1.0).abs() < 1e-6, "semicircle bulge is ±1, got {bulge}");
}
#[test]
fn svg_smooth_quadratic_has_two_coordinates() {
let smooth = format!("{SVG_PAGE}<path d=\"M0 0 Q3 3 6 0 T12 0\"/></svg>");
let explicit = format!("{SVG_PAGE}<path d=\"M0 0 Q3 3 6 0 Q9 -3 12 0\"/></svg>");
let smooth = read(smooth.as_bytes(), "smooth.svg").unwrap();
let explicit = read(explicit.as_bytes(), "explicit.svg").unwrap();
assert_eq!(geometry(&smooth), geometry(&explicit));
}
#[test]
fn svg_group_transforms_apply() {
let svg = format!("{SVG_PAGE}<g transform=\"translate(5,2)\"><line x1=\"0\" y1=\"0\" x2=\"10\" y2=\"0\"/></g></svg>");
@@ -3072,6 +3081,33 @@ fn svgz_gunzips_to_the_same_drawing() {
assert_eq!(plain.model.iter().map(|e| &e.kind).collect::<Vec<_>>(), packed.model.iter().map(|e| &e.kind).collect::<Vec<_>>());
}
#[test]
fn svgz_checks_the_gzip_trailer_and_combines_members() {
let svg = format!("{SVG_PAGE}<circle cx=\"5\" cy=\"5\" r=\"1\"/></svg>");
let split = svg.len() / 2;
let mut members = gzip_of(&svg.as_bytes()[..split]);
members.extend(gzip_of(&svg.as_bytes()[split..]));
let plain = read(svg.as_bytes(), "a.svg").unwrap();
let decoded = read(&members, "a.svgz").unwrap();
assert_eq!(plain.model.iter().map(|e| &e.kind).collect::<Vec<_>>(), decoded.model.iter().map(|e| &e.kind).collect::<Vec<_>>());
let mut corrupt = gzip_of(svg.as_bytes());
let crc_offset = corrupt.len() - 8;
corrupt[crc_offset] ^= 1;
assert!(read(&corrupt, "a.svgz").is_err());
}
#[test]
fn svgz_open_and_svg_export_follow_the_public_dispatch() {
let source = format!("{SVG_PAGE}<line x1=\"1\" y1=\"2\" x2=\"9\" y2=\"7\"/></svg>");
let drawing = read(&gzip_of(source.as_bytes()), "input.svgz").unwrap();
assert_eq!(kinds(&drawing), ["Line"]);
let output = write(&drawing, "output.svg").unwrap();
assert!(std::str::from_utf8(&output).unwrap().contains("<polyline"));
let reopened = read(&output, "output.svg").unwrap();
assert!(!reopened.model.is_empty());
}
#[test]
fn svg_read_dispatches_by_extension() {
let svg = format!("{SVG_PAGE}<circle cx=\"5\" cy=\"5\" r=\"1\"/></svg>");
+74
View File
@@ -0,0 +1,74 @@
//! A negative DIMGAP draws a frame around the dimension text. The `*D` block written for the
//! dimension holds the frame's four sides, the negative DIMGAP reads back from the file, and a
//! PDF plot draws the frame.
use cadcraft_doc::{Common, DimKind, Dimension, Drawing, EntityKind, Space};
use cadcraft_geom::Vec3;
use crate::pdf_read;
fn linear() -> Dimension {
Dimension {
kind: DimKind::Linear { rotation: 0.0 },
defpt: Vec3::new(15.0, 5.0, 0.0),
text_mid: Vec3::ZERO,
p13: Vec3::ZERO,
p14: Vec3::new(30.0, 0.0, 0.0),
p15: Vec3::ZERO,
p16: Vec3::ZERO,
text: String::new(),
style: "Standard".into(),
measurement: 0.0,
text_rotation: 0.0,
user_text_pos: false,
block: None,
insertion_point: Vec3::ZERO,
overrides: Default::default(),
assoc: Vec::new(),
marks: Default::default(),
}
}
/// Save a drawing with one dimension in a Standard style of DIMGAP `gap`, read it back, and
/// return the style's DIMGAP and the number of LINEs in the dimension's `*D` block.
fn roundtrip(gap: f64) -> (f64, usize) {
let mut d = Drawing::new_imperial();
d.dim_styles.iter_mut().for_each(|s| s.text_gap = gap);
d.add(&Space::Model, Common::default(), EntityKind::Dimension(linear())).unwrap();
let back = cadcraft_io::read_dxf(cadcraft_io::write_dxf(&d).as_bytes()).unwrap();
let dm = back
.model
.iter()
.find_map(|e| match &e.kind {
EntityKind::Dimension(dm) => Some(dm.clone()),
_ => None,
})
.unwrap();
let block = back.block(dm.block.as_deref().unwrap()).unwrap();
let lines = block.entities.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count();
(back.dim_style("Standard").unwrap().text_gap, lines)
}
/// The number of path segments (`l`) in the PDF of a drawing with one dimension in a Standard
/// style of DIMGAP `gap`.
fn pdf_segments(gap: f64) -> usize {
let mut d = Drawing::new_imperial();
d.dim_styles.iter_mut().for_each(|s| s.text_gap = gap);
d.add(&Space::Model, Common::default(), EntityKind::Dimension(linear())).unwrap();
let doc = pdf_read::read(&cadcraft_io::plot(&d, &Space::Model, &serde_json::json!({"compress": false})).unwrap());
pdf_read::count(&doc.pages[0].content, "l")
}
#[test]
fn pdf_draws_the_text_frame() {
assert_eq!(pdf_segments(-0.09), pdf_segments(0.09) + 4);
}
#[test]
fn dimension_block_holds_the_text_frame() {
let (gap, plain) = roundtrip(0.09);
assert!((gap - 0.09).abs() < 1e-12, "{gap}");
let (gap, framed) = roundtrip(-0.09);
assert!((gap + 0.09).abs() < 1e-12, "{gap}");
assert_eq!(framed, plain + 4);
}
+2
View File
@@ -14,6 +14,7 @@ mod codepages;
mod dim_block_resave_roundtrip;
mod dim_block_text;
mod dim_marks_roundtrip;
mod dim_text_frame;
mod dimstyle_vars_roundtrip;
mod dimtfill_roundtrip;
mod drafting_spacing;
@@ -72,6 +73,7 @@ mod spline_fit_data;
mod split_entities_section;
mod style_typeface;
mod svg_arc_budget;
mod svg_ellipse_transform_axis;
mod svg_tiny_extents;
mod table_cellstyle_roundtrip;
mod tables_objects_roundtrip;
@@ -0,0 +1,64 @@
//! SVG import of an ellipse under a rotation, skew or non-uniform scale: the major axis of the
//! resulting `ELLIPSE` must point along the major axis of the transformed shape in the output plane.
use cadcraft_doc::EntityKind;
use cadcraft_io::read;
/// Reads `<ellipse rx=20 ry=10>` under `transform` and returns (major direction angle, ratio).
fn import(transform: &str) -> (f64, f64) {
let svg = format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><g transform="{transform}"><ellipse cx="0" cy="0" rx="20" ry="10"/></g></svg>"#);
let d = read(svg.as_bytes(), "a.svg").unwrap();
let e = d
.model
.iter()
.find_map(|e| match &e.kind {
EntityKind::Ellipse(el) => Some(el.clone()),
_ => None,
})
.unwrap();
let (dx, dy) = (e.major.x - e.center.x, e.major.y - e.center.y);
(dy.atan2(dx), e.ratio)
}
/// Major-axis angle and ratio of the image of the ellipse under the 2x2 map `[a c; b d]`, with
/// the SVG y axis flipped (eigenvectors of `B·Bᵀ`, where B's columns are the transformed radii).
fn expected(a: f64, b: f64, c: f64, d: f64) -> (f64, f64) {
let (bx, by) = ((20.0 * a, -20.0 * b), (10.0 * c, -10.0 * d));
let m11 = bx.0 * bx.0 + by.0 * by.0;
let m22 = bx.1 * bx.1 + by.1 * by.1;
let m12 = bx.0 * bx.1 + by.0 * by.1;
let angle = 0.5 * (2.0 * m12).atan2(m11 - m22);
let tr = m11 + m22;
let disc = ((m11 - m22).powi(2) + 4.0 * m12 * m12).sqrt();
(angle, ((tr - disc) / (tr + disc)).sqrt())
}
/// Angles equal up to the sign of the axis (modulo π).
fn same_axis(got: f64, want: f64) -> bool {
let diff = (got - want).rem_euclid(std::f64::consts::PI);
diff < 1e-6 || std::f64::consts::PI - diff < 1e-6
}
fn check(transform: &str, m: (f64, f64, f64, f64)) {
let (angle, ratio) = import(transform);
let (want_angle, want_ratio) = expected(m.0, m.1, m.2, m.3);
assert!(same_axis(angle, want_angle), "{transform}: major axis at {}°, want {}°", angle.to_degrees(), want_angle.to_degrees());
assert!((ratio - want_ratio).abs() < 1e-9, "{transform}: ratio {ratio}, want {want_ratio}");
}
#[test]
fn rotated_ellipse_keeps_its_major_axis_direction() {
let (s, c) = 30f64.to_radians().sin_cos();
check("rotate(30)", (c, s, -s, c));
}
#[test]
fn skewed_ellipse_gets_the_output_space_major_axis() {
check("skewX(30)", (1.0, 0.0, 30f64.to_radians().tan(), 1.0));
}
#[test]
fn scaled_after_rotation_ellipse_gets_the_output_space_major_axis() {
let (s, c) = 30f64.to_radians().sin_cos();
check("matrix(2 0 0 1 0 0) rotate(30)", (2.0 * c, s, -2.0 * s, c));
}
+16
View File
@@ -361,6 +361,22 @@ pub fn dimension_geometry_with(d: &Dimension, st: &DimStyle, dimscale: f64, font
let (hw, hh) = (w / 2.0 + gap, h / 2.0 + gap);
g.text_fill = [(-hw, -hh), (hw, -hh), (hw, hh), (-hw, hh)].into_iter().map(|(px, py)| text_mid + x * px + y * py).collect();
}
// DIMGAP below 0: a frame around the text and the arc symbol over it, widened by |DIMGAP| on
// every side. A DIMINSPECT frame takes its place.
if st.text_gap < 0.0 && !g.mtext.is_empty() && d.marks.inspect.as_ref().is_none_or(|ins| ins.shape >= 2) {
let (w, h) = measure(&g.mtext);
let (x, y) = (Vec2::from_angle(text_angle), Vec2::from_angle(text_angle).perp());
// DIMARCSYM 1: the arc symbol's half width and how far its top is above the text's middle.
let arc_over =
(matches!(d.kind, DimKind::ArcLength) && st.arc_symbol == 1).then(|| ((w / 2.0).max(th / 2.0), h / 2.0 + gap / 2.0 + th * 0.35));
let (hw, top) = arc_over.map_or((w / 2.0, h / 2.0), |(half, peak)| ((w / 2.0).max(half), (h / 2.0).max(peak)));
let (hw, top, bottom) = (hw + gap, top + gap, h / 2.0 + gap);
let corners: Vec<Vec2> =
[(-hw, -bottom), (hw, -bottom), (hw, top), (-hw, top)].into_iter().map(|(px, py)| text_mid + x * px + y * py).collect();
for (a, b) in corners.iter().zip(corners.iter().cycle().skip(1)) {
g.text_mark(vec![*a, *b]);
}
}
g.value = decode_value(&cadcraft_fonts::plain_mtext(&g.mtext));
if !g.mtext.is_empty() {
let l = cadcraft_fonts::layout_mtext_with(&g.mtext, &params(text_mid, text_angle));
+17 -3
View File
@@ -77,7 +77,7 @@ fn prepare_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_mid: Vec2) -
let axis = Vec2::from_angle(angle);
(text_width * axis.dot(u).abs() + text_height * axis.perp().dot(u).abs()) / 2.0
};
let inside_angle = if st.text_inside_horizontal { 0.0 } else { along_angle };
let inside_angle = text_angle(config, st.text_inside_horizontal, along_angle);
let tvp = if st.text_above == 0 && st.text_vertical_pos.is_finite() { st.text_vertical_pos } else { 0.0 };
let centred = st.text_above == 0 && tvp.abs() < 0.7;
let text_need = if centred { 2.0 * (extent(inside_angle) + config.gap) } else { 2.0 * extent(inside_angle) };
@@ -129,6 +129,20 @@ fn prepare_linear(config: &DimConfig<'_>, g: &mut DimGeometry, text_mid: Vec2) -
}
}
/// The text's angle: an explicit text rotation (DIMTEDIT Angle, the Properties palette's Text
/// rotation) turns it, so the dimension line leaves room for the text as turned; otherwise
/// horizontal (DIMTIH inside, DIMTOH outside) or `along` the line.
fn text_angle(config: &DimConfig<'_>, horizontal: bool, along: f64) -> f64 {
let rotation = config.dimension.text_rotation;
if rotation != 0.0 && rotation.is_finite() {
rotation
} else if horizontal {
0.0
} else {
along
}
}
fn position_linear_text(config: &DimConfig<'_>, state: &mut LinearDimState) {
let st = config.style;
let along_angle = readable(state.u.angle());
@@ -136,8 +150,8 @@ fn position_linear_text(config: &DimConfig<'_>, state: &mut LinearDimState) {
let axis = Vec2::from_angle(angle);
(state.text_width * axis.dot(state.u).abs() + state.text_height * axis.perp().dot(state.u).abs()) / 2.0
};
let inside_angle = if st.text_inside_horizontal { 0.0 } else { along_angle };
state.angle = if state.text_outside { if st.text_outside_horizontal { 0.0 } else { along_angle } } else { inside_angle };
let inside_angle = text_angle(config, st.text_inside_horizontal, along_angle);
state.angle = if state.text_outside { text_angle(config, st.text_outside_horizontal, along_angle) } else { inside_angle };
state.half_extent = extent(state.angle);
state.along_center = if state.text_outside {
state.f2 + state.u * (2.0 * config.arrow_size.max(config.tick_size) + config.gap + state.half_extent)
+168
View File
@@ -167,6 +167,159 @@ fn dimtvp_uses_the_dimension_text_height() {
assert!((g.text_pos.y - 6.6).abs() < 1e-6, "text y={} height={}", g.text_pos.y, g.text_height);
}
/// The last four lines of `g` as a frame: four sides, each starting where the one before ends.
fn frame_of(g: &DimGeometry) -> Vec<Vec<Vec2>> {
let sides: Vec<Vec<Vec2>> = g.lines.iter().rev().take(4).rev().cloned().collect();
assert_eq!(sides.len(), 4);
for (a, b) in sides.iter().zip(sides.iter().cycle().skip(1)) {
assert_eq!(a.len(), 2);
assert!(a[1].dist(b[0]) < 1e-9, "{sides:?}");
}
sides
}
#[test]
fn negative_dimgap_draws_a_frame_around_the_text() {
let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
let plain = dimension_geometry(&d, &st_with(|s| s.text_gap = 0.09), 1.0);
let framed = dimension_geometry(&d, &st_with(|s| s.text_gap = -0.09), 1.0);
// The same text place and dimension line break as DIMGAP 0.09, and four more lines.
assert!(framed.text_pos.dist(plain.text_pos) < 1e-12);
assert_eq!(framed.lines.len(), plain.lines.len() + 4);
assert_eq!(framed.lines_of(LineRole::Dim).count(), plain.lines_of(LineRole::Dim).count() + 4);
// The frame is the text box widened by 0.09 on every side, around the text.
let frame = bbox(&frame_of(&framed));
let l = cadcraft_fonts::layout_mtext_with(&framed.mtext, &MTextParams { attach: 5, ..MTextParams::new(Vec2::ZERO, 0.18) });
assert!((frame.width() - (l.bounds.width() + 0.18)).abs() < 1e-9, "{frame:?}");
assert!((frame.height() - (l.bounds.height() + 0.18)).abs() < 1e-9, "{frame:?}");
let text = bbox(&framed.text);
assert!(frame.min.x < text.min.x && text.max.x < frame.max.x && frame.min.y < text.min.y && text.max.y < frame.max.y);
assert!((frame.center().dist(framed.text_pos)) < 1e-9, "{frame:?}");
// DIMGAP 0 and above: no frame.
assert_eq!(dimension_geometry(&d, &st_with(|s| s.text_gap = 0.0), 1.0).lines.len(), plain.lines.len());
}
#[test]
fn the_dimgap_frame_holds_every_line_of_a_multi_line_text() {
let mut d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
let one = frame_of(&dimension_geometry(&d, &st_with(|s| s.text_gap = -0.09), 1.0));
d.text = "<>\\PTYP".into();
let g = dimension_geometry(&d, &st_with(|s| s.text_gap = -0.09), 1.0);
let frame = bbox(&frame_of(&g));
let l = cadcraft_fonts::layout_mtext_with(&g.mtext, &MTextParams { attach: 5, ..MTextParams::new(Vec2::ZERO, 0.18) });
assert!(l.bounds.height() > 0.18 * 1.5, "two lines: {:?}", l.bounds);
assert!((frame.height() - (l.bounds.height() + 0.18)).abs() < 1e-9, "{frame:?}");
assert!(frame.height() > bbox(&one).height(), "{frame:?}");
let text = bbox(&g.text);
assert!(frame.min.x < text.min.x && text.max.x < frame.max.x && frame.min.y < text.min.y && text.max.y < frame.max.y, "{frame:?} {text:?}");
}
#[test]
fn the_dimgap_frame_is_drawn_over_a_text_background() {
let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
let g = dimension_geometry(
&d,
&st_with(|s| {
s.text_gap = -0.09;
s.text_fill = 1;
}),
1.0,
);
assert_eq!(g.text_fill.len(), 4);
// The four sides are text marks, which are drawn after the background.
let n = g.lines.len();
for i in n - 4..n {
assert!(g.text_marks.contains(&i), "{:?}", g.text_marks);
}
}
#[test]
fn the_frame_turns_with_the_text() {
let d = lin((0.0, 0.0), (0.0, 10.0), (5.0, 0.0), std::f64::consts::FRAC_PI_2);
let g = dimension_geometry(
&d,
&st_with(|s| {
s.text_gap = -0.09;
s.text_inside_horizontal = false;
}),
1.0,
);
assert!((g.text_angle.abs() - std::f64::consts::FRAC_PI_2).abs() < 1e-9, "{}", g.text_angle);
// Two sides along the text, two across it, the long ones along the dimension line.
for s in frame_of(&g) {
let v = s[1] - s[0];
assert!(v.x.abs() < 1e-9 || v.y.abs() < 1e-9, "{v:?}");
}
let frame = bbox(&frame_of(&g));
assert!(frame.height() > frame.width(), "{frame:?}");
assert!(bbox(&g.text).max.y < frame.max.y && frame.min.y < bbox(&g.text).min.y);
}
#[test]
fn the_frame_takes_in_the_arc_symbol_over_the_text() {
let mut d = lin((10.0, 0.0), (0.0, 10.0), (12.0, 0.0), 0.0);
d.kind = DimKind::ArcLength;
let g = dimension_geometry(
&d,
&st_with(|s| {
s.text_gap = -0.09;
s.arc_symbol = 1;
s.text_inside_horizontal = true;
}),
1.0,
);
let frame = bbox(&frame_of(&g));
// The arc symbol is the line drawn just before the frame.
let sym = &g.lines[g.lines.len() - 5];
assert_eq!(sym.len(), 13);
let s = bbox(std::slice::from_ref(sym));
assert!((frame.max.y - (s.max.y + 0.09)).abs() < 1e-9, "{frame:?} {s:?}");
assert!(frame.min.x < s.min.x && s.max.x < frame.max.x, "{frame:?} {s:?}");
let text = bbox(&g.text);
assert!(frame.min.y < text.min.y && text.max.y < frame.max.y, "{frame:?} {text:?}");
}
#[test]
fn the_arc_symbol_and_the_frame_turn_with_a_text_angle() {
let mut d = lin((10.0, 0.0), (0.0, 10.0), (12.0, 0.0), 0.0);
d.kind = DimKind::ArcLength;
d.text_rotation = 0.5;
let g = dimension_geometry(
&d,
&st_with(|s| {
s.text_gap = -0.09;
s.arc_symbol = 1;
}),
1.0,
);
assert!((g.text_angle - 0.5).abs() < 1e-12);
// In the text's own axes, the frame is upright and holds the symbol 0.09 below its top.
let (x, y) = (Vec2::from_angle(0.5), Vec2::from_angle(0.5).perp());
let local = |pts: &[Vec<Vec2>]| -> Vec<Vec<Vec2>> {
pts.iter().map(|l| l.iter().map(|p| Vec2::new((*p - g.text_pos).dot(x), (*p - g.text_pos).dot(y))).collect()).collect()
};
let frame = bbox(&local(&frame_of(&g)));
let sym = bbox(&local(std::slice::from_ref(&g.lines[g.lines.len() - 5])));
assert!((frame.max.y - (sym.max.y + 0.09)).abs() < 1e-9, "{frame:?} {sym:?}");
assert!(frame.min.x < sym.min.x && sym.max.x < frame.max.x, "{frame:?} {sym:?}");
// The symbol's ends sit level in the text's axes.
let s = &local(std::slice::from_ref(&g.lines[g.lines.len() - 5]))[0];
assert!((s[0].y - s[12].y).abs() < 1e-9, "{s:?}");
}
#[test]
fn an_inspection_frame_takes_the_place_of_the_dimgap_frame() {
let mut d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
d.marks.inspect = Some(cadcraft_doc::Inspection { shape: 0, label: "A".into(), rate: "50%".into() });
let st = |gap: f64| st_with(|s| s.text_gap = gap);
let inspected = dimension_geometry(&d, &st(0.09), 1.0).lines.len();
assert_eq!(dimension_geometry(&d, &st(-0.09), 1.0).lines.len(), inspected);
// Shape none draws no inspection frame, so DIMGAP's frame is drawn.
d.marks.inspect = Some(cadcraft_doc::Inspection { shape: 2, label: String::new(), rate: String::new() });
let none = dimension_geometry(&d, &st(0.09), 1.0).lines.len();
assert_eq!(dimension_geometry(&d, &st(-0.09), 1.0).lines.len(), none + 4);
}
#[test]
fn dimtad_one_uses_autocad_text_clearance() {
let d = lin((0.0, 0.10), (0.0, 0.70), (0.30, 0.40), std::f64::consts::FRAC_PI_2);
@@ -201,6 +354,21 @@ fn text_alignment_vertical_dimension() {
assert!((a.text_angle - std::f64::consts::FRAC_PI_2).abs() < 1e-9, "aligned: {}", a.text_angle);
}
#[test]
fn explicit_text_rotation_widens_the_dimension_line_gap() {
// A vertical dimension's text, horizontal by DIMTIH, turned along the line (DIMTEDIT Angle,
// the Properties palette's Text rotation): the line's gap fits the text as turned.
let mut d = lin((0.0, 0.0), (0.0, 40.0), (5.0, 0.0), std::f64::consts::FRAC_PI_2);
d.text_rotation = std::f64::consts::FRAC_PI_2;
let g = dimension_geometry(&d, &DimStyle::default(), 1.0);
let text = bbox(&g.text);
assert!(text.height() > 2.0 * text.width(), "turned along the line: {text:?}");
for l in g.lines_of(LineRole::Dim) {
let b = bbox(std::slice::from_ref(l));
assert!(b.max.y <= text.min.y + 1e-9 || b.min.y >= text.max.y - 1e-9, "the dimension line {l:?} crosses the text {text:?}");
}
}
#[test]
fn justification_moves_text() {
let d = lin((0.0, 0.0), (10.0, 0.0), (0.0, 5.0), 0.0);
+3 -1
View File
@@ -276,7 +276,9 @@ pub(super) fn draw_arc_length(config: &DimConfig<'_>, g: &mut DimGeometry, text_
if st.arc_symbol == 1 {
// A small arc over the text.
let (tw, tht) = measure(&g.mtext);
let (x, y) = (Vec2::from_angle(text_angle), Vec2::from_angle(text_angle).perp());
// The symbol turns with the text, a DIMTEDIT Angle included.
let a = if d.text_rotation != 0.0 && d.text_rotation.is_finite() { d.text_rotation } else { text_angle };
let (x, y) = (Vec2::from_angle(a), Vec2::from_angle(a).perp());
let half = (tw / 2.0).max(th / 2.0);
let base = text_mid + y * (tht / 2.0 + gap / 2.0);
let sym: Vec<Vec2> = (0..=12)
+19
View File
@@ -354,6 +354,25 @@ fn premultiplied(r: &cadcraft_doc::Raster) -> Option<Pixmap> {
Pixmap::from_vec(data, tiny_skia::IntSize::from_wh(r.width(), r.height())?)
}
/// Write straight-alpha RGBA8 pixels as PNG a row at a time.
pub fn write_rgba_png(mut output: impl std::io::Write, width: u32, height: u32, pixels: &[u8]) -> Option<()> {
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
let stride = usize::try_from(width).ok()?.checked_mul(4).filter(|n| *n > 0)?;
let expected = stride.checked_mul(usize::try_from(height).ok()?)?;
if height == 0 || pixels.len() != expected {
return None;
}
let mut rows = pixels.chunks_exact(stride);
let row = |data: &[u8]| Image::from_u8(width, 1, ChannelLayout::Rgba, data.to_vec()).ok();
let first = row(rows.next()?)?;
let mut encoder = PngRows::new(&mut output, &first, height, &EncodeOptions::default()).ok()?;
encoder.push(&first).ok()?;
for data in rows {
encoder.push(&row(data)?).ok()?;
}
encoder.finish().ok()
}
/// Encode a premultiplied pixmap as PNG without a second full-frame copy.
pub fn encode_png(pixmap: &Pixmap) -> Option<Vec<u8>> {
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
+2 -2
View File
@@ -16,6 +16,8 @@ cadcraft-color = { workspace = true }
cadcraft-doc = { workspace = true }
cadcraft-render = { workspace = true }
cadcraft-engine = { workspace = true }
cadcraft-io = { workspace = true }
craft-image-codecs = { workspace = true }
cadcraft-fonts = { workspace = true }
craft-window = { workspace = true }
egui = { workspace = true }
@@ -40,8 +42,6 @@ craft-ui = { workspace = true, features = ["native-windows"] }
egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }
# Validates the canvas WGSL and its GLSL ES 3.0 (WebGL2) translation in tests (same naga wgpu uses).
naga = { version = "30", features = ["wgsl-in", "glsl-out"] }
# Reads the synthetic dynamic-block fixture of the io tests for the dynamic grips tests.
cadcraft-io = { workspace = true }
[build-dependencies]
serde_json = { workspace = true }
File diff suppressed because it is too large Load Diff
+18 -1
View File
@@ -186,6 +186,10 @@ pub struct CanvasState {
/// The right-click that opened the shortcut menu held Shift or Ctrl: it is the object snap
/// menu ([`crate::context_menu`]).
pub snap_menu: bool,
/// The number (in the session's count of commands) of the INSERT the Blocks palette started
/// and is placing: a quick right-click at its insertion point cancels it
/// ([`right_click_cancels_placing`]).
pub palette_insert: Option<u64>,
/// Tab was pressed over a snap marker: show the next candidate ([`SnapCycle`]).
pub snap_tab: bool,
pub snap_cycle: Option<SnapCycle>,
@@ -783,6 +787,15 @@ fn collect_prompt_clicks(app: &mut CadApp, ui: &egui::Ui, context: PromptClickCo
pressed_primary
}
/// Whether a quick right-click cancels the running command instead of acting as Enter: it asks for
/// the insertion point of an INSERT the Blocks palette started. AutoCAD's Enter asks the point again,
/// and Escape (or this) is how a placement ends, so the palette's own placements get a way out
/// with the mouse.
pub(crate) fn right_click_cancels_placing(app: &CadApp) -> bool {
app.canvas.palette_insert == Some(app.session.commands_started)
&& app.session.current_prompt().is_some_and(|p| p.message == "Specify insertion point")
}
/// Draw the drawing area and handle its input (zoom and pan, picking, the crosshair) for this
/// frame.
///
@@ -969,7 +982,11 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
app.canvas.snap_menu = mods.shift || mods.ctrl;
}
if crate::context_menu::in_command(app, ui, inside, pressed_secondary) {
let _ = app.session.input(Input::Enter);
if right_click_cancels_placing(app) {
crate::cmdline::escape(app);
} else {
let _ = app.session.input(Input::Enter);
}
}
// Right-click on a grip with options (polyline vertex, line end…) opens the grip menu.
if inside && pressed_secondary && idle && !app.canvas.snap_menu {
+9 -5
View File
@@ -372,11 +372,7 @@ pub fn keyboard(app: &mut CadApp, ctx: &egui::Context) {
egui::Event::Ime(_) => {}
egui::Event::Key { key, pressed: true, repeat, modifiers, .. } => match key {
Key::Enter => submit(app),
Key::Escape => {
app.cmd.buffer.clear();
app.cmd.preedit.clear();
app.session.cancel();
}
Key::Escape => escape(app),
Key::Backspace => {
let press = KeyPress { repeat, plain: !(modifiers.alt || modifiers.ctrl || modifiers.command) };
let erase = backspace_erases(
@@ -425,6 +421,14 @@ pub fn keyboard(app: &mut CadApp, ctx: &egui::Context) {
}
}
/// What Escape does, and the right-click or menu "Cancel" that stand for it: what was typed so far
/// goes, and so does the running command.
pub fn escape(app: &mut CadApp) {
app.cmd.buffer.clear();
app.cmd.preedit.clear();
app.session.cancel();
}
pub fn submit(app: &mut CadApp) {
app.cmd.preedit.clear();
// Grip dimensional input: the typed lengths and angles place the grip.
+78 -9
View File
@@ -22,6 +22,7 @@
use cadcraft_doc::EntityKind;
use cadcraft_engine::snap::mode;
use cadcraft_engine::{Input, find_command};
use serde_json::json;
use crate::CadApp;
use crate::menus::{Entry, activate, entry_ui};
@@ -58,6 +59,10 @@ pub const TYPE: &str = "type:";
pub const KEYWORD: &str = "keyword:";
/// An object snap menu item ([`choose_snap`]).
pub const SNAP: &str = "snap:";
/// Dimension Style ▸ item: the selected dimensions take the style that follows.
pub const DIM_STYLE: &str = "dimstyle:";
/// Precision ▸ item: the selected dimensions show this many decimal places (an override).
pub const DIM_PRECISION: &str = "dimprecision:";
fn item(app: &CadApp, id: &str, label: Option<&str>) -> Option<Entry> {
let spec = find_command(id)?;
@@ -158,15 +163,18 @@ fn object_commands(app: &CadApp) -> Vec<(&'static str, Option<&'static str>)> {
}
}
/// [`object_commands`] that are registered, as menu items. The Edit Text entry of a single
/// selected text, mtext or attribute definition opens the Edit Text window instead of the
/// TEXTEDIT command line; the double-click keeps its in-place editing (#842), and several
/// selected texts still take the command line.
/// [`object_commands`] that are registered, as menu items, then the dimension shortcut menu's
/// items when the selection is dimensions. The Edit Text entry of a single selected text, mtext or
/// attribute definition opens the Edit Text window instead of the TEXTEDIT command line; the
/// double-click keeps its in-place editing (#842), and several selected texts still take the
/// command line.
pub fn object_entries(app: &CadApp) -> Vec<Entry> {
object_commands(app)
let mut out: Vec<Entry> = object_commands(app)
.into_iter()
.filter_map(|(id, label)| if id == "textedit" { edit_text_window_entry(app).or_else(|| item(app, id, label)) } else { item(app, id, label) })
.collect()
.collect();
out.extend(dimension_entries(app));
out
}
/// The Edit Text entry as the `textedit:<handle>` dialog id, for a single selected text, mtext
@@ -183,6 +191,64 @@ fn edit_text_window_entry(app: &CadApp) -> Option<Entry> {
Some(Entry::Item { label: "Edit Text".into(), id: format!("textedit:{}", h.hex()), shortcut: None, enabled: true })
}
/// For selected dimensions (and only dimensions): Align Text ▸, Dimension Style ▸ (the
/// drawing's styles, then Save as New Style), Precision ▸ and Remove Style Overrides.
fn dimension_entries(app: &CadApp) -> Vec<Entry> {
let Ok(d) = app.session.doc() else { return Vec::new() };
let sel = app.session.selection();
let dims: Vec<&cadcraft_doc::Dimension> =
sel.iter().filter_map(|h| d.entity(*h)).filter_map(|e| if let EntityKind::Dimension(dm) = &e.kind { Some(dm) } else { None }).collect();
if dims.is_empty() || dims.len() != sel.len() {
return Vec::new();
}
let mut out: Vec<Entry> =
sub("Align Text", items(app, &["dimtedit.home", "dimtedit.angle", "dimtedit.left", "dimtedit.center", "dimtedit.right"]))
.into_iter()
.collect();
// Style names are the drawing's own.
let mut styles: Vec<Entry> = d
.dim_styles
.iter()
.map(|st| Entry::Item { label: st.name.clone(), id: format!("{DIM_STYLE}{}", st.name), shortcut: None, enabled: true })
.collect();
styles.extend(item(app, "dimstyle.saveas", None));
out.extend(sub("Dimension Style", styles));
let precision = (0..=8usize)
.map(|n| Entry::Item {
label: if n == 0 { "0".into() } else { format!("0.{}", "0".repeat(n)) },
id: format!("{DIM_PRECISION}{n}"),
shortcut: None,
enabled: true,
})
.collect();
out.extend(sub("Precision", precision));
// Available while some selected dimension overrides its style.
if let Some(Entry::Item { label, id, shortcut, .. }) = item(app, "dimoverride.clear", None) {
out.push(Entry::Item { label, id, shortcut, enabled: dims.iter().any(|dm| !dm.overrides.is_empty()) });
}
out
}
/// Precision ▸: the selected dimensions show `places` decimal places (DIMDEC, or DIMADEC for
/// angular dimensions), as overrides.
fn set_precision(app: &mut CadApp, places: u8) {
let (mut linear, mut angular) = (Vec::new(), Vec::new());
if let Ok(d) = app.session.doc() {
for h in app.session.selection() {
if let Some(EntityKind::Dimension(dm)) = d.entity(h).map(|e| &e.kind) {
let list =
if matches!(dm.kind, cadcraft_doc::DimKind::Angular | cadcraft_doc::DimKind::Angular3P) { &mut angular } else { &mut linear };
list.push(h.hex());
}
}
}
for (hs, key) in [(linear, "decimals"), (angular, "angularDecimals")] {
if !hs.is_empty() {
let _ = app.run("properties.set", json!({ "handles": hs, key: places }));
}
}
}
/// The command menu while a command runs (`None` when none does): Enter and Cancel, Recent Input,
/// the prompt's options, Snap Overrides at point prompts, Pan and Zoom.
pub fn command_entries(app: &CadApp) -> Option<Vec<Vec<Entry>>> {
@@ -225,9 +291,7 @@ pub fn choose(app: &mut CadApp, id: &str) {
app.cmd.buffer.clear();
app.cmdline("");
} else if id == CANCEL {
// Escape.
app.cmd.buffer.clear();
app.session.cancel();
crate::cmdline::escape(app);
} else if let Some(text) = id.strip_prefix(TYPE) {
app.cmd.buffer.clear();
app.cmdline(text);
@@ -241,6 +305,11 @@ pub fn choose(app: &mut CadApp, id: &str) {
} else if id.starts_with("textedit:") {
// The Edit Text window of the single selected text object; the id carries the handle.
app.ui.dialog = Some(id.to_string());
} else if let Some(name) = id.strip_prefix(DIM_STYLE) {
let hs: Vec<String> = app.session.selection().iter().map(|h| h.hex()).collect();
let _ = app.run("properties.set", json!({ "handles": hs, "dimStyle": name }));
} else if let Some(n) = id.strip_prefix(DIM_PRECISION).and_then(|n| n.parse::<u8>().ok()) {
set_precision(app, n.min(8));
} else {
activate(app, id);
}
+45 -3
View File
@@ -691,6 +691,29 @@ impl Drop for PathlessShots {
}
}
fn write_screenshot_png(img: &image::RgbaImage, output: impl std::io::Write) -> std::io::Result<()> {
cadcraft_render::raster::write_rgba_png(output, img.width(), img.height(), img.as_raw())
.ok_or_else(|| std::io::Error::other("PNG encoding failed"))
}
fn save_explicit_screenshot(img: &image::RgbaImage, path: &str) -> std::io::Result<()> {
use craft_image_codecs::{ChannelLayout, EncodeOptions, Format, Image};
let format = match image::ImageFormat::from_path(path).map_err(std::io::Error::other)? {
image::ImageFormat::Png => Format::Png,
image::ImageFormat::Jpeg => Format::Jpeg,
image::ImageFormat::Bmp => Format::Bmp,
image::ImageFormat::Tiff => Format::Tiff,
_ => return Err(std::io::Error::other("unsupported screenshot format")),
};
if format == Format::Png {
return write_screenshot_png(img, std::fs::File::create(path)?);
}
let pixels = Image::from_u8(img.width(), img.height(), ChannelLayout::Rgba, img.as_raw().clone()).map_err(std::io::Error::other)?;
let opts = EncodeOptions { jpeg_quality: 75, jpeg_chroma_subsampling: false, ..EncodeOptions::default() };
let bytes = craft_image_codecs::encode(&pixels, format, &opts).map_err(std::io::Error::other)?;
std::fs::write(path, bytes)
}
/// Save a pathless screenshot into the private per-process directory: re-validate or recreate it as an owner-only real directory (0700 on Unix; plain create elsewhere), then create up to 64 exclusive files (0600 on Unix) and write a PNG.
fn save_pathless_screenshot(img: &image::RgbaImage, token: u64) -> std::io::Result<std::path::PathBuf> {
use std::io::Write as _;
@@ -713,7 +736,7 @@ fn save_pathless_screenshot(img: &image::RgbaImage, token: u64) -> std::io::Resu
let path = dir.join(format!("cadcraft-shot-{token}-{}.png", next_pathless_nonce()));
match create_private_file(&path) {
Ok(mut file) => {
let written = img.write_to(&mut file, image::ImageFormat::Png).map_err(std::io::Error::other).and_then(|()| file.flush());
let written = write_screenshot_png(img, &mut file).and_then(|()| file.flush());
if let Err(e) = written {
// The reply carries no path on failure, so nobody else could remove the partial file.
drop(file);
@@ -752,7 +775,7 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>, token: u64)
return inline_screenshot(&img, token);
}
let saved = match path {
Some(path) => img.save(path).map(|()| path.to_string()).map_err(std::io::Error::other),
Some(path) => save_explicit_screenshot(&img, path).map(|()| path.to_string()),
None => save_pathless_screenshot(&img, token).map(|path| path.to_string_lossy().into_owned()),
};
match saved {
@@ -766,7 +789,7 @@ pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>, token: u64)
fn inline_screenshot(img: &image::RgbaImage, token: u64) -> Value {
let (w, h) = img.dimensions();
let mut png = Vec::new();
if let Err(e) = img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png) {
if let Err(e) = write_screenshot_png(img, &mut png) {
return json!({"ok": false, "error": e.to_string(), "request": token});
}
json!({"ok": true, "request": token, "result": {"pngBase64": cadcraft_engine::cmd::file::base64_encode(&png), "width": w, "height": h, "bytes": png.len()}})
@@ -776,6 +799,25 @@ fn inline_screenshot(img: &image::RgbaImage, token: u64) -> Value {
mod tests {
use super::*;
#[test]
fn explicit_screenshot_retains_supported_file_formats() {
let img = image::RgbaImage::from_pixel(3, 2, image::Rgba([10, 20, 30, 128]));
for ext in ["png", "bmp", "tiff", "jpg"] {
let path = std::env::temp_dir().join(format!("cadcraft-format-{}-{}.{}", std::process::id(), next_pathless_nonce(), ext));
let name = path.to_string_lossy().to_string();
save_explicit_screenshot(&img, &name).unwrap();
let decoded = image::open(&path).unwrap().to_rgba8();
assert_eq!(decoded.dimensions(), img.dimensions(), "{ext}");
if ext != "jpg" {
let mut original = std::io::Cursor::new(Vec::new());
img.write_to(&mut original, image::ImageFormat::from_path(&path).unwrap()).unwrap();
let original = image::load_from_memory(&original.into_inner()).unwrap().to_rgba8();
assert_eq!(decoded.as_raw(), original.as_raw(), "{ext}");
}
std::fs::remove_file(path).unwrap();
}
}
#[test]
fn an_inline_screenshot_carries_the_png_and_its_size() {
let img = image::RgbaImage::from_pixel(3, 2, image::Rgba([10, 20, 30, 255]));
+99 -170
View File
@@ -28,7 +28,6 @@ pub fn show(app: &mut CadApp, ctx: &egui::Context) {
"about" => about(ctx, &mut open),
"preview" => crate::exchange::dialog(app, ctx, &mut open),
"commands" => commands(app, ctx, &mut open),
"blocks" => blocks(app, ctx, &mut open),
"bedit" => crate::bedit::dialog(app, ctx, &mut open),
"authoring" => crate::bedit::authoring_dialog(app, ctx, &mut open),
"stylesmanager" => crate::plotstyles::dialog(app, ctx, &mut open),
@@ -46,104 +45,112 @@ pub fn show(app: &mut CadApp, ctx: &egui::Context) {
fn dsettings(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
let settings = app.session.drafting_settings();
let (mut snapunit, mut gridunit) = (settings.snapunit, settings.gridunit);
egui::Window::new(crate::tl!("Drafting Settings")).id(egui::Id::unique("Drafting Settings")).open(open).resizable(false).show(ctx, |ui| {
let s = &mut app.session.settings;
ui.heading(crate::tl!("Snap and Grid"));
ui.checkbox(&mut s.snapmode, crate::tl!("Snap On (F9)"));
// SNAPSTYL: the isometric snap and grid (ISODRAFT).
ui.horizontal(|ui| {
ui.radio_value(&mut s.isodraft, false, crate::tl!("Rectangular snap"));
ui.radio_value(&mut s.isodraft, true, crate::tl!("Isometric snap"));
});
ui.horizontal(|ui| {
let x_label = ui.label(crate::tl!("Snap X spacing"));
ui.add(egui::DragValue::new(&mut snapunit.x).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(x_label.id);
let y_label = ui.label(crate::tl!("Y"));
ui.add(egui::DragValue::new(&mut snapunit.y).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(y_label.id);
});
// SNAPTYPE and POLARDIST.
ui.horizontal(|ui| {
ui.label(crate::tl!("Snap type"));
ui.radio_value(&mut s.polarsnap, false, crate::tl!("Grid snap"));
ui.radio_value(&mut s.polarsnap, true, crate::tl!("PolarSnap"));
});
ui.add_enabled_ui(s.polarsnap, |ui| {
let window = egui::Window::new(crate::tl!("Drafting Settings")).id(egui::Id::unique("Drafting Settings")).open(open).resizable(false);
// Taller than a short screen, so the options scroll to keep the window on screen and every one
// reachable (#2339). Asking for the screen's height every frame (egui caps it to the screen)
// gives the scroll area all of it, not the 420-point default or a height kept from a shorter
// screen; the window still takes the height of its contents when they fit.
let window = window.min_height(ctx.content_rect().height());
window.show(ctx, |ui| {
egui::ScrollArea::vertical().show(ui, |ui| {
let s = &mut app.session.settings;
ui.heading(crate::tl!("Snap and Grid"));
ui.checkbox(&mut s.snapmode, crate::tl!("Snap On (F9)"));
// SNAPSTYL: the isometric snap and grid (ISODRAFT).
ui.horizontal(|ui| {
let label = ui.label(crate::tl!("Polar distance"));
ui.add(egui::DragValue::new(&mut s.polardist).speed(0.05).range(0.0..=1e6)).labelled_by(label.id);
ui.radio_value(&mut s.isodraft, false, crate::tl!("Rectangular snap"));
ui.radio_value(&mut s.isodraft, true, crate::tl!("Isometric snap"));
});
});
ui.checkbox(&mut s.gridmode, crate::tl!("Grid On (F7)"));
ui.horizontal(|ui| {
let grid_label = ui.label(crate::tl!("Grid spacing"));
ui.add(egui::DragValue::new(&mut gridunit.x).speed(0.05).range(0.0..=1e6).clamp_existing_to_range(false)).labelled_by(grid_label.id);
let major_label = ui.label(crate::tl!("Major line every"));
ui.add(egui::DragValue::new(&mut s.gridmajor).range(1..=100)).labelled_by(major_label.id);
});
ui.separator();
ui.heading(crate::tl!("Polar Tracking"));
ui.checkbox(&mut s.polarmode, crate::tl!("Polar Tracking On (F10)"));
// POLARANG is held in radians and 15 or 30 come back as 14.999999999999998: round like
// the additional angles, and write back only a newly picked angle.
let current = (s.polarang.to_degrees() * 1e6).round() / 1e6;
let mut deg = current;
ui.horizontal(|ui| {
let label = ui.label(crate::tl!("Increment angle"));
let combo = craft_ui::ComboBox::from_id_salt("polarang").selected_text(format!("{deg}")).show_ui(ui, |ui| {
for a in [90.0, 45.0, 30.0, 22.5, 18.0, 15.0, 10.0, 5.0] {
ui.selectable_value(&mut deg, a, format!("{a}"));
}
ui.horizontal(|ui| {
let x_label = ui.label(crate::tl!("Snap X spacing"));
ui.add(egui::DragValue::new(&mut snapunit.x).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(x_label.id);
let y_label = ui.label(crate::tl!("Y"));
ui.add(egui::DragValue::new(&mut snapunit.y).speed(0.05).range(0.0001..=1e6).clamp_existing_to_range(false)).labelled_by(y_label.id);
});
combo.response.labelled_by(label.id);
});
if deg != current {
s.polarang = deg.to_radians();
}
tracking_options(ui, s);
ui.separator();
ui.heading(crate::tl!("Object Snap"));
let mut on = s.osmode & cadcraft_engine::snap::mode::OFF == 0;
if ui.checkbox(&mut on, crate::tl!("Object Snap On (F3)")).changed() {
if on {
s.osmode &= !cadcraft_engine::snap::mode::OFF;
} else {
s.osmode |= cadcraft_engine::snap::mode::OFF;
// SNAPTYPE and POLARDIST.
ui.horizontal(|ui| {
ui.label(crate::tl!("Snap type"));
ui.radio_value(&mut s.polarsnap, false, crate::tl!("Grid snap"));
ui.radio_value(&mut s.polarsnap, true, crate::tl!("PolarSnap"));
});
ui.add_enabled_ui(s.polarsnap, |ui| {
ui.horizontal(|ui| {
let label = ui.label(crate::tl!("Polar distance"));
ui.add(egui::DragValue::new(&mut s.polardist).speed(0.05).range(0.0..=1e6)).labelled_by(label.id);
});
});
ui.checkbox(&mut s.gridmode, crate::tl!("Grid On (F7)"));
ui.horizontal(|ui| {
let grid_label = ui.label(crate::tl!("Grid spacing"));
ui.add(egui::DragValue::new(&mut gridunit.x).speed(0.05).range(0.0..=1e6).clamp_existing_to_range(false)).labelled_by(grid_label.id);
let major_label = ui.label(crate::tl!("Major line every"));
ui.add(egui::DragValue::new(&mut s.gridmajor).range(1..=100)).labelled_by(major_label.id);
});
ui.separator();
ui.heading(crate::tl!("Polar Tracking"));
ui.checkbox(&mut s.polarmode, crate::tl!("Polar Tracking On (F10)"));
// POLARANG is held in radians and 15 or 30 come back as 14.999999999999998: round like
// the additional angles, and write back only a newly picked angle.
let current = (s.polarang.to_degrees() * 1e6).round() / 1e6;
let mut deg = current;
ui.horizontal(|ui| {
let label = ui.label(crate::tl!("Increment angle"));
let combo = craft_ui::ComboBox::from_id_salt("polarang").selected_text(format!("{deg}")).show_ui(ui, |ui| {
for a in [90.0, 45.0, 30.0, 22.5, 18.0, 15.0, 10.0, 5.0] {
ui.selectable_value(&mut deg, a, format!("{a}"));
}
});
combo.response.labelled_by(label.id);
});
if deg != current {
s.polarang = deg.to_radians();
}
}
egui::Grid::new("osnap_grid").num_columns(2).show(ui, |ui| {
for (i, (bit, name)) in cadcraft_engine::snap::mode::ALL.iter().enumerate() {
let mut v = s.osmode & bit != 0;
if ui.checkbox(&mut v, crate::i18n::t(name)).changed() {
if v {
s.osmode |= bit;
} else {
s.osmode &= !bit;
tracking_options(ui, s);
ui.separator();
ui.heading(crate::tl!("Object Snap"));
let mut on = s.osmode & cadcraft_engine::snap::mode::OFF == 0;
if ui.checkbox(&mut on, crate::tl!("Object Snap On (F3)")).changed() {
if on {
s.osmode &= !cadcraft_engine::snap::mode::OFF;
} else {
s.osmode |= cadcraft_engine::snap::mode::OFF;
}
}
egui::Grid::new("osnap_grid").num_columns(2).show(ui, |ui| {
for (i, (bit, name)) in cadcraft_engine::snap::mode::ALL.iter().enumerate() {
let mut v = s.osmode & bit != 0;
if ui.checkbox(&mut v, crate::i18n::t(name)).changed() {
if v {
s.osmode |= bit;
} else {
s.osmode &= !bit;
}
}
if i % 2 == 1 {
ui.end_row();
}
}
if i % 2 == 1 {
ui.end_row();
}
}
});
ui.separator();
ui.checkbox(&mut s.dynmode, crate::tl!("Enable Dynamic Input (F12)"));
// Pointer input format for second and next points (DYNPIFORMAT, DYNPICOORDS).
ui.indent("dynpi", |ui| {
ui.add_enabled_ui(s.dynmode, |ui| {
ui.label(crate::tl!("Second and next points:"));
ui.horizontal(|ui| {
ui.radio_value(&mut s.dynpi_cartesian, false, crate::tl!("Polar (distance < angle)"));
ui.radio_value(&mut s.dynpi_cartesian, true, crate::tl!("Cartesian (x, y)"));
});
ui.horizontal(|ui| {
ui.radio_value(&mut s.dynpi_absolute, false, crate::tl!("Relative"));
ui.radio_value(&mut s.dynpi_absolute, true, crate::tl!("Absolute"));
});
// DYNPROMPT: the prompt and its options (Down Arrow) beside the cursor.
ui.checkbox(&mut s.dynprompt, crate::tl!("Show command prompting near the crosshairs"));
});
});
ui.checkbox(&mut s.orthomode, crate::tl!("Ortho (F8)"));
ui.separator();
ui.checkbox(&mut s.dynmode, crate::tl!("Enable Dynamic Input (F12)"));
// Pointer input format for second and next points (DYNPIFORMAT, DYNPICOORDS).
ui.indent("dynpi", |ui| {
ui.add_enabled_ui(s.dynmode, |ui| {
ui.label(crate::tl!("Second and next points:"));
ui.horizontal(|ui| {
ui.radio_value(&mut s.dynpi_cartesian, false, crate::tl!("Polar (distance < angle)"));
ui.radio_value(&mut s.dynpi_cartesian, true, crate::tl!("Cartesian (x, y)"));
});
ui.horizontal(|ui| {
ui.radio_value(&mut s.dynpi_absolute, false, crate::tl!("Relative"));
ui.radio_value(&mut s.dynpi_absolute, true, crate::tl!("Absolute"));
});
// DYNPROMPT: the prompt and its options (Down Arrow) beside the cursor.
ui.checkbox(&mut s.dynprompt, crate::tl!("Show command prompting near the crosshairs"));
});
});
ui.checkbox(&mut s.orthomode, crate::tl!("Ortho (F8)"));
})
});
// Drawing edits go through the same command as the CLI, including dirty state and undo.
for (name, before, after) in [("SNAPUNIT", settings.snapunit, snapunit), ("GRIDUNIT", settings.gridunit, gridunit)] {
@@ -399,38 +406,6 @@ fn commands(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
}
}
/// Blocks window listing named (non-anonymous) blocks; clicking one starts INSERT with that block name already supplied.
fn blocks(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
let mut pick = None;
egui::Window::new(crate::tl!("Blocks")).id(egui::Id::unique("Blocks")).open(open).default_size(vec2(320.0, 360.0)).show(ctx, |ui| {
let Ok(d) = app.session.doc() else { return };
let names: Vec<&String> = d.blocks.keys().filter(|k| !k.starts_with('*')).collect();
if names.is_empty() {
ui.label(crate::tl!("No blocks defined in this drawing."));
}
for n in names {
if ui.button(n).on_hover_text(crate::tl!("Insert this block")).clicked() {
pick = Some(n.clone());
}
}
});
if let Some(n) = pick {
insert_block(app, &n);
}
}
/// Start INSERT with `name` already given at its block name prompt, so the next prompt asks for
/// the insertion point.
fn insert_block(app: &mut CadApp, name: &str) {
app.start("insert");
if app.session.running.as_ref().is_none_or(|r| r.id != "insert") {
return;
}
if let Err(e) = app.session.input(cadcraft_engine::Input::Text(name.to_string())) {
app.session.echo(e.to_string());
}
}
/// Interface Language combo; selecting a language runs `ui.language` with its code.
fn language(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
egui::Window::new(crate::tl!("Interface Language")).id(egui::Id::unique("interface_language")).open(open).resizable(false).show(ctx, |ui| {
@@ -447,13 +422,6 @@ fn language(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
#[cfg(test)]
mod tests {
use cadcraft_engine::doc::EntityKind;
use cadcraft_engine::geom::Vec2;
use cadcraft_engine::{Input, Session};
use serde_json::json;
use crate::{CadApp, Services};
#[test]
fn fractional_length_precisions_list_binary_fractions() {
let labels = ["1\"", "1/2\"", "1/4\"", "1/8\"", "1/16\"", "1/32\"", "1/64\"", "1/128\"", "1/256\""];
@@ -462,43 +430,4 @@ mod tests {
assert_eq!(super::length_precisions(5), want);
assert_eq!(super::length_precisions(2).len(), 9);
}
#[test]
fn picking_a_block_starts_insert_with_its_name() {
let mut app = CadApp::new(Session::new(), Services::default());
let c = app.session.execute("circle", &json!({"center": [0, 0], "radius": 1})).unwrap();
let h = c["handle"].as_str().unwrap().to_string();
app.session.execute("block", &json!({"name": "Door 2", "base": [0, 0], "handles": [h], "keep": "delete"})).unwrap();
// A command already running is replaced, as when a command is typed.
app.start("line");
super::insert_block(&mut app, "Door 2");
assert!(app.session.running.as_ref().is_some_and(|r| r.id == "insert"));
assert_eq!(app.session.current_prompt().map(|p| p.message), Some("Specify insertion point".to_string()));
app.session.input(Input::Point(Vec2::new(5.0, 6.0))).unwrap();
// X scale, Y scale and rotation take their defaults.
for _ in 0..3 {
app.session.input(Input::Enter).unwrap();
}
assert!(app.session.running.is_none());
let d = app.session.doc().unwrap();
let mut ins = Vec::new();
for e in d.model.iter() {
if let EntityKind::Insert(i) = &e.kind {
ins.push(i.clone());
}
}
assert_eq!(ins.len(), 1);
assert_eq!(ins[0].block, "Door 2");
assert!((ins[0].insert.x - 5.0).abs() < 1e-9 && (ins[0].insert.y - 6.0).abs() < 1e-9);
}
#[test]
fn picking_a_missing_block_keeps_asking_for_a_name() {
let mut app = CadApp::new(Session::new(), Services::default());
super::insert_block(&mut app, "Nope");
assert!(app.session.running.as_ref().is_some_and(|r| r.id == "insert"));
assert_eq!(app.session.current_prompt().map(|p| p.message), Some("Enter block name".to_string()));
}
}
+13 -1
View File
@@ -19,6 +19,7 @@ pub enum Panel {
Properties,
#[serde(rename = "externalReferences")]
ExternalRefs,
Blocks,
}
impl Panel {
@@ -31,6 +32,7 @@ impl Panel {
Self::Layers => "layers",
Self::Properties => "properties",
Self::ExternalRefs => "externalReferences",
Self::Blocks => "blocks",
}
}
fn label(self) -> &'static str {
@@ -41,6 +43,7 @@ impl Panel {
Self::Layers => "Layers",
Self::Properties => "Properties",
Self::ExternalRefs => "External References",
Self::Blocks => "Blocks",
}
}
/// The icon a palette shows in a column collapsed to icons.
@@ -53,10 +56,11 @@ impl Panel {
Self::Layers => Some(Icon::Layers),
Self::Properties => Some(Icon::Properties),
Self::ExternalRefs => Some(Icon::Attach),
Self::Blocks => Some(Icon::Blocks),
}
}
/// Palettes outside the default arrangement, opened on request (QUICKCALC).
pub const ON_DEMAND: &[Self] = &[Self::QuickCalc];
pub const ON_DEMAND: &[Self] = &[Self::QuickCalc, Self::Blocks];
}
/// The drawing view never moves, floats, closes or takes tabs; palettes dock beside it.
@@ -149,6 +153,7 @@ fn home_anchor(layout: &Layout<Panel>, panel: Panel) -> Option<(Panel, bool)> {
Panel::Properties => &[(Panel::Layers, true), (Panel::ExternalRefs, false)],
Panel::ExternalRefs => &[(Panel::Properties, true), (Panel::Layers, true)],
Panel::QuickCalc => &[(Panel::ExternalRefs, true), (Panel::Properties, true), (Panel::Layers, true)],
Panel::Blocks => &[(Panel::QuickCalc, true), (Panel::ExternalRefs, true), (Panel::Properties, true), (Panel::Layers, true)],
};
if let Some(found) = neighbours.iter().copied().find(|(neighbour, _)| docked(layout, *neighbour)) {
return Some(found);
@@ -414,6 +419,12 @@ impl DockContent<Panel> for Panels<'_> {
Panel::ExternalRefs => {
egui::ScrollArea::both().id_salt("dock-xrefs").auto_shrink([false, false]).show(ui, |ui| crate::xrefs::section(app, ui));
}
Panel::Blocks => {
egui::ScrollArea::vertical()
.id_salt("dock-blocks")
.auto_shrink([false, false])
.show(ui, |ui| crate::blocks_palette::section(app, ui));
}
}
}
fn logical_label(&self, panel: &Panel) -> String {
@@ -442,6 +453,7 @@ fn panel_limits(panel: &Panel) -> PanelLimits {
Panel::QuickCalc => (egui::vec2(240.0, 160.0), 600.0),
Panel::ToolSets => (egui::vec2(220.0, 150.0), 480.0),
Panel::Layers | Panel::Properties | Panel::ExternalRefs => (egui::vec2(220.0, 100.0), 720.0),
Panel::Blocks => (egui::vec2(240.0, 260.0), 720.0),
};
PanelLimits { min, max: egui::vec2(max_width, 1_000_000.0) }
}
+21 -6
View File
@@ -70,16 +70,12 @@ fn render(app: &mut CadApp, ctx: &egui::Context) -> Result<(TextureHandle, Strin
if let Some(f) = ctx.data(|d| d.get_temp::<FromPlot>(egui::Id::unique(FROM_PLOT))) {
let r = app.session.execute("plot", &f.params).map_err(|e| e.to_string())?;
let png = r["data"].as_str().and_then(cadcraft_engine::cmd::file::base64_decode).ok_or("the preview has no image")?;
let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| e.to_string())?.to_rgba8();
let size = [img.width() as usize, img.height() as usize];
let tex = ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR);
let tex = preview_texture(ctx, &png)?;
return Ok((tex, f.info));
}
let r = app.session.execute("preview", &json!({ "width": 1600 })).map_err(|e| e.to_string())?;
let png = r["data"].as_str().and_then(cadcraft_engine::cmd::file::base64_decode).ok_or("the preview has no image")?;
let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| e.to_string())?.to_rgba8();
let size = [img.width() as usize, img.height() as usize];
let tex = ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.as_raw()), egui::TextureOptions::LINEAR);
let tex = preview_texture(ctx, &png)?;
let mut info = format!("{} · {}", r["layout"].as_str().unwrap_or(""), r["paper"].as_str().unwrap_or(""));
if r["landscape"].as_bool() == Some(true) {
info.push_str(" · landscape");
@@ -87,6 +83,15 @@ fn render(app: &mut CadApp, ctx: &egui::Context) -> Result<(TextureHandle, Strin
Ok((tex, info))
}
fn preview_texture(ctx: &egui::Context, png: &[u8]) -> Result<TextureHandle, String> {
if !png.starts_with(b"\x89PNG\r\n\x1a\n") {
return Err("the preview is not a PNG".into());
}
let img = cadcraft_io::raster::decode(png).map_err(|e| e.to_string())?;
let size = [img.width() as usize, img.height() as usize];
Ok(ctx.load_texture("plot-preview", egui::ColorImage::from_rgba_unmultiplied(size, img.rgba()), egui::TextureOptions::LINEAR))
}
/// The Plot Preview window: the sheet as it plots, with Print and Close.
pub fn dialog(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) {
let id = egui::Id::unique("cc_plot_preview");
@@ -169,6 +174,16 @@ mod tests {
(CadApp::new(Session::new(), services), asked)
}
#[test]
fn plot_preview_reads_shared_png_and_rejects_other_bytes() {
let ctx = egui::Context::default();
let mut png = Vec::new();
cadcraft_render::raster::write_rgba_png(&mut png, 1, 1, &[10, 20, 30, 255]).unwrap();
let texture = super::preview_texture(&ctx, &png).unwrap();
assert_eq!(texture.size(), [1, 1]);
assert!(super::preview_texture(&ctx, b"not a PNG").is_err());
}
#[test]
fn typed_and_menu_commands_ask_json_calls_never_do() {
let (mut app, asked) = app();
+28
View File
@@ -906,6 +906,7 @@
Set Current Viewport تعيين إطار العرض الحالي
Set Layer Properties تعيين خصائص الطبقة
Set Properties تعيين الخصائص
Describe Properties وصف الخصائص
Set Table Cell تعيين خلية الجدول
Set Table Cell Style تعيين نمط خلية الجدول
Set Variable تعيين متغير
@@ -1368,6 +1369,33 @@ menu View عرض
overrides built-in يتجاوز المدمج
{alias} is already defined; select it and use Edit. {alias} معرَّف مسبقاً؛ حدده واستخدم «تحرير».
{command} is an unknown command. {command} أمر غير معروف.
Add a drawing file as a block library إضافة ملف رسم كمكتبة كتل
Add a folder of drawings or a drawing file to use its blocks. أضف مجلدًا يحتوي على رسومات أو ملف رسم لاستخدام كتله.
Block Libraries مكتبات الكتل
Block Library مكتبة الكتل
Blocks Palette لوحة الكتل
Click a block, then pick its insertion point. انقر على كتلة ثم حدّد نقطة إدراجها.
Current Drawing الرسم الحالي
Details التفاصيل
Extra Large Icons أيقونات كبيرة جدًا
Folder or file مجلد أو ملف
Import Library Block استيراد كتلة من المكتبة
Insert and Explode إدراج وتفجير
Large Icons أيقونات كبيرة
Libraries المكتبات
Medium Icons أيقونات متوسطة
No block matches the filter. لا توجد كتلة تطابق عامل التصفية.
This block is already in the drawing, so its definition is used. هذه الكتلة موجودة بالفعل في الرسم، لذلك يتم استخدام تعريفها.
Open Library... فتح مكتبة...
Read the library again إعادة قراءة المكتبة
Reading the library... جارٍ قراءة المكتبة...
Refresh تحديث
Remove from the list إزالة من القائمة
Repeat Placement تكرار الوضع
Small Icons أيقونات صغيرة
This drawing has no blocks. لا يحتوي هذا الرسم على كتل.
This library has no drawings or blocks. لا تحتوي هذه المكتبة على رسومات أو كتل.
Only the first {n} are shown. يتم عرض أول {n} فقط.
Find All Find All
Find what: Find what:
Match case Match case
Can't render this file because it contains an unexpected character in line 1336 and column 24.
+27
View File
@@ -1444,6 +1444,33 @@ menu Modify Izmijeni
Save changes to block "{name}"? Sačuvati promjene u bloku „{name}”?
Layouts Rasporedi
Associate Poveži
Add a drawing file as a block library Dodaj datoteku crteža kao biblioteku blokova
Add a folder of drawings or a drawing file to use its blocks. Dodajte mapu s crtežima ili datoteku crteža da biste koristili njene blokove.
Block Libraries Biblioteke blokova
Block Library Biblioteka blokova
Blocks Palette Paleta blokova
Click a block, then pick its insertion point. Kliknite na blok, zatim odredite njegovu tačku umetanja.
Current Drawing Trenutni crtež
Details Detalji
Extra Large Icons Veoma velike ikone
Folder or file Mapa ili datoteka
Import Library Block Uvezi blok iz biblioteke
Insert and Explode Umetni i rastavi
Large Icons Velike ikone
Libraries Biblioteke
Medium Icons Srednje ikone
No block matches the filter. Nijedan blok ne odgovara filteru.
This block is already in the drawing, so its definition is used. Ovaj blok već postoji u crtežu, pa se koristi njegova definicija.
Open Library... Otvori biblioteku...
Read the library again Ponovo učitaj biblioteku
Reading the library... Čitanje biblioteke...
Refresh Osvježi
Remove from the list Ukloni s liste
Repeat Placement Ponovi postavljanje
Small Icons Male ikone
This drawing has no blocks. Ovaj crtež nema blokova.
This library has no drawings or blocks. Ova biblioteka nema crteža ni blokova.
Only the first {n} are shown. Prikazano je samo prvih {n}.
Find All Find All
Find what: Find what:
Match case Match case
Can't render this file because it contains an unexpected character in line 1444 and column 24.
+28
View File
@@ -840,6 +840,7 @@
Set Current Viewport Nastavit aktuální výřez
Set Layer Properties Nastavit vlastnosti hladiny
Set Properties Nastavit vlastnosti
Describe Properties Popsat vlastnosti
Set Table Cell Nastavit buňku tabulky
Set Table Cell Style Nastavit styl buňky tabulky
Set Variable Nastavit proměnnou
@@ -1224,6 +1225,33 @@ menu Modify Modifikace
Check for Updates… Zkontrolovat aktualizace…
CADCraft is up to date. CADCraft je aktuální.
Could not check for updates. Aktualizace se nepodařilo zkontrolovat.
Add a drawing file as a block library Přidat výkresový soubor jako knihovnu bloků
Add a folder of drawings or a drawing file to use its blocks. Přidejte složku s výkresy nebo výkresový soubor, abyste mohli používat jeho bloky.
Block Libraries Knihovny bloků
Block Library Knihovna bloků
Blocks Palette Paleta bloků
Click a block, then pick its insertion point. Klikněte na blok a poté určete jeho vkládací bod.
Current Drawing Aktuální výkres
Details Podrobnosti
Extra Large Icons Extra velké ikony
Folder or file Složka nebo soubor
Import Library Block Importovat blok z knihovny
Insert and Explode Vložit a rozložit
Large Icons Velké ikony
Libraries Knihovny
Medium Icons Střední ikony
No block matches the filter. Filtru neodpovídá žádný blok.
This block is already in the drawing, so its definition is used. Tento blok už v kresbě je, proto se použije jeho definice.
Open Library... Otevřít knihovnu...
Read the library again Načíst knihovnu znovu
Reading the library... Načítání knihovny...
Refresh Obnovit
Remove from the list Odebrat ze seznamu
Repeat Placement Opakovat umístění
Small Icons Malé ikony
This drawing has no blocks. Tento výkres neobsahuje žádné bloky.
This library has no drawings or blocks. Tato knihovna neobsahuje žádné výkresy ani bloky.
Only the first {n} are shown. Zobrazuje se pouze prvních {n}.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft Czech interface catalog — original translations by @Losminek (AI-assisted).
840
841
842
843
844
845
846
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
+29
View File
@@ -729,6 +729,7 @@
Set Current Text Style Textstil als aktuell festlegen
Set Layer Properties Layer-Eigenschaften festlegen
Set Properties Eigenschaften festlegen
Describe Properties Eigenschaften beschreiben
Set Table Cell Tabellenzelle festlegen
Set Variable Variable festlegen
Set View Ansicht festlegen
@@ -1041,6 +1042,34 @@
Check for Updates… Nach Updates suchen…
CADCraft is up to date. CADCraft ist auf dem neuesten Stand.
Could not check for updates. Die Suche nach Updates ist fehlgeschlagen.
Add a drawing file as a block library Zeichnungsdatei als Blockbibliothek hinzufügen
Add a folder of drawings or a drawing file to use its blocks. Fügen Sie einen Ordner mit Zeichnungen oder eine Zeichnungsdatei hinzu, um deren Blöcke zu verwenden.
Block Libraries Blockbibliotheken
Block Library Blockbibliothek
Blocks Palette Blockpalette
Click a block, then pick its insertion point. Klicken Sie auf einen Block und geben Sie dann den Einfügepunkt an.
Current Drawing Aktuelle Zeichnung
Details Details
Extra Large Icons Extragroße Symbole
Folder or file Ordner oder Datei
Import Library Block Bibliotheksblock importieren
Insert and Explode Einfügen und auflösen
Large Icons Große Symbole
Libraries Bibliotheken
Medium Icons Mittelgroße Symbole
No block matches the filter. Kein Block entspricht dem Filter.
This block is already in the drawing, so its definition is used. Dieser Block ist bereits in der Zeichnung, daher wird seine Definition verwendet.
Open Library... Bibliothek öffnen...
Read the library again Bibliothek erneut lesen
Reading the library... Bibliothek wird gelesen...
Refresh Aktualisieren
Remove from the list Aus der Liste entfernen
Repeat Placement Platzierung wiederholen
Small Icons Kleine Symbole
This drawing has no blocks. Diese Zeichnung enthält keine Blöcke.
This library has no drawings or blocks. Diese Bibliothek enthält keine Zeichnungen oder Blöcke.
Options Optionen
Only the first {n} are shown. Nur die ersten {n} werden angezeigt.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft German interface catalog — original translations by the CADCraft contributors.
729
730
731
732
733
734
735
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
+27
View File
@@ -1381,6 +1381,33 @@ menu View Προβολή
Check for Updates… Έλεγχος για ενημερώσεις…
CADCraft is up to date. Το CADCraft είναι ενημερωμένο.
Could not check for updates. Δεν ήταν δυνατός ο έλεγχος για ενημερώσεις.
Add a drawing file as a block library Προσθήκη αρχείου σχεδίου ως βιβλιοθήκης μπλοκ
Add a folder of drawings or a drawing file to use its blocks. Προσθέστε έναν φάκελο με σχέδια ή ένα αρχείο σχεδίου για να χρησιμοποιήσετε τα μπλοκ του.
Block Libraries Βιβλιοθήκες μπλοκ
Block Library Βιβλιοθήκη μπλοκ
Blocks Palette Παλέτα μπλοκ
Click a block, then pick its insertion point. Κάντε κλικ σε ένα μπλοκ και μετά ορίστε το σημείο εισαγωγής του.
Current Drawing Τρέχον σχέδιο
Details Λεπτομέρειες
Extra Large Icons Πολύ μεγάλα εικονίδια
Folder or file Φάκελος ή αρχείο
Import Library Block Εισαγωγή μπλοκ βιβλιοθήκης
Insert and Explode Εισαγωγή και διάσπαση
Large Icons Μεγάλα εικονίδια
Libraries Βιβλιοθήκες
Medium Icons Μεσαία εικονίδια
No block matches the filter. Κανένα μπλοκ δεν ταιριάζει με το φίλτρο.
This block is already in the drawing, so its definition is used. Αυτό το μπλοκ υπάρχει ήδη στο σχέδιο, οπότε χρησιμοποιείται ο ορισμός του.
Open Library... Άνοιγμα βιβλιοθήκης...
Read the library again Επανάγνωση της βιβλιοθήκης
Reading the library... Ανάγνωση της βιβλιοθήκης...
Refresh Ανανέωση
Remove from the list Αφαίρεση από τη λίστα
Repeat Placement Επανάληψη τοποθέτησης
Small Icons Μικρά εικονίδια
This drawing has no blocks. Αυτό το σχέδιο δεν έχει μπλοκ.
This library has no drawings or blocks. Αυτή η βιβλιοθήκη δεν έχει σχέδια ή μπλοκ.
Only the first {n} are shown. Εμφανίζονται μόνο τα πρώτα {n}.
Find All Find All
Find what: Find what:
Match case Match case
Can't render this file because it contains an unexpected character in line 234 and column 24.
+28
View File
@@ -933,6 +933,7 @@
Set Current Text Style Establecer estilo de texto actual
Set Layer Properties Establecer propiedades de capa
Set Properties Establecer propiedades
Describe Properties Describir propiedades
Set Table Cell Establecer celda de tabla
Set Variable Establecer variable
Set View Establecer vista
@@ -1255,6 +1256,33 @@
Check for Updates… Buscar actualizaciones…
CADCraft is up to date. CADCraft está actualizado.
Could not check for updates. No se pudo buscar actualizaciones.
Add a drawing file as a block library Añadir un archivo de dibujo como biblioteca de bloques
Add a folder of drawings or a drawing file to use its blocks. Añada una carpeta de dibujos o un archivo de dibujo para usar sus bloques.
Block Libraries Bibliotecas de bloques
Block Library Biblioteca de bloques
Blocks Palette Paleta de bloques
Click a block, then pick its insertion point. Haga clic en un bloque y luego indique su punto de inserción.
Current Drawing Dibujo actual
Details Detalles
Extra Large Icons Iconos extragrandes
Folder or file Carpeta o archivo
Import Library Block Importar bloque de biblioteca
Insert and Explode Insertar y descomponer
Large Icons Iconos grandes
Libraries Bibliotecas
Medium Icons Iconos medianos
No block matches the filter. Ningún bloque coincide con el filtro.
This block is already in the drawing, so its definition is used. Este bloque ya está en el dibujo, así que se usa su definición.
Open Library... Abrir biblioteca...
Read the library again Volver a leer la biblioteca
Reading the library... Leyendo la biblioteca...
Refresh Actualizar
Remove from the list Quitar de la lista
Repeat Placement Repetir colocación
Small Icons Iconos pequeños
This drawing has no blocks. Este dibujo no tiene bloques.
This library has no drawings or blocks. Esta biblioteca no tiene dibujos ni bloques.
Only the first {n} are shown. Solo se muestran los primeros {n}.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft Spanish interface catalog — original translations.
933
934
935
936
937
938
939
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
+29
View File
@@ -723,6 +723,7 @@
Set Current Text Style Définir le style de texte courant
Set Layer Properties Définir les propriétés du calque
Set Properties Définir les propriétés
Describe Properties Décrire les propriétés
Set Table Cell Définir la cellule de tableau
Set Variable Définir la variable
Set View Définir la vue
@@ -1014,6 +1015,34 @@
Check for Updates… Rechercher des mises à jour…
CADCraft is up to date. CADCraft est à jour.
Could not check for updates. Impossible de rechercher les mises à jour.
Add a drawing file as a block library Ajouter un fichier de dessin comme bibliothèque de blocs
Add a folder of drawings or a drawing file to use its blocks. Ajoutez un dossier de dessins ou un fichier de dessin pour utiliser ses blocs.
Block Libraries Bibliothèques de blocs
Block Library Bibliothèque de blocs
Blocks Palette Palette des blocs
Click a block, then pick its insertion point. Cliquez sur un bloc, puis indiquez son point d'insertion.
Current Drawing Dessin courant
Details Détails
Extra Large Icons Très grandes icônes
Folder or file Dossier ou fichier
Import Library Block Importer un bloc de bibliothèque
Insert and Explode Insérer et décomposer
Large Icons Grandes icônes
Libraries Bibliothèques
Medium Icons Icônes moyennes
No block matches the filter. Aucun bloc ne correspond au filtre.
This block is already in the drawing, so its definition is used. Ce bloc est déjà dans le dessin ; sa définition est utilisée.
Open Library... Ouvrir une bibliothèque...
Read the library again Relire la bibliothèque
Reading the library... Lecture de la bibliothèque...
Refresh Actualiser
Remove from the list Retirer de la liste
Repeat Placement Répéter le placement
Small Icons Petites icônes
This drawing has no blocks. Ce dessin ne contient aucun bloc.
This library has no drawings or blocks. Cette bibliothèque ne contient ni dessin ni bloc.
Options Options
Only the first {n} are shown. Seuls les {n} premiers sont affichés.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft French interface catalog — original translations by @pechnikov2026-star.
723
724
725
726
727
728
729
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
+27
View File
@@ -1346,6 +1346,33 @@ menu View Nézet
Check for Updates… Frissítések keresése…
CADCraft is up to date. A CADCraft naprakész.
Could not check for updates. A frissítések keresése nem sikerült.
Add a drawing file as a block library Rajzfájl hozzáadása blokkkönyvtárként
Add a folder of drawings or a drawing file to use its blocks. Adj hozzá egy rajzokat tartalmazó mappát vagy egy rajzfájlt, hogy használhasd a blokkjait.
Block Libraries Blokkkönyvtárak
Block Library Blokkkönyvtár
Blocks Palette Blokkpaletta
Click a block, then pick its insertion point. Kattints egy blokkra, majd add meg a beszúrási pontját.
Current Drawing Aktuális rajz
Details Részletek
Extra Large Icons Extra nagy ikonok
Folder or file Mappa vagy fájl
Import Library Block Könyvtárblokk importálása
Insert and Explode Beszúrás és szétbontás
Large Icons Nagy ikonok
Libraries Könyvtárak
Medium Icons Közepes ikonok
No block matches the filter. Egy blokk sem felel meg a szűrőnek.
This block is already in the drawing, so its definition is used. Ez a blokk már szerepel a rajzban, ezért a meglévő definícióját használjuk.
Open Library... Könyvtár megnyitása...
Read the library again Könyvtár újraolvasása
Reading the library... Könyvtár olvasása...
Refresh Frissítés
Remove from the list Eltávolítás a listáról
Repeat Placement Elhelyezés ismétlése
Small Icons Kis ikonok
This drawing has no blocks. Ez a rajz nem tartalmaz blokkokat.
This library has no drawings or blocks. Ez a könyvtár nem tartalmaz rajzokat vagy blokkokat.
Only the first {n} are shown. Csak az első {n} látható.
Find All Find All
Find what: Find what:
Match case Match case
Can't render this file because it contains an unexpected character in line 16 and column 72.
+28
View File
@@ -847,6 +847,7 @@ menu Modify Edita
Set Current Viewport Imposta finestra corrente
Set Layer Properties Imposta proprietà layer
Set Properties Imposta proprietà
Describe Properties Descrivi proprietà
Set Table Cell Imposta cella tabella
Set Table Cell Style Imposta stile cella tabella
Set Variable Imposta variabile
@@ -1366,6 +1367,33 @@ menu Modify Edita
Check for Updates… Verifica aggiornamenti…
CADCraft is up to date. CADCraft è aggiornato.
Could not check for updates. Impossibile verificare gli aggiornamenti.
Add a drawing file as a block library Aggiungi un file di disegno come libreria di blocchi
Add a folder of drawings or a drawing file to use its blocks. Aggiungi una cartella di disegni o un file di disegno per usarne i blocchi.
Block Libraries Librerie di blocchi
Block Library Libreria di blocchi
Blocks Palette Tavolozza blocchi
Click a block, then pick its insertion point. Fai clic su un blocco, quindi indica il punto di inserimento.
Current Drawing Disegno corrente
Details Dettagli
Extra Large Icons Icone molto grandi
Folder or file Cartella o file
Import Library Block Importa blocco da libreria
Insert and Explode Inserisci ed esplodi
Large Icons Icone grandi
Libraries Librerie
Medium Icons Icone medie
No block matches the filter. Nessun blocco corrisponde al filtro.
This block is already in the drawing, so its definition is used. Questo blocco è già nel disegno, quindi viene usata la sua definizione.
Open Library... Apri libreria...
Read the library again Rileggi la libreria
Reading the library... Lettura della libreria...
Refresh Aggiorna
Remove from the list Rimuovi dall'elenco
Repeat Placement Ripeti posizionamento
Small Icons Icone piccole
This drawing has no blocks. Questo disegno non contiene blocchi.
This library has no drawings or blocks. Questa libreria non contiene disegni o blocchi.
Only the first {n} are shown. Vengono mostrati solo i primi {n}.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft Italian interface catalog — original translations by Emanuele Bottelli (AI-assisted, Claude).
847
848
849
850
851
852
853
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
+27
View File
@@ -1472,6 +1472,33 @@ menu View ხედი
Text to find მოსაძებნი ტექსტი
Whole words მთლიანი სიტყვები
Nothing found ვერაფერი მოიძებნა
Add a drawing file as a block library ნახაზის ფაილის დამატება ბლოკების ბიბლიოთეკად
Add a folder of drawings or a drawing file to use its blocks. დაამატეთ ნახაზების საქაღალდე ან ნახაზის ფაილი მისი ბლოკების გამოსაყენებლად.
Block Libraries ბლოკების ბიბლიოთეკები
Block Library ბლოკების ბიბლიოთეკა
Blocks Palette ბლოკების პალიტრა
Click a block, then pick its insertion point. დაწკაპეთ ბლოკზე, შემდეგ მიუთითეთ მისი ჩასმის წერტილი.
Current Drawing მიმდინარე ნახაზი
Details დეტალები
Extra Large Icons ძალიან დიდი ხატულები
Folder or file საქაღალდე ან ფაილი
Import Library Block ბიბლიოთეკის ბლოკის იმპორტი
Insert and Explode ჩასმა და დაშლა
Large Icons დიდი ხატულები
Libraries ბიბლიოთეკები
Medium Icons საშუალო ხატულები
No block matches the filter. ფილტრს არც ერთი ბლოკი არ შეესაბამება.
This block is already in the drawing, so its definition is used. ეს ბლოკი ნახაზში უკვე არის, ამიტომ გამოიყენება მისი განსაზღვრება.
Open Library... ბიბლიოთეკის გახსნა...
Read the library again ბიბლიოთეკის თავიდან წაკითხვა
Reading the library... ბიბლიოთეკა იკითხება...
Refresh განახლება
Remove from the list სიიდან მოცილება
Repeat Placement განთავსების გამეორება
Small Icons პატარა ხატულები
This drawing has no blocks. ამ ნახაზში ბლოკები არ არის.
This library has no drawings or blocks. ამ ბიბლიოთეკაში ნახაზები ან ბლოკები არ არის.
Only the first {n} are shown. ნაჩვენებია მხოლოდ პირველი {n}.
# ArtCraft feature naming
Additional Tools დამატებითი ხელსაწყოები
Can't render this file because it contains an unexpected character in line 10 and column 14.
+28
View File
@@ -837,6 +837,7 @@
Set Current Viewport 현재 뷰포트 설정
Set Layer Properties 도면층 특성 설정
Set Properties 특성 설정
Describe Properties 특성 설명
Set Table Cell 표 셀 설정
Set Table Cell Style 표 셀 스타일 설정
Set Variable 변수 설정
@@ -1244,6 +1245,33 @@ menu Modify 수정
Check for Updates… 업데이트 확인…
CADCraft is up to date. CADCraft가 최신 버전입니다.
Could not check for updates. 업데이트를 확인하지 못했습니다.
Add a drawing file as a block library 도면 파일을 블록 라이브러리로 추가
Add a folder of drawings or a drawing file to use its blocks. 블록을 사용하려면 도면이 들어 있는 폴더나 도면 파일을 추가하세요.
Block Libraries 블록 라이브러리
Block Library 블록 라이브러리
Blocks Palette 블록 팔레트
Click a block, then pick its insertion point. 블록을 클릭한 다음 삽입점을 지정하세요.
Current Drawing 현재 도면
Details 자세히
Extra Large Icons 매우 큰 아이콘
Folder or file 폴더 또는 파일
Import Library Block 라이브러리 블록 가져오기
Insert and Explode 삽입 후 분해
Large Icons 큰 아이콘
Libraries 라이브러리
Medium Icons 보통 아이콘
No block matches the filter. 필터와 일치하는 블록이 없습니다.
This block is already in the drawing, so its definition is used. 이 블록은 이미 도면에 있으므로 기존 정의를 사용합니다.
Open Library... 라이브러리 열기...
Read the library again 라이브러리 다시 읽기
Reading the library... 라이브러리를 읽는 중...
Refresh 새로 고침
Remove from the list 목록에서 제거
Repeat Placement 배치 반복
Small Icons 작은 아이콘
This drawing has no blocks. 이 도면에는 블록이 없습니다.
This library has no drawings or blocks. 이 라이브러리에는 도면이나 블록이 없습니다.
Only the first {n} are shown. 처음 {n}개만 표시됩니다.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft Korean interface catalog — original Korean translations.
837
838
839
840
841
842
843
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
+28
View File
@@ -928,6 +928,7 @@
Set Current Text Style Definir estilo de texto atual
Set Layer Properties Definir propriedades da camada
Set Properties Definir propriedades
Describe Properties Descrever propriedades
Set Table Cell Definir célula da tabela
Set Variable Definir variável
Set View Definir vista
@@ -1253,6 +1254,33 @@
Check for Updates… Verificar atualizações…
CADCraft is up to date. O CADCraft está atualizado.
Could not check for updates. Não foi possível verificar atualizações.
Add a drawing file as a block library Adicionar um arquivo de desenho como biblioteca de blocos
Add a folder of drawings or a drawing file to use its blocks. Adicione uma pasta de desenhos ou um arquivo de desenho para usar seus blocos.
Block Libraries Bibliotecas de blocos
Block Library Biblioteca de blocos
Blocks Palette Paleta de blocos
Click a block, then pick its insertion point. Clique em um bloco e depois indique o ponto de inserção.
Current Drawing Desenho atual
Details Detalhes
Extra Large Icons Ícones extragrandes
Folder or file Pasta ou arquivo
Import Library Block Importar bloco da biblioteca
Insert and Explode Inserir e explodir
Large Icons Ícones grandes
Libraries Bibliotecas
Medium Icons Ícones médios
No block matches the filter. Nenhum bloco corresponde ao filtro.
This block is already in the drawing, so its definition is used. Este bloco já está no desenho, então sua definição é usada.
Open Library... Abrir biblioteca...
Read the library again Ler a biblioteca novamente
Reading the library... Lendo a biblioteca...
Refresh Atualizar
Remove from the list Remover da lista
Repeat Placement Repetir posicionamento
Small Icons Ícones pequenos
This drawing has no blocks. Este desenho não tem blocos.
This library has no drawings or blocks. Esta biblioteca não tem desenhos nem blocos.
Only the first {n} are shown. Apenas os primeiros {n} são exibidos.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft Brazilian Portuguese (pt-BR) interface catalog.
928
929
930
931
932
933
934
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
+29
View File
@@ -723,6 +723,7 @@
Set Current Text Style Сделать текстовый стиль текущим
Set Layer Properties Задать свойства слоя
Set Properties Задать свойства
Describe Properties Описать свойства
Set Table Cell Задать ячейку таблицы
Set Variable Задать переменную
Set View Задать вид
@@ -1015,6 +1016,34 @@
Check for Updates… Проверить обновления…
CADCraft is up to date. У вас последняя версия CADCraft.
Could not check for updates. Не удалось проверить обновления.
Add a drawing file as a block library Добавить файл чертежа как библиотеку блоков
Add a folder of drawings or a drawing file to use its blocks. Добавьте папку с чертежами или файл чертежа, чтобы использовать его блоки.
Block Libraries Библиотеки блоков
Block Library Библиотека блоков
Blocks Palette Палитра блоков
Click a block, then pick its insertion point. Щелкните блок, затем укажите точку вставки.
Current Drawing Текущий чертеж
Details Подробно
Extra Large Icons Огромные значки
Folder or file Папка или файл
Import Library Block Импортировать блок из библиотеки
Insert and Explode Вставить и расчленить
Large Icons Крупные значки
Libraries Библиотеки
Medium Icons Обычные значки
No block matches the filter. Нет блоков, соответствующих фильтру.
This block is already in the drawing, so its definition is used. Этот блок уже есть в чертеже, поэтому используется его определение.
Open Library... Открыть библиотеку...
Read the library again Прочитать библиотеку заново
Reading the library... Чтение библиотеки...
Refresh Обновить
Remove from the list Убрать из списка
Repeat Placement Повторять размещение
Small Icons Мелкие значки
This drawing has no blocks. В этом чертеже нет блоков.
This library has no drawings or blocks. В этой библиотеке нет чертежей и блоков.
Options Параметры
Only the first {n} are shown. Показаны только первые {n}.
Find All Find All
Find what: Find what:
Match case Match case
1 # CADCraft Russian interface catalog — original translations by @pechnikov2026-star.
723
724
725
726
727
728
729
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049

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