1 files changed, 161 insertions, 0 deletions

diff --git a/core/src/styles.rs b/core/src/styles.rs
new file mode 100644
index 0000000..c061c58
--- /dev/null
+++ b/core/src/styles.rs
@@ -0,0 +1,161 @@
+use super::colors::Color;
+use super::types::Float;
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+#[non_exhaustive]
+pub enum Pattern {
+    Solid(Color),
+    None,
+}
+
+impl Pattern {
+    pub fn is_none(&self) -> bool {
+        match self {
+            Pattern::None => true,
+            _ => false,
+        }
+    }
+}
+
+impl Default for Pattern {
+    fn default() -> Self {
+        Pattern::Solid(Color::default())
+    }
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct FillStyle {
+    pub(crate) pattern: Pattern,
+}
+
+impl FillStyle {
+    pub fn solid(color: Color) -> Self {
+        FillStyle {
+            pattern: Pattern::Solid(color),
+        }
+    }
+}
+
+impl Default for FillStyle {
+    fn default() -> Self {
+        FillStyle {
+            pattern: Pattern::None,
+        }
+    }
+}
+
+// TODO: probably move Float into an enum with Defined(f64) and Variable(handle)
+#[derive(Clone, Debug)]
+pub struct StrokeStyle {
+    pub(crate) pattern: Pattern,
+    pub(crate) dash: Option<DashStyle>,
+    pub(crate) line_width: Float,
+}
+
+impl StrokeStyle {
+    pub fn solid(color: Color) -> Self {
+        StrokeStyle {
+            pattern: Pattern::Solid(color),
+            dash: None,
+            line_width: Float::Fixed(0.),
+        }
+    }
+
+    pub fn builder() -> StrokeStyleBuilder {
+        StrokeStyleBuilder::default()
+    }
+}
+
+impl Default for StrokeStyle {
+    fn default() -> Self {
+        Self::builder().build()
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct StrokeStyleBuilder {
+    pattern: Option<Pattern>,
+    dash: Option<DashStyle>,
+    line_width: Option<Float>,
+}
+
+impl StrokeStyleBuilder {
+    pub fn pattern(&mut self, pattern: Pattern) -> &mut Self {
+        self.pattern = Some(pattern);
+        self
+    }
+
+    pub fn dash(&mut self, dash: DashStyle) -> &mut Self {
+        self.dash = Some(dash);
+        self
+    }
+
+    pub fn line_width(&mut self, width: Float) -> &mut Self {
+        self.line_width = Some(width);
+        self
+    }
+
+    pub fn build(&mut self) -> StrokeStyle {
+        StrokeStyle {
+            pattern: self.pattern.clone().unwrap_or_default(),
+            dash: self.dash.clone(),
+            line_width: self.line_width.unwrap_or(Float::Fixed(2.)),
+        }
+    }
+
+}
+
+
+
+
+#[derive(Clone, Debug, Default)]
+pub struct DashStyle {
+    pub(crate) dashes: Vec<Float>,
+    pub(crate) offset: Float,
+}
+
+impl DashStyle {
+    pub fn new(dashes: Vec<Float>, offset: Float) -> Self {
+        Self { dashes, offset }
+    }
+
+    pub fn dashes(&self) -> &[Float] {
+        &self.dashes
+    }
+
+    pub fn dashes_mut(&mut self) -> &mut Vec<Float> {
+        &mut self.dashes
+    }
+
+    pub fn offset(&self) -> Float {
+        self.offset
+    }
+
+    // TODO: does this makes sense?
+    pub fn offset_mut(&mut self) -> &mut Float {
+        &mut self.offset
+    }
+}
+
+#[derive(Clone, PartialEq, Debug, Default)]
+pub struct DefinedStrokeStyle {
+    pub(crate) pattern: Pattern,
+    pub(crate) dash: Option<DefinedDashStyle>,
+    pub(crate) line_width: f64,
+}
+
+#[derive(Clone, PartialEq, Debug, Default)]
+pub struct DefinedDashStyle {
+    pub(crate) dashes: Vec<f64>,
+    pub(crate) offset: f64,
+}
+
+impl DefinedDashStyle {
+    pub fn dashes(&self) -> &[f64] {
+        &self.dashes
+    }
+
+    pub fn offset(&self) -> f64 {
+        self.offset
+    }
+}