use super::super::super::*;
use super::HypotheticalClearBorderEdge;
use super::exclusions::FLOAT_EPSILON;
use super::model::*;
pub(in crate::layout) fn float_avoiding_auto_border_box_width(
band: PageInlineSpan,
containing: PageInlineSpan,
margin_left: f32,
margin_right: f32,
) -> BorderBoxLength {
let left_margin = if band.left_x() > containing.left_x() + FLOAT_EPSILON {
0.0
} else {
margin_left
};
let right_margin = if band.right_x() < containing.right_x() - FLOAT_EPSILON {
0.0
} else {
margin_right
};
border_box_pt((band.width() - left_margin - right_margin).max(0.0))
}
impl FloatContext {
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn avoiding_position(
&self,
page_index: usize,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
containing_inline_span: PageInlineSpan,
) -> FloatBandPlacement {
self.avoiding_position_with_role(
page_index,
top,
margin_box_size,
clear,
placement_axes,
containing_inline_span,
true,
)
}
#[allow(clippy::too_many_arguments)]
fn avoiding_bfc_position(
&self,
page_index: usize,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
containing_inline_span: PageInlineSpan,
) -> FloatBandPlacement {
self.avoiding_position_with_role(
page_index,
top,
margin_box_size,
clear,
placement_axes,
containing_inline_span,
false,
)
}
#[allow(clippy::too_many_arguments)]
fn avoiding_position_with_role(
&self,
page_index: usize,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
containing_inline_span: PageInlineSpan,
is_float: bool,
) -> FloatBandPlacement {
let width = margin_box_size.width;
let height = margin_box_size.height;
let mut top = self.clearance_top(
clear,
placement_axes,
page_index,
HypotheticalClearBorderEdge::new(top),
);
if is_float
&& let Some(last) = self
.shapes
.iter()
.rev()
.find(|shape| shape.is_css_float() && shape.page_index == page_index)
{
top = top.min(PageTopBlockPosition::new(
last.margin_box_block_span().top_y(),
));
}
for _ in 0..self.shapes.len().saturating_add(2) {
let block_span = PageBlockSpan::new(top.points(), height);
let band = self.placement_band(page_index, block_span, containing_inline_span);
let available_width = band.width();
if width <= available_width + FLOAT_EPSILON {
return FloatBandPlacement::new(band, top);
}
let next_top = self
.active_placement_shapes(page_index, block_span)
.map(|shape| PageTopBlockPosition::new(shape.margin_box_block_span().bottom_y()))
.fold(top, PageTopBlockPosition::min);
if next_top.points() >= top.points() - FLOAT_EPSILON {
return FloatBandPlacement::new(band, top);
}
top = next_top;
}
let band = self.placement_band(
page_index,
PageBlockSpan::new(top.points(), height),
containing_inline_span,
);
FloatBandPlacement::new(band, top)
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn avoiding_bfc_root_position<F>(
&self,
page_index: usize,
top: PageTopBlockPosition,
clear: Clear,
placement_axes: FloatPlacementAxes,
left: f32,
right: f32,
mut measure: F,
) -> FloatAvoidingBfcPlacement
where
F: FnMut(FloatBand, PageTopBlockPosition) -> FloatAvoidanceCandidate,
{
let mut top = self.clearance_top(
clear,
placement_axes,
page_index,
HypotheticalClearBorderEdge::new(top),
);
let inline_span = PageInlineSpan::from_edges(left, right);
let mut last_placement = None;
for _ in 0..self.shapes.len().saturating_add(2) {
let mut band = self.content_band(
page_index,
PageBlockSpan::new(top.points(), FLOAT_EPSILON),
inline_span,
);
let mut measured = measure(band, top);
let mut stable = false;
for _ in 0..self.shapes.len().saturating_add(3) {
let height = measured
.normal_flow_border_box_block_size
.points()
.max(FLOAT_EPSILON);
let next_band = self.content_band(
page_index,
PageBlockSpan::new(top.points(), height),
inline_span,
);
let next_measured = measure(next_band, top);
stable = (next_band.left() - band.left()).abs() <= FLOAT_EPSILON
&& (next_band.width() - band.width()).abs() <= FLOAT_EPSILON
&& (next_measured.normal_flow_border_box_inline_span.width()
- measured.normal_flow_border_box_inline_span.width())
.abs()
<= FLOAT_EPSILON
&& (next_measured.normal_flow_border_box_block_size.points()
- measured.normal_flow_border_box_block_size.points())
.abs()
<= FLOAT_EPSILON;
band = next_band;
measured = next_measured;
if stable {
break;
}
}
let placement = FloatAvoidingBfcPlacement {
placement: FloatBandPlacement::new(band, top),
candidate: measured,
};
last_placement = Some(placement);
let border_box_span = measured.normal_flow_border_box_inline_span;
let border_box_block_span = PageBlockSpan::new(
top.points(),
measured
.normal_flow_border_box_block_size
.points()
.max(FLOAT_EPSILON),
);
let avoids_active_floats =
self.active_shapes(page_index, border_box_block_span)
.all(|shape| {
if shape.margin_box_inline_span().width() <= FLOAT_EPSILON {
return true;
}
let Some(shape_span) = shape
.area
.horizontal_edges(shape.rect, border_box_block_span)
else {
return true;
};
border_box_span.right_x() <= shape_span.left_x() + FLOAT_EPSILON
|| border_box_span.left_x() >= shape_span.right_x() - FLOAT_EPSILON
});
let fits_containing_inline_span = (measured.permits_inline_start_overflow()
|| border_box_span.left_x() >= left - FLOAT_EPSILON)
&& (measured.permits_inline_end_overflow()
|| border_box_span.right_x() <= right + FLOAT_EPSILON);
if stable && avoids_active_floats && fits_containing_inline_span {
return placement;
}
let block_span = PageBlockSpan::new(
top.points(),
measured
.normal_flow_border_box_block_size
.points()
.max(FLOAT_EPSILON),
);
let rectangular_next_top = self
.active_shapes(page_index, block_span)
.map(|shape| PageTopBlockPosition::new(shape.margin_box_block_span().bottom_y()))
.fold(top, PageTopBlockPosition::min);
let shaped_next_top = self.next_content_slab_with_width(
page_index,
block_span,
inline_span,
measured.normal_flow_border_box_inline_span.width(),
);
let next_top = shaped_next_top
.filter(|next_top| next_top.points() < top.points() - FLOAT_EPSILON)
.unwrap_or(rectangular_next_top);
if next_top.points() >= top.points() - FLOAT_EPSILON {
return placement;
}
top = next_top;
}
last_placement.unwrap_or_else(|| {
let band = self.content_band(
page_index,
PageBlockSpan::new(top.points(), FLOAT_EPSILON),
inline_span,
);
let measured = measure(band, top);
FloatAvoidingBfcPlacement {
placement: FloatBandPlacement::new(band, top),
candidate: measured,
}
})
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn vertical_avoiding_position(
&self,
page_index: usize,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
avoidance_writing_mode: WritingMode,
direction: Direction,
block_slab: PageInlineSpan,
page_bottom: PageTopBlockPosition,
side: Option<UsedFloatSide>,
) -> FloatBandPlacement {
let width = margin_box_size.width;
let height = margin_box_size.height;
let top = self.clearance_top(
clear,
placement_axes,
page_index,
HypotheticalClearBorderEdge::new(top),
);
let inline_size = (top.points() - page_bottom.points()).max(height).max(1.0);
let inline_physical_start = match inline_start_side(avoidance_writing_mode, direction) {
PhysicalSide::Top => top,
PhysicalSide::Bottom => page_bottom,
PhysicalSide::Left | PhysicalSide::Right => {
unreachable!("a vertical containing block has a vertical inline axis")
}
};
let block_start = block_start_side(avoidance_writing_mode);
let initial_block_slab = match block_start {
PhysicalSide::Left => PageInlineSpan::new(block_slab.left_x(), width.max(1.0)),
PhysicalSide::Right => PageInlineSpan::from_edges(
(block_slab.right_x() - width.max(1.0)).max(block_slab.left_x()),
block_slab.right_x(),
),
PhysicalSide::Top | PhysicalSide::Bottom => {
unreachable!("a vertical writing mode has a horizontal block axis")
}
};
if !self.shapes.iter().any(FloatShape::is_css_float) {
let placed_top = match side {
Some(UsedFloatSide::Bottom) => page_bottom.points() + height,
Some(UsedFloatSide::Top)
| Some(UsedFloatSide::Left | UsedFloatSide::Right)
| None => top.points(),
};
return FloatBandPlacement::new(
FloatBand::from_span(PageInlineSpan::new(
initial_block_slab.left_x(),
inline_size,
)),
PageTopBlockPosition::new(placed_top),
);
}
let mut block_slab = initial_block_slab;
for _ in 0..self.shapes.len().saturating_add(2) {
let vertical_slab = vertical_physical_inline_span(
avoidance_writing_mode,
direction,
inline_physical_start,
layout_pt(inline_size),
);
let band = self.logical_band(
avoidance_writing_mode,
direction,
page_index,
FloatBandQuery {
horizontal_slab: block_slab,
vertical_slab,
},
);
let placed_top = match side {
Some(UsedFloatSide::Bottom) => band.block_span.bottom_y() + height,
Some(UsedFloatSide::Top) | None => band.block_span.top_y(),
Some(UsedFloatSide::Left | UsedFloatSide::Right) => band.block_span.top_y(),
};
if height <= band.inline_span.size() + FLOAT_EPSILON {
return FloatBandPlacement::new(
FloatBand::from_span(PageInlineSpan::new(
block_slab.left_x(),
band.inline_span.size(),
)),
PageTopBlockPosition::new(placed_top),
);
}
let Some(next_start) = self.next_vertical_float_slab_start(
page_index,
block_slab,
vertical_slab,
block_start,
) else {
return FloatBandPlacement::new(
FloatBand::from_span(PageInlineSpan::new(
block_slab.left_x(),
band.inline_span.size(),
)),
PageTopBlockPosition::new(placed_top),
);
};
let advances_toward_block_end = match block_start {
PhysicalSide::Left => next_start.left_x() > block_slab.left_x() + FLOAT_EPSILON,
PhysicalSide::Right => next_start.right_x() < block_slab.right_x() - FLOAT_EPSILON,
PhysicalSide::Top | PhysicalSide::Bottom => unreachable!(),
};
if !advances_toward_block_end {
return FloatBandPlacement::new(
FloatBand::from_span(PageInlineSpan::new(
block_slab.left_x(),
band.inline_span.size(),
)),
PageTopBlockPosition::new(placed_top),
);
}
block_slab = next_start;
}
let band = self.logical_band(
avoidance_writing_mode,
direction,
page_index,
FloatBandQuery {
horizontal_slab: block_slab,
vertical_slab: vertical_physical_inline_span(
avoidance_writing_mode,
direction,
inline_physical_start,
layout_pt(inline_size),
),
},
);
let placed_top = match side {
Some(UsedFloatSide::Bottom) => band.block_span.bottom_y() + height,
Some(UsedFloatSide::Top) | None => band.block_span.top_y(),
Some(UsedFloatSide::Left | UsedFloatSide::Right) => band.block_span.top_y(),
};
FloatBandPlacement::new(
FloatBand::from_span(PageInlineSpan::new(
block_slab.left_x(),
band.inline_span.size(),
)),
PageTopBlockPosition::new(placed_top),
)
}
pub(in crate::layout) fn next_vertical_float_slab_start(
&self,
page_index: usize,
block_slab: PageInlineSpan,
inline_slab: PageBlockSpan,
block_start: PhysicalSide,
) -> Option<PageInlineSpan> {
let candidates = self
.shapes
.iter()
.filter(|shape| {
let shape_block_span = shape.margin_box_block_span();
let shape_inline_span = shape.margin_box_inline_span();
shape.is_css_float()
&& shape.page_index == page_index
&& matches!(shape.side, UsedFloatSide::Top | UsedFloatSide::Bottom)
&& shape_inline_span.right_x() > block_slab.left_x() + FLOAT_EPSILON
&& shape_inline_span.left_x() < block_slab.right_x() - FLOAT_EPSILON
&& shape_block_span.top_y() > inline_slab.bottom_y() + FLOAT_EPSILON
&& shape_block_span.bottom_y() < inline_slab.top_y() - FLOAT_EPSILON
})
.map(|shape| shape.margin_box_inline_span());
match block_start {
PhysicalSide::Left => candidates
.map(|shape| PageInlineSpan::new(shape.right_x(), block_slab.width()))
.filter(|next| next.left_x() > block_slab.left_x() + FLOAT_EPSILON)
.min_by(|left, right| {
left.left_x()
.partial_cmp(&right.left_x())
.unwrap_or(std::cmp::Ordering::Equal)
}),
PhysicalSide::Right => candidates
.map(|shape| {
PageInlineSpan::from_edges(shape.left_x() - block_slab.width(), shape.left_x())
})
.filter(|next| next.right_x() < block_slab.right_x() - FLOAT_EPSILON)
.max_by(|left, right| {
left.right_x()
.partial_cmp(&right.right_x())
.unwrap_or(std::cmp::Ordering::Equal)
}),
PhysicalSide::Top | PhysicalSide::Bottom => {
unreachable!("a vertical writing mode has a horizontal block axis")
}
}
}
}
pub(in crate::layout) fn vertical_physical_inline_span(
writing_mode: WritingMode,
direction: Direction,
inline_physical_start: PageTopBlockPosition,
inline_size: LayoutLength,
) -> PageBlockSpan {
match inline_start_side(writing_mode, direction) {
PhysicalSide::Top => PageBlockSpan::from_edges(
inline_physical_start.points(),
inline_physical_start.toward_block_end(inline_size).points(),
),
PhysicalSide::Bottom => PageBlockSpan::from_edges(
PageTopBlockPosition::new(inline_physical_start.points() + inline_size.points())
.points(),
inline_physical_start.points(),
),
PhysicalSide::Left | PhysicalSide::Right => {
unreachable!("vertical inline axis must map to top or bottom")
}
}
}
impl<'a> LayoutBuilder<'a> {
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn place_float_avoiding_margin_box(
&self,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_direction: Direction,
) -> FloatPlacement {
let width = margin_box_size.width;
let placement_axes = FloatPlacementAxes::new(
self.containing_block_writing_mode,
self.containing_block_direction,
);
if self.containing_block_writing_mode != WritingMode::HorizontalTb {
let placement = self.find_vertical_float_avoiding_position(
top,
margin_box_size,
clear,
placement_axes,
self.current_content_logical_inline_content_size(),
None,
);
return FloatPlacement::new(placement.origin, placement.available_span);
}
let placement =
self.find_bfc_avoiding_position(top, margin_box_size, clear, placement_axes);
let x = if placement_direction == Direction::Rtl {
placement.origin.x() + (placement.available_span.width() - width).max(0.0)
} else {
placement.origin.x()
};
FloatPlacement::new(
PageTopPoint::new(x, placement.origin.top_y()),
placement.available_span,
)
}
fn find_bfc_avoiding_position(
&self,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
) -> FloatBandPlacement {
let page_index = self.current_float_page_index();
let context = self
.float_contexts
.last()
.expect("root float context exists");
context.avoiding_bfc_position(
page_index,
top,
margin_box_size,
clear,
placement_axes,
PageInlineSpan::from_edges(self.content_left, self.content_right),
)
}
pub(in crate::layout) fn find_inline_float_avoiding_position(
&self,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
side: UsedFloatSide,
) -> FloatBandPlacement {
let page_index = self.current_float_page_index();
let context = self
.float_contexts
.last()
.expect("root float context exists");
let top = context.initial_letter_float_avoidance_top(page_index, top, side);
context.avoiding_position(
page_index,
top,
margin_box_size,
clear,
placement_axes,
PageInlineSpan::from_edges(self.content_left, self.content_right),
)
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn find_vertical_float_avoiding_position(
&self,
top: PageTopBlockPosition,
margin_box_size: MarginBoxSize,
clear: Clear,
placement_axes: FloatPlacementAxes,
containing_logical_inline_size: LogicalInlineContentSize,
side: Option<UsedFloatSide>,
) -> FloatBandPlacement {
let page_index = self.current_float_page_index();
let context = self
.float_contexts
.last()
.expect("root float context exists");
let avoidance_writing_mode = self.containing_block_writing_mode;
let containing_physical_bottom = if avoidance_writing_mode.has_vertical_lines() {
PageTopBlockPosition::new(
top.points() - containing_logical_inline_size.points().max(0.0),
)
} else {
PageTopBlockPosition::new(self.page_bottom())
};
context.vertical_avoiding_position(
page_index,
top,
margin_box_size,
clear,
placement_axes,
avoidance_writing_mode,
self.containing_block_direction,
PageInlineSpan::from_edges(self.content_left, self.content_right),
containing_physical_bottom,
side,
)
}
pub(in crate::layout) fn prebreak_bfc_margin_box_if_needed(
&mut self,
margin_box_height: MarginBoxLength,
reapplied_margin_top: f32,
) {
if margin_box_height.points() <= FLOAT_EPSILON
|| self.out_of_flow_prebreak_suppression_depth > 0
|| margin_box_height.points() > self.page_area_height() + FLOAT_EPSILON
|| self.cursor_y - margin_box_height.points() >= self.page_bottom() - FLOAT_EPSILON
|| self.cursor_is_at_page_top()
|| !self.current_page_has_content()
{
return;
}
self.push_page();
self.cursor_y -= reapplied_margin_top;
}
pub(in crate::layout) fn current_float_page_index(&self) -> usize {
self.pages.len()
}
}