Minilase/src/ezcad/objects/ellipse.rs

use std::fmt::Debug;

use binrw::{BinRead, BinWrite};
use diff::Diff;

use crate::{
    field_of::FieldOf,
    types::{Coordinate, ObjectType, F64, U32},
};

use super::{ObjectCore, ObjectModifier, Translate};

#[derive(BinRead, BinWrite, Clone, Debug, Diff, PartialEq)]
#[diff(attr(
    #[derive(Debug, PartialEq)]
))]
pub struct Ellipse {
    pub core: ObjectCore,
    #[brw(magic(8u32))] // Number of following fields in struct
    pub clockwise: U32,
    pub drawn_corner_a: FieldOf<Coordinate>,
    pub drawn_corner_b: FieldOf<Coordinate>,
    pub start_angle: F64, // Radians
    pub end_angle: F64,   // Radians
    pub modifier: ObjectModifier,
    pub open_curve: U32,
}

impl Default for Ellipse {
    fn default() -> Self {
        Self {
            core: ObjectCore::default(ObjectType::Ellipse),
            clockwise: 0.into(),
            drawn_corner_a: Coordinate { x: 0.0, y: 0.0 }.into(),
            drawn_corner_b: Coordinate { x: 0.0, y: 0.0 }.into(),
            start_angle: 0.0.into(),
            end_angle: 0.0.into(),
            modifier: ObjectModifier::default(),
            open_curve: 0.into(),
        }
    }
}

impl Translate for Ellipse {
    fn move_absolute(&mut self, origin: Option<Coordinate>, z: Option<f64>) {
        origin.map(|origin| {
            let delta: Coordinate = origin - *self.core.origin;
            self.modifier.move_relative(delta);
        });
        self.core.move_absolute(origin, z);
    }

    fn move_relative(&mut self, delta: Option<Coordinate>, z: Option<f64>) {
        delta.map(|delta| {
            self.modifier.move_relative(delta);
        });
        self.core.move_relative(delta, z);
    }
}