Add support for Display

Cargo.lock

@@ -195,6 +195,7 @@ dependencies = [
  "clap-verbosity-flag",
  "env_logger",
  "log",
+ "strum",
 ]
 
 [[package]]
@@ -316,12 +317,40 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+
 [[package]]
 name = "strsim"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
+[[package]]
+name = "strum"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.42",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"

Cargo.toml

@@ -19,3 +19,4 @@ clap = { version = "4.4.11", features = ["derive"] }
 clap-verbosity-flag = "2.1.1"
 env_logger = "0.10.1"
 log = "0.4.20"
+strum = { version = "0.25.0", features = ["derive"] }

src/ezcad/array_of.rs

@@ -13,9 +13,9 @@ where
     // Temporary variable that holds number of elements
     #[br(temp)]
     #[bw(try_calc(u32::try_from(value.len())))]
-    size: u32,
+    count: u32,
 
-    #[br(count = size / core::mem::size_of::<T>() as u32)]
+    #[br(count = count)]
     pub value: Vec<T>,
 }
 

src/ezcad/field_of.rs

@@ -1,5 +1,6 @@
 use binrw::{binrw, BinRead, BinWrite};
 use std::{
+    fmt::Display,
     mem::size_of,
     ops::{Deref, DerefMut},
 };
@@ -42,6 +43,17 @@ where
     }
 }
 
+impl<T> Display for FieldOf<T>
+where
+    T: for<'a> BinRead<Args<'a> = ()>,
+    T: for<'a> BinWrite<Args<'a> = ()>,
+    T: Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.value)
+    }
+}
+
 impl<T> From<T> for FieldOf<T>
 where
     T: for<'a> BinRead<Args<'a> = ()>,

src/ezcad/file.rs

@@ -6,10 +6,10 @@ use crate::{array_of::ArrayOf, layer::Layer, pen::PenHeader};
 pub struct Header {
     _magic: [u16; 8],
     _unknown_1: [u8; 0x150],
-    pub thumbnail_offset: FilePtr64<Thumbnail>,
-    pub pens_offset: FilePtr64<PenHeader>,
+    pub thumbnail: FilePtr64<Thumbnail>,
+    pub pens: FilePtr64<PenHeader>,
     _unknown_offset: FilePtr64<()>,
-    pub layers_offset: FilePtr64<ArrayOf<Layer>>,
+    pub layers: FilePtr64<ArrayOf<Layer>>,
     _unknown_2: [u8; 0x1A8],
 }
 

src/ezcad/layer.rs

@@ -2,18 +2,10 @@ use binrw::{BinRead, BinWrite};
 
 use crate::{
     array_of::ArrayOf,
-    object::Object,
+    objects::Object,
     types::{Field, WString, F64, U16, U32},
 };
 
