Refactor and comment ♻

src/exec/state.rs

@@ -97,6 +97,7 @@ pub struct ParState {
     /// The spacing between lines (dependent on scaled font size).
     pub leading: Linear,
     /// The spacing between words (dependent on scaled font size).
+    // TODO: Don't ignore this.
     pub word_spacing: Linear,
 }
 

src/layout/par.rs

@@ -6,7 +6,7 @@ use xi_unicode::LineBreakIterator;
 
 use super::*;
 use crate::exec::FontProps;
-use crate::util::RangeExt;
+use crate::util::{RangeExt, SliceExt};
 
 type Range = std::ops::Range<usize>;
 
@@ -35,14 +35,14 @@ pub enum ParChild {
 impl Layout for ParNode {
     fn layout(&self, ctx: &mut LayoutContext, areas: &Areas) -> Vec<Frame> {
         // Collect all text into one string used for BiDi analysis.
-        let (text, ranges) = self.collect_text();
+        let text = self.collect_text();
 
         // Find out the BiDi embedding levels.
         let bidi = BidiInfo::new(&text, Level::from_dir(self.dir));
 
         // Build a representation of the paragraph on which we can do
         // linebreaking without layouting each and every line from scratch.
-        let layout = ParLayout::new(ctx, areas, self, bidi, ranges);
+        let layout = ParLayout::new(ctx, areas, self, bidi);
 
         // Find suitable linebreaks.
         layout.build(ctx, areas.clone(), self)
@@ -54,21 +54,49 @@ impl ParNode {
     /// with a space character and other non-text nodes with the object
     /// replacement character. Returns the full text alongside the range each
     /// child spans in the text.
-    fn collect_text(&self) -> (String, Vec<Range>) {
+    fn collect_text(&self) -> String {
         let mut text = String::new();
-        let mut ranges = vec![];
+        for string in self.strings() {
-
+            text.push_str(string);
-        for child in &self.children {
-            let start = text.len();
-            match *child {
-                ParChild::Spacing(_) => text.push(' '),
-                ParChild::Text(ref piece, _, _) => text.push_str(piece),
-                ParChild::Any(_, _) => text.push('\u{FFFC}'),
         }
-            ranges.push(start .. text.len());
+        text
     }
 
-        (text, ranges)
+    /// The range of each item in the collected text.
+    fn ranges(&self) -> impl Iterator<Item = Range> + '_ {
+        let mut cursor = 0;
+        self.strings().map(move |string| {
+            let start = cursor;
+            cursor += string.len();
+            start .. cursor
+        })
+    }
+
+    /// The string representation of each child.
+    fn strings(&self) -> impl Iterator<Item = &str> {
+        self.children.iter().map(|child| match child {
+            ParChild::Spacing(_) => " ",
+            ParChild::Text(ref piece, _, _) => piece,
+            ParChild::Any(_, _) => "\u{FFFC}",
+        })
+    }
+}
+
+impl From<ParNode> for AnyNode {
+    fn from(par: ParNode) -> Self {
+        Self::new(par)
+    }
+}
+
+impl Debug for ParChild {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Spacing(amount) => write!(f, "Spacing({:?})", amount),
+            Self::Text(text, _, align) => write!(f, "Text({:?}, {:?})", text, align),
+            Self::Any(any, align) => {
+                f.debug_tuple("Any").field(any).field(align).finish()
+            }
+        }
     }
 }
 
@@ -85,16 +113,6 @@ struct ParLayout<'a> {
     ranges: Vec<Range>,
 }
 
-/// A prepared item in a paragraph layout.
-enum ParItem<'a> {
-    /// Spacing between other items.
-    Spacing(Length),
-    /// A shaped text run with consistent direction.
-    Text(ShapedText<'a>, Align),
-    /// A layouted child node.
-    Frame(Frame, Align),
-}
-
 impl<'a> ParLayout<'a> {
     /// Build a paragraph layout for the given node.
     fn new(
@@ -102,28 +120,26 @@ impl<'a> ParLayout<'a> {
         areas: &Areas,
         par: &'a ParNode,
         bidi: BidiInfo<'a>,
-        ranges: Vec<Range>,
     ) -> Self {
         // Prepare an iterator over each child an the range it spans.
-        let iter = ranges.into_iter().zip(&par.children);
-
         let mut items = vec![];
         let mut ranges = vec![];
 
         // Layout the children and collect them into items.
-        for (range, child) in iter {
+        for (range, child) in par.ranges().zip(&par.children) {
             match *child {
                 ParChild::Spacing(amount) => {
                     items.push(ParItem::Spacing(amount));
                     ranges.push(range);
                 }
                 ParChild::Text(_, ref props, align) => {
-                    split_runs(&bidi, range, |sub, dir| {
+                    // TODO: Also split by language and script.
-                        let text = &bidi.text[sub.clone()];
+                    for (subrange, dir) in split_runs(&bidi, range) {
-                        let shaped = shape(text, dir, &mut ctx.env.fonts, props);
+                        let text = &bidi.text[subrange.clone()];
+                        let shaped = shape(ctx, text, dir, props);
                         items.push(ParItem::Text(shaped, align));
-                        ranges.push(sub);
+                        ranges.push(subrange);
-                    });
+                    }
                 }
                 ParChild::Any(ref node, align) => {
                     let frames = node.layout(ctx, areas);
@@ -141,23 +157,33 @@ impl<'a> ParLayout<'a> {
 
     /// Find first-fit line breaks and build the paragraph.
     fn build(self, ctx: &mut LayoutContext, areas: Areas, par: &ParNode) -> Vec<Frame> {
-        let mut start = 0;
-        let mut last = None;
         let mut stack = LineStack::new(par.line_spacing, areas);
 
+        // The current line attempt.
+        // Invariant: Always fits into `stack.areas.current`.
+        let mut last = None;
+
+        // The start of the line in `last`.
+        let mut start = 0;
+
         // Find suitable line breaks.
         // TODO: Provide line break opportunities on alignment changes.
         for (end, mandatory) in LineBreakIterator::new(self.bidi.text) {
-            let mut line = LineLayout::new(&self, start .. end, ctx);
+            // Compute the line and its size.
+            let mut line = LineLayout::new(ctx, &self, start .. end);
 
+            // If the line doesn't fit anymore, we push the last fitting attempt
+            // into the stack and rebuild the line from its end. The resulting
+            // line cannot be broken up further.
             if !stack.areas.current.fits(line.size) {
                 if let Some((last_line, last_end)) = last.take() {
                     stack.push(last_line);
                     start = last_end;
-                    line = LineLayout::new(&self, start .. end, ctx);
+                    line = LineLayout::new(ctx, &self, start .. end);
                 }
             }
 
+            // If the line does not fit vertically, we start a new area.
             if !stack.areas.current.height.fits(line.size.height)
                 && !stack.areas.in_full_last()
             {
@@ -165,14 +191,21 @@ impl<'a> ParLayout<'a> {
             }
 
             if mandatory || !stack.areas.current.width.fits(line.size.width) {
+                // If the line does not fit horizontally or we have a mandatory
+                // line break (i.e. due to "\n"), we push the line into the
+                // stack.
                 stack.push(line);
                 start = end;
                 last = None;
 
+                // If there is a trailing line break at the end of the
+                // paragraph, we want to force an empty line.
                 if mandatory && end == self.bidi.text.len() {
-                    stack.push(LineLayout::new(&self, end .. end, ctx));
+                    stack.push(LineLayout::new(ctx, &self, end .. end));
                 }
             } else {
+                // Otherwise, the line fits both horizontally and vertically
+                // and we remember it.
                 last = Some((line, end));
             }
         }
@@ -185,229 +218,57 @@ impl<'a> ParLayout<'a> {
     }
 
     /// Find the index of the item whose range contains the `text_offset`.
-    #[track_caller]
+    fn find(&self, text_offset: usize) -> Option<usize> {
-    fn find(&self, text_offset: usize) -> usize {
+        self.ranges.binary_search_by(|r| r.locate(text_offset)).ok()
-        find_range(&self.ranges, text_offset).unwrap()
-    }
-}
-
-impl ParItem<'_> {
-    /// The size and baseline of the item.
-    pub fn measure(&self) -> (Size, Length) {
-        match self {
-            Self::Spacing(amount) => (Size::new(*amount, Length::ZERO), Length::ZERO),
-            Self::Text(shaped, _) => (shaped.size, shaped.baseline),
-            Self::Frame(frame, _) => (frame.size, frame.baseline),
-        }
     }
 }
 
 /// Split a range of text into runs of consistent direction.
-fn split_runs(bidi: &BidiInfo, range: Range, mut f: impl FnMut(Range, Dir)) {
+fn split_runs<'a>(
-    let levels = &bidi.levels[range.clone()];
+    bidi: &'a BidiInfo,
-
+    range: Range,
-    let mut start = range.start;
+) -> impl Iterator<Item = (Range, Dir)> + 'a {
-    let mut last = match levels.first() {
+    let mut cursor = range.start;
-        Some(&level) => level,
+    bidi.levels[range.clone()]
-        None => return,
+        .group_by_key(|&level| level)
-    };
+        .map(move |(level, group)| {
-
+            let start = cursor;
-    // Split into runs with the same embedding level.
+            cursor += group.len();
-    for (idx, &level) in levels.iter().enumerate() {
+            (start .. cursor, level.dir())
-        let end = range.start + idx;
+        })
-        if last != level {
-            f(start .. end, last.dir());
-            start = end;
-        }
-        last = level;
 }
 
-    f(start .. range.end, last.dir());
+/// A prepared item in a paragraph layout.
+enum ParItem<'a> {
+    /// Spacing between other items.
+    Spacing(Length),
+    /// A shaped text run with consistent direction.
+    Text(ShapedText<'a>, Align),
+    /// A layouted child node.
+    Frame(Frame, Align),
 }
 
-/// A lightweight representation of a line that spans a specific range in a
+impl ParItem<'_> {
-/// paragraph's text. This type enables you to cheaply measure the size of a
+    /// The size of the item.
-/// line in a range before comitting to building the line's frame.
+    pub fn size(&self) -> Size {
-struct LineLayout<'a> {
+        match self {
-    par: &'a ParLayout<'a>,
+            Self::Spacing(amount) => Size::new(*amount, Length::ZERO),
-    line: Range,
+            Self::Text(shaped, _) => shaped.size,
-    first: Option<ParItem<'a>>,
+            Self::Frame(frame, _) => frame.size,
-    items: &'a [ParItem<'a>],
-    last: Option<ParItem<'a>>,
-    ranges: &'a [Range],
-    size: Size,
-    baseline: Length,
-}
-
-impl<'a> LineLayout<'a> {
-    /// Create a line which spans the given range.
-    fn new(par: &'a ParLayout<'a>, mut line: Range, ctx: &mut LayoutContext) -> Self {
-        // Find the items which bound the text range.
-        let last_idx = par.find(line.end - 1);
-        let first_idx = if line.is_empty() {
-            last_idx
-        } else {
-            par.find(line.start)
-        };
-
-        // Slice out the relevant items and ranges.
-        let mut items = &par.items[first_idx ..= last_idx];
-        let ranges = &par.ranges[first_idx ..= last_idx];
-
-        // Reshape the last item if it's split in half.
-        let mut last = None;
-        if let Some((ParItem::Text(shaped, align), rest)) = items.split_last() {
-            // Compute the string slice indices local to the shaped result.
-            let range = &par.ranges[last_idx];
-            let start = line.start.max(range.start) - range.start;
-            let end = line.end - range.start;
-
-            // Trim whitespace at the end of the line.
-            let end = start + shaped.text[start .. end].trim_end().len();
-            line.end = range.start + end;
-
-            if start != end || rest.is_empty() {
-                // Reshape that part (if the indices span the full range reshaping
-                // is fast and does nothing).
-                let reshaped = shaped.reshape(start .. end, &mut ctx.env.fonts);
-                last = Some(ParItem::Text(reshaped, *align));
-            }
-
-            items = rest;
-        }
-
-        // Reshape the start item if it's split in half.
-        let mut first = None;
-        if let Some((ParItem::Text(shaped, align), rest)) = items.split_first() {
-            let range = &par.ranges[first_idx];
-            let start = line.start - range.start;
-            let end = line.end.min(range.end) - range.start;
-            if start != end {
-                let reshaped = shaped.reshape(start .. end, &mut ctx.env.fonts);
-                first = Some(ParItem::Text(reshaped, *align));
-            }
-            items = rest;
-        }
-
-        let mut width = Length::ZERO;
-        let mut top = Length::ZERO;
-        let mut bottom = Length::ZERO;
-
-        for item in first.iter().chain(items).chain(&last) {
-            let (size, baseline) = item.measure();
-            width += size.width;
-            top = top.max(baseline);
-            bottom = bottom.max(size.height - baseline);
-        }
-
-        Self {
-            par,
-            line,
-            first,
-            items,
-            last,
-            ranges,
-            size: Size::new(width, top + bottom),
-            baseline: top,
         }
     }
 
-    /// Build the line's frame.
+    /// The baseline of the item.
-    fn build(&self, ctx: &mut LayoutContext, width: Length) -> Frame {
+    pub fn baseline(&self) -> Length {
-        let (size, baseline) = (self.size, self.baseline);
+        match self {
-        let full_size = Size::new(size.width.max(width), size.height);
+            Self::Spacing(_) => Length::ZERO,
-
+            Self::Text(shaped, _) => shaped.baseline,
-        let mut output = Frame::new(full_size, baseline);
+            Self::Frame(frame, _) => frame.baseline,
-        let mut offset = Length::ZERO;
-
-        let mut ruler = Align::Start;
-        self.reordered(|item| {
-            let (frame, align) = match *item {
-                ParItem::Spacing(amount) => {
-                    offset += amount;
-                    return;
-                }
-                ParItem::Text(ref shaped, align) => {
-                    (shaped.build(&mut ctx.env.fonts), align)
-                }
-                ParItem::Frame(ref frame, align) => (frame.clone(), align),
-            };
-
-            ruler = ruler.max(align);
-
-            let range = offset .. full_size.width - size.width + offset;
-            let x = ruler.resolve(self.par.dir, range);
-            let y = baseline - frame.baseline;
-
-            offset += frame.size.width;
-            output.push_frame(Point::new(x, y), frame);
-        });
-
-        output
-    }
-
-    /// Iterate through the line's items in visual order.
-    fn reordered(&self, mut f: impl FnMut(&ParItem<'a>)) {
-        if self.line.is_empty() {
-            return;
-        }
-
-        // Find the paragraph that contains the frame.
-        let para = self
-            .par
-            .bidi
-            .paragraphs
-            .iter()
-            .find(|para| para.range.contains(&self.line.start))
-            .unwrap();
-
-        // Compute the reordered ranges in visual order (left to right).
-        let (levels, runs) = self.par.bidi.visual_runs(para, self.line.clone());
-
-        // Find the items for each run.
-        for run in runs {
-            let first_idx = self.find(run.start);
-            let last_idx = self.find(run.end - 1);
-            let range = first_idx ..= last_idx;
-
-            // Provide the items forwards or backwards depending on the run's
-            // direction.
-            if levels[run.start].is_ltr() {
-                for item in range {
-                    f(self.get(item));
-                }
-            } else {
-                for item in range.rev() {
-                    f(self.get(item));
-                }
         }
     }
 }
 
-    /// Find the index of the item whose range contains the `text_offset`.
+/// A simple layouter that stacks lines into areas.
-    #[track_caller]
-    fn find(&self, text_offset: usize) -> usize {
-        find_range(self.ranges, text_offset).unwrap()
-    }
-
-    /// Get the item at the index.
-    #[track_caller]
-    fn get(&self, index: usize) -> &ParItem<'a> {
-        self.iter().nth(index).unwrap()
-    }
-
-    /// Iterate over the items of the line.
-    fn iter(&self) -> impl Iterator<Item = &ParItem<'a>> {
-        self.first.iter().chain(self.items).chain(&self.last)
-    }
-}
-
-/// Find the range that contains the position.
-fn find_range(ranges: &[Range], pos: usize) -> Option<usize> {
-    ranges.binary_search_by(|r| r.locate(pos)).ok()
-}
-
-/// Stacks lines into paragraph frames.
 struct LineStack<'a> {
     line_spacing: Length,
     areas: Areas,
@@ -428,36 +289,38 @@ impl<'a> LineStack<'a> {
     }
 
     fn push(&mut self, line: LineLayout<'a>) {
+        self.areas.current.height -= line.size.height + self.line_spacing;
+
         self.size.width = self.size.width.max(line.size.width);
         self.size.height += line.size.height;
         if !self.lines.is_empty() {
             self.size.height += self.line_spacing;
         }
 
-        self.areas.current.height -= line.size.height + self.line_spacing;
         self.lines.push(line);
     }
 
     fn finish_area(&mut self, ctx: &mut LayoutContext) {
         let expand = self.areas.expand.horizontal;
-        let full = self.areas.full.width;
+        self.size.width = expand.resolve(self.size.width, self.areas.full.width);
-        self.size.width = expand.resolve(self.size.width, full);
 
         let mut output = Frame::new(self.size, self.size.height);
-        let mut y = Length::ZERO;
         let mut first = true;
+        let mut offset = Length::ZERO;
 
         for line in mem::take(&mut self.lines) {
             let frame = line.build(ctx, self.size.width);
-            let height = frame.size.height;
+            let Frame { size, baseline, .. } = frame;
+
+            let pos = Point::new(Length::ZERO, offset);
+            output.push_frame(pos, frame);
 
             if first {
-                output.baseline = y + frame.baseline;
+                output.baseline = offset + baseline;
                 first = false;
             }
 
-            output.push_frame(Point::new(Length::ZERO, y), frame);
+            offset += size.height + self.line_spacing;
-            y += height + self.line_spacing;
         }
 
         self.finished.push(output);
@@ -471,6 +334,206 @@ impl<'a> LineStack<'a> {
     }
 }
 
+/// A lightweight representation of a line that spans a specific range in a
+/// paragraph's text. This type enables you to cheaply measure the size of a
+/// line in a range before comitting to building the line's frame.
+struct LineLayout<'a> {
+    /// The paragraph the line was created in.
+    par: &'a ParLayout<'a>,
+    /// The range the line spans in the paragraph.
+    line: Range,
+    /// A reshaped text item if the line sliced up a text item at the start.
+    first: Option<ParItem<'a>>,
+    /// Middle items which don't need to be reprocessed.
+    items: &'a [ParItem<'a>],
+    /// A reshaped text item if the line sliced up a text item at the end. If
+    /// there is only one text item, this takes precedence over `first`.
+    last: Option<ParItem<'a>>,
+    /// The ranges, indexed as `[first, ..items, last]`. The ranges for `first`
+    /// and `last` aren't trimmed to the line, but it doesn't matter because
+    /// we're just checking which range an index falls into.
+    ranges: &'a [Range],
+    /// The size of the line.
+    size: Size,
+    /// The baseline of the line.
+    baseline: Length,
+}
+
+impl<'a> LineLayout<'a> {
+    /// Create a line which spans the given range.
+    fn new(ctx: &mut LayoutContext, par: &'a ParLayout<'a>, mut line: Range) -> Self {
+        // Find the items which bound the text range.
+        let last_idx = par.find(line.end.saturating_sub(1)).unwrap();
+        let first_idx = if line.is_empty() {
+            last_idx
+        } else {
+            par.find(line.start).unwrap()
+        };
+
+        // Slice out the relevant items and ranges.
+        let mut items = &par.items[first_idx ..= last_idx];
+        let ranges = &par.ranges[first_idx ..= last_idx];
+
+        // Reshape the last item if it's split in half.
+        let mut last = None;
+        if let Some((ParItem::Text(shaped, align), rest)) = items.split_last() {
+            // Compute the range we want to shape, trimming whitespace at the
+            // end of the line.
+            let base = par.ranges[last_idx].start;
+            let start = line.start.max(base);
+            let end = start + par.bidi.text[start .. line.end].trim_end().len();
+            let range = start - base .. end - base;
+
+            // Reshape if necessary.
+            if range.len() < shaped.text.len() {
+                // If start == end and the rest is empty, then we have an empty
+                // line. To make that line have the appropriate height, we shape the
+                // empty string.
+                if !range.is_empty() || rest.is_empty() {
+                    // Reshape that part.
+                    let reshaped = shaped.reshape(ctx, range);
+                    last = Some(ParItem::Text(reshaped, *align));
+                }
+
+                items = rest;
+                line.end = end;
+            }
+        }
+
+        // Reshape the start item if it's split in half.
+        let mut first = None;
+        if let Some((ParItem::Text(shaped, align), rest)) = items.split_first() {
+            // Compute the range we want to shape.
+            let Range { start: base, end: first_end } = par.ranges[first_idx];
+            let start = line.start;
+            let end = line.end.min(first_end);
+            let range = start - base .. end - base;
+
+            // Reshape if necessary.
+            if range.len() < shaped.text.len() {
+                if !range.is_empty() {
+                    let reshaped = shaped.reshape(ctx, range);
+                    first = Some(ParItem::Text(reshaped, *align));
+                }
+
+                items = rest;
+            }
+        }
+
+        let mut width = Length::ZERO;
+        let mut top = Length::ZERO;
+        let mut bottom = Length::ZERO;
+
+        // Measure the size of the line.
+        for item in first.iter().chain(items).chain(&last) {
+            let size = item.size();
+            let baseline = item.baseline();
+            width += size.width;
+            top = top.max(baseline);
+            bottom = bottom.max(size.height - baseline);
+        }
+
+        Self {
+            par,
+            line,
+            first,
+            items,
+            last,
+            ranges,
+            size: Size::new(width, top + bottom),
+            baseline: top,
+        }
+    }
+
+    /// Build the line's frame.
+    fn build(&self, ctx: &mut LayoutContext, width: Length) -> Frame {
+        let full_width = self.size.width.max(width);
+        let full_size = Size::new(full_width, self.size.height);
+        let free_width = full_width - self.size.width;
+
+        let mut output = Frame::new(full_size, self.baseline);
+        let mut ruler = Align::Start;
+        let mut offset = Length::ZERO;
+
+        self.reordered(|item| {
+            let frame = match *item {
+                ParItem::Spacing(amount) => {
+                    offset += amount;
+                    return;
+                }
+                ParItem::Text(ref shaped, align) => {
+                    ruler = ruler.max(align);
+                    shaped.build(ctx)
+                }
+                ParItem::Frame(ref frame, align) => {
+                    ruler = ruler.max(align);
+                    frame.clone()
+                }
+            };
+
+            let Frame { size, baseline, .. } = frame;
+            let pos = Point::new(
+                ruler.resolve(self.par.dir, offset .. free_width + offset),
+                self.baseline - baseline,
+            );
+
+            output.push_frame(pos, frame);
+            offset += size.width;
+        });
+
+        output
+    }
+
+    /// Iterate through the line's items in visual order.
+    fn reordered(&self, mut f: impl FnMut(&ParItem<'a>)) {
+        // The bidi crate doesn't like empty lines.
+        if self.line.is_empty() {
+            return;
+        }
+
+        // Find the paragraph that contains the line.
+        let para = self
+            .par
+            .bidi
+            .paragraphs
+            .iter()
+            .find(|para| para.range.contains(&self.line.start))
+            .unwrap();
+
+        // Compute the reordered ranges in visual order (left to right).
+        let (levels, runs) = self.par.bidi.visual_runs(para, self.line.clone());
+
+        // Find the items for each run.
+        for run in runs {
+            let first_idx = self.find(run.start).unwrap();
+            let last_idx = self.find(run.end - 1).unwrap();
+            let range = first_idx ..= last_idx;
+
+            // Provide the items forwards or backwards depending on the run's
+            // direction.
+            if levels[run.start].is_ltr() {
+                for item in range {
+                    f(self.get(item).unwrap());
+                }
+            } else {
+                for item in range.rev() {
+                    f(self.get(item).unwrap());
+                }
+            }
+        }
+    }
+
+    /// Find the index of the item whose range contains the `text_offset`.
+    fn find(&self, text_offset: usize) -> Option<usize> {
+        self.ranges.binary_search_by(|r| r.locate(text_offset)).ok()
+    }
+
+    /// Get the item at the index.
+    fn get(&self, index: usize) -> Option<&ParItem<'a>> {
+        self.first.iter().chain(self.items).chain(&self.last).nth(index)
+    }
+}
+
 /// Helper methods for BiDi levels.
 trait LevelExt: Sized {
     fn from_dir(dir: Dir) -> Option<Self>;
@@ -490,21 +553,3 @@ impl LevelExt for Level {
         if self.is_ltr() { Dir::LTR } else { Dir::RTL }
     }
 }
-
-impl From<ParNode> for AnyNode {
-    fn from(par: ParNode) -> Self {
-        Self::new(par)
-    }
-}
-
-impl Debug for ParChild {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Spacing(amount) => write!(f, "Spacing({:?})", amount),
-            Self::Text(text, _, align) => write!(f, "Text({:?}, {:?})", text, align),
-            Self::Any(any, align) => {
-                f.debug_tuple("Any").field(any).field(align).finish()
-            }
-        }
-    }
-}

src/layout/shaping.rs

@@ -6,7 +6,7 @@ use fontdock::FaceId;
 use rustybuzz::UnicodeBuffer;
 use ttf_parser::GlyphId;
 
-use super::{Element, Frame, Glyph, Text};
+use super::{Element, Frame, Glyph, LayoutContext, Text};
 use crate::env::FontLoader;
 use crate::exec::FontProps;
 use crate::font::FaceBuf;
@@ -60,12 +60,12 @@ enum Side {
 
 impl<'a> ShapedText<'a> {
     /// Build the shaped text's frame.
-    pub fn build(&self, loader: &mut FontLoader) -> Frame {
+    pub fn build(&self, ctx: &mut LayoutContext) -> Frame {
         let mut frame = Frame::new(self.size, self.baseline);
-        let mut x = Length::ZERO;
+        let mut offset = Length::ZERO;
 
         for (face_id, group) in self.glyphs.as_ref().group_by_key(|g| g.face_id) {
-            let pos = Point::new(x, self.baseline);
+            let pos = Point::new(offset, self.baseline);
             let mut text = Text {
                 face_id,
                 size: self.props.size,
@@ -73,12 +73,12 @@ impl<'a> ShapedText<'a> {
                 glyphs: vec![],
             };
 
-            let face = loader.face(face_id);
+            let face = ctx.env.fonts.face(face_id);
             for glyph in group {
                 let x_advance = face.convert(glyph.x_advance).scale(self.props.size);
                 let x_offset = face.convert(glyph.x_offset).scale(self.props.size);
                 text.glyphs.push(Glyph { id: glyph.glyph_id, x_advance, x_offset });
-                x += x_advance;
+                offset += x_advance;
             }
 
             frame.push(pos, Element::Text(text));
@@ -91,11 +91,11 @@ impl<'a> ShapedText<'a> {
     /// shaping process if possible.
     pub fn reshape(
         &'a self,
+        ctx: &mut LayoutContext,
         text_range: Range<usize>,
-        loader: &mut FontLoader,
     ) -> ShapedText<'a> {
         if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) {
-            let (size, baseline) = measure(glyphs, loader, self.props);
+            let (size, baseline) = measure(&mut ctx.env.fonts, glyphs, self.props);
             Self {
                 text: &self.text[text_range],
                 dir: self.dir,
@@ -105,7 +105,7 @@ impl<'a> ShapedText<'a> {
                 glyphs: Cow::Borrowed(glyphs),
             }
         } else {
-            shape(&self.text[text_range], self.dir, loader, self.props)
+            shape(ctx, &self.text[text_range], self.dir, self.props)
         }
     }
 
@@ -176,18 +176,21 @@ impl Debug for ShapedText<'_> {
 
 /// Shape text into [`ShapedText`].
 pub fn shape<'a>(
+    ctx: &mut LayoutContext,
     text: &'a str,
     dir: Dir,
-    loader: &mut FontLoader,
     props: &'a FontProps,
 ) -> ShapedText<'a> {
+    let loader = &mut ctx.env.fonts;
+
     let mut glyphs = vec![];
     let families = props.families.iter();
     if !text.is_empty() {
-        shape_segment(&mut glyphs, 0, text, dir, loader, props, families, None);
+        shape_segment(loader, &mut glyphs, 0, text, dir, props, families, None);
     }
 
-    let (size, baseline) = measure(&glyphs, loader, props);
+    let (size, baseline) = measure(loader, &glyphs, props);
+
     ShapedText {
         text,
         dir,
@@ -200,14 +203,14 @@ pub fn shape<'a>(
 
 /// Shape text with font fallback using the `families` iterator.
 fn shape_segment<'a>(
+    loader: &mut FontLoader,
     glyphs: &mut Vec<ShapedGlyph>,
     base: usize,
     text: &str,
     dir: Dir,
-    loader: &mut FontLoader,
     props: &FontProps,
     mut families: impl Iterator<Item = &'a str> + Clone,
-    mut first: Option<FaceId>,
+    mut first_face: Option<FaceId>,
 ) {
     // Select the font family.
     let (face_id, fallback) = loop {
@@ -219,17 +222,16 @@ fn shape_segment<'a>(
             },
             // We're out of families, so we don't do any more fallback and just
             // shape the tofus with the first face we originally used.
-            None => match first {
+            None => match first_face {
                 Some(id) => break (id, false),
                 None => return,
             },
         }
     };
 
-    // Register that this is the first available font.
+    // Remember the id if this the first available face since we use that one to
-    if first.is_none() {
+    // shape tofus.
-        first = Some(face_id);
+    first_face.get_or_insert(face_id);
-    }
 
     // Fill the buffer with our text.
     let mut buffer = UnicodeBuffer::new();
@@ -245,7 +247,8 @@ fn shape_segment<'a>(
     let infos = buffer.glyph_infos();
     let pos = buffer.glyph_positions();
 
-    // Collect the shaped glyphs, reshaping with the next font if necessary.
+    // Collect the shaped glyphs, doing fallback and shaping parts again with
+    // the next font if necessary.
     let mut i = 0;
     while i < infos.len() {
         let info = &infos[i];
@@ -263,30 +266,32 @@ fn shape_segment<'a>(
                 safe_to_break: !info.unsafe_to_break(),
             });
         } else {
-            // Do font fallback if the glyph is a tofu.
+            // Determine the source text range for the tofu sequence.
-            //
+            let range = {
                 // First, search for the end of the tofu sequence.
                 let k = i;
                 while infos.get(i + 1).map_or(false, |info| info.codepoint == 0) {
                     i += 1;
                 }
 
-            // Determine the source text range for the tofu sequence.
+                // Then, determine the start and end text index.
-            let range = {
-                // Examples
                 //
-                // Here, _ is a tofu.
+                // Examples:
-                // Note that the glyph cluster length is greater than 1 char!
+                // Everything is shown in visual order. Tofus are written as "_".
+                // We want to find out that the tofus span the text `2..6`.
+                // Note that the clusters are longer than 1 char.
                 //
-                // Left-to-right clusters:
+                // Left-to-right:
-                // h a l i h a l l o
+                // Text:     h a l i h a l l o
-                // A   _   _   C   E
+                // Glyphs:   A   _   _   C   E
-                // 0   2   4   6   8
+                // Clusters: 0   2   4   6   8
+                //              k=1 i=2
                 //
-                // Right-to-left clusters:
+                // Right-to-left:
-                // O L L A H I L A H
+                // Text:     O L L A H I L A H
-                // E   C   _   _   A
+                // Glyphs:   E   C   _   _   A
-                // 8   6   4   2   0
+                // Clusters: 8   6   4   2   0
+                //                  k=2 i=3
 
                 let ltr = dir.is_positive();
                 let first = if ltr { k } else { i };
@@ -295,22 +300,21 @@ fn shape_segment<'a>(
                 let last = if ltr { i.checked_add(1) } else { k.checked_sub(1) };
                 let end = last
                     .and_then(|last| infos.get(last))
-                    .map(|info| info.cluster as usize)
+                    .map_or(text.len(), |info| info.cluster as usize);
-                    .unwrap_or(text.len());
 
                 start .. end
             };
 
             // Recursively shape the tofu sequence with the next family.
             shape_segment(
+                loader,
                 glyphs,
                 base + range.start,
                 &text[range],
                 dir,
-                loader,
                 props,
                 families.clone(),
-                first,
+                first_face,
             );
         }
 
@@ -321,14 +325,14 @@ fn shape_segment<'a>(
 /// Measure the size and baseline of a run of shaped glyphs with the given
 /// properties.
 fn measure(
-    glyphs: &[ShapedGlyph],
     loader: &mut FontLoader,
+    glyphs: &[ShapedGlyph],
     props: &FontProps,
 ) -> (Size, Length) {
+    let mut width = Length::ZERO;
     let mut top = Length::ZERO;
     let mut bottom = Length::ZERO;
-    let mut width = Length::ZERO;
+    let mut expand_vertical = |face: &FaceBuf| {
-    let mut vertical = |face: &FaceBuf| {
         top = top.max(face.vertical_metric(props.top_edge).scale(props.size));
         bottom = bottom.max(-face.vertical_metric(props.bottom_edge).scale(props.size));
     };
@@ -338,14 +342,14 @@ fn measure(
         // first available font.
         for family in props.families.iter() {
             if let Some(face_id) = loader.query(family, props.variant) {
-                vertical(loader.face(face_id));
+                expand_vertical(loader.face(face_id));
                 break;
             }
         }
     } else {
         for (face_id, group) in glyphs.group_by_key(|g| g.face_id) {
             let face = loader.face(face_id);
-            vertical(face);
+            expand_vertical(face);
 
             for glyph in group {
                 width += face.convert(glyph.x_advance).scale(props.size);

src/util.rs

@@ -1,4 +1,5 @@
-/// Utilities.
+//! Utilities.
+
 use std::cmp::Ordering;
 use std::ops::Range;