From 1b3eb42003131c9a5c28ca6efb2c86b43d700016 Mon Sep 17 00:00:00 2001 From: Laurenz Date: Sun, 11 Oct 2020 22:41:21 +0200 Subject: [PATCH] =?UTF-8?q?Refactor=20paragraph=20layout=20=F0=9F=93=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/layout/par.rs | 581 +++++++++++----------------------------------- 1 file changed, 130 insertions(+), 451 deletions(-) diff --git a/src/layout/par.rs b/src/layout/par.rs index 52086cc9d..8c44e0f4e 100644 --- a/src/layout/par.rs +++ b/src/layout/par.rs @@ -1,55 +1,36 @@ use super::*; /// A node that arranges its children into a paragraph. -/// -/// Boxes are laid out along the cross axis as long as they fit into a line. -/// When necessary, a line break is inserted and the new line is offset along -/// the main axis by the height of the previous line plus extra line spacing. #[derive(Debug, Clone, PartialEq)] pub struct Par { + /// The `main` and `cross` directions of this paragraph. + /// + /// The children are placed in lines along the `cross` direction. The lines + /// are stacked along the `main` direction. pub dirs: Gen, - pub line_spacing: Length, - pub children: Vec, + /// How to align _this_ paragraph in _its_ parent. pub aligns: Gen, - pub expand: Spec, + /// Whether to expand the cross axis to fill the area or to fit the content. + pub cross_expansion: Expansion, + /// The spacing to insert after each line. + pub line_spacing: Length, + /// The nodes to be arranged in a paragraph. + pub children: Vec, } #[async_trait(?Send)] impl Layout for Par { - async fn layout( - &self, - ctx: &mut LayoutContext, - constraints: LayoutConstraints, - ) -> Vec { - let mut layouter = LineLayouter::new(LineContext { - dirs: self.dirs, - spaces: constraints.spaces, - repeat: constraints.repeat, - line_spacing: self.line_spacing, - expand: self.expand, - }); - + async fn layout(&self, ctx: &mut LayoutContext, areas: &Areas) -> Vec { + let mut layouter = ParLayouter::new(self, areas.clone()); for child in &self.children { - let items = child - .layout(ctx, LayoutConstraints { - spaces: layouter.remaining(), - repeat: constraints.repeat, - }) - .await; - - for item in items { - match item { - Layouted::Spacing(amount) => layouter.push_spacing(amount), - Layouted::Box(boxed, aligns) => layouter.push_box(boxed, aligns), + for layouted in child.layout(ctx, &layouter.areas).await { + match layouted { + Layouted::Spacing(spacing) => layouter.spacing(spacing), + Layouted::Boxed(boxed, aligns) => layouter.boxed(boxed, aligns.cross), } } } - - layouter - .finish() - .into_iter() - .map(|boxed| Layouted::Box(boxed, self.aligns)) - .collect() + layouter.finish() } } @@ -59,447 +40,145 @@ impl From for LayoutNode { } } -/// Performs the line layouting. -struct LineLayouter { - /// The context used for line layouting. - ctx: LineContext, - /// The underlying layouter that stacks the finished lines. - stack: StackLayouter, - /// The in-progress line. - run: LineRun, -} - -/// The context for line layouting. -#[derive(Debug, Clone)] -struct LineContext { - /// The layout directions. +struct ParLayouter<'a> { + par: &'a Par, + main: SpecAxis, + cross: SpecAxis, dirs: Gen, - /// The spaces to layout into. - spaces: Vec, - /// Whether to spill over into copies of the last space or finish layouting - /// when the last space is used up. - repeat: bool, - /// The spacing to be inserted between each pair of lines. - line_spacing: Length, - /// Whether to expand the size of the resulting layout to the full size of - /// this space or to shrink it to fit the content. - expand: Spec, + areas: Areas, + layouted: Vec, + lines: Vec<(Length, BoxLayout, Align)>, + lines_size: Gen, + run: Vec<(Length, BoxLayout, Align)>, + run_size: Gen, + run_ruler: Align, } -impl LineLayouter { - /// Create a new line layouter. - fn new(ctx: LineContext) -> Self { +impl<'a> ParLayouter<'a> { + fn new(par: &'a Par, areas: Areas) -> Self { Self { - stack: StackLayouter::new(StackContext { - spaces: ctx.spaces.clone(), - dirs: ctx.dirs, - repeat: ctx.repeat, - expand: ctx.expand, - }), - ctx, - run: LineRun::new(), + par, + main: par.dirs.main.axis(), + cross: par.dirs.cross.axis(), + dirs: par.dirs, + areas, + layouted: vec![], + lines: vec![], + lines_size: Gen::ZERO, + run: vec![], + run_size: Gen::ZERO, + run_ruler: Align::Start, } } - /// Add a layout. - fn push_box(&mut self, layout: BoxLayout, aligns: Gen) { - let dirs = self.ctx.dirs; - if let Some(prev) = self.run.aligns { - if aligns.main != prev.main { - // TODO: Issue warning for non-fitting alignment in - // non-repeating context. - let fitting = aligns.main >= self.stack.space.allowed_align; - if !fitting && self.ctx.repeat { - self.finish_space(true); - } else { - self.finish_line(); - } - } else if aligns.cross < prev.cross { - self.finish_line(); - } else if aligns.cross > prev.cross { - let usable = self.stack.usable().get(dirs.cross.axis()); + fn spacing(&mut self, amount: Length) { + let cross_full = self.areas.current.rem.get(self.cross); + self.run_size.cross = (self.run_size.cross + amount).min(cross_full); + } - let mut rest_run = LineRun::new(); - rest_run.size.main = self.run.size.main; - - // FIXME: Alignment in non-expanding parent. - rest_run.usable = Some(match aligns.cross { - Align::Start => unreachable!("start > x"), - Align::Center => usable - 2.0 * self.run.size.cross, - Align::End => usable - self.run.size.cross, - }); - - self.finish_line(); - - // Move back up in the stack layouter. - self.stack.push_spacing(-rest_run.size.main - self.ctx.line_spacing); - self.run = rest_run; - } + fn boxed(&mut self, layout: BoxLayout, align: Align) { + if self.run_ruler > align { + self.finish_run(); } - let size = layout.size.switch(dirs); - let usable = self.usable(); - - if usable.main < size.main || usable.cross < size.cross { - if !self.line_is_empty() { - self.finish_line(); - } - - // TODO: Issue warning about overflow if there is overflow. - let usable = self.usable(); - if usable.main < size.main || usable.cross < size.cross { - self.stack.skip_to_fitting_space(layout.size); - } - } - - self.run.aligns = Some(aligns); - self.run.layouts.push((self.run.size.cross, layout)); - - self.run.size.cross += size.cross; - self.run.size.main = self.run.size.main.max(size.main); - } - - /// Add spacing to the line. - fn push_spacing(&mut self, mut spacing: Length) { - spacing = spacing.min(self.usable().cross); - self.run.size.cross += spacing; - } - - /// The remaining usable size of the line. - /// - /// This specifies how much more would fit before a line break would be - /// needed. - fn usable(&self) -> Gen { - // The base is the usable space of the stack layouter. - let mut usable = self.stack.usable().switch(self.ctx.dirs); - - // If there was another run already, override the stack's size. - if let Some(cross) = self.run.usable { - usable.cross = cross; - } - - usable.cross -= self.run.size.cross; - usable - } - - /// The remaining inner spaces. If something is laid out into these spaces, - /// it will fit into this layouter's underlying stack. - fn remaining(&self) -> Vec { - let mut spaces = self.stack.remaining(); - *spaces[0].size.get_mut(self.ctx.dirs.main.axis()) -= self.run.size.main; - spaces - } - - /// Whether the currently set line is empty. - fn line_is_empty(&self) -> bool { - self.run.size == Gen::ZERO && self.run.layouts.is_empty() - } - - /// Finish everything up and return the final collection of boxes. - fn finish(mut self) -> Vec { - self.finish_line_if_not_empty(); - self.stack.finish() - } - - /// Finish the active space and start a new one. - /// - /// At the top level, this is a page break. - fn finish_space(&mut self, hard: bool) { - self.finish_line_if_not_empty(); - self.stack.finish_space(hard) - } - - /// Finish the active line and start a new one. - fn finish_line(&mut self) { - let dirs = self.ctx.dirs; - - let mut layout = BoxLayout::new(self.run.size.switch(dirs).to_size()); - let aligns = self.run.aligns.unwrap_or_default(); - - let children = std::mem::take(&mut self.run.layouts); - for (offset, child) in children { - let cross = if dirs.cross.is_positive() { - offset - } else { - self.run.size.cross - offset - child.size.get(dirs.cross.axis()) - }; - - let pos = Gen::new(Length::ZERO, cross).switch(dirs).to_point(); - layout.push_layout(pos, child); - } - - self.stack.push_box(layout, aligns); - self.stack.push_spacing(self.ctx.line_spacing); - self.run = LineRun::new(); - } - - fn finish_line_if_not_empty(&mut self) { - if !self.line_is_empty() { - self.finish_line() - } - } -} - -/// A sequence of boxes with the same alignment. A real line can consist of -/// multiple runs with different alignments. -struct LineRun { - /// The so-far accumulated items of the run. - layouts: Vec<(Length, BoxLayout)>, - /// The summed width and maximal height of the run. - size: Gen, - /// The alignment of all layouts in the line. - /// - /// When a new run is created the alignment is yet to be determined and - /// `None` as such. Once a layout is added, its alignment decides the - /// alignment for the whole run. - aligns: Option>, - /// The amount of cross-space left by another run on the same line or `None` - /// if this is the only run so far. - usable: Option, -} - -impl LineRun { - fn new() -> Self { - Self { - layouts: vec![], - size: Gen::ZERO, - aligns: None, - usable: None, - } - } -} - -/// Performs the stack layouting. -pub(super) struct StackLayouter { - /// The context used for stack layouting. - pub ctx: StackContext, - /// The finished layouts. - pub layouts: Vec, - /// The in-progress space. - pub space: Space, -} - -/// The context for stack layouting. -#[derive(Debug, Clone)] -pub(super) struct StackContext { - /// The layouting directions. - pub dirs: Gen, - /// The spaces to layout into. - pub spaces: Vec, - /// Whether to spill over into copies of the last space or finish layouting - /// when the last space is used up. - pub repeat: bool, - /// Whether to expand the size of the resulting layout to the full size of - /// this space or to shrink it to fit the content. - pub expand: Spec, -} - -impl StackLayouter { - /// Create a new stack layouter. - pub fn new(ctx: StackContext) -> Self { - let space = ctx.spaces[0]; - Self { - ctx, - layouts: vec![], - space: Space::new(0, true, space.size), - } - } - - /// Add a layout to the stack. - pub fn push_box(&mut self, layout: BoxLayout, aligns: Gen) { - // If the alignment cannot be fitted in this space, finish it. - // - // TODO: Issue warning for non-fitting alignment in non-repeating - // context. - if aligns.main < self.space.allowed_align && self.ctx.repeat { - self.finish_space(true); - } - - // TODO: Issue warning about overflow if there is overflow in a - // non-repeating context. - if !self.space.usable.fits(layout.size) && self.ctx.repeat { - self.skip_to_fitting_space(layout.size); - } - - // Change the usable space and size of the space. - self.update_metrics(layout.size.switch(self.ctx.dirs)); - - // Add the box to the vector and remember that spacings are allowed - // again. - self.space.layouts.push((layout, aligns)); - self.space.allowed_align = aligns.main; - } - - /// Add spacing to the stack. - pub fn push_spacing(&mut self, mut spacing: Length) { - // Reduce the spacing such that it definitely fits. - let axis = self.ctx.dirs.main.axis(); - spacing = spacing.min(self.space.usable.get(axis)); - - let size = Gen::new(spacing, Length::ZERO); - self.update_metrics(size); - self.space.layouts.push(( - BoxLayout::new(size.switch(self.ctx.dirs).to_size()), - Gen::default(), - )); - } - - fn update_metrics(&mut self, added: Gen) { - let mut used = self.space.used.switch(self.ctx.dirs); - used.cross = used.cross.max(added.cross); - used.main += added.main; - self.space.used = used.switch(self.ctx.dirs).to_size(); - *self.space.usable.get_mut(self.ctx.dirs.main.axis()) -= added.main; - } - - /// Move to the first space that can fit the given size or do nothing - /// if no space is capable of that. - pub fn skip_to_fitting_space(&mut self, size: Size) { - let start = self.next_space(); - for (index, space) in self.ctx.spaces[start ..].iter().enumerate() { - if space.size.fits(size) { - self.finish_space(true); - self.start_space(start + index, true); - break; - } - } - } - - /// The remaining inner spaces. If something is laid out into these spaces, - /// it will fit into this stack. - pub fn remaining(&self) -> Vec { - let mut spaces = vec![LayoutSpace { - base: self.space.size, - size: self.space.usable, - }]; - - spaces.extend(&self.ctx.spaces[self.next_space() ..]); - spaces - } - - /// The remaining usable size. - pub fn usable(&self) -> Size { - self.space.usable - } - - /// Whether the current layout space is empty. - pub fn space_is_empty(&self) -> bool { - self.space.used == Size::ZERO && self.space.layouts.is_empty() - } - - /// Finish everything up and return the final collection of boxes. - pub fn finish(mut self) -> Vec { - if self.space.hard || !self.space_is_empty() { - self.finish_space(false); - } - self.layouts - } - - /// Finish active current space and start a new one. - pub fn finish_space(&mut self, hard: bool) { - let dirs = self.ctx.dirs; - let main = dirs.main.axis(); - - let space = self.ctx.spaces[self.space.index]; - let layout_size = { - let mut used_size = self.space.used; - if self.ctx.expand.horizontal { - used_size.width = space.size.width; - } - if self.ctx.expand.vertical { - used_size.height = space.size.height; - } - used_size + let fits = { + let mut usable = self.areas.current.rem; + *usable.get_mut(self.cross) -= self.run_size.cross; + usable.fits(layout.size) }; - let mut sum = Length::ZERO; - let mut sums = Vec::with_capacity(self.space.layouts.len() + 1); + if !fits { + self.finish_run(); - for (boxed, _) in &self.space.layouts { - sums.push(sum); - sum += boxed.size.get(main); + while !self.areas.current.rem.fits(layout.size) { + if self.areas.in_full_last() { + // TODO: Diagnose once the necessary spans exist. + let _ = warning!("cannot fit box into any area"); + break; + } else { + self.finish_area(); + } + } } - sums.push(sum); + let size = layout.size.switch(self.dirs); + self.run.push((self.run_size.cross, layout, align)); - let mut layout = BoxLayout::new(layout_size); - let used = layout_size.switch(dirs); + self.run_size.cross += size.cross; + self.run_size.main = self.run_size.main.max(size.main); + self.run_ruler = align; + } - let children = std::mem::take(&mut self.space.layouts); - for (i, (boxed, aligns)) in children.into_iter().enumerate() { - let size = boxed.size.switch(dirs); + fn finish_run(&mut self) { + let size = Gen::new(self.run_size.main, match self.par.cross_expansion { + Expansion::Fill => self.areas.current.full.get(self.cross), + Expansion::Fit => self.run_size.cross, + }); - let before = sums[i]; - let after = sum - sums[i + 1]; - let main_len = used.main - size.main; - let main_range = if dirs.main.is_positive() { - before .. main_len - after + let mut output = BoxLayout::new(size.switch(self.dirs).to_size()); + + for (before, layout, align) in std::mem::take(&mut self.run) { + let child_cross_size = layout.size.get(self.cross); + + // Position along the cross axis. + let cross = align.apply(if self.dirs.cross.is_positive() { + let after_with_self = self.run_size.cross - before; + before .. size.cross - after_with_self } else { - main_len - before .. after + let before_with_self = before + child_cross_size; + let after = self.run_size.cross - (before + child_cross_size); + size.cross - before_with_self .. after + }); + + let pos = Gen::new(Length::ZERO, cross).switch(self.dirs).to_point(); + output.push_layout(pos, layout); + } + + self.lines.push((self.lines_size.main, output, self.run_ruler)); + + let main_offset = size.main + self.par.line_spacing; + *self.areas.current.rem.get_mut(self.main) -= main_offset; + self.lines_size.main += main_offset; + self.lines_size.cross = self.lines_size.cross.max(size.cross); + + self.run_size = Gen::ZERO; + self.run_ruler = Align::Start; + } + + fn finish_area(&mut self) { + let size = self.lines_size; + let mut output = BoxLayout::new(size.switch(self.dirs).to_size()); + + for (before, run, cross_align) in std::mem::take(&mut self.lines) { + let child_size = run.size.switch(self.dirs); + + // Position along the main axis. + let main = if self.dirs.main.is_positive() { + before + } else { + size.main - (before + child_size.main) }; - let cross_len = used.cross - size.cross; - let cross_range = if dirs.cross.is_positive() { - Length::ZERO .. cross_len + // Align along the cross axis. + let cross = cross_align.apply(if self.dirs.cross.is_positive() { + Length::ZERO .. size.cross - child_size.cross } else { - cross_len .. Length::ZERO - }; + size.cross - child_size.cross .. Length::ZERO + }); - let main = aligns.main.apply(main_range); - let cross = aligns.cross.apply(cross_range); - let pos = Gen::new(main, cross).switch(dirs).to_point(); - - layout.push_layout(pos, boxed); + let pos = Gen::new(main, cross).switch(self.dirs).to_point(); + output.push_layout(pos, run); } - self.layouts.push(layout); + self.layouted.push(Layouted::Boxed(output, self.par.aligns)); - // ------------------------------------------------------------------ // - // Step 5: Start the next space. - - self.start_space(self.next_space(), hard) + self.areas.next(); + self.lines_size = Gen::ZERO; } - fn start_space(&mut self, index: usize, hard: bool) { - let space = self.ctx.spaces[index]; - self.space = Space::new(index, hard, space.size); - } - - fn next_space(&self) -> usize { - (self.space.index + 1).min(self.ctx.spaces.len() - 1) - } -} - -/// A layout space composed of subspaces which can have different directions and -/// alignments. -#[derive(Debug)] -pub(super) struct Space { - /// The index of this space in `ctx.spaces`. - index: usize, - /// Whether to include a layout for this space even if it would be empty. - hard: bool, - /// The so-far accumulated layouts. - layouts: Vec<(BoxLayout, Gen)>, - /// The full size of this space. - size: Size, - /// The used size of this space. - used: Size, - /// The remaining space. - usable: Size, - /// Which alignments for new boxes are still allowed. - pub(super) allowed_align: Align, -} - -impl Space { - fn new(index: usize, hard: bool, size: Size) -> Self { - Self { - index, - hard, - layouts: vec![], - size, - used: Size::ZERO, - usable: size, - allowed_align: Align::Start, - } + fn finish(mut self) -> Vec { + self.finish_run(); + self.finish_area(); + self.layouted } }