// SPDX-License-Identifier: MIT OR Apache-2.0 // // The one-Parley-tree-per-IFC shape follows DioxusLabs/blitz commit // d788124ab881f9bb537cb452ec1d837604a374a8, especially // `layout/construct.rs::build_inline_layout_into`. Moli deliberately // keeps the item stream, source mapping, and Parley layout pass-local. // Relative positioning of atomic inline boxes additionally follows Blitz // commit 4a9be930accc971675d5730e4fde3cfa13c3b57e. use std::{ collections::{BTreeMap, HashMap}, fmt::Debug, hash::Hash, ops::Range, }; use parley::{ BreakReason, InlineBox, InlineBoxBidi, InlineBoxKind, Layout, PositionedLayoutItem, TextStyle, }; use taffy::{MaybeResolve as _, Point, Size}; use crate::text_normalization::{TextCharacter, TextTransformState, classify_text_character}; use crate::{ LayoutBoxId, LayoutBoxKind, LayoutWorld, PaintColor, PaintRect, style::{ InlineDirection, InlineTextTransform, InlineUnicodeBidi, InlineVerticalAlign, InlineWhiteSpaceCollapse, LayoutInlineAlignment, }, stylo_to_parley::TextBrush, text::{DocumentLayoutServices, InlineFontMetrics}, }; /// Resolve the relative inset applied after Parley has positioned an atomic /// inline box. Taffy cannot do this itself because atomic IFC children are /// represented as Parley inline objects and their final locations are written /// back after line layout. pub(crate) fn relative_atomic_inset_offset( style: &taffy::Style, containing_block_size: Size, container_direction: InlineDirection, ) -> Point { let inset = taffy::Rect { left: style.inset.left.maybe_resolve( containing_block_size.width, crate::style::resolve_stylo_calc_value, ), right: style.inset.right.maybe_resolve( containing_block_size.width, crate::style::resolve_stylo_calc_value, ), top: style.inset.top.maybe_resolve( containing_block_size.height, crate::style::resolve_stylo_calc_value, ), bottom: style.inset.bottom.maybe_resolve( containing_block_size.height, crate::style::resolve_stylo_calc_value, ), }; Point { x: if container_direction == InlineDirection::Rtl { inset .right .map(|value| -value) .or(inset.left) .unwrap_or(0.0) } else { inset .left .or(inset.right.map(|value| -value)) .unwrap_or(0.0) }, y: inset .top .or(inset.bottom.map(|value| -value)) .unwrap_or(0.0), } } #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct InlineSourceMapEntry { pub(crate) output_range: Range, pub(crate) box_id: LayoutBoxId, pub(crate) source_byte_range: Range, pub(crate) source_utf16_range: Range, } #[derive(Clone, Debug)] pub(crate) struct InlineTextUnit { pub(crate) output_range: Range, pub(crate) style_box: LayoutBoxId, pub(crate) ancestors: Vec, pub(crate) sources: Vec, pub(crate) control: bool, /// A normalized CSS space that can still collapse at a line boundary. pub(crate) collapsible_whitespace: bool, pub(crate) break_spaces_opportunity: bool, } #[derive(Clone, Debug)] pub(crate) struct SourceOrigin { pub(crate) box_id: LayoutBoxId, pub(crate) byte_range: Range, pub(crate) utf16_range: Range, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum InlineObjectRole { Atomic, Float, OutOfFlow, StartEdge, EndEdge, } impl InlineObjectRole { fn parley_bidi(self) -> InlineBoxBidi { match self { Self::Atomic => InlineBoxBidi::Neutral, // Floating and static-position placeholders resolve a neutral // U+FFFC in bidi analysis only. An enclosing inline edge's level // may otherwise carry them across the following directional run. Self::Float | Self::OutOfFlow => InlineBoxBidi::Neutral, // CSS tag boundaries do not add bidi characters. Leading edges // follow the next participant, closing edges the preceding one. Self::StartEdge => InlineBoxBidi::InheritNext, Self::EndEdge => InlineBoxBidi::InheritPrevious, } } } #[derive(Clone, Debug)] pub(crate) struct InlineObject { pub(crate) box_id: LayoutBoxId, pub(crate) role: InlineObjectRole, pub(crate) ancestors: Vec, /// The object's own computed `vertical-align`. Structural ancestor shifts /// are applied by the per-line inline box-state tree. pub(crate) vertical_align: InlineVerticalAlign, } /// Used inline-edge dimensions for one numeric layout probe. Margins can /// create a line, but only border/padding retain an empty inline's line height /// in quirks mode. #[derive(Clone, Copy, Debug, Default)] pub(crate) struct InlineEdgeContribution { pub(crate) creates_line: bool, pub(crate) has_border_or_padding: bool, } /// Pass-owned metadata for one non-atomic inline box flattened into Parley. /// /// Parley owns shaping and inline-axis breaking, while this hierarchy restores /// the box states required by CSS line layout. It mirrors Blink's /// `InlineBoxState`: every inline keeps its own font strut, parent, and /// `vertical-align` instead of composing all ancestors onto each glyph run. #[derive(Clone, Copy, Debug)] pub(crate) struct InlineStructuralBox { pub(crate) box_id: LayoutBoxId, pub(crate) parent: LayoutBoxId, pub(crate) vertical_align: InlineVerticalAlign, pub(crate) strut: Option, pub(crate) include_used_font_metrics: bool, } #[derive(Debug)] pub(crate) struct InlineFormattingContext { /// The actual whitespace-processed text supplied to the shaper. pub(crate) text: String, pub(crate) root_style: LayoutBoxId, /// Reusable Parley layout for intrinsic and final-width probes. Line /// breaking replaces only Parley's line output while retaining the shaped /// runs, clusters, glyphs, and their allocations, so probes must not clone /// the complete shaped paragraph. pub(crate) measurement_layout: Option>, /// The accepted `PerformLayout` result consumed by paint and CSSOM. This is /// kept separate from the reusable measurement layout so a later intrinsic /// probe cannot overwrite the last accepted line layout. pub(crate) laid_out: Option>, /// Pass-local memo for intrinsic widths of a pure-text paragraph. Numeric /// positioning buffers intentionally remain probe-local: retaining their /// capacity on every IFC increases the peak footprint of the fresh layout /// world more than it saves allocator traffic. pub(crate) content_widths: InlineContentWidthsMemo, pub(crate) text_units: Vec, pub(crate) source_map: Vec, pub(crate) selection: Option, pub(crate) objects: Vec, /// Primary-font metrics indexed by Parley's style index. Glyph runs may /// use fallback fonts, but their CSSOM rectangles and text-edge alignment /// retain these primary metrics. Only `line-height: normal` additionally /// unites the used font's metrics into the enclosing line box. pub(crate) font_metrics: Vec>, /// The IFC owner's primary-font strut used while reconstructing CSS line /// baselines. Fallback glyph fonts must not replace its line height or /// x-height. pub(crate) parent_strut: Option, /// Quirks and limited-quirks omit the block's strut and empty, undecorated /// inline struts from line height. Keep font metrics for alignment/paint. pub(crate) uses_quirks_line_height: bool, pub(crate) root_includes_used_font_metrics: bool, /// Direct structural parent of each shaped style. Including this identity /// in style deduplication prevents glyph runs from crossing a box-state /// boundary even when their paint/font properties are otherwise equal. pub(crate) style_parents: Vec, pub(crate) structural_boxes: Vec, pub(crate) line_placements: Vec, pub(crate) fragments: InlineFragments, } #[derive(Debug, Default)] pub(crate) struct InlineContentWidthsMemo { entry: Option, #[cfg(test)] hits: usize, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] struct InlineContentWidthsCacheKey { indent_bits: u32, each_line: bool, hanging: bool, } impl InlineContentWidthsCacheKey { fn new(indent: f32, options: parley::IndentOptions) -> Self { Self { indent_bits: indent.to_bits(), each_line: options.each_line, hanging: options.hanging, } } } #[derive(Clone, Copy, Debug)] struct InlineContentWidthsCache { key: InlineContentWidthsCacheKey, widths: parley::ContentWidths, } impl InlineContentWidthsMemo { /// Reuses intrinsic widths only when the IFC contains shaped text and no /// inline object whose width can change between Taffy probes. /// /// Parley deliberately recalculates content widths on every call. For a /// pure-text IFC, however, the scanned items and cluster advances are /// immutable for this fresh layout pass. The key includes text-indent so /// this adapter remains correct if Parley starts incorporating indentation /// into intrinsic widths in a future release. pub(crate) fn content_widths_for_probe( &mut self, layout: &Layout, indent: f32, options: parley::IndentOptions, ) -> parley::ContentWidths { if layout.inline_boxes().len() != 0 { return layout.calculate_content_widths(); } let key = InlineContentWidthsCacheKey::new(indent, options); if let Some(cached) = self.entry.filter(|cached| cached.key == key) { #[cfg(test)] { self.hits += 1; } return cached.widths; } let widths = layout.calculate_content_widths(); self.entry = Some(InlineContentWidthsCache { key, widths }); widths } } /// Restores the reusable Parley paragraph to its shaped, unbroken state before /// another inline measurement probe. /// /// `text-align: justify` mutates whitespace cluster advances. Parley undoes /// those adjustments when a new line breaker is created, so this reset must /// happen before intrinsic content widths are read for the next probe. Dropping /// the breaker immediately also clears the previous line output while retaining /// its vector capacity and all shaped runs, clusters, and glyphs. pub(crate) fn reset_inline_layout_for_probe(layout: &mut Layout) { drop(layout.break_lines()); } /// Place CSS decorations around visual fragments after bidi reordering. /// /// Edge widths still participate in logical line breaking. Their visual slots /// follow CSS direction and descendant fragments, independently of the text's /// resolved bidi levels. Process descendants first so nested decorations are /// included when placing their parent's physical edges. pub(crate) fn position_inline_edges( world: &LayoutWorld, context: &InlineFormattingContext, layout: &mut Layout, ) { if !context.objects.iter().any(|object| { matches!( object.role, InlineObjectRole::StartEdge | InlineObjectRole::EndEdge ) }) { return; } for line_index in 0..layout.len() { let line = layout.get(line_index).expect("known line"); let mut ancestors = vec![Vec::new(); line.len()]; for run in line.runs() { ancestors[run.index()] = overlapping_output_ranges(&context.text_units, &run.text_range()) .iter() .filter(|unit| !unit.control) .flat_map(|unit| unit.ancestors.iter().copied()) .collect(); } let mut edges = BTreeMap::>::new(); for (slot, inline_box) in line.inline_box_indices() { let Some(object) = context.object(inline_box.id) else { continue; }; ancestors[slot] = object.ancestors.clone(); if matches!( object.role, InlineObjectRole::StartEdge | InlineObjectRole::EndEdge ) { let physical_left = (object.role == InlineObjectRole::StartEdge) == (world.boxes[object.box_id.index()].style.direction() == InlineDirection::Ltr); edges .entry(object.box_id.index()) .or_default() .push((slot, physical_left)); } } let mut edges = edges.into_iter().collect::>(); edges.sort_by_key(|(_, slots)| std::cmp::Reverse(ancestors[slots[0].0].len())); let mut order = (0..line.len()).collect::>(); for (box_index, mut slots) in edges { let original_position = order .iter() .position(|slot| slots.iter().any(|(edge, _)| edge == slot)) .expect("edge on this line"); order.retain(|slot| !slots.iter().any(|(edge, _)| edge == slot)); let box_id = LayoutBoxId::from_index(box_index); let first = order .iter() .position(|slot| ancestors[*slot].contains(&box_id)); let last = order .iter() .rposition(|slot| ancestors[*slot].contains(&box_id)); slots.sort_by_key(|(_, left)| !left); if let (Some(first), Some(last)) = (first, last) { if let Some((slot, _)) = slots.iter().find(|(_, left)| !left) { order.insert(last + 1, *slot); } if let Some((slot, _)) = slots.iter().find(|(_, left)| *left) { order.insert(first, *slot); } } else { let position = original_position.min(order.len()); order.splice(position..position, slots.iter().map(|(slot, _)| *slot)); } } if order.iter().enumerate().any(|(index, &slot)| index != slot) { layout.reorder_line_items(line_index, &order); } } } #[derive(Clone, Copy, Debug)] pub(crate) struct InlineStrutMetrics { line_ascent: f32, line_descent: f32, text_ascent: f32, text_descent: f32, x_height: f32, } #[derive(Clone, Debug, PartialEq)] pub(crate) enum InlineSelection { Range(Range), Caret { offset: usize, color: PaintColor }, } #[derive(Clone, Debug, PartialEq)] pub(crate) struct InlineLinePlacement { pub(crate) line_index: usize, pub(crate) rect: PaintRect, pub(crate) baseline: f32, /// CSS phantom line boxes retain positions for their inline descendants, /// but do not contribute height, baselines, or block margin-collapse /// barriers. pub(crate) phantom: bool, content_offset: f32, item_offsets: Vec, glyph_offsets: Vec, box_block_placements: Vec, } /// Numeric line-box result shared by intrinsic measurement and final inline /// placement. Intrinsic probes need these four values, but do not need the /// per-item, per-glyph, and per-box vectors stored by [`InlineLinePlacement`]. #[derive(Clone, Copy, Debug, Default, PartialEq)] pub(crate) struct InlineLineMetrics { pub(crate) line_expansion: f32, pub(crate) first_baseline: Option, pub(crate) last_baseline: Option, pub(crate) has_non_phantom_line: bool, } impl InlineLinePlacement { pub(crate) fn item_offset(&self, item_index: usize) -> f32 { self.item_offsets .get(item_index) .copied() .unwrap_or_default() } fn glyph_offset(&self, run_index: usize, style_index: usize) -> f32 { self.glyph_offsets .iter() .find(|offset| offset.run_index == run_index && offset.style_index == style_index) .map_or(self.content_offset, |offset| offset.offset) } pub(crate) fn translate_block_axis(&mut self, offset: f32) { self.rect.y += offset; self.baseline += offset; self.content_offset += offset; for item_offset in &mut self.item_offsets { *item_offset += offset; } for glyph_offset in &mut self.glyph_offsets { glyph_offset.offset += offset; } for box_placement in &mut self.box_block_placements { box_placement.top += offset; } } } #[derive(Clone, Copy, Debug, PartialEq)] struct InlineGlyphOffset { run_index: usize, style_index: usize, offset: f32, } #[derive(Clone, Copy, Debug, PartialEq)] struct InlineBoxBlockPlacement { box_id: LayoutBoxId, top: f32, height: f32, } impl InlineFormattingContext { pub(crate) fn object(&self, id: u64) -> Option<&InlineObject> { usize::try_from(id) .ok() .and_then(|index| self.objects.get(index)) } fn style_parent(&self, index: usize) -> LayoutBoxId { self.style_parents .get(index) .copied() .unwrap_or(self.root_style) } pub(crate) fn style_is_within_box(&self, index: usize, target: LayoutBoxId) -> bool { let mut current = Some(self.style_parent(index)); while let Some(box_id) = current { if box_id == target { return true; } current = self.structural_box(box_id).map(|state| state.parent); } false } fn box_includes_used_font_metrics(&self, box_id: LayoutBoxId) -> bool { if box_id == self.root_style { return self.root_includes_used_font_metrics; } self.structural_box(box_id) .is_some_and(|state| state.include_used_font_metrics) } fn structural_box(&self, id: LayoutBoxId) -> Option<&InlineStructuralBox> { self.structural_boxes .iter() .find(|state| state.box_id == id) } } #[derive(Clone, Debug, Default)] pub(crate) struct InlineFragments { pub(crate) lines: Vec, pub(crate) text: Vec, pub(crate) boxes: Vec, } #[derive(Clone, Copy, Debug, PartialEq)] pub(crate) struct InlineLineFragment { pub(crate) line_index: usize, pub(crate) rect: PaintRect, /// Included in `rect` for CSSOM and painting; excluded from scrolling on demand. pub(crate) hanging_advance: f32, /// Conservative glyph/decoration/shadow ink used only by capture culling. /// CSSOM line geometry continues to use `rect`. pub(crate) paint_bounds: InlinePaintBounds, pub(crate) baseline: f32, } impl InlineLineFragment { pub(crate) fn scrollable_rect(&self, rtl: bool) -> PaintRect { let mut rect = self.rect; let hanging = self.hanging_advance.min(rect.width); rect.width -= hanging; if rtl { rect.x += hanging; } rect } } #[derive(Clone, Copy, Debug, Default, PartialEq)] pub(crate) enum InlinePaintBounds { #[default] Empty, Bounded(PaintRect), Unbounded, } impl InlinePaintBounds { fn include(&mut self, rect: PaintRect) { *self = match *self { Self::Empty => Self::Bounded(rect), Self::Bounded(current) => Self::Bounded(current.union(rect)), Self::Unbounded => Self::Unbounded, }; } } #[derive(Clone, Debug, PartialEq)] pub(crate) struct InlineSourceFragment { pub(crate) line_index: usize, pub(crate) box_id: LayoutBoxId, pub(crate) source_byte_range: Range, pub(crate) source_utf16_range: Range, pub(crate) rtl: bool, pub(crate) rect: PaintRect, } #[derive(Clone, Copy, Debug, PartialEq)] pub(crate) struct InlineBoxFragment { pub(crate) line_index: usize, pub(crate) box_id: LayoutBoxId, pub(crate) rect: PaintRect, pub(crate) has_start_edge: bool, pub(crate) has_end_edge: bool, } pub(crate) fn build_inline_fragments( context: &InlineFormattingContext, layout: &Layout, line_placements: &[InlineLinePlacement], ) -> InlineFragments { // Binary overlap lookup relies on both endpoints being monotonic. Validate // each immutable normalization product once, rather than rescanning the // complete maps for every visual glyph cluster in debug and test builds. debug_assert!(output_ranges_are_monotonic(&context.text_units)); debug_assert!(output_ranges_are_monotonic(&context.source_map)); let mut fragments = InlineFragments::default(); let mut box_fragments = HashMap::<(usize, usize), FragmentAccumulator>::new(); let mut source_fragments = HashMap::::new(); let style_paint_outsets = layout .styles() .iter() .map(text_style_paint_outsets) .collect::>(); for (line_index, line) in layout.lines().enumerate() { let metrics = line.metrics(); let placement = line_placements .get(line_index) .filter(|placement| placement.line_index == line_index); let line_rect = placement.map_or_else( || { PaintRect::new( metrics.inline_min_coord + metrics.offset, metrics.block_min_coord, metrics.advance, (metrics.block_max_coord - metrics.block_min_coord).max(0.0), ) }, |placement| placement.rect, ); fragments.lines.push(InlineLineFragment { line_index, rect: line_rect, hanging_advance: metrics.hanging_advance, paint_bounds: context .selection .as_ref() .map_or(InlinePaintBounds::Empty, |_| { InlinePaintBounds::Bounded(line_rect) }), baseline: placement.map_or(metrics.baseline, |placement| placement.baseline), }); if let Some(placement) = placement { for box_placement in &placement.box_block_placements { box_fragments .entry((box_placement.box_id.index(), line_index)) .or_default() .include_block_axis(box_placement.top, box_placement.height); } } for (cluster, cluster_offset) in line.positioned_visual_clusters() { let run = cluster.run(); let run_metrics = run.font_metrics(); let range = cluster.text_range(); let style_index = usize::from(cluster.style_index()); let vertical_offset = placement.map_or(0.0, |placement| { placement.glyph_offset(run.index(), style_index) }); // CSSOM text quads use the typographic font box. CSS // `line-height` and its leading enlarge the containing line // box, but not LayoutText/Range geometry. This matches // Blink's InlineBoxState::text_top/text_height contract. let font_metrics = context .font_metrics .get(style_index) .copied() .flatten() .map(|metrics| inline_strut_metrics(metrics, true)); let ascent = font_metrics.map_or(run_metrics.ascent, |metrics| metrics.text_ascent); let descent = font_metrics.map_or(run_metrics.descent, |metrics| metrics.text_descent); let rect = PaintRect::new( metrics.inline_min_coord + cluster_offset, metrics.baseline - ascent + vertical_offset, cluster.advance().max(0.0), (ascent + descent).max(0.0), ); if let Some(style) = layout.styles().get(style_index) && style.brush.paint { // Parley exposes typographic cluster boxes rather than // exact outline bounds. A two-em guard is deliberately // conservative for italic/color-glyph overhang, while the // style sidecar adds CSS stroke, shadow, and decoration // ink. This work happens once, alongside final // fragment materialization, not during every paint. let glyph_guard = run.font_size().max(0.0) * 2.0 + 1.0; let line = &mut fragments.lines[line_index]; match style_paint_outsets.get(style_index).copied().flatten() { Some(outsets) => line.paint_bounds.include(outsets.outset(rect, glyph_guard)), None => line.paint_bounds = InlinePaintBounds::Unbounded, } } for unit in overlapping_output_ranges(&context.text_units, &range) { for ancestor in &unit.ancestors { box_fragments .entry((ancestor.index(), line_index)) .or_default() .include_inline_axis(rect.x, rect.width); } } for source in overlapping_output_ranges(&context.source_map, &range) { source_fragments .entry(SourceFragmentKey { box_index: source.box_id.index(), source_byte_start: source.source_byte_range.start, source_byte_end: source.source_byte_range.end, source_utf16_start: source.source_utf16_range.start, source_utf16_end: source.source_utf16_range.end, line_index, rtl: cluster.is_rtl(), }) .or_default() .include(rect); } } for (item_index, item) in line.items().enumerate() { let PositionedLayoutItem::InlineBox(positioned) = item else { continue; }; let Some(object) = context.object(positioned.id) else { continue; }; let rect = (object.role == InlineObjectRole::Atomic).then(|| { PaintRect::new( positioned.x, positioned.y + placement.map_or(0.0, |placement| placement.item_offset(item_index)), positioned.width.max(0.0), positioned.height.max(0.0), ) }); for ancestor in &object.ancestors { let accumulator = box_fragments .entry((ancestor.index(), line_index)) .or_default(); if let Some(rect) = rect { accumulator.include_inline_axis(rect.x, rect.width); } else if matches!( object.role, InlineObjectRole::StartEdge | InlineObjectRole::EndEdge ) { accumulator.include_inline_axis(positioned.x, positioned.width); } } match object.role { InlineObjectRole::StartEdge | InlineObjectRole::EndEdge => { let accumulator = box_fragments .entry((object.box_id.index(), line_index)) .or_default(); accumulator.include_inline_axis(positioned.x, positioned.width); accumulator.has_start_edge |= object.role == InlineObjectRole::StartEdge; accumulator.has_end_edge |= object.role == InlineObjectRole::EndEdge; } InlineObjectRole::Atomic | InlineObjectRole::Float | InlineObjectRole::OutOfFlow => {} } } } let mut box_fragments = box_fragments.into_iter().collect::>(); box_fragments.sort_unstable_by_key(|(key, _)| *key); fragments.boxes = box_fragments .into_iter() .filter_map(|((box_index, line_index), accumulator)| { let line_rect = fragments.lines.get(line_index)?.rect; Some(InlineBoxFragment { line_index, box_id: LayoutBoxId::from_index(box_index), rect: accumulator.rect(line_rect)?, has_start_edge: accumulator.has_start_edge, has_end_edge: accumulator.has_end_edge, }) }) .collect(); let mut source_fragments = source_fragments.into_iter().collect::>(); source_fragments.sort_unstable_by_key(|(key, _)| *key); fragments.text = source_fragments .into_iter() .filter_map(|(key, accumulator)| { let line_rect = fragments.lines.get(key.line_index)?.rect; Some(InlineSourceFragment { line_index: key.line_index, box_id: LayoutBoxId::from_index(key.box_index), source_byte_range: key.source_byte_start..key.source_byte_end, source_utf16_range: key.source_utf16_start..key.source_utf16_end, rtl: key.rtl, rect: accumulator.rect(line_rect)?, }) }) .collect(); fragments } #[derive(Clone, Copy, Debug, Default)] struct TextPaintOutsets { top: f32, right: f32, bottom: f32, left: f32, } impl TextPaintOutsets { fn outset(self, rect: PaintRect, guard: f32) -> PaintRect { let top = self.top.max(0.0) + guard; let right = self.right.max(0.0) + guard; let bottom = self.bottom.max(0.0) + guard; let left = self.left.max(0.0) + guard; PaintRect::new( rect.x - left, rect.y - top, (rect.width + left + right).max(0.0), (rect.height + top + bottom).max(0.0), ) } } fn text_style_paint_outsets(style: &parley::layout::Style) -> Option { let mut outsets = TextPaintOutsets::default(); if let Some(stroke) = style.brush.stroke { if !stroke.width.is_finite() { return None; } // Include the outer half of the stroke and its possible miter joins. // Transparent strokes still contribute to background-clip:text masks. let outset = crate::PaintTextStroke::ink_outset(stroke.width, 0.0); if !outset.is_finite() { return None; } outsets = TextPaintOutsets { top: outset, right: outset, bottom: outset, left: outset, }; } for shadow in style .brush .shadows .iter() .filter(|shadow| shadow.color.alpha > 0.0) { if !shadow.offset.x.is_finite() || !shadow.offset.y.is_finite() || !shadow.blur_radius.is_finite() { return None; } let blur = shadow.blur_radius.max(0.0) * 4.0 + 1.0; outsets.left = outsets.left.max(blur - shadow.offset.x); outsets.right = outsets.right.max(blur + shadow.offset.x); outsets.top = outsets.top.max(blur - shadow.offset.y); outsets.bottom = outsets.bottom.max(blur + shadow.offset.y); } let decoration = style.brush.decoration; if decoration.underline || decoration.overline || decoration.line_through { // Normal decoration ink remains inside the guarded typographic box. // Authored underline offsets can move it arbitrarily far away. let displaced = decoration.underline_offset.unwrap_or_default().abs() + decoration.thickness.unwrap_or(1.0).max(0.0) * 3.0 + 1.0; outsets.top = outsets.top.max(displaced); outsets.bottom = outsets.bottom.max(displaced); } Some(outsets) } /// Breaks a shared IFC text stream while preserving CSS `break-spaces` /// trailing-space semantics that Parley 0.10 does not model directly. pub(crate) fn break_inline_lines( context: &InlineFormattingContext, layout: &mut Layout, max_advance: Option, ) { layout.break_all_lines(max_advance); let Some(width) = max_advance.filter(|width| width.is_finite() && *width > 0.0) else { return; }; if !context .text_units .iter() .any(|unit| unit.break_spaces_opportunity) { return; } // Parley hangs an overflowing U+0020 on the preceding line. That is // correct for normal whitespace but not for `break-spaces`, where every // preserved space occupies line width. Identify only the lines where the // initial break actually overflowed through trailing whitespace. let tolerance = width.abs().max(1.0) * f32::EPSILON * 8.0; let adjust_lines = layout .lines() .map(|line| { let metrics = line.metrics(); let line_range = line.text_range(); metrics.hanging_advance > 0.0 && metrics.advance > width + tolerance && overlapping_output_ranges(&context.text_units, &line_range) .iter() .any(|unit| unit.break_spaces_opportunity) }) .collect::>(); if !adjust_lines.iter().any(|adjust| *adjust) { return; } // Moving the affected line width one representable step inward makes the // last fitting preserved space use Parley's normal overflowing-space // commit. Restore the real CSS width on every committed line so alignment // and fragments still observe the containing block, not the breaker shim. let adjusted_width = (width - tolerance).max(0.0); let mut breaker = layout.break_lines(); breaker.state_mut().set_layout_max_advance(width); let mut line_index = 0; let mut use_normal_breaking = false; while !breaker.is_done() { let line_width = if adjust_lines.get(line_index).copied().unwrap_or(false) { adjusted_width } else { width }; breaker.state_mut().set_line_max_advance(line_width); match breaker.break_next() { Some(parley::YieldData::LineBreak(_)) => { breaker.set_prior_line_width(width); line_index += 1; } Some( parley::YieldData::MaxHeightExceeded(_) | parley::YieldData::InlineBoxBreak(_), ) => { // Neither condition is produced by Moli's rectangular // IFC input. Fall back to the already supported normal // breaker instead of looping or publishing a partial layout. use_normal_breaking = true; break; } None => break, } } breaker.finish(); if use_normal_breaking { layout.break_all_lines(Some(width)); } } /// Reads Parley's line items together with their CSS content contribution. /// Parley retains line-edge spaces for positioning and selection. Collapse /// their contribution here before resolving vertical metrics, while keeping /// every item in the same order for painting and fragment geometry. fn line_items_with_content<'a>( context: &'a InlineFormattingContext, layout: &'a Layout, line: &parley::Line<'a, TextBrush>, ) -> impl Iterator, bool)> + 'a { let has_content = |item: &PositionedLayoutItem<'_, TextBrush>| match item { PositionedLayoutItem::GlyphRun(glyph_run) => { glyph_run.style().brush.paint && glyph_run.glyphs().next().is_some() } PositionedLayoutItem::InlineBox(positioned) => context .object(positioned.id) .is_some_and(|object| object.role == InlineObjectRole::Atomic), }; let only_collapsible_spaces = |item: &PositionedLayoutItem<'_, TextBrush>| match item { PositionedLayoutItem::GlyphRun(glyph_run) => { glyph_run_is_collapsible_whitespace(context, glyph_run) } PositionedLayoutItem::InlineBox(_) => false, }; // CSS whitespace contribution follows logical input order, before bidi // reordering. Parley's visual item order can put an interior space outside // the two atomic objects surrounding it in the logical stream. let logical_range = |item: &PositionedLayoutItem<'_, TextBrush>| match item { PositionedLayoutItem::GlyphRun(glyph_run) => glyph_run .run() .clusters() .filter(|cluster| std::ptr::eq(cluster.style(), glyph_run.style())) .map(|cluster| cluster.text_range()) .reduce(|left, right| left.start.min(right.start)..left.end.max(right.end)), PositionedLayoutItem::InlineBox(positioned) => usize::try_from(positioned.id) .ok() .and_then(|index| layout.inline_boxes().nth(index)) .map(|object| object.index..object.index), }; let mut content_range: Option> = None; if context.uses_quirks_line_height { for item in line.items() { if has_content(&item) && !only_collapsible_spaces(&item) && let Some(range) = logical_range(&item) { content_range = Some(content_range.map_or(range.clone(), |previous| { previous.start.min(range.start)..previous.end.max(range.end) })); } } } line.items().map(move |item| { let interior = || { content_range.as_ref().is_some_and(|content| { logical_range(&item) .is_some_and(|range| range.start >= content.start && range.end <= content.end) }) }; let contributes = has_content(&item) && (!context.uses_quirks_line_height || !only_collapsible_spaces(&item) || interior()); (item, contributes) }) } fn glyph_run_is_collapsible_whitespace( context: &InlineFormattingContext, glyph_run: &parley::GlyphRun<'_, TextBrush>, ) -> bool { let mut found = false; let only_spaces = glyph_run .run() .clusters() .filter(|cluster| std::ptr::eq(cluster.style(), glyph_run.style())) .all(|cluster| { found = true; let units = overlapping_output_ranges(&context.text_units, &cluster.text_range()); !units.is_empty() && units.iter().all(|unit| unit.collapsible_whitespace) }); found && only_spaces } /// Builds the pass-local vertical placement sidecar that Parley 0.10 does not /// provide for CSS `vertical-align`. The sidecar leaves Parley's shaped data /// immutable and applies the same offsets to glyph projection, atomic boxes, /// out-of-flow static positions, and fragment geometry. pub(crate) fn measure_inline_lines( context: &InlineFormattingContext, layout: &Layout, atomic_baseline_ascents: &[Option], structural_edge_contributions: &[InlineEdgeContribution], float_line_clearances: &[f32], ) -> InlineLineMetrics { resolve_inline_lines( context, layout, atomic_baseline_ascents, structural_edge_contributions, float_line_clearances, None, ) } pub(crate) fn build_inline_line_placements( context: &InlineFormattingContext, layout: &Layout, atomic_baseline_ascents: &[Option], structural_edge_contributions: &[InlineEdgeContribution], float_line_clearances: &[f32], ) -> (Vec, InlineLineMetrics) { let mut placements = Vec::with_capacity(layout.lines().len()); let metrics = resolve_inline_lines( context, layout, atomic_baseline_ascents, structural_edge_contributions, float_line_clearances, Some(&mut placements), ); (placements, metrics) } fn resolve_inline_lines( context: &InlineFormattingContext, layout: &Layout, atomic_baseline_ascents: &[Option], structural_edge_contributions: &[InlineEdgeContribution], float_line_clearances: &[f32], mut placements: Option<&mut Vec>, ) -> InlineLineMetrics { let mut result = InlineLineMetrics::default(); let mut preceding_adjustment = 0.0; let mut unadjusted_line_top = 0.0; for (line_index, line) in layout.lines().enumerate() { let metrics = line.metrics(); let raw_top = unadjusted_line_top; let raw_bottom = raw_top + metrics.line_height.max(0.0); let mut geometries = line_items_with_content(context, layout, &line) .map(|(item, contributes_to_line)| match item { PositionedLayoutItem::GlyphRun(glyph_run) => { let run = glyph_run.run(); let run_metrics = run.font_metrics(); let paint = glyph_run.style().brush.paint; let style_index = glyph_run .glyphs() .next() .map(|_| usize::from(glyph_run.style_index())); let structural_parent = style_index.map_or(context.root_style, |index| context.style_parent(index)); let primary_strut = style_index .and_then(|index| context.font_metrics.get(index).copied().flatten()) .map(|metrics| inline_strut_metrics(metrics, true)); let bounds = glyph_line_bounds( primary_strut, run_metrics, run.line_height(), context.box_includes_used_font_metrics(structural_parent), ); InlineItemVerticalGeometry { bounds, initial_top: glyph_run.baseline() + bounds.top, structural_parent, object_index: None, vertical_align: InlineVerticalAlign::default(), // Parley may expose an empty root-style run next to // float/out-of-flow placeholders. It carries the font // style but no glyph geometry and is not in-flow line // content by itself. contributes_to_line, creates_line: contributes_to_line, glyph_key: if paint { style_index.map(|index| (run.index(), index)) } else { None }, anchor: LineVerticalAnchor::Root, relative_offset: 0.0, } } PositionedLayoutItem::InlineBox(positioned) => { let object = context.object(positioned.id); let object_index = usize::try_from(positioned.id).ok(); let internal_baseline_ascent = object .filter(|object| object.role == InlineObjectRole::Atomic) .and(object_index) .and_then(|index| atomic_baseline_ascents.get(index).copied().flatten()); let is_atomic = object.is_some_and(|object| object.role == InlineObjectRole::Atomic); let baseline_ascent = internal_baseline_ascent .or_else(|| is_atomic.then_some(positioned.height)) .unwrap_or_default(); InlineItemVerticalGeometry { bounds: if is_atomic { InlineVerticalBounds { top: -baseline_ascent, bottom: positioned.height - baseline_ascent, } } else { InlineVerticalBounds::ZERO }, initial_top: positioned.y, structural_parent: object .and_then(|object| object.ancestors.last().copied()) .unwrap_or(context.root_style), object_index, vertical_align: if is_atomic { object .map(|object| object.vertical_align) .unwrap_or_default() } else { InlineVerticalAlign::default() }, contributes_to_line, creates_line: object.is_some_and(|object| match object.role { InlineObjectRole::Atomic => true, InlineObjectRole::StartEdge | InlineObjectRole::EndEdge => object_index .and_then(|index| structural_edge_contributions.get(index)) .is_some_and(|edge| edge.creates_line), InlineObjectRole::Float | InlineObjectRole::OutOfFlow => false, }), glyph_key: None, anchor: LineVerticalAnchor::Root, relative_offset: 0.0, } } }) .collect::>(); // Parley keeps forced breaks as clusters without positioned glyphs. // In quirks mode their metrics are a fallback for their own empty box, // resolved after that box's content rather than for the whole line. let line_break = if context.uses_quirks_line_height && line.break_reason() == BreakReason::Explicit { line_break_metrics(context, layout, &line) } else { None }; let mut states = build_line_inline_box_states( context, layout, line.text_range(), &geometries, line_break.map(|(box_id, _)| box_id), ); let mut state_indices = BTreeMap::new(); for (index, state) in states.iter().enumerate() { state_indices.insert(state.box_id.index(), index); } let empty_caret = context.text.is_empty() && matches!(context.selection, Some(InlineSelection::Caret { .. })); let phantom = css_line_is_phantom( line.break_reason(), geometries.iter().any(|geometry| geometry.creates_line), ) && !empty_caret; for state in &mut states { state.parent = state_indices.get(&state.parent_box.index()).copied(); state.alignment.anchor = state .parent .map_or(LineVerticalAnchor::Root, LineVerticalAnchor::State); } for geometry in &mut geometries { let box_id = geometry .edge(context) .map_or(geometry.structural_parent, |object| object.box_id); geometry.anchor = state_indices .get(&box_id.index()) .copied() .map_or(LineVerticalAnchor::Root, LineVerticalAnchor::State); } let line_break = line_break.map(|(box_id, bounds)| { let anchor = state_indices .get(&box_id.index()) .copied() .map_or(LineVerticalAnchor::Root, LineVerticalAnchor::State); (anchor, bounds) }); let fallback_root_bounds = InlineVerticalBounds { top: metrics.block_min_coord - metrics.baseline, bottom: metrics.block_max_coord - metrics.baseline, }; let mut root_bounds = (!phantom && !context.uses_quirks_line_height).then(|| { context .parent_strut .map_or(fallback_root_bounds, InlineVerticalBounds::from_strut) }); for state in &mut states { state.line_contribution = (!phantom && !context.uses_quirks_line_height && state.has_strut_content) .then_some(state.strut) .flatten() .map(InlineVerticalBounds::from_strut); } // One pending list per structural target plus one for the root line // box. Top/bottom descendants are resolved only after the target's // other aligned descendants have established its subtree metrics. let root_pending_index = states.len(); let mut pending = vec![Vec::::new(); states.len() + 1]; for (item_index, geometry) in geometries.iter_mut().enumerate() { // Text supplies its own strut through glyph_line_bounds below. // An empty inline only contributes if this fragment has used // inline-axis border/padding; margin alone is insufficient. if geometry .object_index .and_then(|index| structural_edge_contributions.get(index)) .is_some_and(|edge| edge.has_border_or_padding) && let LineVerticalAnchor::State(index) = geometry.anchor && let Some(strut) = states[index].strut { include_in_parent( InlineVerticalBounds::from_strut(strut), Some(index), &mut states, &mut root_bounds, ); } if !geometry.contributes_to_line { continue; } let parent = match geometry.anchor { LineVerticalAnchor::State(index) => Some(index), LineVerticalAnchor::Root => None, }; if matches!( geometry.vertical_align.kind, LayoutInlineAlignment::Top | LayoutInlineAlignment::Bottom ) { let target = nearest_top_or_bottom_target(&states, parent).unwrap_or(root_pending_index); pending[target].push(PendingLineAlignment { member: PendingLineMember::Item(item_index), bounds: geometry.bounds, vertical_align: geometry.vertical_align, }); continue; } let offset = non_edge_vertical_offset( geometry.vertical_align, alignment_reference(context, &states, parent), geometry.bounds, ); geometry.relative_offset = offset; include_in_parent( geometry.bounds.shifted(offset), parent, &mut states, &mut root_bounds, ); } let mut state_order = (0..states.len()).collect::>(); state_order.sort_by_key(|index| std::cmp::Reverse(states[*index].depth)); for state_index in state_order.iter().copied() { let target_pending = std::mem::take(&mut pending[state_index]); let mut target_metrics = states[state_index].line_contribution.take(); resolve_pending_alignments( target_pending, LineVerticalAnchor::State(state_index), &mut target_metrics, &mut states, &mut geometries, ); states[state_index].line_contribution = target_metrics.or_else(|| { line_break .filter(|(anchor, _)| *anchor == LineVerticalAnchor::State(state_index)) .map(|(_, bounds)| bounds) }); let parent = states[state_index].parent; let vertical_align = states[state_index].vertical_align; // Empty boxes still have a position. Text-edge alignments activate // a zero-sized participant, as Blink's pending alignment does; // length/baseline/middle shifts do not create a height operand. if matches!( vertical_align.kind, LayoutInlineAlignment::TextTop | LayoutInlineAlignment::TextBottom ) { states[state_index] .line_contribution .get_or_insert(InlineVerticalBounds::ZERO); } let state_bounds = states[state_index] .line_contribution .unwrap_or(InlineVerticalBounds::ZERO); if matches!( vertical_align.kind, LayoutInlineAlignment::Top | LayoutInlineAlignment::Bottom ) { let target = nearest_top_or_bottom_target(&states, parent).unwrap_or(root_pending_index); pending[target].push(PendingLineAlignment { member: PendingLineMember::State(state_index), bounds: state_bounds, vertical_align, }); continue; } let offset = non_edge_vertical_offset( vertical_align, alignment_reference(context, &states, parent), state_bounds, ); states[state_index].alignment.relative_offset = offset; if let Some(contribution) = states[state_index].line_contribution { include_in_parent( contribution.shifted(offset), parent, &mut states, &mut root_bounds, ); } } resolve_pending_alignments( std::mem::take(&mut pending[root_pending_index]), LineVerticalAnchor::Root, &mut root_bounds, &mut states, &mut geometries, ); root_bounds = root_bounds.or_else(|| { line_break .filter(|(anchor, _)| *anchor == LineVerticalAnchor::Root) .map(|(_, bounds)| bounds) }); let bounds = if phantom { InlineVerticalBounds::ZERO } else if empty_caret { // Empty editors still need their font strut for caret geometry. fallback_root_bounds } else if context.uses_quirks_line_height { root_bounds.unwrap_or(InlineVerticalBounds::ZERO) } else { root_bounds.unwrap_or(fallback_root_bounds) }; let line_height = bounds.height(); if !phantom { // CSS baseline adjustment can remove phantom lines or change line // heights. Keep float avoidance as a minimum top, so neither that // adjustment nor Parley's height sum discards the clearance. let clearance = float_line_clearances .get(line_index) .copied() .unwrap_or(0.0); preceding_adjustment += (clearance - raw_top - preceding_adjustment).max(0.0); } let root_baseline = raw_top + preceding_adjustment - bounds.top; if !phantom { result.has_non_phantom_line = true; result.first_baseline.get_or_insert(root_baseline); result.last_baseline = Some(root_baseline); } // Intrinsic and flex/grid probes need only the resolved line height // and baselines. The following state walk and vectors exist solely to // place final glyphs, atomic objects, and structural fragments. if let Some(placements) = placements.as_mut() { // Place alignment anchors before the states that reference them. for state_index in state_order.iter().rev().copied() { states[state_index].alignment.global_offset = states[state_index].alignment.relative_offset + anchor_global_offset(states[state_index].alignment.anchor, &states); } let item_offsets = geometries .iter() .map(|geometry| { let desired_top = root_baseline + anchor_global_offset(geometry.anchor, &states) + geometry.relative_offset + geometry.bounds.top; desired_top - geometry.initial_top }) .collect::>(); let glyph_offsets = geometries .iter() .zip(&item_offsets) .filter_map(|(geometry, offset)| { let (run_index, style_index) = geometry.glyph_key?; Some(InlineGlyphOffset { run_index, style_index, offset: *offset, }) }) .collect(); let box_block_placements = states .iter() .filter_map(|state| { let strut = state.strut?; let baseline = root_baseline + state.alignment.global_offset; // An empty closing fragment has no font box only when // its whole quirks line has no resolved vertical metrics. // Content with zero height still retains the font box. let (top, height) = if context.uses_quirks_line_height && !state.has_strut_content && root_bounds.is_none() { (baseline, 0.0) } else { ( baseline - strut.text_ascent, (strut.text_ascent + strut.text_descent).max(0.0), ) }; Some(InlineBoxBlockPlacement { box_id: state.box_id, top, height, }) }) .collect(); placements.push(InlineLinePlacement { line_index, rect: PaintRect::new( metrics.inline_min_coord + metrics.offset, raw_top + preceding_adjustment, metrics.advance, line_height, ), baseline: root_baseline, phantom, content_offset: root_baseline - metrics.baseline, item_offsets, glyph_offsets, box_block_placements, }); } // Parley already excludes an empty terminal line from layout.height(). // Do not subtract its inherited metrics again after an oversized atom // has forced an emergency break at the end of the paragraph. let measured_height = if line_index + 1 == layout.len() && line.is_empty() { 0.0 } else { raw_bottom - raw_top }; preceding_adjustment += line_height - measured_height; unadjusted_line_top += metrics.line_height.max(0.0); } result.line_expansion = preceding_adjustment; result } #[derive(Clone, Copy, Debug)] struct InlineItemVerticalGeometry { /// Line-height bounds relative to this item's own alignment baseline. bounds: InlineVerticalBounds, /// Parley's original block-start coordinate for converting the resolved /// baseline back into an item delta. initial_top: f32, structural_parent: LayoutBoxId, /// Source object identity; its role and used edge contributions stay in /// their input records rather than being copied into vertical geometry. object_index: Option, vertical_align: InlineVerticalAlign, /// Whether this item supplies block-axis geometry to the line. contributes_to_line: bool, /// Whether this item prevents the line from being a CSS phantom line box. /// Structural inline edges with non-zero inline-axis decorations create a /// line without themselves affecting its block-axis height. creates_line: bool, glyph_key: Option<(usize, usize)>, anchor: LineVerticalAnchor, relative_offset: f32, } impl InlineItemVerticalGeometry { /// Structural edges align to their own box rather than to their parent. fn edge<'a>(&self, context: &'a InlineFormattingContext) -> Option<&'a InlineObject> { let object = context.objects.get(self.object_index?)?; matches!( object.role, InlineObjectRole::StartEdge | InlineObjectRole::EndEdge ) .then_some(object) } } fn line_break_metrics( context: &InlineFormattingContext, layout: &Layout, line: &parley::Line<'_, TextBrush>, ) -> Option<(LayoutBoxId, InlineVerticalBounds)> { line.runs().find_map(|run| { let cluster = run .clusters() .find(|cluster| cluster.is_hard_line_break())?; let style_index = layout .styles() .iter() .position(|style| std::ptr::eq(style, cluster.style()))?; let structural_parent = context.style_parent(style_index); let primary_strut = context.font_metrics[style_index].map(|metrics| inline_strut_metrics(metrics, true)); let bounds = glyph_line_bounds( primary_strut, run.font_metrics(), run.line_height(), context.box_includes_used_font_metrics(structural_parent), ); Some((structural_parent, bounds)) }) } #[derive(Clone, Copy, Debug)] struct LineInlineBoxState { box_id: LayoutBoxId, parent_box: LayoutBoxId, parent: Option, depth: usize, vertical_align: InlineVerticalAlign, strut: Option, /// Content and start edges, plus closing edges in standards mode, /// retain this box's strut and the struts of its structural ancestors. has_strut_content: bool, /// Bounds participating in the line-height union, independent of font /// geometry and the alignment of this fragment. None differs from ZERO. line_contribution: Option, alignment: InlineBoxAlignment, } #[derive(Clone, Copy, Debug)] struct InlineBoxAlignment { anchor: LineVerticalAnchor, relative_offset: f32, global_offset: f32, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum LineVerticalAnchor { Root, State(usize), } #[derive(Clone, Copy, Debug)] enum PendingLineMember { State(usize), Item(usize), } #[derive(Clone, Copy, Debug)] struct PendingLineAlignment { member: PendingLineMember, bounds: InlineVerticalBounds, vertical_align: InlineVerticalAlign, } #[derive(Clone, Copy, Debug)] struct InlineVerticalBounds { top: f32, bottom: f32, } impl InlineVerticalBounds { const ZERO: Self = Self { top: 0.0, bottom: 0.0, }; fn from_strut(strut: InlineStrutMetrics) -> Self { Self { top: -strut.line_ascent, bottom: strut.line_descent, } } fn shifted(self, offset: f32) -> Self { Self { top: self.top + offset, bottom: self.bottom + offset, } } fn height(self) -> f32 { (self.bottom - self.top).max(0.0) } fn include(&mut self, other: Self) { self.top = self.top.min(other.top); self.bottom = self.bottom.max(other.bottom); } } fn glyph_line_bounds( primary_strut: Option, used_font: &parley::FontMetrics, used_line_height: f32, include_used_font_metrics: bool, ) -> InlineVerticalBounds { let used_strut = inline_strut_metrics( InlineFontMetrics { ascent: used_font.ascent, descent: used_font.descent, line_height: used_line_height, x_height: used_font.x_height.unwrap_or(used_font.ascent * 0.56), }, true, ); let used_bounds = InlineVerticalBounds::from_strut(used_strut); let mut bounds = primary_strut.map_or(used_bounds, InlineVerticalBounds::from_strut); if include_used_font_metrics { bounds.include(used_bounds); } bounds } fn build_line_inline_box_states( context: &InlineFormattingContext, layout: &Layout, line_range: Range, geometries: &[InlineItemVerticalGeometry], line_break_box: Option, ) -> Vec { let mut present = std::collections::BTreeSet::new(); let mut strut_boxes = std::collections::BTreeSet::new(); for unit in overlapping_output_ranges(&context.text_units, &line_range) { for ancestor in &unit.ancestors { mark_structural_path(context, *ancestor, &mut present); if !unit.control { mark_structural_path(context, *ancestor, &mut strut_boxes); } } } for geometry in geometries { mark_structural_path(context, geometry.structural_parent, &mut present); if geometry.contributes_to_line { mark_structural_path(context, geometry.structural_parent, &mut strut_boxes); } if let Some(object) = geometry.edge(context) { mark_structural_path(context, object.box_id, &mut present); // A zero-size closing edge still retains its standards strut. // Parley can carry a close after a collapsed trailing space onto // the next line; that close belongs to the preceding fragment. let follows_wrapped_space = || { geometry .object_index .and_then(|index| layout.inline_boxes().nth(index)) .filter(|edge| edge.index <= line_range.start) .is_some_and(|edge| { context .text_units .partition_point(|unit| unit.output_range.end <= edge.index) .checked_sub(1) .and_then(|index| context.text_units.get(index)) .is_some_and(|unit| { unit.output_range.end == edge.index && unit.collapsible_whitespace && unit.ancestors.contains(&object.box_id) }) }) }; if object.role == InlineObjectRole::StartEdge || (!context.uses_quirks_line_height && (geometry.creates_line || !follows_wrapped_space())) { mark_structural_path(context, object.box_id, &mut strut_boxes); } } } if let Some(box_id) = line_break_box { mark_structural_path(context, box_id, &mut present); } context .structural_boxes .iter() .filter(|state| present.contains(&state.box_id.index())) .map(|state| LineInlineBoxState { box_id: state.box_id, parent_box: state.parent, parent: None, depth: structural_box_depth(context, state.box_id), vertical_align: state.vertical_align, strut: state.strut, has_strut_content: strut_boxes.contains(&state.box_id.index()), line_contribution: None, alignment: InlineBoxAlignment { anchor: LineVerticalAnchor::Root, relative_offset: 0.0, global_offset: 0.0, }, }) .collect() } fn mark_structural_path( context: &InlineFormattingContext, mut box_id: LayoutBoxId, present: &mut std::collections::BTreeSet, ) { while box_id != context.root_style { let Some(state) = context.structural_box(box_id) else { break; }; if !present.insert(box_id.index()) { break; } box_id = state.parent; } } fn structural_box_depth(context: &InlineFormattingContext, mut box_id: LayoutBoxId) -> usize { let mut depth = 0; while box_id != context.root_style { let Some(state) = context.structural_box(box_id) else { break; }; depth += 1; box_id = state.parent; } depth } fn alignment_reference( context: &InlineFormattingContext, states: &[LineInlineBoxState], parent: Option, ) -> Option { parent .and_then(|index| states.get(index).and_then(|state| state.strut)) .or_else(|| parent.is_none().then_some(context.parent_strut).flatten()) } fn include_in_parent( bounds: InlineVerticalBounds, parent: Option, states: &mut [LineInlineBoxState], root_bounds: &mut Option, ) { let target = parent .and_then(|index| { states .get_mut(index) .map(|state| &mut state.line_contribution) }) .unwrap_or(root_bounds); match target { Some(metrics) => metrics.include(bounds), None => *target = Some(bounds), } } fn nearest_top_or_bottom_target( states: &[LineInlineBoxState], mut parent: Option, ) -> Option { while let Some(index) = parent { let state = &states[index]; if matches!( state.vertical_align.kind, LayoutInlineAlignment::Top | LayoutInlineAlignment::Bottom ) { return Some(index); } parent = state.parent; } None } fn resolve_pending_alignments( pending: Vec, target_anchor: LineVerticalAnchor, target_metrics: &mut Option, states: &mut [LineInlineBoxState], geometries: &mut [InlineItemVerticalGeometry], ) { if pending.is_empty() { return; } let aligned = target_metrics.unwrap_or(InlineVerticalBounds::ZERO); let mut maximum = aligned; for child in &pending { let height = child.bounds.height(); if height <= maximum.height() { continue; } maximum = match child.vertical_align.kind { LayoutInlineAlignment::Top => InlineVerticalBounds { top: aligned.top, bottom: aligned.top + height, }, LayoutInlineAlignment::Bottom => InlineVerticalBounds { top: aligned.bottom - height, bottom: aligned.bottom, }, _ => maximum, }; } for child in pending { let offset = match child.vertical_align.kind { LayoutInlineAlignment::Top => maximum.top - child.bounds.top, LayoutInlineAlignment::Bottom => maximum.bottom - child.bounds.bottom, _ => 0.0, } - child.vertical_align.baseline_shift; match child.member { PendingLineMember::State(index) => { states[index].alignment.anchor = target_anchor; states[index].alignment.relative_offset = offset; } PendingLineMember::Item(index) => { geometries[index].anchor = target_anchor; geometries[index].relative_offset = offset; } } let shifted = child.bounds.shifted(offset); match target_metrics { Some(metrics) => metrics.include(shifted), None => *target_metrics = Some(shifted), } } } fn anchor_global_offset(anchor: LineVerticalAnchor, states: &[LineInlineBoxState]) -> f32 { match anchor { LineVerticalAnchor::Root => 0.0, LineVerticalAnchor::State(index) => states .get(index) .map_or(0.0, |state| state.alignment.global_offset), } } /// CSS line boxes ending in a preserved newline exist even when they contain /// no paintable item. Parley's explicit break reason covers both preserved /// segment breaks and the normalized `
` control. fn css_line_is_phantom(break_reason: BreakReason, has_in_flow_content: bool) -> bool { !has_in_flow_content && break_reason != BreakReason::Explicit } fn non_edge_vertical_offset( vertical_align: InlineVerticalAlign, parent: Option, item: InlineVerticalBounds, ) -> f32 { let baseline_shift = -vertical_align.baseline_shift; let (parent_text_top, parent_text_bottom, parent_x_height) = parent .map_or((0.0, 0.0, 0.0), |strut| { (-strut.text_ascent, strut.text_descent, strut.x_height) }); let alignment_shift = match vertical_align.kind { LayoutInlineAlignment::Baseline => 0.0, LayoutInlineAlignment::TextTop => parent_text_top - item.top, LayoutInlineAlignment::Middle => -parent_x_height * 0.5 - (item.top + item.bottom) * 0.5, LayoutInlineAlignment::TextBottom => parent_text_bottom - item.bottom, LayoutInlineAlignment::Top | LayoutInlineAlignment::Bottom => 0.0, }; alignment_shift + baseline_shift } #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] struct SourceFragmentKey { box_index: usize, source_byte_start: usize, source_byte_end: usize, source_utf16_start: usize, source_utf16_end: usize, line_index: usize, rtl: bool, } #[derive(Clone, Copy, Debug, Default)] struct FragmentAccumulator { min_x: Option, min_y: Option, max_x: Option, max_y: Option, has_start_edge: bool, has_end_edge: bool, } impl FragmentAccumulator { fn include(&mut self, rect: PaintRect) { self.include_inline_axis(rect.x, rect.width); self.min_y = Some(self.min_y.map_or(rect.y, |value| value.min(rect.y))); self.max_y = Some(self.max_y.map_or(rect.y + rect.height, |value| { value.max(rect.y + rect.height) })); } fn include_inline_axis(&mut self, x: f32, width: f32) { self.min_x = Some(self.min_x.map_or(x, |value| value.min(x))); self.max_x = Some(self.max_x.map_or(x + width, |value| value.max(x + width))); } fn include_block_axis(&mut self, y: f32, height: f32) { self.min_y = Some(self.min_y.map_or(y, |value| value.min(y))); self.max_y = Some(self.max_y.map_or(y + height, |value| value.max(y + height))); } fn rect(self, fallback_block_rect: PaintRect) -> Option { let min_x = self.min_x?; let min_y = self.min_y.unwrap_or(fallback_block_rect.y); let max_y = self .max_y .unwrap_or(fallback_block_rect.y + fallback_block_rect.height); Some(PaintRect::new( min_x, min_y, (self.max_x? - min_x).max(0.0), (max_y - min_y).max(0.0), )) } } fn ranges_overlap(left: &Range, right: &Range) -> bool { left.start < right.end && right.start < left.end } trait HasInlineOutputRange { fn output_range(&self) -> &Range; } impl HasInlineOutputRange for InlineTextUnit { fn output_range(&self) -> &Range { &self.output_range } } impl HasInlineOutputRange for InlineSourceMapEntry { fn output_range(&self) -> &Range { &self.output_range } } /// Returns the contiguous slice intersecting `target` from an output-ordered /// inline map. Normalization produces non-overlapping ranges, except that a /// single output range can have multiple source origins (for example CRLF /// merged across text nodes). Visual glyph clusters are not ordered under /// bidi, so two binary searches are used instead of a stateful cursor. fn overlapping_output_ranges<'a, T>(items: &'a [T], target: &Range) -> &'a [T] where T: HasInlineOutputRange, { if target.is_empty() { return &items[..0]; } let start = items.partition_point(|item| item.output_range().end <= target.start); let end = start + items[start..].partition_point(|item| item.output_range().start < target.end); &items[start..end] } fn output_ranges_are_monotonic(items: &[T]) -> bool where T: HasInlineOutputRange, { items.windows(2).all(|pair| { pair[0].output_range().start <= pair[1].output_range().start && pair[0].output_range().end <= pair[1].output_range().end }) } pub(crate) fn prepare_inline_contexts( world: &mut LayoutWorld, services: &mut DocumentLayoutServices, ) where N: Copy + Debug + Eq + Hash, { let profile_started = moli_trace::cpu_profile_enabled().then(std::time::Instant::now); let mut collection_elapsed = std::time::Duration::ZERO; let mut preparation_elapsed = std::time::Duration::ZERO; let mut prepared_context_count = 0usize; let mut text_unit_count = 0usize; for layout_box in &mut world.boxes { layout_box.inline_layout = None; layout_box.inline_context_owner = None; layout_box.inline_flattened = false; layout_box.inline_static_position = None; } let owners = (0..world.boxes.len()) .map(LayoutBoxId::from_index) .filter(|id| world.boxes[id.index()].inline_formatting_context) .collect::>(); let mut initialized = false; for owner in owners { // A normal inline descendant is already flattened into the ancestor's // Parley tree. Atomic inline boxes still establish their own inner IFC. if world.boxes[owner.index()].inline_flattened { continue; } let collection_started = profile_started.map(|_| std::time::Instant::now()); let input = collect_inline_input(world, owner); if let Some(started) = collection_started { collection_elapsed += started.elapsed(); text_unit_count += input.units.len(); } if input.units.is_empty() && input.objects.is_empty() && world.boxes[owner.index()].text_selection.is_none() { continue; } let preparation_started = profile_started.map(|_| std::time::Instant::now()); let parley = services.parley_mut(); let context = input.build(world, parley); if let Some(started) = preparation_started { preparation_elapsed += started.elapsed(); prepared_context_count += 1; } world.boxes[owner.index()].inline_layout = Some(context); initialized = true; } if initialized { services.text_layout_passes = services.text_layout_passes.saturating_add(1); } if let Some(started) = profile_started { tracing::info!( target: "moli_cpu_profile", stage = "layout_inline_preparation", root = ?world.boxes[world.root().index()].source(), total_us = started.elapsed().as_micros(), collection_us = collection_elapsed.as_micros(), preparation_us = preparation_elapsed.as_micros(), prepared_context_count, text_unit_count, ); } } struct InlineBuildInput { text: String, units: Vec, objects: Vec<(usize, InlineObject, InlineBoxKind)>, items: Vec, source_map: Vec, root_style: LayoutBoxId, } fn intern_resolved_inline_style( styles: &mut Vec>, style_parents: &mut Vec, style_samples: &mut Vec>, style: TextStyle<'static, 'static, TextBrush>, structural_parent: LayoutBoxId, sample: Option, ) -> usize { let style_slot = styles .iter() .enumerate() .position(|(index, candidate)| { *candidate == style && style_parents[index] == structural_parent }) .unwrap_or_else(|| { let index = styles.len(); styles.push(style); style_parents.push(structural_parent); style_samples.push(None); index }); if style_samples[style_slot].is_none() { style_samples[style_slot] = sample; } style_slot } fn append_resolved_inline_run( runs: &mut Vec<(Range, usize)>, range: Range, style_slot: usize, ) { match runs.last_mut() { Some((previous_range, previous_slot)) if *previous_slot == style_slot && previous_range.end == range.start => { previous_range.end = range.end; } _ => runs.push((range, style_slot)), } } impl InlineBuildInput { /// Normalize DOM order first, then adapt forced-break fragment ownership /// to Parley's byte anchors. Synthetic bidi controls are real intervening /// items; consecutive close tags and empty text are the only items that /// Blink absorbs into the preceding forced-break fragment. fn projected_object_anchors(&self) -> Vec { let mut anchors = self .objects .iter() .map(|(index, _, _)| *index) .collect::>(); let mut forced_break = None; for item in &self.items { match *item { InlineLogicalItem::Text(index) => { let unit = &self.units[index]; forced_break = (!unit.control && &self.text[unit.output_range.clone()] == "\n") .then_some(unit.output_range.start); } InlineLogicalItem::Object(index) => { if self.objects[index].1.role == InlineObjectRole::EndEdge { if let Some(anchor) = forced_break { anchors[index] = anchor; } } else { forced_break = None; } } } } anchors } fn build( mut self, world: &LayoutWorld, parley: &mut crate::text::ParleyDocumentServices, ) -> InlineFormattingContext where N: Copy + Debug + Eq + Hash, { let selection = project_inline_selection(world, &self.source_map).or_else(|| { world.boxes[self.root_style.index()] .text_selection .filter(|selection| selection.is_caret()) .map(|_| InlineSelection::Caret { offset: 0, color: world.boxes[self.root_style.index()].style.caret_color(), }) }); let mut root_text_style = world.boxes[self.root_style.index()] .style .parley_text_style(); parley.resolve_font_families(&mut root_text_style, None); let quantize = true; let mut styles = Vec::new(); let mut style_parents = Vec::new(); let mut style_samples = Vec::new(); let mut resolved_runs = Vec::<(Range, usize)>::new(); // Source mapping, whitespace and selection still use individual units. // Style conversion only needs a contiguous run with the same style, // direct structural parent and paint state. Avoid repeating it for // every character; unicode-range font selection remains per character. for units in self.units.chunk_by(|left, right| { left.style_box == right.style_box && left.ancestors.last() == right.ancestors.last() && left.control == right.control && left.output_range.end == right.output_range.start }) { let unit = &units[0]; let output_range = unit.output_range.start ..units .last() .expect("style chunks are nonempty") .output_range .end; let mut base_style = world.boxes[unit.style_box.index()] .style .parley_text_style(); // `vertical-align` belongs to the structural inline box, not to // each descendant glyph. Keep glyphs baseline-aligned within their // direct box state; closing that state moves the complete subtree. base_style.brush.paint = !unit.control; let structural_parent = unit.ancestors.last().copied().unwrap_or(self.root_style); if !parley.requires_character_font_resolution(&base_style) { let sample = (!unit.control) .then(|| self.text[output_range.clone()].chars().next()) .flatten(); parley.resolve_font_families(&mut base_style, None); let style_slot = intern_resolved_inline_style( &mut styles, &mut style_parents, &mut style_samples, base_style, structural_parent, sample, ); append_resolved_inline_run(&mut resolved_runs, output_range, style_slot); continue; } for (relative_start, character) in self.text[output_range.clone()].char_indices() { let start = output_range.start + relative_start; let end = start + character.len_utf8(); let mut style = base_style.clone(); parley.resolve_font_families(&mut style, Some(character)); let style_slot = intern_resolved_inline_style( &mut styles, &mut style_parents, &mut style_samples, style, structural_parent, (!unit.control).then_some(character), ); append_resolved_inline_run(&mut resolved_runs, start..end, style_slot); } } let mut builder = parley.layout_context.style_run_builder( &mut parley.font_context, &self.text, 1.0, quantize, ); let style_indices = styles .iter() .map(|style| builder.push_style(style.clone())) .collect::>(); if resolved_runs.is_empty() { let style_index = builder.push_style(root_text_style.clone()); builder.push_style_run(style_index, 0..0); } else { for (range, style_slot) in &resolved_runs { builder.push_style_run(style_indices[*style_slot], range.clone()); } } let object_anchors = self.projected_object_anchors(); for (object_id, (_, object, kind)) in self.objects.iter().enumerate() { builder.push_inline_box_with_bidi( InlineBox { id: u64::try_from(object_id).expect("one IFC exceeded the u64 object limit"), kind: *kind, index: object_anchors[object_id], width: 0.0, height: 0.0, baseline: None, vertical_align: parley::VerticalAlign::default(), }, object.role.parley_bidi(), ); } let layout = builder.build(&self.text); let font_metrics = styles .iter() .zip(style_samples) .map(|(style, sample)| parley.inline_font_metrics(style, sample)) .collect(); let parent_strut = measure_inline_strut(parley, root_text_style.clone(), quantize); let mut structural_boxes = Vec::new(); for (_, object, _) in &self.objects { if object.role != InlineObjectRole::StartEdge || structural_boxes .iter() .any(|state: &InlineStructuralBox| state.box_id == object.box_id) { continue; } let mut style = world.boxes[object.box_id.index()].style.parley_text_style(); parley.resolve_font_families(&mut style, None); structural_boxes.push(InlineStructuralBox { box_id: object.box_id, parent: object.ancestors.last().copied().unwrap_or(self.root_style), vertical_align: object.vertical_align, strut: measure_inline_strut(parley, style, quantize), include_used_font_metrics: world.boxes[object.box_id.index()] .style .includes_used_font_metrics(), }); } let objects = self .objects .drain(..) .map(|(_, object, _)| object) .collect(); InlineFormattingContext { text: self.text, root_style: self.root_style, measurement_layout: Some(layout), laid_out: None, content_widths: InlineContentWidthsMemo::default(), text_units: self.units, source_map: self.source_map, selection, objects, font_metrics, parent_strut, uses_quirks_line_height: world.quirks_mode != style::context::QuirksMode::NoQuirks, root_includes_used_font_metrics: world.boxes[self.root_style.index()] .style .includes_used_font_metrics(), style_parents, structural_boxes, line_placements: Vec::new(), fragments: InlineFragments::default(), } } } fn measure_inline_strut( parley: &mut crate::text::ParleyDocumentServices, style: TextStyle<'static, 'static, TextBrush>, quantize: bool, ) -> Option { let metrics = parley.inline_font_metrics(&style, None)?; Some(inline_strut_metrics(metrics, quantize)) } fn inline_strut_metrics(metrics: InlineFontMetrics, quantize: bool) -> InlineStrutMetrics { let (ascent, descent, leading_above, leading_below) = if quantize { let ascent = metrics.ascent.round(); let descent = metrics.descent.round(); let leading = metrics.line_height - ascent - descent; let leading_above = (leading * 0.5).floor(); let leading_below = leading.round() - leading_above; (ascent, descent, leading_above, leading_below) } else { let half_leading = (metrics.line_height - metrics.ascent - metrics.descent) * 0.5; (metrics.ascent, metrics.descent, half_leading, half_leading) }; InlineStrutMetrics { line_ascent: ascent + leading_above, line_descent: descent + leading_below, text_ascent: ascent, text_descent: descent, x_height: metrics.x_height, } } fn project_inline_selection( world: &LayoutWorld, source_map: &[InlineSourceMapEntry], ) -> Option where N: Copy + Debug + Eq + Hash, { let mut selected_start = None::; let mut selected_end = None::; let mut caret = None::<(usize, PaintColor)>; for entry in source_map { let Some(selection) = world.boxes[entry.box_id.index()].text_selection else { continue; }; if selection.is_caret() { if caret.is_none() { caret = caret_output_offset(source_map, entry.box_id, selection.start).map(|offset| { ( offset, world.boxes[entry.box_id.index()].style.caret_color(), ) }); } continue; } let selected = selection.start.min(selection.end)..selection.start.max(selection.end); if !ranges_overlap(&entry.source_utf16_range, &selected) { continue; } selected_start = Some(selected_start.map_or(entry.output_range.start, |start| { start.min(entry.output_range.start) })); selected_end = Some(selected_end.map_or(entry.output_range.end, |end| { end.max(entry.output_range.end) })); } match (selected_start, selected_end) { (Some(start), Some(end)) if start < end => Some(InlineSelection::Range(start..end)), _ => caret.map(|(offset, color)| InlineSelection::Caret { offset, color }), } } fn caret_output_offset( source_map: &[InlineSourceMapEntry], box_id: LayoutBoxId, utf16_offset: usize, ) -> Option { let entries = source_map .iter() .filter(|entry| entry.box_id == box_id) .collect::>(); let first = entries.first()?; if utf16_offset <= first.source_utf16_range.start { return Some(first.output_range.start); } for entry in &entries { if utf16_offset < entry.source_utf16_range.end { return Some(entry.output_range.start); } if utf16_offset == entry.source_utf16_range.end { return Some(entry.output_range.end); } } entries.last().map(|entry| entry.output_range.end) } fn collect_inline_input(world: &mut LayoutWorld, owner: LayoutBoxId) -> InlineBuildInput where N: Copy + Debug + Eq + Hash, { let mut normalizer = InlineNormalizer::new(owner); let children = world.boxes[owner.index()].children.clone(); for child in children { collect_box(world, owner, child, &mut Vec::new(), &mut normalizer); } normalizer.finish() } fn collect_box( world: &mut LayoutWorld, owner: LayoutBoxId, id: LayoutBoxId, ancestors: &mut Vec, normalizer: &mut InlineNormalizer, ) where N: Copy + Debug + Eq + Hash, { let kind = world.boxes[id.index()].kind; let display = world.boxes[id.index()].style.display(); if kind == LayoutBoxKind::PseudoMarker && world.boxes[id.index()].outside_list_marker { return; } world.boxes[id.index()].inline_context_owner = Some(owner); if kind == LayoutBoxKind::Text { world.boxes[id.index()].inline_flattened = true; let text = world.boxes[id.index()].text.clone().unwrap_or_default(); normalizer.push_text( id, &text, world.boxes[id.index()].style.white_space_collapse(), world.boxes[id.index()].style.text_transform(), ancestors, ); return; } if kind == LayoutBoxKind::LineBreak { world.boxes[id.index()].inline_flattened = true; normalizer.hard_break(id, ancestors); return; } if world.boxes[id.index()].style.is_floated() { normalizer.push_object( id, InlineObjectRole::Float, InlineBoxKind::CustomOutOfFlow, ancestors, world.boxes[id.index()].style.vertical_align(), ); return; } let out_of_flow = world.boxes[id.index()].style.is_out_of_flow(); if out_of_flow { normalizer.push_object( id, InlineObjectRole::OutOfFlow, InlineBoxKind::OutOfFlow, ancestors, world.boxes[id.index()].style.vertical_align(), ); return; } let structural_inline = display.is_inline_flow() && !matches!( kind, LayoutBoxKind::Replaced | LayoutBoxKind::FormControl | LayoutBoxKind::InlineTableWrapper ); if !structural_inline { normalizer.push_object( id, InlineObjectRole::Atomic, InlineBoxKind::InFlow, ancestors, world.boxes[id.index()].style.vertical_align(), ); return; } world.boxes[id.index()].inline_flattened = true; let vertical_align = world.boxes[id.index()].style.vertical_align(); normalizer.open_inline( id, world.boxes[id.index()].style.unicode_bidi(), world.boxes[id.index()].style.direction(), ancestors, vertical_align, ); ancestors.push(id); let children = world.boxes[id.index()].children.clone(); for child in children { collect_box(world, owner, child, ancestors, normalizer); } ancestors.pop(); normalizer.close_inline(id, ancestors, vertical_align); } struct PendingWhitespace { output_index: usize, unit_index: usize, object_index: usize, item_index: usize, style_box: LayoutBoxId, ancestors: Vec, sources: Vec, contains_segment_break: bool, } struct PendingCarriageReturn { style_box: LayoutBoxId, mode: InlineWhiteSpaceCollapse, ancestors: Vec, origin: SourceOrigin, } /// Keeps text/control/object order even when several objects share a byte /// offset. Indices refer to their normalized input records, not Parley IDs. #[derive(Clone, Copy, Debug)] enum InlineLogicalItem { Text(usize), Object(usize), } #[derive(Clone, Copy, Debug)] struct InlineBidiContext { owner: LayoutBoxId, enter: char, exit: char, } struct InlineNormalizer { root_style: LayoutBoxId, text: String, units: Vec, objects: Vec<(usize, InlineObject, InlineBoxKind)>, items: Vec, bidi_contexts: Vec, pending: Option, pending_carriage_return: Option, line_has_content: bool, text_transform: TextTransformState, } impl InlineNormalizer { fn new(root_style: LayoutBoxId) -> Self { Self { root_style, text: String::new(), units: Vec::new(), objects: Vec::new(), items: Vec::new(), bidi_contexts: Vec::new(), pending: None, pending_carriage_return: None, line_has_content: false, text_transform: TextTransformState::default(), } } fn push_text( &mut self, box_id: LayoutBoxId, text: &str, mode: InlineWhiteSpaceCollapse, transform: InlineTextTransform, ancestors: &[LayoutBoxId], ) { let mut utf16_offset = 0; let mut characters = text.char_indices().peekable(); if let Some(pending) = self.pending_carriage_return.take() { self.text_transform.reset(); if let Some(&(byte_offset, '\n')) = characters.peek() { characters.next(); let utf16_end = '\n'.len_utf16(); self.push_character( pending.style_box, '\n', pending.mode, &pending.ancestors, vec![ pending.origin, SourceOrigin { box_id, byte_range: byte_offset..byte_offset + '\n'.len_utf8(), utf16_range: 0..utf16_end, }, ], ); utf16_offset = utf16_end; } else { self.push_character( pending.style_box, '\n', pending.mode, &pending.ancestors, vec![pending.origin], ); } } while let Some((byte_offset, source_char)) = characters.next() { let byte_end = byte_offset + source_char.len_utf8(); let utf16_end = utf16_offset + source_char.len_utf16(); let origin = SourceOrigin { box_id, byte_range: byte_offset..byte_end, utf16_range: utf16_offset..utf16_end, }; utf16_offset = utf16_end; if source_char == '\r' { if let Some(&(next_byte, '\n')) = characters.peek() { self.text_transform.reset(); characters.next(); let lf_utf16_end = utf16_offset + '\n'.len_utf16(); self.push_character( box_id, '\n', mode, ancestors, vec![ origin, SourceOrigin { box_id, byte_range: next_byte..next_byte + '\n'.len_utf8(), utf16_range: utf16_offset..lf_utf16_end, }, ], ); utf16_offset = lf_utf16_end; continue; } if characters.peek().is_none() { self.pending_carriage_return = Some(PendingCarriageReturn { style_box: box_id, mode, ancestors: ancestors.to_vec(), origin, }); break; } } let transformed = self.text_transform.transform(source_char, transform); for character in transformed { self.push_character(box_id, character, mode, ancestors, vec![origin.clone()]); } } } fn push_character( &mut self, style_box: LayoutBoxId, character: char, mode: InlineWhiteSpaceCollapse, ancestors: &[LayoutBoxId], sources: Vec, ) { match classify_text_character(character, mode) { TextCharacter::Collapsible { segment_break } => { self.queue_whitespace(style_box, ancestors, sources, segment_break); } TextCharacter::ForcedBreak { preserve_pending } => { if preserve_pending { self.flush_pending(); } self.pending = None; self.append_forced_break(style_box, ancestors, sources); } TextCharacter::Preserved { character, break_after, } => { self.flush_pending(); self.append_unit(style_box, character, ancestors, sources, false); if break_after { // Parley needs a non-source break opportunity after a preserved space. let unit_index = self.units.len(); self.append_unit(style_box, '\u{200B}', ancestors, Vec::new(), true); self.units[unit_index].break_spaces_opportunity = true; } self.line_has_content = true; } } } fn queue_whitespace( &mut self, style_box: LayoutBoxId, ancestors: &[LayoutBoxId], sources: Vec, segment_break: bool, ) { let pending = self.pending.get_or_insert_with(|| PendingWhitespace { output_index: self.text.len(), unit_index: self.units.len(), object_index: self.objects.len(), item_index: self.items.len(), style_box, ancestors: ancestors.to_vec(), sources: Vec::new(), contains_segment_break: false, }); pending.sources.extend(sources); pending.contains_segment_break |= segment_break; } fn flush_pending(&mut self) { let Some(pending) = self.pending.take() else { return; }; if !self.line_has_content { return; } // Inline boundaries and bidi controls can be collected while a // collapsible space is still pending. If the space survives, it // precedes all of those later items in DOM order. Insert it at the // point where the collapsible sequence began instead of appending it // after the deferred boundaries. self.text.insert(pending.output_index, ' '); for unit in &mut self.units[pending.unit_index..] { unit.output_range.start += 1; unit.output_range.end += 1; } for (byte_index, _, _) in &mut self.objects[pending.object_index..] { *byte_index += 1; } for item in &mut self.items[pending.item_index..] { if let InlineLogicalItem::Text(index) = item { *index += 1; } } self.items.insert( pending.item_index, InlineLogicalItem::Text(pending.unit_index), ); self.units.insert( pending.unit_index, InlineTextUnit { output_range: pending.output_index..pending.output_index + 1, style_box: pending.style_box, ancestors: pending.ancestors, sources: pending.sources, control: false, collapsible_whitespace: true, break_spaces_opportunity: false, }, ); } fn hard_break(&mut self, box_id: LayoutBoxId, ancestors: &[LayoutBoxId]) { self.flush_pending_carriage_return(); self.pending = None; self.append_forced_break(box_id, ancestors, Vec::new()); } fn append_forced_break( &mut self, box_id: LayoutBoxId, ancestors: &[LayoutBoxId], sources: Vec, ) { // CSS bidi contexts end before a paragraph break and resume after it. // Associate synthetic controls with the break, without DOM sources. for index in (0..self.bidi_contexts.len()).rev() { let exit = self.bidi_contexts[index].exit; self.append_unit(box_id, exit, ancestors, Vec::new(), true); } self.append_unit(box_id, '\n', ancestors, sources, false); for index in 0..self.bidi_contexts.len() { let enter = self.bidi_contexts[index].enter; self.append_unit(box_id, enter, ancestors, Vec::new(), true); } self.line_has_content = false; self.text_transform.reset(); } fn open_inline( &mut self, box_id: LayoutBoxId, bidi: InlineUnicodeBidi, direction: InlineDirection, ancestors: &[LayoutBoxId], vertical_align: InlineVerticalAlign, ) { self.flush_pending_carriage_return(); // CSS Writing Modes injects the opening bidi controls outside the // inline box boundary. Keep the opaque item order aligned with // Blink's InlineItemsBuilder: enter bidi context, then open the tag. for (enter, exit) in bidi_controls(bidi, direction) { self.append_unit(box_id, enter, ancestors, Vec::new(), true); self.bidi_contexts.push(InlineBidiContext { owner: box_id, enter, exit, }); } self.push_object( box_id, InlineObjectRole::StartEdge, InlineBoxKind::InFlow, ancestors, vertical_align, ); } fn close_inline( &mut self, box_id: LayoutBoxId, ancestors: &[LayoutBoxId], vertical_align: InlineVerticalAlign, ) { // Close the inline box before leaving its injected bidi context. self.push_object( box_id, InlineObjectRole::EndEdge, InlineBoxKind::InFlow, ancestors, vertical_align, ); while self .bidi_contexts .last() .is_some_and(|context| context.owner == box_id) { let context = self .bidi_contexts .pop() .expect("checked active bidi context"); self.append_unit(box_id, context.exit, ancestors, Vec::new(), true); } } fn push_object( &mut self, box_id: LayoutBoxId, role: InlineObjectRole, kind: InlineBoxKind, ancestors: &[LayoutBoxId], vertical_align: InlineVerticalAlign, ) { self.flush_pending_carriage_return(); // Absolutely positioned descendants do not interrupt CSS whitespace // collapsing or make an otherwise empty line non-empty. // In particular, a hidden loading hint before an inline button must // not preserve a leading space and create an extra line beside a float. if matches!(role, InlineObjectRole::Atomic | InlineObjectRole::Float) { self.flush_pending(); self.line_has_content = true; } self.items .push(InlineLogicalItem::Object(self.objects.len())); self.objects.push(( self.text.len(), InlineObject { box_id, role, ancestors: ancestors.to_vec(), vertical_align, }, kind, )); } fn append_unit( &mut self, style_box: LayoutBoxId, character: char, ancestors: &[LayoutBoxId], sources: Vec, control: bool, ) { let start = self.text.len(); self.text.push(character); self.items.push(InlineLogicalItem::Text(self.units.len())); self.units.push(InlineTextUnit { output_range: start..self.text.len(), style_box, ancestors: ancestors.to_vec(), sources, control, collapsible_whitespace: false, break_spaces_opportunity: false, }); } fn finish(mut self) -> InlineBuildInput { self.flush_pending_carriage_return(); // Pending collapsed whitespace at the end of an IFC is discarded. self.pending = None; let source_map = self .units .iter() .flat_map(|unit| { unit.sources.iter().map(|source| InlineSourceMapEntry { output_range: unit.output_range.clone(), box_id: source.box_id, source_byte_range: source.byte_range.clone(), source_utf16_range: source.utf16_range.clone(), }) }) .collect(); InlineBuildInput { text: self.text, units: self.units, objects: self.objects, items: self.items, source_map, root_style: self.root_style, } } fn flush_pending_carriage_return(&mut self) { let Some(pending) = self.pending_carriage_return.take() else { return; }; self.text_transform.reset(); self.push_character( pending.style_box, '\n', pending.mode, &pending.ancestors, vec![pending.origin], ); } } fn bidi_controls(bidi: InlineUnicodeBidi, direction: InlineDirection) -> Vec<(char, char)> { let (embed, override_control, isolate) = match direction { InlineDirection::Ltr => ('\u{202A}', '\u{202D}', '\u{2066}'), InlineDirection::Rtl => ('\u{202B}', '\u{202E}', '\u{2067}'), }; match bidi { InlineUnicodeBidi::Normal => Vec::new(), InlineUnicodeBidi::Embed => vec![(embed, '\u{202C}')], InlineUnicodeBidi::Isolate => vec![(isolate, '\u{2069}')], InlineUnicodeBidi::BidiOverride => vec![(override_control, '\u{202C}')], InlineUnicodeBidi::IsolateOverride => { vec![(isolate, '\u{2069}'), (override_control, '\u{202C}')] } InlineUnicodeBidi::Plaintext => vec![('\u{2068}', '\u{2069}')], } } #[cfg(test)] mod tests { use super::*; #[test] fn carriage_returns_separate_space_styles_at_atomic_and_float_objects() { let root = LayoutBoxId::from_index(0); let prefix = LayoutBoxId::from_index(1); let object = LayoutBoxId::from_index(2); let tail = LayoutBoxId::from_index(3); for (role, expected, tail_spaces) in [ (InlineObjectRole::Atomic, "a b", 1), (InlineObjectRole::Float, "a b", 1), (InlineObjectRole::OutOfFlow, "a b", 0), (InlineObjectRole::StartEdge, "a b", 0), (InlineObjectRole::EndEdge, "a b", 0), ] { let mut normalizer = InlineNormalizer::new(root); normalizer.push_text( prefix, "a\r", InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, &[root], ); let kind = match role { InlineObjectRole::Float => InlineBoxKind::CustomOutOfFlow, InlineObjectRole::OutOfFlow => InlineBoxKind::OutOfFlow, _ => InlineBoxKind::InFlow, }; normalizer.push_object(object, role, kind, &[root], InlineVerticalAlign::default()); normalizer.push_text( tail, "\nb", InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, &[root], ); let input = normalizer.finish(); assert_eq!(input.text, expected, "{role:?}"); assert_eq!( input .units .iter() .filter(|unit| unit.style_box == tail && &input.text[unit.output_range.clone()] == " ") .count(), tail_spaces, "{role:?}" ); } } #[test] fn capitalize_keeps_boundaries_across_segment_breaks_and_text_runs() { for (runs, expected) in [ (vec!["a\nb"], "A B"), (vec!["a\tb"], "A B"), (vec!["a\r\nb"], "A B"), (vec!["a\r", "\nb"], "A B"), (vec!["a", "b"], "Ab"), (vec!["a\u{0301}", "b"], "A\u{0301}b"), ] { let input = runs .iter() .enumerate() .map(|(index, text)| (LayoutBoxId::from_index(index + 1), *text)) .collect::>(); assert_eq!( normalize( &input, InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::Capitalize ) .text, expected, "{runs:?}" ); } } #[test] fn ordered_output_range_lookup_handles_duplicates_gaps_and_bidi_order() { let source = |output_range: Range| InlineSourceMapEntry { output_range, box_id: LayoutBoxId::from_index(1), source_byte_range: 0..1, source_utf16_range: 0..1, }; let entries = vec![ source(0..1), source(1..2), source(1..2), source(2..5), source(7..9), ]; assert!(output_ranges_are_monotonic(&entries)); assert!(!output_ranges_are_monotonic(&[source(1..3), source(0..4),])); assert!(!output_ranges_are_monotonic(&[source(0..4), source(1..3),])); let ranges = |query: Range| { overlapping_output_ranges(&entries, &query) .iter() .map(|entry| entry.output_range.clone()) .collect::>() }; assert_eq!(ranges(1..3), vec![1..2, 1..2, 2..5]); // Visual clusters may query logical text in either direction. assert_eq!(ranges(7..8), vec![7..9]); assert_eq!(ranges(0..1), vec![0..1]); assert!(ranges(5..7).is_empty()); assert!(ranges(2..2).is_empty()); } #[test] fn normal_line_height_unites_metrics_from_the_shaped_fallback_font() { let primary = InlineStrutMetrics { line_ascent: 8.0, line_descent: 2.0, text_ascent: 8.0, text_descent: 2.0, x_height: 4.0, }; let fallback = parley::FontMetrics { ascent: 18.0, descent: 6.0, leading: 6.0, ..parley::FontMetrics::fallback(0.0) }; let explicit = glyph_line_bounds(Some(primary), &fallback, 30.0, false); assert_eq!(explicit.top, -8.0); assert_eq!(explicit.bottom, 2.0); let normal = glyph_line_bounds(Some(primary), &fallback, 30.0, true); assert_eq!(normal.top, -21.0); assert_eq!(normal.bottom, 9.0); } #[test] fn text_edge_alignment_excludes_line_height_leading() { let strut = inline_strut_metrics( InlineFontMetrics { ascent: 10.0, descent: 2.0, line_height: 20.0, x_height: 5.0, }, false, ); let baseline = strut.line_ascent; assert_eq!(baseline - strut.line_ascent, 0.0); assert_eq!(baseline - strut.text_ascent, 4.0); assert_eq!(baseline + strut.text_descent, 16.0); assert_eq!(baseline + strut.line_descent, 20.0); assert_eq!( non_edge_vertical_offset( InlineVerticalAlign { kind: LayoutInlineAlignment::TextTop, baseline_shift: 0.0, }, Some(strut), InlineVerticalBounds { top: -baseline, bottom: 8.0 - baseline, }, ), 4.0, ); } #[test] fn explicit_break_prevents_an_otherwise_empty_line_from_being_phantom() { assert!(!css_line_is_phantom(BreakReason::Explicit, false)); assert!(css_line_is_phantom(BreakReason::None, false)); assert!(!css_line_is_phantom(BreakReason::None, true)); } #[test] fn parley_forced_break_and_optional_editor_tail_map_to_css_phantom_lines() { let text = "\n"; let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); let style = builder.push_style(TextStyle::default()); builder.push_style_run(style, ..); let mut layout = builder.build(text); layout.break_all_lines(None); let mut lines = layout.lines(); let forced_break_line = lines.next().expect("preserved newline must create a line"); assert_eq!(forced_break_line.break_reason(), BreakReason::Explicit); assert!(!css_line_is_phantom( forced_break_line.break_reason(), false, )); for editor_tail in lines { let break_reason = editor_tail.break_reason(); assert!( css_line_is_phantom(break_reason, false), "Parley editor tail must not become an extra CSS line box: {break_reason:?}" ); } } #[test] fn closing_inline_edges_remain_on_the_forced_break_line() { for (bidi, reopen_inline, inner_line, outer_line) in [ (InlineUnicodeBidi::Normal, false, 0, 0), (InlineUnicodeBidi::Embed, false, 1, 1), (InlineUnicodeBidi::Normal, true, 0, 1), ] { let root = LayoutBoxId::from_index(0); let outer = LayoutBoxId::from_index(1); let inner = LayoutBoxId::from_index(2); let atom = LayoutBoxId::from_index(3); let reopened = LayoutBoxId::from_index(4); let align = InlineVerticalAlign::default(); let mut normalizer = InlineNormalizer::new(root); normalizer.open_inline( outer, InlineUnicodeBidi::Normal, InlineDirection::Ltr, &[], align, ); normalizer.open_inline(inner, bidi, InlineDirection::Ltr, &[outer], align); normalizer.push_object( atom, InlineObjectRole::Atomic, InlineBoxKind::InFlow, &[outer, inner], align, ); normalizer.hard_break(inner, &[outer, inner]); normalizer.close_inline(inner, &[outer], align); if reopen_inline { normalizer.open_inline( reopened, InlineUnicodeBidi::Normal, InlineDirection::Ltr, &[outer], align, ); normalizer.close_inline(reopened, &[outer], align); } normalizer.close_inline(outer, &[], align); normalizer.hard_break(root, &[]); let input = normalizer.finish(); let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, &input.text, 1.0, true); let style = builder.push_style(TextStyle::default()); builder.push_style_run(style, ..); let anchors = input.projected_object_anchors(); for (id, (_, object, kind)) in input.objects.iter().enumerate() { builder.push_inline_box_with_bidi( InlineBox { id: id as u64, kind: *kind, index: anchors[id], width: 1.0, height: 20.0, baseline: None, vertical_align: parley::VerticalAlign::default(), }, object.role.parley_bidi(), ); } let mut layout = builder.build(&input.text); layout.break_all_lines(None); for (box_id, expected_line) in [(inner, inner_line), (outer, outer_line)] { let object_id = input .objects .iter() .position(|(_, object, _)| { object.box_id == box_id && object.role == InlineObjectRole::EndEdge }) .unwrap() as u64; let actual_line = layout.lines().position(|line| { line.items().any(|item| { matches!(item, PositionedLayoutItem::InlineBox(item) if item.id == object_id) }) }); assert_eq!( actual_line, Some(expected_line), "{bidi:?}, reopen={reopen_inline}, box={box_id:?}" ); } } } #[test] fn preserved_breaks_balance_nested_bidi_contexts_without_synthetic_dom_sources() { for mode in [ InlineWhiteSpaceCollapse::Preserve, InlineWhiteSpaceCollapse::PreserveBreaks, InlineWhiteSpaceCollapse::BreakSpaces, ] { let root = LayoutBoxId::from_index(0); let outer = LayoutBoxId::from_index(1); let inner = LayoutBoxId::from_index(2); let text = LayoutBoxId::from_index(3); let align = InlineVerticalAlign::default(); let mut normalizer = InlineNormalizer::new(root); normalizer.open_inline( outer, InlineUnicodeBidi::IsolateOverride, InlineDirection::Rtl, &[], align, ); normalizer.open_inline( inner, InlineUnicodeBidi::Embed, InlineDirection::Ltr, &[outer], align, ); normalizer.push_text( text, "a\r\nb", mode, InlineTextTransform::None, &[outer, inner], ); normalizer.close_inline(inner, &[outer], align); normalizer.close_inline(outer, &[], align); assert!(normalizer.bidi_contexts.is_empty()); let input = normalizer.finish(); assert_eq!( input.text, "\u{2067}\u{202e}\u{202a}a\u{202c}\u{202c}\u{2069}\n\u{2067}\u{202e}\u{202a}b\u{202c}\u{202c}\u{2069}" ); let newline = input.text.find('\n').unwrap(); assert_eq!(input.source_map.len(), 4); assert_eq!(input.source_map[1].output_range, newline..newline + 1); assert_eq!(input.source_map[2].output_range, newline..newline + 1); for (index, source) in input.source_map.iter().enumerate() { assert_eq!(source.box_id, text); assert_eq!(source.source_byte_range, index..index + 1); assert_eq!(source.source_utf16_range, index..index + 1); } assert!( input .units .iter() .filter(|unit| unit.control) .all(|unit| unit.sources.is_empty()) ); assert!(output_ranges_are_monotonic(&input.source_map)); } } #[test] fn pending_carriage_return_breaks_before_entering_the_next_bidi_context() { let root = LayoutBoxId::from_index(0); let outer = LayoutBoxId::from_index(1); let inner = LayoutBoxId::from_index(2); let text = LayoutBoxId::from_index(3); let align = InlineVerticalAlign::default(); let mut normalizer = InlineNormalizer::new(root); normalizer.open_inline( outer, InlineUnicodeBidi::Embed, InlineDirection::Ltr, &[], align, ); normalizer.push_text( text, "\r", InlineWhiteSpaceCollapse::Preserve, InlineTextTransform::None, &[outer], ); normalizer.open_inline( inner, InlineUnicodeBidi::Isolate, InlineDirection::Rtl, &[outer], align, ); normalizer.close_inline(inner, &[outer], align); normalizer.close_inline(outer, &[], align); let input = normalizer.finish(); assert_eq!( input.text, "\u{202a}\u{202c}\n\u{202a}\u{2067}\u{2069}\u{202c}" ); assert_eq!(input.source_map.len(), 1); assert_eq!(input.source_map[0].source_byte_range, 0..1); assert_eq!(input.source_map[0].source_utf16_range, 0..1); let anchors = input.projected_object_anchors(); assert_eq!(anchors[1], "\u{202a}\u{202c}\n\u{202a}\u{2067}".len()); } #[test] fn parley_shaped_layout_can_be_rebroken_across_probe_widths() { let text = "alpha beta gamma delta epsilon"; let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); let style = builder.push_style(TextStyle::default()); builder.push_style_run(style, ..); let shaped = builder.build(text); let mut reused = shaped.clone(); let signature = |layout: &Layout| { ( layout.width(), layout.full_width(), layout.height(), layout .lines() .map(|line| (line.text_range(), line.break_reason(), *line.metrics())) .collect::>(), ) }; // Exercise the same order used by Taffy: intrinsic constraints may // alternate with definite widths, and a scrollbar correction may ask // the accepted paragraph to break at another width later in the pass. for width in [45.0, 160.0, 65.0, 160.0] { reused.break_all_lines(Some(width)); let mut fresh = shaped.clone(); fresh.break_all_lines(Some(width)); assert_eq!(signature(&reused), signature(&fresh)); } } #[test] fn parley_probe_reset_removes_justification_before_intrinsic_widths() { let text = "alpha beta gamma delta epsilon zeta eta theta"; let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); let style = builder.push_style(TextStyle::default()); builder.push_style_run(style, ..); let shaped = builder.build(text); let expected = shaped.calculate_content_widths(); let mut reused = shaped.clone(); reused.break_all_lines(Some(120.0)); reused.align( parley::Alignment::Justify, parley::AlignmentOptions { align_when_overflowing: false, last_line_alignment: None, }, ); let justified = reused.calculate_content_widths(); assert_eq!( justified.max, expected.max, "Parley keeps line justification separate from intrinsic shaped advances" ); reset_inline_layout_for_probe(&mut reused); let restored = reused.calculate_content_widths(); assert_eq!(restored.min, expected.min); assert_eq!(restored.max, expected.max); assert!( reused.is_empty(), "a fresh probe must not retain the previous line output" ); } #[test] fn pure_text_content_width_cache_is_keyed_and_object_probes_bypass_it() { let text = "alpha beta gamma delta"; let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); let style = builder.push_style(TextStyle::default()); builder.push_style_run(style, ..); let layout = builder.build(text); let options = parley::IndentOptions::default(); let mut memo = InlineContentWidthsMemo::default(); let first = memo.content_widths_for_probe(&layout, 0.0, options); let second = memo.content_widths_for_probe(&layout, 0.0, options); assert_eq!(first.min, second.min); assert_eq!(first.max, second.max); assert_eq!(memo.hits, 1); let changed_options = parley::IndentOptions { each_line: true, hanging: false, }; memo.content_widths_for_probe(&layout, 12.0, changed_options); assert_eq!(memo.hits, 1); assert_eq!( memo.entry.expect("cache must be populated").key, InlineContentWidthsCacheKey::new(12.0, changed_options), ); let cached = memo.entry; let mut object_builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); let object_style = object_builder.push_style(TextStyle::default()); object_builder.push_style_run(object_style, ..); object_builder.push_inline_box(InlineBox { id: 0, kind: InlineBoxKind::InFlow, index: 5, width: 20.0, height: 10.0, baseline: None, vertical_align: parley::VerticalAlign::default(), }); let mut object_layout = object_builder.build(text); let object_first = memo.content_widths_for_probe(&object_layout, 12.0, changed_options); object_layout.inline_boxes_mut().next().unwrap().width = 60.0; let object_second = memo.content_widths_for_probe(&object_layout, 12.0, changed_options); assert!(object_second.max > object_first.max); assert_eq!(memo.hits, 1); assert_eq!( memo.entry.map(|entry| entry.key), cached.map(|entry| entry.key), "a dynamic inline-object probe must neither reuse nor replace the pure-text cache", ); } #[test] fn intrinsic_line_summary_matches_materialized_line_placements() { let root = LayoutBoxId::from_index(0); let text = "first line\nsecond line"; let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); let style = builder.push_style(TextStyle::default()); builder.push_style_run(style, ..); let mut layout = builder.build(text); layout.break_all_lines(Some(80.0)); let context = InlineFormattingContext { text: "".into(), root_style: root, measurement_layout: Some(layout.clone()), laid_out: None, content_widths: InlineContentWidthsMemo::default(), text_units: Vec::new(), source_map: Vec::new(), selection: None, objects: Vec::new(), font_metrics: vec![None], parent_strut: None, uses_quirks_line_height: false, root_includes_used_font_metrics: false, style_parents: vec![root], structural_boxes: Vec::new(), line_placements: Vec::new(), fragments: InlineFragments::default(), }; let summary = measure_inline_lines(&context, &layout, &[], &[], &[]); let (placements, materialized_summary) = build_inline_line_placements(&context, &layout, &[], &[], &[]); assert_eq!(summary, materialized_summary); assert_eq!(placements.len(), layout.lines().len()); assert_eq!( placements .iter() .find(|line| !line.phantom) .map(|line| line.baseline), summary.first_baseline ); assert_eq!( placements .iter() .rev() .find(|line| !line.phantom) .map(|line| line.baseline), summary.last_baseline ); } #[test] fn fragment_positions_match_parley_with_bidi_boxes_spacing_and_alignment() { let text = "office a\u{301} אבג alpha beta gamma delta אבג end"; let split = text.find('א').unwrap(); let root = LayoutBoxId::from_index(0); for direction in [parley::BaseDirection::Ltr, parley::BaseDirection::Rtl] { for alignment in [ parley::Alignment::Start, parley::Alignment::End, parley::Alignment::Center, parley::Alignment::Justify, ] { let mut font_context = parley::FontContext::new(); let mut layout_context = parley::LayoutContext::::new(); let mut builder = layout_context.style_run_builder(&mut font_context, text, 1.0, true); builder.set_base_direction(direction); let first = builder.push_style(TextStyle { letter_spacing: 0.75, word_spacing: 2.25, ..TextStyle::default() }); let second = builder.push_style(TextStyle { font_size: 20.0, letter_spacing: -0.25, ..TextStyle::default() }); builder.push_style_run(first, ..split); builder.push_style_run(second, split..); for (id, (index, width)) in [(0, 8.125), (split, 11.75), (text.len(), 5.5)] .into_iter() .enumerate() { builder.push_inline_box(InlineBox { id: id as u64, kind: InlineBoxKind::InFlow, index, width, height: 10.0, baseline: None, vertical_align: parley::VerticalAlign::default(), }); } let mut layout = builder.build(text); layout.set_text_indent(9.25, parley::IndentOptions::default()); layout.break_all_lines(Some(120.0)); layout.align(alignment, parley::AlignmentOptions::default()); assert!(layout.lines().len() > 1); assert!( layout .lines() .flat_map(|line| line.runs()) .any(|run| run.is_rtl()) ); assert!( layout .lines() .flat_map(|line| line.runs()) .any(|run| !run.is_rtl()) ); let mut utf16_offset = 0; let source_map = text .char_indices() .map(|(start, ch)| { let utf16_start = utf16_offset; utf16_offset += ch.len_utf16(); InlineSourceMapEntry { output_range: start..start + ch.len_utf8(), box_id: root, source_byte_range: start..start + ch.len_utf8(), source_utf16_range: utf16_start..utf16_offset, } }) .collect(); let context = InlineFormattingContext { text: text.to_owned(), root_style: root, measurement_layout: None, laid_out: None, content_widths: InlineContentWidthsMemo::default(), text_units: Vec::new(), source_map, selection: None, objects: Vec::new(), font_metrics: Vec::new(), parent_strut: None, uses_quirks_line_height: false, root_includes_used_font_metrics: false, style_parents: Vec::new(), structural_boxes: Vec::new(), line_placements: Vec::new(), fragments: InlineFragments::default(), }; let fragments = build_inline_fragments(&context, &layout, &[]); assert!(!fragments.text.is_empty()); for fragment in fragments.text { let line = layout.lines().nth(fragment.line_index).unwrap(); // Parley's independent, slower position API is the // reference for CSSOM text geometry, including ligatures // and graphemes spanning multiple source characters. let bounds = line .runs() .flat_map(|run| run.visual_clusters()) .filter(|cluster| { let range = cluster.text_range(); range.start < fragment.source_byte_range.end && fragment.source_byte_range.start < range.end }) .map(|cluster| { let x = line.metrics().inline_min_coord + cluster.visual_offset().unwrap(); (x, x + cluster.advance().max(0.0)) }); let (left, right) = bounds .reduce(|(left, right), (x, end)| (left.min(x), right.max(end))) .unwrap(); assert_eq!(fragment.rect.x, left, "{direction:?}, {alignment:?}"); assert!((fragment.rect.right() - right).abs() < 0.001); } } } } fn normalize( chunks: &[(LayoutBoxId, &str)], mode: InlineWhiteSpaceCollapse, transform: InlineTextTransform, ) -> InlineBuildInput { let root = LayoutBoxId::from_index(0); let mut normalizer = InlineNormalizer::new(root); for (box_id, text) in chunks { normalizer.push_text(*box_id, text, mode, transform, &[root]); } normalizer.finish() } #[test] fn preserve_merges_crlf_across_adjacent_text_nodes_with_both_origins() { let first = LayoutBoxId::from_index(1); let second = LayoutBoxId::from_index(2); let input = normalize( &[(first, "A\r"), (second, "\nB")], InlineWhiteSpaceCollapse::Preserve, InlineTextTransform::None, ); assert_eq!(input.text, "A\nB"); assert_eq!( input.source_map, vec![ InlineSourceMapEntry { output_range: 0..1, box_id: first, source_byte_range: 0..1, source_utf16_range: 0..1, }, InlineSourceMapEntry { output_range: 1..2, box_id: first, source_byte_range: 1..2, source_utf16_range: 1..2, }, InlineSourceMapEntry { output_range: 1..2, box_id: second, source_byte_range: 0..1, source_utf16_range: 0..1, }, InlineSourceMapEntry { output_range: 2..3, box_id: second, source_byte_range: 1..2, source_utf16_range: 1..2, }, ] ); } #[test] fn collapse_turns_a_cjk_segment_break_into_space_across_text_nodes() { let first = LayoutBoxId::from_index(1); let second = LayoutBoxId::from_index(2); let input = normalize( &[(first, "\u{4e2d}\n"), (second, "\u{6587}")], InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, ); assert_eq!(input.text, "\u{4e2d} \u{6587}"); assert_eq!(input.source_map.len(), 3); assert_eq!(input.source_map[0].box_id, first); assert_eq!(input.source_map[0].source_byte_range, 0..3); assert_eq!(input.source_map[0].source_utf16_range, 0..1); assert_eq!(input.source_map[1].output_range, 3..4); assert_eq!(input.source_map[1].box_id, first); assert_eq!(input.source_map[1].source_byte_range, 3..4); assert_eq!(input.source_map[1].source_utf16_range, 1..2); assert_eq!(input.source_map[2].box_id, second); assert_eq!(input.source_map[2].source_byte_range, 0..3); assert_eq!(input.source_map[2].source_utf16_range, 0..1); } #[test] fn break_spaces_inserts_non_source_break_controls_after_preserved_spaces() { let text = LayoutBoxId::from_index(1); let input = normalize( &[(text, "A B")], InlineWhiteSpaceCollapse::BreakSpaces, InlineTextTransform::None, ); assert_eq!(input.text, "A \u{200B} \u{200B}B"); assert_eq!(input.units.iter().filter(|unit| unit.control).count(), 2); assert_eq!( input .units .iter() .filter(|unit| unit.break_spaces_opportunity) .count(), 2 ); assert_eq!(input.source_map.len(), 4); assert!( input .source_map .iter() .all(|entry| { &input.text[entry.output_range.clone()] != "\u{200B}" }) ); } #[test] fn collapsed_spaces_remain_in_dom_order_across_inline_boundaries() { let root = LayoutBoxId::from_index(0); let first_inline = LayoutBoxId::from_index(1); let first_text = LayoutBoxId::from_index(2); let outer_space = LayoutBoxId::from_index(3); let second_inline = LayoutBoxId::from_index(4); let second_text = LayoutBoxId::from_index(5); let trailing_text = LayoutBoxId::from_index(6); let mut normalizer = InlineNormalizer::new(root); normalizer.open_inline( first_inline, InlineUnicodeBidi::Normal, InlineDirection::Ltr, &[], InlineVerticalAlign::default(), ); normalizer.push_text( first_text, "A", InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, &[first_inline], ); normalizer.close_inline(first_inline, &[], InlineVerticalAlign::default()); normalizer.push_text( outer_space, " ", InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, &[], ); normalizer.open_inline( second_inline, InlineUnicodeBidi::Embed, InlineDirection::Ltr, &[], InlineVerticalAlign::default(), ); normalizer.push_text( second_text, "B ", InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, &[second_inline], ); normalizer.close_inline(second_inline, &[], InlineVerticalAlign::default()); normalizer.push_text( trailing_text, "C", InlineWhiteSpaceCollapse::Collapse, InlineTextTransform::None, &[], ); let input = normalizer.finish(); assert_eq!(input.text, "A \u{202a}B \u{202c}C"); assert_eq!( input .objects .iter() .map(|(index, object, _)| (*index, object.box_id, object.role)) .collect::>(), vec![ (0, first_inline, InlineObjectRole::StartEdge), (1, first_inline, InlineObjectRole::EndEdge), (5, second_inline, InlineObjectRole::StartEdge), (7, second_inline, InlineObjectRole::EndEdge), ] ); assert_eq!(input.units[1].output_range, 1..2); assert!(input.units[1].ancestors.is_empty()); assert_eq!(input.units[4].output_range, 6..7); assert_eq!(input.units[4].ancestors, vec![second_inline]); } #[test] fn uppercase_expansion_retains_byte_and_utf16_source_ranges() { let text = LayoutBoxId::from_index(1); let input = normalize( &[(text, "\u{df}\u{1f642}")], InlineWhiteSpaceCollapse::Preserve, InlineTextTransform::Uppercase, ); assert_eq!(input.text, "SS\u{1f642}"); assert_eq!(input.source_map.len(), 3); for entry in &input.source_map[..2] { assert_eq!(entry.box_id, text); assert_eq!(entry.source_byte_range, 0..2); assert_eq!(entry.source_utf16_range, 0..1); } assert_eq!(input.source_map[0].output_range, 0..1); assert_eq!(input.source_map[1].output_range, 1..2); assert_eq!(input.source_map[2].output_range, 2..6); assert_eq!(input.source_map[2].source_byte_range, 2..6); assert_eq!(input.source_map[2].source_utf16_range, 1..3); } }