-// #[derive(BinRead, BinWrite, Debug)]
-// pub struct LayerHeader {
-//     // pub layer_count: u32,
-//     // #[br(count = layer_count)]
-//     // pub layers: Vec<Layer>,
-//     pub layers: ArrayOf<Layer>,
-// }
-
 #[derive(BinRead, BinWrite, Debug)]
 #[brw(magic(17u32))] // Number of fields within this struct
 pub struct LayerPre {

src/ezcad/mod.rs

@@ -2,6 +2,6 @@ pub mod array_of;
 pub mod field_of;
 pub mod file;
 pub mod layer;
-pub mod object;
+pub mod objects;
 pub mod pen;
 pub mod types;

src/ezcad/object.rs

@@ -1,111 +0,0 @@
-use binrw::{BinRead, BinWrite};
-
-use crate::{
-    array_of::ArrayOf,
-    field_of::FieldOf,
-    types::{Field, ObjectType, Point, WString, F64, U16, U32},
-};
-
-#[derive(BinRead, BinWrite, Debug)]
-pub enum LineType {
-    #[brw(magic = 0x0001u64)]
-    Point(Point),
-    #[brw(magic = 0x0100u64)]
-    Line { points: ArrayOf<Point> },
-    #[brw(magic = 0x0300u64)]
-    Bezier { points: ArrayOf<Point> },
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-#[brw(magic(17u32))]
-pub struct ObjBase {
-    pub pen: U32,
-    pub obj_type: FieldOf<ObjectType>,
-    pub flags: U16,
-    pub name: WString,
-    pub count: U32,
-    _unknown_1: Field,
-    pub io_control_enable_mask: U16,
-    pub io_control_disable_mask: U16,
-    _unknown_2: [Field; 5],
-    pub origin: FieldOf<Point>,
-    pub z: F64,
-    pub a: F64,
-    _unknown_3: Field,
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-pub struct Lines {
-    pub base: ObjBase,
-    pub lines: ArrayOf<LineType>,
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-pub struct Rectangle {
-    pub base: ObjBase,
-    #[brw(magic(8u32))] // Number of following fields in struct
-    pub corner_a: FieldOf<Point>,
-    pub corner_b: FieldOf<Point>,
-    pub round_bottom_left: F64,
-    pub round_bottom_right: F64,
-    pub round_top_right: F64,
-    pub round_top_left: F64,
-    _unknown_1: [Field; 2],
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-pub struct Circle {
-    pub base: ObjBase,
-    #[brw(magic(6u32))] // Number of following fields in struct
-    pub origin: FieldOf<Point>,
-    pub radius: F64,
-    pub start_angle: F64,
-    pub clockwise: U32,
-    _unknown_1: [Field; 2],
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-pub struct Ellipse {
-    pub base: ObjBase,
-    #[brw(magic(8u32))] // Number of following fields in struct
-    pub clockwise: U32,
-    pub corner_a: FieldOf<Point>,
-    pub corner_b: FieldOf<Point>,
-    pub start_angle: F64,
-    pub end_angle: F64,
-    _unknown_1: [Field; 2],
-    pub open_curve: U32,
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-pub struct Polygon {
-    pub base: ObjBase,
-    #[brw(magic(10u32))] // Number of following fields in struct
-    pub invert_shape: U32,
-    pub corner_a: FieldOf<Point>,
-    pub corner_b: FieldOf<Point>,
-    pub offset_cx: F64,
-    pub offset_cy: F64,
-    pub offset_dx: F64,
-    pub offset_dy: F64,
-    pub edges: U32,
-    _unknown_1: [Field; 2],
-}
-
-#[derive(BinRead, BinWrite, Debug)]
-pub enum Object {
-    #[brw(magic = 1u32)]
-    Curve(Lines),
-    #[brw(magic = 2u32)]
-    Point(Lines),
-    #[brw(magic = 3u32)]
-    Rectangle(Rectangle),
-    #[brw(magic = 4u32)]
-    Circle(Circle),
-    #[brw(magic = 5u32)]
-    Ellipse(Ellipse),
-    #[brw(magic = 6u32)]
-    Polygon(Polygon),
-    // #[brw(magic = 32u32)]
-    // Hatch(Hatch),
-}

src/ezcad/objects/circle.rs

@@ -0,0 +1,27 @@
+use std::fmt::Display;
+
+use binrw::{BinRead, BinWrite};
+
+use crate::{
+    field_of::FieldOf,
+    types::{Field, Point, F64, U32},
+};
+
+use super::ObjBase;
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Circle {
+    pub base: ObjBase,
+    #[brw(magic(6u32))] // Number of following fields in struct
+    pub origin: FieldOf<Point>,
+    pub radius: F64,
+    pub start_angle: F64,
+    pub clockwise: U32,
+    _unknown_1: [Field; 2],
+}
+
+impl Display for Circle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.base)
+    }
+}

src/ezcad/objects/ellipse.rs

@@ -0,0 +1,29 @@
+use std::fmt::Display;
+
+use binrw::{BinRead, BinWrite};
+
+use crate::{
+    field_of::FieldOf,
+    types::{Field, Point, F64, U32},
+};
+
+use super::ObjBase;
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Ellipse {
+    pub base: ObjBase,
+    #[brw(magic(8u32))] // Number of following fields in struct
+    pub clockwise: U32,
+    pub corner_a: FieldOf<Point>,
+    pub corner_b: FieldOf<Point>,
+    pub start_angle: F64,
+    pub end_angle: F64,
+    _unknown_1: [Field; 2],
+    pub open_curve: U32,
+}
+
+impl Display for Ellipse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.base)
+    }
+}

src/ezcad/objects/hatch.rs

@@ -0,0 +1 @@
+

src/ezcad/objects/line.rs

@@ -0,0 +1,29 @@
+use std::fmt::Display;
+
+use binrw::{BinRead, BinWrite};
+
+use crate::{array_of::ArrayOf, types::Point};
+
+use super::ObjBase;
+
+#[derive(BinRead, BinWrite, Debug)]
+pub enum LineType {
+    #[brw(magic = 0x0001u64)]
+    Point(Point),
+    #[brw(magic = 0x0100u64)]
+    Line { points: ArrayOf<Point> },
+    #[brw(magic = 0x0300u64)]
+    Bezier { points: ArrayOf<Point> },
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Lines {
+    pub base: ObjBase,
+    pub lines: ArrayOf<LineType>,
+}
+
+impl Display for Lines {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.base)
+    }
+}

