a770fa5a5e5f
dxf_mleader.rs
//! Multileaders in DXF (DXF Reference: MULTILEADER entity). The entity's own groups (style,
//! leader type, landing and dogleg switches, content type, block attribute values) come after
//! the `AcDbMLeader` marker; the geometry lives in nested sections that reuse the same group
//! codes: `300 CONTEXT_DATA{` … `301 }` holds the content (MText or block) and the plane, each
//! `302 LEADER{` … `303 }` inside it a landing point with its dogleg, and each
//! `304 LEADER_LINE{` … `305 }` inside that the vertices of one leader line from the arrowhead.
//!
//! The reader walks those sections with a level counter over the record's tags, so an
//! unterminated or unbalanced section ends with the record; counts of leaders, lines,
//! vertices and attribute values are capped.
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use cadcraft_doc::{Attrib, Drawing, Entity, EntityKind, Handle, Insert, MLeader, MLeaderStyle, MText};
use cadcraft_geom::Vec3;
use craft_dxf::Tag;
/// Most leader roots (landings) read per multileader.
const MAX_ROOTS: usize = 256;
/// Most leader lines read per multileader, over all its roots.
const MAX_LINES: usize = 4096;
/// Most leader line vertices read per multileader.
const MAX_VERTICES: usize = 100_000;
/// Most block attribute values read per multileader.
const MAX_ATTRIBS: usize = 4096;
/// ByBlock as a 32-bit colour value (0xC1000000).
const BYBLOCK: i64 = -1_056_964_608;
/// No background colour (0xC8000000).
const NO_COLOR: i64 = -939_524_096;
/// Data of a multileader that needs the file's objects: its MLEADERSTYLE handle and the values
/// of its block attributes by ATTDEF handle (all upper case).
#[derive(Debug, Default)]
pub(crate) struct Pending {
style: Option<String>,
attribs: Vec<(String, String)>,
}
/// A point read group by group (x, then y and z).
#[derive(Clone, Copy, Default)]
struct P {
x: Option<f64>,
y: Option<f64>,
z: Option<f64>,
}
impl P {
/// Take group `code` when it is coordinate `base`, `base + 10` or `base + 20`.
fn take(&mut self, base: i32, code: i32, v: f64) -> bool {
let slot = match code - base {
0 => &mut self.x,
10 => &mut self.y,
20 => &mut self.z,
_ => return false,
};
*slot = Some(v);
true
}
fn get(&self) -> Option<Vec3> {
self.x.map(|x| Vec3::new(x, self.y.unwrap_or(0.0), self.z.unwrap_or(0.0)))
}
}
#[derive(Default)]
struct Root {
landing: P,
dogleg: Option<f64>,
lines: Vec<Vec<Vec3>>,
}
#[derive(Default)]
struct Parsed {
// Entity level.
style: Option<String>,
leader_type: Option<i64>,
dogleg_on: Option<bool>,
dogleg: Option<f64>,
arrow: Option<f64>,
content: Option<i64>,
text_style: Option<String>,
block: Option<String>,
block_scale: P,
block_rotation: Option<f64>,
attribs: Vec<(String, String)>,
// CONTEXT_DATA.
base: P,
text_height: Option<f64>,
arrow_ctx: Option<f64>,
has_text: Option<bool>,
text: Option<String>,
text_style_ctx: Option<String>,
text_location: P,
text_direction: P,
text_rotation: Option<f64>,
text_width: Option<f64>,
line_spacing: Option<f64>,
line_spacing_style: Option<i64>,
/// Text side (171: 1 left, 2 centre, 3 right).
side: Option<i64>,
/// How the text's left / right side attaches to the landing (174 / 175, or 173 / 95 on
/// the entity): which line of the text the landing points at.
left_attach: Option<i64>,
right_attach: Option<i64>,
has_block: Option<bool>,
block_ctx: Option<String>,
block_location: P,
block_scale_ctx: P,
block_rotation_ctx: Option<f64>,
roots: Vec<Root>,
}
#[derive(Clone, Copy, PartialEq)]
enum Level {
Entity,
Context,
Root,
Line,
}
fn handle(t: &Tag) -> Option<String> {
let h = t.str().trim().to_ascii_uppercase();
(!h.is_empty() && h != "0").then_some(h)
}
fn finite(v: f64) -> Option<f64> {
v.is_finite().then_some(v)
}
fn parse(tags: &[Tag]) -> Parsed {
// The entity's own groups follow the AcDbMLeader marker (or, without one, the last marker).
let start =
tags.iter().position(|t| t.code == 100 && t.str() == "AcDbMLeader").or_else(|| tags.iter().rposition(|t| t.code == 100)).map_or(0, |i| i + 1);
let mut p = Parsed::default();
let mut lvl = Level::Entity;
// Whether the current root / line is kept (under the caps) and the last vertex was.
let (mut root_kept, mut line_kept, mut vertex_kept) = (false, false, false);
let (mut lines, mut vertices) = (0usize, 0usize);
let mut attrib: Option<String> = None;
for t in tags.get(start..).unwrap_or(&[]) {
let (c, f) = (t.code, t.f64());
match lvl {
Level::Entity => match c {
300 if t.str().trim_start().starts_with("CONTEXT_DATA") => lvl = Level::Context,
340 => p.style = handle(t),
170 => p.leader_type = Some(t.i64()),
291 => p.dogleg_on = Some(t.i64() != 0),
41 => p.dogleg = finite(f),
42 => p.arrow = finite(f),
172 => p.content = Some(t.i64()),
343 => p.text_style = handle(t),
344 => p.block = handle(t),
10 | 20 | 30 => {
p.block_scale.take(10, c, f);
}
43 => p.block_rotation = finite(f),
173 => p.left_attach = p.left_attach.or(Some(t.i64())),
95 => p.right_attach = p.right_attach.or(Some(t.i64())),
// Block attribute values: ATTDEF handle (330), index, width, then the text (302).
330 => attrib = handle(t),
302 => {
if let Some(h) = attrib.take()
&& p.attribs.len() < MAX_ATTRIBS
{
p.attribs.push((h, t.str()));
}
}
_ => {}
},
Level::Context => match c {
301 => lvl = Level::Entity,
302 if t.str().trim_start().starts_with("LEADER") => {
root_kept = p.roots.len() < MAX_ROOTS;
if root_kept {
p.roots.push(Root::default());
}
lvl = Level::Root;
}
10 | 20 | 30 => {
p.base.take(10, c, f);
}
41 => p.text_height = finite(f),
140 => p.arrow_ctx = finite(f),
290 => p.has_text = Some(t.i64() != 0),
304 => p.text = Some(t.str()),
340 => p.text_style_ctx = handle(t),
12 | 22 | 32 => {
p.text_location.take(12, c, f);
}
13 | 23 | 33 => {
p.text_direction.take(13, c, f);
}
42 => p.text_rotation = finite(f),
43 => p.text_width = finite(f),
45 => p.line_spacing = finite(f),
170 => p.line_spacing_style = Some(t.i64()),
171 => p.side = Some(t.i64()),
174 => p.left_attach = Some(t.i64()),
175 => p.right_attach = Some(t.i64()),
296 => p.has_block = Some(t.i64() != 0),
341 => p.block_ctx = handle(t),
15 | 25 | 35 => {
p.block_location.take(15, c, f);
}
16 | 26 | 36 => {
p.block_scale_ctx.take(16, c, f);
}
46 => p.block_rotation_ctx = finite(f),
_ => {}
},
Level::Root => match c {
303 => lvl = Level::Context,
301 => lvl = Level::Entity,
304 if t.str().trim_start().starts_with("LEADER_LINE") => {
line_kept = root_kept && lines < MAX_LINES;
if line_kept && let Some(r) = p.roots.last_mut() {
r.lines.push(Vec::new());
lines += 1;
}
vertex_kept = false;
lvl = Level::Line;
}
10 | 20 | 30 if root_kept => {
if let Some(r) = p.roots.last_mut() {
r.landing.take(10, c, f);
}
}
40 if root_kept => {
if let Some(r) = p.roots.last_mut() {
r.dogleg = finite(f);
}
}
_ => {}
},
Level::Line => match c {
305 => lvl = Level::Root,
303 => lvl = Level::Context,
301 => lvl = Level::Entity,
10 => {
vertex_kept = line_kept && vertices < MAX_VERTICES;
if vertex_kept && let Some(l) = p.roots.last_mut().and_then(|r| r.lines.last_mut()) {
l.push(Vec3::new(f, 0.0, 0.0));
vertices += 1;
}
}
20 | 30 if vertex_kept => {
if let Some(v) = p.roots.last_mut().and_then(|r| r.lines.last_mut()).and_then(|l| l.last_mut()) {
if c == 20 {
v.y = f;
} else {
v.z = f;
}
}
}
_ => {}
},
}
}
p
}
/// A MULTILEADER record as a multileader. Names that come from handles (style, text style,
/// block) are filled in by [`resolve`] and [`apply`].
pub(crate) fn read(tags: &[Tag]) -> MLeader {
let p = parse(tags);
let def = MLeaderStyle::default();
let pos = |v: Option<f64>| v.filter(|x| *x > 0.0);
// Leader lines: those of the first root run to its landing; a further root's lines get
// their own landing as a last vertex (one landing per multileader here).
let mut leaders: Vec<Vec<Vec3>> = Vec::new();
for (i, r) in p.roots.iter().enumerate() {
for l in r.lines.iter().filter(|l| !l.is_empty()) {
let mut l = l.clone();
if i > 0
&& let Some(land) = r.landing.get()
{
l.push(land);
}
leaders.push(l);
}
}
let none = p.leader_type == Some(0);
if none {
leaders.clear();
}
let text_location = p.text_location.get();
let block_location = p.block_location.get();
let landing = p.roots.iter().find_map(|r| r.landing.get()).or(p.base.get()).or(text_location).or(block_location).unwrap_or(Vec3::ZERO);
let dogleg = if leaders.is_empty() || p.dogleg_on == Some(false) {
0.0
} else {
p.roots.iter().find_map(|r| r.dogleg).or(p.dogleg).filter(|d| *d >= 0.0).unwrap_or(0.0)
};
let has_block = p.has_block.unwrap_or(p.content == Some(1));
let has_text = !has_block && p.has_text.unwrap_or(p.content == Some(2));
let text = has_text.then(|| {
let rotation = match p.text_direction.get() {
Some(d) if d.x != 0.0 || d.y != 0.0 => d.y.atan2(d.x),
_ => p.text_rotation.unwrap_or(0.0),
};
MText {
insert: text_location.unwrap_or(landing),
height: pos(p.text_height).unwrap_or(def.text_height),
width: p.text_width.unwrap_or(0.0).max(0.0),
attach: attach_point(&p, text_location.unwrap_or(landing).x < landing.x),
rotation,
style: def.text_style.clone(),
contents: p.text.clone().unwrap_or_default(),
line_spacing: pos(p.line_spacing).unwrap_or(1.0),
line_spacing_exact: p.line_spacing_style == Some(2),
columns: None,
}
});
let block = has_block.then(|| {
let scale = p.block_scale_ctx.get().or(p.block_scale.get()).unwrap_or(Vec3::new(1.0, 1.0, 1.0));
let nz = |v: f64| if v != 0.0 { v } else { 1.0 };
Insert {
block: String::new(),
insert: block_location.unwrap_or(landing),
scale: Vec3::new(nz(scale.x), nz(scale.y), nz(scale.z)),
rotation: p.block_rotation_ctx.or(p.block_rotation).unwrap_or(0.0),
attribs: Vec::new(),
cols: 1,
rows: 1,
col_spacing: 0.0,
row_spacing: 0.0,
clip: None,
}
});
MLeader {
leaders,
landing,
dogleg,
text,
style: def.name,
arrow_size: pos(p.arrow_ctx).or(pos(p.arrow)).unwrap_or(def.arrow_size),
spline: p.leader_type == Some(2),
block,
}
}
/// The MText attachment point (1..=9) of the text: its column from the text side (171), its
/// row from how the side facing the landing attaches (top line, middle or bottom line).
fn attach_point(p: &Parsed, text_left_of_landing: bool) -> u8 {
let col = p.side.unwrap_or(1).clamp(1, 3);
let side = if text_left_of_landing { p.right_attach.or(p.left_attach) } else { p.left_attach.or(p.right_attach) };
let row = match side.unwrap_or(0) {
2 | 9 => 1,
3..=5 => 2,
_ => 0,
};
u8::try_from(row * 3 + col).unwrap_or(1)
}
/// Text style and block names from the file's STYLE and BLOCK_RECORD handles (upper case →
/// name); block content whose block is unknown is dropped. Returns what needs the objects.
pub(crate) fn resolve(tags: &[Tag], m: &mut MLeader, styles: &HashMap<String, String>, brs: &HashMap<String, String>) -> Pending {
let p = parse(tags);
if let Some(t) = &mut m.text
&& let Some(n) = p.text_style_ctx.iter().chain(&p.text_style).find_map(|h| styles.get(h)).filter(|n| !n.is_empty())
{
t.style = n.clone();
}
if m.block.is_some() {
match p.block_ctx.iter().chain(&p.block).find_map(|h| brs.get(h)).filter(|n| !n.is_empty()) {
Some(n) => {
if let Some(b) = &mut m.block {
b.block = n.clone();
}
}
None => m.block = None,
}
}
Pending { style: p.style, attribs: p.attribs }
}
/// Multileader style names (by MLEADERSTYLE handle, from the ACAD_MLEADERSTYLE dictionary) and
/// block attribute values (by the ATTDEF of the content block), for multileaders in model
/// space, the layouts and block definitions.
pub(crate) fn apply(d: &mut Drawing, fixes: &[(Handle, Pending)], names: &HashMap<String, String>) {
let fixes: Vec<&(Handle, Pending)> = fixes.iter().filter(|(_, p)| p.style.is_some() || !p.attribs.is_empty()).collect();
if fixes.is_empty() {
return;
}
// Block definitions holding the multileaders that are in no space.
let wanted: HashSet<Handle> = fixes.iter().map(|(h, _)| *h).filter(|h| d.entity(*h).is_none()).collect();
let mut owner: HashMap<Handle, String> = HashMap::new();
if !wanted.is_empty() {
for (name, b) in &d.blocks {
for e in b.entities.iter().filter(|e| wanted.contains(&e.handle)) {
owner.entry(e.handle).or_insert_with(|| name.clone());
}
}
}
for (h, pend) in fixes {
let block_of = owner.get(h);
let current = match block_of {
Some(b) => d.block(b).and_then(|b| b.entities.get(*h)),
None => d.entity(*h),
};
let Some(EntityKind::MLeader(m)) = current.map(|e| &e.kind) else { continue };
let mut m = m.clone();
if let Some(s) = pend.style.as_ref().and_then(|s| names.get(s)).filter(|n| !n.is_empty()) {
m.style = s.clone();
}
if !pend.attribs.is_empty()
&& let Some(ins) = &m.block
{
let a = attribs(d, ins, &pend.attribs);
if let Some(ins) = &mut m.block {
ins.attribs = a;
}
}
let set = |e: &mut Entity| e.kind = EntityKind::MLeader(m);
match block_of {
Some(b) => {
if let Some(b) = d.blocks.get_mut(b) {
Arc::make_mut(b).entities.modify(*h, set);
}
}
None => {
let _ = d.modify_entity(*h, set);
}
}
}
}
/// The attributes of a multileader's block content: each value placed like its ATTDEF.
fn attribs(d: &Drawing, ins: &Insert, values: &[(String, String)]) -> Vec<Attrib> {
let Some(blk) = d.block(&ins.block) else { return Vec::new() };
let m = ins.transform(blk.base.xy());
let mut out = Vec::new();
for (h, value) in values {
let def = Handle::parse_hex(h).and_then(|h| blk.entities.get(h));
let Some(EntityKind::AttDef(ad)) = def.map(|e| &e.kind) else { continue };
let mut k = EntityKind::Text(ad.text.clone());
k.transform(&m);
let EntityKind::Text(mut text) = k else { continue };
text.value = value.clone();
out.push(Attrib {
tag: ad.tag.clone(),
text,
invisible: ad.invisible,
constant: false,
prompt: String::new(),
props: Default::default(),
multiline: None,
modes: Default::default(),
});
}
out
}
/// What a MULTILEADER record points at in the file being written.
pub(crate) struct Refs {
/// MLEADERSTYLE handle.
pub style: String,
/// STYLE record handle of the text.
pub text_style: Option<String>,
/// BLOCK_RECORD handle of the content block.
pub block: Option<String>,
}
/// The groups of a MULTILEADER record after its `AcDbMLeader` marker.
pub(crate) fn entity_tags(d: &Drawing, m: &MLeader, r: &Refs) -> Vec<Tag> {
let mut t: Vec<Tag> = Vec::new();
let s = |t: &mut Vec<Tag>, c: i32, v: &str| t.push(Tag::s(c, v));
let f = |t: &mut Vec<Tag>, c: i32, v: f64| t.push(Tag::f(c, v));
let i = |t: &mut Vec<Tag>, c: i32, v: i64| t.push(Tag::i(c, v));
let p = |t: &mut Vec<Tag>, c: i32, v: Vec3| {
t.push(Tag::f(c, v.x));
t.push(Tag::f(c + 10, v.y));
t.push(Tag::f(c + 20, v.z));
};
let style = d.mleader_styles.iter().find(|x| x.name.eq_ignore_ascii_case(&m.style)).cloned().unwrap_or_default();
// Block content wins over text when an entity has both (DXF has one content type).
let block = m.block.as_ref().zip(r.block.as_ref());
let text = if block.is_some() { None } else { m.text.as_ref() };
let content_pt = block.map(|(b, _)| b.insert).or(text.map(|x| x.insert));
let dir = if content_pt.is_some_and(|c| c.x < m.landing.x) { -1.0 } else { 1.0 };
let attach = text.map_or(1, |x| x.attach.clamp(1, 9));
// The text's row as its attachment to the landing (top of top line, middle of text,
// bottom of bottom line) and its column as the text side and alignment.
let vert = match attach {
1..=3 => 0,
4..=6 => 2,
_ => 4,
};
let align = i64::from((attach - 1) % 3);
i(&mut t, 270, 2);
s(&mut t, 300, "CONTEXT_DATA{");
f(&mut t, 40, 1.0);
p(&mut t, 10, m.landing + Vec3::new(m.dogleg * dir, 0.0, 0.0));
f(&mut t, 41, text.map_or(style.text_height, |x| x.height));
f(&mut t, 140, m.arrow_size);
f(&mut t, 145, style.landing_gap);
i(&mut t, 174, vert);
i(&mut t, 175, vert);
i(&mut t, 176, align);
i(&mut t, 177, 1);
i(&mut t, 290, i64::from(text.is_some()));
if let Some(x) = text {
s(&mut t, 304, &x.contents);
p(&mut t, 11, Vec3::Z);
if let Some(h) = &r.text_style {
s(&mut t, 340, h);
}
p(&mut t, 12, x.insert);
p(&mut t, 13, Vec3::new(x.rotation.cos(), x.rotation.sin(), 0.0));
f(&mut t, 42, x.rotation);
f(&mut t, 43, x.width);
f(&mut t, 44, 0.0);
f(&mut t, 45, x.line_spacing);
i(&mut t, 170, if x.line_spacing_exact { 2 } else { 1 });
i(&mut t, 90, BYBLOCK);
i(&mut t, 171, align + 1);
i(&mut t, 172, 1);
i(&mut t, 91, NO_COLOR);
f(&mut t, 141, 1.5);
i(&mut t, 92, 0);
i(&mut t, 291, 0);
i(&mut t, 292, 0);
i(&mut t, 173, 0);
i(&mut t, 293, 0);
f(&mut t, 142, 0.0);
f(&mut t, 143, 0.0);
i(&mut t, 294, 0);
i(&mut t, 295, 0);
}
i(&mut t, 296, i64::from(block.is_some()));
if let Some((b, h)) = block {
s(&mut t, 341, h);
p(&mut t, 14, Vec3::Z);
p(&mut t, 15, b.insert);
p(&mut t, 16, b.scale);
f(&mut t, 46, b.rotation);
i(&mut t, 93, BYBLOCK);
// Block → world, row by row.
let base = d.block(&b.block).map_or(Vec3::ZERO, |x| x.base);
let mx = b.transform(base.xy());
let z = b.insert.z - b.scale.z * base.z;
for v in [mx.a, mx.c, 0.0, mx.e, mx.b, mx.d, 0.0, mx.f, 0.0, 0.0, b.scale.z, z, 0.0, 0.0, 0.0, 1.0] {
f(&mut t, 47, v);
}
}
p(&mut t, 110, Vec3::new(0.0, 0.0, m.landing.z));
p(&mut t, 111, Vec3::new(1.0, 0.0, 0.0));
p(&mut t, 112, Vec3::new(0.0, 1.0, 0.0));
i(&mut t, 297, 0);
if !m.leaders.is_empty() {
s(&mut t, 302, "LEADER{");
i(&mut t, 290, 1);
i(&mut t, 291, 1);
p(&mut t, 10, m.landing);
p(&mut t, 11, Vec3::new(dir, 0.0, 0.0));
i(&mut t, 90, 0);
f(&mut t, 40, m.dogleg);
for (n, l) in m.leaders.iter().enumerate() {
s(&mut t, 304, "LEADER_LINE{");
for v in l {
p(&mut t, 10, *v);
}
i(&mut t, 91, i64::try_from(n).unwrap_or(i64::MAX));
s(&mut t, 305, "}");
}
i(&mut t, 271, 0);
s(&mut t, 303, "}");
}
i(&mut t, 272, 9);
i(&mut t, 273, 9);
s(&mut t, 301, "}");
s(&mut t, 340, &r.style);
// Overridden properties: leader type, landing and dogleg, arrowhead size, content type,
// text style and height, block content (the entity holds its own values).
i(&mut t, 90, 0x1 | 0x10 | 0x40 | 0x80 | 0x200 | 0x400 | 0x800 | 0x1_0000 | 0x8_0000);
i(
&mut t,
170,
if m.leaders.is_empty() {
0
} else if m.spline {
2
} else {
1
},
);
i(&mut t, 91, BYBLOCK);
i(&mut t, 171, -2);
i(&mut t, 290, 1);
i(&mut t, 291, i64::from(m.dogleg > 0.0));
f(&mut t, 41, m.dogleg);
f(&mut t, 42, m.arrow_size);
i(
&mut t,
172,
if block.is_some() {
1
} else if text.is_some() {
2
} else {
0
},
);
if let Some(h) = &r.text_style {
s(&mut t, 343, h);
}
i(&mut t, 173, vert);
i(&mut t, 95, vert);
i(&mut t, 174, 1);
i(&mut t, 175, align);
i(&mut t, 92, BYBLOCK);
i(&mut t, 292, 0);
if let Some((b, h)) = block {
s(&mut t, 344, h);
i(&mut t, 93, BYBLOCK);
p(&mut t, 10, b.scale);
f(&mut t, 43, b.rotation);
i(&mut t, 176, 1);
// Attribute values by their ATTDEF in the block.
let defs: Vec<(Handle, &str)> = d
.block(&b.block)
.map(|blk| {
blk.entities
.iter()
.filter_map(|e| if let EntityKind::AttDef(ad) = &e.kind { Some((e.handle, ad.tag.as_str())) } else { None })
.collect()
})
.unwrap_or_default();
let mut n = 0i64;
for a in &b.attribs {
let Some((h, _)) = defs.iter().find(|(_, tag)| tag.eq_ignore_ascii_case(&a.tag)) else { continue };
s(&mut t, 330, &h.hex());
i(&mut t, 177, n);
f(&mut t, 44, 0.0);
s(&mut t, 302, &a.text.value);
n += 1;
}
}
i(&mut t, 293, 0);
i(&mut t, 294, 0);
i(&mut t, 178, 0);
i(&mut t, 179, 1);
f(&mut t, 45, 1.0);
i(&mut t, 271, 0);
i(&mut t, 272, 9);
i(&mut t, 273, 9);
t
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.