WIP

1 files changed, 133 insertions, 0 deletions

diff --git a/examples/lib-dfscq-log/src/spacer.rs b/examples/lib-dfscq-log/src/spacer.rs
new file mode 100644
index 0000000..6878183
--- /dev/null
+++ b/examples/lib-dfscq-log/src/spacer.rs
@@ -0,0 +1,133 @@
+use diaphragm_core::{
+    types::{Float, ShapeContext},
+    ComplexShape, DrawResult, DynDrawable, SolverContext,
+};
+
+#[derive(Clone)]
+pub struct Spacer {
+    pub margin_left: Float,
+    pub margin_right: Float,
+    pub margin_top: Float,
+    pub margin_bottom: Float,
+    pub content: DynDrawable,
+}
+
+impl Spacer {
+    pub fn builder<T: Into<DynDrawable>>(drawable: T) -> SpacerBuilder {
+        SpacerBuilder::new(drawable)
+    }
+}
+
+impl ComplexShape for Spacer {
+    fn draw(&self, context: &ShapeContext, solver: &mut dyn SolverContext) -> DrawResult {
+        let mut result = DrawResult::new();
+
+        let bounds_left = context.bounds().left(solver);
+        let bounds_right = context.bounds().right(solver);
+        let bounds_top = context.bounds().top(solver);
+        let bounds_bottom = context.bounds().bottom(solver);
+
+        let wanted_content_left = solver.float_add(&[bounds_left, self.margin_left]);
+        let content_left = self.content.bounds().left(solver);
+        let content_left_constraint = solver.float_eq(content_left, wanted_content_left);
+        solver.constrain(content_left_constraint);
+
+        let wanted_content_right = solver.float_sub(&[bounds_right, self.margin_right]);
+        let content_right = self.content.bounds().right(solver);
+        let content_right_constraint = solver.float_eq(content_right, wanted_content_right);
+        solver.constrain(content_right_constraint);
+
+        let wanted_content_top = solver.float_add(&[bounds_top, self.margin_top]);
+        let content_top = self.content.bounds().top(solver);
+        let content_top_constraint = solver.float_eq(content_top, wanted_content_top);
+        solver.constrain(content_top_constraint);
+
+        let wanted_content_bottom = solver.float_sub(&[bounds_bottom, self.margin_bottom]);
+        let content_bottom = self.content.bounds().bottom(solver);
+        let content_bottom_constraint = solver.float_eq(content_bottom, wanted_content_bottom);
+        solver.constrain(content_bottom_constraint);
+
+        result.push_dyn(self.content.clone());
+
+        result
+    }
+}
+
+#[derive(Clone)]
+pub struct SpacerBuilder {
+    pub margin_left: Option<Float>,
+    pub margin_right: Option<Float>,
+    pub margin_top: Option<Float>,
+    pub margin_bottom: Option<Float>,
+    pub content: DynDrawable,
+}
+
+impl SpacerBuilder {
+    pub fn new<T: Into<DynDrawable>>(drawable: T) -> Self {
+        SpacerBuilder {
+            margin_left: None,
+            margin_right: None,
+            margin_top: None,
+            margin_bottom: None,
+            content: drawable.into(),
+        }
+    }
+
+    pub fn margin_left(&mut self, margin_left: Float) -> &mut Self {
+        self.margin_left = Some(margin_left);
+        self
+    }
+
+    pub fn margin_right(&mut self, margin_right: Float) -> &mut Self {
+        self.margin_right = Some(margin_right);
+        self
+    }
+
+    pub fn margin_top(&mut self, margin_top: Float) -> &mut Self {
+        self.margin_top = Some(margin_top);
+        self
+    }
+
+    pub fn margin_bottom(&mut self, margin_bottom: Float) -> &mut Self {
+        self.margin_bottom = Some(margin_bottom);
+        self
+    }
+
+    pub fn vertical_align_center(&mut self, solver: &mut dyn SolverContext) -> &mut Self {
+        let vertical_margin = solver.new_free_float();
+        self.margin_top = Some(vertical_margin);
+        self.margin_bottom = Some(vertical_margin);
+        self
+    }
+
+    pub fn vertical_align_center_with(&mut self, margin: Float) -> &mut Self {
+        self.margin_top = Some(margin);
+        self.margin_bottom = Some(margin);
+        self
+    }
+
+    pub fn horizontal_align_center(&mut self, solver: &mut dyn SolverContext) -> &mut Self {
+        let horizontal_margin = solver.new_free_float();
+        self.margin_left = Some(horizontal_margin);
+        self.margin_right = Some(horizontal_margin);
+        self
+    }
+
+    pub fn horizontal_align_center_with(&mut self, margin: Float) -> &mut Self {
+        self.margin_left = Some(margin);
+        self.margin_right = Some(margin);
+        self
+    }
+
+    pub fn build(&self, solver: &mut dyn SolverContext) -> Spacer {
+        Spacer {
+            margin_left: self.margin_left.unwrap_or_else(|| solver.new_free_float()),
+            margin_right: self.margin_right.unwrap_or_else(|| solver.new_free_float()),
+            margin_top: self.margin_top.unwrap_or_else(|| solver.new_free_float()),
+            margin_bottom: self
+                .margin_bottom
+                .unwrap_or_else(|| solver.new_free_float()),
+            content: self.content.clone(),
+        }
+    }
+}