use super::*;
pub(in crate::layout) fn has_styled_inline_descendant_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
has_styled_inline_descendant_with_inline_flow_scope(
element,
parent_style,
stylesheets,
ancestors,
false,
&mut resolver,
)
}
fn has_styled_inline_descendant_with_inline_flow_scope(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
inside_inline_flow: bool,
resolver: &mut DomStyleResolver<'_>,
) -> bool {
let has_non_phantom_direct_text = element.children.iter().any(|child| {
matches!(
&child.kind,
NodeKind::Text(text) if inline_text_has_non_phantom_content(text, parent_style)
)
});
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
element.children.iter().any(|child| {
let NodeKind::Element(child_element) = &child.kind else {
return false;
};
let signature =
ElementSignature::from_sibling_snapshot(element_index, sibling_tags.clone())
.expect("source child must have a cached sibling signature");
element_index += 1;
let child_style = resolver.style_for_element(
child_element,
signature.clone(),
stylesheets,
Some(parent_style),
ancestors,
);
if child_style.display.is_none() {
return true;
}
if matches!(child_style.position, Position::Absolute | Position::Fixed) {
return true;
}
if child_style.float != Float::None {
return inside_inline_flow || has_non_phantom_direct_text;
}
if child_style.display.is_block_level() {
return false;
}
if child_style.display.is_ruby() {
return true;
}
if child_element.attrs.contains_key("href") {
return true;
}
if (child_style.display.is_atomic_inline() || is_replaced_element(child_element))
&& child_style.display.is_inline_level()
|| (child_style.display.is_table() && child_style.display.is_inline_or_run_in_level())
{
return true;
}
inline_style_affects_line(parent_style, &child_style) || {
let mut child_ancestors = ancestors.to_vec();
child_ancestors.push(signature);
has_styled_inline_descendant_with_inline_flow_scope(
child_element,
&child_style,
stylesheets,
&child_ancestors,
inside_inline_flow
|| (child_style.display.is_inline_level() && child_style.display.is_flow()),
resolver,
)
}
})
}
pub(in crate::layout) fn inline_style_affects_line(
parent: &ComputedStyle,
child: &ComputedStyle,
) -> bool {
child.before_style.is_some()
|| child.after_style.is_some()
|| inline_bidi_scope_affects_line_ordering(child)
|| child.float != Float::None
|| child.color != parent.color
|| 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_palette != parent.font_palette
|| child.line_height != parent.line_height
|| child.text_decoration != parent.text_decoration
|| child.text_transform != parent.text_transform
|| child.word_space_transform != parent.word_space_transform
|| child.tab_size != parent.tab_size
|| child.vertical_align != parent.vertical_align
|| child.white_space != parent.white_space
|| inline_break_policy_differs(parent, child)
|| child.background.background_color.is_potentially_visible()
|| child.background.background_image.is_image()
|| child.background.background_layers.iter().any(|layer| layer.image.is_image())
|| used_border_width(child) > layout_pt(0.0)
|| child.margin != parent.margin
|| child.padding != parent.padding
|| child.box_values.margin != parent.box_values.margin
|| child.box_values.padding != parent.box_values.padding
|| matches!(child.position, Position::Relative | Position::Sticky)
|| child.opacity.value() < 1.0
}
fn inline_break_policy_differs(parent: &ComputedStyle, child: &ComputedStyle) -> bool {
child.language != parent.language
|| child.hyphens != parent.hyphens
|| child.hyphenate_character != parent.hyphenate_character
|| child.hyphenate_limit_chars != parent.hyphenate_limit_chars
|| child.word_break != parent.word_break
|| child.overflow_wrap != parent.overflow_wrap
|| child.line_break != parent.line_break
|| child.text_wrap_mode != parent.text_wrap_mode
|| child.text_wrap_style != parent.text_wrap_style
}
pub(in crate::layout) fn has_direct_inline_replaced_child(element: &Element) -> bool {
element.children.iter().any(|child| {
matches!(&child.kind, NodeKind::Element(child_element) if is_replaced_element(child_element))
})
}
pub(in crate::layout) fn has_direct_flow_child_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
font_system: &mut FontSystem,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
has_direct_flow_child_with_resolver(element, parent_style, stylesheets, &mut resolver)
}
pub(in crate::layout) fn has_direct_float_only_source_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
font_system: &mut FontSystem,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
let mut has_float = false;
for child in &element.children {
match &child.kind {
NodeKind::Text(text) => {
if inline_text_has_non_phantom_content(text, parent_style) {
return false;
}
}
NodeKind::Element(child_element) => {
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let style = resolver.structural_style_for_element(
child_element,
signature,
stylesheets,
Some(parent_style),
&[],
);
if style.display.is_none()
|| matches!(style.position, Position::Absolute | Position::Fixed)
{
continue;
}
match style.float.layout_role() {
FloatLayoutRole::Exclusion => has_float = true,
FloatLayoutRole::None | FloatLayoutRole::Footnote => return false,
}
}
}
}
has_float
}
pub(in crate::layout) fn has_direct_flow_child_with_resolver(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
resolver: &mut DomStyleResolver<'_>,
) -> bool {
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
element.children.iter().any(|child| {
let NodeKind::Element(child_element) = &child.kind else {
return false;
};
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let style = resolver.structural_style_for_element(
child_element,
signature,
stylesheets,
Some(parent_style),
&[],
);
if is_replaced_element(child_element) && style.display.is_inline_level() {
return false;
}
style.display.is_block_level()
})
}
pub(in crate::layout) fn has_ordered_mixed_flow_content_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
has_ordered_mixed_flow_content_with_resolver(
element,
parent_style,
stylesheets,
ancestors,
&mut resolver,
)
}
pub(in crate::layout) fn requires_suppressed_dom_source_collection_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
) -> bool {
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
let mut resolver = DomStyleResolver::with_font_system(font_system);
element.children.iter().any(|child| {
let NodeKind::Element(child_element) = &child.kind else {
return false;
};
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let child_style = resolver.style_for_element(
child_element,
signature,
stylesheets,
Some(parent_style),
ancestors,
);
child_style.display.is_none() && !inline_text(child_element).is_empty()
})
}
pub(in crate::layout) fn has_block_in_inline_split_boundary_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
has_block_in_inline_split_boundary_with_resolver(
element,
parent_style,
stylesheets,
ancestors,
false,
&mut resolver,
)
}
pub(in crate::layout) fn has_ruby_formatting_descendant_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
cached_descendants: &mut HashMap<ElementId, bool>,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
has_ruby_formatting_descendant_with_resolver(
element,
parent_style,
stylesheets,
ancestors,
&mut resolver,
cached_descendants,
)
}
pub(in crate::layout) fn has_unwrapped_table_internal_descendant_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
) -> bool {
let mut resolver = DomStyleResolver::with_font_system(font_system);
let mut ancestor_stack = ancestors.to_vec();
has_unwrapped_table_internal_descendant_with_resolver(
element,
parent_style,
stylesheets,
&mut ancestor_stack,
&mut resolver,
)
}
pub(in crate::layout) fn has_direct_run_in_child_with_font_metrics(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
font_system: &mut FontSystem,
) -> bool {
let sibling_tags = element_sibling_signature_list(element);
let mut resolver = DomStyleResolver::with_font_system(font_system);
let mut element_index = 0usize;
element.children.iter().any(|child| {
let NodeKind::Element(child_element) = &child.kind else {
return false;
};
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
resolver
.structural_style_for_element(
child_element,
signature,
stylesheets,
Some(parent_style),
ancestors,
)
.display
.is_run_in()
})
}
fn has_unwrapped_table_internal_descendant_with_resolver(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &mut Vec<ElementSignature>,
resolver: &mut DomStyleResolver<'_>,
) -> bool {
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
for child in &element.children {
let NodeKind::Element(child_element) = &child.kind else {
continue;
};
let signature =
ElementSignature::from_sibling_snapshot(element_index, sibling_tags.clone())
.expect("source child must have a cached sibling signature");
element_index += 1;
let child_style = resolver.structural_style_for_element(
child_element,
signature.clone(),
stylesheets,
Some(parent_style),
ancestors,
);
if child_style.display.is_none() {
continue;
}
if is_table_internal_display(child_style.display) {
return true;
}
if child_style.display.is_table() {
continue;
}
ancestors.push(signature);
let has_unwrapped_descendant = has_unwrapped_table_internal_descendant_with_resolver(
child_element,
&child_style,
stylesheets,
ancestors,
resolver,
);
let popped = ancestors.pop();
debug_assert!(
popped.is_some(),
"recursive table probe must pop its pushed ancestor"
);
if has_unwrapped_descendant {
return true;
}
}
false
}
fn is_table_internal_display(display: Display) -> bool {
matches!(
display.inner,
DisplayInner::TableCaption
| DisplayInner::TableColumnGroup
| DisplayInner::TableColumn
| DisplayInner::TableHeaderGroup
| DisplayInner::TableRowGroup
| DisplayInner::TableFooterGroup
| DisplayInner::TableRow
| DisplayInner::TableCell
)
}
fn has_block_in_inline_split_boundary_with_resolver(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
inside_inline_flow: bool,
resolver: &mut DomStyleResolver<'_>,
) -> bool {
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
for child in &element.children {
let NodeKind::Element(child_element) = &child.kind else {
continue;
};
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let child_style = resolver.structural_style_for_element(
child_element,
signature.clone(),
stylesheets,
Some(parent_style),
ancestors,
);
if child_style.display.is_none() {
continue;
}
if inside_inline_flow && is_normal_block_flow_child(child_element, &child_style) {
return true;
}
let continues_inline_flow = child_style.display.is_contents()
|| ((child_style.display.is_inline_level() && child_style.display.is_flow())
|| child_style.display.is_ruby()
|| child_style.display.is_ruby_internal())
&& child_style.float == Float::None
&& matches!(
child_style.position,
Position::Static | Position::Relative | Position::Running(_)
);
if continues_inline_flow {
let mut child_ancestors = ancestors.to_vec();
child_ancestors.push(signature);
if has_block_in_inline_split_boundary_with_resolver(
child_element,
&child_style,
stylesheets,
&child_ancestors,
true,
resolver,
) {
return true;
}
}
}
false
}
fn has_ruby_formatting_descendant_with_resolver(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
resolver: &mut DomStyleResolver<'_>,
cached_descendants: &mut HashMap<ElementId, bool>,
) -> bool {
if let Some(&contains_ruby) = cached_descendants.get(&element.id) {
return contains_ruby;
}
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
for child in &element.children {
let NodeKind::Element(child_element) = &child.kind else {
continue;
};
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let child_style = resolver.structural_style_for_element(
child_element,
signature.clone(),
stylesheets,
Some(parent_style),
ancestors,
);
if child_style.display.is_none() {
continue;
}
if child_style.display.is_ruby() {
cached_descendants.insert(element.id, true);
return true;
}
let continues_inline_flow = child_style.display.is_contents()
|| ((child_style.display.is_inline_level() && child_style.display.is_flow())
|| child_style.display.is_ruby_internal())
&& child_style.float == Float::None
&& matches!(
child_style.position,
Position::Static | Position::Relative | Position::Running(_)
);
if !continues_inline_flow {
continue;
}
let mut child_ancestors = ancestors.to_vec();
child_ancestors.push(signature);
if has_ruby_formatting_descendant_with_resolver(
child_element,
&child_style,
stylesheets,
&child_ancestors,
resolver,
cached_descendants,
) {
cached_descendants.insert(element.id, true);
return true;
}
}
cached_descendants.insert(element.id, false);
false
}
pub(in crate::layout) fn has_ordered_mixed_flow_content_with_resolver(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
resolver: &mut DomStyleResolver<'_>,
) -> bool {
if suppresses_ordered_mixed_flow_detection(element) {
return false;
}
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
let mut has_inline = false;
let mut has_flow = false;
let mut has_positioned_static_boundary = false;
let mut has_block_static_boundary_after_flow = false;
let mut has_later_float_after_static_boundary = false;
for child in &element.children {
match &child.kind {
NodeKind::Text(text) => {
if !normalize_inline_text(text).is_empty() {
has_inline = true;
}
}
NodeKind::Element(child_element) => {
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let child_style = resolver.style_for_element(
child_element,
signature.clone(),
stylesheets,
Some(parent_style),
ancestors,
);
if child_style.display.is_none() {
continue;
}
if child_style.float.layout_role() == FloatLayoutRole::Footnote {
return true;
}
if matches!(child_style.position, Position::Absolute | Position::Fixed) {
let is_block_static_boundary = child_style.display.is_block_level();
has_positioned_static_boundary |= is_block_static_boundary;
has_block_static_boundary_after_flow |= is_block_static_boundary && has_flow;
has_inline |= child_style.display.is_inline_level();
continue;
}
let is_float_source = child_style.float.layout_role() == FloatLayoutRole::Exclusion;
let is_normal_flow_child = is_normal_block_flow_child(child_element, &child_style)
|| (is_html_table_element(child_element)
&& child_style.display.is_block_level())
|| (is_replaced_element(child_element)
&& child_style.display.is_block_level());
if is_float_source || is_normal_flow_child {
has_later_float_after_static_boundary |= has_block_static_boundary_after_flow
&& matches!(
child_style.float,
Float::Left | Float::Right | Float::InlineStart | Float::InlineEnd
);
has_flow |= is_normal_flow_child;
} else if child_style.display.is_contents() {
let mut child_ancestors = ancestors.to_vec();
child_ancestors.push(signature);
if display_contents_has_inline_flow_contribution_with_resolver(
child_element,
&child_style,
stylesheets,
&child_ancestors,
resolver,
) {
has_inline = true;
}
} else if child_style.display.is_inline_level()
|| is_line_break_element(child_element)
|| !inline_text(child_element).is_empty()
{
has_inline = true;
}
}
}
if (has_inline && (has_flow || has_positioned_static_boundary))
|| has_later_float_after_static_boundary
{
return true;
}
}
false
}
fn display_contents_has_inline_flow_contribution_with_resolver(
element: &Element,
parent_style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
ancestors: &[ElementSignature],
resolver: &mut DomStyleResolver<'_>,
) -> bool {
let sibling_tags = element_sibling_signature_list(element);
let mut element_index = 0usize;
for child in &element.children {
match &child.kind {
NodeKind::Text(text) => {
if !normalize_inline_text(text).is_empty() {
return true;
}
}
NodeKind::Element(child_element) => {
let signature = ElementSignature::with_sibling_list(
child_element.tag.clone(),
child_element.attrs.clone(),
element_index,
sibling_tags.clone(),
);
element_index += 1;
let child_style = resolver.style_for_element(
child_element,
signature.clone(),
stylesheets,
Some(parent_style),
ancestors,
);
if child_style.display.is_none() {
continue;
}
let preserves_parent_inline_context = child_style.display.is_contents()
|| (child_style.display.is_inline_level()
&& child_style.float == Float::None
&& matches!(
child_style.position,
Position::Static | Position::Relative | Position::Running(_)
));
if !preserves_parent_inline_context {
continue;
}
let has_generated_inline_content = child_style
.before_style
.as_deref()
.is_some_and(generated_content_has_non_phantom_inline_content)
|| child_style
.after_style
.as_deref()
.is_some_and(generated_content_has_non_phantom_inline_content);
if has_generated_inline_content || child_style.display.is_inline_level() {
return true;
}
debug_assert!(child_style.display.is_contents());
let mut child_ancestors = ancestors.to_vec();
child_ancestors.push(signature);
if display_contents_has_inline_flow_contribution_with_resolver(
child_element,
&child_style,
stylesheets,
&child_ancestors,
resolver,
) {
return true;
}
}
}
}
false
}
#[cfg(test)]
mod tests;