1 files changed, 24 insertions, 83 deletions

diff --git a/core/src/runtime.rs b/core/src/runtime.rs
index 6b1b5d1..5fd17e9 100644
--- a/core/src/runtime.rs
+++ b/core/src/runtime.rs
@@ -1,11 +1,11 @@
-use crate::core_shapes::CoreDrawable;
-use crate::rendering::Render;
-use crate::types::Bounds;
-
-// use super::complex_shapes::{ComplexShape, Drawable};
-use super::rendering::Renderer;
-use super::solving::{Constrainable, SolverContext};
+use crate::{
+    core_shapes::CoreDrawable,
+    rendering::{Render, Renderer},
+    solving::{Constrainable, SolverContext},
+    types::Bounds,
+};
 
+// TODO:
 // const RECURSION_LIMIT: u64 = 10_000;
 
 pub struct Runtime<'a> {
@@ -20,15 +20,10 @@ impl<'a> Runtime<'a> {
         Self {
             solver_ctx,
             renderer,
-            // drawables: Vec::new(),
             drawables: Vec::new(),
         }
     }
 
-    // pub fn add_drawable<T: ComplexShape + 'static>(&mut self, drawable: Drawable<T>) {
-    //     self.drawables.push(drawable.into())
-    // }
-
     pub fn add_drawable(&mut self, drawable: CoreDrawable) {
         self.drawables.push(drawable)
     }
@@ -41,88 +36,34 @@ impl<'a> Runtime<'a> {
         &mut *self.renderer
     }
 
-    pub fn render(mut self, bounds: Bounds) {
-        let model = self.solver_ctx.solve();
+    pub fn render(self, bounds: Bounds) {
+        // Separate self into several variables, so we can get mutable references to each at the
+        // same time
+        let Runtime {
+            mut solver_ctx,
+            mut renderer,
+            drawables,
+        } = self;
+
+        for drawable in &drawables {
+            drawable.inherent_constraints(&mut *solver_ctx, &mut *renderer);
+        }
+
+        let model = solver_ctx.solve();
 
         let bounds = bounds
             .fixate(&*model)
             .expect("Could not fixate figure bounds");
 
-        self.renderer.set_size(bounds.width, bounds.height);
+        renderer.set_size(bounds.width, bounds.height);
 
-        for drawable in &self.drawables {
+        for drawable in &drawables {
             let defined_drawable = drawable
                 .fixate(&*model)
                 .expect("Could not fixate core shape");
             defined_drawable
                 .shape
-                .render(defined_drawable.context, &mut *self.renderer);
+                .render(defined_drawable.context, &mut *renderer);
         }
     }
-
-    // TODO: preserve ordering of shapes
-    // pub fn render(mut self) {
-    //     let mut drawables = self.drawables;
-    //     let mut waited_on_variables = Vec::new();
-    //     let mut core_shapes = Vec::new();
-    //
-    //     /*
-    //     for drawable in &self.shapes {
-    //         let bounds = &drawable.bounds;
-    //         let shape = &drawable.shape;
-    //
-    //         if let Some(core_shape) = shape.to_render() {
-    //             drawables.push((*drawable).clone());
-    //             continue;
-    //         }
-    //
-    //         let mut result = shape.draw(bounds);
-    //         drawables.append(&mut result.subshapes);
-    //         waited_on_variables.append(&mut result.waiting_on);
-    //     }
-    //     */
-    //
-    //     let mut recursion_count = 0;
-    //
-    //     while !drawables.is_empty() {
-    //         recursion_count += 1;
-    //
-    //         if recursion_count > RECURSION_LIMIT {
-    //             panic!("Recursion limit reached");
-    //         }
-    //
-    //         let mut tmp_drawables = Vec::new();
-    //
-    //         for drawable in drawables.drain(..) {
-    //             let shape_ctx = &drawable.context;
-    //             let shape = &drawable.shape;
-    //
-    //             if let Some(core_shape) = shape.as_core_shape() {
-    //                 core_shape.constrain(shape_ctx, &mut *self.solver_ctx, &*self.renderer);
-    //                 core_shapes.push((shape.dyn_clone(), shape_ctx.clone())); // Better to Arc? Cow?
-    //                 continue;
-    //             }
-    //
-    //             let mut result = shape.draw(shape_ctx, &mut *self.solver_ctx);
-    //             tmp_drawables.append(&mut result.subshapes);
-    //             waited_on_variables.append(&mut result.waiting_on);
-    //         }
-    //
-    //         drawables = tmp_drawables;
-    //     }
-    //
-    //     let model = self.solver_ctx.solve();
-    //
-    //     // Delay rendering core shapes until later to have all the constraints
-    //     for (core_shape, shape_ctx) in core_shapes {
-    //         let core_shape = core_shape.as_core_shape().unwrap();
-    //
-    //         match (core_shape.to_render(&*model), shape_ctx.fixate(&*model)) {
-    //             (Some(defined_shape), Some(shape_ctx)) => {
-    //                 defined_shape.render(shape_ctx, &mut *self.renderer)
-    //             }
-    //             _ => panic!("Failed to fixate core shape"),
-    //         }
-    //     }
-    // }
 }