diff --git a/src/geom/em.rs b/src/geom/em.rs index af6be7065..b9f1d8978 100644 --- a/src/geom/em.rs +++ b/src/geom/em.rs @@ -27,6 +27,11 @@ impl Em { Self(Scalar(units.into() / units_per_em)) } + /// Create an em length from a length at the given font size. + pub fn from_length(length: Length, font_size: Length) -> Self { + Self(Scalar(length / font_size)) + } + /// Convert to a length at the given font size. pub fn resolve(self, font_size: Length) -> Length { self.get() * font_size diff --git a/src/library/par.rs b/src/library/par.rs index cc5dd9b6d..8b4adf92d 100644 --- a/src/library/par.rs +++ b/src/library/par.rs @@ -32,6 +32,8 @@ impl ParNode { pub const DIR: Dir = Dir::LTR; /// How to align text and inline objects in their line. pub const ALIGN: Align = Align::Left; + /// Whether to justify text in its line. + pub const JUSTIFY: bool = false; /// The spacing between lines (dependent on scaled font size). pub const LEADING: Linear = Relative::new(0.65).into(); /// The extra spacing between paragraphs (dependent on scaled font size). @@ -75,6 +77,7 @@ impl ParNode { styles.set_opt(Self::DIR, dir); styles.set_opt(Self::ALIGN, align); + styles.set_opt(Self::JUSTIFY, args.named("justify")?); styles.set_opt(Self::LEADING, args.named("leading")?); styles.set_opt(Self::SPACING, args.named("spacing")?); styles.set_opt(Self::INDENT, args.named("indent")?); @@ -83,103 +86,6 @@ impl ParNode { } } -impl Layout for ParNode { - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult>> { - // Collect all text into one string used for BiDi analysis. - let text = self.collect_text(); - let level = Level::from_dir(styles.get(Self::DIR)); - let bidi = BidiInfo::new(&text, level); - - // Prepare paragraph layout by building a representation on which we can - // do line breaking without layouting each and every line from scratch. - let par = ParLayout::new(ctx, self, bidi, regions, &styles)?; - let fonts = &mut ctx.fonts; - let em = styles.get(TextNode::SIZE).abs; - let align = styles.get(ParNode::ALIGN); - let leading = styles.get(ParNode::LEADING).resolve(em); - - // The already determined lines and the current line attempt. - let mut lines = vec![]; - let mut start = 0; - let mut last = None; - - // Find suitable line breaks. - for (end, mandatory) in LineBreakIterator::new(&text) { - // Compute the line and its size. - let mut line = par.line(fonts, 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 !regions.first.x.fits(line.size.x) { - if let Some((last_line, last_end)) = last.take() { - lines.push(last_line); - start = last_end; - line = par.line(fonts, start .. end); - } - } - - // Finish the current line if there is a mandatory line break (i.e. - // due to "\n") or if the line doesn't fit horizontally already - // since no shorter line will be possible. - if mandatory || !regions.first.x.fits(line.size.x) { - lines.push(line); - start = end; - last = None; - } else { - last = Some((line, end)); - } - } - - if let Some((line, _)) = last { - lines.push(line); - } - - // Determine the paragraph's width: Fit to width if we shoudn't expand - // and there's no fractional spacing. - let mut width = regions.first.x; - if !regions.expand.x && lines.iter().all(|line| line.fr.is_zero()) { - width = lines.iter().map(|line| line.size.x).max().unwrap_or_default(); - } - - // State for final frame building. - let mut regions = regions.clone(); - let mut finished = vec![]; - let mut first = true; - let mut output = Frame::new(Size::with_x(width)); - - // Stack the lines into one frame per region. - for line in lines { - while !regions.first.y.fits(line.size.y) && !regions.in_last() { - finished.push(Arc::new(output)); - output = Frame::new(Size::with_x(width)); - regions.next(); - first = true; - } - - if !first { - output.size.y += leading; - } - - let frame = line.build(fonts, width, align); - let pos = Point::with_y(output.size.y); - output.size.y += frame.size.y; - output.merge_frame(pos, frame); - - regions.first.y -= line.size.y + leading; - first = false; - } - - finished.push(Arc::new(output)); - Ok(finished) - } -} - impl ParNode { /// Concatenate all text in the paragraph into one string, replacing spacing /// with a space character and other non-text nodes with the object @@ -212,6 +118,127 @@ impl ParNode { } } +impl Layout for ParNode { + fn layout( + &self, + ctx: &mut Context, + regions: &Regions, + styles: StyleChain, + ) -> TypResult>> { + // Collect all text into one string and perform BiDi analysis. + let text = self.collect_text(); + let level = Level::from_dir(styles.get(Self::DIR)); + let bidi = BidiInfo::new(&text, level); + + // Prepare paragraph layout by building a representation on which we can + // do line breaking without layouting each and every line from scratch. + let par = ParLayout::new(ctx, self, bidi, regions, &styles)?; + + // Break the paragraph into lines. + let lines = break_lines(&mut ctx.fonts, &par, regions.first.x); + + // Stack the lines into one frame per region. + Ok(stack_lines(&ctx.fonts, lines, regions, styles)) + } +} + +/// Perform line breaking. +fn break_lines<'a>( + fonts: &mut FontStore, + par: &'a ParLayout<'a>, + width: Length, +) -> Vec> { + // The already determined lines and the current line attempt. + let mut lines = vec![]; + let mut start = 0; + let mut last = None; + + // Find suitable line breaks. + for (end, mandatory) in LineBreakIterator::new(&par.bidi.text) { + // Compute the line and its size. + let mut line = par.line(fonts, start .. end, mandatory); + + // 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 !width.fits(line.size.x) { + if let Some((last_line, last_end)) = last.take() { + lines.push(last_line); + start = last_end; + line = par.line(fonts, start .. end, mandatory); + } + } + + // Finish the current line if there is a mandatory line break (i.e. + // due to "\n") or if the line doesn't fit horizontally already + // since then no shorter line will be possible. + if mandatory || !width.fits(line.size.x) { + lines.push(line); + start = end; + last = None; + } else { + last = Some((line, end)); + } + } + + if let Some((line, _)) = last { + lines.push(line); + } + + lines +} + +/// Combine the lines into one frame per region. +fn stack_lines( + fonts: &FontStore, + lines: Vec, + regions: &Regions, + styles: StyleChain, +) -> Vec> { + let em = styles.get(TextNode::SIZE).abs; + let leading = styles.get(ParNode::LEADING).resolve(em); + let align = styles.get(ParNode::ALIGN); + let justify = styles.get(ParNode::JUSTIFY); + + // Determine the paragraph's width: Full width of the region if we + // should expand or there's fractional spacing, fit-to-width otherwise. + let mut width = regions.first.x; + if !regions.expand.x && lines.iter().all(|line| line.fr.is_zero()) { + width = lines.iter().map(|line| line.size.x).max().unwrap_or_default(); + } + + // State for final frame building. + let mut regions = regions.clone(); + let mut finished = vec![]; + let mut first = true; + let mut output = Frame::new(Size::with_x(width)); + + // Stack the lines into one frame per region. + for line in lines { + while !regions.first.y.fits(line.size.y) && !regions.in_last() { + finished.push(Arc::new(output)); + output = Frame::new(Size::with_x(width)); + regions.next(); + first = true; + } + + if !first { + output.size.y += leading; + } + + let frame = line.build(fonts, width, align, justify); + let pos = Point::with_y(output.size.y); + output.size.y += frame.size.y; + output.merge_frame(pos, frame); + + regions.first.y -= line.size.y + leading; + first = false; + } + + finished.push(Arc::new(output)); + finished +} + impl Debug for ParNode { fn fmt(&self, f: &mut Formatter) -> fmt::Result { f.write_str("Par ")?; @@ -261,7 +288,7 @@ impl LinebreakNode { } /// A paragraph representation in which children are already layouted and text -/// is separated into shapable runs. +/// is already preshaped. struct ParLayout<'a> { /// Bidirectional text embedding levels for the paragraph. bidi: BidiInfo<'a>, @@ -340,7 +367,12 @@ impl<'a> ParLayout<'a> { } /// Create a line which spans the given range. - fn line(&'a self, fonts: &mut FontStore, mut range: Range) -> LineLayout<'a> { + fn line( + &'a self, + fonts: &mut FontStore, + mut range: Range, + mandatory: bool, + ) -> LineLayout<'a> { // Find the items which bound the text range. let last_idx = self.find(range.end.saturating_sub(1)).unwrap(); let first_idx = if range.is_empty() { @@ -432,6 +464,7 @@ impl<'a> ParLayout<'a> { size: Size::new(width, top + bottom), baseline: top, fr, + mandatory, } } @@ -467,18 +500,36 @@ struct LineLayout<'a> { baseline: Length, /// The sum of fractional ratios in the line. fr: Fractional, + /// Whether the line ends at a mandatory break. + mandatory: bool, } impl<'a> LineLayout<'a> { /// Build the line's frame. - fn build(&self, fonts: &FontStore, width: Length, align: Align) -> Frame { - let size = Size::new(self.size.x.max(width), self.size.y); - let remaining = size.x - self.size.x; + fn build( + &self, + fonts: &FontStore, + width: Length, + align: Align, + justify: bool, + ) -> Frame { + let size = Size::new(width, self.size.y); + let mut remaining = width - self.size.x; let mut offset = Length::zero(); let mut output = Frame::new(size); output.baseline = Some(self.baseline); + let mut justification = Length::zero(); + if justify + && !self.mandatory + && self.range.end < self.bidi.text.len() + && self.fr.is_zero() + { + justification = remaining / self.spaces() as f64; + remaining = Length::zero(); + } + for item in self.reordered() { let mut position = |frame: Frame| { let x = offset + align.resolve(remaining); @@ -490,7 +541,7 @@ impl<'a> LineLayout<'a> { match item { ParItem::Absolute(v) => offset += *v, ParItem::Fractional(v) => offset += v.resolve(self.fr, remaining), - ParItem::Text(shaped) => position(shaped.build(fonts)), + ParItem::Text(shaped) => position(shaped.build(fonts, justification)), ParItem::Frame(frame) => position(frame.clone()), } } @@ -498,6 +549,11 @@ impl<'a> LineLayout<'a> { output } + /// The number of spaces in the line. + fn spaces(&self) -> usize { + self.shapeds().map(ShapedText::spaces).sum() + } + /// Iterate through the line's items in visual order. fn reordered(&self) -> impl Iterator> { // The bidi crate doesn't like empty lines. @@ -533,6 +589,19 @@ impl<'a> LineLayout<'a> { .map(move |idx| self.get(idx).unwrap()) } + /// Iterate over the line's items. + fn items(&self) -> impl Iterator> { + self.first.iter().chain(self.items).chain(&self.last) + } + + /// Iterate through the line's text items. + fn shapeds(&self) -> impl Iterator> { + self.items().filter_map(|item| match item { + ParItem::Text(shaped) => Some(shaped), + _ => None, + }) + } + /// Find the index of the item whose range contains the `text_offset`. fn find(&self, text_offset: usize) -> Option { self.ranges.binary_search_by(|r| r.locate(text_offset)).ok() @@ -540,7 +609,7 @@ impl<'a> LineLayout<'a> { /// 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) + self.items().nth(index) } } diff --git a/src/library/text.rs b/src/library/text.rs index 448ba9af0..b76b60ee9 100644 --- a/src/library/text.rs +++ b/src/library/text.rs @@ -406,6 +406,191 @@ impl Case { } } +/// The result of shaping text. +/// +/// This type contains owned or borrowed shaped text runs, which can be +/// measured, used to reshape substrings more quickly and converted into a +/// frame. +#[derive(Debug, Clone)] +pub struct ShapedText<'a> { + /// The text that was shaped. + pub text: Cow<'a, str>, + /// The text direction. + pub dir: Dir, + /// The text's style properties. + pub styles: StyleChain<'a>, + /// The size of the text's bounding box. + pub size: Size, + /// The baseline from the top of the frame. + pub baseline: Length, + /// The shaped glyphs. + pub glyphs: Cow<'a, [ShapedGlyph]>, +} + +/// A single glyph resulting from shaping. +#[derive(Debug, Copy, Clone)] +pub struct ShapedGlyph { + /// The font face the glyph is contained in. + pub face_id: FaceId, + /// The glyph's index in the face. + pub glyph_id: u16, + /// The advance width of the glyph. + pub x_advance: Em, + /// The horizontal offset of the glyph. + pub x_offset: Em, + /// The start index of the glyph in the source text. + pub text_index: usize, + /// Whether splitting the shaping result before this glyph would yield the + /// same results as shaping the parts to both sides of `text_index` + /// separately. + pub safe_to_break: bool, + /// Whether this glyph represents a space. + pub is_space: bool, +} + +/// A visual side. +enum Side { + Left, + Right, +} + +impl<'a> ShapedText<'a> { + /// Build the shaped text's frame. + /// + /// The `justification` defines how much extra advance width each + /// [space glyph](ShapedGlyph::is_space) will get. + pub fn build(&self, fonts: &FontStore, justification: Length) -> Frame { + let mut offset = Length::zero(); + let mut frame = Frame::new(self.size); + frame.baseline = Some(self.baseline); + + for (face_id, group) in self.glyphs.as_ref().group_by_key(|g| g.face_id) { + let pos = Point::new(offset, self.baseline); + + let size = self.styles.get(TextNode::SIZE).abs; + let fill = self.styles.get(TextNode::FILL); + let glyphs = group + .iter() + .map(|glyph| Glyph { + id: glyph.glyph_id, + x_advance: glyph.x_advance + + if glyph.is_space { + frame.size.x += justification; + Em::from_length(justification, size) + } else { + Em::zero() + }, + x_offset: glyph.x_offset, + }) + .collect(); + + let text = Text { face_id, size, fill, glyphs }; + let text_layer = frame.layer(); + let width = text.width(); + + // Apply line decorations. + for deco in self.styles.get_cloned(TextNode::LINES) { + decorate(&mut frame, &deco, fonts, &text, pos, width); + } + + frame.insert(text_layer, pos, Element::Text(text)); + offset += width; + } + + // Apply link if it exists. + if let Some(url) = self.styles.get_ref(TextNode::LINK) { + frame.link(url); + } + + frame + } + + /// How many spaces the text contains. + pub fn spaces(&self) -> usize { + self.glyphs.iter().filter(|g| g.is_space).count() + } + + /// Reshape a range of the shaped text, reusing information from this + /// shaping process if possible. + pub fn reshape( + &'a self, + fonts: &mut FontStore, + text_range: Range, + ) -> ShapedText<'a> { + if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) { + let (size, baseline) = measure(fonts, glyphs, self.styles); + Self { + text: Cow::Borrowed(&self.text[text_range]), + dir: self.dir, + styles: self.styles.clone(), + size, + baseline, + glyphs: Cow::Borrowed(glyphs), + } + } else { + shape(fonts, &self.text[text_range], self.styles.clone(), self.dir) + } + } + + /// Find the subslice of glyphs that represent the given text range if both + /// sides are safe to break. + fn slice_safe_to_break(&self, text_range: Range) -> Option<&[ShapedGlyph]> { + let Range { mut start, mut end } = text_range; + if !self.dir.is_positive() { + std::mem::swap(&mut start, &mut end); + } + + let left = self.find_safe_to_break(start, Side::Left)?; + let right = self.find_safe_to_break(end, Side::Right)?; + Some(&self.glyphs[left .. right]) + } + + /// Find the glyph offset matching the text index that is most towards the + /// given side and safe-to-break. + fn find_safe_to_break(&self, text_index: usize, towards: Side) -> Option { + let ltr = self.dir.is_positive(); + + // Handle edge cases. + let len = self.glyphs.len(); + if text_index == 0 { + return Some(if ltr { 0 } else { len }); + } else if text_index == self.text.len() { + return Some(if ltr { len } else { 0 }); + } + + // Find any glyph with the text index. + let mut idx = self + .glyphs + .binary_search_by(|g| { + let ordering = g.text_index.cmp(&text_index); + if ltr { ordering } else { ordering.reverse() } + }) + .ok()?; + + let next = match towards { + Side::Left => usize::checked_sub, + Side::Right => usize::checked_add, + }; + + // Search for the outermost glyph with the text index. + while let Some(next) = next(idx, 1) { + if self.glyphs.get(next).map_or(true, |g| g.text_index != text_index) { + break; + } + idx = next; + } + + // RTL needs offset one because the left side of the range should be + // exclusive and the right side inclusive, contrary to the normal + // behaviour of ranges. + if !ltr { + idx += 1; + } + + self.glyphs[idx].safe_to_break.then(|| idx) + } +} + /// Shape text into [`ShapedText`]. pub fn shape<'a>( fonts: &mut FontStore, @@ -446,197 +631,6 @@ pub fn shape<'a>( } } -/// Shape text with font fallback using the `families` iterator. -fn shape_segment<'a>( - fonts: &mut FontStore, - glyphs: &mut Vec, - base: usize, - text: &str, - variant: FontVariant, - mut families: impl Iterator + Clone, - mut first_face: Option, - dir: Dir, - tags: &[rustybuzz::Feature], -) { - // No font has newlines. - if text.chars().all(|c| c == '\n') { - return; - } - - // Select the font family. - let (face_id, fallback) = loop { - // Try to load the next available font family. - match families.next() { - Some(family) => { - if let Some(id) = fonts.select(family, variant) { - break (id, true); - } - } - // 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_face { - Some(id) => break (id, false), - None => return, - }, - } - }; - - // Remember the id if this the first available face since we use that one to - // shape tofus. - first_face.get_or_insert(face_id); - - // Fill the buffer with our text. - let mut buffer = UnicodeBuffer::new(); - buffer.push_str(text); - buffer.set_direction(match dir { - Dir::LTR => rustybuzz::Direction::LeftToRight, - Dir::RTL => rustybuzz::Direction::RightToLeft, - _ => unimplemented!(), - }); - - // Shape! - let mut face = fonts.get(face_id); - let buffer = rustybuzz::shape(face.ttf(), tags, buffer); - let infos = buffer.glyph_infos(); - let pos = buffer.glyph_positions(); - - // 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]; - let cluster = info.cluster as usize; - - if info.glyph_id != 0 || !fallback { - // Add the glyph to the shaped output. - // TODO: Don't ignore y_advance and y_offset. - glyphs.push(ShapedGlyph { - face_id, - glyph_id: info.glyph_id as u16, - x_advance: face.to_em(pos[i].x_advance), - x_offset: face.to_em(pos[i].x_offset), - text_index: base + cluster, - safe_to_break: !info.unsafe_to_break(), - }); - } else { - // 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.glyph_id == 0) { - i += 1; - } - - // Then, determine the start and end text index. - // - // Examples: - // 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: - // Text: h a l i h a l l o - // Glyphs: A _ _ C E - // Clusters: 0 2 4 6 8 - // k=1 i=2 - // - // Right-to-left: - // Text: O L L A H I L A H - // Glyphs: E C _ _ A - // Clusters: 8 6 4 2 0 - // k=2 i=3 - let ltr = dir.is_positive(); - let first = if ltr { k } else { i }; - let start = infos[first].cluster as usize; - let last = if ltr { i.checked_add(1) } else { k.checked_sub(1) }; - let end = last - .and_then(|last| infos.get(last)) - .map_or(text.len(), |info| info.cluster as usize); - - start .. end - }; - - // Recursively shape the tofu sequence with the next family. - shape_segment( - fonts, - glyphs, - base + range.start, - &text[range], - variant, - families.clone(), - first_face, - dir, - tags, - ); - - face = fonts.get(face_id); - } - - i += 1; - } -} - -/// Apply tracking to a slice of shaped glyphs. -fn track(glyphs: &mut [ShapedGlyph], tracking: Em) { - if tracking.is_zero() { - return; - } - - let mut glyphs = glyphs.iter_mut().peekable(); - while let Some(glyph) = glyphs.next() { - if glyphs - .peek() - .map_or(false, |next| glyph.text_index != next.text_index) - { - glyph.x_advance += tracking; - } - } -} - -/// Measure the size and baseline of a run of shaped glyphs with the given -/// properties. -fn measure( - fonts: &mut FontStore, - glyphs: &[ShapedGlyph], - styles: StyleChain, -) -> (Size, Length) { - let mut width = Length::zero(); - let mut top = Length::zero(); - let mut bottom = Length::zero(); - - let size = styles.get(TextNode::SIZE).abs; - let top_edge = styles.get(TextNode::TOP_EDGE); - let bottom_edge = styles.get(TextNode::BOTTOM_EDGE); - - // Expand top and bottom by reading the face's vertical metrics. - let mut expand = |face: &Face| { - top.set_max(face.vertical_metric(top_edge, size)); - bottom.set_max(-face.vertical_metric(bottom_edge, size)); - }; - - if glyphs.is_empty() { - // When there are no glyphs, we just use the vertical metrics of the - // first available font. - for family in families(styles) { - if let Some(face_id) = fonts.select(family, variant(styles)) { - expand(fonts.get(face_id)); - break; - } - } - } else { - for (face_id, group) in glyphs.group_by_key(|g| g.face_id) { - let face = fonts.get(face_id); - expand(face); - - for glyph in group { - width += glyph.x_advance.resolve(size); - } - } - } - - (Size::new(width, top + bottom), top) -} - /// Resolve the font variant with `STRONG` and `EMPH` factored in. fn variant(styles: StyleChain) -> FontVariant { let mut variant = FontVariant::new( @@ -762,297 +756,319 @@ fn tags(styles: StyleChain) -> Vec { tags } -/// The result of shaping text. -/// -/// This type contains owned or borrowed shaped text runs, which can be -/// measured, used to reshape substrings more quickly and converted into a -/// frame. -#[derive(Debug, Clone)] -pub struct ShapedText<'a> { - /// The text that was shaped. - pub text: Cow<'a, str>, - /// The text direction. - pub dir: Dir, - /// The text's style properties. - pub styles: StyleChain<'a>, - /// The font size. - pub size: Size, - /// The baseline from the top of the frame. - pub baseline: Length, - /// The shaped glyphs. - pub glyphs: Cow<'a, [ShapedGlyph]>, -} - -/// A single glyph resulting from shaping. -#[derive(Debug, Copy, Clone)] -pub struct ShapedGlyph { - /// The font face the glyph is contained in. - pub face_id: FaceId, - /// The glyph's index in the face. - pub glyph_id: u16, - /// The advance width of the glyph. - pub x_advance: Em, - /// The horizontal offset of the glyph. - pub x_offset: Em, - /// The start index of the glyph in the source text. - pub text_index: usize, - /// Whether splitting the shaping result before this glyph would yield the - /// same results as shaping the parts to both sides of `text_index` - /// separately. - pub safe_to_break: bool, -} - -impl<'a> ShapedText<'a> { - /// Build the shaped text's frame. - pub fn build(&self, fonts: &FontStore) -> Frame { - let mut offset = Length::zero(); - let mut frame = Frame::new(self.size); - frame.baseline = Some(self.baseline); - - for (face_id, group) in self.glyphs.as_ref().group_by_key(|g| g.face_id) { - let pos = Point::new(offset, self.baseline); - - let size = self.styles.get(TextNode::SIZE).abs; - let fill = self.styles.get(TextNode::FILL); - let glyphs = group - .iter() - .map(|glyph| Glyph { - id: glyph.glyph_id, - x_advance: glyph.x_advance, - x_offset: glyph.x_offset, - }) - .collect(); - - let text = Text { face_id, size, fill, glyphs }; - let text_layer = frame.layer(); - let width = text.width(); - - // Apply line decorations. - for deco in self.styles.get_cloned(TextNode::LINES) { - self.decorate(&mut frame, &deco, fonts, &text, pos, width); - } - - frame.insert(text_layer, pos, Element::Text(text)); - offset += width; - } - - // Apply link if it exists. - if let Some(url) = self.styles.get_ref(TextNode::LINK) { - frame.link(url); - } - - frame +/// Shape text with font fallback using the `families` iterator. +fn shape_segment<'a>( + fonts: &mut FontStore, + glyphs: &mut Vec, + base: usize, + text: &str, + variant: FontVariant, + mut families: impl Iterator + Clone, + mut first_face: Option, + dir: Dir, + tags: &[rustybuzz::Feature], +) { + // No font has newlines. + if text.chars().all(|c| c == '\n') { + return; } - /// Add line decorations to a run of shaped text of a single font. - fn decorate( - &self, - frame: &mut Frame, - deco: &Decoration, - fonts: &FontStore, - text: &Text, - pos: Point, - width: Length, - ) { - let face = fonts.get(text.face_id); - let metrics = match deco.line { - super::STRIKETHROUGH => face.strikethrough, - super::OVERLINE => face.overline, - super::UNDERLINE | _ => face.underline, - }; - - let evade = deco.evade && deco.line != super::STRIKETHROUGH; - let extent = deco.extent.resolve(text.size); - let offset = deco - .offset - .map(|s| s.resolve(text.size)) - .unwrap_or(-metrics.position.resolve(text.size)); - - let stroke = Stroke { - paint: deco.stroke.unwrap_or(text.fill), - thickness: deco - .thickness - .map(|s| s.resolve(text.size)) - .unwrap_or(metrics.thickness.resolve(text.size)), - }; - - let gap_padding = 0.08 * text.size; - let min_width = 0.162 * text.size; - - let mut start = pos.x - extent; - let end = pos.x + (width + 2.0 * extent); - - let mut push_segment = |from: Length, to: Length| { - let origin = Point::new(from, pos.y + offset); - let target = Point::new(to - from, Length::zero()); - - if target.x >= min_width || !evade { - let shape = Shape::stroked(Geometry::Line(target), stroke); - frame.push(origin, Element::Shape(shape)); + // Select the font family. + let (face_id, fallback) = loop { + // Try to load the next available font family. + match families.next() { + Some(family) => { + if let Some(id) = fonts.select(family, variant) { + break (id, true); + } } - }; - - if !evade { - push_segment(start, end); - return; + // 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_face { + Some(id) => break (id, false), + None => return, + }, } + }; - let line = Line::new( - kurbo::Point::new(pos.x.to_raw(), offset.to_raw()), - kurbo::Point::new((pos.x + width).to_raw(), offset.to_raw()), - ); + // Remember the id if this the first available face since we use that one to + // shape tofus. + first_face.get_or_insert(face_id); - let mut x = pos.x; - let mut intersections = vec![]; + // Fill the buffer with our text. + let mut buffer = UnicodeBuffer::new(); + buffer.push_str(text); + buffer.set_direction(match dir { + Dir::LTR => rustybuzz::Direction::LeftToRight, + Dir::RTL => rustybuzz::Direction::RightToLeft, + _ => unimplemented!(), + }); - for glyph in text.glyphs.iter() { - let dx = glyph.x_offset.resolve(text.size) + x; - let mut builder = - KurboPathBuilder::new(face.units_per_em, text.size, dx.to_raw()); + // Shape! + let mut face = fonts.get(face_id); + let buffer = rustybuzz::shape(face.ttf(), tags, buffer); + let infos = buffer.glyph_infos(); + let pos = buffer.glyph_positions(); - let bbox = face.ttf().outline_glyph(GlyphId(glyph.id), &mut builder); - let path = builder.finish(); + // 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]; + let cluster = info.cluster as usize; - x += glyph.x_advance.resolve(text.size); - - // Only do the costly segments intersection test if the line - // intersects the bounding box. - if bbox.map_or(false, |bbox| { - let y_min = -face.to_em(bbox.y_max).resolve(text.size); - let y_max = -face.to_em(bbox.y_min).resolve(text.size); - - offset >= y_min && offset <= y_max - }) { - // Find all intersections of segments with the line. - intersections.extend( - path.segments() - .flat_map(|seg| seg.intersect_line(line)) - .map(|is| Length::raw(line.eval(is.line_t).x)), - ); - } - } - - // When emitting the decorative line segments, we move from left to - // right. The intersections are not necessarily in this order, yet. - intersections.sort(); - - for gap in intersections.chunks_exact(2) { - let l = gap[0] - gap_padding; - let r = gap[1] + gap_padding; - - if start >= end { - break; - } - - if start >= l { - start = r; - continue; - } - - push_segment(start, l); - start = r; - } - - if start < end { - push_segment(start, end); - } - } - - /// Reshape a range of the shaped text, reusing information from this - /// shaping process if possible. - pub fn reshape( - &'a self, - fonts: &mut FontStore, - text_range: Range, - ) -> ShapedText<'a> { - if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) { - let (size, baseline) = measure(fonts, glyphs, self.styles); - Self { - text: Cow::Borrowed(&self.text[text_range]), - dir: self.dir, - styles: self.styles.clone(), - size, - baseline, - glyphs: Cow::Borrowed(glyphs), - } + if info.glyph_id != 0 || !fallback { + // Add the glyph to the shaped output. + // TODO: Don't ignore y_advance and y_offset. + glyphs.push(ShapedGlyph { + face_id, + glyph_id: info.glyph_id as u16, + x_advance: face.to_em(pos[i].x_advance), + x_offset: face.to_em(pos[i].x_offset), + text_index: base + cluster, + safe_to_break: !info.unsafe_to_break(), + is_space: text[cluster ..].chars().next() == Some(' '), + }); } else { - shape(fonts, &self.text[text_range], self.styles.clone(), self.dir) + // 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.glyph_id == 0) { + i += 1; + } + + // Then, determine the start and end text index. + // + // Examples: + // 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: + // Text: h a l i h a l l o + // Glyphs: A _ _ C E + // Clusters: 0 2 4 6 8 + // k=1 i=2 + // + // Right-to-left: + // Text: O L L A H I L A H + // Glyphs: E C _ _ A + // Clusters: 8 6 4 2 0 + // k=2 i=3 + let ltr = dir.is_positive(); + let first = if ltr { k } else { i }; + let start = infos[first].cluster as usize; + let last = if ltr { i.checked_add(1) } else { k.checked_sub(1) }; + let end = last + .and_then(|last| infos.get(last)) + .map_or(text.len(), |info| info.cluster as usize); + + start .. end + }; + + // Recursively shape the tofu sequence with the next family. + shape_segment( + fonts, + glyphs, + base + range.start, + &text[range], + variant, + families.clone(), + first_face, + dir, + tags, + ); + + face = fonts.get(face_id); } + + i += 1; + } +} + +/// Apply tracking to a slice of shaped glyphs. +fn track(glyphs: &mut [ShapedGlyph], tracking: Em) { + if tracking.is_zero() { + return; } - /// Find the subslice of glyphs that represent the given text range if both - /// sides are safe to break. - fn slice_safe_to_break(&self, text_range: Range) -> Option<&[ShapedGlyph]> { - let Range { mut start, mut end } = text_range; - if !self.dir.is_positive() { - std::mem::swap(&mut start, &mut end); + let mut glyphs = glyphs.iter_mut().peekable(); + while let Some(glyph) = glyphs.next() { + if glyphs + .peek() + .map_or(false, |next| glyph.text_index != next.text_index) + { + glyph.x_advance += tracking; } - - let left = self.find_safe_to_break(start, Side::Left)?; - let right = self.find_safe_to_break(end, Side::Right)?; - Some(&self.glyphs[left .. right]) } +} - /// Find the glyph offset matching the text index that is most towards the - /// given side and safe-to-break. - fn find_safe_to_break(&self, text_index: usize, towards: Side) -> Option { - let ltr = self.dir.is_positive(); +/// Measure the size and baseline of a run of shaped glyphs with the given +/// properties. +fn measure( + fonts: &mut FontStore, + glyphs: &[ShapedGlyph], + styles: StyleChain, +) -> (Size, Length) { + let mut width = Length::zero(); + let mut top = Length::zero(); + let mut bottom = Length::zero(); - // Handle edge cases. - let len = self.glyphs.len(); - if text_index == 0 { - return Some(if ltr { 0 } else { len }); - } else if text_index == self.text.len() { - return Some(if ltr { len } else { 0 }); - } + let size = styles.get(TextNode::SIZE).abs; + let top_edge = styles.get(TextNode::TOP_EDGE); + let bottom_edge = styles.get(TextNode::BOTTOM_EDGE); - // Find any glyph with the text index. - let mut idx = self - .glyphs - .binary_search_by(|g| { - let ordering = g.text_index.cmp(&text_index); - if ltr { ordering } else { ordering.reverse() } - }) - .ok()?; + // Expand top and bottom by reading the face's vertical metrics. + let mut expand = |face: &Face| { + top.set_max(face.vertical_metric(top_edge, size)); + bottom.set_max(-face.vertical_metric(bottom_edge, size)); + }; - let next = match towards { - Side::Left => usize::checked_sub, - Side::Right => usize::checked_add, - }; - - // Search for the outermost glyph with the text index. - while let Some(next) = next(idx, 1) { - if self.glyphs.get(next).map_or(true, |g| g.text_index != text_index) { + if glyphs.is_empty() { + // When there are no glyphs, we just use the vertical metrics of the + // first available font. + for family in families(styles) { + if let Some(face_id) = fonts.select(family, variant(styles)) { + expand(fonts.get(face_id)); break; } - idx = next; + } + } else { + for (face_id, group) in glyphs.group_by_key(|g| g.face_id) { + let face = fonts.get(face_id); + expand(face); + + for glyph in group { + width += glyph.x_advance.resolve(size); + } + } + } + + (Size::new(width, top + bottom), top) +} + +/// Add line decorations to a single run of shaped text. +fn decorate( + frame: &mut Frame, + deco: &Decoration, + fonts: &FontStore, + text: &Text, + pos: Point, + width: Length, +) { + let face = fonts.get(text.face_id); + let metrics = match deco.line { + super::STRIKETHROUGH => face.strikethrough, + super::OVERLINE => face.overline, + super::UNDERLINE | _ => face.underline, + }; + + let evade = deco.evade && deco.line != super::STRIKETHROUGH; + let extent = deco.extent.resolve(text.size); + let offset = deco + .offset + .map(|s| s.resolve(text.size)) + .unwrap_or(-metrics.position.resolve(text.size)); + + let stroke = Stroke { + paint: deco.stroke.unwrap_or(text.fill), + thickness: deco + .thickness + .map(|s| s.resolve(text.size)) + .unwrap_or(metrics.thickness.resolve(text.size)), + }; + + let gap_padding = 0.08 * text.size; + let min_width = 0.162 * text.size; + + let mut start = pos.x - extent; + let end = pos.x + (width + 2.0 * extent); + + let mut push_segment = |from: Length, to: Length| { + let origin = Point::new(from, pos.y + offset); + let target = Point::new(to - from, Length::zero()); + + if target.x >= min_width || !evade { + let shape = Shape::stroked(Geometry::Line(target), stroke); + frame.push(origin, Element::Shape(shape)); + } + }; + + if !evade { + push_segment(start, end); + return; + } + + let line = Line::new( + kurbo::Point::new(pos.x.to_raw(), offset.to_raw()), + kurbo::Point::new((pos.x + width).to_raw(), offset.to_raw()), + ); + + let mut x = pos.x; + let mut intersections = vec![]; + + for glyph in text.glyphs.iter() { + let dx = glyph.x_offset.resolve(text.size) + x; + let mut builder = BezPathBuilder::new(face.units_per_em, text.size, dx.to_raw()); + + let bbox = face.ttf().outline_glyph(GlyphId(glyph.id), &mut builder); + let path = builder.finish(); + + x += glyph.x_advance.resolve(text.size); + + // Only do the costly segments intersection test if the line + // intersects the bounding box. + if bbox.map_or(false, |bbox| { + let y_min = -face.to_em(bbox.y_max).resolve(text.size); + let y_max = -face.to_em(bbox.y_min).resolve(text.size); + + offset >= y_min && offset <= y_max + }) { + // Find all intersections of segments with the line. + intersections.extend( + path.segments() + .flat_map(|seg| seg.intersect_line(line)) + .map(|is| Length::raw(line.eval(is.line_t).x)), + ); + } + } + + // When emitting the decorative line segments, we move from left to + // right. The intersections are not necessarily in this order, yet. + intersections.sort(); + + for gap in intersections.chunks_exact(2) { + let l = gap[0] - gap_padding; + let r = gap[1] + gap_padding; + + if start >= end { + break; } - // RTL needs offset one because the left side of the range should be - // exclusive and the right side inclusive, contrary to the normal - // behaviour of ranges. - if !ltr { - idx += 1; + if start >= l { + start = r; + continue; } - self.glyphs[idx].safe_to_break.then(|| idx) + push_segment(start, l); + start = r; + } + + if start < end { + push_segment(start, end); } } -/// A visual side. -enum Side { - Left, - Right, -} - -struct KurboPathBuilder { +/// Builds a kurbo [`BezPath`] for a glyph. +struct BezPathBuilder { path: BezPath, units_per_em: f64, font_size: Length, x_offset: f64, } -impl KurboPathBuilder { +impl BezPathBuilder { fn new(units_per_em: f64, font_size: Length, x_offset: f64) -> Self { Self { path: BezPath::new(), @@ -1075,7 +1091,7 @@ impl KurboPathBuilder { } } -impl OutlineBuilder for KurboPathBuilder { +impl OutlineBuilder for BezPathBuilder { fn move_to(&mut self, x: f32, y: f32) { self.path.move_to(self.p(x, y)); } diff --git a/tests/ref/text/justify.png b/tests/ref/text/justify.png new file mode 100644 index 000000000..26787af9f Binary files /dev/null and b/tests/ref/text/justify.png differ diff --git a/tests/typ/text/justify.typ b/tests/typ/text/justify.typ new file mode 100644 index 000000000..7b8a28299 --- /dev/null +++ b/tests/typ/text/justify.typ @@ -0,0 +1,14 @@ + +--- +#set par(indent: 14pt, spacing: 0pt, leading: 5pt, justify: true) + +This text is justified, meaning that spaces are stretched so that the text +forms as "block" with flush edges at both sides. + +First line indents and hyphenation play nicely with justified text. + +--- +// Test that lines with hard breaks aren't justified. +#set par(justify: true) +A B C \ +D