Compare commits

..
31 Commits
Author SHA1 Message Date
Tanish Manku e1a048ba42 Stack d1: #2152: -ATTEDIT Position keeps aligned and fit text's baseline
Position set both points of a justified attribute to the pick, which left
aligned and fit text no direction or length. Both points now move by the
same offset, from the point the text is placed by.
2026-11-19 15:14:28 -07:00
Tanish Manku b713869cec Stack d1: #2368: put first_center's doc comment back on it 2026-11-19 15:14:28 -07:00
Tanish Manku bdc0c7b2a7 Stack d1: #2368: ARRAYEDIT puts a center given with a new base point where asked
center was read in the array's placement from before base or keyPoint moved
its insertion point, so the centre landed off by that move.
2026-11-19 15:14:28 -07:00
Tanish Manku bd7d94c8ea Stack d1: #2368: refuse a key point search over more than 10,000 objects
The search took the first 10,000 objects and could miss a nearer key point
on a later one; now it says so and asks for a point.
2026-11-19 15:14:28 -07:00
Tanish Manku c6e80bea8f Stack d1: #2368: refuse a keyPoint that isn't a point
A keyPoint that couldn't be read was taken as none, so ARRAYRECT,
ARRAYPOLAR and ARRAYEDIT went on with another base point.
2026-11-19 15:14:28 -07:00
Alex Ortiz 22226a08ad -ATTEDIT: Position, Height, Angle and Style one at a time (#2152)
The -ATTEDIT part of 6a86919f from #2152; its -RENAME VPort part is left
out for #2907.
2026-11-19 14:48:28 -07:00
Tanish Manku 7060a86ea6 Merge #2368: Array base points: the Key point option in ARRAYRECT, ARRAYPOLAR and ARRAYEDIT (F5) 2026-11-19 14:47:28 -07:00
Tanish Manku c4fd42bc0b Merge #2915: -LAYER stAte: save, restore, edit, rename, delete and list layer states 2026-11-19 14:46:56 -07:00
Tanish Manku 75e737e2f3 Merge #2907: -RENAME: viewport configurations, and AutoCAD's messages 2026-11-19 14:46:17 -07:00
2ez4gcxandClaude Opus 5.5 685e364381 Prompt: declare NO_OR as a slice; test the states prompt's text
This PR and #2726 each add a prompt to NO_OR and raise its array length
from 28 to 29, so with both merged the array holds 30 entries under a
length of 29 (E0308), whichever lands first. A slice has no length to
keep in step; both PRs make the same change to this line.

No test noticed "Enter states to change" missing from NO_OR, so the Esc
test now checks the toggles prompt as AutoCAD 2024 writes it, without
"or" before the keywords.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 09:29:04 +07:00
2ez4gcxandClaude Opus 5.5 2f3368f400 Merge feat/acad-layer-states, now with main fbb08380
Brings in #2910's merge of main fbb08380, which also changes that branch's
layer state reader and writer to import Tag from craft_dxf (main #3040
replaced cadcraft-dxf with craft-dxf). This merge is clean: the tree is
#2910's plus exactly this branch's own changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 11:34:01 +07:00
2ez4gcxandClaude Opus 5.5 1a918ff740 Merge main into feat/acad-layer-states
Brings the branch up to main fbb08380. The merge has no conflicts, but
since #3040 the DXF tag crate is craft-dxf from craft-libs, so the layer
state reader and writer this branch adds imports Tag from craft_dxf
instead of the removed cadcraft_dxf. Without that the merged crate doesn't
compile.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 11:08:27 +07:00
2ez4gcxandClaude Opus 5.5 7616ff63ea Merge main into fix/rename-vport-messages
Brings the branch up to main 6d744887, which has #2954's fix for
mtext::tests::strips_formatting, so the gate runs on a main that passes.
No conflicts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 14:06:45 +07:00
2ez4gcxandClaude Opus 5.5 9def40d174 Merge feat/acad-layer-states, now with main
Brings in #2910's merge of main 6d744887 (with #2954's fix for
mtext::tests::strips_formatting), whose dxf_raw.rs conflict is resolved
there. This merge is clean: the tree is #2910's plus exactly this branch's
own changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 11:58:51 +07:00
2ez4gcxandClaude Opus 5.5 8f039dc3fa Merge main into feat/acad-layer-states
Brings the branch up to main 6d744887, which has #2954's fix for
mtext::tests::strips_formatting. The one conflict is in
crates/io/src/dxf_raw.rs: main moved the extension-dictionary liveness test
inside its hard-owner settle passes, and this branch keeps a merged LAYER
extension dictionary's objects live there. The check now sits inside main's
closure, unchanged otherwise.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 11:22:48 +07:00
2ez4gcxandClaude Opus 5.5 2206a861f2 Merge #2910's case-folded layer state entries; fix a test comment
Brings in feat/acad-layer-states: entries of AutoCAD's dictionary whose
names differ only in case are read as one state, as AutoCAD 2024 opens them.
The JSON lookup test's comment now says where two such names can come from:
CADCraft's own record keeps the second, which AutoCAD doesn't see.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 08:31:28 +07:00
2ez4gcxandClaude Opus 5.5 cd9f8b1dd3 Layer states: entries in another case are one state, as in AutoCAD 2024
AutoCAD 2024 opens the entries S and s of one ACAD_LAYERSTATES dictionary as
a single state, named as the first entry in the dictionary and holding the
last entry's record (measured with both dictionary orders). The reader kept
two states, so a save moved the second to CADCraft's record and AutoCAD then
restored the other record than before. It now reads them as AutoCAD does;
CADCraft's own record still keeps a second spelling it wrote itself.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 08:20:19 +07:00
2ez4gcxandClaude Opus 5.5 b3fbfa0a3c Merge #2910's layer state reader bound; layerstate.save checks names
Brings in feat/acad-layer-states (b9d74f8f): a state holds each layer once,
a repeated entry applying over the earlier one, and copies of layers into
states share a per-file budget.

After review: the JSON layerstate.save refuses a name valid_name refuses
(empty, over 255 characters, a control character or one AutoCAD refuses),
as -LAYER stAte Save and layerstate.rename already did.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 04:32:56 +07:00
2ez4gcxandClaude Opus 5.5 10aa4e18f7 -RENAME VPort tests: *Invalid*, Enter, and the JSON form's refusals
After review: the viewport configuration test checks that "*Invalid*"
follows only a name already used, that Enter as the new name is refused,
the measured cfg1 typed for CFG1 to cfg1 row (it was run without an
assertion), and the JSON form's refusal of a name already used or invalid
and its case-only rename.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 03:53:36 +07:00
2ez4gcxandClaude Opus 5.5 b9d74f8feb Layer states: each layer once per state, and a bound on copied layers
Each entry of a state copied the drawing's layer, so a small file naming one
layer with a long description in many entries could take gigabytes. A state
now holds each LAYER handle once; a repeated entry applies over the earlier
one, which gives what restoring both in turn did, and AutoCAD 2024 restores
the later of two full entries (measured). New copies are charged to one
per-file budget of 256 MiB, as image-definition strings are; past it the
remaining entries are left out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 03:53:09 +07:00
2ez4gcxandClaude Opus 5.5 2cb1fcd060 Layer states: layerstate.save replaces only the state the lookups reach
f8be7d83 replaced every state whose name matched without regard to case,
so in a file holding both M2 and m2 (one AutoCAD 2024 opens), saving m2
dropped M2 too. Save now replaces the state Restore and Delete reach (the
same spelling, else another case) and leaves the other one, as AutoCAD,
which refuses the save, leaves both.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 00:14:05 +07:00
2ez4gcxandClaude Opus 5.5 f8be7d8339 Layer states: layerstate.save replaces a state named in another case
This PR makes layerstate.restore, rename and delete find a state's name
without regard to case, as AutoCAD 2024 does, but layerstate.save still
replaced only a state of the same spelling, so saving s1 next to S1 made
a second state that the lookups then had to choose between. AutoCAD
keeps one state per name in any case: its -LAYER stAte Save and
layerstate-save refuse s1 after S1 and keep S1 (measured; layerstate-has
"s1" is T). -LAYER stAte Save here already refuses; the JSON command now
replaces a state whose name differs only in case, as it replaces one of
the same spelling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 22:47:03 +07:00
2ez4gcxandClaude Opus 5.5 60fc6e7b40 Merge feat/acad-layer-states: a frozen current layer without an entry stays frozen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 12:43:25 +07:00
2ez4gcxandClaude Opus 5.5 38cab40e46 Layer state restore: a frozen current layer without an entry stays frozen
A state whose current layer (302) is frozen in the drawing made it current
whenever the mask had Frozen, even with no entry of its own to thaw it,
leaving a frozen current layer. AutoCAD 2024 keeps the current layer then
(measured: 302 = frozen B, mask 2047, no entry for B, A current -> A stays
current, B stays frozen, the other entries are restored; with an entry B
becomes current and thaws). It now takes Frozen in the mask and an entry
for that layer, matched without case as the per-layer restore matches.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 12:09:52 +07:00
2ez4gcxandClaude Opus 5.5 7997db2fd0 Merge feat/acad-layer-states: the layer state tests added for review on #2910
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 11:07:04 +07:00
2ez4gcxandClaude Opus 5.5 bcb6d6ac51 Layer states: tests for each mask bit, old records, the limit and dangling entries
- Restore: one state per remaining mask bit (Plot, VP freeze new, Linetype,
  Lineweight, Plot style, Transparency) restores only its property.
- A state of CADCraft's own record from before masks (JSON with only the
  name and the layers) reads as mask 2047, no current layer, no description.
- 100 001 states in AutoCAD's dictionary: the last one in the file is left
  out and the others come in file order.
- The LAYER table's kept extension dictionary with entries pointing at a
  handle of nothing and at 0: neither is written.
- States named "" and " " stay in CADCraft's record.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 10:36:45 +07:00
2ez4gcxandClaude Opus 5.5 50555a9110 -LAYER stAte: save, restore, edit, rename, delete and list layer states
-LAYER stAte printed "not available yet". It now runs the layer state
options with AutoCAD 2024's prompts and messages (measured with
accoreconsole): Save lists the ten "Enter states to change" toggles and
remembers them for the next Save; Edit sets a state's own mask and keeps
bits no toggle reaches; Name and Save refuse names a state has in any
case and the characters layer names refuse; unknown names re-prompt;
`?` lists names without regard to case. Import and EXport stay "not
available yet".

The layerstate.* commands find names as spelled, else in another case,
and layerstate.save takes an optional mask.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 04:03:26 +07:00
2ez4gcxandClaude Opus 5.5 5420dea6c1 -RENAME: compare the new name with the stored one; refuse layer 0 and Continuous
The old name is now kept as the drawing spells it, so a new name in another
case than that is a rename even when it is the old name as typed: AutoCAD 2024
renames viewport configuration CFG1 typed cfg1 to cfg1, and leaves it for
cfg1 to CFG1 (measured; the same for layers).

At the old-name prompt AutoCAD 2024 ends the command on names it won't
rename (measured): layer 0 and linetype Continuous ("Cannot rename ..." and
*Invalid*), linetypes ByLayer and ByBlock and block names starting with "*"
such as *Model_Space or an anonymous *U0 ("Invalid ... name.").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 00:13:16 +07:00
2ez4gcxandClaude Opus 5.5 9ed3607b72 DXF/DWG: layer states in AutoCAD's form, restored by mask and current layer
CADCraft kept saved layer states only in its own CADCRAFT_LAYERSTATES record,
so AutoCAD 2024 listed none of them ("Unknown layer state name.") and
CADCraft read none of AutoCAD's ACAD_LAYERSTATES ("No saved layer states.").

States now go into the LAYER table's extension dictionary, ACAD_LAYERSTATES,
one XRECORD each, in the layout AutoCAD 2024 writes (measured): mask, current
layer, and per layer its handle, flags, colour (92 for a true colour),
lineweight, linetype, plot style (Color_N, or the placeholder handle with
named plot styles), transparency, and 93 on an xref's layer. View layer
snapshots and names repeated in another case stay in CADCraft's record.
Reading takes AutoCAD's states, then CADCraft's own. A kept LAYER table
dictionary (layer filters) joins the one written for the states.

layerstate.restore now does what AutoCAD does: the state's current layer
first (unless left frozen), only the masked properties, never freezing the
current layer; layerstate.save records the current layer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 23:47:19 +07:00
2ez4gcxandClaude Opus 5.5 38f51899fc -RENAME: viewport configurations, and AutoCAD's messages
-RENAME's VPort option printed "not available yet". It now renames a saved
viewport configuration, every tile of it (never *Active), as AutoCAD 2024
does; the JSON form takes table "vport".