src/ezcad/objects/mod.rs

@@ -0,0 +1,72 @@
+use std::fmt::Display;
+
+use binrw::{BinRead, BinWrite};
+
+use crate::{
+    field_of::FieldOf,
+    types::{Field, ObjectType, Point, WString, F64, U16, U32},
+};
+
+use self::{circle::Circle, ellipse::Ellipse, line::Lines, polygon::Polygon, rectangle::Rectangle};
+
+pub mod circle;
+pub mod ellipse;
+pub mod hatch;
+pub mod line;
+pub mod polygon;
+pub mod rectangle;
+
+#[derive(BinRead, BinWrite, Debug)]
+#[brw(magic(17u32))]
+pub struct ObjBase {
+    pub pen: U32,
+    pub obj_type: FieldOf<ObjectType>,
+    pub flags: U16,
+    pub name: WString,
+    pub count: U32,
+    _unknown_1: Field,
+    pub io_control_enable_mask: U16,
+    pub io_control_disable_mask: U16,
+    _unknown_2: [Field; 5],
+    pub origin: FieldOf<Point>,
+    pub z: F64,
+    pub a: F64,
+    _unknown_3: Field,
+}
+
+impl Display for ObjBase {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("[{}]", self.obj_type))
+    }
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub enum Object {
+    #[brw(magic = 1u32)]
+    Curve(Lines),
+    #[brw(magic = 2u32)]
+    Point(Lines),
+    #[brw(magic = 3u32)]
+    Rectangle(Rectangle),
+    #[brw(magic = 4u32)]
+    Circle(Circle),
+    #[brw(magic = 5u32)]
+    Ellipse(Ellipse),
+    #[brw(magic = 6u32)]
+    Polygon(Polygon),
+    // #[brw(magic = 32u32)]
+    // Hatch(Hatch),
+}
+
+impl Display for Object {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Object::Curve(x) => write!(f, "{}", x),
+            Object::Point(x) => write!(f, "{}", x),
+            Object::Rectangle(x) => write!(f, "{}", x),
+            Object::Circle(x) => write!(f, "{}", x),
+            Object::Ellipse(x) => write!(f, "{}", x),
+            Object::Polygon(x) => write!(f, "{}", x),
+        }
+    }
+}

src/ezcad/objects/polygon.rs

@@ -0,0 +1,31 @@
+use std::fmt::Display;
+
+use binrw::{BinRead, BinWrite};
+
+use crate::{
+    field_of::FieldOf,
+    types::{Field, Point, F64, U32},
+};
+
+use super::ObjBase;
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Polygon {
+    pub base: ObjBase,
+    #[brw(magic(10u32))] // Number of following fields in struct
+    pub invert_shape: U32,
+    pub corner_a: FieldOf<Point>,
+    pub corner_b: FieldOf<Point>,
+    pub offset_cx: F64,
+    pub offset_cy: F64,
+    pub offset_dx: F64,
+    pub offset_dy: F64,
+    pub edges: U32,
+    _unknown_1: [Field; 2],
+}
+
+impl Display for Polygon {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.base)
+    }
+}

src/ezcad/objects/rectangle.rs

