WIP

1 files changed, 285 insertions, 0 deletions

diff --git a/core/src/complex_shapes.rs b/core/src/complex_shapes.rs
new file mode 100644
index 0000000..e23881d
--- /dev/null
+++ b/core/src/complex_shapes.rs
@@ -0,0 +1,285 @@
+use super::core_shapes::CoreShape;
+use super::solving::SolverContext;
+use super::styles::{FillStyle, StrokeStyle};
+use super::types::{Bounds, ShapeContext, ShapeContextBuilder};
+
+pub trait ComplexShape: DynClone {
+    fn as_core_shape(&self) -> Option<&dyn CoreShape> {
+        None
+    }
+
+    fn draw(&self, context: &ShapeContext, solver: &mut dyn SolverContext) -> DrawResult;
+}
+
+pub trait DynClone {
+    fn dyn_clone(&self) -> Box<dyn ComplexShape>;
+}
+
+impl<T: Clone + ComplexShape + 'static> DynClone for T {
+    fn dyn_clone(&self) -> Box<dyn ComplexShape> {
+        Box::new(self.clone())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Drawable<T: ComplexShape> {
+    pub(crate) context: ShapeContext,
+    pub(crate) shape: T,
+}
+
+impl<T: ComplexShape> Drawable<T> {
+    pub fn new(shape: T, context: ShapeContext) -> Self {
+        Self { context, shape }
+    }
+
+    pub fn from_shape(shape: T, solver: &mut dyn SolverContext) -> Self {
+        Self {
+            context: ShapeContext::builder().build(solver),
+            shape,
+        }
+    }
+
+    pub fn builder(shape: T) -> DrawableBuilder<T>
+    where
+        T: Clone,
+    {
+        DrawableBuilder::new(shape)
+    }
+
+    pub fn shape(&self) -> &T {
+        &self.shape
+    }
+
+    pub fn shape_mut(&mut self) -> &mut T {
+        &mut self.shape
+    }
+
+    pub fn bounds(&self) -> &Bounds {
+        &self.context.bounds
+    }
+
+    pub fn bounds_mut(&mut self) -> &mut Bounds {
+        &mut self.context.bounds
+    }
+
+    pub fn fill_style(&mut self) -> &mut FillStyle {
+        &mut self.context.fill
+    }
+
+    pub fn stroke_style(&mut self) -> &mut StrokeStyle {
+        &mut self.context.stroke
+    }
+}
+
+pub struct DrawableBuilder<T: ComplexShape> {
+    context: ShapeContextBuilder,
+    shape: T,
+}
+
+impl<T: ComplexShape + Clone> DrawableBuilder<T> {
+    pub fn new(shape: T) -> Self {
+        Self {
+            context: ShapeContext::builder(),
+            shape,
+        }
+    }
+
+    pub fn bounds(&mut self, bounds: Bounds) -> &mut Self {
+        self.context.bounds(bounds);
+        self
+    }
+
+    pub fn fill(&mut self, fill: FillStyle) -> &mut Self {
+        self.context.fill(fill);
+        self
+    }
+
+    pub fn stroke(&mut self, stroke: StrokeStyle) -> &mut Self {
+        self.context.stroke(stroke);
+        self
+    }
+
+    pub fn build(&self, solver: &mut dyn SolverContext) -> Drawable<T> {
+        Drawable {
+            shape: self.shape.clone(),
+            context: self.context.build(solver),
+        }
+    }
+}
+
+pub struct DynDrawable {
+    pub(crate) context: ShapeContext,
+    pub(crate) shape: Box<dyn ComplexShape>,
+}
+
+// TODO: copy paste is bad?
+impl DynDrawable {
+    pub fn new<T: ComplexShape + 'static>(shape: T, context: ShapeContext) -> Self {
+        Self {
+            context,
+            shape: Box::new(shape),
+        }
+    }
+
+    pub fn new_dyn(shape: Box<dyn ComplexShape>, context: ShapeContext) -> Self {
+        Self { context, shape }
+    }
+
+    pub fn from_shape<T: ComplexShape + 'static>(shape: T, solver: &mut dyn SolverContext) -> Self {
+        Self {
+            context: ShapeContext::builder().build(solver),
+            shape: Box::new(shape),
+        }
+    }
+
+    pub fn from_dyn(shape: Box<dyn ComplexShape>, solver: &mut dyn SolverContext) -> Self {
+        Self {
+            context: ShapeContext::builder().build(solver),
+            shape,
+        }
+    }
+
+    pub fn shape(&self) -> &dyn ComplexShape {
+        &*self.shape
+    }
+
+    pub fn shape_mut(&mut self) -> &mut dyn ComplexShape {
+        &mut *self.shape
+    }
+
+    pub fn bounds(&self) -> &Bounds {
+        &self.context.bounds
+    }
+
+    pub fn bounds_mut(&mut self) -> &mut Bounds {
+        &mut self.context.bounds
+    }
+
+    pub fn fill_style(&mut self) -> &mut FillStyle {
+        &mut self.context.fill
+    }
+
+    pub fn stroke_mut(&mut self) -> &mut StrokeStyle {
+        &mut self.context.stroke
+    }
+}
+
+impl Clone for DynDrawable {
+    fn clone(&self) -> Self {
+        DynDrawable {
+            context: self.context.clone(),
+            shape: self.shape.dyn_clone(),
+        }
+    }
+}
+
+impl<T: ComplexShape + 'static> From<Drawable<T>> for DynDrawable {
+    fn from(drawable: Drawable<T>) -> Self {
+        DynDrawable {
+            context: drawable.context,
+            shape: Box::new(drawable.shape),
+        }
+    }
+}
+
+pub struct DrawResult {
+    pub(crate) subshapes: Vec<DynDrawable>,
+    pub(crate) waiting_on: Vec<()>,
+}
+
+impl DrawResult {
+    pub fn new() -> Self {
+        Self {
+            subshapes: Vec::new(),
+            waiting_on: Vec::new(),
+        }
+    }
+
+    /*
+    pub fn push_shape<T: ComplexShape + 'static>(&mut self, shape: T, context: ShapeContext) {
+        self.subshapes.push(DynDrawable {
+            context,
+            shape: Box::new(shape),
+        })
+    }
+
+    pub fn push_boxed_shape(&mut self, shape: Box<dyn ComplexShape>, context: ShapeContext) {
+        self.subshapes.push(DynDrawable { context, shape })
+    }
+    */
+
+    pub fn push<T: ComplexShape + 'static>(&mut self, drawable: Drawable<T>) {
+        self.subshapes.push(drawable.into())
+    }
+
+    pub fn push_dyn(&mut self, drawable: DynDrawable) {
+        self.subshapes.push(drawable)
+    }
+}
+
+/*
+pub trait Drawable {
+    fn draw<'z3>(&self, bounds: &Bounds<'z3>, z3_ctx: &z3::Context) -> DrawResult;
+}
+
+/*
+impl Drawable for Box<dyn Drawable> {
+    fn draw<'z3>(&self, bounds: &Bounds<'z3>, z3_ctx: &z3::Context) -> DrawResult {
+        (**self).draw(bounds, z3_ctx)
+    }
+}
+*/
+
+impl Drawable for CoreShape {
+    fn draw<'z3>(
+        &self,
+        bounds: &Bounds<'z3>,
+    ) -> (
+        Vec<Bounded<'z3, CoreShape>>,
+        Vec<Bounded<'z3, Box<dyn Drawable>>>,
+    ) {
+        // TODO: clone, really?
+        (
+            vec![Bounded::<CoreShape> {
+                bounds: bounds.clone(),
+                shape: self.clone(),
+            }],
+            vec![],
+        )
+    }
+
+    fn constraints(&self, _bounds: &Bounds, _z3_ctx: &z3::Context) -> Vec<z3::ast::Bool> {
+        vec![]
+    }
+}
+
+/*
+impl<'a, T: Drawable> Drawable for Vec<Bounded<'a, T>> {
+    fn draw<'z3>(
+        &self,
+        _bounds: &Bounds<'z3>,
+  as_render        Vec<Bounded<'z3, CoreShape>>,
+        Vec<Bounded<'z3, Box<dyn Drawable>>>,
+    ) {
+        let mut core_shapes = Vec::new();
+        let mut complex_drawables = Vec::new();
+
+        for drawable in self.iter() {
+            let (mut inner_core_shapes, mut inner_complex_drawables) =
+                drawable.shape.draw(&drawable.bounds);
+
+            core_shapes.append(&mut inner_core_shapes);
+            complex_drawables.append(&mut inner_complex_drawables);
+        }
+
+        (core_shapes, complex_drawables)
+    }
+
+    fn constraints(&self, _bounds: &Bounds, z3_ctx: &z3::Context) -> Vec<z3::ast::Bool> {
+        self.iter()
+            .flat_map(|drawable| drawable.shape.constraints(&drawable.bounds, z3_ctx))
+            .collect()
+    }
+}
+*/
+*/