WIP

1 files changed, 72 insertions, 0 deletions

diff --git a/examples/lib-dfscq-log/src/blocks.rs b/examples/lib-dfscq-log/src/blocks.rs
new file mode 100644
index 0000000..0576b7d
--- /dev/null
+++ b/examples/lib-dfscq-log/src/blocks.rs
@@ -0,0 +1,72 @@
+use diaphragm_core::{
+    core_shapes::Rectangle,
+    types::{Float, ShapeContext},
+    ComplexShape, DrawResult, Drawable, SolverContext,
+};
+
+#[derive(Debug, Clone)]
+pub struct Block {
+    pub grow: u8,
+}
+
+impl ComplexShape for Block {
+    fn draw(&self, context: &ShapeContext, _solver: &mut dyn SolverContext) -> DrawResult {
+        let mut result = DrawResult::new();
+
+        // Grow is handled at the upper level
+        let block = Drawable::new(Rectangle {}, context.clone());
+
+        result.push(block);
+
+        result
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Blocks {
+    pub blocks: Vec<Drawable<Block>>,
+    pub unit_width: Float,
+}
+
+impl ComplexShape for Blocks {
+    fn draw(&self, context: &ShapeContext, solver: &mut dyn SolverContext) -> DrawResult {
+        let mut result = DrawResult::new();
+
+        let sum: u8 = self.blocks.iter().map(|block| block.shape().grow).sum();
+
+        let mut rect_left = context.bounds().left(solver);
+        let rect_top = context.bounds().top(solver);
+        let rect_height = context.bounds().height(solver);
+
+        for block in &self.blocks {
+            let block_top = block.bounds().top(solver);
+            let rect_top_constraint = solver.float_eq(block_top, rect_top);
+            solver.constrain(rect_top_constraint);
+
+            let block_left = block.bounds().left(solver);
+            let rect_left_constraint = solver.float_eq(block_left, rect_left);
+            solver.constrain(rect_left_constraint);
+
+            let grow = Float::Fixed(block.shape().grow as f64);
+            let block_width = block.bounds().width(solver);
+            let rect_width = solver.float_mul(&[self.unit_width, grow]);
+            let rect_width_constraint = solver.float_eq(block_width, rect_width);
+            solver.constrain(rect_width_constraint);
+
+            let block_height = block.bounds().height(solver);
+            let rect_height_constraint = solver.float_eq(block_height, rect_height);
+            solver.constrain(rect_height_constraint);
+
+            result.push(block.clone());
+
+            rect_left = solver.float_add(&[rect_left, rect_width]);
+        }
+
+        let this_width = solver.float_mul(&[self.unit_width, Float::Fixed(sum as f64)]);
+        let bounds_width = context.bounds().width(solver);
+        let bounds_width_constraint = solver.float_eq(bounds_width, this_width);
+        solver.constrain(bounds_width_constraint);
+
+        result
+    }
+}