@@ -0,0 +1,29 @@
+use std::fmt::Display;
+
+use binrw::{BinRead, BinWrite};
+
+use crate::{
+    field_of::FieldOf,
+    types::{Field, Point, F64},
+};
+
+use super::ObjBase;
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Rectangle {
+    pub base: ObjBase,
+    #[brw(magic(8u32))] // Number of following fields in struct
+    pub corner_a: FieldOf<Point>,
+    pub corner_b: FieldOf<Point>,
+    pub round_bottom_left: F64,
+    pub round_bottom_right: F64,
+    pub round_top_right: F64,
+    pub round_top_left: F64,
+    _unknown_1: [Field; 2],
+}
+
+impl Display for Rectangle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.base)
+    }
+}

src/ezcad/types.rs

@@ -1,5 +1,7 @@
 #![allow(dead_code)]
 
+use std::fmt::Display;
+
 use binrw::{binrw, BinRead, BinWrite};
 
 use crate::{array_of::ArrayOf, field_of::FieldOf};
@@ -11,11 +13,21 @@ pub type U32 = FieldOf<u32>;
 pub type U16 = FieldOf<u16>;
 pub type F64 = FieldOf<f64>;
 
-pub type WString = ArrayOf<u16>;
+#[binrw]
+#[derive(Debug, PartialEq)]
+pub struct WString {
+    // Temporary variable that holds number of elements
+    #[br(temp)]
+    #[bw(try_calc(u32::try_from(value.len())))]
+    size: u32,
+
+    #[br(count = size / core::mem::size_of::<u16>() as u32)]
+    pub value: Vec<u16>,
+}
 
 impl From<&WString> for String {
     fn from(value: &WString) -> Self {
-        String::from_utf16_lossy(value)
+        String::from_utf16_lossy(&value.value)
     }
 }
 
@@ -26,6 +38,12 @@ impl From<String> for WString {
     }
 }
 
+impl Display for WString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", String::from(self))
+    }
+}
+
 #[derive(BinRead, BinWrite, PartialEq, Debug)]
 pub struct Rgba {
     pub red: u8,
@@ -34,23 +52,29 @@ pub struct Rgba {
     pub alpha: u8,
 }
 
+impl Display for Rgba {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "({}, {}, {}, {})",
+            self.red, self.green, self.blue, self.alpha
+        )
+    }
+}
+
 #[derive(BinRead, BinWrite, PartialEq, Debug)]
 pub struct Point {
     pub x: f64,
     pub y: f64,
 }
 
-#[binrw]
-#[derive(PartialEq, Debug)]
-pub struct MultiLine {
-    #[br(temp)]
-    #[bw(try_calc(u32::try_from(points.len())))]
-    point_count: u32,
-    #[br(count = point_count)]
-    points: Vec<Point>,
+impl Display for Point {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
 }
 
-#[derive(BinRead, BinWrite, PartialEq, Debug)]
+#[derive(BinRead, BinWrite, PartialEq, Debug, strum::Display)]
 #[brw(repr(u32))]
 #[repr(u32)]
 pub enum WobbleType {
@@ -61,7 +85,7 @@ pub enum WobbleType {
     Hori8 = 4,
 }
 
-#[derive(BinRead, BinWrite, PartialEq, Debug)]
+#[derive(BinRead, BinWrite, PartialEq, Debug, strum::Display)]
 #[brw(repr(u16))]
 #[repr(u16)]
 pub enum ObjectType {
@@ -74,7 +98,7 @@ pub enum ObjectType {
     Hatch = 32,
 }
 
-#[derive(BinRead, BinWrite, PartialEq, Debug)]
+#[derive(BinRead, BinWrite, PartialEq, Debug, strum::Display)]
 #[brw(repr(u16))]
 #[repr(u16)]
 pub enum LineType {

src/main.rs

@@ -46,6 +46,11 @@ fn main() {
     // for i in 0..50 {
     //     dbg!(&file.pens_offset.start_offset.pens[i].disabled);
     // }
-    dbg!(String::from(&file.pens_offset.start_offset.pens[0].name));
+    // dbg!(String::from(&file.pens_offset.start_offset.pens[0].name));
     // dbg!(&file.pens_offset.start_offset.pens[255].wobble_type);
+    for layer in file.layers.iter() {
+        for object in layer.objects.iter() {
+            info!("{object}");
+        }
+    }
 }