-RENAME also answers a name it can't take as AutoCAD 2024 does (measured
for blocks, dimension styles, layers, linetypes, text styles, UCSs, views
and viewport configurations), ending the command instead of asking again:
"Cannot find layer "X".", "A layer named "X" already exists." then
"*Invalid*", "Invalid layer name." (also for no name at all). A UCS is
"ucs" in the prompts and in "A ucs named", "UCS" in the other two.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 21:38:04 +07:00
Francesco BVandClaude Opus 5.5 b600293cfa arrays: the Key point option of a base point (F5)
ARRAYRECT, ARRAYPOLAR and ARRAYEDIT (Base point and REPlace) offered Key
point but only said it was not available. It now asks for a key point on
the source (or replacement) objects and takes their key point nearest the
pick (an end point, midpoint, centre, quadrant, vertex or insertion point)
as the base point; in ARRAYEDIT the source objects are searched as placed
at the item picked. The JSON forms take `keyPoint`.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-27 22:42:36 +01:00
49 changed files with 2758 additions and 1324 deletions
-5
View File
@@ -128,8 +128,3 @@ sync_github_name = true
[people.tyrel]
real_name = "Tyrel Haveman"
[people.Sladrian]
real_name = "Sladrian Pedroso"
display_name = "Sladrian Pedroso"
sync_github_name = false
+39 -1
View File
@@ -931,11 +931,49 @@ pub struct Ucs {
pub y_axis: Vec3,
}
/// A saved layer state (LAYERSTATE).
/// A saved layer state (LAYERSTATE), as AutoCAD keeps one in the LAYER table's
/// `ACAD_LAYERSTATES` dictionary.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct LayerState {
pub name: String,
pub layers: Vec<Layer>,
/// The properties restoring sets ([`LayerState::ON`] …): AutoCAD's mask (group 91 of the
/// state's XRECORD). Bits CADCraft doesn't use are kept as read.
pub mask: u32,
/// The layer restoring makes current; empty, or a layer the drawing doesn't have, leaves the
/// current layer as it is (AutoCAD 2024, measured).
pub current: String,
/// Group 301 of the state's XRECORD: empty as AutoCAD 2024's -LAYER saves a state; a text a
/// file holds there is kept.
pub description: String,
}
impl Default for LayerState {
fn default() -> Self {
LayerState { name: String::new(), layers: Vec::new(), mask: LayerState::ALL, current: String::new(), description: String::new() }
}
}
impl LayerState {
pub const ON: u32 = 1;
pub const FROZEN: u32 = 2;
pub const LOCKED: u32 = 4;
pub const PLOT: u32 = 8;
pub const VP_FREEZE_NEW: u32 = 16;
pub const COLOR: u32 = 32;
pub const LINETYPE: u32 = 64;
pub const LINEWEIGHT: u32 = 128;
pub const PLOT_STYLE: u32 = 256;
pub const TRANSPARENCY: u32 = 1024;
/// Every property: the mask of AutoCAD 2024's -LAYER stAte Save with its defaults (2047; bit
/// 512, which no property toggles, is always set).
pub const ALL: u32 = 2047;
/// A state of every property of `layers`, with `current` the layer restoring makes current.
pub fn new(name: impl Into<String>, layers: Vec<Layer>, current: impl Into<String>) -> Self {
LayerState { name: name.into(), layers, current: current.into(), ..LayerState::default() }
}
}
/// A named group of entities (GROUP).
+72 -12
View File
@@ -27,6 +27,10 @@ mod edit;
/// Most preview entities drawn while the array is edited.
const PREVIEW_LIMIT: usize = 2000;
/// Most objects whose key points are searched for a Key point base point.
const MAX_KEY_OBJECTS: usize = 10_000;
/// The prompt after the Key point option of a base point.
const KEY_POINT_PROMPT: &str = "Specify key point on source objects to use as base point";
/// Keyword-only prompts: each typed token is matched on its own (no free text).
const KEYWORDS: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
@@ -41,13 +45,13 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("arrayrect", "Rectangular Array", run_arrayrect)
.menu(&["Modify", "Array", "Rectangular Array"])
.params(
"{handles?, rows, cols, rowSpacing, colSpacing, levels? (1), levelSpacing?, rowElevation?, axisAngle? (degrees), base? ([x, y], default the objects' centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
"{handles?, rows, cols, rowSpacing, colSpacing, levels? (1), levelSpacing?, rowElevation?, axisAngle? (degrees), base? ([x, y], default the objects' centre), keyPoint? ([x, y]: the base point is the objects' key point nearest it), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
)
.interactive(|_| Ok(Box::new(RectM::default()))),
CommandSpec::new("arraypolar", "Polar Array", run_arraypolar)
.menu(&["Modify", "Array", "Polar Array"])
.params(
"{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
"{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), keyPoint? ([x, y]: the base point is the objects' key point nearest it), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
)
.interactive(|_| Ok(Box::new(PolarM::default()))),
CommandSpec::new("-array", "Array", classic::run_classic)
@@ -246,6 +250,45 @@ fn bounds(d: &Drawing, hs: &[Handle]) -> Bounds2 {
hs.iter().filter_map(|h| d.entity(*h).map(|e| cadcraft_doc::entity_bounds(d, e, 0))).fold(Bounds2::EMPTY, |a, b| a.union(&b))
}
/// The key point of `ents`, placed by `m`, nearest `at`: one of their grips (end points,
/// midpoints, centres, vertices, insertion points). `None` when they have none. More than
/// [`MAX_KEY_OBJECTS`] objects are refused: searching only some could miss the nearest one.
pub(crate) fn nearest_key_point<'a>(ents: impl Iterator<Item = &'a Entity>, m: &Mat3, at: Vec2) -> Result<Option<Vec2>> {
if !at.is_finite() {
return Ok(None);
}
let mut best: Option<(Vec2, f64)> = None;
for (n, e) in ents.enumerate() {
if n >= MAX_KEY_OBJECTS {
return Err(other(format!("Too many objects to search for a key point (at most {MAX_KEY_OBJECTS}); specify a point.")));
}
let mut k = e.kind.clone();
k.transform(m);
for g in k.grips().into_iter().filter(|g| g.is_finite()) {
let d = g.dist(at);
if best.is_none_or(|(_, bd)| d < bd) {
best = Some((g, d));
}
}
}
Ok(best.map(|b| b.0))
}
/// `keyPoint` of a JSON form: absent or null is none; anything else must be a point, rather than
/// be taken as none and the base point found another way.
pub(crate) fn key_point_param(cmd: &str, p: &Value) -> Result<Option<Vec2>> {
match p.get("keyPoint") {
None | Some(Value::Null) => Ok(None),
Some(_) => point_param(p, "keyPoint").map(Some).ok_or_else(|| bad(cmd, "`keyPoint` must be a point [x, y]")),
}
}
/// The key point of objects `hs` in the drawing nearest `at`.
pub(crate) fn key_point_of(d: &Drawing, hs: &[Handle], at: Vec2) -> Result<Vec2> {
nearest_key_point(hs.iter().filter_map(|h| d.entity(*h)).map(|e| &**e), &Mat3::IDENTITY, at)?
.ok_or_else(|| other("The objects have no key point; specify a point."))
}
/// The centre of the first object (the point a non-rotated polar copy is moved by).
fn first_center(d: &Drawing, hs: &[Handle]) -> Option<Vec2> {
hs.first().and_then(|h| d.entity(*h)).map(|e| cadcraft_doc::entity_bounds(d, e, 0).center()).filter(|c| c.is_finite())
@@ -386,9 +429,10 @@ fn run_arrayrect(s: &mut Session, p: &Value) -> Result<Value> {
row_elevation: f64_or(p, "rowElevation", 0.0),
});
let rs = f64_or(p, "rowSpacing", 1.0);
let base = match point_param(p, "base") {
Some(b) => b,
None => Some(bounds(s.doc()?, &hs).center()).filter(|c| c.is_finite()).unwrap_or_default(),
let base = match (key_point_param("arrayrect", p)?, point_param(p, "base")) {
(Some(k), _) => key_point_of(s.doc()?, &hs, k)?,
(None, Some(b)) => b,
(None, None) => Some(bounds(s.doc()?, &hs).center()).filter(|c| c.is_finite()).unwrap_or_default(),
};
let p2 = params(kind, levels, f64_or(p, "levelSpacing", rs));
let associative = bool_or(p, "associative", assoc_default(s));
@@ -402,7 +446,10 @@ fn run_arraypolar(s: &mut Session, p: &Value) -> Result<Value> {
let rows = count_or("arraypolar", p, "rows", 1)?;
let levels = count_or("arraypolar", p, "levels", 1)?;
check_size(s, n.saturating_mul(rows).saturating_mul(levels), hs.len())?;
let base = point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c);
let base = match key_point_param("arraypolar", p)? {
Some(k) => key_point_of(s.doc()?, &hs, k)?,
None => point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c),
};
let row_spacing = f64_or(p, "rowSpacing", 1.0);
let fill = f64_or(p, "angle", 360.0);
if !(fill.abs() >= 1e-9 && fill.abs() <= 360.0 + 1e-9) {
@@ -503,6 +550,8 @@ enum RStage {
Main,
Assoc,
Base,
/// Base point: Key point (a grip of the source objects).
BaseKey,
/// COUnt: columns, then rows.
CountCols,
CountRows,
@@ -663,6 +712,7 @@ impl Interactive for RectM {
.default("eXit"),
Assoc => assoc_prompt(self.assoc),
Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
CountCols | ColsCount => cols(),
CountRows | RowsCount => rows(),
SpaceCols => dist("Specify the distance between columns", self.cs).kw(&["Unit cell"]),
@@ -712,10 +762,12 @@ impl Interactive for RectM {
self.base = self.centroid;
Main
}
(Base, Input::Keyword(_)) => {
s.echo("Key points are not available yet; specify a point.");
Base
(Base, Input::Keyword(_)) => BaseKey,
(BaseKey, Input::Point(p)) => {
self.base = key_point_of(s.doc()?, &self.objs, *p)?;
Main
}
(BaseKey, Input::Enter) => Base,
(CountCols | ColsCount, _) => match count(&i, self.cols, max_count(s, self.rows.saturating_mul(self.levels), n))? {
Some(c) => {
self.cols = c;
@@ -858,6 +910,9 @@ enum PStage {
Main,
Assoc,
Base,
/// Key point of the base point asked from the center prompt, or from the main prompt.
CenterBaseKey,
BaseKey,
Items,
Between,
Fill,
@@ -1034,6 +1089,7 @@ impl Interactive for PolarM {
match self.stage {
Center => Prompt::new("Specify center point of array", Accept::POINT).kw(&["Base point", "Axis of rotation"]),
CenterBase | Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
CenterBaseKey | BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
Main => Prompt::new("Select grip to edit array", Accept::POINT)
.kw(&["ASsociative", "Base point", "Items", "Angle between", "Fill angle", "ROWs", "Levels", "ROTate items", "eXit"])
.default("eXit"),
@@ -1092,10 +1148,14 @@ impl Interactive for PolarM {
self.base = None;
if stage == CenterBase { Center } else { Main }
}
(CenterBase | Base, Input::Keyword(_)) => {
s.echo("Key points are not available yet; specify a point.");
stage
(CenterBase, Input::Keyword(_)) => CenterBaseKey,
(Base, Input::Keyword(_)) => BaseKey,
(CenterBaseKey | BaseKey, Input::Point(p)) => {
self.base = Some(key_point_of(s.doc()?, &self.objs, *p)?);
if stage == CenterBaseKey { Center } else { Main }
}
(CenterBaseKey, Input::Enter) => CenterBase,
(BaseKey, Input::Enter) => Base,
(Items, _) => match count(&i, self.items, max_count(s, self.rows.saturating_mul(self.levels), n))? {
Some(c) => {
self.items = c;
+49 -10
View File
@@ -18,7 +18,9 @@ use super::super::helpers::v3;
use super::super::machines::{SelOutcome, SelectPhase, number};
use super::super::{CommandSpec, bad, bool_or, point_param, targets};
use super::{KEYWORDS, angle, check_size, count, fmt, nesting, other, yes, yes_no};
use super::{
KEY_POINT_PROMPT, KEYWORDS, angle, check_size, count, fmt, key_point_of, key_point_param, nearest_key_point, nesting, other, yes, yes_no,
};
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
pub(super) fn specs() -> Vec<CommandSpec> {
@@ -26,7 +28,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
CommandSpec::new("arrayedit", "Edit Array", run_arrayedit)
.menu(&["Modify", "Object", "Array"])
.params(
"{handle, cols?, rows?, colSpacing?, rowSpacing?, axisAngle? (degrees), rowElevation?, levels?, levelSpacing?, items?, angle? (fill, degrees), angleBetween?, rotate?: bool, center? ([x, y]), base? ([x, y], the new base point), reset?: bool, replace?: {handles, base? ([x, y], default the objects' centre), items: [[i, j, level]…] | \"source\"}, source?: {item? ([i, j, level], default [0, 0, 0])} (places the source objects for editing; ARRAYCLOSE ends)}",
"{handle, cols?, rows?, colSpacing?, rowSpacing?, axisAngle? (degrees), rowElevation?, levels?, levelSpacing?, items?, angle? (fill, degrees), angleBetween?, rotate?: bool, center? ([x, y]), base? ([x, y], the new base point), reset?: bool, replace?: {handles, base? ([x, y], default the objects' centre), items: [[i, j, level]…] | \"source\"}, keyPoint? ([x, y]: the new base point is the source objects' key point nearest it, on the item there), replace?.keyPoint? ([x, y]: the replacement objects' key point nearest it is their base point), source?: {item? ([i, j, level], default [0, 0, 0])} (places the source objects for editing; ARRAYCLOSE ends)}",
)
.interactive(|_| Ok(Box::new(EditM::default()))),
CommandSpec::new("arrayclose", "Close Array Editing", run_arrayclose)
@@ -215,6 +217,16 @@ fn item_at(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Option<(u32, u32, u32)
best.map(|b| b.0)
}
/// ARRAYEDIT Key point: the key point of the source objects nearest `at`, with the objects as
/// placed at the item under `at` (within `tol`).
fn source_key_point(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Result<Vec2> {
let item = item_at(d, h, at, tol).ok_or_else(|| other("No array item there; specify a point on an item of the array."))?;
let (ins, blk, p) = array_of(d, h)?;
let src = d.block(&p.source).ok_or_else(|| other("The array's source block is missing."))?;
let m = ins.transform(blk.base.xy()).then_before(item_place(&p, item)?).then_before(Mat3::translate(-src.base.xy()));
nearest_key_point(src.entities.iter().map(|e| e.as_ref()), &m, at)?.ok_or_else(|| other("The source objects have no key point; specify a point."))
}
/// Move the base point of array `h` to world point `base` without moving the items.
fn rebase(s: &mut Session, h: Handle, base: Vec2) -> Result<()> {
let d = s.doc()?;
@@ -343,6 +355,9 @@ fn close_source(s: &mut Session, save: bool) -> Result<Value> {
// ---------------- JSON ----------------
/// How far outside an item's extents a JSON `keyPoint` may be.
const KEY_POINT_TOLERANCE: f64 = 1e-6;
fn item_param(v: &Value) -> Option<(u32, u32, u32)> {
let a = v.as_array()?;
let n = |k: usize| a.get(k).and_then(Value::as_u64).and_then(|x| u32::try_from(x).ok());
@@ -449,9 +464,7 @@ fn fill_from_between(b: f64, items: u32) -> Result<f64> {
fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
let h = super::super::curves::handle_param(p, "handle").ok_or_else(|| bad("arrayedit", "`handle` (the array) is required"))?;
refuse_while_editing(s)?;
let (ins, blk, _) = array_of(s.doc()?, h)?;
let w = ins.transform(blk.base.xy());
let to_local = w.inverse().ok_or_else(|| other("The array's scale is zero."))?;
array_of(s.doc()?, h)?;
if bool_or(p, "reset", false) {
let (_, _, mut a) = array_of(s.doc()?, h)?;
a.replaced.clear();
@@ -459,7 +472,10 @@ fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
}
if let Some(r) = p.get("replace").filter(|v| !v.is_null()) {
let hs = targets(s, r)?;
let base = point_param(r, "base").unwrap_or_else(|| s.doc().map(|d| centroid(d, &hs)).unwrap_or_default());
let base = match key_point_param("arrayedit", r)? {
Some(k) => key_point_of(s.doc()?, &hs, k)?,
None => point_param(r, "base").unwrap_or_else(|| s.doc().map(|d| centroid(d, &hs)).unwrap_or_default()),
};
let name = block_from(s, h, &hs, base)?;
let (_, _, mut a) = array_of(s.doc()?, h)?;
match r.get("items") {
@@ -477,7 +493,13 @@ fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(b) = point_param(p, "base") {
rebase(s, h, b)?;
}
let (_, _, mut a) = array_of(s.doc()?, h)?;
if let Some(k) = key_point_param("arrayedit", p)? {
let at = source_key_point(s.doc()?, h, k, KEY_POINT_TOLERANCE)?;
rebase(s, h, at)?;
}
// A new base point moves the array's insertion point: read `center` in its placement after.
let (ins, blk, mut a) = array_of(s.doc()?, h)?;
let to_local = ins.transform(blk.base.xy()).inverse().ok_or_else(|| other("The array's scale is zero."))?;
let before = a.clone();
apply_params(&mut a, p, &to_local)?;
if a != before {
@@ -507,6 +529,8 @@ enum Stage {
Select,
Main,
Base,
/// Base point: Key point (of the source objects).
BaseKey,
ColsCount,
ColsSpace,
ColsTotal,
@@ -524,6 +548,8 @@ enum Stage {
/// REPlace: objects, their base point, then the items to replace.
RepSelect,
RepBase,
/// REPlace base point: Key point (of the replacement objects).
RepKey,
RepItems,
/// Source: the item whose objects are placed for editing.
SourceItem,
@@ -659,6 +685,7 @@ impl Interactive for EditM {
.kw(&["Source", "REPlace", "Base point", "Rows", "Columns", "Levels", "RESet", "eXit"])
.default("eXit"),
Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
ColsCount => Prompt::new("Enter the number of columns", Accept::NUMBER).default(cols.to_string()),
ColsSpace => dist("Specify the distance between columns", cs).kw(&["Total"]),
ColsTotal => dist("Specify the distance between the first and last column", total(cols, cs)),
@@ -687,6 +714,7 @@ impl Interactive for EditM {
Rotate => Prompt::new("Rotate arrayed items?", KEYWORDS).kw(&["Yes", "No"]).default(yes(polar.as_ref().is_none_or(|k| k.rotate))),
RepSelect => Prompt::new("Select replacement objects", Accept::SELECT),
RepBase => Prompt::new("Select base point of replacement objects", Accept::POINT).kw(&["Key point"]).default("centroid"),
RepKey => Prompt::new("Specify key point on replacement objects to use as base point", Accept::POINT),
RepItems => Prompt::new("Select an item in array to replace", Accept::POINT).kw(&["Source objects"]),
SourceItem => Prompt::new("Select item in array", Accept::POINT),
}
@@ -746,10 +774,21 @@ impl Interactive for EditM {
}
Main
}
(Base | RepBase, Input::Keyword(_)) => {
s.echo("Key points are not available yet; specify a point.");
stage
(Base, Input::Keyword(_)) => BaseKey,
(RepBase, Input::Keyword(_)) => RepKey,
(BaseKey, Input::Point(p)) => {
let tol = s.pixel_size() * s.settings.pickbox;
let at = source_key_point(s.doc()?, h, *p, tol)?;
rebase(s, h, at)?;
Main
}
(BaseKey, Input::Enter) => Base,
(RepKey, Input::Point(p)) => {
let base = key_point_of(s.doc()?, &self.rep_objs, *p)?;
self.rep_block = Some(block_from(s, h, &self.rep_objs.clone(), base)?);
RepItems
}
(RepKey, Input::Enter) => RepBase,
(ColsCount | Items, _) => match count(&i, c64, self.max_for(s, r64.saturating_mul(l64)))? {
Some(n) => {
let n = super::count32(n);
+164 -6
View File
@@ -4,6 +4,7 @@
use cadcraft_doc::color::Color;
use cadcraft_doc::{AttribProps, Common, EntityKind, HAlign, Handle, Text, VAlign};
use cadcraft_geom::Vec3;
use serde_json::{Map, Value, json};
use crate::cmd::curves::KW;
@@ -153,6 +154,19 @@ fn set_value(text: &mut Text, value: String) {
}
}
/// Move `text` so the point it is placed by lands on `to`: the alignment point of justified text,
/// else the insertion point. Both points move by the same offset, so aligned and fit text keep the
/// baseline between them.
fn move_text(text: &mut Text, to: cadcraft_geom::Vec2) {
let anchor = match text.align_pt {
Some(ap) if !matches!((text.halign, text.valign), (HAlign::Left, VAlign::Baseline) | (HAlign::Aligned | HAlign::Fit, _)) => ap,
_ => text.insert,
};
let d = Vec3::new(to.x - anchor.x, to.y - anchor.y, 0.0);
text.insert = text.insert + d;
text.align_pt = text.align_pt.map(|ap| ap + d);
}
/// Change the properties set on attribute `k` of block reference `h`.
fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut AttribProps)) -> Result<()> {
s.doc_mut()?.modify_entity(h, |e| {
@@ -165,6 +179,18 @@ fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut Attri
Ok(())
}
/// Modify the attribute `k` of block reference `h`.
fn modify_attrib(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut cadcraft_doc::Attrib)) -> Result<()> {
s.doc_mut()?.modify_entity(h, |e| {
if let EntityKind::Insert(ins) = &mut e.kind
&& let Some(a) = ins.attribs.get_mut(k)
{
f(a);
}
})?;
Ok(())
}
/// The layer and colour attribute `k` of block reference `h` is drawn with: its own, else its
/// definition's (layer 0 is the reference's layer).
fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)> {
@@ -180,6 +206,14 @@ fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)
Some((layer, c.color))
}
/// The current text properties of attribute `k` of block reference `h`.
fn current_text(s: &Session, (h, k): (Handle, usize)) -> Option<cadcraft_doc::Text> {
let d = s.doc().ok()?;
let e = d.entity(h)?;
let EntityKind::Insert(ins) = &e.kind else { return None };
ins.attribs.get(k).map(|a| a.text.clone())
}
/// Replace every `find` in `value` with `with`, unless the result would be too long.
fn replaced(value: &str, find: &str, with: &str) -> Option<String> {
if find.is_empty() || !value.contains(find) {
@@ -292,6 +326,10 @@ enum Stage {
Select,
/// One at a time: what to do with the current attribute.
Option,
Position,
Height,
Angle,
Style,
ValueKind,
NewValue,
Layer,
@@ -365,6 +403,7 @@ impl Interactive for DashAtteditM {
}
fn prompt(&self, s: &Session) -> Prompt {
let cur = self.items.get(self.cur).and_then(|it| current_props(s, *it));
let cur_text = self.items.get(self.cur).and_then(|it| current_text(s, *it));
match self.stage {
Stage::OneAtATime => Prompt::new("Edit attributes one at a time?", KW).kw(&["Yes", "No"]).default("Y"),
Stage::VisibleOnly => Prompt::new("Edit only attributes visible on screen?", KW).kw(&["Yes", "No"]).default("Y"),
@@ -372,7 +411,31 @@ impl Interactive for DashAtteditM {
Stage::TagSpec => Prompt::new("Enter attribute tag specification", Accept::TEXT).default("*"),
Stage::ValueSpec => Prompt::new("Enter attribute value specification", Accept::TEXT).default("*"),
Stage::Select => Prompt::new("Select attributes", Accept::SELECT),
Stage::Option => Prompt::new("Enter an option", KW).kw(&["Value", "Layer", "Color", "Next"]).default("N"),
Stage::Option => {
Prompt::new("Enter an option", KW).kw(&["Value", "Position", "Height", "Angle", "Style", "Layer", "Color", "Next"]).default("N")
}
Stage::Position => Prompt::new("Enter new text insertion point", Accept::POINT),
Stage::Height => {
let p = Prompt::new("Enter new text height", Accept::POINT_OR_NUMBER);
match cur_text {
Some(t) => p.default(format!("{:.4}", t.height)),
None => p,
}
}
Stage::Angle => {
let p = Prompt::new("Enter new text rotation angle", Accept::POINT_OR_NUMBER);
match cur_text {
Some(t) => p.default(format!("{:.4}", t.rotation.to_degrees())),
None => p,
}
}
Stage::Style => {
let p = Prompt::new("Enter new text style", Accept::TEXT);
match cur_text {
Some(t) => p.default(t.style),
None => p,
}
}
Stage::ValueKind => Prompt::new("Enter type of value modification", KW).kw(&["Change", "Replace"]).default("R"),
Stage::NewValue => Prompt::new("Enter new attribute value", Accept::TEXT),
Stage::Layer => {
@@ -446,6 +509,10 @@ impl Interactive for DashAtteditM {
}
Stage::Option => match &i {
Input::Keyword(k) if k == "Value" => self.stage = Stage::ValueKind,
Input::Keyword(k) if k == "Position" => self.stage = Stage::Position,
Input::Keyword(k) if k == "Height" => self.stage = Stage::Height,
Input::Keyword(k) if k == "Angle" => self.stage = Stage::Angle,
Input::Keyword(k) if k == "Style" => self.stage = Stage::Style,
Input::Keyword(k) if k == "Layer" => self.stage = Stage::Layer,
Input::Keyword(k) if k == "Color" => self.stage = Stage::Color,
Input::Keyword(_) | Input::Enter => {
@@ -457,14 +524,105 @@ impl Interactive for DashAtteditM {
}
Input::Text(t) => {
let tl = t.trim().to_ascii_lowercase();
let later = ["Position", "Height", "Angle", "Style"];
return match later.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
Some(k) => Err(EngineError::Other(format!("{k} is not available yet."))),
None => Err(invalid_keyword()),
};
let opts = ["Value", "Position", "Height", "Angle", "Style", "Layer", "Color", "Next"];
match opts.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
Some(&"Value") => self.stage = Stage::ValueKind,
Some(&"Position") => self.stage = Stage::Position,
Some(&"Height") => self.stage = Stage::Height,
Some(&"Angle") => self.stage = Stage::Angle,
Some(&"Style") => self.stage = Stage::Style,
Some(&"Layer") => self.stage = Stage::Layer,
Some(&"Color") => self.stage = Stage::Color,
Some(&"Next") => {
self.cur += 1;
if self.cur >= self.items.len() {
return Ok(Step::Done);
}
self.show_current(s);
}
_ => return Err(invalid_keyword()),
}
}
_ => {}
},
Stage::Position => {
let p = match i {
Input::Point(p) => p,
Input::Enter => {
self.stage = Stage::Option;
return Ok(Step::Continue);
}
_ => return Ok(Step::Continue),
};
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| move_text(&mut a.text, p))?;
}
self.stage = Stage::Option;
}
Stage::Height => {
let h = match &i {
Input::Point(p) => {
let cur_pt = self.items.get(self.cur).and_then(|it| current_text(s, *it)).map(|t| t.insert.xy());
match cur_pt {
Some(base) => base.dist(*p).max(1e-9),
None => p.len().max(1e-9),
}
}
Input::Text(t) if !t.trim().is_empty() => crate::units::parse_distance(t.trim())
.filter(|v| *v > 0.0)
.ok_or_else(|| EngineError::Other("Requires a positive number.".into()))?,
Input::Enter => {
self.stage = Stage::Option;
return Ok(Step::Continue);
}
_ => return Ok(Step::Continue),
};
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| {
a.text.height = h;
})?;
}
self.stage = Stage::Option;
}
Stage::Angle => {
let ang = match &i {
Input::Point(p) => {
let cur_pt = self.items.get(self.cur).and_then(|it| current_text(s, *it)).map(|t| t.insert.xy());
match cur_pt {
Some(base) => base.angle_to(*p),
None => p.y.atan2(p.x),
}
}
Input::Text(t) if !t.trim().is_empty() => {
s.angle_settings().direction(t.trim()).ok_or_else(|| EngineError::Other("Requires an angle.".into()))?
}
Input::Enter => {
self.stage = Stage::Option;
return Ok(Step::Continue);
}
_ => return Ok(Step::Continue),
};
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| {
a.text.rotation = ang;
})?;
}
self.stage = Stage::Option;
}
Stage::Style => {
let Some(t) = text else { return Ok(Step::Continue) };
let t = t.trim();
if !t.is_empty() {
let st =
s.doc()?.text_style(t).map(|st| st.name.clone()).ok_or_else(|| EngineError::Other(format!("Cannot find style \"{t}\".")))?;
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| {
a.text.style = st;
})?;
}
}
self.stage = Stage::Option;
}
Stage::ValueKind => match &i {
Input::Keyword(k) if k == "Change" => self.stage = Stage::Find,
Input::Keyword(_) | Input::Enter => self.stage = Stage::NewValue,
+246 -16
View File
@@ -1,6 +1,7 @@
//! Layers: LAYER (programmatic sub-ids, -LAYER prompts), layer tools (LAYMCUR, LAYISO, LAYOFF, LAYFRZ…).
mod prompts;
mod state_prompts;
use cadcraft_color::Color;
use cadcraft_doc::{Layer, Lineweight};
@@ -55,7 +56,9 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("layon", "Turn All Layers On", |s, _| all_layers(s, |l| l.on = true)),
CommandSpec::new("laythw", "Thaw All Layers", |s, _| all_layers(s, |l| l.frozen = false)),
CommandSpec::new("layerp", "Previous Layer", run_layerp).menu(&["Format", "Layer Tools", "Previous Layer"]),
CommandSpec::new("layerstate.save", "Save Layer State", run_state_save).menu(&["Format", "Layer States Manager..."]).params("{name}"),
CommandSpec::new("layerstate.save", "Save Layer State", run_state_save)
.menu(&["Format", "Layer States Manager..."])
.params("{name, mask? (properties restoring sets: 1 on, 2 frozen, 4 locked, 8 plot, 16 new viewport freeze, 32 color, 64 linetype, 128 lineweight, 256 plot style, 1024 transparency; default all)}"),
CommandSpec::new("layerstate.restore", "Restore Layer State", run_state_restore).params("{name}"),
CommandSpec::new("layerstate.list", "List Layer States", run_state_list).params("{} → states").noundo(),
CommandSpec::new("layerstate.delete", "Delete Layer State", run_state_delete).params("{name}"),
@@ -400,31 +403,108 @@ fn all_layers(s: &mut Session, f: fn(&mut Layer)) -> Result<Value> {
}
fn run_state_save(s: &mut Session, p: &Value) -> Result<Value> {
use cadcraft_doc::LayerState as S;
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.save", "`name` is required"))?.to_string();
// As -LAYER stAte Save and layerstate.rename take names: none empty, over 255 characters, with a
// control character or with one AutoCAD 2024 refuses (measured for Save).
if !valid_name(&name) {
return Err(bad("layerstate.save", "invalid name"));
}
// The properties restoring sets; bit 512, which no property toggles, is always set, as AutoCAD
// 2024 saves it (measured: On alone is 513).
let mask = match p.get("mask") {
None | Some(Value::Null) => S::ALL,
Some(v) => {
let m = v.as_u64().filter(|m| m & !u64::from(S::ALL) == 0);
m.and_then(|m| u32::try_from(m).ok()).ok_or_else(|| bad("layerstate.save", "`mask` must be a sum of layer state bits (0 to 2047)"))? | 512
}
};
let d = s.doc_mut()?;
let layers = d.layers.clone();
d.layer_states.retain(|st| st.name != name);
d.layer_states.push(cadcraft_doc::LayerState { name, layers });
let current = d.header.str("CLAYER", "0");
// Replace the state Restore and Delete reach (the same spelling, else another case), so a
// drawing keeps one state per name: AutoCAD 2024 finds states without regard to case. Its
// -LAYER stAte Save and layerstate-save refuse `s1` after `S1` (measured), as the command line
// here does; this command replaces, as it does a state of the same spelling. When a file holds
// both `S1` and `s1`, only the one spelled so is replaced.
if let Some(i) = state_index(d, &name) {
d.layer_states.remove(i);
}
d.layer_states.push(S { mask, ..S::new(name, layers, current) });
ok()
}
/// The saved state called `name`: the one spelled so, else the first whose name differs only in
/// case. AutoCAD 2024 finds layer states without regard to case (measured: Restore, Edit, Name
/// and Delete of `s1` reach `S1`); case is compared as for layers and view snapshots.
pub(super) fn state_index(d: &cadcraft_doc::Drawing, name: &str) -> Option<usize> {
d.layer_states.iter().position(|st| st.name == name).or_else(|| d.layer_states.iter().position(|st| st.name.eq_ignore_ascii_case(name)))
}
fn run_state_restore(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.restore", "`name` is required"))?;
let d = s.doc_mut()?;
let st = d.layer_states.iter().find(|st| st.name == name).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
restore_layers(d, st.layers);
let st = state_index(d, name).and_then(|i| d.layer_states.get(i)).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
restore_state(d, &st);
ok()
}
/// Restore a saved layer state as AutoCAD 2024 does (measured): first the current layer it
/// names, when the drawing has it and the restore doesn't leave it frozen, then on each drawing
/// layer the state names (without regard to case) the properties its mask covers. The current
/// layer is never frozen; other properties (descriptions, names) stay as they are.
pub(crate) fn restore_state(d: &mut cadcraft_doc::Drawing, st: &cadcraft_doc::LayerState) {
use cadcraft_doc::LayerState as S;
// A frozen layer only thaws with Frozen in the mask and an entry of its own: without one
// AutoCAD 2024 keeps the current layer (measured).
let thaws = |l: &Layer| st.mask & S::FROZEN != 0 && st.layers.iter().any(|saved| saved.name.eq_ignore_ascii_case(&l.name));
if let Some(l) = d.layer(&st.current).filter(|l| !l.frozen || thaws(l)) {
let name = l.name.clone();
d.header.set_str("CLAYER", &name);
}
let current = d.header.str("CLAYER", "0");
let index = layer_index(d);
let has = |bit: u32| st.mask & bit != 0;
for saved in &st.layers {
let Some(l) = index.get(&saved.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) else { continue };
if has(S::ON) {
l.on = saved.on;
}
if has(S::FROZEN) {
l.frozen = saved.frozen && !l.name.eq_ignore_ascii_case(&current);
}
if has(S::LOCKED) {
l.locked = saved.locked;
}
if has(S::PLOT) {
l.plot = saved.plot;
}
if has(S::VP_FREEZE_NEW) {
l.vp_freeze_new = saved.vp_freeze_new;
}
if has(S::COLOR) {
l.color = saved.color;
}
if has(S::LINETYPE) {
l.linetype.clone_from(&saved.linetype);
}
if has(S::LINEWEIGHT) {
l.lineweight = saved.lineweight;
}
if has(S::PLOT_STYLE) {
l.plot_style.clone_from(&saved.plot_style);
}
if has(S::TRANSPARENCY) {
l.transparency = saved.transparency;
}
}
}
/// Put the saved layers back over the drawing's layers of the same name (without regard to case);
/// saved layers the drawing no longer has are skipped. Both lists can come from a file, so the
/// drawing's layers are looked up in an index rather than scanned per saved layer.
pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::with_capacity(d.layers.len());
for (i, l) in d.layers.iter().enumerate() {
// The first of names that differ only in case, as `Drawing::layer_mut` finds it.
index.entry(l.name.to_ascii_lowercase()).or_insert(i);
}
let index = layer_index(d);
for layer in saved {
if let Some(l) = index.get(&layer.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) {
*l = layer;
@@ -432,6 +512,16 @@ pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
}
}
/// The drawing's layers by lower-case name: the first of names that differ only in case, as
/// `Drawing::layer_mut` finds it.
fn layer_index(d: &cadcraft_doc::Drawing) -> std::collections::HashMap<String, usize> {
let mut index = std::collections::HashMap::with_capacity(d.layers.len());
for (i, l) in d.layers.iter().enumerate() {
index.entry(l.name.to_ascii_lowercase()).or_insert(i);
}
index
}
fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
let d = s.doc()?;
let states: Vec<Value> = d.layer_states.iter().map(|st| json!({ "name": st.name, "layers": st.layers.len() })).collect();
@@ -446,10 +536,8 @@ fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
fn run_state_delete(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.delete", "`name` is required"))?;
let d = s.doc_mut()?;
if !d.layer_states.iter().any(|st| st.name == name) {
return Err(bad("layerstate.delete", "no such layer state"));
}
d.layer_states.retain(|st| st.name != name);
let i = state_index(d, name).ok_or_else(|| bad("layerstate.delete", "no such layer state"))?;
d.layer_states.remove(i);
ok()
}
@@ -460,10 +548,12 @@ fn run_state_rename(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad("layerstate.rename", "invalid name"));
}
let d = s.doc_mut()?;
if d.layer_states.iter().any(|st| st.name == to) {
// A name in another case counts, the state's own too (AutoCAD 2024 refuses `S1` to `s1`,
// measured).
if d.layer_states.iter().any(|st| st.name.eq_ignore_ascii_case(&to)) {
return Err(bad("layerstate.rename", format!("layer state `{to}` already exists")));
}
let st = d.layer_states.iter_mut().find(|st| st.name == from).ok_or_else(|| bad("layerstate.rename", "no such layer state"))?;
let st = state_index(d, from).and_then(|i| d.layer_states.get_mut(i)).ok_or_else(|| bad("layerstate.rename", "no such layer state"))?;
st.name = to;
ok()
}
@@ -516,6 +606,146 @@ mod tests {
assert!(used.contains(&true) && used.contains(&false));
}
/// Restoring follows AutoCAD 2024 (measured with -LAYER stAte and states written into a DXF):
/// the current layer first, then only the properties the mask covers; the current layer stays
/// thawed; a current layer that is empty or gone leaves the current layer as it is.
#[test]
fn layer_state_restore_follows_the_mask_and_current_layer() {
use cadcraft_color::Color;
use cadcraft_doc::LayerState;
let mut s = Session::new();
s.execute("layer.new", &json!({ "name": "A", "color": 1, "current": true })).unwrap();
s.execute("layer.new", &json!({ "name": "B" })).unwrap();
s.execute("layerstate.save", &json!({ "name": "all" })).unwrap();
let saved = s.doc().unwrap().layer_states[0].clone();
assert_eq!((saved.mask, saved.current.as_str()), (LayerState::ALL, "A"));
// Only On: A's colour stays green, B comes back on (AutoCAD's S7, mask 513).
let d = s.doc_mut().unwrap();
d.layer_states.push(LayerState { name: "on".into(), mask: LayerState::ON | 512, ..saved.clone() });
s.execute("layer.set", &json!({ "name": "A", "color": 3 })).unwrap();
s.execute("layer.set", &json!({ "name": "B", "on": false, "locked": true })).unwrap();
s.execute("layer.current", &json!({ "name": "B" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "on" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
let (a, b) = (d.layer("A").unwrap(), d.layer("B").unwrap());
assert_eq!((a.color, b.on, b.locked), (Color::Index(3), true, true));
// Every property.
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
let d = s.doc().unwrap();
assert_eq!((d.layer("A").unwrap().color, d.layer("B").unwrap().locked), (Color::Index(1), false));
// A state that freezes B with no current layer of its own (or one that is gone), restored
// with B current: B stays current and thawed; A is turned off.
for current in ["", "NOSUCH"] {
let mut frozen = s.doc().unwrap().layers.clone();
for l in &mut frozen {
l.frozen = l.name == "B";
l.on = l.name != "A";
}
s.doc_mut().unwrap().layer_states.push(LayerState::new(format!("f{current}"), frozen.clone(), current));
s.execute("layer.current", &json!({ "name": "B" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": format!("f{current}") })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "B", "{current:?}");
assert!(!d.layer("B").unwrap().frozen && !d.layer("A").unwrap().on, "{current:?}");
// Naming A current, it becomes current and B freezes.
s.doc_mut().unwrap().layer_states.push(LayerState::new("fA", frozen, "A"));
s.execute("layerstate.restore", &json!({ "name": "fA" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
assert!(d.layer("B").unwrap().frozen);
s.doc_mut().unwrap().layer_states.retain(|st| st.name != "fA");
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
}
// A current layer the state's mask leaves frozen doesn't become current (AutoCAD's S9: On
// only, current B; restored with A current and B frozen).
let mut on_only = s.doc().unwrap().layer_states[0].clone();
(on_only.name, on_only.mask, on_only.current) = ("S9".into(), LayerState::ON | 512, "B".into());
s.doc_mut().unwrap().layer_states.push(on_only);
s.execute("layer.current", &json!({ "name": "A" })).unwrap();
s.execute("layer.set", &json!({ "name": "B", "frozen": true })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "S9" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
assert!(d.layer("B").unwrap().frozen);
// With Frozen in the mask B is thawed and made current.
let mut thaw = s.doc().unwrap().layer_states[0].clone();
(thaw.name, thaw.current) = ("thaw".into(), "B".into());
s.doc_mut().unwrap().layer_states.push(thaw);
s.execute("layerstate.restore", &json!({ "name": "thaw" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "B");
assert!(!d.layer("B").unwrap().frozen);
// Frozen in the mask, but no entry for B (a state written elsewhere): nothing would thaw
// B, so A stays current and B frozen (AutoCAD 2024, measured).
let mut no_entry = s.doc().unwrap().layer_states[0].clone();
(no_entry.name, no_entry.current) = ("no entry".into(), "B".into());
no_entry.layers.retain(|l| l.name != "B");
s.doc_mut().unwrap().layer_states.push(no_entry);
s.execute("layer.current", &json!({ "name": "A" })).unwrap();
s.execute("layer.set", &json!({ "name": "B", "frozen": true })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "no entry" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
assert!(d.layer("B").unwrap().frozen);
// An entry spelled in another case is B's (layer names ignore case, as the restore of the
// properties does): B is thawed and made current.
let mut other_case = s.doc().unwrap().layer_states[0].clone();
(other_case.name, other_case.current) = ("other case".into(), "B".into());
for l in other_case.layers.iter_mut().filter(|l| l.name == "B") {
l.name = "b".into();
}
s.doc_mut().unwrap().layer_states.push(other_case);
s.execute("layerstate.restore", &json!({ "name": "other case" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "B");
assert!(!d.layer("B").unwrap().frozen);
// What a state doesn't hold stays: the description.
s.execute("layer.set", &json!({ "name": "A", "description": "kept" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
assert_eq!(s.doc().unwrap().layer("A").unwrap().description, "kept");
}
/// Plotting, freezing in new viewports, linetype, lineweight, plot style and transparency each
/// come back under their own mask bit only: a state of one bit restores that property and
/// leaves the other five as they are.
#[test]
fn layer_state_restores_each_property_under_its_own_bit_only() {
use cadcraft_doc::{Drawing, LayerState as S, Lineweight};
let mut s = Session::new();
s.execute("layer.new", &json!({ "name": "A" })).unwrap();
s.execute("layerstate.save", &json!({ "name": "all" })).unwrap();
let saved = s.doc().unwrap().layer_states[0].clone();
let props = |d: &Drawing| {
let l = d.layer("A").unwrap();
(l.plot, l.vp_freeze_new, l.linetype.clone(), l.lineweight, l.plot_style.clone(), l.transparency)
};
let change = |d: &mut Drawing| {
let l = d.layer_mut("A").unwrap();
(l.plot, l.vp_freeze_new, l.linetype, l.lineweight, l.plot_style, l.transparency) =
(false, true, "DASHED".into(), Lineweight::from_dxf(50), "Thick".into(), 40);
};
let before = props(s.doc().unwrap());
change(s.doc_mut().unwrap());
let after = props(s.doc().unwrap());
for bit in [S::PLOT, S::VP_FREEZE_NEW, S::LINETYPE, S::LINEWEIGHT, S::PLOT_STYLE, S::TRANSPARENCY] {
let name = format!("b{bit}");
s.doc_mut().unwrap().layer_states.push(S { name: name.clone(), mask: bit | 512, ..saved.clone() });
change(s.doc_mut().unwrap());
s.execute("layerstate.restore", &json!({ "name": name })).unwrap();
let mut want = after.clone();
match bit {
S::PLOT => want.0 = before.0,
S::VP_FREEZE_NEW => want.1 = before.1,
S::LINETYPE => want.2.clone_from(&before.2),
S::LINEWEIGHT => want.3 = before.3,
S::PLOT_STYLE => want.4.clone_from(&before.4),
_ => want.5 = before.5,
}
assert_eq!(props(s.doc().unwrap()), want, "mask {bit}");
}
}
#[test]
fn rejected_layer_set_changes_nothing() {
let mut s = Session::new();
+20 -7
View File
@@ -8,6 +8,7 @@ use serde_json::{Value, json};
use super::super::find_command;
use super::super::qselect::wildcard;
use super::state_prompts;
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
const OPTIONS: &[&str] = &[
@@ -34,9 +35,9 @@ const OPTIONS: &[&str] = &[
];
/// Keyword-only: spaces separate inputs.
const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
pub(super) const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
/// A name or value: Space ends the input, as it does in AutoCAD scripts.
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
pub(super) const NAME: Accept = Accept { number: true, ..Accept::TEXT };
/// A per-layer change applied to a list of layer names.
#[derive(Clone, Debug)]
@@ -111,6 +112,8 @@ enum Stage {
Layers(Change),
/// Turning the current layer off asks first.
ConfirmOff(Vec<String>),
/// stAte and its options.
State(state_prompts::Stage),
}
#[derive(Default)]
@@ -123,19 +126,19 @@ fn current_layer(s: &Session) -> String {
}
/// Run a layer command's body directly: the running command records the single undo step.
fn call(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
pub(super) fn call(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.into()))?;
(spec.run)(s, p)
}
fn message(e: &EngineError) -> String {
pub(super) fn message(e: &EngineError) -> String {
match e {
EngineError::BadParams { msg, .. } => msg.clone(),
other => other.to_string(),
}
}
fn retry(msg: impl Into<String>) -> EngineError {
pub(super) fn retry(msg: impl Into<String>) -> EngineError {
EngineError::Other(msg.into())
}
@@ -188,8 +191,9 @@ impl LayerM {
"LOck" => Stage::Layers(Change::Lock),
"Unlock" => Stage::Layers(Change::Unlock),
"Description" => Stage::Description,
"stAte" => Stage::State(state_prompts::Stage::Option),
other => {
// MATerial, stAte, rEconcile: report and stay at the option prompt.
// MATerial, rEconcile: report and stay at the option prompt.
s.echo(format!("-LAYER {other} is not available yet."));
Stage::Option
}
@@ -262,7 +266,7 @@ impl LayerM {
Ok(Step::Continue)
};
match stage {
Stage::Option => Ok(Step::Continue),
Stage::Option | Stage::State(_) => Ok(Step::Continue),
Stage::List => {
self.list(s, text.as_deref().unwrap_or("*"));
Ok(Step::Continue)
@@ -434,9 +438,18 @@ impl Interactive for LayerM {
if enter_is_current { p.default(cur) } else { p }
}
Stage::ConfirmOff(_) => Prompt::new(format!("Really want layer \"{cur}\" (the CURRENT layer) off?"), KW).kw(&["Yes", "No"]).default("N"),
Stage::State(st) => st.prompt(),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Stage::State(st) = &mut self.stage
&& !matches!(i, Input::Cancel)
{
if !st.input(s, &i)? {
self.stage = Stage::Option;
}
return Ok(Step::Continue);
}
match (&self.stage, &i) {
(_, Input::Cancel) => Ok(Step::Cancel),
(Stage::Option, Input::Enter) => Ok(Step::Done),
@@ -0,0 +1,256 @@
//! -LAYER stAte: save, restore, edit, rename, delete and list the drawing's layer states, with
//! AutoCAD 2024's prompts and messages (measured). Save, Restore, Name and Delete run the
//! `layerstate.*` commands; Edit changes the state's mask in place.
use cadcraft_doc::LayerState as LS;
use serde_json::{Value, json};
use super::prompts::{KW, NAME, call, message, retry};
use super::{state_index, valid_name};
use crate::{Input, Prompt, Result, Session};
/// The options after stAte. Import and EXport (layer state files) are not available yet.
const OPTIONS: &[&str] = &["?", "Save", "Restore", "Edit", "Name", "Delete", "Import", "EXport"];
/// "Enter states to change": each keyword, the name AutoCAD 2024 lists it by and its mask bit, in
/// AutoCAD's order.
const TOGGLES: [(&str, &str, u32); 10] = [
("On", "On", LS::ON),
("Frozen", "Frozen", LS::FROZEN),
("Lock", "Lock", LS::LOCKED),
("Plot", "Plot", LS::PLOT),
("Newvpfreeze", "Newvpfreeze", LS::VP_FREEZE_NEW),
("Color", "Color", LS::COLOR),
("lineType", "lineType", LS::LINETYPE),
("lineWeight", "lineWeight", LS::LINEWEIGHT),
("TRansparency", "Transparency", LS::TRANSPARENCY),
("plotStyle", "plotStyle", LS::PLOT_STYLE),
];
/// The options that ask for a saved state's name.
#[derive(Clone, Copy, Debug)]
pub(super) enum Pick {
Restore,
Edit,
Name,
Delete,
}
impl Pick {
fn verb(self) -> &'static str {
match self {
Pick::Restore => "restore",
Pick::Edit => "edit",
Pick::Name => "rename",
Pick::Delete => "delete",
}
}
}
#[derive(Clone, Debug, Default)]
pub(super) enum Stage {
#[default]
Option,
/// Save: the new state's name.
SaveName,
/// Restore, Edit, Name or Delete: the saved state's name.
Pick(Pick),
/// Name: the new name of the state called so.
RenameTo(String),
/// "Enter states to change" for the state `name`: one Save makes on Enter, or one Edit
/// changes (`edit`).
Toggles { name: String, mask: u32, edit: bool },
}
impl Stage {
pub(super) fn prompt(&self) -> Prompt {
match self {
Stage::Option => Prompt::new("Enter an option", KW).kw(OPTIONS),
Stage::SaveName | Stage::RenameTo(_) => Prompt::new("Enter new layer state name", NAME),
Stage::Pick(p) => Prompt::new(format!("Enter name of layer state to {}", p.verb()), NAME).kw(&["?"]),
Stage::Toggles { .. } => Prompt::new("Enter states to change", KW).kw(&TOGGLES.map(|t| t.0)),
}
}
/// One input. `Ok(false)`: back to -LAYER's options. An invalid input leaves the stage as it
/// is, so the prompt is asked again.
pub(super) fn input(&mut self, s: &mut Session, i: &Input) -> Result<bool> {
let text = match i {
Input::Text(t) | Input::Keyword(t) => Some(t.trim().to_string()).filter(|t| !t.is_empty()),
_ => None,
};
let next = match std::mem::take(self) {
Stage::Option => match i {
Input::Enter => return Ok(false),
Input::Keyword(k) => option(s, k),
_ => return Err(retry("Invalid option keyword.")),
},
Stage::SaveName => match text {
None => Stage::Option,
Some(n) => save_name(s, n),
},
Stage::Pick(p) => match (i, text) {
(Input::Keyword(k), _) if k == "?" => {
list(s);
Stage::Pick(p)
}
(_, None) => Stage::Option,
(_, Some(n)) => pick(s, p, &n),
},
Stage::RenameTo(from) => {
if let Some(to) = text {
rename(s, &from, &to);
}
Stage::Option
}
Stage::Toggles { name, mut mask, edit } => match i {
Input::Keyword(k) => {
if let Some(&(_, _, bit)) = TOGGLES.iter().find(|t| t.0 == k) {
mask ^= bit;
}
show(s, mask);
Stage::Toggles { name, mask, edit }
}
Input::Enter => {
finish(s, &name, mask, edit);
Stage::Option
}
_ => {
*self = Stage::Toggles { name, mask, edit };
return Err(retry("Invalid option keyword."));
}
},
};
*self = next;
Ok(true)
}
}
fn option(s: &mut Session, k: &str) -> Stage {
match k {
"?" => {
list(s);
Stage::Option
}
"Save" => Stage::SaveName,
"Restore" => Stage::Pick(Pick::Restore),
"Edit" => Stage::Pick(Pick::Edit),
"Name" => Stage::Pick(Pick::Name),
"Delete" => Stage::Pick(Pick::Delete),
other => {
s.echo(format!("-LAYER stAte {other} is not available yet."));
Stage::Option
}
}
}
/// Whether a saved state has the name `n` in any case.
fn taken(s: &Session, n: &str) -> bool {
s.doc().is_ok_and(|d| d.layer_states.iter().any(|st| st.name.eq_ignore_ascii_case(n)))
}
/// Save's name: refused (asked again) when it has a character AutoCAD 2024 refuses (the layer
/// name ones, measured one by one), is longer than 255 characters (measured 256), or is a saved
/// state's name in any case (measured `s1` after `S1`).
fn save_name(s: &mut Session, n: String) -> Stage {
if !valid_name(&n) {
s.echo(format!("\"{n}\" is an invalid layer state name."));
return Stage::SaveName;
}
if taken(s, &n) {
s.echo(format!("Layer state \"{n}\" already exists."));
return Stage::SaveName;
}
let mask = s.settings.layer_state_mask;
show(s, mask);
Stage::Toggles { name: n, mask, edit: false }
}
fn pick(s: &mut Session, p: Pick, n: &str) -> Stage {
let found = s.doc().ok().and_then(|d| state_index(d, n).and_then(|i| d.layer_states.get(i)).map(|st| (st.name.clone(), st.mask)));
let Some((name, mask)) = found else {
s.echo("Unknown layer state name.");
return Stage::Pick(p);
};
match p {
Pick::Restore => {
run(s, "layerstate.restore", &json!({ "name": name }));
Stage::Option
}
Pick::Delete => {
run(s, "layerstate.delete", &json!({ "name": name }));
Stage::Option
}
Pick::Edit => {
show(s, mask);
Stage::Toggles { name, mask, edit: true }
}
Pick::Name => Stage::RenameTo(name),
}
}
/// Name's new name. A name some state has in any case, the state's own too, is refused with
/// AutoCAD 2024's two lines (measured `S2` onto `S2`, `S1` onto `s1`). A name with a character
/// AutoCAD refuses leaves the state as it is with no message, as AutoCAD does (measured `a,b`,
/// `a<b`); AutoCAD renames to a name starting with "*" as an anonymous `*A1`, and CADCraft leaves
/// that state as it is too.
fn rename(s: &mut Session, from: &str, to: &str) {
if taken(s, to) {
s.echo("Layer state could not be renamed.");
s.echo(format!("{to} already exists."));
} else if valid_name(to) {
run(s, "layerstate.rename", &json!({ "from": from, "to": to }));
}
}
/// Enter at "Enter states to change": Save makes the state with this mask and keeps the toggles
/// for the next Save; Edit sets the state's mask and keeps the bits no toggle reaches (AutoCAD's
/// 65536 after a restore). Edit leaves the next Save's toggles alone (measured).
fn finish(s: &mut Session, name: &str, mask: u32, edit: bool) {
if !edit {
if run(s, "layerstate.save", &json!({ "name": name, "mask": mask & LS::ALL })) {
s.settings.layer_state_mask = mask & LS::ALL;
}
return;
}
// Only a changed mask touches the drawing.
let Ok(d) = s.doc() else { return };
let Some(i) = state_index(d, name).filter(|&i| d.layer_states.get(i).is_some_and(|st| st.mask != mask)) else { return };
if let Ok(d) = s.doc_mut()
&& let Some(st) = d.layer_states.get_mut(i)
{
st.mask = mask;
}
}
/// Run a `layerstate.*` command, reporting a refusal; `true` when it ran.
fn run(s: &mut Session, id: &str, p: &Value) -> bool {
match call(s, id, p) {
Ok(_) => true,
Err(e) => {
s.echo(message(&e));
false
}
}
}
/// The toggles as AutoCAD 2024 lists them before "Enter states to change".
fn show(s: &mut Session, mask: u32) {
s.echo("States");
for (_, label, bit) in TOGGLES {
s.echo(format!("{label:<20}{}", if mask & bit != 0 { "Yes" } else { "No" }));
}
}
/// `?`: every saved state by name without regard to case, as AutoCAD 2024 lists them (measured:
/// `S2`, `b`, `S1` saved in that order list as `b`, `S1`, `S2`; a name starting with "*", its
/// `*A1`, is listed too).
fn list(s: &mut Session) {
let mut names: Vec<String> = s.doc().map(|d| d.layer_states.iter().map(|st| st.name.clone()).collect()).unwrap_or_default();
names.sort_by_cached_key(|n| n.to_ascii_lowercase());
s.echo("Layer state");
s.echo("-".repeat(29));
for n in names {
s.echo(n);
}
}
+1 -4
View File
@@ -323,16 +323,13 @@ impl Interactive for StretchM {
s.echo("Select objects to stretch by crossing-window or crossing-polygon...");
Ok(Step::Continue)
}
/// Returns the active interactive prompt for the current `STRETCH` phase.
fn prompt(&self, _s: &Session) -> Prompt {
if let (StretchPhase::Select, Some(m)) = (self.phase, &self.mode) {
return m.prompt();
}
match (self.phase, self.corner) {
(StretchPhase::Select, Some(c)) => Prompt::new("Specify opposite corner", Accept::POINT).corner(c),
(StretchPhase::Select, None) => {
Prompt { picks_one: self.removing, ..Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT) }
}
(StretchPhase::Select, None) => Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT),
(StretchPhase::Base, _) => Prompt::new("Specify base point", Accept::POINT).kw(&["Displacement"]).default("Displacement"),
(StretchPhase::Displacement, _) => Prompt::new("Specify displacement", Accept::POINT).default("0,0"),
(StretchPhase::Second, _) => Prompt::new("Specify second point or <use first point as displacement>", Accept::POINT).base_opt(self.base),
+2 -2
View File
@@ -101,7 +101,7 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("rename", "Rename...", run_rename)
.menu(&["Format", "Rename..."])
.alias(&["ren", "-rename"])
.params("{table: layer|linetype|style|dimstyle|block|mleaderstyle|tablestyle|view|ucs, from, to}")
.params("{table: layer|linetype|style|dimstyle|block|mleaderstyle|tablestyle|view|ucs|vport, from, to}")
.interactive(|_| Ok(Box::new(rename::RenameM::default()))),
]
}
@@ -995,7 +995,7 @@ fn run_rename(s: &mut Session, p: &Value) -> Result<Value> {
}
"block" => rename::block(s, &from, &to)?,
"mleaderstyle" | "multileaderstyle" => rename::simple(s, "mleaderstyle", &from, &to)?,
"tablestyle" | "view" | "ucs" => rename::simple(s, &table, &from, &to)?,
"tablestyle" | "view" | "ucs" | "vport" => rename::simple(s, &table, &from, &to)?,
"style" | "textstyle" => {
run_style_rename(s, &json!({ "from": from, "to": to }))?;
}
+81 -16
View File
@@ -93,6 +93,8 @@ pub(super) fn simple(s: &mut Session, table: &str, from: &str, to: &str) -> Resu
"tablestyle" => d.table_styles.iter_mut().map(|t| &mut t.name).collect(),
"view" => d.views.iter_mut().map(|t| &mut t.name).collect(),
"ucs" => d.ucss.iter_mut().map(|t| &mut t.name).collect(),
// A saved viewport configuration, every tile of it; never the one shown (`*Active`).
"vport" => d.vports.iter_mut().filter(|v| !v.is_active()).map(|t| &mut t.name).collect(),
_ => return Err(bad("rename", "unsupported table")),
};
if !to.eq_ignore_ascii_case(from) && names.iter().any(|n| n.eq_ignore_ascii_case(&to)) {
@@ -134,35 +136,47 @@ const TYPES: &[(&str, Option<&str>, &str)] = &[
("Plotstyle", None, "plot style"),
("textStyle", Some("style"), "text style"),
("Tablestyle", Some("tablestyle"), "table style"),
("Ucs", Some("ucs"), "UCS"),
("Ucs", Some("ucs"), "ucs"),
("VIew", Some("view"), "view"),
("VPort", None, "viewport configuration"),
("VPort", Some("vport"), "viewport configuration"),
];
/// The noun in "Cannot find …" and "Invalid … name.": AutoCAD 2024 writes "UCS" there, "ucs" in
/// its prompts and in "A ucs named … already exists." (measured).
fn title(noun: &str) -> &str {
if noun == "ucs" { "UCS" } else { noun }
}
/// Keyword-only: spaces separate inputs.
const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
/// A name: Space ends the input.
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
fn any_named<'a>(mut names: impl Iterator<Item = &'a String>, name: &str) -> bool {
names.any(|n| n.eq_ignore_ascii_case(name))
fn any_named<'a>(mut names: impl Iterator<Item = &'a String>, name: &str) -> Option<String> {
names.find(|n| n.eq_ignore_ascii_case(name)).cloned()
}
fn exists(d: &Drawing, table: &str, name: &str) -> bool {
/// The name as the drawing spells it of the `table` entry named `name` (without regard to case).
fn stored(d: &Drawing, table: &str, name: &str) -> Option<String> {
match table {
"block" => d.block(name).is_some(),
"layer" => d.layer(name).is_some(),
"linetype" => d.linetype(name).is_some(),
"style" => d.text_style(name).is_some(),
"dimstyle" => d.dim_style(name).is_some(),
"block" => d.block(name).map(|t| t.name.clone()),
"layer" => d.layer(name).map(|t| t.name.clone()),
"linetype" => d.linetype(name).map(|t| t.name.clone()),
"style" => d.text_style(name).map(|t| t.name.clone()),
"dimstyle" => d.dim_style(name).map(|t| t.name.clone()),
"mleaderstyle" => any_named(d.mleader_styles.iter().map(|t| &t.name), name),
"tablestyle" => any_named(d.table_styles.iter().map(|t| &t.name), name),
"view" => any_named(d.views.iter().map(|t| &t.name), name),
"ucs" => any_named(d.ucss.iter().map(|t| &t.name), name),
_ => true,
"vport" => any_named(d.vports.iter().filter(|v| !v.is_active()).map(|t| &t.name), name),
_ => Some(name.to_string()),
}
}
fn exists(d: &Drawing, table: &str, name: &str) -> bool {
stored(d, table, name).is_some()
}
#[derive(Default)]
enum Stage {
#[default]
@@ -199,6 +213,15 @@ impl Interactive for RenameM {
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
// No new name is an invalid one (AutoCAD 2024, measured for layers, blocks, views and
// viewport configurations).
if i == Input::Enter
&& let Stage::New(t, _) = &self.stage
&& let Some((_, Some(_), noun)) = TYPES.get(*t)
{
s.echo(format!("Invalid {} name.", title(noun)));
return Ok(Step::Done);
}
if matches!(i, Input::Cancel | Input::Enter) {
return Ok(if i == Input::Cancel { Step::Cancel } else { Step::Done });
}
@@ -217,12 +240,41 @@ impl Interactive for RenameM {
self.stage = Stage::Old(t);
return Ok(Step::Continue);
};
if let Some(table) = table
&& !exists(s.doc()?, table, &name)
{
self.stage = Stage::Old(t);
return Err(EngineError::Other(format!("No {noun} named \"{name}\".")));
// AutoCAD 2024 ends -RENAME on an old name it won't rename (measured): "Invalid … name."
// for a viewport configuration or block whose name starts with "*" (*Active,
// *Model_Space, an anonymous block's *U0) and for linetypes ByLayer and ByBlock;
// "Cannot rename …" and "*Invalid*" for layer 0 and linetype Continuous.
let invalid = match *table {
Some("vport" | "block") => name.starts_with('*'),
Some("linetype") => name.eq_ignore_ascii_case("bylayer") || name.eq_ignore_ascii_case("byblock"),
_ => false,
};
if invalid {
s.echo(format!("Invalid {} name.", title(noun)));
return Ok(Step::Done);
}
let fixed = match *table {
Some("layer") => name == "0",
Some("linetype") => name.eq_ignore_ascii_case("continuous"),
_ => false,
};
if fixed {
s.echo(format!("Cannot rename {} \"{name}\".", title(noun)));
s.echo("*Invalid*");
return Ok(Step::Done);
}
// The old name as the drawing spells it: a new name in another case than that is a
// rename, even when it is the old name as typed (AutoCAD 2024, measured).
let name = match table {
Some(table) => match stored(s.doc()?, table, &name) {
Some(n) => n,
None => {
s.echo(format!("Cannot find {} \"{name}\".", title(noun)));
return Ok(Step::Done);
}
},
None => name,
};
self.stage = Stage::New(t, name);
Ok(Step::Continue)
}
@@ -235,6 +287,19 @@ impl Interactive for RenameM {
s.echo(format!("Renaming a {noun} is not available yet."));
return Ok(Step::Done);
};
// AutoCAD 2024's messages, each ending the command (measured).
if !valid_name(&name) {
s.echo(format!("Invalid {} name.", title(noun)));
return Ok(Step::Done);
}
if !name.eq_ignore_ascii_case(&old) && exists(s.doc()?, table, &name) {
s.echo(format!("A {noun} named \"{name}\" already exists."));
s.echo("*Invalid*");
return Ok(Step::Done);
}
if name == old {
return Ok(Step::Done);
}
match super::run_rename(s, &json!({ "table": table, "from": old, "to": name })) {
Ok(_) => Ok(Step::Done),
Err(e) => {
+3 -4
View File
@@ -8,7 +8,6 @@ use cadcraft_doc::{Drawing, EntityKind, Handle};
use cadcraft_geom::{Bounds2, Line, Vec2, line_line};
use serde_json::{Value, json};
use super::curves::KW;
use super::helpers::{line, lwpoly, rect_vertices};
use super::modify::{Edges, extend, trim};
use super::{bad, point_param, points_param};
@@ -361,7 +360,7 @@ impl Interactive for TrimM {
Stage::Crossing(Some(_)) => Prompt::new("Specify opposite corner", Accept::POINT),
Stage::Mode => {
let msg = if self.extend { "Enter an extend mode option" } else { "Enter a trim mode option" };
Prompt::new(msg, KW).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
Prompt::new(msg, Accept::TEXT).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
}
Stage::Project => {
let cur = match proj_mode(s) {
@@ -369,9 +368,9 @@ impl Interactive for TrimM {
2 => "View",
_ => "Ucs",
};
Prompt::new("Enter a projection option", KW).kw(&["None", "Ucs", "View"]).default(cur)
Prompt::new("Enter a projection option", Accept::TEXT).kw(&["None", "Ucs", "View"]).default(cur)
}
Stage::Edge => Prompt::new("Enter an implied edge extension mode", KW).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
Stage::Edge => Prompt::new("Enter an implied edge extension mode", Accept::TEXT).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
"Extend"
} else {
"No extend"
+1 -1
View File
@@ -138,7 +138,7 @@ fn save(s: &mut Session, name: &str, window: Option<Bounds2>, snapshot: bool) ->
let layer_state = snapshot.then(|| {
let state = snapshot_name(name);
d.layer_states.retain(|l| !l.name.eq_ignore_ascii_case(&state));
d.layer_states.push(LayerState { name: state.clone(), layers: d.layers.clone() });
d.layer_states.push(LayerState::new(state.clone(), d.layers.clone(), ""));
state
});
if let Some(old) = &replaced {
+2 -1
View File
@@ -31,7 +31,7 @@ impl Accept {
/// [Truecolor/COlorbook] <BYLAYER>:". A prompt asking for something else besides its keywords has
/// it: "Enter block name or [?]:", "Specify insertion base point or [Basepoint/…]:". Read from
/// AutoCAD's command line over measured runs, where no prompt was written both ways.
const NO_OR: [&str; 28] = [
const NO_OR: &[&str] = &[
"Bring to front",
"Calculate rectangle dimensions based on",
"Choose mode for selected object conversion",
@@ -50,6 +50,7 @@ const NO_OR: [&str; 28] = [
"Enter option",
"Enter polyline linetype generation option",
"Enter property to change",
"Enter states to change",
"Enter the type of array",
"Enter type of unused objects to purge",
"Enter viewport arrangement",
+5
View File
@@ -27,6 +27,10 @@ pub struct Settings {
pub measureinit: bool,
/// -VIEW sEttings > Layer snapshot: named views save the layer settings with them.
pub view_layer_snapshot: bool,
/// -LAYER stAte Save: the properties a new layer state restores (its mask), as the last Save
/// left them. AutoCAD 2024 keeps these toggles in the registry from one Save to the next
/// (measured); Edit doesn't change them.
pub layer_state_mask: u32,
pub dynmode: bool,
/// DYNDIGRIP: which dimensions grip dimensional input shows while a grip is stretched (bits:
/// 1 resulting length, 2 length change, 4 absolute angle, 8 angle change, 16 radius); read
@@ -148,6 +152,7 @@ impl Default for Settings {
zoomfactor: 60,
measureinit: false,
view_layer_snapshot: true,
layer_state_mask: cadcraft_doc::LayerState::ALL,
dynmode: true,
dyndigrip: 31,
dyndivis: 1,
+202
View File
@@ -0,0 +1,202 @@
//! The Key point option of a base point: ARRAYRECT, ARRAYPOLAR and ARRAYEDIT (Base point and
//! REPlace) take the source objects' key point (an end point, midpoint, centre…) nearest the
//! picked point as the base point; the JSON forms take `keyPoint`.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{ArrayKind, ArrayParams, EntityKind, Handle};
use cadcraft_engine::geom::Vec2;
use serde_json::json;
fn source_line(s: &mut Session) -> String {
let r = s.execute("line", &json!({"points": [[0, 0], [2, 1]]})).unwrap();
r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap().to_string()
}
fn handle(v: &serde_json::Value) -> Handle {
Handle::parse_hex(v["handle"].as_str().unwrap()).unwrap()
}
/// The array's insertion point (its base point) and parameters.
fn array(s: &Session, h: Handle) -> (Vec2, ArrayParams) {
let d = s.doc().unwrap();
let e = d.entity(h).unwrap();
let EntityKind::Insert(i) = &e.kind else { panic!("not an array") };
(i.insert.xy(), d.array_params(e).unwrap())
}
fn only_array(s: &Session) -> Handle {
let d = s.doc().unwrap();
let arrays: Vec<Handle> = d.model.iter().filter(|e| d.array_params(e).is_some()).map(|e| e.handle).collect();
assert_eq!(arrays.len(), 1);
arrays[0]
}
fn typed(s: &mut Session, inputs: &[&str]) {
for t in inputs {
s.cmdline(t).unwrap();
}
}
#[test]
fn arrayrect_and_arraypolar_take_a_key_point_as_the_base_point() {
let mut s = Session::new();
let l = source_line(&mut s);
let r = s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "colSpacing": 5, "keyPoint": [1.9, 1.05]})).unwrap();
assert!(array(&s, handle(&r)).0.near(Vec2::new(2.0, 1.0), 1e-9));
let mut s = Session::new();
let l = source_line(&mut s);
let r = s.execute("arraypolar", &json!({"handles": [l], "center": [-10, 0], "count": 4, "keyPoint": [1.1, 0.4]})).unwrap();
assert!(array(&s, handle(&r)).0.near(Vec2::new(1.0, 0.5), 1e-9), "the line's midpoint");
}
#[test]
fn typed_key_points_at_arrayrect_and_arraypolar() {
let mut s = Session::new();
source_line(&mut s);
typed(&mut s, &["arrayrect", "l", "", "b", "k", "1.9,0.95", "x"]);
assert!(array(&s, only_array(&s)).0.near(Vec2::new(2.0, 1.0), 1e-9));
// Enter at the key point prompt goes back to the base point prompt.
let mut s = Session::new();
source_line(&mut s);
typed(&mut s, &["arraypolar", "l", "", "b", "k"]);
assert!(s.current_prompt().unwrap().message.contains("key point"));
typed(&mut s, &[""]);
assert!(s.current_prompt().unwrap().message.contains("base point"));
typed(&mut s, &["k", "0.1,0.1", "-10,0", "x"]);
assert!(array(&s, only_array(&s)).0.near(Vec2::new(0.0, 0.0), 1e-9));
}
#[test]
fn arrayedit_moves_the_base_point_to_a_key_point_of_an_item() {
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 3, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
// Near the start of the third item: the base point goes to (10, 0), the items stay.
s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": [10.2, 0.05]})).unwrap();
let (at, p) = array(&s, h);
assert!(at.near(Vec2::new(10.0, 0.0), 1e-9), "{at:?}");
assert!(matches!(p.kind, ArrayKind::Rect(r) if r.cols == 3 && r.col_spacing == 5.0));
let items = s.execute("explode", &json!({"handles": [h.hex()]})).unwrap();
assert!(items.to_string().len() > 2);
let d = s.doc().unwrap();
let mut starts: Vec<(i64, i64)> = d
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Line(l) => Some(((l.a.x * 10.0).round() as i64, (l.a.y * 10.0).round() as i64)),
_ => None,
})
.collect();
starts.sort();
assert_eq!(starts, [(0, 0), (50, 0), (100, 0)]);
// Not on an item: refused.
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 3, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
assert!(s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": [3.5, 40]})).is_err());
assert!(array(&s, h).0.near(Vec2::ZERO, 1e-9));
// Typed: Base point, Key point, a point on the second item near its end.
s.set_selection(vec![h]);
typed(&mut s, &["arrayedit", "b", "k", "6.9,0.9", "x"]);
assert!(array(&s, h).0.near(Vec2::new(7.0, 1.0), 1e-9));
}
#[test]
fn replacement_objects_take_a_key_point_as_their_base_point() {
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 3, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
let c = s.execute("circle", &json!({"center": [50, 50], "radius": 1})).unwrap()["handle"].clone();
// The circle's right quadrant is the base point: on item 1 (at x = 5) its centre is at x = 4.
s.execute("arrayedit", &json!({"handle": h.hex(), "replace": {"handles": [c], "keyPoint": [51.2, 50.1], "items": [[1, 0, 0]]}})).unwrap();
s.execute("explode", &json!({"handles": [h.hex()]})).unwrap();
let d = s.doc().unwrap();
// The replaced item stays a reference to the replacement block.
let centres: Vec<Vec2> = d
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Insert(i) => d.block(&i.block).map(|b| (i.transform(b.base.xy()), b)),
_ => None,
})
.flat_map(|(m, b)| {
b.entities
.iter()
.filter_map(move |e| match &e.kind {
EntityKind::Circle(c) => Some(m.apply(c.center.xy())),
_ => None,
})
.collect::<Vec<_>>()
})
.collect();
assert!(centres.iter().any(|c| c.near(Vec2::new(4.0, 0.0), 1e-9)), "{centres:?}");
}
#[test]
fn hostile_key_points_never_panic() {
let mut s = Session::new();
let l = source_line(&mut s);
for kp in [json!(["a", 1]), json!([1e308, -1e308]), json!([]), json!("x"), json!(null)] {
let _ = s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "keyPoint": kp}));
let _ = s.execute("arraypolar", &json!({"handles": [l], "center": [5, 5], "count": 3, "keyPoint": kp}));
}
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
for kp in [json!([1e308, 1e308]), json!([-1e308, 0]), json!(["x"]), json!([0.5, 0.25])] {
let _ = s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": kp}));
let _ = s.execute("arrayedit", &json!({"handle": h.hex(), "replace": {"handles": [], "keyPoint": kp, "items": [[0, 0, 0]]}}));
}
// Typed key points far away or on nothing are refused without leaving the command broken.
s.set_selection(vec![h]);
typed(&mut s, &["arrayedit", "b", "k"]);
assert!(s.cmdline("1e300,1e300").is_err() || s.running.is_some());
s.cancel();
}
/// A `keyPoint` that is there but isn't a point is refused, not taken as no key point (which
/// would make the array at another base point).
#[test]
fn a_key_point_that_is_not_a_point_is_refused() {
let mut s = Session::new();
let l = source_line(&mut s);
assert!(s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "keyPoint": ["bad", 1]})).is_err());
assert!(s.execute("arraypolar", &json!({"handles": [l], "center": [-10, 0], "count": 3, "keyPoint": "x"})).is_err());
assert!(s.doc().unwrap().model.iter().all(|e| s.doc().unwrap().array_params(e).is_none()), "no array made");
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
assert!(s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": [1]})).is_err());
let c = s.execute("circle", &json!({"center": [50, 50], "radius": 1})).unwrap()["handle"].clone();
assert!(s.execute("arrayedit", &json!({"handle": h.hex(), "replace": {"handles": [c], "keyPoint": {}, "items": [[1, 0, 0]]}})).is_err());
}
/// More objects than the key point search takes are refused rather than searched in part, which
/// could miss the nearest key point.
#[test]
fn a_key_point_of_too_many_objects_is_refused() {
let mut s = Session::new();
// 10,001 lines; the last one ends nearest the key point.
let pts: Vec<[f64; 2]> = (0..10_002).map(|i| [f64::from(i), 0.0]).collect();
let r = s.execute("line", &json!({ "points": pts })).unwrap();
let hs: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
assert_eq!(hs.len(), 10_001, "{r}");
let e = s.execute("arraypolar", &json!({"handles": hs, "center": [0, -50], "count": 2, "keyPoint": [10_001.2, 0]})).unwrap_err();
assert!(e.to_string().contains("10000"), "{e}");
}
/// ARRAYEDIT with a new base point (`base` or `keyPoint`) and a polar `center` in one call puts the
/// centre where asked: the base point moves the array's insertion point, so the centre is read in
/// the array's placement after that move.
#[test]
fn arrayedit_center_with_a_new_base_point_lands_where_asked() {
for (key, at) in [("base", json!([2, 1])), ("keyPoint", json!([1.95, 0.99]))] {
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arraypolar", &json!({"handles": [l], "center": [-10, 0], "count": 4, "base": [0, 0]})).unwrap());
s.execute("arrayedit", &json!({"handle": h.hex(), key: at, "center": [5, 0]})).unwrap();
let (ins, p) = array(&s, h);
let ArrayKind::Polar(k) = p.kind else { panic!("not polar") };
assert!(ins.near(Vec2::new(2.0, 1.0), 1e-9), "{key}: {ins:?}");
// The centre is kept relative to the insertion point.
assert!((ins + k.center).near(Vec2::new(5.0, 0.0), 1e-9), "{key}: centre at {:?}", ins + k.center);
}
}
+43 -4
View File
@@ -83,14 +83,22 @@ fn dash_attedit_one_at_a_time_edits_the_selected_attributes() {
let mut s = with_block();
let h = handle(&insert(&mut s, 100.0, json!({"T": "abc"})));
type_lines(&mut s, &["-attedit", "y", "", "T", "", "105,0", ""]);
assert!(s.prompt_text().contains("[Value/Layer/Color/Next] <N>"), "{}", s.prompt_text());
// Unsupported options say so and keep the prompt.
s.cmdline("p").unwrap();
assert!(s.log.iter().any(|l| l.contains("Position is not available yet")), "{:?}", s.log);
assert!(s.prompt_text().contains("[Value/Position/Height/Angle/Style/Layer/Color/Next] <N>"), "{}", s.prompt_text());
// Edit Position, Height, Angle, and Style
type_lines(&mut s, &["p", "10,20", "h", "2.5", "a", "45", "s", "Standard"]);
// Edit Value: change and replace
type_lines(&mut s, &["v", "c", "b", "B", "v", "r", "replaced value", "n"]);
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(value(&s, h, "T"), "replaced value");
assert_eq!(value(&s, h, "U"), "u");
let EntityKind::Insert(ins) = &s.doc().unwrap().entity(h).unwrap().kind else { panic!("not an insert") };
let att = ins.attribs.iter().find(|a| a.tag == "T").unwrap();
assert!((att.text.insert.x - 10.0).abs() < 1e-6);
assert!((att.text.insert.y - 20.0).abs() < 1e-6);
assert!((att.text.height - 2.5).abs() < 1e-6);
assert!((att.text.rotation.to_degrees() - 45.0).abs() < 1e-4);
assert_eq!(att.text.style, "Standard");
}
#[test]
@@ -109,3 +117,34 @@ fn attribute_tags_match_in_any_case_and_unknown_tags_are_reported() {
let r = s.execute("attedit", &json!({"handle": h.hex(), "values": {"T": "four"}})).unwrap();
assert_eq!(r, json!({"changed": 1}));
}
/// -ATTEDIT Position moves an aligned or fit attribute without losing its baseline: both of its
/// points move by the same offset (setting both to the picked point would leave no direction or
/// length to fit the text between).
#[test]
fn dash_attedit_position_keeps_an_aligned_attributes_baseline() {
use cadcraft_doc::HAlign;
use cadcraft_geom::Vec3;
for halign in [HAlign::Aligned, HAlign::Fit] {
let mut s = with_block();
let h = handle(&insert(&mut s, 100.0, json!({"T": "abc"})));
s.doc_mut()
.unwrap()
.modify_entity(h, |e| {
if let EntityKind::Insert(i) = &mut e.kind {
for a in i.attribs.iter_mut().filter(|a| a.tag == "T") {
a.text.halign = halign;
a.text.insert = Vec3::new(100.0, 1.0, 0.0);
a.text.align_pt = Some(Vec3::new(104.0, 1.0, 0.0));
}
}
})
.unwrap();
type_lines(&mut s, &["-attedit", "y", "", "T", "", "105,0", "", "p", "10,20", "n"]);
assert!(s.running.is_none(), "{}", s.prompt_text());
let EntityKind::Insert(ins) = &s.doc().unwrap().entity(h).unwrap().kind else { panic!("not an insert") };
let t = &ins.attribs.iter().find(|a| a.tag == "T").unwrap().text;
assert!(t.insert.xy().near(cadcraft_geom::Vec2::new(10.0, 20.0), 1e-9), "{halign:?}: {:?}", t.insert);
assert!(t.align_pt.is_some_and(|p| p.xy().near(cadcraft_geom::Vec2::new(14.0, 20.0), 1e-9)), "{halign:?}: {:?}", t.align_pt);
}
}
+1 -1
View File
@@ -38,7 +38,7 @@ fn dash_attedit_sets_layer_and_colour_of_one_attribute() {
for t in ["-attedit", "y", "", "T", "", "105,0", ""] {
s.cmdline(t).unwrap();
}
assert!(s.prompt_text().contains("[Value/Layer/Color/Next] <N>"), "{}", s.prompt_text());
assert!(s.prompt_text().contains("[Value/Position/Height/Angle/Style/Layer/Color/Next] <N>"), "{}", s.prompt_text());
s.cmdline("l").unwrap();
assert!(s.prompt_text().contains("Enter new layer name <0>"), "{}", s.prompt_text());
// An unknown layer is refused and asked again.
@@ -0,0 +1,247 @@
//! -LAYER stAte: AutoCAD 2024's layer state prompts and messages (measured with accoreconsole on a
//! drawing with layers A, red, and B), and the `layerstate.*` commands they run.
use cadcraft_engine::doc::LayerState;
use cadcraft_engine::{Input, Session};
use serde_json::json;
const LABELS: [&str; 10] = ["On", "Frozen", "Lock", "Plot", "Newvpfreeze", "Color", "lineType", "lineWeight", "Transparency", "plotStyle"];
/// The toggles AutoCAD lists before "Enter states to change", with `no` the ones set to No.
fn table(no: &[&str]) -> Vec<String> {
let mut v = vec!["States".to_string()];
v.extend(LABELS.iter().map(|l| format!("{l:<20}{}", if no.contains(l) { "No" } else { "Yes" })));
v
}
/// Layers A (red) and B; the current layer stays 0.
fn drawing() -> Session {
let mut s = Session::new();
s.script("-LAYER N A,B C 1 A\n\n").unwrap();
s
}
/// Run `script` to its end and return what it wrote besides the commands' names and -LAYER's
/// "Current layer" line.
fn run(s: &mut Session, script: &str) -> Vec<String> {
let at = s.log.len();
s.script(script).unwrap();
assert!(s.running.is_none(), "{script:?} ends at: {}", s.prompt_text());
s.log[at..].iter().filter(|l| !l.starts_with("Command: ") && !l.starts_with("Current layer:")).cloned().collect()
}
fn states(s: &Session) -> Vec<(String, u32)> {
s.doc().unwrap().layer_states.iter().map(|st| (st.name.clone(), st.mask)).collect()
}
fn state(name: &str, mask: u32) -> (String, u32) {
(name.to_string(), mask)
}
#[test]
fn save_asks_the_states_and_remembers_them_for_the_next_save() {
let mut s = drawing();
// Each toggle lists the states again; On off is AutoCAD's 2046.
let out = run(&mut s, "-LAYER A S S6 ON\n\n\n\nLINE 0,0 1,0\n\n");
assert_eq!(out, [table(&[]), table(&["On"])].concat());
assert_eq!(states(&s), [state("S6", 2046)]);
assert_eq!(s.doc().unwrap().model.len(), 1, "the next command runs");
// The next Save starts from the toggles the last one left: On alone is 513, then every
// toggle once more is 2046 (AutoCAD's S7 and S8).
let out = run(&mut s, "-LAYER A S S7 ON F L P N C T W TR S\n\n\n\n");
assert_eq!(out[..11], table(&["On"]));
assert_eq!(
out[out.len() - 11..],
table(&["Frozen", "Lock", "Plot", "Newvpfreeze", "Color", "lineType", "lineWeight", "Transparency", "plotStyle"])
);
run(&mut s, "-LAYER A S S8 ON F L P N C T W TR S\n\n\n\n");
run(&mut s, "-LAYER A S S9 ON\n\n\n\n");
assert_eq!(states(&s)[1..], [state("S7", 513), state("S8", 2046), state("S9", LayerState::ALL)]);
// Edit lists and changes the state's own mask (found in any case), not the next Save's
// toggles (AutoCAD: Edit S1 to 2015, then S2 is 2047).
let out = run(&mut s, "-LAYER A E s6 ON C\n\n\n\n");
assert_eq!(out, [table(&["On"]), table(&[]), table(&["Color"])].concat());
run(&mut s, "-LAYER A S S10\n\n\n\n");
assert_eq!(states(&s)[0], state("S6", 2015));
assert_eq!(states(&s)[4], state("S10", LayerState::ALL));
// Each -LAYER is one undo step.
s.undo().unwrap();
assert_eq!(states(&s).len(), 4);
s.undo().unwrap();
assert_eq!(states(&s)[0], state("S6", 2046));
// A state from AutoCAD after a restore (mask 67583 = 2047 + 65536) named as AutoCAD names a
// state renamed to "*X": `?` lists it, and Edit keeps the bit no toggle reaches.
s.doc_mut().unwrap().layer_states.push(LayerState { name: "*A1".into(), mask: 67583, ..LayerState::default() });
assert_eq!(
run(
&mut s,
"-LAYER A ?
"
)[2],
"*A1"
);
run(
&mut s,
"-LAYER A E *a1 C
",
);
assert_eq!(states(&s)[4], state("*A1", 67583 - 32));
}
#[test]
fn names_follow_autocads_rules_and_messages() {
let mut s = drawing();
run(&mut s, "-LAYER A S S1\n\n\n\n");
// A saved name in another case is refused and asked again.
let out = run(&mut s, "-LAYER A S s1 S2\n\n\n\n");
assert_eq!(out, [vec!["Layer state \"s1\" already exists.".to_string()], table(&[])].concat());
// The layer name characters, and more than 255 characters, are refused; Enter goes back.
let long = "y".repeat(256);
let out = run(&mut s, &format!("-LAYER A S *X a<b a,b {long}\n\n\n\n"));
assert_eq!(
out,
[
"\"*X\" is an invalid layer state name.",
"\"a<b\" is an invalid layer state name.",
"\"a,b\" is an invalid layer state name.",
&format!("\"{long}\" is an invalid layer state name.")
]
);
run(&mut s, &format!("-LAYER A S {}\n\n\n\n", "x".repeat(255)));
assert_eq!(states(&s).len(), 3);
run(&mut s, &format!("-LAYER A D {}\n\n\n", "x".repeat(255)));
// `?` lists by name without regard to case.
run(&mut s, "-LAYER A S b\n\n\n\n");
let list = ["Layer state", "-----------------------------", "b", "S1", "S2"];
assert_eq!(run(&mut s, "-LAYER A ?\n\n\n"), list);
// Each name prompt lists on `?`, says an unknown name and asks again, and Enter goes back.
let out = run(&mut s, "-LAYER A R ? NOSUCH\n\nE NOSUCH\n\nN NOSUCH\n\nD NOSUCH\n\n\n\n");
assert_eq!(out[..5], list);
assert_eq!(out[5..], ["Unknown layer state name."; 4]);
// Unknown options, Import and EXport.
let out = run(&mut s, "-LAYER A XYZ I EX\n\n\n");
assert_eq!(out, ["Invalid option keyword.", "-LAYER stAte Import is not available yet.", "-LAYER stAte EXport is not available yet."]);
let out = run(&mut s, "-LAYER A S T1 XYZ\n\n\n\n");
assert_eq!(out, [table(&[]), vec!["Invalid option keyword.".to_string()]].concat());
assert_eq!(states(&s).len(), 4, "T1 is saved after the invalid toggle");
run(&mut s, "-LAYER A D T1\n\n\n");
// Name: a name some state has in any case, the state's own too, is refused with two lines.
assert_eq!(run(&mut s, "-LAYER A N S1 S2\n\n\n"), ["Layer state could not be renamed.", "S2 already exists."]);
assert_eq!(run(&mut s, "-LAYER A N S1 s1\n\n\n"), ["Layer state could not be renamed.", "s1 already exists."]);
// A name with a refused character leaves the state as it is, with no message; Enter too.
assert!(run(&mut s, "-LAYER A N S1 a,b\n\n\n").is_empty());
assert!(run(&mut s, "-LAYER A N S1\n\n\n\n").is_empty());
assert_eq!(states(&s).iter().map(|st| st.0.as_str()).collect::<Vec<_>>(), ["S1", "S2", "b"]);
// The old name in another case.
assert!(run(&mut s, "-LAYER A N s1 S9\n\n\n").is_empty());
assert_eq!(states(&s).iter().map(|st| st.0.as_str()).collect::<Vec<_>>(), ["S9", "S2", "b"]);
assert!(run(&mut s, "-LAYER A D s9\n\n\n").is_empty());
assert_eq!(states(&s).iter().map(|st| st.0.as_str()).collect::<Vec<_>>(), ["S2", "b"]);
}
#[test]
fn esc_drops_the_state_being_saved_and_undo_takes_back_name_and_delete() {
let mut s = drawing();
run(
&mut s,
"-LAYER A S S1
",
);
// Esc at the toggles: that state isn't saved and the next Save's toggles stay as they were;
// what the same -LAYER did before Esc stays, as for the other -LAYER options.
s.script(
"-LAYER A S S2
S S3 C ON
",
)
.unwrap();
// AutoCAD 2024 asks for the toggles without "or" before them.
assert_eq!(
s.current_prompt().unwrap().display(),
"Enter states to change [On/Frozen/Lock/Plot/Newvpfreeze/Color/lineType/lineWeight/TRansparency/plotStyle]:"
);
s.input(Input::Cancel).unwrap();
assert!(s.running.is_none());
assert_eq!(states(&s), [state("S1", LayerState::ALL), state("S2", LayerState::ALL)]);
assert_eq!(s.settings.layer_state_mask, LayerState::ALL);
// Name and Delete are one undo step each, like Save.
run(
&mut s,
"-LAYER A N S1 S9
",
);
run(
&mut s,
"-LAYER A D S2
",
);
assert_eq!(states(&s), [state("S9", LayerState::ALL)]);
s.undo().unwrap();
assert_eq!(states(&s), [state("S9", LayerState::ALL), state("S2", LayerState::ALL)]);
s.undo().unwrap();
assert_eq!(states(&s), [state("S1", LayerState::ALL), state("S2", LayerState::ALL)]);
}
#[test]
fn restore_finds_the_state_in_any_case() {
let mut s = drawing();
run(&mut s, "-LAYER A S S1\n\n\n\n");
run(&mut s, "-LAYER C 3 A M C\n\n");
let d = s.doc().unwrap();
assert_eq!((d.layer("A").unwrap().color, d.header.str("CLAYER", "0")), (cadcraft_color::Color::Index(3), "C".to_string()));
assert!(run(&mut s, "-LAYER A R s1\n\n\n").is_empty());
let d = s.doc().unwrap();
assert_eq!((d.layer("A").unwrap().color, d.header.str("CLAYER", "0")), (cadcraft_color::Color::Index(1), "0".to_string()));
}
#[test]
fn json_layer_states_take_a_mask_and_find_names_in_any_case() {
let mut s = drawing();
s.execute("layerstate.save", &json!({ "name": "M" })).unwrap();
s.execute("layerstate.save", &json!({ "name": "On", "mask": LayerState::ON })).unwrap();
for bad in [json!(4096), json!(-1), json!(1.5), json!("1")] {
assert!(s.execute("layerstate.save", &json!({ "name": "X", "mask": bad })).is_err(), "{bad}");
}
assert_eq!(states(&s), [state("M", LayerState::ALL), state("On", 513)]);
// Restore, Rename and Delete find a name in another case; a name another state has in any
// case is refused, the state's own in another case too.
s.execute("layer.set", &json!({ "name": "A", "color": "3" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "m" })).unwrap();
assert_eq!(s.doc().unwrap().layer("A").unwrap().color, cadcraft_color::Color::Index(1));
assert!(s.execute("layerstate.rename", &json!({ "from": "m", "to": "ON" })).is_err());
assert!(s.execute("layerstate.rename", &json!({ "from": "m", "to": "m" })).is_err());
s.execute("layerstate.rename", &json!({ "from": "m", "to": "M2" })).unwrap();
s.execute("layerstate.delete", &json!({ "name": "on" })).unwrap();
assert_eq!(states(&s), [state("M2", LayerState::ALL)]);
// A name -LAYER stAte Save refuses is refused here too, and nothing is saved.
let long = "x".repeat(256);
for name in ["", " ", "a<b", "a\nb", long.as_str()] {
assert!(s.execute("layerstate.save", &json!({ "name": name })).is_err(), "{name:?}");
}
assert_eq!(states(&s), [state("M2", LayerState::ALL)]);
// Save onto a name another state has in another case replaces that state, as one spelled the
// same: AutoCAD 2024 keeps one state per name in any case.
s.execute("layerstate.save", &json!({ "name": "m2", "mask": LayerState::ON })).unwrap();
assert_eq!(states(&s), [state("m2", 513)]);
// Names that differ only in case (CADCraft's own record keeps the second of them, which AutoCAD
// 2024 doesn't see): Save and Delete take the one spelled so, though the other comes first, and
// leave the other.
s.doc_mut().unwrap().layer_states.insert(0, LayerState::new("M2", Vec::new(), ""));
s.execute("layerstate.save", &json!({ "name": "m2", "mask": LayerState::ON | LayerState::FROZEN })).unwrap();
assert_eq!(states(&s), [state("M2", LayerState::ALL), state("m2", 515)]);
s.execute("layerstate.delete", &json!({ "name": "m2" })).unwrap();
assert_eq!(states(&s), [state("M2", LayerState::ALL)]);
}
+2
View File
@@ -4,6 +4,7 @@ mod annotate_options;
mod annotative;
mod arc_ctrl_direction;
mod array_commands;
mod array_key_point;
mod assoc_array;
mod attdef_command;
mod attdisp_attsync;
@@ -78,6 +79,7 @@ mod join_close;
mod json_param_validation;
mod layer_cmdline;
mod layer_merge_delete;
mod layer_state_cmdline;
mod layoff_repeat;
mod layout_prompts;
mod leader_command;
+128 -6
View File
@@ -76,13 +76,135 @@ fn rename_prompts_type_old_and_new_name() {
assert!(d.block("Pump").is_some() && d.layer("New").is_some() && d.layer("Old").is_none(), "{:?}", s.log);
assert_eq!(insert_targets(d), ["Assy", "Pump", "Pump", "Pump"]);
assert_eq!(d.model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count(), 1);
// An unknown old name re-prompts; a type CADCraft lacks reads both names and reports.
s.script("-RENAME LA Missing\nNew\nNewer\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.doc().unwrap().layer("Newer").is_some());
// A type CADCraft lacks reads both names and reports.
let n = s.log.len();
s.script("-RENAME VP a b\nLINE 0,0 2,0\n\n").unwrap();
s.script("-RENAME M a b\nLINE 0,0 2,0\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.log[n..].iter().any(|l| l.contains("not available yet")), "{:?}", &s.log[n..]);
assert!(s.log[n..].iter().any(|l| l.contains("Renaming a material is not available yet.")), "{:?}", &s.log[n..]);
assert_eq!(s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count(), 2);
}
/// What `script` adds to the log; the command has ended.
fn said(s: &mut Session, script: &str) -> Vec<String> {
let n = s.log.len();
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
s.log[n..].to_vec()
}
fn says(log: &[String], text: &str) -> bool {
log.iter().any(|l| l.contains(text))
}
#[test]
fn rename_ends_on_a_name_it_cannot_take_with_autocads_messages() {
// AutoCAD 2024 (accoreconsole, measured, the same for blocks, dimension styles, layers,
// linetypes, text styles, UCSs and views): `Cannot find layer "X".` for an old name that
// doesn't exist, `A layer named "X" already exists.` and `*Invalid*` for a new name that does,
// `Invalid layer name.` for one it can't take; each ends the command.
let mut s = drawing();
for name in ["A1", "A2"] {
s.execute("layer.new", &json!({ "name": name })).unwrap();
}
let log = said(&mut s, "-RENAME LA NOSUCH\nLINE 0,0 3,0\n\n");
assert!(says(&log, "Cannot find layer \"NOSUCH\"."), "{log:?}");
// The command ended there: the next input started LINE.
assert_eq!(s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count(), 1);
let log = said(&mut s, "-RENAME LA A1 A2\n");
assert!(says(&log, "A layer named \"A2\" already exists.") && says(&log, "*Invalid*"), "{log:?}");
let log = said(&mut s, "-RENAME LA A1 X<Y\n");
assert!(says(&log, "Invalid layer name."), "{log:?}");
// No new name at all is an invalid one too.
s.cmdline("-RENAME LA A1").unwrap();
let n = s.log.len();
s.cmdline("").unwrap();
assert!(s.running.is_none() && says(&s.log[n..], "Invalid layer name."), "{:?}", &s.log[n..]);
assert!(s.doc().unwrap().layer("A1").is_some());
said(&mut s, "-RENAME LA A1 B1\n");
assert!(s.doc().unwrap().layer("B1").is_some() && s.doc().unwrap().layer("A1").is_none());
// The old name in another case than stored, and the new name as typed: a rename to that case
// (AutoCAD 2024, measured: LAY1 typed lay1, new name lay1, gives lay1).
said(&mut s, "-RENAME LA b1 b1\n");
assert!(s.doc().unwrap().layers.iter().any(|l| l.name == "b1"));
// Old names AutoCAD 2024 won't rename (measured), each ending the command before the new name.
let lines = |s: &Session| s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count();
for (script, message) in [
("-RENAME LA 0\n", "Cannot rename layer \"0\"."),
("-RENAME LT continuous\n", "Cannot rename linetype \"continuous\"."),
("-RENAME LT ByLayer\n", "Invalid linetype name."),
("-RENAME LT byblock\n", "Invalid linetype name."),
("-RENAME LT CONTINUOUS\n", "Cannot rename linetype \"CONTINUOUS\"."),
("-RENAME B *Model_Space\n", "Invalid block name."),
("-RENAME B *U1\n", "Invalid block name."),
] {
let n = lines(&s);
let log = said(&mut s, &format!("{script}LINE 0,0 4,0\n\n"));
assert!(says(&log, message), "{script}: {log:?}");
assert_eq!(says(&log, "*Invalid*"), message.starts_with("Cannot"), "{script}: {log:?}");
assert_eq!(lines(&s), n + 1, "{script}: the next input starts a command");
}
// A UCS is "ucs" in the prompts and in "A ucs named", "UCS" in the other two.
for name in ["U1", "U2"] {
let ucs = cadcraft_engine::doc::Ucs { name: name.into(), origin: Default::default(), x_axis: Default::default(), y_axis: Default::default() };
s.doc_mut().unwrap().ucss.push(ucs);
}
s.cmdline("-RENAME U").unwrap();
assert!(s.prompt_text().contains("Enter old ucs name"), "{}", s.prompt_text());
s.cancel();
assert!(says(&said(&mut s, "-RENAME U NOSUCH\n"), "Cannot find UCS \"NOSUCH\"."));
assert!(says(&said(&mut s, "-RENAME U U1 U2\n"), "A ucs named \"U2\" already exists."));
assert!(says(&said(&mut s, "-RENAME U U1 X<Y\n"), "Invalid UCS name."));
}
#[test]
fn rename_takes_a_saved_viewport_configuration() {
// AutoCAD 2024 (measured): -RENAME VPort renames a saved configuration, every tile of it, old
// name in any case, and to another case of its own name; "*ACTIVE" (old or new), names with
// characters AutoCAD refuses and names already used are refused as for the other types.
let mut s = Session::new();
s.execute("-vports", &json!({ "option": "2", "arrangement": "vertical" })).unwrap();
s.execute("-vports", &json!({ "option": "save", "name": "CFG1" })).unwrap();
s.execute("-vports", &json!({ "option": "save", "name": "CFG3" })).unwrap();
let names = |s: &Session| -> Vec<(String, usize)> { s.doc().unwrap().vports.iter().map(|v| (v.name.clone(), v.tiles.len())).collect() };
said(&mut s, "-RENAME VP cfg1 CFG2\n");
assert_eq!(names(&s), [("*Active".to_string(), 2), ("CFG2".to_string(), 2), ("CFG3".to_string(), 2)]);
for (script, message) in [
// A refused old name ends the command before the new name is asked.
("-RENAME VP NOSUCH\n", "Cannot find viewport configuration \"NOSUCH\"."),
("-RENAME VP *ACTIVE\n", "Invalid viewport configuration name."),
("-RENAME VP CFG2 *ACTIVE\n", "Invalid viewport configuration name."),
("-RENAME VP CFG2 A<B\n", "Invalid viewport configuration name."),
("-RENAME VP CFG2 CFG3\n", "A viewport configuration named \"CFG3\" already exists."),
] {
let log = said(&mut s, script);
assert!(says(&log, message), "{script}: {log:?}");
// "*Invalid*" follows a name already used only.
assert_eq!(says(&log, "*Invalid*"), message.ends_with("already exists."), "{script}: {log:?}");
}
// No new name at all is an invalid one too (measured: CFG1, then Enter).
s.cmdline("-RENAME VP CFG2").unwrap();
let n = s.log.len();
s.cmdline("").unwrap();
assert!(s.running.is_none() && says(&s.log[n..], "Invalid viewport configuration name."), "{:?}", &s.log[n..]);
assert_eq!(names(&s), [("*Active".to_string(), 2), ("CFG2".to_string(), 2), ("CFG3".to_string(), 2)]);
said(&mut s, "-RENAME VP CFG2 cfg2\n");
assert_eq!(names(&s), [("*Active".to_string(), 2), ("cfg2".to_string(), 2), ("CFG3".to_string(), 2)]);
// The new name is compared with the stored one, not with the old name as typed (measured:
// CFG1 typed cfg1 to cfg1 gives cfg1; typed cfg1 to CFG1 changes nothing).
said(&mut s, "-RENAME VP CFG2 CFG2\n");
assert_eq!(names(&s)[1].0, "CFG2");
said(&mut s, "-RENAME VP cfg2 CFG2\n");
assert_eq!(names(&s)[1].0, "CFG2");
said(&mut s, "-RENAME VP cfg2 cfg2\n");
assert_eq!(names(&s)[1].0, "cfg2");
// The JSON form too, which never takes the configuration shown, and refuses a name already
// used (in any case) or with a character AutoCAD refuses, as for the other tables.
s.execute("rename", &json!({ "table": "vport", "from": "CFG3", "to": "Pair" })).unwrap();
assert_eq!(names(&s)[2].0, "Pair");
for to in ["Shown", "CFG2", "A<B"] {
let from = if to == "Shown" { "*Active" } else { "Pair" };
assert!(s.execute("rename", &json!({ "table": "vport", "from": from, "to": to })).is_err(), "{from} to {to}");
}
s.execute("rename", &json!({ "table": "vport", "from": "pair", "to": "PAIR" })).unwrap();
assert_eq!(names(&s), [("*Active".to_string(), 2), ("cfg2".to_string(), 2), ("PAIR".to_string(), 2)]);
}
+294
View File
@@ -0,0 +1,294 @@
//! Saved layer states as AutoCAD keeps them: the LAYER table's extension dictionary holds an
//! `ACAD_LAYERSTATES` dictionary of one XRECORD per state. Measured in AutoCAD 2024 (DXFOUT of
//! states saved with -LAYER stAte), an XRECORD holds `280 1`, the mask (91), a text (301: empty
//! as -LAYER saves it; AutoCAD keeps one a file holds through restore and DXFOUT), `290 0` and
//! the current layer's name (302), then for each layer its LAYER handle (330),
//! flags (90: 1 off, 2 frozen, 4 locked, 8 plotted, 16 frozen in new viewports), colour index
//! (62), lineweight (370), for a layer of an xref 93 (0 for a newly attached one; a file can hold
//! 1, whose meaning isn't measured), LTYPE handle (331), plot style (in a drawing of colour-dependent
//! plot styles the name `Color_N` in group 1, N its colour index; of named ones the handle of its
//! placeholder object in group 390), transparency (440: 0 opaque, else `0x02000000 | alpha`) and,
//! for a true colour, 92 (`0xC2RRGGBB`).
//!
//! States AutoCAD's dictionary can't hold stay in CADCraft's own record (`CADCRAFT_LAYERSTATES`):
//! the view layer snapshots (`*VIEW name`), and a name that repeats an earlier one in another
//! case: AutoCAD 2024 opens the entries `S` and `s` of one dictionary as one state, named as the
//! first entry and holding the last one's record (measured), and so does the reader here.
use std::collections::{HashMap, HashSet};
use cadcraft_color::{Color, Rgb};
use cadcraft_doc::{Layer, LayerState, Lineweight};
use craft_dxf::Tag;
use crate::dxf_ext::{transparency_from_dxf, transparency_to_dxf};
/// The key of the states dictionary in the LAYER table's extension dictionary.
pub(crate) const KEY: &str = "ACAD_LAYERSTATES";
/// The prefix of a true colour in group 92.
const TRUE_COLOR: u32 = 0xC200_0000;
/// The bytes of layers the states of one file may copy (CWE-400). Each entry of a state is a copy
/// of the drawing's layer, its names and description included, so without a bound a small file
/// naming one layer with a long description in a great many entries would take gigabytes.
pub(crate) const MAX_COPIED_BYTES: usize = 256 << 20;
/// Which of `states` go into AutoCAD's dictionary (the others into CADCraft's record).
pub(crate) fn in_acad(states: &[LayerState]) -> Vec<bool> {
let mut seen: HashSet<String> = HashSet::with_capacity(states.len());
states.iter().map(|st| !st.name.trim().is_empty() && !st.name.starts_with('*') && seen.insert(st.name.to_lowercase())).collect()
}
/// The states CADCraft's own record keeps (those [`in_acad`] leaves out).
pub(crate) fn own(states: &[LayerState]) -> Vec<LayerState> {
states.iter().zip(in_acad(states)).filter(|(_, acad)| !acad).map(|(st, _)| st.clone()).collect()
}
/// Handles of the objects that hold the drawing's states in AutoCAD's form.
#[derive(Default)]
pub(crate) struct Plan {
/// The LAYER table, which owns the extension dictionary.
pub table: String,
/// The LAYER table's extension dictionary.
pub xdict: String,
/// The `ACAD_LAYERSTATES` dictionary.
dict: String,
/// (index in the drawing's states, XRECORD handle).
records: Vec<(usize, String)>,
}
impl Plan {
pub fn new(states: &[LayerState], mut handle: impl FnMut() -> String) -> Self {
let acad = in_acad(states);
if !acad.contains(&true) {
return Plan::default();
}
let xdict = handle();
let dict = handle();
let records = acad.iter().enumerate().filter(|(_, a)| **a).map(|(i, _)| (i, handle())).collect();
Plan { table: String::new(), xdict, dict, records }
}
pub fn is_empty(&self) -> bool {
self.records.is_empty()
}
}
/// What the state objects need from the rest of the file.
pub(crate) struct Refs<'a> {
/// Upper-case layer name → LAYER record handle.
pub layers: &'a HashMap<String, String>,
/// Upper-case linetype name → LTYPE record handle.
pub ltypes: &'a HashMap<String, String>,
/// Upper-case plot style name → its placeholder object's handle.
pub pstyles: &'a HashMap<String, String>,
/// Plot styles by colour (`$PSTYLEMODE` 1): the plot style name is `Color_N`.
pub colour_dependent: bool,
}
/// The objects of plan `p`: the extension dictionary, the `ACAD_LAYERSTATES` dictionary and one
/// XRECORD per state. Layers the drawing no longer has are left out of a state (AutoCAD names
/// layers by handle).
pub(crate) fn objects(p: &Plan, states: &[LayerState], refs: &Refs) -> Vec<Tag> {
let mut t = Vec::new();
if p.is_empty() {
return t;
}
t.extend([Tag::s(0, "DICTIONARY"), Tag::s(5, &p.xdict), Tag::s(330, &p.table), Tag::s(100, "AcDbDictionary"), Tag::i(280, 1), Tag::i(281, 1)]);
t.extend([Tag::s(3, KEY), Tag::s(360, &p.dict)]);
t.extend([Tag::s(0, "DICTIONARY"), Tag::s(5, &p.dict), Tag::s(102, "{ACAD_REACTORS"), Tag::s(330, &p.xdict), Tag::s(102, "}")]);
t.extend([Tag::s(330, &p.xdict), Tag::s(100, "AcDbDictionary"), Tag::i(281, 1)]);
let planned = || p.records.iter().filter_map(|(i, h)| Some((states.get(*i)?, h)));
for (st, h) in planned() {
t.extend([Tag::s(3, &st.name), Tag::s(350, h)]);
}
for (st, h) in planned() {
t.extend([Tag::s(0, "XRECORD"), Tag::s(5, h), Tag::s(102, "{ACAD_REACTORS"), Tag::s(330, &p.dict), Tag::s(102, "}"), Tag::s(330, &p.dict)]);
t.extend([Tag::s(100, "AcDbXrecord"), Tag::i(280, 1), Tag::i(91, i64::from(st.mask)), Tag::s(301, &st.description), Tag::i(290, 0)]);
t.push(Tag::s(302, &st.current));
for l in &st.layers {
if let Some(lh) = refs.layers.get(&l.name.to_ascii_uppercase()) {
layer(&mut t, l, lh, refs);
}
}
}
t
}
/// One layer of a state's XRECORD.
fn layer(t: &mut Vec<Tag>, l: &Layer, handle: &str, refs: &Refs) {
let flags = i64::from(!l.on) | i64::from(l.frozen) << 1 | i64::from(l.locked) << 2 | i64::from(l.plot) << 3 | i64::from(l.vp_freeze_new) << 4;
let aci = match l.color {
Color::True(rgb) => i64::from(cadcraft_color::nearest_aci(rgb)),
c => i64::from(c.to_aci()).clamp(1, 255),
};
t.extend([Tag::s(330, handle), Tag::i(90, flags), Tag::i(62, aci), Tag::i(370, i64::from(l.lineweight.to_dxf()))]);
if crate::dxf_xref::dependent(&l.name) {
t.push(Tag::i(93, 0));
}
// A linetype the drawing no longer has: Continuous, which every drawing has.
if let Some(lt) = refs.ltypes.get(&l.linetype.to_ascii_uppercase()).or_else(|| refs.ltypes.get("CONTINUOUS")) {
t.push(Tag::s(331, lt));
}
if refs.colour_dependent {
t.push(Tag::s(1, format!("Color_{aci}")));
} else if let Some(ps) = refs.pstyles.get(&l.plot_style.trim().to_ascii_uppercase()).or_else(|| refs.pstyles.get("NORMAL")) {
t.push(Tag::s(390, ps));
}
t.push(Tag::i(440, if l.transparency == 0 { 0 } else { transparency_to_dxf(l.transparency) }));
if let Color::True(rgb) = l.color {
t.push(Tag::i(92, i64::from(i32::from_be_bytes((TRUE_COLOR | rgb.to_u32()).to_be_bytes()))));
}
}
/// What a state's handles name in the drawing being read.
pub(crate) struct Lookup<'a> {
/// The drawing's layer a LAYER handle names: a state's layer starts as a copy of it (what the
/// state doesn't hold, such as the description, is the drawing's).
pub layer: &'a dyn Fn(&str) -> Option<Layer>,
/// The linetype an LTYPE handle names.
pub ltype: &'a dyn Fn(&str) -> Option<String>,
/// The plot style a placeholder handle names.
pub pstyle: &'a dyn Fn(&str) -> Option<String>,
/// Plot styles by colour: group 1 (`Color_N`) says nothing the layer's colour doesn't.
pub colour_dependent: bool,
}
/// The state `name` from its XRECORD's groups. A layer whose record is gone (AutoCAD keeps a
/// purged layer's entry, measured) is skipped. A layer named in two entries is in the state once,
/// the later entry's groups over the earlier one's, as restoring both in turn did: AutoCAD 2024
/// restores the later one (measured with entries that each set every property). Each copy of a
/// layer is charged to `budget`, the file's [`MAX_COPIED_BYTES`]; once it is spent, the entries
/// left are left out.
pub(crate) fn read(name: &str, tags: &[Tag], lookup: &Lookup, budget: &mut usize) -> LayerState {
let mut st = LayerState { name: name.to_string(), ..LayerState::default() };
// The data follows the subclass marker (an XRECORD without one holds none).
let start = tags.iter().position(|t| t.code == 100 && t.str().trim() == "AcDbXrecord").map_or(tags.len(), |i| i + 1);
let body = tags.get(start..).unwrap_or_default();
let first = body.iter().position(|t| t.code == 330).unwrap_or(body.len());
for t in body.get(..first).unwrap_or_default() {
match t.code {
91 => st.mask = t.str().trim().parse::<u32>().unwrap_or(LayerState::ALL),
301 => st.description = t.str(),
302 => st.current = t.str(),
_ => {}
}
}
let rest = body.get(first..).unwrap_or_default();
// The index in the state of each layer by its LAYER handle.
let mut index: HashMap<String, usize> = HashMap::new();
let mut at = 0;
while let Some(group) = rest.get(at..) {
let Some(head) = group.first() else { break };
let len = group.iter().skip(1).position(|t| t.code == 330).map_or(group.len(), |n| n + 1);
at += len;
let groups = group.get(1..len).unwrap_or_default();
let key = head.str().trim().to_ascii_uppercase();
if let Some(slot) = index.get(&key).and_then(|&i| st.layers.get_mut(i)) {
entry(slot, groups, lookup);
} else if let Some(mut l) = (lookup.layer)(&head.str()) {
let Some(left) = budget.checked_sub(cost(&l)) else { break };
*budget = left;
entry(&mut l, groups, lookup);
index.insert(key, st.layers.len());
st.layers.push(l);
}
}
st
}
/// The bytes a copy of layer `l` takes.
fn cost(l: &Layer) -> usize {
std::mem::size_of::<Layer>() + l.name.len() + l.linetype.len() + l.description.len() + l.plot_style.len()
}
/// A layer's properties from the groups after its handle.
fn entry(l: &mut Layer, groups: &[Tag], lookup: &Lookup) {
let int = |t: &Tag| t.str().trim().parse::<i64>().ok();
let mut true_color = None;
for t in groups {
match t.code {
90 => {
if let Some(f) = int(t) {
(l.on, l.frozen, l.locked, l.plot, l.vp_freeze_new) = (f & 1 == 0, f & 2 != 0, f & 4 != 0, f & 8 != 0, f & 16 != 0);
}
}
62 => {
if let Some(c) = int(t).map(i64::abs).and_then(|c| u8::try_from(c).ok()).filter(|c| *c >= 1) {
l.color = Color::Index(c);
}
}
92 => true_color = int(t).and_then(|v| u32::try_from(v & 0xFFFF_FFFF).ok()).filter(|v| v & 0xFF00_0000 == TRUE_COLOR),
370 => {
if let Some(w) = int(t).and_then(|w| i16::try_from(w).ok()) {
l.lineweight = Lineweight::from_dxf(w);
}
}
331 => {
if let Some(lt) = (lookup.ltype)(&t.str()) {
l.linetype = lt;
}
}
390 => {
if let Some(ps) = (lookup.pstyle)(&t.str()) {
l.plot_style = ps;
}
}
1 if !lookup.colour_dependent => l.plot_style = t.str(),
440 => {
if let Some(v) = int(t) {
l.transparency = transparency_from_dxf(v).unwrap_or(0);
}
}
_ => {}
}
}
if let Some(v) = true_color {
l.color = Color::True(Rgb::from_u32(v & 0x00FF_FFFF));
}
}
#[cfg(test)]
mod tests {
use super::*;
/// A state's XRECORD groups with an entry per (layer handle, colour index).
fn tags(entries: &[(&str, i64)]) -> Vec<Tag> {
let mut t = vec![Tag::s(100, "AcDbXrecord"), Tag::i(280, 1), Tag::i(91, 2047), Tag::s(302, "0")];
for (h, aci) in entries {
t.extend([Tag::s(330, *h), Tag::i(90, 8)]);
// 0: no colour group.
if *aci != 0 {
t.push(Tag::i(62, *aci));
}
}
t
}
#[test]
fn a_layer_named_twice_takes_its_last_entry_and_copies_stop_at_the_budget() {
let layer = |h: &str| match h {
"A1" => Some(Layer::new("A")),
"B1" => Some(Layer::new("B")),
_ => None,
};
let none = |_: &str| None::<String>;
let lookup = Lookup { layer: &layer, ltype: &none, pstyle: &none, colour_dependent: true };
let colours = |st: &LayerState| st.layers.iter().map(|l| (l.name.clone(), l.color)).collect::<Vec<_>>();
// AutoCAD 2024 restores the last of two entries of one layer (measured: green, then blue,
// restores blue); it stays in the first one's place. A later entry without a colour keeps
// the earlier one's, as restoring both in turn did.
let mut budget = MAX_COPIED_BYTES;
let st = read("S", &tags(&[("A1", 3), ("B1", 2), ("A1", 5), ("B1", 0)]), &lookup, &mut budget);
assert_eq!(colours(&st), [("A".to_string(), Color::Index(5)), ("B".to_string(), Color::Index(2))]);
// Each new copy is charged (a repeated entry copies nothing); past the budget the rest of
// the entries, and of the file's states, are left out.
let one = cost(&Layer::new("A"));
let mut budget = one;
let st = read("S", &tags(&[("A1", 3), ("A1", 4), ("B1", 5)]), &lookup, &mut budget);
assert_eq!((colours(&st), budget), (vec![("A".to_string(), Color::Index(4))], 0));
let st = read("T", &tags(&[("B1", 2)]), &lookup, &mut budget);
assert!(st.layers.is_empty());
}
}
+77 -21
View File
@@ -36,10 +36,11 @@ const MODELLED_KEYS: &[&str] = &[
"ACAD_IMAGE_VARS",
];
/// Extension dictionary entries not kept raw: dimension associativity (CADCraft reads and
/// rewrites it), draw order and annotation scale contexts (written from their own models by the
/// changes that model them; stale copies would contradict the drawing).
const MODELLED_XDICT_KEYS: &[&str] = &["ACAD_DIMASSOC", "ACAD_SORTENTS", "ACDBCONTEXTDATAMANAGER"];
/// Extension dictionary entries not kept raw: dimension associativity and the LAYER table's layer
/// states (CADCraft reads and rewrites them), draw order and annotation scale contexts (written
/// from their own models by the changes that model them; stale copies would contradict the
/// drawing).
const MODELLED_XDICT_KEYS: &[&str] = &["ACAD_DIMASSOC", "ACAD_LAYERSTATES", "ACAD_SORTENTS", "ACDBCONTEXTDATAMANAGER"];
/// Applications whose xdata CADCraft reads and writes itself. `ACAD` holds dimension overrides
/// (DSTYLE) on dimensions and dimension styles; elsewhere it is kept.
@@ -989,20 +990,7 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
let root = objects.first().filter(|(k, _, _)| is_dictionary(k)).map(|(_, s, _)| *s);
let root_keys: HashSet<String> =
objects.iter().find(|(_, s, _)| Some(*s) == root).map(|(_, _, t)| entries(t).into_iter().map(|(k, _)| up(&k)).collect()).unwrap_or_default();
// Extension dictionaries that go on a written record (one without its own).
let mut block = String::new();
let mut attached: HashSet<String> = HashSet::new();
for r in &recs {
if r.kind == "BLOCK" {
block = up(&val(body(r), 2).unwrap_or_default());
}
if let Some(x) = extra_for(f, &xd, r, body(r), &block)
&& let Some(xd) = x.xdict
&& head(body(r)).xdict.is_none()
{
attached.insert(xd.hex());
}
}
let (mut attached, merged) = kept_dictionaries(f, &xd, &recs, tags);
for (_, t) in planned.values().flatten() {
let x = head(t.get(1..).unwrap_or(&[])).handle.and_then(|h| handle(&h)).and_then(|h| entity_extra(f, &xd, h));
attached.extend(x.and_then(|x| x.xdict).map(Handle::hex));
@@ -1050,7 +1038,7 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
if nod.contains(&owner) {
break dict_entries.get(&cur).is_some_and(|k| !root_keys.contains(&up(k))) && root.is_some();
}
if attached.contains(&cur) {
if attached.contains(&cur) || merged.contains_key(&cur) {
break true;
}
break unknown.contains(&owner) && written.contains(&owner);
@@ -1068,6 +1056,13 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
alive.insert(o.handle.hex(), format!("{next:X}"));
next = next.saturating_add(1);
}
// A merged dictionary is not written: what pointed at it points at the written one.
for (kept, own) in &merged {
if let Some(h) = alive.get_mut(kept) {
h.clone_from(own);
}
}
let merged_into: HashMap<String, &ForeignObject> = merged.iter().filter_map(|(kept, own)| Some((own.clone(), *objs.get(kept)?))).collect();
let entities: HashSet<String> = all_entities(d).map(|e| e.handle.hex()).filter(|h| written.contains(h)).collect();
let map = Map { f, alive, raw: objs.keys().cloned().collect(), roles, entities };
let mut out: Vec<Tag> = Vec::with_capacity(tags.len() + f.objects.iter().map(|o| o.tags.len() + 1).sum::<usize>());
@@ -1081,7 +1076,7 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
continue;
}
if r.kind == "ENDSEC" && r.sec == "OBJECTS" {
for o in f.objects.iter().filter(|o| map.alive.contains_key(&o.handle.hex())) {
for o in f.objects.iter().filter(|o| map.alive.contains_key(&o.handle.hex()) && !merged.contains_key(&o.handle.hex())) {
let number = is_proxy(&o.kind).then(|| renumber(class_number(o.tags.iter().map(|r| (r.code, r.value.as_str()))))).flatten();
match number {
Some(n) => {
@@ -1105,11 +1100,15 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
}
out.extend(tags.get(r.start).cloned());
let x = extra_for(f, &xd, r, b, &block);
if x.is_none() && Some(r.start) != root {
let joined = joined_into(&merged_into, b);
if x.is_none() && Some(r.start) != root && joined.is_none() {
out.extend(b.iter().cloned());
continue;
}
record(&map, r, b, x.as_deref(), None, Some(r.start) == root, &mut out);
if let Some(kept) = joined {
join_entries(&map, b, kept, &mut out);
}
}
add_appids(&mut out);
let top = max_handle(&out).saturating_add(1);
@@ -1121,6 +1120,32 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
*tags = out;
}
/// Kept extension dictionaries of written records: those that go on a record without its own,
/// and those whose entries join the one the writer gave a table (the LAYER table's, holding the
/// layer states) as kept dictionary → the written one.
fn kept_dictionaries(f: &Foreign, xd: &XdataOf, recs: &[Rec], tags: &[Tag]) -> (HashSet<String>, HashMap<String, String>) {
let body = |r: &Rec| tags.get(r.start + 1..r.end).unwrap_or(&[]);
let mut block = String::new();
let mut attached: HashSet<String> = HashSet::new();
let mut merged: HashMap<String, String> = HashMap::new();
for r in recs {
if r.kind == "BLOCK" {
block = up(&val(body(r), 2).unwrap_or_default());
}
let Some(kept) = extra_for(f, xd, r, body(r), &block).and_then(|x| x.xdict) else { continue };
match head(body(r)).xdict {
None => {
attached.insert(kept.hex());
}
Some(own) if r.sec == "TABLES" => {
merged.insert(kept.hex(), own);
}
Some(_) => {}
}
}
(attached, merged)
}
/// Complete source tables keep positional identities even when names repeat.
fn proxy_class_number(f: &Foreign, numbers: &HashMap<String, i64>, old: Option<i64>) -> Option<i64> {
if f.complete_class_table {
@@ -1352,6 +1377,37 @@ fn record(map: &Map, r: &Rec, b: &[Tag], x: Option<&ForeignExtra>, unknown: Opti
}
}
/// The kept dictionary whose entries join written dictionary `b`, if any.
fn joined_into<'a>(merged_into: &HashMap<String, &'a ForeignObject>, b: &[Tag]) -> Option<&'a ForeignObject> {
if merged_into.is_empty() {
return None;
}
head(b).handle.and_then(|h| merged_into.get(&h).copied())
}
/// The entries of kept dictionary `kept` that written dictionary `b` doesn't have (by key, without
/// regard to case), appended to it with their handles remapped; entries whose object is gone are
/// left out.
fn join_entries(map: &Map, b: &[Tag], kept: &ForeignObject, out: &mut Vec<Tag>) {
let has = |key: &str| b.iter().any(|t| t.code == 3 && up(&t.str()) == up(key));
let mut key: Option<&str> = None;
for t in kept.tags.iter().take_while(|t| t.code < 1000) {
match t.code {
3 => key = Some(t.value.as_str()),
350 | 360 => {
if let Some(k) = key.take()
&& !has(k)
&& let Some(h) = map.get(&t.value).filter(|h| h != "0")
{
out.push(Tag::s(3, k));
out.push(Tag::s(t.code, h));
}
}
_ => {}
}
}
}
/// Kept xdata of applications the record doesn't already carry, handles remapped.
fn xdata(map: &Map, x: &ForeignExtra, own: &HashSet<String>, out: &mut Vec<Tag>) {
let mut skip = false;
+96 -5
View File
@@ -8,10 +8,14 @@ use super::{Drawing, EntityKind, Group, Handle, HashMap, MLeaderStyle, PageSetup
pub(super) struct Objects {
/// Dictionary entry handle (upper case) → entry name.
names: HashMap<String, String>,
/// (dictionary handle, entry handle), both upper case, in the order the dictionaries list them.
entry_order: Vec<(String, String)>,
/// SCALE objects (the annotation scale list), in file order.
scales: Vec<cadcraft_doc::AnnoScale>,
/// XRECORD handle (upper case) → its groups.
xrecords: HashMap<String, Vec<Tag>>,
/// XRECORD handles in file order.
xrecord_order: Vec<String>,
/// TABLESTYLE objects: (handle, groups).
table_styles: Vec<(String, Vec<Tag>)>,
/// DIMASSOC objects.
@@ -50,7 +54,11 @@ impl Objects {
if let Some(n) = name.take()
&& self.names.len() < MAX_OBJECTS
{
self.names.insert(t.str().trim().to_ascii_uppercase(), n);
let entry = t.str().trim().to_ascii_uppercase();
if self.entry_order.len() < MAX_OBJECTS {
self.entry_order.push((h.clone(), entry.clone()));
}
self.names.insert(entry, n);
}
}
_ => {}
@@ -58,7 +66,9 @@ impl Objects {
}
}
"XRECORD" if self.xrecords.len() < MAX_OBJECTS => {
self.xrecords.insert(h, tags.to_vec());
if self.xrecords.insert(h.clone(), tags.to_vec()).is_none() {
self.xrecord_order.push(h);
}
}
"TABLESTYLE" if self.table_styles.len() < MAX_OBJECTS => self.table_styles.push((h, tags.to_vec())),
"DIMASSOC" if self.dimassocs.len() < MAX_OBJECTS => self.dimassocs.push(tags.to_vec()),
@@ -80,6 +90,65 @@ impl Objects {
}
}
/// The layer states of the LAYER table's `ACAD_LAYERSTATES` dictionary (its XRECORDs, in file
/// order), read with the drawing's layers and linetypes. Entries whose names differ only in case
/// are one state, as AutoCAD 2024 opens them (measured with `S` and `s` in both orders): named as
/// the first of them in the dictionary, holding the last one's record, where the first of their
/// records comes in the file.
fn acad_layer_states(&self, d: &Drawing, rx: &Rx) -> Vec<cadcraft_doc::LayerState> {
let dicts: std::collections::HashSet<&str> =
self.names.iter().filter(|(_, n)| n.eq_ignore_ascii_case(crate::dxf_layer_states::KEY)).map(|(h, _)| h.as_str()).collect();
if dicts.is_empty() {
return Vec::new();
}
let mut by_name: HashMap<String, &cadcraft_doc::Layer> = HashMap::with_capacity(d.layers.len());
for l in &d.layers {
by_name.entry(l.name.to_ascii_lowercase()).or_insert(l);
}
let layer_of =
|h: &str| rx.layers.get(&h.trim().to_ascii_uppercase()).and_then(|n| by_name.get(&n.to_ascii_lowercase())).map(|l| (*l).clone());
let ltype_of = |h: &str| rx.ltypes.get(&h.trim().to_ascii_uppercase()).cloned();
let pstyle_of = |h: &str| rx.pstyles.get(&h.trim().to_ascii_uppercase()).cloned();
let lookup = crate::dxf_layer_states::Lookup {
layer: &layer_of,
ltype: &ltype_of,
pstyle: &pstyle_of,
colour_dependent: d.header.i64("PSTYLEMODE", 1) != 0,
};
let ours = |tags: &[Tag]| owner(tags).is_some_and(|o| dicts.contains(o.as_str()));
// By lower-case name: the first entry's name and the last entry's record, in dictionary order.
let mut first: HashMap<String, &String> = HashMap::new();
let mut last: HashMap<String, &Vec<Tag>> = HashMap::new();
for (dict, h) in &self.entry_order {
if dicts.contains(dict.as_str())
&& let (Some(name), Some(tags)) = (self.names.get(h), self.xrecords.get(h))
&& ours(tags)
{
first.entry(name.to_ascii_lowercase()).or_insert(name);
last.insert(name.to_ascii_lowercase(), tags);
}
}
let mut out = Vec::new();
let mut taken = std::collections::HashSet::new();
let mut budget = crate::dxf_layer_states::MAX_COPIED_BYTES;
for h in &self.xrecord_order {
let (Some(tags), Some(name)) = (self.xrecords.get(h), self.names.get(h)) else { continue };
if out.len() >= crate::dxf_ext::MAX_LAYER_STATES {
break;
}
if !ours(tags) {
continue;
}
let key = name.to_ascii_lowercase();
if taken.insert(key.clone()) {
let name = first.get(&key).copied().unwrap_or(name);
let tags = last.get(&key).copied().unwrap_or(tags);
out.push(crate::dxf_layer_states::read(name, tags, &lookup, &mut budget));
}
}
out
}
/// The text of the CADCraft XRECORD stored under `key` in a dictionary (its 1/3 strings).
pub(super) fn xrecord_text(&self, key: &str) -> Option<String> {
let h = self.names.iter().find(|(_, n)| n.as_str() == key).map(|(h, _)| h)?;
@@ -208,10 +277,18 @@ impl Objects {
if let Some(p) = self.xrecord_text(crate::dxf_ext::ANNOTATION_KEY).and_then(|t| crate::dxf_ext::parse_anno(&t)) {
crate::dxf_ext::apply_anno(d, p);
}
// Saved layer states.
if let Some(states) = self.xrecord_text(crate::dxf_ext::LAYER_STATES_KEY).and_then(|t| crate::dxf_ext::parse_layer_states(&t)) {
d.layer_states = states;
// Saved layer states: AutoCAD's, then those of CADCraft's own record (a file of an
// earlier version keeps them all there) that AutoCAD's doesn't hold.
let mut states = self.acad_layer_states(d, rx);
if let Some(own) = self.xrecord_text(crate::dxf_ext::LAYER_STATES_KEY).and_then(|t| crate::dxf_ext::parse_layer_states(&t)) {
let mut names: std::collections::HashSet<String> = states.iter().map(|s| s.name.clone()).collect();
for st in own {
if states.len() < crate::dxf_ext::MAX_LAYER_STATES && names.insert(st.name.clone()) {
states.push(st);
}
}
}
d.layer_states = states;
// The drawing's plot style tables.
if let Some(tables) = self.xrecord_text(crate::dxf_ext::PLOT_STYLES_KEY).and_then(|t| crate::dxf_ext::parse_plot_styles(&t)) {
d.plot_style_tables = tables;
@@ -231,6 +308,20 @@ impl Objects {
}
}
/// An object's owner (its first group 330 outside a `102` group), upper case.
fn owner(tags: &[Tag]) -> Option<String> {
let mut inside = false;
for t in tags {
match t.code {
102 => inside = t.str().trim().starts_with('{'),
330 if !inside => return Some(t.str().trim().to_ascii_uppercase()),
100 => return None,
_ => {}
}
}
None
}
/// Page setup from a LAYOUT object's AcDbPlotSettings fields (sizes and margins in mm).
pub(super) fn page_setup(t: &T) -> PageSetup {
let mut p = PageSetup::default();
+2
View File
@@ -58,6 +58,8 @@ pub(super) struct Ctx {
pub(super) frozen_341: bool,
/// MTEXT columns as the legacy groups 75..79 even from R2018 (the groups AutoLISP lists).
pub(super) legacy_columns: bool,
/// Saved layer states in AutoCAD's form (the LAYER table's extension dictionary).
pub(super) layer_states: crate::dxf_layer_states::Plan,
}
impl Ctx {
+8
View File
@@ -143,10 +143,18 @@ pub(super) fn vport_table(w: &mut W, d: &Drawing, ext: Bounds2) {
}
pub(super) fn table_head(w: &mut W, name: &str, count: usize) -> String {
table_head_x(w, name, count, None)
}
/// A table's head, with its extension dictionary `xdict` when it has one.
pub(super) fn table_head_x(w: &mut W, name: &str, count: usize, xdict: Option<&str>) -> String {
let h = w.h();
w.s(0, "TABLE");
w.s(2, name);
w.s(5, h.clone());
if let Some(x) = xdict {
w.group("ACAD_XDICTIONARY", 360, &[x]);
}
w.s(330, "0");
w.s(100, "AcDbSymbolTable");
w.i(70, count as i64);
+29 -8
View File
@@ -4,7 +4,7 @@ use super::common::annotative_xdata;
use super::ctx::{AssocObj, Ctx};
use super::entity::{entity, hatch_reactors};
use super::header::{code_page, header_vars};
use super::layout::{paper_views, record_head, sheet_first, table_head, vport_table};
use super::layout::{paper_views, record_head, sheet_first, table_head, table_head_x, vport_table};
use super::objects::{cadcraft_fonts_name, group_obj, mleader_style_obj, scale_list, table_style_obj};
use super::{
Block, Color, DimStyle, DimVal, Drawing, Entity, EntityKind, EntityStore, Group, HVal, Handle, HashMap, Layout, MLeaderStyle, PageSetup, Space,
@@ -68,7 +68,7 @@ fn write_tables(w: &mut W, plan: TableWritePlan<'_>) -> HashMap<String, String>
}
}
w.s(0, "ENDTAB");
write_layer_table(w, d);
write_layer_table(w, d, &mut cx.layer_states);
// STYLE. Linetype shapes from a shape file that isn't a text style get an unnamed shape
// style record (70 bit 1) naming the file.
let mut shape_files: Vec<String> = Vec::new();
@@ -185,8 +185,12 @@ fn write_tables(w: &mut W, plan: TableWritePlan<'_>) -> HashMap<String, String>
ltype_handles
}
fn write_layer_table(w: &mut W, d: &Drawing) {
let th = table_head(w, "LAYER", d.layers.len());
/// The LAYER table; when the drawing has layer states AutoCAD can hold, the table's extension
/// dictionary holds them (written with the objects, [`crate::dxf_layer_states`]).
fn write_layer_table(w: &mut W, d: &Drawing, states: &mut crate::dxf_layer_states::Plan) {
let xdict = (!states.is_empty()).then(|| states.xdict.clone());
let th = table_head_x(w, "LAYER", d.layers.len(), xdict.as_deref());
states.table.clone_from(&th);
for l in &d.layers {
let lh = record_head(w, "LAYER", &th, "AcDbLayerTableRecord");
w.layers.insert(l.name.to_ascii_uppercase(), lh);
@@ -749,6 +753,16 @@ fn write_objects(w: &mut W, plan: ObjectWritePlan<'_>) {
write_root_group_objects(w, &plan, &groups, &group_owner, &written, &mleader_dict);
write_style_objects(w, &plan, &mleader_dict, &mleader_handles);
write_named_objects(w, &plan);
let layer_states = {
let refs = crate::dxf_layer_states::Refs {
layers: &w.layers,
ltypes: &plan.cx.ltypes,
pstyles: &w.pstyles,
colour_dependent: plan.d.header.i64("PSTYLEMODE", 1) != 0,
};
crate::dxf_layer_states::objects(&plan.cx.layer_states, &plan.d.layer_states, &refs)
};
w.t.extend(layer_states);
write_associative_objects(w, plan.cx);
write_layout_objects(w, &plan);
// Raster image definitions.
@@ -979,7 +993,9 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
if let Some(chunks) = dxf_ext::constraint_chunks(&d.constraints, &d.parametric) {
xrecords.push((dxf_ext::CONSTRAINTS_KEY, w.h(), chunks));
}
if let Some(chunks) = dxf_ext::layer_state_chunks(&d.layer_states) {
// Saved layer states: AutoCAD's dictionary holds those it can, CADCraft's record the others.
cx.layer_states = crate::dxf_layer_states::Plan::new(&d.layer_states, || w.h());
if let Some(chunks) = dxf_ext::layer_state_chunks(&crate::dxf_layer_states::own(&d.layer_states)) {
xrecords.push((dxf_ext::LAYER_STATES_KEY, w.h(), chunks));
}
if let Some(chunks) = dxf_ext::plot_style_chunks(&d.plot_style_tables) {
@@ -991,14 +1007,19 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
// The annotation scale list: the ACAD_SCALELIST dictionary of SCALE objects.
let scale_dict = w.h();
let scales: Vec<(&cadcraft_doc::AnnoScale, String)> = d.scales.iter().filter(|s| s.is_valid()).map(|s| (s, w.h())).collect();
// Plot style names used by layers and objects (Normal always), each a placeholder object.
// Plot style names used by layers and objects (Normal always), each a placeholder object; in
// a drawing of named plot styles also those of the layers of saved layer states, which name
// theirs by placeholder.
let pstyle_dict = w.h();
let mut pstyle_names: Vec<String> = vec![cadcraft_doc::NORMAL_STYLE.to_string()];
let named = d.layers.iter().map(|l| l.plot_style.as_str()).chain(every.iter().map(|e| e.common.plot_style.as_str()));
let mut seen: std::collections::HashSet<String> = pstyle_names.iter().map(|n| n.to_ascii_uppercase()).collect();
let named_styles = d.header.i64("PSTYLEMODE", 1) == 0;
let in_states = d.layer_states.iter().filter(|_| named_styles).flat_map(|s| s.layers.iter());
let named = d.layers.iter().chain(in_states).map(|l| l.plot_style.as_str()).chain(every.iter().map(|e| e.common.plot_style.as_str()));
for n in named {
let n = n.trim();
let logical = n.is_empty() || n.eq_ignore_ascii_case("bylayer") || n.eq_ignore_ascii_case("byblock");
if !logical && pstyle_names.len() < dxf_ext::MAX_PLOT_STYLE_NAMES && !pstyle_names.iter().any(|x| x.eq_ignore_ascii_case(n)) {
if !logical && pstyle_names.len() < dxf_ext::MAX_PLOT_STYLE_NAMES && seen.insert(n.to_ascii_uppercase()) {
pstyle_names.push(n.to_string());
}
}
+1
View File
@@ -9,6 +9,7 @@ mod dxf_raw;
mod dxf_clip;
mod dxf_ext;
mod dxf_image;
mod dxf_layer_states;
mod dxf_mleader;
mod dxf_read;
mod dxf_table;
+17 -5
View File
@@ -1856,22 +1856,24 @@ fn layer_states_roundtrip_next_to_constraints() {
description: "walls \\ hidden".into(),
..Layer::default()
});
d.layer_states.push(LayerState { name: "Plot".into(), layers: d.layers.clone() });
d.layer_states.push(LayerState::new("Plot", d.layers.clone(), "Wände"));
let mut off = d.layers.clone();
for l in &mut off {
(l.on, l.frozen, l.locked, l.plot) = (false, true, true, false);
}
d.layer_states.push(LayerState { name: "All off".into(), layers: off });
d.layer_states.push(LayerState::new("All off", off, ""));
let text = write_dxf(&d);
assert!(text.contains("CADCRAFT_LAYERSTATES"));
// AutoCAD's dictionary holds both states; CADCraft's record isn't needed.
assert!(text.contains("ACAD_LAYERSTATES") && !text.contains("CADCRAFT_LAYERSTATES"));
let back = read_dxf(text.as_bytes()).unwrap();
assert_eq!(back.layer_states, d.layer_states);
assert_eq!(back.constraints, constraints);
assert_eq!(roundtrip(&back).layer_states, d.layer_states);
#[cfg(not(target_arch = "wasm32"))]
assert_eq!(read(&write(&d, "x.dwg").unwrap(), "x.dwg").unwrap().layer_states, d.layer_states);
// Drawings without saved layer states carry no record.
assert!(!write_dxf(&Drawing::new_imperial()).contains("CADCRAFT_LAYERSTATES"));
// Drawings without saved layer states carry neither.
let none = write_dxf(&Drawing::new_imperial());
assert!(!none.contains("CADCRAFT_LAYERSTATES") && !none.contains("ACAD_LAYERSTATES"));
}
fn table_sample() -> Table {
@@ -3713,3 +3715,13 @@ fn solid_hatch_keeps_angle_scale_and_double_flag() {
assert!(f("41").is_some_and(|s| (s - 2.0).abs() < 1e-12), "{h:?}");
assert_eq!(group(h, "77"), Some("0"), "{h:?}");
}
/// A layer state of CADCraft's own record from before states had a mask, a current layer and a
/// description (its JSON holds only the name and the layers) restores every property and names no
/// current layer.
#[test]
fn a_layer_state_saved_before_masks_restores_everything() {
let states = crate::dxf_ext::parse_layer_states(r#"{"version":1,"states":[{"name":"S","layers":[]}]}"#).unwrap();
let got: Vec<(&str, u32, &str, &str)> = states.iter().map(|s| (s.name.as_str(), s.mask, s.current.as_str(), s.description.as_str())).collect();
assert_eq!(got, [("S", LayerState::ALL, "", "")]);
}
+451
View File
@@ -0,0 +1,451 @@
//! Saved layer states in AutoCAD's form: the LAYER table's extension dictionary holds an
//! `ACAD_LAYERSTATES` dictionary of one XRECORD per state. The groups below are copied from
//! AutoCAD 2024's own DXFOUT of states saved with -LAYER stAte on a self-built drawing.
use cadcraft_color::{Color, Rgb};
use cadcraft_doc::{Drawing, Layer, LayerState, Lineweight};
use cadcraft_io::{read, write_dxf};
/// `(code, value)` pairs of a DXF, trimmed.
fn pairs(dxf: &str) -> Vec<(String, String)> {
let lines: Vec<&str> = dxf.lines().collect();
lines.chunks(2).filter_map(|c| Some((c.first()?.trim().to_string(), c.get(1)?.trim().to_string()))).collect()
}
fn join(p: &[(String, String)]) -> String {
p.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect()
}
fn g(c: &str, v: &str) -> (String, String) {
(c.to_string(), v.to_string())
}
/// The records of a DXF: (type, groups after the `0`).
fn records(p: &[(String, String)]) -> Vec<(String, Vec<(String, String)>)> {
let mut out: Vec<(String, Vec<(String, String)>)> = Vec::new();
for (c, v) in p {
if c == "0" {
out.push((v.clone(), Vec::new()));
} else if let Some(last) = out.last_mut() {
last.1.push((c.clone(), v.clone()));
}
}
out
}
fn value<'a>(groups: &'a [(String, String)], code: &str) -> Option<&'a str> {
groups.iter().find(|(c, _)| c == code).map(|(_, v)| v.as_str())
}
/// The handle of table record `kind` named `name`.
fn record_handle(p: &[(String, String)], kind: &str, name: &str) -> String {
let recs = records(p);
let (_, groups) = recs.iter().find(|(k, gs)| k == kind && value(gs, "2").is_some_and(|n| n.eq_ignore_ascii_case(name))).unwrap();
value(groups, "5").unwrap().to_string()
}
/// A handle above every handle of the file, plus `k`.
fn fresh(p: &[(String, String)], k: u64) -> String {
let top = p.iter().filter(|(c, _)| c == "5" || c == "105").filter_map(|(_, v)| u64::from_str_radix(v, 16).ok()).max().unwrap();
format!("{:X}", top + 0x100 + k)
}
/// `dxf` with the LAYER table given extension dictionary `xdict` and `objects` added at the end
/// of OBJECTS.
fn inject(dxf: &str, xdict: &str, objects: Vec<(String, String)>) -> String {
let mut p = pairs(dxf);
let table = p.iter().enumerate().position(|(i, (c, v))| c == "0" && v == "TABLE" && p.get(i + 1).is_some_and(|n| n.1 == "LAYER")).unwrap();
let at = table + p[table..].iter().position(|(c, _)| c == "5").unwrap() + 1;
p.splice(at..at, [g("102", "{ACAD_XDICTIONARY"), g("360", xdict), g("102", "}")]);
let objs = p.iter().position(|(c, v)| c == "2" && v == "OBJECTS").unwrap();
let end = objs + p[objs..].iter().position(|(c, v)| c == "0" && v == "ENDSEC").unwrap();
p.splice(end..end, objects);
join(&p)
}
/// Layers A (red) and B, and the DASHED linetype.
fn drawing() -> Drawing {
let mut d = Drawing::new_metric();
d.layers.push(Layer { color: Color::Index(1), ..Layer::new("A") });
d.layers.push(Layer::new("B"));
d.linetypes.push(cadcraft_doc::library::standard_linetypes().into_iter().find(|l| l.name == "DASHED").unwrap());
d
}
/// State S2 as AutoCAD 2024 wrote it after -LAYER: A true colour 10,20,30 (nearest index 168),
/// 50% transparent, 0.35 mm, DASHED, not plotted; B locked and frozen in new viewports. Then the
/// entry of a layer purged since (AutoCAD keeps it, pointing at handles that are gone).
fn s2(p: &[(String, String)], rec: &str, dict: &str) -> Vec<(String, String)> {
let (a, b, zero) = (record_handle(p, "LAYER", "A"), record_handle(p, "LAYER", "B"), record_handle(p, "LAYER", "0"));
let (cont, dashed) = (record_handle(p, "LTYPE", "Continuous"), record_handle(p, "LTYPE", "DASHED"));
let gone = fresh(p, 0x50);
let mut v =
vec![g("0", "XRECORD"), g("5", rec), g("102", "{ACAD_REACTORS"), g("330", dict), g("102", "}"), g("330", dict), g("100", "AcDbXrecord")];
v.extend([g("280", "1"), g("91", "2047"), g("301", ""), g("290", "0"), g("302", "0")]);
for (h, flags, aci, lw, lt, ps, tr) in [
(b.as_str(), "28", "7", "-3", cont.as_str(), "Color_7", "0"),
(a.as_str(), "0", "168", "35", dashed.as_str(), "Color_168", "33554559"),
(zero.as_str(), "8", "7", "-3", cont.as_str(), "Color_7", "0"),
(gone.as_str(), "8", "7", "-3", gone.as_str(), "Color_7", "0"),
] {
v.extend([g("330", h), g("90", flags), g("62", aci), g("370", lw), g("331", lt), g("1", ps), g("440", tr)]);
if h == a {
v.push(g("92", "-1039526882"));
}
}
v
}
/// State S7, saved with only On and restored once (AutoCAD then sets bit 65536), current layer A.
fn s7(p: &[(String, String)], rec: &str, dict: &str) -> Vec<(String, String)> {
let (a, b) = (record_handle(p, "LAYER", "A"), record_handle(p, "LAYER", "B"));
let cont = record_handle(p, "LTYPE", "Continuous");
let mut v =
vec![g("0", "XRECORD"), g("5", rec), g("102", "{ACAD_REACTORS"), g("330", dict), g("102", "}"), g("330", dict), g("100", "AcDbXrecord")];
v.extend([g("280", "1"), g("91", "66049"), g("301", "only on"), g("290", "0"), g("302", "A")]);
for (h, aci) in [(b.as_str(), "7"), (a.as_str(), "1")] {
v.extend([g("330", h), g("90", "8"), g("62", aci), g("370", "-3"), g("331", &cont), g("1", &format!("Color_{aci}")), g("440", "0")]);
}
v
}
/// The extension dictionary of the LAYER table and the states dictionary, with `extra` entries in
/// the extension dictionary.
fn dictionaries(p: &[(String, String)], x: &str, y: &str, states: &[(&str, &str)], extra: &[(&str, &str)]) -> Vec<(String, String)> {
let table = {
let recs = records(p);
let (_, gs) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
value(gs, "5").unwrap().to_string()
};
let mut v = vec![g("0", "DICTIONARY"), g("5", x), g("330", &table), g("100", "AcDbDictionary"), g("280", "1"), g("281", "1")];
for (k, h) in extra.iter().copied().chain([("ACAD_LAYERSTATES", y)]) {
v.extend([g("3", k), g("360", h)]);
}
v.extend([
g("0", "DICTIONARY"),
g("5", y),
g("102", "{ACAD_REACTORS"),
g("330", x),
g("102", "}"),
g("330", x),
g("100", "AcDbDictionary"),
g("281", "1"),
]);
for (name, h) in states {
v.extend([g("3", name), g("350", h)]);
}
v
}
fn autocad_file() -> String {
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r2, r7) = (h(1), h(2), h(3), h(4));
let mut objects = dictionaries(&p, &x, &y, &[("S2", &r2), ("S7", &r7)], &[]);
objects.extend(s2(&p, &r2, &y));
objects.extend(s7(&p, &r7, &y));
inject(&base, &x, objects)
}
#[test]
fn reads_the_layer_states_autocad_writes() {
let d = read(autocad_file().as_bytes(), "acad.dxf").unwrap();
let names: Vec<&str> = d.layer_states.iter().map(|s| s.name.as_str()).collect();
assert_eq!(names, ["S2", "S7"]);
let s2 = &d.layer_states[0];
assert_eq!((s2.mask, s2.current.as_str(), s2.description.as_str()), (2047, "0", ""));
// The purged layer's entry is skipped.
let layers: Vec<&str> = s2.layers.iter().map(|l| l.name.as_str()).collect();
assert_eq!(layers, ["B", "A", "0"]);
let a = &s2.layers[1];
assert_eq!(a.color, Color::True(Rgb(10, 20, 30)));
assert_eq!((a.transparency, a.lineweight, a.linetype.as_str()), (50, Lineweight::from_dxf(35), "DASHED"));
assert!(a.on && !a.frozen && !a.locked && !a.plot && !a.vp_freeze_new);
// A colour-dependent drawing: the plot style stays the layer's ("Color_168" is its colour's).
assert_eq!(a.plot_style, "Normal");
let b = &s2.layers[0];
assert!(b.on && !b.frozen && b.locked && b.plot && b.vp_freeze_new, "{b:?}");
assert_eq!((b.color, b.linetype.as_str(), b.transparency), (Color::Index(7), "Continuous", 0));
let s7 = &d.layer_states[1];
assert_eq!((s7.mask, s7.current.as_str(), s7.description.as_str()), (66049, "A", "only on"));
assert_eq!(s7.layers.iter().find(|l| l.name == "A").unwrap().color, Color::Index(1));
}
#[test]
fn autocads_layer_states_are_written_back_in_its_form() {
let d = read(autocad_file().as_bytes(), "acad.dxf").unwrap();
let text = write_dxf(&d);
let p = pairs(&text);
// One states dictionary, in the LAYER table's extension dictionary, and no CADCraft copy.
assert_eq!(p.iter().filter(|(c, v)| c == "3" && v == "ACAD_LAYERSTATES").count(), 1);
assert!(!text.contains("CADCRAFT_LAYERSTATES"));
let recs = records(&p);
let (_, table) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
let x = table.windows(2).find(|w| w[0] == g("102", "{ACAD_XDICTIONARY")).map(|w| w[1].1.clone()).unwrap();
let (_, xd) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(x.as_str())).unwrap();
assert_eq!(value(xd, "330"), value(table, "5"));
let back = read(text.as_bytes(), "back.dxf").unwrap();
assert_eq!(back.layer_states, d.layer_states);
// The XRECORD of S2 as AutoCAD writes it: B, then A.
let (a_h, b_h) = (record_handle(&p, "LAYER", "A"), record_handle(&p, "LAYER", "B"));
let (_, rec) = recs.iter().find(|(k, gs)| k == "XRECORD" && gs.contains(&g("91", "2047"))).unwrap();
let head = rec.iter().position(|(c, _)| c == "280").unwrap();
assert_eq!(rec[head..head + 5], [("280", "1"), ("91", "2047"), ("301", ""), ("290", "0"), ("302", "0")].map(|(c, v)| g(c, v)));
let cont = record_handle(&p, "LTYPE", "Continuous");
let b = [("330", b_h.as_str()), ("90", "28"), ("62", "7"), ("370", "-3"), ("331", &cont), ("1", "Color_7"), ("440", "0")];
assert_eq!(rec[head + 5..head + 12], b.map(|(c, v)| g(c, v)));
let from = rec.iter().position(|(c, v)| c == "330" && *v == a_h).unwrap();
let a: Vec<(String, String)> = rec[from..from + 9].to_vec();
let dashed = record_handle(&p, "LTYPE", "DASHED");
let want = [
("330", a_h.as_str()),
("90", "0"),
("62", "168"),
("370", "35"),
("331", &dashed),
("1", "Color_168"),
("440", "33554559"),
("92", "-1039526882"),
];
assert_eq!(a[..8], want.map(|(c, v)| g(c, v)), "{a:?}");
#[cfg(not(target_arch = "wasm32"))]
{
let dwg = cadcraft_io::write(&d, "x.dwg").unwrap();
assert_eq!(read(&dwg, "x.dwg").unwrap().layer_states, d.layer_states);
}
}
#[test]
fn layer_filters_next_to_the_states_are_kept() {
// The LAYER table's extension dictionary of a drawing with layer filters holds them next to
// the states (ACAD_LAYERFILTERS, ACLYDICTIONARY): they stay, in the dictionary CADCraft writes.
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r2, f, fr, gone) = (h(1), h(2), h(3), h(4), h(5), h(6));
// Two entries whose objects the file doesn't have (a handle of nothing, and a null one): they
// aren't written into the table's dictionary.
let extra = [("ACAD_LAYERFILTERS", f.as_str()), ("OTHER_GONE", gone.as_str()), ("OTHER_NULL", "0")];
let mut objects = dictionaries(&p, &x, &y, &[("S2", &r2)], &extra);
objects.extend(s2(&p, &r2, &y));
objects.extend([g("0", "DICTIONARY"), g("5", &f), g("102", "{ACAD_REACTORS"), g("330", &x), g("102", "}"), g("330", &x)]);
objects.extend([g("100", "AcDbDictionary"), g("281", "1"), g("3", "Walls"), g("350", &fr)]);
objects.extend([g("0", "XRECORD"), g("5", &fr), g("102", "{ACAD_REACTORS"), g("330", &f), g("102", "}"), g("330", &f), g("100", "AcDbXrecord")]);
objects.extend([g("280", "1"), g("1", "A*")]);
let file = inject(&base, &x, objects);
let mut text = file;
for round in 0..2 {
let d = read(text.as_bytes(), "f.dxf").unwrap();
assert_eq!(d.layer_states.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["S2"], "round {round}");
text = write_dxf(&d);
let p = pairs(&text);
let recs = records(&p);
let (_, table) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
let xdicts: Vec<String> = table.windows(2).filter(|w| w[0] == g("102", "{ACAD_XDICTIONARY")).map(|w| w[1].1.clone()).collect();
assert_eq!(xdicts.len(), 1, "round {round}");
let xd = &xdicts[0];
let (_, dict) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(xd.as_str())).unwrap();
let keys: Vec<&str> = dict.iter().filter(|(c, _)| c == "3").map(|(_, v)| v.as_str()).collect();
assert_eq!(keys, ["ACAD_LAYERSTATES", "ACAD_LAYERFILTERS"], "round {round}");
// The filters dictionary is owned by the written one, and so is its filter by it.
let fh = dict.windows(2).find(|w| w[0] == g("3", "ACAD_LAYERFILTERS")).map(|w| w[1].1.clone()).unwrap();
let (_, fd) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(fh.as_str())).unwrap();
let owner = fd.iter().filter(|(c, _)| c == "330").map(|(_, v)| v.as_str()).collect::<Vec<_>>();
assert_eq!(owner, [xd.as_str(), xd.as_str()], "round {round}: reactor and owner");
let walls = value(fd, "350").unwrap();
let (_, wr) = recs.iter().find(|(k, gs)| k == "XRECORD" && value(gs, "5") == Some(walls)).unwrap();
assert!(wr.contains(&g("330", &fh)) && wr.contains(&g("1", "A*")), "round {round}");
// The kept dictionary itself is not written a second time.
assert_eq!(recs.iter().filter(|(k, gs)| k == "DICTIONARY" && gs.iter().any(|(c, v)| c == "3" && v == "ACAD_LAYERFILTERS")).count(), 1);
}
// With every state deleted the filters stay, in the table's own dictionary, and AutoCAD's states
// don't come back.
let mut d = read(text.as_bytes(), "f.dxf").unwrap();
d.layer_states.clear();
let text = write_dxf(&d);
assert!(!text.contains("ACAD_LAYERSTATES"));
let p = pairs(&text);
let recs = records(&p);
let (_, table) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
let xd = table.windows(2).find(|w| w[0] == g("102", "{ACAD_XDICTIONARY")).map(|w| w[1].1.clone()).unwrap();
let (_, dict) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(xd.as_str())).unwrap();
assert_eq!(dict.iter().filter(|(c, _)| c == "3").map(|(_, v)| v.as_str()).collect::<Vec<_>>(), ["ACAD_LAYERFILTERS"]);
assert!(read(text.as_bytes(), "g.dxf").unwrap().layer_states.is_empty());
}
#[test]
fn entries_whose_names_differ_only_in_case_open_as_one_state() {
// AutoCAD 2024 opens the entries `S` and `s` of one ACAD_LAYERSTATES dictionary as one state:
// named as the first entry in the dictionary and holding the last entry's record (measured with
// the records in one file order and the entries in both dictionary orders, so the first entry's
// record came first in the file once and last once). Here S2's record (mask 2047) comes first in
// the file, then state T's, then S7's (66049); the merged state stays where S2's record is.
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r2, r7, rt) = (h(1), h(2), h(3), h(4), h(5));
let states = |d: &Drawing| d.layer_states.iter().map(|s| (s.name.clone(), s.mask)).collect::<Vec<_>>();
for (pair, name, mask) in [([("S", r2.as_str()), ("s", r7.as_str())], "S", 66049), ([("s", r7.as_str()), ("S", r2.as_str())], "s", 2047)] {
let entries = [pair[0], ("T", rt.as_str()), pair[1]];
let mut objects = dictionaries(&p, &x, &y, &entries, &[]);
objects.extend(s2(&p, &r2, &y));
objects.extend(s7(&p, &rt, &y));
objects.extend(s7(&p, &r7, &y));
let d = read(inject(&base, &x, objects).as_bytes(), "case.dxf").unwrap();
let want = [(name.to_string(), mask), ("T".to_string(), 66049)];
assert_eq!(states(&d), want, "{entries:?}");
// Written back, they are the states AutoCAD opened.
let back = read(write_dxf(&d).as_bytes(), "back.dxf").unwrap();
assert_eq!(states(&back), want, "{entries:?}");
}
// A record the dictionary lists as `s` but another object owns isn't a state, and doesn't stand
// in for S's record either.
let mut objects = dictionaries(&p, &x, &y, &[("S", r2.as_str()), ("s", r7.as_str())], &[]);
objects.extend(s2(&p, &r2, &y));
objects.extend(s7(&p, &r7, &x));
let d = read(inject(&base, &x, objects).as_bytes(), "stray.dxf").unwrap();
assert_eq!(states(&d), [("S".to_string(), 2047)]);
}
#[test]
fn view_snapshots_and_names_twice_in_another_case_stay_in_cadcrafts_record() {
let mut d = drawing();
for name in ["Plan", "*VIEW Front", "PLAN", "Wände", "WÄNDE", "", " "] {
d.layer_states.push(LayerState::new(name, d.layers.clone(), "A"));
}
let text = write_dxf(&d);
let p = pairs(&text);
let recs = records(&p);
let (_, states) =
recs.iter().find(|(k, gs)| k == "DICTIONARY" && gs.contains(&g("281", "1")) && gs.iter().any(|(c, v)| c == "3" && v == "Plan")).unwrap();
// (The DXF writes "ä" as \U+00E4.)
let keys: Vec<String> = states.iter().filter(|(c, _)| c == "3").map(|(_, v)| v.replace("\\U+00E4", "ä")).collect();
assert_eq!(keys, ["Plan", "Wände"], "AutoCAD's dictionary holds the first of each name");
assert!(text.contains("CADCRAFT_LAYERSTATES"));
let back = read(text.as_bytes(), "v.dxf").unwrap();
// AutoCAD's states first, then CADCraft's own.
// (A blank name can't be a key of AutoCAD's dictionary: those stay in CADCraft's record too.)
let want: Vec<LayerState> = [0, 3, 1, 2, 4, 5, 6].iter().map(|&i| d.layer_states[i].clone()).collect();
assert_eq!(back.layer_states, want);
#[cfg(not(target_arch = "wasm32"))]
{
let dwg = cadcraft_io::write(&d, "v.dwg").unwrap();
assert_eq!(read(&dwg, "v.dwg").unwrap().layer_states, want);
}
}
#[test]
fn a_layer_of_an_xref_gets_group_93() {
// AutoCAD 2024 writes 93 (0 for a newly attached xref) after the lineweight of an xref's layer
// only (measured with a self-built xref).
let mut d = drawing();
d.layers.push(Layer::new("XR|L1"));
d.layer_states.push(LayerState::new("X", d.layers.clone(), "0"));
let p = pairs(&write_dxf(&d));
let recs = records(&p);
let (_, rec) = recs.iter().find(|(k, gs)| k == "XRECORD" && gs.contains(&g("91", "2047"))).unwrap();
let start = rec.iter().position(|(c, _)| c == "302").unwrap() + 1;
let mut with_93 = Vec::new();
let mut layer = String::new();
for (i, (c, v)) in rec.iter().enumerate().skip(start) {
match c.as_str() {
"330" => layer.clone_from(v),
"93" => {
assert_eq!((v.as_str(), rec[i - 1].0.as_str(), rec[i + 1].0.as_str()), ("0", "370", "331"));
with_93.push(layer.clone());
}
_ => {}
}
}
assert_eq!(with_93, [record_handle(&p, "LAYER", "XR|L1")]);
}
#[test]
fn named_plot_styles_are_written_by_placeholder() {
// In a drawing of named plot styles AutoCAD 2024 writes a layer's plot style as group 390, the
// handle of the style's placeholder object (measured); CADCraft reads it back by that handle.
let mut d = drawing();
d.header.set_i64("PSTYLEMODE", 0);
let a = d.layers.iter().position(|l| l.name == "A").unwrap();
d.layers[a].plot_style = "Thick".into();
d.layer_states.push(LayerState::new("N", d.layers.clone(), "0"));
// No layer uses Thick any more: its placeholder is written for the state.
d.layers[a].plot_style = "Normal".into();
let text = write_dxf(&d);
let p = pairs(&text);
let recs = records(&p);
let (_, names) = recs.iter().find(|(k, _)| k == "ACDBDICTIONARYWDFLT").unwrap();
let thick = names.windows(2).find(|w| w[0] == g("3", "Thick")).map(|w| w[1].1.clone()).unwrap();
let (_, rec) = recs.iter().find(|(k, gs)| k == "XRECORD" && gs.contains(&g("91", "2047"))).unwrap();
assert!(rec.contains(&g("390", &thick)) && !rec.iter().any(|(c, _)| c == "1"), "{rec:?}");
let back = read(text.as_bytes(), "n.dxf").unwrap();
assert_eq!(back.layer_states[0].layers.iter().find(|l| l.name == "A").unwrap().plot_style, "Thick");
assert_eq!(back.layer_states, d.layer_states);
#[cfg(not(target_arch = "wasm32"))]
{
let dwg = cadcraft_io::write(&d, "n.dwg").unwrap();
assert_eq!(read(&dwg, "n.dwg").unwrap().layer_states, d.layer_states);
}
}
#[test]
fn a_state_in_both_records_is_read_from_autocads() {
// A file of an earlier CADCraft keeps its states in CADCraft's record; AutoCAD then saves a state
// of the same name in its own dictionary: AutoCAD's is the one read.
let mut d = drawing();
d.layer_states.push(LayerState::new("S", d.layers.clone(), "A"));
d.layer_states.push(LayerState::new("*VIEW S", d.layers.clone(), "B"));
let text = write_dxf(&d);
assert!(text.contains("*VIEW S"));
let text = text.replace("*VIEW S", "S");
let back = read(text.as_bytes(), "both.dxf").unwrap();
assert_eq!(back.layer_states.iter().map(|s| (s.name.as_str(), s.current.as_str())).collect::<Vec<_>>(), [("S", "A")]);
}
#[test]
fn states_past_the_limit_are_left_out_and_the_rest_come_in_file_order() {
// A hostile file with one state more than the reader keeps (100 000): the last one in the file
// is left out, and the others come in file order, here the reverse of their names' order.
const LIMIT: u64 = 100_000;
let base = write_dxf(&drawing());
let p = pairs(&base);
let first = u64::from_str_radix(&fresh(&p, 0), 16).unwrap();
let h = |k: u64| format!("{:X}", first + k);
let (x, y) = (h(1), h(2));
let names: Vec<String> = (0..=LIMIT).map(|i| format!("S{:06}", LIMIT + 1 - i)).collect();
let records: Vec<String> = (0..=LIMIT).map(|i| h(3 + i)).collect();
let entries: Vec<(&str, &str)> = names.iter().map(String::as_str).zip(records.iter().map(String::as_str)).collect();
let mut objects = dictionaries(&p, &x, &y, &entries, &[]);
for r in &records {
objects.extend([g("0", "XRECORD"), g("5", r), g("330", &y), g("100", "AcDbXrecord")]);
objects.extend([g("280", "1"), g("91", "2047"), g("301", ""), g("290", "0"), g("302", "0")]);
}
let d = read(inject(&base, &x, objects).as_bytes(), "many.dxf").unwrap();
let names: Vec<&str> = d.layer_states.iter().map(|s| s.name.as_str()).collect();
assert_eq!(names.len(), 100_000);
assert_eq!((names.first().copied(), names.get(1).copied(), names.last().copied()), (Some("S100001"), Some("S100000"), Some("S000002")));
}
#[test]
fn a_record_twice_in_a_file_is_one_state() {
// A damaged file can hold an object twice under one handle: one state.
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r7) = (h(1), h(2), h(4));
let mut objects = dictionaries(&p, &x, &y, &[("S7", &r7)], &[]);
objects.extend(s7(&p, &r7, &y));
objects.extend(s7(&p, &r7, &y));
let d = read(inject(&base, &x, objects).as_bytes(), "twice.dxf").unwrap();
assert_eq!(d.layer_states.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["S7"]);
}
#[test]
fn group_92_without_the_true_colour_prefix_is_not_a_true_colour() {
// AutoCAD 2024 writes 92 only for a true colour, 0xC2RRGGBB (measured); a value with another
// high byte (not seen from AutoCAD) leaves the colour index of group 62.
let text = autocad_file().replace("92\n-1039526882", "92\n-1023410175");
let d = read(text.as_bytes(), "c3.dxf").unwrap();
assert_eq!(d.layer_states[0].layers.iter().find(|l| l.name == "A").unwrap().color, Color::Index(168));
}
+1
View File
@@ -32,6 +32,7 @@ mod groups_roundtrip;
mod hatch_assoc_roundtrip;
mod hatch_pattern_def;
mod helix_roundtrip;
mod layer_states_acad;
mod layout_limits_roundtrip;
mod layout_paper_units;
mod layout_plot_window;
+1 -1
View File
@@ -185,7 +185,7 @@ pub(super) fn layer_states() -> Case {
layer.on = false;
layer.locked = true;
}
drawing.layer_states.push(LayerState { name: "Saved".into(), layers });
drawing.layer_states.push(LayerState::new("Saved", layers, "0"));
Case { name: "drawing/layer-state".into(), drawing }
}
+15 -5
View File
@@ -492,11 +492,16 @@ const OBJECTS: &str = "
330 61
100 AcDbXrecord
280 1
91 0
91 2047
301 Plan
8 WALLS
90 0
290 0
302 0
330 11
90 8
62 1
370 -3
1 Normal
440 0
0 DICTIONARY
5 63
330 10
@@ -803,14 +808,19 @@ fn ucs_layer_states_and_block_descriptions_are_kept() {
assert_eq!((u.origin.x, u.origin.y, u.origin.z), (1.0, 2.0, 3.0));
assert_eq!((u.x_axis.y, u.y_axis.x), (1.0, -1.0));
assert_eq!(d.block("DOOR").map(|b| b.description.as_str()), Some("A door leaf"));
let states: Vec<(&str, Vec<&str>)> =
d.layer_states.iter().map(|s| (s.name.as_str(), s.layers.iter().map(|l| l.name.as_str()).collect())).collect();
assert_eq!(states, [("Plan", vec!["WALLS"])]);
for o in [&a, &b] {
// Layer states live in the LAYER table's extension dictionary.
// Layer states live in the LAYER table's extension dictionary, each layer named by its
// handle (as AutoCAD 2024 writes them; CADCraft reads and rewrites them).
let table = o.of("TABLE").into_iter().find(|t| s(t, 2) == "LAYER").expect("LAYER table");
let [xd] = group(table, "ACAD_XDICTIONARY").try_into().expect("LAYER table extension dictionary");
let (_, dict) = o.handle(&xd).expect("dictionary");
let (_, states) = o.entry(dict, "ACAD_LAYERSTATES").expect("ACAD_LAYERSTATES");
let (_, plan) = o.entry(states, "Plan").expect("layer state Plan");
assert_eq!((s(plan, 301), s(plan, 8)), ("Plan".into(), "WALLS".into()));
let layers = plan.iter().skip_while(|t| t.code != 302).filter(|t| t.code == 330).map(Tag::str).collect::<Vec<_>>();
assert_eq!((s(plan, 301), layers), ("Plan".into(), vec![h(o.named("LAYER", "WALLS"))]));
}
}
+143 -207
View File
@@ -20,7 +20,6 @@ mod grid;
mod grips;
mod list;
mod pick;
mod press;
mod viewport;
mod widgets;
@@ -165,7 +164,7 @@ pub struct CanvasState {
/// A GRIP edit was running last frame (its grips go cold when it ends).
grip_editing: bool,
/// The grip whose menu (Stretch, Add Vertex, Lengthen…) a right-click opened.
pub(crate) grip_menu: Option<(Handle, usize)>,
grip_menu: Option<(Handle, usize)>,
/// Dynamic block grips of the selection (cached), the one being dragged, and the list grip
/// whose choices are open (and whether it opened this frame).
pub(crate) dyn_grips: crate::dyngrips::Cache,
@@ -182,8 +181,8 @@ pub struct CanvasState {
hover_frozen: Vec<String>,
/// Constraint glyphs for the parametric overlay (cached per drawing revision).
pub param: crate::parametric::Cache,
/// The primary-button press being held, when it was acted on (see [`press`]).
press: Option<press::Press>,
/// A selection window opened by a press-and-drag, to close where the button is let go.
drag_window: bool,
/// 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,
@@ -514,7 +513,13 @@ fn paint_content_highlights(frame: &mut CanvasPaint<'_>, bg: Rgb, sel: &[Handle]
}
}
fn paint_pointer_overlay(frame: &mut CanvasPaint<'_>, paper_rect: Option<Rect>, surround: Color32, sheet: Option<cadcraft_render::Sheet>) {
fn paint_pointer_overlay(
frame: &mut CanvasPaint<'_>,
paper_rect: Option<Rect>,
surround: Color32,
selecting: bool,
sheet: Option<cadcraft_render::Sheet>,
) {
let app = &mut *frame.app;
let ui = &mut *frame.ui;
let painter = frame.painter;
@@ -558,8 +563,7 @@ fn paint_pointer_overlay(frame: &mut CanvasPaint<'_>, paper_rect: Option<Rect>,
// Use the painted sheet even in MSPACE, where the editing transform follows a
// model viewport. The whole cursor takes one colour from its centre.
let ink = paper_rect.map_or(t.crosshair, |paper| crate::theme::crosshair_color(if paper.contains(hp) { t.paper } else { surround }));
let picking = app.session.picking_objects() && app.session.pending_window.is_none();
draw_crosshair(app, painter, rect, hp, picking, ink);
draw_crosshair(app, painter, rect, hp, selecting, ink);
if app.canvas.cycle_badge && app.canvas.cycle.is_none() {
cycle_badge(painter, hp);
}
@@ -607,12 +611,12 @@ fn handle_double_click(app: &mut CadApp, ctx: DoubleClickContext<'_>) -> Option<
if !in_active {
app.canvas.hot_grips.clear();
app.session.pending_window = None;
app.canvas.press = None;
app.canvas.drag_window = false;
if app.run("mspace", serde_json::json!({"at": [pp.x, pp.y]})).is_err() && active_viewport.is_some() {
let _ = app.run("pspace", serde_json::json!({}));
}
app.session.pending_window = None;
app.canvas.press = None;
app.canvas.drag_window = false;
app.canvas.list = None;
return None;
}
@@ -653,7 +657,43 @@ fn update_canvas_cursor(
) -> (Option<Vec2>, Option<crate::dyninput::Frame>) {
let raw_world = hover.filter(|_| inside).map(|p| xf.to_world(p));
let dyn_frame = crate::cmdline::dyn_frame(app);
track_cursor(app, raw_world, xf, ui.ctx(), dyn_frame);
if let Some(w) = raw_world {
let mut eff = effective_point(app, w, xf, ui.ctx());
// A locked Dynamic Input value (`40,` or `40<` typed) holds the cursor and overrides snaps.
if let Some(f) = dyn_frame
&& let Some(e) = crate::dyninput::parse(&app.cmd.buffer, &f)
&& e.first_locked().is_some()
{
eff = crate::dyninput::constrain(&e, &f, eff, app.cmd.second_locked());
app.canvas.snap = None;
app.canvas.track = None;
}
// Grip dimensional input: typed lengths and angles hold the grip and override snaps.
let grip_held = crate::grip_dyn::constrain(app, eff);
if let Some(q) = grip_held {
eff = q;
app.canvas.snap = None;
app.canvas.track = None;
}
app.canvas.cursor = Some(eff);
app.session.cursor = eff;
app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred);
// Typed or menu snap overrides (END, NON…) and Tab cycling; a locked Dynamic Input value wins.
if dyn_frame.and_then(|f| crate::dyninput::parse(&app.cmd.buffer, &f)).is_none_or(|e| e.first_locked().is_none()) {
override_cursor(app, w, xf);
}
// Typed grip dimensions win over snap overrides too.
if let Some(q) = grip_held {
app.canvas.cursor = Some(q);
app.session.cursor = q;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
} else {
app.canvas.cursor = None;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
(raw_world, dyn_frame)
}
@@ -703,91 +743,48 @@ fn update_hover(app: &mut CadApp, ui: &egui::Ui, inside: bool, hover_pos: Option
}
}
struct PressContext {
struct PromptClickContext<'a> {
rect: Rect,
xf: Xf,
inside: bool,
middle_down: bool,
mods: egui::Modifiers,
primary_clicked: bool,
response: &'a egui::Response,
}
/// Clicks count when the button goes down, where it went down, however fast the mouse moves
/// (#1001, #815): each press among this frame's events places its point, picks its object or sets a
/// selection window's corner at once. What the pointer does while the button is held only decides
/// whether the press becomes a drag ([`press`]): a drag closes the window its press opened where
/// the button comes up; after a click the window waits for the next press. A press on a grip
/// (idle) clicks the grip when the button comes up near it, however long it was held (#2813).
/// Presses while ZOOM Realtime runs are left to the clicks in [`show`]. Returns whether a press
/// handled here was released this frame (its click must not count again).
fn handle_presses(app: &mut CadApp, ui: &egui::Ui, context: &PressContext) -> bool {
let PressContext { rect, xf, inside, middle_down, mods } = *context;
let (steps, now, primary_down) = ui.input(|i| (press::steps(&i.events), i.time, i.pointer.primary_down()));
let mut click_used = false;
for step in steps {
match step {
press::Step::Down(pos, m) => {
app.canvas.press = None;
if !inside || !rect.contains(pos) || middle_down {
continue;
}
// A press on the Dynamic Input options menu is the menu's (picked on release);
// elsewhere it closes the menu and counts as usual.
if app.cmd.options.is_some() {
if app.cmd.option_at(pos).is_some() {
continue;
}
app.cmd.options = None;
}
// Selection cycling: the press picks a row of the open list, or opens the list over
// overlapping objects (#1149). Its release must not count again.
if cycle_click(app, &xf, Some(pos), Some(xf.to_world(pos)), m.shift) {
app.canvas.press = Some(press::Press::new(pos, false));
continue;
}
if press_takes(app, &xf, pos) {
let opened = press_at(app, &xf, ui.ctx(), pos, m);
app.canvas.press = Some(press::Press::new(pos, opened));
} else if !app.session.realtime_zoom_active() {
// A grip with no command running: clicked when the button comes up. egui
// calls a press held longer than 0.8 s a drag, and a slow drawing's frames
// can make an ordinary click that long (#2813).
app.canvas.press = Some(press::Press::on_grip(pos, m));
}
}
press::Step::Move(pos) => {
if let Some(p) = &mut app.canvas.press {
p.moved(pos, now);
}
}
press::Step::Up(pos) => {
let Some(mut p) = app.canvas.press.take() else { continue };
click_used = true;
if p.is_on_grip() {
if let Some((at, m)) = p.grip_click(pos) {
if let Some(g) = crate::dyngrips::at(app, &xf, Some(at)) {
crate::dyngrips::click(app, g);
} else if let Some(g) = grip_at(app, &xf, Some(at)) {
click_grip(app, g, m.shift);
}
}
continue;
}
// PICKDRAG off: a window takes two clicks, a drag doesn't close it (#1032).
if app.session.settings.pickdrag && p.released_as_drag(pos, now) && p.opened_window && app.session.pending_window.is_some() {
let end = xf.to_world(pos);
let done = if app.session.prompting() { app.session.input(Input::Point(end)) } else { app.session.idle_click(end, mods.shift) };
if let Err(e) = done {
app.session.echo(e.to_string());
}
fn collect_prompt_clicks(app: &mut CadApp, ui: &egui::Ui, context: PromptClickContext<'_>) -> bool {
// egui drops a click whose button comes up a few pixels from where it went down (a drag to it),
// and eframe hands a slow frame's clicks over together, which egui reports as one.
let point_prompt = app.session.current_prompt().is_some_and(|p| cadcraft_engine::pointmod::accepts(&p))
&& app.session.pending_window.is_none()
&& !app.session.realtime_zoom_active();
let pressed_primary = context.primary_clicked || (point_prompt && context.response.drag_stopped_by(egui::PointerButton::Primary));
if point_prompt && context.inside && pressed_primary && !context.middle_down && app.cmd.options.is_none() && app.cmd.buffer.is_empty() {
let releases: Vec<egui::Pos2> = ui.input(|i| {
i.events
.iter()
.filter_map(|e| match e {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, .. } => Some(*pos),
_ => None,
})
.collect()
});
// The last one is placed below, at the cursor, like any click.
if let Some((_, earlier)) = releases.split_last() {
for pos in earlier.iter().filter(|p| context.rect.contains(**p)) {
let w = effective_point(app, context.xf.to_world(*pos), &context.xf, ui.ctx());
let result = match app.canvas.snap {
Some(hit) => app.session.input_snapped(hit),
None => app.session.input(Input::Point(w)),
};
if let Err(e) = result {
app.session.echo(e.to_string());
}
}
}
}
if !primary_down {
// The button came up where we didn't see it (outside the window, say).
app.canvas.press = None;
}
click_used
pressed_primary
}
/// Whether a quick right-click cancels the running command instead of acting as Enter: it asks for
@@ -875,21 +872,8 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
return;
};
// Selection cycling's list closes when the prompt, the drawing or the view changes.
let key: CycleKey = (
app.session.running.as_ref().map(|r| r.id.clone()),
app.session.current_prompt().map(|p| p.message),
app.session.state().map_or(0, |st| st.uid),
app.session.state().map_or(0, |st| st.revision),
xf.center,
xf.scale,
);
if app.canvas.cycle_key.as_ref() != Some(&key) {
app.canvas.cycle = None;
app.canvas.hover_cycle = None;
app.canvas.cycle_key = Some(key);
}
let click_used = handle_presses(app, ui, &PressContext { rect, xf, inside, middle_down, mods });
let pressed_primary =
collect_prompt_clicks(app, ui, PromptClickContext { rect, xf, inside, middle_down, primary_clicked: pressed_primary, response: &resp });
let (raw_world, dyn_frame) = update_canvas_cursor(app, ui, &xf, inside, hover_pos);
@@ -909,14 +893,26 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
let idle_dbl = dbl_primary && app.session.running.is_none();
if idle_dbl {
app.session.pending_window = None;
app.canvas.press = None;
app.canvas.drag_window = false;
}
let pressed_primary = pressed_primary && !picked && !hatch_dialog && !idle_dbl;
let cycled = pressed_primary && !click_used && !middle_down && cycle_click(app, &xf, hover_pos, raw_world.filter(|_| inside), mods.shift);
// Clicks the presses above left alone: on grips, and during ZOOM Realtime.
let key: CycleKey = (
app.session.running.as_ref().map(|r| r.id.clone()),
app.session.current_prompt().map(|p| p.message),
app.session.state().map_or(0, |st| st.uid),
app.session.state().map_or(0, |st| st.revision),
xf.center,
xf.scale,
);
if app.canvas.cycle_key.as_ref() != Some(&key) {
app.canvas.cycle = None;
app.canvas.hover_cycle = None;
app.canvas.cycle_key = Some(key);
}
let cycled = pressed_primary && !middle_down && cycle_click(app, &xf, hover_pos, raw_world.filter(|_| inside), mods.shift);
// Clicks.
if inside
&& pressed_primary
&& !click_used
&& !middle_down
&& !cycled
&& let Some(p) = app.canvas.cursor
@@ -948,31 +944,58 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
app.session.echo(e.to_string());
}
}
// A quick right-click is Enter (the classic CAD default): it enters what was typed, ends the
// input of a running command, and between commands repeats the last one. Held, it opens the
// command menu or the shortcut menu (Repeat, Clipboard, …). Shift/Ctrl+right-click opens the
// object snap menu.
// Press-and-drag selection window (PICKDRAG = 2; click-click still works): a drag
// that starts while objects are being selected opens a window where the button went down,
// and letting go closes it. Drags on grips and drags while drawing are left alone.
if !app.session.settings.pickdrag {
app.canvas.drag_window = false;
}
if app.session.settings.pickdrag
&& resp.drag_started_by(egui::PointerButton::Primary)
&& !middle_down
&& app.canvas.cycle.is_none()
&& app.session.pending_window.is_none()
&& let Some(origin) = ui.input(|i| i.pointer.press_origin())
&& rect.contains(origin)
&& grip_at(app, &xf, Some(origin)).is_none()
&& crate::dyngrips::at(app, &xf, Some(origin)).is_none()
{
app.canvas.drag_window = app.session.begin_window(xf.to_world(origin));
}
if app.canvas.drag_window && resp.drag_stopped_by(egui::PointerButton::Primary) {
app.canvas.drag_window = false;
if app.session.pending_window.is_some()
&& let Some(end) = ui.input(|i| i.pointer.interact_pos())
{
let end = xf.to_world(end);
let done = if app.session.prompting() { app.session.input(Input::Point(end)) } else { app.session.idle_click(end, mods.shift) };
if let Err(e) = done {
app.session.echo(e.to_string());
}
}
}
// Right-click acts as Enter while a command runs (the classic CAD default; held, it opens the
// command menu); otherwise it opens the shortcut menu (Repeat, Clipboard, …).
// Shift/Ctrl+right-click opens the object snap menu.
let idle = !app.session.prompting();
if inside && pressed_secondary {
app.canvas.snap_menu = mods.shift || mods.ctrl;
}
if crate::context_menu::in_command(app, ui, inside, pressed_secondary) {
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 {
app.canvas.grip_menu = grip_at(app, &xf, hover_pos).filter(|g| !grip_options(app, *g).is_empty());
}
let enter = crate::context_menu::in_command(app, ui, inside, pressed_secondary);
if enter {
if right_click_cancels_placing(app) {
crate::cmdline::escape(app);
} else {
// As the Enter key does: what was typed (`rec`, `@10,0`), or Enter when nothing was.
crate::cmdline::submit(app);
}
}
crate::dyngrips::menu(app, ui.ctx(), &xf);
if idle && !app.canvas.snap_menu && app.canvas.grip_menu.is_some() {
grip_menu(app, &resp);
} else if (idle && !enter) || app.canvas.snap_menu {
} else if idle || app.canvas.snap_menu {
crate::context_menu::show(app, &resp);
}
@@ -998,95 +1021,6 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
});
}
/// Put the cursor at `raw` (world, `None` off the canvas): snaps, ortho and polar, a locked
/// Dynamic Input value and typed grip dimensions applied (`app.canvas.cursor`, `.snap`, `.track`).
fn track_cursor(app: &mut CadApp, raw: Option<Vec2>, xf: &Xf, ctx: &egui::Context, dyn_frame: Option<crate::dyninput::Frame>) {
if let Some(w) = raw {
let mut eff = effective_point(app, w, xf, ctx);
// A locked Dynamic Input value (`40,` or `40<` typed) holds the cursor and overrides snaps.
if let Some(f) = dyn_frame
&& let Some(e) = crate::dyninput::parse(&app.cmd.buffer, &f)
&& e.first_locked().is_some()
{
eff = crate::dyninput::constrain(&e, &f, eff, app.cmd.second_locked());
app.canvas.snap = None;
app.canvas.track = None;
}
// Grip dimensional input: typed lengths and angles hold the grip and override snaps.
let grip_held = crate::grip_dyn::constrain(app, eff);
if let Some(q) = grip_held {
eff = q;
app.canvas.snap = None;
app.canvas.track = None;
}
app.canvas.cursor = Some(eff);
app.session.cursor = eff;
app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred);
// Typed or menu snap overrides (END, NON…) and Tab cycling; a locked Dynamic Input value wins.
if dyn_frame.and_then(|f| crate::dyninput::parse(&app.cmd.buffer, &f)).is_none_or(|e| e.first_locked().is_none()) {
override_cursor(app, w, xf);
}
// Typed grip dimensions win over snap overrides too.
if let Some(q) = grip_held {
app.canvas.cursor = Some(q);
app.session.cursor = q;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
} else {
app.canvas.cursor = None;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
}
/// Whether the press at `pos` is acted on when the button goes down ([`press_at`]): at any prompt
/// and on the drawing with no command running. Grips (with no command running) and ZOOM Realtime
/// keep their clicks.
fn press_takes(app: &mut CadApp, xf: &Xf, pos: Pos2) -> bool {
if app.session.realtime_zoom_active() {
return false;
}
if app.session.prompting() {
return true;
}
crate::dyngrips::at(app, xf, Some(pos)).is_none() && grip_at(app, xf, Some(pos)).is_none()
}
/// Act on a press at `pos`: at a prompt the point goes in (snapped as the cursor would be there);
/// with no command running it picks the object there or sets a selection window's corner.
/// Returns whether the press opened a selection window.
fn press_at(app: &mut CadApp, xf: &Xf, ctx: &egui::Context, pos: Pos2, mods: egui::Modifiers) -> bool {
let had_window = app.session.pending_window.is_some();
let raw = xf.to_world(pos);
let dyn_frame = crate::cmdline::dyn_frame(app);
track_cursor(app, Some(raw), xf, ctx, dyn_frame);
let Some(p) = app.canvas.cursor else { return false };
if app.session.prompting() {
// Ctrl held while picking the point of a grip edit makes copies (the Copy option).
if mods.ctrl && app.session.running.as_ref().is_some_and(|r| r.id == "grip") {
let _ = app.session.input(Input::Keyword("Copy".into()));
}
// Clicking places the point; a value typed into the Dynamic Input boxes is used up.
if let Some(f) = dyn_frame
&& crate::dyninput::parse(&app.cmd.buffer, &f).is_some()
{
app.cmd.buffer.clear();
}
// Preserve a snap's viewport origin for DIST, and its deferred curve where needed.
let result = match app.canvas.snap {
Some(hit) => app.session.input_snapped(hit),
None => app.session.input(Input::Point(p)),
};
if let Err(e) = result {
app.session.echo(e.to_string());
}
} else if let Err(e) = app.session.idle_click(raw, mods.shift) {
app.session.echo(e.to_string());
}
!had_window && app.session.pending_window.is_some()
}
fn paint_canvas(frame: CanvasPaint<'_>) {
let CanvasPaint {
app,
@@ -1107,6 +1041,7 @@ fn paint_canvas(frame: CanvasPaint<'_>) {
raw_world,
} = frame;
let scale = xf.scale;
let selecting = app.session.previews_selection();
painter.rect_filled(rect, 0.0, t.canvas);
let t0 = crate::now_ms();
let mut views = vec![(xf_paper.world_bounds(), 1.0 / xf_paper.scale)];
@@ -1288,6 +1223,7 @@ fn paint_canvas(frame: CanvasPaint<'_>) {
},
paper_rect,
surround,
selecting,
sheet,
);
}
+12 -21
View File
@@ -212,37 +212,28 @@ pub(super) fn override_cursor(app: &mut CadApp, raw: Vec2, xf: &Xf) {
app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred);
}
/// Half the side of the pick box (`PICKBOX * 1.5` screen points), or `None` when `PICKBOX` is 0.
fn pickbox_half(pickbox: f64) -> Option<f32> {
let half = (pickbox * 1.5) as f32;
(half.is_finite() && half >= 1.0).then_some(half)
}
/// Draws the canvas cursor at `at`: the full crosshair with pickbox when idle, crosshair lines
/// only at point prompts, and the pickbox square alone at command object-selection prompts.
pub(super) fn draw_crosshair(app: &CadApp, p: &egui::Painter, rect: Rect, at: Pos2, pickbox: bool, ink: Color32) {
let st = Stroke::new(1.0, ink);
let len = (rect.height() * app.session.settings.cursorsize as f32 / 100.0).max(12.0);
let picking_in_cmd = pickbox && app.session.current_prompt().is_some_and(|pr| pr.picks_objects());
let pb = if pickbox { pickbox_half(app.session.settings.pickbox).or(picking_in_cmd.then_some(1.5)) } else { None };
let pb = if pickbox { pickbox_half(app.session.settings.pickbox) } else { None };
let gap = pb.unwrap_or(0.0);
// At a command prompt that selects objects, AutoCAD shows only the pickbox square (no
// crosshair lines); when idle or once a selection window corner is picked, the crosshair
// lines are drawn.
if !picking_in_cmd {
// Along the isometric plane's axes in isometric drafting.
if app.session.settings.isodraft {
for a in cadcraft_engine::snap::iso::cursor_axes(&app.session.settings) {
let dir = vec2(a.cos() as f32, -(a.sin() as f32));
p.line_segment([at - dir * len, at - dir * gap], st);
p.line_segment([at + dir * gap, at + dir * len], st);
}
} else {
p.line_segment([pos2(at.x - len, at.y), pos2(at.x - gap, at.y)], st);
p.line_segment([pos2(at.x + gap, at.y), pos2(at.x + len, at.y)], st);
p.line_segment([pos2(at.x, at.y - len), pos2(at.x, at.y - gap)], st);
p.line_segment([pos2(at.x, at.y + gap), pos2(at.x, at.y + len)], st);
// Along the isometric plane's axes in isometric drafting.
if app.session.settings.isodraft {
for a in cadcraft_engine::snap::iso::cursor_axes(&app.session.settings) {
let dir = vec2(a.cos() as f32, -(a.sin() as f32));
p.line_segment([at - dir * len, at - dir * gap], st);
p.line_segment([at + dir * gap, at + dir * len], st);
}
} else {
p.line_segment([pos2(at.x - len, at.y), pos2(at.x - gap, at.y)], st);
p.line_segment([pos2(at.x + gap, at.y), pos2(at.x + len, at.y)], st);
p.line_segment([pos2(at.x, at.y - len), pos2(at.x, at.y - gap)], st);
p.line_segment([pos2(at.x, at.y + gap), pos2(at.x, at.y + len)], st);
}
if let Some(pb) = pb {
p.rect_stroke(Rect::from_center_size(at, vec2(pb * 2.0, pb * 2.0)), 0.0, st, egui::StrokeKind::Middle);
-167
View File
@@ -1,167 +0,0 @@
//! Press-first clicks (#1001): a click on the canvas counts when the primary button goes down, at
//! the spot where it went down, however fast the mouse is moving. Where the pointer goes while the
//! button is held only decides whether the press also becomes a drag:
//!
//! - holding still, or staying within [`TOLERANCE`] of the press, never makes a drag;
//! - once the pointer leaves the tolerance a timer starts; a button still down [`DRAG_DELAY`]
//! later is a drag (a selection window the press opened closes where the button comes up);
//! - a button that comes up sooner was a click (the window waits for the next press).
//!
//! The timer starts on leaving the tolerance, not on the press: pressing, holding still and then
//! moving and letting go quickly is still a click, as in AutoCAD.
//!
//! A press on a grip with no command running ([`Press::on_grip`]) is the exception: the grip is
//! clicked when the button comes up within [`TOLERANCE`] of the press, however long it was held
//! (#2813), and a drag from it does nothing.
use egui::{Modifiers, Pos2};
/// How far (points) the pointer may wander from the press before the timer starts.
pub(crate) const TOLERANCE: f32 = 6.0;
/// How long (seconds) the button must stay down after the pointer left [`TOLERANCE`] for the
/// press to be a drag.
pub(crate) const DRAG_DELAY: f64 = 0.25;
/// A primary-button press being held.
#[derive(Clone, Copy, Debug)]
pub(crate) struct Press {
origin: Pos2,
/// When the pointer first went further than [`TOLERANCE`] from `origin` (seconds).
left_at: Option<f64>,
/// The press opened a selection window (set its first corner).
pub(crate) opened_window: bool,
/// The press went down on a grip with no command running, with these modifiers: it is a click
/// on the grip if the button comes up near it ([`Self::grip_click`]).
on_grip: Option<Modifiers>,
}
impl Press {
pub(crate) fn new(origin: Pos2, opened_window: bool) -> Self {
Self { origin, left_at: None, opened_window, on_grip: None }
}
/// A press on a grip with no command running, acted on when the button comes up.
pub(crate) fn on_grip(origin: Pos2, modifiers: Modifiers) -> Self {
Self { origin, left_at: None, opened_window: false, on_grip: Some(modifiers) }
}
/// For a press on a grip ([`Self::on_grip`]) whose button came up at `pos`: `Some` (where it
/// went down, the modifiers then) when that is a click on the grip, within [`TOLERANCE`] of the
/// press however long the button was held; `None` for a drag from it or a press elsewhere.
pub(crate) fn grip_click(&self, pos: Pos2) -> Option<(Pos2, Modifiers)> {
let modifiers = self.on_grip?;
(pos.distance(self.origin) <= TOLERANCE).then_some((self.origin, modifiers))
}
/// Whether the press went down on a grip ([`Self::on_grip`]).
pub(crate) fn is_on_grip(&self) -> bool {
self.on_grip.is_some()
}
/// The pointer is at `pos` at time `now`.
pub(crate) fn moved(&mut self, pos: Pos2, now: f64) {
if self.left_at.is_none() && pos.distance(self.origin) > TOLERANCE {
self.left_at = Some(now);
}
}
/// Whether the button coming up at `pos` at time `now` ends a drag rather than a click.
pub(crate) fn released_as_drag(&mut self, pos: Pos2, now: f64) -> bool {
self.moved(pos, now);
self.left_at.is_some_and(|t| now - t >= DRAG_DELAY)
}
}
/// A primary-button event of the frame, in order.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) enum Step {
Down(Pos2, Modifiers),
Move(Pos2),
Up(Pos2),
}
/// The primary-button presses, pointer moves and releases among a frame's events, in order. A slow
/// frame can hold several clicks; each press is its own step (#815).
pub(crate) fn steps(events: &[egui::Event]) -> Vec<Step> {
events
.iter()
.filter_map(|e| match *e {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, modifiers } => Some(Step::Down(pos, modifiers)),
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, .. } => Some(Step::Up(pos)),
egui::Event::PointerMoved(pos) => Some(Step::Move(pos)),
_ => None,
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use egui::pos2;
#[test]
fn staying_within_the_tolerance_is_a_click_however_long_the_button_is_held() {
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(104.0, 103.0), 0.5);
assert!(!p.released_as_drag(pos2(105.0, 100.0), 5.0));
}
#[test]
fn letting_go_soon_after_leaving_the_tolerance_is_a_click() {
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(112.0, 100.0), 1.0);
assert!(!p.released_as_drag(pos2(130.0, 100.0), 1.0 + DRAG_DELAY / 2.0));
}
#[test]
fn holding_still_then_moving_and_letting_go_quickly_is_a_click() {
// The timer starts when the pointer leaves the tolerance, not when the button goes down.
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(101.0, 100.0), 2.0);
assert!(!p.released_as_drag(pos2(140.0, 100.0), 2.05));
}
#[test]
fn a_button_still_down_after_the_delay_is_a_drag() {
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(110.0, 100.0), 1.0);
p.moved(pos2(200.0, 150.0), 1.1);
assert!(p.released_as_drag(pos2(250.0, 160.0), 1.0 + DRAG_DELAY));
}
#[test]
fn a_grip_press_is_a_click_where_it_went_down_only_when_let_go_near_it() {
let p = Press::on_grip(pos2(100.0, 100.0), Modifiers::SHIFT);
assert!(p.is_on_grip());
assert_eq!(p.grip_click(pos2(103.0, 104.0)), Some((pos2(100.0, 100.0), Modifiers::SHIFT)));
assert_eq!(p.grip_click(pos2(120.0, 100.0)), None, "a drag from the grip is no click");
let elsewhere = Press::new(pos2(100.0, 100.0), false);
assert!(!elsewhere.is_on_grip());
assert_eq!(elsewhere.grip_click(pos2(100.0, 100.0)), None);
}
#[test]
fn steps_keep_every_press_of_a_slow_frame_in_order() {
let at = |x| pos2(x, 10.0);
let button =
|x, pressed| egui::Event::PointerButton { pos: at(x), button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
let events = vec![
egui::Event::PointerMoved(at(1.0)),
button(1.0, true),
button(1.0, false),
egui::Event::PointerButton { pos: at(2.0), button: egui::PointerButton::Secondary, pressed: true, modifiers: Modifiers::NONE },
button(3.0, true),
button(3.0, false),
];
assert_eq!(
steps(&events),
vec![
Step::Move(at(1.0)),
Step::Down(at(1.0), Modifiers::NONE),
Step::Up(at(1.0)),
Step::Down(at(3.0), Modifiers::NONE),
Step::Up(at(3.0))
]
);
}
}
-60
View File
@@ -249,66 +249,6 @@ fn clicking_a_hot_grip_leaves_hidden_objects_out_of_the_stretch() {
assert_eq!(app.canvas.hot_grips, vec![(shown, 0)], "the hidden object's grip must leave the hot set");
}
/// Verifies that command object-selection prompts draw only the pickbox square while idle and
/// point prompts draw the crosshair lines.
#[test]
fn cursor_shows_pickbox_only_at_command_object_selection_prompts() {
let mut app = CadApp::new(cadcraft_engine::Session::new(), crate::Services::default());
let rect = Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
let at = pos2(400.0, 300.0);
let paint = |app: &CadApp| {
let ctx = egui::Context::default();
let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
let painter = ui.painter_at(rect);
let picking = app.session.picking_objects() && app.session.pending_window.is_none();
draw_crosshair(app, &painter, rect, at, picking, Color32::WHITE);
});
out.textures_delta.clear();
let mut lines = 0usize;
let mut rects = 0usize;
for clipped in &out.shapes {
match &clipped.shape {
Shape::LineSegment { .. } => lines += 1,
Shape::Rect(r) if r.rect.center() == at => rects += 1,
_ => {}
}
}
(lines, rects)
};
// 1. Idle with PICKFIRST on: crosshair lines (4 segments) + pickbox square (1 rect).
assert_eq!(paint(&app), (4, 1), "idle with PICKFIRST on");
// 2. Idle with SELECTIONPREVIEW = 0: pickbox still drawn while PICKFIRST is on.
app.session.settings.selectionpreview = 0;
assert_eq!(paint(&app), (4, 1), "idle with SELECTIONPREVIEW = 0");
app.session.settings.selectionpreview = 3;
// 3. Command asking for points (LINE): crosshair lines only (4 segments, 0 rects).
app.session.cmdline("line").unwrap();
assert_eq!(paint(&app), (4, 0), "point prompt (LINE)");
app.session.cancel();
// 4. Command asking to select objects (ERASE): pickbox square only (0 segments, 1 rect).
app.session.cmdline("erase").unwrap();
assert_eq!(paint(&app), (0, 1), "object selection prompt (ERASE)");
// 5. Even when PICKBOX = 0, a command object-selection prompt keeps a minimal visible pickbox.
app.session.settings.pickbox = 0.0;
assert_eq!(paint(&app), (0, 1), "object selection prompt with PICKBOX = 0");
app.session.settings.pickbox = 3.0;
// 6. While picking the second corner of a selection window, the crosshair lines return.
app.session.pending_window = Some(cadcraft_engine::PendingWindow { corner: Vec2::ZERO, during_command: true });
assert_eq!(paint(&app), (4, 0), "selection window second corner");
app.session.pending_window = None;
app.session.cancel();
// 7. STRETCH's "Remove objects" prompt also draws the pickbox-only cursor.
app.session.cmdline("stretch r").unwrap();
assert_eq!(paint(&app), (0, 1), "STRETCH Remove objects prompt");
}
/// Makes the layer "Hidden" and, on Layout1, two viewports over the model: the first freezes
/// "Hidden", the second freezes nothing. The app is left in paper space.
fn viewports_freezing_hidden(app: &mut CadApp) -> (String, String) {
+14 -26
View File
@@ -1,7 +1,6 @@
//! The canvas's right-click menus, after AutoCAD's shortcut menus:
//!
//! - **No command running** ([`entries`], opened by holding the button: a quick right-click is
//! Enter, which repeats the last command): Repeat the last command, Recent Commands, the
//! - **No command running** ([`entries`]): Repeat the last command, Recent Commands, the
//! Clipboard and Isolate; with a selection the editing commands, Draw Order, Group, the edit
//! commands of the selected object type, Select Similar and Deselect All; then Undo/Redo,
//! Pan/Zoom, Quick Select, Find, Properties and Options.
@@ -11,8 +10,8 @@
//! Preferences ▸ Right-Click Customization sets how long, `rightClickDuration`). With that turned
//! off (`timeSensitiveRightClick`), Command mode says what a right-click does
//! (`rightClickCommand`: the menu, Enter, or the menu only when the prompt has options).
//! With it off, `rightClickDefault` and `rightClickEdit` can make a right-click with no command
//! running repeat the last command instead of opening the menu.
//! `rightClickDefault` and `rightClickEdit` can make a right-click with no command running
//! repeat the last command instead of opening the menu.
//! - **Shift/Ctrl+right-click** ([`snap_entries`]): the object snap menu. Its items type the point
//! modifiers and snap overrides (`_from`, `_endp`, `_non`…) at the current point prompt.
//!
@@ -388,16 +387,13 @@ pub fn groups_ui(ui: &mut egui::Ui, groups: &[Vec<Entry>], clicked: &mut Option<
pub fn show(app: &mut CadApp, resp: &egui::Response) {
let mut clicked = None;
let snap = app.canvas.snap_menu;
// Right-Click Customization: with the time-sensitive right-click off and nothing selected
// (Default mode) or a selection (Edit mode), a right-click may repeat the last command instead
// of opening the menu. With no last command yet, it opens the menu. With the time-sensitive
// right-click on, a quick click is already Enter ([`in_command`]) and a longer one is this
// menu, as in AutoCAD.
// Right-Click Customization: with nothing selected (Default mode) or a selection (Edit mode),
// a right-click may repeat the last command instead of opening the menu. With no last command
// yet, it opens the menu.
let o = &app.options;
let mode =
if o.right_click_default == o.right_click_edit || app.session.selection().is_empty() { o.right_click_default } else { o.right_click_edit };
if !snap
&& !o.time_sensitive_right_click
&& mode == crate::options::IdleClick::Repeat
&& let Some(last) = app.session.last_command.clone()
{
@@ -421,15 +417,13 @@ pub fn show(app: &mut CadApp, resp: &egui::Response) {
#[derive(Clone, Copy, Default)]
struct Press(f64, egui::Pos2);
/// The canvas's right button (Shift/Ctrl+right-click is the snap menu's). With the time-sensitive
/// right-click on, a quick click is Enter — returns `true` when the caller should send it; between
/// commands that runs what was typed or repeats the last command — and while a command runs a
/// click held for OPTIONS `rightClickDuration` opens the command menu ([`command_entries`]) at the
/// pointer (between commands a held click is left to the caller's shortcut menu). With it turned
/// off, `rightClickCommand` says whether a click while a command runs opens the menu or is Enter,
/// and between commands the caller follows `rightClickDefault` and `rightClickEdit`. Call it every
/// frame with whether the pointer is on the canvas and whether a right-click ended there; it also
/// shows the menu while it is open.
/// The canvas's right button while a command runs (Shift/Ctrl+right-click is the snap menu's): a
/// quick click is Enter — returns `true` when the caller should send it — and a click held for
/// OPTIONS `rightClickDuration` opens the command menu ([`command_entries`]) at the pointer. With
/// the time-sensitive right-click turned off, `rightClickCommand` says whether a click opens the
/// menu or is Enter. Call it every frame
/// with whether the pointer is on the canvas and whether a right-click ended there; it also shows
/// the menu while it is open.
pub fn in_command(app: &mut CadApp, ui: &egui::Ui, inside: bool, right_clicked: bool) -> bool {
let ctx = ui.ctx().clone();
let press_id = egui::Id::unique("cc_command_menu_press");
@@ -454,21 +448,15 @@ pub fn in_command(app: &mut CadApp, ui: &egui::Ui, inside: bool, right_clicked:
};
let hold = f64::from(o.right_click_hold_ms) / 1000.0;
let mut open = false;
let mut quick = false;
if released && let Some(Press(t0, p0)) = ctx.data_mut(|d| d.remove_temp::<Press>(press_id)) {
// A drag isn't a click; a click held long enough asks for the menu.
let still = pos.is_some_and(|p| p.distance(p0) <= 6.0);
let held = if timed { now - t0 >= hold } else { menu };
open = running && still && held;
quick = !held;
}
let enter = running && inside && right_clicked && !open && (timed || !menu);
if !running {
// Between commands a quick click is Enter too (as in AutoCAD): it runs the typed command,
// or repeats the last one; held, it opens the shortcut menu. A grip with options keeps
// its menu.
let something = !app.cmd.buffer.trim().is_empty() || app.session.last_command.is_some();
return timed && quick && inside && right_clicked && !app.canvas.snap_menu && app.canvas.grip_menu.is_none() && something;
return false;
}
let mut clicked = None;
let popup = egui::Popup::new(popup_id, ctx, egui::PopupAnchor::PointerFixed, ui.layer_id())
+5 -8
View File
@@ -16,9 +16,9 @@
//! | `SAVETIME` | minutes between automatic saves, 0–600 (0: off) |
//! | `SAVEFILEPATH` | the folder automatic saves go to |
//! | `ISAVEBAK` | 1: saving over a drawing keeps the previous file as `<name>.bak` (default); 0: no backup |
//! | `timeSensitiveRightClick` | a quick right-click is Enter (between commands it runs what was typed, or repeats the last command) and holding the button opens the shortcut menu (default); `false`: `rightClickCommand` decides while a command runs, `rightClickDefault` and `rightClickEdit` between commands |
//! | `timeSensitiveRightClick` | while a command runs, a quick right-click is Enter and holding the button opens the shortcut menu (default); `false`: `rightClickCommand` decides |
//! | `rightClickDuration` | how long the right button is held to open the menu while a command runs, 100–2000 ms (250) |
//! | `rightClickDefault`, `rightClickEdit` | with the time-sensitive right-click off, a right-click with no command running and nothing (`Default`) or something (`Edit`) selected: `"menu"` (the shortcut menu, default) or `"repeat"` (the last command) |
//! | `rightClickDefault`, `rightClickEdit` | a right-click with no command running and nothing (`Default`) or something (`Edit`) selected: `"menu"` (the shortcut menu, default) or `"repeat"` (the last command) |
//! | `rightClickCommand` | a right-click while a command runs, with the time-sensitive right-click off: `"menu"` (default), `"enter"`, or `"menuWithOptions"` (the menu when the prompt has options, else Enter) |
//! | `systemCursor` | keep the system cursor visible over the drawing area |
//! | `historyLines` | command-line history lines, 0–12 |
@@ -139,16 +139,13 @@ pub struct UiOptions {
pub snap_marker_size: f32,
/// The selection highlight colour; `None` keeps the theme's.
pub selection_color: Option<Color32>,
/// A quick right-click is Enter and a held one opens the shortcut menu (AutoCAD's
/// time-sensitive right-click). Between commands that Enter runs what was typed, or repeats
/// the last command; with neither, the click opens the shortcut menu. Off:
/// [`Self::right_click_command`] decides while a command runs, and [`Self::right_click_default`]
/// and [`Self::right_click_edit`] between commands.
/// While a command runs: a quick right-click is Enter and a held one opens the shortcut menu
/// (AutoCAD's time-sensitive right-click). Off: [`Self::right_click_command`] decides.
pub time_sensitive_right_click: bool,
/// How long the right button is held to open the menu while a command runs, in milliseconds.
pub right_click_hold_ms: u32,
/// A right-click with no command running and nothing selected (Default mode) or a selection
/// (Edit mode), with the time-sensitive right-click off.
/// (Edit mode).
pub right_click_default: IdleClick,
pub right_click_edit: IdleClick,
/// A right-click while a command runs, with the time-sensitive right-click off.
+14 -26
View File
@@ -615,35 +615,23 @@ fn right_click_window(o: &super::UiOptions, ctx: &egui::Context, open: &mut bool
ui.label(crate::tl!("milliseconds"));
});
hint(ui, crate::tl!("While a command runs, a quick click is Enter and a longer click opens the shortcut menu."));
hint(ui, crate::tl!("With no command running, a quick click repeats the last command or runs what was typed."));
});
ui.add_space(6.0);
// Like Command mode, Default and Edit modes decide only with the time-sensitive
// right-click off: with it on, a quick click is Enter and a longer one the menu.
ui.add_enabled_ui(!o.time_sensitive_right_click, |ui| {
for (title, note, key, current) in [
(
crate::tl!("Default Mode"),
crate::tl!("No objects selected and no command running:"),
"rightClickDefault",
o.right_click_default,
),
(crate::tl!("Edit Mode"), crate::tl!("Objects selected and no command running:"), "rightClickEdit", o.right_click_edit),
] {
heading(ui, title);
ui.group(|ui| {
ui.set_width(ui.available_width());
hint(ui, note);
for (choice, label) in
[(IdleClick::Repeat, crate::tl!("Repeat last command")), (IdleClick::Menu, crate::tl!("Shortcut Menu"))]
{
if ui.radio(current == choice, label).clicked() && current != choice {
changes.insert(key.into(), json!(choice.as_str()));
}
for (title, note, key, current) in [
(crate::tl!("Default Mode"), crate::tl!("No objects selected and no command running:"), "rightClickDefault", o.right_click_default),
(crate::tl!("Edit Mode"), crate::tl!("Objects selected and no command running:"), "rightClickEdit", o.right_click_edit),
] {
heading(ui, title);
ui.group(|ui| {
ui.set_width(ui.available_width());
hint(ui, note);
for (choice, label) in [(IdleClick::Repeat, crate::tl!("Repeat last command")), (IdleClick::Menu, crate::tl!("Shortcut Menu"))] {
if ui.radio(current == choice, label).clicked() && current != choice {
changes.insert(key.into(), json!(choice.as_str()));
}
});
}
});
}
});
}
ui.add_enabled_ui(!o.time_sensitive_right_click, |ui| {
heading(ui, crate::tl!("Command Mode"));
ui.group(|ui| {
-38
View File
@@ -240,42 +240,4 @@ fn time_sensitive_right_click() {
painted(&mut app, &ctx, Vec::new(), 3.1);
assert!(app.session.running.is_none(), "a quick right-click is Enter: {}", app.session.prompt_text());
assert_eq!(app.session.doc().unwrap().model.handles().len(), 1);
// Between commands a quick right-click is Enter too: it repeats LINE (it opened the shortcut
// menu instead).
painted(&mut app, &ctx, vec![quick(true)], 4.0);
painted(&mut app, &ctx, vec![quick(false)], 4.05);
let text = painted(&mut app, &ctx, Vec::new(), 4.1);
assert!(app.session.running.is_some(), "a quick right-click repeats LINE: {}", app.session.prompt_text());
assert!(!text.contains("Repeat LINE"), "no shortcut menu on a quick click:\n{text}");
app.session.input(cadcraft_engine::Input::Cancel).unwrap();
// Held, it opens the shortcut menu and repeats nothing.
painted(&mut app, &ctx, vec![quick(true)], 5.0);
painted(&mut app, &ctx, Vec::new(), 5.2);
painted(&mut app, &ctx, vec![quick(false)], 5.0 + context_menu::HOLD_SECS + 0.1);
let text = painted(&mut app, &ctx, Vec::new(), 5.5);
assert!(text.contains("Repeat LINE"), "Repeat LINE missing from the painted menu:\n{text}");
assert!(app.session.running.is_none(), "held, no repeat: {}", app.session.prompt_text());
// A quick click enters what was typed, as the Enter key does (#1387): a command name between
// commands (not a repeat of LINE)…
painted(
&mut app,
&ctx,
vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }],
5.6,
);
// The menu closes on the frame after Escape.
painted(&mut app, &ctx, Vec::new(), 5.7);
app.cmd.buffer = "circle".into();
painted(&mut app, &ctx, vec![quick(true)], 6.0);
painted(&mut app, &ctx, vec![quick(false)], 6.05);
painted(&mut app, &ctx, Vec::new(), 6.1);
assert!(app.session.prompt_text().contains("center point"), "the typed CIRCLE starts: {}", app.session.prompt_text());
// …and a point while a command runs.
app.cmd.buffer = "5,5".into();
painted(&mut app, &ctx, vec![quick(true)], 7.0);
painted(&mut app, &ctx, vec![quick(false)], 7.05);
painted(&mut app, &ctx, Vec::new(), 7.1);
assert!(app.session.prompt_text().contains("radius"), "the typed center is entered: {}", app.session.prompt_text());
}
-4
View File
@@ -21,7 +21,6 @@ mod instant_modals;
mod lisp_files;
mod measure_distance_snapping;
mod menubar_hover;
mod moving_clicks;
mod mspace_viewport_view;
mod named_viewports_dialog;
mod native_menu_text_keys;
@@ -30,7 +29,6 @@ mod options_dialog;
mod options_right_click;
mod parameters_rename;
mod pickdrag;
mod press_first_clicks;
mod properties_described;
mod properties_units;
mod rapid_clicks;
@@ -38,8 +36,6 @@ mod selection_cycling;
mod shared_controls;
mod shortcut_menus;
mod shortcuts_checked;
mod slow_clicks;
mod space_at_options;
mod status_bar_toggles;
mod style_dialogs;
mod system_cursor;
-183
View File
@@ -1,183 +0,0 @@
//! A click made while the mouse moves counts where the button went down, in the commands #1001
//! names (STRETCH, MOVE, TRIM), with no command running, with PICKDRAG off, at a click-click
//! window's second corner and over overlapping objects (selection cycling).
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Drawing, EntityKind, Space};
use cadcraft_engine::geom::Vec2;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use serde_json::json;
fn screen(h: &Harness<'_, CadApp>, p: Vec2) -> Pos2 {
h.state().canvas.xf.unwrap().to_screen(p)
}
fn button(h: &mut Harness<'_, CadApp>, pos: Pos2, pressed: bool) {
h.event(Event::PointerMoved(pos));
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
fn lines(h: &Harness<'_, CadApp>) -> Vec<(Vec2, Vec2)> {
let st = h.state().session.state().unwrap();
st.doc
.space(&Space::Model)
.unwrap()
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Line(l) => Some((l.a.xy(), l.b.xy())),
_ => None,
})
.collect()
}
/// A harness at 60 frames a second, with two lines to select: a horizontal one through (20, 50)
/// and (40, 50), and a vertical one at x = 80.
fn select_harness() -> Harness<'static, CadApp> {
let mut session = Session::empty();
session.open_drawing(Drawing::new_imperial(), "Moving clicks", None);
session.execute("view.set", &json!({"center":[50,50],"height":100})).unwrap();
session.settings.osmode = 0;
session.execute("line", &json!({"points": [[20, 50], [40, 50]]})).unwrap();
session.execute("line", &json!({"points": [[80, 30], [80, 70]]})).unwrap();
let mut app = CadApp::new(session, Services::default());
app.canvas.zoom_pending = false;
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(5);
h
}
/// Press at `down`, move on (the hand is already going somewhere) and let go at `up`, `frames`
/// frames later.
fn press_moving(h: &mut Harness<'_, CadApp>, down: Vec2, up: Vec2, frames: usize) {
let (d, u) = (screen(h, down), screen(h, up));
button(h, d, true);
h.run_steps(1);
for i in 1..=frames {
let t = i as f32 / frames as f32;
h.event(Event::PointerMoved(d + (u - d) * t));
h.run_steps(1);
}
button(h, u, false);
h.run_steps(2);
}
fn handles(h: &Harness<'_, CadApp>) -> Vec<cadcraft_engine::doc::Handle> {
let st = h.state().session.state().unwrap();
st.doc.space(&Space::Model).unwrap().iter().map(|e| e.handle).collect()
}
/// #1001: in STRETCH (whose "Select objects" takes points), a click made while the mouse moves
/// picks the object where the button went down; on empty space it starts STRETCH's window.
#[test]
fn a_click_made_while_moving_selects_in_stretch() {
let mut h = select_harness();
let ids = handles(&h);
h.state_mut().start("stretch");
h.run_steps(2);
// Down on the horizontal line, up a few units off it, a few frames later.
press_moving(&mut h, Vec2::new(30.0, 50.0), Vec2::new(32.0, 54.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[0]], "the line under the button is picked");
// Down on empty space while moving: the window starts where the button went down.
press_moving(&mut h, Vec2::new(70.0, 20.0), Vec2::new(72.0, 22.0), 4);
assert_eq!(h.state().session.current_prompt().unwrap().message, "Specify opposite corner");
let corner = screen(&h, Vec2::new(90.0, 80.0));
button(&mut h, corner, true);
h.run_steps(1);
button(&mut h, corner, false);
h.run_steps(2);
assert_eq!(h.state().session.selection(), vec![ids[0], ids[1]], "the window took the vertical line");
}
/// At a generic "Select objects" (MOVE), a moving click picks the object where the button went
/// down instead of closing a tiny window; a slow press-and-drag is still a window.
#[test]
fn a_click_made_while_moving_selects_in_move_and_a_slow_drag_is_a_window() {
let mut h = select_harness();
let ids = handles(&h);
h.state_mut().start("move");
h.run_steps(2);
press_moving(&mut h, Vec2::new(30.0, 50.0), Vec2::new(32.0, 54.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[0]]);
assert!(h.state().session.pending_window.is_none());
// Half a second from (70, 20) to (90, 80): a window around the vertical line.
press_moving(&mut h, Vec2::new(70.0, 20.0), Vec2::new(90.0, 80.0), 30);
assert!(h.state().session.pending_window.is_none(), "closed where the drag ended");
assert_eq!(h.state().session.selection(), vec![ids[0], ids[1]]);
}
/// With no command running, the same moving click picks the object.
#[test]
fn a_click_made_while_moving_picks_with_no_command() {
let mut h = select_harness();
let ids = handles(&h);
press_moving(&mut h, Vec2::new(80.0, 40.0), Vec2::new(83.0, 41.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[1]]);
}
/// A click-click window already open: its second corner, clicked while moving, closes it where the
/// button went down instead of being lost to the drag egui saw.
#[test]
fn a_click_made_while_moving_closes_a_click_click_window() {
let mut h = select_harness();
let ids = handles(&h);
let corner = screen(&h, Vec2::new(70.0, 20.0));
button(&mut h, corner, true);
h.run_steps(1);
button(&mut h, corner, false);
h.run_steps(2);
assert!(h.state().session.pending_window.is_some(), "the click on empty space opened a window");
press_moving(&mut h, Vec2::new(90.0, 80.0), Vec2::new(92.0, 82.0), 4);
assert!(h.state().session.pending_window.is_none(), "the moving click closed the window");
assert_eq!(h.state().session.selection(), vec![ids[1]], "the window took the vertical line");
}
/// With PICKDRAG 0 no drag opens a window, and a click made while moving still picks the object.
#[test]
fn a_click_made_while_moving_picks_with_pickdrag_off() {
let mut h = select_harness();
let ids = handles(&h);
h.state_mut().session.settings.pickdrag = false;
press_moving(&mut h, Vec2::new(80.0, 40.0), Vec2::new(83.0, 41.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[1]]);
assert!(h.state().session.pending_window.is_none());
}
/// TRIM's "Select object to trim": a click made while moving trims the part the button went down
/// on.
#[test]
fn a_click_made_while_moving_trims_in_trim() {
let mut h = select_harness();
// A vertical cutting edge through the horizontal line, at x = 30.
h.state_mut().session.execute("line", &json!({"points": [[30, 40], [30, 60]]})).unwrap();
h.state_mut().start("trim");
h.run_steps(2);
press_moving(&mut h, Vec2::new(36.0, 50.0), Vec2::new(39.0, 56.0), 4);
let got = lines(&h);
assert!(
got.iter().any(|(a, b)| a.near(Vec2::new(20.0, 50.0), 1e-6) && b.near(Vec2::new(30.0, 50.0), 1e-6)),
"the right part of the horizontal line was trimmed: {got:?}"
);
}
/// With SELECTIONCYCLING 2, a click made while moving over overlapping objects opens selection
/// cycling's list, as a still click does, instead of picking one of them.
#[test]
fn a_click_made_while_moving_over_overlapping_objects_lists_them() {
let mut h = select_harness();
h.state_mut().session.execute("line", &json!({"points": [[20, 50], [60, 50]]})).unwrap();
h.state_mut().session.execute("setvar", &json!({ "name": "SELECTIONCYCLING", "value": 2 })).unwrap();
h.state_mut().session.set_selection(Vec::new());
h.run_steps(2);
press_moving(&mut h, Vec2::new(30.0, 50.0), Vec2::new(32.0, 54.0), 4);
assert_eq!(h.state().canvas.cycle_rows().len(), 2, "both lines are listed");
assert!(h.state().session.selection().is_empty(), "nothing is picked until a row is chosen");
}
+5 -28
View File
@@ -99,7 +99,7 @@ fn right_click_settings_are_checked_and_survive_a_restart() {
#[test]
fn an_idle_right_click_can_repeat_the_last_command() {
let mut a = app();
a.run("options", json!({"timeSensitiveRightClick": false, "rightClickDefault": "repeat"})).unwrap();
a.run("options", json!({"rightClickDefault": "repeat"})).unwrap();
a.cmdline("circle 0,0 5");
assert!(!a.session.prompting());
let ctx = egui::Context::default();
@@ -116,22 +116,6 @@ fn an_idle_right_click_can_repeat_the_last_command() {
assert!(text.contains("Erase"), "the shortcut menu opens:\n{text}");
}
/// With the time-sensitive right-click on (the default), Default and Edit modes don't decide, as
/// in AutoCAD: a quick click is Enter (#1387) and a longer one opens the shortcut menu, even with
/// both set to repeat the last command.
#[test]
fn the_time_sensitive_right_click_decides_between_commands_too() {
let mut a = app();
a.run("options", json!({"rightClickDefault": "repeat", "rightClickEdit": "repeat"})).unwrap();
a.cmdline("circle 0,0 5");
assert!(!a.session.prompting());
let ctx = egui::Context::default();
frame(&mut a, &ctx, Vec::new(), 0.0);
let text = right_click(&mut a, &ctx, 0.1, 0.4);
assert!(!a.session.prompting(), "a longer click repeats nothing: {}", a.session.prompt_text());
assert!(text.contains("Repeat CIRCLE"), "the shortcut menu opens:\n{text}");
}
#[test]
fn command_mode_and_click_duration_decide_enter_or_the_menu() {
let ctx = egui::Context::default();
@@ -198,17 +182,6 @@ fn the_customization_window_sets_every_mode() {
h.get_by_label("Longer click duration:");
shot(&mut h, "options-right-click.png");
// Default, Edit and Command modes apply once the time-sensitive right-click is off; with it
// on, Default mode's choice can't be made.
if let Some(n) = h.get_all_by_label("Repeat last command").next() {
n.click();
}
h.run_steps(3);
assert_eq!(h.state().options.right_click_default, IdleClick::Menu);
h.get_by_label("Turn on time-sensitive right-click").click();
h.run_steps(3);
assert!(!h.state().options.time_sensitive_right_click);
// Default mode's "Repeat last command" comes first, Edit mode's second.
if let Some(n) = h.get_all_by_label("Repeat last command").next() {
n.click();
@@ -217,6 +190,10 @@ fn the_customization_window_sets_every_mode() {
assert_eq!(h.state().options.right_click_default, IdleClick::Repeat);
assert_eq!(h.state().options.right_click_edit, IdleClick::Menu);
// Command mode applies once the time-sensitive right-click is off.
h.get_by_label("Turn on time-sensitive right-click").click();
h.run_steps(3);
assert!(!h.state().options.time_sensitive_right_click);
h.get_by_label("Shortcut Menu: enabled when command options are present").click();
h.run_steps(3);
assert_eq!(h.state().options.right_click_command, CommandClick::MenuWithOptions);
+7 -5
View File
@@ -83,11 +83,13 @@ fn drag_is_disabled_but_two_clicks_still_complete_the_window() {
button(&mut h, a, true);
button(&mut h, a, false);
assert!(h.state().session.pending_window.is_some());
// The second corner is where the button goes down (#1001): a drag on from there, let go
// elsewhere, changes nothing.
h.run_steps(30); // Separate deliberate clicks from the double-click interval.
let away = xf.to_screen(Vec2::new(30.0, 8.0));
drag(&mut h, b, away);
// A held-button movement after the first click must not consume the second corner.
drag(&mut h, a, b);
assert!(h.state().session.pending_window.is_some());
assert!(h.state().session.selection().is_empty());
h.run_steps(30); // Separate deliberate clicks from egui's double-click interval.
button(&mut h, b, true);
button(&mut h, b, false);
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
@@ -1,189 +0,0 @@
//! Press-first clicks (#1001): a click counts when the button goes down, where it went down, even
//! while the mouse is moving; holding the button after the pointer left a small tolerance makes a
//! drag. The harness runs at 60 frames a second and each queued event is one frame, so the number
//! of moves between press and release is how long the button was held.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Drawing, EntityKind, Space};
use cadcraft_engine::geom::Vec2;
use cadcraft_engine::prompt::Input;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use serde_json::json;
fn harness() -> Harness<'static, CadApp> {
let mut session = Session::empty();
session.open_drawing(Drawing::new_imperial(), "Press first", None);
session.execute("view.set", &json!({"center":[50,50],"height":100})).unwrap();
session.settings.osmode = 0;
session.settings.snapmode = false;
session.settings.orthomode = false;
session.execute("line", &json!({"points": [[20, 20], [60, 20]]})).unwrap();
let mut app = CadApp::new(session, Services::default());
app.canvas.zoom_pending = false;
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(5);
h
}
fn screen(h: &Harness<'_, CadApp>, p: Vec2) -> Pos2 {
h.state().canvas.xf.unwrap().to_screen(p)
}
fn button(h: &mut Harness<'_, CadApp>, pos: Pos2, pressed: bool) {
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
/// Press at `at`, then move `dx` points to the right over `frames` frames and let go there.
fn moving_click(h: &mut Harness<'_, CadApp>, at: Pos2, dx: f32, frames: usize) {
h.event(Event::PointerMoved(at));
button(h, at, true);
for i in 1..=frames {
h.event(Event::PointerMoved(at + vec2(dx * i as f32 / frames as f32, 0.0)));
}
button(h, at + vec2(dx, 0.0), false);
h.run_steps(2);
}
/// A click that moves 15 points while the button is down, let go within two frames.
fn quick_moving_click(h: &mut Harness<'_, CadApp>, at: Vec2) {
let pos = screen(h, at);
moving_click(h, pos, 15.0, 2);
}
fn start(h: &mut Harness<'_, CadApp>, id: &str) {
h.state_mut().start(id);
h.run_steps(2);
assert_eq!(h.state().session.running.as_ref().map(|r| r.id.as_str()), Some(id));
}
fn enter(h: &mut Harness<'_, CadApp>) {
h.state_mut().session.input(Input::Enter).unwrap();
h.run_steps(2);
}
fn lines(h: &Harness<'_, CadApp>) -> Vec<(Vec2, Vec2)> {
let st = h.state().session.state().unwrap();
st.doc
.space(&Space::Model)
.unwrap()
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Line(l) => Some((l.a.xy(), l.b.xy())),
_ => None,
})
.collect()
}
#[test]
fn move_takes_the_base_and_second_point_where_the_button_went_down() {
let mut h = harness();
start(&mut h, "move");
quick_moving_click(&mut h, Vec2::new(40.0, 20.0));
enter(&mut h);
// Base point and second point, both clicked on the move: 15 points is 1.5 drawing units here.
quick_moving_click(&mut h, Vec2::new(30.0, 40.0));
quick_moving_click(&mut h, Vec2::new(50.0, 40.0));
let got = lines(&h);
assert_eq!(got.len(), 1, "{got:?}");
assert!(got[0].0.near(Vec2::new(40.0, 20.0), 1e-3) && got[0].1.near(Vec2::new(80.0, 20.0), 1e-3), "moved by (20, 0): {got:?}");
}
#[test]
fn an_object_clicked_on_the_move_is_picked_with_no_command_running() {
let mut h = harness();
quick_moving_click(&mut h, Vec2::new(40.0, 20.0));
assert_eq!(h.state().session.selection().len(), 1);
assert!(h.state().session.pending_window.is_none());
}
#[test]
fn an_object_clicked_on_the_move_is_picked_at_select_objects() {
let mut h = harness();
start(&mut h, "erase");
quick_moving_click(&mut h, Vec2::new(40.0, 20.0));
enter(&mut h);
assert!(lines(&h).is_empty(), "the line was picked and erased");
}
#[test]
fn both_corners_of_a_click_click_window_count_while_the_mouse_moves() {
let mut h = harness();
// Lower left, then upper right: a window around the whole line.
quick_moving_click(&mut h, Vec2::new(10.0, 10.0));
assert!(h.state().session.pending_window.is_some(), "a quick click leaves the window open for the second corner");
quick_moving_click(&mut h, Vec2::new(70.0, 30.0));
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
#[test]
fn holding_the_button_while_moving_drags_a_window() {
let mut h = harness();
// Half a second of dragging from lower left to upper right of the line.
let from = screen(&h, Vec2::new(10.0, 10.0));
let to = screen(&h, Vec2::new(70.0, 30.0));
h.event(Event::PointerMoved(from));
button(&mut h, from, true);
for i in 1..=30 {
h.event(Event::PointerMoved(from + (to - from) * (i as f32 / 30.0)));
}
button(&mut h, to, false);
h.run_steps(2);
assert!(h.state().session.pending_window.is_none(), "letting go closes the dragged window");
assert_eq!(h.state().session.selection().len(), 1);
}
#[test]
fn holding_still_then_moving_and_letting_go_quickly_is_a_click() {
let mut h = harness();
let at = screen(&h, Vec2::new(10.0, 10.0));
h.event(Event::PointerMoved(at));
button(&mut h, at, true);
// Held in place for half a second: no drag yet.
h.run_steps(30);
h.event(Event::PointerMoved(at + vec2(40.0, 0.0)));
button(&mut h, at + vec2(40.0, 0.0), false);
h.run_steps(2);
assert!(h.state().session.pending_window.is_some(), "still waiting for the second corner");
}
#[test]
fn two_window_corners_clicked_within_one_frame_both_count() {
let mut h = harness();
let (a, b) = (screen(&h, Vec2::new(10.0, 10.0)), screen(&h, Vec2::new(70.0, 30.0)));
// A slow frame: both clicks arrive before the next one is drawn.
for pos in [a, b] {
h.input_mut().events.push(Event::PointerMoved(pos));
for pressed in [true, false] {
h.input_mut().events.push(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
}
h.run_steps(2);
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
#[test]
fn cpolygon_points_clicked_on_the_move_all_count() {
// #1546: a narrow crossing polygon over the line's right end (x 58.6–59.9, the line ends at
// 60), each point clicked while moving. Taken where the buttons came up (1.5 units further
// right) it would miss the line.
let mut h = harness();
start(&mut h, "erase");
h.state_mut().session.input(Input::Keyword("CP".into())).unwrap();
h.run_steps(2);
for p in [Vec2::new(58.6, 15.0), Vec2::new(59.9, 15.0), Vec2::new(59.9, 25.0), Vec2::new(58.6, 25.0)] {
quick_moving_click(&mut h, p);
}
enter(&mut h);
enter(&mut h);
assert!(lines(&h).is_empty(), "the polygon crossed the line and ERASE removed it");
}
+2 -3
View File
@@ -88,12 +88,11 @@ fn a_click_made_while_the_mouse_moves_still_places_the_point() {
let down = screen(&h, Vec2::new(40.0, 10.0));
button(&mut h, down, true);
h.run_steps(1);
// The hand is already on its way to the next point when the button comes up; the point is
// where the button went down (#1001), not where the hand got to.
// The hand is already on its way to the next point when the button comes up.
let up = down + vec2(12.0, 0.0);
button(&mut h, up, false);
h.run_steps(2);
let got = lines(&h);
assert_eq!(got.len(), 1, "{got:?}");
assert!(got[0].1.near(h.state().canvas.xf.unwrap().to_world(down), 1e-4), "{got:?}");
assert!(got[0].1.near(h.state().canvas.xf.unwrap().to_world(up), 1e-4), "{got:?}");
}
-159
View File
@@ -1,159 +0,0 @@
//! A click on an object selects it, however long the frames around it take (#2813).
//!
//! egui calls a press that lasts longer than `max_click_duration` (0.8 s) a drag, and it times the
//! press by frames. On a large drawing that draws slowly, an ordinary click can come down in one
//! frame and up in the next, more than 0.8 s later. The canvas took that "drag" for a press-and-drag
//! selection window that never left the click, a window of no size, and nothing was selected; when
//! no frame ran while the button was down, egui reported nothing at all.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Drawing, Handle, Space};
use cadcraft_engine::geom::Vec2;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use serde_json::json;
/// Seconds each harness step advances egui's clock: two steps between press and release make a
/// press longer than egui's 0.8 s click limit.
const STEP: f32 = 0.5;
/// A drawing with one line from (10, 10) to (30, 10), no object snaps, nothing selected; each frame
/// advances egui's clock by [`STEP`].
fn harness() -> (Harness<'static, CadApp>, Handle) {
harness_stepping(STEP)
}
/// [`harness`] with each frame advancing egui's clock by `step` seconds.
fn harness_stepping(step: f32) -> (Harness<'static, CadApp>, Handle) {
let mut session = Session::empty();
session.open_drawing(Drawing::new_imperial(), "Slow clicks", None);
session.execute("view.set", &json!({"center": [50, 50], "height": 100})).unwrap();
session.settings.osmode = 0;
session.execute("line", &json!({"points": [[10, 10], [30, 10]]})).unwrap();
let line = session.doc().unwrap().space(&Space::Model).unwrap().iter().next().unwrap().handle;
let mut app = CadApp::new(session, Services::default());
app.canvas.zoom_pending = false;
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_step_dt(step).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(3);
(h, line)
}
fn screen(h: &Harness<'_, CadApp>, p: Vec2) -> Pos2 {
h.state().canvas.xf.unwrap().to_screen(p)
}
fn button(h: &mut Harness<'_, CadApp>, pos: Pos2, pressed: bool) {
h.event(Event::PointerMoved(pos));
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
/// Press at `down`, let `frames` slow frames pass, release at `up`.
fn slow_click(h: &mut Harness<'_, CadApp>, down: Pos2, up: Pos2, frames: usize) {
button(h, down, true);
h.run_steps(frames);
button(h, up, false);
h.run_steps(2);
}
#[test]
fn a_click_spanning_slow_frames_selects_the_object() {
let (mut h, line) = harness();
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at, 2);
assert_eq!(h.state().session.selection(), vec![line]);
assert!(h.state().session.pending_window.is_none(), "no window is left open");
}
/// The slowest case: the frame the button went down in took a second, and the next frame already
/// has it up. No frame ran with the button down, so egui reports neither a click nor a drag.
#[test]
fn a_click_across_one_slow_frame_selects_the_object() {
let (mut h, line) = harness_stepping(1.0);
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at, 1);
assert_eq!(h.state().session.selection(), vec![line]);
}
/// A slow click on a grip of a selected object makes it hot, as a quick one does.
#[test]
fn a_slow_click_on_a_grip_starts_a_grip_edit() {
let (mut h, line) = harness();
h.state_mut().session.set_selection(vec![line]);
h.run_steps(2);
let grip = screen(&h, Vec2::new(30.0, 10.0));
slow_click(&mut h, grip, grip, 2);
assert_eq!(h.state().session.running.as_ref().map(|r| r.id.as_str()), Some("grip"));
}
/// The hand drifts a pixel or two while the button is down: still a click.
#[test]
fn a_slow_click_that_drifts_within_the_click_distance_selects_the_object() {
let (mut h, line) = harness();
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at + vec2(2.0, 1.0), 2);
assert_eq!(h.state().session.selection(), vec![line]);
}
/// In empty space a slow click does what a quick one does there: it starts a click-click window.
#[test]
fn a_slow_click_in_empty_space_starts_a_window_as_a_click_does() {
let (mut h, _) = harness();
let at = screen(&h, Vec2::new(20.0, 40.0));
slow_click(&mut h, at, at, 2);
assert!(h.state().session.selection().is_empty());
let corner = h.state().session.pending_window.map(|w| w.corner);
assert!(corner.is_some_and(|c| c.near(Vec2::new(20.0, 40.0), 0.5)), "{corner:?}");
}
/// A real press-and-drag still opens and closes a selection window, slow or not.
#[test]
fn a_press_and_drag_still_selects_by_window() {
let (mut h, line) = harness();
let (from, to) = (screen(&h, Vec2::new(5.0, 15.0)), screen(&h, Vec2::new(35.0, 5.0)));
button(&mut h, from, true);
h.run_steps(1);
h.event(Event::PointerMoved(from + (to - from) / 2.0));
h.run_steps(2);
button(&mut h, to, false);
h.run_steps(2);
assert_eq!(h.state().session.selection(), vec![line]);
assert!(h.state().session.pending_window.is_none());
}
/// While a command asks for objects, a slow click on one picks it.
#[test]
fn a_slow_click_picks_at_select_objects() {
let (mut h, line) = harness();
h.state_mut().start("erase");
h.run_steps(2);
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at, 2);
h.state_mut().session.input(cadcraft_engine::Input::Enter).unwrap();
h.run_steps(2);
let d = h.state().session.doc().unwrap();
assert!(d.entity(line).is_none(), "the line was picked and erased");
}
/// At a point prompt, a click across one slow frame places one point. This already worked (a drag
/// that stops at a point prompt counts as a click, #815). The test keeps it so, and shows the click
/// isn't counted twice (CIRCLE would take the second as the radius).
#[test]
fn a_click_across_one_slow_frame_places_a_point() {
let (mut h, _) = harness_stepping(1.0);
h.state_mut().start("circle");
h.run_steps(1);
let prompt = |h: &Harness<'_, CadApp>| h.state().session.current_prompt().map(|p| p.message).unwrap_or_default();
let center_prompt = prompt(&h);
let at = screen(&h, Vec2::new(60.0, 60.0));
slow_click(&mut h, at, at, 1);
let next = prompt(&h);
assert_ne!(next, center_prompt, "the center was taken");
assert!(next.to_ascii_lowercase().starts_with("specify radius"), "{next}");
}
@@ -1,59 +0,0 @@
//! Space is Enter at TRIM's and EXTEND's option prompts, as at AutoCAD's (#3092): typing `O`,
//! Space, `S`, Space switches to Standard mode instead of typing a space into the command line.
use cadcraft_engine::Session;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Key, Modifiers, vec2};
use egui_kittest::Harness;
fn harness() -> Harness<'static, CadApp> {
let app = CadApp::new(Session::new(), Services::default());
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(3);
h
}
/// Type `text` at the keyboard: a space arrives as the Space key and as text, like a real press.
fn type_keys(h: &mut Harness<'static, CadApp>, text: &str) {
for c in text.chars() {
if c == ' ' {
h.event(egui::Event::Key { key: Key::Space, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
}
h.event(egui::Event::Text(c.to_string()));
h.run_steps(1);
}
h.run_steps(1);
}
fn header(h: &Harness<'static, CadApp>, name: &str) -> i64 {
h.state().session.doc().unwrap().header.i64(name, -1)
}
fn prompt(h: &Harness<'static, CadApp>) -> String {
h.state().session.current_prompt().map(|p| p.message).unwrap_or_default()
}
#[test]
fn space_answers_trim_and_extend_option_prompts() {
let mut h = harness();
type_keys(&mut h, "trim o s ");
assert_eq!(h.state().cmd.buffer, "", "Space typed a space instead of entering the option");
assert_eq!(header(&h, "TRIMEXTENDMODE"), 0, "S chose Standard mode");
// Standard mode asks for cutting edges; Enter selects all, then Project and Edge.
type_keys(&mut h, " p n e e ");
assert_eq!(h.state().cmd.buffer, "");
assert_eq!(header(&h, "PROJMODE"), 0, "N chose no projection");
assert_eq!(header(&h, "EDGEMODE"), 1, "E chose Extend");
assert!(prompt(&h).starts_with("Select object to trim"), "back at the trim prompt: {}", prompt(&h));
h.key_press(Key::Escape);
h.run_steps(2);
type_keys(&mut h, "extend o q ");
assert_eq!(h.state().cmd.buffer, "");
assert_eq!(header(&h, "TRIMEXTENDMODE"), 1, "Q chose Quick mode in EXTEND");
}