use std::rc::Rc;
use super::*;
use crate::units::content_box_to_margin_box_length;
impl PhysicalInlineTextBounds {
pub(in crate::layout) fn new(baseline_origin: InlinePoint, inline_size: f32) -> Self {
Self {
baseline_origin,
inline_size: inline_size.max(0.0),
}
}
pub(in crate::layout) fn x(self) -> f32 {
self.baseline_origin.x
}
pub(in crate::layout) fn y(self) -> f32 {
self.baseline_origin.y
}
pub(in crate::layout) fn width(self) -> f32 {
self.inline_size
}
pub(in crate::layout) fn set_x(&mut self, x: f32) {
self.baseline_origin.x = x;
}
pub(in crate::layout) fn set_y(&mut self, y: f32) {
self.baseline_origin.y = y;
}
pub(in crate::layout) fn set_width(&mut self, width: f32) {
self.inline_size = width.max(0.0);
}
pub(in crate::layout) fn text_origin(self) -> PaintPoint {
PaintPoint::new(self.x(), self.y())
}
pub(in crate::layout) fn link_paint_rect(self, font_size: f32) -> PaintRect {
paint_space_rect(self.x(), self.y() - 2.0, self.width(), font_size + 4.0)
}
}
impl InlineLineGeometry {
pub(in crate::layout) fn new(
content_left: f32,
content_right: f32,
cursor_y: f32,
line_block_size: f32,
context: InlinePaintContext<'_>,
) -> Self {
let style = context.block_style;
let direction = context.direction;
let inline_size = (context.available_width - context.line_indent).max(0.0);
let content_inline_start = content_left + context.padding_left;
let axes = WritingModeAxes::new(style.writing_mode, direction);
let inline_start = match axes.physical_side(LogicalSide::InlineStart) {
PhysicalSide::Left => content_inline_start + context.line_indent,
PhysicalSide::Right => content_inline_start + inline_size,
PhysicalSide::Top => cursor_y - context.line_indent,
PhysicalSide::Bottom => cursor_y - inline_size,
};
let block_start = match axes.physical_side(LogicalSide::BlockStart) {
PhysicalSide::Top | PhysicalSide::Bottom => cursor_y,
PhysicalSide::Left => content_inline_start,
PhysicalSide::Right => content_right - line_block_size.max(0.0),
};
Self {
writing_mode: style.writing_mode,
direction,
inline_start_offset: context.line_indent,
inline_start,
inline_size,
block_start,
line_block_size: line_block_size.max(0.0),
text_box_line_trim: TextBoxLineTrim::default(),
}
}
pub(in crate::layout) fn alignment_offset(
self,
content_inline_size: f32,
align: TextAlign,
) -> f32 {
let free_space = (self.inline_size - content_inline_size).max(0.0);
match align {
TextAlign::Left if self.line_left_is_inline_end() => free_space,
TextAlign::Right if self.line_right_is_inline_end() => free_space,
TextAlign::Center => free_space / 2.0,
TextAlign::End => free_space,
TextAlign::Left
| TextAlign::Right
| TextAlign::Start
| TextAlign::Justify
| TextAlign::JustifyAll => 0.0,
}
}
pub(in crate::layout) fn hanging_punctuation_offset(
self,
hanging_widths: HangingPunctuationWidths,
) -> f32 {
match self.direction {
Direction::Ltr => -hanging_widths.start,
Direction::Rtl => hanging_widths.end,
}
}
pub(in crate::layout) fn visual_line_origin(
self,
logical_inline_start: f32,
line_inline_size: f32,
) -> f32 {
self.physical_inline_origin(logical_inline_start, line_inline_size)
}
pub(in crate::layout) fn visual_line_item_rect(
self,
line_logical_inline_start: f32,
line_physical_origin: f32,
visual_inline_start: f32,
inline_size: f32,
horizontal_y: f32,
block_size: f32,
) -> PhysicalInlineRect {
let axes = WritingModeAxes::new(self.writing_mode, self.direction);
if !axes.swaps_physical_axes() {
PhysicalInlineRect::new(InlineRect::new(
InlinePoint::new(line_physical_origin + visual_inline_start, horizontal_y),
InlineSize::new(inline_size, block_size),
))
} else {
PhysicalInlineRect::new(InlineRect::new(
InlinePoint::new(
self.block_start,
self.physical_inline_origin(
line_logical_inline_start + visual_inline_start,
inline_size,
),
),
InlineSize::new(block_size, inline_size),
))
}
}
pub(in crate::layout) fn position_visual_text_group(
self,
group: &mut PreparedInlineTextGroup,
line_logical_inline_start: f32,
line_physical_origin: f32,
visual_inline_start: f32,
) {
if !WritingModeAxes::new(self.writing_mode, self.direction).swaps_physical_axes() {
group.set_x(line_physical_origin + visual_inline_start);
} else {
group.set_x(self.block_start);
group.set_y(self.vertical_text_inline_origin(
line_logical_inline_start + visual_inline_start,
group.width(),
));
}
}
pub(in crate::layout) fn physical_inline_origin(
self,
logical_inline_start: f32,
inline_size: f32,
) -> f32 {
match WritingModeAxes::new(self.writing_mode, self.direction)
.physical_side(LogicalSide::InlineStart)
{
PhysicalSide::Right | PhysicalSide::Top => {
self.inline_start - logical_inline_start - inline_size
}
PhysicalSide::Left | PhysicalSide::Bottom => self.inline_start + logical_inline_start,
}
}
pub(in crate::layout) fn vertical_text_inline_origin(
self,
logical_inline_start: f32,
inline_size: f32,
) -> f32 {
let (placement, placement_logical_inline_start) =
if self.writing_mode == WritingMode::SidewaysLr && self.direction == Direction::Rtl {
(
Self {
direction: Direction::Ltr,
inline_start: self.inline_start - self.inline_size,
..self
},
self.inline_size - logical_inline_start - inline_size,
)
} else {
(self, logical_inline_start)
};
let origin = placement.physical_inline_origin(placement_logical_inline_start, inline_size);
if WritingModeAxes::new(self.writing_mode, placement.direction)
.physical_side(LogicalSide::InlineStart)
== PhysicalSide::Top
{
origin + inline_size
} else {
origin
}
}
fn line_left_side(self) -> PhysicalSide {
FlowAxes::new(self.writing_mode, self.direction).line_left_side()
}
fn line_right_side(self) -> PhysicalSide {
FlowAxes::new(self.writing_mode, self.direction).line_right_side()
}
fn line_left_is_inline_end(self) -> bool {
WritingModeAxes::new(self.writing_mode, self.direction)
.physical_side(LogicalSide::InlineEnd)
== self.line_left_side()
}
fn line_right_is_inline_end(self) -> bool {
WritingModeAxes::new(self.writing_mode, self.direction)
.physical_side(LogicalSide::InlineEnd)
== self.line_right_side()
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct InlineParagraphContext<'a> {
pub(in crate::layout) block_style: &'a ComputedStyle,
pub(in crate::layout) line_clamp: Option<css::InlineLineClamp<'a>>,
pub(in crate::layout) clamp_continuation: css::ClampContinuation,
pub(in crate::layout) stylesheets: &'a Stylesheets<'a>,
pub(in crate::layout) initial_first_formatted_line: bool,
pub(in crate::layout) available_width: f32,
pub(in crate::layout) padding_left: f32,
pub(in crate::layout) hanging_indent: f32,
pub(in crate::layout) hanging_punctuation_reserve: f32,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct InlinePaintContext<'a> {
pub(in crate::layout) block_style: &'a ComputedStyle,
pub(in crate::layout) direction: Direction,
pub(in crate::layout) available_width: f32,
pub(in crate::layout) padding_left: f32,
pub(in crate::layout) line_indent: f32,
pub(in crate::layout) text_align: TextAlign,
pub(in crate::layout) is_first_line: bool,
pub(in crate::layout) line_block_size: f32,
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineAtomData {
pub(in crate::layout) content: InlineAtomContent,
pub(in crate::layout) style: Rc<css::ZoomedLayoutStyle>,
pub(in crate::layout) outside_marker: Option<ListMarker>,
pub(in crate::layout) content_inline_offset: f32,
pub(in crate::layout) content_inline_paint_width: Option<f32>,
pub(in crate::layout) escaped_positioned_layers: Option<Rc<[PositionedPaintLayer]>>,
pub(in crate::layout) link_target: Option<Rc<str>>,
pub(in crate::layout) alt_text: Option<Rc<str>>,
pub(in crate::layout) tracking_scope: Option<Rc<InlineTrackingScope>>,
pub(in crate::layout) current_color_override: Option<CssColor>,
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineAtom {
pub(in crate::layout) data: Rc<InlineAtomData>,
pub(in crate::layout) size: InlineSize,
pub(in crate::layout) baseline: InlineAtomBaseline,
pub(in crate::layout) baseline_placement: InlineBaselinePlacement,
pub(in crate::layout) visual_offset: InlineVisualOffset,
pub(in crate::layout) ruby_placement: Option<ruby::ResolvedRubyPlacement>,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct ResolvedInlineAtomGeometry {
pub(in crate::layout) physical_margin_box_size: MarginBoxSize,
pub(in crate::layout) baseline: InlineAtomBaseline,
pub(in crate::layout) baseline_placement: InlineBaselinePlacement,
}
impl ResolvedInlineAtomGeometry {
pub(in crate::layout) fn exported_from_logical_block_start(
style: &css::ZoomedLayoutStyle,
physical_margin_box_size: MarginBoxSize,
border_box_block_size: LayoutLength,
baseline_offset: LayoutLength,
baseline_placement: InlineBaselinePlacement,
) -> Self {
Self {
physical_margin_box_size,
baseline: InlineAtomBaseline::Physical {
source: InlineAtomBaselineSource::BorderBox,
baselines: crate::layout::baseline::PhysicalBaselineSets::default()
.with_first_from_logical_block_start(
block_start_side(style.writing_mode),
border_box_block_size,
baseline_offset,
BaselineMetric::Alphabetic,
),
missing_axis_synthesis: AtomicInlineBaselineSynthesisSource::MarginBox,
},
baseline_placement,
}
}
#[allow(clippy::too_many_arguments)]
pub(in crate::layout) fn from_resolved_boxes(
style: &css::ZoomedLayoutStyle,
content: ContentBoxSize,
horizontal_non_content: NonContentLength,
vertical_non_content: NonContentLength,
horizontal_margins: LayoutLength,
vertical_margins: LayoutLength,
baseline_offset: LayoutLength,
baseline_placement: InlineBaselinePlacement,
) -> Self {
let width = content_box_to_margin_box_length(
content_box_pt(content.width),
horizontal_non_content,
horizontal_margins,
);
let height = content_box_to_margin_box_length(
content_box_pt(content.height),
vertical_non_content,
vertical_margins,
);
let border_box_block_size = if style.writing_mode.has_vertical_lines() {
content_box_to_border_box_length(content_box_pt(content.width), horizontal_non_content)
} else {
content_box_to_border_box_length(content_box_pt(content.height), vertical_non_content)
};
Self::exported_from_logical_block_start(
style,
margin_box_size_pt(width.points(), height.points()),
layout_pt(border_box_block_size.points()),
baseline_offset,
baseline_placement,
)
}
fn inline_layout_size(self) -> InlineSize {
InlineSize::new(
self.physical_margin_box_size.width,
self.physical_margin_box_size.height,
)
}
}
pub(in crate::layout) trait IntoInlineAtomUsedStyle {
fn into_inline_atom_used_style(self) -> css::ZoomedLayoutStyle;
}
impl IntoInlineAtomUsedStyle for css::ZoomedLayoutStyle {
fn into_inline_atom_used_style(self) -> css::ZoomedLayoutStyle {
self
}
}
impl IntoInlineAtomUsedStyle for ComputedStyle {
fn into_inline_atom_used_style(self) -> css::ZoomedLayoutStyle {
css::LayoutStyle::from_computed(&self).into_zoomed()
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) enum InlineAtomBaseline {
TextCombineParentCentral,
Physical {
source: InlineAtomBaselineSource,
baselines: crate::layout::baseline::PhysicalBaselineSets,
missing_axis_synthesis: AtomicInlineBaselineSynthesisSource,
},
Synthesized {
source: AtomicInlineBaselineSynthesisSource,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum AtomicInlineBaselineSynthesisSource {
MarginBox,
BorderBox,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) enum InlineAtomBaselineSource {
BorderBox,
TableBox,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct AtomicInlineBaselineCoordinates {
pub(in crate::layout) margin_box: AtomicInlineMarginBoxBaselineOffset,
pub(in crate::layout) paint_placement: AtomicInlinePaintPlacementBaselineOffset,
}
impl InlineAtom {
#[allow(clippy::arc_with_non_send_sync, clippy::too_many_arguments)]
pub(in crate::layout) fn new(
content: InlineAtomContent,
style: impl IntoInlineAtomUsedStyle,
escaped_positioned_layers: Option<Box<[PositionedPaintLayer]>>,
size: InlineSize,
baseline_offset: f32,
baseline_shift: f32,
link_target: Option<String>,
alt_text: Option<String>,
) -> Self {
let style = style.into_inline_atom_used_style();
let margin_box_block_size = if style.writing_mode.has_vertical_lines() {
size.width
} else {
size.height
};
let block_margins = if style.writing_mode.has_vertical_lines() {
style.margin.left + style.margin.right
} else {
style.margin.top + style.margin.bottom
};
let geometry = ResolvedInlineAtomGeometry::exported_from_logical_block_start(
&style,
margin_box_size_pt(size.width, size.height),
layout_pt((margin_box_block_size - block_margins).max(0.0)),
layout_pt(baseline_offset),
InlineBaselinePlacement::from_inherited_glyph_displacement(
glyph_baseline_displacement_pt(baseline_shift),
),
);
Self::from_resolved_geometry(
content,
style,
escaped_positioned_layers,
geometry,
link_target,
alt_text,
)
}
#[allow(clippy::arc_with_non_send_sync, clippy::too_many_arguments)]
pub(in crate::layout) fn from_resolved_geometry(
content: InlineAtomContent,
style: impl IntoInlineAtomUsedStyle,
escaped_positioned_layers: Option<Box<[PositionedPaintLayer]>>,
geometry: ResolvedInlineAtomGeometry,
link_target: Option<String>,
alt_text: Option<String>,
) -> Self {
let style = style.into_inline_atom_used_style();
Self {
data: Rc::new(InlineAtomData {
content,
style: Rc::new(style),
outside_marker: None,
content_inline_offset: 0.0,
content_inline_paint_width: None,
escaped_positioned_layers: escaped_positioned_layers.map(Rc::from),
link_target: link_target.map(Rc::from),
alt_text: alt_text.map(Rc::from),
tracking_scope: None,
current_color_override: None,
}),
size: geometry.inline_layout_size(),
baseline: geometry.baseline,
baseline_placement: geometry.baseline_placement,
visual_offset: InlineVisualOffset::zero(),
ruby_placement: None,
}
}
pub(in crate::layout) fn with_visual_offset(
mut self,
visual_offset: InlineVisualOffset,
) -> Self {
self.visual_offset = visual_offset;
self
}
pub(in crate::layout) fn baseline_shift(&self) -> f32 {
self.baseline_placement.glyph_displacement().points()
}
pub(in crate::layout) fn add_baseline_placement(&mut self, placement: InlineBaselinePlacement) {
self.baseline_placement = self.baseline_placement.with_added(placement);
}
pub(in crate::layout) fn with_ruby_placement(
mut self,
placement: ruby::ResolvedRubyPlacement,
) -> Self {
self.ruby_placement = Some(placement);
self
}
pub(in crate::layout) fn ruby_placement(&self) -> Option<&ruby::ResolvedRubyPlacement> {
self.ruby_placement.as_ref()
}
pub(in crate::layout) fn with_tracking_scope(mut self, scope: Rc<InlineTrackingScope>) -> Self {
Rc::make_mut(&mut self.data).tracking_scope = Some(scope);
self
}
pub(in crate::layout) fn set_text_autospace_advance(
&mut self,
style: &ComputedStyle,
advance: LayoutLength,
) {
let data = Rc::make_mut(&mut self.data);
let InlineAtomContent::InlineEdge(InlineEdgeRole::TextAutospace(spacing)) =
&mut data.content
else {
unreachable!("only text-autospace atoms have a style-dependent advance");
};
*spacing = InlineTextBoundarySpacing::new(advance);
data.style = Rc::new(style.clone().into_inline_atom_used_style());
self.size = InlineSize::new(advance.points(), 0.0);
}
pub(in crate::layout) fn mark_metrics_only_strut(&mut self) {
let data = Rc::make_mut(&mut self.data);
let InlineAtomContent::InlineEdge(InlineEdgeRole::BoxEdge(edge)) = &data.content else {
unreachable!("only a transparent inline-box edge can become a metrics strut");
};
debug_assert_eq!(edge.advance, 0.0);
debug_assert_eq!(edge.paint_extent, 0.0);
debug_assert!(!edge.is_positioning_marker());
data.content = InlineAtomContent::InlineEdge(InlineEdgeRole::MetricsOnlyStrut);
}
pub(in crate::layout) fn tracking_scope(&self) -> Option<&Rc<InlineTrackingScope>> {
self.data.tracking_scope.as_ref()
}
pub(in crate::layout) fn line_relative_scope(&self) -> Option<&InlineTrackingScope> {
self.tracking_scope()
.and_then(|scope| scope.nearest_line_relative_scope())
}
pub(in crate::layout) fn line_relative_alignment(
&self,
) -> Option<InlineScopeLineRelativeAlignment> {
(!self.content().is_inline_edge())
.then(|| {
InlineScopeLineRelativeAlignment::from_baseline_shift(
&self.style().vertical_align.baseline_shift,
)
})
.flatten()
.or_else(|| {
self.line_relative_scope()
.and_then(InlineTrackingScope::line_relative_alignment)
})
}
pub(in crate::layout) fn with_outside_marker(mut self, marker: Option<ListMarker>) -> Self {
Rc::make_mut(&mut self.data).outside_marker = marker;
self
}
pub(in crate::layout) fn with_content_inline_offset(mut self, offset: f32) -> Self {
Rc::make_mut(&mut self.data).content_inline_offset = offset;
self
}
pub(in crate::layout) fn with_content_inline_paint_width(mut self, width: f32) -> Self {
Rc::make_mut(&mut self.data).content_inline_paint_width = Some(width);
self
}
pub(in crate::layout) fn content(&self) -> &InlineAtomContent {
&self.data.content
}
pub(in crate::layout) fn style(&self) -> &ComputedStyle {
&self.data.style
}
pub(in crate::layout) fn set_current_color_override(&mut self, color: CssColor) {
Rc::make_mut(&mut self.data).current_color_override = Some(color);
}
pub(in crate::layout) fn current_color_override(&self) -> Option<CssColor> {
self.data.current_color_override
}
pub(in crate::layout) fn baseline_offset_from_alignment_source_block_start(
&self,
border_box_block_size: f32,
containing_style: &ComputedStyle,
) -> AtomicInlineBaselineSourceOffset {
match self.baseline {
InlineAtomBaseline::TextCombineParentCentral => {
unreachable!("text-combine baseline requires parent central-baseline geometry")
}
InlineAtomBaseline::Physical { baselines, .. } => baselines
.first_from_logical_block_start_with_metric(
block_start_side(containing_style.writing_mode),
layout_pt(border_box_block_size),
)
.map(|(baseline, _)| baseline)
.map(LayoutLength::points)
.map(atomic_inline_baseline_source_pt)
.unwrap_or_else(|| atomic_inline_baseline_source_pt(border_box_block_size)),
InlineAtomBaseline::Synthesized { .. } => {
atomic_inline_baseline_source_pt(border_box_block_size)
}
}
}
pub(in crate::layout) fn content_derived_baseline_metric(
&self,
containing_style: &ComputedStyle,
) -> Option<BaselineMetric> {
match self.baseline {
InlineAtomBaseline::TextCombineParentCentral => Some(BaselineMetric::Central),
InlineAtomBaseline::Physical { baselines, .. } => baselines
.first_from_logical_block_start_with_metric(
block_start_side(containing_style.writing_mode),
layout_pt(inline_atom_logical_border_block_size(
self,
containing_style,
)),
)
.map(|(_, metric)| metric),
InlineAtomBaseline::Synthesized { .. } => None,
}
}
pub(in crate::layout) fn resolve_baseline_coordinates(
&self,
border_box_block_size: f32,
margin_box_block_size: f32,
block_start_margin: f32,
block_end_margin: f32,
containing_style: &ComputedStyle,
) -> AtomicInlineBaselineCoordinates {
let exported_source_box = match self.baseline {
InlineAtomBaseline::Physical { source, .. } => Some(source),
InlineAtomBaseline::TextCombineParentCentral
| InlineAtomBaseline::Synthesized { .. } => None,
};
let synthesized_source = match self.baseline {
InlineAtomBaseline::TextCombineParentCentral => {
unreachable!("text-combine coordinates are resolved from parent text metrics")
}
InlineAtomBaseline::Synthesized { source } => Some(source),
InlineAtomBaseline::Physical {
missing_axis_synthesis,
..
} if self
.content_derived_baseline_metric(containing_style)
.is_none() =>
{
Some(missing_axis_synthesis)
}
InlineAtomBaseline::Physical { .. } => None,
};
let source = self.baseline_offset_from_alignment_source_block_start(
border_box_block_size,
containing_style,
);
let (margin_box, paint_placement) = match synthesized_source {
Some(AtomicInlineBaselineSynthesisSource::MarginBox) => (
atomic_inline_margin_box_baseline_pt(margin_box_block_size),
atomic_inline_paint_placement_baseline_pt(border_box_block_size + block_end_margin),
),
Some(AtomicInlineBaselineSynthesisSource::BorderBox) => (
atomic_inline_margin_box_baseline_pt(block_start_margin + source.points()),
atomic_inline_paint_placement_baseline_pt(source.points()),
),
None => {
debug_assert!(exported_source_box.is_some());
(
atomic_inline_margin_box_baseline_pt(block_start_margin + source.points()),
atomic_inline_paint_placement_baseline_pt(source.points()),
)
}
};
AtomicInlineBaselineCoordinates {
margin_box,
paint_placement,
}
}
pub(in crate::layout) fn with_exported_table_box_baseline(mut self) -> Self {
let InlineAtomBaseline::Physical {
baselines,
missing_axis_synthesis,
..
} = self.baseline
else {
unreachable!("only an exported baseline can originate from a table box");
};
self.baseline = InlineAtomBaseline::Physical {
source: InlineAtomBaselineSource::TableBox,
baselines,
missing_axis_synthesis,
};
self
}
pub(in crate::layout) fn with_flex_exported_baselines(
mut self,
baselines: crate::layout::baseline::PhysicalBaselineSets,
) -> Self {
self.baseline = InlineAtomBaseline::Physical {
source: InlineAtomBaselineSource::BorderBox,
baselines,
missing_axis_synthesis: AtomicInlineBaselineSynthesisSource::MarginBox,
};
self
}
pub(in crate::layout) fn with_synthesized_border_box_block_end_baseline(mut self) -> Self {
self.baseline = InlineAtomBaseline::Synthesized {
source: AtomicInlineBaselineSynthesisSource::BorderBox,
};
self
}
pub(in crate::layout) fn with_synthesized_margin_box_block_end_baseline(mut self) -> Self {
self.baseline = InlineAtomBaseline::Synthesized {
source: AtomicInlineBaselineSynthesisSource::MarginBox,
};
self
}
pub(in crate::layout) fn with_text_combine_parent_central_baseline(mut self) -> Self {
self.baseline = InlineAtomBaseline::TextCombineParentCentral;
self
}
pub(in crate::layout) fn outside_marker(&self) -> Option<&ListMarker> {
self.data.outside_marker.as_ref()
}
pub(in crate::layout) fn content_inline_offset(&self) -> f32 {
self.data.content_inline_offset
}
pub(in crate::layout) fn content_inline_paint_width(&self) -> Option<f32> {
self.data.content_inline_paint_width
}
pub(in crate::layout) fn escaped_positioned_layers(&self) -> Option<&[PositionedPaintLayer]> {
self.data.escaped_positioned_layers.as_deref()
}
pub(in crate::layout) fn append_escaped_positioned_layers(
&mut self,
layers: Vec<PositionedPaintLayer>,
) {
if layers.is_empty() {
return;
}
let data = Rc::make_mut(&mut self.data);
let mut retained = data
.escaped_positioned_layers
.as_deref()
.unwrap_or_default()
.to_vec();
retained.extend(layers);
data.escaped_positioned_layers = Some(Rc::from(retained));
}
pub(in crate::layout) fn link_target(&self) -> Option<&str> {
self.data.link_target.as_deref()
}
pub(in crate::layout) fn alt_text(&self) -> Option<&str> {
self.data.alt_text.as_deref()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(in crate::layout) enum InlineFloatId {
Element(ElementId),
FirstLetter(FirstLetterPseudoGroupId),
}
#[derive(Debug, Clone)]
#[allow(clippy::large_enum_variant)]
pub(in crate::layout) enum InlineFloatContents {
Element {
element: Element,
signature: ElementSignature,
generated_content: bool,
generated_pseudo_source: Option<box_tree::CounterEventSource>,
},
FirstLetterText {
fragments: Rc<[InlineFragment]>,
group_id: FirstLetterPseudoGroupId,
},
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineFloatData {
pub(in crate::layout) contents: InlineFloatContents,
pub(in crate::layout) style: ComputedStyle,
pub(in crate::layout) positioning_containing_block:
Option<InlinePositioningContainingBlockSource>,
}
#[derive(Debug, Clone, PartialEq)]
pub(in crate::layout) struct InlinePositioningContainingBlockSource {
pub(in crate::layout) id: InlinePositioningContainingBlockId,
pub(in crate::layout) style: Box<css::ZoomedLayoutStyle>,
}
impl InlinePositioningContainingBlockSource {
pub(in crate::layout) fn as_borrowed(
&self,
) -> BorrowedInlinePositioningContainingBlockSource<'_> {
BorrowedInlinePositioningContainingBlockSource {
id: self.id,
style: self.style.as_ref(),
}
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct BorrowedInlinePositioningContainingBlockSource<'a> {
pub(in crate::layout) id: InlinePositioningContainingBlockId,
pub(in crate::layout) style: &'a css::ZoomedLayoutStyle,
}
impl BorrowedInlinePositioningContainingBlockSource<'_> {
pub(in crate::layout) fn into_owned(self) -> InlinePositioningContainingBlockSource {
InlinePositioningContainingBlockSource {
id: self.id,
style: Box::new(self.style.clone()),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(in crate::layout) struct InlinePositioningContainingBlockId(pub(in crate::layout) usize);
#[derive(Debug, Clone)]
pub(in crate::layout) struct InlineFloat {
pub(in crate::layout) data: Rc<InlineFloatData>,
}
impl InlineFloat {
pub(in crate::layout) fn new(
element: Element,
signature: ElementSignature,
style: ComputedStyle,
generated_content: bool,
generated_pseudo_source: Option<box_tree::CounterEventSource>,
positioning_containing_block: Option<InlinePositioningContainingBlockSource>,
) -> Self {
Self {
data: Rc::new(InlineFloatData {
contents: InlineFloatContents::Element {
element,
signature,
generated_content,
generated_pseudo_source,
},
style,
positioning_containing_block,
}),
}
}
pub(in crate::layout) fn first_letter(
fragments: Vec<InlineFragment>,
group_id: FirstLetterPseudoGroupId,
style: ComputedStyle,
) -> Self {
Self {
data: Rc::new(InlineFloatData {
contents: InlineFloatContents::FirstLetterText {
fragments: Rc::from(fragments.into_boxed_slice()),
group_id,
},
style,
positioning_containing_block: None,
}),
}
}
pub(in crate::layout) fn id(&self) -> InlineFloatId {
match &self.data.contents {
InlineFloatContents::Element { element, .. } => InlineFloatId::Element(element.id),
InlineFloatContents::FirstLetterText { group_id, .. } => {
InlineFloatId::FirstLetter(*group_id)
}
}
}
pub(in crate::layout) fn element(&self) -> Option<&Element> {
match &self.data.contents {
InlineFloatContents::Element { element, .. } => Some(element),
InlineFloatContents::FirstLetterText { .. } => None,
}
}
pub(in crate::layout) fn signature(&self) -> Option<&ElementSignature> {
match &self.data.contents {
InlineFloatContents::Element { signature, .. } => Some(signature),
InlineFloatContents::FirstLetterText { .. } => None,
}
}
pub(in crate::layout) fn style(&self) -> &ComputedStyle {
&self.data.style
}
pub(in crate::layout) fn is_generated_content(&self) -> bool {
matches!(
self.data.contents,
InlineFloatContents::Element {
generated_content: true,
..
}
)
}
pub(in crate::layout) fn generated_pseudo_source(
&self,
) -> Option<box_tree::CounterEventSource> {
match &self.data.contents {
InlineFloatContents::Element {
generated_pseudo_source,
..
} => *generated_pseudo_source,
InlineFloatContents::FirstLetterText { .. } => None,
}
}
pub(in crate::layout) fn first_letter_fragments(&self) -> Option<&[InlineFragment]> {
match &self.data.contents {
InlineFloatContents::FirstLetterText { fragments, .. } => Some(fragments),
InlineFloatContents::Element { .. } => None,
}
}
pub(in crate::layout) fn positioning_containing_block(
&self,
) -> Option<&InlinePositioningContainingBlockSource> {
self.data.positioning_containing_block.as_ref()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(in crate::layout) enum InlineStaticPositionSourceId {
Element {
element: crate::dom::ElementId,
source: InlineStaticPositionBoxSource,
},
Block,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(in crate::layout) enum InlineStaticPositionBoxSource {
Principal,
GeneratedPseudo(box_tree::GeneratedPseudoKind),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(in crate::layout) enum StaticPositionHypotheticalBoundary {
Transparent,
Atomic,
}
impl InlineStaticPositionSourceId {
pub(in crate::layout) fn for_element(element: &Element) -> Self {
Self::Element {
element: element.id,
source: InlineStaticPositionBoxSource::Principal,
}
}
pub(in crate::layout) fn for_box_source(
element: &Element,
source: &box_tree::BoxSource<'_>,
) -> Self {
let source = match source {
box_tree::BoxSource::Principal => InlineStaticPositionBoxSource::Principal,
box_tree::BoxSource::GeneratedPseudo(pseudo) => {
InlineStaticPositionBoxSource::GeneratedPseudo(pseudo.kind)
}
};
Self::Element {
element: element.id,
source,
}
}
pub(in crate::layout) fn for_generated_pseudo(
element: &Element,
kind: box_tree::GeneratedPseudoKind,
) -> Self {
Self::Element {
element: element.id,
source: InlineStaticPositionBoxSource::GeneratedPseudo(kind),
}
}
pub(in crate::layout) fn box_source_for_element(
self,
candidate: crate::dom::ElementId,
) -> Option<InlineStaticPositionBoxSource> {
match self {
Self::Element { element, source } if element == candidate => Some(source),
Self::Element { .. } | Self::Block => None,
}
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) enum InlineAtomContent {
Canvas,
Iframe(crate::dom::ElementId),
Image(DecodedPngImage),
Gradient {
image: BackgroundImage,
fallback: DecodedPngImage,
},
Svg {
asset: Option<SharedSvgAsset>,
},
StaticPositionHypothetical {
source: InlineStaticPositionSourceId,
boundary: StaticPositionHypotheticalBoundary,
},
InlineBox {
sequence: inline_layout::InlineLineSequence,
},
Ruby {
base_text: String,
base: RubyInlineLevel,
annotations: Vec<RubyInlineLevel>,
annotation_sides: Vec<css::RubyAnnotationSide>,
base_block_size: f32,
annotation_block_sizes: Vec<f32>,
},
TextCombineUpright {
composition: Box<TextCombineComposition>,
},
InlineFragment {
fragment: Box<PaintFragment>,
replay_coordinates: AtomicInlineFragmentReplayCoordinates,
table_cell_context: Option<table::TableCellContentCoordinateContext>,
contents_overflow_clip_applied: bool,
},
InlineEdge(InlineEdgeRole),
Leader(String),
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct TextCombineSource {
pub(in crate::layout) boundary_text: String,
pub(in crate::layout) style: Box<ComputedStyle>,
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct TextCombineLayout {
pub(in crate::layout) sequence: inline_layout::InlineLineSequence,
pub(in crate::layout) horizontal_style: Box<ComputedStyle>,
pub(in crate::layout) inline_scale: f32,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct TextCombineSquareGeometry {
extent: LayoutLength,
}
impl TextCombineSquareGeometry {
pub(in crate::layout) fn new(extent: LayoutLength) -> Self {
debug_assert!(extent.points() >= 0.0);
Self { extent }
}
pub(in crate::layout) fn points(self) -> f32 {
self.extent.points()
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct TextCombineComposition {
pub(in crate::layout) source: TextCombineSource,
pub(in crate::layout) layout: TextCombineLayout,
pub(in crate::layout) square: TextCombineSquareGeometry,
}
#[derive(Debug, Clone, Copy)]
struct ScratchAtomicBorderBoxOrigin(PaintPoint);
#[derive(Debug, Clone, Copy)]
struct FinalAtomicBorderBoxOrigin(PaintPoint);
impl FinalAtomicBorderBoxOrigin {
fn from_prepared_border_box(border_box: PhysicalInlineRect) -> Self {
Self(PaintPoint::new(border_box.x(), border_box.y()))
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct AtomicInlineCaptureFrame {
scratch_border_box_origin: ScratchAtomicBorderBoxOrigin,
}
impl AtomicInlineCaptureFrame {
pub(in crate::layout) fn for_scratch_border_box(scratch_border_box_origin: PaintPoint) -> Self {
Self {
scratch_border_box_origin: ScratchAtomicBorderBoxOrigin(scratch_border_box_origin),
}
}
pub(in crate::layout) fn replay_coordinates(self) -> AtomicInlineFragmentReplayCoordinates {
AtomicInlineFragmentReplayCoordinates {
scratch_border_box_origin: self.scratch_border_box_origin,
}
}
pub(in crate::layout) fn resolve_positioned_replay(
self,
replay: EscapedAtomReplay,
) -> EscapedAtomReplay {
replay.resolve_from_capture_origin(self.scratch_border_box_origin.0)
}
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct AtomicInlineFragmentReplayCoordinates {
scratch_border_box_origin: ScratchAtomicBorderBoxOrigin,
}
impl AtomicInlineFragmentReplayCoordinates {
pub(in crate::layout) fn border_box_local() -> Self {
AtomicInlineCaptureFrame::for_scratch_border_box(PaintPoint::new(0.0, 0.0))
.replay_coordinates()
}
pub(in crate::layout) fn replay_translation(
self,
final_border_box: PhysicalInlineRect,
) -> PaintTranslation {
let scratch_origin = self.scratch_border_box_origin.0;
let final_origin = FinalAtomicBorderBoxOrigin::from_prepared_border_box(final_border_box);
debug_assert!(scratch_origin.x.is_finite());
debug_assert!(scratch_origin.y.is_finite());
debug_assert!(final_border_box.x().is_finite());
debug_assert!(final_border_box.y().is_finite());
let translation = PaintTranslation::new(
final_origin.0.x - scratch_origin.x,
final_origin.0.y - scratch_origin.y,
);
let replayed_origin = translation.transform_point(scratch_origin);
debug_assert!(
replayed_origin_matches_border_box(replayed_origin, final_origin.0, scratch_origin,),
"atomic-inline replay must map its scratch border box to the final border box"
);
translation
}
}
fn replayed_origin_matches_border_box(
replayed: PaintPoint,
expected: PaintPoint,
captured: PaintPoint,
) -> bool {
fn coordinate_matches(replayed: f32, expected: f32, captured: f32) -> bool {
const ROUND_TRIP_ULPS: f32 = 8.0;
let scale = replayed
.abs()
.max(expected.abs())
.max(captured.abs())
.max(1.0);
(replayed - expected).abs() <= ROUND_TRIP_ULPS * f32::EPSILON * scale
}
coordinate_matches(replayed.x, expected.x, captured.x)
&& coordinate_matches(replayed.y, expected.y, captured.y)
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct RubyInlineLevel {
pub(in crate::layout) sequence: inline_layout::InlineLineSequence,
pub(in crate::layout) style: Box<ComputedStyle>,
pub(in crate::layout) overhang_policy: css::RubyOverhang,
pub(in crate::layout) paint_inline_size: ruby::RubyPaintInlineSpan,
pub(in crate::layout) containing_inline_size: ruby::RubyColumnInlineSpan,
pub(in crate::layout) starts_span: bool,
pub(in crate::layout) column_span: usize,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct InlineBoxEdgeFragment {
pub(in crate::layout) logical_edge: InlineLogicalEdge,
pub(in crate::layout) physical_side: PhysicalSide,
pub(in crate::layout) positioning_containing_block_id:
Option<InlinePositioningContainingBlockId>,
pub(in crate::layout) advance: f32,
pub(in crate::layout) paint_extent: f32,
}
impl InlineBoxEdgeFragment {
pub(in crate::layout) fn contributes_to_line_box(self) -> bool {
self.advance != 0.0 || self.paint_extent != 0.0
}
pub(in crate::layout) fn is_positioning_marker(self) -> bool {
self.positioning_containing_block_id.is_some()
&& self.advance == 0.0
&& self.paint_extent == 0.0
}
}
#[cfg(test)]
mod inline_box_edge_fragment_tests {
use super::*;
fn edge(
advance: f32,
paint_extent: f32,
positioning_containing_block_id: Option<InlinePositioningContainingBlockId>,
) -> InlineBoxEdgeFragment {
InlineBoxEdgeFragment {
logical_edge: InlineLogicalEdge::Start,
physical_side: PhysicalSide::Left,
positioning_containing_block_id,
advance,
paint_extent,
}
}
#[test]
fn box_edge_line_contribution_preserves_signed_and_painted_geometry() {
assert!(!edge(0.0, 0.0, None).contributes_to_line_box());
assert!(edge(10.0, 0.0, None).contributes_to_line_box());
assert!(edge(-10.0, 0.0, None).contributes_to_line_box());
assert!(edge(0.0, 10.0, None).contributes_to_line_box());
let marker = edge(0.0, 0.0, Some(InlinePositioningContainingBlockId(1)));
assert!(marker.is_positioning_marker());
assert!(!marker.contributes_to_line_box());
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) enum InlineLogicalEdge {
Start,
End,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) enum InlineEdgeRole {
BoxEdge(InlineBoxEdgeFragment),
MetricsOnlyStrut,
TextAutospace(InlineTextBoundarySpacing),
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct InlineTextBoundarySpacing {
advance: LayoutLength,
}
impl InlineTextBoundarySpacing {
pub(in crate::layout) const fn new(advance: LayoutLength) -> Self {
Self { advance }
}
pub(in crate::layout) const fn advance(self) -> LayoutLength {
self.advance
}
}
impl InlineAtomContent {
pub(in crate::layout) fn textual_boundary_text(&self) -> Option<&str> {
match self {
Self::Ruby { base_text, .. } => Some(base_text),
Self::TextCombineUpright { composition } => {
Some(composition.source.boundary_text.as_str())
}
_ => None,
}
}
pub(in crate::layout) fn textual_boundary_style(&self) -> Option<&ComputedStyle> {
match self {
Self::TextCombineUpright { composition } => Some(&composition.source.style),
_ => None,
}
}
pub(in crate::layout) fn ignores_boundary_letter_spacing(&self) -> bool {
matches!(self, Self::TextCombineUpright { .. })
}
pub(in crate::layout) fn is_inline_edge(&self) -> bool {
matches!(self, Self::InlineEdge(_))
}
pub(in crate::layout) fn is_box_edge(&self) -> bool {
matches!(self, Self::InlineEdge(InlineEdgeRole::BoxEdge(_)))
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) enum InlineItem {
Word(Box<InlineWord>),
Atom(Box<InlineAtom>),
StaticPositionSourceMarker(InlineStaticPositionSourceId),
Float(Box<InlineFloat>),
Break(InlineBreak),
PageScopeStart(Option<String>),
PageScopeEnd,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(in crate::layout) struct InlineBreak {
pub(in crate::layout) clear: Clear,
pub(in crate::layout) origin: InlineBreakOrigin,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub(in crate::layout) enum InlineBreakOrigin {
#[default]
Explicit,
PreservedSegment,
}
impl Default for InlineBreak {
fn default() -> Self {
Self {
clear: Clear::None,
origin: InlineBreakOrigin::Explicit,
}
}
}
impl AsRef<InlineItem> for InlineItem {
fn as_ref(&self) -> &InlineItem {
self
}
}
#[derive(Debug, Clone)]
#[allow(clippy::large_enum_variant)]
pub(in crate::layout) enum InlineLineItem {
Fragment(InlineFragment),
Atom(InlineAtom),
Float(InlineFloat),
}
impl AsRef<InlineLineItem> for InlineLineItem {
fn as_ref(&self) -> &InlineLineItem {
self
}
}
#[derive(Debug, Clone)]
pub(in crate::layout) struct CommittedInlineFloat {
pub(in crate::layout) marker: (usize, usize),
pub(in crate::layout) selected_row: usize,
pub(in crate::layout) replay: InlineFloatReplayMetadata,
pub(in crate::layout) exclusion: FloatShape,
}
#[derive(Debug, Clone, Copy)]
pub(in crate::layout) struct InlineFloatReplayMetadata {
pub(in crate::layout) source_range_start: (usize, usize),
pub(in crate::layout) source_range_end: (usize, usize),
pub(in crate::layout) physical_row: usize,
pub(in crate::layout) physical_block_offset: f32,
pub(in crate::layout) used_block_advance: f32,
}
impl CommittedInlineFloat {
pub(in crate::layout) fn is_valid(&self) -> bool {
self.marker.0 != usize::MAX
&& self.marker.1 != usize::MAX
&& self.selected_row != usize::MAX
&& self.replay.physical_row != usize::MAX
&& self.exclusion.is_css_float()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct FragmentainerSequence {
flow_axes: FlowAxes,
initial_context: PageContext,
initial_fragmentainer_count: usize,
continuation_context: PageContext,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct FragmentainerBlockInterval {
start: f32,
capacity: f32,
}
impl FragmentainerBlockInterval {
pub(in crate::layout) fn start(self) -> f32 {
self.start
}
pub(in crate::layout) fn capacity(self) -> f32 {
self.capacity
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct FragmentainerPlacement {
ordinal: usize,
flow_axes: FlowAxes,
logical_block_interval: FragmentainerBlockInterval,
content_rect: PageTopRect,
scratch_context: PageContext,
}
impl FragmentainerPlacement {
fn for_scratch_context(
ordinal: usize,
flow_axes: FlowAxes,
logical_block_interval: FragmentainerBlockInterval,
scratch_context: PageContext,
) -> Self {
Self {
ordinal,
flow_axes,
logical_block_interval,
content_rect: PageTopRect::new(
scratch_context.left(),
scratch_context.top(),
scratch_context.area_width(),
scratch_context.area_height(),
),
scratch_context,
}
}
pub(in crate::layout) fn ordinal(self) -> usize {
self.ordinal
}
pub(in crate::layout) fn flow_axes(self) -> FlowAxes {
self.flow_axes
}
pub(in crate::layout) fn content_rect(self) -> PageTopRect {
self.content_rect
}
pub(in crate::layout) fn scratch_context(self) -> PageContext {
self.scratch_context
}
pub(in crate::layout) fn logical_block_capacity(self) -> f32 {
self.logical_block_interval.capacity()
}
pub(in crate::layout) fn logical_block_start(self) -> f32 {
self.logical_block_interval.start()
}
pub(in crate::layout) fn block_start_edge(self) -> f32 {
match self.flow_axes.block_start_side() {
PhysicalSide::Top => self.content_rect.top_y(),
PhysicalSide::Bottom => self.content_rect.bottom_y(),
PhysicalSide::Left => self.content_rect.x(),
PhysicalSide::Right => self.content_rect.x() + self.content_rect.width(),
}
}
pub(in crate::layout) fn block_end_edge(self) -> f32 {
match self.flow_axes.block_start_side() {
PhysicalSide::Top => self.content_rect.bottom_y(),
PhysicalSide::Bottom => self.content_rect.top_y(),
PhysicalSide::Left => self.content_rect.x() + self.content_rect.width(),
PhysicalSide::Right => self.content_rect.x(),
}
}
}
impl FragmentainerSequence {
pub(in crate::layout) fn new(
flow_axes: FlowAxes,
initial_context: PageContext,
initial_fragmentainer_count: usize,
continuation_context: PageContext,
) -> Self {
Self {
flow_axes,
initial_context,
initial_fragmentainer_count,
continuation_context,
}
}
pub(in crate::layout) fn context_for_fragmentainer(self, index: usize) -> PageContext {
self.placement_for_fragmentainer(index).scratch_context()
}
pub(in crate::layout) fn placement_for_fragmentainer(
self,
index: usize,
) -> FragmentainerPlacement {
let (context, interval) = self.fragmentainer_context_and_interval(index);
FragmentainerPlacement::for_scratch_context(index, self.flow_axes, interval, context)
}
pub(in crate::layout) fn placement_for_logical_block_position(
self,
position: f32,
) -> FragmentainerPlacement {
let position = position.max(0.0);
let first = self
.initial_context
.logical_block_size(self.flow_axes.writing_mode())
.max(0.0);
let initial_span = first * self.initial_fragmentainer_count as f32;
let index = if first > 0.01 && position < initial_span {
(position / first).floor() as usize
} else {
let continuation = self
.continuation_context
.logical_block_size(self.flow_axes.writing_mode())
.max(0.0);
if continuation <= 0.01 {
self.initial_fragmentainer_count
} else {
self.initial_fragmentainer_count
+ ((position - initial_span).max(0.0) / continuation).floor() as usize
}
};
self.placement_for_fragmentainer(index)
}
pub(in crate::layout) fn placement_at_destination(
self,
index: usize,
content_rect: PageTopRect,
) -> FragmentainerPlacement {
let mut placement = self.placement_for_fragmentainer(index);
placement.content_rect = content_rect;
placement
}
pub(in crate::layout) fn current_placement(
self,
completed_fragmentainers: usize,
) -> FragmentainerPlacement {
self.placement_for_fragmentainer(completed_fragmentainers)
}
pub(in crate::layout) fn continuation_context(self) -> PageContext {
self.continuation_context
}
fn fragmentainer_context_and_interval(
self,
index: usize,
) -> (PageContext, FragmentainerBlockInterval) {
let first_capacity = self
.initial_context
.logical_block_size(self.flow_axes.writing_mode())
.max(0.0);
let continuation_capacity = self
.continuation_context
.logical_block_size(self.flow_axes.writing_mode())
.max(0.0);
let initial_count = self.initial_fragmentainer_count;
let (context, start, capacity) = if index < initial_count {
(
self.initial_context,
index as f32 * first_capacity,
first_capacity,
)
} else {
(
self.continuation_context,
initial_count as f32 * first_capacity
+ (index - initial_count) as f32 * continuation_capacity,
continuation_capacity,
)
};
(context, FragmentainerBlockInterval { start, capacity })
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct FragmentainerOverride {
pub(in crate::layout) kind: FragmentainerKind,
pub(in crate::layout) sequence: FragmentainerSequence,
pub(in crate::layout) relax_widows_orphans: bool,
}
impl FragmentainerOverride {
pub(in crate::layout) fn context_for_fragmentainer(self, index: usize) -> PageContext {
self.sequence.context_for_fragmentainer(index)
}
pub(in crate::layout) fn placement_for_fragmentainer(
self,
index: usize,
) -> FragmentainerPlacement {
self.sequence.placement_for_fragmentainer(index)
}
pub(in crate::layout) fn continuation_context(self) -> PageContext {
self.sequence.continuation_context()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(in crate::layout) struct MulticolColumnContainingBlock {
pub(in crate::layout) inline_size: LogicalInlineContentSize,
pub(in crate::layout) content_left: f32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(in crate::layout) struct AnchorText {
pub(in crate::layout) content: String,
pub(in crate::layout) before: String,
pub(in crate::layout) after: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(in crate::layout) struct TargetAnchor {
pub(in crate::layout) page_index: usize,
pub(in crate::layout) text: AnchorText,
pub(in crate::layout) counters: HashMap<String, Vec<i32>>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(in crate::layout) struct TargetReferenceSnapshot {
pub(in crate::layout) anchors: HashMap<String, TargetAnchor>,
pub(in crate::layout) total_pages: usize,
}
#[cfg(test)]
mod atomic_inline_capture_frame_tests {
use super::*;
#[test]
fn replay_origin_invariant_allows_f32_subtract_add_rounding() {
let captured = PaintPoint::new(20.0, 20.0);
let expected = PaintPoint::new(20.0, 39.999_996);
let replayed = PaintTranslation::new(expected.x - captured.x, expected.y - captured.y)
.transform_point(captured);
assert!(replayed_origin_matches_border_box(
replayed, expected, captured
));
}
#[test]
fn replay_origin_invariant_rejects_meaningful_coordinate_errors() {
assert!(!replayed_origin_matches_border_box(
PaintPoint::new(20.0, 40.01),
PaintPoint::new(20.0, 40.0),
PaintPoint::new(20.0, 20.0),
));
}
#[test]
fn border_box_capture_retains_the_scratch_border_origin() {
let frame = AtomicInlineCaptureFrame::for_scratch_border_box(PaintPoint::new(12.0, 34.0));
assert_eq!(
frame.scratch_border_box_origin.0,
PaintPoint::new(12.0, 34.0)
);
}
#[test]
fn replay_translation_maps_the_scratch_border_box_to_the_final_border_box() {
let frame = AtomicInlineCaptureFrame::for_scratch_border_box(PaintPoint::new(12.0, 34.0));
let translation = frame
.replay_coordinates()
.replay_translation(PhysicalInlineRect::new(InlineRect::new(
InlinePoint::new(20.0, 30.0),
InlineSize::new(10.0, 8.0),
)));
assert_eq!(
translation.transform_point(PaintPoint::new(12.0, 34.0)),
PaintPoint::new(20.0, 30.0),
);
}
}
#[cfg(test)]
mod fragmentainer_sequence_tests {
use super::*;
#[test]
fn placement_retains_ordinal_axes_and_scratch_content_geometry() {
let options = RenderOptions::default();
let context = PageContext::from_options(&options);
let sequence = FragmentainerSequence::new(
FlowAxes::new(WritingMode::VerticalRl, Direction::Rtl),
context,
1,
context,
);
let placement = sequence.placement_for_fragmentainer(2);
assert_eq!(placement.ordinal(), 2);
assert_eq!(
placement.flow_axes().writing_mode(),
WritingMode::VerticalRl
);
assert_eq!(placement.scratch_context(), context);
assert_eq!(placement.content_rect().x(), context.left());
assert_eq!(placement.content_rect().top_y(), context.top());
assert_eq!(
placement.logical_block_capacity(),
context.logical_block_size(WritingMode::VerticalRl),
);
assert_eq!(
placement.logical_block_interval.start,
2.0 * context.logical_block_size(WritingMode::VerticalRl),
);
}
#[test]
fn destination_placement_projects_block_edges_from_outer_axes() {
let context = PageContext::from_options(&RenderOptions::default());
let rect = PageTopRect::new(20.0, 100.0, 30.0, 40.0);
let lr = FragmentainerSequence::new(
FlowAxes::new(WritingMode::VerticalLr, Direction::Rtl),
context,
1,
context,
)
.placement_at_destination(3, rect);
assert_eq!(lr.block_start_edge(), 20.0);
assert_eq!(lr.block_end_edge(), 50.0);
let rl = FragmentainerSequence::new(
FlowAxes::new(WritingMode::VerticalRl, Direction::Rtl),
context,
1,
context,
)
.placement_at_destination(3, rect);
assert_eq!(rl.block_start_edge(), 50.0);
assert_eq!(rl.block_end_edge(), 20.0);
}
#[test]
fn first_fragment_variation_precedes_the_continuation_intervals() {
let base = PageContext::from_options(&RenderOptions::default());
let initial = PageContext {
margins: PageMargins::from_points(
0.0,
base.size.width() - 40.0,
base.size.height() - 150.0,
0.0,
),
..base
};
let continuation = PageContext {
margins: PageMargins::from_points(
0.0,
base.size.width() - 30.0,
base.size.height() - 150.0,
0.0,
),
..base
};
let sequence = FragmentainerSequence::new(
FlowAxes::new(WritingMode::VerticalRl, Direction::Rtl),
initial,
1,
continuation,
);
let first = sequence.placement_for_fragmentainer(0);
let second = sequence.placement_for_fragmentainer(1);
let third = sequence.placement_for_fragmentainer(2);
assert_eq!(first.logical_block_capacity(), 40.0);
assert_eq!(second.logical_block_capacity(), 30.0);
assert_eq!(second.logical_block_interval.start, 40.0);
assert_eq!(third.logical_block_interval.start, 70.0);
}
}