1 files changed, 86 insertions, 0 deletions

diff --git a/core/src/core_shapes.rs b/core/src/core_shapes.rs
new file mode 100644
index 0000000..c3d3cae
--- /dev/null
+++ b/core/src/core_shapes.rs
@@ -0,0 +1,86 @@
+use super::complex_shapes::{ComplexShape, DrawResult};
+use super::rendering::{Render, Renderer};
+use super::solving::{Constrainable, SolverContext, SolverModel};
+use super::types::*;
+
+pub trait CoreShape {
+    fn constrain(
+        &self,
+        _context: &ShapeContext,
+        _solver: &mut dyn SolverContext,
+        _renderer: &dyn Renderer,
+    ) {
+    }
+    fn to_render(&self, model: &dyn SolverModel) -> Option<Box<dyn Render>>;
+}
+
+impl<T: CoreShape + Clone + 'static> ComplexShape for T {
+    fn as_core_shape(&self) -> Option<&dyn CoreShape> {
+        Some(self)
+    }
+
+    fn draw(&self, _context: &ShapeContext, _solver: &mut dyn SolverContext) -> DrawResult {
+        panic!("Tried to decompose core shape")
+    }
+}
+
+// TODO: add default
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Rectangle {}
+
+impl CoreShape for Rectangle {
+    fn to_render(&self, _model: &dyn SolverModel) -> Option<Box<dyn Render>> {
+        Some(Box::new(self.clone()))
+    }
+}
+
+pub use super::text::{DefinedText, Text};
+
+impl CoreShape for Text {
+    fn constrain(
+        &self,
+        context: &ShapeContext,
+        solver: &mut dyn SolverContext,
+        renderer: &dyn Renderer,
+    ) {
+        let height_constraint = solver.float_eq(context.bounds.height, self.font.size);
+        solver.constrain(height_constraint);
+
+        // TODO: handle multiline
+        let (width, height) = renderer.text_extents(&self.content, &self.font);
+        dbg!(height);
+
+        let scale = solver.float_div(self.font.size, Float::Fixed(height));
+
+        let calculated_width = solver.float_mul(&[Float::Fixed(width), scale]);
+        let width_constraint = solver.float_eq(context.bounds.width, calculated_width);
+        solver.constrain(width_constraint);
+    }
+
+    fn to_render(&self, model: &dyn SolverModel) -> Option<Box<dyn Render>> {
+        self.fixate(model)
+            .map(|path| -> Box<dyn Render> { Box::new(path) })
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct StraightPath {
+    pub(crate) points: Vec<Point2D>,
+}
+
+impl StraightPath {
+    pub fn new(points: Vec<Point2D>) -> Self {
+        Self { points }
+    }
+}
+
+pub struct DefinedStraightPath {
+    pub(crate) points: Vec<DefinedPoint2D>,
+}
+
+impl CoreShape for StraightPath {
+    fn to_render(&self, model: &dyn SolverModel) -> Option<Box<dyn Render>> {
+        self.fixate(model)
+            .map(|path| -> Box<dyn Render> { Box::new(path) })
+    }
+}