use std::rc::Rc;
use super::*;
pub(in crate::layout) fn block_bidi_scope_needs_inline_controls(style: &ComputedStyle) -> bool {
matches!(
style.unicode_bidi,
UnicodeBidi::Embed | UnicodeBidi::BidiOverride | UnicodeBidi::IsolateOverride
)
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) enum InlineBoxEdge {
Start,
End,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct InlineElementScopeOptions {
pub(in crate::layout) push_page_scope: bool,
pub(in crate::layout) push_inside_marker: bool,
pub(in crate::layout) mark_hanging_edges: bool,
pub(in crate::layout) preserve_empty_metrics: bool,
pub(in crate::layout) fragment_edges: box_tree::InlineBoxFragmentEdges,
}
impl InlineElementScopeOptions {
pub(in crate::layout) const DOM_INTRINSIC: Self = Self {
push_page_scope: false,
push_inside_marker: true,
mark_hanging_edges: true,
preserve_empty_metrics: false,
fragment_edges: box_tree::InlineBoxFragmentEdges::ALL,
};
pub(in crate::layout) const DOM_PAINT: Self = Self {
push_page_scope: true,
push_inside_marker: true,
mark_hanging_edges: true,
preserve_empty_metrics: false,
fragment_edges: box_tree::InlineBoxFragmentEdges::ALL,
};
pub(in crate::layout) const BOX_PAINT: Self = Self {
push_page_scope: true,
push_inside_marker: true,
mark_hanging_edges: true,
preserve_empty_metrics: false,
fragment_edges: box_tree::InlineBoxFragmentEdges::ALL,
};
pub(in crate::layout) const BOX_INTRINSIC: Self = Self {
push_page_scope: false,
push_inside_marker: false,
mark_hanging_edges: true,
preserve_empty_metrics: false,
fragment_edges: box_tree::InlineBoxFragmentEdges::ALL,
};
pub(in crate::layout) fn with_fragment_edges(
mut self,
fragment_edges: box_tree::InlineBoxFragmentEdges,
) -> Self {
self.fragment_edges = fragment_edges;
self
}
pub(in crate::layout) fn with_preserved_empty_metrics(mut self, preserve: bool) -> Self {
self.preserve_empty_metrics = preserve;
self
}
}
pub(in crate::layout) fn empty_inline_scope_has_distinct_metrics(
parent: &ComputedStyle,
child: &ComputedStyle,
) -> bool {
child.font_family != parent.font_family
|| child.font_size != parent.font_size
|| child.font_style != parent.font_style
|| child.font_weight != parent.font_weight
|| child.font_width != parent.font_width
|| child.font_size_adjust != parent.font_size_adjust
|| child.font_variation_settings != parent.font_variation_settings
|| child.line_height != parent.line_height
|| child.vertical_align != parent.vertical_align
}
#[derive(Debug)]
pub(in crate::layout) struct InlineElementScopeState {
pub(in crate::layout) inline_box_start: usize,
pub(in crate::layout) link_target: Option<String>,
pub(in crate::layout) baseline_shift: f32,
pub(in crate::layout) visual_offset: InlineVisualOffset,
pub(in crate::layout) edge_style: Box<css::ZoomedLayoutStyle>,
pub(in crate::layout) positioning_containing_block_id:
Option<InlinePositioningContainingBlockId>,
pub(in crate::layout) pushed_page_scope: bool,
pub(in crate::layout) mark_hanging_edges: bool,
pub(in crate::layout) preserve_empty_metrics: bool,
pub(in crate::layout) fragment_edges: box_tree::InlineBoxFragmentEdges,
pub(in crate::layout) counter_scope: CounterScopeState,
pub(in crate::layout) counter_snapshot: Option<CounterSet>,
}
impl InlineElementScopeState {
pub(in crate::layout) fn positioning_containing_block_source(
&self,
) -> Option<BorrowedInlinePositioningContainingBlockSource<'_>> {
self.positioning_containing_block_id.map(|id| {
BorrowedInlinePositioningContainingBlockSource {
id,
style: self.edge_style.as_ref(),
}
})
}
}
pub(in crate::layout) fn inline_box_edge_width(
style: &ComputedStyle,
edge: InlineBoxEdge,
) -> LayoutLength {
let (margin, border, padding) = inline_box_edge_components(style, edge);
layout_pt(margin + border + padding)
}
pub(in crate::layout) fn inline_box_edge_has_nonzero_component(
style: &ComputedStyle,
edge: InlineBoxEdge,
) -> bool {
let (margin, border, padding) = inline_box_edge_components(style, edge);
margin.abs() > 0.001 || border.abs() > 0.001 || padding.abs() > 0.001
}
pub(in crate::layout) fn inline_box_edge_components(
style: &ComputedStyle,
edge: InlineBoxEdge,
) -> (f32, f32, f32) {
let side = inline_box_edge_physical_side(style, edge);
let borders = used_border_widths(style);
match side {
PhysicalSide::Top => (style.margin.top, borders.top, style.padding.top),
PhysicalSide::Right => (style.margin.right, borders.right, style.padding.right),
PhysicalSide::Bottom => (style.margin.bottom, borders.bottom, style.padding.bottom),
PhysicalSide::Left => (style.margin.left, borders.left, style.padding.left),
}
}
pub(in crate::layout) fn inline_box_edge_physical_side(
style: &ComputedStyle,
edge: InlineBoxEdge,
) -> PhysicalSide {
match edge {
InlineBoxEdge::Start => inline_start_side(style.writing_mode, style.used_direction()),
InlineBoxEdge::End => inline_end_side(style.writing_mode, style.used_direction()),
}
}
pub(in crate::layout) fn inline_scope_establishes_positioning_containing_block(
style: &ComputedStyle,
) -> bool {
matches!(
style.position,
Position::Absolute | Position::Fixed | Position::Relative | Position::Sticky
) || style.has_transform()
}
pub(in crate::layout) fn mark_inline_box_hanging_edges(
output: &mut [InlineItem],
inline_box_start: usize,
style: &ComputedStyle,
fragment_edges: box_tree::InlineBoxFragmentEdges,
) {
let items = &mut output[inline_box_start..];
let blocks_start = fragment_edges.owns_start && inline_box_blocks_hanging_start(style);
let blocks_end = fragment_edges.owns_end && inline_box_blocks_hanging_end(style);
let has_blocking_edge = blocks_start || blocks_end;
let mut marked_visible_item = false;
if blocks_start && let Some(word) = items.iter_mut().find_map(visible_hanging_edge_word_mut) {
word.hanging_edges.blocks_start = true;
marked_visible_item = true;
}
if blocks_end
&& let Some(word) = items
.iter_mut()
.rev()
.find_map(visible_hanging_edge_word_mut)
{
word.hanging_edges.blocks_end = true;
marked_visible_item = true;
}
if has_blocking_edge
&& !marked_visible_item
&& let Some(word) = output[..inline_box_start]
.iter_mut()
.rev()
.find_map(visible_hanging_edge_word_mut)
{
word.hanging_edges.blocks_end = true;
}
}
pub(in crate::layout) fn mark_inline_box_ancestor_decorations(
output: &mut [InlineItem],
inline_box_start: usize,
style: &ComputedStyle,
positioning_containing_block_id: Option<InlinePositioningContainingBlockId>,
) {
let has_paint_effect_scope = style.opacity.value() < 1.0;
let paint_effect_scope_id = has_paint_effect_scope.then(InlinePaintScopeId::allocate);
if !inline_box_has_paintable_decoration(style)
&& !has_paint_effect_scope
&& positioning_containing_block_id.is_none()
{
return;
}
let mut scope_depth = 0usize;
for item in &mut output[inline_box_start..] {
if let InlineItem::Atom(atom) = item
&& let InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge)) = atom.content()
{
match edge.logical_edge {
InlineLogicalEdge::Start => {
scope_depth += 1;
continue;
}
InlineLogicalEdge::End => {
scope_depth = scope_depth.saturating_sub(1);
continue;
}
}
}
let Some(word) = visible_hanging_edge_word_mut(item) else {
continue;
};
let word_owns_scope_background = style.background.background_color.is_potentially_visible()
&& word.style.background.background_color == style.background.background_color;
let paints_background_or_border =
scope_depth > 1 || (scope_depth > 0 && !word_owns_scope_background);
if !paints_background_or_border
&& !has_paint_effect_scope
&& positioning_containing_block_id.is_none()
{
continue;
}
let mut decorations = word.ancestor_inline_decorations.to_vec();
decorations.push(InlineAncestorDecoration {
style: style.clone(),
hanging_edges: InlineHangingEdges::default(),
paints_background_or_border,
positioning_containing_block_id,
paint_effect_scope_id,
});
word.ancestor_inline_decorations = Rc::from(decorations.into_boxed_slice());
}
}
pub(in crate::layout) fn inline_box_has_paintable_decoration(style: &ComputedStyle) -> bool {
style.background.background_color.is_potentially_visible()
|| style.background.background_image.is_image()
|| used_border_width(style).points() > 0.0
}
pub(in crate::layout) fn visible_hanging_edge_word_mut(
item: &mut InlineItem,
) -> Option<&mut InlineWord> {
let InlineItem::Word(word) = item else {
return None;
};
let text = trim_css_collapsible_whitespace(&word.text);
if text.is_empty() || text.chars().all(character_is_bidi_format_control) {
return None;
}
Some(word)
}
pub(in crate::layout) fn inline_box_blocks_hanging_start(style: &ComputedStyle) -> bool {
match style.direction {
Direction::Ltr => style.padding.left != 0.0 || style.border_widths.left != 0.0,
Direction::Rtl => style.padding.right != 0.0 || style.border_widths.right != 0.0,
}
}
pub(in crate::layout) fn inline_box_blocks_hanging_end(style: &ComputedStyle) -> bool {
match style.direction {
Direction::Ltr => style.padding.right != 0.0 || style.border_widths.right != 0.0,
Direction::Rtl => style.padding.left != 0.0 || style.border_widths.left != 0.0,
}
}
impl<'a> LayoutBuilder<'a> {
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn push_inline_box_edge_item(
&mut self,
style: &ComputedStyle,
edge: InlineBoxEdge,
positioning_containing_block_id: Option<InlinePositioningContainingBlockId>,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
link_target: Option<String>,
output: &mut Vec<InlineItem>,
) {
let width = inline_box_edge_width(style, edge).points();
let (_, border, padding) = inline_box_edge_components(style, edge);
let edge_fragment = InlineBoxEdgeFragment {
logical_edge: match edge {
InlineBoxEdge::Start => InlineLogicalEdge::Start,
InlineBoxEdge::End => InlineLogicalEdge::End,
},
physical_side: inline_box_edge_physical_side(style, edge),
positioning_containing_block_id,
advance: width,
paint_extent: (border + padding).max(0.0),
};
let baseline_offset = self.inline_box_text_line_layout_baseline_offset(style);
output.push(InlineItem::Atom(Box::new(
InlineAtom::new(
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge_fragment)),
style.clone(),
None,
InlineSize::new(width, style.line_height),
baseline_offset,
baseline_shift,
link_target,
None,
)
.with_visual_offset(visual_offset),
)));
}
#[allow(clippy::too_many_arguments)]
fn push_zero_advance_positioning_edge_item(
&mut self,
style: &ComputedStyle,
edge: InlineBoxEdge,
positioning_containing_block_id: InlinePositioningContainingBlockId,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
output: &mut Vec<InlineItem>,
) {
let edge_fragment = InlineBoxEdgeFragment {
logical_edge: match edge {
InlineBoxEdge::Start => InlineLogicalEdge::Start,
InlineBoxEdge::End => InlineLogicalEdge::End,
},
physical_side: inline_box_edge_physical_side(style, edge),
positioning_containing_block_id: Some(positioning_containing_block_id),
advance: 0.0,
paint_extent: 0.0,
};
let baseline_offset = self.inline_box_text_line_layout_baseline_offset(style);
output.push(InlineItem::Atom(Box::new(
InlineAtom::new(
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge_fragment)),
style.clone(),
None,
InlineSize::new(0.0, style.line_height),
baseline_offset,
baseline_shift,
None,
None,
)
.with_visual_offset(visual_offset),
)));
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn push_inline_scope_start_items(
&mut self,
style: &ComputedStyle,
link_target: Option<String>,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
positioning_containing_block_id: Option<InlinePositioningContainingBlockId>,
include_box_edge: bool,
output: &mut Vec<InlineItem>,
) {
let positioned_bidi_isolate = positioning_containing_block_id.is_some()
&& matches!(
style.unicode_bidi,
UnicodeBidi::Isolate | UnicodeBidi::IsolateOverride | UnicodeBidi::Plaintext
);
let outer_positioning_containing_block_id = if positioned_bidi_isolate {
None
} else {
positioning_containing_block_id
};
if include_box_edge {
self.push_inline_box_edge_item(
style,
InlineBoxEdge::Start,
outer_positioning_containing_block_id,
baseline_shift,
visual_offset,
None,
output,
);
}
self.push_bidi_scope_start(style, link_target, baseline_shift, visual_offset, output);
if positioned_bidi_isolate
&& let Some(positioning_containing_block_id) = positioning_containing_block_id
{
self.push_zero_advance_positioning_edge_item(
style,
InlineBoxEdge::Start,
positioning_containing_block_id,
baseline_shift,
visual_offset,
output,
);
}
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn push_inline_scope_end_items(
&mut self,
style: &ComputedStyle,
link_target: Option<String>,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
positioning_containing_block_id: Option<InlinePositioningContainingBlockId>,
include_box_edge: bool,
output: &mut Vec<InlineItem>,
) {
let positioned_bidi_isolate = positioning_containing_block_id.is_some()
&& matches!(
style.unicode_bidi,
UnicodeBidi::Isolate | UnicodeBidi::IsolateOverride | UnicodeBidi::Plaintext
);
let outer_positioning_containing_block_id = if positioned_bidi_isolate {
None
} else {
positioning_containing_block_id
};
if positioned_bidi_isolate
&& let Some(positioning_containing_block_id) = positioning_containing_block_id
{
self.push_zero_advance_positioning_edge_item(
style,
InlineBoxEdge::End,
positioning_containing_block_id,
baseline_shift,
visual_offset,
output,
);
}
self.push_bidi_scope_end(style, link_target, baseline_shift, visual_offset, output);
if include_box_edge {
self.push_inline_box_edge_item(
style,
InlineBoxEdge::End,
outer_positioning_containing_block_id,
baseline_shift,
visual_offset,
None,
output,
);
}
}
pub(in crate::layout) fn begin_inline_element_scope(
&mut self,
element: &Element,
style: &ComputedStyle,
link_target: Option<String>,
placement: InlinePlacement,
options: InlineElementScopeOptions,
output: &mut Vec<InlineItem>,
) -> InlineElementScopeState {
let counter_snapshot = (!options.push_page_scope).then(|| self.counter_set.clone());
let counter_scope = self.begin_counter_scope(element, style);
let inline_box_start = output.len();
let mut edge_style = self.style_with_current_used_lengths(style);
if style.line_height_is_normal() {
let used_line_height = self
.font_system
.resolved_inline_text_metrics(style)
.line_block_size()
.points();
edge_style.line_height = used_line_height;
edge_style.line_height_value = css::ComputedLineHeight::from_points(used_line_height);
}
let edge_percentage_basis = if options.push_page_scope {
self.current_content_logical_inline_content_size()
} else {
LogicalInlineContentSize::new(content_box_pt(0.0))
};
apply_used_box_metrics_for_logical_inline_basis(
&mut edge_style,
PercentageBasis::definite(edge_percentage_basis),
);
let fragment_edges = if edge_style.box_decoration_break == css::BoxDecorationBreak::Clone {
box_tree::InlineBoxFragmentEdges::ALL
} else {
options.fragment_edges
};
let positioning_containing_block_id =
inline_scope_establishes_positioning_containing_block(&edge_style)
.then_some(InlinePositioningContainingBlockId(inline_box_start));
let pushed_page_scope = false;
if pushed_page_scope {
output.push(InlineItem::PageScopeStart(
style
.page
.specified_name()
.map(|name| name.as_str().to_string()),
));
}
self.push_inline_scope_start_items(
&edge_style,
link_target.clone(),
placement.baseline_shift(),
placement.visual_offset,
positioning_containing_block_id,
fragment_edges.owns_start,
output,
);
if options.push_inside_marker
&& style.display.is_list_item()
&& (style.list_style_position == ListStylePosition::Inside
|| style.display.is_inline_level())
&& let Some(marker) =
self.marker_for_list_item(element, style, self.containing_block_direction)
{
self.push_inside_marker_items(&marker, style, link_target.clone(), output);
}
InlineElementScopeState {
inline_box_start,
link_target,
baseline_shift: placement.baseline_shift(),
visual_offset: placement.visual_offset,
edge_style: Box::new(edge_style),
positioning_containing_block_id,
pushed_page_scope,
mark_hanging_edges: options.mark_hanging_edges,
preserve_empty_metrics: options.preserve_empty_metrics,
fragment_edges,
counter_scope,
counter_snapshot,
}
}
pub(in crate::layout) fn end_inline_element_scope(
&mut self,
state: InlineElementScopeState,
_style: &ComputedStyle,
output: &mut Vec<InlineItem>,
) {
let InlineElementScopeState {
inline_box_start,
link_target,
baseline_shift,
visual_offset,
edge_style,
positioning_containing_block_id,
pushed_page_scope,
mark_hanging_edges,
preserve_empty_metrics,
fragment_edges,
counter_scope,
counter_snapshot,
} = state;
self.push_inline_scope_end_items(
&edge_style,
link_target,
baseline_shift,
visual_offset,
positioning_containing_block_id,
fragment_edges.owns_end,
output,
);
if pushed_page_scope {
output.push(InlineItem::PageScopeEnd);
}
if mark_hanging_edges {
mark_inline_box_hanging_edges(output, inline_box_start, &edge_style, fragment_edges);
}
if !edge_style.display.is_contents() {
mark_inline_box_ancestor_decorations(
output,
inline_box_start,
&edge_style,
positioning_containing_block_id,
);
}
if preserve_empty_metrics
&& inline_scope_has_only_structural_items(&output[inline_box_start..])
&& let Some(atom) = output[inline_box_start..].iter_mut().find_map(|item| {
let InlineItem::Atom(atom) = item else {
return None;
};
matches!(atom.content(), InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge))
if edge.advance == 0.0 && edge.paint_extent == 0.0 && !edge.is_positioning_marker())
.then_some(atom)
})
{
atom.mark_metrics_only_strut();
}
self.end_counter_scope(counter_scope);
if let Some(counter_snapshot) = counter_snapshot {
self.counter_set = counter_snapshot;
}
}
pub(in crate::layout) fn collect_element_content_or_inline_items(
&mut self,
element: &Element,
style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
inherited_link: Option<String>,
placement: InlinePlacement,
output: &mut Vec<InlineItem>,
) {
if style.content.is_generated() {
self.push_element_content_items_from_dom(
element,
style,
stylesheets,
inherited_link,
placement,
output,
);
} else {
self.collect_inline_items(
element,
style,
stylesheets,
inherited_link,
placement,
output,
);
}
}
}
fn inline_scope_has_only_structural_items(items: &[InlineItem]) -> bool {
items.iter().all(|item| match item {
InlineItem::Atom(atom) => matches!(
atom.content(),
InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(_))
),
InlineItem::Word(word) => word.source == InlineTextSource::BidiControl,
InlineItem::StaticPositionSourceMarker(_) => true,
InlineItem::Float(_)
| InlineItem::Break(_)
| InlineItem::PageScopeStart(_)
| InlineItem::PageScopeEnd => false,
})
}
pub(super) fn mark_inline_text_items_as_run_in(items: &mut [InlineItem]) {
for item in items {
if let InlineItem::Word(word) = item
&& word.source != InlineTextSource::Marker
{
word.source = InlineTextSource::RunIn;
}
}
}
impl<'a> LayoutBuilder<'a> {
pub(in crate::layout) fn push_bidi_scope_start(
&mut self,
style: &ComputedStyle,
link_target: Option<String>,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
output: &mut Vec<InlineItem>,
) {
if let Some((start, _)) = bidi_control_scope_for_style(style) {
self.push_bidi_control_text(
start,
style,
link_target,
InlinePlacement::new(baseline_shift, visual_offset),
output,
);
}
}
pub(in crate::layout) fn push_bidi_scope_end(
&mut self,
style: &ComputedStyle,
link_target: Option<String>,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
output: &mut Vec<InlineItem>,
) {
if let Some((_, end)) = bidi_control_scope_for_style(style) {
self.push_bidi_control_text(
end,
style,
link_target,
InlinePlacement::new(baseline_shift, visual_offset),
output,
);
}
}
pub(in crate::layout) fn push_bidi_control_text(
&mut self,
text: &str,
style: &ComputedStyle,
link_target: Option<String>,
placement: InlinePlacement,
output: &mut Vec<InlineItem>,
) {
if !text.is_empty() {
output.push(InlineItem::Word(Box::new(InlineWord {
text: text.to_string(),
style: inline_style(style),
baseline_shift: placement.baseline_shift(),
visual_offset: placement.visual_offset,
link_target: link_target.map(Rc::from),
mergeable: true,
source: InlineTextSource::BidiControl,
hanging_edges: InlineHangingEdges::default(),
excluded_positioning_geometry_source: None,
ancestor_inline_decorations: Vec::new().into(),
})));
}
}
pub(in crate::layout) fn push_inline_words(
&mut self,
text: &str,
style: &ComputedStyle,
link_target: Option<String>,
baseline_shift: f32,
visual_offset: InlineVisualOffset,
output: &mut Vec<InlineItem>,
) {
push_inline_words_for_style(
text,
style,
link_target,
baseline_shift,
visual_offset,
output,
);
}
}
pub(in crate::layout) fn has_inline_container_formatting_box(
children: &[box_tree::FormattingBox<'_>],
) -> bool {
children.iter().any(|child| match child {
box_tree::FormattingBox::Inline(box_) if box_.core.element.tag == "br" => {
has_inline_container_formatting_box(&box_.core.children)
}
box_tree::FormattingBox::Inline(_) => true,
box_tree::FormattingBox::Text(_) | box_tree::FormattingBox::Replaced(_) => false,
_ => has_inline_container_formatting_box(child.children()),
})
}
pub(in crate::layout) fn has_out_of_flow_formatting_box(
children: &[box_tree::FormattingBox<'_>],
) -> bool {
children.iter().any(|child| {
box_tree::is_out_of_flow_box(child) || has_out_of_flow_formatting_box(child.children())
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn block_plaintext_uses_per_paragraph_bidi_resolution_without_controls() {
let mut plaintext = ComputedStyle::initial();
plaintext.unicode_bidi = UnicodeBidi::Plaintext;
assert!(
!block_bidi_scope_needs_inline_controls(&plaintext),
"block plaintext must not wrap multiple forced paragraphs in one FSI/PDI scope"
);
let mut inline_plaintext = ComputedStyle::initial();
inline_plaintext.display = Display::INLINE;
inline_plaintext.unicode_bidi = UnicodeBidi::Plaintext;
assert_eq!(
bidi_control_scope_for_style(&inline_plaintext),
Some(("\u{2068}", "\u{2069}")),
"inline plaintext remains an isolate"
);
let mut override_style = ComputedStyle::initial();
override_style.unicode_bidi = UnicodeBidi::BidiOverride;
assert!(block_bidi_scope_needs_inline_controls(&override_style));
}
}