Simple line layouter 🧾

1 files changed, 0 insertions, 198 deletions

diff --git a/src/layout/flex.rs b/src/layout/flex.rs
deleted file mode 100644
index 72878a29..00000000
--- a/src/layout/flex.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use super::*;
-
-/// The flex layouter first arranges boxes along a primary and if necessary also
-/// along a secondary axis.
-#[derive(Debug, Clone)]
-pub struct FlexLayouter {
-    axes: LayoutAxes,
-    flex_spacing: Size,
-    stack: StackLayouter,
-
-    units: Vec<FlexUnit>,
-    line: FlexLine,
-    part: PartialLine,
-}
-
-#[derive(Debug, Clone)]
-enum FlexUnit {
-    Boxed(Layout),
-    Space(Size, SpacingKind),
-    SetAxes(LayoutAxes),
-    Break,
-}
-
-#[derive(Debug, Clone)]
-struct FlexLine {
-    usable: Size,
-    actions: LayoutActions,
-    combined_dimensions: Size2D,
-}
-
-impl FlexLine {
-    fn new(usable: Size) -> FlexLine {
-        FlexLine {
-            usable,
-            actions: LayoutActions::new(),
-            combined_dimensions: Size2D::ZERO,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct PartialLine {
-    usable: Size,
-    content: Vec<(Size, Layout)>,
-    dimensions: Size2D,
-    space: LastSpacing,
-}
-
-impl PartialLine {
-    fn new(usable: Size) -> PartialLine {
-        PartialLine {
-            usable,
-            content: vec![],
-            dimensions: Size2D::ZERO,
-            space: LastSpacing::Hard,
-        }
-    }
-}
-
-/// The context for flex layouting.
-///
-/// See [`LayoutContext`] for details about the fields.
-#[derive(Debug, Clone)]
-pub struct FlexContext {
-    pub spaces: LayoutSpaces,
-    pub axes: LayoutAxes,
-    pub alignment: LayoutAlignment,
-    pub flex_spacing: Size,
-    pub repeat: bool,
-    pub debug: bool,
-}
-
-impl FlexLayouter {
-    /// Create a new flex layouter.
-    pub fn new(ctx: FlexContext) -> FlexLayouter {
-        let stack = StackLayouter::new(StackContext {
-            spaces: ctx.spaces,
-            axes: ctx.axes,
-            alignment: ctx.alignment,
-            repeat: ctx.repeat,
-            debug: ctx.debug,
-        });
-
-        let usable = stack.primary_usable();
-
-        FlexLayouter {
-            axes: ctx.axes,
-            flex_spacing: ctx.flex_spacing,
-            stack,
-
-            units: vec![],
-            line: FlexLine::new(usable),
-            part: PartialLine::new(usable),
-        }
-    }
-
-    pub fn add(&mut self, layout: Layout) {
-        self.units.push(FlexUnit::Boxed(layout));
-    }
-
-    pub fn add_multiple(&mut self, layouts: MultiLayout) {
-        for layout in layouts {
-            self.add(layout);
-        }
-    }
-
-    pub fn add_break(&mut self) {
-        self.units.push(FlexUnit::Break);
-    }
-
-    pub fn add_primary_space(&mut self, space: Size, kind: SpacingKind) {
-        self.units.push(FlexUnit::Space(space, kind))
-    }
-
-    pub fn add_secondary_space(&mut self, space: Size, kind: SpacingKind) -> LayoutResult<()> {
-        if !self.run_is_empty() {
-            self.finish_run()?;
-        }
-        Ok(self.stack.add_spacing(space, kind))
-    }
-
-    pub fn set_axes(&mut self, axes: LayoutAxes) {
-        self.units.push(FlexUnit::SetAxes(axes));
-    }
-
-    pub fn set_spaces(&mut self, spaces: LayoutSpaces, replace_empty: bool) {
-        if replace_empty && self.run_is_empty() && self.stack.space_is_empty() {
-            self.stack.set_spaces(spaces, true);
-            self.start_line();
-        } else {
-            self.stack.set_spaces(spaces, false);
-        }
-    }
-
-    pub fn remaining(&self) -> LayoutSpaces {
-        self.stack.remaining()
-    }
-
-    pub fn run_is_empty(&self) -> bool {
-        !self.units.iter().any(|unit| matches!(unit, FlexUnit::Boxed(_)))
-    }
-
-    pub fn run_last_is_space(&self) -> bool {
-        matches!(self.units.last(), Some(FlexUnit::Space(_, _)))
-    }
-
-    pub fn finish(mut self) -> LayoutResult<MultiLayout> {
-        self.finish_space(false)?;
-        self.stack.finish()
-    }
-
-    pub fn finish_space(&mut self, hard: bool) -> LayoutResult<()> {
-        if !self.run_is_empty() {
-            self.finish_run()?;
-        }
-
-        self.stack.finish_space(hard)?;
-        Ok(self.start_line())
-    }
-
-    pub fn finish_run(&mut self) -> LayoutResult<Size2D> {
-        let units = std::mem::replace(&mut self.units, vec![]);
-        for unit in units {
-            match unit {
-                FlexUnit::Boxed(boxed) => self.layout_box(boxed)?,
-                FlexUnit::Space(space, kind) => self.layout_space(space, kind),
-                FlexUnit::SetAxes(axes) => self.layout_set_axes(axes),
-                FlexUnit::Break => { self.finish_line()?; },
-            }
-        }
-
-        self.finish_line()
-    }
-
-    fn finish_line(&mut self) -> LayoutResult<Size2D> {
-        unimplemented!()
-    }
-
-    fn start_line(&mut self) {
-        unimplemented!()
-    }
-
-    fn finish_partial_line(&mut self) {
-        unimplemented!()
-    }
-
-    fn layout_box(&mut self, _boxed: Layout) -> LayoutResult<()> {
-        unimplemented!()
-    }
-
-    fn layout_space(&mut self, _space: Size, _kind: SpacingKind) {
-        unimplemented!()
-    }
-
-    fn layout_set_axes(&mut self, _axes: LayoutAxes) {
-        unimplemented!()
-    }
-}