2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Functionality for reading/writing elements (geometry, text labels,
|
|
|
|
|
/// structure references) and associated properties.
|
|
|
|
|
///
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2025-04-10 01:07:11 -07:00
|
|
|
use crate::records::{
|
|
|
|
|
//BOX, BOUNDARY, NODE, PATH, TEXT, SREF, AREF,
|
2022-05-20 19:44:17 -07:00
|
|
|
DATATYPE, PATHTYPE, BOXTYPE, NODETYPE, TEXTTYPE,
|
|
|
|
|
LAYER, XY, WIDTH, COLROW, PRESENTATION, STRING,
|
|
|
|
|
STRANS, MAG, ANGLE, PROPATTR, PROPVALUE,
|
|
|
|
|
ENDEL, BGNEXTN, ENDEXTN, SNAME,
|
|
|
|
|
};
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2022-05-08 16:41:43 -07:00
|
|
|
use crate::records;
|
|
|
|
|
use crate::record::{RecordHeader, Record};
|
2025-04-10 01:07:11 -07:00
|
|
|
use crate::basic::{IResult, fail, take_bytes}; //OResult
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2025-04-10 01:07:11 -07:00
|
|
|
use std::string::String;
|
2021-12-18 21:05:00 -08:00
|
|
|
use std::collections::HashMap;
|
2025-04-10 01:07:11 -07:00
|
|
|
//use std::io::Write;
|
|
|
|
|
|
|
|
|
|
use arrow::array::{
|
2025-04-12 12:06:36 -07:00
|
|
|
StructBuilder, FixedSizeListBuilder, ListBuilder, StringBuilder, ArrayBuilder, BooleanBuilder,
|
2025-04-22 20:16:38 -07:00
|
|
|
Int32Builder, Int16Builder, UInt64Builder, UInt32Builder, UInt8Builder, Float64Builder,
|
2025-04-10 01:07:11 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2025-04-11 11:18:56 -07:00
|
|
|
pub type DListBuilder = ListBuilder<Box<dyn ArrayBuilder>>;
|
2025-04-12 12:06:36 -07:00
|
|
|
pub type FListBuilder = FixedSizeListBuilder<Box<dyn ArrayBuilder>>;
|
2025-04-10 01:07:11 -07:00
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
struct PropertyRecord {
|
|
|
|
|
key: i16,
|
|
|
|
|
value: String,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct BoundaryRecord {
|
|
|
|
|
layer_id: u32,
|
|
|
|
|
vertices: Vec<i32>,
|
|
|
|
|
properties: Vec<PropertyRecord>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct BoundaryBatchRecord {
|
|
|
|
|
layer_id: u32,
|
|
|
|
|
vertices: Vec<i32>,
|
|
|
|
|
vertex_offsets: Vec<u32>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct RectBatchRecord {
|
|
|
|
|
layer_id: u32,
|
|
|
|
|
rects: Vec<i32>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct SRefRecord {
|
|
|
|
|
target_id: u32,
|
|
|
|
|
invert_y: bool,
|
|
|
|
|
scale: f64,
|
|
|
|
|
angle_rad: f64,
|
|
|
|
|
xy: u64,
|
|
|
|
|
properties: Vec<PropertyRecord>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct ARefRecord {
|
|
|
|
|
target_id: u32,
|
|
|
|
|
invert_y: bool,
|
|
|
|
|
scale: f64,
|
|
|
|
|
angle_rad: f64,
|
|
|
|
|
xy: u64,
|
|
|
|
|
xy0: u64,
|
|
|
|
|
xy1: u64,
|
|
|
|
|
counts: u32,
|
|
|
|
|
properties: Vec<PropertyRecord>,
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-14 14:27:09 -08:00
|
|
|
#[derive(Clone)]
|
|
|
|
|
pub struct ScanRefRecord {
|
|
|
|
|
pub target_id: u32,
|
|
|
|
|
pub invert_y: bool,
|
|
|
|
|
pub scale: f64,
|
|
|
|
|
pub angle_rad: f64,
|
|
|
|
|
pub xy: u64,
|
|
|
|
|
pub xy0: u64,
|
|
|
|
|
pub xy1: u64,
|
|
|
|
|
pub counts: u32,
|
|
|
|
|
}
|
|
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
enum RefRecord {
|
|
|
|
|
SRef(SRefRecord),
|
|
|
|
|
ARef(ARefRecord),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const UNIT_COUNTS: u32 = (1_u32 << 16) | 1_u32;
|
2026-11-14 14:27:09 -08:00
|
|
|
const ZERO_XY: u64 = 0;
|
2026-04-02 20:22:15 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
fn layer_id_for(
|
|
|
|
|
layer: i16,
|
|
|
|
|
dtype: i16,
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
) -> u32 {
|
|
|
|
|
let layer32 = ((layer as u16 as u32) << 16) | (dtype as u16 as u32);
|
|
|
|
|
let next_id = layers.len();
|
|
|
|
|
*layers.entry(layer32).or_insert(next_id.try_into().unwrap())
|
|
|
|
|
}
|
|
|
|
|
|
2025-04-10 01:07:11 -07:00
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
fn insert_layer(
|
|
|
|
|
layer: i16,
|
|
|
|
|
dtype: i16,
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
struct_builder: &mut StructBuilder,
|
|
|
|
|
field_index: usize,
|
|
|
|
|
) {
|
2026-04-02 20:22:15 -07:00
|
|
|
let id = layer_id_for(layer, dtype, layers);
|
2025-04-20 23:21:54 -07:00
|
|
|
let layer_builder = struct_builder.field_builder::<UInt32Builder>(field_index).unwrap();
|
2026-04-02 20:22:15 -07:00
|
|
|
layer_builder.append_value(id);
|
2025-04-20 23:21:54 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pub fn read_elements<'a>(
|
|
|
|
|
input: &'a [u8],
|
|
|
|
|
cell_builder: &mut StructBuilder,
|
|
|
|
|
names: &mut HashMap<String, u32>,
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
) -> IResult<'a, ()> {
|
2025-04-12 12:06:36 -07:00
|
|
|
let mut input = input;
|
2026-04-02 20:22:15 -07:00
|
|
|
let mut boundaries = Vec::<BoundaryRecord>::new();
|
|
|
|
|
let mut srefs = Vec::<SRefRecord>::new();
|
|
|
|
|
let mut arefs = Vec::<ARefRecord>::new();
|
2025-04-12 12:06:36 -07:00
|
|
|
let (_, mut header) = RecordHeader::read(input)?; // don't consume tag
|
2025-04-10 01:07:11 -07:00
|
|
|
while header.tag != records::RTAG_ENDSTR {
|
2025-04-12 12:06:36 -07:00
|
|
|
(input, _) = match header.tag {
|
2026-04-02 20:22:15 -07:00
|
|
|
records::RTAG_SREF | records::RTAG_AREF => {
|
|
|
|
|
let (next_input, ref_record) = read_ref(input, header.tag, names)?;
|
|
|
|
|
match ref_record {
|
|
|
|
|
RefRecord::SRef(sref) => srefs.push(sref),
|
|
|
|
|
RefRecord::ARef(aref) => arefs.push(aref),
|
|
|
|
|
}
|
|
|
|
|
(next_input, ())
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_BOUNDARY => {
|
|
|
|
|
let (next_input, boundary) = read_boundary(input, layers)?;
|
|
|
|
|
boundaries.push(boundary);
|
|
|
|
|
(next_input, ())
|
|
|
|
|
},
|
2025-04-20 23:21:54 -07:00
|
|
|
records::RTAG_PATH => read_path(input, cell_builder, layers)?,
|
|
|
|
|
records::RTAG_NODE => read_boxnode(input, cell_builder, header.tag, layers)?,
|
|
|
|
|
records::RTAG_BOX => read_boxnode(input, cell_builder, header.tag, layers)?,
|
|
|
|
|
records::RTAG_TEXT => read_text(input, cell_builder, layers)?,
|
2025-04-10 01:07:11 -07:00
|
|
|
_ => {
|
|
|
|
|
// don't care, skip
|
2025-04-12 12:06:36 -07:00
|
|
|
let result = take_bytes(input, header.data_size + 4)?;
|
|
|
|
|
(result.0, ())
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
2025-04-12 12:06:36 -07:00
|
|
|
};
|
|
|
|
|
(_, header) = RecordHeader::read(input)?; // don't consume tag
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
2025-04-12 12:06:36 -07:00
|
|
|
(input, _) = take_bytes(input, 4_usize)?; // consume endstr tag
|
|
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
let mut sref_plain = Vec::<SRefRecord>::with_capacity(srefs.len() + arefs.len() / 4);
|
|
|
|
|
let mut sref_props = Vec::<SRefRecord>::with_capacity(srefs.len() / 16 + arefs.len() / 64);
|
|
|
|
|
for sref in srefs {
|
|
|
|
|
if sref.properties.is_empty() {
|
|
|
|
|
sref_plain.push(sref);
|
|
|
|
|
} else {
|
|
|
|
|
sref_props.push(sref);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let mut aref_plain = Vec::<ARefRecord>::with_capacity(arefs.len());
|
|
|
|
|
let mut aref_props = Vec::<ARefRecord>::with_capacity(arefs.len() / 16);
|
|
|
|
|
for aref in arefs {
|
|
|
|
|
if aref.counts == UNIT_COUNTS {
|
|
|
|
|
let sref = aref_to_sref(aref);
|
|
|
|
|
if sref.properties.is_empty() {
|
|
|
|
|
sref_plain.push(sref);
|
|
|
|
|
} else {
|
|
|
|
|
sref_props.push(sref);
|
|
|
|
|
}
|
|
|
|
|
} else if aref.properties.is_empty() {
|
|
|
|
|
aref_plain.push(aref);
|
|
|
|
|
} else {
|
|
|
|
|
aref_props.push(aref);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
sref_plain.sort_by_key(|sref| sref.target_id);
|
|
|
|
|
aref_plain.sort_by_key(|aref| aref.target_id);
|
|
|
|
|
|
|
|
|
|
let mut boundary_plain = Vec::<BoundaryRecord>::with_capacity(boundaries.len());
|
|
|
|
|
let mut boundary_props = Vec::<BoundaryRecord>::with_capacity(boundaries.len() / 16);
|
|
|
|
|
for boundary in boundaries {
|
|
|
|
|
if boundary.properties.is_empty() {
|
|
|
|
|
boundary_plain.push(boundary);
|
|
|
|
|
} else {
|
|
|
|
|
boundary_props.push(boundary);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
boundary_plain.sort_by_key(|boundary| boundary.layer_id);
|
|
|
|
|
|
|
|
|
|
let mut rect_batches = Vec::<RectBatchRecord>::new();
|
|
|
|
|
let mut boundary_batches = Vec::<BoundaryBatchRecord>::new();
|
|
|
|
|
let mut ii = 0;
|
|
|
|
|
while ii < boundary_plain.len() {
|
|
|
|
|
let start = ii;
|
|
|
|
|
let layer_id = boundary_plain[ii].layer_id;
|
|
|
|
|
while ii < boundary_plain.len() && boundary_plain[ii].layer_id == layer_id {
|
|
|
|
|
ii += 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let group = &boundary_plain[start..ii];
|
|
|
|
|
let rect_capacity = group.len() * 4;
|
|
|
|
|
let vertex_capacity = group.iter().map(|boundary| boundary.vertices.len()).sum();
|
|
|
|
|
let mut rect_batch = RectBatchRecord {
|
|
|
|
|
layer_id,
|
|
|
|
|
rects: Vec::with_capacity(rect_capacity),
|
|
|
|
|
};
|
|
|
|
|
let mut boundary_batch = BoundaryBatchRecord {
|
|
|
|
|
layer_id,
|
|
|
|
|
vertices: Vec::with_capacity(vertex_capacity),
|
|
|
|
|
vertex_offsets: Vec::with_capacity(group.len()),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let mut next_offset: u32 = 0;
|
|
|
|
|
for boundary in group {
|
|
|
|
|
if let Some(rect) = boundary_to_rect(&boundary.vertices) {
|
|
|
|
|
rect_batch.rects.extend_from_slice(&rect);
|
|
|
|
|
} else {
|
|
|
|
|
boundary_batch.vertex_offsets.push(next_offset);
|
|
|
|
|
boundary_batch.vertices.extend_from_slice(&boundary.vertices);
|
|
|
|
|
next_offset += (boundary.vertices.len() / 2) as u32;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if !rect_batch.rects.is_empty() {
|
|
|
|
|
rect_batches.push(rect_batch);
|
|
|
|
|
}
|
|
|
|
|
if !boundary_batch.vertex_offsets.is_empty() {
|
|
|
|
|
boundary_batches.push(boundary_batch);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let sref_builder = cell_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
|
|
|
for sref in sref_plain {
|
|
|
|
|
append_sref(sref_builder, sref);
|
|
|
|
|
}
|
|
|
|
|
sref_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let aref_builder = cell_builder.field_builder::<DListBuilder>(3).unwrap();
|
|
|
|
|
for aref in aref_plain {
|
|
|
|
|
append_aref(aref_builder, aref);
|
|
|
|
|
}
|
|
|
|
|
aref_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let sref_props_builder = cell_builder.field_builder::<DListBuilder>(4).unwrap();
|
|
|
|
|
for sref in sref_props {
|
|
|
|
|
append_sref_prop(sref_props_builder, sref);
|
|
|
|
|
}
|
|
|
|
|
sref_props_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let aref_props_builder = cell_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
|
|
|
for aref in aref_props {
|
|
|
|
|
append_aref_prop(aref_props_builder, aref);
|
|
|
|
|
}
|
|
|
|
|
aref_props_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let rect_batches_builder = cell_builder.field_builder::<DListBuilder>(6).unwrap();
|
|
|
|
|
for rect_batch in rect_batches {
|
|
|
|
|
append_rect_batch(rect_batches_builder, rect_batch);
|
|
|
|
|
}
|
|
|
|
|
rect_batches_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let boundary_batches_builder = cell_builder.field_builder::<DListBuilder>(7).unwrap();
|
|
|
|
|
for boundary_batch in boundary_batches {
|
|
|
|
|
append_boundary_batch(boundary_batches_builder, boundary_batch);
|
|
|
|
|
}
|
|
|
|
|
boundary_batches_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let boundary_props_builder = cell_builder.field_builder::<DListBuilder>(8).unwrap();
|
|
|
|
|
for boundary in boundary_props {
|
|
|
|
|
append_boundary_prop(boundary_props_builder, boundary);
|
|
|
|
|
}
|
|
|
|
|
boundary_props_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let paths_builder = cell_builder.field_builder::<DListBuilder>(9).unwrap();
|
2025-04-12 12:06:36 -07:00
|
|
|
paths_builder.append(true);
|
2026-04-02 20:22:15 -07:00
|
|
|
let nodes_builder = cell_builder.field_builder::<DListBuilder>(10).unwrap();
|
2025-04-12 12:06:36 -07:00
|
|
|
nodes_builder.append(true);
|
2026-04-02 20:22:15 -07:00
|
|
|
let boxes_builder = cell_builder.field_builder::<DListBuilder>(11).unwrap();
|
2025-04-12 12:06:36 -07:00
|
|
|
boxes_builder.append(true);
|
2026-04-02 20:22:15 -07:00
|
|
|
let texts_builder = cell_builder.field_builder::<DListBuilder>(12).unwrap();
|
2025-04-12 12:06:36 -07:00
|
|
|
texts_builder.append(true);
|
|
|
|
|
|
2025-04-10 01:07:11 -07:00
|
|
|
Ok((input, ()))
|
|
|
|
|
}
|
|
|
|
|
|
2025-04-12 12:06:36 -07:00
|
|
|
|
2026-11-14 14:27:09 -08:00
|
|
|
pub fn scan_elements<'a>(
|
|
|
|
|
input: &'a [u8],
|
|
|
|
|
names: &mut HashMap<String, u32>,
|
|
|
|
|
) -> IResult<'a, Vec<ScanRefRecord>> {
|
|
|
|
|
let mut input = input;
|
|
|
|
|
let mut refs = Vec::<ScanRefRecord>::new();
|
|
|
|
|
let (_, mut header) = RecordHeader::read(input)?;
|
|
|
|
|
while header.tag != records::RTAG_ENDSTR {
|
|
|
|
|
(input, _) = match header.tag {
|
|
|
|
|
records::RTAG_SREF | records::RTAG_AREF => {
|
|
|
|
|
let (next_input, ref_record) = read_ref(input, header.tag, names)?;
|
|
|
|
|
refs.push(scan_ref_from_record(ref_record));
|
|
|
|
|
(next_input, ())
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_BOUNDARY
|
|
|
|
|
| records::RTAG_PATH
|
|
|
|
|
| records::RTAG_NODE
|
|
|
|
|
| records::RTAG_BOX
|
|
|
|
|
| records::RTAG_TEXT => skip_element(input)?,
|
|
|
|
|
_ => {
|
|
|
|
|
let result = take_bytes(input, header.data_size + 4)?;
|
|
|
|
|
(result.0, ())
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
(_, header) = RecordHeader::read(input)?;
|
|
|
|
|
}
|
|
|
|
|
refs.sort_by_key(|scan_ref| scan_ref.target_id);
|
|
|
|
|
(input, _) = take_bytes(input, 4_usize)?;
|
|
|
|
|
Ok((input, refs))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
fn append_sref(
|
|
|
|
|
sref_builder: &mut DListBuilder,
|
|
|
|
|
sref: SRefRecord,
|
|
|
|
|
) {
|
|
|
|
|
let sref_struct_builder = sref_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
let target_builder = sref_struct_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
target_builder.append_value(sref.target_id);
|
|
|
|
|
let invert_builder = sref_struct_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
|
|
|
invert_builder.append_value(sref.invert_y);
|
|
|
|
|
let scale_builder = sref_struct_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
|
|
|
scale_builder.append_value(sref.scale);
|
|
|
|
|
let angle_builder = sref_struct_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
|
|
|
angle_builder.append_value(sref.angle_rad);
|
|
|
|
|
let xy_builder = sref_struct_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
|
|
|
xy_builder.append_value(sref.xy);
|
|
|
|
|
|
|
|
|
|
sref_struct_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2026-11-14 14:27:09 -08:00
|
|
|
fn scan_ref_from_record(ref_record: RefRecord) -> ScanRefRecord {
|
|
|
|
|
match ref_record {
|
|
|
|
|
RefRecord::SRef(sref) => ScanRefRecord {
|
|
|
|
|
target_id: sref.target_id,
|
|
|
|
|
invert_y: sref.invert_y,
|
|
|
|
|
scale: sref.scale,
|
|
|
|
|
angle_rad: sref.angle_rad,
|
|
|
|
|
xy: sref.xy,
|
|
|
|
|
xy0: ZERO_XY,
|
|
|
|
|
xy1: ZERO_XY,
|
|
|
|
|
counts: UNIT_COUNTS,
|
|
|
|
|
},
|
|
|
|
|
RefRecord::ARef(aref) => ScanRefRecord {
|
|
|
|
|
target_id: aref.target_id,
|
|
|
|
|
invert_y: aref.invert_y,
|
|
|
|
|
scale: aref.scale,
|
|
|
|
|
angle_rad: aref.angle_rad,
|
|
|
|
|
xy: aref.xy,
|
|
|
|
|
xy0: aref.xy0,
|
|
|
|
|
xy1: aref.xy1,
|
|
|
|
|
counts: aref.counts,
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn skip_element<'a>(input: &'a [u8]) -> IResult<'a, ()> {
|
|
|
|
|
let mut input = input;
|
|
|
|
|
loop {
|
|
|
|
|
let (next_input, header) = RecordHeader::read(input)?;
|
|
|
|
|
let (next_input, _) = take_bytes(next_input, header.data_size)?;
|
|
|
|
|
input = next_input;
|
|
|
|
|
if header.tag == ENDEL::tag() {
|
|
|
|
|
return Ok((input, ()));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
fn append_aref(
|
|
|
|
|
aref_builder: &mut DListBuilder,
|
|
|
|
|
aref: ARefRecord,
|
|
|
|
|
) {
|
|
|
|
|
let aref_struct_builder = aref_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let target_builder = aref_struct_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
target_builder.append_value(aref.target_id);
|
|
|
|
|
let invert_builder = aref_struct_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
|
|
|
invert_builder.append_value(aref.invert_y);
|
|
|
|
|
let scale_builder = aref_struct_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
|
|
|
scale_builder.append_value(aref.scale);
|
|
|
|
|
let angle_builder = aref_struct_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
|
|
|
angle_builder.append_value(aref.angle_rad);
|
|
|
|
|
let xy_builder = aref_struct_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
|
|
|
xy_builder.append_value(aref.xy);
|
|
|
|
|
let xy0_builder = aref_struct_builder.field_builder::<UInt64Builder>(5).unwrap();
|
|
|
|
|
xy0_builder.append_value(aref.xy0);
|
|
|
|
|
let xy1_builder = aref_struct_builder.field_builder::<UInt64Builder>(6).unwrap();
|
|
|
|
|
xy1_builder.append_value(aref.xy1);
|
|
|
|
|
let counts_builder = aref_struct_builder.field_builder::<UInt32Builder>(7).unwrap();
|
|
|
|
|
counts_builder.append_value(aref.counts);
|
|
|
|
|
|
|
|
|
|
aref_struct_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn append_properties(
|
|
|
|
|
props_builder: &mut DListBuilder,
|
|
|
|
|
properties: Vec<PropertyRecord>,
|
|
|
|
|
) {
|
|
|
|
|
for prop in properties {
|
|
|
|
|
let prop_builder = props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
let key_builder = prop_builder.field_builder::<Int16Builder>(0).unwrap();
|
|
|
|
|
key_builder.append_value(prop.key);
|
|
|
|
|
|
|
|
|
|
let val_builder = prop_builder.field_builder::<StringBuilder>(1).unwrap();
|
|
|
|
|
val_builder.append_value(prop.value);
|
|
|
|
|
|
|
|
|
|
prop_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
props_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn append_sref_prop(
|
|
|
|
|
sref_props_builder: &mut DListBuilder,
|
|
|
|
|
sref: SRefRecord,
|
|
|
|
|
) {
|
|
|
|
|
let sref_prop_builder = sref_props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let target_builder = sref_prop_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
target_builder.append_value(sref.target_id);
|
|
|
|
|
let invert_builder = sref_prop_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
|
|
|
invert_builder.append_value(sref.invert_y);
|
|
|
|
|
let scale_builder = sref_prop_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
|
|
|
scale_builder.append_value(sref.scale);
|
|
|
|
|
let angle_builder = sref_prop_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
|
|
|
angle_builder.append_value(sref.angle_rad);
|
|
|
|
|
let xy_builder = sref_prop_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
|
|
|
xy_builder.append_value(sref.xy);
|
|
|
|
|
|
|
|
|
|
let props_builder = sref_prop_builder.field_builder::<DListBuilder>(5).unwrap();
|
|
|
|
|
append_properties(props_builder, sref.properties);
|
|
|
|
|
|
|
|
|
|
sref_prop_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn append_aref_prop(
|
|
|
|
|
aref_props_builder: &mut DListBuilder,
|
|
|
|
|
aref: ARefRecord,
|
|
|
|
|
) {
|
|
|
|
|
let aref_prop_builder = aref_props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let target_builder = aref_prop_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
target_builder.append_value(aref.target_id);
|
|
|
|
|
let invert_builder = aref_prop_builder.field_builder::<BooleanBuilder>(1).unwrap();
|
|
|
|
|
invert_builder.append_value(aref.invert_y);
|
|
|
|
|
let scale_builder = aref_prop_builder.field_builder::<Float64Builder>(2).unwrap();
|
|
|
|
|
scale_builder.append_value(aref.scale);
|
|
|
|
|
let angle_builder = aref_prop_builder.field_builder::<Float64Builder>(3).unwrap();
|
|
|
|
|
angle_builder.append_value(aref.angle_rad);
|
|
|
|
|
let xy_builder = aref_prop_builder.field_builder::<UInt64Builder>(4).unwrap();
|
|
|
|
|
xy_builder.append_value(aref.xy);
|
|
|
|
|
let xy0_builder = aref_prop_builder.field_builder::<UInt64Builder>(5).unwrap();
|
|
|
|
|
xy0_builder.append_value(aref.xy0);
|
|
|
|
|
let xy1_builder = aref_prop_builder.field_builder::<UInt64Builder>(6).unwrap();
|
|
|
|
|
xy1_builder.append_value(aref.xy1);
|
|
|
|
|
let counts_builder = aref_prop_builder.field_builder::<UInt32Builder>(7).unwrap();
|
|
|
|
|
counts_builder.append_value(aref.counts);
|
|
|
|
|
|
|
|
|
|
let props_builder = aref_prop_builder.field_builder::<DListBuilder>(8).unwrap();
|
|
|
|
|
append_properties(props_builder, aref.properties);
|
|
|
|
|
|
|
|
|
|
aref_prop_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn aref_to_sref(aref: ARefRecord) -> SRefRecord {
|
|
|
|
|
SRefRecord {
|
|
|
|
|
target_id: aref.target_id,
|
|
|
|
|
invert_y: aref.invert_y,
|
|
|
|
|
scale: aref.scale,
|
|
|
|
|
angle_rad: aref.angle_rad,
|
|
|
|
|
xy: aref.xy,
|
|
|
|
|
properties: aref.properties,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn read_boundary<'a>(
|
|
|
|
|
input: &'a [u8],
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
) -> IResult<'a, BoundaryRecord> {
|
2025-04-10 01:07:11 -07:00
|
|
|
let (input, _) = records::BOUNDARY::read(input)?;
|
|
|
|
|
|
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
2026-04-02 20:22:15 -07:00
|
|
|
let layer_id = layer_id_for(layer, dtype, layers);
|
2025-04-10 01:07:11 -07:00
|
|
|
|
|
|
|
|
let (input, xy_iter) = XY::read(input)?;
|
2026-04-02 20:22:15 -07:00
|
|
|
let mut vertices: Vec<i32> = xy_iter.collect();
|
|
|
|
|
vertices.truncate(vertices.len().saturating_sub(2));
|
|
|
|
|
|
|
|
|
|
let (input, properties) = read_properties_vec(input)?;
|
|
|
|
|
|
|
|
|
|
Ok((input, BoundaryRecord { layer_id, vertices, properties }))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn append_boundary_batch(
|
|
|
|
|
boundary_batches_builder: &mut DListBuilder,
|
|
|
|
|
boundary_batch: BoundaryBatchRecord,
|
|
|
|
|
) {
|
|
|
|
|
let boundary_batch_builder = boundary_batches_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let layer_builder = boundary_batch_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
layer_builder.append_value(boundary_batch.layer_id);
|
|
|
|
|
|
|
|
|
|
let vertices_builder = boundary_batch_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
|
|
|
let vertex_builder = vertices_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
|
|
|
vertex_builder.append_slice(&boundary_batch.vertices);
|
|
|
|
|
vertices_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let offsets_builder = boundary_batch_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
|
|
|
let offset_builder = offsets_builder.values().as_any_mut().downcast_mut::<UInt32Builder>().unwrap();
|
|
|
|
|
offset_builder.append_slice(&boundary_batch.vertex_offsets);
|
|
|
|
|
offsets_builder.append(true);
|
|
|
|
|
|
|
|
|
|
boundary_batch_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn append_rect_batch(
|
|
|
|
|
rect_batches_builder: &mut DListBuilder,
|
|
|
|
|
rect_batch: RectBatchRecord,
|
|
|
|
|
) {
|
|
|
|
|
let rect_batch_builder = rect_batches_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let layer_builder = rect_batch_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
layer_builder.append_value(rect_batch.layer_id);
|
|
|
|
|
|
|
|
|
|
let rects_builder = rect_batch_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
|
|
|
let rect_builder = rects_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
|
|
|
rect_builder.append_slice(&rect_batch.rects);
|
|
|
|
|
rects_builder.append(true);
|
|
|
|
|
|
|
|
|
|
rect_batch_builder.append(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn append_boundary_prop(
|
|
|
|
|
boundary_props_builder: &mut DListBuilder,
|
|
|
|
|
boundary: BoundaryRecord,
|
|
|
|
|
) {
|
|
|
|
|
let boundary_prop_builder = boundary_props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let layer_builder = boundary_prop_builder.field_builder::<UInt32Builder>(0).unwrap();
|
|
|
|
|
layer_builder.append_value(boundary.layer_id);
|
|
|
|
|
|
|
|
|
|
let vertices_builder = boundary_prop_builder.field_builder::<DListBuilder>(1).unwrap();
|
|
|
|
|
let vertex_builder = vertices_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
|
|
|
vertex_builder.append_slice(&boundary.vertices);
|
|
|
|
|
vertices_builder.append(true);
|
|
|
|
|
|
|
|
|
|
let props_builder = boundary_prop_builder.field_builder::<DListBuilder>(2).unwrap();
|
|
|
|
|
for prop in boundary.properties {
|
|
|
|
|
let prop_builder = props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
let key_builder = prop_builder.field_builder::<Int16Builder>(0).unwrap();
|
|
|
|
|
key_builder.append_value(prop.key);
|
|
|
|
|
|
|
|
|
|
let val_builder = prop_builder.field_builder::<StringBuilder>(1).unwrap();
|
|
|
|
|
val_builder.append_value(prop.value);
|
|
|
|
|
|
|
|
|
|
prop_builder.append(true);
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
2026-04-02 20:22:15 -07:00
|
|
|
props_builder.append(true);
|
2025-04-10 01:07:11 -07:00
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
boundary_prop_builder.append(true);
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
pub fn read_path<'a>(
|
|
|
|
|
input: &'a [u8],
|
|
|
|
|
cell_builder: &mut StructBuilder,
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
) -> IResult<'a, ()> {
|
2026-04-02 20:22:15 -07:00
|
|
|
let paths_builder = cell_builder.field_builder::<DListBuilder>(9).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let path_builder = paths_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let (input, _) = records::PATH::read(input)?;
|
|
|
|
|
|
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
2025-04-20 23:21:54 -07:00
|
|
|
insert_layer(layer, dtype, layers, path_builder, 0);
|
2025-04-10 01:07:11 -07:00
|
|
|
|
|
|
|
|
let mut path_type = None;
|
|
|
|
|
let mut width = None;
|
|
|
|
|
let mut bgn_ext = None;
|
|
|
|
|
let mut end_ext = None;
|
|
|
|
|
|
2025-04-11 11:18:56 -07:00
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
2025-04-10 01:07:11 -07:00
|
|
|
while header.tag != records::RTAG_XY {
|
|
|
|
|
match header.tag {
|
|
|
|
|
records::RTAG_PATHTYPE => {
|
|
|
|
|
let _path_type;
|
|
|
|
|
(input, _path_type) = PATHTYPE::read_data(input, header.data_size)?;
|
|
|
|
|
path_type = Some(_path_type);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_WIDTH => {
|
|
|
|
|
let _width;
|
|
|
|
|
(input, _width) = WIDTH::read_data(input, header.data_size)?;
|
|
|
|
|
width = Some(_width);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_BGNEXTN => {
|
|
|
|
|
let _bgn_ext;
|
|
|
|
|
(input, _bgn_ext) = BGNEXTN::read_data(input, header.data_size)?;
|
|
|
|
|
bgn_ext = Some(_bgn_ext);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_ENDEXTN => {
|
|
|
|
|
let _end_ext;
|
|
|
|
|
(input, _end_ext) = ENDEXTN::read_data(input, header.data_size)?;
|
|
|
|
|
end_ext = Some(_end_ext);
|
|
|
|
|
},
|
|
|
|
|
_ =>
|
|
|
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
|
|
|
};
|
2025-04-11 11:18:56 -07:00
|
|
|
(input, header) = RecordHeader::read(input)?;
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
2025-04-20 23:21:54 -07:00
|
|
|
let path_type_builder = path_builder.field_builder::<Int16Builder>(1).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
path_type_builder.append_option(path_type);
|
2025-04-20 23:21:54 -07:00
|
|
|
let ext0_builder = path_builder.field_builder::<Int32Builder>(2).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
ext0_builder.append_option(bgn_ext);
|
2025-04-20 23:21:54 -07:00
|
|
|
let ext1_builder = path_builder.field_builder::<Int32Builder>(3).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
ext1_builder.append_option(end_ext);
|
2025-04-20 23:21:54 -07:00
|
|
|
let width_builder = path_builder.field_builder::<Int32Builder>(4).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
width_builder.append_option(width);
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
let xys_builder = path_builder.field_builder::<DListBuilder>(5).unwrap();
|
2025-04-12 12:06:36 -07:00
|
|
|
let (input, xy_iter) = XY::read_data(input, header.data_size)?;
|
2025-04-10 01:07:11 -07:00
|
|
|
for xy in xy_iter {
|
|
|
|
|
let xy_builder = xys_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
|
|
|
xy_builder.append_value(xy);
|
|
|
|
|
}
|
|
|
|
|
xys_builder.append(true);
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
let props_builder = path_builder.field_builder::<DListBuilder>(6).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let (input, ()) = read_properties(input, props_builder)?;
|
|
|
|
|
|
|
|
|
|
path_builder.append(true);
|
|
|
|
|
Ok((input, ()))
|
|
|
|
|
}
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
pub fn read_boxnode<'a>(
|
|
|
|
|
input: &'a [u8],
|
|
|
|
|
cell_builder: &mut StructBuilder,
|
|
|
|
|
tag: u16,
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
) -> IResult<'a, ()> {
|
2025-04-10 01:07:11 -07:00
|
|
|
let field_num = match tag {
|
2026-04-02 20:22:15 -07:00
|
|
|
records::RTAG_NODE => 10,
|
|
|
|
|
records::RTAG_BOX => 11,
|
2025-04-10 01:07:11 -07:00
|
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let boxnodes_builder = cell_builder.field_builder::<DListBuilder>(field_num).unwrap();
|
|
|
|
|
let boxnode_builder = boxnodes_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let (input, _) = match tag {
|
|
|
|
|
records::RTAG_NODE => records::NODE::read(input)?,
|
|
|
|
|
records::RTAG_BOX => records::BOX::read(input)?,
|
|
|
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = match tag {
|
|
|
|
|
records::RTAG_NODE => NODETYPE::read(input)?,
|
|
|
|
|
records::RTAG_BOX => BOXTYPE::read(input)?,
|
|
|
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
|
|
|
};
|
2025-04-20 23:21:54 -07:00
|
|
|
insert_layer(layer, dtype, layers, boxnode_builder, 0);
|
2025-04-10 01:07:11 -07:00
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
let xys_builder = boxnode_builder.field_builder::<DListBuilder>(1).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let xy_builder = xys_builder.values().as_any_mut().downcast_mut::<Int32Builder>().unwrap();
|
|
|
|
|
let (input, xy_iter) = XY::read(input)?;
|
|
|
|
|
for xy in xy_iter {
|
|
|
|
|
xy_builder.append_value(xy);
|
|
|
|
|
}
|
|
|
|
|
xys_builder.append(true);
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
let props_builder = boxnode_builder.field_builder::<DListBuilder>(2).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let (input, ()) = read_properties(input, props_builder)?;
|
|
|
|
|
|
|
|
|
|
boxnode_builder.append(true);
|
|
|
|
|
Ok((input, ()))
|
|
|
|
|
}
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
pub fn read_text<'a>(
|
|
|
|
|
input: &'a [u8],
|
|
|
|
|
cell_builder: &mut StructBuilder,
|
|
|
|
|
layers: &mut HashMap<u32, u32>,
|
|
|
|
|
) -> IResult<'a, ()> {
|
2026-04-02 20:22:15 -07:00
|
|
|
let texts_builder = cell_builder.field_builder::<DListBuilder>(12).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let text_builder = texts_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
|
|
|
|
|
|
|
|
|
let mut path_type = None;
|
|
|
|
|
let mut pres_hori = None;
|
|
|
|
|
let mut pres_vert = None;
|
|
|
|
|
let mut pres_font = None;
|
|
|
|
|
let mut invert_y = None;
|
|
|
|
|
let mut width = None;
|
|
|
|
|
let mut mag = None;
|
|
|
|
|
let mut angle_deg = None;
|
|
|
|
|
|
|
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = TEXTTYPE::read(input)?;
|
2025-04-20 23:21:54 -07:00
|
|
|
insert_layer(layer, dtype, layers, text_builder, 0);
|
2025-04-10 01:07:11 -07:00
|
|
|
|
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
|
|
|
while header.tag != records::RTAG_XY {
|
|
|
|
|
match header.tag {
|
|
|
|
|
// TODO warn if repeat tags?
|
|
|
|
|
records::RTAG_PRESENTATION => {
|
|
|
|
|
let _presentation;
|
|
|
|
|
(input, _presentation) = PRESENTATION::read_data(input, header.data_size)?;
|
|
|
|
|
pres_hori = Some(_presentation[14] as u8 * 2 + _presentation[15] as u8);
|
|
|
|
|
pres_vert = Some(_presentation[12] as u8 * 2 + _presentation[13] as u8);
|
|
|
|
|
pres_font = Some(_presentation[10] as u8 * 2 + _presentation[11] as u8);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_PATHTYPE => {
|
|
|
|
|
let _path_type;
|
|
|
|
|
(input, _path_type) = PATHTYPE::read_data(input, header.data_size)?;
|
|
|
|
|
path_type = Some(_path_type);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_WIDTH => {
|
|
|
|
|
let _width;
|
|
|
|
|
(input, _width) = WIDTH::read_data(input, header.data_size)?;
|
|
|
|
|
width = Some(_width);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_STRANS => {
|
|
|
|
|
let strans;
|
|
|
|
|
(input, strans) = STRANS::read_data(input, header.data_size)?;
|
|
|
|
|
invert_y = Some(strans[0]);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_MAG => {
|
|
|
|
|
let _mag;
|
|
|
|
|
(input, _mag) = MAG::read_data(input, header.data_size)?;
|
|
|
|
|
mag = Some(_mag);
|
|
|
|
|
},
|
|
|
|
|
records::RTAG_ANGLE => {
|
|
|
|
|
let _angle_deg;
|
|
|
|
|
(input, _angle_deg) = ANGLE::read_data(input, header.data_size)?;
|
|
|
|
|
angle_deg = Some(_angle_deg);
|
|
|
|
|
},
|
|
|
|
|
_ =>
|
|
|
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
|
|
|
}
|
|
|
|
|
(input, header) = RecordHeader::read(input)?;
|
|
|
|
|
}
|
|
|
|
|
|
2025-04-20 23:21:54 -07:00
|
|
|
let pres_hori_builder = text_builder.field_builder::<UInt8Builder>(1).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
pres_hori_builder.append_option(pres_hori);
|
2025-04-20 23:21:54 -07:00
|
|
|
let pres_vert_builder = text_builder.field_builder::<UInt8Builder>(2).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
pres_vert_builder.append_option(pres_vert);
|
2025-04-20 23:21:54 -07:00
|
|
|
let pres_font_builder = text_builder.field_builder::<UInt8Builder>(3).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
pres_font_builder.append_option(pres_font);
|
2025-04-20 23:21:54 -07:00
|
|
|
let path_type_builder = text_builder.field_builder::<Int16Builder>(4).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
path_type_builder.append_option(path_type);
|
2025-04-20 23:21:54 -07:00
|
|
|
let width_builder = text_builder.field_builder::<Int32Builder>(5).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
width_builder.append_option(width);
|
2025-04-20 23:21:54 -07:00
|
|
|
let inv_builder = text_builder.field_builder::<BooleanBuilder>(6).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
inv_builder.append_option(invert_y);
|
2025-04-20 23:21:54 -07:00
|
|
|
let mag_builder = text_builder.field_builder::<Float64Builder>(7).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
mag_builder.append_option(mag);
|
2025-04-20 23:21:54 -07:00
|
|
|
let angle_builder = text_builder.field_builder::<Float64Builder>(8).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
angle_builder.append_option(angle_deg);
|
|
|
|
|
|
2025-04-12 12:06:36 -07:00
|
|
|
let (input, mut xy_iter) = XY::read_data(input, header.data_size)?;
|
2025-04-22 20:16:38 -07:00
|
|
|
let xx = xy_iter.next().unwrap();
|
|
|
|
|
let yy = xy_iter.next().unwrap();
|
|
|
|
|
let xy = ((xx as u32 as u64) << 32) | (yy as u32 as u64);
|
|
|
|
|
let xy_builder = text_builder.field_builder::<UInt64Builder>(9).unwrap();
|
|
|
|
|
xy_builder.append_value(xy);
|
2025-04-10 01:07:11 -07:00
|
|
|
|
|
|
|
|
let (input, string_bytes) = STRING::read(input)?;
|
|
|
|
|
let string = String::from_utf8(string_bytes).unwrap();
|
2025-04-22 20:16:38 -07:00
|
|
|
let string_builder = text_builder.field_builder::<StringBuilder>(10).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
string_builder.append_value(string);
|
|
|
|
|
|
2025-04-22 20:16:38 -07:00
|
|
|
let props_builder = text_builder.field_builder::<DListBuilder>(11).unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let (input, ()) = read_properties(input, props_builder)?;
|
|
|
|
|
|
|
|
|
|
text_builder.append(true);
|
|
|
|
|
Ok((input, ()))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
fn boundary_to_rect(vertices: &[i32]) -> Option<[i32; 4]> {
|
|
|
|
|
if vertices.len() != 8 {
|
|
|
|
|
return None;
|
|
|
|
|
}
|
2025-04-10 01:07:11 -07:00
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
let xs = [vertices[0], vertices[2], vertices[4], vertices[6]];
|
|
|
|
|
let ys = [vertices[1], vertices[3], vertices[5], vertices[7]];
|
|
|
|
|
|
|
|
|
|
let min_x = *xs.iter().min().unwrap();
|
|
|
|
|
let max_x = *xs.iter().max().unwrap();
|
|
|
|
|
let min_y = *ys.iter().min().unwrap();
|
|
|
|
|
let max_y = *ys.iter().max().unwrap();
|
|
|
|
|
if min_x >= max_x || min_y >= max_y {
|
|
|
|
|
return None;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let mut seen_corners: u8 = 0;
|
|
|
|
|
for ii in 0..4 {
|
|
|
|
|
let jj = (ii + 1) % 4;
|
|
|
|
|
let dx = xs[jj] - xs[ii];
|
|
|
|
|
let dy = ys[jj] - ys[ii];
|
|
|
|
|
if (dx == 0) == (dy == 0) {
|
|
|
|
|
return None;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let x = xs[ii];
|
|
|
|
|
let y = ys[ii];
|
|
|
|
|
if (x != min_x && x != max_x) || (y != min_y && y != max_y) {
|
|
|
|
|
return None;
|
|
|
|
|
}
|
|
|
|
|
let code = ((x == max_x) as u8) << 1 | ((y == max_y) as u8);
|
|
|
|
|
seen_corners |= 1 << code;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if seen_corners != 0b1111 {
|
|
|
|
|
return None;
|
|
|
|
|
}
|
|
|
|
|
Some([min_x, min_y, max_x, max_y])
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn read_ref<'a>(
|
2025-04-20 23:21:54 -07:00
|
|
|
input: &'a [u8],
|
|
|
|
|
tag: u16,
|
|
|
|
|
names: &mut HashMap<String, u32>,
|
2026-04-02 20:22:15 -07:00
|
|
|
) -> IResult<'a, RefRecord> {
|
2025-04-12 12:06:36 -07:00
|
|
|
let (input, _) = match tag {
|
|
|
|
|
records::RTAG_SREF => records::SREF::read(input)?,
|
|
|
|
|
records::RTAG_AREF => records::AREF::read(input)?,
|
|
|
|
|
_ => return fail(input, format!("Unexpected tag {:04x}", tag)),
|
|
|
|
|
};
|
|
|
|
|
|
2025-04-10 01:07:11 -07:00
|
|
|
let is_aref = tag == records::RTAG_AREF;
|
2026-04-02 20:22:15 -07:00
|
|
|
let mut invert_y = false;
|
|
|
|
|
let mut scale = 1.0;
|
|
|
|
|
let mut angle_rad = 0.0;
|
2025-04-10 01:07:11 -07:00
|
|
|
let mut colrow = None;
|
|
|
|
|
|
|
|
|
|
let (input, struct_name_bytes) = SNAME::skip_and_read(input)?;
|
|
|
|
|
let struct_name = String::from_utf8(struct_name_bytes).unwrap();
|
|
|
|
|
let next_id = names.len();
|
|
|
|
|
let id = names.entry(struct_name).or_insert(next_id.try_into().unwrap());
|
|
|
|
|
|
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
|
|
|
while header.tag != records::RTAG_XY {
|
|
|
|
|
match header.tag {
|
|
|
|
|
records::RTAG_STRANS => {
|
|
|
|
|
let strans;
|
|
|
|
|
(input, strans) = STRANS::read_data(input, header.data_size)?;
|
2026-04-02 20:22:15 -07:00
|
|
|
invert_y = strans[0];
|
2025-04-10 01:07:11 -07:00
|
|
|
},
|
|
|
|
|
records::RTAG_MAG => {
|
|
|
|
|
let _mag;
|
|
|
|
|
(input, _mag) = MAG::read_data(input, header.data_size)?;
|
2026-04-02 20:22:15 -07:00
|
|
|
scale = _mag;
|
2025-04-10 01:07:11 -07:00
|
|
|
},
|
|
|
|
|
records::RTAG_ANGLE => {
|
|
|
|
|
let _angle_deg;
|
|
|
|
|
(input, _angle_deg) = ANGLE::read_data(input, header.data_size)?;
|
2026-04-02 20:22:15 -07:00
|
|
|
angle_rad = _angle_deg.to_radians();
|
2025-04-10 01:07:11 -07:00
|
|
|
},
|
|
|
|
|
records::RTAG_COLROW => {
|
2026-11-14 14:39:01 -08:00
|
|
|
if header.data_size != 4 {
|
|
|
|
|
return fail(input, "COLROW must contain two counts".to_string());
|
|
|
|
|
}
|
2025-04-10 01:07:11 -07:00
|
|
|
let mut _colrow;
|
|
|
|
|
(input, _colrow) = COLROW::read_data(input, header.data_size)?;
|
|
|
|
|
colrow = Some((_colrow.next().unwrap(), _colrow.next().unwrap()));
|
|
|
|
|
if !is_aref {
|
|
|
|
|
return fail(input, "Got a COLROW record inside an SREF".to_string());
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
_ =>
|
|
|
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
|
|
|
|
};
|
|
|
|
|
(input, header) = RecordHeader::read(input)?;
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-14 14:39:01 -08:00
|
|
|
let expected_xy_size = if is_aref { 24 } else { 8 };
|
|
|
|
|
if header.data_size != expected_xy_size {
|
|
|
|
|
return fail(input, format!("Expected {expected_xy_size} bytes of reference coordinates, got {}", header.data_size));
|
|
|
|
|
}
|
2025-04-10 01:07:11 -07:00
|
|
|
let (input, mut xy_iter) = XY::read_data(input, header.data_size)?;
|
2025-04-22 20:16:38 -07:00
|
|
|
let xx = xy_iter.next().unwrap();
|
|
|
|
|
let yy = xy_iter.next().unwrap();
|
|
|
|
|
let xy = ((xx as u32 as u64) << 32) | (yy as u32 as u64);
|
2026-04-02 20:22:15 -07:00
|
|
|
let (input, properties) = read_properties_vec(input)?;
|
2025-04-10 01:07:11 -07:00
|
|
|
|
|
|
|
|
if is_aref {
|
2025-04-12 23:02:08 -07:00
|
|
|
if colrow.is_none() {
|
|
|
|
|
return fail(input, "AREF without COLROW before XY".to_string())
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
2025-04-12 23:02:08 -07:00
|
|
|
let (count0, count1) = colrow.unwrap();
|
2026-11-14 14:39:01 -08:00
|
|
|
if count0 <= 0 || count1 <= 0 {
|
|
|
|
|
return fail(input, "AREF column and row counts must be positive".to_string());
|
|
|
|
|
}
|
2025-04-12 23:02:08 -07:00
|
|
|
|
2026-11-14 14:39:01 -08:00
|
|
|
let pitch = |end: i32, origin: i32, count: i16| {
|
|
|
|
|
let value = (i64::from(end) - i64::from(origin)) / i64::from(count);
|
|
|
|
|
i32::try_from(value).map_err(|_| (input, crate::basic::ErrType::Failed(
|
|
|
|
|
"AREF pitch exceeds signed 32-bit coordinate range".to_string()
|
|
|
|
|
)))
|
|
|
|
|
};
|
|
|
|
|
let x0a = pitch(xy_iter.next().unwrap(), xx, count0)?;
|
|
|
|
|
let y0a = pitch(xy_iter.next().unwrap(), yy, count0)?;
|
|
|
|
|
let x1a = pitch(xy_iter.next().unwrap(), xx, count1)?;
|
|
|
|
|
let y1a = pitch(xy_iter.next().unwrap(), yy, count1)?;
|
2025-04-12 23:02:08 -07:00
|
|
|
|
2025-04-22 20:16:38 -07:00
|
|
|
let xy0a = ((x0a as u32 as u64) << 32) | (y0a as u32 as u64);
|
|
|
|
|
let xy1a = ((x1a as u32 as u64) << 32) | (y1a as u32 as u64);
|
|
|
|
|
let counts = ((count0 as u16 as u32) << 16) | (count1 as u16 as u32);
|
2026-04-02 20:22:15 -07:00
|
|
|
Ok((input, RefRecord::ARef(ARefRecord {
|
|
|
|
|
target_id: *id,
|
|
|
|
|
invert_y,
|
|
|
|
|
scale,
|
|
|
|
|
angle_rad,
|
|
|
|
|
xy,
|
|
|
|
|
xy0: xy0a,
|
|
|
|
|
xy1: xy1a,
|
|
|
|
|
counts,
|
|
|
|
|
properties,
|
|
|
|
|
})))
|
2025-04-12 12:06:36 -07:00
|
|
|
} else {
|
2026-04-02 20:22:15 -07:00
|
|
|
Ok((input, RefRecord::SRef(SRefRecord {
|
|
|
|
|
target_id: *id,
|
|
|
|
|
invert_y,
|
|
|
|
|
scale,
|
|
|
|
|
angle_rad,
|
|
|
|
|
xy,
|
|
|
|
|
properties,
|
|
|
|
|
})))
|
2025-04-10 01:07:11 -07:00
|
|
|
}
|
|
|
|
|
}
|
2021-12-18 21:05:00 -08:00
|
|
|
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Read element properties.
|
|
|
|
|
///
|
|
|
|
|
/// Assumes PROPATTR records have unique values.
|
|
|
|
|
/// Stops reading after consuming ENDEL record.
|
|
|
|
|
///
|
|
|
|
|
/// Args:
|
|
|
|
|
/// stream: Stream to read from.
|
|
|
|
|
///
|
|
|
|
|
/// Returns:
|
|
|
|
|
/// propattr: -> propvalue mapping
|
|
|
|
|
///
|
2025-04-10 01:07:11 -07:00
|
|
|
pub fn read_properties<'a>(input: &'a [u8], props_builder: &mut DListBuilder) -> IResult<'a, ()> {
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
while header.tag != ENDEL::tag() {
|
|
|
|
|
if header.tag == PROPATTR::tag() {
|
2025-04-10 01:07:11 -07:00
|
|
|
let key;
|
|
|
|
|
let value_bytes;
|
|
|
|
|
(input, key) = PROPATTR::read_data(input, header.data_size)?;
|
|
|
|
|
(input, value_bytes) = PROPVALUE::read(input)?;
|
|
|
|
|
|
|
|
|
|
let value = String::from_utf8(value_bytes).unwrap();
|
|
|
|
|
//assert!(!properties.contains_key(&key), "Duplicate property key: {}", key);
|
|
|
|
|
|
2025-04-12 12:06:36 -07:00
|
|
|
let prop_builder = props_builder.values().as_any_mut().downcast_mut::<StructBuilder>().unwrap();
|
2025-04-10 01:07:11 -07:00
|
|
|
let key_builder = prop_builder.field_builder::<Int16Builder>(0).unwrap();
|
|
|
|
|
key_builder.append_value(key);
|
|
|
|
|
|
|
|
|
|
let val_builder = prop_builder.field_builder::<StringBuilder>(1).unwrap();
|
|
|
|
|
val_builder.append_value(value);
|
|
|
|
|
|
|
|
|
|
prop_builder.append(true);
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
(input, header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
2025-04-10 01:07:11 -07:00
|
|
|
props_builder.append(true);
|
|
|
|
|
Ok((input, ()))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2026-04-02 20:22:15 -07:00
|
|
|
|
|
|
|
|
fn read_properties_vec<'a>(input: &'a [u8]) -> IResult<'a, Vec<PropertyRecord>> {
|
|
|
|
|
let mut properties = Vec::<PropertyRecord>::new();
|
|
|
|
|
|
|
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
|
|
|
|
while header.tag != ENDEL::tag() {
|
|
|
|
|
if header.tag == PROPATTR::tag() {
|
|
|
|
|
let key;
|
|
|
|
|
let value_bytes;
|
|
|
|
|
(input, key) = PROPATTR::read_data(input, header.data_size)?;
|
|
|
|
|
(input, value_bytes) = PROPVALUE::read(input)?;
|
|
|
|
|
|
|
|
|
|
properties.push(PropertyRecord {
|
|
|
|
|
key,
|
|
|
|
|
value: String::from_utf8(value_bytes).unwrap(),
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
(input, header) = RecordHeader::read(input)?;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ok((input, properties))
|
|
|
|
|
}
|
|
|
|
|
|
2025-04-10 01:07:11 -07:00
|
|
|
/*
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Write element properties.
|
|
|
|
|
///
|
|
|
|
|
/// This is does _not_ write the ENDEL record.
|
|
|
|
|
///
|
|
|
|
|
/// Args:
|
|
|
|
|
/// stream: Stream to write to.
|
|
|
|
|
///
|
|
|
|
|
pub fn write_properties<W: Write>(ww: &mut W, properties: &HashMap::<i16, Vec<u8>>) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
for (key, value) in properties {
|
2021-12-18 21:05:00 -08:00
|
|
|
size += PROPATTR::write(ww, key)?;
|
|
|
|
|
size += PROPVALUE::write(ww, value)?;
|
|
|
|
|
}
|
|
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
pub trait Element {
|
|
|
|
|
///
|
|
|
|
|
/// Read from a stream to construct this object.
|
|
|
|
|
/// Consumes up to (and including) the ENDEL record.
|
|
|
|
|
///
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> where Self: Sized;
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Write this element to a stream.
|
|
|
|
|
/// Finishes with an ENDEL record.
|
|
|
|
|
///
|
|
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Datastructure representing
|
|
|
|
|
/// an instance of a structure (SREF / structure reference) or
|
|
|
|
|
/// an array of instances (AREF / array reference).
|
|
|
|
|
/// Type is determined by the presence of the `colrow` tuple.
|
|
|
|
|
///
|
|
|
|
|
/// Transforms are applied to each individual instance (_not_
|
|
|
|
|
/// to the instance's origin location || array vectors).
|
|
|
|
|
///
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub struct Reference {
|
|
|
|
|
/// Name of the structure being referenced.
|
|
|
|
|
struct_name: Vec<u8>,
|
|
|
|
|
/// Whether to mirror the pattern (negate y-values / flip across x-axis). Default false.
|
|
|
|
|
invert_y: bool,
|
|
|
|
|
/// Scaling factor (default 1)
|
|
|
|
|
mag: f64,
|
|
|
|
|
/// Rotation (degrees counterclockwise)
|
|
|
|
|
angle_deg: f64,
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
/// (For SREF) Location in the parent structure corresponding to the instance's origin (0, 0).
|
|
|
|
|
/// (For AREF) 3 locations:
|
|
|
|
|
/// [`offset`,
|
|
|
|
|
/// `offset + col_basis_vector * colrow[0]`,
|
|
|
|
|
/// `offset + row_basis_vector * colrow[1]`]
|
|
|
|
|
/// which define the first instance's offset and the array's basis vectors.
|
|
|
|
|
/// Note that many GDS implementations only support manhattan basis vectors, and some
|
|
|
|
|
/// assume a certain axis mapping (e.g. x->columns, y->rows) and "reinterpret" the
|
|
|
|
|
/// basis vectors to match it.
|
|
|
|
|
xy: Vec<i32>,
|
|
|
|
|
|
|
|
|
|
/// Number of columns and rows (AREF) || None (SREF)
|
|
|
|
|
colrow: Option<(i16, i16)>,
|
|
|
|
|
/// Properties associated with this reference.
|
|
|
|
|
properties: HashMap::<i16, Vec<u8>>,
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Element for Reference {
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut invert_y = false;
|
2022-03-20 16:28:34 -07:00
|
|
|
let mut mag = 1.0;
|
|
|
|
|
let mut angle_deg = 0.0;
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut colrow = None;
|
2022-03-20 16:28:34 -07:00
|
|
|
let (input, struct_name) = SNAME::skip_and_read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
while header.tag != records::RTAG_XY {
|
|
|
|
|
match header.tag {
|
2022-03-20 16:28:34 -07:00
|
|
|
records::RTAG_STRANS => {
|
|
|
|
|
let result = STRANS::read_data(input, header.data_size)?;
|
|
|
|
|
input = result.0;
|
|
|
|
|
invert_y = result.1[0];
|
|
|
|
|
},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_MAG =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, mag) = MAG::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_ANGLE =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, angle_deg) = ANGLE::read_data(input, header.data_size)?;},
|
|
|
|
|
records::RTAG_COLROW => {
|
|
|
|
|
let result = COLROW::read_data(input, header.data_size)?;
|
|
|
|
|
input = result.0;
|
|
|
|
|
colrow = Some((result.1[0], result.1[1]));
|
|
|
|
|
},
|
2021-12-18 21:05:00 -08:00
|
|
|
_ =>
|
2022-03-20 16:28:34 -07:00
|
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
2021-12-18 21:05:00 -08:00
|
|
|
};
|
2022-03-20 16:28:34 -07:00
|
|
|
(input, header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
let (input, xy) = XY::read_data(input, header.data_size)?;
|
|
|
|
|
let (input, properties) = read_properties(input)?;
|
2022-03-20 16:28:34 -07:00
|
|
|
Ok((input, Reference{
|
2021-12-18 21:05:00 -08:00
|
|
|
struct_name: struct_name,
|
|
|
|
|
xy: xy,
|
|
|
|
|
properties: properties,
|
|
|
|
|
colrow: colrow,
|
|
|
|
|
invert_y: invert_y,
|
|
|
|
|
mag: mag,
|
|
|
|
|
angle_deg: angle_deg
|
2022-03-20 16:28:34 -07:00
|
|
|
}))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
|
|
|
|
size += match self.colrow {
|
2022-03-20 16:28:34 -07:00
|
|
|
None => SREF::write(ww, &())?,
|
|
|
|
|
Some(_) => AREF::write(ww, &())?,
|
2021-12-18 21:05:00 -08:00
|
|
|
};
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
size += SNAME::write(ww, &self.struct_name)?;
|
|
|
|
|
if self.angle_deg != 0.0 || self.mag != 1.0 || self.invert_y {
|
|
|
|
|
let strans = {
|
|
|
|
|
let mut arr = [false; 16];
|
|
|
|
|
arr[0] = self.invert_y;
|
|
|
|
|
arr
|
|
|
|
|
};
|
|
|
|
|
size += STRANS::write(ww, &strans)?;
|
|
|
|
|
if self.mag != 1.0 {
|
|
|
|
|
size += MAG::write(ww, &self.mag)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
if self.angle_deg != 0.0 {
|
|
|
|
|
size += ANGLE::write(ww, &self.angle_deg)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
if let Some(cr) = self.colrow {
|
|
|
|
|
size += COLROW::write(ww, &vec!{cr.0, cr.1})?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
|
|
|
size += write_properties(ww, &self.properties)?;
|
|
|
|
|
size += ENDEL::write(ww, &())?;
|
2021-12-18 21:05:00 -08:00
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Reference {
|
|
|
|
|
pub fn check(&self) {
|
|
|
|
|
if self.colrow.is_some() {
|
2022-03-20 16:28:34 -07:00
|
|
|
assert!(self.xy.len() != 6, "colrow is Some, so expected size-6 xy. Got {:?}", self.xy);
|
2021-12-18 21:05:00 -08:00
|
|
|
} else {
|
2022-03-20 16:28:34 -07:00
|
|
|
assert!(self.xy.len() != 2, "Expected size-2 xy. Got {:?}", self.xy);
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Datastructure representing a Boundary element.
|
|
|
|
|
///
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub struct Boundary {
|
|
|
|
|
/// (layer, data_type) tuple
|
|
|
|
|
layer: (i16, i16),
|
|
|
|
|
/// Ordered vertices of the shape. First and last points should be identical. Order x0, y0, x1,...
|
|
|
|
|
xy: Vec<i32>,
|
|
|
|
|
/// Properties for the element.
|
|
|
|
|
properties: HashMap::<i16, Vec<u8>>,
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Element for Boundary {
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
2021-12-18 21:05:00 -08:00
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
|
|
|
|
let (input, xy) = XY::read(input)?;
|
|
|
|
|
let (input, properties) = read_properties(input)?;
|
2022-03-20 16:28:34 -07:00
|
|
|
Ok((input, Boundary{
|
2021-12-18 21:05:00 -08:00
|
|
|
layer: (layer, dtype),
|
|
|
|
|
xy: xy,
|
|
|
|
|
properties: properties,
|
2022-03-20 16:28:34 -07:00
|
|
|
}))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
size += BOUNDARY::write(ww, &())?;
|
|
|
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
|
|
|
size += DATATYPE::write(ww, &self.layer.1)?;
|
|
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
|
|
|
size += write_properties(ww, &self.properties)?;
|
|
|
|
|
size += ENDEL::write(ww, &())?;
|
2021-12-18 21:05:00 -08:00
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Datastructure representing a Path element.
|
|
|
|
|
///
|
|
|
|
|
/// If `path_type < 4`, `extension` values are not written.
|
|
|
|
|
/// During read, `exension` defaults to (0, 0) even if unused.
|
|
|
|
|
///
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub struct Path {
|
|
|
|
|
/// (layer, data_type) tuple
|
|
|
|
|
layer: (i16, i16),
|
|
|
|
|
/// End-cap type (0: flush, 1: circle, 2: square, 4: custom)
|
|
|
|
|
path_type: i16,
|
|
|
|
|
/// Path width
|
|
|
|
|
width: i32,
|
|
|
|
|
/// Extension when using path_type=4. Ignored otherwise.
|
|
|
|
|
extension: (i32, i32),
|
|
|
|
|
/// Path centerline coordinates. [x0, y0, x1, y1,...]
|
|
|
|
|
xy: Vec<i32>,
|
|
|
|
|
/// Properties for the element.
|
|
|
|
|
properties: HashMap::<i16, Vec<u8>>,
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Element for Path {
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut path_type = 0;
|
|
|
|
|
let mut width = 0;
|
|
|
|
|
let mut bgn_ext = 0;
|
|
|
|
|
let mut end_ext = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = DATATYPE::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
|
2025-04-11 11:18:56 -07:00
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
while header.tag != records::RTAG_XY {
|
|
|
|
|
match header.tag {
|
|
|
|
|
records::RTAG_PATHTYPE =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, path_type) = PATHTYPE::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_WIDTH =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, width) = WIDTH::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_BGNEXTN =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, bgn_ext) = BGNEXTN::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_ENDEXTN =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, end_ext) = ENDEXTN::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
_ =>
|
2022-03-20 16:28:34 -07:00
|
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
2021-12-18 21:05:00 -08:00
|
|
|
};
|
2025-04-11 11:18:56 -07:00
|
|
|
(input, header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
let (input, xy) = XY::read_data(input, header.data_size)?;
|
|
|
|
|
let (input, properties) = read_properties(input)?;
|
2022-03-20 16:28:34 -07:00
|
|
|
Ok((input, Path{
|
2021-12-18 21:05:00 -08:00
|
|
|
layer: (layer, dtype),
|
|
|
|
|
xy: xy,
|
|
|
|
|
properties: properties,
|
|
|
|
|
extension: (bgn_ext, end_ext),
|
|
|
|
|
path_type: path_type,
|
|
|
|
|
width: width,
|
2022-03-20 16:28:34 -07:00
|
|
|
}))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
size += PATH::write(ww, &())?;
|
|
|
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
|
|
|
size += DATATYPE::write(ww, &self.layer.1)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
if self.path_type != 0 {
|
2022-03-20 16:28:34 -07:00
|
|
|
size += PATHTYPE::write(ww, &self.path_type)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
if self.width != 0 {
|
2022-03-20 16:28:34 -07:00
|
|
|
size += WIDTH::write(ww, &self.width)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if self.path_type < 4 {
|
|
|
|
|
let (bgn_ext, end_ext) = self.extension;
|
|
|
|
|
if bgn_ext != 0 {
|
2022-03-20 16:28:34 -07:00
|
|
|
size += BGNEXTN::write(ww, &bgn_ext)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
if end_ext != 0 {
|
2022-03-20 16:28:34 -07:00
|
|
|
size += ENDEXTN::write(ww, &end_ext)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
|
|
|
size += write_properties(ww, &self.properties)?;
|
|
|
|
|
size += ENDEL::write(ww, &())?;
|
2021-12-18 21:05:00 -08:00
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Datastructure representing a Box element. Rarely used.
|
|
|
|
|
///
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub struct GDSBox {
|
|
|
|
|
/// (layer, box_type) tuple
|
|
|
|
|
layer: (i16, i16),
|
|
|
|
|
/// Box coordinates (5 pairs)
|
|
|
|
|
xy: Vec<i32>,
|
|
|
|
|
/// Properties for the element.
|
|
|
|
|
properties: HashMap::<i16, Vec<u8>>,
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Element for GDSBox {
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
2021-12-18 21:05:00 -08:00
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = BOXTYPE::read(input)?;
|
|
|
|
|
let (input, xy) = XY::read(input)?;
|
|
|
|
|
let (input, properties) = read_properties(input)?;
|
2022-03-20 16:28:34 -07:00
|
|
|
Ok((input, GDSBox{
|
2021-12-18 21:05:00 -08:00
|
|
|
layer: (layer, dtype),
|
|
|
|
|
xy: xy,
|
|
|
|
|
properties: properties,
|
2022-03-20 16:28:34 -07:00
|
|
|
}))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
size += BOX::write(ww, &())?;
|
|
|
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
|
|
|
size += BOXTYPE::write(ww, &self.layer.1)?;
|
|
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
|
|
|
size += write_properties(ww, &self.properties)?;
|
|
|
|
|
size += ENDEL::write(ww, &())?;
|
2021-12-18 21:05:00 -08:00
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Datastructure representing a Node element. Rarely used.
|
|
|
|
|
///
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub struct Node {
|
|
|
|
|
/// (layer, box_type) tuple
|
|
|
|
|
layer: (i16, i16),
|
|
|
|
|
/// 1-50 pairs of coordinates.
|
|
|
|
|
xy: Vec<i32>,
|
|
|
|
|
/// Properties for the element.
|
|
|
|
|
properties: HashMap::<i16, Vec<u8>>,
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Element for Node {
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
2021-12-18 21:05:00 -08:00
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = NODETYPE::read(input)?;
|
|
|
|
|
let (input, xy) = XY::read(input)?;
|
|
|
|
|
let (input, properties) = read_properties(input)?;
|
2022-03-20 16:28:34 -07:00
|
|
|
Ok((input, Node{
|
2021-12-18 21:05:00 -08:00
|
|
|
layer: (layer, dtype),
|
|
|
|
|
xy: xy,
|
|
|
|
|
properties: properties,
|
2022-03-20 16:28:34 -07:00
|
|
|
}))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
size += NODE::write(ww, &())?;
|
|
|
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
|
|
|
size += NODETYPE::write(ww, &self.layer.1)?;
|
|
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
|
|
|
size += write_properties(ww, &self.properties)?;
|
|
|
|
|
size += ENDEL::write(ww, &())?;
|
2021-12-18 21:05:00 -08:00
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
///
|
|
|
|
|
/// Datastructure representing a text label.
|
|
|
|
|
///
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub struct Text {
|
|
|
|
|
/// (layer, node_type) tuple
|
|
|
|
|
layer: (i16, i16),
|
|
|
|
|
|
|
|
|
|
/// Bit array. Default all zeros.
|
|
|
|
|
/// bits 0-1: 00 left/01 center/10 right
|
|
|
|
|
/// bits 2-3: 00 top/01 middle/10 bottom
|
|
|
|
|
/// bits 4-5: font number
|
2021-12-18 21:05:00 -08:00
|
|
|
presentation: [bool; 16],
|
2022-03-20 16:28:34 -07:00
|
|
|
|
|
|
|
|
/// Default 0
|
|
|
|
|
path_type: i16,
|
|
|
|
|
/// Default 0
|
|
|
|
|
width: i32,
|
|
|
|
|
/// Vertical inversion. Default false.
|
|
|
|
|
invert_y: bool,
|
|
|
|
|
/// Scaling factor. Default 1.
|
|
|
|
|
mag: f64,
|
|
|
|
|
/// Rotation (ccw). Default 0.
|
|
|
|
|
angle_deg: f64,
|
|
|
|
|
/// Position (1 pair only)
|
|
|
|
|
xy: Vec<i32>,
|
|
|
|
|
/// Text content
|
|
|
|
|
string: Vec<u8>,
|
|
|
|
|
/// Properties for the element.
|
|
|
|
|
properties: HashMap::<i16, Vec<u8>>
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Element for Text {
|
2026-04-02 20:35:31 -07:00
|
|
|
fn read(input: &[u8]) -> IResult<'_, Self> {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut path_type = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
let mut presentation = [false; 16];
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut invert_y = false;
|
|
|
|
|
let mut width = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
let mut mag = 1.0;
|
|
|
|
|
let mut angle_deg = 0.0;
|
2021-12-18 21:05:00 -08:00
|
|
|
let (input, layer) = LAYER::skip_and_read(input)?;
|
|
|
|
|
let (input, dtype) = TEXTTYPE::read(input)?;
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
let (mut input, mut header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
while header.tag != records::RTAG_XY {
|
|
|
|
|
match header.tag {
|
|
|
|
|
records::RTAG_PRESENTATION =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, presentation) = PRESENTATION::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_PATHTYPE =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, path_type) = PATHTYPE::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_WIDTH =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, width) = WIDTH::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_STRANS => {
|
2022-03-20 16:28:34 -07:00
|
|
|
let result = STRANS::read_data(input, header.data_size)?;
|
|
|
|
|
input = result.0;
|
|
|
|
|
invert_y = result.1[0];
|
2021-12-18 21:05:00 -08:00
|
|
|
},
|
|
|
|
|
records::RTAG_MAG =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, mag) = MAG::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
records::RTAG_ANGLE =>
|
2022-03-20 16:28:34 -07:00
|
|
|
{(input, angle_deg) = ANGLE::read_data(input, header.data_size)?;},
|
2021-12-18 21:05:00 -08:00
|
|
|
_ =>
|
2022-03-20 16:28:34 -07:00
|
|
|
return fail(input, format!("Unexpected tag {:04x}", header.tag)),
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
(input, header) = RecordHeader::read(input)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
let (input, xy) = XY::read_data(input, header.data_size)?;
|
|
|
|
|
|
|
|
|
|
let (input, string) = STRING::read(input)?;
|
|
|
|
|
let (input, properties) = read_properties(input)?;
|
2022-03-20 16:28:34 -07:00
|
|
|
Ok((input, Text{
|
2021-12-18 21:05:00 -08:00
|
|
|
layer: (layer, dtype),
|
|
|
|
|
xy: xy,
|
|
|
|
|
properties: properties,
|
|
|
|
|
string: string,
|
|
|
|
|
presentation: presentation,
|
|
|
|
|
path_type: path_type,
|
|
|
|
|
width: width,
|
|
|
|
|
invert_y: invert_y,
|
|
|
|
|
mag: mag,
|
|
|
|
|
angle_deg: angle_deg,
|
2022-03-20 16:28:34 -07:00
|
|
|
}))
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
|
2022-03-20 16:28:34 -07:00
|
|
|
fn write<W: Write>(&self, ww: &mut W) -> OResult {
|
2021-12-18 21:05:00 -08:00
|
|
|
let mut size = 0;
|
2022-03-20 16:28:34 -07:00
|
|
|
size += TEXT::write(ww, &())?;
|
|
|
|
|
size += LAYER::write(ww, &self.layer.0)?;
|
|
|
|
|
size += TEXTTYPE::write(ww, &self.layer.1)?;
|
|
|
|
|
if self.presentation.iter().any(|&x| x) {
|
|
|
|
|
size += PRESENTATION::write(ww, &self.presentation)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
if self.path_type != 0 {
|
2022-03-20 16:28:34 -07:00
|
|
|
size += PATHTYPE::write(ww, &self.path_type)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
if self.width != 0 {
|
2022-03-20 16:28:34 -07:00
|
|
|
size += WIDTH::write(ww, &self.width)?
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
if self.angle_deg != 0.0 || self.mag != 1.0 || self.invert_y {
|
|
|
|
|
let strans = {
|
|
|
|
|
let mut arr = [false; 16];
|
|
|
|
|
arr[0] = self.invert_y;
|
|
|
|
|
arr
|
|
|
|
|
};
|
|
|
|
|
size += STRANS::write(ww, &strans)?;
|
|
|
|
|
if self.mag != 1.0 {
|
|
|
|
|
size += MAG::write(ww, &self.mag)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
if self.angle_deg != 0.0 {
|
|
|
|
|
size += ANGLE::write(ww, &self.angle_deg)?;
|
2021-12-18 21:05:00 -08:00
|
|
|
}
|
|
|
|
|
}
|
2022-03-20 16:28:34 -07:00
|
|
|
size += XY::write(ww, &self.xy)?;
|
|
|
|
|
size += STRING::write(ww, &self.string)?;
|
|
|
|
|
size += write_properties(ww, &self.properties)?;
|
|
|
|
|
size += ENDEL::write(ww, &())?;
|
2021-12-18 21:05:00 -08:00
|
|
|
Ok(size)
|
|
|
|
|
}
|
|
|
|
|
}
|
2025-04-10 01:07:11 -07:00
|
|
|
*/
|