add support for images, and some chores

- SVG files not yet supported
- Remove dead commented code
- Add inherent constraints for text, path, and images
- Formatting

1 files changed, 105 insertions, 69 deletions

diff --git a/core/src/core_shapes.rs b/core/src/core_shapes.rs
index e6d79c9..c380870 100644
--- a/core/src/core_shapes.rs
+++ b/core/src/core_shapes.rs
@@ -1,7 +1,12 @@
-use crate::types::{CoreShapeContext, DefinedCoreShapeContext, DefinedPoint2D, Point2D};
+use std::path::PathBuf;
 
-pub use super::text::{DefinedText, Text};
+use crate::{
+    text::{DefinedText, Text},
+    types::{CoreShapeContext, DefinedCoreShapeContext, DefinedPoint2D, Float, Point2D},
+    Renderer, SolverContext,
+};
 
+#[derive(Debug, Clone)]
 pub struct CoreDrawable {
     pub(crate) shape: CoreShape,
     pub(crate) context: CoreShapeContext,
@@ -11,12 +16,91 @@ impl CoreDrawable {
     pub fn new(shape: CoreShape, context: CoreShapeContext) -> Self {
         Self { shape, context }
     }
+
+    // TODO: I don't like this design
+    // TODO: plus, having an enum for CoreShape could be bad since types have
+    // various sizes
+    pub(crate) fn inherent_constraints(
+        &self,
+        solver: &mut dyn SolverContext,
+        renderer: &mut dyn Renderer,
+    ) {
+        match &self.shape {
+            CoreShape::Text(text) => {
+                let (text_width, text_height) = renderer.text_extents(&text.content, &text.font);
+
+                let calculated_width =
+                    solver.float_mul(&[Float::Fixed(text_width), text.font.size]);
+                let bounds_width = self.context.bounds().width(solver);
+                let width_constraint = solver.float_eq(bounds_width, calculated_width);
+                solver.constrain(width_constraint);
+
+                let calculated_height =
+                    solver.float_mul(&[Float::Fixed(text_height), text.font.size]);
+                let bounds_height = self.context.bounds().height(solver);
+                let height_constraint = solver.float_eq(bounds_height, calculated_height);
+                solver.constrain(height_constraint);
+            }
+            CoreShape::StraightPath(path) => {
+                let (all_x, all_y): (Vec<_>, Vec<_>) =
+                    path.points.iter().map(|p| (p.x, p.y)).unzip();
+
+                let min_x = solver.float_min(&all_x);
+                let max_x = solver.float_max(&all_x);
+                let min_y = solver.float_min(&all_y);
+                let max_y = solver.float_max(&all_y);
+
+                let bounds_top = self.context.bounds().top(solver);
+                let bounds_bottom = self.context.bounds().bottom(solver);
+                let bounds_left = self.context.bounds().left(solver);
+                let bounds_right = self.context.bounds().right(solver);
+
+                let top_constraint = solver.float_eq(bounds_top, min_x);
+                solver.constrain(top_constraint);
+
+                let bottom_constraint = solver.float_eq(bounds_bottom, max_x);
+                solver.constrain(bottom_constraint);
+
+                let left_constraint = solver.float_eq(bounds_left, min_y);
+                solver.constrain(left_constraint);
+
+                let right_constraint = solver.float_eq(bounds_right, max_y);
+                solver.constrain(right_constraint);
+            }
+            CoreShape::Image(image) => {
+                if !image.keep_aspect_ratio {
+                    return;
+                }
+
+                let scale_x = solver.new_free_float();
+                let scale_y = solver.new_free_float();
+
+                let constraint = solver.float_eq(scale_x, scale_y);
+                solver.constrain(constraint);
+
+                let (orig_width, orig_height) = renderer.geometry_for_image(&image.path);
+
+                let orig_width_scaled = solver.float_mul(&[scale_x, Float::Fixed(orig_width)]);
+                let width_constraint =
+                    solver.float_eq(self.context.bounds().width, orig_width_scaled);
+                solver.constrain(width_constraint);
+
+                let orig_height_scaled = solver.float_mul(&[scale_y, Float::Fixed(orig_height)]);
+                let height_constraint =
+                    solver.float_eq(self.context.bounds().height, orig_height_scaled);
+                solver.constrain(height_constraint);
+            }
+            _ => (),
+        }
+    }
 }
 
+#[derive(Debug, Clone)]
 pub enum CoreShape {
     Rectangle(Rectangle),
     Text(Text),
     StraightPath(StraightPath),
+    Image(Image),
 }
 
 impl From<Rectangle> for CoreShape {
@@ -37,6 +121,12 @@ impl From<StraightPath> for CoreShape {
     }
 }
 
+impl From<Image> for CoreShape {
+    fn from(image: Image) -> Self {
+        CoreShape::Image(image)
+    }
+}
+
 pub struct DefinedCoreDrawable {
     pub(crate) shape: DefinedCoreShape,
     pub(crate) context: DefinedCoreShapeContext,
@@ -46,72 +136,12 @@ pub enum DefinedCoreShape {
     Rectangle(Rectangle),
     Text(DefinedText),
     StraightPath(DefinedStraightPath),
+    Image(Image),
 }
 
-/*
-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")
-    }
-}
-*/
-
 #[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))
-    }
-}
-*/
-
-// TODO: re-enable this in some way
-/*
-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>,
@@ -127,11 +157,17 @@ 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) })
+#[derive(Clone, Debug, Default)]
+pub struct Image {
+    pub(crate) path: PathBuf,
+    pub(crate) keep_aspect_ratio: bool,
+}
+
+impl Image {
+    pub fn new(path: PathBuf, keep_aspect_ratio: bool) -> Self {
+        Self {
+            path,
+            keep_aspect_ratio,
+        }
     }
 }
-*/