use super::super::*;
fn has_table_or_replaced_descendant(element: &Element) -> bool {
element.children.iter().any(|child| {
let NodeKind::Element(child_element) = &child.kind else {
return false;
};
is_table_or_replaced_element(child_element)
|| has_table_or_replaced_descendant(child_element)
})
}
fn has_table_or_replaced_descendant_box(child_boxes: &[box_tree::FormattingBox<'_>]) -> bool {
child_boxes.iter().any(|child| match child {
box_tree::FormattingBox::Table(_) | box_tree::FormattingBox::Replaced(_) => true,
box_tree::FormattingBox::AtomicInline(box_) => {
is_table_or_replaced_element(box_.core.element)
|| has_table_or_replaced_descendant_box(&box_.core.children)
}
box_tree::FormattingBox::Block(box_) => {
has_table_or_replaced_descendant_box(&box_.core.children)
}
box_tree::FormattingBox::Inline(box_) => {
has_table_or_replaced_descendant_box(&box_.core.children)
}
box_tree::FormattingBox::InlineSplitBlockContext(box_) => {
has_table_or_replaced_descendant_box(&box_.core.children)
}
box_tree::FormattingBox::AnonymousBlock(box_) => {
has_table_or_replaced_descendant_box(&box_.children)
}
box_tree::FormattingBox::Flex(box_) => {
has_table_or_replaced_descendant_box(&box_.core.children)
}
box_tree::FormattingBox::Text(_) => false,
})
}
impl<'a> LayoutBuilder<'a> {
pub(in crate::layout) fn avoid_break_fragmentation_extent(
&mut self,
element: &Element,
style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
available_outer_width: f32,
child_boxes: Option<&[box_tree::FormattingBox<'_>]>,
fragmentation_writing_mode: WritingMode,
) -> Option<LayoutLength> {
if !WritingModeAxes::new(fragmentation_writing_mode, self.containing_block_direction)
.swaps_physical_axes()
{
return self
.estimate_element_height(
element,
style,
stylesheets,
available_outer_width,
child_boxes,
)
.map(layout_pt);
}
let geometry = self.block_layout_geometry(element, style, stylesheets, child_boxes);
let used_style = &geometry.style;
Some(layout_pt(
geometry.outer_inline().width().points()
+ used_style.margin.left
+ used_style.margin.right,
))
}
pub(in crate::layout) fn avoid_break_current_fragmentainer(
&self,
writing_mode: WritingMode,
content_block_start: PageTopBlockPosition,
) -> Fragmentainer {
if WritingModeAxes::new(writing_mode, self.containing_block_direction).swaps_physical_axes()
{
let extent = layout_pt(self.current_page_context.area_width());
Fragmentainer::new(extent, extent)
} else {
self.fragmentainer_from_page_cursor(content_block_start)
}
}
pub(in crate::layout) fn next_empty_avoid_break_fragmentainer(
&mut self,
fragmentainer_kind: FragmentainerKind,
writing_mode: WritingMode,
) -> Fragmentainer {
if !WritingModeAxes::new(writing_mode, self.containing_block_direction)
.swaps_physical_axes()
{
return self.next_empty_fragmentainer(fragmentainer_kind);
}
let context = match fragmentainer_kind {
FragmentainerKind::Page => self.resolved_page_context(
self.destination_document_page_number(self.pages.len() + 2),
false,
),
FragmentainerKind::Column => self
.fragmentainer_override
.map(|override_| override_.context_for_fragmentainer(self.pages.len() + 1))
.unwrap_or(self.current_page_context),
};
let extent = layout_pt(context.area_width());
Fragmentainer::new(extent, extent)
}
pub(in crate::layout) fn should_try_avoid_break_inside(
&self,
style: &ComputedStyle,
fragmentainer_kind: FragmentainerKind,
) -> bool {
let break_context = FragmentBreakContext::for_standalone_box(style);
fragmentainer_kind.avoids_break_inside(style)
&& self.avoid_inside_retry_depth == 0
&& break_context
.forced_break_before_in(fragmentainer_kind)
.is_none()
&& break_context
.forced_break_after_in(fragmentainer_kind)
.is_none()
&& !style.display.is_none()
&& !style.display.is_inline_level()
&& !matches!(style.position, Position::Absolute | Position::Fixed)
&& self.current_page_has_content()
&& !self.cursor_is_at_page_top()
}
pub(in crate::layout) fn should_prebreak_avoid_inside(
&mut self,
element: &Element,
style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
child_boxes: Option<&[box_tree::FormattingBox<'_>]>,
fragmentainer_kind: FragmentainerKind,
) -> bool {
let break_context = FragmentBreakContext::for_standalone_box(style);
if !fragmentainer_kind.avoids_break_inside(style)
|| self.avoid_inside_retry_depth > 0
|| break_context
.forced_break_before_in(fragmentainer_kind)
.is_some()
|| break_context
.forced_break_after_in(fragmentainer_kind)
.is_some()
|| style.display.is_none()
|| style.display.is_inline_level()
|| matches!(style.position, Position::Absolute | Position::Fixed)
|| !child_boxes
.map(has_table_or_replaced_descendant_box)
.unwrap_or_else(|| has_table_or_replaced_descendant(element))
|| !self.current_page_has_content()
|| self.cursor_is_at_page_top()
{
return false;
}
let available_width =
(self.content_right - self.content_left - style.margin.left - style.margin.right)
.max(style.font_size);
let Some(required_block_size) = self.avoid_break_fragmentation_extent(
element,
style,
stylesheets,
available_width,
child_boxes,
self.containing_block_writing_mode,
) else {
return false;
};
let current_fragmentainer = self.avoid_break_current_fragmentainer(
self.containing_block_writing_mode,
PageTopBlockPosition::new(self.cursor_y),
);
let should_break = FragmentPrebreakDecision::choose(FragmentPrebreakInput {
can_advance: true,
current_fragmentainer,
required_block_size,
empty_fragmentainer: current_fragmentainer,
empty_fit_block_size: required_block_size,
})
.should_break;
if should_break {
log::debug!(
"moving break-inside: avoid <{}> to next page: required block extent {:.2}, remaining {:.2}",
element.tag,
required_block_size.points(),
current_fragmentainer.available_block_size().points()
);
}
should_break
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn layout_avoiding_break_inside(
&mut self,
element: &Element,
style: &ComputedStyle,
stylesheets: &Stylesheets<'_>,
run_in_children: &[box_tree::FormattingBox<'_>],
child_boxes: Option<&[box_tree::FormattingBox<'_>]>,
table_fragment: Option<&box_tree::TableFragment<'_>>,
principal_box_paint_mode: PrincipalBoxPaintMode,
) {
let snapshot = self.snapshot();
let pages_before = snapshot.page_count();
self.layout_element_inner_with_principal_effect_context(
element,
style,
stylesheets,
run_in_children,
child_boxes,
table_fragment,
true,
principal_box_paint_mode,
None,
);
if self.pages.len() <= pages_before {
return;
}
let available_width =
(self.content_right - self.content_left - style.margin.left - style.margin.right)
.max(style.font_size);
let avoid_box_fits_empty_page = self
.avoid_break_fragmentation_extent(
element,
style,
stylesheets,
available_width,
child_boxes,
self.containing_block_writing_mode,
)
.is_some_and(|required_block_size| {
self.avoid_break_current_fragmentainer(
self.containing_block_writing_mode,
PageTopBlockPosition::new(self.page_top()),
)
.block_size_fits_empty(required_block_size)
});
self.restore(snapshot);
let continuation = self.block_page_break_continuation_context();
self.push_page_if_nonempty();
if !self.current_page_has_content()
&& self.active_fragmentainer_kind() == FragmentainerKind::Page
{
let page_number = self.destination_document_page_number(self.pages.len() + 1);
let context = self.resolved_page_context(page_number, false);
self.replay_fragment_continuation_on_page(&continuation, context);
}
let mut retry_style = style.clone();
retry_style.break_inside = css::BreakInsideAvoidance::Auto;
if avoid_box_fits_empty_page {
self.avoid_inside_retry_depth += 1;
}
self.layout_element_inner_with_principal_effect_context(
element,
&retry_style,
stylesheets,
run_in_children,
child_boxes,
table_fragment,
true,
principal_box_paint_mode,
None,
);
if avoid_box_fits_empty_page {
self.avoid_inside_retry_depth -= 1;
}
}
}