Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

layout: make padding and border use Au in pbm (#31289)

Browse source 
* use au for padding and border in pbm

* review fix
This commit is contained in:
atbrakhi 2024-02-12 23:49:50 +01:00 • committed by GitHub
parent f25fe3539a
commit 8ba251c95f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 168 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

13
components/layout_2020/flexbox/layout.rs
View file

@ -517,7 +517,10 @@ impl<'a> FlexItem<'a> {
let padding = flex_context.sides_to_flex_relative(pbm.padding); let padding = flex_context.sides_to_flex_relative(pbm.padding);
let border = flex_context.sides_to_flex_relative(pbm.border); let border = flex_context.sides_to_flex_relative(pbm.border);
let padding_border = padding.sum_by_axis() + border.sum_by_axis(); let padding_border = padding.sum_by_axis() + border.sum_by_axis();
let pbm_auto_is_zero = padding_border + margin_auto_is_zero.sum_by_axis(); let pbm_auto_is_zero = FlexRelativeVec2 {
main: padding_border.main.into(),
cross: padding_border.cross.into(),
} + margin_auto_is_zero.sum_by_axis();
let align_self = flex_context.align_for(&box_.style().clone_align_self()); let align_self = flex_context.align_for(&box_.style().clone_align_self());
@ -540,8 +543,8 @@ impl<'a> FlexItem<'a> {
content_box_size, content_box_size,
content_min_size, content_min_size,
content_max_size, content_max_size,
padding: padding.map(|t| (*t).into()), padding,
border: border.map(|t| (*t).into()), border,
margin, margin,
pbm_auto_is_zero, pbm_auto_is_zero,
flex_base_size, flex_base_size,
@ -557,7 +560,7 @@ fn flex_base_size(
flex_item: &mut IndependentFormattingContext, flex_item: &mut IndependentFormattingContext,
cross_axis_is_item_block_axis: bool, cross_axis_is_item_block_axis: bool,
content_box_size: FlexRelativeVec2<LengthOrAuto>, content_box_size: FlexRelativeVec2<LengthOrAuto>,
padding_border_sums: FlexRelativeVec2<Length>, padding_border_sums: FlexRelativeVec2<Au>,
) -> Length { ) -> Length {
let used_flex_basis = match &flex_item.style().get_position().flex_basis { let used_flex_basis = match &flex_item.style().get_position().flex_basis {
FlexBasis::Content => FlexBasis::Content, FlexBasis::Content => FlexBasis::Content,
@ -568,7 +571,7 @@ fn flex_base_size(
BoxSizing::BorderBox => { BoxSizing::BorderBox => {
// This may make `length` negative, // This may make `length` negative,
// but it will be clamped in the hypothetical main size // but it will be clamped in the hypothetical main size
length - padding_border_sums.main length - padding_border_sums.main.into()
}, },
} }
}; };

8
components/layout_2020/flow/float.rs
View file

@ -900,7 +900,7 @@ impl FloatBox {
// or non-replaced. // or non-replaced.
let pbm = style.padding_border_margin(containing_block); let pbm = style.padding_border_margin(containing_block);
let margin = pbm.margin.auto_is(Length::zero); let margin = pbm.margin.auto_is(Length::zero);
let pbm_sums = &(&pbm.padding + &pbm.border) + &margin; let pbm_sums = &(&pbm.padding + &pbm.border) + &margin.clone().into();
let (content_size, children); let (content_size, children);
match self.contents { match self.contents {
@ -918,7 +918,7 @@ impl FloatBox {
let tentative_inline_size = box_size.inline.auto_is(|| { let tentative_inline_size = box_size.inline.auto_is(|| {
let available_size = let available_size =
containing_block.inline_size - pbm_sums.inline_sum(); containing_block.inline_size - pbm_sums.inline_sum().into();
non_replaced non_replaced
.inline_content_sizes(layout_context) .inline_content_sizes(layout_context)
.shrink_to_fit(available_size.into()) .shrink_to_fit(available_size.into())
@ -976,8 +976,8 @@ impl FloatBox {
style.clone(), style.clone(),
children, children,
content_rect, content_rect,
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
// Clearance is handled internally by the float placement logic, so there's no need // Clearance is handled internally by the float placement logic, so there's no need
// to store it explicitly in the fragment. // to store it explicitly in the fragment.

50
components/layout_2020/flow/inline.rs
View file

@ -648,13 +648,14 @@ impl<'a, 'b> InlineFormattingContextState<'a, 'b> {
); );
if inline_box.is_first_fragment { if inline_box.is_first_fragment {
self.current_line.inline_position += inline_box_state.pbm.padding.inline_start + self.current_line.inline_position += Length::from(
inline_box_state.pbm.border.inline_start + inline_box_state.pbm.padding.inline_start +
inline_box_state inline_box_state.pbm.border.inline_start,
.pbm ) + inline_box_state
.margin .pbm
.inline_start .margin
.auto_is(Length::zero); .inline_start
.auto_is(Length::zero)
} }
let line_item = inline_box_state let line_item = inline_box_state
@ -686,10 +687,10 @@ impl<'a, 'b> InlineFormattingContextState<'a, 'b> {
} }
if inline_box_state.is_last_fragment { if inline_box_state.is_last_fragment {
let pbm_end = inline_box_state.pbm.padding.inline_end + let pbm_end = Length::from(
inline_box_state.pbm.border.inline_end + inline_box_state.pbm.padding.inline_end + inline_box_state.pbm.border.inline_end,
inline_box_state.pbm.margin.inline_end.auto_is(Length::zero); ) + inline_box_state.pbm.margin.inline_end.auto_is(Length::zero);
self.current_line_segment.inline_size += pbm_end; self.current_line_segment.inline_size += pbm_end.into();
} }
} }
@ -1819,7 +1820,7 @@ impl IndependentFormattingContext {
let style = self.style(); let style = self.style();
let pbm = style.padding_border_margin(ifc.containing_block); let pbm = style.padding_border_margin(ifc.containing_block);
let margin = pbm.margin.auto_is(Length::zero); let margin = pbm.margin.auto_is(Length::zero);
let pbm_sums = &(&pbm.padding + &pbm.border) + &margin; let pbm_sums = &(&pbm.padding + &pbm.border) + &margin.clone().into();
let mut child_positioning_context = None; let mut child_positioning_context = None;
// We need to know the inline size of the atomic before deciding whether to do the line break. // We need to know the inline size of the atomic before deciding whether to do the line break.
@ -1836,16 +1837,16 @@ impl IndependentFormattingContext {
.make_fragments(&replaced.style, size.clone()); .make_fragments(&replaced.style, size.clone());
let content_rect = LogicalRect { let content_rect = LogicalRect {
start_corner: pbm_sums.start_offset(), start_corner: pbm_sums.start_offset(),
size: size.into(), size,
}; };
BoxFragment::new( BoxFragment::new(
replaced.base_fragment_info, replaced.base_fragment_info,
replaced.style.clone(), replaced.style.clone(),
fragments, fragments,
content_rect, content_rect.into(),
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
None, /* clearance */ None, /* clearance */
CollapsedBlockMargins::zero(), CollapsedBlockMargins::zero(),
@ -1865,7 +1866,8 @@ impl IndependentFormattingContext {
// https://drafts.csswg.org/css2/visudet.html#inlineblock-width // https://drafts.csswg.org/css2/visudet.html#inlineblock-width
let tentative_inline_size = box_size.inline.auto_is(|| { let tentative_inline_size = box_size.inline.auto_is(|| {
let available_size = ifc.containing_block.inline_size - pbm_sums.inline_sum(); let available_size =
ifc.containing_block.inline_size - pbm_sums.inline_sum().into();
non_replaced non_replaced
.inline_content_sizes(layout_context) .inline_content_sizes(layout_context)
.shrink_to_fit(available_size.into()) .shrink_to_fit(available_size.into())
@ -1915,8 +1917,8 @@ impl IndependentFormattingContext {
let content_rect = LogicalRect { let content_rect = LogicalRect {
start_corner: pbm_sums.start_offset(), start_corner: pbm_sums.start_offset(),
size: LogicalVec2 { size: LogicalVec2 {
block: block_size, block: block_size.into(),
inline: inline_size, inline: inline_size.into(),
}, },
}; };
@ -1924,9 +1926,9 @@ impl IndependentFormattingContext {
non_replaced.base_fragment_info, non_replaced.base_fragment_info,
non_replaced.style.clone(), non_replaced.style.clone(),
independent_layout.fragments, independent_layout.fragments,
content_rect, content_rect.into(),
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
None, None,
CollapsedBlockMargins::zero(), CollapsedBlockMargins::zero(),
@ -1943,11 +1945,11 @@ impl IndependentFormattingContext {
ifc.process_soft_wrap_opportunity(); ifc.process_soft_wrap_opportunity();
} }
let size = &pbm_sums.sum() + &fragment.content_rect.size; let size = &pbm_sums.sum().into() + &fragment.content_rect.size;
let baseline_offset = fragment let baseline_offset = fragment
.baselines .baselines
.last .last
.map(|baseline| Au::from(pbm_sums.block_start) + baseline) .map(|baseline| pbm_sums.block_start + baseline)
.unwrap_or(size.block.into()); .unwrap_or(size.block.into());
let (block_sizes, baseline_offset_in_parent) = let (block_sizes, baseline_offset_in_parent) =

30
components/layout_2020/flow/line.rs
View file

@ -298,12 +298,17 @@ impl InlineBoxLineItem {
let mut margin = self.pbm.margin.auto_is(Length::zero); let mut margin = self.pbm.margin.auto_is(Length::zero);
if !self.is_first_fragment { if !self.is_first_fragment {
padding.inline_start = Length::zero(); padding.inline_start = Au::zero();
border.inline_start = Length::zero(); border.inline_start = Au::zero();
margin.inline_start = Length::zero(); margin.inline_start = Length::zero();
} }
let pbm_sums = &(&padding + &border) + &margin; if !self.is_last_fragment_of_ib_split {
state.inline_position += pbm_sums.inline_start; padding.inline_end = Au::zero();
border.inline_end = Au::zero();
margin.inline_end = Length::zero();
}
let pbm_sums = &(&padding + &border) + &margin.map(|t| (*t).into());
state.inline_position += pbm_sums.inline_start.into();
let space_above_baseline = self.calculate_space_above_baseline(); let space_above_baseline = self.calculate_space_above_baseline();
let block_start_offset = self.calculate_block_start(state, space_above_baseline); let block_start_offset = self.calculate_block_start(state, space_above_baseline);
@ -336,14 +341,14 @@ impl InlineBoxLineItem {
// potential block-in-inline split and this line included the actual end of this // potential block-in-inline split and this line included the actual end of this
// fragment (it doesn't continue on the next line). // fragment (it doesn't continue on the next line).
if !self.is_last_fragment_of_ib_split || !saw_end { if !self.is_last_fragment_of_ib_split || !saw_end {
padding.inline_end = Length::zero(); padding.inline_end = Au::zero();
border.inline_end = Length::zero(); border.inline_end = Au::zero();
margin.inline_end = Length::zero(); margin.inline_end = Length::zero();
} }
let pbm_sums = &(&padding + &border) + &margin; let pbm_sums = &(&padding + &border) + &margin.clone().into();
// If the inline box didn't have any content at all, don't add a Fragment for it. // If the inline box didn't have any content at all, don't add a Fragment for it.
let box_has_padding_border_or_margin = pbm_sums.inline_sum() > Length::zero(); let box_has_padding_border_or_margin = pbm_sums.inline_sum() > Au::zero();
let box_had_absolutes = let box_had_absolutes =
original_nested_positioning_context_length != nested_state.positioning_context.len(); original_nested_positioning_context_length != nested_state.positioning_context.len();
if !self.is_first_fragment && if !self.is_first_fragment &&
@ -374,22 +379,19 @@ impl InlineBoxLineItem {
content_rect.start_corner += &relative_adjustement(&style, state.ifc_containing_block); content_rect.start_corner += &relative_adjustement(&style, state.ifc_containing_block);
} }
// NB: There is no need to set a baseline offset for this BoxFragment, because the
// baselines of this InlineFormattingContext is what will propagate to `display:
// inline-block` ancestors.
let mut fragment = BoxFragment::new( let mut fragment = BoxFragment::new(
self.base_fragment_info, self.base_fragment_info,
self.style.clone(), self.style.clone(),
fragments, fragments,
content_rect, content_rect,
padding, padding.into(),
border, border.into(),
margin, margin,
None, /* clearance */ None, /* clearance */
CollapsedBlockMargins::zero(), CollapsedBlockMargins::zero(),
); );
state.inline_position = nested_state.inline_position + pbm_sums.inline_end; state.inline_position = nested_state.inline_position + pbm_sums.inline_end.into();
if let Some(mut positioning_context) = positioning_context.take() { if let Some(mut positioning_context) = positioning_context.take() {
assert!(original_nested_positioning_context_length == PositioningContextLength::zero()); assert!(original_nested_positioning_context_length == PositioningContextLength::zero());

119
components/layout_2020/flow/mod.rs
View file

@ -126,7 +126,7 @@ impl BlockLevelBox {
_ => return false, _ => return false,
}; };
if pbm.padding.block_start != Length::zero() || pbm.border.block_start != Length::zero() { if pbm.padding.block_start != Au::zero() || pbm.border.block_start != Au::zero() {
return false; return false;
} }
@ -142,7 +142,7 @@ impl BlockLevelBox {
let margin_inline_start = pbm.margin.inline_start.auto_is(Length::zero); let margin_inline_start = pbm.margin.inline_start.auto_is(Length::zero);
let margin_inline_end = pbm.margin.inline_end.auto_is(Length::zero); let margin_inline_end = pbm.margin.inline_end.auto_is(Length::zero);
containing_block.inline_size - containing_block.inline_size -
pbm.padding_border_sums.inline - pbm.padding_border_sums.inline.into() -
margin_inline_start - margin_inline_start -
margin_inline_end margin_inline_end
}) })
@ -169,10 +169,7 @@ impl BlockLevelBox {
style.content_block_size().is_definitely_zero() || style.content_block_size().is_auto(); style.content_block_size().is_definitely_zero() || style.content_block_size().is_auto();
let min_block_size_zero = let min_block_size_zero =
style.min_block_size().is_definitely_zero() || style.min_block_size().is_auto(); style.min_block_size().is_definitely_zero() || style.min_block_size().is_auto();
if !min_block_size_zero || if !min_block_size_zero || !block_size_zero || pbm.padding_border_sums.block != Au::zero() {
!block_size_zero ||
pbm.padding_border_sums.block != Length::zero()
{
return false; return false;
} }
@ -637,9 +634,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
let computed_block_size = style.content_block_size(); let computed_block_size = style.content_block_size();
let start_margin_can_collapse_with_children = let start_margin_can_collapse_with_children =
pbm.padding.block_start == Length::zero() && pbm.border.block_start == Length::zero(); pbm.padding.block_start == Au::zero() && pbm.border.block_start == Au::zero();
let end_margin_can_collapse_with_children = pbm.padding.block_end == Length::zero() && let end_margin_can_collapse_with_children = pbm.padding.block_end == Au::zero() &&
pbm.border.block_end == Length::zero() && pbm.border.block_end == Au::zero() &&
computed_block_size.is_auto(); computed_block_size.is_auto();
let mut clearance = None; let mut clearance = None;
@ -688,10 +685,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
// NB: This will be a no-op if we're collapsing margins with our children since that // NB: This will be a no-op if we're collapsing margins with our children since that
// can only happen if we have no block-start padding and border. // can only happen if we have no block-start padding and border.
sequential_layout_state.advance_block_position( sequential_layout_state.advance_block_position(
(pbm.padding.block_start + pbm.padding.block_start +
pbm.border.block_start + pbm.border.block_start +
clearance.unwrap_or_else(Au::zero).into()) clearance.unwrap_or_else(Au::zero),
.into(),
); );
// We are about to lay out children. Update the offset between the block formatting // We are about to lay out children. Update the offset between the block formatting
@ -703,8 +699,8 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
.floats .floats
.containing_block_info .containing_block_info
.inline_start + .inline_start +
pbm.padding.inline_start.into() + pbm.padding.inline_start +
pbm.border.inline_start.into() + pbm.border.inline_start +
margin.inline_start.into(); margin.inline_start.into();
let new_cb_offsets = ContainingBlockPositionInfo { let new_cb_offsets = ContainingBlockPositionInfo {
block_start: sequential_layout_state.bfc_relative_block_position, block_start: sequential_layout_state.bfc_relative_block_position,
@ -754,7 +750,7 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
let computed_min_block_size = style.min_block_size(); let computed_min_block_size = style.min_block_size();
block_margins_collapsed_with_children.collapsed_through = collapsible_margins_in_children block_margins_collapsed_with_children.collapsed_through = collapsible_margins_in_children
.collapsed_through && .collapsed_through &&
pbm.padding_border_sums.block == Length::zero() && pbm.padding_border_sums.block == Au::zero() &&
(computed_block_size.is_definitely_zero() || computed_block_size.is_auto()) && (computed_block_size.is_definitely_zero() || computed_block_size.is_auto()) &&
(computed_min_block_size.is_definitely_zero() || computed_min_block_size.is_auto()); (computed_min_block_size.is_definitely_zero() || computed_min_block_size.is_auto());
@ -778,7 +774,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
// the block direction. In that case, the ceiling for floats is effectively raised // the block direction. In that case, the ceiling for floats is effectively raised
// as long as no floats in the overflowing content lowered it. // as long as no floats in the overflowing content lowered it.
sequential_layout_state.advance_block_position( sequential_layout_state.advance_block_position(
(block_size - content_block_size + pbm.padding.block_end + pbm.border.block_end).into(), Au::from(block_size - content_block_size) +
pbm.padding.block_end +
pbm.border.block_end,
); );
if !end_margin_can_collapse_with_children { if !end_margin_can_collapse_with_children {
@ -791,12 +789,12 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
start_corner: LogicalVec2 { start_corner: LogicalVec2 {
block: (pbm.padding.block_start + block: (pbm.padding.block_start +
pbm.border.block_start + pbm.border.block_start +
clearance.unwrap_or_else(Au::zero).into()), clearance.unwrap_or_else(Au::zero)),
inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start.into(),
}, },
size: LogicalVec2 { size: LogicalVec2 {
block: block_size, block: block_size.into(),
inline: containing_block_for_children.inline_size, inline: containing_block_for_children.inline_size.into(),
}, },
}; };
@ -804,9 +802,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context(
base_fragment_info, base_fragment_info,
style.clone(), style.clone(),
flow_layout.fragments, flow_layout.fragments,
content_rect, content_rect.into(),
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
clearance.map(|t| t.into()), clearance.map(|t| t.into()),
block_margins_collapsed_with_children, block_margins_collapsed_with_children,
@ -866,22 +864,25 @@ impl NonReplacedFormattingContext {
let content_rect = LogicalRect { let content_rect = LogicalRect {
start_corner: LogicalVec2 { start_corner: LogicalVec2 {
block: pbm.padding.block_start + pbm.border.block_start, block: pbm.padding.block_start + pbm.border.block_start,
inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, inline: pbm.padding.inline_start +
pbm.border.inline_start +
margin.inline_start.into(),
}, },
size: LogicalVec2 { size: LogicalVec2 {
block: block_size, block: block_size.into(),
inline: containing_block_for_children.inline_size, inline: containing_block_for_children.inline_size.into(),
}, },
}; };
let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin);
BoxFragment::new( BoxFragment::new(
self.base_fragment_info, self.base_fragment_info,
self.style.clone(), self.style.clone(),
layout.fragments, layout.fragments,
content_rect, content_rect.into(),
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
None, /* clearance */ None, /* clearance */
block_margins_collapsed_with_children, block_margins_collapsed_with_children,
@ -961,7 +962,7 @@ impl NonReplacedFormattingContext {
containing_block, containing_block,
&collapsed_margin_block_start, &collapsed_margin_block_start,
&pbm, &pbm,
&content_size + &pbm.padding_border_sums, &content_size + &pbm.padding_border_sums.clone().into(),
&self.style, &self.style,
); );
} else { } else {
@ -980,11 +981,13 @@ impl NonReplacedFormattingContext {
let minimum_size_of_block = &LogicalVec2 { let minimum_size_of_block = &LogicalVec2 {
inline: min_box_size.inline, inline: min_box_size.inline,
block: block_size.auto_is(|| min_box_size.block), block: block_size.auto_is(|| min_box_size.block),
} + &pbm.padding_border_sums; }
.into() +
&pbm.padding_border_sums;
let mut placement = PlacementAmongFloats::new( let mut placement = PlacementAmongFloats::new(
&sequential_layout_state.floats, &sequential_layout_state.floats,
ceiling, ceiling,
minimum_size_of_block.into(), minimum_size_of_block,
&pbm, &pbm,
); );
let mut placement_rect; let mut placement_rect;
@ -992,10 +995,9 @@ impl NonReplacedFormattingContext {
loop { loop {
// First try to place the block using the minimum size as the object size. // First try to place the block using the minimum size as the object size.
placement_rect = placement.place(); placement_rect = placement.place();
let proposed_inline_size = Length::from( let proposed_inline_size =
placement_rect.size.inline - pbm.padding_border_sums.inline.into(), Length::from(placement_rect.size.inline - pbm.padding_border_sums.inline)
) .clamp_between_extremums(min_box_size.inline, max_box_size.inline);
.clamp_between_extremums(min_box_size.inline, max_box_size.inline);
// Now lay out the block using the inline size we calculated from the placement. // Now lay out the block using the inline size we calculated from the placement.
// Later we'll check to see if the resulting block size is compatible with the // Later we'll check to see if the resulting block size is compatible with the
@ -1027,7 +1029,7 @@ impl NonReplacedFormattingContext {
// size of auto. Try to fit it into our precalculated placement among the // size of auto. Try to fit it into our precalculated placement among the
// floats. If it fits, then we can stop trying layout candidates. // floats. If it fits, then we can stop trying layout candidates.
if placement.try_to_expand_for_auto_block_size( if placement.try_to_expand_for_auto_block_size(
(content_size.block + pbm.padding_border_sums.block).into(), Au::from(content_size.block) + pbm.padding_border_sums.block,
&placement_rect.size, &placement_rect.size,
) { ) {
break; break;
@ -1057,7 +1059,7 @@ impl NonReplacedFormattingContext {
sequential_layout_state, sequential_layout_state,
containing_block, containing_block,
&pbm, &pbm,
content_size.inline + pbm.padding_border_sums.inline, content_size.inline + pbm.padding_border_sums.inline.into(),
placement_rect.into(), placement_rect.into(),
); );
} }
@ -1079,10 +1081,8 @@ impl NonReplacedFormattingContext {
// Margins can never collapse into independent formatting contexts. // Margins can never collapse into independent formatting contexts.
sequential_layout_state.collapse_margins(); sequential_layout_state.collapse_margins();
sequential_layout_state.advance_block_position( sequential_layout_state.advance_block_position(
(pbm.padding_border_sums.block + pbm.padding_border_sums.block +
content_size.block + (content_size.block + clearance.unwrap_or_else(Length::zero)).into(),
clearance.unwrap_or_else(Length::zero))
.into(),
); );
sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end)); sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end));
@ -1090,19 +1090,22 @@ impl NonReplacedFormattingContext {
start_corner: LogicalVec2 { start_corner: LogicalVec2 {
block: pbm.padding.block_start + block: pbm.padding.block_start +
pbm.border.block_start + pbm.border.block_start +
clearance.unwrap_or_else(Length::zero), clearance.unwrap_or_else(Length::zero).into(),
inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, inline: pbm.padding.inline_start +
pbm.border.inline_start +
margin.inline_start.into(),
}, },
size: content_size, size: content_size.into(),
}; };
let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin);
BoxFragment::new( BoxFragment::new(
self.base_fragment_info, self.base_fragment_info,
self.style.clone(), self.style.clone(),
layout.fragments, layout.fragments,
content_rect, content_rect.into(),
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
clearance, clearance,
block_margins_collapsed_with_children, block_margins_collapsed_with_children,
@ -1142,7 +1145,7 @@ fn layout_in_flow_replaced_block_level<'a>(
// than defined by section 10.3.3. CSS 2 does not define when a UA may put said // than defined by section 10.3.3. CSS 2 does not define when a UA may put said
// element next to the float or by how much said element may become narrower." // element next to the float or by how much said element may become narrower."
let collapsed_margin_block_start = CollapsedMargin::new(margin_block_start); let collapsed_margin_block_start = CollapsedMargin::new(margin_block_start);
let size = &content_size + &pbm.padding_border_sums.clone().into(); let size = &content_size + &pbm.padding_border_sums.clone();
(clearance, (margin_inline_start, margin_inline_end)) = (clearance, (margin_inline_start, margin_inline_end)) =
solve_clearance_and_inline_margins_avoiding_floats( solve_clearance_and_inline_margins_avoiding_floats(
sequential_layout_state, sequential_layout_state,
@ -1184,22 +1187,23 @@ fn layout_in_flow_replaced_block_level<'a>(
let start_corner = LogicalVec2 { let start_corner = LogicalVec2 {
block: pbm.padding.block_start + block: pbm.padding.block_start +
pbm.border.block_start + pbm.border.block_start +
clearance.unwrap_or_else(Length::zero), clearance.unwrap_or_else(Length::zero).into(),
inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start.into(),
}; };
let content_rect = LogicalRect { let content_rect = LogicalRect {
start_corner, start_corner,
size: content_size.into(), size: content_size,
}; };
let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin);
BoxFragment::new( BoxFragment::new(
base_fragment_info, base_fragment_info,
style.clone(), style.clone(),
fragments, fragments,
content_rect, content_rect.into(),
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
clearance, clearance,
block_margins_collapsed_with_children, block_margins_collapsed_with_children,
@ -1238,7 +1242,7 @@ fn solve_containing_block_padding_border_and_margin_for_in_flow_box<'a>(
let margin_inline_start = pbm.margin.inline_start.auto_is(Length::zero); let margin_inline_start = pbm.margin.inline_start.auto_is(Length::zero);
let margin_inline_end = pbm.margin.inline_end.auto_is(Length::zero); let margin_inline_end = pbm.margin.inline_end.auto_is(Length::zero);
containing_block.inline_size - containing_block.inline_size -
pbm.padding_border_sums.inline - pbm.padding_border_sums.inline.into() -
margin_inline_start - margin_inline_start -
margin_inline_end margin_inline_end
}) })
@ -1348,7 +1352,8 @@ fn solve_inline_margins_for_in_flow_block_level(
pbm: &PaddingBorderMargin, pbm: &PaddingBorderMargin,
inline_size: Length, inline_size: Length,
) -> (Length, Length) { ) -> (Length, Length) {
let free_space = containing_block.inline_size - pbm.padding_border_sums.inline - inline_size; let free_space =
containing_block.inline_size - pbm.padding_border_sums.inline.into() - inline_size;
let margin_inline_start = match (pbm.margin.inline_start, pbm.margin.inline_end) { let margin_inline_start = match (pbm.margin.inline_start, pbm.margin.inline_end) {
(LengthOrAuto::Auto, LengthOrAuto::Auto) => Length::zero().max(free_space / 2.), (LengthOrAuto::Auto, LengthOrAuto::Auto) => Length::zero().max(free_space / 2.),
(LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => { (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => {

22
components/layout_2020/geom.rs
View file

@ -362,6 +362,28 @@ impl<T: Zero> LogicalSides<T> {
} }
} }
impl From<LogicalSides<CSSPixelLength>> for LogicalSides<Au> {
fn from(value: LogicalSides<CSSPixelLength>) -> Self {
LogicalSides {
inline_start: value.inline_start.into(),
inline_end: value.inline_end.into(),
block_start: value.block_start.into(),
block_end: value.block_end.into(),
}
}
}
impl From<LogicalSides<Au>> for LogicalSides<CSSPixelLength> {
fn from(value: LogicalSides<Au>) -> Self {
LogicalSides {
inline_start: value.inline_start.into(),
inline_end: value.inline_end.into(),
block_start: value.block_start.into(),
block_end: value.block_end.into(),
}
}
}
impl<T> LogicalRect<T> { impl<T> LogicalRect<T> {
pub fn max_inline_position(&self) -> T pub fn max_inline_position(&self) -> T
where where

18
components/layout_2020/positioned.rs
View file

@ -500,7 +500,7 @@ impl HoistedAbsolutelyPositionedBox {
let shared_fragment = self.fragment.borrow(); let shared_fragment = self.fragment.borrow();
let inline_axis_solver = AbsoluteAxisSolver { let inline_axis_solver = AbsoluteAxisSolver {
containing_size: cbis, containing_size: cbis,
padding_border_sum: pbm.padding_border_sums.inline, padding_border_sum: pbm.padding_border_sums.inline.into(),
computed_margin_start: pbm.margin.inline_start, computed_margin_start: pbm.margin.inline_start,
computed_margin_end: pbm.margin.inline_end, computed_margin_end: pbm.margin.inline_end,
avoid_negative_margin_start: true, avoid_negative_margin_start: true,
@ -509,7 +509,7 @@ impl HoistedAbsolutelyPositionedBox {
let block_axis_solver = AbsoluteAxisSolver { let block_axis_solver = AbsoluteAxisSolver {
containing_size: cbbs, containing_size: cbbs,
padding_border_sum: pbm.padding_border_sums.block, padding_border_sum: pbm.padding_border_sums.block.into(),
computed_margin_start: pbm.margin.block_start, computed_margin_start: pbm.margin.block_start,
computed_margin_end: pbm.margin.block_end, computed_margin_end: pbm.margin.block_end,
avoid_negative_margin_start: false, avoid_negative_margin_start: false,
@ -558,7 +558,7 @@ impl HoistedAbsolutelyPositionedBox {
}; };
let margin_sum = inline_axis.margin_start + inline_axis.margin_end; let margin_sum = inline_axis.margin_start + inline_axis.margin_end;
let available_size = let available_size =
cbis - anchor - pbm.padding_border_sums.inline - margin_sum; cbis - anchor - pbm.padding_border_sums.inline.into() - margin_sum;
non_replaced non_replaced
.inline_content_sizes(layout_context) .inline_content_sizes(layout_context)
.shrink_to_fit(available_size.into()) .shrink_to_fit(available_size.into())
@ -672,15 +672,15 @@ impl HoistedAbsolutelyPositionedBox {
let pb = &pbm.padding + &pbm.border; let pb = &pbm.padding + &pbm.border;
let inline_start = match inline_axis.anchor { let inline_start = match inline_axis.anchor {
Anchor::Start(start) => start + pb.inline_start + margin.inline_start, Anchor::Start(start) => start + pb.inline_start.into() + margin.inline_start,
Anchor::End(end) => { Anchor::End(end) => {
cbis - end - pb.inline_end - margin.inline_end - content_size.inline cbis - end - pb.inline_end.into() - margin.inline_end - content_size.inline
}, },
}; };
let block_start = match block_axis.anchor { let block_start = match block_axis.anchor {
Anchor::Start(start) => start + pb.block_start + margin.block_start, Anchor::Start(start) => start + pb.block_start.into() + margin.block_start,
Anchor::End(end) => { Anchor::End(end) => {
cbbs - end - pb.block_end - margin.block_end - content_size.block cbbs - end - pb.block_end.into() - margin.block_end - content_size.block
}, },
}; };
@ -700,8 +700,8 @@ impl HoistedAbsolutelyPositionedBox {
absolutely_positioned_box.context.style().clone(), absolutely_positioned_box.context.style().clone(),
fragments, fragments,
content_rect, content_rect,
pbm.padding, pbm.padding.into(),
pbm.border, pbm.border.into(),
margin, margin,
None, /* clearance */ None, /* clearance */
// We do not set the baseline offset, because absolutely positioned // We do not set the baseline offset, because absolutely positioned

30
components/layout_2020/style_ext.rs
View file

@ -116,12 +116,12 @@ impl DisplayLayoutInternal {
/// Percentages resolved but not `auto` margins /// Percentages resolved but not `auto` margins
#[derive(Clone)] #[derive(Clone)]
pub(crate) struct PaddingBorderMargin { pub(crate) struct PaddingBorderMargin {
pub padding: LogicalSides<Length>, pub padding: LogicalSides<Au>,
pub border: LogicalSides<Length>, pub border: LogicalSides<Au>,
pub margin: LogicalSides<LengthOrAuto>, pub margin: LogicalSides<LengthOrAuto>,
/// Pre-computed sums in each axis /// Pre-computed sums in each axis
pub padding_border_sums: LogicalVec2<Length>, pub padding_border_sums: LogicalVec2<Au>,
} }
impl PaddingBorderMargin { impl PaddingBorderMargin {
@ -288,8 +288,12 @@ impl ComputedValuesExt for ComputedValues {
BoxSizing::BorderBox => LogicalVec2 { BoxSizing::BorderBox => LogicalVec2 {
// These may be negative, but will later be clamped by `min-width`/`min-height` // These may be negative, but will later be clamped by `min-width`/`min-height`
// which is clamped to zero. // which is clamped to zero.
inline: box_size.inline.map(|i| i - pbm.padding_border_sums.inline), inline: box_size
block: box_size.block.map(|b| b - pbm.padding_border_sums.block), .inline
.map(|i| i - pbm.padding_border_sums.inline.into()),
block: box_size
.block
.map(|b| b - pbm.padding_border_sums.block.into()),
}, },
} }
} }
@ -308,10 +312,10 @@ impl ComputedValuesExt for ComputedValues {
// Clamp to zero to make sure the used size components are non-negative // Clamp to zero to make sure the used size components are non-negative
inline: min_box_size inline: min_box_size
.inline .inline
.map(|i| (i - pbm.padding_border_sums.inline).max(Length::zero())), .map(|i| (i - pbm.padding_border_sums.inline.into()).max(Length::zero())),
block: min_box_size block: min_box_size
.block .block
.map(|b| (b - pbm.padding_border_sums.block).max(Length::zero())), .map(|b| (b - pbm.padding_border_sums.block.into()).max(Length::zero())),
}, },
} }
} }
@ -332,10 +336,10 @@ impl ComputedValuesExt for ComputedValues {
LogicalVec2 { LogicalVec2 {
inline: max_box_size inline: max_box_size
.inline .inline
.map(|i| i - pbm.padding_border_sums.inline), .map(|i| i - pbm.padding_border_sums.inline.into()),
block: max_box_size block: max_box_size
.block .block
.map(|b| b - pbm.padding_border_sums.block), .map(|b| b - pbm.padding_border_sums.block.into()),
} }
}, },
} }
@ -349,11 +353,11 @@ impl ComputedValuesExt for ComputedValues {
let border = self.border_width(containing_block.style.writing_mode); let border = self.border_width(containing_block.style.writing_mode);
PaddingBorderMargin { PaddingBorderMargin {
padding_border_sums: LogicalVec2 { padding_border_sums: LogicalVec2 {
inline: padding.inline_sum() + border.inline_sum(), inline: (padding.inline_sum() + border.inline_sum()).into(),
block: padding.block_sum() + border.block_sum(), block: (padding.block_sum() + border.block_sum()).into(),
}, },
padding, padding: padding.into(),
border, border: border.into(),
margin: self margin: self
.margin(containing_block.style.writing_mode) .margin(containing_block.style.writing_mode)
.percentages_relative_to(cbis), .percentages_relative_to(cbis),

4
components/layout_2020/table/layout.rs
View file

@ -202,8 +202,8 @@ impl<'a> TableLayout<'a> {
let percentage_contribution = let percentage_contribution =
Percentage(inline_size_percent.0.min(max_inline_size_percent.0)); Percentage(inline_size_percent.0.min(max_inline_size_percent.0));
outer_min_content_width += pbm.padding_border_sums.inline.into(); outer_min_content_width += pbm.padding_border_sums.inline;
outer_max_content_width += pbm.padding_border_sums.inline.into(); outer_max_content_width += pbm.padding_border_sums.inline;
row_measures[column_index] = CellOrColumnMeasure { row_measures[column_index] = CellOrColumnMeasure {
content_sizes: ContentSizes { content_sizes: ContentSizes {
min_content: outer_min_content_width, min_content: outer_min_content_width,

2
tests/wpt/meta/html/rendering/non-replaced-elements/the-hr-element-0/width.html.ini Normal file
View file

@ -0,0 +1,2 @@
[width.html]
expected: FAIL