diff --git a/crates/doc/src/foreign.rs b/crates/doc/src/foreign.rs index f30404d0a..6feb9eeb8 100644 --- a/crates/doc/src/foreign.rs +++ b/crates/doc/src/foreign.rs @@ -85,6 +85,9 @@ pub struct Foreign { /// The drawing's own `$ACADVER` is the version it is saved as, which SAVEAS changes, so a /// later save must not take it for this one (#2471). pub version: Option, + /// The file's registered applications (APPID names as read, in file order). Saving writes + /// them all back, whether or not any xdata still names them. + pub appids: Vec, } impl Foreign { @@ -103,6 +106,7 @@ impl Foreign { && self.targets.is_empty() && self.class_order.is_empty() && self.data_store.is_empty() + && self.appids.is_empty() } /// The entities with a geometry record in the data store: an `ACDSRECORD` naming the entity diff --git a/crates/doc/src/tables.rs b/crates/doc/src/tables.rs index c3c6f1559..8ae080f59 100644 --- a/crates/doc/src/tables.rs +++ b/crates/doc/src/tables.rs @@ -821,6 +821,18 @@ pub struct PageSetup { /// save keeps where the sheet sits; `None` for a page CADCraft made, written as 0,0 (#2109). #[serde(skip_serializing_if = "Option::is_none")] pub image_origin: Option, + /// The plot layout flags (DXF group 70 of AcDbPlotSettings) as the file had them. Saving keeps + /// the bits CADCraft doesn't model (plot paper space last, plot with plot styles, standard + /// scale and the rest) as read instead of forcing its defaults (#3227); `None` for page setups + /// made in CADCraft. + #[serde(skip)] + pub file_plot_flags: Option, + /// The standard scale the file chose (DXF group 75, such as 25 for 1:50) and the plot scale it + /// was read with. While the scale is unchanged, saving keeps that choice and the standard scale + /// flag instead of writing the scale as a custom one; `None` for a custom scale, scaled to + /// fit, or a page setup made in CADCraft. + #[serde(skip)] + pub file_standard_scale: Option<(i64, f64)>, } impl Default for PageSetup { @@ -844,6 +856,8 @@ impl Default for PageSetup { paper_mm: None, file_paper: None, image_origin: None, + file_plot_flags: None, + file_standard_scale: None, } } } diff --git a/crates/engine/src/cmd/hatch.rs b/crates/engine/src/cmd/hatch.rs index 97fc1b5b7..7a1771374 100644 --- a/crates/engine/src/cmd/hatch.rs +++ b/crates/engine/src/cmd/hatch.rs @@ -1,4 +1,5 @@ //! HATCH, GRADIENT, BOUNDARY, REGION: boundaries from pick points or selected closed objects. +//! HATCHGENERATEBOUNDARY: polylines around existing hatches. mod patfile; pub(super) use edit::{set_pattern, takes_pattern}; @@ -36,6 +37,9 @@ pub fn specs() -> Vec { // Typed with nothing selected it asks for objects, as in AutoCAD, rather than converting none. .interactive(|_| Ok(Box::new(SelectRun::new("region", "REGION")))), CommandSpec::new("hatchedit", "Hatch Edit", edit::run_hatchedit).menu(&["Modify", "Object", "Hatch..."]).alias(&["he", "-hatchedit"]).params("{handles?, pattern?, scale?, angle?, gradient?: {name?, color1?, color2?, angle? (degrees), centered?} (makes or changes a gradient fill; `pattern` turns it back), associative?: bool (false unlinks; true links each loop to a closed object of the same shape, or to `boundary` objects), boundary?: [hex], addPoints?: [[x,y]], addBoundary?: [hex], removeLoops?: [zero-based index] (geometry edits require one hatch), style?, origin? | originMode?, separate?: true, recreate?: \"polyline\"|\"region\", associate?: bool (link to the recreated boundary)}").interactive(|s| Ok(Box::new(edit::HatchEditM::new(s)))), + CommandSpec::new("hatchgenerateboundary", "Generate Boundary", edit::run_hatchgenerateboundary) + .params("{handles?} (a closed polyline around each boundary loop of the hatches, which stay as they are) → handles") + .interactive(|_| Ok(Box::new(SelectRun::new("hatchgenerateboundary", "HATCHGENERATEBOUNDARY")))), CommandSpec::new("hatchpick", "Hatch Pick", pick::run_hatchpick) .params("{points?: [[x,y]] (internal points), handles?: [hex] (closed objects)} (typed: Points, Objects, oRigin or Hatch, then the picks): the Hatch and Gradient dialog's picks, kept in the session; changes nothing") .enabled(has_doc) diff --git a/crates/engine/src/cmd/hatch/edit.rs b/crates/engine/src/cmd/hatch/edit.rs index 3f4b9ba0b..0590dbe7a 100644 --- a/crates/engine/src/cmd/hatch/edit.rs +++ b/crates/engine/src/cmd/hatch/edit.rs @@ -29,6 +29,59 @@ fn hatches(s: &Session, p: &Value) -> Result> { Ok(out) } +/// Most polylines one HATCHGENERATEBOUNDARY call creates. +const MAX_GENERATED: usize = 10_000; + +/// HATCHGENERATEBOUNDARY: a closed polyline around every boundary loop (outer and islands) of +/// the selected hatches, at each hatch's height. The hatches are not changed: an associative +/// hatch stays linked to its own boundary objects and is not linked to the new polylines. +pub(super) fn run_hatchgenerateboundary(s: &mut Session, p: &Value) -> Result { + let selected = targets(s, p)?; + // The polylines go to the current space, so every hatch must be there too. + let space = s.space(); + let mut loops = Vec::new(); + let mut found = false; + // A hatch named twice gets its boundary once. + let mut seen = std::collections::HashSet::new(); + { + let d = s.doc()?; + for h in selected { + let Some(e) = d.entity(h) else { continue }; + let EntityKind::Hatch(x) = &e.kind else { continue }; + if !seen.insert(h) { + continue; + } + found = true; + if d.space_of(h).as_ref() != Some(&space) { + return Err(bad("hatchgenerateboundary", format!("hatch {} is not in the current space; switch to its layout first", h.hex()))); + } + // Every selected hatch counts: none is left out of a call that succeeds. Compared + // against the room left, so a hostile loop count can't overflow the sum. + if x.loops.len() > MAX_GENERATED.saturating_sub(loops.len()) { + return Err(bad("hatchgenerateboundary", format!("more than {MAX_GENERATED} boundary polylines in one call; select fewer hatches"))); + } + // The elevation runs along the hatch's normal: one facing down Z (mirrored) lies at its + // negative, where the polyline, facing up, goes. + let z = if e.common.extrusion.z < 0.0 { -x.elevation } else { x.elevation }; + loops.extend(x.loops.iter().map(|l| (l.vertices.clone(), z))); + } + } + if !found { + return Err(bad("hatchgenerateboundary", "select one or more hatches")); + } + // Everything is checked before anything is added, so a refused call leaves nothing behind. + let mut created = Vec::new(); + for (vs, elevation) in loops { + let mut kind = lwpoly(vs, true); + if let EntityKind::LwPolyline(pl) = &mut kind { + pl.elevation = elevation; + } + created.push(s.add_entity(kind)?.hex()); + } + let n = created.len(); + Ok(json!({ "handles": created, "message": format!("{n} boundary polyline(s) created.") })) +} + fn outline(l: &HatchLoop) -> Vec { Polyline { vertices: l.vertices.clone(), closed: true }.tessellate(1e-3) } diff --git a/crates/engine/src/file_access/commands.rs b/crates/engine/src/file_access/commands.rs index c72521c9a..7b26f14f8 100644 --- a/crates/engine/src/file_access/commands.rs +++ b/crates/engine/src/file_access/commands.rs @@ -235,6 +235,7 @@ pub const NO_FILES: &[&str] = &[ "boundary", "region", "hatchedit", + "hatchgenerateboundary", "hatchpick", "overkill", "block", diff --git a/crates/engine/tests/it/hatch_generate_boundary.rs b/crates/engine/tests/it/hatch_generate_boundary.rs new file mode 100644 index 000000000..f79c4aca3 --- /dev/null +++ b/crates/engine/tests/it/hatch_generate_boundary.rs @@ -0,0 +1,205 @@ +//! HATCHGENERATEBOUNDARY (#2801): closed polylines around existing hatches, which stay as they are. + +use cadcraft_engine::doc::{EntityKind, Handle, Hatch, LwPolyline}; +use cadcraft_engine::{Input, Session}; +use serde_json::{Value, json}; + +fn hatch(s: &Session, h: &str) -> Hatch { + match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind { + EntityKind::Hatch(x) => x.clone(), + k => panic!("not a hatch: {k:?}"), + } +} + +fn poly(s: &Session, h: &str) -> LwPolyline { + match &s.doc().unwrap().entity(Handle::parse_hex(h).unwrap()).unwrap().kind { + EntityKind::LwPolyline(p) => p.clone(), + k => panic!("not a polyline: {k:?}"), + } +} + +fn handle(v: &Value) -> String { + v["handle"].as_str().unwrap().to_string() +} + +fn handles(v: &Value) -> Vec { + v["handles"].as_array().unwrap().iter().map(|h| h.as_str().unwrap().to_string()).collect() +} + +fn rect(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> String { + handle(&s.execute("rectang", &json!({ "p1": a, "p2": b })).unwrap()) +} + +fn count(s: &Session) -> usize { + s.doc().unwrap().model.iter().count() +} + +#[test] +fn generates_a_closed_polyline_around_a_hatch_without_its_outline() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r.clone()] })).unwrap()); + s.execute("erase", &json!({ "handles": [r] })).unwrap(); + let before = hatch(&s, &h); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h.clone()] })).unwrap(); + let new = handles(&v); + assert_eq!(new.len(), 1); + let p = poly(&s, &new[0]); + assert!(p.closed); + assert_eq!(p.vertices, before.loops[0].vertices); + assert_eq!(hatch(&s, &h), before, "the hatch is not changed"); + s.execute("undo", &json!({})).unwrap(); + assert_eq!(count(&s), 1, "one undo step removes what was generated"); +} + +#[test] +fn islands_get_their_own_polylines() { + let mut s = Session::new(); + rect(&mut s, [0.0, 0.0], [20.0, 20.0]); + rect(&mut s, [5.0, 5.0], [10.0, 10.0]); + let h = handle(&s.execute("hatch", &json!({ "points": [[2, 2]] })).unwrap()); + assert_eq!(hatch(&s, &h).loops.len(), 2); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap(); + assert_eq!(handles(&v).len(), 2); +} + +#[test] +fn every_selected_hatch_gets_its_boundary() { + let mut s = Session::new(); + let a = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let b = rect(&mut s, [10.0, 0.0], [14.0, 2.0]); + let ha = handle(&s.execute("hatch", &json!({ "handles": [a] })).unwrap()); + let hb = handle(&s.execute("hatch", &json!({ "handles": [b] })).unwrap()); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [ha, hb] })).unwrap(); + assert_eq!(handles(&v).len(), 2); +} + +#[test] +fn a_hatch_named_twice_gets_one_boundary() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h.clone(), h] })).unwrap(); + assert_eq!(handles(&v).len(), 1); +} + +#[test] +fn an_associative_hatch_stays_linked_to_its_own_boundary() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r.clone()], "associative": true })).unwrap()); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h.clone()] })).unwrap(); + let p = handles(&v)[0].clone(); + // Moving the generated polyline leaves the hatch where it is. + s.execute("move", &json!({ "handles": [p], "delta": [0, 10] })).unwrap(); + assert_eq!(hatch(&s, &h).loops[0].vertices[0].p.y, 0.0); + // Moving the original rectangle still moves the hatch. + s.execute("move", &json!({ "handles": [r], "delta": [10, 0] })).unwrap(); + assert!(hatch(&s, &h).associative); + assert_eq!(hatch(&s, &h).loops[0].vertices[0].p.x, 10.0); +} + +#[test] +fn boundaries_keep_the_hatch_elevation() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + s.doc_mut() + .unwrap() + .modify_entity(Handle::parse_hex(&h).unwrap(), |e| { + if let EntityKind::Hatch(x) = &mut e.kind { + x.elevation = 300.0; + } + }) + .unwrap(); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap(); + assert_eq!(poly(&s, &handles(&v)[0]).elevation, 300.0); +} + +/// A mirrored hatch (normal 0,0,-1, as exploding a mirrored block makes) at elevation 300 lies at +/// world Z -300; its boundary, facing up, goes there too, not to +300. +#[test] +fn a_mirrored_hatchs_boundary_keeps_its_world_height() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + s.doc_mut() + .unwrap() + .modify_entity(Handle::parse_hex(&h).unwrap(), |e| { + e.common.extrusion = cadcraft_engine::geom::Vec3::new(0.0, 0.0, -1.0); + if let EntityKind::Hatch(x) = &mut e.kind { + x.elevation = 300.0; + } + }) + .unwrap(); + let v = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap(); + let new = Handle::parse_hex(&handles(&v)[0]).unwrap(); + let e = s.doc().unwrap().entity(new).unwrap().clone(); + let EntityKind::LwPolyline(p) = &e.kind else { panic!("not a polyline") }; + assert_eq!(e.common.extrusion.z.signum() * p.elevation, -300.0); +} + +#[test] +fn refuses_a_hatch_in_another_space_and_adds_nothing() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap(); + let before = s.doc().unwrap().entity_count(); + let e = s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).unwrap_err(); + assert!(e.to_string().contains("not in the current space"), "{e}"); + assert_eq!(s.doc().unwrap().entity_count(), before); +} + +#[test] +fn refuses_more_boundaries_than_the_limit_and_adds_nothing() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + // One hatch with more loops than one call may turn into polylines. + s.doc_mut() + .unwrap() + .modify_entity(Handle::parse_hex(&h).unwrap(), |e| { + if let EntityKind::Hatch(x) = &mut e.kind { + let l = x.loops[0].clone(); + x.loops = vec![l; 10_001]; + } + }) + .unwrap(); + let before = count(&s); + assert!(s.execute("hatchgenerateboundary", &json!({ "handles": [h] })).is_err()); + assert_eq!(count(&s), before); +} + +#[test] +fn needs_a_hatch() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + assert!(s.execute("hatchgenerateboundary", &json!({ "handles": [r] })).is_err()); + assert_eq!(count(&s), 1, "nothing is added"); +} + +#[test] +fn runs_at_once_on_selected_hatches() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + s.set_selection(vec![Handle::parse_hex(&h).unwrap()]); + s.start("hatchgenerateboundary").unwrap(); + assert!(s.current_prompt().is_none(), "a pickfirst selection needs no prompt"); + assert_eq!(count(&s), 3); +} + +#[test] +fn asks_for_hatches_without_a_selection() { + let mut s = Session::new(); + let r = rect(&mut s, [0.0, 0.0], [4.0, 2.0]); + let h = handle(&s.execute("hatch", &json!({ "handles": [r] })).unwrap()); + s.set_selection(Vec::new()); + s.start("hatchgenerateboundary").unwrap(); + assert!(s.current_prompt().is_some()); + s.input(Input::Pick(vec![Handle::parse_hex(&h).unwrap()])).unwrap(); + s.input(Input::Enter).unwrap(); + assert!(s.current_prompt().is_none()); + assert_eq!(count(&s), 3); +} diff --git a/crates/engine/tests/it/main.rs b/crates/engine/tests/it/main.rs index 0c08b4bc0..2f3f9630d 100644 --- a/crates/engine/tests/it/main.rs +++ b/crates/engine/tests/it/main.rs @@ -68,6 +68,7 @@ mod group_selection; mod groups; mod hatch_assoc; mod hatch_dialog_helpers; +mod hatch_generate_boundary; mod hatch_numeric_validation; mod hatch_options; mod helix; diff --git a/crates/io/src/dxf_raw.rs b/crates/io/src/dxf_raw.rs index 9ff8378ff..3c1b7d124 100644 --- a/crates/io/src/dxf_raw.rs +++ b/crates/io/src/dxf_raw.rs @@ -457,6 +457,10 @@ pub(crate) fn read(secs: &[SectionRef<'_>], d: &mut Drawing) { if !f.is_empty() { f.version = file_version(secs); } + // Added after the version: registered applications alone are no kept objects whose groups + // the DWG writer must read as the file's version, and nearly every file has some (ACAD). + let appids = tables.iter().filter(|(k, _, _)| k == "APPID").filter_map(|(_, _, t)| val(t, 2)).map(|n| n.trim().to_string()); + f.appids = appids.take(MAX_OBJECTS).collect(); // The file's handles of the objects CADCraft writes itself (AutoLISP's `handent`). f.handles = ids.iter().filter(|(h, _)| !ents.contains_key(*h)).filter_map(|(h, k)| Some((handle(h)?, k.clone()))).take(MAX_OBJECTS).collect(); if !f.is_empty() || !f.handles.is_empty() { @@ -1267,7 +1271,7 @@ pub(crate) fn finish( join_entries(&map, b, kept, &mut out); } } - add_appids(&mut out); + add_appids(&mut out, &f.appids); let top = max_handle(&out).saturating_add(1); if let Some(t) = seed_index(&out).and_then(|i| out.get_mut(i)) && Handle::parse_hex(&t.str()).is_none_or(|h| h.0 < top) @@ -1593,9 +1597,13 @@ fn xdata(map: &Map, x: &ForeignExtra, own: &HashSet, out: &mut Vec) } } -/// APPID records for every application with xdata in the file, added to the APPID table. -fn add_appids(out: &mut Vec) { - let used: BTreeMap = out.iter().filter(|t| t.code == 1001).map(|t| (up(&t.str()), t.str().trim().to_string())).collect(); +/// APPID records for every application with xdata in the file and every one the file read had +/// (`kept`), added to the APPID table. +fn add_appids(out: &mut Vec, kept: &[String]) { + let mut used: BTreeMap = out.iter().filter(|t| t.code == 1001).map(|t| (up(&t.str()), t.str().trim().to_string())).collect(); + for name in kept.iter().filter(|n| !n.is_empty()) { + used.entry(up(name)).or_insert_with(|| name.clone()); + } let recs = written_records(out); let Some(table) = recs.iter().position(|r| { r.sec == "TABLES" && r.kind == "TABLE" && val(out.get(r.start + 1..r.end).unwrap_or(&[]), 2).is_some_and(|n| up(&n) == "APPID") diff --git a/crates/io/src/dxf_read/entities.rs b/crates/io/src/dxf_read/entities.rs index 899b20430..9d888af5a 100644 --- a/crates/io/src/dxf_read/entities.rs +++ b/crates/io/src/dxf_read/entities.rs @@ -88,6 +88,7 @@ fn lwpolyline(tags: &[Tag], c: &mut Common, t: &T) -> Option { // In a tilted plane: drawn as seen from above, at the vertices' mean height, its // vertices now plan coordinates. (verts, elevation) = plan_of_tilted(c.extrusion, elevation, &verts, flags & 1 != 0); + thickness_along_z(c); c.extrusion = Vec3::Z; } else if c.extrusion.z < 0.0 { for v in &mut verts { @@ -577,7 +578,7 @@ pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) - break; } } - let c = common(t); + let mut c = common(t); let mut extra: Vec = Vec::new(); let k = if flags & 64 != 0 { // Face records that name a missing vertex (or fewer than three) are dropped: they draw @@ -599,13 +600,26 @@ pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) - } else if flags & 8 != 0 { EntityKind::Polyline3d(Polyline3d { points: pts.iter().map(|p| p.0).collect(), closed: flags & 1 != 0 }) } else { - // A 2D polyline's vertices are in its OCS: mirrored like LWPOLYLINE. - let m = if c.extrusion.z < 0.0 { -1.0 } else { 1.0 }; + // A 2D polyline's vertices are in its OCS, at the elevation of the POLYLINE's own point: + // in a tilted plane drawn as seen from above like LWPOLYLINE, else mirrored like it. + let closed = flags & 1 != 0; + let mut vertices: Vec = pts.iter().map(|p| PolyVertex { p: p.0.xy(), bulge: p.1, start_width: p.2, end_width: p.3 }).collect(); + let mut elevation = t.p(10).z; + if tilted(c.extrusion, run_points(&vertices, elevation, closed)) { + (vertices, elevation) = plan_of_tilted(c.extrusion, elevation, &vertices, closed); + thickness_along_z(&mut c); + c.extrusion = Vec3::Z; + } else if c.extrusion.z < 0.0 { + for v in &mut vertices { + v.p.x = -v.p.x; + v.bulge = -v.bulge; + } + } EntityKind::LwPolyline(LwPolyline { - vertices: pts.iter().map(|p| PolyVertex { p: Vec2::new(m * p.0.x, p.0.y), bulge: m * p.1, start_width: p.2, end_width: p.3 }).collect(), - closed: flags & 1 != 0, + vertices, + closed, const_width: t.fd(40, 0.0).min(t.fd(41, 0.0)).max(0.0), - elevation: t.p(10).z, + elevation, plinegen: flags & 128 != 0, }) }; @@ -714,3 +728,11 @@ fn helix(tags: &[Tag]) -> Helix { } .sanitized() } + +/// A polyline drawn as seen from above gets the normal +Z: its thickness keeps the side of Z it +/// extruded toward, which the normal it is losing said. +fn thickness_along_z(c: &mut Common) { + if c.extrusion.z < 0.0 { + c.thickness = -c.thickness; + } +} diff --git a/crates/io/src/dxf_read/objects.rs b/crates/io/src/dxf_read/objects.rs index d0b51540a..91f5ca34f 100644 --- a/crates/io/src/dxf_read/objects.rs +++ b/crates/io/src/dxf_read/objects.rs @@ -421,6 +421,8 @@ pub(super) fn page_setup(t: &T, tags: &[Tag]) -> PageSetup { // Plot layout flags: 2 display plot styles, 4 centred, 16 standard scale (75 = 0: scaled // to fit), 128 lineweights. if let Some(flags) = t.i(70) { + // Kept to be written back (a 16-bit group: only those bits). + p.file_plot_flags = Some(flags & 0xFFFF); p.show_plot_styles = flags & 2 != 0; p.center = flags & 4 != 0; p.lineweights = flags & 128 != 0; @@ -432,6 +434,13 @@ pub(super) fn page_setup(t: &T, tags: &[Tag]) -> PageSetup { if let Some(s) = pos(ratio).or_else(|| pos(t.f(147))) { p.scale = s; } + // A standard scale (flag 16, group 75 above 0: 0 is scaled to fit, the DXF Reference lists + // 1 to 32), kept with the scale it stands for so a save can tell it was not changed. + if t.i(70).is_some_and(|f| f & 16 != 0) + && let Some(code) = t.i(75).filter(|c| (1..=32).contains(c)) + { + p.file_standard_scale = Some((code, p.scale)); + } p.plot_area = match t.i(74) { Some(0) => "display", Some(1) => "extents", diff --git a/crates/io/src/dxf_write/entity.rs b/crates/io/src/dxf_write/entity.rs index eebdc6401..fcfa6d204 100644 --- a/crates/io/src/dxf_write/entity.rs +++ b/crates/io/src/dxf_write/entity.rs @@ -108,7 +108,10 @@ fn write_basic_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bo EntityKind::Line(l) => { w.s(0, "LINE"); common(w, e, owner, paper, "AcDbLine"); - thickness(w, e); + // Along the normal written with it (210 below), as read. + if e.common.thickness != 0.0 { + w.f(39, e.common.thickness); + } w.p(10, l.a); w.p(11, l.b); extrusion(w, e); @@ -156,8 +159,13 @@ fn write_basic_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bo if p.const_width > 0.0 { w.f(43, p.const_width); } - if p.elevation != 0.0 { - w.f(38, p.elevation); + // The elevation runs along the polyline's normal, which isn't written: one facing down + // Z is at the elevation's negative. That is exact for a normal of 0,0,-1 only; a tilted + // one pointing partly down is flipped the same way (the reader brings tilted polylines + // into plan with normal Z, so only other sources make one). + let elevation = if e.common.extrusion.z < 0.0 { -p.elevation } else { p.elevation }; + if elevation != 0.0 { + w.f(38, elevation); } thickness(w, e); for v in &p.vertices { @@ -609,7 +617,10 @@ fn write_hatch_entity(w: &mut W, d: &Drawing, e: &Entity, owner: &str, paper: bo if let EntityKind::Hatch(h) = &e.kind { w.s(0, "HATCH"); common(w, e, owner, paper, "AcDbHatch"); - w.p(10, Vec3::new(0.0, 0.0, h.elevation)); + // Its elevation runs along its normal, written as Z: one facing down is at the negative. + // Exact for a normal of 0,0,-1; the reader brings a tilted hatch into plan with normal Z. + let elevation = if e.common.extrusion.z < 0.0 { -h.elevation } else { h.elevation }; + w.p(10, Vec3::new(0.0, 0.0, elevation)); w.p(210, Vec3::Z); w.s(2, &h.pattern); w.i(70, i64::from(h.solid)); @@ -829,10 +840,14 @@ fn gradient(w: &mut W, g: &Gradient) { w.s(1000, g.color2.name()); } -/// Group 39 (thickness) of the entities whose DXF Reference record has one; only when set. +/// Group 39 (thickness) of the entities whose DXF Reference record has one; only when set. They +/// are written with no normal, so they extrude along Z: one whose normal points down Z extrudes +/// the other way, and its thickness changes sign. That is exact for a normal of 0,0,-1; a tilted +/// one pointing partly down only gets the closer of the two directions. fn thickness(w: &mut W, e: &Entity) { - if e.common.thickness != 0.0 { - w.f(39, e.common.thickness); + let t = if e.common.extrusion.z < 0.0 { -e.common.thickness } else { e.common.thickness }; + if t != 0.0 { + w.f(39, t); } } diff --git a/crates/io/src/dxf_write/sections.rs b/crates/io/src/dxf_write/sections.rs index b8f013a82..de24f3acd 100644 --- a/crates/io/src/dxf_write/sections.rs +++ b/crates/io/src/dxf_write/sections.rs @@ -413,6 +413,23 @@ struct LayoutWriteData<'a> { limits: Option<(Vec2, Vec2)>, } +/// The plot layout flags (AcDbPlotSettings group 70) for `page`. The bits CADCraft models come +/// from the page: 2 display plot styles, 4 centred, 128 lineweights, and 16 standard scale where +/// the scale decides it (scaled to fit: set; a custom scale: clear). The rest are kept as the file +/// had them (#3227); a page CADCraft made gets 512 (plot paper space last) and 32 (plot with plot +/// styles), and 16 when its scale is standard. +fn plot_layout_flags(page: &PageSetup, standard: bool) -> i64 { + const MODELED: i64 = 2 | 4 | 128; + const STANDARD_SCALE: i64 = 16; + let kept = match page.file_plot_flags { + Some(f) if page.scale_to_fit => (f & !MODELED) | STANDARD_SCALE, + Some(f) if !standard => f & !MODELED & !STANDARD_SCALE, + Some(f) => f & !MODELED, + None => 512 | 32 | if standard { STANDARD_SCALE } else { 0 }, + }; + kept | if page.lineweights { 128 } else { 0 } | if page.center { 4 } else { 0 } | if page.show_plot_styles { 2 } else { 0 } +} + fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData<'_>) { let d = context.drawing; let layout_dict = context.dictionary; @@ -426,13 +443,10 @@ fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData< // Plot scale: a standard scale when fitting or 1:1, otherwise custom (142 paper units // per 143 drawing units). let scale = if page.scale.is_finite() && page.scale > 0.0 { page.scale } else { 1.0 }; - let standard = page.scale_to_fit || scale == 1.0; - let plot_flags = 512 - | 32 - | if standard { 16 } else { 0 } - | if page.lineweights { 128 } else { 0 } - | if page.center { 4 } else { 0 } - | if page.show_plot_styles { 2 } else { 0 }; + // The file's standard scale (such as 1:50) while the scale is still the one read with it. + let file_standard = page.file_standard_scale.filter(|&(_, s)| !page.scale_to_fit && s == scale).map(|(code, _)| code); + let standard = page.scale_to_fit || scale == 1.0 || file_standard.is_some(); + let plot_flags = plot_layout_flags(page, standard); let plot_type = match page.plot_area.as_str() { "display" => 0, "extents" => 1, @@ -474,7 +488,7 @@ fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData< w.i(73, rotation); w.i(74, plot_type); w.s(7, &page.plot_style_table); - w.i(75, if page.scale_to_fit { 0 } else { 16 }); + w.i(75, if page.scale_to_fit { 0 } else { file_standard.unwrap_or(16) }); w.f(147, scale); // The paper image origin the file had (#2109), else 0,0. let origin = page.image_origin.filter(|o| o.is_finite()).unwrap_or(Vec2::ZERO); diff --git a/crates/io/src/tests.rs b/crates/io/src/tests.rs index 44af892ee..f19bdb409 100644 --- a/crates/io/src/tests.rs +++ b/crates/io/src/tests.rs @@ -2683,6 +2683,84 @@ fn mirrored_2d_polyline_extrusion_flips_x_and_bulge() { assert_eq!(got, vec![(-1.0, 0.0, -1.0), (-3.0, 0.0, 0.0)]); } +/// Objects whose normal is 0,0,-1, at OCS height 5 and most of them 2 thick, keep their world height +/// and the side they extrude to through a save. They are written with no normal (along Z), so an +/// elevation or a thickness written as read put a polyline or a hatch at Z +5 instead of -5, and +/// extruded a circle, point, solid or text up instead of down (AutoCAD 2024 opening the saved file, +/// measured). A line writes its normal, and keeps its thickness as read. The same objects facing up +/// (no normal, and 0,0,1) keep +5 and +2: only a normal pointing down Z changes the sign. +#[test] +fn mirrored_objects_keep_their_world_height_and_thickness_side() { + let records = |normal: &str| { + format!( + "0\nLWPOLYLINE\n8\n0\n90\n2\n70\n0\n38\n5\n39\n2\n{normal}10\n0\n20\n0\n42\n0.5\n10\n-10\n20\n0\n\ + 0\nPOLYLINE\n8\n0\n66\n1\n70\n0\n10\n0\n20\n0\n30\n5\n{normal}0\nVERTEX\n8\n0\n10\n0\n20\n10\n0\nVERTEX\n8\n0\n10\n-10\n20\n10\n0\nSEQEND\n\ + 0\nCIRCLE\n8\n0\n10\n-10\n20\n5\n30\n5\n40\n5\n39\n2\n{normal}\ + 0\nARC\n8\n0\n10\n-30\n20\n5\n30\n5\n40\n5\n50\n180\n51\n270\n{normal}\ + 0\nPOINT\n8\n0\n10\n-40\n20\n0\n30\n5\n39\n2\n{normal}\ + 0\nSOLID\n8\n0\n10\n50\n20\n0\n30\n5\n11\n60\n21\n0\n31\n5\n12\n50\n22\n5\n32\n5\n13\n60\n23\n5\n33\n5\n39\n2\n{normal}\ + 0\nHATCH\n8\n0\n10\n0\n20\n0\n30\n5\n{normal}2\nSOLID\n70\n1\n71\n0\n91\n1\n92\n2\n72\n0\n73\n1\n93\n4\n\ + 10\n70\n20\n0\n10\n80\n20\n0\n10\n80\n20\n5\n10\n70\n20\n5\n97\n0\n75\n0\n76\n1\n98\n0\n\ + 0\nTEXT\n8\n0\n10\n-90\n20\n0\n30\n5\n40\n2\n1\nA\n39\n2\n{normal}\ + 0\nLINE\n8\n0\n39\n2\n10\n0\n20\n20\n30\n3\n11\n10\n21\n20\n31\n3\n{normal}" + ) + }; + let (down, up) = ("210\n0\n220\n0\n230\n-1\n", "210\n0\n220\n0\n230\n1\n"); + let text = format!("0\nSECTION\n2\nENTITIES\n{}{}{}0\nENDSEC\n0\nEOF\n", records(down), records(""), records(up)); + // Each object's kind, world height and thickness along world Z. + let place = |d: &Drawing| -> Vec<(&'static str, f64, f64)> { + d.model + .iter() + .map(|e| { + let n = e.common.extrusion.z.signum(); + let (kind, z) = match &e.kind { + EntityKind::LwPolyline(p) => ("polyline", n * p.elevation), + EntityKind::Circle(c) => ("circle", c.center.z), + EntityKind::Arc(a) => ("arc", a.center.z), + EntityKind::Point(p) => ("point", p.p.z), + EntityKind::Solid(s) => ("solid", s.corners[0].z), + EntityKind::Hatch(h) => ("hatch", n * h.elevation), + EntityKind::Text(t) => ("text", t.insert.z), + EntityKind::Line(l) => ("line", l.a.z), + _ => ("other", f64::NAN), + }; + (kind, z, n * e.common.thickness) + }) + .collect() + }; + let d = read(text.as_bytes(), "m.dxf").unwrap(); + let mut want = vec![ + ("polyline", -5.0, -2.0), + ("polyline", -5.0, 0.0), + ("circle", -5.0, -2.0), + ("arc", -5.0, 0.0), + ("point", 5.0, -2.0), + ("solid", -5.0, -2.0), + ("hatch", -5.0, 0.0), + ("text", -5.0, -2.0), + ("line", 3.0, -2.0), + ]; + let facing_up = [ + ("polyline", 5.0, 2.0), + ("polyline", 5.0, 0.0), + ("circle", 5.0, 2.0), + ("arc", 5.0, 0.0), + ("point", 5.0, 2.0), + ("solid", 5.0, 2.0), + ("hatch", 5.0, 0.0), + ("text", 5.0, 2.0), + ("line", 3.0, 2.0), + ]; + want.extend(facing_up); + want.extend(facing_up); + assert_eq!(place(&d), want, "as read"); + let out = write(&d, "m.dxf").unwrap(); + assert_eq!(place(&read(&out, "m.dxf").unwrap()), want, "after a save"); + let pairs = dxf_pairs(std::str::from_utf8(&out).unwrap()); + let lines: Vec<_> = dxf_records(&pairs, "LINE").into_iter().map(|l| (group(l, "39"), group(l, "230"))).collect(); + assert_eq!(lines, [(Some("2.0"), Some("-1.0")), (Some("2.0"), None), (Some("2.0"), None)]); +} + #[test] fn mirrored_hatch_extrusion_flips_boundary() { // HATCH boundaries are OCS: the square (1,0)..(3,2) under extrusion (0,0,-1) lies at (-3,0)..(-1,2). @@ -2727,6 +2805,20 @@ fn tilted_hatch_turns_its_gradient() { assert!((g.angle - std::f64::consts::PI).abs() < 1e-9, "gradient angle {}", g.angle); } +/// A tilted polyline with a thickness, its normal pointing partly down Z, still extrudes toward -Z +/// once it is drawn as seen from above and saved with no normal. +#[test] +fn tilted_thick_polyline_keeps_its_extrusion_side() { + let text = "0\nSECTION\n2\nENTITIES\n0\nLWPOLYLINE\n8\n0\n90\n2\n70\n0\n39\n5\n210\n0\n220\n0.5\n230\n-0.8660254037844386\n\ + 10\n1\n20\n0\n10\n3\n20\n2\n0\nENDSEC\n0\nEOF\n"; + let d = read(text.as_bytes(), "p.dxf").unwrap(); + let e = d.model.iter().next().unwrap(); + assert_eq!((e.common.thickness, e.common.extrusion), (-5.0, Vec3::Z)); + let back = roundtrip(&d); + let e = back.model.iter().next().unwrap(); + assert_eq!((e.common.thickness, e.common.extrusion), (-5.0, Vec3::Z), "saved with no normal, it still extrudes toward -Z"); +} + /// A straight tilted LWPOLYLINE keeps its vertex widths (groups 40/41) on the projected vertices. #[test] fn tilted_straight_lwpolyline_keeps_its_widths() { @@ -2841,6 +2933,57 @@ fn tilted_lwpolyline_is_drawn_as_seen_from_above() { assert_eq!(p.vertices.iter().map(|v| v.bulge).collect::>(), vec![1.0, 1.0]); } +/// A 2D POLYLINE (heavy polyline) in a tilted plane is drawn as seen from above, like a +/// LWPOLYLINE: before, its OCS points were taken for world coordinates. With extrusion +/// (0, 0.5, -√3/2) the OCS axes are x = (-1,0,0) and y = (0, √3/2, 1/2), and the elevation of 2 +/// moves the plane by twice the normal, (0, 1, -√3): the square (1,0)..(3,2) lies over +/// (-3,1)..(-1,1+√3), its corners at a mean height of 1/2 - √3. +#[test] +fn tilted_2d_polyline_is_drawn_as_seen_from_above() { + let square = |n: &str| { + format!( + "0\nSECTION\n2\nENTITIES\n0\nPOLYLINE\n8\n0\n66\n1\n10\n0\n20\n0\n30\n2\n70\n1\n{n}\ + 0\nVERTEX\n8\n0\n10\n1\n20\n0\n0\nVERTEX\n8\n0\n10\n3\n20\n0\n0\nVERTEX\n8\n0\n10\n3\n20\n2\n\ + 0\nVERTEX\n8\n0\n10\n1\n20\n2\n0\nSEQEND\n0\nENDSEC\n0\nEOF\n" + ) + }; + let d = read(square("210\n0\n220\n0.5\n230\n-0.8660254037844386\n").as_bytes(), "p.dxf").unwrap(); + let b = d.extents(&Space::Model); + let r3 = 3f64.sqrt(); + for (got, want) in [(b.min.x, -3.0), (b.min.y, 1.0), (b.max.x, -1.0), (b.max.y, 1.0 + r3)] { + assert!((got - want).abs() < 1e-9, "extents {b:?}"); + } + let e = d.model.iter().next().unwrap(); + assert_eq!(e.common.extrusion, Vec3::Z, "its points are plan coordinates now"); + let EntityKind::LwPolyline(p) = &e.kind else { panic!("not a polyline") }; + assert!((p.elevation - (0.5 - r3)).abs() < 1e-9, "the mean height of its corners: {}", p.elevation); + // In plan and in the mirrored plane the polyline stays as it was: mirrored only in x. + let plain = read(square("").as_bytes(), "p.dxf").unwrap(); + let b = plain.extents(&Space::Model); + assert!((b.min.x - 1.0).abs() < 1e-9 && (b.max.y - 2.0).abs() < 1e-9, "extents {b:?}"); + let mirrored = read(square("210\n0\n220\n0\n230\n-1\n").as_bytes(), "p.dxf").unwrap(); + let b = mirrored.extents(&Space::Model); + assert!((b.min.x + 3.0).abs() < 1e-9 && (b.max.x + 1.0).abs() < 1e-9, "extents {b:?}"); + assert_eq!(mirrored.model.iter().next().unwrap().common.extrusion, Vec3::new(0.0, 0.0, -1.0)); +} + +/// A tilted 2D POLYLINE with an arc keeps its shape as seen from above: the half circle from +/// (0,0) to (2,0) is flattened into its half ellipse, in plan x from -2 to 0 and reaching √3/2. +#[test] +fn tilted_2d_polyline_arc_is_flattened() { + let text = "0\nSECTION\n2\nENTITIES\n0\nPOLYLINE\n8\n0\n66\n1\n10\n0\n20\n0\n30\n0\n70\n0\n210\n0\n220\n0.5\n230\n-0.8660254037844386\n\ + 0\nVERTEX\n8\n0\n10\n0\n20\n0\n42\n1\n0\nVERTEX\n8\n0\n10\n2\n20\n0\n0\nSEQEND\n0\nENDSEC\n0\nEOF\n"; + let d = read(text.as_bytes(), "p.dxf").unwrap(); + let p = first(&d, |k| if let EntityKind::LwPolyline(p) = k { Some(p.clone()) } else { None }); + assert!(p.vertices.len() > 8 && p.vertices.iter().all(|v| v.bulge == 0.0), "{} vertices", p.vertices.len()); + let b = d.extents(&Space::Model); + // Bulge 1 turns counter-clockwise from (0,0) to (2,0), so the arc runs below its chord, down + // to OCS y -1: plan y -√3/2. + for (got, want) in [(b.min.x, -2.0), (b.max.x, 0.0), (b.min.y, -(3f64.sqrt()) / 2.0), (b.max.y, 0.0)] { + assert!((got - want).abs() < 5e-3, "extents {b:?}"); + } +} + /// The model extents of a one-loop solid HATCH whose edge boundary is `edges` (group 72 onwards). fn hatch_edge_extents(edges: &str) -> Bounds2 { let n = edges.matches("72\n").count(); diff --git a/crates/io/tests/it/layout_plot_flags.rs b/crates/io/tests/it/layout_plot_flags.rs new file mode 100644 index 000000000..35d6cdeb9 --- /dev/null +++ b/crates/io/tests/it/layout_plot_flags.rs @@ -0,0 +1,74 @@ +//! #3227: saving kept the layout's plot flags only for the bits CADCraft models and forced 512 +//! (plot paper space last), 32 (plot with plot styles) and 16 (standard scale) on, so a layout +//! with flags 0 came back as 560, in DXF and in DWG. + +use cadcraft_doc::{Drawing, Layout, PageSetup}; +use cadcraft_io::{read, write}; + +/// A drawing with layout SHEET read with plot layout `flags` (lineweights, centring and display +/// plot styles follow them, as the reader sets them). +fn drawing(flags: i64) -> Drawing { + let mut d = Drawing::new_imperial(); + let mut l = Layout::new("SHEET", 1); + l.page = PageSetup { + lineweights: flags & 128 != 0, + center: flags & 4 != 0, + show_plot_styles: flags & 2 != 0, + file_plot_flags: Some(flags), + ..PageSetup::default() + }; + d.layouts.push(l); + d +} + +/// The plot layout flags of SHEET after saving `d` as `name` and reading it back. +fn flags_after_save(d: &Drawing, name: &str) -> Option { + let bytes = write(d, name).unwrap(); + let back = read(&bytes, name).unwrap(); + back.layouts.iter().find(|l| l.name == "SHEET")?.page.file_plot_flags +} + +#[test] +fn plot_layout_flags_are_saved_as_read() { + cadcraft_io::dwg_worker::allow_in_process(); + for name in ["sheet.dxf", "sheet.dwg"] { + for flags in [0, 176, 560, 688] { + assert_eq!(flags_after_save(&drawing(flags), name), Some(flags), "{name}: flags {flags}"); + } + } +} + +#[test] +fn an_unchanged_standard_scale_keeps_its_flag_and_choice() { + cadcraft_io::dwg_worker::allow_in_process(); + // Flags 176 with standard scale 25 (1:50): the scale is 0.02, not 1:1, and still standard. + let mut d = drawing(176); + let page = &mut d.layouts.last_mut().unwrap().page; + page.scale = 0.02; + page.file_standard_scale = Some((25, 0.02)); + for name in ["sheet.dxf", "sheet.dwg"] { + let back = read(&write(&d, name).unwrap(), name).unwrap(); + let page = &back.layouts.iter().find(|l| l.name == "SHEET").unwrap().page; + assert_eq!(page.file_plot_flags, Some(176), "{name}"); + assert_eq!(page.file_standard_scale, Some((25, 0.02)), "{name}"); + } + // A scale changed after reading is a custom one: 16 is cleared and the choice dropped. + d.layouts.last_mut().unwrap().page.scale = 0.05; + assert_eq!(flags_after_save(&d, "sheet.dxf"), Some(160)); +} + +#[test] +fn the_page_still_decides_the_bits_cadcraft_models() { + // Lineweights turned on and a custom scale chosen after reading flags 16: 128 is set and the + // standard scale bit cleared, the rest kept. + let mut d = drawing(16 | 512); + let page = &mut d.layouts.last_mut().unwrap().page; + page.lineweights = true; + page.scale = 0.02; + assert_eq!(flags_after_save(&d, "sheet.dxf"), Some(512 | 128)); + // A page made in CADCraft keeps the defaults (plot paper space last, plot with plot styles, + // standard scale, lineweights). + let mut d = drawing(0); + d.layouts.last_mut().unwrap().page = PageSetup::default(); + assert_eq!(flags_after_save(&d, "sheet.dxf"), Some(512 | 128 | 32 | 16)); +} diff --git a/crates/io/tests/it/main.rs b/crates/io/tests/it/main.rs index 0e53c4536..42d3b28fd 100644 --- a/crates/io/tests/it/main.rs +++ b/crates/io/tests/it/main.rs @@ -36,6 +36,7 @@ mod helix_roundtrip; mod layer_states_acad; mod layout_limits_roundtrip; mod layout_paper_units; +mod layout_plot_flags; mod layout_plot_window; mod leader_vertex_elevation; #[cfg(not(target_arch = "wasm32"))] diff --git a/crates/io/tests/it/roundtrip/collections.rs b/crates/io/tests/it/roundtrip/collections.rs index 6315fbed9..95acb6328 100644 --- a/crates/io/tests/it/roundtrip/collections.rs +++ b/crates/io/tests/it/roundtrip/collections.rs @@ -257,7 +257,8 @@ pub(super) fn assert_layouts(a: &Drawing, b: &Drawing, context: &str) { let back = b.layouts.iter().find(|l| l.name == layout.name).expect("layout must survive"); assert_eq!(back.tab_order, layout.tab_order, "{context}.{}.tab_order", layout.name); // The groups 44, 45 and 73 the file stored are provenance, not a setting. - let setting = |p: &cadcraft_doc::PageSetup| cadcraft_doc::PageSetup { file_paper: None, ..p.clone() }; + let setting = + |p: &cadcraft_doc::PageSetup| cadcraft_doc::PageSetup { file_paper: None, file_plot_flags: None, file_standard_scale: None, ..p.clone() }; assert_eq!(setting(&back.page), setting(&layout.page), "{context}.{}.page", layout.name); assert_eq!(back.view, layout.view, "{context}.{}.view", layout.name); compare::entities(a, b, &layout.entities, &back.entities, &format!("{context}.layout[{}]", layout.name)); diff --git a/crates/io/tests/it/tables_objects_roundtrip.rs b/crates/io/tests/it/tables_objects_roundtrip.rs index 17b21f742..502aafa3d 100644 --- a/crates/io/tests/it/tables_objects_roundtrip.rs +++ b/crates/io/tests/it/tables_objects_roundtrip.rs @@ -112,7 +112,7 @@ fn layout_page_setup_and_paper_view_round_trip() { for (a, b) in d.layouts.iter().zip(&r.layouts) { assert_eq!(a.name, b.name); // The groups 44, 45 and 73 the file stored are provenance, not a setting. - let read = cadcraft_doc::PageSetup { file_paper: None, ..b.page.clone() }; + let read = cadcraft_doc::PageSetup { file_paper: None, file_plot_flags: None, file_standard_scale: None, ..b.page.clone() }; assert_eq!(a.page, read, "{}", a.name); assert_eq!(a.view, b.view, "{}", a.name); } diff --git a/crates/io/tests/registered_applications_kept.rs b/crates/io/tests/registered_applications_kept.rs new file mode 100644 index 000000000..1be4e0952 --- /dev/null +++ b/crates/io/tests/registered_applications_kept.rs @@ -0,0 +1,121 @@ +//! The registered applications (APPID) of a file are saved back, in DXF and in DWG, save after +//! save, also those no xdata names. + +use cadcraft_doc::Drawing; +use cadcraft_io::{read, read_dxf, write, write_dxf}; + +/// The records of a DXF: each `(code, value)` from its `0` group on. +fn records(text: &str) -> Vec> { + let lines: Vec<&str> = text.lines().collect(); + let mut out: Vec> = Vec::new(); + for chunk in lines.chunks(2) { + let [code, value] = chunk else { break }; + let Ok(c) = code.trim().parse::() else { continue }; + let pair = (c, value.trim().to_string()); + if c == 0 { + out.push(vec![pair]); + } else if let Some(r) = out.last_mut() { + r.push(pair); + } + } + out +} + +/// The value of the record's first group `code`. +fn value(r: &[(i32, String)], code: i32) -> Option<&str> { + r.iter().find(|(c, _)| *c == code).map(|(_, v)| v.as_str()) +} + +/// A file whose APPID table has `Other_App` (handle 7A00), which no xdata names; with `xdata`, +/// a line's xdata names it as `OTHER_APP`. +fn source(xdata: bool) -> String { + let mut out = String::new(); + let mut put = |c: i32, v: &str| out.push_str(&format!("{c:>3}\n{v}\n")); + for r in records(&write_dxf(&Drawing::new_metric())) { + for (c, v) in &r { + put(*c, v); + } + if xdata && r[0].1 == "SECTION" && value(&r, 2) == Some("ENTITIES") { + for (c, v) in [ + (0, "LINE"), + (5, "7A01"), + (100, "AcDbEntity"), + (8, "0"), + (100, "AcDbLine"), + (10, "0"), + (20, "0"), + (30, "0"), + (11, "10"), + (21, "0"), + (31, "0"), + (1001, "OTHER_APP"), + (1000, "x"), + ] { + put(c, v); + } + } + if r[0].1 == "TABLE" && value(&r, 2) == Some("APPID") { + let table = value(&r, 5).unwrap_or("0").to_string(); + for (c, v) in [ + (0, "APPID"), + (5, "7A00"), + (330, table.as_str()), + (100, "AcDbSymbolTableRecord"), + (100, "AcDbRegAppTableRecord"), + (2, "Other_App"), + (70, "0"), + ] { + put(c, v); + } + } + } + out +} + +/// How many APPID records of the DXF are named `Other_App`, in any case. +fn appids(text: &str) -> usize { + records(text).into_iter().filter(|r| r[0].1 == "APPID" && value(r, 2).is_some_and(|n| n.eq_ignore_ascii_case("Other_App"))).count() +} + +#[test] +fn registered_applications_no_xdata_names_are_kept() { + cadcraft_io::dwg_worker::allow_in_process(); + let mut d = read_dxf(source(false).as_bytes()).expect("read"); + for generation in 1..=2 { + let text = write_dxf(&d); + assert_eq!(appids(&text), 1, "DXF {generation}"); + d = read_dxf(text.as_bytes()).expect("reread"); + } + for generation in 1..=2 { + let dwg = write(&d, "kept.dwg").expect("DWG"); + d = read(&dwg, "kept.dwg").expect("DWG read"); + assert_eq!(appids(&write_dxf(&d)), 1, "DWG {generation}"); + } +} + +/// An application both registered and named by xdata, in another case, gets one record. +#[test] +fn a_registered_application_xdata_names_gets_one_record() { + cadcraft_io::dwg_worker::allow_in_process(); + let mut d = read_dxf(source(true).as_bytes()).expect("read"); + for generation in 1..=2 { + let text = write_dxf(&d); + assert!(text.contains("OTHER_APP"), "DXF {generation}: the line's xdata is kept"); + assert_eq!(appids(&text), 1, "DXF {generation}"); + d = read_dxf(text.as_bytes()).expect("reread"); + } + for generation in 1..=2 { + let dwg = write(&d, "kept.dwg").expect("DWG"); + d = read(&dwg, "kept.dwg").expect("DWG read"); + assert_eq!(appids(&write_dxf(&d)), 1, "DWG {generation}"); + } +} + +/// Registered applications alone are not kept objects: a file with nothing else to keep notes no +/// version, so the DWG writer reads its R2000 text as before rather than as the file's version. +#[test] +fn registered_applications_alone_note_no_version() { + let d = read_dxf(source(false).as_bytes()).expect("read"); + assert!(d.foreign.appids.iter().any(|n| n == "Other_App"), "{:?}", d.foreign.appids); + assert_eq!(d.foreign.version, None); +} diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs index 48682f050..62aedc1a6 100644 --- a/crates/ui-egui/src/context_menu.rs +++ b/crates/ui-egui/src/context_menu.rs @@ -133,8 +133,8 @@ pub fn entries(app: &CadApp) -> Vec> { } /// The edit commands of the selected objects' type (when they are all of one type), with their -/// labels: Edit Text for text, Block Editor and Edit Attributes for block references, Hatch Edit, -/// Polyline Edit, Spline Edit… +/// labels: Edit Text for text, Block Editor and Edit Attributes for block references, Hatch Edit +/// and Generate Boundary for hatches, Polyline Edit, Spline Edit… fn object_commands(app: &CadApp) -> Vec<(&'static str, Option<&'static str>)> { let Ok(d) = app.session.doc() else { return Vec::new() }; let sel = app.session.selection(); @@ -153,7 +153,7 @@ fn object_commands(app: &CadApp) -> Vec<(&'static str, Option<&'static str>)> { } v } - EntityKind::Hatch(_) => vec![("hatchedit", None)], + EntityKind::Hatch(_) => vec![("hatchedit", None), ("hatchgenerateboundary", None)], EntityKind::LwPolyline(_) | EntityKind::Polyline3d(_) => vec![("pedit", Some("Polyline Edit"))], EntityKind::Spline(_) => vec![("splinedit", Some("Spline Edit"))], EntityKind::Dimension(_) => vec![("dimtedit", None)], diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv index 88eb14515..207b0ac5e 100644 --- a/crates/ui-egui/src/i18n/es.tsv +++ b/crates/ui-egui/src/i18n/es.tsv @@ -374,6 +374,7 @@ From Desde From Template... Desde plantilla... General General + Generate Boundary Generar contorno Geometric Center Centro geométrico Geometric Constraint Restricción geométrica Geometric Constraints Restricciones geométricas diff --git a/crates/ui-egui/src/i18n/zh.tsv b/crates/ui-egui/src/i18n/zh.tsv index 2d0a6faa5..5d5972061 100644 --- a/crates/ui-egui/src/i18n/zh.tsv +++ b/crates/ui-egui/src/i18n/zh.tsv @@ -296,6 +296,7 @@ Freeze/Thaw in the current viewport 在当前视口中冻结/解冻 From 自 General 常规 + Generate Boundary 生成边界 Geometric Center 几何中心 Geometric Constraint 几何约束 Geometric Constraints 几何约束